plugin.cs

using BepInEx;
using HarmonyLib;
using LiteNetLib;
using LiteNetLib.Utils;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace NineSolsCoop
{
    //struct ref: ErrorMessage
    public struct ErrorMessage
    {
        public string Message;
        public float ExpiryTime;
    }//entry
    [BepInPlugin("com.coop.ninesols", "ninesols-coop", "1.0.0")]
    public class Plugin : BaseUnityPlugin
    {
        public static PluginB Instance => PluginB.Instance;
        public static bool IsApplyingNetworkSync
        {
            get => PluginB.IsApplyingNetworkSync;
            set => PluginB.IsApplyingNetworkSync = value;
        }

        private void Awake()
        {
            SceneManager.sceneLoaded += OnSceneLoadedInitial;

            var harmony = new Harmony("com.coop.ninesols");
            harmony.PatchAll();
        }

        private void OnSceneLoadedInitial(Scene scene, LoadSceneMode mode)
        {
            if (GameObject.Find("NineSolsCoopController") == null)
            {
                var coopObject = new GameObject("NineSolsCoopController");
                DontDestroyOnLoad(coopObject);

                coopObject.AddComponent<PluginB>();
                coopObject.AddComponent<NetworkManager>();
                coopObject.AddComponent<PlayerData>();
                coopObject.AddComponent<Chat>();
            }
        }
    }

    //for new versions
    public class PluginB : MonoBehaviour
    {
        public static PluginB Instance;
        public static bool IsApplyingNetworkSync = false;

        public string Nickname = "Player";
        public string TargetIP = "127.0.0.1";
        public int TargetPort = 7777;
        public readonly List<ErrorMessage> ErrorQueue = new List<ErrorMessage>();
        public readonly Dictionary<int, string> AnimationHashToName = new Dictionary<int, string>();
        //var2
        public int LocalAnimationHash = 0;
        public float LocalNormalizedTime = 0f;
        public bool IsTypingChat = false;
        //var3
        private bool showMenu = false;
        private Rect windowRect = new Rect(20, 20, 300, 180);
        private Texture2D borderTex;
        private Texture2D bgTex;
        private GUIStyle winStyle;
        private GUIStyle btnStyle;
        private GUIStyle inputStyle;
        private GUIStyle errorStyle;
        private GUIStyle chatStyle;
        private GUIStyle chatInputStyle;
        //var4
        private float lastSendTime = 0f;

        private void Awake()
        {
            Instance = this;
        }

        private void OnEnable()
        {
            SceneManager.sceneLoaded += OnSceneLoaded;
        }

        private void OnDisable()
        {
            SceneManager.sceneLoaded -= OnSceneLoaded;
        }

        private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
        {
            if (PlayerData.Instance != null)
            {
                PlayerData.Instance.DestroyRemote();
            }
            if (NetworkManager.Instance != null && NetworkManager.Instance.IsConnected)
            {
                NetDataWriter writer = new NetDataWriter();
                writer.Put((byte)PacketType.SceneChange);
                writer.Put(scene.name);
                NetworkManager.Instance.Send(writer, DeliveryMethod.ReliableOrdered);
            }
        }

        private void Update()
        {
            UpdateErrorQueue();

            if (UnityEngine.Input.GetKeyDown(KeyCode.F1))
            {
                showMenu = !showMenu;
            }

            if (NetworkManager.Instance != null && NetworkManager.Instance.IsConnected)
            {
                if (Time.timeScale == 0f)
                {
                    Time.timeScale = 1f;
                }

                if (Time.time - lastSendTime > 0.03f)
                {
                    lastSendTime = Time.time;
                    SendLocalState();   // +
                }
            }
        }

        private void SendLocalState()//ya
        {
            if (Player.i == null) return;

            var animator = Player.i.GetComponentInChildren<Animator>();
            if (animator != null)
            {
                var stateInfo = animator.GetCurrentAnimatorStateInfo(0);
                LocalAnimationHash = stateInfo.shortNameHash;
                LocalNormalizedTime = stateInfo.normalizedTime;
            }

            Vector3 pos = Player.i.transform.position;
            float scaleX = Player.i.transform.localScale.x;
            bool isFacingRight = Player.i.Facing == Facings.Right;
            string sceneName = SceneManager.GetActiveScene().name;

            float hp = 0f;
            float maxHp = 100f;
            if (Player.i.health != null)
            {
                hp = Player.i.health.currentValue;
                if (Player.i.health.maxHealth != null)
                {//check real
                    maxHp = Player.i.health.maxHealth.Value;
                }
            }

            NetDataWriter writer = new NetDataWriter();
            writer.Put((byte)PacketType.Position);
            writer.Put(pos.x);
            writer.Put(pos.y);
            writer.Put(pos.z);
            writer.Put(scaleX);
            writer.Put(LocalAnimationHash);
            writer.Put(LocalNormalizedTime);
            writer.Put(isFacingRight);
            writer.Put(sceneName);
            writer.Put(hp);
            writer.Put(maxHp);

            NetworkManager.Instance.Send(writer, DeliveryMethod.Unreliable);
        }

        public void OnConnected()
        {
            NetDataWriter writer = new NetDataWriter();
            writer.Put((byte)PacketType.Handshake);
            writer.Put(Nickname);
            NetworkManager.Instance.Send(writer, DeliveryMethod.ReliableOrdered);
        }

        public void OnDisconnected()
        {
            if (PlayerData.Instance != null)
            {
                PlayerData.Instance.DestroyRemote();
            }
        }

        public void SendMonsterDamage(string id, float value, bool isConsumeInjury)
        {
            /*
            NetDataWriter writer = new NetDataWriter();
            writer.Put((byte)PacketType.MonsterDamage);
            writer.Put(id);
            writer.Put(value);
            writer.Put(isConsumeInjury);
            NetworkManager.Instance.Send(writer, DeliveryMethod.ReliableOrdered);
            */
        }

        public void SendMonsterDie(string id)
        {
            /*
            NetDataWriter writer = new NetDataWriter();
            writer.Put((byte)PacketType.MonsterDie);
            writer.Put(id);//die
            NetworkManager.Instance.Send(writer, DeliveryMethod.ReliableOrdered);
            */
        }

        public void ReceiveData(NetPacketReader reader)
        {
            if (reader.AvailableBytes < 1) return;
            PacketType type = (PacketType)reader.GetByte();

            if (type == PacketType.Position)
            {
                if (PlayerData.Instance != null)
                {
                    PlayerData.Instance.RemotePosition = new Vector3(reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
                    PlayerData.Instance.RemoteScaleX = reader.GetFloat();
                    PlayerData.Instance.RemoteAnimationHash = reader.GetInt();
                    PlayerData.Instance.RemoteNormalizedTime = reader.GetFloat();
                    PlayerData.Instance.RemoteFacingRight = reader.GetBool();
                    PlayerData.Instance.RemoteScene = reader.GetString();
                    PlayerData.Instance.RemoteHP = reader.GetFloat();
                    PlayerData.Instance.RemoteMaxHP = reader.GetFloat();
                }
            }
            else if (type == PacketType.Handshake)
            {
                if (PlayerData.Instance != null)
                {
                    PlayerData.Instance.RemoteNickname = reader.GetString();
                }
            }
            else if (type == PacketType.Chat)
            {
                string msg = reader.GetString();
                if (Chat.Instance != null)
                {
                    Chat.Instance.AddMessage(msg);
                }
            }
            else if (type == PacketType.SceneChange)
            {
                if (PlayerData.Instance != null)
                {
                    PlayerData.Instance.RemoteScene = reader.GetString();
                }
            }
            /*
            else if (type == PacketType.MonsterDamage)
            {
                string id = reader.GetString();
                float dmg = reader.GetFloat();
                bool isConsume = reader.GetBool();

                if (MonsterRegistry.ActiveMonsters.TryGetValue(id, out var monster))
                {
                    IsApplyingNetworkSync = true;
                    monster.postureSystem.TakeDamage(dmg, isConsume, null);
                    IsApplyingNetworkSync = false;
                }
            }
            else if (type == PacketType.MonsterDie)
            {
                string id = reader.GetString();

                if (MonsterRegistry.ActiveMonsters.TryGetValue(id, out var monster))
                {
                    IsApplyingNetworkSync = true;
                    monster.health.currentValue = 0f;
                    monster.postureSystem.PostureValue = 0f;
                    monster.postureSystem.CurrentInternalInjury = 0f;
                    EffectHitData dummy = EffectHitData.HitDataPool.Borrow();
                    monster.Die(dummy);
                    IsApplyingNetworkSync = false;
                }
            }
            */
        }

        public void AddError(string msg)
        {
            lock (ErrorQueue)
            {
                ErrorQueue.Add(new ErrorMessage
                {
                    Message = msg,
                    ExpiryTime = Time.time + 5f
                });
            }
        }

        private void UpdateErrorQueue()
        {
            lock (ErrorQueue)
            {
                ErrorQueue.RemoveAll(e => Time.time > e.ExpiryTime);
            }
        }

        private void InitMenuStyles()//default
        {
            if (borderTex == null)
            {
                borderTex = new Texture2D(2, 2);
                Color gold = new Color(0.83f, 0.68f, 0.36f, 1f);
                borderTex.SetPixels(new Color[] { gold, gold, gold, gold });
                borderTex.Apply();

                bgTex = new Texture2D(2, 2);
                Color dark = new Color(0.04f, 0.08f, 0.09f, 0.95f);
                bgTex.SetPixels(new Color[] { dark, dark, dark, dark });
                bgTex.Apply();

                winStyle = new GUIStyle();
                winStyle.fontSize = 14;
                winStyle.fontStyle = FontStyle.Bold;
                winStyle.normal.textColor = new Color(0.83f, 0.68f, 0.36f, 1f);
                winStyle.alignment = TextAnchor.UpperCenter;

                btnStyle = new GUIStyle(GUI.skin.button);
                btnStyle.fontSize = 12;
                btnStyle.fontStyle = FontStyle.Bold;
                btnStyle.normal.textColor = Color.white;

                inputStyle = new GUIStyle(GUI.skin.textField);
                inputStyle.fontSize = 12;
                inputStyle.alignment = TextAnchor.MiddleCenter;

                errorStyle = new GUIStyle();
                errorStyle.fontSize = 14;
                errorStyle.fontStyle = FontStyle.Bold;
                errorStyle.normal.textColor = new Color(0.9f, 0.2f, 0.2f, 1f);

                chatStyle = new GUIStyle();
                chatStyle.fontSize = 14;
                chatStyle.fontStyle = FontStyle.Bold;
                chatStyle.normal.textColor = Color.white;

                chatInputStyle = new GUIStyle(GUI.skin.textField);
                chatInputStyle.fontSize = 14;
                chatInputStyle.alignment = TextAnchor.MiddleLeft;
            }
        }

        private void OnGUI()
        {
            InitMenuStyles();

            if (showMenu)
            {
                windowRect = GUI.Window(0, windowRect, DrawCoopWindow, "");
            }

            DrawErrors();   // +
            DrawChat(); // +
        }

        private void DrawErrors()
        {
            lock (ErrorQueue)
            {
                float startY = Screen.height - 40f;
                for (int i = 0; i < ErrorQueue.Count; i++)
                {//pis +uun
                    var err = ErrorQueue[i];
                    GUI.Label(new Rect(20, startY - (i * 25), 450, 20), $"error -> {err.Message}", errorStyle);
                }
            }
        }

        private void DrawChat()
        {
            if (Chat.Instance == null) return;

            float screenHeight = Screen.height;
            float startY = screenHeight - 120f;
            float startX = 20f;

            lock (Chat.Instance.Messages)
            {
                for (int i = 0; i < Chat.Instance.Messages.Count; i++)
                {
                    var msg = Chat.Instance.Messages[i];
                    GUI.Label(new Rect(startX + 1, startY - (i * 25) + 1, 600, 25), msg.Text, new GUIStyle(chatStyle) { normal = { textColor = Color.black } });
                    GUI.Label(new Rect(startX, startY - (i * 25), 600, 25), msg.Text, chatStyle);
                }
            }

            if (Chat.Instance.IsTyping)
            {
                float inputY = screenHeight - 60f;
                GUI.Box(new Rect(startX - 5, inputY - 5, 410, 35), "");

                Event e = Event.current;
                if (e != null && e.type == EventType.KeyDown)
                {
                    if (e.keyCode == KeyCode.Return)
                    {
                        e.Use();
                        Chat.Instance.SendChatOutside();
                    }
                    else if (e.keyCode == KeyCode.Escape)
                    {
                        e.Use();
                        Chat.Instance.CancelChatOutside();
                    }
                }

                GUI.SetNextControlName("ChatInput");
                Chat.Instance.InputText = GUI.TextField(new Rect(startX, inputY, 400, 25), Chat.Instance.InputText, 100, chatInputStyle);
                GUI.FocusControl("ChatInput");
            }
        }

        private void DrawCoopWindow(int id)
        {
            GUI.DrawTexture(new Rect(0, 0, windowRect.width, windowRect.height), bgTex);
            GUI.Box(new Rect(0, 0, windowRect.width, windowRect.height), "", winStyle);

            GUI.DrawTexture(new Rect(0, 0, windowRect.width, 1), borderTex);
            GUI.DrawTexture(new Rect(0, windowRect.height - 1, windowRect.width, 1), borderTex);
            GUI.DrawTexture(new Rect(0, 0, 1, windowRect.height), borderTex);
            GUI.DrawTexture(new Rect(windowRect.width - 1, 0, 1, windowRect.height), borderTex);

            GUILayout.BeginArea(new Rect(10, 10, windowRect.width - 20, windowRect.height - 20));
            GUILayout.Label("lobby", winStyle);
            GUILayout.Space(10);

            GUILayout.BeginHorizontal();
            GUILayout.Label("nick:", GUILayout.Width(40));
            Nickname = GUILayout.TextField(Nickname, inputStyle);
            GUILayout.EndHorizontal();

            if (NetworkManager.Instance != null)
            {
                if (!NetworkManager.Instance.IsConnected && !NetworkManager.Instance.IsRunning)
                {
                    GUILayout.BeginHorizontal();
                    GUILayout.Label("ip:", GUILayout.Width(40));
                    TargetIP = GUILayout.TextField(TargetIP, inputStyle);
                    GUILayout.EndHorizontal();

                    GUILayout.BeginHorizontal();
                    GUILayout.Label("port:", GUILayout.Width(40));
                    string portStr = GUILayout.TextField(TargetPort.ToString(), inputStyle);
                    if (int.TryParse(portStr, out int port)) TargetPort = port;
                    GUILayout.EndHorizontal();

                    GUILayout.Space(10);
                    if (GUILayout.Button("host server", btnStyle))
                    {
                        NetworkManager.Instance.StartServer(TargetPort);
                    }
                    if (GUILayout.Button("connect to server", btnStyle))
                    {
                        NetworkManager.Instance.StartClient(TargetIP, TargetPort);
                    }
                }
                else
                {
                    string status = "offline";
                    if (NetworkManager.Instance.IsConnected)
                    {
                        status = NetworkManager.Instance.IsServer ? "connected (host)" : "connected (guest)";
                    }
                    else if (NetworkManager.Instance.IsRunning)
                    {
                        status = "waiting for peer...";
                    }

                    GUILayout.Label($"status: {status}", winStyle);
                    GUILayout.Space(10);
                    if (GUILayout.Button("disconnect", btnStyle))
                    {
                        NetworkManager.Instance.Stop();
                    }
                }
            }

            GUILayout.EndArea();
            GUI.DragWindow(new Rect(0, 0, 10000, 10000));
        }
    }//end
}