861408244

Build Type

github

Committed by GitHub

Commit Message

Merge 7b8397e94 into 8ba8f6511

Pull Request Pull Request #1108: Monogame client

Run Details

2310 of 3684 branches covered (62.7%)

Branch coverage included in aggregate %.

49 of 179 new or added lines in 78 files covered. (27.37%)

60 existing lines in 10 files now uncovered.

6146 of 8018 relevant lines covered (76.65%)

73675.01 hits per line

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

55.56

/Zilon.Core/Zilon.Core/Persons/AttackActorJobProgress.cs

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

using Newtonsoft.Json;

using Zilon.Core.Schemes;
using Zilon.Core.Tactics;

namespace Zilon.Core.Persons
{
    public class AttackActorJobProgress : IJobProgress
    {
        private readonly ITacticalAct _tacticalAct;
        private readonly IActor _targetActor;

        public AttackActorJobProgress(IActor targetActor, ITacticalAct tacticalAct)
        {
            _targetActor = targetActor;
            _tacticalAct = tacticalAct;
        }

        private static bool ActorHasTag(string tag, IActor targetActor)
        {
            var monsterPersonScheme = GetPersonScheme(targetActor);

            if (monsterPersonScheme is null)
            {
                return false;
            }

            if (monsterPersonScheme.Tags != null)
            {
                return false;
            }

            return monsterPersonScheme.Tags.Contains(tag);
        }

        private static void AddProgress(IJob job, List<IJob> modifiedJobs)
        {
            job.Progress++;
            modifiedJobs.Add(job);
        }

        private void AddProgressUsingAdditionalData(IJob job, List<IJob> modifiedJobs, string[] dataList)
        {
            foreach (var dataItem in dataList)
            {
                Debug.Assert(!string.IsNullOrWhiteSpace(dataItem), "Данные работы не должны быть пустыми.");
                if (string.IsNullOrWhiteSpace(dataItem))
                {
                    continue;
                }

                var jobData = JsonConvert.DeserializeObject<AttackActorJobData>(dataItem);

                Debug.Assert(jobData.MonsterTags != null || jobData.WeaponTags != null,
                    "В данных работ должны быть указаны теги, на основе которых фильтруются работы.");

                if (jobData.WeaponTags != null)
                {
                    // Засчитываем прогресс, если у оружия, которым было произведено действие,
                    // есть все указанные теги.

                    ProcessAttackBySpecifiedWeapons(job, modifiedJobs, jobData);
                }
                else if (jobData.MonsterTags != null)
                {
                    // Засчитываем прогресс, если у атакуемого актёра
                    // есть все указанные теги.

                    ProcessAttackToSpecifiedMonster(job, modifiedJobs, jobData);
                }
                else
                {
                    Debug.Assert(true, "Все варианты данных должны обрабатываться.");
                }
            }
        }

        private static IMonsterScheme? GetPersonScheme(IActor targetActor)
        {
            var monsterPerson = targetActor.Person as MonsterPerson;
            return monsterPerson?.Scheme;
        }

        private void ProcessAttackBySpecifiedWeapons(IJob job, List<IJob> modifiedJobs, AttackActorJobData jobData)
        {
            Debug.Assert(jobData.WeaponTags.Any(), "Должно быть указано не менее одного тега.");

            if (jobData.WeaponTags is null)
            {
                return;
            }

            if (!jobData.WeaponTags.Any())
            {
                return;
            }

            var weaponHasAllTags = true;
            foreach (var tag in jobData.WeaponTags)
            {
                Debug.Assert(!string.IsNullOrWhiteSpace(tag), "Теги не могут быть пустыми.");
                if (string.IsNullOrWhiteSpace(tag))
                {
                    continue;
                }

                var weaponHasTag = WeaponHasTag(tag, _tacticalAct);
                if (!weaponHasTag)
                {
                    weaponHasAllTags = false;
                    break;
                }
            }

            if (weaponHasAllTags)
            {
                AddProgress(job, modifiedJobs);
            }
        }

