Starter Forge Client & Server Stuff

ClientPackets.cs

using BeardedManStudios;
using BeardedManStudios.Forge.Networking;
using BeardedManStudios.Forge.Networking.Unity;
using BeardedManStudios.Forge.Networking.Lobby;
using BeardedManStudios.Forge.Networking.Frame;
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

public partial class GameClient : MonoBehaviour
{
    //ClientHUD hud;

    public void HandleGamePackets(int opcode, int start, BMSByte data, NetworkingPlayer player)
    {
        if (opcode == start + GameOpcodes.PKT_SendAbilityList)
            ReceiveAbilities(player, data);
        if (opcode == start + GameOpcodes.PKT_ReceiveInv)
            ReceiveInv(player, data);
        if (opcode == start + GameOpcodes.PKT_InvMoveResultSwap)
            ResultMoveSwap(player, data);
        if (opcode == start + GameOpcodes.PKT_InvMoveResultStack)
            ResultMoveStack(player, data);
        if (opcode == start + GameOpcodes.PKT_InvMoveResultMove)
            ResultMoveBlank(player, data);
        if (opcode == start + GameOpcodes.PKT_InvRemoveItem)
            ResultRemoveItem(player, data);
        if (opcode == start + GameOpcodes.PKT_InvSendAddItem)
            ResultAddItem(player, data);
        if (opcode == start + GameOpcodes.PKT_SendHudError)
            ReceiveHUDError(player, data);
    }

