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();
}
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 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));
}
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);
}
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);
}
}
