static void Simulate(IDictionary <int, ITickObjectClient> dict, float normalizedTime, TickObjectEnumerator etor)
{
TickEvent ev = InstancePool.Get <TickEvent>();
uint serverTick = SyncManagerClient.Instance.serverTick;
while (etor.MoveNext())
{
TickObject obj = etor.Current;
ITickObjectClient tickObject;
if (dict.TryGetValue(obj.Id, out tickObject))
{
for (int i = 0; i < obj.EventsLength; ++i)
{
obj.GetEvents(ev, i);
if (serverTick == ev.Tick)
{
tickObject.EventUpdate(ev);
break;
}
}
if (!tickObject.predict)
{
tickObject.Lerping(normalizedTime, obj);
}
if (obj.TickObjectLength > 0 && null != tickObject.children)
{
Simulate(tickObject.children, normalizedTime, new TickObjectEnumerator(obj));
}
}
}
}
static VectorOffset SampleEvents(ITickObject obj, FlatBufferBuilder fbb, bool full)
{
VectorOffset vecOffset = default(VectorOffset);
if (!full && obj.eventType != TickEventType.NONE)
{
var eventVector = OffsetArrayPool.Alloc <TickEvent>((int)snapshotOverTick);
for (uint i = 0; i < snapshotOverTick; ++i)
{
int eventOffset = obj.SnapshotEvent(fbb, tickCount - snapshotOverTick + i);
if (eventOffset > 0)
{
eventVector.offsets[eventVector.position++] = TickEvent.CreateTickEvent(
fbb,
tickCount - snapshotOverTick + i,
obj.eventType,
eventOffset);
}
}
TickObject.StartEventsVector(fbb, eventVector.position);
vecOffset = Helpers.SetVector(fbb, eventVector);
OffsetArrayPool.Dealloc(ref eventVector);
}
return(vecOffset);
}
void Parse(TickObject obj, out Vector3 pos, out Quaternion rot)
{
Protocol.Kinematics data = InstancePool.Get <Protocol.Kinematics>();
obj.GetData(data);
Vec3 vec3 = InstancePool.Get <Vec3>();
data.GetPos(vec3);
pos = new Vector3(vec3.X, vec3.Y, vec3.Z);
data.GetRot(vec3);
rot = Quaternion.Euler(vec3.X, vec3.Y, vec3.Z);
}
static void FullUpdate(IDictionary <int, ITickObjectClient> dict, TickObjectEnumerator etor)
{
while (etor.MoveNext())
{
TickObject obj = etor.Current;
ITickObjectClient tickobject;
if (dict.TryGetValue(obj.Id, out tickobject))
{
tickobject.FullUpdate(obj);
if (obj.TickObjectLength > 0 && null != tickobject.children)
{
FullUpdate(tickobject.children, new TickObjectEnumerator(obj));
}
}
}
}
static void ApplyDeltaForPredict(IDictionary <int, ITickObjectClient> dict, TickObjectEnumerator etor)
{
while (etor.MoveNext())
{
TickObject obj = etor.Current;
ITickObjectClient tickobject;
if (dict.TryGetValue(obj.Id, out tickobject) && tickobject.predict)
{
tickobject.ApplyDeltaForPredict(obj);
}
if (obj.TickObjectLength > 0 && null != tickobject.children)
{
ApplyDeltaForPredict(tickobject.children, new TickObjectEnumerator(obj));
}
}
}
public override void Lerping(float t, TickObject obj)
{
Vector3 pos;
Quaternion rot;
Parse(obj, out pos, out rot);
transform.position = Vector3.Lerp(mPosition, pos, t);
transform.rotation = Quaternion.Lerp(mRotation, rot, t);
if (Mathf.Approximately(t, 1f))
{
mPosition = transform.position;
mRotation = transform.rotation;
}
}
static VectorOffset SampleSnapshot(IList <ITickObject> list, FlatBufferBuilder fbb, bool full)
{
var tickObjectOffset = default(VectorOffset);
if (null != list && list.Count > 0)
{
var boxArray = OffsetArrayPool.Alloc <TickObject>(list.Count);
foreach (var obj in list)
{
boxArray.offsets[boxArray.position++] = TickObject.CreateTickObject(
fbb,
obj.id,
obj.type,
SampleData(obj, fbb, full),
SampleEvents(obj, fbb, full),
SampleSnapshot(obj.children, fbb, full));
}
Msg_SC_Snapshot.StartTickObjectVector(fbb, boxArray.position);
tickObjectOffset = Helpers.SetVector(fbb, boxArray);
OffsetArrayPool.Dealloc(ref boxArray);
}
return(tickObjectOffset);
}
public override void ApplyDeltaForPredict(TickObject obj)
{
Parse(obj, out mPosition, out mRotation);
}
public override void FullUpdate(TickObject obj)
{
Parse(obj, out mPosition, out mRotation);
transform.position = mPosition;
transform.rotation = mRotation;
}
public void ApplyDeltaForPredict(TickObject obj)
{
}
public void Lerping(float t, TickObject obj)
{
}
public void FullUpdate(TickObject obj)
{
Protocol.Avatar data = InstancePool.Get <Protocol.Avatar>();
obj.GetData(data);
mCommon.color = (new Color()).FromInt(data.Color);
}
public abstract void ApplyDeltaForPredict(TickObject obj);
public abstract void Lerping(float t, TickObject obj);
public abstract void FullUpdate(TickObject obj);
