SDM_LethalCompany_Mod/ScarletMansion/ScarletMansion/DunGenPatch/GeneratePathPatch.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using HarmonyLib;
using GameNetcodeStuff;
using System.Reflection;
using System.Reflection.Emit;
using BepInEx.Logging;
using UnityEngine;
using System.Collections;
using DunGen;
using LethalLevelLoader;

namespace ScarletMansion.DunGenPatch {

  public class GeneratePathPatch {

    [HarmonyPatch(typeof(RoundManager), "GenerateNewFloor")]
    [HarmonyPrefix]
    public static void DungeonGeneratorGenerate_PrefixPrefix(){
      // safety check
      Plugin.logger.LogInfo("Disabling SDM logic");
      Patch.Deactivate();
      //Patch.ActivateAnalysis();
    }

    public static void GeneratePatch(RoundManager roundManager){
      Plugin.logger.LogInfo("Loading Scarlet Mansion map so we are activating the alt. dungen scripts");
      Patch.Activate(roundManager.dungeonGenerator.Generator);
    }

    [HarmonyPostfix]
    [HarmonyPatch(typeof(DungeonGenerator), "GenerateMainPath")]
    public static void GenerateMainPathPatch(ref DungeonGenerator __instance, ref IEnumerator __result){
      if (Patch.active && Patch.callAlternative) {
        GeneratePath.RandomizeLineArchetypes(__instance, true);
      }
    }

    [HarmonyPostfix]
    [HarmonyPatch(typeof(DungeonGenerator), "GenerateBranchPaths")]
    public static void GenerateBranchPathsPatch(ref DungeonGenerator __instance, ref IEnumerator __result){
      if (Patch.active && Patch.callAlternative) {
        __result = GeneratePath.GenerateAlternativeMainPaths(__instance);
      }
    }

    [HarmonyPostfix]
    [HarmonyPatch(typeof(RoundManager), "FinishGeneratingLevel")]
    public static void GenerateBranchPathsPatch(){
      if (Patch.active) {
        Plugin.logger.LogInfo("Alt. InnerGenerate() function complete");
      }
    }

    [HarmonyTranspiler]
    [HarmonyPatch(typeof(DungeonGenerator), "GenerateMainPath", MethodType.Enumerator)]
    public static IEnumerable<CodeInstruction> GenerateMainPathPatch(IEnumerable<CodeInstruction> instructions){
      
      var addFunction = typeof(List<DungeonArchetype>).GetMethod("Add", BindingFlags.Instance | BindingFlags.Public);

      var sequence = new InstructionSequence("archetype node");
      sequence.AddOperandTypeCheck(OpCodes.Ldfld, typeof(List<DungeonArchetype>));
      sequence.AddBasic(OpCodes.Ldnull);
      sequence.AddBasic(OpCodes.Callvirt, addFunction);

      foreach(var instruction in instructions){

        if (sequence.VerifyStage(instruction)){

          var method = typeof(GeneratePath).GetMethod("ModifyMainBranchNodeArchetype", BindingFlags.Public | BindingFlags.Static);

          yield return new CodeInstruction(OpCodes.Ldloc_S, 8);
          yield return new CodeInstruction(OpCodes.Call, method);

          yield return instruction;

          continue;
        }

        yield return instruction;
      }

      sequence.ReportComplete();
    }
    
    /*
    
    [HarmonyPatch(typeof(DungeonGenerator), "AddTile")]
    [HarmonyPostfix]
    public static void AddTilePatch(TileProxy attachTo, IEnumerable<TileSet> useableTileSets, DungeonArchetype archetype, ref TileProxy __result){
      var atString = attachTo != null ? attachTo.Prefab.ToString() : "NULL";
      var aString = archetype ? archetype.ToString() : "NULL";
      var rString = __result != null ? __result.Prefab.ToString() : "NULL";

      Plugin.logger.LogInfo($"");
      Plugin.logger.LogInfo($"Attach: {atString}");
      Plugin.logger.LogInfo($"ValidCount: {useableTileSets.Sum(u => u.TileWeights.Weights.Count).ToString()}");
      Plugin.logger.LogInfo($"Entry: {aString}");
      Plugin.logger.LogInfo($"Result: {rString}");
      
    }
    
    [HarmonyPatch(typeof(DungeonGenerator), "TryPlaceTile")]
    [HarmonyPostfix]
    public static void TryPlaceTilePatch(ref TilePlacementResult __result){
      Plugin.logger.LogInfo(__result.ToString());
    }

    [HarmonyPatch(typeof(DoorwayPairFinder), "GetDoorwayPairs")]
    [HarmonyPostfix]
    public static void GetDoorwayPairsPatch(ref  Queue<DoorwayPair> __result){
      Plugin.logger.LogInfo(__result.Count().ToString());
    }
    */

  }



}