public override int CalculateDamage(SuperMetroidModel model, InGameState inGameState, int times = 1, bool usePreviousRoom = false)
{
int currentRegularEnergy = inGameState.GetCurrentAmount(Items.RechargeableResourceEnum.RegularEnergy);
// Don't take damage if we've already reached the threshold
return(Math.Max(0, currentRegularEnergy - Value));
}
public override ExecutionResult Execute(SuperMetroidModel model, InGameState inGameState, int times = 1, bool usePreviousRoom = false)
{
int currentAmmo = inGameState.GetCurrentAmount(AmmoType.GetConsumableResourceEnum());
int ammoCost = Math.Min(currentAmmo, Count);
if (inGameState.IsResourceAvailable(model, AmmoType.GetConsumableResourceEnum(), ammoCost))
{
var resultingState = inGameState.Clone();
resultingState.ApplyConsumeResource(model, AmmoType.GetConsumableResourceEnum(), ammoCost);
return(new ExecutionResult(resultingState));
}
else
{
return(null);
}
}
public ExecutionResult Execute(SuperMetroidModel model, InGameState inGameState, int times = 1, bool usePreviousRoom = false)
{
var requirementsResult = FarmCycle.RequirementExecution.Execute(model, inGameState, times: times, usePreviousRoom: usePreviousRoom);
// Can't even execute one cycle, so return a failure
if (requirementsResult == null)
{
return(null);
}
// Build a dictionary of resources that are spent while doing the execution of a cycle
ResourceCount resourceVariation = requirementsResult.ResultingState.GetResourceVariationWith(inGameState);
// Start with all consumable resources
IDictionary <ConsumableResourceEnum, int> costingResources = Enum.GetValues(typeof(ConsumableResourceEnum))
.Cast <ConsumableResourceEnum>()
// Invert the resource variation to convert it to a resource cost
.Select(resource => (resource: resource, cost: resourceVariation.GetAmount(resource) * -1))
// Keep only pairs where some of the resource has been spent
.Where(resourceCost => resourceCost.cost > 0)
// Finally, build a dictionary from the pairs
.ToDictionary(resourceCost => resourceCost.resource, resourceCost => resourceCost.cost);
// Identify all resources that can be refilled by this farm cycle
IEnumerable <ConsumableResourceEnum> farmableResources = ComputeFarmableResources(model, costingResources);
// Calculate the initial effective drop rates, taking into account currently full resources.
// However, resources that are full but not farmable here should not be taken into account.
IEnumerable <ConsumableResourceEnum> fullResources = inGameState.GetFullConsumableResources().Intersect(farmableResources).ToArray();
EnemyDrops initialEffectiveDropRates = FarmCycle.RoomEnemy.Enemy.GetEffectiveDropRates(model, fullResources);
// Build a dictionary containing the variation per cycle for each consmable resource
IDictionary <ConsumableResourceEnum, decimal> resourceVariationPerCycle = Enum.GetValues(typeof(ConsumableResourceEnum))
.Cast <ConsumableResourceEnum>()
.ToDictionary(resource => resource, resource => CalculateResourceVariationPerCycle(model, resource, initialEffectiveDropRates, costingResources));
// Identify resources that are creeping down as we farm
IEnumerable <ConsumableResourceEnum> initiallyUnstableResources = costingResources
.Where(pair => resourceVariationPerCycle[pair.Key] < 0)
.Select(pair => pair.Key)
.ToArray();
// If there's no resources we can farm, just return now
if (!farmableResources.Any())
{
// If any of the resources initially lose out per farm cycle, we're not even able to farm. Return a failure.
if (initiallyUnstableResources.Any())
{
return(null);
}
// Otherwise, we're able to farm but it doesn't do anything according to logical options
return(new ExecutionResult(inGameState.Clone()));
}
// If there's no resource that initially loses out, we're not concerned about losing any resources.
// We can refill all farmable resources and report a success
if (!initiallyUnstableResources.Any())
{
return(ExecuteRefill(model, inGameState, farmableResources));
}
// If we have resources that initially lose out, they must eventually turn farmable.
// Otherwise, we consider this a failure.
if (initiallyUnstableResources.Except(farmableResources).Any())
{
return(null);
}
// Now we know we have at least one resource that currently loses out per cycle, but can eventually recharge.
// Execute some farming to see if we can stabilize those resources before we run out.
IEnumerable <ConsumableResourceEnum> notFullFarmableResources = farmableResources.Except(fullResources).ToArray();
IDictionary <ConsumableResourceEnum, decimal> resourceCounts = Enum.GetValues(typeof(ConsumableResourceEnum))
.Cast <ConsumableResourceEnum>()
.ToDictionary(resource => resource, resource => (decimal)inGameState.GetCurrentAmount(resource));
EnemyDrops effectiveDropRates = initialEffectiveDropRates;
// Execute farm cycles until a resource runs out or all costing resources have stabilized
while (costingResources
.Where(pair => resourceVariationPerCycle[pair.Key] < 0)
.Any())
{
// Figure out how many cycles we need to execute in order to refill something farmable and stable
int cyclesToRefillSomething = notFullFarmableResources.Select(resource =>
decimal.ToInt32(decimal.Ceiling((inGameState.GetMaxAmount(resource) - resourceCounts[resource]) / resourceVariationPerCycle[resource])))
.Where(cycleCount => cycleCount > 0)
.Min();
// Apply to each farmable resource the resource variation from executing that many cycles.
// We don't care if it goes over maximum since we won't apply these to the in-game state
foreach (ConsumableResourceEnum resource in notFullFarmableResources)
{
resourceCounts[resource] += resourceVariationPerCycle[resource] * cyclesToRefillSomething;
}
// If an unstable resource has dipped below the cost per cycle, we can't go on. Return a failure.
if (costingResources.Where(costingResource => resourceCounts[costingResource.Key] < costingResource.Value).Any())
{
return(null);
}
// If we haven't run out of anything, prepare the next loop
// Update full resources
fullResources = resourceCounts
.Where(pair => pair.Value >= inGameState.GetMaxAmount(pair.Key))
.Select(pair => pair.Key)
.Intersect(farmableResources)
.ToArray();
// Update farmable resources by excluding newly-full resources
notFullFarmableResources = notFullFarmableResources.Except(fullResources).ToArray();
// Calculate a new effective drop rate using the new list of full resources
// If that new effective drop rate stabilizes all unstable resources, we'll make it out of the loop
effectiveDropRates = model.Rules.CalculateEffectiveDropRates(FarmCycle.RoomEnemy.Enemy.Drops, model.Rules.GetUnneededDrops(fullResources));
// Use the new effective drop rate to calculate the new resourceVariationPerCycle for resources we still care about
resourceVariationPerCycle = notFullFarmableResources
.ToDictionary(resource => resource, resource => CalculateResourceVariationPerCycle(model, resource, effectiveDropRates, costingResources));
}
// All resources are now stable. We already checked beforehand that all costing resources eventually become farmable,
// so we can just apply a refill for all farmable resources and return a success.
return(ExecuteRefill(model, inGameState, farmableResources));
}