1159391921

Build # 1159391921

Build Type

github

Committed by GitHub

Commit Message

Merge 8be270c8a into 7418907ca

Pull Request Pull Request #1242: GameDev Weekend 2021

Run Details

1961 of 3851 branches covered (50.92%)

Branch coverage included in aggregate %.

78 of 181 new or added lines in 21 files covered. (43.09%)

61 existing lines in 12 files now uncovered.

4836 of 7838 relevant lines covered (61.7%)

34495.53 hits per line

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

0.0

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

﻿using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
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;

        [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));
        }

        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);
            AddEquipment(inventory, "med-mask");
            AddEquipment(inventory, "med-gloves");
        }

        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 IPlayerEventLogService? PlayerEventLogService { get; set; }

        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 ConditionsModule();
            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.DefaultActs is null)
            {
                throw new InvalidOperationException();
            }

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

kreghek / Zilon_Roguelike / 1159391921

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