Vytváření "Flux": Jednoduchá flashová hra s Gravity mechanik

Czech (Čeština) translation by Jakub Dokoupil (you can also view the original English article)

V tomto kurzu já vysvětlím, hlavní kroky a pracovní postup pro vytvoření jednoduché vesmírná přežití hra, založena na gravitace mechanik, vysvětlil v předchozím tutoriálu. Tato hra je napsána v AS3 pomocí FlashDevelop.

Hrát hru

Klávesami Šipka vlevo a vpravo manévrovat vaše loď, nahoru a dolů šipkami zvýšit nebo snížit velikost magnetického pole, které produkuje a mezerníku k obrácení polarity. Bílé krystaly ke zvýšení zásoby paliva -, ale vyhnout se ty červené, Sbírejte, protože používají ji. Ne hit rock, nebo je to konec hry!

V tomto kurzu nebudeme vytvářet skutečně plné hry zobrazené výše; pak jen začnem, tím, že velmi jednoduché provedení s jednoduchou grafiku a jen jeden druh objektu. Nicméně do konce, byste měli zjistit dost, aby mohli přidat další funkce!

Hra sama o sobě je velice jednoduchý ve svém současném stavu - Podívejte se na tuto kritiku tipy, jak si můžete vzít to od jednoduché demo plnou hru!

Pojďme začít!

Vytvořit nový projekt AS3 v FlashDevelop a nastavte jeho rozměry na 550x600px.

 package 
{
  [SWF(width = "550", height = "600")]
	
	public class Main extends Sprite
	{
	
	}
}

Krok 1: Identifikace herní objekty

Existuje šest objektů v částice, které lze identifikovat hru výše:

Energie - reprezentována objektem bílý oválný tvar
Asteroidů - zastoupené objektem rockově
Energetické spotřebitel - reprezentované rudá hvězda svázán se zeleným světlem.
Hvězdy - pozadí
Rozsah indikátor - reprezentované bílý kruh
Loď - hráč objektu

Samozřejmě můžete přidat do jiného objektu, aby interaktivní hru nebo přidat novou funkci. Pro tento kurz bude prostě uděláme

Krok 2: Energetická třída

Z objektů jsme identifikovali čtyři z nich skutečně pracují stejným způsobem: tím pádem od shora dolů.

Jsou to:

Hvězdy
Přívod energie
Spotřeba energie
Planetka

V tomto kurzu budeme pouze objekty "zásobování energií", mimo výše uvedené čtyři. Tak začněme vytvořením těchto objektů a jejich upadl, náhodné reprodukující pozici a rychlost.

Začněte vytvořením energetické třídy:

	package  
	{
		import flash.display.MovieClip;
		import flash.events.Event;

		public class Energy extends MovieClip
		{
			private var rSpeed:Number = 0;
			
			public function Energy(speed:Number)
			{		
				graphics.beginFill(0x321312);
				graphics.drawCircle(0, 0 , 8);
				
				rSpeed = speed;
			}
			
			// we will call this every frame
			public function move():void
			{
				this.y += rSpeed;
				//rotation speed is linked to moving speed
				this.rotation += rSpeed / 8;
			}
		}
	}

Krok 3: GameScreen třída

Tato třída bude nakonec kontrolovat většinu aspektů naší hry, včetně hnutí hráče a herní smyčky.

Vytvořte třídu:

package  
{
	
	public class GameScreen extends MovieClip
	{

		public function GameScreen()
		{
		
		}
	}
}

To je vše, potřebujeme pro tuto chvíli.

Krok 4: Aktualizovat hlavní třída

Nyní vytvoříme instance GameScreen v rámci hlavní:

package 
{
	import flash.display.Sprite;
	import flash.events.Event;

	[SWF(width = "550", height = "600")]
	 
	public class Main extends Sprite 
	{
		private var game:GameScreen;
		
		public function Main():void 
		{
			// don't display a yellow rectangle on the screen at startup
			stage.stageFocusRect = false;
			
			game = new GameScreen();
			addChild(game);
			
			// give keyboard focus to the game screen immediately
			stage.focus = game;
		}
	}
}

