protected RailRoom(RailResource resource, RailConnection connection)
{
Resource = resource;
this.connection = connection;
entities = new Dictionary <EntityId, RailEntityBase>(EntityId.CreateEqualityComparer());
Tick = Tick.INVALID;
}
protected RailConnection(RailRegistry registry)
{
Resource = new RailResource(registry);
Interpreter = new RailInterpreter();
Room = null;
hasStarted = false;
}
public static void Decode(
this RailPacketIncoming packet,
RailResource resource,
RailBitBuffer buffer)
{
packet.Decode(resource, resource, resource, buffer);
}
public static void Encode(
this RailPacketOutgoing packet,
RailResource resource,
RailBitBuffer buffer)
{
packet.Encode(resource, resource, buffer);
}
public RailServerRoom(RailResource resource, RailServer server) : base(resource, server)
{
ToUpdate = new List <RailEntityServer>();
ToRemove = new List <RailEntityServer>();
Clients = new HashSet <RailPeer>();
this.server = server;
}
/// <summary>
/// Creates a new entity with its corresponding state.
/// </summary>
/// <param name="resource"></param>
/// <param name="factoryType"></param>
/// <returns></returns>
public static RailEntityBase Create(RailResource resource, int factoryType)
{
RailEntityBase entity = resource.CreateEntity(factoryType);
entity.CommandCreator = resource;
entity.EventCreator = resource;
entity.InitState(resource, resource.CreateState(factoryType));
return(entity);
}
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 RailEvent Clone(RailResource resource)
{
RailEvent clone = resource.CreateEvent(FactoryType);
clone.EventId = EventId;
clone.Attempts = Attempts;
clone.Room = Room;
clone.Sender = Sender;
clone.DataSerializer.SetDataFrom(DataSerializer);
return(clone);
}
public RailClientPeer(
RailResource resource,
IRailNetPeer netPeer,
RailInterpreter interpreter) : base(
resource,
netPeer,
ExternalEntityVisibility.All,
RailConfig.SERVER_SEND_RATE,
interpreter)
{
localView = new RailView();
}
public RailClientRoom(RailResource resource, RailClient client) : base(resource, client)
{
eventCreator = resource;
ToUpdate = new List <RailEntityClient>();
ToRemove = new List <RailEntityClient>();
IEqualityComparer <EntityId> entityIdComparer = EntityId.CreateEqualityComparer();
pendingEntities = new Dictionary <EntityId, RailEntityClient>(entityIdComparer);
knownEntities = new Dictionary <EntityId, RailEntityClient>(entityIdComparer);
localPeer = new RailController(resource, ExternalEntityVisibility.All, null);
this.client = client;
}
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;
}
public RailEntityBase ProduceEntity(RailResource resource)
{
return(RailEntityBase.Create(resource, state.FactoryType));
}
