860934740

Build Type

github

Committed by GitHub

Commit Message

Merge 81686153a into 62f27c124

Pull Request Pull Request #1107: renamed: IEffectsModule to IConditionModule, EffectsModule to Conditi…

Run Details

2315 of 3682 branches covered (62.87%)

Branch coverage included in aggregate %.

46 of 52 new or added lines in 8 files covered. (88.46%)

10 existing lines in 5 files now uncovered.

6169 of 8016 relevant lines covered (76.96%)

97514.67 hits per line

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

68.52

/Zilon.Core/Zilon.Core/Tactics/Behaviour/UsePropHelper.cs

﻿using System;
using System.Diagnostics;
using System.Linq;

using Zilon.Core.PersonModules;
using Zilon.Core.Persons;
using Zilon.Core.Props;
using Zilon.Core.Schemes;

namespace Zilon.Core.Tactics.Behaviour
{
    /// <summary>
    /// Helper class to accumulate code for prop usage.
    /// </summary>
    public static class UsePropHelper
    {
        /// <summary>
        /// Checks a prop allowed to use by restriction rules.
        /// </summary>
        /// <param name="usedProp">The prop to use.</param>
        /// <param name="actor">The actor using the prop.</param>
        /// <param name="context"> The context of usage. </param>
        /// <returns>Returns true if usage allowed. Otherwise - false.</returns>
        public static bool CheckPropAllowedByRestrictions(IProp usedProp, IActor actor, IActorTaskContext context)
        {
            var restrictions = usedProp.Scheme.Use?.Restrictions;
            if (restrictions is null)
            {
                // Prop without restrictions automaticcaly allowed.
                return true;
            }

            if (restrictions.Items is null)
            {
                Debug.Fail("The restriction items can not be null.");

                // There are restrictions but items is null. This is incorrect.
                // We know it restricted but don't know how to check it.
                // So prop is now allowed at all.
                return false;
            }

            foreach (var restriction in restrictions.Items)
            {
                if (restriction is null)
                {
                    continue;
                }

                var isAllowed = CheckPropAllowedByRestriction(restriction.Type, actor, context);

                if (!isAllowed)
                {
                    return false;
                }
            }

            // No restrictions were fired means usage allowed.
            return true;
        }

        private static bool CheckСonditionWithMaxLevel(IActor actor, SurvivalStatType effectType)
        {
            var isRestricted = false;

            var сonditionModule = actor.Person.GetModuleSafe<IConditionModule>();
            if (сonditionModule != null)
            {
                var searchingСondition = сonditionModule.Items.OfType<SurvivalStatHazardEffect>()
                    .SingleOrDefault(x => x.Type == effectType && x.Level == SurvivalStatHazardLevel.Max);

                if (searchingСondition != null)
                {
                    isRestricted = true;
                }
            }

            return isRestricted;
        }

        private static bool CheckPropAllowedByRestriction(UsageRestrictionRule restrictionType, IActor actor,
            IActorTaskContext context)
        {
            switch (restrictionType)
            {
                case UsageRestrictionRule.Undefined:
                    throw new InvalidOperationException(
                        $"Restriction type is {nameof(UsageRestrictionRule.Undefined)}.");

                case UsageRestrictionRule.NoStarvation:
                    return !IsRestrictedByStarvation(actor);
                    
                case UsageRestrictionRule.NoDehydration:
                    return !IsRestrictedByDehydration(actor);
                    
                case UsageRestrictionRule.NoOverdose:
                    return !IsRestrictedByOverdose(actor);

                case UsageRestrictionRule.OnlySafeEnvironment:

                    var hostilesinSector = context.Sector.ActorManager.Items
                        .Where(x => x != actor && actor.Person.Fraction.GetRelation(x.Person.Fraction) ==
                            FractionRelation.Enmity);
                    
                    return !hostilesinSector.Any();

                default:
                    throw new NotSupportedException($"Restriction {restrictionType} is unknown.");
            }
        }

        private static bool IsRestrictedByDehydration(IActor actor)
        {
            return CheckСonditionWithMaxLevel(actor, SurvivalStatType.Hydration);
        }

        private static bool IsRestrictedByOverdose(IActor actor)
        {
            return CheckСonditionWithMaxLevel(actor, SurvivalStatType.Intoxication);
        }

        private static bool IsRestrictedByStarvation(IActor actor)
        {
            return CheckСonditionWithMaxLevel(actor, SurvivalStatType.Satiety);
        }
    }
}

