/* read_win_bminfoheader:
* Reads information from a BMP file header.
*/
static int read_win_bminfoheader(ALLEGRO_FILE *f, BMPINFOHEADER *infoheader)
{
WINBMPINFOHEADER win_infoheader;
win_infoheader.biWidth = al_fread32le(f);
win_infoheader.biHeight = al_fread32le(f);
win_infoheader.biPlanes = al_fread16le(f);
win_infoheader.biBitCount = al_fread16le(f);
win_infoheader.biCompression = al_fread32le(f);
win_infoheader.biSizeImage = al_fread32le(f);
win_infoheader.biXPelsPerMeter = al_fread32le(f);
win_infoheader.biYPelsPerMeter = al_fread32le(f);
win_infoheader.biClrUsed = al_fread32le(f);
win_infoheader.biClrImportant = al_fread32le(f);
infoheader->biWidth = win_infoheader.biWidth;
infoheader->biHeight = win_infoheader.biHeight;
infoheader->biBitCount = win_infoheader.biBitCount;
infoheader->biCompression = win_infoheader.biCompression;
infoheader->biClrUsed = win_infoheader.biClrUsed;
if (al_feof(f) || al_ferror(f)) {
ALLEGRO_ERROR("Failed to read file header\n");
return -1;
}
return 0;
}
T3F_TILEMAP * t3f_load_tilemap_f(ALLEGRO_FILE * fp)
{
int i, j, k, w, h;
T3F_TILEMAP * tmp;
char header[16];
al_fread(fp, header, 16);
if(strcmp(header, "T3F_TILEMAP"))
{
return NULL;
}
tmp = malloc(sizeof(T3F_TILEMAP));
if(!tmp)
{
return NULL;
}
switch(header[15])
{
case 0:
{
tmp->layers = al_fread16le(fp);
for(i = 0; i < tmp->layers; i++)
{
tmp->layer[i] = malloc(sizeof(T3F_TILEMAP_LAYER));
w = al_fread16le(fp);
h = al_fread16le(fp);
tmp->layer[i] = t3f_create_tilemap_layer(w, h);
for(j = 0; j < tmp->layer[i]->height; j++)
{
for(k = 0; k < tmp->layer[i]->width; k++)
{
tmp->layer[i]->data[j][k] = al_fread16le(fp);
}
}
tmp->layer[i]->x = t3f_fread_float(fp);
tmp->layer[i]->y = t3f_fread_float(fp);
tmp->layer[i]->z = t3f_fread_float(fp);
tmp->layer[i]->scale = t3f_fread_float(fp);
tmp->layer[i]->speed_x = t3f_fread_float(fp);
tmp->layer[i]->speed_y = t3f_fread_float(fp);
tmp->layer[i]->flags = al_fread32le(fp);
}
tmp->flags = al_fread32le(fp);
break;
}
}
return tmp;
}
static ALLEGRO_FILE *get_next_chunk(ALLEGRO_FILE *file)
{
/* Reads the length of the next chunk, and if not at end of file, returns a
slice that represents that portion of the file. */
const uint32_t length = al_fread32le(file);
return !al_feof(file) ? al_fopen_slice(file, length, "rw") : NULL;
}
/* read_bmfileheader:
* Reads a BMP file header and check that it has the BMP magic number.
*/
static int read_bmfileheader(ALLEGRO_FILE *f, BMPFILEHEADER *fileheader)
{
fileheader->bfType = al_fread16le(f);
fileheader->bfSize = al_fread32le(f);
fileheader->bfReserved1 = al_fread16le(f);
fileheader->bfReserved2 = al_fread16le(f);
fileheader->bfOffBits = al_fread32le(f);
if (fileheader->bfType != 19778) {
ALLEGRO_ERROR("Not BMP format\n");
return -1;
}
if (al_feof(f) || al_ferror(f)) {
ALLEGRO_ERROR("Failed to read file header\n");
return -1;
}
return 0;
}
/* vector object IO */
T3F_VECTOR_OBJECT * t3f_load_vector_object_f(ALLEGRO_FILE * fp)
{
T3F_VECTOR_OBJECT * vp = NULL;
T3F_VECTOR_SEGMENT segment;
int r, g, b, a;
char header[16] = {0};
int i;
int segments = 0;
if(al_fread(fp, header, 16) != 16)
{
return NULL;
}
if(stricmp(header, "T3FV"))
{
return NULL;
}
vp = t3f_create_vector_object();
if(!vp)
{
return NULL;
}
segments = al_fread32le(fp);
for(i = 0; i < segments; i++)
{
segment.point[0].x = t3f_fread_float(fp);
segment.point[0].y = t3f_fread_float(fp);
segment.point[0].z = t3f_fread_float(fp);
segment.point[1].x = t3f_fread_float(fp);
segment.point[1].y = t3f_fread_float(fp);
segment.point[1].z = t3f_fread_float(fp);
r = al_fgetc(fp);
g = al_fgetc(fp);
b = al_fgetc(fp);
a = al_fgetc(fp);
segment.color = al_map_rgba(r, g, b, a);
segment.thickness = t3f_fread_float(fp);
if(!t3f_add_vector_segment(vp, segment.point[0].x, segment.point[0].y, segment.point[0].z, segment.point[1].x, segment.point[1].y, segment.point[1].z, segment.color, segment.thickness))
{
return NULL;
}
}
return vp;
}
T3F_ANIMATION * t3f_load_animation_f(ALLEGRO_FILE * fp, const char * fn)
{
T3F_ANIMATION * ap;
int i;
char header[12] = {0};
int ver;
int fpos = 0;
ALLEGRO_STATE old_state;
ALLEGRO_BITMAP * bp;
al_fread(fp, header, 12);
ver = check_header(header);
if(ver < 0)
{
return NULL;
}
ap = t3f_create_animation();
if(ap)
{
switch(ver)
{
case 0:
{
ap->bitmaps->count = al_fread16le(fp);
for(i = 0; i < ap->bitmaps->count; i++)
{
ap->bitmaps->bitmap[i] = t3f_load_resource_f((void **)(&ap->bitmaps->bitmap[i]), T3F_RESOURCE_TYPE_BITMAP, fp, fn, 1, 0);
}
ap->frames = al_fread16le(fp);
for(i = 0; i < ap->frames; i++)
{
ap->frame[i] = al_malloc(sizeof(T3F_ANIMATION_FRAME));
if(!ap->frame[i])
{
return NULL;
}
ap->frame[i]->bitmap = al_fread16le(fp);
ap->frame[i]->x = t3f_fread_float(fp);
ap->frame[i]->y = t3f_fread_float(fp);
ap->frame[i]->z = t3f_fread_float(fp);
ap->frame[i]->width = t3f_fread_float(fp);
ap->frame[i]->height = t3f_fread_float(fp);
ap->frame[i]->angle = t3f_fread_float(fp);
ap->frame[i]->ticks = al_fread32le(fp);
ap->frame[i]->flags = al_fread32le(fp);
}
ap->flags = al_fread32le(fp);
break;
}
case 1:
{
ap->bitmaps->count = al_fread16le(fp);
for(i = 0; i < ap->bitmaps->count; i++)
{
fpos = al_ftell(fp);
ap->bitmaps->bitmap[i] = t3f_load_resource_f((void **)(&ap->bitmaps->bitmap[i]), T3F_RESOURCE_TYPE_BITMAP, fp, fn, 0, 0);
if(!ap->bitmaps->bitmap[i])
{
al_fseek(fp, fpos, ALLEGRO_SEEK_SET);
al_store_state(&old_state, ALLEGRO_STATE_NEW_BITMAP_PARAMETERS);
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
bp = t3f_load_bitmap_f(fp);
al_restore_state(&old_state);
if(bp)
{
ap->bitmaps->bitmap[i] = t3f_squeeze_bitmap(bp, NULL, NULL);
al_destroy_bitmap(bp);
}
}
else if(al_get_bitmap_flags(ap->bitmaps->bitmap[i]) & ALLEGRO_MEMORY_BITMAP)
{
bp = t3f_squeeze_bitmap(ap->bitmaps->bitmap[i], NULL, NULL);
al_destroy_bitmap(ap->bitmaps->bitmap[i]);
ap->bitmaps->bitmap[i] = bp;
}
if(!ap->bitmaps->bitmap[i])
{
return NULL;
}
}
ap->frames = al_fread16le(fp);
for(i = 0; i < ap->frames; i++)
{
ap->frame[i] = al_malloc(sizeof(T3F_ANIMATION_FRAME));
if(!ap->frame[i])
{
return NULL;
}
ap->frame[i]->bitmap = al_fread16le(fp);
ap->frame[i]->x = t3f_fread_float(fp);
ap->frame[i]->y = t3f_fread_float(fp);
ap->frame[i]->z = t3f_fread_float(fp);
ap->frame[i]->width = t3f_fread_float(fp);
ap->frame[i]->height = t3f_fread_float(fp);
ap->frame[i]->angle = t3f_fread_float(fp);
ap->frame[i]->ticks = al_fread32le(fp);
ap->frame[i]->flags = al_fread32le(fp);
}
ap->flags = al_fread32le(fp);
break;
}
}
}
t3f_animation_build_frame_list(ap);
return ap;
}
T3F_TILESET * t3f_load_tileset_f(ALLEGRO_FILE * fp, const char * fn)
{
int i, j;
T3F_TILESET * tsp;
char header[16];
tsp = t3f_create_tileset(0, 0);
if(!tsp)
{
return NULL;
}
al_fread(fp, header, 16);
if(strcmp(header, "T3F_TILESET"))
{
t3f_destroy_tileset(tsp);
return NULL;
}
switch(header[15])
{
case 0:
{
/* read tile data */
tsp->tiles = al_fread16le(fp);
for(i = 0; i < tsp->tiles; i++)
{
tsp->tile[i] = t3f_create_tile();
tsp->tile[i]->ap = t3f_load_animation_f(fp, fn);
if(!tsp->tile[i]->ap)
{
printf("load animation failed\n");
return NULL;
}
tsp->tile[i]->flags = al_fread32le(fp);
/* read user data */
if(tsp->tile[i]->flags & T3F_TILE_FLAG_USER_DATA)
{
for(j = 0; j < T3F_TILE_MAX_DATA; j++)
{
tsp->tile[i]->user_data[j] = al_fread32le(fp);
}
}
/* read animation frames */
tsp->tile[i]->frame_list_total = al_fread32le(fp);
for(j = 0; j < tsp->tile[i]->frame_list_total; j++)
{
tsp->tile[i]->frame_list[j] = al_fread16le(fp);
}
}
/* read tileset data */
tsp->width = al_fread32le(fp);
tsp->height = al_fread32le(fp);
tsp->flags = al_fread32le(fp);
break;
}
}
return tsp;
}
void WorldStage::LoadMapFromFileOrCreateNewMap()
{
const int MAP_WIDTH = 80;
const int MAP_HEIGHT = 80;
const int ARBITRARY_NUMBER_OF_WALLS = 20;
const int VALID_VERSION = 0;
currentMap = new RegionalMap();
currentMap->InitToField(MAP_WIDTH, MAP_HEIGHT, 0);
//Determine map player is on
int mapX = 0, mapY = 0;
auto player = actorList.GetActor(1);
if(player)
{
mapX = player->x/MAP_WIDTH;
mapY = player->y/MAP_HEIGHT;
}
//Load that one
std::stringstream ss;
ss << "region." << mapX << "." << mapY;
//Try to load the region by that name
ALLEGRO_FILE *file = al_fopen(ss.str().c_str(), "r");
if(file)
{
const int BUF_SIZE = 512;
char buffer[BUF_SIZE];
bool isValid = true;
if(!al_fgets(file, buffer, BUF_SIZE))
{
std::string str = buffer;
if(!str.empty() && str[str.length()-1] == '\n') str.erase(str.length()-1);
if(strcmp(str.c_str(), "b272bda9bf0c1cdcba614b5ed99c4d62") != 0)
{
isValid = false;
}
}
if(isValid && !al_fgets(file, buffer, BUF_SIZE))
{
std::string str = buffer;
if(!str.empty() && str[str.length()-1] == '\n') str.erase(str.length()-1);
if(strcmp(str.c_str(), "0") != 0)
{
isValid = false;
}
}
if(isValid)
{
for(int y = 0; y < MAP_HEIGHT; y++) for(int x = 0; x < MAP_WIDTH; x++)
{
//returns bytes read, 32bits = 4 bytes
int material = al_fread32le(file);
if(!al_feof(file))
{
currentMap->tile[x][y].materialTypeIndex = material;
}
}
//Get actor IDs
int actorId = al_fread32le(file);
while(!al_feof(file))
{
currentMap->actorIDs.push_back(actorId);
actorId = al_fread32le(file);
}
}
al_fclose(file);
}
else //no file
{
for(int nWalls = 0; nWalls < ARBITRARY_NUMBER_OF_WALLS; nWalls++)
{
//Manually place down some walls to run into
int x = rng::Rand(MAP_WIDTH);
int y = rng::Rand(MAP_HEIGHT);
currentMap->tile[x][y].materialTypeIndex = 1;
}
}
}
