Inicjalizacja tablicy ze stałą zmienialną w kodzie. Kurs "Od zera do gier kodera".

#include "game.h"
#include <iostream>
#include <ctime>

FIELD g_aPlansza[ SIZE ][ SIZE ];

GAMESTATE g_StanGry = GS_NOTSTARTED;
SIGN g_AktualnyGracz;

bool StartGry()
{
    for( int i = 0; i < SIZE; i++ )
    for( int j = 0; j < SIZE; j++ )
         g_aPlansza[ i ][ j ] = FLD_EMPTY;
   
    if( g_StanGry != GS_NOTSTARTED ) return false;
   
    // losujemy gracza, który będzie zaczynał
    srand( static_cast < unsigned >( time( NULL ) ) );
    g_AktualnyGracz =( rand() % 2 == 0 ? SGN_CIRCLE
        : SGN_CROSS );
   
    // ustawaiamy stan gry na ruch graczy
    g_StanGry = GS_MOVE;
   
    return true;
}

bool Ruch( unsigned uNumerPola )
{
   
    if( g_StanGry != GS_MOVE ) return false;
   
    if( !( uNumerPola >= 1 && uNumerPola <= SIZE * SIZE ) ) return false;
   
    unsigned uY =( uNumerPola - 1 ) / SIZE;
    unsigned uX =( uNumerPola - 1 ) % SIZE;
   
    if( g_aPlansza[ uY ][ uX ] == FLD_EMPTY )
    // wstaw znak akualnego gracza w danym polu
         g_aPlansza[ uY ][ uX ] = static_cast < FIELD >( g_AktualnyGracz );
   
    else
         return false;
   
    /*int LINE [(SIZE*2)+2][SIZE][2] = { { {0,0}, {0,1}, {0,2}, {0,3} }, // górna pozioma
    { {1,0}, {1,1}, {1,2}, {1,3} }, // środ. pozioma
    { {2,0}, {2,1}, {2,2}, {2,3} }, // dolna pozioma
    { {3,0}, {3,1}, {3,2}, {3,3} },
    { {0,0}, {1,0}, {2,0}, {3,0} }, // lewa pionowa
    { {0,1}, {1,1}, {2,1}, {3,1} }, // środ. pionowa
    { {0,2}, {1,2}, {2,2}, {3,2} }, // prawa pionowa
    { {0,3}, {1,3}, {2,3}, {3,3} },
    { {0,0}, {1,1}, {2,2}, {3,3} }, // backslashow
    { {0}, {1}, {2}, {3} } }; // slashowa*/
    unsigned int LINE[( SIZE * 2 ) + 2 ][ SIZE ][ 2 ];
    int i, j, k;
    // pierwsza zmiennna
    for( i = 0; i < SIZE; ++i )
    for( j = 0; j < SIZE; ++j )
         LINE[ i ][ j ][ 0 ] = i;
   
    for( i = SIZE; i <( SIZE * 2 ) + 2; ++i )
    for( j = 0; j < SIZE; ++j )
         LINE[ i ][ j ][ 0 ] = j;
    // druga zmienna
    for( i = 0; i < SIZE; ++i )
    for( j = 0; j < SIZE; ++j )
         LINE[ i ][ j ][ 1 ] = j;
   
    for( i = SIZE; i < SIZE * 2; ++i )
    for( k = 0; k < SIZE; ++k )
    for( j = 0; j < SIZE; ++j )
         LINE[ i ][ j ][ 1 ] = k;
   
    for( k = SIZE; k = 0; k-- )
    for( j = 0; j < SIZE; ++j )
         LINE[( SIZE * 2 ) + 2 ][ j ][ 1 ] = k;
   
    FIELD Pole, ZgodnePole;
    unsigned uLiczbaZgodnychPol;
    for( int i = 0; i <( SIZE * 2 ) + 1; ++i )
    {
        // i przebiega po kolejnych możliwych liniach
       
        // zerujemy zmienne pomocnicze
        Pole = ZgodnePole = FLD_EMPTY; // obie zmienn == FLD_EMPTY
        uLiczbaZgodnychPol = 0;
       
        for( int j = 0; j < SIZE; ++j )
        {
            // j przebiega po polach w każdej linii
           
            // pobieramy rzeczone pole
            Pole = g_aPlansza[ LINE[ i ][ j ][ 0 ] ][ LINE[ i ][ j ][ 1 ] ];
           
            // jeśli sprawdzone pole różne od tego, które ma sie zgadzać...
            if( Pole != ZgodnePole )
            {
                // to zmieniamy zgodne pole na to aktualne
                ZgodnePole = Pole;
                uLiczbaZgodnychPol = 1;
            }
            else
            // jeśli natomiast oba pola zgadzają się to
            // inkrementujemy licznik takich zgodnych pól
                 ++uLiczbaZgodnychPol;
           
        }
       
        // teraz sprawdzamy czy udało nam się zgodzić linię
        if( uLiczbaZgodnychPol == SIZE && ZgodnePole != FLD_EMPTY )
        {
            // jeżeli tak to ustawiamy stan gry na wygraną
            g_StanGry = GS_WON;
           
            // przerywamy pętle i funkcję
            return true;
        }
    }
   
    unsigned uLiczbaZapelnionychPol = 0;
   
    for( int i = 0; i < SIZE; ++i )
    for( int j = 0; j < SIZE; ++j )
    if( g_aPlansza[ i ][ j ] != FLD_EMPTY )
         ++uLiczbaZapelnionychPol;
   
    if( uLiczbaZapelnionychPol == SIZE * SIZE )
    {
        g_StanGry = GS_DRAW;
        return true;
    }
   
    g_AktualnyGracz =( g_AktualnyGracz == SGN_CIRCLE ?
    SGN_CROSS: SGN_CIRCLE );
   
    return true;
}

bool RysujPlansze()
{
    if( g_StanGry == GS_NOTSTARTED ) return false;
   
    system( "cls" );
   
    cout << "    KOLKO I KRZYZYK    " << endl;
    cout << "-----------------------" << endl << endl;
    for( int i = 0; i < SIZE; ++i )
    {
        // lewa ramka
        cout << "         |";
       
        // wiersz
        for( int j = 0; j < SIZE; ++j )
        {
            if( g_aPlansza[ i ][ j ] == FLD_EMPTY )
            {
                // numer pola
                printf( "%3d", i * SIZE + j + 1 );
            }
            else
            // wyświetlamy kółko albo krzyżyk
                 cout << static_cast < char >( g_aPlansza[ i ][ j ] );
           
        }
       
        // prawa część ramki
        cout << "|" << endl;
    }
   
    switch( g_StanGry )
    {
    case GS_MOVE:
        // prośba o następny ruch
        cout << "Podaj numer pola, w ktorym" << endl;
        cout << "chcesz postawic ";
        cout <<( g_AktualnyGracz == SGN_CIRCLE ?
    "kolko": "krzyzyk" ) << ": ";
        break;
    case GS_WON:
        // informacja o wygranej
        cout << "Wygral gracz stawiajacy ";
        cout <<( g_AktualnyGracz == SGN_CIRCLE ?
    "kolko": "krzyzyk" ) << "!";
        break;
    case GS_DRAW:
        // informacje o remisie
        cout << "Remis!";
        break;
    }
   
   
    return true;
}