Wykrywanie wygranej w grze kółko i krzyżyk dla dowolnej ilości pól

Question

Napisałem program na poprawę oceny(2 klasa liceum) kółko i krzyżyk z tym że to gracz wybiera jak duże ma być pole. Mam jednak jeden problem, mianowicie program nie wykrywa wygranej dla drugiego diagonala i nie mogę znaleźć błędu może komus się uda

//Poni¿szy program to kó³ko i krzy¿yk z opcj¹ wybranie wielkosci planszy
//Program zawiera pe³n¹ obs³ugê b³êdów
//Ze wzglêdów estetycznych nie mo¿na wybraæ wiêkszej planszy ni¿ 10
#include <iostream>
#include <cstdlib>
#include <sstream>
#include <conio.h>
using namespace std;

void PokazMenu (char &znak, string &rozmiar);
void RysujPlansze (char znak, int rozmiar, char **pole, char kto);
void RuchGracza (char **pole, string rozmiar, char znak);
bool CzyWygrana (char **pole, int rozmiar);
bool CzyPoprawnePole (string x, string y, char **pole, string rozmiar);
bool CzyPoprawneMenu (string rozmiar, string brzeg);
bool CzyLiczba (string liczba);
string ToString(const int& obj);
int stoi(string A);
bool CzyKoniec();

