Hjälp med fem i rad c++

// ------------------
// | Fem-I-Rad Spel |
// ------------------

// Inkludera filer som används.
#include <stdio.h>		// printf, scanf_s	(utmatning, inmatning)
#include <stdlib.h>     // srand, rand		(slumpgenerator)
#include <time.h>       // time				(klockan)

// Vi börjar med att definiera konstanter för spelet.
#define BOARD_SIZE 10		// Storleken på spelplanen.
#define MARKERS_TO_WIN 5	// Antal pjäser i rad som krävs för att vinna.
#define EMPTY_MARKER '-'	// Bokstav som representerar en tom ruta på spelplanen.
#define PLAYER_1_MARKER 'X'	// Boksatav som representerar den första spelarens pjäser.
#define PLAYER_2_MARKER 'O' // Boksatav som representerar den andra spelarens pjäser.

// Deklarera Globala variabler som spelet använder.
char board[BOARD_SIZE][BOARD_SIZE];	// 2-Dimensionell array av bokstäver som representerar spelplanen, bokstäverna kan antingen vara "EMPTY_MARKER", "PLAYER_1_MARKER" eller "PLAYER_2_MARKER".
int lastMarkerX, lastMarkerY;		// Vi lagrar positionen för den senaste placerade spelpjäsen, därför att vi kan då enkalre testa om en spelare har vunnit.

// Funktioner som spelet använder sig utav.
void initBoard();								// Nollställa spelplanen.
void printBoard();								// Skriva ut spelplanen.
bool placeMarker(int x, int y, char marker);	// Placera spelpjäs.
void playMultiplayer();							// Själva spelet för två spelare.
void playSingleplayer();						// Själva spelet mot dator.
bool humanTurn(char marker);					// En mänsklig spelares drag.
bool computerTurn(char marker);					// Datorns drag.
bool checkWin();								// Kolla om senaste draget gjorde att spelaren vann.
bool checkMultiplayer();						// Kolla om användaren vill spela mot en annan spelare, eller mot datorn.

// Huvudprogrammet, detta körs när programet startas.
int main(){
	printf("Welcome to 5-in-a-row!\n");	// Skriv ut välkomst text.
	srand(time(NULL));					// Initiera slumpgenerator från klockan.
	initBoard();						// Nollställer spelplanen.
	if (checkMultiplayer())				// Kolla om det ska vara multiplayer.
		playMultiplayer();				// Starta spelet för två spelare.
	else playSingleplayer();			// Annars starta spelet för en spelare.
    return 0;		
}

// Kolla om användaren vill spela mot en annan spelare, eller mot datorn.
bool checkMultiplayer() {
	char choice;							// Bokstav för val som användaren anger.
	printf("Select gamemode:\n");			// Skriv ut val av spelläge.
	printf("1.) Human vs human.\n");		// Skriv ut Alternativ 1, två spelare mot varandra.
	printf("2.) Human vs computer.\n");		// Skriv ut Alternativ 2, spelare mot dator.
	printf("Your choice: ");				// Skriv ut ange val.
	scanf_s("%c", &choice);					// Låt användare skriva in sitt val.
	if (choice == '1') return true;			// Om Alternativ 1, returnera sant
	return false;							// Annars, returnara falskt.
}

// Själva spelet för två spelare.
void playMultiplayer() {
	printBoard();
	char currentPlayer = PLAYER_1_MARKER;				// Variabel för den nuvarande spelaren som har sin tur att spela.
	bool done = false;									// Variabel för att se om spelet är klart eller som det ska fortsätta.
	while (!done) {										// När spelet inte är klart, fortsätt spela.
		printf("Player %c:s turn\n", currentPlayer);	// Skriv ut vems tur att spela.
		while (!humanTurn(currentPlayer));				// Vi använder en loop, så om spelaren misslyckas med att välja en ruta får denne försöka igen.
		printBoard();									// Rita ut spelplanen.
		done = checkWin();								// Kolla om spelaren vann.
		currentPlayer = currentPlayer == PLAYER_1_MARKER ? PLAYER_2_MARKER : PLAYER_1_MARKER;	// Här byter vi till nästa spelare.
	}
	printf("Congratualtions Player %c, you won!\n", board[lastMarkerX][lastMarkerY]);			// Skriv ut vem som vann.
}

