public void SetPeer(IRailNetPeer netPeer) { RailDebug.Assert(this.serverPeer == null, "Overwriting peer"); this.serverPeer = new RailClientPeer(netPeer, this.Interpreter); this.serverPeer.PacketReceived += this.OnPacketReceived; this.serverPeer.EventReceived += base.OnEventReceived; }
internal RailServerPeer( IRailNetPeer netPeer, RailInterpreter interpreter) : base(netPeer, interpreter) { this.scope = new RailScope(); }
internal void SendPacket(IRailNetPeer peer, IRailPacket packet) { this.bitBuffer.Clear(); packet.Encode(this.bitBuffer); int length = this.bitBuffer.Store(this.bytes); RailDebug.Assert(length <= RailConfig.PACKCAP_MESSAGE_TOTAL); peer.SendPayload(this.bytes, length); }
internal RailClientPeer( IRailNetPeer netPeer, RailInterpreter interpreter) : base(netPeer, interpreter) { this.localView = new RailView(); this.sortingList = new List <RailEntity>(); }
public void SendPacket(RailResource resource, IRailNetPeer peer, RailPacketOutgoing packet) { bitBuffer.Clear(); packet.Encode(resource, bitBuffer); int length = bitBuffer.Store(bytes); RailDebug.Assert(length <= RailConfig.PACKCAP_MESSAGE_TOTAL); peer.SendPayload(new ArraySegment <byte>(bytes, 0, length)); }
public RailServerPeer( RailResource resource, IRailNetPeer netPeer, RailInterpreter interpreter) : base( resource, netPeer, ExternalEntityVisibility.Scoped, RailConfig.CLIENT_SEND_RATE, interpreter) { }
public RailController( IRailStateConstruction stateCreator, ExternalEntityVisibility eVisibility, [CanBeNull] IRailNetPeer netPeer) { controlledEntities = new HashSet <RailEntityBase>(); NetPeer = netPeer; Scope = eVisibility == ExternalEntityVisibility.Scoped ? new RailScope(this, stateCreator) : null; }
public RailClientPeer( RailResource resource, IRailNetPeer netPeer, RailInterpreter interpreter) : base( resource, netPeer, ExternalEntityVisibility.All, RailConfig.SERVER_SEND_RATE, interpreter) { localView = new RailView(); }
public void RemoveClient(IRailNetPeer netClient) { if (clients.ContainsKey(netClient)) { RailServerPeer client = clients[netClient]; clients.Remove(netClient); Room.RemoveClient(client); // Revoke control of all the entities controlled by that client client.Shutdown(); ClientRemoved?.Invoke(client); } }
public void AddClient(IRailNetPeer netPeer, string identifier) { if (clients.ContainsKey(netPeer) == false) { RailServerPeer client = new RailServerPeer(Resource, netPeer, Interpreter) { Identifier = identifier }; client.EventReceived += OnEventReceived; client.PacketReceived += OnPacketReceived; clients.Add(netPeer, client); Room.AddClient(client); ClientAdded?.Invoke(client); } }
/// <summary> /// Wraps an incoming connection in a peer and stores it. /// </summary> public void AddPeer(IRailNetPeer peer) { if (this.clients.ContainsKey(peer) == false) { RailServerPeer client = new RailServerPeer(peer, this.Interpreter); client.EventReceived += base.OnEventReceived; client.PacketReceived += this.OnPacketReceived; this.clients.Add(peer, client); if (this.ControllerJoined != null) { this.ControllerJoined.Invoke(client); } } }
protected void OnPayloadReceived(IRailNetPeer peer, byte[] buffer, int length) { RailBitBuffer bitBuffer = this.interpreter.LoadData(buffer, length); this.reusableIncoming.Decode(bitBuffer); if (bitBuffer.IsFinished) { this.ProcessPacket(this.reusableIncoming); } else { RailDebug.LogError("Bad packet read, discarding..."); } this.reusableIncoming.Reset(); }
/// <summary> /// Wraps an incoming connection in a peer and stores it. /// </summary> public void RemovePeer(IRailNetPeer peer) { if (this.clients.ContainsKey(peer)) { RailServerPeer client = this.clients[peer]; this.clients.Remove(peer); if (this.ControllerLeft != null) { this.ControllerLeft.Invoke(client); } // Revoke control of all the entities controlled by that controller client.Shutdown(); } }
protected RailPeer( IRailNetPeer netPeer, RailInterpreter interpreter, RailPacket reusableIncoming, RailPacket reusableOutgoing) { this.netPeer = netPeer; this.interpreter = interpreter; this.controlledEntities = new HashSet <RailEntity>(); this.remoteClock = new RailClock(); this.outgoingEvents = new Queue <RailEvent>(); this.reusableIncoming = reusableIncoming; this.reusableOutgoing = reusableOutgoing; this.lastQueuedEventId = SequenceId.START.Next; this.processedEventHistory = new SequenceWindow(SequenceId.START); this.netPeer.PayloadReceived += this.OnPayloadReceived; }
protected RailPeer( RailResource resource, IRailNetPeer netPeer, ExternalEntityVisibility visibility, uint remoteSendRate, RailInterpreter interpreter, RailPacketIncoming reusableIncoming, RailPacketOutgoing reusableOutgoing) : base(resource, visibility, netPeer) { Resource = resource; RemoteClock = new RailClock(remoteSendRate); this.interpreter = interpreter; outgoingEvents = new Queue <RailEvent>(); this.reusableIncoming = reusableIncoming; this.reusableOutgoing = reusableOutgoing; lastQueuedEventId = SequenceId.Start.Next; eventHistory = new RailHistory(RailConfig.HISTORY_CHUNKS); LocalTick = Tick.START; netPeer.PayloadReceived += OnPayloadReceived; }
private void OnPayloadReceived(IRailNetPeer peer, ArraySegment <byte> buffer) { try { RailBitBuffer bitBuffer = interpreter.LoadData(buffer); reusableIncoming.Reset(); reusableIncoming.Decode(Resource, bitBuffer); if (bitBuffer.IsFinished) { ProcessPacket(reusableIncoming, LocalTick); } else { RailDebug.LogError("Bad packet read, discarding..."); } } catch (Exception e) { RailDebug.LogError("Error during packet read: " + e); } }
/// <summary> /// Sets the current server peer. /// </summary> public void SetPeer(IRailNetPeer netPeer) { if (netPeer == null) { if (ServerPeer != null) { ServerPeer.PacketReceived -= OnPacketReceived; ServerPeer.EventReceived -= OnEventReceived; Disconnected?.Invoke(ServerPeer); } ServerPeer = null; } else { RailDebug.Assert(ServerPeer == null, "Overwriting peer"); ServerPeer = new RailClientPeer(Resource, netPeer, Interpreter); ServerPeer.PacketReceived += OnPacketReceived; ServerPeer.EventReceived += OnEventReceived; Connected?.Invoke(ServerPeer); } }