prosty snake - problem z usuwaniem elementów

0

Cześć, już chwilę czasu męczę się ze swoim snakiem. Wrzucę 2 funkcje, które powinny powiedzieć co i jak jeśli nie to wyślę całość.

Funkcja odpowiadająca za ruch:

 void Part::move_part()
{
        positions.x_position_next = positions.x_position;         //zapisuję wspolrzedne
        positions.y_position_next = positions.y_position;         //do wyswietlenia kolejnej czesci weza
        positions.new_x_position_next = positions.new_x;
        positions.new_y_position_next = positions.new_y;

    if (kbhit())
    {
        switch (getch())
        {
        case 'a':
            {
                positions.new_x = -1;
                positions.new_y = 0;
                break;
            }
        case 'd':
            {
                positions.new_x = 1;
                positions.new_y = 0;
                break;
            }
        case 'w':
            {
                positions.new_y = -1;
                positions.new_x = 0;
                break;
            }
        case 's':
            {
                positions.new_y = 1;
                positions.new_x = 0;
                break;
            }
        }
    }

     positions.x_position += positions.new_x;  //wspolrzedne do wyswietlenia glowy weza 
     positions.y_position += positions.new_y;
}

Odświeżanie planszy:


bool Board::refresh_board()
{

   int fruit = fruit_counter;     //aktualna ilosc zjedzonych owocow

   new_part.move_part();     //ruch glowy (funkcja powyzej)

    if(((rand() % 1000) > 130) && is_fruit == false )   //tworzenie owocu
        create_fruit();
    else if (new_part.get_positions().x_position == fruit_positionx &&
          new_part.get_positions().y_position == fruit_positiony)
          {
            is_fruit = false;
            fruit_counter++;
          }


    if (fruit_counter > 0 && fruit != fruit_counter )   // jesli waz zjadl owoc to
    {                                                   //to dodaj nowy obiekt do vector<Body> parts;

        parts.push_back(part);
    }


    for (int i = 0; i < fruit_counter; i++)    //obliczanie kolejnych czesci weza
    {
        if(i == 0)
        {
            parts[i].set_body(new_part.get_positions().x_position_next,    //glowa i nastepny element
                                       new_part.get_positions().y_position_next,
                                       new_part.get_positions().new_x_position_next,
                                       new_part.get_positions().new_y_position_next);
        }
        else
        {
            parts[i].set_body(parts[i-1].get_body().next_x,  //kolejny na podstawie poprzedniego
                                       parts[i-1].get_body().next_y,                                               
                                       new_part.get_positions().new_x_position_next,
                                       new_part.get_positions().new_y_position_next);
        }

    }


gotoxy(new_part,parts);   //rysowanie weza

Sleep(100);

if (fruit_counter > 0)   //funkcja usuwajaca poprzedni element
{
int a = parts[fruit_counter-1].get_body().x_pos;
int b = parts[fruit_counter-1].get_body().y_pos;
gotoclear(a,b);
}

    return is_end;
}
 

Snake w pewien sposób działa, ponieważ rzeczywiście rośnie a elementy podążają za sobą - jednak problem leży w usuwaniu ostatniego elementu, gdy ma głowę + 2 dodatkowe elementy działa ok, gdy dochodzi 3 i kolejne pojawia się problem przy skręcaniu - zostawia jakby kupy czyli nieusunięte znaki. Oto jak wygląda funkcja wyliczająca kolejne współrzędne set_body. Według mnie na pewno tutaj leży błąd (pomijając całą koncepcję, która może być po prostu zła).

 
void set_body(short int x, short int y, short int dxx, short int dyy)
                        {body_pos.x_pos = x;
                         body_pos.y_pos = y;
                         body_pos.dx = dxx;
                         body_pos.dy = dyy;
                         body_pos.next_x = body_pos.x_pos - body_pos.dx; body_pos.next_y = body_pos.y_pos - body_pos.dy; }

Mój pomysł był taki, żeby obliczać kolejne współrzędne na podstawie kierunku głowy a potem następnego elementu, jednak tutaj wszystkie współrzędne przyjmują od razu kierunek głowy co prowadzi do błędu.

Byłbym wdzięczny za pomysły :)

1

Mój pomysł był taki, żeby obliczać kolejne współrzędne na podstawie kierunku głowy (...)

Po prostu przesuwaj ostatni element węża w miejsce jego nowej głowy ;-)

Poza tym:
1.Jaki sens ma wydzielanie klasy Part?
2.Part::move_part powinno przyjmować kierunek ruchu w argumencie, a nie operować na globalnym stanie (kbhit/getch).

1 użytkowników online, w tym zalogowanych: 0, gości: 1