869950998

Build Type

github

Committed by GitHub

Commit Message

Merge c8a8a4548 into 00d2fa5b7

Pull Request Pull Request #1124: Feature 1100 autoplay mode

Run Details

2297 of 3696 branches covered (62.15%)

Branch coverage included in aggregate %.

50 of 58 new or added lines in 15 files covered. (86.21%)

19 existing lines in 9 files now uncovered.

6162 of 8034 relevant lines covered (76.7%)

63247.34 hits per line

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

85.71

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

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

using Zilon.Core.PersonModules;
using Zilon.Core.Persons;
using Zilon.Core.Tactics;
using Zilon.Core.Tactics.Behaviour;
using Zilon.Core.Tactics.Spatial;

namespace Zilon.Bot.Players.Logics
{
    public sealed class DefeatTargetLogicState : LogicStateBase
    {
        private const int REFRESH_COUNTER_VALUE = 3;

        private readonly ITacticalActUsageService _actService;

        private MoveTask _moveTask;

        private int _refreshCounter;

        public DefeatTargetLogicState(ITacticalActUsageService actService)
        {
            _actService = actService ?? throw new ArgumentNullException(nameof(actService));
        }

        public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
            ILogicStrategyData strategyData)
        {
            var triggerTarget = strategyData.TriggerIntuder;

            if (triggerTarget == null)
            {
                throw new InvalidOperationException(
                    $"Assign {nameof(strategyData.TriggerIntuder)} with not null valie in related trigger.");
            }

            var targetCanBeDamaged = triggerTarget.CanBeDamaged();
            if (!targetCanBeDamaged)
            {
                Complete = true;
                return null;
            }

            var attackParams = CheckAttackAvailability(actor, triggerTarget, context.Sector.Map);
            if (attackParams.IsAvailable)
            {
                var act = attackParams.TacticalAct;

                var taskContext = new ActorTaskContext(context.Sector);

                var attackTask = new AttackTask(actor, taskContext, triggerTarget, act, _actService);
                return attackTask;
            }

            // Маршрут до цели обновляем каждые 3 хода.
            // Для оптимизации.
            // Эффект потери цели.
            if (_refreshCounter > 0 && _moveTask?.CanExecute() == true)
            {
                _refreshCounter--;
                return _moveTask;
            }

            var map = context.Sector.Map;
            _refreshCounter = REFRESH_COUNTER_VALUE;
            var targetIsOnLine = map.TargetIsOnLine(actor.Node, triggerTarget.Node);

            if (targetIsOnLine)
            {
                var taskContext = new ActorTaskContext(context.Sector);

                _moveTask = new MoveTask(actor, taskContext, triggerTarget.Node, map);
                return _moveTask;
            }

            // Цел за пределами видимости. Считается потерянной.
            return null;
        }

        protected override void ResetData()
        {
            _refreshCounter = 0;
            _moveTask = null;
        }

        private static AttackParams CheckAttackAvailability(IActor actor, IAttackTarget target, ISectorMap map)
        {
            var combatActModule = actor.Person.GetModuleSafe<ICombatActModule>();
            if (combatActModule is null)
            {
                throw new NotSupportedException();
            }

            var inventory = actor.Person.GetModuleSafe<IInventoryModule>();

            var acts = combatActModule.CalcCombatActs();
            var act = SelectActHelper.SelectBestAct(acts, inventory);

            var isInDistance = act.CheckDistance(actor.Node, target.Node, map);
            var targetIsOnLine = map.TargetIsOnLine(actor.Node, target.Node);

            var attackParams = new AttackParams
            {
                IsAvailable = isInDistance && targetIsOnLine,
                TacticalAct = act
            };

            return attackParams;
        }