// En människas tur att spela.
bool humanTurn(char marker) {
	int x, y;										// Variabler Rad och kolumn som spelaren vill placera sin pjäs på.
	printf("Select location to place marker...\n");	// Skriver ut att spelaren ska välja var hon vill placera sin pjäs.
	printf("Enter row: ");							// Skriver ut frågan om vilken rad spelaren vill placera på.
	scanf_s("%d", &x);								// Låter spelaren skriva in vilken rad som den vill placera spelpjäsen på.
	printf("Enter column: ");						// Skriver ut frågan om vilken kolumn spelaren vill placera på.
	scanf_s("%d", &y);								// Låter spelaren skriva in vilken kolumn som den vill placera spelpjäsen på.
	return placeMarker(x, y, marker);				// Placera pjäsen på spelplanen.
}

// Placera spelpjäs.
bool placeMarker(int x, int y, char marker) {
	if (board[x][y] != EMPTY_MARKER) return false;			// Om det redan finns än pjäs på rutan, returnera falskt. (det gick ej att placera pjäsen).
	board[x][y] = marker;									// Placera spelpjäsen på brädet.
	lastMarkerX = x;										// Vi lägger undan raden för pjäsen i den globala variabeln för senast placerade pjäs rad position.
	lastMarkerY = y;										// Vi lägger undan kolumnen för pjäsen i den globala variabeln för senast placerade pjäs kolumn position.
	return true;
}

// Skriva ut spelplanen.
void printBoard() {
	printf("  ");											// Skriv ut tomma mellanslag för att snygga till.
	for (int i = 0; i < BOARD_SIZE; i++) printf("%2d", i);	// Skriv ut nummer för kolumnerna.
	for (int i = 0; i < BOARD_SIZE; i++) {					// Gå igenom alla rader.
		printf("\n%2d ", i);								// för varje rad på spelplanen, skriv ut en ny rad, och skriv ut nummer för raderna.
		for (int j = 0; j < BOARD_SIZE; j++)				// Gå igenom alla kolumner.
			printf("%c ", board[i][j]);						// Skriv ut spelmarkörerna på spelplannen.
	}
	printf("\n");											// Byt rad.
}

// Nollställa spelplanen.
void initBoard() {
	for (int i = 0; i < BOARD_SIZE; i++)				// Gå igenom alla rader.
		for (int j = 0; j < BOARD_SIZE; j++)			// Gå igenom alla kolumner.
			board[i][j] = EMPTY_MARKER;					// Placera en tom markör på spelplanen.
}

