mirror of
https://github.com/DorkSquadRR/DorkNet.git
synced 2026-10-25 23:18:44 -07:00
feat: Rec Royale night mode (ClientMod) + admin switch to give baked RRO rooms a data blob
ClientMod (2023-03-21): opt-in Rec Royale night mode. RRO scenes never
enable the room mood engine (no data blob → SceneMoodSettings.isEnabled
stays false, CurrentMood null, the per-frame update returns at once), so
the mod replays the room-data loader's bring-up, registers a shipped
night MoodSetting (Night_Calm_Outdoor_Mood by default) as the scene's
default mood, supplies a skybox material on the Custom/SkyBox shader
(MoodConfig.SkyBoxMaterial is not loaded outside custom rooms), assigns
the scene's directional light as RenderSettings.sun, matches the key
light to the engine-driven sun, darkens via the mood's post-exposure and
sun/ambient intensities, forces post-processing on, keeps or disables
fog, hides the daytime cloud meshes, unlocks weapon flashlights, and
restores everything on hotkey-off / scene change. All knobs live in
dorknet-clientmod.json (RecRoyaleNight*), written by install-melon.ps1.
Server/admin: baked Rec Room Originals are seeded with an empty
DataBlobName, which the 2023 client reads as "no room data" — no Maker
Pen, no CV2 room-settings chips, no saves, and for Rec Royale no game at
all (its game-rule chip RecRoyaleSolos_GameRuleWrapperCircuit ships in
the blob, not the scene). New admin actions on the Sub-rooms tab:
POST rooms/{id}/subrooms/{sub}/blob/enable stamps the synthetic default
blob name (which CdnController already answers with the RRO-editable
blob) and blob/reset clears it back to scene-only. IsRRO is derived from
IsAGRoom, so the client keeps loading the baked map.
Docs: README section, docs/admin.md procedure, docs/recroom-2023-room-save.md,
new docs/recroom-2023-scene-moods.md with the ISIL offsets behind all of it.
Tests: RroRoomBlobTests.
This commit is contained in:
Alexa
@@ -6,8 +6,9 @@
|
||||
// 2. TLS trust bypass — make BouncyCastle never reject server certs
|
||||
//
|
||||
// Plus the anti-cheat BYPASS patches (anti-tamper / ToxMod / file-hash)
|
||||
// needed so a modded client isn't kicked, and two opt-in features that
|
||||
// are OFF by default (Desktop Screen-Share FPS, RRO quest party size).
|
||||
// needed so a modded client isn't kicked, and three opt-in features that
|
||||
// are OFF by default (Desktop Screen-Share FPS, RRO quest party size,
|
||||
// Rec Royale night mode).
|
||||
//
|
||||
// This is the STABLE, shipping mod: it carries no diagnostic/tracing
|
||||
// code. All of that lives in the separate DorkNet.DebugMod (drop it in
|
||||
@@ -109,6 +110,52 @@ public class Mod : MelonMod
|
||||
// generic "Quest" config is intentionally NOT in the default list.
|
||||
public static string[] QuestMaxTeamSizeRooms =
|
||||
{ "CrimsonCauldron", "Crescendo", "GoldenTrophy", "IsleOfLostSkulls", "TheRiseofJumbotron" };
|
||||
|
||||
// ── Rec Royale night mode (client-side visual) ──
|
||||
// Re-skins Rec Royale with one of the game's own shipped night
|
||||
// MoodSetting assets (sky dome, sun, fog, bloom, colour grading)
|
||||
// through SceneMoodSettings' apply path, and unlocks the weapon
|
||||
// flashlight prefab while it is on. Purely local: the networked room
|
||||
// mood index is never touched. See RecRoyaleNight.
|
||||
public static bool RecRoyaleNightMode = false;
|
||||
// Resources asset name of the MoodSetting to apply. Shipped options:
|
||||
// Night_Calm_Outdoor_Mood, Night_Spooky_Outdoor_Mood,
|
||||
// Night_Wild_Outdoor_Mood, Night_StuntRunner_Outdoor_Mood, OuterSpace_Mood.
|
||||
public static string RecRoyaleNightMood = "Night_Calm_Outdoor_Mood";
|
||||
// Unity scene names (substring, case-insensitive) that count as Rec
|
||||
// Royale. 2023-03-21 has a single map: RecRoyale_Frontier.
|
||||
public static string[] RecRoyaleNightScenes = { "RecRoyale" };
|
||||
// Force WeaponFlashlightController.FlashlightAllowed while night is on.
|
||||
public static bool RecRoyaleNightFlashlights = true;
|
||||
// Apply the mood's fog block too. Off = the mood's FogSettings are
|
||||
// swapped for a block captured from the scene, so fog stays as-is.
|
||||
public static bool RecRoyaleNightFog = false;
|
||||
// Darkening knobs applied to the mood data before it is used. Baked
|
||||
// lightmaps can't be dimmed, so post-exposure (EV, added to the mood's
|
||||
// ColorGradingSettings.exposure) is what actually darkens the whole
|
||||
// frame; the sun/ambient multipliers tone down realtime lighting.
|
||||
public static float RecRoyaleNightExposure = -3.5f; // EV offset (0 = mood default)
|
||||
public static float RecRoyaleNightSunScale = 0.15f; // × SunSettings.sunIntensity (1 = unchanged)
|
||||
public static float RecRoyaleNightAmbientScale = 0.2f; // × SkyBoxSettings.ambientLightIntensity (1 = unchanged)
|
||||
// Post-exposure only renders if the scene Volume is on and the camera
|
||||
// renders post-processing; force both while night mode is active.
|
||||
public static bool RecRoyaleNightForcePostProcessing = true;
|
||||
// The engine only drives RenderSettings.sun (Frontier: the sun-disc
|
||||
// light). Copy its rotation/colour onto every other directional light
|
||||
// and scale their intensity by RecRoyaleNightSunScale.
|
||||
public static bool RecRoyaleNightMatchSunLights = true;
|
||||
// Turn fog off entirely while night is on (RenderSettings.fog=false and
|
||||
// the mood's fog block pushed out of range). Ignored when
|
||||
// RecRoyaleNightFog is true.
|
||||
public static bool RecRoyaleNightDisableFog = false;
|
||||
// Renderers whose GameObject or material name contains any of these
|
||||
// (case-insensitive) are hidden while night is on. Frontier's daytime
|
||||
// cloud meshes are CloudPlane/Clouds/…_Cloud_RecRoyale_Frontier_Mat.
|
||||
public static string[] RecRoyaleNightHideObjects = { "Cloud" };
|
||||
// Optional UnityEngine.KeyCode name to toggle night at runtime (e.g.
|
||||
// "N"). Empty = no hotkey. A hotkey also arms the feature when
|
||||
// RecRoyaleNightMode is false, so it can be switched on in-game.
|
||||
public static string RecRoyaleNightToggleKey = "";
|
||||
}
|
||||
public override void OnInitializeMelon()
|
||||
{
|
||||
@@ -178,6 +225,19 @@ public class Mod : MelonMod
|
||||
postfix: nameof(QuestTeamSize.RelaxEmptySpawnFilter_Postfix));
|
||||
}
|
||||
|
||||
// Rec Royale night mode: armed when enabled OR when a hotkey is set
|
||||
// (so it can be switched on in-game). Scene detection + mood apply
|
||||
// run from OnSceneWasLoaded / OnUpdate below.
|
||||
if (Cfg.RecRoyaleNightMode || !string.IsNullOrWhiteSpace(Cfg.RecRoyaleNightToggleKey))
|
||||
{
|
||||
_recRoyaleNightArmed = true;
|
||||
RecRoyaleNight.Register(HarmonyInstance);
|
||||
}
|
||||
}
|
||||
private bool _recRoyaleNightArmed;
|
||||
public override void OnSceneWasLoaded(int buildIndex, string sceneName)
|
||||
{
|
||||
if (_recRoyaleNightArmed) RecRoyaleNight.OnSceneLoaded(sceneName);
|
||||
}
|
||||
private bool PatchFileHashCheckerCallback()
|
||||
{
|
||||
@@ -359,6 +419,8 @@ public class Mod : MelonMod
|
||||
}
|
||||
public override void OnUpdate()
|
||||
{
|
||||
if (_recRoyaleNightArmed) RecRoyaleNight.Tick();
|
||||
|
||||
if (!_antiTamperCallbackPatchesComplete && ++_antiTamperCallbackRetryFrame >= 300)
|
||||
{
|
||||
_antiTamperCallbackRetryFrame = 0;
|
||||
@@ -404,6 +466,33 @@ public class Mod : MelonMod
|
||||
rooms.Add(e.GetString()!);
|
||||
Cfg.QuestMaxTeamSizeRooms = rooms.ToArray(); // explicit (incl. empty = none)
|
||||
}
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightMode", out v)) Cfg.RecRoyaleNightMode = v.GetBoolean();
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightMood", out v)) Cfg.RecRoyaleNightMood = v.GetString() ?? Cfg.RecRoyaleNightMood;
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightFlashlights", out v)) Cfg.RecRoyaleNightFlashlights = v.GetBoolean();
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightFog", out v)) Cfg.RecRoyaleNightFog = v.GetBoolean();
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightExposure", out v)) Cfg.RecRoyaleNightExposure = (float)v.GetDouble();
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightSunScale", out v)) Cfg.RecRoyaleNightSunScale = (float)v.GetDouble();
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightAmbientScale", out v)) Cfg.RecRoyaleNightAmbientScale = (float)v.GetDouble();
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightForcePostProcessing", out v)) Cfg.RecRoyaleNightForcePostProcessing = v.GetBoolean();
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightMatchSunLights", out v)) Cfg.RecRoyaleNightMatchSunLights = v.GetBoolean();
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightDisableFog", out v)) Cfg.RecRoyaleNightDisableFog = v.GetBoolean();
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightHideObjects", out v) && v.ValueKind == JsonValueKind.Array)
|
||||
{
|
||||
var names = new List<string>();
|
||||
foreach (var e in v.EnumerateArray())
|
||||
if (e.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(e.GetString()))
|
||||
names.Add(e.GetString()!);
|
||||
Cfg.RecRoyaleNightHideObjects = names.ToArray(); // explicit (incl. empty = hide nothing)
|
||||
}
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightToggleKey", out v)) Cfg.RecRoyaleNightToggleKey = v.GetString() ?? "";
|
||||
if (TryGetConfigValue(r, "RecRoyaleNightScenes", out v) && v.ValueKind == JsonValueKind.Array)
|
||||
{
|
||||
var scenes = new List<string>();
|
||||
foreach (var e in v.EnumerateArray())
|
||||
if (e.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(e.GetString()))
|
||||
scenes.Add(e.GetString()!);
|
||||
if (scenes.Count > 0) Cfg.RecRoyaleNightScenes = scenes.ToArray();
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
@@ -573,7 +662,7 @@ public class Mod : MelonMod
|
||||
private MethodInfo GetPatchMethod(string name)
|
||||
{
|
||||
// Look in the core + feature patch holder classes.
|
||||
foreach (var holder in new[] { typeof(UriPatches), typeof(AntiCheatPatches), typeof(AntiTamperPatches), typeof(FileHashCheckerPatches), typeof(ToxModPatches), typeof(TlsPatches), typeof(ScreenSharePatches), typeof(QuestTeamSize) })
|
||||
foreach (var holder in new[] { typeof(UriPatches), typeof(AntiCheatPatches), typeof(AntiTamperPatches), typeof(FileHashCheckerPatches), typeof(ToxModPatches), typeof(TlsPatches), typeof(ScreenSharePatches), typeof(QuestTeamSize), typeof(RecRoyaleNight) })
|
||||
{
|
||||
var m = holder.GetMethod(name, BindingFlags.Public | BindingFlags.Static);
|
||||
if (m is not null) return m;
|
||||
|
||||
@@ -0,0 +1,1401 @@
|
||||
// Rec Royale night mode — client-side, opt-in.
|
||||
//
|
||||
// Rec Royale never shipped a night variant, but the March-2023 client
|
||||
// carries everything needed to build one from the game's own tooling:
|
||||
//
|
||||
// • Every room scene owns a RecRoomSceneManager (name-preserved field
|
||||
// `sceneMoodSettings` → RecRoom.Core.Scene.SceneMoodSettings). That
|
||||
// object is the room "mood" engine behind the Maker Pen sky/sun/fog
|
||||
// settings: it holds `availableMoods` (MoodSetting[]), `defaultMood`
|
||||
// and `CurrentMood`, plus blenders for skybox, sun, fog, bloom and
|
||||
// colour grading.
|
||||
// • SceneMoodSettings.MLLBALMKEGJ(MoodSetting) is the apply step
|
||||
// (ISIL: SceneMoodSettings.txt:3025-3581). It pushes the mood's six
|
||||
// settings blocks into the blenders (ALCMNGKOEBK), swaps the URP
|
||||
// VolumeProfile (OEKNGEMDMDB), sets RenderSettings.skybox to the
|
||||
// global MoodConfig skybox material (LNMDIIFOFPD.NHAEHKJINFH, shader
|
||||
// "Custom/SkyBox"), re-aims RenderSettings.sun, sets every
|
||||
// ReflectionProbe.customBakedTexture to the mood's baked cubemap and
|
||||
// force-updates the blenders. It does NOT touch the networked mood
|
||||
// index, so calling it is purely local.
|
||||
// • The build ships ready-made night moods as Resources assets
|
||||
// (resources.assets; ResourceManager table in globalgamemanagers):
|
||||
// Night_Calm_Outdoor_Mood ("Calm Night"), Night_Spooky_Outdoor_Mood
|
||||
// ("Spooky Night"), Night_Wild_Outdoor_Mood ("Wild Night"),
|
||||
// Night_StuntRunner_Outdoor_Mood and OuterSpace_Mood ("Outer Space").
|
||||
// • The only Rec Royale map in this build is
|
||||
// Assets/Activities/RecRoyale/Maps/RecRoyale_Frontier/RecRoyale_Frontier.unity.
|
||||
//
|
||||
// RRO SCENES HAVE NO ROOM DATA BLOB. The mood engine's `isEnabled` flag
|
||||
// (SceneMoodSettings+0x38) is only switched on by the room-data loader
|
||||
// (EIMFCPIHEPF.JPKEMACDNCF, ISIL :2136-2310), which runs for custom rooms
|
||||
// only. While it is off, get_CurrentMood returns null and nothing ticks.
|
||||
// The loader's bring-up sequence is:
|
||||
// LKIKMLNPCFK(false) // SetEnabled(false): applies a null mood
|
||||
// LIEDFOLBGHL() // capture the scene's own skybox/sun/fog as the
|
||||
// // blenders' "previous" data (checks shader name
|
||||
// // "Custom/SkyBox" → HasRecRoomSkyboxShader)
|
||||
// LKIKMLNPCFK(true) // SetEnabled(true)
|
||||
// This mod replays exactly that before applying the night mood.
|
||||
//
|
||||
// Deliberately NOT used: SceneMoodSettings.IPAMPMBDPNB(Guid) /
|
||||
// set_CurrentRoomMoodIndex. `_currentRoomMoodIndex` is a
|
||||
// RecRoom.Networking.SynchronizedFields DFAOKLDJPEL<int>, i.e. it
|
||||
// replicates to every player in the instance. Applying the mood directly
|
||||
// keeps night mode a per-client visual choice.
|
||||
//
|
||||
// Weapon flashlights: WeaponFlashlightController.get_FlashlightAllowed
|
||||
// (ISIL: WeaponFlashlightController.txt:3-75) is
|
||||
// `Matchmaking.FBELDNLEKAC() != null && [+0x28] == 15` — a game-mode
|
||||
// gate for an activity that isn't Rec Royale. A Harmony postfix forces it
|
||||
// true while night mode is active, so weapons picked up in the dark get
|
||||
// the game's own flashlight prefab.
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Reflection;
|
||||
using HarmonyLib;
|
||||
using Il2CppInterop.Runtime;
|
||||
using Il2CppInterop.Runtime.InteropTypes;
|
||||
|
||||
namespace DorkNet.ClientMod;
|
||||
|
||||
internal static class RecRoyaleNight
|
||||
{
|
||||
private const BindingFlags Any = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
|
||||
|
||||
// Runtime state. `Active` starts from Cfg.RecRoyaleNightMode and flips
|
||||
// with the hotkey; `_inRoyale` tracks whether the current scene is one
|
||||
// of Cfg.RecRoyaleNightScenes.
|
||||
public static bool Active { get; private set; }
|
||||
private static bool _inRoyale;
|
||||
private static string _sceneName = "";
|
||||
private static bool _appliedThisScene;
|
||||
private static int _frame;
|
||||
private static int _sceneFrames; // frames since the Royale scene loaded
|
||||
private static int _reassertFrames; // frames since the last re-apply
|
||||
|
||||
// Per-scene bring-up bookkeeping so toggling off can put things back.
|
||||
private static bool _engineWasDisabled; // we enabled the mood engine ourselves
|
||||
private static object? _originalSkybox; // RenderSettings.skybox before we touched it
|
||||
private static bool _sunWasNull; // we assigned RenderSettings.sun ourselves
|
||||
private static object? _originalFog; // MoodSetting.FogSettings before we swapped it
|
||||
private static object? _fogPatchedMood; // the mood asset whose FogSettings we replaced
|
||||
private static object? _darkPatchedMood; // the mood asset whose exposure/sun/ambient we changed
|
||||
private static float? _origExposure, _origSunIntensity, _origAmbient;
|
||||
private static bool _diagLogged;
|
||||
|
||||
private const int PollEveryFrames = 30; // ~0.5 s @ 60 fps
|
||||
private const int SettleFrames = 90; // let the scene's own lighting settle first
|
||||
private const int PollGiveUpFrames = 60 * 120; // stop polling after ~2 min
|
||||
private const int ReassertEveryFrames = 60 * 10; // re-apply every ~10 s
|
||||
|
||||
// Resolved reflection handles (lazy, cached).
|
||||
private static bool _resolved;
|
||||
private static Type? _sceneManagerType;
|
||||
private static PropertyInfo? _sceneManagerInstance;
|
||||
private static FieldInfo? _sceneMoodSettingsField;
|
||||
private static PropertyInfo? _sceneMoodSettingsProp;
|
||||
private static Type? _moodSettingType;
|
||||
private static MethodInfo? _applyMood; // MLLBALMKEGJ(MoodSetting)
|
||||
private static MethodInfo? _setEnabled; // LKIKMLNPCFK(bool)
|
||||
private static MethodInfo? _capture; // LIEDFOLBGHL()
|
||||
private static FieldInfo? _isEnabled; // isEnabled
|
||||
private static PropertyInfo? _roomMoodsEnabled;
|
||||
private static PropertyInfo? _hasSkyShader;
|
||||
private static PropertyInfo? _hasSunSource;
|
||||
private static PropertyInfo? _volume;
|
||||
private static FieldInfo? _availableMoods;
|
||||
private static PropertyInfo? _currentMood;
|
||||
private static PropertyInfo? _friendlyName;
|
||||
private static PropertyInfo? _renderSkybox; // UnityEngine.RenderSettings.skybox
|
||||
private static PropertyInfo? _renderSun; // UnityEngine.RenderSettings.sun
|
||||
private static Type? _lightType; // UnityEngine.Light
|
||||
private static Type? _fogSettingsType; // FogMoodSettings
|
||||
private static MethodInfo? _fogCapture; // FogMoodSettings.NLDDIDEIEFH() — read RenderSettings fog
|
||||
private static PropertyInfo? _moodFog; // MoodSetting.FogSettings
|
||||
private static Type? _materialType; // UnityEngine.Material
|
||||
private static Type? _shaderType; // UnityEngine.Shader
|
||||
private static Type? _moodConfigHolder; // LNMDIIFOFPD (static MoodConfig holder)
|
||||
private static Type? _cameraDataType; // UnityEngine.Rendering.Universal.UniversalAdditionalCameraData
|
||||
private static object? _ourSkybox; // Material we created for the mood skybox
|
||||
private static object? _nightMood; // MoodSetting interop wrapper
|
||||
private static string _nightMoodLoadedName = "";
|
||||
|
||||
// Hotkey
|
||||
private static bool _inputResolved;
|
||||
private static MethodInfo? _getKeyDown;
|
||||
private static object? _toggleKey;
|
||||
|
||||
// ── registration ──────────────────────────────────────────────────
|
||||
public static void Register(HarmonyLib.Harmony harmony)
|
||||
{
|
||||
Active = Mod.Cfg.RecRoyaleNightMode;
|
||||
Mod.Log.Msg($"[royale-night] enabled={Active} mood={Mod.Cfg.RecRoyaleNightMood} " +
|
||||
$"scenes=[{string.Join(",", Mod.Cfg.RecRoyaleNightScenes)}] " +
|
||||
$"flashlights={Mod.Cfg.RecRoyaleNightFlashlights} " +
|
||||
$"hotkey={(string.IsNullOrWhiteSpace(Mod.Cfg.RecRoyaleNightToggleKey) ? "<none>" : Mod.Cfg.RecRoyaleNightToggleKey)}");
|
||||
|
||||
if (Mod.Cfg.RecRoyaleNightFlashlights)
|
||||
TryPatchFlashlightGate(harmony);
|
||||
}
|
||||
|
||||
// POSTFIX on WeaponFlashlightController.get_FlashlightAllowed. The
|
||||
// interop property carries the obfuscated name (KIMMMCCKMJL in the
|
||||
// 2023-03-21 build) while the il2cpp method keeps `get_FlashlightAllowed`,
|
||||
// so resolve by name first and fall back to "the only read-only bool
|
||||
// property declared on the type".
|
||||
private static void TryPatchFlashlightGate(HarmonyLib.Harmony harmony)
|
||||
{
|
||||
try
|
||||
{
|
||||
var type = Mod.ResolveType("WeaponFlashlightController");
|
||||
if (type is null)
|
||||
{
|
||||
Mod.Log.Warning("[patch-miss] WeaponFlashlightController: type not found");
|
||||
return;
|
||||
}
|
||||
|
||||
MethodInfo? getter = AccessTools.PropertyGetter(type, "FlashlightAllowed")
|
||||
?? AccessTools.PropertyGetter(type, "KIMMMCCKMJL");
|
||||
if (getter is null)
|
||||
{
|
||||
PropertyInfo? only = null;
|
||||
int count = 0;
|
||||
foreach (var p in type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
|
||||
{
|
||||
if (p.PropertyType != typeof(bool) || !p.CanRead || p.CanWrite || p.GetIndexParameters().Length != 0) continue;
|
||||
only = p; count++;
|
||||
}
|
||||
if (count == 1) getter = only!.GetGetMethod(true);
|
||||
}
|
||||
if (getter is null)
|
||||
{
|
||||
Mod.Log.Warning("[patch-miss] WeaponFlashlightController.get_FlashlightAllowed");
|
||||
return;
|
||||
}
|
||||
|
||||
var postfix = typeof(RecRoyaleNight).GetMethod(nameof(FlashlightAllowed_Postfix), BindingFlags.Public | BindingFlags.Static)!;
|
||||
harmony.Patch(getter, postfix: new HarmonyMethod(postfix));
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Mod.Log.Error($"[patch-fail] WeaponFlashlightController.get_FlashlightAllowed: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
public static void FlashlightAllowed_Postfix(ref bool __result)
|
||||
{
|
||||
if (Active && _inRoyale) __result = true;
|
||||
}
|
||||
|
||||
// ── lifecycle (called from Mod) ───────────────────────────────────
|
||||
public static void OnSceneLoaded(string sceneName)
|
||||
{
|
||||
_sceneName = sceneName ?? "";
|
||||
var was = _inRoyale;
|
||||
_inRoyale = MatchesScene(_sceneName);
|
||||
if (_inRoyale)
|
||||
{
|
||||
_appliedThisScene = false;
|
||||
_sceneFrames = 0;
|
||||
_reassertFrames = 0;
|
||||
_engineWasDisabled = false;
|
||||
_originalSkybox = null;
|
||||
_sunWasNull = false;
|
||||
_diagLogged = false;
|
||||
RestoreMoodPatches();
|
||||
Mod.Log.Msg($"[royale-night] scene '{_sceneName}' loaded — night mode {(Active ? "will apply" : "is off (hotkey to enable)")}");
|
||||
}
|
||||
else if (was)
|
||||
{
|
||||
_appliedThisScene = false;
|
||||
_engineWasDisabled = false;
|
||||
_originalSkybox = null;
|
||||
_sunWasNull = false;
|
||||
RestoreMoodPatches();
|
||||
}
|
||||
}
|
||||
|
||||
public static void Tick()
|
||||
{
|
||||
_frame++;
|
||||
PollHotkey();
|
||||
|
||||
if (!_inRoyale || !Active) return;
|
||||
_sceneFrames++;
|
||||
if (_frame % PollEveryFrames != 0) return;
|
||||
|
||||
if (!_appliedThisScene)
|
||||
{
|
||||
if (_sceneFrames < SettleFrames || _sceneFrames > PollGiveUpFrames) return;
|
||||
if (TryApply(true)) _appliedThisScene = true;
|
||||
return;
|
||||
}
|
||||
|
||||
// Cheap safeguard: the game re-applies its own mood on quality
|
||||
// changes / studio events. Re-assert every ~10 s; when the blenders
|
||||
// are already at target this is visually a no-op.
|
||||
_reassertFrames += PollEveryFrames;
|
||||
if (_reassertFrames >= ReassertEveryFrames)
|
||||
{
|
||||
_reassertFrames = 0;
|
||||
TryApply(true);
|
||||
}
|
||||
}
|
||||
|
||||
public static void Toggle()
|
||||
{
|
||||
Active = !Active;
|
||||
Mod.Log.Msg($"[royale-night] toggled {(Active ? "ON" : "OFF")}");
|
||||
if (!_inRoyale) return;
|
||||
if (TryApply(Active)) _appliedThisScene = Active;
|
||||
else if (!Active) _appliedThisScene = false;
|
||||
}
|
||||
|
||||
// ── the actual apply ──────────────────────────────────────────────
|
||||
// night=true → bring the mood engine up if needed, apply the night mood
|
||||
// night=false → restore: scene mood if the engine was already running,
|
||||
// otherwise disable the engine again + put the skybox back
|
||||
private static bool TryApply(bool night)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!_resolved && !Resolve()) return false;
|
||||
if (_applyMood is null) return false;
|
||||
|
||||
var manager = GetSceneManager();
|
||||
if (manager is null) { Diag("scene manager instance is null"); return false; }
|
||||
|
||||
var moods = _sceneMoodSettingsField?.GetValue(manager) ?? _sceneMoodSettingsProp?.GetValue(manager);
|
||||
if (moods is null) { Diag("sceneMoodSettings is null"); return false; }
|
||||
|
||||
// `isEnabled` reads differently through the interop property vs the
|
||||
// field (seen True/False for the same state), so don't gate on it.
|
||||
// RoomMoodsEnabled (= isEnabled && defaultMood != null) is computed
|
||||
// game-side and is false for every RRO scene; bring the engine up
|
||||
// exactly once per Royale scene whenever it is not true.
|
||||
var enabled = GetMember(moods, "isEnabled") is true;
|
||||
var roomMoodsEnabled = Read(_roomMoodsEnabled, moods) is true;
|
||||
LogState(moods, enabled);
|
||||
|
||||
if (night)
|
||||
{
|
||||
var target = GetNightMood();
|
||||
if (target is null) return false;
|
||||
|
||||
if (!roomMoodsEnabled && !_engineWasDisabled)
|
||||
{
|
||||
// Replay the room-data loader's bring-up. Remember the
|
||||
// scene's own skybox so toggle-off can restore it.
|
||||
if (_originalSkybox is null && _renderSkybox is not null)
|
||||
_originalSkybox = _renderSkybox.GetValue(null);
|
||||
if (_setEnabled is null || _capture is null)
|
||||
{
|
||||
Mod.Log.Warning("[royale-night] mood engine is disabled in this scene and SetEnabled/Capture are unresolved — cannot bring it up");
|
||||
return false;
|
||||
}
|
||||
|
||||
// RRO scenes leave RenderSettings.sun unset, and the engine
|
||||
// skips every sun change (direction, colour, intensity) when
|
||||
// HasSunSource is false. Point it at the scene's directional
|
||||
// light BEFORE capture so the flag comes out true.
|
||||
EnsureSun();
|
||||
|
||||
// Keep the scene's own fog unless asked otherwise: replace
|
||||
// the mood's FogSettings with a block captured from the
|
||||
// current RenderSettings before anything changes them.
|
||||
if (!Mod.Cfg.RecRoyaleNightFog) PreserveFog(target);
|
||||
|
||||
// Baked lightmaps can't be dimmed, so darken the frame via
|
||||
// the mood's own post-exposure and tone down sun/ambient.
|
||||
PatchDarkness(target);
|
||||
|
||||
_setEnabled.Invoke(moods, new object[] { false });
|
||||
_capture.Invoke(moods, null);
|
||||
|
||||
// The per-frame update (CEKLEBHDAHA, ISIL :3895-4031) returns
|
||||
// at once while get_CurrentMood() is null, and the one-shot
|
||||
// apply only sets blend TARGETS — the update is what writes
|
||||
// sky colours, rotates the sun and pushes exposure. In RRO
|
||||
// scenes CurrentMood is null because defaultMood is unset.
|
||||
// Register the night mood as this scene's defaultMood and
|
||||
// sole availableMoods entry so the engine runs like a
|
||||
// one-mood custom room.
|
||||
InstallSceneMood(moods, target);
|
||||
|
||||
_setEnabled.Invoke(moods, new object[] { true });
|
||||
_engineWasDisabled = true;
|
||||
ProbeCircuitsSupport();
|
||||
var cm = _currentMood?.GetValue(moods);
|
||||
Mod.Log.Msg($"[royale-night] mood engine brought up (skyShader={Read(_hasSkyShader, moods)} sun={Read(_hasSunSource, moods)} volume={!(Read(_volume, moods) is null)} " +
|
||||
$"roomMoodsEnabled={Read(_roomMoodsEnabled, moods)} currentMood={(cm is null || IsUnityNull(cm) ? "<null>" : Describe(cm))})");
|
||||
|
||||
// First apply swaps RenderSettings.skybox to
|
||||
// MoodConfig.SkyBoxMaterial. In RRO scenes that material is
|
||||
// not loaded (it lives in the custom-room scene's shared
|
||||
// assets), so the skybox ends up null → black sky and the
|
||||
// engine's HasRecRoomSkyboxShader / HasSunSource stay false
|
||||
// (both need shader "Custom/SkyBox" on RenderSettings.skybox).
|
||||
// Supply a material built from that shader, re-capture so
|
||||
// the flags flip, then fall through to the real apply.
|
||||
_applyMood.Invoke(moods, new[] { target });
|
||||
EnsureMoodSkybox();
|
||||
_capture.Invoke(moods, null);
|
||||
Mod.Log.Msg($"[royale-night] re-captured (skyShader={Read(_hasSkyShader, moods)} sun={Read(_hasSunSource, moods)} skybox={DescribeSkybox()})");
|
||||
EnsurePostProcessing(moods);
|
||||
}
|
||||
|
||||
_applyMood.Invoke(moods, new[] { target });
|
||||
if (Mod.Cfg.RecRoyaleNightMatchSunLights) MatchOtherSunLights();
|
||||
if (Mod.Cfg.RecRoyaleNightDisableFog && !Mod.Cfg.RecRoyaleNightFog) ForceFogOff();
|
||||
HideObjects();
|
||||
Mod.Log.Msg($"[royale-night] applied mood '{Describe(target)}' in '{_sceneName}'");
|
||||
return true;
|
||||
}
|
||||
|
||||
// restore
|
||||
if (_engineWasDisabled)
|
||||
{
|
||||
RestoreOtherSunLights();
|
||||
ShowObjects();
|
||||
RestoreFogState();
|
||||
_setEnabled?.Invoke(moods, new object[] { false }); // applies the captured "previous" data
|
||||
UninstallSceneMood(moods);
|
||||
if (_originalSkybox is not null && _renderSkybox is not null)
|
||||
_renderSkybox.SetValue(null, _originalSkybox);
|
||||
if (_sunWasNull && _renderSun is not null)
|
||||
_renderSun.SetValue(null, null);
|
||||
RestoreMoodPatches();
|
||||
_engineWasDisabled = false;
|
||||
_originalSkybox = null;
|
||||
_sunWasNull = false;
|
||||
Mod.Log.Msg($"[royale-night] mood engine disabled again, scene skybox/sun restored in '{_sceneName}'");
|
||||
return true;
|
||||
}
|
||||
|
||||
var current = _currentMood?.GetValue(moods);
|
||||
if (current is null || IsUnityNull(current)) { Diag("no CurrentMood to restore"); return false; }
|
||||
_applyMood.Invoke(moods, new[] { current });
|
||||
Mod.Log.Msg($"[royale-night] restored scene mood '{Describe(current)}' in '{_sceneName}'");
|
||||
return true;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Mod.Log.Warning($"[royale-night] apply failed: {(ex.InnerException ?? ex).Message}");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static void LogState(object moods, bool enabled)
|
||||
{
|
||||
if (_diagLogged) return;
|
||||
_diagLogged = true;
|
||||
try
|
||||
{
|
||||
var arr = GetMember(moods, "availableMoods");
|
||||
var cur = _currentMood?.GetValue(moods);
|
||||
Mod.Log.Msg($"[royale-night] engine state: isEnabled={enabled} roomMoodsEnabled={Read(_roomMoodsEnabled, moods)} " +
|
||||
$"availableMoods={Count(arr)} currentMood={(cur is null || IsUnityNull(cur) ? "<null>" : Describe(cur))} " +
|
||||
$"skyShader={Read(_hasSkyShader, moods)} sun={Read(_hasSunSource, moods)} volume={!(Read(_volume, moods) is null)}");
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] state log failed: {ex.Message}"); }
|
||||
}
|
||||
|
||||
private static object? Read(PropertyInfo? p, object o)
|
||||
{
|
||||
try { return p?.GetValue(o); } catch { return null; }
|
||||
}
|
||||
|
||||
private static void Diag(string why)
|
||||
{
|
||||
if (_frame % (PollEveryFrames * 20) == 0) Mod.Log.Msg($"[royale-night] waiting: {why}");
|
||||
}
|
||||
|
||||
private static bool Resolve()
|
||||
{
|
||||
_resolved = true;
|
||||
|
||||
_sceneManagerType = Mod.ResolveType("RecRoomSceneManager");
|
||||
var moodSettingsType = Mod.ResolveType("RecRoom.Core.Scene.SceneMoodSettings");
|
||||
_moodSettingType = Mod.ResolveType("RecRoom.Core.Creation.SceneMoods.MoodSetting");
|
||||
if (_sceneManagerType is null || moodSettingsType is null || _moodSettingType is null)
|
||||
{
|
||||
Mod.Log.Warning($"[royale-night] types missing — sceneManager={_sceneManagerType is not null} " +
|
||||
$"sceneMoodSettings={moodSettingsType is not null} moodSetting={_moodSettingType is not null}");
|
||||
return false;
|
||||
}
|
||||
|
||||
// RecRoomSceneManager.Instance: the il2cpp getter is get_Instance but
|
||||
// the interop property name is obfuscated (PDCOCJBICGC in 2023-03-21).
|
||||
// Pick the static property whose type is RecRoomSceneManager.
|
||||
_sceneManagerInstance = AccessTools.Property(_sceneManagerType, "Instance");
|
||||
if (_sceneManagerInstance is null)
|
||||
{
|
||||
foreach (var p in _sceneManagerType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static))
|
||||
{
|
||||
if (p.PropertyType == _sceneManagerType && p.CanRead && p.GetIndexParameters().Length == 0)
|
||||
{ _sceneManagerInstance = p; break; }
|
||||
}
|
||||
}
|
||||
|
||||
_sceneMoodSettingsField = AccessTools.Field(_sceneManagerType, "sceneMoodSettings");
|
||||
if (_sceneMoodSettingsField is null)
|
||||
{
|
||||
foreach (var p in _sceneManagerType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
|
||||
if (p.PropertyType == moodSettingsType && p.CanRead) { _sceneMoodSettingsProp = p; break; }
|
||||
}
|
||||
|
||||
_currentMood = AccessTools.Property(moodSettingsType, "CurrentMood");
|
||||
_roomMoodsEnabled = AccessTools.Property(moodSettingsType, "RoomMoodsEnabled");
|
||||
_hasSkyShader = AccessTools.Property(moodSettingsType, "HasRecRoomSkyboxShader");
|
||||
_hasSunSource = AccessTools.Property(moodSettingsType, "HasSunSource");
|
||||
_volume = AccessTools.Property(moodSettingsType, "Volume");
|
||||
_availableMoods = AccessTools.Field(moodSettingsType, "availableMoods");
|
||||
_isEnabled = AccessTools.Field(moodSettingsType, "isEnabled");
|
||||
_friendlyName = AccessTools.Property(_moodSettingType, "FriendlyName");
|
||||
|
||||
// Apply step: MLLBALMKEGJ(MoodSetting) in 2023-03-21. Fallback: the
|
||||
// only non-setter void method taking exactly one MoodSetting.
|
||||
_applyMood = AccessTools.Method(moodSettingsType, "MLLBALMKEGJ", new[] { _moodSettingType });
|
||||
if (_applyMood is null)
|
||||
{
|
||||
foreach (var m in moodSettingsType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
|
||||
{
|
||||
if (m.ReturnType != typeof(void) || m.Name.StartsWith("set_", StringComparison.Ordinal)) continue;
|
||||
var ps = m.GetParameters();
|
||||
if (ps.Length == 1 && ps[0].ParameterType == _moodSettingType) { _applyMood = m; break; }
|
||||
}
|
||||
}
|
||||
|
||||
// SetEnabled(bool): LKIKMLNPCFK in 2023-03-21. Fallback: the only
|
||||
// public non-setter void(bool) declared on the type.
|
||||
_setEnabled = AccessTools.Method(moodSettingsType, "LKIKMLNPCFK", new[] { typeof(bool) });
|
||||
if (_setEnabled is null)
|
||||
{
|
||||
MethodInfo? only = null; int n = 0;
|
||||
foreach (var m in moodSettingsType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
|
||||
{
|
||||
if (m.ReturnType != typeof(void) || m.Name.StartsWith("set_", StringComparison.Ordinal)) continue;
|
||||
var ps = m.GetParameters();
|
||||
if (ps.Length == 1 && ps[0].ParameterType == typeof(bool)) { only = m; n++; }
|
||||
}
|
||||
if (n == 1) _setEnabled = only;
|
||||
}
|
||||
|
||||
// Capture current scene lighting: LIEDFOLBGHL() in 2023-03-21. Too
|
||||
// many void() methods on the type to pick by shape — name only.
|
||||
_capture = AccessTools.Method(moodSettingsType, "LIEDFOLBGHL", Type.EmptyTypes);
|
||||
|
||||
var renderSettings = Mod.ResolveType("UnityEngine.RenderSettings");
|
||||
_renderSkybox = renderSettings is null ? null : AccessTools.Property(renderSettings, "skybox");
|
||||
_renderSun = renderSettings is null ? null : AccessTools.Property(renderSettings, "sun");
|
||||
_lightType = Mod.ResolveType("UnityEngine.Light");
|
||||
|
||||
// Fog preservation: FogMoodSettings() + NLDDIDEIEFH() reads
|
||||
// RenderSettings.fog/fogStartDistance/fogEndDistance/fogColor into the
|
||||
// block (ISIL FogMoodSettings.txt, called right after the ctor in
|
||||
// LIEDFOLBGHL). MoodSetting.FogSettings is the serialized reference
|
||||
// the apply step hands to the fog blender.
|
||||
_fogSettingsType = Mod.ResolveType("RecRoom.Core.Creation.SceneMoods.MoodBlendData.FogMoodSettings");
|
||||
_fogCapture = _fogSettingsType is null ? null : AccessTools.Method(_fogSettingsType, "NLDDIDEIEFH", Type.EmptyTypes);
|
||||
_moodFog = AccessTools.Property(_moodSettingType, "FogSettings");
|
||||
|
||||
_materialType = Mod.ResolveType("UnityEngine.Material");
|
||||
_shaderType = Mod.ResolveType("UnityEngine.Shader");
|
||||
_moodConfigHolder = Mod.ResolveType("LNMDIIFOFPD");
|
||||
_cameraDataType = Mod.ResolveType("UnityEngine.Rendering.Universal.UniversalAdditionalCameraData");
|
||||
|
||||
var ok = _sceneManagerInstance is not null
|
||||
&& (_sceneMoodSettingsField is not null || _sceneMoodSettingsProp is not null)
|
||||
&& _applyMood is not null;
|
||||
Mod.Log.Msg($"[royale-night] resolved: instance={_sceneManagerInstance is not null} " +
|
||||
$"moodSettings={_sceneMoodSettingsField is not null || _sceneMoodSettingsProp is not null} " +
|
||||
$"apply={_applyMood is not null} setEnabled={_setEnabled is not null} capture={_capture is not null} " +
|
||||
$"isEnabled={_isEnabled is not null} currentMood={_currentMood is not null} skybox={_renderSkybox is not null} " +
|
||||
$"sun={_renderSun is not null} light={_lightType is not null} fogCapture={_fogCapture is not null} moodFog={_moodFog is not null}");
|
||||
return ok;
|
||||
}
|
||||
|
||||
// RenderSettings.sun ← the scene's directional Light when unset. Frontier
|
||||
// ships without the reference ("Sun Source reference has not been set in
|
||||
// Lighting settings" is the engine's own warning), so nothing sun-related
|
||||
// from the mood would otherwise apply.
|
||||
private static void EnsureSun()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_renderSun is null || _lightType is null) return;
|
||||
var current = _renderSun.GetValue(null);
|
||||
if (current is not null && !IsUnityNull(current))
|
||||
{
|
||||
Mod.Log.Msg($"[royale-night] RenderSettings.sun already set: '{ObjectName(current)}'");
|
||||
return;
|
||||
}
|
||||
|
||||
var unityObject = Mod.ResolveType("UnityEngine.Object");
|
||||
var il2cppLight = Il2CppTypeOf(_lightType);
|
||||
if (unityObject is null || il2cppLight is null) return;
|
||||
|
||||
object? directional = null;
|
||||
foreach (var m in unityObject.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
||||
{
|
||||
if (m.Name != "FindObjectsOfType" || m.IsGenericMethodDefinition) continue;
|
||||
var ps = m.GetParameters();
|
||||
if (ps.Length != 1) continue;
|
||||
var arr = m.Invoke(null, new object[] { il2cppLight });
|
||||
var n = Count(arr);
|
||||
float best = -1f;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
var item = Item(arr, i);
|
||||
if (item is null) continue;
|
||||
var light = AsType(item, _lightType);
|
||||
if (light is null) continue;
|
||||
// LightType.Directional == 1
|
||||
var kind = GetMember(light, "type");
|
||||
if (kind is null || Convert.ToInt32(kind) != 1) continue;
|
||||
var intensity = GetMember(light, "intensity") is float f ? f : 0f;
|
||||
if (intensity > best) { best = intensity; directional = light; }
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if (directional is null)
|
||||
{
|
||||
Mod.Log.Warning("[royale-night] no directional Light found in scene — sun direction/colour will not change");
|
||||
return;
|
||||
}
|
||||
_renderSun.SetValue(null, directional);
|
||||
_sunWasNull = true;
|
||||
Mod.Log.Msg($"[royale-night] RenderSettings.sun ← '{ObjectName(directional)}'");
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] EnsureSun failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
}
|
||||
|
||||
// Swap the mood asset's FogSettings for a block captured from the
|
||||
// scene's current RenderSettings so applying the mood leaves fog as-is.
|
||||
// The asset is shared for the session, so RestoreFog puts the original
|
||||
// block back when we leave or toggle off.
|
||||
private static void PreserveFog(object mood)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_fogSettingsType is null || _fogCapture is null || _moodFog is null || !_moodFog.CanWrite)
|
||||
{
|
||||
Mod.Log.Warning("[royale-night] fog preservation unavailable (FogMoodSettings/NLDDIDEIEFH/FogSettings unresolved) — mood fog will apply");
|
||||
return;
|
||||
}
|
||||
if (ReferenceEquals(_fogPatchedMood, mood) && _originalFog is not null) return;
|
||||
|
||||
var captured = Activator.CreateInstance(_fogSettingsType);
|
||||
if (captured is null) return;
|
||||
_fogCapture.Invoke(captured, null);
|
||||
if (Mod.Cfg.RecRoyaleNightDisableFog)
|
||||
{
|
||||
// The block has no exposed enabled flag; push it out of range so
|
||||
// even if the blender re-enables fog each frame it is invisible.
|
||||
SetMember(captured, "startDistance", 1_000_000f);
|
||||
SetMember(captured, "fadeDistance", 1_000_000f);
|
||||
}
|
||||
|
||||
_originalFog = _moodFog.GetValue(mood);
|
||||
_fogPatchedMood = mood;
|
||||
_moodFog.SetValue(mood, captured);
|
||||
Mod.Log.Msg("[royale-night] mood fog replaced with the scene's own fog settings");
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] PreserveFog failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
}
|
||||
|
||||
private static void RestoreFog()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_fogPatchedMood is not null && _originalFog is not null && _moodFog is not null && _moodFog.CanWrite)
|
||||
_moodFog.SetValue(_fogPatchedMood, _originalFog);
|
||||
}
|
||||
catch { }
|
||||
_fogPatchedMood = null;
|
||||
_originalFog = null;
|
||||
}
|
||||
|
||||
private static void RestoreMoodPatches()
|
||||
{
|
||||
RestoreFog();
|
||||
RestoreDarkness();
|
||||
RestoreOtherSunLights();
|
||||
// Scene objects die with the scene; just forget them.
|
||||
_probed = false;
|
||||
_hidden.Clear();
|
||||
_hideScanned = false;
|
||||
_fogStateSaved = false;
|
||||
_origFogEnabled = null;
|
||||
// The scene's SceneMoodSettings dies with the scene; just forget it.
|
||||
_sceneMoodInstalled = false;
|
||||
_sceneMoodsObj = null;
|
||||
_origDefaultMood = _origAvailableMoods = null;
|
||||
}
|
||||
|
||||
// The engine drives exactly one light: RenderSettings.sun (Frontier:
|
||||
// "SkyboxLight", the sun-disc light). The map's actual key light is a
|
||||
// separate directional Light it never touches, so daylight keeps
|
||||
// casting. Copy the engine-driven sun's rotation and colour onto every
|
||||
// other directional light and scale their intensity down. Originals are
|
||||
// kept per light and restored on toggle-off / scene change.
|
||||
private sealed class LightState
|
||||
{
|
||||
public object Light = null!;
|
||||
public object? Intensity, Color, Rotation, ShadowStrength;
|
||||
}
|
||||
private static readonly List<LightState> _otherSuns = new();
|
||||
|
||||
private static void MatchOtherSunLights()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_renderSun is null || _lightType is null) return;
|
||||
var sun = _renderSun.GetValue(null);
|
||||
if (sun is null || IsUnityNull(sun)) return;
|
||||
var sunPtr = (sun as Il2CppObjectBase)?.Pointer ?? IntPtr.Zero;
|
||||
var sunTransform = GetMember(sun, "transform");
|
||||
var sunRotation = sunTransform is null ? null : GetMember(sunTransform, "rotation");
|
||||
var sunColor = GetMember(sun, "color");
|
||||
|
||||
var unityObject = Mod.ResolveType("UnityEngine.Object");
|
||||
var il2cppLight = Il2CppTypeOf(_lightType);
|
||||
if (unityObject is null || il2cppLight is null) return;
|
||||
|
||||
MethodInfo? findAll = null;
|
||||
foreach (var m in unityObject.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
||||
if (m.Name == "FindObjectsOfType" && !m.IsGenericMethodDefinition && m.GetParameters().Length == 1) { findAll = m; break; }
|
||||
if (findAll is null) return;
|
||||
|
||||
var arr = findAll.Invoke(null, new object[] { il2cppLight });
|
||||
var n = Count(arr);
|
||||
var touched = new List<string>();
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
var item = Item(arr, i);
|
||||
if (item is null) continue;
|
||||
var light = AsType(item, _lightType);
|
||||
if (light is null) continue;
|
||||
var kind = GetMember(light, "type");
|
||||
if (kind is null || Convert.ToInt32(kind) != 1) continue; // Directional only
|
||||
var ptr = (light as Il2CppObjectBase)?.Pointer ?? IntPtr.Zero;
|
||||
if (ptr != IntPtr.Zero && ptr == sunPtr) continue; // engine already drives this one
|
||||
|
||||
var state = _otherSuns.Find(s => (s.Light as Il2CppObjectBase)?.Pointer == ptr);
|
||||
if (state is null)
|
||||
{
|
||||
state = new LightState
|
||||
{
|
||||
Light = light,
|
||||
Intensity = GetMember(light, "intensity"),
|
||||
Color = GetMember(light, "color"),
|
||||
ShadowStrength = GetMember(light, "shadowStrength"),
|
||||
Rotation = GetMember(light, "transform") is object tr ? GetMember(tr, "rotation") : null,
|
||||
};
|
||||
_otherSuns.Add(state);
|
||||
}
|
||||
|
||||
if (state.Intensity is float orig)
|
||||
SetMember(light, "intensity", orig * Mod.Cfg.RecRoyaleNightSunScale);
|
||||
if (sunColor is not null) SetMember(light, "color", sunColor);
|
||||
if (sunRotation is not null && GetMember(light, "transform") is object t)
|
||||
SetMember(t, "rotation", sunRotation);
|
||||
touched.Add(ObjectName(light));
|
||||
}
|
||||
if (touched.Count > 0 && !_otherSunsLogged)
|
||||
{
|
||||
_otherSunsLogged = true;
|
||||
Mod.Log.Msg($"[royale-night] matched {touched.Count} other directional light(s) to the mood sun: {string.Join(", ", touched)}");
|
||||
}
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] MatchOtherSunLights failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
}
|
||||
private static bool _otherSunsLogged;
|
||||
|
||||
// Register the mood as the scene's defaultMood + sole availableMoods entry
|
||||
// (get_CurrentMood returns availableMoods[index] when the synced index is
|
||||
// set, else defaultMood — either way our mood). Originals are kept so
|
||||
// UninstallSceneMood can put the scene back to "no room moods".
|
||||
private static object? _sceneMoodsObj;
|
||||
private static object? _origDefaultMood, _origAvailableMoods;
|
||||
private static bool _sceneMoodInstalled;
|
||||
|
||||
private static void InstallSceneMood(object moods, object mood)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_sceneMoodInstalled && ReferenceEquals(_sceneMoodsObj, moods)) return;
|
||||
_sceneMoodsObj = moods;
|
||||
_origDefaultMood = GetMember(moods, "defaultMood");
|
||||
_origAvailableMoods = GetMember(moods, "availableMoods");
|
||||
|
||||
var okDefault = SetMember(moods, "defaultMood", mood);
|
||||
|
||||
// availableMoods is an Il2CppReferenceArray<MoodSetting>; build a
|
||||
// one-element array of the same interop type and fill slot 0.
|
||||
var okArray = false;
|
||||
var arrProp = moods.GetType().GetProperty("availableMoods", Any);
|
||||
var arrType = arrProp?.PropertyType ?? _origAvailableMoods?.GetType();
|
||||
if (arrType is not null)
|
||||
{
|
||||
object? arr = null;
|
||||
foreach (var sig in new[] { new[] { typeof(long) }, new[] { typeof(int) } })
|
||||
{
|
||||
var ctor = arrType.GetConstructor(sig);
|
||||
if (ctor is null) continue;
|
||||
try { arr = ctor.Invoke(new object[] { sig[0] == typeof(long) ? 1L : 1 }); break; } catch { }
|
||||
}
|
||||
if (arr is not null)
|
||||
{
|
||||
var set = arrType.GetMethod("set_Item", new[] { typeof(int), _moodSettingType! });
|
||||
if (set is null)
|
||||
{
|
||||
foreach (var m in arrType.GetMethods())
|
||||
if (m.Name == "set_Item" && m.GetParameters().Length == 2 && m.GetParameters()[0].ParameterType == typeof(int)) { set = m; break; }
|
||||
}
|
||||
try { set?.Invoke(arr, new[] { 0, mood }); okArray = set is not null && SetMember(moods, "availableMoods", arr); } catch { }
|
||||
}
|
||||
}
|
||||
|
||||
_sceneMoodInstalled = okDefault || okArray;
|
||||
Mod.Log.Msg($"[royale-night] installed mood as scene default (defaultMood={okDefault} availableMoods={okArray})");
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] InstallSceneMood failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
}
|
||||
|
||||
private static void UninstallSceneMood(object moods)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!_sceneMoodInstalled) return;
|
||||
if (_origDefaultMood is not null) SetMember(moods, "defaultMood", _origDefaultMood);
|
||||
else SetMember(moods, "defaultMood", null!);
|
||||
if (_origAvailableMoods is not null) SetMember(moods, "availableMoods", _origAvailableMoods);
|
||||
}
|
||||
catch { }
|
||||
_sceneMoodInstalled = false;
|
||||
_sceneMoodsObj = null;
|
||||
_origDefaultMood = _origAvailableMoods = null;
|
||||
}
|
||||
|
||||
// ── fog off / hide objects ────────────────────────────────────────
|
||||
private static bool _fogStateSaved;
|
||||
private static object? _origFogEnabled;
|
||||
private static Type? _renderSettingsType;
|
||||
|
||||
private static void ForceFogOff()
|
||||
{
|
||||
try
|
||||
{
|
||||
_renderSettingsType ??= Mod.ResolveType("UnityEngine.RenderSettings");
|
||||
if (_renderSettingsType is null) return;
|
||||
var p = _renderSettingsType.GetProperty("fog", BindingFlags.Public | BindingFlags.Static);
|
||||
if (p is null) return;
|
||||
if (!_fogStateSaved) { _origFogEnabled = p.GetValue(null); _fogStateSaved = true; }
|
||||
if (p.GetValue(null) is true) p.SetValue(null, false);
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] ForceFogOff failed: {ex.Message}"); }
|
||||
}
|
||||
|
||||
private static void RestoreFogState()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_fogStateSaved && _renderSettingsType is not null && _origFogEnabled is bool b)
|
||||
_renderSettingsType.GetProperty("fog", BindingFlags.Public | BindingFlags.Static)?.SetValue(null, b);
|
||||
}
|
||||
catch { }
|
||||
_fogStateSaved = false;
|
||||
_origFogEnabled = null;
|
||||
}
|
||||
|
||||
// Disable every Renderer whose GameObject or material name contains one
|
||||
// of Cfg.RecRoyaleNightHideObjects. Runs each apply cycle but only scans
|
||||
// once per scene (the matches are static scenery); ShowObjects re-enables.
|
||||
private static readonly List<object> _hidden = new();
|
||||
private static bool _hideScanned;
|
||||
|
||||
private static void HideObjects()
|
||||
{
|
||||
if (_hideScanned) return;
|
||||
_hideScanned = true;
|
||||
try
|
||||
{
|
||||
var patterns = new List<string>();
|
||||
foreach (var s in Mod.Cfg.RecRoyaleNightHideObjects)
|
||||
if (!string.IsNullOrWhiteSpace(s)) patterns.Add(s.Trim());
|
||||
if (patterns.Count == 0) return;
|
||||
|
||||
var rendererType = Mod.ResolveType("UnityEngine.Renderer");
|
||||
var unityObject = Mod.ResolveType("UnityEngine.Object");
|
||||
var il2cppRenderer = rendererType is null ? null : Il2CppTypeOf(rendererType);
|
||||
if (rendererType is null || unityObject is null || il2cppRenderer is null) return;
|
||||
|
||||
MethodInfo? findAll = null;
|
||||
foreach (var m in unityObject.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
||||
if (m.Name == "FindObjectsOfType" && !m.IsGenericMethodDefinition && m.GetParameters().Length == 1) { findAll = m; break; }
|
||||
if (findAll is null) return;
|
||||
|
||||
var arr = findAll.Invoke(null, new object[] { il2cppRenderer });
|
||||
var n = Count(arr);
|
||||
var names = new HashSet<string>();
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
var item = Item(arr, i);
|
||||
if (item is null) continue;
|
||||
var r = AsType(item, rendererType);
|
||||
if (r is null) continue;
|
||||
var name = ObjectName(r);
|
||||
var matName = "";
|
||||
try { var mat = GetMember(r, "sharedMaterial"); if (mat is not null && !IsUnityNull(mat)) matName = ObjectName(mat); } catch { }
|
||||
var hit = false;
|
||||
foreach (var p in patterns)
|
||||
if (name.Contains(p, StringComparison.OrdinalIgnoreCase) || matName.Contains(p, StringComparison.OrdinalIgnoreCase)) { hit = true; break; }
|
||||
if (!hit) continue;
|
||||
if (GetMember(r, "enabled") is true && SetMember(r, "enabled", false))
|
||||
{
|
||||
_hidden.Add(r);
|
||||
names.Add(name);
|
||||
}
|
||||
}
|
||||
Mod.Log.Msg($"[royale-night] hid {_hidden.Count} renderer(s) matching [{string.Join(",", patterns)}]: {string.Join(", ", names)}");
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] HideObjects failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
}
|
||||
|
||||
private static void ShowObjects()
|
||||
{
|
||||
foreach (var r in _hidden)
|
||||
{
|
||||
try { if (!IsUnityNull(r)) SetMember(r, "enabled", true); } catch { }
|
||||
}
|
||||
_hidden.Clear();
|
||||
_hideScanned = false;
|
||||
}
|
||||
|
||||
// ── CV2 room-settings probe ───────────────────────────────────────
|
||||
// The Maker Pen mood chips ("Skydome Constant", "Room Skydome Modify",
|
||||
// Sun/Fog/Background Objects equivalents) drive RoomSkydome / RoomSun /
|
||||
// RoomFog components that hang off RoomElementSettingsManager, which
|
||||
// CircuitsV2Manager brings up. Log whether any of that exists in this
|
||||
// scene so we know what a chips-in-Rec-Royale build would have to add.
|
||||
private static bool _probed;
|
||||
private static void ProbeCircuitsSupport()
|
||||
{
|
||||
if (_probed) return;
|
||||
_probed = true;
|
||||
try
|
||||
{
|
||||
var unityObject = Mod.ResolveType("UnityEngine.Object");
|
||||
if (unityObject is null) return;
|
||||
MethodInfo? findAll = null;
|
||||
foreach (var m in unityObject.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
||||
if (m.Name == "FindObjectsOfType" && !m.IsGenericMethodDefinition && m.GetParameters().Length == 1) { findAll = m; break; }
|
||||
if (findAll is null) return;
|
||||
|
||||
var parts = new List<string>();
|
||||
foreach (var name in new[]
|
||||
{
|
||||
"RecRoom.CircuitsV2.CircuitsV2Manager",
|
||||
"RecRoom.CircuitsV2.RoomSettings.RoomElementSettingsManager",
|
||||
"RecRoom.CircuitsV2.RoomSettings.RoomSkydome",
|
||||
"RecRoom.CircuitsV2.RoomSettings.RoomSun",
|
||||
"RecRoom.CircuitsV2.RoomSettings.RoomFog",
|
||||
"RecRoom.CircuitsV2.RoomSettings.RoomBackgroundObjects",
|
||||
"MakerPen",
|
||||
})
|
||||
{
|
||||
var t = Mod.ResolveType(name);
|
||||
if (t is null) { parts.Add($"{name.Substring(name.LastIndexOf('.') + 1)}=<type missing>"); continue; }
|
||||
var il2 = Il2CppTypeOf(t);
|
||||
if (il2 is null) { parts.Add($"{t.Name}=?"); continue; }
|
||||
int n = 0;
|
||||
try { n = Count(findAll.Invoke(null, new object[] { il2 })); } catch (Exception ex) { parts.Add($"{t.Name}=err:{(ex.InnerException ?? ex).Message}"); continue; }
|
||||
parts.Add($"{t.Name}={n}");
|
||||
}
|
||||
Mod.Log.Msg($"[royale-night] CV2 probe in '{_sceneName}': {string.Join(" ", parts)}");
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] CV2 probe failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
}
|
||||
|
||||
private static void RestoreOtherSunLights()
|
||||
{
|
||||
foreach (var s in _otherSuns)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (IsUnityNull(s.Light)) continue;
|
||||
if (s.Intensity is not null) SetMember(s.Light, "intensity", s.Intensity);
|
||||
if (s.Color is not null) SetMember(s.Light, "color", s.Color);
|
||||
if (s.ShadowStrength is not null) SetMember(s.Light, "shadowStrength", s.ShadowStrength);
|
||||
if (s.Rotation is not null && GetMember(s.Light, "transform") is object t) SetMember(t, "rotation", s.Rotation);
|
||||
}
|
||||
catch { }
|
||||
}
|
||||
_otherSuns.Clear();
|
||||
_otherSunsLogged = false;
|
||||
}
|
||||
|
||||
// Make sure RenderSettings.skybox is a material on the "Custom/SkyBox"
|
||||
// shader. The apply step assigns MoodConfig.SkyBoxMaterial
|
||||
// (LNMDIIFOFPD.NHAEHKJINFH → SkyBoxMaterial); in RRO scenes that
|
||||
// reference resolves to nothing, leaving the skybox null. Prefer any
|
||||
// already-loaded material on that shader, else create one, and also
|
||||
// write it into MoodConfig so later applies keep using it.
|
||||
private static void EnsureMoodSkybox()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_renderSkybox is null || _materialType is null || _shaderType is null) return;
|
||||
|
||||
var current = _renderSkybox.GetValue(null);
|
||||
var currentShader = current is null || IsUnityNull(current) ? "" : ShaderNameOf(current);
|
||||
if (currentShader == "Custom/SkyBox") return;
|
||||
|
||||
object? mat = _ourSkybox is not null && !IsUnityNull(_ourSkybox) ? _ourSkybox : null;
|
||||
|
||||
// 1. Any loaded material already on the shader (e.g. the real
|
||||
// Skybox_Moods_Sunny_Default_Mat if some scene brought it in).
|
||||
if (mat is null)
|
||||
{
|
||||
var resources = Mod.ResolveType("UnityEngine.Resources");
|
||||
var il2cppMat = Il2CppTypeOf(_materialType);
|
||||
if (resources is not null && il2cppMat is not null)
|
||||
{
|
||||
foreach (var m in resources.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
||||
{
|
||||
if (m.Name != "FindObjectsOfTypeAll" || m.IsGenericMethodDefinition || m.GetParameters().Length != 1) continue;
|
||||
var arr = m.Invoke(null, new object[] { il2cppMat });
|
||||
var n = Count(arr);
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
var item = Item(arr, i);
|
||||
if (item is null) continue;
|
||||
var wrapped = AsType(item, _materialType);
|
||||
if (wrapped is not null && ShaderNameOf(wrapped) == "Custom/SkyBox") { mat = wrapped; break; }
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (mat is not null) Mod.Log.Msg($"[royale-night] using loaded skybox material '{ObjectName(mat)}'");
|
||||
}
|
||||
|
||||
// 2. Build one: new Material(Shader.Find("Custom/SkyBox")).
|
||||
if (mat is null)
|
||||
{
|
||||
var find = AccessTools.Method(_shaderType, "Find", new[] { typeof(string) });
|
||||
var shader = find?.Invoke(null, new object[] { "Custom/SkyBox" });
|
||||
if (shader is null || IsUnityNull(shader))
|
||||
{
|
||||
Mod.Log.Warning("[royale-night] Shader.Find(\"Custom/SkyBox\") returned nothing — sky colours will not apply");
|
||||
return;
|
||||
}
|
||||
var ctor = _materialType.GetConstructor(new[] { _shaderType }) ?? _materialType.GetConstructor(new[] { shader.GetType() });
|
||||
if (ctor is null)
|
||||
{
|
||||
Mod.Log.Warning("[royale-night] Material(Shader) constructor not found");
|
||||
return;
|
||||
}
|
||||
mat = ctor.Invoke(new[] { shader });
|
||||
SetMember(mat, "name", "DorkNet_RecRoyaleNight_Skybox");
|
||||
Mod.Log.Msg("[royale-night] created skybox material on Custom/SkyBox");
|
||||
}
|
||||
|
||||
_ourSkybox = mat;
|
||||
_renderSkybox.SetValue(null, mat);
|
||||
|
||||
// Keep the engine's own apply path pointing at it too.
|
||||
if (_moodConfigHolder is not null)
|
||||
{
|
||||
foreach (var p in _moodConfigHolder.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static))
|
||||
{
|
||||
if (!p.CanRead || p.GetIndexParameters().Length != 0) continue;
|
||||
var cfg = p.GetValue(null);
|
||||
if (cfg is null || IsUnityNull(cfg)) continue;
|
||||
if (SetMember(cfg, "SkyBoxMaterial", mat)) Mod.Log.Msg("[royale-night] MoodConfig.SkyBoxMaterial ← our material");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] EnsureMoodSkybox failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
}
|
||||
|
||||
private static string ShaderNameOf(object material)
|
||||
{
|
||||
try
|
||||
{
|
||||
var shader = GetMember(material, "shader");
|
||||
return shader is null || IsUnityNull(shader) ? "" : ObjectName(shader);
|
||||
}
|
||||
catch { return ""; }
|
||||
}
|
||||
|
||||
private static string DescribeSkybox()
|
||||
{
|
||||
try
|
||||
{
|
||||
var sky = _renderSkybox?.GetValue(null);
|
||||
if (sky is null || IsUnityNull(sky)) return "<null>";
|
||||
return $"'{ObjectName(sky)}' [{ShaderNameOf(sky)}]";
|
||||
}
|
||||
catch { return "?"; }
|
||||
}
|
||||
|
||||
// Post-exposure lives in the URP Volume the mood engine drives. It only
|
||||
// shows if the Volume is enabled with weight and the camera renders
|
||||
// post-processing (Rec Room's graphics settings can turn that off).
|
||||
private static void EnsurePostProcessing(object moods)
|
||||
{
|
||||
try
|
||||
{
|
||||
var volume = Read(_volume, moods);
|
||||
if (volume is not null && !IsUnityNull(volume))
|
||||
{
|
||||
var enabled = GetMember(volume, "enabled");
|
||||
var weight = GetMember(volume, "weight");
|
||||
var isGlobal = GetMember(volume, "isGlobal");
|
||||
var profile = GetMember(volume, "profile");
|
||||
Mod.Log.Msg($"[royale-night] volume: enabled={enabled} weight={weight} global={isGlobal} profile={(profile is null ? "<null>" : ObjectName(profile))}");
|
||||
if (Mod.Cfg.RecRoyaleNightForcePostProcessing)
|
||||
{
|
||||
if (enabled is false) SetMember(volume, "enabled", true);
|
||||
if (weight is float w && w < 1f) SetMember(volume, "weight", 1f);
|
||||
}
|
||||
}
|
||||
else Mod.Log.Warning("[royale-night] scene mood Volume is null — post-exposure darkening unavailable");
|
||||
|
||||
if (_cameraDataType is null) { Mod.Log.Warning("[royale-night] UniversalAdditionalCameraData type not found"); return; }
|
||||
var unityObject = Mod.ResolveType("UnityEngine.Object");
|
||||
var il2cppCam = Il2CppTypeOf(_cameraDataType);
|
||||
if (unityObject is null || il2cppCam is null) return;
|
||||
foreach (var m in unityObject.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
||||
{
|
||||
if (m.Name != "FindObjectsOfType" || m.IsGenericMethodDefinition || m.GetParameters().Length != 1) continue;
|
||||
var arr = m.Invoke(null, new object[] { il2cppCam });
|
||||
var n = Count(arr);
|
||||
int forced = 0;
|
||||
var states = new List<string>();
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
var item = Item(arr, i);
|
||||
if (item is null) continue;
|
||||
var cam = AsType(item, _cameraDataType);
|
||||
if (cam is null) continue;
|
||||
var pp = GetMember(cam, "renderPostProcessing");
|
||||
states.Add($"{ObjectName(cam)}={pp}");
|
||||
if (pp is false && Mod.Cfg.RecRoyaleNightForcePostProcessing && SetMember(cam, "renderPostProcessing", true)) forced++;
|
||||
}
|
||||
Mod.Log.Msg($"[royale-night] camera post-processing: {string.Join(", ", states)}{(forced > 0 ? $" → forced on ({forced})" : "")}");
|
||||
break;
|
||||
}
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] EnsurePostProcessing failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
}
|
||||
|
||||
// Darken the mood data in place before it is applied:
|
||||
// ColorGradingSettings.exposure += RecRoyaleNightExposure (EV; the
|
||||
// ColorGrading blender writes it into ColorAdjustments.postExposure
|
||||
// via VolumeParameter.Override — the only knob that also dims baked
|
||||
// lightmaps, since it's a full-frame post effect)
|
||||
// SunSettings.sunIntensity *= RecRoyaleNightSunScale
|
||||
// SkyBoxSettings.ambientLightIntensity *= RecRoyaleNightAmbientScale
|
||||
// Originals are kept and restored by RestoreDarkness so the shared asset
|
||||
// is clean again for any custom room that uses the same mood.
|
||||
private static void PatchDarkness(object mood)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (ReferenceEquals(_darkPatchedMood, mood)) return;
|
||||
RestoreDarkness();
|
||||
|
||||
var grading = GetMember(mood, "ColorGradingSettings");
|
||||
var sun = GetMember(mood, "SunSettings");
|
||||
var sky = GetMember(mood, "SkyBoxSettings");
|
||||
|
||||
if (grading is not null && Mod.Cfg.RecRoyaleNightExposure != 0f && GetMember(grading, "exposure") is float ev)
|
||||
{
|
||||
_origExposure = ev;
|
||||
SetMember(grading, "exposure", ev + Mod.Cfg.RecRoyaleNightExposure);
|
||||
}
|
||||
if (sun is not null && Mod.Cfg.RecRoyaleNightSunScale != 1f && GetMember(sun, "sunIntensity") is float si)
|
||||
{
|
||||
_origSunIntensity = si;
|
||||
SetMember(sun, "sunIntensity", si * Mod.Cfg.RecRoyaleNightSunScale);
|
||||
}
|
||||
if (sky is not null && Mod.Cfg.RecRoyaleNightAmbientScale != 1f && GetMember(sky, "ambientLightIntensity") is float ai)
|
||||
{
|
||||
_origAmbient = ai;
|
||||
SetMember(sky, "ambientLightIntensity", ai * Mod.Cfg.RecRoyaleNightAmbientScale);
|
||||
}
|
||||
_darkPatchedMood = mood;
|
||||
Mod.Log.Msg($"[royale-night] darkened mood: exposure {_origExposure?.ToString("0.##") ?? "?"}→{(_origExposure + Mod.Cfg.RecRoyaleNightExposure)?.ToString("0.##") ?? "?"} EV, " +
|
||||
$"sun ×{Mod.Cfg.RecRoyaleNightSunScale} ({_origSunIntensity?.ToString("0.##") ?? "?"}), ambient ×{Mod.Cfg.RecRoyaleNightAmbientScale} ({_origAmbient?.ToString("0.##") ?? "?"})");
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] PatchDarkness failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
}
|
||||
|
||||
private static void RestoreDarkness()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_darkPatchedMood is not null)
|
||||
{
|
||||
var grading = GetMember(_darkPatchedMood, "ColorGradingSettings");
|
||||
var sun = GetMember(_darkPatchedMood, "SunSettings");
|
||||
var sky = GetMember(_darkPatchedMood, "SkyBoxSettings");
|
||||
if (grading is not null && _origExposure is float e) SetMember(grading, "exposure", e);
|
||||
if (sun is not null && _origSunIntensity is float s) SetMember(sun, "sunIntensity", s);
|
||||
if (sky is not null && _origAmbient is float a) SetMember(sky, "ambientLightIntensity", a);
|
||||
}
|
||||
}
|
||||
catch { }
|
||||
_darkPatchedMood = null;
|
||||
_origExposure = _origSunIntensity = _origAmbient = null;
|
||||
}
|
||||
|
||||
private static bool SetMember(object o, string name, object value)
|
||||
{
|
||||
var t = o.GetType();
|
||||
var p = t.GetProperty(name, Any);
|
||||
if (p is not null && p.CanWrite) { try { p.SetValue(o, value); return true; } catch { } }
|
||||
var f = t.GetField(name, Any);
|
||||
if (f is not null) { try { f.SetValue(o, value); return true; } catch { } }
|
||||
return false;
|
||||
}
|
||||
|
||||
// Il2CppInterop exposes il2cpp fields as properties (and, on some
|
||||
// versions, as fields). Read either.
|
||||
private static object? GetMember(object o, string name)
|
||||
{
|
||||
var t = o.GetType();
|
||||
var p = t.GetProperty(name, Any);
|
||||
if (p is not null && p.CanRead && p.GetIndexParameters().Length == 0)
|
||||
{ try { return p.GetValue(o); } catch { } }
|
||||
var f = t.GetField(name, Any);
|
||||
if (f is not null) { try { return f.GetValue(o); } catch { } }
|
||||
return null;
|
||||
}
|
||||
|
||||
// Il2CppType.From(Type) → Il2CppSystem.Type, via reflection so this
|
||||
// project keeps not referencing Il2Cppmscorlib at compile time.
|
||||
private static object? Il2CppTypeOf(Type type)
|
||||
{
|
||||
foreach (var m in typeof(Il2CppType).GetMethods(BindingFlags.Public | BindingFlags.Static))
|
||||
{
|
||||
if (m.Name != "From" || m.IsGenericMethodDefinition) continue;
|
||||
var ps = m.GetParameters();
|
||||
if (ps.Length >= 1 && ps[0].ParameterType == typeof(Type))
|
||||
{
|
||||
var args = new object?[ps.Length];
|
||||
args[0] = type;
|
||||
for (int i = 1; i < ps.Length; i++) args[i] = ps[i].HasDefaultValue ? ps[i].DefaultValue : (ps[i].ParameterType.IsValueType ? Activator.CreateInstance(ps[i].ParameterType) : null);
|
||||
var r = m.Invoke(null, args);
|
||||
if (r is not null) return r;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static object? GetSceneManager()
|
||||
{
|
||||
var inst = _sceneManagerInstance?.GetValue(null);
|
||||
if (inst is null || IsUnityNull(inst)) return null;
|
||||
return inst;
|
||||
}
|
||||
|
||||
// Loads the configured MoodSetting asset. Resources.Load(path, Type)
|
||||
// pulls it out of resources.assets by name (the ResourceManager table
|
||||
// keys are the lower-cased asset names, no folder). Fallback:
|
||||
// Resources.FindObjectsOfTypeAll(MoodSetting) by name, which only sees
|
||||
// assets already in memory.
|
||||
private static object? GetNightMood()
|
||||
{
|
||||
var wanted = (Mod.Cfg.RecRoyaleNightMood ?? "").Trim();
|
||||
if (wanted.Length == 0) wanted = "Night_Calm_Outdoor_Mood";
|
||||
if (_nightMood is not null && _nightMoodLoadedName == wanted && !IsUnityNull(_nightMood))
|
||||
return _nightMood;
|
||||
|
||||
_nightMood = null;
|
||||
var resources = Mod.ResolveType("UnityEngine.Resources");
|
||||
if (resources is null || _moodSettingType is null)
|
||||
{
|
||||
Mod.Log.Warning("[royale-night] UnityEngine.Resources not found");
|
||||
return null;
|
||||
}
|
||||
|
||||
var il2cppType = Il2CppTypeOf(_moodSettingType);
|
||||
if (il2cppType is null)
|
||||
{
|
||||
Mod.Log.Warning("[royale-night] Il2CppType.From(Type) not found");
|
||||
return null;
|
||||
}
|
||||
object? found = null;
|
||||
|
||||
foreach (var m in resources.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
||||
{
|
||||
if (m.Name != "Load" || m.IsGenericMethodDefinition) continue;
|
||||
var ps = m.GetParameters();
|
||||
if (ps.Length != 2 || ps[0].ParameterType != typeof(string)) continue;
|
||||
try
|
||||
{
|
||||
found = m.Invoke(null, new object[] { wanted, il2cppType });
|
||||
if (found is not null && !IsUnityNull(found)) break;
|
||||
found = null;
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] Resources.Load failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
}
|
||||
|
||||
if (found is null)
|
||||
{
|
||||
foreach (var m in resources.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
||||
{
|
||||
if (m.Name != "FindObjectsOfTypeAll" || m.IsGenericMethodDefinition) continue;
|
||||
var ps = m.GetParameters();
|
||||
if (ps.Length != 1) continue;
|
||||
try
|
||||
{
|
||||
var arr = m.Invoke(null, new object[] { il2cppType });
|
||||
var n = Count(arr);
|
||||
var names = new List<string>();
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
var item = Item(arr, i);
|
||||
if (item is null) continue;
|
||||
var name = ObjectName(item);
|
||||
names.Add(name);
|
||||
if (string.Equals(name, wanted, StringComparison.OrdinalIgnoreCase)) { found = item; break; }
|
||||
}
|
||||
if (found is null)
|
||||
Mod.Log.Warning($"[royale-night] mood '{wanted}' not in memory; loaded moods: {string.Join(", ", names)}");
|
||||
}
|
||||
catch (Exception ex) { Mod.Log.Warning($"[royale-night] FindObjectsOfTypeAll failed: {(ex.InnerException ?? ex).Message}"); }
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (found is null)
|
||||
{
|
||||
Mod.Log.Warning($"[royale-night] could not load MoodSetting '{wanted}'");
|
||||
return null;
|
||||
}
|
||||
|
||||
// Resources.Load hands back a UnityEngine.Object wrapper; re-wrap the
|
||||
// same il2cpp pointer as MoodSetting so the apply method accepts it.
|
||||
_nightMood = AsType(found, _moodSettingType);
|
||||
_nightMoodLoadedName = wanted;
|
||||
return _nightMood;
|
||||
}
|
||||
|
||||
private static object? AsType(object obj, Type target)
|
||||
{
|
||||
if (target.IsInstanceOfType(obj)) return obj;
|
||||
if (obj is Il2CppObjectBase il2cpp)
|
||||
{
|
||||
var ctor = target.GetConstructor(new[] { typeof(IntPtr) });
|
||||
if (ctor is not null) return ctor.Invoke(new object[] { il2cpp.Pointer });
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
// ── hotkey ────────────────────────────────────────────────────────
|
||||
private static void PollHotkey()
|
||||
{
|
||||
var key = Mod.Cfg.RecRoyaleNightToggleKey;
|
||||
if (string.IsNullOrWhiteSpace(key)) return;
|
||||
try
|
||||
{
|
||||
if (!_inputResolved) ResolveInput(key);
|
||||
if (_getKeyDown is null || _toggleKey is null) return;
|
||||
if (_getKeyDown.Invoke(null, new[] { _toggleKey }) is true) Toggle();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Mod.Log.Warning($"[royale-night] hotkey poll failed: {ex.Message}");
|
||||
_getKeyDown = null; // stop spamming
|
||||
}
|
||||
}
|
||||
|
||||
private static void ResolveInput(string key)
|
||||
{
|
||||
_inputResolved = true;
|
||||
var keyCodeType = Mod.ResolveType("UnityEngine.KeyCode");
|
||||
var inputType = Mod.ResolveType("UnityEngine.Input");
|
||||
if (keyCodeType is null || inputType is null)
|
||||
{
|
||||
Mod.Log.Warning("[royale-night] UnityEngine.Input/KeyCode not found — hotkey disabled");
|
||||
return;
|
||||
}
|
||||
try { _toggleKey = Enum.Parse(keyCodeType, key, ignoreCase: true); }
|
||||
catch
|
||||
{
|
||||
Mod.Log.Warning($"[royale-night] '{key}' is not a UnityEngine.KeyCode — hotkey disabled");
|
||||
return;
|
||||
}
|
||||
_getKeyDown = AccessTools.Method(inputType, "GetKeyDown", new[] { keyCodeType });
|
||||
if (_getKeyDown is null) Mod.Log.Warning("[royale-night] Input.GetKeyDown(KeyCode) not found — hotkey disabled");
|
||||
}
|
||||
|
||||
// ── helpers ───────────────────────────────────────────────────────
|
||||
private static bool MatchesScene(string sceneName)
|
||||
{
|
||||
if (string.IsNullOrEmpty(sceneName)) return false;
|
||||
foreach (var s in Mod.Cfg.RecRoyaleNightScenes)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(s)) continue;
|
||||
if (sceneName.Contains(s.Trim(), StringComparison.OrdinalIgnoreCase)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// UnityEngine.Object wrappers are non-null C# objects even when the
|
||||
// native object is destroyed/missing; `== null` is overloaded in the
|
||||
// interop, so route through the static op_Equality when present.
|
||||
private static bool IsUnityNull(object obj)
|
||||
{
|
||||
try
|
||||
{
|
||||
var t = obj.GetType();
|
||||
var eq = t.GetMethod("op_Equality", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
|
||||
if (eq is not null && eq.GetParameters().Length == 2)
|
||||
return eq.Invoke(null, new[] { obj, null }) is true;
|
||||
}
|
||||
catch { }
|
||||
return false;
|
||||
}
|
||||
|
||||
private static string ObjectName(object obj)
|
||||
{
|
||||
try
|
||||
{
|
||||
var p = obj.GetType().GetProperty("name", Any);
|
||||
return p?.GetValue(obj) as string ?? "";
|
||||
}
|
||||
catch { return ""; }
|
||||
}
|
||||
|
||||
private static string Describe(object mood)
|
||||
{
|
||||
var friendly = "";
|
||||
try { friendly = _friendlyName?.GetValue(mood) as string ?? ""; } catch { }
|
||||
var name = ObjectName(mood);
|
||||
return friendly.Length > 0 ? $"{friendly} ({name})" : name;
|
||||
}
|
||||
|
||||
private static int Count(object? arr)
|
||||
{
|
||||
if (arr is null) return 0;
|
||||
if (arr is Array a) return a.Length;
|
||||
var p = arr.GetType().GetProperty("Length") ?? arr.GetType().GetProperty("Count");
|
||||
return (p?.GetValue(arr) as int?) ?? 0;
|
||||
}
|
||||
|
||||
private static object? Item(object? arr, int i)
|
||||
{
|
||||
if (arr is null) return null;
|
||||
if (arr is Array a) return a.GetValue(i);
|
||||
var gi = arr.GetType().GetMethod("get_Item", new[] { typeof(int) });
|
||||
return gi?.Invoke(arr, new object[] { i });
|
||||
}
|
||||
}
|
||||
@@ -11,5 +11,18 @@
|
||||
"GoldenTrophy",
|
||||
"IsleOfLostSkulls",
|
||||
"TheRiseofJumbotron"
|
||||
]
|
||||
],
|
||||
"RecRoyaleNightMode": false,
|
||||
"RecRoyaleNightMood": "Night_Calm_Outdoor_Mood",
|
||||
"RecRoyaleNightScenes": ["RecRoyale"],
|
||||
"RecRoyaleNightFlashlights": true,
|
||||
"RecRoyaleNightFog": false,
|
||||
"RecRoyaleNightExposure": -3.5,
|
||||
"RecRoyaleNightSunScale": 0.15,
|
||||
"RecRoyaleNightAmbientScale": 0.2,
|
||||
"RecRoyaleNightForcePostProcessing": true,
|
||||
"RecRoyaleNightMatchSunLights": true,
|
||||
"RecRoyaleNightDisableFog": false,
|
||||
"RecRoyaleNightHideObjects": ["Cloud"],
|
||||
"RecRoyaleNightToggleKey": ""
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user