Share
We zijn nu halverwege deze serie en tot nu toe hebben we veel besproken. In de vorige zelfstudie hebben we een puntensysteem aan onze game toegevoegd, uiteindelijk hebben we de zwaartekracht op de blokken toegepast en hebben we ons koppelingssysteem verbeterd. In deze tutorial gaan we enkele kleine verbeteringen aan ons ruilsysteem aanbrengen, de tekst met zwevende punten toevoegen die je kunt zien in de definitieve versie van het spel en ons matchingsysteem voor eens en voor altijd.
Hier is een demo van de game waaraan we werken in deze serie:
Op dit moment is er in de game een zeer eenvoudige ruilmechanisme geïmplementeerd. Hoewel het systeem dat we gebruiken om deze swaps uit te voeren erg effectief is, zijn er twee problemen die je zou kunnen tegenkomen tijdens het spelen, en beide moeten worden opgelost voordat we verder gaan.
Deze problemen komen voort uit hetzelfde idee: dat het ruilsysteem geen rekening houdt met de grenzen van het speelveld.
Wat betekent dit precies? Nou, ten eerste, als je wilde, zou je een blok buiten het speelveld naar links of rechts kunnen verplaatsen, door een ruil te maken zoals de afbeelding hieronder:
Als je de game in gaat en deze swap maakt, zul je zien dat de game niets doet om je te stoppen, en doet alsof het speelveld voor altijd in een horizontale richting blijft bestaan. De reden hiervoor is dat, op dit moment, het speelveld doet blijf voor altijd horizontaal.
Omdat we nooit hebben bepaald waar de linker- en rechtergrenzen van het speelveld zijn, of zelfs dat het speelveld links en rechts grenzen heeft, probeert het spel nooit te voorkomen dat de speler het blok verder naar de zijkant verplaatst. Dit probleem komt ook naar voren als je ook de andere kant van het speelveld weghaalt.
Om dit probleem op te lossen, voegen we enkele nieuwe voorwaarden toe aan de Blok> Op DragDrop-drop Evenement. Ga naar dit evenement en voeg deze voorwaarde toe aan het sub-evenement dat controleert op linkerruil:
Voorwaarde: LeftBlock> Vergelijk X-vergelijking = Groter of gelijk X = SPAWNX
Voeg deze voorwaarde nu toe aan het sub-evenement dat controleert op juiste swaps:
Voorwaarde: RightBlock> Vergelijk X vergelijking = Minder of gelijk X = SPAWNX + Block.Width * 8
Uw links en rechts swapping-evenementen zouden er nu als volgt uit moeten zien:
Deze nieuwe voorwaarden die we hebben toegevoegd, worden door de ruilevenementen gebruikt als een controle om ervoor te zorgen dat de ruil zich binnen de horizontale grenzen van het speelveld bevindt. De eerste zorgt ervoor dat de positie waarnaar het blok wordt gerouleerd, niet verder naar links is dan de meest linkse blokken, en de tweede zorgt ervoor dat de positie waarnaar het blok wordt gerouleerd, niet verder naar rechts dan het rechtsboven ligt. de meeste blokken.
Bij de tweede heb ik een formule gebruikt Block.Width om te vinden waar de meest rechtse blokken zijn om ervoor te zorgen dat, als de grootte van de blokken verandert, dit niet zou voorkomen dat deze voorwaarde werkt.
Als je het spel uitvoert, zou je niet langer horizontale swaps kunnen maken die blokken buiten het speelveld zouden plaatsen.
Het andere probleem dat we hebben is dat het spel je niet belet om een blok onder het speelveld te ruilen. Open het spel en probeer een wissel te maken zoals die ik heb geïllustreerd in deze afbeelding:
Na het maken van deze ruil, had je moeten zien dat het blok in wezen gewoon achter het onderste stuk van het speelveld verdwijnt, en de blokken die erboven waren moeten zijn gevallen om de nu lege ruimte te vullen. Nogmaals, dit probleem is omdat we nooit hebben aangegeven waar de onderkant van het veld is.
In de vorige tutorial hebben we verklaard dat de blokken moeten stoppen met vallen na het bereiken van een bepaalde hoogte, maar we hebben nooit gezegd of het oké was voor een blok om onder die hoogte te komen bij het uitvoeren van een ruil.
Dit oplossen is net zo eenvoudig als de vorige twee problemen. Ga naar het sub-evenement dat op neerwaartse swaps controleert en voeg deze voorwaarde toe:
Voorwaarde: BottomBlock> Vergelijk Y-vergelijking = minder of gelijk Y = SPAWNY
Uw code voor deze sectie zou er nu als volgt moeten uitzien:
Net als de vorige voorwaarde, zorgt dit ervoor dat de ruil het blok niet in een gebied buiten het speelveld plaatst. In dit geval kijkt het naar het gebied onder het speelveld.
Als je op dit moment je spel test, zou je nu geen swaps kunnen maken die het blok onder de basis van het speelveld plaatsen.
Op dit punt hebben we de problemen opgelost met het ruilsysteem en kunnen we ons puntensysteem nog beter maken.
Op dit moment is ons puntensysteem behoorlijk effectief. Het werkt zoals we het bedoeld hebben en geeft alles al correct weer. Desondanks, als je het spel aan een speler hebt gegeven en ermee akkoord hebt gegaan, kunnen ze misschien niet precies aangeven hoeveel punten ze van elke groep hebben verdiend, omdat het spel snel kan bewegen.
Om dit probleem op te lossen, gaan we tekstpop-ups toevoegen die aangeven hoeveel punten de speler maakt uit groepen die ze vormen. Dit voegt extra visuele flair toe aan het spel en het zal de speler duidelijk maken hoe waardevol grotere groepen kunnen zijn.
Voordat we kunnen beginnen met het toevoegen van de functionaliteit, moeten we een nieuw object maken dat zal fungeren als de tekst pop-up, dus volg deze stappen.
Accentsconagua
FloatingPointsText Game Field 616, 250 127, 43 0 Calibri, Bold, 24 255, 255, 255 1.25.Het object dat we zojuist hebben gemaakt, zal worden gebruikt om de zwevende tekst te maken die de speler vertelt hoeveel punten een bepaalde groep ze zal geven. Nu we dit object daadwerkelijk hebben, moeten we het zo implementeren dat wanneer de speler een overeenkomst maakt, het een nieuw exemplaar van het object zal uitzetten en de tekst zal veranderen om het juiste aantal punten te tonen.
Om de puntentekst te laten spawnen, voegen we twee nieuwe acties toe aan de NumMatchesFound controles in de FindMatches functie.
Ga naar de FindMatches functie en voeg deze twee acties toe aan het einde van elk NumMatchesFound> 3 controleren:
Actie: Systeem> Object maken Object = FloatingPointsText Layer = 2 X = Block.X - Block.Width / 2 Y = Block.Y - Block.Width / 2 Action: FloatingPointsText> Set Text Text = NumMatchesFound * 10
Jouw FindMatches functie zou er nu als volgt uit moeten zien:
Dus wat doen deze acties? De eerste actie maakt de FloatingPointsText object bovenop het eerste blok in de groep, en het tweede blok vermenigvuldigt het aantal blokken in de groep met 10, net zoals onze puntenformule dat doet, en stelt de tekst van het nieuwe object in op dat getal.
Als je het spel nu uitvoert, zou je moeten opmerken dat de tekst helemaal niet beweegt. Om dit probleem op te lossen gaan we een nieuw evenement aan onze game toevoegen.
Ga terug naar Evenementblad 1 en voeg een nieuw evenement toe:
Voorwaarde: Systeem> Elke tikactie: FloatingPointsText> Verplaatsen onder een hoek Hoek = -90 Afstand = 0,25
Je nieuwe evenement zou er als volgt uit moeten zien:
Als je het spel nu uitvoert, zul je zien dat de tekst wel beweegt.
Op dit punt, onze FloatingPointsText werkt zoals wij het willen, maar u hebt misschien een klein probleem opgemerkt nu het systeem is geïnstalleerd. Het probleem zelf komt voort uit de manier waarop het koppelingssysteem werkt, en nu we kunnen zien dat er nog steeds een probleem is met het matchen, kunnen we dit laatste probleem oplossen en ons aanpassingssysteem op bed leggen.
Als je nog niet weet wat voor probleem ik het heb, ga dan in het spel en maak een groep die vier blokken bevat. Zodra je groep is gemaakt, zou je iets moeten zien dat lijkt op wat ik heb in de onderstaande afbeelding:
Zoals je ziet hebben we dat eigenlijk wel twee exemplaren van de zwevende tekstobjecten. Als je een groep met vijf blokken maakt, wordt het probleem alleen maar erger en zie je drie exemplaren van de puntentekst.
De reden voor dit probleem is gebaseerd op de manier waarop overeenkomsten worden gedetecteerd. Op dit moment kijkt ons koppelingssysteem elk blok afzonderlijk en kijkt in de goede richting en de neerwaartse richting om overeenkomsten te vinden. Daarom vindt het matching-systeem hier eigenlijk drie groepen van verschillende grootte, hoewel het eigenlijk slechts één grote groep is.
De eerste groep wordt gevonden wanneer deze begint met Blok A en bevat vijf blokken:
De tweede groep wordt gevonden wanneer deze begint met Blok B en bevat vier blokken:
En de derde groep wordt gevonden wanneer deze begint met Blok C en bevat drie blokken:
Dus, op dit moment is ons koppelingssysteem erg inefficiënt - en gebroken - omdat het dezelfde blokken meerdere keren controleert en meer groepen registreert dan er daadwerkelijk zijn.
Het oplossen van dit probleem is eigenlijk veel eenvoudiger dan het in eerste instantie lijkt.
Het probleem komt hier vooral voort uit het feit dat het koppelingssysteem niet weet of het blok waarmee het begint eigenlijk het begin van de groep is. Als we konden garanderen dat we alleen naar blokken keken die het verst naar rechts of het hoogste waren, binnen de groepen waartoe ze behoorden, dan zou het koppelingssysteem effectief zijn zoals het is.
Dus het enige wat we moeten doen is een voorwaarde of gebeurtenis toevoegen die ervoor zorgt dat er geen overeenkomende blokken boven of links van het blok waar we mee beginnen, en om de functie te vertellen wanneer deze controle is uitgevoerd, zodat deze kan ga normaal verder als het blok waar het naar kijkt het begin van de groep is.
Het eerste dat we zullen toevoegen is een nieuwe parameter voor de CheckMatches functie. Deze parameter is een geheel getal en dat zal het ook zijn 1 of 0.
Als de parameter is 1, het geeft de functie aan dat het de controle moet uitvoeren om er zeker van te zijn dat het naar het eerste blok in de groep kijkt; als het is 0, het geeft aan de functie die het heeft nu al heeft deze controle uitgevoerd en kan normaal doorgaan om te bepalen of de groep uit drie of meer blokken bestaat.
Dus begin met naar de FindMatches functie. In deze functie bel je CheckMatches tweemaal. Omdat dit de eerste keer is dat u belt CheckMatches voor welk blok je ook kijkt, je moet een nieuwe parameter toevoegen aan elk van deze functieaanroepen en deze instellen 1 zodat het controleert of het blok waarnaar wordt gekeken het begin van een groep is.
Jouw FindMatches De functie zou er nu zo uit moeten zien en ik heb de twee gewijzigde uitspraken voor uw gemak gemarkeerd:
Nu vertellen we het CheckMatches Wanneer deze nieuwe controle moet worden uitgevoerd, moeten we de nieuwe cheque toevoegen om deze uit te voeren. Ga naar je CheckMatches functie, en voeg dit nieuwe sub-evenement toe als het eerste sub-evenement:
Evenement: Blok> Vergelijk X Comaprison = Gelijk aan X = Functie.Param (0) - ((Block.Width + 2) * Function.Param (3)) Voorwaarde: Blok> Vergelijk Y Comaprison = Gelijk aan Y = Function.Param (1) - ((Block.Width + 2) * Function.Param (4)) Voorwaarde: Functie> Vergelijk parameter Index = 5 Vergelijking = Gelijk aan Waarde = 1
Voordat u klaar bent met het wijzigen van de CheckMatches functie moet je ook een Else statement toevoegen aan de bovenkant van de originele event voor de CheckMatches functie, en u moet de nieuwe parameter toevoegen aan de CheckMatches functieaanroep en stel deze in op 0.
De nieuwe code voor de CheckMatches-functie zou er als volgt uit moeten zien:
Het evenement dat we hebben toegevoegd, doet precies wat ik hierboven heb beschreven. Eerst kijkt het naar het blok boven of links van het eerste blok dat je passeert.
Als dat blok dezelfde kleur heeft als degene die je hebt ingevoerd, doet het niets omdat het weet dat het blok dat je hebt doorgegeven niet het eerste blok in die groep is.
Aan de andere kant, als dat zo is niet dezelfde kleur als het blok dat je hebt ingevoerd, de oorspronkelijke controle gebeurt vanwege de Else-verklaring die we zojuist hebben toegevoegd, en het zoekt naar een groep van drie of meer blokken zoals normaal.
Als je de game op dit moment test en een groep met meer dan drie blokken maakt, zou je slechts één zwevend tekstobject moeten zien dat aangeeft hoeveel punten die groep waard was.
Nu we al deze functies hebben opgelost en we eindelijk ons koppelingssysteem hebben voltooid, zijn we klaar om het bewegingssysteem te implementeren. Omdat we al veel hebben gedaan in deze tutorial en omdat het bewegingssysteem ons vereist om meerdere complexe systemen te maken, zal ik wachten tot het volgende artikel om het bewegingssysteem te starten.
Als je ernaar verlangt eraan te gaan werken, overweeg dan een paar van deze dingen. Het eerste dat je hoeft te doen is natuurlijk de beweging zelf implementeren. Gebruik daarvoor een soortgelijk systeem als wat we gebruikten bij het laten zweven van de punten van tekstobjecten. Ga vanaf daar nadenken over hoe je de snelheid zou veranderen waarmee ze bewegen. Tot slot, hoe gaat u nieuwe rijen blokken genereren voor de speler en hoe weet u dat wanneer om nieuwe rijen te genereren?
Neem even de tijd om deze dingen te overwegen, en ik zie je volgende week terug voor de volgende grote aflevering van de serie.