// Kollar om den senaste placerade pjäsen gjorde att spelaren vann.
bool checkWin() {
	char marker = board[lastMarkerX][lastMarkerY];		// Senaste spelarens spelpjäs.
	int left = 0, right = 0, up = 0, down = 0;			// Antal likadana pjäser längs olika riktningar.
	int leftUp = 0, leftDown = 0, rightUp = 0, rightDown = 0;

	// Undersök vinst: vertikalt.
	for (int x = lastMarkerX; x >= 0; x--) {			// Kolla alla pjäser upp.
		if (board[x][lastMarkerY] == marker) up++;		// Om samma pjäs: öka antal pjäser i rad upp med ett.
		else break;										// Om inte samma pjäs: sluta kolla åt upp.
	}
	for (int x = lastMarkerX; x < BOARD_SIZE; x++) {	// Kolla alla pjäser ned.
		if (board[x][lastMarkerY] == marker) down++;	// Om samma pjäs: öka antal pjäser i rad ned med ett.
		else break;										// Om inte samma pjäs: sluta kolla åt ned.
	}
	if (up + down > MARKERS_TO_WIN) return true;		// Om antal pjäser till upp och ned är störe än kravet för vinst (större eftersom mitten pjäsen räknas två gånger), då är det vinst och vi returnerar sant. 

														// Undersök vinst: horisontellt.
	for (int y = lastMarkerY; y >= 0; y--) {			// Kolla alla pjäser vänster.
		if (board[lastMarkerX][y] == marker) left++;	// Om samma pjäs: öka antal pjäser i rad vänster med ett.
		else break;										// Om inte samma pjäs: sluta kolla åt vänster.
	}
	for (int y = lastMarkerY; y < BOARD_SIZE; y++) {	// Kolla alla pjäser höger.
		if (board[lastMarkerX][y] == marker) right++;	// Om samma pjäs: öka antal pjäser i rad höger med ett.
		else break;										// Om inte samma pjäs: sluta kolla åt höger.
	}
	if (left + right > MARKERS_TO_WIN) return true;		// Om antal pjäser till höger och vänster är störe än kravet för vinst (större eftersom mitten pjäsen räknas två gånger), då är det vinst och vi returnerar sant. 

														// Undersök vinst: diagonalt vänster-upp till höger-ned.
	for (int x = lastMarkerX, y = lastMarkerY; x >= 0 && y >= 0; x--, y--) {	// Kolla alla pjäser vänster-upp.
		if (board[x][y] == marker) leftUp++;									// Om samma pjäs: öka antal pjäser i diagonalen vänster-upp med ett.
		else break;																// Om inte samma pjäs: sluta kolla åt diagonalen vänster-upp.
	}
	for (int x = lastMarkerX, y = lastMarkerY; x < BOARD_SIZE && y < BOARD_SIZE; x++, y++) {	// Kolla alla pjäser höger-ned.
		if (board[x][y] == marker) rightDown++;													// Om samma pjäs: öka antal pjäser i diagonalen höger-ned med ett.
		else break;																				// Om inte samma pjäs: sluta kolla åt diagonalen höger-ned.
	}
	if (leftUp + rightDown > MARKERS_TO_WIN) return true; // Om antal pjäser diagonalt vänster-upp till höger-ned är störe än kravet för vinst (större eftersom mitten pjäsen räknas två gånger), då är det vinst och vi returnerar sant. 

														  // Undersök vinst: diagonalt höger-upp till vänster-ned.
	for (int x = lastMarkerX, y = lastMarkerY; x >= 0 && y < BOARD_SIZE; x--, y++) {	// Kolla alla pjäser höger-upp.
		if (board[x][y] == marker) rightUp++;											// Om samma pjäs: öka antal pjäser i diagonalen höger-upp med ett.
		else break;																		// Om inte samma pjäs: sluta kolla åt diagonalen höger-upp.
	}
	for (int x = lastMarkerX, y = lastMarkerY; x < BOARD_SIZE && y >= 0; x++, y--) {	// Kolla alla pjäser vänster-ned.
		if (board[x][y] == marker) leftDown++;											// Om samma pjäs: öka antal pjäser i diagonalen vänster-ned med ett.
		else break;																		// Om inte samma pjäs: sluta kolla åt diagonalen vänster-ned.
	}
	if (rightUp + leftDown > MARKERS_TO_WIN) return true; // Om antal pjäser diagonalt höger-upp till vänster-ned är störe än kravet för vinst (större eftersom mitten pjäsen räknas två gånger), då är det vinst och vi returnerar sant. 

	return false;	// Ingen vinst har hittats, alltså returnerar vi falskt.
}

// En dators tur att spela.
bool computerTurn(char marker) {
	int x, y;										// Variabler Rad och kolumn som datorn vill placera sin pjäs på.
	x = rand() % BOARD_SIZE;						// Datorn väljer en slupvis rad på spelplanen.
	y = rand() % BOARD_SIZE;						// Datorn väljer en slupvis kolumn på spelplanen.
	return placeMarker(x, y, marker);				// Placerar pjäsen på spelplanen.
}

