public override int GetPoints(AgricolaPlayer player, out string title) { foreach (var option in options) { var count = player.GetResource(option.Resource); if (option.Resource == Resource.Vegetables || option.Resource == Resource.Grain) { count += player.Farmyard.PlantedResourceCount(option.Resource); } if (option.RequiredCount <= count) { title = option.RequiredCount + " " + option.Resource.ToString(); return(option.Points); } } title = null; return(0); }
public override bool CanExecute(AgricolaPlayer player, Data.GameActionData data) { if (!base.CanExecute(player, data)) { return(false); } var choiceData = (AnimalChoiceActionData)data; if (choiceData.Option == AnimalResource.Cattle && player.Food < 1) { return(false); } var animalData = new Dictionary <AnimalResource, int>(); animalData[choiceData.Option] = 1; return(ActionService.CanAssignAnimals(player, choiceData.AnimalData, animalData)); }
public static void Cook(AgricolaPlayer player, ImmutableList <GameEventTrigger> eventTriggers, ResourceConversionData[] data, List <GameActionNotice> resultingNotices) { var availableConversions = Curator.GetAnytimeResourceConversions(player); var trigger = new ResourceConversionTrigger(); foreach (var conversion in data) { var conversionDefinition = availableConversions.Where(x => x.Id == conversion.Id && x.InType == conversion.InType && x.InAmount == conversion.InAmount && x.OutType == conversion.OutType).OrderByDescending(a => a.OutAmount).FirstOrDefault(); if (!conversionDefinition.InType.IsAnimal()) { var inputCache = new ResourceCache(conversionDefinition.InType, -conversion.Count); var outputCache = new ResourceCache(conversionDefinition.OutType, (conversion.Count / conversionDefinition.InAmount) * conversionDefinition.OutAmount); // Deduct the cost player.AddResource(inputCache); if (!conversionDefinition.OutType.IsAnimal()) { // Add the converted resources player.AddResource(outputCache); } else { ((AgricolaGame)player.Game).AddInterrupt(new AssignAnimalsAction(player, (AnimalResource)conversionDefinition.OutType, conversionDefinition.OutAmount, resultingNotices)); } inputCache = new ResourceCache(inputCache.Type, inputCache.Count * -1); resultingNotices.Add(new GameActionNotice(player.Name, NoticeVerb.Converted.ToString(), new ConversionPredicate(inputCache, outputCache))); trigger.AddConvertedResources(ResourcesConvertedData.FromResourceConversion(conversionDefinition, conversion.Count / conversionDefinition.InAmount)); } } ProcessEventTrigger(player, trigger, resultingNotices); CheckTriggers(player, eventTriggers, resultingNotices); }
/// <summary> /// Ensures that the requested animal assignment data is valid. /// </summary> /// <param name="player"></param> /// <param name="data"></param> /// <param name="newAnimals"></param> /// <returns></returns> public static bool CanAssignAnimals(AgricolaPlayer player, AnimalCacheActionData data, AnimalManager manager, Dictionary <AnimalResource, int> newAnimals) { var requestedTotals = AnimalHousingData.GetTotals(data.Assignments); requestedTotals[AnimalResource.Sheep] += data.Free[AnimalResource.Sheep] + data.Cook[AnimalResource.Sheep]; requestedTotals[AnimalResource.Boar] += data.Free[AnimalResource.Boar] + data.Cook[AnimalResource.Boar]; requestedTotals[AnimalResource.Cattle] += data.Free[AnimalResource.Cattle] + data.Cook[AnimalResource.Cattle]; var currentSheep = player.Farmyard.AnimalCount(AnimalResource.Sheep); // If the incoming total of animals in all assignments is different then the currently // assigned total animals plus the new animals being taken from the cache return false. if (requestedTotals[AnimalResource.Sheep] != currentSheep + (newAnimals != null && newAnimals.ContainsKey(AnimalResource.Sheep) ? newAnimals[AnimalResource.Sheep] : 0) || requestedTotals[AnimalResource.Boar] != player.Farmyard.AnimalCount(AnimalResource.Boar) + (newAnimals != null && newAnimals.ContainsKey(AnimalResource.Boar) ? newAnimals[AnimalResource.Boar] : 0) || requestedTotals[AnimalResource.Cattle] != player.Farmyard.AnimalCount(AnimalResource.Cattle) + (newAnimals != null && newAnimals.ContainsKey(AnimalResource.Cattle) ? newAnimals[AnimalResource.Cattle] : 0)) { return(false); } if (!manager.AreAssignmentsValid(data.Assignments)) { return(false); } var cooking = false; foreach (var count in data.Cook.Values) { if (count > 0) { cooking = true; } } if (cooking && !Curator.CanCook(player)) { return(false); } return(true); }
public override GameAction OnExecute(AgricolaPlayer player, GameActionData data) { base.OnExecute(player, data); if (familyMode) { this.TakeCaches(player); } else { var improvementData = ((StartingPlayerActionData)data).ImprovementData; if (improvementData != null) { ActionService.BuyImprovement(player, improvementData, ResultingNotices); } } Game.StartingPlayer = player; this.ResultingNotices.Add(new GameActionNotice(player.Name, NoticeVerb.Starts.ToString())); return(this); }
/// <summary> /// Returns points if the card owner has the most occupations /// </summary> /// <param name="player"></param> /// <param name="title"></param> /// <returns></returns> public override int GetPoints(AgricolaPlayer player, out string title) { var players = ((AgricolaGame)player.Game).AgricolaPlayers; var mostPlayedOccupations = 0; foreach (var p in players) { var playedOccupations = Curator.GetOwnedOccupationCount(p); if (playedOccupations > mostPlayedOccupations) { mostPlayedOccupations = playedOccupations; } } title = "Most Occupations"; if (Curator.GetOwnedOccupationCount(player) == mostPlayedOccupations) { return(points); } return(0); }
/// <summary> /// Checks if a player has the ability to cook any goods /// </summary> /// <param name="player"></param> /// <param name="data"></param> /// <returns></returns> public static bool CanCook(AgricolaPlayer player, ResourceConversionData[] data) { var availableConversions = Curator.GetAnytimeResourceConversions(player); foreach (var conversion in data) { var conversionDefinition = availableConversions.FirstOrDefault(x => x.Id == conversion.Id && x.InType == conversion.InType && x.InAmount == conversion.InAmount && x.OutType == conversion.OutType); if (conversionDefinition == null) { return(false); } if (conversionDefinition.InLimit.HasValue && (conversionDefinition.InLimit.Value < conversion.Count / conversion.InAmount)) { return(false); } if (conversion.Count % conversionDefinition.InAmount != 0) { return(false); } if (Enum.IsDefined(typeof(AnimalResource), conversionDefinition.InType.ToString())) { var animalType = (AnimalResource)(Enum.Parse(typeof(AnimalResource), conversionDefinition.InType.ToString())); if (player.Farmyard.AnimalManager.GetAnimalCount(animalType) < conversion.Count) { return(false); } } else if (player.GetResource(conversionDefinition.InType) < conversion.Count) { return(false); } } return(true); }
public override int GetPoints(AgricolaPlayer player, out string title) { switch (houseType) { case HouseType.Wood: title = "Wood Hut"; break; case HouseType.Clay: title = "Clay Hut"; break; case HouseType.Stone: title = "Stone House"; break; default: title = ""; break; } return(player.Farmyard.HouseType == houseType ? points : 0); }
public override GameAction OnExecute(AgricolaPlayer player, Data.GameActionData data) { base.OnExecute(player, data); var occupationData = (OccupationActionData)data; if (occupationData.FamilyGrowth) { player.AddFamilyMember(); AddUser(player); // Add the baby to the action display ResultingNotices.Add(new GameActionNotice(player.Name, NoticeVerb.GrowFamily.ToString())); } else { var triggers = new List <GameEventTrigger>(); triggers.AddRange(eventTriggers); triggers.Add(new TakeOccupationActionTrigger()); ActionService.PlayOccupation(player, ImmutableList.Create <GameEventTrigger>(triggers.ToArray()), ResultingNotices, occupationData); } return(this); }
public override int GetPoints(AgricolaPlayer player, out string title) { title = "Most animals of each type:"; var sheep = player.Farmyard.AnimalManager.GetAnimalCount(AnimalResource.Sheep); var boar = player.Farmyard.AnimalManager.GetAnimalCount(AnimalResource.Boar); var cattle = player.Farmyard.AnimalManager.GetAnimalCount(AnimalResource.Cattle); foreach (var p in ((AgricolaGame)player.Game).AgricolaPlayers) { if (p.Farmyard.AnimalManager.GetAnimalCount(AnimalResource.Sheep) > sheep) { return(0); } if (p.Farmyard.AnimalManager.GetAnimalCount(AnimalResource.Boar) > boar) { return(0); } if (p.Farmyard.AnimalManager.GetAnimalCount(AnimalResource.Cattle) > cattle) { return(0); } } switch (player.Game.Players.Count()) { case 3: return(2); case 4: return(3); case 5: return(4); default: return(0); } }
public override GameAction OnExecute(AgricolaPlayer player, GameActionData data) { base.OnExecute(player, data); var resources = CacheResources.Values.ToList(); foreach (var cache in TakeResourceCaches) { resources.Add(cache); } ActionService.AssignCacheResources(player, eventTriggers, ResultingNotices, resources.ToArray()); foreach (var cache in resources) { if (CacheResources.ContainsKey(cache.Type)) { CacheResources[cache.Type] = new ResourceCache(cache.Type, 0); } } return(this); }
/// <summary> /// Assigns a single resource to a player and triggers /// events. /// </summary> /// <param name="player"></param> /// <param name="cache"></param> /// <param name="eventTriggers">Triggers attached to the calling actions.</param> /// <param name="resultingNotices"></param> /// <param name="partOfMultiCache"></param> public static void AssignCacheResource(AgricolaPlayer player, ImmutableList <GameEventTrigger> eventTriggers, List <GameActionNotice> resultingNotices, ResourceCache cache, bool partOfMultiCache = false) { if (cache.Type.IsAnimal()) { //player.Game.AddInterrupt(new AssignAnimalsAction(player, cache, resultingNotices)); } else { player.AddResource(cache.Type, cache.Count); resultingNotices.Add(new GameActionNotice(player.Name, NoticeVerb.Take.ToString(), new ResourceCache(cache.Type, cache.Count))); var resourceTrigger = new TakeCachedResourceTrigger(cache.Type); ProcessEventTrigger(player, resourceTrigger, resultingNotices); if (!partOfMultiCache) { var onlyResourceTrigger = new TakeSoleCachedResourceTrigger(cache.Type); ProcessEventTrigger(player, onlyResourceTrigger, resultingNotices); } CheckTriggers(player, eventTriggers, resultingNotices); } }
/// <summary> /// Assigns multiple resources to a player and triggers /// events. /// </summary> /// <param name="player"></param> /// <param name="caches"></param> /// <param name="eventTriggers">Triggers attached to the calling actions.</param> /// <param name="resultingNotices"></param> public static void AssignCacheResources(AgricolaPlayer player, ImmutableList <GameEventTrigger> eventTriggers, List <GameActionNotice> resultingNotices, ResourceCache[] caches) { var animals = new List <ResourceCache>(); foreach (var cache in caches) { if (cache.Type.IsAnimal()) { animals.Add(cache); } else { AssignCacheResource(player, null, resultingNotices, cache, true); } } if (animals.Count > 0) { ((AgricolaGame)player.Game).AddInterrupt(new AssignAnimalsAction(player, animals.ToArray(), resultingNotices)); } CheckTriggers(player, eventTriggers, resultingNotices); }
/// <summary> /// Executes the event. /// </summary> /// <param name="player">The player to execute the event for.</param> /// <param name="resultingNotices">Outgoing informational notices caused by this event.</param> public void Execute(AgricolaPlayer player, GameEventTrigger trigger, Card card, List <GameActionNotice> resultingNotices) { if (card != null) { int executionCount = 0; ImmutableDictionary <string, Object> metadata; if (player.TryGetCardMetadata(card, out metadata)) { if (metadata.ContainsKey(MetadataKeyExecutionCount)) { executionCount = (int)metadata[MetadataKeyExecutionCount]; } } else { metadata = ImmutableDictionary <string, Object> .Empty; } executionCount++; player.SetCardMetadata(card, metadata.SetItem(MetadataKeyExecutionCount, executionCount)); } OnExecute(player, trigger, card, resultingNotices); }
public override int GetPoints(AgricolaPlayer player, out string title) { var x = player.BeggingCards; if (x == 0) { title = ""; return(0); } if (x > 2) { x = 2; } title = "Discard " + x + " Begging Card"; if (x > 1) { title += "s"; } return(x * 3); }
public override GameAction OnExecute(AgricolaPlayer player, Data.GameActionData data) { base.OnExecute(player, data); ActionService.Renovate(player, ResultingNotices); switch (mode) { case RenovationActionMode.Fences: player.PayCosts(additionalCosts); ActionService.BuildFences(player, eventTriggers, ResultingNotices, ((RenovationActionData)data).FenceData, pastures.ToImmutableArray()); break; case RenovationActionMode.Improvement: var improvementData = ((RenovationActionData)data).ImprovementData; if (improvementData != null) { ActionService.BuyImprovement(player, ((RenovationActionData)data).ImprovementData, ResultingNotices); } break; } return(this); }
/// <summary> /// Checks if all prerequisites of the card are met /// </summary> /// <param name="player"></param> /// <returns></returns> public bool PrerequisitesMet(AgricolaPlayer player) { return(!Prerequisites.Any(x => !x.IsMet(player))); }
public override bool CanExecute(AgricolaPlayer player, GameActionData data) { if (data != null && data.GetType() == typeof(CacheExchangeData)) { var exchangeData = (CacheExchangeData)data; if (exchangeData.exchanges != null) { var ownedCardIds = player.OwnedCardIds; var requestedIds = exchangeData.exchanges.Where(x => x.Count > 0).Select(x => x.Id); var ownsAllCards = requestedIds.Intersect(ownedCardIds).Count() == requestedIds.Count(); if (!ownsAllCards) { return(false); } availableConversions = player.OwnedCards.Where(x => requestedIds.Contains(x.Id)).SelectMany(card => card.CacheExchanges); var total = new Dictionary <Resource, int>(); foreach (var exchange in exchangeData.exchanges) { if (exchange.Count > 0) { var conversionDefinition = availableConversions.FirstOrDefault(x => x.Id == exchange.Id && x.InType == exchange.InType && x.InAmount == exchange.InAmount && x.OutType == exchange.OutType); if (conversionDefinition == null) { return(false); } if (conversionDefinition.InLimit.HasValue && conversionDefinition.InLimit.Value < exchange.Count / exchange.InAmount) { return(false); } if (!total.ContainsKey(exchange.InType)) { total[exchange.InType] = 0; } total[exchange.InType] += exchange.InAmount; } } foreach (var kvp in total) { if (!this.CacheResources.ContainsKey(kvp.Key)) { return(false); } if (this.CacheResources[kvp.Key].Count < kvp.Value) { return(false); } } } } if (!base.CanExecute(player, data)) { return(false); } return(true); }
protected override void OnExecute(AgricolaPlayer player, GameEventTrigger trigger, Card card, List <GameActionNotice> resultingNotices) { return; }
public override bool Triggered(AgricolaPlayer resolvingPlayer, AgricolaPlayer triggeringPlayer, GameEventTrigger trigger) { return(base.Triggered(resolvingPlayer, triggeringPlayer, trigger) && this.Type == ((TakeSoleCachedResourceTrigger)trigger).Type); }
public void AddUser(AgricolaPlayer player) { this.Users.Add(player); }
public override GameAction OnExecute(AgricolaPlayer player, GameActionData data) { AddUser(player); player.UseFamilyMember(); return(this); }
public override bool CanExecute(AgricolaPlayer player, GameActionData data) { return(this.Users.Count == 0 && player.HasFamilyMemberAvailable()); }
public void TakeCaches(AgricolaPlayer player) { TakeCaches(player, null, null); }
public void TakeCaches(AgricolaPlayer player, Dictionary <Resource, int> leaveBehind, Dictionary <Resource, int> gained) { var taking = new Dictionary <Resource, int>(); foreach (var cache in CacheResources) { if (!taking.ContainsKey(cache.Value.Type)) { taking[cache.Value.Type] = cache.Value.Count; } else { taking[cache.Value.Type] += cache.Value.Count; } } if (leaveBehind != null) { foreach (var cache in leaveBehind) { if (taking.ContainsKey(cache.Key)) { taking[cache.Key] -= leaveBehind[cache.Key]; } } } var takingCaches = taking.Select(x => new ResourceCache(x.Key, x.Value)); if (eventTriggers != null) { foreach (var trigger in eventTriggers) { if (trigger.GetType() == typeof(TravelingPlayersActionTrigger)) { ((TravelingPlayersActionTrigger)trigger).FoodTaken = taking[Resource.Food]; } } } if (gained != null) { foreach (var kvp in gained) { if (!taking.ContainsKey(kvp.Key)) { taking[kvp.Key] = kvp.Value; } else { taking[kvp.Key] += kvp.Value; } } } if (takingCaches.Count() > 1) { ActionService.AssignCacheResources(player, eventTriggers, ResultingNotices, taking.Select(x => new ResourceCache(x.Key, x.Value)).ToArray()); foreach (var kvp in taking) { if (CacheResources.ContainsKey(kvp.Key)) { var cache = CacheResources[kvp.Key]; CacheResources[kvp.Key] = cache.updateCount(-kvp.Value); } } } else { var cache = CacheResources.Values.First(); if (cache.Type.IsAnimal()) { //player.Game.AddInterrupt(new AssignAnimalsAction(player, cache, ResultingNotices)); } else { ActionService.AssignCacheResource(player, eventTriggers, ResultingNotices, new ResourceCache(cache.Type, taking[cache.Type])); } CacheResources[cache.Type] = cache.updateCount(-taking[cache.Type]); } }
public BakeAction(AgricolaPlayer player, List <GameActionNotice> resultingNotices) : base(player, (int)InterruptActionId.Bake, resultingNotices, new BakeTrigger()) { }
protected override void OnExecute(AgricolaPlayer player, GameEventTrigger trigger, Card card, List <GameActionNotice> resultingNotices) { ((AgricolaGame)player.Game).AddInterrupt(new FencePastureAction(player, resultingNotices)); }
public override GameAction OnExecute(AgricolaPlayer player, Data.GameActionData data) { ActionService.BuildFences(player, eventTriggers, ResultingNotices, (BuildFencesActionData)data, pastures.ToImmutableArray()); return(this); }
public override bool CanExecute(AgricolaPlayer player, Data.GameActionData data) { ResourceCache[] costs; return(ActionService.CanBuildFences(player, Id, (BuildFencesActionData)data, out pastures, out costs)); }
public FencePastureAction(AgricolaPlayer player, List <GameActionNotice> resultingNotices) : base(player, (int)InterruptActionId.FencePasture, resultingNotices) { }