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"); } }
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 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"); } }
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 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); } }
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 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 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); } }
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); } }
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); } }
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); } }
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); } }
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); } }
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 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"); } }
// 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 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 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"); } }