public static string GeneratePlayerCommandsMessage(CmdState cmd)
{
NetworkingMessage msg = new NetworkingMessage(NetworkingMessageType.CMDS);
msg.content = ToJson(cmd);
return(ToJson(msg));
}
IEnumerator HandleClient()
{
while (true)
{
client.DispatchCallback(status);
int netMessagesCount = client.ReceiveMessagesOnConnection(connection, netMessages, maxMessages);
if (netMessagesCount > 0)
{
for (int i = 0; i < netMessagesCount; i++)
{
// ref NetworkingMessage netMessage = ref netMessages[i];
NetworkingMessage netMessage = netMessages[i];
Debug.Log("Message received from server - Channel ID: " + netMessage.channel + ", Data length: " + netMessage.length);
netMessage.Destroy();
}
}
Thread.Sleep(15);
yield return(null);
}
}
IEnumerator HandleServer()
{
while (true)
{
server.DispatchCallback(status);
int netMessagesCount = server.ReceiveMessagesOnListenSocket(listenSocket, netMessages, maxMessages);
if (netMessagesCount > 0)
{
for (int i = 0; i < netMessagesCount; i++)
{
// ref NetworkingMessage netMessage = ref netMessages[i];
NetworkingMessage netMessage = netMessages[i];
Debug.Log("Message received from - ID: " + netMessage.connection + ", Channel ID: " + netMessage.channel + ", Data length: " + netMessage.length);
netMessage.Destroy();
}
}
Thread.Sleep(15);
yield return(null);
}
}
public static string GenerateGameStateMessage(GameState gs)
{
NetworkingMessage msg = new NetworkingMessage(NetworkingMessageType.GAME_STATE);
msg.content = ToJson(gs);
return(ToJson(msg));
}
public static byte[] GenerateUnitCommandNetworkingMessage(UnitCommand uc)
{
NetworkingMessage nm = new NetworkingMessage();
nm.type = NetworkingMessageType.USER_COMMANDS;
nm.content = ToByteArray(uc);
return(ToByteArray(nm));
}
public static byte[] GenerateClientIDNetworkingMessage(uint id)
{
NetworkingMessage nm = new NetworkingMessage();
nm.type = NetworkingMessageType.SERVER_SEND_ID;
nm.content = ToByteArray(id);
return(ToByteArray(nm));
}
public static byte[] GenerateUsernameNetworkingMessage(string username)
{
NetworkingMessage nm = new NetworkingMessage();
nm.type = NetworkingMessageType.CLIENT_USERNAME;
nm.content = ToByteArray(username);
return(ToByteArray(nm));
}
public static string GenerateServerAcceptJoinMessage(GameStartInfo gsi)
{
NetworkingMessageType msgType = NetworkingMessageType.SERVER_JOIN_RESPONSE;
NetworkingMessage msg = new NetworkingMessage(msgType);
msg.content = ToJson(gsi);
return(ToJson(msg));
}
public static byte[] GenerateEntityDataNetworkingMessage(List <EntityData> ed, int frame)
{
NetworkingMessage nm = new NetworkingMessage();
nm.type = NetworkingMessageType.ENTITY_DATA;
nm.content = ToByteArray(ed);
nm.frame = frame;
return(ToByteArray(nm));
}
public static byte[] GenerateEntityStateNetworkingMessage(List <EntityState> es, int frame)
{
NetworkingMessage nm = new NetworkingMessage();
nm.type = NetworkingMessageType.ENTITY_STATE;
nm.content = ToByteArray(es);
nm.frame = frame;
return(ToByteArray(nm));
}
public static byte[] GeneratePlayerStateNetworkingMessage(List <PlayerState> ps, int frame)
{
NetworkingMessage nm = new NetworkingMessage();
nm.type = NetworkingMessageType.PLAYER_STATE;
nm.content = ToByteArray(ps);
nm.frame = frame;
return(ToByteArray(nm));
}
public static byte[] GenerateGameStateNetworkingMessage(GameState gs, int frame)
{
NetworkingMessage nm = new NetworkingMessage();
nm.type = NetworkingMessageType.GAME_STATE;
nm.content = ToByteArray(gs);
nm.frame = frame;
return(ToByteArray(nm));
}
public static byte[] GeneratePlayerDataNetworkingMessage(List <PlayerData> pd, int frame)
{
NetworkingMessage nm = new NetworkingMessage();
nm.type = NetworkingMessageType.PLAYER_DATA;
nm.content = ToByteArray(pd);
nm.frame = frame;
return(ToByteArray(nm));
}
void HandleGameState(NetworkingMessage inmsg)
{
GameState ngs = NetworkingMessageTranslator.ParseGameState(inmsg.content);
// TODO
// Add handling for out of place turns... this should never happen tho...
// Flag Update game runner
state = ClientState.BEGIN_ANIMATION;
newGameState = ngs;
}
public void AddMessage(NetworkingMessage message)
{
#if UNITY_ENABLE_COLLECTION_CHECKS
if (m_IncomingMessages.Ptr == null)
{
throw new NullReferenceException();
}
#endif
Debug.Log($"add - messageptr = {message.release}");
m_IncomingMessages->Add(message);
AddEvent(NetworkEvent.Type.Data);
}
public void readNetworkMessages()
{
if (netMessageCount > 0)
{
for (int i = 0; i < netMessageCount; i++)
{
ref NetworkingMessage netMessage = ref netMessages[i];
netMessage.CopyTo(messageDataBuffer);
uint connection = netMessage.connection; //who sent it
netMessage.Destroy();
Message m = Message.decipherMessage(messageDataBuffer);
HandleNetworkMessage(m);
}
}
void OnMessage(ref Valve.Sockets.NetworkingMessage netMessage)
{
// Debug.Log(String.Format("Message received server - ID: {0}, Channel ID: {1}, Data length: {2}", netMessage.connection, netMessage.channel, netMessage.length));
byte[] messageDataBuffer = new byte[netMessage.length];
netMessage.CopyTo(messageDataBuffer);
netMessage.Destroy();
try
{
NetworkingMessage msg = NetworkingMessageTranslator.ParseMessage(messageDataBuffer);
UInt32 clientID = netMessage.connection;
switch (msg.type)
{
case NetworkingMessageType.GAME_STATE:
GameState gs = (GameState)NetworkingMessageTranslator.ByteArrayToObject(msg.content);
Debug.Log("Server recieved game state: " + gs.state);
break;
case NetworkingMessageType.CLIENT_USERNAME:
string username = (string)NetworkingMessageTranslator.ByteArrayToObject(msg.content);
sgr.pm.UpdateUsername(clientID, username);
break;
case NetworkingMessageType.USER_COMMANDS:
UnitCommand uc = (UnitCommand)NetworkingMessageTranslator.ByteArrayToObject(msg.content);
Debug.Log("Server recieved unit command: " + uc.entityID);
sgr.ReceiveUnitCommand(uc);
break;
}
}
catch (Exception ex)
{
Debug.LogWarning(ex.ToString());
}
}
public bool PopMessage(out NetworkingMessage message)
{
if (m_IncomingMessages->Length > 0)
{
message = UnsafeUtility.ReadArrayElement <NetworkingMessage>(m_IncomingMessages->Ptr, 0);
if (m_IncomingMessages->Length > 1)
{
m_IncomingMessages->RemoveAtSwapBack <NetworkingMessage>(0);
}
Debug.Log($"pop - messageptr = {message.release}");
return(true);
}
message = default;
return(false);
}
void HandleAcceptJoin(NetworkingMessage inmsg)
{
GameStartInfo gsi = NetworkingMessageTranslator.ParseServerAcceptJoin(inmsg.content);
int playerID = gsi.playerID;
if (playerID > -1)
{
this.state = ClientState.JOIN_ACCEPTED;
Debug.Log("Client Joined Server. PlayerID is " + playerID + " ... Waiting for game to start");
playerController.playerID = playerID;
gr.UpdateTerrainSeed(gsi.terrainSeed);
}
else
{
Debug.Log("Client was not allowed to connect... Disconnecting");
SendDisconnect();
playerController.OnFailedToConnect();
}
}
void HandleIncomingData(ConnectionObject co, String data)
{
NetworkingMessage inmsg = NetworkingMessageTranslator.ParseMessage(data);
if (inmsg.type == NetworkingMessageType.CLIENT_JOIN)
{
HandleJoin(co, inmsg);
}
if (inmsg.type == NetworkingMessageType.DISCONNECT)
{
HandleDisconnect(co, inmsg);
}
if (inmsg.type == NetworkingMessageType.CMDS)
{
HandlePlayerCommands(co, inmsg);
}
}
void HandleIncomingData(String data)
{
NetworkingMessage inmsg = NetworkingMessageTranslator.ParseMessage(data);
Debug.Log("Client received : " + data);
if (inmsg.type == NetworkingMessageType.SERVER_JOIN_RESPONSE)
{
HandleAcceptJoin(inmsg);
}
if (inmsg.type == NetworkingMessageType.DISCONNECT)
{
HandleDisconnect(inmsg);
}
if (inmsg.type == NetworkingMessageType.GAME_STATE)
{
HandleGameState(inmsg);
}
}
void HandleJoin(ConnectionObject co, NetworkingMessage inmsg)
{
bool canJoin = PlayersCanJoin();
if (canJoin)
{
co.serverPlayerID = playerIDTracker++;
}
String outmsg = NetworkingMessageTranslator.GenerateServerAcceptJoinMessage(new GameStartInfo(co.serverPlayerID, gr.terrainSeed));
ch.BeginSend(co, outmsg);
// Apply game logic...
// If enough players begin game
if (CanStartGame())
{
state = ServerState.SETUP_GAME;
}
}
void Update()
{
if (client == null)
{
return;
}
client.DispatchCallback(status);
int netMessagesCount = client.ReceiveMessagesOnConnection(connection, netMessages, maxMessages);
if (netMessagesCount > 0)
{
for (int i = 0; i < netMessagesCount; i++)
{
ref NetworkingMessage netMessage = ref netMessages[i];
Debug.Log("Message received from server - Channel ID: " + netMessage.channel + ", Data length: " + netMessage.length);
netMessage.Destroy();
}
}
void HandlePlayerCommands(ConnectionObject co, NetworkingMessage inmsg)
{
CmdState cmd = NetworkingMessageTranslator.ParseShipCommands(inmsg.content);
if (state == ServerState.COMMAND)
{
bool valid = gr.AddPlayersCommands(cmd, co.serverPlayerID);
if (!valid)
{
//TODO
// Send msg back to client saying cmd are invalid
}
// CHECK IF ALL PLAYER CMDS ARE IN
// IF SO BEGIN PROCESSING
if (ReadyToProcess())
{
state = ServerState.PROCESSING;
Debug.Log("Beginning to process gamestate");
}
}
}
void Update()
{
if (networkClient != null)
{
networkClient.DispatchCallback(status);
int netMessagesCount = isServer ? networkClient.ReceiveMessagesOnListenSocket(listenSocket, netMessages, maxMessages) : networkClient.ReceiveMessagesOnConnection(connection, netMessages, maxMessages);
if (netMessagesCount > 0)
{
for (int i = 0; i < netMessagesCount; i++)
{
ref NetworkingMessage netMessage = ref netMessages[i];
Debug.Log("Message received from server - Channel ID: " + netMessage.channel + ", Data length: " + netMessage.length);
netMessage.CopyTo(messageDataBuffer);
netMessage.Destroy();
string result = Encoding.ASCII.GetString(messageDataBuffer);
messages.Add(result);
}
}
}
void HandleDisconnect(NetworkingMessage inmsg)
{
this.state = ClientState.DISCONNECTING;
EnableSafeToDisconnect();
}
void HandleDisconnect(ConnectionObject co, NetworkingMessage inmsg)
{
ch.CloseConnection(co);
// Modify Game Logic??
}
public static void ServerLoop()
{
Library.Initialize();
server = new NetworkingSockets();
Address address = new Address();
NetworkingUtils utils = new NetworkingUtils();
utils.SetDebugCallback(DebugType.Important, (type, message) => {
Console.WriteLine("Valve Debug - Type: {0}, Message: {1}", type, message);
});
unsafe {
int sendRateMin = 5 * 1024 * 1024;
int sendRateMax = MAX_UPLOAD;
int sendBufferSize = MAX_BUFFER;
utils.SetConfigurationValue(ConfigurationValue.SendRateMin, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&sendRateMin));
utils.SetConfigurationValue(ConfigurationValue.SendRateMax, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&sendRateMax));
utils.SetConfigurationValue(ConfigurationValue.SendBufferSize, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&sendBufferSize));
}
address.SetAddress("::0", port);
uint listenSocket = server.CreateListenSocket(ref address);
uint pollGroup = server.CreatePollGroup();
Console.WriteLine($"Server {SERVER_NAME} started Listening on port {port} for maximum of {MAX_PLAYERS} players\nEnforcing maps is {ENFORCE_MAPS}");
StartAnnouncing();
StatusCallback status = (ref StatusInfo info, IntPtr context) => {
switch (info.connectionInfo.state)
{
case ConnectionState.None:
break;
case ConnectionState.Connecting:
server.AcceptConnection(info.connection);
server.SetConnectionPollGroup(pollGroup, info.connection);
break;
case ConnectionState.Connected:
Console.WriteLine("Client connected - IP: " + info.connectionInfo.address.GetIP());
bool openSlot = false;
for (byte i = 0; i < MAX_PLAYERS; i++)
{
if (players[i] == null)
{
players[i] = new Player(i, info.connection, info.connectionInfo.address);
byte[] versionNumber = ASCIIEncoding.ASCII.GetBytes(VERSION_NUMBER);
byte[] versionMessage = new byte[versionNumber.Length + 1];
versionMessage[0] = (byte)OpCode.VersionNumber;
Array.Copy(versionNumber, 0, versionMessage, 1, versionNumber.Length);
server.SendMessageToConnection(players[i].connection, versionMessage, SendFlags.Reliable | SendFlags.NoNagle);
if (ENFORCE_MAPS)
{
server.SendMessageToConnection(players[i].connection, mapListBytes, SendFlags.Reliable);
server.SendMessageToConnection(players[i].connection, GetCurrentMapHashMessage(), SendFlags.Reliable);
}
foreach (Player player in players)
{
if (player != null && player != players[i])
{
server.SendMessageToConnection(players[i].connection, new byte[] { (byte)OpCode.Connect, player.playerID }, SendFlags.Reliable);
server.SendMessageToConnection(player.connection, new byte[] { (byte)OpCode.Connect, i }, SendFlags.Reliable);
if (player.usernameMessage != null)
{
server.SendMessageToConnection(players[i].connection, player.usernameMessage, SendFlags.Reliable);
}
if (player.allGearUploaded)
{
foreach (KeyValuePair <string, byte[]> value in player.gear)
{
server.SendMessageToConnection(players[i].connection, value.Value, SendFlags.Reliable);
}
}
}
}
server.FlushMessagesOnConnection(players[i].connection);
openSlot = true;
break;
}
}
if (!openSlot)
{
server.CloseConnection(info.connection);
}
break;
case ConnectionState.ClosedByPeer:
RemovePlayer(info.connection);
break;
}
};
#if VALVESOCKETS_SPAN
MessageCallback messageCallback = (in NetworkingMessage netMessage) => {
byte[] messageData = new byte[netMessage.length];
netMessage.CopyTo(messageData);
Player sendingPlayer = null;
foreach (Player player in players)
{
if (player != null && player.connection == netMessage.connection)
{
sendingPlayer = player;
break;
}
}
if (sendingPlayer != null)
{
ProcessMessage(messageData, sendingPlayer.playerID, server);
}
};
#else
const int maxMessages = 256;
NetworkingMessage[] netMessages = new NetworkingMessage[maxMessages];
#endif
while (RUNNING)
{
server.DispatchCallback(status);
#if VALVESOCKETS_SPAN
server.ReceiveMessagesOnPollGroup(pollGroup, messageCallback, 256);
#else
int netMessagesCount = server.ReceiveMessagesOnConnection(listenSocket, netMessages, maxMessages);
if (netMessagesCount > 0)
{
for (int i = 0; i < netMessagesCount; i++)
{
ref NetworkingMessage netMessage = ref netMessages[i];
byte[] messageData = new byte[netMessage.length];
netMessage.CopyTo(messageData);
Player sendingPlayer = null;
foreach (Player player in players)
{
if (player != null && player.connection == netMessage.connection)
{
sendingPlayer = player;
break;
}
}
//Console.WriteLine("Recieved packet from connection {0}, sending player null: {1}", netMessage.connection, sendingPlayer == null);
if (sendingPlayer != null)
{
ProcessMessage(messageData, sendingPlayer.playerID, server);
}
netMessage.Destroy();
}
}
#endif
mapVotes.Clear();
total_players = 0;
foreach (Player player in players)
{
if (player != null)
{
total_players++;
if (player.timeoutWatch.ElapsedMilliseconds > 15000)
{
Console.WriteLine($"{player.playerID} has been timed out for not responding for 15 seconds");
RemovePlayer(player.connection, player.playerID, true);
}
if (!mapVotes.ContainsKey(player.currentVote))
{
mapVotes.Add(player.currentVote, 1);
}
else
{
mapVotes[player.currentVote]++;
}
}
}
// Handle map voting and map enforcement
if (ENFORCE_MAPS)
{
if (total_players == 0)
{
currentMapHash = "1";
}
bool startNewTimer = false;
if (mapVotes.ContainsKey("current"))
{
if (mapVotes["current"] < (int)Math.Ceiling((float)total_players / 2))
{
if (!mapVoteTimer.IsRunning)
{
startNewTimer = true;
}
}
}
else if (!mapVoteTimer.IsRunning && total_players > 0)
{
startNewTimer = true;
}
if (startNewTimer)
{
mapVoteTimer.Restart();
byte[] mapVoteMsg = new byte[] { (byte)OpCode.MapVote, 0, 0 };
foreach (Player player in players)
{
if (player != null)
{
server.SendMessageToConnection(player.connection, mapVoteMsg, SendFlags.Reliable);
}
}
}
if (mapVoteTimer.IsRunning && mapVoteTimer.ElapsedMilliseconds > 30000 && total_players > 0)
{
mapVoteTimer.Stop();
Tuple <string, int> mostVoted = null;
foreach (var item in mapVotes)
{
if (!item.Key.Equals("current"))
{
if (mostVoted == null || mostVoted.Item2 < item.Value)
{
mostVoted = Tuple.Create <string, int>(item.Key, item.Value);
}
}
}
currentMapHash = mostVoted.Item1;
byte[] newMapMessage = GetCurrentMapHashMessage();
foreach (Player player in players)
{
if (player != null)
{
server.SendMessageToConnection(player.connection, newMapMessage, SendFlags.Reliable);
player.currentVote = "current";
}
}
}
else if (total_players == 0)
{
mapVoteTimer.Stop();
}
}
}
void OnMessage(ref Valve.Sockets.NetworkingMessage netMessage)
{
// Debug.Log(String.Format("Message received client - ID: {0}, Channel ID: {1}, Data length: {2}", netMessage.connection, netMessage.channel, netMessage.length));
byte[] messageDataBuffer = new byte[netMessage.length];
netMessage.CopyTo(messageDataBuffer);
netMessage.Destroy();
try
{
NetworkingMessage msg = NetworkingMessageTranslator.ParseMessage(messageDataBuffer);
switch (msg.type)
{
case NetworkingMessageType.GAME_STATE:
GameState gs = (GameState)NetworkingMessageTranslator.ByteArrayToObject(msg.content);
Instance.cgr.ReceiveGameState(gs, msg.frame);
break;
case NetworkingMessageType.SERVER_SEND_ID:
Instance.cgr.playerID = (uint)NetworkingMessageTranslator.ByteArrayToObject(msg.content);
Debug.Log("Client received client ID: " + Instance.cgr.playerID);
break;
case NetworkingMessageType.ENTITY_DATA:
List <EntityData> ed = (List <EntityData>)NetworkingMessageTranslator.ByteArrayToObject(msg.content);
Instance.cgr.ReceiveEntityData(ed, msg.frame);
break;
case NetworkingMessageType.ENTITY_STATE:
List <EntityState> es = (List <EntityState>)NetworkingMessageTranslator.ByteArrayToObject(msg.content);
Instance.cgr.ReceiveEntityState(es, msg.frame);
break;
case NetworkingMessageType.PLAYER_DATA:
List <PlayerData> pd = (List <PlayerData>)NetworkingMessageTranslator.ByteArrayToObject(msg.content);
Instance.cgr.ReceivePlayerData(pd, msg.frame);
break;
case NetworkingMessageType.PLAYER_STATE:
List <PlayerState> ps = (List <PlayerState>)NetworkingMessageTranslator.ByteArrayToObject(msg.content);
Instance.cgr.ReceivePlayerState(ps, msg.frame);
break;
}
}
catch (Exception ex)
{
Debug.LogWarning(ex.ToString());
}
}
static void Run(CancellationTokenSource cts)
{
ushort port = 8080;
NetworkingSockets server = new NetworkingSockets();
Address address = new Address();
address.SetAddress("::0", port);
uint listenSocket = server.CreateListenSocket(ref address);
StatusCallback status = (info, context) => {
switch (info.connectionInfo.state)
{
case ConnectionState.None:
break;
case ConnectionState.Connecting:
server.AcceptConnection(info.connection);
break;
case ConnectionState.Connected:
Console.WriteLine("Client connected - ID: " + info.connection + ", IP: " + info.connectionInfo.address.GetIP());
break;
case ConnectionState.ClosedByPeer:
server.CloseConnection(info.connection);
Console.WriteLine("Client disconnected - ID: " + info.connection + ", IP: " + info.connectionInfo.address.GetIP());
break;
}
};
#if VALVESOCKETS_SPAN
MessageCallback message = (in NetworkingMessage netMessage) => {
Console.WriteLine("Message received from - ID: " + netMessage.connection + ", Channel ID: " + netMessage.channel + ", Data length: " + netMessage.length);
};
#else
const int maxMessages = 20;
NetworkingMessage[] netMessages = new NetworkingMessage[maxMessages];
#endif
while (!cts.IsCancellationRequested)
{
server.DispatchCallback(status);
#if VALVESOCKETS_SPAN
server.ReceiveMessagesOnListenSocket(listenSocket, message, 20);
#else
int netMessagesCount = server.ReceiveMessagesOnListenSocket(listenSocket, netMessages, maxMessages);
if (netMessagesCount > 0)
{
for (int i = 0; i < netMessagesCount; i++)
{
ref NetworkingMessage netMessage = ref netMessages[i];
Console.WriteLine("Message received from - ID: " + netMessage.connection + ", Channel ID: " + netMessage.channel + ", Data length: " + netMessage.length);
netMessage.Destroy();
}
}
#endif
Thread.Sleep(15);
}
