public static void Decode(
this RailPacketIncoming packet,
RailResource resource,
RailBitBuffer buffer)
{
packet.Decode(resource, resource, resource, buffer);
}
public static void WriteTicks(this RailBitBuffer buffer, Tick[] ticks)
{
for (int i = 0; i < ticks.Length; i++)
{
ticks[i].Write(buffer);
}
}
private void CompressData()
{
DataWithCompressor data0 = new DataWithCompressor
{
CompressedInt = 0,
CompressedFloat = 0.0f,
CompressedInt64 = 0
};
DataWithCompressor data1 = new DataWithCompressor
{
CompressedInt = int.MinValue + 212,
CompressedFloat = -212.0f,
CompressedInt64 = long.MinValue + 212
};
((IRailPoolable <RailState>)data0).Allocated();
((IRailPoolable <RailState>)data1).Allocated();
// Transfer data from data1 to data0 via buffer
uint uiFlagAll = 0xFFFF;
RailBitBuffer buffer = new RailBitBuffer();
data1.DataSerializer.EncodeMutableData(buffer, uiFlagAll);
data0.DataSerializer.DecodeMutableData(buffer, uiFlagAll);
Assert.Equal(data1.CompressedInt, data0.CompressedInt);
Assert.Equal(data1.CompressedFloat, data0.CompressedFloat);
Assert.Equal(data1.CompressedInt64, data0.CompressedInt64);
}
private void CustomData()
{
RailSynchronizedFactory.Detect(Assembly.GetExecutingAssembly());
DataWithCustomField data0 = new DataWithCustomField
{
Data = new Foo()
{
A = 0,
B = 0
}
};
DataWithCustomField data1 = new DataWithCustomField
{
Data = new Foo()
{
A = 42,
B = 43
}
};
((IRailPoolable <RailState>)data0).Allocated();
((IRailPoolable <RailState>)data1).Allocated();
// Transfer data from data1 to data0 via buffer
uint uiFlagAll = 0xFFFF;
RailBitBuffer buffer = new RailBitBuffer();
data1.DataSerializer.EncodeMutableData(buffer, uiFlagAll);
data0.DataSerializer.DecodeMutableData(buffer, uiFlagAll);
Assert.Equal(data1.Data.A, data0.Data.A);
Assert.Equal(data1.Data.B, data0.Data.B);
}
public static void ReadTicks(this RailBitBuffer buffer, Tick[] toStore)
{
for (int i = 0; i < toStore.Length; i++)
{
toStore[i] = Tick.Read(buffer);
}
}
private void EventDataIsSerialized()
{
Event instance0 = (Event)eventCreator.Object.CreateEvent(iFactoryType);
instance0.Attempts = 1;
instance0.Data = 43;
instance0.EventId = SequenceId.Start + 44;
eventCreator.Verify(m => m.CreateEvent(iFactoryType), Times.Once());
// Encode to buffer
RailBitBuffer buffer = new RailBitBuffer();
instance0.Encode(eventCreator.Object.EventTypeCompressor, buffer, Tick.START);
// Read from buffer
RailEvent instance1Base = RailEvent.Decode(
eventCreator.Object,
eventCreator.Object.EventTypeCompressor,
buffer,
Tick.START);
eventCreator.Verify(m => m.CreateEvent(iFactoryType), Times.Exactly(2));
Assert.Equal(instance0.EventId, instance1Base.EventId);
Assert.IsType <Event>(instance0);
Assert.Equal(instance0.Data, ((Event)instance1Base).Data);
}
private void CanEncode(int iNumberOfEntries)
{
// Add entries to pending
RailPackedListOutgoing <Foo> list = new RailPackedListOutgoing <Foo>();
for (int i = 0; i < iNumberOfEntries; ++i)
{
list.AddPending(poolMock.Object.Allocate());
}
Assert.Equal(iNumberOfEntries, elementsCreated);
poolMock.Verify(p => p.Allocate(), Times.Exactly(iNumberOfEntries));
poolMock.Verify(p => p.Deallocate(It.IsAny <Foo>()), Times.Never);
// Encode
RailBitBuffer buffer = new RailBitBuffer();
list.Encode(
buffer,
RailConfig.PACKCAP_COMMANDS,
RailConfig.MAXSIZE_COMMANDUPDATE,
(foo, buf) => foo.WriteData(buf));
Assert.False(buffer.Empty);
poolMock.Verify(p => p.Allocate(), Times.Exactly(iNumberOfEntries));
poolMock.Verify(p => p.Deallocate(It.IsAny <Foo>()), Times.Never);
Assert.Equal(iNumberOfEntries, list.Sent.Count());
// Clear the list. This should deallocate all sent objects.
list.Clear();
poolMock.Verify(p => p.Allocate(), Times.Exactly(iNumberOfEntries));
poolMock.Verify(p => p.Deallocate(It.IsAny <Foo>()), Times.Exactly(iNumberOfEntries));
}
public static void EncodeEventArg(this RailBitBuffer buffer, Argument arg)
{
buffer.Write(NumberOfBitsForArgType, Convert.ToByte(arg.EventType));
switch (arg.EventType)
{
case EventArgType.EntityReference:
buffer.WriteEntityId(arg.RailId.Value);
break;
case EventArgType.MBGUID:
buffer.WriteMBGUID(arg.MbGUID.Value);
break;
case EventArgType.Null:
// Empty
break;
case EventArgType.Int:
buffer.WriteInt(arg.Int.Value);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static void Encode(
this RailPacketOutgoing packet,
RailResource resource,
RailBitBuffer buffer)
{
packet.Encode(resource, resource, buffer);
}
protected override void EncodeData(RailBitBuffer buffer)
{
buffer.WriteBool(this.Up);
buffer.WriteBool(this.Down);
buffer.WriteBool(this.Left);
buffer.WriteBool(this.Right);
buffer.WriteBool(this.Action);
}
protected override void EncodePayload(
RailBitBuffer buffer,
int reservedBytes)
{
#if SERVER
// Write: [Deltas]
this.EncodeDeltas(buffer, reservedBytes);
}
public void Encode(RailBitBuffer buffer)
{
// Write: [SenderTick]
buffer.WriteTick(ClientTick);
// Write: [Command Data]
DataSerializer.EncodeData(buffer);
}
private void EncodeCommands(RailBitBuffer buffer)
{
commandUpdates.Encode(
buffer,
RailConfig.PACKCAP_COMMANDS,
RailConfig.MAXSIZE_COMMANDUPDATE,
(commandUpdate, buf) => commandUpdate.Encode(buf));
}
public static Foo Decode(this RailBitBuffer buffer)
{
return(new Foo()
{
A = buffer.ReadInt(),
B = buffer.ReadInt()
});
}
public override void DecodePayload(
IRailCommandConstruction commandCreator,
IRailStateConstruction stateCreator,
RailBitBuffer buffer)
{
// Read: [Deltas]
DecodeDeltas(stateCreator, buffer);
}
internal static void EncodeDelta(
RailBitBuffer buffer,
RailStateDelta delta)
{
// Write: [EntityId]
buffer.WriteEntityId(delta.EntityId);
// Write: [IsFrozen]
buffer.WriteBool(delta.IsFrozen);
if (delta.IsFrozen == false)
{
// Write: [FactoryType]
RailState state = delta.State;
buffer.WriteInt(RailState.FactoryTypeCompressor, state.factoryType);
// Write: [IsRemoved]
buffer.WriteBool(state.RemovedTick.IsValid);
if (state.RemovedTick.IsValid)
{
// Write: [RemovedTick]
buffer.WriteTick(state.RemovedTick);
// End Write
}
else
{
// Write: [HasControllerData]
buffer.WriteBool(state.HasControllerData);
// Write: [HasImmutableData]
buffer.WriteBool(state.HasImmutableData);
// Write: [Flags]
buffer.Write(state.FlagBits, state.Flags);
// Write: [Mutable Data]
state.EncodeMutableData(buffer, state.Flags);
if (state.HasControllerData)
{
// Write: [Controller Data]
state.EncodeControllerData(buffer);
// Write: [Command Ack]
buffer.WriteTick(state.CommandAck);
}
if (state.HasImmutableData)
{
// Write: [Immutable Data]
state.EncodeImmutableData(buffer);
}
}
}
}
internal void Encode(
RailBitBuffer buffer)
{
// Write: [SenderTick]
buffer.WriteTick(this.ClientTick);
// Write: [Command Data]
this.EncodeData(buffer);
}
public static long PeekInt64(this RailBitBuffer buffer, RailInt64Compressor compressor)
{
if (compressor.RequiredBits > RailConfig.VARINT_FALLBACK_SIZE)
{
return(compressor.Unpack(buffer.PeekUInt64()));
}
return(compressor.Unpack(buffer.Peek(compressor.RequiredBits)));
}
private void ReadWriteInt64(long expected)
{
RailBitBuffer buffer = new RailBitBuffer();
buffer.WriteInt64(expected);
long actual = buffer.ReadInt64();
Assert.Equal(expected, actual);
}
private void ReadWriteUInt(uint expected)
{
RailBitBuffer buffer = new RailBitBuffer();
buffer.WriteUInt(expected);
ulong actual = buffer.ReadUInt();
Assert.Equal(expected, actual);
}
public static int ReadInt(this RailBitBuffer buffer, RailIntCompressor compressor)
{
if (compressor.RequiredBits > RailConfig.VARINT_FALLBACK_SIZE)
{
return(compressor.Unpack(buffer.ReadUInt()));
}
return(compressor.Unpack(buffer.Read(compressor.RequiredBits)));
}
protected override void DecodeData(RailBitBuffer buffer)
{
this.SetData(
buffer.ReadBool(),
buffer.ReadBool(),
buffer.ReadBool(),
buffer.ReadBool(),
buffer.ReadBool());
}
public void Decode(RailBitBuffer buffer, Func <RailBitBuffer, T> decode)
{
IEnumerable <T> decoded = buffer.UnpackAll(decode);
foreach (T delta in decoded)
{
received.Add(delta);
}
}
public override void EncodePayload(
IRailStateConstruction stateCreator,
RailBitBuffer buffer,
Tick localTick,
int reservedBytes)
{
// Write: [Deltas]
EncodeDeltas(stateCreator, buffer, reservedBytes);
}
public static Tick CreateTick(uint uiValue)
{
// Ticks can, by design, not be created from a raw value. We can work around this since
// we know that ticks are serialized as uint.
RailBitBuffer bitBuffer = new RailBitBuffer(2);
bitBuffer.WriteUInt(uiValue);
return(Tick.Read(bitBuffer));
}
public static float PeekFloat(this RailBitBuffer buffer, RailFloatCompressor compressor)
{
if (compressor.RequiredBits > RailConfig.VARINT_FALLBACK_SIZE)
{
return(compressor.Unpack(buffer.PeekUInt()));
}
return(compressor.Unpack(buffer.Peek(compressor.RequiredBits)));
}
internal static FixedByteBuffer8 Read(RailBitBuffer buffer)
{
uint first = 0;
uint second = 0;
first = buffer.ReadUInt();
if (buffer.ReadBool())
second = buffer.ReadUInt();
return new FixedByteBuffer8(first, second);
}
public void EncodeMutableData(RailBitBuffer buffer, uint flags)
{
for (int i = 0; i < mutable.Count; ++i)
{
if ((flags & ToFlag(i)) == ToFlag(i))
{
mutable[i].WriteTo(buffer);
}
}
}
public static void WriteMethodCall(this RailBitBuffer buffer, MethodCall pack)
{
buffer.WriteInt(pack.Id.InternalValue);
buffer.EncodeEventArg(pack.Instance);
buffer.WriteInt(pack.Arguments.Count);
foreach (Argument arg in pack.Arguments)
{
buffer.EncodeEventArg(arg);
}
}
/// <summary>
/// Note that the packetTick may not be the tick this event was created on
/// if we're re-trying to send this event in subsequent packets. This tick
/// is intended for use in tick diffs for compression.
/// </summary>
public void Encode(RailIntCompressor compressor, RailBitBuffer buffer, Tick packetTick)
{
// Write: [EventType]
buffer.WriteInt(compressor, FactoryType);
// Write: [EventId]
buffer.WriteSequenceId(EventId);
// Write: [EventData]
DataSerializer.WriteData(buffer, packetTick);
}
private void EncodeDeltas(
IRailStateConstruction stateCreator,
RailBitBuffer buffer,
int reservedBytes)
{
deltas.Encode(
buffer,
RailConfig.PACKCAP_MESSAGE_TOTAL - reservedBytes,
RailConfig.MAXSIZE_ENTITY,
(delta, buf) => RailStateDeltaSerializer.EncodeDelta(stateCreator, buf, delta));
}
public override void DecodePayload(
IRailCommandConstruction commandCreator,
IRailStateConstruction stateCreator,
RailBitBuffer buffer)
{
// Read: [Commands]
DecodeCommands(commandCreator, buffer);
// Read: [View]
DecodeView(buffer);
}
protected override void EncodePayload(
RailBitBuffer buffer,
int reservedBytes)
{
#if CLIENT
// Write: [Commands]
this.EncodeCommands(buffer);
// Write: [View]
this.EncodeView(buffer, reservedBytes);
}
internal void Write(RailBitBuffer buffer)
{
uint first =
FixedByteBuffer8.Pack(this.val0, this.val1, this.val2, this.val3);
uint second =
FixedByteBuffer8.Pack(this.val4, this.val5, this.val6, this.val7);
bool writeSecond = (second > 0);
buffer.WriteUInt(first);
buffer.WriteBool(writeSecond);
if (writeSecond)
buffer.WriteUInt(second);
}
protected override void DecodePayload(RailBitBuffer buffer)
{
#if CLIENT
// Read: [Deltas]
this.DecodeDeltas(buffer);
}
protected void EncodeCommands(RailBitBuffer buffer)
{
this.commandUpdates.Encode(
buffer,
RailConfig.PACKCAP_COMMANDS,
RailConfig.MAXSIZE_COMMANDUPDATE,
(commandUpdate) => commandUpdate.Encode(buffer));
}
public void DecodeView(RailBitBuffer buffer)
{
IEnumerable<KeyValuePair<EntityId, RailViewEntry>> decoded =
buffer.UnpackAll(
() =>
{
return new KeyValuePair<EntityId, RailViewEntry>(
buffer.ReadEntityId(), // Read: [EntityId]
new RailViewEntry(
buffer.ReadTick(), // Read: [Tick]
buffer.ReadBool())); // Read: [IsFrozen]
});
foreach (var pair in decoded)
this.view.RecordUpdate(pair.Key, pair.Value);
#endif
}
protected override void DecodePayload(RailBitBuffer buffer)
{
#if SERVER
// Read: [Commands]
this.DecodeCommands(buffer);
// Read: [View]
this.DecodeView(buffer);
}
protected void DecodeCommands(RailBitBuffer buffer)
{
this.commandUpdates.Decode(
buffer,
() => RailCommandUpdate.Decode(buffer));
}
private void DecodeDeltas(RailBitBuffer buffer)
{
this.deltas.Decode(
buffer,
() => RailState.DecodeDelta(buffer, this.SenderTick));
#endif
}
protected void EncodeView(RailBitBuffer buffer, int reservedBytes)
{
buffer.PackToSize(
RailConfig.PACKCAP_MESSAGE_TOTAL - reservedBytes,
int.MaxValue,
this.view.GetOrdered(),
(pair) =>
{
buffer.WriteEntityId(pair.Key); // Write: [EntityId]
buffer.WriteTick(pair.Value.Tick); // Write: [Tick]
buffer.WriteBool(pair.Value.IsFrozen); // Write: [IsFrozen]
});
#endif
}
private void EncodeDeltas(
RailBitBuffer buffer,
int reservedBytes)
{
this.deltas.Encode(
buffer,
RailConfig.PACKCAP_MESSAGE_TOTAL - reservedBytes,
RailConfig.MAXSIZE_ENTITY,
(delta) => RailState.EncodeDelta(buffer, delta));
#endif
}
internal RailInterpreter()
{
this.bytes = new byte[RailConfig.DATA_BUFFER_SIZE];
this.bitBuffer = new RailBitBuffer();
}
internal void Write(RailBitBuffer buffer)
{
buffer.WriteByte(this.bitField);
}
internal static BitArray8 Read(RailBitBuffer buffer)
{
return new BitArray8(buffer.ReadByte());
}
internal static BitArray8 Peek(RailBitBuffer buffer)
{
return new BitArray8(buffer.PeekByte());
}