// Själva spelet mot dator.
void playSingleplayer() {
	printBoard();
	char currentPlayer = PLAYER_1_MARKER;				// Variabel för den nuvarande spelaren som har sin tur att spela.
	bool done = false;									// Variabel för att se om spelet är klart eller som det ska fortsätta.
	while (!done) {										// När spelet inte är klart, fortsätt spela.
		printf("Player %c:s turn\n", currentPlayer);	// Skriv ut vems tur att spela.
		if (currentPlayer == PLAYER_1_MARKER)			// Kolla om människas tur.
			while (!humanTurn(currentPlayer));			// Vi använder en loop, så om spelaren misslyckas med att välja en ruta får denne försöka igen.
		else											// Annars är det datorns tur.
			while (!computerTurn(currentPlayer));
		printBoard();									// Rita ut spelplanen.
		done = checkWin();								// Kolla om spelaren vann.
		currentPlayer = currentPlayer == PLAYER_1_MARKER ? PLAYER_2_MARKER : PLAYER_1_MARKER;	// Här byter vi till nästa spelare.
	}
	if (board[lastMarkerX][lastMarkerY] == PLAYER_1_MARKER)	// Kolla om spelaren vann.
		printf("Congratualtions, you won!\n");				// Skriv ut vinst-text.
	else													// Annars vann datorn.
		printf("To bad, you loose!\n");						// Skriv ut förlust-text.
}

// ----------------------------
// | Fem-I-Rad Spel Med Musen |
// ----------------------------

#include <windows.h>	// Händelser.
#include <stdio.h>		// Inmatning.
#include <stdlib.h>     // Slumpgenerator.
#include <time.h>       // Klockan.(används bara av slumpgeneratorn)

//  ------------------------------------------------------------------------------------------------------
//  ---------------------- HÄNDELSE-KOD FÖRBEREDELSER ----------------------------------------------------
//  ------------------------------------------------------------------------------------------------------

// Definierar konstanter till fönster och händelser.
#define MOUSE_PRESSED_OR_RELEASED 0		// 0 betyder att knapp är tryckt eller släppt.
#define EVENT_BUFFER_SIZE 128			// Antal händelser som kan lagras i bufferten för händelser.

// Globala variabler till fönster och händelser.
INPUT_RECORD eventInputBuffer[EVENT_BUFFER_SIZE];			 // Händelse Buffert
DWORD nrOfEvents;											 // Antal händelser som ligger i händelse bufferten. 
HANDLE consoleInputHandle = GetStdHandle(STD_INPUT_HANDLE);	 // Hämtar hantaget till standard input som hör till konsollen. 
HANDLE consoleOutputHandle = GetStdHandle(STD_OUTPUT_HANDLE);// Hämtar hantaget till standard output som hör till konsollen. 

// Funktioner för händelsehantering.
void initConsole();									// Ställer in konsollen för att hantera händelser.
void clearScreen();									// Rensar skärmen och ställer in konsollen för att hantera händelser på nytt.
void eventHandler();								// Läser in och hanterar händelser.
void keyboardEventHandler(KEY_EVENT_RECORD);		// Hanterar tangentbords-tryckningar.
void mouseEventHandler(MOUSE_EVENT_RECORD);			// Hanterar mus-tryckningar.

//  ------------------------------------------------------------------------------------------------------
//  ---------------------- SPEL-KOD FÖRBEREDELSER --------------------------------------------------------
//  ------------------------------------------------------------------------------------------------------

// Vi börjar med att definiera konstanter för spelet.
#define BOARD_SIZE 10		// Storleken på spelplanen.
#define MARKERS_TO_WIN 5	// Antal pjäser i rad som krävs för att vinna.
#define EMPTY_MARKER '-'	// Bokstav som representerar en tom ruta på spelplanen.
#define PLAYER_1_MARKER 'X'	// Boksatav som representerar den första spelarens pjäser.
#define PLAYER_2_MARKER 'O' // Boksatav som representerar den andra spelarens pjäser.

// Vi definierar de olika lägen spellet kan befinna sig i.
#define GAME_STATE_START_MENU 1	// Spelet kan vara i huvudmeny.
#define GAME_STATE_HUMAN 2		// Det kan vara en människas tur att spela.
#define GAME_STATE_COMPUTER 3	// Det kan vara en dators tur att spela.
#define GAME_STATE_END 4		// Spelet är över.

