// I've settled on the first prototype being a trail of evenly spaced VERY small dots.
private void RenderRoute(DT_PlayerRole role, PLY_SnapSpot snapSpot)
{
Vector3 vPos = role.mStart;
vPos.z = vPos.y - 1f;
vPos.y = 1f;
vPos += snapSpot.transform.position;
DATA_Route rt = IO_RouteList.FLOAD_ROUTE_BY_NAME(role.mDetail);
for (int i = 0; i + 1 < rt.mSpots.Length; i++)
{
// render a bunch of spots, along the path from a -> b.
Vector3 vStartPos = vPos + UT_VecConversion.ConvertVec2(rt.mSpots[i]);
Vector3 vFinalPos = vPos + UT_VecConversion.ConvertVec2(rt.mSpots[i + 1]);
Vector3 vIterPos = vStartPos;
Vector3 vDir = Vector3.Normalize(vFinalPos - vStartPos);
while (Vector3.Dot(vDir, vFinalPos - vIterPos) > 0f)
{
Instantiate(GFX_RouteTrail, vIterPos, transform.rotation);
vIterPos += vDir * 1f;
}
}
}
public void FDisplayJobs()
{
// Destroy existing jobs.
PE_Route[] oldRoutes = FindObjectsOfType <PE_Route>();
for (int i = 0; i < oldRoutes.Length; i++)
{
oldRoutes[i].FDestroySelf();
}
PE_BlockImg[] blockImages = FindObjectsOfType <PE_BlockImg>();
for (int i = 0; i < blockImages.Length; i++)
{
Destroy(blockImages[i].gameObject);
}
// For all the receivers in the scene, spawn a route object.
// actually, spawn THEIR route, on them.
PE_Role[] roles = FindObjectsOfType <PE_Role>();
foreach (PE_Role role in roles)
{
if (role.mRole == "Route")
{
DATA_Route route = IO_RouteList.FLOAD_ROUTE_BY_NAME(role.mDetails);
if (route == null)
{
Debug.Log("Woah, incorrect route: " + role.mDetails);
return;
}
else
{
PE_Route rt = Instantiate(PF_Route);
rt.mTag = role.mTag;
foreach (Vector2 spot in route.mSpots)
{
Vector2 vSpot = spot;
vSpot /= 10f; // manual conversion, hacky I know.
vSpot += (Vector2)role.transform.position;
// on the player who they belong to.
var node = Instantiate(PF_RouteSpot, vSpot, role.transform.rotation);
rt.mNodes.Add(node);
rt.mLineRenderer.positionCount = rt.mNodes.Count;
Vector3 lineSpot = node.transform.position; lineSpot.z = 0f;
rt.mLineRenderer.SetPosition(rt.mNodes.Count - 1, lineSpot);
}
}
}
else if (role.mRole == "Pass Block" || role.mRole == "Run Block")
{
Vector2 vBlockSpot = role.transform.position;
vBlockSpot.y -= 0.1f; // manual fudge factor.
Instantiate(PF_BlockImage, vBlockSpot, transform.rotation);
}
}
}
// For now we are ignoring the defensive play name.
public void FSetUpPlay(string sOffName, string sDefName, PLY_SnapSpot rSnapSpot)
{
// ------------------------------- LOAD IN PLAYERS
DATA_Play playToRun = IO_PlayList.FLOAD_PLAY_BY_NAME(sOffName);
if (playToRun == null)
{
Debug.Log("No play of that name");
}
// Now we just pretend there were no issues, so we put our players in their spots.
for (int i = 0; i < playToRun.mPlayerRoles.Length; i++)
{
Vector3 vPlayerSpot = new Vector3();
vPlayerSpot.x = playToRun.mPlayerRoles[i].mStart.x;
vPlayerSpot.z = playToRun.mPlayerRoles[i].mStart.y;
vPlayerSpot += rSnapSpot.transform.position;
var clone = Instantiate(PF_OffensivePlayer, vPlayerSpot, transform.rotation);
clone.mJob.mTag = playToRun.mPlayerRoles[i].mTag;
clone.mJob.mRole = playToRun.mPlayerRoles[i].mRole;
clone.mJob.mDetail = playToRun.mPlayerRoles[i].mDetail;
}
int randomDefPlay = Random.Range(0, IO_DefPlays.mPlays.Length);
// DATA_Play defPlay = IO_DefPlays.mPlays[randomDefPlay];
DATA_Play defPlay = IO_DefPlays.FLOAD_PLAY_BY_NAME(sDefName);
PRAC_UI ui = FindObjectOfType <PRAC_UI>();
ui.mDefensivePlayName.text = defPlay.mName;
// spawn a defensive player according to the play.
for (int i = 0; i < defPlay.mPlayerRoles.Length; i++)
{
Vector3 vPlayerSpot = new Vector3();
vPlayerSpot.x = defPlay.mPlayerRoles[i].mStart.x;
vPlayerSpot.z = defPlay.mPlayerRoles[i].mStart.y;
vPlayerSpot += rSnapSpot.transform.position;
var clone = Instantiate(PF_DefensivePlayer, vPlayerSpot, transform.rotation);
clone.mJob.mTag = defPlay.mPlayerRoles[i].mTag;
clone.mJob.mRole = defPlay.mPlayerRoles[i].mRole;
clone.mJob.mDetail = defPlay.mPlayerRoles[i].mDetail;
}
// --------------------------------------------- Set all athletes to waiting for snap.
PRAC_Ath[] athletes = FindObjectsOfType <PRAC_Ath>();
foreach (PRAC_Ath athlete in athletes)
{
athlete.mState = PRAC_Ath.PRAC_ATH_STATE.SPRE_SNAP;
}
// --------------------------------------------- Re-arrange offensive and defensive player pointers left->right.
PRAC_Off[] offenders = FindObjectsOfType <PRAC_Off>();
PRAC_Def[] defenders = FindObjectsOfType <PRAC_Def>();
SortPlayersLeftToRight(offenders);
SortPlayersLeftToRight(defenders);
// -------------------------------------- For route runners, load in their routes.
IO_RouteList.FLOAD_ROUTES();
for (int i = 0; i < offenders.Length; i++)
{
if (offenders[i].mJob.mRole == "Route")
{
// Yep, memory not allocated error if we don't do this here.
offenders[i].GetComponent <OFF_RouteLog>().mRouteSpots = new List <Vector3>();
DATA_Route rt = IO_RouteList.FLOAD_ROUTE_BY_NAME(offenders[i].mJob.mDetail);
foreach (Vector2 routeSpot in rt.mSpots)
{
Vector3 vSpot = offenders[i].transform.position;
vSpot.x += routeSpot.x; vSpot.z += routeSpot.y;
// Also, shove the spot into the receiver, just for now.
offenders[i].GetComponent <OFF_RouteLog>().mRouteSpots.Add(vSpot);
// Instantiate(PF_RouteNode, vSpot, transform.rotation);
}
}
}
// ---------------------------------------------------------- Shove the player "into" the QB character.
for (int i = 0; i < offenders.Length; i++)
{
if (offenders[i].mJob.mTag == "QB")
{
Vector3 vSpot = offenders[i].transform.position;
vSpot.y = 1f;
FindObjectOfType <PC_Controller>().transform.position = vSpot;
}
}
// ------------------------------------------ Now we're assigning the man for man coverage.
// An offense has 5 eligible receivers on every play, so we actually SHOULD go by that, not their routes.
// Update, we've added PRS_AssignMan which globally stores the order that tags should be covered, and the same for defense.
List <PRAC_Off> elibibleRecs = new List <PRAC_Off>();
foreach (PRAC_Off off in offenders)
{
if (PRS_AssignMan.FELIGIBLE_RECEIVER(off.mJob.mTag))
{
elibibleRecs.Add(off);
}
}
elibibleRecs = PRS_AssignMan.FSORT_RECEIVER_IMPORTANCE(elibibleRecs);
List <PRAC_Def> defsInMan = new List <PRAC_Def>();
foreach (PRAC_Def def in defenders)
{
if (def.mJob.mRole == "Man")
{
Debug.Log("Added");
defsInMan.Add(def);
}
}
defsInMan = PRS_AssignMan.FSORT_DEFENDER_IMPORTANCE(defsInMan);
// Now we finally start assigning man coverage responsibility.
for (int i = 0; i < defsInMan.Count; i++)
{
if (elibibleRecs.Count <= 0)
{
break;
}
defsInMan[i].GetComponent <DEF_ManLog>().rMan = elibibleRecs[0];
elibibleRecs.RemoveAt(0);
}
// ---------- ALIGN MAN DEFENDERS TO THE GUY THEY'RE COVERING
for (int i = 0; i < defsInMan.Count; i++)
{
Vector3 vManPos = defsInMan[i].GetComponent <DEF_ManLog>().rMan.transform.position;
vManPos.z += 7f;
defsInMan[i].transform.position = vManPos;
}
}
