protected override void OnUpdate() { Entities.ForEach((Entity e, Component.Spawner spawner, ref LocalToWorld localToWorld) => { int spawnCount = spawner._count; var spawnPositions = new NativeArray <float3>(spawnCount, Allocator.TempJob); GeneratePoints.RandomPointsInUnitSphere(spawnPositions); var entities = new NativeArray <Entity>(spawnCount, Allocator.TempJob); for (int i = 0; i < spawnCount; ++i) { entities[i] = PostUpdateCommands.Instantiate(spawner._prefab); } for (int i = 0; i < spawnCount; i++) { PostUpdateCommands.SetComponent(entities[i], new LocalToWorld { Value = float4x4.TRS( localToWorld.Position + (spawnPositions[i] * spawner._radius), quaternion.LookRotationSafe(spawnPositions[i], math.up()), new float3(1.0f, 1.0f, 1.0f)) }); } PostUpdateCommands.RemoveComponent <Component.Spawner>(e); spawnPositions.Dispose(); entities.Dispose(); }); }
protected override void OnUpdate() { Entities.ForEach((Entity e, SpawnRandomInSphere spawner, ref LocalToWorld localToWorld) => { int toSpawnCount = spawner.Count; var spawnPositions = new NativeArray <float3>(toSpawnCount, Allocator.TempJob); GeneratePoints.RandomPointsInUnitSphere(spawnPositions); // Calling Instantiate once per spawned Entity is rather slow, and not recommended // This code is placeholder until we add the ability to bulk-instantiate many entities from an ECB var entities = new NativeArray <Entity>(toSpawnCount, Allocator.Temp); for (int i = 0; i < toSpawnCount; ++i) { entities[i] = PostUpdateCommands.Instantiate(spawner.Prefab); } for (int i = 0; i < toSpawnCount; i++) { PostUpdateCommands.SetComponent(entities[i], new LocalToWorld { Value = float4x4.TRS( localToWorld.Position + (spawnPositions[i] * spawner.Radius), quaternion.LookRotationSafe(spawnPositions[i], math.up()), new float3(1.0f, 1.0f, 1.0f)) }); } PostUpdateCommands.RemoveComponent <SpawnRandomInSphere>(e); spawnPositions.Dispose(); entities.Dispose(); }); }
protected override void OnUpdate() { if (logicFrames.Count <= 0) { return; } //run logic frame var logicFrame = logicFrames.Dequeue(); switch (logicFrame.opId) { case OPType.CreateAgent: var instance = PostUpdateCommands.Instantiate(prefab); PostUpdateCommands.AddComponent(instance, new AgentComponent { nexPosition = new float3(0), position = new float3(0), moveSpeed = 1 }); PostUpdateCommands.SetComponent(instance, new LocalToWorld() { Value = new float4x4(quaternion.identity, new float3(0, 0, 0)) }); break; case OPType.Idle: break; } }
protected override void OnUpdate() { { Entities.With(Component_Query).ForEach((Unity.Entities.Entity Component_QueryEntity, ref PlayerWeaponData Component_QueryPlayerWeaponData, ref PlayerInput Component_QueryPlayerInput, ref Unity.Transforms.Translation Component_QueryTranslation) => { Debug.Log("being run"); if (Component_QueryPlayerInput.Fire) { Debug.Log("attemping to spawn"); Unity.Entities.Entity entity = PostUpdateCommands.Instantiate(Component_QueryPlayerWeaponData.BulletType); PostUpdateCommands.AddComponent <PlayerInput>(entity, new PlayerInput { HorizontalInput = 0F, VerticalInput = 0F, Fire = false }); PostUpdateCommands.SetComponent <Unity.Transforms.Translation>(entity, new Unity.Transforms.Translation { Value = new Unity.Mathematics.float3 { x = Component_QueryTranslation.Value.x, y = Component_QueryTranslation.Value.y, z = Component_QueryTranslation.Value.z } }); PostUpdateCommands.AddComponent <SetBulletVelocity>(entity, new SetBulletVelocity { TargetEntity = Component_QueryEntity, TargetPosition = Component_QueryTranslation.Value }); } } ); } }
protected override void OnUpdate() { if (Boot.Instance.PlayerEntity == null) { return; } float elapsed = Time.deltaTime; Entities.ForEach((ref SpawnSource spawnSource) => { Rect spawnArea = spawnSource.spawnArea; spawnSource.currDelay -= elapsed; while (spawnSource.currDelay < 0) { Entity spawnedEntity = PostUpdateCommands.Instantiate(spawnSource.spawnType); PostUpdateCommands.SetComponent(spawnedEntity, new Translation { Value = new float3(spawnArea.xMin + rand.NextFloat() * (spawnArea.xMax - spawnArea.xMin), spawnArea.yMin + rand.NextFloat() * (spawnArea.yMax - spawnArea.yMin), 0) }); spawnSource.currDelay += spawnSource.delayPerSpawn; } }); }
protected override void OnUpdate() { using (var selectedUnits = m_selectedUnits.ToEntityArray(Unity.Collections.Allocator.TempJob)) { foreach (var selectedUnit in selectedUnits) { var prefab = m_entityManager.GetSharedComponentData <HighlightSpawnerComponent>(selectedUnit).Highlight; var instance = PostUpdateCommands.Instantiate(prefab); PostUpdateCommands.AddComponent(instance, new Parent { Value = selectedUnit }); PostUpdateCommands.AddComponent(selectedUnit, new AttachedHighlightComponent { Highlight = instance }); PostUpdateCommands.AddComponent(instance, typeof(LocalToParent)); PostUpdateCommands.SetComponent(instance, new Translation { Value = new float3(0f, -0.8f, 0) }); PostUpdateCommands.RemoveComponent <NeedsHighlighComponent>(selectedUnit); } } using (var deselectedUnits = m_delectedUnits.ToEntityArray(Unity.Collections.Allocator.TempJob)) { foreach (var deselectedUnit in deselectedUnits) { var highlight = m_entityManager.GetComponentData <AttachedHighlightComponent>(deselectedUnit); PostUpdateCommands.DestroyEntity(highlight.Highlight); PostUpdateCommands.RemoveComponent(m_delectedUnits, typeof(AttachedHighlightComponent)); PostUpdateCommands.RemoveComponent <DeselectedTagComponent>(deselectedUnit); } } }
protected override void OnUpdate() { Entities.WithAll(ComponentType.ReadOnly <SpawnningTag>(), ComponentType.ReadOnly <LocalToWorld>(), ComponentType.ReadWrite <WaterSpawner>()).ForEach((ref WaterSpawner waterSpawnner, ref LocalToWorld localToWorld) => { waterSpawnner.TimeBetweenSpawns += Time.DeltaTime; if (waterSpawnner.TimeBetweenSpawns >= waterSpawnner.WaterSpawnRate) { Entity water = PostUpdateCommands.Instantiate(waterSpawnner.WaterEntity); Translation translation = new Translation { Value = localToWorld.Position }; PhysicsVelocity velocity = new PhysicsVelocity { Linear = localToWorld.Forward * waterSpawnner.WaterPressure }; PostUpdateCommands.SetComponent(water, translation); PostUpdateCommands.SetComponent(water, velocity); } } ); }
protected override void OnUpdate() { float bulletSpeed = Boot.Settings.BulletSpeed; Entity bulletPrototype = Boot.Instance.PlayerBulletEntity; float dt = Time.deltaTime; Entities.ForEach((ref Player player, ref PlayerInput playerInput, ref Translation pos, ref Rotation rotation) => { if (math.lengthsq(playerInput.Shoot) > .5f * .5f) { player.CurrFireCooldown -= dt; if (player.CurrFireCooldown <= 0) { var newBullet = PostUpdateCommands.Instantiate(bulletPrototype); float3 vel = math.mul(rotation.Value, new float3(0, 0, bulletSpeed)); PostUpdateCommands.AddComponent(newBullet, new Velocity { Value = vel.xy }); PostUpdateCommands.SetComponent(newBullet, new Translation { Value = pos.Value }); player.CurrFireCooldown += player.FireCooldown; } player.CurrFireCooldown = math.max(player.CurrFireCooldown, 0); } }); }
protected override void OnUpdate() { Entities.ForEach((Entity e, ref SpawnAllComponent sac) => { int totalCount = sac.Count * 3; float3 armSpawnPos = new float3(0, 0, 0); PostUpdateCommands.RemoveComponent <SpawnAllComponent>(e); // Calling Instantiate once per spawned Entity is rather slow, and not recommended // This code is placeholder until we add the ability to bulk-instantiate many entities from an ECB int index = 0; var entities = new NativeArray <Entity>(totalCount, Allocator.Temp); while (index < totalCount) { entities[index] = PostUpdateCommands.Instantiate(sac.RockPrefab); PostUpdateCommands.AddComponent(entities[index], new Scale { Value = 0f }); PostUpdateCommands.AddComponent(entities[index], new RockComponent()); PostUpdateCommands.AddComponent(entities[index], new RigidBodyComponent()); PostUpdateCommands.AddComponent(entities[index], new InitComponentTag()); //TODO Need to fill in data PostUpdateCommands.AddComponent(entities[index], new SizeableComponent()); //TODO Need to fill in data index++; // Spawn Tin Cans entities[index] = PostUpdateCommands.Instantiate(sac.TinCanPrefab); PostUpdateCommands.AddComponent(entities[index], new Scale { Value = 1f }); PostUpdateCommands.AddComponent(entities[index], new TinCanComponent { RangeY = new float2(3f, 8f), ReserveTime = 3 }); PostUpdateCommands.AddComponent(entities[index], new RigidBodyComponent { Gravity = 20f, //spawnComponent.Gravity, Velocity = float3.zero, AngularVelocity = float3.zero }); PostUpdateCommands.AddComponent(entities[index], new SizeableComponent { ScaleFactor = 1f, TargetSize = 0.4f, CurrentSize = 0f }); //TODO Need to fill in data PostUpdateCommands.AddComponent(entities[index], new InitComponentTag()); index++; // Spawn Arms entities[index] = PostUpdateCommands.Instantiate(sac.ArmPrefab); PostUpdateCommands.SetComponent(entities[index], new Translation { Value = armSpawnPos }); armSpawnPos.x += 2.0f; index++; } entities.Dispose(); }); }
protected override void OnUpdate() { var gameState = GetSingleton <GameState>(); if (gameState.Value != GameStates.InGame) { return; } m_ElapsedTime += Time.DeltaTime; var settings = GetSingleton <AsteroidSpawner>(); var settingsEntity = GetSingletonEntity <AsteroidSpawner>(); var asteroidSprites = EntityManager.GetBuffer <AsteroidSprite>(settingsEntity); // if (settings.Rate < 1) var timeLimit = 1.0f / settings.Rate; var camera = GetSingleton <Camera>(); var srPrefab = EntityManager.GetComponentData <SpriteRenderer>(settings.Prefab); if (m_ElapsedTime > timeLimit) { // world view var x = camera.aspect * camera.fov; var y = camera.fov; // find a point somewhere outside of view, var rot = quaternion.RotateZ(m_Random.NextFloat(2 * math.PI)); var pos = new float3(x, y, 0); pos = math.mul(rot, pos); // aim it directly at the camera's position var dir = math.normalize(float3.zero - pos) * m_Random.NextFloat(settings.MinSpeed, settings.MaxSpeed); // vary the aim by a a little to miss the center rot = quaternion.RotateZ(m_Random.NextFloat(settings.PathVariation * 2 * math.PI)); // 10% variation // vary the speed as well dir = math.mul(rot, dir); var ast = PostUpdateCommands.Instantiate(settings.Prefab); var astType = m_Random.NextInt(asteroidSprites.Length); srPrefab.Sprite = asteroidSprites[astType].Sprite; PostUpdateCommands.SetComponent(ast, srPrefab); PostUpdateCommands.SetComponent(ast, new PhysicsVelocity { Linear = new float2(dir.x, dir.y) }); PostUpdateCommands.SetComponent(ast, new Translation { Value = pos }); m_ElapsedTime = 0; } }
protected override void OnUpdate() { Entities.WithNone <SendRpcCommandRequestComponent>().ForEach((Entity reqEnt, ref GoInGameRequest req, ref ReceiveRpcCommandRequestComponent reqSrc) => { if (connectedPlayers < GameSession.serverSession.numberOfPlayers) { PostUpdateCommands.AddComponent <NetworkStreamInGame>(reqSrc.SourceConnection); var ghostCollection = GetSingleton <GhostPrefabCollectionComponent>(); var ghostId = SerpentineGhostSerializerCollection.FindGhostType <CarStubSnapshotData>(); var prefab = EntityManager.GetBuffer <GhostPrefabBuffer>(ghostCollection.serverPrefabs)[ghostId].Value; var player = PostUpdateCommands.Instantiate(prefab); int indexOfNextFreeSpawnLocationIndex = Random.Range(0, freeSpawnLocationIndices.Count); uint nextSpawnLocationIndex = freeSpawnLocationIndices[indexOfNextFreeSpawnLocationIndex]; freeSpawnLocationIndices.RemoveAt(indexOfNextFreeSpawnLocationIndex); PostUpdateCommands.SetComponent(player, new Translation { Value = SerializedFields.singleton.spawnLocations[(int)nextSpawnLocationIndex].position }); PostUpdateCommands.SetComponent(player, new Rotation { Value = SerializedFields.singleton.spawnLocations[(int)nextSpawnLocationIndex].rotation }); PostUpdateCommands.SetComponent(player, new SynchronizedCarComponent { PlayerId = EntityManager.GetComponentData <NetworkIdComponent>(reqSrc.SourceConnection).Value }); PostUpdateCommands.SetComponent(player, new MissileScopeComponent { TargetPlayerId = null }); PostUpdateCommands.AddBuffer <PlayerInput>(player); PostUpdateCommands.AddBuffer <PowerupSlotElement>(player); PostUpdateCommands.AddBuffer <LaserPowerupSlotElement>(player); for (int i = 0; i < SerializedFields.singleton.numberOfPowerupSlots; i++) { PostUpdateCommands.AppendToBuffer(player, new PowerupSlotElement { Content = PowerupSlotContent.Empty }); } PostUpdateCommands.SetComponent(reqSrc.SourceConnection, new CommandTargetComponent { targetEntity = player }); PostUpdateCommands.DestroyEntity(reqEnt); var raceInformationRequest = PostUpdateCommands.CreateEntity(); PostUpdateCommands.AddComponent(raceInformationRequest, new RaceInformationRequest { laps = GameSession.serverSession.laps }); PostUpdateCommands.AddComponent(raceInformationRequest, new SendRpcCommandRequestComponent { TargetConnection = reqSrc.SourceConnection }); connectedPlayers++; } }); }
protected override void OnUpdate() { Entities.WithNone <SendRpcCommandRequestComponent>().ForEach((Entity reqEnt, ref SpawnAvatarCommand req, ref ReceiveRpcCommandRequestComponent reqSrc) => { int connectionId = EntityManager.GetComponentData <NetworkIdComponent>(reqSrc.SourceConnection).Value; PostUpdateCommands.AddComponent <NetworkStreamInGame>(reqSrc.SourceConnection); UnityEngine.Debug.Log(String.Format("Server setting connection {0} to in game", connectionId)); // Delete original avatar Entities.ForEach((Entity ent, ref PlayerId playerId) => { if (playerId.playerId == connectionId) { PostUpdateCommands.DestroyEntity(ent); } }); // Setup the character avatar Entity ghostCollection = GetSingletonEntity <GhostPrefabCollectionComponent>(); DynamicBuffer <GhostPrefabBuffer> ghostPrefabs = EntityManager.GetBuffer <GhostPrefabBuffer>(ghostCollection); int ghostId = GetPlayerGhostIndex(ghostPrefabs, req.avatarId, EntityManager); var prefab = EntityManager.GetBuffer <GhostPrefabBuffer>(ghostCollection)[ghostId].Value; var player = PostUpdateCommands.Instantiate(prefab); PostUpdateCommands.SetComponent(player, new PlayerId { playerId = connectionId }); PostUpdateCommands.SetComponent(player, new Translation { Value = req.position }); PostUpdateCommands.SetComponent(player, new Rotation { Value = req.attitude }); PostUpdateCommands.SetComponent(player, new GhostOwnerComponent { NetworkId = connectionId }); int deadPlayerId = GetPlayerGhostIndex(ghostPrefabs, PlayerPrefabComponent.DeadPlayerId, EntityManager); var dedPrefab = EntityManager.GetBuffer <GhostPrefabBuffer>(ghostCollection)[deadPlayerId].Value; var dedPlayer = PostUpdateCommands.Instantiate(dedPrefab); PostUpdateCommands.SetComponent(dedPrefab, new Translation { Value = req.position }); PostUpdateCommands.SetComponent(dedPrefab, new Rotation { Value = req.attitude }); PostUpdateCommands.AddBuffer <PlayerInput>(player); PostUpdateCommands.SetComponent(reqSrc.SourceConnection, new CommandTargetComponent { targetEntity = player }); PostUpdateCommands.DestroyEntity(reqEnt); }); }
protected override void OnUpdate() { var input = m_CharacterGunInputQuery.GetSingleton <CharacterGunInput>(); float dt = Time.fixedDeltaTime; Entities.ForEach( (ref LocalToWorld gunTransform, ref Rotation gunRotation, ref CharacterGun gun) => { // Handle input { float a = -input.Looking.y; gunRotation.Value = math.mul(gunRotation.Value, quaternion.Euler(math.radians(a), 0, 0)); gun.IsFiring = input.Firing > 0f ? 1 : 0; } if (gun.IsFiring == 0) { gun.Duration = 0; gun.WasFiring = 0; return; } gun.Duration += dt; if ((gun.Duration > gun.Rate) || (gun.WasFiring == 0)) { if (gun.Bullet != null) { var e = PostUpdateCommands.Instantiate(gun.Bullet); Translation position = new Translation() { Value = gunTransform.Position + gunTransform.Forward }; Rotation rotation = new Rotation() { Value = gunRotation.Value }; PhysicsVelocity velocity = new PhysicsVelocity() { Linear = gunTransform.Forward * gun.Strength, Angular = float3.zero }; PostUpdateCommands.SetComponent(e, position); PostUpdateCommands.SetComponent(e, rotation); PostUpdateCommands.SetComponent(e, velocity); } gun.Duration = 0; } gun.WasFiring = 1; } ); }
protected override void OnUpdate() { var physicsWorldSystem = World.GetExistingSystem <PhysicsWorldSystem>(); var physicsWorld = physicsWorldSystem.PhysicsWorld; var explosions = GetSingleton <ExplosionSpawner>(); { var didExplode = false; Entities.WithAll <Missile>() .ForEach(( Entity missileEntity, ref PhysicsColliderBlob collider, ref Translation tr, ref Rotation rot) => { // check with missile if (physicsWorld.OverlapCollider( new OverlapColliderInput { Collider = collider.Collider, Transform = new PhysicsTransform(tr.Value, rot.Value), Filter = collider.Collider.Value.Filter }, out OverlapColliderHit hit)) { var asteroidEntity = physicsWorld.AllBodies[hit.PhysicsBodyIndex].Entity; var exp = PostUpdateCommands.Instantiate(explosions.Prefab); PostUpdateCommands.SetComponent(exp, new Translation { Value = tr.Value }); PostUpdateCommands.DestroyEntity(asteroidEntity); PostUpdateCommands.DestroyEntity(missileEntity); didExplode = true; } }); if (didExplode) { var randomSfx = m_Random.NextInt(0, 3); var explosionSfx = randomSfx == 2 ? AudioTypes.AsteroidExplosionLarge : randomSfx == 1 ? AudioTypes.AsteroidExplosionMedium : AudioTypes.AsteroidExplosionSmall; AudioUtils.PlaySound(EntityManager, explosionSfx); } } }
protected override void OnUpdate() { var singleton = GetSingleton <EnvironmentOffsetComponent>(); var configuration = GetSingleton <EnvironmentConfiguration>(); var configurationEntity = GetSingletonEntity <EnvironmentConfiguration>(); var blockVariants = EntityManager.GetBuffer <EnvironmentBlockBufferEntry>(configurationEntity); var forward = 0; var backward = 0; var requiredForward = singleton.Offset + configuration.UnitsRequestedForward; var requiredBackward = singleton.Offset - configuration.UnitsRequestedBackward; Entities.ForEach((Entity entity, ref EnvironmentBlockComponent block) => { forward = math.max(forward, block.Offset + block.Size); backward = math.min(backward, block.Offset); if (block.Offset + block.Size < requiredBackward) { PostUpdateCommands.DestroyEntity(entity); } }); while (requiredForward > forward) { forward += SpawnBlock(forward, false); } while (requiredBackward < backward) { backward -= SpawnBlock(backward, true); } int SpawnBlock(int offset, bool offsetBySize) { var variant = blockVariants[_random.NextInt(blockVariants.Length)]; var entity = PostUpdateCommands.Instantiate(variant.Entity); var spawnAtOffset = offsetBySize ? offset - variant.Size : offset; PostUpdateCommands.SetComponent(entity, new EnvironmentBlockComponent(variant.Size) { Offset = spawnAtOffset }); return(variant.Size); } }
protected override void OnUpdate() { var state = GetSingleton <ObstacleSpawnState>(); var environment = GetSingleton <EnvironmentOffsetComponent>(); var configuration = GetSingleton <ObstacleConfiguration>(); var difficulty = GetSingleton <DifficultyStateComponent>(); var offscreenOffset = environment.Offset + configuration.OffscreenOffset; var lastSpawnOffsetDelta = offscreenOffset - state.LastObstacleOffset; var obstaclesPeriod = configuration.SpawnPeriod - difficulty.Value * configuration.SpawnPeriodDifficultyFactor; if (lastSpawnOffsetDelta < obstaclesPeriod) { return; } var configurationEntity = GetSingletonEntity <ObstacleConfiguration>(); var obstacleVariants = EntityManager.GetBuffer <ObstacleBufferEntry>(configurationEntity); var source = obstacleVariants[_random.NextInt(obstacleVariants.Length)]; var ceil = _random.NextBool(); if (ceil == state.LastObstacleOrientation) { var switchChance = 0.2f * difficulty.Value; if (_random.NextFloat() < switchChance) { ceil = !ceil; } } var entity = PostUpdateCommands.Instantiate(source.Entity); PostUpdateCommands.AddComponent(entity, new ObstacleComponent { Offset = offscreenOffset, Ceil = ceil }); PostUpdateCommands.SetComponent( entity, new Rotation() { Value = ceil ? quaternion.Euler(0.0f, 0.0f, math.PI) : quaternion.identity }); state.LastObstacleOrientation = ceil; state.LastObstacleOffset = offscreenOffset; SetSingleton(state); }
void SpawnEntities(int count) { isSpawn = true; Entity entity; Vector2 circle; Entity EntityPrefab = GameObjectConversionUtility.ConvertGameObjectHierarchy(playerPrefab, World.Active); #region Record the count of spawned Entities 记录现有实体数量 if (carCount >= maxCount) { PostUpdateCommands.DestroyEntity(EntityPrefab); return; } else if (carCount + count > maxCount) { count = maxCount - carCount; carCount = maxCount; } else { carCount += count; } #endregion for (int i = 0; i < count; i++) { entity = PostUpdateCommands.Instantiate(EntityPrefab); circle = Random.insideUnitCircle * Range; Translation pos = new Translation() { Value = new float3(circle.x, 1, circle.y) }; Move move = new Move() { acceleratioin = 5, maxSpeed = 5, targetPos = pos.Value, isHit = 0, }; PostUpdateCommands.SetComponent(entity, pos); PostUpdateCommands.SetComponent(entity, move); } PostUpdateCommands.DestroyEntity(EntityPrefab); }
protected override void OnUpdate() { Entities.ForEach((Entity spawnerEntity, ref SpawnData spawndata, ref LocalToWorld localToWorld) => { Action <float4x4, SpawnData, int, int, bool> spawn = (lToWorld, spawnData, x, y, disabled) => { var pos = new float4(x, 0.0f, y, 1); pos = math.mul(lToWorld, pos); var cube = PostUpdateCommands.Instantiate(spawnData.Prefab); PostUpdateCommands.SetComponent(cube, new Translation { Value = pos.xyz }); PostUpdateCommands.AddComponent(cube, new SpawnIndex { Value = (y * spawnData.CountX) + x, Height = spawnData.CountY }); if (disabled) { PostUpdateCommands.AddComponent(cube, new DisableRendering { }); } }; if (!spawndata.HasRenderingDisabledEntities) { for (int x = 0; x < spawndata.CountX; ++x) { for (int y = 0; y < spawndata.CountY; ++y) { spawn(localToWorld.Value, spawndata, x, y, false); } } } else { for (int x = 0; x < spawndata.CountX; ++x) { for (int y = 0; y < spawndata.CountY; ++y) { spawn(localToWorld.Value, spawndata, x, y, false); spawn(localToWorld.Value, spawndata, x, y, true); } } } PostUpdateCommands.DestroyEntity(spawnerEntity); }); }
protected override void OnUpdate() { Entities.ForEach((Entity spawnerEntity, ref EntityBuffer_VariableSpawner spawnerData, ref Translation translation) => { var spawnTime = Time.deltaTime; var newEntity = PostUpdateCommands.Instantiate(spawnerData.prefab); // 动态创建实体 筛选器内 PostUpdateCommands.AddComponent <Parent>(newEntity, new Parent { Value = spawnerEntity }); PostUpdateCommands.AddComponent <LocalToParent>(newEntity, new LocalToParent()); PostUpdateCommands.SetComponent <Translation>(newEntity, new Translation { Value = new float3(0, 0.3f * math.sin(5.0f * spawnTime), 0) }); }); }
protected override void OnUpdate() { Entities.WithNone <NetworkStreamInGame>().ForEach((Entity ent, ref NetworkIdComponent id) => { PostUpdateCommands.AddComponent <NetworkStreamInGame>(ent); var ghostId = LagCompensationGhostSerializerCollection.FindGhostType <LagPlayerSnapshotData>(); var playerPrefab = EntityManager.GetBuffer <GhostPrefabBuffer>(GetSingleton <GhostPrefabCollectionComponent>().serverPrefabs)[ghostId].Value; var player = PostUpdateCommands.Instantiate(playerPrefab); PostUpdateCommands.SetComponent(player, new LagPlayer { playerId = id.Value }); PostUpdateCommands.SetComponent(ent, new CommandTargetComponent { targetEntity = player }); }); }
protected override void OnUpdate() { var gameState = GetSingleton <GameStateData>(); if (gameState.State != GameState.Spawn) { return; } var cellManagerEntity = GetSingletonEntity <CellManager>(); var cellManager = GetSingleton <CellManager>(); var cellSprites = EntityManager.GetBuffer <CellSprite>(cellManagerEntity); var cellPrefabSR = EntityManager.GetComponentData <SpriteRenderer>(cellManager.CellPrefab); // look at every column and spawn if it's less than minimum for (var x = 0; x < cellManager.MaxCol; x++) { var results = Entities.GetCellEntitiesAtColumn(x); var needed = cellManager.MaxRow - results.Length; // spawn for (var i = 0; i < needed; i++) { var y = i + cellManager.MaxRow; var cell = PostUpdateCommands.Instantiate(cellManager.CellPrefab); PostUpdateCommands.SetComponent(cell, new Translation { Value = new float3(x, y, 0) }); var color = m_Random.NextInt(cellSprites.Length); PostUpdateCommands.AddComponent(cell, new Cell { Position = new int2(x, y), Color = color }); cellPrefabSR.Sprite = cellSprites[color].Sprite; PostUpdateCommands.SetComponent(cell, cellPrefabSR); } } gameState.State = GameState.Drop; SetSingleton(gameState); }
protected override void OnUpdate() { int curEntityCnt = m_mobQuery.CalculateEntityCount(); int curWantedMobCnt = ECSManager.Instance.MobCnt; if (curEntityCnt < curWantedMobCnt) { int diff = curWantedMobCnt - curEntityCnt; for (int i = 0; i < diff; ++i) { var entity = PostUpdateCommands.Instantiate(ECSManager.Instance.MobPrefab); var startPos = GameManager.instance.GetSpawnPosFromStart(GameManager.instance.m_defaultSpawnPos, curEntityCnt + i, 2.0f); var targetPos = new Vector3(startPos.x, startPos.y, GameManager.instance.Target.transform.position.z); PostUpdateCommands.SetComponent(entity, new Translation { Value = startPos }); PostUpdateCommands.SetComponent(entity, new MobStartPos { Value = startPos }); PostUpdateCommands.SetComponent(entity, new MobTargetPos { Value = targetPos }); PostUpdateCommands.SetComponent(entity, new MobStateData { Value = MobState.ToTarget }); } } else if (curEntityCnt > curWantedMobCnt) { int diff = curEntityCnt - curWantedMobCnt; var entityArray = m_mobQuery.ToEntityArray(Allocator.Temp); if (diff > entityArray.Length) { diff = entityArray.Length; } for (int i = curEntityCnt - 1; i >= curWantedMobCnt; --i) { PostUpdateCommands.DestroyEntity(entityArray[i]); } entityArray.Dispose(); } }
protected override void OnUpdate() { var state = GetSingleton <GameState>(); if (state.Value != GameStateEnum.InGame) { return; } var spawnerEntity = GetSingletonEntity <CarrotSpawner>(); var spawner = GetSingleton <CarrotSpawner>(); float elapsedTime = spawner.ElapsedTime; float timeLimit = spawner.TimeLimit; elapsedTime += Time.DeltaTime; if (elapsedTime > timeLimit) { var y = random.NextFloat(4) - 2; var pos = new float3(5, y, 0); var gold = random_gold.NextFloat(1); var renderer = EntityManager.GetComponentData <SpriteRenderer>(spawner.Prefab); if (gold <= 0.05) { renderer.Sprite = spawner.Gold; } else { renderer.Sprite = spawner.Nomal; } var carrot = PostUpdateCommands.Instantiate(spawner.Prefab); PostUpdateCommands.SetComponent <SpriteRenderer>(carrot, renderer); PostUpdateCommands.SetComponent(carrot, new Translation { Value = pos }); if (gold <= 0.05) { PostUpdateCommands.AddComponent <GoldTag>(carrot); } elapsedTime = 0; } spawner.ElapsedTime = elapsedTime; EntityManager.SetComponentData <CarrotSpawner>(spawnerEntity, spawner); }
protected override void OnUpdate() { Entities.ForEach((Entity spawnerEntity, ref FixedRateSpawner spawnerData, ref LocalToWorld localToWord, ref Rotation rotation) => { var spawnTime = UnityEngine.Time.time;//UnityEngine.Time.time var newEntity = PostUpdateCommands.Instantiate(spawnerData.Prefab); PostUpdateCommands.SetComponent(newEntity, new Translation { Value = localToWord.Position }); PostUpdateCommands.SetComponent(newEntity, new Rotation { Value = rotation.Value }); PostUpdateCommands.SetComponent(newEntity, new ProjectileSpawnTime { SpawnTime = spawnTime }); }); }
protected override void OnUpdate() { float dt = Time.fixedDeltaTime; Entities.ForEach( (ref LocalToWorld gunTransform, ref Rotation gunRotation, ref PhysicsGun gun) => { if (gun.isFiring == 0) { gun.duration = 0; gun.wasFiring = 0; return; } gun.duration += dt; if ((gun.duration > gun.rate) || (gun.wasFiring == 0)) { if (gun.bullet != null) { var e = PostUpdateCommands.Instantiate(gun.bullet); Translation position = new Translation() { Value = gunTransform.Position + gunTransform.Forward }; Rotation rotation = new Rotation() { Value = gunRotation.Value }; PhysicsVelocity velocity = new PhysicsVelocity() { Linear = gunTransform.Forward * gun.strength, Angular = float3.zero }; PostUpdateCommands.SetComponent(e, position); PostUpdateCommands.SetComponent(e, rotation); PostUpdateCommands.SetComponent(e, velocity); } gun.duration = 0; } gun.wasFiring = 1; } ); }
protected override void OnUpdate() { Entities.ForEach((Entity spawnerEntity, ref VariableRateSpawner spawnerData, ref Translation translation) => { var spawnTime = (float)Time.ElapsedTime; var newEntity = PostUpdateCommands.Instantiate(spawnerData.Prefab); PostUpdateCommands.AddComponent(newEntity, new Parent { Value = spawnerEntity }); PostUpdateCommands.AddComponent(newEntity, new LocalToParent()); PostUpdateCommands.SetComponent(newEntity, new Translation { Value = new float3(0, 0.3f * math.sin(5.0f * spawnTime), 0) }); PostUpdateCommands.SetComponent(newEntity, new ProjectileSpawnTime { SpawnTime = spawnTime }); }); }
private void SpawnHearts() { var gameState = GetSingleton <GameStateData>(); var heartManager = GetSingleton <HeartManager>(); var heartManagerEntity = GetSingletonEntity <HeartManager>(); gameState.Hearts = heartManager.NoOfHearts; SetSingleton(gameState); var camEntity = GetSingletonEntity <Camera>(); var camTr = EntityManager.GetComponentData <Translation>(camEntity); var cam = GetSingleton <Camera>(); var top = cam.fov - 0.5f; var right = top * cam.aspect; var heartAnchor = new float3(right + camTr.Value.x, top + camTr.Value.y, 0); var heartBuffer = PostUpdateCommands.AddBuffer <Heart>(heartManagerEntity); for (var i = 0; i < gameState.Hearts; i++) { var translation = new Translation { Value = heartAnchor }; var heartBackground = PostUpdateCommands.Instantiate(heartManager.HeartBackgroundPrefab); var heart = PostUpdateCommands.Instantiate(heartManager.HeartPrefab); PostUpdateCommands.SetComponent(heartBackground, translation); PostUpdateCommands.SetComponent(heart, translation); PostUpdateCommands.AddComponent(heartBackground, typeof(HeartBackground)); heartBuffer.Add(new Heart() { Value = heart }); heartAnchor.x--; } m_NoOfHearts = gameState.Hearts; }
private void SpawnPlayArea() { var cellManager = GetSingleton <CellManager>(); for (var x = 0; x < cellManager.MaxCol; x++) { for (var y = 0; y < cellManager.MaxRow; y++) { var backgroundEntity = PostUpdateCommands.Instantiate(cellManager.CellBackground); PostUpdateCommands.AddComponent <CellBackground>(backgroundEntity); PostUpdateCommands.SetComponent(backgroundEntity, new Translation { Value = new float3(x, y, 0) }); } } }
protected override void OnUpdate() { var spawnZoneEntity = GetSingletonEntity <SpawnZone>(); DynamicBuffer <SpawnPoint> spawnPoints = EntityManager.GetBuffer <SpawnPoint>(spawnZoneEntity); Entities.WithNone <SendRpcCommandRequestComponent>().ForEach((Entity reqEnt, ref JoinGameRequest req, ref ReceiveRpcCommandRequestComponent reqSrc) => { int connectionId = EntityManager.GetComponentData <NetworkIdComponent>(reqSrc.SourceConnection).Value; PostUpdateCommands.AddComponent <NetworkStreamInGame>(reqSrc.SourceConnection); UnityEngine.Debug.Log(String.Format("Server setting connection {0} to in game", connectionId)); // Setup the character avatar Entity ghostCollection = GetSingletonEntity <GhostPrefabCollectionComponent>(); DynamicBuffer <GhostPrefabBuffer> ghostPrefabs = EntityManager.GetBuffer <GhostPrefabBuffer>(ghostCollection); int ghostId = SpawnPlayerAvatarSystem.GetPlayerGhostIndex(ghostPrefabs, PlayerPrefabComponent.AliveCharacterId, EntityManager); var prefab = EntityManager.GetBuffer <GhostPrefabBuffer>(ghostCollection)[ghostId].Value; var player = PostUpdateCommands.Instantiate(prefab); PostUpdateCommands.SetComponent(player, new PlayerId { playerId = connectionId }); PostUpdateCommands.SetComponent(player, new GhostOwnerComponent { NetworkId = connectionId }); float3 spawnTranslation = spawnPoints[connectionId % spawnPoints.Length].position; quaternion spawnRotation = spawnPoints[connectionId % spawnPoints.Length].attitude; float verticalRotation = ((Quaternion)spawnRotation).eulerAngles.y; PostUpdateCommands.SetComponent(player, new Translation { Value = spawnTranslation }); PostUpdateCommands.SetComponent(player, new Rotation { Value = spawnRotation }); PostUpdateCommands.AddBuffer <PlayerInput>(player); PostUpdateCommands.SetComponent(reqSrc.SourceConnection, new CommandTargetComponent { targetEntity = player }); PostUpdateCommands.DestroyEntity(reqEnt); }); }
protected override void OnUpdate() { Entities.ForEach((Entity e, SpawnRandomInSphere spawner, ref LocalToWorld localToWorld) => { int toSpawnCount = spawner.Count; // Using a .TempJob instead of a .Temp for `spawnPositions`, because the method // `RandomPointsInUnitSphere` passes this NativeArray into a Job var spawnPositions = new NativeArray <float3>(toSpawnCount, Allocator.TempJob); GeneratePoints.RandomPointsInUnitSphere(spawnPositions); // Calling Instantiate once per spawned Entity is rather slow, and not recommended // This code is placeholder until we add the ability to bulk-instantiate many entities from an ECB var entities = new NativeArray <Entity>(toSpawnCount, Allocator.Temp); for (int i = 0; i < toSpawnCount; ++i) { entities[i] = PostUpdateCommands.Instantiate(spawner.Prefab); } for (int i = 0; i < toSpawnCount; i++) { PostUpdateCommands.SetComponent(entities[i], new LocalToWorld { Value = float4x4.TRS( localToWorld.Position + (spawnPositions[i] * spawner.Radius), quaternion.LookRotationSafe(spawnPositions[i], math.up()), new float3(1.0f, 1.0f, 1.0f)) }); } // Using 'RemoveComponent' instead of 'DestroyEntity' as a safety. // Removing the SpawnRandomInSphere component is sufficient to prevent the spawner // from executing its spawn logic more than once. The spawner may have other components // that are relevant to ongoing processing; this system doesn't know about them & shouldn't // assume the entity is safe to delete. PostUpdateCommands.RemoveComponent <SpawnRandomInSphere>(e); spawnPositions.Dispose(); entities.Dispose(); }); }