Particles

[Exigo]

Jak się operuje na obiektowo w cpp? ;o Chodzi o to że chcę zrobić obiekty (celniej: particle), w stylu spadającego śniegu/deszczu - lecz nie mam zielonego pojęcia jak się za to zabrać. Proste punkciki zwiększające wartość y co pętlę, rysujące biały piksel, niszczące się po przekroczeniu granicy ileś-tam y - żadne coś.

Po prostu nigdy nie pisałem obiektowo. ;f

[PsichiX]

wszystko zależy od tego jakiej biblioteki / silnika renderującego używasz. jeśli masz stałą maksymalną liczbę particli tego samego typu (ta sama tekstura) to możesz wpakować całość do tablicy i renderować za jednym rozmachem, wtedy musisz mieć strukturę która będzie zawierała dane potrzebne bibliotece aby za jednym zamachem wyrenderowała całą tablicę.

[Exigo]

Allegro. Ok. Czyli jak to zrobić? ;x

Chodzi mi o prosty przykładowy kod. Z resztą się połapie.

[PsichiX]

sadze ze allegro nie ma takiej funkcji co by raz tablice sprajtow narysowala, wiec mozesz potraktowac particle jako sprajty i wsadzic je w dowolny kontener chociazby liste, i przelatujac ja rysowac kolejno kazdy sprajt.

przykladowa struktura:

 

struct PARTICLE_DESC
{
BITMAP* sprite; // nie znam allegrowskiego sprajta wiec tutaj dasz co trzeba;p
int x;
int y;
int speed;
};

// lista particli
list<PARTICLE_DESC> particles;

// dodanie particla
PARTICLE_DESC part;
part.sprite=jakis_sobie_sprajt_particla;
part.x=rand()%800; // losowa pozycja X
part.y=0;
part.speed=rand()%10+1; // losowa predkosc
particles.push_back(part); // wrzucamy particla do listy

// aktualizacja particli
for(list<PARTICLE_DESC>::iterator iter=particles.begin();iter!=particles.end();iter++)
{
iter->y+speed;
if(iter->y>600)
{
iter->x=rand()%800; // losowa pozycja X
iter->y=0;
iter->speed=rand()%10+1; // losowa predkosc
}
draw_sprite(sprite,x,y); // tez nie znam funkcji rysujacej sprajta wiec zastapisz to
}

// a tak skasujesz dowolny element listy
list<PARTICLE_DESC>::iterator iter=iterator_listy_particles; // iter=particles.begin()
particles.erase(iter);

coś takiego ;P

[Exigo]

Wyrzuca błąd że nie wie co to "list", mimo faktu że wcisnąłem inkluda. ;c

[PsichiX]

po includzie:

using namespace std;

[Exigo]

Nie mam zielonego pojęcia czemu particle po pojawieniu się - znikają od razu. ;o

 

PARTICLE_DESC part;
part.x=rand()%320;
part.y=0;
part.speed=rand()%10+1;
particles.push_back(part);

for(list<PARTICLE_DESC>::iterator iter=particles.begin();iter!=particles.end();iter++)
{
iter->y+part.speed;
if(iter->y>240)
{
iter->x=rand()%320;
iter->y=0;
iter->speed=rand()%10+1;
}
masked_blit(partic,bufor,0,0,part.x,part.y,partic->h,partic->w);
}

list<PARTICLE_DESC>::iterator iter=particles.begin();
particles.erase(iter);

[PsichiX]

list<PARTICLE_DESC>::iterator iter=particles.begin();

particles.erase(iter);

dlatemu - kasujesz nowo powstały particle. ja ten kod napisałem ogólnikowo, czyli co kiedy sie robi, to nie jest kod dla zwykłego kopiuj-wklej całości.

 

Gdzieś na początku:

struct PARTICLE_DESC
{
int x;
int y;
int speed;
};

// lista particli
list<PARTICLE_DESC> particles;

 

gdzieś indziej sobie dodasz ze 100 particli:

for(int i=0;i<100;i++)
{
PARTICLE_DESC part;
part.x=rand()%320;
part.y=0;
part.speed=rand()%10+1;
particles.push_back(part);
}

 

