kod który po wystrzeleniu ent leci tam gdzie celuje:
new Float: Velocity[3] VelocityByAim(id, 1500 , Velocity) entity_set_vector(Ent, EV_VEC_velocity ,Velocity)
rysunek:
Witamy w Nieoficjalnym polskim support'cie AMX Mod X, jak w większości społeczności internetowych musisz się zarejestrować aby móc odpowiadać lub zakładać nowe tematy, ale nie bój się to jest prosty proces w którym wymagamy minimalnych informacji.
|
Napisano 06.04.2012 21:52
new Float: Velocity[3] VelocityByAim(id, 1500 , Velocity) entity_set_vector(Ent, EV_VEC_velocity ,Velocity)
Napisano 07.04.2012 00:31
///////////////////////////////////////////////////
///////// odpowiedź na pierwsze pytanie: //////////
///////////////////////////////////////////////////
new Float:Velocity[3];
VelocityByAim(id, 1500, Velocity);
for(new i=0;i<3;++i)Velocity[i]*=-1; // odwrócenie zwrotów wektorów
entity_set_vector(Ent, EV_VEC_velocity ,Velocity);
///////////////////////////////////////////////////
/////////// odpowiedź na drugie pytanie: //////////
///////////////////////////////////////////////////
new Float:Velocity[3];
VelocityByAim(id, 1500, Velocity);
for(new i=1;i<3;++i)Velocity[i]*=-1; // odwrócenie zwrotów wektorów płaszczyzny poziomej
Velocity[0]=0.0; // wyzerowanie wektora wysokości
entity_set_vector(Ent, EV_VEC_velocity ,Velocity);
Użytkownik benio101 edytował ten post 07.04.2012 00:39
Napisano 07.04.2012 00:51
Napisano 07.04.2012 09:10
lib xs daje dużo funkcji do pracy z wektorami
1. xs_vec_neg
jeśli chcesz poczytać o wektorach to z książek mogę ci polecić
http://helion.pl/ksi...ourg,fiprog.htm
w liceum też są omawiane wektory ale nie wszystkie aspekty
na alliedmoders widziałem tutek poszukaj
xs_vec_neg(const Float:vec[], Float:out[]) { out[0] = -vec[0]; out[1] = -vec[1]; out[2] = -vec[2]; }Możesz mi objaśnić do czego mogę użyć tego ?
Napisano 07.04.2012 09:41
new Float:velocity[3]; VelocityByAim(id, 700, velocity); velocity[2] = random_float(265.0,285.0); entity_set_vector(identa, EV_VEC_velocity, velocity);
Napisano 07.04.2012 10:01
Z tego, co widzę, to ta funkcja odwraca wektor, odpowiedź na Twoje pierwsze pytanie.lib xs daje dużo funkcji do pracy z wektorami
1. xs_vec_neg
jeśli chcesz poczytać o wektorach to z książek mogę ci polecić
http://helion.pl/ksi...ourg,fiprog.htm
w liceum też są omawiane wektory ale nie wszystkie aspekty
na alliedmoders widziałem tutek poszukajxs_vec_neg(const Float:vec[], Float:out[]) { out[0] = -vec[0]; out[1] = -vec[1]; out[2] = -vec[2]; }Możesz mi objaśnić do czego mogę użyć tego ?
Napisano 07.04.2012 10:08
Napisano 07.04.2012 10:25
///////////////////////////////////////////////////
///////// odpowiedź na pierwsze pytanie: //////////
///////////////////////////////////////////////////
new Float:Velocity[3];
VelocityByAim(id, 1500, Velocity);
for(new i=0;i<3;++i)Velocity[i]*=-1; // odwrócenie zwrotów wektorów
entity_set_vector(Ent, EV_VEC_velocity ,Velocity);
///////////////////////////////////////////////////
/////////// odpowiedź na drugie pytanie: //////////
///////////////////////////////////////////////////
new Float:Velocity[3];
VelocityByAim(id, 1500, Velocity);
for(new i=1;i<3;++i)Velocity[i]*=-1; // odwrócenie zwrotów wektorów płaszczyzny poziomej
Velocity[0]=0.0; // wyzerowanie wektora wysokości
entity_set_vector(Ent, EV_VEC_velocity ,Velocity);
VelocityByAim(id, -1500, Velocity);
Napisano 07.04.2012 10:40
for(new i=1;i<3;++i)Velocity[i]*=-1;
x' = x*cos(alfa) - y*sin(alfa) y' = x*sin(alfa) + y*cos(alfa)4. I ostatecznie odwracamy wektor (xs_vec_neg), gdyż chcemy uzyskać przeciwny kierunek.
Użytkownik benio101 edytował ten post 07.04.2012 10:47
Napisano 07.04.2012 11:49
Napisano 07.04.2012 13:18
for(new i=1;i<3;++i)Velocity[i]*=-1; // odwrócenie zwrotów wektorów płaszczyzny poziomej[/color][color=#000000]tylko
Velocity[2]=0.0; // wyzerowanie wektora wysokoci
for(new i=0;i<2;++i)Velocity[i]*=-1; // odwrócenie zwrotów wektorów płaszczyzny poziomej[/color][color=#000000]bo musimy odwrócić wymiary szerokości i długości, a jedynie wysokość (2) wyzerować.
Velocity[2]=0.0; // wyzerowanie wektora wysokości
register_clcmd("say jump","jump");odpalony na serwerze pokazuje, że po wpisaniu na sayu "jump", gracz jest popychany do tyłu, jednak, jak wyżej napisałem, moc tego pchnięcia jest różna w zależności od wysokości, na jaką celuje / patrzy gracz.
public jump(id){
new Float:Velocity[3];
VelocityByAim(id, 1500, Velocity);
for(new i=0;i<2;++i)Velocity[i]*=-1;
Velocity[2]=0.0;
entity_set_vector(id, EV_VEC_velocity ,Velocity);
}
Użytkownik benio101 edytował ten post 07.04.2012 13:19
Napisano 07.04.2012 13:46
Okej, a jak mogę ustawić żeby ent leciał na tej samej wysokości tylko np. w lewo od gracza ?Też tak robiłem, wyrzuca w dobrym kierunku, lecz z różną siłą, zależną od kąta nachylenia osi pionowej celowania przez fgracza, tj. jeśli patrzy wprost przed siebie, to wyrzuca maksymalnie prawidłowo, lecz im większe odchylenie (ku podłodze lub niebu), tym mniejsza odległość wektora. I tutaj jest stricte fizyka, wzór bodajże ten, co podałem wyżej, lecz nie umiem go odnieść do amxxa.
Najlepiej, żeby nie bawić się w cuda niewida, to myślę, żeby zapisać pozycję aimingu gracza, zmienić do wprost przed siebie, wtedy wywołać ww. algorytm i na końcu przywrócić stary aiming gracza.
edit. Aha.. no i niefor(new i=1;i<3;++i)Velocity[i]*=-1; // odwrócenie zwrotów wektorów płaszczyzny poziomej[/color][color=#000000]tylko
Velocity[2]=0.0; // wyzerowanie wektora wysokoci
for(new i=0;i<2;++i)Velocity[i]*=-1; // odwrócenie zwrotów wektorów płaszczyzny poziomej[/color][color=#000000]bo musimy odwrócić wymiary szerokości i długości, a jedynie wysokość (2) wyzerować.
Velocity[2]=0.0; // wyzerowanie wektora wysokości
Krótki kod:register_clcmd("say jump","jump");odpalony na serwerze pokazuje, że po wpisaniu na sayu "jump", gracz jest popychany do tyłu, jednak, jak wyżej napisałem, moc tego pchnięcia jest różna w zależności od wysokości, na jaką celuje / patrzy gracz.
public jump(id){
new Float:Velocity[3];
VelocityByAim(id, 1500, Velocity);
for(new i=0;i<2;++i)Velocity[i]*=-1;
Velocity[2]=0.0;
entity_set_vector(id, EV_VEC_velocity ,Velocity);
}
Napisano 07.04.2012 14:10
3. Tutaj znowu będzie trzeba na podstawie kąta obrócenia gracza obliczyć, gdzie jest "lewo" i odpowiednio przesunąć obydwa wektory, wektor 0 i 1.Okej, a jak mogę ustawić żeby ent leciał na tej samej wysokości tylko np. w lewo od gracza ?
Napisano 07.04.2012 14:30
Napisano 07.04.2012 14:53
// Vector Operations -------------------------------------------------------------------------------Jeśli mi się uda znormalizować, wykorzystując podaną tutaj funkcję, to podam na bieżąco dane.
public Float:getVecLen(Float:Vec[3]){
new Float:VecNull[3]={0.0,0.0,0.0}
new Float:len=vector_distance(Vec,VecNull)
return len
}
public Float:scalar_triple_product(Float:a[3],Float:b[3]){
new Float:up[3]={0.0,0.0,1.0}
new Float:Ret[3]
Ret[0]=a[1]*b[2]-a[2]*b[1]
Ret[1]=a[2]*b[0]-a[0]*b[2]
Ret[2]=a[0]*b[1]-a[1]*b[0]
return vectorProduct(Ret,up)
}
public normalize(Float:Vec[3],Float:Ret[3],Float:multiplier){
new Float:len=getVecLen(Vec)
copyVec(Vec,Ret)
Ret[0]/=len
Ret[1]/=len
Ret[2]/=len
Ret[0]*=multiplier
Ret[1]*=multiplier
Ret[2]*=multiplier
}
public rotateVectorZ(Float:Vec[3],Float:direction[3],Float:Ret[3]){
// rotates vector about z-axis
new Float:tmp[3]
copyVec(Vec,tmp)
tmp[2]=0.0
new Float:dest_len=getVecLen(tmp)
copyVec(direction,tmp)
tmp[2]=0.0
new Float:tmp2[3]
normalize(tmp,tmp2,dest_len)
tmp2[2]=Vec[2]
copyVec(tmp2,Ret)
}
public Float:vectorProduct(Float:Vec1[3],Float:Vec2[3]){
return Vec1[0]*Vec2[0]+Vec1[1]*Vec2[1]+Vec1[2]*Vec2[2]
}
public copyVec(Float:Vec[3],Float:Ret[3]){
Ret[0]=Vec[0]
Ret[1]=Vec[1]
Ret[2]=Vec[2]
}
public subVec(Float:Vec1[3],Float:Vec2[3],Float:Ret[3]){
Ret[0]=Vec1[0]-Vec2[0]
Ret[1]=Vec1[1]-Vec2[1]
Ret[2]=Vec1[2]-Vec2[2]
}
public addVec(Float:Vec1[3],Float:Vec2[3]){
Vec1[0]+=Vec2[0]
Vec1[1]+=Vec2[1]
Vec1[2]+=Vec2[2]
}
Napisano 07.04.2012 16:00
new Float:Velocity[3]; // Pojemnik na wektor
VelocityByAim(id, -1500, Velocity); // Ustalenie obrotu gracza wraz z odwróceniem wektora (Optymalizacja by G[o]Q)
Velocity[2]=0.0; // Wyzerowanie pionowego przesunięcia wektora, aby uzyskać proste przesunięcie (prosty strzał, a nie w górę, czy w dół)
normalize(Velocity,Velocity,1500.0); // Normalizacja wektora wraz ze zwiększeniem, czyli dostosowanie wielkości przesunięcia po usunięciu przesunięcia pionowego
entity_set_vector(Ent, EV_VEC_velocity ,Velocity); // przesunięcie właściwe
// gdzie id to ID gracza, Ent to ID bytu, np. właśnie strzały
public normalize(Float:Vec[3],Float:Ret[3],Float:multiplier){ // funkcja normalizująca znaleziona w kodzie źródłowym ESP
new Float:len=getVecLen(Vec)
copyVec(Vec,Ret)
Ret[0]/=len
Ret[1]/=len
Ret[2]/=len
Ret[0]*=multiplier
Ret[1]*=multiplier
Ret[2]*=multiplier
}
public copyVec(Float:Vec[3],Float:Ret[3]){ // funkcja pomocnicza do funkcji normalizującej
Ret[0]=Vec[0]
Ret[1]=Vec[1]
Ret[2]=Vec[2]
}
public Float:getVecLen(Float:Vec[3]){ // druga i ostatnia funkcja pomocnicza do funkcji normalizującej
new Float:VecNull[3]={0.0,0.0,0.0}
new Float:len=vector_distance(Vec,VecNull)
return len
}
register_clcmd("say jump","jump");
public jump(id){
new Float:Velocity[3];
VelocityByAim(id, -1500, Velocity);
Velocity[2]=0.0;
normalize(Velocity,Velocity,1500.0);
entity_set_vector(id, EV_VEC_velocity ,Velocity);
}
// ponieważ za ent (numer bytu) w entity_set_vector daliśmy ID gracza (id), to gracz zostanie przesunięty,
// czyli dostanie kopniaka i z siłą 1500 poleci do tyłu, bez względu, czy patrzy się na górę, na dół, czy przed siebie
public normalize(Float:Vec[3],Float:Ret[3],Float:multiplier){
new Float:len=getVecLen(Vec)
copyVec(Vec,Ret)
Ret[0]/=len
Ret[1]/=len
Ret[2]/=len
Ret[0]*=multiplier
Ret[1]*=multiplier
Ret[2]*=multiplier
}
public copyVec(Float:Vec[3],Float:Ret[3]){
Ret[0]=Vec[0]
Ret[1]=Vec[1]
Ret[2]=Vec[2]
}
public Float:getVecLen(Float:Vec[3]){
new Float:VecNull[3]={0.0,0.0,0.0}
new Float:len=vector_distance(Vec,VecNull)
return len
}
Użytkownik benio101 edytował ten post 07.04.2012 16:09
Napisano 07.04.2012 23:27
Tworzę cztery byty, jeden leci wprost przed gracza drugi w tył, trzeci w lewo a czwarty w prawo i tylerozpisaliście się tak że nie wiadomo co czytać opisz jakoś krótko co chcesz uzyskać
z tego co mogę się zorientować wystarczy znormalizować wektor po wyzerowaniu przesunięcia wysokości i pomnożyć go przez scalar
Napisano 07.04.2012 23:36
Napisano 07.04.2012 23:46
new Angles[3],vecprosto[3],vectyl[3],vecprawo[3],veclewo[3] pev(id,pev_v_angle,Angles) angle_vector (Angles, ANGLEVECTOR_FORWARD, vecprosto) angle_vector (Angles, ANGLEVECTOR_RIGHT,vecprawo) xs_vec_neg(vecprosto,vectyl) xs_vec_neg(vecprawo,veclewo) //możesz pokazać jak dalej zrobić?
Napisano 07.04.2012 23:58
0 użytkowników, 1 gości, 0 anonimowych