void update_creature_graphic_field_4F(struct Thing *thing)
{
// Clear related flags
thing->field_4F &= ~TF4F_Unknown01;
thing->field_4F &= ~TF4F_Unknown10;
thing->field_4F &= ~TF4F_Unknown20;
thing->field_4F &= ~0x40;
// Now set only those that should be
if (((thing->alloc_flags & TAlF_IsControlled) != 0) && is_my_player_number(thing->owner))
{
thing->field_4F |= TF4F_Unknown01;
} else
if (creatures[thing->model].field_7)
{
thing->field_4F |= TF4F_Unknown10;
thing->field_4F |= TF4F_Unknown20;
} else
if (creature_is_invisible(thing))
{
if (is_my_player_number(thing->owner))
{
thing->field_4F &= ~TF4F_Unknown10;
thing->field_4F |= TF4F_Unknown20;
} else
{
thing->field_4F |= TF4F_Unknown01;
}
}
}
/**
* Does a step of being imprisoned.
* Informs if the imprisoning cycle should end.
* @param thing
*/
CrCheckRet process_prison_function(struct Thing *creatng)
{
struct Room *room;
room = get_room_creature_works_in(creatng);
if (!room_still_valid_as_type_for_thing(room, RoK_PRISON, creatng))
{
WARNLOG("Room %s owned by player %d is bad work place for %s index %d owner %d",room_code_name(room->kind),(int)room->owner,thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
set_start_state(creatng);
return CrCkRet_Continue;
}
process_creature_hunger(creatng);
if ( process_prisoner_skelification(creatng,room) )
return CrCkRet_Deleted;
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(creatng);
if ((cctrl->instance_id == CrInst_NULL) && process_prison_food(creatng, room) )
return CrCkRet_Continue;
// Breaking from jail is only possible once per some amount of turns
if ((game.play_gameturn % gameadd.time_between_prison_break) == 0)
{
if (jailbreak_possible(room, creatng->owner))
{
if (is_my_player_number(room->owner))
output_message(SMsg_PrisonersEscaping, 40, true);
else if (is_my_player_number(room->owner))
output_message(SMsg_CreatrFreedPrison, 40, true);
set_start_state(creatng);
return CrCkRet_Continue;
}
}
return CrCkRet_Available;
}
long attempt_anger_job(struct Thing *creatng, long ajob_kind)
{
switch (ajob_kind)
{
case 1:
if (!attempt_anger_job_kill_creatures(creatng))
break;
return true;
case 2:
if (!attempt_anger_job_destroy_rooms(creatng))
break;
if (is_my_player_number(creatng->owner))
output_message(SMsg_CreatrDestroyRooms, 500, 1);
return true;
case 4:
if (!attempt_anger_job_leave_dungeon(creatng))
break;
if (is_my_player_number(creatng->owner))
output_message(SMsg_CreatureLeaving, 500, 1);
return true;
case 8:
if (!attempt_anger_job_steal_gold(creatng))
break;
return true;
case 16:
if (!attempt_anger_job_damage_walls(creatng))
break;
if (is_my_player_number(creatng->owner))
output_message(SMsg_CreatrDestroyRooms, 500, 1);
return true;
case 32:
if (!attempt_anger_job_mad_psycho(creatng))
break;
return true;
case 64:
if (!attempt_anger_job_persuade(creatng)) {
// If can't init persuade, then leave alone
if (!attempt_anger_job_leave_dungeon(creatng))
break;
if (is_my_player_number(creatng->owner))
output_message(SMsg_CreatureLeaving, 500, 1);
}
return true;
case 128:
if (!attempt_anger_job_join_enemy(creatng))
break;
return true;
default:
break;
}
return false;
}
CrCheckRet process_scavenge_function(struct Thing *calltng)
{
SYNCDBG(18,"Starting for %s owner %d",thing_model_name(calltng),(int)calltng->owner);
//return _DK_process_scavenge_function(thing);
struct CreatureControl *callctrl;
callctrl = creature_control_get_from_thing(calltng);
struct Dungeon *calldngn;
struct Room *room;
calldngn = get_dungeon(calltng->owner);
room = get_room_creature_works_in(calltng);
if ( !room_still_valid_as_type_for_thing(room, RoK_SCAVENGER, calltng) )
{
WARNLOG("Room %s owned by player %d is bad work place for %s owned by played %d",room_code_name(room->kind),(int)room->owner,thing_model_name(calltng),(int)calltng->owner);
set_start_state(calltng);
return CrCkRet_Continue;
}
struct CreatureStats *crstat;
crstat = creature_stats_get_from_thing(calltng);
if (!player_can_afford_to_scavenge_creature(calltng))
{
if (is_my_player_number(calltng->owner))
output_message(SMsg_NoGoldToScavenge, 500, 1);
set_start_state(calltng);
return CrCkRet_Continue;
}
if (calldngn->scavenge_counters_turn != game.play_gameturn)
{
reset_scavenge_counts(calldngn);
}
long work_value;
work_value = compute_creature_work_value(crstat->scavenge_value*256, room->efficiency, callctrl->explevel);
work_value = process_work_speed_on_work_value(calltng, work_value);
SYNCDBG(9,"The %s index %d owner %d produced %d scavenge points",thing_model_name(calltng),(int)calltng->index,(int)calltng->owner,(int)work_value);
struct Thing *scavtng;
scavtng = get_scavenger_target(calltng);
if (!thing_is_invalid(scavtng))
{
process_scavenge_creature_from_level(scavtng, calltng, work_value);
} else
if (can_scavenge_creature_from_pool(calldngn, calltng->model))
{
process_scavenge_creature_from_pool(calltng, work_value);
} else
{
if (crstat->entrance_force) {
calldngn->field_1485++;
}
return 0;
}
callctrl->field_82++;
if (callctrl->field_82 > game.scavenge_cost_frequency)
{
callctrl->field_82 -= game.scavenge_cost_frequency;
if (take_money_from_dungeon(calltng->owner, crstat->scavenger_cost, 1) < 0) {
ERRORLOG("Cannot take %d gold from dungeon %d",(int)crstat->scavenger_cost,(int)calltng->owner);
}
create_price_effect(&calltng->mappos, calltng->owner, crstat->scavenger_cost);
}
return 0;
}
void reset_creature_eye_lens(struct Thing *thing)
{
if (is_my_player_number(thing->owner))
{
setup_eye_lens(0);
}
}
void transfer_creature(struct Thing *boxtng, struct Thing *transftng, unsigned char plyr_idx)
{
SYNCDBG(7,"Starting");
struct CreatureControl *cctrl;
if (!thing_exists(boxtng) || (box_thing_to_special(boxtng) != SpcKind_TrnsfrCrtr) ) {
ERRORMSG("Invalid transfer box object!");
return;
}
// Check if 'things' are correct
if (!thing_exists(transftng) || !thing_is_creature(transftng) || (transftng->owner != plyr_idx)) {
ERRORMSG("Invalid transfer creature thing!");
return;
}
cctrl = creature_control_get_from_thing(transftng);
set_transfered_creature(plyr_idx, transftng->model, cctrl->explevel);
remove_thing_from_power_hand_list(transftng, plyr_idx);
kill_creature(transftng, INVALID_THING, -1, CrDed_NoEffects|CrDed_NotReallyDying);
create_special_used_effect(&boxtng->mappos, plyr_idx);
remove_events_thing_is_attached_to(boxtng);
force_any_creature_dragging_owned_thing_to_drop_it(boxtng);
delete_thing_structure(boxtng, 0);
if (is_my_player_number(plyr_idx))
output_message(SMsg_CommonAcknowledge, 0, true);
}
TbBool output_message_room_related_from_computer_or_player_action(PlayerNumber plyr_idx, RoomKind rkind, OutputMessageKind msg_kind)
{
if (!is_my_player_number(plyr_idx)) {
return false;
}
const struct RoomConfigStats *roomst;
roomst = get_room_kind_stats(rkind);
long delay, msg_idx;
switch (msg_kind)
{
case OMsg_RoomNeeded:
msg_idx = roomst->msg_needed;
delay = MESSAGE_DELAY_ROOM_NEED;
break;
case OMsg_RoomTooSmall:
msg_idx = roomst->msg_too_small;
delay = MESSAGE_DELAY_ROOM_SMALL;
break;
case OMsg_RoomNoRoute:
msg_idx = roomst->msg_no_route;
delay = MESSAGE_DELAY_ROOM_NEED;
break;
default:
msg_idx = 0;
delay = 0;
break;
}
if (msg_idx < 1) {
return false;
}
return output_message(msg_idx, delay, true);
}
short at_scavenger_room(struct Thing *thing)
{
struct CreatureControl *cctrl;
struct CreatureStats *crstat;
struct Dungeon *dungeon;
struct Room *room;
//return _DK_at_scavenger_room(thing);
room = get_room_thing_is_on(thing);
if (!room_initially_valid_as_type_for_thing(room, RoK_SCAVENGER, thing))
{
WARNLOG("Room %s owned by player %d is invalid for %s index %d",room_code_name(room->kind),(int)room->owner,thing_model_name(thing),(int)thing->index);
set_start_state(thing);
return 0;
}
cctrl = creature_control_get_from_thing(thing);
crstat = creature_stats_get_from_thing(thing);
dungeon = get_dungeon(thing->owner);
if (crstat->scavenger_cost >= dungeon->total_money_owned)
{
if (is_my_player_number(thing->owner))
output_message(SMsg_NoGoldToScavenge, MESSAGE_DELAY_TREASURY, true);
set_start_state(thing);
return 0;
}
if (!add_creature_to_work_room(thing, room))
{
set_start_state(thing);
return 0;
}
internal_set_thing_state(thing, CrSt_Scavengering);
cctrl->field_82 = 0;
return 1;
}
struct Thing *create_and_control_creature_as_controller(struct PlayerInfo *player, long breed, struct Coord3d *pos)
{
struct CreatureStats *crstat;
struct CreatureControl *cctrl;
struct Dungeon *dungeon;
struct Thing *thing;
struct Camera *cam;
struct InitLight ilght;
SYNCDBG(6,"Request for model %ld at (%d,%d,%d)",breed,(int)pos->x.val,(int)pos->y.val,(int)pos->z.val);
//return _DK_create_and_control_creature_as_controller(player, a2, pos);
thing = create_creature(pos, breed, player->id_number);
if (thing_is_invalid(thing))
return INVALID_THING;
dungeon = get_dungeon(thing->owner);
dungeon->num_active_creatrs--;
dungeon->owned_creatures_of_model[thing->model]--;
if (is_my_player(player))
{
toggle_status_menu(0);
turn_off_roaming_menus();
}
cam = player->acamera;
player->controlled_thing_idx = thing->index;
player->field_31 = thing->creation_turn;
player->field_4B5 = cam->field_6;
thing->alloc_flags |= TAlF_IsControlled;
thing->field_4F |= 0x01;
cctrl = creature_control_get_from_thing(thing);
cctrl->flgfield_2 |= 0x02;
cctrl->max_speed = calculate_correct_creature_maxspeed(thing);
set_player_mode(player, PVT_CreatureContrl);
set_start_state(thing);
// Preparing light object
LbMemorySet(&ilght, 0, sizeof(struct InitLight));
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_2 = 36;
ilght.field_3 = 1;
ilght.is_dynamic = 1;
ilght.field_0 = 2560;
thing->light_id = light_create_light(&ilght);
if (thing->light_id != 0)
{
light_set_light_never_cache(thing->light_id);
} else
{
ERRORLOG("Cannot allocate light to new hero");
}
if (is_my_player_number(thing->owner))
{
if (thing->class_id == TCls_Creature)
{
crstat = creature_stats_get_from_thing(thing);
setup_eye_lens(crstat->eye_effect);
}
}
return thing;
}
TbBool set_transfered_creature(PlayerNumber plyr_idx, ThingModel model, long explevel)
{
if (is_my_player_number(plyr_idx))
{
game.intralvl_transfered_creature.model = model;
game.intralvl_transfered_creature.explevel = explevel;
return true;
}
return false;
}
short good_attack_room(struct Thing *thing)
{
// Debug code to find incorrect states
if (!is_hero_thing(thing))
{
ERRORLOG("Non hero %s index %d owner %d - reset",thing_model_name(thing),(int)thing->index,(int)thing->owner);
set_start_state(thing);
return 0;
}
//return _DK_good_attack_room(thing);
MapSlabCoord base_slb_x,base_slb_y;
base_slb_x = subtile_slab_fast(thing->mappos.x.stl.num);
base_slb_y = subtile_slab_fast(thing->mappos.y.stl.num);
struct Room *room;
room = slab_room_get(base_slb_x, base_slb_y);
// If the current tile can be destroyed
if (room_exists(room) && (room->owner != thing->owner) && !room_cannot_vandalise(room->kind))
{
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(thing);
if (cctrl->instance_id == CrInst_NULL)
{
set_creature_instance(thing, CrInst_ATTACK_ROOM_SLAB, 1, 0, 0);
MapCoord ev_coord_x,ev_coord_y;
ev_coord_x = subtile_coord_center(room->central_stl_x);
ev_coord_y = subtile_coord_center(room->central_stl_y);
event_create_event_or_update_nearby_existing_event(ev_coord_x, ev_coord_y, EvKind_RoomUnderAttack, room->owner, 0);
if (is_my_player_number(room->owner))
output_message(SMsg_EnemyDestroyRooms, MESSAGE_DELAY_FIGHT, true);
}
return 1;
}
// Otherwise, search around for a tile to destroy
long m,n;
m = ACTION_RANDOM(SMALL_AROUND_SLAB_LENGTH);
for (n=0; n < SMALL_AROUND_SLAB_LENGTH; n++)
{
MapSlabCoord slb_x,slb_y;
slb_x = base_slb_x + (long)small_around[m].delta_x;
slb_y = base_slb_y + (long)small_around[m].delta_y;
room = slab_room_get(slb_x, slb_y);
if (room_exists(room) && (room->owner != thing->owner))
{
if (setup_person_move_to_position(thing, slb_x, slb_y, NavRtF_Default))
{
thing->continue_state = CrSt_GoodAttackRoom1;
return 1;
}
}
m = (m+1) % SMALL_AROUND_SLAB_LENGTH;
}
set_start_state(thing);
return 0;
}
void process_armageddon(void)
{
struct PlayerInfo *player;
struct Dungeon *dungeon;
struct Thing *heartng;
long i;
SYNCDBG(6,"Starting");
//_DK_process_armageddon(); return;
if (game.armageddon_cast_turn == 0)
return;
if (game.armageddon.count_down+game.armageddon_cast_turn > game.play_gameturn)
{
if (player_cannot_win(game.armageddon_caster_idx))
{
// Stop the armageddon if its originator is just losing
game.armageddon_cast_turn = 0;
}
} else
if (game.armageddon.count_down+game.armageddon_cast_turn == game.play_gameturn)
{
for (i=0; i < PLAYERS_COUNT; i++)
{
player = get_player(i);
if (player_exists(player))
{
if (player->field_2C == 1)
reveal_whole_map(player);
}
}
} else
if (game.armageddon.count_down+game.armageddon_cast_turn < game.play_gameturn)
{
for (i=0; i < PLAYERS_COUNT; i++)
{
player = get_player(i);
if ( (player_exists(player)) && (player->field_2C == 1) )
{
dungeon = get_dungeon(player->id_number);
if ((player->victory_state == VicS_Undecided) && (dungeon->num_active_creatrs == 0))
{
event_kill_all_players_events(i);
set_player_as_lost_level(player);
if (is_my_player_number(i))
LbPaletteSet(engine_palette);
heartng = get_player_soul_container(player->id_number);
if (thing_exists(heartng)) {
heartng->health = -1;
}
}
}
}
}
}
short creature_scavenged_disappear(struct Thing *thing)
{
struct CreatureControl *cctrl;
struct Dungeon *dungeon;
struct Room *room;
struct Coord3d pos;
long stl_x, stl_y;
long i;
//return _DK_creature_scavenged_disappear(thing);
cctrl = creature_control_get_from_thing(thing);
cctrl->byte_9A--;
if (cctrl->byte_9A > 0)
{
if ((cctrl->byte_9A == 7) && (cctrl->byte_9B < PLAYERS_COUNT))
{
create_effect(&thing->mappos, get_scavenge_effect_element(cctrl->byte_9B), thing->owner);
}
return 0;
}
// We don't really have to convert coordinates into numbers and back to XY.
i = get_subtile_number(cctrl->scavenge.stl_9D_x, cctrl->scavenge.stl_9D_y);
stl_x = stl_num_decode_x(i);
stl_y = stl_num_decode_y(i);
room = subtile_room_get(stl_x, stl_y);
if (room_is_invalid(room) || (room->kind != RoK_SCAVENGER))
{
ERRORLOG("Room %s at (%d,%d) disappeared.",room_code_name(RoK_SCAVENGER),(int)stl_x,(int)stl_y);
kill_creature(thing, INVALID_THING, -1, CrDed_NoEffects);
return -1;
}
if (find_random_valid_position_for_thing_in_room(thing, room, &pos))
{
move_thing_in_map(thing, &pos);
anger_set_creature_anger_all_types(thing, 0);
dungeon = get_dungeon(cctrl->byte_9B);
dungeon->creatures_scavenge_gain++;
if (is_my_player_number(thing->owner))
output_message(SMsg_MinionScanvenged, 0, true);
cctrl->byte_9C = thing->owner;
change_creature_owner(thing, cctrl->byte_9B);
internal_set_thing_state(thing, CrSt_CreatureScavengedReappear);
return 0;
} else
{
ERRORLOG("No valid position inside %s room for %s.",room_code_name(room->kind),thing_model_name(thing));
kill_creature(thing, INVALID_THING, -1, CrDed_NoEffects);
return -1;
}
}
void turn_off_event_box_if_necessary(PlayerNumber plyr_idx, unsigned char event_idx)
{
struct Dungeon *dungeon;
dungeon = get_players_num_dungeon(plyr_idx);
if (dungeon->visible_event_idx != event_idx) {
return;
}
dungeon->visible_event_idx = 0;
if (is_my_player_number(plyr_idx))
{
turn_off_menu(GMnu_TEXT_INFO);
turn_off_menu(GMnu_BATTLE);
turn_off_menu(GMnu_DUNGEON_SPECIAL);
}
}
TbBool process_prisoner_skelification(struct Thing *thing, struct Room *room)
{
struct CreatureStats *crstat;
crstat = creature_stats_get_from_thing(thing);
if ((thing->health >= 0) || (!crstat->humanoid_creature)) {
return false;
}
//TODO [config] Allow skeletification only if spent specific amount of turns in prison (set low value)
if (ACTION_RANDOM(101) > game.prison_skeleton_chance)
return false;
if (is_my_player_number(room->owner))
output_message(SMsg_PrisonMadeSkeleton, 0, true);
prison_convert_creature_to_skeleton(room,thing);
return true;
}
short manufacturing(struct Thing *creatng)
{
struct Room *room;
//return _DK_manufacturing(creatng);
TRACE_THING(creatng);
room = get_room_thing_is_on(creatng);
if (creature_work_in_room_no_longer_possible(room, RoK_WORKSHOP, creatng))
{
remove_creature_from_work_room(creatng);
set_start_state(creatng);
return CrStRet_ResetFail;
}
if (room->used_capacity > room->total_capacity)
{
if (is_my_player_number(creatng->owner))
output_message(SMsg_WorkshopTooSmall, 500, true);
remove_creature_from_work_room(creatng);
set_start_state(creatng);
return CrStRet_ResetOk;
}
struct Dungeon *dungeon;
dungeon = get_dungeon(creatng->owner);
if (dungeon->manufacture_class)
{
struct CreatureControl *cctrl;
struct CreatureStats *crstat;
cctrl = creature_control_get_from_thing(creatng);
crstat = creature_stats_get_from_thing(creatng);
long work_value;
work_value = compute_creature_work_value(crstat->manufacture_value*256, room->efficiency, cctrl->explevel);
work_value = process_work_speed_on_work_value(creatng, work_value);
SYNCDBG(9,"The %s index %d produced %d manufacture points",thing_model_name(creatng),(int)creatng->index,(int)work_value);
dungeon->manufacture_progress += work_value;
dungeon->field_1181 += work_value;
} else
{
WARNDBG(9,"The %s index %d owner %d is manufacturing nothing",thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
// This may be cause by a creature taking up place in workshop where crate should be created; the creature should take a break
if (room->used_capacity >= room->total_capacity) {
external_set_thing_state(creatng, CrSt_CreatureGoingHomeToSleep);
return CrStRet_Modified;
}
}
process_creature_in_workshop(creatng, room);
return CrStRet_Modified;
}
void setup_alliances(void)
{
int i;
struct PlayerInfo *player;
for (i=0; i<PLAYERS_COUNT; i++)
{
player = get_player(i);
if (!is_my_player_number(i) && player_exists(player))
{
if (frontend_is_player_allied(my_player_number, i))
{
set_ally_with_player(my_player_number, i, true);
set_ally_with_player(i, my_player_number, true);
}
}
}
}
TbBool creature_can_do_research_near_pos(const struct Thing *creatng, MapSubtlCoord stl_x, MapSubtlCoord stl_y, CreatureJob new_job, unsigned long flags)
{
if (!creature_can_do_research(creatng))
{
struct Room *room;
room = subtile_room_get(stl_x, stl_y);
struct Dungeon *dungeon;
dungeon = get_dungeon(room->owner);
if (!is_neutral_thing(creatng) && (dungeon->current_research_idx < 0))
{
if (is_my_player_number(dungeon->owner) && ((flags & JobChk_PlayMsgOnFail) != 0)) {
output_message(SMsg_NoMoreReseach, 500, true);
}
}
return false;
}
return true;
}
short good_arrived_at_attack_room(struct Thing *thing)
{
struct Room *room;
room = get_room_thing_is_on(thing);
// If the current tile can be destroyed
if (room_exists(room) && (room->owner != thing->owner) && !room_cannot_vandalise(room->kind))
{
internal_set_thing_state(thing, CrSt_GoodAttackRoom1);
MapCoord ev_coord_x,ev_coord_y;
ev_coord_x = subtile_coord_center(room->central_stl_x);
ev_coord_y = subtile_coord_center(room->central_stl_y);
event_create_event_or_update_nearby_existing_event(ev_coord_x, ev_coord_y, EvKind_RoomUnderAttack, room->owner, 0);
if (is_my_player_number(room->owner))
output_message(SMsg_EnemyDestroyRooms, MESSAGE_DELAY_FIGHT, true);
return 1;
}
set_start_state(thing);
return 0;
}
short at_research_room(struct Thing *thing)
{
struct CreatureControl *cctrl;
struct Dungeon *dungeon;
struct Room *room;
cctrl = creature_control_get_from_thing(thing);
cctrl->target_room_id = 0;
dungeon = get_dungeon(thing->owner);
if (!creature_can_do_research(thing))
{
if (!is_neutral_thing(thing) && (dungeon->current_research_idx < 0))
{
if (is_my_player_number(dungeon->owner))
output_message(SMsg_NoMoreReseach, 500, true);
}
set_start_state(thing);
return 0;
}
room = get_room_thing_is_on(thing);
if (!room_initially_valid_as_type_for_thing(room, RoK_LIBRARY, thing))
{
WARNLOG("Room %s owned by player %d is invalid for %s index %d",room_code_name(room->kind),(int)room->owner,thing_model_name(thing),(int)thing->index);
set_start_state(thing);
return 0;
}
if (!add_creature_to_work_room(thing, room))
{
set_start_state(thing);
return 0;
}
if (!setup_random_head_for_room(thing, room, NavRtF_Default))
{
ERRORLOG("The %s index %d can not move in research room", thing_model_name(thing),(int)thing->index);
remove_creature_from_work_room(thing);
set_start_state(thing);
return 0;
}
thing->continue_state = CrSt_Researching;
cctrl->field_82 = 0;
cctrl->byte_9A = 3;
return 1;
}
short at_training_room(struct Thing *thing)
{
struct CreatureControl *cctrl;
struct CreatureStats *crstat;
struct Dungeon *dungeon;
struct Room *room;
//return _DK_at_training_room(thing);
cctrl = creature_control_get_from_thing(thing);
cctrl->target_room_id = 0;
if (!creature_can_be_trained(thing))
{
SYNCDBG(9,"Ending training of %s level %d; creature is not trainable",thing_model_name(thing),(int)cctrl->explevel);
set_start_state(thing);
return 0;
}
crstat = creature_stats_get_from_thing(thing);
dungeon = get_dungeon(thing->owner);
if (dungeon->total_money_owned < crstat->training_cost)
{
if (is_my_player_number(thing->owner))
output_message(SMsg_NoGoldToTrain, MESSAGE_DELAY_TREASURY, true);
set_start_state(thing);
return 0;
}
room = get_room_thing_is_on(thing);
if (!room_initially_valid_as_type_for_thing(room, RoK_TRAINING, thing))
{
WARNLOG("Room %s owned by player %d is invalid for %s",room_code_name(room->kind),(int)room->owner,thing_model_name(thing));
set_start_state(thing);
return 0;
}
if ( !add_creature_to_work_room(thing, room) )
{
set_start_state(thing);
return 0;
}
internal_set_thing_state(thing, CrSt_Training);
setup_move_to_new_training_position(thing, room, 1);
cctrl->field_82 = 0;
return 1;
}
TbBool tag_cursor_blocks_place_trap(PlayerNumber plyr_idx, MapSubtlCoord stl_x, MapSubtlCoord stl_y)
{
SYNCDBG(7,"Starting");
int floor_height;
TbBool can_place;
MapSlabCoord slb_x, slb_y;
slb_x = subtile_slab_fast(stl_x);
slb_y = subtile_slab_fast(stl_y);
can_place = can_place_trap_on(plyr_idx, stl_x, stl_y);
floor_height = floor_height_for_volume_box(plyr_idx, slb_x, slb_y);
if (is_my_player_number(plyr_idx))
{
if (!game_is_busy_doing_gui() && (game.small_map_state != 2)) {
// Move to first subtile on a slab
stl_x = slab_subtile(slb_x,0);
stl_y = slab_subtile(slb_y,0);
draw_map_volume_box(subtile_coord(stl_x,0), subtile_coord(stl_y,0),
subtile_coord(stl_x+STL_PER_SLB,0), subtile_coord(stl_y+STL_PER_SLB,0), floor_height, can_place);
}
}
return can_place;
}
void resurrect_creature(struct Thing *boxtng, PlayerNumber owner, ThingModel crmodel, unsigned char crlevel)
{
struct Thing *creatng;
if (!thing_exists(boxtng) || (box_thing_to_special(boxtng) != SpcKind_Resurrect) ) {
ERRORMSG("Invalid resurrect box object!");
return;
}
creatng = create_creature(&boxtng->mappos, crmodel, owner);
if (!thing_is_invalid(creatng))
{
init_creature_level(creatng, crlevel);
if (is_my_player_number(owner))
output_message(SMsg_CommonAcknowledge, 0, true);
}
create_special_used_effect(&boxtng->mappos, owner);
remove_events_thing_is_attached_to(boxtng);
force_any_creature_dragging_owned_thing_to_drop_it(boxtng);
if ((gameadd.classic_bugs_flags & ClscBug_ResurrectForever) == 0) {
remove_item_from_dead_creature_list(get_players_num_dungeon(owner), crmodel, crlevel);
}
delete_thing_structure(boxtng, 0);
}
short researching(struct Thing *thing)
{
struct Dungeon *dungeon;
long i;
TRACE_THING(thing);
dungeon = get_dungeon(thing->owner);
if (is_neutral_thing(thing))
{
ERRORLOG("Neutral %s index %d cannot do research",thing_model_name(thing),(int)thing->index);
remove_creature_from_work_room(thing);
set_start_state(thing);
return CrStRet_Unchanged;
}
if (!creature_can_do_research(thing))
{
if (!is_neutral_thing(thing) && (dungeon->current_research_idx < 0))
{
if (is_my_player_number(dungeon->owner))
output_message(SMsg_NoMoreReseach, 500, true);
}
remove_creature_from_work_room(thing);
set_start_state(thing);
return CrStRet_Unchanged;
}
// Get and verify working room
struct Room *room;
room = get_room_thing_is_on(thing);
if (creature_work_in_room_no_longer_possible(room, RoK_LIBRARY, thing))
{
remove_creature_from_work_room(thing);
set_start_state(thing);
return CrStRet_ResetFail;
}
if (room->used_capacity > room->total_capacity)
{
output_message_room_related_from_computer_or_player_action(room->owner, room->kind, OMsg_RoomTooSmall);
remove_creature_from_work_room(thing);
set_start_state(thing);
return CrStRet_ResetOk;
}
process_research_function(thing);
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(thing);
if ( (game.play_gameturn - dungeon->field_AE5 < 50)
&& ((game.play_gameturn + thing->index) & 0x03) == 0)
{
external_set_thing_state(thing, CrSt_CreatureBeHappy);
cctrl->countdown_282 = 50;
cctrl->long_9A = 0;
return CrStRet_Modified;
}
if (cctrl->instance_id != CrInst_NULL)
return 1;
cctrl->field_82++;
// Shall we do some "Standing and thinking"
if (cctrl->field_82 <= 128)
{
if (cctrl->byte_9A == 3)
{
// Do some random thinking
if ((cctrl->field_82 % 16) == 0)
{
i = ACTION_RANDOM(LbFPMath_PI) - LbFPMath_PI/2;
cctrl->long_9B = ((long)thing->move_angle_xy + i) & LbFPMath_AngleMask;
cctrl->byte_9A = 4;
}
} else
{
// Look at different direction while thinking
if (creature_turn_to_face_angle(thing, cctrl->long_9B) < LbFPMath_PI/18)
{
cctrl->byte_9A = 3;
}
}
return 1;
}
// Finished "Standing and thinking" - make "new idea" effect and go to next position
if (!setup_random_head_for_room(thing, room, NavRtF_Default))
{
ERRORLOG("Cannot move %s index %d in %s room", thing_model_name(thing),(int)thing->index,room_code_name(room->kind));
set_start_state(thing);
return 1;
}
thing->continue_state = CrSt_Researching;
cctrl->field_82 = 0;
cctrl->byte_9A = 3;
if (cctrl->explevel < 3)
{
create_effect(&thing->mappos, TngEff_Unknown54, thing->owner);
} else
if (cctrl->explevel < 6)
{
create_effect(&thing->mappos, TngEff_Unknown55, thing->owner);
} else
{
create_effect(&thing->mappos, TngEff_Unknown56, thing->owner);
}
return 1;
}
/** Returns if a creature can do specific job at given map position.
*
* @param creatng The creature which is planned for the job.
* @param stl_x Target map position, x coord.
* @param stl_y Target map position, y coord.
* @param new_job Job selection with single job flag set.
* @return True if the creature can do the job specified, false otherwise.
* @see creature_can_do_job_for_player() similar function for use when only target player is known
*/
TbBool creature_can_do_job_near_position(struct Thing *creatng, MapSubtlCoord stl_x, MapSubtlCoord stl_y, CreatureJob new_job, unsigned long flags)
{
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(creatng);
SYNCDBG(6,"Starting for %s (owner %d) and job %s",thing_model_name(creatng),(int)creatng->owner,creature_job_code_name(new_job));
struct CreatureStats *crstat;
crstat = creature_stats_get_from_thing(creatng);
if (creature_will_reject_job(creatng, new_job))
{
SYNCDBG(3,"Cannot assign %s at (%d,%d) for %s index %d owner %d; in not-do-jobs list",creature_job_code_name(new_job),(int)stl_x,(int)stl_y,thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
if ((flags & JobChk_SetStateOnFail) != 0) {
anger_apply_anger_to_creature(creatng, crstat->annoy_will_not_do_job, AngR_Other, 1);
external_set_thing_state(creatng, CrSt_CreatureMoan);
cctrl->field_282 = 50;
}
return false;
}
// Don't allow creatures changed to chickens to have any job assigned, besides those specifically marked
if (creature_affected_by_spell(creatng, SplK_Chicken) && ((get_flags_for_job(new_job) & JoKF_AllowChickenized) == 0))
{
SYNCDBG(3,"Cannot assign %s at (%d,%d) for %s index %d owner %d; under chicken spell",creature_job_code_name(new_job),(int)stl_x,(int)stl_y,thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
return false;
}
// Check if the job is related to correct map place (room,slab)
if (!is_correct_position_to_perform_job(creatng, stl_x, stl_y, new_job))
{
SYNCDBG(3,"Cannot assign %s at (%d,%d) for %s index %d owner %d; not correct place for job",creature_job_code_name(new_job),(int)stl_x,(int)stl_y,thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
return false;
}
struct CreatureJobConfig *jobcfg;
jobcfg = get_config_for_job(new_job);
if (jobcfg->func_cord_check == NULL)
{
SYNCDBG(3,"Cannot assign %s at (%d,%d) for %s index %d owner %d; job has no coord check function",creature_job_code_name(new_job),(int)stl_x,(int)stl_y,thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
return false;
}
if (!jobcfg->func_cord_check(creatng, stl_x, stl_y, new_job, flags))
{
SYNCDBG(3,"Cannot assign %s at (%d,%d) for %s index %d owner %d; coord check not passed",creature_job_code_name(new_job),(int)stl_x,(int)stl_y,thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
return false;
}
// If other tests pass, check if related room (if is needed) has capacity to be used for that job
if ((get_flags_for_job(new_job) & JoKF_NeedsCapacity) != 0)
{
struct Room *room;
room = subtile_room_get(stl_x, stl_y);
if (!room_has_enough_free_capacity_for_creature(room, creatng))
{
SYNCDBG(3,"Cannot assign %s at (%d,%d) for %s index %d owner %d; not enough room capacity",creature_job_code_name(new_job),(int)stl_x,(int)stl_y,thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
if ((flags & JobChk_PlayMsgOnFail) != 0) {
const struct RoomConfigStats *roomst;
roomst = get_room_kind_stats(room->kind);
if (is_my_player_number(room->owner) && (roomst->msg_too_small > 0)) {
output_message_room_related_from_computer_or_player_action(roomst->msg_too_small);
}
}
return false;
}
}
return true;
}
/** Returns if a creature can do specific job for the player.
*
* @param creatng The creature which is planned for the job.
* @param plyr_idx Player for whom the job is to be done.
* @param new_job Job selection with single job flag set.
* @param flags Function behavior adjustment flags.
* @return True if the creature can do the job specified, false otherwise.
* @note this should be used instead of person_will_do_job_for_room()
* @note this function will never change state of the input thing, even if appropriate flags are set
* @see creature_can_do_job_near_position() similar function for use when target position is known
*/
TbBool creature_can_do_job_for_player(const struct Thing *creatng, PlayerNumber plyr_idx, CreatureJob new_job, unsigned long flags)
{
SYNCDBG(16,"Starting for %s (owner %d) and job %s",thing_model_name(creatng),(int)creatng->owner,creature_job_code_name(new_job));
if (creature_will_reject_job(creatng, new_job))
{
SYNCDBG(13,"Cannot assign %s for %s index %d owner %d; in not do jobs list",creature_job_code_name(new_job),thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
return false;
}
if (!is_correct_owner_to_perform_job(creatng, plyr_idx, new_job))
{
SYNCDBG(13,"Cannot assign %s for %s index %d owner %d; not correct owner for job",creature_job_code_name(new_job),thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
return false;
}
// Don't allow creatures changed to chickens to have any job assigned, besides those specifically marked
if (creature_affected_by_spell(creatng, SplK_Chicken) && ((get_flags_for_job(new_job) & JoKF_AllowChickenized) == 0))
{
SYNCDBG(13,"Cannot assign %s for %s index %d owner %d; under chicken spell",creature_job_code_name(new_job),thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
return false;
}
// Check if the job is related to correct player
struct CreatureJobConfig *jobcfg;
jobcfg = get_config_for_job(new_job);
if (jobcfg->func_plyr_check == NULL)
{
return false;
}
if (!jobcfg->func_plyr_check(creatng, plyr_idx, new_job))
{
return false;
}
RoomKind job_rkind;
job_rkind = get_room_for_job(new_job);
if (job_rkind != RoK_NONE)
{
if (!player_has_room(plyr_idx, job_rkind))
{
SYNCDBG(3,"Cannot assign %s in player %d room for %s index %d owner %d; no required room built",creature_job_code_name(new_job),(int)plyr_idx,thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
if ((flags & JobChk_PlayMsgOnFail) != 0) {
const struct RoomConfigStats *roomst;
roomst = get_room_kind_stats(get_room_for_job(new_job));
if (is_my_player_number(plyr_idx) && (roomst->msg_needed > 0)) {
output_message_room_related_from_computer_or_player_action(roomst->msg_needed);
}
}
return false;
}
if ((get_flags_for_job(new_job) & JoKF_NeedsCapacity) != 0)
{
struct Room *room;
room = find_room_with_spare_capacity(plyr_idx, job_rkind, 1);
if (room_is_invalid(room))
{
SYNCDBG(3,"Cannot assign %s in player %d room for %s index %d owner %d; not enough room capacity",creature_job_code_name(new_job),(int)plyr_idx,thing_model_name(creatng),(int)creatng->index,(int)creatng->owner);
if ((flags & JobChk_PlayMsgOnFail) != 0) {
const struct RoomConfigStats *roomst;
roomst = get_room_kind_stats(get_room_for_job(new_job));
if (is_my_player_number(plyr_idx) && (roomst->msg_too_small > 0)) {
output_message_room_related_from_computer_or_player_action(roomst->msg_too_small);
}
}
return false;
}
}
}
return true;
}
short process_player_manufacturing(PlayerNumber plyr_idx)
{
struct Dungeon *dungeon;
struct Room *room;
int k;
SYNCDBG(7,"Starting for player %d",(int)plyr_idx);
dungeon = get_players_num_dungeon(plyr_idx);
if (!player_has_room_of_role(plyr_idx, RoRoF_CratesManufctr))
{
return true;
}
if (dungeon->manufacture_class == TCls_Empty)
{
get_next_manufacture(dungeon);
return true;
}
k = manufacture_points_required(dungeon->manufacture_class, dungeon->manufacture_kind);
// If we don't have enough manufacture points, don't do anything
if (dungeon->manufacture_progress < (k << 8))
return true;
// Try to do the manufacturing
room = find_room_with_spare_room_item_capacity(plyr_idx, RoK_WORKSHOP);
if (room_is_invalid(room))
{
dungeon->manufacture_class = TCls_Empty;
return false;
}
if (check_workshop_item_limit_reached(plyr_idx, dungeon->manufacture_class, dungeon->manufacture_kind))
{
ERRORLOG("Bad choice for manufacturing - limit reached for %s kind %d",thing_class_code_name(dungeon->manufacture_class),(int)dungeon->manufacture_kind);
get_next_manufacture(dungeon);
return false;
}
if (create_workshop_object_in_workshop_room(plyr_idx, dungeon->manufacture_class, dungeon->manufacture_kind) == 0)
{
ERRORLOG("Could not create manufactured %s kind %d",thing_class_code_name(dungeon->manufacture_class),(int)dungeon->manufacture_kind);
return false;
}
add_workshop_item_to_amounts(plyr_idx, dungeon->manufacture_class, dungeon->manufacture_kind);
switch (dungeon->manufacture_class)
{
case TCls_Trap:
dungeon->lvstats.manufactured_traps++;
// If that's local player - make a message
if (is_my_player_number(plyr_idx))
output_message(SMsg_ManufacturedTrap, 0, true);
break;
case TCls_Door:
dungeon->lvstats.manufactured_doors++;
// If that's local player - make a message
if (is_my_player_number(plyr_idx))
output_message(SMsg_ManufacturedDoor, 0, true);
break;
default:
ERRORLOG("Invalid type of new manufacture, %d",(int)dungeon->manufacture_class);
return false;
}
dungeon->manufacture_progress -= (k << 8);
dungeon->field_118B = game.play_gameturn;
dungeon->lvstats.manufactured_items++;
get_next_manufacture(dungeon);
return true;
}
long instf_dig(struct Thing *creatng, long *param)
{
struct CreatureControl *cctrl;
struct Dungeon *dungeon;
struct SlabMap *slb;
long stl_x,stl_y;
long task_idx,taskkind;
long dig_damage,gold;
SYNCDBG(16,"Starting");
TRACE_THING(creatng);
//return _DK_instf_dig(thing, param);
cctrl = creature_control_get_from_thing(creatng);
dungeon = get_dungeon(creatng->owner);
task_idx = cctrl->word_91;
{
struct MapTask *task;
task = get_dungeon_task_list_entry(dungeon,task_idx);
taskkind = task->kind;
if (task->coords != cctrl->word_8F) {
return 0;
}
stl_x = stl_num_decode_x(cctrl->word_8F);
stl_y = stl_num_decode_y(cctrl->word_8F);
}
slb = get_slabmap_for_subtile(stl_x, stl_y);
if (slabmap_block_invalid(slb)) {
return 0;
}
dig_damage = calculate_damage_did_to_slab_with_single_hit(creatng, slb);
if (slb->health > dig_damage)
{
if (!slab_kind_is_indestructible(slb->kind))
slb->health -= dig_damage;
thing_play_sample(creatng, 63 + UNSYNC_RANDOM(6), NORMAL_PITCH, 0, 3, 0, 2, FULL_LOUDNESS);
create_effect(&creatng->mappos, TngEff_Unknown25, creatng->owner);
if (taskkind == SDDigTask_MineGold)
{
gold = calculate_gold_digged_out_of_slab_with_single_hit(dig_damage, creatng->owner, cctrl->explevel, slb);
creatng->creature.gold_carried += gold;
dungeon->lvstats.gold_mined += gold;
}
return 0;
}
// slb->health <= dig_damage - we're going to destroy the slab
remove_from_task_list(creatng->owner, task_idx);
if (taskkind == SDDigTask_MineGold)
{
gold = calculate_gold_digged_out_of_slab_with_single_hit(slb->health, creatng->owner, cctrl->explevel, slb);
creatng->creature.gold_carried += gold;
dungeon->lvstats.gold_mined += gold;
mine_out_block(stl_x, stl_y, creatng->owner);
if (dig_has_revealed_area(stl_x, stl_y, creatng->owner))
{
EventIndex evidx;
evidx = event_create_event_or_update_nearby_existing_event(
subtile_coord_center(stl_x), subtile_coord_center(stl_y),
EvKind_AreaDiscovered, creatng->owner, 0);
if ((evidx > 0) && is_my_player_number(creatng->owner))
output_message(SMsg_DugIntoNewArea, 0, true);
}
} else
if (taskkind == SDDigTask_DigEarth)
{
dig_out_block(stl_x, stl_y, creatng->owner);
if (dig_has_revealed_area(stl_x, stl_y, creatng->owner))
{
EventIndex evidx;
evidx = event_create_event_or_update_nearby_existing_event(
subtile_coord_center(stl_x), subtile_coord_center(stl_y),
EvKind_AreaDiscovered, creatng->owner, 0);
if ((evidx > 0) && is_my_player_number(creatng->owner))
output_message(SMsg_DugIntoNewArea, 0, true);
}
}
check_map_explored(creatng, stl_x, stl_y);
thing_play_sample(creatng, 72 + UNSYNC_RANDOM(3), NORMAL_PITCH, 0, 3, 0, 4, FULL_LOUDNESS);
return 1;
}
CrStateRet training(struct Thing *thing)
{
struct CreatureControl *cctrl;
TRACE_THING(thing);
SYNCDBG(18,"Starting");
//return _DK_training(thing);
cctrl = creature_control_get_from_thing(thing);
// Check if we should finish training
if (!creature_can_be_trained(thing))
{
SYNCDBG(9,"Ending training of %s level %d; creature is not trainable",thing_model_name(thing),(int)cctrl->explevel);
remove_creature_from_work_room(thing);
set_start_state(thing);
return CrStRet_ResetOk;
}
if (!player_can_afford_to_train_creature(thing))
{
SYNCDBG(19,"Ending training %s index %d; cannot afford",thing_model_name(thing),(int)thing->index);
if (is_my_player_number(thing->owner))
output_message(SMsg_NoGoldToTrain, MESSAGE_DELAY_TREASURY, true);
remove_creature_from_work_room(thing);
set_start_state(thing);
return CrStRet_ResetFail;
}
// Check if we're in correct room
struct Room *room;
room = get_room_thing_is_on(thing);
if (creature_work_in_room_no_longer_possible(room, RoK_TRAINING, thing))
{
remove_creature_from_work_room(thing);
set_start_state(thing);
return CrStRet_ResetFail;
}
struct Dungeon *dungeon;
struct CreatureStats *crstat;
dungeon = get_dungeon(thing->owner);
crstat = creature_stats_get_from_thing(thing);
// Pay for the training
cctrl->field_82++;
if (cctrl->field_82 >= game.train_cost_frequency)
{
cctrl->field_82 -= game.train_cost_frequency;
if (take_money_from_dungeon(thing->owner, crstat->training_cost, 1) < 0) {
ERRORLOG("Cannot take %d gold from dungeon %d",(int)crstat->training_cost,(int)thing->owner);
}
create_price_effect(&thing->mappos, thing->owner, crstat->training_cost);
}
if ((cctrl->instance_id != CrInst_NULL) || !check_experience_upgrade(thing))
{
long work_value;
// Training speed does not grow with experience - otherwise it would be too fast
work_value = compute_creature_work_value(crstat->training_value*256, room->efficiency, 0);
work_value = process_work_speed_on_work_value(thing, work_value);
SYNCDBG(19,"The %s index %d produced %d training points",thing_model_name(thing),(int)thing->index,(int)work_value);
cctrl->exp_points += work_value;
dungeon->total_experience_creatures_gained += work_value;
process_creature_in_training_room(thing, room);
} else
{
if (external_set_thing_state(thing, CrSt_CreatureBeHappy)) {
cctrl->field_282 = 50;
}
dungeon->lvstats.creatures_trained++;
}
return CrStRet_Modified;
}
TbBool process_scavenge_creature_from_level(struct Thing *scavtng, struct Thing *calltng, long work_value)
{
struct Dungeon *calldngn;
long num_prayers;
calldngn = get_dungeon(calltng->owner);
if (dungeon_invalid(calldngn)) {
ERRORLOG("The %s owner %d can't do scavenging - has no dungeon",thing_model_name(calltng),(int)calltng->owner);
return false;
}
// Compute amount of creatures praying against the scavenge
if (!is_neutral_thing(scavtng)) {
struct Dungeon *scavdngn;
scavdngn = get_dungeon(scavtng->owner);
num_prayers = scavdngn->creatures_praying[scavtng->model];
} else {
num_prayers = 0;
}
// Increase scavenging counter, used to break the prayers counter
calldngn->creatures_scavenging[scavtng->model]++;
// If scavenge is blocked by prayers, return
if (calldngn->creatures_scavenging[calltng->model] < 2 * num_prayers) {
SYNCDBG(8, "Player %d prayers (%d) are blocking player %d scavenging (%d) of %s", (int)scavtng->owner,
(int)num_prayers, (int)calltng->owner, (int)calldngn->creatures_scavenging[calltng->model], thing_model_name(calltng));
return false;
}
SYNCDBG(18,"The %s index %d scavenges %s index %d",thing_model_name(calltng),(int)calltng->index,thing_model_name(scavtng),(int)scavtng->index);
// If we're starting to scavenge a new creature, do the switch
if (calldngn->scavenge_targets[calltng->model] != scavtng->index)
{
calldngn->scavenge_turn_points[calltng->model] = work_value;
if (calldngn->scavenge_targets[calltng->model] > 0)
{
// Stop scavenging old creature
struct Thing *thing;
thing = thing_get(calldngn->scavenge_targets[calltng->model]);
if (thing_is_creature(thing) && (thing->model == calltng->model))
{
if (creature_is_being_scavenged(thing)) {
set_start_state(thing);
}
}
}
// Start the new scavenging
calldngn->scavenge_targets[calltng->model] = scavtng->index;
if (is_my_player_number(scavtng->owner)) {
output_message(SMsg_CreatureScanvenged, 500, 1);
}
event_create_event(scavtng->mappos.x.val, scavtng->mappos.y.val, EvKind_CreatrScavenged, scavtng->owner, scavtng->index);
} else
{
calldngn->scavenge_turn_points[calltng->model] += work_value;
}
// Make sure the scavenged creature is in correct state
if (!creature_is_being_scavenged(scavtng))
{
if (!is_neutral_thing(scavtng)) {
external_set_thing_state(scavtng, CrSt_CreatureBeingScavenged);
}
}
long scavpts;
scavpts = calculate_correct_creature_scavenge_required(scavtng, calltng->owner);
if ((scavpts << 8) < calldngn->scavenge_turn_points[calltng->model])
{
SYNCDBG(8,"The %s index %d owner %d accumulated enough points to turn to scavenger",thing_model_name(scavtng),(int)scavtng->index,(int)scavtng->owner);
turn_creature_to_scavenger(scavtng, calltng);
calldngn->scavenge_turn_points[calltng->model] -= (scavpts << 8);
return true;
}
return false;
}
