private IEnumerator PlayerTurn()
{
isPlayerTurn = true;
isAwaitingUserInput = true;
while (isAwaitingUserInput)
{
yield return(null);
}
var playerIndex = random.NextInt(allySpawnPoints.Count);
var player = allySpawnPoints[playerIndex];
var enemyIndex = random.NextInt(enemySpawnPoints.Count);
var enemy = enemySpawnPoints[enemyIndex];
var positionOld = player.transform.position;
var enemyAttackPanel = enemy.transform.Find("AttackPanel").gameObject;
yield return(player.transform.DOMove(enemyAttackPanel.transform.position, 0.3f).WaitForCompletion());
yield return(player.Attack());
enemies[enemyIndex].health -= 10;
yield return(player.transform.DOMove(positionOld, 0.3f).WaitForCompletion());
isPlayerTurn = false;
}
void Spawn()
{
if (prefab == Entity.Null)
{
return;
}
var random = new Unity.Mathematics.Random((uint)new System.Random().Next());
var entities = new NativeArray <Entity>(spawnCount, Allocator.Temp);
entityManager.Instantiate(prefab, entities);
for (var i = 0; i < entities.Length; ++i)
{
entityManager.AddComponentData(entities[i], new Translation
{
Value = new float3(
random.NextInt(-25, 25),
2,
random.NextInt(-25, 25)
)
});
}
entities.Dispose();
}
protected override void OnUpdate(EntityCommandBuffer.Concurrent ecb)
{
var random = new Random(mainRandom.NextUInt(uint.MinValue, uint.MaxValue));
var minSpeed = setup.minSpeed;
var maxSpeed = setup.maxSpeed;
var movementEnumCount = MovementEnumCount;
Entities
.WithAll <EnemyTag>()
.WithNone <MovementTypeTag>()
.ForEach((Entity entity, int entityInQueryIndex, ref Rotation rot) =>
{
ecb.AddComponent <MovementTypeTag>(entityInQueryIndex, entity);
var i = random.NextInt(0, 1) * 2 - 1; // -1 or 1
rot.Value = quaternion.Euler(0, i * math.PI / 2, 0);
var index = (MovementEnum)random.NextInt(0, movementEnumCount);
index = MovementEnum.Spiral;
switch (index)
{
case MovementEnum.Linear:
break;
case MovementEnum.Spiral:
ecb.AddComponent(entityInQueryIndex, entity, new MovementSpiral
{
speed = random.NextFloat(minSpeed, maxSpeed)
});
break;
}
})
.ScheduleParallel();
}
private void FixedUpdate()
{
var rnd = _rnd.NextInt(0, 5) > 3;
Debug.Log(rnd);
if (_jump)
{
ProcessJump();
_jump = false;
}
if (_fire)
{
try
{
FireProjectile(_direction);
}
finally
{
_fire = false;
}
}
ProcessMove();
}
public int GetSpawnVehicleIndex(ref Unity.Mathematics.Random random, uint poolSpawn)
{
if (poolSpawn == 0)
{
return(random.NextInt(0, VehiclePool.Length));
}
// Otherwise we need to figure out which vehicle to assign
// Todo: could bake the num set bits out!
uint pool = poolSpawn;
uint numSetBits = poolSpawn - ((poolSpawn >> 1) & 0x55555555);
numSetBits = (numSetBits & 0x33333333) + ((numSetBits >> 2) & 0x33333333);
numSetBits = ((numSetBits + (numSetBits >> 4) & 0x0F0F0F0F) * 0x01010101) >> 24;
// we now have a number between 0 & 32,
int chosenBitIdx = random.NextInt(0, (int)numSetBits) + 1;
uint poolTemp = poolSpawn;
uint lsb = poolTemp;
//TODO: make the below better?
while (chosenBitIdx > 0)
{
lsb = poolTemp;
poolTemp &= poolTemp - 1; // clear least significant set bit
lsb ^= poolTemp; // lsb contains the index (1<<index) of the pool for this position
chosenBitIdx--;
}
float fidx = math.log2(lsb);
return((int)(fidx));
}
protected override void OnUpdate()
{
foreach (Pool entity in GetEntities <Pool>())
{
List <GameObject> activeArtifacts = entity.artifactsPoolComponent.activePool;
List <GameObject> passiveArtifacts = entity.artifactsPoolComponent.passivePool;
int passiveCount = entity.artifactsPoolComponent.passiveCount;
int activeCount = entity.artifactsPoolComponent.activeCount;
Random random = Rand.GetRandom();
List <GameObject> active = new List <GameObject>();
List <GameObject> passive = new List <GameObject>();
for (byte i = 0; i < passiveCount; i++)
{
int randId = random.NextInt(passiveArtifacts.Count);
GameObject gameObject = GameObject.Instantiate(passiveArtifacts[randId]);
passiveArtifacts.RemoveAt(randId);
gameObject.GetComponent <ArtifactComponent>().id = i;
passive.Add(gameObject);
}
for (byte i = 0; i < activeCount; i++)
{
int randId = random.NextInt(activeArtifacts.Count);
GameObject gameObject = GameObject.Instantiate(activeArtifacts[randId]);
activeArtifacts.RemoveAt(randId);
gameObject.GetComponent <ArtifactComponent>().id = i;
active.Add(gameObject);
}
entity.artifactsPoolComponent.active = active;
entity.artifactsPoolComponent.passive = passive;
}
Enabled = false;
}
static int2 RandomPointInRoom(ref Random rand, IntRect room)
{
int x = rand.NextInt(room.xMin, room.xMax + 1);
int y = rand.NextInt(room.yMin, room.yMax + 1);
return(new int2(x, y));
}
IEnumerator SpawnZombieBatch()
{
while (spawnedCount < 5000)
{
yield return(new WaitForSeconds(4));
spawnedCount += 80;
Unity.Mathematics.Random rand = new Unity.Mathematics.Random(42);
var prefab = GameObjectConversionUtility.ConvertGameObjectHierarchy(zombiePrefab, World.DefaultGameObjectInjectionWorld);
var entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
uint count = 0;
while (count++ < 100)
{
var instance = entityManager.Instantiate(prefab);
var space = rand.NextInt2(minPos, maxPos);
space.x += rand.NextInt(-2, 2);
space.y += rand.NextInt(-2, 2);
var position = transform.TransformPoint(new float3(space.x, 1, space.y));
entityManager.SetComponentData(instance, new Translation {
Value = position
});
var movementData = entityManager.GetComponentData <MovementComponent>(instance);
movementData.speed += rand.NextFloat(-4f, 0f);
entityManager.SetComponentData(instance, movementData);
}
}
}
private void InitializeRandomStats(int currentLevel, ref Unity.Mathematics.Random random,
ref HealthStatComponent healthStatComponent,
ref AttackStatComponent attackStatComponent,
ref DefenceStatComponent defenceStatComponent,
ref MagicStatComponent magicStatComponent)
{
var points = random.NextInt(currentLevel, currentLevel * 2);
for (var i = 1; i < points; i++)
{
var randomStat = random.NextInt(0, 100);
if (randomStat < 25)
{
healthStatComponent.PointsSpent++;
}
else if (randomStat < 50)
{
attackStatComponent.PointsSpent++;
}
else if (randomStat < 75)
{
defenceStatComponent.PointsSpent++;
}
else if (randomStat < 100)
{
magicStatComponent.PointsSpent++;
}
}
}
public unsafe void TestMeshColliderCreateWithInvalidIndices()
{
int numTriangles = 10;
var vertices = new NativeArray <float3>(numTriangles * 3, Allocator.Persistent);
var triangles = new NativeArray <int>(numTriangles * 3, Allocator.Persistent);
for (int i = 0; i < numTriangles * 3; i++)
{
vertices[i] = new float3((float)i, 1.0f * (float)(i % 2), (float)(i + 1));
triangles[i] = i;
}
Random rnd = new Random(0x12345678);
for (int i = 0; i < 100; i++)
{
int indexToChange = rnd.NextInt(0, triangles.Length - 1);
int invalidValue = rnd.NextInt() * (rnd.NextBool() ? -1 : 1);
triangles[indexToChange] = invalidValue;
TestUtils.ThrowsException <System.ArgumentException>(
() => Unity.Physics.MeshCollider.Create(vertices, triangles)
);
triangles[indexToChange] = indexToChange;
}
triangles.Dispose();
vertices.Dispose();
}
public static void ANDNOT_1Byte()
{
Unity.Mathematics.Random rng = new Unity.Mathematics.Random(Helpers.GetRngSeed);
for (int i = 0; i < 3; i++)
{
byte operand = (byte)rng.NextInt(byte.MinValue + 1, byte.MaxValue + 1);
NativeArray <byte> test = new NativeArray <byte>(rng.NextInt(1, 1_000_000), Allocator.Persistent);
for (int j = 0; j < test.Length; j++)
{
test[j] = (byte)rng.NextUInt();
}
ulong scalar = 0;
for (int j = 0; j < test.Length; j++)
{
scalar += (ulong)math.countbits(0x0000_00FF & (~(uint)test[j] & operand));
}
Assert.AreEqual(scalar, test.SIMD_CountBits(BitwiseOperation.ANDNOT, operand));
test.Dispose();
}
}
protected override void OnUpdate()
{
gird = PathFindingSetup.Instance.pathfindingGrid;
Entities.ForEach((Entity entity, DynamicBuffer <PathPosition> pathPositionBuff, ref Translation translation, ref PathFollow pathFollow) =>
{
if (pathFollow.index >= 0)
{
var pathPosition = pathPositionBuff[pathFollow.index].Position;
var targetPosition = new float3(pathPosition.x, pathPosition.y, 0);
if (math.distance(targetPosition, translation.Value) < .1f)
{
//next way point
pathFollow.index--;
return;
}
var moveDir = math.normalize(targetPosition - translation.Value);
translation.Value += moveDir * _moveSpeed * Time.DeltaTime;
}
else if (pathFollow.index == -1)
{
//just finish last move
pathFollow.index = -2;
gird.GetXY(translation.Value, out var startX, out var startY);
EntityManager.AddComponentData(entity, new PathFindingParam
{
startPos = new int2(startX, startY),
endPos = new int2(random.NextInt(0, 30), random.NextInt(0, 15)),
});
}
});
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
int mapWidth = PathfindingGridSetup.Instance.pathfindingGrid.GetWidth();
int mapHeight = PathfindingGridSetup.Instance.pathfindingGrid.GetHeight();
float3 originPosition = float3.zero;
float cellSize = PathfindingGridSetup.Instance.pathfindingGrid.GetCellSize();
Unity.Mathematics.Random random = new Unity.Mathematics.Random(this.random.NextUInt(1, 10000));
EntityCommandBuffer.Concurrent entityCommandBuffer = endSimulationEntityCommandBufferSystem.CreateCommandBuffer().ToConcurrent();
JobHandle jobHandle = Entities.WithNone <PathfindingParams>().ForEach((Entity entity, int entityInQueryIndex, in PathFollow pathFollow, in Translation translation) => {
if (pathFollow.pathIndex == -1)
{
GetXY(translation.Value + new float3(1, 1, 0) * cellSize * +.5f, originPosition, cellSize, out int startX, out int startY);
ValidateGridPosition(ref startX, ref startY, mapWidth, mapHeight);
int endX = random.NextInt(0, mapWidth);
int endY = random.NextInt(0, mapHeight);
entityCommandBuffer.AddComponent(entityInQueryIndex, entity, new PathfindingParams
{
startPosition = new int2(startX, startY), endPosition = new int2(endX, endY)
});
}
}).Schedule(inputDeps);
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 Execute()
{
var random = new Random();
random.InitState(Seed);
var holeCount = (int)(Generator.SizeX * Generator.SizeY * 0.05f);
for (int i = 0; i < holeCount; ++i)
{
var coord = new int2(random.NextInt(Generator.SizeX), random.NextInt(Generator.SizeY));
// Do not spawn holes in the 4 corners
if ((coord.x == 0 && coord.y == 0) ||
(coord.x == 0 && coord.y == Generator.SizeY - 1) ||
(coord.x == Generator.SizeX - 1 && coord.y == 0) ||
(coord.x == Generator.SizeX - 1 && coord.y == Generator.SizeY - 1))
{
continue;
}
// Do not place holes under homebases
if (HomebaseMap.ContainsKey(coord))
{
continue;
}
if (FloorMap.ContainsKey(coord))
{
CommandBuffer.DestroyEntity(FloorMap[coord]);
FloorMap.Remove(coord);
}
}
}
protected override void OnUpdate()
{
var cursorsToInit = m_Cursors.CalculateEntityCount();
if (cursorsToInit <= 0)
{
return;
}
var boardCount = m_BoardQuery.CalculateEntityCount();
if (boardCount <= 0)
{
return;
}
var board = m_BoardQuery.GetSingleton <LbBoard>();
var random = new Unity.Mathematics.Random();
random.InitState(1);
Entities.ForEach((Entity entity, ref LbCursorInit ci, ref LbMovementTarget movement, ref LbDistanceToTarget distance) =>
{
var position = new float3(random.NextInt(0, board.SizeX), 1, random.NextInt(0, board.SizeY));
movement.To = position;
distance.Value = 0.0f;
World.EntityManager.RemoveComponent <LbCursorInit>(entity);
});
}
public static void ORNOT_4Bytes()
{
Unity.Mathematics.Random rng = new Unity.Mathematics.Random(Helpers.GetRngSeed);
for (int i = 0; i < 3; i++)
{
uint operand = (uint)rng.NextInt();
NativeArray <uint> test = new NativeArray <uint>(rng.NextInt(1, 1_000_000), Allocator.Persistent);
for (int j = 0; j < test.Length; j++)
{
test[j] = (uint)rng.NextUInt();
}
ulong scalar = 0;
for (int j = 0; j < test.Length; j++)
{
scalar += (ulong)math.countbits((~(uint)test[j] | operand));
}
Assert.AreEqual(scalar, test.SIMD_CountBits(BitwiseOperation.ORNOT, operand));
test.Dispose();
}
}
public static void XNOR_2Bytes()
{
Unity.Mathematics.Random rng = new Unity.Mathematics.Random(Helpers.GetRngSeed);
for (int i = 0; i < 3; i++)
{
ushort operand = (ushort)rng.NextInt(ushort.MinValue + 1, ushort.MaxValue + 1);
NativeArray <ushort> test = new NativeArray <ushort>(rng.NextInt(1, 1_000_000), Allocator.Persistent);
for (int j = 0; j < test.Length; j++)
{
test[j] = (ushort)rng.NextUInt();
}
ulong scalar = 0;
for (int j = 0; j < test.Length; j++)
{
scalar += (ulong)math.countbits(0x0000_FFFF & ~((uint)(test[j] ^ operand)));
}
Assert.AreEqual(scalar, test.SIMD_CountBits(BitwiseOperation.XNOR, operand));
test.Dispose();
}
}
void generateRandomMotion(ref Random rnd, out MotionVelocity velocity, out MotionData motion, bool allowInfiniteMass)
{
motion = new MotionData
{
WorldFromMotion = generateRandomTransform(ref rnd),
BodyFromMotion = generateRandomTransform(ref rnd)
};
float3 inertia = rnd.NextFloat3(1e-3f, 100.0f);
switch (rnd.NextInt(3))
{
case 0: // all values random
break;
case 1: // two values the same
int index = rnd.NextInt(3);
inertia[(index + 1) % 2] = inertia[index];
break;
case 2: // all values the same
inertia = inertia.zzz;
break;
}
velocity = new MotionVelocity
{
LinearVelocity = rnd.NextBool() ? float3.zero : rnd.NextFloat3(-50.0f, 50.0f),
AngularVelocity = rnd.NextBool() ? float3.zero : rnd.NextFloat3(-50.0f, 50.0f),
InverseInertiaAndMass = (allowInfiniteMass && rnd.NextBool()) ? float4.zero : new float4(1.0f / inertia, rnd.NextFloat(1e-3f, 100.0f))
};
}
public void Execute()
{
PlaceSpawner(ref CommandBuffer, Generator.Player1Cursor, int2.zero);
PlaceSpawner(ref CommandBuffer, Generator.Player2Cursor, int2.zero);
PlaceSpawner(ref CommandBuffer, Generator.Player3Cursor, int2.zero);
PlaceSpawner(ref CommandBuffer, Generator.Player4Cursor, int2.zero);
var spawnLocation1 = new int2(0, 0);
var spawnLocation2 = new int2(Generator.SizeX - 1, 0);
var spawnLocation3 = new int2(0, Generator.SizeY - 1);
var spawnLocation4 = new int2(Generator.SizeX - 1, Generator.SizeY - 1);
PlaceSpawner(ref CommandBuffer, Generator.SpawnerPrefab, spawnLocation1);
PlaceSpawner(ref CommandBuffer, Generator.SpawnerPrefab, spawnLocation2);
PlaceSpawner(ref CommandBuffer, Generator.SpawnerPrefab, spawnLocation3);
PlaceSpawner(ref CommandBuffer, Generator.SpawnerPrefab, spawnLocation4);
var random = new Random();
random.InitState(Seed);
var checkFlag = kHoleFlag | kHomebaseFlag;
var spawnerMap = new NativeHashMap <int2, byte>(Generator.AdditionalSpawners + 4, Allocator.Temp);
spawnerMap.TryAdd(spawnLocation1, 1);
spawnerMap.TryAdd(spawnLocation2, 1);
spawnerMap.TryAdd(spawnLocation3, 1);
spawnerMap.TryAdd(spawnLocation4, 1);
var remaining = Generator.AdditionalSpawners;
while (remaining > 0)
{
var coord = new int2(random.NextInt(Generator.SizeX), random.NextInt(Generator.SizeY));
var index = coord.y * Generator.SizeY + coord.x;
// Avoid placing spawners in holes, homebases and on top of other spawners
var cellMapValue = DirectionBuffer[index].Value & checkFlag;
if (cellMapValue == kHoleFlag || cellMapValue == kHomebaseFlag || spawnerMap.ContainsKey(coord))
{
continue;
}
PlaceSpawner(ref CommandBuffer, Generator.SpawnerPrefab, coord);
spawnerMap.TryAdd(coord, 1);
remaining--;
}
spawnerMap.Dispose();
var entity = CommandBuffer.CreateEntity();
CommandBuffer.AddComponent(entity, new LbGameTimer()
{
Value = LbConstants.GameTime
});
}
public void Execute(Entity entity, int index, ref LbArrowPosition arrowPosition, [ReadOnly] ref LbPlayer player)
{
var random = new Random((uint)(Seed + index));
var position = new float3(random.NextInt(0, Size), 1, random.NextInt(0, Size));
arrowPosition.Value = position;
CommandBuffer.SetComponent(index, entity, arrowPosition);
CommandBuffer.RemoveComponent <LbArrow>(index, entity);
}
// public int i_eliteScore ;
public void Execute(int i)
{
int i_eliteProbablityCount = na_indexProbability.Length;
random.InitState((uint)(random.NextInt(i_eliteProbablityCount) + na_randomValues [i]));
random.NextInt2();
int i_firstPorbabilityIndex = random.NextInt(0, i_eliteProbablityCount);
int i_secondPorbabilityIndex = random.NextInt(0, i_eliteProbablityCount);
int i_firstParentEntityIndex = na_indexProbability [i_firstPorbabilityIndex];
int i_secondParentEntityIndex = na_indexProbability [i_secondPorbabilityIndex];
Entity firstParentEntity = na_parentPopulationEntities [i_firstParentEntityIndex];
Entity secondParentEntity = na_parentPopulationEntities [i_secondParentEntityIndex];
DynamicBuffer <NNInput2HiddenLayersWeightsBuffer> a_firstParentInput2HiddenLayersWeights = input2HiddenLayersWeightsBuffer [firstParentEntity];
DynamicBuffer <NNHidden2OutputLayersWeightsBuffer> a_firstParentHidden2OutputLayersWeights = hidden2OutputLayersWeightsBuffer [firstParentEntity];
DynamicBuffer <NNInput2HiddenLayersWeightsBuffer> a_secondParentInput2HiddenLayersWeights = input2HiddenLayersWeightsBuffer [secondParentEntity];
DynamicBuffer <NNHidden2OutputLayersWeightsBuffer> a_secondParentHidden2OutputLayersWeights = hidden2OutputLayersWeightsBuffer [secondParentEntity];
Entity offspringEntity = na_offspringPopulationEntities [i];
DynamicBuffer <NNInput2HiddenLayersWeightsBuffer> a_offspringInput2HiddenLayersWeights = input2HiddenLayersWeightsBuffer [offspringEntity];
DynamicBuffer <NNHidden2OutputLayersWeightsBuffer> a_offspringtHidden2OutputLayersWeights = hidden2OutputLayersWeightsBuffer [offspringEntity];
int i_input2HiddenLayersWeightsCount = a_firstParentInput2HiddenLayersWeights.Length;
int i_hidden2OutputLayersWeightsCount = a_firstParentHidden2OutputLayersWeights.Length;
a_offspringInput2HiddenLayersWeights.ResizeUninitialized(i_input2HiddenLayersWeightsCount);
a_offspringtHidden2OutputLayersWeights.ResizeUninitialized(i_hidden2OutputLayersWeightsCount);
// 50 / 50 chance to get trait (NN weights) from parent A or B.
for (int j = 0; j < a_offspringInput2HiddenLayersWeights.Length; j++)
{
float f = random.NextFloat() < 0.5f ? a_firstParentInput2HiddenLayersWeights [j].f : a_secondParentInput2HiddenLayersWeights [j].f;
a_offspringInput2HiddenLayersWeights [j] = new NNInput2HiddenLayersWeightsBuffer()
{
f = f
};
}
for (int j = 0; j < a_offspringtHidden2OutputLayersWeights.Length; j++)
{
float f = random.NextFloat() < 0.5f ? a_firstParentHidden2OutputLayersWeights [j].f : a_secondParentHidden2OutputLayersWeights [j].f;
a_offspringtHidden2OutputLayersWeights [j] = new NNHidden2OutputLayersWeightsBuffer()
{
f = f
};
}
}
Entity RandomCreateVoxel(int jobIndex, Prefabs prefabs, int y, float height)
{
if (y + 1 > height)
{
var randomFactroy = Random.NextInt(0, 39);
if (randomFactroy < 10)
{
return(CommandBuffer.Instantiate(jobIndex, prefabs.GroundGreen));
}
if (randomFactroy < 20)
{
return(CommandBuffer.Instantiate(jobIndex, prefabs.GroundBrown));
}
if (randomFactroy < 30)
{
return(CommandBuffer.Instantiate(jobIndex, prefabs.GreyStone));
}
// if (randomFactroy < 40)
// return CommandBuffer.Instantiate (jobIndex, prefabs.Ground3);
// if (randomFactroy < 50)
// return CommandBuffer.Instantiate (jobIndex, prefabs.Ground4);
// if (randomFactroy < 60)
// return CommandBuffer.Instantiate (jobIndex, prefabs.Ground5);
// if (randomFactroy < 70)
// return CommandBuffer.Instantiate (jobIndex, prefabs.GroundVegetation0);
// if (randomFactroy < 80)
// return CommandBuffer.Instantiate (jobIndex, prefabs.GroundVegetation1);
// if (randomFactroy < 90)
// return CommandBuffer.Instantiate (jobIndex, prefabs.GroundVegetation2);
// if (randomFactroy < 100)
// return CommandBuffer.Instantiate (jobIndex, prefabs.GroundVegetation3);
// if (randomFactroy < 110)
// return CommandBuffer.Instantiate (jobIndex, prefabs.GroundVegetation4);
// if (randomFactroy < 120)
// return CommandBuffer.Instantiate (jobIndex, prefabs.GroundVegetation5);
}
if (y >= 0)
{
var randomFactroy = Random.NextInt(0, 39);
if (randomFactroy < 10)
{
return(CommandBuffer.Instantiate(jobIndex, prefabs.GroundBrown));
}
if (randomFactroy < 20)
{
return(CommandBuffer.Instantiate(jobIndex, prefabs.Sand));
}
if (randomFactroy < 30)
{
return(CommandBuffer.Instantiate(jobIndex, prefabs.GreyStone));
}
}
return(CommandBuffer.Instantiate(jobIndex, prefabs.GroundBrown));
}
void TargetHit(float3 position)
{
if (zoomedForVertices)
{
GameObject.Instantiate(hitsSmall[_rand.NextInt(0, hitsSmall.Length)], position, quaternion.identity);
}
else
{
GameObject.Instantiate(hitsLarge[_rand.NextInt(0, hitsLarge.Length)], position, quaternion.identity);
}
}
private IEnumerator EnemyTurn(bool isMonster)
{
// Special case for the Lancelot battle.
if (_activeEnemy.damage == 0)
{
yield break;
}
var positionPrev = _activeEnemy.transform.position;
GameObject targetPlayer;
if (GameState.Instance.ArthurHasExcalibur)
{
targetPlayer = _players.First();
}
else
{
targetPlayer = _players[_random.NextInt(0, _players.Count)];
}
var animator = _activeEnemy.GetComponent <Animator>();
animator.SetBool(_aidIsMoving, false);
animator.SetBool(_aidIsAttacking, true);
yield return(_activeEnemy.transform.DOMove(targetPlayer.transform.position, Constants.SpeedAttack).SetSpeedBased().WaitForCompletion());
if (isMonster)
{
audioSourceSound.clip = audioClipHitMonster;
}
else
{
audioSourceSound.clip = audioClipHitBoss;
}
audioSourceSound.Play();
if (targetPlayer == _players[0])
{
GameState.Instance.DamageArthur(_activeEnemy.damage);
}
else
{
GameState.Instance.DamageLancelot(_activeEnemy.damage);
}
yield return(_activeEnemy.transform.DOMove(positionPrev, Constants.SpeedAttack).SetSpeedBased().WaitForCompletion());
animator.SetBool(_aidIsAttacking, false);
}
static void GenerateRooms(DynamicBuffer <MapTiles> map, MapData mapData, GenerateMap genData, DynamicBuffer <IntRect> rooms)
{
Random rand = new Random((uint)genData.seed);
for (int i = 0; i < genData.iterationCount; ++i)
{
int w = rand.NextInt(genData.minRoomSize, genData.maxRoomSize);
int h = rand.NextInt(genData.minRoomSize, genData.maxRoomSize);
int x = rand.NextInt(1, mapData.width - w - 1);
int y = rand.NextInt(1, mapData.height - h - 1);
IntRect newRoom = IntRect.FromPositionSize(x, y, w, h);
bool ok = true;
for (int roomIndex = 0; roomIndex < rooms.Length; ++roomIndex)
{
var existing = rooms[roomIndex];
// Accounting for walls during overlap test
existing.Size += 2;
existing.Position--;
if (newRoom.Intersect(existing))
{
ok = false;
break;
}
}
if (ok)
{
BuildRoom(map, mapData, newRoom);
if (rooms.Length > 0)
{
var newPos = newRoom.Center;
var prevPos = rooms[rooms.Length - 1].Center;
if (rand.NextInt(0, 2) == 1)
{
BuildHorizontalTunnel(map, mapData, prevPos.x, newPos.x, prevPos.y);
BuildVerticalTunnel(map, mapData, prevPos.y, newPos.y, newPos.x);
}
else
{
BuildVerticalTunnel(map, mapData, prevPos.y, newPos.y, prevPos.x);
BuildHorizontalTunnel(map, mapData, prevPos.x, newPos.x, newPos.y);
}
}
rooms.Add(newRoom);
}
}
}
protected override void OnUpdate()
{
if (UnityEngine.Time.time - m_LastSpawn < m_SpawnRate)
{
return;
}
m_LastSpawn = UnityEngine.Time.time - m_Random.NextFloat(-GameData.Instance.spawnRateNoise, GameData.Instance.spawnRateNoise);
int batchCount = m_Random.NextInt(GameData.Instance.enemySpawnBatchCountMin, GameData.Instance.enemySpawnBatchCountMax);
for (int i = 0; i < batchCount; i++)
{
var instanceSpawnPos = FirstWaypointPos +
new float3(m_Random.NextFloat(-GameData.Instance.spawnPositionNoise, GameData.Instance.spawnPositionNoise),
0, m_Random.NextFloat(-GameData.Instance.spawnPositionNoise, GameData.Instance.spawnPositionNoise));
Entity prefab = GameData.Instance.EnemyEntityPrefab;
Entity instance = EntityManager.Instantiate(prefab);
EntityManager.SetName(instance, "Enemy");
EntityManager.AddComponentData(instance, new AgentTag {
});
EntityManager.SetComponentData(instance, new Translation {
Value = instanceSpawnPos
});
EntityManager.AddComponentData(instance, new MoveSpeedComponent {
Value = GameData.Instance.agentMoveSpeed
});
EntityManager.AddComponentData(instance, new FollowWaypointTag {
});
EntityManager.AddComponentData(instance, new WaypointMovementComponent {
CurrentTargetIndex = 0
});
EntityManager.AddComponentData(instance, new AttackRadiusComponent {
Value = GameData.Instance.agentScanRadius
});
EntityManager.AddSharedComponentData(instance, new EnemyTeamComponent());
int maxHealth = m_Random.NextInt(GameData.Instance.agentInitialHealthMin, GameData.Instance.agentInitialHealthMax);
EntityManager.AddComponentData(instance, new HealthComponent {
Health = maxHealth, MaxHealth = maxHealth
});
EntityManager.AddComponentData(instance, new AttackStatusComponent {
});
}
StatDisplay.Instance.AgentCount += batchCount;
}
public void PathRandomObstacles()
{
using (var grid = new TestGrid(31))
{
int obstacleCount = 32;
var rand = new Unity.Mathematics.Random(0xF545AA3F);
for (int i = 0; i < obstacleCount; i++)
{
var faceIndex = rand.NextInt(0, 6);
var xy = rand.NextInt2(new int2(grid.RowCount, grid.RowCount));
var sourcePosition = new CartesianGridCoordinates {
x = (short)xy.x, y = (short)xy.y
};
var cubeFace = new CartesianGridOnCubeFace {
Value = (byte)faceIndex
};
var cellIndex = CartesianGridOnCubeUtility.CellIndex(sourcePosition, cubeFace, grid.RowCount);
if (rand.NextBool())
{
grid.AddWallWest(cellIndex);
}
else
{
grid.AddWallSouth(cellIndex);
}
}
int testCount = 64;
for (int i = 0; i < testCount; i++)
{
var sourceXY = rand.NextInt2(new int2(grid.RowCount, grid.RowCount));
var sourceFaceIndex = rand.NextInt(0, 6);
var sourceCubeFace = new CartesianGridOnCubeFace {
Value = (byte)sourceFaceIndex
};
var sourcePosition = new CartesianGridCoordinates {
x = (short)sourceXY.x, y = (short)sourceXY.y
};
var targetXY = rand.NextInt2(new int2(grid.RowCount, grid.RowCount));
var targetFaceIndex = rand.NextInt(0, 6);
var targetCubeFace = new CartesianGridOnCubeFace {
Value = (byte)targetFaceIndex
};
var targetPosition = new CartesianGridCoordinates {
x = (short)targetXY.x, y = (short)targetXY.y
};
grid.WalkPathDistance(sourcePosition, sourceCubeFace, targetPosition, targetCubeFace);
}
}
}
private static void FullUpdate(ref Translation position, ref Rotation rotation, ref BoidData boid, NativeArray <BoidData> boidsData,
float agentNeighbourDistance, float agentAvoidDistance, float3 goalPos, float deltaTime,
float minSpeed, float maxSpeed, Bounds bounds, uint baseSeed, float avoidCollidersDistance, PhysicsWorld world)
{
float3 direction = float3.zero;
float3 forward = math.forward(rotation.Value);
bool turning;
RaycastInput rayInput = new RaycastInput
{
Start = boid.CurrentPosition,
End = boid.CurrentPosition + avoidCollidersDistance * forward,
Filter = CollisionFilter.Default
};
if (!bounds.Contains(boid.CurrentPosition)) //handle getting out of bounds
{
turning = true;
direction = (float3)bounds.center - boid.CurrentPosition;
}
else if (world.CastRay(rayInput, out Unity.Physics.RaycastHit hit))
{
turning = true;
direction = (float3)Vector3.Reflect(forward, hit.SurfaceNormal);
}
else
{
turning = false;
}
if (turning) //adjust path if needed
{
rotation.Value = math.slerp(rotation.Value, quaternion.LookRotation(direction, new float3(0, 1, 0)), boid.RotationSpeed * deltaTime);
}
else //random direction or direction calculated based on the flocking rules
{
Unity.Mathematics.Random rand = new Unity.Mathematics.Random(baseSeed + boid.Index);
if (rand.NextInt(0, 100) < 10)
{
boid.Speed = rand.NextFloat(minSpeed, maxSpeed);
}
if (rand.NextInt(0, 100) < 20)
{
ApplyBoidRules(ref boid, ref rotation, boidsData, agentNeighbourDistance, agentAvoidDistance, goalPos, deltaTime);
}
}
//move agent forward, along its direction
position.Value += boid.Speed * math.forward(rotation.Value) * deltaTime;
boid.CurrentPosition = position.Value;
}
void CreateObstacleEntities(GameObject obstaclePrefab, SimulationConfig config, NativeList <Entity> obstacles)
{
var gameConversionSettings = GameObjectConversionSettings.FromWorld(World, null);
var entityPrefab = GameObjectConversionUtility.ConvertGameObjectHierarchy(obstaclePrefab, gameConversionSettings);
var random = new Random(config.Seed);
var obstacleRings = config.ObstacleRingsCount;
var obstaclesPerRing = config.ObstaclesPerRing;
var mapSize = config.MapSize;
var obstacleRadius = EntityManager.GetComponentData <Radius>(entityPrefab).Value;
var scale = new float3(2, 2, .1f) * obstacleRadius;
obstacleRadius *= mapSize;
for (var i = 1; i <= obstacleRings; i++)
{
var ringRadius = (i / (obstacleRings + 1f)) * (mapSize * .5f);
var circumference = ringRadius * 2f * math.PI;
var maxCount = (int)math.ceil(circumference / (2f * obstacleRadius) * 2f);
var offset = random.NextInt(0, maxCount);
var holeCount = random.NextInt(1, 3);
for (int j = 0; j < maxCount; j++)
{
var t = (float)j / maxCount;
if ((t * holeCount) % 1f < obstaclesPerRing)
{
var angle = (j + offset) / (float)maxCount * (2f * Mathf.PI);
var position = new float3(mapSize * .5f + Mathf.Cos(angle) * ringRadius, mapSize * .5f + Mathf.Sin(angle) * ringRadius, 0);
// Debug.DrawRay(position / mapSize,-Vector3.forward * .05f,Color.green,10000f);
var obstacle = EntityManager.Instantiate(entityPrefab);
EntityManager.AddComponentData(obstacle, new Translation {
Value = position / mapSize
});
EntityManager.AddComponentData(obstacle, new NonUniformScale {
Value = scale
});
EntityManager.AddComponentData(obstacle, new ObstacleTag());
obstacles.Add(obstacle);
#if UNITY_EDITOR
EntityManager.SetName(obstacle, $"Obstacle:{obstacle.Index}");
#endif
}
}
}
Enabled = false;
}
