/// <summary> /// Checks if a card drawn by Dracula can be played immediately and resolves it if so /// </summary> /// <param name="game">The GameState</param> /// <param name="eventPlayedByDracula">The Event to assess</param> /// <param name="logic">The artificial intelligence component</param> private static void PlayImmediatelyDraculaCard(GameState game, Event eventPlayedByDracula, DecisionMaker logic) { switch (eventPlayedByDracula) { case Event.NightVisit: PlayNightVisit(game, logic); break; case Event.VampiricInfluence: PlayVampiricInfluence(game, logic); break; case Event.Evasion: PlayEvasion(game, logic); break; case Event.QuinceyPMorris: case Event.ImmanuelHildesheim: case Event.DraculasBrides: PlayDraculaAlly(game, eventPlayedByDracula, logic); break; default: Console.WriteLine("Dracula drew an Event card into his hand"); break; } }
/// <summary> /// Determines if Dracula is playing Seduction at the start of an Encounter /// </summary> /// <param name="game">The GameState</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if Dracula successfully plays Seduction</returns> private static bool DraculaIsPlayingSeduction(GameState game, DecisionMaker logic) { if (logic.ChooseToPlaySeduction(game)) { Console.WriteLine("Dracula is playing Seduction"); game.Dracula.DiscardEvent(Event.Seduction, game.EventDiscard); if (HunterPlayingGoodLuckToCancelDraculaEvent(game, Event.Seduction, Event.Seduction, logic) > 0) { Console.WriteLine("Seduction cancelled"); return false; } return true; } return false; }
/// <summary> /// Determines if Dracula is playing Trap against a Hunter at the start of a combat /// </summary> /// <param name="game">The GameState</param> /// <param name="huntersInvolved">The list of Hunters involved in the combat</param> /// <param name="opponent">The Opponent</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if Dracula successfully plays Trap</returns> private static bool DraculaIsPlayingTrap(GameState game, List<HunterPlayer> huntersInvolved, Opponent opponent, DecisionMaker logic) { if (logic.ChooseToPlayTrap(game, huntersInvolved, opponent)) { Console.WriteLine("Dracula is playing Trap"); game.Dracula.DiscardEvent(Event.Trap, game.EventDiscard); if (HunterPlayingGoodLuckToCancelDraculaEvent(game, Event.Trap, Event.Trap, logic) > 0) { Console.WriteLine("Trap cancelled"); return false; } return true; } return false; }
/// <summary> /// Determines if Dracula is playing Customs Search on a Hunter /// </summary> /// <param name="game">The GameState</param> /// <param name="hunterMoved">The Hunter who moved</param> /// <param name="origin">The original Location</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if Dracula successfully plays Customs Search</returns> private static bool DraculaIsPlayingCustomsSearch(GameState game, Hunter hunterMoved, Location origin, DecisionMaker logic) { if (logic.ChooseToPlayCustomsSearch(game, hunterMoved, origin)) { Console.WriteLine("Dracula is playing Customs Search"); game.Dracula.DiscardEvent(Event.CustomsSearch, game.EventDiscard); if (HunterPlayingGoodLuckToCancelDraculaEvent(game, Event.CustomsSearch, Event.CustomsSearch, logic) > 0) { Console.WriteLine("Customs Search cancelled"); return false; } return true; } return false; }
/// <summary> /// Checks to see if Dracula is playing False Tip-off when a Hunter attempts to catch a train by rolling the die /// </summary> /// <param name="game">The GameState</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if Dracula successfully plays False Tip-off</returns> private static bool DraculaIsPlayingFalseTipoffToDelayHunter(GameState game, DecisionMaker logic) { if (logic.ChooseToDelayHunterWithFalseTipoff(game)) { Console.WriteLine("Dracula is playing False Tip-off to delay the train"); game.Dracula.DiscardEvent(Event.FalseTipoff, game.EventDiscard); if (HunterPlayingGoodLuckToCancelDraculaEvent(game, Event.FalseTipoff, Event.FalseTipoff, logic) > 0 || HunterPlayingCharteredCarriageToCancelFalseTipOff(game, Event.FalseTipoff, Event.FalseTipoff, logic) > 0) { return false; } return true; } return false; }
/// <summary> /// Resolves an Encounter of New Vampire for a group of Hunters /// </summary> /// <param name="game">The GameState</param> /// <param name="huntersInvolved">A list of Hunters involved in the Encounter</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if the Hunters can continue resolving Encounters</returns> private static bool ResolveNewVampire(GameState game, List<Hunter> huntersInvolved, DecisionMaker logic, out bool discardNewVampire, out bool seductionPlayed) { seductionPlayed = false; switch (game.TimeOfDay) { case TimeOfDay.Dawn: case TimeOfDay.Noon: case TimeOfDay.Dusk: Console.WriteLine("New Vampire encountered during the day and disposed of"); discardNewVampire = true; return true; } if (DraculaIsPlayingSeduction(game, logic)) { seductionPlayed = true; discardNewVampire = false; foreach (var h in huntersInvolved) { Console.WriteLine("{0} is bitten!"); if (!HunterPlayingGreatStrengthToCancelBite(game, h, logic)) { game.Hunters[(int)h].AdjustBites(1); } } if (CheckForHunterDeath(game)) { return false; } return true; } Console.WriteLine("Roll a die and enter the result"); var dieRoll = 0; while (dieRoll == 0) { if (!(int.TryParse(Console.ReadLine(), out dieRoll) && dieRoll > 0 && dieRoll < 7)) { dieRoll = 0; } } switch (dieRoll) { case 1: case 2: case 3: Console.WriteLine("The Vampire attempts to bite you"); var groupHasHolyItem = false; foreach (var h in huntersInvolved) { Console.WriteLine("What Items does {0} have? 0= nothing, 1= Crucifix, 2= Heavenly Host", h.Name()); var holyItem = Item.None; var answer = -1; while (answer == -1) { if (int.TryParse(Console.ReadLine(), out answer)) { if (answer > -1 && answer < 3) { switch (answer) { case 0: holyItem = Item.None; break; case 1: holyItem = Item.Crucifix; break; case 2: holyItem = Item.HeavenlyHost; break; } } else { answer = -1; } } } if (holyItem != Item.None) { groupHasHolyItem = true; AddItemCardToDraculaKnownCardsIfNotAlreadyKnown(game, game.Hunters[(int)h], holyItem); break; } } if (groupHasHolyItem) { Console.WriteLine("Bite attempted negated by holy item"); discardNewVampire = true; return true; } discardNewVampire = true; foreach (var h in huntersInvolved) { Console.WriteLine("{0} is bitten!", h.Name()); if (!HunterPlayingGreatStrengthToCancelBite(game, h, logic)) { game.Hunters[(int)h].AdjustBites(1); } } if (CheckForHunterDeath(game)) { return false; } break; case 4: case 5: case 6: Console.WriteLine("The Vampire attempts to escape"); var groupHasSharpItem = false; foreach (var h in huntersInvolved) { Console.WriteLine("What Items does {0} have? 0= nothing, 1= Knife, 2= Stake", h.Name()); var sharpItem = Item.None; var answer = -1; while (answer == -1) { if (int.TryParse(Console.ReadLine(), out answer)) { if (answer > -1 && answer < 3) { switch (answer) { case 0: sharpItem = Item.None; break; case 1: sharpItem = Item.Knife; break; case 2: sharpItem = Item.Stake; break; } } else { answer = -1; } } } if (sharpItem != Item.None) { groupHasSharpItem = true; game.Hunters[(int)h].DiscardItem(game, sharpItem); break; } } if (groupHasSharpItem) { Console.WriteLine("Escape attempted negated by sharp weapon"); discardNewVampire = true; return true; } Console.WriteLine("The Vampire escapes and remains in the city"); discardNewVampire = false; return true; } discardNewVampire = true; return true; }
/// <summary> /// For spending a Resolve point by a Hunter /// </summary> /// <param name="game">The GameState</param> /// <param name="resolveName">A string to be converted to the ResolveAbility being used</param> /// <param name="hunterIndex">A string to be converted to the Hunter spending Resolve</param> /// <param name="logic">The artificial intelligence component</param> private static void SpendResolve(GameState game, string resolveName, string hunterIndex, DecisionMaker logic) { var hunterSpendingResolve = Hunter.Nobody; int index = -2; if (int.TryParse(hunterIndex, out index)) { hunterSpendingResolve = game.GetHunterFromInt(index); } var line = ""; while (hunterSpendingResolve == Hunter.Nobody && index != -1) { Console.WriteLine("Who is spending resolve? {0}= {1}, {2}= {3}, {4}= {5}, {6}= {7} (-1 to cancel)", (int)Hunter.LordGodalming, Hunter.LordGodalming.Name(), (int)Hunter.DrSeward, Hunter.DrSeward.Name(), (int)Hunter.VanHelsing, Hunter.VanHelsing.Name(), (int)Hunter.MinaHarker, Hunter.MinaHarker.Name()); line = Console.ReadLine(); if (int.TryParse(line, out index)) { if (index < -1 || index > 4) { index = -2; } if (index == -1) { Console.WriteLine("Cancelled"); return; } hunterSpendingResolve = game.GetHunterFromInt(index); Console.WriteLine(hunterSpendingResolve.Name()); } else { Console.WriteLine("I didn't understand that"); } } var ability = Enumerations.GetResolveAbilityFromString(resolveName); while (ability == ResolveAbility.None && line.ToLower() != "cancel") { Console.WriteLine("What resolve ability is {0} using?", hunterSpendingResolve.Name()); line = Console.ReadLine(); if (line.ToLower() == "cancel") { Console.WriteLine("Cancelled"); return; } ability = Enumerations.GetResolveAbilityFromString(line); } switch (ability) { case ResolveAbility.NewspaperReports: PlayNewsPaperReports(game, hunterSpendingResolve, logic); break; case ResolveAbility.InnerStrength: PlayInnerStrength(game, hunterSpendingResolve); break; case ResolveAbility.SenseOfEmergency: PlaySenseOfEmergency(game, hunterSpendingResolve, logic); break; } game.AdjustResolve(-1); }
/// <summary> /// Resolves the Telegraph Ahead Event /// </summary> /// <param name="game">The GameState</param> /// <param name="hunterPlayingEvent">The Hunter playing the Event</param> /// <param name="logic">The artificial intelligence component</param> private static void PlayTelegraphAhead(GameState game, Hunter hunterPlayingEvent, DecisionMaker logic) { foreach (var loc in game.Map.LocationsConnectedByRoadTo(game.Hunters[(int)hunterPlayingEvent].CurrentLocation)) { if (DraculaIsPlayingSensationalistPressToPreventRevealingLocation(game, loc, logic)) { Console.WriteLine("Dracula prevented a location from being revealed"); } else { int position = game.Dracula.RevealCardInTrailWithLocation(loc); if (position > -1) { Console.WriteLine("{0} revealed", loc.Name()); logic.EliminateTrailsThatDoNotContainLocationAtPosition(game, loc, position); } else { position = game.Dracula.RevealCardInCatacombsWithLocation(loc); if (position > -1) { Console.WriteLine("{0} revealed", loc.Name()); logic.EliminateTrailsThatContainLocation(game, loc); } else { logic.EliminateTrailsThatContainLocation(game, loc); } } } } }
/// <summary> /// Resolves the Vampire Lair Event card /// </summary> /// <param name="game">The GameState</param> /// <param name="hunterPlayingEvent">The Hunter playing the Event</param> /// <param name="logic">The artificial intelligence component</param> private static void PlayVampireLair(GameState game, Hunter hunterPlayingEvent, DecisionMaker logic) { if (game.Vampires < 1) { Console.WriteLine("No Vampires to battle"); return; } if (ResolveCombat(game, new List<HunterPlayer> { game.Hunters[(int)hunterPlayingEvent] }, Opponent.NewVampire, logic)) { game.AdjustVampires(-1); } }
/// <summary> /// Handles the Sense of Emergency card or Resolve ability /// </summary> /// <param name="game">The GameState</param> /// <param name="hunterPlayingEvent">The Hunter playing the Event</param> /// <param name="logic">The artificial intelligence component</param> private static void PlaySenseOfEmergency(GameState game, Hunter hunterPlayingEvent, DecisionMaker logic) { if (game.Hunters[(int)hunterPlayingEvent].Health <= 6 - game.Vampires) { Console.WriteLine("{0} does not have enough health", hunterPlayingEvent.Name()); return; } Console.WriteLine("{0} loses {1} health", hunterPlayingEvent.Name(), 6 - game.Vampires); game.Hunters[(int)hunterPlayingEvent].AdjustHealth(game.Vampires - 6); Console.WriteLine("Where is {0} moving?"); var destination = Location.Nowhere; while (destination == Location.Nowhere) { destination = Enumerations.GetLocationFromString(Console.ReadLine()); } HandleMoveOperation(game, ((int)hunterPlayingEvent).ToString(), destination.Name(), logic); }
/// <summary> /// Resolves the Stormy Seas Event /// </summary> /// <param name="game">The GameState</param> /// <param name="hunterPlayingEvent">The Hunter playing the Event</param> /// <param name="logic">The artificial intelligence component</param> private static void PlayStormySeas(GameState game, Hunter hunterPlayingEvent, DecisionMaker logic) { Console.WriteLine("Where is {0} playing Stormy Seas?", hunterPlayingEvent.Name()); var stormySeasLocation = Location.Nowhere; while (stormySeasLocation == Location.Nowhere || game.Map.TypeOfLocation(stormySeasLocation) != LocationType.Sea) { stormySeasLocation = Enumerations.GetLocationFromString(Console.ReadLine()); } game.StormySeasLocation = stormySeasLocation; game.StormySeasRounds = 2; if (stormySeasLocation == game.Dracula.CurrentLocation) { Console.WriteLine("Dracula was in {0}", stormySeasLocation.Name()); int position = game.Dracula.RevealCardInTrailWithLocation(stormySeasLocation); logic.EliminateTrailsThatDoNotContainLocationAtPosition(game, stormySeasLocation, position); var destination = logic.ChoosePortToGoToAfterStormySeas(game); if (destination == Location.Nowhere) { Console.WriteLine("Dracula cannot make a legal move"); game.Dracula.TakePunishmentForCheating(game); return; } int doubleBackSlot; var cardDroppedOffTrail = game.Dracula.MoveTo(destination, Power.None, out doubleBackSlot); logic.AddDisembarkedCardToAllPossibleTrails(game); if (doubleBackSlot > -1) { Console.WriteLine("Dracula Doubled Back to the location in slot {0}", doubleBackSlot + 1); } var cardsDroppedOffTrail = new List<DraculaCardSlot>(); if (cardDroppedOffTrail != null) { cardsDroppedOffTrail.Add(cardDroppedOffTrail); } if (DraculaIsPlayingSensationalistPressToPreventRevealingLocation(game, destination, logic)) { Console.WriteLine("Dracula prevented a location from being revealed"); } else { game.Dracula.RevealCardInTrailWithLocation(destination); logic.EliminateTrailsThatDoNotContainLocationAtPosition(game, destination, 0); } DealWithDroppedOffCardSlots(game, cardsDroppedOffTrail, logic); CheckForJonathanHarker(game, logic); } else { logic.EliminateTrailsThatContainLocation(game, stormySeasLocation); } }
/// <summary> /// Resolves the Night Visit Event /// </summary> /// <param name="game">The GameState</param> /// <param name="logic">The artificial intelligence component</param> private static void PlayNightVisit(GameState game, DecisionMaker logic) { Console.WriteLine("Dracula is playing Night Visit"); if (HunterPlayingGoodLuckToCancelDraculaEvent(game, Event.NightVisit, Event.NightVisit, logic) > 0) { Console.WriteLine("Night Visit cancelled"); return; } var bittenHunters = new List<HunterPlayer>(); foreach (var h in game.Hunters) { if (h != null && h.BiteCount > 0) { bittenHunters.Add(h); } } var victim = logic.ChooseNightVisitVictim(bittenHunters); Console.WriteLine("{0} is visited in the night and loses 2 health", victim.Hunter.Name()); victim.AdjustHealth(-2); CheckForHunterDeath(game); }
/// <summary> /// Resolves the Newspaper Reports Event or Resolve ability /// </summary> /// <param name="game">The GameState</param> /// <param name="hunterPlayingEvent">The Hunter playing the Event</param> /// <param name="logic">The artificial intelligence component</param> private static void PlayNewsPaperReports(GameState game, Hunter hunterPlayingEvent, DecisionMaker logic) { for (var i = 5; i > 0; i--) { if (game.Dracula.Trail[i] != null && game.Dracula.Trail[i].DraculaCards.First().Location != Location.Nowhere && game.Dracula.Trail[i].DraculaCards.First().Location != game.Dracula.CurrentLocation && !game.Dracula.Trail[i].DraculaCards.First().IsRevealed) { if (DraculaIsPlayingSensationalistPressToPreventRevealingLocation(game, game.Dracula.Trail[i].DraculaCards.First().Location, logic)) { Console.WriteLine("Dracula prevented a location from being revealed"); } else { game.Dracula.RevealCardAtPosition(i); logic.EliminateTrailsThatDoNotContainLocationAtPosition(game, game.Dracula.Trail[i].DraculaCards.First().Location, i); break; } } } }
/// <summary> /// Resolves the Money Trail Event /// </summary> /// <param name="game">The GameState</param> /// <param name="hunterPlayingEvent">The Hunter playing the Event</param> /// <param name="logic">The artificial intelligence component</param> private static void PlayMoneyTrail(GameState game, Hunter hunterPlayingEvent, DecisionMaker logic) { for (var i = 5; i > 0; i--) { if (game.Dracula.Trail[i] != null && game.Map.TypeOfLocation(game.Dracula.Trail[i].DraculaCards.First().Location) == LocationType.Sea) { if (DraculaIsPlayingSensationalistPressToPreventRevealingLocation(game, game.Dracula.Trail[i].DraculaCards.First().Location, logic)) { Console.WriteLine("Dracula prevented a location from being revealed"); } else { game.Dracula.RevealCardAtPosition(i); logic.EliminateTrailsThatDoNotContainLocationAtPosition(game, game.Dracula.Trail[i].DraculaCards.First().Location, i); } } } }
/// <summary> /// Handles cards dropped off the end of Dracula's Trails /// </summary> /// <param name="game">The GameState</param> /// <param name="cardsDroppedOffTrail">A List of cards that have dropped off the end of the Trail</param> /// <param name="logic">The artificial intelligence component</param> private static void DealWithDroppedOffCardSlots(GameState game, List<DraculaCardSlot> cardsDroppedOffTrail, DecisionMaker logic) { foreach (var cardDroppedOffTrail in cardsDroppedOffTrail) { if (cardDroppedOffTrail.DraculaCards.Count() > 1) { cardDroppedOffTrail.DraculaCards.Remove(cardDroppedOffTrail.DraculaCards[1]); } if (cardDroppedOffTrail.DraculaCards.First().Location == game.Dracula.LocationWhereHideWasUsed && game.Dracula.LocationWhereHideWasUsed != Location.Nowhere) { int position; var encountersToReturnToEncounterPool = game.Dracula.DiscardHide(out position); Console.WriteLine("The location where Dracula used Hide dropped off the trail, so the Hide card is also removed from the trail. It was in position {0}", position + 1); logic.EliminateTrailsThatDoNotContainHideAtPosition(game, position); foreach (var enc in encountersToReturnToEncounterPool) { enc.IsRevealed = false; game.EncounterPool.Add(enc); } } var index = logic.ChooseToPutDroppedOffCardInCatacombs(game, cardDroppedOffTrail); if (index > -1) { game.Dracula.Catacombs[index] = cardDroppedOffTrail; game.Dracula.PlaceEncounterTileOnCard( logic.ChooseEncounterTileToPlaceOnDraculaCardSlot(game, game.Dracula.Catacombs[index]), cardDroppedOffTrail); } else { cardDroppedOffTrail.DraculaCards.First().IsRevealed = false; while (cardDroppedOffTrail.EncounterTiles.Count() > 0) { cardDroppedOffTrail.EncounterTiles.First().IsRevealed = false; MatureEncounter(game, cardDroppedOffTrail.EncounterTiles.First(), logic); cardDroppedOffTrail.EncounterTiles.Remove(cardDroppedOffTrail.EncounterTiles.First()); } } } }
/// <summary> /// Resolves the Vampiric Influence Event card /// </summary> /// <param name="game">The GameState</param> /// <param name="logic">The artificial intelligence component</param> private static void PlayVampiricInfluence(GameState game, DecisionMaker logic) { Console.WriteLine("Dracula played Vampiric Influence"); var bittenHunters = new List<HunterPlayer>(); if (HunterPlayingGoodLuckToCancelDraculaEvent(game, Event.VampiricInfluence, Event.VampiricInfluence, logic) > 0) { Console.WriteLine("Vampiric Influence cancelled"); return; } foreach (var h in game.Hunters) { if (h != null && h.BiteCount > 0) { bittenHunters.Add(h); } } var victim = logic.ChooseVampiricInfluenceVictim(bittenHunters); Console.WriteLine( "Dracula is influencing {0}, who must show Dracula all of {1} cards and declare {1} next move", victim.Hunter.Name(), victim.Hunter == Hunter.MinaHarker ? "her" : "his"); DraculaLooksAtAllHuntersItems(game, victim); DraculaLooksAtAllHuntersEvents(game, victim); HunterDeclaresNextMove(game, victim); }
/// <summary> /// Resolves an encounter of a Minion With Knife And Rifle for a group of Hunters /// </summary> /// <param name="game">The GameState</param> /// <param name="huntersInvolved">A list of Hunters involved in the combat</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if the Hunters can continue resolving Encounters</returns> private static bool ResolveMinionWithKnifeAndRifle(GameState game, List<Hunter> huntersInvolved, DecisionMaker logic) { var huntersInCombat = new List<HunterPlayer>(); foreach (var h in huntersInvolved) { huntersInCombat.Add(game.Hunters[(int)h]); } var continueEncounters = ResolveCombat(game, huntersInCombat, Opponent.MinionWithKnifeAndRifle, logic); if (CheckForHunterDeath(game)) { return false; } if (continueEncounters && DraculaIsPlayingRelentlessMinion(game, huntersInvolved, Opponent.MinionWithKnifeAndRifle, logic)) { return ResolveMinionWithKnifeAndRifle(game, huntersInvolved, logic); } return continueEncounters; }
/// <summary> /// Resolves an Encounter of Ambush for a group of Hunters /// </summary> /// <param name="game">The GameState</param> /// <param name="huntersInvolved">A list of Hunters involved in the Encounter</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if the Hunters can continue resolving Encounters</returns> private static bool ResolveAmbush(GameState game, List<Hunter> huntersInvolved, DecisionMaker logic) { game.Dracula.DrawEncounter(game.EncounterPool); game.Dracula.DiscardEncounterTile(game, logic.ChooseEncounterTileToDiscardFromEncounterHand(game)); return true; }
/// <summary> /// Resolves an Encounter of Thief for a group of Hunters /// </summary> /// <param name="game">The GameState</param> /// <param name="huntersInvolved">A list of Hunters involved in the Encounter</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if the Hunters can continue resolving Encounters</returns> private static bool ResolveThief(GameState game, List<Hunter> huntersInvolved, DecisionMaker logic) { foreach (var h in huntersInvolved) { if (game.Hunters[(int)h].HasDogsFaceUp) { return true; } } foreach (var h in huntersInvolved) { var typeOfCardToDiscard = logic.ChooseToDiscardItemFromHunterInsteadOfEvent(game.Hunters[(int)h]); if (typeOfCardToDiscard != CardType.None) { Console.WriteLine("Dracula has decided to discard an {0} from {1}", typeOfCardToDiscard, h.Name()); } } Console.WriteLine("Use the standard discard command to tell me what was discarded"); return true; }
/// <summary> /// Resolves an Encounter of Assassin for a group of Hunters /// </summary> /// <param name="game">The GameState</param> /// <param name="huntersInvolved">A list of Hunters involved in the combat</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if the Hunters can continue resolving Encounters</returns> private static bool ResolveAssassin(GameState game, List<Hunter> huntersInvolved, DecisionMaker logic) { var huntersInCombat = new List<HunterPlayer>(); foreach (var h in huntersInvolved) { huntersInCombat.Add(game.Hunters[(int)h]); } var continueEncounters = ResolveCombat(game, huntersInCombat, Opponent.Assassin, logic); if (CheckForHunterDeath(game)) { return false; } return continueEncounters; }
/// <summary> /// Provides details about various aspects of the gamestate that are not otherwise displayed on the screen /// </summary> /// <param name="game">The GameState</param> private static void DisplayState(GameState game, string argument1, DecisionMaker logic) { Console.WriteLine("The state of the game:"); foreach (var h in game.Hunters) { if (h != null) { Console.WriteLine("{0} is in {1} with {2} Items and {3} Events, on {4} health with {5} bites{6}", h.Hunter.Name(), h.CurrentLocation.Name(), h.ItemCount, h.EventCount, h.Health, h.BiteCount, h.HasDogsFaceUp ? " and has Dogs face up" : ""); if (h.EncountersInFrontOfPlayer.Any()) { Console.Write("These Encounter tiles are in front of {0}: ", h.Hunter.Name()); foreach (EncounterTile enc in h.EncountersInFrontOfPlayer) { Console.Write("{0}, ", enc.Encounter.Name()); } Console.WriteLine(""); } if (h.ItemsKnownToDracula.Any() && argument1 == "debug") { Console.Write("These Items held by {0} are known to Dracula: ", h.Hunter.Name()); foreach (var i in h.ItemsKnownToDracula) { Console.Write("{0}, ", i.Item.Name()); } Console.WriteLine(""); } if (h.EventsKnownToDracula.Any() && argument1 == "debug") { Console.Write("These Events held by {0} are known to Dracula: ", h.Hunter.Name()); foreach (var e in h.EventsKnownToDracula) { Console.Write("{0}, ", e.Event.Name()); } Console.WriteLine(""); } } } if (argument1 == "debug") { Console.WriteLine("Dracula is in {0} with {1} blood and has {2} Events", game.Dracula.CurrentLocation.Name(), game.Dracula.Blood, game.Dracula.EventHand.Count()); Console.Write("Dracula is holding these Encounter tiles: "); foreach (var enc in game.Dracula.EncounterHand) { Console.Write("{0} ", enc.Encounter.Name()); } Console.WriteLine(""); if (game.Dracula.EventHand.Count() > 0) { Console.Write("Dracula is holding these Event cards: "); foreach (var e in game.Dracula.EventHand) { Console.Write("{0} ", e.Event.Name()); } } } Console.WriteLine(""); Console.WriteLine("These Items are in the discard:"); foreach (var i in game.ItemDiscard) { Console.WriteLine(i.Item.Name()); } Console.WriteLine("These Events are in the discard:"); foreach (var e in game.EventDiscard) { Console.WriteLine(e.Event.Name()); } if (argument1 == "debug") { Console.WriteLine("There are {0} possible configurations of Dracula's trail", logic.PossibilityTree.Count()); Console.WriteLine("Dracula could be in one of {0} possible locations", logic.NumberOfPossibleCurrentLocations); Console.WriteLine("Dracula's current strategy is {0}", logic.Strategy); } }
/// <summary> /// Resolves a combat between a group of Hunters and an Opponent /// </summary> /// <param name="game">The GameState</param> /// <param name="huntersInvolved">A list of HunterPlayers involved in the combat</param> /// <param name="opponent">The Opponent type</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if the Hunters can continue resolving Encounters</returns> private static bool ResolveCombat(GameState game, List<HunterPlayer> huntersInvolved, Opponent opponent, DecisionMaker logic) { var roundsWithoutEscaping = 0; var answer = -1; do { Console.WriteLine( "Is anyone playing an Event at the start of this combat? 0= Nobody, {0}= {1}, {2}= {3}, {4}= {5}, {6}= {7}", (int)Hunter.LordGodalming, Hunter.LordGodalming.Name(), (int)Hunter.DrSeward, Hunter.DrSeward.Name(), (int)Hunter.VanHelsing, Hunter.VanHelsing.Name(), (int)Hunter.MinaHarker, Hunter.MinaHarker.Name()); while (answer == -1) { if (int.TryParse(Console.ReadLine(), out answer)) { if (answer < 0 || answer > 4) { answer = -1; } } } if (answer > 0) { var line = ""; Console.WriteLine("What Event is {0} playing? (cancel to cancel)", ((Hunter)answer).Name()); var eventBeingPlayed = Event.None; while (eventBeingPlayed != Event.AdvancePlanning && eventBeingPlayed != Event.EscapeRoute && eventBeingPlayed != Event.HeroicLeap && line.ToLower() != "cancel") { line = Console.ReadLine(); eventBeingPlayed = Enumerations.GetEventFromString(line); } if (line.ToLower() == "cancel") { answer = -1; } else { switch (eventBeingPlayed) { case Event.AdvancePlanning: game.Hunters[answer].DiscardEvent(game, Event.AdvancePlanning); if (!DraculaIsPlayingDevilishPowerToCancelEvent(game, Event.AdvancePlanning, Event.AdvancePlanning, logic, game.Hunters[answer])) { Console.WriteLine("One participant of your choice has combat rolls at +1 for this combat"); CheckForCardsRevealedForBeingBitten(game); } else { Console.WriteLine("Advance Planning cancelled"); CheckForCardsRevealedForBeingBitten(game); } break; case Event.EscapeRoute: game.Hunters[answer].DiscardEvent(game, Event.EscapeRoute); if (!DraculaIsPlayingDevilishPowerToCancelEvent(game, Event.EscapeRoute, Event.EscapeRoute, logic, game.Hunters[answer])) { Console.WriteLine("Combat cancelled", ((Hunter)answer).Name()); CheckForCardsRevealedForBeingBitten(game); return false; } CheckForCardsRevealedForBeingBitten(game); Console.WriteLine("Escape Route cancelled"); break; case Event.HeroicLeap: game.Hunters[answer].DiscardEvent(game, Event.HeroicLeap); if (!DraculaIsPlayingDevilishPowerToCancelEvent(game, Event.HeroicLeap, Event.HeroicLeap, logic, game.Hunters[answer])) { Console.WriteLine("Roll a die and enter the result"); var dieRoll = 0; while (dieRoll == 0) { if (int.TryParse(Console.ReadLine(), out dieRoll)) { if (dieRoll < 1 || dieRoll > 7) { dieRoll = 0; } } } game.Hunters[answer].AdjustHealth(-dieRoll); game.Dracula.AdjustBlood(-dieRoll); CheckForHunterDeath(game); CheckForCardsRevealedForBeingBitten(game); return false; } Console.WriteLine("Heroic Leap cancelled"); break; CheckForCardsRevealedForBeingBitten(game); } } answer = -1; } } while (answer != 0); answer = -1; if (opponent == Opponent.Dracula || opponent == Opponent.NewVampire) { Console.WriteLine("Is anyone playing Garlic at the start of this combat? 0= Nobody, {0}{1}{2}{3}", huntersInvolved.Find(h => h.Hunter == Hunter.LordGodalming) == null ? "" : "1= Lord Godalming", huntersInvolved.Find(h => h.Hunter == Hunter.DrSeward) == null ? "" : "2= Dr. Seward", huntersInvolved.Find(h => h.Hunter == Hunter.VanHelsing) == null ? "" : "3= Van Helsing", huntersInvolved.Find(h => h.Hunter == Hunter.MinaHarker) == null ? "" : "4= Mina Harker"); while (answer == -1) { if (int.TryParse(Console.ReadLine(), out answer)) { if (answer < 0 || answer > 4) { answer = -1; } else if (answer != 0 && huntersInvolved.Find(h => (int)h.Hunter == answer) == null) { answer = -1; } } else { answer = -1; } } if (answer > 0) { game.Hunters[answer].DiscardItem(game, Item.Garlic); CheckForCardsRevealedForBeingBitten(game); roundsWithoutEscaping = 3; } } if (DraculaIsPlayingTrap(game, huntersInvolved, opponent, logic)) { Console.WriteLine("Dracula played Trap. All of his combat rolls are at +1 for this combat"); } var rageTarget = DraculaIsPlayingRageAgainstHunter(game, huntersInvolved, logic); if (rageTarget != Hunter.Nobody) { Console.WriteLine("Dracula played Rage against {0} and must reveal all Items", rageTarget.Name()); DraculaLooksAtAllHuntersItems(game, game.Hunters[(int)rageTarget]); var itemDiscarded = logic.ChooseItemToDiscardWithRage(game, rageTarget); game.Hunters[(int)rageTarget].DiscardItem(game, itemDiscarded); Console.WriteLine("Dracula discarded {0}", itemDiscarded.Name()); roundsWithoutEscaping = 3; } var basicHunterCombatCards = new List<ItemCard> { new ItemCard(Item.Punch), new ItemCard(Item.Dodge), new ItemCard(Item.Escape) }; var enemyCombatCards = new List<EnemyCombatCard>(); switch (opponent) { case Opponent.MinionWithKnife: enemyCombatCards.Add(EnemyCombatCard.Punch); enemyCombatCards.Add(EnemyCombatCard.Dodge); enemyCombatCards.Add(EnemyCombatCard.Knife); break; case Opponent.MinionWithKnifeAndPistol: enemyCombatCards.Add(EnemyCombatCard.Punch); enemyCombatCards.Add(EnemyCombatCard.Dodge); enemyCombatCards.Add(EnemyCombatCard.Knife); enemyCombatCards.Add(EnemyCombatCard.Pistol); break; case Opponent.MinionWithKnifeAndRifle: enemyCombatCards.Add(EnemyCombatCard.Punch); enemyCombatCards.Add(EnemyCombatCard.Dodge); enemyCombatCards.Add(EnemyCombatCard.Knife); enemyCombatCards.Add(EnemyCombatCard.Rifle); break; case Opponent.Assassin: enemyCombatCards.Add(EnemyCombatCard.Punch); enemyCombatCards.Add(EnemyCombatCard.Dodge); enemyCombatCards.Add(EnemyCombatCard.Knife); enemyCombatCards.Add(EnemyCombatCard.Pistol); enemyCombatCards.Add(EnemyCombatCard.Rifle); break; case Opponent.Dracula: enemyCombatCards.Add(EnemyCombatCard.Claws); enemyCombatCards.Add(EnemyCombatCard.Dodge); enemyCombatCards.Add(EnemyCombatCard.EscapeMan); switch (game.TimeOfDay) { case TimeOfDay.Twilight: case TimeOfDay.Midnight: case TimeOfDay.SmallHours: enemyCombatCards.Add(EnemyCombatCard.EscapeBat); enemyCombatCards.Add(EnemyCombatCard.EscapeMist); enemyCombatCards.Add(EnemyCombatCard.Fangs); enemyCombatCards.Add(EnemyCombatCard.Mesmerize); enemyCombatCards.Add(EnemyCombatCard.Strength); break; } break; case Opponent.NewVampire: enemyCombatCards.Add(EnemyCombatCard.Claws); enemyCombatCards.Add(EnemyCombatCard.Dodge); switch (game.TimeOfDay) { case TimeOfDay.Twilight: case TimeOfDay.Midnight: case TimeOfDay.SmallHours: enemyCombatCards.Add(EnemyCombatCard.Fangs); enemyCombatCards.Add(EnemyCombatCard.Mesmerize); enemyCombatCards.Add(EnemyCombatCard.Strength); break; } break; } var firstRound = true; var repelled = false; var continueCombat = true; var sisterAgathaInEffect = (opponent == Opponent.Dracula && game.HunterAlly != null && game.HunterAlly.Event == Event.SisterAgatha); var enemyCombatCardChosen = EnemyCombatCard.None; var enemyTarget = Hunter.Nobody; while (continueCombat) { foreach (var h in huntersInvolved) { var itemUsedByHunterLastRound = h.LastCombatCardChosen; do { Console.WriteLine("Which combat card is {0} using this round?", h.Hunter.Name()); h.LastCombatCardChosen = Enumerations.GetItemFromString(Console.ReadLine()); } while (h.LastCombatCardChosen == Item.None); if (basicHunterCombatCards.Find(card => card.Item == h.LastCombatCardChosen) == null && h.ItemsKnownToDracula.Find(item => item.Item == h.LastCombatCardChosen) == null) { var itemDraculaNowKnowsAbout = game.ItemDeck.Find(card => card.Item == h.LastCombatCardChosen); h.ItemsKnownToDracula.Add(itemDraculaNowKnowsAbout); game.ItemDeck.Remove(itemDraculaNowKnowsAbout); } else if (itemUsedByHunterLastRound == h.LastCombatCardChosen && basicHunterCombatCards.Find(card => card.Item == h.LastCombatCardChosen) == null) { var itemDraculaAlreadyKnewAbout = h.ItemsKnownToDracula.Find(card => card.Item == itemUsedByHunterLastRound); if (itemDraculaAlreadyKnewAbout != null) { h.ItemsKnownToDracula.Remove(itemDraculaAlreadyKnewAbout); } if (h.ItemsKnownToDracula.Find(card => card.Item == itemUsedByHunterLastRound) == null) { var itemDraculaNowKnowsAbout = game.ItemDeck.Find(card => card.Item == h.LastCombatCardChosen); h.ItemsKnownToDracula.Add(itemDraculaNowKnowsAbout); game.ItemDeck.Remove(itemDraculaNowKnowsAbout); } h.ItemsKnownToDracula.Add(itemDraculaAlreadyKnewAbout); } } enemyCombatCardChosen = logic.ChooseCombatCardAndTarget(game, huntersInvolved, enemyCombatCards, firstRound, out enemyTarget, enemyCombatCardChosen, repelled, sisterAgathaInEffect, roundsWithoutEscaping); roundsWithoutEscaping--; var bloodCost = false; if (sisterAgathaInEffect && (enemyCombatCardChosen == EnemyCombatCard.Fangs || enemyCombatCardChosen == EnemyCombatCard.EscapeBat || enemyCombatCardChosen == EnemyCombatCard.EscapeMan || enemyCombatCardChosen == EnemyCombatCard.EscapeMist)) { game.Dracula.AdjustBlood(-2); bloodCost = true; } Console.WriteLine("{0} used {1} against {2}{3}", opponent.Name(), enemyCombatCardChosen.Name(), enemyTarget.Name(), bloodCost ? " at a cost of 2 blood" : ""); var line = ""; var index = 0; do { Console.WriteLine("What was the outcome? 1= Continue 2= Repel 3= Item destroyed or Event discarded 4= End"); line = Console.ReadLine(); if (int.TryParse(line, out index)) { if (index < 1 || index > 4) { index = 0; } } } while (index == 0); switch (index) { case 1: break; case 2: repelled = true; break; case 3: HunterPlayer hunterToDiscardCard = null; if (huntersInvolved.Count == 1) { hunterToDiscardCard = huntersInvolved.First(); } else { var hunterIndex = 0; do { Console.Write("Whose card is being discarded? "); foreach (var h in huntersInvolved) { Console.Write("{0}= {1} ", (int)h.Hunter, h.Hunter.Name()); } line = Console.ReadLine(); if (int.TryParse(line, out hunterIndex)) { foreach (var h in huntersInvolved) { if ((int)h.Hunter == hunterIndex) { hunterToDiscardCard = h; break; } } } } while (hunterToDiscardCard == null); } var itemDestroyed = Item.None; var eventDiscarded = Event.None; while (itemDestroyed == Item.None && eventDiscarded == Event.None) { Console.WriteLine("What card was discarded?"); line = Console.ReadLine(); itemDestroyed = Enumerations.GetItemFromString(line); eventDiscarded = Enumerations.GetEventFromString(line); } if (itemDestroyed != Item.None) { hunterToDiscardCard.DiscardItem(game, itemDestroyed); } else if (eventDiscarded != Event.None) { hunterToDiscardCard.DiscardEvent(game, eventDiscarded); } break; case 4: continueCombat = false; break; } firstRound = false; } var health = -1; foreach (var h in huntersInvolved) { Console.WriteLine("How much health does {0} have now?", h.Hunter.Name()); do { if (int.TryParse(Console.ReadLine(), out health)) { health = Math.Max(0, Math.Min(h.MaxHealth, health)); Console.WriteLine(health); } } while (health == -1); h.AdjustHealth(health - h.Health); } if (opponent == Opponent.Dracula) { Console.WriteLine("How much blood does Dracula have now?"); do { if (int.TryParse(Console.ReadLine(), out health)) { health = Math.Max(0, Math.Min(15, health)); Console.WriteLine(health); } } while (health == -1); game.Dracula.AdjustBlood(health - game.Dracula.Blood); } Console.WriteLine("Did {0} win? (An end result is a no)", huntersInvolved.Count() > 1 ? "the Hunters" : huntersInvolved.First().Hunter.Name()); string input; do { input = Console.ReadLine(); } while (!"yes".StartsWith(input.ToLower()) && !"no".StartsWith(input.ToLower())); if ("yes".StartsWith(input.ToLower())) { if (opponent == Opponent.NewVampire) { game.AdjustVampires(-1); } Console.WriteLine("Don't forget to register any cards discarded, such as Great Strength used to prevent health loss, Events due to enemy Knife wounds, Items consumed, etc."); return true; } if (opponent == Opponent.Dracula) { switch (enemyCombatCardChosen) { case EnemyCombatCard.Mesmerize: Console.WriteLine("{0} is bitten and must discard all Items!", enemyTarget.Name()); if (!HunterPlayingGreatStrengthToCancelBite(game, enemyTarget, logic)) { game.Hunters[(int)enemyTarget].AdjustBites(1); } while (game.Hunters[(int)enemyTarget].ItemCount > 0) { var line = ""; var itemDiscarded = Item.None; do { Console.WriteLine("What is the name of the Item being discarded?"); line = Console.ReadLine(); itemDiscarded = Enumerations.GetItemFromString(line); } while (itemDiscarded == Item.None); game.Hunters[(int)enemyTarget].DiscardItem(game, itemDiscarded); } CheckForHunterDeath(game); break; case EnemyCombatCard.Fangs: Console.WriteLine("{0} is bitten!", enemyTarget.Name()); if (!HunterPlayingGreatStrengthToCancelBite(game, enemyTarget, logic)) { game.Hunters[(int)enemyTarget].AdjustBites(1); } CheckForHunterDeath(game); goto case EnemyCombatCard.EscapeBat; case EnemyCombatCard.EscapeBat: Console.WriteLine("Dracula escaped in the form of a bat"); Location destination = logic.ChooseEscapeAsBatDestination(game); game.Dracula.EscapeAsBat(game, destination); logic.AddEscapeAsBatCardToAllTrails(game); int position = -1; if (game.HuntersAt(destination).Any() || destination == Location.CastleDracula) { position = game.Dracula.RevealCardInTrailWithLocation(destination); logic.EliminateTrailsThatDoNotContainLocationAtPosition(game, destination, position); } else { logic.EliminateTrailsThatHaveHuntersAtPosition(game, game.Dracula.CurrentLocationPosition); } break; } } Console.WriteLine("Don't forget to register any cards discarded, such as Great Strength used to prevent health loss or Items due to enemy Knife wounds"); foreach (HunterPlayer h in huntersInvolved) { h.LastCombatCardChosen = Item.None; } return false; }
/// <summary> /// Determines if Dracula is playing Devilish Power to cancel an Event played by a Hunter /// </summary> /// <param name="game">The GameState</param> /// <param name="eventBeingPlayedNow">The Event being played now</param> /// <param name="eventInitiallyPlayed">The Event initially played at the beginning of this exchange</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if Dracula successfully plays Devilish Power</returns> private static bool DraculaIsPlayingDevilishPowerToCancelEvent(GameState game, Event eventBeingPlayedNow, Event eventInitiallyPlayed, DecisionMaker logic, HunterPlayer hunterPlayingEvent) { if (logic.ChooseToCancelEventWithDevilishPower(game, eventBeingPlayedNow, eventInitiallyPlayed, hunterPlayingEvent)) { Console.WriteLine("Dracula is playing Devilish Power to cancel {0}", eventBeingPlayedNow.Name()); game.Dracula.DiscardEvent(Event.DevilishPower, game.EventDiscard); if (HunterPlayingGoodLuckToCancelDraculaEvent(game, Event.DevilishPower, eventInitiallyPlayed, logic) > 0) { return false; } return true; } return false; }
/// <summary>Checks if the sixth card in Dracula's Trail should be revealed by Jonathan Harker</summary> /// <param name="game">The GameState</param> private static void CheckForJonathanHarker(GameState game, DecisionMaker logic) { if (game.HunterAlly != null && game.HunterAlly.Event == Event.JonathanHarker && game.Dracula.Trail[5] != null) { game.Dracula.RevealCardAtPosition(5); if (game.Dracula.Trail[5].DraculaCards.First().Location != Location.Nowhere) { logic.EliminateTrailsThatDoNotContainLocationAtPosition(game, game.Dracula.Trail[5].DraculaCards.First().Location, 5); } } }
/// <summary> /// Determines if Dracula is playing Rage against a Hunter at the start of a combat /// </summary> /// <param name="game">The GameState</param> /// <param name="huntersInvolved">The list of Hunters involved in the combat</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if Dracula successfully plays Rage</returns> private static Hunter DraculaIsPlayingRageAgainstHunter(GameState game, List<HunterPlayer> huntersInvolved, DecisionMaker logic) { var rageTarget = logic.ChooseToPlayRage(game, huntersInvolved); if (rageTarget != Hunter.Nobody) { Console.WriteLine("Dracula is playing Rage against {0}", rageTarget.Name()); game.Dracula.DiscardEvent(Event.Rage, game.EventDiscard); if (HunterPlayingGoodLuckToCancelDraculaEvent(game, Event.Rage, Event.Rage, logic) > 0) { Console.WriteLine("Rage cancelled"); return Hunter.Nobody; } return rageTarget; } return Hunter.Nobody; }
/// <summary> /// Resolves an Encounter of Desecrated Soil for a group of Hunters /// </summary> /// <param name="game">The GameState</param> /// <param name="huntersInvolved">A list of Hunters involved in the Encounter</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if the Hunters can continue resolving Encounters</returns> private static bool ResolveDesecratedSoil(GameState game, List<Hunter> huntersInvolved, DecisionMaker logic) { Console.WriteLine("Draw an Event card. If it is a Hunter card, name it, otherwise type \"take\""); var line = ""; var eventDrawn = Event.None; do { line = Console.ReadLine(); eventDrawn = Enumerations.GetEventFromString(line); } while (eventDrawn == Event.None && !"take".StartsWith(line.ToLower())); if ("take".StartsWith(line.ToLower())) { var eventPlayedByDracula = game.Dracula.TakeEvent(game.EventDeck, game.EventDiscard); PlayImmediatelyDraculaCard(game, eventPlayedByDracula, logic); if (game.Dracula.EventHand.Count() > game.Dracula.EventHandSize) { Console.WriteLine("Dracula disacarded {0}", game.Dracula.DiscardEvent(logic.ChooseEventToDiscard(game), game.EventDiscard).Name()); } } else { var eventCardDiscarded = game.EventDeck.Find(card => card.Event == eventDrawn); if (eventCardDiscarded != null) { Console.WriteLine("{0} discarded", eventDrawn); game.EventDeck.Remove(eventCardDiscarded); game.EventDiscard.Add(eventCardDiscarded); } } return true; }
/// <summary> /// Checks if Dracula is playing Sensationalist Press to prevent a Location card from being revealed /// </summary> /// <param name="game">The GameState</param> /// <param name="location">The Location being revealed</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if Dracula successfully plays Sensationalist Press</returns> private static bool DraculaIsPlayingSensationalistPressToPreventRevealingLocation(GameState game, Location location, DecisionMaker logic) { if (logic.ChooseToPlaySensationalistPress(game, location)) { Console.WriteLine("Dracula is playing Sensationalist Press"); game.Dracula.DiscardEvent(Event.SensationalistPress, game.EventDiscard); if (HunterPlayingGoodLuckToCancelDraculaEvent(game, Event.SensationalistPress, Event.SensationalistPress, logic) > 0) { Console.WriteLine("Sensationalist Press cancelled"); return false; } return true; } return false; }
/// <summary> /// Resolves an Encounter on a group of Hunters /// </summary> /// <param name="game">The GameState</param> /// <param name="encounterTileBeingResolved">The Encounter being resolved</param> /// <param name="trailIndex">The Index of the Trail slot (0-5), or Catacombs slot (6-8) where the Encounter is being resolved, or -1 if being resolved from Dracula's hand</param> /// <returns>True if the Hunters can continue resolving Encounters</returns> private static bool ResolveEncounterTile(GameState game, EncounterTile encounterTileBeingResolved, List<Hunter> huntersInvolved, DecisionMaker logic, int trailIndex) { Console.WriteLine("Resolving {0} with {1}{2}", encounterTileBeingResolved.Encounter.Name(), huntersInvolved.First().Name(), huntersInvolved.Count() > 1 ? " and his group" : ""); var continueEncounters = true; var discardEncounterTile = true; foreach (var h in huntersInvolved) { Console.WriteLine("Will {0} play Secret Weapon?", h.Name()); var line = ""; do { line = Console.ReadLine(); } while (!"yes".StartsWith(line.ToLower()) && !"no".StartsWith(line.ToLower())); if ("yes".StartsWith(line.ToLower())) { game.Hunters[(int)h].DiscardEvent(game, Event.SecretWeapon); if (DraculaIsPlayingDevilishPowerToCancelEvent(game, Event.SecretWeapon, Event.SecretWeapon, logic, game.Hunters[(int)h])) { Console.WriteLine("Secret Weapon cancelled"); } else { DiscardUnknownItemFromHunter(game, game.Hunters[(int)h]); Console.WriteLine("What is the name of the Item being retrieved from the discard pile?"); var itemRetrieved = Item.None; while (itemRetrieved == Item.None) { itemRetrieved = Enumerations.GetItemFromString(Console.ReadLine()); } var itemCardRetrieved = game.ItemDiscard.Find(card => card.Item == itemRetrieved); game.ItemDiscard.Remove(itemCardRetrieved); game.Hunters[(int)h].ItemsKnownToDracula.Add(itemCardRetrieved); game.Hunters[(int)h].DrawItemCard(); } } } foreach (var h in huntersInvolved) { Console.WriteLine("Will {0} play Forewarned?", h.Name()); var line = ""; do { line = Console.ReadLine(); } while (!"yes".StartsWith(line.ToLower()) && !"no".StartsWith(line.ToLower())); if ("yes".StartsWith(line.ToLower())) { game.Hunters[(int)h].DiscardEvent(game, Event.Forewarned); if (DraculaIsPlayingDevilishPowerToCancelEvent(game, Event.SecretWeapon, Event.SecretWeapon, logic, game.Hunters[(int)h])) { Console.WriteLine("Forewarned cancelled"); } else { Console.WriteLine("Encounter cancelled"); game.EncounterPool.Add(encounterTileBeingResolved); if (trailIndex > -1) { game.Dracula.Trail[trailIndex].EncounterTiles.Remove(encounterTileBeingResolved); } return true; } } } switch (encounterTileBeingResolved.Encounter) { case Encounter.Ambush: continueEncounters = ResolveAmbush(game, huntersInvolved, logic); break; case Encounter.Assassin: continueEncounters = ResolveAssassin(game, huntersInvolved, logic); break; case Encounter.Bats: discardEncounterTile = false; game.Hunters[(int)huntersInvolved.First()].EncountersInFrontOfPlayer.Add(encounterTileBeingResolved); if (trailIndex > -1) { game.Dracula.Trail[trailIndex].EncounterTiles.Remove(encounterTileBeingResolved); } else { game.Dracula.EncounterHand.Remove(encounterTileBeingResolved); } return false; case Encounter.DesecratedSoil: continueEncounters = ResolveDesecratedSoil(game, huntersInvolved, logic); break; case Encounter.Fog: discardEncounterTile = false; game.Hunters[(int)huntersInvolved.First()].EncountersInFrontOfPlayer.Add(encounterTileBeingResolved); if (trailIndex > -1) { game.Dracula.Trail[trailIndex].EncounterTiles.Remove(encounterTileBeingResolved); } else { game.Dracula.EncounterHand.Remove(encounterTileBeingResolved); } return false; case Encounter.MinionWithKnife: continueEncounters = ResolveMinionWithKnife(game, huntersInvolved, logic); break; case Encounter.MinionWithKnifeAndPistol: continueEncounters = ResolveMinionWithKnifeAndPistol(game, huntersInvolved, logic); break; case Encounter.MinionWithKnifeAndRifle: continueEncounters = ResolveMinionWithKnifeAndRifle(game, huntersInvolved, logic); break; case Encounter.Hoax: continueEncounters = ResolveHoax(game, huntersInvolved); break; case Encounter.Lightning: continueEncounters = ResolveLightning(game, huntersInvolved); break; case Encounter.Peasants: continueEncounters = ResolvePeasants(game, huntersInvolved); break; case Encounter.Plague: continueEncounters = ResolvePlague(game, huntersInvolved); break; case Encounter.Rats: continueEncounters = ResolveRats(game, huntersInvolved); break; case Encounter.Saboteur: continueEncounters = ResolveSaboteur(game, huntersInvolved); break; case Encounter.Spy: continueEncounters = ResolveSpy(game, huntersInvolved); break; case Encounter.Thief: continueEncounters = ResolveThief(game, huntersInvolved, logic); break; case Encounter.NewVampire: var seductionPlayed = false; continueEncounters = ResolveNewVampire(game, huntersInvolved, logic, out discardEncounterTile, out seductionPlayed); if (seductionPlayed) { game.Dracula.EncounterHand.Add(encounterTileBeingResolved); while (game.Dracula.EncounterHand.Count() > game.Dracula.EncounterHandSize) { game.Dracula.DiscardEncounterTile(game, logic.ChooseEncounterTileToDiscardFromEncounterHand(game)); } if (trailIndex > -1) { game.Dracula.Trail[trailIndex].EncounterTiles.Remove(encounterTileBeingResolved); } else { game.Dracula.EncounterHand.Remove(encounterTileBeingResolved); } } break; case Encounter.Wolves: continueEncounters = ResolveWolves(game, huntersInvolved); break; default: return false; } if (discardEncounterTile) { game.EncounterPool.Add(encounterTileBeingResolved); if (trailIndex > -1) { game.Dracula.Trail[trailIndex].EncounterTiles.Remove(encounterTileBeingResolved); } else { game.Dracula.EncounterHand.Remove(encounterTileBeingResolved); } } return continueEncounters; }
/// <summary> /// Determines if Dracula is playing Wild Horses at the start of a combat /// </summary> /// <param name="game">The GameState</param> /// <param name="logic">The artificial intelligence component</param> /// <returns>True if Dracula successfully plays Wild Horses</returns> private static bool DraculaIsPlayingWildHorses(GameState game, DecisionMaker logic) { if (logic.ChooseToPlayWildHorses(game)) { Console.WriteLine("Dracula is playing Wild Horses to control your movement"); game.Dracula.DiscardEvent(Event.WildHorses, game.EventDiscard); if (HunterPlayingGoodLuckToCancelDraculaEvent(game, Event.WildHorses, Event.WildHorses, logic) > 0) { Console.WriteLine("Wild Horses cancelled"); return false; } return true; } return false; }
/// <summary> /// Resolves the Hypnosis Event /// </summary> /// <param name="game">The GameState</param> /// <param name="hunterPlayingEvent">The Hunter playing the Event</param> /// <param name="logic">The artificial intelligence component</param> private static void PlayHypnosis(GameState game, Hunter hunterPlayingEvent, DecisionMaker logic) { Console.WriteLine("Roll a die and enter the result"); var dieRoll = 0; while (dieRoll == 0) { if (int.TryParse(Console.ReadLine(), out dieRoll)) { if (dieRoll < 1 || dieRoll > 7) { dieRoll = 0; } } } switch (dieRoll) { case 1: case 2: Console.WriteLine("No effect"); break; case 3: case 4: case 5: case 6: if (DraculaIsPlayingSensationalistPressToPreventRevealingLocation(game, game.Dracula.CurrentLocation, logic)) { Console.WriteLine("Dracula prevented a location from being revealed"); } else { game.Dracula.RevealCardInTrailWithLocation(game.Dracula.CurrentLocation); logic.EliminateTrailsThatDoNotContainLocationAtPosition(game, game.Dracula.CurrentLocation, game.Dracula.CurrentLocationPosition); } game.Dracula.RevealAllVampires(); var power = Power.None; var advanceMoveLocation = logic.ChooseDestinationAndPower(game, out power); if (advanceMoveLocation == Location.Nowhere && power == Power.None) { Console.WriteLine("Dracula will have no legal moves next turn"); } else { game.Dracula.AdvanceMoveLocation = advanceMoveLocation; game.Dracula.AdvanceMovePower = power; Console.WriteLine("Dracula's next move will be to {0}{1}", game.Dracula.AdvanceMoveLocation, power == Power.None ? "" : " using " + game.Dracula.AdvanceMovePower.Name()); } break; } }