[Java] bewegend object; van a naar b(eter)

[Verwijderd]

Ik heb een aplett gemaakt waarin ik een object van punt a naar punt n kan laten bewegen. Deze code ziet er als volgt uit.

Java:

    public void DoAnimation()
    {
    if(this.getX() <heading[heading_index].getX() )
    {
            x += movementSpeed;     
    }
    if(this.getY() < heading[heading_index].getY())
        {
            y += movementSpeed; 
        }
    if(this.getX() >heading[heading_index].getX() )
    {
            x -= movementSpeed;     
    }
    if(this.getY() > heading[heading_index].getY())
        {
            y -= movementSpeed; 
        }
    if (distance(heading[heading_index])< 1){
            if (heading_index+1 < heading_count)
            {
                
                heading_index += 1;
            }
            else
            {
                heading_index = 0;
            }
        }   
    
    }

De code functioneert aardig maar toch wil ik zelf nog wat meer optimalisatie toepassen. Nu heb ik al de point classe helemaal uitgeplozen en niet veel gevonden. Waar ik naar opzoek ben is dit. Ik wil eigenlijk de if's die de richting bepalen vervangen door 1 i die de afstand tussen de point heading en zich zelf vermindert met n en m stappen. Ik zit zelf te denken aan een pythagoras functie die de nieuwe afstand tussen het punt en zijn heading zet, alleen kan ik niet zomaar de afstand (point.distance()) zetten. Heeft iemand dus nog suggesties hoe ik dit voor elkaar krijg.

[Gert]

Je zou kunnen doen curX - this.X -> nieuweX = curX + resultaat en hetzelfde voor Y.
Dan heb je nog 0 if statements over, nouja, misschien een om te kijken of resultaatx en resultaaty niet allebei 0 zijn, want dant gebeurt er niets meer.

[Woy]

Waarom ga je niet met float's werken. Dan kan je bij het starten van je annimatie een DeltaX en een DeltaY ( oftewel je horizonale en verticale snelheid. ). Je kan dan per animatie ronde gewoon deze waardes bij de huidig X en Y optellen. Bij het tekenen kan je die dan gewoon afronden naar hele getallen.

Om het nog mooier te maken zou je de DeltaX en DeltaY nog elke keer kunnen schalen aan de hand van de verlopen tijd.

Je zou dan ongeveer zo iets krijgen.

Java:

public void Animatie()
{
    deltaX = 0.1;
    deltaY = 0.2;
    while( x < eindX && y < eindY )
    {
        aantalMilliseconden = GetAantalVerstrekenMilliseconden();
        x += deltaX * aantalMilliseconden;
        y += deltaY * aantalMilliseconden;
    }
}

je zou ook even naar Dit topic kunnen kijken.

[ Voor 36% gewijzigd door Woy op 29-12-2003 22:14 ]

[Verwijderd]

He

Voor een algoritme met demping kan je kijken in mijn thread:
[rml][ Algoritme] Pendulumania[/rml]

Hierin wordt door een paar mensen uitgelegt hoe het moet.
Het is niet in Java, maar volgens mij kan men er een hoop van leren

Groetjes

[hobbit_be]

veel beter zijn "easing" engines of keyframes.

voor actionscript :

http://www.robertpenner.com/easing/