Pitch By Pitch

Over the last few weeks, I’ve done a lot of work on my Retrosheet Scorecard project, and I’m pleased to announce that Version 2 is ready. There are a lot of improvements in Version 2, but the most exciting is that games can now be exported AND imported. One of the coolest things with this new version is that I can take any event file from Retrosheet’s game file library, import it into the spreadsheet, and I can see a scorecard of the game. I was checking out the 1979 World Series last night.

Here is the listing of changes in Version 2.

• Event files can be imported
• When you import an event file, you can populate the rosters from either a ROS file or that game’s event file.
• Fixed an error that occurred with a game ended after midnight
• Earned runs are automatically set to 0, when left blank
• If you have an error on your scoresheet, a message appears, and the program does not attempt to generate a box score.
• Umpires are not input by their real names, not a Retrosheet ID
• x and X are no longer case sensitive. 3xH works the same as 3XH.

  The one improvement that didn’t make it into this version involves the positioning of substitutes. When a substitute enters the game, his name is written on the top-most available line on the scorecard. Ideally, I’d like to see the player’s name entered closer to his position in the batting order. I plan to make this change in the near future, but I wanted to release this version first.

  As always, let me know if you have any questions.

  Enjoy!
  Ben

I’ve posted my Retrosheet Scorecard.

I created it using Microsoft Excel and VBA macros.

Please check it out and let me know what you think!

I must admit that baseball will not be my top priority tonight. The Philadelphia Flyers travel to the Burgh for Game 1 of their first-round playoff series.

Still, I’ll keep an eye on the game, and here are some quick notes for tonight:
– We got Delwyn Young for two players to be named later. Apparently, he’ll be in Pittsburgh later this week. Time will tell where he fits in, and who gets bumped to make room for him.
– Andy LaRoche is back in the starting lineup tonight. He WILL get a hit.
– It’s Jackie Robinson day. Pay tribute to #42.

10:23 Update – Well, not much to say about the baseball game (other than everybody wore #42… which made the game very confusing). The Pens, however, got off to a great start, defeating the Flyers 4-1.

The Astros got four runs in a hurry. Mike Hampton threw 6 shutout innings, and that was about enough. Adam LaRoche hit a solo shot in the 9th. Andy LaRoche didn’t get his hit. He was replaced in the top of the 6th.

The most ironic event of the evening for me was that I decided to post my Retrosheet Scorecard this evening, despite my knowledge that at least one game situation doesn’t work well (a pinch hitter is at bat when the third out of an inning is a caught stealing. Sure enough, it happened tonight.

I’ve discussed the amount of information that you can extract from Retrosheet event files. Using this information, you can perform an almost unlimited amount of analysis on just about any game, player, team, or season in baseball history.

Something that is more difficult is to perform the same type of analysis on information from the current season. Since Retrosheet releases all of their data at once, at the end of each season, there are no event files to process.

For a long time, I looked for a tool that would help to convert a scorecard into a Retrosheet-formatted event file. Several years back, Heritage Software had a piece of freeware called Official Scorer. This program did a pretty nice job, but it wasn’t capable of handling pitch data, and it had problems with the program crashing at random times. There is/was a program from Diamond Ware called DWENTRY. I believe that this is the program used by Retrosheet to create their files, but I can’t find a copy of it anywhere.

So, after struggling to find exactly what I was looking for, I decided that I should try to build something myself. I’ve done a good amount of programming, but most of it has been web-based and I’m not nearly fluent enough in Java or C to create a full featured program, so I decided that using VBScript macros within a Microsoft Excel workbook would be my best option.

This workbook has been a work in progress for almost 3 years now… not that I’ve been working on it for 3 years… I’ve just slowly pieced it together and improved it when I’ve had time.

It’s not perfect, and nowhere near it. Ideally, this program would have the capability of:

a) looking like a scorecard and being used to score a game
b) creating a Retrosheet-formatted event file
c) importing a Retrosheet-formatted event file and populating the scorecard based on game data

Currently, it’s decent at completing tasks A and B. I know of several game caveats that cause the program to fail. I plan to use my scorecards from the 2009 Pittsburgh Pirates to help identify (and fix, if possible) these shortcomings.

