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;
}
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;
}
/**
* 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;
}
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;
}