private IResponse <IPieceModel> TryPlacePiece(PlacePiece act)
{
var entry = GetEntry(act.Player);
var isKing = act.Card.PieceType == EPieceType.King;
if (!entry.PlacedKing && !isKing)
{
return(new Response <IPieceModel>(null, EResponse.Fail, EError.Error, "Must place king first"));
}
var playerMana = act.Player.Mana;
var manaCost = act.Card.ManaCost;
#if !IGNORE_MANA
if (playerMana.Value - manaCost.Value < 0)
{
Warn($"{act.Player} deoesn't have mana to play {act.Card}");
return(new Response <IPieceModel>(null, EResponse.Fail, EError.NotEnoughMana, $"Attempted {act}"));
}
#endif
var resp = Board.TryPlacePiece(act);
if (resp.Failed)
{
Warn($"{act} failed");
return(resp);
}
playerMana.Value -= manaCost.Value;
if (isKing)
{
entry.PlacedKing = true;
}
return(resp);
}
public IResponse <IPieceModel> TryPlacePiece(PlacePiece place)
{
Assert.IsNotNull(place);
var coord = place.Coord;
Assert.IsTrue(IsValidCoord(coord));
var placeCard = place.Card;
if (At(coord) != null)
{
return(new Response <IPieceModel>(
null, EResponse.Fail, EError.InvalidTarget, $"Already {At(coord)}, cannot place {placeCard}"));
}
if (placeCard.PieceType == EPieceType.King && TestForCheck(place).Any())
{
return(Response <IPieceModel> .FailWith("Can't place King in Check"));
}
var piece = Registry.Get <IPieceModel>(place.Player, placeCard);
var set = AddPiece(coord, piece);
if (set.Success)
{
piece.MovedThisTurn = true;
}
var response = new Response <IPieceModel>(piece, set.Type, set.Error);
Verbose(20, $"{place} -> {response}");
return(response);
}
public void copySide(bool white)
{
List <GeneratedTile> toCopy = new List <GeneratedTile>();
foreach (List <GeneratedTile> item in GenerateGame.instance.board)
{
if (item.Count != 0 && item[0].isWhite == white)
{
toCopy.AddRange(item);
}
}
int row = 0;
foreach (GeneratedTile item in toCopy)
{
if (white)
{
row = GenerateGame.instance.boardSize - (int)item.pos.x - 1;
}
else
{
row = Mathf.Abs((int)item.pos.x - GenerateGame.instance.boardSize) - 1;
}
//Debug.Log(row);
if (GenerateGame.instance.board[row][Mathf.FloorToInt(item.pos.y)].occupied)
{
RemovePiece.removePiece(GenerateGame.instance.board[row][Mathf.FloorToInt(item.pos.y)].occupiedBy);
}
if (item.occupied)
{
PlacePiece.placePiece(item.occupiedBy, GenerateGame.instance.board[row][Mathf.FloorToInt(item.pos.y)]);
}
}
}
public ActionResult <bool> PlacePiece([FromBody] PlacePiece data)
{
var game = (from value in iRepository.GetSpellen()
where value.Token.Equals(data.gameToken)
select value).FirstOrDefault();
//Check if the playerToken is on its turn
if (game.GetPlayerColourOnToken(data.playerToken) != game.AandeBeurt)
{
return(StatusCode(403));
}
//Check if player wants to pass its turn
if (!data.pass)
{
if (game.PlacePiece(data.y, data.x))
{
Console.WriteLine(game.Bord);
//add zet to db
iRepository.PlacePiece(data.gameToken, game);
return(true);
}
return(false);
}
else
{
return(true);
}
}
public IResponse <IPieceModel> TryPlacePiece(PlacePiece place)
{
Assert.IsNotNull(place);
var coord = place.Coord;
Assert.IsTrue(IsValidCoord(coord));
if (At(coord) != null)
{
return(new Response <IPieceModel>(
null, EResponse.Fail, EError.InvalidTarget, $"Already {At(coord)}, cannot place {place.Card}"));
}
var piece = Registry.New <IPieceModel>(place.Player, place.Card);
var set = AddPiece(coord, piece);
if (set.Success)
{
piece.MovedThisTurn = true;
}
var response = new Response <IPieceModel>(piece, set.Type, set.Error);
Verbose(20, $"{place} -> {response}");
return(response);
}
public void WhenPlacingAPiece_ThenCallsWriter()
{
var spy = new BoardWriterSpy();
var emptyBoardReaderStub = new EmptyBoardReaderStub();
var placePiece = new PlacePiece(spy, emptyBoardReaderStub);
placePiece.Execute(0, 0);
Assert.True(spy.Called);
}
public void PlacePiece()
{
Common.Schema.PlacePiece p = new PlacePiece()
{
gameId = game.GameId,
playerGuid = game.Guid
};
Send(XmlMessageConverter.ToXml(p));
game.Pieces.Remove(CarriedPiece);
}
public void WhenPlacingTheFirstPiece_ThenUpdatesBoard(
int x, int y,
int?expectedPieceType, int expectedX, int expectedY)
{
var spy = new BoardWriterSpy();
var emptyBoardReaderStub = new EmptyBoardReaderStub();
var placePiece = new PlacePiece(spy, emptyBoardReaderStub);
placePiece.Execute(x, y);
Assert.AreEqual(expectedPieceType, spy.LastBoard.PieceAt(expectedX, expectedY));
}
public void GivenAPieceHasBeenPlaced_WhenPlacingAPiece_ThenUpdatedBoardIncludesBothPieces()
{
var spy = new BoardWriterSpy();
var boardReaderStub = new PieceSetOriginBoardReaderStub();
var placePiece = new PlacePiece(spy, boardReaderStub);
placePiece.Execute(1, 0);
Assert.AreEqual(0, spy.LastBoard.PieceAt(0, 0));
Assert.AreEqual(1, spy.LastBoard.PieceAt(1, 0));
}
public void MustIgnoreMoveOnExistingPiece(int x, int y)
{
var spy = new BoardWriterSpy();
var boardReaderStub = new PieceSetOriginBoardReaderStub(x, y);
var placePiece = new PlacePiece(spy, boardReaderStub);
placePiece.Execute(x, y);
Assert.That(spy.LastBoard, Is.Null);
}
public void DoesNotMutateTheBoard()
{
var spy = new BoardWriterSpy();
var boardReaderStub = new PieceSetOriginBoardReaderStub();
var originalBoard = boardReaderStub.Fetch();
var placePiece = new PlacePiece(spy, boardReaderStub);
placePiece.Execute(1, 0);
Assert.IsNull(originalBoard.PieceAt(1, 0));
}
public void CanDetectAWinForOHorizontally()
{
var placePiece = new PlacePiece(boardGateway, boardGateway);
placePiece.Execute(0, 0);
placePiece.Execute(0, 1);
placePiece.Execute(1, 0);
placePiece.Execute(1, 1);
placePiece.Execute(2, 0);
var seeBoard = new SeeBoard(boardGateway);
var response = seeBoard.Execute();
Assert.That(response.Winner, Is.Zero);
}
public void CanDetectAWinForOAntiDiagonally()
{
var placePiece = new PlacePiece(boardGateway, boardGateway);
placePiece.Execute(2, 0);
placePiece.Execute(1, 0);
placePiece.Execute(1, 1);
placePiece.Execute(2, 1);
placePiece.Execute(0, 2);
var seeBoard = new SeeBoard(boardGateway);
var response = seeBoard.Execute();
Assert.That(response.Winner, Is.EqualTo(0));
}
public void GivenAGameWithOnePiecePlaced_WhenISeeTheBoard_ThenTheBoardIsUpdatedCorrectly()
{
var placePiece = new PlacePiece(boardGateway, boardGateway);
placePiece.Execute(0, 0);
var seeBoard = new SeeBoard(boardGateway);
var response = seeBoard.Execute();
Assert.AreEqual(
new int?[, ]
{
{ 0, null, null },
{ null, null, null },
{ null, null, null }
},
response.Board
);
}
public void WhenANewPieceIsPlaced_MustBeDifferentFrom_ThePrevious()
{
var placePiece = new PlacePiece(boardGateway, boardGateway);
placePiece.Execute(0, 0);
placePiece.Execute(0, 1);
var seeBoard = new SeeBoard(boardGateway);
var response = seeBoard.Execute();
Assert.AreEqual(
new int?[, ]
{
{ 0, null, null },
{ 1, null, null },
{ null, null, null }
},
response.Board
);
}
public void CanNotOverwriteExistingPiece()
{
var placePiece = new PlacePiece(boardGateway, boardGateway);
placePiece.Execute(0, 0);
placePiece.Execute(0, 0);
placePiece.Execute(0, 2);
var seeBoard = new SeeBoard(boardGateway);
var response = seeBoard.Execute();
Assert.AreEqual(
new int?[, ]
{
{ 0, null, null },
{ null, null, null },
{ 1, null, null }
},
response.Board
);
}
public void GivenAllThePiecesArePlaced_AndThereIsNoWinner_CanDetectATie()
{
var placePiece = new PlacePiece(boardGateway, boardGateway);
placePiece.Execute(0, 2);
placePiece.Execute(1, 2);
placePiece.Execute(2, 2);
placePiece.Execute(1, 1);
placePiece.Execute(0, 1);
placePiece.Execute(0, 0);
placePiece.Execute(1, 0);
placePiece.Execute(2, 0);
placePiece.Execute(2, 1);
var seeBoard = new SeeBoard(boardGateway);
var response = seeBoard.Execute();
Assert.That(response.Winner, Is.Null);
Assert.That(response.HasGameEnded, Is.True);
}
private IResponse <IPieceModel> TryPlacePiece(PlacePiece act)
{
var entry = GetEntry(act.Player);
var card = act.Card;
// Have to start with a King.
var isKing = card.PieceType == EPieceType.King;
if (!entry.PlacedKing && !isKing)
{
return(Response <IPieceModel> .FailWith("Must place king first."));
}
if (isKing && InCheck(card.Color, act.Coord))
{
return(Response <IPieceModel> .FailWith("Can't place king in check."));
}
// Can only have one Queen.
var owner = act.Owner as IPlayerModel;
if (act.Card.PieceType == EPieceType.Queen)
{
var otherQueen = Board.Pieces.Any(p => p.SameOwner(owner) && p.PieceType == EPieceType.Queen);
if (otherQueen)
{
return(Response <IPieceModel> .FailWith("Can have up to one Queen on Board at a time."));
}
var nearKing = Board.GetAdjacent(
act.Coord, 1).Interrupts.Any(
p => p.SameOwner(owner) && p.PieceType == EPieceType.King);
if (!nearKing)
{
return(Response <IPieceModel> .FailWith("Queens must be placed next to a King."));
}
}
// Check mana cost.
var playerMana = act.Player.Mana;
var manaCost = act.Card.ManaCost;
#if !IGNORE_MANA
if (playerMana.Value - manaCost.Value < 0)
{
return(Response <IPieceModel> .FailWith("Not enough mana."));
}
#endif
// Pawns can only be placed next to a friendly.
if (card.PieceType == EPieceType.Peon &&
!Board.GetAdjacent(act.Coord, 1).Interrupts.Any(other => other.SameOwner(card)))
{
return(Response <IPieceModel> .FailWith("Peons must be placed next to friendly pieces."));
}
// Let the board make the final decision based on its own state.
var resp = Board.TryPlacePiece(act);
if (resp.Failed)
{
return(resp);
}
// We can place the card!
playerMana.Value -= manaCost.Value;
if (isKing)
{
entry.PlacedKing = true;
}
return(resp);
}
public void SetUp()
{
_placePiece = new PlacePiece(this);
_viewGrid = new ViewGrid(this);
_grid = new GridBuilder().Build();
}
public async Task HandleMessage(PlacePiece message, Socket handler)
{
if (!ValidateMessage(message))
{
return;
}
string resp = "";
await Task.Delay((int)GameMasterClient.Settings.ActionCosts.PlacingDelay);
Wrapper.Player currentPlayer = Players.Single(p => p.Guid == message.playerGuid);
GameMasterClient.Logger.Log(message, currentPlayer);
var dmb = new DataMessageBuilder(currentPlayer.Id);
lock (BoardLock)
{
Wrapper.Piece carriedPiece =
Pieces.SingleOrDefault(
pc =>
pc.PlayerId == currentPlayer.Id);
if (carriedPiece != null && !IsPlayerInGoalArea(currentPlayer))
{
Wrapper.Piece lyingPiece =
Pieces.FirstOrDefault(
pc =>
pc.PlayerId != currentPlayer.Id && pc.Location.Equals(currentPlayer.Location));
if (lyingPiece == null) //leaving our piece there
{
carriedPiece.PlayerId = null;
carriedPiece.Location.x = currentPlayer.Location.x;
carriedPiece.Location.y = currentPlayer.Location.y;
(Board.Fields[carriedPiece.Location.x, carriedPiece.Location.y] as Wrapper.TaskField).PieceId =
carriedPiece.Id;
Board.UpdateDistanceToPiece(Pieces);
}
else //destroying piece
{
Pieces.Remove(carriedPiece);
}
Wrapper.TaskField tf =
Board.Fields[currentPlayer.X, currentPlayer.Y] as Wrapper.TaskField;
resp = dmb.AddTaskField(tf.SchemaField as TaskField).GetXml();
GameMasterClient.Connection.SendFromClient(handler, resp);
return;
}
if (carriedPiece == null ||
carriedPiece.Type == PieceType.sham)
{
if (IsPlayerInGoalArea(currentPlayer))
{
//send empty piece collection
resp = dmb
.SetGoalFields(new GoalField[0])
.GetXml();
}
else
{
resp = dmb
.SetTaskFields(new TaskField[0])
.GetXml();
}
GameMasterClient.Connection.SendFromClient(handler, resp);
return;
}
Wrapper.GoalField gf = Board.Fields[currentPlayer.X, currentPlayer.Y] as Wrapper.GoalField;
// remove piece and goal
if (gf.Type == GoalFieldType.goal)
{
gf.Type = GoalFieldType.nongoal;
}
Pieces.Remove(carriedPiece);
bool blueWon = false;
EndGame(Board, TeamColour.blue);
if (endGame)
{
blueWon = true;
}
else
{
EndGame(Board, TeamColour.red);
}
if (endGame)
{
GameInProgress = false;
EndGameEventArgs args;
GameMasterClient.CancelToken.Cancel();
if (blueWon)
{
ConsoleDebug.Good("Blue team won!");
args = new EndGameEventArgs(TeamBlue, TeamRed)
{
Handler = handler
};
}
else
{
ConsoleDebug.Good("Red team won!");
args = new EndGameEventArgs(TeamRed, TeamBlue)
{
Handler = handler
};
}
foreach (var player in Players)
{
string endGameResponse = new DataMessageBuilder(player.Id, true)
.SetWrapperTaskFields(Board.GetTaskFields())
.SetWrapperGoalFields(Board.GetGoalFields())
.SetWrapperPieces(Pieces)
.SetPlayerLocation(player.Location)
.GetXml();
GameMasterClient.Connection.SendFromClient(handler, endGameResponse);
}
gameMaster.Logger.LogEndGame(this, blueWon ? TeamColour.blue : TeamColour.red);
OnGameEnd(this, args);
return;
}
resp = new DataMessageBuilder(currentPlayer.Id, endGame)
.AddGoalField(gf.SchemaField as GoalField)
.GetXml();
}
GameMasterClient.Connection.SendFromClient(handler, resp);
}
public PlacePieceMessage(PlacePiece place) : base(place)
{
}
/// <summary> /// Test that the King of the given color is not in check /// </summary> /// <param name="place"></param> /// <returns>All pieces that are putting the king in Check</returns> public IEnumerable <IPieceModel> TestForCheck(PlacePiece place) => TestForCheck(place.Card.Color, place.Coord);
