PeopleSprites*.dat

[locatellidaniel]

I know its confusing, and I'm looking at ways to explain this better, since I discovered this by trial and error.

At the bottom there is the Imhex pattern, and also a tiny html/js tool that does the parsing and renders the animations.

Main File structure

1. Variations
2. MidHeader << I still have to figure this one out.
3. Animations
4. Bitmaps
5. LayerGroups

1. Variations

The first chunk is an array of what I call "variations". A variation is a valid combination of all the layerGroups of an animation. You cannot have for example a woman body with man legs, or a person carrying two things in the same hand.
So this represent all valid LayerGroup combinations. Interestingly this is the only thing that seems to change between PeopleSprites* files.

2. MidHeader

I have yet not found out what this chunk means.

3. Animations

This is an array of Animations (length of 101 per file).

The animation structure is:

• Animation
  • Directions[]
    • Frames[]
      • indexes[]
      • layerGroups[]

Each animation contains usually 8 "Directions", that correspond to each possible isometric rotation of the animated object.

A Direction is an array of "Frames".

A Frame is composed of a set of references to "BitmapChunks" and a particular render order. The references are "indexes" and "layerGroups".

4. Bitmaps

This part is an array of bitmap chunks, which is byte data of image, similar to locations.dat where one byte corresponds to a color in the palette, but also some extra data like: position to draw the chunk in the frame, width and height of the chunk and more.

The bitmaps are not as straightforwards as it seems, there is sth that feels buggy. The last columns of pixels, should actually be the first column, and viceversa. I'm not sure why this is or is sth wrong with my code.

5. LayerGroups

There are 25 LayerGroups defined in each file. A LayerGroup groups together the BitmapChunks that are somehow related.

For example, the LayerGroup 0 represents all the BitmapChunks of "Legs".
It is an array of 6 elements. Each of these elements is a "Variation" of Legs:

• 0: being dark pants
• 1: being gray pants
• 2: ...etc

So each LayerGroup is actually an array of indexes to the BitmapChunks array.
i.e. LayerGroup 0 ("Legs") is an array of numbers [0,448,...] which are indexes of the BitmapChunks array where the leg bitmaps start.

Rendering

Once all the data is loaded in memory. Rendering a Frame of an Animation is drawing all BitmapChunks that correspond to the selected Variation.

I cannot explain this without showing code, so it's better if I leave you what I have and we can start from there.

Pattern Code

The imhex pattern definition:

#pragma pattern_limit 1000000

// Each variation has an index corresponding to each LayerGroup
//  When the index is FF (255) that layer should not be drawn.
struct Variation {
	le u8 layer_group_variation_index[24]  [[color("00fff0")]];
	padding[1];
};


// The secondary part of the file, not really sure what it means
struct MidHeader {
	le u16 size;
	padding[2];
	le u16 data[size];
	le u8 flag;
	if (flag == 0x00) {
		padding[3];
	} else if (flag == 0x01) {
		padding[5];
	}
};


// Guess: this is a frame description for an animation, describing the bitmapchunks to draw
// The first data is the indexes
// The second piece of data is the layer group
struct Frame {
	u8 count  [[color("00ffff")]];
	le u16 index[count] [[color("cccccc")]];
	
	u8 layer_group[count] [[color("333399")]];
	padding[1];
};

//
// Each animation has usually 8 "Directions", corresponding to an angle in the iso view.
struct Direction {
	le u8 frame_count [[color("ff0000")]];
	Frame frames[frame_count];
};

// 
// 
struct Animation {
	le u8 direction_count [[color("00ff00")]];
	Direction directions[direction_count];
};


// The header for the bitmap data
struct BitmapChunkHeader {
	le u16 width [[color("00ff00")]];
	le u16 height [[color("00dd00")]];
	le u16 x [[color("ff0000")]];
	le u16 y [[color("990000")]];
	le u16 frame_width [[color("00dd00")]];// always 0x80
	le u16 frame_height [[color("00dd00")]];// always 0x60
	le u32 counter [[color("00ffff")]]; // <<<<< mystery

};

// Sprite bitmap data
struct BitmapChunk {
	BitmapChunkHeader header;
	u8 pixel_data[header.width*header.height] [[color("666666")]];
};


struct BitmapChunkIndex {
	le u16 start [[color("fff000")]];
	padding[2];
};

struct LayerGroup {
	u8 count;
	BitmapChunkIndex index[count];
};


//
//
//


// Variations
le u16 variation_count @ 0x0;
Variation variations[variation_count] @ $;

// MID
le u16 mid_header_count  @ $;
MidHeader mid_headers[mid_header_count] @ $;

// ANIMATIONS
u8 animation_count @ $;
Animation animations[animation_count] @ $;

// Bitmap CHUNKS
le u16 sprite_chunk_count @ $;
le u16 some_padding @ $; // 2 byte padding
BitmapChunk bitmap_chunks[sprite_chunk_count] @ $;

// Layer Groups
LayerGroup layer_groups[25] @ 0x3884fb;

Parsing and Rendering Tool

A first draft version of a JS tool to render and test the content of a PeopleSprites file. Please forgive the ugly coding, will clean it up later.

Instructions:

• Unzip somwhere
• open the html file
• Click open file and open a PeopleSprites.dat file.

gocrespriter-v1.zip