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 FShowDefensivePlay(DATA_Play defPlay, PLY_SnapSpot snapSpot)
{
for (int i = 0; i < defPlay.mPlayerRoles.Length; i++)
{
RenderRole(defPlay.mPlayerRoles[i], snapSpot);
}
}
public void FDisplayPlay()
{
DATA_Play ply = IO_PlayList.FLOAD_PLAY_BY_NAME(mPlayName);
if (ply == null)
{
Debug.Log("That play doesn't exist");
return;
}
foreach (DT_PlayerRole guy in ply.mPlayerRoles)
{
var clone = Instantiate(GFX_Player, transform.position, transform.rotation);
Vector2 vGFXSpawn = new Vector2();
vGFXSpawn = guy.mStart;
// Now we do this conversion for the 1000x time.
vGFXSpawn *= rField.GetComponent <RectTransform>().rect.width / 50f; // field is 50 meters.
vGFXSpawn += (Vector2)rField.transform.position;
vGFXSpawn *= 1000f;
GFX_Player gfx = clone.GetComponentInChildren <GFX_Player>();
Debug.Log("Current transform: " + gfx.GetComponent <RectTransform>().position);
clone.GetComponentInChildren <RectTransform>().position = vGFXSpawn;
clone.transform.position = vGFXSpawn;
Debug.Log("New transform: " + gfx.GetComponent <RectTransform>().position);
}
}
// Loads in all plays.
public static void FLOAD_PLAYS()
{
string path = Application.dataPath + "/FILE_IO/Plays/";
string[] fPathNames = Directory.GetFiles(path, "*.bin");
foreach (string sName in fPathNames)
{
Debug.Log(sName);
}
mPlays = new DATA_Play[fPathNames.Length];
for (int i = 0; i < fPathNames.Length; i++)
{
BinaryReader br = new BinaryReader(new FileStream(fPathNames[i], FileMode.Open));
mPlays[i] = new DATA_Play();
mPlays[i].mName = br.ReadString();
// Debug.Log("Play Name: " + mPlays[i].mName);
mPlays[i].mPlayerRoles = new DT_PlayerRole[br.ReadInt32()]; // read in the number of players
for (int j = 0; j < mPlays[i].mPlayerRoles.Length; j++)
{
DT_PlayerRole temp = new DT_PlayerRole();
temp.mTag = br.ReadString();
temp.mRole = br.ReadString();
temp.mDetail = br.ReadString();
temp.mStart.x = br.ReadSingle();
temp.mStart.y = br.ReadSingle();
mPlays[i].mPlayerRoles[j] = temp;
}
}
}
public void BT_SavePlay()
{
if (rPlayInputText.text == string.Empty)
{
Debug.Log("Please enter a play name");
return;
}
// gather up all the defenders in the scene.
PE_Role[] roles = FindObjectsOfType <PE_Role>();
DATA_Play ply = new DATA_Play();
ply.mName = rPlayInputText.text;
ply.mPlayerRoles = new DT_PlayerRole[roles.Length]; // Should always be 11.
Debug.Log("Should be 11: " + ply.mPlayerRoles.Length);
for (int i = 0; i < ply.mPlayerRoles.Length; i++)
{
DT_PlayerRole dtRole = new DT_PlayerRole();
dtRole.mTag = roles[i].mTag;
dtRole.mRole = roles[i].mRole;
dtRole.mDetail = roles[i].mDetails;
dtRole.mStart = roles[i].mStartPos;
ply.mPlayerRoles[i] = dtRole;
}
IO_DefPlays.FWRITE_PLAY(ply);
}
// Fun fact, scriptable objects created at runtime will not be kept.
public DATA_Play FConvertPlayToDATA(string sName)
{
DATA_Play play = new DATA_Play();
play.mName = sName;
// get array of all ED_Roles? Then save them.
PE_Role[] roles = FindObjectsOfType <PE_Role>();
play.mPlayerRoles = new DT_PlayerRole[roles.Length];
for (int i = 0; i < roles.Length; i++)
{
DT_PlayerRole temp = new DT_PlayerRole();
temp.mRole = roles[i].mRole;
// temp.mStart = roles[i].mStartPos;
temp.mTag = roles[i].mTag;
// find the position from the field position.
float fMetersToPixels = 50f / rField.GetComponent <RectTransform>().rect.width; // field is 50 meters
temp.mStart.x = (roles[i].transform.position.x - rField.transform.position.x) / fMetersToPixels;
// adjust for starting on 10.
temp.mStart.y = (roles[i].transform.position.y - rField.transform.position.y) / fMetersToPixels + 15f;
// oh lol, forgot to add detail.
temp.mDetail = roles[i].mDetails;
play.mPlayerRoles[i] = temp;
}
return(play);
}
public static DATA_Play FLOAD_PLAY_BY_NAME(string sName)
{
DATA_Play play = new DATA_Play();
for (int i = 0; i < mPlays.Length; i++)
{
if (mPlays[i].mName == sName)
{
play = mPlays[i];
Debug.Log("Play Name: " + play.mName);
return(play);
}
Debug.Log("Plays loaded: " + mPlays[i].mName);
}
Debug.Log("Play not found: " + sName);
return(null);
}
public static bool FWRITE_PLAY(DATA_Play play)
{
if (play.mName == string.Empty)
{
Debug.Log("Can't save empty play name");
return(false);
}
string sPath = Application.dataPath + "/FILE_IO/Plays/Defense/";
// first check if that play already exists.
string[] fPathNames = Directory.GetFiles(sPath, "*.bin");
sPath += play.mName + ".bin";
foreach (string sName in fPathNames)
{
if (sName == sPath)
{
Debug.Log("Error. Play name conflict.");
Debug.Log("Overwriting anyways");
//return false;
}
}
BinaryWriter bw = new BinaryWriter(new FileStream(sPath, FileMode.Create));
bw.Write(play.mName);
// here's where I write the number of players.
bw.Write(play.mPlayerRoles.Length);
foreach (DT_PlayerRole pRole in play.mPlayerRoles)
{
bw.Write(pRole.mTag);
bw.Write(pRole.mRole);
bw.Write(pRole.mDetail); // this would be things like the specific route, or how to run block.
bw.Write(pRole.mStart.x);
bw.Write(pRole.mStart.y);
}
Debug.Log("Play Saved: " + play.mName);
bw.Close();
return(true);
}
// We also have to destroy the roles currently in the scene.
public void FLoadPlay(DATA_Play play)
{
PE_Role[] roles = FindObjectsOfType <PE_Role>();
for (int i = 0; i < roles.Length; i++)
{
Destroy(roles[i].gameObject);
}
Debug.Log("Play: " + play.mName);
for (int i = 0; i < play.mPlayerRoles.Length; i++)
{
PE_Role role = Instantiate(PF_PlayerRole, transform.position, transform.rotation);
role.mTag = play.mPlayerRoles[i].mTag;
role.mRole = play.mPlayerRoles[i].mRole; // just a string now.
role.mDetails = play.mPlayerRoles[i].mDetail;
role.mStartPos.x = play.mPlayerRoles[i].mStart.x;
role.mStartPos.y = play.mPlayerRoles[i].mStart.y;
// Here I'm making sure that the players always start on whole numbers, even if the play is not saved that way.
role.mStartPos.x = (float)System.Math.Round((double)role.mStartPos.x, 0);
role.mStartPos.y = (float)System.Math.Round((double)role.mStartPos.y, 0);
// okay, now actually make it spawn in the right spot.
// update. I guess we need to work in pixels.
float fMetersToPixels = 50f / rField.GetComponent <RectTransform>().rect.width;
Vector3 vPos = new Vector3();
vPos.x = rField.transform.position.x + role.mStartPos.x * fMetersToPixels;
vPos.y = rField.transform.position.y + role.mStartPos.y * fMetersToPixels;
// set the y to the 10 yard line, normalized. That is where I decided the play starts from.
vPos.y -= 15f * fMetersToPixels;
role.transform.position = vPos;
}
// Since the old ones are garbage now.
cSelector.FGetNewReferences();
}
public void FShowAllPlayRoles(DATA_Play offPlay, DATA_Play defPlay, PLY_SnapSpot snapSpot)
{
FShowOffensivePlay(offPlay, snapSpot);
FShowDefensivePlay(defPlay, snapSpot);
}
// 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;
}
}
