---

battle_core.h File Reference

Declaration of functions referenced during the battle stage of the game and accessing the battlefield array. More...

Go to the source code of this file.

Defines
#define	BATTLEFIELD_DIMENSIONS   10
Functions
void	initialise_battlefield ()
	Function used to initialise the elements of the battlefield array. More...
int	belong_to_player (int player, int x, int y)
	Detect if piece on battlefield belongs to a specific player. More...
int	attack_or_move (int z, int w)
	Detect if a player made an attack or a move. More...
int	check_piece_clicked (int player, int x, int y, int z, int w)
	Check if piece clicked is moveable. More...
int	legal_move (int x, int y, int z, int w)
	Check if we have a valid move. More...
int	check_scout_move (int x, int y, int z, int w, int difference)
	Check if a Scout's move is valid. More...
int	decide_winner (int x, int y, int z, int w)
	Decides who won a battle. More...
void	perform_move (int player, int x1, int y1, int x2, int y2, int reveal)
	Used to update data structures after a move. More...
int	get_bitmapno (char *name)
	Get the bitmap number of a piece. More...
Variables
piece	pieces_table [12]
	Statically defined array. More...
battlefield_piece	battlefield [BATTLEFIELD_DIMENSIONS][BATTLEFIELD_DIMENSIONS]
	Main array for a console. More...

---

Detailed Description

Declaration of functions referenced during the battle stage of the game and accessing the battlefield array.

---

Define Documentation

#define BATTLEFIELD_DIMENSIONS   10

This variable is used while defining the battlefield array. The battlefield array is 10x10 which is also the size of the board.

---

Function Documentation

int attack_or_move (  int    z, int    w )

Detect if a player made an attack or a move. Parameters: z  Integer x-coordinate of the second part of the move command w  Integer y-coordinate of the second part of the move command Returns: int returns TRUE (1) if we have an attack and FALSE (0) if we have a move This function helps us detect if a placement performed by a player is an attack or a move. This function is called after we have checked that the piece being moved belongs to the player and that the square that we are trying to place the piece on doesn't. Thus, to detect if we have a move, we check the z,w coordinates on the battlefield. If they refer to an empty slot then it is a move else an attack. For example, if we receive a move(1, 2 , 3 , 4 , 5) and the first tests are passed (checks on if 2,3 belongs to 1, and tests on whether 4,5 doesn't), then if battlefield[4][5] is empty then we move else we attack. { if (battlefield[z][w].player == -1) return FALSE; else return TRUE; }

int belong_to_player (  int    player, int    x, int    y )

Detect if piece on battlefield belongs to a specific player. Parameters: player  The integer id of the player that we want to check if it is his piece x  The integer x coordinate of the board that this piece is on y  The integer y coordinate of the board that this piece is on Returns: int returns TRUE (1) if the piece belongs to player, FALSE (0) otherwise This functions is used by other functions in battle_functions.c. Its functionality allows us to tidily detect, if a piece on the board that a player tries to move, belongs to him or not. If it does then he can make a move if the second part of the move (placement) is legal. If teh piece does not belong to him then we have an illegal reference, and thus an illegal move. { if (battlefield[x][y].player == player) return TRUE; else return FALSE; }

int check_piece_clicked (  int    player, int    x, int    y, int    z, int    w )

Check if piece clicked is moveable. Parameters: player  The integer id of the player that made the move x  The integer x coordinate of the board that this piece is on y  The integer y coordinate of the board that this piece is on z  The integer x coordinate of the board that the player wants to move this piece to w  The integer y coordinate of the board that the player wants to move this piece to Returns: int returns TRUE (1) if we have a valid move, FALSE (0) otherwise This function is the next stage after checking piece ownership by the belong_to_player function. Since when using it we know that the pieces that we are referencing are valid, we now need to check if the pieces we are trying to move are moveable and if the piece which we are trying to move the piece to does not belong to the same player. All pieces in Stratego2Go are moveable apart from a Bomb and a Flag. Should the move be illegal, we output the appropriate debug information. { if (belong_to_player(player , x , y) ){ if ( (strcmp(battlefield[x][y].occupied.name,"Bomb") != 0) && (strcmp(battlefield[x][y].occupied.name,"Flag") != 0) ){ if (!(belong_to_player(player , z , w)) )/* if second click does not belong to player */ return TRUE; else { /* second click belongs to same player */ vccPrintPdxDebugInfo("Piece [%d][%d] is yours so you can not attack it\n",z,w); return FALSE; } } else { vccPrintPdxDebugInfo("Piece [%d][%d] is a %s and can not be moved\n",x,y,battlefield[x][y].occupied.name); return FALSE; } } else { vccPrintPdxDebugInfo("Piece [%d][%d] (%s) does not belong to you\n",x,y,battlefield[x][y].occupied.name); return FALSE; } }

