public static Angle FromPoints(Vector center, Vector v1, Vector v2)
{
var ab = v1 - center;
var bc = v2 - center;
return(FromRadians(MathP.Acos(Vector.Dot(ab, bc) / (ab.Length * bc.Length))));
}
private bool CheckPointsAreStraight(IEnumerable <PointM> points)
{
Angle avgAngle = Angle.FromPoints(points.First().ToVector(), points.Last().ToVector());
avgAngle.Normalize();
double tolerance = Layout.ShouldHaveStraightFrets() ? 2.5 : 1;
//double maxDiff = 0;
for (int i = 1; i < points.Count() - 1; i++)
{
var curAngle = Angle.FromPoints(points.First().ToVector(), points.ElementAt(i).ToVector());
curAngle.Normalize();
var angleDiff = MathP.Abs(curAngle.Degrees - avgAngle.Degrees);
if (angleDiff > tolerance)
{
return(false);
}
//if (angleDiff > maxDiff)
// maxDiff = angleDiff;
}
return(true);
//if (maxDiff >= 1)
// Console.WriteLine(string.Format("max diff for fret {0}: {1}", FretIndex, Angle.FromDegrees(maxDiff)));
//return maxDiff <= tolerance;
}
internal void SetAim(Vector2 dir, bool useArrow = true)
{
aimDirection = dir.normalized;
if (useArrow)
{
hookGameObject.SetActive(true);
hookGameObject.transform.rotation = MathP.RotationFromDirection(-aimDirection);
if (aimDirection.x < 0)
{
hookHeadRenderer.flipY = true;
hookPos.transform.localPosition = new Vector2(hitPosX, -hitPosY);
}
else if (aimDirection.x > 0)
{
hookHeadRenderer.flipY = false;
hookPos.transform.localPosition = new Vector2(hitPosX, hitPosY);
}
}
else
{
hookGameObject.SetActive(false);
}
if (playerController.isGrounded)
{
aimDirection = new Vector2(aimDirection.x, Mathf.Clamp(aimDirection.y, 0, 2));
}
if (!lockBackthrowTarget)
{
backthrowTarget.localPosition = -aimDirection * hookDistance;
}
}
//Construct my unit.
public Unit GetUnit(WaveUnit wu, Dungeon d)
{
//Create our unit to hold the result.
Unit r = null;
if (wu.data.unit != null)
{
r = Unit.NewUnit(wu.data.unit);
}
else
{
r = Unit.NewUnit(d.randomUnits[Random.Range(0, d.randomUnits.Count)]);
}
//Set equips.
EquipUnit(ref r, wu, d);
//Set rank and level.
int ulevel = 1;
if (wu.data.level > 0)
{
ulevel = wu.data.level - 1;
}
else if (level > 0)
{
ulevel = level - 1;
}
else
{
ulevel = d.unitLevel - 1;
}
if (wu.data.rank > 0)
{
r.rank = wu.data.rank;
}
else if (rank > 0)
{
r.rank = rank;
}
else if (d.unitRank > 0)
{
r.rank = d.unitRank;
}
else
{
r.rank = MathP.GetRank(ulevel);
}
r.LevelUp(ulevel);
//Heal the unit.
r.cHP = r.GetmHP();
//Return the result.
return(r);
}
private bool CheckForHardBreak(/*IEnumerable<PointM> points*/)
{
var points = new List <PointM>();
for (int i = 0; i < Segments.Count; i++)
{
if (i == 0)
{
points.Add(Segments[i].P2);
}
points.Add(Segments[i].PointOnString);
if (i == Segments.Count - 1)
{
points.Add(Segments[i].P1);
}
}
int straightCtr = 0;
Vector prevDir = Vector.Empty;
Angle prevAngle = Angle.Empty;
for (int i = 0; i < points.Count - 1; i++)
{
var curDir = (points[i + 1] - points[i]).Direction;
var curAngle = Angle.FromPoints(points[i].ToVector(), points[i + 1].ToVector()).Normalized();
if (!prevAngle.IsEmpty)
{
if (MathP.Abs(curAngle.Degrees - prevAngle.Degrees) > 25)
{
//hard break
SplitFret(i - 1);
return(true);
}
}
if (!prevDir.IsEmpty)
{
if ((prevDir - curDir).Length <= 0.01)
{
straightCtr++;
}
}
prevAngle = curAngle;
prevDir = curDir;
}
return(false);
}
public StringLine ConstructString(SIString str, Measure nutPos, Measure bridgePos)
{
var opp = Measure.Abs(nutPos - bridgePos);
Measure adj = str.ScaleLength;
if (str.LengthCalculationMethod == LengthFunction.AlongString && opp > Measure.Zero)
{
var theta = MathP.Asin(opp.NormalizedValue / str.ScaleLength.NormalizedValue);
adj = MathP.Cos(theta) * str.ScaleLength;
}
var p1 = new PointM(nutPos, (adj / 2d));
var p2 = new PointM(bridgePos, (adj / 2d) * -1d);
return(AddVisualElement(new StringLine(str, p1, p2)));
}
static void Main(string[] args)
{
MathP primath = new MathP();
//Console.WriteLine("- - - - - - -");
//Console.WriteLine("1. Test if a number is prime");
//Console.Write("Number to test: ");
//ulong testNumber = ulong.Parse(Console.ReadLine());
//Console.WriteLine($"{testNumber} result: {primath.IsPrime(testNumber)}");
//Console.WriteLine($"collected {primath.GetCached().Count} :: {PrintCollected(primath.GetCached())}");
//Console.WriteLine("- - - - - - -");
//Console.WriteLine("2. Number of primes up to a number");
//Console.Write("Upper bound (inclusive): ");
//ulong upper = ulong.Parse(Console.ReadLine());
//Console.WriteLine($"up to {upper} result: {PrintList(primath.PrimesBelow(upper))}");
//Console.WriteLine($"collected {primath.GetCached().Count} :: {PrintCollected(primath.GetCached())}");
//Console.WriteLine("- - - - - - -");
//Console.WriteLine("3. Number of primes in a range");
//Console.Write("Lower bound: ");
//ulong lower = ulong.Parse(Console.ReadLine());
//Console.Write("Upper bound: ");
//upper = ulong.Parse(Console.ReadLine());
//Console.WriteLine($"{lower}..{upper} result: {PrintList(primath.PrimesInRange(lower, upper))}");
//Console.WriteLine($"collected {primath.GetCached().Count} :: {PrintCollected(primath.GetCached())}");
Console.WriteLine("- - - - - - -");
Console.WriteLine("4. Factors of a number");
Console.Write("Number: ");
ulong target = ulong.Parse(Console.ReadLine());
Console.WriteLine($"{target} result: {PrintList(primath.Factors(target))}");
Console.WriteLine("- - - - - - -");
Console.WriteLine("5. Prime factors of a number");
Console.Write("Number: ");
target = ulong.Parse(Console.ReadLine());
Console.WriteLine($"{target} result: {PrintList(primath.PrimeFactors(target))}");
}
//Apply status effects.
public void ApplyStatusEffects(Unit t, AttackData data, float variableValue)
{
//For each status effect.
for (int se = 0; se < statusEffects.Length; se++)
{
//Apply elemental advantage.
float hit = hitRoll;
if (MathP.IsElementAdavantage(data.actor.uElement, t.uElement) == 1)
{
hit /= ELEMPLUS;
}
else if (MathP.IsElementAdavantage(data.actor.uElement, t.uElement) == -1)
{
hit /= ELEMMINUS;
}
//Roll.
float rand = Random.Range(0, 100);
if ((rand < statusChances[se] && (hit < ((float)data.actor.GetDEX() / (float)t.GetAGI()) * 100) || !statusEffects[se].isNegative))
{
StatusEffect r = StatusEffect.Instantiate(statusEffects[se]);
if (t == data.actor)
{
r.duration = statusDurations[se] + 1;
}
else
{
r.duration = statusDurations[se];
}
r.applier = data.actor;
r.variableValue = variableValue;
t.AddStatusEffect(r);
}
else if (rand < statusChances[se] && statusEffects[se].isNegative && hit > ((float)data.actor.GetDEX() / (float)t.GetAGI()) * 100)
{
t.textQueue.Add("Resist");
t.textColor.Add(Color.white);
}
}
}
internal void Update()
{
currentPos = transform.position;
dir1 = currentPos - prevPos;
dir1 *= 10;
prevPos = currentPos;
if (rotateToDirection)
{
if (enemyAI.rotateDuringAttack && !enemyAI.doneAttacking)
{
transform.rotation = Quaternion.Slerp(transform.rotation, MathP.RotationFromDirection(-dir1), Time.deltaTime * 5f);
}
else
{
transform.right = rb.velocity;
}
}
else
{
transform.rotation = Quaternion.identity;
RotateGFX(input);
}
}
/// <summary>
/// Calculates the compensated fret positions (takes into account the pitch offset from pressing the string along the fretboard).
/// </summary>
/// <param name="properties">The string's physical properties.</param>
/// <param name="stringLength">The real string length (not the scale length).</param>
/// <param name="openTuning">The tuning of the open string (not fretted).</param>
/// <param name="temperament">The temperament to use.</param>
/// <param name="actionAtFirstFret">Action at the first fret, measured above the fret.</param>
/// <param name="actionAtTwelfthFret">Action at the twelfth fret, measured above the fret.</param>
/// <param name="fretHeight">Fret height. Set to zero for fretless.</param>
/// <param name="numberOfFrets">Number of fret to calculate.</param>
/// <returns>Returns an array of fret positions (distances from the bridge) starting at fret 0 (nut)</returns>
public static Measure[] CalculateFretsCompensatedPositions(StringProperties properties, Measure stringLength, PitchValue openTuning, Temperament temperament,
Measure actionAtFirstFret, Measure actionAtTwelfthFret, Measure fretHeight, int numberOfFrets)
{
var fretPositions = new PreciseDouble[numberOfFrets + 1]; //+1 to include nut and improve readability (e.g. fretPositions[1] = fret #1 instead of fretPositions[0])
var frettedLengths = new PreciseDouble[numberOfFrets + 1]; //+1 to include nut and improve readability (e.g. frettedLengths[1] = fret #1 instead of frettedLengths[0])
var frettedTensions = new PreciseDouble[numberOfFrets + 1]; //+1 to include nut and improve readability (e.g. frettedTensions[1] = fret #1 instead of frettedTensions[0])
var finalFretPositions = new Measure[numberOfFrets + 1];
var fretHeightIn = fretHeight[UnitOfMeasure.Inches];
//Calculate the fret positions
PreciseDouble flatLength = stringLength[UnitOfMeasure.Inches];
for (int i = 1; i <= numberOfFrets; i++)//i=1 to skip the nut
{
var fretRatio = (PreciseDouble)Math.Pow(2, i / 12d);
//fretRatio = GetAdjustedFretRatio(openTuning, i, temperament);
fretPositions[i] = flatLength - (flatLength / fretRatio);
}
var gaugeOffset = (properties.StringDiameter / 2d)[UnitOfMeasure.Inches];
var fret1Action = new Vector(fretPositions[1],
actionAtFirstFret[UnitOfMeasure.Inches] +
fretHeight[UnitOfMeasure.Inches]);
var fret12Action = new Vector(fretPositions[12],
actionAtTwelfthFret[UnitOfMeasure.Inches] +
fretHeight[UnitOfMeasure.Inches]);
var actionLineEq = Line.FromPoints(fret1Action, fret12Action);
var nutPos = actionLineEq.GetPointForX(0);
var saddlePos = actionLineEq.GetPointForX(flatLength);
var saddleToNutDir = (nutPos - saddlePos).Normalized;
frettedLengths[0] = (nutPos - saddlePos).Length;//actual string length
finalFretPositions[0] = Measure.Zero;
PreciseDouble L = frettedLengths[0]; // stringLength[UnitOfMeasure.Inches];
PreciseDouble f = openTuning.Frequency; //Frequency, Hz.
PreciseDouble E = properties.ModulusOfElasticity; //Modulus of Elasticity, core wire, GPa
E *= 145038d; //GPa to PSI
PreciseDouble A = properties.CoreWireArea != 0 ? properties.CoreWireArea : properties.StringArea; //Area, core wire, in²
PreciseDouble mul = properties.UnitWeight; //String mass per unit length, lbs./ inch
PreciseDouble g = 386.089; //Gravity, 386.089 in./ sec²
//Calculate the open string tension: T = (mul * (2* L* f )^2) / g
double T = (mul * Math.Pow((2 * L * f), 2)) / g;
//Calculate "unstressed" string length: Lor = L / ((T / (E * A)) + 1)
double Lor = L / ((T / (E * A)) + 1);
for (int i = 1; i <= numberOfFrets; i++)//i=1 to skip the nut
{
var fretFreq = GetPitchAtFret(openTuning, i, temperament).Frequency;
var fretTopPos = new Vector(fretPositions[i], fretHeightIn);
var prevFretPos = new Vector(fretPositions[i - 1], fretHeightIn);
if (i == 1)
{
prevFretPos.Y = nutPos.Y;
}
var fingerPressPos = new Vector();
fingerPressPos.X = prevFretPos.X;// (fretTopPos.X + prevFretPos.X) / 2d;
if (i == 1)
{
fingerPressPos.X = (fretTopPos.X + prevFretPos.X) / 2d;
}
fingerPressPos.Y = fretHeightIn;
//fingerPressPos.Y = PreciseDouble.Max(fretHeightIn - gaugeOffset, gaugeOffset);
//var fretCenterPos = new Vector(fretPositions[i - 1], i == 1 ? nutPos.Y : fretHeight[UnitOfMeasure.Inches]);
//Calculate the fretted string length : Ls(n) = The sum of the distances between the top of the fret from the nut and saddle
//var Lsn = frettedLengths[i] =
// (saddlePos - fretTopPos).Length +
// (fretTopPos - fingerPressPos).Length +
// (fingerPressPos - nutPos).Length;
var Lsn = frettedLengths[i] =
(saddlePos - fretTopPos).Length +
(fretTopPos - nutPos).Length;
//var Lsn = frettedLengths[i] = (nutPos - fretCenterPos).Length + (fretCenterPos - fretTopPos).Length + (fretTopPos - saddlePos).Length;
//Calculate the fretted string tension : Ts(n) = ((Lsn - Lor) / Lor) * E * A
var Tsn = frettedTensions[i] = ((Lsn - Lor) / Lor) * E * A;
//Calculate fret compensated position: Lfret(n) = SQRT((g * Tsn )/ mul ) / (2 * fn )
var Lfretn = MathP.Sqrt((g * Tsn) / mul) / (2d * fretFreq);
//var opp = saddlePos.Y - fretHeightIn;
//var theta = MathP.Asin(opp / Lfretn);
//var fretDist = MathP.Cos(theta) * Lfretn;
//var pos2D = saddlePos + (saddleToNutDir * Lfretn);
//var testPos = flatLength - fretDist;
var finalPos = flatLength - Lfretn;
fretPositions[i] = finalPos;
finalFretPositions[i] = Measure.Inches(finalPos);
}
return(finalFretPositions);
}
public string ToString(MeasureFormat format)
{
if (IsEmpty)
{
return("N/A");
}
var usedUnit = format.OverrideUnit ?? Unit;
string digitFormat = string.Empty;
if (format.MinimumDecimals > 0 || format.MaximumDecimals > 0)
{
digitFormat = ":0.";
}
if (format.MinimumDecimals > 0)
{
digitFormat = digitFormat.PadRight(3 + format.MinimumDecimals, '0');
}
if (format.MaximumDecimals > 0)
{
digitFormat = digitFormat.PadRight(3 + format.MaximumDecimals, '#');
}
if (usedUnit == null)
{
return(string.Format("{0" + digitFormat + "}", Value));
}
var displayedUnit = format.ShowUnitOfMeasure ? usedUnit.Symbol : string.Empty;
const double sixtyfourth = 0.015625d;
if (usedUnit == UnitOfMeasure.Inches && format.ShowFractions)
{
var value = this[usedUnit];
int whole = (int)MathP.Floor(value);
var remain = value - whole;
if (remain >= sixtyfourth && remain + sixtyfourth < 1d)
{
int sixtyFourCount = 0;
while (remain >= sixtyfourth || Math.Abs(remain - sixtyfourth) < 0.000001)
{
sixtyFourCount++;
remain -= sixtyfourth;
}
int baseFrac = 64;
while ((sixtyFourCount / 2d) % 2d == 0d || (sixtyFourCount / 2d) % 2d == 1d)
{
baseFrac /= 2;
sixtyFourCount /= 2;
}
if ((whole > 0 || remain > sixtyfourth / 2) && (format.AllowApproximation || remain < 0.002))
{
if (whole == 0)
{
return(string.Format("{3}{0}/{1}{2}", sixtyFourCount, baseFrac, displayedUnit, remain > 0.002 ? "~" : string.Empty));
}
else
{
return(string.Format("{0} {4}{1}/{2}{3}", whole, sixtyFourCount, baseFrac, displayedUnit, remain > 0.002 ? "~" : string.Empty));
}
}
}
else if (remain > 0.002 && remain < sixtyfourth && whole > 0 && format.AllowApproximation)
{
return(string.Format("~{0}{1}", whole, displayedUnit));
}
}
else if (usedUnit == UnitOfMeasure.Feets && format.ShowFractions)
{
var value = this[usedUnit];
int whole = (int)MathP.Floor(value);
var remain = value - whole;
if (remain >= sixtyfourth / 12d && format.ShowUnitOfMeasure)
{
return(string.Format("{0}{1} {2}", whole, usedUnit.Symbol, Inches(remain * 12d).ToString(format.Clone())));
}
else if (whole > 0 && remain > 0 && remain < sixtyfourth / 12d && format.AllowApproximation)
{
return(string.Format("~{0}{1}", whole, displayedUnit));
}
}
return(string.Format("{0" + digitFormat + "}{1}", this[usedUnit], displayedUnit));
}
public static Angle FromDirectionVector(Vector vec)
{
var dirVec = vec.Length == 1 ? vec : vec.Normalized;
return(FromRadians(MathP.Atan2(dirVec.Y, dirVec.X)));
}
public static Angle FromPoints(Vector v1, Vector v2)
{
var dirVec = (v2 - v1).Normalized;
return(FromRadians(MathP.Atan2(dirVec.Y, dirVec.X)));
}
public static bool operator ==(Angle a1, Angle a2)
{
return(MathP.Abs(a1.Degrees - a2.Degrees) <= double.Epsilon);
}
public static Vector FromAngle(Angle angle)
{
return(new Vector(MathP.Cos(angle.Radians), MathP.Sin(angle.Radians)));
}
//Make a single attack.
public long AttackTarget(Unit actor, Unit target, AttackData data, bool isCrit, float dmgMod)
{
//If we crit, apply that.
float critmod = 1f;
if (isCrit)
{
critmod = actor.GetCritDMG();
}
//Apply elemental advantage.
float hit = hitRoll;
if (MathP.IsElementAdavantage(actor.uElement, target.uElement) == 1)
{
hit /= ELEMPLUS;
}
else if (MathP.IsElementAdavantage(actor.uElement, target.uElement) == -1)
{
hit /= ELEMMINUS;
}
//Check if we miss.
if (hit < ((float)actor.GetDEX() / (float)target.GetAGI()) * 100)
{
//Roll for damage.
float rowMod = 1;
if (data.actorParty.GetAllUnits().Contains(target))
{
rowMod = data.actorParty.GetRowDamageMod(target);
}
else if (data.defendingParty.GetAllUnits().Contains(target))
{
rowMod = data.defendingParty.GetRowDamageMod(target);
}
long d = MathP.GetDamage((decimal)(GetSkillDamage(actor) * dmgMod), target.GetStat(defenseStat));
d = (long)(Mathf.CeilToInt(d * rowMod));
//Apply elemental advantage.
if (MathP.IsElementAdavantage(actor.uElement, target.uElement) == 1)
{
d = (long)(d * ELEMPLUS);
}
else if (MathP.IsElementAdavantage(actor.uElement, target.uElement) == -1)
{
d = (long)(d * ELEMMINUS);
}
//Deal the damage.
if (target.myStatusEffects.Find(n => n.isCover) == null)
{
target.TakeHit(d, false, critmod, MathP.IsElementAdavantage(actor.uElement, target.uElement));
}
else
{
//Get how much damage is diverted.
for (int i = 0; i < target.myStatusEffects.Count; i++)
{
long diverted = 0;
if (target.myStatusEffects[i].isCover && target.myStatusEffects[i].applier != null)
{
diverted += (long)((target.myStatusEffects[i].variableValue / 100) * (float)d);
Debug.Log("Yes");
//If the diverter is still alive and stuff.
if (target.myStatusEffects[i].applier.IsAlive())
{
target.myStatusEffects[i].applier.TakeHit(diverted, false, 1f);
d -= diverted;
}
}
}
//Finally, deal remaining damage to the target.
target.TakeHit(d, false, critmod, MathP.IsElementAdavantage(actor.uElement, target.uElement));
}
//Take any thorns damage.
if (target.GetThorns(Mathf.CeilToInt((long)(d * critmod))) > 0)
{
actor.TakeHit(target.GetThorns(Mathf.CeilToInt((long)(d * critmod))), false, 1f);
}
return(d);
}
else
{
target.TakeMiss();
return(-1);
}
}
/// <summary>
/// Returns the fret position as the distance from the bridge.
/// </summary>
/// <param name="fret"></param>
/// <returns></returns>
public static PreciseDouble GetEqualTemperedFretPosition(int fret)
{
return((PreciseDouble)1d / MathP.Pow(2, fret / 12d));
}