Proč se obtěžovat? No tak to bude jednodušší přidat extra obrazovky později, pokud chceme (jako preloader, úvodní obrazovku, hru přes obrazovky...).

Krok 5: Zavedení správce třídy

Aby se zabránilo GameScreen třídy stává příliš velký nepořádek, budeme používat samostatné třídy spravovat každý objekt.

Každý manager třída bude obsahovat všechny funkce, které se týkají a pracovat s konkrétním objektem. Zde je třída EnergyManager:

package  
{
	import flash.display.MovieClip;
	
	public class EnergyManager
	{
		// this Vector will store all instances of the Energy class
		private var energyList:Vector.<Energy>	
		private var gameScreen:GameScreen;
		
		public function EnergyManager(gs:GameScreen) 
		{
			gameScreen = gs;
			energyList = new Vector.<Energy>;	
		}
	}
}

Všimněte si, že jsme vyžadují odkaz na GameScreen mají být předány do konstruktoru, a uložíme tento odkaz soukromé proměnné. Jsme také nastavit vektor ukládat odkazy na všechny energetické objekty.

Zatím třída obsahovat žádné další funkce; přidáme je do později.

Krok 6: Vytvoření energie

Přidejte níže uvedené funkce pro tvorbu energie, to je jen funkce; Zavoláme funkci později z GameScreen třídy:

	public function createEnergy(number:int):void	
	{
		var energy:Energy;
		for (var i:int = 0; i < number; i++) {		

			energy = new Energy(4);				
				
			gameScreen.addEnergyToScreen(energy);
				
			energyList.push(energy);				
	
			energy.x = Calculation.generateRandomValue(30, 520);		
			energy.y = Calculation.generateRandomValue( -150, -20); 
		}
	}

Vytvoření nové dodávky energie s rychlostí 4, přidat do seznamu zobrazení (přes GameScreen), přidejte jej do vektoru veškerou energii objekty, že jsme právě vytvořili a nastavte jeho pozici na náhodný bod v určitých mezích.

