Tworzenie planszy do gry

Witam

Muszę napisać gre młynek na zaliczenie niestety nie wiem jak się do tego zabrać, nie chce zlecać zrobienie tego jakiejś firmie ponieważ chcę tego się nauczyć a nie ma lepszego sposobu jak zrobić to samemu, niestety nie nauczę się jeśli nie będę wiedział nawet jak zacząć. Mam wiele pytań jednak zacznę od podstawowego, nie wiem jak stworzyć plansze do gry, do tego chciałbym aby wyświetlona była ona wizualnie i co ruch zmieniało się na niej ustawienie pionka. na razie w zasadach plansze tą przedstawiłem w sposób następujący:
printf(" 1-----------2-----------3\n");
printf(" | | |\n");
printf(" | 4------5------6 |\n");
printf(" | | | | |\n");
printf(" | | 7--8--9 | |\n");
printf(" | | | | | |\n");
printf(" 1O--11--12 13--14--15\n");
printf(" | | | | | |\n");
printf(" | | 16-17-18 | |\n");
printf(" | | | | |\n");
printf(" | 19-----2O-----21 |\n");
printf(" | | |\n");
printf(" 22----------23---------24\n");

Chodzi mi o to aby zamiast liczb była wyświetlana litera czyj pionek jest na planszy np. B(biały), N(niebieski).
Potem jak umożliwić dodanie 9 pionków każdemu z graczy na stworzoną planszę i w jaki sposób umożliwić im poruszanie sie pomiędzy polami. Myślę iż musi być tu pewna zależność tzn. pion stojący na miejscu 1 może się ruszyć tylko na miejsce 2 i 10, ale nie może na pozostałe, jak to zrobić ?
Na początek to tyle proszę o pomoc ewentualne jakieś wskazówki bo nie wiem jak to ugryźć.

Aha jeszcze jedno w programie muszę użyć

•kapsułkowanie
•dziedziczenie
•polimorfizm
•szablony (własne)
•kontenery STL
•algorytmy STL

wyświetlanie możesz najprościej zrobić tak:

void rysuj(char* plansza) // lub: void rysuj(const vector<char>& plansza)
{
        printf("                           %c----------%c----------%c\n", plansza[0], plansza[1], plansza[2]);
        printf("                           |           |           |\n");
        printf("                           |    %c-----%c----%c    |\n", plansza[3], plansza[4], plansza[5]);
...
}

stwórz sobie klasę gra, która posiada metody w stylu:
bool wykonaj_ruch(int nr); // zwraca czy ruch udało się wykonać === czy ruch był poprawny
bool czy_wygrana() const; // wiadomo co zwraca
pole prywatne:
wyswietlacz_planszy* wyswietlacz;
vector<char> plansza;
konstruktor: gra(wyswietlacz_planszy* wyswietlacz): wyswietlacz(wyswietlacz), plansza(24,' ') { ... }

zrób sobie również klasę abstrakcyjną:
wyswietlacz_planszy, która będzie zawierała metody abstrakcyjne
virtual void rysuj();
void przypisz_gre(gra* _gra) { m_gra = _gra; }
pola protected:
gra* m_gra;

zrob sobie klase która po niej dziedziczy (np. wyswietlacz_konsolowy), zaimplementuj co trzeba

szablony oraz algorytmy stl będą chyba trochę na siłe, ale możesz je w sumie zaimplementować w klasie wyświetlającej wyniki (typ wyniku jako typ użyty w szablonie), a z algorytmow np. for_each do przejechania po wynikach

Ok a co oznacza to:

		void przypisz_gre(gra* _gra) { m_gra = _gra; }
		protected:
		gra* m_gra;

Bo nie rozumiem w ogole :S

na razie tak wyglądają moje klasy;

	class gra{
		
	public:
		gra(){char gracz1, char gracz2};
		bool czy_wygrana() const; // 1 -wygrana 0- przegrana
		
		

		}

		class plansza{// abstrakcyjna
			char plansza[23];
			char PionBialy;
			char BionNiebieski;
			int x=0;
			char kierunek // ruch w ktorym 
				plansza(){};
				for(x=0; x<24; x++)
	{
		plansza[x]='W';
	}
			void rysuj(char* plansza)
{
	HANDLE hCmdOut;																// Zmiana koloru czcionki
    hCmdOut = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleTextAttribute(hCmdOut, FOREGROUND_RED | FOREGROUND_INTENSITY);	// Zmiana koloru czcionki
		printf("\n");
		printf("%c-----------%c-----------%c      |  Legenda:\n", plansza[0], plansza[1], plansza[2]);
		printf("|           |           |      | W-Wolne miejsce.\n");
		printf("|    %c------%c------%c    |      | B-Pionek bialy.\n", plansza[3], plansza[4], plansza[5]);
		printf("|    |      |      |    |      | N-Pionek niebieski.              \n");
		printf("|    |   %c--%c--%c   |    |      |              \n", plansza[6], plansza[7], plansza[8]);
		printf("|    |   |     |   |    |      |              \n");
		printf("%c---%c----%c     %c---%c----%c      |              \n", plansza[9], plansza[10], plansza[11], plansza[12], plansza[13], plansza[14]);
		printf("|    |   |     |   |    |      |              \n");
		printf("|    |   %c--%c--%c   |    |      |              \n", plansza[15], plansza[16], plansza[17]);
		printf("|    |      |      |    |      |              \n");
		printf("|    %c------%c------%c    |      |              \n", plansza[18], plansza[19], plansza[20]);
		printf("|           |           |      |              \n");
		printf("%c-----------%c-----------%c      |              \n", plansza[21], plansza[22], plansza[23]);
}

			wyswietlacz_planszy;// która będzie zawierała metody abstrakcyjne
			rysuj();
			bool wykonaj_ruch(int nr); // zwraca czy ruch udało się wykonać == czy ruch był poprawny
			void przypisz_gre(gra* _gra) { m_gra = _gra; }
			protected:
			gra* m_gra;
			
		}
		class Pole { // tutaj to potrzebuj aby sprawdzac czy nie ma ulozonego ktorys z graczy calego rządku w mlynie 
		
		SetE(Pole &x){
			this->E=&x
		}
		SetW(Pole&x){
			this->W=&x
		}
		SetN(Pole &x){
			this->N=&x
		}
		SetS(Pole &x){
			this->S=&x
		}
		};