ModdingWiki - Recent changes [en-gb]

DAT Format (Shadowcaster)

Diema — Thu, 06 Aug 2026 14:50:54 GMT

Initial draft

New page

== Overview ==
[[Shadowcaster]] contains two forms of DAT archive. This page is about the game's WAD-like game data archives. Another page details the [[Cutscene Format (Shadowcaster)|cutscene DAT format]].

A Shadowcaster game-data archive has the following general structure:
<syntaxhighlight lang="cpp">
uint16_t NumRecords; // the number of sub-files contained in this archive.
uint32_t Directory; // an offset from the start of this file to the beginning of the record list.

uint8_t DataRegion[...]; // raw sub-file data. there can be hidden sections here; a sub-file's start does not have to begin right after the end of the previous.

// within each sub-file record is the following format:
uint32_t Offset; // offset to the start of the data, from the beginning of the file.
uint32_t Size; // the sub-file's size in bytes.
uint16_t NameOfs; // a pointer from the beginning of the directory to a null-terminated string. this can be zero.
uint16_t Flags; // in the floppy version, this is always zero. in the CD version, a value of 1 indicates RLE compression.
</syntaxhighlight>

=== Record Names ===
In this format, sub-file records do not have to have a name.

The underlying logic of this is that the game will often request a specific named lump, then refer to unnamed records using an ID offset from that. For example, if the lump named "view" is lump #0, then the game can refer to "view+5" to refer to lump #5, and therefore, lump #5 does not have to store its name. In such a case, <code>NameOfs = 0</code>.

By convention, SLADE and MapCaster notate the names of these lumps as ID offsets from the last named entry found.

== Reading a DAT Archive ==
Adapted from MapCaster GML:
<syntaxhighlight lang="cpp">
NumRecords = buffer_read(buf, buffer_u16);
Directory = buffer_read(buf, buffer_u32);

buffer_seek(buf, buffer_seek_start, Directory);
for(z = 0; z < NumRecords; z++) {
Records[z] = ds_map_create();

r = Records[z];
r[? "Offset"] = buffer_read(buf, buffer_u32);
r[? "Size"] = buffer_read(buf, buffer_u32);
r[? "NameOffset"] = buffer_read(buf, buffer_u16);
r[? "Flags"] = buffer_read(buf, buffer_u16);

// name all lumps
if(r[? "NameOffset"] != 0) {
last_name = 0;
prev_ofs = buffer_tell(buf);

// seek to the name table
buffer_seek(buf, buffer_seek_start, Directory + r[? "NameOffset"]);

r[? "Name"] = ReadString(...); // read until 0x00 is encountered

// go back to where we were before in reading the directory
buffer_seek(buf, buffer_seek_start, prev_ofs);
}
else { // if the lump has no name, treat it as being
// named as an offset from the previous named lump
last_name++;
l = Records[z - last_name];
r[? "Name"] = l[? "Name"] + "+" + string(last_name);
}
}
</syntaxhighlight>

Shadowcaster

Diema — Thu, 06 Aug 2026 14:39:13 GMT

Update to also put DAT format spec in, acknowledge a difference between ravdata and cutscene DATs

