public bool Execute(Equipment item, AffixManager affixManager)
{
if (item.Corrupted || item.Rarity != EquipmentRarity.Rare)
{
return(false);
}
int fourMod = 8;
int fiveMod = 3;
int sixMod = 1;
var sum = fourMod + fiveMod + sixMod;
var roll = Random.Next(sum);
int modCount = roll < fourMod ? 4 :
roll < fourMod + fiveMod ? 5 :
6;
item.Stats.Clear();
var mod = _essence.ItemClassToMod[item.ItemBase.ItemClass];
StatFactory.AffixToStat(Random, item, mod);
for (int i = 1; i < modCount; i++)
{
StatFactory.AddExplicit(Random, item, affixManager);
}
return(true);
}
private static AdditionalSkillLevelParser CreateSut(bool isSpell = false, Dictionary <int, SkillLevelDefinition>?supportLevelDefinitions = null)
{
supportLevelDefinitions ??= new Dictionary <int, SkillLevelDefinition>();
var skillDefinitions = new SkillDefinitions(new[]
{
SkillDefinition.CreateActive("a", 0, "", "b", Array.Empty <string>(),
new SkillBaseItemDefinition("a", "a", ReleaseState.Released, new[] { "g1", "g2", isSpell ? "spell" : "attack" }),
CreateActiveSkillDefinition("a"), new Dictionary <int, SkillLevelDefinition>()),
SkillDefinition.CreateActive("b", 1, "", null, Array.Empty <string>(),
null, CreateActiveSkillDefinition("b"), new Dictionary <int, SkillLevelDefinition>()),
SkillDefinition.CreateSupport("s1", 2, "", "s2", Array.Empty <string>(),
new SkillBaseItemDefinition("s1", "s1", ReleaseState.Released, new[] { "g2", "g3" }),
CreateSupportSkillDefinition(), supportLevelDefinitions),
SkillDefinition.CreateSupport("s2", 3, "", null, Array.Empty <string>(),
null, CreateSupportSkillDefinition(), supportLevelDefinitions),
SkillDefinition.CreateSupport("s3", 4, "", null, Array.Empty <string>(),
null, CreateSupportSkillDefinition(), supportLevelDefinitions),
});
var statFactory = new StatFactory();
return(new AdditionalSkillLevelParser(skillDefinitions,
new GemStatBuilders(statFactory),
new GemTagBuilders(),
new ValueBuilders(),
new MetaStatBuilders(statFactory),
new SkillBuilders(statFactory, skillDefinitions)));
}
public IStatBuilder AdditionalLevels(ISkillBuilder skill)
{
var coreBuilder = new CoreStatBuilderFromCoreBuilder <string>(
CoreBuilder.Proxy(skill, (ps, b) => b.Build(ps).Id),
(e, t) => StatFactory.FromIdentity($"Gem.AdditionalLevels.{t}", e, typeof(int)));
return(new StatBuilder(StatFactory, coreBuilder));
}
private IStatBuilder AdditionalLevels(string identityInfix, IGemTagBuilder gemTag, Func <BuildParameters, string, string> buildIdentitySuffix)
{
var coreBuilder = new CoreStatBuilderFromCoreBuilder <string>(
CoreBuilder.Proxy(gemTag, (ps, b) => buildIdentitySuffix(ps, b.Build(ps))),
(e, t) => StatFactory.FromIdentity($"Gem.AdditionalLevels{identityInfix}.{t}", e, typeof(int)));
return(new StatBuilder(StatFactory, coreBuilder));
}
public IStatBuilder DamageHasKeyword(DamageSource damageSource, IKeywordBuilder keyword)
{
var coreBuilder = new CoreStatBuilderFromCoreBuilder <Keyword>(
CoreBuilder.Proxy(keyword, (ps, b) => b.Build(ps)),
(e, k) => StatFactory.MainSkillPartDamageHasKeyword(e, k, damageSource));
return(new StatBuilder(StatFactory, coreBuilder));
}
public Action <Equipment, AffixManager, CurrencyModifiers> RerollExplicits()
{
return((item, affixManager, currencyModifier) => {
foreach (var stat in item.Stats)
{
StatFactory.Reroll(_random, item, stat, currencyModifier);
}
});
}
public Action <Equipment, AffixManager, CurrencyModifiers> AddExplicitByItemClass(Dictionary <string, Affix> explicitsByItemClass)
{
return((item, affixManager, currencyModifier) => {
if (explicitsByItemClass.ContainsKey(item.ItemBase.ItemClass))
{
StatFactory.AddExplicit(_random, item, explicitsByItemClass[item.ItemBase.ItemClass]);
}
});
}
private IEnumerable <IStat> ConvertStat(BuildParameters parameters, ICoreBuilder <string> identity, IStat stat)
{
var builtIdentity = identity.Build(parameters);
return(from e in Entity.Build(stat.Entity)
let i = $"On({builtIdentity}).By({e})"
let registrationType = GainOnAction(stat, builtIdentity, e)
select StatFactory.CopyWithSuffix(stat, i, stat.DataType, registrationType));
}
public CoreStatBuilderFromCoreBuilder(
ICoreBuilder <T> coreBuilder,
StatFactory statFactory,
IEntityBuilder entityBuilder = null)
{
_coreBuilder = coreBuilder;
_statFactory = statFactory;
_entityBuilder = entityBuilder ?? new ModifierSourceEntityBuilder();
}
public bool Execute(Equipment item, AffixManager affixManager)
{
if (item.Corrupted || item.Rarity != EquipmentRarity.Rare)
{
return(false);
}
var corruptedEssenceChance = Fossils.Max(x => x.CorruptedEssenceChance);
bool addCorruptedEssence = false;
if (corruptedEssenceChance == 100)
{
addCorruptedEssence = true;
}
else if (corruptedEssenceChance > 0)
{
var chance = Random.Next(100);
if (chance >= corruptedEssenceChance)
{
addCorruptedEssence = true;
}
}
int addedAffixes = 0;
if (addCorruptedEssence)
{
var essence = _corruptionOnlyEssences[Random.Next(_corruptionOnlyEssences.Count)];
StatFactory.AddExplicit(Random, item, essence.ItemClassToMod[item.ItemBase.ItemClass]);
addedAffixes = 1;
}
int fourMod = 8;
int fiveMod = 3;
int sixMod = 1;
var sum = fourMod + fiveMod + sixMod;
var roll = Random.Next(sum);
int modCount = roll < fourMod ? 4 :
roll < fourMod + fiveMod ? 5 :
6;
item.Stats.Clear();
for (int i = addedAffixes; i < modCount; i++)
{
StatFactory.AddExplicit(Random, item, affixManager, Fossils);
}
return(true);
}
void GiveStats()
{
Debug.Log("Give!");
StatFactory sf = gameObject.GetComponent <StatFactory>();
if (sf)
{
m_Char.GiveStats(sf.Get());
}
m_Char.m_Events.MissingStats = false;
}
public bool Execute(Equipment item, AffixManager affixManager)
{
if (item.Corrupted || item.Rarity != EquipmentRarity.Magic || item.Prefixes.Count + item.Suffixes.Count != 1)
{
return(false);
}
StatFactory.AddExplicit(Random, item, affixManager);
return(true);
}
public bool Execute(Equipment item, AffixManager affixManager)
{
if (item.Corrupted || item.Rarity == EquipmentRarity.Normal || item.Rarity == EquipmentRarity.Unique || item.Stats.Count == 0)
{
return(false);
}
StatFactory.RemoveExplicit(_random, item);
return(true);
}
void GiveDMG()
{
Debug.Log("Give! DMG");
DamageAble dmg = gameObject.GetComponent <DamageAble>();
StatFactory sf = gameObject.GetComponent <StatFactory>();
dmg.m_Stats = sf.Get();
m_Char.m_damage = dmg;
m_Char.m_Events.MissingDamageComponent = false;
}
public void SetUp()
{
_sut = Calculator.CreateCalculator();
_bar = new Stat("Bar");
_foo = new Stat("Foo");
var statFactory = new StatFactory();
_barFooConversion = statFactory.ConvertTo(_bar, _foo);
_barFooGain = statFactory.GainAs(_bar, _foo);
_barConversion = statFactory.Conversion(_bar);
_barSkillConversion = statFactory.SkillConversion(_bar);
}
private static AdditionalSkillLevelMaximumParser CreateSut(IEnumerable <int> activeLevels, IEnumerable <int> supportLevels)
{
var skillDefinitions = new SkillDefinitions(new[]
{
CreateActive("a", CreateActiveSkillDefinition("a"), activeLevels.ToDictionary(l => l, _ => CreateLevelDefinition())),
CreateSupport("s", CreateSupportSkillDefinition(), supportLevels.ToDictionary(l => l, _ => CreateLevelDefinition())),
});
var statFactory = new StatFactory();
return(new AdditionalSkillLevelMaximumParser(skillDefinitions,
new GemStatBuilders(statFactory),
new ValueBuilders()));
}
public bool Execute(Equipment item, AffixManager affixManager)
{
if (item.Corrupted || item.Rarity != EquipmentRarity.Magic)
{
return(false);
}
item.Rarity = EquipmentRarity.Rare;
StatFactory.AddExplicit(Random, item, affixManager);
return(true);
}
public Action <Equipment, AffixManager, CurrencyModifiers> AddExplicits(DistributionOptions distributionOptions)
{
return((item, affixManager, currencyModifier) => {
switch (distributionOptions)
{
case DistributionOptions.MagicDistribution:
StatFactory.AddExplicits(_random, item, affixManager, StatFactory.MagicAffixCountOdds, currencyModifier);
break;
case DistributionOptions.RareDistribution:
StatFactory.AddExplicits(_random, item, affixManager, StatFactory.RareAffixCountOdds, currencyModifier);
break;
}
});
}
/// <summary>
/// compute the similarity of case base's cases and problem case
///
/// </summary>
/// <param name="cases"></param>
/// <param name="problem"></param>
/// <returns></returns>
public ArrayList ComputeSimilarity(ArrayList cases, Case problem)
{
if (_env == null)
{
throw new ContextException("environment variable is not set");
}
ICBRContext ctx = CBRContextManager.GetCBRContext(_env);
if (ctx == null)
{
throw new ContextException("not set context");
}
ISimilarity sim = (ISimilarity)ctx.GetSimilarity();
if (sim == null)
{
throw new ContextException("similarity method is not set");
}
ArrayList stats = new ArrayList();
double similarityThrehold = ctx.GetSimilarityThrehold();
for (int i = 0; i < cases.Count; i++)
{
Case solution = (Case)cases[i];
double similarity = sim.Compare(problem, solution);
//continue if the similarity by comparing is lower than the
//similarity threhold in context setting
if (similarity < similarityThrehold)
{
continue;
}
IStat s = StatFactory.newInstance();
s.SetCBRCase(solution);
s.SetCaseSimilarity(similarity);
//bi-sort similarity
if (stats.Count <= 0)
{
stats.Add(s);
continue;
}
SortSimilarity(stats, s);
}
return(stats);
}
public void Init()
{
try
{
m_Char.Init(gameObject, m_Image, 1, new SM_Defend(), gameObject.GetComponent <DamageAble>(), m_attLog);
}
catch (Exception) { }
StatFactory sf = gameObject.GetComponent <StatFactory>();
if (sf)
{
m_Char.GiveStats(sf.Get());
}
Run = true;
}
public bool Execute(Equipment item, AffixManager affixManager)
{
if (Random == null)
{
throw new InvalidOperationException("The random number generator is uninitialized");
}
if (item.Corrupted || item.Implicit == null)
{
return(false);
}
StatFactory.Reroll(Random, item, item.Implicit);
return(true);
}
public bool Execute(Equipment item, AffixManager affixManager)
{
if (item.Corrupted || item.Rarity == EquipmentRarity.Normal || item.Rarity == EquipmentRarity.Unique)
{
return(false);
}
StatFactory.RemoveAllExplicits(item);
if (!item.Stats.Any())
{
item.Rarity = EquipmentRarity.Normal;
}
return(true);
}
private IValue BuildTargetPoolValue(BuildParameters parameters, IStat targetPoolStat)
{
var entity = parameters.ModifierSourceEntity;
var targetPoolValue = new StatValue(targetPoolStat);
return(new FunctionalValue(
c => c.GetValue(TargetPoolValueStat(targetPoolValue.Calculate(c))),
$"Value of Pool {targetPoolValue}"));
IStat TargetPoolValueStat(NodeValue?targetPool)
{
var targetPoolString = ((Pool)targetPool.Single()).ToString();
return(StatFactory.FromIdentity(targetPoolString, entity, typeof(uint)));
}
}
public bool Execute(Equipment item, AffixManager affixManager)
{
if (Random == null)
{
throw new InvalidOperationException("The random number generator is uninitialized");
}
if (item.Corrupted || item.Rarity != EquipmentRarity.Rare || (item.Prefixes.Count >= 3 && item.Suffixes.Count >= 3))
{
return(false);
}
StatFactory.AddExplicit(Random, item, affixManager);
return(true);
}
public Action <Equipment, AffixManager, CurrencyModifiers> ResetItem()
{
return((item, affixManager, currencyModifier) =>
{
item.Influence.Clear();
item.Implicits.Clear();
item.Rarity = EquipmentRarity.Normal;
item.Quality = 0;
item.QualityType = QualityType.Default;
item.Stats.Clear();
item.Destroyed = false;
item.Completed = false;
item.Corrupted = false;
item.ItemBase.Implicits.ForEach(x => StatFactory.AddImplicit(_random, item, x));
});
}
void SpawnEnemy(int i, int j)
{
if (Random.Range(0f, 1f) < m_EnemySpawnrate)
{
Vector3 pos = m_Rooms[i, j].transform.position;
GameObject NE = Instantiate(m_Enemy, transform.parent);
Enemy E = NE.GetComponent <Enemy>();
E.m_attLog = m_log;
E.m_Target = m_Player;
NE.transform.position = pos;
StatFactory SF = NE.GetComponent <StatFactory>();
SF.MakeRandom(150, 25, 10, 25, 25, 25, 25, 25, 1);
E.Init();
}
}
public bool Execute(Equipment item, AffixManager affixManager)
{
if (item.Corrupted || item.Rarity != EquipmentRarity.Magic)
{
return(false);
}
item.Stats.Clear();
int affixCount = Random.Next(2) + 1;
for (int i = 0; i < affixCount; i++)
{
StatFactory.AddExplicit(Random, item, affixManager);
}
return(true);
}
private static AdditionalSkillQualityParser CreateSut(Dictionary <int, SkillLevelDefinition>?supportLevelDefinitions = null)
{
supportLevelDefinitions ??= new Dictionary <int, SkillLevelDefinition>();
var skillDefinitions = new SkillDefinitions(new[]
{
SkillDefinition.CreateActive("a", 0, "", null, Array.Empty <string>(),
new SkillBaseItemDefinition("a", "a", ReleaseState.Released, Array.Empty <string>()),
CreateActiveSkillDefinition("a"), new Dictionary <int, SkillLevelDefinition>()),
SkillDefinition.CreateSupport("s1", 2, "", null, Array.Empty <string>(),
new SkillBaseItemDefinition("s1", "s1", ReleaseState.Released, Array.Empty <string>()),
CreateSupportSkillDefinition(), supportLevelDefinitions),
});
var statFactory = new StatFactory();
return(new AdditionalSkillQualityParser(skillDefinitions,
new GemStatBuilders(statFactory),
new ValueBuilders(),
new MetaStatBuilders(statFactory)));
}
public bool Execute(Equipment item, AffixManager affixManager)
{
if (Random == null)
{
throw new InvalidOperationException("The random number generator is uninitialized");
}
if (item.Corrupted || item.Rarity == EquipmentRarity.Normal)
{
return(false);
}
foreach (var stat in item.Stats)
{
StatFactory.Reroll(Random, item, stat);
}
return(true);
}
// Class
// Subclass
public Unit(string Name = "Unit", double GrowthRate = .25)
{
name = Name;
growthRate = GrowthRate;
experience = 0;
StatFactory sf = new StatFactory();
Health = sf.GetStat(StatType.Health, 0, 99);
Stamina = sf.GetStat(StatType.Stamina, 0, 99);
Strength = sf.GetStat(StatType.Strength);
Skill = sf.GetStat(StatType.Skill);
Endurance = sf.GetStat(StatType.Endurance);
Magic = sf.GetStat(StatType.Magic);
Defense = sf.GetStat(StatType.Defense);
Resistance = sf.GetStat(StatType.Resistance);
Luck = sf.GetStat(StatType.Luck);
Speed = sf.GetStat(StatType.Speed);
Movement = sf.GetStat(StatType.Movement, 4, 8);
}
