private bool DoFindPath(TileGrid.FindPathArgs args, DiscreteSpeedMoveable discreteMoveable, out MoveablePath pathForSpeed)
{
List <DubinCSC> path = null;
pathForSpeed = null;
bool pathfound = false;
if (TileGrid.Instance().FindPath(args, out path))
{
pathfound = true;
pathForSpeed = new MoveablePath()
{
path = path,
turnRadius = discreteMoveable.CurrentTurnRadius,
isReverse = discreteMoveable.currentSpeed == Speed.Reverse,
isDirectional = args.IsDirectionalPath,
moveRateCost = 1.0f,
speed = discreteMoveable.currentSpeed
};
}
;
return(pathfound);
}
//bool FindPath(Vector3 dest, Vector3 destDir, out MoveablePath bestMoveablePath)
//{
//}
//bool FindPath(Vector3 dest, out MoveablePath bestMoveablePath)
//{
//}
// TODO: These functions are a bit out of place, steps all over other territory.
// I should probably move'em to a discrete moveable
bool DoFindBestPath(DiscreteSpeedMoveable discreteMoveable, TileGrid.FindPathArgs args, out MoveablePath bestMoveablePath, bool flipBackAfterReverse)
{
bool pathFound = false;
List <DubinCSC> path;
int bestIndex = 0;
float bestDistance = float.MaxValue;
List <DubinCSC> bestPath;
// reverse
// neutral
// combat speed
// full
// check reverse manually, since it has slightly different Args
pathFound |= TileGrid.Instance().FindPath(args, out bestPath);
if (pathFound)
{
bestDistance = TotalDistance(bestPath) * discreteMoveable.SpeedCostArray[0];
}
// flip the fwd/right args for all forward movement
if (flipBackAfterReverse)
{
args.Fwd = -args.Fwd;
args.Right = -args.Right;
}
for (int i = 1; i < discreteMoveable.SpeedCostArray.Length; ++i)
{
// check next
args.TurnRadius = discreteMoveable.TurnRadiusArray[i];
if (TileGrid.Instance().FindPath(args, out path))
{
float nextDistance = TotalDistance(path) * discreteMoveable.SpeedCostArray[i];
if (nextDistance < bestDistance)
{
bestDistance = nextDistance;
bestIndex = i;
bestPath = path;
}
pathFound = true;
}
}
bestMoveablePath = new MoveablePath()
{
path = bestPath,
turnRadius = discreteMoveable.TurnRadiusArray[bestIndex],
isReverse = bestIndex == 0,
isDirectional = args.IsDirectionalPath,
moveRateCost = discreteMoveable.SpeedCostArray[bestIndex],
speed = (Speed)bestIndex
};
return(pathFound);
}
public void Repath()
{
if (this.tileMoveable.CurrentPath != null)
{
DiscreteSpeedMoveable discreteMoveable = tileMoveable.GetComponent <DiscreteSpeedMoveable>();
finalPath = null;
bool bCouldUpdatePath = false;
bool bNeedRepath = false;
if (this.tileMoveable.transform.position == this.transform.position &&
this.tileMoveable.transform.forward == this.transform.forward &&
discreteMoveable.currentSpeed == tileMoveable.CurrentPath.speed)
{
bNeedRepath = false;
}
else
{
bNeedRepath = true;
if (this.tileMoveable.CurrentPath.isDirectional)
{
// Directional search
bCouldUpdatePath
= FindPathAtCurrentSpeed(this.transform.position, this.tileMoveable.CurrentPath.GetEndDirectionVec3(), out finalPath);
}
else
{
// Non-Directional search
bCouldUpdatePath
= FindPathAtCurrentSpeed(this.transform.position, out finalPath);
}
}
if (bNeedRepath)
{
if (!bCouldUpdatePath)
{
SetPositionAndDirection(this.tileMoveable.transform.position, this.tileMoveable.transform.forward);
}
else
{
SetPositionAndDirection(this.transform.position, finalPath.GetEndDirectionVec3());
}
}
this.tileMoveable.CurrentPath = finalPath;
this.UpdatePathLines();
}
}
public void OnPointerClick(PointerEventData eventData)
{
if (eventData.pointerId == kLeftMouse &&
draggingHasOccured == false &&
tileMoveable != null &&
finalPath != null)
{
RaycastHit hitInfo;
Ray ray = Camera.main.ScreenPointToRay(eventData.position);
if (Physics.Raycast(ray, out hitInfo, 1000.0f, widgetLayer))
{
this.tileMoveable.BeginMove();
finalPath = null;
}
}
}
bool FindBestPath(Vector3 dest, out MoveablePath bestMoveablePath)
{
DiscreteSpeedMoveable discreteMoveable = tileMoveable.GetComponent <DiscreteSpeedMoveable>();
// Note: We start out testing reverse first, hence the negatives
var args = new TileGrid.FindPathArgs()
{
Fwd = -tileMoveable.transform.forward,
Right = -tileMoveable.transform.right,
TurnRadius = discreteMoveable.TurnRadiusArray[0],
Pos = tileMoveable.transform.position,
Dest = dest,
BoxCollider = tileMoveable.boxCollider
};
return(DoFindBestPath(discreteMoveable, args, out bestMoveablePath, true));
}
bool FindPathAtCurrentSpeed(Vector3 dest, out MoveablePath pathForSpeed)
{
DiscreteSpeedMoveable discreteMoveable = tileMoveable.GetComponent <DiscreteSpeedMoveable>();
float dir = discreteMoveable.currentSpeed == Speed.Reverse ? -1.0f : 1.0f;
var args = new TileGrid.FindPathArgs()
{
Fwd = dir * tileMoveable.transform.forward,
Right = dir * tileMoveable.transform.right,
TurnRadius = discreteMoveable.CurrentTurnRadius,
Pos = tileMoveable.transform.position,
Dest = dest,
BoxCollider = tileMoveable.boxCollider,
};
return(DoFindPath(args, discreteMoveable, out pathForSpeed));
}
bool FindBestPath(Vector3 dest, Vector3 destDir, out MoveablePath bestMoveablePath)
{
DiscreteSpeedMoveable discreteMoveable = tileMoveable.GetComponent <DiscreteSpeedMoveable>();
// Note: For directional paths, we do NOT flip for reverse movement.
var args = new TileGrid.FindPathArgs()
{
Fwd = -tileMoveable.transform.forward,
Right = -tileMoveable.transform.right,
TurnRadius = discreteMoveable.TurnRadiusArray[0],
Pos = tileMoveable.transform.position,
Dest = dest,
DestDir = destDir,
BoxCollider = tileMoveable.boxCollider,
IsDirectionalPath = true
};
return(DoFindBestPath(discreteMoveable, args, out bestMoveablePath, true));
}
bool FindPathAtCurrentSpeed(Vector3 dest, Vector3 destDir, out MoveablePath pathForSpeed)
{
DiscreteSpeedMoveable discreteMoveable = tileMoveable.GetComponent <DiscreteSpeedMoveable>();
float dir = discreteMoveable.currentSpeed == Speed.Reverse ? -1.0f : 1.0f;
// Note: We start out testing reverse first, hence the negatives
var args = new TileGrid.FindPathArgs()
{
Fwd = dir * tileMoveable.transform.forward,
Right = dir * tileMoveable.transform.right,
TurnRadius = discreteMoveable.CurrentTurnRadius,
Pos = tileMoveable.transform.position,
Dest = dest,
DestDir = destDir,
BoxCollider = tileMoveable.boxCollider,
IsDirectionalPath = true
};
return(DoFindPath(args, discreteMoveable, out pathForSpeed));
}
