GM'owe "bounce" w C++

Marcin1147 · 18 Grudnia 2009

Hej, mam taki kod:

void Odbij()    //Funkcja odbijania piłki
{
    randomize();    //Losowość
    int from=20;    //Ustaw zakres
    rands=random(from*2)-from;    //Losuj losową liczbę w przedziale od -20 do 20
    ball->direction+=180+(ball->direction*2)+rands;    //Odbijanie z losowym współczynnikiem
}

Problem mam z tą funkcją ponieważ nie zawsze działa jak należy, "świruje" itd.

Zmienna ball->direction i ball->speed działają tak ja w GM (mój patent) ale coś napisanie odpowiednika dla GM'owego "bounce" mi nie wychodzi :sp_ike:

PsichiX · 18 Grudnia 2009

GMowe bounce dziala na zasadzie kolizji masek. sprawdza ksztalt i na jego podstawie wylicza wektor normalny i wektor odbicia. a ze Ty masz obiekty jako kulki to latwo znajdziesz wektor normalny (jest on przedluzeniem promienia, przecinajacym sie z punktem gdzie nastapila kolizja na okregu kulki), wzor na wektor odbicia znajdziesz w sieci, nawet chyba pod pierwszym linkiem w googlach :)

(mój patent)

sprowadzę Cię na ziemię i powiem - nie ;p

Marcin1147 · 18 Grudnia 2009

Ale czy to trochę nie za trudne? :P

Oczekiwałem czegoś w stylu: ball->direction*=2; albo coś takiego ;/

PsichiX · 18 Grudnia 2009

no wlasnie nie jest to takie jak oczekiwales :P

Marcin1147 · 18 Grudnia 2009

A odbijanie się od powierzchni płaskiej tzn. leci na ścianę pod kątem 45, odbija się i odlatuje od ściany pod kątem 135? :P

E: Jeżeli to jednak niemożliwe poprosiłbym cię o podanie tego wektora odbicia bo w googlach jakoś nic nie mogę znaleźć: http://www.google.pl/search?q=wektor+odbicia

Will · 18 Grudnia 2009

R=I-2N(dot(N,L));

N-normalna

I-promień padania

Kofel · 18 Grudnia 2009

R=I-2N(dot(N,L));
N-normalna

I-promień padania

fajnie ze wyjaśniłeś dwie nazwy, ale co z resztą? szamanami jesteśmy?

Will · 19 Grudnia 2009

R=I-2N(dot(N,I));

N-normalna

I-promień padania

Mój błąd, żadnego L tam nie ma.

vec3 reflect(vec3 I,vec3 N)//wektor n powinien być znormlizowany

