OneNightDuel/FNAF_Clone/Client.cs

using System;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using FNAF_Clone.GUI;
using FNAF_Clone.Map;
using GlobalClassLib;
using LiteNetLib;
using LiteNetLib.Utils;
using PacketLib;

namespace FNAF_Clone;

public class Client { 
    private static EventBasedNetListener listener = new();
    private static NetManager client;
    private static NetPeer server;

    private static NetDataWriter writer;
    private static NetPacketProcessor processor;
    public static ClientPlayer Player { get; } = new();
    

    public static void Connect(string endPoint, int port) {
        writer = new NetDataWriter();
        processor = new NetPacketProcessor();
        
        NestedTypeManager.AutoRegister(processor);
        
        processor.SubscribeReusable<JoinAcceptPacket>(OnJoinAccept);
        processor.SubscribeReusable<UpdatePlayerPacket>(OnPlayerUpdate);
        processor.SubscribeReusable<MapInitPacket>(OnMapInit);
        
        client = new NetManager(listener){
            AutoRecycle = true
        };

        client.Start();
        Console.WriteLine($"Connecting to server @ {endPoint}:{port}");
        
        listener.NetworkReceiveEvent += (peer, reader, channel, method) => {
            OnNetworkReceive(peer, reader, method);
        };
        
        listener.PeerConnectedEvent += peer => {
            Console.WriteLine("Connected to Server");
            server = peer;
            SendPacket(new JoinPacket {username = "Player1"}, DeliveryMethod.ReliableOrdered);
        };
        
        client.Connect(endPoint, port, ""); // TODO: figure out how keys work
    }

    public static void SendPacket<T>(T packet, DeliveryMethod deliveryMethod) where T : class, new() {
        if (server != null) {
            writer.Reset();
            processor.Write(writer, packet);
            server.Send(writer, deliveryMethod);
        }
    }
    public static void SendCommands(PlayerCommand[] pCommands) {
        SendPacket(new PlayerCommandPacket{commands = pCommands}, DeliveryMethod.ReliableOrdered);
    }

    private static void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) {
        processor.ReadAllPackets(reader, peer);
    }

    private static void OnJoinAccept(JoinAcceptPacket packet) {
        Console.WriteLine($"Accepted by server, pid: {packet.state.pid}");
        Player.state = packet.state;
    }

    private static void OnMapInit(MapInitPacket packet) {
        (int id1, int id2, ConnectorType type)[] connectorsData = new (int id1, int id2, ConnectorType type)[packet.Connectors.Length / 3];
        for (int i = 0; i < packet.Connectors.Length / 3; i++){
            connectorsData[i] = (packet.Connectors[i * 3], packet.Connectors[i * 3 + 1], (ConnectorType)packet.Connectors[i * 3 + 2]);
        }
        ClientMapManager.InitMap();
        TileConnectorProjection[] connectors = connectorsData.Select(c => new TileConnectorProjection(ClientMapManager.Get(c.id1), ClientMapManager.Get(c.id2), c.type)).ToArray();
        ClientMapManager.InitConnectors(connectors);
        UIManager.SpawnDoors(connectors.Where(c => c.Type == ConnectorType.DOOR_REMOTE).ToArray());
    }
    
    public static void Update() {
        client.PollEvents();
    }

    public static void OnPlayerUpdate(UpdatePlayerPacket packet) { // TODO: move this to a separate class
        
        //Player.state = Player.state.pid == 0 ? packet.stateP1 : packet.stateP2;

        foreach (var e in packet.events){
            switch (e.ID){
                case 0: // join
                    Console.WriteLine("E: Player joined");
                    break;
                case 1: // leave
                    Console.WriteLine("E: Player left");
                    break;
                case 2: // switch cam
                    if (Player.state.pid != e.Args[0]) return;
                    if (Player.state.camera != e.Args[1]) Console.WriteLine("!!! DESYNC: CAMERA STATE");
                    Console.WriteLine($"E: player {e.Args[0]} switched to camera {e.Args[1]}");
                    break;
                case 3: // toggle cam
                    if (Player.state.monitorUp != (e.Args[1] == 1)) Console.WriteLine("!!! DESYNC: MONITOR STATE");
                    
                    UIManager.ChangeMonitorState(e.Args[1] == 1);
                    Console.WriteLine($"E: Player {e.Args[0]} toggled monitor {(e.Args[1] == 0 ? "off" : "on")}");
                    break;
                case 4: // toggle door
                    if (Player.state.doorStates[e.Args[1]] != (e.Args[2] == 1)) Console.WriteLine("!!! DESYNC: DOOR STATE");
                    
                    // UIManager.ChangeDoorState((Direction)e.Args[1], e.Args[2] == 1);
                    Console.WriteLine($"E: Player {e.Args[0]} {(e.Args[2] == 1 ? "closed" : "opened")} door {e.Args[1]}");
                    break;
                case 5: // toggle remote door
                    if (ClientMapManager.GetConnector((e.Args[1], e.Args[2])).Blocked != (e.Args[3] == 1)) Console.WriteLine("!!! DESYNC: REMOTE DOOR STATE");
                    Console.WriteLine($"E: Player {e.Args[0]} {(e.Args[3] == 1 ? "closed" : "opened")} door {e.Args[1]}-{e.Args[2]}");
                    break;
                case -1: // movement
                    throw new NotImplementedException();

            }
        }        
    }
    
    
}