493 lines
21 KiB
C#
493 lines
21 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using HarmonyLib;
|
|
using UnityEngine;
|
|
using DunGen.Graph;
|
|
using ScarletMansion.DunGenPatch;
|
|
using LethalLib.Modules;
|
|
using Unity.Netcode;
|
|
using LethalLevelLoader;
|
|
using static UnityEngine.GraphicsBuffer;
|
|
using ScarletMansion.GamePatch.Components;
|
|
using System.Security.Cryptography;
|
|
using ScarletMansion.GamePatch.Enemies;
|
|
using UnityEngine.UI;
|
|
using ScarletMansion.GamePatch.Items;
|
|
|
|
namespace ScarletMansion.GamePatch {
|
|
|
|
public class InitPatch {
|
|
|
|
private static void CreateNetworkManager(StartOfRound __instance){
|
|
Plugin.logger.LogInfo($"IsServer: {__instance.IsServer}");
|
|
if (__instance.IsServer) {
|
|
if (ScarletNetworkManager.Instance == null) {
|
|
var prefab = Assets.networkObjectList.scarletNetworkManager;
|
|
var obj = GameObject.Instantiate(prefab);
|
|
var comp = obj.GetComponent<NetworkObject>();
|
|
comp.Spawn(false);
|
|
Plugin.logger.LogInfo("Created Scarlet Network Manager. We in");
|
|
} else {
|
|
Plugin.logger.LogWarning("Scarlet Network Manager already exists? Probably scary");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static IEnumerator WaitForNetworkObject(StartOfRound __instance, Action<StartOfRound> action){
|
|
while(__instance.NetworkObject.IsSpawned == false) {
|
|
yield return null;
|
|
}
|
|
action(__instance);
|
|
}
|
|
|
|
[HarmonyPatch(typeof(StartOfRound), "Awake")]
|
|
[HarmonyPrefix]
|
|
public static void StartOfRound_Start(ref StartOfRound __instance) {
|
|
ScarletYukariTrigger.audioClipIndex = -1;
|
|
PlayerAnimatorStateHelper.ClearAnimators();
|
|
|
|
__instance.StartCoroutine(WaitForNetworkObject(__instance, CreateNetworkManager));
|
|
|
|
/*
|
|
foreach(var p in __instance.levels){
|
|
var totalScrap = p.spawnableScrap.Sum(s => s.rarity);
|
|
var totalEnemy = p.Enemies.Sum(s => s.rarity);
|
|
Plugin.logger.LogInfo($"{p.PlanetName}: S{totalScrap}, E{totalEnemy}");
|
|
}*/
|
|
|
|
// safety cleaning
|
|
DunGenPatch.Patch.Deactivate();
|
|
//ScarletLightingManager.Clean();
|
|
|
|
FixMapReferences(__instance);
|
|
FixItemPrefabValues(__instance);
|
|
|
|
// fix audio clips
|
|
var statusEffectClips = __instance.statusEffectClips.ToList();
|
|
ScarletYukariTrigger.audioClipIndex = statusEffectClips.Count;
|
|
statusEffectClips.Add(Assets.networkObjectList.sinkingAudioClip);
|
|
__instance.statusEffectClips = statusEffectClips.ToArray();
|
|
|
|
// DunGenAnalyis.Analysis(Assets.dungeon, __instance, RoundManager.Instance);
|
|
}
|
|
|
|
[HarmonyPatch(typeof(RoundManager), "Awake")]
|
|
[HarmonyPrefix]
|
|
public static void RoundManagerAwakePatch(ref RoundManager __instance) {
|
|
FixDungeonPrefabValues(__instance);
|
|
|
|
/*
|
|
foreach(var d in __instance.dungeonFlowTypes) {
|
|
Plugin.logger.LogInfo("--------");
|
|
Plugin.logger.LogInfo($"{d.name}: {d.Length.ToString()}");
|
|
Plugin.logger.LogInfo($"{d.BranchMode}: {d.BranchCount.ToString()}");
|
|
foreach(var l in d.Lines){
|
|
Plugin.logger.LogInfo($" {l.Position}, {l.Length}");
|
|
foreach(var a in l.DungeonArchetypes){
|
|
Plugin.logger.LogInfo($" {a.BranchCount.ToString()}, {a.BranchingDepth.ToString()}");
|
|
}
|
|
}
|
|
Plugin.logger.LogInfo("--------\n");
|
|
}
|
|
*/
|
|
}
|
|
|
|
[HarmonyPatch(typeof(RoundManager), "Start")]
|
|
[HarmonyPostfix]
|
|
public static void RoundManagerStartPatch(ref RoundManager __instance) {
|
|
MyOwnCoroutine.AddCoroutine(UpdateNetworkConfig(__instance));
|
|
}
|
|
|
|
public static bool GameReadNullCheck(object target, string targetString, string error) {
|
|
if (target == null) {
|
|
Plugin.logger.LogError($"Error when find ({targetString}). {error}!");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static void FixParticleSystemMaterial(ParticleSystemRenderer toFixParticleSystem, ParticleSystemRenderer copyParticleSystem) {
|
|
toFixParticleSystem.sharedMaterial = copyParticleSystem.sharedMaterial;
|
|
}
|
|
|
|
private static void FixParticleSystemMaterial(ParticleSystem toFixParticleSystem, ParticleSystem copyParticleSystem) {
|
|
FixParticleSystemMaterial(toFixParticleSystem.GetComponent<ParticleSystemRenderer>(), copyParticleSystem.GetComponent<ParticleSystemRenderer>());
|
|
}
|
|
|
|
private static void FixParticleSystemMaterialAndChildren(ParticleSystem toFixParticleSystem, ParticleSystem copyParticleSystem) {
|
|
FixParticleSystemMaterial(toFixParticleSystem, copyParticleSystem);
|
|
|
|
for(var i = 0; i < toFixParticleSystem.transform.childCount && i < copyParticleSystem.transform.childCount; ++i) {
|
|
var child0 = toFixParticleSystem.transform.GetChild(i).GetComponent<ParticleSystemRenderer>();
|
|
var child1 = copyParticleSystem.transform.GetChild(i).GetComponent<ParticleSystemRenderer>();
|
|
FixParticleSystemMaterial(child0, child1);
|
|
}
|
|
}
|
|
|
|
public static void FixMapReferences(StartOfRound round){
|
|
|
|
try {
|
|
// use the names of assets instead of the itemName or enemyName
|
|
// to account for the korean patch and such
|
|
if (Assets.genericItemGroup == null || Assets.tabletopItemGroup == null){
|
|
var bottleItem = round.allItemsList.itemsList
|
|
.FirstOrDefault(i => i.name.ToLowerInvariant() == "bottlebin");
|
|
|
|
if (GameReadNullCheck(bottleItem, "bottlebin", "Generic/Tabletop scrap will not spawn")){
|
|
Assets.genericItemGroup = bottleItem.spawnPositionTypes[0];
|
|
Assets.tabletopItemGroup = bottleItem.spawnPositionTypes[1];
|
|
}
|
|
}
|
|
|
|
if (Assets.smallItemGroup == null){
|
|
var cupValue = round.allItemsList.itemsList
|
|
.FirstOrDefault(i => i.name.ToLowerInvariant() == "fancycup");
|
|
|
|
if (GameReadNullCheck(cupValue, "fancycup", "Small scrap will not spawn")){
|
|
Assets.smallItemGroup = cupValue.spawnPositionTypes[1];
|
|
}
|
|
}
|
|
|
|
var allEnemies = round.levels
|
|
.SelectMany(lev => lev.Enemies);
|
|
|
|
var knight = Assets.knight;
|
|
if (knight.enemyType == null){
|
|
var springItem = allEnemies.FirstOrDefault(e => e.enemyType.name.ToLowerInvariant() == "springman");
|
|
|
|
if (GameReadNullCheck(springItem, "springman", "Knight enemy will not spawn")) {
|
|
var type = ScriptableObject.Instantiate(springItem.enemyType);
|
|
type.name = "Knight";
|
|
type.enemyPrefab = knight.enemy;
|
|
type.enemyName = "Knight";
|
|
|
|
knight.enemyType = type;
|
|
knight.enemy.GetComponentInChildren<EnemyAI>().enemyType = type;
|
|
LethalLib.Modules.Enemies.RegisterEnemy(type, 0, Levels.LevelTypes.None, knight.terminalNode, knight.terminalKeyword);
|
|
}
|
|
}
|
|
|
|
var maid = Assets.maid;
|
|
if (maid.enemyType == null){
|
|
var butlerItem = allEnemies.FirstOrDefault(e => e.enemyType.name.ToLowerInvariant() == "butler");
|
|
|
|
if (GameReadNullCheck(butlerItem, "butler", "Maid enemy will not spawn")) {
|
|
var type = ScriptableObject.Instantiate(butlerItem.enemyType);
|
|
type.name = "Maid";
|
|
type.enemyPrefab = maid.enemy;
|
|
type.enemyName = "Maid";
|
|
type.pushPlayerForce *= 0.25f;
|
|
|
|
maid.enemyType = type;
|
|
var maidScript = maid.enemy.GetComponentInChildren<MaidVariant>();
|
|
maidScript.enemyType = type;
|
|
|
|
var butlerPrefab = butlerItem.enemyType.enemyPrefab;
|
|
var butlerScript = butlerPrefab.GetComponent<ButlerEnemyAI>();
|
|
FixParticleSystemMaterialAndChildren(maidScript.stabBloodParticle, butlerScript.stabBloodParticle);
|
|
|
|
LethalLib.Modules.Enemies.RegisterEnemy(type, 0, Levels.LevelTypes.None, maid.terminalNode, maid.terminalKeyword);
|
|
}
|
|
}
|
|
|
|
|
|
} catch (Exception e) {
|
|
Plugin.logger.LogError("Error when reading base game's item list. Pretty big error I would say");
|
|
Plugin.logger.LogError(e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public static void FixItemPrefabValues(StartOfRound round){
|
|
|
|
try {
|
|
|
|
var itemsList = round.allItemsList.itemsList;
|
|
|
|
void QuickItemFix(Item itemToFix, Item itemReference){
|
|
itemToFix.itemIcon = itemReference.itemIcon;
|
|
itemToFix.grabSFX = itemReference.grabSFX;
|
|
itemToFix.dropSFX = itemReference.dropSFX;
|
|
itemToFix.pocketSFX = itemReference.pocketSFX;
|
|
}
|
|
|
|
var magClass = itemsList.FirstOrDefault(i => i.name.ToLowerInvariant() == "magnifyingglass");
|
|
if (GameReadNullCheck(magClass, "magnifyingglass", "Item will have missing image and sound assets")) {
|
|
QuickItemFix(Assets.scrapItems[0].item, magClass);
|
|
QuickItemFix(Assets.scrapItems[1].item, magClass);
|
|
QuickItemFix(Assets.scrapItems[4].item, magClass);
|
|
}
|
|
|
|
var paintClass = itemsList.FirstOrDefault(i => i.name.ToLowerInvariant() == "fancypainting");
|
|
if (GameReadNullCheck(paintClass, "fancypainting", "Item will have missing image and sound assets")){
|
|
QuickItemFix(Assets.scrapItems[2].item, paintClass);
|
|
}
|
|
|
|
void UpdateFlashlight(Assets.Flashlight flashlight, string search, int fixIndex){
|
|
var flashItem = round.allItemsList.itemsList
|
|
.FirstOrDefault(i => i.name.ToLowerInvariant() == search);
|
|
|
|
if (GameReadNullCheck(flashItem, search, "CRYSTAL FLASHLIGHT WILL FAIL")){
|
|
var prefab = Assets.networkObjectList.toFixGameObjects[fixIndex];
|
|
|
|
var item = ScriptableObject.Instantiate(flashItem);
|
|
item.name = flashlight.assetName;
|
|
item.itemName = flashlight.displayName;
|
|
item.saveItemVariable = true;
|
|
item.batteryUsage *= 1.5f;
|
|
item.spawnPrefab = prefab;
|
|
item.weight += 0.02f;
|
|
item.isScrap = true;
|
|
|
|
flashlight.item = item;
|
|
flashlight.lethalVanillaItem = flashItem;
|
|
|
|
var scarletItemComp = prefab.GetComponentInChildren<FlashlightItem>();
|
|
var refItemComp = flashItem.spawnPrefab.GetComponentInChildren<FlashlightItem>();
|
|
scarletItemComp.bulbDark = refItemComp.bulbDark;
|
|
scarletItemComp.bulbLight = refItemComp.bulbLight;
|
|
scarletItemComp.flashlightClips = refItemComp.flashlightClips;
|
|
scarletItemComp.flashlightFlicker = refItemComp.flashlightFlicker;
|
|
scarletItemComp.outOfBatteriesClip = refItemComp.outOfBatteriesClip;
|
|
scarletItemComp.itemProperties = item;
|
|
|
|
var scarletAudioComp = scarletItemComp.flashlightAudio;
|
|
var refAudioComp = refItemComp.flashlightAudio;
|
|
scarletAudioComp.SetCustomCurve(AudioSourceCurveType.CustomRolloff, refAudioComp.GetCustomCurve(AudioSourceCurveType.CustomRolloff));
|
|
|
|
var scarletLightComp = scarletItemComp.flashlightBulb;
|
|
var refLightComp = refItemComp.flashlightBulb;
|
|
scarletLightComp.cookie = refLightComp.cookie;
|
|
|
|
void CopyAndPasteMeshFilterAndRenderer(MeshRenderer meshScarlet, MeshRenderer meshReference){
|
|
meshScarlet.sharedMaterials = meshReference.sharedMaterials;
|
|
var scarletMeshComp = meshScarlet.GetComponent<MeshFilter>();
|
|
var refMeshComp = meshReference.GetComponent<MeshFilter>();
|
|
scarletMeshComp.sharedMesh = refMeshComp.sharedMesh;
|
|
}
|
|
|
|
CopyAndPasteMeshFilterAndRenderer(scarletItemComp.flashlightMesh, refItemComp.flashlightMesh);
|
|
var scarletTie = scarletItemComp.flashlightMesh.transform.Find("Tie");
|
|
var refTie = refItemComp.flashlightMesh.transform.Find("Tie");
|
|
if (scarletTie && refTie) {
|
|
var scarletTieMesh = scarletTie.GetComponent<MeshRenderer>();
|
|
var refTieMesh = refTie.GetComponent<MeshRenderer>();
|
|
if (scarletTieMesh && refTieMesh) {
|
|
Plugin.logger.LogInfo("Fixed tie of bb flashlight");
|
|
CopyAndPasteMeshFilterAndRenderer(scarletTieMesh, refTieMesh);
|
|
}
|
|
}
|
|
|
|
LethalLib.Modules.Items.RegisterItem(item);
|
|
}
|
|
}
|
|
|
|
var knifeItem = round.allItemsList.itemsList.FirstOrDefault(i => i.name.ToLowerInvariant() == "knife");
|
|
if (GameReadNullCheck(knifeItem, "knife", "Item will have missing image and sound assets")){
|
|
var scarletKnife = Assets.scrapItems[3].item;
|
|
QuickItemFix(scarletKnife, knifeItem);
|
|
|
|
var scarletPrefab = scarletKnife.spawnPrefab;
|
|
var scarletScript = scarletPrefab.GetComponent<ScarletKnife>();
|
|
|
|
var knifePrefab = knifeItem.spawnPrefab;
|
|
var knifeScript = knifePrefab.GetComponent<KnifeItem>();
|
|
|
|
scarletScript.hitSFX = knifeScript.hitSFX;
|
|
scarletScript.swingSFX = knifeScript.swingSFX;
|
|
|
|
FixParticleSystemMaterialAndChildren(scarletScript.bloodParticle, knifeScript.bloodParticle);
|
|
FixParticleSystemMaterial(scarletScript.buffedParticleSystem, knifeScript.bloodParticle);
|
|
}
|
|
|
|
if (Assets.flashlight.item == null) {
|
|
UpdateFlashlight(Assets.flashlight, "proflashlight", 2);
|
|
}
|
|
|
|
if (Assets.flashlightBB.item == null) {
|
|
UpdateFlashlight(Assets.flashlightBB, "flashlight", 3);
|
|
}
|
|
|
|
var keyItem = round.allItemsList.itemsList.FirstOrDefault(i => i.name.ToLowerInvariant() == "key");
|
|
if (GameReadNullCheck(keyItem, "key", "Item will have missing image and sound assets")){
|
|
var scarletPrefab = Assets.networkObjectList.toFixGameObjects[5];
|
|
var scarletKey = scarletPrefab.GetComponent<GrabbableObject>().itemProperties;
|
|
QuickItemFix(scarletKey, keyItem);
|
|
|
|
var keyPrefab = keyItem.spawnPrefab;
|
|
scarletPrefab.GetComponent<MeshFilter>().sharedMesh = keyPrefab.GetComponent<MeshFilter>().sharedMesh;
|
|
|
|
var mats = keyPrefab.GetComponent<MeshRenderer>().sharedMaterials;
|
|
mats = mats.Select(m => {
|
|
var n = new Material(m);
|
|
n.color = Color.red;
|
|
return n;
|
|
}).ToArray();
|
|
scarletPrefab.GetComponent<MeshRenderer>().sharedMaterials = mats;
|
|
|
|
|
|
Assets.dungeonExtended.OverrideKeyPrefab = scarletPrefab;
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
Plugin.logger.LogError("Error when reading base game's item list. Pretty big error I would say");
|
|
Plugin.logger.LogError(e);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
public static void FixDungeonPrefabValues(RoundManager manager){
|
|
|
|
var networkmanager = GameObject.FindObjectOfType<NetworkManager>();
|
|
var prefabs = networkmanager.NetworkConfig.Prefabs.Prefabs;
|
|
var prefabFixList = Assets.networkObjectList.toFixGameObjects;
|
|
|
|
//foreach(var p in prefabs){
|
|
// var hasInteract = p.Prefab.GetComponentInChildren<InteractTrigger>();
|
|
// var interStr = hasInteract ? "YES" : "";
|
|
// Plugin.logger.LogInfo($"{p.Prefab.name}: {interStr}");
|
|
//}
|
|
|
|
var steeldoor = prefabs.FirstOrDefault(p => p.Prefab.name.ToLowerInvariant() == "fancydoormapmodel");
|
|
if (GameReadNullCheck(steeldoor, "FancyDoorMapModel", "SDM doors will have missing icons and sounds")){
|
|
var interact = steeldoor.Prefab.GetComponentInChildren<InteractTrigger>();
|
|
var animateTrigger = steeldoor.Prefab.GetComponentInChildren<AnimatedObjectTrigger>();
|
|
Assets.hoverIcon = interact.hoverIcon;
|
|
|
|
var boolFalse = animateTrigger.boolFalseAudios;
|
|
var boolTrue = animateTrigger.boolTrueAudios;
|
|
var secondary = animateTrigger.secondaryAudios;
|
|
|
|
FixDoorway(prefabFixList[0]);
|
|
FixDoorway(prefabFixList[1]);
|
|
|
|
void FixDoorway(GameObject g){
|
|
var animate = g.GetComponentInChildren<AnimatedObjectTrigger>();
|
|
|
|
animate.boolFalseAudios = boolFalse;
|
|
animate.boolTrueAudios = boolTrue;
|
|
animate.secondaryAudios = secondary;
|
|
}
|
|
}
|
|
|
|
var mine = prefabs.FirstOrDefault(p => p.Prefab.name.ToLowerInvariant() == "landmine");
|
|
var turret = prefabs.FirstOrDefault(p => p.Prefab.name.ToLowerInvariant() == "turretcontainer");
|
|
var spiketrap = prefabs.FirstOrDefault(p => p.Prefab.name.ToLowerInvariant() == "spikerooftraphazard");
|
|
|
|
if (GameReadNullCheck(mine, "LandMine", "Map Object Hazards will not spawn") && GameReadNullCheck(turret, "TurretContainer", "Map Object Hazards will not spawn") && GameReadNullCheck(spiketrap, "SpikeRoofTrapHazard", "Map Object Hazards will not spawn")){
|
|
Assets.dungeonMapHazardFound = true;
|
|
Assets.dungeonMinesMapHazard = mine.Prefab;
|
|
Assets.dungeonTurretMapHazard = turret.Prefab;
|
|
Assets.dungeonSpikeTrapMapHazard = spiketrap.Prefab;
|
|
|
|
}
|
|
|
|
try {
|
|
var flow = manager.dungeonFlowTypes.Select(d => d.dungeonFlow).FirstOrDefault(d => d.name == "Level1Flow");
|
|
var tiles = flow.Nodes[1].TileSets[0].TileWeights.Weights;
|
|
var doorways = tiles.SelectMany(t => t.Value.GetComponentsInChildren<DunGen.Doorway>());
|
|
var blockers = doorways.SelectMany(d => d.BlockerPrefabWeights).Select(e => e.GameObject);
|
|
var globalprops = blockers.SelectMany(b => b.GetComponentsInChildren<DunGen.GlobalProp>());
|
|
var fireProp = globalprops.FirstOrDefault(f => f.PropGroupID == 1231);
|
|
prefabFixList[4].GetComponent<FixValues.FixFireExit>().Setup(fireProp.gameObject);
|
|
|
|
} catch (Exception e){
|
|
Plugin.logger.LogInfo("Failed to setup vanilla fire exit. The 'Use SDM Fire Exits' config will be ignored");
|
|
Plugin.logger.LogError(e.ToString());
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
private static IEnumerator UpdateNetworkConfig(RoundManager roundManager){
|
|
while(PluginConfig.Synced == false){
|
|
yield return null;
|
|
}
|
|
|
|
/*
|
|
var list = ExtendedDungeonMapLoad.GetCustomMoons(PluginConfig.Instance.customMapsValue, PluginConfig.Instance.customMapDefaultWeightValue);
|
|
ExtendedDungeonMapLoad.ClearLastCustomMoonEntryList();
|
|
|
|
// overriding with dis
|
|
if (list.Count > 0){
|
|
Plugin.logger.LogInfo("Overring default snow moons. Loading with custom moon list");
|
|
ExtendedDungeonMapLoad.AddToExtendedDungeonFlow(list);
|
|
}
|
|
|
|
else {
|
|
Plugin.logger.LogInfo("Loading SDM to default snow moons");
|
|
|
|
Assets.dineEntry.SetRarity(PluginConfig.Instance.dungeonSnowWeightValue);
|
|
Assets.rendEntry.SetRarity(PluginConfig.Instance.dungeonSnowWeightValue);
|
|
Assets.titanEntry.SetRarity(PluginConfig.Instance.dungeonTitanWeightValue);
|
|
|
|
var dun = Assets.dungeonExtended;
|
|
Assets.dineEntry.Add(dun);
|
|
Assets.rendEntry.Add(dun);
|
|
Assets.titanEntry.Add(dun);
|
|
}
|
|
*/
|
|
|
|
Lights.ScarletLightCleanup.weights = new float[] {
|
|
PluginConfig.Instance.lightsSpawnZeroWeightValue,
|
|
PluginConfig.Instance.lightsSpawnOneWeightValue,
|
|
PluginConfig.Instance.lightsSpawnTwoWeightValue
|
|
//PluginConfig.Instance.lightsSpawnThreeWeightValue
|
|
};
|
|
|
|
/*
|
|
foreach(var item in Assets.items){
|
|
item.UpdateStringWithRarity();
|
|
}
|
|
// hack
|
|
foreach(var level in PatchedContent.ExtendedLevels) {
|
|
Plugin.logger.LogInfo($"{level.name}: {level.AuthorName}");
|
|
var hackCall = typeof(ItemManager).GetMethod("InjectCustomItemsIntoLevelViaDynamicRarity", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
|
|
hackCall.Invoke(null, new object[] { level, true } );
|
|
}
|
|
*/
|
|
|
|
//Assets.dungeonExtended.DynamicDungeonSizeMinMax = new Vector2(PluginConfig.Instance.dunGenMultiplierValue.min, PluginConfig.Instance.dunGenMultiplierValue.max);
|
|
Assets.dungeon.Length = PluginConfig.Instance.mainPathLengthValue.GetDungenIntRange();
|
|
|
|
var mayorTileSet = PluginConfig.Instance.disableBasementValue ? Assets.networkObjectList.mayorVanillaTileset : Assets.networkObjectList.mayorRegularTileset;
|
|
Assets.dungeon.Nodes[1].TileSets = new List<DunGen.TileSet>() { mayorTileSet };
|
|
|
|
DungeonFlow.GlobalPropSettings GetGlobalPropSetting(int id) {
|
|
foreach(var p in Assets.dungeon.GlobalProps){
|
|
if (p.ID == id ) return p;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
GetGlobalPropSetting(254).Count = new DunGen.IntRange(
|
|
PluginConfig.Instance.paintingCountValue,
|
|
PluginConfig.Instance.paintingCountValue
|
|
);
|
|
|
|
Plugin.logger.LogInfo("Set networked config values");
|
|
}
|
|
|
|
public static void UpdateTileWeightDebug(string tile, float multiplier){
|
|
var tilesets = Assets.dungeon.GetUsedTileSets();
|
|
foreach(var s in tilesets){
|
|
foreach(var t in s.TileWeights.Weights){
|
|
var n = t.Value.name;
|
|
if (n.Contains(tile)) {
|
|
Plugin.logger.LogInfo($"{t.Value.name} weight being multiplied by {multiplier}");
|
|
t.MainPathWeight *= multiplier;
|
|
t.BranchPathWeight *= multiplier;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|