potem w pętli głównej aktualizujesz (poprawilem, dziwne ze nikt nie zauwazyl ;p):

for(list<PARTICLE_DESC>::iterator iter=particles.begin();iter!=particles.end();iter++)
{
iter->y+iter->speed;
if(iter->y>240)
{
iter->x=rand()%320;
iter->y=0;
iter->speed=rand()%10+1;
}
masked_blit(partic,bufor,0,0,iter->x,iter->y,partic->h,partic->w);
}

 

a gdy ich już nie potrzebujesz to dajesz:

jeśli chcesz usunąć wszystkie particle:

particles.clear()

lub jeśli chcesz usunąć jakiś konkretny:

int _i=0;
for(list<PARTICLE_DESC>::iterator iter=particles.begin();iter!=particles.end();iter++)
{
if(_i==id_particla_do_usuniecia)
{
particles.erase(iter);
break;
}
_i++;
}

[Exigo]

Nadal mrugają. ;o

 

//(w pętli głównej)
PARTICLE_DESC part;
part.x=rand()%320;
part.y=0;
part.speed=rand()%10+1;
particles.push_back(part);
for(list<PARTICLE_DESC>::iterator iter=particles.begin();iter!=particles.end();iter++)
{
iter->y+part.speed;
if(iter->y>240)
{
iter->x=rand()%320;
iter->y=0;
iter->speed=rand()%10+1;
}
masked_blit(partic,bufor,0,0,part.x,part.y,partic->h,partic->w);
}

[PsichiX]

EDIT: Poprawilem aktualizacje, bo pokracznie ja przepisalem ;p

 

podeślij mi projekt na PW i poprawie bo wiem gdzie leży błąd, ale nie wytłumacze Ci go na sucho, jesli sam tego nie dostrzezesz

[Exigo]

Ok, teraz nie mrugają...

... ale ich wartość y nie zwiększa się o speed. ;X

 

Edit: ok, prześlę. ;o

[PsichiX]

daj wać projekt (ale nie fragment kodu, tylko projekt cały bo to nie działa jak w GM. spoko, nie podkradne nic :P)

edit: nom to czekam :)

edit2: odeslane

edit2: ale gupi blad xD iter->y+iter->speed; // zapomnialem dac "+=" zamiast "+" i nie dodawal do pozycji ;P

[Exigo]

Następny problem. ; D

(kod aktualizacji:)

pocisk_iter->pocisk_y-=3;
if(pocisk_iter->pocisk_y<-(b_pocisk->h))
{pociski.erase(pocisk_iter);}
masked_blit(b_pocisk,b_bufor,0,0,pocisk_iter->pocisk_x,pocisk_iter->pocisk_y,
b_pocisk->w,b_pocisk->h);

Czemu przy usuwaniu jest tak zwana - "zwiecha"? ;f

[PsichiX]

pocisk_iter->pocisk_y-=3;
if(pocisk_iter->pocisk_y<-(b_pocisk->h))
{
pociski.erase(pocisk_iter++);
continue;
}
masked_blit(b_pocisk,b_bufor,0,0,pocisk_iter->pocisk_x,pocisk_iter->pocisk_y,
b_pocisk->w,b_pocisk->h);

natura iteratorow wymaga by w petli iterator wskazujacy na element do usuniecia zostal inkrementowany/dekrementowany przy usuwaniu aby ominac ten wlasnie blad

[Exigo]

Coś dziwnie muliło, tzn. gdy jakiś pocisk się niszczył, to pocisk na 'poprzednim' miejscu w liście zatrzymywał się 1 pętlę. Kombinując, zmieniłem na pocisk_iter-- i chodzi jak w zegarku (już pociski się nie cofają). W czym rzecz? Czemu powinno lepiej działać ++, a jest odwrotnie? ;o

Mimo wszystko - chodzi. ;d

[PsichiX]

to wynika z samej struktury petli ktora masz, i Twoj sposob z -- jest dobry, ja zapomnialem ze moim sposobem ominie jednego particla