using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using PouetHunterGame.Object;
using PouetHunterGame.Useful;
using TMPro;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("PouetHunterGame")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PouetHunterGame")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4bfd40e1-a03f-48d7-9539-7b383e562621")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace PouetHunterGame
{
[BepInPlugin("Xelan.PouetHunterGame", "PouetHunterGame", "1.0.0")]
public class PouetHunterGame : BaseUnityPlugin
{
private const string modGUID = "Xelan.PouetHunterGame";
private const string modName = "PouetHunterGame";
private const string modVersion = "1.0.0";
private readonly Harmony harmony = new Harmony("Xelan.PouetHunterGame");
private static PouetHunterGame Instance;
public static ManualLogSource Logger;
public static ConfigEntry<bool> SpawnJetpack;
public static ConfigEntry<bool> SpawnBeltbagForHunters;
public static ConfigEntry<bool> SpawnMapperForHunters;
public static ConfigEntry<bool> DisplayNewHunterName;
public static ConfigEntry<bool> CanChosenScrapBeTwoHanded;
public static ConfigEntry<bool> MonstersInside;
public static ConfigEntry<bool> MonstersOutside;
public static ConfigEntry<int> ShotgunAmount;
public static ConfigEntry<int> AmmoAmount;
public static ConfigEntry<int> StartingHour;
public static ConfigEntry<int> EndingHour;
public static ConfigEntry<int> TotalRounds;
public static ConfigEntry<int> NbScraps;
public static PlayerControllerB[] players;
public static HashSet<PlayerControllerB> hunters = new HashSet<PlayerControllerB>();
public static HashSet<ulong> welcomedPlayers = new HashSet<ulong>();
public static HashSet<GrabbableObject> AlreadyCollectedScraps = new HashSet<GrabbableObject>();
public static Dictionary<string, int> WinsAsHunter = new Dictionary<string, int>();
public static Dictionary<string, int> WinsAsPouet = new Dictionary<string, int>();
public static Dictionary<string, string> playersColor = new Dictionary<string, string>();
public static string scrapChosenName;
public static int numRound = 1;
public static bool HuntersWon = true;
public static bool GameAlreadyOver = false;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
Logger = Logger.CreateLogSource("Xelan.PouetHunterGame");
Logger.LogInfo((object)"╔═══════════════════════════════════════════════╗");
Logger.LogInfo((object)"║ PouetHunterGame is UP ! ║");
Logger.LogInfo((object)"╚═══════════════════════════════════════════════╝");
LoadConfig();
harmony.PatchAll();
}
private void LoadConfig()
{
SpawnJetpack = Bind("Paramètre de la partie", "Jetpack", defaultValue: false, "Fait apparaître des Jetpack pour chaque joueur au début de la partie");
StartingHour = Bind("Paramètre de la partie", "Heure de départ", 9, "Heure à partir de laquelle les Pouets ne peuvent plus sortir de la Facility sans l'objet recherché");
EndingHour = Bind("Paramètre de la partie", "Heure de fin", 24, "Heure à partir de laquelle la partie se termine");
TotalRounds = Bind("Paramètre de la partie", "Nombre de manche", 5, "Nombre de manche dans la partie (1 Manche = 1 Jour)");
NbScraps = Bind("Paramètre de la partie", "Nombre de Scraps", 3, "Nombre de Scraps permettant de devenir Hunter");
CanChosenScrapBeTwoHanded = Bind("Paramètre de la partie", "Scraps à 2 mains", defaultValue: true, "Est-ce que l'objet à récupérer peut être un objet à 2 mains ?");
MonstersInside = Bind("Paramètre de la partie", "Monstres Interieur", defaultValue: true, "Est-ce que les monstres apparaissent à l'intérieur ?");
MonstersOutside = Bind("Paramètre de la partie", "Monstres Exterieur", defaultValue: true, "Est-ce que les monstres apparaissent à l'extérieur ?");
ShotgunAmount = Bind("Paramètre des Hunters", "Nombre de Shotgun", 1, "Nombre de Shotgun à faire apparaître pour les Hunters");
AmmoAmount = Bind("Paramètre des Hunters", "Nombre de Munition", 8, "Nombre de Munition à faire apparaître pour les Hunters");
SpawnBeltbagForHunters = Bind("Paramètre des Hunters", "Beltbag", defaultValue: false, "Fait apparaître des Beltbags pour les Hunters");
SpawnMapperForHunters = Bind("Paramètre des Hunters", "Mapper", defaultValue: false, "Fait apparaître des Mappers pour les Hunters 2h avant la fin du temps");
DisplayNewHunterName = Bind("Paramètre des Hunters", "Afficher nouveau Hunter", defaultValue: false, "Lorsque quelqu'un devient Hunter, affiche son nom via Transmit");
CreateIntConfig(StartingHour, 9, 23);
CreateIntConfig(EndingHour, 12, 24);
CreateIntConfig(TotalRounds, 1, 10);
CreateIntConfig(NbScraps, 1, 10);
CreateIntConfig(ShotgunAmount, 0, 5);
CreateIntConfig(AmmoAmount, 0, 20);
}
private ConfigEntry<T> Bind<T>(string section, string key, T defaultValue, string description)
{
return ((BaseUnityPlugin)this).Config.Bind<T>(section, key, defaultValue, description);
}
private void CreateIntConfig(ConfigEntry<int> configEntry, int min = 0, int max = 100)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Expected O, but got Unknown
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Expected O, but got Unknown
IntSliderOptions val = new IntSliderOptions();
((BaseRangeOptions<int>)val).Min = min;
((BaseRangeOptions<int>)val).Max = max;
((BaseOptions)val).RequiresRestart = false;
IntSliderConfigItem val2 = new IntSliderConfigItem(configEntry, val);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
}
}
}
namespace PouetHunterGame.Useful
{
internal class ColorManager
{
private static readonly Regex HexColorRegex = new Regex("^#([0-9a-fA-F]{6})$", RegexOptions.Compiled);
public static string GetRandomHexColor()
{
Random random = new Random();
int num = random.Next(256);
int num2 = random.Next(256);
int num3 = random.Next(256);
return $"#{num:X2}{num2:X2}{num3:X2}";
}
public static string GetPlayerColor(PlayerControllerB player)
{
return PouetHunterGame.playersColor.ContainsKey(player.playerUsername) ? PouetHunterGame.playersColor[player.playerUsername] : "white";
}
public static string SetNewColorForPlayer(PlayerControllerB player, string newColor)
{
string text = PouetHunterGame.playersColor[player.playerUsername];
if (CouleursToHEX.CouleursHEX.TryGetValue(newColor.ToLower(), out var value))
{
text = value;
}
else if (HexColorRegex.IsMatch(newColor))
{
text = newColor;
}
PouetHunterGame.playersColor[player.playerUsername] = text;
return text;
}
}
internal class GameOverManager
{
public static bool IsGameOver()
{
if (!TimeOfDay.Instance.timeHasStarted)
{
return false;
}
bool allPlayersDead = StartOfRound.Instance.allPlayersDead;
bool flag = TimeOfDay.Instance.hour >= GameUtils.GetValidHour(PouetHunterGame.EndingHour.Value, 12, 24);
if (allPlayersDead || flag || (!IsThereAChoosenScrapLeftInside() && AllHuntersAreDead() && !IsThereAChoosenScrapBeingHeldOutside()))
{
PouetHunterGame.HuntersWon = false;
return true;
}
if (AllPouetsAreDead())
{
return true;
}
if (OnlyOnePlayerRemain())
{
PouetHunterGame.HuntersWon = false;
return true;
}
return false;
}
public static bool AllHuntersAreDead()
{
return PouetHunterGame.hunters.All((PlayerControllerB x) => x.isPlayerDead);
}
public static bool AllPouetsAreDead()
{
return PouetHunterGame.players.Where((PlayerControllerB x) => !x.isPlayerDead).All((PlayerControllerB x) => PouetHunterGame.hunters.Contains(x));
}
public static bool OnlyOnePlayerRemain()
{
return PouetHunterGame.players.Count((PlayerControllerB x) => !x.isPlayerDead) == 1;
}
public static bool IsThereAChoosenScrapLeftInside()
{
List<GrabbableObject> list = (from x in Object.FindObjectsOfType<GrabbableObject>()
where x.itemProperties.itemName.Equals(PouetHunterGame.scrapChosenName) && x.isInFactory
select x).ToList();
return list.Count != 0;
}
public static bool IsThereAChoosenScrapBeingHeldOutside()
{
List<GrabbableObject> list = (from x in Object.FindObjectsOfType<GrabbableObject>()
where x.itemProperties.itemName.Equals(PouetHunterGame.scrapChosenName) && !x.isInFactory && x.isHeld
select x).ToList();
return list.Count != 0;
}
public static void DisplaysWinners()
{
Dictionary<PlayerControllerB, int> dictionary = new Dictionary<PlayerControllerB, int>();
PlayerControllerB[] players = PouetHunterGame.players;
foreach (PlayerControllerB val in players)
{
string playerUsername = val.playerUsername;
int num = (PouetHunterGame.WinsAsHunter.ContainsKey(playerUsername) ? PouetHunterGame.WinsAsHunter[playerUsername] : 0);
int num2 = (PouetHunterGame.WinsAsPouet.ContainsKey(playerUsername) ? PouetHunterGame.WinsAsPouet[playerUsername] : 0);
dictionary[val] = num + num2;
}
int maxWins = dictionary.Values.Max();
List<PlayerControllerB> list = (from x in dictionary
where x.Value == maxWins
select x.Key).ToList();
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("<color=white>[</color><color=#FFC000>Partie Terminée</color><color=white>]</color>\n");
if (list.Count > 1)
{
stringBuilder.Append("<color=#FFC000>Gagnants :</color>\n");
}
else
{
stringBuilder.Append("<color=#FFC000>Gagnant :</color>\n");
}
foreach (PlayerControllerB item in list)
{
stringBuilder.Append("<color=" + ColorManager.GetPlayerColor(item) + ">" + item.playerUsername + "</color>\n");
}
HUDManager.Instance.AddTextToChatOnServer(stringBuilder.ToString(), -1);
}
public static IEnumerator KillRemainingPlayerWithDelay()
{
yield return (object)new WaitForSeconds(5f);
foreach (PlayerControllerB player in PouetHunterGame.players.Where((PlayerControllerB x) => !x.isPlayerDead))
{
player.DamagePlayerFromOtherClientServerRpc(200, Vector3.zero, 0);
PouetHunterGame.Logger.LogInfo((object)("Killing " + player.playerUsername + " as he was still ALIVE"));
}
}
}
internal class GameUtils
{
public static void DisplayTip(string title, string msg, bool isWarning = false)
{
HUDManager.Instance.DisplayTip(title, msg, isWarning, false, "LC_Tip1");
}
public static void ClearChat()
{
HUDManager instance = HUDManager.Instance;
if (instance != null)
{
for (int i = 0; i < 3; i++)
{
instance.AddTextToChatOnServer("\u00a0", -1);
instance.AddTextToChatOnServer("\u00a0\u00a0", -1);
}
}
}
public static bool IsPlayerHolding(PlayerControllerB player, string scrapName)
{
return player.ItemSlots.Where((GrabbableObject scrap) => (Object)(object)scrap != (Object)null).Any((GrabbableObject scrap) => string.Equals(scrap.itemProperties.itemName, scrapName, StringComparison.OrdinalIgnoreCase));
}
public static int GetValidHour(int hour, int min, int max)
{
if (hour < min)
{
return min - 6;
}
if (hour > max)
{
return max - 6;
}
return hour - 6;
}
public static void ResetRound()
{
PouetHunterGame.hunters.Clear();
PouetHunterGame.HuntersWon = true;
PouetHunterGame.GameAlreadyOver = false;
PouetHunterGame.AlreadyCollectedScraps.Clear();
}
public static void ResetGame(bool resetWelcomePlayer = true)
{
if (resetWelcomePlayer)
{
PouetHunterGame.welcomedPlayers.Clear();
PouetHunterGame.playersColor.Clear();
}
PouetHunterGame.WinsAsHunter.Clear();
PouetHunterGame.WinsAsPouet.Clear();
PouetHunterGame.numRound = 1;
ResetRound();
PouetHunterGame.Logger.LogInfo((object)"The Game has been reset");
}
public static void UnlockAllDoors()
{
IEnumerable<DoorLock> enumerable = from x in Object.FindObjectsOfType<DoorLock>()
where x.isLocked
select x;
int num = 0;
foreach (DoorLock item in enumerable)
{
item.UnlockDoorSyncWithServer();
num++;
}
PouetHunterGame.Logger.LogInfo((object)(num + " doors have been Unlocked"));
}
public static void DisplayScoreBoard()
{
HUDManager instance = HUDManager.Instance;
if (instance != null)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("<color=white>[</color><color=#FFC000>Scoreboard</color><color=white>]</color>\n");
PlayerControllerB[] players = PouetHunterGame.players;
foreach (PlayerControllerB val in players)
{
string playerUsername = val.playerUsername;
int num = (PouetHunterGame.WinsAsHunter.ContainsKey(playerUsername) ? PouetHunterGame.WinsAsHunter[playerUsername] : 0);
int num2 = (PouetHunterGame.WinsAsPouet.ContainsKey(playerUsername) ? PouetHunterGame.WinsAsPouet[playerUsername] : 0);
stringBuilder.Append($"<color={ColorManager.GetPlayerColor(val)}>{playerUsername}</color><color=white> : {num}</color><color=#FF0000>H</color><color=white> | {num2}</color><color=#D86ECC>P</color>\n");
}
instance.AddTextToChatOnServer(stringBuilder.ToString(), -1);
}
}
public static void DisplayBeginingRoundMessage()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("<color=white>[</color><color=#D86ECC>Pouet</color><color=#FF0000>Hunter</color><color=#FFC000>Game</color><color=white>]\n");
stringBuilder.Append($"<color=white>[</color><color=#FFC000>Manche {PouetHunterGame.numRound}/{PouetHunterGame.TotalRounds.Value}</color><color=white>]</color>\n");
stringBuilder.Append("Scrap à trouver :</color><color=#24A5FC>\n" + PouetHunterGame.scrapChosenName + "</color>\n");
stringBuilder.Append("<color=white>Nombre :</color><color=#24A5FC>\n" + PouetHunterGame.NbScraps.Value + "</color>\n");
stringBuilder.Append("<color=white>Heure Début-Fin :</color>\n<color=#24A5FC>" + PouetHunterGame.StartingHour.Value + "H</color><color=white> - </color><color=#24A5FC>" + PouetHunterGame.EndingHour.Value + "H</color>");
HUDManager.Instance.AddTextToChatOnServer(stringBuilder.ToString(), -1);
}
public static void UnlockAllSuitsAndSignalTranslator()
{
int[] array = new int[8] { 0, 1, 2, 3, 17, 24, 25, 26 };
int[] array2 = array;
foreach (int num in array2)
{
UnlockableItem val = StartOfRound.Instance.unlockablesList.unlockables[num];
if (!val.alreadyUnlocked)
{
StartOfRound.Instance.BuyShipUnlockableServerRpc(num, Object.FindObjectOfType<Terminal>().groupCredits);
PouetHunterGame.Logger.LogInfo((object)(val.unlockableName + " has been unlock"));
}
}
}
public static void HideShipObjectWithID(int id, Vector3 position)
{
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
PlaceableShipObject val = ((IEnumerable<PlaceableShipObject>)Object.FindObjectsOfType<PlaceableShipObject>()).FirstOrDefault((Func<PlaceableShipObject, bool>)((PlaceableShipObject x) => x.unlockableID == id));
if (val == null)
{
PouetHunterGame.Logger.LogError((object)"Object not found");
return;
}
if (val.parentObject == null)
{
PouetHunterGame.Logger.LogError((object)"Object Parent is null");
return;
}
NetworkObjectReference val2 = NetworkObjectReference.op_Implicit(((Component)val.parentObject).GetComponent<NetworkObject>());
ShipBuildModeManager instance = ShipBuildModeManager.Instance;
Quaternion rotation = ((Component)val).transform.rotation;
instance.PlaceShipObject(position, ((Quaternion)(ref rotation)).eulerAngles, val, false);
ShipBuildModeManager instance2 = ShipBuildModeManager.Instance;
rotation = ((Component)val).transform.rotation;
instance2.PlaceShipObjectServerRpc(position, ((Quaternion)(ref rotation)).eulerAngles, val2, 0);
PouetHunterGame.Logger.LogInfo((object)$"Object {id} hidden at {((Component)val).transform.position}");
}
public static void ChangeStartingDeadline(int newDeadLine)
{
TimeOfDay instance = TimeOfDay.Instance;
instance.quotaVariables.deadlineDaysAmount = newDeadLine;
instance.timeUntilDeadline = (float)(instance.quotaVariables.deadlineDaysAmount + newDeadLine) * instance.totalTime;
TimeOfDay.Instance.timeUntilDeadline = (int)(TimeOfDay.Instance.totalTime * (float)TimeOfDay.Instance.quotaVariables.deadlineDaysAmount);
TimeOfDay.Instance.SyncTimeClientRpc(instance.globalTime, (int)instance.timeUntilDeadline);
((TMP_Text)StartOfRound.Instance.deadlineMonitorText).text = "DEADLINE:\n " + PouetHunterGame.TotalRounds.Value + " Days";
}
public static TerminalNode CreateTerminalNode(string message, bool clearPreviousText = true, int maxChar = 50)
{
TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
val.displayText = message;
val.clearPreviousText = clearPreviousText;
val.maxCharactersToType = maxChar;
return val;
}
}
internal class ScrapSpawningManager
{
private static readonly HashSet<string> blacklistedChoosenScraps = new HashSet<string> { "clown horn", "shotgun" };
public static void SpawnHunterEquipment(PlayerControllerB player, int shotgunAmount = 1, int ammoAmount = 2)
{
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
if (player == null || player.isPlayerDead)
{
return;
}
Vector3 spawnPosition = default(Vector3);
((Vector3)(ref spawnPosition))..ctor(4f, 5f, -14f);
List<ObjectToSpawn> list = new List<ObjectToSpawn>
{
new ObjectToSpawn(59, 1.15f, 0, shotgunAmount),
new ObjectToSpawn(60, 1f, 0, ammoAmount)
};
if (PouetHunterGame.SpawnBeltbagForHunters.Value)
{
list.Add(new ObjectToSpawn(79, 1.15f, 0, 1));
}
if (PouetHunterGame.SpawnMapperForHunters.Value && TimeOfDay.Instance.hour + 6 >= PouetHunterGame.EndingHour.Value - 2)
{
list.Add(new ObjectToSpawn(8, 1f, 0, 1));
}
foreach (ObjectToSpawn item in list)
{
SpawnObject(item, spawnPosition);
}
}
public static void SpawnPouetsEquipment()
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
Vector3 spawnPosition = default(Vector3);
((Vector3)(ref spawnPosition))..ctor(4f, 5f, -14f);
int amount = PouetHunterGame.players.Length;
SpawnObject(new ObjectToSpawn(25, 1f, 0, amount), spawnPosition);
if (PouetHunterGame.SpawnJetpack.Value)
{
SpawnObject(new ObjectToSpawn(4, 1.5f, 0, amount), spawnPosition);
}
}
public static void SpawnObject(ObjectToSpawn o, Vector3 spawnPosition)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < o.Amount; i++)
{
GameObject val = Object.Instantiate<GameObject>(StartOfRound.Instance.allItemsList.itemsList[o.Index].spawnPrefab, spawnPosition, Quaternion.identity);
ScanNodeProperties val2 = val.GetComponent<ScanNodeProperties>() ?? val.AddComponent<ScanNodeProperties>();
val2.scrapValue = o.Value;
val2.subText = $"Value: ${o.Value}";
GrabbableObject component = val.GetComponent<GrabbableObject>();
component.fallTime = 0f;
component.scrapValue = o.Value;
if (o.Weight != -1f)
{
component.itemProperties.weight = o.Weight;
}
component.itemProperties.creditsWorth = o.Value;
component.SetScrapValue(o.Value);
val.GetComponent<NetworkObject>().Spawn(false);
ManualLogSource logger = PouetHunterGame.Logger;
string itemName = val.gameObject.GetComponent<GrabbableObject>().itemProperties.itemName;
Vector3 val3 = spawnPosition;
logger.LogInfo((object)("Spawning scrap " + itemName + " at " + ((object)(Vector3)(ref val3)).ToString()));
}
}
public static void DespawnScrapsInShip(bool despawnEverything = true, string scrapName = "")
{
StartOfRound instance = StartOfRound.Instance;
object obj2;
if (instance == null)
{
obj2 = null;
}
else
{
Transform elevatorTransform = instance.elevatorTransform;
obj2 = ((elevatorTransform != null) ? ((Component)elevatorTransform).gameObject : null);
}
GameObject val = (GameObject)obj2;
if (val == null)
{
PouetHunterGame.Logger.LogError((object)"Ship not found");
return;
}
List<GrabbableObject> list = (from obj in val.GetComponentsInChildren<GrabbableObject>()
where !(obj is RagdollGrabbableObject) && !obj.isHeld
select obj).ToList();
foreach (GrabbableObject item in list)
{
if (despawnEverything || item.itemProperties.itemName.Equals(scrapName))
{
DespawnScraps(item);
}
}
}
public static void DespawnScraps(GrabbableObject scrapToDespawn)
{
NetworkObject component = ((Component)scrapToDespawn).gameObject.GetComponent<NetworkObject>();
if ((Object)(object)component != (Object)null && component.IsSpawned && !scrapToDespawn.isHeld)
{
PouetHunterGame.Logger.LogInfo((object)("Despawning scrap : " + scrapToDespawn.itemProperties.itemName));
Object.Destroy((Object)(object)((Component)scrapToDespawn).gameObject);
}
}
public static void DespawnAllScrapsRemaining()
{
List<GrabbableObject> list = (from obj in Object.FindObjectsOfType<GrabbableObject>()
where !(obj is RagdollGrabbableObject) && !obj.isHeld
select obj).ToList();
foreach (GrabbableObject item in list)
{
DespawnScraps(item);
}
}
public static void SpawnMapperForHunters()
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
foreach (PlayerControllerB item in PouetHunterGame.hunters.Where((PlayerControllerB x) => !x.isPlayerDead))
{
Vector3 position = ((Component)item).transform.position;
SpawnObject(new ObjectToSpawn(8, 1f, 0, 1), position);
PouetHunterGame.Logger.LogInfo((object)$"Spawning Mapper for {item.playerUsername} at {position}");
}
}
public static void SelectAndSpawnChosenScraps()
{
SelectChosenScrap();
SpawnChosenScrap();
PouetHunterGame.Logger.LogInfo((object)$"Spawning {PouetHunterGame.NbScraps.Value} {PouetHunterGame.scrapChosenName}");
}
public static void SelectChosenScrap()
{
HashSet<string> allScrapsInLevel = (from x in Object.FindObjectsOfType<GrabbableObject>()
where x.isInFactory && x.itemProperties.isScrap
select x.itemProperties.itemName.ToLower()).ToHashSet();
List<string> list = (from x in StartOfRound.Instance.allItemsList.itemsList
where !allScrapsInLevel.Contains(x.itemName.ToLower()) && x.isScrap && !IsBlacklistedScrap(x.itemName) && AllowTwoHanded(x)
select x.itemName).ToList();
PouetHunterGame.scrapChosenName = list[Random.Range(0, list.Count)];
}
public static void SpawnChosenScrap()
{
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Unknown result type (might be due to invalid IL or missing references)
//IL_0181: Unknown result type (might be due to invalid IL or missing references)
//IL_0186: Unknown result type (might be due to invalid IL or missing references)
//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
RoundManager instance = RoundManager.Instance;
Item val = ((IEnumerable<Item>)StartOfRound.Instance.allItemsList.itemsList).FirstOrDefault((Func<Item, bool>)((Item x) => x.itemName.Equals(PouetHunterGame.scrapChosenName, StringComparison.OrdinalIgnoreCase)));
if (val == null)
{
PouetHunterGame.Logger.LogError((object)(PouetHunterGame.scrapChosenName + " not found in itemsList"));
return;
}
List<RandomScrapSpawn> list = (from spawn in Object.FindObjectsOfType<RandomScrapSpawn>()
where !spawn.spawnUsed
select spawn).ToList();
Random anomalyRandom = instance.AnomalyRandom;
List<NetworkObjectReference> list2 = new List<NetworkObjectReference>();
List<int> list3 = new List<int>();
for (int i = 0; i < PouetHunterGame.NbScraps.Value; i++)
{
if (list.Count == 0)
{
PouetHunterGame.Logger.LogError((object)"No Spawnpoint available");
break;
}
RandomScrapSpawn val2 = list[anomalyRandom.Next(list.Count)];
list.Remove(val2);
val2.spawnUsed = true;
Vector3 val3 = (val2.spawnedItemsCopyPosition ? ((Component)val2).transform.position : (instance.GetRandomNavMeshPositionInBoxPredictable(((Component)val2).transform.position, val2.itemSpawnRange, instance.navHit, anomalyRandom, -1, 1f) + Vector3.up * val.verticalOffset));
GameObject val4 = Object.Instantiate<GameObject>(val.spawnPrefab, val3, Quaternion.identity, instance.spawnedScrapContainer);
GrabbableObject component = val4.GetComponent<GrabbableObject>();
((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
component.fallTime = 0f;
int item = (component.scrapValue = anomalyRandom.Next(val.minValue, val.maxValue));
NetworkObject component2 = val4.GetComponent<NetworkObject>();
component2.Spawn(false);
list2.Add(NetworkObjectReference.op_Implicit(component2));
list3.Add(item);
}
((MonoBehaviour)instance).StartCoroutine(WaitForChosenScrapsToSpawnToSync(list2.ToArray(), list3.ToArray()));
}
public static bool IsBlacklistedScrap(string scrapName)
{
return blacklistedChoosenScraps.Contains(scrapName.ToLower());
}
public static IEnumerator WaitForChosenScrapsToSpawnToSync(NetworkObjectReference[] spawnedScrap, int[] scrapValues)
{
yield return (object)new WaitForSeconds(11f);
RoundManager.Instance.SyncScrapValuesClientRpc(spawnedScrap, scrapValues);
}
public static bool AllowTwoHanded(Item item)
{
if (item == null)
{
return false;
}
return PouetHunterGame.CanChosenScrapBeTwoHanded.Value || item.twoHanded;
}
}
}
namespace PouetHunterGame.Patches
{
[HarmonyPatch(typeof(CentipedeAI))]
internal class CentipedeAIPatch
{
[HarmonyPatch("ClingToPlayer")]
[HarmonyPostfix]
public static void ClingToPlayer_Postfix(CentipedeAI __instance, PlayerControllerB playerScript)
{
__instance.StopClingingServerRpc(false);
}
}
[HarmonyPatch(typeof(EnemyAI))]
internal class EnemyAIPatch
{
[HarmonyPatch("SwitchToBehaviourState")]
[HarmonyPrefix]
public static bool SwitchToBehaviourState_Prefix(EnemyAI __instance, ref int stateIndex)
{
if (__instance is JesterAI && ((NetworkBehaviour)__instance).IsHost)
{
stateIndex = 0;
}
return true;
}
}
[HarmonyPatch(typeof(GameNetworkManager))]
internal class GameNetworkManagerPatch
{
[HarmonyPatch("SteamMatchmaking_OnLobbyCreated")]
[HarmonyPrefix]
public static void SteamMatchmaking_OnLobbyCreated_Prefix()
{
GameUtils.ResetGame();
}
}
[HarmonyPatch(typeof(GrabbableObject))]
internal class GrabbableObjectPatch
{
[HarmonyPatch("OnBroughtToShip")]
[HarmonyPostfix]
public static void OnBroughtToShip_Postfix(ref GrabbableObject __instance)
{
string itemName = __instance.itemProperties.itemName;
if (itemName == null || !itemName.Equals(PouetHunterGame.scrapChosenName, StringComparison.OrdinalIgnoreCase))
{
return;
}
if (PouetHunterGame.AlreadyCollectedScraps.Contains(__instance))
{
PouetHunterGame.Logger.LogError((object)"This Scrap has already been collected");
return;
}
PouetHunterGame.AlreadyCollectedScraps.Add(__instance);
PlayerControllerB playerHeldBy = __instance.playerHeldBy;
if (playerHeldBy == null)
{
PouetHunterGame.Logger.LogError((object)("Nobody is holding : " + __instance.itemProperties.itemName));
return;
}
if (!PouetHunterGame.hunters.Contains(playerHeldBy))
{
PouetHunterGame.hunters.Add(playerHeldBy);
PouetHunterGame.Logger.LogInfo((object)("Adding to hunters : " + playerHeldBy.playerUsername));
if (!PouetHunterGame.WinsAsHunter.ContainsKey(playerHeldBy.playerUsername))
{
PouetHunterGame.WinsAsHunter.Add(playerHeldBy.playerUsername, 1);
}
else
{
PouetHunterGame.WinsAsHunter[playerHeldBy.playerUsername]++;
}
if (PouetHunterGame.DisplayNewHunterName.Value)
{
HUDManager.Instance.UseSignalTranslatorServerRpc("H->" + playerHeldBy.playerUsername);
}
}
ScrapSpawningManager.SpawnHunterEquipment(playerHeldBy, PouetHunterGame.ShotgunAmount.Value, PouetHunterGame.AmmoAmount.Value);
}
}
[HarmonyPatch(typeof(HUDManager))]
internal class HUDManagerPatch
{
[HarmonyPatch("AddTextMessageClientRpc")]
[HarmonyPrefix]
public static bool AddTextMessageClientRpc_Prefix(string chatMessage)
{
if (chatMessage.Contains("was left behind") || chatMessage.Contains("joined the ship"))
{
return false;
}
return true;
}
[HarmonyPatch("AddPlayerChatMessageClientRpc")]
[HarmonyPrefix]
public static bool AddPlayerChatMessageClientRpc_Prefix(string chatMessage, int playerId)
{
Regex regex = new Regex("^/couleur (?<valeurCouleur>.+)$");
Match match = regex.Match(chatMessage);
if (match.Success)
{
string text = ColorManager.SetNewColorForPlayer(StartOfRound.Instance.allPlayerScripts[playerId], match.Groups["valeurCouleur"].Value);
PouetHunterGame.Logger.LogInfo((object)(StartOfRound.Instance.allPlayerScripts[playerId].playerUsername + " color is now : " + text));
return false;
}
return true;
}
[HarmonyPatch("ApplyPenalty")]
[HarmonyPrefix]
public static bool ApplyPenalty_Prefix(int playersDead, int bodiesInsured)
{
Terminal val = Object.FindFirstObjectByType<Terminal>();
if (val == null)
{
PouetHunterGame.Logger.LogError((object)"Terminal is null");
return false;
}
val.SyncGroupCreditsServerRpc(100000, 0);
PouetHunterGame.Logger.LogInfo((object)"Setting new group credits to 100 000");
return false;
}
}
[HarmonyPatch(typeof(MeteorShowers))]
internal class MeteorShowersPatch
{
[HarmonyPatch("BeginDay")]
[HarmonyPrefix]
public static bool BeginDay_Prefix(ref MeteorShowers __instance, float timeOfDay)
{
if (!((NetworkBehaviour)__instance).IsServer)
{
return false;
}
__instance.meteors.Clear();
HUDManager.Instance.MeteorShowerWarningHUD();
TimeOfDay.Instance.SetBeginMeteorShowerClientRpc();
__instance.meteorsEnabled = true;
return false;
}
[HarmonyPatch("Update")]
[HarmonyPrefix]
public static bool Update_Prefix(MeteorShowers __instance)
{
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Expected O, but got Unknown
if (!TimeOfDay.Instance.timeHasStarted || !StartOfRound.Instance.shipDoorsEnabled || !__instance.meteorsEnabled)
{
return false;
}
for (int i = 0; i < PouetHunterGame.players.Length; i++)
{
if (__instance.meteors.Count <= 3 && CanBeMeteorited(PouetHunterGame.players[i]))
{
Vector3 position = ((Component)PouetHunterGame.players[i]).transform.position;
Meteor item = new Meteor
{
scale = 10f,
landingPosition = position,
skyDirection = Vector3.up * 0.1f,
normalizedLandingTime = Mathf.Clamp(TimeOfDay.Instance.normalizedTimeOfDay, 0f, 0.99f)
};
__instance.meteors.Add(item);
PouetHunterGame.Logger.LogInfo((object)("Summoning Meteor on " + PouetHunterGame.players[i].playerUsername));
if (__instance.meteors.Count >= 4)
{
break;
}
}
}
foreach (Meteor meteor in __instance.meteors)
{
__instance.MeteorUpdate(meteor);
}
return false;
}
private static bool CanBeMeteorited(PlayerControllerB player)
{
return !player.isPlayerDead && !player.isInsideFactory && !PouetHunterGame.hunters.Contains(player) && !GameUtils.IsPlayerHolding(player, PouetHunterGame.scrapChosenName);
}
}
[HarmonyPatch(typeof(RoundManager))]
internal class RoundManagerPatch
{
[HarmonyPatch("SpawnMapObjects")]
[HarmonyPostfix]
public static void SpawnMapObjects_Postfix(RoundManager __instance)
{
GameUtils.ResetRound();
ScrapSpawningManager.SelectAndSpawnChosenScraps();
GameUtils.ClearChat();
GameUtils.DisplayBeginingRoundMessage();
ScrapSpawningManager.SpawnPouetsEquipment();
}
[HarmonyPatch("ShowStaticElectricityWarningServerRpc")]
[HarmonyPrefix]
public static bool ShowStaticElectricityWarningServerRpc_Prefix(NetworkObjectReference warningObject, float timeLeft)
{
return false;
}
[HarmonyPatch("LightningStrikeServerRpc")]
[HarmonyPrefix]
public static bool LightningStrikeServerRpc_Prefix(Vector3 strikePosition)
{
return false;
}
[HarmonyPatch("LoadNewLevel")]
[HarmonyPrefix]
public static bool LoadNewLevel_Prefix(ref SelectableLevel newLevel)
{
if (!PouetHunterGame.MonstersInside.Value)
{
foreach (SpawnableEnemyWithRarity enemy in newLevel.Enemies)
{
enemy.rarity = 0;
}
PouetHunterGame.Logger.LogInfo((object)"Entities Inside removed");
}
if (!PouetHunterGame.MonstersOutside.Value)
{
foreach (SpawnableEnemyWithRarity outsideEnemy in newLevel.OutsideEnemies)
{
outsideEnemy.rarity = 0;
}
PouetHunterGame.Logger.LogInfo((object)"Entities Outside removed");
}
return true;
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class StartOfRoundPatch
{
[HarmonyPatch("StartTrackingAllPlayerVoices")]
[HarmonyPostfix]
public static void StartTrackingAllPlayerVoices_Postfix()
{
if (!((NetworkBehaviour)StartOfRound.Instance.localPlayerController).IsHost)
{
return;
}
PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
PlayerControllerB[] array = allPlayerScripts;
foreach (PlayerControllerB val in array)
{
if (val.isPlayerControlled && !PouetHunterGame.welcomedPlayers.Contains(val.actualClientId))
{
PouetHunterGame.welcomedPlayers.Add(val.actualClientId);
string randomHexColor = ColorManager.GetRandomHexColor();
PouetHunterGame.playersColor.Add(val.playerUsername, randomHexColor);
string text = "<color=white>[</color><color=#D86ECC>Pouet</color><color=#FF0000>Hunter</color><color=#FFC000>Game</color><color=white>] Bienvenue à bord </color><color=" + randomHexColor + ">" + val.playerUsername + "</color><color=white>.</color>";
HUDManager.Instance.AddTextToChatOnServer(text, -1);
}
}
}
[HarmonyPatch("Start")]
[HarmonyPostfix]
public static void Start_Postfix()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
GameUtils.UnlockAllSuitsAndSignalTranslator();
GameUtils.HideShipObjectWithID(17, new Vector3(2f, -5f, -14f));
GameUtils.ChangeStartingDeadline(PouetHunterGame.TotalRounds.Value);
}
[HarmonyPatch("EndOfGame")]
[HarmonyPostfix]
public static void EndOfGame_Postfix(ref StartOfRound __instance, int bodiesInsured = 0, int connectedPlayersOnServer = 0, int scrapCollected = 0)
{
ScrapSpawningManager.DespawnAllScrapsRemaining();
GameUtils.DisplayScoreBoard();
}
[HarmonyPatch("Update")]
[HarmonyPostfix]
public static void Update_Postfix()
{
//IL_045a: Unknown result type (might be due to invalid IL or missing references)
PouetHunterGame.players = (from x in Object.FindObjectsOfType<PlayerControllerB>()
where x.isPlayerControlled || x.isPlayerDead
select x).ToArray();
if (GameOverManager.IsGameOver() && !PouetHunterGame.GameAlreadyOver)
{
GameUtils.ClearChat();
HUDManager.Instance.AddTextToChatOnServer("<color=white>[</color><color=#FFC000>Manche Terminée</color><color=white>]</color>", -1);
PouetHunterGame.GameAlreadyOver = true;
StringBuilder stringBuilder = new StringBuilder();
if (StartOfRound.Instance.allPlayersDead)
{
stringBuilder.Append("<color=#FF0000>Pas de gagnant !</color>");
}
else
{
TimeOfDay.Instance.SetShipLeaveEarlyClientRpc(TimeOfDay.Instance.normalizedTimeOfDay, 4);
if (PouetHunterGame.HuntersWon)
{
stringBuilder.Append("<color=white>Victoire des </color><color=#FF0000>Hunters</color><color=white>:</color>\n");
foreach (PlayerControllerB hunter in PouetHunterGame.hunters)
{
stringBuilder.Append("<color=" + ColorManager.GetPlayerColor(hunter) + ">" + hunter.playerUsername + "</color>\n");
if (!hunter.isPlayerDead)
{
if (!PouetHunterGame.WinsAsHunter.ContainsKey(hunter.playerUsername))
{
PouetHunterGame.WinsAsHunter.Add(hunter.playerUsername, 1);
}
else
{
PouetHunterGame.WinsAsHunter[hunter.playerUsername]++;
}
}
}
}
else
{
stringBuilder.Append("<color=white>Victoire des </color><color=#D86ECC>Pouets</color><color=white>:\n");
foreach (PlayerControllerB item in PouetHunterGame.players.Where((PlayerControllerB x) => !x.isPlayerDead))
{
if (!PouetHunterGame.hunters.Contains(item))
{
stringBuilder.Append("<color=" + ColorManager.GetPlayerColor(item) + ">" + item.playerUsername + "</color>\n");
if (!PouetHunterGame.WinsAsPouet.ContainsKey(item.playerUsername))
{
PouetHunterGame.WinsAsPouet.Add(item.playerUsername, 1);
}
else
{
PouetHunterGame.WinsAsPouet[item.playerUsername]++;
}
}
}
}
}
if (!PouetHunterGame.HuntersWon && PouetHunterGame.hunters.Count > 0)
{
stringBuilder.Append("<color=white>[</color><color=#FF0000>Hunters</color><color=white>]</color>\n");
foreach (PlayerControllerB hunter2 in PouetHunterGame.hunters)
{
stringBuilder.Append("<color=" + ColorManager.GetPlayerColor(hunter2) + ">" + hunter2.playerUsername + "</color>\n");
}
}
HUDManager.Instance.AddTextToChatOnServer(stringBuilder.ToString(), -1);
((MonoBehaviour)StartOfRound.Instance).StartCoroutine(GameOverManager.KillRemainingPlayerWithDelay());
}
if (!TimeOfDay.Instance.timeHasStarted || TimeOfDay.Instance.hour < GameUtils.GetValidHour(PouetHunterGame.StartingHour.Value, 9, 23))
{
return;
}
foreach (PlayerControllerB item2 in PouetHunterGame.players.Where((PlayerControllerB x) => !x.isPlayerDead))
{
if (!PouetHunterGame.hunters.Contains(item2) && item2.isInsideFactory && !GameUtils.IsPlayerHolding(item2, "Clown horn"))
{
PouetHunterGame.Logger.LogInfo((object)("Trying to kill " + item2.playerUsername + " ID : " + item2.actualClientId));
item2.DamagePlayerFromOtherClientServerRpc(200, Vector3.zero, 0);
}
}
}
[HarmonyPatch("OnClientDisconnect")]
[HarmonyPrefix]
public static void OnClientDisconnect_Prefix(ulong clientId)
{
PouetHunterGame.welcomedPlayers.Remove(clientId);
string text = StartOfRound.Instance.allPlayerScripts.Where((PlayerControllerB x) => x.actualClientId.Equals(clientId)).First()?.playerUsername;
if (text != null)
{
PouetHunterGame.playersColor.Remove(text);
}
}
[HarmonyPatch("EndGameServerRpc")]
[HarmonyPrefix]
public static bool EndGameServerRpc_Prefix(int playerClientId)
{
return false;
}
[HarmonyPatch("BuyShipUnlockableServerRpc")]
[HarmonyPrefix]
public static bool BuyShipUnlockableServerRpc_Prefix(int unlockableID, int newGroupCreditsAmount)
{
if (unlockableID == 5)
{
return false;
}
return true;
}
[HarmonyPatch("ResetShip")]
[HarmonyPostfix]
public static void ResetShip_Postfix()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
GameUtils.UnlockAllSuitsAndSignalTranslator();
GameUtils.HideShipObjectWithID(17, new Vector3(2f, -5f, -14f));
GameUtils.ClearChat();
GameOverManager.DisplaysWinners();
GameUtils.ResetGame(resetWelcomePlayer: false);
Terminal val = Object.FindObjectOfType<Terminal>();
if (val == null)
{
PouetHunterGame.Logger.LogError((object)"Terminal not found");
return;
}
val.SyncGroupCreditsServerRpc(100000, 0);
PouetHunterGame.Logger.LogInfo((object)"Setting new group credits to 100 000");
TimeOfDay.Instance.SyncTimeClientRpc(TimeOfDay.Instance.globalTime, (int)TimeOfDay.Instance.timeUntilDeadline);
}
}
[HarmonyPatch(typeof(Terminal))]
internal class TerminalPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
public static void Start_Postfix(Terminal __instance, ref TerminalNodesList ___terminalNodes)
{
__instance.SyncGroupCreditsServerRpc(100000, 0);
PouetHunterGame.Logger.LogInfo((object)"Setting new group credits to 100 000");
int index = 1;
string displayText = ___terminalNodes.specialNodes[index].displayText;
string displayText2 = (displayText += "\n[PouetHunterGame]\nEntrez \"phg <nombre>\" pour changer le nombre de manche et recommencer la partie\nEntrez \"phg fin\" pour terminer la partie prématurément\n");
___terminalNodes.specialNodes[index].displayText = displayText2;
}
[HarmonyPatch("ParsePlayerSentence")]
[HarmonyPrefix]
[HarmonyPriority(800)]
private static bool ParsePlayerSentencePatch(Terminal __instance, ref TerminalNode __result)
{
string text = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded);
if (text.Contains("phg fin"))
{
StartOfRound.Instance.ResetShip();
__result = GameUtils.CreateTerminalNode("La partie a été réinitialisée \ud83d\ude01");
return false;
}
Match match = Regex.Match(text, "phg\\s+(-?\\d+)", RegexOptions.IgnoreCase);
if (match.Success)
{
int num = int.Parse(match.Groups[1].Value);
if (num < 1 || num > 10)
{
__result = GameUtils.CreateTerminalNode($"{num} n'est pas une valeur valide.\nVeuillez saisir une valeur entre 1 et 10");
return false;
}
PouetHunterGame.TotalRounds.Value = num;
GameUtils.ChangeStartingDeadline(PouetHunterGame.TotalRounds.Value);
StartOfRound.Instance.ResetShip();
__result = GameUtils.CreateTerminalNode($"Nombre de manche : {PouetHunterGame.TotalRounds.Value}\nPartie réinitialisée !");
return false;
}
return true;
}
}
[HarmonyPatch(typeof(TimeOfDay))]
internal class TimeOfDayPatch
{
[HarmonyPatch("DecideRandomDayEvents")]
[HarmonyPrefix]
public static bool DecideRandomDayEvents_Prefix()
{
return false;
}
[HarmonyPatch("MoveTimeOfDay")]
[HarmonyPostfix]
public static void MoveTimeOfDay_Postfix(TimeOfDay __instance)
{
if (__instance.hour >= GameUtils.GetValidHour(PouetHunterGame.StartingHour.Value, 9, 23) && !__instance.MeteorWeather.meteorsEnabled)
{
__instance.MeteorWeather.SetStartMeteorShower();
GameUtils.UnlockAllDoors();
}
}
[HarmonyPatch("SetShipLeaveEarlyServerRpc")]
[HarmonyPrefix]
public static bool SetShipLeaveEarlyServerRpc_Prefix()
{
return false;
}
[HarmonyPatch("OnHourChanged")]
[HarmonyPrefix]
public static void OnHourChanged_Prefix(TimeOfDay __instance)
{
int num = __instance.hour + 6;
if (num > 8 && num < PouetHunterGame.EndingHour.Value && num % 4 == 0)
{
HUDManager.Instance.UseSignalTranslatorServerRpc($"{num} Heures");
}
if (PouetHunterGame.SpawnMapperForHunters.Value && num == PouetHunterGame.EndingHour.Value - 2)
{
ScrapSpawningManager.SpawnMapperForHunters();
HUDManager.Instance.UseSignalTranslatorServerRpc("H->Mapper");
}
}
[HarmonyPatch("OnDayChanged")]
[HarmonyPostfix]
public static void OnDayChanged_Postfix(TimeOfDay __instance)
{
PouetHunterGame.numRound++;
if (__instance.daysUntilDeadline == 0)
{
if (((NetworkBehaviour)__instance).IsServer)
{
GameNetworkManager.Instance.ResetSavedGameValues();
}
StartOfRound.Instance.ResetShip();
}
}
}
}
namespace PouetHunterGame.Object
{
internal class CouleursToHEX
{
public static readonly Dictionary<string, string> CouleursHEX = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "rouge", "#FF0000" },
{ "vert", "#00FF00" },
{ "bleu", "#0000FF" },
{ "blanc", "#FFFFFF" },
{ "noir", "#000000" },
{ "jaune", "#FFFF00" },
{ "cyan", "#00FFFF" },
{ "magenta", "#FF00FF" },
{ "gris", "#808080" },
{ "orange", "#FFA500" },
{ "rose", "#FFC0CB" },
{ "violet", "#800080" },
{ "marron", "#A52A2A" },
{ "turquoise", "#40E0D0" },
{ "beige", "#F5F5DC" },
{ "bordeaux", "#800000" },
{ "lavande", "#E6E6FA" },
{ "ivoire", "#FFFFF0" },
{ "sable", "#F4A460" },
{ "menthe", "#98FF98" },
{ "pêche", "#FFDAB9" },
{ "prune", "#DDA0DD" },
{ "corail", "#FF7F50" },
{ "indigo", "#4B0082" },
{ "chocolat", "#D2691E" },
{ "ardoise", "#708090" },
{ "abricot", "#FBCEB1" },
{ "aigue-marine", "#7FFFD4" },
{ "améthyste", "#9966CC" },
{ "anthracite", "#293133" },
{ "azur", "#007FFF" },
{ "bleu ciel", "#87CEEB" },
{ "bleu roi", "#002366" },
{ "carmin", "#960018" },
{ "cerise", "#DE3163" },
{ "chartreuse", "#7FFF00" },
{ "cuivre", "#B87333" },
{ "émeraude", "#50C878" },
{ "framboise", "#E30B5C" },
{ "fuchsia", "#FF00FF" },
{ "jade", "#00A86B" },
{ "kaki", "#F0E68C" },
{ "lavande foncée", "#734F96" },
{ "lime", "#BFFF00" },
{ "lin", "#FAF0E6" },
{ "marine", "#000080" },
{ "moutarde", "#FFDB58" },
{ "nacré", "#FDFD96" },
{ "ocre", "#CC7722" },
{ "olive", "#808000" },
{ "or", "#FFD700" },
{ "perle", "#EAE0C8" },
{ "rose bonbon", "#FF69B4" },
{ "rouille", "#B7410E" },
{ "safran", "#F4C430" },
{ "saphir", "#0F52BA" },
{ "saumon", "#FA8072" },
{ "sépia", "#704214" },
{ "tomate", "#FF6347" },
{ "vert forêt", "#228B22" },
{ "vert pomme", "#8DB600" },
{ "vert sapin", "#014421" },
{ "violacé", "#6A5ACD" }
};
}
internal class ObjectToSpawn
{
public int Index { get; set; }
public float Weight { get; set; }
public int Value { get; set; }
public int Amount { get; set; }
public ObjectToSpawn(int index, float weight, int value, int amount)
{
Index = index;
Weight = weight;
Value = value;
Amount = amount;
}
}
}
