860942864

Build Type

github

Committed by GitHub

Commit Message

Merge aaeef5925 into 62f27c124

Pull Request Pull Request #1107: renamed: IEffectsModule to IConditionModule, EffectsModule to Conditi…

Run Details

2332 of 3682 branches covered (63.34%)

Branch coverage included in aggregate %.

46 of 52 new or added lines in 8 files covered. (88.46%)

12 existing lines in 5 files now uncovered.

6191 of 8016 relevant lines covered (77.23%)

167765.29 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.57

/Zilon.Core/Zilon.Core/PersonGeneration/FullPersonFactoryBase.cs

﻿using System;
using System.Collections.Generic;
using System.Linq;

using Zilon.Core.CommonServices.Dices;
using Zilon.Core.PersonModules;
using Zilon.Core.Persons;
using Zilon.Core.Props;
using Zilon.Core.Schemes;
using Zilon.Core.Scoring;
using Zilon.Core.Tactics;

namespace Zilon.Core.PersonGeneration
{
    public abstract class FullPersonFactoryBase : IPersonFactory
    {
        private readonly IPersonPerkInitializator _personPerkInitializator;
        private readonly IPropFactory _propFactory;
        private readonly ISurvivalRandomSource _survivalRandomSource;

        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        protected FullPersonFactoryBase(
            ISchemeService schemeService,
            ISurvivalRandomSource survivalRandomSource,
            IPropFactory propFactory,
            IDropResolver dropResolver,
            IPersonPerkInitializator personPerkInitializator,
            IDice dice)
        {
            SchemeService = schemeService ?? throw new ArgumentNullException(nameof(schemeService));
            _survivalRandomSource =
                survivalRandomSource ?? throw new ArgumentNullException(nameof(survivalRandomSource));
            _propFactory = propFactory ?? throw new ArgumentNullException(nameof(propFactory));
            DropResolver = dropResolver ?? throw new ArgumentNullException(nameof(dropResolver));
            _personPerkInitializator = personPerkInitializator ??
                                       throw new ArgumentNullException(nameof(personPerkInitializator));
            Dice = dice ?? throw new ArgumentNullException(nameof(dice));
        }

        public IPlayerEventLogService? PlayerEventLogService { get; set; }

        protected static int BodySlotIndex => 1;

        protected IDice Dice { get; }

        protected IDropResolver DropResolver { get; }

        protected static int HeadSlotIndex => 0;

        protected static int MainHandSlotIndex => 2;

        protected static int OffHandSlotIndex => 3;

        protected ISchemeService SchemeService { get; }

        protected void AddDefaultProps(IInventoryModule inventory)
        {
            AddResource(inventory, "packed-food", 1);
            AddResource(inventory, "water-bottle", 1);
            AddResource(inventory, "med-kit", 1);
        }

        protected static void AddEquipment(IEquipmentModule equipmentModule, int slotIndex, Equipment equipment)
        {
            if (equipmentModule is null)
            {
                throw new ArgumentNullException(nameof(equipmentModule));
            }

            equipmentModule[slotIndex] = equipment;
        }

        protected void AddEquipment(IInventoryModule inventory, string sid)
        {
            var scheme = SchemeService.GetScheme<IPropScheme>(sid);
            var prop = _propFactory.CreateEquipment(scheme);
            AddPropToInventory(inventory, prop);
        }

        protected static void AddPropToInventory(IPropStore inventory, IProp prop)
        {
            if (inventory is null)
            {
                throw new ArgumentNullException(nameof(inventory));
            }

            inventory.Add(prop);
        }

        protected void AddResource(IInventoryModule inventory, string resourceSid, int count)
        {
            if (inventory is null)
            {
                throw new ArgumentNullException(nameof(inventory));
            }

            try
            {
                var resourceScheme = SchemeService.GetScheme<IPropScheme>(resourceSid);
                var resource = _propFactory.CreateResource(resourceScheme, count);
                inventory.Add(resource);
            }
            catch (KeyNotFoundException exception)
            {
                throw new CreatePersonException($"Не найден объект {resourceSid}", exception);
            }
        }

