Kółko i krzyżyk nie działa poprawnie.

Witam,
Niedawno rozpocząłem swoją przygodę z programowania. Korzystam z kursu "Od zera do gierkodera".
Jednym z rozdziałów jest tworzenie gry w kółko i krzyżyk. Na podstawie tego kursu stworzyłem własną gre. Niestety gdzieś popełniłem błąd. GRa kompiluje się lecz nie działa poprawnie - stan planszy do gry sie nie zmienia. Czy ktoś z bardziej doświadczonych programistów mógłby mi pomoc w znalezeniu mojego błędu?

gra.h

#ifndef GRA_H_INCLUDED
#define GRA_H_INCLUDED

enum STAN_GRY
{
    STAN_NIEROZPOCZETA,
    STAN_RUCH,
    STAN_WYGRANA,
    STAN_REMIS
};
enum ZNAK
{
    ZNAK_KOLKO='O',
    ZNAK_KRZYZYK='X'
};
enum POLE
{
    POLE_PUSTE,
    POLE_KOLKO=ZNAK_KOLKO,
    POLE_KRZYZYK=ZNAK_KRZYZYK
};

extern STAN_GRY g_StanGry;
// prototypy funkcji
//------------------
bool StartGry();
bool Ruch(unsigned);
bool RysujPlansze();


#endif // GRA_H_INCLUDED
 

gra.cpp

#include "gra.h"
#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;

POLE g_Plansza[3][3]
{
    {POLE_PUSTE, POLE_PUSTE, POLE_PUSTE},
    {POLE_PUSTE, POLE_PUSTE, POLE_PUSTE},
    {POLE_PUSTE, POLE_PUSTE, POLE_PUSTE}
};
STAN_GRY g_StanGry = STAN_NIEROZPOCZETA;
ZNAK g_AktualnyGracz;

bool StartGry()
{
    if(g_StanGry!=STAN_NIEROZPOCZETA)
        return false;
    // losujemy gracza, który bêdzie zaczyna³
    srand(time(0));
    g_AktualnyGracz = (rand() % 2 == 0 ? ZNAK_KOLKO : ZNAK_KRZYZYK);

    // ustawiamy stan gry na ruch graczy
    g_StanGry=STAN_RUCH;
    return true;
}

bool RysujPlansze()
{
    if (g_StanGry==STAN_NIEROZPOCZETA)
        return false;
    system ("cls");
    cout<<"   KOLKO I KRZYZYK   "<<endl;
    cout<<"---------------------"<<endl;
    cout<<"         ---   "<<endl;
    for (int i=0;i<3;i++)
    {
        cout<<"        |";
        for (int j=0;j<3;j++)
        {
            if (g_Plansza[i][j] == POLE_PUSTE)
                cout << i * 3 + j + 1;
            else
            {
                cout << static_cast<char>(g_Plansza[i][j]);
            }
        }
        cout <<"|"<<endl;
    }
    cout<<"         ---   "<<endl<<endl;
    switch (g_StanGry)
    {
        case STAN_RUCH:
            cout << "Podaj numer pola, w ktorym" << endl;
            cout << "chcesz postawic ";
            cout << (g_AktualnyGracz == ZNAK_KOLKO ? "kolko" : "krzyzyk") << ": ";
        break;
        case STAN_WYGRANA:
            cout << "Wygral gracz stawiajacy ";
            cout << (g_AktualnyGracz == ZNAK_KOLKO ? "kolka" : "krzyzyki") << "!";
        break;
        case STAN_REMIS:
            cout << "Remis!";
        break;
    }
    return true;
}

bool Ruch(unsigned uNumerPola)
{
    if(g_StanGry!=STAN_RUCH)
        return false;
    if(!(uNumerPola >= 1 && uNumerPola <= 9))
        return false;
    unsigned uY = (uNumerPola - 1) / 3;
    unsigned uX = (uNumerPola - 1) % 3;
    if (g_Plansza[uY][uX]!=POLE_PUSTE)
    {
        g_Plansza[uY][uX] = static_cast<POLE>(g_AktualnyGracz);
    }
    else
        return false;
    const int LINIE[][3][2] = { { { 0,0 }, { 0,1 }, { 0,2 } }, // górna pozioma
                            { { 1,0 }, { 1,1 }, { 1,2 } },// œrod. pozioma
                            { { 2,0 }, { 2,1 }, { 2,2 } },// dolna pozioma
                            { { 0,0 }, { 1,0 }, { 2,0 } }, // lewa pionowa
                            { { 0,1 }, { 1,1 }, { 2,1 } }, // œrod. pionowa
                            { { 0,2 }, { 1,2 }, { 2,2 } }, // prawa pionowa
                            { { 0,0 }, { 1,1 }, { 2,2 } }, // p. backslashowa
                            { { 2,0 }, { 1,1 }, { 0,2 } } }; // p. slashowa

    POLE Pole, ZgodnePole;
    unsigned LiczbaZgodnychPol;
    for(int i=0;i<8;i++)
    {
        Pole=POLE_PUSTE;
        ZgodnePole=POLE_PUSTE;
        LiczbaZgodnychPol=0;
        for (int j=0;j<3;j++)
        {
            Pole = g_Plansza[LINIE[i][j][0]][LINIE[i][j][1]];
            // jeœli sprawdzane pole ró¿ne od tego, które ma siê zgadzaæ...
            if (Pole != ZgodnePole)
            {
                // to zmieniamy zgadzane pole na to aktualne
                ZgodnePole = Pole;
                LiczbaZgodnychPol = 1;
            }
            else
                // jeœli natomiast oba pola siê zgadzaj¹, no to
                // inkrementujemy licznik takich zgodnych pól
                ++LiczbaZgodnychPol;
            // teraz sprawdzamy, czy uda³o nam siê zgodziæ liniê
        }
        if (LiczbaZgodnychPol == 3 && ZgodnePole != POLE_PUSTE)
            {
            // je¿eli tak, no to ustawiamy stan gry na wygran¹
            g_StanGry = STAN_WYGRANA;
            // przerywamy pêtlê i funkcjê
            return true;
        }

    }

    unsigned LiczbaZapelnionychPol = 0;
    for (int i = 0; i < 3; ++i)
    {
        for (int j = 0; j < 3; ++j)
        {
            if (g_Plansza[i][j] != POLE_PUSTE)
            ++LiczbaZapelnionychPol;
        }
    }
    if (LiczbaZapelnionychPol == 3*3)
    {
        g_StanGry = STAN_REMIS;
        return true;
    }
    g_AktualnyGracz = (g_AktualnyGracz == ZNAK_KOLKO ?
                    ZNAK_KRZYZYK : ZNAK_KOLKO);
    return true;
} 

main.cpp

#include <iostream>
#include "gra.h"

using namespace std;


int main()
{
    StartGry();

    for(;;)
    {
        RysujPlansze();
        if (g_StanGry == STAN_RUCH)
        {
            unsigned uNumerPola;
            cin >> uNumerPola;
            Ruch (uNumerPola);
        }
        else if (g_StanGry == STAN_WYGRANA || g_StanGry == STAN_REMIS)
            break;
    }
    ("PAUSE");
    return 0;
}
 

   if (g_Plansza[uY][uX]!=POLE_PUSTE)
    {
        g_Plansza[uY][uX] = static_cast<POLE>(g_AktualnyGracz);
    }
    else
        return false;

Z racji, że początkowo wszystkie pola mają wartość PUSTE_POLE, zamiast przypisywać wykonuje "return false";

Już widzę. Powinno być == a nie !=.
Bardzo Ci dziekuję.