public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var skill = item as Skill;
Cooldown = skill.Cooldown;
StaminaCost = skill.StaminaCost;
ManaCost = skill.ManaCost;
DurabilityCost = skill.DurabilityCost;
DurabilityCostPercent = skill.DurabilityCostPercent;
HealthCost = skill.HealthCost;
RequiredPType = skill.RequiredPType;
if (skill.RequiredItems != null)
{
foreach (Skill.ItemRequired itemReq in skill.RequiredItems)
{
if (itemReq.Item != null)
{
RequiredItems.Add(new SkillItemReq
{
ItemID = itemReq.Item.ItemID,
Consume = itemReq.Consume,
Quantity = itemReq.Quantity
});
}
}
}
}
public static void Dump()
{
SL.LogWarning("[Dataminer] Starting full dump!");
// setup tags
for (int i = 1; i < 500; i++)
{
if (TagSourceManager.Instance.GetTag(i.ToString()) is Tag tag)
{
ListManager.AddTagSource(tag, null);
}
}
DM_Item.ParseAllItems();
DM_StatusEffect.ParseAllEffects();
DM_Recipe.ParseAllRecipes();
DM_EnchantmentRecipe.ParseAllRecipes();
SL.LogWarning("Saving early lists...");
ListManager.SaveEarlyLists();
SL.LogWarning("Finished prefab dumping.");
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var comp = item as Throwable;
DestroyDelay = comp.DestroyDelay;
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var comp = item as Blueprint;
DeployableItemID = comp.GetComponent <Deployable>()?.Item?.ItemID ?? -1;
IsUpgrade = comp.IsUpgrade;
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var template = holder as DM_RecipeItem;
var recipeItem = item as RecipeItem;
template.RecipeUID = recipeItem.Recipe.UID;
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var comp = item as Instrument;
PeriodicTime = comp.PeriodicTime;
PulseSpeed = comp.PulseSpeed;
StrikeTime = comp.StrikeTime;
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var template = holder as DM_Armor;
var armor = item as Armor;
template.Class = armor.Class;
template.GearSoundMaterial = armor.GearSoundMaterial;
template.ImpactSoundMaterial = armor.ImpactSoundMaterial;
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var template = holder as DM_RangeAttackSkill;
var skill = item as RangeAttackSkill;
template.AutoLoad = skill.AutoLoad;
template.FakeShoot = skill.FakeShoot;
template.OverrideAimOffset = skill.OverrideAimOffset;
template.AimOffset = skill.AimOffset;
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var template = holder as DM_Equipment;
var equipment = item as Equipment;
template.EquipSlot = equipment.EquipSlot;
template.VisualDetectabilityAdd = equipment.VisualDetectabilityAdd;
template.TwoHandType = equipment.TwoHand;
template.IKType = equipment.IKType;
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var template = holder as DM_TrinketSkill;
var skill = item as TrinketSkill;
template.CompatibleItemIDs = new List <int>();
foreach (var compatItem in skill.CompatibleItems)
{
template.CompatibleItemIDs.Add(compatItem.ItemID);
}
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var template = holder as DM_ThrowSkill;
var skill = item as ThrowSkill;
template.ThrowableItemIDs = new List <int>();
foreach (var throwable in skill.ThrowableItems)
{
template.ThrowableItemIDs.Add(throwable.ItemID);
}
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var template = holder as DM_CounterSkill;
var skill = item as CounterSkill;
template.BlockMult = skill.BlockMult;
template.DamageMult = skill.DamageMult;
template.KnockbackMult = skill.KnockbackMult;
template.BlockDamageTypes = skill.BlockTypes;
template.CounterDamageTypes = skill.CounterTypes;
template.MaxRange = skill.MaxRange;
template.TurnTowardsDealer = skill.TurnTowardsDealer;
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var trap = item as DeployableTrap;
var recipes = (TrapEffectRecipe[])At.GetField(trap, "m_trapRecipes");
foreach (var recipe in recipes)
{
var dmRecipe = new DM_TrapRecipe();
dmRecipe.Serialize(recipe, trap);
TrapRecipeEffects.Add(dmRecipe);
}
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var skill = item as CounterAbsorbSkill;
var template = holder as DM_CounterAbsorbSkill;
template.Absorbs = new List <AbsorbType>();
foreach (var absorb in skill.Absorbs)
{
template.Absorbs.Add(new AbsorbType()
{
Condition = absorb.Condition != null ? (DM_BooleanCondition)DM_EffectCondition.ParseCondition(absorb.Condition) : null,
DamageTypes = absorb.Types
});
}
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var skill = item as MeleeSkill;
Blockable = skill.Blockable;
NoWeaponAtkTag = skill.NoWeaponAtkTag;
if (skill.MeleeHitDetector is MeleeHitDetector detector)
{
Damage = detector.Damage;
Impact = detector.Impact;
LinecastCount = detector.LinecastCount;
Radius = detector.Radius;
Unblockable = detector.Unblockable;
}
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var attackSkill = item as AttackSkill;
AmmunitionTypes = attackSkill.AmmunitionTypes;
RequiredOffHandTypes = attackSkill.RequiredOffHandTypes;
RequiredWeaponTypes = attackSkill.RequiredWeaponTypes;
RequireImbue = attackSkill.RequireImbue;
AmmunitionAmount = attackSkill.AmmunitionAmount;
foreach (var tag in attackSkill.RequiredTags)
{
RequiredWeaponTags.Add(tag.Tag.TagName);
}
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var bag = item as Bag;
var template = holder as DM_Bag;
template.Capacity = bag.BagCapacity;
template.Restrict_Dodge = bag.RestrictDodge;
template.InventoryProtection = bag.InventoryProtection;
if (bag.GetComponentInChildren <Preserver>() is Preserver p &&
At.GetField(p, "m_preservedElements") is List <Preserver.PreservedElement> list &&
list.Count > 0)
{
template.Preserver_Amount = list[0].Preservation;
template.Nullify_Perish = p.NullifyPerishing;
}
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var building = item as Building;
var constructionPhases = At.GetField(building, "m_constructionPhases") as Building.ConstructionPhase[];
foreach (var phase in constructionPhases)
{
ConstructionPhases.Add(DM_ConstructionPhase.SerializePhase(phase));
}
var upgradePhases = At.GetField(building, "m_upgradePhases") as Building.ConstructionPhase[];
foreach (var phase in upgradePhases)
{
UpgradePhases.Add(DM_ConstructionPhase.SerializePhase(phase));
}
}
public override void SerializeItem(Item item, DM_Item holder)
{
base.SerializeItem(item, holder);
var weapon = item as Weapon;
WeaponType = weapon.Type;
Unblockable = weapon.Unblockable;
SwingSound = weapon.SwingSoundType;
SpecialIsZoom = weapon.SpecialIsZoom;
MaxProjectileShots = -1;
BaseHealthAbsorbRatio = weapon.BaseHealthAbsorbRatio;
BaseMaxHealthAbsorbRatio = weapon.BaseMaxHealthAbsorbRatio;
IgnoreHalfResistances = weapon.IgnoreHalfResistances;
if (weapon.GetComponent <WeaponLoadout>() is WeaponLoadout loadout)
{
MaxProjectileShots = loadout.MaxProjectileLoaded;
}
}
private static string GetFullSaveDir(Item item, DM_Item template)
{
string dir;
if (item.GetType() != typeof(Item))
{
dir = GetFolderRecursive(item, "", item.GetType());
}
else
{
if (template.Tags.Contains("Consummable"))
{
dir = "/Consumable";
}
else
{
dir = "/_Unsorted";
}
}
template.saveDir = dir;
return(Serializer.Folders.Items + dir);
}
public virtual void SerializeItem(Item item, DM_Item holder)
{
holder.gameObjectName = item.gameObject.name;
holder.ItemID = item.ItemID;
holder.Name = item.Name;
holder.Description = item.Description;
holder.LegacyItemID = item.LegacyItemID;
holder.CastLocomotionEnabled = item.CastLocomotionEnabled;
holder.CastModifier = item.CastModifier;
holder.CastSheatheRequired = item.CastSheathRequired;
holder.GroupItemInDisplay = item.GroupItemInDisplay;
holder.HasPhysicsWhenWorld = item.HasPhysicsWhenWorld;
holder.IsPickable = item.IsPickable;
holder.IsUsable = item.IsUsable;
holder.QtyRemovedOnUse = item.QtyRemovedOnUse;
holder.MobileCastMovementMult = item.MobileCastMovementMult;
holder.RepairedInRest = item.RepairedInRest;
holder.BehaviorOnNoDurability = item.BehaviorOnNoDurability;
holder.OverrideSellModifier = (float)At.GetField(item, "m_overrideSellModifier");
if (item.GetComponent <Perishable>() is Perishable perish)
{
float perishRate = perish.DepletionRate * 0.03333333f;
float perishModifier = 1 / perishRate;
var remainingTicks = item.MaxDurability * perishModifier; // each tick is 2 in-game minutes (~5 seconds irl)
var minutes = remainingTicks * 2;
TimeSpan t = TimeSpan.FromMinutes(minutes);
holder.PerishTime = $"{t.Days} Days, {t.Hours} Hours, {t.Minutes} Minutes, {t.Seconds} Seconds";
}
holder.CastType = (Character.SpellCastType)At.GetField(item, "m_activateEffectAnimType");
if (item.GetComponent <ItemStats>() is ItemStats stats)
{
holder.StatsHolder = DM_ItemStats.ParseItemStats(stats);
}
if (item.Tags != null)
{
foreach (Tag tag in item.Tags)
{
holder.Tags.Add(tag.TagName);
ListManager.AddTagSource(tag, Serializer.SafeName(item.Name));
}
}
foreach (Transform child in item.transform)
{
var effectsChild = DM_EffectTransform.ParseTransform(child);
if (effectsChild.ChildEffects.Count > 0 || effectsChild.Effects.Count > 0 || effectsChild.EffectConditions.Count > 0)
{
holder.EffectTransforms.Add(effectsChild);
}
}
}