    //REQUEST INVENTORY
    public void RequestInventory()
    {
        try
        {
            int temp = 1;
            BMSByte cachedData = new BMSByte();
            cachedData = ObjectMapper.Instance.MapBytes(cachedData, temp);
            SendPacketServer(GameOpcodes.PKT_RequestInv, cachedData);
        }
        catch (Exception e)
        {
            Debug.LogError("Error Request Inventory: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //REQUEST ABILITIES
    public void RequestAbilities()
    {
        try
        {
            int temp = 1;
            BMSByte cachedData = new BMSByte();
            cachedData = ObjectMapper.Instance.MapBytes(cachedData, temp);
            SendPacketServer(GameOpcodes.PKT_RequestAbilityList, cachedData);
        }
        catch (Exception e)
        {
            Debug.LogError("Error Request Abilities: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //RECEIVE/LOAD ABILITIES
    public void ReceiveAbilities(NetworkingPlayer sender, BMSByte stream)
    {
        try
        {
	    MainThreadManager.Run(() =>
	    {
	        string abilities1 = ObjectMapper.Instance.Map<string>(stream);
	        Debug.Log("Received Abilities: " + abilities1);

	        //GameObject InventoryObj = GameObject.Find("ScriptController");
	        //InventoryObj.GetComponent<SpellBook>().LoadAbilityList(abilities1);
	    });
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Receive Abilities: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //RECEIVE INVENTORY
    public void ReceiveInv(NetworkingPlayer sender, BMSByte stream)
    {
        MainThreadManager.Run(() =>
        {
            try
            {
                string inventory = ObjectMapper.Instance.Map<string>(stream);
                Debug.Log("Received Inventory: " + inventory);

                //GameObject InventoryObj = GameObject.FindWithTag("Inventory");
                //InventoryObj.GetComponent<Inventory>().ReceiveInventory(inventory);
            }
            catch (Exception e)
            {
                Debug.LogWarning("Error Receive Inventory: " + e.Message + "\r\n" + e.StackTrace);
            }
        });
    }

    //REQUEST MOVE ITEM
    public void RequestMoveItem(string item1, string slotMoveTo)
    {
        try
        {
            BMSByte cachedData = new BMSByte();
            cachedData = ObjectMapper.Instance.MapBytes(cachedData, item1, slotMoveTo);
            SendPacketServer(GameOpcodes.PKT_InvMoveItem, cachedData);
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Move Item: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //REQUEST MOVE ITEM CONTAINER
    public void RequestMoveItemContainer(string item1, string slotMoveTo, int gobjID)
    {
        try
        {
            BMSByte cachedData = new BMSByte();
            cachedData = ObjectMapper.Instance.MapBytes(cachedData, gobjID, item1, slotMoveTo);
            SendPacketServer(GameOpcodes.PKT_InvMoveItem, cachedData);
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Move Item Container: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //RECEIVE MOVE SWAP
    public void ResultMoveSwap(NetworkingPlayer sender, BMSByte stream)
    {
        try
        {
	    MainThreadManager.Run(() =>
	    {
	        string data = ObjectMapper.Instance.Map<string>(stream);
	        //GameObject obj = GameObject.FindWithTag("Inventory");
	        //obj.GetComponent<Inventory>().MoveItemSwap(data);
	    });
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Move Item Swap: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //RECEIVE MOVE STACK
    public void ResultMoveStack(NetworkingPlayer sender, BMSByte stream)
    {
        try
        {
	    MainThreadManager.Run(() =>
	    {
	        string data = ObjectMapper.Instance.Map<string>(stream);
	        //GameObject obj = GameObject.FindWithTag("Inventory");
	        //obj.GetComponent<Inventory>().MoveItemBlank(data);
	    });
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Move Item Swap: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //RECEIVE MOVE BLANK
    public void ResultMoveBlank(NetworkingPlayer sender, BMSByte stream)
    {
        try
        {
	    MainThreadManager.Run(() =>
	    {
            	string data = ObjectMapper.Instance.Map<string>(stream);
            	//GameObject obj = GameObject.FindWithTag("Inventory");
            	//obj.GetComponent<Inventory>().MoveItemBlank(data);
	    });
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Move Item Blank: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //RECEIVE REMOVE ITEM
    public void ResultRemoveItem(NetworkingPlayer sender, BMSByte stream)
    {
        try
        {
	    MainThreadManager.Run(() =>
	    {
	        int slotID = ObjectMapper.Instance.Map<int>(stream);
	        //GameObject obj = GameObject.FindWithTag("Inventory");
	        //obj.GetComponent<Inventory>().RemoveSlot(slotID);
	        Debug.Log("Packets: RemoveSlot: " + slotID);
	    });
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Result Remove Item: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //RECEIVE ADD ITEM
    public void ResultAddItem(NetworkingPlayer sender, BMSByte stream)
    {
        try
        {
	    MainThreadManager.Run(() =>
	    {
	        string data = ObjectMapper.Instance.Map<string>(stream);
	        //GameObject obj = GameObject.FindWithTag("Inventory");
	        //obj.GetComponent<Inventory>().AddNewItem(data);
	    });
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Add Item: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //RECEIVE HUD ERROR
    public void ReceiveHUDError(NetworkingPlayer sender, BMSByte stream)
    {
        string strError = ObjectMapper.Instance.Map<string>(stream);

        //hud.ShowHudError(strError);
    }


    //REQUEST DROP ITEM
    public void RequestDropItem(string item1)
    {
        try
        {
            BMSByte cachedData = new BMSByte();
            cachedData = ObjectMapper.Instance.MapBytes(cachedData, item1);
            SendPacketServer(GameOpcodes.PKT_InvDropItem, cachedData);
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Drop Item: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //REQUEST SAVE PLAYER
    public void RequestSavePlayer()
    {
        try
        {
            BMSByte cachedData = new BMSByte();
            cachedData = ObjectMapper.Instance.MapBytes(cachedData, "");
            SendPacketServer(GameOpcodes.PKT_PlayerSave, cachedData);
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Request Save Player: " + e.Message + "\r\n" + e.StackTrace);
        }
    }

    //REQUEST CRAFTING LIST (TODO)
    public void RequestCraftingList()
    {
        /*try
        {
            int temp = 1;
            BMSByte cachedData = new BMSByte();
            cachedData = ObjectMapper.Instance.MapBytes(cachedData, temp);
            SendPacketServer(GameOpcodes.PKT_InvRequestCrafting, cachedData);
        }
        catch (Exception e)
        {
            Debug.LogWarning("Error Request Crafting: " + e.Message + "\r\n" + e.StackTrace);
        }*/
    }


    private void SendPacketServer(int opcode, BMSByte data)
    {
        ulong timestep = client.Time.Timestep;
        int opcode2 = MessageGroupIds.START_OF_GENERIC_IDS + opcode;
        Binary bin = new Binary(timestep, false, data, Receivers.Server, opcode2, false);
        ((UDPClient)client).Send(bin, true);
    }
}

GameClient.cs

using BeardedManStudios;
using BeardedManStudios.Forge.Networking;
using BeardedManStudios.Forge.Networking.Unity;
using BeardedManStudios.Forge.Networking.Lobby;
using BeardedManStudios.Forge.Networking.Frame;
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using System.Text.RegularExpressions;

public partial class GameClient : MonoBehaviour
{
    public bool useMainThreadManagerForRPCs = true;
    public string username;
    public string playerpass;
    public string serverIP;
    public uint serverPort;
    public int ping;
    public GameObject networkManager = null;
    private NetworkManager mgr = null;

    NetWorker client;
    float reconnectTimer = 10.0f;
    float pingTimer = 0.0f;
    float pingTime = 5.0f;

    private void Start()
    {
        // Do any firewall opening requests on the operating system
        if (connectMainSceneServer)
            NetWorker.PingForFirewall((ushort)ServerSettings.ServerHostPort);
        else
            NetWorker.PingForFirewall((ushort)ServerSettings.CharSelectPort);
        
        if (useMainThreadManagerForRPCs)
                Rpc.MainThreadRunner = MainThreadManager.Instance;

        string ip1 = serverIP;

        StartClient(ip1, serverPort);
    }

    private void Awake()
    {
        DontDestroyOnLoad(gameObject);
    }

    public void StartClient(string ip, int port)
    {
        Debug.Log("[GameClient] Connecting to GameServer: " + ip + ":" + port);

        client = new UDPClient();
        ((UDPClient)client).Connect(ip, (ushort)port);

        Connected(client);
    }

    public void Connected(NetWorker networker)
    {
        if (!networker.IsBound)
        {
            Debug.LogError("NetWorker failed to bind");
            return;
        }

        if (connectMainSceneServer)
        {
            if (mgr == null && networkManager == null)
            {
                Debug.LogWarning("[GameClient] A network manager was not provided, generating a new one instead");
                networkManager = new GameObject("Network Manager");
                mgr = networkManager.AddComponent<NetworkManager>();
            }
            else if (mgr == null) //Spawn Prefab
                mgr = Instantiate(networkManager).GetComponent<NetworkManager>();

            //Setup Client for Spawning/RPCs
            //mgr.Initialize(networker);
            NetworkManager.Instance.Initialize(networker);
        }

        //Setup Delegates
        networker.disconnected += ServerDisconnect;
        networker.binaryMessageReceived += ReadBinary;
        networker.onPingPong += OnPingPong;
        //networker.textMessageReceived += MessageReceived;

        //Send LoginRequest/EnterWorld
        PlayerConnect(networker);
    }

    private void PlayerConnect(NetWorker networker1)
    {
        try
        {
            //Debug.Log("[GameClient] Client Logging In: " + player.Name + ". NetID: " + player.NetworkId);
            //LoginRequest(bl_Utilz.SetGetUsername2, bl_Utilz.SetGetPass); //Verify Login
        }
        catch (Exception e)
        {
        }
    }

    private void ReadBinary(NetworkingPlayer player, Binary frameData, NetWorker networker1)
    {
        int start = MessageGroupIds.START_OF_GENERIC_IDS;
        BMSByte data = frameData.StreamData;

        if (frameData.GroupId == start + GameOpcodes.PKT_LoginResult)
            ReadLoginResult(player, data);

        if (frameData.GroupId == start + GameOpcodes.PKT_CharacterList)
            ReadCharList(player, data);

        if (frameData.GroupId == start + GameOpcodes.PKT_CreateCharResult)
            ReadCreateCharResult(player, data);

        if (frameData.GroupId == start + GameOpcodes.PKT_EnterWorldResult)
            ReadEnterWorldResult(player, data);
    }


    #region Client Packets

    private void ReadLoginResult(NetworkingPlayer sender, BMSByte stream)
    {
        string loginresult = ObjectMapper.Instance.Map<string>(stream);
        string dummy = ObjectMapper.Instance.Map<string>(stream);
        Debug.Log("[GameClient] Received Login Result: " + loginresult);
        if (loginresult == "success")
        {
            Debug.Log("[GameClient] Loading Char Create Scene");
        }
    }

    private void ReadCharList(NetworkingPlayer sender, BMSByte stream)
    {
        string charListData = ObjectMapper.Instance.Map<string>(stream);

        Debug.Log("[GameClient] Character List Received: " + charListData);

        MainThreadManager.Run(() =>
        {
            //if (charSelect != null)
                //charSelect.ShowCharList(charListData);
        });
    }

    private void ReadCreateCharResult(NetworkingPlayer sender, BMSByte stream)
    {
        int result = ObjectMapper.Instance.Map<int>(stream);

        if (result == 0) //Char Name Exists
        {
            //Display Error
            Debug.Log("[GameClient] Character Name already exists.");
        }
        if (result == 1) //Char Created
        {
            //Hide CharCreate & Refresh Char List
            MainThreadManager.Run(() =>
            {
                //if (charSelect != null)
                    //charSelect.HideCharCreate();
            });
            
            RequestCharList();
        }
    }

    private void ReadEnterWorldResult(NetworkingPlayer sender, BMSByte stream)
    {
        int enterResult = ObjectMapper.Instance.Map<int>(stream);

        //bl_Utilz.SetGetCharname = ObjectMapper.Instance.Map<string>(stream);
        //bl_Utilz.SetGetGender = ObjectMapper.Instance.Map<int>(stream);
        //bl_Utilz.SetGetRace = ObjectMapper.Instance.Map<int>(stream);
        //bl_Utilz.SetGetLevel = ObjectMapper.Instance.Map<int>(stream);
        //bl_Utilz.SetGetXP = ObjectMapper.Instance.Map<int>(stream);
    }

    public void CreateCharRequest(string charname1, int gender, int race, string morphz)
    {
        Debug.Log("[GameClient] Sending Create Char Request");

        //SEND PACKET: CREATE CHAR
        ulong timestep = client.Time.Timestep;
        int opcode = MessageGroupIds.START_OF_GENERIC_IDS + GameOpcodes.PKT_CreateChar;
        BMSByte data = new BMSByte();
        data = ObjectMapper.Instance.MapBytes(data, charname1, gender, race, morphz);
        Binary bin = new Binary(timestep, false, data, Receivers.Server, opcode, false);
        ((UDPClient)client).Send(bin, true);
    }

    public void RequestCharList()
    {
        Debug.Log("[GameClient] Sending Char List Request");

        //SEND PACKET: REQUEST CHAR LIST
        ulong timestep = client.Time.Timestep;
        int opcode = MessageGroupIds.START_OF_GENERIC_IDS + GameOpcodes.PKT_CharListRequest;
        BMSByte data = new BMSByte();
        data = ObjectMapper.Instance.MapBytes(data, bl_Utilz.SetGetUsername2);
        Binary bin = new Binary(timestep, false, data, Receivers.Server, opcode, false);
        ((UDPClient)client).Send(bin, true);
    }

    //Request for Login Verification
    public void LoginRequest(string username, string pass)
    {
        Debug.Log("[GameClient] Sending Login Request");

        //SEND PACKET: REQUEST CHAR LIST
        ulong timestep = client.Time.Timestep;
        int opcode = MessageGroupIds.START_OF_GENERIC_IDS + GameOpcodes.PKT_LoginRequest;
        BMSByte data = new BMSByte();
        data = ObjectMapper.Instance.MapBytes(data, username, pass);
        Binary bin = new Binary(timestep, false, data, Receivers.Server, opcode, false);
        ((UDPClient)client).Send(bin, true);
    }

    //Request to Spawn Player
    public void RequestEnterWorld(string username, string pass, int charID)
    {
        Debug.Log("[GameClient] Sending Enter World Request");

        //SEND PACKET: ENTER WORLD
        ulong timestep = client.Time.Timestep;
        int opcode = MessageGroupIds.START_OF_GENERIC_IDS + GameOpcodes.PKT_EnterWorld;
        BMSByte data = new BMSByte();
        data = ObjectMapper.Instance.MapBytes(data, username, pass, charID);
        Binary bin = new Binary(timestep, false, data, Receivers.Server, opcode, false);
        ((UDPClient)client).Send(bin, true);
    }

    #endregion

    /*public void EnterGame()
    {
        MainThreadManager.Run(() =>
        {
            Debug.Log("Loading Ingame Scene");
            SceneManager.LoadScene(ServerSettings.sceneMap);
        });
    }*/

    private void ServerDisconnect(NetWorker networker1)
    {
        try
        {
            Debug.Log("[GameClient] The server disconnected.");
            MainThreadManager.Run(() =>
            {
                //SceneManager.LoadScene("Lobby");
            });
        }
        catch (Exception e)
        {}
    }

    private void OnPingPong(double ping1, NetWorker player)
    {
        //Store Ping In Static Script
        //bl_Utilz.PingGameServer = (int)ping1;
        ping = (int)ping1;
    }

    void Dispose()
    {
        client.onPingPong -= OnPingPong;
        client.disconnected -= ServerDisconnect;
        client.binaryMessageReceived -= ReadBinary;
    }

    private void OnApplicationQuit()
    {
        if (bl_Utilz.IsClientServer == 1)
        {
            if (client != null)
                client.Disconnect(true);
            //WriteToLog.CloseFile();
            Debug.Log("Game closed.");
        }
    }

    public bool isConnected()
    {
        if (client != null)
            return client.IsConnected;
        else
            return false;
    }

    private void Update()
    {
        //Auto Reconnect Example
        if (client.IsConnected == false)
        {
            reconnectTimer -= Time.deltaTime;
            if (reconnectTimer < 0)
            {
                StartClient(serverIP, serverPort);
                Debug.Log("[GameClient] Trying to reconnect.");
                reconnectTimer = 10f;
            }
        }

        //Ping
        if (client.IsBound == true)
        {
            pingTimer -= Time.deltaTime;
            if (pingTimer < 0)
            {
                if (client != null)
                    if (client.IsBound)
                        client.Ping();
                pingTimer = pingTime;
            }
        }
    }

    void OnDisable()
    {
        //StopAllCoroutines();
        SceneManager.sceneLoaded -= OnLevelFinishedLoading;
    }

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

    void OnLevelFinishedLoading(Scene scene, LoadSceneMode mode)
    {
        //if (scene.name == "Map1")
    }
}

GameOpcodes.cs

using System;
using System.Collections.Generic;
using System.Text;

public static class GameOpcodes
{
    //LOGIN OPCODES
    public const int PKT_LoginRequest = 1000;
    public const int PKT_LoginResult = 1001;
    public const int PKT_CharacterList = 1002;
    public const int PKT_CreateChar = 1003;
    public const int PKT_CreateCharResult = 1004;
    public const int PKT_EnterWorld = 1005;
    public const int PKT_EnterWorldResult = 1006;
    public const int PKT_LoadSceneChar = 1008;
    public const int PKT_SendHudError = 1009;
    public const int PKT_CharListRequest = 1010;

    //INVENTORY OPCODES
    public const int PKT_RequestInv = 1100;
    public const int PKT_ReceiveInv = 1101;
    public const int PKT_InvMoveItem = 1102;
    public const int PKT_InvMoveResultStack = 1103;
    public const int PKT_InvMoveResultSwap = 1104;
    public const int PKT_InvMoveResultMove = 1105;
    public const int PKT_InvRemoveItem = 1106;
    public const int PKT_InvUpdateABItem = 1110;
    public const int PKT_InvRemoveABItem = 1111;
    public const int PKT_InvSendAddItem = 1120;
    public const int PKT_InvDropItem = 1121;
    public const int PKT_PickupObj = 1122;
}

GameServer.cs

using BeardedManStudios;
using BeardedManStudios.Forge.Networking;
using BeardedManStudios.Forge.Networking.Unity;
using BeardedManStudios.Forge.Networking.Lobby;
using BeardedManStudios.Forge.Networking.Frame;
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using UnityEngine;
using UnityEngine.SceneManagement;

public partial class GameServer : MonoBehaviour
{
    public GameObject networkManager = null;
    private NetworkManager mgr = null;

    public bool isMainSceneServer;
    public bool useMainThreadManagerForRPCs = true;
    public bool useTCP = false;
    public bool serverPlayer = true;

    NetWorker server;

    private void Start()
    {
        NetWorker.PingForFirewall((ushort)ServerSettings.ServerHostPort);

        if (useMainThreadManagerForRPCs)
            Rpc.MainThreadRunner = MainThreadManager.Instance;

        Host(ServerSettings.HostIP, ServerSettings.ServerHostPort);
    }

    private void Awake()
    {
        DontDestroyOnLoad(gameObject);
    }

    public void Host(string ip, int port)
    {
        Debug.Log("[GameServer] Starting Forge Server: " + ip + ":" + port);

	server = new UDPServer(ServerSettings.maxPlayers);
	((UDPServer)server).Connect(ip, (ushort)port);

	server.playerTimeout += (player, sender) =>
	{
	    Debug.Log("[GameServer] Player " + player.NetworkId + " timed out");
	};

	Connected(server);
    }

    void HandlePlayerTimeOut(NetworkingPlayer player, NetWorker sender)
    {
        Debug.Log("Player " + player.NetworkId + " timed out");
    }

    public void Connected(NetWorker networker)
    {
        if (!networker.IsBound)
        {
            Debug.LogError("NetWorker failed to bind");
            return;
        }

        //Setup NetworkManager
        if (isMainSceneServer)
        {
            if (mgr == null && networkManager == null)
            {
                Debug.LogWarning("A network manager was not provided, generating a new one instead");
                networkManager = new GameObject("Network Manager");
                mgr = networkManager.AddComponent<NetworkManager>();
            }
            else if (mgr == null) //Instantiate Prefab
                mgr = Instantiate(networkManager).GetComponent<NetworkManager>();

            //Setup Server for Spawning/RPCs
            //mgr.Initialize(networker);
            NetworkManager.Instance.Initialize(networker);
        }

        //Handle Connects/Disconnects
        networker.playerConnected += PlayerConnected2;
        networker.playerDisconnected += PlayerDisconnected2;
        networker.playerTimeout += HandlePlayerTimeOut;
        networker.binaryMessageReceived += ReadBinary;
        //server.textMessageReceived += MessageReceived;

        if (serverPlayer)
        {
            Debug.Log("[GameServer] Spawning Server Player");

            //Spawn Server Player
            Invoke("SpawnServerPlayer", 1.0f);
        }

        //Load which Scene
        LoadServerScene();
    }

    private void ReadBinary(NetworkingPlayer player, Binary frameData, NetWorker networker1)
    {
        int start = MessageGroupIds.START_OF_GENERIC_IDS;
        BMSByte data = frameData.StreamData;


        if (frameData.GroupId == start + GameOpcodes.PKT_LoginRequest)
            ReadLoginRequest(player, data);

        if (frameData.GroupId == start + GameOpcodes.PKT_CharListRequest)
            GetCharListRequest(player, data);

        if (frameData.GroupId == start + GameOpcodes.PKT_CreateChar)
            CreateCharRequest(player, data);
        
        //Handle In Game Packets
        HandleGamePackets(frameData.GroupId, start, data, player);
        
        if (frameData.GroupId == start + GameOpcodes.PKT_EnterWorld)
            EnterWorldRequest(player, data);
    }


    #region Packet Requests

    private void ReadLoginRequest(NetworkingPlayer sender, BMSByte stream)
    {
        string loginResultCode = "fail";
        string temp = "result";
        string username = ObjectMapper.Instance.Map<string>(stream);
        string playerpass = ObjectMapper.Instance.Map<string>(stream);

        Debug.Log("[GameServer] Login Request: " + username + ", " + playerpass);

        //VERIFY LOGIN
        if (VerifyLogin(username, playerpass) == true)
            loginResultCode = "success";
        else
            loginResultCode = "fail";

        //SEND PACKET
        if (loginResultCode == "success")
        {
            //SEND PACKET: LOGIN RESULT
            ulong timestep = server.Time.Timestep;
            int opcode = MessageGroupIds.START_OF_GENERIC_IDS + GameOpcodes.PKT_LoginResult;
            BMSByte data = new BMSByte();
            data = ObjectMapper.Instance.MapBytes(data, loginResultCode, temp);
            Binary bin = new Binary(timestep, false, data, Receivers.Target, opcode, false);
            ((UDPServer)server).Send(sender, bin, true);

            Debug.Log("[GameServer] Send Game Login Result - tell client to load Char Selection!");

            //SET USERNAME TO NETPLAYER
            sender.Name = username;
        }

        //DISCONNECT IF FAILED
        if (loginResultCode == "fail")
        {
            ((IServer)server).Disconnect(sender, true);
            Debug.Log("[GameServer] Player Login Failed: " + username + ", pass: " + playerpass);
        }
    }

    public void GetCharListRequest(NetworkingPlayer sender, BMSByte stream)
    {
        Debug.Log("[GameServer] Client Requested CharList");
        //SEND CHARACTER LIST
        string username1 = sender.Name;
        SendCharacterList(username1, sender);
    }

    public void SendCharacterList(string username, NetworkingPlayer player)
    {
        /*string charList = "";

        charList = PlayerHandler.GetCharacterList(username);

        Debug.Log("[GameServer] Sending Char List to: " + username + ". charList: " + charList);

        //SEND PACKET: CHARACTER LIST
        ulong timestep = server.Time.Timestep;
        int opcode = MessageGroupIds.START_OF_GENERIC_IDS + GameOpcodes.PKT_CharacterList;
        BMSByte data = new BMSByte();
        data = ObjectMapper.Instance.MapBytes(data, charList);
        Binary bin = new Binary(timestep, false, data, Receivers.Target, opcode, false);
        ((UDPServer)server).Send(player, bin, true);*/
    }

    public void CreateCharRequest(NetworkingPlayer sender, BMSByte stream)
    {
        string username1 = sender.Name;
        string charName1 = ObjectMapper.Instance.Map<string>(stream);
        int gender1 = ObjectMapper.Instance.Map<int>(stream);
        int race1 = ObjectMapper.Instance.Map<int>(stream);
        string morphs1 = ObjectMapper.Instance.Map<string>(stream);

        if (IsCharNameValid(charName1) == false)
        {
            //SEND PACKET: CREATE CHAR RESULT ERROR
            int result1 = 0;
            ulong timestep = server.Time.Timestep;
            int opcode = MessageGroupIds.START_OF_GENERIC_IDS + GameOpcodes.PKT_CreateCharResult;
            BMSByte data = new BMSByte();
            data = ObjectMapper.Instance.MapBytes(data, result1);
            Binary bin = new Binary(timestep, false, data, Receivers.Target, opcode, false);
            ((UDPServer)server).Send(sender, bin, true);

            SendCharacterList(username1, sender);
            return;
        }

        if (PlayerHandler.CharNameExists(charName1))
        {
            //SEND PACKET: CREATE CHAR RESULT ERROR
            int result1 = 0;
            ulong timestep = server.Time.Timestep;
            int opcode = MessageGroupIds.START_OF_GENERIC_IDS + GameOpcodes.PKT_CreateCharResult;
            BMSByte data = new BMSByte();
            data = ObjectMapper.Instance.MapBytes(data, result1);
            Binary bin = new Binary(timestep, false, data, Receivers.Target, opcode, false);
            ((UDPServer)server).Send(sender, bin, true);

            SendCharacterList(username1, sender);
        }
        else
        {
            //Create New Char & Send List
            PlayerHandler.CreateNewPlayer(charName1, username1, gender1, race1, morphs1);
            SendCharacterList(username1, sender);

            //SEND PACKET: CREATE CHAR RESULT SUCCESS
            int result1 = 1;
            ulong timestep = server.Time.Timestep;
            int opcode = MessageGroupIds.START_OF_GENERIC_IDS + GameOpcodes.PKT_CreateCharResult;
            BMSByte data = new BMSByte();
            data = ObjectMapper.Instance.MapBytes(data, result1);
            Binary bin = new Binary(timestep, false, data, Receivers.Target, opcode, false);
            ((UDPServer)server).Send(sender, bin, true);
        }
    }

    public void EnterWorldRequest(NetworkingPlayer sender, BMSByte stream)
    {
        string username = ObjectMapper.Instance.Map<string>(stream);
        string playerpass = ObjectMapper.Instance.Map<string>(stream);
        int charID = ObjectMapper.Instance.Map<int>(stream);

        string charname = "";
        
        //charname = PlayerHandler.GetCharNameIfOwned(charID, username);

        Debug.Log("[GameServer] Enter World Start: " + charname + ", username: " + username + ", charID: " + charID);

        if (VerifyLogin(username, playerpass) == true)
        {
            if (charname != "") //Char is Owned then Login
            {
                //ADD PLAYER TO LIST
                sender.Name = username;
                //PlayerHandler.LoginPlayer(charname, sender.NetworkId, sender);

                Debug.Log("[GameServer] Send Enter World Result");

                //Get Player Info
                //int x = PlayerHandler.GetPlayerByNetworkID(sender.NetworkId);
                //int gender1 = PlayerHandler.players[x].gender;
                ////int race1 = PlayerHandler.players[x].race;
                //int level1 = PlayerHandler.players[x].level;
                //int exp1 = PlayerHandler.players[x].currXP;

                //SEND PACKET: ENTER WORLD RESULT
                ulong timestep = server.Time.Timestep;
                int opcode = MessageGroupIds.START_OF_GENERIC_IDS + GameOpcodes.PKT_EnterWorldResult;
                BMSByte data = new BMSByte();
                data = ObjectMapper.Instance.MapBytes(data, 1, charname, gender1, race1, level1, exp1);
                Binary bin = new Binary(timestep, false, data, Receivers.Target, opcode, false);
                ((UDPServer)server).Send(sender, bin, true);

                //Spawn Player
                SpawnPlayer(x, sender.NetworkId, true, sender);
            }
            else
            {
                Debug.Log("[GameServer] Enter World Error: Character was not owned.");
                ((IServer)server).Disconnect(sender, true);
            }
        }
        else
        {
            Debug.Log("[GameServer] Enter World Error: Login Failed.");
            ((IServer)server).Disconnect(sender, true);
        }
    }

    public void SpawnPlayer(int index1, uint netID, bool isClient, NetworkingPlayer clientPlayer)
    {
        MainThreadManager.Run(() =>
        {
            Debug.Log("[GameServer] Spawning Player: ");
        
            //
            var player1 = NetworkManager.Instance.InstantiatePlayer(index1);
            player1.networkObject.playerNetworkId = netID;

        });
    }

    public void SpawnServerPlayer()
    {
        int index1 = PlayerHandler.GetPlayerByCharname(bl_Utilz.SetGetCharname);

        SpawnPlayer(index1, server.Me.NetworkId, false, null);   //server.Me.NetworkId);
    }

    public bool IsCharNameValid(string charName1)
    {
        bool result1 = false;
        result1 = Regex.IsMatch(charName1, "[a-z0-9]+", RegexOptions.IgnoreCase);
        return result1;
    }

    public bool VerifyLogin(string username, string playerpass)
    {
        //Validate User/Pass
        return true;
    }

    #endregion



    private void PlayerDisconnected2(NetworkingPlayer player, NetWorker networker1)
    {
        try
        {
            if (isMainSceneServer == true)
            {
                uint playerNetID = player.NetworkId;
                //int i = PlayerHandler.GetPlayerByNetworkID(playerNetID);
                //if (i == -1) return;

                //string charname1 = PlayerHandler.players[i].charname;

                Debug.Log("[GameServer] Player disconnected netID: " + playerNetID);

                //DESTROY PLAYER
                foreach (var no in server.NetworkObjectList)
                {
                    if (no.Owner == player)
                    {
                        Debug.Log("[GameServer] Found DCed player, destroying: " + no.NetworkId);
                        networker1.NetworkObjectList.Remove(no);
                        no.Destroy();
                        return;
                    }
                }
            }
        }
        catch (Exception e)
        {}
    }

    private void PlayerConnected2(NetworkingPlayer player, NetWorker networker1)
    {
        try
        {
            Debug.Log("[GameServer] User Connected: " + player.Name + ". NetID: " + player.NetworkId);
        }
        catch (Exception e)
        {}
    }

    public void LoadServerScene()
    {
        Debug.Log("Server Loading Next Scene. IsMainServer: " + isMainSceneServer);

        //Temp Login Server Player
        server.Me.Name = "Admin";

        //Load Map Scene
        SceneManager.LoadScene(ServerSettings.sceneMap);
    }

    private void OnApplicationQuit()
    {
        //if (bl_Utilz.IsClientServer == 1) //Ignore on Clients
            //return;

        if (server != null)
            server.Disconnect(true);

        //WriteToLog.CloseFile();
        Debug.Log("[GameServer]Server Shutdown. Runtime: " + Time.time + " seconds.");
    }

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

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

    //LOAD SERVER
    private void OnLevelFinishedLoading(Scene scene, LoadSceneMode mode)
    {
        //Load Server Data
        Debug.Log("[GameServer] Started!");
    }

    public void KickPlayer(NetworkingPlayer player)
    {
        try
        {
            Debug.Log("[GameServer] KickPlayer: " + player.Ip);
            server.Disconnect(player, true);
        }
        catch (Exception ex)
        {
            Debug.Log("[GameServer] KickPlayer Error: " + ex.Message + " Trace: " + ex.StackTrace);
        }
    }

    void Dispose()
    {
        try
        {
            server.playerTimeout -= HandlePlayerTimeOut;
            server.textMessageReceived -= MessageReceived;
            server.playerConnected -= PlayerConnected2;
            server.playerDisconnected -= PlayerDisconnected2;
        }
        catch (Exception ex)
        {
            string temp = ex.Message;
        }
    }
}