Złe rysowanie planszy

Witam,
pisałem dwa razy na ten temat, wreszcie udało mi się to napisać ale teraz mam problem, ponieważ ponownie się rysuje plansza zamiast aktualizować się w jednym miejscu. Dziękuję z góry za odpowiedź.

//------------------------game.h------------------------
#pragma once
#include <string>
#include <iostream>
using namespace std;


class CGame;

// znak - czyli kółko lub krzyżyk :)
enum SIGN {SGN_NULL = '?', SGN_CIRCLE = 'O', SGN_CROSS = 'X' };

// pojedyncze pole (może być puste, mieć kółko lub krzyżyk)
enum FIELD { FLD_EMPTY = 0,				// puste
			 FLD_CIRCLE = SGN_CIRCLE,	// kółko
			 FLD_CROSS  = SGN_CROSS};	// krzyżyk

// stan gry
enum GAMESTATE { GS_NOTSTARTED,			// nie rozpoczęta
				 GS_MOVE,				// ruch gracza
				 GS_WON,				// wygrana gracza
				 GS_DRAW };				// remis

struct Gracz{
	string strNazwa;
	SIGN sgnZnak;
};

class CGame{
private:
	Gracz m_Player[2];
	GAMESTATE m_StanGry;
	Gracz m_AktualnyGracz;
	FIELD m_Plansza[3][3];
public:
	CGame();
	bool bStartGry(GAMESTATE);
	bool bRysuj(GAMESTATE);
	bool bRuch(GAMESTATE,unsigned);
	void wczytaj();
	void losowanie();
	void wypisz();
	GAMESTATE StanGry() { return m_StanGry;}
};

//------------------------game.cpp------------------------

#include "game.h"
#include <iostream>
using namespace std;

CGame::CGame()
{
		for(int i =1;i<2;i++)
		{
			m_Player[i].strNazwa = "???";
			m_Player[i].sgnZnak = SGN_NULL;
		}
		m_StanGry = GS_NOTSTARTED;
		
		for(int i =0;i<3;i++)
			for(int j =0;j<3;j++)
				m_Plansza[i][j] = FLD_EMPTY;

		m_AktualnyGracz.sgnZnak = SGN_NULL;
}

void CGame::wczytaj()
{
	for(int i =0;i<2;i++)
	{
	cout << "Podaj nazwe gracz nr. "<< i+1 <<": ";
	getline(cin,m_Player[i].strNazwa);
	}
}

void CGame::losowanie()
{

	m_Player[0].sgnZnak = SGN_CROSS;
	m_Player[1].sgnZnak = SGN_CIRCLE;
		
}

void CGame::wypisz()
{
	for(int i =0;i<2;i++)
		cout << m_Player[i].strNazwa << " - " << static_cast<char>(m_Player[i].sgnZnak)<<endl;
}

bool CGame::bStartGry(GAMESTATE StanGry)
{
	m_StanGry = StanGry;
	if(m_StanGry != GS_NOTSTARTED)
		return false;

	wczytaj();
	losowanie();
	system("cls");
	wypisz();
	m_AktualnyGracz = m_Player[0];

	m_StanGry = GS_MOVE;

	return true;
}

bool CGame::bRysuj(GAMESTATE StanGry)
{
	m_StanGry = StanGry;
	if(m_StanGry == GS_NOTSTARTED)
		return false;
	cout << "\tKOLKO I KRZYZYK\n";
	cout << "\t----------------\n\n";
	cout << "\t-----";
	for(int i =0;i<3;i++)
	{
		cout << "\t|";
		for(int j =0;j<3;j++)
		{
			if(m_Plansza[i][j] == FLD_EMPTY)
				cout<< i * 3 + j +1 ;
			else
				cout << static_cast<char>(m_Plansza[i][j]);
		}
		cout << "|\n";
	}
	cout <<"\t-----\n\n";


	switch (m_StanGry)
	{
	case GS_MOVE:
		cout << m_AktualnyGracz.strNazwa << " wykonuje ruch.\n";
		cout << "Podaj nr pola na ktorym chcesz postawic " << static_cast<char>(m_AktualnyGracz.sgnZnak)
			<< ": ";
		break;
	case GS_WON:
		cout <<"Wygral " <<m_AktualnyGracz.strNazwa<<endl;
		break;
	case GS_DRAW:
		cout << "Remis!!!\n";
		break;
	default:
		cout << "Blad\n";
		break;
	}

	return true;
}

