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;
}
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);
}
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;
}
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));
}
}
public WVec(WRange x, WRange y, WRange z)
{
X = x.Range; Y = y.Range; Z = z.Range;
}
// 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));
}
public WPos(WRange x, WRange y, WRange z)
{
X = x.Range; Y = y.Range; Z = z.Range;
}
public WVec(WRange x, WRange y, WRange z)
{
X = x.Range; Y = y.Range; Z = z.Range;
}
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;
}));
}
}
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);
}
// 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));
}
