/// <summary>
/// 处理角落的力反馈：攻击角落的敌人，攻击者向远离方向运动
/// </summary>
/// <param name="attacker"></param>
/// <param name="target"></param>
private static void ProcessCornerPush(Entity attacker, Entity target)
{
var hitDef = attacker.GetComponent <HitComponent>().HitDef;
if (UtilityFuncs.GetFrontStageDist(attacker) < new Number(5) / new Number(10) && hitDef.moveContact)
{
Number velX = 0;
if (hitDef.moveGuarded)
{
velX = hitDef.guardVel.X();
}
else if (hitDef.moveHit)
{
var targetMoveComponent = target.GetComponent <MoveComponent>();
if (targetMoveComponent.PhysicsType == PhysicsType.Air)
{
velX = hitDef.airVel.X();
}
else
{
velX = hitDef.groundVel.X();
}
}
var moveComponent = attacker.GetComponent <MoveComponent>();
if (moveComponent.PhysicsType == PhysicsType.Air)
{
moveComponent.VelAdd(-Number.Abs(velX) * hitDef.airCornerPush, 0);
}
else
{
moveComponent.VelAdd(-Number.Abs(velX) * hitDef.groundCornerPush, 0);
}
}
}
public void AssertSystemSolvable(List <Entity> equations, List <VariableEntity> vars, int rootCount = -1)
{
var sys = MathS.Equations(equations.ToArray());
var sol = sys.Solve(vars.ToArray());
Assert.IsTrue(sol.Shape[0] == rootCount || rootCount == -1, "Got " + sol.Shape[0] + " instead of " + rootCount);
for (int i = 0; i < sol.Shape[0]; i++)
{
foreach (var eq in equations)
{
var eqCopy = eq.DeepCopy();
Assert.AreEqual(sol.Shape[1], vars.Count, "Incorrect output of Solve");
for (int rootid = 0; rootid < sol.Shape[1]; rootid++)
{
eqCopy = eqCopy.Substitute(vars[rootid], sol[i, rootid]);
}
foreach (var uniqvar in MathS.Utils.GetUniqueVariables(eqCopy).FiniteSet())
{
eqCopy = eqCopy.Substitute(uniqvar.Name, 3);
}
var E = Number.Abs(eqCopy.Eval());
Assert.IsTrue(E.IsDefinite() && E < 0.0001,
"i: " + i + " eq: " + eq.ToString() + " E: " + E.ToString());
}
}
}
/// <summary>
/// Perform one iteration of searching for a root with Newton-Raphson method
/// </summary>
/// <param name="f"></param>
/// <param name="df"></param>
/// <param name="value"></param>
/// <param name="precision"></param>
/// <returns></returns>
private static ComplexNumber NewtonIter(FastExpression f, FastExpression df, ComplexNumber value, int precision)
{
ComplexNumber prev = value;
int minCheckIters = (int)Math.Sqrt(precision);
for (int i = 0; i < precision; i++)
{
if (i == precision - 1)
{
prev = value.Copy();
}
try // TODO: remove try catch in for
{
value -= (f.Substitute(value) / df.Substitute(value)) as ComplexNumber;
}
catch (MathSException)
{
throw new MathSException("Two or more variables in SolveNt is forbidden");
}
if (i > minCheckIters && prev == value)
{
return(value);
}
}
if (Number.Abs(prev - value) > MathS.Settings.PrecisionErrorCommon)
{
return(RealNumber.NaN());
}
else
{
return(value);
}
}
public static bool IsRectangleCircleOverlap(Vector rectOrigin, Vector rectSize, Number rectRotation, Vector circleOrigin, Number circleRadius)
{
circleOrigin -= rectOrigin;
if (rectRotation != Number.Zero)
{
circleOrigin = Vector.Rotate(Vector.zero, circleOrigin, -rectRotation);
}
var corners = GetRectangleVertices(Vector.zero, rectSize, 0);
circleOrigin.x = Number.Abs(circleOrigin.x);
circleOrigin.y = Number.Abs(circleOrigin.y);
var h = corners[1];
var u = circleOrigin - h;
if (u.x < 0)
{
u.x = 0;
}
if (u.y < 0)
{
u.y = 0;
}
return(Vector.Dot(u, u) <= (circleRadius * circleRadius));
}
public void Test1()
{
var x = MathS.Var("x");
var expr = x;
Assert.IsTrue(Number.Abs(expr.DefiniteIntegral(x, 0, 1).Real - 1.0 / 2) < 0.1);
}
public override bool OverlapBox(Vector origin, Vector size, Number rotation)
{
if (this.rotation == Number.Zero && rotation == Number.Zero)
{
return(Number.Abs(position.x - origin.x) <= (this.size.x + size.x) &&
Number.Abs(position.y - origin.y) <= (this.size.y + size.y));
}
var rect1 = PhysicsUtils.GetRectangleVertices(position, this.size, this.rotation);
var rect2 = PhysicsUtils.GetRectangleVertices(origin, size, rotation);
return(PhysicsUtils.IsRectangleOverlap(rect1, rect2));
}
public static decimal CheckRoots(Entity equation, VariableEntity toSub, Entity varValue)
{
equation = equation.Substitute(toSub, varValue);
var allVars = MathS.Utils.GetUniqueVariables(equation);
foreach (var vr in allVars.FiniteSet())
{
equation = equation.Substitute(vr.Name, 3
/* MUST be integer to correspond to integer coefficient of periodic roots*/);
}
return(Number.Abs(equation.Eval()));
}
// это нашел только один множитель, нужно короче проверить число на простоту, если не простое,
// поделить на результат и потом исследовать получившееся, то есть проверить его на простоту и если нужно найти его
//простой делитель
public Number RoPolland(Number n)
{
Random r = new Random();
Number one = new Number(1);
var insert = r.Next(1, (int)n.Value.First());
Number x = new Number(insert);
Number y = new Number(1);
ulong i = 1;
ulong j = 2;
Number d = GreaterCommonDivider(n, Number.Abs(x - y));
while (d <= one)
{
if (i == j)
{
y = x;
j = j * 2;
}
x = (x * x - one) % n;
i++;
d = GreaterCommonDivider(n, Number.Abs(x - y));
}
return(d);
}
public void AbsTests(double value, double expected)
{
Number v = value;
v.Abs().AssertIsEqualTo(expected);
}
public static Number Abs(Number value)
{
return(value.Abs());
}
public void TestMethod1()
{
Number n = new Number("-125^6");
Assert.AreEqual(125, n.Abs());
}
public void TestMethod3()
{
Number n = new Number("-2");
Assert.AreEqual(2, n.Abs());
}
public void TestMethod2()
{
Number n = new Number("4");
Assert.AreEqual(4, n.Abs());
}
public static Number Distance(Number value1, Number value2)
{
return(Number.Abs(value1 - value2));
}