{

return I-2.0f*N*dot(N,I);

{

float dot(vec3 v1,vec3 v2)

{

return v1.x*v2.x+v1.y*v2.y+v1.z*v2.z;

}

Marcin1147 · 20 Grudnia 2009

Przepraszam, ale ten kod to chyba do 3d, bo skąd ja mam w 2d wziąć coś takiego jak Z? :P

PsichiX · 20 Grudnia 2009

to mnoz tylko 2 pierwsze: X i Y, Z w tym przypadku bedzie zawsze rowne 0

float dot(vec2 v1,vec2 v2)

{

return v1.x*v2.x+v1.y*v2.y

};

Marcin1147 · 20 Grudnia 2009

A w jakiej bibliotece jest ten typ vec2, vec3 - bo chyba nie w standardowych :P

PsichiX · 20 Grudnia 2009

sam mozesz je sobie zrobic. Korzysci z obiektowosci.

struct vec2

{

float x;

float y;

};

Marcin1147 · 20 Grudnia 2009

OMG dobra, to łatwiejsze niż myślałem :P

Wiesz Vec kojarzy mi się z wektorem, takim co ma pkt. zaczepienia kierunek, wartość i inne syfy :P

Ale skoro I to promień padania, to jak mam go wyrazić w X i Y?

PsichiX · 20 Grudnia 2009

generalnie kierunki lepiej trzymac w wektorach.

zawsze konwertuj kierunki obrotu na wektory za pomoca lengthdirs.

vec2 kierunek;

kierunek.x=lengthdir_x(direction,1);

kierunek.y=lengthdir_y(direction,1);

Marcin1147 · 20 Grudnia 2009

Czekaj, uaktualnie mój cudowny kod:

struct vec2
{
float x;
float y;
};

vec2 reflect(vec2 I,vec2 N)
{
return I-2.0f*N*dot(N,I);
{

float dot(vec2 v1,vec2 v2)
{
return v1.x*v2.x+v1.y*v2.y;
}

void Odbij()  
{
vec2 kierunek,nowy;
kierunek.x=lengthdir_x(ball->direction,1);
kierunek.y=lengthdir_y(ball->direction,1);
nowy=reflect(12,kierunek);
i_co_teraz();
}

PsichiX · 20 Grudnia 2009

musisz jeszcze zrobic przeciazenie operatora mnozenia dla vec2 (przy okazji reszte tez)

vec2& operator* (vec2& v1,vec2& v2)
{
vec2 temp;
temp.x=v1.x*v2.x;
temp.y=v1.y*v2.y;
return(temp);
};

vec2& operator/ (vec2& v1,vec2& v2)
{
vec2 temp;
temp.x=v1.x/v2.x;
temp.y=v1.y/v2.y;
return(temp);
};

vec2& operator+ (vec2& v1,vec2& v2)
{
vec2 temp;
temp.x=v1.x+v2.x;
temp.y=v1.y+v2.y;
return(temp);
};

vec2& operator- (vec2& v1,vec2& v2)
{
vec2 temp;
temp.x=v1.x-v2.x;
temp.y=v1.y-v2.y;
return(temp);
};

Marcin1147 · 20 Grudnia 2009

Czekaj, a co mam w takim razie wstawić w miejsce i_co_teraz(); aby przerobić ten hmm "wektor" spowrotem na ball->direction ?

PsichiX · 20 Grudnia 2009

point_direction() musisz sobie napisac. na forum nie raz byl poruszany o tym watek z tego co wiem

Marcin1147 · 20 Grudnia 2009

struct vec2
{
float x;
float y;
};

//pomijam operatory

vec2 reflect(vec2 I,vec2 N)
{
return I-2.0f*N*dot(N,I);
{

float dot(vec2 v1,vec2 v2)
{
return v1.x*v2.x+v1.y*v2.y;
}

int point_direction(int x1, int x2, int y1, int y2)
{
atan2(y2-y1,x2-x1) * 180 / M_PI; //korzystam z math.h
}

void Odbij()  
{
vec2 kierunek,nowy;
kierunek.x=lengthdir_x(ball->direction,1);
kierunek.y=lengthdir_y(ball->direction,1);
nowy=reflect(12,kierunek);
ball->direction=point_direction(nowy.x,nowy.y, -co tutaj-, -co tutaj-);
}

A co z x2, y2 :(

PsichiX · 20 Grudnia 2009

ball->direction=point_direction(0,0,nowy.x,nowy.y);

bo wektor kierunku to tylko kierunek, bez pozycji poczatkowej, a raczej pozycja ta lezy na [0,0]

Marcin1147 · 20 Grudnia 2009

Jezu, dzięki PsichiX że wytrzymałeś tyle czasu z takim noobem jak ja ^_^

Dam znać czy działa, i jeszcze raz dzięki.

PsichiX · 20 Grudnia 2009

zapomnialem jeszcze o operatorach dla vec2 z liczbami bez ktorych nie zadziala funkcja reflect:

vec2& operator* (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x*v2;
temp.y=v1.y*v2;
return(temp);
};


vec2& operator/ (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x/v2;
temp.y=v1.y/v2;
return(temp);
};


vec2& operator+ (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x+v2;
temp.y=v1.y+v2;
return(temp);
};


vec2& operator- (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x-v2;
temp.y=v1.y-v2;
return(temp);
};

Marcin1147 · 20 Grudnia 2009

We wszystkich funkcjach operatorów wywala takie coś:

Attempting to return a reference to local variable 'temp'

PsichiX · 20 Grudnia 2009

to jak zwraca "vec2&" zamien na "vec2" bez "&"

Marcin1147 · 20 Grudnia 2009

Brakuje mi jeszcze lengthdirów do C++, kiedyś widziałem to na GMClanie ale teraz nie mogę znaleźć!

PsichiX · 20 Grudnia 2009

float lengthdir_x(float len,float dir)
{
return(cos(degtorad(dir))*len)
};

float lengthdir_y(float len,float dir)
{
return(sin(degtorad(dir))*len)
};

Marcin1147 · 20 Grudnia 2009

Ok, mam takie coś:

//
//Początek GMCLAN'owego syfa
//
struct vec2
{
float x;
float y;
};

vec2 operator* (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x*v2;
temp.y=v1.y*v2;
return(temp);
};

vec2 operator/ (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x/v2;
temp.y=v1.y/v2;
return(temp);
};

vec2 operator+ (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x+v2;
temp.y=v1.y+v2;
return(temp);
};

vec2 operator- (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x-v2;
temp.y=v1.y-v2;
return(temp);
};

float dot(vec2 v1,vec2 v2)
{
return v1.x*v2.x+v1.y*v2.y;
}

vec2 reflect(vec2 I,vec2 N)
{
return I-2.0f*N*dot(N,I);
}

int point_direction(int x1, int x2, int y1, int y2)
{
return(atan2(y2-y1,x2-x1) * 180 / M_PI);
}

double degtorad( double alfa) { return alfa * M_PI / 180; }

float lengthdir_x(float len,float dir)
{
return(cos(degtorad(dir))*len);
}

float lengthdir_y(float len,float dir)
{
return(sin(degtorad(dir))*len);
}

void Odbij()
{

vec2 srodek;
srodek.x=12;
srodek.y=12;

vec2 kierunek,nowy;
kierunek.x=lengthdir_x(ball->direction,1);
kierunek.y=lengthdir_y(ball->direction,1);
nowy=reflect(srodek,kierunek);
ball->direction=point_direction(0,0,nowy.x,nowy.y);
}
//
//Koniec GMCLAN'owego syfa
//

I wywala: Illegal structure operation tutaj:

vec2 reflect(vec2 I,vec2 N)
{

return I-2.0f*N*dot(N,I);

}

PsichiX · 20 Grudnia 2009

bo mususz miec operatory vec2<->float oraz vec2<->vec2, a ty masz tylko te pierwsze. zapomnaiels o drugich, dla tego nie moze wykonac dzialan wektora z wektorem.

Marcin1147 · 20 Grudnia 2009

//
//Początek GMCLAN'owego syfa
//
struct vec2
{
float x;
float y;
};

//Operatory wektor<->float
vec2 operator* (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x*v2;
temp.y=v1.y*v2;
return(temp);
};

vec2 operator/ (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x/v2;
temp.y=v1.y/v2;
return(temp);
};

vec2 operator+ (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x+v2;
temp.y=v1.y+v2;
return(temp);
};

vec2 operator- (vec2& v1,float& v2)
{
vec2 temp;
temp.x=v1.x-v2;
temp.y=v1.y-v2;
return(temp);
};
//Operatory wektor<->float

//Operatory wektor<->wektor
vec2 operator* (vec2& v1,vec2& v2)
{
vec2 temp;
temp.x=v1.x*v2.x;
temp.y=v1.y*v2.y;
return(temp);
};

vec2 operator/ (vec2& v1,vec2& v2)
{
vec2 temp;
temp.x=v1.x/v2.x;
temp.y=v1.y/v2.y;
return(temp);
};

vec2 operator+ (vec2& v1,vec2& v2)
{
vec2 temp;
temp.x=v1.x+v2.x;
temp.y=v1.y+v2.y;
return(temp);
};

vec2 operator- (vec2& v1,vec2& v2)
{
vec2 temp;
temp.x=v1.x-v2.x;
temp.y=v1.y-v2.y;
return(temp);
};
//Operatory wektor<->wektor

float dot(vec2 v1,vec2 v2)
{
return v1.x*v2.x+v1.y*v2.y;
}

vec2 reflect(vec2 I,vec2 N)
{
return I-2.0f*N*dot(N,I);
}

int point_direction(int x1, int x2, int y1, int y2)
{
return(atan2(y2-y1,x2-x1) * 180 / M_PI);
}

double degtorad( double alfa) { return alfa * M_PI / 180; }

float lengthdir_x(float len,float dir)
{
return(cos(degtorad(dir))*len);
}

float lengthdir_y(float len,float dir)
{
return(sin(degtorad(dir))*len);
}

void Odbij()
{

vec2 srodek;
srodek.x=12;
srodek.y=12;

vec2 kierunek,nowy;
kierunek.x=lengthdir_x(ball->direction,1);
kierunek.y=lengthdir_y(ball->direction,1);
nowy=reflect(srodek,kierunek);
ball->direction=point_direction(0,0,nowy.x,nowy.y);
}
//
//Koniec GMCLAN'owego syfa
//

Ten sam error!

Will · 20 Grudnia 2009

Boże, nie przekazuj float'a przez referencje toż to zbrodnia przeciw szybkości działania twojego programu a do tego w tym wypadku błąd.

edit: Nie zwraca się referencji do lokalnego obiektu

GM'owe "bounce" w C++

Rekomendowane odpowiedzi

Jeśli chcesz dodać odpowiedź, zaloguj się lub zarejestruj nowe konto

Zarejestruj nowe konto

Zaloguj się

Ostatnio przeglądający 0 użytkowników