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());
}