Randomized Cars feature (v1.3.0.0)

Changes:
* Changed description for Data Effect in Ghost Mode to note that it also effects the finish despawn effect.

New Options:
* Randomized Cars - Cars will be randomly assigned a car type and colors, allowing for more variety when racing ghosts.

Randomized Cars:
* Enable or disabled the Randomized Cars feature.
* Change whether randomness is fixed, so that individual replays will use the same random values.
* Add an extra randomness seed that's combined with Fixed Randomness (or Random By Placement) to change up what you'll normally see.
* Change whether cars are randomized for local leaderboards replays.
* Change whether cars are randomized for online leaderboards replays.
* Change whether cars are randomized for Steam Rival replays (requires Steam Rivals to be enabled).
* Change whether online replays using the Kickstarter backer car will also be randomized (randomization is disabled by default).
* Change individual weights of vanilla cars, and weights for all custom cars, so that certain cars will be more likely to get chosen.
* Weights for individual custom cars can be changed by adding entries to `random.car_chances` in `Settings/Config.json`.
* Change how random cars are selected:
    * Off - Car types won't be randomized.
    * Car Types - Default behavior where duplicates are allowed. Choose cars based on individual weighted values.
    * Car Types (Cycle) - Cycle through all available car types before choosing duplicates.
* Change whether car/color randomness is decided by placement order (otherwise it will be decided by replay, or random if Fixed Randomness is disabled).
* Change how random car colors are selected:
    * Off - Car colors won't be randomized.
    * Color Presets - Default behavior where duplicates are allowed. Colors are chozen from your car color presets.
    * Color Presets (Cycle) - Cycle through all available color presets before choosing duplicates.
    * HSV - Colors are generated with random Hue/Saturation/Value channels.
    * RGB - Colors are generated with random Red/Green/Blue channels.
    * Default Colors - Cars will always use their own default color preset. Useful for custom cars that aren't intended to be recolored.

Author: trigger-segfault

Distance.ReplayIntensifies/ConfigurationLogic.cs

@@ -94,8 +94,19 @@
     <Compile Include="Harmony\Assembly-CSharp\PlayerDataReplay\get_CreateCarScreen_.cs" />
     <Compile Include="Harmony\Assembly-CSharp\PlayerDataReplay\InitCarVirtual.cs" />
     <Compile Include="Harmony\Assembly-CSharp\PlayerDataReplay\OnEventReplayOptionsMenuClosed.cs" />
+    <Compile Include="Harmony\Assembly-CSharp\ReplayManager\AddOnlineReplaysToGroup.cs" />
+    <Compile Include="Harmony\Assembly-CSharp\ReplayManager\AddReplayToGroup.cs" />
+    <Compile Include="Harmony\Assembly-CSharp\ReplayManager\OnAllPlayerEventFinish.cs" />
+    <Compile Include="Harmony\Assembly-CSharp\ReplayManager\OnEventModeStarted.cs" />
     <Compile Include="Harmony\Assembly-CSharp\ReplayManager\OnLoadedOnlineReplaysDownloadFinished.cs" />
+    <Compile Include="Randomizer\RandomCarMethod.cs" />
+    <Compile Include="Randomizer\RandomColorMethod.cs" />
+    <Compile Include="Scripts\ReplayManagerCompoundData.cs" />
+    <Compile Include="Helpers\Crc.cs" />
     <Compile Include="Helpers\SteamworksHelper.cs" />
+    <Compile Include="Randomizer\RandomColorPreset.cs" />
+    <Compile Include="Randomizer\RandomCarType.cs" />
+    <Compile Include="Scripts\CarReplayDataCompoundData.cs" />
     <Compile Include="Scripts\PlayerDataReplayCompoundData.cs" />
     <Compile Include="Harmony\Assembly-CSharp\CarLevelOfDetail\SetLevelOfDetail.cs" />
     <Compile Include="Harmony\Assembly-CSharp\FinishMenuLogic\ShowOnlineLeaderboards.cs" />

Distance.ReplayIntensifies/Distance.ReplayIntensifies.csproj

