Marc
/
server
forked from github/server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
server/src/laws.c

4244 lines
121 KiB
C
Raw Blame History

#ifdef _MSC_VER
#include <platform.h>
#endif
#include <kernel/config.h>
#include "laws.h"
#include <modules/gmcmd.h>
#include "alchemy.h"
#include "automate.h"
#include "battle.h"
#include "contact.h"
#include "economy.h"
#include "give.h"
#include "market.h"
#include "morale.h"
#include "monsters.h"
#include "move.h"
#include "randenc.h"
#include "recruit.h"
#include "renumber.h"
#include "spy.h"
#include "study.h"
#include "wormhole.h"
#include "prefix.h"
#include "reports.h"
#include "teleport.h"
#include "guard.h"
#include "volcano.h"
/* kernel includes */
#include "kernel/alliance.h"
#include "kernel/ally.h"
#include "kernel/calendar.h"
#include "kernel/callbacks.h"
#include "kernel/connection.h"
#include "kernel/curse.h"
#include "kernel/building.h"
#include "kernel/faction.h"
#include "kernel/group.h"
#include "kernel/item.h"
#include "kernel/messages.h"
#include "kernel/order.h"
#include "kernel/plane.h"
#include "kernel/pool.h"
#include "kernel/race.h"
#include "kernel/region.h"
#include "kernel/resources.h"
#include "kernel/ship.h"
#include "kernel/spell.h"
#include "kernel/spellbook.h"
#include "kernel/terrain.h"
#include "kernel/terrainid.h"
#include "kernel/unit.h"
/* util includes */
#include <kernel/attrib.h>
#include <util/base36.h>
#include <kernel/event.h>
#include <util/goodies.h>
#include "util/keyword.h"
#include <util/language.h>
#include <util/lists.h>
#include <util/log.h>
#include <util/macros.h>
#include <util/message.h>
#include <util/param.h>
#include <util/parser.h>
#include <util/password.h>
#include <util/path.h>
#include <util/rand.h>
#include <util/rng.h>
#include <util/strings.h>
#include <util/umlaut.h>
#include <util/unicode.h>
/* attributes includes */
#include <attributes/otherfaction.h>
#include <attributes/racename.h>
#include <attributes/raceprefix.h>
#include <attributes/seenspell.h>
#include <attributes/stealth.h>
#include <spells/buildingcurse.h>
#include <spells/regioncurse.h>
#include <spells/unitcurse.h>
#include <selist.h>
#include <iniparser.h>
/* libc includes */
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
/* chance that a peasant dies of starvation: */
#define PEASANT_STARVATION_CHANCE 0.9
/* Pferdevermehrung */
#define HORSEGROWTH 4
/* Wanderungschance pro Pferd */
#define HORSEMOVE 3
/* Vermehrungschance pro Baum */
#define FORESTGROWTH 10000 /* In Millionstel */
/** Ausbreitung und Vermehrung */
#define MAXDEMAND 25
#define DMRISE 0.1F /* weekly chance that demand goes up */
#define DMRISEHAFEN 0.2F /* weekly chance that demand goes up with harbor */
param_t findparam_ex(const char *s, const struct locale * lang)
{
param_t result = findparam(s, lang);
if (result == NOPARAM) {
const building_type *btype = findbuildingtype(s, lang);
if (btype != NULL)
return P_GEBAEUDE;
}
return (result == P_BUILDING) ? P_GEBAEUDE : result;
}
int NewbieImmunity(void)
{
int result = config_get_int("NewbieImmunity", 0);
return result;
}
bool IsImmune(const faction * f)
{
return !fval(f, FFL_NPC) && f->age < NewbieImmunity();
}
int NMRTimeout(void)
{
static int config, nmr_timeout, ini_timeout;
if (config_changed(&config)) {
nmr_timeout = config_get_int("nmr.timeout", 0);
ini_timeout = config_get_int("game.maxnmr", 0);
}
if (nmr_timeout > 0) {
if (ini_timeout > nmr_timeout) {
return nmr_timeout;
}
return (ini_timeout > 0) ? ini_timeout : nmr_timeout;
}
return ini_timeout;
}
bool LongHunger(const struct unit *u)
{
if (u != NULL) {
if (!fval(u, UFL_HUNGER))
return false;
if (u_race(u) == get_race(RC_DAEMON))
return false;
}
return config_get_int("hunger.long", 0) != 0;
}
static bool RemoveNMRNewbie(void)
{
int value = config_get_int("nmr.removenewbie", 0);
return value != 0;
}
static void dumbeffect(unit *u) {
int effect = get_effect(u, oldpotiontype[P_FOOL]);
if (effect > 0) { /* Trank "Dumpfbackenbrot" */
skill *sv = u->skills, *sb = NULL;
while (sv != u->skills + u->skill_size) {
if (sb == NULL || skill_compare(sv, sb) > 0) {
sb = sv;
}
++sv;
}
/* bestes Talent raussuchen */
if (sb != NULL) {
int weeks = u->number;
if (weeks > effect) weeks = effect;
reduce_skill(u, sb, weeks);
ADDMSG(&u->faction->msgs, msg_message("dumbeffect",
"unit weeks skill", u, weeks, (skill_t)sb->id));
} /* sonst Glueck gehabt: wer nix weiss, kann nix vergessen... */
change_effect(u, oldpotiontype[P_FOOL], -effect);
}
}
static void astral_crumble(unit *u) {
item **itemp = &u->items;
while (*itemp) {
item *itm = *itemp;
if ((itm->type->flags & ITF_NOTLOST) == 0) {
if (itm->type->flags & (ITF_BIG | ITF_ANIMAL | ITF_CURSED)) {
ADDMSG(&u->faction->msgs, msg_message("itemcrumble",
"unit region item amount",
u, u->region, itm->type->rtype, itm->number));
i_free(i_remove(itemp, itm));
continue;
}
}
itemp = &itm->next;
}
}
static void age_unit(region * r, unit * u)
{
const race *rc = u_race(u);
++u->age;
if (u->number > 0 && rc->age_unit) {
rc->age_unit(u);
}
if (u->attribs) {
dumbeffect(u);
}
if (u->items && u->region && is_astral(u->region)) {
astral_crumble(u);
}
}
static void live(region * r)
{
unit **up = &r->units;
get_food(r);
while (*up) {
unit *u = *up;
/* IUW: age_unit() kann u loeschen, u->next ist dann
* undefiniert, also muessen wir hier schon das naechste
* Element bestimmen */
age_unit(r, u);
if (*up == u)
up = &u->next;
}
}
/*
* This procedure calculates the number of emigrating peasants for the given
* region r. There are two incentives for peasants to emigrate:
* 1) They prefer the less crowded areas.
* Example: mountains, 700 peasants (max 1000), 70% inhabited
* plain, 5000 peasants (max 10000), 50% inhabited
* 700*(PEASANTSWANDER_WEIGHT/100)*((70-50)/100) peasants wander
* from mountains to plain.
* Effect : peasents will leave densely populated regions.
* 2) Peasants prefer richer neighbour regions.
* Example: region A, 700 peasants, wealth $10500, $15 per head
* region B, 2500 peasants, wealth $25000, $10 per head
* Some peasants will emigrate from B to A because $15 > $10
* exactly: 2500*(PEASANTSGREED_WEIGHT1/100)*((15-10)/100)
* Not taken in consideration:
* - movement because of monsters.
* - movement because of wars
* - movement because of low loyalty relating to present parties.
*/
#define MAX_EMIGRATION(p) ((p)/MAXDIRECTIONS)
#define MAX_IMMIGRATION(p) ((p)*2/3)
void peasant_migration(region * r)
{
int i;
int maxp = region_maxworkers(r);
int rp = rpeasants(r);
int max_immigrants = MAX_IMMIGRATION(maxp - rp);
if (volcano_module()) {
static int terrain_cache;
static const terrain_type *t_volcano;
static const terrain_type *t_smoking;
if (terrain_changed(&terrain_cache)) {
t_volcano = newterrain(T_VOLCANO);
t_smoking = newterrain(T_VOLCANO_SMOKING);
}
if (r->terrain == t_volcano || r->terrain == t_smoking) {
max_immigrants = max_immigrants / 10;
}
}
for (i = 0; max_immigrants > 0 && i != MAXDIRECTIONS; i++) {
int dir = (turn + 1 + i) % MAXDIRECTIONS;
region *rc = rconnect(r, (direction_t)dir);
if (rc != NULL && fval(rc->terrain, LAND_REGION)) {
int rp2 = rpeasants(rc);
int maxp2 = region_maxworkers(rc);
int max_emigration = MAX_EMIGRATION(rp2 - maxp2);
if (max_emigration > 0) {
if (max_emigration > max_immigrants) max_emigration = max_immigrants;
if (max_emigration + r->land->newpeasants > USHRT_MAX) {
max_emigration = USHRT_MAX - r->land->newpeasants;
}
if (max_emigration + rc->land->newpeasants > USHRT_MAX) {
max_emigration = USHRT_MAX - rc->land->newpeasants;
}
r->land->newpeasants += (short)max_emigration;
rc->land->newpeasants -= (short)max_emigration;
max_immigrants -= max_emigration;
}
}
}
}
/* Vermehrungsrate Bauern in 1/10000.
* TODO: Evt. Berechnungsfehler, reale Vermehrungsraten scheinen hoeher. */
#define PEASANTGROWTH 10
#define PEASANTLUCK 10
#define PEASANTFORCE 0.75 /* Chance einer Vermehrung trotz 90% Auslastung */
static double peasant_growth_factor(void)
{
return config_get_flt("rules.peasants.growth.factor", 0.0001 * (double)PEASANTGROWTH);
}
static double peasant_luck_factor(void)
{
return config_get_flt("rules.peasants.peasantluck.factor", PEASANTLUCK);
}
int peasant_luck_effect(int peasants, int luck, int maxp, double variance)
{
int births = 0;
double mean;
if (luck == 0) return 0;
mean = fmin(luck, peasants);
mean *= peasant_luck_factor() * peasant_growth_factor();
mean *= ((peasants / (double)maxp < .9) ? 1 : PEASANTFORCE);
births = RAND_ROUND(normalvariate(mean, variance * mean));
if (births <= 0)
births = 1;
if (births > peasants / 2)
births = peasants / 2 + 1;
return births;
}
static void peasants(region * r, int rule)
{
int rp = rpeasants(r);
int money = rmoney(r);
int maxp = max_production(r);
int n, satiated;
int dead = 0, peasants = rp;
if (peasants > 0 && rule > 0) {
int luck = 0;
double fraction = peasants * peasant_growth_factor();
int births = RAND_ROUND(fraction);
attrib *a = a_find(r->attribs, &at_peasantluck);
if (a != NULL) {
luck = a->data.i * 1000;
}
luck = peasant_luck_effect(peasants, luck, maxp, .5);
if (luck > 0)
ADDMSG(&r->msgs, msg_message("peasantluck_success", "births", luck));
peasants += births + luck;
}
/* Alle werden satt, oder halt soviele fuer die es auch Geld gibt */
satiated = money / maintenance_cost(NULL);
if (satiated > peasants) satiated = peasants;
rsetmoney(r, money - satiated * maintenance_cost(NULL));
/* Von denjenigen, die nicht satt geworden sind, verhungert der
* Grossteil. dead kann nie groesser als rpeasants(r) - satiated werden,
* so dass rpeasants(r) >= 0 bleiben muss. */
/* Es verhungert maximal die unterernaehrten Bevoelkerung. */
n = peasants - satiated;
if (n > rp) n = rp;
dead += (int)(0.5 + n * PEASANT_STARVATION_CHANCE);
if (dead > 0) {
ADDMSG(&r->msgs, msg_message("phunger", "dead", dead));
peasants -= dead;
}
rsetpeasants(r, peasants);
}
/* ------------------------------------------------------------- */
typedef struct migration {
struct migration *next;
region *r;
int horses;
int trees;
} migration;
#define MSIZE 1023
migration *migrants[MSIZE];
migration *free_migrants;
static migration *get_migrants(region * r)
{
int key = reg_hashkey(r);
int index = key % MSIZE;
migration *m = migrants[index];
while (m && m->r != r)
m = m->next;
if (m == NULL) {
/* Es gibt noch keine Migration. Also eine erzeugen
*/
m = free_migrants;
if (!m) {
m = calloc(1, sizeof(migration));
if (!m) abort();
}
else {
free_migrants = free_migrants->next;
m->horses = 0;
m->trees = 0;
}
m->r = r;
m->next = migrants[index];
migrants[index] = m;
}
return m;
}
static void migrate(region * r)
{
int key = reg_hashkey(r);
int index = key % MSIZE;
migration **hp = &migrants[index];
fset(r, RF_MIGRATION);
while (*hp && (*hp)->r != r)
hp = &(*hp)->next;
if (*hp) {
migration *m = *hp;
rsethorses(r, rhorses(r) + m->horses);
/* Was macht das denn hier?
* Baumwanderung wird in trees() gemacht.
* wer fragt das? Die Baumwanderung war abhaengig von der
* Auswertungsreihenfolge der regionen,
* das hatte ich geaendert. jemand hat es wieder geloescht, toll.
* ich habe es wieder aktiviert, muss getestet werden.
*/
*hp = m->next;
m->next = free_migrants;
free_migrants = m;
}
}
static void horses(region * r)
{
int horses, maxhorses;
direction_t n;
/* Logistisches Wachstum, Optimum bei halbem Maximalbesatz. */
maxhorses = region_maxworkers(r) / 10;
horses = rhorses(r);
if (horses > 0) {
if (is_cursed(r->attribs, &ct_godcursezone)) {
rsethorses(r, (int)(horses * 0.9));
}
else if (maxhorses > 0) {
double growth =
(RESOURCE_QUANTITY * (HORSEGROWTH * 200.0 * ((double)maxhorses -
horses))) / (double)maxhorses;
if (growth > 0) {
int i;
if (a_find(r->attribs, &at_horseluck)) {
growth *= 2;
}
/* printf("Horses: <%d> %d -> ", growth, horses); */
i = (int)(0.5 + (horses * 0.0001) * growth);
/* printf("%d\n", horses); */
rsethorses(r, horses + i);
}
}
}
/* Pferde wandern in Nachbarregionen.
* Falls die Nachbarregion noch berechnet
* werden muss, wird eine migration-Struktur gebildet,
* die dann erst in die Berechnung der Nachbarstruktur einfliesst.
*/
for (n = 0; n != MAXDIRECTIONS; n++) {
region *r2 = rconnect(r, n);
if (r2 && fval(r2->terrain, WALK_INTO)) {
int pt = (rhorses(r) * HORSEMOVE) / 100;
pt = (int)normalvariate(pt, pt / 4.0);
if (pt < 0) pt = 0;
if (fval(r2, RF_MIGRATION))
rsethorses(r2, rhorses(r2) + pt);
else {
migration *nb;
/* haben wir die Migration schonmal benutzt?
* wenn nicht, muessen wir sie suchen.
* Wandernde Pferde vermehren sich nicht.
*/
nb = get_migrants(r2);
nb->horses += pt;
}
/* Wandernde Pferde sollten auch abgezogen werden */
rsethorses(r, rhorses(r) - pt);
}
}
assert(rhorses(r) >= 0);
}
static int count_race(const region * r, const race * rc)
{
unit *u;
int c = 0;
for (u = r->units; u; u = u->next)
if (u_race(u) == rc)
c += u->number;
return c;
}
attrib_type at_germs = {
"germs",
DEFAULT_INIT,
DEFAULT_FINALIZE,
DEFAULT_AGE,
a_writeshorts,
a_readshorts,
NULL,
ATF_UNIQUE
};
static void
growing_trees_e3(region * r, const int current_season,
const int last_weeks_season)
{
static const int transform[4][3] = {
{ -1, -1, 0 },
{ TREE_SEED, TREE_SAPLING, 2 },
{ TREE_SAPLING, TREE_TREE, 2 },
{ TREE_TREE, TREE_SEED, 2 }
};
if (r->land && current_season != last_weeks_season
&& transform[current_season][2]) {
int src_type = transform[current_season][0];
int dst_type = transform[current_season][1];
int src = rtrees(r, src_type);
int dst = rtrees(r, dst_type);
int grow = src / transform[current_season][2];
if (grow > 0) {
if (src_type != TREE_TREE) {
rsettrees(r, src_type, src - grow);
}
rsettrees(r, dst_type, dst + grow);
if (dst_type == TREE_SEED && r->terrain->size) {
region *rn[MAXDIRECTIONS];
int d;
double fgrow = grow / (double)MAXDIRECTIONS;
get_neighbours(r, rn);
for (d = 0; d != MAXDIRECTIONS; ++d) {
region *rx = rn[d];
if (rx && rx->land) {
double scale = 1.0;
int g;
double fg, ch;
int seeds = rtrees(rx, dst_type);
if (r->terrain->size > rx->terrain->size) {
scale = (scale * rx->terrain->size) / r->terrain->size;
}
fg = scale * fgrow;
g = (int)fg;
ch = fg - g;
if (chance(ch))
++g;
if (g > 0) {
rsettrees(rx, dst_type, seeds + g);
}
}
}
}
}
}
}
static void
growing_trees(region * r, const season_t current_season, const season_t last_weeks_season)
{
int grownup_trees, i, seeds, sprout;
attrib *a;
if (current_season == SEASON_SUMMER || current_season == SEASON_AUTUMN) {
double seedchance = 0.01F * RESOURCE_QUANTITY;
int mp, elves = count_race(r, get_race(RC_ELF));
direction_t d;
a = a_find(r->attribs, &at_germs);
if (a && last_weeks_season == SEASON_SPRING) {
/* ungekeimte Samen bleiben erhalten, Sproesslinge wachsen */
sprout = rtrees(r, 1);
if (sprout > a->data.sa[1]) sprout = a->data.sa[1];
/* aus dem gesamt Sproesslingepool abziehen */
rsettrees(r, 1, rtrees(r, 1) - sprout);
/* zu den Baeumen hinzufuegen */
rsettrees(r, 2, rtrees(r, 2) + sprout);
a_removeall(&r->attribs, &at_germs);
}
if (is_cursed(r->attribs, &ct_godcursezone)) {
rsettrees(r, 1, (int)(rtrees(r, 1) * 0.9));
rsettrees(r, 2, (int)(rtrees(r, 2) * 0.9));
return;
}
mp = max_production(r);
if (mp <= 0)
return;
/* Grundchance 1.0% */
/* Jeder Elf in der Region erhoeht die Chance marginal */
mp = mp / 8;
if (elves > mp) elves = mp;
if (elves) {
seedchance += 1.0 - pow(0.99999, elves * RESOURCE_QUANTITY);
}
grownup_trees = rtrees(r, 2);
seeds = 0;
if (grownup_trees > 0) {
double remainder = seedchance * grownup_trees;
seeds = (int)(remainder);
remainder -= seeds;
if (chance(remainder)) {
++seeds;
}
if (seeds > 0) {
seeds += rtrees(r, 0);
rsettrees(r, 0, seeds);
}
}
/* Baeume breiten sich in Nachbarregionen aus. */
/* Gesamtzahl der Samen:
* bis zu 6% (FORESTGROWTH*3) der Baeume samen in die Nachbarregionen */
seeds = (rtrees(r, 2) * FORESTGROWTH * 3) / 1000000;
for (d = 0; d != MAXDIRECTIONS; ++d) {
region *r2 = rconnect(r, d);
if (r2 && fval(r2->terrain, LAND_REGION) && r2->terrain->size) {
/* Eine Landregion, wir versuchen Samen zu verteilen:
* Die Chance, das Samen ein Stueck Boden finden, in dem sie
* keimen koennen, haengt von der Bewuchsdichte und der
* verfuegbaren Flaeche ab. In Gletschern gibt es weniger
* Moeglichkeiten als in Ebenen. */
sprout = 0;
seedchance = (1000.0 * region_maxworkers(r2)) / r2->terrain->size;
for (i = 0; i < seeds / MAXDIRECTIONS; i++) {
if (rng_int() % 10000 < seedchance)
sprout++;
}
rsettrees(r2, 0, rtrees(r2, 0) + sprout);
}
}
}
else if (current_season == SEASON_SPRING) {
int growth;
if (is_cursed(r->attribs, &ct_godcursezone))
return;
/* in at_germs merken uns die Zahl der Samen und Sproesslinge, die
* dieses Jahr aelter werden duerfen, damit nicht ein Same im selben
* Zyklus zum Baum werden kann */
a = a_find(r->attribs, &at_germs);
if (!a) {
a = a_add(&r->attribs, a_new(&at_germs));
a->data.sa[0] = (short)rtrees(r, 0);
a->data.sa[1] = (short)rtrees(r, 1);
}
/* wir haben 6 Wochen zum wachsen, jeder Same/Spross hat 18% Chance
* zu wachsen, damit sollten nach 5-6 Wochen alle gewachsen sein */
growth = 1800;
/* Samenwachstum */
/* Raubbau abfangen, es duerfen nie mehr Samen wachsen, als aktuell
* in der Region sind */
seeds = rtrees(r, 0);
if (seeds > a->data.sa[0]) seeds = a->data.sa[0];
sprout = 0;
for (i = 0; i < seeds; i++) {
if (rng_int() % 10000 < growth)
sprout++;
}
/* aus dem Samenpool dieses Jahres abziehen */
a->data.sa[0] = (short)(seeds - sprout);
/* aus dem gesamt Samenpool abziehen */
rsettrees(r, 0, rtrees(r, 0) - sprout);
/* zu den Sproesslinge hinzufuegen */
rsettrees(r, 1, rtrees(r, 1) + sprout);
/* Baumwachstum */
/* hier gehen wir davon aus, das Jungbaeume nicht ohne weiteres aus
* der Region entfernt werden koennen, da Jungbaeume in der gleichen
* Runde nachwachsen, wir also nicht mehr zwischen diesjaehrigen und
* 'alten' Jungbaeumen unterscheiden koennten */
sprout = rtrees(r, 1);
if (sprout > a->data.sa[1]) sprout = a->data.sa[1];
grownup_trees = 0;
for (i = 0; i < sprout; i++) {
if (rng_int() % 10000 < growth)
grownup_trees++;
}
/* aus dem Sproesslingepool dieses Jahres abziehen */
a->data.sa[1] = (short)(sprout - grownup_trees);
/* aus dem gesamt Sproesslingepool abziehen */
rsettrees(r, 1, rtrees(r, 1) - grownup_trees);
/* zu den Baeumen hinzufuegen */
rsettrees(r, 2, rtrees(r, 2) + grownup_trees);
}
}
static void
growing_herbs(region * r, const int current_season, const season_t last_weeks_season)
{
/* Jetzt die Kraeutervermehrung. Vermehrt wird logistisch:
*
* Jedes Kraut hat eine Wahrscheinlichkeit von (100-(vorhandene
* Kraeuter))% sich zu vermehren. */
UNUSED_ARG(last_weeks_season);
if (current_season != SEASON_WINTER) {
int i, herbs = rherbs(r);
for (i = herbs; i > 0; --i) {
if (rng_int() % 100 < (100 - herbs)) {
++herbs;
}
}
rsetherbs(r, herbs);
}
}
void immigration(void)
{
region *r;
int repopulate = config_get_int("rules.economy.repopulate_maximum", 90);
log_info(" - Einwanderung...");
for (r = regions; r; r = r->next) {
if (r->land && r->land->newpeasants) {
int rp = rpeasants(r) + r->land->newpeasants;
/* FIXME: kann ernsthaft abs(newpeasants) > rpeasants(r) sein? */
if (rp < 0) rp = 0;
rsetpeasants(r, rp);
r->land->newpeasants = 0;
}
/* Genereate some (0-6 depending on the income) peasants out of nothing */
/* if less than 50 are in the region and there is space and no monster or demon units in the region */
if (repopulate) {
int peasants = rpeasants(r);
int income = wage(r, NULL, NULL, turn) - maintenance_cost(NULL) + 1;
if (income >= 0 && r->land && (peasants < repopulate) && region_maxworkers(r) >(peasants + 30) * 2) {
int badunit = 0;
unit *u;
for (u = r->units; u; u = u->next) {
if (!playerrace(u_race(u)) || u_race(u) == get_race(RC_DAEMON)) {
badunit = 1;
break;
}
}
if (badunit == 0) {
peasants += (int)(rng_double()*income);
rsetpeasants(r, peasants);
}
}
}
}
}
void nmr_warnings(void)
{
faction *f, *fa;
#define HELP_NMR (HELP_GUARD|HELP_MONEY)
for (f = factions; f; f = f->next) {
if (!fval(f, FFL_NOIDLEOUT) && turn > f->lastorders) {
ADDMSG(&f->msgs, msg_message("nmr_warning", ""));
if (turn - f->lastorders == NMRTimeout() - 1) {
ADDMSG(&f->msgs, msg_message("nmr_warning_final", ""));
}
if ((turn - f->lastorders) >= 2) {
message *msg = NULL;
for (fa = factions; fa; fa = fa->next) {
int warn = 0;
if (config_get_int("rules.alliances", 0) != 0) {
if (f->alliance && f->alliance == fa->alliance) {
warn = 1;
}
}
else if (alliedfaction(f, fa, HELP_NMR) && alliedfaction(fa, f, HELP_NMR)) {
warn = 1;
}
if (warn) {
if (msg == NULL) {
msg = msg_message("warn_dropout", "faction turns", f,
turn - f->lastorders);
}
add_message(&fa->msgs, msg);
}
}
if (msg != NULL)
msg_release(msg);
}
}
}
}
void demographics(void)
{
region *r;
int plant_rules = config_get_int("rules.grow.formula", 2);
int horse_rules = config_get_int("rules.horses.growth", 1);
int peasant_rules = config_get_int("rules.peasants.growth", 1);
const struct building_type *bt_harbour = bt_find("harbour");
season_t current_season = calendar_season(turn);
season_t last_weeks_season = calendar_season(turn - 1);
for (r = regions; r; r = r->next) {
++r->age; /* also oceans. no idea why we didn't always do that */
live(r);
if (!fval(r->terrain, SEA_REGION)) {
/* die Nachfrage nach Produkten steigt. */
struct demand *dmd;
if (r->land) {
for (dmd = r->land->demands; dmd; dmd = dmd->next) {
if (dmd->value > 0 && dmd->value < MAXDEMAND) {
float rise = DMRISE;
if (buildingtype_exists(r, bt_harbour, true))
rise = DMRISEHAFEN;
if (rng_double() < rise)
++dmd->value;
}
}
/* Seuchen erst nachdem die Bauern sich vermehrt haben
* und gewandert sind */
peasant_migration(r);
peasants(r, peasant_rules);
if (r->age > 20) {
double mwp = fmax(region_maxworkers(r), 1);
double prob =
pow(rpeasants(r) / (mwp * wage(r, NULL, NULL, turn) * 0.13), 4.0)
* PLAGUE_CHANCE;
if (rng_double() < prob) {
plagues(r);
}
}
if (horse_rules > 0) {
horses(r);
}
if (plant_rules == 2) { /* E2 */
growing_trees(r, current_season, last_weeks_season);
growing_herbs(r, current_season, last_weeks_season);
}
else if (plant_rules==1) { /* E3 */
growing_trees_e3(r, current_season, last_weeks_season);
}
}
update_resources(r);
if (r->land)
migrate(r);
}
}
while (free_migrants) {
migration *m = free_migrants->next;
free(free_migrants);
free_migrants = m;
};
remove_empty_units();
immigration();
}
int leave_cmd(unit * u, struct order *ord)
{
region *r = u->region;
if (fval(u, UFL_ENTER)) {
/* if we just entered this round, then we don't leave again */
return 0;
}
if (fval(r->terrain, SEA_REGION) && u->ship) {
if (!fval(u_race(u), RCF_SWIM)) {
cmistake(u, ord, 11, MSG_MOVE);
return 0;
}
if (has_horses(u)) {
cmistake(u, ord, 231, MSG_MOVE);
return 0;
}
}
leave(u, true);
return 0;
}
void transfer_faction(faction *fsrc, faction *fdst) {
unit *u;
skill_t sk;
int hmax, hnow;
int skill_count[MAXSKILLS];
int skill_limit[MAXSKILLS];
assert(fsrc != fdst);
for (sk = 0; sk != MAXSKILLS; ++sk) {
skill_limit[sk] = faction_skill_limit(fdst, sk);
}
memset(skill_count, 0, sizeof(skill_count));
for (u = fdst->units; u != NULL; u = u->nextF) {
if (u->skills) {
int i;
for (i = 0; i != u->skill_size; ++i) {
const skill *sv = u->skills + i;
skill_t sk = (skill_t)sv->id;
skill_count[sk] += u->number;
}
}
}
hnow = countheroes(fdst);
hmax = maxheroes(fdst);
u = fsrc->units;
while (u) {
unit *unext = u->nextF;
if (u_race(u) == fdst->race) {
if (u->flags & UFL_HERO) {
if (u->number + hnow > hmax) {
u->flags &= ~UFL_HERO;
}
else {
hnow += u->number;
}
}
if (give_unit_allowed(u) == 0 && !get_mage(u)) {
if (u->skills) {
int i;
for (i = 0; i != u->skill_size; ++i) {
const skill *sv = u->skills + i;
skill_t sk = (skill_t)sv->id;
if (skill_count[sk] + u->number > skill_limit[sk]) {
break;
}
}
if (i != u->skill_size) {
u = u->nextF;
continue;
}
}
ADDMSG(&fdst->msgs, msg_message("transfer_unit", "unit", u));
u_setfaction(u, fdst);
}
}
u = unext;
}
}
int quit_cmd(unit * u, struct order *ord)
{
char token[128];
faction *f = u->faction;
const char *passwd;
keyword_t kwd;
kwd = init_order_depr(ord);
assert(kwd == K_QUIT);
passwd = gettoken(token, sizeof(token));
if (checkpasswd(f, (const char *)passwd)) {
int flags = FFL_QUIT;
if (rule_transfermen()) {
param_t p;
p = getparam(f->locale);
if (p == P_FACTION) {
#ifdef QUIT_WITH_TRANSFER
faction *f2 = getfaction();
if (f2 == NULL) {
cmistake(u, ord, 66, MSG_EVENT);
flags = 0;
}
else if (f->race != f2->race) {
cmistake(u, ord, 281, MSG_EVENT);
flags = 0;
}
else {
unit *u2;
for (u2 = u->region->units; u2; u2 = u2->next) {
if (u2->faction == f2) {
if (ucontact(u2, u)) {
transfer_faction(u->faction, u2->faction);
break;
}
}
}
if (u2 == NULL) {
/* no target unit found */
cmistake(u, ord, 40, MSG_EVENT);
flags = 0;
}
}
#else
log_error("faction %s: QUIT FACTION is disabled.", factionname(f));
flags = 0;
#endif
}
}
f->flags |= flags;
}
else {
char buffer[64];
write_order(ord, f->locale, buffer, sizeof(buffer));
cmistake(u, ord, 86, MSG_EVENT);
log_warning("QUIT with illegal password for faction %s: %s\n", itoa36(f->no), buffer);
}
return 0;
}
static bool mayenter(region * r, unit * u, building * b)
{
unit *u2;
UNUSED_ARG(r);
if (fval(b, BLD_UNGUARDED))
return true;
u2 = building_owner(b);
if (u2 == NULL || ucontact(u2, u)
|| alliedunit(u2, u->faction, HELP_GUARD))
return true;
return false;
}
static int mayboard(const unit * u, ship * sh)
{
unit *u2 = ship_owner(sh);
return (!u2 || ucontact(u2, u) || alliedunit(u2, u->faction, HELP_GUARD));
}
static bool CheckOverload(void)
{
return config_get_int("rules.check_overload", 0) != 0;
}
int enter_ship(unit * u, struct order *ord, int id, bool report)
{
region *r = u->region;
ship *sh;
const race * rc = u_race(u);
/* Muss abgefangen werden, sonst koennten Schwimmer an
* Bord von Schiffen an Land gelangen. */
if (!(rc->flags & (RCF_CANSAIL | RCF_WALK | RCF_FLY))) {
if (report) {
cmistake(u, ord, 233, MSG_MOVE);
}
return 0;
}
sh = findship(id);
if (sh == NULL || sh->region != r) {
if (report) {
cmistake(u, ord, 20, MSG_MOVE);
}
return 0;
}
if (sh == u->ship) {
return 1;
}
if (!mayboard(u, sh)) {
if (report) {
cmistake(u, ord, 34, MSG_MOVE);
}
return 0;
}
if (CheckOverload()) {
int sweight, scabins;
int mweight = ship_capacity(sh);
int mcabins = ship_cabins(sh);
if (mweight > 0) {
getshipweight(sh, &sweight, &scabins);
sweight += weight(u);
if (mcabins) {
int pweight = u->number * u_race(u)->weight;
/* weight goes into number of cabins, not cargo */
scabins += pweight;
sweight -= pweight;
}
if (sweight > mweight || (mcabins && (scabins > mcabins))) {
if (report)
cmistake(u, ord, 34, MSG_MOVE);
return 0;
}
}
}
if (leave(u, false)) {
u_set_ship(u, sh);
fset(u, UFL_ENTER);
return 1;
}
else if (report) {
cmistake(u, ord, 150, MSG_MOVE);
}
return 0;
}
int enter_building(unit * u, order * ord, int id, bool report)
{
region *r = u->region;
building *b;
/* Schwimmer koennen keine Gebaeude betreten, ausser diese sind
* auf dem Ozean */
if (!fval(u_race(u), RCF_WALK) && !fval(u_race(u), RCF_FLY)) {
if (!fval(r->terrain, SEA_REGION)) {
if (report) {
cmistake(u, ord, 232, MSG_MOVE);
}
return 0;
}
}
b = findbuilding(id);
if (b == NULL || b->region != r) {
if (report) {
cmistake(u, ord, 6, MSG_MOVE);
}
return 0;
}
if (!mayenter(r, u, b)) {
if (report) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "entrance_denied",
"building", b));
}
return 0;
}
if (leave(u, 0)) {
fset(u, UFL_ENTER);
u_set_building(u, b);
return 1;
}
else if (report) {
cmistake(u, ord, 150, MSG_MOVE);
}
return 0;
}
static void do_contact(region * r)
{
unit * u;
for (u = r->units; u; u = u->next) {
order *ord;
for (ord = u->orders; ord; ord = ord->next) {
keyword_t kwd = getkeyword(ord);
if (kwd == K_CONTACT) {
contact_cmd(u, ord);
}
}
}
}
void do_enter(struct region *r, bool is_final_attempt)
{
unit **uptr;
for (uptr = &r->units; *uptr;) {
unit *u = *uptr;
order **ordp = &u->orders;
while (*ordp) {
order *ord = *ordp;
if (getkeyword(ord) == K_ENTER) {
char token[128];
param_t p;
int id;
unit *ulast = NULL;
const char * s;
init_order_depr(ord);
s = gettoken(token, sizeof(token));
p = findparam_ex(s, u->faction->locale);
id = getid();
switch (p) {
case P_BUILDING:
case P_GEBAEUDE:
if (u->building && u->building->no == id)
break;
if (enter_building(u, ord, id, is_final_attempt)) {
unit *ub;
for (ub = u; ub; ub = ub->next) {
if (ub->building == u->building) {
ulast = ub;
}
}
}
break;
case P_SHIP:
if (u->ship && u->ship->no == id)
break;
if (enter_ship(u, ord, id, is_final_attempt)) {
unit *ub;
ulast = u;
for (ub = u; ub; ub = ub->next) {
if (ub->ship == u->ship) {
ulast = ub;
}
}
}
break;
default:
if (is_final_attempt) {
cmistake(u, ord, 79, MSG_MOVE);
}
}
if (ulast != NULL) {
/* Wenn wir hier angekommen sind, war der Befehl
* erfolgreich und wir loeschen ihn, damit er im
* zweiten Versuch nicht nochmal ausgefuehrt wird. */
*ordp = ord->next;
ord->next = NULL;
free_order(ord);
if (ulast != u) {
/* put u behind ulast so it's the last unit in the building */
*uptr = u->next;
u->next = ulast->next;
ulast->next = u;
}
break;
}
}
if (*ordp == ord)
ordp = &ord->next;
}
if (*uptr == u)
uptr = &u->next;
}
}
int dropouts[2];
int *age = NULL;
bool nmr_death(const faction * f, int turn, int timeout)
{
if (f->age >= timeout && turn - f->lastorders >= timeout) {
static bool rule_destroy;
static int config;
if (config_changed(&config)) {
rule_destroy = config_get_int("rules.nmr.destroy", 0) != 0;
}
if (rule_destroy) {
unit *u;
for (u = f->units; u; u = u->nextF) {
if (u->building && building_owner(u->building) == u) {
remove_building(&u->region->buildings, u->building);
}
}
}
return true;
}
return false;
}
static void remove_idle_players(void)
{
faction **fp;
int i, timeout = NMRTimeout();
log_info(" - beseitige Spieler, die sich zu lange nicht mehr gemeldet haben...");
for (fp = &factions; *fp;) {
faction *f = *fp;
if (timeout > 0 && nmr_death(f, turn, timeout)) {
destroyfaction(fp);
} else {
if (fval(f, FFL_NOIDLEOUT)) {
f->lastorders = turn;
}
else if (turn != f->lastorders) {
char info[256];
sprintf(info, "%d Einheiten, %d Personen",
f->num_units, f->num_people);
}
fp = &f->next;
}
}
log_info(" - beseitige Spieler, die sich nach der Anmeldung nicht gemeldet haben...");
i = turn + 1;
if (i < 4) i = 4;
age = calloc(i, sizeof(int));
if (!age) abort();
for (fp = &factions; *fp;) {
faction *f = *fp;
if (!is_monsters(f)) {
if (RemoveNMRNewbie() && !fval(f, FFL_NOIDLEOUT)) {
if (f->age >= 0 && f->age <= turn)
++age[f->age];
if (f->age == 2 || f->age == 3) {
if (f->lastorders == turn - 2) {
++dropouts[f->age - 2];
destroyfaction(fp);
continue;
}
}
}
}
fp = &f->next;
}
}
void quit(void)
{
faction **fptr = &factions;
while (*fptr) {
faction *f = *fptr;
if (f->flags & FFL_QUIT) {
destroyfaction(fptr);
}
else {
++f->age;
fptr = &f->next;
}
}
remove_idle_players();
remove_empty_units();
}
/* ------------------------------------------------------------- */
/* HELFE partei [<ALLES | SILBER | GIB | KAEMPFE | WAHRNEHMUNG>] [NICHT] */
int ally_cmd(unit * u, struct order *ord)
{
char token[128];
struct allies **sfp;
faction *f;
int keyword, not_kw;
const char *s;
int sf_status;
init_order_depr(ord);
f = getfaction();
if (f == NULL || is_monsters(f)) {
cmistake(u, ord, 66, MSG_EVENT);
return 0;
}
if (f == u->faction)
return 0;
s = gettoken(token, sizeof(token));
if (!s || !s[0]) {
keyword = P_ANY;
}
else {
keyword = findparam(s, u->faction->locale);
}
sfp = &u->faction->allies;
if (fval(u, UFL_GROUP)) {
group *g = get_group(u);
if (g) {
sfp = &g->allies;
}
}
not_kw = getparam(u->faction->locale); /* HELFE partei [modus] NICHT */
sf_status = ally_get(*sfp, f);
switch (keyword) {
case P_NOT:
sf_status = 0;
break;
case NOPARAM:
cmistake(u, ord, 137, MSG_EVENT);
return 0;
case P_ANY:
sf_status = (not_kw == P_NOT) ? 0 : HELP_ALL;
break;
case P_TRAVEL:
if (not_kw == P_NOT) {
sf_status = sf_status & (HELP_ALL - HELP_TRAVEL);
}
else {
sf_status |= HELP_TRAVEL;
}
break;
case P_GIVE:
if (not_kw == P_NOT)
sf_status &= (HELP_ALL - HELP_GIVE);
else
sf_status |= HELP_GIVE;
break;
case P_MONEY:
if (not_kw == P_NOT)
sf_status &= (HELP_ALL - HELP_MONEY);
else
sf_status |= HELP_MONEY;
break;
case P_FIGHT:
if (not_kw == P_NOT)
sf_status &= (HELP_ALL - HELP_FIGHT);
else
sf_status |= HELP_FIGHT;
break;
case P_FACTIONSTEALTH:
if (not_kw == P_NOT)
sf_status &= (HELP_ALL - HELP_FSTEALTH);
else
sf_status |= HELP_FSTEALTH;
break;
case P_GUARD:
if (not_kw == P_NOT)
sf_status &= (HELP_ALL - HELP_GUARD);
else
sf_status |= HELP_GUARD;
break;
}
sf_status &= HelpMask();
ally_set(sfp, f, sf_status);
return 0;
}
static struct local_names *pnames;
static void init_prefixnames(void)
{
int i;
for (i = 0; localenames[i]; ++i) {
const struct locale *lang = get_locale(localenames[i]);
bool exist = false;
struct local_names *in = pnames;
while (in != NULL) {
if (in->lang == lang) {
exist = true;
break;
}
in = in->next;
}
if (in == NULL) {
in = calloc(1, sizeof(local_names));
if (!in) abort();
}
in->next = pnames;
in->lang = lang;
if (!exist && race_prefixes) {
int key;
for (key = 0; race_prefixes[key]; ++key) {
variant var;
const char *pname =
LOC(lang, mkname("prefix", race_prefixes[key]));
if (findtoken(in->names, pname, &var) == E_TOK_NOMATCH || var.i != key) {
var.i = key;
addtoken((struct tnode **)&in->names, pname, var);
addtoken((struct tnode **)&in->names, LOC(lang, mkname("prefix",
race_prefixes[key])), var);
}
}
}
pnames = in;
}
}
int prefix_cmd(unit * u, struct order *ord)
{
char token[128];
attrib **ap;
const char *s;
local_names *in = pnames;
variant var;
const struct locale *lang = u->faction->locale;
while (in != NULL) {
if (in->lang == lang)
break;
in = in->next;
}
if (in == NULL) {
init_prefixnames();
for (in = pnames; in && in->lang != lang; in = in->next);
if (!in) return 0;
}
init_order_depr(ord);
s = gettoken(token, sizeof(token));
if (!s || !*s) {
group *g = get_group(u);
if (g) {
a_removeall(&g->attribs, &at_raceprefix);
}
else {
a_removeall(&u->faction->attribs, &at_raceprefix);
}
return 0;
}
else if (findtoken(in->names, s, &var) == E_TOK_NOMATCH) {
return 0;
}
else if (race_prefixes[var.i] == NULL) {
cmistake(u, ord, 299, MSG_EVENT);
}
else {
group *g = get_group(u);
if (g) {
ap = &g->attribs;
}
else {
ap = &u->faction->attribs;
}
set_prefix(ap, race_prefixes[var.i]);
}
return 0;
}
int display_cmd(unit * u, struct order *ord)
{
char token[128];
char **s = NULL;
char *str;
region *r = u->region;
init_order_depr(ord);
str = gettoken(token, sizeof(token));
switch (findparam_ex(str, u->faction->locale)) {
case P_BUILDING:
case P_GEBAEUDE:
if (!u->building) {
cmistake(u, ord, 145, MSG_PRODUCE);
break;
}
if (building_owner(u->building) != u) {
cmistake(u, ord, 5, MSG_PRODUCE);
break;
}
if (!fval(u->building->type, BTF_NAMECHANGE) && u->building->display && u->building->display[0]) {
cmistake(u, ord, 278, MSG_EVENT);
break;
}
s = &u->building->display;
break;
case P_SHIP:
if (!u->ship) {
cmistake(u, ord, 144, MSG_PRODUCE);
break;
}
if (ship_owner(u->ship) != u) {
cmistake(u, ord, 12, MSG_PRODUCE);
break;
}
s = &u->ship->display;
break;
case P_UNIT:
str = getstrtoken();
if (str) {
unicode_utf8_trim(str);
}
unit_setinfo(u, str);
break;
case P_PRIVAT:
str = getstrtoken();
if (str) {
unicode_utf8_trim(str);
}
usetprivate(u, str);
break;
case P_REGION:
if (!r->land || u->faction != region_get_owner(r)) {
cmistake(u, ord, 147, MSG_EVENT);
break;
}
s = &r->land->display;
break;
default:
cmistake(u, ord, 110, MSG_EVENT);
break;
}
if (s != NULL) {
const char *s2 = getstrtoken();
free(*s);
if (s2) {
char * sdup = str_strdup(s2);
if (unicode_utf8_trim(sdup) != 0) {
log_info("trimming info: %s", s2);
}
if (strlen(sdup) >= DISPLAYSIZE) {
sdup[DISPLAYSIZE-1] = 0;
}
*s = sdup;
}
else {
*s = NULL;
}
}
return 0;
}
bool renamed_building(const building * b)
{
const struct locale *lang = locales;
size_t len = strlen(b->name);
for (; lang; lang = nextlocale(lang)) {
const char *bdname = LOC(lang, b->type->_name);
if (bdname) {
size_t bdlen = strlen(bdname);
if (len >= bdlen && strncmp(b->name, bdname, bdlen) == 0) {
return false;
}
}
}
return true;
}
static int rename_cmd(unit * u, order * ord, char **s, const char *s2)
{
char name[NAMESIZE];
assert(s2);
if (!s2[0]) {
cmistake(u, ord, 84, MSG_EVENT);
return 0;
}
/* TODO: Validate to make sure people don't have illegal characters in
* names, phishing-style? () come to mind. */
str_strlcpy(name, s2, sizeof(name));
if (unicode_utf8_trim(name) != 0) {
log_info("trimming name: %s", s2);
}
free(*s);
*s = str_strdup(name);
return 0;
}
static bool try_rename(unit *u, building *b, order *ord) {
unit *owner = b ? building_owner(b) : NULL;
bool foreign = !(owner && owner->faction == u->faction);
if (!b) {
cmistake(u, ord, u->building ? 6 : 145, MSG_EVENT);
return false;
}
if (!fval(b->type, BTF_NAMECHANGE) && renamed_building(b)) {
cmistake(u, ord, 278, MSG_EVENT);
return false;
}
if (foreign) {
if (renamed_building(b)) {
cmistake(u, ord, 246, MSG_EVENT);
return false;
}
if (owner) {
if (cansee(owner->faction, u->region, u, 0)) {
ADDMSG(&owner->faction->msgs,
msg_message("renamed_building_seen",
"building renamer region", b, u, u->region));
}
else {
ADDMSG(&owner->faction->msgs,
msg_message("renamed_building_notseen",
"building region", b, u->region));
}
}
}
if (owner && owner->faction != u->faction) {
cmistake(u, ord, 148, MSG_PRODUCE);
return false;
}
return true;
}
int
rename_building(unit * u, order * ord, building * b, const char *name)
{
assert(name);
if (!try_rename(u, b, ord)) {
return -1;
}
return rename_cmd(u, ord, &b->name, name);
}
int name_cmd(struct unit *u, struct order *ord)
{
char token[128];
building *b = u->building;
region *r = u->region;
char **s = NULL;
param_t p;
bool foreign = false;
const char *str;
init_order(ord, u->faction->locale);
str = gettoken(token, sizeof(token));
p = findparam_ex(str, u->faction->locale);
if (p == P_FOREIGN) {
str = gettoken(token, sizeof(token));
foreign = true;
p = findparam_ex(str, u->faction->locale);
}
switch (p) {
case P_ALLIANCE:
if (!foreign && f_get_alliance(u->faction)) {
alliance *al = u->faction->alliance;
faction *lead = alliance_get_leader(al);
if (lead == u->faction) {
s = &al->name;
}
}
break;
case P_BUILDING:
case P_GEBAEUDE:
if (foreign) {
b = getbuilding(u->region);
}
if (try_rename(u, b, ord)) {
s = &b->name;
}
break;
case P_FACTION:
if (foreign) {
faction *f;
f = getfaction();
if (!f) {
cmistake(u, ord, 66, MSG_EVENT);
break;
}
if (f->age < 10) {
cmistake(u, ord, 248, MSG_EVENT);
break;
}
else {
const struct locale *lang = locales;
size_t f_len = strlen(f->name);
for (; lang; lang = nextlocale(lang)) {
const char *fdname = LOC(lang, "factiondefault");
size_t fdlen = strlen(fdname);
if (f_len >= fdlen && strncmp(f->name, fdname, fdlen) == 0) {
break;
}
}
if (lang == NULL) {
cmistake(u, ord, 247, MSG_EVENT);
break;
}
}
if (cansee(f, r, u, 0)) {
ADDMSG(&f->msgs,
msg_message("renamed_faction_seen", "unit region", u, r));
}
else {
ADDMSG(&f->msgs, msg_message("renamed_faction_notseen", "", r));
}
s = &f->name;
}
else {
s = &u->faction->name;
}
break;
case P_SHIP:
if (foreign) {
ship *sh = getship(r);
unit *uo;
if (!sh) {
cmistake(u, ord, 20, MSG_EVENT);
break;
}
else {
const struct locale *lang = locales;
size_t sh_len = strlen(sh->name);
for (; lang; lang = nextlocale(lang)) {
const char *sdname = LOC(lang, sh->type->_name);
size_t sdlen = strlen(sdname);
if (sh_len >= sdlen && strncmp(sh->name, sdname, sdlen) == 0) {
break;
}
sdname = LOC(lang, parameters[P_SHIP]);
sdlen = strlen(sdname);
if (sh_len >= sdlen && strncmp(sh->name, sdname, sdlen) == 0) {
break;
}
}
if (lang == NULL) {
cmistake(u, ord, 245, MSG_EVENT);
break;
}
}
uo = ship_owner(sh);
if (uo) {
if (cansee(uo->faction, r, u, 0)) {
ADDMSG(&uo->faction->msgs,
msg_message("renamed_ship_seen", "ship renamer region", sh, u, r));
}
else {
ADDMSG(&uo->faction->msgs,
msg_message("renamed_ship_notseen", "ship region", sh, r));
}
}
s = &sh->name;
}
else {
unit *uo;
if (!u->ship) {
cmistake(u, ord, 144, MSG_PRODUCE);
break;
}
uo = ship_owner(u->ship);
if (uo->faction != u->faction) {
cmistake(u, ord, 12, MSG_PRODUCE);
break;
}
s = &u->ship->name;
}
break;
case P_UNIT:
if (foreign) {
unit *u2 = 0;
getunit(r, u->faction, &u2);
if (!u2 || !cansee(u->faction, r, u2, 0)) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord,
"feedback_unit_not_found", ""));
break;
}
else {
char udefault[32];
default_name(u2, udefault, sizeof(udefault));
if (strcmp(unit_getname(u2), udefault) != 0) {
cmistake(u, ord, 244, MSG_EVENT);
break;
}
}
if (cansee(u2->faction, r, u, 0)) {
ADDMSG(&u2->faction->msgs, msg_message("renamed_seen",
"renamer renamed region", u, u2, r));
}
else {
ADDMSG(&u2->faction->msgs, msg_message("renamed_notseen",
"renamed region", u2, r));
}
s = &u2->_name;
}
else {
s = &u->_name;
}
break;
case P_REGION:
if (u->faction != region_get_owner(r)) {
cmistake(u, ord, 147, MSG_EVENT);
break;
}
s = &r->land->name;
break;
case P_GROUP:
{
group *g = get_group(u);
if (g) {
s = &g->name;
break;
}
else {
cmistake(u, ord, 109, MSG_EVENT);
break;
}
}
break;
default:
cmistake(u, ord, 109, MSG_EVENT);
break;
}
if (s != NULL) {
const char *name = getstrtoken();
if (name) {
rename_cmd(u, ord, s, name);
}
else {
cmistake(u, ord, 84, MSG_EVENT);
}
}
return 0;
}
/* ------------------------------------------------------------- */
void
deliverMail(faction * f, region * r, unit * u, const char *s, unit * receiver)
{
if (!cansee(f, r, u, 0)) {
u = NULL;
}
if (!receiver) { /* BOTSCHAFT an PARTEI */
ADDMSG(&f->msgs,
msg_message("regionmessage", "region sender string", r, u, s));
}
else { /* BOTSCHAFT an EINHEIT */
ADDMSG(&f->msgs,
msg_message("unitmessage", "region unit sender string", r,
receiver, u, s));
}
}
static void
mailunit(region * r, unit * u, int n, struct order *ord, const char *s)
{
unit *u2 = findunitr(r, n);
if (u2 && cansee(u->faction, r, u2, 0)) {
deliverMail(u2->faction, r, u, s, u2);
/* now done in prepare_mail_cmd */
}
else {
/* Immer eine Meldung - sonst koennte man so getarnte EHs enttarnen:
* keine Meldung -> EH hier. */
ADDMSG(&u->faction->msgs,
msg_feedback(u, ord, "feedback_unit_not_found", ""));
}
}
static void mailfaction(unit * u, int n, struct order *ord, const char *s)
{
faction *f;
f = findfaction(n);
if (f && n > 0)
deliverMail(f, u->region, u, s, NULL);
else
cmistake(u, ord, 66, MSG_MESSAGE);
}
int mail_cmd(unit * u, struct order *ord)
{
char token[128];
region *r = u->region;
unit *u2;
const char *s;
int n, cont;
init_order_depr(ord);
s = gettoken(token, sizeof(token));
/* Falls kein Parameter, ist das eine Einheitsnummer;
* das Fuellwort "AN" muss wegfallen, da gueltige Nummer! */
do {
cont = 0;
switch (findparam_ex(s, u->faction->locale)) {
case P_REGION:
/* koennen alle Einheiten in der Region sehen */
s = getstrtoken();
if (!s || !s[0]) {
cmistake(u, ord, 30, MSG_MESSAGE);
break;
}
else {
ADDMSG(&r->msgs, msg_message("mail_result", "unit message", u, s));
return 0;
}
case P_FACTION:
n = getid();
for (u2 = r->units; u2; u2 = u2->next) {
if (u2->faction->no == n && seefaction(u->faction, r, u2, 0)) {
break;
}
}
if (!u2) {
cmistake(u, ord, 66, MSG_MESSAGE);
break;
}
s = getstrtoken();
if (!s || !s[0]) {
cmistake(u, ord, 30, MSG_MESSAGE);
break;
}
mailfaction(u, n, ord, s);
return 0;
case P_UNIT:
n = getid();
for (u2 = r->units; u2; u2 = u2->next) {
if (u2->no == n && cansee(u->faction, r, u2, 0)) {
break;
}
}
if (!u2) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord,
"feedback_unit_not_found", ""));
return 0;
}
s = getstrtoken();
if (!s || !s[0]) {
cmistake(u, ord, 30, MSG_MESSAGE);
break;
}
else {
mailunit(r, u, n, ord, s);
}
return 0;
case P_BUILDING:
case P_GEBAEUDE:
{
building *b = getbuilding(r);
if (!b) {
cmistake(u, ord, 6, MSG_MESSAGE);
break;
}
s = getstrtoken();
if (!s || !s[0]) {
cmistake(u, ord, 30, MSG_MESSAGE);
break;
}
for (u2 = r->units; u2; u2 = u2->next)
freset(u2->faction, FFL_SELECT);
for (u2 = r->units; u2; u2 = u2->next) {
if (u2->building == b && !fval(u2->faction, FFL_SELECT)
&& cansee(u->faction, r, u2, 0)) {
mailunit(r, u, u2->no, ord, s);
fset(u2->faction, FFL_SELECT);
}
}
return 0;
}
case P_SHIP:
{
ship *sh = getship(r);
if (!sh) {
cmistake(u, ord, 20, MSG_MESSAGE);
break;
}
s = getstrtoken();
if (!s || !s[0]) {
cmistake(u, ord, 30, MSG_MESSAGE);
break;
}
for (u2 = r->units; u2; u2 = u2->next)
freset(u2->faction, FFL_SELECT);
for (u2 = r->units; u2; u2 = u2->next) {
if (u2->ship == sh && !fval(u2->faction, FFL_SELECT)
&& cansee(u->faction, r, u2, 0)) {
mailunit(r, u, u2->no, ord, s);
fset(u2->faction, FFL_SELECT);
}
}
return 0;
}
default:
/* possibly filler token? */
s = getstrtoken();
if (s && *s)
cont = 1;
break;
}
} while (cont);
cmistake(u, ord, 149, MSG_MESSAGE);
return 0;
}
/* ------------------------------------------------------------- */
int banner_cmd(unit * u, struct order *ord)
{
const char * s;
init_order_depr(ord);
s = getstrtoken();
if (!s || !s[0]) {
cmistake(u, ord, 125, MSG_EVENT);
}
else {
faction_setbanner(u->faction, s);
ADDMSG(&u->faction->msgs, msg_message("changebanner", "value", s));
}
return 0;
}
int email_cmd(unit * u, struct order *ord)
{
const char *s;
init_order_depr(ord);
s = getstrtoken();
if (!s || !s[0]) {
cmistake(u, ord, 85, MSG_EVENT);
}
else {
faction *f = u->faction;
if (check_email(s) == 0) {
faction_setemail(f, s);
ADDMSG(&f->msgs, msg_message("changemail", "value", faction_getemail(f)));
} else {
log_error("Invalid email address for faction %s: %s\n", itoa36(f->no), s);
ADDMSG(&f->msgs, msg_message("changemail_invalid", "value", s));
}
}
return 0;
}
bool password_wellformed(const char *password)
{
unsigned char *c = (unsigned char *)password;
int i;
if (!password || password[0]=='\0') {
return false;
}
for (i = 0; c[i] && i != PASSWORD_MAXSIZE; ++i) {
if (!isalnum(c[i])) {
return false;
}
}
return true;
}
int password_cmd(unit * u, struct order *ord)
{
char pwbuf[PASSWORD_MAXSIZE + 1];
const char *s;
init_order_depr(ord);
pwbuf[PASSWORD_MAXSIZE] = '\n';
s = gettoken(pwbuf, sizeof(pwbuf));
if (pwbuf[PASSWORD_MAXSIZE] == '\0') {
cmistake(u, ord, 321, MSG_EVENT);
pwbuf[PASSWORD_MAXSIZE - 1] = '\0';
}
if (!s || !password_wellformed(s)) {
if (s) {
cmistake(u, ord, 283, MSG_EVENT);
}
password_generate(pwbuf, PASSWORD_MAXSIZE);
}
faction_setpassword(u->faction, password_hash(pwbuf, PASSWORD_DEFAULT));
ADDMSG(&u->faction->msgs, msg_message("changepasswd", "value", pwbuf));
u->faction->flags |= FFL_PWMSG;
return 0;
}
int send_cmd(unit * u, struct order *ord)
{
char token[128];
const char *s;
int option;
init_order_depr(ord);
s = gettoken(token, sizeof(token));
option = findoption(s, u->faction->locale);
if (option == -1) {
cmistake(u, ord, 135, MSG_EVENT);
}
else {
if (getparam(u->faction->locale) == P_NOT) {
if (option == O_COMPRESS || option == O_BZIP2) {
cmistake(u, ord, 305, MSG_EVENT);
}
else {
u->faction->options = u->faction->options & ~(1 << option);
}
}
else {
u->faction->options = u->faction->options | (1 << option);
if (option == O_COMPRESS)
u->faction->options &= ~(1 << O_BZIP2);
if (option == O_BZIP2)
u->faction->options &= ~(1 << O_COMPRESS);
}
}
return 0;
}
static void display_potion(unit * u, const item_type * itype) {
show_item(u, itype);
}
static void display_item(unit * u, const item_type * itype)
{
faction * f = u->faction;
const char *name;
const char *key;
const char *info;
name = resourcename(itype->rtype, 0);
key = mkname("iteminfo", name);
info = locale_getstring(f->locale, key);
if (info == NULL) {
info = LOC(f->locale, mkname("iteminfo", "no_info"));
}
ADDMSG(&f->msgs, msg_message("displayitem", "weight item description",
itype->weight, itype->rtype, info));
}
static void display_race(faction * f, const race * rc)
{
char buf[2048];
sbstring sbs;
sbs_init(&sbs, buf, sizeof(buf));
report_raceinfo(rc, f->locale, &sbs);
addmessage(0, f, buf, MSG_EVENT, ML_IMPORTANT);
}
static void reshow_other(unit * u, struct order *ord, const char *s) {
int err = 21;
bool found = false;
if (s) {
const spell *sp = 0;
const item_type *itype;
const race *rc;
/* check if it's an item */
itype = finditemtype(s, u->faction->locale);
sp = unit_getspell(u, s, u->faction->locale);
rc = findrace(s, u->faction->locale);
if (itype) {
/* if this is a potion, we need the right alchemy skill */
err = 36; /* we do not have this item? */
if (itype->flags & ITF_POTION) {
/* we don't have the item, but it is a potion. do we know it? */
int level = potion_level(itype);
if (level > 0 && 2 * level <= effskill(u, SK_ALCHEMY, NULL)) {
display_potion(u, itype);
found = true;
}
}
else {
int i = i_get(u->items, itype);
if (i > 0) {
found = true;
display_item(u, itype);
}
}
}
if (sp) {
reset_seen_spells(u->faction, sp);
found = true;
}
if (rc && u_race(u) == rc) {
display_race(u->faction, rc);
found = true;
}
}
if (!found) {
cmistake(u, ord, err, MSG_EVENT);
}
}
static void reshow(unit * u, struct order *ord, const char *s, param_t p)
{
switch (p) {
case P_ZAUBER:
reset_seen_spells(u->faction, NULL);
break;
case P_POTIONS:
if (!display_potions(u)) {
cmistake(u, ord, 285, MSG_EVENT);
}
break;
case NOPARAM:
reshow_other(u, ord, s);
break;
default:
cmistake(u, ord, 222, MSG_EVENT);
break;
}
}
int promotion_cmd(unit * u, struct order *ord)
{
const struct resource_type *rsilver = get_resourcetype(R_SILVER);
int money, people;
if (fval(u, UFL_HERO)) {
/* TODO: message "is already a hero" */
return 0;
}
if (maxheroes(u->faction) < countheroes(u->faction) + u->number) {
ADDMSG(&u->faction->msgs,
msg_feedback(u, ord, "heroes_maxed", "max count",
maxheroes(u->faction), countheroes(u->faction)));
return 0;
}
if (!valid_race(u->faction, u_race(u))) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "heroes_race", "race",
u_race(u)));
return 0;
}
people = u->faction->num_people * u->number;
money = get_pooled(u, rsilver, GET_ALL, people);
if (people > money) {
ADDMSG(&u->faction->msgs,
msg_feedback(u, ord, "heroes_cost", "cost have", people, money));
return 0;
}
use_pooled(u, rsilver, GET_ALL, people);
fset(u, UFL_HERO);
ADDMSG(&u->faction->msgs, msg_message("hero_promotion", "unit cost",
u, people));
return 0;
}
int group_cmd(unit * u, struct order *ord)
{
keyword_t kwd;
kwd = init_order_depr(ord);
assert(kwd == K_GROUP);
join_group(u, getstrtoken());
return 0;
}
int origin_cmd(unit * u, struct order *ord)
{
int px, py;
init_order_depr(ord);
px = getint();
py = getint();
faction_setorigin(u->faction, getplaneid(u->region), px, py);
return 0;
}
int guard_off_cmd(unit * u, struct order *ord)
{
assert(getkeyword(ord) == K_GUARD);
init_order_depr(ord);
if (getparam(u->faction->locale) == P_NOT) {
setguard(u, false);
}
return 0;
}
int reshow_cmd(unit * u, struct order *ord)
{
char lbuf[64];
const char *s;
param_t p = NOPARAM;
init_order_depr(ord);
s = gettoken(lbuf, sizeof(lbuf));
if (s && isparam(s, u->faction->locale, P_ANY)) {
p = getparam(u->faction->locale);
s = NULL;
}
reshow(u, ord, s, p);
return 0;
}
int status_cmd(unit * u, struct order *ord)
{
char token[128];
const char *s;
init_order_depr(ord);
s = gettoken(token, sizeof(token));
switch (findparam(s, u->faction->locale)) {
case P_NOT:
unit_setstatus(u, ST_AVOID);
break;
case P_BEHIND:
unit_setstatus(u, ST_BEHIND);
break;
case P_FLEE:
unit_setstatus(u, ST_FLEE);
break;
case P_CHICKEN:
unit_setstatus(u, ST_CHICKEN);
break;
case P_AGGRO:
unit_setstatus(u, ST_AGGRO);
break;
case P_VORNE:
unit_setstatus(u, ST_FIGHT);
break;
case P_HELP:
if (getparam(u->faction->locale) == P_NOT) {
fset(u, UFL_NOAID);
}
else {
freset(u, UFL_NOAID);
}
break;
default:
if (s && s[0]) {
add_message(&u->faction->msgs,
msg_feedback(u, ord, "unknown_status", ""));
}
else {
unit_setstatus(u, ST_FIGHT);
}
}
return 0;
}
int combatspell_cmd(unit * u, struct order *ord)
{
char token[128];
const char *s;
int level = 0;
spell *sp = 0;
init_order_depr(ord);
s = gettoken(token, sizeof(token));
/* KAMPFZAUBER [NICHT] loescht alle gesetzten Kampfzauber */
if (!s || *s == 0 || findparam(s, u->faction->locale) == P_NOT) {
unset_combatspell(u, 0);
return 0;
}
/* Optional: STUFE n */
if (findparam(s, u->faction->locale) == P_LEVEL) {
/* Merken, setzen kommt erst spaeter */
level = getuint();
s = gettoken(token, sizeof(token));
}
sp = unit_getspell(u, s, u->faction->locale);
if (!sp) {
cmistake(u, ord, 173, MSG_MAGIC);
return 0;
}
s = gettoken(token, sizeof(token));
if (findparam(s, u->faction->locale) == P_NOT) {
/* KAMPFZAUBER "<Spruchname>" NICHT loescht diesen speziellen
* Kampfzauber */
unset_combatspell(u, sp);
return 0;
}
else {
/* KAMPFZAUBER "<Spruchname>" setzt diesen Kampfzauber */
/* knowsspell prueft auf ist_magier, ist_spruch, kennt_spruch */
if (!knowsspell(u->region, u, sp)) {
/* Fehler 'Spell not found' */
cmistake(u, ord, 173, MSG_MAGIC);
}
else if (!u_hasspell(u, sp)) {
/* Diesen Zauber kennt die Einheit nicht */
cmistake(u, ord, 169, MSG_MAGIC);
}
else if (!(sp->sptyp & ISCOMBATSPELL)) {
/* Diesen Kampfzauber gibt es nicht */
cmistake(u, ord, 171, MSG_MAGIC);
}
else {
set_combatspell(u, sp, ord, level);
}
}
return 0;
}
int guard_on_cmd(unit * u, struct order *ord)
{
assert(getkeyword(ord) == K_GUARD);
assert(u);
assert(u->faction);
init_order_depr(ord);
/* GUARD NOT is handled in goard_off_cmd earlier in the turn */
if (getparam(u->faction->locale) == P_NOT) {
return 0;
}
if (fval(u, UFL_MOVED)) {
cmistake(u, ord, 187, MSG_EVENT);
}
else if (fval(u_race(u), RCF_ILLUSIONARY)) {
cmistake(u, ord, 95, MSG_EVENT);
}
else {
int err = can_start_guarding(u);
if (err == E_GUARD_OK) {
setguard(u, true);
}
else if (err == E_GUARD_TERRAIN) {
cmistake(u, ord, 2, MSG_EVENT);
}
else if (err == E_GUARD_UNARMED) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "unit_unarmed", ""));
}
else if (err == E_GUARD_FLEEING) {
cmistake(u, ord, 320, MSG_EVENT);
}
else if (err == E_GUARD_NEWBIE) {
cmistake(u, ord, 304, MSG_EVENT);
}
}
return 0;
}
void sinkships(struct region * r)
{
ship **shp = &r->ships;
while (*shp) {
ship *sh = *shp;
if (!sh->type->construction || sh->size >= sh->type->construction->maxsize) {
if (fval(r->terrain, SEA_REGION)) {
if (!ship_crewed(sh)) {
/* ship is at sea, but not enough people to control it */
double dmg = config_get_flt("rules.ship.damage.nocrewocean", 0.3);
damage_ship(sh, dmg);
}
}
else if (!ship_owner(sh)) {
/* any ship lying around without an owner slowly rots */
double dmg = config_get_flt("rules.ship.damage.nocrew", 0.05);
damage_ship(sh, dmg);
}
}
if (sh->damage >= sh->size * DAMAGE_SCALE) {
sink_ship(sh);
remove_ship(shp, sh);
}
if (*shp == sh)
shp = &sh->next;
}
}
void restack_units(void)
{
region *r;
for (r = regions; r; r = r->next) {
unit **up = &r->units;
bool sorted = false;
while (*up) {
unit *u = *up;
if (!fval(u, UFL_MARK)) {
struct order *ord;
for (ord = u->orders; ord; ord = ord->next) {
if (getkeyword(ord) == K_SORT) {
char token[128];
const char *s;
param_t p;
int id;
unit *v;
init_order_depr(ord);
s = gettoken(token, sizeof(token));
p = findparam(s, u->faction->locale);
id = getid();
v = findunit(id);
if (!v || v->faction != u->faction || v->region != r) {
cmistake(u, ord, 258, MSG_EVENT);
}
else if (v->building != u->building || v->ship != u->ship) {
cmistake(u, ord, 259, MSG_EVENT);
}
else if (u->building && building_owner(u->building) == u) {
cmistake(u, ord, 260, MSG_EVENT);
}
else if (u->ship && ship_owner(u->ship) == u) {
cmistake(u, ord, 260, MSG_EVENT);
}
else if (v == u) {
syntax_error(u, ord);
}
else {
switch (p) {
case P_AFTER:
*up = u->next;
u->next = v->next;
v->next = u;
fset(u, UFL_MARK);
sorted = true;
break;
case P_BEFORE:
if (v->ship && ship_owner(v->ship) == v) {
cmistake(v, ord, 261, MSG_EVENT);
}
else if (v->building && building_owner(v->building) == v) {
cmistake(v, ord, 261, MSG_EVENT);
}
else {
unit **vp = &r->units;
while (*vp != v)
vp = &(*vp)->next;
*vp = u;
*up = u->next;
u->next = v;
}
fset(u, UFL_MARK);
sorted = true;
break;
default:
/* TODO: syntax error message? */
break;
}
}
break;
}
}
}
if (u == *up)
up = &u->next;
}
if (sorted) {
unit *u;
for (u = r->units; u; u = u->next) {
freset(u, UFL_MARK);
}
}
}
}
/* blesses stone circles create an astral protection in the astral region
* above the shield, which prevents chaos suction and other spells.
* The shield is created when a magician enters the blessed stone circle,
* and lasts for as long as his skill level / 2 is, at no mana cost.
*
* TODO: this would be nicer in a btype->age function, but we don't have it.
*/
static void age_stonecircle(building *b) {
const struct resource_type *rtype = get_resourcetype(R_UNICORN);
region *r = b->region;
unit *u, *mage = NULL;
/* step 1: give unicorns to people in the building,
* find out if there's a magician in there. */
for (u = r->units; u; u = u->next) {
if (b == u->building && inside_building(u)) {
if (!mage && is_mage(u)) {
mage = u;
}
if (rtype) {
int n, unicorns = 0;
for (n = 0; n != u->number; ++n) {
if (chance(0.02)) {
i_change(&u->items, rtype->itype, 1);
++unicorns;
}
if (unicorns) {
ADDMSG(&u->faction->msgs, msg_message("scunicorn",
"unit amount rtype",
u, unicorns, rtype));
}
}
}
}
}
/* step 2: if there's a magician, and a connection to astral space, create the
* curse. */
if (get_astralplane()) {
region *rt = r_standard_to_astral(r);
if (mage && rt && !fval(rt->terrain, FORBIDDEN_REGION)) {
curse *c = get_curse(rt->attribs, &ct_astralblock);
if (!c) {
int sk = effskill(mage, SK_MAGIC, NULL);
if (sk > 0) {
int vig = sk;
int dur = (sk + 1) / 2;
float effect = 100;
/* the mage reactivates the circle */
c = create_curse(mage, &rt->attribs, &ct_astralblock,
vig, dur, effect, 0);
ADDMSG(&r->msgs,
msg_message("astralshield_activate", "region unit", r, mage));
}
}
else {
int sk = effskill(mage, SK_MAGIC, NULL);
if (c->duration < sk / 2) c->duration = sk / 2;
if (c->vigour < sk) c->vigour = sk;
}
}
}
}
static building *age_building(building * b)
{
if (is_building_type(b->type, "blessedstonecircle")) {
age_stonecircle(b);
}
a_age(&b->attribs, b);
handle_event(b->attribs, "timer", b);
return b;
}
static void age_region(region * r)
{
a_age(&r->attribs, r);
handle_event(r->attribs, "timer", r);
if (!r->land)
return;
morale_update(r);
}
static void ageing(void)
{
faction *f;
region *r;
/* altern spezieller Attribute, die eine Sonderbehandlung brauchen? */
for (r = regions; r; r = r->next) {
unit *u;
for (u = r->units; u; u = u->next) {
/* Goliathwasser */
int i = get_effect(u, oldpotiontype[P_STRONG]);
if (i > 0) {
if (i > u->number) i = u->number;
change_effect(u, oldpotiontype[P_STRONG], - i);
}
/* Berserkerblut */
i = get_effect(u, oldpotiontype[P_BERSERK]);
if (i > 0) {
if (i > u->number) i = u->number;
change_effect(u, oldpotiontype[P_BERSERK], - i);
}
if (u->attribs) {
curse * c = get_curse(u->attribs, &ct_oldrace);
if (c && curse_active(c)) {
if (c->duration == 1 && !(c_flags(c) & CURSE_NOAGE)) {
u_setrace(u, get_race(curse_geteffect_int(c)));
u->irace = NULL;
}
}
}
}
}
/* Borders */
age_borders();
/* Factions */
for (f = factions; f; f = f->next) {
a_age(&f->attribs, f);
handle_event(f->attribs, "timer", f);
}
/* Regionen */
for (r = regions; r; r = r->next) {
building **bp;
unit **up;
ship **sp;
age_region(r);
/* Einheiten */
for (up = &r->units; *up;) {
unit *u = *up;
a_age(&u->attribs, u);
if (u == *up)
handle_event(u->attribs, "timer", u);
if (u == *up) /*-V581 */
up = &(*up)->next;
}
/* Schiffe */
for (sp = &r->ships; *sp;) {
ship *s = *sp;
a_age(&s->attribs, s);
if (s == *sp)
handle_event(s->attribs, "timer", s);
if (s == *sp) /*-V581 */
sp = &(*sp)->next;
}
/* Gebaeude */
for (bp = &r->buildings; *bp;) {
building *b = *bp;
age_building(b);
if (b == *bp)
bp = &b->next;
}
if (rule_region_owners()) {
update_owners(r);
}
}
}
static int maxunits(const faction * f)
{
int flimit = rule_faction_limit();
int alimit = rule_alliance_limit();
UNUSED_ARG(f);
if (alimit == 0) {
return flimit;
}
if (flimit == 0) {
return alimit;
}
return (alimit > flimit) ? flimit : alimit;
}
int checkunitnumber(const faction * f, int add)
{
int alimit, flimit;
int fno = f->num_units + add;
flimit = rule_faction_limit();
if (flimit && fno > flimit) {
return 2;
}
alimit = rule_alliance_limit();
if (alimit) {
int unitsinalliance = alliance_size(f->alliance);
if (unitsinalliance + add > alimit) {
return 1;
}
}
return 0;
}
void maketemp_cmd(unit *u, order **olist)
{
order *makeord;
int err = checkunitnumber(u->faction, 1);
makeord = *olist;
if (err) {
if (err == 1) {
ADDMSG(&u->faction->msgs,
msg_feedback(u, makeord,
"too_many_units_in_alliance",
"allowed", maxunits(u->faction)));
}
else {
ADDMSG(&u->faction->msgs,
msg_feedback(u, makeord,
"too_many_units_in_faction",
"allowed", maxunits(u->faction)));
}
*olist = makeord->next;
makeord->next = NULL;
free_order(makeord);
while (*olist) {
keyword_t kwd;
order * ord = *olist;
*olist = ord->next;
ord->next = NULL;
kwd = getkeyword(ord);
free_order(ord);
if (kwd == K_END) {
break;
}
}
}
else {
char token[128];
const char *s;
int alias;
ship *sh;
unit *u2;
order **ordp, **oinsert;
#ifndef NDEBUG
keyword_t kwd = init_order_depr(makeord);
assert(kwd == K_MAKETEMP);
#endif
alias = getid();
s = gettoken(token, sizeof(token));
if (s && s[0] == '\0') {
/* empty name? => generate one */
s = NULL;
}
u2 = create_unit(u->region, u->faction, 0, u->faction->race, alias, s, u);
fset(u2, UFL_ISNEW);
usetalias(u2, alias);
sh = leftship(u);
if (sh) {
set_leftship(u2, sh);
}
unit_setstatus(u2, u->status);
/* copy orders until K_END from u to u2 */
ordp = &makeord->next;
oinsert = &u2->orders;
while (*ordp) {
order *ord = *ordp;
*ordp = ord->next;
if (getkeyword(ord) == K_END) {
ord->next = NULL;
free_order(ord);
break;
}
*oinsert = ord;
oinsert = &ord->next;
*oinsert = NULL;
}
*olist = *ordp;
makeord->next = NULL;
free_order(makeord);
if (!u2->orders) {
order *deford = default_order(u2->faction->locale);
if (deford) {
set_order(&u2->thisorder, NULL);
unit_addorder(u2, deford);
}
}
}
}
void new_units(void)
{
region *r;
unit *u;
/* neue einheiten werden gemacht und ihre befehle (bis zum "ende" zu
* ihnen rueberkopiert, damit diese einheiten genauso wie die alten
* einheiten verwendet werden koennen. */
for (r = regions; r; r = r->next) {
for (u = r->units; u; u = u->next) {
order **ordp = &u->orders;
/* this needs to happen very early in the game somewhere. since this is
** pretty much the first function called per turn, and I am lazy, I
** decree that it goes here */
if (u->flags & UFL_GUARD) {
fset(r, RF_GUARDED);
}
while (*ordp) {
order *ord = *ordp;
if (getkeyword(ord) == K_MAKETEMP) {
maketemp_cmd(u, ordp);
}
else {
ordp = &ord->next;
}
}
}
}
}
void update_long_order(unit * u)
{
order *ord;
bool exclusive = true;
keyword_t thiskwd = NOKEYWORD;
bool hunger = LongHunger(u);
freset(u, UFL_MOVED);
freset(u, UFL_LONGACTION);
/* check all orders for a potential new long order this round: */
for (ord = u->orders; ord; ord = ord->next) {
keyword_t kwd = getkeyword(ord);
if (kwd == NOKEYWORD) continue;
if (u->old_orders && is_repeated(kwd)) {
/* this new order will replace the old defaults */
free_orders(&u->old_orders);
}
/* hungry units do not get long orders: */
if (hunger) {
if (u->old_orders) {
/* keep looking for repeated orders that might clear the old_orders */
continue;
}
break;
}
if (is_long(kwd)) {
if (thiskwd == NOKEYWORD) {
/* we have found the (first) long order
* some long orders can have multiple instances: */
switch (kwd) {
/* Wenn gehandelt wird, darf kein langer Befehl ausgefuehrt
* werden. Da Handel erst nach anderen langen Befehlen kommt,
* muss das vorher abgefangen werden. Wir merken uns also
* hier, ob die Einheit handelt. */
case K_BUY:
case K_SELL:
case K_CAST:
/* non-exclusive orders can be used with others. BUY can be paired with SELL,
* CAST with other CAST orders. compatibility is checked once the second
* long order is analyzed (below). */
exclusive = false;
break;
default:
set_order(&u->thisorder, copy_order(ord));
break;
}
thiskwd = kwd;
}
else {
/* we have found a second long order. this is okay for some, but not all commands.
* u->thisorder is already set, and should not have to be updated. */
switch (kwd) {
case K_CAST:
if (thiskwd != K_CAST) {
cmistake(u, ord, 52, MSG_EVENT);
}
break;
case K_SELL:
if (thiskwd != K_SELL && thiskwd != K_BUY) {
cmistake(u, ord, 52, MSG_EVENT);
}
break;
case K_BUY:
if (thiskwd != K_SELL) {
cmistake(u, ord, 52, MSG_EVENT);
}
else {
thiskwd = K_BUY;
}
break;
default:
if (kwd > thiskwd) {
/* swap out thisorder for the new one */
cmistake(u, u->thisorder, 52, MSG_EVENT);
set_order(&u->thisorder, copy_order(ord));
}
else {
cmistake(u, ord, 52, MSG_EVENT);
}
break;
}
}
}
}
if (hunger) {
/* Hungernde Einheiten fuehren NUR den default-Befehl aus */
set_order(&u->thisorder, default_order(u->faction->locale));
}
else if (!exclusive) {
/* Wenn die Einheit handelt oder zaubert, muss der Default-Befehl geloescht werden. */
set_order(&u->thisorder, NULL);
}
}
static int use_item(unit * u, const item_type * itype, int amount, struct order *ord)
{
int i;
i = get_pooled(u, itype->rtype, GET_DEFAULT, amount);
if (amount > i) {
/* TODO: message? eg. "not enough %, using only %" */
amount = i;
}
if (amount == 0) {
return ENOITEM;
}
if (itype->flags & ITF_CANUSE) {
int result = callbacks.use_item(u, itype, amount, ord);
if (result > 0) {
use_pooled(u, itype->rtype, GET_DEFAULT, result);
}
return result;
}
return EUNUSABLE;
}
void monthly_healing(void)
{
region *r;
for (r = regions; r; r = r->next) {
unit *u;
double healingcurse = 0;
if (r->attribs) {
/* bonus zuruecksetzen */
curse *c = get_curse(r->attribs, &ct_healing);
if (c != NULL) {
healingcurse = curse_geteffect(c);
}
}
for (u = r->units; u; u = u->next) {
int umhp = unit_max_hp(u) * u->number;
double p = 1.0;
/* hp ueber Maximum bauen sich ab. Wird zb durch Elixier der Macht
* oder veraendertes Ausdauertalent verursacht */
if (u->hp > umhp) {
int diff = u->hp - umhp;
u->hp -= (int)ceil(diff / 2.0);
if (u->hp < umhp) {
u->hp = umhp;
}
continue;
}
if (u_race(u)->flags & RCF_NOHEAL)
continue;
if (fval(u, UFL_HUNGER))
continue;
if (fval(r->terrain, SEA_REGION) && u->ship == NULL
&& !(canswim(u) || canfly(u))) {
continue;
}
p *= u_heal_factor(u);
if (u->hp < umhp) {
double maxheal = fmax(u->number, umhp / 20.0);
int addhp;
if (active_building(u, bt_find("inn"))) {
p *= 1.5;
}
/* pro punkt 5% hoeher */
p *= (1.0 + healingcurse * 0.05);
maxheal = p * maxheal;
addhp = (int)maxheal;
maxheal -= addhp;
if (maxheal > 0.0 && chance(maxheal))
++addhp;
/* Aufaddieren der geheilten HP. */
if (umhp > u->hp + addhp) umhp = u->hp + addhp;
u->hp = umhp;
/* soll man an negativer regeneration sterben koennen? */
assert(u->hp > 0);
}
}
}
}
static void remove_exclusive(order ** ordp)
{
while (*ordp) {
order *ord = *ordp;
if (is_exclusive(ord)) {
*ordp = ord->next;
ord->next = NULL;
free_order(ord);
}
else {
ordp = &ord->next;
}
}
}
void defaultorders(void)
{
region *r;
assert(!keyword_disabled(K_DEFAULT));
for (r = regions; r; r = r->next) {
unit *u;
for (u = r->units; u; u = u->next) {
bool neworders = false;
order **ordp = &u->orders;
while (*ordp != NULL) {
order *ord = *ordp;
if (getkeyword(ord) == K_DEFAULT) {
char lbuf[8192];
order *new_order = 0;
const char *s;
init_order_depr(ord);
s = gettoken(lbuf, sizeof(lbuf));
if (s) {
new_order = parse_order(s, u->faction->locale);
}
*ordp = ord->next;
ord->next = NULL;
free_order(ord);
if (!neworders) {
/* lange Befehle aus orders und old_orders loeschen zu gunsten des neuen */
/* TODO: why only is_exclusive, not is_long? what about CAST, BUY, SELL? */
remove_exclusive(&u->orders);
remove_exclusive(&u->old_orders);
neworders = true;
ordp = &u->orders; /* we could have broken ordp */
}
if (new_order)
addlist(&u->old_orders, new_order);
}
else
ordp = &ord->next;
}
}
}
}
/* ************************************************************ */
/* GANZ WICHTIG! ALLE GEAENDERTEN SPRUECHE NEU ANZEIGEN */
/* GANZ WICHTIG! FUEGT AUCH NEUE ZAUBER IN DIE LISTE DER BEKANNTEN EIN */
/* ************************************************************ */
#define COMMONSPELLS 1 /* number of new common spells per level */
#define MAXMAGES 128 /* should be enough */
static int faction_getmages(faction * f, unit ** results, int numresults)
{
unit *u;
int maxlevel = 0, n = 0;
for (u = f->units; u; u = u->nextF) {
if (u->number > 0) {
struct sc_mage * mage = get_mage(u);
if (mage) {
int level = effskill(u, SK_MAGIC, NULL);
if (level > maxlevel) {
maxlevel = level;
}
if (n < numresults) {
results[n++] = u;
}
}
}
}
if (n < numresults) {
results[n] = 0;
}
return maxlevel;
}
static void copy_spells(const spellbook * src, spellbook * dst, int maxlevel)
{
assert(dst);
if (src && src->spells) {
selist *ql;
int qi;
for (qi = 0, ql = src->spells; ql; selist_advance(&ql, &qi, 1)) {
spellbook_entry * sbe = (spellbook_entry *)selist_get(ql, qi);
if (sbe->level <= maxlevel) {
spell *sp = spellref_get(&sbe->spref);
if (!spellbook_get(dst, sp)) {
spellbook_add(dst, sp, sbe->level);
}
}
}
}
}
static void show_new_spells(faction * f, int level, const spellbook *book)
{
if (book) {
selist *ql = book->spells;
int qi;
for (qi = 0; ql; selist_advance(&ql, &qi, 1)) {
spellbook_entry *sbe = (spellbook_entry *)selist_get(ql, qi);
if (sbe->level <= level) {
show_spell(f, sbe);
}
}
}
}
static void update_spells(void)
{
faction *f;
for (f = factions; f; f = f->next) {
if (f->magiegebiet != M_NONE && !is_monsters(f)) {
unit *mages[MAXMAGES];
int i;
int maxlevel = faction_getmages(f, mages, MAXMAGES);
struct spellbook *fsb;
if (maxlevel && FactionSpells()) {
spellbook * book = get_spellbook(magic_school[f->magiegebiet]);
if (!f->spellbook) {
f->spellbook = create_spellbook(NULL);
}
copy_spells(book, f->spellbook, maxlevel);
if (maxlevel > f->max_spelllevel) {
spellbook * common_spells = get_spellbook(magic_school[M_COMMON]);
pick_random_spells(f, maxlevel, common_spells, COMMONSPELLS);
}
}
fsb = faction_get_spellbook(f);
show_new_spells(f, maxlevel, fsb);
for (i = 0; i != MAXMAGES && mages[i]; ++i) {
unit * u = mages[i];
spellbook *sb = unit_get_spellbook(u);
if (sb != fsb) {
int level = effskill(u, SK_MAGIC, NULL);
show_new_spells(f, level, sb);
}
}
}
}
}
int use_cmd(unit * u, struct order *ord)
{
char token[128];
const char *t;
int n, err = ENOITEM;
const item_type *itype;
init_order_depr(ord);
t = gettoken(token, sizeof(token));
if (!t) {
cmistake(u, ord, 43, MSG_PRODUCE);
return err;
}
n = atoip((const char *)t);
if (n == 0) {
if (isparam(t, u->faction->locale, P_ANY)) {
/* BENUTZE ALLES Yanxspirit */
n = INT_MAX;
t = gettoken(token, sizeof(token));
}
else {
/* BENUTZE Yanxspirit */
n = 1;
}
}
else {
/* BENUTZE 42 Yanxspirit */
t = gettoken(token, sizeof(token));
}
itype = t ? finditemtype(t, u->faction->locale) : NULL;
if (itype != NULL) {
err = use_item(u, itype, n, ord);
}
switch (err) {
case ENOITEM:
cmistake(u, ord, 43, MSG_PRODUCE);
break;
case EUNUSABLE:
cmistake(u, ord, 76, MSG_PRODUCE);
break;
case ENOSKILL:
cmistake(u, ord, 50, MSG_PRODUCE);
break;
default:
/* no error */
break;
}
return err;
}
int pay_cmd(unit * u, struct order *ord)
{
if (!u->building) {
cmistake(u, ord, 6, MSG_EVENT);
}
else {
param_t p;
int id;
init_order_depr(ord);
p = getparam(u->faction->locale);
id = getid();
if (p == P_NOT) {
unit *owner = building_owner(u->building);
/* If the unit is not the owner of the building: error */
if (owner->no != u->no) {
/* The building is not ours error */
cmistake(u, ord, 1222, MSG_EVENT);
}
else {
/* If no building id is given or it is the id of our building, just set the do-not-pay flag */
if (id == 0 || id == u->building->no) {
u->building->flags |= BLD_DONTPAY;
}
else {
/* Find the building that matches to the given id*/
building *b = findbuilding(id);
/* If there is a building and it is in the same region as the unit continue, else: error */
if (b && b->region == u->region)
{
/* If the unit is also the building owner (this is true if rules.region_owner_pay_building */
/* is set and no one is in the building) set the do-not-pay flag for this building, else: error */
if (building_owner(b) == u) {
b->flags |= BLD_DONTPAY;
}
else
{
/* The building is not ours error */
cmistake(u, ord, 1222, MSG_EVENT);
}
}
else
{
/* Building not found error */
cmistake(u, ord, 6, MSG_PRODUCE);
}
}
}
}
}
return 0;
}
static int reserve_i(unit * u, struct order *ord, int flags)
{
if (u->number > 0) {
char token[128];
int use, count, para;
const item_type *itype;
const char *s;
init_order_depr(ord);
s = gettoken(token, sizeof(token));
count = s ? atoip(s) : 0;
para = findparam(s, u->faction->locale);
if (count == 0 && para == P_EACH) {
count = getint() * u->number;
}
s = gettoken(token, sizeof(token));
itype = s ? finditemtype(s, u->faction->locale) : 0;
if (itype == NULL)
return 0;
set_resvalue(u, itype, 0); /* make sure the pool is empty */
if (count == 0 && para == P_ANY) {
count = get_resource(u, itype->rtype);
}
use = use_pooled(u, itype->rtype, flags, count);
if (use) {
set_resvalue(u, itype, use);
change_resource(u, itype->rtype, use);
return use;
}
}
return 0;
}
int reserve_cmd(unit * u, struct order *ord) {
return reserve_i(u, ord, GET_DEFAULT);
}
int reserve_self(unit * u, struct order *ord) {
return reserve_i(u, ord, GET_RESERVE | GET_SLACK);
}
int claim_cmd(unit * u, struct order *ord)
{
char token[128];
const char *t;
int n = 1;
const item_type *itype = 0;
init_order_depr(ord);
t = gettoken(token, sizeof(token));
if (t) {
n = atoip((const char *)t);
if (n == 0) {
n = 1;
}
else {
t = gettoken(token, sizeof(token));
}
if (t) {
itype = finditemtype(t, u->faction->locale);
}
}
if (itype) {
item **iclaim = i_find(&u->faction->items, itype);
if (iclaim && *iclaim) {
if (n > (*iclaim)->number) n = (*iclaim)->number;
i_change(iclaim, itype, -n);
i_change(&u->items, itype, n);
}
}
else {
cmistake(u, ord, 43, MSG_PRODUCE);
}
return 0;
}
enum {
PROC_THISORDER = 1 << 0,
PROC_LONGORDER = 1 << 1
};
typedef enum processor_t { PR_GLOBAL, PR_REGION_PRE, PR_UNIT, PR_ORDER, PR_REGION_POST } processor_t;
typedef struct processor {
struct processor *next;
int priority;
processor_t type;
unsigned int flags;
union {
struct {
keyword_t kword;
int(*process) (struct unit *, struct order *);
} per_order;
struct {
void(*process) (struct unit *);
} per_unit;
struct {
void(*process) (struct region *);
} per_region;
struct {
void(*process) (void);
} global;
} data;
const char *name;
} processor;
static processor *processors;
static processor *add_proc(int priority, const char *name, processor_t type)
{
processor **pproc = &processors;
processor *proc;
while (*pproc) {
proc = *pproc;
if (proc->priority > priority)
break;
else if (proc->priority == priority && proc->type >= type)
break;
pproc = &proc->next;
}
proc = (processor *)malloc(sizeof(processor));
if (!proc) abort();
proc->priority = priority;
proc->type = type;
proc->name = name;
proc->next = *pproc;
*pproc = proc;
return proc;
}
void
add_proc_order(int priority, keyword_t kword, int(*parser) (struct unit *,
struct order *), unsigned int flags, const char *name)
{
if (!keyword_disabled(kword)) {
processor *proc = add_proc(priority, name, PR_ORDER);
if (proc) {
proc->data.per_order.process = parser;
proc->data.per_order.kword = kword;
proc->flags = flags;
}
}
}
void add_proc_global(int priority, void(*process) (void), const char *name)
{
processor *proc = add_proc(priority, name, PR_GLOBAL);
if (proc) {
proc->data.global.process = process;
}
}
void add_proc_region(int priority, void(*process) (region *), const char *name)
{
processor *proc = add_proc(priority, name, PR_REGION_PRE);
if (proc) {
proc->data.per_region.process = process;
}
}
void
add_proc_postregion(int priority, void(*process) (region *), const char *name)
{
processor *proc = add_proc(priority, name, PR_REGION_POST);
if (proc) {
proc->data.per_region.process = process;
}
}
void add_proc_unit(int priority, void(*process) (unit *), const char *name)
{
processor *proc = add_proc(priority, name, PR_UNIT);
if (proc) {
proc->data.per_unit.process = process;
}
}
bool long_order_allowed(const unit *u)
{
const region *r = u->region;
if (fval(u, UFL_LONGACTION)) {
/* this message was already given in laws.update_long_order
cmistake(u, ord, 52, MSG_PRODUCE);
*/
return false;
}
else if (fval(r->terrain, SEA_REGION)
&& u_race(u) != get_race(RC_AQUARIAN)
&& !(u_race(u)->flags & RCF_SWIM)) {
/* error message disabled by popular demand */
return false;
}
return true;
}
/* per priority, execute processors in order from PR_GLOBAL down to PR_ORDER */
void process(void)
{
processor *proc = processors;
faction *f;
while (proc) {
int prio = proc->priority;
region *r;
processor *pglobal = proc;
log_debug("- Step %u", prio);
while (proc && proc->priority == prio) {
if (proc->name)
log_debug(" - %s", proc->name);
proc = proc->next;
}
while (pglobal && pglobal->priority == prio && pglobal->type == PR_GLOBAL) {
pglobal->data.global.process();
pglobal = pglobal->next;
}
if (pglobal == NULL || pglobal->priority != prio)
continue;
for (r = regions; r; r = r->next) {
unit *u;
processor *pregion = pglobal;
while (pregion && pregion->priority == prio
&& pregion->type == PR_REGION_PRE) {
pregion->data.per_region.process(r);
pregion = pregion->next;
}
if (pregion == NULL || pregion->priority != prio)
continue;
if (r->units) {
for (u = r->units; u; u = u->next) {
processor *porder, *punit = pregion;
while (punit && punit->priority == prio && punit->type == PR_UNIT) {
punit->data.per_unit.process(u);
punit = punit->next;
}
if (punit == NULL || punit->priority != prio)
continue;
porder = punit;
while (porder && porder->priority == prio && porder->type == PR_ORDER) {
order **ordp = &u->orders;
if (porder->flags & PROC_THISORDER)
ordp = &u->thisorder;
while (*ordp) {
order *ord = *ordp;
if (getkeyword(ord) == porder->data.per_order.kword) {
if (porder->flags & PROC_LONGORDER) {
if (u->number == 0) {
ord = NULL;
}
else if (u_race(u) == get_race(RC_INSECT)
&& r_insectstalled(r)
&& !is_cursed(u->attribs, &ct_insectfur)) {
ord = NULL;
}
else if (LongHunger(u)) {
cmistake(u, ord, 224, MSG_MAGIC);
ord = NULL;
}
else if (!long_order_allowed(u)) {
ord = NULL;
}
}
if (ord) {
porder->data.per_order.process(u, ord);
if (!u->orders) {
/* GIVE UNIT or QUIT delete all orders of the unit, stop */
break;
}
}
}
if (!ord || *ordp == ord)
ordp = &(*ordp)->next;
}
porder = porder->next;
}
}
}
while (pregion && pregion->priority == prio
&& pregion->type != PR_REGION_POST) {
pregion = pregion->next;
}
while (pregion && pregion->priority == prio
&& pregion->type == PR_REGION_POST) {
pregion->data.per_region.process(r);
pregion = pregion->next;
}
if (pregion == NULL || pregion->priority != prio)
continue;
}
}
log_debug("\n - Leere Gruppen loeschen...\n");
for (f = factions; f; f = f->next) {
group **gp = &f->groups;
while (*gp) {
group *g = *gp;
if (g->members == 0) {
*gp = g->next;
free_group(g);
}
else
gp = &g->next;
}
}
}
int armedmen(const unit * u, bool siege_weapons)
{
item *itm;
int n = 0;
if (!(u_race(u)->flags & RCF_NOWEAPONS)) {
if (effskill(u, SK_WEAPONLESS, NULL) >= 1) {
/* kann ohne waffen bewachen: fuer drachen */
n = u->number;
}
else {
/* alle Waffen werden gezaehlt, und dann wird auf die Anzahl
* Personen minimiert */
for (itm = u->items; itm; itm = itm->next) {
const weapon_type *wtype = resource2weapon(itm->type->rtype);
if (wtype == NULL || (!siege_weapons && (wtype->flags & WTF_SIEGE)))
continue;
if (effskill(u, wtype->skill, NULL) >= 1)
n += itm->number;
if (n >= u->number)
break;
}
if (n > u->number) n = u->number;
}
}
return n;
}
static void enter_1(region * r)
{
do_enter(r, 0);
}
static void enter_2(region * r)
{
do_enter(r, 1);
}
bool help_enter(unit *uo, unit *u) {
return uo->faction == u->faction || alliedunit(uo, u->faction, HELP_GUARD);
}
static void do_force_leave(region *r) {
force_leave(r, NULL);
}
bool rule_force_leave(int flags) {
int rules = config_get_int("rules.owners.force_leave", 0);
return (rules&flags) == flags;
}
void init_processor(void)
{
int p;
while (processors) {
processor * next = processors->next;
free(processors);
processors = next;
}
p = 10;
add_proc_global(p, nmr_warnings, "NMR Warnings");
add_proc_global(p, new_units, "Neue Einheiten erschaffen");
p += 10;
add_proc_unit(p, update_long_order, "Langen Befehl aktualisieren");
add_proc_order(p, K_BANNER, banner_cmd, 0, NULL);
add_proc_order(p, K_EMAIL, email_cmd, 0, NULL);
add_proc_order(p, K_PASSWORD, password_cmd, 0, NULL);
add_proc_order(p, K_SEND, send_cmd, 0, NULL);
add_proc_order(p, K_GROUP, group_cmd, 0, NULL);
p += 10;
add_proc_order(p, K_URSPRUNG, origin_cmd, 0, NULL);
add_proc_order(p, K_ALLY, ally_cmd, 0, NULL);
add_proc_order(p, K_PREFIX, prefix_cmd, 0, NULL);
add_proc_order(p, K_SETSTEALTH, setstealth_cmd, 0, NULL);
add_proc_order(p, K_STATUS, status_cmd, 0, NULL);
add_proc_order(p, K_COMBATSPELL, combatspell_cmd, 0, NULL);
add_proc_order(p, K_DISPLAY, display_cmd, 0, NULL);
add_proc_order(p, K_NAME, name_cmd, 0, NULL);
add_proc_order(p, K_GUARD, guard_off_cmd, 0, NULL);
add_proc_order(p, K_RESHOW, reshow_cmd, 0, NULL);
if (config_get_int("rules.alliances", 0) == 1) {
p += 10;
add_proc_global(p, alliance_cmd, NULL);
}
p += 10;
add_proc_region(p, do_contact, "Kontaktieren");
add_proc_order(p, K_MAIL, mail_cmd, 0, "Botschaften");
p += 10; /* all claims must be done before we can USE */
add_proc_region(p, enter_1, "Betreten (1. Versuch)"); /* for GIVE CONTROL */
add_proc_order(p, K_USE, use_cmd, 0, "Benutzen");
add_proc_order(p, K_QUIT, quit_cmd, 0, "Stirb");
p += 10; /* in case it has any effects on alliance victories */
add_proc_order(p, K_GIVE, give_control_cmd, 0, "GIB KOMMANDO");
p += 10; /* in case it has any effects on alliance victories */
add_proc_order(p, K_LEAVE, leave_cmd, 0, "Verlassen");
p += 10;
add_proc_region(p, enter_1, "Betreten (2. Versuch)"); /* to allow a buildingowner to enter the castle pre combat */
p += 10;
add_proc_global(p, do_battles, "Attackieren");
p += 10; /* can't allow reserve before siege (weapons) */
add_proc_region(p, enter_1, "Betreten (3. Versuch)"); /* to claim a castle after a victory and to be able to DESTROY it in the same turn */
if (config_get_int("rules.reserve.twophase", 0)) {
add_proc_order(p, K_RESERVE, reserve_self, 0, "RESERVE (self)");
p += 10;
}
add_proc_order(p, K_RESERVE, reserve_cmd, 0, "RESERVE (all)");
add_proc_order(p, K_CLAIM, claim_cmd, 0, NULL);
add_proc_unit(p, follow_unit, "Folge auf Einheiten setzen");
p += 10; /* rest rng again before economics */
if (rule_force_leave(FORCE_LEAVE_ALL)) {
add_proc_region(p, do_force_leave, "kick non-allies out of buildings/ships");
}
add_proc_region(p, economics, "Geben, Vergessen");
add_proc_region(p+1, recruit, "Rekrutieren");
add_proc_region(p+2, destroy, "Zerstoeren");
/* all recruitment must be finished before we can calculate
* promotion cost of ability */
p += 10;
add_proc_global(p, quit, "Sterben");
add_proc_order(p, K_PROMOTION, promotion_cmd, 0, "Heldenbefoerderung");
p += 10;
if (!keyword_disabled(K_PAY)) {
add_proc_order(p, K_PAY, pay_cmd, 0, "Gebaeudeunterhalt (BEZAHLE NICHT)");
}
add_proc_postregion(p, maintain_buildings, "Gebaeudeunterhalt");
if (!keyword_disabled(K_CAST)) {
p += 10;
add_proc_global(p, magic, "Zaubern");
}
p += 10;
add_proc_region(p, do_autostudy, "study automation");
add_proc_order(p, K_TEACH, teach_cmd, PROC_THISORDER | PROC_LONGORDER,
"Lehren");
p += 10;
add_proc_order(p, K_STUDY, study_cmd, PROC_THISORDER | PROC_LONGORDER,
"Lernen");
p += 10;
add_proc_order(p, K_MAKE, make_cmd, PROC_THISORDER | PROC_LONGORDER,
"Produktion");
add_proc_postregion(p, produce, "Arbeiten, Handel, Rekruten");
add_proc_postregion(p, split_allocations, "Produktion II");
p += 10;
add_proc_region(p, enter_2, "Betreten (4. Versuch)"); /* Once again after QUIT */
p += 10;
add_proc_region(p, sinkships, "Schiffe sinken");
p += 10;
add_proc_global(p, movement, "Bewegungen");
if (config_get_int("work.auto", 0)) {
p += 10;
add_proc_region(p, auto_work, "Arbeiten (auto)");
}
p += 10;
add_proc_order(p, K_GUARD, guard_on_cmd, 0, "Bewache (an)");
p += 10;
add_proc_unit(p, monster_kills_peasants,
"Monster fressen und vertreiben Bauern");
p += 10;
add_proc_global(p, randomevents, "Zufallsereignisse");
p += 10;
add_proc_global(p, monthly_healing, "Regeneration (HP)");
add_proc_global(p, regenerate_aura, "Regeneration (Aura)");
if (!keyword_disabled(K_DEFAULT)) {
add_proc_global(p, defaultorders, "Defaults setzen");
}
add_proc_global(p, demographics, "Nahrung, Seuchen, Wachstum, Wanderung");
if (!keyword_disabled(K_SORT)) {
p += 10;
add_proc_global(p, restack_units, "Einheiten sortieren");
}
if (!keyword_disabled(K_NUMBER)) {
add_proc_order(p, K_NUMBER, renumber_cmd, 0, "Neue Nummern (Einheiten)");
p += 10;
add_proc_global(p, renumber_factions, "Neue Nummern");
}
}
static void reset_game(void)
{
region *r;
faction *f;
for (r = regions; r; r = r->next) {
unit *u;
building *b;
r->flags &= RF_SAVEMASK;
for (u = r->units; u; u = u->next) {
u->flags &= UFL_SAVEMASK;
}
for (b = r->buildings; b; b = b->next) {
b->flags &= BLD_SAVEMASK;
}
if (r->land && r->land->ownership && r->land->ownership->owner) {
faction *owner = r->land->ownership->owner;
if (owner == get_monsters()) {
/* some compat-fix, i believe. */
owner = update_owners(r);
}
if (owner) {
fset(r, RF_GUARDED);
}
}
}
for (f = factions; f; f = f->next) {
f->flags &= FFL_SAVEMASK;
}
}
void turn_begin(void)
{
int handle_start = first_turn();
assert(turn >= 0);
if (turn < handle_start) {
/* this should only happen during tests */
turn = handle_start;
}
++turn;
reset_game();
}
void turn_process(void)
{
init_processor();
process();
if (markets_module()) {
do_markets();
}
}
void turn_end(void)
{
log_info(" - Attribute altern");
ageing();
remove_empty_units();
/* must happen AFTER age, because that would destroy them right away */
if (config_get_int("modules.wormhole", 0)) {
wormholes_update();
}
/* immer ausfuehren, wenn neue Sprueche dazugekommen sind, oder sich
* Beschreibungen geaendert haben */
update_spells();
}
/** determine if unit can be seen by faction
* @param f -- the observiong faction
* @param u -- the unit that is observed
* @param r -- the region that u is obesrved from (see below)
* @param m -- terrain modifier to stealth
*
* r kann != u->region sein, wenn es um Durchreisen geht,
* oder Zauber (sp_generous, sp_fetchastral).
* Es muss auch niemand aus f in der region sein, wenn sie vom Turm
* erblickt wird */
bool
cansee(const faction * f, const region * r, const unit * u, int modifier)
{
int stealth, rings;
if (u->faction == f || omniscient(f)) {
return true;
}
else if (fval(u_race(u), RCF_INVISIBLE)) {
return false;
}
else if (u->number == 0) {
attrib *a = a_find(u->attribs, &at_creator);
if (a) { /* u is an empty temporary unit. In this special case
we look at the creating unit. */
u = (unit *)a->data.v;
}
else {
return false;
}
}
/* simple visibility, just gotta have a viewer in the region to see 'em */
if (leftship(u) || is_guard(u) || u->building || u->ship) {
return true;
}
rings = invisible(u, NULL);
stealth = eff_stealth(u, r) - modifier;
unit *u2;
for (u2 = r->units; u2; u2 = u2->next) {
if (u2->faction == f) {
if (rings < u->number || invisible(u, u2) < u->number) {
if (skill_enabled(SK_PERCEPTION)) {
int observation = effskill(u2, SK_PERCEPTION, NULL);
if (observation >= stealth) {
return true;
}
}
else {
return true;
}
}
}
}
return (rings <= 0 && stealth <= 0);
}
bool cansee_unit(const unit * u, const unit * target, int modifier)
/* target->region kann != u->region sein, wenn es um durchreisen geht */
{
if (fval(u_race(target), RCF_INVISIBLE) || target->number == 0)
return false;
else if (target->faction == u->faction)
return true;
else {
int n, rings;
if (is_guard(target) || target->building
|| target->ship) {
return true;
}
n = eff_stealth(target, target->region) - modifier;
rings = invisible(target, NULL);
if (rings == 0 && n <= 0) {
return true;
}
if (rings && invisible(target, u) >= target->number) {
return false;
}
if (skill_enabled(SK_PERCEPTION)) {
int o = effskill(u, SK_PERCEPTION, target->region);
if (o >= n) {
return true;
}
}
else {
return true;
}
}
return false;
}
bool
cansee_durchgezogen(const faction * f, const region * r, const unit * u,
int modifier)
/* r kann != u->region sein, wenn es um durchreisen geht */
/* und es muss niemand aus f in der region sein, wenn sie vom Turm
* erblickt wird */
{
unit *u2;
if (fval(u_race(u), RCF_INVISIBLE) || u->number == 0)
return false;
else if (u->faction == f)
return true;
else {
int rings, n;
if (is_guard(u) || u->building || u->ship) {
return true;
}
n = eff_stealth(u, r) - modifier;
rings = invisible(u, NULL);
if (rings == 0 && n <= 0) {
return true;
}
for (u2 = r->units; u2; u2 = u2->next) {
if (u2->faction == f) {
int o;
if (rings && invisible(u, u2) >= u->number)
continue;
o = effskill(u2, SK_PERCEPTION, NULL);
if (o >= n) {
return true;
}
}
}
}
return false;
}
bool
seefaction(const faction * f, const region * r, const unit * u, int modifier)
{
if (((f == u->faction) || !fval(u, UFL_ANON_FACTION))
&& cansee(f, r, u, modifier))
return true;
return false;
}
Reference in New Issue View Git Blame Copy Permalink