public VNetPacketMemSteam SerializeSinaglePackage(UpdateLatestPacakge msg)
{
VNetPacketMemSteam stream = VNetPacketMemSteam.Allocate();
stream.Stream.Seek(0, SeekOrigin.Begin);
var binaryWriter = MyBinaryWriter.Allocate(stream.Stream);
long bodyLength;
var old = MessagePool.GetPackageBySeq(msg.Head.LastAckUserCmdSeq);
int count = 0;
if (old != null)
{
msg.Head.Serialize(binaryWriter);
bodyLength = SerializeComponents(binaryWriter, old.UpdateComponents, msg.UpdateComponents, out count);
}
else
{
msg.Head.LastAckUserCmdSeq = -1;
msg.Head.Serialize(binaryWriter);
bodyLength = SerializeComponents(binaryWriter, _emptyUpdateComponents, msg.UpdateComponents, out count);
}
AssertUtility.Assert(bodyLength < 65535);
msg.Head.ReWriteComponentCountAndBodyLength(binaryWriter, (short)bodyLength, (byte)count);
binaryWriter.ReleaseReference();
return(stream);
}
public override void Write(MyBinaryWriter stream)
{
stream.Write(Elements.Count);
stream.Write(stream.DataStartOffset);
if (Elements.Count > 0)
{
var currOffs = stream.BaseStream.Position;
stream.Seek(stream.DataStartOffset, SeekOrigin.Begin);
if (typeof(T).IsSubclassOf(typeof(Element)))
{
var elementSize = (Elements[0] as Element).GetSize();
stream.DataStartOffset += elementSize * Elements.Count;
}
else
{
stream.DataStartOffset += Marshal.SizeOf(typeof(T)) * Elements.Count;
}
foreach (var element in Elements)
{
stream.Write <T>(element);
}
stream.Seek((int)currOffs, SeekOrigin.Begin);
}
}
public MemoryStream SerializeSinaglePackage(UpdateLatestPacakge msg)
{
MemoryStream stream = ObjectAllocatorHolder <MemoryStream> .Allocate();
stream.Seek(0, SeekOrigin.Begin);
var binaryWriter = MyBinaryWriter.Allocate(stream);
long bodyLength;
var old = MessagePool.GetPackageBySeq(msg.Head.BaseUserCmdSeq);
if (old != null)
{
msg.Head.Serialize(binaryWriter);
bodyLength = SerializeComponents(binaryWriter, old.UpdateComponents, msg.UpdateComponents);
}
else
{
msg.Head.BaseUserCmdSeq = -1;
msg.Head.Serialize(binaryWriter);
bodyLength = SerializeComponents(binaryWriter, _emptyUpdateComponents, msg.UpdateComponents);
}
AssertUtility.Assert(bodyLength < 65535);
msg.Head.ReWriteBodyLength(binaryWriter, (short)bodyLength);
binaryWriter.ReleaseReference();
return(stream);
}
/// <summary>
/// 判断与比较值不相同的情况下，将当前值写入Wirter
/// </summary>
/// <param name="comparedInfo"></param>
/// <param name="writer"></param>
public void Write(WeaponBagContainer comparedInfo, MyBinaryWriter writer)
{
writer.Write(HeldSlotPointer);
writer.Write(LastSlotPointer);
BitArrayWrapper bitArray = BitArrayWrapper.Allocate(GameGlobalConst.WeaponSlotMaxLength, false);
// return new BitArray(5, true);
if (comparedInfo == null)
{
bitArray.SetAll(true);
}
else
{
for (int i = 0; i < GameGlobalConst.WeaponSlotMaxLength; i++)
{
bitArray[i] = slotWeapons[i] != comparedInfo.slotWeapons[i];
}
}
writer.Write(bitArray);
for (int i = 0; i < GameGlobalConst.WeaponSlotMaxLength; i++)
{
if (bitArray[i])
{
writer.Write(slotWeapons[i].WeaponKey.EntityId);
writer.Write(slotWeapons[i].WeaponKey.EntityType);
}
}
bitArray.ReleaseReference();
}
public override void Write(MyBinaryWriter stream)
{
//stream.DataStartOffset += 16;
stream.Write(C);
stream.Write(D);
E.Write(stream);
}
public void WriteBody(MyBinaryWriter writer)
{
FieldSerializeUtil.Serialize(Target, writer);
FieldSerializeUtil.Serialize(Offset, writer);
FieldSerializeUtil.Serialize(HitPoint, writer);
}
public void ReWriteBodyLength(MyBinaryWriter stream, short bodyLenght)
{
BodyLength = bodyLenght;
stream.Seek(-bodyLenght - 2, SeekOrigin.Current);
stream.Write(bodyLenght);
stream.Seek(bodyLenght, SeekOrigin.Current);
}
public void WriteBody(MyBinaryWriter writer)
{
FieldSerializeUtil.Serialize(Offset, writer);
FieldSerializeUtil.Serialize(HitPoint, writer);
FieldSerializeUtil.Serialize((byte)EnvironmentType, writer);
}
public override void Write(MyBinaryWriter stream)
{
for (var i = 0; i < Values.Length; ++i)
{
stream.Write <T>(Values[i]);
}
}
public override void Write(MyBinaryWriter stream)
{
stream.Write(Id);
stream.Write(Bone);
stream.Write(Position);
AnimateAttached.Write(stream);
}
public override void Write(MyBinaryWriter stream)
{
stream.Write(Id);
stream.Write(Data);
stream.Write(Bone);
stream.Write(Position);
Enabled.Write(stream);
}
public void Write(MyBinaryWriter writer)
{
for (int i = 0; i < GlobalConst.WeaponSlotMaxLength; i++)
{
writer.Write(slotWeapons[i].WeaponKey.EntityId);
writer.Write(slotWeapons[i].WeaponKey.EntityType);
}
}
public void WriteBody(MyBinaryWriter writer)
{
FieldSerializeUtil.Serialize(owner, writer);
FieldSerializeUtil.Serialize((byte)fireEffectType, writer);
FieldSerializeUtil.Serialize(pitch, writer);
FieldSerializeUtil.Serialize(yaw, writer);
FieldSerializeUtil.Serialize(weaponId, writer);
}
public virtual void WriteBody(MyBinaryWriter writer)
{
// FieldSerializeUtil.Serialize((byte) footstepState, writer);
// FieldSerializeUtil.Serialize((byte) footMatType, writer);
// FieldSerializeUtil.Serialize((byte) subType, writer);
FieldSerializeUtil.Serialize(relatedPos, writer);
FieldSerializeUtil.Serialize(relatedRocation, writer);
}
public void Write(FixedVector3 data, MyBinaryWriter writer)
{
var v = data.WorldVector3();
writer.Write(v.x);
writer.Write(v.y);
writer.Write(v.z);
}
public static void Write <T>(T cur, T last, MyBinaryWriter writer) where T : IPatchClass <T>, new()
{
var serializer = _patchSerializers[cur.GetName()];
if (serializer is IPatchSerializer <T> )
{
(serializer as IPatchSerializer <T>).Write(cur, last, writer);
}
}
public void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager serializerManager)
{
writer.Write(BaseSnapshotSeq);
writer.Write(_entityPatchList.Count);
foreach (var item in _entityPatchList)
{
item.Serialize(writer, serializerManager);
}
}
public void Serialize(MyBinaryWriter writer)
{
writer.Write(VehicleSimulationTime);
writer.Write(ServerTime);
writer.Write(SnapshotSeq);
writer.Write(LastUserCmdSeq);
writer.Write(Self.EntityId);
writer.Write(Self.EntityType);
}
public void Write(MyBinaryWriter writer)
{
writer.Write(Commands.Count);
for (int i = 0; i < Commands.Count; ++i)
{
writer.Write(Commands[i].Key);
writer.Write(Commands[i].Value);
}
}
public void Serialize(MyBinaryWriter stream)
{
stream.Write(BaseUserCmdSeq);
stream.Write(UserCmdSeq);
stream.Write(LastSnapshotId);
stream.Write(ComponentCount);
stream.Write((short)0);
}
public void ReWriteComponentCountAndBodyLength(MyBinaryWriter stream, short bodyLenght, byte count)
{
SerializeCount = count;
BodyLength = bodyLenght;
stream.Seek(-bodyLenght - 3, SeekOrigin.Current);
stream.Write(count);
stream.Write(bodyLenght);
stream.Seek(bodyLenght, SeekOrigin.Current);
}
public void WriteBody(MyBinaryWriter writer)
{
FieldSerializeUtil.Serialize(Offset, writer);
FieldSerializeUtil.Serialize(HitPoint, writer);
FieldSerializeUtil.Serialize((byte)EnvironmentType, writer);
FieldSerializeUtil.Serialize(HitAudioId, writer);
FieldSerializeUtil.Serialize(needEffectEntity?(byte)1:(byte)0, writer);
FieldSerializeUtil.Serialize(ChunkId, writer);
}
public void Write(WeaponBagContainer comparedInfo, MyBinaryWriter writer)
{
writer.Write(HeldSlotPointer);
writer.Write(LastSlotPointer);
for (int i = 0; i < GlobalConst.WeaponSlotMaxLength; i++)
{
writer.Write(slotWeapons[i].WeaponKey.EntityId);
writer.Write(slotWeapons[i].WeaponKey.EntityType);
}
}
public override void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager serializerManager)
{
writer.Write((byte)EntityReplicateOperationType.Mod);
writer.Write(Key.EntityId);
writer.Write(Key.EntityType);
writer.Write((short)ComponentPatchList.Count);
for (int i = 0; i < ComponentPatchList.Count; i++)
{
ComponentPatchList[i].Serialize(writer, serializerManager);
}
}
public int Serialize(Stream outStream, object message)
{
var msg = message as UpdateLatestPacakge;
var binaryWriter = MyBinaryWriter.Allocate(outStream);
binaryWriter.Write(_version);
if (MessagePool.GetPackageBySeq(msg.Head.LastUserCmdSeq) != null)
{
_logger.ErrorFormat("repetition msg.Head.UserCmdSeq{0}", msg.Head.LastUserCmdSeq);
binaryWriter.Write((byte)0);
return(binaryWriter.WriterLenght);
}
MessagePool.AddMessage(msg);
MessagePool.ClearOldMessage(msg.Head.LastAckUserCmdSeq);
if (_sendHistoryStreams.Count > _sendCount)
{
RemoveHistoryFirst();
}
for (int i = 0; i < _sendCount; i++)
{
if (_sendHistorySeqs.Count > 0 && msg.Head.LastAckUserCmdSeq > 0 &&
_sendHistorySeqs.First() <= msg.Head.LastAckUserCmdSeq)
{
RemoveHistoryFirst();
}
else
{
break;
}
}
var stream = SerializeSinaglePackage(msg);
_sendHistoryStreams.AddLast(stream);
_sendHistorySeqs.AddLast(msg.Head.LastUserCmdSeq);
binaryWriter.Write((byte)_sendHistoryStreams.Count);
foreach (var sendHistroyStream in _sendHistoryStreams)
{
binaryWriter.Write(sendHistroyStream.Stream.GetBuffer(),
(int)(sendHistroyStream.Stream.Position - sendHistroyStream.Length), (int)sendHistroyStream.Length);
}
_logger.DebugFormat("send package{0}", binaryWriter.Position);
var ret = binaryWriter.WriterLenght;
binaryWriter.ReleaseReference();
return(ret);
}
public void Write(MyBinaryWriter writer)
{
AssertUtility.Assert((int)EEventType.End < 255);
writer.Write((byte)_events.Count);
foreach (var v in _events.Values)
{
writer.Write((byte)v.EventType);
v.WriteBody(writer);
}
}
public override void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager serializerManager)
{
writer.Write((byte)ComponentReplicateOperationType.Add);
var componentId = Component.GetComponentId();
writer.Write((short)componentId);
var componentSerializer = serializerManager.GetSerializer(componentId);
componentSerializer.SerializeAll(Component as INetworkObject, DoCompress, writer);
}
public void WriteBody(MyBinaryWriter writer)
{
FieldSerializeUtil.Serialize((byte)bodyPart, writer);
// FieldSerializeUtil.Serialize(bulletBaseText, writer);
//
FieldSerializeUtil.Serialize(statisticStr, writer);
FieldSerializeUtil.Serialize(cmdSeq, writer);
FieldSerializeUtil.Serialize(serverTime, writer);
FieldSerializeUtil.Serialize(totalDamage, writer);
FieldSerializeUtil.Serialize(shootKey, writer);
FieldSerializeUtil.Serialize(shootTarget, writer);
}
public void Write(MyBinaryWriter writer)
{
writer.Write(Commands.Count);
for (int i = 0; i < Commands.Count; ++i)
{
writer.Write(Commands[i].Key);
writer.Write(Commands[i].Value.EventParam);
writer.Write(Commands[i].Value.IntParameter);
writer.Write(Commands[i].Value.FloatParameter);
writer.Write(Commands[i].Value.StringParameter);
}
}
public void Write(MyBinaryWriter writer, Action <MyBinaryWriter, T> write)
{
writer.Write7BitEncodedInt(Width);
writer.Write7BitEncodedInt(Height);
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
write(writer, m_Array[x, y]);
}
}
}
void ResetWriteBuffer ()
{
this.buffer = new MemoryStream ();
writer = new MyBinaryWriter (buffer);
}
// XmlWriterSettings support
#endregion
#region Constructors
public XmlBinaryDictionaryWriter (Stream stream,
IXmlDictionary dictionary,
XmlBinaryWriterSession session, bool ownsStream)
{
if (dictionary == null)
dictionary = new XmlDictionary ();
if (session == null)
session = new XmlBinaryWriterSession ();
original = new MyBinaryWriter (stream);
this.writer = original;
buffer_writer = new MyBinaryWriter (buffer);
this.dict_ext = dictionary;
this.session = session;
owns_stream = ownsStream;
AddNamespace ("xml", "http://www.w3.org/XML/1998/namespace");
AddNamespace ("xml", "http://www.w3.org/2000/xmlns/");
ns_index = 2;
}
public void Write7BitEncodedIntTest ()
{
MemoryStream stream = new MemoryStream ();
var writer = new MyBinaryWriter (stream);
writer.WriteLeb128 (5);
Assert.AreEqual (new byte[] { 5 }, stream.ToArray (), "#1");
stream = new MemoryStream ();
writer = new MyBinaryWriter (stream);
writer.WriteLeb128 (int.MaxValue);
Assert.AreEqual (new byte[] { 255, 255, 255, 255, 7 }, stream.ToArray (), "#2");
stream = new MemoryStream ();
writer = new MyBinaryWriter (stream);
writer.WriteLeb128 (128);
Assert.AreEqual (new byte[] { 128, 1 }, stream.ToArray (), "#3");
stream = new MemoryStream ();
writer = new MyBinaryWriter (stream);
writer.WriteLeb128 (-1025);
Assert.AreEqual (new byte[] { 255, 247, 255, 255, 15 }, stream.ToArray (), "#4");
stream = new MemoryStream ();
writer = new MyBinaryWriter (stream);
writer.WriteLeb128 (int.MinValue);
Assert.AreEqual (new byte[] { 128, 128, 128, 128, 8 }, stream.ToArray (), "#5");
stream = new MemoryStream ();
writer = new MyBinaryWriter (stream);
writer.WriteLeb128 (-1);
Assert.AreEqual (new byte[] { 255, 255, 255, 255, 15 }, stream.ToArray (), "#6");
stream = new MemoryStream ();
writer = new MyBinaryWriter (stream);
writer.WriteLeb128 (0);
Assert.AreEqual (new byte[] { 0 }, stream.ToArray (), "#7");
}
