public void Start()
{
seed = useRandomSeed ? Random.Range(int.MinValue, int.MaxValue) : staticSeed;
Random.InitState(seed);
Debug.Log($"seed: {seed}");
SpawnFood(foodCount);
genomes.AddRange(RandomGenomes(randomGenomeCount));
for (var i = 0; i < organismCount; i++)
{
var go = Instantiate(organismPrefab, Random.insideUnitSphere * spawnRadius, Random.rotation, organismParent);
var organism = go.GetComponent <Organism>();
organism.Initialize(new OrganismConfig
{
Seed = Random.Range(int.MinValue, int.MaxValue),
Dialect = dialect.ToCharArray(),
StartingEnergy = startingEnergy,
Mutate = false,
NewGenome = genomes[Random.Range(0, genomes.Count)],
Generation = 1,
Born = Time.frameCount,
});
}
}
public ImprovedPerlinNoise(int seed)
{
Random.InitState(seed);
int i;
for (i = 0; i < SIZE; i++)
{
Permutation[i] = i;
}
while (--i != 0)
{
var k = Permutation[i];
var j = Random.Range(0, SIZE);
Permutation[i] = Permutation[j];
Permutation[j] = k;
}
for (i = 0; i < SIZE; i++)
{
Permutation[SIZE + i] = Permutation[i];
}
}
private void SetupWaves(bool custom)
{
if (!custom)
{
//create basic waves based off basic wave settings
var backupSeed = Random.state;
Random.InitState(surfaceData.randomSeed);
var basicWaves = surfaceData._basicWaveSettings;
var a = basicWaves.amplitude;
var d = basicWaves.direction;
var l = basicWaves.wavelength;
var numWave = basicWaves.numWaves;
_waves = new Wave[numWave];
var r = 1f / numWave;
for (var i = 0; i < numWave; i++)
{
var p = Mathf.Lerp(0.5f, 1.5f, i * r);
var amp = a * p * Random.Range(0.8f, 1.2f);
var dir = d + Random.Range(-90f, 90f);
var len = l * p * Random.Range(0.6f, 1.4f);
_waves[i] = new Wave(amp, dir, len, Vector2.zero, false);
Random.InitState(surfaceData.randomSeed + i + 1);
}
Random.state = backupSeed;
}
else
{
_waves = surfaceData._waves.ToArray();
}
}
public void InitInputArrays(NativeArray <PointAndIndex> points, NativeArray <Aabb> aabbs, NativeArray <CollisionFilter> filters)
{
Random.InitState(1234);
const int posRange = 1000;
const int radiusRangeMin = 1;
const int radiusRangeMax = 10;
for (int i = 0; i < points.Length; i++)
{
float3 pos;
pos.x = Random.Range(-posRange, posRange);
pos.y = Random.Range(-posRange, posRange);
pos.z = Random.Range(-posRange, posRange);
points[i] = new PointAndIndex {
Position = pos, Index = i
};
float3 radius = new float3(Random.Range(radiusRangeMin, radiusRangeMax));
aabbs[i] = new Aabb {
Min = pos - radius, Max = pos + radius
};
filters[i] = CollisionFilter.Default;
}
}
public void UnsafeHashMap_Performance_RepeatLookup([Values(10, 100, 1000, 10000, 100000, 1000000, 2500000, 10000000)] int insertions)
{
using (var container = new UnsafeHashMap <int, int>(insertions, Allocator.Persistent))
{
using (var addedKeys = new NativeList <int>(insertions, Allocator.Persistent))
{
Random.InitState(0);
for (int i = 0; i < insertions; i++)
{
int randKey = Random.Range(0, insertions);
container.Add(randKey, randKey);
addedKeys.Add(randKey);
}
Measure.Method(() =>
{
for (int i = 0; i < insertions; i++)
{
int randKey = addedKeys[i];
Assert.IsTrue(container.TryGetValue(randKey, out _));
}
})
.WarmupCount(10)
.MeasurementCount(10)
.Run();
}
}
}
// Update the Asteroids
public void UpdateAsteroid(Asteroid asteroid, Double time)
{
List <Vessel> spaceObjects = FlightGlobals.Vessels.Where(v => !v.DiscoveryInfo.HaveKnowledgeAbout(DiscoveryLevels.StateVectors) && Math.Abs(v.DiscoveryInfo.GetSignalLife(Planetarium.GetUniversalTime())) < 0.01).ToList();
Int32 limit = Random.Range(asteroid.SpawnGroupMinLimit, asteroid.SpawnGroupMaxLimit);
if (spaceObjects.Any())
{
Vessel vessel = spaceObjects.First();
Debug.Log("[Kopernicus] " + vessel.vesselName + " has been untracked for too long and is now lost.");
vessel.Die();
}
else if (GameVariables.Instance.UnlockedSpaceObjectDiscovery(ScenarioUpgradeableFacilities.GetFacilityLevel(SpaceCenterFacility.TrackingStation)))
{
Int32 untrackedCount = FlightGlobals.Vessels.Count(v => !v.DiscoveryInfo.HaveKnowledgeAbout(DiscoveryLevels.StateVectors)) - spaceObjects.Count;
Int32 max = Mathf.Max(untrackedCount, limit);
if (max <= untrackedCount)
{
return;
}
if (Random.Range(0, 100) < asteroid.Probability)
{
UInt32 seed = (UInt32)Random.Range(0, Int32.MaxValue);
Random.InitState((Int32)seed);
SpawnAsteroid(asteroid, seed);
}
else
{
Debug.Log("[Kopernicus] No new objects this time. (Probability is " + asteroid.Probability.Value + "%)");
}
}
}
void Start()
{
m_Player = GameObject.FindObjectOfType <PlayerMove>().gameObject;
m_FollowPlayer = GameObject.FindObjectOfType <FollowPlayer>().gameObject.GetComponent <FollowPlayer>();
//TODO Later on, this should add the current level of the game, so that when you go to the next level in the game, it will create a new level.
Random.InitState(m_Seed + LevelManager.instance.GetLevelNumber());
SetupLevel();
//TODO find all the Gameobjects with the tag "Hole" and add them to our list
m_Holes.AddRange(GameObject.FindGameObjectsWithTag("Hole"));
if (GameManager.instance.GetLastHoleName() != null)
{
m_Player.GetComponent <PlayerMove>().ReturnLastPos();
for (int i = 0; i < m_Holes.Count; i++)
{
if (m_Holes[i].name == GameManager.instance.GetLastHoleName())
{
GameObject currentListGameObject = m_Holes[i];
m_Player.transform.position = new Vector3(currentListGameObject.transform.position.x - 1, currentListGameObject.transform.position.y, 0f);
//send the player's transform to the resetCameraPos function, to use the player transform to help reset the camera's position.
m_FollowPlayer.ResetCameraPos(m_Player.transform.position);
}
}
}
}
/// <summary>
/// 随机获取几个地方单位
/// </summary>
/// <param name="random"></param>
/// <returns></returns>
protected List <BaseCharacterEntity> GetRandomEnemy(int random)
{
List <BaseCharacterEntity> allEnemys = GamePlayManager.Singleton.GetFoes(selfOnly);
List <BaseCharacterEntity> givCharacterEntities = new List <BaseCharacterEntity>();
if (allEnemys.Count >= random)
{
List <int> randomIndex = new List <int>();
Random.InitState(DateTime.Now.Millisecond);
int index = UnityEngine.Random.Range(0, allEnemys.Count);
int seed = 1;
while (randomIndex.Count < random)
{
seed++;
Random.InitState(DateTime.Now.Millisecond + seed);
index = UnityEngine.Random.Range(0, allEnemys.Count);
if (!randomIndex.Contains(index))
{
randomIndex.Add(index);
}
}
for (int i = 0; i < randomIndex.Count; i++)
{
givCharacterEntities.Add(allEnemys[randomIndex[i]]);
}
return(givCharacterEntities);
}
else
{
return(allEnemys);
}
}
/// <summary> Return color based on type </summary>
public static Color GetTypeColor(Type type)
{
VerifyLoaded();
if (type == null)
{
return(Color.gray);
}
var typeName = type.PrettyName();
if (!typeColors.ContainsKey(typeName))
{
if (settings[lastKey].typeColors.ContainsKey(typeName))
{
typeColors.Add(typeName, settings[lastKey].typeColors[typeName]);
}
else
{
#if UNITY_5_4_OR_NEWER
Random.InitState(typeName.GetHashCode());
#else
UnityEngine.Random.seed = typeName.GetHashCode();
#endif
typeColors.Add(typeName, new Color(Random.value, Random.value, Random.value));
}
}
return(typeColors[typeName]);
}
private List <UDPU> GetOptions()
{
var options = new List <UDPU>();
// First option (Effect)
Random.InitState((int)DateTime.Now.Ticks);
var firstOption = Random.Range(UpgradesDatabase.EffectsBottomIndex, UpgradesDatabase.EffectsTopIndex + 1);
options.Add((UDPU)firstOption);
// Second option (Effect)
int secondOption;
do
{
Random.InitState((int)DateTime.Now.Ticks);
secondOption = Random.Range(UpgradesDatabase.EffectsBottomIndex, UpgradesDatabase.EffectsTopIndex + 1);
} while (firstOption == secondOption);
options.Add((UDPU)secondOption);
// Third option (Mechanical)
Random.InitState((int)DateTime.Now.Ticks);
var thirdOption = Random.Range(UpgradesDatabase.MechanicalBottomIndex, UpgradesDatabase.MechanicalTopIndex + 1);
options.Add((UDPU)thirdOption);
// Fourth option (Stats)
Random.InitState((int)DateTime.Now.Ticks);
var fourthOption = Random.Range(UpgradesDatabase.StatsBottomIndex, UpgradesDatabase.StatsTopIndex + 1);
options.Add((UDPU)fourthOption);
return(options);
}
/**
* Given all of the listed values, calculates an (2^n + 1) by (2^n + 1) float array
* containing heights, as calculated by the diamond-square algorithm.
*/
public static float[,] GetHeights(
int seed,
int n,
float _minCornerHeight,
float _maxCornerHeight,
float _minHeightAddition,
float _maxHeightAddition,
float _heightAdditionFactor
)
{
// Set utility fields.
minCornerHeight = _minCornerHeight;
maxCornerHeight = _maxCornerHeight;
minHeightAddition = _minHeightAddition;
maxHeightAddition = _maxHeightAddition;
heightAdditionFactor = _heightAdditionFactor;
// Calculate and set utility values.
Random.InitState(seed);
numVerticesPerSide = (int)Mathf.Pow(2, n) + 1;
heights = new float[numVerticesPerSide, numVerticesPerSide];
// Calculate the heights.
InitializeCorners();
PerformDiamondSquare();
return(heights);
}
protected IEnumerator Start()
{
if (Hellos.Length > 0)
{
Random.InitState((int)DateTime.Now.Ticks);
var index = Random.Range(0, Hellos.Length);
var soundName = Hellos.GetElement(index);
Facade.Instance <MusicManager>().Play(soundName);
}
var actionCount = DefaultAction.Length;
var flag = actionCount > 0;
// ReSharper disable once LoopVariableIsNeverChangedInsideLoop
while (flag)
{
Random.InitState((int)DateTime.Now.Ticks);
var random = Random.Range(Interval.x, Interval.y);
yield return(new WaitForSeconds(random));
Random.InitState((int)DateTime.Now.Ticks);
var index = Random.Range(1, actionCount);
var defaultAction = DefaultAction.GetElement(index);
if (!string.IsNullOrEmpty(defaultAction))
{
AnimationAdapter.PlayByName(defaultAction, null, null, true);
}
}
}
void RandomFillMap()
{
if (useRandomSeed)
{
Random.InitState((int)Time.time);
}
else
{
Random.InitState(seed.GetHashCode());
}
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
if (x == 0 || x == width - 1 || y == 0 || y == height - 1)
{
map[x, y] = 1;
}
else
{
map[x, y] = (Random.Range(0, 100) < randomFillPercent) ? 1 : 0;
}
}
}
}
public Model(CitySettings settings)
{
this.nPatches = settings.patchNum != -1 ? settings.patchNum : 15;
plazaNeeded = settings.plaza;
citadelNeeded = true;
wallsNeeded = settings.wall;
var seed = settings.seed;
do
{
try
{
Random.InitState(++seed);
Debug.Log(seed);
build();
instance = this;
}
catch (Exception e)
{
Debug.Log(
e.StackTrace
);
instance = null;
}
finally
{
Random.State oldstate = Random.state;
Random.state = oldstate;
}
}while (instance == null);
}
private SeedManager(int val)
{
_originalRandomState = Random.state;
Seed = val;
Random.InitState(val);
Debug.Log($"current generation seed is {Seed}");
}
public void SetRandomTreesOnFire()
{
int treeAmount = 5;
//Random.InitState(DateTime.UtcNow.Millisecond);
Random.InitState(15);
foreach (var dataPair in _terrainToTreeData)
{
var terrain = dataPair.Key;
var data = terrain.terrainData;
var treeData = dataPair.Value;
var handler = treeData.Handler;
var indices = new List <int>();
var length = data.treeInstanceCount;
for (int i = 0; i < treeAmount; i++)
{
var randomIndex = Random.Range(0, length);
indices.Add(randomIndex);
var instance = data.GetTreeInstance(randomIndex);
handler.MarkTreeOnFire(instance);
}
ToggleTreeInstances(indices, IndexOfBurningPrototype, terrain);
terrain.Flush();
}
}
private SeedManager()
{
_originalRandomState = Random.state;
Seed = (int)System.DateTime.Now.Ticks;
Random.InitState(Seed);
Debug.Log($"current generation seed is {Seed}");
}
public void OnStartButton()
{
if (Seed.textComponent.text.Length > 0)
{
GameController.Instance.SetSeed(int.Parse(Seed.textComponent.text));
}
else
{
Random.InitState(System.DateTime.Now.GetHashCode());
GameController.Instance.SetSeed(Random.Range(0, int.MaxValue));
}
if (MaxNumberSwarmlings.text.Length > 0)
{
GameController.Instance.SetMaxNumberSwarmlings(int.Parse(MaxNumberSwarmlings.text));
}
if (SwarmlingHealthFactor.text.Length > 0)
{
GameController.Instance.SetSwarmlingHealthFactor(float.Parse(SwarmlingHealthFactor.text));
}
if (PlayerMaxHealth.text.Length > 0)
{
GameController.Instance.SetPlayerStartHealth(int.Parse(PlayerMaxHealth.text));
}
MainMenu.enabled = false;
Instructions.enabled = true;
GameController.Instance.SetActivePlayers(int.Parse(ActivePlayers.textComponent.text));
GameController.Instance.SetBrightness(Brightness.normalizedValue);
StartCoroutine(FadeMusicOutAndLoad(5, 5));
}
public void Start()
{
seeder = seederObj.GetComponent <PUN2_RoomController>();
int seed = getSeed();
Debug.Log("THIS IS FROM MAZE.CS" + seed);
Random.InitState(seed);
Debug.Log("THIS IS FROM MAZE.CS" + seed);
tiles = new Tile[width * height];
for (int i = 0; i < width * height; i++)
{
tiles[i] = new Tile();
}
edges = new List <Edge>();
spawnLeftRightBoundaries();
spawnUpDownBoundaries();
spawnInnerEdgesLeftRight();
spawnInnerEdgesUpDown();
StartCoroutine(removeEdgeCoroutine());
StartCoroutine(waiter());
}
private void Awake()
{
camera = Camera.main;
planes = GeometryUtility.CalculateFrustumPlanes(camera);
Random.InitState(DateTime.Now.Millisecond);
}
public T Eval(int seed, ref List <IDistribution <T> > path)
{
float weightSum = 0.0f;
foreach (IDistribution <T> d in distributions)
{
weightSum += d.GetWeight();
}
Random.InitState(seed);
int nextSeed = Random.Range(0, int.MaxValue);
float random = Random.Range(0, weightSum);
foreach (IDistribution <T> d in distributions)
{
if (d.GetWeight() > random)
{
path.Add(d);
return(d.Eval(nextSeed, ref path));
}
else
{
random -= d.GetWeight();
}
}
return(default);
void RandomText(GameObject nextMap)
{
Random.InitState(DateTime.Now.Second);
GameObject[] allSpheres = GameObject.FindGameObjectsWithTag("Sphere");
foreach (GameObject sphere in allSpheres)
{
if (sphere.transform.parent == nextMap.transform)
{
Text t = sphere.GetComponentInChildren <Text>();
t.text = ((int)Random.Range(0, 5)).ToString();
if (t.text == "0")
{
Destroy(sphere);
}
}
}
GameObject[] allDiamonds = GameObject.FindGameObjectsWithTag("Diamond");
int index = 0;
foreach (GameObject diamond in allDiamonds)
{
if (diamond.transform.parent == nextMap.transform)
{
Text t = diamond.GetComponentInChildren <Text>();
t.text = ((int)Random.Range(1, 15)).ToString();
diamond.GetComponent <SpriteRenderer>().sprite = diaColor[index];
index++;
}
}
}
// Use this for initialization
void Start()
{
if (useRandomSeed)
{
seed = System.DateTime.Now.Ticks.ToString();
}
Random.InitState(seed.GetHashCode());
currentPointAmount = basePointAmount;
// Calculate CLOSE BOTTOM LEFT and FAR TOP RIGHT corner of total area
CalculateTotalArea();
// Initialize the direction pool with the given vectors
InitializeDirectionPool();
// Create line renderers
GenerateLineRenderers();
// Create mesh for each line
GenerateHoleMeshes();
// Customize mesh appearence/collision
AddMeshRenderers();
AddMeshColliders();
}
private void Start()
{
Random.InitState(123456789);
var copy = new Bounds(_worldBounds.Center, _worldBounds.Size * 4F);
_spatialHashing = new SpatialHash <ItemTest>(copy, new float3(10F), Allocator.Persistent);
for (int i = 0; i < _spawnCount; i++)
{
var g = GameObject.CreatePrimitive(PrimitiveType.Cube);
if (_useRaycast == false)
{
g.AddComponent <HashTeleport>();
}
Destroy(g.GetComponent <BoxCollider>());
g.transform.position = new Vector3(Random.Range(_worldBounds.Min.x + 1, _worldBounds.Max.x),
Random.Range(_worldBounds.Min.y + 1, _worldBounds.Max.y),
Random.Range(_worldBounds.Min.z + 1, _worldBounds.Max.z));
var item = new ItemTest()
{
ID = i, Position = g.transform.position
};
Profiler.BeginSample("SpatialHasing Add");
_spatialHashing.Add(ref item);
Profiler.EndSample();
_listItemGameobject.Add(g);
_listItem.Add(item);
}
}
public static void StartLevel(int levelIndex)
{
_levelIndex = levelIndex;
LevelConfig levelConfig = Refs.Instance.Settings.Levels[levelIndex];
Random.InitState(levelConfig.Seed);
// Spawn Ship
SpawnShip();
// Init Asteroid spawning
_asteroidSpawner = Observable
.Interval(TimeSpan.FromSeconds(Refs.Instance.Settings.AsteroidsSpawnRate))
.Subscribe(_ => Spawner.SpawnAsteroid());
// Init Level Timer
float time = levelConfig.Time;
TimerEndTime.Value = Time.time + time;
_timer = Observable
.Timer(TimeSpan.FromSeconds(time))
.Subscribe(_ => OnTimerOut());
// Change State
Transition(LevelState.InProcess);
}
private void OnSetClass(object sender, object args)
{
object[] param = args as object[];
int num = MatchController.NumberOfPlayers;
UnitParameters unitParam = (UnitParameters)param[1];
Random.InitState(unitParam.RandomSeed);
foreach (PlayerController player in MatchController.Players)
{
if (player.netId == (NetworkInstanceId)param[0])
{
player.AssignUnit(new BasicUnit(GameModel.Map.GetRandomUnoccupiedCell(), MapGenerator.GetRandomDirection(), unitParam.Class));
}
if (player.ControlledUnit != null)
{
--num;
}
}
if (num == 0)
{
Starting = false;
GameView.Clear();
ShowMap();
GameView.Init();
CheckState();
}
}
/// <summary>
/// Seek and import a GameObject from mods to replace a Daggerfall billboard.
/// </summary>
/// <param name="archive">Texture archive for original billboard.</param>
/// <param name="record">Texture record for original billboard.</param>
/// <param name="position">Position to assign to GameObject.</param>
/// <param name="parent">Parent to assign to GameObject.</param>
/// <param name="inDungeon">Fix position for dungeon models.</param>
/// <returns>Returns the imported model or null if not found.</returns>
public static GameObject ImportCustomFlatGameobject(int archive, int record, Vector3 position, Transform parent, bool inDungeon = false)
{
GameObject go;
if (!TryImportGameObject(archive, record, true, out go))
{
return(null);
}
go.name = GetFlatReplacementName(archive, record);
go.transform.parent = parent;
// Assign position
AlignToBase(go.transform, position, archive, record, inDungeon);
// Assign a random rotation
var iObjectPositioner = go.GetComponent <IObjectPositioner>();
if (iObjectPositioner == null || iObjectPositioner.AllowFlatRotation)
{
Random.InitState((int)position.x);
go.transform.Rotate(0, Random.Range(0f, 360f), 0);
}
// Add NPC trigger collider
if (RDBLayout.IsNPCFlat(archive))
{
Collider col = go.AddComponent <BoxCollider>();
col.isTrigger = true;
}
// Finalise gameobject materials
FinaliseMaterials(go);
return(go);
}
public void Generate()
{
Clear();
Random.InitState(Seed.GetHashCode());
RandomOffset = new Vector3Int(
Random.Range(-999999, 999999),
Random.Range(-999999, 999999),
0
);
foreach (var biome in BiomeConfigs)
{
var tiles = new Dictionary <Vector4, TileBase>();
biome.TileConfig.GetCacheData(tiles);
float key = Mathf.Round(biome.Height * Height);
if (!CachedBiomes.ContainsKey(key))
{
CachedBiomes.Add(key, new Tuple <int, Dictionary <Vector4, TileBase> >(biome.TileConfig.GetHashCode(), tiles));
}
foreach (var spawner in biome.Spawners)
{
if (spawner.Spawer == null)
{
continue;
}
RegisterSpawner(spawner.Probability, spawner.Spawer);
}
}
ChunkProvider.Boot();
ChunkProvider.RandomOffset = new Vector3Int(RandomOffset.x, RandomOffset.y, 0);
}
// Use this for initialization
void Start()
{
Random.InitState(DateTime.Now.Millisecond);
rooms = FindObjectsOfType <room>();
print("Start Game");
BuildLevel();
}
public void InitMap()
{
//初始化时将自己加入chunks列表
/* chunks.Add(this);
* Debug.Log(transform.position + ":" + chunks.Count);*/
//获取自身相关组件引用
meshRenderer = GetComponent <MeshRenderer>();
meshCollider = GetComponent <MeshCollider>();
meshFilter = GetComponent <MeshFilter>();
//初始化随机种子
Random.InitState(DateTime.Now.Second);
//3个偏移量
offset0 = new Vector3(Random.value * 1000, Random.value * 1000, Random.value * 1000);
offset1 = new Vector3(Random.value * 1000, Random.value * 1000, Random.value * 1000);
offset2 = new Vector3(Random.value * 1000, Random.value * 1000, Random.value * 1000);
//初始化Map
//遍历map，生成其中每个Block的信息
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
for (int z = 0; z < width; z++)
{
map[x, y, z] = GenerateBlockType(new Vector3(x, y, z) + transform.position);
}
}
}
//根据生成的信息，Build出Chunk的网格
}
