Pomysl na poruszanie sie pionkiem po planszy

Szukam jakiegos sposobu na poruszanie sie pionkiem po planszy w grze chinczyk, plansza jest tablica dwuwymiarowa a plansza przypomina ksztaltem krzyz. Jakim sposobem mozna by bylo to zrobic? Probowalem to robic jakos zakresami liczbowymi ale jest tak wiele warunkow i przypadkow ze nie moge sobie z tym poradzic.

  for(licznik;licznik>0;licznik--)
      {
      if(konieckoniec==false)
      {
      if(i<=4&&j==4)
      {
         plansza[i][j]='_';
         plansza[i-1][j]='1';
         i--;
         wyswietl_plansze(plansza);
         system("pause");
         cout<<"CZESC"<<endl;
         if(i==0) 
         {
                  konieckoniec==true;
                  i_4_4=0;
         }
         }
      }
       if(koniec==false)
       {
              if(i<=4&&j<=6)
              {
               plansza[i][j]='_';
               plansza[i][j+1]='1';
               j++;
               wyswietl_plansze(plansza);
               system("pause");
               if(i==4&&j==4) koniec=true;
               }
       }
       if(koniec_4_4==false)
       {
            if(i==4&&j==4)
              {    
                    plansza[i_4_4][4]='_';
                    plansza[i_4_4-1][4]='1';
                    i_4_4--;
                    wyswietl_plansze(plansza);
                    system("pause");
                    if(i_4_4==0) koniec_4_4=true;
              }
       }
       if(koniec_0_4==false)
       {
            if(i_4_4==0&&j==4)
              {
                   plansza[0][j_0_4]='_';
                   plansza[0][j_0_4+1]='1';
                   j_0_4++;
                   wyswietl_plansze(plansza);
                   system("pause");
                   if(i_4_4==0&&j_0_4==6) koniec_0_4=true;
              }
       if(koniec_0_4==true) 
       {
                            II_cwiartka(plansza, n, i, j);
                            I_cwiartka=false; 
       }
      }
      }
      if(n==6) szostka_1(plansza, n, i, j);
}

plansza wyglada tak:

Robisz tak: Pionek wchodzący na planszę ma pozycje równą 0.
dajesz 4 kierunki: Lewo, prawo, góra dół.

(przykład dla pionka zaczynającego na samym dole)
1 ruch w lewo,
4 ruchy do góry,
4 ruchy w lewo,
2 ruchy do góry,
4 ruchy w prawo,
4 ruchy do góry,
2 ruchy w prawo,
4 ruchy na dół,
4 ruchy w prawo,
2 ruchy na dół,
4 ruchy w lewo,
4 ruchy na dół,
1 ruch w lewo
3 ruchy do góry (końcowe)

Każdy kierunek powtarza się 3x. Teraz pomyśl sobie jak na podstawie pozycji i liczby kroków wyliczyć pozycje ;)
Jeśli nie chcesz tego animować to można to zrobić jeszcze szybciej (ale wzór będzie bardziej skomplikowany).

No dobra, moze nie do konca jasno sie wyrazilem. Nie bardzo ogarniam programowanie, dlatego prosilbym tez o jakis pomysl jakby to mialo mniej wiecej wygladac w kodzie(czy jakies struktury, klasy, czy na tablicy to robic i takie tam). Z gory dzieki.

Stwórz ciąg ruchów, pionek "wyjmuje" następny; Wtedy plansza może mieć dowolny kształt :)

Nigdy nie grałem w tą grę i nie znam do końca zasad, ale z tego co przeczytałem droga nie krzyżuje się w żaden sposób dlatego IMO warto całkowicie "olać" kierunki skoro pionkami można poruszać się tylko wokół zewnętrznej krawędzi. Dodatkowo gracz nie ma żadnego wpływu na grę poza rzucaniem kostką.

Ja zrobił bym to na zasadzie tablicy punktów kolejnych kroków wytyczonej drogi.
przyjmując że startujemy z pkt. (4, 10) jak na rysunku początkowe pkt. wyglądały by tak:
4, 10
4, 9
4, 8
4, 7
4, 6
3, 6
2, 6
1, 6
0, 6
0, 5
... itd.

teraz np. wyliczenie pozycji pionka startowego od pozycji 0 o np. 3 pola to tylko tab[aktualna_pozycja+3]; w ten sposób masz koordynaty x i y na tym polu.

czyli stworzyc tablice 1-wymiarowa tab[40] (tyle jest pol na drodze) i do kazdego tab[i] zaczynajac od pozycji poczatkowej (4,0) podac wspolrzedne x,y itd. wtedy moglbym sie odwolywac zamiast do wspolrzednych od razu do tab[i] i zwiekszasc o n wyrzuconych oczek, tak?

Po co tablica? Do szybkiego obliczania współrzędnych musisz przyjąć któryś punkt na planszy jako początek(masz jego x/y) i na podstawie przesunięcia obliczać o ile się przesunął w lewo/prawo (i już masz pozycje x), i o ile się przesunął w góre/dół(pozycja y).

