/// <summary> /// Winner of the diceroll contest starts placing a port /// </summary> /// <param name="game"></param> /// <returns>First player to place a port</returns> public override void Start(XmlGame game) { int portCount = 0; foreach (Territory t in game.Board.Territories) { foreach (EPortType port in t.PortList) { game.ActionsQueue.Enqueue(new PlacePortAction() { // Placing ports goes chronologically starting with the winner. // The first player always has the advantage: // - For example with 5 ports and 4 players, first player may place twice // while the rest only once. // - First player may plac first, conveniently placing port alongside // - Since port stack is open, first player placing last port is 100% certain // known port GamePlayer = game.Players[portCount % game.Players.Count], // pass territoryID such that player knows to expect possible port locations TerritoryID = t.ID }); portCount++; } } }
public override void Execute(XmlGame game, GamePlayer player) { _Message = String.Format("{0} played a Victory Point card" , player.XmlPlayer.ID); base.Execute(game, player); }
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 Execute(XmlGame game, GamePlayer player) { player.DevRoadShips += 2; _Message = String.Format("{0} played a road building card", player.XmlPlayer.Name); base.Execute(game, player); }
public override void Execute(XmlGame game, GamePlayer player) { StringBuilder msg = new StringBuilder(); msg.Append(String.Format("{0} stole ", player.XmlPlayer.Name)); foreach (GamePlayer gamePlayer in game.Players) { //steal only form opponents if (!gamePlayer.XmlPlayer.Equals(player.XmlPlayer.ID)) { // and only if he has the type of resource if (gamePlayer.Resources[Resource, true] > 0) { // add resources by the development card owner player.Resources[Resource, true] += gamePlayer.Resources[Resource, true]; msg.Append(String.Format("{0} {1} from {2}, ", gamePlayer.Resources[Resource, true], Resource.ToString(), gamePlayer.XmlPlayer.Name)); // remove resources at victims gamePlayer.Resources[Resource, true] = 0; } } } // remove the trailing "," _Message = msg.ToString().Substring(0, msg.ToString().Length - 2); base.Execute(game, player); }
/// <summary> /// Constructs based on XML game. /// </summary> /// <param name="xmlGame">Parsed game from PinballX XML database</param> public AggregatedGame([NotNull] PinballXGame xmlGame) : this(Locator.Current) { Update(xmlGame); FileId = Path.Combine(xmlGame.System.TablePath, xmlGame.FileName); // Unlink local file when table path changes. XmlGame.WhenAnyValue(g => g.System.TablePath).Subscribe(newPath => ClearLocalFile()); }
public override void Execute(XmlGame game, GamePlayer player) { // Update largest army game.CalculateLargestArmy(player); _Message = String.Format("{0} played a soldier", player.XmlPlayer.Name); base.Execute(game, player); }
public override void Execute(XmlGame game, GamePlayer player) { _Message = String.Format("{0} gained {1} by playing a Year of Plenty card", player.XmlPlayer.Name, Resources.ToString()); // give player the resources player.Resources.AddCards(Resources); base.Execute(game, player); }
public virtual bool AllowedAction(InGameAction inGameAction, XmlGame game) { if (_AllowedActions.Contains(inGameAction.GetType())) { return true; } else { return false; } }
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); }
/// <summary> /// Updates XML game. /// </summary> /// <param name="xmlGame">Parsed game from PinballX XML database</param> /// <returns>This instance</returns> public AggregatedGame Update(PinballXGame xmlGame) { if (XmlGame == null) { XmlGame = xmlGame; } else { XmlGame.Update(xmlGame); } return(this); }
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 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 override bool IsValid(XmlGame game) { if (!base.IsValid(game)) return false; if (Resource == EResource.Volcano) { _InvalidMessage = "Cannot monopoly on volcano resource"; return false; } if (Resource == EResource.Gold) { _InvalidMessage = "Cannot monopoly gold resource"; return false; } if (Resource == EResource.Discovery) { _InvalidMessage = "Cannot monopoly discovery resource"; } return true; }
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 override GamePhase Next(XmlGame game) { // Determine if we should skip placing ports // randomports are assigned at start using the port lists on each territory. // The remaining ports are placed in the placement phase List<EPortType> allPorts = new List<EPortType>(); foreach (Territory t in game.Board.Territories) { foreach (EPortType p in t.PortList) { allPorts.Add(p); } } if (allPorts.Count == 0) { // We do not have any ports to set, skip to placement phase return new PlacementGamePhase(); } else { // players should place ports return new PlacePortGamePhase(); } }
public override void Start(XmlGame game) { game.ActionsQueue.Enqueue(new PlacementDoneAction() { Sender = 0 }); }
public virtual void ProcessAction(InGameAction inGameAction, XmlGame game) { // base class should implement throw new NotImplementedException(); }
public override bool IsValid(XmlGame game) { if (!base.IsValid(game)) return false; return true; }
public virtual void Start(XmlGame game) { throw new NotImplementedException(); }
/// <summary> /// Checks if the XML game is equal, i.e. the data is equal (to /// check if it should be updated). /// </summary> /// <param name="xmlGame">XML game to compare</param> /// <returns>True if equal, false otherwise</returns> public bool EqualsXmlGame(PinballXGame xmlGame) { return(XmlGame != null && XmlGame.Equals(xmlGame)); }
public override bool AllowedAction(InGameAction inGameAction, XmlGame game) { return base.AllowedAction(inGameAction, game); }
public virtual TurnPhase ProcessAction(InGameAction action, XmlGame game) { throw new NotImplementedException(); }
public override GamePhase Next(XmlGame game) { return new PlacementGamePhase(); }
// Each player should place a town+road public override void Start(XmlGame game) { // Expect each player to place town/road - town/road int i = 0; bool back = false; // A loop going backward. Each index should be hit twice. // Example with 4 players: p1 - p2 - p3 - p4 - p4 - p3 - p2 - p1 while (i > -1) { // If tournament starting rules are set, second building should be a city if (back && game.Settings.TournamentStart) { // Tournamanet starting rules, add a city game.ActionsQueue.Enqueue(new BuildCityAction() { GamePlayer = game.Players[i] }); } else { // Normal starting rules, add two towns game.ActionsQueue.Enqueue(new BuildTownAction() { GamePlayer = game.Players[i] }); } // This action actually might be a BuildShipAction too. // TODO: implement this somewhere game.ActionsQueue.Enqueue(new BuildRoadAction() { GamePlayer = game.Players[i] }); // if the "back" flag is set, we should decrease the counter if (back) { i--; } else { i++; } // flip the flag when counter reaches maximum value // (maximum value equals amount of players) if (i == game.Players.Count) { // next loop is walked with same maximum value i--; // switch flag back = true; } } // When in tournament phase, very player may build a third road if (game.Settings.TournamentStart) { for (int j = 0; j < game.Players.Count; j++) { game.ActionsQueue.Enqueue(new BuildRoadAction() { GamePlayer = game.Players[j] }); } } }
public override GamePhase Next(XmlGame game) { return new PlayTurnsGamePhase(); }
public override GamePhase Next(XmlGame game) { return new EndedGamePhase(); }
/// <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); }