        protected void FillSlot(HumanPerson person, IDropTableScheme? dropScheme, int slotIndex)
        {
            if (dropScheme is null)
            {
                return;
            }

            // Генерируем предметы.
            // Выбираем предмет, как экипировку в слот.
            // Если он может быть экипирован, то устанавливаем в слот.
            // Остальные дропнутые предметы складываем просто в инвентарь.
            // Если текущий предмет невозможно экипировать, то его тоже помещаем в инвентарь.

            var inventory = person.GetModule<IInventoryModule>();
            var dropedProps = DropResolver.Resolve(new[] { dropScheme });
            var usedEquipment = dropedProps.OfType<Equipment>().FirstOrDefault();
            if (usedEquipment != null)
            {
                var equipmentModule = person.GetModule<IEquipmentModule>();
                var canBeEquiped = CanBeEquiped(equipmentModule, slotIndex, usedEquipment);
                if (canBeEquiped)
                {
                    AddEquipment(equipmentModule, slotIndex, usedEquipment);
                    var unusedMainWeaponDrops = dropedProps.Where(x => x != usedEquipment).ToArray();
                    foreach (var prop in unusedMainWeaponDrops)
                    {
                        AddPropToInventory(inventory, prop);
                    }
                }
                else
                {
                    foreach (var prop in dropedProps)
                    {
                        AddPropToInventory(inventory, prop);
                    }
                }
            }
            else
            {
                foreach (var prop in dropedProps)
                {
                    AddPropToInventory(inventory, prop);
                }
            }
        }

        protected abstract void RollStartEquipment(IInventoryModule inventory, HumanPerson person);

        private static bool CanBeEquiped(
            IEquipmentModule equipmentModule,
            int slotIndex,
            Equipment equipment)
        {
            return EquipmentCarrierHelper.CanBeEquiped(equipmentModule, slotIndex, equipment);
        }

        private IAttributesModule RollAndAddPersonAttributesToPerson(IPerson person)
        {
            var attributes = new[]
            {
                RollAttribute(PersonAttributeType.PhysicalStrength),
                RollAttribute(PersonAttributeType.Dexterity),
                RollAttribute(PersonAttributeType.Perception),
                RollAttribute(PersonAttributeType.Constitution)
            };

            var attributesModule = new AttributesModule(attributes);

            person.AddModule(attributesModule);

            return attributesModule;
        }

        private PersonAttribute RollAttribute(PersonAttributeType attributeType)
        {
            var value = 10 + Dice.Roll(-4, 4);
            return new PersonAttribute(attributeType, value);
        }

        private void RollTraitPerks(IEvolutionModule evolutionData)
        {
            if (evolutionData is null)
            {
                throw new ArgumentNullException(nameof(evolutionData));
            }

            var rolledTraits = _personPerkInitializator.Generate();
            evolutionData.AddBuildInPerks(rolledTraits);
        }