main()
{
    char znak;
    string rozmiar;
    do
    {
       PokazMenu(znak, rozmiar);
       int roz = stoi(rozmiar);

       char **pole = new char *[roz];

       for(int i = 0; i < roz; i++)
       {
           pole[i] = new char [roz];

           for(int j = 0; j < roz; j++)
           {
               pole[i][j] = 'e';
           }
       }

       RysujPlansze(znak, roz, pole, '\0');
       RuchGracza(pole, rozmiar, znak);

       delete [] pole;

    } while (CzyKoniec() != true);
}
//--------------------------------------------------------------------------------
void PokazMenu(char &znak, string &rozmiar)
{
    system("cls");
    string brzeg = "[                                        ]\r[";
    cout << brzeg << "  Witaj w grze kolko i krzyzyk!\n"
         << brzeg << "  Polecam zmienic czcionke na rastrowa\n"
         << brzeg << "  Podaj rozmiar planszy ( <10 ):\n";

    do
    {
        cout << brzeg << "  ";
        cin  >> rozmiar;

    } while(!CzyPoprawneMenu(rozmiar, brzeg));

    cout << brzeg << "  Podaj wzor planszy\n"
         << brzeg << "  ";
    cin  >> znak;
    system("cls");
}
//---------------------------------------------------------
void RysujPlansze(char znak, int rozmiar, char **pole, char kto)
{
    int d = rozmiar*5 + 2;
    system("cls");
    for(int y = 0; y < d; y++)
    {
        for(int x = 0; x < d; x++)
        {
            if(y == 0 && !((x-2) % 5))
            {
                cout << x/5 + 1;
            }

            else if(x == 0 && !((y-2) % 5))
            {
                cout << y/5 + 1;
            }

            else if (x > 0 && y > 0 &&
                    ((x-1) % 5 == 0  || (y-1) % 5 == 0))
            {
                cout << znak;
            }

            else
            {
                if(pole[(y-2)/5][(x-2)/5] == 'o')
                {

                    if (((x - 3)%5 == 0 && (y - 3)%5 == 0) ||
                       ((x - 4)%5 == 0 && (y - 4)%5 == 0))
                    {
                        cout << "/";
                    }

                    else if (((x - 3)%5 == 0 && (y - 4)%5 == 0) ||
                            ((x - 4)%5 == 0 && (y - 3)%5 == 0))
                    {
                        cout << "\\";
                    }

                    else
                    {
                        cout << " ";
                    }
                }

                else if(pole[(y-2)/5][(x-2)/5] == 'x')
                {
                    if (((x - 3)%5 == 0 && (y - 3)%5 == 0) ||
                       ((x - 4)%5 == 0 && (y - 4)%5 == 0))
                    {
                        cout << "\\";
                    }

                    else if (((x - 3)%5 == 0 && (y - 4)%5 == 0) ||
                            ((x - 4)%5 == 0 && (y - 3)%5 == 0))
                    {
                        cout << "/";
                    }

                    else
                    {
                        cout << " ";
                    }
                }
                else cout << " ";
            }
        }
        cout << endl;

    }
    cout << endl;
}
//--------------------------------------------------------------------------------
bool CzyWygrana(char **pole, int rozmiar)
{
    int N = rozmiar - 1;
    bool * licznik = new bool[N];

    //Wygrana w poziomie
    for(int y = 0; y < N + 1; y++)
    {
        int i = 0;
        int x = 0;

        for(; x < N; x++)
        {
            if(pole[y][x] == pole[y][x + 1] && pole[y][x] != 'e' )
            {
                licznik[x] = 1;
            }

            else
            {
                licznik[x] = 0;
            }
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1) break;
        }

        if(i == N)
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }

            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
    }

    //Wygrana w pionie
    for(int x = 0; x < N + 1; x++)
    {
        int i = 0;
        int y = 0;

        for(; y < N; y++)
        {
            if(pole[y][x] == pole[y + 1][x] && pole[y][x] != 'e' )
            {
                licznik[y] = 1;
            }

            else
            {
                licznik[x] = 0;
            }
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1) break;
        }

        if(i == N)
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }

            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
    }
    //Wygrana diagonalna '\'
   {
       int x = 0, i = 0;

       for(; x < N; x++)
       {
           if(pole[x][x] == pole[x + 1][x + 1] && pole[x][x] != 'e' )
           {
               licznik[x] = 1;
           }

           else
           {
               licznik[x] = 0;
           }
       }

       for(; i < N; i++)
       {
            if(licznik[i] != 1)
            {
               break;
            }
       }

       if(i == N)
       {
            if(pole[x][x] == 'o')
            {
                  cout << "Wygrywa kolko";
                  return 1;
            }

            else
            {
                  cout << "Wygrywa krzyzyk";
                  return 1;
            }
         }

         return 0;
   }

    //Wygrana diagonalna2 /
     {
       int x = 0, i = 0, y = N;

       for(; x < N; x++, y--)
       {
           if(pole[y][x] == pole[y - 1][x + 1] && pole[y][x] != 'e' )
           {
               licznik[x] = 1;
           }

           else
           {
               licznik[x] = 0;
           }
       }

       for(; i < N; i++)
       {
            if(licznik[i] != 1)
            {
               break;
            }
       }

       if(i == N)
       {
            if(pole[y][x] == 'o')
            {
                  cout << "Wygrywa kolko";
                  return 1;
            }

            else
            {
                  cout << "Wygrywa krzyzyk";
                  return 1;
            }
         }

         return 0;
   }
    delete [] licznik;
}
//--------------------------------------------------------------------------------
void RuchGracza(char **pole, string rozmiar, char znak)
{
    int roz = stoi(rozmiar);
    char kto = 'o';
    string sX, sY;
    int i = 0;
    do
    {
        if(i == roz*roz)
        {
           cout << "Remis";
           break;
        }
        do
        {
            cout << "Ruch gracza '" << kto
                 << "'\nPodaj wspolrzedne: ";
            cin >> sX >> sY;
        } while(!CzyPoprawnePole(sX, sY, pole, rozmiar));

        int x = stoi(sX), y = stoi(sY);

        if (kto == 'o')
        {
            pole[y - 1][x - 1] = 'o';
            RysujPlansze(znak, roz, pole, kto);
            kto = 'x';
        }
        else if (kto == 'x')
        {
            pole[y - 1][x - 1] = 'x';
            RysujPlansze(znak, roz, pole, kto);
            kto = 'o';
        }

        i++;
    } while(!CzyWygrana(pole, roz));

}
//--------------------------------------------------------------------------------
bool CzyPoprawnePole(string sX, string sY, char **pole, string rozmiar)
{
    int roz = stoi(rozmiar);
    int x = stoi(sX), y = stoi(sY);

    if(!CzyLiczba(sX) || !CzyLiczba(sY))
    {
        cout << "\nTo nie jest liczba!\n"
             << "Sprobuj jeszcze raz.\n\n";
        return 0;
    }

    if(x > roz || y > roz || x < 1 || y < 1)
    {
        cout << "Podales nie poprawne dane! Sprobuj jeszcze raz.\n";
        return 0;
    }

    if(pole[y - 1][x - 1] != 'e')
    {
        cout << "To pole jest zajete! Sprobuj jeszcze raz.\n";
        return 0;
    }

    return 1;
}
//--------------------------------------------------------------------------------
bool CzyPoprawneMenu (string rozmiar, string brzeg)
{
   int roz = stoi(rozmiar);
   if(!CzyLiczba(rozmiar))
    {
        cout << brzeg << "  To nie jest liczba!\n"
             << brzeg << "  Sprobuj jeszcze raz.\n";
        return 0;
    }

    if(roz <= 0 || roz > 9)
    {
        cout << brzeg << "  Podales nie poprawne dane!\n"
             << brzeg << "  Sprobuj jeszcze raz.\n";
        return 0;
    }

    return 1;
}
//--------------------------------------------------------------------------------
bool CzyLiczba(string liczba)
{
   for( int i = 0; i < liczba.length(); i++ )
   {
        if (!isdigit (liczba[i]))
        {
            return 0;
        }
   }

   return 1;
}
//--------------------------------------------------------------------------------
bool CzyKoniec()
{
   getch();
   int Koniec;

   while(true)
   {
      system("cls");
      cout << "     **MENU**\n\n"
           << "1. Zagraj jeszcze raz\n"
           << "2. Koniec gry\n";

      Koniec = getch();

      if(Koniec == '1')
      {
         return 0;
      }

      else if(Koniec == '2')
      {
         return 1;
      }

      else
      {
         cout << "Nie poprawny znak. Sprobuj jeszcze raz";
      }
   }

}
//--------------------------------------------------------------------------------
int stoi(string str)
{
    return atoi(str.c_str());
}

 

Answer 1

Sprubuję pomóc. Na cpp 11 masz przeładowane stoi();

Comments

Aplikacja ma problemy przy postawieniu 2 znaków, których przedłużenie wychodzi poza planszę. Błąd występuje przed sprawdzaniem wygranej. Komunikat: bad_alloc.

---

Problem występuje tylko przy wielkości planszy 9, najprościej ograniczyć bardziej wielkość.

---

:D linijka 270

Cout najlepszym debugerem.

---

Nie do końca rozumiem co powoduje ten błąd, czy mógłbys napisać jeszcze raz i błąd z nie wykrywaniem wygranej działa również dla mniejszych plansz.

A ta nazwa stoi(), tylko dlatego że nie wiedziałem jak mam korzystać z c++ 11 w codeblocksie, więc napisałem sobie własną funkcję.

---

Wiesz już co jest nie tak z linią 270? Nie pisałem, że nie wykrywa wygranej, to wiadome + patrz zdanie wcześniej. Problem to crash. Postaw takie same znaki w 1x1 i 2x1 na wielkości 9. Więcej napisać nie mogę, zalecenia z góry.