public unsafe int GetPoints(int i, float3 *dest) { Unity.Mathematics.Random rng = new Unity.Mathematics.Random(m_Seeds[i]); GetResolution(ref rng, out int res0, out int res1); float scale = rng.NextBool() ? 1.0f : rng.NextFloat(1.0f, 5.0f); float radius = rng.NextFloat(0.01f, 1.0f / scale); // Generate points int numPoints; if (res1 == 0) { // Random scattered points for (int iPoint = 0; iPoint < res0; iPoint++) { dest[iPoint] = math.normalize(rng.NextFloat3(-1, 1)) * radius; } numPoints = res0; } else { // Spherical coordinates int iPoint = 0; for (int iPhi = 0; iPhi < res0; iPhi++) { float phi = (2 * iPhi + 1) * math.PI / res0; float sinPhi = math.sin(phi); float cosPhi = math.cos(phi); for (int iTheta = 0; iTheta < res1; iTheta++) { float theta = 0.5f * (2 * iTheta + 1) * math.PI / res1; float sinTheta = math.sin(theta); float cosTheta = math.cos(theta); dest[iPoint++] = new float3(radius * sinTheta * cosPhi, radius * sinTheta * sinPhi, radius * cosTheta); } } numPoints = iPoint; } // Offset, scale and rotate float3 center = rng.NextBool() ? float3.zero : rng.NextFloat3(1.0f); quaternion orientation = rng.NextBool() ? quaternion.identity : rng.NextQuaternionRotation(); for (int iPoint = 0; iPoint < numPoints; iPoint++) { dest[iPoint] = math.mul(orientation, dest[iPoint] * new float3(scale, 1, 1) + center); } return(numPoints); }
public void ControllerManater_update() { var random = new Random(); random.InitState(1234567); using (var buffer = new NativeList <ControllerUnit>(ControllerBuffer.MaxFrames, Allocator.Persistent)) { const int NUM = 10; double time = 0; var file_path0 = Application.dataPath + "/../tmp.txt"; using (System.IO.StreamWriter sw = new System.IO.StreamWriter(file_path0)) { var device = new ControllerDevice(buffer); for (var i = 0; i < NUM; ++i) { var ppos = random.NextFloat3(); var tpos = random.NextFloat3(); device.Update(time, ppos, tpos, true /* testing */); time += 1.0 / 60.0; var unit = device.GetCurrent(); sw.WriteLine(unit.ToString()); } Assert.AreEqual(NUM, buffer.Length); sw.WriteLine("----"); for (var i = 0; i < buffer.Length; ++i) { var unit = buffer[i]; sw.WriteLine(unit.ToString()); } sw.WriteLine("----"); var replay = new ControllerReplay(); for (var i = 0; i < NUM * 10; ++i) { var ppos = random.NextFloat3(); var tpos = random.NextFloat3(); var unit = replay.Step(buffer, ppos, tpos); time += 1.0 / 60.0; sw.WriteLine(unit.ToString()); } } } }
void SpawnMeteor() { var elapsedFromLastSpawnedAt = Time.time - lastSpawnedAt; if (elapsedFromLastSpawnedAt < _spawnInterval) { return; } var transform = this.transform; var meteorGameObject = Instantiate(meteorPrefab, transform); var meteor = meteorGameObject.GetComponent <Meteor>(); meteor.speed = _meteorSpeed; meteor.rotationAxis = normalize(random.NextFloat3()); meteor.rotationSpeed = meteorRotationSpeedRange.x + (meteorRotationSpeedRange.x - meteorRotationSpeedRange.y) * random.NextFloat(); var meteorPosition = meteorGameObject.transform.position; var lanePosition = (Lane.Position)(Mathf.Abs(random.NextInt()) % 3); meteorPosition.x = lane.GetTargetXFromPosition(lanePosition); meteorGameObject.transform.position = meteorPosition; _spawnInterval -= _spawnInterval * spawnIntervalReductionRate * elapsedFromLastSpawnedAt; _meteorSpeed += _meteorSpeed * meteorSpeedIncreaseRate * elapsedFromLastSpawnedAt; var microStarParticleMain = microStarParticle.main; microStarParticleMain.startSpeedMultiplier = _meteorSpeed; lastSpawnedAt = Time.time; }
public void Execute(ref RandomMotion motion, [ReadOnly] ref Translation position, ref PhysicsVelocity velocity, [ReadOnly] ref PhysicsMass mass) { motion.CurrentTime += deltaTime; random.InitState((uint)(motion.CurrentTime * 1000)); var currentOffset = position.Value - motion.InitialPosition; var desiredOffset = motion.DesiredPosition - motion.InitialPosition; // If we are close enough to the destination pick a new destination if (math.lengthsq(position.Value - motion.DesiredPosition) < motion.Tolerance) { var min = new float3(-math.abs(motion.Range)); var max = new float3(math.abs(motion.Range)); desiredOffset = random.NextFloat3(min, max); motion.DesiredPosition = desiredOffset + motion.InitialPosition; } var offset = desiredOffset - currentOffset; // Smoothly change the linear velocity velocity.Linear = math.lerp(velocity.Linear, offset, motion.Speed); if (mass.InverseMass != 0) { velocity.Linear -= gravity * deltaTime; } }
protected override void OnUpdate() { var random = new Random(); float deltaTime = Time.DeltaTime; var stepComponent = HasSingleton <PhysicsStep>() ? GetSingleton <PhysicsStep>() : PhysicsStep.Default; Entities .WithName("ApplyRandomMotion") .WithBurst() .ForEach((ref RandomMotion motion, ref PhysicsVelocity velocity, in Translation position, in PhysicsMass mass) => { motion.CurrentTime += deltaTime; random.InitState((uint)(motion.CurrentTime * 1000)); var currentOffset = position.Value - motion.InitialPosition; var desiredOffset = motion.DesiredPosition - motion.InitialPosition; // If we are close enough to the destination pick a new destination if (math.lengthsq(position.Value - motion.DesiredPosition) < motion.Tolerance) { var min = new float3(-math.abs(motion.Range)); var max = new float3(math.abs(motion.Range)); desiredOffset = random.NextFloat3(min, max); motion.DesiredPosition = desiredOffset + motion.InitialPosition; } var offset = desiredOffset - currentOffset; // Smoothly change the linear velocity velocity.Linear = math.lerp(velocity.Linear, offset, motion.Speed); if (mass.InverseMass != 0) { velocity.Linear -= stepComponent.Gravity * deltaTime; } }).Schedule();
void Start() { var settings = GameObjectConversionSettings.FromWorld(World.DefaultGameObjectInjectionWorld, null); var prefab = GameObjectConversionUtility.ConvertGameObjectHierarchy(Prefab, settings); var entityManager = World.DefaultGameObjectInjectionWorld.EntityManager; var random = new Unity.Mathematics.Random(853); for (int i = 0; i < boidCount; ++i) { var instance = entityManager.Instantiate(prefab); var position = transform.TransformPoint(random.NextFloat3(1f)); entityManager.SetComponentData(instance, new Translation { Value = position }); entityManager.SetComponentData(instance, new Rotation { Value = quaternion.identity }); entityManager.SetComponentData(instance, new NonUniformScale { Value = new float3(boidScale.x, boidScale.y, boidScale.z) }); entityManager.SetComponentData(instance, new Velocity { Value = random.NextFloat3Direction() * param.initSpeed }); entityManager.SetComponentData(instance, new Acceleration { Value = float3.zero }); // Dynamic Buffer の追加 entityManager.AddBuffer <NeighborsEntityBuffer>(instance); } }
// Start is called before the first frame update void Start() { store = new BlobAssetStore(); entityManager = World.DefaultGameObjectInjectionWorld.EntityManager; var settings = GameObjectConversionSettings.FromWorld(World.DefaultGameObjectInjectionWorld, store); Entity boid = GameObjectConversionUtility.ConvertGameObjectHierarchy(boidPrefab, settings); Unity.Mathematics.Random rand = new Unity.Mathematics.Random((uint)System.DateTime.Now.Millisecond); for (int i = 0; i < boidSize; ++i) { var instance = entityManager.Instantiate(boid); float3 xyz = rand.NextFloat3(minBound, maxBound); quaternion q = rand.NextQuaternionRotation(); entityManager.SetComponentData(instance, new Translation { Value = xyz }); entityManager.SetComponentData(instance, new Rotation { Value = q }); float3 velocity = math.mul(q, new float3(0, 0, rand.NextFloat(1f, 10f))); entityManager.SetComponentData(instance, new SteerVelocity { velocity = velocity, lastVelocity = velocity }); if (entityManager.HasComponent <SteerWander>(instance)) { entityManager.AddComponentData(instance, new SteerWanderEdit() { qrot = quaternion.identity }); } } }
void Start() { random_.InitState(1234); int spawnnum = SceneManager.Num; bool first = true; while (spawnnum > 0) { var num = random_.NextInt(3, 5); var center = new float3(random_.NextFloat(-200, 200), 64f, random_.NextFloat(-200, 200)); var replay_index_center = random_.NextInt(100, 10000); for (var j = 0; j < num; ++j) { var pos = center + random_.NextFloat3(-6, 6); var replay_index = replay_index_center + random_.NextInt(20, 40) * (random_.NextBool() ? 1 : -1); var entity = FighterSystem.Instantiate(FighterManager.Prefab, pos, quaternion.identity, replay_index); if (first) { var fighterSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem <FighterSystem>(); fighterSystem.PrimaryEntity = entity; first = false; } --spawnnum; if (spawnnum > 0) { continue; } break; } } }
public void 正しく圧縮できているかチェック() { const int N = 100; //const float EPS = 0.01f; const float EPS = 1.0f; var quarArr = new Quaternion[N]; var quat32Arr = new Quaternion32[N]; var forward = new float3(0.0f, 0.0f, 1.0f); var rnd = new Random((uint)System.DateTime.Now.Ticks); for (int i = 0; i < N; ++i) { var axis = rnd.NextFloat3(); var angle = rnd.NextFloat() * math.PI; var orig = quarArr[i] = quaternion.AxisAngle(axis, angle); quat32Arr[i] = Quaternion32.Compressed(orig); var result = quat32Arr[i].Decompressed(); var ffa = math.rotate(orig, forward); var ffb = math.rotate(result, forward); Debug.Log($"ffa:{ffa}\nffb:{ffb}"); Assert.IsTrue(NearEqual(ffa, ffb, EPS), $"ffa:{ffa}\nffb:{ffb}"); } }
private void GenerateEntities() { var entityManager = World.DefaultGameObjectInjectionWorld.EntityManager; // using (var spriteEntities = new NativeArray<Entity>(entitiesToSpawn, Allocator.Temp)) var spriteEntities = new NativeArray <Entity>(entitiesToSpawn, Allocator.Temp); // { var spriteArchetype = entityManager.CreateArchetype( typeof(RenderMesh), typeof(RenderBounds), typeof(LocalToWorld), typeof(Translation)); entityManager.CreateEntity(spriteArchetype, spriteEntities); var rnd = new Unity.Mathematics.Random((uint)System.DateTime.UtcNow.Ticks); for (var i = 0; i < entitiesToSpawn; ++i) { var spriteEntity = spriteEntities[i]; entityManager.SetSharedComponentData(spriteEntity, new RenderMesh { mesh = spriteMesh, material = spriteMaterial }); entityManager.SetComponentData(spriteEntity, new Translation { Value = rnd.NextFloat3(new float3(-5, -3, 0), new float3(5, 3, 0)) }); } // } spriteEntities.Dispose(); }
void Start() { var manager = World.Active.GetOrCreateManager <EntityManager>(); var archetype = manager.CreateArchetype( typeof(Position), typeof(Rotation), typeof(Scale), typeof(Velocity), typeof(Acceleration), typeof(NeighborsEntityBuffer), typeof(MeshInstanceRenderer)); var random = new Unity.Mathematics.Random(853); for (int i = 0; i < boidCount; ++i) { var entity = manager.CreateEntity(archetype); manager.SetComponentData(entity, new Position { Value = random.NextFloat3(1f) }); manager.SetComponentData(entity, new Rotation { Value = quaternion.identity }); manager.SetComponentData(entity, new Scale { Value = new float3(boidScale.x, boidScale.y, boidScale.z) }); manager.SetComponentData(entity, new Velocity { Value = random.NextFloat3Direction() * param.initSpeed }); manager.SetComponentData(entity, new Acceleration { Value = float3.zero }); manager.SetSharedComponentData(entity, renderer); } }
public void RandomNotZero() { Unity.Mathematics.Random random = Random(); bool notZero = random.NextInt() != 0 && !random.NextFloat3().Equals(float3.zero); Assert.IsTrue(notZero); }
public void GetNextRandomPosition(out float3 pos, out quaternion rot, out float3 forward, out float2 localPos, out float speed, out int2 gridId) { int find = 0; pos = new float3(); rot = new quaternion(); forward = new float3(); gridId = new int2(); speed = 0; localPos = new float2(); float3 min = startPos - Size / 2; float3 max = startPos + Size / 2; while (find == 0) { pos = RandomGen.NextFloat3(min, max); gridId = GetGridId(pos); if (!IsWalkable(gridId)) { continue; } pos.y = 0; forward = RandomGen.NextFloat3Direction(); forward.y = 0; forward = math.normalize(forward); rot = quaternion.LookRotation(forward, new float3(0, 1, 0)); localPos = GetLocalPos(gridId, pos); speed = RandomGen.NextFloat(1.0f, 2.0f); find = 1; } return; }
protected override void SingletonAwake() { SystemsPaused = true; RenderMesh = new RenderMesh { mesh = Mesh, material = Material }; Bounds = Mesh.bounds.ToAABB(); var entityManager = World.DefaultGameObjectInjectionWorld.EntityManager; const int NumberOfBodies = 100000; var random = new Unity.Mathematics.Random(UInt32.MaxValue); var entities = entityManager.CreateEntity(Archetypes.BaseBodyArchetype, NumberOfBodies, Allocator.Temp); for (int i = 0; i < entities.Length; ++i) { var entity = entities[i]; var position = (double3)math.normalize((random.NextFloat3() * 2f) - 1f) * 100f; CreateBody(entityManager, entity, position, 0.25f); } entities.Dispose(); //TestBed(); }
public unsafe void ConvexConvexDistanceTest() { Random rnd = new Random(0x12345678); uint dbgTest = 0; int numTests = 5000; if (dbgTest > 0) { numTests = 1; } for (int i = 0; i < numTests; i++) { // Save state to repro this query without doing everything that came before it if (dbgTest > 0) { rnd.state = dbgTest; } uint state = rnd.state; // Generate random query inputs ConvexCollider *target = (ConvexCollider *)TestUtils.GenerateRandomConvex(ref rnd).GetUnsafePtr(); ConvexCollider *query = (ConvexCollider *)TestUtils.GenerateRandomConvex(ref rnd).GetUnsafePtr(); MTransform queryFromTarget = new MTransform( (rnd.NextInt(10) > 0) ? rnd.NextQuaternionRotation() : quaternion.identity, rnd.NextFloat3(-3.0f, 3.0f)); TestConvexConvexDistance(target, query, queryFromTarget, "ConvexConvexDistanceTest failed " + i + " (" + state.ToString() + ")"); } }
public void Execute(int index) { Random.InitState((uint)(Random.state + index)); Translations[index] = new Translation() { Value = Random.NextFloat3(Min, Max) }; Points[index] = new Point(Random.NextInt(PointMin, PointMax)); }
private void CreateEntities() { var rnd = new Random(12345); counter++; for (int i = 0; i < 2000; i++) { CreateEntity(rnd.NextFloat3(-value * counter, value * counter), renderMeshFrames[rnd.NextInt(0, renderMeshFrames.Count - 1)]); } }
void Update() { for (var i = 0; i < 4; ++i) { var pos = random_.NextFloat3(-100, 100); var dir = random_.NextFloat3Direction(); var rot = quaternion.LookRotation(dir, new float3(0, 1, 0)); MissileSystem.Instantiate(MissileManager.Prefab, pos, rot); } }
public void Execute() { var points = new NativeArray <float3>(1024, Allocator.Temp); var random = new Random(1234); for (var i = 0; i < points.Length; ++i) { points[i] = random.NextFloat3(new float3(-1f), new float3(1f)); } ConvexCollider.Create(points, ConvexHullGenerationParameters.Default).Release(); }
void Explode() { isRunning = false; var rigidbody = GetComponent <Rigidbody>(); rigidbody.isKinematic = false; rigidbody.AddExplosionForce(explosionForce, random.NextFloat3(), explosionRadius); explodeCompletionSource.TrySetResult(); }
void LeoECS() { _world = new EcsWorld(); JobMoveSystem.MinSpeed = param.minSpeed; JobMoveSystem.MaxSpeed = param.maxSpeed; JobMoveSystem.BoidScale = boidScale; JobMoveSystem.WallScale = param.wallScale * 0.5f; JobMoveSystem.WallDistance = param.wallDistance; JobMoveSystem.WallWeight = param.wallWeight; JobMoveSystem.NeighborFov = math.cos(math.radians(param.neighborFov)); JobMoveSystem.NeighborDistance = param.neighborDistance; JobMoveSystem.SeparationWeight = param.separationWeight; JobMoveSystem.AlignmentWeight = param.alignmentWeight; JobMoveSystem.CohesionWeight = param.cohesionWeight; JobMoveSystem.EntitiesCount = boidCount; JobMoveSystem.NumBoidsPerJob = boidCount / System.Environment.ProcessorCount; if (BoidsVisualisationSystem._nativeMatrices.IsCreated) { BoidsVisualisationSystem._nativeMatrices.Dispose(); } BoidsVisualisationSystem._nativeMatrices = new NativeArray <Matrix4x4> (boidCount, Allocator.Persistent); BoidsVisualisationSystem._matrices = new Matrix4x4[boidCount]; var timeSystem = new TimeSystem(); _systems = new EcsSystems(_world); _systems .Add(timeSystem) .Add(new BoidsSimulationSystem()) .Add(new JobMoveSystem()) .Add(new BoidsVisualisationSystem() { mesh = mesh, material = material, scale = boidScale }) .Inject(timeSystem) .Initialize(); var random = new Unity.Mathematics.Random(853); BoidEntityData.Create(boidCount); for (int i = 0; i < boidCount; ++i) { var initSpeed = param.initSpeed; //init them with these default values var boid = _world.CreateEntityWith <BoidEntityData> (); boid.id = i; boid.Position = random.NextFloat3(1f); boid.Velocity = random.NextFloat3Direction() * initSpeed;; boid.Acceleration = float3.zero; } _world.ProcessDelayedUpdates(); }
protected static void RandomPointsOnCircle(float3 center, float3 range, ref NativeArray <float3> positions, ref NativeArray <quaternion> rotations, int seed = 0) { var count = positions.Length; // initialize the seed of the random number generator var random = new Unity.Mathematics.Random((uint)seed); for (int i = 0; i < count; i++) { positions[i] = center + random.NextFloat3(-range, range); rotations[i] = random.NextQuaternionRotation(); } }
public static void SpawnParticles() { var entityManager = World.Active.GetOrCreateManager <EntityManager>(); var random = new Unity.Mathematics.Random(835483957); for (int i = 0; i < 1000; i++) { Entity particle = entityManager.CreateEntity(WaterParticleArchetype); entityManager.AddSharedComponentData(particle, WaterParticleLook); var position = random.NextFloat3() * Constants.MAX_WORLD_SIZE - Constants.HIGH_WORLD_EDGE; position.y = 0; var velocity = random.NextFloat3() * 4f - 2; velocity.y = 0; float lifeTime = random.NextFloat() * Constants.PARTICLE_LIFETIME; float scaleX = random.NextFloat() * .3f + 0.3f; float scaleZ = random.NextFloat() * 1.5f + 0.8f; var angle = random.NextFloat() * 180; var q = quaternion.RotateY(angle); entityManager.SetComponentData(particle, new Scale { Value = new float3(scaleX, 0.1f, scaleZ) }); entityManager.SetComponentData(particle, new Position { Value = position }); entityManager.SetComponentData(particle, new Rotation { Value = q }); entityManager.SetComponentData(particle, new VelocityComponent { Value = new float3(1, 0, 0) }); entityManager.SetComponentData(particle, new ParticleComponent { LifeTimeLeft = lifeTime }); } }
void Start() { var rand = new Unity.Mathematics.Random(_randomSeed); var parent = transform; var rot = quaternion.identity; for (var i = 0; i < _instanceCount; i++) { var pos = (rand.NextFloat3() - 0.5f) * _extent; pos = parent.TransformPoint(pos); Instantiate(_prefab, pos, rot, parent); } }
public override void ProcessFrame(Playable playable, FrameData info, object playerData) { var target = playerData as Transform; if (target == null) { return; } var t = (float)playable.GetTime(); var id = (uint)(t * 1e+6f % 0xfffffff); var rand = new Unity.Mathematics.Random((randomSeed + 1) ^ id); var p = rand.NextFloat3(); var r = rand.NextFloat3(); p = (p * 2 - 1) * positionAmount * info.weight; r = (r * 2 - 1) * rotationAmount * info.weight; target.localPosition += (Vector3)p; target.localRotation = Quaternion.Euler(r) * target.localRotation; }
public void RandomPointsOnCircle(float3 center, float3 range, ref NativeArray <float3> positions, ref NativeArray <quaternion> rotations) { var count = positions.Length; // Initialize the seed of the random number generator for (int i = 0; i < count; i++) { positions[i] = center + random.NextFloat3(-range, range); rotations[i] = random.NextQuaternionRotation(); } }
protected override void OnCreate() { for (int i = 0; i < CacheSize; i++) { SubOneFloats.Add(rand.NextFloat()); Directions.Add(rand.NextFloat3(MoveRandom.DirectionMin, MoveRandom.DirectionMax)); Angles.Add(rand.NextFloat(0f, Mathf.PI * 2)); LifeSpans.Add(rand.NextFloat(1f, 15f)); CenterDists.Add(rand.NextFloat(radius)); CubeTypes.Add(rand.NextUInt((uint)SpawnerSystem.SpawnOdds)); } base.OnCreate(); }
private void Initialize() { EntityManager entityManager = World.Active.EntityManager; NativeArray <Entity> cubeEntities = new NativeArray <Entity>(numberOfEntitiesToSpawn, Allocator.Temp); EntityArchetype cubeArchetype = entityManager.CreateArchetype( typeof(RenderMesh), typeof(LocalToWorld), typeof(Translation), typeof(Rotation), typeof(NonUniformScale), typeof(Rotator) ); entityManager.CreateEntity(cubeArchetype, cubeEntities); Unity.Mathematics.Random rnd = new Unity.Mathematics.Random(); rnd.InitState((uint)System.DateTime.UtcNow.Ticks); for (int i = 0; i < cubeEntities.Length; i++) { Entity cubeEntity = cubeEntities[i]; entityManager.SetSharedComponentData(cubeEntity, new RenderMesh { mesh = config.Mesh, material = config.Material }); entityManager.SetComponentData(cubeEntity, new Translation { Value = rnd.NextFloat3(new float3(config.MinEntityPosition.x, 0, config.MinEntityPosition.y), new float3(config.MaxEntityPosition.x, 0, config.MaxEntityPosition.y)) }); entityManager.SetComponentData(cubeEntity, new NonUniformScale { Value = rnd.NextFloat3(new float3(config.MinEntityScale.x, config.MinEntityScale.y, config.MinEntityScale.x), new float3(config.MaxEntityScale.x, config.MaxEntityScale.y, config.MaxEntityScale.x)) }); entityManager.SetComponentData(cubeEntity, new Rotator { Rotation = rnd.NextFloat(0, 360), RotationSpeed = rnd.NextFloat(config.MinSpin, config.MaxSpin) }); } cubeEntities.Dispose(); }
void SpawnSphere() { BlobAssetReference <Collider> sourceCollider = entityManager.GetComponentData <PhysicsCollider>(sourceEntity).Value; Unity.Mathematics.Random random = new Unity.Mathematics.Random(); random.InitState(10); for (int i = 0; i < spawnCount; i++) { var instance = entityManager.Instantiate(sourceEntity); entityManager.SetComponentData(instance, new Translation { Value = center + random.NextFloat3(-range, range) }); } }
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); }); }