public void MakeTurn()
{
string name = "Player 1";
var messageService = new Mock <IMessageService>();
var turnService = new TurnService(messageService.Object);
IPlayer player1 = new Human(turnService)
{
Name = name
};
IPlayer player2 = new Computer(turnService);
for (var i = 1; i < 4; i++)
{
messageService.Setup(e => e.ReadPlayerChoice()).Returns(i.ToString());
int choice1 = player1.MakeTurn();
int choice2 = player2.MakeTurn();
Assert.IsTrue(choice1 == i);
Assert.IsTrue(new[] { 1, 2, 3 }.Contains(choice2));
}
}
public void Discard_SetsTargetPlayer()
{
// Arrange
const int deckCardIndex = 0;
const int deckCardId = 1;
IDrawableCardState turnDeck = new CardState(deckCardIndex, deckCardId);
IList <IDiscardedCardState> roundDiscard = null;
IDiscardableCardState handCard = new CardState(1, 2);
IDiscardableCardState discardCard = new CardState(deckCardIndex, deckCardId);
IList <IDiscardableCardState> turnHand = new List <IDiscardableCardState>(new[] { handCard, discardCard });
IDiscardablePlayerState discardablePlayerState = new PlayerState(Guid.Empty, roundDiscard, turnHand);
IDiscardableTurnState turn = new TurnState(turnDeck, discardablePlayer: discardablePlayerState);
IList <IDiscardableCardState> targetHand = null;
IList <IDiscardedCardState> targetDiscard = null;
ITargetablePlayerState targetPlayer = new PlayerState(Guid.Parse("076d24f5-c5a1-48b8-be65-7afdd3f64130"), targetDiscard, targetHand);
var expected = targetPlayer;
IDiscardedCardState discardedCard = new CardState(deckCardIndex, deckCardId);
_cardStateFactory
.Setup(csf => csf.Discard(discardCard))
.Returns(discardedCard);
// Act
TurnService service = this.CreateService();
service.Discard(turn, discardCard, targetPlayer);
var actual = turn.TargetPlayer;
// Assert
Assert.AreEqual(expected, actual);
}
public void Discard_SetsTurnHand()
{
// Arrange
const int deckCardIndex = 0;
const int deckCardId = 1;
IDrawableCardState turnDeck = new CardState(deckCardIndex, deckCardId);
IList <IDiscardedCardState> roundDiscard = null;
IDiscardableCardState handCard = new CardState(1, 2);
IDiscardableCardState discardCard = new CardState(deckCardIndex, deckCardId);
var expected = new[] { handCard };
IList <IDiscardableCardState> turnHand = new List <IDiscardableCardState>(new[] { handCard, discardCard });
IDiscardablePlayerState discardablePlayerState = new PlayerState(Guid.Empty, roundDiscard, turnHand);
IDiscardableTurnState turn = new TurnState(turnDeck, discardablePlayer: discardablePlayerState);
IDiscardedCardState discardedCard = new CardState(deckCardIndex, deckCardId);
_cardStateFactory
.Setup(csf => csf.Discard(discardCard))
.Returns(discardedCard);
// Act
TurnService service = this.CreateService();
service.Discard(turn, discardCard);
var actual = turn.DiscardablePlayer.TurnHand;
// Assert
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void Step(ref CheckmateModalStepState token, int condition)
{
ModalEV modal = modalService.FindModalEV(entitiesDB);
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
PlayerColor victoriousPlayer = TurnService.CalcOtherTurnPlayer(currentTurn.TurnPlayer.PlayerColor);
SetModalOptions(modal, victoriousPlayer);
modalService.DisplayModal(modal);
}
//20% of this one is not covered.
private TurnTimer Timer(int gameId = 5, string word = "Cake", int turnInterval = 0, int letterInterval = 0)
{
//Tests are not covered 100% because we never hit these two fields.
turnInterval = turnInterval <= 0 ? _turnInterval : turnInterval;
letterInterval = letterInterval <= 0 ? _letterInterval : letterInterval;
service = new TurnService(null);
return(service.CreateTurnTimer(gameId, word, turnInterval, letterInterval));
}
public bool DoesForcedRearrangementResolveOrPreventCheck(
PieceEV forcedRearrangementPiece, PieceEV commander, List <PieceEV> towerPieces, IEntitiesDB entitiesDB)
{
List <PieceEV> allPieces = pieceFindService.FindAllBoardPieces(entitiesDB).ToList();
List <PieceEV> enemyPieces = pieceFindService.FindPiecesByTeam(
TurnService.CalcOtherTurnPlayer(commander.PlayerOwner.PlayerColor), entitiesDB).ToList();
List <PieceEV> actualThreats = destinationTileService.FindActualEnemyThreats(
commander, enemyPieces, allPieces, entitiesDB);
return(destinationTileService.ForcedRearrangementCanResolveThreats(
commander, forcedRearrangementPiece, actualThreats, allPieces, entitiesDB));
}
static void Main(string[] args)
{
var boardService = new BoardService();
var consoleWrapper = new ConsoleWrapper();
var inputService = new InputService(boardService);
var resultService = new ResultService(boardService);
var turnService = new TurnService(inputService, resultService, consoleWrapper);
var game = new GameService(turnService, boardService);
game.Play();
Console.ReadLine();
}
public WorldSimulation()
{
WorldSize = Convert.ToInt32(Settings.Default.WorldSize);
generator = new Generate(WorldSize);
AddAllAgents(generator.GenerateAgents());
// ініціалізація сервісів
filterService = new FilterService();
locationBuilder = new LocationServiceBuilder();
turnService = new TurnService();
sensorService = new SensorService();
statistic = new StatisticService();
rand = new Random();
}
private bool DropReleasesCheck(
PieceEV pieceToDrop,
Vector2 location,
PlayerColor playerColor,
PieceSide side,
HandPieceEV handPiece,
DropCheckmateLevel recursionLevel,
IEntitiesDB entitiesDB)
{
bool returnValue;
PieceEV?topPieceAtLocation = pieceFindService.FindTopPieceByLocation(location, entitiesDB);
pieceSetService.SetTopOfTowerToFalse(topPieceAtLocation, entitiesDB);
int tier = topPieceAtLocation.HasValue ? topPieceAtLocation.Value.Tier.Tier + 1 : 1;
pieceSetService.SetPieceLocationAndTier(pieceToDrop, location, tier, entitiesDB);
pieceSetService.SetPiecePlayerOwner(pieceToDrop, playerColor, entitiesDB);
pieceSetService.SetPieceSide(pieceToDrop, side, entitiesDB);
handService.DecrementHandPiece(ref handPiece);
PlayerColor enemyPlayerColor = TurnService.CalcOtherTurnPlayer(playerColor);
returnValue = DropCheckmateNotViolated(
pieceToDrop,
location,
playerColor,
side,
handPiece,
recursionLevel,
entitiesDB);
if (returnValue)
{
returnValue = !checkService.IsCommanderInCheck(playerColor, entitiesDB);
}
handService.IncrementHandPiece(ref handPiece);
pieceSetService.SetPieceLocationToHandLocation(pieceToDrop, entitiesDB);
if (topPieceAtLocation.HasValue)
{
pieceSetService.SetTopOfTower(topPieceAtLocation.Value, entitiesDB);
}
return(returnValue);
}
private void MoveCapturePieceToOtherPlayersHand(PieceEV pieceCaptured)
{
// Remove piece from player hand
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
HandPieceEV handPiece = handService.FindHandPiece(
pieceCaptured.Piece.Front,
pieceCaptured.Piece.Back,
currentTurn.TurnPlayer.PlayerColor,
entitiesDB);
handService.DecrementHandPiece(ref handPiece);
// Add piece to other player's hand
PlayerColor opponent = TurnService.CalcOtherTurnPlayer(currentTurn.TurnPlayer.PlayerColor);
handService.AddPieceToHand(pieceCaptured, entitiesDB, opponent);
}
private void SetModalOptions(TowerModalEV modal)
{
PieceEV pieceTier1 = pieceFindService.FindPieceEVById(modal.Tier1.ReferencedPieceId, entitiesDB).Value;
List <PieceEV> piecesAtLocation = pieceFindService.FindPiecesByLocation(pieceTier1.Location.Location, entitiesDB);
TurnEV currentTurnEV = turnService.GetCurrentTurnEV(entitiesDB);
PlayerColor colorToEnable = TurnService.CalcOtherTurnPlayer(currentTurnEV.TurnPlayer.PlayerColor);
PieceEV pieceTier2 = piecesAtLocation[1];
PieceEV?pieceTier3 = piecesAtLocation.Count > 2 ? (PieceEV?)piecesAtLocation[2] : null;
// TODO I think this logic is unnecessary, but I'm too scared to remove it now (all handled in TowerModalEngine). Later refactor.
bool noTier1CheckViolationsExist = immobileCaptureService.NoTier1CheckViolationsExist(piecesAtLocation, entitiesDB);
bool noTier3BetrayalTwoFileMoveViolationsExist = immobileCaptureService.NoTier3BetrayalTwoFileMoveViolationsExist(piecesAtLocation, entitiesDB);
entitiesDB.ExecuteOnEntity(
modal.ID,
(ref TowerModalEV modalToChange) =>
{
modalToChange.ImmobileCaptureState.ImmobileCaptureDesignated = true;
modalToChange.Tier1.Enabled = noTier1CheckViolationsExist &&
pieceTier1.PlayerOwner.PlayerColor == colorToEnable &&
pieceTier1.PlayerOwner.PlayerColor != pieceTier2.PlayerOwner.PlayerColor;
modalToChange.Tier2.Enabled = pieceTier2.PlayerOwner.PlayerColor == colorToEnable &&
(pieceTier2.PlayerOwner.PlayerColor != pieceTier1.PlayerOwner.PlayerColor ||
(pieceTier3.HasValue && pieceTier2.PlayerOwner.PlayerColor != pieceTier3.Value.PlayerOwner.PlayerColor));
if (pieceTier3.HasValue)
{
modalToChange.Tier3.Enabled = noTier3BetrayalTwoFileMoveViolationsExist &&
pieceTier3.Value.PlayerOwner.PlayerColor == colorToEnable &&
pieceTier3.Value.PlayerOwner.PlayerColor != pieceTier2.PlayerOwner.PlayerColor;
}
else
{
modalToChange.Tier3.Enabled = false;
}
});
}
/// <summary>
/// The main entry point for the application.
/// </summary>
//[STAThread]
static void Main()
{
//TODO validate program input
Console.WriteLine("(i)nteractive or (f)ile game?");
string gameType = Console.ReadLine();
//setting this up to read a file
switch (gameType)
{
case "i":
break;
case "f":
TurnService.GetTurnFile();
break;
}
Console.ReadLine();
//Application.EnableVisualStyles();
//Application.SetCompatibleTextRenderingDefault(false);
//Application.Run(new Form1());
}
private bool DropCheckmateNotViolated(
PieceEV pieceToDrop,
Vector2 location,
PlayerColor playerColor,
PieceSide side,
HandPieceEV handPiece,
DropCheckmateLevel recursionLevel,
IEntitiesDB entitiesDB)
{
bool returnValue = true;
PlayerColor enemyPlayerColor = TurnService.CalcOtherTurnPlayer(playerColor);
if (recursionLevel != DropCheckmateLevel.FINAL_TURN_PLAYER_CHECK && // Prevent infinite recursion
AbilityToPiece.HasAbility(DropAbility.CANNOT_DROP_CHECKMATE, pieceToDrop.Piece.PieceType) &&
checkService.IsCommanderInCheck(enemyPlayerColor, entitiesDB))
{
recursionLevel = recursionLevel == DropCheckmateLevel.FIRST_TURN_PLAYER_CHECK
? DropCheckmateLevel.SECOND_ENEMY_PLAYER_CHECK : DropCheckmateLevel.FINAL_TURN_PLAYER_CHECK;
returnValue = AnyValidMoves(enemyPlayerColor, entitiesDB, recursionLevel);
}
return(returnValue);
}
public TurnServiceTests()
{
playerRepository = Substitute.For <IRepository <Player> >();
timeProvider = Substitute.For <ITimeProvider>();
turnService = new TurnService(playerRepository, timeProvider);
}
