find vertical and horizontal moves, forwards and backwards

players/playerlib.cc

@@ -3,6 +3,9 @@
 
 #include "playerlib.h"
 
+//determines whether move or not and adds them to a movesList
+int fillMovesList(cell (*)[fieldWidth], movesList *, size_t, size_t, unsigned int *, unsigned int *);
+
 char enemyc = 0, ownc = 0;
 
 char
@@ -31,3 +34,89 @@ readStateBuffer(char *stateBuffer, struct cell (*gameField)[fieldWidth]) {
 	}
 	return 0;
 }
+
+int
+fillMovesList(cell (*field)[fieldWidth], movesList *moves, size_t row, size_t col, unsigned int *ownCount, unsigned int *enemyCount) {
+	++(field[row][col].timesVisited);
+	if (field[row][col].content == ownc)
+	{
+		++(*ownCount);
+		*enemyCount = 0;
+		printf("%d,%d: ownCount: %d, enemyCount: %d\n", row, col, *ownCount, *enemyCount);
+	}
+	if(field[row][col].content == enemyc && ownCount)
+	{
+		++(*enemyCount);
+		printf("%d,%d: ownCount: %d, enemyCount: %d\n", row, col, *ownCount, *enemyCount);
+	}
+	if(field[row][col].content == '.')
+	{
+		if (*ownCount && *enemyCount > 0)
+		{
+			printf("BAM!\n");
+			moves->list[moves->movesNumber].turnRow = row+1;
+			moves->list[moves->movesNumber].turnCol = col+1;
+			++(moves->movesNumber);
+		}
+		*ownCount = 0;
+		*enemyCount = 0;
+		printf("%d,%d: ownCount: %d, enemyCount: %d\n", row, col, *ownCount, *enemyCount);
+	}
+	return 0;
+}
+
+int
+findHorizontalForwardMoves(cell (*field)[fieldWidth], movesList *moves) {
+	//Anzahl eigener/gegnerischer Steine
+	unsigned int ownCount = 0, enemyCount = 0;
+	for (size_t row = 0;row < fieldHeight; ++row)
+	{
+		for (size_t col = 0;col < fieldWidth; ++col)
+		{
+			fillMovesList(field, moves, row, col, &ownCount, &enemyCount);
+		}
+	}
+	return 0;
+}
+
+int
+findHorizontalBackwardMoves(cell (*field)[fieldWidth], movesList *moves) {
+	//Anzahl eigener/gegnerischer Steine
+	unsigned int ownCount = 0, enemyCount = 0;
+	for (int row = 7; row >= 0; --row)
+	{
+		for (int col = 7; col >= 0; --col)
+		{
+			fillMovesList(field, moves, row, col, &ownCount, &enemyCount);
+		}
+	}
+	return 0;
+}
+
+int
+findVerticalForwardMoves(cell (*field)[fieldWidth], movesList *moves) {
+	//Anzahl eigener/gegnerischer Steine
+	unsigned int ownCount = 0, enemyCount = 0;
+	for (size_t col = 0;col < fieldHeight; ++col)
+	{
+		for (size_t row = 0;row < fieldWidth; ++row)
+		{
+			fillMovesList(field, moves, row, col, &ownCount, &enemyCount);
+		}
+	}
+	return 0;
+}
+
+int
+findVerticalBackwardMoves(cell (*field)[fieldWidth], movesList *moves) {
+	//Anzahl eigener/gegnerischer Steine
+	unsigned int ownCount = 0, enemyCount = 0;
+	for (int col = 7; col >= 0; --col)
+	{
+		for (int row = 7; row >= 0; --row)
+		{
+			fillMovesList(field, moves, row, col, &ownCount, &enemyCount);
+		}
+	}
+	return 0;
+}

players/playerlib.h

@@ -18,15 +18,15 @@ struct movesList {
 	move *list = new move[fieldWidth*fieldHeight-4]();
 };
 
-enum iterDirection
-{
-	forwards, backwards
-};
-
-
 //returns the character used for the enemy's stones
 extern char getEnemyChar(char);
 //reads the stateBuffer string into a 2d matrix
 extern int readStateBuffer(char*, cell (*)[fieldWidth]);
 
+//adds all hotizontally-forward found moves to movesList
+int findHorizontalForwardMoves(cell (*)[fieldWidth], movesList *);
+int findHorizontalBackwardMoves(cell (*)[fieldWidth], movesList *);
+int findVerticalForwardMoves(cell (*)[fieldWidth], movesList *);
+int findVerticalBackwardMoves(cell (*)[fieldWidth], movesList *);
+
 #endif

players/random-player.cc

@@ -19,100 +19,70 @@ send_move(int row, int col)
 	return 0;
 }
 
