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); }