/// <summary> /// Draw stuff names and info icon buttons as headers for stat table. /// </summary> /// <param name="startRect"> Rect for drawing stats. </param> /// <param name="start"> Start index from which <paramref name="pairListToDraw"/> should begin to read. </param> /// <param name="end"> End index which is one greater than the index at which <paramref name="pairListToDraw"/> should stop reading. </param> /// <param name="pairListToDraw"> A working set of <see cref="TSPWQuality"/>. </param> private static void DrawStatTableHeader(Rect startRect, int start, int end, List <TSPWQuality> pairListToDraw) { Text.Anchor = TextAnchor.MiddleCenter; Text.WordWrap = false; for (int i = start; i < pairListToDraw.Count && i < end; i++) { TSPWQuality pair = pairListToDraw[i]; Rect buttonRect = startRect.ReplaceWidth(GenUI.SmallIconSize); if (Widgets.ButtonImage(buttonRect, TexResource.Info)) { Thing thing = pair.MakeThingWithoutID(); Find.WindowStack.Add(new Dialog_InfoCard(thing)); } Rect labelRect = startRect.ReplacexMin(buttonRect.xMax + GenUI.GapTiny); string text = pair.stuff != null?pair.stuff.LabelAsStuff.CapitalizeFirst().ColorizeByQuality(pair.Quality) : pair.thing.LabelCap.ToString(); labelRect.width -= GenUI.GapTiny; if (text.StripTags().GetWidthCached() > labelRect.width) { Text.Anchor = TextAnchor.MiddleLeft; } Widgets.Label(labelRect, text); startRect = startRect.ReplaceX(startRect.xMax); } Text.Anchor = TextAnchor.UpperLeft; Text.WordWrap = true; }
private static void DrawRangedStatRows(List <TSPWQuality> pairList, Rect startRect, int from, int to) { List <List <StatDrawInfo> > listHolder = new List <List <StatDrawInfo> >(); List <List <StatDrawInfo> > transposedLists = new List <List <StatDrawInfo> >(); // listHolder[0] listHolder[1] // | stuff1 | | stuff2 | // | Damage | | Damage | // | AP | | AP | /* stuff1 stuff2 * transposedLists[0] Damage Damage * transposedLists[1] AP AP */ for (int i = from; i < to && i < pairList.Count; i++) { TSPWQuality pair = pairList[i]; List <StatDrawInfo> infoList = new List <StatDrawInfo>(); infoList.AddRange(pair.thing.SpecialDisplayStats(StatRequest.For(pair.thing, pair.stuff, pair.Quality)) .Where(r => _rangedWeaponStats.Any(s => s.label.CapitalizeFirst() == r.LabelCap)) .Select(r => (StatDrawInfo)r) .ToList()); listHolder.Add(infoList); } // Transpose lists for (int i = 0; i < _rangedWeaponStats.Count; i++) { List <StatDrawInfo> newList = new List <StatDrawInfo>(); foreach (List <StatDrawInfo> list in listHolder) { newList.Add( list.Find(s => s.LabelCap == _rangedWeaponStats[i].label.CapitalizeFirst()) ?? new StatDrawInfo() { ValueString = "-", Tip = string.Empty, }); } if (newList.Count > 1) { List <StatDrawInfo> orderedList = newList.OrderByDescending(t => t.Value).ToList(); foreach (StatDrawInfo statDrawInfo in orderedList) { if (statDrawInfo.Value == orderedList[0].Value) { statDrawInfo.Color = Color.green; } } } transposedLists.Add(newList); } DrawStatRows(_rangedWeaponStats, null, startRect, from, to, out _, transposedLists, true); }
private static float GetMaxValueWithMaxMass(ThingStuffPairWithQuality t, float massSoFar, float maxMass, Func <ThingStuffPairWithQuality, float> getMinValue, Func <ThingStuffPairWithQuality, float> getMaxValue) { if (maxMass == 3.40282347E+38f) { return(getMaxValue(t)); } int num = Mathf.Clamp(Mathf.FloorToInt((maxMass - massSoFar) / t.GetStatValue(StatDefOf.Mass)), 1, t.thing.stackLimit); return(getMinValue(t) * (float)num); }
public static IEnumerable <GenUI.AnonymousStackElement> GetRewardStackElementsForThings(IEnumerable <Reward_Items.RememberedItem> thingDefs) { tmpThingDefs.Clear(); foreach (Reward_Items.RememberedItem thingDef in thingDefs) { bool flag = false; for (int j = 0; j < tmpThingDefs.Count; j++) { if (tmpThingDefs[j].thing == thingDef.thing && tmpThingDefs[j].label == thingDef.label) { tmpThingDefs[j] = new Reward_Items.RememberedItem(tmpThingDefs[j].thing, tmpThingDefs[j].stackCount + thingDef.stackCount, tmpThingDefs[j].label); flag = true; break; } } if (!flag) { tmpThingDefs.Add(thingDef); } } for (int i = 0; i < tmpThingDefs.Count; i++) { ThingStuffPairWithQuality thing = tmpThingDefs[i].thing; int stackCount = tmpThingDefs[i].stackCount; string label = tmpThingDefs[i].label.CapitalizeFirst() + ((stackCount > 1) ? (" x" + stackCount) : ""); yield return(new GenUI.AnonymousStackElement { drawer = delegate(Rect rect) { Widgets.DrawHighlight(rect); Rect rect2 = new Rect(rect.x + 6f, rect.y + 1f, rect.width - 12f, rect.height - 2f); if (Mouse.IsOver(rect)) { Widgets.DrawHighlight(rect); TooltipHandler.TipRegion(rect, thing.thing.DescriptionDetailed + "\n\n" + "ClickForMoreInfo".Translate()); } Widgets.ThingIcon(new Rect(rect2.x, rect2.y, 22f, 22f), thing.thing, thing.stuff); Rect rect3 = rect2; rect3.xMin += 24f; Widgets.Label(rect3, label); if (Widgets.ButtonInvisible(rect)) { Find.WindowStack.Add(new Dialog_InfoCard(thing.thing, thing.stuff)); } }, width = Text.CalcSize(label).x + 12f + 22f + 2f }); } }
private static Thing MakeThingSimple(TSP pair) { ThingWithComps thing = new ThingWithComps(); CompQuality compQuality = new CompQuality { parent = thing }; Traverse.Create(thing).Field("comps").SetValue(new List <ThingComp>()).Method("Add", compQuality).GetValue(); Trace.WriteLine(thing.AllComps.Count); thing.def = pair.thing; thing.SetStuffDirect(pair.stuff); if (thing.TryGetComp <CompQuality>() == null) { Trace.WriteLine(thing.AllComps[0].GetType()); Trace.WriteLine(thing.AllComps[0] as CompQuality == null ? "null" : "no"); Trace.WriteLine(typeof(CompQuality)); Trace.WriteLine("quality is null"); } thing.TryGetComp <CompQuality>().SetQuality(pair.Quality, ArtGenerationContext.Outsider); return(thing); }
private float GetMinValue(ThingStuffPairWithQuality thingStuffPair) { return(thingStuffPair.GetStatValue(StatDefOf.MarketValue) * (float)thingStuffPair.thing.minRewardCount); }
internal bool <> m__0(ThingStuffPairWithQuality x) { return(this.getMaxValue(x) < this.trashThreshold); }
private static void DrawStatRows(List <StatDef> stats, List <TSPWQuality> pairs, Rect startRect, int from, int to, out float rollingY, List <List <StatDrawInfo> > listHolder = null, bool specialStats = false) { float startX = startRect.x; for (int i = 0; i < stats.Count; i++) { List <StatDrawInfo> statInfoList = new List <StatDrawInfo>(); if (!specialStats) { statInfoList = new List <StatDrawInfo>(); // Retrieve stat value and create a view model, StatDrawInfo, for drawing. for (int j = from; j < to && j < pairs.Count; j++) { TSPWQuality pair = pairs[j]; StatDrawInfo drawInfo = new StatDrawInfo(); Thing tempThing = pair.MakeThingWithoutID(); StatRequest statRequest = StatRequest.For(tempThing); if ((stats[i].Worker.ShouldShowFor(statRequest) && !stats[i].Worker.IsDisabledFor(tempThing)) || stats[i] == StatDefOf.MaxHitPoints || stats[i] == StatDefOf.MeleeWeapon_CooldownMultiplier) { drawInfo.StatRequest = statRequest; drawInfo.Value = GetCachedValue(_statCache, () => stats[i].Worker.GetValue(drawInfo.StatRequest), pair, stats[i]); drawInfo.Tip = GetCachedValue(_statTipCache, () => stats[i].Worker.GetExplanationFull(drawInfo.StatRequest, stats[i].toStringNumberSense, drawInfo.Value), pair, stats[i]); } else { drawInfo.Value = -1; drawInfo.Tip = string.Empty; } statInfoList.Add(drawInfo); } if (statInfoList.Count > 1) { // Highlight highest stat value. List <StatDrawInfo> orderedList = statInfoList.OrderByDescending(t => t.Value).ToList(); foreach (StatDrawInfo statDrawInfo in orderedList) { if (statDrawInfo.Value == orderedList[0].Value) { statDrawInfo.Color = Color.green; } } } } else { statInfoList = listHolder[i]; } #pragma warning disable SA1118 // Parameter should not span multiple lines // Draw stat for each stuff choice. Text.Anchor = TextAnchor.MiddleCenter; foreach (StatDrawInfo info in statInfoList) { GUI.color = info.Color; Widgets.Label( startRect, specialStats ? info.ValueString : info.Value == -1 ? "-" : stats[i].Worker.ValueToString(info.Value, true, stats[i].toStringNumberSense)); Widgets.DrawHighlightIfMouseover(startRect); Text.Anchor = TextAnchor.MiddleLeft; TooltipHandler.TipRegion(startRect, info.Tip); Text.Anchor = TextAnchor.MiddleCenter; startRect = startRect.ReplaceX(startRect.xMax); } #pragma warning restore SA1118 // Parameter should not span multiple lines startRect = new Rect(startX, startRect.yMax, startRect.width, startRect.height); } rollingY = startRect.y; Text.Anchor = TextAnchor.UpperLeft; GUI.color = Color.white; }
private static float GetNonTrashMass(ThingStuffPairWithQuality t, float trashThreshold, Func <ThingStuffPairWithQuality, float> getMinValue) { int num = Mathf.Clamp(Mathf.CeilToInt(trashThreshold / getMinValue(t)), 1, t.thing.stackLimit); return(t.GetStatValue(StatDefOf.Mass) * (float)num); }
private float GetMaxValue(ThingStuffPairWithQuality thingStuffPair) { return(this.GetMinValue(thingStuffPair) * (float)thingStuffPair.thing.stackLimit); }
private float GetMinValue(ThingStuffPairWithQuality thingStuffPair) { return(thingStuffPair.GetStatValue(StatDefOf.MarketValue)); }
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); } }
private float GetMaxValue(ThingStuffPairWithQuality thingStuffPair) { return(thingStuffPair.GetStatValue(StatDefOf.MarketValue) * (float)thingStuffPair.thing.stackLimit); }
private static T GetCachedValue <T>(Dictionary <TSPWQuality, Dictionary <StatDef, T> > cache, Func <T> valueGetter, TSPWQuality pair, StatDef statDef) { if (cache.TryGetValue(pair, out Dictionary <StatDef, T> cachedValues)) { if (cachedValues.TryGetValue(statDef, out T cacheValue)) { return(cacheValue); } else { cacheValue = valueGetter(); cachedValues[statDef] = cacheValue; return(cacheValue); } } else { T statValue = valueGetter(); cachedValues = new Dictionary <StatDef, T>(); cache[pair] = cachedValues; cachedValues[statDef] = statValue; return(statValue); } }
private static float <GeneratePossibleDefs> m__4(ThingStuffPairWithQuality x) { return(x.GetStatValue(StatDefOf.Nutrition) * (float)x.thing.stackLimit); }
private static float <GeneratePossibleDefs> m__3(ThingStuffPairWithQuality x) { return(x.GetStatValue(StatDefOf.Nutrition)); }
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 = float.MaxValue) { 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 = GetTrashThreshold(countRange, totalValue, getMaxValue); allowedThingStuffPairs.RemoveAll((ThingStuffPairWithQuality x) => getMaxValue(x) < trashThreshold); if (!allowedThingStuffPairs.Any()) { return(chosen); } float minCandidateValueEver = 3.40282347E+38f; float maxCandidateValueEver = -3.40282347E+38f; float minMassEver = 3.40282347E+38f; foreach (ThingStuffPairWithQuality allowedThingStuffPair in allowedThingStuffPairs) { ThingStuffPairWithQuality current = allowedThingStuffPair; minCandidateValueEver = Mathf.Min(minCandidateValueEver, getMinValue(current)); maxCandidateValueEver = Mathf.Max(maxCandidateValueEver, getMaxValue(current)); if (current.thing.category != ThingCategory.Pawn) { minMassEver = Mathf.Min(minMassEver, GetNonTrashMass(current, 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 (maxMass != 3.40282347E+38f && 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); } if (chosen.Count < countRange.min && totalMinValueSoFar + minCandidateValueEver * (float)(countRange.min - chosen.Count - 1) + Mathf.Max(getMinValue(x), trashThreshold) > totalValue) { return(false); } return(true); }); 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()) { enumerable = enumerable2; } } float maxCandidateMinValue = -3.40282347E+38f; 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 != 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, 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 RememberedItem(ThingStuffPairWithQuality thing, int stackCount, string label) { this.thing = thing; this.stackCount = stackCount; this.label = label; }