Created
October 6, 2020 16:50
-
-
Save HolyFot/39b46bfae5d3b613164adbb9970cfa90 to your computer and use it in GitHub Desktop.
Starter Forge Client & Server Stuff
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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") | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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; | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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; | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment