private void GetGameAndHuman(string gameId, string playerId, out Game game, out IHumanPlayer human)
{
var playerGuid = Guid.Parse(playerId);
game = _gameRepository.GetGameById(Guid.Parse(gameId));
human = game.Players.OfType <IHumanPlayer>().Single(h => h.Id == playerGuid);
}
public void Collision(IHumanPlayer player, ITakeSpace other)
{
var angle = player.AngleAvoiding(other);
player.Turn(angle + 2 * Math.Sign(angle));
s = State.Collided;
}
public GameEngine(IAiPlayer aiPlayer, IHumanPlayer humanPlayer)
{
_player1 = aiPlayer;
_player2 = humanPlayer;
_humanVsAi = true;
Initialize();
}
public async Task <Game> SetupGameAsync()
{
var boardState = _board.ResetGameBoardState();
//Create a new game with 3 players, 1 himan 1 unskilled AI and 1 skilled AI.
_players = new List <IPlayer>
{
new HumanPlayer(_board),
new SkilledPlayer(_board),
new UnSkilledPlayer(_board)
};
_state = new GameState(_players);
_deck.Shuffle();
_deck.Deal(ref _players);
//Find out which player goes first and set as current player
CurrentPlayer = _players.Where(x => x.HasSevenDiamonds()).First();
_humanPlayer = _players.First(x => x.IsHuman()) as IHumanPlayer;
var response = new Game
{
BoardState = boardState,
History = await _state.GetHistory(),
GameOver = await _state.IsGameOver(),
PlayerHand = _humanPlayer.ShowHand(),
NextPlayer = CurrentPlayer
};
return(response);
}
public IHand ContinueFromHumanPickTurn(IHumanPlayer human, bool willPick)
{
if (TurnType != TurnType.Pick)
{
throw new WrongGamePhaseExcpetion("Game must be in the Pick phase.");
}
var hand = _gameStateDesciber.CurrentHand;
return(new PickProcessor().ContinueFromHumanPickTurn(human, willPick, hand, new PickProcessor()));
}
public void Collision(IHumanPlayer player, ITakeSpace other)
{
if (player.Movement == MoveState.Moving)
{
return; // nothing to do?
}
double angle = player.AngleAvoiding(other);
player.Turn(angle);
//Console.WriteLine("Turning {0} degrees to avoid obstacle.", angle);
hasCollidedLastTurn = true;
}
/// <summary>
/// Use this method to bury cards in a Jack-of-Diamonds game.
/// </summary>
public void BuryCards(IHand hand, IHumanPlayer picker, List <SheepCard> cardsToBury, bool goItAlone)
{
if (hand.Picker != picker)
{
throw new NotPlayersTurnException("A non-picker cannot bury cards.");
}
cardsToBury.ForEach(c => picker.RemoveCard(c));
cardsToBury.ForEach(c => hand.AddBuried(c));
if (goItAlone)
{
hand.GoItAlone();
}
}
public void DoSomething(IHumanPlayer player, List <IWalker> zombies, List <IWalker> humans, List <ITakeSpace> obstacles, List <ResupplyPoint> resupply)
{
if (player.Movement == MoveState.Moving)
{
return;
}
switch (rng.Next(2))
{
case 0: player.Turn((rng.NextDouble() > 0.5 ? -1 : 1) * rng.NextDouble() * 300.0); break;
case 1: player.GoForward(rng.NextDouble() * 20.0); break;
}
}
public void BuryCards(IHumanPlayer player, List <SheepCard> cards, bool goItAlone, SheepCard?partnerCard)
{
if (TurnType != TurnType.Bury)
{
throw new WrongGamePhaseExcpetion("Game must be in the Bury phase.");
}
if (PartnerMethodEnum == Models.PartnerMethod.JackOfDiamonds || !partnerCard.HasValue)
{
new PickProcessor().BuryCards(IHands.Last(), player, cards, goItAlone);
}
else
{
new PickProcessor().BuryCards(IHands.Last(), player, cards, goItAlone, partnerCard.Value);
}
}
/// <summary>
/// Use this method to bury cards in a Called-Ace game.
/// </summary>
public void BuryCards(IHand hand, IHumanPlayer picker, List <SheepCard> cardsToBury, bool goItAlone, SheepCard partnerCard)
{
if (picker.Cards.Contains(partnerCard))
{
throw new ArgumentException("Picker has the parner card");
}
if (!picker.Cards.Any(c => CardUtil.GetSuit(c) == CardUtil.GetSuit(partnerCard)))
{
throw new ArgumentException($"Picker does not have a card in the {CardUtil.GetSuit(partnerCard).ToString()} suit");
}
if (!_validCalledAceCards.Contains(partnerCard))
{
throw new ArgumentException($"{CardUtil.GetAbbreviation(partnerCard)} is not a valid partner card.");
}
hand.SetPartnerCard(partnerCard);
BuryCards(hand, picker, cardsToBury, goItAlone);
}
public IHand ContinueFromHumanPickTurn(IHumanPlayer human, bool willPick, IHand hand, IPickProcessor pickProcessorOuter)
{
if (hand.PlayersWithoutPickTurn.FirstOrDefault() != human)
{
throw new NotPlayersTurnException("This is not the player's turn to pick.");
}
if (willPick)
{
hand.Blinds.ToList().ForEach(c => human.AddCard(c));
hand.SetPicker(human, new List <SheepCard>());
}
else
{
hand.PlayerWontPick(human);
pickProcessorOuter.PlayNonHumanPickTurns(hand);
}
return(hand);
}
public void RecordTurn(IHumanPlayer player, SheepCard card)
{
var trick = _gameStateDesciber.CurrentTrick;
if (trick.PlayersWithoutTurn.FirstOrDefault() != player)
{
throw new NotPlayersTurnException($"This is not the turn for the player: {player.Name}");
}
if (!player.Cards.Contains(card))
{
throw new ArgumentException("Player does not have this card", "card");
}
if (!trick.IsLegalAddition(card, player))
{
throw new ArgumentException("This move is not legal", "card");
}
trick.Add(player, card);
}
public void Collision(IHumanPlayer player, Edge edge)
{
double angle = 0;
switch (edge)
{
case Edge.Top:
angle = player.AngleToHeading(180);
break;
case Edge.Bottom:
angle = player.AngleToHeading(0);
break;
case Edge.Left:
angle = player.AngleToHeading(90);
break;
case Edge.Right:
angle = player.AngleToHeading(270);
break;
case Edge.TopAndLeft:
angle = player.AngleToHeading(90 + 45);
break;
case Edge.TopAndRight:
angle = player.AngleToHeading(180 + 45);
break;
case Edge.BottomAndLeft:
angle = player.AngleToHeading(45);
break;
case Edge.BottomAndRight:
angle = player.AngleToHeading(270 + 45);
break;
}
Console.WriteLine("Turning around {0} degrees", angle);
player.Turn(angle);
s = State.Collided;
}
public void SetInfo(IHumanPlayer player,
IArtificialIntelligence ai,
IList <IMonsterCard> playerMonsters,
IList <IManaCostable> playerEffects,
IList <IMonsterCard> aiMonsters,
IList <IManaCostable> aiEffects,
int playerRemaining,
int aiRemaining,
Phases phase,
bool playersTurn,
bool playerIsTarget)
{
this.Player = player;
this.AI = ai;
this.PlayerMonsters = playerMonsters;
this.PlayerEffects = playerEffects;
this.AIMonsters = aiMonsters;
this.AIEffects = aiEffects;
this.PlayerCardsRemaining = playerRemaining;
this.AICardsRemainig = aiRemaining;
this.Phase = phase;
this.PlayersTurn = playersTurn;
this.PlayerIsTarget = playerIsTarget;
}
public GameManagmentUI()
{
PlugableHumanPlayer = new ConsolePlayer();
Model = new BackgammonModel();
BoardUI = new Pawn[12, 12];
}
public void DoSomething(IHumanPlayer player, List <IWalker> zombies, List <IWalker> humans, List <ITakeSpace> obstacles, List <ResupplyPoint> resupply)
{
if (player.Movement == MoveState.Moving)
{
return;
}
switch (state)
{
case 0:
player.Turn(player.AngleToHeading(45));
state++;
break;
case 1:
case 3:
case 5:
case 7:
case 9:
case 11:
case 13:
case 15:
player.GoForward(5.0);
state++;
break;
case 2:
player.Turn(player.AngleToHeading(90));
state++;
break;
case 4:
player.Turn(player.AngleToHeading(90 + 45));
state++;
break;
case 6:
player.Turn(player.AngleToHeading(180));
state++;
break;
case 8:
player.Turn(player.AngleToHeading(180 + 45));
state++;
break;
case 10:
player.Turn(player.AngleToHeading(270));
state++;
break;
case 12:
player.Turn(player.AngleToHeading(270 + 45));
state++;
break;
case 14:
player.Turn(player.AngleToHeading(0));
state++;
break;
case 16:
player.Turn(rng.NextDouble() * 300.0);
state = 0;
break;
}
}
public void Collision(IHumanPlayer player, ITakeSpace other)
{
}
public void Collision(IHumanPlayer player, Edge edge)
{
}
public void DoSomething(IHumanPlayer player, List <IWalker> zombies, List <IWalker> humans, List <ITakeSpace> obstacles, List <ResupplyPoint> resupply)
{
// am I almost dead?? If so, eat something!
if (player.Lifespan == 1)
{
//Console.WriteLine("Almost dead -- eating something!");
player.Eat();
return;
}
// am I already moving? If so, don't update my movement.
if (player.Movement == MoveState.Moving)
{
return;
}
// I collided last turn, but I've finished my turning to avoid that now. Go forward instead.
if (hasCollidedLastTurn)
{
//Console.WriteLine("Collided last turn. Finished turning, so going forward a bit.");
player.GoForward(rand.Next(4, 35));
hasCollidedLastTurn = false;
return;
}
// find the closest resupply point.
if (visited.Count == resupply.Count)
{
visited.Clear(); // start again!
}
if (resupply.Count == 0)
{
//Console.WriteLine("No resupply points? There's nothing for a greedy human to do, then :-(. Will just sit and starve here...");
return; // do nothing!
}
ResupplyPoint supplyPoint = null;
foreach (ResupplyPoint r in resupply)
{
if ((supplyPoint == null || player.DistanceFrom(supplyPoint) > player.DistanceFrom(r)) && !visited.Contains(r.Id))
{
supplyPoint = r;
}
}
// am I there already?
if (supplyPoint.Intersects(player) && supplyPoint.Available.Length > 0)
{
if (supplyPoint.Available.Contains(SupplyItem.Food))
{
//Console.WriteLine("Taking some food.");
player.TakeFoodFrom(supplyPoint);
}
else
{
//Console.WriteLine("Taking some socks.");
player.TakeSocksFrom(supplyPoint);
}
visited.Add(supplyPoint.Id);
}
else
{
// I still need to go there...
double angleTo = player.AngleTo(supplyPoint);
if (Math.Abs(angleTo) >= 10.0)
{
//Console.WriteLine("Turning {0} degrees to face my food, yum!");
player.Turn(angleTo);
}
else
{
//Console.WriteLine("Going to my food.");
player.GoForward(player.DistanceFrom(supplyPoint));
}
}
}
public void Collision(IHumanPlayer player, ITakeSpace other)
{
//Console.WriteLine("random human: I collided with {0}", other);
player.Turn(player.AngleAvoiding(other));
}
public void Collision(IHumanPlayer player, Edge edge)
{
//Console.WriteLine("Hit the {0} edge of the map", edge);
}
public Controller(IComputerPlayer computerPlayer, IHumanPlayer humanPlayer, IGameService gameService)
{
_computerPlayer = computerPlayer;
_humanPlayer = humanPlayer;
_gameService = gameService;
}
public Controller(IComputerPlayer computerPlayer, IHumanPlayer humanPlayer, IGameService gameService)
{
_computerPlayer = computerPlayer;
_humanPlayer = humanPlayer;
_gameService = gameService;
}
public void Collision(IHumanPlayer player, ITakeSpace other)
{
throw new NotImplementedException();
}
IWalker GetClosestZombie(IHumanPlayer player, List <IWalker> zombies)
{
return(zombies.OrderBy(x => x.DistanceFrom(player)).Where(x => !x.IsStunned).FirstOrDefault());
}
public HumanPlayer(ePlayer type, IHumanPlayer plugableHumanPlayer)
{
Type = type;
PlugableHumanPlayer = plugableHumanPlayer;
EatenPawns = new Stack <Pawn>();
}
public void Collision(IHumanPlayer player, Edge edge)
{
throw new NotImplementedException();
}
ResupplyPoint GetClosestResupplyWith(IHumanPlayer player, List <ResupplyPoint> resupply, SupplyItem what)
{
return(resupply.OrderBy(x => x.DistanceFrom(player)).Where(x => x.Available.Contains(what)).FirstOrDefault());
}
public void DoSomething(IHumanPlayer player, List <IWalker> zombies, List <IWalker> humans, List <ITakeSpace> obstacles, List <ResupplyPoint> resupply)
{
throw new NotImplementedException();
}
public void DoSomething(IHumanPlayer player, List <IWalker> zombies, List <IWalker> humans, List <ITakeSpace> obstacles, List <ResupplyPoint> resupply)
{
gameTime++;
if (player.Lifespan == 1)
{
player.Eat();
}
//if (zombies.Count == 0) return; // nothing to do!
var closestZ =
zombies
.OrderBy(x => x.DistanceFrom(player))
.Where(x => !x.IsStunned)
.Where(x => !targeted.ContainsKey(x.Id) || (gameTime - targeted[x.Id] > 8))
.FirstOrDefault();
if (closestZ != null && player.IsInSockRange(closestZ) && player.Inventory.Contains(SupplyItem.Sock))
{
// screw it, throw a sock!
player.Throw(player.Heading + player.AngleTo(closestZ));
targeted[closestZ.Id] = gameTime;
return;
}
if (player.Lifespan < player.MaximumLifespan / 2 && !player.Inventory.Contains(SupplyItem.Food) && gameTime % 20 == 0)
{
s = State.FindFood;
}
else if (!player.Inventory.Contains(SupplyItem.Sock) && gameTime % 50 == 0)
{
s = State.FindAmmo;
}
if (player.Movement == MoveState.Moving)
{
return;
}
Console.WriteLine("State: {0}", s);
switch (s)
{
case State.Undecided: {
if (zombies.Count == 0)
{
s = State.AllDone;
//s = State.RunAway;
return;
}
if (!player.Inventory.Contains(SupplyItem.Sock))
{
s = State.FindAmmo;
}
else if (!player.Inventory.Contains(SupplyItem.Food))
{
s = State.FindFood;
}
else
{
go_to = (RunState)(((int)++go_to) % 4);
s = State.RunAway;
}
break;
}
case State.FindFood:
case State.FindAmmo: {
var r = GetClosestResupplyWith(player, resupply, s == State.FindFood ? SupplyItem.Food : SupplyItem.Sock);
if (r == null)
{
return; // ... aaand wait?
}
if (player.IsCloseEnoughToInteractWith(r))
{
s = s == State.FindFood ? State.GetFood : State.GetAmmo;
return;
}
var angle = player.AngleTo(r);
if (Math.Abs(angle) < 1.0)
{
player.GoForward(player.DistanceFrom(r));
}
else
{
player.Turn(angle);
}
break;
}
case State.GetFood: {
var r = GetClosestResupplyWith(player, resupply, SupplyItem.Food);
if (r == null)
{
s = State.Undecided;
return;
}
if (!player.IsCloseEnoughToInteractWith(r))
{
s = State.FindFood;
return;
}
Console.WriteLine("Available here: {0}", String.Join(", ", r.Available));
if (r.Available.Contains(SupplyItem.Food))
{
player.TakeFoodFrom(r);
s = State.Undecided;
}
break;
}
case State.GetAmmo: {
var r = GetClosestResupplyWith(player, resupply, SupplyItem.Sock);
if (r == null)
{
s = State.Undecided;
return;
}
if (!player.IsCloseEnoughToInteractWith(r))
{
s = State.FindAmmo;
return;
}
Console.WriteLine("Available here: {0}", String.Join(", ", r.Available));
if (r.Available.Contains(SupplyItem.Sock) && player.InventorySlotsLeft > 1)
{
player.TakeSocksFrom(r);
return;
}
s = State.Undecided;
break;
}
case State.RunAway: {
// shift along the state, if we need to.
switch (go_to)
{
case RunState.TopLeft: if (player.Position.X <= player.MapWidth * 0.15 && player.Position.Y <= player.MapHeight * 0.15)
{
go_to = RunState.TopRight;
}
break;
case RunState.TopRight: if (player.Position.X >= player.MapWidth * 0.85 && player.Position.Y <= player.MapHeight * 0.15)
{
go_to = RunState.BottomLeft;
}
break;
case RunState.BottomLeft: if (player.Position.X <= player.MapWidth * 0.15 && player.Position.Y >= player.MapHeight * 0.85)
{
go_to = RunState.BottomRight;
}
break;
case RunState.BottomRight: if (player.Position.X >= player.MapWidth * 0.85 && player.Position.Y >= player.MapHeight * 0.85)
{
go_to = RunState.TopLeft;
}
break;
}
// check if we're angled correctly.
double angle = 0;
switch (go_to)
{
case RunState.TopLeft: angle = player.AngleToCoordinates(player.MapWidth * 0.1, player.MapHeight * 0.1); break;
case RunState.TopRight: angle = player.AngleToCoordinates(player.MapWidth * 0.9, player.MapHeight * 0.1); break;
case RunState.BottomLeft: angle = player.AngleToCoordinates(player.MapWidth * 0.1, player.MapHeight * 0.9); break;
case RunState.BottomRight: angle = player.AngleToCoordinates(player.MapWidth * 0.9, player.MapHeight * 0.9); break;
}
double dist = 0;
switch (go_to)
{
case RunState.TopLeft: dist = player.DistanceFrom(player.MapWidth * 0.1, player.MapHeight * 0.1); break;
case RunState.TopRight: dist = player.DistanceFrom(player.MapWidth * 0.9, player.MapHeight * 0.1); break;
case RunState.BottomLeft: dist = player.DistanceFrom(player.MapWidth * 0.1, player.MapHeight * 0.9); break;
case RunState.BottomRight: dist = player.DistanceFrom(player.MapWidth * 0.9, player.MapHeight * 0.9); break;
}
if (Math.Abs(angle) < 5.0)
{
player.GoForward(dist);
}
else
{
player.Turn(angle);
}
break;
}
case State.Collided: {
player.GoForward(rand.Next(1, 6));
s = State.Undecided;
break;
}
case State.AllDone: {
s = State.Dance0;
break;
}
case State.Dance0: player.Turn(20); s = State.Dance1; break;
case State.Dance1: player.GoForward(6.0); s = State.Dance0; break;
}
}
