OBJECT DAT FILES

Back to RCT TID home

Last Updated September 18, 2004

Many thanks go to Jonathon Wilson for determing much of the information on this page!

The visual items in RCT2 are stored in the g1.dat file in the data directory and as individual dat files in the objdata directory.

The dat files begin with a sixteen byte "DAT File Header". The first four bytes are flags. The next eight bytes are the ASCII characters of the file name (padded with trailing spaces as needed). The next four bytes are a checksum. The DAT File Header is followed by an encoded data chunk. It is the same type of encoding as described on the SV6/SC6 page. (The first byte specifies the type of encoding; the next four bytes are the size.) The remainder of the description here is based on the decoded file. This is a "work in progress"! I am using the following model for the Dat file structure:

The first byte of the DAT File Header contains a flag to identify the type of dat file. Use the lower four bits to identify the type (0 through 0x0A) of the object. Every object has a DAT File Header, Object Header (different for each object type) and a String Table.

DAT File Header: The high nibble of the first byte of the Flags is used to determine if this is a standard (original=8, 1st expansion pack=1) or custom object (high nibble=0). Also, the lower four bits of the first byte determine the "Type" of the object as described below. The remainder of Flags can be ignored. The last byte of Flags is 0x00 for RCT2 custom files made with my editor, 0x09 for original RCT2 files, and 0x0C for RCT2 expansion pack files. Custom files made with other programs may have any value at this spot. I highly recommend using 0x00.

Flags : longword
filename : 8 bytes
checksum : longword

The Checksum is calculated by starting with the value 0xF369A75B. Read one byte at a time from the decoded file. Start with the first byte of the file, then skip the next three bytes. Then read the eight bytes of the Filename. Skip the four bytes of the checksum (you're calculating it now!). Then process each byte of the remainder of the (decoded) file.

Each byte is processed by XOR'ing it with the low byte of CheckSum. Then CheckSum is rotated left by eleven bits. (this was errantly listed as thirteen earlier)

Object Header: Following the DAT File Header is a "Object Header" which is a different structure (and size) for each object type. Here are some Delphi definitions for some of the Object Headers and their flags:

TType1Header = packed record
{00} MsgRef        : word;     // zero
{02} Fill_1        : longword; // zero
{06} Flags         : longword; // zero
{0A} Height        : byte;
{0B} CursorSel     : byte;
{0C} BuildFee      : smallint;
{0E} RemoveFee     : smallint;
{10} GraphicsStart : longword; // zero in DAT files
{14} Anim1         : word;     // Delay between individual frames of animation - controls speed
{16} Anim2         : word;     // bits0..4: animation counter mask (ie. sequence length - 1)
                               // bit 5: 0=continuous animation (sequence length should be a power of 2)
                               // bit 5: 1=intermittent; bits 6 and up indicate interval length
{18} Anim3         : word;     // Length of animation sequence (limit to 0x80)
{1A} BaseIndex     : byte;     // zero in DAT files
{1B} Fill_2        : byte;     // zero in DAT files
end;

TType2Header = packed record // Large Scenery : length = 1A
{00}reserved0 : word;        // Always zero in files
{02}reserved1 : longword;    // Always zero in files
{06}CursorSel : byte;
{07}flags     : byte;        // bit 3 = 3D sign
{08}BuildFee  : word;
{0A}RemoveFee : smallint;
{0C}reserved2 : longword;    // Always zero in files
{10}reserved3 : byte;        // Always zero in files
{11}Scrolling : byte;        // 0xFF if not scrolling, otherwise, indicates scrolling direction, location
{12}reserved4 : longword;    // Always zero in files
{16}reserved5 : longword;    // Always zero in files
end;

TType2TileSpec = packed record
  Row       : smallint; // div by 32
  Col       : smallint; // div by 32
  Z         : smallint; // div by 16
  Clearance : byte;     // div by 8
  Unknown1  : byte;     // bit 5 is set to indicate no supports
  Flags     : byte;     // upper nibble=tile occupation (F=full tile), lower nibble=walls (0=all sides)
end;


TType3Header = packed record // Walls : length = 14.
{00}reserved0 : word; // Always zero in files
{02}reserved1 : longword; // Always zero in files
{06}CursorSel : byte; //
{07}Flags     : byte;
{08}Clearance : byte; //
{09}Effects   : byte; // first nibble = visibility (0 = opaque), upper nibble: 1 = animated (8 frames)
{0A}BuildFee  : word; // X 10.
{0C}reserved2 : byte; // Always zero in files
{0D}Scrolling : byte; // 0xFF if not scrolling
end;

TType4Header = packed record // Banners : length = 12.
{00}reserved0 : word;     // always zero
{02}reserved1 : longword; // always zero
{06}Scrolling : byte;     // 0xFF if not scrolling, otherwise, indicates scrolling direction, location
{07}Flags : byte;
{08}BuildFee : word;      // X 10. refund is 75% (rounded down)
{0A}reserved2 : word;     // always zero
end;

TType6Header = packed record // Path Additions : length = 14.
{00}reserved0 : word;     // Always zero in files
{02}reserved1 : longword; // Always zero in files
{06}Flags : word;
{08}Subtype : byte;
{09}CursorSel : byte;
{0A}BuildFee : word;      // X 10.
{0C}reserved2 : byte;     // Always zero in files
{0D}unknown1 : byte;      // Always zero in files
end;

Subtypes:

0 = Lamp (edge centered, 1 dialog view, 2 frames of static (normal and vandalized)

1 = Litter bin (edge centered/inset, 1 dialog view, 3 frames of static (normal and vandalized, and full)

2 = Bench (edge centered/inset, 1 dialog view, 2 frames of static (normal and vandalized)

3 = Jump fountain (corners, 1 dialog view, 1 frame of static)

String Table(s): Folowing the Object Header is a string table containing text in different languages.Each string begins with a byte to specify the language.

The string immediately follows that byte and is null terminated. An 0xFF for the Language code indicates the end of the strings. Type 0 and 10 objects have three string tables; other types have one string table.

Group Info: a sixteen byte structure. There is a four byte value. This is followed by an eight byte string indicating which scenery group file this item belongs to (if any). That is followed by a 4-byte value.

Flag : longword (first byte is 0xFF if default item - 87 for official groups, 07 for custom groups)
FileName : 8 bytes
Checksum: longword = 0

Image directory: First is a 4-byte value which specifies how many images are in the file. Then a 4-byte value which specifies the length of the scan line graphic data (starting after the image directory). Then there is a sixteen byte entry for each image. It uses the same format as the csg1i.dat file of RCT1.

TGraphicRecord = record
StartAddress : longword;
Width, Height, Xoffset, Yoffset : smallint; // signed two byte variables
Flags : word;
unused : word // to pad the structure to 16 bytes
end;

StartAddress points to the start of the scan line index in the file. It is an offset rather than an absolute address - the first scan line index has a StartAddress of 00000000.