@@ -1,36 +1,38 @@
-using HarmonyLib;
-using System;
+using Distance.ReplayIntensifies.Scripts;
+using HarmonyLib;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
-using UnityEngine;
 
 namespace Distance.ReplayIntensifies.Harmony
 {
 	/// <summary>
 	/// Patch to allow unclamped car colors for opponents (so others can show off their ultrabright car presets).
 	/// This patch is needed because the <see cref="PlayerDataBase.ClampCarColors_"/> property seems to be inlined
 	/// by the JIT.
+	/// <para/>
+	/// Also includes patch to initialized randomized car type and colors.
 	/// </summary>
 	/// <remarks>
-	/// Required For: Unrestricted Opponent Car Colors.
+	/// Required For: Unrestricted Opponent Car Colors, and Randomized Cars.
 	/// </remarks>
 	[HarmonyPatch(typeof(PlayerDataBase), nameof(PlayerDataBase.Initialize))]
 	internal static class PlayerDataBase__Initialize
 	{
 		[HarmonyTranspiler]
 		internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
 		{
-			Mod.Instance.Logger.Info("Transpiling...");
+			var codes = new List<CodeInstruction>(instructions);
+
+			Mod.Instance.Logger.Info("Transpiling... (1/3)");
 			// VISUAL:
 			// Replace call to PlayerDataBase.ClampCarColors_.get with Mod.GetClampCarColors
 			//if (PlayerDataBase.ClampCarColors_)
 			//{
 			//	data.carColors_.ClampColors();
 			//}
 
-			var codes = new List<CodeInstruction>(instructions);
 			for (int i = 0; i < codes.Count; i++)
 			{
 				// Find getter for: virtual bool PlayerDataBase.ClampCarColors_
@@ -46,7 +48,82 @@ internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruct
 					break;
 				}
 			}
+
+			Mod.Instance.Logger.Info("Transpiling... (2/3)");
+			// VISUAL:
+			// Override call to assigning car type so we can hook random car selection.
+			//this.UseCarWithName(data.carName_, null);
+			// -to-
+			//UseCarWithNameOverride_(this, data.carName_, null);
+
+			for (int i = 0; i < codes.Count; i++)
+			{
+				if (codes[i].opcode == OpCodes.Call && ((MethodInfo)codes[i].operand).Name == "UseCarWithName")
+				{
+					Mod.Instance.Logger.Info($"call UseCarWithName @ {i}");
+
+					// Replace: call UseCarWithName
+					// With:    call UseCarWithNameOverride_
+					codes[i].opcode = OpCodes.Call;
+					codes[i].operand = typeof(PlayerDataBase__Initialize).GetMethod(nameof(UseCarWithNameOverride_));
+
+					break;
+				}
+			}
+
+			Mod.Instance.Logger.Info("Transpiling... (3/3)");
+			// VISUAL:
+			// Override call to assigning car colors so we can hook random car selection.
+			//this.SetOriginalColors(data.carColors_);
+			// -to-
+			//SetOriginalColorsOverride_(this, data.carColors_);
+
+			for (int i = 0; i < codes.Count; i++)
+			{
+				if (codes[i].opcode == OpCodes.Call && ((MethodInfo)codes[i].operand).Name == "SetOriginalColors")
+				{
+					Mod.Instance.Logger.Info($"call SetOriginalColors @ {i}");
+
+					// Replace: call SetOriginalColors
+					// With:    call SetOriginalColorsOverride_
+					codes[i].opcode = OpCodes.Call;
+					codes[i].operand = typeof(PlayerDataBase__Initialize).GetMethod(nameof(SetOriginalColorsOverride_));
+
+					break;
+				}
+			}
+
 			return codes.AsEnumerable();
 		}
+
+		#region Helpers
+
+		public static bool UseCarWithNameOverride_(PlayerDataBase playerDataBase, string carName, Profile profile)
+		{
+			if (playerDataBase is PlayerDataReplay playerDataReplay)
+			{
+				var compoundData = playerDataReplay.GetComponent<PlayerDataReplayCompoundData>();
+				if (compoundData && compoundData.IsRandomnessEnabled)
+				{
+					carName = compoundData.CarData.name_;
+				}
+			}
+			return playerDataBase.UseCarWithName(carName, profile);
+		}
+
+		public static void SetOriginalColorsOverride_(PlayerDataBase playerDataBase, CarColors carColors)
+		{
+			if (playerDataBase is PlayerDataReplay playerDataReplay)
+			{
+				var compoundData = playerDataReplay.GetComponent<PlayerDataReplayCompoundData>();
+				if (compoundData && compoundData.IsRandomnessEnabled)
+				{
+					carColors = compoundData.CarData.colors_;
+				}
+			}
+			playerDataBase.SetOriginalColors(carColors);
+		}
+
+		#endregion
 	}
 }

