private void DrawTradeableLabels(Rect rowRect, ThingEntry entry)
{
var trade = entry.tradeable;
if (!trade.HasAnyThing)
{
return;
}
if (Mouse.IsOver(rowRect))
{
Widgets.DrawHighlight(rowRect);
}
var thingIconArea = new Rect(0f, 0f, 27f, 27f);
Widgets.ThingIcon(thingIconArea, trade.AnyThing);
Widgets.InfoCardButton(40f, 0f, trade.AnyThing);
Text.Anchor = TextAnchor.MiddleLeft;
Text.WordWrap = false;
var itemLabelArea = new Rect(80f, 0f, rowRect.width - 80f, rowRect.height);
var itemLabel = trade.LabelCap;
if (entry.animal)
{
itemLabel += " (" + entry.GenderString() + ")";
}
else if (entry.type.HasQuality() && itemLabel.IndexOf("(normal)", StringComparison.Ordinal) != -1)
{
itemLabel = itemLabel.Substring(0, itemLabel.IndexOf("(normal)", StringComparison.Ordinal));
}
Widgets.Label(itemLabelArea, itemLabel);
Text.WordWrap = true;
Transferable localTrad = trade;
TooltipHandler.TipRegion(
rowRect,
new TipSignal(
() =>
{
if (!localTrad.HasAnyThing)
{
return(string.Empty);
}
var text = trade.LabelCap;
var tipDescription = localTrad.TipDescription;
if (!tipDescription.NullOrEmpty())
{
text = text + ": " + tipDescription;
}
return(text);
},
localTrad.GetHashCode()));
}
public ThingEntry Clone()
{
var cloned = new ThingEntry
{
def = def,
stuffDef = stuffDef,
gender = gender,
tradeable = tradeable == null
? null
: new Tradeable(tradeable.FirstThingColony, tradeable.FirstThingTrader),
thing = thing,
pawnDef = pawnDef,
type = type,
stackSize = stackSize,
cost = cost,
color = color,
stacks = stacks,
gear = gear,
animal = animal,
label = label,
hideFromPortrait = hideFromPortrait
};
return(cloned);
}
private void AddRecordIfNotThereAlready(ThingKey key, ThingEntry record)
{
if (!entries.TryGetValue(key, out _))
{
entries[key] = record;
}
}
private bool isBuyableItem(ThingEntry entry)
{
if (entry.animal)
{
return(!RestrictedItems.Contains(entry.pawnDef));
}
return(!RestrictedItems.Contains(entry.def));
}
public ThingEntry AddThingDefWithStuff(ThingDef def, ThingDef stuff, ThingType type)
{
ThingKey key = new ThingKey(def, stuff);
ThingEntry entry = CreateThingEntry(def, stuff, type);
if (entry != null)
{
AddRecordIfNotThereAlready(key, entry);
}
return(entry);
}
protected bool AddRecordIfNotThereAlready(ThingKey key, ThingEntry record)
{
if (entries.TryGetValue(key, out ThingEntry value))
{
return(false);
}
else
{
entries[key] = record;
return(true);
}
}
protected void AddThingDef(ThingDef def, ThingType type)
{
if (def.MadeFromStuff)
{
foreach (var s in stuff)
{
if (s.stuffProps.CanMake(def))
{
ThingKey key = new ThingKey(def, s);
ThingEntry entry = CreateThingEntry(def, s, type);
if (entry != null)
{
AddRecordIfNotThereAlready(key, entry);
}
}
}
}
else if (def.race != null && def.race.Animal)
{
if (def.race.hasGenders)
{
ThingEntry femaleEntry = CreateThingEntry(def, Gender.Female, type);
if (femaleEntry != null)
{
AddRecordIfNotThereAlready(new ThingKey(def, Gender.Female), femaleEntry);
}
ThingEntry maleEntry = CreateThingEntry(def, Gender.Male, type);
if (maleEntry != null)
{
AddRecordIfNotThereAlready(new ThingKey(def, Gender.Male), maleEntry);
}
}
else
{
ThingKey key = new ThingKey(def, Gender.None);
ThingEntry entry = CreateThingEntry(def, Gender.None, type);
if (entry != null)
{
AddRecordIfNotThereAlready(key, entry);
}
}
}
else
{
ThingKey key = new ThingKey(def, null);
ThingEntry entry = CreateThingEntry(def, null, Gender.None, type);
if (entry != null)
{
AddRecordIfNotThereAlready(key, entry);
}
}
}
public double CalculateThingCost(ThingKey thingKey)
{
ThingEntry entry = ThingDatabase.Instance.LookupThingEntry(thingKey);
if (entry != null)
{
return(entry.cost);
}
else
{
return(0);
}
}
// MAYBE TODO?: if goodwill > 80 should have change of having more advanced items (some chance
// of containing any number of restricted item on the restricted list)
private void DetermineAllRequestableItems()
{
if (!ThingDatabase.Instance.Loaded)
{
return;
}
List <ThingEntry> thingEntries = (from x in ThingDatabase.Instance.AllThings()
where hasMaximumTechLevel(x, faction.def.techLevel)
where isBuyableItem(x)
select x).ToList();
foreach (ThingEntry originalEntry in thingEntries)
{
ThingEntry thingEntry = originalEntry.Clone();
if (thingEntry.pawnDef != null)
{
Pawn pawn = thingEntry.thing as Pawn;
Tradeable trad = new Tradeable(pawn, pawn);
trad.thingsColony = new List <Thing>();
thingEntry.tradeable = trad;
allRequestableItems.Add(thingEntry);
}
else
{
Thing thing = thingEntry.thing;
thing.stackCount = int.MaxValue;
Tradeable trad = new Tradeable(thing, thing);
if (!trad.IsCurrency)
{
trad.thingsColony = new List <Thing>();
string key = thing.def.label;
if (key != null)
{
if (thing.Stuff != null)
{
key += thing.Stuff.label;
}
if (colonyItemCount.ContainsKey(key))
{
Thing colonyThing = ThingMaker.MakeThing(thing.def, thing.Stuff);
colonyThing.stackCount = colonyItemCount[key];
trad.thingsColony.Add(colonyThing);
}
}
thingEntry.tradeable = trad;
allRequestableItems.Add(thingEntry);
}
}
}
}
private bool hasMaximumTechLevel(ThingEntry entry, TechLevel tLevel)
{
if (entry.def.techLevel > tLevel)
{
return(false);
}
if (RestrictedItems.researchTechCache.ContainsKey(entry.def) &&
RestrictedItems.researchTechCache[entry.def] > tLevel)
{
return(false);
}
if ((entry.def.intricate || entry.def.thingCategories?.Contains(ThingCategoryDefOf.Techprints) == true) &&
tLevel < TechLevel.Industrial)
{
return(false);
}
if (entry.def.thingClass == typeof(Building) &&
(!entry.def.Minifiable || entry.def.designationCategory == null))
{
return(false);
}
if (entry.def.destroyOnDrop || entry.def.menuHidden)
{
return(false);
}
return(true);
/*
* var lvl = (int)entry.def.techLevel;
*
* // there's probably a better way to test for an advanced component but oh well
* if (entry.thing.def.label == "advanced component" && (int)tLevel < (int)TechLevel.Industrial)
* {
* return false;
* }
*
* if (lvl > 1)
* {
* // Current tech level or one level beneath
* return lvl <= (int)tLevel && lvl >= (int)tLevel - 1;
* }
*
* return lvl <= (int)tLevel;
*/
}
private bool hasMaximumTechLevel(ThingEntry entry, TechLevel tLevel)
{
int lvl = (int)entry.def.techLevel;
// there's probably a better way to test for an advanced component but oh well
if (entry.thing.def.label == "advanced component" && (int)tLevel < (int)TechLevel.Industrial)
{
return(false);
}
if (lvl > 1)
{
// Current tech level or one level beneath
return(lvl <= (int)tLevel && lvl >= ((int)tLevel) - 1);
}
return(lvl <= (int)tLevel);
}
public void AdjustItemRequest(ThingType thingTypeFilter, ThingEntry entry, int numRequested, float price)
{
int key = entry.tradeable.GetHashCode();
if (requestedItems[thingTypeFilter].dict.ContainsKey(key))
{
int amount = Mathf.Max(numRequested, 0);
if (amount == 0)
{
//Log.Message("Requested: " + numRequested.ToString());
//Log.Message(requestedItems[thingTypeFilter].Count.ToString() + " items in current filter");
requestedItems[thingTypeFilter].dict.Remove(key);
//Log.Message("Colony just removed request for " + entry.tradeable.ThingDef.LabelCap);
}
else if (amount == requestedItems[thingTypeFilter].dict[key].amount)
{
return;
}
else
{
requestedItems[thingTypeFilter].dict[key] = new RequestItem
{
item = entry,
amount = amount,
pricePerItem = price,
isPawn = entry.pawnDef != null
};
//Log.Message("Colony just adjusted request for " + entry.tradeable.ThingDef.LabelCap + " to " + numRequested);
}
}
else if (numRequested > 0)
{
requestedItems[thingTypeFilter].dict[key] = new RequestItem
{
item = entry,
amount = numRequested,
pricePerItem = price,
isPawn = entry.pawnDef != null
};
//Log.Message("Colony just requested " + entry.tradeable.ThingDef.LabelCap + " x" + numRequested + (entry.pawnDef != null ? " (" + entry.gender + ")" : ""));
}
}
public ThingEntry Clone()
{
ThingEntry cloned = new ThingEntry();
cloned.def = def;
cloned.stuffDef = stuffDef;
cloned.gender = gender;
cloned.tradeable = tradeable == null ?
null :
new Tradeable(tradeable.FirstThingColony, tradeable.FirstThingTrader);
cloned.thing = thing;
cloned.pawnDef = pawnDef;
cloned.type = type;
cloned.stackSize = stackSize;
cloned.cost = cost;
cloned.color = color;
cloned.stacks = stacks;
cloned.gear = gear;
cloned.animal = animal;
cloned.label = label;
cloned.hideFromPortrait = hideFromPortrait;
return(cloned);
}
private void FilterRequestableItems()
{
if (!ThingDatabase.Instance.Loaded)
{
return;
}
filteredRequestableItems.Clear();
List <ThingEntry> thingEntries = (from x in ThingDatabase.Instance.AllThingsOfType(thingTypeFilter)
where hasMaximumTechLevel(x, faction.def.techLevel)
select x).ToList();
foreach (ThingEntry thingEntry in thingEntries)
{
if (thingEntry.def == ThingDefOf.Silver)
{
continue;
}
ThingEntry foundEntry = GetTradeableThingEntry(thingEntry.thing);
if (foundEntry == null)
{
//Log.Warning("Could not find matching TradeableThingEntry for " + thingEntry.Label);
continue;
}
else
{
bool madeOfRightStuff = stuffTypeFilter == null || foundEntry.tradeable.FirstThingTrader.Stuff == stuffTypeFilter;
if (madeOfRightStuff)
{
filteredRequestableItems.Add(foundEntry);
}
}
}
//Log.Message("There are " + filteredRequestableItems.Count.ToString() + " requestable items to show for filter " +
// thingTypeFilter.ToString() + " and for stuff " + (stuffTypeFilter == null ? " all" : stuffTypeFilter.LabelCap));
}
private void DrawTradeableRow(Rect rowRect, ThingEntry entry, int index)
{
if (index % 2 == 1)
{
Widgets.DrawLightHighlight(rowRect);
}
var trade = entry.tradeable;
// Begin Row group
GUI.BeginGroup(rowRect);
float x = 0; // starting from left
// Draw item icon and info icon
Text.Anchor = TextAnchor.MiddleLeft;
var idRect = new Rect(x, 0, iconNameAreaWidth, rowRect.height);
TransferableUIUtility.DoExtraAnimalIcons(trade, rowRect, ref x);
DrawTradeableLabels(idRect, entry);
x += iconNameAreaWidth;
// Draw the price for requesting the item
var priceTextArea = new Rect(x, 0, priceTextAreaWidth, rowRect.height);
var price = DrawPrice(priceTextArea, trade);
x += priceTextAreaWidth;
// Draw the number the colony currently has, if any
var countHeldBy = trade.CountHeldBy(Transactor.Colony);
if (countHeldBy != 0)
{
var colonyItemCountArea = new Rect(x, 0, colonyItemCountAreaWidth, rowRect.height);
if (Mouse.IsOver(colonyItemCountArea))
{
Widgets.DrawHighlight(colonyItemCountArea);
}
var paddedRect = colonyItemCountArea;
paddedRect.xMin += 5f;
paddedRect.xMax -= 5f;
Widgets.Label(paddedRect, countHeldBy.ToStringCached());
TooltipHandler.TipRegion(colonyItemCountArea, colonyCountTooltipText);
}
// Draw the input box to select number of requests
var countAdjustInterfaceRect = new Rect(rightAlignOffset, 0, rightContentSize, rowRect.height);
var interactiveNumericFieldArea = new Rect(countAdjustInterfaceRect.center.x - 45f,
countAdjustInterfaceRect.center.y - 12.5f, 90f, 25f).Rounded();
var paddedNumericFieldArea = interactiveNumericFieldArea.ContractedBy(2f);
paddedNumericFieldArea.xMax -= 15f;
paddedNumericFieldArea.xMin += 16f;
if (requestSession?.deal != null)
{
var amountRequested = requestSession.deal.GetCountForItem(thingTypeFilter, trade);
var amountAsString = amountRequested.ToString();
Widgets.TextFieldNumeric(paddedNumericFieldArea, ref amountRequested, ref amountAsString, 0,
float.MaxValue);
requestSession.deal.AdjustItemRequest(thingTypeFilter, entry, amountRequested, price);
// Draw the reset to zero button by input field
if (amountRequested > 0)
{
var resetToZeroButton = interactiveNumericFieldArea;
resetToZeroButton.x -= resetItemCountAreaWidth - 5;
resetToZeroButton.width = resetItemCountAreaWidth;
if (Widgets.ButtonText(resetToZeroButton, "0"))
{
requestSession.deal.AdjustItemRequest(thingTypeFilter, entry, 0, price);
}
}
}
// End Row group
GenUI.ResetLabelAlign();
GUI.EndGroup();
}
private ThingEntry CreateThingEntry(ThingDef def, ThingDef stuffDef, Gender gender, ThingType type)
{
var baseCost = costs.GetBaseThingCost(def, stuffDef);
if (baseCost == 0)
{
return(null);
}
var stackSize = CalculateStackCount();
var result = new ThingEntry
{
type = type,
def = def,
stuffDef = stuffDef,
stackSize = stackSize,
cost = costs.CalculateStackCost(def, stuffDef, baseCost),
stacks = true,
gear = false,
animal = false
};
if (def.MadeFromStuff && stuffDef != null)
{
if (stuffDef.stuffProps.allowColorGenerators &&
(def.colorGenerator != null || def.colorGeneratorInTraderStock != null))
{
if (def.colorGenerator != null)
{
result.color = def.colorGenerator.NewRandomizedColor();
}
else if (def.colorGeneratorInTraderStock != null)
{
result.color = def.colorGeneratorInTraderStock.NewRandomizedColor();
}
}
else
{
result.color = stuffDef.stuffProps.color;
}
}
else
{
result.color = def.graphicData?.color ?? Color.white;
}
if (def.apparel != null)
{
result.stacks = false;
result.gear = true;
}
if (def.weaponTags != null && def.weaponTags.Count > 0)
{
result.stacks = false;
result.gear = true;
}
if (def.thingCategories != null)
{
if (def.thingCategories.SingleOrDefault(d => d.defName == "FoodMeals") != null)
{
result.gear = true;
}
if (def.thingCategories.SingleOrDefault(d => d.defName == "Medicine") != null)
{
result.gear = true;
}
}
if (def.defName == "Apparel_PersonalShield")
{
result.hideFromPortrait = true;
}
if (def.race != null && def.race.Animal)
{
result.animal = true;
result.gender = gender;
try
{
var pawn = CreatePawn(def, gender);
if (pawn == null)
{
return(null);
}
result.thing = pawn;
result.pawnDef = pawn.kindDef;
}
catch (Exception)
{
Log.Warning("Failed to create a pawn for animal thing entry: " + def.defName);
//Log.Message(" Exception message: " + e);
return(null);
}
}
result.thing ??= ThingMaker.MakeThing(def, stuffDef);
return(result);
}
public static string GenderString(this ThingEntry entry)
{
return(entry.gender.ToString().ToLower());
}
