SecretPluginLaboratories/GamblingCoin/GamblingCoinEventHandler.cs

using System.Numerics;
using LabApi.Events.Arguments.PlayerEvents;
using LabApi.Features.Wrappers;
using MapGeneration;
using Mirror;
using PlayerRoles;
using Respawning.Waves;
using Utils;
using Logger = LabApi.Features.Console.Logger;
using Random = UnityEngine.Random;

namespace GamblingCoin
{
    public class GamblingCoinEventHandler
    {
        private readonly WeightedRandomExecutor<PlayerFlippedCoinEventArgs> _executor;

        public GamblingCoinEventHandler()
        {
            var configMessages = Plugin.Singleton.ConfigMessages;
            var configGameplay = Plugin.Singleton.ConfigGameplay;
            var configChances = Plugin.Singleton.ConfigChances;

            _executor = new WeightedRandomExecutor<PlayerFlippedCoinEventArgs>();

            _executor
                .AddAction(_ =>
                {
                    Warhead.DetonationTime += configGameplay.WarheadTimeIncrease;
                    Warhead.Start(suppressSubtitles: true);
                }, configChances.NukeChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.SpawnWaveMessage, configGameplay.BroadcastDuration);
                    
                    if(GetPlayers().Any(player=>player.Role == RoleTypeId.Spectator)) {
                        Respawning.WaveManager.InitiateRespawn(Respawning.WaveManager.Waves[Random.Range(0, Respawning.WaveManager.Waves.Count)]);
                    }
                }, configChances.SpawnWaveChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.ItemSpawnMessage, configGameplay.BroadcastDuration);
                    SpawnRandomItemAtPlayer(x.Player, configGameplay.Items.CommonItems);
                }, configChances.CommonItemChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.UncommonItemSpawnMessage, configGameplay.BroadcastDuration);
                    SpawnRandomItemAtPlayer(x.Player, configGameplay.Items.UncommonItems);
                }, configChances.UncommonItemChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.RareItemSpawnMessage, configGameplay.BroadcastDuration);
                    SpawnRandomItemAtPlayer(x.Player, configGameplay.Items.RareItems);
                }, configChances.RareItemChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.EpicItemSpawnMessage, configGameplay.BroadcastDuration);
                    SpawnRandomItemAtPlayer(x.Player, configGameplay.Items.EpicItems);
                }, configChances.EpicItemChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.LegendaryItemSpawnMessage, configGameplay.BroadcastDuration);
                    SpawnRandomItemAtPlayer(x.Player, configGameplay.Items.LegendaryItems);
                }, configChances.LegendaryItemChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.RandomTeleportMessage, configGameplay.BroadcastDuration);
                    
                    var randomRoom = Map.GetRandomRoom();
                    if (randomRoom == null) return;
                    
                    var newPos = randomRoom.Position;

                    x.Player.Position = newPos + new UnityEngine.Vector3(0, configGameplay.TeleportHeightOffset, 0);;
                }, configChances.RandomTeleportChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.StealItemMessage, configGameplay.BroadcastDuration);

                    if (x.Player.CurrentItem != null) x.Player.DropItem(x.Player.CurrentItem);
                }, configChances.StealItemChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.ExplosionMessage, configGameplay.BroadcastDuration);

                    x.Player.ClearInventory();
                    
                    ExplosionUtils.ServerExplode(x.Player.ReferenceHub, ExplosionType.Custom);
                }, configChances.ExplosionChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.AntiMicroMessage, configGameplay.BroadcastDuration);
                    GetPlayers().ForEach(p => { p.RemoveItem(ItemType.MicroHID, configGameplay.MaxMicrosToRemove); });
                    //TODO: remove *all* micros
                }, configChances.AntiMicroChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.GrenadeMessage, configGameplay.BroadcastDuration);

                    var grenade = (TimedGrenadeProjectile)Pickup.Create(ItemType.GrenadeHE, x.Player.Position);
                    grenade?.Spawn();
                    grenade?.FuseEnd();
                }, configChances.GrenadeChance)
                .AddAction(x =>
                    {
                        x.Player.SendBroadcast(configMessages.PocketDimensionMessage, configGameplay.BroadcastDuration);
                        
                        var newPos = Map.Rooms.First(roomIdentifier => roomIdentifier.Zone==FacilityZone.Other).Position;

                        x.Player.Position = newPos + new UnityEngine.Vector3(0, configGameplay.TeleportHeightOffset, 0);
                    },
                    configChances.PocketDimensionChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.AdvancedPositiveEffectMessage, configGameplay.BroadcastDuration);
                    ApplyRandomEffect(x.Player, configGameplay.Effects.AdvancedPositive);
                }, configChances.AdvancedPositiveEffectChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.PositiveEffectMessage, configGameplay.BroadcastDuration);
                    ApplyRandomEffect(x.Player, configGameplay.Effects.Positive);
                }, configChances.PositiveEffectChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.NegativeEffectMessage, configGameplay.BroadcastDuration);
                    ApplyRandomEffect(x.Player, configGameplay.Effects.Negative);
                }, configChances.NegativeEffectChance)
                .AddAction(x =>
                {
                    x.Player.SendBroadcast(configMessages.AdvancedNegativeEffectMessage, configGameplay.BroadcastDuration);
                    ApplyRandomEffect(x.Player, configGameplay.Effects.AdvancedNegative);
                }, configChances.AdvancedNegativeEffectChance)
                .AddAction(x =>
                {
                    var players = GetPlayers();
                    
                    var randomPlayer = players[Random.Range(0,GetPlayers().Length)];
                    
                    while(randomPlayer.RoleBase.Team is Team.Dead or Team.SCPs) randomPlayer = players[Random.Range(0,GetPlayers().Length)];
                    
                    x.Player.SendBroadcast(configMessages.SwitchInventoryMessage, configGameplay.BroadcastDuration);
                    randomPlayer.SendBroadcast(configMessages.SwitchInventoryMessage, configGameplay.BroadcastDuration);

                    var randomPlayerItems = new List<Item>();
                    randomPlayer.Items.CopyTo(randomPlayerItems);
                    var items = x.Player.Items;
                    
                    randomPlayer.ClearInventory();
                    foreach (var itemBase in items)
                    {
                        randomPlayer.AddItem(itemBase.Type);
                    }
                    
                    x.Player.ClearInventory();
                    foreach (var randomPlayerItem in randomPlayerItems)
                    {
                        x.Player.AddItem(randomPlayerItem.Type);
                    }
                }, configChances.SwitchInventoryChance);
            
            return;

            void ApplyRandomEffect(Player player, AdvancedEffectSettings settings)
            {
                var effectChosen = settings.Effects[Random.Range(0, settings.Effects.Length)];
                var effectSettings = settings.Settings[effectChosen];

                player.ReferenceHub.playerEffectsController.ChangeState(effectChosen, effectSettings.Intensity, effectSettings.Duration, effectSettings.AddDuration);
            }

            void SpawnItemAtPlayer(Player player, ItemType item)
            {
                var pickup = Pickup.Create(item, player.Position + new UnityEngine.Vector3(0,1,0));
                if (pickup == null) return;
                
                pickup.Spawn();
            }

            void SpawnRandomItemAtPlayer(Player player, ItemType[] items)
            {
                var itemIndex = Random.Range(0, items.Length);
                SpawnItemAtPlayer(player, items[itemIndex]);
            }

            Player[] GetPlayers()
            {
                return Player.Dictionary.Values.ToArray();
            }
        }

        public void OnFlippedCoin(PlayerFlippedCoinEventArgs ev)
        {
            _executor.Execute(ev);
        }
    }
}