public static RPColor GetFactionBGColor(PlayerFaction _Faction)
{
if (_Faction == PlayerFaction.Horde)
{
return(RPColor.HordeBG);
}
else if (_Faction == PlayerFaction.Alliance)
{
return(RPColor.AllianceBG);
}
return(RPColor.DarkGray);
}
public static RPColor GetFactionTextColor(PlayerFaction _Faction)
{
if (_Faction == PlayerFaction.Horde)
{
return(RPColor.HordeText);
}
else if (_Faction == PlayerFaction.Alliance)
{
return(RPColor.AllianceText);
}
return(RPColor.Gray);
}
public static string GetFactionLimitStr(PlayerFaction _Faction)
{
if (_Faction == PlayerFaction.Horde)
{
return("Ho");
}
else if (_Faction == PlayerFaction.Alliance)
{
return("Al");
}
else
{
return("All");
}
}
//public void Update(string _PlayerName, PlayerData.Player _PlayerData)
//{
// GuildPlayerStatusHistory playerGuildHistory = null;
// if (m_Players.TryGetValue(_PlayerName, out playerGuildHistory) == false)
// playerGuildHistory = null;
// if (_PlayerData.Guild.GuildName == m_GuildName)
// {
// playerGuildHistory = new GuildPlayerStatusHistory(_PlayerName);
// playerGuildHistory.InitCache(this);
// m_Players.Add(_PlayerName, playerGuildHistory);
// playerGuildHistory.SetGuildData(_PlayerData.Guild, _PlayerData.LastSeen);
// if (m_Faction == Faction.Unknown)
// {
// m_Faction = VF_RealmPlayersDatabase.StaticValues.GetFaction(_PlayerData.Character.Race);
// }
// }
// else if (playerGuildHistory != null)
// {
// playerGuildHistory.SetNotInGuild(_PlayerData.LastSeen);
// }
//}
public void Update(string _PlayerName, PlayerData.PlayerHistory _PlayerData, DateTime _EarliestDateTime)
{
GuildPlayerStatusHistory playerGuildHistory = null;
if (m_Players.TryGetValue(_PlayerName, out playerGuildHistory) == false)
{
playerGuildHistory = null;
}
for (int i = 0; i < _PlayerData.GuildHistory.Count; ++i)
{
var guildHistory = _PlayerData.GuildHistory[i];
if (guildHistory.Uploader.GetTime() < _EarliestDateTime)
{
continue;
}
if (guildHistory.Data.GuildName == m_GuildName)
{
if (playerGuildHistory == null)
{
if (m_Players.TryGetValue(_PlayerName, out playerGuildHistory) == false)
{
playerGuildHistory = new GuildPlayerStatusHistory(_PlayerName);
playerGuildHistory.InitCache(this);
m_Players.Add(_PlayerName, playerGuildHistory);
if (m_Faction == Faction.Unknown || (DateTime.UtcNow - guildHistory.Uploader.GetTime()).TotalDays < 14)
{
if (_PlayerData.CharacterHistory.Count > 0)
{
m_Faction = VF_RealmPlayersDatabase.StaticValues.GetFaction(_PlayerData.GetCharacterItemAtTime(guildHistory.Uploader.GetTime()).Data.Race);
}
}
}
}
playerGuildHistory.SetGuildData(guildHistory.Data, guildHistory.Uploader.GetTime());
}
else if (playerGuildHistory != null)
{
playerGuildHistory.SetNotInGuild(guildHistory.Uploader.GetTime());
}
}
}
public static string ConvertRankVisual(int _Rank, PlayerFaction _Faction)
{
if (_Rank < 0 || _Rank > 14)
{
return("Unknown");
}
if (_Faction == PlayerFaction.Horde)
{
return(VisualResources._HordeRankVisualName[_Rank]);
}
else if (_Faction == PlayerFaction.Alliance)
{
return(VisualResources._AllianceRankVisualName[_Rank]);
}
else
{
return("Unknown");
}
}
public PlayerFaction GetFaction(RealmDB _RealmDB)
{
int hordeCount = 0;
int allianceCount = 0;
var playersFightData = m_Raids.Last().Value.BossFights.Last().PlayerFightData;
foreach (var playerData in playersFightData)
{
var player = _RealmDB.FindPlayer(playerData.Item1);
if (player != null)
{
PlayerFaction playerFaction = VF_RealmPlayersDatabase.StaticValues.GetFaction(player.Character.Race);
if (playerFaction == PlayerFaction.Horde)
{
++hordeCount;
}
else if (playerFaction == PlayerFaction.Alliance)
{
++allianceCount;
}
if (hordeCount - allianceCount > 10)
{
return(PlayerFaction.Horde);
}
else if (allianceCount - hordeCount > 10)
{
return(PlayerFaction.Alliance);
}
}
}
if (hordeCount > allianceCount)
{
return(PlayerFaction.Horde);
}
else
{
return(PlayerFaction.Alliance);
}
}
protected void Page_Load(object sender, EventArgs e)
{
int pageNr = PageUtility.GetQueryInt(Request, "page", 1);
int pageIndex = pageNr - 1;//Change range from 0 to * instead of 1 to *
int count = PageUtility.GetQueryInt(Request, "count", 50);
if (count > 500)
{
count = 500;
}
var realm = RealmControl.Realm;
if (realm == VF_RealmPlayersDatabase.WowRealm.Unknown || realm == VF_RealmPlayersDatabase.WowRealm.All)
{
InstanceControl.SetAllMode();
}
else if (StaticValues.GetWowVersion(realm, true) == VF_RealmPlayersDatabase.WowVersionEnum.TBC)
{
InstanceControl.SetTBCMode();
}
else
{
InstanceControl.SetVanillaMode();
}
string guildStr = PageUtility.GetQueryString(Request, "Guild", null);
if (guildStr != null)
{
this.Title = "Raids for " + guildStr + " | RaidStats";
m_BreadCrumbHTML = new MvcHtmlString(PageUtility.BreadCrumb_AddHome()
+ PageUtility.BreadCrumb_AddRealm(realm)
+ PageUtility.BreadCrumb_AddFinish(guildStr)
+ PageUtility.BreadCrumb_AddFinish("Raids"));
m_RaidListInfoHTML = new MvcHtmlString("<h1>Recorded raids for " + guildStr + "</h1><p>Sorted by the time the raid ended</p><p>"
+ PageUtility.CreateLink("InstanceList.aspx?realm=" + RealmPlayersServer.StaticValues.ConvertRealmParam(realm) + "&Guild=" + guildStr, "Instances statistics by guild") + "</p><p>"
+ PageUtility.CreateLink("BossList.aspx?realm=" + RealmPlayersServer.StaticValues.ConvertRealmParam(realm) + "&Guild=" + guildStr, "Bosses statistics by guild") + "</p><p>"
+ (guildStr != "PUG" ? PageUtility.CreateLink(PageUtility.HOSTURL_Armory + "GuildViewer.aspx?realm=" + RealmPlayersServer.StaticValues.ConvertRealmParam(realm) + "&Guild=" + guildStr, "View guild on RealmPlayers(Armory)") : "") + "</p>");
}
else
{
this.Title = "Raids | RaidStats";
m_BreadCrumbHTML = new MvcHtmlString(PageUtility.BreadCrumb_AddHome()
+ PageUtility.BreadCrumb_AddRealm(realm) + PageUtility.BreadCrumb_AddFinish("Raids"));
m_RaidListInfoHTML = new MvcHtmlString("<h1>All recorded raids</h1><p>Sorted by the time the raid ended</p>");
}
var raidCollection = ApplicationInstance.Instance.GetRaidCollection();
var orderedRaids = raidCollection.m_Raids.OrderByDescending((_Value) => { return(_Value.Value.RaidEndDate); });
m_TableHeadHTML = new MvcHtmlString(
PageUtility.CreateTableRow("",
PageUtility.CreateTableColumnHead("#Nr") +
PageUtility.CreateTableColumnHead("Guild") +
PageUtility.CreateTableColumnHead("Raid Instance(ID)") +
PageUtility.CreateTableColumnHead("Start Date") +
PageUtility.CreateTableColumnHead("End Date") +
PageUtility.CreateTableColumnHead("Realm")));
VF_RaidDamageDatabase.RealmDB realmDB = null;
var guildSummaryDB = ApplicationInstance.Instance.GetGuildSummaryDatabase();
int nr = 0;
int i = orderedRaids.Count();
string tableBody = "";
foreach (var raid in orderedRaids)
{
if (raid.Value.Realm == VF_RealmPlayersDatabase.WowRealm.Test_Server)
{
continue;//Skip Test_Server
}
if (raid.Value.RaidOwnerName == "")
{
continue;//Skip RaidOwnerName == "" because something is obviously wrong!
}
if ((realm == VF_RealmPlayersDatabase.WowRealm.All || realm == raid.Value.Realm) &&
(guildStr == null || guildStr == raid.Value.RaidOwnerName) &&
InstanceControl.IsFiltered(raid.Value.RaidInstance) == true)
{
nr++;
if (nr > pageIndex * count && nr <= (pageIndex + 1) * count)
{
string raidOwnerVisual = raid.Value.RaidOwnerName;
var recordedBy = raid.Value.GetRecordedByPlayers();
if (recordedBy.Count > 0)
{
VF_RealmPlayersDatabase.PlayerFaction faction = VF_RealmPlayersDatabase.PlayerFaction.Unknown;
if (raid.Value.RaidOwnerName != "PUG")
{
try
{
faction = guildSummaryDB.GetGuildSummary(raid.Value.Realm, raid.Value.RaidOwnerName).Faction;
}
catch (Exception)
{}
}
else
{
if (realmDB == null || realmDB.Realm != raid.Value.Realm)
{
realmDB = ApplicationInstance.Instance.GetRealmDB(raid.Value.Realm);
}
faction = RealmPlayersServer.StaticValues.GetFaction(realmDB.GetPlayer(recordedBy.First()).Character.Race);
}
if (faction == VF_RealmPlayersDatabase.PlayerFaction.Horde)
{
raidOwnerVisual = PageUtility.CreateImage("assets/img/Horde_32.png") + raidOwnerVisual;
}
else if (faction == VF_RealmPlayersDatabase.PlayerFaction.Alliance)
{
raidOwnerVisual = PageUtility.CreateImage("assets/img/Alliance_32.png") + raidOwnerVisual;
}
}
tableBody += PageUtility.CreateTableRow("", PageUtility.CreateTableColumn("#" + i) +
PageUtility.CreateTableColumn(PageUtility.CreateLink("RaidList.aspx?realm=" + RealmPlayersServer.StaticValues.ConvertRealmParam(raid.Value.Realm) + "&Guild=" + raid.Value.RaidOwnerName, raidOwnerVisual)) +
PageUtility.CreateTableColumn(PageUtility.CreateLink("RaidOverview.aspx?Raid=" + raid.Value.UniqueRaidID, PageUtility.CreateImage(StaticValues._RaidInstanceImages[raid.Value.RaidInstance]) + " " + raid.Value.RaidInstance + "(" + raid.Value.RaidID + ")")) +
PageUtility.CreateTableColumn(raid.Value.RaidStartDate.ToLocalTime().ToString("yyy-MM-dd HH:mm:ss")) +
PageUtility.CreateTableColumn(raid.Value.RaidEndDate.ToLocalTime().ToString("yyy-MM-dd HH:mm:ss")) +
PageUtility.CreateTableColumn(RealmPlayersServer.StaticValues.ConvertRealmViewing(raid.Value.Realm)));
}
if (nr >= (pageIndex + 1) * count)
{
break;
}
}
--i;
}
if (nr != 0 && nr <= pageIndex * count)
{
pageIndex = (nr - 1) / count;
Response.Redirect(PageUtility.CreateUrlWithNewQueryValue(Request, "page", (pageIndex + 1).ToString()));
}
m_TableBodyHTML = new MvcHtmlString(tableBody);
m_PaginationHTML = new MvcHtmlString(PageUtility.CreatePagination(Request, pageNr, ((orderedRaids.Count() - 1) / count) + 1));
}
public static string GetFactionCSSName(PlayerFaction _Faction)
{
return(VisualResources._FactionCSSName[_Faction]);
}
public static string GetFactionIMG(PlayerFaction _Faction)
{
return(VisualResources._FactionImgUrl[_Faction]);
}
public static string ConvertRankVisualWithNr(int _Rank, PlayerFaction _Faction)
{
return(ConvertRankVisual(_Rank, _Faction) + "(" + _Rank + ")");
}
protected void Page_Load(object sender, EventArgs e)
{
string sectionStr = PageUtility.GetQueryString(Request, "section", "ranks");
int count = PageUtility.GetQueryInt(Request, "count", 100);
if (count > 500)
{
count = 500;
}
var realm = RealmControl.Realm;
if (realm == WowRealm.Unknown)
{
return;
}
var wowVersion = StaticValues.GetWowVersion(realm);
PlayerColumn[] lifetimeKillsColumns = Table_Lifetime_Kills_Columns;
PlayerColumn[] rankColumns = Table_Ranks_Columns;
Func <KeyValuePair <string, Player>, double> rankSorterLambda = (KeyValuePair <string, Player> _Player) => { return(_Player.Value.GetRankTotal()); };
Func <Player, bool> rankShowLambda = (Player _Player) => { return(_Player.ReceivedStandingLastWeek() == true && ((DateTime.UtcNow - _Player.LastSeen).TotalDays <= 7.0)); };
if (wowVersion == VF_RealmPlayersDatabase.WowVersionEnum.TBC)
{
lifetimeKillsColumns = Table_Lifetime_Kills_Columns_TBC;
rankColumns = Table_Ranks_Columns_TBC;
rankSorterLambda = (KeyValuePair <string, Player> _Player) => {
return(_Player.Value.GetArenaRatingTotal());
};
rankShowLambda = (Player _Player) => {
return(_Player.Arena != null);
};
}
if (sectionStr == "standings")
{
this.Title = "Standings @ " + StaticValues.ConvertRealmParam(realm) + " | RealmPlayers";
m_PageHTML = new MvcHtmlString(CreateStandingsTable(realm, count, (player) => { return(player.ReceivedStandingLastWeek()); }));
if (wowVersion == VF_RealmPlayersDatabase.WowVersionEnum.TBC)
{
GeneratePageDetails("Standings", count * 2, "TBC works with a different PVP system so there are no standings.");
}
else
{
var rankUpdateDay = StaticValues.GetRankUpdadeDayType(realm);
switch (rankUpdateDay)
{
case VF_RealmPlayersDatabase.StaticValues.RankUpdateDayType.Wednesday_Morning:
GeneratePageDetails("Standings", count * 2, "Last weeks standings for players. Only shows players who received a standing last week. This list resets when the realm calculates new standings for players every wednesday morning.");
break;
case VF_RealmPlayersDatabase.StaticValues.RankUpdateDayType.Wednesday_Midday:
GeneratePageDetails("Standings", count * 2, "Last weeks standings for players. Only shows players who received a standing last week. This list resets when the realm calculates new standings for players every wednesday.");
break;
case VF_RealmPlayersDatabase.StaticValues.RankUpdateDayType.Sunday_Midnight:
GeneratePageDetails("Standings", count * 2, "Last weeks standings for players. Only shows players who received a standing last week. This list resets when the realm calculates new standings for players every sunday midnight.");
break;
default:
break;
}
}
}
else if (sectionStr == "twink_ranks")
{
this.Title = "Twinks @ " + StaticValues.ConvertRealmParam(realm) + " | RealmPlayers";
m_PageHTML = new MvcHtmlString(CreatePVPTable(realm, count, Table_Twink_Ranks_Columns
, (KeyValuePair <string, Player> _Player) => { return(_Player.Value.GetRankTotal()); }
, (Player _Player) => { return(_Player.Character.Level > 10 && _Player.Character.Level < 60 && _Player.Honor.CurrentRank > 0 && (DateTime.UtcNow - _Player.LastSeen).TotalDays <= 30); }));
GeneratePageDetails("Twinks", count, "PVP Ranks for players that are below lvl 60. This is meant to show active twinks on the realm. Only shows players that was seen less than 30 days ago");
}
else if (sectionStr == "lifetime_kills")
{
this.Title = "Lifetime Kills @ " + StaticValues.ConvertRealmParam(realm) + " | RealmPlayers";
m_PageHTML = new MvcHtmlString(CreatePVPTable(realm, count, lifetimeKillsColumns
, (KeyValuePair <string, Player> _Player) => { return(_Player.Value.Honor.LifetimeHK); }
, (Player _Player) => { return(true); }));
GeneratePageDetails("Lifetime Kills", count, "List sorted by the amount of total honorable kills received. This is to show the players who have pvped the most overall.");
}
else if (sectionStr == "highest_ranks")
{
this.Title = "Highest Ranks @ " + StaticValues.ConvertRealmParam(realm) + " | RealmPlayers";
if (wowVersion == VF_RealmPlayersDatabase.WowVersionEnum.TBC)
{
m_PageHTML = new MvcHtmlString("");
GeneratePageDetails("Highest Ranks", count, "TBC works with a different PVP system so there are no lifetime highest ranks.");
}
else
{
var playerSummaryDB = Hidden.ApplicationInstance.Instance.GetPlayerSummaryDatabase();
var pvpSummaries = playerSummaryDB.GetPVPSummaries(realm);
DateTime referenceDateTime = new DateTime(2010, 1, 1);
var orderedPVPSummaries = pvpSummaries.OrderByDescending((_Value) => ((int)_Value.Value.m_HighestRank.Key) * 100000 - (_Value.Value.m_HighestRank.Value != DateTime.MinValue ? (int)((_Value.Value.m_HighestRank.Value - referenceDateTime).TotalDays) : 0));
//////////////////////////////////
int pageIndex = PageUtility.GetQueryInt(Request, "page", 1) - 1;//Change range from 0 to * instead of 1 to *
PlayerColumn[] playerColumns = new PlayerColumn[] {
PlayerColumn.Number,
PlayerColumn.Character_And_Guild,
PlayerColumn.Race_And_Class,
PlayerColumn.Total_HKs,
PlayerColumn.LastSeen,
};
Dictionary <PlayerColumn, string[]> extraColumns = new Dictionary <PlayerColumn, string[]>();
extraColumns[PlayerColumn.Number] = new string[] { "Rank", "Date Achieved" };
//extraColumns[PlayerColumn.Total_HKs] = new string[] { "Weeks with standing" };
string table = "<table class='table'>";
table += "<thead>" + PageUtility.CreatePlayerTableHeaderRow(playerColumns, extraColumns) + "</thead>";
table += "<tbody>";
var playerArray = DatabaseAccess.GetRealmPlayers(this, realm, NotLoadedDecision.RedirectAndWait);
int nr = 0;
foreach (var pvpSummary in orderedPVPSummaries)
{
nr++;
if (nr > pageIndex * count && nr <= (pageIndex + 1) * count)
{
Player playerData = null;
if (playerArray.TryGetValue(playerSummaryDB.GetPlayer(pvpSummary), out playerData) == true)
{
VF_RealmPlayersDatabase.PlayerFaction playerFaction = StaticValues.GetFaction(playerData.Character.Race);
int rank = (int)pvpSummary.Value.m_HighestRank.Key;
float rankProgress = pvpSummary.Value.m_HighestRank.Key - (float)rank;
extraColumns[PlayerColumn.Number] = new string[] { PageUtility.CreatePlayerRankDiv(rank, rankProgress, playerFaction), pvpSummary.Value.m_HighestRank.Value.ToString("yyyy-MM-dd") };
//extraColumns[PlayerColumn.Total_HKs] = new string[] { pvpSummary.Value.m_ActivePVPWeeks.ToString() };
table += PageUtility.CreatePlayerRow(nr, realm, playerData, playerColumns, null, extraColumns);
}
}
if (nr >= (pageIndex + 1) * count)
{
break;
}
}
table += "</tbody></table>";
if (nr != 0 && nr <= pageIndex * count)
{
pageIndex = (nr - 1) / count;
Response.Redirect(PageUtility.CreateUrlWithNewQueryValue(Request, "page", (pageIndex + 1).ToString()));
}
m_PageHTML = new MvcHtmlString(table);
//////////////////////////////////
GeneratePageDetails("Highest Ranks", count, "Highest lifetime achieved PVP Ranks for players, sorted by date of achievment");
}
}
else// if (sectionStr == "ranks")
{
this.Title = "Ranks @ " + StaticValues.ConvertRealmParam(realm) + " | RealmPlayers";
if (realm == WowRealm.Nostalrius || realm == WowRealm.NostalriusPVE)
{
rankShowLambda = (Player _Player) =>
{
return((DateTime.UtcNow - _Player.LastSeen).TotalDays < 14);
};
GeneratePageDetails("Ranks", count, "Highest PVP Ranks for active players.");
}
else if (wowVersion == VF_RealmPlayersDatabase.WowVersionEnum.TBC)
{
GeneratePageDetails("Arena Ranking", count, "Shows the highest rated arena teams, sorted by a sum of the total rating for 5v5, 3v3 and 2v2.");
}
else
{
GeneratePageDetails("Ranks", count, "Highest PVP Ranks for players. Only lists players who received standing last week. This is because no rank decay would make the list extremely boring(filled with players that dont even pvp).");
}
m_PageHTML = new MvcHtmlString(CreatePVPTable(realm, count, rankColumns
, rankSorterLambda, rankShowLambda));
}
//href='javascript:navigateWithNewQuery(\"page\",\"1\")'
int pageNr = PageUtility.GetQueryInt(Request, "page", 1);
int maxPageNr = 1000000 / count;
m_PaginationHTML = new MvcHtmlString(PageUtility.CreatePagination(Request, pageNr, maxPageNr));
}
protected void Page_Load(object sender, EventArgs e)
{
string fightName = PageUtility.GetQueryString(Request, "FightName");
List <PlayerClass> classLimits = ClassControl.GetClassLimits();//PageUtility.GetQueryString(Request, "ClassLimit", "WrIWaIWlIMaIPrIShIRoIPaIDrIHu"));
List <PlayerFaction> factionLimits = ClassControl.GetFactionLimits();
bool showMultipleEntries = PageUtility.GetQueryString(Request, "MultipleEntries", "false").ToLower() != "false";
string guildLimit = PageUtility.GetQueryString(Request, "Guild", null);
string playerLimit = PageUtility.GetQueryString(Request, "PlayerLimit", null);
string andPlayer = PageUtility.GetQueryString(Request, "AndPlayer", null);
int showEntriesCount = PageUtility.GetQueryInt(Request, "Count", 50);
if (showEntriesCount > 100)
{
showEntriesCount = 100;
}
var realm = RealmControl.Realm;
var realmDB = ApplicationInstance.Instance.GetRealmDB(VF_RealmPlayersDatabase.WowRealm.Emerald_Dream);
//var raidCollection = ApplicationInstance.Instance.GetRaidCollection();
var summaryDatabase = ApplicationInstance.Instance.GetSummaryDatabase();
if (summaryDatabase == null)
{
return;
}
if (guildLimit != null)
{
this.Title = fightName + " Highscore for " + guildLimit + " | RaidStats";
}
else if (playerLimit != null)
{
this.Title = fightName + " Highscore for " + playerLimit + " | RaidStats";
}
else
{
this.Title = fightName + " Highscore | RaidStats";
}
IEnumerable <VF_RaidDamageDatabase.Models.PurgedPlayer> purgePlayers = ApplicationInstance.Instance.GetPurgedPlayers(realm);
var fightInstances = summaryDatabase.GetHSElligibleBossFights(fightName, realm, guildLimit, null, purgePlayers);
//Remove fights that have too low precision
if (fightInstances.Count > 0)
{
string breadCrumbCommon = "";
if (guildLimit != null)
{
breadCrumbCommon = PageUtility.BreadCrumb_AddHome()
+ PageUtility.BreadCrumb_AddRealm(realm)
+ PageUtility.BreadCrumb_AddLink("RaidList.aspx?Guild=" + guildLimit, guildLimit)
+ PageUtility.BreadCrumb_AddLink("BossList.aspx?Guild=" + guildLimit, "Bosses");
}
else if (playerLimit != null)
{
breadCrumbCommon = PageUtility.BreadCrumb_AddHome()
+ PageUtility.BreadCrumb_AddRealm(realm)
+ PageUtility.BreadCrumb_AddLink("PlayerOverview.aspx?realm=" + RealmPlayersServer.StaticValues.ConvertRealmParam(realm) + "&player=" + playerLimit, playerLimit)
+ PageUtility.BreadCrumb_AddLink("BossList.aspx?realm=" + RealmPlayersServer.StaticValues.ConvertRealmParam(realm) + "&player=" + playerLimit, "Bosses");
}
else
{
breadCrumbCommon = PageUtility.BreadCrumb_AddHome()
+ PageUtility.BreadCrumb_AddRealm(realm)
+ PageUtility.BreadCrumb_AddLink("BossList.aspx", "Bosses");
}
if (ClassControl.HasClassLimits() == true)
{
string colorClasses = ClassControl.GetColorClassesStr();
string breadCrumb = breadCrumbCommon + PageUtility.BreadCrumb_AddThisPageWithout(fightName, Request, "ClassLimit");
if (ClassControl.HasFactionLimits() == true)
{
breadCrumb += PageUtility.BreadCrumb_AddFinish("vs " + colorClasses);
breadCrumb += PageUtility.BreadCrumb_AddFinish("Only " + ClassControl.GetColorFactionStr());
}
else
{
breadCrumb += PageUtility.BreadCrumb_AddFinish("vs " + colorClasses);
}
m_BreadCrumbHTML = new MvcHtmlString(breadCrumb);
}
else
{
if (ClassControl.HasFactionLimits() == true)
{
m_BreadCrumbHTML = new MvcHtmlString(breadCrumbCommon
+ PageUtility.BreadCrumb_AddThisPageWithout(fightName, Request, "FactionLimit")
+ PageUtility.BreadCrumb_AddFinish("Only " + ClassControl.GetColorFactionStr()));
}
else
{
m_BreadCrumbHTML = new MvcHtmlString(breadCrumbCommon
+ PageUtility.BreadCrumb_AddFinish(fightName));
}
}
string graphSection = "<h1>Highscore for ";
if (playerLimit != null)
{
graphSection += playerLimit;
}
else
{
graphSection += "players";
}
graphSection += " vs " + fightName + "</h1><p>Fights with unrealistic dmg spikes(SW_Stats reset bug) are disqualified from this list.</p>";
//graphSection += "<p>View Highscore for class: ";
//foreach (var classLimit in ClassLimitConverter)
//{
// graphSection += PageUtility.CreateLink(PageUtility.CreateUrlWithNewQueryValue(Request, "ClassLimit", classLimit.Key), PageUtility.CreateColorCodedName(classLimit.Value.ToString(), classLimit.Value)) + ", ";
//}
if (playerLimit != null)
{
showMultipleEntries = true;//Force it to true
}
else
{
if (showMultipleEntries == false)
{
graphSection += "<p>Currently <u>not</u> showing multiple entries per player/guild. <a href='" + PageUtility.CreateUrlWithNewQueryValue(Request, "MultipleEntries", "true") + "'>Click here if you want to show multiple entries per entities</a></p>";
}
else
{
graphSection += "<p>Currently showing multiple entries per player/guild. <a href='" + PageUtility.CreateUrlWithNewQueryValue(Request, "MultipleEntries", "false") + "'>Click here if you do not want to show multiple entries per entities</a></p>";
}
}
//if (showEntriesCount < 50)
//{
// graphSection += "<p>Currently showing " + showEntriesCount + " entries per data table. <a href='" + PageUtility.CreateUrlWithNewQueryValue(Request, "Count", "50") + "'>Click here if you want to show up to 50</a></p>";
//}
//else if (showEntriesCount >= 50)
//{
// graphSection += "<p>Currently showing " + showEntriesCount + " entries per data table. <a href='" + PageUtility.CreateUrlWithNewQueryValue(Request, "Count", "25") + "'>Click here if you want to show only 25</a></p>";
//}
if (guildLimit != null)
{
graphSection += "<p>Note that this does only show data from the guild " + guildLimit + ".<br />If you want to see for all guilds click " + PageUtility.CreateLink(PageUtility.CreateUrlWithNewQueryValue(Request, "Guild", "null"), "here") + "</p>";
}
//graphSection += "</p>";
m_InfoTextHTML = new MvcHtmlString(graphSection);
PlayerFaction factionFilter = PlayerFaction.Unknown;
if (factionLimits != null && factionLimits.Count == 1)
{
factionFilter = factionLimits[0];
}
List <string> includePlayers = null;
if (andPlayer != null)
{
includePlayers = new List <string> {
andPlayer
};
}
m_GraphSection = new MvcHtmlString(VF.FightOverallOverviewGenerator.Generate(fightInstances, ApplicationInstance.Instance.GetRPPDatabase(), new VF.FightOverallOverviewGenerator.GenerateDetails {
ClassFilter = classLimits, EntriesCount = showEntriesCount, ShowMultipleEntries = showMultipleEntries, RealmFilter = realm, GuildFilter = guildLimit, PlayerFilter = playerLimit, FactionFilter = factionFilter, IncludePlayers = includePlayers
}));
}
}
