static void test_monsters_learn_exp(CuTest * tc)
{
faction *f, *f2;
unit *u, *m;
skill* sk;
create_monsters(&f, &f2, &u, &m);
config_set("study.produceexp", "30");
u_setrace(u, u_race(m));
produceexp(u, SK_MELEE, u->number);
sk = unit_skill(u, SK_MELEE);
CuAssertTrue(tc, !sk);
produceexp(m, SK_MELEE, u->number);
sk = unit_skill(m, SK_MELEE);
CuAssertTrue(tc, sk && (sk->level > 0 || (sk->level == 0 && sk->weeks > 0)));
test_cleanup();
}
void herbsearch(region * r, unit * u, int max)
{
int herbsfound;
const item_type *whichherb;
if (eff_skill(u, SK_HERBALISM, r) == 0) {
cmistake(u, u->thisorder, 59, MSG_PRODUCE);
return;
}
if (is_guarded(r, u, GUARD_PRODUCE)) {
cmistake(u, u->thisorder, 70, MSG_EVENT);
return;
}
whichherb = rherbtype(r);
if (whichherb == NULL) {
cmistake(u, u->thisorder, 108, MSG_PRODUCE);
return;
}
if (max)
max = _min(max, rherbs(r));
else
max = rherbs(r);
herbsfound = ntimespprob(eff_skill(u, SK_HERBALISM, r) * u->number,
(double)rherbs(r) / 100.0F, -0.01F);
herbsfound = _min(herbsfound, max);
rsetherbs(r, rherbs(r) - herbsfound);
if (herbsfound) {
produceexp(u, SK_HERBALISM, u->number);
i_change(&u->items, whichherb, herbsfound);
ADDMSG(&u->faction->msgs, msg_message("herbfound",
"unit region amount herb", u, r, herbsfound, whichherb->rtype));
} else {
ADDMSG(&u->faction->msgs, msg_message("researchherb_none",
"unit region", u, u->region));
}
}
void plan_monsters(faction * f)
{
region *r;
assert(f);
attack_chance = get_param_flt(global.parameters, "rules.monsters.attack_chance", 0.4);
f->lastorders = turn;
for (r = regions; r; r = r->next) {
unit *u;
bool attacking = false;
for (u = r->units; u; u = u->next) {
attrib *ta;
order *long_order = NULL;
/* Ab hier nur noch Befehle für NPC-Einheiten. */
if (!is_monsters(u->faction))
continue;
/* Befehle müssen jede Runde neu gegeben werden: */
free_orders(&u->orders);
if (skill_enabled(SK_PERCEPTION)) {
/* Monster bekommen jede Runde ein paar Tage Wahrnehmung dazu */
/* TODO: this only works for playerrace */
produceexp(u, SK_PERCEPTION, u->number);
}
if (!attacking) {
if (chance(attack_chance)) attacking = true;
}
if (u->status > ST_BEHIND) {
setstatus(u, ST_FIGHT);
/* all monsters fight */
}
if (attacking && (!r->land || is_guard(u, GUARD_TAX))) {
monster_attacks(u);
}
/* units with a plan to kill get ATTACK orders: */
ta = a_find(u->attribs, &at_hate);
if (ta && !monster_is_waiting(u)) {
unit *tu = (unit *)ta->data.v;
if (tu && tu->region == r) {
order * ord = monster_attack(u, tu);
if (ord) {
addlist(&u->orders, ord);
}
}
else if (tu) {
tu = findunitg(ta->data.i, NULL);
if (tu != NULL) {
long_order = make_movement_order(u, tu->region, 2, allowed_walk);
}
}
else
a_remove(&u->attribs, ta);
}
/* All monsters guard the region: */
if (!monster_is_waiting(u) && r->land) {
addlist(&u->orders, create_order(K_GUARD, u->faction->locale, NULL));
}
/* Einheiten mit Bewegungsplan kriegen ein NACH: */
if (long_order == NULL) {
attrib *ta = a_find(u->attribs, &at_targetregion);
if (ta) {
if (u->region == (region *)ta->data.v) {
a_remove(&u->attribs, ta);
}
}
else if (u_race(u)->flags & RCF_MOVERANDOM) {
if (rng_int() % 100 < MOVECHANCE || check_overpopulated(u)) {
long_order = monster_move(r, u);
}
}
}
if (long_order == NULL && unit_can_study(u)) {
/* Einheiten, die Waffenlosen Kampf lernen könnten, lernen es um
* zu bewachen: */
if (u_race(u)->bonus[SK_WEAPONLESS] != -99) {
if (effskill(u, SK_WEAPONLESS, 0) < 1) {
long_order =
create_order(K_STUDY, f->locale, "'%s'",
skillname(SK_WEAPONLESS, f->locale));
}
}
}
if (long_order == NULL) {
/* Ab hier noch nicht generalisierte Spezialbehandlungen. */
if (!u->orders) {
handle_event(u->attribs, "ai_move", u);
}
switch (old_race(u_race(u))) {
case RC_SEASERPENT:
long_order = create_order(K_PIRACY, f->locale, NULL);
break;
#ifdef TODO_ALP
case RC_ALP:
long_order = monster_seeks_target(r, u);
break;
#endif
case RC_FIREDRAGON:
case RC_DRAGON:
case RC_WYRM:
long_order = plan_dragon(u);
break;
default:
if (u_race(u)->flags & RCF_LEARN) {
long_order = monster_learn(u);
}
break;
}
}
if (long_order) {
addlist(&u->orders, long_order);
}
}
}
pathfinder_cleanup();
}
/** Use up resources for building an object.
* Build up to 'size' points of 'type', where 'completed'
* of the first object have already been finished. return the
* actual size that could be built.
*/
int build(unit * u, const construction * ctype, int completed, int want)
{
const construction *type = ctype;
int skills = INT_MAX; /* number of skill points remainig */
int basesk = 0;
int made = 0;
if (want <= 0)
return 0;
if (type == NULL)
return ENOMATERIALS;
if (type->improvement == NULL && completed == type->maxsize)
return ECOMPLETE;
if (type->btype != NULL) {
building *b;
if (!u->building || u->building->type != type->btype) {
return EBUILDINGREQ;
}
b = inside_building(u);
if (b == NULL)
return EBUILDINGREQ;
}
if (type->skill != NOSKILL) {
int effsk;
int dm = get_effect(u, oldpotiontype[P_DOMORE]);
assert(u->number);
basesk = effskill(u, type->skill);
if (basesk == 0)
return ENEEDSKILL;
effsk = basesk;
if (inside_building(u)) {
effsk = skillmod(u->building->type->attribs, u, u->region, type->skill,
effsk, SMF_PRODUCTION);
}
effsk = skillmod(type->attribs, u, u->region, type->skill,
effsk, SMF_PRODUCTION);
if (effsk < 0)
return effsk; /* pass errors to caller */
if (effsk == 0)
return ENEEDSKILL;
skills = effsk * u->number;
/* technically, nimblefinge and domore should be in a global set of
* "game"-attributes, (as at_skillmod) but for a while, we're leaving
* them in here. */
if (dm != 0) {
/* Auswirkung Schaffenstrunk */
dm = _min(dm, u->number);
change_effect(u, oldpotiontype[P_DOMORE], -dm);
skills += dm * effsk;
}
}
for (; want > 0 && skills > 0;) {
int c, n;
/* skip over everything that's already been done:
* type->improvement==NULL means no more improvements, but no size limits
* type->improvement==type means build another object of the same time
* while material lasts type->improvement==x means build x when type
* is finished */
while (type->improvement != NULL &&
type->improvement != type &&
type->maxsize > 0 && type->maxsize <= completed) {
completed -= type->maxsize;
type = type->improvement;
}
if (type == NULL) {
if (made == 0)
return ECOMPLETE;
break; /* completed */
}
/* Hier ist entweder maxsize == -1, oder completed < maxsize.
* Andernfalls ist das Datenfile oder sonstwas kaputt...
* (enno): Nein, das ist für Dinge, bei denen die nächste Ausbaustufe
* die gleiche wie die vorherige ist. z.b. gegenstände.
*/
if (type->maxsize > 1) {
completed = completed % type->maxsize;
}
else {
completed = 0;
assert(type->reqsize >= 1);
}
if (basesk < type->minskill) {
if (made == 0)
return ELOWSKILL; /* not good enough to go on */
}
/* n = maximum buildable size */
if (type->minskill > 1) {
n = skills / type->minskill;
}
else {
n = skills;
}
/* Flinkfingerring wirkt nicht auf Mengenbegrenzte (magische)
* Talente */
if (skill_limit(u->faction, type->skill) == INT_MAX) {
const resource_type *ring = get_resourcetype(R_RING_OF_NIMBLEFINGER);
item *itm = ring ? *i_find(&u->items, ring->itype) : 0;
int i = itm ? itm->number : 0;
if (i > 0) {
int rings = _min(u->number, i);
n = n * ((roqf_factor() - 1) * rings + u->number) / u->number;
}
}
if (want < n) n = want;
if (type->maxsize > 0) {
n = _min(type->maxsize - completed, n);
if (type->improvement == NULL) {
want = n;
}
}
if (type->materials)
for (c = 0; n > 0 && type->materials[c].number; c++) {
const struct resource_type *rtype = type->materials[c].rtype;
int need, prebuilt;
int canuse = get_pooled(u, rtype, GET_DEFAULT, INT_MAX);
if (inside_building(u)) {
canuse = matmod(u->building->type->attribs, u, rtype, canuse);
}
if (canuse < 0)
return canuse; /* pass errors to caller */
canuse = matmod(type->attribs, u, rtype, canuse);
if (type->reqsize > 1) {
prebuilt =
required(completed, type->reqsize, type->materials[c].number);
for (; n;) {
need =
required(completed + n, type->reqsize, type->materials[c].number);
if (need - prebuilt <= canuse)
break;
--n; /* TODO: optimieren? */
}
}
else {
int maxn = canuse / type->materials[c].number;
if (maxn < n)
n = maxn;
}
}
if (n <= 0) {
if (made == 0)
return ENOMATERIALS;
else
break;
}
if (type->materials)
for (c = 0; type->materials[c].number; c++) {
const struct resource_type *rtype = type->materials[c].rtype;
int prebuilt =
required(completed, type->reqsize, type->materials[c].number);
int need =
required(completed + n, type->reqsize, type->materials[c].number);
int multi = 1;
int canuse = 100; /* normalization */
if (inside_building(u))
canuse = matmod(u->building->type->attribs, u, rtype, canuse);
if (canuse < 0)
return canuse; /* pass errors to caller */
canuse = matmod(type->attribs, u, rtype, canuse);
assert(canuse % 100 == 0
|| !"only constant multipliers are implemented in build()");
multi = canuse / 100;
if (canuse < 0)
return canuse; /* pass errors to caller */
use_pooled(u, rtype, GET_DEFAULT,
(need - prebuilt + multi - 1) / multi);
}
made += n;
skills -= n * type->minskill;
want -= n;
completed = completed + n;
}
/* Nur soviel PRODUCEEXP wie auch tatsaechlich gemacht wurde */
produceexp(u, ctype->skill, _min(made, u->number));
return made;
}
void build_road(region * r, unit * u, int size, direction_t d)
{
int n, left;
region *rn = rconnect(r, d);
assert(u->number);
if (!eff_skill(u, SK_ROAD_BUILDING, r)) {
cmistake(u, u->thisorder, 103, MSG_PRODUCE);
return;
}
if (besieged(u)) {
cmistake(u, u->thisorder, 60, MSG_PRODUCE);
return;
}
if (rn == NULL || rn->terrain->max_road < 0) {
cmistake(u, u->thisorder, 94, MSG_PRODUCE);
return;
}
if (r->terrain->max_road < 0) {
cmistake(u, u->thisorder, 94, MSG_PRODUCE);
return;
}
if (r->terrain == newterrain(T_SWAMP)) {
/* wenn kein Damm existiert */
const struct building_type *bt_dam = bt_find("dam");
if (!bt_dam || !buildingtype_exists(r, bt_dam, true)) {
cmistake(u, u->thisorder, 132, MSG_PRODUCE);
return;
}
}
else if (r->terrain == newterrain(T_DESERT)) {
const struct building_type *bt_caravan = bt_find("caravan");
/* wenn keine Karawanserei existiert */
if (!bt_caravan || !buildingtype_exists(r, bt_caravan, true)) {
cmistake(u, u->thisorder, 133, MSG_PRODUCE);
return;
}
}
else if (r->terrain == newterrain(T_GLACIER)) {
const struct building_type *bt_tunnel = bt_find("tunnel");
/* wenn kein Tunnel existiert */
if (!bt_tunnel || !buildingtype_exists(r, bt_tunnel, true)) {
cmistake(u, u->thisorder, 131, MSG_PRODUCE);
return;
}
}
/* left kann man noch bauen */
left = r->terrain->max_road - rroad(r, d);
/* hoffentlich ist r->road <= r->terrain->max_road, n also >= 0 */
if (left <= 0) {
ADDMSG(&u->faction->msgs, msg_feedback(u, u->thisorder,
"error_roads_finished", ""));
return;
}
if (size > 0)
left = _min(size, left);
/* baumaximum anhand der rohstoffe */
if (u_race(u) == get_race(RC_STONEGOLEM)) {
n = u->number * GOLEM_STONE;
}
else {
n = get_pooled(u, get_resourcetype(R_STONE), GET_DEFAULT, left);
if (n == 0) {
cmistake(u, u->thisorder, 151, MSG_PRODUCE);
return;
}
}
left = _min(n, left);
/* n = maximum by skill. try to maximize it */
n = u->number * eff_skill(u, SK_ROAD_BUILDING, r);
if (n < left) {
const resource_type *ring = get_resourcetype(R_RING_OF_NIMBLEFINGER);
item *itm = ring ? *i_find(&u->items, ring->itype) : 0;
if (itm != NULL && itm->number > 0) {
int rings = _min(u->number, itm->number);
n = n * ((roqf_factor() - 1) * rings + u->number) / u->number;
}
}
if (n < left) {
int dm = get_effect(u, oldpotiontype[P_DOMORE]);
if (dm != 0) {
int sk = eff_skill(u, SK_ROAD_BUILDING, r);
int todo = (left - n + sk - 1) / sk;
todo = _min(todo, u->number);
dm = _min(dm, todo);
change_effect(u, oldpotiontype[P_DOMORE], -dm);
n += dm * sk;
} /* Auswirkung Schaffenstrunk */
}
/* make minimum of possible and available: */
n = _min(left, n);
/* n is now modified by several special effects, so we have to
* minimize it again to make sure the road will not grow beyond
* maximum. */
rsetroad(r, d, rroad(r, d) + (short)n);
if (u_race(u) == get_race(RC_STONEGOLEM)) {
int golemsused = n / GOLEM_STONE;
if (n % GOLEM_STONE != 0) {
++golemsused;
}
scale_number(u, u->number - golemsused);
}
else {
use_pooled(u, get_resourcetype(R_STONE), GET_DEFAULT, n);
/* Nur soviel PRODUCEEXP wie auch tatsaechlich gemacht wurde */
produceexp(u, SK_ROAD_BUILDING, _min(n, u->number));
}
ADDMSG(&u->faction->msgs, msg_message("buildroad",
"region unit size", r, u, n));
}