← Older revision		Revision as of 14:39, 6 August 2026
(One intermediate revision by the same user not shown)
Line 32:		Line 32:
	\| Name = [https://www.doomworld.com/forum/topic/155625-mapcaster-level-editor-for-shadowcaster/ MapCaster]		\| Name = [https://www.doomworld.com/forum/topic/155625-mapcaster-level-editor-for-shadowcaster/ MapCaster]
	\| Platform = Windows		\| Platform = Windows
	\| grp = No		\| grp = Edit
	\| map = Edit		\| map = Edit
	\| gfx = No		\| gfx = No
Line 67:		Line 67:
	\| KnownFormat = Yes		\| KnownFormat = Yes
	\| Desc = Sound effects		\| Desc = Sound effects
			}}
			{{GameFile
			\| Name = ravdata.dat
			\| Format = [[DAT Format (Shadowcaster)]]
			\| KnownFormat = Yes
			\| Desc = Data archive
			}}
			{{GameFile
			\| Name = *.dat
			\| Format = [[Cutscene Format (Shadowcaster)]]
			\| KnownFormat = No
			\| Desc = Cutscenes
	}}		}}
	{{GameFile		{{GameFile

OJT Format (Shadowcaster)

Diema — Thu, 06 Aug 2026 14:27:18 GMT

Initial draft

New page

== Overview ==
[[Shadowcaster]] OJT files describe a list of static objects present in a given level. These files are a linear list of 57-byte records with no header.
<syntaxhighlight lang="cpp">
uint32_t Tag; // does not have to necessarily be unique.
uint32_t Ptr_Prev; // typically if there is a previous OJT record before this one, this is set to sizeof(ojt_record) (57).
uint32_t Ptr_Next; // same as above, but forwards in the file.
uint8_t Collision; // typically zero for a non-solid object, or 1 for a solid one.
uint8_t Gravity; // a bitfield describing the object's relationship to gravity.
// some known values: 0 = no gravity; 1 = hangs from ceiling; 3 = spawn on ceiling, subject to gravity.
char DisplayName[20]; // not used by the game. a string that usually contains the name of the sprite used. seems to be an editor leftover?
uint32_t Pic; // a literal lump number from RAVDATA.DAT. This is the graphic the object will use in the 3D view.
uint32_t Width; // the object's width (or "radius" if you prefer), represented in frac-units (0-63 within a tile).
uint32_t Height; // same as the above, but the object's height along Z+.
uint32_t Unknown;
uint8_t TileX;
uint8_t TileY; // the object's coarse tile X/Y coordinates (0-31 are valid).
uint8_t Sides; // the number of sides the sprite has. for example: 0 = one-sided sprite, 8 = eight-sided sprite (like Doom).
uint16_t SubTileX;
uint16_t SubTileY; // the object's sub-tile X/Y fractional values (0-63 are valid).
</syntaxhighlight>

== Reading an OJT file ==
Adapted from MapCaster GML:
<syntaxhighlight lang="cpp">
for(i = 0; i < NumOjtsInFile; i++) {
ojt.Tag = buffer_read(ojt_file, buffer_u32);
ojt.Ptr_Prev = buffer_read(ojt_file, buffer_u32);
ojt.Ptr_Next = buffer_read(ojt_file, buffer_u32);
ojt.Collision = buffer_read(ojt_file, buffer_u8);
ojt.Gravity = buffer_read(ojt_file, buffer_u8)
ojt.DisplayName = ReadString(20);
ojt.Pic = buffer_read(ojt_file, buffer_u32);
ojt.Width = buffer_read(ojt_file, buffer_u32);
ojt.Height = buffer_read(ojt_file, buffer_u32);
ojt.Unknown = buffer_read(ojt_file, buffer_u32);
ojt.x = buffer_read(ojt_file, buffer_u8) * TILESIZE; // TILESIZE = 64 in Shadowcaster
ojt.y = buffer_read(ojt_file, buffer_u8) * TILESIZE; // TILESIZE = 64 in Shadowcaster
ojt.Sides = buffer_read(ojt_file, buffer_u8);
ojt.x += buffer_read(ojt_file, buffer_u16);
ojt.y += buffer_read(ojt_file, buffer_u16);
}
</syntaxhighlight>

LIB Format (Shadowcaster)

Diema — Thu, 06 Aug 2026 13:23:17 GMT

Initial draft

New page

== Overview ==

[[Shadowcaster]] .lib archives can be considered the "ancestor" of the Doom WAD format. They are mostly similar, realistically only differing in how you are expected to find the sub-file directory.

At the high level, .lib archives consist of a data region, the directory region, and finally the number of records stored at the very end of the file.

=== Data Region ===

The data region is simply every file's contents, concatenated end-to-end. There can possibly be "hidden" sections; one file does not necessarily need to exactly start at the end of the previous, or itself end at the start of the next.

In the case of .lib files, mostly level data and music are stored; graphics are stored in [[DAT Format (Shadowcaster)|DAT files]].

=== Directory ===

The directory immediately precedes the record count, and consists of a number of 21-byte entries with the following format:
<syntaxhighlight lang="cpp">
uint32_t Size;
uint32_t Offset; // from beginning of file
char RecordName[13];
</syntaxhighlight>

=== Record Count ===

Determining how many records are stored in the directory is done by seeking to the end of the file and reading the final uint16_t found there.

== Reading a lib file ==

Adapted from MapCaster GML:
<syntaxhighlight lang="cpp">
// first, we get the number of records and construct a pointer to the start of the directory
buffer_seek(Lib, buffer_seek_start, filesize - 2);
NumRecords = buffer_read(Lib, buffer_u16);
// offset to the start of the directory:
Directory = filesize - 2 - (NumRecords * 21);

// seek to the start of the directory
buffer_seek(Lib, buffer_seek_start, Directory);

// Read all entries until the end
for(i = 0; i < NumRecords; i++) {
Records[i] = ds_map_create();
r = Records[i];
r[? "Size"] = buffer_read(Lib, buffer_u32);
r[? "Offset"] = buffer_read(Lib, buffer_u32);

// read the name string
r[? "Name"] = ReadString(13); // directory subfile names are always exactly 13 bytes and follow 8.3 DOS filename convention, and are null-terminated

}</syntaxhighlight>