Understanding the Knight Online TBL format

[quote name='twostars' timestamp='1296849756' post='1831']
The general KO TBL format's actually pretty simple.
A TBL is comprised of columns, and rows. That's a table - nothing complex there, so let's take a look at the header of an unencrypted TBL and see what we can pull from it.

1.298 item_org_us.tbl:


The first byte you'll see is 0x25, or in decimal: 37.
As you'll find with any TBL editor, there's 37 columns in the 1.298 TBLs, which brings us to the (somewhat assumptive, but otherwise correct) correct notion that the first byte is the column count. Actually, it's a DWORD/int, so it's 4 bytes - so it includes the following 3 0x00 bytes.

Typically, when it declares a count, what follows will be a series of bytes, the number of which dependant on the count, so with that in mind, let's look at the following bytes (which seem to be in a pattern):


You'll note I've gone through and selected 37 (our column count!) groups of 4 bytes which, you can see, lead up to the next section (pattern changes).
These groups of 4 bytes, or again, DWORDS/ints are the column's data-types. Each data-type is represented by a DWORD, they're represented as follows:

1 - signed byte
2 - unsigned byte
3 - signed short
4 - unsigned short
5 - signed int
6 - unsigned int
7 - string (string length defined by prefixed int)
8 - float

These needs to be stored when attempting to interpret the data, otherwise from here on out things will get very tricky.

So, for this TBL, following these rules our columns are:

6 - unsigned int (4 bytes)
2 - unsigned byte (1 byte)
7 - string (length = 4 bytes + the string's actual length, which will be what those prefixed 4 bytes are defined as)
7 - string (length = 4 bytes + the string's actual length, which will be what those prefixed 4 bytes are defined as)
6 - unsigned int (4 bytes)
2 - unsigned byte (1 byte)
6 - unsigned int (4 bytes)
6 - unsigned int (4 bytes)
6 - unsigned int (4 bytes)
6 - unsigned int (4 bytes)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
4 - unsigned short (2 bytes)
4 - unsigned short (2 bytes)
4 - unsigned short (2 bytes)
4 - unsigned short (2 bytes)
4 - unsigned short (2 bytes)
5 - signed int (4 bytes)
5 - signed int (4 bytes)
4 - unsigned short (2 bytes)
2 - unsigned byte (1 byte)
6 - unsigned int (4 bytes)
6 - unsigned int (4 bytes)
1 - signed byte (1 byte)
1 - signed byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)
2 - unsigned byte (1 byte)

Okay, so, so far the structure is:
* int - column count
* int - (for each column) column's data-type

The next bit is just as easy. It's exactly the same. The TBL needs to know how many rows there are, so the next part is obviously.. the row count (again, a DWORD/int [4 bytes]):


As you can see, the first 4 bytes there are the row count (1198). The same deal with the columns, there will be that many rows to follow. They will obviously follow the column structure, otherwise they wouldn't be a table!

So, let's go through the row as a demonstration:


unsigned int (4 bytes) = 30 25 90 06 = 110110000
unsigned byte (1 byte) = 00 = 0

string (length = 4 bytes + the string's actual length, which will be what those prefixed 4 bytes are defined as)
= length = 06 00 00 00 = 6
= string (6 bytes long) = 44 61 67 67 65 72 = Dagger

string (length = 4 bytes + the string's actual length, which will be what those prefixed 4 bytes are defined as)
= length = 00 00 00 00 = 0
= string (0 bytes long) = (no string)

unsigned int (4 bytes) = 00 00 00 00 = 0
unsigned byte (1 byte) = 00 = 0
unsigned int (4 bytes) = B8 03 A8 00 = 11011000
unsigned int (4 bytes) = B8 03 A8 00 = 11011000
unsigned int (4 bytes) = 0E 00 00 00 = 14
unsigned int (4 bytes) = 2D 01 00 00 = 301
unsigned byte (1 byte) = 0B = 11
unsigned byte (1 byte) = 00 = 0
unsigned byte (1 byte) = 00 = 0
unsigned byte (1 byte) = 00 = 0
unsigned byte (1 byte) = 00 = 0
unsigned short (2 bytes) = 06 00 = 6
unsigned short (2 bytes) = 6D 00 = 109
unsigned short (2 bytes) = 0A 00 = 10
unsigned short (2 bytes) = 14 00 = 20
unsigned short (2 bytes) = A0 0F = 4000
signed int (4 bytes) = 7F 01 00 00 = 383
signed int (4 bytes) = 00 00 00 00 = 0
unsigned short (2 bytes) = 00 00 = 0
unsigned byte (1 byte) = 00 = 0
unsigned int (4 bytes) = 00 00 00 00 = 0
unsigned int (4 bytes) = 00 00 00 00 = 0
signed byte (1 byte) = 08 = 8
signed byte (1 byte) = 63 = 99
unsigned byte (1 byte) = 00 = 0
unsigned byte (1 byte) = 00 = 0
unsigned byte (1 byte) = 00 = 0
unsigned byte (1 byte) = 00 = 0
unsigned byte (1 byte) = 42 = 66
unsigned byte (1 byte) = 00 = 0
unsigned byte (1 byte) = 00 = 0
unsigned byte (1 byte) = C9 = 201
unsigned byte (1 byte) = 01 = 1

..and we're done!

Take a look at the same file in a TBL editor:


As you can't see it all in that screenshot, here's the row:
110110000 0 Dagger 0 0 11011000 11011000 14 301 11 0 0 0 0 6 109 10 20 4000 383 0 0 0 0 0 8 99 0 0 0 0 66 0 0 201 1

... you can see that we definitely got it!

The rows are the last part of the TBL's structure, it really is that simple!

The final structure (it's really complex isn't it?!!):

* int - column count
* int - (for each column) column's data-type
* int - row count
* (each row following the column structure defined above)

It's really pretty straightforward.
[/quote]