TbBool good_setup_loot_research_room(struct Thing *thing, long dngn_id)
{
struct CreatureControl *cctrl;
struct Room *room;
room = find_random_room_creature_can_navigate_to(thing, dngn_id, RoK_LIBRARY, NavRtF_Default);
if (room_is_invalid(room))
{
SYNCDBG(6,"No accessible player %d library found",(int)dngn_id);
return false;
}
struct Coord3d pos;
if (!find_random_valid_position_for_thing_in_room(thing, room, &pos))
{
SYNCDBG(6,"No position for %s index %d in %s owned by player %d",
thing_model_name(thing),(int)thing->index,room_code_name(room->kind),(int)room->owner);
return false;
}
if (!setup_person_move_to_coord(thing, &pos, NavRtF_Default))
{
SYNCDBG(6,"Cannot setup move %s index %d to %s owned by player %d",
thing_model_name(thing),(int)thing->index,room_code_name(room->kind),(int)room->owner);
return false;
}
cctrl = creature_control_get_from_thing(thing);
thing->continue_state = CrSt_CreatureSearchForSpellToStealInRoom;
cctrl->target_room_id = room->index;
return true;
}
TbBool can_build_room_at_slab(PlayerNumber plyr_idx, RoomKind rkind,
MapSlabCoord slb_x, MapSlabCoord slb_y)
{
if (!subtile_revealed(slab_subtile_center(slb_x), slab_subtile_center(slb_y), plyr_idx)) {
SYNCDBG(7,"Cannot place %s owner %d as slab (%d,%d) is not revealed",room_code_name(rkind),(int)plyr_idx,(int)slb_x,(int)slb_y);
return false;
}
struct SlabMap *slb;
slb = get_slabmap_block(slb_x, slb_y);
if (slb->room_index > 0) {
SYNCDBG(7,"Cannot place %s owner %d as slab (%d,%d) has room index %d",room_code_name(rkind),(int)plyr_idx,(int)slb_x,(int)slb_y,(int)slb->room_index);
return false;
}
if (slab_has_trap_on(slb_x, slb_y) || slab_has_door_thing_on(slb_x, slb_y)) {
SYNCDBG(7,"Cannot place %s owner %d as slab (%d,%d) has blocking thing on it",room_code_name(rkind),(int)plyr_idx,(int)slb_x,(int)slb_y);
return false;
}
if (rkind == RoK_BRIDGE) {
return slab_kind_is_liquid(slb->kind) && slab_by_players_land(plyr_idx, slb_x, slb_y);
}
if (slabmap_owner(slb) != plyr_idx) {
return false;
}
return (slb->kind == SlbT_CLAIMED);
}
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;
}
}
short at_workshop_room(struct Thing *thing)
{
struct CreatureControl *cctrl;
struct Room *room;
//return _DK_at_workshop_room(thing);
cctrl = creature_control_get_from_thing(thing);
cctrl->target_room_id = 0;
room = get_room_thing_is_on(thing);
if (!room_initially_valid_as_type_for_thing(room, RoK_WORKSHOP, 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 (room->total_capacity <= room->used_capacity)
{
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_Manufacturing);
setup_move_to_new_workshop_position(thing, room, 1);
return 1;
}
CrStateRet creature_at_changed_lair(struct Thing *creatng)
{
struct Room *room;
TRACE_THING(creatng);
//return _DK_creature_at_changed_lair(thing);
if (!thing_is_on_own_room_tile(creatng))
{
set_start_state(creatng);
return CrStRet_ResetFail;
}
room = get_room_thing_is_on(creatng);
if (!room_initially_valid_as_type_for_thing(room, RoK_LAIR, creatng))
{
WARNLOG("Room %s owned by player %d is invalid for %s",room_code_name(room->kind),(int)room->owner,thing_model_name(creatng));
set_start_state(creatng);
return CrStRet_ResetFail;
}
if (!creature_add_lair_to_room(creatng, room)) {
internal_set_thing_state(creatng, CrSt_CreatureChooseRoomForLairSite);
return CrStRet_Modified;
}
// All done - finish the state
set_start_state(creatng);
return CrStRet_ResetOk;
}
struct Thing *create_crate_in_workshop(struct Room *room, ThingModel cratngmodel, MapSubtlCoord stl_x, MapSubtlCoord stl_y)
{
struct Coord3d pos;
struct Thing *cratetng;
if (!room_role_matches(room->kind, RoRoF_CratesStorage)) {
SYNCDBG(4,"Crate %s cannot be created in a %s owned by player %d, wrong room",object_code_name(cratngmodel),room_code_name(room->kind),(int)room->owner);
return INVALID_THING;
}
pos.x.val = subtile_coord_center(stl_x);
pos.y.val = subtile_coord_center(stl_y);
pos.z.val = 0;
cratetng = create_object(&pos, cratngmodel, room->owner, -1);
if (thing_is_invalid(cratetng))
{
return INVALID_THING;
}
// Neutral thing do not need any more processing
if (is_neutral_thing(cratetng) || !player_exists(get_player(room->owner))) {
return cratetng;
}
if (!add_workshop_object_to_workshop(room, cratetng)) {
ERRORLOG("Could not fit %s in %s index %d",
thing_model_name(cratetng),room_code_name(room->kind),(int)room->index);
//remove_item_from_room_capacity(room); -- no need, it was not added
destroy_object(cratetng);
return INVALID_THING;
}
ThingClass tngclass;
ThingModel tngmodel;
tngclass = crate_thing_to_workshop_item_class(cratetng);
tngmodel = crate_thing_to_workshop_item_model(cratetng);
add_workshop_item_to_amounts(cratetng->owner, tngclass, tngmodel);
return cratetng;
}
long instf_attack_room_slab(struct Thing *creatng, long *param)
{
TRACE_THING(creatng);
//return _DK_instf_attack_room_slab(creatng, param);
struct Room *room;
room = get_room_thing_is_on(creatng);
if (room_is_invalid(room))
{
ERRORLOG("The %s is not on room",thing_model_name(creatng));
return 0;
}
struct SlabMap *slb;
slb = get_slabmap_thing_is_on(creatng);
if (slb->health > 2)
{
//TODO CONFIG damage made to room slabs is constant - doesn't look good
slb->health -= 2;
thing_play_sample(creatng, 128 + UNSYNC_RANDOM(3), NORMAL_PITCH, 0, 3, 0, 2, FULL_LOUDNESS);
return 1;
}
if (room->owner != game.neutral_player_num)
{
struct Dungeon *dungeon;
dungeon = get_dungeon(room->owner);
dungeon->rooms_destroyed++;
}
if (!delete_room_slab(coord_slab(creatng->mappos.x.val), coord_slab(creatng->mappos.y.val), 1))
{
ERRORLOG("Cannot delete %s room tile destroyed by %s",room_code_name(room->kind),thing_model_name(creatng));
return 0;
}
create_effect(&creatng->mappos, 3, creatng->owner);
thing_play_sample(creatng, 47, NORMAL_PITCH, 0, 3, 0, 2, FULL_LOUDNESS);
return 1;
}
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 Room * find_nearest_navigable_room_for_thing_with_capacity_and_closer_than(struct Thing *thing, PlayerNumber owner, RoomKind rkind, unsigned char nav_flags, long used, long *neardistance)
{
struct Dungeon *dungeon;
struct Room *nearoom;
long distance;
int i;
SYNCDBG(18,"Searching for %s navigable by %s index %d",room_code_name(rkind),thing_model_name(thing),(int)thing->index);
dungeon = get_dungeon(owner);
nearoom = INVALID_ROOM;
distance = *neardistance;
i = dungeon->room_kind[rkind];
while (i != 0)
{
struct Room *room;
room = find_next_navigable_room_for_thing_with_capacity_and_closer_than(thing, i, nav_flags, used, &distance);
if (room_is_invalid(room)) {
break;
}
// Found closer room
i = room->next_of_owner;
nearoom = room;
}
*neardistance = distance;
return nearoom;
}
short at_guard_post_room(struct Thing *thing)
{
struct CreatureControl *cctrl;
struct Room *room;
cctrl = creature_control_get_from_thing(thing);
cctrl->target_room_id = 0;
room = get_room_thing_is_on(thing);
if (!room_initially_valid_as_type_for_thing(room, get_room_for_job(Job_GUARD), 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, Job_GUARD))
{
set_start_state(thing);
return 0;
}
internal_set_thing_state(thing, get_continue_state_for_job(Job_GUARD));
if (!person_get_somewhere_adjacent_in_room(thing, room, &cctrl->moveto_pos))
{
cctrl->moveto_pos.x.val = thing->mappos.x.val;
cctrl->moveto_pos.y.val = thing->mappos.y.val;
cctrl->moveto_pos.z.val = thing->mappos.z.val;
}
return 1;
}
void setup_workshop_search_for_post(struct Thing *creatng)
{
struct Room *room;
struct Thing *postng;
postng = INVALID_THING;
room = get_room_thing_is_on(creatng);
// Find a random slab in the room to be used as our starting point
long i;
unsigned long n;
i = ACTION_RANDOM(room->slabs_count);
n = room->slabs_list;
while (i > 0)
{
n = get_next_slab_number_in_room(n);
i--;
}
i = room->slabs_count;
while (i > 0)
{
// Loop the slabs list
if (n <= 0) {
n = room->slabs_list;
}
MapSlabCoord slb_x, slb_y;
slb_x = subtile_slab_fast(stl_num_decode_x(n));
slb_y = subtile_slab_fast(stl_num_decode_y(n));
struct Thing *objtng;
objtng = get_workshop_equipment_to_work_with_on_subtile(creatng->owner, slab_subtile_center(slb_x), slab_subtile_center(slb_y));
if (!thing_is_invalid(objtng)) {
postng = objtng;
}
n = get_next_slab_number_in_room(n);
i--;
}
if (thing_is_invalid(postng))
{
SYNCDBG(9,"Work in %s, the %s moves to new pos",room_code_name(room->kind),thing_model_name(creatng));
setup_move_to_new_workshop_position(creatng, room, 1);
} else
{
SYNCDBG(9,"Work in %s, the %s found a post",room_code_name(room->kind),thing_model_name(creatng));
setup_workshop_move(creatng, get_subtile_number(postng->mappos.x.stl.num, postng->mappos.y.stl.num));
}
}
/**
* Returns any room of given kind and owner to which the thing can navigate.
*
* @param thing The thing to navigate into room.
* @param owner Owner of the rooms to be checked.
* @param rkind Room kind to be returned.
* @param nav_flags Navigation flags, for checking if creature can reach the room.
* @return Nearest room of given kind and owner, or invalid room if none found.
*/
struct Room *find_any_navigable_room_for_thing_closer_than(struct Thing *thing, PlayerNumber owner, RoomKind rkind, unsigned char nav_flags, long max_distance)
{
struct Dungeon *dungeon;
dungeon = get_dungeon(owner);
SYNCDBG(18,"Searching for %s navigable by %s index %d",room_code_name(rkind),thing_model_name(thing),(int)thing->index);
long neardistance;
struct Room *nearoom;
neardistance = max_distance;
nearoom = INVALID_ROOM;
nearoom = find_next_navigable_room_for_thing_with_capacity_and_closer_than(thing, dungeon->room_kind[rkind], nav_flags, 0, &neardistance);
return nearoom;
}
long computer_check_move_creatures_to_room(struct Computer2 *comp, struct ComputerCheck * check)
{
struct Dungeon *dungeon;
struct Room *room;
dungeon = comp->dungeon;
SYNCDBG(8,"Checking player %d for move to %s", (int)dungeon->owner, room_code_name(check->param2));
int num_to_move;
num_to_move = check->param1 * dungeon->num_active_creatrs / 100;
if (num_to_move <= 0) {
SYNCDBG(8,"No creatures to move, active %d percentage %d", (int)dungeon->num_active_creatrs, (int)check->param1);
return CTaskRet_Unk4;
}
if (computer_able_to_use_magic(comp, PwrK_HAND, 1, num_to_move) != 1) {
return CTaskRet_Unk4;
}
// If there's already task in progress which uses hand, then don't add more
// content of the hand could be used by wrong task by mistake
if (is_task_in_progress_using_hand(comp)) {
return CTaskRet_Unk4;
}
unsigned long k;
long i;
k = 0;
i = dungeon->room_kind[check->param2];
while (i != 0)
{
room = room_get(i);
if (room_is_invalid(room))
{
ERRORLOG("Jump to invalid room detected");
break;
}
i = room->next_of_owner;
// Per-room code
if (room->total_capacity > room->used_capacity)
{
int num_to_move_fit;
num_to_move_fit = min(num_to_move, room->total_capacity - room->used_capacity);
if (create_task_move_creatures_to_room(comp, room->index, num_to_move_fit)) {
SYNCDBG(8,"Added task to move %d creatures to %s index %d", (int)num_to_move_fit,room_code_name(room->kind),(int)room->index);
return CTaskRet_Unk1;
}
}
// Per-room code ends
k++;
if (k > ROOMS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping rooms list");
break;
}
}
return CTaskRet_Unk4;
}
long computer_check_move_creatures_to_room(struct Computer2 *comp, struct ComputerCheck * check)
{
struct Dungeon *dungeon;
struct Room *room;
dungeon = comp->dungeon;
SYNCDBG(8,"Checking player %d for move to %s", (int)dungeon->owner, room_code_name(check->param2));
//return _DK_computer_check_move_creatures_to_room(comp, check);
//TODO check if should be changed to computer_able_to_use_magic()
if (!is_power_available(dungeon->owner, PwrK_HAND)) {
return 4;
}
int num_to_move;
num_to_move = check->param1 * dungeon->num_active_creatrs / 100;
if (num_to_move <= 0) {
SYNCDBG(8,"No creatures to move, active %d percentage %d", (int)dungeon->num_active_creatrs, (int)check->param1);
return 4;
}
if (is_task_in_progress(comp, CTT_MoveCreatureToRoom)) {
return 4;
}
unsigned long k;
long i;
k = 0;
i = dungeon->room_kind[check->param2];
while (i != 0)
{
room = room_get(i);
if (room_is_invalid(room))
{
ERRORLOG("Jump to invalid room detected");
break;
}
i = room->next_of_owner;
// Per-room code
if (room->total_capacity > room->used_capacity)
{
if (create_task_move_creatures_to_room(comp, room->index, num_to_move)) {
SYNCDBG(8,"Added task to move %d creatures to %s index %d", (int)num_to_move,room_code_name(room->kind),(int)room->index);
return 1;
}
}
// Per-room code ends
k++;
if (k > ROOMS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping rooms list");
break;
}
}
return 4;
}
struct Room * find_nearest_navigable_room_for_thing_with_capacity_and_closer_than(struct Thing *thing, PlayerNumber owner, RoomKind rkind, unsigned char nav_flags, long used, long *neardistance)
{
struct Dungeon *dungeon;
struct Room *nearoom;
long distance;
struct Coord3d pos;
struct Room *room;
unsigned long k;
int i;
SYNCDBG(18,"Searching for %s navigable by %s index %d",room_code_name(rkind),thing_model_name(thing),(int)thing->index);
dungeon = get_dungeon(owner);
nearoom = INVALID_ROOM;
k = 0;
i = dungeon->room_kind[rkind];
while (i != 0)
{
room = room_get(i);
if (room_is_invalid(room))
{
ERRORLOG("Jump to invalid room detected");
break;
}
i = room->next_of_owner;
// Per-room code
// Compute simplified distance - without use of mul or div
distance = abs(thing->mappos.x.stl.num - (int)room->central_stl_x)
+ abs(thing->mappos.y.stl.num - (int)room->central_stl_y);
if ((*neardistance > distance) && (room->used_capacity >= used))
{
if (find_first_valid_position_for_thing_anywhere_in_room(thing, room, &pos))
{
if ((thing->class_id != TCls_Creature)
|| creature_can_navigate_to(thing, &pos, nav_flags))
{
*neardistance = distance;
nearoom = room;
}
}
}
// Per-room code ends
k++;
if (k > ROOMS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping rooms list");
break;
}
}
return nearoom;
}
void find_nearest_rooms_for_ambient_sound(void)
{
struct PlayerInfo *player;
struct Room *room;
struct MapOffset *sstep;
struct Coord3d pos;
long slb_x,slb_y;
MapSubtlCoord stl_x,stl_y;
long i,k;
SYNCDBG(8,"Starting");
if ((SoundDisabled) || (GetCurrentSoundMasterVolume() <= 0))
return;
player = get_my_player();
struct Camera *cam;
cam = player->acamera;
if (cam == NULL)
{
ERRORLOG("No active camera");
set_room_playing_ambient_sound(NULL, 0);
return;
}
slb_x = subtile_slab(cam->mappos.x.stl.num);
slb_y = subtile_slab(cam->mappos.y.stl.num);
for (i = 0; i < 11*11; i++)
{
sstep = &spiral_step[i];
stl_x = slab_subtile_center(slb_x + sstep->h);
stl_y = slab_subtile_center(slb_y + sstep->v);
if (subtile_is_player_room(player->id_number,stl_x,stl_y))
{
room = subtile_room_get(stl_x, stl_y);
if (room_is_invalid(room))
continue;
struct RoomConfigStats *roomst;
roomst = &slab_conf.room_cfgstats[room->kind];
k = roomst->ambient_snd_smp_id;
if (k > 0)
{
SYNCDBG(8,"Playing ambient for %s at (%d,%d)",room_code_name(room->kind),(int)stl_x,(int)stl_y);
pos.x.val = subtile_coord_center(stl_x);
pos.y.val = subtile_coord_center(stl_y);
pos.z.val = subtile_coord(1,0);
set_room_playing_ambient_sound(&pos, k);
return;
}
}
}
set_room_playing_ambient_sound(NULL, 0);
}
TbBool setup_move_to_new_workshop_position(struct Thing *thing, struct Room *room, unsigned long a3)
{
struct CreatureControl *cctrl;
SubtlCodedCoords stl_num;
cctrl = creature_control_get_from_thing(thing);
if ( a3 )
cctrl->byte_9E = 50;
cctrl->byte_9A = 1;
stl_num = find_position_around_in_room(&thing->mappos, thing->owner, room->kind);
if (stl_num <= 0)
{
WARNLOG("Could not find position around in %s of %d slabs",room_code_name(room->kind),(int)room->slabs_count);
return false;
}
return setup_workshop_move(thing,stl_num);
}
long computer_check_for_expand_room_kind(struct Computer2 *comp, struct ComputerCheck * check, RoomKind rkind, long max_slabs, long around_start)
{
struct Dungeon *dungeon;
dungeon = comp->dungeon;
{
struct RoomStats *rstat;
rstat = room_stats_get_for_kind(rkind);
// If we don't have money for the room - don't even try
// Check price for two slabs - after all, we don't want to end up having nothing
if (2*rstat->cost >= dungeon->total_money_owned) {
return 0;
}
}
MapSubtlCoord max_radius;
// Don't allow the room to be made into long, narrow shape
max_radius = 3 * slab_subtile(LbSqrL(max_slabs),2) / 4;
struct Room *room;
long i;
unsigned long k;
i = dungeon->room_kind[rkind];
k = 0;
while (i != 0)
{
room = room_get(i);
if (room_is_invalid(room))
{
ERRORLOG("Jump to invalid room detected");
break;
}
i = room->next_of_owner;
// Per-room code
if ((room->slabs_count > 0) && (room->slabs_count < max_slabs)) {
if (computer_check_for_expand_specific_room(comp, check, room, max_radius, around_start)) {
SYNCDBG(6,"The %s index %d will be expanded",room_code_name(room->kind),(int)room->index);
return 1;
}
}
// Per-room code ends
k++;
if (k > ROOMS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping rooms list");
break;
}
}
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_lair_to_sleep(struct Thing *thing)
{
struct CreatureControl *cctrl;
struct Thing *lairtng;
struct Room *room;
TRACE_THING(thing);
//return _DK_at_lair_to_sleep(thing);
cctrl = creature_control_get_from_thing(thing);
lairtng = thing_get(cctrl->lairtng_idx);
TRACE_THING(lairtng);
cctrl->target_room_id = 0;
if (thing_is_invalid(lairtng) || (cctrl->slap_turns != 0))
{
set_start_state(thing);
return 0;
}
if (!creature_will_sleep(thing))
{
set_start_state(thing);
return 0;
}
room = get_room_thing_is_on(thing);
if (!room_initially_valid_as_type_for_thing(room, RoK_LAIR, 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 ((cctrl->lair_room_id != room->index))
{
set_start_state(thing);
return 0;
}
if ( !creature_turn_to_face_angle(thing, lairtng->field_52) )
{
internal_set_thing_state(thing, CrSt_CreatureSleep);
cctrl->field_82 = 200;
thing->movement_flags &= ~TMvF_Flying;
}
process_lair_enemy(thing, room);
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;
}
short at_barrack_room(struct Thing *creatng)
{
struct Room *room;
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(creatng);
cctrl->target_room_id = 0;
room = get_room_thing_is_on(creatng);
if (!room_initially_valid_as_type_for_thing(room, RoK_BARRACKS, creatng))
{
WARNLOG("Room %s owned by player %d is invalid for %s index %d",room_code_name(room->kind),(int)room->owner,thing_model_name(creatng),(int)creatng->index);
set_start_state(creatng);
return 0;
}
if (!add_creature_to_work_room(creatng, room))
{
set_start_state(creatng);
return 0;
}
internal_set_thing_state(creatng, CrSt_Barracking);
return 1;
}
short creature_arrived_at_prison(struct Thing *creatng)
{
struct CreatureControl *cctrl;
struct Room *room;
TRACE_THING(creatng);
cctrl = creature_control_get_from_thing(creatng);
cctrl->target_room_id = 0;
room = get_room_thing_is_on(creatng);
if (!room_initially_valid_as_type_for_thing(room, RoK_PRISON, creatng))
{
WARNLOG("Room %s owned by player %d is invalid for %s index %d",room_code_name(room->kind),(int)room->owner,thing_model_name(creatng),(int)creatng->index);
set_start_state(creatng);
return 0;
}
if (!add_creature_to_work_room(creatng, room))
{
output_message_room_related_from_computer_or_player_action(room->owner, room->kind, OMsg_RoomTooSmall);
cctrl->flgfield_1 &= ~CCFlg_NoCompControl;
set_start_state(creatng);
return 0;
}
cctrl->field_82 = game.play_gameturn;
cctrl->flgfield_1 |= CCFlg_NoCompControl;
internal_set_thing_state(creatng, CrSt_CreatureInPrison);
if (creature_affected_by_spell(creatng, SplK_Speed)) {
terminate_thing_spell_effect(creatng, SplK_Speed);
}
if (creature_affected_by_spell(creatng, SplK_Invisibility)) {
terminate_thing_spell_effect(creatng, SplK_Invisibility);
}
if (creatng->light_id != 0) {
light_delete_light(creatng->light_id);
creatng->light_id = 0;
}
return 1;
}
/**
* Counts amount of rooms of specific type owned by specific player.
* @param plyr_idx The player number. Only specific player number is accepted.
* @param rkind Room kind to count. Only specific kind is accepted.
*/
long count_player_rooms_of_type(PlayerNumber plyr_idx, RoomKind rkind)
{
struct Dungeon *dungeon;
struct Room *room;
long i;
unsigned long k;
// note that we can't get_players_num_dungeon() because players
// may be uninitialized yet when this is called.
dungeon = get_dungeon(plyr_idx);
if (dungeon_invalid(dungeon))
return 0;
i = dungeon->room_kind[rkind];
k = 0;
while (i != 0)
{
room = room_get(i);
if (room_is_invalid(room))
{
ERRORLOG("Jump to invalid room detected");
break;
}
i = room->next_of_owner;
// No Per-room code - we only want count
SYNCDBG(19,"Player %d has %s at (%d,%d)",(int)plyr_idx, room_code_name(room->kind), (int)room->central_stl_x, (int)room->central_stl_y);
if (room->owner != plyr_idx) {
ERRORDBG(3,"Player %d has bad room in %s list; it's really %s index %d owned by player %d",(int)plyr_idx, room_code_name(rkind), room_code_name(room->kind), (int)room->index, (int)room->owner);
break;
}
k++;
if (k > ROOMS_COUNT)
{
ERRORLOG("Infinite loop detected when sweeping rooms list");
break;
}
}
return k;
}
/**
* Does a step of researching.
* Informs if the research cycle should end.
* @param thing
*/
CrCheckRet process_research_function(struct Thing *creatng)
{
struct Dungeon *dungeon;
struct Room *room;
dungeon = get_dungeon(creatng->owner);
if (dungeon_invalid(dungeon)) {
SYNCDBG(9,"The %s index %d cannot work as player %d has no dungeon",
thing_model_name(creatng), (int)creatng->index, (int)creatng->owner);
set_start_state(creatng);
return CrCkRet_Continue;
}
if (!creature_can_do_research(creatng)) {
set_start_state(creatng);
return CrCkRet_Continue;
}
room = get_room_creature_works_in(creatng);
if ( !room_still_valid_as_type_for_thing(room, RoK_LIBRARY, 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;
}
long work_value;
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(creatng);
struct CreatureStats *crstat;
crstat = creature_stats_get_from_thing(creatng);
work_value = compute_creature_work_value(crstat->research_value*256, room->efficiency, cctrl->explevel);
work_value = process_work_speed_on_work_value(creatng, work_value);
SYNCDBG(19,"The %s index %d produced %d research points",thing_model_name(creatng),(int)creatng->index,(int)work_value);
dungeon->total_research_points += work_value;
dungeon->research_progress += work_value;
//TODO CREATURE_JOBS going postal should be possible for all jobs, not only research
process_job_stress_and_going_postal(creatng, room);
return CrCkRet_Available;
}
/**
* Quick attack is just putting CTA spell on enemy room.
* @param comp
* @param check
*/
long computer_check_for_quick_attack(struct Computer2 *comp, struct ComputerCheck * check)
{
struct Dungeon *dungeon;
SYNCDBG(8,"Starting");
dungeon = comp->dungeon;
int creatrs_num;
creatrs_num = check->param1 * dungeon->num_active_creatrs / 100;
if (check->param3 >= creatrs_num) {
return CTaskRet_Unk4;
}
if (computer_able_to_use_magic(comp, PwrK_CALL2ARMS, 1, 3) != 1) {
return CTaskRet_Unk4;
}
if ((check_call_to_arms(comp) != 1) || is_there_an_attack_task(comp)) {
return CTaskRet_Unk4;
}
struct Room *room;
room = get_hated_room_for_quick_attack(comp, check->param3);
if (room_is_invalid(room)) {
return CTaskRet_Unk4;
}
struct Coord3d pos;
// TODO COMPUTER_PLAYER We should make sure the place of cast is accessible for creatures
pos.x.val = subtile_coord_center(room->central_stl_x);
pos.y.val = subtile_coord_center(room->central_stl_y);
pos.z.val = subtile_coord(1,0);
if (count_creatures_availiable_for_fight(comp, &pos) <= check->param3) {
return CTaskRet_Unk4;
}
if (!create_task_magic_support_call_to_arms(comp, &pos, check->param2, 0, creatrs_num)) {
return CTaskRet_Unk4;
}
SYNCLOG("Player %d decided to attack %s owned by player %d",(int)dungeon->owner,room_code_name(room->kind),(int)room->owner);
output_message(SMsg_EnemyHarassments+ACTION_RANDOM(8), 500, 1);
return CTaskRet_Unk1;
}
short barracking(struct Thing *creatng)
{
struct Room *room;
room = get_room_thing_is_on(creatng);
if (!room_still_valid_as_type_for_thing(room, RoK_BARRACKS, 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);
remove_creature_from_work_room(creatng);
set_start_state(creatng);
return CrStRet_ResetFail;
}
if (person_move_somewhere_adjacent_in_room(creatng, room)) {
creatng->continue_state = CrSt_Barracking;
}
return CrStRet_Modified;
}
TbBool attempt_job_sleep_in_lair_near_pos(struct Thing *creatng, MapSubtlCoord stl_x, MapSubtlCoord stl_y, CreatureJob new_job)
{
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(creatng);
SYNCDBG(16,"Starting for %s (owner %d) and job %s",thing_model_name(creatng),(int)creatng->owner,creature_job_code_name(new_job));
struct Room *room;
room = subtile_room_get(stl_x, stl_y);
if (get_arrive_at_state_for_job(new_job) == CrSt_Unused) {
ERRORLOG("No arrive at state for job %s in %s room",creature_job_code_name(new_job),room_code_name(room->kind));
return false;
}
cctrl->slap_turns = 0;
cctrl->max_speed = calculate_correct_creature_maxspeed(creatng);
if (creature_has_lair_room(creatng) && (room->index == cctrl->lair_room_id))
{
if (creature_move_to_home_lair(creatng))
{
creatng->continue_state = CrSt_CreatureGoingHomeToSleep;
return 1;
}
}
struct Coord3d pos;
if (find_first_valid_position_for_thing_in_room(creatng, room, &pos)
&& setup_person_move_to_coord(creatng, &pos, NavRtF_Default))
{
creatng->continue_state = CrSt_CreatureChangeLair;
cctrl->target_room_id = room->index;
return 1;
}
return 0;
}
TbBool attempt_job_work_in_room_and_cure_near_pos(struct Thing *creatng, MapSubtlCoord stl_x, MapSubtlCoord stl_y, CreatureJob new_job)
{
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(creatng);
SYNCDBG(16,"Starting for %s (owner %d) and job %s",thing_model_name(creatng),(int)creatng->owner,creature_job_code_name(new_job));
struct Room *room;
room = subtile_room_get(stl_x, stl_y);
if (get_arrive_at_state_for_job(new_job) == CrSt_Unused) {
ERRORLOG("No arrive at state for job %s in %s room",creature_job_code_name(new_job),room_code_name(room->kind));
return false;
}
struct Coord3d pos;
if (!find_first_valid_position_for_thing_in_room(creatng, room, &pos)) {
return false;
}
if (!setup_person_move_to_position(creatng, pos.x.stl.num, pos.y.stl.num, NavRtF_Default)) {
return false;
}
creatng->continue_state = get_arrive_at_state_for_job(new_job);
cctrl->target_room_id = room->index;
process_temple_cure(creatng);
return true;
}
TbBool attempt_job_work_in_room_near_pos(struct Thing *creatng, MapSubtlCoord stl_x, MapSubtlCoord stl_y, CreatureJob new_job)
{
struct CreatureControl *cctrl;
cctrl = creature_control_get_from_thing(creatng);
SYNCDBG(16,"Starting for %s (owner %d) and job %s",thing_model_name(creatng),(int)creatng->owner,creature_job_code_name(new_job));
struct Room *room;
room = subtile_room_get(stl_x, stl_y);
if (get_arrive_at_state_for_job(new_job) == CrSt_Unused) {
ERRORLOG("No arrive at state for job %s in %s room",creature_job_code_name(new_job),room_code_name(room->kind));
return false;
}
if (!creature_move_to_place_in_room(creatng, room, new_job)) {
return false;
}
creatng->continue_state = get_arrive_at_state_for_job(new_job);
cctrl->target_room_id = room->index;
if ((new_job == Job_TRAIN) && (creatng->model == get_players_special_digger_model(room->owner))) {
cctrl->digger.last_did_job = SDLstJob_UseTraining4;
}
return true;
}
