public Board(GameSettings gameSettings, ContentManager content)
{
this.gameSettings = gameSettings;
GenerateStones();
Stand = new Stand(content);
Init();
}
public AsciiBoard(GameSettings gameSettings, SpriteFont font, SpriteBatch sp)
{
this.gameSettings = gameSettings;
this.font = font;
this.spriteBatch = sp;
GenerateStones();
Init();
}
/// <summary>
/// Process the actual game state
/// </summary>
/// <param name="gameLogic"></param>
/// <param name="models"></param>
/// <param name="gameSettings"></param>
#region static public void Process(Game gameLogic, Models models, GameSettings gameSettings)
static public void Process(Connect4Game gameLogic, GameSettings gameSettings, IBoard board)
{
// Gameplay for the chosen game mode
switch (gameLogic.GameMode)
{
case GameSettings.GAMEMODE.SinglePlayer:
{
FSM_SinglePlayer(gameLogic, gameSettings, board);
break;
}
case GameSettings.GAMEMODE.LocalMultiPlayer:
{
//FSM_MultiPlayer(gameLogic, gameSettings);
break;
}
case GameSettings.GAMEMODE.CPUvsCPU:
{
//FSM_CPUvsCPU();
break;
}
}
}
/// <summary>
/// Constructor.
/// </summary>
public GameplayScreen()
{
TransitionOnTime = TimeSpan.FromSeconds (1.5);
TransitionOffTime = TimeSpan.FromSeconds (0.5);
gameSettings = new GameSettings();
gameLogic = new Connect4Game (GameSettings.GAMEMODE.SinglePlayer,
gameSettings.STARTING_PLAYER,
gameSettings.AI_STRENGTH,
gameSettings);
player1 = new Player2 (gameSettings.PLAYER_RED_NAME, true);
switch (gameSettings.AI_STRENGTH)
{
case GameSettings.DIFFICULTY.Easy:
{
player2 = new Player2 ("RookieBot", false);
break;
}
case GameSettings.DIFFICULTY.Medium:
{
player2 = new Player2 ("TrainedBot", false);
break;
}
case GameSettings.DIFFICULTY.Hard:
{
player2 = new Player2 ("Chief O'Bot", false);
break;
}
}
gameLogic.player1 = player1;
gameLogic.player2 = player2;
this.Reset(gameSettings);
}
public void SetGfxSkin(GameSettings.SkinType skinType)
{
if (skinType == SkinType.Classic)
{
if (GfxSkin == SkinType.Different)
{
this.SkinChanged = true;
}
standPath = MEDIAPATH + "classic\\stand_classic.x";
stoneRedPath = MEDIAPATH + "classic\\stone_red_classic.x";
stoneYellowPath = MEDIAPATH + "classic\\stone_yellow_classic.x";
GfxSkin = SkinType.Classic;
}
if (skinType == SkinType.Different)
{
if (GfxSkin == SkinType.Classic)
{
this.SkinChanged = true;
}
standPath = MEDIAPATH + "new\\ball.x";
standPath = MEDIAPATH + "new\\stand_different.x";
stoneRedPath = MEDIAPATH + "new\\stone_red_different.x";
stoneYellowPath = MEDIAPATH + "new\\stone_yellow_different.x";
GfxSkin = SkinType.Different;
}
}
public void Reset(GameSettings gameSettings)
{
gameLogic.ClearGame();
FSM.IsFinished = false;
}
/*
* Das Eröffnungsbuch wird aus "connect-4.data.txt" eingelesen, die Zobrist Keys aus "zobristkeys.txt".
* "Log white.txt" und "Log black.txt" sind voreingestellt als Logfiles.
*/
public ComputerPlayer(bool color, System.String name, bool bookEnabled, GameSettings.DIFFICULTY difficulty)
: base(color, name)
{
InitBlock();
this.bookEnabled = bookEnabled;
InitAsync(difficulty);
}
async private void InitAsync(GameSettings.DIFFICULTY difficulty)
{
if (bookEnabled)
{
await readBook(@"Content\Book.txt");
sortBook();
}
for (int i = 0; i < HASHSIZE; i++)
{
HashTable1[i] = new HashElement();
HashTable2[i] = new HashElement();
HashTable3[i] = new HashElement();
}
var zkReader = new ZobristKeys();
char[] array;
long x;
int power;
for (int i = 0; i < 42; i = i + 7)
{
for (int k = 0; k < 2; k++)
{
array = zkReader.ReadLine().ToCharArray();
x = 0;
power = 0;
if (array[0] == '0')
{
for (int l = 63; l >= 1; l--)
{
x = x + ((array[l] == '1' ? 1 : 0) * (long)(System.Math.Pow(2.0, (double)power)));
power += 1;
}
}
if (array[0] == '1')
{
x = (long)(-System.Math.Pow(2.0, 63));
for (int l = 63; l >= 1; l--)
{
x = x + ((array[l] == '1' ? 1 : 0) * (long)(System.Math.Pow(2.0, (double)power)));
power += 1;
}
}
zobristKeys[i][k] = x;
}
if (i == 41)
{
break;
}
if (i >= 35)
{
i = (i + 8) % 42 - 7;
}
}
// Set difficulty by defining the node limit
switch (difficulty)
{
case (GameSettings.DIFFICULTY.Easy):
{
Random rand = new Random();
NODELIMIT = rand.Next(10, 20);
break;
}
case (GameSettings.DIFFICULTY.Medium):
{
Random rand = new Random();
NODELIMIT = rand.Next(50, 1000);
break;
}
case (GameSettings.DIFFICULTY.Hard):
{
Random rand = new Random();
NODELIMIT = rand.Next(200000, 500000);
break;
}
}
}
/// <summary>
/// Single player mode
/// </summary>
/// <param name="gameLogic"></param>
/// <param name="models"></param>
/// <param name="gameSettings"></param>
#region private static void FSM_SinglePlayer(...)
private static void FSM_SinglePlayer(Connect4Game gameLogic, GameSettings gameSettings, IBoard board)
{
switch (gameLogic.GameState)
{
case GameSettings.GAMESTATE.S_BeforeGame:
{
if (gameLogic.STARTING_PLAYER == gameSettings.RED_PLAYER)
{
gameLogic.GameState = GameSettings.GAMESTATE.S_Player1Move;
gameLogic.HUMAN_PLAYER = gameSettings.RED_PLAYER;
}
else
{
gameLogic.GameState = GameSettings.GAMESTATE.S_WaitForCPU;
gameLogic.HUMAN_PLAYER = gameSettings.YELLOW_PLAYER;
}
break;
}
case GameSettings.GAMESTATE.S_Player1Move:
{
//HandleMouseInput(gameSettings, gameLogic);
//HandleKeyInput(gameSettings, gameLogic);
break;
}
case GameSettings.GAMESTATE.S_DropPlayerStone:
{
if (board.DropStone(gameLogic))
{
if (board.Bounce())
gameLogic.GameState = GameSettings.GAMESTATE.S_SwitchPlayer;
}
break;
}
case GameSettings.GAMESTATE.S_SwitchPlayer:
{
// Change player
gameLogic.SwitchPlayer();
gameLogic.CheckIfFinished();
if (gameLogic.NextGameState == GameSettings.GAMESTATE.S_GameFinished)
{
gameLogic.GameState = GameSettings.GAMESTATE.S_GameFinished;
}
else
{
board.SwitchStones(gameLogic);
if (gameLogic.activePlayer == gameSettings.RED_PLAYER)
{
// Reset stone position for the next new stone
gameLogic.SetNextPlayerStone();
gameLogic.GameState = GameSettings.GAMESTATE.S_Player1Move;
}
else
{
gameLogic.GameState = GameSettings.GAMESTATE.S_WaitForCPU;
}
}
break;
}
case GameSettings.GAMESTATE.S_WaitForCPU:
{
// Start the AI
if (!gameLogic.AIStarted)
{
gameLogic.CPUMove();
}
if (gameLogic.NextGameState == GameSettings.GAMESTATE.S_DropCPUStone)
{
gameLogic.AbortAI();
board.Update(gameLogic.column * board.ColumnDistance);
gameLogic.GameState = GameSettings.GAMESTATE.S_DropCPUStone;
}
break;
}
case GameSettings.GAMESTATE.S_DropCPUStone:
{
if (board.DropStone(gameLogic))
{
if (board.Bounce())
gameLogic.GameState = GameSettings.GAMESTATE.S_SwitchPlayer;
}
break;
}
case GameSettings.GAMESTATE.S_GameFinished:
{
IsFinished = true;
break;
}
}
}
public static void HandleKeyInput(GameSettings gameSettings, Connect4Game gameLogic, KeyboardState keyboardState, IBoard board)
{
if(gameLogic.GameState != GameSettings.GAMESTATE.S_Player1Move)
return;
#region Right key
if (!flagRight && !flagDown)
{
if (keyboardState.IsKeyDown(Keys.Right))
{
flagRight = true;
if (gameLogic.column < gameSettings.COLUMNS - 1)
{
// Update gamefield information
gameLogic.column++;
gameLogic.SetRow(gameLogic.column);
}
else
{
// Update gamefield information
gameLogic.column = 0;
gameLogic.SetRow(gameLogic.column);
}
board.Update(gameLogic.column * board.ColumnDistance);
}
}
#endregion
#region Left key
if (!flagLeft && !flagDown)
{
if (keyboardState.IsKeyDown(Keys.Left))
{
flagLeft = true;
if (gameLogic.column > 0)
{
// Update gamefield information
gameLogic.column--;
gameLogic.SetRow(gameLogic.column);
}
else
{
// Update gamefield information
gameLogic.column = gameSettings.COLUMNS - 1;
gameLogic.SetRow(gameLogic.column);
}
board.Update(gameLogic.column * board.ColumnDistance);
}
}
#endregion
#region Down key
if (!flagDown)
{
if (keyboardState.IsKeyDown(Keys.Down) && gameLogic.row != -1)
{
flagDown = true;
gameLogic.SetRow(gameLogic.column);
gameLogic.AddRowElement(gameLogic.column, gameLogic.row);
// Update game field
gameLogic.UpdateGameField();
// Drop player stone
gameLogic.GameState = GameSettings.GAMESTATE.S_DropPlayerStone;
}
}
#endregion
// Reset flags
if (!keyboardState.IsKeyDown(Keys.Right))
flagRight = false;
if (!keyboardState.IsKeyDown(Keys.Left))
flagLeft = false;
if (!keyboardState.IsKeyDown(Keys.Down))
flagDown = false;
}
/// <summary>
/// Start a new game
/// </summary>
/// <param name="mode"></param>
public Connect4Game(GameSettings.GAMEMODE mode, int startingPlayer, GameSettings.DIFFICULTY difficulty, GameSettings settings)
{
startTime = DateTime.Now;
RED_PLAYER = settings.RED_PLAYER;
YELLOW_PLAYER = settings.YELLOW_PLAYER;
COLUMNS = settings.COLUMNS;
ROWS = settings.ROWS;
this.aiStrength = difficulty;
this.GameMode = mode;
this.STARTING_PLAYER = startingPlayer;
this.activePlayer = startingPlayer;
map = new int[settings.COLUMNS, settings.ROWS];
switch (GameMode)
{
case (GameSettings.GAMEMODE.SinglePlayer):
{
position = new Position();
zuege = new MoveList();
comp = new ComputerPlayer(Position.WHITE, "Machine", true, difficulty);
this.GameState = GameSettings.GAMESTATE.S_BeforeGame;
break;
}
case (GameSettings.GAMEMODE.CPUvsCPU):
{
position = new Position();
zuege = new MoveList();
comp = new ComputerPlayer(Position.WHITE, "Machine1", true, difficulty);
if (this.STARTING_PLAYER == RED_PLAYER)
{
this.GameState = GameSettings.GAMESTATE.S_WaitForCPU;
this.HUMAN_PLAYER = RED_PLAYER;
}
else
{
this.GameState = GameSettings.GAMESTATE.S_WaitForCPU;
this.HUMAN_PLAYER = YELLOW_PLAYER;
}
break;
}
case (GameSettings.GAMEMODE.LocalMultiPlayer):
{
position = new Position();
zuege = new MoveList();
this.GameState = GameSettings.GAMESTATE.S_BeforeGame;
break;
}
case (GameSettings.GAMEMODE.NetworkGame):
{
position = new Position();
zuege = new MoveList();
/*string line = "";
using (StreamReader sr = new StreamReader("net.txt"))
{
string tmp;
while ((tmp = sr.ReadLine()) != null)
{
line = tmp;
}
sr.Close();
}
int port = Convert.ToInt32(line.Split(',')[0]);
string ip = line.Split(',')[1];
if (Convert.ToInt32(line.Split(',')[2]) == 2)
{
netStartPlayer = 1;
}
else
{
netStartPlayer = 2;
}
NetGame = new Networking(port, ip);*/
this.GameState = GameSettings.GAMESTATE.S_WaitForConnection;
break;
}
}
}
public static int GetScore(GameSettings.DIFFICULTY AIStrength, int turn, DateTime startTime)
{
int points;
long gameDuration = (DateTime.Now.Ticks - startTime.Ticks)/10000000;
switch (AIStrength)
{
case (GameSettings.DIFFICULTY.Confused):
{
points = 1;
break;
}
case (GameSettings.DIFFICULTY.Easy):
{
points = 1000000 / (turn + Convert.ToInt32(gameDuration));
break;
}
case (GameSettings.DIFFICULTY.Medium):
{
points = 10000000 / (turn + Convert.ToInt32(gameDuration));
break;
}
case (GameSettings.DIFFICULTY.Hard):
{
points = 100000000 / (turn + Convert.ToInt32(gameDuration));
break;
}
default:
{
points = -1;
break;
}
}
return points;
}