        private void ProcessAttackToSpecifiedMonster(IJob job, List<IJob> modifiedJobs, AttackActorJobData jobData)
        {
            Debug.Assert(jobData.WeaponTags.Any(), "Должно быть указано не менее одного тега.");

            if (jobData.MonsterTags is null)
            {
                return;
            }

            if (!jobData.MonsterTags.Any())
            {
                return;
            }

            var monsterHasAllTags = true;
            foreach (var tag in jobData.MonsterTags)
            {
                Debug.Assert(!string.IsNullOrWhiteSpace(tag), "Теги не могут быть пустыми.");
                if (string.IsNullOrWhiteSpace(tag))
                {
                    continue;
                }

                var actorHasTag = ActorHasTag(tag, _targetActor);
                if (!actorHasTag)
                {
                    monsterHasAllTags = false;
                    break;
                }
            }

            if (monsterHasAllTags)
            {
                AddProgress(job, modifiedJobs);
            }
        }

        private void ProcessJob(IJob job, List<IJob> modifiedJobs)
        {
            if (job.Scheme.Data is null)
            {
                AddProgress(job, modifiedJobs);
            }
            else
            {
                AddProgressUsingAdditionalData(job, modifiedJobs, job.Scheme.Data);
            }
        }

        private static bool WeaponHasTag(string tag, ITacticalAct tacticalAct)
        {
            if (tacticalAct.Equipment is null)
            {
                return false;
            }

            if (tacticalAct.Equipment.Scheme.Tags is null)
            {
                return false;
            }

            return tacticalAct.Equipment.Scheme.Tags.Contains(tag);
        }

