void clear_messages(void)
{
int i;
for (i=0; i < MESSAGE_QUEUE_COUNT; i++)
{
LbMemorySet(&message_queue[i], 0, sizeof(struct MessageQueueEntry));
}
// Set end turn to 0 for all messages
for (i=0; i < sizeof(messages)/sizeof(messages[0]); i++)
{
messages[i].end_time = 0;
}
// Remove when won't be needed anymore
for (i=0; i < sizeof(_DK_messages)/sizeof(_DK_messages[0]); i++)
{
_DK_messages[i].end_time = 0;
}
}
void clear_columns(void)
{
struct Column *colmn;
int i;
for (i=0; i < COLUMNS_COUNT; i++)
{
colmn = &game.columns_data[i];
LbMemorySet(colmn, 0, sizeof(struct Column));
colmn->baseblock = 1;
make_solidmask(colmn);
}
game.field_149E6E = -1;
game.field_149E7C = 24;
game.unrevealed_column_idx = 0;
for (i=0; i < 18; i++)
{
game.field_14A818[i] = 0;
}
}
void init_top_texture_to_cube_table(void)
{
//_DK_init_top_texture_to_cube_table();
LbMemorySet(game.field_14BB65, 0, sizeof(game.field_14BB65));
int n;
for (n=1; n < 592; n++)
{
int i;
for (i=1; i < CUBE_ITEMS_MAX; i++)
{
struct CubeAttribs * cubed;
cubed = &game.cubes_data[i];
if (cubed->texture_id[4] == n) {
game.field_14BB65[n] = i;
break;
}
}
}
}
void delete_thing_structure_f(struct Thing *thing, long a2, const char *func_name)
{
TRACE_THING(thing);
if ((thing->alloc_flags & TAlF_InDungeonList) != 0) {
remove_first_creature(thing);
}
if (!a2)
{
if (thing->light_id != 0) {
light_delete_light(thing->light_id);
thing->light_id = 0;
}
}
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(thing);
if (!creature_control_invalid(cctrl))
{
if ( !a2 )
{
remove_creature_lair(thing);
if (creature_is_group_member(thing)) {
remove_creature_from_group(thing);
}
}
delete_control_structure(cctrl);
}
if (thing->snd_emitter_id != 0) {
S3DDestroySoundEmitterAndSamples(thing->snd_emitter_id);
thing->snd_emitter_id = 0;
}
remove_thing_from_its_class_list(thing);
remove_thing_from_mapwho(thing);
if (thing->index > 0) {
game.free_things_start_index--;
game.free_things[game.free_things_start_index] = thing->index;
} else {
#if (BFDEBUG_LEVEL > 0)
ERRORMSG("%s: Performed deleting of thing with bad index %d!",func_name,(int)thing->index);
#endif
}
LbMemorySet(thing, 0, sizeof(struct Thing));
}
struct CreatureControl *allocate_free_control_structure(void)
{
struct CreatureControl *cctrl;
long i;
for (i=1; i < CREATURES_COUNT; i++)
{
cctrl = game.persons.cctrl_lookup[i];
if (!creature_control_invalid(cctrl))
{
if ((cctrl->flgfield_1 & CCFlg_Exists) == 0)
{
LbMemorySet(cctrl, 0, sizeof(struct CreatureControl));
cctrl->flgfield_1 |= CCFlg_Exists;
cctrl->index = i;
return cctrl;
}
}
}
return NULL;
}
void setup_input_field(struct GuiButton *gbtn, const char * empty_text)
{
char *content;
lbInkey = 0;
LbMemorySet(backup_input_field, 0, INPUT_FIELD_LEN);
content = (char *)gbtn->content;
if (content == NULL)
{
ERRORLOG("Button has invalid content pointer");
return;
}
strncpy(backup_input_field, content, INPUT_FIELD_LEN-1);
backup_input_field[INPUT_FIELD_LEN-1] = '\0';
// Check if the text drawn should be treated as empty; if it is, ignore that string
if ((empty_text != NULL) && (strncmp(empty_text, backup_input_field, INPUT_FIELD_LEN-1) == 0))
{
*content = '\0';
}
input_field_pos = LbLocTextStringLength(content);
}
TbBool update_slabset_column_indices(struct Column *cols, long ccount)
{
struct Column *colmn;
struct Column lcolmn;
struct SlabSet *sset;
long ncol;
long i,k,n;
LbMemorySet(&lcolmn,0,sizeof(struct Column));
for (i=0; i < game.slabset_num; i++)
{
sset = &game.slabset[i];
for (k=0; k < 9; k++)
{
n = sset->col_idx[k];
if (n >= 0)
{
lcolmn.baseblock = n;
ncol = find_column(&lcolmn);
if (ncol == 0)
{
ncol = create_column(&lcolmn);
colmn = get_column(ncol);
colmn->bitfields |= 0x01;
}
} else
{
if (-n < ccount)
ncol = find_column(&cols[-n]);
else
ncol = 0;
if (ncol == 0)
{
ERRORLOG("E14R432Q#222564-3; I should be able to find a column here");
continue;
}
}
sset->col_idx[k] = -ncol;
}
}
return true;
}
short load_continue_game(void)
{
unsigned char buf[14];
unsigned char bonus[20];
char cmpgn_fname[CAMPAIGN_FNAME_LEN];
long lvnum;
long i;
if (!read_continue_game_part(buf,0,14))
{
WARNLOG("Can't read continue game file head");
return false;
}
i = (char *)&game.campaign_fname[0] - (char *)&game;
read_continue_game_part((unsigned char *)cmpgn_fname,i,CAMPAIGN_FNAME_LEN);
cmpgn_fname[CAMPAIGN_FNAME_LEN-1] = '\0';
if (!change_campaign(cmpgn_fname))
{
ERRORLOG("Unable to load campaign");
return false;
}
lvnum = ((struct Game *)buf)->continue_level_number;
if (!is_singleplayer_like_level(lvnum))
{
WARNLOG("Level number in continue file is incorrect");
return false;
}
set_continue_level_number(lvnum);
LbMemorySet(bonus, 0, sizeof(bonus));
i = (char *)&game.intralvl.bonuses_found[0] - (char *)&game;
read_continue_game_part(bonus,i,16);
for (i=0; i < BONUS_LEVEL_STORAGE_COUNT; i++)
game.intralvl.bonuses_found[i] = bonus[i];
LbStringCopy(game.campaign_fname,campaign.fname,sizeof(game.campaign_fname));
update_extra_levels_visibility();
i = (char *)&game.intralvl_transfered_creature - (char *)&game.intralvl.bonuses_found[0];
game.intralvl_transfered_creature.model = bonus[i];
game.intralvl_transfered_creature.explevel = bonus[i+1];
return true;
}
void frontnet_rewite_net_messages(void)
{
struct NetMessage lmsg[NET_MESSAGES_COUNT];
struct NetMessage *nmsg;
long i,k;
k = 0;
i = net_number_of_messages;
for (i=0; i < NET_MESSAGES_COUNT; i++)
LbMemorySet(&lmsg[i], 0, sizeof(struct NetMessage));
for (i=0; i < net_number_of_messages; i++)
{
nmsg = &net_message[i];
if (is_network_player_active(nmsg->plyr_idx))
{
memcpy(&lmsg[k], nmsg, sizeof(struct NetMessage));
k++;
}
}
net_number_of_messages = k;
for (i=0; i < NET_MESSAGES_COUNT; i++)
memcpy(&net_message[i], &lmsg[i], sizeof(struct NetMessage));
}
static void
_backtrace(int depth , LPCONTEXT context)
{
STACKFRAME frame;
char module_name_raw[MAX_PATH];
LbMemorySet(&frame,0,sizeof(frame));
frame.AddrPC.Offset = context->Eip;
frame.AddrPC.Mode = AddrModeFlat;
frame.AddrStack.Offset = context->Esp;
frame.AddrStack.Mode = AddrModeFlat;
frame.AddrFrame.Offset = context->Ebp;
frame.AddrFrame.Mode = AddrModeFlat;
HANDLE process = GetCurrentProcess();
HANDLE thread = GetCurrentThread();
while (StackWalk(IMAGE_FILE_MACHINE_I386, process, thread, &frame,
context, 0, SymFunctionTableAccess, SymGetModuleBase, 0))
{
--depth;
if (depth < 0)
break;
DWORD module_base = SymGetModuleBase(process, frame.AddrPC.Offset);
const char * module_name = "[unknown module]";
if (module_base &&
GetModuleFileNameA((HINSTANCE)module_base, module_name_raw, MAX_PATH))
{
module_name = strrchr(module_name_raw,'\\');
if (module_name != NULL)
module_name++;
else
module_name = module_name_raw;
}
LbJustLog(" in %s at %04x:%08x, base %08x\n", module_name, context->SegCs, frame.AddrPC.Offset, module_base);
}
}
void generate_wibble_table(void)
{
struct WibbleTable *wibl;
struct WibbleTable *qwibl;
unsigned long seed;
int i,n;
// Clear the whole wibble table
for (n=0; n < 4; n++)
{
wibl = &wibble_table[32*n];
for (i=0; i < 32; i++)
{
LbMemorySet(wibl, 0, sizeof(struct WibbleTable));
wibl++;
}
}
seed = 0;
for (i=0; i < 32; i++)
{
wibl = &wibble_table[i+32];
n = (LB_RANDOM(65447,&seed) % 127);
wibl->field_0 = n - 63;
n = (LB_RANDOM(65447,&seed) % 127);
wibl->field_4 = (n - 63) / 3;
n = (LB_RANDOM(65447,&seed) % 127);
wibl->field_8 = n - 63;
qwibl = &wibble_table[i+64];
n = (LB_RANDOM(65447,&seed) % 2047);
wibl->field_C = n - 1023;
n = (LB_RANDOM(65447,&seed) % 127);
qwibl->field_0 = n - 63;
n = (LB_RANDOM(65447,&seed) % 127);
qwibl->field_8 = n - 63;
}
}
void generate_wibble_table(void)
{
struct WibbleTable *wibl;
struct WibbleTable *qwibl;
unsigned short seed;
int i,n;
// Clear the whole wibble table
for (n=0; n < 4; n++)
{
wibl = &wibble_table[32*n];
for (i=0; i < 32; i++)
{
LbMemorySet(wibl, 0, sizeof(struct WibbleTable));
wibl++;
}
}
// Set wibble values using special random algorithm
seed = 0;
for (i=0; i < 32; i++)
{
wibl = &wibble_table[i+32];
n = wibble_random(65447,&seed);
wibl->field_0 = (n % 127) - 63;
n = wibble_random(65447,&seed);
wibl->field_4 = ((n % 127) - 63) / 3;
n = wibble_random(65447,&seed);
wibl->field_8 = (n % 127) - 63;
qwibl = &wibble_table[i+64];
n = wibble_random(65447,&seed);
wibl->field_C = (n % 2047) - 1023;
n = wibble_random(65447,&seed);
qwibl->field_0 = (n % 127) - 63;
n = wibble_random(65447,&seed);
qwibl->field_8 = (n % 127) - 63;
}
}
void update_explored_flags_for_power_sight(struct PlayerInfo *player)
{
struct Dungeon *dungeon;
struct Thing *thing;
SYNCDBG(9,"Starting");
dungeon = get_players_dungeon(player);
LbMemorySet(backup_explored, 0, sizeof(backup_explored));
if (dungeon->sight_casted_thing_idx == 0) {
return;
}
thing = thing_get(dungeon->sight_casted_thing_idx);
if (!thing_is_object(thing)) {
ERRORLOG("Sight thing index %d invalid", (int)dungeon->sight_casted_thing_idx);
turn_off_power_sight_of_evil(player->id_number);
dungeon->sight_casted_thing_idx = 0;
return;
}
TRACE_THING(thing);
// Fill the backup_explored array
store_backup_explored_flags_for_power_sight(player, &thing->mappos);
update_vertical_explored_flags_for_power_sight(player, &thing->mappos);
update_horizonal_explored_flags_for_power_sight(player, &thing->mappos);
}
void redraw_isometric_view(void)
{
struct PlayerInfo *player;
struct Dungeon *dungeon;
TbGraphicsWindow ewnd;
struct Coord3d pos;
SYNCDBG(6,"Starting");
player = get_my_player();
if (player->acamera == NULL)
return;
memcpy(&pos,&player->acamera->mappos,sizeof(struct Coord3d));
LbMemorySet(&ewnd, 0, sizeof(TbGraphicsWindow));
if (player->field_45F != 1)
player->field_45F = 1;
dungeon = get_players_num_dungeon(my_player_number);
// Camera position modifications
make_camera_deviations(player,dungeon);
update_explored_flags_for_power_sight(player);
if ((game.flags_font & FFlg_unk08) != 0)
{
store_engine_window(&ewnd,1);
setup_engine_window(ewnd.x, ewnd.y, ewnd.width >> 1, ewnd.height >> 1);
}
struct Thing *create_trap(struct Coord3d *pos, ThingModel trpkind, PlayerNumber plyr_idx)
{
SYNCDBG(7,"Starting");
struct TrapStats *trapstat;
trapstat = &trap_stats[trpkind];
if (!i_can_allocate_free_thing_structure(FTAF_FreeEffectIfNoSlots)) {
ERRORDBG(3,"Cannot create trap %s for player %d. There are too many things allocated.",trap_code_name(trpkind),(int)plyr_idx);
erstat_inc(ESE_NoFreeThings);
return INVALID_THING;
}
struct InitLight ilght;
LbMemorySet(&ilght, 0, sizeof(struct InitLight));
struct Thing *thing;
thing = allocate_free_thing_structure(FTAF_FreeEffectIfNoSlots);
if (thing->index == 0) {
ERRORDBG(3,"Should be able to allocate trap %s for player %d, but failed.",trap_code_name(trpkind),(int)plyr_idx);
erstat_inc(ESE_NoFreeThings);
return INVALID_THING;
}
thing->class_id = TCls_Trap;
thing->model = trpkind;
thing->mappos.x.val = pos->x.val;
thing->mappos.y.val = pos->y.val;
thing->mappos.z.val = pos->z.val;
thing->next_on_mapblk = 0;
thing->parent_idx = thing->index;
thing->owner = plyr_idx;
char start_frame;
if (trapstat->field_13) {
start_frame = -1;
} else {
start_frame = 0;
}
set_thing_draw(thing, trapstat->field_4, trapstat->field_D, trapstat->field_8, trapstat->field_C, start_frame, 2);
if (trapstat->field_11) {
thing->field_4F |= 0x02;
} else {
thing->field_4F &= ~0x02;
}
if (trapstat->field_C) {
thing->field_4F |= 0x40;
} else {
thing->field_4F &= ~0x40;
}
thing->clipbox_size_xy = trapstat->size_xy;
thing->clipbox_size_yz = trapstat->field_16;
thing->solid_size_xy = trapstat->size_xy;
thing->field_5C = trapstat->field_16;
thing->creation_turn = game.play_gameturn;
thing->health = trapstat->field_0;
thing->field_4F &= ~0x10;
thing->field_4F |= 0x20;
thing->byte_13 = 0;
thing->long_14 = game.play_gameturn;
if (trapstat->field_1C != 0)
{
ilght.mappos.x.val = thing->mappos.x.val;
ilght.mappos.y.val = thing->mappos.y.val;
ilght.mappos.z.val = thing->mappos.z.val;
ilght.field_0 = trapstat->field_1C;
ilght.field_2 = trapstat->field_1E;
ilght.is_dynamic = 1;
ilght.field_3 = trapstat->field_1F;
thing->light_id = light_create_light(&ilght);
if (thing->light_id <= 0) {
SYNCDBG(8,"Cannot allocate dynamic light to %s.",thing_model_name(thing));
}
}
add_thing_to_its_class_list(thing);
place_thing_in_mapwho(thing);
return thing;
}
void light_free_light(struct Light *lgt)
{
LbMemorySet(lgt, 0, sizeof(struct Light));
}
void gui_delete_box(struct GuiBox *gbox)
{
gui_remove_box_from_list(gbox);
LbMemorySet(gbox, 0, sizeof(struct GuiBox));
}
void delete_control_structure(struct CreatureControl *cctrl)
{
LbMemorySet(cctrl, 0, sizeof(struct CreatureControl));
}
void light_shadow_cache_free(struct ShadowCache *shdc)
{
LbMemorySet(shdc, 0, sizeof(struct ShadowCache));
}
TbBool parse_objects_object_blocks(char *buf, long len, const char *config_textname, unsigned short flags)
{
struct ObjectConfigStats *objst;
struct Objects *objdat;
long pos;
int i,k,n;
int cmd_num;
// Block name and parameter word store variables
char block_buf[COMMAND_WORD_LEN];
char word_buf[COMMAND_WORD_LEN];
// Initialize the objects array
int arr_size;
if ((flags & CnfLd_AcceptPartial) == 0)
{
arr_size = sizeof(object_conf.object_cfgstats)/sizeof(object_conf.object_cfgstats[0]);
for (i=0; i < arr_size; i++)
{
objst = &object_conf.object_cfgstats[i];
LbMemorySet(objst->code_name, 0, COMMAND_WORD_LEN);
objst->name_stridx = 201;
objst->genre = 0;
if (i < object_conf.object_types_count)
{
object_desc[i].name = objst->code_name;
object_desc[i].num = i;
} else
{
object_desc[i].name = NULL;
object_desc[i].num = 0;
}
}
}
// Load the file
arr_size = object_conf.object_types_count;
for (i=0; i < arr_size; i++)
{
sprintf(block_buf,"object%d",i);
pos = 0;
k = find_conf_block(buf,&pos,len,block_buf);
if (k < 0)
{
if ((flags & CnfLd_AcceptPartial) == 0) {
WARNMSG("Block [%s] not found in %s file.",block_buf,config_textname);
return false;
}
continue;
}
objst = &object_conf.object_cfgstats[i];
objdat = get_objects_data(i);
#define COMMAND_TEXT(cmd_num) get_conf_parameter_text(objects_object_commands,cmd_num)
while (pos<len)
{
// Finding command number in this line
cmd_num = recognize_conf_command(buf,&pos,len,objects_object_commands);
// Now store the config item in correct place
if (cmd_num == -3) break; // if next block starts
if ((flags & CnfLd_ListOnly) != 0) {
// In "List only" mode, accept only name command
if (cmd_num > 1) {
cmd_num = 0;
}
}
n = 0;
switch (cmd_num)
{
case 1: // NAME
if (get_conf_parameter_single(buf,&pos,len,objst->code_name,COMMAND_WORD_LEN) <= 0)
{
CONFWRNLOG("Couldn't read \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
break;
}
break;
case 2: // GENRE
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
n = get_id(objects_genres_desc, word_buf);
}
if (n <= 0)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
break;
}
objst->genre = n;
break;
case 3: // RELATEDCREATURE
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
n = get_id(creature_desc, word_buf);
}
if (n < 0)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
break;
}
objdat->related_creatr_model = n;
break;
case 4: // PROPERTIES
while (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = get_id(objects_properties_commands, word_buf);
switch (k)
{
case 1: // EXISTS_ONLY_IN_ROOM
objst->model_flags |= OMF_ExistsOnlyInRoom;
n++;
break;
case 2: // DESTROYED_ON_ROOM_CLAIM
objst->model_flags |= OMF_DestroyedOnRoomClaim;
n++;
break;
case 3: // CHOWNED_ON_ROOM_CLAIM
objst->model_flags |= OMF_ChOwnedOnRoomClaim;
n++;
break;
case 4: // DESTROYED_ON_ROOM_PLACE
objst->model_flags |= OMF_DestroyedOnRoomPlace;
n++;
break;
default:
CONFWRNLOG("Incorrect value of \"%s\" parameter \"%s\" in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),word_buf,block_buf,config_textname);
break;
}
}
break;
case 0: // comment
break;
case -1: // end of buffer
break;
default:
CONFWRNLOG("Unrecognized command (%d) in [%s] block of %s file.",
cmd_num,block_buf,config_textname);
break;
}
skip_conf_to_next_line(buf,&pos,len);
}
#undef COMMAND_TEXT
}
return true;
}
void frontnet_session_update(void)
{
static long last_enum_players = 0;
static long last_enum_sessions = 0;
long i;
if (LbTimerClock() >= last_enum_sessions)
{
net_number_of_sessions = 0;
LbMemorySet(net_session, 0, sizeof(net_session));
if ( LbNetwork_EnumerateSessions(enum_sessions_callback, 0) )
ERRORLOG("LbNetwork_EnumerateSessions() failed");
last_enum_sessions = LbTimerClock();
if (net_number_of_sessions == 0)
{
net_session_index_active = -1;
net_session_index_active_id = -1;
} else
if (net_session_index_active != -1)
{
if ((net_session_index_active >= net_number_of_sessions)
|| (!net_session[net_session_index_active]->joinable))
{
net_session_index_active = -1;
for (i=0; i < net_number_of_sessions; i++)
{
if (net_session[i]->joinable)
{
net_session_index_active = i;
break;
}
}
}
if (net_session_index_active == -1)
net_session_index_active_id = -1;
}
}
if ((net_number_of_sessions == 0) || (net_session_scroll_offset < 0))
{
net_session_scroll_offset = 0;
} else
if (net_session_scroll_offset > net_number_of_sessions-1)
{
net_session_scroll_offset = net_number_of_sessions-1;
}
if (net_session_index_active == -1)
{
net_number_of_enum_players = 0;
} else
if (LbTimerClock() >= last_enum_players)
{
net_number_of_enum_players = 0;
LbMemorySet(net_player, 0, sizeof(net_player));
if ( LbNetwork_EnumeratePlayers(net_session[net_session_index_active], enum_players_callback, 0) )
{
net_session_index_active = -1;
net_session_index_active_id = -1;
return;
}
last_enum_players = LbTimerClock();
}
if (net_number_of_enum_players == 0)
{
net_player_scroll_offset = 0;
} else
if (net_player_scroll_offset < 0)
{
net_player_scroll_offset = 0;
} else
if (net_player_scroll_offset > net_number_of_enum_players-1)
{
net_player_scroll_offset = net_number_of_enum_players-1;
}
}
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;
}
TbBool parse_cubes_cube_blocks(char *buf, long len, const char *config_textname, unsigned short flags)
{
struct CubeConfigStats *objst;
struct CubeAttribs * cubed;
long pos;
int i,k,n;
int cmd_num;
// Block name and parameter word store variables
char block_buf[COMMAND_WORD_LEN];
char word_buf[COMMAND_WORD_LEN];
// Initialize the cubes array
int arr_size;
if ((flags & CnfLd_AcceptPartial) == 0)
{
arr_size = sizeof(cube_conf.cube_cfgstats)/sizeof(cube_conf.cube_cfgstats[0]);
for (i=0; i < arr_size; i++)
{
objst = &cube_conf.cube_cfgstats[i];
LbMemorySet(objst->code_name, 0, COMMAND_WORD_LEN);
if (i < cube_conf.cube_types_count)
{
cube_desc[i].name = objst->code_name;
cube_desc[i].num = i;
} else
{
cube_desc[i].name = NULL;
cube_desc[i].num = 0;
}
}
}
// Load the file
arr_size = cube_conf.cube_types_count;
for (i=0; i < arr_size; i++)
{
sprintf(block_buf,"cube%d",i);
pos = 0;
k = find_conf_block(buf,&pos,len,block_buf);
if (k < 0)
{
if ((flags & CnfLd_AcceptPartial) == 0) {
WARNMSG("Block [%s] not found in %s file.",block_buf,config_textname);
return false;
}
continue;
}
objst = &cube_conf.cube_cfgstats[i];
cubed = &game.cubes_data[i];
#define COMMAND_TEXT(cmd_num) get_conf_parameter_text(cubes_cube_commands,cmd_num)
while (pos<len)
{
// Finding command number in this line
cmd_num = recognize_conf_command(buf,&pos,len,cubes_cube_commands);
// Now store the config item in correct place
if (cmd_num == -3) break; // if next block starts
if ((flags & CnfLd_ListOnly) != 0) {
// In "List only" mode, accept only name command
if (cmd_num > 1) {
cmd_num = 0;
}
}
n = 0;
switch (cmd_num)
{
case 1: // NAME
if (get_conf_parameter_single(buf,&pos,len,objst->code_name,COMMAND_WORD_LEN) <= 0)
{
CONFWRNLOG("Couldn't read \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
break;
}
break;
case 2: // TEXTURES
while (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if (n >= CUBE_TEXTURES)
{
CONFWRNLOG("Too many \"%s\" parameters in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
break;
}
cubed->texture_id[n] = k;
n++;
}
if (n < CUBE_TEXTURES)
{
CONFWRNLOG("Couldn't read all \"%s\" parameters in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 3: // FLAGS
while (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if (n >= CUBE_TEXTURES)
{
CONFWRNLOG("Too many \"%s\" parameters in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
break;
}
cubed->field_C[n] = k;
n++;
}
if (n < CUBE_TEXTURES)
{
CONFWRNLOG("Couldn't read all \"%s\" parameters in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 0: // comment
break;
case -1: // end of buffer
break;
default:
CONFWRNLOG("Unrecognized command (%d) in [%s] block of %s file.",
cmd_num,block_buf,config_textname);
break;
}
skip_conf_to_next_line(buf,&pos,len);
}
#undef COMMAND_TEXT
}
return true;
}
TbBool parse_lenses_data_blocks(char *buf, long len, const char *config_textname, unsigned short flags)
{
long pos;
int i,k,n;
int cmd_num;
char *fname;
struct LensConfig *lenscfg;
// Block name and parameter word store variables
char block_buf[COMMAND_WORD_LEN];
char word_buf[COMMAND_WORD_LEN];
// Initialize the array
int arr_size;
if ((flags & CnfLd_AcceptPartial) == 0)
{
arr_size = sizeof(lenses_conf.lenses)/sizeof(lenses_conf.lenses[0]);
for (i=0; i < arr_size; i++)
{
lenscfg = &lenses_conf.lenses[i];
LbMemorySet(lenscfg->code_name, 0, COMMAND_WORD_LEN);
LbMemorySet(lenscfg->mist_file, 0, DISKPATH_SIZE);
lenscfg->mist_lightness = 0;
lenscfg->mist_ghost = 0;
lenscfg->displace_kind = 0;
lenscfg->displace_magnitude = 0;
lenscfg->displace_period = 1;
LbMemorySet(lenscfg->palette, 0, PALETTE_SIZE*sizeof(TbPixel));
lenscfg->flags = 0;
if (i < lenses_conf.lenses_count)
{
lenses_desc[i].name = lenscfg->code_name;
lenses_desc[i].num = i;
} else
{
lenses_desc[i].name = NULL;
lenses_desc[i].num = 0;
}
}
}
// Load the file
arr_size = lenses_conf.lenses_count;
for (i=0; i < arr_size; i++)
{
sprintf(block_buf,"lens%d",i);
pos = 0;
k = find_conf_block(buf,&pos,len,block_buf);
if (k < 0)
{
if ((flags & CnfLd_AcceptPartial) == 0) {
WARNMSG("Block [%s] not found in %s file.",block_buf,config_textname);
return false;
}
continue;
}
lenscfg = &lenses_conf.lenses[i];
#define COMMAND_TEXT(cmd_num) get_conf_parameter_text(lenses_data_commands,cmd_num)
while (pos<len)
{
// Finding command number in this line
cmd_num = recognize_conf_command(buf,&pos,len,lenses_data_commands);
// Now store the config item in correct place
if (cmd_num == -3) break; // if next block starts
if ((flags & CnfLd_ListOnly) != 0) {
// In "List only" mode, accept only name command
if (cmd_num > 1) {
cmd_num = 0;
}
}
n = 0;
switch (cmd_num)
{
case 1: // NAME
if (get_conf_parameter_single(buf,&pos,len,lenscfg->code_name,COMMAND_WORD_LEN) <= 0)
{
CONFWRNLOG("Couldn't read \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
break;
}
n++;
break;
case 2: // MIST
if (get_conf_parameter_single(buf,&pos,len,lenscfg->mist_file,DISKPATH_SIZE) > 0)
{
n++;
}
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if ((k >= 0) && (k < 64))
{
lenscfg->mist_lightness = k;
n++;
}
}
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if ((k >= 0) && (k < 256))
{
lenscfg->mist_ghost = k;
n++;
}
}
if (n < 3)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
} else
{
lenscfg->flags |= LCF_HasMist;
}
break;
case 3: // DISPLACEMENT
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if ((k > 0) && (k < 256))
{
lenscfg->displace_kind = k;
n++;
}
}
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if ((k >= 0) && (k < 512))
{
lenscfg->displace_magnitude = k;
n++;
}
}
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if ((k > 0) && (k < 512))
{
lenscfg->displace_period = k;
n++;
}
}
if (n < 3)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
} else
{
lenscfg->flags |= LCF_HasDisplace;
}
break;
case 4: // PALETTE
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
fname = prepare_file_path(FGrp_StdData,word_buf);
if ( LbFileLoadAt(fname, lenscfg->palette) == PALETTE_SIZE)
{
n++;
}
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
} else
{
lenscfg->flags |= LCF_HasPalette;
}
break;
case 0: // comment
break;
case -1: // end of buffer
break;
default:
CONFWRNLOG("Unrecognized command (%d) in [%s] block of %s file.",
cmd_num,block_buf,config_textname);
break;
}
skip_conf_to_next_line(buf,&pos,len);
}
#undef COMMAND_TEXT
}
return true;
}
TbBool parse_trapdoor_door_blocks(char *buf, long len, const char *config_textname, unsigned short flags)
{
struct ManfctrConfig *mconf;
struct DoorConfigStats *doorst;
long pos;
int i,k,n;
int cmd_num;
// Block name and parameter word store variables
char block_buf[COMMAND_WORD_LEN];
char word_buf[COMMAND_WORD_LEN];
SYNCDBG(19,"Starting");
// Initialize the doors array
int arr_size;
if ((flags & CnfLd_AcceptPartial) == 0)
{
arr_size = sizeof(trapdoor_conf.door_cfgstats)/sizeof(trapdoor_conf.door_cfgstats[0]);
for (i=0; i < arr_size; i++)
{
doorst = &trapdoor_conf.door_cfgstats[i];
LbMemorySet(doorst->code_name, 0, COMMAND_WORD_LEN);
doorst->name_stridx = GUIStr_Empty;
doorst->tooltip_stridx = GUIStr_Empty;
doorst->bigsym_sprite_idx = 0;
doorst->medsym_sprite_idx = 0;
doorst->pointer_sprite_idx = 0;
doorst->panel_tab_idx = 0;
if (i < trapdoor_conf.door_types_count)
{
door_desc[i].name = doorst->code_name;
door_desc[i].num = i;
} else
{
door_desc[i].name = NULL;
door_desc[i].num = 0;
}
}
}
// Parse every numbered block within range
arr_size = trapdoor_conf.door_types_count;
for (i=0; i < arr_size; i++)
{
sprintf(block_buf,"door%d",i);
pos = 0;
k = find_conf_block(buf,&pos,len,block_buf);
if (k < 0)
{
if ((flags & CnfLd_AcceptPartial) == 0) {
WARNMSG("Block [%s] not found in %s file.",block_buf,config_textname);
return false;
}
continue;
}
mconf = &game.doors_config[i];
doorst = &trapdoor_conf.door_cfgstats[i];
#define COMMAND_TEXT(cmd_num) get_conf_parameter_text(trapdoor_door_commands,cmd_num)
while (pos<len)
{
// Finding command number in this line
cmd_num = recognize_conf_command(buf,&pos,len,trapdoor_door_commands);
// Now store the config item in correct place
if (cmd_num == -3) break; // if next block starts
if ((flags & CnfLd_ListOnly) != 0) {
// In "List only" mode, accept only name command
if (cmd_num > 1) {
cmd_num = 0;
}
}
n = 0;
switch (cmd_num)
{
case 1: // NAME
if (get_conf_parameter_single(buf,&pos,len,doorst->code_name,COMMAND_WORD_LEN) <= 0)
{
CONFWRNLOG("Couldn't read \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
break;
}
break;
case 2: // MANUFACTURELEVEL
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
mconf->manufct_level = k;
n++;
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 3: // MANUFACTUREREQUIRED
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
mconf->manufct_required = k;
n++;
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 5: // HEALTH
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
door_stats[i][0].health = k;
door_stats[i][1].health = k;
n++;
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 6: // SELLINGVALUE
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
mconf->selling_value = k;
n++;
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 7: // NAMETEXTID
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if (k > 0)
{
doorst->name_stridx = k;
n++;
}
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 8: // TOOLTIPTEXTID
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if (k > 0)
{
doorst->tooltip_stridx = k;
n++;
}
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 9: // CRATE
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
n = get_id(object_desc, word_buf);
}
if (n < 0)
{
CONFWRNLOG("Incorrect crate object \"%s\" in [%s] block of %s file.",
word_buf,block_buf,config_textname);
break;
}
object_conf.object_to_door_or_trap[n] = i;
object_conf.workshop_object_class[n] = TCls_Door;
trapdoor_conf.door_to_object[i] = n;
break;
case 10: // SYMBOLSPRITES
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if (k >= 0)
{
doorst->bigsym_sprite_idx = k;
n++;
}
}
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if (k >= 0)
{
doorst->medsym_sprite_idx = k;
n++;
}
}
if (n < 2)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 11: // POINTERSPRITES
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if (k >= 0)
{
doorst->pointer_sprite_idx = k;
n++;
}
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 12: // PANELTABINDEX
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
if (k >= 0)
{
doorst->panel_tab_idx = k;
n++;
}
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 0: // comment
break;
case -1: // end of buffer
break;
default:
CONFWRNLOG("Unrecognized command (%d) in [%s] block of %s file.",
cmd_num,block_buf,config_textname);
break;
}
skip_conf_to_next_line(buf,&pos,len);
}
#undef COMMAND_TEXT
}
return true;
}
TbBool parse_effects_effect_blocks(char *buf, long len, const char *config_textname, unsigned short flags)
{
struct EffectConfigStats *effcst;
long pos;
int i,k,n;
int cmd_num;
// Block name and parameter word store variables
char block_buf[COMMAND_WORD_LEN];
char word_buf[COMMAND_WORD_LEN];
SYNCDBG(19,"Starting");
// Initialize the effects array
int arr_size;
if ((flags & CnfLd_AcceptPartial) == 0)
{
arr_size = sizeof(effects_conf.effect_cfgstats)/sizeof(effects_conf.effect_cfgstats[0]);
for (i=0; i < arr_size; i++)
{
effcst = &effects_conf.effect_cfgstats[i];
LbMemorySet(effcst->code_name, 0, COMMAND_WORD_LEN);
if (i < 69)
effcst->old = &effect_info[i];
else
effcst->old = &effect_info[0];
if (i < effects_conf.effect_types_count)
{
effect_desc[i].name = effcst->code_name;
effect_desc[i].num = i;
} else
{
effect_desc[i].name = NULL;
effect_desc[i].num = 0;
}
}
}
// Parse every numbered block within range
arr_size = effects_conf.effect_types_count;
for (i=0; i < arr_size; i++)
{
sprintf(block_buf,"effect%d",i);
SYNCDBG(19,"Block [%s]",block_buf);
pos = 0;
k = find_conf_block(buf,&pos,len,block_buf);
if (k < 0)
{
if ((flags & CnfLd_AcceptPartial) == 0) {
WARNMSG("Block [%s] not found in %s file.",block_buf,config_textname);
return false;
}
continue;
}
effcst = &effects_conf.effect_cfgstats[i];
#define COMMAND_TEXT(cmd_num) get_conf_parameter_text(effects_effect_commands,cmd_num)
while (pos<len)
{
// Finding command number in this line
cmd_num = recognize_conf_command(buf,&pos,len,effects_effect_commands);
SYNCDBG(19,"Command %s",COMMAND_TEXT(cmd_num));
// Now store the config item in correct place
if (cmd_num == -3) break; // if next block starts
if ((flags & CnfLd_ListOnly) != 0) {
// In "List only" mode, accept only name command
if (cmd_num > 1) {
cmd_num = 0;
}
}
n = 0;
switch (cmd_num)
{
case 1: // NAME
if (get_conf_parameter_single(buf,&pos,len,effcst->code_name,COMMAND_WORD_LEN) <= 0)
{
CONFWRNLOG("Couldn't read \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
break;
}
break;
case 2: // HEALTH
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
effcst->old->start_health = k;
n++;
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 3: // GENERATIONTYPE
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
effcst->old->generation_type = k;
n++;
}
if (n < 1)
{
CONFWRNLOG("Incorrect value of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 4: // GENERATIONACCELXYRANGE
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
effcst->old->accel_xy_min = k;
n++;
}
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
effcst->old->accel_xy_max = k;
n++;
}
if (n < 2)
{
CONFWRNLOG("Couldn't read all values of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 5: // GENERATIONACCELZRANGE
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
effcst->old->accel_z_min = k;
n++;
}
if (get_conf_parameter_single(buf,&pos,len,word_buf,sizeof(word_buf)) > 0)
{
k = atoi(word_buf);
effcst->old->accel_z_max = k;
n++;
}
if (n < 2)
{
CONFWRNLOG("Couldn't read all values of \"%s\" parameter in [%s] block of %s file.",
COMMAND_TEXT(cmd_num),block_buf,config_textname);
}
break;
case 6: // GENERATIONKINDRANGE
//TODO CONFIG Add effect parameter reading
break;
case 7: // AREAAFFECTTYPE
//TODO CONFIG Add effect parameter reading
break;
case 0: // comment
break;
case -1: // end of buffer
break;
default:
CONFWRNLOG("Unrecognized command (%d) in [%s] block of %s file.",
cmd_num,block_buf,config_textname);
break;
}
skip_conf_to_next_line(buf,&pos,len);
//write_effects_effect_to_log(effcst, i);
}
#undef COMMAND_TEXT
}
return true;
}
TbBool init_sound_heap_two_banks(unsigned char *heap_mem, long heap_size, char *snd_fname, char *spc_fname, long a5)
{
long i;
long buf_len;
unsigned char *buf;
SYNCDBG(8,"Starting");
LbMemorySet(heap_mem, 0, heap_size);
using_two_banks = 0;
// Open first sound bank and prepare sample table
if (sound_file != -1)
close_sound_bank(0);
samples_in_bank = 0;
sound_file = _DK_LbFileOpen(snd_fname,Lb_FILE_MODE_READ_ONLY);
if (sound_file == -1)
{
ERRORLOG("Couldn't open primary sound bank file \"%s\"",snd_fname);
return false;
}
buf = heap_mem;
buf_len = heap_size;
i = parse_sound_file(sound_file, buf, &samples_in_bank, buf_len, a5);
if (i == 0)
{
ERRORLOG("Couldn't parse sound bank file \"%s\"",snd_fname);
close_sound_heap();
return false;
}
sample_table = (struct SampleTable *)buf;
buf_len -= i;
buf += i;
if (buf_len <= 0)
{
ERRORLOG("Sound bank buffer too short");
close_sound_heap();
return false;
}
// Open second sound bank and prepare sample table
if (sound_file2 != -1)
close_sound_bank(1);
samples_in_bank2 = 0;
sound_file2 = _DK_LbFileOpen(spc_fname,Lb_FILE_MODE_READ_ONLY);
if (sound_file2 == -1)
{
ERRORLOG("Couldn't open secondary sound bank file \"%s\"",spc_fname);
return false;
}
i = parse_sound_file(sound_file2, buf, &samples_in_bank2, buf_len, a5);
if (i == 0)
{
ERRORLOG("Couldn't parse sound bank file \"%s\"",spc_fname);
close_sound_heap();
return false;
}
sample_table2 = (struct SampleTable *)buf;
buf_len -= i;
buf += i;
if (buf_len <= 0)
{
ERRORLOG("Sound bank buffer too short");
close_sound_heap();
return false;
}
SYNCLOG("Got sound buffer of %ld bytes, samples in banks: %d,%d",buf_len,(int)samples_in_bank,(int)samples_in_bank2);
sndheap = heapmgr_init(buf, buf_len, samples_in_bank2 + samples_in_bank);
if (sndheap == NULL)
{
ERRORLOG("Sound heap manager init error");
close_sound_heap();
return false;
}
using_two_banks = 1;
return true;
}
void check_treasure_map(unsigned char *treasure_map, unsigned short *vein_list, long *gold_next_idx, MapSlabCoord veinslb_x, MapSlabCoord veinslb_y)
{
struct GoldLookup *gldlook;
struct SlabMap *slb;
SlabCodedCoords slb_num,slb_around;
MapSlabCoord slb_x,slb_y;
long gold_slabs,gem_slabs;
long vein_total,vein_idx;
long gld_v1,gld_v2,gld_v3;
long gold_idx;
// First, find a vein
vein_total = 0;
slb_x = veinslb_x;
slb_y = veinslb_y;
gld_v1 = 0;
gld_v2 = 0;
gld_v3 = 0;
gem_slabs = 0;
gold_slabs = 0;
slb_num = get_slab_number(slb_x, slb_y);
treasure_map[slb_num] |= 0x02;
for (vein_idx=0; vein_idx <= vein_total; vein_idx++)
{
gld_v1 += slb_x;
gld_v2 += slb_y;
gld_v3++;
slb_around = get_slab_number(slb_x, slb_y);
slb = get_slabmap_direct(slb_around);
if (slb->kind == SlbT_GEMS)
{
gem_slabs++;
} else
{
gold_slabs++;
slb_around = get_slab_number(slb_x-1, slb_y);
if ((treasure_map[slb_around] & 0x03) == 0)
{
treasure_map[slb_around] |= 0x02;
vein_list[vein_total] = slb_around;
vein_total++;
}
slb_around = get_slab_number(slb_x+1, slb_y);
if ((treasure_map[slb_around] & 0x03) == 0)
{
treasure_map[slb_around] |= 0x02;
vein_list[vein_total] = slb_around;
vein_total++;
}
slb_around = get_slab_number(slb_x, slb_y-1);
if ((treasure_map[slb_around] & 0x03) == 0)
{
treasure_map[slb_around] |= 0x02;
vein_list[vein_total] = slb_around;
vein_total++;
}
slb_around = get_slab_number(slb_x, slb_y+1);
if ((treasure_map[slb_around] & 0x03) == 0)
{
treasure_map[slb_around] |= 0x02;
vein_list[vein_total] = slb_around;
vein_total++;
}
}
// Move to next slab in list
slb_x = slb_num_decode_x(vein_list[vein_idx]);
slb_y = slb_num_decode_y(vein_list[vein_idx]);
}
// Now get a GoldLookup struct to put the vein into
if (*gold_next_idx < GOLD_LOOKUP_COUNT)
{
gold_idx = *gold_next_idx;
(*gold_next_idx)++;
} else
{
gold_idx = smaller_gold_vein_lookup_idx(gold_slabs, gem_slabs);
}
// Write the vein to GoldLookup item
if (gold_idx != -1)
{
gldlook = get_gold_lookup(gold_idx);
LbMemorySet(gldlook, 0, sizeof(struct GoldLookup));
gldlook->flags |= 0x01;
gldlook->x_stl_num = slab_subtile_center(gld_v1 / gld_v3);
gldlook->y_stl_num = slab_subtile_center(gld_v2 / gld_v3);
gldlook->field_A = gold_slabs;
gldlook->field_C = 0;
gldlook->num_gold_slabs = gold_slabs;
gldlook->num_gem_slabs = gem_slabs;
SYNCDBG(8,"Added vein %d at (%d,%d)",(int)gold_idx,(int)gldlook->x_stl_num,(int)gldlook->y_stl_num);
}
}
