Exemple #1
0
        public static bool TryParse(string s, out WRange result)
        {
            s = s.ToLowerInvariant();
            var components = s.Split('c');
            int cell = 0;
            int subcell = 0;
            result = WRange.Zero;

            switch (components.Length)
            {
            case 2:
                if (!int.TryParse(components[0], out cell) ||
                    !int.TryParse(components[1], out subcell))
                    return false;
                break;
            case 1:
                if (!int.TryParse(components[0], out subcell))
                    return false;
                break;
            default: return false;
            }

            result = new WRange(1024*cell + subcell);
            return true;
        }
Exemple #2
0
        public static bool TryParse(string s, out WRange result)
        {
            s = s.ToLowerInvariant();
            var components = s.Split('c');
            int cell       = 0;
            int subcell    = 0;

            result = WRange.Zero;

            switch (components.Length)
            {
            case 2:
                if (!int.TryParse(components[0], out cell) ||
                    !int.TryParse(components[1], out subcell))
                {
                    return(false);
                }
                break;

            case 1:
                if (!int.TryParse(components[0], out subcell))
                {
                    return(false);
                }
                break;

            default: return(false);
            }

            result = new WRange(1024 * cell + subcell);
            return(true);
        }
Exemple #3
0
        public override bool Equals(object obj)
        {
            if (obj == null)
            {
                return(false);
            }

            WRange o = (WRange)obj;

            return(o == this);
        }
        ///<summary>Evaluates the attractiveness of a position according to all considerations</summary>
        public int GetAttractiveness(WPos pos, Player firedBy)
        {
            var answer = 0;
            var world = firedBy.World;
            var targetTile = world.Map.CellContaining(pos);

            if (!world.Map.Contains(targetTile))
                return 0;

            foreach (var consideration in Considerations)
            {
                var radiusToUse = new WRange(consideration.CheckRadius.Range);

                var checkActors = world.FindActorsInCircle(pos, radiusToUse);
                foreach (var scrutinized in checkActors)
                    answer += consideration.GetAttractiveness(scrutinized, firedBy.Stances[scrutinized.Owner], firedBy);
            }

            return answer;
        }
Exemple #5
0
 public static IEnumerable <Actor> FindActorsInCircle(this World world, WPos origin, WRange r)
 {
     using (new PerfSample("FindUnitsInCircle"))
     {
         // Target ranges are calculated in 2D, so ignore height differences
         var vec = new WVec(r, r, WRange.Zero);
         var rSq = r.Range * r.Range;
         return(world.ActorMap.ActorsInBox(origin - vec, origin + vec).Where(
                    a => (a.CenterPosition - origin).HorizontalLengthSquared <= rSq));
     }
 }
Exemple #6
0
 public WVec(WRange x, WRange y, WRange z)
 {
     X = x.Range; Y = y.Range; Z = z.Range;
 }
Exemple #7
0
 // Sampled a N-sample probability density function in the range [-1024..1024, -1024..1024]
 // 1 sample produces a rectangular probability
 // 2 samples produces a triangular probability
 // ...
 // N samples approximates a true gaussian
 public static WVec FromPDF(MersenneTwister r, int samples)
 {
     return(new WVec(WRange.FromPDF(r, samples), WRange.FromPDF(r, samples), WRange.Zero));
 }
Exemple #8
0
 public WPos(WRange x, WRange y, WRange z)
 {
     X = x.Range; Y = y.Range; Z = z.Range;
 }
Exemple #9
0
 public WVec(WRange x, WRange y, WRange z)
 {
     X = x.Range; Y = y.Range; Z = z.Range;
 }
Exemple #10
0
 public static IEnumerable <Actor> FindActorsInCircle(this World world, WPos origin, WRange r)
 {
     using (new PerfSample("FindUnitsInCircle"))
     {
         // Target ranges are calculated in 2D, so ignore height differences
         var vec = new WVec(r, r, WRange.Zero);
         var rSq = r.Range * r.Range;
         return(world.FindActorsInBox(origin - vec, origin + vec).Where(a =>
         {
             var pos = a.CenterPosition;
             var dx = (long)(pos.X - origin.X);
             var dy = (long)(pos.Y - origin.Y);
             return dx * dx + dy * dy <= rSq;
         }));
     }
 }
