public Encounter(TeamComp tc, CachedLog log, Raid r)
{
TC = tc;
Boss = tc.Encounter;
Players = GetPlayersFromLog(log.PlayersNew, r, tc.Encounter);
tc.Success = log.Succsess;
}
private static void AddBoss(Raid raid, Boss boss, CachedLog log)
{
var players = new List <Position>();
var tc = new TeamComp(-1, boss, log.IsCM, players, log.Succsess);
raid.Bosses.Add(tc);
}
public float GetTotalScore(TeamComp teamComp)
{
float score = 0;
int count = 0;
score += GetHardCCScore(teamComp.Champs, out count);
score += GetHardEngageScore(teamComp.Champs, out count);
score += GetDisengageScore(teamComp.Champs, out count);
score += GetPokeScore(teamComp.Champs, out count);
score += GetWaveClearScore(teamComp.Champs, out count);
score += GetTankScore(teamComp.Champs, out count);
score += GetPhysicalScore(teamComp.Champs, out count);
score += GetMagicalScore(teamComp.Champs, out count);
score += GetUtilityScore(teamComp.Champs, out count);
score += GetEarlyScore(teamComp.Champs, out count);
score += GetMidScore(teamComp.Champs, out count);
score += GetLateScore(teamComp.Champs, out count);
score += GetPreferredLaneScore(teamComp.Players);
return(score);
}
public void ChampionChanged(bool shouldUpdate = false)
{
if (!shouldUpdate)
{
return;
}
TeamComp teamComp = default;
teamComp.Players = new List <PlayerData>();
teamComp.Champs = new List <ChampionData>();
for (int i = 0; i < m_PositionControllers.Count; i++)
{
teamComp.Players.Add(m_PositionControllers[i].m_CurrentPlayer);
teamComp.Champs.Add(m_PositionControllers[i].m_CurrentChampion);
}
Score.Instance.GetTotalScore(teamComp);
m_CompMaker.FillScoreText(Score.Instance.GetTotalScore(teamComp));
m_CompMaker.FillCompText(teamComp);
}
public float GetTotalScore(TeamComp teamComp, out int[] champCounts)
{
float score = 0;
List <int> returnChampCounts = new List <int>();
int count = 0;
score += GetHardCCScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetHardEngageScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetDisengageScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetPokeScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetWaveClearScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetTankScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetPhysicalScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetMagicalScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetUtilityScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetEarlyScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetMidScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetLateScore(teamComp.Champs, out count);
returnChampCounts.Add(count);
score += GetPreferredLaneScore(teamComp.Players);
champCounts = returnChampCounts.ToArray();
return(score);
}
public void RollComp()
{
if (!m_CompsMade)
{
PopulateComps();
m_CompsMade = true;
}
List <TeamComp> rolledComps = new List <TeamComp>();
PositionController topPosition = CompDataController.Instance.m_PositionControllers[0];
PositionController junglePosition = CompDataController.Instance.m_PositionControllers[1];
PositionController middlePosition = CompDataController.Instance.m_PositionControllers[2];
PositionController bottomPosition = CompDataController.Instance.m_PositionControllers[3];
PositionController supportPosition = CompDataController.Instance.m_PositionControllers[4];
List <ChampionData> bannedChampions = CompDataController.Instance.m_BannedChampions;
foreach (TeamComp comp in m_TeamComps)
{
if (topPosition.m_IsPlayerLocked && !comp.Players[0].m_PlayerName.Equals(topPosition.m_CurrentPlayer.m_PlayerName))
{
continue;
}
if (junglePosition.m_IsPlayerLocked && !comp.Players[1].m_PlayerName.Equals(junglePosition.m_CurrentPlayer.m_PlayerName))
{
continue;
}
if (middlePosition.m_IsPlayerLocked && !comp.Players[2].m_PlayerName.Equals(middlePosition.m_CurrentPlayer.m_PlayerName))
{
continue;
}
if (bottomPosition.m_IsPlayerLocked && !comp.Players[3].m_PlayerName.Equals(bottomPosition.m_CurrentPlayer.m_PlayerName))
{
continue;
}
if (supportPosition.m_IsPlayerLocked && !comp.Players[4].m_PlayerName.Equals(supportPosition.m_CurrentPlayer.m_PlayerName))
{
continue;
}
if (topPosition.m_IsChampionLocked && !comp.Champs[0].m_ChampionName.Equals(topPosition.m_CurrentChampion.m_ChampionName))
{
continue;
}
if (junglePosition.m_IsChampionLocked && !comp.Champs[1].m_ChampionName.Equals(junglePosition.m_CurrentChampion.m_ChampionName))
{
continue;
}
if (middlePosition.m_IsChampionLocked && !comp.Champs[2].m_ChampionName.Equals(middlePosition.m_CurrentChampion.m_ChampionName))
{
continue;
}
if (bottomPosition.m_IsChampionLocked && !comp.Champs[3].m_ChampionName.Equals(bottomPosition.m_CurrentChampion.m_ChampionName))
{
continue;
}
if (supportPosition.m_IsChampionLocked && !comp.Champs[4].m_ChampionName.Equals(supportPosition.m_CurrentChampion.m_ChampionName))
{
continue;
}
bool containsBanned = false;
for (int i = 0; i < comp.Champs.Count; i++)
{
if (bannedChampions.Contains(comp.Champs[i]))
{
containsBanned = true;
break;
}
}
if (containsBanned)
{
continue;
}
rolledComps.Add(comp);
}
rolledComps = rolledComps.OrderByDescending(x => x.CompScore).ToList <TeamComp>();
float maxScore = rolledComps[0].CompScore;
List <TeamComp> maxScoreComps = new List <TeamComp>();
for (int i = 0; i < rolledComps.Count; i++)
{
if (rolledComps[i].CompScore >= maxScore)
{
maxScoreComps.Add(rolledComps[i]);
}
else
{
break;
}
}
TeamComp bestComp = maxScoreComps[UnityEngine.Random.Range(0, maxScoreComps.Count)];
if (!topPosition.m_IsPlayerLocked)
{
topPosition.AssignPlayer(bestComp.Players[0].m_PlayerName);
}
if (!topPosition.m_IsChampionLocked)
{
topPosition.AssignChampion(bestComp.Champs[0].m_ChampionName);
}
if (!junglePosition.m_IsPlayerLocked)
{
junglePosition.AssignPlayer(bestComp.Players[1].m_PlayerName);
}
if (!junglePosition.m_IsChampionLocked)
{
junglePosition.AssignChampion(bestComp.Champs[1].m_ChampionName);
}
if (!middlePosition.m_IsPlayerLocked)
{
middlePosition.AssignPlayer(bestComp.Players[2].m_PlayerName);
}
if (!middlePosition.m_IsChampionLocked)
{
middlePosition.AssignChampion(bestComp.Champs[2].m_ChampionName);
}
if (!bottomPosition.m_IsPlayerLocked)
{
bottomPosition.AssignPlayer(bestComp.Players[3].m_PlayerName);
}
if (!bottomPosition.m_IsChampionLocked)
{
bottomPosition.AssignChampion(bestComp.Champs[3].m_ChampionName);
}
if (!supportPosition.m_IsPlayerLocked)
{
supportPosition.AssignPlayer(bestComp.Players[4].m_PlayerName);
}
if (!supportPosition.m_IsChampionLocked)
{
supportPosition.AssignChampion(bestComp.Champs[4].m_ChampionName);
}
FillScoreText(bestComp.CompScore);
FillCompText(bestComp);
}
public void PopulateComps()
{
m_TeamComps.Clear();
GC.Collect();
List <List <PlayerData> > players = GetPlayers();
PositionController topPosition = CompDataController.Instance.m_PositionControllers[0];
PositionController junglePosition = CompDataController.Instance.m_PositionControllers[1];
PositionController middlePosition = CompDataController.Instance.m_PositionControllers[2];
PositionController bottomPosition = CompDataController.Instance.m_PositionControllers[3];
PositionController supportPosition = CompDataController.Instance.m_PositionControllers[4];
List <ChampionData> bannedChampions = CompDataController.Instance.m_BannedChampions;
bool sizeExceeded = false;
for (int playerIndex = 0; playerIndex < players.Count; playerIndex++)
{
if (topPosition.m_IsPlayerLocked && !players[playerIndex][0].m_PlayerName.Equals(topPosition.m_CurrentPlayer.m_PlayerName))
{
continue;
}
if (junglePosition.m_IsPlayerLocked && !players[playerIndex][1].m_PlayerName.Equals(junglePosition.m_CurrentPlayer.m_PlayerName))
{
continue;
}
if (middlePosition.m_IsPlayerLocked && !players[playerIndex][2].m_PlayerName.Equals(middlePosition.m_CurrentPlayer.m_PlayerName))
{
continue;
}
if (bottomPosition.m_IsPlayerLocked && !players[playerIndex][3].m_PlayerName.Equals(bottomPosition.m_CurrentPlayer.m_PlayerName))
{
continue;
}
if (supportPosition.m_IsPlayerLocked && !players[playerIndex][4].m_PlayerName.Equals(supportPosition.m_CurrentPlayer.m_PlayerName))
{
continue;
}
for (int top = 0; top < players[playerIndex][0].m_TopChampions.Count; top++)
{
if (topPosition.m_IsChampionLocked && !players[playerIndex][0].m_TopChampions[top].m_ChampionName.Equals(topPosition.m_CurrentChampion.m_ChampionName))
{
continue;
}
for (int jungle = 0; jungle < players[playerIndex][1].m_JungleChampions.Count; jungle++)
{
if (junglePosition.m_IsChampionLocked && !players[playerIndex][1].m_JungleChampions[jungle].m_ChampionName.Equals(junglePosition.m_CurrentChampion.m_ChampionName))
{
continue;
}
for (int middle = 0; middle < players[playerIndex][2].m_MiddleChampions.Count; middle++)
{
if (middlePosition.m_IsChampionLocked && !players[playerIndex][2].m_MiddleChampions[middle].m_ChampionName.Equals(middlePosition.m_CurrentChampion.m_ChampionName))
{
continue;
}
for (int bottom = 0; bottom < players[playerIndex][3].m_BottomChampions.Count; bottom++)
{
if (bottomPosition.m_IsChampionLocked && !players[playerIndex][3].m_BottomChampions[bottom].m_ChampionName.Equals(bottomPosition.m_CurrentChampion.m_ChampionName))
{
continue;
}
for (int support = 0; support < players[playerIndex][4].m_SupportChampions.Count; support++)
{
if (supportPosition.m_IsChampionLocked && !players[playerIndex][4].m_SupportChampions[support].m_ChampionName.Equals(supportPosition.m_CurrentChampion.m_ChampionName))
{
continue;
}
List <ChampionData> loopChampComp = new List <ChampionData>();
loopChampComp.Add(players[playerIndex][0].m_TopChampions[top]);
loopChampComp.Add(players[playerIndex][1].m_JungleChampions[jungle]);
loopChampComp.Add(players[playerIndex][2].m_MiddleChampions[middle]);
loopChampComp.Add(players[playerIndex][3].m_BottomChampions[bottom]);
loopChampComp.Add(players[playerIndex][4].m_SupportChampions[support]);
TeamComp teamComp = new TeamComp();
teamComp.Champs = loopChampComp;
teamComp.Players = players[playerIndex];
teamComp.CompScore = Score.Instance.GetTotalScore(teamComp);
m_TeamComps.Add(teamComp);
if (m_TeamComps.Count > 2000000)
{
sizeExceeded = true;
break;
}
}
if (sizeExceeded)
{
break;
}
}
if (sizeExceeded)
{
break;
}
}
if (sizeExceeded)
{
break;
}
}
if (sizeExceeded)
{
break;
}
}
if (sizeExceeded)
{
break;
}
}
m_TeamComps = m_TeamComps.OrderByDescending(x => x.CompScore).ToList <TeamComp>();
float maxScore = m_TeamComps[0].CompScore;
List <TeamComp> maxScoreComps = new List <TeamComp>();
for (int i = 0; i < m_TeamComps.Count; i++)
{
if (m_TeamComps[i].CompScore >= maxScore)
{
maxScoreComps.Add(m_TeamComps[i]);
}
else
{
break;
}
}
GC.Collect();
}
public void FillCompText(TeamComp comp)
{
int[] compCounts = null;
Score.Instance.GetTotalScore(comp, out compCounts);
string compText = "";
if (compCounts == null)
{
m_CompText.text = "Can't calculate score!";
return;
}
if (compCounts[HARD_CC] < 3)
{
compText += 3 - compCounts[HARD_CC] + " Hard CC,";
}
if (compCounts[HARD_ENGAGE] < 2)
{
compText += 2 - compCounts[HARD_ENGAGE] + " Hard Engage,";
}
if (compCounts[DISENGAGE] < 1)
{
compText += 1 - compCounts[DISENGAGE] + " Disengage,";
}
if (compCounts[POKE] < 1)
{
compText += 1 - compCounts[POKE] + " Poke,";
}
if (compCounts[WAVECLEAR] < 1)
{
compText += 1 - compCounts[WAVECLEAR] + " Wave Clear,";
}
if (compCounts[TANK] < 2)
{
compText += 2 - compCounts[TANK] + " Tank,";
}
if (compCounts[PHYSICAL] < 1)
{
compText += 1 - compCounts[PHYSICAL] + " AD,";
}
if (compCounts[MAGICAL] < 1)
{
compText += 1 - compCounts[MAGICAL] + " AP,";
}
if (compCounts[UTILITY] < 1)
{
compText += 1 - compCounts[UTILITY] + " Utility,";
}
if (compCounts[EARLY_GAME] < 1)
{
compText += 1 - compCounts[EARLY_GAME] + " Early Game,";
}
if (compCounts[MID_GAME] < 1)
{
compText += 1 - compCounts[MID_GAME] + " Mid Game,";
}
if (compCounts[LATE_GAME] < 2)
{
compText += 2 - compCounts[LATE_GAME] + " Late Game,";
}
if (!string.IsNullOrEmpty(compText))
{
compText = compText.Substring(0, compText.Length - 1);
m_CompText.text = "Missing:\n" + compText;
}
else
{
m_CompText.text = "All bases covered!";
}
}