        public IPerson Create(string personSchemeSid, IFraction fraction)
        {
            var personScheme = SchemeService.GetScheme<IPersonScheme>(personSchemeSid);

            var person = new HumanPerson(personScheme, fraction);

            var attributeModule = RollAndAddPersonAttributesToPerson(person);

            var movingModule = new MovingModule(attributeModule);
            person.AddModule(movingModule);

            var inventoryModule = new InventoryModule();
            person.AddModule(inventoryModule);

            var notNullSlots = personScheme.Slots.Select(x => x!).ToArray();
            var equipmentModule = new EquipmentModule(notNullSlots);
            person.AddModule(equipmentModule);

            var effectsModule = new ConditionModule();
            person.AddModule(effectsModule);

            var evolutionModule = new EvolutionModule(SchemeService);
            person.AddModule(evolutionModule);
            RollTraitPerks(evolutionModule);

            var survivalModule = new HumanSurvivalModule(personScheme, _survivalRandomSource, attributeModule,
                effectsModule, evolutionModule, equipmentModule)
            {
                PlayerEventLogService = PlayerEventLogService
            };
            person.AddModule(survivalModule);

            RollStartEquipment(inventoryModule, person);

            if (person.Scheme.DefaultAct is null)
            {
                throw new InvalidOperationException();
            }

            var defaultActScheme = SchemeService.GetScheme<ITacticalActScheme>(person.Scheme.DefaultAct);
            var combatActModule = new CombatActModule(
                defaultActScheme,
                equipmentModule,
                effectsModule,
                evolutionModule);

            person.AddModule(combatActModule);

            var combatStatsModule = new CombatStatsModule(evolutionModule, equipmentModule);
            person.AddModule(combatStatsModule);

            var diseaseModule = new DiseaseModule(effectsModule);
            person.AddModule(diseaseModule);

            var fowModule = new FowData();
            person.AddModule(fowModule);

            person.PlayerEventLogService = PlayerEventLogService;

            return person;
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4
5	using Zilon.Core.CommonServices.Dices;
6	using Zilon.Core.PersonModules;
7	using Zilon.Core.Persons;
8	using Zilon.Core.Props;
9	using Zilon.Core.Schemes;
10	using Zilon.Core.Scoring;
11	using Zilon.Core.Tactics;
12
13	namespace Zilon.Core.PersonGeneration
14	{
15	public abstract class FullPersonFactoryBase : IPersonFactory
16	{
17	private readonly IPersonPerkInitializator _personPerkInitializator;
18	private readonly IPropFactory _propFactory;
19	private readonly ISurvivalRandomSource _survivalRandomSource;
20
21	[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
22	protected FullPersonFactoryBase(
23	ISchemeService schemeService,
24	ISurvivalRandomSource survivalRandomSource,
25	IPropFactory propFactory,
26	IDropResolver dropResolver,
27	IPersonPerkInitializator personPerkInitializator,
28	IDice dice)
29	{
30	SchemeService = schemeService ?? throw new ArgumentNullException(nameof(schemeService));
31	_survivalRandomSource =
32	survivalRandomSource ?? throw new ArgumentNullException(nameof(survivalRandomSource));
33	_propFactory = propFactory ?? throw new ArgumentNullException(nameof(propFactory));
34	DropResolver = dropResolver ?? throw new ArgumentNullException(nameof(dropResolver));
35	_personPerkInitializator = personPerkInitializator ??
36	throw new ArgumentNullException(nameof(personPerkInitializator));
37	Dice = dice ?? throw new ArgumentNullException(nameof(dice));
38	}
39
40	public IPlayerEventLogService? PlayerEventLogService { get; set; }
41
42	protected static int BodySlotIndex => 1;	4✔
43
44	protected IDice Dice { get; }
45
46	protected IDropResolver DropResolver { get; }
47
48	protected static int HeadSlotIndex => 0;	4✔
49
50	protected static int MainHandSlotIndex => 2;	4✔
51
52	protected static int OffHandSlotIndex => 3;	4✔
53
54	protected ISchemeService SchemeService { get; }
55
56	protected void AddDefaultProps(IInventoryModule inventory)
57	{
58	AddResource(inventory, "packed-food", 1);	4✔
59	AddResource(inventory, "water-bottle", 1);	4✔
60	AddResource(inventory, "med-kit", 1);	4✔
61	}	4✔
62
63	protected static void AddEquipment(IEquipmentModule equipmentModule, int slotIndex, Equipment equipment)
64	{
65	if (equipmentModule is null)	8!
66	{
67	throw new ArgumentNullException(nameof(equipmentModule));	×
68	}
69
70	equipmentModule[slotIndex] = equipment;	8✔
71	}	8✔
72
73	protected void AddEquipment(IInventoryModule inventory, string sid)
74	{
75	var scheme = SchemeService.GetScheme<IPropScheme>(sid);	×
76	var prop = _propFactory.CreateEquipment(scheme);	×
77	AddPropToInventory(inventory, prop);	×
78	}	×
79
80	protected static void AddPropToInventory(IPropStore inventory, IProp prop)
81	{
82	if (inventory is null)	3!
83	{
84	throw new ArgumentNullException(nameof(inventory));	×
85	}
86
87	inventory.Add(prop);	3✔
88	}	3✔
89
90	protected void AddResource(IInventoryModule inventory, string resourceSid, int count)
91	{
92	if (inventory is null)	12!
93	{
94	throw new ArgumentNullException(nameof(inventory));	×
95	}
96
97	try
98	{
99	var resourceScheme = SchemeService.GetScheme<IPropScheme>(resourceSid);	12✔
100	var resource = _propFactory.CreateResource(resourceScheme, count);	12✔
101	inventory.Add(resource);	12✔
102	}	12✔
103	catch (KeyNotFoundException exception)	×
104	{
105	throw new CreatePersonException($"Не найден объект {resourceSid}", exception);	×
106	}
107	}	12✔
108
109	protected void FillSlot(HumanPerson person, IDropTableScheme? dropScheme, int slotIndex)
110	{
111	if (dropScheme is null)	16!
112	{
113	return;	×
114	}
115
116	// Генерируем предметы.
117	// Выбираем предмет, как экипировку в слот.
118	// Если он может быть экипирован, то устанавливаем в слот.
119	// Остальные дропнутые предметы складываем просто в инвентарь.
120	// Если текущий предмет невозможно экипировать, то его тоже помещаем в инвентарь.
121
122	var inventory = person.GetModule<IInventoryModule>();	16✔
123	var dropedProps = DropResolver.Resolve(new[] { dropScheme });	16✔
124	var usedEquipment = dropedProps.OfType<Equipment>().FirstOrDefault();	16✔
125	if (usedEquipment != null)	16✔
126	{
127	var equipmentModule = person.GetModule<IEquipmentModule>();	8✔
128	var canBeEquiped = CanBeEquiped(equipmentModule, slotIndex, usedEquipment);	8✔
129	if (canBeEquiped)	8!
130	{
131	AddEquipment(equipmentModule, slotIndex, usedEquipment);	8✔
132	var unusedMainWeaponDrops = dropedProps.Where(x => x != usedEquipment).ToArray();	8✔
133	foreach (var prop in unusedMainWeaponDrops)	16!
134	{
UNCOV 135	AddPropToInventory(inventory, prop);	×
136	}
137	}
138	else
139	{
140	foreach (var prop in dropedProps)	×
141	{
142	AddPropToInventory(inventory, prop);	×
143	}
144	}
145	}
146	else
147	{
148	foreach (var prop in dropedProps)	16!
149	{
150	AddPropToInventory(inventory, prop);	×
151	}
152	}
153	}	8✔
154
155	protected abstract void RollStartEquipment(IInventoryModule inventory, HumanPerson person);
156
157	private static bool CanBeEquiped(
158	IEquipmentModule equipmentModule,
159	int slotIndex,
160	Equipment equipment)
161	{
162	return EquipmentCarrierHelper.CanBeEquiped(equipmentModule, slotIndex, equipment);	8✔
163	}
164
165	private IAttributesModule RollAndAddPersonAttributesToPerson(IPerson person)
166	{
167	var attributes = new[]	4✔
168	{	4✔
169	RollAttribute(PersonAttributeType.PhysicalStrength),	4✔
170	RollAttribute(PersonAttributeType.Dexterity),	4✔
171	RollAttribute(PersonAttributeType.Perception),	4✔
172	RollAttribute(PersonAttributeType.Constitution)	4✔
173	};	4✔
174
175	var attributesModule = new AttributesModule(attributes);	4✔
176
177	person.AddModule(attributesModule);	4✔
178
179	return attributesModule;	4✔
180	}
181
182	private PersonAttribute RollAttribute(PersonAttributeType attributeType)
183	{
184	var value = 10 + Dice.Roll(-4, 4);	16✔
185	return new PersonAttribute(attributeType, value);	16✔
186	}
187
188	private void RollTraitPerks(IEvolutionModule evolutionData)
189	{
190	if (evolutionData is null)	4!
191	{
192	throw new ArgumentNullException(nameof(evolutionData));	×
193	}
194
195	var rolledTraits = _personPerkInitializator.Generate();	4✔
196	evolutionData.AddBuildInPerks(rolledTraits);	4✔
197	}	4✔
198
199	public IPerson Create(string personSchemeSid, IFraction fraction)
200	{
201	var personScheme = SchemeService.GetScheme<IPersonScheme>(personSchemeSid);	4✔
202
203	var person = new HumanPerson(personScheme, fraction);	4✔
204
205	var attributeModule = RollAndAddPersonAttributesToPerson(person);	4✔
206
207	var movingModule = new MovingModule(attributeModule);	4✔
208	person.AddModule(movingModule);	4✔
209
210	var inventoryModule = new InventoryModule();	4✔
211	person.AddModule(inventoryModule);	4✔
212
213	var notNullSlots = personScheme.Slots.Select(x => x!).ToArray();	4✔
214	var equipmentModule = new EquipmentModule(notNullSlots);	4✔
215	person.AddModule(equipmentModule);	4✔
216
217	var effectsModule = new ConditionModule();	4✔
218	person.AddModule(effectsModule);	4✔
219
220	var evolutionModule = new EvolutionModule(SchemeService);	4✔
221	person.AddModule(evolutionModule);	4✔
222	RollTraitPerks(evolutionModule);	4✔
223
224	var survivalModule = new HumanSurvivalModule(personScheme, _survivalRandomSource, attributeModule,	4✔
225	effectsModule, evolutionModule, equipmentModule)	4✔
226	{	4✔
227	PlayerEventLogService = PlayerEventLogService	4✔
228	};	4✔
229	person.AddModule(survivalModule);	4✔
230
231	RollStartEquipment(inventoryModule, person);	4✔
232
233	if (person.Scheme.DefaultAct is null)	4!
234	{
235	throw new InvalidOperationException();	×
236	}
237
238	var defaultActScheme = SchemeService.GetScheme<ITacticalActScheme>(person.Scheme.DefaultAct);	4✔
239	var combatActModule = new CombatActModule(	4✔
240	defaultActScheme,	4✔
241	equipmentModule,	4✔
242	effectsModule,	4✔
243	evolutionModule);	4✔
244
245	person.AddModule(combatActModule);	4✔
246
247	var combatStatsModule = new CombatStatsModule(evolutionModule, equipmentModule);	4✔
248	person.AddModule(combatStatsModule);	4✔
249
250	var diseaseModule = new DiseaseModule(effectsModule);	4✔
251	person.AddModule(diseaseModule);	4✔
252
253	var fowModule = new FowData();	4✔
254	person.AddModule(fowModule);	4✔
255
256	person.PlayerEventLogService = PlayerEventLogService;	4✔
257
258	return person;	4✔
259	}
260	}
261	}

kreghek / Zilon_Roguelike / 860942864

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous