public static IReadOnlyDictionary <ItemID, Item> UpdateOrCreateMap(IReadOnlyDictionary <ItemID, Item>?sourceMap, ICollection <Initializer> initializers, IReadOnlyDictionary <AnimateID, Animate> animates)
{
SnapshotContainer?snapshot = null;
if (sourceMap != null)
{
snapshot = new();
TakeSnapshots(snapshot, sourceMap);
}
Dictionary <ItemID, Item> items = new(initializers.Count);
var compoundInitializers = new List <Initializer>();
var typedInitializers = new Dictionary <Initializer, Func <Initializer, IReadOnlyDictionary <AnimateID, Animate>, IReadOnlyDictionary <ItemID, Item>, Item> >();
foreach (var initializer in initializers)
{
var createMethod = GetCreateMethod(initializer.ID);
if (createMethod != null)
{
typedInitializers[initializer] = createMethod;
}
else if (initializer.UsableOn != null && initializer.UsableOn.Length > 0)
{
if (initializer.Components != null && initializer.Components.Length == 2)
{
compoundInitializers.Add(initializer);
}
else
{
items[initializer.ID] = RegisterTexts(UsableItem.Create(initializer, animates), initializer);
}
}
else
{
items[initializer.ID] = RegisterTexts(Create(initializer), initializer);
}
}
foreach (var initializer in compoundInitializers)
{
items[initializer.ID] = RegisterTexts(CompoundItem.Create(initializer, animates, items), initializer);
}
foreach (var initializerMethod in typedInitializers)
{
var initializer = initializerMethod.Key;
items[initializer.ID] = RegisterTexts(initializerMethod.Value.Invoke(initializer, animates, items), initializer);
}
if (snapshot != null)
{
RestoreSnapshots(snapshot, items);
}
return(items);
}
private Compound FromStream()
{
var compoundID = _r.ReadUInt32();
// write compoundType
var compoundType = CompoundSpec <TEngine> .GetTypeByID(_r.ReadUInt32());
var spec = CompoundSpec <TEngine> .GetSpec(compoundType);
if (_r.ReadUInt16() != spec.Length)
{
throw new Exception();
}
_s.Seek(spec.Length * sizeof(long), SeekOrigin.Current);
var compoundElements = new CompoundItem[spec.Length][];
for (int specIndex = 0; specIndex < spec.Length; specIndex++)
{
var elementSpec = ElementSpec <TEngine> .GetSpec(spec.Types[specIndex]);
var sizeOfElement = ElementSpec <TEngine> .SizeOfElement;
var stateSizeInBytes = elementSpec.StateSizeInBytes;
if (_r.ReadUInt32() != elementSpec.TotalSizeInBytes)
{
throw new Exception();
}
var elementLength = _r.ReadUInt32();
var elements = new CompoundItem[elementLength];
for (int elementIndex = 0; elementIndex < elementLength; elementIndex++)
{
elements[elementIndex].ID = _r.ReadUInt32();
_s.Seek(sizeOfElement, SeekOrigin.Current);
var remainingPitch = (long)stateSizeInBytes;
var dataSizeInBytes = elementSpec.DataSizeInBytes;
if (dataSizeInBytes > 0)
{
elements[elementIndex].Data = _r.ReadBytes(dataSizeInBytes);
remainingPitch -= dataSizeInBytes;
}
if (remainingPitch < 0)
{
throw new OverflowException("Data larger then StateSize");
}
if (remainingPitch > 0)
{
_s.Seek(remainingPitch, SeekOrigin.Current);
}
}
compoundElements[specIndex] = elements;
}
return(new Compound
{
ID = compoundID,
Elements = compoundElements,
Type = compoundType,
});
}
/// <summary>
/// Registers a new CompoundItem.
/// </summary>
/// <param name="compound">The enum Compound value for this item.</param>
/// <param name="description">The tooltip for this item.</param>
/// <param name="recipe">The recipe for this item.</param>
/// <param name="stackCrafted">How much of this item is crafted per recipe.</param>
/// <param name="defaults">The defaults set for this item's <seealso cref="Item"/> item field.</param>
/// <param name="state">The default ElementState for this compound.</param>
/// <param name="boilingPoint">The boiling point for this compound in Kelvin. Set to -1 for "unstable".</param>
/// <param name="meltingPoint">The melting point for this compound in Kelvin. Set to -1 for "unstable".</param>
/// <param name="elements">The Action for adding elements to this compound's recipe.</param>
/// <param name="gasColor">Optional. Determines the colour for the gas drawn for this element when in the world.</param>
/// <param name="liquid">Optional. The ModLiquid for this element.</param>
/// <param name="isPlaceableBar">Optional. Determines if this metal element is a placeable bar.</param>
internal static void RegisterCompound(Compound compound, string description, Action <ModRecipe> recipe, int stackCrafted, Action <Item> defaults, ElementState state, CompoundClassification classification, float boilingPoint, float meltingPoint, Action <CompoundItem> elements, Color?gasColor = null, ModLiquid liquid = null, bool isPlaceableBar = false)
{
string internalName = CompoundName(compound, false);
CompoundItem item = new CompoundItem(compound,
description,
state,
classification,
gasColor ?? Color.White,
isPlaceableBar,
liquid,
boilingPoint,
meltingPoint,
elements);
mod.AddItem(internalName, item);
//Add the corresponding bar tile if it should exist
// TODO: make a ScienceBar for compounds
if (isPlaceableBar)
{
mod.AddTile(internalName, new ScienceBar(), $"TerraScience/Content/Tiles/{internalName}");
}
//Cache the defaults and recipe so we can use it anytime
TerraScience.CachedCompoundDefaults.Add(internalName, defaults);
TerraScience.CachedCompoundRecipes.Add(internalName,
(r, e) => {
recipe(r);
for (int i = 0; i < item.Elements.Count; i++)
{
Tuple <Element, int> pair = item.Elements[i];
r.AddIngredient(mod.ItemType(ElementUtils.ElementName(pair.Item1)), pair.Item2);
}
r.SetResult(e, stackCrafted);
r.AddRecipe();
});
}
static void Postfix(ref List <CompoundItemData> ___sourceData, ref CompoundTable[] ___m_compoundTable)
{
if (!enabled)
{
return;
}
CompoundItemData cidd = ___sourceData.Find((CompoundItemData c) => c.ItemID == 2000046);
int start = 5000;
int start2 = 5001000;
List <CookMenuData> datas = Singleton <CookMenuMgr> .Instance.DataList;
var TagList = DbReader.Read <CookItemtarget>(LocalDb.cur.ReadFullTable("Cook_TagList"), 20);
foreach (CookMenuData data in datas)
{
try
{
if (data.Mats.Count > 0)
{
CompoundItemData cid = cidd;
cid.NameID = Module <ItemDataMgr> .Self.GetItemNameId(data.Food);
cid.ItemID = data.Food;
List <CookMenuData.Mat> mats = new List <CookMenuData.Mat>();
if (data.Mats[0].ID > 200)
{
mats.Add(data.Mats[0]);
}
else
{
List <CookItemtarget> items = TagList.FindAll((t) => t.Tag.Contains(data.Mats[0].ID));
foreach (CookItemtarget item in items)
{
mats.Add(new CookMenuData.Mat()
{
ID = item.ID,
Num = data.Mats[0].Num
});
}
}
foreach (CookMenuData.Mat mat in mats)
{
cid.RequireItem1 = mat.ID;
cid.RequireItemNum1 = data.Mats[0].Num;
if (data.Mats.Count > 1)
{
List <CookMenuData.Mat> mats2 = new List <CookMenuData.Mat>();
if (data.Mats[1].ID > 200)
{
mats2.Add(data.Mats[1]);
}
else
{
List <CookItemtarget> items = TagList.FindAll((t) => t.Tag.Contains(data.Mats[1].ID));
foreach (CookItemtarget item in items)
{
mats2.Add(new CookMenuData.Mat()
{
ID = item.ID,
Num = data.Mats[1].Num
});
}
}
foreach (CookMenuData.Mat mat2 in mats2)
{
cid.RequireItem2 = mat2.ID;
cid.RequireItemNum2 = data.Mats[1].Num;
if (data.Mats.Count > 2)
{
List <CookMenuData.Mat> mats3 = new List <CookMenuData.Mat>();
if (data.Mats[2].ID > 200)
{
mats3.Add(data.Mats[2]);
}
else
{
List <CookItemtarget> items = TagList.FindAll((t) => t.Tag.Contains(data.Mats[2].ID));
foreach (CookItemtarget item in items)
{
mats3.Add(new CookMenuData.Mat()
{
ID = item.ID,
Num = data.Mats[2].Num
});
}
}
foreach (CookMenuData.Mat mat3 in mats3)
{
cid.RequireItem3 = mat3.ID;
cid.RequireItemNum3 = data.Mats[2].Num;
cid.ID = start++;
cid.BookId = start2++;
CompoundItem ci = new CompoundItem(cid);
___m_compoundTable[(int)cidd.CompoundType].AddItem(ci);
}
}
else
{
cid.ID = start++;
cid.BookId = start2++;
CompoundItem ci = new CompoundItem(cid);
___m_compoundTable[(int)cidd.CompoundType].AddItem(ci);
}
}
}
else
{
cid.ID = start++;
cid.BookId = start2++;
CompoundItem ci = new CompoundItem(cid);
___m_compoundTable[(int)cidd.CompoundType].AddItem(ci);
}
}
}
}
catch (Exception ex)
{
Dbgl("exception: " + ex);
}
}
}
