public void Execute(int i, TransformAccess transform) { Vector3 currentVelocity = ObjectVelocities[i]; random randomGen = new random((uint)(i * Time + 1 + Seed)); transform.position += transform.localToWorldMatrix.MultiplyVector(new Vector3(0, 0, 1)) * SwimSpeed * JobDeltaTime * randomGen.NextFloat(0.3f, 1.0f); if (currentVelocity != Vector3.zero) { transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(currentVelocity), TurnSpeed * JobDeltaTime); } Vector3 currentPosition = transform.position; bool randomise = true; if (currentPosition.x > Center.x + Bounds.x / 2 || currentPosition.x < Center.x - Bounds.x / 2 || currentPosition.z > Center.z + Bounds.z / 2 || currentPosition.z < Center.z - Bounds.z / 2) { Vector3 internalPosition = new Vector3(Center.x + randomGen.NextFloat(-Bounds.x / 2, Bounds.x / 2) / 1.3f, 0, Center.z + randomGen.NextFloat(-Bounds.z / 2, Bounds.z / 2) / 1.3f); currentVelocity = (internalPosition - currentPosition).normalized; ObjectVelocities[i] = currentVelocity; transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(currentVelocity), TurnSpeed * JobDeltaTime * 2); randomise = false; } if (randomise) { if (randomGen.NextInt(0, SwimChangeFrequency) <= 2) { ObjectVelocities[i] = new Vector3(randomGen.NextFloat(-1f, 1f), 0, randomGen.NextFloat(-1f, 1f)); } } }
public void Execute(int index) { Directions[index] = new Vector3( Random.NextFloat(-SpreadFactor, SpreadFactor), Random.NextFloat(-SpreadFactor, SpreadFactor), Random.NextFloat(-SpreadFactor, SpreadFactor)); }
protected override PerformanceData CreateGraph(Entity entity, ref Rig rig, ProcessDefaultAnimationGraph graphSystem, ref PerformanceSetup setup) { if (!EntityManager.HasComponent <PerformanceSetupAsset>(entity)) { throw new System.InvalidOperationException("Entity is missing a PerformanceSetupAsset IBufferElementData"); } if (EntityManager.GetBuffer <PerformanceSetupAsset>(entity).Length != 2) { throw new System.InvalidOperationException("Entity needs 2 PerformanceSetupAssets"); } var set = graphSystem.Set; var data = new PerformanceData { Graph = graphSystem.CreateGraph() }; var deltaTimeNode = graphSystem.CreateNode <ConvertDeltaTimeToFloatNode>(data.Graph); var timeNode = graphSystem.CreateNode <TimeCounterNode>(data.Graph); var entityNode = graphSystem.CreateNode(data.Graph, entity); var clipBuffer = EntityManager.GetBuffer <PerformanceSetupAsset>(entity); var clipPlayerNodes = new NativeArray <NodeHandle <ClipPlayerNode> >(clipBuffer.Length, Allocator.Temp); // Clips to binary mixer data.InertialNode = graphSystem.CreateNode <InertialBlendingNode>(data.Graph); clipPlayerNodes[0] = graphSystem.CreateNode <ClipPlayerNode>(data.Graph); clipPlayerNodes[1] = graphSystem.CreateNode <ClipPlayerNode>(data.Graph); set.SetData(clipPlayerNodes[0], ClipPlayerNode.KernelPorts.Speed, s_Random.NextFloat(0.1f, 1f)); set.SetData(clipPlayerNodes[1], ClipPlayerNode.KernelPorts.Speed, s_Random.NextFloat(0.1f, 1f)); set.SetData(timeNode, TimeCounterNode.KernelPorts.Speed, 1f); set.Connect(entityNode, deltaTimeNode, ConvertDeltaTimeToFloatNode.KernelPorts.Input); set.Connect(deltaTimeNode, ConvertDeltaTimeToFloatNode.KernelPorts.Output, clipPlayerNodes[0], ClipPlayerNode.KernelPorts.DeltaTime); set.Connect(deltaTimeNode, ConvertDeltaTimeToFloatNode.KernelPorts.Output, clipPlayerNodes[1], ClipPlayerNode.KernelPorts.DeltaTime); set.Connect(deltaTimeNode, ConvertDeltaTimeToFloatNode.KernelPorts.Output, timeNode, TimeCounterNode.KernelPorts.DeltaTime); set.Connect(clipPlayerNodes[0], ClipPlayerNode.KernelPorts.Output, data.InertialNode, InertialBlendingNode.KernelPorts.Input0); set.Connect(clipPlayerNodes[1], ClipPlayerNode.KernelPorts.Output, data.InertialNode, InertialBlendingNode.KernelPorts.Input1); set.Connect(timeNode, TimeCounterNode.KernelPorts.Time, data.InertialNode, InertialBlendingNode.KernelPorts.Time); set.Connect(timeNode, TimeCounterNode.KernelPorts.OutputDeltaTime, data.InertialNode, InertialBlendingNode.KernelPorts.DeltaTime); set.Connect(data.InertialNode, InertialBlendingNode.KernelPorts.Output, entityNode, NodeSet.ConnectionType.Feedback); set.SendMessage(clipPlayerNodes[0], ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration { Mask = ClipConfigurationMask.LoopTime }); set.SendMessage(clipPlayerNodes[1], ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration { Mask = ClipConfigurationMask.LoopTime }); set.SendMessage(clipPlayerNodes[0], ClipPlayerNode.SimulationPorts.Rig, rig); set.SendMessage(clipPlayerNodes[1], ClipPlayerNode.SimulationPorts.Rig, rig); set.SendMessage(clipPlayerNodes[0], ClipPlayerNode.SimulationPorts.Clip, clipBuffer[0].Clip); set.SendMessage(clipPlayerNodes[1], ClipPlayerNode.SimulationPorts.Clip, clipBuffer[1].Clip); set.SendMessage(data.InertialNode, InertialBlendingNode.SimulationPorts.Rig, rig); set.SendMessage(data.InertialNode, InertialBlendingNode.SimulationPorts.Duration, 1); return(data); }
static Mesh CreateMesh(Material material) { var random = new Random(); random.InitState(12345); var vertices = new Vector3[POINT_MAX * 2]; for (var i = 0; i < POINT_MAX; ++i) { float x = random.NextFloat(-RANGE, RANGE); float y = random.NextFloat(-RANGE, RANGE); float z = random.NextFloat(-RANGE, RANGE); var point = new Vector3(x, y, z); vertices[i * 2 + 0] = point; vertices[i * 2 + 1] = point; } var indices = new int[POINT_MAX * 2]; for (var i = 0; i < POINT_MAX * 2; ++i) { indices[i] = i; } var colors = new Color[POINT_MAX * 2]; for (var i = 0; i < POINT_MAX; ++i) { colors[i * 2 + 0] = new Color(0f, 0f, 0f /* not used */, 1f); colors[i * 2 + 1] = new Color(0f, 0f, 0f /* not used */, 0f); } var uvs = new Vector2[POINT_MAX * 2]; for (var i = 0; i < POINT_MAX; ++i) { uvs[i * 2 + 0] = new Vector2(1f, 0f); uvs[i * 2 + 1] = new Vector2(0f, 1f); } var mesh = new Mesh(); mesh.name = "debris"; mesh.vertices = vertices; mesh.colors = colors; mesh.uv = uvs; mesh.bounds = new Bounds(Vector3.zero, Vector3.one * 99999999); mesh.SetIndices(indices, MeshTopology.Lines, 0); mesh.UploadMeshData(true /* markNoLogerReadable */); _material = material; material.SetFloat("_Range", RANGE); material.SetFloat("_RangeR", 1f / RANGE); const float cpower = 0.4f; material.SetColor(MaterialColor, new Color(cpower, cpower, cpower)); // mesh_ = mesh; return(mesh); }
static string GetColorStringFromHash(uint hash) { var rnd = new Unity.Mathematics.Random(); rnd.InitState(hash); var color = Color.HSVToRGB(rnd.NextFloat(0.1f, 0.9f), rnd.NextFloat(0.5f, 1), rnd.NextFloat(0.5f, 1)); var colorStr = ColorUtility.ToHtmlStringRGB(color); return(colorStr); }
public void Convert(Entity entity, EntityManager manager, GameObjectConversionSystem converter) { InitRandom(); float randomSpeed = s_random.NextFloat(1f, 5f); float randomAngle = s_random.NextFloat(0f, (float)(2.0 * System.Math.PI)); Vector3 randomDirection = new Vector3(Mathf.Cos(randomAngle), 0f, Mathf.Sin(randomAngle)); Ant a = new Ant { speed = randomSpeed, direction = randomDirection }; manager.AddComponentData(entity, a); }
public void Break() { if (PlacementSet.BreakAble) { if (_stuff != null) { var explodable = _stuff.gameObject.AddComponent <Explodable>(); _stuff.gameObject.AddComponent <BoxCollider2D>(); explodable.allowRuntimeFragmentation = true; explodable.fragmentLayer = "Breaks"; explodable.extraPoints = 10; explodable.orderInLayer = 3; explodable.explode(); Sounds.Get().PlayDestructionSound(); gameObject.GetComponent <BoxCollider2D>().enabled = false; var fragments = explodable.fragments; foreach (var f in fragments) { Destroy(f.GetComponent <PolygonCollider2D>(), _random.NextFloat(1.0f, 2.5f)); Destroy(f, 3f); } if (showAfterBreak.ShowObject != null) { showAfterBreak.ShowObject.gameObject.SetActive(true); } Destroy(gameObject, 2.0f); } } }
public void Execute(ref ExecuteContext <Parameters, Providers> context) { if (context.Outputs.Count == 0) { return; } if (m_Random.state == 0) { m_Random.InitState(2747636419u); } var outputSampleBuffer = context.Outputs.GetSampleBuffer(0); var outputChannels = outputSampleBuffer.Channels; var parameters = context.Parameters; var inputCount = context.Inputs.Count; for (var channel = 0; channel < outputChannels; ++channel) { var outputBuffer = outputSampleBuffer.GetBuffer(channel); for (var i = 0; i < inputCount; i++) { var inputBuff = context.Inputs.GetSampleBuffer(i).GetBuffer(channel); for (var s = 0; s < outputBuffer.Length; s++) { outputBuffer[s] += inputBuff[s]; } } for (var s = 0; s < outputBuffer.Length; s++) { outputBuffer[s] += m_Random.NextFloat() * 2.0f - 1.0f + parameters.GetFloat(Parameters.Offset, s); } } }
public void Execute(Entity entity, int index, [ReadOnly, ChangedFilter] DynamicBuffer <PhysicsTriggerResults> physicsTriggerResults, [ReadOnly] ref ActorAttribute3Offset <_HP> hpOffset, [ReadOnly] ref ActorOwner actorOwner, [ReadOnly] ref Actor actor) { for (var i = 0; i < physicsTriggerResults.Length; ++i) { var targetEntity = physicsTriggerResults[i].entity; var hp = hpOffset.GetValue(random.NextFloat(0f, 1f)); if (hpModifyFromEntity.Exists(targetEntity)) { hpModifyFromEntity[targetEntity].Add(new ActorAttribute3Modifys <_HP> { player = actorOwner.playerEntity, type = actor.actorType, value = hp, attribute3ModifyType = Attribute3SubModifyType.ValueOffset }); } // var translation = translationFromEntity[targetEntity]; AttributeModifyFxSpawner.createInServer(endCommandBuffer, index, actor.actorType, translation, hp, 0f, default); } }
protected override void OnUpdate() { var random = new Unity.Mathematics.Random((uint)Random.Range(1, 100000)); var buffer = PostAttackEntityBuffer.CreateCommandBuffer().AsParallelWriter(); Dependency = Entities.ForEach( (Entity e, int entityInQueryIndex, in Attack attack, in Instigator attacker, in Target target, in BeamEffectStyle style, in HitLocation hitLoc, in SourceLocation sourceLoc) => { var laserEffect = new BeamEffect() { start = sourceLoc.Position, end = hitLoc.Position, lifetime = 0.2f }; if (attack.Result == Attack.eResult.Miss) { var delta = new Unity.Mathematics.float3(random.NextFloat() - 0.5f, 0f, random.NextFloat() - 0.5f); laserEffect.end = laserEffect.end + 6f * delta; } Entity effect = buffer.CreateEntity(entityInQueryIndex); buffer.AddComponent(entityInQueryIndex, effect, laserEffect); buffer.AddComponent(entityInQueryIndex, effect, style); buffer.AddComponent(entityInQueryIndex, effect, attacker); buffer.AddComponent(entityInQueryIndex, effect, target); }
/// <summary> /// Generates one sample /// </summary> /// <returns>The generated sample</returns> public float Sample() { var rng = new Unity.Mathematics.Random(ScenarioBase.activeScenario.NextRandomState()); return(SamplerUtility.TruncatedNormalSample( rng.NextFloat(), range.minimum, range.maximum, mean, standardDeviation)); }
/// <summary> /// Generates one sample /// </summary> /// <returns>The generated sample</returns> public float Sample() { Initialize(); var rng = new Unity.Mathematics.Random(ScenarioBase.activeScenario.NextRandomState()); return(SamplerUtility.AnimationCurveSample( m_IntegratedCurve, rng.NextFloat(), m_Interval, m_StartTime, m_EndTime)); }
protected override void OnUpdate() { // -- SpawnUnitsSystem_Main var rng = new Unity.Mathematics.Random((uint)(DateTime.Now.ToString().GetHashCode())); Entities .WithStructuralChanges() .WithoutBurst() .WithName("SpawnUnitsSystem_Main") .ForEach((Entity e, ref SpawnRequest spawnRequest) => { var count = spawnRequest.Count; var entities = EntityManager.CreateEntity(_archetype, (int)count, Allocator.Temp); foreach (var entity in entities) { string name = Names[rng.NextInt(0, Names.Length - 1)]; var nameCount = ++_countByName[name]; _countByName[name] = nameCount; EntityManager.SetName(entity, name + nameCount); EntityManager.SetSharedComponentData(entity, new InPlace() { Place = Place.Home }); EntityManager.SetComponentData(entity, new WorkStat() { Speed = rng.NextFloat(5f, 7f) }); EntityManager.SetComponentData(entity, new EnergyStat() { Count = 100, FatiguePressure = rng.NextFloat(15f, 25f) }); EntityManager.SetComponentData(entity, new EnergyRegeneration() { Value = rng.NextFloat(20f, 30f) }); } entities.Dispose(); EntityManager.DestroyEntity(e); }) .Run(); }
protected override void OnUpdate() { Entities .WithoutBurst() .WithStructuralChanges() .WithAll <EntitySpawnData>() .ForEach((Entity entity) => EntityManager.AddBuffer <EntityLifeTimeBuffer>(entity)) .Run() ; var deltaTime = TimeSpan.FromSeconds(World.Time.DeltaTime); var random = new Random((uint)Environment.TickCount); Entities .WithoutBurst() .WithStructuralChanges() .ForEach((Entity spawner, DynamicBuffer <EntityLifeTimeBuffer> entities, in EntitySpawnData data) => { var ecb = new EntityCommandBuffer(Allocator.Temp); var newEntities = ecb.SetBuffer <EntityLifeTimeBuffer>(spawner); foreach (var entity in entities) { var buffer = entity; buffer.LifeTime -= deltaTime; if (buffer.LifeTime <= TimeSpan.Zero) { ecb.DestroyEntity(buffer.Entity); } else { newEntities.Add(buffer); } } var count = data.Count - entities.Length; for (var i = 0; i < count; i++) { var instance = ecb.Instantiate(data.Prefab); var position = random.NextFloat3(data.PositionBounds.min, data.PositionBounds.max); ecb.SetComponent(instance, new Translation { Value = position }); var lifetime = TimeSpan.FromSeconds(random.NextFloat(data.LifeTimeRange.x, data.LifeTimeRange.y)); newEntities.Add(new EntityLifeTimeBuffer { Entity = instance, LifeTime = lifetime }); } ecb.Playback(EntityManager); ecb.Dispose(); }).Run(); }
public void Execute(int index) { var rb = RigidBodies[index]; var seed = (uint)(index + 10000) * 100000; var random = new Unity.Mathematics.Random(seed); var t = random.NextFloat(); var point = Spline.JobSafe_GetPoint(Points, Mode, SplineSpace, localToWorldMatrix, ClosedSpline, t); var offset_x = random.NextFloat(RandomMinSpeed, RandomMaxSpeed) * 0.1f; var offset_z = random.NextFloat(RandomMinSpeed, RandomMaxSpeed) * 0.1f; rb.position = point.position + new Vector3(offset_x, 0f, offset_z); // speed var speed_x = random.NextFloat(RandomMinSpeed, RandomMaxSpeed); var speed_y = random.NextFloat(RandomMinSpeed, RandomMaxSpeed); var speed_z = random.NextFloat(RandomMinSpeed, RandomMaxSpeed); rb.velocity = new Vector3(speed_x, speed_y, speed_z); RigidBodies[index] = rb; }
public static void Float() { Unity.Mathematics.Random rng = new Unity.Mathematics.Random(Helpers.GetRngSeed); Helpers.Test <float>( (array) => { array.SIMD_MinMax(out float min, out float max); Assert.AreEqual(min, array.SIMD_Minimum()); Assert.AreEqual(max, array.SIMD_Maximum()); }, () => rng.NextFloat(float.MinValue, float.MaxValue)); }
public void Execute(int index, TransformAccess transform) { Vector3 currentVelocity = fishVels[index]; // 在Job中不允许用UnityEngine的Random.Range方法,只能使用MathRandom: // UnityException: Range can only be called from the main thread. Constructors and field initializers will be executed from the loading thread when loading a scene. URandom ranGen = new URandom((uint)(index * time + 1 + seed)); transform.position += transform.localToWorldMatrix.MultiplyVector(Vector3.forward * swimSpeed * deltaTime * ranGen.NextFloat(0.3f, 1.0f)); if (currentVelocity != Vector3.zero) { transform.rotation = Quaternion.Lerp( transform.rotation, Quaternion.LookRotation(currentVelocity), turnSpeed * deltaTime); } // 超出边界就朝中心游动 if (transform.position.x > centerPos.x + spawnBounds.x / 2 || transform.position.x < centerPos.x - spawnBounds.x / 2 || transform.position.z > centerPos.z + spawnBounds.z / 2 || transform.position.z < centerPos.z - spawnBounds.z / 2) { Vector3 internalPosition = new Vector3(centerPos.x + ranGen.NextFloat(-spawnBounds.x / 2, spawnBounds.x / 2), 0, centerPos.z + ranGen.NextFloat(-spawnBounds.z / 2, spawnBounds.z / 2)) * 0.8f; fishVels[index] = (internalPosition - transform.position).normalized; } else { fishRotLeftTimes[index] -= deltaTime; if (fishRotLeftTimes[index] <= 0) { fishVels[index] = new Vector3(ranGen.NextFloat(-1f, 1f), 0, ranGen.NextFloat(-1f, 1f)); fishRotLeftTimes[index] = ranGen.NextFloat(1f, 5f); } } }
protected override void OnUpdate() { Entities.With(m_AddGroup).ForEach((Entity entity) => { if (m_Random.NextFloat() > 0.1f) { return; } EntityManager.GetComponentObject <Transform>( EntityManager.GetComponentData <ViewReference>(entity).Value) .GetComponentInChildren <ReadyAudioPlayer>() .PlayAtPoint(EntityManager.GetComponentData <Translation>(entity).Value); }); EntityManager.AddComponent(m_AddGroup, ComponentType.ReadWrite <AudioPlayed>()); EntityManager.RemoveComponent(m_RemoveGroup, ComponentType.ReadWrite <AudioPlayed>()); }
/// <summary> /// Returns a random element with the chances of rolling based on <paramref name="weights"/> /// </summary> /// <param name="weights">Positive floats representing weights. Negative values may lead to unpredictable behaviour.</param> public static T GetRandom <T>(this IReadOnlyList <T> list, IReadOnlyList <float> weights, ref MRandom random) { if (list == null) { throw new ArgumentNullException(nameof(list)); } if (list.Count == 0) { throw new ArgumentException("Empty list"); } if (weights == null) { throw new ArgumentNullException(nameof(weights)); } if (weights.Count == 0) { throw new ArgumentException("Empty weights"); } if (list.Count != weights.Count) { throw new ArgumentException("Array sizes must be equal"); } if (list.Count == 1) { return(list[0]); } var cumulative = new List <float>(weights); for (int i = 1; i < cumulative.Count; i++) { cumulative[i] += cumulative[i - 1]; } float randomValue = random.NextFloat(0, cumulative[cumulative.Count - 1]); int index = cumulative.FindIndex(a => a >= randomValue); if (index == -1) { throw new ArgumentException("Weights must be positive"); } return(list[index]); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var time = Time.DeltaTime; timeSinceStart += time; var random = new Random((uint)(timeSinceStart * 1000f)); return(Entities.WithBurst().ForEach((ref BugAiComponent ai, ref PhysicsVelocity velocity, in BugComponent bug) => { ai.TimeTillNextTurn -= time; if (ai.TimeTillNextTurn <= 0) { velocity.Angular = random.NextFloat3(ai.RotationRange.x, ai.RotationRange.y); velocity.Angular = random.NextBool() ? velocity.Angular : -velocity.Angular; ai.TimeTillNextTurn = random.NextFloat(ai.IntervalRangeSec.x, ai.IntervalRangeSec.y); } }) .Schedule(inputDeps)); }
//物理运算 public void Execute(ref GravityComponentData gravityData, ref Position positionData) { if (gravityData.delay > 0) { gravityData.delay -= deltaTime; } else { Vector3 pos = positionData.Value; float v = gravityData.velocity + G * gravityData.mass * deltaTime; pos.y += v; if (pos.y < bottomY) { pos.y = topY; gravityData.velocity = 0f; gravityData.delay = random.NextFloat(0, 10); } positionData.Value = pos; } }
public static Color RandomColor(ref Random random, float alpha = 1) { return(new Color(random.NextFloat(), random.NextFloat(), random.NextFloat(), alpha)); }
private void Generate() { GameObject line = new GameObject(); var lr = line.AddComponent <LineRenderer>(); lr.positionCount = 5; lr.SetPosition(0, new Vector3(0, 0, -1)); lr.SetPosition(1, new Vector3(m_world.pixelW, 0, -1)); lr.SetPosition(2, new Vector3(m_world.pixelW, m_world.pixelH, -1)); lr.SetPosition(3, new Vector3(0, m_world.pixelH, -1)); lr.SetPosition(4, new Vector3(0, 0, -1)); lr.startWidth = 2; lr.endWidth = 2; for (int i = 0; i < m_world.settings.plates; i++) { int x = m_rand.NextInt(0, m_world.pixelW); int y = m_rand.NextInt(0, m_world.pixelH); Hex hex = m_layout.PixelToHex(new Point(x, y)).HexRound(); Plate p = new Plate(this, hex, UnityEngine.Random.ColorHSV()) { elevation = Random.Range(0f, 255f), movementSpeed = m_rand.NextFloat(MIN_SPD, MAX_SPD), direction = (HexDirection)Random.Range(0, HexConstants.DIRECTIONS - 1), }; m_world.AddPlate(p); } /* * ------------------------------------------------------ * Setting hexes to plates * ------------------------------------------------------ */ foreach (var pair in m_world.TileData) { int closestId = 0; int closest = int.MaxValue; for (int i = 0; i < m_world.settings.plates; i++) { int dist = pair.Key.Distance(m_world.plates[i].center); if (closest > dist) { closest = dist; closestId = i; } } for (int i = 0; i < m_world.settings.plates; i++) { int dist = pair.Key.Distance(HexUtils.WrapOffset(m_world.plates[i].center, m_world.size.x)); if (closest > dist) { closest = dist; closestId = i; } } pair.Value.hexData.plateId = m_world.GetPlates()[closestId].id; pair.Value.hexData.oldPlateId = m_world.GetPlates()[closestId].id; m_world.GetPlates()[closestId].AddHex(pair.Key); } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { float deltaTime = Time.DeltaTime; uint seed = (uint)(UnityEngine.Random.value * 10000); Random random = new Random(seed); var entityCommandBuffer = _commandBufferSystem.CreateCommandBuffer().ToConcurrent(); JobHandle jobHandle = Entities.ForEach( (Entity entity, int entityInQueryIndex, ref UnitSpawnerData spawnerData) => { if (spawnerData._spawnInActive) { return; } // Spawn Light Enemy Update Time if (spawnerData._currentLightUnitTime <= 0) { if (spawnerData._currentLightEntityInBetweenTime <= 0) { float value = random.NextFloat(); if (value <= 0.5f) { entityCommandBuffer.Instantiate(entityInQueryIndex, spawnerData.lightEntityA); } else { entityCommandBuffer.Instantiate(entityInQueryIndex, spawnerData.lightEntityB); } spawnerData._currentLightEntityCount += 1; if (spawnerData._currentLightEntityCount >= spawnerData.lightEntityBurstCount) { spawnerData._currentLightUnitTime = spawnerData ._currentDeadPerSec .Map(spawnerData.minDeathPerSec, spawnerData.maxDeathPerSec, spawnerData.maxTimeBetweenLightEntity, spawnerData.minTimeBetweenLightEntity); spawnerData._currentLightEntityCount = 0; } else { spawnerData._currentLightEntityInBetweenTime = spawnerData.lightBurstTimeBetween; } } else { spawnerData._currentLightEntityInBetweenTime -= deltaTime; } } else { spawnerData._currentLightUnitTime -= deltaTime; } // Spawn Heavy Enemy Update Time if (spawnerData._currentHeavyUnitTime <= 0) { float value = random.NextFloat(); if (value <= 0.5f) { entityCommandBuffer.Instantiate(entityInQueryIndex, spawnerData.heavyEntityA); } else { entityCommandBuffer.Instantiate(entityInQueryIndex, spawnerData.heavyEntityB); } spawnerData._currentHeavyUnitTime = spawnerData ._currentDeadPerSec .Map(spawnerData.minDeathPerSec, spawnerData.maxDeathPerSec, spawnerData.maxTimeBetweenHeavyEntity, spawnerData.maxTimeBetweenHeavyEntity); } else { spawnerData._currentHeavyUnitTime -= deltaTime; } }).Schedule(inputDeps); _commandBufferSystem.AddJobHandleForProducer(jobHandle); return(jobHandle); }
unsafe int UpdateCentroids() { int *hassign = stackalloc int[k]; for (int i = 0; i < k; ++i) { hassign[i] = 0; } Debug.Assert(centroids.Length == d * k); for (int i = 0; i < centroids.Length; ++i) { centroids[i] = 0.0f; } for (int i = 0; i < numSamples; ++i) { int ci = distances[i].index; Debug.Assert(ci >= 0 && ci < k); hassign[ci]++; for (int j = 0; j < d; ++j) { centroids[ci * d + j] += features[i * d + j]; } } for (int ci = 0; ci < k; ci++) { var ni = hassign[ci]; if (ni != 0) { for (int j = 0; j < d; ++j) { centroids[ci * d + j] /= (float)ni; } } } // // Take care of void clusters // int nsplit = 0; var random = new Unity.Mathematics.Random(1234); for (int ci = 0; ci < k; ++ci) { // // need to redefine a centroid // if (hassign[ci] == 0) { int cj = 0; while (true) { // // probability to pick this cluster for split // float p = (hassign[cj] - 1.0f) / (float)(numSamples - k); float r = random.NextFloat(); if (r < p) { // // found our cluster to be split // break; } cj = (cj + 1) % k; } for (int j = 0; j < d; ++j) { centroids[ci * d + j] = centroids[cj * d + j]; } // // small symmetric perturbation // float eps = 1.0f / 1024.0f; for (int j = 0; j < d; ++j) { if (j % 2 == 0) { centroids[ci * d + j] *= 1 + eps; centroids[cj * d + j] *= 1 - eps; } else { centroids[ci * d + j] *= 1 - eps; centroids[cj * d + j] *= 1 + eps; } } // // assume even split of the cluster // hassign[ci] = hassign[cj] / 2; hassign[cj] -= hassign[ci]; nsplit++; } } return(nsplit); }
public static void CreateAttributeOperEntities(EntityManager EntityManager, Entity ActorEntity) { var random = new Unity.Mathematics.Random((uint)ActorEntity.Index); for (var i = 0; i < 5; i++) { new PermanentAttributeModifierTag().CreateAttributeModifier <TAttribute, TOper>(EntityManager, ActorEntity, random.NextFloat(0, 50)); } }
public MapResourceObject[] GenerateResources(Random rand, Terrain terrain, int size) { int featureSize = size / 16; int halfSize = size / 2 - 16 / 2; MapResourceObject[] mapResourceObjects = new MapResourceObject[featureSize * featureSize]; for (int z = 0; z < featureSize; z++) { for (int x = 0; x < featureSize; x++) { uint index = rand.NextUInt(0, 5); ItemObj[] resources; switch (index) { default: continue; case 0: resources = ironResources; break; case 1: resources = copperResources; break; case 2: resources = coalResources; break; } if (resources.Length == 0) { continue; } ItemObj obj = resources[rand.NextInt(0, resources.Length)]; switch (obj.Item) { case MapResource resourceObject: { MapResourceObject instance = mapResourceObjects[x + z * featureSize] = Instantiate(resourcePrefab, transform); Vector3 pos = new Vector3(x * 16 - halfSize, 0, z * 16 - halfSize); pos.y = terrain.SampleHeight(pos); Quaternion rotation = Quaternion.Euler(0, rand.NextFloat(-180, 180), 0); instance.Init(pos, rotation, obj.Item as MapResource, rand.NextUInt(3000, 6000)); break; } case Factory factory: break; } } } return(mapResourceObjects); }