SDM_LethalCompany_Mod/ScarletMansion/ScarletMansion/Assets.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
using System.Reflection;
using System.IO;
using DunGen.Graph;
using UnityEngine.Experimental.Rendering;
using LethalLib.Modules;
using LethalLevelLoader;
using ScarletMansion.GamePatch.Items;
using static ScarletMansion.Assets;
using DunGenPlus;

namespace ScarletMansion {
  public static class Assets {

    static BepInEx.Logging.ManualLogSource logger => Plugin.logger;

    public static ActionList onAssetsLoadEvent = new ActionList("onAssetsLoad");

    const string mainAssetBundleName = "scarletmansion";

    // main assets
    public static AssetBundle MainAssetBundle = null;
		public static DungeonFlow dungeon;
    public static DunGenExtender dunGenExtender;
    public static NetworkObjectListScriptableObject networkObjectList;
    public static AudioClip entranceAudioClip;

    // extended dungeon values
    public static ExtendedMod extendedMod;
    public static ExtendedDungeonFlow dungeonExtended;

    // enemy values

    public class Enemy {
      public GameObject enemy;
      public EnemyType enemyType;
      public Func<int> rarityFunc;

      public TerminalNode terminalNode;
      public TerminalKeyword terminalKeyword;

      public Enemy(GameObject enemy, TerminalNode node, TerminalKeyword keyword) {
        this.enemy = enemy;
        this.terminalNode = node;
        this.terminalKeyword = keyword;
      }

      public SpawnableEnemyWithRarity GetItemEntry(int rarity){
        var entry = new SpawnableEnemyWithRarity();
        entry.enemyType = enemyType;
        entry.rarity = rarity;
        return entry;
      }
    }

    public static Enemy knight;
    public static Enemy maid;

    // item values

    public class GlobalItem {
      public Item item;
      private int _itemId;

      public GlobalItem(Item item) {
        this.item = item;
        _itemId = -1;
      }


      public int itemId {
        get {
          // cache time
          if (_itemId == -1 && StartOfRound.Instance) {
            var itemString = item ? item.itemName : "NULL";
            _itemId = Utility.GetGlobalItemId(item);

            if (_itemId != -1) {
              Plugin.logger.LogWarning($"Cached {_itemId} itemId for item {itemString}");
              return _itemId;
            }
            Plugin.logger.LogWarning($"Tried to get itemId for item {itemString} but failed");
          }

          return _itemId;
        } set {
          _itemId = value;
        }
      }
    }

    public class ScrapItem : GlobalItem {
      public Func<int> rarityFunc;

      public ScrapItem(Item item, Func<int> func) : base (item){
        rarityFunc = func;
      }

      public SpawnableItemWithRarity GetItemRarity(){
        var item = new SpawnableItemWithRarity();
        item.spawnableItem = this.item;
        item.rarity = rarityFunc();
        return item;
      }

    }

    public class Flashlight : GlobalItem {
      public string assetName;
      public string displayName;

      public Item lethalVanillaItem;
      public int lethalHelmetIndex = -1;
      public int scarletHelmetIndex = -1;

      public Flashlight(string baseName, int lethalHelmetIndex) : base(null) {
        assetName = $"Scarlet{baseName}";
        displayName = $"D. {baseName}";
        this.lethalHelmetIndex = lethalHelmetIndex;
      }

      public bool ContainsItem(Item compareItem) {
        return compareItem == item || compareItem == lethalVanillaItem;
      }
    }

    public static List<GlobalItem> globalItems;
    public static List<ScrapItem> scrapItems;    

    public static Dictionary<string, Func<int>> itemRarityTable = new Dictionary<string, Func<int>>(){
      { "Deco. crystal", () => PluginConfig.Instance.crystalWeightValue },
      { "Shattered deco. crystal", () => PluginConfig.Instance.crystalBrokenWeightValue },
      { "Demonic painting", () => 0 },
      { "Maid's knife", () => 0 },
      { "Doll Snow Globe", () => PluginConfig.Instance.snowGlobeWeightValue }
    };


    public static Flashlight flashlight;
    public static Flashlight flashlightBB;
    public static GlobalItem key;

    public static GlobalItem GetGlobalItem(Item item){
      return globalItems.FirstOrDefault(x => x.item == item);
    }

    public static Flashlight GetFlashlight(Item item){
      if (flashlight.ContainsItem(item)) return flashlight;
      if (flashlightBB.ContainsItem(item)) return flashlightBB;
      return null;
    }

