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