public override bool Write(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
if (obj.RootState.Entity.HasParent)
{
if (connection.entityChannel.ExistsOnRemote(obj.RootState.Entity.Parent))
{
packet.WriteEntity(obj.RootState.Entity.Parent);
}
else
{
return(false);
}
}
else
{
packet.WriteEntity(null);
}
if (PositionEnabled)
{
PositionCompression.Pack(packet, storage.Values[obj[this] + POSITION].Vector3);
if (Extrapolation.Enabled)
{
PositionCompression.Pack(packet, storage.Values[obj[this] + VELOCITY].Vector3);
}
}
if (RotationEnabled)
{
RotationCompression.Pack(packet, storage.Values[obj[this] + ROTATION].Quaternion);
}
return(true);
}
public void BeginSmoothing()
{
SmoothStorageFrom = DuplicateStorage(Storage);
SmoothStorageTo = DuplicateStorage(Storage);
SmoothFrameFrom = Core.Frame;
SmoothFrameTo = SmoothFrameFrom + Meta.SmoothFrames;
}
public override object DebugValue(NetworkObj obj, NetworkStorage storage)
{
if (storage.Values[obj[this]].ProtocolToken == null)
{
return("NULL");
}
return(storage.Values[obj[this]].ProtocolToken.ToString());
}
public void FreeStorage(NetworkStorage storage)
{
storage.Frame = 0;
storage.Root = null;
storage.ClearAll();
System.Array.Clear(storage.Values, 0, storage.Values.Length);
StoragePool.Push(storage);
}
public override bool Write(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
// adjust trigger
storage.Values[obj[this]].TriggerSend.Update(Core.Frame, false);
// write history
packet.WriteInt(storage.Values[obj[this]].TriggerSend.History, obj.RootState.Entity.SendRate);
// this always succeeds!
return(true);
}
public override object DebugValue(NetworkObj obj, NetworkStorage storage)
{
Entity entity = Core.FindEntity(storage.Values[obj[this]].NetworkId);
if (entity)
{
return(entity.ToString());
}
return("NULL");
}
public override void Read(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
if (Interpolation.Enabled)
{
storage.Values[obj[this] + 1].Float1 = Compression.Read(packet);
}
else
{
storage.Values[obj[this]].Float0 = Compression.Read(packet);
}
}
public NetworkStorage DuplicateStorage(NetworkStorage s)
{
NetworkStorage c;
c = AllocateStorage();
c.Root = s.Root;
c.Frame = s.Frame;
Array.Copy(s.Values, 0, c.Values, 0, s.Values.Length);
return(c);
}
public override void Read(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
UE.Vector3 v = Compression.Read(packet);
if (Interpolation.Enabled && (obj.Root is NetworkState))
{
storage.Values[obj[this] + 1].Vector3 = v;
}
else
{
storage.Values[obj[this]].Vector3 = v;
}
}
public override bool Write(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
try
{
packet.WriteToken(storage.Values[obj[this]].ProtocolToken);
return(true);
}
catch (Exception exn)
{
NetLog.Error("User code threw exception while serializing protocol token");
NetLog.Exception(exn);
return(false);
}
}
public override void Read(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
obj.RootState.Entity.SetParentInternal(packet.ReadEntity());
if (PositionEnabled)
{
storage.Values[obj[this] + POSITION].Vector3 = PositionCompression.Read(packet);
if (Extrapolation.Enabled)
{
storage.Values[obj[this] + VELOCITY].Vector3 = PositionCompression.Read(packet);
}
}
if (RotationEnabled)
{
storage.Values[obj[this] + ROTATION].Quaternion = RotationCompression.Read(packet);
}
}
public override void SmoothCommandCorrection(NetworkObj obj, NetworkStorage from, NetworkStorage to, NetworkStorage storage, float t)
{
if (Interpolation.Enabled)
{
var v0 = from.Values[obj[this]].Vector3;
var v1 = to.Values[obj[this]].Vector3;
var m = (v1 - v0).sqrMagnitude;
if (m < (Interpolation.SnapMagnitude * Interpolation.SnapMagnitude))
{
storage.Values[obj[this]].Vector3 = UE.Vector3.Lerp(v0, v1, t);
}
else
{
storage.Values[obj[this]].Vector3 = v1;
}
}
else
{
storage.Values[obj[this]].Vector3 = to.Values[obj[this]].Vector3;
}
}
void MecanimPull(NetworkObj obj, NetworkStorage storage)
{
if (obj.RootState.Animator == null)
{
return;
}
if (obj.RootState.Animator.GetBool(PropertyName) && (obj.RootState.Animator.IsInTransition(MecanimLayer) == false))
{
// update send trigger
storage.Values[obj[this]].TriggerSend.Update(Core.Frame, true);
// notify Ascension this property changed
storage.PropertyChanged(obj.OffsetProperties + this.OffsetProperties);
// invoke callback
var cb = obj.Storage.Values[obj[this]].Action;
if (cb != null)
{
cb();
}
}
}
public override object DebugValue(NetworkObj obj, NetworkStorage storage)
{
var nt = obj.Storage.Values[obj[this]].Transform;
if (nt != null && nt.Simulate)
{
var p = obj.Storage.Values[obj[this] + POSITION].Vector3;
var r = obj.Storage.Values[obj[this] + ROTATION].Quaternion;
var pos = string.Format("X:{0} Y:{1} Z:{2}", p.x.ToString("F2"), p.y.ToString("F2"), p.z.ToString("F2"));
var rot = string.Format("X:{0} Y:{1} Z:{2}", r.x.ToString("F2"), r.y.ToString("F2"), r.z.ToString("F2"));
var render = "";
if (nt.Render)
{
render = string.Format("(R: {0})", nt.Render.gameObject.name);
}
return(string.Format("{0} / {1}{2}", pos, rot, render));
}
return("NOT ASSIGNED");
}
public void FreeStorage(NetworkStorage storage)
{
Meta.FreeStorage(storage);
}
public virtual object DebugValue(NetworkObj obj, NetworkStorage storage)
{
return("NONE");
}
public Event(Event_Meta meta)
: base(meta)
{
Meta = meta;
storage = AllocateStorage();
}
public abstract bool Write(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet);
public abstract void Read(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet);
public virtual void OnFrameCloned(NetworkObj obj, NetworkStorage storage)
{
}
public virtual void SmoothCommandCorrection(NetworkObj obj, NetworkStorage from, NetworkStorage to, NetworkStorage storage, float t)
{
}
public override void Read(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
storage.Values[obj[this]].Color = packet.ReadColorRGBA();
}
public override void Read(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
storage.Values[obj[this]].Guid = packet.ReadGuid();
}
public override void Read(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
storage.Values[obj[this]].Matrix4x4 = packet.ReadMatrix4x4();
}
public Command(Command_Meta meta)
: base(meta)
{
Meta = meta;
storage = AllocateStorage();
}
public override bool Write(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
Compression.Pack(packet, storage.Values[obj[this]].Float0);
return(true);
}
public override bool Write(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
packet.WriteGuid(storage.Values[obj[this]].Guid);
return(true);
}
public override void OnFrameCloned(NetworkObj obj, NetworkStorage storage)
{
storage.Values[obj[this]].TriggerLocal.Frame = 0;
storage.Values[obj[this]].TriggerLocal.History = 0;
}
public override object DebugValue(NetworkObj obj, NetworkStorage storage)
{
return(storage.Values[obj[this]].Guid);
}
public override void Read(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
storage.Values[obj[this]].Int0 = Compression.Read(packet);
}