    // game references

    public static ItemGroup genericItemGroup;
    public static ItemGroup tabletopItemGroup;
    public static ItemGroup smallItemGroup;

    public static bool dungeonMapHazardFound;
    public static GameObject dungeonTurretMapHazard;
    public static GameObject dungeonMinesMapHazard;
    public static GameObject dungeonSpikeTrapMapHazard;

    public static Sprite hoverIcon;

    public static void LoadAssetBundle() {
      if (MainAssetBundle == null) {
        var assembly = Assembly.GetExecutingAssembly();
        var resourceNames = assembly.GetManifestResourceNames();
        if (resourceNames.Length >= 1) {
          var name = resourceNames[0];
          using (var assetStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name)) {
            Plugin.logger.LogDebug($"Loading resource {name}");
            MainAssetBundle = AssetBundle.LoadFromStream(assetStream);
          }
        }
        
      }

      dungeon = Load<DungeonFlow>("SDMLevel");
      networkObjectList = Load<NetworkObjectListScriptableObject>("SDMList");
      dunGenExtender = Load<DunGenExtender>("DunGenExtender");
      entranceAudioClip = Load<AudioClip>("entrance_ogg");

      knight = new Enemy(
        Load<GameObject>("NET_KnightEnemy"),
        Load<TerminalNode>("KnightNode"),
        Load<TerminalKeyword>("KnightKeyword")
      );

      maid = new Enemy(
        Load<GameObject>("NET_MaidEnemy"),
        Load<TerminalNode>("MaidNode"),
        Load<TerminalKeyword>("MaidKeyword")
      );

      RegisterNetworkPrefab(networkObjectList.networkDungeon);
      RegisterNetworkPrefab(networkObjectList.networkDoors);
      RegisterNetworkPrefab(networkObjectList.networkItems);
      RegisterNetworkPrefab(networkObjectList.networkFrames);
      RegisterNetworkPrefab(networkObjectList.networkOther);

      globalItems = new List<GlobalItem>();
      scrapItems = new List<ScrapItem>();
      foreach(var i in networkObjectList.items){
        var entry = new GlobalItem(i);
        globalItems.Add(entry);

        Items.RegisterItem(i);
        Plugin.logger.LogDebug($"Global Item {i.itemName} registered");
      }

      foreach(var i in networkObjectList.scrapItems) {
        var entry = new ScrapItem(i, GetItemRarityFunction(i));
        scrapItems.Add(entry);
        globalItems.Add(entry);

        Items.RegisterScrap(i, 0, Levels.LevelTypes.None);
        NetworkPrefabs.RegisterNetworkPrefab(i.spawnPrefab);
        Plugin.logger.LogDebug($"Scrap Item {i.itemName} registered");
      }

      flashlight = new Flashlight("Pro Flashlight", 0);
      flashlightBB = new Flashlight("Flashlight", 1);
      key = new GlobalItem(networkObjectList.items[0]);
      globalItems.Add(flashlight);
      globalItems.Add(flashlightBB);

      foreach(var e in networkObjectList.enemies) {
        Enemies.RegisterEnemy(e, 0, Levels.LevelTypes.None, null, null);
        NetworkPrefabs.RegisterNetworkPrefab(e.enemyPrefab);
      }

      onAssetsLoadEvent.Call();
    }

    public static Func<int> GetItemRarityFunction(Item item){
      var name = item.itemName;
      
      if (itemRarityTable.ContainsKey(name)){
        return itemRarityTable[name];
      }

      Plugin.logger.LogError($"Could not find rarity function for {name}. Setting to default value 10");
      return () => 10;
    }


    private static void RegisterNetworkPrefab(List<GameObject> list){
      foreach(var p in list){
        NetworkPrefabs.RegisterNetworkPrefab(p);
      }
    }

    public static T Load<T>(string name, bool onlyReportErrors = true) where T: UnityEngine.Object {
      if (MainAssetBundle == null){
        logger.LogError($"Trying to load in asset but asset bundle is missing");
        return null;
      }

      var asset = MainAssetBundle.LoadAsset<T>(name);
      var missingasset = asset == null;

      if (missingasset || onlyReportErrors == true) {
        logger.LogDebug($"Loading asset {name}");
      }

      if (missingasset) {
        logger.LogError($"...but it was not found");
      }

      return asset;

    }
  }
}