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(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 override void Write(MyBinaryWriter stream)
{
//stream.DataStartOffset += 16;
stream.Write(C);
stream.Write(D);
E.Write(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.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 Write(FixedVector3 data, MyBinaryWriter writer)
{
var v = data.WorldVector3();
writer.Write(v.x);
writer.Write(v.y);
writer.Write(v.z);
}
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 Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager serializerManager)
{
writer.Write(BaseSnapshotSeq);
writer.Write(_entityPatchList.Count);
foreach (var item in _entityPatchList)
{
item.Serialize(writer, serializerManager);
}
}
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 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 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 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 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 Write(MyBinaryWriter stream)
{
stream.Write(Type);
stream.Write(FarClip);
stream.Write(NearClip);
Positions.Write(stream);
stream.Write(PositionBase);
TargetPositions.Write(stream);
stream.Write(TargetPositionBase);
Roll.Write(stream);
FoV.Write(stream);
}
public void Write(MyBinaryWriter writer)
{
AssertUtility.Assert((int)EEventType.End < 255);
int c = _events.Count;
writer.Write((short)c);
for (var i = 0; i < c; i++)
{
var node = _events[i];
writer.Write((byte)node.EventType);
node.WriteBody(writer);
}
}
public override void Write(MyBinaryWriter stream)
{
stream.Write(Type);
stream.Write(Bone);
stream.Write(Position);
AmbientColor.Write(stream);
AmbientInsensity.Write(stream);
DiffuseColor.Write(stream);
DiffuseIntensity.Write(stream);
AttenuationStart.Write(stream);
AttenuationEnd.Write(stream);
Unknown.Write(stream);
}
public void Serialize(MyBinaryWriter writer)
{
writer.Write(_bitNum);
ulong val = _value;
ulong byteMask = 0x000000ff;
int byteNum = (int)System.Math.Ceiling(_bitNum * 1.0 / 8);
for (int i = 0; i < byteNum; i++)
{
byte b = (byte)(val & byteMask);
val = val >> 8;
writer.Write(b);
}
}
public void Write(MyBinaryWriter writer)
{
AssertUtility.Assert((int)EEventType.End < 255);
writer.Write((byte)_events.Count);
foreach (KeyValuePair <EEventType, List <IEvent> > eventListPair in _events)
{
writer.Write((byte)eventListPair.Key);
writer.Write(eventListPair.Value.Count);
foreach (var node in eventListPair.Value)
{
node.WriteBody(writer);
}
}
}
public void saveBinaryFile(ObservableCollection <User> Users)
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.FileName = "users.bin";
saveFileDialog.DefaultExt = ".bin";
saveFileDialog.Filter = "Binary documents (.bin)|*.bin";
var result = saveFileDialog.ShowDialog();
if (result == true)
{
writer.Create(saveFileDialog.FileName);
foreach (var u in Users)
{
PublicUsers.Add(new UserAbstraction {
ID = u.ID, LastName = u.LastName, Name = u.Name,
SecondName = u.SecondName, Email = u.Email
});
}
writer.Write(PublicUsers);
}
}
public void ReWriteBodyLength(MyBinaryWriter stream, short bodyLenght)
{
BodyLength = bodyLenght;
stream.Seek(-bodyLenght - 2, SeekOrigin.Current);
stream.Write(bodyLenght);
stream.Seek(bodyLenght, SeekOrigin.Current);
}
public override void Write(MyBinaryWriter stream)
{
for (var i = 0; i < Values.Length; ++i)
{
stream.Write <T>(Values[i]);
}
}
public static void WriteFieldsMask(MyBinaryWriter writer, BitArray fieldsMask)
{
var count = fieldsMask.Count;
if (count > Byte.MaxValue)
{
string info = string.Format("property count {0} exceed the byte max", count);
throw new Exception(info);
}
writer.Write((byte)count);
byte[] bytes = ToBytes(fieldsMask);
for (int i = 0; i < bytes.Length; i++)
{
writer.Write(bytes[i]);
}
}
public override void Write(MyBinaryWriter stream)
{
stream.Write(Position);
for (var i = 0; i < Weights.Length; ++i)
{
stream.Write(Weights[i]);
}
for (var i = 0; i < Indices.Length; ++i)
{
stream.Write(Indices[i]);
}
stream.Write(Normal);
for (var i = 0; i < TextureCoordinates.Length; ++i)
{
stream.Write(TextureCoordinates[i]);
}
}
public void Write(NetworkAnimatorLayer right, MyBinaryWriter writer)
{
BitArrayWrapper bitArray = BitArrayWrapper.Allocate(7, false);
if (right == null)
{
bitArray.SetAll(true);
}
else
{
bitArray[0] = !CompareUtility.IsApproximatelyEqual(LayerIndex, right.LayerIndex);
bitArray[1] = Weight != right.Weight;
bitArray[2] = !CompareUtility.IsApproximatelyEqual(CurrentStateHash, right.CurrentStateHash);
bitArray[3] = NormalizedTime != right.NormalizedTime;
bitArray[4] = StateDuration != right.StateDuration;
bitArray[5] = TransitionNormalizedTime != right.TransitionNormalizedTime;
bitArray[6] = TransitionDuration != right.TransitionDuration;
}
writer.Write(bitArray);
if (bitArray[0])
{
writer.Write(LayerIndex);
}
if (bitArray[1])
{
writer.Write(Weight);
}
if (bitArray[2])
{
writer.Write(CurrentStateHash);
}
if (bitArray[3])
{
writer.Write(NormalizedTime);
}
if (bitArray[4])
{
writer.Write(StateDuration);
}
if (bitArray[5])
{
writer.Write(TransitionNormalizedTime);
}
if (bitArray[6])
{
writer.Write(TransitionDuration);
}
bitArray.ReleaseReference();
}
public override void Write(MyBinaryWriter stream)
{
stream.DataStartOffset += GetSize();
stream.Write(Magic);
stream.Write(Version);
Name.Write(stream);
stream.Write(GlobalModelFlags);
GlobalSequences.Write(stream);
Animations.Write(stream);
AnimationLookups.Write(stream);
Bones.Write(stream);
KeyBoneLookup.Write(stream);
Vertices.Write(stream);
stream.Write(nViews);
SubmeshAnimations.Write(stream);
Textures.Write(stream);
Transparencies.Write(stream);
UVAnimations.Write(stream);
TextureReplacements.Write(stream);
Materials.Write(stream);
BoneLookups.Write(stream);
TextureLookups.Write(stream);
TextureUnits.Write(stream);
TransparencyLookups.Write(stream);
AnimTextureLookups.Write(stream);
for (var i = 0; i < BoundingBox.Length; ++i)
{
stream.Write <C3Vector>(BoundingBox[i]);
}
stream.Write(BoundingSphereRadius);
for (var i = 0; i < CollisionBox.Length; ++i)
{
stream.Write <C3Vector>(CollisionBox[i]);
}
stream.Write(CollisionSphereRadius);
BoundingTriangles.Write(stream);
BoundingVertices.Write(stream);
BoundingNormals.Write(stream);
Attachments.Write(stream);
AttachementLookups.Write(stream);
Events.Write(stream);
Lights.Write(stream);
Cameras.Write(stream);
CameraLookups.Write(stream);
RibbonEmitters.Write(stream);
ParticleEmitters.Write(stream);
if (HasExtraField())
{
Unknown.Write(stream);
}
}
public void Serialize(MyBinaryWriter writer, string version)
{
writer.Write(version);
writer.Write(VehicleSimulationTime);
writer.Write(ServerTime);
writer.Write(SnapshotSeq);
writer.Write(LastUserCmdSeq);
writer.Write(Self.EntityId);
writer.Write(Self.EntityType);
}
public override void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager serializerManager)
{
var start = writer.BaseStream.Length;
writer.Write((byte)ComponentReplicateOperationType.Mod);
var componentId = Component.GetComponentId();
AssertUtility.Assert(componentId < 65535);
writer.Write((short)componentId);
_bitMask.Serialize(writer);
var componentSerializer = serializerManager.GetSerializer(componentId);
componentSerializer.Serialize(LastComponent as INetworkObject, Component as INetworkObject, _bitMask, DoCompress, writer);
var end = writer.BaseStream.Length;
var length = end - start;
_total[componentId] += length;
_current[componentId] = length;
_count[componentId] += 1;
_average[componentId] = _total[componentId] / _count[componentId];
}
void ProcessPendingBuffer(bool last, bool endElement)
{
if (buffer.Position > 0)
{
byte [] arr = buffer.GetBuffer();
if (endElement)
{
arr [0]++;
}
original.Write(arr, 0, (int)buffer.Position);
buffer.SetLength(0);
}
if (last)
{
writer = original;
}
}
