916838616

Build Type

github

Committed by GitHub

Commit Message

Merge 6c63469af into 703433632

Pull Request Pull Request #1177: Equip and use command

Run Details

1884 of 3692 branches covered (51.03%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 2 files covered. (0.0%)

97 existing lines in 8 files now uncovered.

4858 of 7832 relevant lines covered (62.03%)

20966.03 hits per line

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

0.0

/Zilon.Core/Zilon.Bot.Players/Logics/ExploreLogicState.cs

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

using Zilon.Core.Graphs;
using Zilon.Core.PersonModules;
using Zilon.Core.Tactics;
using Zilon.Core.Tactics.Behaviour;
using Zilon.Core.Tactics.Behaviour.Bots;
using Zilon.Core.Tactics.Spatial;

namespace Zilon.Bot.Players.Logics
{
    //TODO Перепроверить работу этого состояния.
    // Есть подозрение, что оно не работает.
    public sealed class ExploreLogicState : MoveLogicStateBase
    {
        [ExcludeFromCodeCoverage]
        public ExploreLogicState(IDecisionSource decisionSource) : base(decisionSource)
        {
        }

        public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
            ILogicStrategyData strategyData)
        {
            if (MoveTask == null)
            {
                MoveTask = CreateBypassMoveTask(actor, strategyData, context.Sector);

                if (MoveTask != null)
                {
                    return MoveTask;
                }

                // Это может произойти, если актёр не выбрал следующий узел.
                // Тогда переводим актёра в режим ожидания.

                var taskContext = new ActorTaskContext(context.Sector);
                IdleTask = new IdleTask(actor, taskContext, DecisionSource);
                return IdleTask;
            }

            if (!MoveTask.IsComplete)
            {
                // Если команда на перемещение к целевой точке патруля не закончена,
                // тогда продолжаем её.
                // Предварительно проверяем, не мешает ли что-либо её продолжить выполнять.
                if (!MoveTask.CanExecute())
                {
                    MoveTask = CreateBypassMoveTask(actor, strategyData, context.Sector);
                }

                if (MoveTask != null)
                {
                    return MoveTask;
                }

                var taskContext = new ActorTaskContext(context.Sector);
                IdleTask = new IdleTask(actor, taskContext, DecisionSource);
                return IdleTask;
            }

            Complete = true;
            return null;
        }

        private MoveTask CreateBypassMoveTask(IActor actor, ILogicStrategyData strategyData, ISector sector)
        {
            var map = sector.Map;

            var frontNodes = WriteObservedNodesOrGetFromFow(actor, strategyData, sector).ToArray();
            if (!frontNodes.Any())
            {
                return null;
            }

            var availableNodesArray = frontNodes as HexNode[] ?? frontNodes.ToArray();

            if (availableNodesArray.Length == 0)
            {
                // There is no nodes available to roaming.
                // We can do nothing.
                return null;
            }

            for (var i = 0; i < 3; i++)
            {
                var targetNode = DecisionSource.SelectTargetRoamingNode(availableNodesArray);

                if (map.IsPositionAvailableFor(targetNode, actor))
                {
                    var context = new ActorTaskContext(sector);
                    var moveTask = new MoveTask(actor, context, targetNode, map);

                    return moveTask;
                }
            }

            return null;
        }

        private static IGraphNode[] GetKnownNodes(ISector sector, IFowData fowModule)
        {
            var fowItems = fowModule.GetSectorFowData(sector);

            var exploredFowItems = fowItems.GetFowNodeByState(SectorMapNodeFowState.Explored);
            var observingFowItems = fowItems.GetFowNodeByState(SectorMapNodeFowState.Observing);

            var knownNodes = exploredFowItems.Select(x => x.Node).Union(observingFowItems.Select(x => x.Node))
                .ToArray();
            return knownNodes;
        }

        private static IEnumerable<IGraphNode> GetNodesUsingFowModule(
            ILogicStrategyData strategyData,
            ISector sector,
            IFowData fowModule)
        {
            IEnumerable<IGraphNode> frontNodes;

            var knownNodes = GetKnownNodes(sector, fowModule);

            var map = sector.Map;
            var frontNodesHashSet = new HashSet<IGraphNode>();
            foreach (var node in knownNodes)
            {
                // Примечаем выходы
                if (map.Transitions.ContainsKey(node))
                {
                    strategyData.ExitNodes.Add(node);
                }

                var nextUnknownNodes = map.GetNext(node).Where(x => !knownNodes.Contains(x));
                if (nextUnknownNodes.Any())
                {
                    foreach (var unknownNode in nextUnknownNodes)
                    {
                        frontNodesHashSet.Add(unknownNode);
                    }
                }
            }

            frontNodes = frontNodesHashSet;
            return frontNodes;
        }

        private static IEnumerable<IGraphNode> GetNodesUsingStrategyData(
            IActor actor,
            ILogicStrategyData strategyData,
            ISector sector)
        {
            IEnumerable<IGraphNode> frontNodes;
            var map = sector.Map;

            var observeNodes = map.Nodes.Where(x => map.DistanceBetween(x, actor.Node) < 5);

            foreach (var mapNode in observeNodes)
            {
                strategyData.ObservedNodes.Add(mapNode);
            }

            // Собираем пограничные неисследованные узлы.
            var frontNodesHashSet = new HashSet<IGraphNode>();
            foreach (var observedNode in strategyData.ObservedNodes)
            {
                var nextNodes = map.GetNext(observedNode);

                var notObservedNextNodes = nextNodes.Where(x => !strategyData.ObservedNodes.Contains(x));

                foreach (var edgeNode in notObservedNextNodes)
                {
                    frontNodesHashSet.Add(edgeNode);
                }

                // Примечаем выходы
                if (map.Transitions.ContainsKey(observedNode))
                {
                    strategyData.ExitNodes.Add(observedNode);
                }
            }

            var emptyFrontNodes = !frontNodesHashSet.Any();
            var allNodesObserved = map.Nodes.All(x => strategyData.ObservedNodes.Contains(x));

            Debug.Assert((emptyFrontNodes && allNodesObserved) || !emptyFrontNodes,
                "Это состояние выполняется, только если есть неисследованые узлы.");

            frontNodes = frontNodesHashSet;
            return frontNodes;
        }

        private static IEnumerable<IGraphNode> WriteObservedNodesOrGetFromFow(IActor actor,
            ILogicStrategyData strategyData,
            ISector sector)
        {
            IEnumerable<IGraphNode> frontNodes;

            var fowModule = actor.Person.GetModuleSafe<IFowData>();
            if (fowModule is null)
            {
                frontNodes = GetNodesUsingStrategyData(actor, strategyData, sector);
            }
            else
            {
                frontNodes = GetNodesUsingFowModule(strategyData, sector, fowModule);
            }

            if (!frontNodes.Any())
            {
                var closestNode = sector.Map.GetNext(actor.Node).FirstOrDefault();
                if (closestNode != null)
                {
                    frontNodes = new[] { closestNode };
                }
            }

            return frontNodes;
        }
    }
}

