Share
Vi er nå halvveis gjennom denne serien, og så langt har vi dekket mye. I den forrige veiledningen la vi til et poengsystem til vårt spill, og til slutt brukte vi "tyngdekraften" til blokkene, og vi forbedret vårt matchende system. I denne opplæringen skal vi gjøre noen små forbedringer i vårt bytte system, legg til flytende poengteksten du kan se i den endelige versjonen av spillet, og avslutt vårt samsvarende system en gang for alle.
Her er en demonstrasjon av spillet vi jobber med i denne serien:
Akkurat nå har spillet en veldig enkel bytte mekaniker implementert. Selv om systemet vi bruker for å utføre disse byttene, er svært effektivt, er det to problemer du kan støte på mens du spiller, og begge skal løst før vi går videre.
Disse problemene stammer fra den samme ideen: at byttesystemet ikke tar hensyn til spillfeltets grenser.
Hva betyr dette, akkurat? Vel, for det første, hvis du vil, kan du flytte en blokk utenfor spillfeltet til venstre eller høyre ved å bytte som den som er vist nedenfor:
Hvis du går inn i spillet og gjør dette byttet, vil du se at spillet ikke gjør noe for å stoppe deg, og fungerer som om spillfeltet fortsetter for alltid i en horisontal retning. Årsaken til dette er at, akkurat nå, spillfeltet gjør fortsett evig horisontalt.
Siden vi aldri har definert hvor venstre og høyre kant av spillfeltet er, eller til og med at spillfeltet har forlatt og høyre grenser, prøver spillet aldri å stoppe spilleren fra å flytte blokken videre til siden. Dette problemet kommer også opp når du bytter ut den andre kanten av spillfeltet også.
For å løse dette problemet legger vi til noen nye forhold til Blokker> På DragDrop-dråpe Begivenhet. Gå til denne hendelsen og legg til denne betingelsen for underarrangementet som sjekker om venstrebytter:
Tilstand: LeftBlock> Sammenlign X Sammenligning = Større eller lik X = SPAWNX
Legg nå denne betingelsen til underarrangementet som sjekker for riktige swaps:
Tilstand: HøyreBlock> Sammenlign X Sammenligning = Mindre eller lik X = SPAWNX + Block.Width * 8
Dine venstre og høyre bytte hendelser bør nå se slik ut:
Disse nye forholdene vi har lagt til, blir brukt av byttehendelsene som en sjekk for å sikre at byttet er innenfor de horisontale grensene til spillfeltet. Den første sikrer at stillingen blokken blir byttet til, ikke lenger til venstre enn de venstre blokkene, og den andre sikrer at stillingen blokken blir byttet til, ikke lenger til høyre enn høyre- de fleste blokker.
Med den andre brukte jeg en formel med Block.Width for å finne hvor de høyeste blokkene er å sikre at hvis størrelsen på blokkene endres, vil det ikke hindre at denne tilstanden virker.
Hvis du kjører spillet, bør du ikke lenger kunne lage horisontale swaps som ville sette blokker utenfor spillområdet.
Det andre problemet vi har er at spillet ikke stopper deg fra å bytte en blokk under spillfeltet. Åpne spillet og prøv å bytte som den jeg har illustrert i dette bildet:
Etter å ha gjort denne byttingen, burde du ha sett blokken stort sett bare forsvunnet bak bunndelen av spillfeltet, og blokkene som var over den, burde ha falt for å fylle inn det nå tomme rommet. Igjen er dette problemet fordi vi aldri har definert hvor den nederste kanten av feltet er.
I den tidligere opplæringen erklærte vi at blokkene skulle slutte å falle etter å ha nått en viss høyde, men vi sa aldri om det var greit for en blokk å gå under denne høyden når du utveksler en bytte.
Å fikse dette vil være like enkelt som de to foregående problemene. Gå til underarrangementet som sjekker for nedbytter, og legg til denne betingelsen:
Tilstand: BottomBlock> Sammenlign Y-sammenligning = Mindre eller lik Y = SPAWNY
Koden din for denne delen skal nå se slik ut:
På samme måte som den forrige tilstanden sikrer dette at byttet ikke ville plassere blokken inn i et område utenfor spillfeltet. I dette tilfellet ser det på området under spillfeltet.
Hvis du tester spillet ditt på dette tidspunktet, bør du nå ikke kunne lage swaps som legger blokkene under bunnen av spillfeltet.
På dette tidspunktet har vi løst problemene med byttesystemet, og kan fortsette å gjøre vårt poengsystem enda bedre.
Akkurat nå er vårt poengsystem ganske effektivt. Det fungerer som vi tenkte, og viser allerede alt riktig. Til tross for det, skjønt, hvis du ga spillet til en spiller og satte dem ned med det, kan de kanskje ikke fortelle nøyaktig hvor mange poeng de fikk fra hver gruppe de laget, siden spillet kan bevege seg raskt.
For å løse dette problemet skal vi legge til tekstoppslag som viser hvor mange poeng spilleren gjør fra alle grupper de danner. Dette vil legge til ekstra visuell flair til spillet, og det vil gjøre det klart for spilleren hvor verdifulle større grupper kan være.
Før vi kan begynne å legge til funksjonaliteten, må vi opprette et nytt objekt som vil fungere som tekst-popup, så følg disse trinnene.
Accentsconagua
FloatingPointsText Spillfelt 616, 250 127, 43 0 Calibri, Fet, 24 255, 255, 255 1,25.Objektet vi nettopp har laget, skal brukes til å lage flytende tekst som forteller spilleren hvor mange poeng en gitt gruppe vil gi dem. Nå som vi faktisk har dette objektet, må vi implementere det slik at når spilleren lager en kamp, vil den gyte en ny forekomst av objektet og endre teksten for å vise riktig antall poeng.
For å gyte poengteksten skal vi legge til to nye handlinger til NumMatchesFound sjekker i FindMatches funksjon.
Gå til FindMatches funksjon, og legg til disse to handlingene til slutten av hver NumMatchesFound> 3 kryss av:
Handling: System> Opprett objekt Objekt = FloatingPointsText Layer = 2 X = Block.X - Block.Width / 2 Y = Block.Y - Block.Width / 2 Action: FloatingPointsText> Angi teksttekst = NumMatchesFound * 10
Din FindMatches funksjonen skal nå se slik ut:
Så hva gjør disse handlingene? Den første handlingen skaper FloatingPointsText objekt øverst på den første blokken i gruppen, og den andre multipliserer antall blokker i gruppen med 10, akkurat som vår poengformel gjør, og setter teksten til det nye objektet til det nummeret.
Hvis du kjører spillet på dette punktet, bør du legge merke til at teksten ikke beveger seg i det hele tatt. For å fikse dette problemet skal vi legge til en ny Event i vårt spill.
Gå tilbake til Event Sheet 1 og legg til en ny hendelse:
Tilstand: System> Hver Tick-handling: FloatingPointsText> Flytt i vinkel Angle = -90 Avstand = 0.25
Din nye hendelse skal se slik ut:
Hvis du kjører spillet nå, vil du se at teksten beveger seg.
På dette punktet, vår FloatingPointsText Fungerer slik vi ønsker det, men du har kanskje lagt merke til et lite problem nå når systemet er på plass. Problemet i seg selv kommer fra hvordan samsvarende system fungerer, og nå som vi kan se at det fortsatt er et problem med samsvarende, kan vi sette om å fikse dette siste problemet, og sette vårt matchende system i seng.
Hvis du ikke vet hva problemet jeg snakker om, gå inn i spillet, og lag en gruppe som inneholder fire blokker. Når gruppen din er laget, bør du se noe som ligner på det jeg har i bildet nedenfor:
Som du kan se, har vi faktisk to forekomster av de flytende tekstobjektene. Hvis du lager en gruppe med fem blokker, blir problemet enda verre, og du vil faktisk se tre forekomster av punktteksten.
Årsaken til dette problemet er basert på måten kampanjer oppdages på. For øyeblikket ser vårt matchende system på hver blokk hver for seg, og ser i høyre retning og nedadgående retning for å finne kamper. På grunn av dette er det matchende systemet faktisk å finne tre forskjellige størrelsesgrupper her, selv om det egentlig bare er en stor gruppe.
Den første gruppen vil bli funnet når den starter med blokk A, og vil inneholde fem blokker:
Den andre gruppen vil bli funnet når den starter med blokk B, og vil inneholde fire blokker:
Og den tredje gruppen vil bli funnet når den starter med blokk C, og vil inneholde tre blokker:
Så, akkurat nå er vårt matchende system svært ineffektivt - og ødelagt - siden det er å sjekke de samme blokkene flere ganger og registrere flere grupper enn det egentlig er.
Å fikse dette problemet er faktisk mye enklere enn det kan virke først.
Problemet her stammer hovedsakelig fra det faktum at det matchende systemet ikke har mulighet til å vite om blokken den begynner med, er faktisk begynnelsen av gruppen. Hvis vi kunne garantere at vi bare så på Blokker som var lengst til høyre, eller høyest oppe, innenfor de gruppene de tilhørte, ville det tilsvarende systemet være effektivt som det er.
Så alt vi trenger å gjøre er å legge til en betingelse eller begivenhet som sikrer at det ikke er noen tilsvarende blokker over eller til venstre for blokken vi begynner med, og for å fortelle funksjonen når den har utført denne sjekken, slik at den kan fortsett normalt hvis blokken den ser på er starten på gruppen.
Det første vi legger til, er en ny parameter for CheckMatches funksjon. Denne parameteren vil være et heltall, og det vil være enten 1 eller 0.
Hvis parameteren er 1, det vil indikere for funksjonen som den trenger for å utføre sjekken for å sikre at den ser på den første blokk i gruppen; hvis det er 0, det vil indikere for funksjonen den har allerede utført denne sjekken, og kan fortsette normalt for å avgjøre om gruppen består av tre eller flere blokker.
Så, start med å gå til FindMatches funksjon. I denne funksjonen ringer du CheckMatches to ganger. Siden dette er første gang du ringer CheckMatches For hvilken blokk du ser på, må du legge til en ny parameter for hver av disse funksjonene samt sette den til 1 slik at den vil sjekke for å se om blokken den ser på er starten på en gruppe.
Din FindMatches funksjonen skal nå se slik ut, og jeg har fremhevet de to endrede setningene for enkelhets skyld:
Nå som vi forteller CheckMatches når den trenger å utføre denne nye kontrollen, må vi faktisk legge til den nye sjekken for at den skal utføres. Gå til din CheckMatches funksjon, og legg til denne nye delhendelsen som den første delhendelsen:
Begivenhet: Blokk> Sammenlign X Comaprison = Lige til X = Funksjon.Param (0) - ((Blokk.Width + 2) * Funksjon.Param (3)) Tilstand: Blokk> Sammenlign Y Comaprison = Lik til Y = Function.Param (1) - ((Block.Width + 2) * Function.Param (4)) Tilstand: Funksjon> Sammenlign parameter Indeks = 5 Sammenligning = Likeverdig = 1
Før du er ferdig med å endre CheckMatches funksjon du må også legge til en annen setning til toppen av den opprinnelige hendelsen for CheckMatches funksjon, og du må legge til den nye parameteren til CheckMatches funksjonsanrop og sett den til 0.
Den nye koden for CheckMatches-funksjonen skal se slik ut:
Hendelsen vi la til gjør akkurat det jeg beskrev ovenfor. Først ser det på blokken ovenfor, eller til venstre for, den første blokken du sender inn.
Hvis den blokken er den samme fargen som den du passerte inn, gjør den ingenting siden det vet at blokken du passerte inn, ikke er den første Blokken i den gruppen.
På den annen side, hvis det er ikke Den samme fargen som blokken du passerte inn, skjer den opprinnelige sjekken på grunn av Else-setningen vi nettopp har lagt til, og det ser ut til en gruppe på tre eller flere blokker slik det normalt ville.
Hvis du tester spillet på dette tidspunktet og lager en gruppe med mer enn tre blokker, bør du bare se ett flytende tekstobjekt som forteller deg hvor mange poeng denne gruppen var verdt.
Nå som vi er ferdig med å fikse alle disse funksjonene, og vi har endelig fullført vårt matchende system, er vi klare til å implementere bevegelsessystemet. Siden vi allerede har gjort mye i denne opplæringen, og siden bevegelsessystemet krever at vi gjør flere komplekse systemer, skal jeg vente til neste artikkel for å starte bevegelsessystemet.
Hvis du er ivrig etter å begynne å jobbe med det, bør du vurdere noen av disse tingene. Åpenbart er det første du må gjøre, å implementere bevegelsen selv. For det, prøv å bruke et lignende system til det vi brukte når punktene for tekstobjekter flytes. Derfra begynner du å vurdere hvordan du vil endre hastigheten som de beveger seg på. Til slutt, hvordan vil du generere nye rader med blokker for spilleren, og hvordan vil du vite det når å generere nye rader?
Ta deg tid til å vurdere disse tingene, og jeg vil se deg tilbake her neste uke for neste store avdrag av serien.
