mirror of
https://github.com/DorkSquadRR/DorkNet.git
synced 2026-10-25 23:18:44 -07:00
Alexa
258183fb94
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.
1402 lines
66 KiB
C#
1402 lines
66 KiB
C#
// 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 });
|
||
}
|
||
}
|