1	using System.Collections.Generic;
2	using System.Diagnostics;
3	using System.Diagnostics.CodeAnalysis;
4	using System.Linq;
5
6	using Zilon.Core.Graphs;
7	using Zilon.Core.PersonModules;
8	using Zilon.Core.Tactics;
9	using Zilon.Core.Tactics.Behaviour;
10	using Zilon.Core.Tactics.Behaviour.Bots;
11	using Zilon.Core.Tactics.Spatial;
12
13	namespace Zilon.Bot.Players.Logics
14	{
15	//TODO Перепроверить работу этого состояния.
16	// Есть подозрение, что оно не работает.
17	public sealed class ExploreLogicState : MoveLogicStateBase
18	{
19	[ExcludeFromCodeCoverage]
20	public ExploreLogicState(IDecisionSource decisionSource) : base(decisionSource)
21	{
22	}
23
24	public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
25	ILogicStrategyData strategyData)
26	{
UNCOV 27	if (MoveTask == null)	×
28	{
UNCOV 29	MoveTask = CreateBypassMoveTask(actor, strategyData, context.Sector);	×
30
UNCOV 31	if (MoveTask != null)	×
32	{
UNCOV 33	return MoveTask;	×
34	}
35
36	// Это может произойти, если актёр не выбрал следующий узел.
37	// Тогда переводим актёра в режим ожидания.
38
39	var taskContext = new ActorTaskContext(context.Sector);	×
40	IdleTask = new IdleTask(actor, taskContext, DecisionSource);	×
41	return IdleTask;	×
42	}
43
44	if (!MoveTask.IsComplete)	×
45	{
46	// Если команда на перемещение к целевой точке патруля не закончена,
47	// тогда продолжаем её.
48	// Предварительно проверяем, не мешает ли что-либо её продолжить выполнять.
49	if (!MoveTask.CanExecute())	×
50	{
51	MoveTask = CreateBypassMoveTask(actor, strategyData, context.Sector);	×
52	}
53
54	if (MoveTask != null)	×
55	{
56	return MoveTask;	×
57	}
58
59	var taskContext = new ActorTaskContext(context.Sector);	×
60	IdleTask = new IdleTask(actor, taskContext, DecisionSource);	×
61	return IdleTask;	×
62	}
63
64	Complete = true;	×
65	return null;	×
66	}
67
68	private MoveTask CreateBypassMoveTask(IActor actor, ILogicStrategyData strategyData, ISector sector)
69	{
UNCOV 70	var map = sector.Map;	×
71
UNCOV 72	var frontNodes = WriteObservedNodesOrGetFromFow(actor, strategyData, sector).ToArray();	×
UNCOV 73	if (!frontNodes.Any())	×
74	{
75	return null;	×
76	}
77
UNCOV 78	var availableNodesArray = frontNodes as HexNode[] ?? frontNodes.ToArray();	×
79
UNCOV 80	if (availableNodesArray.Length == 0)	×
81	{
82	// There is no nodes available to roaming.
83	// We can do nothing.
84	return null;	×
85	}
86
UNCOV 87	for (var i = 0; i < 3; i++)	×
88	{
UNCOV 89	var targetNode = DecisionSource.SelectTargetRoamingNode(availableNodesArray);	×
90
UNCOV 91	if (map.IsPositionAvailableFor(targetNode, actor))	×
92	{
UNCOV 93	var context = new ActorTaskContext(sector);	×
UNCOV 94	var moveTask = new MoveTask(actor, context, targetNode, map);	×
95
UNCOV 96	return moveTask;	×
97	}
98	}
99
100	return null;	×
101	}
102
103	private static IGraphNode[] GetKnownNodes(ISector sector, IFowData fowModule)
104	{
UNCOV 105	var fowItems = fowModule.GetSectorFowData(sector);	×
106
UNCOV 107	var exploredFowItems = fowItems.GetFowNodeByState(SectorMapNodeFowState.Explored);	×
UNCOV 108	var observingFowItems = fowItems.GetFowNodeByState(SectorMapNodeFowState.Observing);	×
109
UNCOV 110	var knownNodes = exploredFowItems.Select(x => x.Node).Union(observingFowItems.Select(x => x.Node))	×
UNCOV 111	.ToArray();	×
UNCOV 112	return knownNodes;	×
113	}
114
115	private static IEnumerable<IGraphNode> GetNodesUsingFowModule(
116	ILogicStrategyData strategyData,
117	ISector sector,
118	IFowData fowModule)
119	{
120	IEnumerable<IGraphNode> frontNodes;
121
UNCOV 122	var knownNodes = GetKnownNodes(sector, fowModule);	×
123
UNCOV 124	var map = sector.Map;	×
UNCOV 125	var frontNodesHashSet = new HashSet<IGraphNode>();	×
UNCOV 126	foreach (var node in knownNodes)	×
127	{
128	// Примечаем выходы
129	if (map.Transitions.ContainsKey(node))	×
130	{
131	strategyData.ExitNodes.Add(node);	×
132	}
133
134	var nextUnknownNodes = map.GetNext(node).Where(x => !knownNodes.Contains(x));	×
135	if (nextUnknownNodes.Any())	×
136	{
137	foreach (var unknownNode in nextUnknownNodes)	×
138	{
139	frontNodesHashSet.Add(unknownNode);	×
140	}
141	}
142	}
143
UNCOV 144	frontNodes = frontNodesHashSet;	×
UNCOV 145	return frontNodes;	×
146	}
147
148	private static IEnumerable<IGraphNode> GetNodesUsingStrategyData(
149	IActor actor,
150	ILogicStrategyData strategyData,
151	ISector sector)
152	{
153	IEnumerable<IGraphNode> frontNodes;
154	var map = sector.Map;	×
155
156	var observeNodes = map.Nodes.Where(x => map.DistanceBetween(x, actor.Node) < 5);	×
157
158	foreach (var mapNode in observeNodes)	×
159	{
160	strategyData.ObservedNodes.Add(mapNode);	×
161	}
162
163	// Собираем пограничные неисследованные узлы.
164	var frontNodesHashSet = new HashSet<IGraphNode>();	×
165	foreach (var observedNode in strategyData.ObservedNodes)	×
166	{
167	var nextNodes = map.GetNext(observedNode);	×
168
169	var notObservedNextNodes = nextNodes.Where(x => !strategyData.ObservedNodes.Contains(x));	×
170
171	foreach (var edgeNode in notObservedNextNodes)	×
172	{
173	frontNodesHashSet.Add(edgeNode);	×
174	}
175
176	// Примечаем выходы
177	if (map.Transitions.ContainsKey(observedNode))	×
178	{
179	strategyData.ExitNodes.Add(observedNode);	×
180	}
181	}
182
183	var emptyFrontNodes = !frontNodesHashSet.Any();	×
184	var allNodesObserved = map.Nodes.All(x => strategyData.ObservedNodes.Contains(x));	×
185
186	Debug.Assert((emptyFrontNodes && allNodesObserved) \|\| !emptyFrontNodes,
187	"Это состояние выполняется, только если есть неисследованые узлы.");
188
189	frontNodes = frontNodesHashSet;	×
190	return frontNodes;	×
191	}
192
193	private static IEnumerable<IGraphNode> WriteObservedNodesOrGetFromFow(IActor actor,
194	ILogicStrategyData strategyData,
195	ISector sector)
196	{
197	IEnumerable<IGraphNode> frontNodes;
198
UNCOV 199	var fowModule = actor.Person.GetModuleSafe<IFowData>();	×
UNCOV 200	if (fowModule is null)	×
201	{
202	frontNodes = GetNodesUsingStrategyData(actor, strategyData, sector);	×
203	}
204	else
205	{
UNCOV 206	frontNodes = GetNodesUsingFowModule(strategyData, sector, fowModule);	×
207	}
208
UNCOV 209	if (!frontNodes.Any())	×
210	{
UNCOV 211	var closestNode = sector.Map.GetNext(actor.Node).FirstOrDefault();	×
UNCOV 212	if (closestNode != null)	×
213	{
UNCOV 214	frontNodes = new[] { closestNode };	×
215	}
216	}
217
UNCOV 218	return frontNodes;	×
219	}
220	}
221	}

kreghek / Zilon_Roguelike / 916838616

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