1164820726

Build # 1164820726

Build Type

github

Committed by GitHub

Commit Message

Merge 6397cb04a into 7418907ca

Pull Request Pull Request #1242: GameDev Weekend 2021

Run Details

1964 of 3851 branches covered (51.0%)

Branch coverage included in aggregate %.

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

58 existing lines in 11 files now uncovered.

4839 of 7838 relevant lines covered (61.74%)

34495.91 hits per line

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

0.0

/Zilon.Core/Zilon.Core/PersonGeneration/TemplateBasedPersonFactory.cs

﻿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.Tactics;

namespace Zilon.Core.PersonGeneration
{
    public sealed class TemplateBasedPersonFactory : FullPersonFactoryBase
    {
        public TemplateBasedPersonFactory(
            ISchemeService schemeService,
            ISurvivalRandomSource survivalRandomSource,
            IPropFactory propFactory,
            IDropResolver dropResolver,
            IPersonPerkInitializator personPerkInitializator,
            IDice dice) : base(schemeService, survivalRandomSource, propFactory, dropResolver, personPerkInitializator,
            dice)
        {
        }

        protected override void RollStartEquipment(IInventoryModule inventory, HumanPerson person)
        {
            var templates = GetPersonTemplateByFraction(person.Fraction, SchemeService);
            var rolledTemplate = Dice.RollFromList(templates);

            person.PersonEquipmentTemplate = rolledTemplate.Name;
            person.PersonEquipmentDescriptionTemplate = rolledTemplate.Description;

            var headDropScheme = rolledTemplate.HeadEquipments;
            FillSlot(person, headDropScheme, HeadSlotIndex);

            var armorDropScheme = rolledTemplate.BodyEquipments;
            FillSlot(person, armorDropScheme, BodySlotIndex);

            var mainWeaponDropScheme = rolledTemplate.MainHandEquipments;
            FillSlot(person, mainWeaponDropScheme, MainHandSlotIndex);

            var offWeaponDropScheme = rolledTemplate.OffHandEquipments;
            FillSlot(person, offWeaponDropScheme, OffHandSlotIndex);

            var startPropDropScheme = rolledTemplate.InventoryProps;
            if (startPropDropScheme != null)
            {
                var startProps = DropResolver.Resolve(new[] { startPropDropScheme });
                foreach (var prop in startProps)
                {
                    AddPropToInventory(inventory, prop);
                }
            }

            AddDefaultProps(inventory);
        }

        [ExcludeFromCodeCoverage(Justification = "This event is very rare and we have no stable unit-tests for this." +
                                                 " So exclude the method to clean actual code coverage up.")]
        private static IPersonTemplateScheme[] GetInterventionalistsPersonTemplates(ISchemeService schemeService)
        {
            return schemeService.GetSchemes<IPersonTemplateScheme>()
                .Where(x => x.FractionSid == "interventionists")
                .ToArray();
        }

        [ExcludeFromCodeCoverage(Justification = "This event is very rare and we have no stable unit-tests for this." +
                                                 " So exclude the method to clean actual code coverage up.")]
        private static IPersonTemplateScheme[] GetMilitiaPersonTemplates(ISchemeService schemeService)
        {
            return schemeService.GetSchemes<IPersonTemplateScheme>()
                .Where(x => x.FractionSid == "militia").ToArray();
        }

        private static IPersonTemplateScheme[] GetPersonTemplateByFraction(IFraction fraction,
            ISchemeService schemeService)
        {
            if (fraction == Fractions.InterventionistFraction)
            {
                return GetInterventionalistsPersonTemplates(schemeService);
            }

            if (fraction == Fractions.MilitiaFraction)
            {
                return GetMilitiaPersonTemplates(schemeService);
            }

            if (fraction == Fractions.TroublemakerFraction)
            {
                return GetTroublemakerPersonTemplates(schemeService);
            }

            return GetPlayerPersonTemplates(schemeService);
        }

        private static IPersonTemplateScheme[] GetPlayerPersonTemplates(ISchemeService schemeService)
        {
            return schemeService.GetSchemes<IPersonTemplateScheme>()
                .Where(x => x.FractionSid == "player").ToArray();
        }

        [ExcludeFromCodeCoverage(Justification = "This event is very rare and we have no stable unit-tests for this." +
                                                 " So exclude the method to clean actual code coverage up.")]
        private static IPersonTemplateScheme[] GetTroublemakerPersonTemplates(ISchemeService schemeService)
        {
            return schemeService.GetSchemes<IPersonTemplateScheme>()
                .Where(x => x.FractionSid == "troublemakers")
                .ToArray();
        }
    }
}