Distance.ReplayIntensifies/Harmony/Assembly-CSharp/PlayerDataBase/Initialize.cs

@@ -0,0 +1,67 @@
+using Distance.ReplayIntensifies.Scripts;
+using HarmonyLib;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using UnityEngine;
+
+namespace Distance.ReplayIntensifies.Harmony
+{
+	/// <summary>
+	/// Patch to mark replays that were loaded from online leaderboards.
+	/// </summary>
+	/// <remarks>
+	/// Required For: Use Random Online Cars.
+	/// </remarks>
+	[HarmonyPatch(typeof(ReplayManager), nameof(ReplayManager.AddOnlineReplaysToGroup))]
+	internal static class ReplayManager__AddOnlineReplaysToGroup
+	{
+		[HarmonyTranspiler]
+		internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
+		{
+			var codes = new List<CodeInstruction>(instructions);
+
+			Mod.Instance.Logger.Info("Transpiling...");
+			// VISUAL:
+			//this.AddReplayToGroup(carReplayData, group);
+			// -to-
+			//AddOnlineReplayToGroupOverride_(this, carReplayData, group);
+
+			for (int i = 0; i < codes.Count; i++)
+			{
+				if (codes[i].opcode == OpCodes.Call && ((MethodInfo)codes[i].operand).Name == "AddReplayToGroup")
+				{
+					Mod.Instance.Logger.Info($"call AddReplayToGroup @ {i}");
+
+					// Replace: call AddReplayToGroup
+					// With:    call AddOnlineReplayToGroupOverride_
+					codes[i].opcode  = OpCodes.Call;
+					codes[i].operand = typeof(ReplayManager__AddOnlineReplaysToGroup).GetMethod(nameof(AddOnlineReplayToGroupOverride_));
+
+					break;
+				}
+			}
+
+			return codes.AsEnumerable();
+		}
+
+		#region Helpers
+
+		public static void AddOnlineReplayToGroupOverride_(ReplayManager replayManager, CarReplayData carReplayData, GameObject group)
+		{
+			if (carReplayData)
+			{
+				var carCompoundData = carReplayData.gameObject.GetOrAddComponent<CarReplayDataCompoundData>();
+				if (carCompoundData)
+				{
+					carCompoundData.IsOnline = true;
+				}
+			}
+
+			replayManager.AddReplayToGroup(carReplayData, group);
+		}
+
+		#endregion
+	}
+}

Distance.ReplayIntensifies/Harmony/Assembly-CSharp/ReplayManager/AddOnlineReplaysToGroup.cs

@@ -0,0 +1,29 @@
+using Distance.ReplayIntensifies.Scripts;
+using HarmonyLib;
+using UnityEngine;
+
+namespace Distance.ReplayIntensifies.Harmony
+{
+	/// <summary>
+	/// Patch to mark replays that did not finish the level, and ensure compound data is always created.
+	/// </summary>
+	/// <remarks>
+	/// Required For: Randomized Cars.
+	/// </remarks>
+	[HarmonyPatch(typeof(ReplayManager), nameof(ReplayManager.AddReplayToGroup))]
+	internal static class ReplayManager__AddReplayToGroup
+	{
+		[HarmonyPostfix]
+		internal static void Postfix(ReplayManager __instance, CarReplayData carReplayData, GameObject group)
+		{
+			if (carReplayData)
+			{
+				var carCompoundData = carReplayData.gameObject.GetOrAddComponent<CarReplayDataCompoundData>();
+				if (carCompoundData)
+				{
+					carCompoundData.DidNotFinish = (group == __instance.didNotFinishReplays_);
+				}
+			}
+		}
+	}
+}

Distance.ReplayIntensifies/Harmony/Assembly-CSharp/ReplayManager/AddReplayToGroup.cs

