protected override void OnUpdate()
{
var group = World.GetExistingSystem <GhostPredictionSystemGroup>();
var tick = group.PredictingTick;
var deltaTime = Time.DeltaTime;
var isClient = World.GetExistingSystem <ClientSimulationSystemGroup>() != null;
Entities.ForEach((
DynamicBuffer <PlayerInput> inputBuffer,
ref PlayerView view,
ref Rotation rot,
in PlayerId playerId,
in PredictedGhostComponent prediction) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
PlayerInput input;
inputBuffer.GetDataAtTick(tick, out input);
view.pitch = input.targetPitch;
view.yaw = input.targetYaw;
rot.Value.value = quaternion.Euler(new float3(0, math.radians(view.yaw), 0)).value;
}).ScheduleParallel();
protected override void OnUpdate()
{
var group = World.GetExistingSystem <GhostPredictionSystemGroup>();
var tick = group.PredictingTick;
var deltaTime = Time.DeltaTime;
Entities.ForEach((
DynamicBuffer <PlayerInput> inputBuffer,
ref KCCVelocity velocity,
ref KCCJumping jump,
in PredictedGhostComponent prediction,
in PlayerView view,
in KCCMovementSettings settings) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
inputBuffer.GetDataAtTick(tick, out PlayerInput input);
// Rotate movement vector around current attitude (only care about horizontal)
float3 inputVector = new float3(input.horizMove, 0, input.vertMove);
// Don't allow the total movement to be more than the 1x max move speed
float3 direction = inputVector / math.max(math.length(inputVector), 1);
float speedMultiplier = input.IsSprinting ? settings.SprintSpeed : settings.moveSpeed;
quaternion horizPlaneView = quaternion.RotateY(math.radians(view.yaw));
// Make movement vector based on player input
velocity.playerVelocity = math.mul(horizPlaneView, direction) * speedMultiplier;
// including jump action
jump.attemptingJump = input.IsJumping;
}).Schedule();
protected override void OnCreate()
{
// m_BeginSimEcb = World.GetOrCreateSystem<BeginSimulationEntityCommandBufferSystem>();
//We will grab this system so we can use its "prediction tick" and "DeltaTime"
m_PredictionGroup = World.GetOrCreateSystem <GhostPredictionSystemGroup>();
}
protected override void OnUpdate()
{
var group = World.GetExistingSystem <GhostPredictionSystemGroup>();
var tick = group.PredictingTick;
var deltaTime = group.Time.DeltaTime;
Entities.ForEach((DynamicBuffer <CubeInput> inputBuffer, ref Translation trans, ref PredictedGhostComponent prediction) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
CubeInput input;
inputBuffer.GetDataAtTick(tick, out input);
if (input.Horizontal > 0)
{
trans.Value.x += deltaTime;
}
if (input.Horizontal < 0)
{
trans.Value.x -= deltaTime;
}
if (input.Vertical > 0)
{
trans.Value.y += deltaTime;
}
if (input.Vertical < 0)
{
trans.Value.y -= deltaTime;
}
});
}
protected override void OnCreate()
{
m_GhostUpdateSystemGroup = World.GetOrCreateSystem <GhostUpdateSystemGroup>();
m_ClientSimulationSystemGroup = World.GetOrCreateSystem <ClientSimulationSystemGroup>();
m_GhostPredictionSystemGroup = World.GetOrCreateSystem <GhostPredictionSystemGroup>();
m_interpolatedQuery = GetEntityQuery(new EntityQueryDesc
{
All = new [] {
ComponentType.ReadWrite <CharacterSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>(),
ComponentType.ReadWrite <Attack>(),
ComponentType.ReadWrite <Damage>(),
ComponentType.ReadWrite <MovableCharacterComponent>(),
ComponentType.ReadWrite <PlayerData>(),
ComponentType.ReadWrite <PrefabCreator>(),
ComponentType.ReadWrite <Translation>(),
},
None = new [] { ComponentType.ReadWrite <PredictedGhostComponent>() }
});
m_predictedQuery = GetEntityQuery(new EntityQueryDesc
{
All = new [] {
ComponentType.ReadOnly <CharacterSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>(),
ComponentType.ReadOnly <PredictedGhostComponent>(),
}
});
RequireForUpdate(GetEntityQuery(ComponentType.ReadWrite <CharacterSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>()));
}
protected override void OnCreate()
{
m_Barrier = World.GetOrCreateSystem <BeginSimulationEntityCommandBufferSystem>();
m_PredictionGroup = World.GetOrCreateSystem <GhostPredictionSystemGroup>();
RequireSingletonForUpdate <LevelComponent>();
RequireSingletonForUpdate <GhostPrefabCollectionComponent>();
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
inputDeps.Complete();
var healthStateFromEntity = GetComponentDataFromEntity <HealthStateData>(true);
var time = GetEntityQuery(ComponentType.ReadOnly <GlobalGameTime>()).GetSingleton <GlobalGameTime>().gameTime;
var predictedFromEntity = GetComponentDataFromEntity <PredictedGhostComponent>(false);
var PredictingTick = World.GetExistingSystem <GhostPredictionSystemGroup>().PredictingTick;
Entities
.ForEach((ref Ability.AbilityStateIdle stateIdle, ref Ability.EnabledAbility enabledAbility, ref PredictedState predictedState) =>
{
if (predictedFromEntity.Exists(enabledAbility.owner) && !GhostPredictionSystemGroup.ShouldPredict(PredictingTick, predictedFromEntity[enabledAbility.owner]))
{
return;
}
var shouldDash = enabledAbility.activeButtonIndex == 0 && DashAllowed(healthStateFromEntity[enabledAbility.owner]);
if (shouldDash)
{
stateIdle.requestActive = true;
predictedState.locoStartTick = time.tick;
}
}).Run();
return(default);
protected override void OnCreate()
{
_storeSystem = World.GetOrCreateSystem <GameObjectManager>();
RequireSingletonForUpdate <CommandTargetComponent>();
RequireSingletonForUpdate <EnableNetFPS>();
_clientSimulationSystemGroup = World.GetOrCreateSystem <GhostPredictionSystemGroup>();
}
protected override void OnUpdate()
{
var group = World.GetExistingSystem <GhostPredictionSystemGroup>();
var predictingTick = group.PredictingTick;
var deltaTime = Time.DeltaTime;
var speed = _appConfig.Characters[0].Speed;
var time = (int)(Time.ElapsedTime);
var colliders = _colliders;
var skillsMap = _skillsDurationMap;
Entities.WithoutBurst().WithReadOnly(colliders).ForEach((Entity e, DynamicBuffer <PlayerInput> inputBuffer,
ref Attack attack, ref Damage damage,
ref Translation trans, ref PlayerData pdata, ref PredictedGhostComponent prediction) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(predictingTick, prediction))
{
return;
}
if (!(inputBuffer.GetDataAtTick(predictingTick, out PlayerInput input) && input.Tick == predictingTick))
{
// LogServer(isServer, $"Did NOT run server-side prediction because only available input had tick {input.Tick} while the predicting tick is {predictingTick}");
return;
}
protected override void OnUpdate()
{
var tick = m_GhostPredictionSystemGroup.PredictingTick;
var deltaTime = Time.DeltaTime;
Entities.ForEach((DynamicBuffer <CubeInput> inputBuffer, ref Translation trans, in PredictedGhostComponent prediction) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
CubeInput input;
inputBuffer.GetDataAtTick(tick, out input);
if (input.horizontal > 0)
{
trans.Value.x += deltaTime;
}
if (input.horizontal < 0)
{
trans.Value.x -= deltaTime;
}
if (input.vertical > 0)
{
trans.Value.z += deltaTime;
}
if (input.vertical < 0)
{
trans.Value.z -= deltaTime;
}
}).ScheduleParallel();
}
protected override void OnCreate()
{
m_GhostUpdateSystemGroup = World.GetOrCreateSystem <GhostUpdateSystemGroup>();
m_ClientSimulationSystemGroup = World.GetOrCreateSystem <ClientSimulationSystemGroup>();
m_GhostPredictionSystemGroup = World.GetOrCreateSystem <GhostPredictionSystemGroup>();
m_interpolatedQuery = GetEntityQuery(new EntityQueryDesc
{
All = new [] {
ComponentType.ReadWrite <ExtraBlockSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>(),
ComponentType.ReadWrite <Rotation>(),
ComponentType.ReadWrite <Translation>(),
},
None = new [] { ComponentType.ReadWrite <PredictedGhostComponent>() }
});
m_predictedQuery = GetEntityQuery(new EntityQueryDesc
{
All = new [] {
ComponentType.ReadOnly <ExtraBlockSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>(),
ComponentType.ReadOnly <PredictedGhostComponent>(),
ComponentType.ReadWrite <Rotation>(),
ComponentType.ReadWrite <Translation>(),
}
});
RequireForUpdate(GetEntityQuery(ComponentType.ReadWrite <ExtraBlockSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>()));
}
protected override void OnUpdate()
{
var group = World.GetExistingSystem <GhostPredictionSystemGroup>();
var tick = group.PredictingTick;
var deltaTime = Time.DeltaTime;
Entities.ForEach((DynamicBuffer <CubeInput> inputBuffer, ref Translation trans, ref PredictedGhostComponent prediction, ref Rotation rot) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
CubeInput input;
inputBuffer.GetDataAtTick(tick, out input);
rot.Value = quaternion.AxisAngle(math.up(), input.rotation * math.PI / 180);
if (input.horizontal > 0)
{
trans.Value.x += deltaTime;
}
if (input.horizontal < 0)
{
trans.Value.x -= deltaTime;
}
if (input.vertical > 0)
{
trans.Value.z += deltaTime;
}
if (input.vertical < 0)
{
trans.Value.z -= deltaTime;
}
});
}
protected override void OnCreate()
{
m_GhostUpdateSystemGroup = World.GetOrCreateSystem <GhostUpdateSystemGroup>();
m_ghostEntityMap = m_GhostUpdateSystemGroup.GhostEntityMap;
#if UNITY_EDITOR || DEVELOPMENT_BUILD
m_ghostMinMaxSnapshotTick = m_GhostUpdateSystemGroup.GhostSnapshotTickMinMax;
#endif
m_ClientSimulationSystemGroup = World.GetOrCreateSystem <ClientSimulationSystemGroup>();
m_GhostPredictionSystemGroup = World.GetOrCreateSystem <GhostPredictionSystemGroup>();
m_interpolatedQuery = GetEntityQuery(new EntityQueryDesc
{
All = new [] {
ComponentType.ReadWrite <LagCompensationTestPlayerSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>(),
ComponentType.ReadWrite <LagCompensationTestPlayer>(),
ComponentType.ReadWrite <Rotation>(),
ComponentType.ReadWrite <Translation>(),
},
None = new [] { ComponentType.ReadWrite <PredictedGhostComponent>() }
});
m_predictedQuery = GetEntityQuery(new EntityQueryDesc
{
All = new [] {
ComponentType.ReadOnly <LagCompensationTestPlayerSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>(),
ComponentType.ReadOnly <PredictedGhostComponent>(),
ComponentType.ReadWrite <LagCompensationTestPlayer>(),
ComponentType.ReadWrite <Rotation>(),
ComponentType.ReadWrite <Translation>(),
}
});
RequireForUpdate(GetEntityQuery(ComponentType.ReadWrite <LagCompensationTestPlayerSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>()));
}
public void Execute([ReadOnly] ref Velocity velocity, ref Translation position, [ReadOnly] ref PredictedGhostComponent prediction)
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
position.Value.xy += velocity.Value * deltaTime;
}
protected override void OnCreate()
{
simulationDeltaTime = 1f / GetSingleton <ClientServerTickRate>().SimulationTickRate;
ghostPredictionSystemGroup = World.GetOrCreateSystem <GhostPredictionSystemGroup>();
startCountdownServerSystem = World.GetOrCreateSystem <StartCountdownServerSystem>();
checkpointInitializationSystem = World.GetOrCreateSystem <CheckpointInitializationSystem>();
}
protected override void OnUpdate()
{
var tick = m_GhostPredictionSystemGroup.PredictingTick;
var deltaTime = Time.DeltaTime;
Entities.ForEach((DynamicBuffer <PlayerInput> inputBuffer, ref Translation trans, ref PhysicsVelocity pv, in PredictedGhostComponent prediction, in PlayerMovementSpeed pms) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
PlayerInput input;
inputBuffer.GetDataAtTick(tick, out input);
var speed = pms.speed;
/*if (input.horizontal > 0)
* trans.Value.x += speed * deltaTime;
* if (input.horizontal < 0)
* trans.Value.x -= speed * deltaTime;
* if (input.vertical > 0)
* trans.Value.z += speed * deltaTime;
* if (input.vertical < 0)
* trans.Value.z -= speed * deltaTime;*/
// cosi' non rimbalza ma lagga e ci mette un po' ad accelerare
if (input.horizontal > 0)
{
pv.Linear.x += speed * deltaTime;
}
if (input.horizontal < 0)
{
pv.Linear.x -= speed * deltaTime;
}
if (input.vertical > 0)
{
pv.Linear.z += speed * deltaTime;
}
if (input.vertical < 0)
{
pv.Linear.z -= speed * deltaTime;
}
if (input.firstJump)
{
pv.Linear.y = 8f;
input.firstJump = false;
}
/*
* un altro modo per far muovere l'oggetto è generando un impulso lineare (using Unity.Physics.Extensions):
* Itero su tutte le entities che hanno i componenti PhysicsVelocity e PhysicsMass (+ PlayerMovementSpeed
* e l'input del Player, nel nostro caso DynamicBuffer<PlayerInput>), quindi imposto la direzione
* dell'impulso con:
* float3 direction = new float3(horizontalInput, 0.0f, verticalInput);
* e applico l'impulso lineare utilizzando il metodo seguente:
* PhysicsComponentExtensions.ApplyLinearImpulse(ref velocity, physicsMass, direction * movement.Force
*/
}).ScheduleParallel();
protected override void OnUpdate()
{
Dependency.Complete();
var time = GetEntityQuery(ComponentType.ReadOnly <GlobalGameTime>()).GetSingleton <GlobalGameTime>().gameTime;
var playerControlledStateFromEntity = GetComponentDataFromEntity <PlayerControlled.State>(true);
var characterPredictedDataFromEntity = GetComponentDataFromEntity <Character.PredictedData>(false);
var characterStartPositionFromEntity = GetComponentDataFromEntity <CharacterControllerMoveQuery>(false);
var characterVelocityFromEntity = GetComponentDataFromEntity <CharacterControllerVelocity>(false);
var predictedFromEntity = GetComponentDataFromEntity <PredictedGhostComponent>(false);
var PredictingTick = World.GetExistingSystem <GhostPredictionSystemGroup>().PredictingTick;
Entities
.ForEach((ref Ability.EnabledAbility activeAbility, ref Ability.AbilityStateActive stateActive, ref Settings settings, ref PredictedState predictedState) =>
{
if (!characterVelocityFromEntity.HasComponent(activeAbility.owner) &&
predictedFromEntity.Exists(activeAbility.owner) &&
!GhostPredictionSystemGroup.ShouldPredict(PredictingTick, predictedFromEntity[activeAbility.owner]))
{
return;
}
var command = playerControlledStateFromEntity[activeAbility.owner].command;
var charPredictedState = characterPredictedDataFromEntity[activeAbility.owner];
var startPosition = characterStartPositionFromEntity[activeAbility.owner];
startPosition.StartPosition = charPredictedState.position;
characterStartPositionFromEntity[activeAbility.owner] = startPosition;
var phaseDuration = time.DurationSinceTick(predictedState.locoStartTick);
if (phaseDuration >= settings.dashDuration)
{
stateActive.requestCooldown = true;
return;
}
//GameDebug.Log($"{predictedState.locoStartTick} :: {time.tick}");
var velocity = predictedState.startVelocity;
if (predictedState.locoStartTick + 1 == time.tick)
{
var dashVel = settings.dashDistance / settings.dashDuration;
var moveYawRotation = Quaternion.Euler(0, command.lookYaw + command.moveYaw, 0);
var moveVec = moveYawRotation * Vector3.forward;
velocity = moveVec * dashVel;
velocity.y = 0f;
predictedState.startVelocity = velocity;
//GameDebug.Log($"predictedState.startVelocity {predictedState.startVelocity}");
}
var oldVel = characterVelocityFromEntity[activeAbility.owner];
oldVel.Velocity = velocity;
characterVelocityFromEntity[activeAbility.owner] = oldVel;
}).Run();
}
protected override void OnUpdate()
{
var barrier = m_Barrier.CreateCommandBuffer().ToConcurrent();
var group = World.GetExistingSystem <GhostPredictionSystemGroup>();
var tick = group.PredictingTick;
var deltaTime = Time.DeltaTime;
Entities
.WithBurst()
.ForEach((Entity entity, int entityInQueryIndex, DynamicBuffer <PlayerInput> inputBuffer, ref PhysicsVelocity v, ref PredictedGhostComponent prediction, in Translation t, in PlayerTag player) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
Player.PlayerInput input;
inputBuffer.GetDataAtTick(tick, out input);
if (input.Left)
{
v.Linear.x = player.speed;
}
if (input.Right)
{
v.Linear.x = -player.speed;
}
if (input.Up)
{
v.Linear.y = player.jumpForce;
}
//if (input.Down)
// t.Value.y -= speed;
if (input.Shoot)
{
/*Debug.DrawLine(t.Value, (Vector3)t.Value + new Vector3(0, 1, 0), Color.red);
* Debug.DrawLine(t.Value, (Vector3)t.Value + new Vector3(0, -1, 0), Color.red);
* Debug.DrawLine(t.Value, (Vector3)t.Value + new Vector3(1, 0, 0), Color.red);
* Debug.DrawLine(t.Value, (Vector3)t.Value + new Vector3(-1, 0, 0), Color.red);*/
var stencilEntity = barrier.CreateEntity(entityInQueryIndex);
barrier.AddComponent(entityInQueryIndex, stencilEntity, new VoxelStencilInput
{
centerX = t.Value.x,
centerY = t.Value.y,
fillType = false,
radius = 1f,
shape = VoxelShape.Circle
});
}
}).ScheduleParallel();
protected override void OnCreate()
{
//This will grab the BeginSimulationEntityCommandBuffer system to be used in OnUpdate
m_BeginSimEcb = World.GetOrCreateSystem <BeginSimulationEntityCommandBufferSystem>();
//This will grab the BeginSimulationEntityCommandBuffer system to be used in OnUpdate
m_PredictionGroup = World.GetOrCreateSystem <GhostPredictionSystemGroup>();
//We check to ensure GameSettingsComponent exists to know if the SubScene has been streamed in
//We need the SubScene for actions in our OnUpdate()
RequireSingletonForUpdate <GameSettingsComponent>();
}
protected override void OnUpdate()
{
var predictionGroup = World.GetExistingSystem <GhostPredictionSystemGroup>();
var tick = predictionGroup.PredictingTick;
var deltaTime = Time.DeltaTime;
Entities.WithAll <BulletTagComponent>().ForEach((ref Translation position, in PredictedGhostComponent prediction, in Velocity velocity) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
position.Value.xy += velocity.Value * deltaTime;
}).ScheduleParallel();
protected override void OnUpdate()
{
var deltaTime = m_PredictionGroup.Time.DeltaTime;
var currentTick = m_PredictionGroup.PredictingTick;
Entities
.ForEach((ref Translation position, in VelocityComponent velocity, in PredictedGhostComponent prediction) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(currentTick, prediction))
{
return;
}
position.Value.xyz += velocity.Linear * deltaTime;
}).ScheduleParallel();
protected override void OnUpdate()
{
var group = World.GetExistingSystem <GhostPredictionSystemGroup>();
var tick = group.PredictingTick;
Entities.ForEach((ref ServerPuckData puck, ref PhysicsVelocity vel, ref PredictedGhostComponent prediction) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
LimitPuckVelocitySystem.SetVel(ref vel);
});
}
protected override void OnCreate()
{
m_GhostUpdateSystemGroup = World.GetOrCreateSystem <GhostUpdateSystemGroup>();
m_ghostEntityMap = m_GhostUpdateSystemGroup.GhostEntityMap;
#if UNITY_EDITOR || DEVELOPMENT_BUILD
m_ghostMinMaxSnapshotTick = m_GhostUpdateSystemGroup.GhostSnapshotTickMinMax;
#endif
m_ClientSimulationSystemGroup = World.GetOrCreateSystem <ClientSimulationSystemGroup>();
m_GhostPredictionSystemGroup = World.GetOrCreateSystem <GhostPredictionSystemGroup>();
m_interpolatedQuery = GetEntityQuery(new EntityQueryDesc
{
All = new [] {
ComponentType.ReadWrite <Char_TerraformerSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>(),
ComponentType.ReadWrite <Character.InterpolatedData>(),
ComponentType.ReadWrite <Character.ReplicatedData>(),
ComponentType.ReadWrite <CharacterControllerGroundSupportData>(),
ComponentType.ReadWrite <CharacterControllerMoveResult>(),
ComponentType.ReadWrite <CharacterControllerVelocity>(),
ComponentType.ReadWrite <HealthStateData>(),
ComponentType.ReadWrite <Inventory.State>(),
ComponentType.ReadWrite <Player.OwnerPlayerId>(),
ComponentType.ReadWrite <PlayerControlled.State>(),
ComponentType.ReadOnly <LinkedEntityGroup>(),
},
None = new [] { ComponentType.ReadWrite <PredictedGhostComponent>() }
});
m_predictedQuery = GetEntityQuery(new EntityQueryDesc
{
All = new [] {
ComponentType.ReadOnly <Char_TerraformerSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>(),
ComponentType.ReadOnly <PredictedGhostComponent>(),
ComponentType.ReadWrite <Character.PredictedData>(),
ComponentType.ReadWrite <Character.ReplicatedData>(),
ComponentType.ReadWrite <CharacterControllerGroundSupportData>(),
ComponentType.ReadWrite <CharacterControllerMoveResult>(),
ComponentType.ReadWrite <CharacterControllerVelocity>(),
ComponentType.ReadWrite <HealthStateData>(),
ComponentType.ReadWrite <Inventory.State>(),
ComponentType.ReadWrite <Player.OwnerPlayerId>(),
ComponentType.ReadWrite <PlayerControlled.State>(),
ComponentType.ReadOnly <LinkedEntityGroup>(),
}
});
RequireForUpdate(GetEntityQuery(ComponentType.ReadWrite <Char_TerraformerSnapshotData>(),
ComponentType.ReadOnly <GhostComponent>()));
}
protected override void OnUpdate()
{
var group = World.GetExistingSystem <GhostPredictionSystemGroup>();
var tick = group.PredictingTick;
Entities.ForEach((DynamicBuffer <CharacterSyncData> inputBuffer, ref MovableComponent movable, ref LookRotationComponent rotatable, ref PredictedGhostComponent prediction) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
inputBuffer.GetDataAtTick(tick, out CharacterSyncData input);
//这里只需要将数据进行更改
movable.Direction = rotatable.Direction = new float3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
});
}
protected override void OnUpdate()
{
var group = World.GetExistingSystem <GhostPredictionSystemGroup>();
var tick = group.PredictingTick;
var deltaTime = Time.DeltaTime;
var entityManager = EntityManager;
Entities.ForEach((Entity ent, DynamicBuffer <PilotInput> inputBuffer, ref PredictedGhostComponent prediction, in CameraRigChild cameraRigChild) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
inputBuffer.GetDataAtTick(tick, out PilotInput input);
entityManager.SetComponentData(ent, new CameraRigChild {
Value = cameraRigChild.Value,
headPose = input.head.positon,
headRot = input.head.rotation,
leftHandPose = input.leftHand.positon,
leftHandRot = input.leftHand.rotation,
rightHandPose = input.rightHand.positon,
rightHandRot = input.rightHand.rotation
});
var cameraRig = entityManager.GetComponentData <CameraRigData>(cameraRigChild.Value);
entityManager.SetComponentData(cameraRig.head, new Translation {
Value = cameraRigChild.headPose
});
entityManager.SetComponentData(cameraRig.head, new Rotation {
Value = cameraRigChild.headRot
});
entityManager.SetComponentData(cameraRig.leftHand, new Translation {
Value = cameraRigChild.leftHandPose
});
entityManager.SetComponentData(cameraRig.leftHand, new Rotation {
Value = cameraRigChild.leftHandRot
});
entityManager.SetComponentData(cameraRig.rightHand, new Translation {
Value = cameraRigChild.rightHandPose
});
entityManager.SetComponentData(cameraRig.rightHand, new Rotation {
Value = cameraRigChild.rightHandRot
});
}).Run();
}
protected override void OnUpdate()
{
var group = World.GetExistingSystem <GhostPredictionSystemGroup>();
var tick = group.PredictingTick;
Entities
.WithBurst()
.ForEach((DynamicBuffer <Player.PlayerInput> inputBuffer, ref SpriteInformation sd, ref PredictedGhostComponent prediction) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
Player.PlayerInput input;
inputBuffer.GetDataAtTick(tick, out input);
if (input.Left && input.Right)
{
sd.animation = 0;
}
else if (input.Left)
{
sd.direction = SpriteInformation.Direction.LEFT;
sd.animation = 1;
}
else if (input.Right)
{
sd.direction = SpriteInformation.Direction.RIGHT;
sd.animation = 1;
}
else
{
sd.animation = 0;
}
if (input.Down && input.Up)
{
sd.animation = 0;
}
else if (input.Down || input.Up)
{
sd.animation = 1;
}
}).ScheduleParallel();
}
protected override void OnUpdate()
{
if (!s_IsEnabled)
{
return;
}
var tick = m_GhostPredictionSystemGroup.PredictingTick;
var deltaTime = Time.DeltaTime;
Entities.ForEach((ref Translation trans, in PredictedGhostComponent predictedGhost) => {
if (!GhostPredictionSystemGroup.ShouldPredict(tick, predictedGhost))
{
return;
}
// Make sure we advance by one unit per tick, makes it easier to debug the values
trans.Value.x += deltaTime * 60.0f;
}).ScheduleParallel();
}
protected override void OnUpdate()
{
var group = World.GetExistingSystem <GhostPredictionSystemGroup> ();
var tick = group.PredictingTick;
var projectiles = projectileQuery.ToEntityArray(Allocator.TempJob);
var projectilePositions = projectileQuery.ToComponentDataArray <Translation> (Allocator.TempJob);
var projectileId = projectileQuery.ToComponentDataArray <ProjectileComponent> (Allocator.TempJob);
Entities.ForEach((ref Translation trans, ref MovableCubeComponent cube, ref PredictedGhostComponent prediction) => {
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediction))
{
return;
}
Rectangle rect = new Rectangle {
x = trans.Value.x - 0.5f, y = trans.Value.z - 0.5f, width = 1, height = 1
};
for (var j = 0; j < projectiles.Length; j++)
{
if (projectileId[j].playerId != cube.PlayerId)
{
Circle circle = new Circle {
x = projectilePositions[j].Value.x, y = projectilePositions[j].Value.z, radius = 0.5f
};
if (CircleToRectangle(circle, rect))
{
// UI.Instance.updatePlayerScore (cube.PlayerId);
// Death
trans.Value = new float3(0, 0.5f, 0);
PostUpdateCommands.SetComponent(projectiles[j], new Translation {
Value = new float3(100, 0, 100)
});
}
}
}
});
projectiles.Dispose();
projectilePositions.Dispose();
projectileId.Dispose();
}
protected override void OnUpdate()
{
var tick = predictionGroup.PredictingTick;
Entities
.ForEach((Entity entity, ref Translation translation, in DynamicBuffer <TestInput> inputBuffer, in PredictedGhostComponent
prediciton) =>
{
if (!GhostPredictionSystemGroup.ShouldPredict(tick, prediciton))
{
return;
}
if (!inputBuffer.GetDataAtTick(tick, out var input))
{
return;
}
translation.Value.y += 1.0f * input.Value;
}).Run();
protected override void OnCreate()
{
m_GhostUpdateSystemGroup = World.GetOrCreateSystem <GhostUpdateSystemGroup>();
m_ghostEntityMap = m_GhostUpdateSystemGroup.GhostEntityMap;
#if UNITY_EDITOR || DEVELOPMENT_BUILD
m_ghostMinMaxSnapshotTick = m_GhostUpdateSystemGroup.GhostSnapshotTickMinMax;
#endif
m_ClientSimulationSystemGroup = World.GetOrCreateSystem <ClientSimulationSystemGroup>();
m_GhostPredictionSystemGroup = World.GetOrCreateSystem <GhostPredictionSystemGroup>();
m_interpolatedQuery = GetEntityQuery(new EntityQueryDesc
{
All = new [] {
ComponentType.ReadWrite <__GHOST_NAME__SnapshotData>(),
ComponentType.ReadOnly <GhostComponent>(),
#region __GHOST_INTERPOLATED_COMPONENT_TYPE__
ComponentType.ReadWrite <__GHOST_COMPONENT_TYPE__>(),
#endregion
#region __GHOST_INTERPOLATED_READ_ONLY_COMPONENT_TYPE__
ComponentType.ReadOnly <__GHOST_COMPONENT_TYPE__>(),
#endregion
},
None = new [] { ComponentType.ReadWrite <PredictedGhostComponent>() }
});
m_predictedQuery = GetEntityQuery(new EntityQueryDesc
{
All = new [] {
ComponentType.ReadOnly <__GHOST_NAME__SnapshotData>(),
ComponentType.ReadOnly <GhostComponent>(),
ComponentType.ReadOnly <PredictedGhostComponent>(),
#region __GHOST_PREDICTED_COMPONENT_TYPE__
ComponentType.ReadWrite <__GHOST_COMPONENT_TYPE__>(),
#endregion
#region __GHOST_PREDICTED_READ_ONLY_COMPONENT_TYPE__
ComponentType.ReadOnly <__GHOST_COMPONENT_TYPE__>(),
#endregion
}
});
RequireForUpdate(GetEntityQuery(ComponentType.ReadWrite <__GHOST_NAME__SnapshotData>(),
ComponentType.ReadOnly <GhostComponent>()));
}