protected override JobHandle OnUpdate(JobHandle inputDeps) { var handle = inputDeps; if (PlayerPositionChanged()) { var jobDespawn = new DeSpawnChunksAround { childBuffer = GetBufferFromEntity <ChunkChildBlock>(true), commandBuffer = ecbSystem.CreateCommandBuffer().ToConcurrent(), playerPosition = GetPlayerPosition() }; handle = jobDespawn.Schedule(this, handle); var job = new SpawnChunksAround { commandBuffer = ecbSystem.CreateCommandBuffer(), playerPosition = GetPlayerPosition() }; handle = job.Schedule(handle); ecbSystem.AddJobHandleForProducer(handle); } return(handle); }
protected override JobHandle OnUpdate(JobHandle inputDep) { if (!m_DriverSystem.ClientDriver.IsCreated) { return(inputDep); } PingClientUIBehaviour.UpdateStats(m_pingStats[0], m_pingStats[1]); if (PingClientUIBehaviour.ServerEndPoint.IsValid && m_ConnectionGroup.IsEmptyIgnoreFilter) { var conJob = new ConnectJob { driver = m_DriverSystem.ClientDriver, serverEP = PingClientUIBehaviour.ServerEndPoint, commandBuffer = m_Barrier.CreateCommandBuffer() }; inputDep = conJob.Schedule(inputDep); m_Barrier.AddJobHandleForProducer(inputDep); return(inputDep); } var pingJob = new PingJob { driver = m_DriverSystem.ClientDriver, serverEP = PingClientUIBehaviour.ServerEndPoint, pendingPings = m_pendingPings, pingStats = m_pingStats, fixedTime = Time.fixedTime, commandBuffer = m_Barrier.CreateCommandBuffer() }; var handle = pingJob.ScheduleSingle(this, inputDep); m_Barrier.AddJobHandleForProducer(handle); return(handle); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { JobHandle queryJob; var connection = m_ConnectionQuery.ToEntityArray(Allocator.TempJob, out queryJob); var sendSetupJob = new SendPlayerSetupJob { CommandBuffer = m_CommandBuffer.CreateCommandBuffer(), RpcQueue = m_RpcSettingsQueue, ConnectionEntity = connection, RpcBuffer = GetBufferFromEntity <OutgoingRpcDataStreamBufferComponent>() }; var jobHandle = sendSetupJob.ScheduleSingle(this, JobHandle.CombineDependencies(inputDeps, queryJob)); var remoteCommandJob = new SendRemoteCommandJob() { CommandBuffer = m_CommandBuffer.CreateCommandBuffer(), RpcQueue = m_RpcRemoteCmdQueue, ConnectionEntity = connection, RpcBuffer = GetBufferFromEntity <OutgoingRpcDataStreamBufferComponent>() }; jobHandle = remoteCommandJob.ScheduleSingle(this, jobHandle); m_CommandBuffer.AddJobHandleForProducer(jobHandle); return(jobHandle); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var inputDeps1 = new AddSystemStateJob { Ecb = m_EntityCommandBuffer.CreateCommandBuffer().ToConcurrent(), EntityType = GetArchetypeChunkEntityType(), Targets = GetArchetypeChunkComponentType <AbilityOwnerComponent>() }.Schedule(m_AddSystemState, inputDeps); var inputDeps2 = new CleanupEntityJob { Ecb = m_EntityCommandBuffer.CreateCommandBuffer().ToConcurrent(), EntityType = GetArchetypeChunkEntityType(), }.Schedule(m_RemoveSystemState, inputDeps); inputDeps = JobHandle.CombineDependencies(inputDeps, inputDeps1, inputDeps2); inputDeps = new RemoveElementFromDynamicBuffer { bufferFromEntity = GetBufferFromEntity <GrantedAbilityBufferElement>(), entities = m_RemoveSystemState.ToEntityArray(Allocator.TempJob), targetComponents = m_RemoveSystemState.ToComponentDataArray <GrantedAbilitySystemStateComponent>(Allocator.TempJob) }.Schedule(inputDeps); inputDeps = new AddElementToDynamicBuffer { bufferFromEntity = GetBufferFromEntity <GrantedAbilityBufferElement>(), entities = m_AddSystemState.ToEntityArray(Allocator.TempJob), targetComponents = m_AddSystemState.ToComponentDataArray <AbilityOwnerComponent>(Allocator.TempJob) }.Schedule(inputDeps); m_EntityCommandBuffer.AddJobHandleForProducer(inputDeps); return(inputDeps); }
void Generate(Entity mapEntity, float2 resize) { var mapData = EntityManager.GetComponentData <MapData>(mapEntity); var commandBuffer = _barrierSystem.CreateCommandBuffer(); int monsterCount = _monstersQuery.CalculateEntityCount(); Job.WithCode(() => { var genData = GenerateMap.Default; genData.monsterCount = monsterCount; commandBuffer.AddComponent(mapEntity, genData); mapData.width += (int)resize.x; mapData.height += (int)resize.y; mapData.width = math.max(15, mapData.width); mapData.height = math.max(15, mapData.height); commandBuffer.SetComponent(mapEntity, mapData); }).Schedule(); _barrierSystem.AddJobHandleForProducer(Dependency); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var mouse = GetSingleton <SingletonMouseInput>(); var jobHandle = inputDeps; if (mouse.LeftClickUp) { var selectionBoxJob = new SelectionBoxJob { currentMouseRayPosition = mouse.CurrentMouseRaycastPosition, initialMouseRayPosition = mouse.InitialMouseRaycastPosition, selected = GetComponentDataFromEntity <TagSelected>(), entityCommandBuffer = m_EntityCommandBufferSystem.CreateCommandBuffer(), }; jobHandle = selectionBoxJob.ScheduleSingle(this, inputDeps); } else if (mouse.LeftClickDown) { var selectClickJob = new SelectClickJob { currentMouseRayPosition = mouse.CurrentMouseRaycastPosition, selected = GetComponentDataFromEntity <TagSelected>(), entityCommandBuffer = m_EntityCommandBufferSystem.CreateCommandBuffer(), }; jobHandle = selectClickJob.Schedule(this, inputDeps); } m_EntityCommandBufferSystem.AddJobHandleForProducer(jobHandle); return(jobHandle); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { inputDeps.Complete(); JobHandle serverJobHandle; //Debug.Log("server system on update"); if (!m_Driver.IsCreated) { ReliableUtility.Parameters reliabilityParams = new ReliableUtility.Parameters { WindowSize = 32 }; SimulatorUtility.Parameters simulatorParams = new SimulatorUtility.Parameters { MaxPacketSize = k_PacketSize, MaxPacketCount = 30, PacketDelayMs = 100 }; m_Driver = new UdpNetworkDriver(simulatorParams, reliabilityParams); NetworkEndPoint endpoint = NetworkEndPoint.AnyIpv4; endpoint.Port = 9000; if (m_Driver.Bind(endpoint) != 0) { Debug.Log("Failed to bind to port 9000"); } else { m_Driver.Listen(); Debug.Log("driver listening on port 9000"); } currentId = new NativeList <int>(1, Allocator.Persistent); currentId.Add(0); } else { serverJobHandle = m_Driver.ScheduleUpdate(inputDeps); serverJobHandle = new ListenForConnectionsJob { commandBuffer = m_Barrier.CreateCommandBuffer(), driver = m_Driver, }.Schedule(serverJobHandle); serverJobHandle.Complete(); serverJobHandle = new UpdateServerJob { commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(), driver = m_Driver.ToConcurrent(), id = currentId.AsDeferredJobArray() }.Schedule(this, serverJobHandle); m_Barrier.AddJobHandleForProducer(serverJobHandle); //Debug.Log("about to listen for connections"); return(serverJobHandle); } return(inputDeps); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { JobHandle bulletHandle; JobHandle asteroidHandle; JobHandle levelHandle; JobHandle settingsHandle; var asteroidJob = new DestroyAsteroidJob { commandBuffer = barrier.CreateCommandBuffer().ToConcurrent(), bulletChunks = bulletGroup.CreateArchetypeChunkArrayAsync(Allocator.TempJob, out bulletHandle), bulletAgeType = GetArchetypeChunkComponentType <BulletAgeComponent>(true), positionType = GetArchetypeChunkComponentType <Translation>(true), sphereType = GetArchetypeChunkComponentType <CollisionSphereComponent>(true), entityType = GetArchetypeChunkEntityType(), level = m_LevelGroup.ToComponentDataArrayAsync <LevelComponent>(Allocator.TempJob, out levelHandle) }; var shipJob = new DestroyShipJob { commandBuffer = barrier.CreateCommandBuffer().ToConcurrent(), asteroidChunks = asteroidGroup.CreateArchetypeChunkArrayAsync(Allocator.TempJob, out asteroidHandle), bulletChunks = asteroidJob.bulletChunks, bulletAgeType = asteroidJob.bulletAgeType, positionType = asteroidJob.positionType, sphereType = asteroidJob.sphereType, playerIdType = GetArchetypeChunkComponentType <PlayerIdComponentData>(), entityType = asteroidJob.entityType, serverSettings = settingsGroup.ToComponentDataArrayAsync <ServerSettings>(Allocator.TempJob, out settingsHandle), playerClearQueue = playerClearQueue.AsParallelWriter(), 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, commandTarget = GetComponentDataFromEntity <CommandTargetComponent>() }; var cleanupChunkJob = new ChunkCleanupJob { bulletChunks = shipJob.bulletChunks, asteroidChunks = shipJob.asteroidChunks, level = shipJob.level }; return(JobHandle.CombineDependencies(cleanupShipJob.Schedule(h2), cleanupChunkJob.Schedule(handle))); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { inputDeps.Complete(); JobHandle clientJobHandle; if (!m_Driver.IsCreated) { ReliableUtility.Parameters reliabilityParams = new ReliableUtility.Parameters { WindowSize = 32 }; SimulatorUtility.Parameters simulatorParams = new SimulatorUtility.Parameters { MaxPacketSize = k_PacketSize, MaxPacketCount = 30, PacketDelayMs = 100 }; m_Driver = new UdpNetworkDriver(simulatorParams, reliabilityParams); m_Server_EndPoint = NetworkEndPoint.LoopbackIpv4; m_Server_EndPoint.Port = 9000; } else { clientJobHandle = m_Driver.ScheduleUpdate(inputDeps); if (m_Server_EndPoint.IsValid && m_ConnectionGroup.IsEmptyIgnoreFilter) { //Debug.Log("client job handle about to be created"); clientJobHandle = new SendConnectionRequestJob { commandBuffer = m_Barrier.CreateCommandBuffer(), driver = m_Driver, serverEndPoint = m_Server_EndPoint, }.Schedule(clientJobHandle); } clientJobHandle.Complete(); clientJobHandle = new UpdateClientJob { commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(), driver = m_Driver.ToConcurrent(), serverEndPoint = m_Server_EndPoint, }.Schedule(this, clientJobHandle); m_Barrier.AddJobHandleForProducer(clientJobHandle); return(clientJobHandle); } return(inputDeps); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { if (_options == null) { _options = GameObject.Find("Options").GetComponent <Options>(); } inputDeps = JobHandle.CombineDependencies(inputDeps, _terrain.UpdateCacheJob); var blockHitCounts = new NativeArray <int>(_options.terrainSizeX * _options.terrainSizeZ, Allocator.TempJob); JobHandle outputJob = new UpdateCannonballJob { PlayerCenterPosition = _playerPosCache.PlayerPosition + new float3(0, PLAYER_RADIUS, 0), ElapsedTime = Time.time, TerrainSize = new int2(_options.terrainSizeX, _options.terrainSizeZ), EnableInvincibility = _options.invincibility, BlockHeights = _terrain.CachedBlockHeights, BlockEntities = _terrain.BlockEntities, BlockHitCounts = blockHitCounts, BoxHeightDamage = _options.boxHeightDamage, CommandBuffer = _barrier.CreateCommandBuffer().ToConcurrent(), }.Schedule(_cannonballQuery, inputDeps); _barrier.AddJobHandleForProducer(outputJob); return(outputJob); }
protected override void OnUpdate() { var ecb = BeginSimulationEntityCommandBufferSystem.CreateCommandBuffer(); var prefabs = GetSingleton <EntityPrefabs>(); Entities .WithName("Spawn_Balls") .ForEach((ref BallSpawner spawner, in LocalToWorld localToWorld) => { var r = spawner.Random.NextFloat2Direction(); var xz = float3(r.x, 0, r.y); var up = float3(0, 1, 0); spawner.TimeRemainder += spawner.SpawnsPerTick; while (spawner.TimeRemainder >= 1) { var ball = ecb.Instantiate(prefabs.Ball); ecb.SetComponent(ball, new Translation { Value = localToWorld.Position }); ecb.SetComponent(ball, new Rotation { Value = Quaternion.LookRotation(xz, up) }); spawner.TimeRemainder--; } }) .WithBurst() .Schedule(); BeginSimulationEntityCommandBufferSystem.AddJobHandleForProducer(Dependency); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { if (m_Prefab == Entity.Null) { var prefabs = GetSingleton <GhostPrefabCollectionComponent>(); var serverPrefabs = EntityManager.GetBuffer <GhostPrefabBuffer>(prefabs.serverPrefabs); m_Prefab = serverPrefabs[AsteroidsGhostSerializerCollection.FindGhostType <ShipSnapshotData>()].Value; m_Radius = EntityManager.GetComponentData <CollisionSphereComponent>(m_Prefab).radius; } JobHandle levelHandle; var spawnJob = new SpawnJob { commandBuffer = barrier.CreateCommandBuffer(), playerStateFromEntity = GetComponentDataFromEntity <PlayerStateComponentData>(), commandTargetFromEntity = GetComponentDataFromEntity <CommandTargetComponent>(), networkIdFromEntity = GetComponentDataFromEntity <NetworkIdComponent>(), shipPrefab = m_Prefab, shipRadius = m_Radius, level = m_LevelGroup.ToComponentDataArray <LevelComponent>(Allocator.TempJob, out levelHandle), rand = new Unity.Mathematics.Random((uint)Stopwatch.GetTimestamp()) }; var handle = spawnJob.ScheduleSingle(this, JobHandle.CombineDependencies(inputDeps, levelHandle)); barrier.AddJobHandleForProducer(handle); return(handle); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { EntityCommandBuffer.Concurrent CommandBuffer = m_EntityCommandBuffer.CreateCommandBuffer().ToConcurrent(); JobHandle handle = Entities .WithNone <TC_CooldownRunning>() .WithAll <TC_CooldownCompleted, TC_CreationCooldown>() .ForEach( (Entity entity, int entityInQueryIndex) => { CommandBuffer.RemoveComponent <TC_CreationCooldown>(entityInQueryIndex, entity); CommandBuffer.RemoveComponent <TC_CooldownCompleted>(entityInQueryIndex, entity); CommandBuffer.AddComponent <PlayMonoAnimation_C>(entityInQueryIndex, entity); CommandBuffer.SetComponent(entityInQueryIndex, entity, new PlayMonoAnimation_C { id = UnityEngine.Animator.StringToHash("Caixa@Open") }); }) .WithoutBurst() .Schedule(inputDeps); handle.Complete(); return(handle); }
protected override void OnUpdate() { var playerEntity = GetSingletonEntity <NetworkIdComponent>(); var commandTargetFromEntity = GetComponentDataFromEntity <CommandTargetComponent>(); var commandBuffer = m_Barrier.CreateCommandBuffer().AsParallelWriter(); Entities .WithNone <GhostShipState>() .WithAll <ShipTagComponentData, PredictedGhostComponent>() .ForEach((Entity entity) => { var state = commandTargetFromEntity[playerEntity]; state.targetEntity = entity; commandTargetFromEntity[playerEntity] = state; commandBuffer.AddComponent(0, entity, new GhostShipState()); }).Schedule(); Entities.WithNone <SnapshotData>() .WithAll <GhostShipState>() .WithNativeDisableParallelForRestriction(commandTargetFromEntity) .ForEach((Entity ent, int entityInQueryIndex) => { var commandTarget = commandTargetFromEntity[playerEntity]; if (ent == commandTarget.targetEntity) { commandTarget.targetEntity = Entity.Null; commandTargetFromEntity[playerEntity] = commandTarget; } commandBuffer.RemoveComponent <GhostShipState>(entityInQueryIndex, ent); }).ScheduleParallel(); m_Barrier.AddJobHandleForProducer(Dependency); }
protected override void OnUpdate() { var entityType = GetEntityTypeHandle(); var playerEntity = GetSingletonEntity <NetworkIdComponent>(); var commandTargetFromEntity = GetComponentDataFromEntity <CommandTargetComponent>(); var commandBuffer = m_Barrier.CreateCommandBuffer().AsParallelWriter(); Entities.WithNone <GhostShipState>().WithAll <ShipTagComponentData, PredictedGhostComponent>().ForEach((Entity entity) => { var state = commandTargetFromEntity[playerEntity]; state.targetEntity = entity; commandTargetFromEntity[playerEntity] = state; commandBuffer.AddComponent(0, entity, new GhostShipState()); }).Schedule(); var destroyJob = new DestroyJob { commandBuffer = commandBuffer, entityType = entityType, playerEntity = playerEntity, commandTargetFromEntity = GetComponentDataFromEntity <CommandTargetComponent>() }; var inputDeps = destroyJob.Schedule(m_DestroyGroup, Dependency); m_Barrier.AddJobHandleForProducer(inputDeps); Dependency = inputDeps; }
protected override JobHandle OnUpdate(JobHandle inputDeps) { // Deserialize the command type from the reader stream // Execute the RPC inputDeps = JobHandle.CombineDependencies(inputDeps, m_ReceiveSystem.LastDriverWriter); var execJob = new RpcExecJob { commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(), entityType = GetArchetypeChunkEntityType(), connectionType = GetArchetypeChunkComponentType <NetworkStreamConnection>(), inBufferType = GetArchetypeChunkBufferType <IncomingRpcDataStreamBufferComponent>(), outBufferType = GetArchetypeChunkBufferType <OutgoingRpcDataStreamBufferComponent>(), execute = m_RpcData, hashToIndex = m_RpcTypeHashToIndex, driver = m_ReceiveSystem.ConcurrentDriver, reliablePipeline = m_ReceiveSystem.ReliablePipeline, protocolVersion = GetSingleton <NetworkProtocolVersion>() }; var handle = execJob.Schedule(m_RpcBufferGroup, inputDeps); m_Barrier.AddJobHandleForProducer(handle); handle = m_ReceiveSystem.Driver.ScheduleFlushSend(handle); m_ReceiveSystem.LastDriverWriter = handle; return(handle); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { EntityCommandBuffer.Concurrent commandBuffer = m_EntityCommandBuffer.CreateCommandBuffer().ToConcurrent(); JobHandle jobConfigureDrop = Entities .WithAll <TC_PerformingAction>() .ForEach((Entity entity, int entityInQueryIndex, in Translation translation, in C_HoldComponentData holdComponent, in DirectionData directionData) => { int2 i2Direction = directionData.directionLook; float fXDropPosition = translation.Value.x + (float)i2Direction.x / 2; commandBuffer.AddComponent <MC_RemoveInHold>(entityInQueryIndex, holdComponent.Item); commandBuffer.SetComponent(entityInQueryIndex, holdComponent.Item, new MC_RemoveInHold { Position = new float3(fXDropPosition, translation.Value.y, 0) }); commandBuffer.RemoveComponent <TC_PerformingAction>(entityInQueryIndex, entity); commandBuffer.RemoveComponent <C_HoldComponentData>(entityInQueryIndex, entity); commandBuffer.AddComponent <TC_CooldownAction>(entityInQueryIndex, entity); commandBuffer.AddComponent <TC_CooldownRunning>(entityInQueryIndex, entity); commandBuffer.SetComponent(entityInQueryIndex, entity, new C_CooldownComponent { Cooldown = 1, DeltaTime = 0 }); }).Schedule(inputDeps);
protected override JobHandle OnUpdate(JobHandle inputDeps) { if (m_LevelGroup.IsEmptyIgnoreFilter) { var settings = GetSingleton <ServerSettings>(); var level = EntityManager.CreateEntity(); EntityManager.AddComponentData(level, new LevelComponent { width = settings.levelWidth, height = settings.levelHeight, playerForce = settings.playerForce, bulletVelocity = settings.bulletVelocity }); return(inputDeps); } JobHandle levelDep; var job = new RequestLoadJob { commandBuffer = m_Barrier.CreateCommandBuffer(), level = m_LevelGroup.ToComponentDataArray <LevelComponent>(Allocator.TempJob, out levelDep) }; var handle = job.ScheduleSingle(this, JobHandle.CombineDependencies(inputDeps, levelDep)); m_Barrier.AddJobHandleForProducer(handle); return(handle); }
protected override void OnUpdate() { var commandBuffer = m_Barrier.CreateCommandBuffer(); var serverData = GetSingleton <GameSettingsComponent>(); var gameNameData = GetSingleton <ServerDataComponent>(); Entities .WithNone <SentClientGameRpcTag>() .ForEach((Entity entity, in NetworkIdComponent netId) => { commandBuffer.AddComponent(entity, new SentClientGameRpcTag()); var req = commandBuffer.CreateEntity(); commandBuffer.AddComponent(req, new SendClientGameRpc { levelWidth = serverData.levelWidth, levelHeight = serverData.levelHeight, levelDepth = serverData.levelDepth, playerForce = serverData.playerForce, bulletVelocity = serverData.bulletVelocity, gameName = gameNameData.GameName }); commandBuffer.AddComponent(req, new SendRpcCommandRequestComponent { TargetConnection = entity }); }).Schedule(); m_Barrier.AddJobHandleForProducer(Dependency); }
protected override void OnUpdate() { var actualNumSpawners = q_spawners.CalculateEntityCount(); var ecb = _ecb.CreateCommandBuffer().AsParallelWriter(); Entities .ForEach((int entityInQueryIndex, in SpawnerEntityData spawnerEntity, in SpawnerNumberData spawnerNumber) => { var suppoedNumSpawners = spawnerNumber.Value; if (suppoedNumSpawners > actualNumSpawners) { //Get the difference first. var diffNumSpawner = suppoedNumSpawners - actualNumSpawners; for (int i = 0; i < diffNumSpawner; i++) { var spawner = ecb.Instantiate(entityInQueryIndex, spawnerEntity.spawner); #if UNITY_EDITOR //Debugging purposes. ecb.SetComponent(entityInQueryIndex, spawner, new PatternBlobIndexData { index = i }); ecb.SetComponent(entityInQueryIndex, spawner, new BulletBlobIndexData { index = i }); #endif } } }).ScheduleParallel();
protected override void OnUpdate() { uint interpolatedTick = _networkTimeSystem.interpolateTargetTick; uint predictedTick = _networkTimeSystem.predictTargetTick; var commandBuffer = _barrier.CreateCommandBuffer(); // 插值类型的Ghost销毁 while (_interpolatedDespawnQueue.Count > 0 && !SequenceHelpers.IsNewer(_interpolatedDespawnQueue.Peek().Tick, interpolatedTick)) { var desspawnGhost = _interpolatedDespawnQueue.Dequeue(); if (_ghostReceiveSystem.SpawnedGhostEntityMap.TryGetValue(desspawnGhost.Ghost, out Entity ent)) { commandBuffer.DestroyEntity(ent); _ghostReceiveSystem.SpawnedGhostEntityMap.Remove(desspawnGhost.Ghost); } } // 预测类型的Ghost销毁 while (_predictedDespawnQueue.Count > 0 && !SequenceHelpers.IsNewer(_predictedDespawnQueue.Peek().Tick, predictedTick)) { var desspawnGhost = _predictedDespawnQueue.Dequeue(); if (_ghostReceiveSystem.SpawnedGhostEntityMap.TryGetValue(desspawnGhost.Ghost, out Entity ent)) { commandBuffer.DestroyEntity(ent); _ghostReceiveSystem.SpawnedGhostEntityMap.Remove(desspawnGhost.Ghost); } } }
protected override void OnUpdate() { var spawnListEnt = GetSingletonEntity <PredictedGhostSpawnList>(); var spawnList = EntityManager.GetBuffer <PredictedGhostSpawn>(spawnListEnt); var commandBuffer = _barrier.CreateCommandBuffer(); Entities.ForEach((DynamicBuffer <GhostSpawnBuffer> ghosts, DynamicBuffer <SnapshotDataBuffer> data) => { for (int i = 0; i < ghosts.Length; i++) { var ghost = ghosts[i]; if (ghost.SpawnType == GhostSpawnBuffer.Type.Predicted) { for (int j = 0; j < spawnList.Length; j++) { if (ghost.GhostType == spawnList[j].GhostType) { ghost.PredictedSpawnEntity = spawnList[j].Entity; spawnList[j] = spawnList[spawnList.Length - 1]; spawnList.RemoveAt(spawnList.Length - 1); commandBuffer.RemoveComponent <PredictedGhostSpawnPendingComponent>( ghost.PredictedSpawnEntity); break; } } ghosts[i] = ghost; } } }); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var projectileTranslations = m_projectilesQuery.ToComponentDataArray <Translation>(Allocator.TempJob); var projectileCollisions = m_projectilesQuery.ToComponentDataArray <CollisionSize>(Allocator.TempJob); var projectiles = m_projectilesQuery.ToEntityArray(Allocator.TempJob); poolLocations.Clear(); EntityManager.GetAllUniqueSharedComponentData <ProjectilePoolLocation>(poolLocations); if (projectileCollisions.Length > 0 && poolLocations.Count > 1) { var job = new ProjectileCollisionJob { ProjectileTranslations = projectileTranslations, ProjectileCollisions = projectileCollisions, Projectiles = projectiles, ECB = m_beginSimEcbSystem.CreateCommandBuffer().ToConcurrent(), PoolLocation = poolLocations[1].Value }; inputDeps = job.Schedule(this, inputDeps); m_projectilesQuery.AddDependency(inputDeps); m_beginSimEcbSystem.AddJobHandleForProducer(inputDeps); } else { projectileTranslations.Dispose(); projectileCollisions.Dispose(); projectiles.Dispose(); } return(inputDeps); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { if (Time.time - oldTime > updateTime) { oldTime = Time.time; var nativeArr = new NativeList <PlayerState>(100, Allocator.TempJob); var playerStateJob = new CreatePlayerStateJob() { arr = nativeArr }.ScheduleSingle(this, inputDeps); playerStateJob.Complete(); var serializeJob = new SerializeStateJob() { CommandBuffer = m_EndFrameBarrier.CreateCommandBuffer(), players = nativeArr }.Schedule(playerStateJob); m_EndFrameBarrier.AddJobHandleForProducer(serializeJob); serializeJob.Complete(); nativeArr.Dispose(); return(serializeJob); } return(inputDeps); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var entityType = GetArchetypeChunkEntityType(); JobHandle playerHandle; var playerEntity = playerGroup.ToEntityArray(Allocator.TempJob, out playerHandle); var updateJob = new UpdateJob { snapshotFromEntity = GetBufferFromEntity <ShipSnapshotData>(), targetTick = NetworkTimeSystem.interpolateTargetTick }; inputDeps = updateJob.Schedule(this, inputDeps); var destroyJob = new DestroyJob { commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(), entityType = entityType, playerEntity = playerEntity, playerStateFromEntity = GetComponentDataFromEntity <PlayerStateComponentData>() }; inputDeps = destroyJob.Schedule(destroyGroup, JobHandle.CombineDependencies(inputDeps, playerHandle)); m_Barrier.AddJobHandleForProducer(inputDeps); return(inputDeps); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { inputDeps.Complete(); var barrier = m_Barrier.CreateCommandBuffer(); Entities .WithoutBurst() .WithAll <MeshAssignTag>() .ForEach((Entity entity, ref ChunkComponent cc, in RenderMesh rnd, in DynamicBuffer <IntBuffer> triangles, in DynamicBuffer <VectorBuffer> vertices) => { barrier.RemoveComponent <MeshAssignTag>(entity); var trianglesArray = new int[triangles.Length];; // triangles.Reinterpret<int>().ToArray(); var verticesArray = new Vector3[vertices.Length]; // vertices.Reinterpret<Vector3>().ToArray(); for (int i = 0; i < triangles.Length; i++) { trianglesArray[i] = triangles[i]; } for (int i = 0; i < vertices.Length; i++) { verticesArray[i] = vertices[i]; } rnd.mesh.Clear(); rnd.mesh.vertices = verticesArray; rnd.mesh.triangles = trianglesArray; rnd.mesh.normals = verticesArray.Select(x => new Vector3(0, 0, 1)).ToArray(); rnd.mesh.RecalculateBounds(); barrier.SetSharedComponent(entity, rnd); }).Run();
protected override void OnUpdate() { var commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(); var rpcFromEntity = GetBufferFromEntity <OutgoingRpcDataStreamBufferComponent>(); var levelFromEntity = GetComponentDataFromEntity <LevelComponent>(); var levelSingleton = m_LevelSingleton; var rpcQueue = m_RpcQueue; Entities.ForEach((Entity entity, int nativeThreadIndex, in LevelLoadRequest request, in ReceiveRpcCommandRequestComponent requestSource) => { commandBuffer.DestroyEntity(nativeThreadIndex, entity); // Check for disconnects if (!rpcFromEntity.Exists(requestSource.SourceConnection)) { return; } // set the level size - fake loading of level levelFromEntity[levelSingleton] = new LevelComponent { width = request.width, height = request.height, playerForce = request.playerForce, bulletVelocity = request.bulletVelocity }; commandBuffer.AddComponent(nativeThreadIndex, requestSource.SourceConnection, new PlayerStateComponentData()); commandBuffer.AddComponent(nativeThreadIndex, requestSource.SourceConnection, default(NetworkStreamInGame)); rpcQueue.Schedule(rpcFromEntity[requestSource.SourceConnection], new RpcLevelLoaded()); }).Schedule();
private void Start() { if (spawnAtEcs) { commandBufferSystem = World.DefaultGameObjectInjectionWorld .GetOrCreateSystem <BeginSimulationEntityCommandBufferSystem>(); var entityPrefab = GameObjectConversionUtility.ConvertGameObjectHierarchy(ecsPrefab, new GameObjectConversionSettings(World.DefaultGameObjectInjectionWorld, GameObjectConversionUtility.ConversionFlags.SceneViewLiveLink, new BlobAssetStore())); var jobHandle = new MyEcsSpawnJob() { CommandBuffer = commandBufferSystem.CreateCommandBuffer(), NumberOfCubes = numberOfCubes, EcsPrefab = entityPrefab, MyRandom = new Random((uint)UnityEngine.Random.Range(1, 100000)) }.Schedule(); commandBufferSystem.AddJobHandleForProducer(jobHandle); } else { for (var i = 0; i < numberOfCubes; i++) { Instantiate(monoPrefab).transform.position = new Vector3(UnityEngine.Random.Range(-100, 100f), 0, 0); } } }
private JobHandle ConsiderOwner(JobHandle prepareDistDataJobHandle, NativeArray <OwnerPosContainer> ownerPosContainers) { // ecb改成单线程 // create group // group to array var entities = m_placeGroup.ToEntityArray(Allocator.TempJob); var setPlaceOwnerConsiderers = m_placeGroup.ToComponentDataArray <SetPlaceOwnerConsiderer>(Allocator.TempJob); var places = m_placeGroup.ToComponentDataArray <Place>(Allocator.TempJob); var translations = m_placeGroup.ToComponentDataArray <Translation>(Allocator.TempJob); var ownerConsiderJobHandle = new OwnerConsiderJob { BeginEcb = m_beginEcbSystem.CreateCommandBuffer(), EndEcb = m_endEcbSystem.CreateCommandBuffer(), Entities = entities, SetPlaceOwnerConsiderers = setPlaceOwnerConsiderers, Places = places, Translations = translations, OwnPlacesBuffer = GetBufferFromEntity <MyOwnPlace>(), OwnersPos = ownerPosContainers, }.Schedule(prepareDistDataJobHandle); // TEST 是否可以直接dispose? // 看看parentSystem是怎么dispose的。 // 是在manager操作后dispose的,确保一定完成。 // 试试不用mananger行不行。 // 结果:失败, // 换成自动模式。 // entities.Dispose(); // setPlaceOwnerConsiderers.Dispose(); // places.Dispose(); // translations.Dispose(); return(ownerConsiderJobHandle); }
protected override JobHandle OnUpdate(JobHandle handle) { if (init && count > 0) { em.DestroyEntity(boubleQuery); count = 0; return(handle); } count = boubleQuery.CalculateEntityCount(); var f = GetSingleton <SpawnerRndAreaComp>(); if (sd.rangeMultChanged) { List <float> ranges = new List <float>(); ranges.Add(sd.defaultGrav); for (int i = 1; i < 6; i++) { ranges.Add(ranges[i - 1] * sd.rangeMult); } f.smallRange = ranges[1]; f.mediumRange = ranges[2]; f.largeRange = ranges[3]; f.hugeRange = ranges[4]; f.superRange = ranges[5]; ranges.Clear(); sd.rangeMultChanged = false; SetSingleton <SpawnerRndAreaComp>(f); } createCount = sd.totalCount - count; for (int i = 0; i < createCount; i++) { rndDir = _random.NextFloat2Direction(); rndPos.x = rndDir.x; rndPos.y = 0; rndPos.z = rndDir.y; rndPos *= init ? _random.NextFloat(0, sd.cylinderRadius) : sd.cylinderRadius; rndPos.y = _random.NextFloat(-sd.cylinderHeight, sd.cylinderHeight); posList[i] = rndPos; } handle = new Joby { ecb = _ecbs.CreateCommandBuffer().ToConcurrent(), f = f, sd = sd, prefabEntity = _prefabEntity, absorb = sd.absorb, bounce = sd.bounce, posList = posList, bubFrac = .5f / BoubleAuth._grad }.Schedule(createCount, 10, handle); _ecbs.AddJobHandleForProducer(handle); init = false; return(handle); }