[HarmonyPriority(Priority.First + 1)] //Just before ProducerFrameworkMod. Can't use HarmonyBefore attribute, that wasn't working for some reason
public static bool DayUpdate_Prefix(SObject __instance, GameLocation location)
{
if (__instance == null || string.IsNullOrEmpty(__instance.GetMassProducerKey()))
{
return(true);
}
MassProductionMachineDefinition mpm = ModEntry.GetMPMMachine(__instance.name, __instance.GetMassProducerKey());
if (mpm == null)
{
return(true);
}
if (__instance.bigCraftable.Value)
{
if (ProducerController.GetProducerConfig(__instance.Name) is ProducerConfig producerConfig)
{
if (producerConfig != null)
{
if (ProducerController.GetProducerItem(__instance.Name, null) is ProducerRule producerRule)
{
if (!producerConfig.CheckSeasonCondition() || !producerConfig.CheckLocationCondition(location))
{
ProducerRuleController.ClearProduction(__instance, location);
return(false);
}
else if (producerConfig.NoInputStartMode != null)
{
if (producerConfig.NoInputStartMode == NoInputStartMode.DayUpdate || producerConfig.NoInputStartMode == NoInputStartMode.Placement)
{
if (__instance.heldObject.Value == null)
{
try
{
Farmer who = Game1.getFarmer((long)__instance.owner);
PFMCompatability.ProduceOutput(producerRule, mpm.Settings, __instance,
(i, q) => who.hasItemInInventory(i, q), who, who.currentLocation, producerConfig);
}
catch (RestrictionException)
{
//Does not show the restriction error since the machine is auto-starting.
}
}
}
return(false);
}
}
}
}
}
return(true);
}
/// <summary>
/// Defines all mass production machines.
/// </summary>
/// <param name="settings">Specifies the kinds of machines being set up.</param>
/// <returns>All mass production machine definitions.</returns>
public static List <MassProductionMachineDefinition> Setup(Dictionary <string, MPMSettings> settings)
{
List <MassProductionMachineDefinition> mpms = new List <MassProductionMachineDefinition>();
//PFM integration
List <ProducerRule> allProducerRules = ProducerController.GetProducerRules();
List <string> baseProducers = new List <string>();
foreach (ProducerRule rule in allProducerRules)
{
if (ProducerController.GetProducerConfig(rule.ProducerName) != null && !baseProducers.Contains(rule.ProducerName))
{
baseProducers.Add(rule.ProducerName);
}
}
foreach (string baseProducerName in baseProducers)
{
ProducerConfig config = ProducerController.GetProducerConfig(baseProducerName);
foreach (MPMSettings setting in settings.Values)
{
if (config == null ||
(config.NoInputStartMode.HasValue && setting.InputRequirementEnum == InputRequirement.InputRequired) ||
(!config.NoInputStartMode.HasValue && setting.InputRequirementEnum == InputRequirement.NoInputsOnly))
{
continue;
}
mpms.Add(new MassProductionMachineDefinition(baseProducerName, setting));
}
}
//Other vanilla machines
foreach (string vanillaMachineName in StaticValues.SUPPORTED_VANILLA_MACHINES.Keys)
{
if (!baseProducers.Contains(vanillaMachineName))
{
InputRequirement inputRequirement = StaticValues.SUPPORTED_VANILLA_MACHINES[vanillaMachineName];
foreach (MPMSettings setting in settings.Values)
{
if (setting.InputRequirementEnum == inputRequirement || setting.InputRequirementEnum == InputRequirement.NoRequirements)
{
mpms.Add(new MassProductionMachineDefinition(vanillaMachineName, setting));
}
}
}
}
return(mpms);
}
/// <summary>
/// Overrides the base Automate machine factory's return value with one from this mod if that machine needs special support to
/// make use of the mass production upgrades. Also replicated PFMAutomate's functionality.
/// </summary>
/// <param name="__result"></param>
/// <param name="obj"></param>
public static void GetFor(ref object __result, SObject obj)
{
if (__result != null && __result is IMachine machine)
{
string machineFullName = __result.GetType().FullName;
if (VanillaOverrides.VanillaOverrideList.AUTOMATE_OVERRIDES.ContainsKey(machineFullName) ||
PFM_SUPPORTED_VANILLA_MACHINES.Contains(machineFullName) && (ProducerController.HasProducerRule(obj.Name) || ProducerController.GetProducerConfig(obj.Name) != null))
{
__result = new VanillaAutomatedOverride((IMachine)__result);
}
}
}
static void Main()
{
IEventConduit eventConduit = new DefaultEventConduit();
eventConduit.Start();
ProducerController producerController = new ProducerController(eventConduit);
producerController.Start();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
eventConduit.Stop();
producerController.Stop();
}
/// <summary>
/// Gets the current configuration of the machine.
/// </summary>
/// <param name="mpm"></param>
/// <returns></returns>
private ProducerConfig GetCurrentConfig(out MassProductionMachineDefinition mpm)
{
mpm = null;
ProducerConfig producerConfig;
if (IsMassProducer)
{
mpm = ModEntry.GetMPMMachine(Machine.name, Machine.GetMassProducerKey());
producerConfig = ProducerController.GetProducerConfig(mpm.BaseProducerName);
}
else
{
producerConfig = ProducerController.GetProducerConfig(Machine.name);
}
return(producerConfig);
}
/// <summary>
/// Adapted from https://github.com/Digus/StardewValleyMods/blob/master/PFMAutomate/Automate/CustomProducerMachine.cs
/// </summary>
/// <param name="item"></param>
internal void Reset(Item item)
{
PFMCompatability.ClearProduction(Machine, Location);
MassProductionMachineDefinition mpm = null;
ProducerConfig producerConfig;
if (IsMassProducer)
{
mpm = ModEntry.GetMPMMachine(Machine.name, Machine.GetMassProducerKey());
producerConfig = ProducerController.GetProducerConfig(mpm.BaseProducerName);
}
else
{
producerConfig = ProducerController.GetProducerConfig(Machine.name);
}
if (producerConfig == null)
{
return;
}
else if (producerConfig.NoInputStartMode != null || producerConfig.IncrementStatsOnOutput.Count > 0)
{
producerConfig.IncrementStats(item);
if (producerConfig.NoInputStartMode == NoInputStartMode.Placement)
{
if (ProducerController.GetProducerItem(Machine.Name, null) is ProducerRule producerRule)
{
try
{
if (producerConfig.CheckLocationCondition(Location) && producerConfig.CheckSeasonCondition())
{
if (mpm != null)
{
PFMCompatability.ProduceOutput(producerRule, mpm.Settings, Machine, (i, q) => true, null, Location, producerConfig);
}
else
{
ProducerRuleController.ProduceOutput(producerRule, Machine, (i, q) => true, null, Location, producerConfig);
}
}
}
catch (RestrictionException) { /*No action needed*/ }
}
}
}
}
/// <summary>
/// Adapted from https://github.com/Digus/StardewValleyMods/blob/master/ProducerFrameworkMod/ProducerRuleController.cs
/// </summary>
/// <param name="producer"></param>
/// <param name="location"></param>
/// <param name="who"></param>
public static void PrepareOutput(SObject producer, GameLocation location, Farmer who)
{
if (string.IsNullOrEmpty(producer.GetMassProducerKey()))
{
return;
}
MassProductionMachineDefinition mpm = ModEntry.GetMPMMachine(producer.name, producer.GetMassProducerKey());
if (mpm == null)
{
return;
}
foreach (ProducerRule producerRule in ProducerController.GetProducerRules(mpm.BaseProducerName))
{
if (producerRule.LookForInputWhenReady is InputSearchConfig inputSearchConfig)
{
if (producerRule.OutputConfigs.Find(o => o.OutputIndex == producer.heldObject.Value.ParentSheetIndex) is OutputConfig outputConfig)
{
SObject input = SearchInput(location, producer.tileLocation, inputSearchConfig);
List <InputInfo> inputInfo = InputInfo.ConvertPFMInputs(producerRule, input);
SObject output = OutputConfigController.CreateOutput(outputConfig, input, ProducerRuleController.GetRandomForProducing(producer.tileLocation));
output.Stack = mpm.Settings.CalculateOutputProduced(output.stack, inputInfo.ToArray());
if (mpm.Settings.Quality.HasValue)
{
if (mpm.Settings.Quality == QualitySetting.KeepInput)
{
output.Quality = input.Quality;
}
else
{
output.Quality = mpm.Settings.GetOutputQuality();
}
}
producer.heldObject.Value = output;
OutputConfigController.LoadOutputName(outputConfig, producer.heldObject.Value, input, who);
break;
}
}
}
}
public bool SetInput(IStorage input)
{
foreach (ITrackedStack trackedStack in input.GetItems())
{
if (trackedStack.Sample is SObject objectInput &&
!objectInput.bigCraftable.Value &&
ProducerController.GetProducerItem(_machine.Name, objectInput) is ProducerRule producerRule &&
!ProducerRuleController.IsInputExcluded(producerRule, objectInput))
{
if (input.TryGetIngredient(objectInput.ParentSheetIndex, producerRule.InputStack, out IConsumable inputConsumable))
{
objectInput = inputConsumable.Sample as SObject;
List <IConsumable> requiredFuels = GetRequiredFuels(producerRule, input);
if (requiredFuels != null)
{
Random random = ProducerRuleController.GetRandomForProducing(_machine.TileLocation);
OutputConfig outputConfig = OutputConfigController.ChooseOutput(producerRule.OutputConfigs, random);
SObject output = OutputConfigController.CreateOutput(outputConfig, objectInput, random);
_machine.heldObject.Value = output;
OutputConfigController.LoadOutputName(outputConfig, output, objectInput);
_machine.MinutesUntilReady = producerRule.MinutesUntilReady;
if (ProducerController.GetProducerConfig(_machine.Name) is ProducerConfig producerConfig)
{
_machine.showNextIndex.Value = producerConfig.AlternateFrameProducing;
}
_machine.initializeLightSource(_machine.TileLocation, false);
producerRule.IncrementStatsOnInput.ForEach(s => StatsController.IncrementStardewStats(s, producerRule.InputStack));
inputConsumable.Take();
requiredFuels.ForEach(f => f.Reduce());
return(true);
}
}
}
}
return(false);
}
public bool SetInput(IStorage input)
{
foreach (ITrackedStack trackedStack in input.GetItems())
{
if (trackedStack.Sample is SObject objectInput &&
!objectInput.bigCraftable.Value &&
ProducerController.GetProducerItem(_machine.Name, objectInput) is ProducerRule producerRule &&
!ProducerRuleController.IsInputExcluded(producerRule, objectInput))
{
ProducerConfig producerConfig = ProducerController.GetProducerConfig(_machine.Name);
if (producerConfig == null || (producerConfig.CheckLocationCondition(Location) && producerConfig.CheckSeasonCondition()))
{
if (input.TryGetIngredient(objectInput.ParentSheetIndex, producerRule.InputStack,
out IConsumable inputConsumable))
{
objectInput = inputConsumable.Sample as SObject;
List <IConsumable> requiredFuels = GetRequiredFuels(producerRule, input);
if (requiredFuels != null)
{
try
{
OutputConfig outputConfig = ProducerRuleController.ProduceOutput(producerRule, _machine,
(i, q) => input.TryGetIngredient(i, q, out IConsumable fuel), null, Location,
producerConfig, objectInput, noSoundAndAnimation: true);
if (outputConfig != null)
{
inputConsumable.Take();
requiredFuels.ForEach(f => f.Reduce());
List <IConsumable> outputRequiredFuels = GetRequiredFuels(outputConfig, input);
outputRequiredFuels.ForEach(f => f.Reduce());
return(true);
}
}
catch (RestrictionException) { /* No action needed */ }
}
}
}
}
}
return(false);
}
public void ProducerRequestTest()
{
//ARRANGE
var producers = new List <Producer>();
//ACT
producers = (List <Producer>)ProducerController.GetProducers();
//ASSERT
Assert.IsNotNull(producers);
Assert.IsTrue(producers.Count > 0);
//OUTPUT
foreach (Producer producer in producers)
{
Console.WriteLine("Producer: " + producer.Name);
}
Console.WriteLine("Producer Count: " + producers.Count);
}
public ProducerControllerTests()
{
mediator = A.Fake<IMediator>();
A.CallTo(() => mediator.SendAsync(A<GetCountries>._)).Returns(new List<CountryData>
{
new CountryData
{
Id = new Guid("4345FB05-F7DF-4E16-939C-C09FCA5C7D7B"),
Name = "United Kingdom"
},
new CountryData
{
Id = new Guid("29B0D09E-BA77-49FB-AF95-4171408C07C9"),
Name = "Germany"
}
});
A.CallTo(() => mediator.SendAsync(A<GetProducerForNotification>._)).Returns(CreateProducer(producerId));
producerController = new ProducerController(mediator, new AddAddressBookEntryMap());
}
public void ProducerEdiblesTest()
{
//ARRANGE
var edibles = new List <Edible>();
//ACT
edibles = (List <Edible>)ProducerController.GetProducerEdibles("0000000000L6M7E0000000000");
//ASSERT
foreach (Edible edible in edibles)
{
Assert.IsNotNull(edible);
Assert.IsTrue(edible.IsValid());
}
//OUTPUT
foreach (Edible edible in edibles)
{
Console.WriteLine("Edible: " + edible.Name);
Console.WriteLine("-----------------------");
}
}
public void ProducerExtractsTest()
{
//ARRANGE
var extracts = new List <Extract>();
//ACT
extracts = (List <Extract>)ProducerController.GetProducerExtracts("0000000000VU7TG0000000000");
//ASSERT
foreach (Extract extract in extracts)
{
Assert.IsNotNull(extract);
Assert.IsTrue(extract.IsValid());
}
//OUTPUT
foreach (Extract extract in extracts)
{
Console.WriteLine("Extract: " + extract.Name);
Console.WriteLine("-----------------------");
}
}
public ProducerControllerTests()
{
mediator = A.Fake <IMediator>();
this.auditService = A.Fake <IAuditService>();
A.CallTo(() => mediator.SendAsync(A <GetCountries> ._)).Returns(new List <CountryData>
{
new CountryData
{
Id = new Guid("4345FB05-F7DF-4E16-939C-C09FCA5C7D7B"),
Name = "United Kingdom"
},
new CountryData
{
Id = new Guid("29B0D09E-BA77-49FB-AF95-4171408C07C9"),
Name = "Germany"
}
});
A.CallTo(() => mediator.SendAsync(A <GetProducerForNotification> ._)).Returns(CreateProducer(producerId));
producerController = new ProducerController(mediator, new AddAddressBookEntryMap(), this.auditService);
A.CallTo(() => auditService.AddAuditEntry(this.mediator, notificationId, "user", NotificationAuditType.Added, NotificationAuditScreenType.Producer));
}
public void ProducerProductsTest()
{
//ARRANGE
var products = new List <Product>();
//ACT
products = (List <Product>)ProducerController.GetProducerProducts("0000000000N4E9N0000000000");
//ASSERT
foreach (Product product in products)
{
Assert.IsNotNull(product);
Assert.IsTrue(product.IsValid());
}
//OUTPUT
foreach (Product product in products)
{
Console.WriteLine("Product: " + product.Name);
Console.WriteLine("-----------------------");
}
}
public MachineState GetState()
{
if (_machine.heldObject.Value != null && _machine.minutesUntilReady <= 0 && _machine.readyForHarvest.Value)
{
return(MachineState.Done);
}
if (ProducerController.GetProducerConfig(_machine.Name) is ProducerConfig producerConfig)
{
if (!producerConfig.CheckWeatherCondition() || !producerConfig.CheckSeasonCondition() || !producerConfig.CheckLocationCondition(Location) || !producerConfig.CheckCurrentTimeCondition())
{
return(MachineState.Disabled);
}
if (producerConfig.NoInputStartMode != null)
{
//A no input machine is considered processing even while empty.
return(MachineState.Processing);
}
}
if (_machine.heldObject.Value == null)
{
return(MachineState.Empty);
}
return(MachineState.Processing);
}
[HarmonyPriority(801)] //Just before ProducerFrameworkMod. Can't use HarmonyBefore attribute, that wasn't working for some reason
internal static bool PerformObjectDropInAction(SObject __instance, Item dropInItem, bool probe, Farmer who, ref bool __result)
{
if (__instance.isTemporarilyInvisible || !(dropInItem is SObject))
{
return(false);
}
SObject input = dropInItem as SObject;
bool failLocationCondition = false;
bool failSeasonCondition = false;
MPMSettings upgradeSettings = ModEntry.GetSettingsFromItem(input.name);
if (upgradeSettings != null)
{
if (!probe)
{
//Change the machine's mass producer settings
MassProductionMachineDefinition mpm = ModEntry.GetMPMMachine(__instance.name, upgradeSettings.Key);
if (mpm == null)
{
Game1.showRedMessage("This cannot take that upgrade.");
}
else
{
string oldProducerKey = __instance.GetMassProducerKey();
if (!string.IsNullOrEmpty(oldProducerKey))
{
string upgradeItemName = ModEntry.MPMSettings[oldProducerKey].UpgradeObject;
JsonAssets.Api jsonAssets = ModEntry.Instance.Helper.ModRegistry.GetApi("spacechase0.JsonAssets") as JsonAssets.Api;
int upgradeItemId = jsonAssets.GetObjectId(upgradeItemName);
Game1.createItemDebris(new SObject(upgradeItemId, 1), __instance.TileLocation * Game1.tileSize, 0, who.currentLocation);
}
__instance.SetMassProducerKey(upgradeSettings.Key);
input.Stack -= 1;
__result = input.Stack <= 0;
return(false);
}
}
}
else
{
//Check if this is a valid input for the machine's use
if (string.IsNullOrEmpty(__instance.GetMassProducerKey()))
{
return(true);
}
if (__instance.heldObject.Value != null && !__instance.name.Equals("Crystalarium") || input.bigCraftable.Value)
{
return(true);
}
MassProductionMachineDefinition mpm = ModEntry.GetMPMMachine(__instance.name, __instance.GetMassProducerKey());
if (mpm == null)
{
return(true);
}
if (StaticValues.SUPPORTED_VANILLA_MACHINES.ContainsKey(__instance.name))
{
IVanillaOverride vanillaOverride = VanillaOverrideList.GetFor(__instance.name);
if (vanillaOverride != null)
{
bool overrideResult = vanillaOverride.Manual_PerformObjectDropInAction(__instance, input, probe, who, mpm);
//End early if a result has been found
if (overrideResult)
{
__result = input.Stack <= 0;
return(true);
}
}
}
ProducerConfig baseConfig = mpm.GetBaseProducerConfig();
GameLocation location = who.currentLocation;
if (baseConfig != null)
{
//TOREVIEW: maybe have machines that can break these conditions?
if (!baseConfig.CheckLocationCondition(location))
{
failLocationCondition = true;
}
if (!baseConfig.CheckSeasonCondition())
{
failSeasonCondition = true;
}
if (baseConfig.NoInputStartMode != null)
{
return(true);
}
}
if (ProducerController.GetProducerItem(__instance.name, input) is ProducerRule producerRule)
{
if (PFMCompatability.IsInputExcluded(producerRule, mpm, input))
{
return(true);
}
if (__instance.bigCraftable.Value && !probe && __instance.heldObject.Value == null)
{
__instance.scale.X = 5f;
}
try
{
if (failLocationCondition)
{
throw new RestrictionException("Machine can't be used in this location.");
}
if (failSeasonCondition)
{
throw new RestrictionException("Machine can't be used in this season.");
}
List <InputInfo> inputAndFuelInfo = InputInfo.ConvertPFMInputs(producerRule, input);
PFMCompatability.ValidateIfInputsLessThanRequired(producerRule, mpm.Settings, inputAndFuelInfo, who);
Dictionary <int, int> fuelQuantities = new Dictionary <int, int>();
foreach (InputInfo inputInfo in inputAndFuelInfo)
{
if (inputInfo.IsFuel)
{
fuelQuantities.Add(inputInfo.ID, mpm.Settings.CalculateInputRequired(inputInfo));
}
}
Func <int, int, bool> fuelSearch = (i, q) => who.hasItemInInventory(i, fuelQuantities[i]);
OutputConfig outputConfig = PFMCompatability.ProduceOutput(producerRule, mpm.Settings, __instance,
fuelSearch, who, location, baseConfig, input, mpm.Settings.CalculateInputRequired(inputAndFuelInfo.First()), probe,
inputInfo: inputAndFuelInfo);
if (outputConfig != null)
{
if (!probe)
{
foreach (InputInfo inputInfo in inputAndFuelInfo)
{
if (inputInfo.IsFuel)
{
RemoveItemsFromInventory(who, inputInfo.ID, mpm.Settings.CalculateInputRequired(inputInfo));
}
}
List <InputInfo> outputConfigFuels = InputInfo.ConvertPFMInputs(outputConfig);
foreach (InputInfo fuel in outputConfigFuels)
{
RemoveItemsFromInventory(who, fuel.ID, mpm.Settings.CalculateInputRequired(fuel));
}
input.Stack -= mpm.Settings.CalculateInputRequired(inputAndFuelInfo.First());
__result = input.Stack <= 0;
}
else
{
__result = true;
}
}
}
catch (RestrictionException e)
{
__result = false;
if (e.Message != null && !probe && who.IsLocalPlayer)
{
Game1.showRedMessage(e.Message);
}
}
return(false);
}
}
return(!failLocationCondition && !failSeasonCondition);
}
public static void GetFor(ref object __result, Object obj)
{
string machineFullName = __result?.GetType().FullName;
if (machineFullName == "CCRMAutomate.Automate.ClonerMachine" && (ProducerController.HasProducerRule(obj.Name) || ProducerController.GetProducerConfig(obj.Name) != null))
{
__result = new CustomClonerMachine((IMachine)__result);
}
}
/// <summary>
/// Gets the PFM config for the base machine.
/// </summary>
/// <returns></returns>
public ProducerConfig GetBaseProducerConfig()
{
return(ProducerController.GetProducerConfig(BaseProducerName));
}
/// <summary>
/// Adapted from https://github.com/Digus/StardewValleyMods/blob/master/PFMAutomate/Automate/CustomProducerMachine.cs
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public bool SetInput(IStorage input)
{
if (IsMassProducer)
{
MassProductionMachineDefinition mpm = ModEntry.GetMPMMachine(Machine.name, Machine.GetMassProducerKey());
foreach (ITrackedStack trackedStack in input.GetItems())
{
if (trackedStack.Sample is SObject objectInput && !objectInput.bigCraftable.Value &&
ProducerController.GetProducerItem(Machine.Name, objectInput) is ProducerRule producerRule &&
!PFMCompatability.IsInputExcluded(producerRule, mpm, objectInput))
{
ProducerConfig producerConfig = mpm.GetBaseProducerConfig();
if (producerConfig == null || (producerConfig.CheckLocationCondition(Location) && producerConfig.CheckSeasonCondition()))
{
List <InputInfo> inputsRequired = InputInfo.ConvertPFMInputs(producerRule, objectInput);
if (inputsRequired.Count > 0 &&
input.TryGetIngredient(objectInput.ParentSheetIndex, mpm.Settings.CalculateInputRequired(inputsRequired.First()), out IConsumable inputConsumable))
{
objectInput = inputConsumable.Sample as SObject;
List <IConsumable> requiredFuels = GetRequiredFuels(inputsRequired, mpm.Settings, input);
if (requiredFuels != null)
{
try
{
Dictionary <int, int> fuelQuantities = new Dictionary <int, int>();
foreach (InputInfo inputInfo in inputsRequired)
{
if (inputInfo.IsFuel)
{
fuelQuantities.Add(inputInfo.ID, mpm.Settings.CalculateInputRequired(inputInfo));
}
}
Func <int, int, bool> fuelSearch = (i, q) => input.TryGetIngredient(i, fuelQuantities[i], out IConsumable fuel);
OutputConfig outputConfig = PFMCompatability.ProduceOutput(producerRule, mpm.Settings, Machine, fuelSearch, null, Location, producerConfig,
objectInput, inputQuantity: mpm.Settings.CalculateInputRequired(inputsRequired.First()), noSoundAndAnimation: true,
inputInfo: inputsRequired);
if (outputConfig != null)
{
inputConsumable.Take();
requiredFuels.ForEach(f => f.Reduce());
List <IConsumable> outputRequiredFuels = GetRequiredFuels(InputInfo.ConvertPFMInputs(outputConfig), mpm.Settings, input);
outputRequiredFuels.ForEach(f => f.Reduce());
return(true);
}
}
catch (RestrictionException) { /* No action needed */ }
}
}
}
}
}
}
else
{
foreach (ITrackedStack trackedStack in input.GetItems())
{
if (trackedStack.Sample is SObject objectInput && !objectInput.bigCraftable.Value &&
ProducerController.GetProducerItem(Machine.Name, objectInput) is ProducerRule producerRule &&
!ProducerRuleController.IsInputExcluded(producerRule, objectInput))
{
ProducerConfig producerConfig = ProducerController.GetProducerConfig(Machine.name);
if (producerConfig == null || (producerConfig.CheckLocationCondition(Location) && producerConfig.CheckSeasonCondition()))
{
if (input.TryGetIngredient(objectInput.ParentSheetIndex, producerRule.InputStack, out IConsumable inputConsumable))
{
objectInput = inputConsumable.Sample as SObject;
List <IConsumable> requiredFuels = GetRequiredFuels(InputInfo.ConvertPFMInputs(producerRule, objectInput), null, input);
if (requiredFuels != null)
{
try
{
Func <int, int, bool> fuelSearch = (i, q) => input.TryGetIngredient(i, q, out IConsumable fuel);
OutputConfig outputConfig = ProducerRuleController.ProduceOutput(producerRule, Machine, fuelSearch, null, Location, producerConfig,
objectInput, noSoundAndAnimation: true);
if (outputConfig != null)
{
inputConsumable.Take();
requiredFuels.ForEach(f => f.Reduce());
List <IConsumable> outputRequiredFuels = GetRequiredFuels(InputInfo.ConvertPFMInputs(outputConfig), null, input);
outputRequiredFuels.ForEach(f => f.Reduce());
return(true);
}
}
catch (RestrictionException) { /* No action needed */ }
}
}
}
}
}
}
return(false);
}
// Start is called before the first frame update
void Start()
{
controller = FindObjectOfType <ProducerController>();
rb = GetComponent <Rigidbody2D>();
animator = GetComponent <Animator>();
}
public List <Dictionary <string, object> > GetRecipes(string producerName)
{
List <ProducerRule> producerRules = ProducerController.GetProducerRules(producerName);
return(GetRecipes(producerRules));
}
public List <ProducerRule> GetProducerRules(string producerName)
{
return(ProducerController.GetProducerRules(producerName));
}
public static void GetFor(ref object __result, SObject obj)
{
string machineFullName = __result?.GetType().FullName;
if (SupportedVanillaMachines.Contains(machineFullName) && (ProducerController.HasProducerRule(obj.Name) || ProducerController.GetProducerConfig(obj.Name) != null))
{
__result = new VanillaProducerMachine((IMachine)__result);
}
}
// Start is called before the first frame update
void Start()
{
producerController = FindObjectOfType <ProducerController>();
}
