static string GetRandomSmallBloodPrefab()
{
int[] smallIndices = new int[] { 4, 5, 6, 7 };
int index = random.NextInt(smallIndices.Length);
return($"Blood{smallIndices[index]}");
}
void Start()
{
m_ResultsDelayedQueries = new bool[m_QueryCount];
m_ResultsDirectQueries = new bool[m_QueryCountPerFrame];
m_BlackBoard = new BlackBoard(m_EntryCount, m_QueryCount);
m_BlackBoardSystem = World.Active.GetOrCreateSystem <BlackBoardSystem>();
m_BlackBoardSystem.BlackBoards.Add("TestBlackBoard", m_BlackBoard);
m_Rand = new Random();
m_Rand.InitState();
for (int i = 0; i < m_EntryCount; i++)
{
m_BlackBoard.SetEntry(i, m_Rand.NextInt());
}
for (int i = 0; i < m_QueryCount; i++)
{
var value1 = m_Rand.NextInt();
var value2 = m_Rand.NextInt();
m_BlackBoard.SetQuery(
i,
m_Rand.NextInt(0, m_EntryCount),
value1 < value2 ? value1 : value2,
value1 < value2 ? value2 : value1);
}
}
public static Entity GetRandomMagicWeapon(int level, ref Unity.Mathematics.Random random, EntityCommandBuffer commandBuffer)
{
var itemEntity = commandBuffer.CreateEntity();
var storeIndex = Array.FindIndex(ItemsManagerComponent.Instance.ItemsStoreComponent.Items,
item => item.ItemType == ItemType.Gear && item.GearType == GearType.Magic);
var iconIndex = random.NextInt(0,
ItemsManagerComponent.Instance.ItemsStoreComponent.Items[storeIndex].Icons.Length);
commandBuffer.AddComponent(itemEntity, new ItemComponent
{
StoreIndex = storeIndex,
IconIndex = iconIndex,
Level = level
});
commandBuffer.AddComponent(itemEntity, new MagicStatModifierComponent
{
Value = random.NextInt(1, 6)
});
var randomStatModifiersArray = new NativeArray <WeaponStatsModifiers>(3, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
randomStatModifiersArray[0] = WeaponStatsModifiers.Defence;
randomStatModifiersArray[1] = WeaponStatsModifiers.Attack;
randomStatModifiersArray[2] = WeaponStatsModifiers.Health;
AddRandomStats(itemEntity, commandBuffer, randomStatModifiersArray, ref random);
randomStatModifiersArray.Dispose();
return(itemEntity);
}
// Start is called before the first frame update
void Start()
{
nativeResult = new NativeArray <int>(1, Allocator.Persistent);
blobResult = new NativeArray <int>(1, Allocator.Persistent);
random = new Unity.Mathematics.Random((uint)System.DateTime.Now.Ticks);
// generate all keys
allKeys = new NativeArray <int>(itemCount, Allocator.Persistent);
allQueries = new NativeArray <int>(itemCount * 2, Allocator.Persistent);
for (int i = 0; i < itemCount; i++)
{
allKeys[i] = random.NextInt(0, 50); // generate duplicate keys
// 50/50 random queries and certainly existing keys
allQueries[i * 2] = allKeys[i];
allQueries[i * 2 + 1] = random.NextInt(-1000, 1000);
}
// construct source
source = new NativeMultiHashMap <int, int>(allKeys.Length, Allocator.Persistent);
for (int i = 0; i < itemCount; i++)
{
source.Add(allKeys[i], 1);
}
BlobBuilder builder = new BlobBuilder(Allocator.Temp);
ref var root = ref builder.ConstructRoot <BlobMultiHashMap <int, int> >();
// Update is called once per frame
void Update()
{
var clock = new Stopwatch();
clock.Start();
for (var i = 0; i < m_EntryUpdatePerFrame; i++)
{
m_BlackBoard.SetEntry(m_Rand.NextInt(0, m_EntryCount), m_Rand.NextInt());
}
m_EntryUpdateTime = clock.ElapsedTicks;
m_EntryUpdateTimeMS = clock.ElapsedMilliseconds;
clock.Restart();
for (var i = 0; i < m_QueryCount; i++)
{
m_ResultsDelayedQueries[i] = m_BlackBoard.GetQueryResult(i);
}
m_ResultsDelayedQueriesTime = clock.ElapsedTicks;
m_ResultsDelayedQueriesTimeMS = clock.ElapsedMilliseconds;
clock.Restart();
for (var i = 0; i < m_QueryCountPerFrame; i++)
{
var value1 = m_Rand.NextInt();
var value2 = m_Rand.NextInt();
m_ResultsDirectQueries[i] = m_BlackBoard.GetQueryResult(
m_Rand.NextInt(0, m_EntryCount),
value1 < value2 ? value1 : value2,
value1 < value2 ? value2 : value1);
}
m_ResultsDirectQueriesTime = clock.ElapsedTicks;
m_ResultsDirectQueriesTimeMS = clock.ElapsedMilliseconds;
}
public Intent Act(ref GameStateData gs, int id)
{
intent.actionIntent =
(ActionsAvailable)rdm.NextInt((int)ActionsAvailable.NONE, (int)ActionsAvailable.BLOCK);
intent.moveIntent = (ActionsAvailable)rdm.NextInt(0, (int)ActionsAvailable.NONE);
return(intent);
}
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));
}
}
}
protected override void OnUpdate()
{
if (this._dropGroup.CalculateEntityCount() == 0)
{
return;
}
var dropChunks = this._dropGroup.CreateArchetypeChunkArray(Allocator.TempJob);
for (var c = 0; c < dropChunks.Length; c++)
{
var chunk = dropChunks[c];
var entities = chunk.GetNativeArray(this.GetArchetypeChunkEntityType());
if (entities.Length > 0)
{
for (var i = 0; i < chunk.Count; i++)
{
var ownerEntity = entities[i];
this.Entities.With(this._lootGroup).ForEach((Entity itemEntity, ref PickedUpComponent pickedUpComponent) =>
{
if (pickedUpComponent.Owner == ownerEntity && _random.NextInt(0, 100) < 85)
{
this.PostUpdateCommands.AddComponent(itemEntity, new DestroyComponent());
}
});
}
}
}
dropChunks.Dispose();
}
private static void AddRandomStats(Entity itemEntity, EntityCommandBuffer commandBuffer, NativeArray <WeaponStatsModifiers> randomStatModifiersArray, ref Unity.Mathematics.Random random)
{
var chance = 50;
ShuffleStatsArray(randomStatModifiersArray, ref random);
for (int i = 0; i < randomStatModifiersArray.Length; i++)
{
if (random.NextInt(0, 100) < chance)
{
chance -= 20;
switch (randomStatModifiersArray[i])
{
case WeaponStatsModifiers.Attack:
commandBuffer.AddComponent(itemEntity, new AttackStatModifierComponent
{
Value = random.NextInt(1, 4)
});
break;
case WeaponStatsModifiers.Defence:
commandBuffer.AddComponent(itemEntity, new DefenceStatModifierComponent
{
Value = random.NextInt(1, 4)
});
break;
case WeaponStatsModifiers.Magick:
commandBuffer.AddComponent(itemEntity, new MagicStatModifierComponent
{
Value = random.NextInt(1, 4)
});
break;
case WeaponStatsModifiers.Health:
commandBuffer.AddComponent(itemEntity, new HealthStatModifierComponent
{
Value = random.NextInt(1, 4)
});
break;
}
}
else
{
return;
}
}
}
internal void GenerateNewWayPointPath()
{
var roadIds = new RoadSet(RoadNetwork);
if (!roadIds.Contains(m_RoadId))
{
m_RoadId = roadIds.GetNotTraversed(Math.Abs(m_Rand.NextInt()));
if (m_RoadId.Equals(default))
public void Update()
{
var random = new Unity.Mathematics.Random(1);
for (var i = 0; i < _tenants; i++)
{
PowerUsage += random.NextInt(12, 24);
}
}
public void Run()
{
EcsEntity mainCharacter = EcsEntity.Null;
foreach (var index in _mainCharacterFIlter)
{
mainCharacter = _mainCharacterFIlter.Entities[index];
}
if (mainCharacter == EcsEntity.Null)
{
return;
}
foreach (var index in _ecsFilter)
{
var joyStick = _ecsFilter.Get1[index];
mainCharacter.Set <MoveComponent>().Value = joyStick.Value;
}
foreach (var index in _randomClickFilter)
{
var click = _ecsFilter.Get1[index];
mainCharacter.Set <RecalculateStats>();
mainCharacter.Set <AgilityComponent>().Value = random.NextInt(1, 20);
mainCharacter.Set <IntellectComponent>().Value = random.NextInt(1, 20);
mainCharacter.Set <StrengthComponent>().Value = random.NextInt(1, 20);
var lc = mainCharacter.Get <LevelComponent>();
lc.Value++;
mainCharacter.Set <UpdateAvalableSkillsComponent>();
}
foreach (var index in _learnSkill)
{
var id = _learnSkill.Get1[index].Id;
var canLearn = mainCharacter.Get <AvailableToLearnSkillsComponent>();
var skill = canLearn.Skills[id];
var learn = mainCharacter.Set <LearnSkillComponent>();
learn.Skill = skill;
mainCharacter.Set <UpdateAvalableSkillsComponent>();
}
}
private static void ShuffleStatsArray(NativeArray <WeaponStatsModifiers> array, ref Unity.Mathematics.Random random)
{
for (int i = 0; i < array.Length; i++)
{
var rIndex = random.NextInt(0, array.Length);
var tmp = array[rIndex];
array[rIndex] = array[i];
array[i] = tmp;
}
}
public void TestPerformance()
{
//map
for (var i = 0; i < 100; i++)
{
var node = EntityManager.CreateEntity();
EntityManager.AddComponentData(node, new TestNode
{
Cost = 1, Id = i
});
}
//request
var random = new Random();
random.InitState();
for (var i = 0; i < 1000; i++)
{
var request = EntityManager.CreateEntity();
EntityManager.AddComponentData(request, new PathFindingRequest
{
StartId = 0, GoalId = random.NextInt(90, 99)
});
}
var system = World.GetOrCreateSystem <TestSystem>();
system.resultECB =
World.GetOrCreateSystem <EndInitializationEntityCommandBufferSystem>();
system.cleanECB = World.GetOrCreateSystem <EndSimulationEntityCommandBufferSystem>();
Stopwatch sw = Stopwatch.StartNew();
system.Update();
system.resultECB.Update();
EntityManager.CompleteAllJobs();
var resultQuery =
EntityManager.CreateEntityQuery(
typeof(PathResult), typeof(PathRoute));
var resultEntities = resultQuery.ToEntityArray(Allocator.TempJob);
var results = resultQuery.ToComponentDataArray <PathResult>(Allocator.TempJob);
Assert.AreEqual(1000, results.Length);
foreach (var result in results)
{
Assert.AreEqual(true, result.Success, result.Log.ToString());
}
resultEntities.Dispose();
results.Dispose();
sw.Stop();
Debug.Log(sw.ElapsedMilliseconds);
}
private IEnumerator DoAttack(Vector2 pos, Vector2 dir)
{
_coolDown = false;
var ammo = ammos[_random.NextInt(0, ammos.Count)];
var projectile = Instantiate(ammo, pos, Quaternion.identity).GetComponent <Projectile>();
projectile.SetDir(dir);
yield return(new WaitForSeconds(cdTime));
_coolDown = true;
}
public void Execute()
{
var random = new Unity.Mathematics.Random(Seed);
for (int i = 0; i < InputData.Dimensions.x; i++)
{
var swap = random.NextInt(0, InputData.Dimensions.x);
Swap(InputData, i, swap);
Swap(ResultData, i, swap);
}
}
/// <summary>
/// Returns a random element
/// </summary>
public static T GetRandom <T>(this IReadOnlyList <T> list, ref MRandom random)
{
if (list == null)
{
throw new ArgumentNullException(nameof(list));
}
if (list.Count == 0)
{
throw new ArgumentException("Empty list");
}
return(list[random.NextInt(0, list.Count)]);
}
public void ReFillEnergySuppliers(ref GameMasterData master)
{
var random = new Random(RandomSeed);
foreach (ref var energySupplier in EnergySuppliers)
{
if (energySupplier.Value > 0)
{
continue;
}
var _ = random.NextUInt4();
random.state = _.x;
energySupplier.Position.x = random.NextInt(0, master.Width - 1);
random.state = _.y;
energySupplier.Position.y = random.NextInt(0, master.Height - 1);
random.state = _.z;
energySupplier.Value = random.NextInt(500, 20000);
random.state = _.w;
}
RandomSeed = random.state;
}
public static void Test <T>(Action <NativeArray <T> > test, Func <T> generateElement, int maxLength = 5000000)
where T : unmanaged
{
Unity.Mathematics.Random rng = new Unity.Mathematics.Random(GetRngSeed);
NativeArray <T> array = new NativeArray <T>(rng.NextInt(0, maxLength), Allocator.Persistent);
for (int i = 0; i < Helpers.NUM_TESTS; i++)
{
for (int j = 0; j < array.Length; j++)
{
array[j] = generateElement();
}
test(array);
array.Dispose();
array = new NativeArray <T>(rng.NextInt(0, maxLength), Allocator.Persistent);
}
array.Dispose();
}
public void Execute()
{
var rng = new Random(Seed);
for (var i = 0; i <= Deck.Length - 2; ++i)
{
var j = rng.NextInt(i, Deck.Length);
var tmp = Deck[i];
Deck[i] = Deck[j];
Deck[j] = tmp;
}
}
internal int SampleCommandIndex(ref Random rng)
{
int w = rng.NextInt(0, _totalWeight);
for (int i = 0; i < _runningSumWeights.Length; i++)
{
if (w < _runningSumWeights[i])
{
return(i);
}
}
return(_runningSumWeights.Length - 1);
}
public static void Shuffle <T>(IList <T> list, ref Rng rng)
{
int n = list.Count;
while (n > 1)
{
n--;
int k = rng.NextInt(n + 1);
T value = list[k];
list[k] = list[n];
list[n] = value;
}
}
// Spawn deals for all merchants for current year in turn 0
protected override void OnUpdate()
{
var calendarQuery = GetEntityQuery(ComponentType.ReadOnly <TimeTable>());
var calendar = GetComponent <TimeTable>(calendarQuery.GetSingletonEntity());
if (calendar.Turn != 0 || calendar.Pause)
{
return;
}
var dealManagerQuery = GetEntityQuery(ComponentType.ReadOnly <DealSpawner>());
var dealPrefab = GetComponent <DealSpawner>(dealManagerQuery.GetSingletonEntity()).DealPrefab;
var merchantQuery = GetEntityQuery(ComponentType.ReadOnly <Merchant>());
var merchants = merchantQuery.ToComponentDataArray <Merchant>(Allocator.TempJob);
Entities
.WithStructuralChanges()
.ForEach((in Merchant merchant) =>
{
// ReSharper disable once AccessToDisposedClosure
for (var i = 0; i < merchants.Length; i++)
{
// ReSharper disable once AccessToDisposedClosure
if (merchants[i].Id <= merchant.Id)
{
continue;
}
var numDeals = _random.NextInt(5, 11);
for (var j = 1; j <= numDeals; j++)
{
var newDeal = EntityManager.Instantiate(dealPrefab);
EntityManager.SetComponentData(newDeal, new Deal
{
Turn = j,
FirstMerchantId = merchant.Id,
FirstMerchantRandom = new Random(_random.NextUInt()),
FirstMerchantType = merchant.Type,
// ReSharper disable once AccessToDisposedClosure
SecondMerchantId = merchants[i].Id,
SecondMerchantRandom = new Random(_random.NextUInt()),
// ReSharper disable once AccessToDisposedClosure
SecondMerchantType = merchants[i].Type
});
Mappings[merchant.Type].Invoke(EntityManager, newDeal);
// ReSharper disable once AccessToDisposedClosure
Mappings[merchants[i].Type].Invoke(EntityManager, newDeal);
}
}
}).Run();
/// <summary>
/// Fisher–Yates shuffle
/// </summary>
/// <remarks>
/// https://en.wikipedia.org/wiki/Fisher–Yates_shuffle
/// </remarks>
public static void Shuffle <T>(this IList <T> list, ref MRandom random)
{
if (list == null)
{
throw new ArgumentNullException(nameof(list));
}
for (int i = 0; i < list.Count; i++)
{
int j = random.NextInt(i, list.Count);
T tmp = list[j];
list[j] = list[i];
list[i] = tmp;
}
}
public static void Short()
{
Unity.Mathematics.Random rng = new Unity.Mathematics.Random(Helpers.GetRngSeed);
Helpers.Test <short>(
(array) =>
{
array.SIMD_MinMax(out short min, out short max);
Assert.AreEqual(min, array.SIMD_Minimum());
Assert.AreEqual(max, array.SIMD_Maximum());
},
() => (short)rng.NextInt(short.MinValue, short.MaxValue + 1));
}
private void Fill(NativeArray <TKey> queries, NativeHashMap <TKey, int> hashmap, ref BlobBuilderHashMap <TKey, int> blobBuilderHashMap,
int amt)
{
for (int i = 0; i < amt; i++)
{
TKey key = GetRandomKey(random);
int randomValue = random.NextInt(1000);
hashmap.TryAdd(key, randomValue);
blobBuilderHashMap.TryAdd(key, randomValue);
// 50/50, query random and existing keys
queries[i * 2] = GetRandomKey(random);
queries[i * 2 + 1] = key;
}
}
/// <summary>
/// Returns a random element and removes it from the list
/// </summary>
public static T PopRandom <T>(this List <T> list, ref MRandom random)
{
if (list == null)
{
throw new ArgumentNullException(nameof(list));
}
if (list.Count == 0)
{
throw new ArgumentException("Empty list");
}
int index = random.NextInt(0, list.Count);
T item = list[index];
list.RemoveAt(index);
return(item);
}
public static Entity GetHealthPotion(ref Unity.Mathematics.Random random, EntityCommandBuffer commandBuffer)
{
var itemEntity = commandBuffer.CreateEntity();
var storeIndex = Array.FindIndex(ItemsManagerComponent.Instance.ItemsStoreComponent.Items,
item => item.ItemType == ItemType.Potion);
var iconIndex = random.NextInt(0,
ItemsManagerComponent.Instance.ItemsStoreComponent.Items[storeIndex].Icons.Length);
commandBuffer.AddComponent(itemEntity, new ItemComponent
{
StoreIndex = storeIndex,
IconIndex = iconIndex,
Level = 1
});
return(itemEntity);
}
public static void CrossOver(Network a, Network b, Network c, ref Rng r)
{
for (int l = 0; l < c.Layers.Count; l++)
{
int paramsLeft = c.Layers[l].ParamCount;
while (paramsLeft > 0)
{
int copySeqLength = Math.Min(r.NextInt(4, 16), paramsLeft);
Network parent = r.NextDouble() < 0.5f ? a : b;
for (int p = 0; p < copySeqLength; p++)
{
c.Layers[l][p] = parent.Layers[l][p];
}
paramsLeft -= copySeqLength;
}
}
}
protected override void OnUpdate()
{
Random r = new Random(Convert.ToUInt32(new System.Random().Next()));
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// get entities with position
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
NativeList <Entity> entitiesWithPosition = new NativeList <Entity>(Allocator.TempJob);
Entities
.ForEach((Entity e, ref PositionComponentData component) => {
entitiesWithPosition.Add(e);
})
.Schedule();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// shuffle
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Job
.WithCode(() => {
// https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modern_method
for (int i = entitiesWithPosition.Length - 1; i >= 1; i--)
{
int j = r.NextInt(0, i + 1); // max is not inclusive
(entitiesWithPosition[i], entitiesWithPosition[j]) =
(entitiesWithPosition[j], entitiesWithPosition[i]);
}
})
.Schedule();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// do something with the shuffled list and dispose of it
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Job
.WithCode(() => {
if (entitiesWithPosition.IsEmpty)
{
return;
}
int index = entitiesWithPosition[0].Index;
Debug.Log($"Initial shuffled entity index: {index}");
})
.WithDisposeOnCompletion(entitiesWithPosition)
.Schedule();
}
