// Start is called before the first frame update
void Start()
{
playerBlack = createPlayer(PlayerEnum.black, GameProperties.playerBlackIsHuman);
playerWhite = createPlayer(PlayerEnum.white, GameProperties.playerWhiteIsHuman);
gameO = new Game(playerBlack, playerWhite);
boardUpdateO = GameObject.FindObjectOfType <BoardUpdate>();
boardUpdateO.setBoard(gameO.gameBoard);
boardUpdateO.game = this.gameO;
boardSquarePropertiesO = GameObject.FindObjectOfType <BoardSquareProperties>();
gameO.initGame();
}
void sDevice_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (Pause)
return;
if (e.PropertyName != "DeviceOnTopID" && e.PropertyName != "FlippingSide" && e.PropertyName != "JustShaked" && e.PropertyName != "HomePressed")
return;
ButtonEvent homePressed = sDevice.HomePressed ? ButtonEvent.Single : ButtonEvent.None;
BoardUpdate update = new BoardUpdate() { DeviceOnTopID = sDevice.DeviceOnTopID, FlippingSide = sDevice.FlippingSide, Shaked = sDevice.JustShaked, ButtonEvent = homePressed };
NotifyContextServices(this, new NotifyContextMonitorListenersEventArgs(typeof(BoardUpdate), update));
}
public void UpdateBoard(BoardUpdate update)
{
if (_db.TryGetValue(update.BoardId, out var db))
{
var stored = db.GetData <BoardUpdate>(update.BoardId);
stored.Moves.AddRange(update.Moves);
db.SetData(update.BoardId, stored);
if (update.UpdateType == COMMIT)
{
db.CommitChanges();
}
}
}
/// <summary>
/// Runs the match.
/// </summary>
/// <returns>The match result.</returns>
public Winner Run()
{
// Initially there's no winner
Winner winner = Winner.None;
// Notify listeners match is about to start
MatchStart?.Invoke(
matchConfig,
new string[] {
matchData.GetThinker(PColor.White).ToString(),
matchData.GetThinker(PColor.Red).ToString()
});
// Notify listeners that we have a new empty board
BoardUpdate?.Invoke(board);
// Game loop
while (true)
{
// Next player plays
winner = Play();
// Break loop if a winner is found
if (winner != Winner.None)
{
break;
}
}
// Notify listeners that match is over
MatchOver?.Invoke(
winner,
solution,
new string[] {
matchData.GetThinker(PColor.White).ToString(),
matchData.GetThinker(PColor.Red).ToString()
});
// Return match result
return(winner);
}
/// Current thinker makes its move
private Winner Play()
{
// Get a reference to the current thinker
IThinker thinker = matchData.CurrentThinker;
// Determine the color of the current thinker
PColor color = board.Turn;
// Match result so far
Winner winner = Winner.None;
// Thinking start time
DateTime startTime = DateTime.Now;
// Real think time in milliseconds
int thinkTimeMillis;
// Apparent thinking time left
int timeLeftMillis;
// Task to execute the thinker in a separate thread
Task <FutureMove> thinkTask;
// Notify listeners that next turn is about to start
NextTurn?.Invoke(color, thinker.ToString());
// Ask thinker to think about its next move
thinkTask = Task.Run(
() => thinker.Think(board.Copy(), ts.Token));
// The thinking process might throw an exception, so we wrap
// task waiting in a try/catch block
try
{
// Wait for thinker to think... until the allowed time limit
if (thinkTask.Wait(timeLimitMillis))
{
// Thinker successfully made a move within the time limit
// Get the move selected by the thinker
FutureMove move = thinkTask.Result;
// Was the thinker able to chose a move?
if (move.IsNoMove)
{
// Thinker was not able to chose a move
// Raise an invalid play event and set the other
// thinker as the winner of the match
winner = OnInvalidPlay(
color, thinker,
"Thinker unable to perform move");
}
else
{
// Thinker was able to chose a move
// Perform move in game board, get column where move
// was performed
int row = board.DoMove(move.shape, move.column);
// If the column had space for the move...
if (row >= 0)
{
// Obtain thinking end time
thinkTimeMillis = (int)(DateTime.Now - startTime)
.TotalMilliseconds;
// How much time left for the minimum apparent move
// time?
timeLeftMillis =
minMoveTimeMillis - thinkTimeMillis;
// Was the minimum apparent move time reached
if (timeLeftMillis > 0)
{
// If not, wait until it is reached
Thread.Sleep(timeLeftMillis);
}
// Notify listeners of the move performed
MovePerformed?.Invoke(
color, thinker.ToString(),
move, thinkTimeMillis);
// Get possible winner and solution
winner = board.CheckWinner(solution);
}
else
{
// If we get here, column didn't have space for the
// move, which means that thinker made an invalid
// move and should lose the game
// Raise an invalid play event and set the other
// thinker as the winner of the match
winner = OnInvalidPlay(
color, thinker,
"Tried to place piece in column "
+ $"{move.column}, which is full");
}
}
}
else // Did the time limit expired?
{
// Notify thinker to voluntarily stop thinking
ts.Cancel();
// Raise an invalid play event and set the other thinker
// as the winner of the match
winner = OnInvalidPlay(
color, thinker, "Time limit expired");
}
}
catch (Exception e)
{
// Is this an inner exception?
if (e.InnerException != null)
{
// If so, use it for error message purposes
e = e.InnerException;
}
// Raise an invalid play event and set the other thinker as
// the winner of the match
winner = OnInvalidPlay(
color, thinker,
$"Thinker exception: '{e.Message}'");
}
// Notify listeners that the board was updated
BoardUpdate?.Invoke(board);
// Return winner
return(winner);
}