#define START_MENU_OPTION_MULTIPLAYER 1		// Vilken rad på menyn knappen för multiplayer ligger på.
#define START_MENU_OPTION_SINGLEPLAYER 2	// Vilken rad på menyn knappen för singleplayer ligger på.

// Deklarera Globala variabler som spelet använder.
char currentGameState = GAME_STATE_START_MENU;	// Variabel för nuvarande spelläge, spelet börjar på start menyn.
char board[BOARD_SIZE][BOARD_SIZE];				// 2-Dimensionell array av bokstäver som representerar spelplanen, bokstäverna kan antingen vara "EMPTY_MARKER", "PLAYER_1_MARKER" eller "PLAYER_2_MARKER".
int lastMarkerX, lastMarkerY;					// Vi lagrar positionen för den senaste placerade spelpjäsen, därför att vi kan då enkalre testa om en spelare har vunnit.
bool isMultiplayer;								// Variabel som bestämmer om spelet är mot andra spelare eller mot datorn.
char currentPlayer = PLAYER_1_MARKER;			// Håller reda på vems tur det är, börjar på spelare ett.

// Funktioner som spelet använder sig utav.
void initBoard();								// Nollställa spelplanen.
bool placeMarker(int x, int y, char marker);	// Placera spelpjäs.
void humanPlay(int x, int y);					// Människans drag.
bool computerPlay(char marker);					// Datorns drag.
bool checkWin();								// Kolla om senaste draget gjorde att spelaren vann.
void gameRound(bool *done);						// En runda på spelet.
void startMenu(int y);							// Startmeny.

// Grafik funktioner.
void printMenu();								// Skriv ut startmeny.
void printBoard();								// Skriva ut spelplanen.
void printVictory();							// Skriv ut vem som vann.

//  ------------------------------------------------------------------------------------------------------
//  ---------------------- Huvudfunktionen som körs när programmet startas. ------------------------------
//  ------------------------------------------------------------------------------------------------------

int main(){
	initConsole();						// Ställer in konsollen för att hantera händelser.
	printMenu();						// Kolla om vi ska köra mot människa eller dator.
	printBoard();						// Ritar ut spelplanen.
	bool done = false;					// Variabel som avgör om programmet ska avslutas.
	while (!done) {						// Själva programloopen körs tills done är sant.
		eventHandler();					// Hanterar händelser som uppstår från användaren.
		gameRound(&done);				// Kör En runda på spelet.
	}
	printVictory();						// Skriv ut vem som vann.
	system("pause");					// Pausa så att inte konsollen försvinner direkt.
	return 0;
}

//  ------------------------------------------------------------------------------------------------------
//  ---------------------- HÄNDELSE-KOD ------------------------------------------------------------------
//  ------------------------------------------------------------------------------------------------------

// Läser in händelser som uppstår och vidarebefodrar dem till korrekt händelsehanterare.
void eventHandler() {
	ReadConsoleInput(consoleInputHandle, eventInputBuffer, EVENT_BUFFER_SIZE, &nrOfEvents); // Hämtar händelser till bufferten: eventInputBuffer, och räknar antalet händelser till: nrOfEvents.
	for (int i = 0; i < nrOfEvents; i++) {										// För varje händelse.
		switch (eventInputBuffer[i].EventType) {								// Kolla vilken typ av händelse.
		case KEY_EVENT:															// Om det är tangentbordstrckningar.
			keyboardEventHandler(eventInputBuffer[i].Event.KeyEvent);			// Låt tangentbordshanteraren hantera händelsen.
			break;
		case MOUSE_EVENT:														// Om det är tangentbordstrckningar.
			mouseEventHandler(eventInputBuffer[i].Event.MouseEvent);			// Låt mushanteraren hantera händelsen.
			break;
		}
	}
}

// Tangentbordshändelsehanteraren hanterar knapptrckningar på tangentbordet.
void keyboardEventHandler(KEY_EVENT_RECORD keyEvent) {
	if (!keyEvent.bKeyDown) {	// Om vi släpper en tangent på skrivbordet.
		// Nu har vi inget som händer här, men här kan man lägga till flera händelser för att bygga vidare om man vill använda tangentbordet.
	}
}

