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)
{
}
