OneNightDuel/ONDClient/Net/EventProcessor.cs

using System;
using System.Collections.Generic;
using System.Linq;
using GlobalClassLib;
using ONDClient.Enemies;
using ONDClient.GUI;
using ONDClient.Map;
using ONDClient.Sound;
using PacketLib;

namespace ONDClient.Net;

public static class EventProcessor {

    private static readonly Dictionary<int, Action<GameEvent>> eventHandlers = new(){
        [0] = _ => PlayerJoin(),
        [1] = _ => PlayerLeave(),
        [2] = e => SwitchCam(e.Args[0], e.Args[1]),
        [3] = e => ChangeMonitorState(e.Args[0], e.Args[1] == 1),
        [4] = e => ChangeDoorStateOffice(e.Args[0], e.Args[1], e.Args[2] == 1),
        [5] = e => ChangeDoorStateRemote(e.Args[0], (e.Args[1], e.Args[2]), e.Args[3] == 1),
        [6] = e => SpawnEnemy((EnemyType)e.Args[0], e.Args[1], e.Args[3]),
        [7] = e => MoveEnemy(e.Args[0], e.Args[1]),
        [8] = e => EnemyAttack(e.Args[0], e.Args[1]),
        [9] = e => EnemyReset(e.Args[0], e.Args[1]),
        [10] = e => SpotSetActive(e.Args[0], e.Args[1] == 1),
        [11] = e => PlayerWin(e.Args[0]),
        [12] = _ => StartGame(),
        [13] = e => PowerTick(e.Args[0], e.Args[1]),
        [14] = e => PowerOut(e.Args[0]),
        [15] = e => ChangeLightState(e.Args[0], e.Args[1], e.Args[2] == 1),
        [16] = _ => NekoAnger(),
        [17] = _ => VentWalk(),
        [18] = _ => NextPhase()
    };
    
    public static void Evaluate(GameEvent[] events) {
        foreach (var e in events){
            eventHandlers[e.Id](e);
        }        
    }
    
    private static void PlayerJoin() {
        Console.WriteLine("E: Player joined");
    }
    private static void PlayerLeave() {
        Console.WriteLine("E: Player left");
    }
    private static void SwitchCam(int pid, int camId) {
        if (Client.Player.State.Pid != pid){
            UIManager.ChangeCameraOpponent(camId);
            return;
        }
        if (Client.Player.State.Camera != camId) Console.WriteLine("!!! DESYNC: CAMERA STATE");
        Console.WriteLine($"E: player {pid} switched to camera {camId}");
    }
    private static void ChangeMonitorState(int pid, bool state) {
        Console.WriteLine($"E: Player {pid} toggled monitor {(state ? "off" : "on")}");
                    
        if (pid != Client.Player.State.Pid){
            UIManager.ChangeMonitorStateOpponent(state);
            return;
        }
                    
        if (Client.Player.State.MonitorUp != state) Console.WriteLine("!!! DESYNC: MONITOR STATE");
    }
    private static void ChangeDoorStateOffice(int pid, int doorId, bool state) {
        Console.WriteLine($"E: Player {pid} {(state ? "closed" : "opened")} door {doorId}");
                    
        if (pid == Client.Player.State.Pid){
            if (Client.Player.State.DoorStates[doorId] != state) Console.WriteLine("!!! DESYNC: DOOR STATE");
            return;
        }
                    
        Client.Opponent.State.DoorStates[doorId] = state;
        UIManager.ChangeDoorStateOpponent((Direction)doorId, state);
    }
    
    private static void ChangeDoorStateRemote(int pid, (int tile1, int tile2) connectorId, bool state) {
        Console.WriteLine($"E: Player {pid} {(state ? "closed" : "opened")} door {connectorId.tile1}-{connectorId.tile2}");
        TileConnectorProjection connector = ClientMapManager.GetConnector(connectorId);
        if (connector == null){
            Console.WriteLine($"!!! Connector {connectorId} not found");
            return;
        }
        
        if (pid == Client.Player.State.Pid){
            if (connector.Blocked != state) Console.WriteLine("!!! DESYNC: REMOTE DOOR STATE");
            return;
        }
                    
        connector.Blocked = state;
        UIManager.ChangeRemoteDoorState(connectorId, state);
    }

    private static void SpawnEnemy(EnemyType type, int id, int camId) {
        Console.WriteLine($"E: Spawned enemy {type} at {camId}");
        ClientEnemyManager.AddEnemyByTemplate(type, id, ClientMapManager.Get(camId));
        UIManager.UpdateCameras([camId]);
    }

