public void StartGame()
{
CurrentTurn = new Turn();
// Have the initial arrangement rendered.
if (MoveMade != null)
{
MoveMade(this, EventArgs.Empty);
}
HookTurnEvents();
CurrentTurn.GenerateMoves();
PlayerType playerType = _playerTypes[CurrentTurn.PlayingColour];
switch (playerType)
{
case PlayerType.Chimp:
CurrentTurn.MakeRandomMove();
return;
case PlayerType.Computer:
MakeBestMove();
return;
default:
return;
}
}
// Update is called once per frame
void Update()
{
if (Input.GetButtonDown("Fire1"))
{
turnables.Shuffle();
TurnList.OnListUpdate(turnables);
}
if (Input.GetButtonDown("Fire2"))
{
int randomIndex2 = Random.Range(0, turnables.Count);
int randomIndex1 = Random.Range(0, turnables.Count);
ITurn swapped1 = turnables[randomIndex1];
ITurn swapped2 = turnables[randomIndex2];
turnables[randomIndex1] = swapped2;
turnables[randomIndex2] = swapped1;
TurnList.OnListUpdate(turnables);
}
if (Input.GetButtonDown("Jump"))
{
ITurn first = turnables[0];
turnables.RemoveAt(0);
turnables.Add(first);
TurnList.OnListUpdate(turnables);
}
}
public static Turn New(ITurn turnObject)
{
return(new Turn()
{
_turnObject = turnObject
});
}
public void Construct(
IGameMap gameMap,
ITurn turn)
{
_gameMap = gameMap;
_turn = turn;
}
/// <summary>
/// Raises the turn ready event. Implementing classes should call this
/// when they have a turn ready to play
/// </summary>
/// <param name="turn">Turn.</param>
protected virtual void OnTurnReady(ITurn turn)
{
if (TurnReadyEvent != null)
{
TurnReadyEvent(turn);
}
}
public static void NextTurn()
{
int index = 0;
// Find which index we are
for (int i = 0; i < arrayOfUserUids.Length; i++)
{
if (arrayOfUserUids[i] == turnUid)
{
index = i;
break;
}
}
// Find new uid
index++;
if (index > 1)
{
index = 0;
}
string newTurnUid = arrayOfUserUids[index];
Debug.Log("new uid before post: " + newTurnUid);
ITurn newTurn = new ITurn();
newTurn.uid = newTurnUid;
// post new turn
FirebaseDatabase.PostJSON("turn/uid", newTurnUid, "ServerManager", "ProccedNextTurn", "ErrorNextTurn");
}
private void CurrentTurn_Ended(object sender, EventArgs e)
{
currentTurn.Ended -= CurrentTurn_Ended;
currentTurn = provider.GetNext();
currentTurn.Ended += CurrentTurn_Ended;
TurnStarted?.Invoke(this, currentTurn);
}
/// <summary>
/// Passes the turn ready event up from the TurnEngine
/// </summary>
/// <param name="bestTurn">Best turn.</param>
void HandleTurnReadyEvent(ITurn bestTurn)
{
Debug.Log(System.Enum.GetName(typeof(ConnectKPiece), player) + " : " + engine.Stats.ToString());
OnTurnReady(bestTurn);
engine.ResetStatisticsLog();
}
void ReceiveTurn(ITurn turn)
{
//Apply the turn and redraw the board
board = turn.ApplyTurn(board) as ConnectKBoard;
DrawBoard();
//check to see if the game is over
if (board.IsTerminal())
{
ConnectKPiece winner;
if (board.player == ConnectKPiece.P1)
{
winner = ConnectKPiece.P2;
}
else
{
winner = ConnectKPiece.P1;
}
Line winLine = board.GetWinningLine();
if (winLine != null)
{
DrawVictory(winLine, winner);
}
Debug.Log("Game over");
gameEnd = true;
p1.TurnReadyEvent -= ReceiveTurn;
p2.TurnReadyEvent -= ReceiveTurn;
}
else
{
PlayTurn();
}
}
public void AddTurn(ITurn newTurnObject)
{
onTurnStart += newTurnObject.onTurnStart;
//if (turnBasedElementList.Find(n => n.turnIndex == newTurnObject.turnIndex) == null) {
turnBasedElementList.Add(newTurnObject);
//}
}
private void SetGameFinished()
{
currentTurn.Ended -= CurrentTurn_Ended;
var player = currentTurn.Player;
currentTurn = null;
Finished?.Invoke(this, player);
}
public OldBattle(IOldMap map, IObjective objective, ITurn turnState, IActionProber actionProber)
{
_map = map;
_objective = objective;
_turnState = turnState;
_actionProber = actionProber;
}
protected internal override IEnumerable<IMove> GetStrategyAvailableMoves(IBoard board, ITurn turn, IGameRuleStrategyContext context)
{
if (this.NeedToMovePiece(board, turn.Player))
yield break;
var playerName = turn.Player;
var dice = this.GetAvailableDice(turn.Dice).OrderByDescending(x => x.Value).ToList();
var firstPiece = false;
for (var i = (board.Lanes.Count * 3) / 4; i < board.Lanes.Count; i++)
{
var lane = board.Lanes[i];
if (lane.Count == 0 || lane[0].Player != playerName)
continue;
foreach (var die in dice)
{
if (i + die.Value == board.Lanes.Count ||
(i + die.Value > board.Lanes.Count && !firstPiece))
{
yield return new DefaultMove(board.Lanes[i], i, die);
firstPiece = true;
}
}
firstPiece = true;
}
}
public static int Register(ITurn new_turnable)
{
if (Instance == null)
{
return(0);
}
if (Instance.Turnables == null)
{
Instance.Turnables = new List <ITurn>();
}
if (!Instance.Turnables.Contains(new_turnable))
{
MDebug.Log("^turnSystem TURNABLE: register " + new_turnable.GetID());
Instance.Turnables.Add(new_turnable);
// Instance.NormalizeList();
Instance.SortListByTime();
Instance.OnListUpdated.AttemptCall(Instance.Turnables);
return(Instance.Turnables.Count);
}
Instance.SortListByTime();
return(-1);
}
public void Start()
{
if (currentTurn != null) return;
currentTurn = provider.GetNext();
currentTurn.Ended += CurrentTurn_Ended;
TurnStarted?.Invoke(this, currentTurn);
}
public Monopoly(IBoard board, IDice dice, ITurn turn, ILoggerFactory loggerFactory = null)
{
Board = board;
Dice = dice;
Turn = turn;
Players = new List <Player>();
_logger = loggerFactory?.CreateLogger <Monopoly>();
}
public void OnValueChanged(string uidObject)
{
ITurn turn = JsonUtility.FromJson <ITurn>(uidObject);
turnUid = turn.uid;
DiceOnline.turnId = turn.uid;
Debug.Log("Turn uid is now: " + turnUid);
}
void UpdateBackground(object sender, ITurn turn)
{
switch (turn.Side)
{
case Side.CORP: background.sprite = dayCity; break;
case Side.RUNNER: background.sprite = nightCity; break;
}
}
void ReceiveTurn(ITurn turn)
{
//Debug.Log (gameBoard.ToString());
gameBoard = (TTTBoard)((TTTTurn)turn).ApplyTurn(gameBoard);
XTurn = !XTurn;
//Debug.Log (gameBoard.ToString());
DrawBoard();
waiting = false;
}
IEnumerator WaitForTurn(ITurn t)
{
///Double null check because we are checking an interface
while (!forceNext && ((t != null && !t.Equals(null)) && !t.HasEndedTurn() || TurnEventQueue.EventRunning))
{
// MDebug.Log("^turnSystem " + t.GetID() + " Events:" + TurnEventQueue.EventRunning.ToString() + " hasEnded" + t.HasEndedTurn() + "\n" + TurnEventQueue.ToString2());
yield return(null);
}
}
public static bool HasTurn(ITurn t)
{
// MDebug.Log("t " + t.GetID() + " current" + Instance.Current.GetID());
if (Instance == null || Instance.Current == null || Instance.Current != t)
{
return(false);
}
return(true);
}
UI_TurnListItem MakeItem(ITurn u, Transform target)
{
UI_TurnListItem new_item = Instantiate(TurnListItemPrefab.gameObject).GetComponent <UI_TurnListItem>();
new_item.transform.SetParent(target, false);
new_item.SetTurnItem(u);
return(new_item);
}
private void Turn_Ended(object sender, EventArgs e)
{
if (turn != null)
{
turn.Ended -= Turn_Ended;
turn = null;
}
_playable = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="UniversalTurnBasedAI.MinimaxWorker"/> class.
/// </summary>
/// <param name="rootState">The starting state</param>
/// <param name="firstTurn">The turn to apply to the starting state to generate this worker's branch</param>
/// <param name="eval">The Evaluator</param>
/// <param name="maxDepth">Max depth.</param>
/// <param name="ourTurn">Whether or not it is the searching player's turn</param>
/// <param name="waitHandle">Signals the ThreadPool that the search is complete</param>
public MinimaxWorker(IGameState rootState, ITurn firstTurn, IEvaluator eval, int maxDepth, bool ourTurn, EventWaitHandle waitHandle)
{
this.rootState = rootState;
this.firstTurn = firstTurn;
this.maxDepth = maxDepth;
this.ourTurn = ourTurn;
this.eval = eval;
this.waitHandle = waitHandle;
stopped = true;
}
private void TrackClicks(ITurn turn, EventHandler <ClickPool> update)
{
if (monitoredClicks != null)
{
monitoredClicks.Changed -= update;
}
monitoredClicks = turn.Clicks;
monitoredClicks.Changed += update;
update.Invoke(monitoredClicks, monitoredClicks);
}
void CheckTurn(ITurn turn)
{
if ((turn as Unit) != null && (turn as Unit).OwnerID == 1)
{
transform.GetChild(0).gameObject.SetActive(true);
}
else
{
transform.GetChild(0).gameObject.SetActive(false);
}
}
private void Update(ITurn turn)
{
DisplayHeader(TurnRow, $"Turn ({turn.Number} / {Settings.MaxTurns})");
int row = TurnRow + 1;
foreach (var bot in Game.Match.Round.Bots)
{
DisplayBot(row++, bot);
DisplayRow(row++, bot.Action);
}
}
void OnTurnStart(ITurn turn)
{
if (turn as Unit != null && (turn as Unit).OwnerID == 0)
{
GetComponent <CanvasGroup>().alpha = 1;
}
else
{
GetComponent <CanvasGroup>().alpha = 0;
}
}
// 25 Development Cards (14 Knight/Soldier Cards, 6 Progress Cards, 5 Victory Point Cards)
//ore, wool and grain
public void BuyDevelopmentCard(IPlayer player, ITurn turn)
{
if (player == null)
throw new ArgumentNullException(nameof(player));
if (turn == null)
throw new ArgumentNullException(nameof(turn));
if (!player.HasResources(DEVELOPMENTCARD_COST))
throw new InvalidOperationException("Player does not have the resources to buy a Development Card");
player.TakeResources(DEVELOPMENTCARD_COST);
player.AddCard(new DevelopmentCard(deck.Pop(), turn));
}
public static void Unregister(ITurn turnable)
{
if (turnable == Instance.Current)
{
Instance.Current = null;
}
if (Instance.Turnables.Contains(turnable))
{
MDebug.Log("^turnSystem REMOVE " + turnable.GetID());
Instance.Turnables.Remove(turnable);
Instance.OnListUpdated.AttemptCall(Instance.Turnables);
}
}
bool isMyItem(Unit u, ITurn t)
{
if (u == null || t == null)
{
return(false);
}
if (t as Unit != null && t as Unit == u)
{
return(true);
}
return(false);
}
public void Turn(TurningDirection turningDirection)
{
ITurn turning = _mapDirection[CurrentDirection];
if (turningDirection == TurningDirection.R)
{
CurrentDirection = turning.TurnRight();
}
if (turningDirection == TurningDirection.L)
{
CurrentDirection = turning.TurnLeft();
}
}
public IEnumerable<IMove> GetAvailableMoves(IBoard board, ITurn turn)
{
if (!turn.AreDiceRolled || !this.GetAvailableDice(turn.Dice).Any())
yield break;
var context = new DefaultGameRuleStrategyContext();
for (var strategy = this; !context.IsDone && strategy != null; strategy = strategy.next)
{
foreach (var move in strategy.GetStrategyAvailableMoves(board, turn, context))
{
yield return move;
}
}
}
protected internal override IEnumerable<IMove> GetStrategyAvailableMoves(IBoard board, ITurn turn, IGameRuleStrategyContext context)
{
if (board.Bar.Any(x => x.Player == turn.Player))
{
foreach (var die in this.GetAvailableDice(turn.Dice))
{
if (this.IsMoveValid(board, die.Value, turn.Player))
{
yield return new DefaultMove(board.Bar, -1, die);
}
}
context.IsDone = true;
}
}
public void Construct(
IFogOfWar fogOfWar,
IReposition reposition,
ITurn turn,
ISceneTransition sceneTransition)
{
_fogOfWar = fogOfWar;
_reposition = reposition;
_turn = turn;
_sceneTransition = sceneTransition;
players = GameObject.FindObjectsOfType(typeof(Player)) as Player[];
if (StaticVariables.numberOfPlayers == 2)
{
Destroy(players[2].gameObject);
Destroy(players[3].gameObject);
numberOfPlayers = 2;
players = new Player[]
{
players[0],
players[1]
};
players[0].name = StaticVariables.player1Name;
players[1].name = StaticVariables.player2Name;
}
else if (StaticVariables.numberOfPlayers == 3)
{
Destroy(players[3].gameObject);
numberOfPlayers = 3;
players = new Player[]
{
players[0],
players[1],
players[2]
};
players[0].name = StaticVariables.player1Name;
players[1].name = StaticVariables.player2Name;
players[2].name = StaticVariables.player3Name;
}
else if (StaticVariables.numberOfPlayers == 4)
{
numberOfPlayers = 4;
players[0].name = StaticVariables.player1Name;
players[1].name = StaticVariables.player2Name;
players[2].name = StaticVariables.player3Name;
players[3].name = StaticVariables.player4Name;
}
}
public static Move BestMove(ITurn turn, byte depth)
{
// Generate the turn tree
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
TurnNode rootNode = new TurnNode(turn, 0, depth);
stopwatch.Stop();
Random random = new Random();
short randIndex = (short)random.Next(turn.AvailableMoves.Count);
Board board = turn.CurrentBoard;
short bestValue = board.Value;
Move bestMove = null;
foreach (Move move in turn.AvailableMoves)
{
Turn hypotheticalTurn = new Turn(board.Copy(), turn.PlayingColour, leaf: true);
hypotheticalTurn.Execute(move);
short value = hypotheticalTurn.CurrentBoard.Value;
switch (turn.PlayingColour)
{
case PieceColour.White:
if (value > bestValue)
{
bestValue = value;
bestMove = move;
}
break;
case PieceColour.Black:
if (value < bestValue)
{
bestValue = value;
bestMove = move;
}
break;
}
}
if (bestMove != null)
{
return(bestMove);
}
return(turn.AvailableMoves[randIndex]);
}
void OnStartTurn(ITurn turn)
{
float start = m_GrayScale.GetGray();
if (turn.GetType() == typeof(Unit) && (turn as Unit).OwnerID == 1 && !(turn as Unit).IsIdentified)
{
StopAllCoroutines();
Noise.enabled = true;
StartCoroutine(M_Extensions.YieldT(f => m_GrayScale.SetGray(start + (1 - start) * f), 0.25f));
}
else
{
StopAllCoroutines();
Noise.enabled = false;
StartCoroutine(M_Extensions.YieldT(f => m_GrayScale.SetGray(start * (1 - f)), 0.25f));
}
}
public void SetTurnItem(ITurn turn)
{
m_turn = turn;
if (OnSetTurnAble != null)
{
OnSetTurnAble(m_turn);
}
// Image.color = turn.GetColor();
Image.sprite = turn.GetIcon();
BackGround.color = turn.GetColor();
ActiveTurnIndicator.GetComponent <Image>().color = Color.white;
UpdateActiveTurnIndicator( );
turn.OnUpdateSprite += () => SetTurnItem(turn);
}
public DevelopmentCard(DevelopmentCardType type, ITurn boughtTurn)
{
if (!Enum.IsDefined(typeof(DevelopmentCardType), type))
throw new ArgumentException("Invalid card type");
if (boughtTurn == null)
throw new ArgumentNullException(nameof(boughtTurn));
Id = Guid.NewGuid();
Type = type;
if (type == DevelopmentCardType.VictoryPoint)
_playable = true;
else {
turn = boughtTurn;
turn.Ended += Turn_Ended;
}
}
protected internal override IEnumerable<IMove> GetStrategyAvailableMoves(IBoard board, ITurn turn, IGameRuleStrategyContext context)
{
var playerName = turn.Player;
var dice = this.GetAvailableDice(turn.Dice).ToList();
for (var i = 0; i < board.Lanes.Count; i++)
{
var lane = board.Lanes[i];
if (lane.Count == 0 || lane[0].Player != playerName)
continue;
foreach (var die in dice)
{
if (this.IsMoveValid(board, i, die.Value, playerName))
{
yield return new DefaultMove(lane, i, die);
}
}
}
}
public void BuyPhase(IGame game, ITurn turn, IPlayer player)
{
foreach (ICard card in player.Hand)
{
if ((card.Type & CardType.Treasure) == CardType.Treasure)
turn.PlayTreasure(card);
}
while (turn.Buys > 0)
{
if (turn.Treasure >= 8 && game.HasAvailable(Game.Base.Cards.Province))
turn.BuyCard(Game.Base.Cards.Province);
else if (turn.Treasure >= 6 && game.HasAvailable(Game.Base.Cards.Gold))
turn.BuyCard(Game.Base.Cards.Gold);
else if (turn.Treasure >= 3 && game.HasAvailable(Game.Base.Cards.Silver))
turn.BuyCard(Game.Base.Cards.Silver);
else
break;
}
}
private static void PrintBoard(IGame game, ITurn turn, IPlayer player)
{
var board = game.GetBoard(player);
var lanes = board.Lanes;
var playerName = player.Name;
Console.WriteLine("--1--2--3--4--5--6--0---7--8--9-10-11-12-");
for (var row = 0; row < 5; row++)
{
for (var column = 0; column < lanes.Count / 4; column++)
{
var pieces = lanes[column];
Console.Write("|");
Console.Write("{0,1}", pieces.Count > row + 5 ? (pieces[row + 5].Player == playerName ? "W" : "B") : string.Empty);
Console.Write("{0,1}", pieces.Count > row ? (pieces[row].Player == playerName ? "W" : "B") : string.Empty);
}
Console.Write("| ");
Console.Write(board.Bar.Count > row ? (board.Bar[row].Player == playerName ? "W" : "B") : "-");
Console.Write(" |");
for (var column = lanes.Count / 4; column < lanes.Count / 2; column++)
{
var pieces = lanes[column];
Console.Write("{0,1}", pieces.Count > row + 5 ? (pieces[row + 5].Player == playerName ? "W" : "B") : string.Empty);
Console.Write("{0,1}", pieces.Count > row ? (pieces[row].Player == playerName ? "W" : "B") : string.Empty);
Console.Write("|");
}
Console.WriteLine();
}
var dashes = 16 - player.Name.Length;
Console.Write("-{0} {1} {2}--------", new string('-', dashes / 2), player.Name, new string('-', (dashes + 1) / 2));
for (var i = 0; i < 4; i++)
{
if (turn.Dice.Count > i && !turn.Dice[i].IsUsed)
{
Console.Write("{0}--", turn.Dice[i].Value);
}
else
{
Console.Write("---");
}
}
Console.WriteLine("--");
for (var row = 4; row >= 0; row--)
{
for (var column = lanes.Count - 1; column >= (lanes.Count * 3) / 4; column--)
{
var pieces = lanes[column];
Console.Write("|");
Console.Write("{0,1}", pieces.Count > row + 5 ? (pieces[row + 5].Player == playerName ? "W" : "B") : string.Empty);
Console.Write("{0,1}", pieces.Count > row ? (pieces[row].Player == playerName ? "W" : "B") : string.Empty);
}
Console.Write("| - |");
for (var column = ((lanes.Count * 3) / 4) - 1; column >= lanes.Count / 2; column--)
{
var pieces = lanes[column];
Console.Write("{0,1}", pieces.Count > row + 5 ? (pieces[row + 5].Player == playerName ? "W" : "B") : string.Empty);
Console.Write("{0,1}", pieces.Count > row ? (pieces[row].Player == playerName ? "W" : "B") : string.Empty);
Console.Write("|");
}
Console.WriteLine();
}
Console.WriteLine("-24-23-22-21-20-19-----18-17-16-15-14-13-");
}
public void BuyPhase(IGame game, ITurn turn, IPlayer player)
{
foreach (ICard card in player.Hand)
{
if ((card.Type & CardType.Treasure) == CardType.Treasure)
turn.PlayTreasure(card);
}
while (turn.Buys > 0)
{
bool bought = true;
if (turn.Treasure >= 8 && game.HasAvailable(Game.Base.Cards.Province))
turn.BuyCard(Game.Base.Cards.Province);
else if (turn.Treasure >= 6 && game.HasAvailable(Game.Base.Cards.Gold))
turn.BuyCard(Game.Base.Cards.Gold);
else if (turn.Treasure >= 5 && game.HasAvailable(Game.Base.Cards.Mine) && (Count(player, "Mine") / Count(player, "Cards")) < TuningParameters.Get<double>("MineRatio", 0))
{
turn.BuyCard(Game.Base.Cards.Mine);
Increment(player, "Mine");
}
else if (turn.Treasure >= 5 && game.HasAvailable(Game.Base.Cards.Market) && (Count(player, "Market") / Count(player, "Cards")) < TuningParameters.Get<double>("MarketRatio", 0))
{
turn.BuyCard(Game.Base.Cards.Market);
Increment(player, "Market");
}
else if (turn.Treasure >= 4 && game.HasAvailable(Game.Base.Cards.Smithy) && (Count(player, "Smithy") / Count(player, "Cards")) < TuningParameters.Get<double>("SmithyRatio", 0))
{
turn.BuyCard(Game.Base.Cards.Smithy);
Increment(player, "Smithy");
}
else if (turn.Treasure >= 4 && game.HasAvailable(Game.Base.Cards.Militia) && (Count(player, "Militia") / Count(player, "Cards")) < TuningParameters.Get<double>("MilitiaRatio", 0))
{
turn.BuyCard(Game.Base.Cards.Militia);
Increment(player, "Militia");
}
else if (turn.Treasure >= 3 && game.HasAvailable(Game.Base.Cards.Village) && (Count(player, "Village") / Count(player, "Cards")) < TuningParameters.Get<double>("VillageRatio", 0))
{
turn.BuyCard(Game.Base.Cards.Village);
Increment(player, "Village");
}
else if (turn.Treasure >= 3 && game.HasAvailable(Game.Base.Cards.Woodcutter) && (Count(player, "Woodcutter") / Count(player, "Cards")) < TuningParameters.Get<double>("WoodcutterRatio", 0))
{
turn.BuyCard(Game.Base.Cards.Woodcutter);
Increment(player, "Woodcutter");
}
else if (turn.Treasure >= 3 && game.HasAvailable(Game.Base.Cards.Silver))
turn.BuyCard(Game.Base.Cards.Silver);
else if (turn.Treasure >= 2 && game.HasAvailable(Game.Base.Cards.Cellar) && (Count(player, "Cellar") / Count(player, "Cards")) < TuningParameters.Get<double>("CellarRatio", 0))
{
turn.BuyCard(Game.Base.Cards.Cellar);
Increment(player, "Cellar");
}
else if (turn.Treasure >= 2 && game.HasAvailable(Game.Base.Cards.Moat) && (Count(player, "Moat") / Count(player, "Cards")) < TuningParameters.Get<double>("MoatRatio", 0))
{
turn.BuyCard(Game.Base.Cards.Moat);
Increment(player, "Moat");
}
else if (turn.Treasure >= 2 && game.HasAvailable(Game.Base.Cards.Estate))
turn.BuyCard(Game.Base.Cards.Estate);
else
bought = false;
if (bought)
{
Increment(player, "Cards");
continue;
}
else
break;
}
}
public void ActionPhase(IGame game, ITurn turn, IPlayer player)
{
ICard card;
while (turn.Actions > 0)
{
card = Utils.GetCard<Village>(player.Hand);
if (card != null)
{
turn.PlayAction(card, null);
continue;
}
card = Utils.GetCard<Market>(player.Hand);
if (card != null)
{
turn.PlayAction(card, null);
continue;
}
card = Utils.GetCard<Cellar>(player.Hand);
if (card != null)
{
IList<ICard> discards = new List<ICard>();
foreach (ICard cardInHand in player.Hand)
{
if (!Object.ReferenceEquals(cardInHand, card))
{
if ((cardInHand.Type & CardType.Victory) == CardType.Victory &&
(cardInHand.Type & CardType.Action) != CardType.Action)
discards.Add(cardInHand);
else if ((Game.Base.Cards)cardInHand.CardEnum == Game.Base.Cards.Cellar)
discards.Add(cardInHand);
}
}
if (discards.Count > 0)
{
turn.PlayAction(card, discards);
continue;
}
}
card = Utils.GetCard<Smithy>(player.Hand);
if (card != null)
{
turn.PlayAction(card, null);
continue;
}
card = Utils.GetCard<Mine>(player.Hand);
if (card != null)
{
ICard targetCard = Utils.GetCard<Copper>(player.Hand);
if (targetCard != null && game.HasAvailable(Game.Base.Cards.Silver))
{
turn.PlayAction(card, new Mine.MineData { Card = targetCard, TargetType = Game.Base.Cards.Silver });
continue;
}
targetCard = Utils.GetCard<Silver>(player.Hand);
if (targetCard != null && game.HasAvailable(Game.Base.Cards.Gold))
{
turn.PlayAction(card, new Mine.MineData { Card = targetCard, TargetType = Game.Base.Cards.Gold });
continue;
}
}
card = Utils.GetCard<Militia>(player.Hand);
if (card != null)
{
turn.PlayAction(card, null);
continue;
}
card = Utils.GetCard<Woodcutter>(player.Hand);
if (card != null)
{
turn.PlayAction(card, null);
continue;
}
card = Utils.GetCard<Moat>(player.Hand);
if (card != null)
{
turn.PlayAction(card, null);
continue;
}
break;
}
}
public void BuyDevelopmentCantBeCalledWithoutPlayer(IPlayer player, ITurn turn)
{
var board = new Mock<IBoard>();
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
Assert.Throws<ArgumentNullException>(() => bank.BuyDevelopmentCard(player, turn));
}
private IList<IGameMove> CallGetStrategyValidMoves(GameRuleStrategyBase strategy, IGameBoard board, ITurn turn, IGameRuleStrategyContext context)
{
return strategy.GetStrategyAvailableMoves(board, turn, context)
.Cast<IGameMove>()
.ToList();
}
protected internal abstract IEnumerable<IMove> GetStrategyAvailableMoves(IBoard board, ITurn turn, IGameRuleStrategyContext context);
private static bool TryParseValidTurn(NeatAiTurnChoice turnChoice, IPlayerState playerState, IEnumerable<TurnType> validTurnTypes, out ITurn turn)
{
turn = null;
if (!validTurnTypes.Contains(turnChoice.TurnType))
{
return false;
}
if (turnChoice.TurnType == TurnType.Attack)
{
var chosenMove = playerState.ActiveNeuromon.MoveSet.Moves.ElementAtOrDefault(turnChoice.Index);
if (chosenMove != default(Move))
{
turn = new Attack(chosenMove);
return true;
}
}
else if (turnChoice.TurnType == TurnType.SwitchActiveNeuromon)
{
var chosenActiveNeuromon = playerState.InactiveNeuromon.ElementAtOrDefault(turnChoice.Index);
if (chosenActiveNeuromon != default(Neuromon) && !chosenActiveNeuromon.IsDead)
{
turn = new SwitchActiveNeuromon(chosenActiveNeuromon);
return true;
}
}
return false;
}
public void ActionPhase(IGame game, ITurn turn, IPlayer player)
{
}