Exemple #11
0
 public WPos(WRange x, WRange y, WRange z)
 {
     X = x.Range; Y = y.Range; Z = z.Range;
 }
        public static object GetValue(string fieldName, Type fieldType, string value, MemberInfo field)
        {
            if (value != null)
            {
                value = value.Trim();
            }

            if (fieldType == typeof(int))
            {
                int res;
                if (Exts.TryParseIntegerInvariant(value, out res))
                {
                    return(res);
                }
                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(ushort))
            {
                ushort res;
                if (ushort.TryParse(value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out res))
                {
                    return(res);
                }
                return(InvalidValueAction(value, fieldType, fieldName));
            }

            if (fieldType == typeof(long))
            {
                long res;
                if (long.TryParse(value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out res))
                {
                    return(res);
                }
                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(float))
            {
                float res;
                if (float.TryParse(value.Replace("%", ""), NumberStyles.Float, NumberFormatInfo.InvariantInfo, out res))
                {
                    return(res * (value.Contains('%') ? 0.01f : 1f));
                }
                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(decimal))
            {
                decimal res;
                if (decimal.TryParse(value.Replace("%", ""), NumberStyles.Float, NumberFormatInfo.InvariantInfo, out res))
                {
                    return(res * (value.Contains('%') ? 0.01m : 1m));
                }
                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(string))
            {
                if (field != null && field.HasAttribute <TranslateAttribute>())
                {
                    return(Regex.Replace(value, "@[^@]+@", m => Translate(m.Value.Substring(1, m.Value.Length - 2)), RegexOptions.Compiled));
                }
                return(value);
            }

            else if (fieldType == typeof(Color))
            {
                var parts = value.Split(',');
                if (parts.Length == 3)
                {
                    return(Color.FromArgb(
                               Exts.ParseIntegerInvariant(parts[0]).Clamp(0, 255),
                               Exts.ParseIntegerInvariant(parts[1]).Clamp(0, 255),
                               Exts.ParseIntegerInvariant(parts[2]).Clamp(0, 255)));
                }
                if (parts.Length == 4)
                {
                    return(Color.FromArgb(
                               Exts.ParseIntegerInvariant(parts[0]).Clamp(0, 255),
                               Exts.ParseIntegerInvariant(parts[1]).Clamp(0, 255),
                               Exts.ParseIntegerInvariant(parts[2]).Clamp(0, 255),
                               Exts.ParseIntegerInvariant(parts[3]).Clamp(0, 255)));
                }
                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(HSLColor))
            {
                var parts = value.Split(',');

                // Allow old ColorRamp format to be parsed as HSLColor
                if (parts.Length == 3 || parts.Length == 4)
                {
                    return(new HSLColor(
                               (byte)Exts.ParseIntegerInvariant(parts[0]).Clamp(0, 255),
                               (byte)Exts.ParseIntegerInvariant(parts[1]).Clamp(0, 255),
                               (byte)Exts.ParseIntegerInvariant(parts[2]).Clamp(0, 255)));
                }

                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(Hotkey))
            {
                Hotkey res;
                if (Hotkey.TryParse(value, out res))
                {
                    return(res);
                }

                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(WRange))
            {
                WRange res;
                if (WRange.TryParse(value, out res))
                {
                    return(res);
                }

                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(WVec))
            {
                var parts = value.Split(',');
                if (parts.Length == 3)
                {
                    WRange rx, ry, rz;
                    if (WRange.TryParse(parts[0], out rx) && WRange.TryParse(parts[1], out ry) && WRange.TryParse(parts[2], out rz))
                    {
                        return(new WVec(rx, ry, rz));
                    }
                }

                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(WPos))
            {
                var parts = value.Split(',');
                if (parts.Length == 3)
                {
                    WRange rx, ry, rz;
                    if (WRange.TryParse(parts[0], out rx) && WRange.TryParse(parts[1], out ry) && WRange.TryParse(parts[2], out rz))
                    {
                        return(new WPos(rx, ry, rz));
                    }
                }

                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(WAngle))
            {
                int res;
                if (Exts.TryParseIntegerInvariant(value, out res))
                {
                    return(new WAngle(res));
                }
                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(WRot))
            {
                var parts = value.Split(',');
                if (parts.Length == 3)
                {
                    int rr, rp, ry;
                    if (Exts.TryParseIntegerInvariant(value, out rr) &&
                        Exts.TryParseIntegerInvariant(value, out rp) &&
                        Exts.TryParseIntegerInvariant(value, out ry))
                    {
                        return(new WRot(new WAngle(rr), new WAngle(rp), new WAngle(ry)));
                    }
                }

                return(InvalidValueAction(value, fieldType, fieldName));
            }

            else if (fieldType == typeof(CPos))
            {
                var parts = value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                return(new CPos(
                           Exts.ParseIntegerInvariant(parts[0]),
                           Exts.ParseIntegerInvariant(parts[1])));
            }

            else if (fieldType == typeof(CVec))
            {
                var parts = value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                return(new CVec(
                           Exts.ParseIntegerInvariant(parts[0]),
                           Exts.ParseIntegerInvariant(parts[1])));
            }

            else if (fieldType.IsEnum)
            {
                try
                {
                    return(Enum.Parse(fieldType, value, true));
                }
                catch (ArgumentException)
                {
                    return(InvalidValueAction(value, fieldType, fieldName));
                }
            }

            else if (fieldType == typeof(bool))
            {
                return(ParseYesNo(value, fieldType, fieldName));
            }

            else if (fieldType.IsArray)
            {
                if (value == null)
                {
                    return(Array.CreateInstance(fieldType.GetElementType(), 0));
                }

                var parts = value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                var ret = Array.CreateInstance(fieldType.GetElementType(), parts.Length);
                for (int i = 0; i < parts.Length; i++)
                {
                    ret.SetValue(GetValue(fieldName, fieldType.GetElementType(), parts[i].Trim(), field), i);
                }
                return(ret);
            }

            else if (fieldType == typeof(Size))
            {
                var parts = value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                return(new Size(
                           Exts.ParseIntegerInvariant(parts[0]),
                           Exts.ParseIntegerInvariant(parts[1])));
            }

            else if (fieldType == typeof(int2))
            {
                var parts = value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                return(new int2(
                           Exts.ParseIntegerInvariant(parts[0]),
                           Exts.ParseIntegerInvariant(parts[1])));
            }

            else if (fieldType == typeof(float2))
            {
                var   parts = value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                float xx    = 0;
                float yy    = 0;
                float res;
                if (float.TryParse(parts[0].Replace("%", ""), NumberStyles.Float, NumberFormatInfo.InvariantInfo, out res))
                {
                    xx = res * (parts[0].Contains('%') ? 0.01f : 1f);
                }
                if (float.TryParse(parts[1].Replace("%", ""), NumberStyles.Float, NumberFormatInfo.InvariantInfo, out res))
                {
                    yy = res * (parts[1].Contains('%') ? 0.01f : 1f);
                }
                return(new float2(xx, yy));
            }

            else if (fieldType == typeof(Rectangle))
            {
                var parts = value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                return(new Rectangle(
                           Exts.ParseIntegerInvariant(parts[0]),
                           Exts.ParseIntegerInvariant(parts[1]),
                           Exts.ParseIntegerInvariant(parts[2]),
                           Exts.ParseIntegerInvariant(parts[3])));
            }

            else if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(Bits <>))
            {
                var parts     = value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var argTypes  = new Type[] { typeof(string[]) };
                var argValues = new object[] { parts };
                return(fieldType.GetConstructor(argTypes).Invoke(argValues));
            }

            else if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(Nullable <>))
            {
                var innerType  = fieldType.GetGenericArguments().First();
                var innerValue = GetValue("Nullable<T>", innerType, value, field);
                return(fieldType.GetConstructor(new[] { innerType }).Invoke(new[] { innerValue }));
            }

            else if (fieldType == typeof(DateTime))
            {
                DateTime dt;
                if (DateTime.TryParseExact(value, "yyyy-MM-dd HH-mm-ss", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out dt))
                {
                    return(dt);
                }
                return(InvalidValueAction(value, fieldType, fieldName));
            }

            UnknownFieldAction("[Type] {0}".F(value), fieldType);
            return(null);
        }
Exemple #13
0
 // Sampled a N-sample probability density function in the range [-1024..1024, -1024..1024]
 // 1 sample produces a rectangular probability
 // 2 samples produces a triangular probability
 // ...
 // N samples approximates a true gaussian
 public static WVec FromPDF(Thirdparty.Random r, int samples)
 {
     return(new WVec(WRange.FromPDF(r, samples), WRange.FromPDF(r, samples), WRange.Zero));
 }