497561582

Build Type

github

Committed by GitHub

Commit Message

Merge 96f68a42c into 1348daebd

Pull Request Pull Request #1013: Prop usage rules

Run Details

2139 of 3412 branches covered (62.69%)

Branch coverage included in aggregate %.

48 of 67 new or added lines in 9 files covered. (71.64%)

28 existing lines in 11 files now uncovered.

5876 of 7652 relevant lines covered (76.79%)

68660.15 hits per line

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

64.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)
            {
                var isAllowed = CheckPropAllowedByRestriction(restriction.Type, actor, context);

                if (!isAllowed)
                {
                    return false;
                }
            }

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

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

            var effectModule = actor.Person.GetModuleSafe<IEffectsModule>();
            if (effectModule != null)
            {
                var searchingEffect = effectModule.Items.OfType<SurvivalStatHazardEffect>()
                    .SingleOrDefault(x => x.Type == effectType && x.Level == SurvivalStatHazardLevel.Max);

                if (searchingEffect != 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:

                    if (IsRestrictedByStarvation(actor))
                    {
                        return false;
                    }

                    break;

                case UsageRestrictionRule.NoDehydration:

                    if (IsRestrictedByDehydration(actor))
                    {
                        return false;
                    }

                    break;

                case UsageRestrictionRule.NoOverdose:

                    if (IsRestrictedByOverdose(actor))
                    {
                        return false;
                    }

                    break;

                case UsageRestrictionRule.OnlySafeEnvironment:

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

                    break;

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

            return true;
        }

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

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

        private static bool IsRestrictedByStarvation(IActor actor)
        {
            return CheckEffectWithMaxLevel(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;	102✔
27	if (restrictions is null)	102✔
28	{
29	// Prop without restrictions automaticcaly allowed.
30	return true;	99✔
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.
NEW 40	return false;	×
41	}
42
43	foreach (var restriction in restrictions.Items)	9!
44	{
45	var isAllowed = CheckPropAllowedByRestriction(restriction.Type, actor, context);	3✔
46
47	if (!isAllowed)	3!
48	{
49	return false;	3✔
50	}
51	}
52
53	// No restrictions were fired means usage allowed.
NEW 54	return true;	×
55	}
56
57	private static bool CheckEffectWithMaxLevel(IActor actor, SurvivalStatType effectType)
58	{
59	var isRestricted = false;	3✔
60
61	var effectModule = actor.Person.GetModuleSafe<IEffectsModule>();	3✔
62	if (effectModule != null)	3✔
63	{
64	var searchingEffect = effectModule.Items.OfType<SurvivalStatHazardEffect>()	3✔
65	.SingleOrDefault(x => x.Type == effectType && x.Level == SurvivalStatHazardLevel.Max);	3✔
66
67	if (searchingEffect != null)	3✔
68	{
69	isRestricted = true;	3✔
70	}
71	}
72
73	return isRestricted;	3✔
74	}
75
76	private static bool CheckPropAllowedByRestriction(UsageRestrictionRule restrictionType, IActor actor,
77	IActorTaskContext context)
78	{
79	switch (restrictionType)
80	{
81	case UsageRestrictionRule.Undefined:
NEW 82	throw new InvalidOperationException(	×
NEW 83	$"Restriction type is {nameof(UsageRestrictionRule.Undefined)}.");	×
84
85	case UsageRestrictionRule.NoStarvation:
86
87	if (IsRestrictedByStarvation(actor))	1!
88	{
89	return false;	1✔
90	}
91
92	break;
93
94	case UsageRestrictionRule.NoDehydration:
95
96	if (IsRestrictedByDehydration(actor))	1!
97	{
98	return false;	1✔
99	}
100
101	break;
102
103	case UsageRestrictionRule.NoOverdose:
104
105	if (IsRestrictedByOverdose(actor))	1!
106	{
107	return false;	1✔
108	}
109
110	break;
111
112	case UsageRestrictionRule.OnlySafeEnvironment:
113
NEW 114	var hostilesinSector = context.Sector.ActorManager.Items	×
NEW 115	.Where(x => x != actor && actor.Person.Fraction.GetRelation(x.Person.Fraction) ==	×
NEW 116	FractionRelation.Enmity);	×
NEW 117	if (hostilesinSector.Any())	×
118	{
NEW 119	return false;	×
120	}
121
122	break;
123
124	default:
NEW 125	throw new NotSupportedException($"Restriction {restrictionType} is unknown.");	×
126	}
127
NEW 128	return true;	×
129	}
130
131	private static bool IsRestrictedByDehydration(IActor actor)
132	{
133	return CheckEffectWithMaxLevel(actor, SurvivalStatType.Hydration);	1✔
134	}
135
136	private static bool IsRestrictedByOverdose(IActor actor)
137	{
138	return CheckEffectWithMaxLevel(actor, SurvivalStatType.Intoxication);	1✔
139	}
140
141	private static bool IsRestrictedByStarvation(IActor actor)
142	{
143	return CheckEffectWithMaxLevel(actor, SurvivalStatType.Satiety);	1✔
144	}
145	}
146	}

kreghek / Zilon_Roguelike / 497561582

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