void Sync(NeutronReader streamReader)
{
using (streamReader)
{
newPosition = streamReader.ReadVector3();
newRotation = streamReader.ReadQuaternion();
newVelocity = streamReader.ReadVector3();
newAngularVelocity = streamReader.ReadVector3();
}
}
public void OnUDPReceive(IAsyncResult ia)
{
try
{
byte[] data = _UDPSocket.EndReceive(ia, ref _IEPRef);
//======================================================================\\
_UDPSocket.BeginReceive(OnUDPReceive, null);
//======================================================================\\
if (data.Length > 0)
{
lock (lockerUDPEndPoints)
{
if (!udpEndPoints.Contains(_IEPRef))
{
udpEndPoints.Add(_IEPRef);
}
}
//=========================================================================\\
byte[] decompressedBuffer = data.Decompress(COMPRESSION_MODE, data.Length);
//==========================================================================\\
using (NeutronReader mReader = new NeutronReader(decompressedBuffer))
{
Packet mCommand = mReader.ReadPacket <Packet>();
if (GetPlayer(_IEPRef, out Player Sender))
{
switch (mCommand)
{
case Packet.RPC:
HandleRPC(Sender, mCommand, mReader.ReadPacket <Broadcast>(), mReader.ReadInt32(), mReader.ReadPacket <SendTo>(), mReader.ReadPacket <ValidationPacket>(), mReader.ReadBoolean(), mReader.ReadBytes(4096), Sender.tcpClient.RemoteEndPoint());
break;
case Packet.OnCustomPacket:
break;
case Packet.VoiceChat:
HandleVoiceChat(Sender, mCommand, mReader.ReadInt32(), mReader.ReadBytes(4096), Sender.tcpClient.RemoteEndPoint());
break;
}
}
}
}
}
catch (SocketException ex)
{
LoggerError(ex.ErrorCode);
//===========================
RenitializeWhenException(_IEPRef);
}
}
public static void OnUDPReceive(IAsyncResult ia)
{
try
{
byte[] data = _UDPSocket.EndReceive(ia, ref _IEPRef);
//==============================================================================================\\
_UDPSocket.BeginReceive(OnUDPReceive, null);
//==============================================================================================\\
if (data.Length > 0)
{
byte[] decompressedBuffer = data.Decompress(COMPRESSION_MODE, data.Length);
//==================================================================================\\
using (NeutronReader mReader = new NeutronReader(decompressedBuffer))
{
Packet mCommand = mReader.ReadPacket <Packet>();
switch (mCommand)
{
case Packet.SendInput:
SerializableInput nInput = mReader.ReadBytes(2048).DeserializeObject <SerializableInput>();
//================================================================================================================================
SerializableVector3 nVelocity = nInput.Vector;
//================================================================================================================================
Vector3 velocity = new Vector3(nVelocity.x, nVelocity.y, nVelocity.z);
//================================================================================================================================
//Neutron.Enqueue(() => playerRB.velocity = velocity);
break;
case Packet.RPC:
HandleRPC(mReader.ReadInt32(), mReader.ReadBytes(4096));
break;
case Packet.VoiceChat:
HandleVoiceChat(mReader.ReadInt32(), mReader.ReadBytes(4096));
break;
}
}
}
else
{
LoggerError("UDP Error");
}
}
catch (SocketException ex) { LoggerError(ex.Message + ":" + ex.ErrorCode); }
}
public void OnUDPVoiceReceive(IAsyncResult ia)
{
try
{
byte[] data = _UDPVoiceSocket.EndReceive(ia, ref _IEPRefVoice);
//=========================================================================\\
_UDPVoiceSocket.BeginReceive(OnUDPVoiceReceive, null);
//=========================================================================\\
if (data.Length > 0)
{
lock (lockerUDPEndPointsVoices)
{
if (!udpEndPointsVoices.Contains(_IEPRefVoice))
{
udpEndPointsVoices.Add(_IEPRefVoice);
}
}
//=========================================================================\\
using (NeutronReader reader = new NeutronReader(data))
{
int port = reader.ReadInt32();
byte[] buffer = reader.ReadBytes(4092);
//=========================================================================\\
if (GetPlayer(new IPEndPoint(_IEPRefVoice.Address, port), out Player Sender))
{
SendVoice(SendTo.Others, buffer, Sender.tcpClient.RemoteEndPoint(), _IEPRefVoice, tcpPlayers.Values.ToArray());
}
}
}
else
{
}
}
catch (Exception ex)
{
LoggerError(ex.Message);
//============================================
RenitializeVoiceWhenException(_IEPRefVoice);
}
}
public static void ServerMovementValidation(NeutronReader paramsReader, Player mSocket)
{
if (!ServerCheatDetection.enabled)
{
ServerCheatDetection.enabled = true;
}
if (ServerCheatDetection.enabled)
{
Vector3 newPosition = paramsReader.ReadVector3();
Quaternion newRotation = paramsReader.ReadQuaternion();
//Vector3 newVelocity = paramsReader.ReadVector3();
//Vector3 newAngularVelocity = paramsReader.ReadVector3();
//===========================================================\\
PlayerState statePlayer = mSocket.GetStateObject();
if (statePlayer != null)
{
statePlayer.lastPosition = newPosition;
statePlayer.lastRotation = newRotation;
statePlayer.mFrequency++;
}
}
}
void Sync(NeutronReader streamReader)
{
using (streamReader)
{
object[] parameters = streamReader.ReadBytes(8192).DeserializeObject <object[]>();
for (int i = 0; i < parameters.Length; i++)
{
AnimatorControllerParameter parameter = GetAnimator.GetParameter(i);
if (parameter.type == AnimatorControllerParameterType.Bool)
{
GetAnimator.SetBool(parameter.name, (bool)parameters[i]);
}
else if (parameter.type == AnimatorControllerParameterType.Float)
{
GetAnimator.SetFloat(parameter.name, (float)parameters[i]);
}
else if (parameter.type == AnimatorControllerParameterType.Int)
{
GetAnimator.SetInteger(parameter.name, (int)parameters[i]);
}
}
}
}
public void ExecuteValidation(ValidationPacket vType, NeutronReader paramsReader, Player mSocket)
{
using (paramsReader)
{
try
{
switch (vType)
{
case ValidationPacket.Movement:
CustomServerValidation.ServerMovementValidation(paramsReader, mSocket); // Don't change that.
break;
case ValidationPacket.None:
// Your custom validation script.
break;
}
}
catch (Exception ex)
{
NeutronServerFunctions.SendDisconnect(mSocket, ex.Message);
return; // Return to prevent sending to other players. do not use return within the queue (DO NOT WORK).
}
}
}
public virtual void OnCreatedRoom(Room room, NeutronReader options)
{
}
protected static void HandleCreateRoom(Room room, NeutronReader options)
{
Neutron.Enqueue(() => Neutron.Fire(Neutron.onCreatedRoom, new object[] { room, options }), ref monoBehaviourActions);
}
void ProcessClientData(TcpClient mSocket, byte[] bufferCopy, int length, IPEndPoint endPoint)
{
try
{
using (NeutronReader mReader = new NeutronReader(bufferCopy))
{
Packet mCommand = mReader.ReadPacket <Packet>();
if (GetPlayer(mSocket, out Player Sender))
{
switch (mCommand)
{
case Packet.Connected:
HandleConfirmation(Sender, mCommand);
break;
case Packet.Nickname:
HandleNickname(Sender, mReader.ReadString());
break;
case Packet.SendChat:
HandleSendChat(Sender, mCommand, mReader.ReadPacket <Broadcast>(), mReader.ReadString());
break;
case Packet.InstantiatePlayer:
HandleInstantiatePlayer(Sender, mCommand, mReader.ReadPacket <Broadcast>(), mReader.ReadVector3(), mReader.ReadQuaternion(), mReader.ReadString());
break;
case Packet.SendInput:
HandleSendInput(Sender, mCommand, mReader.ReadBytes(length));
break;
case Packet.RPC:
HandleRPC(Sender, mCommand, mReader.ReadPacket <Broadcast>(), mReader.ReadInt32(), mReader.ReadPacket <SendTo>(), mReader.ReadPacket <ValidationPacket>(), mReader.ReadBoolean(), mReader.ReadBytes(length), endPoint);
break;
case Packet.OnCustomPacket:
HandleOnCustomPacket(Sender, mCommand, mReader.ReadPacket <Packet>(), mReader.ReadBytes(length));
break;
case Packet.Database:
Packet dbPacket = mReader.ReadPacket <Packet>();
switch (dbPacket)
{
case Packet.Login:
if (!isLoggedin(mSocket))
{
string username = mReader.ReadString();
string passsword = mReader.ReadString();
Enqueue(() => StartCoroutine(Login(Sender, username, passsword)), ref monoBehaviourActions);
}
else
{
SendErrorMessage(Sender, mCommand, "You are already logged in.");
}
break;
}
break;
case Packet.GetChannels:
HandleGetChannels(Sender, mCommand);
break;
case Packet.JoinChannel:
HandleJoinChannel(Sender, mCommand, mReader.ReadInt32());
break;
case Packet.GetChached:
HandleGetCached(Sender, mReader.ReadPacket <CachedPacket>());
break;
case Packet.CreateRoom:
HandleCreateRoom(Sender, mCommand, mReader.ReadString(), mReader.ReadInt32(), mReader.ReadString(), mReader.ReadBoolean(), mReader.ReadBoolean(), mReader.ReadBytes(length));
break;
case Packet.GetRooms:
HandleGetRooms(Sender, mCommand);
break;
case Packet.JoinRoom:
HandleJoinRoom(Sender, mCommand, mReader.ReadInt32());
break;
case Packet.DestroyPlayer:
HandleDestroyPlayer(Sender, mCommand);
break;
case Packet.SendMousePosition:
HandleNavMeshAgent(Sender, mCommand, mReader.ReadVector3());
break;
}
}
}
}
catch (Exception ex)
{
LoggerError($"Failed to Response Client {ex.Message}");
}
}
