Causality-0/Causality0.cs at master · CnCSharp-Dev/Causality-0 · 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 Causality0.Event.PlayerEvent;
using Causality0.Event.ServerEvent;
using LabApi.Events.Arguments.ServerEvents;
using LabApi.Events.Handlers;
using LabApi.Features;
using LabApi.Loader.Features.Plugins;

namespace Causality0;

public sealed class Causality0 : Plugin<Causality0Config>
{
    public static Causality0 Instance { get; private set; }

    public MapGenerating ServerEvent { get; } = new();

    public Pickups PickupEvent { get; } = new();

    public Verified VerifiedEvent { get; } = new();

    public Shooting ShootingEvent { get; } = new();

    public Reloading ReloadingEvent { get; } = new();

    public Using UsingEvent { get; } = new();

    public global::Causality0.Event.PlayerEvent.VoiceChat VoiceChatEvent { get; } = new();

    public Throwing ThrowingEvent { get; } = new();

    public Interacting InteractingEvent { get; } = new();

    public Lifecycle LifecycleEvent { get; } = new();

    public override string Name { get; } = "Causality-0";

    public override string Description { get; } = "Seed override and dummy injection core.";

    public override string Author { get; } = "MiaoMiao";

    public override Version Version { get; } = new(1, 0, 2);

    public override Version RequiredApiVersion { get; } = new(LabApiProperties.CompiledVersion);

    public override void Enable()
    {
        Instance = this;
        int fps = Config?.DefaultRecordFps ?? 60;
        if (fps < 1)
        {
            fps = 1;
        }
        else if (fps > 240)
        {
            fps = 240;
        }

        Core.Timeline.CurrentFps = fps;
        ServerEvents.WaitingForPlayers += OnWaitingForPlayers;
        ServerEvents.RoundRestarted += OnRoundRestarted;
        ServerEvents.RoundEnded += OnRoundEnded;
        ServerEvent.Enable();
        PickupEvent.Enable();
        VerifiedEvent.Enable();
        ShootingEvent.Enable();
        ReloadingEvent.Enable();
        UsingEvent.Enable();
        VoiceChatEvent.Enable();
        ThrowingEvent.Enable();
        InteractingEvent.Enable();
        LifecycleEvent.Enable();
    }

    public override void Disable()
    {
        Core.Timeline.StopPlay();
        Core.Timeline.CleanupReplayWorld();
        LifecycleEvent.Disable();
        InteractingEvent.Disable();
        ThrowingEvent.Disable();
        VoiceChatEvent.Disable();
        UsingEvent.Disable();
        ReloadingEvent.Disable();
        ShootingEvent.Disable();
        VerifiedEvent.Disable();
        PickupEvent.Disable();
        ServerEvent.Disable();
        ServerEvents.RoundEnded -= OnRoundEnded;
        ServerEvents.RoundRestarted -= OnRoundRestarted;
        ServerEvents.WaitingForPlayers -= OnWaitingForPlayers;
        if (ReferenceEquals(Instance, this))
        {
            Instance = null;
        }
    }

    private void OnWaitingForPlayers()
    {
        Core.Timeline.StopPlay();
        Core.Timeline.CleanupReplayWorld();
    }

    private void OnRoundRestarted()
    {
        Core.Timeline.StopPlay();
        Core.Timeline.CleanupReplayWorld();
    }

    private void OnRoundEnded(RoundEndedEventArgs ev)
    {
        Core.Timeline.StopPlay();
        Core.Timeline.CleanupReplayWorld();
    }
}