public void TestSolutionOpen()
{
RandomGeneratorExtensions.GetGetNewRandom = () => new RandomGenerator(4541247);
// create problem.
var problem = STSPHelper.CreateDirectedSTSP(0, 5, 10, 1, 40);
// create the solver.
var solver = new RandomSolver();
var objective = new STSPObjective();
for (var i = 0; i < 100; i++)
{
// generate solution.
STSPFitness fitness;
var solution = solver.Solve(problem, objective, out fitness);
// test contents.
Assert.AreEqual(problem.First, solution.First);
Assert.AreEqual(problem.Last, solution.Last);
Assert.AreEqual(solution.Count, fitness.Customers);
Assert.IsTrue(40 >= fitness.Weight);
}
}
private void InitializeCampingSkills(int bonusSkills = 0)
{
CurrentCampingSkills = new CampingSkill[HeroClass.CampingSkills.Count];
var availableGeneralSkills = HeroClass.CampingSkills.FindAll(skill => skill.Classes.Count > 4);
int generalSkillsRequired = HeroClass.Generation.NumberOfSharedCampingSkills;
foreach (var skill in availableGeneralSkills.OrderBy(x => RandomSolver.NextDouble())
.Take(Mathf.Min(generalSkillsRequired, availableGeneralSkills.Count)))
{
int skillIndex = HeroClass.CampingSkills.IndexOf(skill);
CurrentCampingSkills[skillIndex] = skill;
}
var availableSpecificSkills = HeroClass.CampingSkills.FindAll(skill => skill.Classes.Count <= 4);
int specificSkillsRequired = HeroClass.Generation.NumberOfSpecificCampingSkills + bonusSkills;
foreach (var skill in availableSpecificSkills.OrderBy(x => RandomSolver.NextDouble())
.Take(Mathf.Min(specificSkillsRequired, availableSpecificSkills.Count)))
{
int skillIndex = HeroClass.CampingSkills.IndexOf(skill);
CurrentCampingSkills[skillIndex] = skill;
}
var availableGeneratedSkills = new List <CampingSkill>(CurrentCampingSkills);
availableGeneratedSkills.RemoveAll(skill => skill == null);
SelectedCampingSkills = availableGeneratedSkills.OrderBy(x => RandomSolver.NextDouble())
.Take(Mathf.Min(4, availableGeneratedSkills.Count)).ToList();
}
public void TestSolutionClosed()
{
RandomGeneratorExtensions.GetGetNewRandom = () => new RandomGenerator(4541247);
// create problem.
var problem = TSPHelper.CreateTSP(0, 0, 5, 10);
// create the solver.
var solver = new RandomSolver();
for (int i = 0; i < 100; i++)
{
// generate solution.
float fitness;
var solution = solver.Solve(problem, new TSPObjective(), out fitness);
// test contents.
Assert.AreEqual(50, fitness);
Assert.AreEqual(0, solution.First);
Assert.AreEqual(0, solution.Last);
var solutionList = new List <int>(solution);
Assert.AreEqual(0, solutionList[0]);
Assert.IsTrue(solutionList.Remove(0));
Assert.IsTrue(solutionList.Remove(1));
Assert.IsTrue(solutionList.Remove(2));
Assert.IsTrue(solutionList.Remove(3));
Assert.IsTrue(solutionList.Remove(4));
Assert.AreEqual(0, solutionList.Count);
}
}
private void InitializeQuirks(RecruitUpgrade expUpgrade = null)
{
int positiveQuirkNumber = RandomSolver.Next(HeroClass.Generation.NumberOfPositiveQuirksMin,
HeroClass.Generation.NumberOfPositiveQuirksMax + 1);
int negativeQuirkNumber = RandomSolver.Next(HeroClass.Generation.NumberOfNegativeQuirksMin,
HeroClass.Generation.NumberOfNegativeQuirksMax + 1);
if (expUpgrade != null)
{
positiveQuirkNumber += expUpgrade.ExtraPositiveQuirks;
negativeQuirkNumber += expUpgrade.ExtraNegativeQuirks;
}
for (int i = 0; i < positiveQuirkNumber; i++)
{
var availableQuirks = DarkestDungeonManager.Data.Quirks.Values.ToList().FindAll(newQuirk => newQuirk.IsPositive &&
quirkData.TrueForAll(quirkInfo => !quirkInfo.Quirk.IncompatibleQuirks.Contains(newQuirk.Id)) &&
quirkData.Find(quirkInfo => quirkInfo.Quirk == newQuirk) == null);
var availableQuirk = availableQuirks[RandomSolver.Next(availableQuirks.Count)];
quirkData.Add(new QuirkInfo(availableQuirk, false, 1, false));
ApplyQuirk(availableQuirk);
}
for (int i = 0; i < negativeQuirkNumber; i++)
{
var availableQuirks = DarkestDungeonManager.Data.Quirks.Values.ToList().FindAll(newQuirk => !newQuirk.IsPositive &&
!newQuirk.IsDisease && quirkData.TrueForAll(quirkInfo => !quirkInfo.Quirk.IncompatibleQuirks.Contains(newQuirk.Id)) &&
quirkData.Find(quirkInfo => quirkInfo.Quirk == newQuirk) == null);
var availableQuirk = availableQuirks[RandomSolver.Next(availableQuirks.Count)];
quirkData.Add(new QuirkInfo(availableQuirk, false, 1, false));
ApplyQuirk(availableQuirk);
}
}
private void InitializeCombatSkills(int bonusSkills = 0)
{
var availableSkills = new List <CombatSkill>(HeroClass.CombatSkills);
int skillsRequired = Mathf.Clamp(HeroClass.Generation.NumberOfRandomCombatSkills + bonusSkills, 0, HeroClass.CombatSkills.Count);
CurrentCombatSkills = new CombatSkill[HeroClass.CombatSkills.Count];
foreach (var guaranteedSkill in availableSkills.FindAll(skill => skill.IsGenerationGuaranteed))
{
CurrentCombatSkills[HeroClass.CombatSkills.IndexOf(guaranteedSkill)] = guaranteedSkill;
availableSkills.Remove(guaranteedSkill);
skillsRequired--;
}
for (int i = skillsRequired; i > 0; i--)
{
int generatedIndex = RandomSolver.Next(availableSkills.Count);
CurrentCombatSkills[HeroClass.CombatSkills.IndexOf(availableSkills[generatedIndex])] = availableSkills[generatedIndex];
availableSkills.RemoveAt(generatedIndex);
}
SelectedCombatSkills = new List <CombatSkill>();
var selectionList = new List <CombatSkill>(CurrentCombatSkills);
selectionList.RemoveAll(skill => skill == null);
int selectedSkills = Mathf.Clamp(HeroClass.NumberOfSelectedCombatSkills, 0, selectionList.Count);
for (int i = 0; i < selectedSkills; i++)
{
int selectedItem = RandomSolver.Next(selectionList.Count);
SelectedCombatSkills.Add(selectionList[selectedItem]);
selectionList.RemoveAt(selectedItem);
}
}
public override bool ApplyInstant(FormationUnit performer, FormationUnit target, Effect effect)
{
if (target == null)
{
return(false);
}
if (!performer.Character.IsMonster)
{
return(false);
}
if (((Monster)performer.Character).Data.ControllerCaptor == null)
{
return(false);
}
float debuffChance = effect.IntegerParams[EffectIntParams.Chance].HasValue ?
(float)effect.IntegerParams[EffectIntParams.Chance].Value / 100 : 1;
debuffChance -= target.Character.GetSingleAttribute(AttributeType.Debuff).ModifiedValue;
debuffChance = performer == target ? 1 : Mathf.Clamp(debuffChance, 0, 0.95f);
if (RandomSolver.CheckSuccess(debuffChance))
{
RaidSceneManager.BattleGround.ControlUnit(target, performer, Duration);
return(true);
}
return(false);
}
public Hero(int heroIndex, PhotonPlayer player)
: base(DarkestDungeonManager.Data.HeroClasses[(string)player.CustomProperties["HC" + heroIndex]])
{
RandomSolver.SetRandomSeed((int)player.CustomProperties["HS" + heroIndex]);
InitializeHeroInfo(0, (string)player.CustomProperties["HN" + heroIndex],
(string)player.CustomProperties["HC" + heroIndex], 0, 30);
InitializeEquipment(1, 1);
InitializeQuirks();
CurrentCombatSkills = new CombatSkill[HeroClass.CombatSkills.Count];
for (int i = 0; i < CurrentCombatSkills.Length; i++)
{
CurrentCombatSkills[i] = HeroClass.CombatSkills[i];
}
var playerSkillFlags = (PlayerSkillFlags)player.CustomProperties["HF" + heroIndex];
SelectedCombatSkills = new List <CombatSkill>();
for (int i = 0; i < CurrentCombatSkills.Length; i++)
{
if ((playerSkillFlags & (PlayerSkillFlags)Mathf.Pow(2, i + 1)) != PlayerSkillFlags.Empty)
{
SelectedCombatSkills.Add(CurrentCombatSkills[i]);
}
}
CurrentCampingSkills = new CampingSkill[HeroClass.CampingSkills.Count];
SelectedCampingSkills = new List <CampingSkill>();
}
public override bool ApplyInstant(FormationUnit performer, FormationUnit target, Effect effect)
{
if (target == null)
{
return(false);
}
float poisonChance = effect.IntegerParams[EffectIntParams.Chance].HasValue ?
(float)effect.IntegerParams[EffectIntParams.Chance].Value / 100 : 1;
poisonChance -= target.Character.GetSingleAttribute(AttributeType.Poison).ModifiedValue;
if (performer != null && performer.Character is Hero)
{
poisonChance += performer.Character.GetSingleAttribute(AttributeType.PoisonChance).ModifiedValue;
}
poisonChance = Mathf.Clamp(poisonChance, 0, 0.95f);
if (RandomSolver.CheckSuccess(poisonChance))
{
var poisonStatus = (PoisonStatusEffect)target.Character.GetStatusEffect(StatusType.Poison);
var newDot = new DamageOverTimeInstanse
{
TickDamage = DotPoison,
TicksAmount = effect.IntegerParams[EffectIntParams.Duration] ?? 3
};
newDot.TicksLeft = newDot.TicksAmount;
poisonStatus.AddInstanse(newDot);
return(true);
}
return(false);
}
public override bool ApplyInstant(FormationUnit performer, FormationUnit target, Effect effect)
{
if (target == null || target.Character is Hero == false)
{
return(false);
}
float diseaseTriggerChance = effect.IntegerParams[EffectIntParams.Chance].HasValue ?
(float)effect.IntegerParams[EffectIntParams.Chance].Value / 100 : 1;
if (!RandomSolver.CheckSuccess(diseaseTriggerChance))
{
return(false);
}
float diseaseChance = 1 - target.Character.GetSingleAttribute(AttributeType.Disease).ModifiedValue;
if (RandomSolver.CheckSuccess(diseaseChance))
{
var hero = (Hero)target.Character;
if (IsRandom == false && Disease != null)
{
if (hero.AddQuirk(Disease))
{
return(true);
}
}
else
{
hero.AddRandomDisease();
return(true);
}
}
return(false);
}
public override bool ApplyInstant(FormationUnit performer, FormationUnit target, Effect effect)
{
if (target == null)
{
return(false);
}
var stunStatus = (StunStatusEffect)target.Character.GetStatusEffect(StatusType.Stun);
if (stunStatus.IsApplied)
{
return(true);
}
float stunChance = effect.IntegerParams[EffectIntParams.Chance].HasValue ?
(float)effect.IntegerParams[EffectIntParams.Chance].Value / 100 : 1;
stunChance -= target.Character.GetSingleAttribute(AttributeType.Stun).ModifiedValue;
if (performer != null && performer.Character is Hero)
{
stunChance += performer.Character.GetSingleAttribute(AttributeType.StunChance).ModifiedValue;
}
stunChance = Mathf.Clamp(stunChance, 0, 0.95f);
if (RandomSolver.CheckSuccess(stunChance))
{
stunStatus.StunApplied = true;
target.SetHalo("stunned");
target.Character[StatusType.Guard].ResetStatus();
return(true);
}
return(false);
}
private void SolveMultiple100()
{
KnapsackInput input;
for (int i = 0; i < 100; i++)
{
input = new KnapsackInput();
input.GenerateRandomItems();
var stopwatch = new Stopwatch();
var solverBaB = new BranchAndBoundSolver(input.Items, input.Capacity);
var solverRand = new RandomSolver(input.Items, input.Capacity);
var solverGreedy = new GreedySolver(input.Items, input.Capacity);
var solverDynamic = new DynamicProgrammingSolver(input.Items, input.Capacity);
stopwatch.Start();
solverBaB.Solve();
stopwatch.Stop();
timeResultsBaB.Add(new DataPoint(i, stopwatch.Elapsed.TotalMilliseconds));
stopwatch.Restart();
solverRand.Solve();
stopwatch.Stop();
timeResultsRand.Add(new DataPoint(i, stopwatch.Elapsed.TotalMilliseconds));
stopwatch.Restart();
solverGreedy.Solve();
stopwatch.Stop();
timeResultsGreedy.Add(new DataPoint(i, stopwatch.Elapsed.TotalMilliseconds));
stopwatch.Restart();
solverDynamic.Solve();
stopwatch.Stop();
timeResultsDynamic.Add(new DataPoint(i, stopwatch.Elapsed.TotalMilliseconds));
}
timeAverageGreedy = Math.Round((timeResultsGreedy.Sum(x => x.Y) / 100), 4);
timeAverageRand = Math.Round((timeResultsRand.Sum(x => x.Y) / 100), 4);
timeAverageBaB = Math.Round((timeResultsBaB.Sum(x => x.Y) / 100), 4);
timeAverageDynamic = Math.Round((timeResultsDynamic.Sum(x => x.Y) / 100), 4);
}
protected virtual bool ChooseTargets(List <FormationUnit> availableTargets, MonsterBrainDecision decision)
{
if (availableTargets.Count > 0)
{
decision.TargetInfo.Targets.Clear();
if (decision.SelectedSkill.TargetRanks.IsMultitarget)
{
decision.TargetInfo.Targets.AddRange(availableTargets);
return(true);
}
else
{
int index = Random.Range(0, availableTargets.Count);
decision.TargetInfo.Targets.Add(availableTargets[index]);
availableTargets.RemoveAt(index);
if (decision.SelectedSkill.ExtraTargetsChance > 0 && availableTargets.Count > 0 &&
RandomSolver.CheckSuccess(decision.SelectedSkill.ExtraTargetsChance))
{
int sideTargetIndex = Random.Range(0, availableTargets.Count);
decision.TargetInfo.Targets.Add(availableTargets[sideTargetIndex]);
return(true);
}
return(true);
}
}
return(false);
}
private static void ChooseRandomMove(string tronFilePath)
{
ISolver solver = new RandomSolver();
Coordinator coordinator = new Coordinator(solver);
coordinator.IsInDebugMode = false;
coordinator.Run(tronFilePath);
}
public Trinket GenerateTrinket()
{
var trinketList = DarkestDungeonManager.Data.Items["trinket"].Values.Cast <Trinket>().ToList();
var rarity = RandomSolver.ChooseByRandom(RarityTable).RarityId;
var rarityList = trinketList.FindAll(item => item.RarityId == rarity);
return(rarityList[UnityEngine.Random.Range(0, rarityList.Count)]);
}
public override bool ApplyQueued(FormationUnit performer, FormationUnit target, Effect effect)
{
if (target == null)
{
return(false);
}
if (target.Character is Hero == false)
{
return(false);
}
if (effect.IntegerParams[EffectIntParams.Chance].HasValue)
{
if (!RandomSolver.CheckSuccess((float)effect.IntegerParams[EffectIntParams.Chance].Value / 100))
{
return(false);
}
}
float initialDamage = StressAmount;
if (performer != null)
{
initialDamage *= (1 + performer.Character.GetSingleAttribute(AttributeType.StressDmgPercent).ModifiedValue);
}
int damage = Mathf.RoundToInt(initialDamage * (1 +
target.Character.GetSingleAttribute(AttributeType.StressDmgReceivedPercent).ModifiedValue));
if (damage < 1)
{
damage = 1;
}
target.Character.Stress.IncreaseValue(damage);
if (target.Character.IsOverstressed)
{
if (target.Character.IsVirtued)
{
target.Character.Stress.CurrentValue = Mathf.Clamp(target.Character.Stress.CurrentValue, 0, 100);
}
else if (!target.Character.IsAfflicted && target.Character.IsOverstressed)
{
RaidSceneManager.Instanse.AddResolveCheck(target);
}
if (Mathf.Approximately(target.Character.Stress.CurrentValue, 200))
{
RaidSceneManager.Instanse.AddHeartAttackCheck(target);
}
}
target.OverlaySlot.UpdateOverlay();
RaidSceneManager.RaidEvents.ShowPopupMessage(target, PopupMessageType.Stress, damage.ToString());
target.SetHalo("afflicted");
return(true);
}
public void ProvideActivity()
{
foreach (var treatmentSlot in TreatmentSlots)
{
switch (treatmentSlot.Status)
{
case ActivitySlotStatus.Caretaken:
treatmentSlot.Status = ActivitySlotStatus.Available;
treatmentSlot.Hero = null;
break;
case ActivitySlotStatus.Blocked:
case ActivitySlotStatus.Checkout:
treatmentSlot.Hero.Status = HeroStatus.Available;
treatmentSlot.Status = ActivitySlotStatus.Available;
treatmentSlot.Hero = null;
break;
case ActivitySlotStatus.Paid:
if (treatmentSlot.TargetDiseaseQuirk != null)
{
if (RandomSolver.CheckSuccess(CureAllChance))
{
var cured = treatmentSlot.Hero.RemoveDiseases();
if (cured.Count == 0)
{
Debug.LogError("Sanitarium treament diseases not found.");
}
else
{
LogActivity(ActivityType.RemoveAllDiseases,
treatmentSlot.Hero, cured.Select(info => info.Quirk.Id).ToArray());
}
}
else
{
if (treatmentSlot.Hero.RemoveQuirk(treatmentSlot.TargetDiseaseQuirk) == null)
{
Debug.LogError("Sanitarium treament disease not found.");
}
else
{
LogActivity(ActivityType.RemoveDisease,
treatmentSlot.Hero, new string[] { treatmentSlot.TargetDiseaseQuirk });
}
}
}
treatmentSlot.Hero.Status = HeroStatus.Available;
treatmentSlot.Status = ActivitySlotStatus.Available;
treatmentSlot.Hero = null;
break;
default:
break;
}
}
}
public static List <ItemDefinition> GenerateLoot(List <LootDefinition> battleLoot, RaidInfo raid)
{
List <ItemDefinition> lootItems = new List <ItemDefinition>();
for (int i = 0; i < battleLoot.Count; i++)
{
for (int j = 0; j < battleLoot[i].Count; j++)
{
LootEntry entry = GetLootEntry(battleLoot[i].Code, raid);
switch (entry.Type)
{
case LootType.Item:
LootEntryItem itemEntry = entry as LootEntryItem;
ItemDefinition data = new ItemDefinition();
data.Type = itemEntry.ItemType;
data.Id = itemEntry.ItemId;
data.Amount = itemEntry.ItemAmount;
lootItems.Add(data);
break;
case LootType.Journal:
LootEntryJournal journalEntry = entry as LootEntryJournal;
ItemDefinition dataJournal = new ItemDefinition();
dataJournal.Type = "journal_page";
if (journalEntry.SpecificId.HasValue)
{
dataJournal.Id = journalEntry.SpecificId.Value.ToString();
}
else
{
dataJournal.Id = RandomSolver.Next(journalEntry.MinIndex, journalEntry.MaxIndex + 1).ToString();
}
dataJournal.Amount = 1;
lootItems.Add(dataJournal);
break;
case LootType.Trinket:
LootEntryTrinket trinketEntry = entry as LootEntryTrinket;
var trinketList = DarkestDungeonManager.Data.Items["trinket"].Values.ToList().
FindAll(trinket => ((Trinket)trinket).RarityId == trinketEntry.Rarity);
Trinket trinketItem = (Trinket)trinketList[RandomSolver.Next(trinketList.Count)];
ItemDefinition trinketDef = new ItemDefinition();
trinketDef.Type = trinketItem.Type;
trinketDef.Id = trinketItem.Id;
trinketDef.Amount = trinketDef.Amount;
lootItems.Add(trinketDef);
break;
case LootType.Nothing:
break;
}
}
}
return(lootItems);
}
private static LootEntry GetLootEntry(string tableId, RaidInfo raid)
{
LootTable lootTable = LootDatabase.LootTables[tableId.ToUpper()].
Find(table => ((table.Difficulty == raid.Quest.Difficulty) || (table.Difficulty == 0)) &&
((table.Dungeon == raid.Dungeon.Name) || (table.Dungeon == "")));
LootEntry lootEntry = RandomSolver.ChooseBySingleRandom(lootTable.Entries);
return(lootEntry.Type != LootType.Table ? lootEntry : GetLootEntry(((LootEntryTable)lootEntry).TableId, raid));
}
public void TestOpen()
{
var problem = TSPHelper.CreateDirectedTSP(0, 10, 100, 5);
var random = new RandomSolver();
var randomRoute = random.Solve(problem, new Optimization.TSP.Directed.TSPObjective());
var op = new DirectionLocalSearch();
float delta;
var optimized = op.Apply(problem, new Optimization.TSP.Directed.TSPObjective(), randomRoute, out delta);
}
public override bool ApplyQueued(FormationUnit performer, FormationUnit target, Effect effect)
{
if (target == null)
{
return(false);
}
if (effect.IntegerParams[EffectIntParams.Chance].HasValue)
{
if (!RandomSolver.CheckSuccess((float)effect.IntegerParams[EffectIntParams.Chance].Value / 100))
{
return(false);
}
}
float initialHeal = HealAmount;
if (performer != null)
{
initialHeal *= (1 + performer.Character.GetSingleAttribute(AttributeType.HpHealPercent).ModifiedValue);
}
if (performer != null && RandomSolver.CheckSuccess(performer.Character.Crit))
{
int critHeal = target.Character.Heal(initialHeal * 1.5f, true);
RaidSceneManager.RaidEvents.ShowPopupMessage(target, PopupMessageType.CritHeal, critHeal.ToString());
if (target.Character is Hero)
{
FMODUnity.RuntimeManager.PlayOneShot("event:/general/status/heal_ally_crit");
}
else
{
FMODUnity.RuntimeManager.PlayOneShot("event:/general/status/heal_enemy_crit");
}
target.OverlaySlot.UpdateOverlay();
return(true);
}
else
{
int heal = target.Character.Heal(initialHeal, true);
RaidSceneManager.RaidEvents.ShowPopupMessage(target, PopupMessageType.Heal, heal.ToString());
if (target.Character is Hero)
{
FMODUnity.RuntimeManager.PlayOneShot("event:/general/status/heal_ally");
}
else
{
FMODUnity.RuntimeManager.PlayOneShot("event:/general/status/heal_enemy");
}
target.OverlaySlot.UpdateOverlay();
return(true);
}
}
public Quirk AddRandomDisease()
{
var replacableQuirks = quirkData.FindAll(quirkInfo => quirkInfo.Quirk.IsDisease);
var availableQuirks = DarkestDungeonManager.Data.Quirks.Values.ToList().FindAll(newQuirk => newQuirk.IsDisease &&
quirkData.TrueForAll(quirkInfo => !quirkInfo.Quirk.IncompatibleQuirks.Contains(newQuirk.Id)) &&
quirkData.All(quirkInfo => quirkInfo.Quirk != newQuirk));
var addedQuirk = availableQuirks[RandomSolver.Next(availableQuirks.Count)];
return(AddOrReplaceQuirk(addedQuirk, replacableQuirks));
}
public void RestockBonus(List <int> rosterIds, Estate estate, string bonusClass, int bonusAmount)
{
EventHeroes.Clear();
GraveIndexes.Clear();
#region Clear unrecruited heroes
if (EventHeroes.Count > 0)
{
for (int i = 0; i < EventHeroes.Count; i++)
{
if (rosterIds.Contains(EventHeroes[i].RosterId))
{
Debug.LogError("Same id returned while restocking heroes.");
}
else
{
rosterIds.Add(EventHeroes[i].RosterId);
}
estate.HeroPurchases.Remove(EventHeroes[i].RosterId);
}
}
#endregion
#region Create bonus recruits
for (int i = 0; i < bonusAmount; i++)
{
RecruitUpgrade experienceUpgrade = null;
if (CurrentRecruitMaxLevel > 0)
{
for (int j = 0; j <= RecruitExperienceUpgrades.Count - 1; j++)
{
if (RecruitExperienceUpgrades[j].Level <= CurrentRecruitMaxLevel &&
RandomSolver.CheckSuccess(RecruitExperienceUpgrades[j].Chance))
{
experienceUpgrade = RecruitExperienceUpgrades[j];
break;
}
}
}
int id = rosterIds[Random.Range(0, rosterIds.Count)];
string heroClass = DarkestDungeonManager.Data.HeroClasses[bonusClass].StringId;
string heroName = LocalizationManager.GetString("hero_name_" + Random.Range(0, 556).ToString());
var newHero = experienceUpgrade == null ?
new Hero(id, heroClass, heroName) :
new Hero(id, heroClass, heroName, experienceUpgrade);
EventHeroes.Add(newHero);
rosterIds.Remove(id);
GeneratePurchaseInfo(newHero, estate);
}
#endregion
}
public void Apply(Unit caster, Unit target, Spell spell, ArenaManager world)
{
int amount = 0;
amount += RandomSolver.Next(minValue, maxValue);
if (amount < 1)
{
amount = 1;
}
int initialDamage = amount;
caster.Character.parameters.Copy(world.SpellInfo.parameters);
for (int i = 0; i < Modifiers.Count; i++)
{
Modifiers[i].ModifySpell(caster, target, world.SpellInfo, spell, world);
}
initialDamage = (int)(initialDamage * world.SpellInfo.parameters[ParameterType.DamageDealing].FinalValue);
bool isCrit = RandomSolver.CheckSuccess(world.SpellInfo.parameters[ParameterType.CritChance].FinalValue);
if (isCrit)
{
initialDamage = (int)(initialDamage * caster.Character.parameters[ParameterType.CritDamageMultiplier].FinalValue);
}
amount = initialDamage;
Buff absorbBuff;
for (int i = target.character.AbsorbEffects.Count - 1; i >= 0; i--)
{
amount = target.character.AbsorbEffects[i](target, world, amount, out absorbBuff);
if (amount != 0)
{
target.character.Buffs.Remove(absorbBuff);
}
else
{
return;
}
}
target.Character.health.Decrease((ushort)amount);
if (caster.id == world.PlayerUnit.id)
{
GameObject damageEvent = MonoBehaviour.Instantiate(Resources.Load("Prefabs/UI/DamageEvent")) as GameObject;
damageEvent.GetComponent <UnitDamageUIEvent>().Initialize(initialDamage, target, isCrit, ArenaManager.PlayerInterface);
}
}
public void Apply(Unit caster, Unit target, Spell spell, ArenaManager world)
{
int amount = modifier;
amount += RandomSolver.Next(minValue, maxValue);
if (amount < 1)
{
amount = 1;
}
target.Character.health.Increase((ushort)amount);
}
public void RestockTrinkets()
{
Trinkets.Clear();
var trinketList = DarkestDungeonManager.Data.Items["trinket"].Values.Cast <Trinket>().ToList();
for (int i = 0; i < TrinketSlots; i++)
{
var rarity = RandomSolver.ChooseByRandom(RarityTable).RarityId;
var rarityList = trinketList.FindAll(item => item.RarityId == rarity);
Trinkets.Add(rarityList[UnityEngine.Random.Range(0, rarityList.Count)]);
}
Trinkets.Sort((x, y) => y.PurchasePrice.CompareTo(x.PurchasePrice));
}
public Quirk RemovePositiveQuirk()
{
var positiveQuirks = quirkData.FindAll(quirkInfo => quirkInfo.Quirk.IsPositive && !quirkInfo.IsLocked);
if (positiveQuirks.Count > 0)
{
var removedQuirk = positiveQuirks[RandomSolver.Next(positiveQuirks.Count)];
RevertQuirk(removedQuirk.Quirk);
quirkData.Remove(removedQuirk);
return(removedQuirk.Quirk);
}
return(null);
}
public Quirk RemoveDiseaseQuirk()
{
var diseases = quirkData.FindAll(quirkInfo => quirkInfo.Quirk.IsDisease);
if (diseases.Count > 0)
{
var removedDisease = diseases[RandomSolver.Next(diseases.Count)];
RevertQuirk(removedDisease.Quirk);
quirkData.Remove(removedDisease);
return(removedDisease.Quirk);
}
return(null);
}
private static void LoadRoomEnviroment(Dungeon dungeon, DungeonEnviromentData envData, int mashIndex)
{
foreach (var room in dungeon.Rooms.Values)
{
room.TextureId = envData.RoomVariations[Random.Range(0, envData.RoomVariations.Count)];
switch (room.Type)
{
case AreaType.Battle:
var monsterBattleSet = RandomSolver.ChooseByRandom(envData.BattleMashes.
Find(mash => mash.MashId == mashIndex).RoomEncounters).MonsterSet;
room.BattleEncounter = new BattleEncounter(monsterBattleSet);
break;
case AreaType.BattleCurio:
if (room.Prop == null)
{
string curioName = RandomSolver.ChooseByRandom(envData.RoomTresures).PropName;
room.Prop = DarkestDungeonManager.Data.Curios[curioName];
var monsterCurioSet = RandomSolver.ChooseByRandom(envData.BattleMashes.
Find(mash => mash.MashId == mashIndex).RoomEncounters).MonsterSet;
room.BattleEncounter = new BattleEncounter(monsterCurioSet);
}
break;
case AreaType.BattleTresure:
if (room.Prop == null)
{
string tresureName = RandomSolver.ChooseByRandom(envData.RoomTresures).PropName;
room.Prop = DarkestDungeonManager.Data.Curios[tresureName];
}
var monsterTreasureSet = RandomSolver.ChooseByRandom(envData.BattleMashes.Find(mash =>
mash.MashId == mashIndex).RoomEncounters).MonsterSet;
room.BattleEncounter = new BattleEncounter(monsterTreasureSet);
break;
case AreaType.Empty:
case AreaType.Entrance:
case AreaType.Curio:
case AreaType.Boss:
break;
default:
Assert.IsTrue(false, "Unexpected room type: " + room.Type);
break;
}
}
}
protected override bool ChooseTargets(List <FormationUnit> availableTargets, MonsterBrainDecision decision)
{
if (availableTargets.Count > 0)
{
decision.TargetInfo.Targets.Clear();
if (decision.SelectedSkill.TargetRanks.IsMultitarget)
{
decision.TargetInfo.Targets.AddRange(availableTargets);
return(true);
}
else
{
float lowestRes = float.MaxValue;
FormationUnit lowestResTarget = null;
foreach (var target in availableTargets)
{
if (target.Character[ResistanceType].ModifiedValue < lowestRes)
{
lowestRes = target.Character[ResistanceType].ModifiedValue;
lowestResTarget = target;
}
}
decision.TargetInfo.Targets.Add(lowestResTarget);
availableTargets.Remove(lowestResTarget);
if (decision.SelectedSkill.ExtraTargetsChance > 0 && availableTargets.Count > 0 &&
RandomSolver.CheckSuccess(decision.SelectedSkill.ExtraTargetsChance))
{
lowestRes = 500f;
lowestResTarget = null;
foreach (var target in availableTargets)
{
if (target.Character[ResistanceType].ModifiedValue < lowestRes)
{
lowestRes = target.Character[ResistanceType].ModifiedValue;
lowestResTarget = target;
}
}
if (lowestResTarget != null)
{
decision.TargetInfo.Targets.Add(lowestResTarget);
}
return(true);
}
return(true);
}
}
return(false);
}
public ISolution Solve()
{
AvailableResourceSolver availableResourceSolver = new AvailableResourceSolver(_problem);
availableResourceSolver.FindAvailableResources();
RandomSolver solver = new RandomSolver(_problem);
var solution = solver.Solve();
return(null);
}
