Matematisk geni søges!

Jeg er ikke helt sikker på hvilken vinkel de vil have graderne for. Nu antager jeg det er vinklen mellem x-aksen og liniestykket bestemt ved de to punkter.

Udregningen er i stil med:

int findDegree(int x_origin, int y_origin, int x_target, int y_target){
int dx = x_target - x_origin;
int dy = y_target - y_origin;
int prik = dx * 1 + dy * 0; // kan selvfølgelig forkortes
double norm = sqrt(dx*dx + dy*dy);
double rad = acos(prik / norm);
int degree = 180 * rad / 3.1415;
return degree;
}

Det blev udnyttet at prikprodukt af to vektorer a og b (for henholdsvis x-akse og liniestykke) både kan skrives som: a_x * b_x + a_y * b_y
eller som: |a|*|b|*cos(v) hvor v er vinklen mellem de to vektorer. Udregningerne er nemmere da b er en enhedsvektor og har 0 i y-koordinaten.

Jeg forstår ikke denne linie, den vil da altid ende i 0 eller hvad ?

<< int prik = dx * 1 + dy * 0; // kan selvfølgelig forkortes

Jeg skriver \"dx * 1 + dy * 0\" så det er mere tydeligt at der er tale om prikprodukt/skalarprodukt. Men hvis jeg ganger dy med 0 bliver det jo altid 0 og hvis jeg ganger dx med 1 bliver det altid dx, så det havde været mere effektivt at skrive:
int prik = dx;
Men så havde det ikke været så nemt at forstå beregningerne der ligger bag.

Når programmet er til java skal du nok skrive Math.sqrt og Math.acos, men det havde du sikkert regnet ud.

Anders

Ok, jeg prøver det så snart jeg kommer hjem

i stedet for 3.1415 kan du bruge Math.PI:
int degree = 180 * rad / Math.PI;

Jeg har lavet følgende funktion nu, og den virker næsten, problemet er bare at uanset hvad returner den kun værdi mellem 0-180, ikke mellem 0-360

    public static int getAimDegree(int intSourceFigurePointer, String strTargetFigureName){

        int intTargetFigurePointer = getFigurePointerByName(strTargetFigureName);

        int x_target = (Integer.parseInt(spriteEngine.Figure[intTargetFigurePointer][spriteEngine.FIGURE_X_POS])/100);
        int y_target = (Integer.parseInt(spriteEngine.Figure[intTargetFigurePointer][spriteEngine.FIGURE_Y_POS])/100);

        int x_origin = (Integer.parseInt(spriteEngine.Figure[intSourceFigurePointer][spriteEngine.FIGURE_X_POS])/100);
        int y_origin = (Integer.parseInt(spriteEngine.Figure[intSourceFigurePointer][spriteEngine.FIGURE_Y_POS])/100);


        int dx = x_target - x_origin;
        int dy = y_target - y_origin;

        int prik = dx * 1 + dy * 0; // kan selvfølgelig forkortes
        double norm = Math.sqrt(dx*dx + dy*dy);
        double rad = Math.acos(prik / norm);
        double degree = 180 * rad / Math.PI;

        return (int) Math.floor(degree);
       

    }

Metoden som den står returnerer den mindste af de to vinkler mellem x-aksen og vektoren. Hvis dy<0 så peger vektoren nedad, så du skal trække resultatet fra 360 ved at erstatte de sidste linier med:

if (dy<0) return (360 - (int) Math.floor(degree));
return (int) Math.floor(degree);

Metoden returnerer nu vinklen målt i positiv omløbsretning, dvs vinklen fra x-aksen til vektoren mod uret.

Jeg fik det til at virke på en anden tilsvarende måde

hairball>

http://www.eksperten.dk/spm/23717
er vist ved at være ret gammelt...