public void GetBattingStatsByYearReturnsEnumerableBattingStatsWithNames()
{
var firstPerson = new BattingStats
{
PlayerId = "personId",
NameLast = "last",
YearId = 2000
};
var secondPerson = new BattingStats
{
PlayerId = "secondPersonId",
NameLast = "secondLast",
YearId = 2000
};
var expectedRecord = new List <BattingStats>()
{
firstPerson,
secondPerson
};
_battingService.Setup(mockBattingService => mockBattingService.GetBattingStatsByYear(firstPerson.YearId)).Returns(expectedRecord);
var actualReturn = _controller.GetBattingStatsByYear(firstPerson.YearId);
Assert.That(actualReturn.ElementAt(0), Is.EqualTo(firstPerson));
Assert.That(actualReturn.ElementAt(1), Is.EqualTo(secondPerson));
}
private static void Compare(BattingStats expected, BattingStats actual)
{
Assert.Equal(expected.StatsType, actual.StatsType);
Assert.Equal(expected.AtBats, actual.AtBats);
Assert.Equal(expected.Runs, actual.Runs);
Assert.Equal(expected.Hits, actual.Hits);
Assert.Equal(expected.Doubles, actual.Doubles);
Assert.Equal(expected.Triples, actual.Triples);
Assert.Equal(expected.HomeRuns, actual.HomeRuns);
Assert.Equal(expected.RunsBattedIn, actual.RunsBattedIn);
Assert.Equal(expected.BaseOnBalls, actual.BaseOnBalls);
Assert.Equal(expected.StrikeOuts, actual.StrikeOuts);
Assert.Equal(expected.StolenBases, actual.StolenBases);
Assert.Equal(expected.CaughtStealing, actual.CaughtStealing);
Assert.Equal(expected.TotalBases, actual.TotalBases);
Assert.Equal(expected.BattingAverage, actual.BattingAverage);
Assert.Equal(expected.OnBasePercentage, actual.OnBasePercentage);
Assert.Equal(expected.SluggingPercentage, actual.SluggingPercentage);
Assert.Equal(expected.OnBasePlusSlugging, actual.OnBasePlusSlugging);
Assert.Equal(expected.ContractRate, actual.ContractRate);
Assert.Equal(expected.Power, actual.Power);
Assert.Equal(expected.WalkRate, actual.WalkRate);
Assert.Equal(expected.Speed, actual.Speed);
Assert.Equal(expected.BasePerformanceValue, actual.BasePerformanceValue);
}
public void GetByTeamReturnsListofBattingStats()
{
var firstPerson = new BattingStats
{
PlayerId = "firstPersonId",
TeamId = "SEA",
NameFirst = "first",
YearId = 2000
};
var secondPerson = new BattingStats
{
PlayerId = "secondPersonId",
TeamId = "SEA",
NameFirst = "sFirst",
YearId = 2000
};
var expectedRecord = new List <BattingStats>()
{
firstPerson,
secondPerson
};
_battingService.Setup(mockBattingService => mockBattingService.GetBattingStatsByTeam(firstPerson.TeamId, firstPerson.YearId)).Returns(expectedRecord);
}
public void TestBattingResultsOutcomes()
{
ps = new BattingStats(10, 80, 1, 20, 30, 50, 70, 80, 90, 91, 100);
Assert.IsTrue(ps.BattingResults[0] == BattingResults.HBP);
Assert.IsTrue(ps.BattingResults[28] == BattingResults.K);
Assert.IsTrue(ps.BattingResults[99] == BattingResults.HR);
}
private void AssertThatEachElementIsEqualWithPlayerValues(Batting batting, BattingStats battingStats)
{
Assert.That(battingStats.NameFirst, Is.EqualTo(batting.Player.NameFirst));
Assert.That(battingStats.NameGiven, Is.EqualTo(batting.Player.NameGiven));
Assert.That(battingStats.NameLast, Is.EqualTo(batting.Player.NameLast));
Assert.That(battingStats.PlayerId, Is.EqualTo(batting.PlayerId));
Assert.That(battingStats.YearId, Is.EqualTo(batting.YearId));
Assert.That(battingStats.Stint, Is.EqualTo(batting.Stint));
Assert.That(battingStats.TeamId, Is.EqualTo(batting.TeamId));
Assert.That(battingStats.LgId, Is.EqualTo(batting.LgId));
Assert.That(battingStats.G, Is.EqualTo(batting.G));
Assert.That(battingStats.GBatting, Is.EqualTo(batting.GBatting));
Assert.That(battingStats.Ab, Is.EqualTo(batting.Ab));
Assert.That(battingStats.R, Is.EqualTo(batting.R));
Assert.That(battingStats.H, Is.EqualTo(batting.H));
Assert.That(battingStats.X2b, Is.EqualTo(batting.X2b));
Assert.That(battingStats.X3b, Is.EqualTo(batting.X3b));
Assert.That(battingStats.Hr, Is.EqualTo(batting.Hr));
Assert.That(battingStats.Rbi, Is.EqualTo(batting.Rbi));
Assert.That(battingStats.Sb, Is.EqualTo(batting.Sb));
Assert.That(battingStats.Cs, Is.EqualTo(batting.Cs));
Assert.That(battingStats.Bb, Is.EqualTo(batting.Bb));
Assert.That(battingStats.So, Is.EqualTo(batting.So));
Assert.That(battingStats.Ibb, Is.EqualTo(batting.Ibb));
Assert.That(battingStats.Hbp, Is.EqualTo(batting.Hbp));
Assert.That(battingStats.Sh, Is.EqualTo(batting.Sh));
Assert.That(battingStats.Sf, Is.EqualTo(batting.Sf));
Assert.That(battingStats.Gidp, Is.EqualTo(batting.Gidp));
}
[Fact] public void DefaultsSetTest()
{
var obj = new BattingStats();
Assert.Equal(StatsType.UNKN, obj.StatsType);
Assert.Equal(0, obj.AtBats);
Assert.Equal(0, obj.Runs);
Assert.Equal(0, obj.Hits);
Assert.Equal(0, obj.Doubles);
Assert.Equal(0, obj.Triples);
Assert.Equal(0, obj.HomeRuns);
Assert.Equal(0, obj.RunsBattedIn);
Assert.Equal(0, obj.BaseOnBalls);
Assert.Equal(0, obj.StrikeOuts);
Assert.Equal(0, obj.StolenBases);
Assert.Equal(0, obj.CaughtStealing);
Assert.Equal(0, obj.TotalBases);
Assert.Equal(0, obj.BattingAverage);
Assert.Equal(0, obj.OnBasePercentage);
Assert.Equal(0, obj.SluggingPercentage);
Assert.Equal(0, obj.OnBasePlusSlugging);
Assert.Equal(0, obj.ContractRate);
Assert.Equal(0, obj.Power);
Assert.Equal(0, obj.WalkRate);
Assert.Equal(0, obj.Speed);
Assert.Equal(0, obj.BasePerformanceValue);
}
public void MapYearCopiesDataFromBattingAndPlayerToBattingLeagueStats()
{
Batting batting = GenerateBattingWithPlayer();
BattingStats battingStats = _mapper.Map(batting);
AssertThatEachElementIsEqualWithPlayerValues(batting, battingStats);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,PlayerId,GameDate,AtBat,Hit,Single,Double,Triple,HomeRun,RunsBattedIn,RunsScored,Walk,Strikeout")] BattingStats battingStats)
{
if (id != battingStats.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(battingStats);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BattingStatsExists(battingStats.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Details", "Players", new { id = battingStats.PlayerId }));
}
ViewData["PlayerId"] = new SelectList(_context.Player, "Id", "ApplicationUserId", battingStats.PlayerId);
return(View(battingStats));
}
public void GetBattingStatsReturnsEnumerableBattingRecords()
{
var firstPerson = new BattingStats
{
PlayerId = "personId"
};
var secondPerson = new BattingStats
{
PlayerId = "personId"
};
var expectedPeople = new List <BattingStats>()
{
firstPerson,
secondPerson
};
_battingService.Setup(mockPlayerService => mockPlayerService.GetBattingStats(firstPerson.PlayerId)).Returns(expectedPeople);
var actualReturn = _controller.GetBattingStats(firstPerson.PlayerId);
Assert.That(actualReturn.ElementAt(0), Is.EqualTo(firstPerson));
Assert.That(actualReturn.ElementAt(1), Is.EqualTo(secondPerson));
}
/// <summary>Set the output <c>StatsType</c> for the <c>BattingStats</c> being creatd</summary>
/// <param name="stats">The type of stats.</param>
/// <returns>The instance of the builder.</returns>
public BattingStatsBuilder AddStats(BattingStats stats)
{
if (stats != null)
{
statsList.Add(stats);
}
return(this);
}
private void AssertGetBattingStatsByYearReturnsStats(Batting expectedBatting)
{
var expectedBattingStatsByYear = new BattingStats();
_mockMapper.Setup(mockBattingMapper => mockBattingMapper.Map(expectedBatting)).Returns(expectedBattingStatsByYear);
var actualBattingLeaderboardStats = _service.GetBattingStatsByYear(expectedBatting.YearId);
Assert.That(actualBattingLeaderboardStats.ElementAt(0), Is.EqualTo(expectedBattingStatsByYear));
}
public void AssertGetBattingStatsReturnsStats(Batting expectedBatting)
{
var expectedBattingStats = new BattingStats();
_mockMapper.Setup(mockBattingMapper => mockBattingMapper.Map(expectedBatting)).Returns(expectedBattingStats);
var actualBatting = _service.GetBattingStats(expectedBatting.PlayerId);
Assert.That(actualBatting.ElementAt(0), Is.EqualTo(expectedBattingStats));
}
public void TestBattingResultsArrayLength()
{
ps = new BattingStats(10, 80, 1, 20, 30, 50, 70, 80, 90, 91, 100);
Assert.IsTrue(ps.BattingResults.Length == 100);
Assert.IsTrue(ps.BattingResultsRanges.Count == 9);
ps.BattingResultsRanges.ForEach((x, y) =>
{
Console.WriteLine($"(Key: {x}, value: {y})");
});
}
private BattingStats GetBattingStats(StatsType statsType)
{
if (!BattingStats.Any(s => s.StatsType == statsType))
{
BattingStats.Add(new BattingStats {
StatsType = statsType
});
}
return(BattingStats.FirstOrDefault(s => s.StatsType == statsType));
}
public void MapCopiesDataFromBattingToBattingStats()
{
Batting batting = GenerateBattingWithoutNullValues();
BattingStats battingStats = _mapper.Map(batting);
AssertThatEachElementIsEqual(batting, battingStats);
Batting battingWithNull = GenerateBattingWithNullValues();
BattingStats battingStatsWithNull = _mapper.Map(battingWithNull);
AssertThatEachElementIsEqual(battingWithNull, battingStatsWithNull);
}
public async Task <IActionResult> Create([Bind("PlayerId,GameDate,AtBat,Hit,Single,Double,Triple,HomeRun,RunsBattedIn,RunsScored,Walk,Strikeout")] BattingStats battingStats)
{
if (ModelState.IsValid)
{
_context.Add(battingStats);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["PlayerId"] = new SelectList(_context.Player, "Id", "ApplicationUserId", battingStats.PlayerId);
return(View(battingStats));
}
private void AssertGetBattingStatsByTeamReturnsStats(Batting firstPerson, Batting secondPerson)
{
var firstBattingStats = new BattingStats();
var secondBattingStats = new BattingStats();
_mockMapper.Setup(mockBattingMapper => mockBattingMapper.Map(firstPerson)).Returns(firstBattingStats);
_mockMapper.Setup(mockBattingMapper => mockBattingMapper.Map(secondPerson)).Returns(secondBattingStats);
var actualBattingStats = _service.GetBattingStatsByTeam(firstPerson.TeamId, firstPerson.YearId);
Assert.That(actualBattingStats.ElementAt(0), Is.EqualTo(firstBattingStats));
//Assert.That(actualBattingStats.ElementAt(1), Is.EqualTo(secondBattingStats));
}
public void AssertGetBattingStatsReturnsStatsWithDuplicateId(Batting firstEntry, Batting secondEntry)
{
var firstEntryStats = new BattingStats();
var secondEntryStats = new BattingStats();
_mockMapper.Setup(mockBattingMapper => mockBattingMapper.Map(firstEntry)).Returns(firstEntryStats);
_mockMapper.Setup(mockBattingMapper => mockBattingMapper.Map(secondEntry)).Returns(secondEntryStats);
var actualBatting = _service.GetBattingStats(firstEntry.PlayerId);
Assert.That(actualBatting.ElementAt(0), Is.EqualTo(firstEntryStats));
Assert.That(actualBatting.ElementAt(1), Is.EqualTo(secondEntryStats));
}
public void SetUp()
{
_calculator = new StatsCalculator();
_fakeBattingStats = GenerateFakeBattingStats();
_fakeCalculatorStats = ConvertOptionalParamsToNonNullable(_fakeBattingStats);
_calculator.CalculateStats(_fakeBattingStats);
_fakeTeamStats = GenerateFakeTeamStats();
_fakeTeamCalculatorStats = ConvertOptionalParamsToNonNullable(_fakeTeamStats);
_calculator.CalculateStats(_fakeTeamStats);
_fakeBattingPostStats = GenerateFakeBattingPostStats();
_fakePostCalculatorStats = ConvertOptionalParamsToNonNullable(_fakeBattingPostStats);
_calculator.CalculateStats(_fakeBattingPostStats);
}
private void AddBattingStats(BattingStats value, StatsType statsType)
{
if (value == null)
{
return;
}
value.StatsType = statsType;
var existing = GetBattingStats(statsType);
if (existing != null)
{
BattingStats.Remove(existing);
}
BattingStats.Add(value);
}
public void TestLoadBattingStatsFromFile()
{
int expectedLines = 41;
string path = @"./Data/BaseballReference/Arizona Diamondbacks_(2001)/Arizona Diamondbacks_(2001) Batting.dat";
Assert.IsTrue(File.Exists(path));
try
{
BattingStats[] bStats = BattingStats.LoadBattingStats(path);
Assert.IsTrue(bStats.Length == expectedLines);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
/// <summary>
/// Loads the batting stats.
/// </summary>
/// <param name="roster">Player[]</param>
/// <param name="directory">string</param>
private static void LoadBattingStats(ref Player [] roster, string directory)
{
BattingStats[] bStats = BattingStats.LoadBattingStats(TextUtilities.FormFilePathName(directory, "Batting", ".dat"));
foreach (Player player in roster)
{
foreach (BattingStats bStat in bStats)
{
if (player.FullName.Equals(bStat.Name))
{
player.BattingStats = bStat;
player.BattingStatistics = new BattingStatisticsContainer(player);
player.SeasonStatistics = new SeasonStatisticsContainer(player);
}
}
}
}
private BattingStats Calculate(BattingStats stats)
{
stats.TotalBases = stats.Hits - stats.Doubles - stats.Triples - stats.HomeRuns
+ stats.Doubles * 2 + stats.Triples * 3 + stats.HomeRuns * 4;
stats.BattingAverage = Divide(stats.Hits, stats.AtBats);
stats.OnBasePercentage = Divide(stats.Hits + stats.BaseOnBalls, stats.AtBats + stats.BaseOnBalls);
stats.SluggingPercentage = Divide(stats.TotalBases, stats.AtBats);
stats.OnBasePlusSlugging = stats.OnBasePercentage + stats.SluggingPercentage;
stats.ContractRate = Divide(stats.AtBats - stats.StrikeOuts, stats.AtBats);
stats.Power = Divide(statsList.Select(s => s.AtBats * s.Power).Sum(), stats.AtBats);
stats.WalkRate = Divide(stats.BaseOnBalls, stats.AtBats + stats.BaseOnBalls);
stats.Speed = Divide(statsList.Select(s => s.AtBats * s.Speed).Sum(), stats.AtBats);
stats.BasePerformanceValue = stats.AtBats + stats.BaseOnBalls > 0
? (stats.WalkRate - MinimumWalkRate) * WeightWalkRate
+ (stats.ContractRate - MinimumContractRate) * WeightContractRate +
+(stats.Power - MinimumPowerAndSpeed) * WeightPower +
+(stats.Speed - MinimumPowerAndSpeed) * WeightSpeed
: 0;
return(stats);
}
[Fact] public void BuildWithCollectionAdd()
{
var stats1 = new BattingStats
{
AtBats = 300,
Runs = 75,
Hits = 96,
Doubles = 24,
Triples = 6,
HomeRuns = 12,
RunsBattedIn = 48,
BaseOnBalls = 30,
StrikeOuts = 60,
StolenBases = 9,
CaughtStealing = 3,
Power = 100,
Speed = 61
};
var stats2 = new BattingStats
{
AtBats = 200,
Runs = 50,
Hits = 64,
Doubles = 16,
Triples = 4,
HomeRuns = 8,
RunsBattedIn = 32,
BaseOnBalls = 20,
StrikeOuts = 40,
StolenBases = 6,
CaughtStealing = 2,
Power = 225,
Speed = 96
};
var expected = new BattingStats
{
AtBats = 500,
Runs = 125,
Hits = 160,
Doubles = 40,
Triples = 10,
HomeRuns = 20,
RunsBattedIn = 80,
BaseOnBalls = 50,
StrikeOuts = 100,
StolenBases = 15,
CaughtStealing = 5,
TotalBases = 280,
BattingAverage = 0.32,
OnBasePercentage = 210d / 550,
SluggingPercentage = 0.56,
OnBasePlusSlugging = 210d / 550 + .56,
ContractRate = 0.8,
Power = 150,
WalkRate = 50d / 550,
Speed = 75,
BasePerformanceValue = 82.6818181818182
};
Compare(expected, new BattingStatsBuilder().AddStats(new BattingStats[] { stats1, stats2 }).Build());
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
builder.Entity <Team>()
.HasMany(t => t.Players)
.WithOne(p => p.Team)
.OnDelete(DeleteBehavior.Restrict);
ApplicationUser user = new ApplicationUser
{
FirstName = "Ima",
LastName = "Parent",
UserName = "******",
NormalizedUserName = "******",
PhoneNumber = "615-555-5555",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
EmailConfirmed = true,
LockoutEnabled = false,
SecurityStamp = "7f434309-a4d9-48e9-9ebb-8803db794577",
Id = "00000000-ffff-ffff-ffff-ffffffffffff",
IsCoach = false
};
var passwordHash = new PasswordHasher <ApplicationUser>();
user.PasswordHash = passwordHash.HashPassword(user, "P@r3nt");
builder.Entity <ApplicationUser>().HasData(user);
Player player = new Player
{
Id = 1,
FirstName = "Johnny",
LastName = "Jones",
Nickname = "JJ",
Age = 9,
Position = "Shortstop",
ApplicationUserId = user.Id,
TeamId = 1
};
builder.Entity <Player>().HasData(player);
Team team = new Team
{
Id = 1,
Name = "The Hooks",
Mascot = "Fish Hook",
TeamAffiliation = "Houston Astros",
ApplicationUserId = user.Id
};
builder.Entity <Team>().HasData(team);
BattingStats battingStats = new BattingStats
{
Id = 1,
PlayerId = 1,
GameDate = new DateTime(2019, 9, 5),
AtBat = 3,
Hit = 2,
Single = 2,
Double = 0,
Triple = 0,
HomeRun = 0,
RunsBattedIn = 1,
RunsScored = 1,
Walk = 0,
Strikeout = 0
};
builder.Entity <BattingStats>().HasData(battingStats);
FieldingStats fieldingStats = new FieldingStats
{
Id = 1,
PlayerId = 1,
GameDate = new DateTime(2019, 9, 5),
Assist = 0,
Error = 1,
Putout = 1,
DoublePlay = 0
};
builder.Entity <FieldingStats>().HasData(fieldingStats);
}
public void TestPitcherVersusBatterOutcomes()
{
ryan.PitchingStats = ps;
p.BattingStats = bs;
ryan.PitchingStats.CurrentControl -= p.BattingStats.ControlModifier;
Assert.IsTrue(ryan.PitchingStats.Control == 75);
Assert.IsTrue(ryan.PitchingStats.CurrentControl == 65);
Dictionary <PitchResults, int> frequencyPitcherControl = new Dictionary <PitchResults, int>();
Dictionary <BattingResults, int> frequencyBatterControl = new Dictionary <BattingResults, int>();
int pitcherControl = 0;
int hits = 0;
for (int i = 0; i < AT_BATS; i++)
{
int roll = Dice.Roll2d10();
if (roll <= ryan.PitchingStats.Control)
{
pitcherControl++;
roll = Dice.Roll2d10();
PitchResults key = ryan.PitchingStats.PitchResults[roll - 1];
if (!frequencyPitcherControl.ContainsKey(key))
{
frequencyPitcherControl.Add(key, 1);
}
else
{
frequencyPitcherControl[key] += 1;
}
if (BattingStats.IsHit(key) == true)
{
hits++;
}
}
else
{
roll = Dice.Roll2d10();
BattingResults key2 = p.BattingStats.BattingResults[roll - 1];
if (!frequencyBatterControl.ContainsKey(key2))
{
frequencyBatterControl.Add(key2, 1);
}
else
{
frequencyBatterControl[key2] += 1;
}
if (BattingStats.IsHit(key2) == true)
{
hits++;
}
}
}
Dictionary <PitchResults, int> .Enumerator cursor = frequencyPitcherControl.GetEnumerator();
Console.WriteLine("The pitcher remained control {0} out of {1} at bats [{2:P}]", pitcherControl, AT_BATS, ((double)pitcherControl / (double)AT_BATS));
while (cursor.MoveNext())
{
Console.WriteLine(cursor.Current.ToString());
}
Console.WriteLine("Results when the batter retained control");
Dictionary <BattingResults, int> .Enumerator cursor2 = frequencyBatterControl.GetEnumerator();
while (cursor2.MoveNext())
{
Console.WriteLine(cursor2.Current.ToString());
}
Console.WriteLine("The batter had a batting average of {0:.000}", ((double)hits / (double)AT_BATS));
}
private static void AssertStats(BattingStats battingStats, int abs, int bbs, int hrs)
{
Assert.Equal(abs, battingStats.AtBats);
Assert.Equal(bbs, battingStats.BaseOnBalls);
Assert.Equal(hrs, battingStats.HomeRuns);
}
public void TestPowerRating()
{
ps = new BattingStats(10, 80, 1, 20, 30, 50, 70, 80, 90, 91, 100);
Assert.IsTrue(ps.PowerRating == 81);
}
private CalculatorStats ConvertOptionalParamsToNonNullable(BattingStats battingStats)
{
var calculatorStats = new CalculatorStats();
if (battingStats.Ab != null)
{
calculatorStats.Ab = (short)battingStats.Ab;
}
else
{
calculatorStats.Ab = 0;
}
if (battingStats.H != null)
{
calculatorStats.H = (short)battingStats.H;
}
else
{
calculatorStats.H = 0;
}
if (battingStats.X2b != null)
{
calculatorStats.X2b = (short)battingStats.X2b;
}
else
{
calculatorStats.X2b = 0;
}
if (battingStats.X3b != null)
{
calculatorStats.X3b = (short)battingStats.X3b;
}
else
{
calculatorStats.X3b = 0;
}
if (battingStats.Hr != null)
{
calculatorStats.Hr = (short)battingStats.Hr;
}
else
{
calculatorStats.Hr = 0;
}
if (battingStats.Bb != null)
{
calculatorStats.Bb = (short)battingStats.Bb;
}
else
{
calculatorStats.Bb = 0;
}
if (battingStats.So != null)
{
calculatorStats.So = (short)battingStats.So;
}
else
{
calculatorStats.So = 0;
}
if (battingStats.Ibb != null)
{
calculatorStats.Ibb = (short)battingStats.Ibb;
}
else
{
calculatorStats.Ibb = 0;
}
if (battingStats.Hbp != null)
{
calculatorStats.Hbp = (short)battingStats.Hbp;
}
else
{
calculatorStats.Hbp = 0;
}
if (battingStats.Sh != null)
{
calculatorStats.Sh = (short)battingStats.Sh;
}
else
{
calculatorStats.Sh = 0;
}
if (battingStats.Sf != null)
{
calculatorStats.Sf = (short)battingStats.Sf;
}
else
{
calculatorStats.Sf = 0;
}
return(calculatorStats);
}
/// <summary>
/// Loads batting stats from database.
/// </summary>
/// <returns>GameStats[]</returns>
/// <param name="dataTable">DataTable</param>
protected override GameStats[] LoadStatsFromDatabase(DataTable dataTable)
{
List <BattingStats> battingStats = new List <BattingStats>();
BattingStatisticsContainer theStats;
BattingStats bStats = null;
string name = string.Empty;
int originalHits = 0;
int atBats = 0;
int games = 0;
double battingAverage = 0.0;
try
{
foreach (DataRow row in dataTable.Rows)
{
string id = row["playerID"].ToString();
name = String.Concat(row["nameFirst"].ToString(), " ", row["nameLast"].ToString());
games = Convert.ToInt32(row["G"]);
atBats = Convert.ToInt32(row["AB"]);
originalHits = Convert.ToInt32(row["H"]);
int orginalHitByPitch = Convert.ToInt32(row["HBP"]);
int originalWalks = Convert.ToInt32(row["BB"]);
int originalStrikeouts = Convert.ToInt32(row["SO"]);
int originalOtherOuts = atBats - (originalHits + originalWalks + orginalHitByPitch + originalStrikeouts);
int originalTotalOuts = originalStrikeouts + originalOtherOuts;
int originalHomeRuns = Convert.ToInt32(row["HR"]);
int originalDoubles = Convert.ToInt32(row["2B"]);
int originalTriples = Convert.ToInt32(row["3B"]);
int originalSingles = originalHits - (originalHomeRuns + originalDoubles + originalTriples);
theStats = new BattingStatisticsContainer(null);
theStats.AtBats = atBats;
theStats.Singles = originalSingles;
theStats.Doubles = originalDoubles;
theStats.Triples = originalTriples;
theStats.Homeruns = originalHomeRuns;
theStats.RBI = Convert.ToInt32(row["RBI"]);
theStats.Walks = originalWalks;
theStats.HitByPitches = orginalHitByPitch;
if (atBats > 0)
{
battingAverage = (double)originalHits / (double)atBats;
}
if (atBats >= 50)//check to see if batter has meaningful bStats
{
int stolenBases = 0;
int caughtStealing = 0;
//Get percentage values
int hits = Constants.GetValueFromDouble(originalHits, atBats);
int speed = 0;
try
{
stolenBases = Convert.ToInt32(row["SB"]);//Lahman doesn't have stolen base attempts, but has caught stealing
}
catch (Exception ex)
{
ex.ToString();
stolenBases = 0;
}
theStats.StolenBases = stolenBases;
try
{
caughtStealing = Convert.ToInt32(row["CS"]);
}
catch (Exception ex)
{
ex.ToString();
caughtStealing = 0;
}
int stealAttempts = stolenBases + caughtStealing;
speed = BattingStats.CalculateSpeed(stolenBases, stealAttempts);
int stamina = BattingStats.CalculateStamina(games);
int batterRating = BattingStats.CalculateBatterRating(games, battingAverage);
int controlModifier = BattingStats.CalculateControlModifier(games, batterRating);
int hitByPitch = Constants.GetValueFromDouble(orginalHitByPitch, atBats);
if (hitByPitch == 0)
{
hitByPitch = 1;
}
//PROFESSIONAL_BATTER_RESULTS_FACTOR
int walks = Constants.GetValueFromDouble(originalWalks, atBats);
walks /= Convert.ToInt32(Convert.ToDouble(Configuration.ConfigurationManager.GetConfigurationValue("PROFESSIONAL_BATTER_RESULTS_FACTOR")));
if (walks == 0)
{
walks = 1;
}
double totalOutPct = (double)originalTotalOuts / (double)atBats;
int strikeouts = Constants.GetValueFromDouble(originalStrikeouts, originalTotalOuts);
strikeouts = (int)(strikeouts * totalOutPct);
strikeouts /= Convert.ToInt32(Convert.ToDouble(Configuration.ConfigurationManager.GetConfigurationValue("PROFESSIONAL_BATTER_RESULTS_FACTOR")));
if (strikeouts == 0)
{
strikeouts = 1;
}
int otherOuts = Constants.GetValueFromDouble(originalOtherOuts, originalTotalOuts);
otherOuts = (int)(otherOuts * totalOutPct);
otherOuts /= Convert.ToInt32(Convert.ToDouble(Configuration.ConfigurationManager.GetConfigurationValue("PROFESSIONAL_BATTER_RESULTS_FACTOR")));
int groundOuts = (int)(otherOuts * 0.5);
if (groundOuts == 0)
{
groundOuts = 1;
}
int flyouts = (int)(otherOuts * 0.5);
if (flyouts == 0)
{
flyouts = 1;
}
double homeRunPct = (double)originalHomeRuns / (double)originalHits;
int homeRuns = (int)(hits * homeRunPct);
homeRuns *= Convert.ToInt32(Convert.ToDouble(Configuration.ConfigurationManager.GetConfigurationValue("PROFESSIONAL_BATTER_RESULTS_FACTOR")));
if (homeRuns == 0)
{
homeRuns = 1;
}
double doublePct = (double)originalDoubles / (double)originalHits;
int doubles = (int)(hits * doublePct);
doubles *= Convert.ToInt32(Convert.ToDouble(Configuration.ConfigurationManager.GetConfigurationValue("PROFESSIONAL_BATTER_RESULTS_FACTOR")));
if (doubles == 0)
{
doubles = 1;
}
double triplePct = (double)originalTriples / (double)originalHits;
int triples = (int)(hits * triplePct);
triples *= Convert.ToInt32(Convert.ToDouble(Configuration.ConfigurationManager.GetConfigurationValue("PROFESSIONAL_BATTER_RESULTS_FACTOR")));
if (triples == 0)
{
triples = 1;
}
double singlePct = (double)originalSingles / (double)originalHits;
int singles = (int)(hits * singlePct);
singles *= Convert.ToInt32(Convert.ToDouble(Configuration.ConfigurationManager.GetConfigurationValue("PROFESSIONAL_BATTER_RESULTS_FACTOR")));
if (singles == 0)
{
singles = 1;
}
bStats = BattingStats.LoadResultRanges(controlModifier, speed, hitByPitch, walks, strikeouts, groundOuts, flyouts, singles, doubles, triples, homeRuns);
bStats.Name = name;
bStats.BatterRating = batterRating;
bStats.GamesPlayed = games;
bStats.Stamina = stamina;
}
else//autogenerate batter because not enough bStats are available
{
if (battingAverage >= 0.300 && games >= 20)
{
bStats = BattingStats.GenerateBattingStats(BatterTypes.Excellent);
}
else if (battingAverage >= 0.200 && battingAverage < 0.300)
{
bStats = BattingStats.GenerateBattingStats(BatterTypes.Average);
}
else
{
bStats = BattingStats.GenerateBattingStats(BatterTypes.Poor);
}
bStats.Name = name;
bStats.BatterRating = BattingStats.CalculateBatterRating(games, battingAverage);
bStats.GamesPlayed = games;
bStats.Stamina = Dice.Roll(30, 60);
}
bStats.BattingStatistics = theStats;
battingStats.Add(bStats);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
bStats = BattingStats.GenerateBattingStats(BatterTypes.Average);
bStats.Name = name;
bStats.BatterRating = BattingStats.CalculateBatterRating(games, battingAverage);
bStats.GamesPlayed = games;
bStats.Stamina = Dice.Roll(50, 70);
battingStats.Add(bStats);
}
return(battingStats.ToArray());
}
