private bool TryVerifyConnection(out string currentIPAddress)
{
currentIPAddress = "127.0.0.1"; // Supports unit tests.
if (OperationContext.Current != null)
{
//http://nayyeri.net/detect-client-ip-in-wcf-3-5
OperationContext context = OperationContext.Current;
MessageProperties messageProperties = context.IncomingMessageProperties;
RemoteEndpointMessageProperty endpointProperty = (RemoteEndpointMessageProperty)messageProperties[RemoteEndpointMessageProperty.Name];
currentIPAddress = endpointProperty.Address;
}
using (DataAccess.CSSStatsDataContext statsDB = new DataAccess.CSSStatsDataContext())
{
string ipAddress = currentIPAddress;
var gameServer = statsDB.GameServers.FirstOrDefault(p => p.GameServerIPs.Where(r => r.IPAddress == ipAddress).Count() > 0);
if (gameServer == null)
return false;
}
return true;
}
private bool TryVerifyConnection(out string currentIPAddress)
{
currentIPAddress = "127.0.0.1"; // Supports unit tests.
if (OperationContext.Current != null)
{
//http://nayyeri.net/detect-client-ip-in-wcf-3-5
OperationContext context = OperationContext.Current;
MessageProperties messageProperties = context.IncomingMessageProperties;
RemoteEndpointMessageProperty endpointProperty = (RemoteEndpointMessageProperty)messageProperties[RemoteEndpointMessageProperty.Name];
currentIPAddress = endpointProperty.Address;
}
using (DataAccess.CSSStatsDataContext statsDB = new DataAccess.CSSStatsDataContext())
{
string ipAddress = currentIPAddress;
var gameServer = statsDB.GameServers.FirstOrDefault(p => p.GameServerIPs.Where(r => r.IPAddress == ipAddress).Count() > 0);
if (gameServer == null)
{
return(false);
}
}
return(true);
}
private void BindData()
{
using (var db = new DataAccess.CSSStatsDataContext())
{
var allFactionNames = db.StatsFactions
.Select(p => new { FactionName = p.WinFactionName } )
.Union
(
db.StatsFactions.Select(p => new { FactionName = p.LossFactionName} )
).Distinct().OrderBy(p => p.FactionName);
List<Data.FactionData> allFactionData = new List<Allegiance.CommunitySecuritySystem.Management.Stats.Data.FactionData>();
foreach (var winFactionName in allFactionNames)
{
Data.FactionData factionData = new Allegiance.CommunitySecuritySystem.Management.Stats.Data.FactionData();
factionData.Name = winFactionName.FactionName;
factionData.Stats = String.Empty;
int index = 0;
foreach (var lossFactionName in allFactionNames)
{
if (winFactionName.FactionName.Equals(lossFactionName.FactionName, StringComparison.InvariantCultureIgnoreCase) == true)
{
factionData.Stats += "<td>--</td>";
}
else
{
var winTotal = db.StatsFactions
.Where(p => p.WinFactionName == winFactionName.FactionName && p.LossFactionName == lossFactionName.FactionName)
.GroupBy(p => new { p.WinFactionName, p.LossFactionName })
.Select(p => p.Sum(r => r.GamesPlayed) ).FirstOrDefault();
var lossTotal = db.StatsFactions
.Where(p => p.WinFactionName == lossFactionName.FactionName && p.LossFactionName == winFactionName.FactionName)
.GroupBy(p => new { p.WinFactionName, p.LossFactionName })
.Select(p => p.Sum(r => r.GamesPlayed)).FirstOrDefault();
if(winTotal + lossTotal == 0)
factionData.Stats += "<td>--</td>";
else
factionData.Stats += String.Format("<td>{0:p}</td>", (decimal) winTotal / (lossTotal + winTotal));
}
index++;
}
allFactionData.Add(factionData);
}
rptFactionHeaders.DataSource = allFactionData;
rptFactionHeaders.DataBind();
rptFactionRow.DataSource = allFactionData;
rptFactionRow.DataBind();
}
}
public List<ActivePlayerData> GetActivePlayers(string token)
{
ValidateToken(token);
string cacheKey = "Stats::GetActivePlayers";
List<ActivePlayerData> returnValue = (List<ActivePlayerData>)HttpRuntime.Cache.Get(cacheKey);
if (returnValue == null)
{
using (DataAccess.CSSDataContext db = new Allegiance.CommunitySecuritySystem.DataAccess.CSSDataContext())
{
//var activeLogins = db.Logins
// .Where(p => p.Sessions.Where(r => r.DateLastCheckIn > DateTime.Now.AddMinutes(-3)).Count() > 0)
// .OrderBy(p => p.Username)
// .ToList();
var activeSessions = db.Sessions
.Where(r => r.DateLastCheckIn > DateTime.Now.AddMinutes(-3))
.OrderBy(p => p.Alias.Callsign)
.ToList();
using (DataAccess.CSSStatsDataContext statsDB = new DataAccess.CSSStatsDataContext())
{
returnValue = activeSessions.GroupJoin(statsDB.StatsLeaderboards, p => p.LoginId, r => r.LoginID, (session, leaderboard) => new { session, leaderboard })
.SelectMany(z => z.leaderboard.DefaultIfEmpty(), (z, leaderboard) => new { z.session, leaderboard })
.Select(p => new ActivePlayerData()
{
PlayerName = p.session.Alias.Callsign,
Rank = p.leaderboard == null ? 0 : (int)Math.Floor(p.leaderboard.Rank)
})
.OrderBy(p => p.PlayerName)
.ToList();
//returnValue = activeLogins.GroupJoin(statsDB.StatsLeaderboards, p => p.Id, r => r.LoginID, (login, leaderboard) => new {login, leaderboard})
// .SelectMany(z => z.leaderboard.DefaultIfEmpty(), (z, leaderboard) => new { z.login, leaderboard } )
// .Select(p => new ActivePlayerData()
// {
// PlayerName = p.login.Username,
// Rank = p.leaderboard == null ? 0 : (int) Math.Floor(p.leaderboard.Rank)
// })
// .OrderBy(p => p.PlayerName)
// .ToList();
//var loginStats = statsDB.StatsLeaderboards
// .Join(activeLogins, p => p.LoginID, r => r.Id, ( p,
// .Where(p => activeLogins.Select(r => r.Id).Contains(p.LoginID) == true).OrderBy(p => p.LoginUsername);
//returnValue = loginStats.ToList();
}
HttpRuntime.Cache.Add(cacheKey, returnValue, null, Cache.NoAbsoluteExpiration, new TimeSpan(0, 0, 30), CacheItemPriority.Normal, null);
}
}
return returnValue;
}
public List <ActivePlayerData> GetActivePlayers(string token)
{
ValidateToken(token);
string cacheKey = "Stats::GetActivePlayers";
List <ActivePlayerData> returnValue = (List <ActivePlayerData>)HttpRuntime.Cache.Get(cacheKey);
if (returnValue == null)
{
using (DataAccess.CSSDataContext db = new Allegiance.CommunitySecuritySystem.DataAccess.CSSDataContext())
{
//var activeLogins = db.Logins
// .Where(p => p.Sessions.Where(r => r.DateLastCheckIn > DateTime.Now.AddMinutes(-3)).Count() > 0)
// .OrderBy(p => p.Username)
// .ToList();
var activeSessions = db.Sessions
.Where(r => r.DateLastCheckIn > DateTime.Now.AddMinutes(-3))
.OrderBy(p => p.Alias.Callsign)
.ToList();
using (DataAccess.CSSStatsDataContext statsDB = new DataAccess.CSSStatsDataContext())
{
returnValue = activeSessions.GroupJoin(statsDB.StatsLeaderboards, p => p.LoginId, r => r.LoginID, (session, leaderboard) => new { session, leaderboard })
.SelectMany(z => z.leaderboard.DefaultIfEmpty(), (z, leaderboard) => new { z.session, leaderboard })
.Select(p => new ActivePlayerData()
{
PlayerName = p.session.Alias.Callsign,
Rank = p.leaderboard == null ? 0 : (int)Math.Floor(p.leaderboard.Rank)
})
.OrderBy(p => p.PlayerName)
.ToList();
//returnValue = activeLogins.GroupJoin(statsDB.StatsLeaderboards, p => p.Id, r => r.LoginID, (login, leaderboard) => new {login, leaderboard})
// .SelectMany(z => z.leaderboard.DefaultIfEmpty(), (z, leaderboard) => new { z.login, leaderboard } )
// .Select(p => new ActivePlayerData()
// {
// PlayerName = p.login.Username,
// Rank = p.leaderboard == null ? 0 : (int) Math.Floor(p.leaderboard.Rank)
// })
// .OrderBy(p => p.PlayerName)
// .ToList();
//var loginStats = statsDB.StatsLeaderboards
// .Join(activeLogins, p => p.LoginID, r => r.Id, ( p,
// .Where(p => activeLogins.Select(r => r.Id).Contains(p.LoginID) == true).OrderBy(p => p.LoginUsername);
//returnValue = loginStats.ToList();
}
HttpRuntime.Cache.Add(cacheKey, returnValue, null, Cache.NoAbsoluteExpiration, new TimeSpan(0, 0, 30), CacheItemPriority.Normal, null);
}
}
return(returnValue);
}
private void SaveTeams(ACSSAuth.DataAccess.CSSDataContext db, DataAccess.CSSStatsDataContext statsDB, ACSSAuth.Server.Data.GameDataset.GameRow gameRow, int gameIdentID)
{
foreach (Data.GameDataset.TeamRow teamRow in gameRow.GetTeamRows())
{
var commanderAlias = DataAccess.Alias.GetAliasByCallsign(db, teamRow.Commander);
int commanderLoginID = 0;
if (commanderAlias != null)
{
commanderLoginID = commanderAlias.Login.Id;
}
DataAccess.GameTeam team = new ACSSAuth.DataAccess.GameTeam()
{
GameID = gameIdentID,
GameTeamCommander = TrimString(teamRow.Commander, 49),
GameTeamCommanderLoginID = commanderLoginID,
GameTeamExpansion = teamRow.ResearchedExpansion,
GameTeamFaction = teamRow.Faction,
GameTeamID = teamRow.TeamID,
GameTeamName = TrimString(teamRow.TeamName, 49),
GameTeamNumber = teamRow.TeamNumber,
GameTeamShipyard = teamRow.ResearchedShipyard,
GameTeamStarbase = teamRow.ResearchedStarbase,
GameTeamSupremacy = teamRow.ResearchedSupremacy,
GameTeamTactical = teamRow.ResearchedTactical,
GameTeamWinner = teamRow.Won
};
statsDB.GameTeams.InsertOnSubmit(team);
statsDB.SubmitChanges();
foreach (Data.GameDataset.TeamMemberRow teamMemberRow in teamRow.GetTeamMemberRows())
{
var teamMemberAlias = DataAccess.Alias.GetAliasByCallsign(db, teamMemberRow.Callsign);
int loginID = 0;
if (teamMemberAlias != null)
{
loginID = teamMemberAlias.Login.Id;
}
DataAccess.GameTeamMember teamMember = new ACSSAuth.DataAccess.GameTeamMember()
{
GameTeamID = team.GameTeamIdentID,
GameTeamMemberCallsign = TrimString(DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, teamMemberRow.Callsign), 49),
GameTeamMemberDuration = teamMemberRow.Duration,
GameTeamMemberLoginID = loginID
};
statsDB.GameTeamMembers.InsertOnSubmit(teamMember);
}
statsDB.SubmitChanges();
}
}
private void SaveChatLog(ACSSAuth.DataAccess.CSSDataContext db, DataAccess.CSSStatsDataContext statsDB, ACSSAuth.Server.Data.GameDataset.GameRow gameRow, int gameIdentID)
{
foreach (Data.GameDataset.ChatLogRow chatLogRow in gameRow.GetChatLogRows())
{
DataAccess.GameChatLog chatLog = new ACSSAuth.DataAccess.GameChatLog()
{
GameChatSpeakerName = TrimString(DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, chatLogRow.SpeakerName), 49),
GameChatTargetName = TrimString(DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, chatLogRow.TargetName), 49),
GameChatText = TrimString(chatLogRow.Text, 2063),
GameChatTime = chatLogRow.ChatTime,
GameID = gameIdentID
};
statsDB.GameChatLogs.InsertOnSubmit(chatLog);
}
}
public void Calculate(DataAccess.CSSStatsDataContext statsDB, Game game)
{
List <GameTeamMember> winningCommanders = new List <GameTeamMember>();
List <GameTeamMember> losingCommanders = new List <GameTeamMember>();
if (IsGameScorable(game) == false)
{
return;
}
foreach (var gameTeam in game.GameTeams)
{
foreach (var gameTeamMember in gameTeam.GameTeamMembers)
{
if (IsPlayerIsValidToScore(statsDB, game, gameTeamMember) == false)
{
continue;
}
int playerLevel = GetLevel(statsDB, gameTeamMember);
int avgWinXp = 0;
int avgLossXp = 0;
int winCount = 0;
int lossCount = 0;
foreach (var opposingTeamMember in gameTeam.GameTeamMembers.Where(p => p != gameTeamMember))
{
if (IsPlayerIsValidToScore(statsDB, game, opposingTeamMember) == false)
{
continue;
}
if (gameTeamMember.Score > opposingTeamMember.Score)
{
avgWinXp += GetXp(statsDB, opposingTeamMember);
winCount++;
}
else if (gameTeamMember.Score < opposingTeamMember.Score)
{
avgLossXp += GetXp(statsDB, opposingTeamMember);
lossCount++;
}
}
int winXpAdjustment = 0;
int lossXpAdjustment = 0;
int playerXp = GetXp(statsDB, gameTeamMember);
if (winCount > 0)
{
int avgWinLevel = GetLevel(statsDB, (int)(avgWinXp / winCount));
int winLevelDifference = GetLevelDifference(statsDB, playerXp, (int)(avgWinXp / winCount));
winXpAdjustment = GetRankAdjustment(statsDB, playerLevel, winLevelDifference, true);
}
if (lossCount > 0)
{
int avgLossLevel = GetLevel(statsDB, (int)(avgLossXp / lossCount));
int lossLevelDifference = GetLevelDifference(statsDB, playerXp, (int)(avgLossXp / lossCount));
lossXpAdjustment = GetRankAdjustment(statsDB, playerLevel, lossLevelDifference, false);
}
int totalPlayerXpAdjustment = winXpAdjustment - lossXpAdjustment;
if (gameTeam.GameTeamCommanderLoginID == gameTeamMember.GameTeamMemberLoginID)
{
if (gameTeam.GameTeamWinner == true)
{
winningCommanders.Add(gameTeamMember);
}
else
{
losingCommanders.Add(gameTeamMember);
}
}
SetXp(statsDB, gameTeamMember, totalPlayerXpAdjustment);
}
}
// Calculate commander's XP bonuses.
// Commander's games count twice. Once for thier performance vs. thier own team, and
// once for thier performance against the opposing commander. If it's a multi-team game,
// then each match up between comms is counted. If it's a 3 way, and you win vs. two comms, then
// you get rewards for beating both. If you loose, you only lose to the winner.
int averageWinningComamanderXp = GetAverageXp(statsDB, winningCommanders);
int averageLosingComamanderXp = GetAverageXp(statsDB, losingCommanders);
foreach (var commander in winningCommanders)
{
var commanderXp = GetXp(statsDB, commander);
var commanderLevel = GetLevel(statsDB, commander);
int levelDifference = GetLevelDifference(statsDB, commanderXp, averageLosingComamanderXp);
var xpAdjustment = GetRankAdjustment(statsDB, commanderLevel, levelDifference, true);
SetXp(statsDB, commander, xpAdjustment);
}
foreach (var commander in losingCommanders)
{
var commanderXp = GetXp(statsDB, commander);
var commanderLevel = GetLevel(statsDB, commander);
int levelDifference = GetLevelDifference(statsDB, commanderXp, averageWinningComamanderXp);
var xpAdjustment = GetRankAdjustment(statsDB, commanderLevel, levelDifference, false);
SetXp(statsDB, commander, -1 * xpAdjustment);
}
}
public int SaveGameData(string gameData, bool isCompressedAndBase64Encoded, out string message)
{
try
{
Data.GameDataset gameDataset = new Data.GameDataset();
//gameDataset.EnforceConstraints = false;
//gameDataset.
if (isCompressedAndBase64Encoded == true)
{
byte[] binaryGameData = Convert.FromBase64String(gameData);
MemoryStream memoryStream = new MemoryStream(binaryGameData);
ICSharpCode.SharpZipLib.GZip.GZipInputStream zipStream = new ICSharpCode.SharpZipLib.GZip.GZipInputStream(memoryStream);
StreamReader streamReader = new StreamReader(zipStream, System.Text.Encoding.Unicode);
//string gameDataXml = streamReader.ReadToEnd();
gameDataset.ReadXml(streamReader, System.Data.XmlReadMode.IgnoreSchema);
}
else
{
//gameDataset.ReadXml(new StringReader(gameData));
gameDataset.ReadXml(new StringReader(gameData), System.Data.XmlReadMode.IgnoreSchema);
}
if (String.IsNullOrEmpty(Settings.Default.TagLastGameDataXmlFileLogLocation) == false)
{
File.WriteAllText(Path.Combine(Settings.Default.TagLastGameDataXmlFileLogLocation, Guid.NewGuid().ToString() + ".xml"), gameDataset.GetXml());
}
string currentIPAddress;
if (OperationContext.Current != null)
{
//http://nayyeri.net/detect-client-ip-in-wcf-3-5
OperationContext context = OperationContext.Current;
MessageProperties messageProperties = context.IncomingMessageProperties;
RemoteEndpointMessageProperty endpointProperty = (RemoteEndpointMessageProperty)messageProperties[RemoteEndpointMessageProperty.Name];
currentIPAddress = endpointProperty.Address;
}
else
{
currentIPAddress = "127.0.0.1"; // Supports unit tests.
}
int gameID = 0;
using (DataAccess.CSSDataContext db = new DataAccess.CSSDataContext())
{
using (DataAccess.CSSStatsDataContext statsDB = new DataAccess.CSSStatsDataContext())
{
var gameServer = statsDB.GameServers.FirstOrDefault(p => p.GameServerIPs.Where(r => r.IPAddress == currentIPAddress).Count() > 0);
if (gameServer == null)
{
throw new Exception("You may not upload data from this address: " + currentIPAddress);
}
try
{
foreach (Data.GameDataset.GameRow gameRow in gameDataset.Game)
{
gameID = SaveGame(db, statsDB, gameServer, gameRow);
}
}
catch (Exception ex)
{
if (String.IsNullOrEmpty(Settings.Default.TagExceptionLogFileName) == false)
{
File.AppendAllText(Settings.Default.TagExceptionLogFileName, DateTime.Now.ToString() + ": " + ex.ToString() + "\n\n\n");
}
throw;
}
statsDB.SubmitChanges();
db.SubmitChanges();
}
}
// Update AllegSkill rank.
AllegSkill.Calculator.UpdateAllegSkillForGame(gameID);
// Update Prestige Rank.
using (DataAccess.CSSStatsDataContext statsDB = new DataAccess.CSSStatsDataContext())
{
var game = statsDB.Games.FirstOrDefault(p => p.GameIdentID == gameID);
if (game == null)
{
Error.Write(new Exception("Tag.SaveGameData(): Couldn't get game for GameID: " + gameID));
}
else
{
PrestigeRankCalculator psc = new PrestigeRankCalculator();
psc.Calculate(statsDB, game);
}
}
message = "Game saved.";
return(gameID);
}
catch (Exception ex)
{
message = ex.ToString();
return(-1);
}
}
private void SaveGameEvents(Allegiance.CommunitySecuritySystem.DataAccess.CSSDataContext db, DataAccess.CSSStatsDataContext statsDB, Allegiance.CommunitySecuritySystem.Server.Data.GameDataset.GameRow gameRow, int gameIdentID)
{
foreach (Data.GameDataset.GameEventRow gameEventRow in gameRow.GetGameEventRows())
{
int performerLoginID = 0;
int targetLoginID = 0;
try
{
var performerAlias = DataAccess.Alias.GetAliasByCallsign(db, gameEventRow.PerformerName);
if (performerAlias != null)
{
performerLoginID = performerAlias.Login.Id;
}
var targetAlias = DataAccess.Alias.GetAliasByCallsign(db, gameEventRow.TargetName);
if (targetAlias != null)
{
targetLoginID = targetAlias.Login.Id;
}
DataAccess.GameEvent gameEvent = new DataAccess.GameEvent()
{
GameEventTime = gameEventRow.EventTime,
GameID = gameIdentID,
GameEventIndirectID = gameEventRow.IndirectID,
GameEventIndirectName = TrimString(DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, gameEventRow.IndirectName), 254),
GameEventPerformerID = gameEventRow.PerformerID,
GameEventPerformerName = TrimString(DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, gameEventRow.PerformerName), 254),
GameEventPerformerLoginID = performerLoginID,
GameEventTargetID = gameEventRow.TargetID,
GameEventTargetName = TrimString(DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, gameEventRow.TargetName), 254),
GameEventTargetLoginID = targetLoginID,
EventID = gameEventRow.EventID
};
statsDB.GameEvents.InsertOnSubmit(gameEvent);
statsDB.SubmitChanges();
}
catch (Exception ex)
{
string errorDetails = String.Format(@"SaveGameEvents(): Insert error!
gameIdentID = {0},
gameEventRow.EventID = {1},
gameEventRow.EventTime = {2},
gameEventRow.GameID = {3},
gameEventRow.IndirectID = {4},
gameEventRow.IndirectName = {5},
gameEventRow.PerformerID = {6},
gameEventRow.PerformerName = {7},
gameEventRow.TargetID = {8},
gameEventRow.TargetName = {9},
performerLoginID = {10},
targetLoginID = {11},
DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, gameEventRow.IndirectName) = {12},
DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, gameEventRow.PerformerName) = {13},
DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, gameEventRow.TargetName) = {14}
===================================================
{15}
",
gameIdentID,
gameEventRow.EventID,
gameEventRow.EventTime,
gameEventRow.GameID,
gameEventRow.IndirectID,
gameEventRow.IndirectName,
gameEventRow.PerformerID,
gameEventRow.PerformerName,
gameEventRow.TargetID,
gameEventRow.TargetName,
performerLoginID,
targetLoginID,
DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, gameEventRow.IndirectName),
DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, gameEventRow.PerformerName),
DataAccess.Alias.GetCallsignFromStringWithTokensAndTags(db, gameEventRow.TargetName),
ex.ToString());
if (String.IsNullOrEmpty(Settings.Default.TagExceptionLogFileName) == false)
{
File.AppendAllText(Settings.Default.TagExceptionLogFileName, DateTime.Now.ToString() + ": " + errorDetails + "\n\n\n");
}
}
}
}
private int SaveGame(DataAccess.CSSDataContext db, DataAccess.CSSStatsDataContext statsDB, DataAccess.GameServer gameServer, Data.GameDataset.GameRow gameRow)
{
DataAccess.Game game = new Allegiance.CommunitySecuritySystem.DataAccess.Game()
{
GameDefections = gameRow.AllowDefections,
GameDevelopments = gameRow.AllowDevelopments,
GameShipyards = gameRow.AllowShipyards,
GameConquest = gameRow.Conquest,
GameCore = TrimString(gameRow.CoreFile, 50),
GameDeathMatch = gameRow.DeathMatch,
GameDeathmatchGoal = gameRow.DeathmatchGoal,
GameEndTime = gameRow.EndTime,
GameFriendlyFire = gameRow.FriendlyFire,
GameName = TrimString(gameRow.GameName, 254),
GameInvulStations = gameRow.InvulnerableStations,
GameMap = TrimString(gameRow.MapName, 49),
GameMaxImbalance = gameRow.MaxImbalance,
GameResources = gameRow.Resources,
GameRevealMap = gameRow.RevealMap,
GameSquadGame = gameRow.SquadGame,
GameStartingMoney = gameRow.StartingMoney,
GameStartTime = gameRow.StartTime,
GameStatsCount = gameRow.StatsCount,
GameTotalMoney = gameRow.TotalMoney,
GameID = gameRow.GameID,
GameServer = gameServer.GameServerID
};
statsDB.Games.InsertOnSubmit(game);
try
{
statsDB.SubmitChanges();
}
catch (Exception ex)
{
string dbLengthErrors = Utilities.LinqErrorDetector.AnalyzeDBChanges(statsDB);
throw new Exception("CSSStats[games]: DB Error, Linq Length Analysis: " + dbLengthErrors + "\r\n", ex);
}
SaveGameEvents(db, statsDB, gameRow, game.GameIdentID);
SaveTeams(db, statsDB, gameRow, game.GameIdentID);
SaveChatLog(db, statsDB, gameRow, game.GameIdentID);
try
{
statsDB.SubmitChanges();
}
catch (Exception ex)
{
string dbLengthErrors = Utilities.LinqErrorDetector.AnalyzeDBChanges(statsDB);
throw new Exception("CSSStats[game data]: DB Error, Linq Length Analysis: " + dbLengthErrors + "\r\n", ex);
}
try
{
db.SubmitChanges();
}
catch (Exception ex)
{
string dbLengthErrors = Utilities.LinqErrorDetector.AnalyzeDBChanges(db);
throw new Exception("CSS DB Error, Linq Length Analysis: " + dbLengthErrors + "\r\n", ex);
}
statsDB.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, game);
UpdateLeaderboard(game.GameIdentID);
UpdateFactionStats(game.GameIdentID);
UpdateMetrics(game.GameIdentID);
statsDB.SubmitChanges();
db.SubmitChanges();
return(game.GameIdentID);
}
public void Calculate(DataAccess.CSSStatsDataContext statsDB, Game game)
{
List <GameTeamMember> winningCommanders = new List <GameTeamMember>();
List <GameTeamMember> losingCommanders = new List <GameTeamMember>();
if (IsGameScorable(game) == false)
{
return;
}
foreach (var gameTeam in game.GameTeams)
{
///////////////////////////////////////////////////////////////
// Calculate the average of all opposing team members.
int opposingTeamCount = 0;
float opposingTeamPRankTotal = 0;
float opposingTeamAvgPRank = 0;
foreach (var opposingTeam in game.GameTeams)
{
if (opposingTeam == gameTeam)
{
continue;
}
opposingTeamPRankTotal += opposingTeam.AveragePRank;
opposingTeamCount++;
}
if (opposingTeamCount > 0)
{
opposingTeamAvgPRank = opposingTeamPRankTotal / opposingTeamCount;
}
///////////////////////////////////////////////////
// Get the game team member's XP adjustment
foreach (var gameTeamMember in gameTeam.GameTeamMembers)
{
if (IsPlayerIsValidToScore(statsDB, game, gameTeamMember) == false)
{
continue;
}
int playerLevel = GetLevel(statsDB, gameTeamMember);
if (playerLevel < 1)
{
playerLevel = 1;
}
float rankRatio = opposingTeamAvgPRank / playerLevel;
int totalPlayerXpAdjustment = gameTeamMember.Score;
if (gameTeam.GameTeamCommanderLoginID == gameTeamMember.GameTeamMemberLoginID)
{
if (gameTeam.GameTeamWinner == true)
{
totalPlayerXpAdjustment += WinningCommanderBonusPoints + (TeamMemberBonusPoints * gameTeam.GameTeamMembers.Count);
}
else
{
totalPlayerXpAdjustment += LosingCommanderBonusPoints + (TeamMemberBonusPoints * gameTeam.GameTeamMembers.Count);
}
}
// Add bonus for minutes played.
totalPlayerXpAdjustment += (int)(gameTeamMember.GameTeamMemberDuration / 60.0 * BonusPointsPerMinute);
// Adjust the XP for the rank offset: playing against a bunch of nubbins doesn't count for that much.
// beating a bunch of vets sends your XP way up!
totalPlayerXpAdjustment = (int)(totalPlayerXpAdjustment * rankRatio);
SetXp(statsDB, gameTeamMember, totalPlayerXpAdjustment);
}
}
//// Calculate commander's XP bonuses.
//// Commander's games count twice. Once for thier performance vs. thier own team, and
//// once for thier performance against the opposing commander. If it's a multi-team game,
//// then each match up between comms is counted. If it's a 3 way, and you win vs. two comms, then
//// you get rewards for beating both. If you loose, you only lose to the winner.
//int averageWinningComamanderXp = GetAverageXp(statsDB, winningCommanders);
//int averageLosingComamanderXp = GetAverageXp(statsDB, losingCommanders);
//foreach (var commander in winningCommanders)
//{
// var commanderXp = GetXp(statsDB, commander);
// var commanderLevel = GetLevel(statsDB, commander);
// int levelDifference = GetLevelDifference(statsDB, commanderXp, averageLosingComamanderXp);
// var xpAdjustment = GetRankAdjustment(statsDB, commanderLevel, levelDifference, true);
// SetXp(statsDB, commander, xpAdjustment);
//}
//foreach (var commander in losingCommanders)
//{
// var commanderXp = GetXp(statsDB, commander);
// var commanderLevel = GetLevel(statsDB, commander);
// int levelDifference = GetLevelDifference(statsDB, commanderXp, averageWinningComamanderXp);
// var xpAdjustment = GetRankAdjustment(statsDB, commanderLevel, levelDifference, false);
// SetXp(statsDB, commander, -1 * xpAdjustment);
//}
}
private void BindData()
{
using (var db = new DataAccess.CSSStatsDataContext())
{
var allFactionNames = db.StatsFactions
.Select(p => new { FactionName = p.WinFactionName })
.Union
(
db.StatsFactions.Select(p => new { FactionName = p.LossFactionName })
).Distinct().OrderBy(p => p.FactionName);
List <Data.FactionData> allFactionData = new List <Allegiance.CommunitySecuritySystem.Management.Stats.Data.FactionData>();
foreach (var winFactionName in allFactionNames)
{
Data.FactionData factionData = new Allegiance.CommunitySecuritySystem.Management.Stats.Data.FactionData();
factionData.Name = winFactionName.FactionName;
factionData.Stats = String.Empty;
int index = 0;
foreach (var lossFactionName in allFactionNames)
{
if (winFactionName.FactionName.Equals(lossFactionName.FactionName, StringComparison.InvariantCultureIgnoreCase) == true)
{
factionData.Stats += "<td>--</td>";
}
else
{
var winTotal = db.StatsFactions
.Where(p => p.WinFactionName == winFactionName.FactionName && p.LossFactionName == lossFactionName.FactionName)
.GroupBy(p => new { p.WinFactionName, p.LossFactionName })
.Select(p => p.Sum(r => r.GamesPlayed)).FirstOrDefault();
var lossTotal = db.StatsFactions
.Where(p => p.WinFactionName == lossFactionName.FactionName && p.LossFactionName == winFactionName.FactionName)
.GroupBy(p => new { p.WinFactionName, p.LossFactionName })
.Select(p => p.Sum(r => r.GamesPlayed)).FirstOrDefault();
if (winTotal + lossTotal == 0)
{
factionData.Stats += "<td>--</td>";
}
else
{
factionData.Stats += String.Format("<td>{0:p}</td>", (decimal)winTotal / (lossTotal + winTotal));
}
}
index++;
}
allFactionData.Add(factionData);
}
rptFactionHeaders.DataSource = allFactionData;
rptFactionHeaders.DataBind();
rptFactionRow.DataSource = allFactionData;
rptFactionRow.DataBind();
}
}
public static void UpdateAllegSkillForGame(int gameID)
{
//using(DataAccess.CSSDataContext db = new DataAccess.CSSDataContext())
//{
using (DataAccess.CSSStatsDataContext statsDB = new DataAccess.CSSStatsDataContext())
{
statsDB.ASGSServiceUpdateASRankings(gameID, 0);
// var allegSkillGamePlayerStats = statsDB.AS_GamePlayerAs.Where(p => p.GameID == gameID);
// var game = statsDB.Games.FirstOrDefault(p => p.GameID == gameID);
// // AllegSkill only supports two teams currently.
// if (game.GameTeams.Count() != 2)
// return;
// foreach (DataAccess.GameTeam team in game.GameTeams)
// {
// foreach (DataAccess.GameTeamMember teamMember in team.GameTeamMembers)
// {
// DataAccess.Alias alias = DataAccess.Alias.GetAliasByCallsign(db, teamMember.GameTeamMemeberCallsign);
// if (alias != null)
// {
// float mu;
// float sigma;
// float commandMu;
// float commandSigma;
// float stackRating;
// int rank;
// int commandRank;
// // TODO: Baker: perform AllegSkill calculations for each team member.
// // ---- Just some dummy code for now. -----
// Random random = new Random();
// mu = random.Next(20, 30);
// sigma = random.Next(-5, 5);
// commandMu = random.Next(20, 30);
// commandSigma = random.Next(-5, 5);
// stackRating = random.Next(-10, 10);
// rank = random.Next(0, 20);
// commandRank = random.Next(0, 20);
// // ---- End dummy code ----
// // Save the finished calculaitons.
// using (DataAccess.CSSStatsDataContext statsDB = new Allegiance.CommunitySecuritySystem.DataAccess.CSSStatsDataContext())
// {
// DataAccess.StatsLeaderboard leaderboard = statsDB.StatsLeaderboards.FirstOrDefault(p => p.LoginUsername == alias.Login.Username);
// if (leaderboard != null)
// {
// leaderboard.CommandMu = commandMu;
// leaderboard.CommandSigma = commandSigma;
// leaderboard.Mu = mu;
// leaderboard.Sigma = sigma;
// leaderboard.StackRating = stackRating;
// leaderboard.Rank = rank;
// leaderboard.CommandRank = commandRank;
// }
// statsDB.SubmitChanges();
// }
// }
// }
// }
// db.SubmitChanges();
//}
}
}
private int GetLevel(DataAccess.CSSStatsDataContext statsDB, GameTeamMember gameTeamMember)
{
int xp = GetXp(statsDB, gameTeamMember);
return(GetLevel(statsDB, xp));
}
public static void UpdateAllegSkillForGame(int gameID)
{
//using(DataAccess.CSSDataContext db = new DataAccess.CSSDataContext())
//{
using (DataAccess.CSSStatsDataContext statsDB = new DataAccess.CSSStatsDataContext())
{
statsDB.ASGSServiceUpdateASRankings(gameID, 0);
// var allegSkillGamePlayerStats = statsDB.AS_GamePlayerAs.Where(p => p.GameID == gameID);
// var game = statsDB.Games.FirstOrDefault(p => p.GameID == gameID);
// // AllegSkill only supports two teams currently.
// if (game.GameTeams.Count() != 2)
// return;
// foreach (DataAccess.GameTeam team in game.GameTeams)
// {
// foreach (DataAccess.GameTeamMember teamMember in team.GameTeamMembers)
// {
// DataAccess.Alias alias = DataAccess.Alias.GetAliasByCallsign(db, teamMember.GameTeamMemeberCallsign);
// if (alias != null)
// {
// float mu;
// float sigma;
// float commandMu;
// float commandSigma;
// float stackRating;
// int rank;
// int commandRank;
// // TODO: Baker: perform AllegSkill calculations for each team member.
// // ---- Just some dummy code for now. -----
// Random random = new Random();
// mu = random.Next(20, 30);
// sigma = random.Next(-5, 5);
// commandMu = random.Next(20, 30);
// commandSigma = random.Next(-5, 5);
// stackRating = random.Next(-10, 10);
// rank = random.Next(0, 20);
// commandRank = random.Next(0, 20);
// // ---- End dummy code ----
// // Save the finished calculaitons.
// using (DataAccess.CSSStatsDataContext statsDB = new ACSSAuth.DataAccess.CSSStatsDataContext())
// {
// DataAccess.StatsLeaderboard leaderboard = statsDB.StatsLeaderboards.FirstOrDefault(p => p.LoginUsername == alias.Login.Username);
// if (leaderboard != null)
// {
// leaderboard.CommandMu = commandMu;
// leaderboard.CommandSigma = commandSigma;
// leaderboard.Mu = mu;
// leaderboard.Sigma = sigma;
// leaderboard.StackRating = stackRating;
// leaderboard.Rank = rank;
// leaderboard.CommandRank = commandRank;
// }
// statsDB.SubmitChanges();
// }
// }
// }
// }
// db.SubmitChanges();
//}
}
}
public int SaveGameData(string gameData, bool isCompressedAndBase64Encoded, out string message)
{
try
{
Data.GameDataset gameDataset = new Data.GameDataset();
//gameDataset.EnforceConstraints = false;
//gameDataset.
if (isCompressedAndBase64Encoded == true)
{
byte[] binaryGameData = Convert.FromBase64String(gameData);
MemoryStream memoryStream = new MemoryStream(binaryGameData);
ICSharpCode.SharpZipLib.GZip.GZipInputStream zipStream = new ICSharpCode.SharpZipLib.GZip.GZipInputStream(memoryStream);
StreamReader streamReader = new StreamReader(zipStream, System.Text.Encoding.Unicode);
//string gameDataXml = streamReader.ReadToEnd();
gameDataset.ReadXml(streamReader, System.Data.XmlReadMode.IgnoreSchema);
}
else
{
//gameDataset.ReadXml(new StringReader(gameData));
gameDataset.ReadXml(new StringReader(gameData), System.Data.XmlReadMode.IgnoreSchema);
}
if (String.IsNullOrEmpty(Settings.Default.TagLastGameDataXmlFileLogLocation) == false)
File.WriteAllText(Path.Combine(Settings.Default.TagLastGameDataXmlFileLogLocation, Guid.NewGuid().ToString() + ".xml"), gameDataset.GetXml());
string currentIPAddress;
if (OperationContext.Current != null)
{
//http://nayyeri.net/detect-client-ip-in-wcf-3-5
OperationContext context = OperationContext.Current;
MessageProperties messageProperties = context.IncomingMessageProperties;
RemoteEndpointMessageProperty endpointProperty = (RemoteEndpointMessageProperty)messageProperties[RemoteEndpointMessageProperty.Name];
currentIPAddress = endpointProperty.Address;
}
else
currentIPAddress = "127.0.0.1"; // Supports unit tests.
int gameID = 0;
using (DataAccess.CSSDataContext db = new DataAccess.CSSDataContext())
{
using (DataAccess.CSSStatsDataContext statsDB = new DataAccess.CSSStatsDataContext())
{
var gameServer = statsDB.GameServers.FirstOrDefault(p => p.GameServerIPs.Where(r => r.IPAddress == currentIPAddress).Count() > 0);
if (gameServer == null)
throw new Exception("You may not upload data from this address: " + currentIPAddress);
try
{
foreach (Data.GameDataset.GameRow gameRow in gameDataset.Game)
gameID = SaveGame(db, statsDB, gameServer, gameRow);
}
catch (Exception ex)
{
if (String.IsNullOrEmpty(Settings.Default.TagExceptionLogFileName) == false)
File.AppendAllText(Settings.Default.TagExceptionLogFileName, DateTime.Now.ToString() + ": " + ex.ToString() + "\n\n\n");
throw;
}
statsDB.SubmitChanges();
db.SubmitChanges();
}
}
// Update AllegSkill rank.
AllegSkill.Calculator.UpdateAllegSkillForGame(gameID);
// Update Prestige Rank.
using (DataAccess.CSSStatsDataContext statsDB = new DataAccess.CSSStatsDataContext())
{
var game = statsDB.Games.FirstOrDefault(p => p.GameIdentID == gameID);
if (game == null)
{
Error.Write(new Exception("Tag.SaveGameData(): Couldn't get game for GameID: " + gameID));
}
else
{
PrestigeRankCalculator psc = new PrestigeRankCalculator();
psc.Calculate(statsDB, game);
}
}
message = "Game saved.";
return gameID;
}
catch (Exception ex)
{
message = ex.ToString();
return -1;
}
}
