public void UpdateResponse(InGameAction action) { if (Player != null) { if (action.Sender == Player.XmlPlayer.ID) { AcceptOfferAction accept = action as AcceptOfferAction; if (accept != null) { UpdateAccept(accept); } RejectOfferAction reject = action as RejectOfferAction; if (reject != null) { UpdateReject(reject); } CounterTradeOfferAction counter = action as CounterTradeOfferAction; if (counter != null) { UpdateCounter(counter); } } } }
public override TurnPhase ProcessAction(InGameAction action, XmlGame game) { if (AllowedAction(action, game)) { action.PerformTurnAction(game); EndTurnAction endTurn = action as EndTurnAction; if (endTurn != null) { return new BeforeDiceRollTurnPhase(); } return this; } else { // Check if we are allowed to trade TradeOfferAction tradeOffer = action as TradeOfferAction; if (tradeOffer != null) { // Only when game setting allows it if (game.Settings.TradingAfterBuilding) { return _TradingPhase; } return null; } return null; } }
public override void ProcessAction(InGameAction inGameAction, XmlGame game) { /* HostStartsGameAction hostStarts = inGameAction as HostStartsGameAction; if (hostStarts != null) { game.ActionsQueue.Enqueue(new DetermineFirstPlayerGamePhase() { Sender = 0 }); } */ inGameAction.PerformTurnAction(game); }
public virtual bool AllowedAction(InGameAction inGameAction, XmlGame game) { if (_AllowedActions.Contains(inGameAction.GetType())) { return true; } else { return false; } }
public override bool AllowedAction(InGameAction inGameAction, XmlGame game) { if (!base.AllowedAction(inGameAction, game)) return false; // Check if we are allowed to trade TradeOfferAction tradeOffer = inGameAction as TradeOfferAction; if (tradeOffer != null && !game.Settings.TradingAfterBuilding) return false; // Default on returning true return true; }
public override void ProcessAction(InGameAction inGameAction, XmlGame game) { inGameAction.PerformTurnAction(game); if (game.ActionsQueue.Count == 0) { // Notify we want to start the placement phase game.ActionsQueue.Enqueue(new PortsPlacedAction() { Sender = 0 }); } else { // Move to the next player game.PlayerOnTurn = game.NextPlayer; } }
public override bool IsAllowed(InGameAction inGameAction, XmlGame game) { if (!base.IsAllowed(inGameAction, game)) return false; // When a placeport action is preformed, the action should be originating // from the expected player on the actionsqueue PlacePortAction placePort = inGameAction as PlacePortAction; if (placePort != null) { if (placePort.Sender != game.ActionsQueue.Peek().Sender) { return false; } } return true; }
public bool BeginAction(InGameAction action) { if (_InteractionBehaviour != null) { _InteractionBehaviour.RemoveStartState(Board); } _InteractionBehaviour = BoardVisualBehaviour.CreateBehaviour(action, CurrentGame); if (_InteractionBehaviour != null) { _InteractionBehaviour.SetStartState(Board); return true; } else { return false; } }
public override TurnPhase ProcessAction(InGameAction action, XmlGame game) { RollDiceAction rollDice = action as RollDiceAction; if (rollDice != null) { return new RollDiceTurnPhase(); } if (AllowedAction(action, game)) { action.PerformTurnAction(game); return this; } else { return null; } }
public override TurnPhase ProcessAction(InGameAction action, XmlGame game) { // If the action is allowed to be executed in this phase, do it if (AllowedAction(action, game)) { action.PerformTurnAction(game); return this; } else // If action is not allowed to execute, check if buildphase allows it. If so, move to // buildphase { if (_BuildPhase.AllowedAction(action, game)) { return _BuildPhase; } throw new Exception("whoa"); } }
public override void ProcessAction(InGameAction inGameAction, XmlGame game) { ClaimVictoryAction claimVictory = inGameAction as ClaimVictoryAction; if (claimVictory != null) { _TurnPhase.ProcessAction(inGameAction, game); return; } PlacementDoneAction placementDone = inGameAction as PlacementDoneAction; if (placementDone != null) { _TurnPhase.ProcessAction(inGameAction, game); return; } EndTurnAction endTurn = inGameAction as EndTurnAction; if (endTurn != null) { _TurnPhase = new BeforeDiceRollTurnPhase(); endTurn.PerformTurnAction(game); return; } // Process the actual in the current turnphase TurnPhase next = _TurnPhase.ProcessAction(inGameAction, game); // If return phase does not match current phase, we have to switch phases and process the action // again if (_TurnPhase != next) { _TurnPhase = next; _TurnPhase = _TurnPhase.ProcessAction(inGameAction, game); } // When the incoming action is not valid, check if it's valid in the next phase. // If so, switch phases if (!_TurnPhase.AllowedAction(inGameAction, game)) { if (_TurnPhase.Next().AllowedAction(inGameAction, game)) { _TurnPhase = _TurnPhase.Next(); } } }
public void ExecuteAction(InGameAction action) { //check if the userid of the action is actually playing if ((from u in _Users where u.ID == action.UserID select u).Count() == 0) { if (action is BuildRoadAction) { TryBuildRoad((BuildRoadAction)action); } } else // we received an ingame action from a user which is not in this game { MessageFromServerAction message = new MessageFromServerAction(); message.Message = String.Format( "Hey! You send an action for game with id: {0}, but you with userid {1} are not in the players list of game with id: {0}", action.GameID, action.UserID); } }
public override void ProcessAction(InGameAction inGameAction, XmlGame game) { // If we build a town or a city, make sure the next action (buildroad) // has OriginatingTownOrCity set. This is ignored for the third road // as required by Tournament Starting Rules. BuildTownAction buildTown = inGameAction as BuildTownAction; if (buildTown != null) { BuildRoadAction buildRoad3 = game.ActionsQueue.Peek() as BuildRoadAction; buildRoad3.OriginatingTownOrCity = buildTown.Location; } BuildCityAction buildCity = inGameAction as BuildCityAction; if (buildCity != null) { BuildRoadAction buildRoad2 = game.ActionsQueue.Peek() as BuildRoadAction; buildRoad2.OriginatingTownOrCity = buildCity.Location; } inGameAction.PerformTurnAction(game); // If the last road or ship has been built, add new gamephase action on the queue BuildRoadAction buildRoad = inGameAction as BuildRoadAction; BuildShipAction buildShip = inGameAction as BuildShipAction; if (buildRoad != null || buildShip != null) { if (game.ActionsQueue.Count == 0) { game.ActionsQueue.Enqueue(new PlacementDoneAction() { Sender = 0 }); } else { // Next player is the player of the first action on the queue game.PlayerOnTurn = game.GetPlayer(game.ActionsQueue.Peek().Sender); } } }
public GameAction ExecuteAction(InGameAction action) { if (action.IsValid(_Game)) { //Execute the game action if the action is valid action.PerformTurnAction(_Game); // Send action back to sender for confirmation //Send action to all other players and spectators //Add action to the gamelog _Game.GameLog.Add(action); return action; } else // we received an illegal ingameaction. // This should only happen when a user deliberately tampers with data { MessageFromServerAction message = new MessageFromServerAction(); message.Message = String.Format( "The game action does not seem to be valid. The reason: action object says \"{0}\"", action.InvalidMessage); return message; } }
/// <summary> /// Returns interaction behaviour for the 3D viewport depending on a game action /// </summary> /// Pattern: Factory method /// <param name="action"></param> /// <param name="game"></param> /// <returns></returns> public static BoardVisualBehaviour CreateBehaviour(InGameAction action, XmlGame game) { PlaceRobberPirateAction placerobberPirate = action as PlaceRobberPirateAction; if (placerobberPirate != null) return new PlaceRobberBehaviour() { OriginatingAction = action }; BuildCityAction buildCity = action as BuildCityAction; if (buildCity != null) return new BuildCityBehaviour(false) { OriginatingAction = action }; BuildTownAction buildTown = action as BuildTownAction; if (buildTown != null) { bool isStart; if (game.Phase.GetType() == typeof(PlayTurnsGamePhase)) isStart = false; else isStart = true; return new BuildTownBehaviour(isStart) { OriginatingAction = action }; } BuildRoadAction buildRoad = action as BuildRoadAction; if (buildRoad != null) return new BuildRoadBehaviour() { StartingTownOrCity = buildRoad.OriginatingTownOrCity, OriginatingAction = action }; BuildShipAction buildShip = action as BuildShipAction; if (buildShip != null) return new BuildShipBehaviour() { OriginatingAction = action }; TradeBankAction tba = action as TradeBankAction; if (tba != null) return new ShowPointsBehaviour(); ClaimVictoryAction claimWin = action as ClaimVictoryAction; if (claimWin != null) { return new TestBehaviour(); } MoveShipAction moveShip = action as MoveShipAction; if (moveShip != null) { return new MoveShipBehaviour() { OriginatingAction = moveShip }; } RollDiceAction rollDice = action as RollDiceAction; if (rollDice != null) { return new ShowResourcesGainedBehaviour() { OriginatingAction=rollDice }; } return null; }
private void TryHandleGameAction(InGameAction action) { if (CheckIfPlayerBelongsToGame(action.GameID, action.Sender)) { //HandleGameAction(action); } else { //notify the user some mismatch happened MessageFromServerAction response = new MessageFromServerAction(); response.Message = String.Format( "You, player {0} do not belong to game with ID {1}", action.GameID, _CurrentPerson.Name); response.Sender = _ServerUser.ID; Whisper(action.Sender, response); return; } }
/// <summary> /// Executes a given InGameAction /// </summary> /// <param name="inGameAction"></param> private void ExecuteInGameAction(InGameAction action) { ServerGame serverGame = (from g in _Games where g.Game.ID == action.GameID select g).Single(); if (!(action).IsValid(serverGame.Game)) { SayError(_CurrentPerson.ID, "Invalid InGameAction object"); } else { GameAction inGameAction = serverGame.ExecuteAction((InGameAction)action); TurnAction turnAction = inGameAction as TurnAction; if (turnAction != null) // When we have a turnaction, we must nullify the data sent to // spectators and players. No need for them to know what kind of // development cards or resources a player has. // The data should not even reside on a clients computer. { // before sending, make sure the actual player gets the // right data Whisper(action.Sender, turnAction); //Now we can nullify it turnAction.NullifyData(); //to send it to spectators and players foreach (XmlUser spectator in serverGame.Spectators) Whisper(spectator.ID, turnAction); foreach (XmlUser player in serverGame.Users) { //we already sent it to the actual player, so omit him if (player.ID != action.Sender) Whisper(player.ID, turnAction); } } else { if (inGameAction != null) { // Send message without nullifying data (no need for ingameactions) // to all clients (players & spectators) foreach (XmlUser client in serverGame.Users.Union<XmlUser>(serverGame.Spectators)) Whisper(client.ID, inGameAction); } else //Some error occured, only reflect back to the originating client { Whisper(action.Sender, inGameAction); } } } }
/// <summary> /// Broadcast the message to all participants of a game /// </summary> /// <param name="action">Action to broadcast</param> /// <param name="game">The game with the participants</param> private void BroadcastMessage(InGameAction action, ServerGame game) { // broadcast message to all users foreach (XmlUser user in game.Users) BroadcastMessage(action, user); // broadcast message to all spectators foreach (XmlUser spectator in game.Spectators) BroadcastMessage(action, spectator); }
private void HandleGameAction(InGameAction action) { // get the corresponding servergame //execute the action on the game }
private void OnExecuteGameAction(InGameAction action) { if (ExecuteGameAction != null) ExecuteGameAction(action); }
private void OnActionCompleted(InGameAction action) { if (ActionCompleted != null) ActionCompleted(action); }
void OnInGameActionReceived(InGameAction action) { if (InGameActionReceived != null) InGameActionReceived(action); }
public override bool AllowedAction(InGameAction inGameAction, XmlGame game) { return base.AllowedAction(inGameAction, game); }
/// <summary> /// Returns true if passed action is allowed to be performed in current /// game phase /// </summary> /// <param name="inGameAction"></param> /// <returns></returns> public virtual bool IsAllowed(InGameAction inGameAction, XmlGame game) { return _AllowedActions.Contains(inGameAction.GetType()); }
public virtual TurnPhase ProcessAction(InGameAction action, XmlGame game) { throw new NotImplementedException(); }
public virtual void ProcessAction(InGameAction inGameAction, XmlGame game) { // base class should implement throw new NotImplementedException(); }
public void SetStatus(InGameAction action) { RollDiceAction rollDice = action as RollDiceAction; if (rollDice != null) { } }
/// <summary> /// Creates gamequeue for each player /// </summary> /// <param name="inGameAction"></param> public override void ProcessAction(InGameAction inGameAction, XmlGame game) { inGameAction.PerformTurnAction(game); RollDiceAction rollDice = inGameAction as RollDiceAction; if (rollDice != null) { // Check if a phase has ended. If the queue is empty, every player has rolled the dice. if (game.ActionsQueue.Count() == 0) { // Make a list of rolls in this round List<RollDiceAction> rolledDices = game.GameLog.GetCurrentRoundRolls(game); // highroll dice number int highRoll = (from rd in rolledDices select rd.Dice).Max(); // When starting player is not determined yet, repeat dice roll between winners until // winner is detemined if (game.GameLog.FirstPlayerIsDetermined(game)) { // We have a starting player int winnerID = rolledDices.Where(rd => rd.Dice == highRoll) .First() .Sender; game.ActionsQueue.Enqueue(new StartingPlayerDeterminedAction() { // The starter of the placement/portplacement/turnactionsgamephase PlayerID = winnerID, // winning dice DiceRoll = highRoll, // Server will send this message Sender = 0 }); return; } else { // Starting player is not determined. Notify players and update Game object game.ActionsQueue.Enqueue(new RolledSameAction() { // Pass on the highest diceroll HighRoll = highRoll, // Server says dice rolled the same Sender = 0 }); // Enqueue each highroller foreach (RollDiceAction sameRoll in rolledDices.Where(rd => rd.Dice == highRoll)) { game.ActionsQueue.Enqueue(new RollDiceAction() { GamePlayer = sameRoll.GamePlayer }); } // First player is on turn game.PlayerOnTurn = game.ActionsQueue.ElementAt(1).GamePlayer; return; } } // Next player should be the player next on the queue game.PlayerOnTurn = game.GetPlayer(game.ActionsQueue .OfType<RollDiceAction>() .First() .Sender); } }
/// <summary> /// /// </summary> /// <param name="action"></param> /// <param name="game"></param> /// <returns></returns> public override TurnPhase ProcessAction(InGameAction action, XmlGame game) { if (AllowedAction(action, game)) { RollDiceAction rollDice = action as RollDiceAction; if (rollDice != null) { rollDice.PerformTurnAction(game); // When a volcano is rolled, expect player to roll dice for volcano /* if (rollDice.HexesAffected.OfType<VolcanoHex>().Count() > 0) { game.ActionsQueue.Enqueue(new RollVolcanoDiceAction() { GamePlayer = rollDice.GamePlayer, VolcanosRolled = rollDice.HexesAffected.OfType<VolcanoHex>().ToList<VolcanoHex>() }); // We expect another action, return current phase return this; } */ // When a 7 is rolled, enqueue every player required to loose cards to do so if (rollDice.Dice == 7) { // Add each player required to loose cards to the queue foreach (int i in rollDice.LooserPlayers) { game.ActionsQueue.Enqueue(new LooseCardsAction() { GamePlayer = game.GetPlayer(i) }); } // Expect player to place robber/pirate and rob a player game.ActionsQueue.Enqueue(new PlaceRobberPirateAction() { GamePlayer = action.GamePlayer }); game.ActionsQueue.Enqueue(new RobPlayerAction() { GamePlayer = action.GamePlayer }); // We have actions to be done, we should stay in this phase return this; } // Any other number has been rolled. // Proceed to trading phase if (game.ActionsQueue.Count == 0) { return new TradingTurnPhase(); } else { return this; } } RobPlayerAction robPlayer = action as RobPlayerAction; if (robPlayer != null) { robPlayer.PerformTurnAction(game); // When finished robbing, advance phase to trading return this; } // perform the action action.PerformTurnAction(game); EndTurnAction endTurn = action as EndTurnAction; if (endTurn != null) { return new BuildTurnPhase(null); } // Return current state return this; } else // Action is not allowed in rollDice phase. Check if it is allowed in subsequent phases, // then return that phase { TradingTurnPhase trading = new TradingTurnPhase(); BuildTurnPhase building = new BuildTurnPhase(trading); if (trading.AllowedAction(action, game)) { return trading; } if (building.AllowedAction(action, game)) { return building; } return null; } }
public override bool IsAllowed(InGameAction inGameAction, XmlGame game) { return _TurnPhase.AllowedAction(inGameAction, game); }