public override void ExecuteReplication(ComponentGroup replicationGroup, ComponentSystemBase system, global::Improbable.Worker.Core.Connection connection) { Profiler.BeginSample("NestedComponent"); var chunkArray = replicationGroup.CreateArchetypeChunkArray(Allocator.TempJob); var spatialOSEntityType = system.GetArchetypeChunkComponentType <SpatialEntityId>(true); var componentType = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.NestedComponent.Component>(); foreach (var chunk in chunkArray) { var entityIdArray = chunk.GetNativeArray(spatialOSEntityType); var componentArray = chunk.GetNativeArray(componentType); for (var i = 0; i < componentArray.Length; i++) { var data = componentArray[i]; var dirtyEvents = 0; if (data.DirtyBit || dirtyEvents > 0) { var update = new global::Improbable.Worker.Core.SchemaComponentUpdate(20152); Improbable.Gdk.Tests.NestedComponent.Serialization.SerializeUpdate(data, update); // Send serialized update over the wire connection.SendComponentUpdate(entityIdArray[i].EntityId, new global::Improbable.Worker.Core.ComponentUpdate(update)); data.DirtyBit = false; componentArray[i] = data; } } } chunkArray.Dispose(); Profiler.EndSample(); }
protected override void OnUpdate() { var chunkArray = m_Group.CreateArchetypeChunkArray(Allocator.TempJob); var entityType = GetArchetypeChunkEntityType(); var knightType = GetArchetypeChunkComponentType <Knight>(true); var orcWolfRiderType = GetArchetypeChunkComponentType <OrcWolfRider>(true); var skeletonType = GetArchetypeChunkComponentType <Skeleton>(true); for (var chunkIndex = 0; chunkIndex < chunkArray.Length; chunkIndex++) { var chunk = chunkArray[chunkIndex]; var entityArray = chunk.GetNativeArray(entityType); if (chunk.Has(knightType)) { m_KnightList.AddRange(entityArray); } else if (chunk.Has(orcWolfRiderType)) { m_OrcWolfRiderList.AddRange(entityArray); } else if (chunk.Has(skeletonType)) { m_SkeletonList.AddRange(entityArray); } } chunkArray.Dispose(); AddToPool(m_KnightPool, m_KnightList); AddToPool(m_OrcWolfRiderPool, m_OrcWolfRiderList); AddToPool(m_SkeletonPool, m_SkeletonList); m_KnightList.Clear(); m_OrcWolfRiderList.Clear(); m_SkeletonList.Clear(); }
protected override void OnUpdate() { var heartbeatType = GetArchetypeChunkComponentType <HeartbeatData>(); var entityDeleterType = GetArchetypeChunkComponentType <WorldCommands.DeleteEntity.CommandSender>(); var responsesType = GetArchetypeChunkComponentType <PlayerHeartbeatClient.CommandResponses.PlayerHeartbeat>(true); var spatialIdType = GetArchetypeChunkComponentType <SpatialEntityId>(true); var chunkArray = group.CreateArchetypeChunkArray(Allocator.TempJob); foreach (var chunk in chunkArray) { var heartbeats = chunk.GetNativeArray(heartbeatType); var responses = chunk.GetNativeArray(responsesType); var deleteRequesters = chunk.GetNativeArray(entityDeleterType); var spatialIds = chunk.GetNativeArray(spatialIdType); for (var i = 0; i < responses.Length; i++) { var heartbeatData = heartbeats[i]; var responded = false; foreach (var response in responses[i].Responses) { if (response.StatusCode == StatusCode.Success) { responded = true; break; } } if (responded) { heartbeatData.NumFailedHeartbeats = 0; } else { heartbeatData.NumFailedHeartbeats += 1; if (heartbeatData.NumFailedHeartbeats >= PlayerLifecycleConfig.MaxNumFailedPlayerHeartbeats) { var entityId = spatialIds[i].EntityId; deleteRequesters[i].RequestsToSend.Add(WorldCommands.DeleteEntity.CreateRequest ( entityId )); worker.LogDispatcher.HandleLog(LogType.Log, new LogEvent( $"A client failed to respond to too many heartbeats. Deleting their player.") .WithField("EntityID", entityId)); } } heartbeats[i] = heartbeatData; } } chunkArray.Dispose(); }
void UpdateMissingVisibleLocalToWorld() { var localToWorldOrderVersion = EntityManager.GetComponentOrderVersion <LocalToWorld>(); if (localToWorldOrderVersion == m_LastLocalToWorldOrderVersion) { return; } EntityCommandBuffer entityCommandBuffer = new EntityCommandBuffer(Allocator.Temp); var entityType = GetArchetypeChunkEntityType(); var chunks = m_MissingVisibleLocalToWorldQuery.CreateArchetypeChunkArray(Allocator.TempJob); for (int i = 0; i < chunks.Length; i++) { var chunk = chunks[i]; var entities = chunk.GetNativeArray(entityType); for (int j = 0; j < chunk.Count; j++) { var entity = entities[j]; entityCommandBuffer.AddComponent(entity, default(VisibleLocalToWorld)); } } entityCommandBuffer.Playback(EntityManager); entityCommandBuffer.Dispose(); chunks.Dispose(); m_LastLocalToWorldOrderVersion = localToWorldOrderVersion; }
public override void AcknowledgeAuthorityLoss(ComponentGroup group, ComponentSystemBase system, Improbable.Worker.Core.Connection connection) { var authorityLossType = system.GetArchetypeChunkComponentType <AuthorityLossImminent <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFields.Component> >(); var spatialEntityType = system.GetArchetypeChunkComponentType <SpatialEntityId>(); var chunkArray = group.CreateArchetypeChunkArray(Allocator.TempJob); foreach (var chunk in chunkArray) { var authorityArray = chunk.GetNativeArray(authorityLossType); var spatialEntityIdArray = chunk.GetNativeArray(spatialEntityType); for (int i = 0; i < authorityArray.Length; ++i) { if (authorityArray[i].AcknowledgeAuthorityLoss) { connection.SendAuthorityLossImminentAcknowledgement(spatialEntityIdArray[i].EntityId, 1003); } } } chunkArray.Dispose(); }
protected override void OnUpdate() { var chunkArray = m_Group.CreateArchetypeChunkArray(Allocator.TempJob); var targetType = GetArchetypeChunkComponentType <Target>(); var translationType = GetArchetypeChunkComponentType <Translation>(); var destinationType = GetArchetypeChunkComponentType <Destination>(); for (var chunkIndex = 0; chunkIndex < chunkArray.Length; chunkIndex++) { var chunk = chunkArray[chunkIndex]; var translationArray = chunk.GetNativeArray(translationType); var destinationArray = chunk.GetNativeArray(destinationType); if (chunk.Has(targetType)) { for (int entityIndex = 0; entityIndex < chunk.Count; entityIndex++) { Debug.DrawLine(translationArray[entityIndex].Value, destinationArray[entityIndex].Value, Color.red); } } else { for (int entityIndex = 0; entityIndex < chunk.Count; entityIndex++) { Debug.DrawLine(translationArray[entityIndex].Value, destinationArray[entityIndex].Value, Color.green); } } } chunkArray.Dispose(); }
// this takes in the compGroup and entityType, and gives us out all entities from all chunks within the group. public NativeArray <Entity> GetEntities(ComponentGroup compGroup, ArchetypeChunkEntityType entityType) { NativeArray <ArchetypeChunk> dataChunks = compGroup.CreateArchetypeChunkArray(Allocator.TempJob); NativeList <ArchetypeChunk> chunkList = new NativeList <ArchetypeChunk> (Allocator.Temp); NativeList <Entity> entityList = new NativeList <Entity> (Allocator.Temp); for (int d = 0; d < dataChunks.Length; d++) { chunkList.Add(dataChunks [d]); } dataChunks.Dispose(); for (int c = 0; c < chunkList.Length; c++) { ArchetypeChunk dataChunk = chunkList [c]; NativeArray <Entity> entityHolder = dataChunk.GetNativeArray(entityType); for (int i = 0; i < entityHolder.Length; i++) { entityList.Add(entityHolder [i]); } } chunkList.Dispose(); NativeArray <Entity> chunkEntities = new NativeArray <Entity> (entityList.Length, Allocator.Persistent); chunkEntities.CopyFrom(entityList); entityList.Dispose(); return(chunkEntities); }
private void UpdateFollowTargetEntity() { var followTargetOrderVersion = _entityManager.GetComponentOrderVersion <FollowTarget>(); if (followTargetOrderVersion == _followTargetOrderVersion) { return; } var followTargetChunks = _componentGroup.CreateArchetypeChunkArray(Allocator.TempJob); if (followTargetChunks.Length > 0) { Assert.IsTrue( followTargetChunks.Length == 1 && followTargetChunks[0].Count == 1, $"Only one followed target is supported. Make sure component {typeof(FollowTarget)} is only in one Entity." ); _followTargetEntity = followTargetChunks[0].GetNativeArray(_entityManager.GetArchetypeChunkEntityType())[0]; } else { _followTargetEntity = Entity.Null; } followTargetChunks.Dispose(); _followTargetOrderVersion = followTargetOrderVersion; }
void VerifyQueryCount(ComponentGroup group, int expectedCount) { var chunks = group.CreateArchetypeChunkArray(Allocator.TempJob); Assert.AreEqual(expectedCount, ArchetypeChunkArray.CalculateEntityCount(chunks)); chunks.Dispose(); }
protected override void OnUpdate() { var chunkArray = m_Group.CreateArchetypeChunkArray(Allocator.TempJob); var translationType = GetArchetypeChunkComponentType <Translation>(true); var knightType = GetArchetypeChunkComponentType <Knight>(true); var orcWolfRiderType = GetArchetypeChunkComponentType <OrcWolfRider>(true); var skeletonType = GetArchetypeChunkComponentType <Skeleton>(true); for (var chunkIndex = 0; chunkIndex < chunkArray.Length; chunkIndex++) { var chunk = chunkArray[chunkIndex]; var translationArray = chunk.GetNativeArray(translationType); for (var entityIndex = 0; entityIndex < chunk.Count; entityIndex++) { var translation = translationArray[entityIndex]; if (chunk.Has(knightType)) { Debug.DrawRay(translation.Value, math.up(), Color.blue); } else if (chunk.Has(orcWolfRiderType)) { Debug.DrawRay(translation.Value, math.up(), Color.magenta); } else if (chunk.Has(skeletonType)) { Debug.DrawRay(translation.Value, math.up(), Color.black); } } } chunkArray.Dispose(); }
public override void ExecuteReplication(ComponentGroup replicationGroup, ComponentSystemBase system, global::Improbable.Worker.CInterop.Connection connection) { Profiler.BeginSample("ExhaustiveBlittableSingular"); var chunkArray = replicationGroup.CreateArchetypeChunkArray(Allocator.TempJob); var spatialOSEntityType = system.GetArchetypeChunkComponentType <SpatialEntityId>(true); var componentType = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.ExhaustiveBlittableSingular.Component>(); foreach (var chunk in chunkArray) { var entityIdArray = chunk.GetNativeArray(spatialOSEntityType); var componentArray = chunk.GetNativeArray(componentType); for (var i = 0; i < componentArray.Length; i++) { var data = componentArray[i]; var eventsToSend = 0; if (data.IsDataDirty() || eventsToSend > 0) { var update = new global::Improbable.Worker.CInterop.SchemaComponentUpdate(197720); Improbable.Gdk.Tests.ExhaustiveBlittableSingular.Serialization.SerializeUpdate(data, update); // Send serialized update over the wire connection.SendComponentUpdate(entityIdArray[i].EntityId.Id, new global::Improbable.Worker.CInterop.ComponentUpdate(update)); data.MarkDataClean(); componentArray[i] = data; } } } chunkArray.Dispose(); Profiler.EndSample(); }
protected override void OnUpdate() { var entityType = GetArchetypeChunkEntityType(); var createEntityType = GetArchetypeChunkComponentType <WorldCommands.CreateEntity.CommandResponses>(); var deleteEntityType = GetArchetypeChunkComponentType <WorldCommands.DeleteEntity.CommandResponses>(); var reserveEntityIdsType = GetArchetypeChunkComponentType <WorldCommands.ReserveEntityIds.CommandResponses>(); var entityQueryType = GetArchetypeChunkComponentType <WorldCommands.EntityQuery.CommandResponses>(); var chunkArray = worldCommandResponseGroup.CreateArchetypeChunkArray(Allocator.TempJob); foreach (var chunk in chunkArray) { var entityArray = chunk.GetNativeArray(entityType); if (chunk.Has(createEntityType)) { var responseArray = chunk.GetNativeArray(createEntityType); for (var i = 0; i < entityArray.Length; i++) { WorldCommands.CreateEntity.ResponsesProvider.Free(responseArray[i].Handle); PostUpdateCommands.RemoveComponent <WorldCommands.CreateEntity.CommandResponses>(entityArray[i]); } } if (chunk.Has(deleteEntityType)) { var responseArray = chunk.GetNativeArray(deleteEntityType); for (var i = 0; i < entityArray.Length; i++) { WorldCommands.DeleteEntity.ResponsesProvider.Free(responseArray[i].Handle); PostUpdateCommands.RemoveComponent <WorldCommands.DeleteEntity.CommandResponses>(entityArray[i]); } } if (chunk.Has(reserveEntityIdsType)) { var responseArray = chunk.GetNativeArray(reserveEntityIdsType); for (var i = 0; i < entityArray.Length; i++) { WorldCommands.ReserveEntityIds.ResponsesProvider.Free(responseArray[i].Handle); PostUpdateCommands.RemoveComponent <WorldCommands.ReserveEntityIds.CommandResponses>( entityArray[i]); } } if (chunk.Has(entityQueryType)) { var responseArray = chunk.GetNativeArray(entityQueryType); for (var i = 0; i < entityArray.Length; i++) { WorldCommands.EntityQuery.ResponsesProvider.Free(responseArray[i].Handle); PostUpdateCommands.RemoveComponent <WorldCommands.EntityQuery.CommandResponses>(entityArray[i]); } } } chunkArray.Dispose(); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var rvChunks = _rVelocityGroup.CreateArchetypeChunkArray(Allocator.TempJob); var partition = new Partition() { Positions = rvChunks, Nearby = GetBufferFromEntity <NearbyEntity>(false), EntityType = GetArchetypeChunkEntityType(), PositionType = GetArchetypeChunkComponentType <Position>(true), RegionSize = RegionSize }; var partDep = partition.Schedule(this, inputDeps); var adjust = new AdjustVelocity() { Nearby = GetBufferFromEntity <NearbyEntity>(true), Positions = GetComponentDataFromEntity <Position>(true), rVelocities = GetComponentDataFromEntity <ReciprocalVelocityData>(true), PredictionWindow = PredictionWindow }; return(adjust.Schedule(this, partDep)); //return JobHandle.CombineDependencies(partDep, adjustDep); }
protected override void OnUpdate() { if (Time.time < timeOfNextHeartbeat) { return; } timeOfNextHeartbeat = Time.time + PlayerLifecycleConfig.PlayerHeartbeatIntervalSeconds; var chunkArray = group.CreateArchetypeChunkArray(Allocator.TempJob); var senderType = GetArchetypeChunkComponentType <PlayerHeartbeatClient.CommandSenders.PlayerHeartbeat>(); var spatialIdType = GetArchetypeChunkComponentType <SpatialEntityId>(true); foreach (var chunk in chunkArray) { var requestSenders = chunk.GetNativeArray(senderType); var spatialIds = chunk.GetNativeArray(spatialIdType); for (var i = 0; i < requestSenders.Length; i++) { requestSenders[i].RequestsToSend .Add(PlayerHeartbeatClient.PlayerHeartbeat.CreateRequest(spatialIds[i].EntityId, new Empty())); } } chunkArray.Dispose(); }
void UpdateChangeParents() { var changeParentsChunks = m_ExistingParentsGroup.CreateArchetypeChunkArray(Allocator.TempJob); if (changeParentsChunks.Length > 0) { var parentType = GetArchetypeChunkComponentType <Parent>(true); var previousParentType = GetArchetypeChunkComponentType <PreviousParent>(true); var entityType = GetArchetypeChunkEntityType(); var changedParents = new NativeList <ChangedParent>(Allocator.TempJob); var filterChangedParentsJob = new FilterChangedParents { Chunks = changeParentsChunks, ChangedParents = changedParents, ParentType = parentType, PreviousParentType = previousParentType, EntityType = entityType }; var filterChangedParentsJobHandle = filterChangedParentsJob.Schedule(); filterChangedParentsJobHandle.Complete(); for (int i = 0; i < changedParents.Length; i++) { var childEntity = changedParents[i].ChildEntity; var previousParentEntity = changedParents[i].PreviousParentEntity; var parentEntity = changedParents[i].ParentEntity; RemoveChildFromParent(childEntity, previousParentEntity); AddChildToParent(childEntity, parentEntity); } changedParents.Dispose(); } changeParentsChunks.Dispose(); }
protected override void OnUpdate() { var chunks = _group.CreateArchetypeChunkArray(Allocator.TempJob); var jobHandles = new NativeArray <JobHandle>(SetUpData.ChunkCount, Allocator.Persistent); var archetypeDataComponent = GetArchetypeChunkBufferType <DataComponent>(); var counter = 0; // ReSharper disable once ForCanBeConvertedToForeach for (var i = 0; i < chunks.Length; i++) { var chunk = chunks[i]; var dataComponents = chunk.GetBufferAccessor(archetypeDataComponent); for (var j = 0; j < dataComponents.Length; j++) { var dataComponent = dataComponents[j]; jobHandles[counter] = new Job { DataComponent = (DataComponent *)dataComponent.GetUnsafePtr(), }.Schedule(dataComponent.Length, SetUpData.BatchCountMultipleJobs); counter++; } } JobHandle.CompleteAll(jobHandles); jobHandles.Dispose(); chunks.Dispose(); }
protected override void OnUpdate() { var chunks = _group.CreateArchetypeChunkArray(Allocator.TempJob); new Job { Chunks = chunks, DataComponent = GetArchetypeChunkBufferType <DataComponent>(), }.Schedule(chunks.Length, 1).Complete(); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { JobHandle bulletHandle; JobHandle asteroidHandle; JobHandle levelHandle; JobHandle settingsHandle; var asteroidJob = new DestroyAsteroidJob { commandBuffer = barrier.CreateCommandBuffer().ToConcurrent(), bulletChunks = bulletGroup.CreateArchetypeChunkArray(Allocator.TempJob, out bulletHandle), bulletAgeType = GetArchetypeChunkComponentType <BulletAgeComponentData>(true), positionType = GetArchetypeChunkComponentType <Translation>(true), sphereType = GetArchetypeChunkComponentType <CollisionSphereComponentData>(true), entityType = GetArchetypeChunkEntityType(), level = m_LevelGroup.ToComponentDataArray <LevelComponent>(Allocator.TempJob, out levelHandle) }; var shipJob = new DestroyShipJob { commandBuffer = barrier.CreateCommandBuffer().ToConcurrent(), asteroidChunks = asteroidGroup.CreateArchetypeChunkArray(Allocator.TempJob, out asteroidHandle), bulletChunks = asteroidJob.bulletChunks, bulletAgeType = asteroidJob.bulletAgeType, positionType = asteroidJob.positionType, sphereType = asteroidJob.sphereType, playerIdType = GetArchetypeChunkComponentType <PlayerIdComponentData>(), entityType = asteroidJob.entityType, serverSettings = settingsGroup.ToComponentDataArray <ServerSettings>(Allocator.TempJob, out settingsHandle), playerClearQueue = playerClearQueue.ToConcurrent(), level = asteroidJob.level }; var asteroidDep = JobHandle.CombineDependencies(inputDeps, bulletHandle, levelHandle); var shipDep = JobHandle.CombineDependencies(asteroidDep, asteroidHandle, settingsHandle); var h1 = asteroidJob.Schedule(asteroidGroup, asteroidDep); var h2 = shipJob.Schedule(shipGroup, shipDep); var handle = JobHandle.CombineDependencies(h1, h2); barrier.AddJobHandleForProducer(handle); var cleanupShipJob = new ClearShipPointerJob { playerClearQueue = playerClearQueue, playerState = GetComponentDataFromEntity <PlayerStateComponentData>() }; var cleanupChunkJob = new ChunkCleanupJob { bulletChunks = shipJob.bulletChunks, asteroidChunks = shipJob.asteroidChunks, level = shipJob.level }; return(JobHandle.CombineDependencies(cleanupShipJob.Schedule(h2), cleanupChunkJob.Schedule(handle))); }
void UpdateDynamicChunkCache() { var dynamicChunksOrderVersion = EntityManager.GetComponentOrderVersion <VisibleLocalToWorld>(); if (dynamicChunksOrderVersion == m_LastDynamicChunksOrderVersion) { return; } // Dispose if (m_DynamicChunks.IsCreated) { m_DynamicChunks.Dispose(); } var sharedComponentCount = EntityManager.GetSharedComponentCount(); var meshInstanceRendererType = GetArchetypeChunkSharedComponentType <MeshInstanceRenderer>(); // Allocate temp data var chunkRendererMap = new NativeMultiHashMap <int, int>(100000, Allocator.TempJob); var foundArchetypes = new NativeList <EntityArchetype>(Allocator.TempJob); Profiler.BeginSample("CreateArchetypeChunkArray"); var chunks = m_DynamicChunksQuery.CreateArchetypeChunkArray(Allocator.TempJob); Profiler.EndSample(); m_DynamicChunks = new NativeArray <ArchetypeChunk>(chunks.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); var mapChunkRenderersJob = new MapChunkRenderers { Chunks = chunks, MeshInstanceRendererType = meshInstanceRendererType, ChunkRendererMap = chunkRendererMap.ToConcurrent() }; var mapChunkRenderersJobHandle = mapChunkRenderersJob.Schedule(chunks.Length, 64); var gatherSortedChunksJob = new GatherSortedChunks { ChunkRendererMap = chunkRendererMap, SharedComponentCount = sharedComponentCount, SortedChunks = m_DynamicChunks, Chunks = chunks }; var gatherSortedChunksJobHandle = gatherSortedChunksJob.Schedule(mapChunkRenderersJobHandle); gatherSortedChunksJobHandle.Complete(); foundArchetypes.Dispose(); chunkRendererMap.Dispose(); chunks.Dispose(); m_LastDynamicChunksOrderVersion = dynamicChunksOrderVersion; }
protected override void OnUpdate() { if (geneticTrainerGroup.GetEntityArray().Length != 0) { float maxPoint = 0; for (int i = 0, length = checkPointComponentGroup.GetEntityArray().Length; i < length; ++i) { maxPoint += checkPointComponentGroup.GetComponentDataArray <PointComponentData>()[i].PointValue; } var chunks = geneticTrainerGroup.CreateArchetypeChunkArray(Allocator.TempJob); for (int i = 0, length = chunks.Length; i < length; ++i) { var chunk = chunks[i]; var entities = chunk.GetNativeArray(GetArchetypeChunkEntityType()); for (int j = 0, trainerCount = entities.Length; j < length; ++j) { var entity = entities[j]; var geneticTrainer = EntityManager.GetComponentObject <Transform>(entity).GetComponent <GeneticTrainerComponent>(); var timer = EntityManager.GetComponentData <TimerData>(entity); timer.Stopped = 1; EntityManager.SetComponentData(entity, timer); var data = geneticTrainer.Value; data.maxPoint = maxPoint; geneticTrainer.Value = data; if (geneticTrainer.preset == null) { geneticTrainer.preset = geneticTrainer.InstantiateGameObject(geneticTrainer.unInitialiazedPreset); EntityManager.Instantiate(geneticTrainer.preset, geneticTrainer.pool); EntityManager.AddComponent(geneticTrainer.pool, ComponentType.Create <CollisionStateComponent>()); EntityManager.AddComponent(geneticTrainer.pool, ComponentType.Create <CollisionResponseComponent>()); var geneticTrainerID = new GeneticTrainerIDComponentData { ID = geneticTrainer.Value.TrainerID }; for (int k = 0, poolLength = geneticTrainer.pool.Length; k < poolLength; ++k) { var poolEntity = geneticTrainer.pool[k]; EntityManager.AddComponentData(poolEntity, new FrozenComponentData()); EntityManager.AddComponentData(poolEntity, new NeuralNetworkIDComponentData { ID = k }); EntityManager.AddSharedComponentData(poolEntity, geneticTrainerID); EntityManager.SetComponentObject(poolEntity, ComponentType.Create <CollisionStateComponent>(), new CollisionStateComponent()); EntityManager.SetComponentObject(poolEntity, ComponentType.Create <CollisionResponseComponent>(), new CarCollisionResponse(poolEntity, EntityManager, checkPointComponentGroup.GetEntityArray().Length, checkPointComponentGroup.GetComponentDataArray <Position>(), checkPointComponentGroup.GetComponentDataArray <PointComponentData>(), checkPointComponentGroup.GetComponentDataArray <IDComponentData>())); } EntityManager.AddComponentData(entity, new InitializedComponentData()); } } } chunks.Dispose(); } }
void CheckNeighboursAreReady() { NativeArray <ArchetypeChunk> dataChunks = meshReadyGroup.CreateArchetypeChunkArray(Allocator.TempJob); ArchetypeChunkEntityType entityType = GetArchetypeChunkEntityType(); ArchetypeChunkComponentType <AdjacentSectors> adjacentType = GetArchetypeChunkComponentType <AdjacentSectors>(true); for (int c = 0; c < dataChunks.Length; c++) { ArchetypeChunk dataChunk = dataChunks[c]; NativeArray <Entity> entities = dataChunk.GetNativeArray(entityType); NativeArray <AdjacentSectors> adjacents = dataChunk.GetNativeArray(adjacentType); for (int e = 0; e < entities.Length; e++) { Entity entity = entities[e]; AdjacentSectors adjacentSquares = adjacents[e]; NativeArray <Block> current = new NativeArray <Block>(entityManager.GetBuffer <Block>(entity).AsNativeArray(), Allocator.TempJob); NativeArray <Block> northNeighbour = new NativeArray <Block>(entityManager.GetBuffer <Block>(adjacentSquares[0]).AsNativeArray(), Allocator.TempJob); NativeArray <Block> southNeighbour = new NativeArray <Block>(entityManager.GetBuffer <Block>(adjacentSquares[1]).AsNativeArray(), Allocator.TempJob); NativeArray <Block> eastNeighbour = new NativeArray <Block>(entityManager.GetBuffer <Block>(adjacentSquares[2]).AsNativeArray(), Allocator.TempJob); NativeArray <Block> westNeighbour = new NativeArray <Block>(entityManager.GetBuffer <Block>(adjacentSquares[3]).AsNativeArray(), Allocator.TempJob); NativeArray <Block> upNeighbour = new NativeArray <Block>(entityManager.GetBuffer <Block>(adjacentSquares[4]).AsNativeArray(), Allocator.TempJob); NativeArray <Block> downNeighbour = new NativeArray <Block>(entityManager.GetBuffer <Block>(adjacentSquares[5]).AsNativeArray(), Allocator.TempJob); if (northNeighbour.Length == 0 || southNeighbour.Length == 0 || eastNeighbour.Length == 0 || westNeighbour.Length == 0 || upNeighbour.Length == 0 || downNeighbour.Length == 0) { current.Dispose(); northNeighbour.Dispose(); southNeighbour.Dispose(); eastNeighbour.Dispose(); westNeighbour.Dispose(); upNeighbour.Dispose(); downNeighbour.Dispose(); continue; } else { PostUpdateCommands.AddComponent(entity, new NeighboursAreReady()); } current.Dispose(); northNeighbour.Dispose(); southNeighbour.Dispose(); eastNeighbour.Dispose(); westNeighbour.Dispose(); upNeighbour.Dispose(); downNeighbour.Dispose(); } } dataChunks.Dispose(); }
protected override void OnUpdate() { ArchetypeChunkComponentType <PlayerInputData> playerInputDataRW = GetArchetypeChunkComponentType <PlayerInputData>(false); NativeArray <ArchetypeChunk> playerInputDataChunk = playerInputDataGroup.CreateArchetypeChunkArray(Allocator.TempJob); if (playerInputDataChunk.Length == 0) { playerInputDataChunk.Dispose(); return; } for (int chunkIndex = 0; chunkIndex < playerInputDataChunk.Length; chunkIndex++) { ArchetypeChunk chunk = playerInputDataChunk[chunkIndex]; int dataCount = chunk.Count; NativeArray <PlayerInputData> playerInputDataArray = chunk.GetNativeArray(playerInputDataRW); for (int dataIndex = 0; dataIndex < dataCount; dataIndex++) { PlayerInputData playerInputData = playerInputDataArray[dataIndex]; float moveHorizontal = 0.0f; float moveVertical = 0.0f; bool fireButtonPressed = false; switch (playerInputData.playerID) { case 0: { moveHorizontal = Input.GetAxis("Horizontal"); moveVertical = Input.GetAxis("Vertical"); fireButtonPressed = Input.GetButton("Fire1"); } break; default: { Debug.LogError("Addional players not supported for now"); } break; } playerInputData.inputMovementDirection.x = moveHorizontal; playerInputData.inputMovementDirection.z = moveVertical; playerInputData.fireButtonPressed = fireButtonPressed ? 1 : 0; playerInputDataArray[dataIndex] = playerInputData; } } playerInputDataChunk.Dispose(); }
protected override void OnUpdate() { var viewPoolSystem = World.GetExistingManager <ViewPoolSystem>(); var chunkArray = m_Group.CreateArchetypeChunkArray(Allocator.TempJob); var entityType = GetArchetypeChunkEntityType(); var knightType = GetArchetypeChunkComponentType <Knight>(true); var orcWolfRiderType = GetArchetypeChunkComponentType <OrcWolfRider>(true); var skeletonType = GetArchetypeChunkComponentType <Skeleton>(true); for (int chunkIndex = 0; chunkIndex < chunkArray.Length; chunkIndex++) { var chunk = chunkArray[chunkIndex]; var hasOrcWolfRider = chunk.Has(orcWolfRiderType); var hasSkeleton = chunk.Has(skeletonType); var entityArray = chunk.GetNativeArray(entityType); { if (chunk.Has(knightType)) { m_KnightList.AddRange(entityArray); } else if (chunk.Has(orcWolfRiderType)) { m_OrcWolfRiderList.AddRange(entityArray); } else if (chunk.Has(skeletonType)) { m_SkeletonList.AddRange(entityArray); } } } chunkArray.Dispose(); for (var entityIndex = 0; entityIndex < m_KnightList.Length; entityIndex++) { Instantiate(viewPoolSystem.m_KnightPool, ViewType.Knight, m_KnightPrefab, m_KnightList[entityIndex]); } for (var entityIndex = 0; entityIndex < m_OrcWolfRiderList.Length; entityIndex++) { Instantiate(viewPoolSystem.m_OrcWolfRiderPool, ViewType.OrcWolfRider, m_OrcWolfRiderPrefab, m_OrcWolfRiderList[entityIndex]); } for (var entityIndex = 0; entityIndex < m_SkeletonList.Length; entityIndex++) { Instantiate(viewPoolSystem.m_SkeletonPool, ViewType.Skeleton, m_SkeletonPrefab, m_SkeletonList[entityIndex]); } m_KnightList.Clear(); m_OrcWolfRiderList.Clear(); m_SkeletonList.Clear(); }
public override void ExecuteReplication(ComponentGroup replicationGroup, ComponentSystemBase system, global::Improbable.Worker.CInterop.Connection connection) { Profiler.BeginSample("Connection"); var chunkArray = replicationGroup.CreateArchetypeChunkArray(Allocator.TempJob); var spatialOSEntityType = system.GetArchetypeChunkComponentType <SpatialEntityId>(true); var componentType = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.Component>(); var eventMyEventType = system.GetArchetypeChunkComponentType <EventSender.MyEvent>(true); foreach (var chunk in chunkArray) { var entityIdArray = chunk.GetNativeArray(spatialOSEntityType); var componentArray = chunk.GetNativeArray(componentType); var eventMyEventArray = chunk.GetNativeArray(eventMyEventType); for (var i = 0; i < componentArray.Length; i++) { var data = componentArray[i]; var eventsToSend = 0; var eventsMyEvent = eventMyEventArray[i].Events; eventsToSend += eventsMyEvent.Count; if (data.IsDataDirty() || eventsToSend > 0) { var update = new global::Improbable.Worker.CInterop.SchemaComponentUpdate(1105); Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.Serialization.SerializeUpdate(data, update); // Serialize events var eventsObject = update.GetEvents(); if (eventsMyEvent.Count > 0) { foreach (var e in eventsMyEvent) { var obj = eventsObject.AddObject(1); global::Improbable.Gdk.Tests.AlternateSchemaSyntax.RandomDataType.Serialization.Serialize(e, obj); } eventsMyEvent.Clear(); } // Send serialized update over the wire connection.SendComponentUpdate(entityIdArray[i].EntityId.Id, new global::Improbable.Worker.CInterop.ComponentUpdate(update), UpdateParameters); data.MarkDataClean(); componentArray[i] = data; } } } chunkArray.Dispose(); Profiler.EndSample(); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { EntityArray boltSpawnerEntityDataArray = boltSpawnerEntityDataGroup.GetEntityArray(); if (boltSpawnerEntityDataArray.Length == 0) { return(inputDeps); } BoltSpawnerEntityData boltSpawnerEntityData = GetComponentDataFromEntity <BoltSpawnerEntityData>()[boltSpawnerEntityDataArray[0]]; ArchetypeChunkEntityType entityTypeRO = GetArchetypeChunkEntityType(); ArchetypeChunkComponentType <PlayerInputData> playerInputDataRO = GetArchetypeChunkComponentType <PlayerInputData>(true); ArchetypeChunkComponentType <PlayerMoveData> playerMoveDataRO = GetArchetypeChunkComponentType <PlayerMoveData>(true); ArchetypeChunkComponentType <Position> positionRO = GetArchetypeChunkComponentType <Position>(true); ArchetypeChunkComponentType <PlayerSpawnBoltData> playerSpawnBoltDataRW = GetArchetypeChunkComponentType <PlayerSpawnBoltData>(false); //CreateArchetypeChunkArray runs inside a job, we can use a job handle to make dependency on that job //A NativeArray<ArchetypeChunk> is allocated with the correct size on the main thread and that's what is returned, we are responsible for de-allocating it (In this case using [DeallocateOnJobCompletion] in the move job) //The job scheduled by CreateArchetypeChunkArray fill that array with correct chunk information JobHandle createChunckArrayJobHandle = new JobHandle(); NativeArray <ArchetypeChunk> playerSpawnBoltDataChunks = playerSpawnBoltDataGroup.CreateArchetypeChunkArray(Allocator.TempJob, out createChunckArrayJobHandle); //Special case when our query return no chunk at all if (playerSpawnBoltDataChunks.Length == 0) { createChunckArrayJobHandle.Complete(); playerSpawnBoltDataChunks.Dispose(); return(inputDeps); } //Make sure our movejob is dependent on the job filling the array has completed JobHandle spawnJobDependency = JobHandle.CombineDependencies(inputDeps, createChunckArrayJobHandle); PlayerSpawnBoltJob playerSpawnBoltJob = new PlayerSpawnBoltJob { chunks = playerSpawnBoltDataChunks, entityTypeRO = entityTypeRO, playerInputDataRO = playerInputDataRO, playerMoveDataRO = playerMoveDataRO, positionRO = positionRO, playerSpawnBoltDataRW = playerSpawnBoltDataRW, spawnBoltEntityQueue = boltSpawnerEntityData.playerBoltSpawnQueueConcurrent, currentTime = Time.time, }; return(playerSpawnBoltJob.Schedule(playerSpawnBoltDataChunks.Length, MonoBehaviourECSBridge.Instance.GetJobBatchCount(playerSpawnBoltDataChunks.Length), spawnJobDependency)); }
public override void ExecuteReplication(ComponentGroup replicationGroup, ComponentSystemBase system, global::Improbable.Worker.Core.Connection connection) { Profiler.BeginSample("ComponentWithNoFieldsWithEvents"); var chunkArray = replicationGroup.CreateArchetypeChunkArray(Allocator.TempJob); var spatialOSEntityType = system.GetArchetypeChunkComponentType <SpatialEntityId>(true); var componentType = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component>(); var eventEvtType = system.GetArchetypeChunkComponentType <EventSender.Evt>(true); foreach (var chunk in chunkArray) { var entityIdArray = chunk.GetNativeArray(spatialOSEntityType); var componentArray = chunk.GetNativeArray(componentType); var eventEvtArray = chunk.GetNativeArray(eventEvtType); for (var i = 0; i < componentArray.Length; i++) { var data = componentArray[i]; var dirtyEvents = 0; var eventsEvt = eventEvtArray[i].Events; dirtyEvents += eventsEvt.Count; if (data.DirtyBit || dirtyEvents > 0) { var update = new global::Improbable.Worker.Core.SchemaComponentUpdate(1004); Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Serialization.SerializeUpdate(data, update); // Serialize events var eventsObject = update.GetEvents(); if (eventsEvt.Count > 0) { foreach (var e in eventsEvt) { var obj = eventsObject.AddObject(1); global::Improbable.Gdk.Tests.ComponentsWithNoFields.Empty.Serialization.Serialize(e, obj); } eventsEvt.Clear(); } // Send serialized update over the wire connection.SendComponentUpdate(entityIdArray[i].EntityId, new global::Improbable.Worker.Core.ComponentUpdate(update)); data.DirtyBit = false; componentArray[i] = data; } } } chunkArray.Dispose(); Profiler.EndSample(); }
internal void CleanCloned() { var enType = GetArchetypeChunkEntityType(); var aca = clonedGroup.CreateArchetypeChunkArray(Allocator.TempJob); for (int i = 0; i < aca.Length; i++) { var ea = aca[i].GetNativeArray(enType); for (int j = 0; j < ea.Length; j++) { EntityManager.RemoveComponent <Cloned>(ea[j]); } } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { NativeArray <ArchetypeChunk> dataChunks = meshDataGroup.CreateArchetypeChunkArray(Allocator.TempJob); if (dataChunks.Length == 0) { dataChunks.Dispose(); return(inputDeps); } EntityCommandBuffer eCBuffer = new EntityCommandBuffer(Allocator.TempJob); ArchetypeChunkEntityType entityType = GetArchetypeChunkEntityType(); ArchetypeChunkComponentType <Sector> sectorType = GetArchetypeChunkComponentType <Sector>(true); ArchetypeChunkComponentType <SectorVisFacesCount> faceCountsType = GetArchetypeChunkComponentType <SectorVisFacesCount>(true); ArchetypeChunkBufferType <Block> blocksType = GetArchetypeChunkBufferType <Block>(true); ArchetypeChunkBufferType <BlockFaces> facesType = GetArchetypeChunkBufferType <BlockFaces>(true); for (int c = 0; c < dataChunks.Length; c++) { ArchetypeChunk dataChunk = dataChunks[c]; // Get chunk data NativeArray <Entity> entities = dataChunk.GetNativeArray(entityType); NativeArray <Sector> sectors = dataChunk.GetNativeArray(sectorType); NativeArray <SectorVisFacesCount> faceCounts = dataChunk.GetNativeArray(faceCountsType); BufferAccessor <Block> blockAccessor = dataChunk.GetBufferAccessor(blocksType); BufferAccessor <BlockFaces> facesAccessor = dataChunk.GetBufferAccessor(facesType); for (int e = 0; e < entities.Length; e++) { var meshDataJob = new MeshDataJob() { ECBuffer = eCBuffer, entity = entities[e], counts = faceCounts[e], sector = sectors[e], blocks = new NativeArray <Block>(blockAccessor[e].AsNativeArray(), Allocator.TempJob), blockFaces = new NativeArray <BlockFaces>(facesAccessor[e].AsNativeArray(), Allocator.TempJob), }.Schedule(inputDeps); meshDataJob.Complete(); } } eCBuffer.Playback(entityManager); eCBuffer.Dispose(); dataChunks.Dispose(); return(inputDeps); }
void ScheduleMoreJobs() { NativeArray <ArchetypeChunk> dataChunks = meshDataGroup.CreateArchetypeChunkArray(Allocator.TempJob); EntityCommandBuffer eCBuffer = new EntityCommandBuffer(Allocator.TempJob); JobHandle allHandles = new JobHandle(); JobHandle previousHandle = new JobHandle(); ArchetypeChunkEntityType entityType = GetArchetypeChunkEntityType(); ArchetypeChunkComponentType <Sector> sectorType = GetArchetypeChunkComponentType <Sector>(true); ArchetypeChunkComponentType <SectorVisFacesCount> faceCountsType = GetArchetypeChunkComponentType <SectorVisFacesCount>(true); ArchetypeChunkBufferType <Block> blocksType = GetArchetypeChunkBufferType <Block>(true); ArchetypeChunkBufferType <BlockFaces> facesType = GetArchetypeChunkBufferType <BlockFaces>(true); for (int c = 0; c < dataChunks.Length; c++) { ArchetypeChunk dataChunk = dataChunks[c]; // Get chunk data NativeArray <Entity> entities = dataChunk.GetNativeArray(entityType); NativeArray <Sector> sectors = dataChunk.GetNativeArray(sectorType); NativeArray <SectorVisFacesCount> faceCounts = dataChunk.GetNativeArray(faceCountsType); BufferAccessor <Block> blockAccessor = dataChunk.GetBufferAccessor(blocksType); BufferAccessor <BlockFaces> facesAccessor = dataChunk.GetBufferAccessor(facesType); for (int e = 0; e < entities.Length; e++) { MeshDataJob meshDataJob = new MeshDataJob() { ECBuffer = eCBuffer, entity = entities[e], counts = faceCounts[e], sector = sectors[e], blocks = new NativeArray <Block>(blockAccessor[e].AsNativeArray(), Allocator.TempJob), blockFaces = new NativeArray <BlockFaces>(facesAccessor[e].AsNativeArray(), Allocator.TempJob), }; JobHandle thisHandle = meshDataJob.Schedule(previousHandle); allHandles = JobHandle.CombineDependencies(thisHandle, allHandles); previousHandle = thisHandle; } } runningCommandBuffer = eCBuffer; runningJobHandle = allHandles; dataChunks.Dispose(); }
protected override void OnUpdate() { _positionType = GetArchetypeChunkComponentType <Position>(); _rotationType = GetArchetypeChunkComponentType <Rotation>(); _xrNodeType = GetArchetypeChunkComponentType <VrNodeData>(); var chunks = _groupControllers.CreateArchetypeChunkArray(Allocator.TempJob); for (int i = 0; i < chunks.Length; i++) { ProcessControllerChunks(chunks[i]); } chunks.Dispose(); }