public void Execute(CollisionEvent collisionEvent)
{
if (dealDamageGroup.HasComponent(collisionEvent.Entities.EntityA))
{
if (damageGroup.Exists(collisionEvent.Entities.EntityB))
{
damageGroup[collisionEvent.Entities.EntityB].Add(new Damage
{
Value = dealDamageGroup[collisionEvent.Entities.EntityA].Value
});
if (fmodGroup.Exists(collisionEvent.Entities.EntityB) && translationGroup.Exists(collisionEvent.Entities.EntityB))
{
SoundManager.GetInstance().PlayOneShotSound(fmodGroup[collisionEvent.Entities.EntityB].DiePath.ToString(), translationGroup[collisionEvent.Entities.EntityB].Value);
}
}
}
if (dealDamageGroup.HasComponent(collisionEvent.Entities.EntityB))
{
if (damageGroup.Exists(collisionEvent.Entities.EntityA))
{
damageGroup[collisionEvent.Entities.EntityA].Add(new Damage
{
Value = dealDamageGroup[collisionEvent.Entities.EntityB].Value
});
if (fmodGroup.Exists(collisionEvent.Entities.EntityA) && translationGroup.Exists(collisionEvent.Entities.EntityA))
{
SoundManager.GetInstance().PlayOneShotSound(fmodGroup[collisionEvent.Entities.EntityA].DiePath.ToString(), translationGroup[collisionEvent.Entities.EntityA].Value);
}
}
}
}
public void Execute(TriggerEvent triggerEvent)
{
if (dealDamageGroup.HasComponent(triggerEvent.Entities.EntityA))
{
if (damageGroup.Exists(triggerEvent.Entities.EntityB))
{
DealDamage dealDamage = dealDamageGroup[triggerEvent.Entities.EntityA];
damageGroup[triggerEvent.Entities.EntityB].Add(new Damage
{
DamageTypeId = dealDamage.DamageTypeId,
Value = dealDamage.Value
});
}
}
if (dealDamageGroup.HasComponent(triggerEvent.Entities.EntityB))
{
if (damageGroup.Exists(triggerEvent.Entities.EntityA))
{
DealDamage dealDamage = dealDamageGroup[triggerEvent.Entities.EntityB];
damageGroup[triggerEvent.Entities.EntityA].Add(new Damage
{
DamageTypeId = dealDamage.DamageTypeId,
Value = dealDamage.Value
});
}
}
}
private void MakeDamage(Entity bomb, Entity enemy)
{
var explosionComponent = explosionGroup[bomb];
if (explosionComponent.explode)
{
if (damageGroup.Exists(enemy) &&
enemiesGroup.Exists(enemy))
{
var damage = (int)(explosionComponent.damage *
(1 - min(1,
(distance(translationGroup[bomb].Value, translationGroup[enemy].Value) -
2) / 6)));
damageGroup[enemy].Add(new Damage
{
Value = damage
});
}
}
else
{
if (damageGroup.Exists(enemy) &&
enemiesGroup.Exists(enemy))
{
if (distance(translationGroup[bomb].Value,
translationGroup[enemy].Value) < 2f)
{
explosionComponent.timer = explosionComponent.ttl;
explosionGroup[bomb] = explosionComponent;
}
}
}
}
public void Execute(TriggerEvent triggerEvent)
{
Entity entityA = triggerEvent.Entities.EntityA;
Entity entityB = triggerEvent.Entities.EntityB;
//The wind will never affect itself
if (entityA != entityB)
{
bool isAWindController = WindControllerGroup.Exists(entityA);
bool isBWindController = WindControllerGroup.Exists(entityB);
bool isAVelocityCurveBuffer = VelocityCurveBufferGroup.Exists(entityA);
bool isBVelocityCurveBuffer = VelocityCurveBufferGroup.Exists(entityB);
//Entity A is a WindController and
//Entity B is a VelocityCurveBuffer
if (isAWindController && isBVelocityCurveBuffer)
{
ApplyWind(entityA,
entityB);
}
//Entity B is a WindController and
//Entity A is a VelocityCurveBuffer
if (isBWindController && isAVelocityCurveBuffer)
{
ApplyWind(entityB,
entityA);
}
}
}
/// <summary>
/// This will be called after input has been sampled and applied to this job data structure;
/// more specifically, at the ScheduleSingle() call down at the bottom of OnUpdate()
/// </summary>
public void Execute(Entity entity, int index, [ReadOnly] ref CommandTargetComponent state)
{
// If this CTC doesn't have an entity, that means it is a connected client with no
// existing ship entity. So, we spawn one!
if (state.targetEntity == Entity.Null)
{
// Spawn the player once they press the spacebar (i.e. the shoot button)
if (shoot != 0)
{
// Create an empty entity for the player...
var req = commandBuffer.CreateEntity(index);
// PlayerSpawnRequest is processed in SpawnSystem.cs, which is server-side.
commandBuffer.AddComponent <PlayerSpawnRequest>(index, req);
// Attach a component that can take RPC commands intended for this entity (this player)
commandBuffer.AddComponent(index, req, new SendRpcCommandRequestComponent {
TargetConnection = entity
});
}
}
// This CTC does have a ship entity, so we want to send command data for it
else
{
// If ship present, store commands in network command buffer
// Honestly no clue what "Exists()" means. At all. Documentation is all
// auto-generated, there's no comments about this.
if (inputFromEntity.Exists(state.targetEntity))
{
var input = inputFromEntity[state.targetEntity];
input.AddCommandData(new ShipCommandData {
tick = inputTargetTick, left = left, right = right, thrust = thrust, shoot = shoot
});
}
}
}
public void Execute(Entity laserEntity, int index,
[ReadOnly, ChangedFilter] DynamicBuffer <PhysicsRaycastResults> raycastResults,
[ReadOnly] ref Laser laser, [ReadOnly] ref ActorAttribute3Offset <_HP> hpOffset, [ReadOnly] ref Translation laserTranslation,
[ReadOnly] ref ActorOwner actorOwner, [ReadOnly] ref Actor actor)
{
for (var i = 0; i < raycastResults.Length; ++i)
{
var raycastResult = raycastResults[i];
var distance = math.distance(laserTranslation.Value, raycastResult.point);
var percent = 1f - distance / laser.distance;
var hp = hpOffset.GetValue(percent);
var targetEntity = raycastResult.entity;
if (hpModifyFromEntity.Exists(targetEntity))
{
hpModifyFromEntity[targetEntity].Add(new ActorAttribute3Modifys <_HP>
{
player = actorOwner.playerEntity,
type = actor.actorType,
value = hp,
attribute3ModifyType = Attribute3SubModifyType.ValueOffset
});
}
//
var translation = new Translation {
Value = raycastResult.point
};
AttributeModifyFxSpawner.createInServer(endCommandBuffer, index, actor.actorType, translation, hp, 0f, default);
}
}
public void Execute(Entity entity, int index, [ReadOnly] ref SendRpcCommandRequestComponent dest,
[ReadOnly] ref TActionRequest action)
{
commandBuffer.DestroyEntity(index, entity);
if (connections.Length > 0)
{
if (dest.TargetConnection != Entity.Null)
{
if (!rpcFromEntity.Exists(dest.TargetConnection))
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
throw new InvalidOperationException("Cannot send RPC with no remote connection.");
#else
return;
#endif
}
var buffer = rpcFromEntity[dest.TargetConnection];
rpcQueue.Schedule(buffer, action);
}
else
{
for (var i = 0; i < connections.Length; ++i)
{
var buffer = rpcFromEntity[connections[i]];
rpcQueue.Schedule(buffer, action);
}
}
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
else
{
throw new InvalidOperationException("Cannot send RPC with no remote connection.");
}
#endif
}
public void Execute(Entity entity, int index,
[ReadOnly, ChangedFilter] DynamicBuffer <PhysicsTriggerResults> physicsTriggerResults,
[ReadOnly] ref ActorAttribute3Offset <_HP> hpOffset,
[ReadOnly] ref ActorOwner actorOwner, [ReadOnly] ref Actor actor)
{
for (var i = 0; i < physicsTriggerResults.Length; ++i)
{
var targetEntity = physicsTriggerResults[i].entity;
var hp = hpOffset.GetValue(random.NextFloat(0f, 1f));
if (hpModifyFromEntity.Exists(targetEntity))
{
hpModifyFromEntity[targetEntity].Add(new ActorAttribute3Modifys <_HP>
{
player = actorOwner.playerEntity,
type = actor.actorType,
value = hp,
attribute3ModifyType = Attribute3SubModifyType.ValueOffset
});
}
//
var translation = translationFromEntity[targetEntity];
AttributeModifyFxSpawner.createInServer(endCommandBuffer, index, actor.actorType, translation, hp, 0f, default);
}
}
void ChildLocalToWorld(float4x4 parentLocalToWorld, Entity entity, bool updateChildrenTransform)
{
bool transformChanged = LocalToParentFromEntity.DidChange(entity, LastSystemVersion);
updateChildrenTransform = updateChildrenTransform || transformChanged;
float4x4 localToWorldMatrix;
if (updateChildrenTransform && LocalToWorldWriteGroupMask.Matches(entity))
{
var localToParent = LocalToParentFromEntity[entity];
localToWorldMatrix = math.mul(parentLocalToWorld, localToParent.Value);
LocalToWorldFromEntity[entity] = new LocalToWorld {
Value = localToWorldMatrix
};
}
else //This entity has a component with the WriteGroup(LocalToWorld)
{
localToWorldMatrix = LocalToWorldFromEntity[entity].Value;
}
if (ChildFromEntity.Exists(entity))
{
var children = ChildFromEntity[entity];
for (int i = 0; i < children.Length; i++)
{
ChildLocalToWorld(localToWorldMatrix, children[i].Value, updateChildrenTransform);
}
}
}
public void UpdateTransformRecursive(ref WorldSpaceRect parentLocalToWorldSpaceRect, WorldSpaceMask currentMask, Entity entity, float2 scale)
{
if (DisabledFromEntity.Exists(entity))
{
return;
}
var childTransform = RectTransformFromEntity[entity];
var childLocalToWorld = RectTransformUtils.CalculateWorldSpaceRect(parentLocalToWorldSpaceRect, scale, childTransform);
WorldSpaceRectFromEntity[entity] = childLocalToWorld;
ElementScaleFromEntity[entity] = new ElementScale()
{
Value = scale
};
UpdateRectMask(entity, childLocalToWorld, ref currentMask);
WorldSpaceMaskFromEntity[entity] = currentMask;
if (RebuildFlagFromEntity.Exists(entity))
{
RebuildFlagFromEntity[entity] = new RebuildElementMeshFlag()
{
Rebuild = true
}
}
;
if (ChildrenFromEntity.Exists(entity))
{
var children = ChildrenFromEntity[entity];
for (int i = 0; i < children.Length; i++)
{
UpdateTransformRecursive(ref childLocalToWorld, currentMask, children[i].Value, scale);
}
}
}
public void Execute(Entity entity, int index, [ReadOnly] ref CommandTargetComponent state)
{
if (state.targetEntity == Entity.Null)
{
if (shoot != 0)
{
rpcQueue.Schedule(rpcBuffer[entity], new RpcSpawn());
}
}
else
{
// If ship, store commands in network command buffer
// FIXME: when destroying the ship is in a command buffer this no longer works
if (shipState.Exists(state.targetEntity)) // There might be a pending set to null
{
shipState[state.targetEntity] = new ShipStateComponentData(thrust, true);
}
if (inputFromEntity.Exists(state.targetEntity))
{
var input = inputFromEntity[state.targetEntity];
input.AddCommandData(new ShipCommandData {
tick = inputTargetTick, left = left, right = right, thrust = thrust, shoot = shoot
});
}
}
}
public void Execute(Entity entity, int index, [ReadOnly] ref CommandTargetComponent state)
{
if (shoot != 0)
{
var req = commandBuffer.CreateEntity(index);
commandBuffer.AddComponent <FireBulletRequest>(index, req);
commandBuffer.AddComponent(index, req, new SendRpcCommandRequestComponent {
TargetConnection = entity
});
}
if (state.targetEntity == Entity.Null)
{
}
else
{
// If ship, store commands in network command buffer
if (inputFromEntity.Exists(state.targetEntity))
{
Debug.Log("Does this get called");
var input = inputFromEntity[state.targetEntity];
input.AddCommandData(new TestCommandData {
tick = inputTargetTick, shoot = shoot
});
}
}
}
public void Execute(Entity entity, int index, [ReadOnly] ref CommandTargetComponent state)
{
if (state.targetEntity == Entity.Null)
{
if (shoot != 0)
{
var req = commandBuffer.CreateEntity(index);
commandBuffer.AddComponent <PlayerSpawnRequest>(index, req);
commandBuffer.AddComponent(index, req, new SendRpcCommandRequestComponent {
TargetConnection = entity
});
}
}
else
{
// If ship, store commands in network command buffer
if (inputFromEntity.Exists(state.targetEntity))
{
var input = inputFromEntity[state.targetEntity];
input.AddCommandData(new ShipCommandData {
tick = inputTargetTick, left = left, right = right, thrust = thrust, shoot = shoot
});
}
}
}
public void Execute(TriggerEvent triggerEvent)
{
var entityA = triggerEvent.Entities.EntityA;
var entityB = triggerEvent.Entities.EntityB;
if (agentData.Exists(entityA) && agentData.Exists(entityB))
{
AgentData adA = agentData[entityA];
AgentData adB = agentData[entityB];
if (TriggerStayRefsFromEntity.Exists(entityA))
{
TriggerStayRefsFromEntity[entityA].Add(new TriggerStayRef {
pos = adB.position, vel = adB.direction * adB.speed
});
}
//if (TriggerStayRefsFromEntity.Exists(entityB))
//TriggerStayRefsFromEntity[entityB].Add(new TriggerStayRef { pos = adA.position, vel = adA.direction * adA.speed });
}
//Planned to be used for wall/obstacle detection (WIP)
if (agentData.Exists(entityA) && !agentData.Exists(entityB) && translationData.Exists(entityB))
{
AgentData adA = agentData[entityA];
Translation trB = translationData[entityB];
float3 origin = adA.position;
float3 offset = trB.Value - origin;
}
}
void ChildLocalToWorld(float4x4 parentLocalToWorld, Entity entity)
{
var localToParent = LocalToParentFromEntity[entity];
float4x4 localToWorldMatrix;
if (LocalToWorldWriteGroupMask.Matches(entity))
{
localToWorldMatrix = math.mul(parentLocalToWorld, localToParent.Value);
LocalToWorldFromEntity[entity] = new LocalToWorld {
Value = localToWorldMatrix
};
}
else //This entity has a component with the WriteGroup(LocalToWorld)
{
localToWorldMatrix = LocalToWorldFromEntity[entity].Value;
}
if (ChildFromEntity.Exists(entity))
{
var children = ChildFromEntity[entity];
for (int i = 0; i < children.Length; i++)
{
ChildLocalToWorld(localToWorldMatrix, children[i].Value);
}
}
}
public void Execute()
{
for (int index = 0; index < TriggerEntitiesCount[0]; index++)
{
var entities = TriggerEntites[index];
// Increment the frame count only for those entities that are
// still in the TriggerEvent list.
// TODO: this assumes overlapping of only one TriggerVolume at a time.
// TODO: we should really compare the entities.VolumeEntity is the
// same as that saved in the component. The OverlappingEntity
// may have jumped from inside one TriggerVolume to another in
// a single frame
if (OverlappingGroup.Exists(entities.OverlappingEntity))
{
var component = OverlappingGroup[entities.OverlappingEntity];
//component.CurrentFrame++;
//OverlappingGroup[entities.OverlappingEntity] = component;
for (int i = 0; i < component.Length; i++)
{
var a = component[i];
a.CurrentFrame++;
component[i] = a;
}
}
}
}
private void ProcessForEntity(Entity entity, Entity otherEntity)
{
if (TriggerEventBufferFromEntity.Exists(entity))
{
DynamicBuffer <TriggerEventBufferElement> triggerEventBuffer = TriggerEventBufferFromEntity[entity];
bool foundMatch = false;
for (int i = 0; i < triggerEventBuffer.Length; i++)
{
TriggerEventBufferElement triggerEvent = triggerEventBuffer[i];
// If entity is already there, update to Stay
if (triggerEvent.Entity == otherEntity)
{
foundMatch = true;
triggerEvent.State = PhysicsEventState.Stay;
triggerEvent._isStale = false;
triggerEventBuffer[i] = triggerEvent;
break;
}
}
// If it's a new entity, add as Enter
if (!foundMatch)
{
triggerEventBuffer.Add(new TriggerEventBufferElement {
Entity = otherEntity,
State = PhysicsEventState.Enter,
_isStale = false,
});
}
}
}
public void Execute(Entity entity, int index, ref DamageEvent c0)
{
if (DamageStackBuffer.Exists(c0.Receiver))
{
DamageStackBuffer[c0.Receiver].Add(c0);
}
ECB.DestroyEntity(index, entity);
}
public void Execute(CollisionEvent collisionEvent)
{
if (collisions.Exists(collisionEvent.Entities.EntityA))
{
collisions[collisionEvent.Entities.EntityA].Add(new CollisionBufferData()
{
entity = collisionEvent.Entities.EntityB
});
}
if (collisions.Exists(collisionEvent.Entities.EntityB))
{
collisions[collisionEvent.Entities.EntityB].Add(new CollisionBufferData()
{
entity = collisionEvent.Entities.EntityA
});
}
}
public void Execute(TriggerEvent triggerEvent)
{
if (triggers.Exists(triggerEvent.Entities.EntityA))
{
triggers[triggerEvent.Entities.EntityA].Add(new TriggerBufferData()
{
entity = triggerEvent.Entities.EntityB
});
}
if (triggers.Exists(triggerEvent.Entities.EntityB))
{
triggers[triggerEvent.Entities.EntityB].Add(new TriggerBufferData()
{
entity = triggerEvent.Entities.EntityA
});
}
}
void RecursiveChildsDestroy(Entity entity, int index)
{
EntityCommandBuffer.DestroyEntity(index, entity);
if (ChildFromEntity.Exists(entity))
{
var children = ChildFromEntity[entity];
for (int i = 0; i < children.Length; i++)
{
RecursiveChildsDestroy(children[i].Value, index);
}
}
}
public void Execute([ReadOnly] ref NetworkStreamConnection connection,
[ReadOnly] ref NetworkSnapshotAckComponent ack, [ReadOnly] ref CommandTargetComponent state)
{
if (isNullCommandData && state.targetEntity != Entity.Null)
{
return;
}
if (!isNullCommandData && !inputFromEntity.Exists(state.targetEntity))
{
return;
}
DataStreamWriter writer = driver.BeginSend(unreliablePipeline, connection.Value);
if (!writer.IsCreated)
{
return;
}
writer.WriteByte((byte)NetworkStreamProtocol.Command);
writer.WriteUInt(ack.LastReceivedSnapshotByLocal);
writer.WriteUInt(ack.ReceivedSnapshotByLocalMask);
writer.WriteUInt(localTime);
uint returnTime = ack.LastReceivedRemoteTime;
if (returnTime != 0)
{
returnTime -= (localTime - ack.LastReceiveTimestamp);
}
writer.WriteUInt(returnTime);
writer.WriteUInt(interpolationDelay);
writer.WriteUInt(inputTargetTick);
if (state.targetEntity != Entity.Null)
{
var input = inputFromEntity[state.targetEntity];
TCommandData baselineInputData;
input.GetDataAtTick(inputTargetTick, out baselineInputData);
baselineInputData.Serialize(ref writer);
for (uint inputIndex = 1; inputIndex < k_InputBufferSendSize; ++inputIndex)
{
TCommandData inputData;
input.GetDataAtTick(inputTargetTick - inputIndex, out inputData);
inputData.Serialize(ref writer, baselineInputData, compressionModel);
}
writer.Flush();
}
#if UNITY_EDITOR || DEVELOPMENT_BUILD
netStats[0] = inputTargetTick;
netStats[1] = (uint)writer.Length;
#endif
driver.EndSend(writer);
}
private void MakeDamage(Entity entityA, Entity entityB)
{
if (!explosionComponent[entityA].explode)
{
if (damageGroup.Exists(entityB) &&
enemiesGroup.Exists(entityB))
{
var movementData = movementGroup[entityA];
movementData.speed = 0;
movementGroup[entityA] = movementData;
}
}
}
void RecursiveChildsDisable(Entity entity, int index)
{
if (ChildFromEntity.Exists(entity))
{
var children = ChildFromEntity[entity];
for (int i = 0; i < children.Length; i++)
{
RecursiveChildsDisable(children[i].Value, index);
}
}
EntityCommandBuffer.AddComponent <Disabled>(index, entity);
EntityCommandBuffer.RemoveComponent <DisableHierarchy>(index, entity);
}
public void Execute()
{
foreach (TriggerEvent collisionEvent in CollisionEvents)
{
Entity entityA = PhysicsWorld.Bodies[collisionEvent.BodyIndices.BodyAIndex].Entity;
Entity entityB = PhysicsWorld.Bodies[collisionEvent.BodyIndices.BodyBIndex].Entity;
if (CollisionInfoBuffer.Exists(entityA))
{
CollisionInfoBuffer[entityA].Add(new CollisionInfo()
{
other = entityB
});
}
if (CollisionInfoBuffer.Exists(entityB))
{
CollisionInfoBuffer[entityB].Add(new CollisionInfo()
{
other = entityA
});
}
}
}
public static Entity GetRootEntity <T>(
Entity entity, ComponentDataFromEntity <Parent> parentFromEntity, BufferFromEntity <T> bufferFromEntity)
where T : struct, IBufferElementData
{
if (!parentFromEntity.Exists(entity) || bufferFromEntity.Exists(entity))
{
return(entity);
}
else
{
return(GetRootEntity(parentFromEntity[entity].Value, parentFromEntity, bufferFromEntity));
}
}
public void Execute()
{
var parents = UniqueParents.GetKeyArray(Allocator.Temp);
for (int i = 0; i < parents.Length; i++)
{
var parent = parents[i];
if (!ChildFromEntity.Exists(parent))
{
ParentsMissingChild.Add(parent);
}
}
}
void DestroyHierarchy(EntityCommandBuffer.Concurrent cmdBuffer, Entity entity, int index, BufferFromEntity <Child> childrenFromEntity)
{
cmdBuffer.DestroyEntity(index, entity);
if (!childrenFromEntity.Exists(entity))
{
return;
}
var children = childrenFromEntity[entity];
for (var i = 0; i < children.Length; ++i)
{
DestroyHierarchy(cmdBuffer, children[i].Value, index, childrenFromEntity);
}
}
public unsafe void Execute(Entity entity, int index, [ReadOnly] ref CommandTargetComponent commandTarget,
ref NetworkSnapshotAckComponent snapshotAck)
{
if (typeof(TCommandData) == typeof(NullCommandData) && commandTarget.targetEntity != Entity.Null)
{
return;
}
if (typeof(TCommandData) != typeof(NullCommandData) && !commandData.Exists(commandTarget.targetEntity))
{
return;
}
var buffer = cmdBuffer[entity];
if (buffer.Length < 4)
{
return;
}
DataStreamReader reader =
DataStreamUnsafeUtility.CreateReaderFromExistingData((byte *)buffer.GetUnsafePtr(), buffer.Length);
var ctx = default(DataStreamReader.Context);
var tick = reader.ReadUInt(ref ctx);
int age = (int)(serverTick - tick);
age *= 256;
snapshotAck.ServerCommandAge = (snapshotAck.ServerCommandAge * 7 + age) / 8;
if (commandTarget.targetEntity != Entity.Null && buffer.Length > 4)
{
var command = commandData[commandTarget.targetEntity];
var baselineReceivedCommand = default(TCommandData);
baselineReceivedCommand.Deserialize(tick, reader, ref ctx);
// Store received commands in the network command buffer
command.AddCommandData(baselineReceivedCommand);
for (uint i = 1; i < CommandSendSystem <TCommandData> .k_InputBufferSendSize; ++i)
{
var receivedCommand = default(TCommandData);
receivedCommand.Deserialize(tick - i, reader, ref ctx, baselineReceivedCommand,
compressionModel);
// Store received commands in the network command buffer
command.AddCommandData(receivedCommand);
}
}
#if UNITY_EDITOR || DEVELOPMENT_BUILD
netStats[0] = serverTick;
netStats[1] += (uint)buffer.Length + 16u; // 16 is the ack fields which are already processed
#endif
buffer.Clear();
}
void ChildTimeScale(float parentTimeScale, Entity entity, bool updateChildrenTimeScale, int depth)
{
if (depth++ > recursiveDepthLimit)
{
LogError(entity);
return;
}
bool IsWritingByParentAndLocal = timeScaleWriteGroupMaskLocalParent.Matches(entity);
updateChildrenTimeScale = updateChildrenTimeScale || (IsWritingByParentAndLocal && LocalTimeScaleFromEntity.DidChange(entity, LastSystemVersion));
bool needUpdate = true;
if (updateChildrenTimeScale)
{
if (IsWritingByParentAndLocal)
{
if (TimeScaleFromEntity[entity].KeepTimeScaleOnParentChange)
{
LocalTimeScaleFromEntity[entity] = parentTimeScale != 0 ? TimeScaleFromEntity[entity].value / parentTimeScale : TimeScaleFromEntity[entity].value;
}
parentTimeScale *= LocalTimeScaleFromEntity[entity].KeepTimeScale ? -LocalTimeScaleFromEntity[entity].value : LocalTimeScaleFromEntity[entity].value;
TimeScaleFromEntity[entity] = new TimeScale(parentTimeScale, TimeScaleFromEntity[entity].KeepTimeScaleOnParentChange);
needUpdate = false;
}
else if (timeScaleWriteGroupMaskParent.Matches(entity))
{
TimeScaleFromEntity[entity] = new TimeScale(parentTimeScale, TimeScaleFromEntity[entity].KeepTimeScaleOnParentChange);
needUpdate = false;
}
}
if (needUpdate)//This entity has a component with the WriteGroup(TimeScale)
{
parentTimeScale = LocalTimeScaleFromEntity[entity].KeepTimeScale ? -TimeScaleFromEntity[entity].value: TimeScaleFromEntity[entity].value;
}
LocalTimeScaleFromEntity[entity] = LocalTimeScaleFromEntity[entity].KeepTimeScale ? -LocalTimeScaleFromEntity[entity].value : LocalTimeScaleFromEntity[entity].value;
if (ChildFromEntity.Exists(entity))
{
var children = ChildFromEntity[entity];
for (int i = 0; i < children.Length; i++)
{
ChildTimeScale(parentTimeScale, children[i].Value, updateChildrenTimeScale, depth);
}
}
}
