686807597

Build Type

github

Committed by GitHub

Commit Message

Merge e606fab75 into 0a9d5c71e

Pull Request Pull Request #1069: Fix 966 automove

Run Details

2323 of 3732 branches covered (62.25%)

Branch coverage included in aggregate %.

11 of 121 new or added lines in 12 files covered. (9.09%)

31 existing lines in 14 files now uncovered.

6115 of 8050 relevant lines covered (75.96%)

92921.35 hits per line

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

63.33

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

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

kreghek / Zilon_Roguelike / 686807597

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