protected void HandleJoinChannel(Player mSender, Packet mCommand, int channel)
{
try
{
if (!mSender.IsInChannel())
{
mSender.currentChannel = channel;
//=====================================================//
tcpPlayers[mSender.tcpClient] = mSender;
//====================================================//
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.Write(channel);
writer.Write(mSender.Serialize());
mSender.Send(SendTo.All, writer.GetBuffer(), Broadcast.Channel, null, ProtocolType.Tcp, null, null);
}
onPlayerJoinedChannel(mSender);
}
else
{
SendErrorMessage(mSender, mCommand, "ERROR: You are already joined to a channel.");
}
}
catch { Debug.LogError("Corrupted Bytes"); }
}
protected void HandleInstantiatePlayer(Player mSender, Packet mCommand, Broadcast broadcast, Vector3 position, Quaternion rotation, string playerPrefab)
{
try
{
if (mSender.IsInChannel())
{
Enqueue(() =>
{
if (Instantiate(mSender, position, rotation, playerPrefab))
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.Write(position);
writer.Write(rotation);
writer.Write(playerPrefab);
writer.Write(mSender.Serialize());
//============================================================================================
mSender.Send(SendTo.All, writer.GetBuffer(), broadcast, null, ProtocolType.Tcp, null, null);
}
}
else
{
SendErrorMessage(mSender, Packet.InstantiatePlayer, "SERVER: -> Failed to instantiate Player, unable to load prefab");
}
}, ref monoBehaviourActions);
}
else
{
SendErrorMessage(mSender, mCommand, "ERROR: You are not on a channel/room.");
}
}
catch { Debug.LogError("Corrupted Bytes"); }
}
protected void HandleNavMeshAgent(Player mSender, Packet mCommand, Vector3 inputPoint)
{
Enqueue(() =>
{
var nMa = playersState[mSender.tcpClient].navAgent;
if (nMa.CalculatePath(inputPoint, nMa.path))
{
if (nMa.pathStatus == UnityEngine.AI.NavMeshPathStatus.PathComplete)
{
nMa.destination = inputPoint;
//======================================================================================================
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.Write(mSender.ID);
writer.Write(inputPoint);
//===================================================================================================
mSender.Send(SendTo.All, writer.GetBuffer(), Broadcast.Channel, null, ProtocolType.Tcp, null, null);
}
}
else
{
SendErrorMessage(mSender, mCommand, "ERROR: Invalid Path. Solution: Clear And Re-Bake IA Path. the scenes between client and server must be identical.");
}
}
else
{
SendErrorMessage(mSender, mCommand, "ERROR: Invalid Path. Solution: Clear And Re-Bake IA Path. the scenes between client and server must be identical.");
}
}, ref monoBehaviourActions);
}
protected void HandleJoinRoom(Player mSender, Packet mCommand, int roomID)
{
try
{
if (mSender.IsInChannel() && !mSender.IsInRoom())
{
onPlayerJoinedRoom(mSender);
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.Write(roomID);
writer.Write(mSender.Serialize());
//================================================================================================\\
mSender.Send(SendTo.Only, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, null);
}
Player _player = tcpPlayers[mSender.tcpClient];
_player.currentRoom = roomID;
tcpPlayers[mSender.tcpClient] = _player;
}
else
{
SendErrorMessage(mSender, mCommand, "WARNING: You already in channel?/or/You are trying to get rooms from within a room, this function is not necessarily prohibited, you can change the behavior on the server, but it is not recommended to obtain the list of rooms within a room, in order to save bandwidth.");
}
}
catch { Debug.LogError("Corrupted Bytes"); }
}
void OnAgent()
{
lastPosition = transform.position;
lastRotation = transform.rotation;
try
{
navResyncTime += Time.deltaTime;
if (navResyncTime > 2f)
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(Packet.navMeshResync);
writer.Write(_Player.ID);
writer.Write(transform.position);
writer.Write(transform.eulerAngles);
//=========================================================================================\\
_Player.Send(SendTo.Only, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, null);
}
navResyncTime = 0;
}
}
catch
{
enabled = false;
}
}
//============================================================================================================//
protected static bool InitConnect()
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(Packet.Connected);
Send(writer.GetBuffer());
}
return(true);
}
private void HandlePlayerDisconnected(Player mSender)
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(Packet.PlayerDisconnected);
writer.Write(mSender.Serialize());
mSender.Send(SendTo.Others, writer.GetBuffer(), Broadcast.Channel, null, ProtocolType.Tcp, null, null);
}
}
protected void HandleVoiceChat(Player mSender, Packet mCommand, int lastPos, byte[] buffer, IPEndPoint onlyEndPoint)
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.Write(lastPos);
writer.Write(buffer);
//SendUDP(SendTo.Others, writer.GetBuffer(), mSender.SendToChannel(), onlyEndPoint);
}
}
public static void SendDisconnect(Player mSocket, string reason)
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(Packet.Disconnected);
writer.Write(reason);
//======================================================================================\\
mSocket.Send(SendTo.Only, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, null);
}
}
public static void SendErrorMessage(Player mSocket, Packet packet, string message)
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(Packet.Fail);
writer.WritePacket(packet);
writer.Write(message);
//========================================================\\
mSocket.Send(SendTo.Only, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, null);
}
}
protected static byte[] DBLogin(string user, string pass)
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(Packet.Database);
writer.WritePacket(Packet.Login);
writer.Write(user);
writer.Write(pass);
return(writer.GetBuffer());
}
}
void Response(Player mSocket, Packet packetToResponse, SendTo send, object[] response)
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(Packet.Database);
writer.WritePacket(packetToResponse);
writer.Write(response.Serialize());
//========================================================================================\\
mSocket.Send(send, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, null);
}
}
void RPC()
{
using (NeutronWriter streamParams = new NeutronWriter())
{
streamParams.Write(transform.position);
streamParams.Write(transform.rotation);
streamParams.Write(GetRigidbody.velocity);
streamParams.Write(GetRigidbody.angularVelocity);
//======================================================================================================================================
Neutron.RPC(isMine, 255, ValidationPacket.Movement, syncTime, streamParams, sendTo, false, Broadcast.Channel, (ProtocolType)(int)protocolType);
}
}
protected void HandleCreateRoom(Player mSender, Packet mCommand, string roomName, int maxPlayers, string Password, bool isVisible, bool JoinOrCreate, byte[] options)
{
try
{
if (mSender.IsInChannel() && !mSender.IsInRoom())
{
Room nRoom = new Room(roomID, roomName, maxPlayers, string.IsNullOrEmpty(Password), isVisible, options);
//=======================================================================================================
void CreateRoom()
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.Write(nRoom.Serialize());
mSender.Send(SendTo.Only, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, null);
}
//=========================================================
serverChannels[mSender.currentChannel]._rooms.Add(nRoom);
//=========================================================
Player _player = tcpPlayers[mSender.tcpClient];
_player.currentRoom = roomID;
tcpPlayers[mSender.tcpClient] = _player;
//=========================================================
roomID++;
}
if (!JoinOrCreate)
{
CreateRoom();
}
else
{
if (!serverChannels[mSender.currentChannel]._rooms.Any(x => x.roomName == roomName))
{
CreateRoom();
}
else
{
HandleJoinRoom(mSender, Packet.JoinRoom, roomID);
}
}
}
else
{
SendErrorMessage(mSender, mCommand, "ERROR: You cannot create a room by being inside one. Call LeaveRoom or you not within a channel");
}
}
catch { Debug.LogError("Corrupted Bytes"); }
}
protected void HandleConfirmation(Player mSocket, Packet mCommand)
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.Write("Status: OK");
writer.Write(mSocket.ID);
mSocket.Send(SendTo.Only, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, (ia) =>
{
if (mSocket.EndSend(ia))
{
}
});
}
}
public static void SendProperties(Player player, NeutronSyncBehaviour properties, SendTo sendTo, Broadcast broadcast)
{
NeutronSyncBehaviour _properties = properties;
//=======================================================\\
string props = JsonUtility.ToJson(_properties);
//=======================================================\\
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(Packet.playerProps);
writer.Write(player.ID);
writer.Write(props);
player.Send(sendTo, writer.GetBuffer(), broadcast, null, ProtocolType.Tcp, null, null);
}
}
// Update is called once per frame
void Update()
{
if (Neutron.IsMine)
{
if (GetParameters(out object[] parameters))
{
using (NeutronWriter streamParams = new NeutronWriter())
{
streamParams.Write(parameters.Serialize());
//======================================================================================================================================
Neutron.RPC(Neutron.NeutronObject, 254, ValidationPacket.None, syncTime, streamParams, SendTo.Others, false, Broadcast.Channel, (ProtocolType)(int)protocolType);
}
}
}
}
protected void HandleSendChat(Player mSender, Packet mCommand, Broadcast broadcast, string message)
{
try
{
using (NeutronWriter writer = new NeutronWriter())
{
Player pSender = mSender;
writer.WritePacket(mCommand);
writer.Write(message);
writer.Write(pSender.Serialize());
//==============================================================================================\\
mSender.Send(SendTo.All, writer.GetBuffer(), broadcast, null, ProtocolType.Tcp, null, null);
}
}
catch { Debug.LogError("Corrupted Bytes"); }
}
protected void HandleGetCached(Player mSender, CachedPacket packetToSendCache)
{
List <byte[]> iP = new List <byte[]>();
//========================================================\\
if (packetToSendCache == CachedPacket.ResyncInstantiate)
{
foreach (var _ps in playersState.Values)
{
if (_ps._Player.Equals(mSender))
{
continue;
}
if (_ps._Player.currentChannel == mSender.currentChannel)
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.Write(_ps.lastPosition);
writer.Write(_ps.lastRotation);
writer.Write(_ps._prefabName);
writer.Write(_ps._Player.Serialize());
//========================================================\\
iP.Add(writer.GetBuffer());
}
}
else
{
continue;
}
}
OnEndBuffer();
}
void OnEndBuffer()
{
if (iP.Count > 0)
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(CachedPacket.ResyncInstantiate);
writer.Write(iP.ToArray().Serialize());
//=============================================================================\\
mSender.Send(SendTo.Only, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, null);
}
}
}
}
protected static void SendRPC(NeutronObject mThis, int RPCID, ValidationPacket validationType, object[] parameters, SendTo sendTo, bool cached, ProtocolType protocolType, Broadcast broadcast)
{
using (NeutronWriter writer = new NeutronWriter())
{
object[] bArray = { mThis.Infor.ownerID, parameters };
//==========================================================================================================//
writer.WritePacket(Packet.RPC);
writer.WritePacket(broadcast);
writer.Write(RPCID);
writer.WritePacket(sendTo);
writer.WritePacket(validationType);
writer.Write(cached);
writer.Write(bArray.Serialize());
//==========================================================================================================//
Send(writer.GetBuffer(), protocolType);
}
}
protected void HandleRPC(Player mSender, Packet mCommand, Broadcast broadcast, int executeID, SendTo sendMode, ValidationPacket vType, bool Cached, byte[] parameters, IPEndPoint onlyEndPoint)
{
try
{
if (mSender.IsInChannel())
{
object[] _array = parameters.DeserializeObject <object[]>();
object[] mParameters = (object[])_array[1];
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.Write(executeID);
writer.Write(parameters);
ExecuteValidation(vType, new NeutronReader((byte[])mParameters[0]), mSender);
if (onlyEndPoint != null)
{
mSender.Send(sendMode, writer.GetBuffer(), broadcast, onlyEndPoint, ProtocolType.Udp, null, (ia) =>
{
_UDPSocket.EndSend(ia);
});
}
else
{
mSender.Send(sendMode, writer.GetBuffer(), broadcast, null, ProtocolType.Tcp, null, (ia) =>
{
mSender.EndSend(ia);
});
}
}
}
else
{
SendErrorMessage(mSender, Packet.SendChat, "ERROR: You are not on a channel/room.");
}
}
catch
{
Debug.LogError("Corrupted Bytes: lenght" + parameters.Length);
}
}
protected void HandleNickname(Player mSender, string Nickname)
{
if (tcpPlayers.TryGetValue(mSender.tcpClient, out Player oldValue))
{
mSender.Nickname = Nickname;
if (tcpPlayers.TryUpdate(mSender.tcpClient, mSender, oldValue))
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(Packet.Nickname);
//======================================================================================\\
mSender.Send(SendTo.Only, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, null);
}
}
else
{
SendErrorMessage(mSender, Packet.Nickname, "ERROR: Failed to Change Nickname");
}
}
}
protected void HandleGetRooms(Player mSender, Packet mCommand)
{
try
{
if (mSender.IsInChannel() && !mSender.IsInRoom())
{
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.Write(serverChannels[mSender.currentChannel]._rooms.ToArray().Serialize());
mSender.Send(SendTo.Only, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, null);
}
}
else
{
SendErrorMessage(mSender, mCommand, "WARNING: You already in channel?/or/You are trying to get rooms from within a room, this function is not necessarily prohibited, you can change the behavior on the server, but it is not recommended to obtain the list of rooms within a room, in order to save bandwidth.");
}
}
catch { Debug.LogError("Corrupted Bytes"); }
}
protected void HandleDestroyPlayer(Player mSender, Packet mCommand)
{
if (playersState.TryRemove(mSender.tcpClient, out PlayerState removedState))
{
PlayerState obj = removedState;
//=======================================================\\
Enqueue(() => Destroy(obj.gameObject), ref monoBehaviourActions);
//=======================================================\\
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
mSender.Send(SendTo.Only, writer.GetBuffer(), Broadcast.None, null, ProtocolType.Tcp, null, null);
}
onPlayerDestroyed(mSender);
}
else
{
SendErrorMessage(mSender, mCommand, "ERROR: Player already destroyed!");
}
}
protected void HandleSendInput(Player mSender, Packet mCommand, byte[] Input)
{
try
{
if (mSender.IsInChannel())
{
Player playerToMove = mSender;
//============================================================================================\\
SerializableInput authInput = Input.DeserializeObject <SerializableInput>();
//============================================================================================\\
Rigidbody rbPlayer = playersState[playerToMove.tcpClient].rigidBody;
//============================================================================================\\
Vector3 newPos = new Vector3(authInput.Horizontal, 0, authInput.Vertical);
//============================================================================================\\
Enqueue(() =>
{
rbPlayer.velocity = (newPos * MOVE_SPEED * Time.deltaTime);
//============================================================================================\\
Vector3 velocity = rbPlayer.velocity;
//============================================================================================\\
SerializableInput nInput = new SerializableInput(authInput.Horizontal, authInput.Vertical, new SerializableVector3(velocity.x, velocity.y, velocity.z));
//============================================================================================\\
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.Write(nInput.Serialize());
//============================================================================================\\
//SendTCP(mSender.tcpClient, SendTo.Only, writer.GetBuffer());
}
}, ref monoBehaviourActions);
}
else
{
SendErrorMessage(mSender, Packet.SendChat, "ERROR: You are not on a channel/room.");
}
}
catch
{
Debug.LogError("Corrupted Bytes");
}
}
protected void HandleOnCustomPacket(Player mSender, Packet mCommand, Packet packet, byte[] customParams)
{
try
{
Packet customPacket = packet;
byte[] customPacketParams = customParams;
using (NeutronWriter writer = new NeutronWriter())
{
writer.WritePacket(mCommand);
writer.WritePacket(customPacket);
writer.Write(customPacketParams);
object[] validationParameters = customPacketParams.DeserializeObject <object[]>();
//PacketValidation(customPacket, new NeutronReader((byte[])validationParameters[0]), mSender);
//SendTCP(mSender.tcpClient, SendTo.Only, writer.GetBuffer());
}
}
catch
{
Debug.LogError("Corrupted Bytes");
}
}
