public static List <MyTreeElement> GenerateRandomTree(int numTotalElements) { // 这里是随机创建树 // numRootChildren: 在根节点上调用几次AddChildrenRecursive int numRootChildren = numTotalElements / 4; IDCounter = 0; var treeElements = new List <MyTreeElement>(numTotalElements); // name, depth, id var root = new MyTreeElement("Root", -1, IDCounter); treeElements.Add(root); for (int i = 0; i < numRootChildren; ++i) { int allowedDepth = 6; AddChildrenRecursive(root, Random.Range(minNumChildren, maxNumChildren), true, numTotalElements, ref allowedDepth, treeElements); } return(treeElements); }
public static void ClaimRooms(this Region region) { //Elevation cells are grouped into their own room to prevent complications while (region.GetCells().Where(x => x.type == CellType.Elevation).Any(x => !x.claimedByRoom)) { var elevationGroups = region.GetCells().Where(x => x.type == CellType.Elevation) .GroupBy(g => new Vector2(g.position.x, g.position.y)); foreach (var elevationGroup in elevationGroups) { var room = new Room(); if (!ClaimRoom(elevationGroup.ToList(), ref room)) { continue; } room.regionId = region.id; RoomCollection.Add(room); } } //Until all cells are claimed by a room while (region.GetCells().Any(x => !x.claimedByRoom)) { var cellsLeftToClaim = region.GetCells().Where(x => !x.claimedByRoom).ToList(); var rootCell = cellsLeftToClaim[Random.Range(0, cellsLeftToClaim.Count)]; var claimSize = region.greedyClaiming ? region.maximumRoomSize : Random.Range(1, region.maximumRoomSize + 1); var projection = ProjectRoom(rootCell, ref cellsLeftToClaim, Random.Range(1, region.maximumRoomSize + 1), region.claimChance, region.roomClaimingStrategy); if (projection.Any()) { var room = new Room(); if (!ClaimRoom(projection, ref room)) { continue; } room.regionId = region.id; RoomCollection.Add(room); } } }
public void Initialize() { _timelineSchedule = new List <int>(); _timelineData = new List <TimelineSerializableData>(); MemberDataModel memberData = MemberDataModel.Instance; ActorDataModel actorData = ActorDataModel.Instance; memberData.Data.ForEach(x => { BattlerSerializable battler = actorData.ByIndex(x.index); _timelineData.Add(new TimelineSerializableData { id = _timelineData.Count, uniqId = battler.uniqId, battlerType = BattlerEnum.BattlerType.Actor, timeLine = Random.Range(battler.parameter.spd / 2, battler.parameter.spd) }); }); EnemyDataModel enemyData = EnemyDataModel.Instance; enemyData.Data.ForEach(x => { _timelineData.Add(new TimelineSerializableData { id = _timelineData.Count, uniqId = x.uniqId, battlerType = BattlerEnum.BattlerType.Enemy, timeLine = Random.Range(x.parameter.spd / 2, x.parameter.spd) }); }); TimelineCalc(); for (int i = 0; i < SCHEDULE_SIZE; i++) { TimeLineForward(); } _timelineView = new TimelineView(); _timelineView.Initialize(this); }
/** * Returns a random sample from the list. */ public static IEnumerable <T> SampleRandom <T>(this IEnumerable <T> source, int sampleCount) { if (source == null) { throw new ArgumentNullException("source"); } if (sampleCount < 0) { throw new ArgumentOutOfRangeException("sampleCount"); } /* Reservoir sampling. */ var samples = new List <T>(); //Must be 1, otherwise we have to use Range(0, i + 1) var i = 1; foreach (var item in source) { if (i <= sampleCount) { samples.Add(item); } else { // Randomly replace elements in the reservoir with a decreasing probability. var r = Random.Range(0, i); if (r < sampleCount) { samples[r] = item; } } i++; } return(samples); }
public static void InitPairs(int minIndex, int maxIndex, int count, NativeArray <ulong> pairs) { Random.InitState(1234); for (var i = 0; i < pairs.Length; ++i) { ulong indexA = (ulong)Random.Range(minIndex, maxIndex); ulong indexB = (ulong)Random.Range(minIndex, maxIndex); if (indexB == indexA) { if (indexB < (ulong)maxIndex) { indexB++; } } pairs[i] = indexA << DispatchPairSequencer.DispatchPair.k_BodyAIndexShift | indexB << DispatchPairSequencer.DispatchPair.k_BodyBIndexShift; } }
public void CalculateResult() { for (int i = 0; i < randomNumbers.Length; i++) { for (int j = 0; j < randomNumbers[i].Length; j++) { randomNumbers[i][j] = Random.Range(0, MaxValue); } } for (int i = 0; i < valueNumbers.Length; i++) { for (int j = 0; j < valueNumbers[i].Length; j++) { valueNumbers[i][j] = Random.Range(0, MaxValue); } } for (int i = 0; i < lights.Length; i++) { lights[i] = Random.Range(0, LightMaxValue); } for (int i = 0; i < exchangeEnums.Length; i++) { exchangeEnums[i] = (ExchangeEnum)Random.Range(0, 16); } exChangedDictionary.Clear(); for (int i = 0; i < 4; i++) { int index = 0; for (int j = 0; j < 4; j++) { if (j != lights[i]) { exChangedDictionary.Add(j + i * 4, exchangeEnums[i * 3 + index]); index += 1; } } } }
private void StartInitializeGame() { GetController <PlayerController>().InitializePlayer(); if (_matchManager.MatchType == Enumerators.MatchType.LOCAL) { GetController <AIController>().InitializePlayer(); } GetController <SkillsController>().InitializeSkills(); GetController <BattlegroundController>().InitializeBattleground(); if (IsTutorial) { IsSpecificGameplayBattleground = true; CurrentTurnPlayer = _tutorialManager.CurrentTutorial.PlayerTurnFirst ? CurrentPlayer : OpponentPlayer; GetController <PlayerController>().SetHand(); GetController <CardsController>().StartCardDistribution(); } else { IsSpecificGameplayBattleground = false; CurrentTurnPlayer = Random.Range(0, 100) > 50 ? CurrentPlayer : OpponentPlayer; OpponentPlayer.SetFirstHand(false); _uiManager.DrawPopup <PlayerOrderPopup>(new object[] { CurrentPlayer.SelfHero, OpponentPlayer.SelfHero }); } IsGameEnded = false; GameInitialized?.Invoke(); }
private void RemoveRandom(out int newSize) { var count = 0; for (var i = 0; i < _keySize; i++) { if (Random.Range(0, 2) == 1) { _nativeMultiHashMap.Remove(_keyData[i]); _checkingResults.Remove(_keyData[i]); } else { count++; } } newSize = count * _valueSize; Assert.AreEqual(newSize, _nativeMultiHashMap.Length); Assert.AreEqual(newSize, Length(_checkingResults)); }
public override void Update(float deltaTime) { // Moves character in a random direction while idle. timeSpentIdle += deltaTime; if (timeSpentIdle >= totalIdleTime) { Tile[] neighbors = character.CurrTile.GetNeighbours(); Tile endTile = neighbors[Random.Range(0, 4)]; List <Tile> path = Pathfinder.FindPathToTile(character.CurrTile, endTile); if (endTile.MovementCost != 0) { // See if the desired tile is walkable, then go there if we can. character.SetState(new MoveState(character, Pathfinder.GoalTileEvaluator(endTile, true), path)); } else { // If the tile is unwalkable, just get a new state. character.SetState(null); } } }
public async Task RandomizeFrom(IList <PreloadMetaData> meta) { Console.WriteLine(meta.Count); if (_lastSelectedRandoms.Count == meta.Count) { _lastSelectedRandoms.Clear(); } var idx = 1; while (_lastSelectedRandoms.Contains(idx)) { idx = (int)(Random.Range(0f, 1f) * meta.Count); } _lastSelectedRandoms.Add(idx); var comp = meta[idx]; SetModelComposition(await _mainAssetStore.GetCompositionByMeta(comp)); }
public override void OnEnter() { //interestArousal += 0.1f; //interestValence += 0.05f; morphMouthAction = true; mSmileFullFaceTarget = -1.0f; mSmileOpenFullFaceTarget = 0.0f; mHappyTarget = 0.0f; mFlirtingTarget = 0.0f; mVisFTarget = 0.0f; mTongueInOutTarget = Random.Range(0.5f, 1.0f); mTongueSideSideTarget = 0.0f; mTongueBendTipTarget = 0.0f; mMouthOpenTarget = Random.Range(0.01f, 0.1f);; mMouthSideLeftTarget = 0.0f; mMouthSideRightTarget = 0.0f; mSmileSimpleLeftTarget = Random.Range(0.0f, 0.3f);; mSmileSimpleRightTarget = mSmileSimpleLeftTarget; mLipsPuckerTarget = Random.Range(0.0f, 0.3f);; mLipsPuckerWideTarget = 0.0f; Duration = Random.Range(1.0f, 3.0f) * lookVariation; }
int[] GenerateZoneCenterCoordinates(int distanceFromAnotherObject, int[,] mapData) { int errors = 0; while (true) { errors++; if (errors > 5000) { return(null); } int xParent = Random.Range(0, _mapCountrySize); int yParent = Random.Range(0, _mapCountrySize); bool canGenerate = FindContent(xParent, yParent, distanceFromAnotherObject, mapData); if (!canGenerate) { continue; } return(new[] { xParent, yParent }); } }
/// <summary> /// Extension to select and return a random item from any IEnumerable. /// NOTE: If the collection does not implement IList, the collection will be iterated through up to twice! /// </summary> /// <param name="collection">The IEnumerable to iterate over and choose an item from.</param> /// <returns>A random item from the provided IEnumerable.</returns> public static object ChooseRandom(this IEnumerable collection) { IList iList = collection as IList; if (iList != null) { if (iList.Count == 0) { throw new ArgumentException("Trying to choose random item from an empty list!"); } return(iList[Random.Range(0, iList.Count)]); } IEnumerator enumerator = collection.GetEnumerator(); int count = 0; while (enumerator.MoveNext()) { count++; } if (count == 0) { throw new ArgumentException("Trying to choose random item from an empty list!"); } enumerator.Reset(); int index = Random.Range(0, count); for (int i = 0; i < index; i++) { enumerator.MoveNext(); } return(enumerator.Current); }
/// <summary> /// Gets a random item from the list using the weights at a certain time /// </summary> /// <param name="time">The time on the animation curve to get the weight from</param> /// <returns>A random item, if all weights are 0, selects a random with equal weighting</returns> /// <exception cref="NullReferenceException">The list is empty</exception> public T GetRandomItem(float time) { if (list.Count == 0) { throw new NullReferenceException("WeightedList is empty"); } float total = list.Sum(t => t.weight.Evaluate(time)); total = Random.Range(0f, total); if (total == 0) { return(list[Random.Range(0, list.Count)].item); } var i = 0; while (total >= 0 && i < list.Count) { float iWeight = list[i].weight.Evaluate(time); if (total < iWeight && iWeight != 0) { return(list[i].item); } total -= iWeight; i++; } // It's not perfect, but it's better than nothing if (total == 0) { return(list[Random.Range(0, list.Count)].item); } throw new NullReferenceException("Cannot return a random item from the WeightedList"); }
/// <summary> /// Generates unique number according specified letter /// </summary> /// <param name="letter"></param> /// <returns></returns> public int GenerateUniqueNumberForLetter(BingoLetter letter) { if (!CanGenerateNumberForLetter(letter)) { throw new Exception("All numbers for letter " + letter + " were already generated"); } var letterIndex = BingoLetterCaster.BingoLetterToInt(letter); var numbersList = _bingoNumberListsArray[letterIndex]; var randomIndexForPickNumber = Random.Range(0, numbersList.Count); // Pick number by random index in numbersList var randomNumber = numbersList[randomIndexForPickNumber]; while (true) { randomNumber = Random.Range(0, 25); if (indexValues[randomNumber] != -1) { indexValues[randomNumber] = -1; break; } else { continue; } } // Remove picked number from list (we don't want generate this number again in further calls // to GenerateUniqueNumberForLetter() method) //indexValues.RemoveAt(randomIndexForPickNumber); //randomNumber = Random.Range(0, 25); return(randomNumber); }
private IEnumerator Tick() { while (true) { var tankMovementSoundEntityViews = entityViewsDB.QueryEntityViews <TankMovementSoundEntityView>(); if (tankMovementSoundEntityViews.Count > 0) { for (int i = 0; i < tankMovementSoundEntityViews.Count; i++) { IAudioSourceComponent audioSourceComponent = tankMovementSoundEntityViews[i].AudioSourceComponent; ITankMovementSoundsComponent soundComponent = tankMovementSoundEntityViews[i].TankMovementSoundsComponent; ITankInputComponent inputComponent = tankMovementSoundEntityViews[i].TankInputComponent; if (Mathf.Abs(inputComponent.Input.z) < 0.1f && Mathf.Abs(inputComponent.Input.x) < 0.1f) { if (audioSourceComponent.Clip == soundComponent.EngineDrivingAudioClip) { audioSourceComponent.Clip = soundComponent.IdleAudioClip; audioSourceComponent.Pitch = Random.Range(1 - 0.1f, 1 + 0.1f); audioSourceComponent.Play(); } } else { if (audioSourceComponent.Clip == soundComponent.IdleAudioClip) { // ... change the clip to driving and play. audioSourceComponent.Clip = soundComponent.EngineDrivingAudioClip; audioSourceComponent.Pitch = Random.Range(1 - 0.1f, 1 + 0.1f); audioSourceComponent.Play(); } } } } yield return(null); } }
public override void OnEnter() { //interestArousal += 0.25f; //interestValence += 0.1f; morphMouthAction = true; mSmileFullFaceTarget = 0.0f; mSmileOpenFullFaceTarget = 0.0f; mGlareTarget = 0.0f; mHappyTarget = Random.Range(0.1f, 0.3f); //mTongueInOutTarget = Random.Range(-0.15f,0.5f); //mTongueSideSideTarget = 0.5f; mTongueBendTipTarget = 0.0f; ///mVisFTarget = Random.Range(0.5f,1.0f); mMouthOpenTarget = -1.0f; mMouthSideLeftTarget = 0.0f; mMouthSideRightTarget = 0.0f; mSmileSimpleLeftTarget = -1.0f; mSmileSimpleRightTarget = -1.0f; mLipsPuckerTarget = Random.Range(0.0f, 0.3f); mLipsPuckerWideTarget = 0.0f; mExcitementTarget = 0.0f; Duration = Random.Range(2.0f, 4.5f) * lookVariation; }
private IDictionary <string, NodeType> FindSubgraphAndMarkNodes(GraphType otherGraph) { IDictionary <string, IList <NodeType> > candidateMarkedNodes = new Dictionary <string, IList <NodeType> >(); bool isSupergraphOfSourceGraph = SubgraphSearch(otherGraph, candidateMarkedNodes); if (!isSupergraphOfSourceGraph) { throw new InvalidOperationException($"No subgraph found in graph {id} matching source graph" + $" {otherGraph.id}, so cannot carry out find and replace operation"); } IDictionary <string, NodeType> markedNodes = new Dictionary <string, NodeType>(candidateMarkedNodes.Count); foreach (KeyValuePair <string, IList <NodeType> > keyValuePair in candidateMarkedNodes) { IList <NodeType> nodes = keyValuePair.Value; NodeType nodeToUse = nodes[nodes.Count == 1 ? 0 : Random.Range(0, nodes.Count)]; markedNodes[keyValuePair.Key] = nodeToUse; } return(markedNodes); }
public override IEnumerable <string> GetAnswers(SouvenirModule module) { if (MaxSteps >= 10) { while (true) { yield return((Random.Range(0, MaxSteps) * Step + Min).ToString(Format)); } } // With no more than 6 possible values, the above case may go into an infinite loop trying to generate 5 distinct values. // In this case, we will return all possible values in a random order and then halt. var values = new int[MaxSteps]; for (int i = MaxSteps - 1; i >= 0; --i) { values[i] = i * Step + Min; } values.Shuffle(); foreach (var i in values) { yield return(i.ToString(Format)); } }
public void PlaySfx(SfxId sfxId) { var sfxInfo = _sfxSettings.GetSfxInfo(sfxId); switch (sfxId) { case SfxId.Shot: _audioViewFactory.Create(sfxInfo.AudioClip, sfxInfo.MixerGroup, Random.Range(0.8f, 1.1f), 0f); break; case SfxId.Pop: _audioViewFactory.Create(sfxInfo.AudioClip, sfxInfo.MixerGroup, Random.Range(0.9f, 1.1f), Random.Range(0f, 0.2f)); break; case SfxId.Explosion: _audioViewFactory.Create(sfxInfo.AudioClip, sfxInfo.MixerGroup, 1f, 0f); break; default: throw new ArgumentOutOfRangeException(nameof(sfxId), sfxId, null); } }
/// <summary> /// Returns a random element from an <c>IEnumerable</c>. Special case for 'int' type. /// Note: RandomOrDefault is much faster when used on a collection of 'int' or 'float'. /// Count < 100 optimised from https://nickstrips.wordpress.com/2010/08/28/c-optimized-extension-method-get-a-random-element-from-a-collection/ /// </summary> public static float RandomOrDefault(this IEnumerable <float> self) { IEnumerable <float> enumerable = self as float[] ?? self.ToArray(); int count = enumerable.Count(); int index = Random.Range(0, count); // When the collection has 100 elements or less, get the random element. // by traversing the collection one element at a time. if (count > 100) { return(enumerable.ElementAt(index)); } using (IEnumerator <float> enumerator = enumerable.GetEnumerator()) { while (index >= 0 && enumerator.MoveNext()) { index--; } return(enumerator.Current); } }
public void GetVerticalWall(MapElement[,] map, ref int posX, int posY, int xSize, int ySize) { //Debug.Log(string.Format("X: {0} Y: {1} PosX: {2} PosY: {3} PosY+Y={4}", xSize,ySize,posX,posY,posY+ySize)); posX += xSize; var door = Random.Range(posY + 1, (posY + ySize) - 1); for (var y = posY; y < posY + ySize; y++) { if (y >= MapSizeY - 1 || posX >= MapSizeX - 1) { continue; } if (y == door) { map[posX, y] = MapElement.Door; } else { map[posX, y] = MapElement.Wall; } } }
public override void OnEnter() { currentEye = "Wink"; //interestArousal += 0.5f; //interestValence += 0.1f; morphEyeAction = true; if (Random.Range(0.0f, 100.0f) > 50.0f) { mEyesClosedLeftTarget = 0.95f; mEyesClosedRightTarget = 0.0f; mSmileSimpleLeftTarget = 0.4f; mSmileSimpleRightTarget = 0.0f; } else { mEyesClosedLeftTarget = 0.0f; mEyesClosedRightTarget = 0.95f; mSmileSimpleLeftTarget = 0.0f; mSmileSimpleRightTarget = 0.4f; } mEyesSquintTarget = 0.0f; Duration = Random.Range(0.25f, 0.3f); }
public override void OnEnter() { //interestArousal += 5.0f; //interestValence += 1.0f; morphMouthAction = true; mSmileFullFaceTarget = 0.0f; mSmileOpenFullFaceTarget = 0.0f; mGlareTarget = 0.0f; sexActionNeckX = -5.0f; mTongueInOutTarget = Random.Range(-0.6f, 0.3f); mTongueSideSideTarget = Random.Range(-0.2f, 0.2f); mTongueBendTipTarget = 0.0f; mHappyTarget = 0.0f; mFlirtingTarget = 0.0f; mMouthOpenTarget = Random.Range(0.4f, 0.8f); mMouthSideLeftTarget = 0.0f; mMouthSideRightTarget = 0.0f; mSmileSimpleLeftTarget = 0.0f; mSmileSimpleRightTarget = 0.0f; mLipsPuckerTarget = Random.Range(0.4f, 1.1f); mLipsPuckerWideTarget = 0.0f; Duration = Random.Range(1.5f, 3.0f) * lookVariation; }
public EffectBase MakeEffect(EffectSet effectSet, EffectDuration durationType = EffectDuration.Undefined) { if (durationType == EffectDuration.Undefined) { durationType = Random.Range(0, 2) > 0 ? EffectDuration.Timed : EffectDuration.Permanent; } EffectBase effect; var statType = effectSet.GameStatType; var amount = Random.Range(effectSet.MinAmount, effectSet.MaxAmount); if (effectSet.GameEffectType == EffectType.Negative) { amount *= -1; } var duration = 0f; if (durationType == EffectDuration.Timed) { duration = Random.Range(effectSet.MinDuration, effectSet.MaxDuration); } else { amount *= _permanentEffectsModifier; } if (effectSet.AffectRegen) { effect = new StatRegenerationChangingEffect(statType, amount, duration, durationType, effectSet.GameEffectType, effectSet.Icon); } else { effect = new StatValueChangingEffect(statType, amount, duration, durationType, effectSet.GameEffectType, effectSet.Icon); } return(effect); }
/// <summary> /// Generate new random level chunk graph /// </summary> /// <param name="width"></param> /// <param name="length"></param> /// <param name="prevGraph"></param> /// <returns></returns> /// <exception cref="Exception"></exception> public static LevelGraph Generate(int width, int length, LevelGraph prevGraph = null) { if (length < MinLength) { throw new Exception("Length must be >= 2"); } if (width < MinWidth) { throw new Exception("Width must be >= 1"); } if (prevGraph != null && prevGraph.width != width) { throw new Exception("Prev graph width not equal"); } var nodes = new Grid <LevelGraphNode>(width, length); // todo handle prevGraph // Fill graph by connected nodes for (var y = 0; y < length; y++) { for (var x = 0; x < width; x++) { nodes.Set(x, y, new LevelGraphNode(x, y, width)); } } // Close one random node on each grid row for (var y = 1; y < length; y++) { CloseNode(Random.Range(0, width), y, nodes); } return(new LevelGraph(nodes)); }
public static Item GenerateLoot(int level) { if (Random.value > 0.3) { return(null); } var possibles = new List <Item>(); foreach (var record in mTable) { if (Random.value < record.Possibility) { possibles.Add(record.CreateLoot(level)); } } if (possibles.Count == 0) { return(null); } return(possibles[Random.Range(0, possibles.Count)]); }
public char Pick() { var n = Chars != null ? Chars.Length : 0; if (Ranges != null) { for (int i = 0; i < Ranges.Length; i += 2) { n += Ranges[i + 1] + 1 - Ranges[i]; } } n = Random.Range(0, n); if (Chars != null) { if (n < Chars.Length) { return(Chars[n]); } n -= Chars.Length; } if (Ranges != null) { for (int i = 0; i < Ranges.Length; i += 2) { if (n < Ranges[i + 1] + 1 - Ranges[i]) { return((char)(Ranges[i] + n)); } n -= Ranges[i + 1] + 1 - Ranges[i]; } // We shouldn't reach here. return(Ranges[0]); } // We shouldn't reach here either. return(Chars[0]); }
public static T Sample <T>(this IEnumerable <T> self) { return(self.ElementAt(Random.Range(0, self.Count()))); }
public int Compare(T a, T b) { return(1 - 2 * Random.Range(0, 1)); }