protected override void OnUpdate()
{
Entities
.WithNone <HasName>()
.ForEach((Entity entity, ref SetName setName) =>
{
#if UNITY_EDITOR
EntityManager.SetName(entity, setName.Value.ToString());
#endif
PostUpdateCommands.AddComponent <HasName>(entity);
});
}
protected override void OnUpdate()
{
Entities.WithNone <NetworkStreamInGame>().ForEach((Entity ent, ref NetworkIdComponent id) =>
{
PostUpdateCommands.AddComponent <NetworkStreamInGame>(ent);
var req = PostUpdateCommands.CreateEntity();
PostUpdateCommands.AddComponent <GoInGameRequest>(req);
PostUpdateCommands.AddComponent(req, new SendRpcCommandRequestComponent {
TargetConnection = ent
});
});
}
private void CreatePlayers(Game game)
{
var query = GetEntityQuery(typeof(Player));
EntityManager.DestroyEntity(query);
for (int i = 0; i < game.playerCount; i++)
{
var e = PostUpdateCommands.CreateEntity();
PostUpdateCommands.AddComponent <Player>(e, new Player());
}
}
protected override void OnUpdate()
{
actionCheck = GetEntityQuery(actorQuery);
readyQuery = GetEntityQuery(readyQueue);
if (actionCheck.CalculateLength() == 0 && readyQuery.CalculateLength() != 0)
{
int pret = -1;
int number = 1;
var initiatives = readyQuery.ToComponentDataArray <Initiative>(Allocator.TempJob);
var type = readyQuery.ToComponentDataArray <UnitType>(Allocator.TempJob);
var entities = readyQuery.ToEntityArray(Allocator.TempJob);
for (int i = 0; i < initiatives.Length; i++)
{
if (initiatives[i].value <= currentInitiative && initiatives[i].value > pret)
{
pret = initiatives[i].value;
number = i;
}
}
PostUpdateCommands.RemoveComponent <ReadyToAction>(entities[number]);
PostUpdateCommands.AddComponent <Action>(entities[number], new Action()
{
});
var pos = EntityManager.GetComponentData <Translation>(entities[number]);
animationManager.instance.DestroyMassAnimationInstance(new animationManager.particleAnimation()
{
name = "UnitCircle", position = new Vector3(pos.Value.x, pos.Value.y, -30)
});
animationManager.instance.CreateMassAnimationName(new animationManager.particleAnimation()
{
name = "UnitCircle", position = new Vector3(pos.Value.x, pos.Value.y, -30)
}, EntityManager.GetSharedComponentData <Team>(entities[number]).value, true);
//UnityEngine.Debug.Log(entities[number]);
Entities.WithAll <CloseUp>().ForEach(
(Entity id) =>
{
PostUpdateCommands.SetComponent(id, new View()
{
state = 0, frame = 0
});
PostUpdateCommands.SetComponent(id, new UnitType()
{
index = type[number].index
});
}
);
type.Dispose();
initiatives.Dispose();
entities.Dispose();
}
}
protected override void OnUpdate()
{
NativeQueue <TileData> nativeQueue = new NativeQueue <TileData>(Allocator.TempJob);
CopyTileJob copyTileJob = new CopyTileJob {
nativeQueue = nativeQueue.ToConcurrent()
};
JobHandle jobHandle = copyTileJob.Schedule(this);
jobHandle.Complete();
NativeArray <TileData> nativeArray = new NativeArray <TileData>(nativeQueue.Count, Allocator.TempJob);
NativeQueueToArrayJob nativeQueueToArrayJob = new NativeQueueToArrayJob {
nativeQueue = nativeQueue,
nativeArray = nativeArray,
};
jobHandle = nativeQueueToArrayJob.Schedule();
jobHandle.Complete();
nativeQueue.Dispose();
var camera = Camera.main;
//if (camera != null && Input.GetMouseButtonDown(0))
{
var mousePosition = Input.mousePosition;
var cameraRay = camera.ScreenPointToRay(mousePosition);
Entities.WithAll <HexTileHightlightComponent>().ForEach((Entity entity) => {
PostUpdateCommands.RemoveComponent <HexTileHightlightComponent>(entity);
});
var deltaTime = Time.deltaTime;
if (UnityEngine.Physics.Raycast(cameraRay, out var closestHit, float.PositiveInfinity))
{
Vector3 mapPos = new Vector3(closestHit.point.x, 0, closestHit.point.z);
CubeIndex index = HexUtils.FromPosition(mapPos, Bootstrap.Defines.TileRadius);
Debug.DrawLine(Vector3.zero, closestHit.point, Color.red, 2.5f);
for (int i = 0; i < nativeArray.Length; i++)
{
if (nativeArray[i].index.Equals(index))
{
PostUpdateCommands.AddComponent(nativeArray[i].entity, new HexTileHightlightComponent());
break;
}
}
}
}
nativeArray.Dispose();
}
protected override void OnUpdate()
{
if (HasSingleton <NetworkStreamConnection>() && !HasSingleton <NetworkIdComponent>() && SendCount > 0)
{
var req = PostUpdateCommands.CreateEntity();
PostUpdateCommands.AddComponent <SimpleRpcCommand>(req);
PostUpdateCommands.AddComponent(req,
new SendRpcCommandRequestComponent {
TargetConnection = Entity.Null
});
--SendCount;
}
}
// This may raise eyebrows from a Unity developer who hasn't used DOTS.
// But a Component System only runs under specific conditions and this conditions are
// only met once in this case. Which is having an Entity with all Components from the Query executed.
protected override void OnUpdate()
{
if (GameManager.Instance.IsRunning)
{
return;
}
Entities.ForEach((Entity entity, ref IsMoving tag) =>
{
PostUpdateCommands.AddComponent <WaitingForSetup>(entity);
PostUpdateCommands.RemoveComponent <IsMoving>(entity);
});
}
protected override void OnUpdate()
{
if (!Input.GetButtonUp("Jump"))
{
return;
}
Entities.With(player).ForEach(entity => {
PostUpdateCommands.RemoveComponent <JumpLaunch>(entity);
PostUpdateCommands.AddComponent <JumpEnd>(entity, new JumpEnd {
});
});
}
protected override void OnUpdate()
{
Entities
.WithAll <NetworkEntity>()
.WithNone <NetworkEntityRegistered>()
.ForEach((Entity entity, ref NetworkEntity networkEntity) =>
{
ServerManager.Instance.Register(networkEntity.networkEntityId, entity);
PostUpdateCommands.AddComponent <NetworkEntityRegistered>(entity);
PostUpdateCommands.AddComponent <TransferNetworkEntityToAllClients>(entity);
});
}
protected override void OnUpdate()
{
var r_entity = rocket.GetEntityArray();
var r_fuel = rocket.GetComponentDataArray <RocketActive>();
for (int i = 0; i < rocket.CalculateLength(); i++)
{
PostUpdateCommands.RemoveComponent <RocketActive>(r_entity[i]);
PostUpdateCommands.AddComponent <RocketInactive>(r_entity[i], new RocketInactive {
Value = r_fuel[i].Value
});
}
}
protected override void OnUpdate()
{
for (int i = 0; i < blocksGroup.Length; i++)
{
float dist = math.distance(playerGroup.playerPos[0].Value, blocksGroup.blockPos[i].Value);
if (dist < 1)
{
/*PostUpdateCommands.DestroyEntity(blocksGroup.entityArray[i]);*/
PostUpdateCommands.AddComponent(blocksGroup.entityArray[i], new Fly());
}
}
}
protected override void OnUpdate()
{
Entities.With(player).ForEach((Entity entity, ref JumpLaunch launch) => {
if (launch.Value > 0)
{
return;
}
PostUpdateCommands.RemoveComponent <JumpLaunch>(entity);
PostUpdateCommands.AddComponent <JumpEnd>(entity, new JumpEnd {
});
});
}
protected override void OnUpdate()
{
Entities.ForEach((Entity entity, ref IsMoving isMovingTag, ref AirplaneComponent airplane) =>
{
if (airplane.IsDead)
{
GameManager.Instance.PlaneDestroyed();
airplane.IsDead = false;
PostUpdateCommands.AddComponent <WaitingForSetup>(entity);
PostUpdateCommands.RemoveComponent <IsMoving>(entity);
}
});
}
protected override void OnUpdate()
{
if (SendCount > 0)
{
var req = PostUpdateCommands.CreateEntity();
PostUpdateCommands.AddComponent(req, Cmd);
PostUpdateCommands.AddComponent(req,
new SendRpcCommandRequestComponent {
TargetConnection = Entity.Null
});
--SendCount;
}
}
protected override void OnUpdate()
{
var j_entity = jump.GetEntityArray();
var j_timer = jump.GetComponentDataArray <JumpAccelerationTimer> ();
for (int i = 0; i < jump.CalculateLength(); i++)
{
PostUpdateCommands.RemoveComponent <JumpReady>(j_entity[i]);
PostUpdateCommands.AddComponent <Jumping> (j_entity[i], new Jumping {
Value = j_timer[i].Value
});
}
}
protected override void OnUpdate()
{
for (var i = 0; i < data.Length; i++)
{
var entityId = data.SpatialEntityIds[i].EntityId;
var responses = data.PlayerHeartbeatResponses[i].Responses;
var entity = data.Entities[i];
foreach (var response in responses)
{
if (response.StatusCode != StatusCode.Success)
{
var failedHeartbeatsComponent = EntityManager.HasComponent <HeartbeatData>(entity)
? EntityManager.GetComponentData <HeartbeatData>(entity)
: new HeartbeatData();
failedHeartbeatsComponent.NumFailedHeartbeats++;
if (EntityManager.HasComponent <HeartbeatData>(entity))
{
PostUpdateCommands.SetComponent(entity, failedHeartbeatsComponent);
}
else
{
PostUpdateCommands.AddComponent(entity, failedHeartbeatsComponent);
}
Debug.LogFormat(Messages.FailedHeartbeat, entityId,
failedHeartbeatsComponent.NumFailedHeartbeats,
PlayerLifecycleConfig.MaxNumFailedPlayerHeartbeats);
if (failedHeartbeatsComponent.NumFailedHeartbeats >=
PlayerLifecycleConfig.MaxNumFailedPlayerHeartbeats)
{
Debug.LogFormat(Messages.DeletingPlayer, entityId);
data.WorldCommandSenders[i].RequestsToSend.Add(new WorldCommands.DeleteEntity.Request
{
EntityId = entityId,
});
}
}
else
{
if (EntityManager.HasComponent <HeartbeatData>(entity))
{
PostUpdateCommands.RemoveComponent <HeartbeatData>(entity);
}
}
}
PostUpdateCommands.RemoveComponent <AwaitingHeartbeatResponseTag>(entity);
}
}
private void KillUnit(Entity unit)
{
EntityQuery thanatosQ = GetEntityQuery(typeof(SoulEater), typeof(HP), typeof(Attack));
if (thanatosQ.CalculateLength() > 0)
{
var thanatosA = thanatosQ.ToEntityArray(Allocator.TempJob);
foreach (var thanatos in thanatosA)
{
var thanatosAttack = EntityManager.GetComponentData <Attack>(thanatos);
var thanatosHP = EntityManager.GetComponentData <HP>(thanatos);
PostUpdateCommands.SetComponent <Attack>(thanatos, new Attack()
{
amountOfCubes = thanatosAttack.amountOfCubes + 1, index = thanatosAttack.index, typeOfCubes = thanatosAttack.typeOfCubes
});
PostUpdateCommands.SetComponent <HP>(thanatos, new HP()
{
startValue = thanatosHP.startValue, currentValue = thanatosHP.currentValue + 8
});
}
thanatosA.Dispose();
thanatosQ.Dispose();
}
int targetId = EntityManager.GetComponentData <Id>(unit).value;
if (SquadsManagement.instance.userSquad.ContainsKey(targetId))
{
SquadsManagement.instance.userSquad.Remove(targetId);
SquadsManagement.instance.userScrollListContent.GetComponent <RectTransform>().sizeDelta = new Vector2(0, SquadsManagement.instance.userSquad.Count * 280);
foreach (var card in SquadsManagement.instance.allCards)
{
if (SquadsManagement.instance.userSquad.ContainsKey(card.Key) && card.Value.transform.localPosition.y < SquadsManagement.instance.allCards[targetId].transform.localPosition.y)
{
card.Value.transform.localPosition += new Vector3(0, 280, 0);
}
}
GameObject.Destroy(SquadsManagement.instance.allCards[targetId]);
}
PostUpdateCommands.RemoveComponent <Unit>(unit);
PostUpdateCommands.RemoveComponent <Action>(unit);
PostUpdateCommands.AddComponent(unit, new View()
{
frame = 0, state = 0
});
PostUpdateCommands.AddComponent(unit, new Dead()
{
});
PostUpdateCommands.AddComponent(unit, new UnitAnimation()
{
});
}
private void Shoot(AudioSource audio, Light light, ParticleSystem particles, LineRenderer line)
{
timer = 0f;
audio.Play();
light.enabled = true;
particles.Stop();
particles.Play();
var go = audio.gameObject;
var pos = go.transform.position;
line.enabled = true;
line.SetPosition(0, pos);
var shootRay = new Ray
{
origin = pos,
direction = go.transform.forward
};
RaycastHit shootHit;
if (Physics.Raycast(shootRay, out shootHit, SurvivalShooterBootstrap.Settings.GunRange,
LayerMask.GetMask("Shootable")))
{
var goEntity = shootHit.collider.gameObject.GetComponent <GameObjectEntity>();
if (goEntity != null)
{
var hitEntity = shootHit.collider.gameObject.GetComponent <GameObjectEntity>().Entity;
var entityManager = World.EntityManager;
if (!entityManager.HasComponent <DamagedData>(hitEntity))
{
PostUpdateCommands.AddComponent(hitEntity, new DamagedData
{
Damage = SurvivalShooterBootstrap.Settings.DamagePerShot,
HitPoint = shootHit.point
});
}
}
line.SetPosition(1, shootHit.point);
}
else
{
line.SetPosition(1, shootRay.origin + shootRay.direction * SurvivalShooterBootstrap.Settings.GunRange);
}
}
protected override void OnUpdate()
{
for (int i = 0; i < _playerData.Length; i++)
{
var Modifyer = _playerData.CModify[i];
for (int j = 0; j < _data.Length; j++)
{
if (Input.GetKeyDown(KeyCode.U) && _playerData.Lists[i].Equiables.Count != 0)
{
if (!EntityManager.HasComponent <DynamicImageTag>(_imageData._Entity[j]) &&
!EntityManager.HasComponent <DynamicButtonTag>(_buttonData._EntityY[j]))
{
if (EntityManager.HasComponent <DynamicEquipmentTag>(_data._EEntity[j]) &&
EntityManager.HasComponent <DynamicMeshTag>(_armorMeshData._EntitY[j]))
{
//this system basically reverses what the InventoryAddSystem and the EquipmentUpdateSystem and the EquipmentSystem have done
//if you have not been in the InventoryAddSystem AND the EquipmentUpdateSystem you will not know what these tags are for
PostUpdateCommands.AddComponent(_imageData._Entity[j], new DynamicImageTag());
PostUpdateCommands.AddComponent(_buttonData._EntityY[j], new DynamicButtonTag());
PostUpdateCommands.RemoveComponent <DynamicMeshTag>(_armorMeshData._EntitY[j]);
PostUpdateCommands.RemoveComponent <DynamicEquipmentTag>(_data._EEntity[j]);
_imageData.Images[j].sprite = _data.Sprites[j].Icon;
_playerData.Lists[i].Items.Add(_data.selection[j]);
_playerData.Lists[i].Equiables.Remove(_data.Equiables[j]);
_imageData.Images[j].enabled = true;
_buttonData.RemoveButt[j].interactable = true;
_armorMeshData.ArmorMesh[j].sharedMesh = null;
Modifyer.AttackModifier = _data.Stats[j].AttackDamage;
Modifyer.ProtectionModifier = _data.Stats[j].protection;
if (Modifyer.ProtectionModifier != 0)
{
_playerData.Lists[i].ProtectionModifiers.Clear();
Modifyer.FinalProtectionModifier = 5;
_playerData.CModify[i] = Modifyer;
}
if (Modifyer.AttackModifier != 0)
{
_playerData.Lists[i].AttackModifiers.Clear();
Modifyer.FinalAttackModifier = 2;
_playerData.CModify[i] = Modifyer;
}
}
}
}
}
}
}
protected override RetargetData CreateGraph(Entity entity, ref Rig rig, PreAnimationGraphSystem graphSystem, ref RetargetSetup setup)
{
var set = graphSystem.Set;
var debugEntity = RigUtils.InstantiateDebugRigEntity(
setup.SrcRig,
EntityManager,
new BoneRendererProperties { BoneShape = BoneRendererUtils.BoneShape.Line, Color = new float4(0f, 1f, 0f, 0.5f), Size = 1f }
);
if (EntityManager.HasComponent<Translation>(entity))
{
PostUpdateCommands.AddComponent(
debugEntity,
EntityManager.GetComponentData<Translation>(entity)
);
}
var data = new RetargetData();
data.DeltaTimeNode = set.Create<DeltaTimeNode>();
data.ClipPlayerNode = set.Create<ClipPlayerNode>();
data.RemapperNode = set.Create<RigRemapperNode>();
data.EntityNode = set.CreateComponentNode(entity);
data.DebugEntityNode = set.CreateComponentNode(debugEntity);
set.SetData(data.ClipPlayerNode, ClipPlayerNode.KernelPorts.Speed, 1.0f);
// Connect kernel ports
set.Connect(data.DeltaTimeNode, DeltaTimeNode.KernelPorts.DeltaTime, data.ClipPlayerNode, ClipPlayerNode.KernelPorts.DeltaTime);
set.Connect(data.ClipPlayerNode, ClipPlayerNode.KernelPorts.Output, data.RemapperNode, RigRemapperNode.KernelPorts.Input);
// Connect EntityNode
set.Connect(data.RemapperNode, RigRemapperNode.KernelPorts.Output, data.EntityNode);
// Connect DebugEntityNode
set.Connect(data.ClipPlayerNode, ClipPlayerNode.KernelPorts.Output, data.DebugEntityNode);
// Send messages
set.SendMessage(data.ClipPlayerNode, ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration { Mask = ClipConfigurationMask.LoopTime });
set.SendMessage(data.ClipPlayerNode, ClipPlayerNode.SimulationPorts.Rig, new Rig { Value = setup.SrcRig });
set.SendMessage(data.ClipPlayerNode, ClipPlayerNode.SimulationPorts.Clip, setup.SrcClip);
set.SendMessage(data.RemapperNode, RigRemapperNode.SimulationPorts.SourceRig, new Rig { Value = setup.SrcRig });
set.SendMessage(data.RemapperNode, RigRemapperNode.SimulationPorts.DestinationRig, rig);
set.SendMessage(data.RemapperNode, RigRemapperNode.SimulationPorts.RemapTable, setup.RemapTable);
PostUpdateCommands.AddComponent(entity, graphSystem.Tag);
PostUpdateCommands.AddComponent(debugEntity, graphSystem.Tag);
return data;
}
private void Send <T>(Entity connection, NativeList <T> list) where T : struct, IRpcCommand
{
for (int j = 0; j < list.Length; j++)
{
T msg = list[j];
Entity ack = PostUpdateCommands.CreateEntity();
PostUpdateCommands.AddComponent(ack, new SendRpcCommandRequestComponent
{
TargetConnection = connection
});
PostUpdateCommands.AddComponent(ack, msg);
}
}
private void AddHealthRegenData(int i)
{
var healthRegenComponent = needData.HealthRegenComponents[i];
var regenData = new HealthRegenData();
if (healthRegenComponent.DamagedRecently)
{
regenData.DamagedRecentlyTimer = healthRegenComponent.RegenCooldownTimer;
regenData.NextSpatialSyncTimer = healthRegenComponent.CooldownSyncInterval;
}
PostUpdateCommands.AddComponent(needData.Entities[i], regenData);
}
protected override void OnUpdate()
{
//Debug.LogError("in onpudate in goingamesystem");
Entities.WithNone <NetworkStreamInGame>().ForEach((Entity ent, ref NetworkIdComponent id) =>
{
//Debug.LogError(" Inside ForEach of goingamesystem");
PostUpdateCommands.AddComponent <NetworkStreamInGame>(ent);
var req = PostUpdateCommands.CreateEntity();
PostUpdateCommands.AddComponent <GoInGameRequest>(req);
PostUpdateCommands.AddComponent(req, new SendRpcCommandRequestComponent {
TargetConnection = ent
});
});
}
protected override void OnUpdate()
{
Entities.ForEach((Entity entity, ref SceneLoadCommand cmd, ref ReceiveRpcCommandRequestComponent req) =>
{
PostUpdateCommands.DestroyEntity(entity);
UnityEngine.Debug.Log($"We received a command - Load Scene {cmd.loadScene} - Unload Scene { cmd.unloadScene }");
Entity sceneLoaderSingleton = PostUpdateCommands.CreateEntity();
PostUpdateCommands.AddComponent(sceneLoaderSingleton, new SceneLoaderSystem.SceneLoadInfo
{
sceneToLoad = cmd.loadScene,
sceneToUnload = cmd.unloadScene
});
});
}
protected override void OnUpdate()
{
for (var i = 0; i < data.Length; i++)
{
var entity = data.Entites[i];
PostUpdateCommands.AddComponent(entity, CameraComponentDefaults.Input);
PostUpdateCommands.AddComponent(entity, CameraComponentDefaults.Transform);
Cursor.lockState = CursorLockMode.Locked;
// Disable system after first run.
Enabled = false;
}
}
// This may raise eyebrows from a Unity developer who hasn't used DOTS.
// But a Component System only runs under specific conditions and this conditions are
// only met once in this case. Which is having an Entity with all Components from the Query executed.
protected override void OnUpdate()
{
Entities.ForEach((Entity entity, ref Translation translation, ref BulletComponent bullet, ref IsMoving tag) =>
{
float3 bulletLimits = translation.Value;
bulletLimits.x -= bullet.Size * 0.5f;
bulletLimits.y -= bullet.Size * 0.5f;
if (bulletLimits.x >= _screenMaxLimits.x || bulletLimits.y >= _screenMaxLimits.y)
{
PostUpdateCommands.AddComponent <WaitingForSetup>(entity);
PostUpdateCommands.RemoveComponent <IsMoving>(entity);
}
});
}
protected override void OnUpdate()
{
Entities.WithNone <HitboxElement>().ForEach((Entity ent, ref Sword sword) => {
EntityManager.AddBuffer <HitboxElement>(ent);
});
//Debug.LogError("in onpudate in goingamesystem");
Entities.WithNone <ClientInit>().ForEach((Entity ent, ref StabHitbox stab, ref AssociatedEntity sword) =>
{
var buffer = EntityManager.GetBuffer <HitboxElement>(sword.Value).Reinterpret <Entity>();
buffer.Add(ent);
PostUpdateCommands.AddComponent <ClientInit>(ent);
});
}
protected override void OnUpdate()
{
if (!_meshesForCreating.IsEmptyIgnoreFilter)
{
Entities.With(_meshesForCreating).ForEach(_cachedForEach);
PostUpdateCommands.AddComponent(_meshesForCreating, ComponentType.ReadOnly <MeshInitialized>());
}
if (!_removedMeshes.IsEmptyIgnoreFilter)
{
Entities.With(_removedMeshes).ForEach(entity => _resourcesMapping.Meshes.Remove(entity));
PostUpdateCommands.RemoveComponent(_removedMeshes, ComponentType.ReadOnly <MeshInitialized>());
}
}
protected override void OnUpdate()
{
Entities.WithNone <Cooldown, UnitAnimation>().WithAll <Unit, Action>().ForEach
(
(Entity id, ref Skill s) =>
{
PostUpdateCommands.AddComponent <UnitAnimation>(id, new UnitAnimation());
PostUpdateCommands.RemoveComponent <Action>(id);
animationManager.instance.currentEntity = id;
//animationManager.instance.ShowSkillScroll(s.skill.ToString());
Spawner.publicSP.chooseSkill(s.skill, EntityManager, PostUpdateCommands, id);
}
);
}
protected override void OnUpdate()
{
if (!init)
{
var random = new Unity.Mathematics.Random(853);
var ghostCollection = GetSingleton <GhostPrefabCollectionComponent>();
var ghostId = whalesGhostSerializerCollection.FindGhostType <BoidSnapshotData>();
var prefab = EntityManager.GetBuffer <GhostPrefabBuffer>(ghostCollection.serverPrefabs)[ghostId].Value;
for (int i = 0; i < Bootstrap.Instance.boidCount; ++i)
{
var boid = EntityManager.Instantiate(prefab);
EntityManager.SetComponentData(boid, new Translation {
Value = random.NextFloat3(1f)
});
EntityManager.SetComponentData(boid, new Rotation {
Value = quaternion.identity
});
EntityManager.SetComponentData(boid, new Velocity {
Value = random.NextFloat3Direction() * Bootstrap.Param.initSpeed
});
EntityManager.SetComponentData(boid, new Acceleration {
Value = float3.zero
});
EntityManager.AddBuffer <NeighborsEntityBuffer>(boid);
}
init = true;
}
Entities.WithNone <SendRpcCommandRequestComponent>().ForEach((Entity reqEnt, ref GoInGameRequest req, ref ReceiveRpcCommandRequestComponent reqSrc) =>
{
PostUpdateCommands.AddComponent <NetworkStreamInGame>(reqSrc.SourceConnection);
UnityEngine.Debug.Log(string.Format("Server setting connection {0} to in game", EntityManager.GetComponentData <NetworkIdComponent>(reqSrc.SourceConnection).Value));
var ghostCollection = GetSingleton <GhostPrefabCollectionComponent>();
var playerGhostId = whalesGhostSerializerCollection.FindGhostType <WhaleSnapshotData>();
var playerPrefab = EntityManager.GetBuffer <GhostPrefabBuffer>(ghostCollection.serverPrefabs)[playerGhostId].Value;
var player = EntityManager.Instantiate(playerPrefab);
EntityManager.SetComponentData(player, new PlayerComponent {
PlayerId = EntityManager.GetComponentData <NetworkIdComponent>(reqSrc.SourceConnection).Value
});
PostUpdateCommands.AddBuffer <InputCommandData>(player);
PostUpdateCommands.SetComponent(reqSrc.SourceConnection, new CommandTargetComponent {
targetEntity = player
});
PostUpdateCommands.DestroyEntity(reqEnt);
});
}