bool CGame::bRuch(GAMESTATE StanGry,unsigned uNumerPola)
{
	m_StanGry = StanGry;
	if(m_StanGry != GS_MOVE) return false;

	if(!(uNumerPola >=1 && uNumerPola <= 9)) return false;
	unsigned uY = (uNumerPola - 1) / 3;
	unsigned uX = (uNumerPola - 1) % 3;

	if(m_Plansza[uY][uX] == FLD_EMPTY)
		m_Plansza[uY][uX] = static_cast<FIELD>(m_AktualnyGracz.sgnZnak);
	else
	{
		cout << "Blad!!!\nNie wolno dwa razy na te samo pole\n";
		return false;
	}
	const int LINIE[][3][2] = { { { 0, 0 }, { 0, 1 }, { 0, 2 } },	// górna pozioma
							{ { 1, 0 }, { 1, 1 }, { 1, 2 } },	// środkowa pozioma
							{ { 2, 0 }, { 2, 2 }, { 2, 2 } },	// dolna pozioma
							{ { 0, 0 }, { 1, 0 }, { 2, 0 } },	// lewa pionowa
							{ { 0, 1 }, { 1, 1 }, { 2, 1 } },	// środkowa pionowa
							{ { 0, 2 }, { 1, 2 }, { 2, 2 } },	// prawa pionowa
							{ { 0, 0 }, { 1, 1 }, { 2, 2 } },	// przekątna backslashowa
							{ { 2, 0 }, { 1, 1 }, { 0, 2 } } };	// przekątna slashowa

	FIELD FLD_Pole,FLD_ZgodnePola;
		unsigned uLiczbaZgodnychPol;
	for(int i =0;i<8;++i)
	{
		FLD_Pole = FLD_ZgodnePola = FLD_EMPTY;
		uLiczbaZgodnychPol =0;
		for(int j =0; j <3;j++)
		{
			FLD_Pole = m_Plansza[LINIE[i][j][0]][LINIE[i][j][1]];

			if(FLD_Pole != FLD_ZgodnePola)
			{
				FLD_ZgodnePola = FLD_Pole;
				uLiczbaZgodnychPol = 1;
			}
			else
				++uLiczbaZgodnychPol;

		}
		if(uLiczbaZgodnychPol == 3 && FLD_ZgodnePola != FLD_EMPTY)
		{
			m_StanGry = GS_WON;
			return true;
		}

	}
	unsigned uLiczbaZapelnionychPol = 0;
	for(int i =0;i<3;i++)
		for(int j =0;j<3;j++)
			if(m_Plansza[i][j] != FLD_EMPTY)
				++uLiczbaZapelnionychPol;
	if(uLiczbaZapelnionychPol == 3*3)
	{
		m_StanGry = GS_DRAW;
		return true;
	}

	m_AktualnyGracz.sgnZnak = (m_AktualnyGracz.sgnZnak == m_Player[0].sgnZnak ?  m_Player[1].sgnZnak : m_Player[0].sgnZnak );
	m_AktualnyGracz.strNazwa = (m_AktualnyGracz.strNazwa == m_Player[0].strNazwa ? m_Player[1].strNazwa : m_Player[0].strNazwa);
	return true;
}

//------------------------main.cpp------------------------
#include "game.h"
#include <iostream>

int main()
{
	CGame *Gra = new CGame;

	Gra->bStartGry(Gra->StanGry());
		
	for(;;)
	{
		Gra->bRysuj(Gra->StanGry());
	if(Gra->StanGry() == GS_MOVE)
		{
			unsigned uRuch;
			cin>>uRuch;
			cin.clear();
			cin.sync();
			Gra->bRuch(Gra->StanGry(),uRuch);
		}
	else if(Gra->StanGry() == GS_WON || Gra->StanGry() == GS_DRAW)
		break;
	}
     delete Gra;
	system("pause");
	return 0;
}
 

system("cls"); - czyści ekran (używasz to) po czym 'rysuje się' tak jakby w tym samym miejscu.