I will keep you posted on my progress, and eventually I will make the workbook available. Until then, you can click on “My Scoresheet” in the Files section on the right-hand side of this page to see a screenshot of the workbook. This printout is the scorecard that I use to score each and every Pirate game.

Retrosheet game files use a code to represent each Major League Baseball stadium.  Here is the legend for those codes.

Ballpark Codes

And because I think this blog needs some color… here is PIT08.

To analyze output from the bgame program, it helps to input the data into a database.  I prefer to use MySQL.  Here’s how.

1) Create a database table.

CREATE TABLE `bgame` (
`gameid` varchar(12) NOT NULL,
`gamedate` varchar(8) NOT NULL,
`gamenumber` int(1) NOT NULL,
`dayofweek` varchar(10) NOT NULL,
`starttime` int(8) NOT NULL,
`dhused` varchar(1) NOT NULL,
`daynight` varchar(1) NOT NULL,
`vteam` varchar(3) NOT NULL,
`hteam` varchar(3) NOT NULL,
`gamesite` varchar(3) NOT NULL,
`vstartingpitcher` varchar(10) NOT NULL,
`hstartingpitcher` varchar(10) NOT NULL,
`humpire` varchar(10) NOT NULL,
`fumpire` varchar(10) NOT NULL,
`sumpire` varchar(10) NOT NULL,
`tumpire` varchar(10) NOT NULL,
`lfumpire` varchar(10) NOT NULL,
`rfumpire` varchar(10) NOT NULL,
`attendance` int(8) NOT NULL,
`psscorer` varchar(25) NOT NULL,
`translator` varchar(25) NOT NULL,
`inputter` varchar(25) NOT NULL,
`inputtime` varchar(15) NOT NULL,
`edittime` varchar(15) NOT NULL,
`howscored` int(8) NOT NULL,
`pitchesentered` int(8) NOT NULL,
`temperature` int(3) NOT NULL,
`winddirection` int(8) NOT NULL,
`windspeed` int(8) NOT NULL,
`fieldcondition` int(8) NOT NULL,
`precipitation` int(8) NOT NULL,
`sky` int(8) NOT NULL,
`timeofgame` int(8) NOT NULL,
`numberofinnings` int(8) NOT NULL,
`vfinalscore` int(8) NOT NULL,
`hfinalscore` int(8) NOT NULL,
`vhits` int(8) NOT NULL,
`hits` int(8) NOT NULL,
`verrors` int(8) NOT NULL,
`herrors` int(8) NOT NULL,
`vlob` int(8) NOT NULL,
`hlob` int(8) NOT NULL,
`wpitcher` varchar(10) NOT NULL,
`lpitcher` varchar(10) NOT NULL,
`spitcher` varchar(10) NOT NULL,
`gwrbi` varchar(10) NOT NULL,
`vbat1` varchar(10) NOT NULL,
`vpos1` int(3) NOT NULL,
`vbat2` varchar(10) NOT NULL,
`vpos2` int(3) NOT NULL,
`vbat3` varchar(10) NOT NULL,
`vpos3` int(3) NOT NULL,
`vbat4` varchar(10) NOT NULL,
`vpos4` int(3) NOT NULL,
`vbat5` varchar(10) NOT NULL,
`vpos5` int(3) NOT NULL,
`vbat6` varchar(10) NOT NULL,
`vpos6` int(3) NOT NULL,
`vbat7` varchar(10) NOT NULL,
`vpos7` int(3) NOT NULL,
`vbat8` varchar(10) NOT NULL,
`vpos8` int(3) NOT NULL,
`vbat9` varchar(10) NOT NULL,
`vpos9` int(3) NOT NULL,
`hbat1` varchar(10) NOT NULL,
`hpos1` int(3) NOT NULL,
`hbat2` varchar(10) NOT NULL,
`hpos2` int(3) NOT NULL,
`hbat3` varchar(10) NOT NULL,
`hpos3` int(3) NOT NULL,
`hbat4` varchar(10) NOT NULL,
`hpos4` int(3) NOT NULL,
`hbat5` varchar(10) NOT NULL,
`hpos5` int(3) NOT NULL,
`hbat6` varchar(10) NOT NULL,
`hpos6` int(3) NOT NULL,
`hbat7` varchar(10) NOT NULL,
`hpos7` int(3) NOT NULL,
`hbat8` varchar(10) NOT NULL,
`hpos8` int(3) NOT NULL,
`hbat9` varchar(10) NOT NULL,
`hpos9` int(3) NOT NULL,
`vfinisher` varchar(10) NOT NULL,
`hfinisher` varchar(10) NOT NULL,
PRIMARY KEY  (`gameid`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

2. Download the Retrosheet zip files, and run the bgame program.

bgame -y 2008 2008ANA.EVA 2008BAL.EVA 2008CHA.EVA 2008DET.EVA 2008OAK.EVA 2008SEA.EVA 2008TBA.EVA 2008TOR.EVA 2008ARI.EVN 2008ATL.EVN 2008CHN.EVN 2008CIN.EVN 2008COL.EVN 2008FLO.EVN 2008HOU.EVN 2008LAN.EVN 2008MIL.EVN 2008NYN.EVN 2008PHI.EVN 2008SDN.EVN 2008SFN.EVN 2008SLN.EVN 2008WAS.EVN 2008BOS.EVA 2008CLE.EVA 2008KCA.EVA 2008MIN.EVA 2008PIT.EVN > 2008COMBINED.csv

3. Import 2008COMBINED.csv into your new MySQL database table.

Recently, when I’ve been scoring baseball games, I’ve preferred to use the Project Scoresheet notation.  Like just about any scoring system, Project Scoresheet has its pros and cons, but I like the way that score cards in this notation can be easily input and analyzed by a computer.  The tradeoff is that it can be difficult, at times, to look at the score card and get a quick idea of the current state of the game.  At first, the notation can be a bit difficult to learn, but once you get the hang of it, you can score games quite efficiently.

I won’t even try to do as good (or as thorough) of a job describing this scoring notation as Alex Reisner.  Check out his description of Project Scoresheet and example score card here.  Alex Reisner’s Introduction to Project Scoresheet Scoring (PDF) – Alex Reisner’s Project Scoresheet score card (PDF). Also,  check out his website at http://alexreisner.com/baseball.  He has some pretty interesting scorecards and player performance graphs on there. 

To give a quick overview: a Project Scoresheet score card has three lines for each at-bat.  The top line is for anything that happened “before the play” (stolen bases, wild pitches, passed balls).  The middle line is for what happened during the play itself (single, double, strike out, ground out, etc.).  The bottom line is for the actions following the play (base runner advancements).

All on-field actions are abbreviated by short codes.

Single, Double, Triple, Home Run, Strikeout = S, D, T, HR, K

To code outs where the ball was put into play, you record the fielders who touched the ball.

A flyout to center = 8/F

A groundout to the shortstop = 63/G

Again, the main advantage to this type of scoring is that the score card can quickly be entered into a computer for analysis.  All of the game files at http://www.retrosheet.org use this notation.

Retrosheet’s bevent program takes a Retrosheet event file and creates a complete description of every at-bat that occurred during the game.  To complete the introduction of Retrosheet’s three pieces of software, I’ll once again start with the event file for the Colorado Rockies @ Los Angeles Dodgers game on 4/9/2007 as an example. Here is the event file.

Here is a step-by-step guide for using bevent.exe.

1. Download bevent.exe from Retrosheet or here, and unzip the executable file.
2. Put the event file (or a text file that includes many event files) in the same directory as the bevent.exe program.
3. You also need to have a team file included in the same directory.  A team file is text file that lists every team, their league, and their three-letter abbreviation.  The team file must have a filename of TEAMYYYY.  For example, here is TEAM2007.
4. Open the Windows Command Prompt. (Start -> Run -> CMD)
5. Navigate to the directory where you stored bevent.exe, the event file, and the team file.
6. Type the command: bevent -y 2007 -f 0-96 dodgers_rockies040907.evn (or the name of your event file).  “-y 2007” specifies the year of the game.  If you are generating game info for a game from 1960, make sure you use -y 1960. “-f 0-96” specifies which fields I want bevent to return.  The default is 0-6, 8-9, 12-13, 16-17, 26-40, 43-45 ,51, 58-61.  0-96 means all fields.
7. If you want to output the game info to a text file (I’d recommend saving as a .csv file so it opens nicely in spreadsheet software), use the command bevent -y 2007 -f 0-96 dodgers_rockies040907.evn > dodgers_rockies_040907_gameinfo.csv.

Here is the output from bevent.exe.

The output is a comma-delimited file that contains the following fields:

0    game id
1    visiting team
2    inning
3    batting team
4    outs
5    balls
6    strikes
7    pitch sequence
8    vis score
9    home score
10   batter
11   batter hand
12   res batter
13   res batter hand
14   pitcher
15   pitcher hand
16   res pitcher
17   res pitcher hand
18   catcher
19   first base
20   second base
21   third base
22   shortstop
23   left field
24   center field
25   right field
26   first runner
27   second runner
28   third runner
29   event text
30   leadoff flag
31   pinchhit flag
32   defensive position
33   lineup position
34   event type
35   batter event flag
36   ab flag
37   hit value
38   SH flag
39   SF flag
40   outs on play
41   double play flag
42   triple play flag
43   RBI on play
44   wild pitch flag
45   passed ball flag
46   fielded by
47   batted ball type
48   bunt flag
49   foul flag
50   hit location
51   num errors
52   1st error player
53   1st error type
54   2nd error player
55   2nd error type
56   3rd error player
57   3rd error type
58   batter dest (5 if scores and unearned, 6 if team unearned)
59   runner on 1st dest (5 if scores and unearned, 6 if team unearned)
60   runner on 2nd dest (5 if scores and unearned, 6 if team unearned)
61   runner on 3rd dest (5 if socres and uneanred, 6 if team unearned)
62   play on batter
63   play on runner on 1st
64   play on runner on 2nd
65   play on runner on 3rd
66   SB for runner on 1st flag
67   SB for runner on 2nd flag
68   SB for runner on 3rd flag
69   CS for runner on 1st flag
70   CS for runner on 2nd flag
71   CS for runner on 3rd flag
72   PO for runner on 1st flag
73   PO for runner on 2nd flag
74   PO for runner on 3rd flag
75   Responsible pitcher for runner on 1st
76   Responsible pitcher for runner on 2nd
77   Responsible pitcher for runner on 3rd
78   New Game Flag
79   End Game Flag
80   Pinch-runner on 1st
81   Pinch-runner on 2nd
82   Pinch-runner on 3rd
83   Runner removed for pinch-runner on 1st
84   Runner removed for pinch-runner on 2nd
85   Runner removed for pinch-runner on 3rd
86   Batter removed for pinch-hitter
87   Position of batter removed for pinch-hitter
88   Fielder with First Putout (0 if none)
89   Fielder with Second Putout (0 if none)
90   Fielder with Third Putout (0 if none)
91   Fielder with First Assist (0 if none)
92   Fielder with Second Assist (0 if none)
93   Fielder with Third Assist (0 if none)
94   Fielder with Fourth Assist (0 if none)
95   Fielder with Fifth Assist (0 if none)
96   event num

Retrosheet’s bgame program takes a Retrosheet event file and creates a game summary. Again, I’ll use the Colorado Rockies @ Los Angeles Dodgers game on 4/9/2007 as an example. Here is the event file.  Here is a step-by-step guide for using bgame.exe.

1. Download bgame.exe from Retrosheet or here, and unzip the executable file.
2. Put the event file (or a text file that includes many event files) in the same directory as the bgame.exe program.
3. You also need to have a team file included in the same directory.  A team file is text file that lists every team, their league, and their three-letter abbreviation.  The team file must have a filename of TEAMYYYY.  For example, here is TEAM2007.
4. Open the Windows Command Prompt.
5. Navigate to the directory where you stored bgame.exe, the event file, and the team file.
6. Type the command: bgame -y 2007 dodgers_rockies040907.evn (or the name of your event file).  -y 2007 specifies the year of the game.  If you are generating game info for a game from 1960, make sure you use -y 1960.
7. If you want to output the game info to a text file, use the command bgame -y 2007 dodgers_rockies040907.evn > dodgers_rockies_040907_gameinfo.txt.

Here is the output from bgame.exe.

The output is a comma-delimited file that contains the following fields:

0       game id - This is formatted (Home Team Abbreviation + YY + MM + DD + Game Number (see below))
1       date - This is formatted YYMMDD
2       game number - This field shows 0 if only one game was played between the two teams on that day.  If a double-header was scheduled, this field will show either 1 or 2.
3       day of week - Monday, Tuesday, etc
4       start time - This field is text only.  For instance 3:30 would be 330.  All times are assumed to be PM.
5       DH used flag - This field displays a T (true) if the designated hitter rule was used.  Otherwise, this field is F (false).
6       day/night flag - This field is D or N.
7       visiting team - This is the three-letter abbreviation of the visiting team.
8       home team
9       game site - Every ballpark has a special Retrosheet code.  The code is displayed in this field.  Click here for a listing of ballpark codes.
10      visiting starting pitcher - This is the unique Retrosheet ID of the visiting team's starting pitcher.
11      home starting pitcher
12      home plate umpire - This is the unique Retrosheet ID of the home team's starting pitcher.
13      first base umpire
14      second base umpire
15      third base umpire
16      left field umpire - Big games have two additional umpires in the outfield.  This is the unique Retrosheet ID of the left field umpire.  If no left field umpire was used, this field is blank.
17      right field umpire
18      attendance - The game's attendance
19      PS scorer - The name of the scorer.
20      translator - The name of the translator.
21      inputter - The name of the inputter.
22      input time - The time that the game was input.
23      edit time - The time that the game was edited.
24      how scored - How the game was scored: live, online, tv, radio, etc.
25      pitches entered? - Were pitches entered, the final count, or just the results of the at-bat.  This field shows: pitches, count, or none.
26      temperature - The temperature of the game, in Fahrenheit.
27      wind direction - The wind direction (fromcf, fromlf, fromrf, rtol, ltor, tolf, torf, tocf, unknown)
28      wind speed - The wind speed, in MPH.
29      field condition - The field condition (dry, wet, soaked, unknown)
30      precipitation - drizzle, none, rain, showers, snow, unknown
31      sky - cloudy, dome, night, overcast, sunny, unknown
32      time of game - The duration of the game, in minutes.
33      number of innings - The number of innings in the game.
34      visitor final score - The number of runs scored by the visiting team.
35      home final score
36      visitor hits - The number of hits by the visiting team.
37      home hits
38      visitor errors - The number of errors committed by the visiting team.
39      home errors
40      visitor left on base - The number of runners left on base by the visiting team.
41      home left on base
42      winning pitcher - The unique Retrosheet ID for the winning pitcher.
43      losing pitcher - The unique Retrosheet ID for the losing pitcher.
44      save for - The unique Retrosheet ID for the player who earned the save.
45      GW RBI - The unique Retrosheet ID for the player who hit the game-winning RBI.  This used to be an official MLB statistic.
46      visitor batter 1 - The unique Retrosheet ID of the first hitter for the visiting team.
47      visitor position 1 - The numeric position of the first hitter for the visiting team (1=P, 2=C, 3=1B, 4=2B, 5=3B, 6=SS, 7=LF, 8=CF, 9=RF).
48      visitor batter 2
49      visitor position 2
50      visitor batter 3
51      visitor position 3
52      visitor batter 4
53      visitor position 4
54      visitor batter 5
55      visitor position 5
56      visitor batter 6
57      visitor position 6
58      visitor batter 7
59      visitor position 7
60      visitor batter 8
61      visitor position 8
62      visitor batter 9
63      visitor position 9
64      home batter 1
65      home position 1
66      home batter 2
67      home position 2
68      home batter 3
69      home position 3
70      home batter 4
71      home position 4
72      home batter 5
73      home position 5
74      home batter 6
75      home position 6
76      home batter 7
77      home position 7
78      home batter 8
79      home position 8
80      home batter 9
81      home position 9
82      visiting finisher (NULL if complete game) - The final pitcher for the visiting team.
83      home finisher (NULL if complete game)