Euclidean vektorer i Flash
en
Del
en
Del
Dette Cyber mandag Envato Tuts + kurs vil bli redusert å bare $ 3. Ikke gå glipp av.
Dette innlegget er en del av en serie som heter You Do The Math.Playing Around med Elastic CollisionsGravity in Action
To ganger i måneden, vi besøker noen av våre lesere favoritt innlegg fra Activetuts + historie. Denne ukens retro-Active tutorial, utgitt første gang i april, er en guide til euklidske vektorer. Hva de er, hvorfor du vil bruke dem, og hvordan de skal implementere dem i Flash med AS3
euklidske vektorer er objekter i geometri med visse egenskaper som er svært nyttig for å utvikle spill. De kan bli sett på som punkter, men de har også en størrelse og en retning. De er representert som pilene går fra startpunktet til sluttpunktet, og det er slik vi vil trekke dem i denne artikkelen.
euklidske vektorer blir ofte brukt i matematikk og fysikk for mye ting: de kan representere hastighet, akselerasjon og krefter i fysikk, eller hjelpe bevise en rekke viktige teoremer i matematikk. I denne opplæringen vil du lære om euklidske vektorer, og bygge en klasse som du kan bruke i din egen flash prosjekter.
Vær oppmerksom på at euklidske vektorer er annerledes enn Action er Vector klasse, og også annerledes enn vektortegning .
vektorer kan brukes i Flash miljø for å hjelpe deg å oppnå komplekse oppgaver som ellers ville kreve mye arbeid hvis gjort uten dem. I denne artikkelen vil du lære hvordan du bruker dem i Flash, samt lære en masse kule triks med vektorer
Trinn 1:. Kartesiske koordinater og Flash koordinater
Før hopping i vektorer, la oss introdusere Flash koordinatsystem. Du er sikkert kjent med det kartesiske koordinatsystem (selv om du ikke vet det ved navn):
Flash system er svært like. Den eneste forskjellen er at y-aksen er opp-ned:
Når vi begynner å arbeide med vektorer i flash, må vi huske at. Men gode nyheter: dette annet system gjør ikke mye forskjell. Arbeide med vektorer i det vil være utgangspunktet som arbeider med vektorer i det kartesiske system
Trinn 2:. Definere en Vector
For hensikten med denne opplæringen, vil vi definere og arbeid med alle vektorer 'første poeng som blir registreringspunkt på scenen, akkurat som de er vanligvis brukes i matematikk. En vektor vil da bli definert på samme måte som et felles punkt, men det vil ha størrelse og vinkel egenskaper. Ta en titt på noen eksempel vektorer definert i den fasen:
Som du ser, en vektor er representert ved en pil, og hver vektor har en viss lengde (eller magnitude Vi vil lage en enkel EuclideanVector klasse for denne opplæringen, med Punkt klasse for å holde vektor koordinater. La oss lage basisvektoren klasse nå: I denne opplæringen, vil vi snakke om forstand Hotell og retning I denne opplæringen vil vi bruke uttrykket "inverse av en vektor" . Den inverse av en vektor er en annen vektor med samme størrelse og retning, men en motsatt forstand. Som oversetter til en vektor med det motsatte signalet til den første vektor koordinater. . Slik at en vektor med et endepunkt av (x, y) ville ha en invers vektor med et endepunkt av (-x, -y) La oss legge til en funksjon i vår EuclideanVector klassen for å returnere den inverse vektor: Nå som Vi har lært hvordan man definerer en vektor, la oss lære hvordan du legger til to vektorer: det er så enkelt som å legge sine koordinater separat. Se på dette bildet: Hvis du legger merke til i bildet, et resultat av tillegg av to vektorer er en annen vektor, og du kan se at dets koordinater er summen av koordinatene til de to andre vektorer. I kode, ville det se slik ut: Så vi kan si at: subtraksjon fungerer nesten det samme som tillegg, men i stedet vil vi legge til inverse Det er allerede kjent hvordan å oppsummere to vektorer, så her er koden for subtraksjon. Denne koden er svært nyttig å få en vektor som går fra det punktet av en vektor til poenget med en annen. Se igjen på bildet og du vil se at dette er sant. Den vil bli brukt mye i de senere eksemplene multiplikasjon mellom en vektor og et tall (vanlige tall er kjent som " scalars "i vektor matematikk) resulterer i en vektor som har hatt størrelse multiplisert med dette tallet, men fremdeles peker i samme retning; Det er "strukket" dersom skalare er større enn 1, og klemt hvis skalare er mellom 0 og 1. følelse av nye vektoren vil være den samme som den opprinnelige vektoren dersom skalar er positiv, eller motsatt hvis negative. I utgangspunktet dette nummeret "skalerer" vektoren. Se på bildet: I koden, vi bare multiplisere en vektor koordinater med antall, som da vil skalere vektoren: For å få en vektor magnitude, vil vi bruke Pythagoras 'læresetning. Hvis du har glemt hva er det, her er en rask oppfriskning: (Mer info her.) Koden er veldig enkel: Du bør også fjerne linjen offentlig Var magnitude: Antall, så dette er hva vi skal bruke fra nå Omfanget av en vektor vil alltid være positive, siden det er kvadratroten av summen av to positive tall Vinkelen på en vektor er vinkelen mellom x-aksen og vektoren retning linje. Vinkelen måles går fra x-aksen og roterer mot klokken til tangentlinjen i kartesisk system: Men i Flash koordinatsystem, siden y-aksen er opp ned, vil denne vinkelen være målt medurs: Dette kan enkelt beregnes ved hjelp av følgende kode. Vinkelen vil bli returnert i radianer, i et område fra 0 til 2 pi. Hvis du ikke vet hva radianer er eller hvordan du bruker dem, vil denne opplæringen av Michael James Williams hjelpe deg mye dot produktet mellom to vektorer er et tall med tilsynelatende ingen betydning, men den har to nyttige bruksområder. La oss først ta en titt på hvordan dot produktet kan beregnes: Men det kan også fås ved hver vektor koordinater: dot produktet kan fortelle oss mye om vinkelen mellom vektorer: hvis det er positivt, da vinkelen i området fra 0 til 90 grader. Hvis det er negative, varierer vinkelen fra 90 til 180 grader. Hvis det er null, er vinkelen 90 grader. Det skjer fordi i den første formelen bare cosinus er ansvarlig for å gi prikk-produktet et "signal": størrelsene er alltid positiv. Men vi vet at en positiv cosinus betyr at vinkelen i området fra 0 til 90 grader, og så videre for negative cosinus og null. dot Produktet kan også brukes til å representere lengden av en vektor i retningen av den andre vektoren. Tenk på det som en projeksjon. Dette beviser extremelly nyttig i ting som Separering av Axis Theorem (SAT) og dens implementering i AS3 for dueller og respons i spill Her er den praktiske koden for å få prikk-produktet mellom to vektorer. Vinkelen mellom vektorer, som vist i trinn 9, kan gis ved prikk-produktet. Her er hvordan man skal beregne det: Det er også en annen måte å beregne vinkelen, noe som gir resultater mellom -pi og pi og beregner alltid vinkelen som går fra den første vektoren til den andre vektoren; Dette er nyttig når du ønsker å enkelt integrere med en skjerm objektets rotasjon (som varierer fra -180 til 180). Metoden fungerer ved å få vinkelen for begge vektorer, deretter trekke vinklene og arbeider på resultatet . Koden: Merk at denne vinkelen returnerer positivt hvis secondAngle Normalisering en vektor betyr å gjøre dens størrelse være lik en, samtidig som man beholder den retning og følelse av vektoren. For å gjøre det, multipliserer vi vektoren med 1 /størrelse. På den måten vil dens størrelse bli redusert eller økt, til 1. normal Formlene er avhengige av det faktum at, ettersom den normale alltid er vinkelrett på en vektor, vi trenger bare å endre rekkefølgen av x- og y-koordinatene og invertere en av dem for å få en normal. Følgende bilde viser prosessen: I bildet, Vec Og Koden er enkel For å rotere en vektor, antar vi at (0, 0) stilling (sitt første punktet) vil være rotasjonssenteret. Det roterte punkt er gitt ved følgende formel: er denne formelen oppnås ved å anvende en rotasjonsmatrise for den vektor. Vi ville gå utover omfanget av denne opplæringen hvis vi gikk inn i matrisen, og hvordan det fungerer, så jeg vil bare la formelen her Koden er ganske mye det samme. Dette er slutten på våre grunnleggende vektoroperasjoner. Hva vil du se neste er måter å bruke denne klassen å gjøre interessante ting. Her er vår klasse så langt: Handlingen begynner her. Avgjøre om et punkt ligger inne i et polygon eller ikke er et veldig interessant tema, og det er mange metoder for å oppnå det. I denne artikkelen vil jeg presentere tre metoder som vanligvis brukes: Alle disse algoritmene vil stole på det faktum at du vet koordinatene til knutepunktene (hjørner) som definerer polygon. Denne algoritmen kan brukes til hvilken som helst form. Dette er hva du leser: enhver form, har det hull eller ikke, det være seg konveks eller ikke. Den er basert på det faktum at enhver ray kastet fra det punktet du ønsker å sjekke ut til uendelig vil krysse et likt antall kanter hvis poenget er utenfor form, eller odde antall kanter hvis poenget er inne i formen. Dette kan bevises ved Jordan kurve teorem, som innebærer at du er nødt til å krysse en grense mellom noen region og annen region hvis du ønsker å flytte fra den ene til andre. I vårt tilfelle, våre regioner er "inne i form" og "utenfor shape" Koden for denne algoritmen er følgende:. Det vil returnere false hvis poenget er ikke inne i formen, eller true hvis poenget er inne i formen svingete antall algoritme Koden benytter varierte vinkel mellom vektorer og gir plass for imprecisions: Legg merke til hvordan vi sjekker resultatene av summen av alle vinkler. Vi sjekker ikke om vinkelen er nøyaktig null eller 2pi. I stedet sjekker vi om det er mindre enn pi og høyere enn pi, en betydelig medianverdi konkav polygon algoritme Tenk deg å stå i et rom formet som bildet ovenfor, og vandre rundt kantene på den med venstre hånd følgende langs veggen. På det punktet langs veggen hvor du er nærmest til det punktet du er interessert i, om det er på høyre side så det må være inne i rommet; hvis det er på din venstre side så det må være utenfor. Problemet ligger i å avgjøre om et punkt er til venstre eller høyre for en kant (som er utgangspunktet en vektor). Dette gjøres gjennom følgende formel: At formelen returnerer et tall mindre enn 0 for poeng til høyre for kanten, og større enn 0 for poeng til venstre for det. Hvis tallet er lik 0, ligger punktet på kanten, og er ansett som innsiden av formen. Koden er følgende: Denne koden fungerer uavhengig av om du har figurens hjørner definert med eller mot klokken Ray avstøpning er en teknikk som ofte brukes for dueller og rendering. Den består av en stråle som er støpt fra ett punkt til et annet (eller ut til uendelig). Dette ray er laget av punkter eller vektorer, og generelt stopper når den treffer en gjenstand eller kanten av skjermen. Tilsvar til punkt-i-form algoritmer, det er mange måter å kaste stråler, og vi vil se to av dem i dette innlegget: to trinn vil vi se nærmere på begge metodene. Etter det, vil vi se hvordan å gjøre vår ray stopp når den treffer en gjenstand. Dette er svært nyttig når du trenger å oppdage kollisjon mot rask bevegelse Denne algoritmen brukes veldig ofte i datagrafikk, og avhenger konvensjonen at linjen vil alltid bli opprettet peker til høyre og nedover. (Hvis en linje må være opprettet for å opp- og venstre retninger, alt er invertert senere.) La oss gå inn i koden: Koden vil produsere en AS3 Vektor av euklidske vektorer som vil gjøre linjen. Med denne Vector, kan vi senere se etter kollisjoner En innføring av Digital Differential Analyzer Denne koden vil også returnere en AS3 Vektor av euklidske vektorer Oppdatering kollisjon via stråler er veldig enkel. . Siden en stråle består av mange vektorer, vil vi se etter kollisjoner mellom hver vektor, og en form, inntil det oppdages en eller enden av strålen er nådd. I følgende kode, vil shapeToCheck være en form akkurat som de vi har brukt i trinn 13-16. Her er koden: Du kan bruke hvilket som helst punkt-inne-shape funksjon du føler deg komfortabel med, men ta hensyn til begrensningene i den siste Du er klar til å begynne å bruke denne kunnskapen overalt nå! Det vil være nyttig mange ganger, og vil spare deg for mye ekstra beregninger når du prøver å gjøre mer komplekse ting i Flash.
) og poeng langs en viss vinkel
. Halen av hver vektor er ved registreringen punktet (0, 0).
pakke {import flash.geom.Point; public class EuclideanVector {public Var posisjoner: Point; offentlig Var magnitude: Number; offentlig Var vinkel: Number; offentlig funksjon EuclideanVector (endepunkt: Point) {stilling = endepunkt; }}}
av en vektor. Legg merke til at retningen bare definerer en linje som "inneholder" vektoren. Den forstand er det som definerer hvilken vei vektorpunkter langs denne linjen
Trinn 3:. Inverse av en Vector
offentlig funksjon inverse (): EuclideanVector {return new EuclideanVector (ny Point (-position.x, -position.y));}
Trinn 4: Grunnleggende bruk Addition
offentlig funksjon sum (otherVector: EuclideanVector): EuclideanVector {position.x + = otherVector.position.x; position.y + = otherVector.position.y; returnere dette;}
vecR == vec1.sum (vec2);
Trinn 5: Grunnleggende bruk subtraksjon
av den andre vektoren til den første vektoren
offentlig funksjon subtrahere (otherVector: EuclideanVector): EuclideanVector {position.x - = otherVector.position.x; position.y - = otherVector.position.y; returnere dette;}
Trinn 6:. Grunnleggende bruk multiplikasjon av et nummer
offentlig funksjon multiplisere (tall: Number): EuclideanVector {position.x * = antall; position.y * = antall; returnere dette;}
Trinn 7: Få en Vector magnitude
offentlig funksjon magnitude (): Antall {return Math .sqrt ((position.x * position.x) + (position.y * position.y));}
Trinn 8:.. Å få Vinkel en Vector
offentlig funksjon vinkel (). Number {var vinkel: Number = Math.atan2 (position.y , position.x); if (vinkel < 0) {vinkel + = Math.PI * 2; } Avkastning vinkel;}
Trinn 9: Dot Product
offentlig funksjon dot (otherVector: EuclideanVector): Antall {return (position.x * otherVector.position.x) + (position.y * otherVector.position.y);}
Trinn 10: Minste Angle Between Vektorer
offentlig funksjon angleBetween (otherVector: EuclideanVector): Antall {return Math.acos (dot (otherVector) /(magnitude () * otherVector.magnitude ()));}
Trinn 11: Varierte vinkel mellom vektorer
offentlig funksjon rangedAngleBetween (otherVector: EuclideanVector): Antall {var firstAngle: Number; Var secondAngle: Number; Var vinkel: Number; firstAngle = Math.atan2 (otherVector.position.y, otherVector.position.x); secondAngle = Math.atan2 (position.y, position.x); vinkel = secondAngle - firstAngle; while (vinkel > Math.PI) vinkel - = Math.PI * 2; while (vinkel < -Math.PI) vinkel + = Math.PI * 2; returnere vinkel;}
er høyere enn firstAngle
, så i hvilken rekkefølge du får varierte vinkel vil påvirke resultatet
!
Trinn 12: Normal en vektor
offentlig funksjon normalize (): EuclideanVector {var m: Number = magnitude (); position.x /= m; position.y /= m; returnere dette;}
Trinn 13: Få Normal av en Vector
av en vektor er en annen vektor som gjør en 90 graders vinkel i forhold til den første. Det kan beregnes ved hjelp av følgende formler:
er den opprinnelige vektoren, Vec2
er vektoren med Vec
's byttet koordinater, og Vec3
er en vektor med Vec2
's negativ y koordinat. Ang2
er variabel, men vinkelen mellom Vec Hotell og Vec3
er Ang Hotell og alltid 90 grader.
offentlig funksjon normalRight (): EuclideanVector {return new EuclideanVector (ny Point (-position.y, position.x));} offentlig funksjon normalLeft (): EuclideanVector {return new EuclideanVector (ny Point (posisjon. y, -position.x));}
Trinn 14: Roterende en Vector
Offentlig funksjon rotere (angleInRadians: Number): EuclideanVector {var newPosX: Number = (position.x * Math.cos (angleInRadians)) - (position.y * tak i Math.sin (angleInRadians)); Var newPosY: Number = (position.x * tak i Math.sin (angleInRadians)) + (position.y * Math.cos (angleInRadians)); position.x = newPosX; position.y = newPosY; returnere dette;}
pakke {import flash.geom.Point; public class EuclideanVector {public Var posisjoner: Point; offentlig Var vinkel: Number; offentlig funksjon EuclideanVector (endepunkt: Point) {stilling = endepunkt; } Offentlig funksjon inverse (): EuclideanVector {return new EuclideanVector (ny Point (-position.x, -position.y)); } Offentlig funksjon sum (otherVector: EuclideanVector): EuclideanVector {position.x + = otherVector.position.x; position.y + = otherVector.position.y; returnere dette; } Offentlig funksjon subtrahere (otherVector: EuclideanVector): EuclideanVector {position.x - = otherVector.position.x; position.y - = otherVector.position.y; returnere dette; } Offentlig funksjon multiplisere (tall: Number): EuclideanVector {position.x * = antall; position.y * = antall; returnere dette; } Offentlig funksjon magnitude (): Antall {return Math.sqrt ((position.x * position.x) + (position.y * position.y)); } Offentlig funksjon vinkel (): Antall {var vinkel: Number = Math.atan2 (position.y, position.x); if (vinkel < 0) {vinkel + = Math.PI * 2; } Returnere vinkel; } Offentlig funksjon dot (otherVector: EuclideanVector): Antall {return (position.x * otherVector.position.x) + (position.y * otherVector.position.y); } Offentlig funksjon angleBetween (otherVector: EuclideanVector): Antall {return Math.acos (dot (otherVector) /(magnitude () * otherVector.magnitude ())); } Offentlig funksjon rangedAngleBetween (otherVector: EuclideanVector): Antall {var firstAngle: Number; Var secondAngle: Number; Var vinkel: Number; firstAngle = Math.atan2 (otherVector.position.y, otherVector.position.x); secondAngle = Math.atan2 (position.y, position.x); vinkel = secondAngle - firstAngle; while (vinkel > Math.PI) vinkel - = Math.PI * 2; while (vinkel < -Math.PI) vinkel + = Math.PI * 2; returnere vinkel; } Offentlig funksjon normalize (): EuclideanVector {position.x /= magnitude (); position.y /= magnitude (); returnere dette; } Offentlig funksjon normalRight (): EuclideanVector {return new EuclideanVector (ny Point (-position.y, position.x)); } Offentlig funksjon normalLeft (): EuclideanVector {return new EuclideanVector (ny Point (position.y, -position.x)); } Offentlig funksjon rotate (angleInRadians: Number): EuclideanVector {var newPosX: Number = (position.x * Math.cos (angleInRadians)) - (position.y * tak i Math.sin (angleInRadians)); Var newPosY: Number = (position.x * tak i Math.sin (angleInRadians)) + (position.y * Math.cos (angleInRadians)); position.x = newPosX; position.y = newPosY; returnere dette; }}}
OK, vi har dekket bygge vektoren klasse, nå la oss ta en tok til å utnytte det
Trinn 15:. Avgjøre om en Point er Inne i en Polygon
krysset nummer
eller selv-odd regelen algoritme
, som avgjør om et punkt er inne i en polygon fra antall kanter som en "stråle" kastet fra punkt til uendelig kors.
svingete antall algoritme
, som gir svaret basert på summen av alle vinkler dannet mellom påfølgende punktene av en polygon og poenget å sjekke.
konveks polygon algoritme
, som, som navnet sier, fungerer bare for konvekse polygoner og er basert på hvorvidt en Poenget er på en viss "side" av hver kant av polygon.
Trinn 16: The Crossing nummer eller Even-Odd Rule Algoritme
Offentlig funksjon isPointInsideShape1 (punkt: EuclideanVector, shapeVertices. Vector < EuclideanVector >): boolske {var numberOfSides: int = shapeVertices.length; Var i: int = 0; Var j: int = numberOfSides - 1; Var oddNodes: Boolean = false; while (i < numberOfSides) {if ((shapeVertices [i] .position.y < point.position.y & & shapeVertices [j] .position.y > = point.position.y) || ( shapeVertices [J] .position.y < point.position.y & & shapeVertices [i] .position.y > = point.position.y)) {if (shapeVertices [i] .position.x + ( ((point.position.y - shapeVertices [i] .position.y) /(shapeVertices [J] .position.y - shapeVertices [i] .position.y)) * (shapeVertices [J] .position.x - shapeVertices [i] .position.x)) < point.position.x) {oddNodes = oddNodes!; }} J = i; i ++; } Returnere oddNodes;}
Trinn 17: The Winding Antall algoritme
.
bruke summen av alle vinklene er gjort mellom punktet for å sjekke, og hvert par av punktene som definerer polygon. Hvis summen er nær 2 pi, så det punktet blir sjekket er inne i vektoren. Hvis det er nær 0 da poenget er utenfor
offentlig funksjon isPointInsideShape2 (punkt: EuclideanVector, shapeVertices: Vector < EuclideanVector >.). Boolske {var numberOfSides: int = shapeVertices.length; Var i: int = 0; Var vinkel: Antall = 0; Var rawAngle: Antall = 0; Var firstVector: EuclideanVector; Var secondVector: EuclideanVector; mens (i < numberOfSides) {firstVector = nye EuclideanVector (ny Point (shapeVertices [i] .position.x - point.position.x, shapeVertices [i] .position.y - point.position.y)); secondVector = new EuclideanVector (ny Point (shapeVertices [(i + 1)% numberOfSides] .position.x - point.position.x, shapeVertices [(i + 1)% numberOfSides] .position.y - point.position.y) ); vinkel + = secondVector.rangedAngleBetween (firstVector); i ++; } If (Math.abs (vinkel) < Math.PI) return false; annet return true;}
Trinn 18:. Den konkave Polygon Algoritmen
avhengig av det faktum at, for en konkav polygon, er et punkt innenfor det alltid til venstre for kanten (hvis vi looping gjennom dem i en retning mot klokken forstand) eller til høyre av kantene (hvis vi looping gjennom dem i klokkens forstand).
offentlig funksjon isPointInsideShape3 (punkt: EuclideanVector, shapeVertices: Vector < EuclideanVector >.): Boolean {var numberOfSides: int = shapeVertices.length; Var i: int = 0; Var firstEdgePoint: EuclideanVector; Var secondEdgePoint: EuclideanVector; Var leftOrRightSide: Boolean; while (i < numberOfSides) {firstEdgePoint = shapeVertices [i]; secondEdgePoint = shapeVertices [(i + 1)% numberOfSides]; if (i == 0) {//Avgjøre hvis poenget er til venstre eller til høyre for første kanten //sant for venstre, falsk for retten leftOrRightSide = ((point.position.y - firstEdgePoint.position.y) * (secondEdgePoint.position.x - firstEdgePoint.position.x)) - ((point.position.x - firstEdgePoint.position.x) * (secondEdgePoint.position.y - firstEdgePoint.position.y)) > 0; } Else {//Nå er alle kanter må være på samme side if (leftOrRightSide & & ((point.position.y - firstEdgePoint.position.y) * (secondEdgePoint.position.x - firstEdgePoint.position.x)) - ((point.position.x - firstEdgePoint.position.x) * (secondEdgePoint.position.y - firstEdgePoint.position.y)) < 0) {//Ikke alle kanter er på samme side! return false; } Else if (leftOrRightSide & & ((point.position.y - firstEdgePoint.position.y) * (secondEdgePoint.position.x - firstEdgePoint.position.x)) - ((point.position.x - firstEdgePoint!. position.x) * (secondEdgePoint.position.y - firstEdgePoint.position.y)) > 0) {//Ikke alle kanter er på samme side! return false; }} I ++; } //Vi loopet gjennom alle hjørnene og ikke oppdage ulike sider return true;}
Step. 19: Ray Casting
Bresenham linje algoritme, som er en veldig rask måte å bestemme nære punkter, som vil gi en tilnærming av en linje mellom dem i den neste.
DDA (Digital Differential Analyzer) -metoden, som også brukes til å opprette en linje.
Trinn 20:. Den Bresenham Line Algoritme
offentlig funksjon createLineBresenham (startVector: EuclideanVector, endVector: EuclideanVector):. Vector < EuclideanVector > { Var punkter: Vector < EuclideanVector >. = New Vector. ≪ EuclideanVector > (); Var bratt: Boolean = Math.abs (endVector.position.y - startVector.position.y) > Math.abs (endVector.position.x - startVector.position.x); Var byttet: Boolean = false; if (bratt) {startVector = new EuclideanVector (ny Point (startVector.position.y, startVector.position.x)); endVector = new EuclideanVector (ny Point (endVector.position.y, endVector.position.x)); } //Making linjen går nedover if (startVector.position.x > endVector.position.x) {var midlertidig: Number = startVector.position.x; startVector.position.x = endVector.position.x; endVector.position.x = midlertidig; midlertidig = startVector.position.y; startVector.position.y = endVector.position.y endVector.position.y = midlertidig; byttet = true; } Var DeltaX: Number = endVector.position.x - startVector.position.x; Var deltaY: Number = Math.abs (endVector.position.y - startVector.position.y); Var error: Number = DeltaX /2; Var currenty: Number = startVector.position.y; Var trinnet: int; if (startVector.position.y < endVector.position.y) {trinn = 1; } Else {step = 1; } Var iterator: int = startVector.position.x; while (iterator < endVector.position.x) {if (bratt) {points.push (ny EuclideanVector (ny Point (currenty, iterator))); } Else {points.push (ny EuclideanVector (ny Point (iterator, currenty))); } Error - = deltaY; if (error < 0) {currenty + = trinn; error + = DeltaX; } Iterator ++; } If (byttet) {points.reverse (); } Returpunkter;}
Trinn 21:. Den DDA Method
brukes til å interpolere variabler mellom to punkter. I motsetning til Bresenham linje algoritme, vil denne metoden bare lage vektorer i heltall stillinger for enkelhet. Her er koden:
offentlig funksjon createLineDDA (startVector: EuclideanVector, endVector: EuclideanVector):. Vector < EuclideanVector > {var punkter: Vector < EuclideanVector >. = New Vector. ≪ EuclideanVector > (); Var dx: Number; Var dy: Number; Var _x: Antall = startPoint.position.x; Var _y: Number = startPoint.position.y; Var m: Number; Var i: int; dx = endPoint.position.x - startPoint.position.x; dy = endPoint.position.y - startPoint.position.y; if (Math.abs (dx) > = Math.abs (dy)) m = Math.abs (dx); annet m = Math.abs (dy); points.push (ny EuclideanVector (ny Point (int (_x), int (_y)))); i = 1; while (i < = m) {_x + = dx /m; _y + = dy /m; points.push (ny EuclideanVector (ny Point (int (_x), int (_y)))); i ++; } Returpunkter;}
Trinn 22: Ser etter kollisjoner Bruke Rays
offentlig funksjon checkRayCollision (ray. Vector < EuclideanVector >, form: Vector < EuclideanVector >.): Boolean {var rayLength: int = ray.length; Var i: int = 0; while (i < rayLength) {if (isPointInsideShape1 (ray [i], form)) {return true; } I ++; } Return false;!}
Konklusjon