public static Thing TryMakeForStockSingle(ThingDef thingDef, int stackCount)
{
Thing result;
if (stackCount <= 0)
{
result = null;
}
else if (!thingDef.tradeability.TraderCanSell())
{
Log.Error("Tried to make non-trader-sellable thing for trader stock: " + thingDef, false);
result = null;
}
else
{
ThingDef stuff = null;
if (thingDef.MadeFromStuff)
{
if (!(from x in GenStuff.AllowedStuffsFor(thingDef, TechLevel.Undefined)
where !PawnWeaponGenerator.IsDerpWeapon(thingDef, x)
select x).TryRandomElementByWeight((ThingDef x) => x.stuffProps.commonality, out stuff))
{
stuff = GenStuff.RandomStuffByCommonalityFor(thingDef, TechLevel.Undefined);
}
}
Thing thing = ThingMaker.MakeThing(thingDef, stuff);
thing.stackCount = stackCount;
result = thing;
}
return(result);
}
public static bool IsDerpAndDisallowed(ThingDef thing, ThingDef stuff, QualityGenerator?qualityGenerator)
{
if (qualityGenerator == QualityGenerator.Gift || qualityGenerator == QualityGenerator.Reward || qualityGenerator == QualityGenerator.Super)
{
if (!PawnWeaponGenerator.IsDerpWeapon(thing, stuff))
{
return(PawnApparelGenerator.IsDerpApparel(thing, stuff));
}
return(true);
}
return(false);
}
public static float CheapestNonDerpPriceFor(ThingDef weaponDef)
{
float num = 9999999f;
for (int i = 0; i < PawnWeaponGenerator.allWeaponPairs.Count; i++)
{
ThingStuffPair thingStuffPair = PawnWeaponGenerator.allWeaponPairs[i];
if (thingStuffPair.thing == weaponDef && !PawnWeaponGenerator.IsDerpWeapon(thingStuffPair.thing, thingStuffPair.stuff) && thingStuffPair.Price < num)
{
num = thingStuffPair.Price;
}
}
return(num);
}
public static Thing TryMakeForStockSingle(ThingDef thingDef, int stackCount)
{
if (stackCount <= 0)
{
return(null);
}
if (!thingDef.tradeability.TraderCanSell())
{
Log.Error("Tried to make non-trader-sellable thing for trader stock: " + thingDef);
return(null);
}
ThingDef result = null;
if (thingDef.MadeFromStuff && !(from x in GenStuff.AllowedStuffsFor(thingDef)
where !PawnWeaponGenerator.IsDerpWeapon(thingDef, x)
select x).TryRandomElementByWeight((ThingDef x) => x.stuffProps.commonality, out result))
{
result = GenStuff.RandomStuffByCommonalityFor(thingDef);
}
Thing thing = ThingMaker.MakeThing(thingDef, result);
thing.stackCount = stackCount;
return(thing);
}
public static List <ThingStuffPairWithQuality> GenerateDefsWithPossibleTotalValue(IntRange countRange, float totalValue, IEnumerable <ThingDef> allowed, TechLevel techLevel, QualityGenerator qualityGenerator, Func <ThingStuffPairWithQuality, float> getMinValue, Func <ThingStuffPairWithQuality, float> getMaxValue, Func <ThingDef, float> weightSelector = null, int tries = 100, float maxMass = 3.40282347E+38f)
{
List <ThingStuffPairWithQuality> chosen = new List <ThingStuffPairWithQuality>();
if (countRange.max <= 0)
{
return(chosen);
}
if (countRange.min < 1)
{
countRange.min = 1;
}
ThingSetMakerByTotalStatUtility.CalculateAllowedThingStuffPairs(allowed, techLevel, qualityGenerator);
float trashThreshold = ThingSetMakerByTotalStatUtility.GetTrashThreshold(countRange, totalValue, getMaxValue);
ThingSetMakerByTotalStatUtility.allowedThingStuffPairs.RemoveAll((ThingStuffPairWithQuality x) => getMaxValue(x) < trashThreshold);
if (!ThingSetMakerByTotalStatUtility.allowedThingStuffPairs.Any <ThingStuffPairWithQuality>())
{
return(chosen);
}
float minCandidateValueEver = float.MaxValue;
float maxCandidateValueEver = float.MinValue;
float minMassEver = float.MaxValue;
foreach (ThingStuffPairWithQuality thingStuffPairWithQuality in ThingSetMakerByTotalStatUtility.allowedThingStuffPairs)
{
minCandidateValueEver = Mathf.Min(minCandidateValueEver, getMinValue(thingStuffPairWithQuality));
maxCandidateValueEver = Mathf.Max(maxCandidateValueEver, getMaxValue(thingStuffPairWithQuality));
if (thingStuffPairWithQuality.thing.category != ThingCategory.Pawn)
{
minMassEver = Mathf.Min(minMassEver, ThingSetMakerByTotalStatUtility.GetNonTrashMass(thingStuffPairWithQuality, trashThreshold, getMinValue));
}
}
minCandidateValueEver = Mathf.Max(minCandidateValueEver, trashThreshold);
float totalMinValueSoFar = 0f;
float totalMaxValueSoFar = 0f;
float minMassSoFar = 0f;
int num = 0;
for (;;)
{
num++;
if (num > 10000)
{
break;
}
IEnumerable <ThingStuffPairWithQuality> enumerable = ThingSetMakerByTotalStatUtility.allowedThingStuffPairs.Where(delegate(ThingStuffPairWithQuality x)
{
if (maxMass != 3.40282347E+38f && x.thing.category != ThingCategory.Pawn)
{
float nonTrashMass = ThingSetMakerByTotalStatUtility.GetNonTrashMass(x, trashThreshold, getMinValue);
if (minMassSoFar + nonTrashMass > maxMass)
{
return(false);
}
if (chosen.Count < countRange.min && minMassSoFar + minMassEver * (float)(countRange.min - chosen.Count - 1) + nonTrashMass > maxMass)
{
return(false);
}
}
return(totalMinValueSoFar + Mathf.Max(getMinValue(x), trashThreshold) <= totalValue && (chosen.Count >= countRange.min || totalMinValueSoFar + minCandidateValueEver * (float)(countRange.min - chosen.Count - 1) + Mathf.Max(getMinValue(x), trashThreshold) <= totalValue));
});
if (countRange.max != 2147483647 && totalMaxValueSoFar < totalValue * 0.5f)
{
IEnumerable <ThingStuffPairWithQuality> enumerable2 = enumerable;
enumerable = from x in enumerable
where totalMaxValueSoFar + maxCandidateValueEver * (float)(countRange.max - chosen.Count - 1) + getMaxValue(x) >= totalValue * 0.5f
select x;
if (!enumerable.Any <ThingStuffPairWithQuality>())
{
enumerable = enumerable2;
}
}
float maxCandidateMinValue = float.MinValue;
foreach (ThingStuffPairWithQuality arg in enumerable)
{
maxCandidateMinValue = Mathf.Max(maxCandidateMinValue, Mathf.Max(getMinValue(arg), trashThreshold));
}
ThingStuffPairWithQuality thingStuffPairWithQuality2;
if (!enumerable.TryRandomElementByWeight(delegate(ThingStuffPairWithQuality x)
{
float a = 1f;
if (countRange.max != 2147483647 && chosen.Count < countRange.max && totalValue >= totalMaxValueSoFar)
{
int num2 = countRange.max - chosen.Count;
float b = (totalValue - totalMaxValueSoFar) / (float)num2;
a = Mathf.InverseLerp(0f, b, getMaxValue(x));
}
float b2 = 1f;
if (chosen.Count < countRange.min && totalValue >= totalMinValueSoFar)
{
int num3 = countRange.min - chosen.Count;
float num4 = (totalValue - totalMinValueSoFar) / (float)num3;
float num5 = Mathf.Max(getMinValue(x), trashThreshold);
if (num5 > num4)
{
b2 = num4 / num5;
}
}
float num6 = Mathf.Max(Mathf.Min(a, b2), 1E-05f);
if (weightSelector != null)
{
num6 *= weightSelector(x.thing);
}
if (totalValue > totalMaxValueSoFar)
{
int num7 = Mathf.Max(countRange.min - chosen.Count, 1);
float num8 = Mathf.InverseLerp(0f, maxCandidateMinValue * 0.85f, ThingSetMakerByTotalStatUtility.GetMaxValueWithMaxMass(x, minMassSoFar, maxMass, getMinValue, getMaxValue) * (float)num7);
num6 *= num8 * num8;
}
if (PawnWeaponGenerator.IsDerpWeapon(x.thing, x.stuff))
{
num6 *= 0.1f;
}
if (techLevel != TechLevel.Undefined)
{
TechLevel techLevel2 = x.thing.techLevel;
if (techLevel2 < techLevel && techLevel2 <= TechLevel.Neolithic && (x.thing.IsApparel || x.thing.IsWeapon))
{
num6 *= 0.1f;
}
}
return(num6);
}, out thingStuffPairWithQuality2))
{
goto Block_10;
}
chosen.Add(thingStuffPairWithQuality2);
totalMinValueSoFar += Mathf.Max(getMinValue(thingStuffPairWithQuality2), trashThreshold);
totalMaxValueSoFar += getMaxValue(thingStuffPairWithQuality2);
if (thingStuffPairWithQuality2.thing.category != ThingCategory.Pawn)
{
minMassSoFar += ThingSetMakerByTotalStatUtility.GetNonTrashMass(thingStuffPairWithQuality2, trashThreshold, getMinValue);
}
if (chosen.Count >= countRange.max)
{
goto Block_12;
}
if (chosen.Count >= countRange.min && totalMaxValueSoFar >= totalValue * 0.9f)
{
goto Block_14;
}
}
Log.Error("Too many iterations.", false);
Block_10:
Block_12:
Block_14:
return(chosen);
}
internal static void MakeTableWeaponPairs()
{
DebugTables.MakeTablesDialog(from p in PawnWeaponGenerator.allWeaponPairs
orderby p.thing.defName descending
select p, new TableDataGetter <ThingStuffPair>("thing", (ThingStuffPair p) => p.thing.defName), new TableDataGetter <ThingStuffPair>("stuff", (ThingStuffPair p) => (p.stuff == null) ? string.Empty : p.stuff.defName), new TableDataGetter <ThingStuffPair>("price", (ThingStuffPair p) => p.Price.ToString()), new TableDataGetter <ThingStuffPair>("commonality", (ThingStuffPair p) => p.Commonality.ToString("F5")), new TableDataGetter <ThingStuffPair>("commMult", (ThingStuffPair p) => p.commonalityMultiplier.ToString("F5")), new TableDataGetter <ThingStuffPair>("def-commonality", (ThingStuffPair p) => p.thing.generateCommonality.ToString("F2")), new TableDataGetter <ThingStuffPair>("derp", (ThingStuffPair p) => (!PawnWeaponGenerator.IsDerpWeapon(p.thing, p.stuff)) ? string.Empty : "D"));
}
public static List <ThingStuffPairWithQuality> GenerateDefsWithPossibleTotalValue_NewTmp3(IntRange countRange, float totalValue, IEnumerable <ThingDef> allowed, TechLevel techLevel, QualityGenerator qualityGenerator, Func <ThingStuffPairWithQuality, float> getMinValue, Func <ThingStuffPairWithQuality, float> getMaxValue, Func <ThingStuffPairWithQuality, float> getSingleThingValue, Func <ThingDef, float> weightSelector = null, int tries = 100, float maxMass = float.MaxValue, bool allowNonStackableDuplicates = true, float minSingleItemValue = 0f)
{
List <ThingStuffPairWithQuality> chosen = new List <ThingStuffPairWithQuality>();
if (countRange.max <= 0)
{
return(chosen);
}
if (countRange.min < 1)
{
countRange.min = 1;
}
CalculateAllowedThingStuffPairs(allowed, techLevel, qualityGenerator);
float trashThreshold = Mathf.Max(GetTrashThreshold(countRange, totalValue, getMaxValue), minSingleItemValue);
allowedThingStuffPairs.RemoveAll((ThingStuffPairWithQuality x) => getMaxValue(x) < trashThreshold);
if (!allowedThingStuffPairs.Any())
{
return(chosen);
}
float minCandidateValueEver = float.MaxValue;
float maxCandidateValueEver = float.MinValue;
float minMassEver = float.MaxValue;
foreach (ThingStuffPairWithQuality allowedThingStuffPair in allowedThingStuffPairs)
{
minCandidateValueEver = Mathf.Min(minCandidateValueEver, getMinValue(allowedThingStuffPair));
maxCandidateValueEver = Mathf.Max(maxCandidateValueEver, getMaxValue(allowedThingStuffPair));
if (allowedThingStuffPair.thing.category != ThingCategory.Pawn)
{
minMassEver = Mathf.Min(minMassEver, GetNonTrashMass(allowedThingStuffPair, trashThreshold, getMinValue));
}
}
minCandidateValueEver = Mathf.Max(minCandidateValueEver, trashThreshold);
float totalMinValueSoFar = 0f;
float totalMaxValueSoFar = 0f;
float minMassSoFar = 0f;
int num = 0;
do
{
num++;
if (num > 10000)
{
Log.Error("Too many iterations.");
break;
}
IEnumerable <ThingStuffPairWithQuality> enumerable = allowedThingStuffPairs.Where(delegate(ThingStuffPairWithQuality x)
{
if (!allowNonStackableDuplicates && x.thing.stackLimit == 1 && chosen.Any((ThingStuffPairWithQuality c) => c.thing == x.thing))
{
return(false);
}
if (maxMass != float.MaxValue && x.thing.category != ThingCategory.Pawn)
{
float nonTrashMass = GetNonTrashMass(x, trashThreshold, getMinValue);
if (minMassSoFar + nonTrashMass > maxMass)
{
return(false);
}
if (chosen.Count < countRange.min && minMassSoFar + minMassEver * (float)(countRange.min - chosen.Count - 1) + nonTrashMass > maxMass)
{
return(false);
}
}
if (totalMinValueSoFar + Mathf.Max(getMinValue(x), trashThreshold) > totalValue)
{
return(false);
}
return((chosen.Count >= countRange.min || !(totalMinValueSoFar + minCandidateValueEver * (float)(countRange.min - chosen.Count - 1) + Mathf.Max(getMinValue(x), trashThreshold) > totalValue)) ? true : false);
});
if (countRange.max != int.MaxValue && totalMaxValueSoFar < totalValue * 0.5f)
{
IEnumerable <ThingStuffPairWithQuality> enumerable2 = enumerable;
enumerable = enumerable.Where((ThingStuffPairWithQuality x) => totalMaxValueSoFar + maxCandidateValueEver * (float)(countRange.max - chosen.Count - 1) + getMaxValue(x) >= totalValue * 0.5f);
if (!enumerable.Any())
{
enumerable = enumerable2;
}
}
float maxCandidateMinValue = float.MinValue;
foreach (ThingStuffPairWithQuality item in enumerable)
{
maxCandidateMinValue = Mathf.Max(maxCandidateMinValue, Mathf.Max(getMinValue(item), trashThreshold));
}
if (!enumerable.TryRandomElementByWeight(delegate(ThingStuffPairWithQuality x)
{
float a = 1f;
if (countRange.max != int.MaxValue && chosen.Count < countRange.max && totalValue >= totalMaxValueSoFar)
{
int num2 = countRange.max - chosen.Count;
float b = (totalValue - totalMaxValueSoFar) / (float)num2;
a = Mathf.InverseLerp(0f, b, getMaxValue(x));
}
float b2 = 1f;
if (chosen.Count < countRange.min && totalValue >= totalMinValueSoFar)
{
int num3 = countRange.min - chosen.Count;
float num4 = (totalValue - totalMinValueSoFar) / (float)num3;
float num5 = Mathf.Max(getMinValue(x), trashThreshold);
if (num5 > num4)
{
b2 = num4 / num5;
}
}
float num6 = Mathf.Max(Mathf.Min(a, b2), 1E-05f);
if (weightSelector != null)
{
num6 *= weightSelector(x.thing);
}
if (totalValue > totalMaxValueSoFar)
{
int num7 = Mathf.Max(countRange.min - chosen.Count, 1);
float num8 = Mathf.InverseLerp(0f, maxCandidateMinValue * 0.85f, GetMaxValueWithMaxMass(x, minMassSoFar, maxMass, getMinValue, getMaxValue) * (float)num7);
num6 *= num8 * num8;
}
if (PawnWeaponGenerator.IsDerpWeapon(x.thing, x.stuff))
{
num6 *= 0.1f;
}
if (techLevel != 0)
{
TechLevel techLevel2 = x.thing.techLevel;
if ((int)techLevel2 < (int)techLevel && (int)techLevel2 <= 2 && (x.thing.IsApparel || x.thing.IsWeapon))
{
num6 *= 0.1f;
}
}
return(num6);
}, out ThingStuffPairWithQuality result))
{
break;
}
chosen.Add(result);
totalMinValueSoFar += Mathf.Max(getMinValue(result), trashThreshold);
totalMaxValueSoFar += getMaxValue(result);
if (result.thing.category != ThingCategory.Pawn)
{
minMassSoFar += GetNonTrashMass(result, trashThreshold, getMinValue);
}
}while (chosen.Count < countRange.max && (chosen.Count < countRange.min || !(totalMaxValueSoFar >= totalValue * 0.9f)));
return(chosen);
}
public static List <ThingStuffPairWithQuality> GenerateDefsWithPossibleTotalValue_NewTmp3(IntRange countRange, float totalValue, IEnumerable <ThingDef> allowed, TechLevel techLevel, QualityGenerator qualityGenerator, Func <ThingStuffPairWithQuality, float> getMinValue, Func <ThingStuffPairWithQuality, float> getMaxValue, Func <ThingStuffPairWithQuality, float> getSingleThingValue, Func <ThingDef, float> weightSelector = null, int tries = 100, float maxMass = float.MaxValue, bool allowNonStackableDuplicates = true, float minSingleItemValue = 0f)
{
minValuesTmp.Clear();
maxValuesTmp.Clear();
List <ThingStuffPairWithQuality> chosen = new List <ThingStuffPairWithQuality>();
if (countRange.max <= 0)
{
return(chosen);
}
if (countRange.min < 1)
{
countRange.min = 1;
}
CalculateAllowedThingStuffPairs(allowed, techLevel, qualityGenerator);
float trashThreshold = Mathf.Max(GetTrashThreshold(countRange, totalValue, MaxValue), minSingleItemValue);
allowedThingStuffPairs.RemoveAll((ThingStuffPairWithQuality x) => MaxValue(x) < trashThreshold);
if (!allowedThingStuffPairs.Any())
{
return(chosen);
}
float a = float.MaxValue;
float num = float.MinValue;
float num2 = float.MaxValue;
foreach (ThingStuffPairWithQuality allowedThingStuffPair in allowedThingStuffPairs)
{
a = Mathf.Min(a, MinValue(allowedThingStuffPair));
num = Mathf.Max(num, MaxValue(allowedThingStuffPair));
if (allowedThingStuffPair.thing.category != ThingCategory.Pawn)
{
num2 = Mathf.Min(num2, GetNonTrashMass(allowedThingStuffPair, trashThreshold, MinValue));
}
}
a = Mathf.Max(a, trashThreshold);
float totalMinValueSoFar = 0f;
float totalMaxValueSoFar = 0f;
float minMassSoFar = 0f;
int num3 = 0;
do
{
num3++;
if (num3 > 10000)
{
Log.Error("Too many iterations.");
break;
}
candidatesTmp.Clear();
for (int i = 0; i < allowedThingStuffPairs.Count; i++)
{
ThingStuffPairWithQuality candidate = allowedThingStuffPairs[i];
if (!allowNonStackableDuplicates && candidate.thing.stackLimit == 1 && chosen.Any((ThingStuffPairWithQuality c) => c.thing == candidate.thing))
{
continue;
}
if (maxMass != float.MaxValue && candidate.thing.category != ThingCategory.Pawn)
{
float nonTrashMass = GetNonTrashMass(candidate, trashThreshold, MinValue);
if (minMassSoFar + nonTrashMass > maxMass || (chosen.Count < countRange.min && minMassSoFar + num2 * (float)(countRange.min - chosen.Count - 1) + nonTrashMass > maxMass))
{
continue;
}
}
if (!(totalMinValueSoFar + Mathf.Max(MinValue(candidate), trashThreshold) > totalValue) && (chosen.Count >= countRange.min || !(totalMinValueSoFar + a * (float)(countRange.min - chosen.Count - 1) + Mathf.Max(MinValue(candidate), trashThreshold) > totalValue)))
{
candidatesTmp.Add(candidate);
}
}
if (countRange.max != int.MaxValue && totalMaxValueSoFar < totalValue * 0.5f)
{
candidatesTmpNew.Clear();
for (int j = 0; j < candidatesTmp.Count; j++)
{
ThingStuffPairWithQuality thingStuffPairWithQuality = candidatesTmp[j];
if (totalMaxValueSoFar + num * (float)(countRange.max - chosen.Count - 1) + MaxValue(thingStuffPairWithQuality) >= totalValue * 0.5f)
{
candidatesTmpNew.Add(thingStuffPairWithQuality);
}
}
if (candidatesTmpNew.Any())
{
candidatesTmp.Clear();
candidatesTmp.AddRange(candidatesTmpNew);
}
}
float maxCandidateMinValue = float.MinValue;
for (int k = 0; k < candidatesTmp.Count; k++)
{
ThingStuffPairWithQuality t2 = candidatesTmp[k];
maxCandidateMinValue = Mathf.Max(maxCandidateMinValue, Mathf.Max(MinValue(t2), trashThreshold));
}
if (!candidatesTmp.TryRandomElementByWeight(delegate(ThingStuffPairWithQuality x)
{
float a2 = 1f;
if (countRange.max != int.MaxValue && chosen.Count < countRange.max && totalValue >= totalMaxValueSoFar)
{
int num4 = countRange.max - chosen.Count;
float b = (totalValue - totalMaxValueSoFar) / (float)num4;
a2 = Mathf.InverseLerp(0f, b, MaxValue(x));
}
float b2 = 1f;
if (chosen.Count < countRange.min && totalValue >= totalMinValueSoFar)
{
int num5 = countRange.min - chosen.Count;
float num6 = (totalValue - totalMinValueSoFar) / (float)num5;
float num7 = Mathf.Max(MinValue(x), trashThreshold);
if (num7 > num6)
{
b2 = num6 / num7;
}
}
float num8 = Mathf.Max(Mathf.Min(a2, b2), 1E-05f);
if (weightSelector != null)
{
num8 *= weightSelector(x.thing);
}
if (totalValue > totalMaxValueSoFar)
{
int num9 = Mathf.Max(countRange.min - chosen.Count, 1);
float num10 = Mathf.InverseLerp(0f, maxCandidateMinValue * 0.85f, GetMaxValueWithMaxMass(x, minMassSoFar, maxMass, MinValue, MaxValue) * (float)num9);
num8 *= num10 * num10;
}
if (PawnWeaponGenerator.IsDerpWeapon(x.thing, x.stuff))
{
num8 *= 0.1f;
}
if (techLevel != 0)
{
TechLevel techLevel2 = x.thing.techLevel;
if ((int)techLevel2 < (int)techLevel && (int)techLevel2 <= 2 && (x.thing.IsApparel || x.thing.IsWeapon))
{
num8 *= 0.1f;
}
}
return(num8);
}, out var result))
{
break;
}
chosen.Add(result);
totalMinValueSoFar += Mathf.Max(MinValue(result), trashThreshold);
totalMaxValueSoFar += MaxValue(result);
if (result.thing.category != ThingCategory.Pawn)
{
minMassSoFar += GetNonTrashMass(result, trashThreshold, MinValue);
}
}while (chosen.Count < countRange.max && (chosen.Count < countRange.min || !(totalMaxValueSoFar >= totalValue * 0.9f)));
return(chosen);
float MaxValue(ThingStuffPairWithQuality t)
{
if (!maxValuesTmp.TryGetValue(t, out var value2))
{
value2 = getMaxValue(t);
maxValuesTmp[t] = value2;
}
return(value2);
}
float MinValue(ThingStuffPairWithQuality t)
{
if (!minValuesTmp.TryGetValue(t, out var value))
{
value = getMinValue(t);
minValuesTmp[t] = value;
}
return(value);
}
}
internal static void MakeTableWeaponPairs()
{
IEnumerable <ThingStuffPair> arg_153_0 = from p in PawnWeaponGenerator.allWeaponPairs
orderby p.thing.defName descending
select p;
TableDataGetter <ThingStuffPair>[] expr_2D = new TableDataGetter <ThingStuffPair> [7];
expr_2D[0] = new TableDataGetter <ThingStuffPair>("thing", (ThingStuffPair p) => p.thing.defName);
expr_2D[1] = new TableDataGetter <ThingStuffPair>("stuff", (ThingStuffPair p) => (p.stuff == null) ? string.Empty : p.stuff.defName);
expr_2D[2] = new TableDataGetter <ThingStuffPair>("price", (ThingStuffPair p) => p.Price.ToString());
expr_2D[3] = new TableDataGetter <ThingStuffPair>("commonality", (ThingStuffPair p) => p.Commonality.ToString("F5"));
expr_2D[4] = new TableDataGetter <ThingStuffPair>("commMult", (ThingStuffPair p) => p.commonalityMultiplier.ToString("F5"));
expr_2D[5] = new TableDataGetter <ThingStuffPair>("def-commonality", (ThingStuffPair p) => p.thing.generateCommonality.ToString("F2"));
expr_2D[6] = new TableDataGetter <ThingStuffPair>("derp", (ThingStuffPair p) => (!PawnWeaponGenerator.IsDerpWeapon(p.thing, p.stuff)) ? string.Empty : "D");
DebugTables.MakeTablesDialog <ThingStuffPair>(arg_153_0, expr_2D);
}
private static string <WeaponPairs> m__A(ThingStuffPair p)
{
return((!PawnWeaponGenerator.IsDerpWeapon(p.thing, p.stuff)) ? string.Empty : "D");
}
private static void WeaponPairs()
{
IEnumerable <ThingStuffPair> dataSources = from p in PawnWeaponGenerator.allWeaponPairs
orderby p.thing.defName descending
select p;
TableDataGetter <ThingStuffPair>[] array = new TableDataGetter <ThingStuffPair> [7];
array[0] = new TableDataGetter <ThingStuffPair>("thing", (ThingStuffPair p) => p.thing.defName);
array[1] = new TableDataGetter <ThingStuffPair>("stuff", (ThingStuffPair p) => (p.stuff == null) ? string.Empty : p.stuff.defName);
array[2] = new TableDataGetter <ThingStuffPair>("price", (ThingStuffPair p) => p.Price.ToString());
array[3] = new TableDataGetter <ThingStuffPair>("commonality", (ThingStuffPair p) => p.Commonality.ToString("F5"));
array[4] = new TableDataGetter <ThingStuffPair>("commMult", (ThingStuffPair p) => p.commonalityMultiplier.ToString("F5"));
array[5] = new TableDataGetter <ThingStuffPair>("generateCommonality", (ThingStuffPair p) => p.thing.generateCommonality.ToString("F2"));
array[6] = new TableDataGetter <ThingStuffPair>("derp", (ThingStuffPair p) => (!PawnWeaponGenerator.IsDerpWeapon(p.thing, p.stuff)) ? string.Empty : "D");
DebugTables.MakeTablesDialog <ThingStuffPair>(dataSources, array);
}
