Replacer/Plugin.cs at main · Augaton/Replacer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
using System;
using Exiled.API.Features;
using Replacer.API;
using AugatonLib.Arbitration;
using AugatonLib.Runtime;
using Replacer.Handlers;
using PlayerEvents = Exiled.Events.Handlers.Player;
using ServerEvents = Exiled.Events.Handlers.Server;

namespace Replacer
{
    public sealed class Plugin : Plugin<Config, Translation>
    {
        public override string Name => "Replacer";

        public override string Author => "Zone-Shilari (base: DGvagabond)";

        public override string Prefix => "replacer";

        public override Version Version => new Version(2, 0, 0);

        public override Version RequiredExiledVersion => new Version(9, 14, 2);

        public const string DepartureOwner = "Replacer";

        public static Plugin Instance { get; private set; }

        private SpectatorQueue queue;
        private PlayerHandlers playerHandlers;

        public override void OnEnabled()
        {
            Instance = this;

            ValidateConfig();

            API.HintBridge.YCoordinate = Config.HintYCoordinate;
            API.HintBridge.FontSize = Config.HintFontSize;

            queue = new SpectatorQueue();
            playerHandlers = new PlayerHandlers(this, queue);

            PlayerEvents.Left += playerHandlers.OnLeft;
            PlayerEvents.ChangingRole += playerHandlers.OnChangingRole;

            ServerEvents.RoundStarted += OnRoundStarted;
            ServerEvents.RoundEnded += OnRoundEnded;
            ServerEvents.RestartingRound += OnRestartingRound;

            DepartureArbiter.Declare(DepartureOwner, 50, player => player is not null);

            PluginDirectory.Register(
                this,
                Capability.Hints,
                Capability.Departure,
                Capability.Bus);

            base.OnEnabled();
        }

        public override void OnDisabled()
        {
            PlayerEvents.Left -= playerHandlers.OnLeft;
            PlayerEvents.ChangingRole -= playerHandlers.OnChangingRole;

            ServerEvents.RoundStarted -= OnRoundStarted;
            ServerEvents.RoundEnded -= OnRoundEnded;
            ServerEvents.RestartingRound -= OnRestartingRound;

            queue?.Clear();
            API.HintBridge.Clear();

            DepartureArbiter.Withdraw(DepartureOwner);
            PluginDirectory.Unregister(this);

            playerHandlers = null;
            queue = null;
            Instance = null;

            base.OnDisabled();
        }

        private void ValidateConfig()
        {
            if (Config.ReplacementDelay < 0f)
            {
                Log.Warn($"ReplacementDelay ({Config.ReplacementDelay}) est negatif, remis a 0.4.");
                Config.ReplacementDelay = 0.4f;
            }

            if (Config.MinimumPlayers < 1)
            {
                Log.Warn($"MinimumPlayers ({Config.MinimumPlayers}) est invalide, remis a 1.");
                Config.MinimumPlayers = 1;
            }

            if (Config.PerPlayerCooldownSeconds < 0f)
            {
                Log.Warn($"PerPlayerCooldownSeconds ({Config.PerPlayerCooldownSeconds}) est negatif, remis a 0.");
                Config.PerPlayerCooldownSeconds = 0f;
            }
        }

        private void OnRoundStarted()
        {
            queue.Clear();
            API.HintBridge.Clear();
        }

        private void OnRoundEnded(Exiled.Events.EventArgs.Server.RoundEndedEventArgs ev) => queue.Clear();

        private void OnRestartingRound() => queue.Clear();
    }
}