TbBool setup_heap_manager(void)
{
SYNCDBG(8,"Starting");
const char *fname;
long i;
//_DK_setup_heap_manager();
if (heap == NULL)
{
ERRORLOG("Graphics Heap not allocated");
return false;
}
i = heap_size / 512;
if (i >= KEEPSPRITE_LENGTH)
i = KEEPSPRITE_LENGTH-1;
graphics_heap = heapmgr_init(heap, heap_size, i);
if (graphics_heap == NULL)
{
ERRORLOG("Not enough memory to initialize heap.");
return false;
}
wait_for_cd_to_be_available();
fname = prepare_file_path(FGrp_StdData,"creature.jty");
//TODO CREATURE_SPRITE Use rewritten file handling when reading is rewritten
file_handle = _DK_LbFileOpen(fname, Lb_FILE_MODE_READ_ONLY);
if (file_handle == -1) {
ERRORLOG("Can not open 'creature.jty'");
return false;
}
for (i=0; i < KEEPSPRITE_LENGTH; i++)
keepsprite[i] = NULL;
for (i=0; i < KEEPSPRITE_LENGTH; i++)
heap_handle[i] = NULL;
return true;
}
TbBool load_slab_tng_file(void)
{
char *fname;
SYNCDBG(5,"Starting");
fname = prepare_file_fmtpath(FGrp_StdData,"slabs.tng");
wait_for_cd_to_be_available();
if ( LbFileExists(fname) )
LbFileLoadAt(fname, &game.slabobjs_num);
else
ERRORLOG("Could not load slab object set");
return true;
}
TbBool load_ceiling_table(void)
{
char *fname;
TbFileHandle fh;
unsigned short *value_array;
char nchr;
char numstr[8];
TbBool do_next;
long i,n;
//_DK_load_ceiling_table(); return true;
// Prepare filename and open the file
wait_for_cd_to_be_available();
fname = prepare_file_path(FGrp_StdData,"ceiling.txt");
fh = LbFileOpen(fname, Lb_FILE_MODE_READ_ONLY);
if (fh == -1) {
return false;
}
value_array = &floor_to_ceiling_map[0];
n = 0;
do_next = 1;
while (do_next == 1)
{
{
do_next = LbFileRead(fh, &nchr, 1);
if (do_next != 1)
break;
if ( (nchr == 10) || (nchr == 44) || (nchr == 32) || (nchr == 9) || (nchr == 13) )
continue;
}
LbMemorySet(numstr, 0, sizeof(numstr));
for (i=0; i < sizeof(numstr); i++)
{
numstr[i] = nchr;
do_next = LbFileRead(fh, &nchr, 1);
if (do_next != 1)
break;
if ( (nchr == 10) || (nchr == 44) || (nchr == 32) || (nchr == 9) || (nchr == 13) )
break;
}
value_array[n] = atol(numstr);
n++;
if (n >= sizeof(floor_to_ceiling_map)/sizeof(floor_to_ceiling_map[0]))
{
do_next = 0;
}
}
LbFileClose(fh);
memcpy(_DK_floor_to_ceiling_map,floor_to_ceiling_map,sizeof(floor_to_ceiling_map));
return true;
}
/**
* Loads map file with given level number and file extension.
* @return Returns NULL if the file doesn't exist or is smaller than ldsize;
* on success, returns a buffer which should be freed after use,
* and sets ldsize into its size.
*/
unsigned char *load_single_map_file_to_buffer(LevelNumber lvnum,const char *fext,long *ldsize,unsigned short flags)
{
unsigned char *buf;
char *fname;
long fsize;
short fgroup;
fgroup = get_level_fgroup(lvnum);
fname = prepare_file_fmtpath(fgroup,"map%05lu.%s",lvnum,fext);
wait_for_cd_to_be_available();
fsize = LbFileLengthRnc(fname);
if (fsize < *ldsize)
{
if ((flags & LMFF_Optional) == 0)
WARNMSG("Map file \"map%05lu.%s\" doesn't exist or is too small.",lvnum,fext);
else
SYNCMSG("Optional file \"map%05lu.%s\" doesn't exist or is too small.",lvnum,fext);
return NULL;
}
if (fsize > ANY_MAP_FILE_MAX_SIZE)
{
if ((flags & LMFF_Optional) == 0)
WARNMSG("Map file \"map%05lu.%s\" exceeds max size of %d; loading failed.",lvnum,fext,ANY_MAP_FILE_MAX_SIZE);
else
SYNCMSG("Optional file \"map%05lu.%s\" exceeds max size of %d; not loading.",lvnum,fext,ANY_MAP_FILE_MAX_SIZE);
return NULL;
}
buf = LbMemoryAlloc(fsize+16);
if (buf == NULL)
{
if ((flags & LMFF_Optional) == 0)
WARNMSG("Can't allocate %ld bytes to load \"map%05lu.%s\".",fsize,lvnum,fext);
else
SYNCMSG("Can't allocate %ld bytes to load \"map%05lu.%s\".",fsize,lvnum,fext);
return NULL;
}
fsize = LbFileLoadAt(fname,buf);
if (fsize < *ldsize)
{
if ((flags & LMFF_Optional) == 0)
WARNMSG("Reading map file \"map%05lu.%s\" failed.",lvnum,fext);
else
SYNCMSG("Reading optional file \"map%05lu.%s\" failed.",lvnum,fext);
LbMemoryFree(buf);
return NULL;
}
*ldsize = fsize;
SYNCDBG(7,"Map file \"map%05lu.%s\" loaded.",lvnum,fext);
return buf;
}
void frontstory_load(void)
{
wait_for_cd_to_be_available();
frontend_load_data_from_cd();
if (LbDataLoadAll(frontstory_load_files_640))
{
ERRORLOG("Unable to Load FRONT STORY FILES");
} else
{
LbDataLoadSetModifyFilenameFunction(_DK_mdlf_default);
LbSpriteSetupAll(frontstory_setup_sprites);
LbPaletteSet(frontend_palette);
srand(LbTimerClock());
frontstory_text_no = GUIStr_EasterPoems + rand() % 26;
}
}
short load_level_file(LevelNumber lvnum)
{
char *fname;
short fgroup;
short result;
fgroup = get_level_fgroup(lvnum);
fname = prepare_file_fmtpath(fgroup,"map%05lu.slb",(unsigned long)lvnum);
wait_for_cd_to_be_available();
if (LbFileExists(fname))
{
result = true;
load_map_data_file(lvnum);
load_map_flag_file(lvnum);
load_column_file(lvnum);
init_whole_blocks();
load_slab_file();
init_columns();
load_static_light_file(lvnum);
if (!load_map_ownership_file(lvnum))
result = false;
load_map_wibble_file(lvnum);
load_and_setup_map_info(lvnum);
load_texture_map_file(game.texture_id, 2);
load_action_point_file(lvnum);
if (!load_map_slab_file(lvnum))
result = false;
if (!load_thing_file(lvnum))
result = false;
reinitialise_map_rooms();
ceiling_init(0, 1);
} else
{
ERRORLOG("The level \"map%05lu\" doesn't exist; creating empty map.",lvnum);
init_whole_blocks();
load_slab_file();
init_columns();
game.texture_id = 0;
load_texture_map_file(game.texture_id, 2);
init_top_texture_to_cube_table();
result = false;
}
return result;
}
TbBool load_texture_map_file(unsigned long tmapidx, unsigned char n)
{
char *fname;
SYNCDBG(7,"Starting");
#ifdef SPRITE_FORMAT_V2
fname = prepare_file_fmtpath(FGrp_StdData,"tmapa%03d-%d.dat",tmapidx,32);
#else
fname = prepare_file_fmtpath(FGrp_StdData,"tmapa%03d.dat",tmapidx);
#endif
if (!wait_for_cd_to_be_available())
return false;
if (!LbFileExists(fname))
{
WARNMSG("Texture file \"%s\" doesn't exits.",fname);
return false;
}
// The texture file has always over 500kb
if (LbFileLoadAt(fname, block_mem) < 65536)
{
WARNMSG("Texture file \"%s\" can't be loaded or is too small.",fname);
return false;
}
return true;
}
TbBool load_game(long slot_num)
{
TbFileHandle fh;
long file_len;
struct PlayerInfo *player;
struct Dungeon *dungeon;
struct CatalogueEntry *centry;
// unsigned char buf[14];
// char cmpgn_fname[CAMPAIGN_FNAME_LEN];
SYNCDBG(6,"Starting");
reset_eye_lenses();
{
// Use fname only here - it is overwritten by next use of prepare_file_fmtpath()
char *fname;
fname = prepare_file_fmtpath(FGrp_Save,saved_game_filename,slot_num);
if (!wait_for_cd_to_be_available())
return false;
fh = LbFileOpen(fname,Lb_FILE_MODE_READ_ONLY);
if (fh == -1)
{
WARNMSG("Cannot open saved game file \"%s\".",fname);
save_catalogue_slot_disable(slot_num);
return false;
}
}
file_len = LbFileLengthHandle(fh);
if (is_primitive_save_version(file_len))
{
//if (LbFileRead(handle, buf, sizeof(buf)) != sizeof(buf))
{
LbFileClose(fh);
save_catalogue_slot_disable(slot_num);
return false;
}
/*LbFileSeek(fh, (char *)&game.campaign_fname[0] - (char *)&game, Lb_FILE_SEEK_BEGINNING);
LbFileRead(fh, cmpgn_fname, CAMPAIGN_FNAME_LEN);
cmpgn_fname[CAMPAIGN_FNAME_LEN-1] = '\0';
if (!change_campaign(cmpgn_fname))
{
ERRORLOG("Unable to load campaign associated with saved game");
}
LbFileClose(fh);
WARNMSG("Saved game file \"%s\" has incompatible version; restarting level.",fname);
player = get_my_player();
player->field_7 = 0;
my_player_number = default_loc_player;
player = get_my_player();
game.flagfield_14EA4A = 2;
set_flag_byte(&game.system_flags,GSF_NetworkActive,false);
player->field_2C = 1;
set_selected_level_number(((struct Game *)buf)->load_restart_level);
set_continue_level_number(((struct Game *)buf)->continue_level_number);
startup_network_game();
return true;*/
}
centry = &save_game_catalogue[slot_num];
LbFileSeek(fh, 0, Lb_FILE_SEEK_BEGINNING);
// Here is the actual loading
if (load_game_chunks(fh,centry) != GLoad_SavedGame)
{
LbFileClose(fh);
WARNMSG("Couldn't correctly load saved game in slot %d.",(int)slot_num);
init_lookups();
return false;
}
LbFileClose(fh);
LbStringCopy(game.campaign_fname,campaign.fname,sizeof(game.campaign_fname));
reinit_level_after_load();
output_message(SMsg_GameLoaded, 0, true);
pannel_map_update(0, 0, map_subtiles_x+1, map_subtiles_y+1);
calculate_moon_phase(false,false);
update_extra_levels_visibility();
player = get_my_player();
set_flag_byte(&player->field_3,0x08,false);
set_flag_byte(&player->field_3,0x04,false);
player->field_4C1 = 0;
player->field_4C5 = 0;
player->field_7 = 0;
PaletteSetPlayerPalette(player, engine_palette);
reinitialise_eye_lens(game.numfield_1B);
// Update the lights system state
light_import_system_state(&gameadd.lightst);
// Victory state
if (player->victory_state != VicS_Undecided)
{
frontstats_initialise();
dungeon = get_players_dungeon(player);
dungeon->lvstats.player_score = 0;
dungeon->lvstats.allow_save_score = 1;
}
game.loaded_swipe_idx = -1;
return true;
}
void fronttorture_load(void)
{
struct PlayerInfo *player;
char *fname;
unsigned char *ptr;
long i,k;
wait_for_cd_to_be_available();
frontend_load_data_from_cd();
memcpy(frontend_backup_palette, &frontend_palette, PALETTE_SIZE);
// Texture blocks memory isn't used here, so reuse it instead of allocating
ptr = block_mem;
// Load RAW/PAL background
fname = prepare_file_path(FGrp_LoData,"torture.raw");
torture_background = ptr;
i = LbFileLoadAt(fname, ptr);
ptr += i;
fname = prepare_file_path(FGrp_LoData,"torture.pal");
torture_palette = ptr;
i = LbFileLoadAt(fname, ptr);
ptr += i;
// Load DAT/TAB sprites for doors
k = 0;
{
fname = prepare_file_fmtpath(FGrp_LoData,"door%02d.dat",k+1);
i = LbFileLoadAt(fname, ptr);
doors[k].data = ptr;
ptr += i;
doors[k].data_end = ptr;
fname = prepare_file_fmtpath(FGrp_LoData,"door%02d.tab",k+1);
i = LbFileLoadAt(fname, ptr);
doors[k].sprites = (struct TbSprite *)ptr;
ptr += i;
doors[k].sprites_end =(struct TbSprite *) ptr;
}
ptr = &game.land_map_start;
for (k=1; k < 8; k++)
{
fname = prepare_file_fmtpath(FGrp_LoData,"door%02d.dat",k+1);
i = LbFileLoadAt(fname, ptr);
doors[k].data = ptr;
ptr += i;
doors[k].data_end = ptr;
fname = prepare_file_fmtpath(FGrp_LoData,"door%02d.tab",k+1);
i = LbFileLoadAt(fname, ptr);
doors[k].sprites = (struct TbSprite *)ptr;
ptr += i;
doors[k].sprites_end = (struct TbSprite *)ptr;
}
ptr = poly_pool;
k = 8;
{
fname = prepare_file_fmtpath(FGrp_LoData,"door%02d.dat",k+1);
i = LbFileLoadAt(fname, ptr);
doors[k].data = ptr;
ptr += i;
doors[k].data_end = ptr;
fname = prepare_file_fmtpath(FGrp_LoData,"door%02d.tab",k+1);
i = LbFileLoadAt(fname, ptr);
doors[k].sprites = (struct TbSprite *)ptr;
ptr += i;
doors[k].sprites_end = (struct TbSprite *)ptr;
}
if ( LbDataLoadAll(torture_load_files) )
ERRORLOG("Unable to load torture load files");
LbSpriteSetupAll(setup_torture_sprites);
frontend_load_data_reset();
memcpy(&frontend_palette, torture_palette, PALETTE_SIZE);
torture_state.action = 0;
torture_door_selected = -1;
torture_end_sprite = -1;
torture_sprite_direction = 0;
LbMemorySet(door_sound_state, 0, TORTURE_DOORS_COUNT*sizeof(struct DoorSoundState));
player = get_my_player();
if (player->victory_state == VicS_WonLevel)
{
LbMouseChangeSpriteAndHotspot(&fronttor_sprites[1], 0, 0);
} else
{
LbMouseChangeSpriteAndHotspot(0, 0, 0);
}
torture_left_button = 0;
}
