Inlägg

// ----------------------------
// | 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.
}

// ------------------
// | 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.
}

T1	FCB		$10, %10, 10		//skapar en sträng som tar 3platser  $hex, %bin, dec
E1	10		//10hex är 10hex
E2	02		//02hex är 10binärt
E3	0A 		//0Ahex är 10decimalt

EQU tar inte upp plats i programminnet, den ger bara en "ettikett/namn" till ett tal.

STA			,-X
E4	E8		//instruktionen har OP : E8  (kollade i databladet)

    private static double genomsnitt(double[] tal){
        return (tal[0] + tal[1] + tal[2]) / tal.length;
    }

    public static void main(String[] args) {
        double[] tal = new double[3];
        tal[0] = 4.3;
        tal[1] = 2.2;
        tal[2] = 8.6;
        double genomsnittet = genomsnitt(tal);
        System.out.print(genomsnittet);
    }

public class Medlem {
    private String namn;
    private String id;
    public Medlem(String namn, String id) {
        this.namn = namn;
        this.id = id;
    }
    public void setNamn(String namn) {
        this.namn = namn;
    }
    public String getNamn() {
        return namn;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getId() {
        return id;
    }
}

int ladder(int* dieValues){
    for (int i=1;i<6;i++)if(dieValues[i]!=1)return 0;
    return 1;
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void rollDice(int* dieValues, int rolls);
int ladder(int* dieValues);
void setZero(int* dieValues);
int main(){
    srand(time(NULL));
    int dieValues[7]={0};
    int num =0;
    while (ladder(dieValues) == 0){
            setZero(dieValues);
            rollDice(dieValues, 5);
            num++;
    }
    printf("You took %d rolls to get the correct ladder.\n", num);
    return 0;
}
void rollDice(int* dieValues, int rolls){
    for (int i=0;i<rolls;i++)dieValues[rand()%6+1]++;
    printf("Dice roll with %d die:\nOne\tTwo\tThree\tFour\tFive\tSix\n%d\t%d\t%d\t%d\t%d\t%d\t\n",rolls, dieValues[1], dieValues[2], dieValues[3], dieValues[4], dieValues[5], dieValues[6]);
}
int ladder(int* dieValues){
    for (int i=1;i<6;i++)if(dieValues[i]!=1)return 0;
    return 1;
}
void setZero(int* dieValues){
    for (int i=1;i<7;i++)dieValues[i]=0;
}

// Beskrivning: (Innehåller en lista med alla inlagda kunder. Klassen ska innehålla ett 
//antal publika metoder som hanterar kunder och dess konton.) 
// Version: (1) 
//****************************************************************** 
import java.util.ArrayList;


//public class BankLogic extends SavingsAccount{
public class BankLogic{

//Deklarerar arraylistan som ska innehålla kunder
public ArrayList<Customer>customers;

//konstruktor som instansierar arraylistan
public BankLogic(){
	super();
	customers=new ArrayList<>();	
}
	
//------------------------------------------------------
//Beskrivning: (Returnerar en sträng med alla bankens kunder) 
//Inparametrar: (pNr och namn) 
//Returvärde: (Returnerar en sträng med alla bankens kunder) 
//------------------------------------------------------  
public String infoBank(){
	String info ="";
	for(Customer customer:customers)info += customer.getCustomer()+"\n";
	return info;
}

 //------------------------------------------------------
 // Beskrivning: (Skapar ny kund med pNr och name) 
 // Inparametrar: (Kund ska endast skapas om inte pNr finns.) 
 // Returvärde: (True om det lyckats annars false) 
 //-------------------------------------------------	
	public boolean addCustomer(String name,long pNr){
            for(Customer customer:customers){
		if (pNr==customer.pNr) return false;
            }
            customers.add(new Customer(name, pNr));
            return true;
        }
	
	//------------------------------------------------------
	// Beskrivning: (Returnerar sträng med presentation av vald kund(pNr+namn och eventuella konton)) 
	// Inparametrar: (pNr) 
	// Returvärde: (pNr+namn och eventuella konton) 
	//------------------------------------------------------	
	//
	public String infoCustomer(long pNr){
            for(Customer customer:customers){
            if (customer.getpNr()==pNr){
                String info = customer.getCustomer();
                for(SavingsAccount account:customer.accounts){
                    info += account.getAccount()+"\n";
                }
                return info;
                }
            }
            return "Ingen kund med det personnummret.";		
	}
	//------------------------------------------------------
	// Beskrivning: (Tar bort kund med personnummer pNr ur banken, alla kundens eventuella konton tas 
	//också bort och resultatet returneras. Strängen som returneras ska ha innehålla 
	//information om vilka konton som togs bort, saldot som kunden får tillbaka samt vad 
	//räntan blev) 
	// Inparametrar: (pNr) 
	// Returvärde: (info om borttagen kunds konto) 
	//------------------------------------------------------
	public String removeCustomer(long pNr){
		for(Customer customer:customers){
			if(customer.getpNr()==pNr){
                            String info = customer.getCustomer();
                            customers.remove(customer);
                            int total = 0;
                            for(SavingsAccount account:customer.accounts){
                                info += account.getAccount()+"\n";
                                total += account.balance;
                            }
                            return "Kund borttagen: "+info+"\n Saldo total: "+total;
			}
		}return  null;
	}
	//------------------------------------------------------
	// Beskrivning: (Skapar ett konto till kund med personnummer pNr)
	// Inparametrar: (pNr) 
	// Returvärde: (returnerar kontonumret som det 
	//skapade kontot fick alternativt returneras –1 om inget konto skapades) 
	//------------------------------------------------------
	public int addSavingsAccount(long pNr){
		for(Customer customer : customers){
                    if (customer.getpNr()==pNr){
                        SavingsAccount newaccount = new SavingsAccount();
                        customer.accounts.add(newaccount);
                        return newaccount.accountid;
                    }
                }
                return -1;
	}
	//------------------------------------------------------
	// Beskrivning: (Byter namn på kund med rätt personnummer pNr till nytt name) 
	// Inparametrar: (pNr) 
	// Returvärde: (returnerar true om namnet ändrades annars returnerar false) 
	//------------------------------------------------------
	  
public boolean changeCustomerName(String name,long pNr){
	for(Customer customer:customers)
         //ifsats för att kolla om customers pnr är lika som det sökta
         if (customer.getpNr()==pNr){
        	customer.setName(name);
        	return true;
         }
	return false;
     }

//------------------------------------------------------
//Beskrivning: (Gör en insättning på konto med kontonnummer accountId som tillhör kunden pNr) 
//Inparametrar: (long pNr,int accountid,double amount) 
//Returvärde: (returnerar true om det gick bra annars false) 
//------------------------------------------------------
public boolean deposit(long pNr,int accountId,double amount){
	for(Customer customer : customers){
        if (customer.pNr==pNr){
            for (SavingsAccount account:customer.accounts){
                if(account.accountid == accountId){
                    account.balance+=amount;
                    return true;
                }
            }
        }     
    }
    return false;
}
//------------------------------------------------------
//Beskrivning: (Gör ett uttag på konto med kontonnummer accountId som tillhör kunden pNr) 
//Inparametrar: (long pNr,int accountId,int amount) 
//Returvärde: (returnerar true om det gick bra annars false) 
//------------------------------------------------------
public boolean withdraw(long pNr,int accountId,int amount){
    for(Customer customer : customers){
        if (customer.pNr==pNr){
            for (SavingsAccount account:customer.accounts){
                if(account.accountid == accountId){
                    if (account.balance>=amount){
                        account.balance-=amount;
                        return true;
                    }
                    else return false;
                }
            }
        }
    }
    return false;
}
//------------------------------------------------------
//Beskrivning: (Returnerar en String som innehåller presentation av kontot med kontonnummer 
//accountId som tillhör kunden pNr (kontonummer, saldo, kontotyp, räntesats)
//Inparametrar: (long pNr,int accountId) 
//Returvärde: (Returnerar en String som innehåller presentation av kontot med kontonnummer 
//accountId som tillhör kunden pNr (kontonummer, saldo, kontotyp, räntesats) 
//------------------------------------------------------

//------------------------------------------------------
// Beskrivning: (Stänger ett konto med kontonnummer accountId som tillhör kunden pNr, 
// Inparametrar: (long pNr ,int accountId) 
// Returvärde: (presentation av kontots saldo samt ränta på pengarna ska genereras.) 
//------------------------------------------------------
public String closeAccount(long pNr ,int accountId){
    for(Customer customer:customers){
        if (customer.pNr == pNr) {
            for (SavingsAccount account:customer.accounts){
                if (account.accountid == accountId){
                    String info = account.getAccount();
                    customer.accounts.remove(account);   
                    return "Kontot avslutat."+info;
                }
            }
        }
    }
    return "Kontot existerar inte.";
}

// Beskrivning: (hanterar följande information: saldo, räntesats, kontotyp (Sparkonto) och kontonummer 
//Man kan utföra transaktioner (insättning/uttag), hämta kontonummer, 
//beräkna ränta (saldo * räntesats/100) samt presentera kontot (kontonummer, saldo, kontotyp, 
//räntesats).
// Version: (1) 
//****************************************************************** 
public class SavingsAccount{

	double balance;
	double rate=2;
	String accounttype="Sparkonto";
	int accountid;
	static int accountcounter=1001;
	double amount;
	
	//konstruktor 	
    public SavingsAccount(){
	this.accountid=getAccountId();
        this.balance= 0;
        this.rate= rate;
        this.accounttype = accounttype;
    }

	public double getBalance(){
		return balance;
	}

   public String getAccounttype(){
	return accounttype;	
   }
	
  public int getAccountId(){
  accountid=accountcounter;
    accountcounter++;
	return accountid;
}

public double getRate(){
	return rate;
}


public String getAccount(){
	return accounttype+" Kontoid: "+accountid+" Saldo: "+balance+" Ränta: "+rate;
	
}

@Override
public String toString(){
	return "Kontotyp:"+getAccount()+"";
}

public  double rateInAccount(){
	return balance+=(balance*rate)/100;	
}

public double withdraw(double balance){
    if(balance>0){
       return balance-=amount; 
    }
    return 0;

}

public double deposit(double balance){
    if(balance>0){
        return balance+=amount;
    }
    return 0;	
}
}

import java.util.ArrayList;

// Beskrivning: (Hanterar följande information: kundens namn, personnummer.
//Man kan till exempel kunna ändra kundens namn samt presentera kunden (personnummer, 
//för- och efternamn samt kundens konton). Dessutom kan man kunna hantera konton) 
// Version: (1) 
//****************************************************************** 
//Klassen Customer
//public class Customer extends SavingsAccount{
public class Customer{
public ArrayList<SavingsAccount>accounts;
//variabler för att hålla namn och persnr
String name;
long pNr;

//konstruktor som ska hämta upp namn och personnr
public Customer(String name,long pNr){
this.name=name;
this.pNr=pNr;
this.accounts=new ArrayList<>();
}

//konstruktor 
public Customer() {
	super();
        accounts=new ArrayList<>();
}
//------------------------------------------------------
//Beskrivning: (getmetod för att hämta namn på kund) 
//Inparametrar: (name) 
//Returvärde: (name) 
//------------------------------------------------------
public String getName(){
	return name;
}
//------------------------------------------------------
//Beskrivning: (getmetod för att hämta personnr=pNr på kund) 
//Inparametrar: (pNr) 
//Returvärde: (pNr) 
//------------------------------------------------------
public long getpNr(){
	return pNr;
}
//Beskrivning: (Setmetod för namn) 
//Inparametrar: (name) 
//Returvärde: (name) 
//------------------------------------------------------
public void setName(String Name){
	name=Name;	
}
//Beskrivning: (Getmetod för namn och personnr) 
//Inparametrar: (name pnr) 
//Returvärde: (name pnr) 
//------------------------------------------------------
public String getCustomer(){
	return "Name:"+getName()+"Personalnumber:"+getpNr();
	
}
//Beskrivning: (Metod för att göra om objektet till en sträng) 
//Inparametrar: (namn och pnr) 
//Returvärde: (kundinformationen omgjort till sträng) 
//Här fick jag hjälp av ett foruminlägg som jag fick fram genom att googlade varför jag bara fick fram 
//konstiga tecken  när jag skulle skriva ut konton.
//http://stackoverflow.com/questions/3615721/how-to-use-the-tostring-method-in-java.
//------------------------------------------------------
@Override
public String toString(){
	return ""+getCustomer()+"";
	
}
}

import java.util.*; // bibliotek som innehåller date, scanner m.m.
public class Datum{
     public static void main(String []args)
     {
        // 1.) Hämta dagens datum och tilldela månad och dag till varsin int med hjälp av date och kalender
        Date date = new Date();
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int month = cal.get(Calendar.MONTH)+1;
        int day = cal.get(Calendar.DAY_OF_MONTH);
        
        // 2.) Läsa in månadsnummer och dagnummer från användaren med scanner
        Scanner scan = new Scanner(System.in); 
        System.out.println("Skriv in ett månadsnummer: ");
        int month_in = scan.nextInt();
        System.out.println("Skriv in ett dagnummer inom månaden: ");
        int day_in = scan.nextInt();
        scan.close();
        
        // 3.) Testa om de är lika med en if sats
        if (month == month_in && day == day_in)
        {
            System.out.println("Datumet är korrekt");
        }
        else
        {
            System.out.println("Datumet är inkorrekt");
        }
     }
}

private void b1_Click_1(object sender, EventArgs e)
        {
            int x = Convert.ToInt32(inbox.Text);
            double y = x * 6.6;
            utbox.Text = y.ToString();
        }