30 odpowiedzi w tym temacie

[KariiO]

Witam, załóżmy że Tworzę enta(strzała) która po wystrzeleniu leci tam gdzie aktualnie celujemy(velocitybyaim), jak mogę zrobić żeby strzała(ent) leciał w odwrotnym kierunku ? Już bez użycia aim lecz po prostu leci zza mnie wprost(rysunek)

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:

[DarkGL]

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

[KariiO]

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 ?

[dasiek]

mozesz to zrobić na zasadzie modułu odrzutowego z Coda

new Float:velocity[3];
VelocityByAim(id, 700, velocity);
velocity[2] = random_float(265.0,285.0);
entity_set_vector(identa, EV_VEC_velocity, velocity);

[dasiek]

xs_vec_neg(const Float:vec[], Float:out[])
Odwraca współżędne vec[] do out[]

xs_vec_neg(const wsp,Float wsp2)
zmienna wsp2 będzie miała współżędne wsp tyle ze odwrotne

[G[o]Q]

///////////////////////////////////////////////////
///////// 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);

wektor wysokosci to Velocity[2] a nie [0] chyba

pozatym powinno wystarczyć takie cos

VelocityByAim(id, -1500, Velocity);

ale najlepiej zbudować swój wektor przy uzyciu xS'a

[KariiO]

Co do odwrócenia zrobiłem tak:

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[2]=0.0; // wyzerowanie wektora wysokości
entity_set_vector(Ent, EV_VEC_velocity ,Velocity);

Ent poleci zza mnie + poleci prosto bo Velocity[2]=0.0; zeruje nawet jakbym celownik w niebo, tak ?
Co do prawej i lewej strony, jak to będzie ?
Velocity[1] ?

[KariiO]

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 nie

for(new i=1;i<3;++i)Velocity[i]*=-1;  // odwrócenie zwrotów wektorów płaszczyzny poziomej[/color][color=#000000]
Velocity[2]=0.0;  // wyzerowanie wektora wysokoœci

tylko

for(new i=0;i<2;++i)Velocity[i]*=-1;  // odwrócenie zwrotów wektorów płaszczyzny poziomej[/color][color=#000000]
Velocity[2]=0.0;  // wyzerowanie wektora wysokośœci

bo musimy odwrócić wymiary szerokoœści i długośœci, a jedynie wysokośœć (2) wyzerować.

Krótki kod:

register_clcmd("say jump","jump");

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);
}

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.

Okej, a jak mogę ustawić żeby ent leciał na tej samej wysokości tylko np. w lewo od gracza ?

|

[DarkGL]

rozpisaliś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

[KariiO]

rozpisaliś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

Tworzę cztery byty, jeden leci wprost przed gracza drugi w tył, trzeci w lewo a czwarty w prawo i tyle

PS. Nie wiem już z jakiego kodu skorzystać

[DarkGL]

skoro masz 4 byty to obliczajmy dla wszystkich jednoczęśnie
potrzebne ci angles gracza i funkcja angle_vector http://www.amxmodx.o...?go=func&id=366
wyciągasz za pomocą tej funkcji vector forward ( przód ) i vector right ( prawy )
teraz używasz xs_vec_neg ( zmiana zwrotu wektora ) aby uzyskać wektor do tyłu ( z tego do przodu ) i w lewo z tego w prawo
masz 4 wektory które są już znormalizowane ( składowe wektora są podzielone przez jego długość )
więc teraz używasz xs_vec_mul_scalar ( mnożenie wektora przez liczbe ) aby pomnożyć te wektory przez szybkość jaką mają mieć enty i otrzymane wektory ustawiasz jako velocity
potrzebny ci kod czy sobie poradzisz

[KariiO]

        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ć?

[DarkGL]

dalej to juz tylko
xs_vec_mul_scalar( wektor , predkosc( jako float ) , ten sam wektor ); i tak 4 wektory

a potem juz tylko
set_pev( numer_enta , pev_velocity , wektor );