// Mushändelsehanteraren hanterar knapptrckningar på musen.
void mouseEventHandler(MOUSE_EVENT_RECORD mouseEvent) {
	if (mouseEvent.dwEventFlags == MOUSE_PRESSED_OR_RELEASED) {			// Om musknappen trcks eller släpps.
		if (mouseEvent.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED) {	// Om det är vänstra musknappen.
			const int mousePosX = mouseEvent.dwMousePosition.X;			// Hämta muspekarens X position i konsollen.
			const int mousePosY = mouseEvent.dwMousePosition.Y;			// Hämta muspekarens Y position i konsollen.
			int col, row;
			switch (currentGameState) {				// Kolla spelläge.
				case GAME_STATE_HUMAN:				// Om det är spelarens tur.
					col = mousePosX / 2;			// Vi måste räkna med att vi ritar ut spelplanen med mellanrum.
					row = mousePosY;				// Inget mellanrum mellan rader.
					humanPlay(row, col);			// Spela pjäsen på den tryckta positionen.
					break;
				case GAME_STATE_START_MENU:			// Om vi är i startmenyn.
					startMenu(mousePosY);			// Testa startmenyn.
					break;
			}
		}
	}
}

// Initiera konsollen genom att tillåta händelser och ta bort markören.
void initConsole() {
	SetConsoleMode(consoleInputHandle, ENABLE_WINDOW_INPUT | ENABLE_MOUSE_INPUT);	// Vi aktiverar händelser till konsol-fönstret.
	CONSOLE_CURSOR_INFO cursor; cursor.bVisible = false; cursor.dwSize = 1,			// Skapa en ny onsynlig markör.
		SetConsoleCursorInfo(consoleOutputHandle, &cursor);							// Aktivera den onsynliga markören till konsolen, så vi inte ser en blinkande markör.
}

//  ------------------------------------------------------------------------------------------------------
//  ---------------------- GRAFIK-KOD --------------------------------------------------------------------
//  ------------------------------------------------------------------------------------------------------

// Skriva ut spelplanen.
void printBoard() {
	for (int i = 0; i < BOARD_SIZE; i++) {		// Gå igenom alla rader.
		for (int j = 0; j < BOARD_SIZE; j++)	// Gå igenom alla kolumner.
			printf("%c ", board[i][j]);			// Skriv ut spelmarkörerna på spelplannen.
		printf("\n");							// Byt rad.
	}
}

// Kolla om användaren vill spela mot en annan spelare, eller mot datorn.
void printMenu() {
	printf("Select gamemode with left mouse button.\n");// Skriv ut val av spelläge.
	printf("Human vs human.\n");			// Skriv ut Alternativ 1, två spelare mot varandra.
	printf("Human vs computer.\n");			// Skriv ut Alternativ 2, spelare mot dator.
}

// Skriv ut vem som vann.
void printVictory() {
	printf("Congratualtions Player %c, you won!\n", board[lastMarkerX][lastMarkerY]);	
}

// Rensar skärmen
void clearScreen() {
	system("cls");	// Rensar skärmen.
	initConsole();	// Konsollen måste tillåta händelser.
}

//  ------------------------------------------------------------------------------------------------------
//  ---------------------- SPEL-KOD ----------------------------------------------------------------------
//  ------------------------------------------------------------------------------------------------------

// En runda av spelet.
void gameRound(bool *done) {
	switch (currentGameState) {		// Kolla vilket spelläge spelet är i.
		case GAME_STATE_HUMAN:		// Människans spel hanteras separat av händelser.
			break;
		case GAME_STATE_COMPUTER:	// Om det är datorns tur att spela.
			while (!computerPlay(currentPlayer));													// Låt datorn göra sitt drag.
			clearScreen();																			// Rensa skärmen.
			printBoard();																			// Rita ut spelplanen.
			currentPlayer = currentPlayer == PLAYER_1_MARKER ? PLAYER_2_MARKER : PLAYER_1_MARKER;	// Här byter vi till nästa spelare.
			currentGameState = GAME_STATE_HUMAN;													// låt människan spela.
			if (checkWin()) currentGameState = GAME_STATE_END;										// Kolla om vinst.
			break;
		case GAME_STATE_END:		// Om spelet är slut.
			*done = true;			// Avsluta spelet.
			break;
	}
}

