public override INetworkSerializable[] CreateSerializables(EntityManager entityManager, Entity entity)
{
var serializableArray = new INetworkSerializable[1];
serializableArray[0] = new SerializedComponentDataHandler <ProjectileData>(entityManager, entity);
return(serializableArray);
}
public static void Send(this NetworkConnection connection, byte header,
INetworkSerializable message, NetworkReliablity reliablity = NetworkReliablity.Reliable)
{
var writer = new Serializer();
writer.Write(header);
message.Serialize(writer);
connection.SendBytes(writer.AsArray(), writer.Position, reliablity);
(message as IDisposable)?.Dispose();
}
public void AddGob(int gobId, INetworkSerializable gob, SerializationModeFlags serializationMode)
{
// Note: Data in GobUpdateMessage may get lost on client because of this case:
// Client doesn't have the gob at the moment the update message is received.
// Because the gob doesn't exist, the client doesn't know the type of the gob and
// therefore has no way of knowing how many bytes in the message are for that one gob.
// The only solution is to skip the remaining message, losing many gob updates.
// This is why GobUpdateMessage sends only varying data.
if (_state != StateType.Initial && _state != StateType.AddingGobs) throw new InvalidOperationException("Cannot add a gob in state " + _state);
_state = StateType.AddingGobs;
_gobIds.Add(gobId);
Write(gob, serializationMode);
}
public void Add(int id, INetworkSerializable spectatorOrTeam, SerializationModeFlags serializationMode)
{
_ids.Add(id);
Write(spectatorOrTeam, serializationMode);
}
public void Write(INetworkSerializable msg) => msg.Serialize(this);
public void Add(int id, INetworkSerializable item, SerializationModeFlags mode)
{
_ids.Add(id);
Write(item, mode);
}
public void Add(INetworkSerializable message)
{
message.Serialize(this);
}
/// <summary>
/// Writes a serialisable object to streamed data,
/// appending to previously written streamed data.
/// </summary>
/// <param name="serializable">The object to serialise.</param>
/// <param name="mode">What to serialise of the serialisable object.</param>
/// <returns>The number of serialised bytes.</returns>
public int Write(INetworkSerializable serializable, SerializationModeFlags mode)
{
switch (DataMode)
{
case DataModeType.Uninitialized:
_writer = NetworkBinaryWriter.Create(new MemoryStream());
break;
case DataModeType.SettingDataByWrite:
break;
default:
throw new InvalidOperationException("Cannot Write() streamed data in mode " + DataMode);
}
DataMode = DataModeType.SettingDataByWrite;
long oldPos = _writer.Seek(0, SeekOrigin.Current);
serializable.Serialize(_writer, mode);
long newPos = _writer.Seek(0, SeekOrigin.Current);
return (int)(newPos - oldPos);
}
/// <summary>
/// Reads the state of a serialisable object from streamed data
/// at the current read position.
/// </summary>
/// <param name="serializable">The object to adopt the serialised state.</param>
/// <param name="mode">What kind of state we are deserialising. Must match
/// the mode the data was written in.</param>
/// <param name="framesAgo">How long ago was the message current.</param>
public void Read(INetworkSerializable serializable, SerializationModeFlags mode, int framesAgo)
{
SetDataModeToRead();
serializable.Deserialize(_reader, mode, framesAgo);
// The reader will be closed when the message goes to garbage collection.
// For now, we leave it open for successive calls to Read().
//reader.Close();
}
