Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?

[C++, Allegro] Coś poruszające się po mapie

Ostatnio zmodyfikowano 2010-08-11 11:59
Autor Wiadomość
SeaMonster131
Temat założony przez niniejszego użytkownika
[C++, Allegro] Coś poruszające się po mapie
» 2010-08-09 18:24:13
Mój problem wygląda tak: mam mape int map[15][16] z wartościami 1 oraz 2. 1 to ziemia, a 2 to trawa tak dla przykładu :) Z trawy jest stworzona ścieżka, i teraz jak zrobić żeby co ileś tam sekund jeden kafel mapy zmieniał się na np trawe z kamieniem i po chwili ten kamień powędrowałby na następny kafel? Mogę to zrobić z if ale ścieżka ma 59 kafli a więc 59 if'ów... :D
Pokaże wam kod:
C/C++
short int map[ 15 ][ 16 ] = {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1,
    1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
    1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 1, 1, 1, 1,
    1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1,
    1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1,
    1, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};
//i w pętli mógłbym zmieniać te wartości... 19 - trawa z kamykiem :)
while( speed > 0 )
{
    kamyk++;
    if( kamyk == 300 ) { map[ 0 ][ 12 ] = 19; }
    if( kamyk == 500 ) { map[ 1 ][ 12 ] = 19; map[ 0 ][ 12 ] = 2; }
    if( kamyk == 700 ) { map[ 2 ][ 12 ] = 19; map[ 1 ][ 12 ] = 2; }
    if( kamyk == 900 ) { map[ 3 ][ 12 ] = 19; map[ 2 ][ 12 ] = 2; }
    if( kamyk == 1100 ) { map[ 3 ][ 11 ] = 19; map[ 3 ][ 12 ] = 2; }
    if( kamyk == 1300 ) { map[ 3 ][ 10 ] = 19; map[ 3 ][ 11 ] = 2; }
    if( kamyk == 1500 ) { map[ 3 ][ 9 ] = 19; map[ 3 ][ 10 ] = 2; }
    if( kamyk == 1700 ) { map[ 3 ][ 8 ] = 19; map[ 3 ][ 9 ] = 2; }
    if( kamyk == 1900 ) { map[ 3 ][ 7 ] = 19; map[ 3 ][ 8 ] = 2; }
    if( kamyk == 2100 ) { map[ 3 ][ 6 ] = 19; map[ 3 ][ 7 ] = 2; }
    speed--;
}
Znacie może jakiś lepszy sposób/algorytm ? :)
Aha, w późniejszym czasie, chciałbym żeby nie tylko jeden kamyk poruszał się po tych kaflach ale np 10 (po tej samej ścieżce, 1 kafel do tyłu :))itp...
P-20638
szyx_yankez
» 2010-08-09 19:48:25
Ja bym to zrobił tak:
-Stworzył bym oddzielną bitmapę np.w kolorze białym,
-Narysował bym na niej czarną linie, zgodnie z położeniem ścieżki(taka szyna po której poruszał by się kafelek),
-Następnie w obroty wchodzi funkcja getpixel, i np.
C/C++
if( getpixel(, x + 1, y ) == makecol( 0, 0, 0 )
id ź w prawo
if( getpixel(, x, y + 1 ) == makecol( 0, 0, 0 )
id ź w g ó re
, ewentualnie lepszym rozwiązanie było by, stworzenie to za pomocą punktów kontrolnych wtedy musiał byś znać pozycje każdego rogu ścieżki i poruszał byś tylko ten kafelek pomiędzy tymi współrzędnymi.;p
P-20640
ison
» 2010-08-09 19:59:30
widzę że piszesz Tower Defense, zgadłem? :D
też coś takiego pisałem w wolnym czasie, link do mojego projektu: http://www.gamedev.pl/projects.php?x=view&id=1288

mogę ci powiedzieć jak ja rozwiązałem problem chodzenia przeciwników, który jest łatwy do napisania i sprawdza się w praktyce idealnie ;)
stwórz sobie drugą tablicę takiej samej wielkości jak plansza, zaznacz na niej ścieżkę po której będą poruszali się przeciwnicy kolejnymi rosnącymi liczbami
przykładowo

0 1 0 0 0 0 0
0 2 0 0 0 0 0
0 3 4 5 6 0 0
0 0 0 0 7 0 0
0 0 0 0 8 0 0
0 0 0 0 9 0 0
każdy przeciwnik będzie sprawdzał do okoła siebie wszystkie pola (w 4 kierunkach, góra,dół,lewo,prawo) i jeśli znajdzie jakiś o numerze większym niż aktualny na którym stoi to idzie w tym kierunku.
Prawda że proste?

uwierz mi że takie rzeczy najlepiej jak się wymyśla samemu, bez pytania na forum, wtedy ma się znacznie większą satysfakcję ze swojego projektu

nigdy nie rób nic na if'ach, to jest najgorsze co może być. Zawsze próbuj rozwiązać problem na inny sposób, może trudniejszy do zakodzenia ale za to wydajniejszy. Weź kartkę i długopis i myśl nad problemem aż coś wykminisz

//edit odnośnie mojego projektu (tudzież podpowiedzi dla ciebie)
widzisz, taka jest różnica między zaif'owaną grą w moim Tower Defensem że u mnie wszyściutko jest robione tak aby później można było łatwo edytować grę (dodawać nowych przeciwników, nowe jednostki) bez edytowania kodu. Moja rada: ściągnij mój projekt, wejdź w pliki gry i przeanalizuj wszystko co tam będzie, jeśli będziesz miał jakieś pytania to mów
P-20641
SeaMonster131
Temat założony przez niniejszego użytkownika
» 2010-08-09 21:05:17
@ison - tak zgadłeś :)
Ściągnąłem Twój projekt i faktycznie, wszystko jest cacy :D (Sama gra też jest fajna :)) Tylko że ja [jeszcze] nie umiem tak zrobić... :)
A co do tego pomysłu, to hmm.. jakoś musze spróbować :) Jak mi sie uda, to dam znać :D
P-20642
SeaMonster131
Temat założony przez niniejszego użytkownika
» 2010-08-10 11:27:58
"każdy przeciwnik będzie sprawdzał do okoła siebie wszystkie pola (w 4 kierunkach, góra,dół,lewo,prawo) i jeśli znajdzie jakiś o numerze większym niż aktualny na którym stoi to idzie w tym kierunku.
Prawda że proste?"
No właśnie nie takie proste :D
Nie wiem jak ten przeciwnik ma sprawdzić czy dookoła niego znajduje się większa liczba??
C/C++
//Tak jak mówiłeś - stworzyłem mape z większymi liczbami
short int mapa[ 15 ][ 16 ] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0,
    0, 0, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 0, 0, 0,
    0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 17, 0, 25, 26, 27, 0, 35, 36, 37, 0, 0, 0, 0, 0,
    0, 0, 18, 0, 24, 0, 28, 0, 34, 0, 38, 0, 0, 0, 0, 0,
    0, 0, 19, 0, 23, 0, 29, 0, 33, 0, 39, 0, 0, 0, 0, 0,
    0, 0, 20, 21, 22, 0, 30, 31, 32, 0, 40, 41, 42, 43, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0,
    59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
