Forumet - Hastighet vid linjär ekvation

Hastighet vid linjär ekvation

68 0 1
Anledningen till att jag postar min fråga här snarare än i vetenskapsforumet är att jag behöver hjälp med detta till ett programmeringsproblem. Jag känner mig aningen retarderad som inte lyckas klura ut det här själv, men jag känner på mig att det går fortare att fråga än att sitta och slita sitt hår i en evighet eller två.

Jag har en punkt som skall färdas från en punkt till en annan efter en rät linje.

Image

Om vi t.ex. tänker oss att vår punkt ska förflytta sig från punkt B till punkt A så löser jag detta ungefär såhär:
m = (A.y-B.y)/(A.x-B.x)
v = 100 --punktens hastighet
while True do
punkt.y = punkt.y - abs(m*v*dt) --dt står för delta time, alltså tiden som förflutit mellan förra iterationen och denna
if B.x > A.x then
punkt.x = punkt.x - v*dt
else
punkt.x = punkt.x + v*dt
end
end
Vad detta medför är att desto lägre delta-x (A.x-B.x) är, desto större blir rörelsen i Y-led. Med andra ord kanske det tar 100 iterationer för punkten att röra sig från B till C, men bara 10 mellan B och A - trots att avståndet mellan punkterna är ungefär detsamma. Jag skulle vilja att punkten rörde sig i samma hastighet, oavsett i vilken riktning den färdades.

Problemet är hur man löser detta. Därför vänder jag mig till er, som mycket troligt är vassare än jag på matte.

EDIT: Jag kom på att jag var lite dum i huvudet. Det vore ju betydligt mycket enklare att göra någonting i stil med:
punkt.x = punkt.x + cos( radians * (pi/180) )*v*dt
punkt.y = punkt.y + sin( radians * (pi/180) )*v*dt
Mitt problem nu är att jag inte vet hur man får ut antalet radianer utifrån en linjes lutning. [blush]

EDIT2: Jag har nu listat ut att:
atan((A.y-B.y)/( A.x-B.x))
ger radianer för vinkeln. Det fungerar dock inte ändå. Förstår inte vad det är jag gör fel. [sad]

Önskar att jag läst trigonometri...

EDIT3: WOHOO! Efter jordens största fulhack så lyckades jag lura min kod att fungera! För de som eventuellt är intresserade så ser min "lösning" ut såhär:projectiles.playershots[c].position.y = projectiles.playershots[c].position.y -math.abs(math.cos(projectiles.playershots[c].direction+math.rad(-90))*projectiles.p​​​layershots[c].v*dt)
projectiles.playershots[c].position.x = projectiles.playershots[c].position.x - math.sin(projectiles.playershots[c].direction+math.rad(-90))*projectiles.playershots​​​[c].v*dt

Spana också in:

Du kan inte lösa den typen av problem med pixelkoordinater. Använd vanlig vektormatte så är det ett enkelt problem att lösa:

Vvel = Normalize (Vend - Vstart) * speed
Vpos = Vstart
While (Vpos != Vend):
Vpos = Vpos + Vvel

Vvel är hastigheten per tidssteg, Vend är punkten du ska till, Vstart är punkten du startar på, speed är en skalär som anger hur många längdenheter punkten ska förflytta sig per tidssteg. Du lär bli tvungen att använda något i stil med While (NotWithinXUnitsOfEachOther(Vpos, Vvel, x)) för något lämpligt valt x istället för Vpos != Vend, eftersom det är ganska osannolikt att de kommer att bli exakt lika.

Då slipper du dessutom alla dyra multiplikationer du har i din senaste version; normaliseringen i början är dyr, men alla andra operationer är billiga. Vet du inte på förhand hur lång tid varje tidssteg kommer att ta är det bara att multiplicera Vvel med den faktiska tiden sedan förra uppdateringen. Då får du visserligen in en extra multiplikation för varje komponent i innerloopen, men du får betydligt bättre resultat än om du förlitar dig på att varje tidssteg kommer att köras på konstant tid.