public void GetPitchingStatsReturnsEnumerablePitchingStatsRecords()
{
var firstPerson = new PitchingStats
{
PlayerId = "personId"
};
var secondPerson = new PitchingStats
{
PlayerId = "personId"
};
var expectedPeople = new List <PitchingStats>()
{
firstPerson,
secondPerson
};
_service.Setup(mockPitchingService => mockPitchingService.GetPitchingStats(firstPerson.PlayerId)).Returns(expectedPeople);
var actualReturn = _controller.GetPitchingStats(firstPerson.PlayerId);
Assert.That(actualReturn.ElementAt(0), Is.EqualTo(firstPerson));
Assert.That(actualReturn.ElementAt(1), Is.EqualTo(secondPerson));
}
private static void Compare(PitchingStats expected, PitchingStats actual)
{
Assert.Equal(expected.StatsType, actual.StatsType);
Assert.Equal(expected.Wins, actual.Wins);
Assert.Equal(expected.Losses, actual.Losses);
Assert.Equal(expected.QualityStarts, actual.QualityStarts);
Assert.Equal(expected.Saves, actual.Saves);
Assert.Equal(expected.BlownSaves, actual.BlownSaves);
Assert.Equal(expected.Holds, actual.Holds);
Assert.Equal(expected.InningsPitched, actual.InningsPitched);
Assert.Equal(expected.HitsAllowed, actual.HitsAllowed);
Assert.Equal(expected.EarnedRuns, actual.EarnedRuns);
Assert.Equal(expected.HomeRunsAllowed, actual.HomeRunsAllowed);
Assert.Equal(expected.BaseOnBallsAllowed, actual.BaseOnBallsAllowed);
Assert.Equal(expected.StrikeOuts, actual.StrikeOuts);
Assert.Equal(expected.FlyBallRate, actual.FlyBallRate);
Assert.Equal(expected.GroundBallRate, actual.GroundBallRate);
Assert.Equal(expected.EarnedRunAverage, actual.EarnedRunAverage);
Assert.Equal(expected.WalksAndHitsPerInningPitched, actual.WalksAndHitsPerInningPitched);
Assert.Equal(expected.BattingAverageOnBallsInPlay, actual.BattingAverageOnBallsInPlay);
Assert.Equal(expected.StrandRate, actual.StrandRate);
Assert.Equal(expected.Command, actual.Command);
Assert.Equal(expected.Dominance, actual.Dominance);
Assert.Equal(expected.Control, actual.Control);
Assert.Equal(expected.GroundBallToFlyBallRate, actual.GroundBallToFlyBallRate);
Assert.Equal(expected.BasePerformanceValue, actual.BasePerformanceValue);
}
[Fact] public void DefaultsSetTest()
{
var obj = new PitchingStats();
Assert.Equal(StatsType.UNKN, obj.StatsType);
Assert.Equal(0, obj.Wins);
Assert.Equal(0, obj.Losses);
Assert.Equal(0, obj.QualityStarts);
Assert.Equal(0, obj.Saves);
Assert.Equal(0, obj.BlownSaves);
Assert.Equal(0, obj.Holds);
Assert.Equal(0, obj.InningsPitched);
Assert.Equal(0, obj.HitsAllowed);
Assert.Equal(0, obj.EarnedRuns);
Assert.Equal(0, obj.HomeRunsAllowed);
Assert.Equal(0, obj.BaseOnBallsAllowed);
Assert.Equal(0, obj.StrikeOuts);
Assert.Equal(0, obj.FlyBallRate);
Assert.Equal(0, obj.GroundBallRate);
Assert.Equal(0, obj.EarnedRunAverage);
Assert.Equal(0, obj.WalksAndHitsPerInningPitched);
Assert.Equal(0, obj.BattingAverageOnBallsInPlay);
Assert.Equal(0, obj.StrandRate);
Assert.Equal(0, obj.Command);
Assert.Equal(0, obj.Dominance);
Assert.Equal(0, obj.Control);
Assert.Equal(0, obj.GroundBallToFlyBallRate);
Assert.Equal(0, obj.BasePerformanceValue);
}
/// <summary>
/// Handle a pitching change.
/// </summary>
/// <param name="pitcher">The pitcher.</param>
/// <param name="stats">The stats.</param>
/// <param name="scoreboard">The scoreboard.</param>
/// <param name="isHome">if set to <c>true</c> [is home].</param>
/// <returns>True if a pitching change was made otherwise false.</returns>
public Boolean PitchingChange(Player pitcher, PitchingStats stats, ScoreBoard scoreboard, Boolean isHome)
{
Boolean newPitcher = false;
if (this.bullpen.Count > 0)
{
// Has the pitcher already been removed?
if (this.lineup.Pitcher == null)
{
var reliefPitcher = this.SelectReliefPitcher(scoreboard, isHome);
this.RelievePitcher(reliefPitcher);
this.lineup.BattingOrder[8] = reliefPitcher;
newPitcher = true;
}
else
{
var pitchCount = Utilities.GetPitchCount(stats);
var expectedPitchCount = Utilities.CalculateExpectedPitchCount(pitcher.PitchingStats, this.startingPitcher);
if (pitchCount > expectedPitchCount)
{
// Pitcher is out of gas - select reliever
var reliefPitcher = this.SelectReliefPitcher(scoreboard, isHome);
this.RelievePitcher(reliefPitcher);
newPitcher = true;
}
}
}
return(newPitcher);
}
public void MapYearCopiesDataFromPitchingPostAndPlayerToPitchingPostStats()
{
Pitching pitching = GeneratePitchingWithPlayer();
PitchingStats pitchingLeaderBoardStats = _mapper.Map(pitching);
AssertThatEachElementIsEqualWithPlayerValues(pitching, pitchingLeaderBoardStats);
}
public void GetPitchingStatsByYearReturnsEnumerablePitchingStats()
{
var firstPerson = new PitchingStats
{
PlayerId = "personId",
NameLast = "last",
YearId = 2000
};
var secondPerson = new PitchingStats
{
PlayerId = "secondPersonId",
NameLast = "secondLast",
YearId = 2000
};
var expectedRecord = new List <PitchingStats>()
{
firstPerson,
secondPerson
};
_service.Setup(mockPlayerService => mockPlayerService.GetPitchingStatsByYear(firstPerson.YearId)).Returns(expectedRecord);
var actualReturn = _controller.GetPitchingStatsByYear(firstPerson.YearId);
Assert.That(actualReturn.ElementAt(0), Is.EqualTo(firstPerson));
Assert.That(actualReturn.ElementAt(1), Is.EqualTo(secondPerson));
}
/// <summary>Adds another instance of <c>PitchingStats</c> to the list.</summary>
/// <param name="stats">The <c>PitchingStats</c> to add to the list.</param>
/// <returns>The instance of the builder.</returns>
public PitchingStatsBuilder AddStats(PitchingStats stats)
{
if (stats != null)
{
statsList.Add(stats);
}
return(this);
}
/// <summary>
/// Gets the pitchers stats.
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns>The pitching stats.</returns>
public PitchingStats GetPitchersStats(String id)
{
PitchingStats stats = null;
this.pitcherStatsDictionary.TryGetValue(id, out stats);
return(stats);
}
public void AssertGetPitchingStatsReturnsStats(Pitching expectedPitching)
{
var expectedPitchingStats = new PitchingStats();
_mockMapper.Setup(mockPitchingMapper => mockPitchingMapper.Map(expectedPitching)).Returns(expectedPitchingStats);
var actualPitching = _service.GetPitchingStats(expectedPitching.PlayerId);
Assert.That(actualPitching.ElementAt(0), Is.EqualTo(expectedPitchingStats));
}
private void AssertGetPitchingLeaderboardStatsByYearReturnsStats(Pitching expectedPitching)
{
var expectedPitchingLeaderboardStats = new PitchingStats();
_mockMapper.Setup(mockPitchingMapper => mockPitchingMapper.Map(expectedPitching)).Returns(expectedPitchingLeaderboardStats);
var actualPitchingLeaderboardStats = _service.GetPitchingStatsByYear(expectedPitching.YearId);
Assert.That(actualPitchingLeaderboardStats.ElementAt(0), Is.EqualTo(expectedPitchingLeaderboardStats));
}
public static Int32 GetPitchCount(PitchingStats stats)
{
Double pitchCount = (Double)stats.Strikeouts * 4.81;
pitchCount += (Double)stats.Walks * 5.14;
pitchCount += (Double)stats.Hits * 3.27;
pitchCount += (Double)(stats.TotalOuts - stats.Strikeouts) * 3.16;
return((Int32)Math.Round(pitchCount));
}
private PitchingStats GetPitchingStats(StatsType statsType)
{
if (!PitchingStats.Any(s => s.StatsType == statsType))
{
PitchingStats.Add(new PitchingStats {
StatsType = statsType
});
}
return(PitchingStats.FirstOrDefault(s => s.StatsType == statsType));
}
public void MapCopiesDataFromPitchingToPitchingStats()
{
Pitching pitching = GeneratePitchingWithoutNullValues();
PitchingStats pitchingStats = _mapper.Map(pitching);
AssertThatEachElementIsEqual(pitching, pitchingStats);
Pitching pitchingWithNull = GeneratePitchingWithNullValues();
PitchingStats pitchingStatsWithNull = _mapper.Map(pitchingWithNull);
AssertThatEachElementIsEqual(pitchingWithNull, pitchingStatsWithNull);
}
public void AssertGetPitchingStatsReturnsStatsWithDuplicateId(Pitching firstEntry, Pitching secondEntry)
{
var firstEntryStats = new PitchingStats();
var secondEntryStats = new PitchingStats();
_mockMapper.Setup(mockBattingMapper => mockBattingMapper.Map(firstEntry)).Returns(firstEntryStats);
_mockMapper.Setup(mockBattingMapper => mockBattingMapper.Map(secondEntry)).Returns(secondEntryStats);
var actualPeople = _service.GetPitchingStats(firstEntry.PlayerId);
Assert.That(actualPeople.ElementAt(0), Is.EqualTo(firstEntryStats));
Assert.That(actualPeople.ElementAt(1), Is.EqualTo(secondEntryStats));
}
private void AddPitchingStats(PitchingStats value, StatsType statsType)
{
if (value == null)
{
return;
}
value.StatsType = statsType;
var existing = GetPitchingStats(statsType);
if (existing != null)
{
PitchingStats.Remove(existing);
}
PitchingStats.Add(value);
}
/// <summary>
/// Loads the pitching stats.
/// </summary>
/// <param name="roster">Player[]</param>
/// <param name="directory">string</param>
private static void LoadPitchingStats(ref Player[] roster, string directory)
{
PitchingStats[] pStats = PitchingStats.LoadPitchingStats(TextUtilities.FormFilePathName(directory, "Pitching", ".dat"));
foreach (Player player in roster)
{
foreach (PitchingStats pStat in pStats)
{
if (player.FullName.Equals(pStat.Name))
{
player.PitchingStats = pStat;
player.PitchingStatistics = new PitchingStatisticsContainer(player);
}
}
}
}
public void TestLoadPitchingStatsFromFile()
{
string path = @"./Data/BaseballReference/Arizona Diamondbacks_(2001)/Arizona Diamondbacks_(2001) Pitching.dat";
PitchingStats[] pstats = null;
Assert.IsTrue(File.Exists(path));
try
{
int EXPECTED_LENGTH = 21;
pstats = PitchingStats.LoadPitchingStats(path);
pstats.ToList().ForEach(Console.WriteLine);
Assert.IsTrue(pstats.Length == EXPECTED_LENGTH);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private PitchingStats Calculate(PitchingStats stats)
{
stats.FlyBallRate = Divide(statsList.Select(s => s.InningsPitched * s.FlyBallRate).Sum(), stats.InningsPitched);
stats.GroundBallRate = Divide(statsList.Select(s => s.InningsPitched * s.GroundBallRate).Sum(), stats.InningsPitched);
stats.EarnedRunAverage = Divide(stats.EarnedRuns, stats.InningsPitched / 9);
stats.WalksAndHitsPerInningPitched = Divide(stats.HitsAllowed + stats.BaseOnBallsAllowed, stats.InningsPitched);
stats.BattingAverageOnBallsInPlay = Divide(stats.HitsAllowed - stats.HomeRunsAllowed,
stats.InningsPitched * BabipMultiplier + stats.HitsAllowed - stats.StrikeOuts - stats.HomeRunsAllowed);
stats.StrandRate = Divide(stats.HitsAllowed + stats.BaseOnBallsAllowed - stats.EarnedRuns,
stats.HitsAllowed + stats.BaseOnBallsAllowed - stats.HomeRunsAllowed);
stats.Dominance = Divide(stats.StrikeOuts, stats.InningsPitched / 9);
stats.Control = Divide(stats.BaseOnBallsAllowed, stats.InningsPitched / 9);
stats.Command = Divide(stats.Dominance, stats.Control);
stats.GroundBallToFlyBallRate = Divide(stats.GroundBallRate, stats.FlyBallRate);
stats.BasePerformanceValue = stats.InningsPitched > 0
? (stats.Dominance - MinimumDominance) * WeightDominance
+ (MaxiumumControl - stats.Control) * WeightControl
+ (stats.GroundBallRate - MinimumGroundBallRate) * WeightGroundBallRate
: 0;
return(stats);
}
private void AssertThatEachElementIsEqualWithPlayerValues(Pitching pitching, PitchingStats pitchingStats)
{
Assert.That(pitchingStats.NameFirst, Is.EqualTo(pitching.Player.NameFirst));
Assert.That(pitchingStats.NameGiven, Is.EqualTo(pitching.Player.NameGiven));
Assert.That(pitchingStats.NameLast, Is.EqualTo(pitching.Player.NameLast));
Assert.That(pitchingStats.PlayerId, Is.EqualTo(pitching.PlayerId));
Assert.That(pitchingStats.YearId, Is.EqualTo(pitching.YearId));
Assert.That(pitchingStats.Stint, Is.EqualTo(pitching.Stint));
Assert.That(pitchingStats.TeamId, Is.EqualTo(pitching.TeamId));
Assert.That(pitchingStats.LgId, Is.EqualTo(pitching.LgId));
Assert.That(pitchingStats.W, Is.EqualTo(pitching.W));
Assert.That(pitchingStats.L, Is.EqualTo(pitching.L));
Assert.That(pitchingStats.G, Is.EqualTo(pitching.G));
Assert.That(pitchingStats.Gs, Is.EqualTo(pitching.Gs));
Assert.That(pitchingStats.Cg, Is.EqualTo(pitching.Cg));
Assert.That(pitchingStats.Sho, Is.EqualTo(pitching.Sho));
Assert.That(pitchingStats.Sv, Is.EqualTo(pitching.Sv));
Assert.That(pitchingStats.Ipouts, Is.EqualTo(pitching.Ipouts));
Assert.That(pitchingStats.H, Is.EqualTo(pitching.H));
Assert.That(pitchingStats.Er, Is.EqualTo(pitching.Er));
Assert.That(pitchingStats.Hr, Is.EqualTo(pitching.Hr));
Assert.That(pitchingStats.Bb, Is.EqualTo(pitching.Bb));
Assert.That(pitchingStats.So, Is.EqualTo(pitching.So));
var localBaopp = pitching.Baopp / 100 ?? 0;
Assert.That(pitchingStats.Baopp, Is.EqualTo(Math.Round(localBaopp, 2)));
var localEra = pitching.Era / 100 ?? 0;
Assert.That(pitchingStats.Era, Is.EqualTo(Math.Round(localEra, 2)));
Assert.That(pitchingStats.Ibb, Is.EqualTo(pitching.Ibb));
Assert.That(pitchingStats.Wp, Is.EqualTo(pitching.Wp));
Assert.That(pitchingStats.Hbp, Is.EqualTo(pitching.Hbp));
Assert.That(pitchingStats.Bk, Is.EqualTo(pitching.Bk));
Assert.That(pitchingStats.Bfp, Is.EqualTo(pitching.Bfp));
Assert.That(pitchingStats.Gf, Is.EqualTo(pitching.Gf));
Assert.That(pitchingStats.R, Is.EqualTo(pitching.R));
Assert.That(pitchingStats.Sh, Is.EqualTo(pitching.Sh));
Assert.That(pitchingStats.Sf, Is.EqualTo(pitching.Sf));
Assert.That(pitchingStats.Gidp, Is.EqualTo(pitching.Gidp));
}
public static Int32 CalculateExpectedPitchCount(PitchingStats stats, Boolean isStarter)
{
Int32 expectedPitchCount = 0;
Int32 totalOuts = (stats.Innings * 3) - stats.Strikeouts;
Int32 totalPitches = (Int32)((Double)stats.Strikeouts * 5.0);
totalPitches += (Int32)((Double)stats.Walks * 5.3);
totalPitches += (Int32)((Double)stats.Hits * 3.4);
totalPitches += (Int32)((Double)totalOuts * 3.3);
Double startPercent = stats.GamesStarted / stats.Games;
Boolean mostlyStarter = false;
if (startPercent > 0.66)
{
mostlyStarter = true;
}
if (isStarter)
{
if (mostlyStarter == false)
{
expectedPitchCount = 105;
}
else
{
Double reliefInnings = 0;
Double startInnings = 0;
if (stats.GamesStarted == 0)
{
reliefInnings = stats.Innings;
}
else if (stats.GamesStarted == stats.Games)
{
startInnings = stats.Innings;
}
else
{
reliefInnings = (stats.Games - stats.GamesStarted) * 1.7;
startInnings = stats.Innings - reliefInnings;
}
Double startPitches = totalPitches * (startInnings / stats.Innings);
expectedPitchCount = (Int32)Math.Ceiling(startPitches / stats.GamesStarted);
if (expectedPitchCount < 64)
{
expectedPitchCount = 64;
}
if (expectedPitchCount > 145)
{
expectedPitchCount = 145;
}
}
}
else
{
if (mostlyStarter)
{
expectedPitchCount = 50;
}
else
{
Double startInnings = stats.GamesStarted * 5.7;
Double reliefInnings = stats.Innings - startInnings;
Double reliefPitches = totalPitches * (reliefInnings / stats.Innings);
expectedPitchCount = (Int32)Math.Ceiling(reliefPitches / (stats.Games - stats.GamesStarted));
}
}
return(expectedPitchCount);
}
[Fact] public void BuildWithCollectionAdd()
{
var stats1 = new PitchingStats
{
Wins = 12,
Losses = 6,
QualityStarts = 18,
Saves = 9,
BlownSaves = 3,
Holds = 15,
InningsPitched = 60,
HitsAllowed = 45,
EarnedRuns = 24,
HomeRunsAllowed = 1,
BaseOnBallsAllowed = 30,
StrikeOuts = 120,
FlyBallRate = 0.2,
GroundBallRate = 0.31
};
var stats2 = new PitchingStats
{
Wins = 8,
Losses = 4,
QualityStarts = 12,
Saves = 6,
BlownSaves = 2,
Holds = 10,
InningsPitched = 40,
HitsAllowed = 30,
EarnedRuns = 16,
HomeRunsAllowed = 0,
BaseOnBallsAllowed = 20,
StrikeOuts = 80,
FlyBallRate = 0.45,
GroundBallRate = 0.66
};
var expected = new PitchingStats
{
Wins = 20,
Losses = 10,
QualityStarts = 30,
Saves = 15,
BlownSaves = 5,
Holds = 25,
InningsPitched = 100,
HitsAllowed = 75,
EarnedRuns = 40,
HomeRunsAllowed = 1,
BaseOnBallsAllowed = 50,
StrikeOuts = 200,
FlyBallRate = .30,
GroundBallRate = .45,
EarnedRunAverage = 3.6,
WalksAndHitsPerInningPitched = 1.25,
BattingAverageOnBallsInPlay = 74 / 156d,
StrandRate = 85 / 124d,
Command = 4,
Dominance = 18,
Control = 4.5,
GroundBallToFlyBallRate = 1.5,
BasePerformanceValue = 225.5
};
Compare(expected, new PitchingStatsBuilder().AddStats(new PitchingStats[] { stats1, stats2 }).Build());
}
/// <summary>
/// Loads PitchingStats[] array from database.
/// </summary>
/// <returns>GameStats[]</returns>
/// <param name="dataTable">DataTable</param>
protected override GameStats[] LoadStatsFromDatabase(DataTable dataTable)
{
List <PitchingStats> pitchingStats = new List <PitchingStats>();
foreach (DataRow row in dataTable.Rows)
{
string name = string.Empty;
string id = string.Empty;
PitchingStats pStats = null;
PitchingStatisticsContainer theStats = null;
int stamina = 0;
double startPct = 0;
int originalHits = Convert.ToInt32(row["H"]);
try
{
theStats = new PitchingStatisticsContainer(null);
name = String.Concat(row["nameFirst"].ToString(), " ", row["nameLast"].ToString());
int battersFaced = (int)Convert.ToDouble(row["BFP"]);
theStats.BattersFaced = battersFaced;
double inningsPitched = (Convert.ToDouble(row["IPouts"]) / 3);
theStats.TotalOuts = (int)Convert.ToDouble(row["IPouts"]);
int completeGames = (int)Convert.ToDouble(row["CG"]);
theStats.CompleteGames = completeGames;
theStats.Saves = Convert.ToInt32(row["SV"]);
theStats.RunsAllowed = Convert.ToInt32(row["R"]);
int hits = Constants.GetValueFromDouble(originalHits, battersFaced);
int totalGamesPitched = Convert.ToInt32(row["G"]);
theStats.PitchingTotalGamesAppeared = totalGamesPitched;
int gamesStarted = Convert.ToInt32(row["GS"]);
theStats.PitchingGamesStarted = gamesStarted;
int wins = Convert.ToInt32(row["W"]);
theStats.Wins = wins;
int losses = Convert.ToInt32(row["L"]);
theStats.Losses = losses;
int totalDecisions = wins + losses;
startPct = Constants.GetValueFromDouble(gamesStarted, totalGamesPitched);
double winLossPct = Constants.GetValueFromDouble(wins, totalDecisions);
int control = PitchingStats.CalculateControl(battersFaced, originalHits, wins, theStats.Saves);
stamina = PitchingStats.CalculateStamina(startPct, wins, completeGames, gamesStarted, totalGamesPitched, inningsPitched);
int balks = Constants.GetValueFromDouble(Convert.ToDouble(row["BK"]), battersFaced);
if (balks == 0)
{
balks = 1;
}
theStats.Balks = Convert.ToInt32(row["BK"]);
int hitByPitch = Constants.GetValueFromDouble(Convert.ToDouble(row["HBP"]), battersFaced);
if (hitByPitch == 0)
{
hitByPitch = 1;
}
theStats.HitByPitches = Convert.ToInt32(row["HBP"]);
int walks = Constants.GetValueFromDouble(Convert.ToDouble(row["BB"]), battersFaced);
if (walks == 0)
{
walks = 1;
}
theStats.Walks = Convert.ToInt32(row["BB"]);
int strikeouts = Constants.GetValueFromDouble(Convert.ToDouble(row["SO"]), battersFaced);
if (strikeouts == 0)
{
strikeouts = 1;
}
theStats.Strikeouts = Convert.ToInt32(row["SO"]);
int otherOuts = Constants.GetValueFromDouble(Convert.ToDouble(row["BFP"]) - Convert.ToDouble(row["H"]) - Convert.ToDouble(row["BB"]) - Convert.ToDouble(row["HBP"]) - Convert.ToDouble(row["SO"]), Convert.ToDouble(row["BFP"]));
int groundOuts = (int)(otherOuts * 0.5);
if (groundOuts == 0)
{
groundOuts = 1;
}
int flyouts = (int)(otherOuts * 0.5);
if (flyouts == 0)
{
flyouts = 1;
}
int homeRuns = Constants.GetValueFromDouble(Convert.ToDouble(row["HR"]), battersFaced);
if (homeRuns == 0)
{
homeRuns = 1;
}
theStats.Homeruns = Convert.ToInt32(row["HR"]);
int otherHits = hits - homeRuns;
//since singles, doubles and triples are not given, we'll use a generic distribution
int singles = (int)(otherHits * 0.6); // singles will be 60% of other hits
if (singles == 0)
{
singles = 1;
}
int doubles = (int)(otherHits * 0.3);
if (doubles == 0)
{
doubles = 1;
}
int triples = (int)(otherHits * 0.1);
if (triples == 0)
{
triples = 1;
}
//Reverse engineer ERA to get earned runs
double ERA = Convert.ToDouble(row["ERA"]);
theStats.EarnedRunsAllowed = (int)(((inningsPitched) / 9) * ERA);
pStats = PitchingStats.LoadResultRanges(control, balks, hitByPitch, walks, strikeouts, groundOuts, flyouts, singles, doubles, triples, homeRuns);
id = row["playerID"].ToString();
pStats.Name = name;
pStats.Stamina = stamina;
pStats.StartPct = (int)startPct;
pStats.PitchingStatistics = theStats;
}
catch (Exception ex)
{
ex.ToString();
pStats = PitchingStats.GeneratePitchingStats(PitcherTypes.Average);
pStats.Name = name;
pStats.Stamina = Dice.Roll(25, 50);
pStats.StartPct = 0;
pStats.PitchingStatistics = theStats;
}
pitchingStats.Add(pStats);
}
return(pitchingStats.ToArray());
}
private static void AssertStats(PitchingStats PitchingStats, int ips, int ers, int ks)
{
Assert.Equal(ips, PitchingStats.InningsPitched);
Assert.Equal(ers, PitchingStats.EarnedRuns);
Assert.Equal(ks, PitchingStats.StrikeOuts);
}
