protected override JobHandle OnUpdate(JobHandle inputDeps)
{
m_FrameCounter++;
var sharedDataManager = GameEntry.Instance.SharedData;
var jobHandle = new TriggerEventsJob
{
PlayerWithGroundCollisionDatas = GetCollisionDataListForSystem <PlayerWithGroundCollisionSolvingSystem>(sharedDataManager),
PlayerWithEnemyCollisionDatas = GetCollisionDataListForSystem <PlayerWithEnemyCollisionSolvingSystem>(sharedDataManager),
PlayerWithItemCollisionDatas = GetCollisionDataListForSystem <PlayerWithItemCollisionSolvingSystem>(sharedDataManager),
SimpleMovingObjectWithGroundCollisionDatas = GetCollisionDataListForSystem <SimpleMovingObjectWithGroundCollisionSolvingSystem>(sharedDataManager),
EnemyAndDeadEnemyCollisionDatas = GetCollisionDataListForSystem <EnemyAndDeadEnemyCollisionSolvingSystem>(sharedDataManager),
PlayerBulletWithGroundCollisionDatas = GetCollisionDataListForSystem <PlayerBulletWithGroundCollisionSolvingSystem>(sharedDataManager),
PlayerBulletWithEnemyCollisionDatas = GetCollisionDataListForSystem <PlayerBulletWithEnemyCollisionSolvingSystem>(sharedDataManager),
PlayerTagEntities = GetComponentDataFromEntity <PlayerTag>(),
GroundTagEntities = GetComponentDataFromEntity <GroundTag>(),
CompositeScaleEntities = GetComponentDataFromEntity <CompositeScale>(),
ScaleEntities = GetComponentDataFromEntity <Scale>(),
TranslationEntities = GetComponentDataFromEntity <Translation>(),
ColliderEntities = GetComponentDataFromEntity <PhysicsCollider>(),
SimpleMovementAbilityEntities = GetComponentDataFromEntity <SimpleMovementAbilityData>(),
EnemyTagEntities = GetComponentDataFromEntity <EnemyTag>(),
DeadEnemyTagEntities = GetComponentDataFromEntity <DeadEnemyTag>(),
ItemTagEntities = GetComponentDataFromEntity <ItemTag>(),
PlayerBulletTagEntities = GetComponentDataFromEntity <PlayerBulletTag>(),
FrameCounter = m_FrameCounter,
}.Schedule(m_StepPhysicsWorld.Simulation, ref m_BuildPhysicsWorld.PhysicsWorld, inputDeps);
jobHandle.Complete();
GetCollisionDataListForSystem <SimpleMovingObjectWithGroundCollisionSolvingSystem>(sharedDataManager).Sort(m_CollisionDataComparer);
GetCollisionDataListForSystem <PlayerBulletWithGroundCollisionSolvingSystem>(sharedDataManager).Sort(m_CollisionDataComparer);
GetCollisionDataListForSystem <PlayerBulletWithEnemyCollisionSolvingSystem>(sharedDataManager).Sort(m_CollisionDataComparer);
return(jobHandle);
}
protected override void OnUpdate()
{
Dependency = new TriggerEventsPreProcessJob {
TriggerEventBufferType = GetArchetypeChunkBufferType <TriggerEventBufferElement>(),
}.ScheduleParallel(_triggerEventsBufferEntityQuery, Dependency);
Dependency = new TriggerEventsJob {
TriggerEventBufferFromEntity = GetBufferFromEntity <TriggerEventBufferElement>(),
}.Schedule(_stepPhysicsWorldSystem.Simulation, ref _buildPhysicsWorldSystem.PhysicsWorld, Dependency);
Dependency = new TriggerEventsPostProcessJob {
TriggerEventBufferType = GetArchetypeChunkBufferType <TriggerEventBufferElement>(),
}.ScheduleParallel(_triggerEventsBufferEntityQuery, Dependency);
}
protected override void OnUpdate()
{
var physicsWorld = World.GetOrCreateSystem <BuildPhysicsWorld>().PhysicsWorld;
var simulation = World.GetOrCreateSystem <StepPhysicsWorld>().Simulation;
Entities.ForEach((DynamicBuffer <CollisionBuffer> collisionBuffer) => { collisionBuffer.Clear(); }).Run();
Entities.ForEach((DynamicBuffer <TriggerBuffer> triggerBuffer) => { triggerBuffer.Clear(); }).Run();
var collisionSystemJob = new CollisionSystemJob
{
Collisions = GetBufferFromEntity <CollisionBuffer>()
}.Schedule(simulation, ref physicsWorld, Dependency);
collisionSystemJob.Complete();
var triggerEventsJob = new TriggerEventsJob()
{
Collisions = GetBufferFromEntity <TriggerBuffer>()
}.Schedule(simulation, ref physicsWorld, Dependency);
triggerEventsJob.Complete();
}
protected override void OnUpdate()
{
Dependency = new TriggerEventsPreProcessJob
{
triggerEventBufferType =
GetBufferTypeHandle <StatefulTriggerEvent>()
}.ScheduleParallel(_triggerEventsBufferEntityQuery, Dependency);
Dependency = new TriggerEventsJob
{
triggerEventBufferFromEntity =
GetBufferFromEntity <StatefulTriggerEvent>()
}.Schedule(
_stepPhysicsWorldSystem.Simulation,
ref _buildPhysicsWorldSystem.PhysicsWorld,
Dependency
);
Dependency = new TriggerEventsPostProcessJob
{
triggerEventBufferType =
GetBufferTypeHandle <StatefulTriggerEvent>()
}.ScheduleParallel(_triggerEventsBufferEntityQuery, Dependency);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
if (stepPhysicsWorld.Simulation.Type == SimulationType.NoPhysics)
{
return(inputDeps);
}
NativeArray <ATriggerEvent> localAtes = new NativeArray <ATriggerEvent>(oldAtes.Length, Allocator.TempJob);
JobHandle jobHandle = new TriggerEventsJob
{
ecb = endSimulationEntityCommandBufferSystem.CreateCommandBuffer(),
hasATriggerEvent = GetComponentDataFromEntity <ATriggerEvent>(),
counter = 0,
currentLength = localAtesRealLength,
localAtes = localAtes
}.Schedule(stepPhysicsWorld.Simulation, ref buildPhysicsWorld.PhysicsWorld, inputDeps);
//must wait for this to finish to continue
jobHandle.Complete();
//verify that ATriggerEntities still exist (thanks a lot particle system)
for (i = 0; i < localAtes.Length; i++)
{
if (localAtes[i].valid)
{
if (!EntityManager.Exists(localAtes[i].entityA) || !EntityManager.Exists(localAtes[i].entityB))
{
for (int j = i; j < localAtes.Length; j++)
{
localAtes[j] = j == localAtes.Length ? localAtes[j + 1] : new ATriggerEvent {
valid = false
}
}
;
i--;
}
}
else
{
break;
}
}
//create/add new trigger events
for (i = 0; i < localAtes.Length; i++)
{
if (localAtes[i].valid)
{
match = false;
localAtes[i] = processTriggers(localAtes[i]);
//flip the entities
if (localAtes[i].triggerType == 0)
{
localAtes[i] = processTriggers(new ATriggerEvent
{
entityA = localAtes[i].entityB,
entityB = localAtes[i].entityA,
triggerType = localAtes[i].triggerType,
valid = localAtes[i].valid
});
}
// if (localAtes[i].triggerType == 0) Debug.Log("Unable to update determine triggerType for entity "+EntityManager.GetName(localAtes[i].entityA)+"::::"+localAtes[i].ToString());
}
else
{
break;
}
}
//if there are no new trigger events
if (i == 0)
{
if (!alreadyCleared)
{
// Debug.Log("Clearing STUFF");
//clear oldAtes
for (i = 0; i < oldAtes.Length; i++)
{
// Debug.Log("checking "+i+" of "+oldAtes.Length);
if (oldAtes[i].valid)
{
Debug.Log("Attempting to remove..." + oldAtes[i].ToString());
switch (oldAtes[i].triggerType)
{
case TriggerEventClass.Damage | TriggerEventClass.PokemonAttacking:
Debug.Log("Removing damage trigger on B");
EntityManager.RemoveComponent <DamageTrigger>(oldAtes[i].entityB);
break;
case TriggerEventClass.Interaction:
//since interaction trigger is set the entityB of the trigger
Debug.Log("Removing Interaction trigger on B");
EntityManager.RemoveComponent <InteractionTrigger>(oldAtes[i].entityB);
break;
default: break;
}
EntityManager.RemoveComponent <ATriggerEvent>(oldAtes[i].entityA);
oldAtes[i] = new ATriggerEvent {
};
}
else
{
// Debug.Log("Failed to get valid");
break;
}
}
Debug.Log("Cleared the persistant NativeArray");
alreadyCleared = true;
}
localAtes.Dispose();
return(inputDeps);
}
//else
if (localAtes.Length > oldAtes.Length)
{
Debug.Log("Adding new persistance values");
oldAtes = new NativeArray <ATriggerEvent>(localAtes.Length + oldAtesBase, Allocator.Persistent);
}
if (alreadyCleared)
{
alreadyCleared = false;
}
/////////////////////////////////////////////////////////////////////////
//clear non-active trigger events
JobHandle cleanJobHandle = new UpdateOldAtesJob
{
ecb = endSimulationEntityCommandBufferSystem.CreateCommandBuffer(),
oldAtes = oldAtes,
localAtes = localAtes
}.Schedule(inputDeps);
cleanJobHandle.Complete();
//update oldAtes content
for (i = 0; i < localAtes.Length; i++)
{
oldAtes[i] = localAtes[i];
}
localAtes.Dispose();
return(cleanJobHandle);
}
}
