void increase_level(struct PlayerInfo *player)
{
struct Dungeon *dungeon;
struct CreatureControl *cctrl;
struct Thing *thing;
unsigned long k;
int i;
dungeon = get_dungeon(player->id_number);
// Increase level of normal creatures
k = 0;
i = dungeon->creatr_list_start;
while (i != 0)
{
thing = thing_get(i);
cctrl = creature_control_get_from_thing(thing);
if (thing_is_invalid(thing) || creature_control_invalid(cctrl))
{
ERRORLOG("Jump to invalid creature detected");
break;
}
i = cctrl->players_next_creature_idx;
// Thing list loop body
creature_increase_level(thing);
// Thing list loop body ends
k++;
if (k > CREATURES_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping creatures list");
erstat_inc(ESE_InfChainTngPerOwner);
break;
}
}
// Increase level of special workers
k = 0;
i = dungeon->digger_list_start;
while (i != 0)
{
thing = thing_get(i);
cctrl = creature_control_get_from_thing(thing);
if (thing_is_invalid(thing) || creature_control_invalid(cctrl))
{
ERRORLOG("Jump to invalid creature detected");
break;
}
i = cctrl->players_next_creature_idx;
// Thing list loop body
creature_increase_level(thing);
// Thing list loop body ends
k++;
if (k > CREATURES_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping creatures list");
erstat_inc(ESE_InfChainTngPerOwner);
break;
}
}
}
struct Thing *allocate_free_thing_structure_f(unsigned char allocflags, const char *func_name)
{
struct Thing *thing;
long i;
// Get a thing from "free things list"
i = game.free_things_start_index;
// If there is no free thing, try to free an effect
if (i >= THINGS_COUNT-1)
{
if ((allocflags & FTAF_FreeEffectIfNoSlots) != 0)
{
thing = thing_get(game.thing_lists[TngList_EffectElems].index);
if (!thing_is_invalid(thing))
{
delete_thing_structure(thing, 0);
} else
{
#if (BFDEBUG_LEVEL > 0)
ERRORMSG("%s: Cannot free up effect element to allocate new thing!",func_name);
#endif
}
}
i = game.free_things_start_index;
}
// Now, if there is still no free thing (we couldn't free any)
if (i >= THINGS_COUNT-1)
{
#if (BFDEBUG_LEVEL > 0)
ERRORMSG("%s: Cannot allocate new thing, no free slots!",func_name);
#endif
return INVALID_THING;
}
// And if there is free one, allocate it
thing = thing_get(game.free_things[i]);
#if (BFDEBUG_LEVEL > 0)
if (thing_exists(thing)) {
ERRORMSG("%s: Found existing thing %d in free things list at pos %d!",func_name,(int)game.free_things[i],(int)i);
}
#endif
LbMemorySet(thing, 0, sizeof(struct Thing));
if (thing_is_invalid(thing)) {
ERRORMSG("%s: Got invalid thing slot instead of free one!",func_name);
return INVALID_THING;
}
thing->alloc_flags |= TAlF_Exists;
thing->index = game.free_things[i];
game.free_things[game.free_things_start_index] = 0;
game.free_things_start_index++;
TRACE_THING(thing);
return thing;
}
int things_list_cb(void *data, int argc, char **argv, char **azColName){
int i;
struct tm tt;
char *laststr;
char humandate[256];
const char *button_group_start="<div class=\"btn-group\" role=\"group\" aria-label=\"actions\">";
const char *button_start="<div type=\"button\" class=\"btn btn-default\">";
// fprintf(stderr, "callback: %s\n", (const char*)data);
for(i=0; i<argc; i++){ // save all fields into the hashmap
hashmap_put(thing , azColName[i],
argv[i] ? argv[i] : "NULL");
}
attrcat(data,"list_of_things","<tr>");
snprintf(line,ml,
"<td><a href=\"/things?macaddr=%s\">"
"%s</td><td>%s</td></a>",
thing_get("macaddr"),
thing_get("hostname"), thing_get("os"));
attrcat(data,"list_of_things",line);
// get last datestamp
laststr = thing_get("last");
if(laststr) relative_time(laststr,humandate);
snprintf(line, ml, "<td>%s</td><td>", humandate);
attrcat(data,"list_of_things",line);
// action buttons
attrcat(data,"list_of_things",button_group_start);
// info button
attrcat(data,"list_of_things",button_start);
snprintf(line,ml,
"<a href=\"/things?macaddr=%s\">info</a></div>",
thing_get("macaddr"));
attrcat(data,"list_of_things",line);
attrcat(data,"list_of_things","</div></td></tr>");
// snprintf(line,ml,"<td>%s</td><td>%s</td>\n",
// thing_get("macaddr"), thing_get("ip4"));
// attrcat(data,"list_of_things",line);
return 0;
}
struct Thing *get_workshop_box_thing(PlayerNumber owner, ThingModel objmodel)
{
struct Thing *thing;
int i,k;
k = 0;
i = game.thing_lists[TngList_Objects].index;
while (i > 0)
{
thing = thing_get(i);
if (thing_is_invalid(thing))
break;
i = thing->next_of_class;
// Per-thing code
if ( ((thing->alloc_flags & TAlF_Exists) != 0) && (thing->model == objmodel) && (thing->owner == owner) )
{
struct Room *room;
room = get_room_thing_is_on(thing);
if (!thing_is_picked_up(thing) && room_role_matches(room->kind, RoRoF_CratesStorage) && (room->owner == owner))
return thing;
}
// Per-thing code ends
k++;
if (k > THINGS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping things list");
break;
}
}
return INVALID_THING;
}
/**
* Returns a hero gate object to which given hero can navigate.
* @todo CREATURE_AI It returns first hero door found, not the best one.
* Maybe it should find the one he will reach faster, or at least a random one?
* @param herotng The hero to be able to make it to gate.
* @return The gate thing, or invalid thing.
*/
struct Thing *find_hero_door_hero_can_navigate_to(struct Thing *herotng)
{
struct Thing *thing;
unsigned long k;
int i;
k = 0;
i = game.thing_lists[TngList_Objects].index;
while (i != 0)
{
thing = thing_get(i);
if (thing_is_invalid(thing))
{
ERRORLOG("Jump to invalid thing detected");
break;
}
i = thing->next_of_class;
// Per thing code
if (object_is_hero_gate(thing))
{
if (creature_can_navigate_to_with_storage(herotng, &thing->mappos, NavRtF_Default)) {
return thing;
}
}
// Per thing code ends
k++;
if (k > THINGS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping things list");
break;
}
}
return NULL;
}
void set_sprite_view_3d(void)
{
long i;
for (i=1; i < THINGS_COUNT; i++)
{
struct Thing *thing;
thing = thing_get(i);
if (thing_exists(thing))
{
if (thing_is_creature(thing) || ((thing->field_4F & TF4F_DoNotDraw) == 0))
{
int n;
n = straight_iso_td(thing->anim_sprite);
if (n >= 0)
{
thing->anim_sprite = n;
long nframes;
nframes = keepersprite_frames(thing->anim_sprite);
if (nframes != thing->field_49)
{
ERRORLOG("No frames different between views C%d, M%d, A%d, B%d",thing->class_id,thing->model,thing->field_49,nframes);
thing->field_49 = nframes;
n = thing->field_49 - 1;
if (n > thing->field_48) {
n = thing->field_48;
}
thing->field_48 = n;
thing->field_40 = n << 8;
}
}
}
}
}
}
short creature_drop_body_in_prison(struct Thing *thing)
{
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(thing);
struct Thing *dragtng;
dragtng = thing_get(cctrl->dragtng_idx);
if (!thing_exists(dragtng) || !creature_is_being_unconscious(dragtng)) {
set_start_state(thing);
return 0;
}
if (!subtile_is_room(thing->mappos.x.stl.num, thing->mappos.y.stl.num)) {
set_start_state(thing);
return 0;
}
struct Room *room;
room = get_room_thing_is_on(thing);
if ((room->owner != thing->owner) || (room->kind != RoK_PRISON)) {
set_start_state(thing);
return 0;
}
make_creature_conscious(dragtng);
initialise_thing_state(dragtng, CrSt_CreatureArrivedAtPrison);
struct CreatureControl *dragctrl;
dragctrl = creature_control_get_from_thing(dragtng);
dragctrl->flgfield_1 |= CCFlg_NoCompControl;
set_start_state(thing);
return 1;
}
struct Thing *get_trap_for_position(MapSubtlCoord stl_x, MapSubtlCoord stl_y)
{
struct Thing *thing;
struct Map *mapblk;
long i;
unsigned long k;
mapblk = get_map_block_at(stl_x,stl_y);
k = 0;
i = get_mapwho_thing_index(mapblk);
while (i != 0)
{
thing = thing_get(i);
TRACE_THING(thing);
if (thing_is_invalid(thing))
{
ERRORLOG("Jump to invalid thing detected");
break;
}
i = thing->next_on_mapblk;
// Per thing code start
if (thing->class_id == TCls_Trap) {
return thing;
}
// Per thing code end
k++;
if (k > THINGS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping things list");
break;
}
}
return INVALID_THING;
}
void init_traps(void)
{
struct Thing *thing;
int i, k;
k = 0;
const struct StructureList *slist;
slist = get_list_for_thing_class(TCls_Trap);
i = slist->index;
while (i != 0)
{
thing = thing_get(i);
if (thing_is_invalid(thing))
{
ERRORLOG("Jump to invalid thing detected");
break;
}
i = thing->next_of_class;
// Per thing code
if (thing->trap.num_shots == 0)
{
rearm_trap(thing);
}
// Per thing code ends
k++;
if (k > slist->index)
{
ERRORLOG("Infinite loop detected when sweeping things list");
break;
}
}
}
void update_explored_flags_for_power_sight(struct PlayerInfo *player)
{
struct Dungeon *dungeon;
struct Thing *thing;
SYNCDBG(9,"Starting");
//_DK_update_explored_flags_for_power_sight(player);
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_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_creature_view(void)
{
SYNCDBG(6,"Starting");
TbGraphicsWindow ewnd;
struct PlayerInfo *player;
struct Thing *thing;
//_DK_redraw_creature_view(); return;
player = get_my_player();
if (player->field_45F != 2)
player->field_45F = 2;
update_explored_flags_for_power_sight(player);
thing = thing_get(player->controlled_thing_idx);
TRACE_THING(thing);
if (!thing_is_invalid(thing))
draw_creature_view(thing);
if (smooth_on)
{
store_engine_window(&ewnd,pixel_size);
smooth_screen_area(lbDisplay.WScreen, ewnd.x, ewnd.y,
ewnd.width, ewnd.height, lbDisplay.GraphicsScreenWidth);
}
remove_explored_flags_for_power_sight(player);
draw_swipe_graphic();
if ((game.numfield_C & 0x20) != 0) {
draw_whole_status_panel();
}
draw_gui();
if ((game.numfield_C & 0x20) != 0) {
draw_overlay_compass(player->minimap_pos_x, player->minimap_pos_y);
}
message_draw();
gui_draw_all_boxes();
draw_tooltip();
}
void set_sprite_view_isometric(void)
{
//_DK_set_sprite_view_isometric();
long i;
for (i=1; i < THINGS_COUNT; i++)
{
struct Thing *thing;
thing = thing_get(i);
if (thing_exists(thing))
{
if (thing_is_creature(thing) || ((thing->field_4F & 0x01) == 0))
{
int n;
n = straight_td_iso(thing->field_44);
if (n >= 0)
{
thing->field_44 = n;
long nframes;
nframes = keepersprite_frames(thing->field_44);
if (nframes != thing->field_49)
{
ERRORLOG("No frames different between views C%d, M%d, A%d, B%d",thing->class_id,thing->model,thing->field_49,nframes);
thing->field_49 = nframes;
n = thing->field_49 - 1;
if (n > thing->field_48) {
n = thing->field_48;
}
thing->field_48 = n;
thing->field_40 = n << 8;
}
}
}
}
}
}
long instf_creature_fire_shot(struct Thing *creatng, long *param)
{
struct CreatureControl *cctrl;
struct Thing *target;
int i;
TRACE_THING(creatng);
cctrl = creature_control_get_from_thing(creatng);
if (cctrl->targtng_idx <= 0)
{
if ((creatng->alloc_flags & TAlF_IsControlled) == 0)
i = 4;
else
i = 1;
}
else if ((creatng->alloc_flags & TAlF_IsControlled) != 0)
{
target = thing_get(cctrl->targtng_idx);
TRACE_THING(target);
if (target->class_id == TCls_Object)
i = 1;
else
i = 2;
}
else
{
target = thing_get(cctrl->targtng_idx);
TRACE_THING(target);
if (target->class_id == TCls_Object)
i = 1;
else if (target->owner == creatng->owner)
i = 2;
else
i = 4;
}
if (cctrl->targtng_idx > 0)
{
target = thing_get(cctrl->targtng_idx);
SYNCDBG(8,"The %s index %d fires %s at %s index %d",thing_model_name(creatng),(int)creatng->index,shot_code_name(*param),thing_model_name(target),(int)target->index);
TRACE_THING(target);
} else
{
target = NULL;
SYNCDBG(8,"The %s index %d fires %s",thing_model_name(creatng),(int)creatng->index,shot_code_name(*param));
}
creature_fire_shot(creatng, target, *param, 1, i);
return 0;
}
void process_disease(struct Thing *creatng)
{
SYNCDBG(18,"Starting");
//_DK_process_disease(thing);
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(creatng);
if (!creature_affected_by_spell(creatng, SplK_Disease)) {
return;
}
if (ACTION_RANDOM(100) < game.disease_transfer_percentage)
{
SubtlCodedCoords stl_num;
long n;
stl_num = get_subtile_number(creatng->mappos.x.stl.num,creatng->mappos.y.stl.num);
for (n=0; n < AROUND_MAP_LENGTH; n++)
{
struct Thing *thing;
struct Map *mapblk;
unsigned long k;
long i;
mapblk = get_map_block_at_pos(stl_num+around_map[n]);
k = 0;
i = get_mapwho_thing_index(mapblk);
while (i != 0)
{
thing = thing_get(i);
if (thing_is_invalid(thing))
{
WARNLOG("Jump out of things array");
break;
}
i = thing->next_on_mapblk;
// Per thing code
if (thing_is_creature(thing) && ((get_creature_model_flags(thing) & CMF_IsSpecDigger) == 0)
&& (thing->owner != cctrl->disease_caster_plyridx) && !creature_affected_by_spell(thing, SplK_Disease))
{
struct CreatureControl *tngcctrl;
tngcctrl = creature_control_get_from_thing(thing);
apply_spell_effect_to_thing(thing, SplK_Disease, cctrl->explevel);
tngcctrl->disease_caster_plyridx = cctrl->disease_caster_plyridx;
}
// Per thing code ends
k++;
if (k > THINGS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping things list");
erstat_inc(ESE_InfChainTngPerMapWho);
break_mapwho_infinite_chain(mapblk);
break;
}
}
}
}
if (((game.play_gameturn - cctrl->disease_start_turn) % game.disease_lose_health_time) == 0)
{
apply_damage_to_thing_and_display_health(creatng, game.disease_lose_percentage_health * cctrl->max_health / 100, DmgT_Biological, cctrl->disease_caster_plyridx);
}
}
long instf_creature_fire_shot(struct Thing *creatng, long *param)
{
struct CreatureControl *cctrl;
struct Thing *target;
int i;
TRACE_THING(creatng);
cctrl = creature_control_get_from_thing(creatng);
if (cctrl->targtng_idx <= 0)
{
if ((creatng->alloc_flags & TAlF_IsControlled) == 0)
i = 4;
else
i = 1;
}
else if ((creatng->alloc_flags & TAlF_IsControlled) != 0)
{
target = thing_get(cctrl->targtng_idx);
TRACE_THING(target);
if (target->class_id == TCls_Object)
i = 1;
else
i = 2;
}
else
{
target = thing_get(cctrl->targtng_idx);
TRACE_THING(target);
if (target->class_id == TCls_Object)
i = 1;
else if (target->owner == creatng->owner)
i = 2;
else
i = 4;
}
if (cctrl->targtng_idx > 0)
{
target = thing_get(cctrl->targtng_idx);
TRACE_THING(target);
} else
{
target = NULL;
}
creature_fire_shot(creatng, target, *param, 1, i);
return 0;
}
struct Thing *get_player_soul_container(PlayerNumber plyr_idx)
{
struct Dungeon *dungeon;
dungeon = get_players_num_dungeon(plyr_idx);
if (dungeon->dnheart_idx > 0) {
return thing_get(dungeon->dnheart_idx);
}
return INVALID_THING;
}
long gfa_controlled_creature_has_instance(struct GuiBox *gbox, struct GuiBoxOption *goptn, long *tag)
{
struct PlayerInfo *player;
struct Thing *thing;
player = get_my_player();
if ((player->controlled_thing_idx <= 0) || (player->controlled_thing_idx >= THINGS_COUNT))
return false;
thing = thing_get(player->controlled_thing_idx);
return creature_instance_is_available(thing, *tag);
}
struct Thing *select_scavenger_target(const struct Thing *calltng)
{
long weakpts;
struct Thing *weaktng;
weaktng = INVALID_THING;
weakpts = LONG_MAX;
struct Thing *thing;
unsigned long k;
int i;
SYNCDBG(18,"Starting");
const struct StructureList *slist;
slist = get_list_for_thing_class(TCls_Creature);
k = 0;
i = slist->index;
while (i != 0)
{
thing = thing_get(i);
if (thing_is_invalid(thing))
{
ERRORLOG("Jump to invalid thing detected");
break;
}
i = thing->next_of_class;
// Per-thing code
if (thing_is_valid_scavenge_target(calltng, thing))
{
SYNCDBG(18,"The %s index %d owner %d is valid target for %s index %d owner %d",
thing_model_name(thing),(int)thing->index,(int)thing->owner,
thing_model_name(calltng),(int)calltng->index,(int)calltng->owner);
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(thing);
if (game.play_gameturn - cctrl->temple_cure_gameturn > game.temple_scavenge_protection_turns)
{
long thingpts;
thingpts = calculate_correct_creature_scavenge_required(thing, calltng->owner);
if (weakpts > thingpts)
{
weakpts = thingpts;
weaktng = thing;
}
}
}
// Per-thing code ends
k++;
if (k > slist->count)
{
ERRORLOG("Infinite loop detected when sweeping things list");
break;
}
}
SYNCDBG(18,"The weakest valid target for %s index %d owner %d is %s index %d owner %d",
thing_model_name(calltng),(int)calltng->index,(int)calltng->owner,
thing_model_name(weaktng),(int)weaktng->index,(int)weaktng->owner);
return weaktng;
}
TbBool find_combat_target_passing_by_subtile_but_having_unrelated_job(const struct Thing *creatng, CreatureJob job_kind, MapSubtlCoord stl_x, MapSubtlCoord stl_y, unsigned long *found_dist, struct Thing **found_thing)
{
struct Thing *thing;
struct Map *mapblk;
long i;
unsigned long k;
long dist;
mapblk = get_map_block_at(stl_x,stl_y);
k = 0;
i = get_mapwho_thing_index(mapblk);
while (i != 0)
{
thing = thing_get(i);
TRACE_THING(thing);
if (thing_is_invalid(thing))
{
ERRORLOG("Jump to invalid thing detected");
break;
}
i = thing->next_on_mapblk;
// Per thing code start
if (thing_is_creature(thing) && (thing->index != creatng->index) && !creature_has_job(thing, job_kind)
&& !creature_is_kept_in_custody(thing) && !creature_is_being_unconscious(thing)
&& !creature_is_dying(thing) && !creature_is_doing_anger_job(thing))
{
if (!creature_is_invisible(thing) || creature_can_see_invisible(creatng))
{
dist = get_combat_distance(creatng, thing);
// If we have combat sight - we want that target, don't search anymore
if (creature_can_see_combat_path(creatng, thing, dist) > AttckT_Unset)
{
*found_dist = dist;
*found_thing = thing;
return true;
}
// No combat sight - but maybe it's at least closer than previous one
if ( *found_dist > dist )
{
*found_dist = dist;
*found_thing = thing;
}
}
}
// Per thing code end
k++;
if (k > THINGS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping things list");
break;
}
}
return false;
}
void update_god_lightning_ball(struct Thing *thing)
{
struct CreatureControl *cctrl;
struct Thing *target;
struct ShotConfigStats *shotst;
long i;
// _DK_update_god_lightning_ball(thing);
if (thing->health <= 0)
{
lightning_modify_palette(thing);
return;
}
i = (game.play_gameturn - thing->creation_turn) % 16;
switch (i)
{
case 0:
god_lightning_choose_next_creature(thing);
break;
case 1:
target = thing_get(thing->shot.target_idx);
if (thing_is_invalid(target))
break;
draw_lightning(&thing->mappos,&target->mappos, 96, 60);
break;
case 2:
target = thing_get(thing->shot.target_idx);
if (thing_is_invalid(target))
break;
shotst = get_shot_model_stats(24);
apply_damage_to_thing_and_display_health(target, shotst->old->damage, shotst->damage_type, thing->owner);
if (target->health < 0)
{
cctrl = creature_control_get_from_thing(target);
cctrl->shot_model = ShM_GodLightBall;
kill_creature(target, INVALID_THING, thing->owner, CrDed_DiedInBattle);
}
thing->shot.target_idx = 0;
break;
}
}
const struct Coord3d *dungeon_get_essential_pos(PlayerNumber plyr_idx)
{
struct Dungeon *dungeon;
dungeon = get_players_num_dungeon(plyr_idx);
if (dungeon->dnheart_idx > 0) {
struct Thing *heartng;
heartng = thing_get(dungeon->dnheart_idx);
if (thing_exists(heartng)) {
return &heartng->mappos;
}
}
return &dungeon->essential_pos;
}
TbBool thing_exists(const struct Thing *thing)
{
if (thing_is_invalid(thing))
return false;
if ((thing->alloc_flags & TAlF_Exists) == 0)
return false;
#if (BFDEBUG_LEVEL > 0)
if (thing->index != (thing-thing_get(0)))
WARNLOG("Incorrectly indexed thing (%d) at pos %d",(int)thing->index,(int)(thing-thing_get(0)));
if ((thing->class_id < 1) || (thing->class_id >= THING_CLASSES_COUNT))
WARNLOG("Thing %d is of invalid class %d",(int)thing->index,(int)thing->class_id);
#endif
return true;
}
TbBool creature_move_to_home_lair(struct Thing *creatng)
{
if (!creature_has_lair_room(creatng)) {
return false;
}
struct CreatureControl *cctrl;
struct Thing *lairtng;
cctrl = creature_control_get_from_thing(creatng);
lairtng = thing_get(cctrl->lairtng_idx);
if (thing_is_invalid(lairtng)) {
return false;
}
return setup_person_move_to_coord(creatng, &lairtng->mappos, NavRtF_Default);
}
long creature_will_sleep(struct Thing *thing)
{
struct CreatureControl *cctrl;
struct Thing *lairtng;
long dist_x,dist_y;
TRACE_THING(thing);
cctrl = creature_control_get_from_thing(thing);
lairtng = thing_get(cctrl->lairtng_idx);
TRACE_THING(lairtng);
if (thing_is_invalid(lairtng))
return false;
dist_x = (long)thing->mappos.x.stl.num - (long)lairtng->mappos.x.stl.num;
dist_y = (long)thing->mappos.y.stl.num - (long)lairtng->mappos.y.stl.num;
return (abs(dist_x) < 1) && (abs(dist_y) < 1);
}
TbBool ambient_sound_stop(void)
{
struct Thing *thing;
thing = thing_get(game.ambient_sound_thing_idx);
if (thing_is_invalid(thing))
{
return false;
}
if (thing->snd_emitter_id != 0)
{
S3DDestroySoundEmitterAndSamples(thing->snd_emitter_id);
thing->snd_emitter_id = 0;
}
return true;
}
TbBool action_point_is_creature_from_list_within(const struct ActionPoint *apt, long first_thing_idx)
{
unsigned long k;
int i;
SYNCDBG(8,"Starting");
k = 0;
i = first_thing_idx;
while (i != 0)
{
struct Thing *thing;
thing = thing_get(i);
TRACE_THING(thing);
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(thing);
if (thing_is_invalid(thing) || creature_control_invalid(cctrl))
{
ERRORLOG("Jump to invalid creature detected");
break;
}
i = cctrl->players_next_creature_idx;
// Thing list loop body
// Range of 0 means activate when on the same subtile
if (apt->range <= 0)
{
if ((apt->mappos.x.stl.num == thing->mappos.x.stl.num)
&& (apt->mappos.y.stl.num == thing->mappos.y.stl.num)) {
return true;
}
} else
{
long dist;
dist = get_distance_xy(thing->mappos.x.val, thing->mappos.y.val, apt->mappos.x.val, apt->mappos.y.val);
if (apt->range > dist) {
return true;
}
}
// Thing list loop body ends
k++;
if (k > CREATURES_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping creatures list");
break;
}
}
return false;
}
void turn_off_power_call_to_arms(PlayerNumber plyr_idx)
{
//_DK_turn_off_call_to_arms(plyr_idx);
if (!player_uses_power_call_to_arms(plyr_idx)) {
return;
}
struct PlayerInfo *player;
player = get_player(plyr_idx);
{
struct Thing *objtng;
objtng = thing_get(player->field_43C);
set_call_to_arms_as_dying(objtng);
struct Dungeon *dungeon;
dungeon = get_players_dungeon(player);
dungeon->cta_start_turn = 0;
}
reset_all_players_creatures_affected_by_cta(plyr_idx);
}
struct Thing *computer_check_creatures_in_room_for_accelerate(struct Computer2 *comp, struct Room *room)
{
struct Dungeon *dungeon;
struct StateInfo *stati;
struct CreatureControl *cctrl;
struct Thing *thing;
unsigned long k;
long i,n;
dungeon = comp->dungeon;
i = room->creatures_list;
k = 0;
while (i != 0)
{
thing = thing_get(i);
cctrl = creature_control_get_from_thing(thing);
if (thing_is_invalid(thing) || creature_control_invalid(cctrl))
{
ERRORLOG("Jump to invalid creature %ld detected",i);
break;
}
i = cctrl->next_in_room;
// Per creature code
if (!thing_affected_by_spell(thing, SplK_Speed))
{
n = get_creature_state_besides_move(thing);
stati = get_thing_state_info_num(n);
if (stati->state_type == 1)
{
if (try_game_action(comp, dungeon->owner, GA_UsePwrSpeedUp, SPELL_MAX_LEVEL, 0, 0, thing->index, 0) > Lb_OK)
{
return thing;
}
}
}
// Per creature code ends
k++;
if (k > THINGS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping things list");
break;
}
}
return INVALID_THING;
}
TbBool find_pressure_trigger_trap_target_passing_by_subtile(const struct Thing *traptng, MapSubtlCoord stl_x, MapSubtlCoord stl_y, struct Thing **found_thing)
{
struct Thing *thing;
struct Map *mapblk;
long i;
unsigned long k;
mapblk = get_map_block_at(stl_x,stl_y);
k = 0;
i = get_mapwho_thing_index(mapblk);
while (i != 0)
{
thing = thing_get(i);
TRACE_THING(thing);
if (thing_is_invalid(thing))
{
ERRORLOG("Jump to invalid thing detected");
break;
}
i = thing->next_on_mapblk;
// Per thing code start
if (thing_is_creature(thing) && (thing->owner != traptng->owner))
{
if (!creature_is_being_unconscious(thing) && !thing_is_dragged_or_pulled(thing)
&& !creature_is_kept_in_custody_by_enemy(thing) && !creature_is_dying(thing)
&& ((get_creature_model_flags(thing) & CMF_IsSpectator) == 0))
{
if (!is_neutral_thing(thing) && !players_are_mutual_allies(traptng->owner,thing->owner))
{
*found_thing = thing;
return true;
}
}
}
// Per thing code end
k++;
if (k > THINGS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping things list");
break;
}
}
return false;
}
struct Thing *get_scavenger_target(const struct Thing *calltng)
{
struct Dungeon *dungeon;
dungeon = get_dungeon(calltng->owner);
{ // Check if last scavenged creature of that kind is still good for scavenging
struct Thing *lastng;
if (dungeon->scavenge_targets[calltng->model] != 0) {
lastng = thing_get(dungeon->scavenge_targets[calltng->model]);
} else {
lastng = INVALID_THING;
}
if (thing_is_valid_scavenge_target(calltng, lastng))
{
SYNCDBG(8,"The last target, %s index %d owner %d, is still valid",thing_model_name(lastng),(int)lastng->index,(int)lastng->owner);
return lastng;
}
}
return select_scavenger_target(calltng);
}