        public IJob[] ApplyToJobs(IEnumerable<IJob> currentJobs)
        {
            if (currentJobs is null)
            {
                throw new ArgumentNullException(nameof(currentJobs));
            }

            var modifiedJobs = new List<IJob>();
            foreach (var job in currentJobs)
            {
                if (job.Scheme.Type != JobType.AttacksActor)
                {
                    continue;
                }

                ProcessJob(job, modifiedJobs);
            }

            return modifiedJobs.ToArray();
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Diagnostics;
4	using System.Linq;
5
6	using Newtonsoft.Json;
7
8	using Zilon.Core.Schemes;
9	using Zilon.Core.Tactics;
10
11	namespace Zilon.Core.Persons
12	{
13	public class AttackActorJobProgress : IJobProgress
14	{
15	private readonly ITacticalAct _tacticalAct;
16	private readonly IActor _targetActor;
17
18	public AttackActorJobProgress(IActor targetActor, ITacticalAct tacticalAct)	134✔
19	{
20	_targetActor = targetActor;	134✔
21	_tacticalAct = tacticalAct;	134✔
22	}	134✔
23
24	private static bool ActorHasTag(string tag, IActor targetActor)
25	{
26	var monsterPersonScheme = GetPersonScheme(targetActor);	×
27
28	if (monsterPersonScheme is null)	×
29	{
30	return false;	×
31	}
32
33	if (monsterPersonScheme.Tags != null)	×
34	{
35	return false;	×
36	}
37
38	return monsterPersonScheme.Tags.Contains(tag);	×
39	}
40
41	private static void AddProgress(IJob job, List<IJob> modifiedJobs)
42	{
43	job.Progress++;	196✔
44	modifiedJobs.Add(job);	196✔
45	}	196✔
46
47	private void AddProgressUsingAdditionalData(IJob job, List<IJob> modifiedJobs, string[] dataList)
48	{
49	foreach (var dataItem in dataList)	1,528✔
50	{
51	Debug.Assert(!string.IsNullOrWhiteSpace(dataItem), "Данные работы не должны быть пустыми.");
52	if (string.IsNullOrWhiteSpace(dataItem))	382✔
53	{
54	continue;
55	}
56
57	var jobData = JsonConvert.DeserializeObject<AttackActorJobData>(dataItem);	382✔
58
59	Debug.Assert(jobData.MonsterTags != null \|\| jobData.WeaponTags != null,
60	"В данных работ должны быть указаны теги, на основе которых фильтруются работы.");
61
62	if (jobData.WeaponTags != null)	382!
63	{
64	// Засчитываем прогресс, если у оружия, которым было произведено действие,
65	// есть все указанные теги.
66
67	ProcessAttackBySpecifiedWeapons(job, modifiedJobs, jobData);	382✔
68	}
69	else if (jobData.MonsterTags != null)	×
70	{
71	// Засчитываем прогресс, если у атакуемого актёра
72	// есть все указанные теги.
73
74	ProcessAttackToSpecifiedMonster(job, modifiedJobs, jobData);	×
75	}
76	else
77	{
78	Debug.Assert(true, "Все варианты данных должны обрабатываться.");
79	}
80	}
81	}	382✔
82
83	private static IMonsterScheme? GetPersonScheme(IActor targetActor)
84	{
85	var monsterPerson = targetActor.Person as MonsterPerson;	×
86	return monsterPerson?.Scheme;	×
87	}
88
89	private void ProcessAttackBySpecifiedWeapons(IJob job, List<IJob> modifiedJobs, AttackActorJobData jobData)
90	{
91	Debug.Assert(jobData.WeaponTags.Any(), "Должно быть указано не менее одного тега.");
92
93	if (jobData.WeaponTags is null)	382!
94	{
95	return;	×
96	}
97
98	if (!jobData.WeaponTags.Any())	382!
99	{
100	return;	×
101	}
102
103	var weaponHasAllTags = true;	382✔
104	foreach (var tag in jobData.WeaponTags)	1,220✔
105	{
106	Debug.Assert(!string.IsNullOrWhiteSpace(tag), "Теги не могут быть пустыми.");
107	if (string.IsNullOrWhiteSpace(tag))	383✔
108	{
109	continue;
110	}
111
112	var weaponHasTag = WeaponHasTag(tag, _tacticalAct);	383✔
113	if (!weaponHasTag)	383✔
114	{
115	weaponHasAllTags = false;	310✔
116	break;	310✔
117	}
118	}
119
120	if (weaponHasAllTags)	382✔
121	{
122	AddProgress(job, modifiedJobs);	72✔
123	}
124	}	382✔
125
126	private void ProcessAttackToSpecifiedMonster(IJob job, List<IJob> modifiedJobs, AttackActorJobData jobData)
127	{
128	Debug.Assert(jobData.WeaponTags.Any(), "Должно быть указано не менее одного тега.");
129
130	if (jobData.MonsterTags is null)	×
131	{
132	return;	×
133	}
134
135	if (!jobData.MonsterTags.Any())	×
136	{
137	return;	×
138	}
139
140	var monsterHasAllTags = true;	×
141	foreach (var tag in jobData.MonsterTags)	×
142	{
143	Debug.Assert(!string.IsNullOrWhiteSpace(tag), "Теги не могут быть пустыми.");
144	if (string.IsNullOrWhiteSpace(tag))	×
145	{
146	continue;
147	}
148
149	var actorHasTag = ActorHasTag(tag, _targetActor);	×
150	if (!actorHasTag)	×
151	{
152	monsterHasAllTags = false;	×
153	break;	×
154	}
155	}
156
157	if (monsterHasAllTags)	×
158	{
159	AddProgress(job, modifiedJobs);	×
160	}
161	}	×
162
163	private void ProcessJob(IJob job, List<IJob> modifiedJobs)
164	{
165	if (job.Scheme.Data is null)	506✔
166	{
167	AddProgress(job, modifiedJobs);	124✔
168	}
169	else
170	{
171	AddProgressUsingAdditionalData(job, modifiedJobs, job.Scheme.Data);	382✔
172	}
173	}	382✔
174
175	private static bool WeaponHasTag(string tag, ITacticalAct tacticalAct)
176	{
177	if (tacticalAct.Equipment is null)	383✔
178	{
179	return false;	66✔
180	}
181
182	if (tacticalAct.Equipment.Scheme.Tags is null)	317!
183	{
184	return false;	×
185	}
186
187	return tacticalAct.Equipment.Scheme.Tags.Contains(tag);	317✔
188	}
189
190	public IJob[] ApplyToJobs(IEnumerable<IJob> currentJobs)
191	{
192	if (currentJobs is null)	934!
193	{
NEW 194	throw new ArgumentNullException(nameof(currentJobs));	×
195	}
196
197	var modifiedJobs = new List<IJob>();	934✔
198	foreach (var job in currentJobs)	3,736✔
199	{
200	if (job.Scheme.Type != JobType.AttacksActor)	934✔
201	{
202	continue;
203	}
204
205	ProcessJob(job, modifiedJobs);	506✔
206	}
207
208	return modifiedJobs.ToArray();	934✔
209	}
210	}
211	}

kreghek / Zilon_Roguelike / 861408244

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