int check_scout_move (  int    x, int    y, int    z, int    w, int    difference )

Check if a Scout's move is valid. Parameters: x  The integer x coordinate of the board that this piece is on y  The integer y coordinate of the board that this piece is on z  The integer x coordinate of the board that the player wants to move this piece to w  The integer y coordinate of the board that the player wants to move this piece to difference  The integer calculated as described in the legal_move function Returns: int returns TRUE (1) if we have a valid move, FALSE (0) otherwise This function accomodates for the rules of moving a scout. For a Scout move to be legal, it must move in the correct direction and not jump over another piece. Furthermore, a scout can not move and attack at the same time. This function is called from, inside the legal_move function and its results are delegated and outputted as the results of this function. { int first_test = 0; /* first test represents the check of if the scout jumped over one piece or not */ /* if it didn't set to 1 and then test if he moved and attacked */ int i; if (z==x) { if (w > y){ for (i=y+1; i<w; i++){ if (battlefield[x][i].player != -1){ /* piece occupied */ vccPrintPdxDebugInfo("Scout can not jump over another piece"); return FALSE; }/* if */ }/* for */ } else if ( w < y){ for (i=w+1; i<y; i++){ if (battlefield[x][i].player != -1){ /* piece occupied */ vccPrintPdxDebugInfo("Scout can not jump over another piece"); return FALSE; }/* if */ }/* for */ }/* if */ first_test = 1; } else if (w == y){ if (z > x){ for (i=x+1; i<z; i++){ if (battlefield[i][y].player != -1){ /* piece occupied */ vccPrintPdxDebugInfo("Scout can not jump over another piece\n"); return FALSE; }/* if */ }/* for */ } else if ( z < x){ for (i=z+1; i<x; i++){ if (battlefield[i][y].player != -1){ /* piece occupied */ vccPrintPdxDebugInfo("Scout can not jump over another piece\n"); return FALSE; }/* if */ }/* for */ }/* if */ first_test = 1; } else { vccPrintPdxDebugInfo("The scout can not move diagonally\n"); return FALSE; }/* else */ /* if we reach this point then teh scout did not jump over another piece test that he can not move and attack. if difference > 1 and the piece that he moves to is not empty then illegal */ if ( (difference > 1) && (battlefield[z][w].player != -1) ){ vccPrintPdxDebugInfo("A scout can not move and attack at the same move\n"); return FALSE; } else return TRUE; }

int decide_winner (  int    x, int    y, int    z, int    w )

Decides who won a battle. Parameters: x  The integer x coordinate of the board that attacking piece is on y  The integer y coordinate of the board that attacking piece is on z  The integer x coordinate of the board that defending piece is on w  The integer y coordinate of the board that defending piece is on Returns: int returns an int representing result of attack. Five possibilities: Return 1: piece on battlefield[x][y] won Return 2: piece on battlefield[z][w] won Return 3: the result was a draw Return 4: piece on battlefield[z][w] was a flag Return 5: none of the above occurred Warning: This function should never return 5. This function is called whenever it is detected that an attack took place. Its result is used in the poin_Entry_Begin function in white.c to provide further information to the user and act appropriately on the outcome of the attack. Appart from checking ranks of pieces, it also takes into consideration the type of each piece and the rules of the game. Thus there is special consideration for a spy vs a Marshal attack, a bomb vs a miner etc... { if ( strcmp(battlefield[z][w].occupied.name , "Flag") == 0) return 4; if ( strcmp(battlefield[z][w].occupied.name , "Bomb") == 0){ if ( strcmp(battlefield[x][y].occupied.name , "Miner") == 0){ return 1; } else return 2; } if ( strcmp(battlefield[x][y].occupied.name , "Spy") == 0){ if ( strcmp(battlefield[z][w].occupied.name , "Marshal") == 0){ return 1; } else return 2; } vccPrintPdxDebugInfo("%d vs %d\n",battlefield[x][y].occupied.rank , battlefield[z][w].occupied.rank); if (battlefield[x][y].occupied.rank < battlefield[z][w].occupied.rank) return 1; if (battlefield[x][y].occupied.rank > battlefield[z][w].occupied.rank) return 2; if (battlefield[x][y].occupied.rank == battlefield[z][w].occupied.rank) return 3; return 5; }

int get_bitmapno (  char *    name )

Get the bitmap number of a piece. Parameters: name  The string representing the name of the piece Returns: int returns the integer identifier of the piece identified by name, -1 otherwise This function is used to find the integer identifier of a piece corresponding to name. The number returned is then passed on to the Graphics module through the first parameter of the DrawSprite command. The integer, is fetched from the pieces_table array defined in the battle_core.h header file. { int i; for ( i = 0; i < 12; i++){ if ( strcmp(name , pieces_table[i].name) == 0) return i; } return -1; }

void initialise_battlefield (    )

