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 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; } }