        private class AttackParams
        {
            public bool IsAvailable { get; set; }
            public ITacticalAct TacticalAct { get; set; }
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4
5	using Zilon.Core.PersonModules;
6	using Zilon.Core.Persons;
7	using Zilon.Core.Tactics;
8	using Zilon.Core.Tactics.Behaviour;
9	using Zilon.Core.Tactics.Spatial;
10
11	namespace Zilon.Bot.Players.Logics
12	{
13	public sealed class DefeatTargetLogicState : LogicStateBase
14	{
15	private const int REFRESH_COUNTER_VALUE = 3;
16
17	private readonly ITacticalActUsageService _actService;
18
19	private MoveTask _moveTask;
20
21	private int _refreshCounter;
22
23	public DefeatTargetLogicState(ITacticalActUsageService actService)	166✔
24	{
25	_actService = actService ?? throw new ArgumentNullException(nameof(actService));	166!
26	}	166✔
27
28	public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
29	ILogicStrategyData strategyData)
30	{
31	var triggerTarget = strategyData.TriggerIntuder;	364✔
32
33	if (triggerTarget == null)	364!
34	{
35	throw new InvalidOperationException(	×
36	$"Assign {nameof(strategyData.TriggerIntuder)} with not null valie in related trigger.");	×
37	}
38
39	var targetCanBeDamaged = triggerTarget.CanBeDamaged();	364✔
40	if (!targetCanBeDamaged)	364✔
41	{
42	Complete = true;	29✔
43	return null;	29✔
44	}
45
46	var attackParams = CheckAttackAvailability(actor, triggerTarget, context.Sector.Map);	335✔
47	if (attackParams.IsAvailable)	335✔
48	{
49	var act = attackParams.TacticalAct;	144✔
50
51	var taskContext = new ActorTaskContext(context.Sector);	144✔
52
53	var attackTask = new AttackTask(actor, taskContext, triggerTarget, act, _actService);	144✔
54	return attackTask;	144✔
55	}
56
57	// Маршрут до цели обновляем каждые 3 хода.
58	// Для оптимизации.
59	// Эффект потери цели.
60	if (_refreshCounter > 0 && _moveTask?.CanExecute() == true)	191!
61	{
62	_refreshCounter--;	106✔
63	return _moveTask;	106✔
64	}
65
66	var map = context.Sector.Map;	85✔
67	_refreshCounter = REFRESH_COUNTER_VALUE;	85✔
68	var targetIsOnLine = map.TargetIsOnLine(actor.Node, triggerTarget.Node);	85✔
69
70	if (targetIsOnLine)	85!
71	{
72	var taskContext = new ActorTaskContext(context.Sector);	85✔
73
74	_moveTask = new MoveTask(actor, taskContext, triggerTarget.Node, map);	85✔
75	return _moveTask;	85✔
76	}
77
78	// Цел за пределами видимости. Считается потерянной.
UNCOV 79	return null;	×
80	}
81
82	protected override void ResetData()
83	{
84	_refreshCounter = 0;	10,279✔
85	_moveTask = null;	10,279✔
86	}	10,279✔
87
88	private static AttackParams CheckAttackAvailability(IActor actor, IAttackTarget target, ISectorMap map)
89	{
90	var combatActModule = actor.Person.GetModuleSafe<ICombatActModule>();	335✔
91	if (combatActModule is null)	335!
92	{
93	throw new NotSupportedException();	×
94	}
95
96	var inventory = actor.Person.GetModuleSafe<IInventoryModule>();	335✔
97
98	var acts = combatActModule.CalcCombatActs();	335✔
99	var act = SelectActHelper.SelectBestAct(acts, inventory);	335✔
100
101	var isInDistance = act.CheckDistance(actor.Node, target.Node, map);	335✔
102	var targetIsOnLine = map.TargetIsOnLine(actor.Node, target.Node);	335✔
103
104	var attackParams = new AttackParams	335✔
105	{	335✔
106	IsAvailable = isInDistance && targetIsOnLine,	335✔
107	TacticalAct = act	335✔
108	};	335✔
109
110	return attackParams;	335✔
111	}
112
113	private class AttackParams
114	{
115	public bool IsAvailable { get; set; }
116	public ITacticalAct TacticalAct { get; set; }
117	}
118	}
119	}

kreghek / Zilon_Roguelike / 869950998

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