870029034

Build Type

github

Committed by GitHub

Commit Message

Merge a499c1036 into 00d2fa5b7

Pull Request Pull Request #1124: Feature 1100 autoplay mode

Run Details

2357 of 3694 branches covered (63.81%)

Branch coverage included in aggregate %.

64 of 77 new or added lines in 16 files covered. (83.12%)

10 existing lines in 8 files now uncovered.

6234 of 8032 relevant lines covered (77.61%)

225106.14 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)	1,435✔
24	{
25	_actService = actService ?? throw new ArgumentNullException(nameof(actService));	1,435!
26	}	1,435✔
27
28	public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
29	ILogicStrategyData strategyData)
30	{
31	var triggerTarget = strategyData.TriggerIntuder;	268✔
32
33	if (triggerTarget == null)	268!
34	{
35	throw new InvalidOperationException(	×
36	$"Assign {nameof(strategyData.TriggerIntuder)} with not null valie in related trigger.");	×
37	}
38
39	var targetCanBeDamaged = triggerTarget.CanBeDamaged();	268✔
40	if (!targetCanBeDamaged)	268✔
41	{
42	Complete = true;	30✔
43	return null;	30✔
44	}
45
46	var attackParams = CheckAttackAvailability(actor, triggerTarget, context.Sector.Map);	238✔
47	if (attackParams.IsAvailable)	238✔
48	{
49	var act = attackParams.TacticalAct;	126✔
50
51	var taskContext = new ActorTaskContext(context.Sector);	126✔
52
53	var attackTask = new AttackTask(actor, taskContext, triggerTarget, act, _actService);	126✔
54	return attackTask;	126✔
55	}
56
57	// Маршрут до цели обновляем каждые 3 хода.
58	// Для оптимизации.
59	// Эффект потери цели.
60	if (_refreshCounter > 0 && _moveTask?.CanExecute() == true)	112!
61	{
62	_refreshCounter--;	56✔
63	return _moveTask;	56✔
64	}
65
66	var map = context.Sector.Map;	56✔
67	_refreshCounter = REFRESH_COUNTER_VALUE;	56✔
68	var targetIsOnLine = map.TargetIsOnLine(actor.Node, triggerTarget.Node);	56✔
69
70	if (targetIsOnLine)	56!
71	{
72	var taskContext = new ActorTaskContext(context.Sector);	56✔
73
74	_moveTask = new MoveTask(actor, taskContext, triggerTarget.Node, map);	56✔
75	return _moveTask;	56✔
76	}
77
78	// Цел за пределами видимости. Считается потерянной.
UNCOV 79	return null;	×
80	}
81
82	protected override void ResetData()
83	{
84	_refreshCounter = 0;	4,918✔
85	_moveTask = null;	4,918✔
86	}	4,918✔
87
88	private static AttackParams CheckAttackAvailability(IActor actor, IAttackTarget target, ISectorMap map)
89	{
90	var combatActModule = actor.Person.GetModuleSafe<ICombatActModule>();	238✔
91	if (combatActModule is null)	238!
92	{
93	throw new NotSupportedException();	×
94	}
95
96	var inventory = actor.Person.GetModuleSafe<IInventoryModule>();	238✔
97
98	var acts = combatActModule.CalcCombatActs();	238✔
99	var act = SelectActHelper.SelectBestAct(acts, inventory);	238✔
100
101	var isInDistance = act.CheckDistance(actor.Node, target.Node, map);	238✔
102	var targetIsOnLine = map.TargetIsOnLine(actor.Node, target.Node);	238✔
103
104	var attackParams = new AttackParams	238✔
105	{	238✔
106	IsAvailable = isInDistance && targetIsOnLine,	238✔
107	TacticalAct = act	238✔
108	};	238✔
109
110	return attackParams;	238✔
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 / 870029034

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