//oraz ruch potworka :)
int ruchpotwora = 0;
//i jak ja teraz mam to przyrównać??? Próbowałem na wiele sposobów lecz mi nie wychodziło :(
while( speed > 0 )
{
    atakpotwor++;
    if( atakpotwor == 301 ) { atakpotwor = 0; }
   
    if( atakpotwor == 300 ) {
       
        if( ruchpotwora < mapa[....][....] ) { // ????
            map[....][....] = 19; //19 numer kafla w bitmapie
        }
       
    }
Próbowałem już ze 100+++ kombinacji i mi nie wychodzi :( Mógłby mnie ktoś jakoś naprowadzić czy coś?
P-20667
pekfos
» 2010-08-10 12:09:23
przecież potwór nie musi być kawałkiem mapy. zrób klasę potwora z jego położeniem i funkcjami do przemieszczania się, choćby i tak:
C/C++
class moster {
    int x, y;
public:
    int move {
        if( y < 5 ) return ++y;
       
        if( x < 20 ) return ++x;
       
    } };
wywołujesz move w pętli i jak potwór dochodzi w dół do y==5 to idzie w prawo do x==20, tak dość łatwo określisz trasę. Do tego timer i będzie ładnie :)
P-20670
ison
» 2010-08-10 12:44:44
tak jak było wymienione wyżej potwór nie może być kawałkiem mapy, jak wtedy będziesz sprawdzał jego ilość HP?
C/C++
class przeciwnik
{
public:
    int x, y;
    int hp;
    przeciwnik( int new_x, int new_y, int new_hp ) //konstruktor
    {
        x = new_x;
        y = new_y;
        hp = new_hp;
    }
    przeciwnik() { } //konstruktor bez argumentów
    ~przeciwnik() { } //destruktor
    void move()
    {
        map[ y ][ x ] = 1; //czyszczę pole na którym znajdował się przed ruchem
        if( map[ y - 1 ][ x ] > map[ y ][ x ] ) y--;
        else if( map[ y + 1 ][ x ] > map[ y ][ x ] ) y++;
        else if( map[ y ][ x - 1 ] > map[ y ][ x ] ) x--;
        else if( map[ y ][ x + 1 ] > map[ y ][ x ] ) x++;
       
        map[ y ][ x ] = 19; //i rysuje go na nowej pozycji
    }
};

nie zapomnij również o timer'ach, tak aby twój program działał na wszystkich komputerach z taką samą szybkością. Tym sposobem co ci podałem wyżej przeciwnicy będą skakać z pola na pole (bez płynnego przejścia). Jeśli chcesz aby przechodzili płynnie to musisz się trochę namęczyć.
P-20672
pekfos
» 2010-08-10 13:36:44
ison: to nadal kawałek mapy!
nie prościej zwykłe:
masked_blit( monster, bufor, 0, 0, x * kafsizex, y * kafsizey, kafsizex, kafsizey )
po co manipulować na mapie skoro można po prostu narysować potwora w innej warstwie z innej bitmapy?
P-20675
« 1 » 2
  Strona 1 z 2 Następna strona