public override BaseCorpse CreateCorpse()
{
int i;
BaseCorpse baseCorpse;
using (TimeWarning timeWarning = TimeWarning.New("Create corpse", 0.1f))
{
NPCPlayerCorpse nPCPlayerCorpse = base.DropCorpse("assets/prefabs/npc/murderer/murderer_corpse.prefab") as NPCPlayerCorpse;
if (nPCPlayerCorpse)
{
nPCPlayerCorpse.SetLootableIn(2f);
nPCPlayerCorpse.SetFlag(BaseEntity.Flags.Reserved5, base.HasPlayerFlag(BasePlayer.PlayerFlags.DisplaySash), false, true);
nPCPlayerCorpse.SetFlag(BaseEntity.Flags.Reserved2, true, false, true);
int num = 0;
while (num < this.inventory.containerWear.itemList.Count)
{
Item item = this.inventory.containerWear.itemList[num];
if (item == null || !(item.info.shortname == "gloweyes"))
{
num++;
}
else
{
this.inventory.containerWear.Remove(item);
break;
}
}
nPCPlayerCorpse.TakeFrom(new ItemContainer[] { this.inventory.containerMain, this.inventory.containerWear, this.inventory.containerBelt });
nPCPlayerCorpse.playerName = base.displayName;
nPCPlayerCorpse.playerSteamID = this.userID;
nPCPlayerCorpse.Spawn();
nPCPlayerCorpse.TakeChildren(this);
ItemContainer[] itemContainerArray = nPCPlayerCorpse.containers;
for (i = 0; i < (int)itemContainerArray.Length; i++)
{
itemContainerArray[i].Clear();
}
if (this.LootSpawnSlots.Length != 0)
{
LootContainer.LootSpawnSlot[] lootSpawnSlots = this.LootSpawnSlots;
for (i = 0; i < (int)lootSpawnSlots.Length; i++)
{
LootContainer.LootSpawnSlot lootSpawnSlot = lootSpawnSlots[i];
for (int j = 0; j < lootSpawnSlot.numberToSpawn; j++)
{
if (UnityEngine.Random.Range(0f, 1f) <= lootSpawnSlot.probability)
{
lootSpawnSlot.definition.SpawnIntoContainer(nPCPlayerCorpse.containers[0]);
}
}
}
}
}
baseCorpse = nPCPlayerCorpse;
}
return(baseCorpse);
}
public override BaseCorpse OnCreateCorpse(HTNPlayer target)
{
int i;
BaseCorpse baseCorpse;
if (this.DeathEffect.isValid)
{
Effect.server.Run(this.DeathEffect.resourcePath, target, 0, Vector3.zero, Vector3.zero, null, false);
}
using (TimeWarning timeWarning = TimeWarning.New("Create corpse", 0.1f))
{
NPCPlayerCorpse navAgent = target.DropCorpse("assets/prefabs/npc/scientist/scientist_corpse.prefab") as NPCPlayerCorpse;
if (navAgent)
{
if (target.AiDomain != null && target.AiDomain.NavAgent != null && target.AiDomain.NavAgent.isOnNavMesh)
{
navAgent.transform.position = navAgent.transform.position + (Vector3.down * target.AiDomain.NavAgent.baseOffset);
}
navAgent.SetLootableIn(2f);
navAgent.SetFlag(BaseEntity.Flags.Reserved5, target.HasPlayerFlag(BasePlayer.PlayerFlags.DisplaySash), false, true);
navAgent.SetFlag(BaseEntity.Flags.Reserved2, true, false, true);
navAgent.TakeFrom(new ItemContainer[] { target.inventory.containerMain, target.inventory.containerWear, target.inventory.containerBelt });
navAgent.playerName = target.displayName;
navAgent.playerSteamID = target.userID;
navAgent.Spawn();
navAgent.TakeChildren(target);
ItemContainer[] itemContainerArray = navAgent.containers;
for (i = 0; i < (int)itemContainerArray.Length; i++)
{
itemContainerArray[i].Clear();
}
if (this.Loot.Length != 0)
{
LootContainer.LootSpawnSlot[] loot = this.Loot;
for (i = 0; i < (int)loot.Length; i++)
{
LootContainer.LootSpawnSlot lootSpawnSlot = loot[i];
for (int j = 0; j < lootSpawnSlot.numberToSpawn; j++)
{
if (UnityEngine.Random.Range(0f, 1f) <= lootSpawnSlot.probability)
{
lootSpawnSlot.definition.SpawnIntoContainer(navAgent.containers[0]);
}
}
}
}
}
baseCorpse = navAgent;
}
return(baseCorpse);
}
public override BaseCorpse CreateCorpse()
{
using (TimeWarning.New("Create corpse"))
{
NPCPlayerCorpse nPCPlayerCorpse = DropCorpse("assets/prefabs/npc/scientist/scientist_corpse.prefab") as NPCPlayerCorpse;
if ((bool)nPCPlayerCorpse)
{
nPCPlayerCorpse.transform.position = nPCPlayerCorpse.transform.position + Vector3.down * NavAgent.baseOffset;
nPCPlayerCorpse.SetLootableIn(2f);
nPCPlayerCorpse.SetFlag(Flags.Reserved5, HasPlayerFlag(PlayerFlags.DisplaySash));
nPCPlayerCorpse.SetFlag(Flags.Reserved2, true);
nPCPlayerCorpse.TakeFrom(inventory.containerMain, inventory.containerWear, inventory.containerBelt);
nPCPlayerCorpse.playerName = OverrideCorpseName();
nPCPlayerCorpse.playerSteamID = userID;
nPCPlayerCorpse.Spawn();
nPCPlayerCorpse.TakeChildren(this);
ItemContainer[] containers = nPCPlayerCorpse.containers;
for (int i = 0; i < containers.Length; i++)
{
containers[i].Clear();
}
if (LootSpawnSlots.Length != 0)
{
object obj = Interface.CallHook("OnCorpsePopulate", this, nPCPlayerCorpse);
if (obj is BaseCorpse)
{
return((BaseCorpse)obj);
}
LootContainer.LootSpawnSlot[] lootSpawnSlots = LootSpawnSlots;
for (int i = 0; i < lootSpawnSlots.Length; i++)
{
LootContainer.LootSpawnSlot lootSpawnSlot = lootSpawnSlots[i];
for (int j = 0; j < lootSpawnSlot.numberToSpawn; j++)
{
if (UnityEngine.Random.Range(0f, 1f) <= lootSpawnSlot.probability)
{
lootSpawnSlot.definition.SpawnIntoContainer(nPCPlayerCorpse.containers[0]);
}
}
}
}
}
return(nPCPlayerCorpse);
}
}
public virtual void PopulateLoot()
{
if (this.LootSpawnSlots.Length != 0)
{
LootContainer.LootSpawnSlot[] lootSpawnSlots = this.LootSpawnSlots;
for (int i = 0; i < (int)lootSpawnSlots.Length; i++)
{
LootContainer.LootSpawnSlot lootSpawnSlot = lootSpawnSlots[i];
for (int j = 0; j < lootSpawnSlot.numberToSpawn; j++)
{
if (UnityEngine.Random.Range(0f, 1f) <= lootSpawnSlot.probability)
{
lootSpawnSlot.definition.SpawnIntoContainer(this.inventory);
}
}
}
}
else if (this.lootDefinition != null)
{
for (int k = 0; k < this.maxDefinitionsToSpawn; k++)
{
this.lootDefinition.SpawnIntoContainer(this.inventory);
}
}
if (this.SpawnType == LootContainer.spawnType.ROADSIDE || this.SpawnType == LootContainer.spawnType.TOWN)
{
foreach (Item item in this.inventory.itemList)
{
if (!item.hasCondition)
{
continue;
}
item.condition = UnityEngine.Random.Range(item.info.condition.foundCondition.fractionMin, item.info.condition.foundCondition.fractionMax) * item.info.condition.max;
}
}
this.GenerateScrap();
}
void LoadAllContainers()
{
try { lootTable = getFile("LootTables"); }
catch (JsonReaderException e)
{
PrintWarning($"JSON error in 'LootTables' > Line: {e.LineNumber} | {e.Path}");
Interface.GetMod().UnloadPlugin(this.Title);
return;
}
lootTables = new Dictionary <string, object>();
lootTables = lootTable["LootTables"] as Dictionary <string, object>;
if (lootTables == null)
{
lootTables = new Dictionary <string, object>();
}
bool wasAdded = false;
foreach (var lootPrefab in lootPrefabsToUse)
{
if (!lootTables.ContainsKey((string)lootPrefab))
{
var loot = GameManager.server.FindPrefab((string)lootPrefab)?.GetComponent <LootContainer>();
if (loot == null)
{
continue;
}
var container = new Dictionary <string, object>();
container.Add("Enabled", ((((string)lootPrefab).Contains("bradley_crate")) || (((string)lootPrefab).Contains("heli_crate"))) ? false : true);
container.Add("Scrap", loot.scrapAmount);
int slots = 0;
if (loot.LootSpawnSlots.Length > 0)
{
LootContainer.LootSpawnSlot[] lootSpawnSlots = loot.LootSpawnSlots;
for (int i = 0; i < lootSpawnSlots.Length; i++)
{
slots += lootSpawnSlots[i].numberToSpawn;
}
}
else
{
slots = loot.maxDefinitionsToSpawn;
}
container.Add("ItemsMin", slots);
container.Add("ItemsMax", slots);
container.Add("MaxBPs", 1);
var itemList = new Dictionary <string, object>();
if (loot.lootDefinition != null)
{
GetLootSpawn(loot.lootDefinition, ref itemList);
}
else if (loot.LootSpawnSlots.Length > 0)
{
LootContainer.LootSpawnSlot[] lootSpawnSlots = loot.LootSpawnSlots;
for (int i = 0; i < lootSpawnSlots.Length; i++)
{
LootContainer.LootSpawnSlot lootSpawnSlot = lootSpawnSlots[i];
GetLootSpawn(lootSpawnSlot.definition, ref itemList);
}
}
container.Add("ItemList", itemList);
lootTables.Add((string)lootPrefab, container);
wasAdded = true;
}
}
if (wasAdded)
{
lootTable.Set("LootTables", lootTables);
lootTable.Save();
}
wasAdded = false;
bool wasRemoved = false;
int activeTypes = 0;
foreach (var lootTable in lootTables.ToList())
{
var loot = GameManager.server.FindPrefab(lootTable.Key)?.GetComponent <LootContainer>();
if (loot == null)
{
lootTables.Remove(lootTable.Key);
wasRemoved = true;
continue;
}
var container = lootTable.Value as Dictionary <string, object>;
if (!container.ContainsKey("Enabled"))
{
container.Add("Enabled", true);
wasAdded = true;
}
if ((bool)container["Enabled"])
{
activeTypes++;
}
if (!container.ContainsKey("Scrap"))
{
container.Add("Scrap", loot.scrapAmount);
wasAdded = true;
}
int slots = 0;
if (loot.LootSpawnSlots.Length > 0)
{
LootContainer.LootSpawnSlot[] lootSpawnSlots = loot.LootSpawnSlots;
for (int i = 0; i < lootSpawnSlots.Length; i++)
{
slots += lootSpawnSlots[i].numberToSpawn;
}
}
else
{
slots = loot.maxDefinitionsToSpawn;
}
if (!container.ContainsKey("MaxBPs"))
{
container.Add("MaxBPs", 1);
wasAdded = true;
}
if (!container.ContainsKey("ItemsMin"))
{
container.Add("ItemsMin", slots);
wasAdded = true;
}
if (!container.ContainsKey("ItemsMax"))
{
container.Add("ItemsMax", slots);
wasAdded = true;
}
if (!container.ContainsKey("ItemsMax"))
{
container.Add("ItemsMax", slots);
wasAdded = true;
}
if (!container.ContainsKey("ItemList"))
{
var itemList = new Dictionary <string, object>();
if (loot.lootDefinition != null)
{
GetLootSpawn(loot.lootDefinition, ref itemList);
}
else if (loot.LootSpawnSlots.Length > 0)
{
LootContainer.LootSpawnSlot[] lootSpawnSlots = loot.LootSpawnSlots;
for (int i = 0; i < lootSpawnSlots.Length; i++)
{
LootContainer.LootSpawnSlot lootSpawnSlot = lootSpawnSlots[i];
GetLootSpawn(lootSpawnSlot.definition, ref itemList);
}
}
container.Add("ItemList", itemList);
wasAdded = true;
}
Items.Add(lootTable.Key, new List <string> [5]);
Blueprints.Add(lootTable.Key, new List <string> [5]);
for (var i = 0; i < 5; ++i)
{
Items[lootTable.Key][i] = new List <string>();
Blueprints[lootTable.Key][i] = new List <string>();
}
foreach (var itemEntry in container["ItemList"] as Dictionary <string, object> )
{
bool isBP = itemEntry.Key.EndsWith(".blueprint") ? true : false;
var def = ItemManager.FindItemDefinition(itemEntry.Key.Replace(".blueprint", ""));
if (def != null)
{
if (isBP && def.Blueprint != null && def.Blueprint.isResearchable)
{
int index = (int)def.rarity;
if (!Blueprints[lootTable.Key][index].Contains(def.shortname))
{
Blueprints[lootTable.Key][index].Add(def.shortname);
}
}
else
{
int index = 0;
object indexoverride;
if (rarityItemOverride.TryGetValue(def.shortname, out indexoverride))
{
index = Convert.ToInt32(indexoverride);
}
else
{
index = (int)def.rarity;
}
if (!Items[lootTable.Key][index].Contains(def.shortname))
{
Items[lootTable.Key][index].Add(def.shortname);
}
}
}
}
totalItemWeight.Add(lootTable.Key, 0);
totalBlueprintWeight.Add(lootTable.Key, 0);
itemWeights.Add(lootTable.Key, new int[5]);
blueprintWeights.Add(lootTable.Key, new int[5]);
for (var i = 0; i < 5; ++i)
{
totalItemWeight[lootTable.Key] += (itemWeights[lootTable.Key][i] = ItemWeight(baseItemRarity, i) * Items[lootTable.Key][i].Count);
totalBlueprintWeight[lootTable.Key] += (blueprintWeights[lootTable.Key][i] = ItemWeight(baseItemRarity, i) * Blueprints[lootTable.Key][i].Count);
}
}
if (wasAdded || wasRemoved)
{
lootTable.Set("LootTables", lootTables);
lootTable.Save();
}
lootTable.Clear();
Puts($"Using '{activeTypes}' active of '{lootTables.Count}' supported containertypes");
}