protected override void OnUpdate() { var finalHp = -1; Entities.With(damageQuery).ForEach((Entity damageEntity, ref DamagePlayerData damageData) => { var damage = damageData.Amount; Entities.With(playerQuery).ForEach((Entity playerEntity, ref PlayerData playerData) => { var newHp = playerData.Hp - damage; if (newHp < 0) { newHp = 0; } playerData.Hp = newHp; finalHp = newHp; }); } ); if (finalHp == 0) { var e = PostUpdateCommands.CreateEntity(gameFinishedArchetype); PostUpdateCommands.SetComponent(e, new GameFinishedData { PlayerWon = false }); } }
// 敵の生成 void SpawnEnemy(ref EnemySpawnSystemData data, ref EnemySpawnSystemSettings spawnSettings) { ++data.SpawnedEnemyCount; var type = UnityEngine.Random.Range(0, spawnSettings.MaxBarrageType); var pos = spawnSettings.RandomArea(); PostUpdateCommands.CreateEntity(MainECS_Manager.CommonEnemyArchetype); PostUpdateCommands.SetComponent(new Position2D { Value = pos }); PostUpdateCommands.SetComponent(new EnemyData { }); PostUpdateCommands.AddSharedComponent(MainECS_Manager.EnemyLook); PostUpdateCommands.AddSharedComponent(MainECS_Manager.EnemyCollision); switch ((BarrageType)type) { case BarrageType.CircularBullet: { PostUpdateCommands.AddSharedComponent(MainECS_Manager.BarrageSettings_CircularBullet); } break; case BarrageType.DirectionBullet: { PostUpdateCommands.AddSharedComponent(MainECS_Manager.BarrageSettings_DirectionBullet); } break; } }
void SpawnEnemy() { var state = m_State.S[0]; var oldState = Random.state; Random.state = state.RandomState; float2 spawnPosition = ComputeSpawnLocation(); state.SpawnedEnemyCount++; PostUpdateCommands.CreateEntity(TwoStickBootstrap.BasicEnemyArchetype); PostUpdateCommands.SetComponent(new Position2D { Value = spawnPosition }); PostUpdateCommands.SetComponent(new Heading2D { Value = new float2(0.0f, -1.0f) }); PostUpdateCommands.SetComponent(default(Enemy)); PostUpdateCommands.SetComponent(new Health { Value = TwoStickBootstrap.Settings.enemyInitialHealth }); PostUpdateCommands.SetComponent(new EnemyShootState { Cooldown = 0.5f }); PostUpdateCommands.SetComponent(new MoveSpeed { speed = TwoStickBootstrap.Settings.enemySpeed }); PostUpdateCommands.AddSharedComponent(TwoStickBootstrap.EnemyLook); state.RandomState = Random.state; m_State.S[0] = state; Random.state = oldState; }
private void Initialize(ref DungeonComponent dungeon, ref DynamicBuffer <EntityBufferElement> cellsBuffer) { cellsBuffer.Clear(); cellsBuffer.ResizeUninitialized(dungeon.SizeInCell.x * dungeon.SizeInCell.y); float cellWidth = GameManager.Instance().CellScale; for (int y = 0; y < dungeon.SizeInCell.y; y++) { for (int x = 0; x < dungeon.SizeInCell.x; x++) { float3 pos = float3.zero; pos.x = cellWidth * (0.5f + x); pos.y = cellWidth * (0.5f + y); Entity entity = PostUpdateCommands.CreateEntity(GameManager.Instance().CellArchetype); PostUpdateCommands.SetComponent(entity, new CellComponent { Coordinate = new int2(x, y), IsWall = true, }); PostUpdateCommands.SetComponent(entity, new Translation { Value = pos, }); PostUpdateCommands.SetComponent(entity, new Scale() { Value = cellWidth, }); } } }
protected override void OnUpdate() { Entities.WithNone <NetworkStreamInGame>() .ForEach((Entity ent, ref NetworkIdComponent id) => { PostUpdateCommands.AddComponent <NetworkStreamInGame>(ent); var req = PostUpdateCommands.CreateEntity(); if (string.IsNullOrEmpty(_session.UserId.ToString())) { PostUpdateCommands.AddComponent(req, new PlayerSpawnRequest { skillId = (short)_appConfig.GetSkillIndex(_session.MainSkill), skill2Id = (short)_appConfig.GetSkillIndex(_session.AttackSkill), skill3Id = (short)_appConfig.GetSkillIndex(_session.DefenceSkill), skill4Id = (short)_appConfig.GetSkillIndex(_session.UtilitySkill), characterId = _mainConfig.GetNameId(_session.Character.Id).Id, skinId = _session.Character.SkinType }); } else { PostUpdateCommands.AddComponent(req, new PlayerSpawnRequest { userId = _session.UserId }); } PostUpdateCommands.AddComponent(req, new SendRpcCommandRequestComponent { TargetConnection = ent }); }); }
protected override void OnUpdate() { var childrenBuffer = GetBufferFromEntity <Child>(true); Entities.With(canvasQuery).ForEach((Entity entity, CanvasSortOrder s0, DynamicBuffer <Child> b0) => { // Clear the list so that we can build a render hierarchy. batchedEntityList.Clear(); var renderBatchEntity = PostUpdateCommands.CreateEntity(renderBatchArchetype); PostUpdateCommands.SetComponent(renderBatchEntity, new RenderGroupID { Value = s0.Value }); var buffer = PostUpdateCommands.AddBuffer <RenderElement>(renderBatchEntity); RecurseChildren(in b0, in childrenBuffer); buffer.ResizeUninitialized(batchedEntityList.Count); for (int i = 0; i < buffer.Length; i++) { buffer[i] = new RenderElement { Value = batchedEntityList[i] }; } PostUpdateCommands.RemoveComponent <DirtyTag>(entity); }); }
protected override void OnUpdate() { Entities.With(_dealDamageQuery).ForEach((Entity entity, ref DealDamage dealDamage, ref Health health) => { health.value -= dealDamage.damage; PostUpdateCommands.RemoveComponent <DealDamage>(entity); if (HasSingleton <AllowTimeFade>() == false) { PostUpdateCommands.CreateEntity(EntityManager.CreateArchetype(ComponentType.ReadWrite <AllowTimeFade>())); } }); if (HasSingleton <AllowTimeFade>()) { Entities.WithAll <TimeFadeValue, TimeFadeClock>().ForEach((TimeFadeValue timeFadeValue, ref TimeFadeClock timeFadeClock) => { var curve = timeFadeValue.value; UnityEngine.Time.timeScale = curve.Evaluate(timeFadeClock.time); if (timeFadeClock.time > curve[curve.length - 1].time) { timeFadeClock.time = curve[0].time; PostUpdateCommands.DestroyEntity(GetSingletonEntity <TimeFadeValue>()); } timeFadeClock.time += UnityEngine.Time.unscaledDeltaTime; }); } }
protected override void OnUpdate() { string selectedMap = "Skeld"; Entities.ForEach((Entity entity, ref StartGameRequest cmd, ref ReceiveRpcCommandRequestComponent req) => { PostUpdateCommands.DestroyEntity(entity); UnityEngine.Debug.Log($"We received a command to start the game"); var loadSceneRequest = PostUpdateCommands.CreateEntity(); PostUpdateCommands.AddComponent(loadSceneRequest, new SceneLoadCommand { loadScene = selectedMap, unloadScene = GameStateSystem.LobbySceneName }); PostUpdateCommands.AddComponent(loadSceneRequest, new SendRpcCommandRequestComponent()); Entity sceneLoaderSingleton = PostUpdateCommands.CreateEntity(); PostUpdateCommands.AddComponent(sceneLoaderSingleton, new SceneLoaderSystem.SceneLoadInfo { sceneToLoad = selectedMap, sceneToUnload = GameStateSystem.LobbySceneName }); Entity teleportPlayers = PostUpdateCommands.CreateEntity(); PostUpdateCommands.AddComponent(teleportPlayers, new TeleportPlayersToSpawn.TeleportPlayerTimer { targetScene = selectedMap }); }); }
void SpawnFood() { var state = m_State.State[0]; var oldState = Random.state; Random.state = state.RandomState; float3 spawnPosition = ComputeSpawnLocation(); state.SpawnedFoodCount++; PostUpdateCommands.CreateEntity(SnakeBootstrap.FoodArchetype); PostUpdateCommands.SetComponent(new Position { Value = spawnPosition }); PostUpdateCommands.SetComponent(new Heading { Value = new float3(0.0f, 0f, -1.0f) }); PostUpdateCommands.SetComponent(new Health { Value = SnakeBootstrap.Settings.enemyInitialHealth }); PostUpdateCommands.SetComponent(new Food { type = FoodType.Normal, timeToLive = 15f }); PostUpdateCommands.AddSharedComponent(SnakeBootstrap.FoodLook); state.RandomState = Random.state; m_State.State[0] = state; Random.state = oldState; }
protected override void OnUpdate() { List <CardView> cardsToKill = new List <CardView>(); Entities.With(sellCardQuery).ForEach((Entity ent, CardView card, ref SellCardData sellCardData) => { PostUpdateCommands.RemoveComponent <SellCardData>(ent); int price = sellCardData.Price; Entities.With(playerQuery).ForEach((Entity playerEntity, ref PlayerData playerData) => { playerData.Coins += price; }); cardsToKill.Add(card); }); foreach (var VARIABLE in cardsToKill) { VARIABLE.Kill(); } if (cardsToKill.Count > 0) { PostUpdateCommands.CreateEntity(postResolveCardArchetype); } }
protected override void OnUpdate() { Entities.WithNone <SendRpcCommandRequestComponent>().ForEach((Entity reqEnt, ref PlayerReadyRequest req, ref ReceiveRpcCommandRequestComponent reqSrc) => { var playerId = EntityManager.GetComponentData <NetworkIdComponent>(reqSrc.SourceConnection).Value; if (!playersReady.Exists((int id) => id == playerId)) { playersReady.Add(playerId); if (playersReady.Count == GameSession.serverSession.numberOfPlayers) { Entities.WithAny <NetworkIdComponent>().ForEach((Entity connectionEntity) => { var countdownStartedRequest = PostUpdateCommands.CreateEntity(); PostUpdateCommands.AddComponent(countdownStartedRequest, new CountdownStartedRequest { CountdownSeconds = SerializedFields.singleton.startCountdownSeconds }); PostUpdateCommands.AddComponent(countdownStartedRequest, new SendRpcCommandRequestComponent { TargetConnection = connectionEntity }); }); var startCountdownEntity = PostUpdateCommands.CreateEntity(); PostUpdateCommands.AddComponent(startCountdownEntity, new StartCountdownComponent { RemainingTime = SerializedFields.singleton.startCountdownSeconds }); } } }); }
protected override void OnUpdate() { for (int i = 0; i < m_Enemies.Entity.Length; ++i) { if ((m_Enemies.Health[i].Value < 1.0f)) { var rank = m_Enemies.EnemyRank[i].Value; if (rank > 1) { PostUpdateCommands.CreateEntity(AsteroidsBootstrap.SplitEnemyArchetype); PostUpdateCommands.SetComponent(new EnemySplitData { Position = new Position2D { Value = m_Enemies.Position[i].Value }, Heading = new Heading2D { Value = m_Enemies.Heading[i].Value }, Rank = new EnemyRank { Value = --rank } }); } PostUpdateCommands.DestroyEntity(m_Enemies.Entity[i]); } } }
protected override void OnUpdate() { var cameraSector = EntityManager.GetComponentData <Sector>(camera.main); // Remove anything outside ObjectsUnloadDistance radius CameraSystem.AddRemoveGrid( cameraSector.value, WorldChunkConstants.ObjectsUnloadDistance, ref objectsFilter.sectors, (int2 sector) => { }, (int index, int2 sector) => { PostUpdateCommands.DestroyEntity(objectsFilter.entities[index]); } ); // Add any missing sector inside ObjectsVisibleDistance radius CameraSystem.AddRemoveGrid( cameraSector.value, WorldChunkConstants.ObjectsVisibleDistance, ref objectsFilter.sectors, (int2 sector) => { PostUpdateCommands.CreateEntity(archetype); PostUpdateCommands.SetComponent(new Sector(sector)); PostUpdateCommands.CreateEntity(); PostUpdateCommands.AddComponent(new WorldSectorVegetationCreateEvent() { sector = sector }); }, (int index, int2 sector) => { } ); }
void SpawnEnemy() { var wave = m_WaveSpawnState.Wave[0]; var oldState = Random.state; Random.state = wave.RandomState; wave.SpawnedEnemyCount++; float3 spawnPosition = GetSpawnLocation(); spawnPosition += new float3(0.0f, 1.0f, 0.0f); var trs = Matrix4x4.TRS(spawnPosition, Quaternion.identity, Vector3.one); PostUpdateCommands.CreateEntity(Bootstrap.Enemy1Archetype); PostUpdateCommands.SetComponent(new TransformMatrix { Value = trs }); PostUpdateCommands.SetComponent(new Position { Value = spawnPosition }); PostUpdateCommands.SetComponent(new Rotation { Value = quaternion.identity }); PostUpdateCommands.SetComponent(new Enemy { Speed = 3.7f, Health = wave.SpawnedWaveCount * (wave.SpawnedWaveCount / 2) + 1 }); PostUpdateCommands.AddSharedComponent(Bootstrap.Enemy1BodyLook); wave.RandomState = Random.state; m_WaveSpawnState.Wave[0] = wave; Random.state = oldState; }
public unsafe void LoadFITLayer(MemoryMap map) { var objectCount = GetObjectCount(0, 0, map); if (objectCount == 0) { return; } mColliders.Add(new NativeList <BlobAssetReference <Unity.Physics.Collider> >(Allocator.Persistent)); mColliders[0].ResizeUninitialized(objectCount); CreateLoadParallelJob(0, 0, map, mColliders[0]).Schedule(objectCount, 100).Complete(); for (int i = 0; i < mColliders[0].Length; i++) { var e = PostUpdateCommands.CreateEntity(mIFCArchetype); PostUpdateCommands.SetComponent(e, new IFCGuid { mValue = &map.mNames[i * 22] }); PostUpdateCommands.SetComponent(e, new IFCObjectID { Voxel = new Voxel { Layer = 0, Index = 0 }, Index = i }); PostUpdateCommands.SetComponent(e, new Unity.Physics.PhysicsCollider { Value = mColliders[0][i] }); } }
protected override void OnUpdate() { if (m_Group.CalculateLength() > 0) { EntityManager.RemoveComponent(m_Group, ComponentType.ReadWrite <DamagedDispatched>()); } new ProcessDamagedJob { DamagedQueue = m_DamagedQueue.ToConcurrent() }.Schedule(this).Complete(); while (m_DamagedQueue.TryDequeue(out var component)) { if (!(EntityManager.Exists(component.This) && EntityManager.Exists(component.Other))) { continue; } var damaged = PostUpdateCommands.CreateEntity(m_Archetype); PostUpdateCommands.SetComponent(damaged, component); PostUpdateCommands.AddComponent(component.This, new DamagedDispatched()); } }
void SpawnIsland() { var state = islandStateGroup.islandSpawnState[0]; PostUpdateCommands.CreateEntity(Bootstrap.islandArchetype); var spawnLocation = state.islandCount == 0 ? new float3(0f, -2.9392f, 0f) : state.lastPosition + GetSpawnLocation(); PostUpdateCommands.SetComponent(new Position() { Value = spawnLocation }); var randomScale = GetRandomScale(); PostUpdateCommands.SetComponent(new Scale() { Value = randomScale }); PostUpdateCommands.SetComponent(new Island()); PostUpdateCommands.AddSharedComponent(Bootstrap.islandLook); state.islandCount++; state.lastPosition = spawnLocation; state.lastSize = randomScale; islandStateGroup.islandSpawnState[0] = state; }
private void HandlePlaceBombAction(int i, PlayerInput input, Position position, Heading heading) { if (!input.PlaceBomb) { return; } // TODO: Find out which bomb type is currently selected from PlayerManager BombAsset bombAsset = BombariaBootstrap.BombManager.GetBombAsset(BombType.Normal); // TODO: Get placeBombActionCooldown from PlayerManager input.PlaceBombActionCooldown = BombariaBootstrap.Settings.placeBombActionCooldown; players.Input[i] = input; PostUpdateCommands.CreateEntity(BombariaBootstrap.BombSpawnArchetype); PostUpdateCommands.SetComponent(new BombSpawnRequest { Bomb = new Bomb { Type = bombAsset.Type, TimeBeforeIgnition = bombAsset.TimeBeforeIgnition, Energy = bombAsset.Energy }, Position = position, Heading = heading }); }
protected override void OnUpdate() { Entities.With(m_Group).ForEach((Entity e, ActionGraphAsset asset) => { ref ActionStateContainer container = ref ActionStateMapToAsset.Instance.GetContainer(asset.Asset); var index = container.AddChunk(); #if UNITY_EDITOR var eName = EntityManager.GetName(e); RunningGraphAsset.Instance.Add(asset.Asset, eName, container, index); #endif //var stateData = ActionStateData.Create(asset.Asset); //stateData.SetNodeCycle(asset.Asset.Entry, NodeCycle.Active); //TODO: 把入口入在启动逻辑中,而不是通过设置为active来处理 var entity = PostUpdateCommands.CreateEntity(); //var entity = EntityManager.CreateEntity(); var stateIndex = new ActionStateIndex(index, asset.Asset.Entry); container.SetNodeCycle(stateIndex, NodeCycle.Active); PostUpdateCommands.AddComponent(e, new ActionRunState() { InstanceID = asset.Asset.GetInstanceID(), ChunkIndex = index }); //PostUpdateCommands.AddComponent(e, new ActionGraphCreated() { }); });
protected override void OnUpdate() { EntityManager manager = World.Active.GetOrCreateManager <EntityManager>(); for (int turretIdx = 0; turretIdx < m_turretData.Length; ++turretIdx) { if (m_turretData.State[turretIdx].TimeSinceLastFire >= 1.0f && m_turretData.State[turretIdx].CanFire == 1) { ComponentTypes.TurretHeadState stateCopy = m_turretData.State[turretIdx]; Entity body = m_turretData.Parent[turretIdx].Value; Position bodyPosition = manager.GetComponentData <Position>(body); PostUpdateCommands.CreateEntity(Bootstrap.MissileArchetype); PostUpdateCommands.SetComponent(new Position { Value = new Vector3(bodyPosition.Value.x, bodyPosition.Value.y, bodyPosition.Value.z) + new Vector3(m_turretData.Positions[turretIdx].Value.x, m_turretData.Positions[turretIdx].Value.y, m_turretData.Positions[turretIdx].Value.z) }); PostUpdateCommands.SetComponent(new MoveSpeed { speed = 10.0f }); PostUpdateCommands.SetComponent(new Rotation { Value = Quaternion.Euler(0.0f, stateCopy.Angle, 0.0f) }); PostUpdateCommands.SetComponent(new ComponentTypes.MissileState { BirthTime = Time.time }); PostUpdateCommands.AddSharedComponent(Bootstrap.MissileLook); stateCopy.TimeSinceLastFire = 0.0f; m_turretData.State[turretIdx] = stateCopy; } } }
protected override void OnUpdate() { for (int index = 0; index < playerInputData.Length; index++) { PlayerInput playerInput = playerInputData.Input[index]; var position = playerInputData.Position[index].Value; var heading = playerInputData.Heading[index].Value; //TODO: Move Input.GetMouseButtonDown to PlayerInputSystem if (playerInput.CoolDownFinished && Input.GetMouseButtonDown(0)) { heading = math.normalize(playerInput.PlayerHeading); playerInput.FireCooldown = BootStrap.GameSettings.PlayerFireRate; PostUpdateCommands.CreateEntity(BootStrap.ArrowArchetype); PostUpdateCommands.SetComponent(new ArrowSpawnData { Position = new Position2D { Value = position }, Heading = new Heading2D { Value = heading } }); } playerInputData.Input[index] = playerInput; } }
void SpawnEnemy() { var state = m_State.S[0]; var oldState = UnityEngine.Random.state; UnityEngine.Random.state = state.RandomState; float3 spawnPosition = ComputeSpawnLocation(); state.SpawnedEnemyCount++; PostUpdateCommands.CreateEntity(TwoStickBootstrap.BasicEnemyArchetype); PostUpdateCommands.SetComponent(new Position { Value = spawnPosition }); PostUpdateCommands.SetComponent(new Rotation { Value = quaternion.LookRotation(new float3(0.0f, 0.0f, -1.0f), math.up()) }); PostUpdateCommands.SetComponent(new Health { Value = TwoStickBootstrap.Settings.enemyInitialHealth }); PostUpdateCommands.SetComponent(new EnemyShootState { Cooldown = 0.5f }); PostUpdateCommands.SetComponent(new MoveSpeed { speed = TwoStickBootstrap.Settings.enemySpeed }); PostUpdateCommands.AddSharedComponent(TwoStickBootstrap.EnemyLook); state.RandomState = UnityEngine.Random.state; m_State.S[0] = state; UnityEngine.Random.state = oldState; }
protected override void OnUpdate() { Settings settings = Bootstrap.Settings; int quantityToSpawn = settings.FoodCount - m_Data.Length; for (int i = 0; i < quantityToSpawn; i++) { PostUpdateCommands.CreateEntity(Bootstrap.FoodArchetype); float possibleSize = settings.ArenaSize * 10 * 0.9f; PostUpdateCommands.SetComponent(new Position { Value = new float3( Random.Range(-possibleSize / 2.0f, possibleSize / 2.0f), Random.Range(-possibleSize / 2.0f, possibleSize / 2.0f), 0.0f ) }); PostUpdateCommands.SetComponent(new Scale { Value = new float3(1.0f, 1.0f, 1.0f) }); PostUpdateCommands.SetComponent(new Size { Value = settings.FoodSize }); PostUpdateCommands.SetComponent( new Scale { Value = new float3(settings.FoodSize, settings.FoodSize, settings.FoodSize) } ); PostUpdateCommands.AddSharedComponent(Bootstrap.FoodLook); } }
protected override void OnUpdate() { for (int i = 0; i < cannonData.Length; i++) { IngridientCannon cannon = cannonData.cannons[i]; cannon.FireCooldown -= Time.deltaTime; if (cannon.CanFire) { //Fire var position = cannonData.positions[i].Value; var heading = cannonData.headings[i].Value; PostUpdateCommands.CreateEntity(BootStrap.IngredientSpawnArchetype); PostUpdateCommands.SetComponent(new IngridientSpawnData { spawnPosition = new Position2D { Value = position }, spawnHeading = new Heading2D { Value = heading }, IngridientType = Random.Range(0, BootStrap.IngredientsData.Length) //Random for now }); cannon.FireCooldown = BootStrap.GameSettings.CannonFireRate; } cannonData.cannons[i] = cannon; } }
protected override void OnUpdate() { var state = _data.State[0]; if (state.SpawnedEntitiesCount >= state.SpawnLimit) { return; } state.SpawnCooldown -= Time.deltaTime; if (state.SpawnCooldown > 0.0f) { _data.State[0] = state; return; } state.SpawnCooldown = state.SpawnInterval; state.SpawnedEntitiesCount++; _data.State[0] = state; var rnd = Random.insideUnitCircle * 3; var pos = new float3(rnd.x, Random.value * 7 + 6, rnd.y); PostUpdateCommands.CreateEntity(BoxArchetype); PostUpdateCommands.SetComponent(new Prefab { PrefabId = 0 }); PostUpdateCommands.SetComponent(new Position { Value = pos }); }
void SpawnEnemy() { var state = m_State.EnemySpawnState[0]; var settings = AsteroidsArcadeBootstrap.Settings; var spawnData = ComputeSpawnLocationAndHeading(settings); var speed = GetRandom(AsteroidsArcadeBootstrap.Settings.enemyMinSpeed, AsteroidsArcadeBootstrap.Settings.enemyMaxSpeed); PostUpdateCommands.CreateEntity(AsteroidsArcadeBootstrap.EnemyAsteroidArchetype); PostUpdateCommands.SetComponent(new EnemySubdivide { Value = 2 }); PostUpdateCommands.SetComponent(new Position2D { Value = spawnData.pos }); PostUpdateCommands.SetComponent(new Health { Value = settings.enemyHealth }); PostUpdateCommands.SetComponent(new Heading2D { Value = spawnData.heading }); PostUpdateCommands.SetComponent(default(Enemy)); PostUpdateCommands.SetComponent(new MoveSpeed { speed = speed }); PostUpdateCommands.AddSharedComponent(AsteroidsArcadeBootstrap.EnemyAsteroidBigLook); m_State.EnemySpawnState[0] = state; }
void SpawnOne() { SpawnerState state = _state.CurrentState[0]; float3 spawnPosition = GetRandomPosition(); state.CurrentCount++; Debug.Log($"spawn new enemy at {spawnPosition}"); PostUpdateCommands.CreateEntity(Bootloader.EnemyArchveType); PostUpdateCommands.SetComponent(new Position { Value = spawnPosition }); PostUpdateCommands.SetComponent(new Rotation { Value = quaternion.LookRotation(new float3(0.0f, 0.0f, -1.0f), math.up()) }); PostUpdateCommands.SetComponent(new MoveSpeed { Speed = GameSettings.ENEMY_SPEED }); PostUpdateCommands.SetComponent(new Health { Value = GameSettings.ENEMY_HP }); PostUpdateCommands.AddSharedComponent(Bootloader.EnemyPrefab); // PostUpdateCommands.AddSharedComponent(Bootloader.EnemyPrefab); _state.CurrentState[0] = state; }
protected override void OnUpdate() { var settings = AsteroidsArcadeBootstrap.Settings; float dt = Time.deltaTime; for (int index = 0; index < m_Data.Length; ++index) { var moveForce = m_Data.MoveForce[index].Value; var heading = m_Data.Heading[index].Value; var position = m_Data.Position[index].Value; var playerInput = m_Data.Input[index]; if (playerInput.Move.y > 0) { moveForce += playerInput.Move.y * heading * settings.playerMoveSpeed * dt; } moveForce -= moveForce * dt * settings.playerInteriaFade; heading += Rotate(heading, -playerInput.Move.x * dt * settings.playerLookSpeed); heading = math.normalize(heading); //Player fires weapon if (playerInput.Fire) { playerInput.FireCooldown = settings.playerFireCoolDown; PostUpdateCommands.CreateEntity(AsteroidsArcadeBootstrap.ShotSpawnArchetype); PostUpdateCommands.SetComponent(new ShotSpawnData { Shot = new Shot { TimeToLive = settings.bulletTimeToLive }, Position = new Position2D { Value = position }, Heading = new Heading2D { Value = heading } }); } position += moveForce * dt; m_Data.Position[index] = new Position2D { Value = position }; m_Data.MoveForce[index] = new MoveForce { Value = moveForce }; m_Data.Heading[index] = new Heading2D { Value = heading }; m_Data.Input[index] = playerInput; } }
protected override void OnUpdate() { float deltaTime = Time.deltaTime; for (int i = 0; i < this._group.Length; ++i) { var playerSettings = this._group.PlayerSettings[i]; var pos = this._group.Position[i].Value; var input = this._group.Input[i]; var movable = playerSettings.MovableAreaInstance; pos = new float2(MainECS_Manager.WorldMousePosision.x, MainECS_Manager.WorldMousePosision.z); if (pos.x <= movable.xMin) { pos.x = movable.xMin; } else if (pos.x > movable.xMax) { pos.x = movable.xMax; } if (pos.y <= movable.yMin) { pos.y = movable.yMin; } else if (pos.y > movable.yMax) { pos.y = movable.yMax; } var retPos = new Position2D { Value = pos }; if (input.Fire == 1) { input.FireCooldown = playerSettings.ShootSettingsInstance.FireCooldown; PostUpdateCommands.CreateEntity(MainECS_Manager.PlayerBulletArchetype); PostUpdateCommands.SetComponent(retPos); PostUpdateCommands.SetComponent( new BulletData { ShotSpeed = playerSettings.ShootSettingsInstance.ShotSpeed, // 上方向固定で発射 ShotAngle = 90, Lifespan = playerSettings.ShootSettingsInstance.Lifespan }); PostUpdateCommands.AddSharedComponent(MainECS_Manager.PlayerBulletLook); PostUpdateCommands.AddSharedComponent(MainECS_Manager.BulletCollision); } this._group.Position[i] = retPos; this._group.Input[i] = input; } }
public void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo) { Debug.Log("[SERVER] peer disconnected " + peer.EndPoint + ", info: " + disconnectInfo.Reason); clientList.RemoveAll(client => client.Id == peer.Id); var hashcode = (int)peer.Tag; var entity = PostUpdateCommands.CreateEntity(); PostUpdateCommands.AddComponent(entity, new DestroyPlayer()); }