public void Execute(Entity entity, int index, ref TerrainSpawner ts) { if (ts.TerrainBuilt == 0) { ts.TerrainBuilt = 1; Entity groundEntity = CommandBuffer.Instantiate(index, prefabs.prefabEntityGround); CommandBuffer.SetComponent(index, groundEntity, new Translation { Value = new float3(0, 0, 0) }); CommandBuffer.AddComponent(index, groundEntity, new NonUniformScale { Value = new float3(bounds.Bounds.c1.x - bounds.Bounds.c0.x, 1, bounds.Bounds.c1.y - bounds.Bounds.c0.y) }); CommandBuffer.AddComponent(index, groundEntity, new TerrainTag { }); for (int count = 0; count < ts.NumOfTrees; count++) { createTree(index, prefabs.prefabEntityTree, prefabs.prefabColliderTree, bounds.Bounds); } for (int count = 0; count < ts.NumOfBubbles; count++) { createBubble(index, prefabs.prefabEntityBubble, bounds.Bounds); } } else { CommandBuffer.RemoveComponent <TerrainSpawner>(index, entity); } }
public StateData Copy(int jobIndex, EntityCommandBuffer.Concurrent entityCommandBuffer) { var stateEntity = entityCommandBuffer.Instantiate(jobIndex, StateEntity); var traitBasedObjects = entityCommandBuffer.SetBuffer <TraitBasedObject>(jobIndex, stateEntity); traitBasedObjects.CopyFrom(TraitBasedObjects.AsNativeArray()); var traitBasedObjectIds = entityCommandBuffer.SetBuffer <TraitBasedObjectId>(jobIndex, stateEntity); traitBasedObjectIds.CopyFrom(TraitBasedObjectIds.AsNativeArray()); var Agents = entityCommandBuffer.SetBuffer <Agent>(jobIndex, stateEntity); Agents.CopyFrom(AgentBuffer.AsNativeArray()); var Locations = entityCommandBuffer.SetBuffer <Location>(jobIndex, stateEntity); Locations.CopyFrom(LocationBuffer.AsNativeArray()); var Targets = entityCommandBuffer.SetBuffer <Target>(jobIndex, stateEntity); Targets.CopyFrom(TargetBuffer.AsNativeArray()); var Collectibles = entityCommandBuffer.SetBuffer <Collectible>(jobIndex, stateEntity); Collectibles.CopyFrom(CollectibleBuffer.AsNativeArray()); return(new StateData { StateEntity = stateEntity, TraitBasedObjects = traitBasedObjects, TraitBasedObjectIds = traitBasedObjectIds, AgentBuffer = Agents, LocationBuffer = Locations, TargetBuffer = Targets, CollectibleBuffer = Collectibles, }); }
public void Execute(Entity entity, int index, ref AutoBulletShooter shooter, [ReadOnly] ref LocalToWorld ltw, [ReadOnly] ref Rotation rot) { shooter.shotTimer -= dt; if (shooter.shotTimer <= 0) { float late = shooter.shotTimer * -1f; shooter.shotTimer = shooter.cooldown; var e = commandBuffer.Instantiate(index, bulletPrefab); var fwd = ltw.Forward; var pos = ltw.Position; var spawnPos = pos + fwd * late; commandBuffer.SetComponent(index, e, new Translation { Value = spawnPos }); commandBuffer.SetComponent(index, e, rot); commandBuffer.SetComponent(index, e, ltw); commandBuffer.SetComponent(index, e, new Bullet { spawnedFrom = entity }); //commandBuffer.SetComponent(index, e, ltw); } }
protected override void OnUpdate() { EntityCommandBuffer.Concurrent ecb = endInitializationECBSystem.CreateCommandBuffer().ToConcurrent(); float deltaTime = UnityEngine.Time.deltaTime; Entities.ForEach((Entity entity, int entityInQueryIndex, ref SpawnerEntitiesCubes spawner, ref LocalToWorld localToWorld) => { spawner.secondsToNextSpawn -= deltaTime; if (spawner.secondsToNextSpawn >= 0) { return; } //exit, no time to spawn yet //queue an instantiate command to the EntityCommandBuffer Entity prefabToSpawn = (spawner.randomness.NextFloat() > 0.5f) ? spawner.redCubePrefab : spawner.blueCubePrefab; Entity instantiatedPrefab = ecb.Instantiate(entityInQueryIndex, prefabToSpawn); //queue a SetComponent command to position the newly created entity at the back of the scene float3 RandomOffset = spawner.randomness.NextFloat3Direction() * spawner.randomness.NextFloat() * spawner.spawnRadius; //random.NextFloat3Direction() gives a random unit-long vector3, and random.NextFloat() returns random float between 0 and 1 ecb.SetComponent(entityInQueryIndex, instantiatedPrefab, new Translation { Value = new float3(localToWorld.Position.x + RandomOffset.x, -9, localToWorld.Position.z + RandomOffset.z) }); //update the time to the next entity spawn spawner.secondsToNextSpawn += spawner.spawnFrequency; }).Schedule(); }
public static Entity Instantiate(EntityCommandBuffer.Concurrent ecb, int jobIndex, float3 target, Entity prefab, Entity prefabTrail, float3 pos, float3 vel, float time) { var entity = ecb.Instantiate(jobIndex, prefab); ecb.SetComponent(jobIndex, entity, new Translation { Value = pos, }); var rot = quaternion.LookRotationSafe(vel, new float3(0, 1, 0)); ecb.SetComponent(jobIndex, entity, new Rotation { Value = rot, }); ecb.SetComponent(jobIndex, entity, new MissileComponent { Target = target, Velocity = vel, }); ecb.SetComponent(jobIndex, entity, AlivePeriod.Create(time, 2f /* period */)); TrailSystem.Instantiate(ecb, jobIndex, prefabTrail, entity /* refering_entity */, pos, 0.5f /* width */, new Color(0.8f, 0.8f, 0.8f), time); return(entity); }
protected override void OnUpdate() { //线程安全的IBufferElementData,World管理的单例锁,Allocator.TempJob 4帧后回收 EntityCommandBuffer.Concurrent cmdBuffer = m_syncPointCEManager.CreateCommandBuffer().ToConcurrent(); //sync point job/Task.Run() Entities.WithName("SpawnData") //找到自己GOToEntity,特殊编译设置 .WithBurst(FloatMode.Default, FloatPrecision.Standard, true) //sync compile: compile before Update .ForEach((Entity entity, int entityInQueryIndex, in SpawnData spawnData, in LocalToWorld location) => { //entityQueryIndex as CommandEntityIndex for (var x = 0; x < spawnData.SpawnSize.x; x++) { for (var z = 0; z < spawnData.SpawnSize.z; z++) { Entity instance = cmdBuffer.Instantiate(entityInQueryIndex, spawnData.PrefabRoot); //center transform(parent.transform), offset float3 pos = math.transform(location.Value, new float3(x, 0, z)); //原生Component,new赋值 cmdBuffer.SetComponent(entityInQueryIndex, instance, new Translation { Value = pos }); //增加Component,也是new赋值 cmdBuffer.AddComponent(entityInQueryIndex, instance, new PlanetRotateBehavior { AngularVelocity = 2 }); cmdBuffer.AddComponent(entityInQueryIndex, instance, new LifetimeData { TimeSpan = spawnData.TimeSpan }); } } //this CommandEntityIndex cmdBuffer.DestroyEntity(entityInQueryIndex, entity); }).ScheduleParallel();
public void CreateBurstLine(Entity bullet, int index, float angle, float3 position, float speed, int bulletsInLine) { for (int i = 0; i < bulletsInLine; ++i) { float speedScale = .5f + (.5f / bulletsInLine * i); Entity entity = commandBuffer.Instantiate(index, bullet); commandBuffer.SetComponent(index, entity, new Translation { Value = position }); commandBuffer.SetComponent(index, entity, new Rotation { Value = quaternion.AxisAngle( new float3(0, 0, 1), angle) }); commandBuffer.SetComponent(index, entity, new BulletMovement { moveType = BulletMovementSystem.MoveType.LINEAR, moveSpeed = speed * speedScale, rotateSpeed = 0 }); } }
public void Execute(Entity entity, int index, [ReadOnly] ref Spawner_SpawnAndRemove spawner, [ReadOnly] ref LocalToWorld location) { var random = new Random(1); for (var x = 0; x < spawner.CountX; x++) { for (var y = 0; y < spawner.CountY; y++) { var instance = CommandBuffer.Instantiate(index, spawner.Prefab); // Place the instantiated in a grid with some noise var position = math.transform(location.Value, new float3(x * 1.3F, noise.cnoise(new float2(x, y) * 0.21F) * 2, y * 1.3F)); CommandBuffer.SetComponent(index, instance, new Translation { Value = position }); CommandBuffer.SetComponent(index, instance, new LifeTime { Value = random.NextFloat(10.0F, 100.0F) }); CommandBuffer.SetComponent(index, instance, new RotationSpeed_SpawnAndRemove { RadiansPerSecond = math.radians(random.NextFloat(25.0F, 90.0F)) }); } } CommandBuffer.DestroyEntity(index, entity); }
public void Execute(Entity entity, int index, ref RangeWeapon weapon, [ReadOnly] ref AttackInputs attackInputs) { if (attackInputs.AttackHeld) { if (Time >= weapon.LastTimeShot + (1f / weapon.FiringRate)) { LocalToWorld localToWorld = LocalToWorldFromEntity[weapon.ShootPointEntity]; // store gun forward direction quaternion dir = quaternion.LookRotationSafe(localToWorld.Forward, localToWorld.Up); // convert angle to radians float spreadAngle = math.radians(30); // change angle over time spreadAngle = spreadAngle / 2 + math.abs(math.sin(Time * 2)) * spreadAngle / 2; // store angle slice per bullet quaternion diffraction = quaternion.EulerXYZ(0, spreadAngle / (math.ceil(weapon.BulletAmountPerShot) + 1), 0); // prepare offset 50% spreadAngle dir = math.mul(dir, quaternion.EulerXYZ(0, -spreadAngle / 2, 0)); for (int i = 0; i < math.ceil(weapon.BulletAmountPerShot); i++) { dir = math.mul(dir, diffraction); Entity spawnedProjectile = entityCommandBuffer.Instantiate(index, weapon.ProjectileEntity); entityCommandBuffer.SetComponent(index, spawnedProjectile, new Translation { Value = localToWorld.Position }); entityCommandBuffer.SetComponent(index, spawnedProjectile, new Rotation { Value = dir }); } weapon.LastTimeShot = Time; } } }
public void Execute(Entity entity, int index, [ReadOnly] ref Spawner spawnerFromEntity, [ReadOnly] ref LocalToWorld location) { var parent = spawnerFromEntity.Parent; var horizontalInterval = spawnerFromEntity.HorizontalInterval; var verticalInterval = spawnerFromEntity.VerticalInterval; var depthInterval = spawnerFromEntity.DepthInterval; var origin = parent != Entity.Null ? LocalToWorldFromEntity[parent].Value : location.Value; for (var x = 0; x < spawnerFromEntity.CountX; x++) { for (var y = 0; y < spawnerFromEntity.CountY; y++) { for (var z = 0; z < spawnerFromEntity.CountZ; z++) { // Place the instantiated in a grid var instance = CommandBuffer.Instantiate(index, spawnerFromEntity.Prefab); var position = math.transform( origin, new float3((x - spawnerFromEntity.CountX * 0.5f) * horizontalInterval, (y - spawnerFromEntity.CountY * 0.5f) * verticalInterval, (z - spawnerFromEntity.CountZ * 0.5f) * depthInterval)); CommandBuffer.SetComponent(index, instance, new Translation { Value = position }); if (parent != Entity.Null) { CommandBuffer.SetParent(index, parent, instance); } } } } CommandBuffer.DestroyEntity(index, entity); }
public StateData Copy(int jobIndex, EntityCommandBuffer.Concurrent entityCommandBuffer) { var stateEntity = entityCommandBuffer.Instantiate(jobIndex, StateEntity); var traitBasedObjects = entityCommandBuffer.SetBuffer <TraitBasedObject>(jobIndex, stateEntity); traitBasedObjects.CopyFrom(TraitBasedObjects.AsNativeArray()); var traitBasedObjectIds = entityCommandBuffer.SetBuffer <TraitBasedObjectId>(jobIndex, stateEntity); traitBasedObjectIds.CopyFrom(TraitBasedObjectIds.AsNativeArray()); var Locations = entityCommandBuffer.SetBuffer <Location>(jobIndex, stateEntity); Locations.CopyFrom(LocationBuffer.AsNativeArray()); var Robots = entityCommandBuffer.SetBuffer <Robot>(jobIndex, stateEntity); Robots.CopyFrom(RobotBuffer.AsNativeArray()); var Dirts = entityCommandBuffer.SetBuffer <Dirt>(jobIndex, stateEntity); Dirts.CopyFrom(DirtBuffer.AsNativeArray()); var Moveables = entityCommandBuffer.SetBuffer <Moveable>(jobIndex, stateEntity); Moveables.CopyFrom(MoveableBuffer.AsNativeArray()); return(new StateData { StateEntity = stateEntity, TraitBasedObjects = traitBasedObjects, TraitBasedObjectIds = traitBasedObjectIds, LocationBuffer = Locations, RobotBuffer = Robots, DirtBuffer = Dirts, MoveableBuffer = Moveables, }); }
public void Execute(int index) { Buffer.Instantiate(index, MasterCopy); Buffer.AddComponent(index, new EcsTestData { value = index }); }
public void Execute(Entity pEntity, int pIndex, ref SpawnData pSpawner, [ReadOnly] ref LocalToWorld pLocalWorld) { pSpawner.timeCounter -= m_deltaTime; if (pSpawner.timeCounter > 0f) { return; } pSpawner.timeCounter = pSpawner.frequency; Entity _instance = m_buffer.Instantiate(pIndex, pSpawner.prefab); m_buffer.SetComponent(pIndex, _instance, new Translation { Value = pLocalWorld.Position + new float3(m_random.NextFloat() * pSpawner.distance, 0f, 0f) }); m_buffer.SetComponent(pIndex, _instance, new NonUniformScale { Value = new float3(m_random.NextFloat(MIN_SCALE, MAX_SCALE), m_random.NextFloat(MIN_SCALE, MAX_SCALE), m_random.NextFloat(MIN_SCALE, MAX_SCALE)) }); m_buffer.AddComponent(pIndex, _instance, new Movement { bouncing = m_random.NextInt(0, 3), speed = m_random.NextFloat(MIN_SPEED, MAX_SPEED), jumpForce = m_random.NextFloat(MIN_FORCE, MAX_FORCE) }); }
public void Execute(Entity entity, int index, [ReadOnly] ref PlayerSpawner spawner, [ReadOnly] ref LocalToWorld location) { var position = location.Position; var aabb = new AABB { //0.5f will represent halfwidth for now max = position + 0.5f, min = position - 0.5f, }; Entity instance = CommandBuffer.Instantiate(index, spawner.entity); CommandBuffer.AddComponent(index, instance, new PlayerData { moveSpeed = 5f, respawnPosition = new float3(0, 0, 0) }); CommandBuffer.AddComponent(index, instance, new PlayerInput { }); CommandBuffer.SetComponent(index, instance, new Translation { Value = new float3(0, 5f, 0) }); CommandBuffer.DestroyEntity(index, entity); //摧毁生成器,可以有多种其他的实现方式,前期开发简单摧毁即可 CommandBuffer.AddComponent(index, instance, aabb); }
public void Execute(Entity e, int jobIndex, [ReadOnly] ref ZombieSpawnerComponent zombieSpawner) { int2 minPos = new int2(-100, 175); int2 maxPos = new int2(100, 230); SpawnCount += 80; if (SpawnCount > 1000) { CommandBuffer.RemoveComponent <ZombieSpawnerComponent>(jobIndex, e); } var prefab = zombieSpawner.prefab; uint count = 0; while (count++ < 80) { var instance = CommandBuffer.Instantiate(jobIndex, prefab); var space = Rand.NextInt2(minPos, maxPos); space.x += Rand.NextInt(-2, 2); space.y += Rand.NextInt(-2, 2); var position = new float3(space.x, 1, space.y); CommandBuffer.SetComponent(jobIndex, instance, new Translation { Value = position }); CommandBuffer.SetComponent(jobIndex, instance, new MovementComponent { speed = 10 + Rand.NextFloat(-4f, 0f), direction = new float3(0, 0, -1), defaultDirection = new float3(0, 0, -1) }); } CommandBuffer.AddComponent(jobIndex, e, new CooldownComponent { waitTime = 5f }); }
public StateData Copy(int jobIndex, EntityCommandBuffer.Concurrent entityCommandBuffer) { var stateEntity = entityCommandBuffer.Instantiate(jobIndex, StateEntity); var traitBasedObjects = entityCommandBuffer.SetBuffer <TraitBasedObject>(jobIndex, stateEntity); traitBasedObjects.CopyFrom(TraitBasedObjects.AsNativeArray()); var traitBasedObjectIds = entityCommandBuffer.SetBuffer <TraitBasedObjectId>(jobIndex, stateEntity); traitBasedObjectIds.CopyFrom(TraitBasedObjectIds.AsNativeArray()); var Games = entityCommandBuffer.SetBuffer <Game>(jobIndex, stateEntity); Games.CopyFrom(GameBuffer.AsNativeArray()); var Coordinates = entityCommandBuffer.SetBuffer <Coordinate>(jobIndex, stateEntity); Coordinates.CopyFrom(CoordinateBuffer.AsNativeArray()); var Cells = entityCommandBuffer.SetBuffer <Cell>(jobIndex, stateEntity); Cells.CopyFrom(CellBuffer.AsNativeArray()); var Blockers = entityCommandBuffer.SetBuffer <Blocker>(jobIndex, stateEntity); Blockers.CopyFrom(BlockerBuffer.AsNativeArray()); return(new StateData { StateEntity = stateEntity, TraitBasedObjects = traitBasedObjects, TraitBasedObjectIds = traitBasedObjectIds, GameBuffer = Games, CoordinateBuffer = Coordinates, CellBuffer = Cells, BlockerBuffer = Blockers, }); }
protected override void OnUpdate() { EntityCommandBuffer.Concurrent ECB = ECBSystem.CreateCommandBuffer().ToConcurrent(); float deltaTime = Time.DeltaTime; Entities .ForEach((int entityInQueryIndex, ref FireCooldown fireCooldown, in TurretInput input, in FireInterval fireInterval, in FireSpeed fireSpeed, in LocalToWorld localToWorld, in ProjectilePrefab projectilePrefab, in ProjectileSpawnPoint spawnPointData) => { //decrease the cooldown if (fireCooldown.Value > 0f) { fireCooldown.Value -= deltaTime; } if (input.Fire && fireCooldown.Value <= 0f) { //fire! Entity newProjectile = ECB.Instantiate(entityInQueryIndex, projectilePrefab.Reference); //override a few components to position, rotate and push the newly created bullet ECB.SetComponent <Translation>(entityInQueryIndex, newProjectile, new Translation { Value = math.transform(localToWorld.Value, spawnPointData.LocalTranslation) }); quaternion worldRotation = math.mul(localToWorld.Rotation, spawnPointData.LocalRotation); ECB.SetComponent <Rotation>(entityInQueryIndex, newProjectile, new Rotation { Value = worldRotation }); ECB.SetComponent <PhysicsVelocity>(entityInQueryIndex, newProjectile, new PhysicsVelocity { Linear = fireSpeed.Value * math.forward(worldRotation) }); fireCooldown.Value = fireInterval.Value; } }).ScheduleParallel();
// ------------------------------------------------------------------------ public void Execute( Entity entity, int index, [ReadOnly] ref EntitySpawnerData spawnerData, [ReadOnly] ref LocalToWorld location) { int2 min = spawnerData.m_minBounds; int2 max = spawnerData.m_maxBounds; for (int x = min.x; x <= max.x; ++x) { for (int z = min.y; z <= max.y; ++z) { // instantiate var instance = m_commandBuffer.Instantiate(index, spawnerData.m_prefab); // position float3 position = new float3(x, 0.0f, z); // set translation component m_commandBuffer.SetComponent(index, instance, new Translation { Value = position } ); } } // destroy spawner m_commandBuffer.DestroyEntity(index, entity); }
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex) { var Velocities = chunk.GetNativeArray(VelocityType); var Translations = chunk.GetNativeArray(TranslationType); var Targets = chunk.GetNativeArray(TargetType); var Entities = chunk.GetNativeArray(EntityType); for (int i = 0; i < chunk.Count; ++i) { var Target = Targets[i]; if (DyingType.Exists(Target.Value))//This code reads: "If Target is dead, stop following it" { ecb.RemoveComponent(chunkIndex, Entities[i], typeof(C_Target)); continue; } var translation = Translations[i]; var velocity = Velocities[i]; float3 targetPos = TranslationData[Target.Value].Value; float3 delta = targetPos - translation.Value; float distanceSquared = delta.x * delta.x + delta.y * delta.y + delta.z * delta.z; if (distanceSquared < HitDistance * HitDistance) { C_DeathTimer timer = new C_DeathTimer() { TimeRemaining = BeeTimeToDeath }; Tag_IsDying tag; ecb.AddComponent(chunkIndex, Target.Value, tag); ecb.SetComponent(chunkIndex, Target.Value, timer); ecb.RemoveComponent(chunkIndex, Entities[i], typeof(C_Target)); //Spawn particles; var bloodVel = new C_Velocity() { Value = velocity.Value * .35f }; for (int particle = 0; particle < 6; ++particle) { var blood = ecb.Instantiate(chunkIndex, BloodPrefab); ecb.SetComponent(chunkIndex, blood, translation); ecb.SetComponent(chunkIndex, blood, bloodVel); } continue; } float force = max(1.0, distanceSquared) < AttackDistance * AttackDistance ? AttackForce : ChaseForce; velocity.Value += delta * (force * dt / sqrt(distanceSquared)); Velocities[i] = velocity; } }
public void Execute(Entity ent, int index, [ReadOnly] ref Translation translation, ref Enemy enemy) { enemy.timer -= deltaTime; var input = new PointDistanceInput() { MaxDistance = enemy.rangeDie, Filter = new CollisionFilter() { CategoryBits = mask, MaskBits = mask, GroupIndex = 0 }, Position = translation.Value }; DistanceHit hit; if (world.CalculateDistance(input, out hit)) { cmd.DestroyEntity(index, ent); cmd.DestroyEntity(index, world.Bodies[hit.RigidBodyIndex].Entity); var e = cmd.Instantiate(index, explosionPrefab); cmd.SetComponent(index, e, new Translation() { Value = hit.Position }); } else if (enemy.timer < 0) { input.MaxDistance = enemy.rangeShoot; if (world.CalculateDistance(input, out hit)) { var dir = hit.Position - translation.Value; dir *= enemy.rangeShoot / math.length(dir) * 0.5f; cmd.DestroyEntity(index, world.Bodies[hit.RigidBodyIndex].Entity); var e = cmd.Instantiate(index, lazerPrefab); cmd.SetComponent(index, e, new Translation() { Value = translation.Value + dir }); cmd.SetComponent(index, e, new Rotation() { Value = quaternion.RotateZ(math.atan2(dir.y, dir.x)) }); enemy.timer = enemy.cooldown; } } }
private static void SpawnEntity(ref EntityCommandBuffer.Concurrent commandBuffer, ref AroundCenterCyclicSpawner spawner, ref Random randomGenerator, int entityInQueryIndex) { var spawnedEntity = commandBuffer.Instantiate(entityInQueryIndex, spawner.EntityToSpawn); ApplyRandomPositionOnCircle(ref commandBuffer, ref spawner, ref randomGenerator, entityInQueryIndex, spawnedEntity); ApplyRandomColor(ref commandBuffer, ref randomGenerator, entityInQueryIndex, spawnedEntity); }
// ---------------------------------------------------- #region // Barrage Methods // 自機に狙い撃ち void Aiming(ref int jobIndex, ref Position2D enemyPosition, ref EnemyParam param, ref EnemyData data) { CommandBuffer.Instantiate(jobIndex, this.EnemyBulletPrefab); CommandBuffer.SetComponent(jobIndex, enemyPosition); CommandBuffer.SetComponent(jobIndex, new BulletData { Speed = param.BulletParam.Speed, Angle = MathHelper.Aiming(enemyPosition.Value, this.PlayerPosition), Lifespan = param.BulletParam.Lifespan, }); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { EntityCommandBuffer.Concurrent ecb = m_ecbSystem.CreateCommandBuffer().ToConcurrent(); NativeArray <Entity> paddles = m_paddleQuery.ToEntityArray(Allocator.TempJob); NativeArray <BallPrefab> ballPrefabs = m_ballPrefabQuery.ToComponentDataArray <BallPrefab>(Allocator.TempJob); float dt = Time.DeltaTime; JobHandle jobHandle = Entities .WithDeallocateOnJobCompletion(paddles) .WithDeallocateOnJobCompletion(ballPrefabs) .ForEach((Entity entity, int entityInQueryIndex, ref BallSpawnRequest spawnData) => { spawnData.m_delay -= dt; if (spawnData.m_delay <= 0.0f) { Entity ballEntity = ecb.Instantiate(entityInQueryIndex, ballPrefabs[0].m_prefab); if (spawnData.m_attachToPaddle) { ecb.AddComponent(entityInQueryIndex, ballEntity, new Parent { Value = paddles[0] }); ecb.AddComponent(entityInQueryIndex, ballEntity, new LocalToParent { }); ecb.AddComponent(entityInQueryIndex, ballEntity, new BlockMovement { }); ecb.SetComponent(entityInQueryIndex, ballEntity, new Translation() { Value = new float3(0.0f, 32.0f, 0.0f) }); } else { ecb.SetComponent(entityInQueryIndex, ballEntity, new Translation() { Value = new float3(spawnData.m_position.x, spawnData.m_position.y, 0.0f) }); } ecb.SetComponent(entityInQueryIndex, ballEntity, new Direction() { m_direction = spawnData.m_direction }); ecb.SetComponent(entityInQueryIndex, ballEntity, new Speed() { m_speed = spawnData.m_speed }); ecb.DestroyEntity(entityInQueryIndex, entity); } }) .Schedule(inputDeps); m_ecbSystem.AddJobHandleForProducer(jobHandle); return(jobHandle); }
public void Execute(Entity entity, int index, ref UnitSpawner spawner) { Entity spawnedEntity = commandBuffer.Instantiate(index, spawner.prefab); commandBuffer.SetComponent(index, spawnedEntity, new Translation { Value = spawner.spawnPoint }); // what does the line below do????? commandBuffer.DestroyEntity(index, entity); }
public static void SpawnCell(int entityInQueryIndex, Entity entity, EntityCommandBuffer.Concurrent commandBuffer, float3 positon, float3 scale) { Entity cellEntity = commandBuffer.Instantiate(entityInQueryIndex, entity); commandBuffer.SetComponent(entityInQueryIndex, cellEntity, new Translation() { Value = positon }); commandBuffer.SetComponent(entityInQueryIndex, cellEntity, new CellComponent(positon, scale)); }
public void Execute(int index) { if (!waves[index].spawned && waves[index].spawnTime < time) { commandBuffer.Instantiate(index, waves[index].wave); waves[index] = new WaveData { spawned = true }; } }
private Entity InstansiateEntity(int index, ref SpawnerData spawnerData, ref LocalToWorld localToWorld) { spawnerData.secondsToNextSpawn = spawnerData.secondsBetweenSpawns; Entity instance = entityCommandBuffer.Instantiate(index, spawnerData.prefab); entityCommandBuffer.SetComponent(index, instance, new Translation { Value = localToWorld.Position }); return(instance); }
public void Execute(Entity entity, int index, ref Spawner spawner, [ReadOnly] ref LocalToWorld localToWorld) { Entity instance = entityCommandBuffer.Instantiate(index, spawner.prefab); entityCommandBuffer.SetComponent(index, instance, new Translation { Value = new unityMath.float3( random.NextFloat(-spawner.randomRange, spawner.randomRange), 1, random.NextFloat(-spawner.randomRange, spawner.randomRange)) }); }
public void Execute(Entity entity, int index, ref Spawner spawner, [ReadOnly] ref LocalToWorld localToWorld) { spawner.nextSpawnTime -= deltaTime; if (spawner.nextSpawnTime <= 0) { spawner.nextSpawnTime += spawner.spawnDelay; Entity instance = entityCommandBuffer.Instantiate(index, spawner.prefab); entityCommandBuffer.SetComponent(index, instance, new Translation { Value = localToWorld.Position + random.NextFloat3Direction() * random.NextFloat() * spawner.maxDistanceFromSpawner }); } }
//Spawn prefabs then move their Transforms to Random position in the world public void Execute(Entity entity, int index, ref Spawner spawner, [ReadOnly] ref LocalToWorld local_to_world) { spawner.seconds_to_next_spawn -= delta_time; if (spawner.seconds_to_next_spawn >= 0) { return; } spawner.seconds_to_next_spawn += spawner.seconds_betweens_spawns; Entity instance = entity_command_buffer.Instantiate(index, spawner.prefab); entity_command_buffer.SetComponent(index, instance, new Translation { Value = local_to_world.Position + random.NextFloat3Direction() * random.NextFloat() * spawner.max_distance_from_spawner }); }