Dobra postawilem na dosc przydlugawy sposob, ale bylem w kropce, utworzylem tablice struktur. Zadziala cos takiego?

 struct pozycja
{
       int i;
       int j;
}   
                  
pozycja pozycja[40];

pozycja[0].i=4; // start 1
pozycja[0].j=0;
pozycja[1].i=4;
pozycja[1].j=1;
pozycja[2].i=4;
pozycja[2].j=2;
pozycja[3].i=4;
pozycja[3].j=3;
pozycja[4].i=4;
pozycja[4].j=4;
pozycja[5].i=3;
pozycja[5].j=4;
pozycja[6].i=2;
pozycja[6].j=4;
pozycja[7].i=1;
pozycja[7].j=4;
pozycja[8].i=0;
pozycja[8].j=4;
pozycja[9].i=0;
pozycja[9].j=5;
pozycja[10].i=0;//start 2
pozycja[10].j=6;
pozycja[11].i=1;
pozycja[11].j=6;
pozycja[12].i=2;
pozycja[12].j=6;
pozycja[13].i=3;
pozycja[13].j=6;
pozycja[14].i=4;
pozycja[14].j=6;
pozycja[15].i=4;
pozycja[15].j=7;
pozycja[16].i=4;
pozycja[16].j=8;
pozycja[17].i=4;
pozycja[17].j=9;
pozycja[18].i=4;
pozycja[18].j=10;
pozycja[19].i=5;
pozycja[19].j=10;
pozycja[20].i=6;//start 3
pozycja[20].j=10;
pozycja[21].i=6;
pozycja[21].j=9;
pozycja[22].i=6;
pozycja[22].j=8;
pozycja[23].i=6;
pozycja[23].j=7;
pozycja[24].i=6;
pozycja[24].j=6;
pozycja[25].i=7;
pozycja[25].j=6;
pozycja[26].i=8;
pozycja[26].j=6;
pozycja[27].i=9;
pozycja[27].j=6;
pozycja[28].i=10;
pozycja[28].j=6;
pozycja[29].i=10;
pozycja[29].j=5;
pozycja[30].i=10;//start 4
pozycja[30].j=4;
pozycja[31].i=9;
pozycja[31].j=4;
pozycja[32].i=8;
pozycja[32].j=4;
pozycja[33].i=7;
pozycja[33].j=4;
pozycja[34].i=6;
pozycja[34].j=4;
pozycja[35].i=6;
pozycja[35].j=3;
pozycja[36].i=6;
pozycja[36].j=2;
pozycja[37].i=6;
pozycja[37].j=1;
pozycja[38].i=6;
pozycja[38].j=0;
pozycja[39].i=5;
pozycja[39].j=0;

@Kubakuba dokładnie tak, Wyobraź sobie tą drogę jak okrąg najlepiej (kształt NIE MA tu znaczenia), współrzędne potrzebne będą tylko do rysowania.
Cała "matematyka" odbywać się będzie tylko na offsetach.

Z tego co przeczytałem na planszy może być kilka pionków zatem dla każdego pionka na mapie trzeba pamiętać:

• punkt początkowy (index) np. dla koloru żółtego 0, kolejnego 10, nast 20 i ostatniego 30
• aktualny offset (stan) pionka na trasie czyli to co jest dodawane do tego punktu początkowego dla danego koloru

musisz też sprawdzać okrążenia przydatna może okazać się reszta z dzielenia przez ilość wszystkich pól po dodaniu ruchu

// po edycji dokładnie miałem na myśli to co jest w ostatnim twoim poście

W jaki sposob zrobic teraz aby dla np. pozycja[0] wyswietlila sie plansza[4][0] ? Musze dodac cos do struktury? Albo chociaz zeby jakos "wyciagalo" i oraz j ze struktury dla danej pozycja[k] i znajac i oraz j wpisalo to do plansza[i][j]='' po czym zmienila wartosc na plansza[i][j]='1' (1 jako pionek, standardowo kazda plansza[i][j] po trasie ma wartosc '')

Chcialem zrobic cos takiego, ale program sie sypie. Ktos wie czemu?

 void start(char plansza[][11])
{
pozycja pozycja[40];
int i,j;
for(int licznik_rzutow=0;licznik_rzutow<3;licznik_rzutow++)
{
    srand(time(NULL));
    int n=rand()%6+1;
    cout<<"Gracz 1 wyrzucil: "<<endl;
    rysuj_kostke();
    cout<<endl;
    if(n==6)
    {
            cout<<"Wychodzisz pionkiem ze schowka..."<<endl;
            cout<<"Podaj nr wiersza: "<<endl;
            cin>>i;
            cout<<"Podaj nr kolumny: "<<endl;
            cin>>j;
            plansza[i][j]='_';
            plansza[pozycja[0].i][pozycja[0].j]='1'; // tu sie sypie
    }
}
}