public void Update(Bout bout)
{
var entry = db.Entry(bout);
entry.State = EntityState.Modified;
db.SaveChanges();
}
public Form_main(AdminInfo adminfor, Form f)
{
InitializeComponent();
this.CenterToParent();
admin = adminfor;
form = f;
this.FormBorderStyle = FormBorderStyle.None;
WindowState = FormWindowState.Maximized;
//自做控件
Bout b = new Bout();
Bitmap bt = new Bitmap(this.Width, this.Height);
Graphics grp = Graphics.FromImage(bt);
// _Graphcis.DrawImage(Image.FromStream(new MemoryStream(_ImageByte)), 0, 0, p_Width, p_Height);
// _Graphcis.Dispose();
// return _Bitmap;
Image img = this.BackgroundImage;
grp.DrawImage(img, 0, 0, this.Width, this.Height);
this.BackgroundImage = img;
Update();
}
public ActionResult FinalizeBout(Bout bout, FormCollection formCollection)
{
try
{
// TODO: Add update logic here
if (ModelState.IsValid)
{
boutData.Update(bout);
var fighters = eloService.FindFighterByBoutId(bout.BoutId);
var newElos = eloService.CalculateNewElo(fighters, bout);
bool result = eloService.UpdateNewElo(newElos);
if (result)
{
return(RedirectToAction("Details", new { id = bout.BoutId }));
}
return(RedirectToAction("Index"));
}
return(RedirectToAction("Create"));
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
return(HttpNotFound());
}
}
public Form_main()
{
InitializeComponent();
this.CenterToParent();
//this.FormBorderStyle = FormBorderStyle.None;
this.NowLogName.Text = NowLogName.Text + ControCenter.NowLogType + ControCenter.NowLogName;
WindowState = FormWindowState.Maximized;
//自做控件
Bout b = new Bout();
Bitmap bt = new Bitmap(this.Width, this.Height);
Graphics grp = Graphics.FromImage(bt);
// _Graphcis.DrawImage(Image.FromStream(new MemoryStream(_ImageByte)), 0, 0, p_Width, p_Height);
// _Graphcis.Dispose();
// return _Bitmap;
Image img = this.BackgroundImage;
grp.DrawImage(img, 0, 0, this.Width, this.Height);
this.BackgroundImage = img;
this.Show();
string str = ControCenter.GernerCDK("8B06025F1F8DDF02C08EF3B7BF21858396507976524B1F74", "30", 0);
}
private void CalculateEstimatedTeamStrength(IEnumerable <Jam> boutJams, Bout bout, Dictionary <int, List <JamPlayer> > jamPlayerMap,
out double homeTeamStrength, out double awayTeamStrength)
{
// we're going to keep this estimate at a per-jam mentality, for now
int totalJams = boutJams.Count();
double jammerPortion = 0.5 / totalJams;
double blockerPortion = 0.125 / totalJams;
homeTeamStrength = 0;
awayTeamStrength = 0;
double totalRating = 0;
foreach (Jam jam in boutJams)
{
var players = jamPlayerMap[jam.ID];
foreach (JamPlayer jamPlayer in players)
{
//totalRating = jp.IsJammer ? jammerPortion * jp.JammerRating : blockerPortion * jp.BlockerRating;
if (jamPlayer.TeamID == bout.HomeTeamID)
{
homeTeamStrength += totalRating;
}
else if (jamPlayer.TeamID == bout.AwayTeamID)
{
awayTeamStrength += totalRating;
}
else
{
throw new InvalidOperationException("Bad player");
}
}
}
}
private void CalculateEstimatedTeamStrength(IEnumerable<Jam> boutJams, Bout bout, Dictionary<int, List<JamPlayer>> jamPlayerMap,
out double homeTeamStrength, out double awayTeamStrength)
{
// we're going to keep this estimate at a per-jam mentality, for now
int totalJams = boutJams.Count();
double jammerPortion = 0.5 / totalJams;
double blockerPortion = 0.125 / totalJams;
homeTeamStrength = 0;
awayTeamStrength = 0;
double totalRating = 0;
foreach(Jam jam in boutJams)
{
var players = jamPlayerMap[jam.ID];
foreach (JamPlayer jamPlayer in players)
{
//totalRating = jp.IsJammer ? jammerPortion * jp.JammerRating : blockerPortion * jp.BlockerRating;
if(jamPlayer.TeamID == bout.HomeTeamID)
{
homeTeamStrength += totalRating;
}
else if(jamPlayer.TeamID == bout.AwayTeamID)
{
awayTeamStrength += totalRating;
}
else
{
throw new InvalidOperationException("Bad player");
}
}
}
}
public void Import(string connectionString, StatbookModel statbook, bool assumeATeams)
{
_connection = new SqlConnection(connectionString);
try
{
_connection.Open();
_transaction = _connection.BeginTransaction();
// insert leagues
LeagueGateway leagueGateway = new LeagueGateway(_connection, _transaction);
var leagues = leagueGateway.GetAllLeagues();
League homeLeague = leagues.FirstOrDefault(l => l.Name.ToLower() == statbook.HomeTeam.LeagueName.ToLower());
League awayLeague = leagues.FirstOrDefault(l => l.Name.ToLower() == statbook.AwayTeam.LeagueName.ToLower());
int maxID = leagues.Select(l => l.ID).Max();
if (homeLeague == null)
{
homeLeague = leagueGateway.GetLeague(maxID + 1, statbook.HomeTeam.LeagueName, statbook.Date, false);
maxID++;
}
if (awayLeague == null)
{
awayLeague = leagueGateway.GetLeague(maxID + 1, statbook.AwayTeam.LeagueName, statbook.Date, false);
maxID++;
}
// insert teams
TeamGateway teamGateway = new TeamGateway(_connection, _transaction);
Team homeTeam, awayTeam;
if (assumeATeams)
{
homeTeam = teamGateway.GetATeam(homeLeague.ID);
awayTeam = teamGateway.GetATeam(awayLeague.ID);
}
else
{
homeTeam = teamGateway.GetTeam(statbook.HomeTeam.Name, homeLeague.ID, "A", false);
awayTeam = teamGateway.GetTeam(statbook.AwayTeam.Name, awayLeague.ID, "A", false);
}
// insert bout
BoutGateway boutGateway = new BoutGateway(_connection, _transaction);
if (!boutGateway.DoesBoutExist(homeTeam.ID, awayTeam.ID, statbook.Date))
{
Bout bout = boutGateway.GetBout(homeTeam.ID, awayTeam.ID, statbook.Date);
BoutDataImport(statbook, bout, homeTeam, awayTeam);
}
else
{
// bout already exists
Console.WriteLine(string.Format("Bout between {0} and {1} on {2} already exists.", homeTeam.Name, awayTeam.Name, statbook.Date));
}
_transaction.Commit();
}
finally
{
_connection.Close();
}
}
public (Fighter RedFighter, Fighter BlueFighter) FindFighterByBoutId(int BoutId)
{
Bout bout = db.Bouts.FirstOrDefault(b => b.BoutId == BoutId);
Fighter RedFighter = db.Fighters.FirstOrDefault(f => f.Id == bout.RedFighterId);
Fighter BlueFighter = db.Fighters.FirstOrDefault(f => f.Id == bout.BlueFighterId);
return(RedFighter, BlueFighter);
}
private List <Jam> CreateJamList(Bout bout, IList <JamLineupModel> lineups)
{
JamGateway jamGateway = new JamGateway(_connection, _transaction);
List <Jam> jams = new List <Jam>();
foreach (JamLineupModel jamLineup in lineups)
{
jams.Add(jamGateway.GetJam(bout.ID, jamLineup.IsFirstHalf, jamLineup.JamNumber));
}
return(jams);
}
internal Bout ReadData(SqlDataReader reader)
{
Bout bout = new Bout();
bout.ID = reader.GetInt32(reader.GetOrdinal("ID"));
bout.HomeTeamID = reader.GetInt32(reader.GetOrdinal("HomeTeamID"));
bout.AwayTeamID = reader.GetInt32(reader.GetOrdinal("AwayTeamID"));
bout.BoutDate = reader.GetDateTime(reader.GetOrdinal("PlayDate"));
bout.RinxterID = reader.IsDBNull(reader.GetOrdinal("RinxterID")) ? (int?)null : reader.GetInt32(reader.GetOrdinal("RinxterID"));
return(bout);
}
public ActionResult Create(Bout bout)
{
try
{
// TODO: Add insert logic here
boutData.Add(bout);
return(RedirectToAction("Details", new { id = bout.BoutId }));
}
catch
{
return(View());
}
}
/// <summary>
/// Determine whether the user is attacking or defending, disable cards they can't use.
/// </summary>
private void PrepForTurn(object sender, GameLogEventArgs e)
{
Bout bout = (Bout)sender;
isAttacking = bout.Attacker == player;
// When attacking, the concede button is disabled on the first turn, then enabled on
// subsequent turns.
if (isAttacking)
{
cpActiveCards.LabelText = "Attack!";
if (bout.AttackCardsPlayed.Count == 0)
{
btnGameConcede.Enabled = false;
}
else
{
btnGameConcede.Enabled = true;
}
// Enable clicking only valid cards.
for (int cardIndex = 0; cardIndex < player.Hand.Count; cardIndex++)
{
playerHand[cardIndex].Enabled = bout.IsValidAttack(player.Hand[cardIndex]);
}
}
else
{
cpActiveCards.LabelText = "Defend!";
// The button should always be enabled when defending.
btnGameConcede.Enabled = true;
// Enable clicking only valid cards.
// We need to be sure that the next player to go is the user
// otherwise we could end up in a situation where the we try
// to find out if a card can defend when there are no attacking
// cards.
if (bout.ActingPlayer == player)
{
for (int cardIndex = 0; cardIndex < player.Hand.Count; cardIndex++)
{
playerHand[cardIndex].Enabled = bout.IsValidDefense(player.Hand[cardIndex]);
}
}
}
}
public void StartGame()
{
deck = new Deck();
deck.Shuffle();
// the last card is the trump card(the one at the bottom face up)
trumpCard = deck.GetCard(0);
// Each player draws 6 cards
DistributeCardsToPlayers();
// Set the attacking player
SetAttacker();
bout = new Bout();
}
public ActionResult Edit(Bout bout)
{
try
{
// TODO: Add update logic here
if (ModelState.IsValid)
{
boutData.Update(bout);
return(RedirectToAction("Details", new { id = bout.BoutId }));
}
return(View(bout));
}
catch
{
return(View());
}
}
private void BoutDataImport(StatbookModel statbook, Bout bout, Team homeTeam, Team awayTeam)
{
// import players
Dictionary <string, Player> homePlayerMap = CreatePlayerMap(homeTeam, statbook.HomeTeam.Players);
Dictionary <string, Player> awayPlayerMap = CreatePlayerMap(awayTeam, statbook.AwayTeam.Players);
// import jams
List <Jam> jamList = CreateJamList(bout, statbook.Lineups);
// import player jams
Dictionary <int, List <JamPlayer> > jamPlayerMap = CreateJamPlayerMap(homePlayerMap, awayPlayerMap, jamList, statbook.Lineups);
// import scores
AddScores(homePlayerMap, awayPlayerMap, jamList, statbook.Scores);
// import penalties/box times
AddPenaltyServices(homePlayerMap, awayPlayerMap, jamList, statbook.Lineups, statbook.Scores, statbook.Penalties);
}
public void Import(string connectionString, StatbookModel statbook)
{
_connection = new SqlConnection(connectionString);
try
{
_connection.Open();
_transaction = _connection.BeginTransaction();
// insert leagues
LeagueGateway leagueGateway = new LeagueGateway(_connection, _transaction);
var leagues = leagueGateway.GetAllLeagues();
League homeLeague = leagues.FirstOrDefault(l => l.Name.ToLower() == statbook.HomeTeam.LeagueName.ToLower());
League awayLeague = leagues.FirstOrDefault(l => l.Name.ToLower() == statbook.AwayTeam.LeagueName.ToLower());
int maxID = leagues.Select(l => l.ID).Max();
if (homeLeague == null || awayLeague == null)
{
throw new InvalidOperationException("Bad league name");
}
// for the basic importer, we'll just take whatever A team this league has, rather than worrying about validating the team name
TeamGateway teamGateway = new TeamGateway(_connection, _transaction);
Team homeTeam = teamGateway.GetATeam(homeLeague.ID);
Team awayTeam = teamGateway.GetATeam(awayLeague.ID);
// insert bout
BoutGateway boutGateway = new BoutGateway(_connection, _transaction);
if (!boutGateway.DoesBoutExist(homeTeam.ID, awayTeam.ID, statbook.Date))
{
Bout bout = boutGateway.GetBout(homeTeam.ID, awayTeam.ID, statbook.Date);
BoutDataImport(statbook, bout, homeTeam, awayTeam);
}
else
{
// bout already exists
Console.WriteLine(string.Format("Bout between {0} and {1} on {2} already exists.", homeTeam.Name, awayTeam.Name, statbook.Date));
}
_transaction.Commit();
}
finally
{
_connection.Close();
}
}
public Bout GetBout(int homeTeamID, int awayTeamID, DateTime boutDate)
{
using (var cmd = new SqlCommand(s_GetBoutQuery, _connection, _transaction))
{
cmd.Parameters.Clear();
cmd.Parameters.Add("@HomeTeamID", SqlDbType.Int).Value = homeTeamID;
cmd.Parameters.Add("@AwayTeamID", SqlDbType.Int).Value = awayTeamID;
cmd.Parameters.Add("@BoutDate", SqlDbType.DateTime).Value = boutDate;
using (var reader = cmd.ExecuteReader())
{
// if the team record doesn't exist, add it
if (!reader.Read())
{
reader.Close();
return(AddInternalBout(homeTeamID, awayTeamID, boutDate));
}
Bout bout = ReadData(reader);
_boutList.Add(bout);
return(bout);
}
}
}
private void CalculateExpectedHomeTeamShare(Bout bout, double homeTeamStrength, double awayTeamStrength)
{
throw new NotImplementedException();
}
private void CalculateExpectedHomeTeamShare(Bout bout, double homeTeamStrength, double awayTeamStrength)
{
throw new NotImplementedException();
}
//-------------------------全局数据-------------------------
public void SetBout(Bout value)
{
bout = value;
SendEvent(BattleEvent.BOUT_UPDATE);
}
internal Bout ReadData(SqlDataReader reader)
{
Bout bout = new Bout();
bout.ID = reader.GetInt32(reader.GetOrdinal("ID"));
bout.HomeTeamID = reader.GetInt32(reader.GetOrdinal("HomeTeamID"));
bout.AwayTeamID = reader.GetInt32(reader.GetOrdinal("AwayTeamID"));
bout.BoutDate = reader.GetDateTime(reader.GetOrdinal("PlayDate"));
bout.RinxterID = reader.IsDBNull(reader.GetOrdinal("RinxterID")) ? (int?)null : reader.GetInt32(reader.GetOrdinal("RinxterID"));
return bout;
}
public IList <PlayerPerformance> GetPlayerValuePerformancesForTeam(int teamID)
{
// pull data
SqlConnection connection = new SqlConnection(_connectionString);
connection.Open();
SqlTransaction transaction = connection.BeginTransaction();
var players = new PlayerGateway(connection, transaction).GetPlayersForTeam(teamID).ToDictionary(p => p.ID);
var jams = new JamGateway(connection, transaction).GetJamsForTeamAfterDate(teamID, new DateTime(2016, 1, 1)).OrderBy(j => j.ID);
var jamBoutMap = jams.ToDictionary(j => j.ID, j => j.BoutID);
var jpe = new JamPlayerEffectivenessGateway(connection, transaction).GetJamPlayerEffectivenessForTeam(teamID);
var jamData = new JamDataGateway(connection, transaction).GetJamDataForTeam(teamID).ToDictionary(jd => jd.JamID);
var teams = new TeamGateway(connection, transaction).GetAllTeams().ToDictionary(t => t.ID);
var bouts = new BoutGateway(connection, transaction).GetBouts().ToDictionary(t => t.ID);
var penalties = new PenaltyGateway(connection, transaction).GetPenaltiesForTeam(teamID)
.GroupBy(p => p.JamID)
.ToDictionary(
g => g.Key,
g => g.GroupBy(g2 => g2.PlayerID).ToDictionary(g3 => g3.Key, g3 => g3.ToList()));
var pgs = new PenaltyGroupGateway(connection, transaction).GetPenaltyGroupsForTeam(teamID);
Dictionary <int, int> boxTimeEstimates = new BoxTimeEstimateGateway(connection, transaction).GetAllBoxTimeEstimates();
Dictionary <FoulComparison, Dictionary <int, float> > sss = new SituationalScoreGateway(connection, transaction).GetAllSituationalScores();
Dictionary <int, double> jte = new JamTeamEffectivenessGateway(connection, transaction).GetJamTeamEffectivenessForTeam(teamID);
AveragePenaltyCostPerJam avgPenCost = new AveragePenaltyCostGateway(connection, transaction).GetAveragePenaltyCost();
transaction.Commit();
connection.Close();
Dictionary <FoulComparison, float> medians = CalculateMedianScores(sss);
PenaltyCostCalculator pcCalc = new PenaltyCostCalculator(_connectionString);
Dictionary <int, double> groupPenaltyCostMap = pcCalc.CalculateValueCostsForTeam(jamData, pgs, boxTimeEstimates, sss, jte);
Dictionary <int, PlayerPerformance> ppMap = new Dictionary <int, PlayerPerformance>(25);
Dictionary <int, double> jamTotalPortionMap = new Dictionary <int, double>(300);
foreach (Jam jam in jams)
{
var pe = jpe[jam.ID];
foreach (JamPlayerEffectiveness eff in pe.Values)
{
// get/set PlayerPerformance object
if (!ppMap.ContainsKey(eff.PlayerID))
{
ppMap[eff.PlayerID] = new PlayerPerformance
{
Player = players[eff.PlayerID],
Bouts = new List <BoutPerformance>()
};
}
PlayerPerformance curPP = ppMap[eff.PlayerID];
// get/set BoutPerformance object
Bout bout = bouts[jam.BoutID];
BoutPerformance bp = null;
if (!curPP.Bouts.Any() ||
curPP.Bouts.Last().BoutDate != bout.BoutDate ||
curPP.Bouts.Last().HomeTeamName != teams[bout.HomeTeamID].Name ||
curPP.Bouts.Last().AwayTeamName != teams[bout.AwayTeamID].Name)
{
bp = new BoutPerformance
{
AwayTeamName = teams[bout.AwayTeamID].Name,
HomeTeamName = teams[bout.HomeTeamID].Name,
BoutDate = bout.BoutDate,
Jams = new List <JamPerformance>()
};
curPP.Bouts.Add(bp);
}
else
{
bp = curPP.Bouts.Last();
}
JamTeamData jd = jamData[jam.ID];
int penaltyCount = penalties.ContainsKey(jam.ID) && penalties[jam.ID].ContainsKey(eff.PlayerID) ? penalties[jam.ID][eff.PlayerID].Count() : 0;
JamPerformance jp = new JamPerformance
{
BlockerJamPercentage = eff.IsJammer ? 0 : eff.JamPortion,
DeltaPercentile = eff.BaseQuality,
IsFirstHalf = jam.IsFirstHalf,
JamID = jam.ID,
JammerJamPercentage = eff.IsJammer ? eff.JamPortion : 0,
JamNumber = jam.JamNumber,
JamPenalties = penaltyCount,
MedianDelta = medians[jd.FoulComparison],
PenaltyCost = 0,
PointDelta = jd.PointDelta
};
if (jamTotalPortionMap.ContainsKey(jam.ID))
{
jamTotalPortionMap[jam.ID] += eff.IsJammer ? eff.JamPortion * 4 : eff.JamPortion;
}
else
{
jamTotalPortionMap[jam.ID] = eff.IsJammer ? eff.JamPortion * 4 : eff.JamPortion;
}
bp.Jams.Add(jp);
}
}
foreach (PenaltyGroup pg in pgs)
{
foreach (Penalty p in pg.Penalties)
{
JamPerformance jp = ppMap[p.PlayerID].Bouts.SelectMany(b => b.Jams).Where(j => j.JamID == p.JamID).First();
jp.PenaltyCost += groupPenaltyCostMap[pg.GroupID];
}
}
foreach (PlayerPerformance pp in ppMap.Values)
{
pp.BlockerPerformance = new RolledUpPerformanceData();
pp.JammerPerformance = new RolledUpPerformanceData();
foreach (BoutPerformance bp in pp.Bouts)
{
bp.BlockerPerformance = new RolledUpPerformanceData();
bp.JammerPerformance = new RolledUpPerformanceData();
foreach (JamPerformance jp in bp.Jams)
{
double averagePenaltyCost = jp.JammerJamPercentage > 0 ? avgPenCost.JammerValueCost : avgPenCost.BlockerValueCost;
double jamShare = (jp.JammerJamPercentage * 4 + jp.BlockerJamPercentage) / jamTotalPortionMap[jp.JamID];
jp.DeltaPortionVersusMedian = (jp.DeltaPercentile - 0.5) * jamShare;
jp.PlayerValue = jp.DeltaPortionVersusMedian + jp.PenaltyCost - averagePenaltyCost;
var rollUp = jp.JammerJamPercentage > 0 ? bp.JammerPerformance : bp.BlockerPerformance;
rollUp.TotalJamPortions += jp.JammerJamPercentage + jp.BlockerJamPercentage;
rollUp.TotalPenalties += jp.JamPenalties;
rollUp.TotalPenaltyCost += jp.PenaltyCost;
rollUp.TotalPointsVersusMedian += jp.DeltaPortionVersusMedian;
rollUp.TotalPlayerValue += jp.PlayerValue;
}
pp.BlockerPerformance.TotalJamPortions += bp.BlockerPerformance.TotalJamPortions;
pp.BlockerPerformance.TotalPenalties += bp.BlockerPerformance.TotalPenalties;
pp.BlockerPerformance.TotalPenaltyCost += bp.BlockerPerformance.TotalPenaltyCost;
pp.BlockerPerformance.TotalPointsVersusMedian += bp.BlockerPerformance.TotalPointsVersusMedian;
pp.BlockerPerformance.TotalPlayerValue += bp.BlockerPerformance.TotalPlayerValue;
pp.JammerPerformance.TotalJamPortions += bp.JammerPerformance.TotalJamPortions;
pp.JammerPerformance.TotalPenalties += bp.JammerPerformance.TotalPenalties;
pp.JammerPerformance.TotalPenaltyCost += bp.JammerPerformance.TotalPenaltyCost;
pp.JammerPerformance.TotalPointsVersusMedian += bp.JammerPerformance.TotalPointsVersusMedian;
pp.JammerPerformance.TotalPlayerValue += bp.JammerPerformance.TotalPlayerValue;
}
}
return(ppMap.Values.ToList());
}
public IList <PlayerPerformance> GetPlayerPointPerformancesForTeam(int teamID)
{
// pull data
SqlConnection connection = new SqlConnection(_connectionString);
connection.Open();
SqlTransaction transaction = connection.BeginTransaction();
var players = new PlayerGateway(connection, transaction).GetPlayersForTeam(teamID).ToDictionary(p => p.ID);
var jams = new JamGateway(connection, transaction).GetJamsForTeamAfterDate(teamID, STATS_START_DATE).OrderBy(j => j.ID);
var jamBoutMap = jams.ToDictionary(j => j.ID, j => j.BoutID);
var jpe = new JamPlayerEffectivenessGateway(connection, transaction).GetJamPlayerEffectivenessForTeam(teamID);
var jdg = new JamDataGateway(connection, transaction);
var jamTeamData = jdg.GetJamDataForTeam(teamID).ToDictionary(jd => jd.JamID);
var jamData = jdg.GetAllJamData().ToDictionary(jd => jd.JamID);
foreach (JamTeamData jtd in jamTeamData.Values)
{
jtd.Year = jamData[jtd.JamID].PlayDate.Year;
}
var teams = new TeamGateway(connection, transaction).GetAllTeams().ToDictionary(t => t.ID);
var bouts = new BoutGateway(connection, transaction).GetBouts().ToDictionary(t => t.ID);
var penalties = new PenaltyGateway(connection, transaction).GetPenaltiesForTeam(teamID)
.GroupBy(p => p.JamID)
.ToDictionary(
g => g.Key,
g => g.GroupBy(g2 => g2.PlayerID).ToDictionary(g3 => g3.Key, g3 => g3.ToList()));
var pgs = new PenaltyGroupGateway(connection, transaction).GetPenaltyGroupsForTeamAfterDate(teamID, STATS_START_DATE);
Dictionary <int, int> boxTimeEstimates = new BoxTimeEstimateGateway(connection, transaction).GetAllBoxTimeEstimates();
Dictionary <FoulComparison, Dictionary <int, float> > sss = new SituationalScoreGateway(connection, transaction).GetAllSituationalScores();
AveragePenaltyCostPerJam avgPenCost = new AveragePenaltyCostGateway(connection, transaction).GetAveragePenaltyCost();
transaction.Commit();
connection.Close();
Dictionary <FoulComparison, float> medians = CalculateMedianScores(sss);
PenaltyCostCalculator ppcCalc = new PenaltyCostCalculator(_connectionString);
Dictionary <int, double> groupPenaltyCostMap = ppcCalc.CalculatePointCostsForTeam(jamTeamData, pgs, boxTimeEstimates, sss);
Dictionary <int, PlayerPerformance> pps = new Dictionary <int, PlayerPerformance>(25);
Dictionary <int, double> jamTotalPortionMap = new Dictionary <int, double>(300);
// we use "jam portions" to divide up the total value of the jam among participating players
// we give jammers an additional multiplier to their jam portions, based on year, to represent their greater impact on team success
foreach (Jam jam in jams)
{
var pe = jpe[jam.ID];
foreach (JamPlayerEffectiveness eff in pe.Values)
{
// get/set PlayerPerformance object
if (!pps.ContainsKey(eff.PlayerID))
{
pps[eff.PlayerID] = new PlayerPerformance
{
Player = players[eff.PlayerID],
Bouts = new List <BoutPerformance>()
};
}
PlayerPerformance curPP = pps[eff.PlayerID];
// get/set BoutPerformance object
Bout bout = bouts[jam.BoutID];
BoutPerformance bp = null;
if (!curPP.Bouts.Any() ||
curPP.Bouts.Last().BoutID != bout.ID)
{
bp = new BoutPerformance
{
BoutID = bout.ID,
AwayTeamName = teams[bout.AwayTeamID].Name,
HomeTeamName = teams[bout.HomeTeamID].Name,
BoutDate = bout.BoutDate,
Jams = new List <JamPerformance>()
};
curPP.Bouts.Add(bp);
}
else
{
bp = curPP.Bouts.Last();
}
JamTeamData jd = jamTeamData[jam.ID];
int penaltyCount = penalties.ContainsKey(jam.ID) && penalties[jam.ID].ContainsKey(eff.PlayerID) ? penalties[jam.ID][eff.PlayerID].Count() : 0;
JamPerformance jp = new JamPerformance
{
BlockerJamPercentage = eff.IsJammer ? 0 : eff.JamPortion,
DeltaPercentile = eff.BaseQuality,
IsFirstHalf = jam.IsFirstHalf,
JamID = jam.ID,
JammerJamPercentage = eff.IsJammer ? eff.JamPortion : 0,
JamNumber = jam.JamNumber,
JamPenalties = penaltyCount,
MedianDelta = medians[jd.FoulComparison],
PenaltyCost = 0,
PointDelta = jd.PointDelta
};
double jammerRatio = bouts[jamBoutMap[jam.ID]].BoutDate.Year == 2019 ? 2.0 : 4.0;
if (jamTotalPortionMap.ContainsKey(jam.ID))
{
jamTotalPortionMap[jam.ID] += eff.IsJammer ? eff.JamPortion * jammerRatio : eff.JamPortion;
}
else
{
jamTotalPortionMap[jam.ID] = eff.IsJammer ? eff.JamPortion * jammerRatio : eff.JamPortion;
}
bp.Jams.Add(jp);
}
}
foreach (PenaltyGroup pg in pgs)
{
foreach (Penalty p in pg.Penalties)
{
if (jams.Any(j => j.ID == p.JamID))
{
JamPerformance jp = pps[p.PlayerID].Bouts.SelectMany(b => b.Jams).Where(j => j.JamID == p.JamID).First();
jp.PenaltyCost += groupPenaltyCostMap[pg.GroupID];
}
}
}
foreach (PlayerPerformance pp in pps.Values)
{
RollUpPlayerPerformance(avgPenCost, jamTotalPortionMap, pp);
}
CalculateTeamAverages(pps, bouts);
foreach (PlayerPerformance pp in pps.Values)
{
pp.BlockerPerformance.PlayerValueVersusTeamAverage = pp.Bouts.Sum(b => b.BlockerPerformance.PlayerValueVersusTeamAverage);
pp.JammerPerformance.PlayerValueVersusTeamAverage = pp.Bouts.Sum(b => b.JammerPerformance.PlayerValueVersusTeamAverage);
}
return(pps.Values.ToList());
}
private static Dictionary <int, PlayerPerformance> GenerateInitialPlayerPerformance(Dictionary <int, Dictionary <int, Player> > players,
IOrderedEnumerable <Jam> jams,
Dictionary <int, Dictionary <int, JamPlayerEffectiveness> > jpe,
Dictionary <int, Dictionary <int, JamTeamData> > jamData,
Dictionary <int, Team> teams,
Dictionary <int, Bout> bouts,
Dictionary <int, Dictionary <int, List <Penalty> > > penalties,
IList <PenaltyGroup> pgs,
AveragePenaltyCostPerJam avgPenCost,
Dictionary <FoulComparison, float> medians,
Dictionary <int, double> groupPenaltyCostMap,
Dictionary <int, double> jamTotalPortionMap)
{
Dictionary <int, PlayerPerformance> pps = new Dictionary <int, PlayerPerformance>();
foreach (Jam jam in jams)
{
var pe = jpe[jam.ID];
foreach (var eff in pe.Values)
{
// get/set PlayerPerformance object
if (!pps.ContainsKey(eff.PlayerID))
{
pps[eff.PlayerID] = new PlayerPerformance
{
Player = players[eff.PlayerID][eff.TeamID],
Bouts = new List <BoutPerformance>()
};
}
PlayerPerformance curPP = pps[eff.PlayerID];
// get/set BoutPerformance object
Bout bout = bouts[jam.BoutID];
BoutPerformance bp = null;
if (!curPP.Bouts.Any() ||
curPP.Bouts.Last().BoutDate != bout.BoutDate ||
curPP.Bouts.Last().HomeTeamName != teams[bout.HomeTeamID].Name ||
curPP.Bouts.Last().AwayTeamName != teams[bout.AwayTeamID].Name)
{
bp = new BoutPerformance
{
BoutID = bout.ID,
AwayTeamName = teams[bout.AwayTeamID].Name,
HomeTeamName = teams[bout.HomeTeamID].Name,
BoutDate = bout.BoutDate,
Jams = new List <JamPerformance>()
};
curPP.Bouts.Add(bp);
}
else
{
bp = curPP.Bouts.Last();
}
JamTeamData jd = jamData[jam.ID][eff.TeamID];
int penaltyCount = penalties.ContainsKey(jam.ID) && penalties[jam.ID].ContainsKey(eff.PlayerID) ? penalties[jam.ID][eff.PlayerID].Count() : 0;
JamPerformance jp = new JamPerformance
{
BlockerJamPercentage = eff.IsJammer ? 0 : eff.JamPortion,
DeltaPercentile = eff.BaseQuality,
IsFirstHalf = jam.IsFirstHalf,
JamID = jam.ID,
JammerJamPercentage = eff.IsJammer ? eff.JamPortion : 0,
JamNumber = jam.JamNumber,
JamPenalties = penaltyCount,
MedianDelta = medians[jd.FoulComparison],
PenaltyCost = 0,
PointDelta = jd.PointDelta
};
if (jamTotalPortionMap.ContainsKey(jam.ID))
{
jamTotalPortionMap[jam.ID] += eff.IsJammer ? eff.JamPortion * 4 : eff.JamPortion;
}
else
{
jamTotalPortionMap[jam.ID] = eff.IsJammer ? eff.JamPortion * 4 : eff.JamPortion;
}
bp.Jams.Add(jp);
}
;
}
foreach (PenaltyGroup pg in pgs)
{
foreach (Penalty p in pg.Penalties)
{
JamPerformance jp = pps[p.PlayerID].Bouts.SelectMany(b => b.Jams).Where(j => j.JamID == p.JamID).First();
jp.PenaltyCost += groupPenaltyCostMap[pg.GroupID];
}
}
Parallel.ForEach(pps.Values, pp =>
{
RollUpPlayerPerformance(avgPenCost, jamTotalPortionMap, pp);
});
return(pps);
}
public void CalculateNewEloCorrectly()
{
//mock fighters
(Fighter, Fighter)fighters =
(
new Fighter
{
FirstName = "Frank",
LastName = "Costoya",
EloRating = 1000,
Hometown = "Miami, FL",
Id = 1,
IsMale = true,
Nickname = "The Tank",
Wins = 15,
Losses = 2,
Draws = 1
},
new Fighter
{
FirstName = "Kevin",
LastName = "Debs",
EloRating = 1000,
Hometown = "Miami, FL",
Id = 2,
IsMale = true,
Nickname = "The Rogue",
Wins = 15,
Losses = 2,
Draws = 1
}
);
//mock bout
Bout bout = new Bout
{
RedFighterId = 1,
BlueFighterId = 2,
BoutId = 1,
BoutDate = new DateTime(2020, 12, 25),
BoutLocation = "Miami, FL",
WeightClass = WeightClass.Heavyweight,
isBoutComplete = false,
IsTitleBout = false,
WinnerId = 1
};
//access to the needed classes
var context = new UfcEloDbContext();
var eloService = new EloService(context);
var result = eloService.CalculateNewElo(fighters, bout);
Console.WriteLine("Red Fighter Updated Elo. Should Be 1015");
Console.WriteLine("----------------------------------");
Console.WriteLine("Result: " + result.RedFighter.EloRating);
Assert.IsTrue(result.RedFighter.EloRating == 1015);
Console.WriteLine("Blue Fighter Updated Elo. Should Be 985");
Console.WriteLine("----------------------------------");
Console.WriteLine("Result: " + result.RedFighter.EloRating);
Assert.IsTrue(result.BlueFighter.EloRating == 985);
}
private void BoutDataImport(StatbookModel statbook, Bout bout, Team homeTeam, Team awayTeam)
{
// import players
Dictionary<string, Player> homePlayerMap = CreatePlayerMap(homeTeam, statbook.HomeTeam.Players);
Dictionary<string, Player> awayPlayerMap = CreatePlayerMap(awayTeam, statbook.AwayTeam.Players);
// import jams
List<Jam> jamList = CreateJamList(bout, statbook.Lineups);
// import player jams
Dictionary<int, List<JamPlayer>> jamPlayerMap = CreateJamPlayerMap(homePlayerMap, awayPlayerMap, jamList, statbook.Lineups);
// import scores
AddScores(homePlayerMap, awayPlayerMap, jamList, statbook.Scores);
// import penalties/box times
AddPenaltyServices(homePlayerMap, awayPlayerMap, jamList, statbook.Lineups, statbook.Scores, statbook.Penalties);
}
private List<Jam> CreateJamList(Bout bout, IList<JamLineupModel> lineups)
{
JamGateway jamGateway = new JamGateway(_connection, _transaction);
List<Jam> jams = new List<Jam>();
foreach(JamLineupModel jamLineup in lineups)
{
jams.Add(jamGateway.GetJam(bout.ID, jamLineup.IsFirstHalf, jamLineup.JamNumber));
}
return jams;
}
public void Add(Bout bout)
{
db.Bouts.Add(bout);
db.SaveChanges();
}