// Om människa försöker spela.
void humanPlay(int x, int y) {
	if (currentGameState == GAME_STATE_HUMAN) {
		if (x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE) {										// Försök endast placera om vi är innanför banan.
			if (placeMarker(x, y, currentPlayer)) {														// Om placering lyckades.
				clearScreen();																			// Rensa skärmen.
				printBoard();																			// Rita ut spelplanen.
				currentPlayer = currentPlayer == PLAYER_1_MARKER ? PLAYER_2_MARKER : PLAYER_1_MARKER;	// Här byter vi till nästa spelare.
				if (!isMultiplayer) currentGameState = GAME_STATE_COMPUTER;								// Om det är singleplayer, låt datorn spela.
				if (checkWin()) currentGameState = GAME_STATE_END;										// Kolla om vinst.
			}
		}
	}
}

// En dators tur att spela. Här kan man vidareutveckla en strategi åt datorn, nu kör den slumpvis.
bool computerPlay(char marker) {
	int x, y;							// Variabler Rad och kolumn som datorn vill placera sin pjäs på.
	x = rand() % BOARD_SIZE;			// Datorn väljer en slupvis rad på spelplanen.
	y = rand() % BOARD_SIZE;			// Datorn väljer en slupvis kolumn på spelplanen.
	return placeMarker(x, y, marker);	// Placerar pjäsen på spelplanen.
}

// Placera spelpjäs.
bool placeMarker(int x, int y, char marker) {
	if (board[x][y] != EMPTY_MARKER) return false;		// Om det redan finns än pjäs på rutan, returnera falskt. (det gick ej att placera pjäsen).
	board[x][y] = marker;								// Placera spelpjäsen på brädet.
	lastMarkerX = x;									// Vi lägger undan raden för pjäsen i den globala variabeln för senast placerade pjäs rad position.
	lastMarkerY = y;									// Vi lägger undan kolumnen för pjäsen i den globala variabeln för senast placerade pjäs kolumn position.
	return true;
}

// Nollställa spelplanen.
void initBoard() {
	for (int i = 0; i < BOARD_SIZE; i++)				// Gå igenom alla rader.
		for (int j = 0; j < BOARD_SIZE; j++)			// Gå igenom alla kolumner.
			board[i][j] = EMPTY_MARKER;					// Placera en tom markör på spelplanen.
}

// Testa att klicka på en rad i startmenyn.
void startMenu(int y) {
	switch (y) {								// Kolla rad som klickades på.
	case START_MENU_OPTION_MULTIPLAYER:		// Om multiplayer är valt.
		currentGameState = GAME_STATE_HUMAN;// Gå över till spelläget.
		isMultiplayer = true;				// Välj multiplayer.
		initBoard();						// Nollställa spelplanen.
		clearScreen();						// Rensa skärmen
		printBoard();						// Rita ut spelplanen.
		break;
	case START_MENU_OPTION_SINGLEPLAYER:	// Om singleplayer är valt.
		currentGameState = GAME_STATE_HUMAN;// Gå över till spelläget
		isMultiplayer = false;				// Välj singleplayer.
		initBoard();						// Nollställa spelplanen.
		clearScreen();						// Rensa skärmen
		printBoard();						// Rita ut spelplanen.
		break;
	}
}

