public static OrdinalDir ToSecondOrdinal(Vector2 dir)
{
OrdinalDir first = ToOrdinal(dir);
bool aboveDiagonal = Mathf.Abs(dir.y) > Mathf.Abs(dir.x);
switch (first)
{
default:
case OrdinalDir.S: return((dir.x > 0) ? OrdinalDir.SW : OrdinalDir.SE);
case OrdinalDir.N: return((dir.x > 0) ? OrdinalDir.NW : OrdinalDir.NE);
case OrdinalDir.W: return((dir.y > 0) ? OrdinalDir.SW : OrdinalDir.NW);
case OrdinalDir.E: return((dir.y > 0) ? OrdinalDir.SE : OrdinalDir.NE);
case OrdinalDir.NE: return((aboveDiagonal) ? OrdinalDir.N : OrdinalDir.E);
case OrdinalDir.NW: return((aboveDiagonal) ? OrdinalDir.N : OrdinalDir.W);
case OrdinalDir.SE: return((aboveDiagonal) ? OrdinalDir.S : OrdinalDir.E);
case OrdinalDir.SW: return((aboveDiagonal) ? OrdinalDir.S : OrdinalDir.W);
}
}
public static OrdinalDir OrdinalAdd(OrdinalDir first, OrdinalDir second)
{
int result = (int)first + (int)second;
if (result >= 8)
{
result -= 8;
}
return((OrdinalDir)result);
}
public static Vector2 ToVector(OrdinalDir dir)
{
int dirInt = (int)dir;
if (dirInt >= 0 && dirInt <= 7)
{
return(new Vector2(OrdinalStepX[dirInt], OrdinalStepY[dirInt]));
}
return(Vector2.zero);
}
public static int OrdinalSubtract(OrdinalDir first, OrdinalDir second)
{
// 1 - 8 = -7, -7 +8 ==1
int result = ((int)first - (int)second);
if (result < 0)
{
result += 8;
}
return(result);
}
public static int OrdinalSubtractAbs(OrdinalDir first, OrdinalDir second)
{
// 8 - 1 = 7,
// 1 - 8 = -7, -7 +8 ==1
int diffLeft = ((int)first - (int)second);
int diffRight = ((int)second - (int)first);
if (diffLeft < 0)
{
diffLeft += 8;
}
if (diffRight < 0)
{
diffRight += 8;
}
return(Mathf.Min(diffLeft, diffRight));
}
public static OrdinalDir OrdinalReverse(OrdinalDir dir)
{
switch (dir)
{
default:
case OrdinalDir.S: return(OrdinalDir.N);
case OrdinalDir.N: return(OrdinalDir.S);
case OrdinalDir.W: return(OrdinalDir.E);
case OrdinalDir.E: return(OrdinalDir.W);
case OrdinalDir.NE: return(OrdinalDir.SW);
case OrdinalDir.SW: return(OrdinalDir.NE);
case OrdinalDir.NW: return(OrdinalDir.SE);
case OrdinalDir.SE: return(OrdinalDir.NW);
}
}
public static void SplitIntoOrdinals(Vector2 dir, float overlap, out OrdinalDir best, out OrdinalDir next)
{
// best
// 0 to 22 = N
// 22 to 45 = NE
// 45 to 67 = NE
// 67 to 90 = E
// next
// if overlap 12
// 0 to 10 = N
// 10 to 22 = NE
// 22 to 35 = N
// 35 to 45 = NE
// 45 to 55 = NE
// 55 to 67 = E
// 67 to 80 = NE
// 80 to 90 = E
// North is top right
//OrdinalDir primaryY = dir.y > 0 ? OrdinalDir.W : OrdinalDir.E;
//OrdinalDir primaryX = dir.x > 0 ? OrdinalDir.N : OrdinalDir.S;
//OrdinalDir diagonal = dir.y > 0 ? (dir.x > 0 ? OrdinalDir.NW : OrdinalDir.SW) : (dir.x > 0 ? OrdinalDir.NE : OrdinalDir.SE);
// North is top left
OrdinalDir primaryY = dir.y > 0 ? OrdinalDir.N : OrdinalDir.S;
OrdinalDir primaryX = dir.x > 0 ? OrdinalDir.E : OrdinalDir.W;
OrdinalDir diagonal = dir.y > 0 ? (dir.x > 0 ? OrdinalDir.NE : OrdinalDir.NW) : (dir.x > 0 ? OrdinalDir.SE : OrdinalDir.SW);
float twentytwo = 22.5f;
float lowLine = 22.5f - overlap;
float highLine = 22.5f + overlap;
float absY = Mathf.Abs(dir.y);
float absX = Mathf.Abs(dir.x);
float degY = Mathf.Asin(absY) * 180f / Mathf.PI;
float degX = Mathf.Asin(absX) * 180f / Mathf.PI;
bool doDebug = false;
if (doDebug)
{
Debug.Log(dir.y + " degY" + degY);
Debug.Log(dir.x + " degX" + degX);
}
if (degY < twentytwo)
{
best = primaryX;
next = (degY < lowLine) ? primaryX : diagonal;
if (doDebug)
{
Debug.Log("1=" + best + " " + next);
}
}
else if (degX < twentytwo) // 67 to 90
{
best = primaryY;
next = (degX < lowLine) ? primaryY : diagonal;
if (doDebug)
{
Debug.Log("4=" + best + " " + next);
}
}
else if (degY < degX) // 22 to 45
{
best = diagonal;
next = (degY < highLine) ? primaryX : diagonal;
if (doDebug)
{
Debug.Log("2=" + best + " " + next);
}
}
else //45 to 67
{
best = diagonal;
next = (degX < highLine) ? primaryY : diagonal;
if (doDebug)
{
Debug.Log("3=" + best + " " + next);
}
}
}
