public DataDrivenMechanics(IBuilderFactories builderFactories, IModifierBuilder modifierBuilder)
: base(builderFactories)
{
_modifierBuilder = modifierBuilder;
_lazyGivenStats = new Lazy <IReadOnlyList <IIntermediateModifier> >(
() => CollectionToList(CreateCollection()));
}
public ItemParser(
BaseItemDefinitions baseItemDefinitions, IBuilderFactories builderFactories, ICoreParser coreParser,
IStatTranslator statTranslator)
{
_baseItemDefinitions = baseItemDefinitions;
_partialParsers = CreatePartialParsers(builderFactories, coreParser, statTranslator);
}
public JewelInSkillTreeParser(
PassiveTreeDefinition tree, IBuilderFactories builderFactories, ICoreParser coreParser)
{
_tree = tree;
_transformationParser = CompositeTransformationJewelParser.Create(
i => builderFactories.PassiveTreeBuilders.NodeEffectiveness(i).Value);
_coreParser = coreParser;
}
public ActiveSkillParser(
SkillDefinitions skillDefinitions, IBuilderFactories builderFactories,
UntranslatedStatParserFactory statParserFactory)
{
(_skillDefinitions, _builderFactories, _statParserFactory) =
(skillDefinitions, builderFactories, statParserFactory);
_partialParsers = CreatePartialParsers();
}
public GameStateDependentMods(
IBuilderFactories builderFactories, IModifierBuilder modifierBuilder, IMetaStatBuilders metaStatBuilders)
: base(builderFactories)
{
_modifierBuilder = modifierBuilder;
_stat = metaStatBuilders;
_lazyGivenStats = new Lazy <IReadOnlyList <IIntermediateModifier> >(() => CreateCollection().ToList());
}
protected LevelBasedStats(
IBuilderFactories builderFactories, IModifierBuilder modifierBuilder, MonsterBaseStats monsterBaseStats)
: base(builderFactories)
{
ModifierBuilder = modifierBuilder;
MonsterBaseStats = monsterBaseStats;
_lazyGivenStats = new Lazy <IReadOnlyList <IIntermediateModifier> >(() => CreateCollection().ToList());
}
private IParser <PartialItemParserParameter>[] CreatePartialParsers(
IBuilderFactories builderFactories, ICoreParser coreParser, IStatTranslator statTranslator)
=> new IParser <PartialItemParserParameter>[]
{
new ItemEquipmentParser(builderFactories),
new ItemPropertyParser(builderFactories),
new ItemModifierParser(builderFactories, coreParser, statTranslator),
};
public ModifierCollection(
IBuilderFactories builderFactories, ModifierSource.Local localModifierSource,
Entity modifierSourceEntity)
{
(_builderFactories, _localModifierSource, _modifierSourceEntity) =
(builderFactories, localModifierSource, modifierSourceEntity);
_globalModifierSource = new ModifierSource.Global(_localModifierSource);
}
public CharacterGivenStats(
IBuilderFactories builderFactories, IModifierBuilder modifierBuilder, CharacterBaseStats characterBaseStats)
: base(builderFactories)
{
_modifierBuilder = modifierBuilder;
_characterBaseStats = characterBaseStats;
_lazyGivenStats = new Lazy <IReadOnlyList <IIntermediateModifier> >(() => CreateCollection().ToList());
}
public GivenStatsCollection(
IBuilderFactories builderFactories,
CharacterBaseStats characterBaseStats, MonsterBaseStats monsterBaseStats)
{
_builderFactories = builderFactories;
_monsterBaseStats = monsterBaseStats;
_characterBaseStats = characterBaseStats;
_lazyCollection = new Lazy <IReadOnlyList <IGivenStats> >(() => CreateCollection(ModifierBuilder.Empty));
}
public ItemParser(
BaseItemDefinitions baseItemDefinitions, IBuilderFactories builderFactories, ICoreParser coreParser,
IStatTranslator statTranslator)
{
_baseItemDefinitions = baseItemDefinitions;
_builderFactories = builderFactories;
_coreParser = coreParser;
_statTranslator = statTranslator;
}
public static async Task <ComputationViewModel> CreateAsync(
GameData gameData, IBuilderFactories builderFactories,
ObservableCalculator observableCalculator, ComputationSchedulerProvider schedulers,
ObservableSet <IReadOnlyList <Skill> > skills)
{
var vm = new ComputationViewModel(observableCalculator, schedulers);
await vm.InitializeAsync(gameData, builderFactories, skills);
return(vm);
}
public static MainSkillSelectionViewModel Create(
SkillDefinitions skillDefinitions, IBuilderFactories builderFactories,
CalculationNodeViewModelFactory nodeFactory,
ObservableSet <IReadOnlyList <Skill> > skills)
{
var vm = new MainSkillSelectionViewModel(skillDefinitions, builderFactories, nodeFactory);
vm.Initialize(skills);
return(vm);
}
public AttributesInJewelRadiusViewModel(PassiveTreeDefinition tree, IBuilderFactories builders, ObservableCalculator calculator)
{
_tree = tree;
_builders = builders;
_calculator = calculator;
_strengthStatBuilder = new Lazy <IStatBuilder>(() => _builders.StatBuilders.Attribute.Strength);
_dexterityStatBuilder = new Lazy <IStatBuilder>(() => _builders.StatBuilders.Attribute.Dexterity);
_intelligenceStatBuilder = new Lazy <IStatBuilder>(() => _builders.StatBuilders.Attribute.Intelligence);
}
public AdditionalSkillStatParser(SkillDefinitions skillDefinitions, IBuilderFactories builderFactories)
{
_parsers = new IParser <AdditionalSkillStatParserParameter>[]
{
new AdditionalSkillLevelParser(skillDefinitions, builderFactories.StatBuilders.Gem, builderFactories.GemTagBuilders,
builderFactories.ValueBuilders, builderFactories.MetaStatBuilders, builderFactories.SkillBuilders),
new AdditionalSkillLevelMaximumParser(skillDefinitions, builderFactories.StatBuilders.Gem, builderFactories.ValueBuilders),
new AdditionalSkillQualityParser(skillDefinitions, builderFactories.StatBuilders.Gem,
builderFactories.ValueBuilders, builderFactories.MetaStatBuilders),
};
}
public ParsingData(
IBuilderFactories builderFactories, IMatchContexts matchContexts, IReferencedMatchers skillMatchers)
{
_builderFactories = builderFactories;
_matchContexts = matchContexts;
_statMatchers = new Lazy <IReadOnlyList <IStatMatchers> >(
() => CreateStatMatchers(new ModifierBuilder()));
_referencedMatchers = new Lazy <IReadOnlyList <IReferencedMatchers> >(
() => CreateReferencedMatchers(skillMatchers));
_statMatchersSelector = new Lazy <StatMatchersSelector>(
() => new StatMatchersSelector(StatMatchers));
}
private async Task InitializeFields(IEnumerable <SkillNode> skillNodes)
{
_gameData.PassiveNodes = skillNodes;
var computationFactory = new ComputationFactory(GameData);
var calculator = computationFactory.CreateCalculator();
_builderFactories = await computationFactory.CreateBuilderFactoriesAsync();
_parser = await computationFactory.CreateParserAsync();
_schedulers = new ComputationSchedulerProvider();
_observables = new ComputationObservables(_parser);
_calculator = new ObservableCalculator(calculator, _schedulers.CalculationThread);
}
private async Task InitializeAsync(
SkillDefinitions skillDefinitions, IBuilderFactories f, ObservableSet <IReadOnlyList <Skill> > skills)
{
MainSkillSelection = MainSkillSelectionViewModel.Create(skillDefinitions, f, _nodeFactory, skills);
InitializeOffensiveStats(f);
InitializeDefensiveStats(f);
ConfigurationStats = await ConfigurationStatsViewModel.CreateAsync(_observableCalculator, _nodeFactory);
AddConfigurationStat(f.StatBuilders.Level, Entity.Enemy);
GainOnActionStats = await GainOnActionStatsViewModel.CreateAsync(_observableCalculator, _nodeFactory);
SharedConfiguration = SharedConfigurationViewModel.Create(_nodeFactory, f);
}
private ParsingData(
IBuilderFactories builderFactories,
SkillDefinitions skills, PassiveTreeDefinition passives,
CharacterBaseStats characterBaseStats, MonsterBaseStats monsterBaseStats)
{
_builderFactories = builderFactories;
_statMatchers = new Lazy <IReadOnlyList <IStatMatchers> >(
() => CreateStatMatchers(ModifierBuilder.Empty, passives.Nodes));
_referencedMatchers = new Lazy <IReadOnlyList <IReferencedMatchers> >(
() => CreateReferencedMatchers(skills.Skills));
_givenStats = new Lazy <IReadOnlyList <IGivenStats> >(
() => new GivenStatsCollection(builderFactories, characterBaseStats, monsterBaseStats));
_statMatchersSelector = new Lazy <StatMatchersSelector>(
() => new StatMatchersSelector(StatMatchers));
}
public static async Task ClassInit()
{
_builderFactories = await BuilderFactoriesTask.ConfigureAwait(false);
_metaStats = _builderFactories.MetaStatBuilders;
var parser = await ParserTask.ConfigureAwait(false);
var modSource = new ModifierSource.Global();
_givenMods = parser.ParseGivenModifiers()
.Append(
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Damage.Taken
.For(_builderFactories.EntityBuilders.Enemy)),
Form.Increase, new Constant(20), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Resistance
.For(_builderFactories.EntityBuilders.Enemy)),
Form.BaseSet, new Constant(60), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.DamageMultiplier),
Form.BaseAdd, new Constant(75), modSource),
new Modifier(
Build(_builderFactories.StatBuilders.Level),
Form.BaseSet, new Constant(90), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Damage.WithSkills),
Form.BaseSet, new Constant(5), modSource),
new Modifier(
Build(_builderFactories.StatBuilders.Accuracy),
Form.BaseAdd, new Constant(1000), modSource),
new Modifier(
Build(_metaStats.SkillHitDamageSource),
Form.BaseSet, new Constant((int)DamageSource.Attack), modSource),
new Modifier(
Build(_metaStats.SkillUsesHand(AttackDamageHand.MainHand)),
Form.BaseSet, new Constant(true), modSource),
new Modifier(
Build(_metaStats.SkillUsesHand(AttackDamageHand.OffHand)),
Form.BaseSet, new Constant(true), modSource),
new Modifier(
Build(_builderFactories.EquipmentBuilders.Equipment[ItemSlot.MainHand].ItemTags),
Form.TotalOverride, new Constant(Tags.Sword.EncodeAsDouble()), modSource))
.ToList();
}
private Parser(
PassiveTreeDefinition passiveTree, BaseItemDefinitions baseItems, SkillDefinitions skills,
StatTranslators statTranslators, IBuilderFactories builderFactories, IParsingData <TStep> parsingData)
{
_statTranslators = statTranslators;
_coreParser = new CoreParser <TStep>(parsingData, builderFactories);
_givenStats = parsingData.GivenStats;
_passiveNodeParser = Caching(new PassiveNodeParser(passiveTree, builderFactories, _coreParser));
_skilledPassiveNodeParser = Caching(new SkilledPassiveNodeParser(passiveTree, builderFactories));
_itemParser = Caching(new ItemParser(baseItems, builderFactories, _coreParser,
statTranslators[StatTranslationFileNames.Main]));
_activeSkillParser =
Caching(new ActiveSkillParser(skills, builderFactories, GetOrAddUntranslatedStatParser));
_supportSkillParser =
Caching(new SupportSkillParser(skills, builderFactories, GetOrAddUntranslatedStatParser));
_skillsParser = new SkillsParser(skills, _activeSkillParser, _supportSkillParser);
}
public static void ClassInit()
{
var compRoot = new CompositionRoot();
_builderFactories = compRoot.BuilderFactories;
_metaStats = compRoot.MetaStats;
var modSource = new ModifierSource.Global();
_givenMods = GivenStatsParser.Parse(compRoot.Parser, compRoot.GivenStats.Result)
.Append(
new Modifier(
Build(_builderFactories.StatBuilders.Level.For(_builderFactories.EntityBuilders.Enemy)),
Form.BaseSet, new Constant(84), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Damage.Taken
.For(_builderFactories.EntityBuilders.Enemy)),
Form.Increase, new Constant(20), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Resistance
.For(_builderFactories.EntityBuilders.Enemy)),
Form.BaseSet, new Constant(60), modSource),
new Modifier(
Build(_builderFactories.StatBuilders.Level),
Form.BaseSet, new Constant(90), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Damage.WithSkills),
Form.BaseSet, new Constant(5), modSource),
new Modifier(
Build(_builderFactories.StatBuilders.Accuracy),
Form.BaseAdd, new Constant(1000), modSource),
new Modifier(
Build(_metaStats.SkillHitDamageSource),
Form.BaseSet, new Constant((int)DamageSource.Attack), modSource),
new Modifier(
Build(_metaStats.SkillUsesHand(AttackDamageHand.MainHand)),
Form.BaseSet, new Constant(true), modSource),
new Modifier(
Build(_metaStats.SkillUsesHand(AttackDamageHand.OffHand)),
Form.BaseSet, new Constant(true), modSource),
new Modifier(
Build(_builderFactories.EquipmentBuilders.Equipment[ItemSlot.MainHand].ItemTags),
Form.TotalOverride, new Constant((int)Tags.Sword), modSource))
.ToList();
}
private MainSkillSelectionViewModel(
SkillDefinitions skillDefinitions, IBuilderFactories builderFactories,
CalculationNodeViewModelFactory nodeFactory)
{
_skillDefinitions = skillDefinitions;
var selectedSkillItemSlotStat = builderFactories.MetaStatBuilders.MainSkillItemSlot
.BuildToStats(Entity.Character).Single();
_selectedSkillItemSlot = nodeFactory.CreateConfiguration(selectedSkillItemSlotStat, new NodeValue(0));
var selectedSkillSocketIndexStat = builderFactories.MetaStatBuilders.MainSkillSocketIndex
.BuildToStats(Entity.Character).Single();
_selectedSkillSocketIndex = nodeFactory.CreateConfiguration(selectedSkillSocketIndexStat, new NodeValue(0));
var selectedSkillPartStat = builderFactories.StatBuilders.MainSkillPart
.BuildToStats(Entity.Character).Single();
_selectedSkillPart = nodeFactory.CreateConfiguration(selectedSkillPartStat, new NodeValue(0));
ConfigurationNodes = new[] { _selectedSkillItemSlot, _selectedSkillSocketIndex, _selectedSkillPart };
}
private async Task InitializeAsync(
GameData gameData, IBuilderFactories f, ObservableSet <IReadOnlyList <Skill> > skills)
{
MainSkillSelection = MainSkillSelectionViewModel.Create(await gameData.Skills, f, _nodeFactory, skills);
InitializeOffensiveStats(f);
InitializeDefensiveStats(f);
ConfigurationStats = await ConfigurationStatsViewModel.CreateAsync(_observableCalculator, _nodeFactory);
AddConfigurationStat(f.StatBuilders.Level, Entity.Enemy);
GainOnActionStats = await GainOnActionStatsViewModel.CreateAsync(_observableCalculator, _nodeFactory);
SharedConfiguration = SharedConfigurationViewModel.Create(_nodeFactory, f);
IndependentResultStats = await IndependentResultStatsViewModel.CreateAsync(_observableCalculator, _nodeFactory);
PassiveTreeConnections = await PassiveTreeConnectionsViewModel.CreateAsync(_observableCalculator, _nodeFactory);
AttributesInJewelRadius = new AttributesInJewelRadiusViewModel(await gameData.PassiveTree, f, _observableCalculator);
}
public AllyLevelBasedStats(
IBuilderFactories builderFactories, IModifierBuilder modifierBuilder, MonsterBaseStats monsterBaseStats)
: base(builderFactories, modifierBuilder, monsterBaseStats)
{
}
public CharacterMechanics(IBuilderFactories builderFactories, IModifierBuilder modifierBuilder)
: base(builderFactories, modifierBuilder)
{
_lazyGivenStats = new Lazy <IReadOnlyList <IIntermediateModifier> >(
() => CreateCollection().ToList());
}
public GeneralStatMatchers(IBuilderFactories builderFactories, IModifierBuilder modifierBuilder)
: base(builderFactories)
{
_modifierBuilder = modifierBuilder;
}
public FormAndStatMatchers(IBuilderFactories builderFactories, IModifierBuilder modifierBuilder)
: base(builderFactories)
{
_modifierBuilder = modifierBuilder;
}
public ItemEquipmentParser(IBuilderFactories builderFactories) => _builderFactories = builderFactories;
public CoreParser(IParsingData <TStep> parsingData, IBuilderFactories builderFactories)
{
_parsingData = parsingData;
_builderFactories = builderFactories;
_parser = new Lazy <Parser>(CreateParser);
}
