protected override JobHandle OnUpdate(JobHandle inputDeps) { EntityCommandBuffer.Concurrent commandBuffer = m_EntityCommandBuffer.CreateCommandBuffer().ToConcurrent(); JobHandle savePos = Entities.ForEach((Entity entity, int entityInQueryIndex, in Translation translation, in C_HoldComponentData holdData, in DirectionData directionData) => { commandBuffer.SetComponent(entityInQueryIndex, holdData.Item, new C_SetPositionComponentData { Position = translation.Value, }); }).Schedule(inputDeps);
public static void PlayAnimForcedJobs(Entity entity, int index, EntityCommandBuffer.Concurrent entityCommandBuffer, ECS_UnitAnimType.TypeEnum ecsUnitAnimTypeEnum, UnitAnim.AnimDir animDir, Skeleton_Anim_OnComplete onComplete) { Skeleton_Data skeletonData = GetSkeletonData(ecsUnitAnimTypeEnum, animDir, onComplete); entityCommandBuffer.SetComponent(index, entity, skeletonData); if (skeletonData.frameRate <= 0) { Debug.LogError("#################### FRAMERATE ZERO!"); } }
public static Entity Instantiate(EntityCommandBuffer.Concurrent ecb, int jobIndex, float3 pos) { var entity = ecb.Instantiate(jobIndex, _prefabEntity); ecb.SetComponent(jobIndex, entity, new AlivePeriod { StartTime = (float)Time.GetCurrent(), Period = 1f, }); var rot = quaternion.identity; var mat = new float4x4(rot, pos); mat.c0.w = Time.GetCurrent(); var rotZ = _random.NextFloat() * math.PI * 2f; mat.c1.w = rotZ; ecb.SetComponent(jobIndex, entity, new ExplosionComponent { Matrix = mat, }); return(entity); }
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex) { var chunkProjectileEntityReference = chunk.GetNativeArray(ProjectileEntityReference); var chunkShootTrigger = chunk.GetNativeArray(ShootTrigger); var chunkLocalToWorld = chunk.GetNativeArray(LocalToWorld); for (var i = 0; i < chunk.Count; i++) { if (!chunkShootTrigger[i].Value) { continue; } Entity projectile = InstantiateEntityAtLocalToWorld(chunkIndex, chunkProjectileEntityReference[i], chunkLocalToWorld[i]); EntityCommandBuffer.SetComponent(chunkIndex, projectile, new MovementDirection() { Value = chunkLocalToWorld[i].Forward }); } }
public void Execute(Entity entity, int index, [ReadOnly] ref Translation translation, [ReadOnly] ref GridPosition gridPosition, ref T1 originComponent, [ReadOnly] ref T2 counterComponent) { originComponent.Value = originComponent.Value + counterComponent.Value * multiplier; bool shouldMorph = originComponent.Value <= 0; if (shouldMorph) { CommandBuffer.DestroyEntity(index, entity); Entity targetPrefab = spawner.GetEntityForType(targetEntityType); Entity newEntity = CommandBuffer.Instantiate(index, targetPrefab); CommandBuffer.SetComponent(index, newEntity, new Translation { Value = translation.Value }); CommandBuffer.SetComponent(index, newEntity, new GridPosition { Value = gridPosition.Value }); } }
private static void ApplyRandomPositionOnCircle(ref EntityCommandBuffer.Concurrent commandBuffer, ref AroundCenterCyclicSpawner spawner, ref Random randomGenerator, int entityInQueryIndex, Entity spawnedEntity) { float3 randomPosition = GetRandomPositionOnCircle(ref randomGenerator, spawner.SpawnDistance); Translation translation = new Translation { Value = randomPosition }; commandBuffer.SetComponent(entityInQueryIndex, spawnedEntity, translation); }
public void Execute(Entity entity, int index, ref Translation translation, ref GridPosition gridPosition, [ReadOnly] ref Movable movable) { if (movable.direction == Direction.NONE) { //Entity is static return; } //Spawn follow juice Entity newJuiceEntity = CommandBuffer.Instantiate(index, spawner.prefabFollowJuice); int layer = Root.ConfigManager.LayersConfig.LayerForEntity(EntityType.FOLLOW_JUICE); int2 juiceGridPosition = gridPosition.Value; float3 juiceTranslation = GridConfig.PositionForCoordinates(juiceGridPosition.x, juiceGridPosition.y, layer); CommandBuffer.SetComponent(index, newJuiceEntity, new GridPosition { Value = juiceGridPosition, layer = layer}); CommandBuffer.SetComponent(index, newJuiceEntity, new Translation() { Value = juiceTranslation}); int2 offset = GridHelpers.DirectionToInt2(movable.direction); //Wrap around the grid int wrappedX = gridPosition.Value.x + offset.x; int wrappedY = gridPosition.Value.y + offset.y; if (gridPosition.Value.x < 0) { wrappedX = GridConfig.width - 1; } else if (GridConfig.width <= gridPosition.Value.x) { wrappedX = 0; } else if (gridPosition.Value.y < 0) { wrappedY = GridConfig.height - 1; } else if (GridConfig.height <= gridPosition.Value.y) { wrappedY = 0; } gridPosition.Value = new int2(wrappedX, wrappedY); translation.Value = GridConfig.PositionForCoordinates(wrappedX, wrappedY, gridPosition.layer); }
private void DoSpawn(int index, float3 translation, quaternion rotation, ref Entity entityType, int direction, float speed, bool isCat) { var instance = CommandBuffer.Instantiate(index, entityType); CommandBuffer.SetComponent(index, instance, new Translation { Value = translation }); CommandBuffer.SetComponent(index, instance, new Rotation { Value = rotation }); CommandBuffer.AddComponent <LbRotationSpeed>(index, instance); CommandBuffer.AddComponent(index, instance, new LbMovementSpeed { Value = speed }); CommandBuffer.AddComponent(index, instance, new LbMovementTarget() { From = translation, To = translation }); CommandBuffer.AddComponent(index, instance, new LbDistanceToTarget { Value = 1.0f }); CommandBuffer.AddComponent(index, instance, new LbDirection() { Value = (byte)direction }); if (isCat) { CommandBuffer.AddComponent <LbCat>(index, instance); CommandBuffer.AddComponent(index, instance, new LbLifetime() { Value = 30.0f }); } else { CommandBuffer.AddComponent <LbRat>(index, instance); } }
public static Entity Instantiate(EntityCommandBuffer.Concurrent ecb, int jobIndex, float3 pos, Entity prefab, float time) { var entity = ecb.Instantiate(jobIndex, prefab); ecb.SetComponent(jobIndex, entity, new AlivePeriod { StartTime = time, Period = 1f, }); var rot = quaternion.identity; var mat = new float4x4(rot, pos); mat.c0.w = time; var random = new Random((uint)pos.GetHashCode()); var rotZ = random.NextFloat() * math.PI * 2f; mat.c1.w = rotZ; ecb.SetComponent(jobIndex, entity, new ExplosionComponent { Matrix = mat, }); return(entity); }
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 e, int jobIndex, [ReadOnly] ref Translation translation, [ReadOnly] ref LauncherComponent launcher, [ReadOnly] ref QuadrantEntityComponent quadData) { //detect if on cooldown if (CooldownData.Exists(e)) { return; } // if not on cooldown, spawn a projectile in a random forward direction (velocity component assignment) // x and y values are allowed to be slightly random for the velocity direction Entity projectile = CommandBuffer.Instantiate(jobIndex, launcher.projectileEntity); CommandBuffer.SetComponent(jobIndex, projectile, new Translation { Value = translation.Value }); CommandBuffer.SetComponent(jobIndex, projectile, new VelocityComponent { Value = new float3(Randomizer.NextFloat(-1.5f, 1.5f), Randomizer.NextFloat(0.25f, 0.8f), Randomizer.NextFloat(3f, 6f)) * (quadData.type == QuadEntityType.Archer ? 15f : 23f) }); CommandBuffer.AddComponent(jobIndex, e, new CooldownComponent { waitTime = Randomizer.NextFloat(0.5f, 2f) }); }
public void Execute(Entity entity, int index, ref BoundingVolume vol, ref HealthModifier healthMod) { if (vol.volume.Intersects(playerBounds)) { // there was a collision, modify the player's health Utils.ModifyHealth(ref playerHealth, healthMod.value); commandBuffer.SetComponent <Health>(index, player, playerHealth); // get rid of the damager commandBuffer.DestroyEntity(index, entity); } }
public void Execute(Entity entity, int index, ref SphereSpawner sphereSpawner) { sphereSpawner.SecondsUntilSpawn -= deltaTime; if (0 < sphereSpawner.SecondsUntilSpawn) { return; } sphereSpawner.SecondsUntilSpawn = sphereSpawner.Delay; Entity icosphereEntity = ecb.Instantiate(index, sphereSpawner.Prefab); var position = new float3(0, positionY, 0); ecb.SetComponent(index, icosphereEntity, new Translation { Value = position }); ecb.SetComponent(index, icosphereEntity, new MaterialId { currentMaterialId = materialType }); ecb.AddComponent <UpdateMaterialTag>(index, icosphereEntity); }
public void Execute(Entity entity, int index, ref Spawner_FromEntity spawnerData, ref LocalToWorld location) { if (spawnerData.time <= 0) { spawnerData.time = 5; Debug.Log("创建一个cube"); var instance = commandBuffer.Instantiate(index, spawnerData.Prefab); commandBuffer.SetComponent(index, instance, new Translation { Value = position }); commandBuffer.SetComponent <Spawner_FromEntity>(index, instance, new Spawner_FromEntity { time = 5, Prefab = spawnerData.Prefab }); } else { spawnerData.time -= delatime; } //commandBuffer.DestroyEntity(index, entity); }
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex) { var chunkEntities = chunk.GetNativeArray(EntityType); var chunkTranslation = chunk.GetNativeArray(TranslationType); var chunkTarget = chunk.GetNativeArray(AttackTargetType); if (chunk.Has(MoveForwardType)) { for (int i = 0; i < chunk.Count; i++) { Entity target = chunkTarget[i].Target; if (AllTranslation.Exists(target)) { float3 targetPos = AllTranslation[target].Value; CommandBuffer.SetComponent(chunkIndex, chunkEntities[i], new MoveForwardComponent() { Target = GetStopPosition(chunkTranslation[i].Value, targetPos) }); } } } else { for (int i = 0; i < chunk.Count; i++) { Entity target = chunkTarget[i].Target; if (AllTranslation.Exists(target)) { float3 targetPos = AllTranslation[target].Value; float3 delta = chunkTranslation[i].Value - targetPos; if (math.lengthsq(delta) > StoppingDistanceSquare) { CommandBuffer.AddComponent(chunkIndex, chunkEntities[i], new MoveForwardComponent() { Target = GetStopPosition(chunkTranslation[i].Value, targetPos) }); } } } } if (chunk.Has(EnemyType)) { for (int i = 0; i < chunk.Count; i++) { CommandBuffer.RemoveComponent <FollowWaypointTag>(chunkIndex, chunkEntities[i]); CommandBuffer.AddComponent(chunkIndex, chunkEntities[i], new InAttackRangeTag()); } } }
public void Execute(int index) { //a Voice is hooked with a new AudioSource. CommandBuffer.AddComponent(PlayRequests[index].VoiceEntity, new RealVoice(PlayRequests[index].VoiceEntity, SourceHandles[index].SourceEntity)); CommandBuffer.SetComponent(SourceHandles[index].SourceEntity, new AudioSourceHandle(SourceHandles[index].SourceEntity)); //the vacant AudioSource is now claimed. CommandBuffer.AddComponent(SourceHandles[index].SourceEntity, new ClaimedByVoice(PlayRequests[index].VoiceEntity)); //the voice entity is no longer requiring to obtain a voice. CommandBuffer.RemoveComponent <RealVoiceRequest>(PlayRequests[index].VoiceEntity); }
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 (HeldType.Exists(Target.Value)) { ecb.RemoveComponent(chunkIndex, Entities[i], typeof(C_Target)); continue; } var translation = Translations[i]; var velocity = Velocities[i]; var targetPos = TranslationData[Target.Value].Value; var delta = targetPos - translation.Value; var distanceSquared = delta.x * delta.x + delta.y * delta.y + delta.z * delta.z; var grid = GridType[Target.Value]; if (StackType[Target.Value].index < StackHeights[GridIndex(grid.x, grid.y)] - 1) { //Not top of stack anymore. ecb.RemoveComponent(chunkIndex, Entities[i], typeof(C_Target)); continue; } if (distanceSquared < GrabDistance * GrabDistance) { C_Held held; held.Holder = Entities[i]; Tag_IsHeld tag; ecb.SetComponent(chunkIndex, Target.Value, held); ecb.AddComponent(chunkIndex, Target.Value, tag); ecb.RemoveComponent(chunkIndex, Entities[i], typeof(C_Target)); C_Holding hold; hold.ent = Target.Value; ecb.AddComponent(chunkIndex, Entities[i], hold); continue; } velocity.Value += delta * (ChaseForce * dt / sqrt(distanceSquared)); Velocities[i] = velocity; } }
public void Execute(int index) { var line = Lines[LineEntities[index]]; line.Position = BoundsArray[index].c0; line.BoundingBoxSize = BoundsArray[index].c1 + (LineProfiles.Exists(LineEntities[index]) ? LineProfiles[LineEntities[index]].Width * 2 : DefaultProfile.Width * 2); Ecb.SetComponent(index, LineEntities[index], line); }
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 }); }
public void Execute(Entity entity, int index, ref SpawnerData spawnerData, [ReadOnly] ref LocalToWorld localToWorld) { spawnerData.secondsToNextSpawn -= deltaTime; if (spawnerData.secondsToNextSpawn <= 0) { if (destinations.Exists(entity)) { Entity instance = InstansiateEntity(index, ref spawnerData, ref localToWorld); entityCommandBuffer.SetComponent(index, instance, destinations[entity]); } if (inputs.Exists(entity) && inputs[entity].IsFiring) { Entity instance = InstansiateEntity(index, ref spawnerData, ref localToWorld); entityCommandBuffer.AddComponent(index, instance, new ChangeDirectionData { newDirection = localToWorld.Forward }); } } }
public void Execute(int index) { var road = Roads[index]; Entity entity = default; DynamicBuffer <LaneVertex> laneVertices = default; if (SplitScheme == SplitScheme.Road) { entity = CommandBuffer.CreateEntity(index, RoadLaneArchetype); CommandBuffer.SetComponent(index, entity, new RoadLane { Name = road.Name }); laneVertices = CommandBuffer.AddBuffer <LaneVertex>(index, entity); } for (var geometryIdx = road.GeometryStartIndex; geometryIdx < road.GeometryStartIndex + road.GeometryCount; geometryIdx++) { var geometry = Geometries[geometryIdx]; if (SplitScheme == SplitScheme.Geometry) { entity = CommandBuffer.CreateEntity(index, RoadLaneArchetype); CommandBuffer.SetComponent(index, entity, new RoadLane { Name = new NativeString512($"{road.Name} {geometry.geometryKind}") }); laneVertices = CommandBuffer.AddBuffer <LaneVertex>(index, entity); } var samples = GeometrySampling.BuildSamplesFromGeometry(geometry, 3f); foreach (var sample in samples) { // TODO: support elevation //Samples use x/y coordinates. Translate to x/z planar Unity coordinates laneVertices.Add(new LaneVertex { GeometryIndex = geometryIdx - road.GeometryStartIndex, Position = sample.pose.pos, Orientation = sample.pose.rot }); } } }
public void Execute(int index) { var updatedPowder = Simulate(powders[index], index); if (!powders[index].Same(updatedPowder)) { cmdBuffer.SetComponent(entities[index], updatedPowder); positions[index] = new Position2D() { Value = PowderGame.CoordToWorld(powders[index].coord) }; } }
#pragma warning restore 649 public void Execute(int jobIndex) { var rng = ThreadRngs[_threadIndex]; float blockHeight = rng.NextFloat(TerrainHeightMin, TerrainHeightMax); ThreadRngs[_threadIndex] = rng; int2 blockCoords = new int2(jobIndex % TerrainSize.x, jobIndex / TerrainSize.x); int blockIndex = BlockCoordsToIndex(blockCoords, TerrainSize); float3 blockPosition = BlockCoordsToPosition(blockCoords, blockHeight, TerrainSize); Entity e = CommandBuffer.Instantiate(jobIndex, BlockPrefab); // TODO(@cort): should store e in BlockEntities yet, but it won't be valid (=non-negative) until the command buffer is played back. CommandBuffer.SetComponent(jobIndex, e, new BlockPositionXZ { Value = blockPosition.xz }); CommandBuffer.SetComponent(jobIndex, e, new BlockIndex { Value = blockIndex }); CommandBuffer.SetComponent(jobIndex, e, new BlockHeight { Value = blockHeight }); }
static Entity Instantiate(EntityCommandBuffer.Concurrent ecb, int jobIndex, Entity prefab, float3 pos, quaternion rot, float3 vel) { var entity = ecb.Instantiate(jobIndex, prefab); ecb.SetComponent(jobIndex, entity, new Translation { Value = pos, }); ecb.SetComponent(jobIndex, entity, new Rotation { Value = rot, }); ecb.SetComponent(jobIndex, entity, new PhysicsVelocity() { Linear = vel, }); ecb.SetComponent(jobIndex, entity, new AlivePeriod { StartTime = (float)Time.GetCurrent(), Period = 2f, }); ecb.SetComponent(jobIndex, entity, new CachedBeamMatrix { Matrix = new float4x4(rot, pos), }); return(entity); }
public void Execute(Entity entity, int index, [ReadOnly] ref Spawner_FromEntity spawnerFromEntity, [ReadOnly] ref LocalToWorld location) { for (var x = 0; x < spawnerFromEntity.CountX; x++) { for (var y = 0; y < spawnerFromEntity.CountY; y++) { var instance = CommandBuffer.Instantiate(index, spawnerFromEntity.Prefab); var xPos = noise.cnoise(new float2(y, x) * 0.21F) * 8; var yPos = noise.cnoise(new float2(x, y) * 0.21F) * 8; var position = new float3(xPos, yPos, 0); CommandBuffer.SetComponent(index, instance, new Translation { Value = position }); CommandBuffer.AddComponent(index, instance, default(TagObstacleComponent)); CommandBuffer.AddComponent(index, instance, new BoxColliderComponent(new float2(1, 2))); } } for (var x = 0; x < spawnerFromEntity.CountX; x++) { for (var y = 0; y < spawnerFromEntity.CountY; y++) { var instance = CommandBuffer.Instantiate(index, spawnerFromEntity.Prefab); var xPos = noise.cnoise(new float2(y, x) * 0.21F) * 8; var yPos = noise.cnoise(new float2(x, y) * 0.21F) * 8; var position = new float3(xPos, yPos, 0); CommandBuffer.SetComponent(index, instance, new Translation { Value = position }); CommandBuffer.AddComponent(index, instance, default(TagAgentComponent)); CommandBuffer.AddComponent(index, instance, new BoxColliderComponent(new float2(2, 1))); } } CommandBuffer.DestroyEntity(index, entity); }
public unsafe void Execute(Entity entity, int index, ref Translation position, ref Rotation rotation, ref Velocity velocity, ref ShipStateComponentData state, [ReadOnly] ref PlayerIdComponentData playerIdData) { var input = inputFromEntity[entity]; ShipCommandData inputData; if (!input.GetDataAtTick(currentTick, out inputData)) { inputData.shoot = 0; } state.State = inputData.thrust; if (inputData.left == 1) { rotation.Value = math.mul(rotation.Value, quaternion.RotateZ(math.radians(-displacement * deltaTime))); } if (inputData.right == 1) { rotation.Value = math.mul(rotation.Value, quaternion.RotateZ(math.radians(displacement * deltaTime))); } if (inputData.thrust == 1) { float3 fwd = new float3(0, playerForce * deltaTime, 0); velocity.Value += math.mul(rotation.Value, fwd).xy; } position.Value.xy += velocity.Value * deltaTime; if (state.WeaponCooldown > 0) { --state.WeaponCooldown; } if (inputData.shoot != 0 && state.WeaponCooldown == 0) { var e = commandBuffer.CreateEntity(index, bulletArchetype); commandBuffer.SetComponent(index, e, position); commandBuffer.SetComponent(index, e, rotation); var vel = new Velocity { Value = math.mul(rotation.Value, new float3(0, bulletVelocity, 0)).xy }; commandBuffer.SetComponent(index, e, new BulletAgeComponentData(1.5f)); commandBuffer.SetComponent(index, e, new PlayerIdComponentData() { PlayerId = playerIdData.PlayerId }); commandBuffer.SetComponent(index, e, vel); commandBuffer.SetComponent(index, e, new CollisionSphereComponentData(bulletRadius)); state.WeaponCooldown = k_CoolDownTicksCount; } }
private void SetVelocity(int index) { float2 position = new float2(Positions[index].Value.x, Positions[index].Value.y); float2 target = Targets[index].Value; VelocityData data = new VelocityData(); data.Velocity = math.normalize(target - position); data.MaxSpeed = MaxSpeed; // Velocities[index] = data; EntityBuffer.SetComponent(index, EntityArray[index], data); }
public Entity CreateBullet(int index, [ReadOnly] ref Translation position, [ReadOnly] ref Rotation rotation, Entity bullet, float angle) { Entity entity = commandBuffer.Instantiate(index, bullet); commandBuffer.SetComponent(index, entity, new Translation { Value = new float3( position.Value.x, position.Value.y, bulletHeight) }); commandBuffer.SetComponent(index, entity, new Rotation { Value = math.mul( math.normalize(rotation.Value), quaternion.AxisAngle( math.forward(rotation.Value), angle)) }); return(entity); }
public void Execute(Entity entity, int index, [ReadOnly] ref PotionData potionData, ref StatData statData) { EntityCommandBuffer.RemoveComponent <ResolveCardInteractionData>(index, entity); EntityCommandBuffer.AddComponent(index, entity, new DirtyData()); var e = EntityCommandBuffer.CreateEntity(index, HealPlayerArchetype); EntityCommandBuffer.SetComponent(index, e, new HealPlayerData { Amount = statData.Value }); EntityCommandBuffer.CreateEntity(index, PostResolveCardArchetype); }