private void RenderRoute(List <Vector2> nodes, Vector3 vStart, PLY_SnapSpot snapSpot)
{
// This should be the actual starting spot of the player.
Vector3 vPos = vStart; vPos.z = vPos.y; vPos.y = 0f;
vPos += snapSpot.transform.position;
Instantiate(GFX_RouteTrail, vPos, transform.rotation);
for (int i = 1; i < nodes.Count; i++)
{
// render a bunch of spots, along the path from a -> b. We're actually going backwards, but it doesn't matter.
Vector3 vINode = UT_VecConversion.ConvertVec2(nodes[i]) * 2f;
vINode.z *= -1f;
Vector3 vIMinusOneNode = UT_VecConversion.ConvertVec2(nodes[i - 1]) * 2f;
vIMinusOneNode.z *= -1f;
Vector3 vStartPos = vPos + vINode;
Vector3 vFinalPos = vPos + vIMinusOneNode;
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;
}
}
}
// 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 FShowOffensivePlay(DATA_OffPlay offPlay, PLY_SnapSpot snapSpot)
{
for (int i = 0; i < offPlay.mRoles.Length; i++)
{
// figure out where they start first.
Vector2 vStart = new Vector2();
DATA_Formation f = IO_Formations.FLOAD_FORMATION(offPlay.mFormation);
for (int j = 0; j < f.mSpots.Length; j++)
{
if (f.mTags[j] == offPlay.mTags[i])
{
vStart = f.mSpots[j];
vStart.y *= -1f;
}
}
if (offPlay.mRoles[i] == "BLOCK")
{
RenderPassBlock(vStart, snapSpot);
}
// We have to first get the route data.
else if (offPlay.mRoles[i] == "ROUTE")
{
for (int j = 0; j < offPlay.mRoutes.Count; j++)
{
if (offPlay.mRoutes[j].mOwner == offPlay.mTags[i])
{
// now we render the route piece by piece.
RenderRoute(offPlay.mRoutes[j].mSpots, vStart, snapSpot);
}
}
}
}
}
public void FActivate()
{
PC_Controller pc = FindObjectOfType <PC_Controller>();
PLY_SnapSpot snap = FindObjectOfType <PLY_SnapSpot>();
mPosToSnapTo = pc.transform.position;
mPosToSnapTo.y += 20f;
if (pc.transform.position.z > snap.transform.position.z)
{
mPosToSnapTo.z += 15f;
}
else
{
mPosToSnapTo.z -= 15f;
}
transform.position = pc.GetComponentInChildren <PC_Camera>().transform.position;
pc.GetComponentInChildren <Camera>().enabled = false;
pc.GetComponentInChildren <AudioListener>().enabled = false;
cCam.enabled = true;
GetComponent <AudioListener>().enabled = true;
pc.mState = PC_Controller.PC_STATE.SINACTIVE;
mState = CAM_STATE.SACTIVE;
}
private void FShowDefensivePlay(DATA_Play defPlay, PLY_SnapSpot snapSpot)
{
for (int i = 0; i < defPlay.mPlayerRoles.Length; i++)
{
RenderRole(defPlay.mPlayerRoles[i], snapSpot);
}
}
public void FSetUpPlayers(string sDefName, PLY_SnapSpot rSnapSpot)
{
DATA_Play p = IO_DefPlays.FLOAD_PLAY_BY_NAME(sDefName);
Debug.Log("About to run: " + p.mName);
List <PRAC_Def_Ply> plys = new List <PRAC_Def_Ply>();
// ------------------------- Old style still has the starting position in there already.
DATA_Play defPlay = IO_DefPlays.FLOAD_PLAY_BY_NAME(sDefName);
// PRAC_UI ui = FindObjectOfType<PRAC_UI>();
// ui.mDefensivePlayName.text = defPlay.mName;
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_DefPlayer, vPlayerSpot, transform.rotation);
clone.mJob.mTag = defPlay.mPlayerRoles[i].mTag;
clone.mJob.mRole = defPlay.mPlayerRoles[i].mRole;
clone.mJob.mDetail = defPlay.mPlayerRoles[i].mDetail;
}
// ----------------------- Figure out who's covering who.
return;
}
private void RenderPassBlock(DT_PlayerRole role, PLY_SnapSpot snapSpot)
{
// Make it just behind the player.
Vector3 vPos = role.mStart;
vPos.z = vPos.y - 1f;
vPos.y = 1f;
vPos += snapSpot.transform.position;
Instantiate(GFX_PassBlock, vPos, transform.rotation);
}
private void RenderRush(DT_PlayerRole role, PLY_SnapSpot snapSpot)
{
// Make it just behind the player.
Vector3 vPos = UT_VecConversion.ConvertVec2(role.mStart);
vPos.z -= 1f;
vPos.y = 1f;
vPos += snapSpot.transform.position;
Instantiate(GFX_Rush, vPos, transform.rotation);
}
private void RUN_Activated()
{
transform.position = transform.position.Hermite(mPosToSnapTo, 0.1f);
// Now we want to look roughly at the snap spot, for now.
PLY_SnapSpot snap = FindObjectOfType <PLY_SnapSpot>();
if (snap != null)
{
transform.LookAt(snap.transform.position, Vector3.up);
}
}
private void RenderRole(DT_PlayerRole role, PLY_SnapSpot snapSpot)
{
switch (role.mRole)
{
case "Zone": RenderZone(role, snapSpot); break;
case "Man": RenderManCover(role, snapSpot); break;
case "Pass Rush": RenderRush(role, snapSpot); break;
case "Pass Block": RenderPassBlock(role, snapSpot); break;
case "Route": RenderRoute(role, snapSpot); break;
}
}
// Again, nothing. Maybe they can slowly walk back to the snap?
protected virtual void RUN_PostPlay()
{
PLY_SnapSpot s = FindObjectOfType <PLY_SnapSpot>();
if (s != null)
{
Vector3 vDis = transform.position - s.transform.position;
vDis = Vector3.Normalize(vDis);
cRigid.velocity = vDis * 0.1f;
}
else
{
cRigid.velocity = Vector3.zero;
}
}
// On deactivate, when we get close is when we actually change everything else.
private void RUN_Deactivating()
{
transform.position = transform.position.Hermite(mPosToSnapTo, 0.2f);
PLY_SnapSpot snap = FindObjectOfType <PLY_SnapSpot>();
if (snap != null)
{
transform.LookAt(snap.transform.position, Vector3.up);
}
if (Vector3.Distance(transform.position, mPosToSnapTo) < 0.1f)
{
TrueDeactivate();
}
}
// Maybe have this as a function that we call.
void Start()
{
cRigid = GetComponent <Rigidbody>();
cAth = GetComponent <PRAC_Ath>();
cAcc = GetComponent <PRAC_AI_Acc>();
cCatchLog = GetComponent <RP_CatchLog>();
if (cAth.mJob.mRole == "Zone")
{
mZoneSpot = IO_ZoneList.FLOAD_ZONE_BY_NAME(cAth.mJob.mDetail).mSpot;
mZoneSpot.z = mZoneSpot.y;
mZoneSpot.y = 0f;
PLY_SnapSpot snap = FindObjectOfType <PLY_SnapSpot>();
mZoneSpot += snap.transform.position;
}
mState = STATE.S_GETTING_TO_SPOT;
}
private void RenderZone(DT_PlayerRole role, PLY_SnapSpot snapSpot)
{
// get the zone details.
DATA_Zone zn = IO_ZoneList.FLOAD_ZONE_BY_NAME(role.mDetail);
GFX_Zone zoneGFX;
if (zn.mSpot.y > 19f)
{
// render using the "deep zone" version.
zoneGFX = GFX_DeepZone;
}
else if (zn.mSpot.y > 9f)
{
// render using mid zone version
zoneGFX = GFX_MidZone;
}
else
{
// render using shallow zone version.
zoneGFX = GFX_ShallowZone;
}
Vector3 vZonePos = snapSpot.transform.position;
vZonePos.z += zn.mSpot.y;
vZonePos.x += zn.mSpot.x;
Instantiate(zoneGFX, vZonePos, transform.rotation);
Vector3 vStartPos = UT_VecConversion.ConvertVec2(role.mStart);
vStartPos += snapSpot.transform.position;
Vector3 vIterPos = vStartPos;
Vector3 vDir = Vector3.Normalize(vZonePos - vStartPos);
while (Vector3.Dot(vDir, vZonePos - vIterPos) > 0f)
{
Instantiate(GFX_ZoneTrail, vIterPos, transform.rotation);
vIterPos += vDir * 0.5f;
}
}
// We're now doing something similar to the zone trail, just spawning little dots to
// a spot in front of the guy we're covering.
// Problem is we're no longer where the play says we should be, since we may have man aligned.
private void RenderManCover(DT_PlayerRole role, PLY_SnapSpot snapSpot)
{
Vector3 vPos = new Vector3();
Vector3 vManSpot = new Vector3();
// Need to get references for all the offensive players in the scene, as well as all the defenders.
PRAC_Off[] offs = FindObjectsOfType <PRAC_Off>();
PRAC_Def[] defs = FindObjectsOfType <PRAC_Def>();
for (int i = 0; i < defs.Length; i++)
{
if (defs[i].mJob.mTag == role.mTag)
{
vPos = defs[i].transform.position;
Instantiate(GFX_ZoneTrail, vPos, transform.rotation);
for (int j = 0; j < offs.Length; j++)
{
if (offs[j].mJob.mTag == defs[i].GetComponent <DEF_ManLog>().rMan.mJob.mTag)
{
vManSpot = offs[j].transform.position;
}
}
}
}
vManSpot.z += 2f;
// So we have our starting and ending position, now make a trail between them.
Vector3 vDir = Vector3.Normalize(vManSpot - vPos);
Vector3 vIterPos = vPos;
while (Vector3.Dot(vDir, vManSpot - vIterPos) > 0f)
{
Instantiate(GFX_ZoneTrail, vIterPos, transform.rotation);
vIterPos += vDir * 1f;
}
}
// 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;
}
}
public void FSetUpPlayers(string sOffName, PLY_SnapSpot rSnapSpot)
{
DATA_OffPlay p = IO_OffensivePlays.FLoadPlay(sOffName);
Debug.Log("About to run: " + p.mName);
DATA_Formation f = IO_Formations.FLOAD_FORMATION(p.mFormation);
Debug.Log("From this formation: " + f.mName);
List <PRAC_Off_Ply> plys = new List <PRAC_Off_Ply>();
// --------------- Set up the players according to the formation.
for (int i = 0; i < f.mTags.Length; i++)
{
Vector3 vSpot = new Vector3();
vSpot.x = f.mSpots[i].x;
vSpot.z = f.mSpots[i].y * -1f;
vSpot.y = 0f;
vSpot += rSnapSpot.transform.position;
var clone = Instantiate(PF_OffPlayer, vSpot, transform.rotation);
clone.mTag = f.mTags[i];
plys.Add(clone);
}
// ---------------- Now give the players their roles.
for (int i = 0; i < p.mTags.Length; i++)
{
for (int j = 0; j < plys.Count; j++)
{
if (plys[j].mTag == p.mTags[i])
{
plys[j].mRole = p.mRoles[i];
}
}
}
// --------------- Assign all the routes to the proper receivers.
for (int i = 0; i < p.mRoutes.Count; i++)
{
for (int j = 0; j < plys.Count; j++)
{
if (plys[j].mTag == p.mRoutes[i].mOwner)
{
plys[j].mSpots = p.mRoutes[i].mSpots;
for (int k = 0; k < plys[j].mSpots.Count; k++)
{
Vector2 v = plys[j].mSpots[k];
v.y *= -1f;
plys[j].mSpots[k] = v;
}
}
}
}
// --------------------------- Shove the player "into" the QB position.
for (int i = 0; i < plys.Count; i++)
{
if (plys[i].mTag == "QB")
{
FindObjectOfType <PC_Controller>().transform.position = plys[i].transform.position;
}
}
return;
}
public void FShowAllPlayRoles(DATA_Play offPlay, DATA_Play defPlay, PLY_SnapSpot snapSpot)
{
FShowOffensivePlay(offPlay, snapSpot);
FShowDefensivePlay(defPlay, snapSpot);
}