1	using System.Diagnostics.CodeAnalysis;
2	using System.Linq;
3
4	using Zilon.Core.CommonServices.Dices;
5	using Zilon.Core.PersonModules;
6	using Zilon.Core.Persons;
7	using Zilon.Core.Props;
8	using Zilon.Core.Schemes;
9	using Zilon.Core.Tactics;
10
11	namespace Zilon.Core.PersonGeneration
12	{
13	public sealed class TemplateBasedPersonFactory : FullPersonFactoryBase
14	{
15	public TemplateBasedPersonFactory(
16	ISchemeService schemeService,
17	ISurvivalRandomSource survivalRandomSource,
18	IPropFactory propFactory,
19	IDropResolver dropResolver,
20	IPersonPerkInitializator personPerkInitializator,
21	IDice dice) : base(schemeService, survivalRandomSource, propFactory, dropResolver, personPerkInitializator,	×
22	dice)	×
23	{
24	}	×
25
26	protected override void RollStartEquipment(IInventoryModule inventory, HumanPerson person)
27	{
28	var templates = GetPersonTemplateByFraction(person.Fraction, SchemeService);	×
29	var rolledTemplate = Dice.RollFromList(templates);	×
30
31	person.PersonEquipmentTemplate = rolledTemplate.Name;	×
NEW 32	person.PersonEquipmentDescriptionTemplate = rolledTemplate.Description;	×
33
34	var headDropScheme = rolledTemplate.HeadEquipments;	×
35	FillSlot(person, headDropScheme, HeadSlotIndex);	×
36
37	var armorDropScheme = rolledTemplate.BodyEquipments;	×
38	FillSlot(person, armorDropScheme, BodySlotIndex);	×
39
40	var mainWeaponDropScheme = rolledTemplate.MainHandEquipments;	×
41	FillSlot(person, mainWeaponDropScheme, MainHandSlotIndex);	×
42
43	var offWeaponDropScheme = rolledTemplate.OffHandEquipments;	×
44	FillSlot(person, offWeaponDropScheme, OffHandSlotIndex);	×
45
46	var startPropDropScheme = rolledTemplate.InventoryProps;	×
47	if (startPropDropScheme != null)	×
48	{
49	var startProps = DropResolver.Resolve(new[] { startPropDropScheme });	×
50	foreach (var prop in startProps)	×
51	{
52	AddPropToInventory(inventory, prop);	×
53	}
54	}
55
56	AddDefaultProps(inventory);	×
57	}	×
58
59	[ExcludeFromCodeCoverage(Justification = "This event is very rare and we have no stable unit-tests for this." +
60	" So exclude the method to clean actual code coverage up.")]
61	private static IPersonTemplateScheme[] GetInterventionalistsPersonTemplates(ISchemeService schemeService)
62	{
63	return schemeService.GetSchemes<IPersonTemplateScheme>()
64	.Where(x => x.FractionSid == "interventionists")
65	.ToArray();
66	}
67
68	[ExcludeFromCodeCoverage(Justification = "This event is very rare and we have no stable unit-tests for this." +
69	" So exclude the method to clean actual code coverage up.")]
70	private static IPersonTemplateScheme[] GetMilitiaPersonTemplates(ISchemeService schemeService)
71	{
72	return schemeService.GetSchemes<IPersonTemplateScheme>()
73	.Where(x => x.FractionSid == "militia").ToArray();
74	}
75
76	private static IPersonTemplateScheme[] GetPersonTemplateByFraction(IFraction fraction,
77	ISchemeService schemeService)
78	{
79	if (fraction == Fractions.InterventionistFraction)	×
80	{
81	return GetInterventionalistsPersonTemplates(schemeService);	×
82	}
83
84	if (fraction == Fractions.MilitiaFraction)	×
85	{
86	return GetMilitiaPersonTemplates(schemeService);	×
87	}
88
89	if (fraction == Fractions.TroublemakerFraction)	×
90	{
91	return GetTroublemakerPersonTemplates(schemeService);	×
92	}
93
94	return GetPlayerPersonTemplates(schemeService);	×
95	}
96
97	private static IPersonTemplateScheme[] GetPlayerPersonTemplates(ISchemeService schemeService)
98	{
99	return schemeService.GetSchemes<IPersonTemplateScheme>()	×
NEW 100	.Where(x => x.FractionSid == "player").ToArray();	×
101	}
102
103	[ExcludeFromCodeCoverage(Justification = "This event is very rare and we have no stable unit-tests for this." +
104	" So exclude the method to clean actual code coverage up.")]
105	private static IPersonTemplateScheme[] GetTroublemakerPersonTemplates(ISchemeService schemeService)
106	{
107	return schemeService.GetSchemes<IPersonTemplateScheme>()
108	.Where(x => x.FractionSid == "troublemakers")
109	.ToArray();
110	}
111	}
112	}

kreghek / Zilon_Roguelike / 1164820726

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