Function used to initialise the elements of the battlefield array. Returns: void Basic functionality is to assign to each element of the array to a "no" player (i.e. value -1) and rank and name to something that does not characterise a piece. This is because at the start of the game, no piece on the board is captured by a piece. These are getting occupied one by one as the players place their pieces on the board. This function is automatically called by the poin_entry_Init function in the white.c file, when the game is commenced. { int i , j; for (i=0; i<10; i++){ for (j=0; j<10; j++){ battlefield[i][j].occupied.name = "UNOCCUPIED"; battlefield[i][j].occupied.rank = -1; battlefield[i][j].occupied.revealed = -1; battlefield[i][j].player = -1; } } }

int legal_move (  int    x, int    y, int    z, int    w )

Check if we have a valid move. Parameters: x  The integer x coordinate of the board that this piece is on y  The integer y coordinate of the board that this piece is on z  The integer x coordinate of the board that the player wants to move this piece to w  The integer y coordinate of the board that the player wants to move this piece to Returns: int returns TRUE (1) if we have a valid move, FALSE (0) otherwise This function checks the movement of a piece in order to decide if we have a legal move or not. It focuses on the legality of coordinates moved. The rules state: One square at a time, forward, backward or sideways Can not jump over another piece even if it is a scout At first, we check if x,y and z,w are different. If they are not then we are trying to move to teh same piece which is illegal. Then we check the number of squares and direction. If the piece we are referencing is a scout then these rules are different (a Scout can move multiple squares) so we call the check_scout_move function. To check the direction and number of squares an easy to use method is devised: If the difference of x+y and z+w is 1 then it is legal else we are trying to move either diagonally or more than one square. { int first_sum; int second_sum; int difference; first_sum = x + y; second_sum = z + w; difference = abs(first_sum - second_sum); if ((x == z) && (y == w)){ vccPrintPdxDebugInfo("Moved to same square so that is no move\n"); return FALSE; } if (strcmp(battlefield[x][y].occupied.name,"Scout") == 0){ /* trying to move scout */ if (check_scout_move(x , y , z , w , difference)) return TRUE; } else {/* not a scout */ if (difference == 1){ /* trying to move to adjacent piece */ return TRUE; } else { vccPrintPdxDebugInfo("A %s can only move one square at a time and not diagonally\n",battlefield[x][y].occupied.name); return FALSE; }/* else */ }/* else */ return FALSE; }

void perform_move (  int    player, int    x1, int    y1, int    x2, int    y2, int    reveal )

Used to update data structures after a move. Parameters: player  The integer id of the player that made the move x1  The integer x coordinate of the board that this piece was on y1  The integer y coordinate of the board that this piece was on x2  The integer x coordinate of the board that this piece is on y2  The integer y coordinate of the board that this piece is on reveal  The integer representing if this piece is revealed or not Returns: void This function is used throughout the game by players, opponents and observers. It represents a move in the battlefield array. Whenever there is a move, the x1,y1 becomes empty and its data are moved onto x2,y2 which are the coordinates of the destination square. The reveal parameter is used to pass information from white.c and the game to the data structures operating on the background. The revealed field is set when a piece has to be revealed to the opponent. This occurs after an attack involving this piece has taken place. Immediately after the attack, the reveal param is set to propagate this information. { /* perform move in data structures */ battlefield[x2][y2].occupied = battlefield[x1][y1].occupied; battlefield[x2][y2].occupied.revealed = reveal; battlefield[x2][y2].player = player; /* make piece empty */ battlefield[x1][y1].occupied.name = "UNOCCUPIED"; battlefield[x1][y1].occupied.rank = -1; battlefield[x1][y1].player = -1; }

---

Variable Documentation

battlefield_piece battlefield[BATTLEFIELD_DIMENSIONS][BATTLEFIELD_DIMENSIONS]

Main array for a console. Warning: Whenever a move has been made by any player this array must be updated This array is the "water tank" of each console as it holds all information concerning the game. Since each element is a battlefield_piece structure, information provided concerns which player is on it and what is the rank and name of that piece. Every function in the game references this array to obtain information about the game status. Its dimensions are suited to the size of the console for reasons of clarity. Each square on the board corresponds to an element on the battlefield array. i.e. the board with coordinates x=3 y=4 is represented by element battlefield[3][4].

piece pieces_table[12]

Initial value: { { "Marshal" , 1}, { "General" , 2}, { "Colonel" , 3}, { "Major" , 4}, { "Captain" , 5}, { "Lieutenant" , 6}, { "Sergeant" , 7}, { "Miner" , 8}, { "Scout" , 9}, { "Spy" , 0}, { "Bomb" , 0}, { "Flag" , 0} } Statically defined array. This array holds the information concerning all the pieces used in the game. This array is accessed from many functions to obtain information about a specific piece. For example, if we need the data for a Marshal we access pieces_table[0]. Warning: The contents of this array should never be altered

---