Share
Ben je ooit verbaasd over de verscheidenheid aan aanvallen in vechtspellen zoals Mortal Kombat, Super Smash Bros, Soul Calibur en anderen? Nu kun je leren hoe je een engine kunt maken om toetscombinaties te detecteren en je eigen vechtgame te bouwen!
Laten we eens kijken naar het eindresultaat waar we naartoe zullen werken:
De combo's in deze demo zijn: aSDF, AAA, en SSS. Type ze!
Ooit een vechtgame (of een ander genre) met veel combo's willen bouwen? In deze tutorial zullen we een eenvoudige klasse maken om belangrijke combo's te detecteren en ons te laten weten wanneer een combo door de gebruiker is gedaan. We zullen ook een heel eenvoudige grafische interface maken om ons onze klas te laten testen.
Voor deze zelfstudie gebruiken we het pure AS3-project van FlashDevelop met preloader. We zullen alleen een project met een preloader maken om het u gemakkelijk te maken als u aan het eindresultaat naar een spel wilt blijven werken. Laten we beginnen met het openen van FlashDevelop en het selecteren van ons project:
Daarmee kunnen we aan onze lessen beginnen.
Om de grafische afbeeldingen te gebruiken die we in Flash Pro binnen ons AS3-project maken, moeten we onze afbeeldingen uit het .fla-bestand exporteren naar een .swc-indeling. Meer informatie over dit formaat is te vinden in optie 2 van deze gids voor FlashDevelop. Maak een nieuwe AS3 FLA in Flash Professional en wijzig vervolgens de instellingen in ons .fla-bestand om de inhoud naar een .swc-indeling te exporteren: ga naar Bestand> Publicatie-instellingen (of druk op Ctrl + Shift + F12) en vink het vakje "Export SWC" aan onder het tabblad "Flash".
Maak je geen zorgen als je geen Flash Professional hebt. Ik heb het laatste SWC-bestand opgenomen in het downloadpakket voor deze zelfstudie. Download het en ga vervolgens naar stap 6.
We zullen eerst alle grafische delen maken en pas daarna zorgen maken over de code. Omdat we te maken hebben met belangrijke combo's, laten we een knop maken met een letter erin om een sleutel te vertegenwoordigen. Onze knop is heel eenvoudig: drie cirkels met verschillende kleuren en enkele filters erin. Zo heb ik de mijne gebouwd: een grote grijze cirkel met een witte cirkel erop en een rode cirkel bovenop de witte. Daarna heb ik een glow- en twee slagschaduwfilters op de rode cirkel toegepast om het eindresultaat te krijgen, dat is opgenomen in de bronbestanden.
Voor meer informatie over hoe de knop is gebouwd, pakt u de bronbestanden voor deze zelfstudie!
We moeten nu onze knop "omhoog" en "omlaag" afbeeldingen geven. Voordat we dat doen, moeten we er een symbool van maken. Laten we het omzetten in een symbool, geef het een naam KeyButtonImage en exporteer het als "SWCAssets.KeyButtonImage". We voegen het toe SWCAssets pakket in de klassenaam voor organisatiedoeleinden wanneer we beginnen met coderen. Dit wordt later duidelijker.
Op onze KeyButtonImage symbool, laten we een ander keyframe maken met dezelfde afbeelding van de eerste en vervolgens de hoek van de filters die we gebruiken op de rode cirkel omkeren. We zullen ook onze frames moeten labelen om ze in onze code te identificeren, dus label het eerste frame als "Up" en het tweede frame als "Down". De afbeelding met de afbeelding zou er als volgt uit moeten zien:
Nu we onze knopafbeelding gereed hebben, is het tijd om ons .swc-bestand te genereren en toe te voegen aan ons FlashDevelop-project. Druk om te publiceren op Alt + Shit + F12. U zult opmerken dat er een .swc-bestand is aangemaakt in dezelfde map van het flash-bestand. Kopieer dit bestand en plaats het in de map "lib" van ons FlashDevelop-project. Klik met de rechtermuisknop en selecteer "Toevoegen aan bibliotheek" om FlashDevelop het bestand te laten herkennen. De naam van het bestand wordt blauw zodra het aan de bibliotheek is toegevoegd.
FlashDevelop is nu klaar om onze knopafbeelding te gebruiken!
Onze afbeelding is klaar, dus we moeten een klasse maken om de afbeelding vast te houden en er functionaliteiten aan toe te voegen. Voeg in FlashDevelop een nieuwe klasse toe in de map src, noem die keybutton en zet flash.display.Sprite als de Base-klasse.
Sinds onze keybutton klasse erft van de klasse Sprite, het kan afbeeldingen toevoegen aan de onderliggende weergavelijst. In deze stap zullen we de afbeelding aan onze klas toevoegen en de lettertekst erin plaatsen. Laten we naar de code springen:
Accentsconagua
pakket import flash.display.Sprite; import flash.text.TextField; import flash.text.TextFormat; import flash.text.TextFormatAlign; import SWCAssets.KeyButtonImage; public class KeyButton breidt Sprite uit private var _image: KeyButtonImage; private var _text: TextField; publieke functie KeyButton (letter: String) _image = new KeyButtonImage (); _image.stop (); addChild (_image); _text = new TextField (); _text.defaultTextFormat = new TextFormat ("Verdana", 28, 0xFFFFFF, true, null, null, null, null, TextFormatAlign.CENTER); _text.text = letter; _text.height = 38; _text.x = - (_ text.width / 2); _text.y = - (_ text.height / 2); _text.mouseEnabled = false; addChild (_text); In regel 11 en 13 declareren we variabelen die de afbeelding van onze knop en de tekst van de letter respectievelijk bevatten. In de constructor van onze klasse (regel 15) vragen we om een string, die de letter is die onze knop zal vertegenwoordigen.
Sinds onze KeyButtonImage heeft twee frames, in regel 18 noemen we de hou op() methode om te voorkomen dat deze doorloopt. We zullen specifieke momenten definiëren voor de afbeelding om later van kader te wisselen. Regel 20 voegt de afbeelding toe aan de lijst met onderliggende items van de knop.
Van regel 22 tot regel 30 maken we ons tekstveld dat een letter bevat, positioneert en uitschakelt voor muisgebeurtenissen (niet noodzakelijk, maar goed om te doen als je tekstveld niets anders zou moeten doen dan de tekst laten zien). Regel 32 voegt de tekst toe aan de lijst met onderliggende items van de knop.
Onze keybutton klasse kan al een afbeelding tonen en een letter voorstellen, dus in deze stap zullen we een paar knoppen op het scherm toevoegen. Omdat we alleen een voorbeeld bouwen om onze klas te testen, zullen we niet alle letters in het voorbeeld toevoegen. In plaats daarvan werken we alleen met 4 letters (maar onze klas zal combo's met willekeurige toetsen kunnen detecteren!): A, S, D en F. We zullen ze nu aan ons scherm toevoegen:
private var keyButtons: Array = []; privé var-sleutels: Array = ["A", "S", "D", "F"]; private function init (e: Event = null): void removeEventListener (Event.ADDED_TO_STAGE, init); var i: int; voor (i = 0; i < 4; i++) keyButtons[i] = new KeyButton(keys[i]); KeyButton(keyButtons[i]).x = 100 + (100 * i); KeyButton(keyButtons[i]).y = 50; addChild(KeyButton(keyButtons[i]));
Regel 1 maakt een array die alle knoppen in ons scherm bevat. Dit zal later zeer nuttig zijn, omdat het ons door de array laat lopen in plaats van per knop te controleren. Regel 2 definieert alleen met welke toetsen we zullen werken (zoals gezegd, A, S, D en F). De regels 12-16 bevinden zich in een lus die de 4 knoppen maakt en deze op het scherm plaatst.
U kunt nu het project compileren en de knoppen in het scherm bekijken:
We zijn nu klaar om te beginnen met het detecteren van combo's. Daarvoor zullen we een creëren ComboHandler klasse. Volg gewoon dezelfde stappen als bij het maken van de keycombo klas, maar deze keer onze ComboHandler klas heeft geen basisklasse.
Wat moet het eerste deel zijn van de ComboHandler klasse? Nou, we zullen eerst moeten detecteren wanneer een toets is ingedrukt. Om dat te doen, moeten we een gebeurtenislistener aan het podium toevoegen (onthoud: zoals voorgesteld door de ActionScript 3-referentie, om wereldwijd te luisteren naar KeyboardEvent evenement luisteraars, ze moeten worden toegevoegd aan het podium!
pakket import flash.display.Stage; import flash.events.KeyboardEvent; openbare klasse ComboHandler public static function initialize (stageReference: Stage): void stageReference.addEventListener (KeyboardEvent.KEY_DOWN, onKeyDown); private static function onKeyDown (e: KeyboardEvent): void
Deze code bouwt alleen de basisstructuur van de ComboHandler klasse. Later zal er nog veel meer worden toegevoegd! Merk op dat we alleen statische methoden hebben gebruikt. Dat komt omdat we er maar een hebben ComboHandler klasse in ons voorbeeld. Enkele suggesties voor verbeteringen in deze klasse zijn beschikbaar in de conclusie.
Onze ComboHandler klasse moet worden geïnitialiseerd via de initialiseren () methode om de luisteraar aan het podium te laten toevoegen. In onze Hoofd klas, moeten we de klas initialiseren voordat we ermee werken. Laten we naar Main.as gaan en dat doen:
private function init (e: Event = null): void removeEventListener (Event.ADDED_TO_STAGE, init); var i: int; voor (i = 0; i < 4; i++) keyButtons[i] = new KeyButton(keys[i]); KeyButton(keyButtons[i]).x = 100 + (100 * i); KeyButton(keyButtons[i]).y = 50; addChild(KeyButton(keyButtons[i])); ComboHandler.initialize(stage);
We hebben de basisstructuur van de ComboHandler klasse gebouwd, dus nu moeten we er dingen aan toevoegen. Het eerste is om combo's in de klas te registreren, zodat het een combo kan detecteren.
Hoe zullen we de combo's in deze klas opslaan? Je hebt misschien wel gehoord van de Dictionary-klasse. Deze klasse kan elke waarde bevatten op basis van een sleutel. In onze klasse zullen de sleutels de combo-namen zijn en de waarde zal een array zijn, waarbij elke index een sleutel uit de combo is. De code ervoor (hieronder uitgelegd):
privé-static var-combo's: woordenboek; public static function initialize (stageReference: Stage): void combos = new Dictionary (); stageReference.addEventListener (KeyboardEvent.KEY_DOWN, onKeyDown); public static function registerCombo (comboName: String, comboKeys: Array): Boolean if (combo's [comboName]) return false; combo's [comboName] = comboKeys; geef waar terug;
In regel 1 maken we het woordenboek waar we het over gehad hebben. Lijn 5 initialiseert het en de functie registerCombo () registreert een combo in het woordenboek. Deze functie keert terug waar als de combo met succes is geregistreerd, of vals als er al een combo met die naam in de klas was (in dat geval moet je misschien de oude combo verwijderen - zie stap 19 daarvoor!).
Een ander ding dat onze klas zou moeten hebben, is een maximale intervaltijd tussen elke toetsaanslag. In sommige games die combo's hebben, hebt u waarschijnlijk gemerkt dat wanneer u op toets A drukt, bijvoorbeeld een seconde wacht en op toets B drukt (aangenomen dat er een "AB" -combinatie is), wordt er geen combo gedetecteerd, omdat u ook hebt gewacht veel om op de B-toets te drukken. Dat gebeurt omdat er een maximale intervaltijd is tussen elke toetsaanslag. Dat is precies wat we in onze klas zullen doen. Dus in de ComboHandler klasse:
persoonlijke statische var pressedKeys: Array; privé statische const MAX_INTERVAL: int = 250; // Milliseconds privé statische var-interval: int; public static function initialize (stageReference: Stage): void combos = new Dictionary (); interval = 0; stageReference.addEventListener (KeyboardEvent.KEY_DOWN, onKeyDown); private static function onKeyDown (e: KeyboardEvent): void if (getTimer () - interval> MAX_INTERVAL) pressedKeys = []; interval = getTimer (); pressedKeys.push (e.keyCode);
In regel 1 maken we een array genaamd pressedKeys. Deze array bevat alle toetsen die door de gebruiker zijn ingedrukt, waarbij de intervaltijd tussen twee toetsen kleiner is dan het maximale interval.
Lijnen 3 en 4 bepalen a MAX_INTERVAL constant, wat ons maximale interval zal zijn, en de interval variabele, waarmee we kunnen berekenen wat de intervaltijd was tussen twee toetsaanslagen.
De onKeyDown () De functie is nu bijna voltooid: we detecteren eerst of de intervaltijd tussen de huidige toetsaanslag en de laatste toetsaanslag hoger is dan het maximale interval. Als dat zo is, stellen we onze opnieuw in pressedKeys array, om alle sleutels te verwijderen die er in zaten. Daarna werken we de intervalvariabele bij naar de huidige tijd (zie de documentatie van getTimer () voor meer informatie over hoe we het interval berekenen) en Duwen() de huidige sleutel tot de pressedKeys rangschikking.
Een laatste ding ontbreekt in onze ComboHandler's onKeyDown () functie: de mogelijkheid om te controleren of, nadat een toets is ingedrukt, een combo door de gebruiker is uitgevoerd. Dit is wat we nu gaan doen:
private static function onKeyDown (e: KeyboardEvent): void if (getTimer () - interval> MAX_INTERVAL) pressedKeys = []; interval = getTimer (); pressedKeys.push (e.keyCode); checkForCombo (); private static function checkForCombo (): void var i: int; var comboFound: String = ""; for (var comboName: String in combo's) if (pressedKeys.join ("") .indexOf ((combo's [comboName] als Array) .join (""))> -1) comboFound = comboName; breken; // Combo gevonden als (comboFound! = "") PressedKeys = []; Regel 12 is de enige wijziging die we hebben aangebracht in onze onKeyDown () functie: bel de checkForCombo () functie. Hiermee wordt gecontroleerd of een combo is uitgevoerd of niet.
De manier waarop we controleren of een combo is uitgevoerd, is erg interessant: we werken met strings. Werken met strings, in dit geval, stelt ons in staat om dingen te detecteren die moeilijker zouden zijn geweest zonder ermee te werken. Stel je bijvoorbeeld voor dat we een combinatie hadden met de toetsen ASDF, maar de pressedKeys array heeft de volgende reeks toetsen: ASFDASDF. Ook al heeft de gebruiker op de eerste vier toetsen gedrukt ("ASFD", wat niet doen komen overeen met een combo) binnen de tijdslimiet, dit mag niet veranderen dat de gebruiker een combo heeft uitgevoerd, zoals aangegeven door de laatste 4 toetsen ("ASDF"). Zonder snaren had ons werk veel langer kunnen duren.
Het idee om met snaren te werken is dit: we plaatsen alle sleutels erin pressedKeys in een tekenreeks, waarbij elke index wordt gescheiden door een spatie (dus de pressedKeys.join ("") functieaanroep), controleer dan of er een bepaalde substring in zit. Deze specifieke substring is een string die wordt gevormd door de toetsen van een combo, ook met elke sleutel gescheiden door een spatie. Als deze substring wordt gevonden, betekent dit dat er een combo is uitgevoerd.
Je kunt dit zelf testen met een code als deze:
pressedKeys = ["A", "S", "F", "D", "A", "S", "D", "F"]; checkForCombo ();
? hoewel je ook een tijdelijke wilt toevoegen trace (comboFound) inbellen checkForCombo () om het resultaat te zien.
Merk echter op dat deze methode niet in alle gevallen zal werken. Het werkt niet als we in plaats van een reeks strings een array met objecten hebben, bijvoorbeeld. Als we een array van objecten hadden, zou de standaard toString () -functie die wordt opgeroepen als join () wordt aangeroepen, "[object Object]" afdrukken, en dus zouden al onze objecten in de array "hetzelfde" zijn in de gemaakte string . Als je dat nog steeds wilt doen, vervang je gewoon de standaard toString () -functie en plaats daar een aangepaste tekst. In stap 14 doen we dat in de klasse ComboEvent - bekijk het voor een referentie!
Nu zullen we stoppen met ons te concentreren op de ComboHandler klasse en werk opnieuw op de knoppen die we hebben gemaakt. (Verwijder de testcode die u zojuist hebt toegevoegd.)
Momenteel staan onze knoppen op het scherm, maar ze laten niets zien. U herinnert zich misschien dat we twee knopafbeeldingen hebben gemaakt: één voor wanneer de knop niet wordt ingedrukt en andere voor wanneer deze wordt ingedrukt. In deze stap zullen onze knoppen zich gedragen wanneer een toets is ingedrukt. Laten we naar onze keybutton klasse:
public function onUp (): void _image.gotoAndStop ("Up"); public function onDown (): void _image.gotoAndStop ("Down"); Merk op dat deze code alleen de frames van de afbeelding van de knop verandert. We moeten ze nog steeds bellen als op de betreffende toets is gedrukt. We doen dat in Main.as:
private function init (e: Event = null): void removeEventListener (Event.ADDED_TO_STAGE, init); var i: int; voor (i = 0; i < 4; i++) keyButtons[i] = new KeyButton(keys[i]); KeyButton(keyButtons[i]).x = 100 + (100 * i); KeyButton(keyButtons[i]).y = 50; addChild(KeyButton(keyButtons[i])); ComboHandler.initialize(stage); stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown); stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUp); private function onKeyDown(e:KeyboardEvent):void var i:int; for (i = 0; i < 4; i++) if (String.fromCharCode(e.keyCode) == keys[i]) KeyButton(keyButtons[i]).onDown(); break; private function onKeyUp(e:KeyboardEvent):void var i:int; for (i = 0; i < 4; i++) if (String.fromCharCode(e.keyCode) == keys[i]) KeyButton(keyButtons[i]).onUp(); break;
Lijnen 18 en 19 zijn de enige toevoegingen aan de in het() functie. Ze voegen meer gebeurtenislisteners toe op het podium om te detecteren wanneer een toets is ingedrukt en wanneer een toets is losgelaten. We gebruiken deze twee luisteraars om onze knoppen te vertellen of ze omhoog of omlaag moeten gaan.
Het enige dat je misschien nog nooit hebt gezien in de onKeyDown () en onkeyup () functies is de String.fromCharCode () functie. Deze functie retourneert een tekenreeks met de char-codes die u als argumenten doorgeeft. Aangezien we slechts één char-code doorgeven, retourneert die functie een tekenreeks met slechts één teken en als deze overeenkomt met de tekenreeksen die we in de array sleutels hebben, betekent dit dat we de betreffende knop moeten laten weten dat hij moet handelen.
U kunt nu de knoppen testen die op en neer gaan!
Op dit moment, onze ComboHandler klasse detecteert toets indrukken, handelt intervaltijden af, controleert of er combo's zijn uitgevoerd, maar het werkt nog steeds niet als een combo is uitgevoerd. Hoe kan het andere dingen vertellen dat er een combo is gedaan? Dat is wat we hier zullen beginnen. Omdat Flash een zeer krachtig gebeurtenissensysteem heeft, zullen we een gebeurtenis verzenden voor wanneer een combo is gedetecteerd en andere objecten deze gebeurtenissen laten ontvangen.
Ga voor meer informatie over aangepaste evenementen naar deze link op 8bitrocket. Maak het ComboEvent klasse met deze code erin:
pakket import flash.events.Event; public class ComboEvent breidt evenement uit public static const COMBO_FINISHED: String = "comboFinished"; public var params: Object; openbare functie ComboEvent (type: String, params: Object, bubbles: Boolean = false, cancelable: Boolean = false) super (type, bubbles, cancelable); this.params = params; public override function clone (): Event return new ComboEvent (type, this.params, bubbles, cancelable); openbare override-functie toString (): String return formatToString ("ComboEvent", "params", "type", "bubbles", "cancelable"); In regel 9 verklaren we de params variabel. Het zal informatie bevatten over de combo die is uitgevoerd (in dit voorbeeld zullen we alleen de naam plaatsen, maar je kunt zetten wat je maar wilt). Let op de clone () functie in de klas. Het is gemaakt om hergebeurde gebeurtenissen toe te staan dezelfde informatie van de oorspronkelijke gebeurtenis te bevatten. Ga naar deze blogpost op Bit 101 voor meer informatie
Nu, in onze ComboHandler klasse, het is tijd om actie te ondernemen wanneer een combo is uitgevoerd. Om dat te doen, moeten we een ComboEvent. Gebeurtenissen kunnen alleen worden verzonden door objecten waarvan de overerving plaatsvindt EventDispatcher, maar ComboHandler ervaart niet van EventDispatcher. In plaats van er van te erven EventDispatcher (dat zou ons dwingen om er een voorbeeld van te hebben ComboHandler, wat we niet willen in het kader van deze tutorial), zullen we een creëren EventDispatcher object in de klasse en laat dit object gebeurtenissen verzenden. Bovendien zullen andere klassen naar dit object luisteren voor evenementen. In ons ComboHandler.as bestand:
Importeer dit:
import flash.events.EventDispatcher;
En voeg deze code toe:
public static var dispatcher: EventDispatcher; public static function initialize (stageReference: Stage): void combos = new Dictionary (); interval = 0; dispatcher = new EventDispatcher (); stageReference.addEventListener (KeyboardEvent.KEY_DOWN, onKeyDown); private static function checkForCombo (): void var i: int; var comboFound: String = ""; for (var comboName: String in combo's) if (pressedKeys.join ("") .indexOf ((combo's [comboName] als Array) .join (""))> -1) comboFound = comboName; breken; // Combo gevonden als (comboFound! = "") PressedKeys = []; dispatcher.dispatchEvent (nieuwe ComboEvent (ComboEvent.COMBO_FINISHED, comboName: comboFound)); In regel 1 verklaren we ons dispatcher-object. In regel 9 initialiseren we het. In regel 34 verzenden we een ComboEvent. En dat is het voor de ComboHandler klasse. Nu moeten we luisteren naar de gebeurtenis die wordt verzonden.
Het controleren op aangepaste gebeurtenissen gebeurt op dezelfde manier als het omgaan met een andere gebeurtenis in AS3: voeg een luisteraar toe aan de coördinator en maak een functie om iets te doen wanneer de luisteraar een gebeurtenis ontvangt. Onze Hoofd klasse moet degene zijn die de gebeurtenis ontvangt, omdat deze iets op het scherm zal tonen wanneer een combo wordt gedetecteerd.
private function init (e: Event = null): void removeEventListener (Event.ADDED_TO_STAGE, init); var i: int; voor (i = 0; i < 4; i++) keyButtons[i] = new KeyButton(keys[i]); KeyButton(keyButtons[i]).x = 100 + (100 * i); KeyButton(keyButtons[i]).y = 50; addChild(KeyButton(keyButtons[i])); ComboHandler.initialize(stage); stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown); stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUp); ComboHandler.dispatcher.addEventListener(ComboEvent.COMBO_FINISHED, onComboComplete); private function onComboComplete(e:ComboEvent):void
De gemarkeerde lijn is waar we de luisteraar aan toevoegen ComboHandler's dispatcher.
In deze zelfstudie laten we tekst op het scherm zien met de naam van de combo die is uitgevoerd. We hebben een tekstveld op het scherm nodig en we moeten de naam van de gecombineerde combo krijgen die is uitgevoerd.
private var textField: TextField; private function init (e: Event = null): void removeEventListener (Event.ADDED_TO_STAGE, init); var i: int; voor (i = 0; i < 4; i++) keyButtons[i] = new KeyButton(keys[i]); KeyButton(keyButtons[i]).x = 100 + (100 * i); KeyButton(keyButtons[i]).y = 50; addChild(KeyButton(keyButtons[i])); ComboHandler.initialize(stage); textField = new TextField(); textField.defaultTextFormat = new TextFormat("Verdana", 20, 0x000000, true); textField.x = 100; textField.y = 200; textField.width = 350; textField.text = "No combo"; addChild(textField); stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown); stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUp); ComboHandler.dispatcher.addEventListener(ComboEvent.COMBO_FINISHED, onComboComplete); private function onComboComplete(e:ComboEvent):void textField.text = e.params.comboName; Regel 1 bevat de verklaring van het tekstveld dat we gaan gebruiken. Regel 20-27 bevat de initialisatie van het tekstveld. In onze onComboComplete () functie, plaatsen we de combo-naam alleen in de tekst van het tekstveld. Dat is het! Nu is het enige wat je nog moet doen om wat combo's te registreren en de klas te testen!
Laten we in het Main.as-bestand enkele combo's registreren: ik zal de "AAA Combo", "SSS Combo" en "ASDF Combo" registreren. U kunt zoveel combo's registreren als u wilt!
private function init (e: Event = null): void removeEventListener (Event.ADDED_TO_STAGE, init); var i: int; voor (i = 0; i < 4; i++) keyButtons[i] = new KeyButton(keys[i]); KeyButton(keyButtons[i]).x = 100 + (100 * i); KeyButton(keyButtons[i]).y = 50; addChild(KeyButton(keyButtons[i])); ComboHandler.initialize(stage); ComboHandler.registerCombo("AAA Combo", [65, 65, 65]); ComboHandler.registerCombo("SSS Combo", [83, 83, 83]); ComboHandler.registerCombo("ASDF Combo", [65, 83, 68, 70]); textField = new TextField(); textField.defaultTextFormat = new TextFormat("Verdana", 20, 0x000000, true); textField.x = 100; textField.y = 200; textField.width = 350; textField.text = "No combo"; addChild(textField); stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown); stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUp); ComboHandler.dispatcher.addEventListener(ComboEvent.COMBO_FINISHED, onComboComplete); Compileer het project en dat is wat u krijgt:
Wat als we een combo wilden verwijderen die is geregistreerd? De volgende functie kan in het bestand ComboHandler.as worden toegevoegd om de positie van het combo-woordenboek naar de standaardinstelling te resetten. Het zal true teruggeven als de combo is verwijderd en false als dat niet het geval was (er was geen combo geregistreerd met die naam).
public static function removeCombo (comboName: String): Boolean if (combo's [comboName]) combo's [comboName] = undefined; geef waar terug; return false;
Nou, gefeliciteerd met het afronden van deze tutorial! U bent klaar om een basiscombo-handler voor uw games te implementeren!
Een basiscombo-handler past echter niet in alle games. Wat als je een spel wilde gebruiken met verschillende personages, en elk personage had zijn combo's en je had meer controle over de handlers nodig? U kunt dat eenvoudig doen als u toestemming geeft voor de ComboHandler klasse, die voor jou een uitdaging blijft.
Je zou die klasse ook kunnen veranderen in een Singleton, in plaats van alleen statische functies te hebben. Er zijn vele andere creatieve toepassingen voor, inclusief het registreren van woorden als een combo en het controleren of iemand een woord heeft getypt of niet.
Had je een creatief gebruik voor deze klas? Deel het met ons in de comments sectie!
