Diablo 2 1.11 Save File

Did some playing around with the single player save game file format for Diablo II recently. There’s some other documentation on it elsewhere but I’ll put what I’ve discovered here for another take on it.

When trying to simply do a hex-edit to the file, there’s 2 major obstacles.
The first is the checksum for the file. Starting at byte offset 12 (0x0C) there is a series of 4 bytes, ending at offset 15 (0x0F). These 4 bytes will be the checksum for the file. The checksum itself is not too complicated, but keep in mind that you must NOT include the checksum bytes themselves as part of the checksum. There are some references to the particular method of checksum but In my own words I’d call it a “256 Modulus-carryover”. Each new byte gets put into the first checksum byte, but before you do any operation on the checksum bytes, you must multiply it by 2 (each iteration). If the first checksum byte becomes greater than 256, it signalsfor a carry bit to be put into the second byte (and so on). Well I’m probably making it sound harder than it is… here’s the algorithm in AutoIt (assumes a byte-array $byteA with each byte of the file loaded sequentially)-

func FixCheckSum()
dim $checksum[4]
$byteA[12]=0x00
$byteA[13]=0x00
$byteA[14]=0x00
$byteA[15]=0x00
$boolCarry=0
for $i=0 to UBound($byteA)-1
$temp=Dec(Hex(Binary($byteA[$i])))+$boolCarry
$checksum[0]= $checksum[0]*2 +$temp
$checksum[1]=$checksum[1]*2
if $checksum[0] > 255 Then
$checksum[1] = $checksum[1] + ($checksum[0] - Mod($checksum[0],256)) / 256
$checksum[0] = Mod($checksum[0],256)
EndIf
$checksum[2]=$checksum[2]*2
if $checksum[1] > 255 Then
$checksum[2] = $checksum[2] + ($checksum[1] - Mod($checksum[1],256)) / 256
$checksum[1] = Mod($checksum[1],256)
EndIf
$checksum[3]=$checksum[3]*2
if $checksum[2] > 255 Then
$checksum[3] = $checksum[3] + ($checksum[2] - Mod($checksum[2],256)) / 256
$checksum[2] = Mod($checksum[2],256)
EndIf
If $checksum[3] > 255 Then
$checksum[3] = Mod($checksum[3], 256)
EndIf
if BitAND($checksum[3],0x80)<>0 Then
$boolCarry=1
Else
$boolCarry=0
EndIf
Next
$byteA[12]="0x"&Hex($checksum[0],2)
$byteA[13]="0x"&Hex($checksum[1],2)
$byteA[14]="0x"&Hex($checksum[2],2)
$byteA[15]="0x"&Hex($checksum[3],2)
EndFunc

Actions speak louder than words sometimes 🙂

The 2nd issue to deal with is that except for single byte entries, the section of the file dealing with character stats is back-asswords…double time! Starting at offset 765 (0x2FD), you should see a two bytes- 0x67 and 0x66, this marks the header for the character stats part of the file. Now take everything after the header (not including it) all the way to the footer tag marked by the bytes 0x69 and 0x66 (not including the footer tag). This is your binary-stream. To make sense of it you’ve gotta first reverse the whole thing from a binary stream perspective. That means- convert each byte to a binary number (eg 11011101 01011010 11101101 11111100 01110111 ect ect) then do a ‘string reverse on it’ so ‘11100010 10000000’ becomes ‘0000001 01000111’. This will be the new base for parsing out data.

Once you have the reversed binary, you’ll be looking at the 9-bit stat header to find out which stat comes in the next sequence of bytes. so the binary stream is in a format like this-
“xxxxxxxx xyyyyyyy yyyxxxxx xxxxyyyy yyyyyy…” where x is the 9bit stat id, and y is the value of the stat. Kepp in mind that although the stat id is always 9-bits, the value is not always 10 bits. Here is a function that returns the number of bits in the value for a given stat id-
 
Func_StatIDtoBitCount($in)
$seekBits=0
Switch $in
Case 0 to 4
$seekBits=10
Case 5
$seekBits=8
Case 6 to 11
$seekBits=21
Case 12
$seekBits=7
Case 13
$seekBits=32
Case 14 to 15
$seekBits=25
EndSwitch
Return $seekBits
EndFunc

$in is the statID. But which ID is for which stat? We’ll here’s another function-

func_statIDToName($in)
Switch $in
Case 0x00
Return "Strength"
Case 0x01
Return "Eng"
Case 0x02
Return "Dex"
Case 0x03
Return "Vit"
Case 0x04
Return "Stat Left"
Case 0x05
Return "Skill Left"
Case 0x06
Return "Life"
Case 0x07
Return "Max Life"
Case 0x08
Return "Mana"
Case 0x09
Return "Max Mana"
Case 0x0A
Return "Stam"
Case 0x0B
Return "Max Stam"
Case 0x0C
Return "level"
Case 0x0D
Return "Exp"
Case 0x0E
Return "Gold"
Case 0x0F
Return "Stash Gold"
EndSwitch
Return "Unknown"
EndFunc

Now, the interesting twist to this goes back to what I said initially. It’s backwards twice, so once you have your revese binary stream. Grab the first 9 bits from it. Now take those 9 bits, and reverse them also. This new binary stream is the statID. Use it to look up the bits for the value. Once you have that, grab that many more bits starting from the end of the statID offset. Reverse the bits you grab again and you have your value.

A troublesome method to store the data but it quite efficient. That’s essentially all there is to the file besides the skill data, which is a story for another day perhaps… it starts after the stat data, and its really not to hard to figure out with some trial and error 🙂

Edit:
Some folks wanted some resources for this. Here’s the main pages I used when i was researching it-

These forums – http://phrozenkeep.planetdiablo.gamespy.com/forum/viewforum.php?f=8
in particular this post-
http://phrozenkeep.planetdiablo.gamespy.com/forum/viewtopic.php?t=9011
And these-
http://www.ladderhall.com/ericjwin/109/trevin/trevinfileformat.html
http://diablo2.my-spot.info/109fileformat.html
http://forums.diii.net/showthread.php?t=532037&page=41

Most of them apply to older version but not a lot changes usually with newer releases. There’s not been a drastic overall to the file structure in a long time and I don’t see why’d they’d do one now…Although I personally haven’t looked at the latest incarnation.

Edit 2: I came back and looked at this for 1.12a. Nothing has really changed. I’ll provide this picture though to help convey another method mentioned in jjscuds comment:

Using this method, you don’t reverse the whole binary stream, you just reverse the bits in each byte, then reverse the bits in each bit-field.