using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using KillThemAll.Extras;
using KillThemAll.Hooks;
using KillThemAll.Managers;
using KillThemAll.Models;
using KillThemAll.Network;
using LethalBestiary.Modules;
using LethalLib.Modules;
using Newtonsoft.Json;
using RuntimeNetcodeRPCValidator;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Serialization;
using UnityEngine.UI;
using UnityEngine.VFX;
using UnityEngine.VFX.Utility;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("KillThemAll")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("KillThemAll")]
[assembly: AssemblyTitle("KillThemAll")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace KillThemAll
{
[BepInPlugin("KillThemAll.Main", "KillThemAll", "0.1.4")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class KillThemAll : BaseUnityPlugin
{
private const string modGUID = "KillThemAll.Main";
private const string modName = "KillThemAll";
private const string modVersion = "0.1.4";
public static KillThemAll instance;
public static AssetBundle hitMarkAsset;
public static AssetBundle hitMarkSfxAsset;
public static AssetBundle vfxBundle;
public static AssetBundle playerReactionsSfxAsset;
public static AssetBundle notificationAsset;
public static AssetBundle tombstoneAsset;
public static AssetBundle colliderTest;
private readonly Harmony harmony = new Harmony("KillThemAll.Main");
private NetcodeValidator netcodeValidator;
private Dictionary<string, ConfigEntry<int>> enemyConfigEntries = new Dictionary<string, ConfigEntry<int>>();
public ConfigEntry<string> TombSaveEntry;
private void Awake()
{
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Expected O, but got Unknown
if ((Object)(object)instance == (Object)null)
{
instance = this;
}
Utils.SetupLog();
Utils.DebugLog("Awaking");
LoadAssetBundles();
harmony.PatchAll(typeof(VanillaHook));
netcodeValidator = new NetcodeValidator("KillThemAll.Main");
netcodeValidator.PatchAll();
netcodeValidator.BindToPreExistingObjectByBehaviour<KillableEnemyEmitter, PlayerControllerB>();
netcodeValidator.BindToPreExistingObjectByBehaviour<UIEmitter, PlayerControllerB>();
netcodeValidator.BindToPreExistingObjectByBehaviour<TombScrapEmitter, PlayerControllerB>();
netcodeValidator.BindToPreExistingObjectByBehaviour<OnSpawnEnemiesEmitter, PlayerControllerB>();
Utils.DebugLog("Awaken");
}
public static List<Type> FindAllDerivedTypes<T>()
{
return FindAllDerivedTypes<T>(Assembly.GetAssembly(typeof(T)));
}
public static List<Type> FindAllDerivedTypes<T>(Assembly assembly)
{
Type baseType = typeof(T);
return (from t in assembly.GetTypes()
where t != baseType && baseType.IsAssignableFrom(t)
select t).ToList();
}
public void Initialise()
{
AddKillThemAllBaseConfigs();
AddBountyConfigs();
Utils.DebugLog("Finding all base enemies...");
List<string> list = new List<string>();
List<Type> list2 = FindAllDerivedTypes<EnemyAI>();
foreach (Type item in list2)
{
if (!(item.Name == "TestEnemy") && !(item.Name == "LassoMan"))
{
string name = item.Name;
name = name.Replace("Enemy", "");
name = name.Replace("(Clone)", "");
name = name.Replace(".prefab", "");
name = name.Replace("AI", "");
Utils.DebugLog("Found enemy: " + name);
list.Add(name);
}
}
Utils.DebugLog("Finding all LethalLib enemies...");
foreach (SpawnableEnemy spawnableEnemy in Enemies.spawnableEnemies)
{
string enemyName = spawnableEnemy.enemy.enemyName;
enemyName = enemyName.Replace("Enemy", "");
enemyName = enemyName.Replace("(Clone)", "");
enemyName = enemyName.Replace(".prefab", "");
enemyName = enemyName.Replace("AI", "");
Utils.DebugLog("Found enemy from LethalLib: " + enemyName);
list.Add(enemyName);
}
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
directoryName.Replace("OLO-KillThemAll", "");
directoryName += "TheWeavers-LethalBestiary/LethalBestiary/LethalBestiary.dll";
Utils.DebugLog("Finding all LethalBestiary enemies...");
foreach (SpawnableEnemy spawnableEnemy2 in Enemies.spawnableEnemies)
{
string enemyName2 = spawnableEnemy2.enemy.enemyName;
enemyName2 = enemyName2.Replace("Enemy", "");
enemyName2 = enemyName2.Replace("(Clone)", "");
enemyName2 = enemyName2.Replace(".prefab", "");
enemyName2 = enemyName2.Replace("AI", "");
Utils.DebugLog("Found enemy from LethalBestiary: " + enemyName2);
list.Add(enemyName2);
}
Utils.DebugLog("Creating config entries based on enemies found...");
foreach (string item2 in list)
{
string text = "Enemy Health";
string text2 = item2 + " Health";
int num = 3;
ConfigEntry<int> val = ((BaseUnityPlugin)this).Config.Bind<int>(text, text2, num, "Health points for " + item2 + "s");
enemyConfigEntries.Add(item2, val);
KillableEnemyManager.Instance.enemyHealthDictionary.Add(item2, val.Value);
Utils.DebugLog("Config entry created for: " + item2);
}
foreach (KeyValuePair<string, ConfigEntry<int>> entry in enemyConfigEntries)
{
entry.Value.SettingChanged += delegate(object sender, EventArgs value)
{
if (sender is ConfigEntry<int> val2)
{
KillableEnemyManager.Instance.SetEnemyHealth(entry.Key, val2.Value);
Utils.DebugLog("Saved health value for: " + entry.Key + " to: " + val2.Value);
}
else
{
Utils.DebugLog("ERROR: Tried to save config entry but entry = NULL");
}
};
}
Utils.DebugLog("Finished creating config entries based on enemies found!");
TombSaveEntry = ((BaseUnityPlugin)this).Config.Bind<string>("!IGNORE THIS!", "Tomb Saving", "", "DO NOT DELETE");
}
public void AddKillThemAllBaseConfigs()
{
ConfigEntry<bool> debugLogEntry = ((BaseUnityPlugin)this).Config.Bind<bool>("KillThemAll", "Debug Log", true, " if checked, log from this mod is output in the console");
ConfigEntry<bool> showHitmarkVfxEntry = ((BaseUnityPlugin)this).Config.Bind<bool>("KillThemAll", "Hit Marker", true, "If enabled, show hitmarker effect when damaging an enemy");
ConfigEntry<bool> playHitmarkSfxEntry = ((BaseUnityPlugin)this).Config.Bind<bool>("KillThemAll", "Hit Marker Sound Effect", true, "If enabled, play hitmarker sound effect when damaging an enemy");
ConfigEntry<bool> playerReactionAKSfxEntry = ((BaseUnityPlugin)this).Config.Bind<bool>("KillThemAll", "Player Reaction", true, "If enabled, play random sound effect when you or others kill an enemy (Its random if it plays or not)");
ConfigEntry<bool> showEnemyDeathEffectEntry = ((BaseUnityPlugin)this).Config.Bind<bool>("KillThemAll", "Enemy Death Effect", true, "If enabled, play enemy death effect");
KillableEnemyManager.Instance.debugLog = debugLogEntry.Value;
KillableEnemyManager.Instance.showHitmarkVfx = showHitmarkVfxEntry.Value;
KillableEnemyManager.Instance.playHitmarkSfx = playHitmarkSfxEntry.Value;
KillableEnemyManager.Instance.playerReactionAKSfx = playerReactionAKSfxEntry.Value;
KillableEnemyManager.Instance.showEnemyDeathEffect = showEnemyDeathEffectEntry.Value;
debugLogEntry.SettingChanged += delegate
{
KillableEnemyManager.Instance.debugLog = debugLogEntry.Value;
};
showHitmarkVfxEntry.SettingChanged += delegate
{
KillableEnemyManager.Instance.showHitmarkVfx = showHitmarkVfxEntry.Value;
};
playHitmarkSfxEntry.SettingChanged += delegate
{
KillableEnemyManager.Instance.playHitmarkSfx = playHitmarkSfxEntry.Value;
};
playerReactionAKSfxEntry.SettingChanged += delegate
{
KillableEnemyManager.Instance.playerReactionAKSfx = playerReactionAKSfxEntry.Value;
};
showEnemyDeathEffectEntry.SettingChanged += delegate
{
KillableEnemyManager.Instance.showEnemyDeathEffect = showEnemyDeathEffectEntry.Value;
};
}
public void AddBountyConfigs()
{
ConfigEntry<int> chanceToSpawnPerRoundEntry = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty Settings", "Rarity per round", 75, " Chance to spawn a bounty that round, the number is used like a percentage, the higher it is the higher the chances!");
ConfigEntry<int> chanceToSpawnPerHourEntry = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty Settings", "Rarity per hour", 50, " Chances to spawn a bounty every hour if one has not spawned yet, , the number is used like a percentage, the higher it is the higher the chances!");
ConfigEntry<int> timeBetweenRetryingBountiesEntry = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty Settings", "Retry per failed bounty", 2, " How many hours should it wait before retrying to spawn a bounty that failed the rarity check, In-game hours.");
ConfigEntry<int> timeBetweenSuccesfulBountiesEntry = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty Settings", "Time between next bounty", 4, " How many hours should it wait before spawning another bounty if possible, In-game hours.");
ConfigEntry<int> bountiesPerRoundEntry = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty Settings", "Bounties per round", 2, " How many bounties can spawn per round if they pass the rarity checks");
ConfigEntry<int> spawnAfterHourEntry = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty Settings", "Spawn after specific hour", 11, " Start spawning bounties after a specific hour, 0 = it will try and spawn from that start of the round, this uses a 24 hour clock.");
ConfigEntry<int> rewardMultiplierEntry = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty Settings", "Reward Multiplier", 4, " This value determines the end reward value for a bounty kill, (Enemy Health * Base Reward) * Reward Multiplier = Credit Reward");
ConfigEntry<int> baseKillRewardMultiplierEntry = ((BaseUnityPlugin)this).Config.Bind<int>("KillThemAll", "Base Reward Multiplier", 4, " This value determines the end reward value for a kill, Enemy Health * Base Reward Multiplier = Credit Reward");
BountyManager.Instance.chanceToSpawnPerRound = chanceToSpawnPerRoundEntry.Value;
BountyManager.Instance.chanceToSpawnPerHour = chanceToSpawnPerHourEntry.Value;
BountyManager.Instance.timeBetweenRetryingBounties = timeBetweenRetryingBountiesEntry.Value;
BountyManager.Instance.timeBetweenSuccesfulBounties = timeBetweenSuccesfulBountiesEntry.Value;
BountyManager.Instance.bountiesPerRound = bountiesPerRoundEntry.Value;
BountyManager.Instance.spawnAfterHour = spawnAfterHourEntry.Value;
BountyManager.Instance.rewardMultiplier = rewardMultiplierEntry.Value;
KillableEnemyManager.Instance.baseKillRewardMultiplier = baseKillRewardMultiplierEntry.Value;
chanceToSpawnPerRoundEntry.SettingChanged += delegate
{
BountyManager.Instance.chanceToSpawnPerRound = chanceToSpawnPerRoundEntry.Value;
Utils.DebugLog("BM: chanceToSpawnPerRound to: " + chanceToSpawnPerRoundEntry.Value);
};
chanceToSpawnPerHourEntry.SettingChanged += delegate
{
BountyManager.Instance.chanceToSpawnPerHour = chanceToSpawnPerHourEntry.Value;
Utils.DebugLog("BM: chanceToSpawnPerHourEntry to: " + chanceToSpawnPerHourEntry.Value);
};
timeBetweenRetryingBountiesEntry.SettingChanged += delegate
{
BountyManager.Instance.timeBetweenRetryingBounties = timeBetweenRetryingBountiesEntry.Value;
Utils.DebugLog("BM: timeBetweenRetryingBountiesEntry to: " + timeBetweenRetryingBountiesEntry.Value);
};
timeBetweenSuccesfulBountiesEntry.SettingChanged += delegate
{
BountyManager.Instance.timeBetweenSuccesfulBounties = timeBetweenSuccesfulBountiesEntry.Value;
Utils.DebugLog("BM: timeBetweenSuccesfulBountiesEntry to: " + timeBetweenSuccesfulBountiesEntry.Value);
};
bountiesPerRoundEntry.SettingChanged += delegate
{
BountyManager.Instance.bountiesPerRound = bountiesPerRoundEntry.Value;
Utils.DebugLog("BM: bountiesPerRoundEntry to: " + bountiesPerRoundEntry.Value);
};
spawnAfterHourEntry.SettingChanged += delegate
{
BountyManager.Instance.spawnAfterHour = spawnAfterHourEntry.Value;
Utils.DebugLog("BM: spawnAfterHourEntry to: " + spawnAfterHourEntry.Value);
};
rewardMultiplierEntry.SettingChanged += delegate
{
BountyManager.Instance.rewardMultiplier = rewardMultiplierEntry.Value;
Utils.DebugLog("BM: rewardMultiplierEntry to: " + rewardMultiplierEntry.Value);
};
baseKillRewardMultiplierEntry.SettingChanged += delegate
{
KillableEnemyManager.Instance.baseKillRewardMultiplier = baseKillRewardMultiplierEntry.Value;
};
}
private void LoadAssetBundles()
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
hitMarkAsset = AssetBundle.LoadFromFile(Path.Combine(directoryName, "hitmarkassetbundle"));
if ((Object)(object)hitMarkAsset == (Object)null)
{
Utils.DebugLog("ERROR: Failed to load hitMarkAsset asset bundles");
return;
}
KillableEnemyManager.Instance.hitmarkHUD = hitMarkAsset.LoadAsset<GameObject>("HitmarkImg");
if (Object.op_Implicit((Object)(object)KillableEnemyManager.Instance.hitmarkHUD))
{
Utils.DebugLog("Successfully found object in assetbundle ( hitmark HUD obj) " + ((Object)KillableEnemyManager.Instance.hitmarkHUD).name);
}
else
{
Utils.DebugLog("ERROR: Not found object in assetbundle ( hitmark HUD obj)");
}
hitMarkSfxAsset = AssetBundle.LoadFromFile(Path.Combine(directoryName, "hitmarksfxassetbundle"));
if ((Object)(object)hitMarkSfxAsset == (Object)null)
{
Utils.DebugLog("ERROR: Failed to load hit mark sfx asset bundles");
return;
}
KillableEnemyManager.Instance.hitmarkSfx = new List<AudioClip>();
KillableEnemyManager.Instance.hitmarkSfx = hitMarkSfxAsset.LoadAllAssets<AudioClip>().ToList();
if (Object.op_Implicit((Object)(object)KillableEnemyManager.Instance.hitmarkSfx[0]))
{
Utils.DebugLog("Successfully found object in assetbundle ( sfx hitmark )");
}
else
{
Utils.DebugLog("ERROR: Not found object in assetbundle ( sfx hitmark )");
}
vfxBundle = AssetBundle.LoadFromFile(Path.Combine(directoryName, "vfxbundle.assets"));
if ((Object)(object)vfxBundle == (Object)null)
{
Utils.DebugLog("ERROR: Failed to load enemyExplosionEffect asset bundles");
return;
}
KillableEnemyManager.Instance.enemyDeathEffect = vfxBundle.LoadAsset<GameObject>("Assets/LethalCompany/Mods/VFX/Blood.prefab");
KillableEnemyManager.Instance.tombDropEffect = vfxBundle.LoadAsset<GameObject>("Assets/LethalCompany/Mods/VFX/Smoke.prefab");
KillableEnemyManager.Instance.enemyBountyEffect = vfxBundle.LoadAsset<GameObject>("Assets/LethalCompany/Mods/VFX/BountyAura.prefab");
if (Object.op_Implicit((Object)(object)KillableEnemyManager.Instance.enemyDeathEffect) && Object.op_Implicit((Object)(object)KillableEnemyManager.Instance.tombDropEffect) && Object.op_Implicit((Object)(object)KillableEnemyManager.Instance.enemyBountyEffect))
{
Utils.DebugLog("Successfully found objects in vfx bundle");
}
else
{
Utils.DebugLog("ERROR: Not found object in vfx bundle");
}
playerReactionsSfxAsset = AssetBundle.LoadFromFile(Path.Combine(directoryName, "reactionsfxassetbundle"));
if ((Object)(object)playerReactionsSfxAsset == (Object)null)
{
Utils.DebugLog("ERROR: Failed to load hit mark sfx asset bundles");
return;
}
KillableEnemyManager.Instance.playerReactionSfx = new List<AudioClip>();
KillableEnemyManager.Instance.playerReactionSfx = playerReactionsSfxAsset.LoadAllAssets<AudioClip>().ToList();
if (Object.op_Implicit((Object)(object)KillableEnemyManager.Instance.playerReactionSfx[0]))
{
Utils.DebugLog("Successfully found object in assetbundle ( playerReactionsSfxAsset )");
}
else
{
Utils.DebugLog("ERROR: Not found object in assetbundle ( playerReactionsSfxAsset )");
}
notificationAsset = AssetBundle.LoadFromFile(Path.Combine(directoryName, "notificationassetbundle"));
if ((Object)(object)notificationAsset == (Object)null)
{
Utils.DebugLog("ERROR: Failed to load notificationAsset bundles");
return;
}
UIManager.Instance.notificationElementObj = notificationAsset.LoadAllAssets<GameObject>().ToList();
if (Object.op_Implicit((Object)(object)UIManager.Instance.notificationElementObj[0]))
{
Utils.DebugLog("Successfully found object in assetbundle ( notification element obj) " + ((Object)UIManager.Instance.notificationElementObj[0]).name);
}
else
{
Utils.DebugLog("ERROR: Not found object in assetbundle ( notification element obj)");
}
if (Object.op_Implicit((Object)(object)UIManager.Instance.notificationElementObj[1]))
{
Utils.DebugLog("Successfully found object in assetbundle ( notification top element obj) " + ((Object)UIManager.Instance.notificationElementObj[1]).name);
}
else
{
Utils.DebugLog("ERROR: Not found object in assetbundle ( notification top element obj)");
}
tombstoneAsset = AssetBundle.LoadFromFile(Path.Combine(directoryName, "tombstoneassetbundle.assets"));
if ((Object)(object)tombstoneAsset == (Object)null)
{
Utils.DebugLog("ERROR: Failed to load tombstoneAsset bundles");
return;
}
Item val = tombstoneAsset.LoadAsset<Item>("Assets/LethalCompany/Mods/Scraps/Tombstones/Tombstones.asset");
if (Object.op_Implicit((Object)(object)val))
{
Utils.DebugLog("Successfully found object in assetbundle ( tombScrapAsset ) ");
if (!Object.op_Implicit((Object)(object)val.spawnPrefab.GetComponent<TombScrap>()))
{
((Behaviour)val.spawnPrefab.AddComponent<TombScrap>()).enabled = false;
((GrabbableObject)val.spawnPrefab.GetComponent<TombScrap>()).itemProperties = val;
((GrabbableObject)val.spawnPrefab.GetComponent<TombScrap>()).itemProperties.saveItemVariable = true;
Utils.DebugLog(" TombScrap added to prefab ");
}
else
{
Utils.DebugLog(" TombScrap already on prefab ");
Utils.DebugLog("TombScrap is enabled: " + ((Behaviour)val.spawnPrefab.GetComponent<TombScrap>()).enabled);
}
}
else
{
Utils.DebugLog("ERROR: Not found object in assetbundle ( tombScrapAsset )");
}
NetworkPrefabs.RegisterNetworkPrefab(val.spawnPrefab);
Items.RegisterScrap(val, 0, (LevelTypes)(-1));
Utilities.FixMixerGroups(val.spawnPrefab);
KillableEnemyManager.Instance.enemyTomb = val;
colliderTest = AssetBundle.LoadFromFile(Path.Combine(directoryName, "colidertest"));
if ((Object)(object)colliderTest == (Object)null)
{
Utils.DebugLog("ERROR: Failed to load colidertest asset bundles");
return;
}
KillableEnemyManager.Instance.colliderTest = colliderTest.LoadAsset<GameObject>("Cube");
if (Object.op_Implicit((Object)(object)KillableEnemyManager.Instance.colliderTest))
{
Utils.DebugLog("Successfully found object in assetbundle( colliderTest cube )" + (object)KillableEnemyManager.Instance.colliderTest);
}
else
{
Utils.DebugLog("ERROR: Not found object in assetbundle ( colliderTest cube )");
}
}
public void SaveTombScrapOnShip(string fileSave, int id, int meshIndex, int matIndex, string enemyName, string playerThatKilled)
{
if (isIdInJason(id))
{
Utils.DebugLog("Tomb with id: " + id + " already exists, skipping save!");
return;
}
Tomb tomb = new Tomb(fileSave, id, meshIndex, matIndex, enemyName, playerThatKilled);
string text = JsonConvert.SerializeObject((object)tomb, (Formatting)0);
string value = TombSaveEntry.Value + ((TombSaveEntry.Value == "") ? text : ("|" + text));
Utils.DebugLog("Saving tomb: " + id + ", json: " + text);
TombSaveEntry.Value = value;
}
public Tomb GetTombById(int id, string fileSave)
{
if (TombSaveEntry.Value.StartsWith('|'))
{
TombSaveEntry.Value = TombSaveEntry.Value.Substring(1);
}
string[] array = TombSaveEntry.Value.Split('|');
List<Tomb> list = new List<Tomb>();
if (array.Length == 0)
{
return null;
}
string[] array2 = array;
foreach (string text in array2)
{
if (text == "")
{
continue;
}
Tomb tomb = JsonConvert.DeserializeObject<Tomb>(text);
if (text.Length != 0)
{
if (tomb == null)
{
return null;
}
list.Add(tomb);
}
}
if (list.Count > 0)
{
list.RemoveAll((Tomb t) => t.fileSave != fileSave);
Tomb tomb2 = list.FirstOrDefault((Tomb t) => t.id == id);
if (tomb2 != null)
{
string oldValue = JsonConvert.SerializeObject((object)tomb2);
TombSaveEntry.Value = TombSaveEntry.Value.Replace(oldValue, "");
TombSaveEntry.Value = TombSaveEntry.Value.Replace("||", "|");
}
return tomb2;
}
Utils.DebugLog("Zero saved tombs found, returning null!");
return null;
}
public void OnDeleteGameSave(string fileSave)
{
if (TombSaveEntry.Value.StartsWith('|'))
{
TombSaveEntry.Value = TombSaveEntry.Value.Substring(1);
}
string[] array = TombSaveEntry.Value.Split('|');
if (array.Length == 0)
{
return;
}
List<Tomb> list = new List<Tomb>();
string[] array2 = array;
foreach (string text in array2)
{
if (text.Length != 0)
{
Tomb tomb = JsonConvert.DeserializeObject<Tomb>(text);
if (tomb == null)
{
Utils.DebugLog("Can not deserialize object to save tomb object!");
return;
}
list.Add(tomb);
}
}
if (list.Count > 0)
{
list.RemoveAll((Tomb t) => t.fileSave != fileSave);
{
foreach (Tomb item in list)
{
string oldValue = JsonConvert.SerializeObject((object)item);
TombSaveEntry.Value = TombSaveEntry.Value.Replace(oldValue, "");
TombSaveEntry.Value = TombSaveEntry.Value.Replace("||", "|");
Utils.DebugLog("Removed Tomb from: " + fileSave + ", Tomb id: " + item.id);
}
return;
}
}
Utils.DebugLog("No tombs saved to delete on: " + fileSave);
}
public void RemoveSavedTombThatDontExist(string fileSave)
{
if (TombSaveEntry.Value.StartsWith('|'))
{
TombSaveEntry.Value = TombSaveEntry.Value.Substring(1);
}
string[] array = TombSaveEntry.Value.Split('|');
if (array.Length == 0)
{
return;
}
List<TombScrap> list = Object.FindObjectsByType<TombScrap>((FindObjectsInactive)0, (FindObjectsSortMode)0).ToList();
List<Tomb> list2 = new List<Tomb>();
string[] array2 = array;
foreach (string text in array2)
{
if (text == "")
{
continue;
}
bool flag = false;
Tomb tomb = JsonConvert.DeserializeObject<Tomb>(text);
if (tomb == null)
{
return;
}
foreach (TombScrap item in list)
{
if (tomb.id == item.id)
{
flag = true;
break;
}
}
if (!flag)
{
list2.Add(tomb);
}
}
if (list2.Count <= 0)
{
return;
}
list2.RemoveAll((Tomb t) => t.fileSave != fileSave);
foreach (Tomb item2 in list2)
{
string oldValue = JsonConvert.SerializeObject((object)item2);
TombSaveEntry.Value = TombSaveEntry.Value.Replace(oldValue, "");
TombSaveEntry.Value = TombSaveEntry.Value.Replace("||", "|");
Utils.DebugLog("Removed (NULL)Tomb from: " + fileSave + ", Tomb id: " + item2.id);
}
}
public bool isIdInJason(int id)
{
return TombSaveEntry.Value.Contains(id.ToString());
}
}
public class Tomb
{
public string fileSave;
public int id;
public int meshIndex;
public int matIndex;
public string enemyName;
public string playerThatKilled;
public Tomb(string fileSave, int id, int meshIndex, int matIndex, string enemyName, string playerThatKilled)
{
this.fileSave = fileSave;
this.id = id;
this.meshIndex = meshIndex;
this.matIndex = matIndex;
this.enemyName = enemyName;
this.playerThatKilled = playerThatKilled;
}
}
}
namespace KillThemAll.Network
{
public class KillableEnemyEmitter : NetworkBehaviour
{
[ServerRpc(RequireOwnership = false)]
public void DoDamageServerRpc(ulong enemyObjectId, ulong playerObjectId, int damage)
{
DoDamageClientRpc(enemyObjectId, playerObjectId, damage);
}
[ServerRpc(RequireOwnership = false)]
public void DoKillServerRpc(ulong objectId, ulong playerObjectId)
{
DoKillClientRpc(objectId, playerObjectId);
}
[ClientRpc]
public void DoDamageClientRpc(ulong objectId, ulong playerObjectId, int damage)
{
KillableEnemyManager.Instance.OnEnemyHit(objectId, playerObjectId, damage);
}
[ClientRpc]
public void DoKillClientRpc(ulong objectId, ulong playerObjectId)
{
KillableEnemyManager.Instance.OnEnemyDeath(objectId, playerObjectId);
}
}
public class OnSpawnEnemiesEmitter : NetworkBehaviour
{
[ServerRpc(RequireOwnership = false)]
public void AddObjectServerRpc(ulong enemyObjectId)
{
AddObjectClientRpc(enemyObjectId);
}
[ClientRpc]
public void AddObjectClientRpc(ulong objectId)
{
SpawnEnemyManager.Instance.AddAuraToBounty(objectId);
}
}
internal class TombScrapEmitter : NetworkBehaviour
{
[ServerRpc(RequireOwnership = false)]
public void SpawnTombServerRpc(ulong enemyKilled_Id, ulong playerThatKilled_Id, ulong tombScrap_Id, int scrapValue, int mesh, int mat)
{
SpawnTombClientRpc(enemyKilled_Id, playerThatKilled_Id, tombScrap_Id, scrapValue, mesh, mat);
}
[ClientRpc]
public void SpawnTombClientRpc(ulong enemyKilled_Id, ulong playerThatKilled_Id, ulong tombScrap_Id, int scrapValue, int mesh, int mat)
{
KillableEnemyManager.Instance.OnTombScrapSpawn(enemyKilled_Id, playerThatKilled_Id, tombScrap_Id, scrapValue, mesh, mat);
}
[ServerRpc]
public void SendTombDataSaveServerRpc(ulong tombScrap_Id, string enemyKilled_Id, string playerKilled, int mesh, int mat)
{
SendTombDataSaveClientRpc(tombScrap_Id, enemyKilled_Id, playerKilled, mesh, mat);
}
[ClientRpc]
public void SendTombDataSaveClientRpc(ulong tombScrap_Id, string enemyKilled_Id, string playerKilled, int mesh, int mat)
{
Utils.GetScrapObject(tombScrap_Id).GetComponent<TombScrap>().LoadItemSaveDataOnJoin(enemyKilled_Id, playerKilled, mesh, mat);
}
}
internal class UIEmitter : NetworkBehaviour
{
[ServerRpc(RequireOwnership = false)]
public void DoNotificationOnKillServerRpc(string enemyName, string playerThatKilledName, int rewardForKill, bool isBounty, int secondsOnScreen)
{
DoNotificationOnKillClientRpc(enemyName, playerThatKilledName, rewardForKill, isBounty, secondsOnScreen);
}
[ServerRpc(RequireOwnership = false)]
public void DoNotificationOnBountyServerRpc(string enemyName, int rewardForKill, int secondsOnScreen)
{
DoNotificationOnBountyClientRpc(enemyName, rewardForKill, secondsOnScreen);
}
[ClientRpc]
public void DoNotificationOnKillClientRpc(string enemyName, string playerThatKilledName, int rewardForKill, bool isBounty, int secondsOnScreen)
{
UIManager.Instance.ShowEnemyKilledNotfication(enemyName, playerThatKilledName, rewardForKill, isBounty, secondsOnScreen);
}
[ClientRpc]
public void DoNotificationOnBountyClientRpc(string enemyName, int rewardForKill, int secondsOnScreen)
{
UIManager.Instance.ShowEnemyBountyNotfication(enemyName, rewardForKill, secondsOnScreen);
}
}
}
namespace KillThemAll.Models
{
public class KillableEnemy : MonoBehaviour
{
private int startingHealth = 0;
private int currentHealth = 0;
private int reward = 0;
private bool bounty = false;
private ulong networkObjectId;
private EnemyAI enemyAI;
private GameObject collisionAIObject;
public EnemyAI EnemyAI
{
get
{
return enemyAI;
}
set
{
enemyAI = value;
}
}
public GameObject CollisionAIObject
{
get
{
return collisionAIObject;
}
set
{
collisionAIObject = value;
}
}
public ulong NetworkObjectId
{
get
{
return networkObjectId;
}
set
{
networkObjectId = value;
}
}
public int CurrentHealth
{
get
{
return currentHealth;
}
set
{
currentHealth = value;
}
}
public int StartingHealth
{
get
{
return startingHealth;
}
set
{
startingHealth = value;
}
}
public int Reward
{
get
{
return reward;
}
set
{
reward = value;
}
}
public bool isBounty
{
get
{
return bounty;
}
set
{
bounty = value;
}
}
public void DoDamage(int amount, ulong playerThatKilled_Id)
{
if (currentHealth != 0)
{
currentHealth -= amount;
if (currentHealth < 0)
{
currentHealth = 0;
}
if (currentHealth == 0 && (((NetworkBehaviour)enemyAI).IsHost || ((NetworkBehaviour)enemyAI).IsServer))
{
((Behaviour)((Component)enemyAI).gameObject.GetComponentInChildren<EnemyAICollisionDetect>()).enabled = false;
Utils.DebugLog("KillableEnemy: DoDamage() Enemy died sending ServerRPC");
KillableEnemyManager.Instance.OnEnemyDeathPrepareServerRPC(((NetworkBehaviour)enemyAI).NetworkObjectId, playerThatKilled_Id);
}
else if (((NetworkBehaviour)enemyAI).IsHost || ((NetworkBehaviour)enemyAI).IsServer)
{
Utils.DebugLog("KillableEnemy: DoDamage() Enemy took damge sending ServerRPC");
((Component)StartOfRound.Instance.allPlayerScripts[0]).gameObject.GetComponent<KillableEnemyEmitter>().DoDamageServerRpc(((NetworkBehaviour)enemyAI).NetworkObjectId, playerThatKilled_Id, amount);
}
}
}
public void DespawnEnemy()
{
((MonoBehaviour)this).StartCoroutine(DespawnEnemyOvertime());
}
public IEnumerator DespawnEnemyOvertime()
{
yield return (object)new WaitForSeconds(0.4f);
if (Object.op_Implicit((Object)(object)((NetworkBehaviour)enemyAI).NetworkObject))
{
Utils.DebugLog("Despawning network object: " + ((Object)this).name);
((NetworkBehaviour)enemyAI).NetworkObject.Despawn(true);
}
}
}
public enum EnemyType
{
default_
}
}
namespace KillThemAll.Managers
{
internal class BountyManager
{
public struct EnemyKilled
{
public string name;
public string killerName;
public bool wasBounty;
public int reward;
}
private const string modGUID = "KillThemAll.BManager";
private static BountyManager _instance;
public Terminal __terminal;
public bool isRoundActive = false;
public int chanceToSpawnPerRound = 100;
public int chanceToSpawnPerHour = 100;
public int timeBetweenRetryingBounties = 1;
public int timeBetweenSuccesfulBounties = 3;
public int bountiesPerRound = 1;
public int spawnAfterHour = 12;
public int rewardMultiplier = 16;
public bool isHost = false;
private int bountiesSpawnedThisRound = 0;
private int retryAtThisHour = 0;
private bool shouldSpawnThisRound = false;
private bool checkedIfItShouldSpawn = false;
public List<EnemyKilled> enemyKilledList = new List<EnemyKilled>();
private bool once = false;
public static BountyManager Instance => _instance ?? (_instance = new BountyManager());
static BountyManager()
{
}
public void ServerUpdateOnRoundStart()
{
if (!checkedIfItShouldSpawn)
{
if (CheckIfBountyShouldSpawnThisRound())
{
Utils.DebugLog("Bounty will spawn this round!");
}
else
{
Utils.DebugLog("Bounty will not spawn this round!");
}
checkedIfItShouldSpawn = true;
}
if (!shouldSpawnThisRound || retryAtThisHour >= 24 || bountiesPerRound == 0 || bountiesSpawnedThisRound >= bountiesPerRound || Utils.GetTimeOfRound() < spawnAfterHour)
{
return;
}
if (Utils.GetTimeOfRound() >= retryAtThisHour)
{
Utils.DebugLog("Its time to try again and its: " + Utils.GetTimeOfRound());
once = false;
int num = Random.Range(0, 100);
Utils.DebugLog("Chance = " + num + ", need below" + chanceToSpawnPerHour);
if (num > chanceToSpawnPerHour)
{
retryAtThisHour = Utils.GetTimeOfRound() + timeBetweenRetryingBounties;
Utils.DebugLog("Didnt pass rarity check retrying bounty at: " + retryAtThisHour);
}
else if (bountiesSpawnedThisRound < bountiesPerRound)
{
bountiesSpawnedThisRound++;
retryAtThisHour = Utils.GetTimeOfRound() + timeBetweenSuccesfulBounties;
Utils.DebugLog("Bounty spawned | count: " + bountiesSpawnedThisRound);
Utils.DebugLog("Next spawn try at: " + retryAtThisHour);
OnSpawnBounty();
}
}
else if (!once)
{
Utils.DebugLog("Need to wait till " + retryAtThisHour + ", and its: " + Utils.GetTimeOfRound());
once = true;
}
}
public void ServerUpdateOnRoundEnd()
{
once = false;
checkedIfItShouldSpawn = false;
shouldSpawnThisRound = false;
bountiesSpawnedThisRound = 0;
retryAtThisHour = 0;
enemyKilledList.Clear();
Utils.DebugLog("ServerUpdateOnRoundEnd: resetting values");
}
public bool CheckIfBountyShouldSpawnThisRound()
{
int num = Random.Range(0, 100);
return shouldSpawnThisRound = num <= chanceToSpawnPerRound;
}
public void OnSpawnBounty()
{
int reward = 0;
string enemyName = SpawnEnemyManager.Instance.SpawnRandomEnemy(out reward);
UIManager.Instance.PrepareOnBountyServerRPC_Notification(enemyName, reward);
}
public void SaveKilledEnemy(string name, string player, bool wasBounty, int reward)
{
EnemyKilled item = default(EnemyKilled);
item.name = name;
item.killerName = player;
item.wasBounty = wasBounty;
item.reward = reward;
Utils.DebugLog("Added killed enemy: " + item.name + " that died by: " + item.killerName + " for " + item.reward + (item.wasBounty ? " and was a bounty" : " and was not a bounty"));
enemyKilledList.Add(item);
}
private void GiveCreditsToCrew(int reward)
{
if (!Object.op_Implicit((Object)(object)__terminal))
{
Utils.DebugLog("ERROR: Reference to terminal is null! Cant give credits");
return;
}
Terminal _terminal = __terminal;
_terminal.groupCredits += reward;
__terminal.SyncGroupCreditsServerRpc(__terminal.groupCredits, __terminal.numberOfItemsInDropship);
}
}
internal class KillableEnemyManager
{
private const string modGUID = "KillThemAll.KEManager";
private static KillableEnemyManager _instance;
public Dictionary<string, int> enemyHealthDictionary = new Dictionary<string, int>();
public PlayerControllerB localPlayer;
public bool debugLog = true;
public bool showHitmarkVfx = true;
public bool playHitmarkSfx = true;
public bool showEnemyDeathEffect = true;
public bool playerReactionAKSfx = true;
public int baseKillRewardMultiplier = 10;
public Animator playerHitmarkAnimator;
private AudioSource playerAudioSource;
public GameObject hitmarkHUD;
public List<AudioClip> hitmarkSfx;
public GameObject enemyDeathEffect;
public GameObject tombDropEffect;
public GameObject enemyBountyEffect;
public List<AudioClip> playerReactionSfx;
public Item enemyTomb;
public GameObject colliderTest;
private GameObject hitMarkerHud;
public static KillableEnemyManager Instance => _instance ?? (_instance = new KillableEnemyManager());
public Dictionary<ulong, EnemyAI> NetworkObjectIDToEnemyAI { get; } = new Dictionary<ulong, EnemyAI>();
public Dictionary<EnemyAI, ulong> EnemyAIToNetworkObjectID { get; } = new Dictionary<EnemyAI, ulong>();
static KillableEnemyManager()
{
}
public void SetEnemyHealth(string enemyName, int newHealth)
{
if (enemyHealthDictionary.ContainsKey(enemyName))
{
enemyHealthDictionary[enemyName] = newHealth;
}
}
public void SetupHitmarkerHUD(PlayerControllerB __instance)
{
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
if (!Object.op_Implicit((Object)(object)__instance) || Object.op_Implicit((Object)(object)hitMarkerHud))
{
return;
}
localPlayer = __instance;
Transform transform = GameObject.Find("Systems/UI/Canvas/PlayerCursor/Cursor").transform;
if (!Object.op_Implicit((Object)(object)transform))
{
Utils.DebugLog("ERROR: SetupHitmarkerHUD() => parentCanvas = NULL");
return;
}
hitMarkerHud = Object.Instantiate<GameObject>(hitmarkHUD, transform.parent, false);
if (!Object.op_Implicit((Object)(object)hitMarkerHud))
{
Utils.DebugLog("ERROR: SetupHitmarkerHUD() => hitMarkerHudObject = NULL");
return;
}
hitMarkerHud.SetActive(true);
hitMarkerHud.transform.localScale = new Vector3(1f, 1f, 1f);
playerHitmarkAnimator = hitMarkerHud.GetComponent<Animator>();
if (!Object.op_Implicit((Object)(object)playerHitmarkAnimator))
{
Utils.DebugLog("ERROR: SetupHitmarkerHUD() => playerHitmarkAnimator = NULL");
return;
}
playerHitmarkAnimator.speed = 1.9f;
Utils.DebugLog("HUD Instantiated for local player: " + localPlayer.playerUsername);
}
public KillableEnemy AssignKillableClassToEnemy(EnemyAI __instance)
{
if (Object.op_Implicit((Object)(object)((Component)__instance).gameObject.GetComponent<KillableEnemy>()))
{
return ((Component)__instance).gameObject.GetComponent<KillableEnemy>();
}
int num = 10000;
string name = ((Object)__instance).name;
name = name.Replace("Enemy", "");
name = name.Replace("(Clone)", "");
name = name.Replace(".prefab", "");
double num2 = 0.0;
string text = "null";
if (enemyHealthDictionary.Count == 0)
{
Utils.DebugLog("enemyHealthDictionary is empty");
}
foreach (KeyValuePair<string, int> item in enemyHealthDictionary)
{
double num3 = Utils.SimilarityRatio(name, item.Key);
if (num3 > num2)
{
num2 = num3;
if (item.Value > 0)
{
num = item.Value;
}
text = item.Key;
Utils.DebugLog("Comparing name: " + name + ", against: " + item.Key + " | Similarity = " + num3);
}
}
if (text == "null")
{
Utils.DebugLog("Not found similar name for: " + name + "!!!");
return null;
}
KillableEnemy killableEnemy = InitializeKillableData(__instance);
killableEnemy.StartingHealth = num;
killableEnemy.CurrentHealth = num;
killableEnemy.Reward = num * baseKillRewardMultiplier;
killableEnemy.EnemyAI = __instance;
killableEnemy.NetworkObjectId = ((NetworkBehaviour)__instance).NetworkObjectId;
killableEnemy.CollisionAIObject = ((Component)((Component)((Component)__instance).gameObject.transform.root).GetComponentInChildren<EnemyAICollisionDetect>()).gameObject;
bool flag = false;
MeshRenderer val = null;
bool flag2 = false;
Utils.DebugLog("Registering enemy: " + ((Object)((Component)__instance).gameObject).name + ", new HP: " + num);
return killableEnemy;
}
private KillableEnemy InitializeKillableData(EnemyAI enemyAI)
{
EnemyAIToNetworkObjectID[enemyAI] = ((NetworkBehaviour)enemyAI).NetworkObjectId;
NetworkObjectIDToEnemyAI[((NetworkBehaviour)enemyAI).NetworkObjectId] = enemyAI;
return ((Component)enemyAI).gameObject.AddComponent<KillableEnemy>();
}
public void OnEnemyDeathPrepareServerRPC(ulong enemyHit_Id, ulong playerThatKilled_Id)
{
EnemyAI enemyAIClassFromNetID = Utils.GetEnemyAIClassFromNetID(enemyHit_Id);
KillableEnemy component = ((Component)enemyAIClassFromNetID).GetComponent<KillableEnemy>();
OnServerEnemyDropItem(enemyAIClassFromNetID);
BountyManager.Instance.SaveKilledEnemy(Utils.GetEnemyName(enemyAIClassFromNetID), Utils.GetPlayerClassFromNetID(playerThatKilled_Id).playerUsername, component.isBounty, component.Reward);
UIManager.Instance.PrepareOnKillServerRPC_Notification(((NetworkBehaviour)enemyAIClassFromNetID).NetworkObjectId, playerThatKilled_Id);
((Component)StartOfRound.Instance.allPlayerScripts[0]).gameObject.GetComponent<KillableEnemyEmitter>().DoKillServerRpc(((NetworkBehaviour)enemyAIClassFromNetID).NetworkObjectId, playerThatKilled_Id);
}
private void OnServerEnemyDropItem(EnemyAI enemyAI)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = ((Component)enemyAI).transform.position + new Vector3(0.2f, 5f, 0.2f);
if (Object.op_Implicit((Object)(object)((Component)enemyAI).gameObject.GetComponent<NutcrackerEnemyAI>()))
{
Object.Instantiate<GameObject>(((Component)enemyAI).gameObject.GetComponent<NutcrackerEnemyAI>().gunPrefab, val, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer).GetComponent<NetworkObject>().Spawn(false);
val.x += 0.5f;
val.z += 0.2f;
Object.Instantiate<GameObject>(((Component)enemyAI).gameObject.GetComponent<NutcrackerEnemyAI>().shotgunShellPrefab, val, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer).GetComponent<NetworkObject>().Spawn(false);
val.z += 0.2f;
Object.Instantiate<GameObject>(((Component)enemyAI).gameObject.GetComponent<NutcrackerEnemyAI>().shotgunShellPrefab, val, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer).GetComponent<NetworkObject>().Spawn(false);
Utils.DebugLog("Nutcracker Died: Spawned Shotgun and Ammo!");
}
if (Object.op_Implicit((Object)(object)((Component)enemyAI).gameObject.GetComponent<ButlerEnemyAI>()))
{
val.x += 0.5f;
val.z += 0.5f;
Object.Instantiate<GameObject>(((Component)enemyAI).gameObject.GetComponent<ButlerEnemyAI>().knifePrefab, val, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer).GetComponent<NetworkObject>().Spawn(false);
Utils.DebugLog("Butler Died: Spawned Knife!");
}
}
public void OnEnemyHitPrepareServerRPC(ulong enemyHit_Id, ulong playerThatHit_Id, int damageHit)
{
EnemyAI enemyAIClassFromNetID = Utils.GetEnemyAIClassFromNetID(enemyHit_Id);
if (Object.op_Implicit((Object)(object)enemyAIClassFromNetID))
{
KillableEnemy component = ((Component)enemyAIClassFromNetID).gameObject.GetComponent<KillableEnemy>();
if ((Object)(object)component != (Object)null)
{
((Component)enemyAIClassFromNetID).gameObject.GetComponent<KillableEnemy>().DoDamage(damageHit, playerThatHit_Id);
}
}
}
public void OnEnemyHit(ulong enemyHit_Id, ulong playerThatHit_Id, int damageHit)
{
EnemyAI enemyAIClassFromNetID = Utils.GetEnemyAIClassFromNetID(enemyHit_Id);
PlayerControllerB playerClassFromNetID = Utils.GetPlayerClassFromNetID(playerThatHit_Id);
if (!Object.op_Implicit((Object)(object)enemyAIClassFromNetID))
{
Utils.DebugLog("ERROR: OnEnemyHit() => enemyAI = NULL");
return;
}
if (!Object.op_Implicit((Object)(object)playerClassFromNetID))
{
Utils.DebugLog("ERROR: OnEnemyHit() => playerThatHit = NULL");
return;
}
Utils.DebugLog("OnEnemyHit: " + ((Object)enemyAIClassFromNetID).name + " hit for " + damageHit + " damage! by: " + playerClassFromNetID.playerUsername);
}
public void OnEnemyDeath(ulong enemyKilled_Id, ulong playerThatKilled_Id)
{
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0212: Unknown result type (might be due to invalid IL or missing references)
//IL_021c: Unknown result type (might be due to invalid IL or missing references)
//IL_016d: Unknown result type (might be due to invalid IL or missing references)
//IL_017d: Unknown result type (might be due to invalid IL or missing references)
//IL_0193: Unknown result type (might be due to invalid IL or missing references)
//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
//IL_01de: Unknown result type (might be due to invalid IL or missing references)
//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
EnemyAI enemyAIClassFromNetID = Utils.GetEnemyAIClassFromNetID(enemyKilled_Id);
PlayerControllerB playerClassFromNetID = Utils.GetPlayerClassFromNetID(playerThatKilled_Id);
if (!Object.op_Implicit((Object)(object)enemyAIClassFromNetID))
{
Utils.DebugLog("ERROR: OnEnemyDeath() => enemyAI = NULL");
return;
}
if (!Object.op_Implicit((Object)(object)playerClassFromNetID))
{
Utils.DebugLog("ERROR: OnEnemyDeath() => playerThatKilled = NULL");
return;
}
enemyAIClassFromNetID.KillEnemy(false);
if (Object.op_Implicit((Object)(object)enemyAIClassFromNetID.creatureSFX))
{
enemyAIClassFromNetID.creatureSFX.Stop();
}
if (Object.op_Implicit((Object)(object)enemyAIClassFromNetID.creatureVoice))
{
enemyAIClassFromNetID.creatureVoice.Stop();
}
if (showEnemyDeathEffect)
{
Vector3 val = default(Vector3);
((Vector3)(ref val))..ctor(((Component)enemyAIClassFromNetID).transform.position.x, ((Component)enemyAIClassFromNetID).transform.position.y + 2f, ((Component)enemyAIClassFromNetID).transform.position.z);
GameObject val2 = Object.Instantiate<GameObject>(enemyDeathEffect, val, enemyDeathEffect.transform.rotation);
val2.transform.localScale = val2.transform.localScale * 0.75f;
val2.AddComponent<VfxDespawn>();
}
Utils.DebugLog("OnEnemyDeath: " + ((Object)enemyAIClassFromNetID).name + " Killed by " + playerClassFromNetID.playerUsername);
PlayReactionAfterKillLocal(playerClassFromNetID);
if (Utils.isHost)
{
KillableEnemy component = ((Component)enemyAIClassFromNetID).GetComponent<KillableEnemy>();
Vector3 pos = default(Vector3);
((Vector3)(ref pos))..ctor(((Component)enemyAIClassFromNetID).transform.position.x, ((Component)enemyAIClassFromNetID).transform.position.y + 2f, ((Component)enemyAIClassFromNetID).transform.position.z);
Vector3 val3 = ((Component)playerClassFromNetID).transform.position - ((Component)enemyAIClassFromNetID).transform.position;
val3.y = 0f;
Quaternion rot = Quaternion.LookRotation(val3);
ServerPrepareTombScrapSpawn(enemyKilled_Id, playerThatKilled_Id, component.Reward, pos, rot);
component.DespawnEnemy();
}
((Component)enemyAIClassFromNetID).transform.position = new Vector3(((Component)enemyAIClassFromNetID).transform.position.x, -10000f, ((Component)enemyAIClassFromNetID).transform.position.z);
Utils.DebugLog("Moved enemy more than 6feet under");
}
public void ServerPrepareTombScrapSpawn(ulong enemyKilled_Id, ulong playerThatKilled_Id, int scrapValue, Vector3 pos, Quaternion rot)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
Utilities.FixMixerGroups(enemyTomb.spawnPrefab);
GameObject val = Object.Instantiate<GameObject>(enemyTomb.spawnPrefab, pos, rot);
int mesh = Random.Range(0, 3);
int mat = Random.Range(0, 3);
val.GetComponent<NetworkObject>().Spawn(false);
Utils.DebugLog("KEM: ServerPrepareTombScrapSpawn() Sending Server RPC");
((Component)StartOfRound.Instance.allPlayerScripts[0]).gameObject.GetComponent<TombScrapEmitter>().SpawnTombServerRpc(enemyKilled_Id, playerThatKilled_Id, val.GetComponent<NetworkObject>().NetworkObjectId, scrapValue, mesh, mat);
}
public void OnTombScrapSpawn(ulong enemyKilled_Id, ulong playerThatKilled_Id, ulong tombScrap_Id, int scrapValue, int mesh, int mat)
{
PlayerControllerB playerClassFromNetID = Utils.GetPlayerClassFromNetID(playerThatKilled_Id);
GameObject scrapObject = Utils.GetScrapObject(tombScrap_Id);
if (!Object.op_Implicit((Object)(object)scrapObject))
{
Utils.DebugLog("tombObj not found in spawned objects list");
}
if (!Object.op_Implicit((Object)(object)scrapObject.GetComponent<TombScrap>()))
{
Utils.DebugLog("TombScrap not found on: " + ((Object)scrapObject).name);
}
else
{
TombScrap component = scrapObject.GetComponent<TombScrap>();
component.scrapVal = scrapValue;
component.enemyName = Utils.GetEnemyName(enemyKilled_Id);
component.playerName = playerClassFromNetID.playerUsername;
component.meshIndex = mesh;
component.matIndex = mat;
component.OnSpawnInit();
}
Utils.DebugLog("Tombstone Spawned! Killer: " + playerClassFromNetID.playerUsername + ", Enemy: " + Utils.GetEnemyName(enemyKilled_Id));
}
public void PlayHitmarkerLocal(PlayerControllerB playerController)
{
if (playHitmarkSfx)
{
if (!Object.op_Implicit((Object)(object)hitmarkSfx[0]))
{
Utils.DebugLog("ERROR: PlayHitmarkerLocal() => hitmarkSfx[0] = NULL");
return;
}
if (!Object.op_Implicit((Object)(object)playerAudioSource))
{
if (!Object.op_Implicit((Object)(object)playerController.movementAudio))
{
Utils.DebugLog("ERROR: PlayHitmarkerLocal() => playerController.movementAudio = NULL");
return;
}
playerAudioSource = playerController.movementAudio;
}
playerAudioSource.PlayOneShot(hitmarkSfx[0], 3f);
Utils.DebugLog("Play Hitmark sound effect on local client");
}
if (showHitmarkVfx)
{
if (!Object.op_Implicit((Object)(object)playerHitmarkAnimator))
{
Utils.DebugLog("ERROR: PlayHitmarkerLocal() => playerHitmarkAnimator = NULL");
return;
}
playerHitmarkAnimator.Play("HitmarkAnim", 0, 0f);
Utils.DebugLog("Play Hitmark effect on local client");
}
}
public void PlayReactionAfterKillLocal(PlayerControllerB playerController)
{
if (playerReactionAKSfx)
{
if (!Object.op_Implicit((Object)(object)playerController))
{
Utils.DebugLog("ERROR: PlayReactionAfterKillLocal() => playerController = NULL");
return;
}
if (!Object.op_Implicit((Object)(object)playerReactionSfx[0]))
{
Utils.DebugLog("ERROR: PlayReactionAfterKillLocal() => playerReactionSfx[0] = NULL");
return;
}
if (!Object.op_Implicit((Object)(object)playerController.movementAudio))
{
Utils.DebugLog("ERROR: PlayReactionAfterKillLocal() => playerController.movementAudio = NULL");
return;
}
playerController.movementAudio.PlayOneShot(playerReactionSfx[0], 1f);
Utils.DebugLog("Playing reaction for killing an enemy: " + playerController.playerUsername);
}
}
}
internal class SpawnEnemyManager
{
public struct Enemy
{
public string name;
public GameObject prefab;
public bool isOutside;
}
private const string modGUID = "KillThemAll.SManager";
private static SpawnEnemyManager _instance;
public static List<Enemy> listOfSpawnableEnemies;
public static SpawnEnemyManager Instance => _instance ?? (_instance = new SpawnEnemyManager());
static SpawnEnemyManager()
{
listOfSpawnableEnemies = new List<Enemy>();
}
public string SpawnRandomEnemy(out int reward)
{
Enemy enemy = listOfSpawnableEnemies[Random.Range(0, listOfSpawnableEnemies.Count)];
reward = SpawnEnemy(enemy);
return enemy.name;
}
private int SpawnEnemy(Enemy enemy)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
Vector3 zero = Vector3.zero;
zero = ((!enemy.isOutside) ? RoundManager.Instance.allEnemyVents[Random.Range(0, RoundManager.Instance.allEnemyVents.Length)].floorNode.position : RoundManager.Instance.outsideAINodes[Random.Range(0, RoundManager.Instance.outsideAINodes.Length)].transform.position);
if (!Object.op_Implicit((Object)(object)enemy.prefab))
{
Utils.DebugLog("enemy.prefab null");
}
GameObject val = Object.Instantiate<GameObject>(enemy.prefab, zero, Quaternion.identity);
NetworkObject componentInChildren = val.GetComponentInChildren<NetworkObject>();
componentInChildren.Spawn(true);
if (!Object.op_Implicit((Object)(object)val.GetComponent<KillableEnemy>()))
{
if (Object.op_Implicit((Object)(object)val.GetComponent<EnemyAI>()))
{
Utils.DebugLog("ERROR: Cant find EnemyAI Class on " + ((Object)val).name);
}
EnemyAI component = val.GetComponent<EnemyAI>();
if (!Object.op_Implicit((Object)(object)component))
{
Utils.DebugLog("ERROR: Cant find EnemyAI Class on " + ((Object)val).name);
return 0;
}
KillableEnemy killableEnemy = KillableEnemyManager.Instance.AssignKillableClassToEnemy(component);
killableEnemy.isBounty = true;
killableEnemy.Reward = killableEnemy.StartingHealth * KillableEnemyManager.Instance.baseKillRewardMultiplier * BountyManager.Instance.rewardMultiplier;
Utils.DebugLog("(had to attach KE class) spawned bounty: " + ((Object)val).name + ", reward: " + killableEnemy.Reward);
((Component)StartOfRound.Instance.allPlayerScripts[0]).gameObject.GetComponent<OnSpawnEnemiesEmitter>().AddObjectServerRpc(componentInChildren.NetworkObjectId);
return killableEnemy.Reward;
}
KillableEnemy component2 = val.GetComponent<KillableEnemy>();
component2.isBounty = true;
component2.Reward = component2.StartingHealth * KillableEnemyManager.Instance.baseKillRewardMultiplier * BountyManager.Instance.rewardMultiplier;
Utils.DebugLog("(class already attached) spawned bounty: " + ((Object)val).name + ", reward: " + component2.Reward);
((Component)StartOfRound.Instance.allPlayerScripts[0]).gameObject.GetComponent<OnSpawnEnemiesEmitter>().AddObjectServerRpc(componentInChildren.NetworkObjectId);
return component2.Reward;
}
public void AddAuraToBounty(ulong enemy_Id)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
EnemyAI enemyAIClassFromNetID = Utils.GetEnemyAIClassFromNetID(enemy_Id);
if (Object.op_Implicit((Object)(object)enemyAIClassFromNetID))
{
GameObject val = Object.Instantiate<GameObject>(KillableEnemyManager.Instance.enemyBountyEffect, Vector3.zero, Quaternion.identity);
val.transform.SetParent(((Component)enemyAIClassFromNetID).transform, false);
val.transform.localRotation = Quaternion.identity;
val.transform.localPosition = Vector3.zero;
}
else
{
Utils.DebugLog("Could not find bounty enemy class to spawn aura!");
}
}
}
internal class UIManager
{
private const string modGUID = "KillThemAll.UIManager";
private static UIManager _instance;
public List<GameObject> notificationElementObj;
private Transform topNotificationParent;
private Transform sideNotificationParent;
public static UIManager Instance => _instance ?? (_instance = new UIManager());
static UIManager()
{
}
public void PrepareOnKillServerRPC_Notification(ulong objectKilled_Id, ulong playerThatKilled_Id)
{
Utils.DebugLog("Preparing server rpc call for kill notification");
KillableEnemy component = ((Component)GeneralExtensions.GetValueSafe<ulong, EnemyAI>(KillableEnemyManager.Instance.NetworkObjectIDToEnemyAI, objectKilled_Id)).gameObject.GetComponent<KillableEnemy>();
string name = ((Object)((Component)component).gameObject).name;
string playerUsername = Utils.GetPlayerClassFromNetID(playerThatKilled_Id).playerUsername;
name = name.Replace("Enemy", "");
name = name.Replace("(Clone)", "");
name = name.Replace(".prefab", "");
((Component)StartOfRound.Instance.allPlayerScripts[0]).GetComponent<UIEmitter>().DoNotificationOnKillServerRpc(name, playerUsername, component.Reward, component.isBounty, component.isBounty ? 6 : 4);
}
public void PrepareOnBountyServerRPC_Notification(string enemyName, int rewardAmount)
{
Utils.DebugLog("Preparing server rpc call for bounty notification");
((Component)StartOfRound.Instance.allPlayerScripts[0]).GetComponent<UIEmitter>().DoNotificationOnBountyServerRpc(enemyName, rewardAmount, 8);
}
public void Initialise()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Expected O, but got Unknown
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
//IL_0190: Unknown result type (might be due to invalid IL or missing references)
if (!Object.op_Implicit((Object)(object)sideNotificationParent))
{
GameObject val = new GameObject("SideNotificationParent");
val.transform.SetParent(GameObject.Find("Systems/UI/Canvas/IngamePlayerHUD/TopLeftCorner/Self").transform, false);
VerticalLayoutGroup val2 = val.AddComponent<VerticalLayoutGroup>();
((Component)val2).transform.localPosition = new Vector3(-30f, -75f, 0f);
((Component)val2).transform.localScale = new Vector3(-0.2f, 0.2f, -0.2f);
((HorizontalOrVerticalLayoutGroup)val2).spacing = 15f;
((LayoutGroup)val2).childAlignment = (TextAnchor)4;
((HorizontalOrVerticalLayoutGroup)val2).reverseArrangement = true;
((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = false;
((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = false;
((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
sideNotificationParent = val.transform;
Utils.DebugLog("sideNotificationParent added " + ((Object)sideNotificationParent).name + ", its parent is " + ((Object)((Component)sideNotificationParent).transform.parent).name);
}
if (!Object.op_Implicit((Object)(object)topNotificationParent))
{
GameObject val3 = new GameObject("topNotificationParent");
Transform parent = ((Component)HUDManager.Instance.Inventory.canvasGroup).transform.parent;
val3.transform.SetParent(parent, false);
VerticalLayoutGroup val4 = val3.AddComponent<VerticalLayoutGroup>();
((Component)val4).transform.localPosition = new Vector3(0f, 150f, 0f);
((Component)val4).transform.localScale = new Vector3(0.3f, 0.3f, 0.3f);
((HorizontalOrVerticalLayoutGroup)val4).spacing = 15f;
((LayoutGroup)val4).childAlignment = (TextAnchor)4;
((HorizontalOrVerticalLayoutGroup)val4).reverseArrangement = true;
((HorizontalOrVerticalLayoutGroup)val4).childControlWidth = false;
((HorizontalOrVerticalLayoutGroup)val4).childControlHeight = false;
((HorizontalOrVerticalLayoutGroup)val4).childForceExpandHeight = false;
((HorizontalOrVerticalLayoutGroup)val4).childForceExpandWidth = false;
topNotificationParent = val3.transform;
Utils.DebugLog("topNotificationParent added " + ((Object)topNotificationParent).name + ", its parent is " + ((Object)((Component)topNotificationParent).transform.parent).name);
}
}
public void ShowEnemyKilledNotfication(string enemyName, string playerThatKilledName, int rewardForKill, bool isBounty, int secondsOnScreen)
{
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
if (!Object.op_Implicit((Object)(object)sideNotificationParent))
{
Utils.DebugLog("ERROR: UIManager() => sideNotificationParent = NULL");
return;
}
GameObject val = Object.Instantiate<GameObject>(notificationElementObj[0], sideNotificationParent, false);
if (!Object.op_Implicit((Object)(object)val))
{
Utils.DebugLog("ERROR: UIManager() => notificationElement = NULL");
return;
}
val.SetActive(true);
val.transform.localPosition = new Vector3(0f, 0f, 0f);
if (!isBounty)
{
((Component)val.transform.GetChild(0)).gameObject.SetActive(false);
((Component)val.transform.GetChild(1)).GetComponent<TMP_Text>().fontSize = 50f;
((Component)val.transform.GetChild(2)).GetComponent<TMP_Text>().fontSize = 50f;
((Component)val.transform.GetChild(1)).GetComponent<TMP_Text>().text = playerThatKilledName + " killed " + enemyName;
((Component)val.transform.GetChild(2)).GetComponent<TMP_Text>().text = "The Company values its tomb at " + rewardForKill;
((Component)val.transform.GetChild(1)).gameObject.SetActive(true);
((Component)val.transform.GetChild(2)).gameObject.SetActive(true);
}
else
{
((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>().fontSize = 55f;
((Component)val.transform.GetChild(1)).GetComponent<TMP_Text>().fontSize = 45f;
((Component)val.transform.GetChild(2)).GetComponent<TMP_Text>().fontSize = 38f;
((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>().text = "BOUNTY " + enemyName.ToUpper() + " KILLED";
((Component)val.transform.GetChild(1)).GetComponent<TMP_Text>().text = playerThatKilledName + " stompped it 6 feet down!";
((Component)val.transform.GetChild(2)).GetComponent<TMP_Text>().text = "The Company values it at " + rewardForKill;
((Component)val.transform.GetChild(0)).gameObject.SetActive(true);
((Component)val.transform.GetChild(1)).gameObject.SetActive(true);
((Component)val.transform.GetChild(2)).gameObject.SetActive(true);
}
Animator component = val.GetComponent<Animator>();
if (!Object.op_Implicit((Object)(object)component))
{
Utils.DebugLog("ERROR: UIManager() => notificationElementAnimator = NULL");
}
else
{
val.AddComponent<ElementDespawn>().StartTimer(secondsOnScreen, component);
}
}
public void ShowEnemyBountyNotfication(string enemyName, int rewardForKill, int secondsOnScreen)
{
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
if (!Object.op_Implicit((Object)(object)topNotificationParent))
{
Utils.DebugLog("ERROR: UIManager() => topNotificationParent = NULL");
return;
}
GameObject val = Object.Instantiate<GameObject>(notificationElementObj[1], topNotificationParent, false);
if (!Object.op_Implicit((Object)(object)val))
{
Utils.DebugLog("ERROR: UIManager() => notificationElement = NULL");
return;
}
val.SetActive(true);
val.transform.localPosition = new Vector3(0f, 0f, 0f);
((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>().fontSize = 80f;
((Component)val.transform.GetChild(1)).GetComponent<TMP_Text>().fontSize = 50f;
((Component)val.transform.GetChild(2)).GetComponent<TMP_Text>().fontSize = 50f;
((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>().text = "bounty Has Awoken".ToUpper();
((Component)val.transform.GetChild(1)).GetComponent<TMP_Text>().text = "Find and kill " + enemyName;
((Component)val.transform.GetChild(2)).GetComponent<TMP_Text>().text = "The Company will reward with " + rewardForKill + " for its tomb!";
((Component)val.transform.GetChild(0)).gameObject.SetActive(true);
((Component)val.transform.GetChild(1)).gameObject.SetActive(true);
((Component)val.transform.GetChild(2)).gameObject.SetActive(true);
Animator component = val.GetComponent<Animator>();
if (!Object.op_Implicit((Object)(object)component))
{
Utils.DebugLog("ERROR: UIManager() => notificationElementAnimator = NULL");
}
else
{
val.AddComponent<ElementDespawn>().StartTimer(secondsOnScreen, component);
}
}
}
}
namespace KillThemAll.Hooks
{
internal class UnityHook
{
private const string modGUID = "KillThemAll.Unity";
static UnityHook()
{
}
[HarmonyPrefix]
[HarmonyPatch(typeof(NetworkManager), "DespawnObject")]
private static void PrefixDespawn(NetworkSpawnManager __instance, NetworkObject networkObject, bool destroyObject)
{
if (Object.op_Implicit((Object)(object)networkObject))
{
EnemyAI component = ((Component)networkObject).GetComponent<EnemyAI>();
if ((Object)(object)component != (Object)null)
{
KillableEnemyManager.Instance.EnemyAIToNetworkObjectID.Remove(component);
KillableEnemyManager.Instance.NetworkObjectIDToEnemyAI.Remove(((NetworkBehaviour)component).NetworkObjectId);
Utils.DebugLog("Removed " + ((Object)component).name + "'s network object");
}
}
}
}
internal class VanillaHook
{
private const string modGUID = "KillThemAll.Vanilla";
static VanillaHook()
{
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
private static void GameNetworkManagerPostStart(GameNetworkManager __instance)
{
KillThemAll.instance.Initialise();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "SaveItemsInShip")]
private static void SaveItemsInShipPost()
{
Utils.DebugLog("Items saved!------------------------");
if (Utils.isHost)
{
KillThemAll.instance.RemoveSavedTombThatDontExist(GameNetworkManager.Instance.currentSaveFileName);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "OnClientConnect")]
private static void OnClientConnectPostfix(ulong clientId)
{
if (!Utils.isHost)
{
return;
}
List<TombScrap> list = Object.FindObjectsByType<TombScrap>((FindObjectsInactive)0, (FindObjectsSortMode)0).ToList();
foreach (TombScrap item in list)
{
ulong networkObjectId = ((Component)item).GetComponent<NetworkObject>().NetworkObjectId;
((Component)StartOfRound.Instance.allPlayerScripts[0]).gameObject.GetComponent<TombScrapEmitter>().SendTombDataSaveServerRpc(networkObjectId, item.enemyName, item.playerName, item.meshIndex, item.matIndex);
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(DeleteFileButton), "DeleteFile")]
private static void PrefixDeleteFileButton()
{
int fileToDelete = Object.FindAnyObjectByType<DeleteFileButton>().fileToDelete;
if (1 == 0)
{
}
string text = fileToDelete switch
{
0 => "LCSaveFile1",
1 => "LCSaveFile2",
2 => "LCSaveFile3",
_ => "LCSaveFile1",
};
if (1 == 0)
{
}
string text2 = text;
KillThemAll.instance.OnDeleteGameSave(text2);
Utils.DebugLog("Delete saved = " + text2);
}
[HarmonyPatch(typeof(RoundManager), "Start")]
[HarmonyPrefix]
private static void GetHost()
{
Utils.isHost = ((NetworkBehaviour)RoundManager.Instance).NetworkManager.IsHost;
Utils.DebugLog("RoundManager start=> Round Started");
}
[HarmonyPatch(typeof(RoundManager), "Update")]
[HarmonyPrefix]
private static void OnRoundManagerUpdate()
{
if (Object.op_Implicit((Object)(object)StartOfRound.Instance) && Utils.isHost && RoundManager.Instance.isSpawningEnemies && !StartOfRound.Instance.shipIsLeaving)
{
BountyManager.Instance.ServerUpdateOnRoundStart();
}
}
[HarmonyPatch(typeof(RoundManager), "DespawnPropsAtEndOfRound")]
[HarmonyPrefix]
private static void OnRoundManagerEnd()
{
if (Object.op_Implicit((Object)(object)StartOfRound.Instance) && Utils.isHost)
{
BountyManager.Instance.ServerUpdateOnRoundEnd();
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
private static void PostfixStartPlayer(PlayerControllerB __instance)
{
if (Utils.IsLocalPlayer(__instance))
{
KillableEnemyManager.Instance.SetupHitmarkerHUD(__instance);
UIManager.Instance.Initialise();
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(EnemyAI), "Start")]
private static void PostfixStartEnemy(EnemyAI __instance)
{
if (Object.op_Implicit((Object)(object)__instance) && Utils.isHost && !Object.op_Implicit((Object)(object)((Component)__instance).gameObject.GetComponent<KillableEnemy>()))
{
KillableEnemyManager.Instance.AssignKillableClassToEnemy(__instance);
Utils.DebugLog("Assigned values on host?: " + Utils.isHost);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(EnemyAI), "Update")]
private static void PostfixUpdateEnemy(EnemyAI __instance)
{
if (Object.op_Implicit((Object)(object)__instance) && Utils.isHost && !Object.op_Implicit((Object)(object)((Component)__instance).gameObject.GetComponent<KillableEnemy>()))
{
KillableEnemyManager.Instance.AssignKillableClassToEnemy(__instance);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(EnemyAI), "HitEnemy")]
private static void HitPostfix(EnemyAI __instance, int force = 1, PlayerControllerB playerWhoHit = null, bool playHitSFX = false)
{
if (Object.op_Implicit((Object)(object)playerWhoHit))
{
if (Utils.IsLocalPlayer(playerWhoHit))
{
KillableEnemyManager.Instance.PlayHitmarkerLocal(playerWhoHit);
}
if (Utils.isHost)
{
Utils.DebugLog("Hook: OnEnemyHit() Prepare ServerRPC");
KillableEnemyManager.Instance.OnEnemyHitPrepareServerRPC(((NetworkBehaviour)__instance).NetworkObjectId, ((NetworkBehaviour)playerWhoHit).NetworkObjectId, force);
}
}
}
[HarmonyPatch(typeof(Terminal), "Start")]
[HarmonyPostfix]
private static void GetAllEnemies(ref SelectableLevel[] ___moonsCatalogueList, Terminal __instance)
{
SelectableLevel[] array = ___moonsCatalogueList;
SpawnEnemyManager.Enemy item = default(SpawnEnemyManager.Enemy);
SelectableLevel[] array2 = array;
foreach (SelectableLevel level in array2)
{
int e;
for (e = 0; e < level.Enemies.Count; e++)
{
if (!SpawnEnemyManager.listOfSpawnableEnemies.Any((SpawnEnemyManager.Enemy x) => x.name == level.Enemies[e].enemyType.enemyName) && !(level.Enemies[e].enemyType.enemyName == "Lasso"))
{
item.name = level.Enemies[e].enemyType.enemyName;
item.prefab = level.Enemies[e].enemyType.enemyPrefab;
item.isOutside = level.Enemies[e].enemyType.isOutsideEnemy;
Utils.DebugLog("Terminal start=> Enemy Found: " + item.name);
SpawnEnemyManager.listOfSpawnableEnemies.Add(item);
}
}
int i;
for (i = 0; i < level.OutsideEnemies.Count; i++)
{
if (!SpawnEnemyManager.listOfSpawnableEnemies.Any((SpawnEnemyManager.Enemy x) => x.name == level.OutsideEnemies[i].enemyType.enemyName) && !(level.Enemies[i].enemyType.enemyName == "Lasso"))
{
item.name = level.OutsideEnemies[i].enemyType.enemyName;
item.prefab = level.OutsideEnemies[i].enemyType.enemyPrefab;
item.isOutside = level.OutsideEnemies[i].enemyType.isOutsideEnemy;
Utils.DebugLog("Terminal start=> Enemy Found: " + item.name);
SpawnEnemyManager.listOfSpawnableEnemies.Add(item);
}
}
}
BountyManager.Instance.__terminal = __instance;
Utils.DebugLog("server BountyManager.Instance.__terminal " + (object)BountyManager.Instance.__terminal);
}
}
}
namespace KillThemAll.Extras
{
internal class ElementDespawn : MonoBehaviour
{
private float waittimer = 3f;
private Animator animator;
private bool isPlayingEnd = false;
public void StartTimer(float time, Animator animator)
{
Utils.DebugLog("StartTimer for despawn ui " + ((Object)this).name);
waittimer = time;
this.animator = animator;
}
private void Update()
{
waittimer -= Time.deltaTime;
if (waittimer <= 0f && !isPlayingEnd)
{
animator.Play("NotificationEnd", 0);
isPlayingEnd = true;
waittimer = 1f;
}
else if (isPlayingEnd && waittimer <= 0f)
{
Utils.DebugLog("Destroying notificationElement");
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
}
public class TombScrap : GrabbableObject
{
public bool HasJustSpawned = false;
public int id = -1;
public int meshIndex = -1;
public int matIndex = -1;
public int scrapVal = -1;
public string enemyName = "";
public string playerName = "";
public void OnSpawnInit(bool saveLoaded = false)
{
base.fallTime = 1f;
base.grabbable = true;
base.isInFactory = true;
base.grabbableToEnemies = true;
if (saveLoaded)
{
base.scrapPersistedThroughRounds = true;
base.isInElevator = true;
base.isInShipRoom = true;
}
if (!Object.op_Implicit((Object)(object)base.itemProperties))
{
base.itemProperties = KillableEnemyManager.Instance.enemyTomb;
}
base.itemProperties.saveItemVariable = true;
base.customGrabTooltip = "Grab Tomb : [E]";
base.mainObjectRenderer = ((Component)this).GetComponent<MeshRenderer>();
HasJustSpawned = true;
if (id == -1)
{
id = Random.Range(0, 99999);
}
UpdateObject();
((Behaviour)this).enabled = true;
}
public override int GetItemDataToSave()
{
KillThemAll.instance.SaveTombScrapOnShip(GameNetworkManager.Instance.currentSaveFileName, id, meshIndex, matIndex, enemyName, playerName);
return id;
}
public override void LoadItemSaveData(int saveDataID)
{
Tomb tombById = KillThemAll.instance.GetTombById(saveDataID, GameNetworkManager.Instance.currentSaveFileName);
if (tombById == null)
{
if (!Utils.isHost)
{
return;
}
Utils.DebugLog("not found saved tomb with id of: " + saveDataID);
}
enemyName = tombById.enemyName;
playerName = tombById.playerThatKilled;
meshIndex = tombById.meshIndex;
matIndex = tombById.matIndex;
Utils.DebugLog("Tomb saved loaded: " + saveDataID);
OnSpawnInit(saveLoaded: true);
}
public void LoadItemSaveDataOnJoin(string enemyName, string playerName, int meshIndex, int matIndex)
{
if (!(this.enemyName != ""))
{
this.enemyName = enemyName;
this.playerName = playerName;
this.meshIndex = meshIndex;
this.matIndex = matIndex;
Utils.DebugLog("Tomb saved loaded");
OnSpawnInit(saveLoaded: true);
}
}
public override void Update()
{
//IL_0170: Unknown result type (might be due to invalid IL or missing references)
//IL_0257: Unknown result type (might be due to invalid IL or missing references)
//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0211: Unknown result type (might be due to invalid IL or missing references)
//IL_022a: Unknown result type (might be due to invalid IL or missing references)
//IL_023b: Unknown result type (might be due to invalid IL or missing references)
if (base.currentUseCooldown >= 0f)
{
base.currentUseCooldown -= Time.deltaTime;
}
if (((NetworkBehaviour)this).IsOwner)
{
if (base.isBeingUsed && base.itemProperties.requiresBattery)
{
if (base.insertedBattery.charge > 0f)
{
if (!base.itemProperties.itemIsTrigger)
{
Battery insertedBattery = base.insertedBattery;
insertedBattery.charge -= Time.deltaTime / base.itemProperties.batteryUsage;
}
}
else if (!base.insertedBattery.empty)
{
base.insertedBattery.empty = true;
if (base.isBeingUsed)
{
Debug.Log((object)"Use up batteries local");
base.isBeingUsed = false;
((GrabbableObject)this).UseUpBatteries();
}
}
}
if (!base.wasOwnerLastFrame)
{
base.wasOwnerLastFrame = true;
}
}
else if (base.wasOwnerLastFrame)
{
base.wasOwnerLastFrame = false;
}
if (base.isHeld || !((Object)(object)base.parentObject == (Object)null))
{
return;
}
if (base.fallTime < 1f)
{
base.reachedFloorTarget = false;
((GrabbableObject)this).FallWithCurve();
if (((Component)this).transform.localPosition.y - base.targetFloorPosition.y < 0.1f && !base.hasHitGround)
{
((GrabbableObject)this).PlayDropSFX();
((GrabbableObject)this).OnHitGround();
}
return;
}
if (!base.reachedFloorTarget)
{
base.reachedFloorTarget = true;
if (base.floorYRot == -1)
{
}
Vector3 val = default(Vector3);
((Vector3)(ref val))..ctor(((Component)this).transform.position.x, ((Component)this).transform.position.y - 0.5f, ((Component)this).transform.position.z);
GameObject val2 = Object.Instantiate<GameObject>(KillableEnemyManager.Instance.tombDropEffect, val, KillableEnemyManager.Instance.tombDropEffect.transform.rotation);
val2.AddComponent<VfxDespawn>();
}
((Component)this).transform.localPosition = base.targetFloorPosition;
}
public override void FallWithCurve()
{
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
float num = base.startFallingPosition.y - base.targetFloorPosition.y;
if (!HasJustSpawned)
{
((Component)this).transform.rotation = Quaternion.Euler(base.itemProperties.restingRotation.x, (float)(base.floorYRot + base.itemProperties.floorYOffset) + 90f, base.itemProperties.restingRotation.z);
}
if (base.floorYRot == -1)
{
}
if (num > 5f)
{
((Component)this).transform.localPosition = Vector3.Lerp(base.startFallingPosition, base.targetFloorPosition, StartOfRound.Instance.objectFallToGroundCurveNoBounce.Evaluate(base.fallTime));
}
else
{
((Component)this).transform.localPosition = Vector3.Lerp(base.startFallingPosition, base.targetFloorPosition, StartOfRound.Instance.objectFallToGroundCurve.Evaluate(base.fallTime));
}
base.fallTime += Mathf.Abs(Time.deltaTime * 6f / num);
}
public override void OnHitGround()
{
((GrabbableObject)this).OnHitGround();
if (HasJustSpawned)
{
HasJustSpawned = false;
}
}
public void UpdateObject()
{
if (scrapVal != -1)
{
base.scrapValue = scrapVal;
}
((GrabbableObject)this).SetScrapValue(base.scrapValue);
((Component)this).GetComponent<MeshFilter>().mesh = base.itemProperties.meshVariants[meshIndex];
((Renderer)((Component)this).GetComponent<MeshRenderer>()).material = base.itemProperties.materialVariants[matIndex];
Transform transform = ((Component)((Component)((Component)this).transform.GetChild(1)).transform.GetChild(0)).transform;
((Component)transform.GetChild(0)).GetComponent<TMP_Text>().text = enemyName;
((Component)transform.GetChild(2)).GetComponent<TMP_Text>().text = playerName;
}
}
[VFXBinder("Transform/TransformBinder")]
public class TransformBinder : VFXBinderBase
{
[VFXPropertyBinding(new string[] { "UnityEditor.VFX.Transform" })]
[SerializeField]
[FormerlySerializedAs("m_Parameter")]
protected ExposedProperty m_Property = ExposedProperty.op_Implicit("Transform");
public Transform Target = null;
private ExposedProperty Position;
private ExposedProperty Angles;
private ExposedProperty Scale;
public string Property
{
get
{
return (string)m_Property;
}
set
{
m_Property = ExposedProperty.op_Implicit(value);
UpdateSubProperties();
}
}
protected override void OnEnable()
{
((VFXBinderBase)this).OnEnable();
UpdateSubProperties();
}
private void OnValidate()
{
UpdateSubProperties();
}
private void UpdateSubProperties()
{
Position = m_Property + ExposedProperty.op_Implicit("_position");
Angles = m_Property + ExposedProperty.op_Implicit("_angles");
Scale = m_Property + ExposedProperty.op_Implicit("_scale");
}
public override bool IsValid(VisualEffect component)
{
return (Object)(object)Target != (Object)null && component.HasVector3(ExposedProperty.op_Implicit(Position)) && component.HasVector3(ExposedProperty.op_Implicit(Angles)) && component.HasVector3(ExposedProperty.op_Implicit(Scale));
}
public override void UpdateBinding(VisualEffect component)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
component.SetVector3(ExposedProperty.op_Implicit(Position), Target.position);
component.SetVector3(ExposedProperty.op_Implicit(Angles), Target.eulerAngles);
component.SetVector3(ExposedProperty.op_Implicit(Scale), Target.localScale);
}
public override string ToString()
{
return string.Format("Transform : '{0}' -> {1}", m_Property, ((Object)(object)Target == (Object)null) ? "(null)" : ((Object)Target).name);
}
}
internal class Utils
{
public static bool isHost;
private static ManualLogSource mls;
private const string modGUID = "KillThemAll";
public static void SetupLog()
{
mls = Logger.CreateLogSource("KillThemAll");
}
public static void DebugLog(string log)
{
if (KillableEnemyManager.Instance.debugLog)
{
mls.LogInfo((object)("--KillThemAll | " + log));
}
}
public static bool IsLocalPlayer(PlayerControllerB playerControllerClass)
{
return (Object)(object)StartOfRound.Instance.localPlayerController == (Object)(object)playerControllerClass;
}
internal static void DebugLog(object p)
{
throw new NotImplementedException();
}
public static PlayerControllerB GetPlayerClassFromNetID(ulong clientID)
{
if (clientID < 0 || !Object.op_Implicit((Object)(object)NetworkManager.Singleton) || !Object.op_Implicit((Object)(object)((Component)NetworkManager.Singleton.SpawnManager.SpawnedObjects[clientID]).gameObject))
{
return null;
}
return ((Component)NetworkManager.Singleton.SpawnManager.SpawnedObjects[clientID]).gameObject.GetComponent<PlayerControllerB>();
}
public static EnemyAI GetEnemyAIClassFromNetID(ulong enemyID)
{
if (enemyID < 0 || !Object.op_Implicit((Object)(object)NetworkManager.Singleton) || !Object.op_Implicit((Object)(object)((Component)NetworkManager.Singleton.SpawnManager.SpawnedObjects[enemyID]).gameObject))
{
return null;
}
return ((Component)NetworkManager.Singleton.SpawnManager.SpawnedObjects[enemyID]).gameObject.GetComponent<EnemyAI>();
}
public static string GetEnemyName(ulong enemyID)
{
if (enemyID < 0 || !Object.op_Implicit((Object)(object)NetworkManager.Singleton) || !Object.op_Implicit((Object)(object)((Component)NetworkManager.Singleton.SpawnManager.SpawnedObjects[enemyID]).gameObject))
{
return null;
}
EnemyAI component = ((Component)NetworkManager.Singleton.SpawnManager.SpawnedObjects[enemyID]).gameObject.GetComponent<EnemyAI>();
string name = ((Object)component).name;
name = name.Replace("Enemy", "");
name = name.Replace("(Clone)", "");
name = name.Replace(".prefab", "");
name = name.Replace("default_", "");
name = name.Replace("Obj", "");
name = name.Replace("(", "");
return name.Replace(")", "");
}
public static string GetEnemyName(EnemyAI enemyClass)
{
string name = ((Object)enemyClass).name;
name = name.Replace("Enemy", "");
name = name.Replace("(Clone)", "");
name = name.Replace(".prefab", "");
name = name.Replace("default_", "");
name = name.Replace("Obj", "");
name = name.Replace("(", "");
return name.Replace(")", "");
}
public static double SimilarityRatio(string str1, string str2)
{
int num = LevenshteinDistance(str1, str2);
int num2 = Math.Max(str1.Length, str2.Length);
return 1.0 - (double)num / (double)num2;
}
public static int LevenshteinDistance(string str1, string str2)
{
int[,] array = new int[str1.Length + 1, str2.Length + 1];
for (int i = 0; i <= str1.Length; i++)
{
for (int j = 0; j <= str2.Length; j++)
{
if (i == 0)
{
array[i, j] = j;
continue;
}
if (j == 0)
{
array[i, j] = i;
continue;
}
int num = ((str1[i - 1] != str2[j - 1]) ? 1 : 0);
array[i, j] = Math.Min(array[i - 1, j] + 1, Math.Min(array[i, j - 1] + 1, array[i - 1, j - 1] + num));
}
}
return array[str1.Length, str2.Length];
}
public static GameObject GetScrapObject(ulong scrapID)
{
if (scrapID < 0 || !Object.op_Implicit((Object)(object)NetworkManager.Singleton) || !Object.op_Implicit((Object)(object)((Component)NetworkManager.Singleton.SpawnManager.SpawnedObjects[scrapID]).gameObject))
{
DebugLog("Scrap ID: " + scrapID + " Not found or Network Manager does not exist");
return null;
}
return ((Component)NetworkManager.Singleton.SpawnManager.SpawnedObjects[scrapID]).gameObject;
}
public static int GetTimeOfRound()
{
int num = (int)(TimeOfDay.Instance.normalizedTimeOfDay * (60f * (float)TimeOfDay.Instance.numberOfHours)) + 360;
return (int)Mathf.Floor((float)(num / 60));
}
}
public class VfxDespawn : MonoBehaviour
{
private float waittimer = 3f;
private void Start()
{
waittimer = 3f;
}
private void Update()
{
waittimer -= Time.deltaTime;
if (waittimer <= 0f)
{
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
}
}
