private static bool TryFindBestBillIngredientsInSet_AllowMix(List <Thing> availableThings, Building_CokeFurnace bill, List <ThingCount> chosen) { chosen.Clear(); for (int i = 0; i < bill.SelectedRecipe.ingredients.Count; i++) { IngredientCount ingredientCount = bill.SelectedRecipe.ingredients[i]; float num = ingredientCount.GetBaseCount(); for (int j = 0; j < availableThings.Count; j++) { Thing thing = availableThings[j]; if (ingredientCount.filter.Allows(thing) && ingredientCount.IsFixedIngredient) { float num2 = bill.SelectedRecipe.IngredientValueGetter.ValuePerUnitOf(thing.def); int num3 = Mathf.Min(Mathf.CeilToInt(num / num2), thing.stackCount); ThingCountUtility.AddToList(chosen, thing, num3); num -= (float)num3 * num2; if (num <= 0.0001f) { break; } } } if (num > 0.0001f) { return(false); } } return(true); }
private static ERecipeType GetType(ThingDef td, IngredientCount ing, Bill_Production bill) { if (ing.IsFixedIngredient) { if (!bill.recipe.fixedIngredientFilter.Allows(td)) { return(ERecipeType.FixedNotSelectable); } if (bill.ingredientFilter.Allows(td)) { return(ERecipeType.FixedSelectableAllowed); } return(ERecipeType.Unknown); } if (bill.recipe.fixedIngredientFilter.Allows(td)) { return(bill.ingredientFilter.Allows(td) ? ERecipeType.SelectableAllowed : ERecipeType.SelectableNotAllowed); } return(ERecipeType.Unknown); }
public static bool Prefix(List <Thing> availableThings, Bill bill, List <ThingCount> chosen, ref bool __result) { Pawn trainee = WorkGiver_DoBill_TryFindBestBillIngredients.Trainee; if (trainee != null) { chosen.Clear(); availableThings.Sort((Thing t, Thing t2) => bill.recipe.IngredientValueGetter.ValuePerUnitOf(t2.def).CompareTo(bill.recipe.IngredientValueGetter.ValuePerUnitOf(t.def))); for (int i = 0; i < bill.recipe.ingredients.Count; i++) { IngredientCount ingredientCount = bill.recipe.ingredients[i]; for (int j = 0; j < availableThings.Count; j++) { Thing thing = availableThings[j]; if (ingredientCount.filter.Allows(thing) && (ingredientCount.IsFixedIngredient || bill.ingredientFilter.Allows(thing))) { ThingCountUtility.AddToList(chosen, thing, 1); } } } __result = true; return(false); } return(true); }
public override void CkeckResolve(Thing thing, int amount, float nutriment) { IngestibleInfo ingestibleInfo = null; if (FoodUtility.IsHumanlikeMeatOrHumanlikeCorpse(thing)) { ingestibleInfo = ThingsWanted[0]; } else if (ThingsWanted[0].inIngredient) { CompIngredients compIngredients = thing.TryGetComp <CompIngredients>(); if (compIngredients != null && !compIngredients.ingredients.NullOrEmpty()) { amount = 0; nutriment = 0; for (int i = 0; i < compIngredients.ingredients.Count; i++) { if (FoodUtility.IsHumanlikeMeat(compIngredients.ingredients[i])) { RecipeDef recipe = DefDatabase <RecipeDef> .AllDefsListForReading.Find(rec => rec.ProducedThingDef == thing.def); IngredientCount ingredient = recipe?.ingredients?.Find(ing => ing.filter.Allows(compIngredients.ingredients[i])) ?? null; if (ingredient != null) { amount += ingredient.CountRequiredOfFor(ThingsWanted[0].ingestible, recipe); nutriment += ingredient.GetBaseCount(); ingestibleInfo = ThingsWanted[0]; } } } } } DoUpdate(ingestibleInfo, amount, nutriment); }
private static void MakeIngredientsListInProcessingOrder(List <IngredientCount> ingredientsOrdered, Bill bill) { ingredientsOrdered.Clear(); if (bill.recipe.productHasIngredientStuff) { ingredientsOrdered.Add(bill.recipe.ingredients[0]); } for (int i = 0; i < bill.recipe.ingredients.Count; i++) { if (!bill.recipe.productHasIngredientStuff || i != 0) { IngredientCount ingredientCount = bill.recipe.ingredients[i]; if (ingredientCount.IsFixedIngredient) { ingredientsOrdered.Add(ingredientCount); } } } for (int j = 0; j < bill.recipe.ingredients.Count; j++) { IngredientCount item = bill.recipe.ingredients[j]; if (!ingredientsOrdered.Contains(item)) { ingredientsOrdered.Add(item); } } }
private static IEnumerable <RecipeDef> DrugAdministerDefs() { foreach (ThingDef item in DefDatabase <ThingDef> .AllDefs.Where((ThingDef d) => d.IsDrug)) { RecipeDef recipeDef = new RecipeDef(); recipeDef.defName = "Administer_" + item.defName; recipeDef.label = "RecipeAdminister".Translate(item.label); recipeDef.jobString = "RecipeAdministerJobString".Translate(item.label); recipeDef.workerClass = typeof(Recipe_AdministerIngestible); recipeDef.targetsBodyPart = false; recipeDef.anesthetize = false; recipeDef.surgerySuccessChanceFactor = 99999f; recipeDef.modContentPack = item.modContentPack; recipeDef.workAmount = item.ingestible.baseIngestTicks; IngredientCount ingredientCount = new IngredientCount(); ingredientCount.SetBaseCount(1f); ingredientCount.filter.SetAllow(item, allow: true); recipeDef.ingredients.Add(ingredientCount); recipeDef.fixedIngredientFilter.SetAllow(item, allow: true); recipeDef.recipeUsers = new List <ThingDef>(); foreach (ThingDef item2 in DefDatabase <ThingDef> .AllDefs.Where((ThingDef d) => d.category == ThingCategory.Pawn && d.race.IsFlesh)) { recipeDef.recipeUsers.Add(item2); } yield return(recipeDef); } }
private static void MakeIngredientsListInProcessingOrder( List <IngredientCount> ingredientsOrdered, Bill bill) { ingredientsOrdered.Clear(); if (bill.recipe.productHasIngredientStuff) { ingredientsOrdered.Add(bill.recipe.ingredients[0]); } for (int index = 0; index < bill.recipe.ingredients.Count; ++index) { if (!bill.recipe.productHasIngredientStuff || index != 0) { IngredientCount ingredient = bill.recipe.ingredients[index]; if (ingredient.IsFixedIngredient) { ingredientsOrdered.Add(ingredient); } } } for (int index = 0; index < bill.recipe.ingredients.Count; ++index) { IngredientCount ingredient = bill.recipe.ingredients[index]; if (!ingredientsOrdered.Contains(ingredient)) { ingredientsOrdered.Add(ingredient); } } }
public static bool TryFindBestRecipeIngredientsInSet_AllowMix(this RecipeDef recipeDef, List <Thing> availableThings, List <ThingCount> chosen) { chosen.Clear(); for (int ingredientIndex = 0; ingredientIndex < recipeDef.ingredients.Count; ++ingredientIndex) { IngredientCount ingredientCount = recipeDef.ingredients[ingredientIndex]; float baseCount = ingredientCount.GetBaseCount(); for (int thingIndex = 0; thingIndex < availableThings.Count; ++thingIndex) { Thing thing = availableThings[thingIndex]; if (ingredientCount.filter.Allows(thing)) { float ingredientValue = recipeDef.IngredientValueGetter.ValuePerUnitOf(thing.def); int countToAdd = Mathf.Min(Mathf.CeilToInt(baseCount / ingredientValue), thing.stackCount); ThingCountUtility.AddToList(chosen, thing, countToAdd); baseCount -= (float)countToAdd * ingredientValue; if ((double)baseCount <= 9.99999974737875E-05) { break; } } } if ((double)baseCount > 9.99999974737875E-05) { return(false); } } return(true); }
private static IEnumerable <RecipeDef> DrugAdministerDefs() { foreach (ThingDef def in from d in DefDatabase <ThingDef> .AllDefs where d.IsDrug select d) { RecipeDef r = new RecipeDef(); r.defName = "Administer_" + def.defName; r.label = "RecipeAdminister".Translate(new object[] { def.label }); r.jobString = "RecipeAdministerJobString".Translate(new object[] { def.label }); r.workerClass = typeof(Recipe_AdministerIngestible); r.targetsBodyPart = false; r.anesthetize = false; r.surgerySuccessChanceFactor = 99999f; r.workAmount = (float)def.ingestible.baseIngestTicks; IngredientCount ic = new IngredientCount(); ic.SetBaseCount(1f); ic.filter.SetAllow(def, true); r.ingredients.Add(ic); r.fixedIngredientFilter.SetAllow(def, true); r.recipeUsers = new List <ThingDef>(); foreach (ThingDef current in DefDatabase <ThingDef> .AllDefs.Where((ThingDef d) => d.category == ThingCategory.Pawn && d.race.IsFlesh)) { r.recipeUsers.Add(current); } yield return(r); } }
public bool TryDropThings(IngredientCount ic, out List <Thing> dropped) { dropped = null; foreach (LinkedList <Thing> l in this.storedThings.Values) { if (l.Count > 0) { if (ic.filter.Allows(l.First.Value.def)) { foreach (Thing t in l) { if (ic.filter.Allows(t)) { this.DropThing(t, null); if (dropped == null) { dropped = new List <Thing>(); } dropped.Add(t); } } } } } return(dropped?.Count > 0); }
private static bool TryFindBestBillIngredientsInSet_AllowMix(List <Thing> availableThings, Bill bill, List <ThingAmount> chosen) { chosen.Clear(); for (int i = 0; i < bill.recipe.ingredients.Count; i++) { IngredientCount ingredientCount = bill.recipe.ingredients[i]; float num = ingredientCount.GetBaseCount(); for (int j = 0; j < availableThings.Count; j++) { Thing thing = availableThings[j]; if (ingredientCount.filter.Allows(thing) && (ingredientCount.IsFixedIngredient || bill.ingredientFilter.Allows(thing))) { float num2 = bill.recipe.IngredientValueGetter.ValuePerUnitOf(thing.def); int num3 = Mathf.Min(Mathf.CeilToInt(num / num2), thing.stackCount); ThingAmount.AddToList(chosen, thing, num3); num -= (float)num3 * num2; if (num <= 9.9999997473787516E-05) { break; } } } if (num > 9.9999997473787516E-05) { return(false); } } return(true); }
private static RecipeDef CreateToEnergyRecipeDef(string defName, string label, string jobString, float workAmount, int count, HashSet <ThingDef> toEnergyDefs) { var r = CreateRecipeDef(defName, label, jobString, workAmount); var c = new IngredientCount(); r.ingredients.Add(c); c.SetBaseCount(count); c.filter = new ThingFilter(); toEnergyDefs.ForEach(d => { if (d.defName != "NR_MaterialEnergy_Energy") { r.fixedIngredientFilter.SetAllow(d, true); c.filter.SetAllow(d, true); } }); c.filter.RecalculateDisplayRootCategory(); r.defaultIngredientFilter = new ThingFilter(); r.defaultIngredientFilter.SetDisallowAll(null); r.fixedIngredientFilter.RecalculateDisplayRootCategory(); r.ResolveReferences(); r.products.Add(new ThingDefCount(energyThingDef, count)); r.allowMixingIngredients = true; return(r); }
internal static bool TryFindBestMixInSet_AllowMix(List <Thing> availableThings, Bill bill, List <ThingCount> chosen) { chosen.Clear(); for (var i = 0; i < bill.recipe.ingredients.Count; i++) { IngredientCount ingredientCount = bill.recipe.ingredients[i]; var num = ingredientCount.GetBaseCount(); for (var j = 0; j < availableThings.Count; j++) { Thing thing = availableThings[j]; if (ingredientCount.filter.Allows(thing) && (ingredientCount.IsFixedIngredient || bill.ingredientFilter.Allows(thing))) { var num2 = bill.recipe.IngredientValueGetter.ValuePerUnitOf(thing.def); var num3 = Mathf.Min(Mathf.CeilToInt(num / num2), thing.stackCount); ThingCountUtility.AddToList(chosen, thing, num3); num -= (float)num3 * num2; if (num <= 0.0001f) { break; } } } if (num > 0.0001f) { return(false); } } return(true); }
private static RecipeDef CreateMaterializeRecipeDef(string defName, string label, string jobString, float workAmount, int energyCount, ThingDef product, int productCount, ThingDef stuff) { var r = CreateRecipeDef(defName, label, jobString, workAmount); var c = new IngredientCount(); r.ingredients.Add(c); c.SetBaseCount(energyCount); c.filter = new ThingFilter(); r.defaultIngredientFilter = new ThingFilter(); if (stuff != null) { var st = new IngredientCount(); r.ingredients.Add(st); st.filter.SetAllow(stuff, true); // とりえあずstuff は 10個でいい. st.SetBaseCount(10); } c.filter.SetAllow(energyThingDef, true); r.defaultIngredientFilter.SetAllow(energyThingDef, true); c.filter.RecalculateDisplayRootCategory(); r.fixedIngredientFilter.RecalculateDisplayRootCategory(); r.ResolveReferences(); r.products.Add(new ThingDefCount(product, productCount)); return(r); }
private static bool TryFindBestBillIngredientsInSet_AllowMix( List <Thing> availableThings, Bill bill, List <ThingCount> chosen) { chosen.Clear(); availableThings.Sort((t, t2) => bill.recipe.IngredientValueGetter.ValuePerUnitOf(t2.def).CompareTo(bill.recipe.IngredientValueGetter.ValuePerUnitOf(t.def))); for (int index1 = 0; index1 < bill.recipe.ingredients.Count; ++index1) { IngredientCount ingredient = bill.recipe.ingredients[index1]; float baseCount = ingredient.GetBaseCount(); for (int index2 = 0; index2 < availableThings.Count; ++index2) { Thing availableThing = availableThings[index2]; if (ingredient.filter.Allows(availableThing) && (ingredient.IsFixedIngredient || bill.ingredientFilter.Allows(availableThing))) { float num = bill.recipe.IngredientValueGetter.ValuePerUnitOf(availableThing.def); int countToAdd = Mathf.Min(Mathf.CeilToInt(baseCount / num), availableThing.stackCount); ThingCountUtility.AddToList(chosen, availableThing, countToAdd); baseCount -= countToAdd * num; if (baseCount <= 9.99999974737875E-05) { break; } } } if (baseCount > 9.99999974737875E-05) { return(false); } } return(true); }
private static IEnumerable <RecipeDef> DefsFromRecipeMakers() { using (IEnumerator <ThingDef> enumerator = (from d in DefDatabase <ThingDef> .AllDefs where d.recipeMaker != null select d).GetEnumerator()) { if (enumerator.MoveNext()) { ThingDef def = enumerator.Current; RecipeMakerProperties rm = def.recipeMaker; RecipeDef r = new RecipeDef { defName = "Make_" + def.defName, label = "RecipeMake".Translate(def.label), jobString = "RecipeMakeJobString".Translate(def.label), modContentPack = def.modContentPack, workAmount = (float)rm.workAmount, workSpeedStat = rm.workSpeedStat, efficiencyStat = rm.efficiencyStat }; if (def.MadeFromStuff) { IngredientCount ingredientCount = new IngredientCount(); ingredientCount.SetBaseCount((float)def.costStuffCount); ingredientCount.filter.SetAllowAllWhoCanMake(def); r.ingredients.Add(ingredientCount); r.fixedIngredientFilter.SetAllowAllWhoCanMake(def); r.productHasIngredientStuff = true; } if (def.costList != null) { foreach (ThingDefCountClass cost in def.costList) { IngredientCount ingredientCount2 = new IngredientCount(); ingredientCount2.SetBaseCount((float)cost.count); ingredientCount2.filter.SetAllow(cost.thingDef, allow: true); r.ingredients.Add(ingredientCount2); } } r.defaultIngredientFilter = rm.defaultIngredientFilter; r.products.Add(new ThingDefCountClass(def, rm.productCount)); r.targetCountAdjustment = rm.targetCountAdjustment; r.skillRequirements = rm.skillRequirements.ListFullCopyOrNull(); r.workSkill = rm.workSkill; r.workSkillLearnFactor = rm.workSkillLearnPerTick; r.unfinishedThingDef = rm.unfinishedThingDef; r.recipeUsers = rm.recipeUsers.ListFullCopyOrNull(); r.effectWorking = rm.effectWorking; r.soundWorking = rm.soundWorking; r.researchPrerequisite = rm.researchPrerequisite; r.factionPrerequisiteTags = rm.factionPrerequisiteTags; yield return(r); /*Error: Unable to find new state assignment for yield return*/; } } yield break; IL_03ca: /*Error near IL_03cb: Unexpected return in MoveNext()*/; }
public static string GetMaxAllowedCount(RecipeDef r, IngredientCount ing, bool isNutrition) { float countMax = 0f, countMaxNutrition = 0f; var bill = CurrentBill; if (bill == null) { return(""); } foreach (var td in ing.filter.AllowedThingDefs) { var ingType = GetType(td, ing, bill); if (ingType != ERecipeType.Unknown && ingType != ERecipeType.SelectableNotAllowed) { var count = ThingCountOnMap(td); if (td.smallVolume) { count *= 10f; } if (count > countMax) { countMax = count; if (isNutrition) { countMaxNutrition = count * NutritionValuePerUnitOf(td); } } //Log.Message(String.Format("thing: {0}({1}), is_fixed: {2}, in_rff: {3}, in_bff: {4}, in_bif: {5}", // td.LabelCap, // count, // ing.IsFixedIngredient, // r.fixedIngredientFilter.Allows(td), // bill.recipe.fixedIngredientFilter.Allows(td), // bill.ingredientFilter.Allows(td))); } } string result; if (isNutrition) { result = !Settings.UseDashes || countMaxNutrition >= ing.GetBaseCount() ? $" ({countMaxNutrition} / {countMax})" : " (-)"; } else { result = !Settings.UseDashes || countMax >= ing.GetBaseCount() ? $" ({countMax})" : " (-)"; } return(result); }
private static bool Prefix(ref string __result, RecipeDef r, IngredientCount ing) { __result = "BillRequiresNutrition" .Translate(ing.GetBaseCount() + BillRequirementsMod.GetMaxAllowedCount(r, ing, true)) + " (" + ing.filter.Summary + ")"; return(false); }
private static IEnumerable <RecipeDef> DefsFromRecipeMakers() { foreach (ThingDef def in from d in DefDatabase <ThingDef> .AllDefs where d.recipeMaker != null select d) { RecipeMakerProperties rm = def.recipeMaker; RecipeDef r = new RecipeDef(); r.defName = "Make_" + def.defName; r.label = "RecipeMake".Translate(new object[] { def.label }); r.jobString = "RecipeMakeJobString".Translate(new object[] { def.label }); r.modContentPack = def.modContentPack; r.workAmount = (float)rm.workAmount; r.workSpeedStat = rm.workSpeedStat; r.efficiencyStat = rm.efficiencyStat; if (def.MadeFromStuff) { IngredientCount ingredientCount = new IngredientCount(); ingredientCount.SetBaseCount((float)def.costStuffCount); ingredientCount.filter.SetAllowAllWhoCanMake(def); r.ingredients.Add(ingredientCount); r.fixedIngredientFilter.SetAllowAllWhoCanMake(def); r.productHasIngredientStuff = true; } if (def.costList != null) { foreach (ThingDefCountClass thingDefCountClass in def.costList) { IngredientCount ingredientCount2 = new IngredientCount(); ingredientCount2.SetBaseCount((float)thingDefCountClass.count); ingredientCount2.filter.SetAllow(thingDefCountClass.thingDef, true); r.ingredients.Add(ingredientCount2); } } r.defaultIngredientFilter = rm.defaultIngredientFilter; r.products.Add(new ThingDefCountClass(def, rm.productCount)); r.targetCountAdjustment = rm.targetCountAdjustment; r.skillRequirements = rm.skillRequirements.ListFullCopyOrNull <SkillRequirement>(); r.workSkill = rm.workSkill; r.workSkillLearnFactor = rm.workSkillLearnPerTick; r.unfinishedThingDef = rm.unfinishedThingDef; r.recipeUsers = rm.recipeUsers.ListFullCopyOrNull <ThingDef>(); r.effectWorking = rm.effectWorking; r.soundWorking = rm.soundWorking; r.researchPrerequisite = rm.researchPrerequisite; r.factionPrerequisiteTags = rm.factionPrerequisiteTags; yield return(r); } yield break; }
private static bool TryFindBestBillIngredientsInSet_NoMix(List <Thing> availableThings, Bill bill, List <ThingCount> chosen) { RecipeDef recipe = bill.recipe; chosen.Clear(); WorkGiver_DoBill.availableCounts.Clear(); WorkGiver_DoBill.availableCounts.GenerateFrom(availableThings); for (int i = 0; i < WorkGiver_DoBill.ingredientsOrdered.Count; i++) { IngredientCount ingredientCount = recipe.ingredients[i]; bool flag = false; for (int j = 0; j < WorkGiver_DoBill.availableCounts.Count; j++) { float num = (float)ingredientCount.CountRequiredOfFor(WorkGiver_DoBill.availableCounts.GetDef(j), bill.recipe); if (num <= WorkGiver_DoBill.availableCounts.GetCount(j)) { if (ingredientCount.filter.Allows(WorkGiver_DoBill.availableCounts.GetDef(j))) { if (ingredientCount.IsFixedIngredient || bill.ingredientFilter.Allows(WorkGiver_DoBill.availableCounts.GetDef(j))) { for (int k = 0; k < availableThings.Count; k++) { if (availableThings[k].def == WorkGiver_DoBill.availableCounts.GetDef(j)) { int num2 = availableThings[k].stackCount - ThingCountUtility.CountOf(chosen, availableThings[k]); if (num2 > 0) { int num3 = Mathf.Min(Mathf.FloorToInt(num), num2); ThingCountUtility.AddToList(chosen, availableThings[k], num3); num -= (float)num3; if (num < 0.001f) { flag = true; float num4 = WorkGiver_DoBill.availableCounts.GetCount(j); num4 -= (float)ingredientCount.CountRequiredOfFor(WorkGiver_DoBill.availableCounts.GetDef(j), bill.recipe); WorkGiver_DoBill.availableCounts.SetCount(j, num4); break; } } } } if (flag) { break; } } } } } if (!flag) { return(false); } } return(true); }
} //end FindClosestIngForBill public static Thing FindClosestIngToBillGiver(Bill theBill, IngredientCount curIng) { IBillGiver billGiver = theBill.billStack.billGiver; IThingHolder holder = billGiver as IThingHolder; Thing building = billGiver as Thing; ThingOwner vatStoredIngredients = holder?.GetDirectlyHeldThings(); if (billGiver == null || building == null || billGiver == null || vatStoredIngredients == null) { return(null); } int storedCount = vatStoredIngredients.FirstOrDefault(thing => thing.def == curIng.FixedIngredient)?.stackCount ?? 0; int countNeededFromRecipe = (int)(curIng.CountRequiredOfFor(curIng.FixedIngredient, theBill.recipe) * QEESettings.instance.organTotalResourcesFloat); int countNeededForCrafting = countNeededFromRecipe - storedCount; countNeededForCrafting = countNeededForCrafting < 0 ? 0 : countNeededForCrafting; //only check the map for Things if the vat still needs some of this ingredient if (countNeededForCrafting > 0) { //find the closest accessible Thing of that ThingDef on the map ThingRequest tRequest = ThingRequest.ForDef(curIng.FixedIngredient); IEnumerable <Thing> searchSet = billGiver.Map.listerThings.ThingsMatching(tRequest); Thing result = GenClosest.ClosestThing_Global(building.Position, searchSet, validator : delegate(Thing testThing) { if (testThing.def.defName != curIng.FixedIngredient.defName) { return(false); } if (testThing.IsForbidden(building.Faction)) { return(false); } return(true); }); //return the Thing, if we found one if (result != null) { //QEEMod.TryLog("Ingredient found: " + curIng.FixedIngredient.label + " | stackCount: " + result.stackCount + " | recipe: " // + countNeededFromRecipe); return(result); } } return(null); } //end function FindClosestIngToBillGiver
public IngredientCountWidget(IngredientCount ingredientCount) { this.uniqueId = uniqueCount; ++uniqueCount; this.IngredientCount = ingredientCount; this.filter = new ThingFilterWidget("Ingredient Filter", this.IngredientCount.filter); this.count = new FloatInputWidget <IngredientCount>( this.IngredientCount, "Ingredient Count", (ic) => IngredientCountStats.GetIngredientCount(ic), (ic, f) => IngredientCountStats.SetIngredientCount(ic, f)); }
public bool IsFixedOrAllowedIngredient(Thing thing) { for (int i = 0; i < recipe.ingredients.Count; i++) { IngredientCount ingredientCount = recipe.ingredients[i]; if (ingredientCount.IsFixedIngredient && ingredientCount.filter.Allows(thing)) { return(true); } } return(recipe.fixedIngredientFilter.Allows(thing) && ingredientFilter.Allows(thing)); }
public override string BillRequirementsDescription(RecipeDef r, IngredientCount ing) { foreach (ThingDef def in ing.filter.AllowedThingDefs) { if (def.IsNutritionGivingIngestible) { return("BillRequiresNutrition".Translate((ing.GetBaseCount()), "") + " (" + ing.filter.Summary + ")"); } } return("BillRequires".Translate((ing.GetBaseCount()), ing.filter.Summary)); }
private static RecipeDef MkNewRecipe(RecipeDef rd, int factor) { if (rd.ingredients.Count == 0 || rd.products.Count != 1) { return(null); } var r = new RecipeDef { defName = rd.defName + $"_{factor}x", label = rd.label + $" x{factor}", description = rd.description + $" (x{factor})", jobString = rd.jobString, modContentPack = rd.modContentPack, workSpeedStat = rd.workSpeedStat, efficiencyStat = rd.efficiencyStat, fixedIngredientFilter = rd.fixedIngredientFilter, productHasIngredientStuff = rd.productHasIngredientStuff, workSkill = rd.workSkill, workSkillLearnFactor = rd.workSkillLearnFactor, skillRequirements = rd.skillRequirements.ListFullCopyOrNull(), recipeUsers = rd.recipeUsers.ListFullCopyOrNull(), unfinishedThingDef = null, //rd.unfinishedThingDef, effectWorking = rd.effectWorking, soundWorking = rd.soundWorking, allowMixingIngredients = rd.allowMixingIngredients, defaultIngredientFilter = rd.defaultIngredientFilter, researchPrerequisite = rd.researchPrerequisite, factionPrerequisiteTags = rd.factionPrerequisiteTags }; r.products.Add(new ThingDefCountClass(rd.products[0].thingDef, rd.products[0].count * factor)); var new_ingredients = new List <IngredientCount>(); foreach (var oic in rd.ingredients) { var nic = new IngredientCount(); nic.SetBaseCount(oic.GetBaseCount() * factor); nic.filter = oic.filter; new_ingredients.Add(nic); } r.ingredients = new_ingredients; r.workAmount = rd.WorkAmountTotal(null) * factor; var IVGClass = (Type)Traverse.Create(rd).Field("ingredientValueGetterClass").GetValue(); Traverse.Create(r).Field("ingredientValueGetterClass").SetValue(IVGClass); //if (rd.unfinishedThingDef != null) // Log.Message(rd.label + " uses unfinishedThingDef " + rd.unfinishedThingDef.label+" an it is removed"); return(r); }
public bool IsFixedOrAllowedIngredient(ThingDef def) { for (int i = 0; i < this.recipe.ingredients.Count; i++) { IngredientCount ingredientCount = this.recipe.ingredients[i]; if (ingredientCount.IsFixedIngredient && ingredientCount.filter.Allows(def)) { return(true); } } return(this.recipe.fixedIngredientFilter.Allows(def) && this.ingredientFilter.Allows(def)); }
private static bool TryFindBestBillIngredientsInSet_NoMix(List <Thing> availableThings, Building_CokeFurnace bill, List <ThingCount> chosen) { RecipeDef recipe = bill.SelectedRecipe; chosen.Clear(); availableCounts.Clear(); availableCounts.GenerateFrom(availableThings); for (int i = 0; i < ingredientsOrdered.Count; i++) { IngredientCount ingredientCount = recipe.ingredients[i]; bool flag = false; for (int j = 0; j < availableCounts.Count; j++) { float num = ingredientCount.CountRequiredOfFor(availableCounts.GetDef(j), bill.SelectedRecipe); if (num > availableCounts.GetCount(j) || !ingredientCount.filter.Allows(availableCounts.GetDef(j)) || !ingredientCount.IsFixedIngredient) { continue; } for (int k = 0; k < availableThings.Count; k++) { if (availableThings[k].def != availableCounts.GetDef(j)) { continue; } int num2 = availableThings[k].stackCount - ThingCountUtility.CountOf(chosen, availableThings[k]); if (num2 > 0) { int num3 = Mathf.Min(Mathf.FloorToInt(num), num2); ThingCountUtility.AddToList(chosen, availableThings[k], num3); num -= (float)num3; if (num < 0.001f) { flag = true; float count = availableCounts.GetCount(j); count -= (float)ingredientCount.CountRequiredOfFor(availableCounts.GetDef(j), bill.SelectedRecipe); availableCounts.SetCount(j, count); break; } } } if (flag) { break; } } if (!flag) { return(false); } } return(true); }
internal static bool TryFindBestMixInSet_NoMix(List <Thing> availableThings, Bill bill, List <ThingCount> chosen, List <IngredientCount> ingredientsOrdered) { var availableCounts = new BMixDefCountList(); RecipeDef recipe = bill.recipe; chosen.Clear(); availableCounts.Clear(); availableCounts.GenerateFrom(availableThings); for (var i = 0; i < ingredientsOrdered.Count; i++) { IngredientCount ingredientCount = recipe.ingredients[i]; var flag = false; for (var j = 0; j < availableCounts.Count; j++) { float num = ingredientCount.CountRequiredOfFor(availableCounts.GetDef(j), bill.recipe); if (num > availableCounts.GetCount(j) || !ingredientCount.filter.Allows(availableCounts.GetDef(j)) || (!ingredientCount.IsFixedIngredient && !bill.ingredientFilter.Allows(availableCounts.GetDef(j)))) { continue; } for (var k = 0; k < availableThings.Count; k++) { if (availableThings[k].def != availableCounts.GetDef(j)) { continue; } var num2 = availableThings[k].stackCount - ThingCountUtility.CountOf(chosen, availableThings[k]); if (num2 > 0) { var num3 = Mathf.Min(Mathf.FloorToInt(num), num2); ThingCountUtility.AddToList(chosen, availableThings[k], num3); num -= (float)num3; if (num < 0.001f) { flag = true; var count = availableCounts.GetCount(j); count -= (float)ingredientCount.CountRequiredOfFor(availableCounts.GetDef(j), bill.recipe); availableCounts.SetCount(j, count); break; } } } if (flag) { break; } } if (!flag) { return(false); } } return(true); }
// Will return null if recipe requires no components private RecipeDef TryMakeRecipeVariantWithSteel(RecipeDef recipeOriginal) { var recipeCopy = (RecipeDef)objectCloneMethod.Invoke(recipeOriginal, null); recipeCopy.shortHash = 0; InjectedDefHasher.GiveShortHasToDef(recipeCopy, typeof(RecipeDef)); recipeCopy.defName += RemoteExplosivesUtility.InjectedRecipeNameSuffix; var newFixedFilter = new ThingFilter(); foreach (var allowedThingDef in recipeOriginal.fixedIngredientFilter.AllowedThingDefs) { if (allowedThingDef == ThingDefOf.Component) { continue; } newFixedFilter.SetAllow(allowedThingDef, true); } newFixedFilter.SetAllow(ThingDefOf.Steel, true); recipeCopy.fixedIngredientFilter = newFixedFilter; recipeCopy.defaultIngredientFilter = null; float numComponentsRequired = 0; var newIngredientList = new List <IngredientCount>(recipeOriginal.ingredients); foreach (var ingredientCount in newIngredientList) { if (ingredientCount.filter.Allows(ThingDefOf.Component)) { numComponentsRequired = ingredientCount.GetBaseCount(); newIngredientList.Remove(ingredientCount); break; } } if (numComponentsRequired == 0) { return(null); } var steelFilter = new ThingFilter(); steelFilter.SetAllow(ThingDefOf.Steel, true); var steelIngredient = new IngredientCount { filter = steelFilter }; steelIngredient.SetBaseCount(ComponentValueInSteel * numComponentsRequired); newIngredientList.Add(steelIngredient); recipeCopy.ingredients = newIngredientList; recipeCopy.ResolveReferences(); return(recipeCopy); }
public void AddItemToFurnace(Thing item) { if (ContainedResources.ContainsKey(item.def)) { IngredientCount ingr = SelectedRecipe.ingredients.Where(x => x.FixedIngredient == item.def).FirstOrDefault(); int remaining = (int)(ingr.GetBaseCount() * Multiplier) - ContainedResources[item.def]; int toSplit = Mathf.Min(item.stackCount, remaining); item.SplitOff(toSplit).Destroy(); ContainedResources[item.def] += toSplit; } }
public void SetupThingWithCompsSpawnVehicleDef() { foreach (ThingDef thingDef in DefDatabase<ThingDef>.AllDefs.Where(x => x.thingClass == System.Type.GetType("Vehicle"))) { if (DefDatabase<ThingDef>.GetNamedSilentFail("Spawn" + thingDef.defName) != null) continue; ThingWithCompsSpawnVehicleDef thingWithCompsSpawnVehicle = new ThingWithCompsSpawnVehicleDef(); thingWithCompsSpawnVehicle.DefaultDef(); thingWithCompsSpawnVehicle.defName = "Spawn" + thingDef.defName; if (DefDatabase<PawnKindDef>.GetNamed(thingDef.defName) != null) thingWithCompsSpawnVehicle.spawnPawnDef = DefDatabase<PawnKindDef>.GetNamed(thingDef.defName); else Log.Error(thingDef.defName + " doesn't have PawnKindDef"); thingWithCompsSpawnVehicle.label = thingDef.label; thingWithCompsSpawnVehicle.description = thingDef.description; thingWithCompsSpawnVehicle.costStuffCount = thingDef.costStuffCount; if (thingDef.statBases.Find(x => x.stat == StatDefOf.WorkToMake) != null) thingWithCompsSpawnVehicle.recipeMaker.workAmount = (int)thingDef.statBases.Find(x => x.stat == StatDefOf.WorkToMake).value; else { Log.Error(thingDef.defName + " doesn't have WorkToMake value. Set 1000 default value"); thingWithCompsSpawnVehicle.recipeMaker.workAmount = 1000; } thingWithCompsSpawnVehicle.PostLoad(); DefDatabase<ThingWithCompsSpawnVehicleDef>.Add(thingWithCompsSpawnVehicle); RecipeDef recipeDef = FullCopyRecipeDef(DefDatabase<RecipeDef>.GetNamed("Make_SpawnVehicleAbstract")); recipeDef.defName = "Make_" + "Spawn" + thingDef.defName; string key1 = "RecipeMake"; object[] objArray1 = new object[1]; int index1 = 0; string str1 = thingDef.label; objArray1[index1] = (object) str1; string str2 = Translator.Translate(key1, objArray1); recipeDef.label = str2; string key2 = "RecipeMakeJobString"; object[] objArray2 = new object[1]; int index2 = 0; string str3 = thingDef.label; objArray2[index2] = (object) str3; string str4 = Translator.Translate(key2, objArray2); recipeDef.jobString = str4; if (thingDef.MadeFromStuff) { IngredientCount ingredientCount = new IngredientCount(); ingredientCount.SetBaseCount((float)thingDef.costStuffCount); ingredientCount.filter.SetAllowAllWhoCanMake(thingDef); recipeDef.ingredients.Add(ingredientCount); recipeDef.fixedIngredientFilter.SetAllowAllWhoCanMake(thingDef); recipeDef.productHasIngredientStuff = true; } recipeDef.products = new List<ThingCount>(); recipeDef.products.Add(new ThingCount(thingDef, 1)); ThingDef unfinishedVehicle = FullCopyUnfinishedThingDef(DefDatabase<ThingDef>.GetNamed("UnfinishedAbstract")); unfinishedVehicle.defName = "Unfinished" + thingDef.defName; unfinishedVehicle.graphicData.texPath = thingDef.graphicData.texPath; unfinishedVehicle.graphicData.graphicClass = thingDef.graphicData.graphicClass; unfinishedVehicle.graphicData.drawSize = thingDef.graphicData.drawSize; unfinishedVehicle.PostLoad(); DefDatabase<ThingDef>.Add(unfinishedVehicle); recipeDef.unfinishedThingDef = unfinishedVehicle; recipeDef.PostLoad(); DefDatabase<RecipeDef>.Add(recipeDef); } }
private void MergeIngredientIntoFilter( ThingFilter filter, IngredientCount ingredient ) { //Log.Message( string.Format( "{0}.CompHopperUser.MergeIngredientIntoFilter( ThingFilter, IngredientCount )", this.parent.ThingID ) ); if( ingredient.filter != null ) { if( !ingredient.filter.Categories().NullOrEmpty() ) { foreach( var category in ingredient.filter.Categories() ) { var categoryDef = DefDatabase<ThingCategoryDef>.GetNamed( category, true ); filter.SetAllow( categoryDef, true ); } } if( !ingredient.filter.ThingDefs().NullOrEmpty() ) { foreach( var thingDef in ingredient.filter.ThingDefs() ) { filter.SetAllow( thingDef, true ); } } } }
private void MergeIngredientIntoHopperSettings( IngredientCount ingredient, RecipeDef recipe ) { //Log.Message( string.Format( "{0}.CompHopperUser.MergeIngredientIntoHopperSettings( IngredientCount, {1} )", this.parent.ThingID, recipe == null ? "null" : recipe.defName ) ); if( ingredient.filter != null ) { if( !ingredient.filter.Categories().NullOrEmpty() ) { foreach( var category in ingredient.filter.Categories() ) { var categoryDef = DefDatabase<ThingCategoryDef>.GetNamed( category, true ); HopperSettingsAmount.AddToList( hopperSettings, categoryDef, ingredient.GetBaseCount(), recipe ); } } if( !ingredient.filter.ThingDefs().NullOrEmpty() ) { foreach( var thingDef in ingredient.filter.ThingDefs() ) { HopperSettingsAmount.AddToList( hopperSettings, thingDef, ingredient.GetBaseCount(), recipe ); } } } }
public RecipeDef targetRecipe; // the parent recipe itself. #endregion Fields #region Constructors public IngredientSelector( Manager manager, IngredientCount ingredient, int count, RecipeDef targetRecipe ) { // set up vars this.ingredient = ingredient; this.targetRecipe = targetRecipe; this.manager = manager; targetCount = (int) Math.Sqrt( count ) * (int) ingredient.GetBaseCount(); allowedThingDefs = ingredient.filter.AllowedThingDefs.ToList(); // if there's only one allowed we don't need to manually choose. if ( allowedThingDefs.Count == 1 ) { recipeSelector = new RecipeSelector( manager, allowedThingDefs.First(), targetCount ); } }