-int
-findVerticalMoves(cell (*field)[fieldWidth], movesList *moves, iterDirection direction) {
-	//Anzahl eigener/gegnerischer Steine
-	unsigned int ownCount = 0, enemyCount = 0;
-	if (direction == forwards)
-	{
-		for (size_t row = 0;row < fieldHeight; ++row)
-		{
-			for (size_t col = 0;col < fieldWidth; ++col)
-			{
-				//TODO: diesen Teil auslagern
-				++(field[row][col].timesVisited);
-				if (field[row][col].content == ownc)
-					++ownCount;
-				if(field[row][col].content == enemyc && ownCount)
-					++enemyCount;
-				if(field[row][col].content == '.')
-				{
-					if (ownCount && enemyCount > 0)
-					{
-						moves->list[moves->movesNumber].turnRow = row+1;
-						moves->list[moves->movesNumber].turnCol = col+1;
-						++(moves->movesNumber);
-					}
-					ownCount = 0;
-					enemyCount = 0;
-				}
-			}
-		}
-	}
-	return 0;
-}
 
 
 int main(void)
 {
-  int done = 0;
+	int done = 0;
 
-  while (!done) {
+	while (!done) {
-	int turn_row = 0;
+		int turn_row = 0;
-	int turn_col = 0;
+		int turn_col = 0;
-    /* BEGIN PLAYER-SPECIFIC CODE */
+		/* BEGIN PLAYER-SPECIFIC CODE */
 
-    // 1. Read state
+		// 1. Read state
-    char state_buffer[128];
+		char state_buffer[128];
-    ssize_t bytes = read(CHILD_IN_FD, state_buffer, sizeof(state_buffer));
+		ssize_t bytes = read(CHILD_IN_FD, state_buffer, sizeof(state_buffer));
-    if (bytes != 65) // invalid number of chars
+		if (bytes != 65) // invalid number of chars
-      abort();
+			abort();
 
-    // state_buffer enthält jetzt 65 Zeichen ('.' oder 'X' oder 'O'):
+		// state_buffer enthält jetzt 65 Zeichen ('.' oder 'X' oder 'O'):
-    //  * Das ERSTE Zeichen gibt an, welcher Spieler an der Reihe ist.
+		//  * Das ERSTE Zeichen gibt an, welcher Spieler an der Reihe ist.
-    //  * Die weiteren 64 Zeichen definieren die Belegung des Feldes.
+		//  * Die weiteren 64 Zeichen definieren die Belegung des Feldes.
-    //  * Die Belegung wird reihenweise gegeben, d.h. die Zeichen
+		//  * Die Belegung wird reihenweise gegeben, d.h. die Zeichen
-    //    1 bis 8 definieren die erste Zeile des Feldes, Zeichen 9 bis 17
+		//    1 bis 8 definieren die erste Zeile des Feldes, Zeichen 9 bis 17
-    //    geben die zweite Zeile usw.
+		//    geben die zweite Zeile usw.
-    //  * X und O stehen hierbei für die jeweiligen Spieler. Leere Felder
+		//  * X und O stehen hierbei für die jeweiligen Spieler. Leere Felder
-    //    sind durch einen Punkt (.) gekennzeichnet. 
+		//    sind durch einen Punkt (.) gekennzeichnet. 
-    
+
-    // 2. TODO: Strategie hier einfügen. Resultat in turn_row und turn_col speichern.
+		// 2. TODO: Strategie hier einfügen. Resultat in turn_row und turn_col speichern.
+
+		if(!enemyc)
+		{
+			ownc = state_buffer[0];
+			enemyc = getEnemyChar(ownc);
+		}
+
+		//pure C:
+		//struct cell (*field)[fieldWidth] = malloc(fieldHeight*fieldWidth*sizeof(struct cell));
+
+		//C++ version:
+		auto field = new cell[fieldHeight][fieldWidth]();
+
+		readStateBuffer(state_buffer, field);	//stateBuffer ist Pointer auf char, field ist Pointer auf struct cell[]
+		movesList *moves = new movesList();
+		findHorizontalForwardMoves(field, moves);
+		findHorizontalBackwardMoves(field, moves);
+		findVerticalForwardMoves(field, moves);
+		findVerticalBackwardMoves(field, moves);
+
+		for (unsigned int i=0; i<moves->movesNumber; ++i)
+		{
+			printf("%d,%d\n",moves->list[i].turnRow,moves->list[i].turnCol);
+		}
+
+		// 3. Return result
+		//send_move(turn_row, turn_col);
+		//for(int i=0; i<fieldHeight; ++i)
+		//	delete [] field[i];
+		delete [] field;
+		delete [] moves;
+
+		/* END PLAYER-SPECIFIC CODE */
 
-    if(!enemyc)
-	{
-		ownc = state_buffer[0];
-        enemyc = getEnemyChar(ownc);
-	}
-    
-	//pure C:
-	//struct cell (*field)[fieldWidth] = malloc(fieldHeight*fieldWidth*sizeof(struct cell));
-	
-	//C++ version:
-	auto field = new cell[fieldHeight][fieldWidth]();
-	
-	readStateBuffer(state_buffer, field);	//stateBuffer ist Pointer auf char, field ist Pointer auf struct cell[]
-	movesList *moves = new movesList();
-	iterDirection direct = forwards;
-	findVerticalMoves(field, moves, direct);
-	
-	for (unsigned int i=0; i<moves->movesNumber; ++i)
-	{
-		printf("%d,%d\n",moves->list[i].turnRow,moves->list[i].turnCol);
 	}
 
-    // 3. Return result
+	return 0;
-    //send_move(turn_row, turn_col);
-	//for(int i=0; i<fieldHeight; ++i)
-	//	delete [] field[i];
-	delete [] field;
-	delete [] moves;
-
-    /* END PLAYER-SPECIFIC CODE */
-
-  }
-
-  return 0;
 }
 
 /* EOF */