// Kollar om den senaste placerade pjäsen gjorde att spelaren vann.
bool checkWin() {
	char marker = board[lastMarkerX][lastMarkerY];		// Senaste spelarens spelpjäs.
	int left = 0, right = 0, up = 0, down = 0;			// Antal likadana pjäser längs olika riktningar.
	int leftUp = 0, leftDown = 0, rightUp = 0, rightDown = 0;

	// Undersök vinst: vertikalt.
	for (int x = lastMarkerX; x >= 0; x--) {			// Kolla alla pjäser upp.
		if (board[x][lastMarkerY] == marker) up++;		// Om samma pjäs: öka antal pjäser i rad upp med ett.
		else break;										// Om inte samma pjäs: sluta kolla åt upp.
	}
	for (int x = lastMarkerX; x < BOARD_SIZE; x++) {	// Kolla alla pjäser ned.
		if (board[x][lastMarkerY] == marker) down++;	// Om samma pjäs: öka antal pjäser i rad ned med ett.
		else break;										// Om inte samma pjäs: sluta kolla åt ned.
	}
	if (up + down > MARKERS_TO_WIN) return true;		// Om antal pjäser till upp och ned är störe än kravet för vinst (större eftersom mitten pjäsen räknas två gånger), då är det vinst och vi returnerar sant. 

														// Undersök vinst: horisontellt.
	for (int y = lastMarkerY; y >= 0; y--) {			// Kolla alla pjäser vänster.
		if (board[lastMarkerX][y] == marker) left++;	// Om samma pjäs: öka antal pjäser i rad vänster med ett.
		else break;										// Om inte samma pjäs: sluta kolla åt vänster.
	}
	for (int y = lastMarkerY; y < BOARD_SIZE; y++) {	// Kolla alla pjäser höger.
		if (board[lastMarkerX][y] == marker) right++;	// Om samma pjäs: öka antal pjäser i rad höger med ett.
		else break;										// Om inte samma pjäs: sluta kolla åt höger.
	}
	if (left + right > MARKERS_TO_WIN) return true;		// Om antal pjäser till höger och vänster är störe än kravet för vinst (större eftersom mitten pjäsen räknas två gånger), då är det vinst och vi returnerar sant. 

														// Undersök vinst: diagonalt vänster-upp till höger-ned.
	for (int x = lastMarkerX, y = lastMarkerY; x >= 0 && y >= 0; x--, y--) {	// Kolla alla pjäser vänster-upp.
		if (board[x][y] == marker) leftUp++;									// Om samma pjäs: öka antal pjäser i diagonalen vänster-upp med ett.
		else break;																// Om inte samma pjäs: sluta kolla åt diagonalen vänster-upp.
	}
	for (int x = lastMarkerX, y = lastMarkerY; x < BOARD_SIZE && y < BOARD_SIZE; x++, y++) {	// Kolla alla pjäser höger-ned.
		if (board[x][y] == marker) rightDown++;													// Om samma pjäs: öka antal pjäser i diagonalen höger-ned med ett.
		else break;																				// Om inte samma pjäs: sluta kolla åt diagonalen höger-ned.
	}
	if (leftUp + rightDown > MARKERS_TO_WIN) return true; // Om antal pjäser diagonalt vänster-upp till höger-ned är störe än kravet för vinst (större eftersom mitten pjäsen räknas två gånger), då är det vinst och vi returnerar sant. 

														  // Undersök vinst: diagonalt höger-upp till vänster-ned.
	for (int x = lastMarkerX, y = lastMarkerY; x >= 0 && y < BOARD_SIZE; x--, y++) {	// Kolla alla pjäser höger-upp.
		if (board[x][y] == marker) rightUp++;											// Om samma pjäs: öka antal pjäser i diagonalen höger-upp med ett.
		else break;																		// Om inte samma pjäs: sluta kolla åt diagonalen höger-upp.
	}
	for (int x = lastMarkerX, y = lastMarkerY; x < BOARD_SIZE && y >= 0; x++, y--) {	// Kolla alla pjäser vänster-ned.
		if (board[x][y] == marker) leftDown++;											// Om samma pjäs: öka antal pjäser i diagonalen vänster-ned med ett.
		else break;																		// Om inte samma pjäs: sluta kolla åt diagonalen vänster-ned.
	}
	if (rightUp + leftDown > MARKERS_TO_WIN) return true; // Om antal pjäser diagonalt höger-upp till vänster-ned är störe än kravet för vinst (större eftersom mitten pjäsen räknas två gånger), då är det vinst och vi returnerar sant. 

	return false;	// Ingen vinst har hittats, alltså returnerar vi falskt.
}