/// <summary>
/// Initialize the weightedButtonGroupDatas. Can be done only once per session.
/// </summary>
public void Initialize()
{
if (!isInitialized)
{
weightedButtonGroupDatas = new WeightedRandomizer <ButtonGroupData>();
foreach (ButtonGroupData _buttonGroupData in buttonGroupDatas)
{
if (_buttonGroupData == null)
{
continue;
}
#if VOODOO_SAUCE
if (_buttonGroupData.buttonGroupVisualPrefab != null &&
_buttonGroupData.buttonGroupVisualPrefab.specialButton != null)
{
Voodoo.Sauce.Components.NoAdsButton noAdsButton = _buttonGroupData.buttonGroupVisualPrefab.specialButton.GetComponent <Voodoo.Sauce.Components.NoAdsButton>();
if (noAdsButton == null || !VoodooSauce.IsPremium())
{
weightedButtonGroupDatas.AddElement(_buttonGroupData, _buttonGroupData.weight);
}
}
else
{
weightedButtonGroupDatas.AddElement(_buttonGroupData, _buttonGroupData.weight);
}
#else
weightedButtonGroupDatas.AddElement(_buttonGroupData, _buttonGroupData.weight);
#endif
isInitialized = true;
}
}
}
private void InitCaches()
{
if (cacheHarvestEffectivenesses == null || cacheHarvestItems == null)
{
cacheHarvestEffectivenesses = new Dictionary <WeaponType, HarvestEffectiveness>();
cacheHarvestItems = new Dictionary <WeaponType, WeightedRandomizer <ItemDropByWeight> >();
foreach (var harvestEffectiveness in harvestEffectivenesses)
{
if (harvestEffectiveness.weaponType != null && harvestEffectiveness.damageEffectiveness > 0)
{
cacheHarvestEffectivenesses[harvestEffectiveness.weaponType] = harvestEffectiveness;
var harvestItems = new Dictionary <ItemDropByWeight, int>();
foreach (var item in harvestEffectiveness.items)
{
if (item.item == null || item.amountPerDamage <= 0 || item.randomWeight <= 0)
{
continue;
}
harvestItems[item] = item.randomWeight;
}
cacheHarvestItems[harvestEffectiveness.weaponType] = WeightedRandomizer.From(harvestItems);
}
}
}
}
// Start is called before the first frame update
void Start()
{
myDictionary = new Dictionary <GameObject, int>();
foreach (var entry in toSpawn)
{
myDictionary.Add(entry.key, entry.value);
}
GameObject objectToSpawn = WeightedRandomizer.From(myDictionary).TakeOne();
GameObject actualObject = null;
if (whereToSpawn != null)
{
actualObject = Instantiate(objectToSpawn, whereToSpawn.position, Quaternion.identity);
}
else
{
actualObject = Instantiate(objectToSpawn, transform.position, Quaternion.identity);
}
if (createAsChild)
{
actualObject.transform.parent = transform;
}
}
public IEnumerator Spawn(int amount)
{
EnemyTracker.InitializeNewWave(amount);
// Game.Hud.remainingEnemies.text = "Remaining enemies: " + amount;
for (var i = 0; i < amount; i++)
{
var spawnIndex = Random.Range(0, _spawnPositions.Length);
yield return(new WaitForSeconds(1 / Game.Controller.currentWave));
var enemy = Instantiate
(
WeightedRandomizer.From(_enemies).TakeOne(),
_spawnPositions[spawnIndex].position,
Quaternion.identity,
enemyContainer
);
enemy.name = enemy.enemyName;
enemy.currentWaveIndex = i;
EnemyTracker.Enemies[i] = enemy;
yield return(new WaitForSeconds(spawnRate));
}
}
private void SpawnCustomer()
{
GameObject selected;
// Select a random customer is list by chance
if (customersToSpawn.Length == 1)
{
selected = customersToSpawn[0].customerPrefab;
}
else if (customersToSpawn.Length > 1)
{
Dictionary <GameObject, int> weights = new Dictionary <GameObject, int>();
for (int i = 1; i < customersToSpawn.Length; i++)
{
weights.Add(customersToSpawn[i].customerPrefab, customersToSpawn[i].chancesOfSpawning);
}
selected = WeightedRandomizer.From(weights).TakeOne();
}
else
{
Debug.LogError("There are no customers to spawn in the GameManager!", gameObject);
return;
}
// Spawn selected customer
_mapManager.GetRandomCustomerSpawner().SpawnCustomer(selected);
}
//public List<BlockModel> generateThisRow = new List<BlockModel>();
#endregion
#region Private Fields
#endregion
#region Getters/Setters/Constructors
#endregion
#region My Methods
public void GenerateBlockZone(BlockZone blockZone, int offset)
{
// Adding +1 to the offset so that the next blockzone doesn't overlap with the last row of the last blockzone.
for (int yPosition = offset + 1; yPosition <= offset + blockZone.LowYPosition; yPosition++)
{
for (int xPosition = blockZone.LowXPosition; xPosition <= blockZone.HighXPosition; xPosition++)
{
BlockModel model =
BlockModelFactory
.Start()
.WithBlockType(WeightedRandomizer.From(blockZone.BlockProbability).TakeOne())
.WithPosition(xPosition, yPosition)
.WithBlockLevelFromBlockType()
.WithBlockExperienceFromBlockType()
.WithBlockHPFromBlockType()
.WithBlockDefenseFromBlockType()
.Finish();
//Debug.Log($"{model.BlockType.BlockName}");
if (model.BlockType.BlockName != "BLANK")
{
blockModels.Add(model);
}
}
}
}
public static void ShowRewardedAd(System.Action <RemakeShowResult> showResultHandler)
{
ShowAd(Singleton.rewardVideoPlacement, (result) =>
{
if (result == RemakeShowResult.Finished)
{
var randomizer = WeightedRandomizer.From(AdsRewards);
var reward = randomizer.TakeOne();
var currencies = reward.currencies;
foreach (var currency in currencies)
{
Save.AddCurrency(currency.id, currency.amount);
}
var items = reward.items;
foreach (var item in items)
{
Save.AddPurchasedItem(item.name);
}
}
if (showResultHandler != null)
{
showResultHandler(result);
}
});
}
private GameObject GetDrop(List <ItemDropWeight> item_weights)
{
Dictionary <GameObject, int> weights = new Dictionary <GameObject, int>();
item_weights.ForEach(x => weights.Add(x.prefab, x.weight));
return(WeightedRandomizer.From(weights).TakeOne());
}
public static void ShowRewardedAd(System.Action <RemakeShowResult> showResultHandler)
{
ShowAd(Singleton.rewardVideoPlacement, (result) =>
{
if (result == RemakeShowResult.Finished)
{
var randomizer = WeightedRandomizer.From(AdsRewards);
var reward = randomizer.TakeOne();
if (OverrideSaveAdsReward != null)
{
// Custom save ads reward function
OverrideSaveAdsReward.Invoke(reward);
}
else
{
// Default save ads reward function
DefaultSaveAdsReward(reward);
}
}
if (showResultHandler != null)
{
showResultHandler.Invoke(result);
}
});
}
private void DrawDayPriorityGenericConversations()
{
// print(AllConversations.Count);
DayPriorityGenericConversations = new List <Conversation>();
Dictionary <Conversation, int> priority1 = new Dictionary <Conversation, int>();
foreach (Conversation conversation in AllConversations)
{
if (CheckIfGeneric(conversation) == false)
{
// print("Not generic");
continue;
}
if (conversation.LookupInt("Priority") == 0)
{
// print("Priority<1");
continue;
}
if (conversation.LookupInt("Priority") == 2)
{
// print("Priority 2. Adding.");
DayPriorityGenericConversations.Add(conversation);
continue;
}
else if (conversation.LookupInt("Priority") == 1)
{
// print("Adding to priority 1 list");
priority1.Add(conversation, conversation.LookupInt("Weight"));
continue;
}
}
int amt = MaxGenPrioConvos - DayPriorityGenericConversations.Count;
if (amt < 0)
{
amt = 0;
}
// print("Getting priority 1: " + amt);
for (int i = 0; i < amt; i++)
{
if (priority1.Count > 0)
{
Conversation conversation = WeightedRandomizer.From(priority1).TakeOne();
DayPriorityGenericConversations.Add(conversation);
priority1.Remove(conversation);
// print("Adding conversation to priority generic list.");
}
else
{
// print("No more eligible conversations");
break;
}
}
// print("Generic priority conversations: " + DayPriorityGenericConversations.Count);
}
void Start()
{
PopulateMetaList();
List<int> weights = new List<int>();
ObstacleMetaList.ForEach(x => weights.Add(x.Weight));
randomizer = new WeightedRandomizer(weights);
}
public LootBoxReward RandomReward()
{
var weight = new Dictionary <LootBoxReward, int>();
foreach (var lootboxReward in lootboxRewards)
{
weight.Add(lootboxReward, lootboxReward.randomWeight);
}
return(WeightedRandomizer.From(weight).TakeOne());
}
public StageRandomFoe RandomFoes()
{
var weight = new Dictionary <StageRandomFoe, int>();
foreach (var randomFoe in randomFoes)
{
weight.Add(randomFoe, randomFoe.randomWeight);
}
return(WeightedRandomizer.From(weight).TakeOne());
}
public string CreateCompetitor(string pName, BlossomData.BlossomGrowth pGrowth, float pMinStrength, float pMaxStrength, float pMinAgility,
float pMaxAgility, float pMinIntellect, float pMaxIntellect, float pMinCharm, float pMaxCharm, int pMinAffection = -1, int pMaxAffection = 1)
{
//CREATE BLOSSOM
BlossomData newBlossom = Instantiate(BlossomPrefab, transform);
newBlossom.ID = "Blossom" + CurrentBlossomID.ToString();
string ID = newBlossom.ID;
CurrentBlossomID += 1;
//newBlossom.Age = pAge;
newBlossom.Name = pName;
newBlossom.Parent1 = string.Empty;
newBlossom.Parent2 = string.Empty;
newBlossom.Growth = pGrowth;
newBlossom.Energy = 2;
//STATS
//Agility
newBlossom.Agility.Value = Random.Range(pMinAgility, pMaxAgility);
//Strength
newBlossom.Strength.Value = Random.Range(pMinStrength, pMaxStrength);
//Intellect
newBlossom.Intellect.Value = Random.Range(pMinIntellect, pMaxIntellect);
//Charm
newBlossom.Charm.Value = Random.Range(pMinCharm, pMaxCharm);
newBlossom.CurrentLevel = string.Empty;
newBlossom.transform.position = Vector2.zero;
//ExistingBlossoms.Add(newBlossom.ID);
BlossomColor[] allColors = Resources.LoadAll <BlossomColor>("BlossomColors");
Dictionary <string, int> colorPool = new Dictionary <string, int>();
foreach (BlossomColor color in allColors)
{
colorPool.Add(color.Name, color.Probability);
}
newBlossom.Color = WeightedRandomizer.From(colorPool).TakeOne();
if (pMinAffection != -1 && pMaxAffection != -1 && pMaxAffection >= pMinAffection)
{
int affection = Random.Range(pMinAffection, pMaxAffection);
newBlossom.Affection = affection;
}
//DESTROY OBJECT, THIS WILL SAVE DATA
Destroy(newBlossom.gameObject);
return(ID);
}
// void GetEligibleConversations(Character character){
//
// EligibleConversations.Clear ();
// List<Conversation> conversations = new List<Conversation>();
//
// if (conversations.Count>0) {
// foreach(Conversation conversation in conversations){
// if (conversation.CheckConditions () == true) {
// if (!character.SaidToday.Contains (conversation)) {
// EligibleConversations.Add (conversation);
// }
// }
// }
// if (EligibleConversations.Count < 1) {
// character.SaidToday.Clear ();
// foreach(Conversation conversation in conversations){
// if (conversation.CheckConditions () == true) {
// EligibleConversations.Add (conversation);
// }
// }
// }
// }
//
// }
//
// void GetEligibleConversations(Character character, ConversationTypes pType){
// EligibleConversations.Clear ();
// List<Conversation> conversations = new List<Conversation>();
// switch (pType) {
// case ConversationTypes.Greeting:
// conversations = character.Greetings;
// break;
// case ConversationTypes.Meeting:
// conversations = character.Meetings;
// break;
// case ConversationTypes.Normal:
// conversations = character.Conversations;
// break;
// default:
// break;
// }
// if (conversations.Count>0) {
// foreach(Conversation conversation in conversations){
// if (conversation.CheckConditions () == true) {
// if (!character.SaidToday.Contains (conversation)) {
// EligibleConversations.Add (conversation);
// }
// }
// }
// if (EligibleConversations.Count < 1) {
// character.SaidToday.Clear ();
// foreach(Conversation conversation in conversations){
// if (conversation.CheckConditions () == true) {
// EligibleConversations.Add (conversation);
// }
// }
// }
// }
//
// }
Conversation GetSingleConversation()
{
var weights = new Dictionary <Conversation, int> ();
foreach (Conversation conversation in EligibleConversations)
{
// weights.Add (conversation, conversation.Weight);
}
return(WeightedRandomizer.From(weights).TakeOne());
}
public AdsReward RandomReward()
{
var cacheRewards = new Dictionary <AdsReward, int>();
foreach (var reward in rewards)
{
cacheRewards[reward] = reward.randomWeight;
}
var randomizer = WeightedRandomizer.From(cacheRewards);
return(randomizer.TakeOne());
}
void Start()
{
myDictionary = new Dictionary <GameObject, int>();
foreach (var entry in toSpawn)
{
myDictionary.Add(entry.key, entry.value);
}
GameObject objectToSpawn = WeightedRandomizer.From(myDictionary).TakeOne();
Instantiate(objectToSpawn, transform.position, Quaternion.identity);
}
// Start is called before the first frame update
void Start()
{
WeightedRandomizer <Color> m_Randomizer = new WeightedRandomizer <Color>();
m_Randomizer.AddValue(Color.black, 1.0f);
m_Randomizer.AddValue(Color.blue, 1.0f);
m_Randomizer.AddValue(Color.green, 1.0f);
m_Randomizer.AddValue(Color.red, 1.0f);
m_Randomizer.AddValue(Color.white, 50.0f);
float minX = m_X_Min;
float maxX = m_X_Max;
float minY = m_Y_Min;
float maxY = m_Y_Max;
//getting camera bounds
if (m_Camera)
{
float halfSize = m_Camera.orthographicSize;
float ratio = m_Camera.aspect;
minY = -halfSize;
maxY = halfSize;
minX = -halfSize * ratio;
maxX = halfSize * ratio;
}
//generate sprites
m_Sprites = new List <SpriteData>(m_SpritesCount);
for (int i = 0; i < m_SpritesCount; i++)
{
var newSprite = new SpriteData();
newSprite.m_Coords.x = MathHelpers.Random_Float(minX, maxX);
newSprite.m_Coords.y = MathHelpers.Random_Float(minY, maxY);
newSprite.m_Color = m_Randomizer.GetRandomValue();
newSprite.m_HorLeft = MathHelpers.Random_CheckChance(0.5f);
newSprite.m_VerUp = MathHelpers.Random_CheckChance(0.5f);
newSprite.m_SpeedMult = MathHelpers.Random_Factor();
newSprite.m_SpeedMult = newSprite.m_SpeedMult * newSprite.m_SpeedMult * newSprite.m_SpeedMult * newSprite.m_SpeedMult * newSprite.m_SpeedMult * newSprite.m_SpeedMult;
newSprite.m_SpriteIndex = MathHelpers.Random_Int(0, 1);
newSprite.m_Angle = MathHelpers.Random_Angle();
newSprite.m_Scale = Interpolation.Linear(0.5f, 2.0f, (Mathf.Pow(MathHelpers.Random_Factor(), 3.0f)));
m_Sprites.Add(newSprite);
}
}
private IEnumerator RepeatSummoning()
{
while (GlobalValues.gameIsActive)
{
yield return(new WaitForSeconds(respawnTime));
var weights = new Dictionary <AvailableMonsters, int>();
weights.Add(AvailableMonsters.Skeleton, 80);
weights.Add(AvailableMonsters.Werewolf, 15);
weights.Add(AvailableMonsters.Ogre, 5);
AvailableMonsters selectedMonster = WeightedRandomizer.From(weights).TakeOne(); d
StartCoroutine(SummonMonster(monsterList[(int)selectedMonster], respawnPoints[Random.Range(0, respawnPoints.Count)]));
}
}
int SetUnitIVs()
{
var boonBaneChances = new Dictionary <int, int>();
boonBaneChances.Add(0, 60); // 60% chance to return a buff of 0
boonBaneChances.Add(3, 16); // 16% chance to return a buff of positive 3
boonBaneChances.Add(-3, 16); // 16% chance to return a buff of negative 3
boonBaneChances.Add(4, 3); // 3% chance etc
boonBaneChances.Add(-4, 3); // 3% chance etc
boonBaneChances.Add(5, 1); // 1% chance etc
boonBaneChances.Add(-5, 1); // 1% chance etc
// This will go through the boonBanes and pick one. The percentages mean that something 50% is 50% more like to be picked than something with 4%
return(WeightedRandomizer.From(boonBaneChances).TakeOne());
}
// Use this for initialization
void Start()
{
Dictionary <GameObject, int> weights = new Dictionary <GameObject, int>();
foreach (var item in spawnPools)
{
weights.Add(item.prefab, item.weight);
}
randomizer = new WeightedRandomizer <GameObject>(weights);
StartCoroutine(Spawn());
//InvokeRepeating("spawny", spawnTime, spawnTime);
//spawny();
}
//custom skill logic
public void RandomAction()
{
// Random Action
// Dictionary of actionId, weight
Dictionary <string, int> actions = new Dictionary <string, int>();
actions.Add(Const.NormalAttack, 5);
foreach (string key in self.Item.GetCustomSkills().Keys)
{
var skill = self.Item.GetCustomSkills()[key];
if (skill == null || !skill.CanUse())
{
continue;
}
actions.Add(key, 5);
}
self.Action = WeightedRandomizer.From(actions).TakeOne();
// Random Target
if (self.Action == Const.NormalAttack)
{
var foes = self.Manager.GetFoes(self);
Random.InitState(System.DateTime.Now.Millisecond);
self.ActionTarget = foes[Random.Range(0, foes.Count - 1)] as CharacterEntity;
}
else
{
switch (self.SelectedCustomSkill.usageScope)
{
case CustomSkill.SkillUsageScope.Enemy:
var foes = self.Manager.GetFoes(self);
Random.InitState(System.DateTime.Now.Millisecond);
self.ActionTarget = foes[Random.Range(0, foes.Count)] as CharacterEntity;
break;
case CustomSkill.SkillUsageScope.Ally:
var allies = self.Manager.GetAllies(self);
Random.InitState(System.DateTime.Now.Millisecond);
self.ActionTarget = allies[Random.Range(0, allies.Count)] as CharacterEntity;
break;
default:
self.ActionTarget = null;
break;
}
}
DoAction();
}
public void PerformCombatAction()
{
TakeDotDamage();
EnemyAbility ab = WeightedRandomizer.From(enemyData.EnemyAbilities).TakeOne();
abName = ab.Name;
Invoke(nameof(UpdateText), 1);
if (ab.MinHeal > 0)
{
EnemyBehavior enemyToHeal = Game.CurrentCombatSystem.Enemies.First(e => e.health == Game.CurrentCombatSystem.Enemies.Max(b => b.health));
enemyToHeal.ReceiveHealing(Random.Range(ab.MinHeal, ab.MaxHeal));
}
if (ab.MinDamage > 0)
{
this.ApplyDamage(Random.Range(ab.MinDamage, ab.MaxDamage + 1), Game.Player, ab.ArmorPiercing);
}
if (ab.MinBlock > 0)
{
this.IncreaseShield(Random.Range(ab.MinBlock, ab.MaxBlock));
}
if (ab.Stun)
{
Game.Player.stunned = true;
}
if (ab.DamageReduction > 0)
{
this.ApplyDamageDebuff(-ab.DamageReduction, Game.Player);
}
if (ab.SelfDamage > 0)
{
this.ReceiveDamage(ab.SelfDamage);
}
if (ab.Dot)
{
this.ReceiveDot(ab.DotDamage, ab.Time);
}
UpdateBars();
}
private IEnumerator SimulateEvent()
{
yield return(new WaitForSeconds(5));
while (true)
{
RemoveDeadEvents();
if (events.Count > 0)
{
Event ev = WeightedRandomizer.From(events).TakeOne();
events.Remove(ev);
PerformEvent(ev);
}
yield return(new WaitForSeconds(EventFrequency));
}
}
public void Generate()
{
transform.DestroyChildren(true);
foreach (var _prefabCollection in prefabs)
{
if (!weights.ContainsKey(_prefabCollection.prefab))
{
weights.Add(_prefabCollection.prefab, _prefabCollection.weight);
}
}
GameObject selected = WeightedRandomizer.From(weights).TakeOne();
foreach (var _prefabCollection in prefabs)
{
if (_prefabCollection.prefab.name.Equals(selected.name))
{
if (_prefabCollection.childPrefabs == null)
{
break;
}
foreach (var _childPrefabs in _prefabCollection.childPrefabs)
{
Dictionary <GameObject, int> childWeights = new Dictionary <GameObject, int>();
foreach (var _childPrefabCollection in _childPrefabs.childPrefabCollection)
{
if (!childWeights.ContainsKey(_childPrefabCollection.prefab))
{
childWeights.Add(_childPrefabCollection.prefab, _childPrefabCollection.weight);
}
}
this.childWeights.Add(childWeights);
}
}
}
GameObject PrefabCollec = (GameObject)Instantiate(selected, transform.position, transform.rotation, transform);
foreach (var _childPrefabCollection in childWeights)
{
GameObject selectedChild = WeightedRandomizer.From(_childPrefabCollection).TakeOne();
GameObject PrefabCollecChild = (GameObject)Instantiate(selectedChild, transform.position, transform.rotation, PrefabCollec.transform);
}
childWeights.Clear();
}
private void DrawDayGenericConversations()
{
DayGenericConversations = new List <Conversation>();
Dictionary <Conversation, int> generic = new Dictionary <Conversation, int>();
foreach (Conversation conversation in AllConversations)
{
// print(conversation.Title);
if (CheckIfGeneric(conversation) == false)
{
// print("Not generic");
continue;
}
if (conversation.LookupInt("Priority") != 0)
{
// print("Priority>0");
continue;
}
generic.Add(conversation, conversation.LookupInt("Weight"));
// print("Add to generic: " + conversation.Title);
}
int amt = maxGenConvos - DayGenericConversations.Count;
if (amt < 0)
{
amt = 0;
}
// print("Adding conversations: " + amt);
for (int i = 0; i < amt; i++)
{
if (generic.Count < 1)
{
// print("No more eligible conversations");
break;
}
Conversation conversation = WeightedRandomizer.From(generic).TakeOne();
DayGenericConversations.Add(conversation);
// AllConversations.Remove(conversation);
generic.Remove(conversation);
// print("Adding to list");
}
// print("Generated generic conversations for the day: " + DayGenericConversations.Count);
}
public void DropLoot(Vector3 position)
{
// 1 in 5 chance of winning a prize!
if (Random.Range(0, 1f) > _chanceOfDrop)
{
return;
}
position.y = 0; // HACKY :D
var copy = Instantiate(_lootBoxPrefab, position, Quaternion.identity);
var lootBox = copy.GetComponent <LootBox>();
lootBox._loot = Instantiate(WeightedRandomizer.From(_weighted).TakeOne());
var visual = lootBox._loot.GetComponent <LootDropMonoBehaviour>()._containerPrefab;
var visualCopy = Instantiate(visual, lootBox.transform);
visualCopy.transform.localPosition = Vector3.zero;
}
public void SetupRoom(RoomSetupProperties properties)
{
var player = PlayerCharacter.GetPlayerCharacter();
var desired_spawn_location = GetOppositeDirection(properties.enter_from);
var player_spawn_points = GetComponentsInChildren <PlayerSpawn>().ToList();
var player_spawn = player_spawn_points.Find((x) => x.spawn_direction == desired_spawn_location);
if (player_spawn == null)
{
player_spawn = player_spawn_points[0];
}
player.transform.position = player_spawn.transform.position;
if (enemy_types.Count == 0)
{
Debug.LogError("NEED TO SET ENEMY WEIGHTS IN ROOM!");
return;
}
Dictionary <GameObject, int> enemy_spawn_dict = new Dictionary <GameObject, int>();
enemy_types.ForEach((enemy) => { enemy_spawn_dict.Add(enemy.enemy_prefab, enemy.weight); });
var enemy_weighted_random = WeightedRandomizer.From(enemy_spawn_dict);
var enemy_spawn_points = GetComponentsInChildren <EnemySpawn>().ToList();
enemy_spawn_points.ForEach((EnemySpawn spawn) => {
var enemy_type = enemy_weighted_random.TakeOne();
var enemy_instance = Instantiate <GameObject>(enemy_type, spawn.transform);
// make new spawns objectives in order to exit room
enemy_instance.AddComponent <ObjectiveEnemy>();
var ai_brain = enemy_instance.GetComponent <AIBrain>();
// disable AI at start
ai_brain.EnableBrain(false);
var distance_to_player = Vector3.Distance(enemy_instance.transform.position, player.gameObject.transform.position);
if (distance_to_player >= 10f)
{
ai_brain.SetEnableOnDistanceOrDamage();
}
});
// @TODO: iterate over AI and set "wake nearby" on wake...
room_setup_complete = true;
}
public static Worker GenerateRandomWorker()
{
Random rand = new Random();
RandomName nameGen = new RandomName(rand);
var worker = new Worker()
{
Name = nameGen.Generate((Sex)rand.Next(0, 2), rand.Next(0, 2)), Cost = 2000
};
var weights = new Dictionary <int, int>()
{
{ 1, 40 },
{ 2, 40 },
{ 3, 15 },
{ 4, 4 },
{ 5, 1 },
};
worker.Efficiency = WeightedRandomizer.From(weights).TakeOne();
return(worker);
}
public void Random()
{
var gameplay = GameplayManager.Singleton;
var dict = new Dictionary <CharacterAttributes, int>();
var list = gameplay.attributes.Values.ToList();
foreach (var entry in list)
{
dict.Add(entry, entry.randomWeight);
}
for (var i = 0; i < randomAttributes.Length; ++i)
{
var randomAttribute = randomAttributes[i];
if (randomAttribute != null)
{
var randomedAttribute = WeightedRandomizer.From(dict).TakeOne();
randomAttribute.SetAttribute(randomedAttribute);
dict.Remove(randomedAttribute);
}
}
}
public static void ShowAd(string placement, System.Action <RemakeShowResult> showResultHandler)
{
ShowResultCallbacks[placement] = showResultHandler;
if (Singleton.adsOverrideActions != null && Singleton.adsOverrideActions.Count > 0)
{
Dictionary <ShowAdOverrideAction, int> randomActions = new Dictionary <ShowAdOverrideAction, int>();
foreach (var overrideAction in Singleton.adsOverrideActions)
{
if (overrideAction.placement.Equals(placement))
{
randomActions[overrideAction] = overrideAction.weight;
}
}
if (randomActions.Count > 0)
{
var randomizer = WeightedRandomizer.From(randomActions);
randomizer.TakeOne().action.Invoke(placement);
return;
}
}
Singleton.DefaultShowAdFunction(placement);
}
void MakeTerrain()
{
List<int> list = new List<int>();
Terrain.ForEach(x => list.Add(x.Weight));
WeightedRandomizer randomizer = new WeightedRandomizer(list);
foreach (WorldMapHexagonTileData tileData in DataCarrier.PersistentData.WorldRepresentation.Values)
{
int ran = randomizer.GetRandomIndex();
WorldMapTerrainDefinition def = Terrain[ran];
tileData.Terrain = def;
}
}
