public override void WritePayload(IValueWriter writerm)
{
writerm.WriteUInt32(this.NetworkID);
writerm.WriteString(this.CharacterName);
writerm.WriteByte((byte)this.Action);
}
public void Write(IValueWriter writer)
{
writer.Write(_grhIndexValueKey, GrhIndex);
writer.Write(_sourceValueKey, SourceName);
writer.Write(_destValueKey, DestName);
writer.Write(_offsetValueKey, Offset);
writer.Write(_originValueKey, Origin);
}
public override void WritePayload(IValueWriter writer)
{
if (String.IsNullOrEmpty (this.Password))
throw new InvalidOperationException ("Can not login without a password.");
writer.WriteString (Username);
writer.WriteString (Password);
}
public override void WritePayload(ISerializationContext context, IValueWriter writer)
{
using (var ms = new MemoryStream())
{
ScreenFrame.Save(ms, ImageFormat.Png);
writer.WriteBytes(ms.GetBuffer());
}
}
public override void WritePayload(IValueWriter writer)
{
base.WritePayload(writer);
writer.WriteBytes(InternalOwnEndPoint.Address.GetAddressBytes());
writer.WriteInt32(InternalOwnEndPoint.Port);
writer.WriteBytes(ExternalPeerEndPoint.Address.GetAddressBytes());
writer.WriteInt32(ExternalPeerEndPoint.Port);
}
public override void WritePayload (ISerializationContext context, IValueWriter writer)
{
if (writer.WriteBool (SenderId != null))
writer.WriteString (SenderId);
writer.WriteInt32 (GroupId);
writer.WriteString (Text);
}
/// <summary>
/// Writes all properties for the given <paramref name="obj"/> that have the <see cref="SyncValueAttribute"/>
/// attribute to the given <see cref="IValueWriter"/>.
/// </summary>
/// <param name="obj">The object to write the persistent values for.</param>
/// <param name="writer">The <see cref="IValueWriter"/> to write to.</param>
public static void Write(object obj, IValueWriter writer)
{
var propertySyncs = PropertySyncHelper.GetPropertySyncs(obj.GetType());
foreach (var ps in propertySyncs)
{
ps.WriteValue(obj, writer);
}
}
public override void WritePayload(ISerializationContext context, IValueWriter writer)
{
writer.WriteInt32 (Entities.Count);
foreach (SnapshotEntity sentity in Entities)
{
WriteEntity (sentity.Entity, context, writer);
}
}
public void Serialize(IValueWriter writer)
{
writer.WriteBool (this.NonCharacter);
writer.WriteInt32 (this.PlayerID);
writer.WriteInt32 (this.path.Count);
foreach(Directions dir in this.path)
writer.WriteInt32 ((int) dir);
}
public override void WritePayload(IValueWriter writer)
{
writer.WriteUInt32 (this.NetworkID);
writer.WriteInt32 (this.X);
writer.WriteInt32 (this.Y);
writer.WriteInt32 (this.Direction);
writer.WriteString (this.Animation);
}
public override void WritePayload(IValueWriter writer)
{
writer.WriteInt32 (this.EventCommands.Count);
foreach(IEventCommand command in this.EventCommands)
{
writer.WriteInt32 ((int) command.Command);
command.Serialize (writer);
}
}
internal NetworkServerConnection(NetworkServerConnectionProvider provider, uint nid, TcpClient tcp, IPEndPoint endPoint, IValueWriter uwriter)
{
this.NetworkId = nid;
this.Tcp = tcp;
this.ReliableStream = tcp.GetStream ();
this.provider = provider;
this.EndPoint = endPoint;
this.UnreliableWriter = uwriter;
this.ReliableReader = new StreamValueReader (ReliableStream);
this.ReliableWriter = new StreamValueWriter (ReliableStream);
}
/// <summary>
/// Writes the state of the object to an <see cref="IValueWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write the values to.</param>
public void WriteState(IValueWriter writer)
{
PersistableHelper.Write(this, writer);
// Equipped bodies
Debug.Assert(_equippedBodies.Count <= byte.MaxValue);
writer.Write("EquippedBodiesCount", (byte)_equippedBodies.Count);
for (var i = 0; i < _equippedBodies.Count; i++)
{
writer.Write("EquippedBody_" + i, _equippedBodies[i]);
}
}
/// <summary>
/// 将指定成员名称的值写入到值写入器中。
/// </summary>
/// <param name="key">成员的名称</param>
/// <param name="valueWriter">值写入器</param>
public void OnReadValue(string key, IValueWriter valueWriter)
{
if (xTypeInfo.rwFieldsCache.TryGetValue(key, out var field))
{
if (field.CanRead)
{
field.OnReadValue(obj, valueWriter);
}
else if ((xTypeInfo.flags & XBindingFlags.RWCannotGetException) != 0)
{
throw new MissingMethodException($"Property '{xTypeInfo.type.Name}.{key}' No define '{"get"}' method or cannot access.");
}
}
else if ((xTypeInfo.flags & XBindingFlags.RWNotFoundException) != 0)
{
throw new MissingMemberException(xTypeInfo.type.Name, key);
}
else
{
valueWriter.DirectWrite(null);
}
}
/// <summary>
/// Writes the <see cref="BackgroundImage"/> to an <see cref="IValueWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write to.</param>
public virtual void Write(IValueWriter writer)
{
writer.Write(_valueKeyName, Name);
writer.WriteEnum(_valueKeyAlignment, Alignment);
writer.Write(_valueKeyColor, Color);
writer.Write(_valueKeyDepth, Depth);
writer.Write(_valueKeyOffset, Offset);
GrhIndex grhIndex;
if (IsSpriteSet())
{
grhIndex = Sprite.GrhData.GrhIndex;
}
else
{
grhIndex = GrhIndex.Invalid;
Debug.Fail("Why is the Sprite not set? That doesn't seem right...");
}
writer.Write(_valueKeyGrhIndex, grhIndex);
}
public void WriteValue(IValueWriter valueWriter, T value)
{
if (value == null)
{
valueWriter.DirectWrite(null);
return;
}
if (valueWriter is IValueWriter <T> tWriter)
{
tWriter.WriteValue(value);
return;
}
var dataReader = new DataSetRW <T>();
dataReader.Initialize(value);
valueWriter.WriteArray(dataReader);
}
/// <summary>
/// Writes a <see cref="IRefractionEffect"/> to an <see cref="IValueWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write to.</param>
/// <param name="re">The <see cref="IRefractionEffect"/> to write.</param>
/// <exception cref="ArgumentException"><paramref name="re"/> is not in the <see cref="ValidTypes"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="re"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="writer"/> is null.</exception>
public static void Write(IValueWriter writer, IRefractionEffect re)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (re == null)
{
throw new ArgumentNullException("re");
}
var asPersistable = re as IPersistable;
string typeName = null;
if (asPersistable != null)
{
typeName = Instance[re.GetType()];
}
if (typeName == null)
{
const string errmsg = "Type `{0}` is not a valid persistable IRefractionEffect type.";
if (log.IsErrorEnabled)
{
log.ErrorFormat(errmsg, re.GetType());
}
throw new ArgumentException(string.Format(errmsg, re.GetType()), "re");
}
writer.Write(_refractionEffectTypeKeyName, typeName);
writer.WriteStartNode(_refractionEffectNodeName);
{
asPersistable.WriteState(writer);
}
writer.WriteEndNode(_refractionEffectNodeName);
}
public void WriteValue(IValueWriter valueWriter, T value)
{
if (value is null)
{
valueWriter.DirectWrite(null);
return;
}
if (valueWriter is IValueWriter <T> tWriter)
{
tWriter.WriteValue(value);
return;
}
var dataReader = new DataRowRW <T>
{
datarow = value
};
valueWriter.WriteObject(dataReader);
}
public void WriteValue(IValueWriter valueWriter, T value)
{
if (value == null)
{
valueWriter.DirectWrite(null);
return;
}
/* 父类引用，子类实例时使用 Type 获取写入器。 */
if (CheckDerivedInstance && TypeHandle != TypeHelper.GetTypeHandle(value))
{
ValueInterface.GetInterface(value).Write(valueWriter, value);
return;
}
var reader = FastObjectRW <T> .Create();
reader.Initialize(value);
valueWriter.WriteObject(reader);
}
public void WriteValue(IValueWriter valueWriter, T value)
{
if (value is null)
{
valueWriter.DirectWrite(null);
return;
}
if (valueWriter is IValueWriter <T> tWriter)
{
tWriter.WriteValue(value);
return;
}
var dataReader = new DataSetRW <T>
{
dataset = value
};
valueWriter.WriteArray(dataReader);
}
public void WriteValue(IValueWriter valueWriter, T value)
{
if (value is null)
{
valueWriter.DirectWrite(null);
return;
}
if (valueWriter is IValueWriter <T> weiter)
{
weiter.WriteValue(value);
return;
}
var reader = new DataTableRW <T>(GetDataTableRWOptions(valueWriter))
{
datatable = value
};
valueWriter.WriteArray(reader);
}
public void WriteValue(IValueWriter valueWriter, T value)
{
if (valueWriter is IValueWriter <T> tWriter)
{
tWriter.WriteValue(value);
}
else if (valueWriter is IValueWriter <IDataReader <TKey> > tWriter2)
{
tWriter2.WriteValue(value);
}
else if (valueWriter is IValueWriter <IDataReader> tWriter3)
{
tWriter3.WriteValue(value);
}
else if (RWHelper.IsArrayKey <TKey>())
{
valueWriter.WriteArray(value.As <int>());
}
else
{
valueWriter.WriteObject(value.As <string>());
}
}
/// <summary>
/// When overridden in the derived class, writes the information for an item.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write to.</param>
/// <param name="itemInfo">The item info to write.</param>
protected override void WriteItemInfo(IValueWriter writer, IItemTable itemInfo)
{
var asPersistable = itemInfo as IPersistable;
if (asPersistable != null)
{
// Implements IPersistable, so can easily write the state
asPersistable.WriteState(writer);
}
else
{
// Doesn't implement IPersistable, so we have to create an ItemTable which is able to load the values from an IItemTable
// and does implement IPersistable. To avoid creating garbage, we cache an ItemTable to use instead of creating
// a new instance every time. Of course, this also means we need thread safety.
// This operation is quite fast (just lots of copying values around) so it would probably be of greater cost to try
// and allow parallization by using multiple ItemTable caches.
lock (_itemTableInfoCacheSync)
{
_itemTableInfoCache.CopyValuesFrom(itemInfo);
_itemTableInfoCache.WriteState(writer);
}
}
}
/// <summary>
/// 在数据写入器中写入该类型的实例。
/// </summary>
/// <param name="valueWriter">值写入器</param>
/// <param name="value">该类型的实例</param>
public void WriteValue(IValueWriter valueWriter, T value)
{
if (value == null)
{
valueWriter.DirectWrite(null);
return;
}
/* 父类引用，子类实例时使用 Type 获取写入器。 */
if (CheckChildrenInstance && TypeHandle != TypeHelper.GetTypeHandle(value))
{
ValueInterface.WriteValue(valueWriter, value);
return;
}
var objectRW = XObjectRW.Create <T>(CurrentBindingFlags);
objectRW.Initialize(value);
valueWriter.WriteObject(objectRW);
}
public void WriteValue(IValueWriter valueWriter, T value)
{
if (value == null)
{
valueWriter.DirectWrite(null);
return;
}
/* 父类引用，子类实例时使用 Type 获取写入器。 */
if (CheckChildrenInstance && Int64TypeHandle != (long)TypeHelper.GetTypeHandle(value))
{
ValueInterface.GetInterface(value).Write(valueWriter, value);
return;
}
var fastObjectRW = FastObjectRW <T> .Create();
fastObjectRW.Initialize(value);
valueWriter.WriteObject(fastObjectRW);
}
public void WriteValue(IValueWriter valueWriter, T value)
{
switch (TypeInfo <Key> .BasicType)
{
case BasicTypes.SByte:
case BasicTypes.Int16:
case BasicTypes.Int32:
case BasicTypes.Int64:
case BasicTypes.Byte:
case BasicTypes.UInt16:
case BasicTypes.UInt32:
case BasicTypes.UInt64:
valueWriter.WriteArray(value.As <int>());
break;
case BasicTypes.Char:
case BasicTypes.String:
valueWriter.WriteObject(value.As <string>());
break;
default:
throw new NotSupportedException(StringHelper.Format("Cannot write a '{0}', It's Key not supported.", typeof(T).Name));
}
}
/// <summary>
/// Writes a signed integer with the specified range to an IValueWriter.
/// </summary>
/// <param name="writer">IValueWriter to write to.</param>
/// <param name="value">Value to write.</param>
/// <param name="name">Name of the value to write.</param>
/// <param name="minValue">Minimum (inclusive) value that the written value can be.</param>
/// <param name="maxValue">Maximum (inclusive) value that the written value can be.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="value"/> is greater than <paramref name="maxValue"/>
/// or less than <paramref name="minValue"/>.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="maxValue"/> is less than <paramref name="minValue"/>.</exception>
public static void Write(this IValueWriter writer, string name, int value, int minValue, int maxValue)
{
if (value < minValue || value > maxValue)
{
throw new ArgumentOutOfRangeException("value", "Value parameter must be between minValue and maxValue.");
}
if (maxValue < minValue)
{
throw new ArgumentOutOfRangeException("maxValue", "MaxValue must be greater than or equal to MinValue.");
}
// Find the number of bits required for the range of desired values
var maxWriteValue = (uint)(maxValue - minValue);
var bitsRequired = BitOps.RequiredBits(maxWriteValue);
// Subtract the minimum value from the value since we want to write how high above the minimum value
// the value is, not the actual value
var offsetFromMin = (uint)(value - minValue);
writer.Write(name, offsetFromMin, bitsRequired);
Debug.Assert((value - minValue) <= maxWriteValue);
Debug.Assert((1 << bitsRequired) >= maxWriteValue);
}
public void WriteValue(IValueWriter valueWriter, ValueTask value)
{
var task = value.AsTask();
try
{
task.Wait();
ValueInterface.WriteValue(valueWriter, new
{
task.AsyncState,
task.Status
});
}
catch
{
ValueInterface.WriteValue(valueWriter, new
{
task.AsyncState,
task.Exception.InnerException,
task.Status
});
}
}
public SlimeMode2Encoder(IValueWriter valueWriter)
{
_valueWriter = valueWriter;
}
/// <summary>
/// When overridden in the derived class, writes all custom state values to the <paramref name="writer"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write the state values to.</param>
protected override void WriteCustomValues(IValueWriter writer)
{
}
/// <summary>
/// When overridden in the derived class, writes a value to an IValueWriter with the specified name.
/// </summary>
/// <param name="name">Name of the value.</param>
/// <param name="writer">IValueWriter to write to.</param>
/// <param name="value">Value to write.</param>
protected override void Write(string name, IValueWriter writer, Vector3 value)
{
writer.Write(name, value);
}
public override void WritePayload(ISerializationContext context, IValueWriter writer)
{
writer.WriteInt32(GroupId);
}
static void WriteKVP(IValueWriter writer, KeyValuePair<string, string> value)
{
writer.Write(_keyValueName, value.Key);
writer.Write(_valueValueName, value.Value ?? string.Empty);
}
/// <summary>
/// When overridden in the derived class, writes all custom state values to the <paramref name="writer"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write the state values to.</param>
protected override void WriteCustomValues(IValueWriter writer)
{
writer.Write("SerializedValue", SerializedValue);
}
internal void Serialize(IValueWriter writer)
{
writer.WriteInt32 (this.UserId);
writer.WriteByte ((byte)this.ResultState);
}
public void OnReadValue(TKey key, IValueWriter valueWriter)
{
ValueInterface <TValue> .WriteValue(valueWriter, content[key]);
}
/// <summary>
/// When overridden in the derived class, writes all custom state values to the <paramref name="writer"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write the state values to.</param>
protected override void WriteCustomValues(IValueWriter writer)
{
writer.Write(_positionKeyName, Position);
writer.Write(_radiusKeyName, Radius);
writer.Write(_strengthKeyName, Strength);
}
public void WriteJson(object value, IValueWriter writer)
{
var flag = (FeatureFlag)value;
var obj = writer.Object();
obj.Name("key").String(flag.Key);
obj.Name("version").Int(flag.Version);
obj.Name("deleted").Bool(flag.Deleted);
obj.Name("on").Bool(flag.On);
var prereqsArr = obj.Name("prerequisites").Array();
foreach (var p in flag.Prerequisites)
{
var prereqObj = prereqsArr.Object();
prereqObj.Name("key").String(p.Key);
prereqObj.Name("variation").Int(p.Variation);
prereqObj.End();
}
prereqsArr.End();
var targetsArr = obj.Name("targets").Array();
foreach (var t in flag.Targets)
{
var targetObj = targetsArr.Object();
targetObj.Name("variation").Int(t.Variation);
SerializationHelpers.WriteStrings(targetObj.Name("values"), t.Values);
targetObj.End();
}
targetsArr.End();
var rulesArr = obj.Name("rules").Array();
foreach (var r in flag.Rules)
{
var ruleObj = rulesArr.Object();
ruleObj.Name("id").String(r.Id);
SerializationHelpers.WriteVariationOrRollout(ref ruleObj, r.Variation, r.Rollout);
SerializationHelpers.WriteClauses(ruleObj.Name("clauses"), r.Clauses);
ruleObj.Name("trackEvents").Bool(r.TrackEvents);
ruleObj.End();
}
rulesArr.End();
var fallthroughObj = obj.Name("fallthrough").Object();
SerializationHelpers.WriteVariationOrRollout(ref fallthroughObj, flag.Fallthrough.Variation, flag.Fallthrough.Rollout);
fallthroughObj.End();
if (flag.OffVariation.HasValue)
{
obj.Name("offVariation").Int(flag.OffVariation.Value);
}
SerializationHelpers.WriteValues(obj.Name("variations"), flag.Variations);
obj.Name("salt").String(flag.Salt);
obj.MaybeName("trackEvents", flag.TrackEvents).Bool(flag.TrackEvents);
obj.MaybeName("trackEventsFallthrough", flag.TrackEventsFallthrough).Bool(flag.TrackEventsFallthrough);
if (flag.DebugEventsUntilDate.HasValue)
{
obj.Name("debugEventsUntilDate").Long(flag.DebugEventsUntilDate.Value.Value);
}
obj.Name("clientSide").Bool(flag.ClientSide);
obj.End();
}
/// <summary>
/// When overridden in the derived class, writes the values unique to this derived type to the
/// <paramref name="writer"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write to.</param>
protected override void WriteCustomValues(IValueWriter writer)
{
writer.Write(_automaticSizeValueKey, AutomaticSize);
writer.WriteStartNode(_textureNodeName);
writer.Write(_textureNameValueKey, TextureName);
writer.Write(_textureSourceValueKey, OriginalSourceRect);
writer.WriteEndNode(_textureNodeName);
}
/// <summary>
/// When overridden in the derived class, writes a value to an IValueWriter with the specified name.
/// </summary>
/// <param name="name">Name of the value.</param>
/// <param name="writer">IValueWriter to write to.</param>
/// <param name="value">Value to write.</param>
protected override void Write(string name, IValueWriter writer, SPValueType value)
{
value.Write(writer, name);
}
public void OnReadValue(object obj, IValueWriter valueWriter)
{
ValueInterface <TValue> .Content.WriteValue(valueWriter, value);
}
/// <summary>
/// Writes the state of the object to an <see cref="IValueWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write the values to.</param>
void IPersistable.WriteState(IValueWriter writer)
{
PersistableHelper.Write(this, writer);
/*
writer.Write(_keyID, ID);
writer.Write(_keyHasSound, Sound.HasValue);
writer.Write(_keySoundID, (Sound.HasValue ? Sound.Value : new SoundID(0)));
writer.Write(_keyScript, Script);
writer.Write(_keyGrhIndex, GrhIndex);
writer.Write(_keyParticleEffect, ParticleEffect);*/
}
public void WriteValue(IValueWriter valueWriter, T value)
{
Get(valueWriter as ITargetedBind).WriteValue(valueWriter, value);
}
public void WriteValue(IValueWriter valueWriter, DateTimeOffset value)
{
valueWriter.WriteString(value.ToString(format));
}
/// <summary>
/// Writes the <see cref="ColumnSchema"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write to.</param>
public void Write(IValueWriter writer)
{
var v = _values.OrderBy(x => x.Key).ToArray();
writer.WriteManyNodes(_valuesNodeName, v, WriteKVP);
}
/// <summary>
/// Writes the <see cref="Skeleton"/> to an <see cref="IValueWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write to.</param>
/// <exception cref="ArgumentNullException"><paramref name="writer" /> is <c>null</c>.</exception>
public void Write(IValueWriter writer)
{
if (writer == null)
throw new ArgumentNullException("writer");
writer.WriteManyNodes(_nodesNodeName, RootNode.GetAllNodes(), ((w, item) => item.Write(w)));
}
/// <summary>
/// When overridden in the derived class, writes all custom state values to the <paramref name="writer"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write the state values to.</param>
protected override void WriteCustomValues(IValueWriter writer)
{
writer.Write(_heightKeyName, Height);
writer.Write(_widthKeyName, Width);
writer.Write(_perimeterKeyName, Perimeter);
}
public void OnReadValue(object obj, IValueWriter valueWriter)
{
Assert(CanRead, "get");
ValueInterface <TValue> .Content.WriteValue(valueWriter, _get(obj));
}
public void WriteValue(IValueWriter valueWriter, ushort value)
{
valueWriter.WriteUInt16(value);
}
/// <summary>
/// Writes the <see cref="GuildID"/> to an <see cref="IValueWriter"/>.
/// </summary>
/// <param name="writer">IValueWriter to write to.</param>
/// <param name="name">Unique name of the <see cref="GuildID"/> that will be used to distinguish it
/// from other values when reading.</param>
public void Write(IValueWriter writer, string name)
{
writer.Write(name, _value);
}
/// <summary>
/// Writes the <see cref="NPCChatDialogBase"/>'s values to an <see cref="IValueWriter"/>.
/// </summary>
/// <param name="writer"><see cref="IValueWriter"/> to write the values to.</param>
public void Write(IValueWriter writer)
{
var items = GetDialogItems();
writer.Write(_nodeValueKeyID, ID);
writer.Write(_nodeValueKeyTitle, Title);
writer.WriteManyNodes(_nodeValueKeyItems, items, ((w, item) => item.Write(w)));
}
/// <summary>
/// Writes a <see cref="GuildID"/> to a <see cref="IValueWriter"/>.
/// </summary>
/// <param name="valueWriter"><see cref="IValueWriter"/> to write to.</param>
/// <param name="name">Unique name of the <see cref="GuildID"/> that will be used to distinguish it
/// from other values when reading.</param>
/// <param name="value"><see cref="GuildID"/> to write.</param>
public static void Write(this IValueWriter valueWriter, string name, GuildID value)
{
value.Write(valueWriter, name);
}
/// <summary>
/// Writes the state of the object to an <see cref="IValueWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write the values to.</param>
public virtual void WriteState(IValueWriter writer)
{
PersistableHelper.Write(this, writer);
}
public override void WritePayload(ISerializationContext context, IValueWriter writer)
{
if (writer.WriteBool (Accepted))
Target.Serialize (context, writer);
}
/// <summary>
/// Writes the state of the object to an <see cref="IValueWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="IValueWriter"/> to write the values to.</param>
public virtual void WriteState(IValueWriter writer)
{
PersistableHelper.Write(this, writer);
}
public void Serialize(IValueWriter writer)
{
}
private void WriteEntity(NetworkEntity entity, ISerializationContext context, IValueWriter writer)
{
writer.WriteString (entity.EntityName);
writer.WriteUInt16 ((UInt16)entity.NetworkID);
writer.WriteUInt16 ((UInt16)entity.Fields.Count);
foreach (var kvp in entity.Fields)
{
object fieldValue = kvp.Value.Value;
writer.WriteString (kvp.Key);
// Write the field type
ushort typeID;
context.TypeMap.GetTypeId (fieldValue.GetType (), out typeID);
writer.WriteUInt16 (typeID);
if (fieldValue is Vector2)
writer.Write (context, (Vector2)fieldValue, Vector2Serializer.Instance);
else if (fieldValue is Vector3)
writer.Write (context, (Vector3)fieldValue, Vector3Serializer.Instance);
else
writer.Write (context, fieldValue, kvp.Value.Type);
}
}
public void Write(IValueWriter writer)
{
writer.WriteManyNodes(_itemsNodeName, Items, ((w, item) => item.Write(w)));
}
public void WriteValue(IValueWriter valueWriter, JsonValue value)
{
ValueInterface.WriteValue(valueWriter, value.value);
}
public override void WritePayload (ISerializationContext context, IValueWriter writer)
{
writer.WriteString (Nickname);
}