    private static void MoveEnemy(int id, int camId) {
        Console.WriteLine($"E: Enemy {id} moved to {camId}");
        int oldPos = ClientEnemyManager.Get(id).Location!.Id;
        ClientEnemyManager.Move(id, ClientMapManager.Get(camId));
        UIManager.UpdateCameras([oldPos, camId]);
        SoundManager.PlayEnemyMove(ClientEnemyManager.Get(id));
    }

    private static void EnemyAttack(int enemyId, int pid) {
        Console.WriteLine($"E: Enemy {enemyId} attacked player {pid}");
        if (pid == Client.Player.State.Pid) {
            UIManager.Jumpscare(ClientEnemyManager.Get(enemyId));
            SoundManager.PlayJumpscare();
        }
    }

    private static void EnemyReset(int id, int camId) {
        Console.WriteLine($"E: Enemy {id} reset to {camId}");
        int preResetPos = ClientEnemyManager.Get(id).Location!.Id;
        ClientEnemyManager.Move(id, ClientMapManager.Get(camId));
        UIManager.UpdateCameras([preResetPos, camId]);
        SoundManager.PlayEnemyReset(ClientEnemyManager.Get(id));
    }

    private static void SpotSetActive(int id, bool state) {
        ClientEnemy enemy = ClientEnemyManager.Get(id);
        if (enemy.Type != EnemyType.SPOT) return;
        Console.WriteLine($"E: Spot:{id} turned {(state ? "on" : " off")}");
        ClientEnemyManager.Get(id).Sprite.SetTexture(state ? 0 : 1);
        SoundManager.PlaySpotActivate();
    }

    private static void PlayerWin(int pid) {
        Console.WriteLine($"E: Player {pid} won");
        if(Client.Player.State.Pid == pid) UIManager.ShowVictoryScreen();
        Client.Disconnect();
        ClientEnemyManager.ClearEnemies();
    }

    private static void StartGame() {
        Console.WriteLine("E: Game started");
        UIManager.DisplayGameUI();
        UIManager.StartTimer();
        SoundManager.StartAmbience();
        Client.State = Client.ConnectionState.GAME_IN_PROGRESS;
    }

    private static void PowerTick(int pid, int value) {
        // Console.WriteLine($"E: power tick {e.Args[0]}: {e.Args[1]}");
        if (pid == Client.Player.State.Pid){
            Client.Player.State.Power = value;
        }
        else{
            Client.Opponent.State.Power = value;
        }

    }
    
    private static void PowerOut(int pid) {
        Console.WriteLine($"E: Player {pid} powered out");
        ClientMapManager.GetAllConnectors().Where(c =>
            (c.Type == ConnectorType.DOOR_REMOTE || c.Type == ConnectorType.DOOR_OFFICE) &&
            c.Owner == Client.GetPlayer(pid)).ToList().ForEach(c => 
        {
            c.Blocked = false;
            if(c.Type == ConnectorType.DOOR_REMOTE)
                UIManager.ChangeRemoteDoorState(c.Id, false);
        });
        foreach (var tile in ClientMapManager.GetAllTiles()){
            tile.Lit = false;
        }

        if (pid == Client.Player.State.Pid){ 
            UIManager.ChangeDoorState(Direction.EAST, false);
            UIManager.ChangeDoorState(Direction.NORTH, false);
            UIManager.ChangeDoorState(Direction.WEST, false);
            CommandManager.AllowGameControls(false);
            UIManager.ChangeMonitorState(false);
            SoundManager.PlayPowerOut();
        }
        else{
            UIManager.ChangeDoorStateOpponent(Direction.EAST, false);
            UIManager.ChangeDoorStateOpponent(Direction.NORTH, false);
            UIManager.ChangeDoorStateOpponent(Direction.WEST, false);
            UIManager.ChangeMonitorStateOpponent(false);
        }
    }

    private static void ChangeLightState(int pid, int camId, bool state) {
        Console.WriteLine($"E: Player {pid} {(state ? "lit": "unlit")} tile {camId}");
        if (pid == Client.Player.State.Pid){
            if (ClientMapManager.Get(camId).Lit != state) Console.WriteLine("!!! DESYNC: LIGHT STATE");
            return;
        }
                    
        ClientMapManager.Get(camId).Lit = state;
        UIManager.UpdateCameras([camId]);
    }

    private static void NekoAnger() {
        SoundManager.PlayNekoAnger();
    }

    private static void VentWalk() {
        SoundManager.PlayVentWalk();
    }
    
    private static void NextPhase() {
        SoundManager.PlayBell();
    }
}