1	using System;
2	using System.Diagnostics;
3	using System.Linq;
4
5	using Zilon.Core.PersonModules;
6	using Zilon.Core.Persons;
7	using Zilon.Core.Props;
8	using Zilon.Core.Schemes;
9
10	namespace Zilon.Core.Tactics.Behaviour
11	{
12	/// <summary>
13	/// Helper class to accumulate code for prop usage.
14	/// </summary>
15	public static class UsePropHelper
16	{
17	/// <summary>
18	/// Checks a prop allowed to use by restriction rules.
19	/// </summary>
20	/// <param name="usedProp">The prop to use.</param>
21	/// <param name="actor">The actor using the prop.</param>
22	/// <param name="context"> The context of usage. </param>
23	/// <returns>Returns true if usage allowed. Otherwise - false.</returns>
24	public static bool CheckPropAllowedByRestrictions(IProp usedProp, IActor actor, IActorTaskContext context)
25	{
26	var restrictions = usedProp.Scheme.Use?.Restrictions;	161!
27	if (restrictions is null)	161✔
28	{
29	// Prop without restrictions automaticcaly allowed.
30	return true;	158✔
31	}
32
33	if (restrictions.Items is null)	3!
34	{
35	Debug.Fail("The restriction items can not be null.");
36
37	// There are restrictions but items is null. This is incorrect.
38	// We know it restricted but don't know how to check it.
39	// So prop is now allowed at all.
40	return false;	×
41	}
42
43	foreach (var restriction in restrictions.Items)	9!
44	{
45	if (restriction is null)	3!
46	{
47	continue;
48	}
49
50	var isAllowed = CheckPropAllowedByRestriction(restriction.Type, actor, context);	3✔
51
52	if (!isAllowed)	3!
53	{
54	return false;	3✔
55	}
56	}
57
58	// No restrictions were fired means usage allowed.
59	return true;	×
60	}
61
62	private static bool CheckСonditionWithMaxLevel(IActor actor, SurvivalStatType effectType)
63	{
64	var isRestricted = false;	3✔
65
66	var сonditionModule = actor.Person.GetModuleSafe<IConditionModule>();	3✔
67	if (сonditionModule != null)	3✔
68	{
69	var searchingСondition = сonditionModule.Items.OfType<SurvivalStatHazardEffect>()	3✔
70	.SingleOrDefault(x => x.Type == effectType && x.Level == SurvivalStatHazardLevel.Max);	3✔
71
72	if (searchingСondition != null)	3✔
73	{
74	isRestricted = true;	3✔
75	}
76	}
77
78	return isRestricted;	3✔
79	}
80
81	private static bool CheckPropAllowedByRestriction(UsageRestrictionRule restrictionType, IActor actor,
82	IActorTaskContext context)
83	{
84	switch (restrictionType)
85	{
86	case UsageRestrictionRule.Undefined:
UNCOV 87	throw new InvalidOperationException(	×
UNCOV 88	$"Restriction type is {nameof(UsageRestrictionRule.Undefined)}.");	×
89
90	case UsageRestrictionRule.NoStarvation:
91	return !IsRestrictedByStarvation(actor);	1✔
92
93	case UsageRestrictionRule.NoDehydration:
94	return !IsRestrictedByDehydration(actor);	1✔
95
96	case UsageRestrictionRule.NoOverdose:
97	return !IsRestrictedByOverdose(actor);	1✔
98
99	case UsageRestrictionRule.OnlySafeEnvironment:
100
NEW 101	var hostilesinSector = context.Sector.ActorManager.Items	×
NEW 102	.Where(x => x != actor && actor.Person.Fraction.GetRelation(x.Person.Fraction) ==	×
NEW 103	FractionRelation.Enmity);	×
104
NEW 105	return !hostilesinSector.Any();	×
106
107	default:
NEW 108	throw new NotSupportedException($"Restriction {restrictionType} is unknown.");	×
109	}
110	}
111
112	private static bool IsRestrictedByDehydration(IActor actor)
113	{
114	return CheckСonditionWithMaxLevel(actor, SurvivalStatType.Hydration);	1✔
115	}
116
117	private static bool IsRestrictedByOverdose(IActor actor)
118	{
119	return CheckСonditionWithMaxLevel(actor, SurvivalStatType.Intoxication);	1✔
120	}
121
122	private static bool IsRestrictedByStarvation(IActor actor)
123	{
124	return CheckСonditionWithMaxLevel(actor, SurvivalStatType.Satiety);	1✔
125	}
126	}
127	}

kreghek / Zilon_Roguelike / 860934740

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