Calculation.generateRandomValue (#, #) je statická funkce jsme nepsal, ale tak Udělejme to teď. Vytvořit novou třídu s názvem výpočet a přidat tuto funkci:

	public static function generateRandomValue(min:Number, max:Number):Number
	{
		var randomValue:Number = min + (Math.random() * (max - min));
			
		return randomValue;
	}

Tato funkce bude generovat náhodné číslo mezi dvěma hodnotami, které jsou jí předány. Získáte další informace o jak funguje tento rychlý Tip. Vzhledem k tomu, to je statická funkce, nepotřebujeme k vytvoření instance výpočtu, aby ji volat.

Co je funkce addEnergyToScreen()? Ještě jsme nedefinovali, tak se to dělá. Přidáte do GameScreen:

		public function addEnergyToScreen(energy:Energy):void
		{
			addChild(energy);
		}

To jen přidává předaná instance energie do seznamu zobrazení. Uděláme také odpovídající funkce Odstranit objekt dané energie z obrazovky:

		public function removeEnergyFromScreen(energy:Energy):void
		{
			if (energy.parent == this)
			{
				removeChild(energy);
			}
		}

Krok 7: Vytváření energie

Nastavíme časovač, který definuje interval pro každý tření. Tento kód je ve funkci konstruktoru je GameScreen:

energyM = new EnergyManager(this);	//remember to pass a reference to the game screen
								
var spawnTimer:Timer = new Timer(3000, 0);
spawnTimer.addEventListener(TimerEvent.TIMER, spawnEnergy);
spawnTimer.start();

Takže každé tři sekundy, časovač bude volat spawnEnergy(). Pojďme napsat tuto funkci:

	private function spawnEnergy(e:TimerEvent):void
	{
		energyM.createEnergy(4);    // create 4 energies
	}

Krok 8: Vytvoření hráče

Pojďme použít jiný, větší kruh k reprezentaci hráč. Nebojte se, import obrázku namísto použití:

public function Player() 
		{
			graphics.beginFill(0x7ebff1);
			graphics.drawCircle(0, 0, 20);

Přidáte tento kód do GameScreen přidat hráče na obrazovku:

// in the variable definitions
public var player:Player;

// in the constructor function
player = new Player;
addChild(player);
player.x = 275;
player.y = 450;

Zatím bychom měli mít několik dodávek energie pádu několika sekund a hráč, která se objeví uprostřed obrazovky:

Krok 9: Přesun hráč

Existují v podstatě dva způsoby pohybu:

Použití logických hodnot (pravda/nepravda) - pravda = přesun, false = nehýbe. Po stisknutí klávesy se šipkou vpravo, hodnota pro "Posun doprava" se změní na true. V každé aktualizaci snímku "pohyblivý právo" je pravda, zvýšíme hodnotu x objektu.
Pomocí přímého aktualizovat každý snímek - při stisknutí klávesy se šipkou vpravo, objekt je řekl, aby pohyb doprava, tím, že zvyšuje jeho hodnotu x.

Druhá metoda nevede k hladké hnutí, když neustále klávesy, ale na první metoda nemá - takže jsme se použít první metodu.

Existují tři jednoduché kroky k tomu:

Vytvořte dvě proměnné typu Boolean, jeden pro pohyb doprava a jeden pro posun vlevo.
```
	private var moveRight:Boolean = false;
	private var moveLeft:Boolean = false;
```

Booleovská hodnota přepnete, když klávesy jsou stisknutí nebo uvolnění:

		addEventListener(Event.ENTER_FRAME, update);
		addEventListener(KeyboardEvent.KEY_DOWN, KeyDownHandler);
		addEventListener(KeyboardEvent.KEY_UP, KeyUpHandler);
	}
		
	private function KeyDownHandler(e:KeyboardEvent):void
	{
		if (e.keyCode == Keyboard.RIGHT) {
			moveRight = true;
		}
		if (e.keyCode == Keyboard.LEFT) {
			moveLeft = true;
		}
		if (e.keyCode == Keyboard.SPACE) {
			if (isGravityPushing == true) {
				isGravityPushing = false;
			} else  {
				isGravityPushing = true;
			}
		}
	}
		
	private function KeyUpHandler(e:KeyboardEvent):void
	{
		if (e.keyCode == Keyboard.RIGHT) {
			moveRight = false;
		}
		if (e.keyCode == Keyboard.LEFT) {
			moveLeft = false;
		}
	}

Na základě těchto logické hodnoty ve skutečnosti pohyb hráče každý snímek:

Nezapomeňte si nejprve vytvořit funkci naslouchání z rámečku událost enter, "aktualizace":

//call this function every frame
private function update(e:Event):void
	if (moveRight == true) {
		player.x += 6;
	}
	if (moveLeft == true) {
		player.x -= 6;
	}

Udržujte hráče v rámci hranice obrazovky:

	if (player.x >= 525) {
		moveRight = false;
	}
	if (player.x <= 20) {
		moveLeft = false;
	}

Zde je jak to všechno vypadá, na místě:

package
{
    import flash.display.MovieClip;
    import flash.events.Event;
    import flash.events.TimerEvent;
    import flash.ui.Keyboard;
    import flash.utils.Timer;
    import flash.events.KeyboardEvent;
 
    public class GameScreen
    {
        public var player:Player;
 
        private var energyM:EnergyManager;
 
        private var moveRight:Boolean = false;
        private var moveLeft:Boolean = false;
        private var isGravityPushing:Boolean = true;
 
        private var returnedPower:int = 0;
 
        private var scoreText:Text;
        private var totalScore:int=0;
        private var score:Text;
 
        public function GameScreen()
        {
            scoreText = new Text("Score :");
            addChild(scoreText);
 
            energyM = new EnergyManager;
 
            var spawnTimer:Timer = new Timer(3000, 0);
            spawnTimer.addEventListener(TimerEvent.TIMER, spawnEnergy);
            spawnTimer.start();
 
            player = new Player;
            addChild(player);
            player.x = 275;
            player.y = 450;
 
            addEventListener(Event.ENTER_FRAME, update);
            addEventListener(KeyboardEvent.KEY_DOWN, KeyDownHandler);
            addEventListener(KeyboardEvent.KEY_UP, KeyUpHandler);
        }

	private function KeyDownHandler(e:KeyboardEvent):void
	{
		if (e.keyCode == Keyboard.RIGHT) {
			moveRight = true;
		}
		if (e.keyCode == Keyboard.LEFT) {
			moveLeft = true;
		}
		if (e.keyCode == Keyboard.SPACE) {
			if (isGravityPushing == true) {
				isGravityPushing = false;
			}else if (isGravityPushing == false) {
				isGravityPushing = true;
			}
		}
	}
		
	private function KeyUpHandler(e:KeyboardEvent):void
	{
		if (e.keyCode == Keyboard.RIGHT) {
			moveRight = false;
		}
		if (e.keyCode == Keyboard.LEFT) {
			moveLeft = false;
		}
	}

	private function update(e:Event):void
	{
		if (player.x >= 525) {
			moveRight = false;
		}
		if (player.x <= 20) {
			moveLeft = false;
		}
		if (moveRight == true) {
			player.x += 6;
		}
		if (moveLeft == true) {
			player.x -= 6;
		}
	}
    }
}

Krok 10: Přesun dodávky energie

V současnosti jsou dodávky energie tření ale nehýbe. Použijeme funkci GameScreen.update() k jejich přesunutí, protože to běží každý snímek.

Přidáte tento kód do GameScreen.update():

			energyM.moveAll();  // will make every energy object move

Teď samozřejmě potřebujeme k EnergyManager.moveAll() funkce, tak přidat do EnergyManager.as:

		public function moveAll():void
		{
			for (var i:int = 0; i < energyList.length; i++) {
				var energyS:Energy = energyList[i];
				energyS.move();
			}
		}

Krok 10: Detekce kolizí

Budeme potřebovat zjistit kolize mezi každý objekt energii a hráč. (Pokud vyvíjíte hru dále, budete muset zkontrolovat planetek a spotřebitelé energie, ale ne pro hvězdy.)

Nejlepším místem pro zpracování těchto kontrol je uvnitř EnergyManager, spustí každý rám GameScreen.

Jedna věc, aby zvážila: kolize kontroluje, bude mezi dvěma kruhy, takže hitTestObject() není ideální. Místo toho budeme používat metody popsané v tomto kurzu.

Můžeme napsat funkci jako níže:

	public function checkCollision(p:Player):int
	{
		// energy transferred due to collision
		var energyTransfer:int = 0;
		
		for (var i:int = 0; i < energyList.length; i++) {
			var energyS:Energy = energyList[i];
			
			var newX:Number = p.x - energyS.x;
			var newY:Number = p.y - energyS.y;
				
			var distance:Number = Math.sqrt(newX * newX + newY * newY);
				
			if (distance <= 28) {
				gameScreen.removeEnergyFromScreen(energyS);
				energyList.splice(i, 1);
				// for this simple game, we'll always transfer 1 unit
				// but you could alter this based on speed of collision
				// or any other factor
				energyTransfer = 1;
			}
		}
		return energyTransfer;
	}

Řádek 32: Všimněte si, že jsme se projít v odkazu na hráče, tak, že můžeme přístup jeho pozici.
Řádek 38: V energetice je zkratka pro zásobování energií.
Linka 40 & 41: najít rozdíl v x a y souřadnice mezi přehrávačem a zásobování energií, kterou v současné době prověřujeme.
Řádek 43: Vypočítejte vzdálenost mezi objekty prostřednictvím Pythagoras.
Řádek 45: Kontrola kolizí; 28 je součtem poloměrů dvou objektů (hráč poloměr je 20, energetické poloměr je 8).
Linka 46 & 47: Odeberte dodávek energie z obrazovky a vektoru.
Linka 51: přidáte maximálně jednu jednotku energie na snímek.

Linka 51 by se mohly změnit na energyTransfer += 1, aby hráči absorbovat více energie objektů najednou. Je to na vás - to vyzkoušet a zjistit, jak to ovlivní hru.

Krok 11: Volání rutiny detekce kolize

Potřebujeme zjistit kolize každý snímek, takže bychom měli zavolat funkci, kterou jsme právě napsali z GameScreen.update().

Za prvé musíme vytvořit proměnnou celé číslo k ukládání energie přenosu hodnotu z funkce detekce kolizí. Budeme používat tuto hodnotu pro zvýšení lodní energii a přidání hráče skóre.

private var returnedPower:int = 0;

returnedPower = energyM.checkCollision(player);

Krok 12: Newtonův gravitační zákon

Než půjdeme do vytváření herních mechanik pro funkci "Push" a "Vytáhnout" lodi, chtěl bych zavést pojem fyzika, na nichž je založena mechanik.

Myšlenka je přilákat objektu směrem k přehrávači prostřednictvím síly. Newtonův zákon všeobecné gravitace nám dává skvělou (a jednoduché) matematického vzorce můžeme použít k tomu, kde síla je gravitační síla:

G je jen číslo, a můžeme jej nastavit na cokoliv, co se nám líbí. Stejně tak můžeme nastavit masy jednotlivých objektů ve hře na všechny hodnoty, které se nám líbí. Gravitace dochází přes nekonečné vzdálenosti, ale v naší hře, budeme mít mezního bodu (označen bílý kruh v demo od začátku kurzu).

Jsou dvě nejdůležitější věci k poznámce o tento vzorec:

Síla je síla závisí na náměstí vzdálenosti mezi dvěma objekty (takže pokud objekty, které jsou dvakrát tak daleko, síla je jedna čtvrtina tak silný).
Směr síly je podél přímé linie spojující dva objekty ve vesmíru.

Krok 13: Revize matematické pojmy

Než začneme, kódování herní mechaniky pro funkci "Push" a "Vytáhnout", buďme jasné, na co budeme chtít:

V podstatě chceme A (hráč) vyvinout sílu na B (krystal) a přesunout B vůči A na základě této síly.

Měli bychom přehodnotit několik pojmů:

Flash pracuje ve stupních, nikoli radiány.
Flash souřadnicový systém má svou y obrácené: jít dolů znamená zvýšení y.
Můžeme získat úhel čáry spojující počítače A a B pomocí Math.atan2 (Bičánek - A.y, B.x - A.x).
Můžeme použít trigonometrii zjistit, kolik potřebujeme přesunout B na obou osách, založené na tento úhel a sílu:
- B.x += (Force*Math.cos(angle));
- Bičánek += (Force*Math.sin(angle));
Používáme je Pythagoras věta přijít na vzdálenosti mezi dvěma objekty:

Další informace naleznete viz kurzy Gravity v akci a trigonometrie pro vývojáře Flash hra.

Krok 14: Implementace Push a Pull

Na základě předchozího vysvětlení, můžeme přijít s osnovou pro náš kód, který přitahuje Každý krystal na lodi:

Rozdíl v x a y mezi lodí a daný krystal.
Najděte úhel mezi nimi, v radiánech.
Najděte vzdálenost mezi nimi pomocí Pythagoras.
Zkontrolujte, zda je objekt uvnitř lodi gravitačního pole.
Pokud ano, výpočet gravitační síly a...
.. .apply síla, změna x a y hodnoty krystalu.

Ukázkový kód:

	public function gravityPull(p:Player): void
	{
		for (var i:int = 0; i < energyList.length; i++) {
			var energyS:Energy = energyList[i];
				
			var nX:Number = (p.x - energyS.x);
			var nY:Number = (p.y - energyS.y);
			
			var angle:Number = Math.atan2(nY, nX);
				
			var r:Number =  Math.sqrt(nX * nX + nY * nY);
				
			if (r <= 250) {
				var f:Number = (4 * 50 * 10) / (r * r); 				
				energyS.x += f * Math.cos(angle);
				energyS.y += f * Math.sin(angle);
			}
		}
	}

Linka 53: Získejte odkaz na hráče.
Řádek 55: jsme smyčka prostřednictvím každého objektu energií.
Linka 61: najdete úhel mezi lodí a energii.
Linka č. 63: najdete vzdálenost mezi nimi, taky.
Linka 65: Zkontrolujte, zda je energie uvnitř lodi silové pole.
Linka 67: použijte vzorec:
- 4 = G, "gravitační konstanta" jsem zvolil.
- 50 = m1, hmotnost lodi hráče.
- 10 = m2, hmotnost objektu energií.
Linka 69: aplikovat hnutí.

Tady je timelapse, ukazující, jak to vypadá:

Všimněte si, že energie pohybuje rychleji, blíže se dostane na loď, díky funkční spolehlivosti r.

Můžeme-li implementovat funkci tlačí jen tím, že síla negativní:

	public function gravityPull(p:Player): void
	{
		for (var i:int = 0; i < energyList.length; i++) {
			var energyS:Energy = energyList[i];
				
			var nX:Number = (p.x - energyS.x);
			var nY:Number = (p.y - energyS.y);
			
			var angle:Number = Math.atan2(nY, nX);
				
			var r:Number =  Math.sqrt(nX * nX + nY * nY);
				
			if (r <= 250) {
				var f:Number = (4 * 50 * 10) / (r * r); 				
				energyS.x -= f * Math.cos(angle);
				energyS.y -= f * Math.sin(angle);
			}
		}
	}

Zde se objekt pohybuje pomaleji, jak se dostane dál od hráče, neboť síla čím dál slabší.

Krok 15: Použije mechanik

Samozřejmě, že budete potřebovat tuto funkci spustit každý snímek GameScreen - ale před tím budeme muset použít logické funkce lze přepínat mezi dvěma funkcemi:

private var isGravityPushing:Boolean = true;  // hitting space toggles it

Budeme používat true pro "Push" a false pro "Pull".

Vnitřní KeyDownHandler():

	if (e.keyCode == Keyboard.SPACE) {
		if (isGravityPushing == true) {
			isGravityPushing = false;
		} else if (isGravityPushing == false) {
			isGravityPushing = true;
		}
	}

Poté budete muset zkontrolovat booleovská hodnota každého rámce. Přidáte tuto metodu update():

	if (isGravityPushing == true) {
		energyM.gravityPull(player);
	}
	if (isGravityPushing == false) {
		energyM.gravityPush(player);
	}

Krok 16: modifikace

Možná zjistíte, že pohyb nevypadá tak hezky. To může být síla není zcela ideální, nebo kvůli funkční spolehlivosti r.

Chtěl bych změnit vzorec jako tak:

var f:Number = (0.8 * 50 * 10) / r;

Jak vidíte, jsem se hodnota "G" na 0,8 a změnil síly závisí na vzdálenosti mezi objekty, spíše než vzdálenost na druhou.

Zkuste to a uvidíte, pokud si změnu. Vždy můžete změnit jej však se vám líbí.

Krok 17: Text třída

Budeme potřebovat zobrazit text na obrazovce, ukazující skóre a lodní zbývající energii.

Za tímto účelem budujeme novou třídu, Text:

package  
{
	import flash.display.MovieClip;
	import flash.text.TextField;
	import flash.events.Event;
	import flash.text.TextFormat;

	import flash.text.TextFormatAlign;

	public class Text extends MovieClip
	{
		public var _scoreText:TextField= new TextField();
		
		public function Text(string:String)
		{	
			var myScoreFormat:TextFormat = new TextFormat(); //Format changeable
			myScoreFormat.size = 24;		
			
			myScoreFormat.align = TextFormatAlign.LEFT;
			myScoreFormat.color = (0x131313);
			
			_scoreText.defaultTextFormat = myScoreFormat;
			
			_scoreText.text = string;
			
			addChild(_scoreText);
		}

		public function updateText(string:String)
		{
			_scoreText.text = string;
		}
	}
}

Je to velmi jednoduché; je to v podstatě MovieClip s textové pole uvnitř.

Krok 18: Přidávání energie pro hráče

Aby hra nějakou výzvu, uděláme lodní energie zvyknete pomalu, tak, že hráč musí sbírat energii pro dobití.

Aby lodní napájení se objeví na samotné lodi, můžeme jednoduše přidat instance textu do seznamu zobrazení objektu loď.

Prohlašuji, že tyto proměnné v rámci loď třídy:

public var totalPower:Number = 100;  // ship starts with this much power
private var powerText:Text;

Budeme muset udržet množství energie (obě uloženy a zobrazeny) aktualizovány každý snímek, takže přidejte tuto novou funkci hráče:

Za prvé, v konstruktoru:

			// add a new text object if it doesn't already exist
			if (!powerText) {
				powerText = new Text(String(int(totalPower))); 
				addChild(powerText);	
				powerText.x -= 20;			//Adjust position
				powerText.y -= 16;
			}

A pak...

	public function updatePower():void
		{
			// fps = 24, so this makes power decrease by 1/sec
			totalPower -= 1 / 24;		
			powerText.updateText(String(int(totalPower)));
		}

Moc se sníží každý snímek o 1/24 z celku, což znamená, to bude snížit o jednu plnou jednotku každou sekundu.

Musíme to spustit každý snímek, takže přidejte tento řádek do GameScreen.update():

player.updatePower();

Krok 19: Aby zvýšení energie

Když loď srazí s objektem energii, chceme zvýšit svou sílu.

V GameScreen.update() přidejte zvýrazněný řádek:

returnedPower = energyM.checkCollision(player);
player.totalPower += returnedPower;

Pamatujte, že můžete změnit, kolik energie je vrácena v EnergyManager.checkCollision() funkce.

Krok 20: Nastavení skóre

Opět budeme potřebovat třída text. Tentokrát budeme zobrazovat "Score" a pak hodnotu.

Tady budeme potřebovat tři více proměnných:

Text "Skóre".
Skóre hodnota text.
Proměnnou pro uložení aktuální skóre.

Prohlašuji, že v GameScreen třídě:

private var scoreText:Text;
private var totalScore:int = 0;
private var score:Text;

V konstruktoru přidejte tento kód:

scoreText = new Text("Score :");
addChild(scoreText);

score = new Text(String(totalScore));
addChild(score);
score.x = scoreText.x + 100;   //Positioning it beside the "Score : " Text.
score.y += 2;

Nyní ve funkci update(), přidáte tuto:

score.updateText(String(totalScore));

To je ono - vytvořili jsme základní verzi výše uvedené hry!

Podívejte se (budete muset stránku znovu načíst):

Další funkce a leštění

Místo na pozadí

Možná také chcete pozadí s vložený obrázek a hvězd. Přidáte do hlavní třídy:

[Embed(source = "/../lib/SpaceBackground.jpg")]	//embed
		private var backgroundImage:Class; //This line must come immediately after the embed

		private var bgImage:Bitmap = new backgroundImage();		
		private var numOfStars:int = 70;

Nyní vytvořte třídu Star:

package assets 
{
	import flash.display.MovieClip;
	import flash.events.Event;

	public class Star extends MovieClip
	{
		private var speed:Number;
		
		public function Star(alpha:Number, size:Number, speed1:Number) 
		{
			graphics.beginFill(0xCCCCCC);
			graphics.drawCircle(0, 0, size);
			
			speed = speed1;
		}
		
		// make sure you call this every frame
		private function moveDown():void
		{
			this.y += speed;
			
			if (this.y >= 600) {
				this.y = 0;
			}
		}
	}
}

V konstruktoru Main() přidejte vytvoření hvězd:

for (var i:int = 0; i < numOfStars; i++) {
		createStars();
}

Tady je skutečný createStars() funkce:

private function createStars():void
{
	var star:Star = new Star(
		Math.random(), 
		Calculations.getRandomValue(1, 2), 
		Calculations.getRandomValue(2, 5)
	);  //random alpha, size and speed
			
	addChild(star);
			
	star.x = Calculations.getRandomValue(0, 550);
	star.y = Calculations.getRandomValue(0, 600);
}

S náhodné alfa, velikosti, polohy a rychlosti je možné generovat pseudo-3D pozadí.

Rozsah indikátor

Kruh ukazatele vzdálenosti lze jednoduše vytvořením další kruh a jeho přidáním do seznamu zobrazení lodi, stejně jako jak jste přidali text ukazatele výkonu. Ujistěte se, že kružnice je soustředěn na lodi a má poloměr roven lodní nabízenou/vyžádanou replikaci rozsahu.

Přidání průhlednosti (alfa hodnota) do kruhu pod kódem:

			graphics.beginFill(0xCCCCCC, 0.1);

Zkuste přidat další ovládací prvky, které činí rozsah zvýšeny nebo sníženy stisknutí kláves Šipka nahoru a dolů.

Závěr

Doufám, že se vám to líbilo tento kurz! Zanechte svůj komentář.

Dále: Přečtěte si tuto kritiku pokyny k převzetí tok od jednoduché demo plnou hru!