@@ -0,0 +1,67 @@
+using Distance.ReplayIntensifies.Scripts;
+using HarmonyLib;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using UnityEngine;
+
+namespace Distance.ReplayIntensifies.Harmony
+{
+	/// <summary>
+	/// Patch to mark replays that were just created from the player's last run (so that we don't randomize them).
+	/// </summary>
+	/// <remarks>
+	/// Required For: Randomized Cars.
+	/// </remarks>
+	[HarmonyPatch(typeof(ReplayManager), nameof(ReplayManager.OnAllPlayerEventFinish))]
+	internal static class ReplayManager__OnAllPlayerEventFinish
+	{
+		[HarmonyTranspiler]
+		internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
+		{
+			var codes = new List<CodeInstruction>(instructions);
+
+			Mod.Instance.Logger.Info("Transpiling...");
+			// VISUAL:
+			//this.AddReplayToGroup(component.FinishAndGetReplayData(data.finishData_), replayGroup);
+			// -to-
+			//AddMyPlayerReplayToGroupOverride_(this, component.FinishAndGetReplayData(data.finishData_), replayGroup);
+
+			for (int i = 0; i < codes.Count; i++)
+			{
+				if (codes[i].opcode == OpCodes.Call && ((MethodInfo)codes[i].operand).Name == "AddReplayToGroup")
+				{
+					Mod.Instance.Logger.Info($"call AddReplayToGroup @ {i}");
+
+					// Replace: call AddReplayToGroup
+					// With:    call AddMyPlayerReplayToGroupOverride_
+					codes[i].opcode  = OpCodes.Call;
+					codes[i].operand = typeof(ReplayManager__OnAllPlayerEventFinish).GetMethod(nameof(AddMyPlayerReplayToGroupOverride_));
+
+					break;
+				}
+			}
+
+			return codes.AsEnumerable();
+		}
+
+		#region Helpers
+
+		public static void AddMyPlayerReplayToGroupOverride_(ReplayManager replayManager, CarReplayData carReplayData, GameObject group)
+		{
+			if (carReplayData)
+			{
+				var carCompoundData = carReplayData.gameObject.GetOrAddComponent<CarReplayDataCompoundData>();
+				if (carCompoundData)
+				{
+					carCompoundData.IsMyPlayer = true;
+				}
+			}
+
+			replayManager.AddReplayToGroup(carReplayData, group);
+		}
+
+		#endregion
+	}
+}

Distance.ReplayIntensifies/Harmony/Assembly-CSharp/ReplayManager/OnAllPlayerEventFinish.cs

@@ -0,0 +1,31 @@
+using Distance.ReplayIntensifies.Scripts;
+using HarmonyLib;
+
+namespace Distance.ReplayIntensifies.Harmony
+{
+	[HarmonyPatch(typeof(ReplayManager), nameof(ReplayManager.OnEventModeStarted))]
+	internal static class ReplayManager__OnEventModeStarted
+	{
+		[HarmonyPrefix]
+		internal static void Prefix(ReplayManager __instance)
+		{
+			if (__instance.gm_.ModeID_ == GameModeID.LevelEditorPlay)
+			{
+				return;
+			}
+
+			if (Mod.Instance.Config.EnableRandomizedCars)
+			{
+				// Create and setup compound data for managing randomization that affects all replay cars.
+				ReplayManagerCompoundData.Create(__instance);
+			}
+		}
+
+		[HarmonyPostfix]
+		internal static void Postfix(ReplayManager __instance)
+		{
+			// Cleanup for unused compound data.
+			__instance.gameObject.RemoveComponent<ReplayManagerCompoundData>();
+		}
+	}
+}

Distance.ReplayIntensifies/Harmony/Assembly-CSharp/ReplayManager/OnEventModeStarted.cs

@@ -0,0 +1,42 @@
+using System.Linq;
+using System.Text;
+
+namespace Distance.ReplayIntensifies.Helpers
+{
+	public static class Crc
+	{
+		private static readonly uint[] Crc32Table = Enumerable.Range(0, 256).Select(Calculate32).ToArray();
+
+		public const uint Initial32 = 0u;
+
+		private static uint Calculate32(int seed)
+		{
+			const uint poly = 0xEDB88320;
+			uint value = unchecked((uint)seed);
+			for (int i = 0; i < 8; i++)
+			{
+				value = ((value & 0x1) != 0) ? ((value >> 1) ^ poly) : (value >> 1);
+			}
+			return value;
+		}
+
+		public static int Hash32(byte[] bytes, int init) => unchecked((int)Hash32(bytes, (uint)init));
+
+		public static uint Hash32(byte[] bytes, uint init = Initial32)
+		{
+			uint result = ~init;
+			foreach (byte b in bytes)
+			{
+				result = (result >> 8) ^ Crc32Table[(byte)(result ^ b)];
+			}
+			return ~result;
+		}
+
+		public static int Hash32(string text, int init) => unchecked((int)Hash32(text, (uint)init));
+
+		public static uint Hash32(string text, uint init = Initial32)
+		{
+			return Hash32(Encoding.UTF8.GetBytes(text), init);
+		}
+	}
+}