using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.SceneManagement;
using Zorro.Core;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyCompany("Nozz")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2025 Nozz")]
[assembly: AssemblyFileVersion("1.0.1")]
[assembly: AssemblyInformationalVersion("1.0.0+59d4a8b787174ab463b664773ed5400e5a5746f5")]
[assembly: AssemblyProduct("BagsForEveryone")]
[assembly: AssemblyTitle("BagsForEveryone")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace BagsForEveryone
{
[BepInPlugin("com.nozz.bagsforeveryone", "BagsForEveryone", "1.1.0")]
public class BagsForEveryonePlugin : BaseUnityPlugin
{
private ConfigEntry<bool> _modEnabled;
private HashSet<int> _playersWithBags = new HashSet<int>();
private bool _gameStarted;
private const int BAG_AMOUNT = 1;
private const float SPAWN_DELAY = 2f;
public static BagsForEveryonePlugin Instance { get; private set; }
internal static ManualLogSource Logger { get; private set; }
private void Awake()
{
Instance = this;
Logger = ((BaseUnityPlugin)this).Logger;
_modEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ModEnabled", true, "Enable or disable automatic backpack spawning");
Logger.LogInfo((object)"Plugin com.nozz.bagsforeveryone loaded successfully!");
Logger.LogInfo((object)"Minimalist automatic backpack spawning system initialized");
}
private void Start()
{
SceneManager.sceneLoaded += OnSceneLoaded;
((MonoBehaviour)this).StartCoroutine(MonitorGameState());
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
_gameStarted = false;
_playersWithBags.Clear();
Logger.LogInfo((object)("Scene changed to: " + ((Scene)(ref scene)).name + " - mod state reset"));
}
private IEnumerator MonitorGameState()
{
while (true)
{
if (!_modEnabled.Value)
{
yield return (object)new WaitForSeconds(1f);
continue;
}
if (!IsInValidGameLevel())
{
yield return (object)new WaitForSeconds(1f);
continue;
}
if (PhotonNetwork.IsConnected && PhotonNetwork.InRoom)
{
if (!_gameStarted)
{
_gameStarted = true;
ManualLogSource logger = Logger;
Scene activeScene = SceneManager.GetActiveScene();
logger.LogInfo((object)("Game started in level: " + ((Scene)(ref activeScene)).name + " - spawning backpacks"));
yield return (object)new WaitForSeconds(2f);
SpawnBagsForAllPlayers();
}
else
{
CheckForNewPlayers();
}
}
else if (_gameStarted)
{
_gameStarted = false;
_playersWithBags.Clear();
Logger.LogInfo((object)"Game session ended - resetting bag tracking");
}
yield return (object)new WaitForSeconds(1f);
}
}
private bool IsInValidGameLevel()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
return ((Scene)(ref activeScene)).name.StartsWith("Level_");
}
private void CheckForNewPlayers()
{
Player[] playerList = PhotonNetwork.PlayerList;
foreach (Player val in playerList)
{
if (!_playersWithBags.Contains(val.ActorNumber))
{
Logger.LogInfo((object)("New player detected: " + val.NickName + " - spawning backpack"));
((MonoBehaviour)this).StartCoroutine(SpawnBagsForPlayer(val));
}
}
}
private void SpawnBagsForAllPlayers()
{
if (!PhotonNetwork.IsConnected || !PhotonNetwork.IsMasterClient)
{
return;
}
Logger.LogInfo((object)"Automatically spawning backpacks for all players...");
Player[] playerList = PhotonNetwork.PlayerList;
foreach (Player val in playerList)
{
if (!_playersWithBags.Contains(val.ActorNumber))
{
((MonoBehaviour)this).StartCoroutine(SpawnBagsForPlayer(val));
}
}
}
private IEnumerator SpawnBagsForPlayer(Player player)
{
SpawnBagForPlayer(player);
yield return (object)new WaitForSeconds(0.1f);
_playersWithBags.Add(player.ActorNumber);
}
private void SpawnBagForPlayer(Player player)
{
try
{
Character playerCharacter = GetPlayerCharacter(player);
if ((Object)(object)playerCharacter == (Object)null)
{
return;
}
Player playerComponent = GetPlayerComponent(player);
if (!((Object)(object)playerComponent == (Object)null))
{
if (playerComponent.backpackSlot.hasBackpack)
{
Logger.LogInfo((object)("Player " + player.NickName + " already has a backpack, skipping"));
return;
}
if (TryGiveBackpackToPlayer(playerComponent))
{
Logger.LogInfo((object)("Backpack given to player: " + player.NickName));
return;
}
SpawnBackpackNearPlayer(playerCharacter);
Logger.LogInfo((object)("Backpack spawned near player: " + player.NickName));
}
}
catch (Exception ex)
{
Logger.LogError((object)("Error spawning backpack for " + player.NickName + ": " + ex.Message));
}
}
private Character GetPlayerCharacter(Player player)
{
foreach (Character allCharacter in Character.AllCharacters)
{
if ((Object)(object)allCharacter != (Object)null && ((MonoBehaviourPun)allCharacter).photonView.Owner == player)
{
return allCharacter;
}
}
return null;
}
private Player GetPlayerComponent(Player photonPlayer)
{
Player[] array = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
foreach (Player val in array)
{
if (((MonoBehaviourPun)val).photonView.Owner == photonPlayer)
{
return val;
}
}
return null;
}
private bool TryGiveBackpackToPlayer(Player player)
{
try
{
ushort num = FindBackpackItemID();
if (num == 0)
{
return false;
}
ItemSlot val = default(ItemSlot);
return player.AddItem(num, (ItemInstanceData)null, ref val) && val is BackpackSlot;
}
catch (Exception ex)
{
Logger.LogError((object)("Error giving backpack to player: " + ex.Message));
return false;
}
}
private ushort FindBackpackItemID()
{
try
{
ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
if (instance?.itemLookup != null)
{
foreach (KeyValuePair<ushort, Item> item in instance.itemLookup)
{
if (item.Value is Backpack)
{
return item.Key;
}
}
}
Backpack[] array = Object.FindObjectsByType<Backpack>((FindObjectsInactive)1, (FindObjectsSortMode)0);
if (array.Length != 0)
{
return ((Item)array[0]).itemID;
}
return 0;
}
catch (Exception ex)
{
Logger.LogError((object)("Error finding backpack item ID: " + ex.Message));
return 0;
}
}
private void SpawnBackpackNearPlayer(Character character)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: 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_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
try
{
Vector3 val = character.Center + Vector3.up * 1f + Random.insideUnitSphere * 1.5f;
val.y = Mathf.Max(val.y, character.Center.y);
string text = FindBackpackPrefabName();
if (!string.IsNullOrEmpty(text))
{
PhotonNetwork.InstantiateItemRoom(text, val, Quaternion.identity);
}
}
catch (Exception ex)
{
Logger.LogError((object)("Error spawning backpack near player: " + ex.Message));
}
}
private string FindBackpackPrefabName()
{
try
{
ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
if (instance?.itemLookup != null)
{
foreach (KeyValuePair<ushort, Item> item in instance.itemLookup)
{
if (item.Value is Backpack)
{
return ((Object)((Component)item.Value).gameObject).name;
}
}
}
Backpack[] array = Object.FindObjectsByType<Backpack>((FindObjectsInactive)1, (FindObjectsSortMode)0);
if (array.Length != 0)
{
return ((Object)((Component)array[0]).gameObject).name;
}
return null;
}
catch (Exception ex)
{
Logger.LogError((object)("Error finding backpack prefab name: " + ex.Message));
return null;
}
}
private void OnDestroy()
{
SceneManager.sceneLoaded -= OnSceneLoaded;
_playersWithBags.Clear();
}
}
[GeneratedCode("BepInEx.PluginInfoProps", "1.0.0.0")]
[EditorBrowsable(EditorBrowsableState.Never)]
internal static class MyPluginInfo
{
public const string PLUGIN_GUID = "com.nozz.bagsforeveryone";
public const string PLUGIN_NAME = "BagsForEveryone";
public const string PLUGIN_VERSION = "1.1.0";
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "com.nozz.bagsforeveryone";
public const string PLUGIN_NAME = "BagsForEveryone";
public const string PLUGIN_VERSION = "1.0.1";
}
}
