Marc/server
1
0
Fork 0
forked from github/server
Code Issues Pull requests Projects Releases Wiki Activity
server/src/battle.c
Enno Rehling e80701ef35 Allow alternative names for some spells.
2020-08-16 16:00:28 +02:00

4054 lines
122 KiB
C
Raw Blame History

#ifdef _MSC_VER
#include <platform.h>
#endif
#include <kernel/config.h>
#include "battle.h"
#include "alchemy.h"
#include "guard.h"
#include "laws.h"
#include "monsters.h"
#include "move.h"
#include "skill.h"
#include "study.h"
#include "spy.h"
#include <spells/buildingcurse.h>
#include <spells/regioncurse.h>
#include <spells/unitcurse.h>
#include <kernel/ally.h>
#include <kernel/alliance.h>
#include <kernel/build.h>
#include <kernel/building.h>
#include <kernel/curse.h>
#include <kernel/equipment.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/race.h>
#include <kernel/region.h>
#include <kernel/ship.h>
#include <kernel/terrain.h>
#include <kernel/unit.h>
#include <kernel/spell.h>
#include <reports.h>
/* attributes includes */
#include <attributes/key.h>
#include <attributes/racename.h>
#include <attributes/otherfaction.h>
/* util includes */
#include <util/assert.h>
#include <kernel/attrib.h>
#include <util/base36.h>
#include <util/language.h>
#include <util/lists.h>
#include <util/log.h>
#include <util/macros.h>
#include <util/parser.h>
#include <util/strings.h>
#include <util/rand.h>
#include <util/rng.h>
#include <selist.h>
/* libc includes */
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#define TACTICS_BONUS 1 /* when undefined, we have a tactics round. else this is the bonus tactics give */
#define TACTICS_MODIFIER 1 /* modifier for generals in the front/rear */
#define CATAPULT_INITIAL_RELOAD 4 /* erster schuss in runde 1 + rng_int() % INITIAL */
#define BASE_CHANCE 70 /* 70% Basis-Ueberlebenschance */
#define TDIFF_CHANGE 5 /* 5% hoeher pro Stufe */
#define DAMAGE_QUOTIENT 2 /* damage += skilldiff/DAMAGE_QUOTIENT */
#define DEBUG_SELECT /* should be disabled if select_enemy works */
typedef enum combatmagic {
DO_PRECOMBATSPELL,
DO_POSTCOMBATSPELL
} combatmagic_t;
#define MINSPELLRANGE 1
#define MAXSPELLRANGE 7
#define ROW_FACTOR 3 /* factor for combat row advancement rule */
#define EFFECT_PANIC_SPELL 25
#define TROLL_REGENERATION 0.10
/* Nach dem alten System: */
static int missile_range[2] = { FIGHT_ROW, BEHIND_ROW };
static int melee_range[2] = { FIGHT_ROW, FIGHT_ROW };
const troop no_troop = { 0, 0 };
#define FORMULA_ORIG 0
#define FORMULA_NEW 1
#define LOOT_MONSTERS (1<<0)
#define LOOT_SELF (1<<1) /* code is mutually exclusive with LOOT_OTHERS */
#define LOOT_OTHERS (1<<2)
#define LOOT_KEEPLOOT (1<<4)
#define DAMAGE_CRITICAL (1<<0)
#define DAMAGE_SKILL_BONUS (1<<4)
static int max_turns;
static int rule_damage;
static int rule_loot;
static int flee_chance_max_percent;
static int flee_chance_base;
static int flee_chance_skill_bonus;
static int skill_formula;
static int rule_cavalry_skill;
static int rule_population_damage;
static unsigned char rule_hero_speed;
static bool rule_anon_battle;
static bool rule_igjarjuk_curse;
static int rule_goblin_bonus;
static int rule_tactics_formula;
static int rule_nat_armor;
static int rule_cavalry_mode;
static int rule_vampire;
static const item_type *it_mistletoe;
/** initialize rules from configuration.
*/
static void init_rules(void)
{
it_mistletoe = it_find("mistletoe");
flee_chance_skill_bonus = config_get_int("rules.combat.flee_chance_bonus", 5);
flee_chance_base = config_get_int("rules.combat.flee_chance_base", 20);
flee_chance_max_percent = config_get_int("rules.combat.flee_chance_limit", 90);
rule_nat_armor = config_get_int("rules.combat.nat_armor", 0);
rule_tactics_formula = config_get_int("rules.tactics.formula", 0);
rule_goblin_bonus = config_get_int("rules.combat.goblinbonus", 10);
rule_hero_speed = (unsigned char)config_get_int("rules.combat.herospeed", 10);
rule_population_damage = config_get_int("rules.combat.populationdamage", 20);
rule_anon_battle = config_get_int("rules.stealth.anon_battle", 1) != 0;
rule_igjarjuk_curse = config_get_int("rules.combat.igjarjuk_curse", 0) != 0;
rule_cavalry_mode = config_get_int("rules.cavalry.mode", 1);
rule_cavalry_skill = config_get_int("rules.cavalry.skill", 2);
rule_vampire = config_get_int("rules.combat.demon_vampire", 0);
rule_loot = config_get_int("rules.combat.loot",
LOOT_MONSTERS | LOOT_OTHERS | LOOT_KEEPLOOT);
/* new formula to calculate to-hit-chance */
skill_formula = config_get_int("rules.combat.skill_formula",
FORMULA_ORIG);
/* maximum number of combat turns */
max_turns = config_get_int("rules.combat.turns", 5);
/* damage calculation */
if (config_get_int("rules.combat.critical", 1)) {
rule_damage |= DAMAGE_CRITICAL;
}
if (config_get_int("rules.combat.skill_bonus", 1)) {
rule_damage |= DAMAGE_SKILL_BONUS;
}
}
static int army_index(side * s)
{
return s->index;
}
const char *sidename(const side * s)
{
#define SIDENAMEBUFLEN 256
static int bufno; /* STATIC_XCALL: used across calls */
static char sidename_buf[4][SIDENAMEBUFLEN]; /* STATIC_RESULT: used for return, not across calls */
bufno = bufno % 4;
str_strlcpy(sidename_buf[bufno], factionname(s->stealthfaction ? s->stealthfaction : s->faction), SIDENAMEBUFLEN);
return sidename_buf[bufno++];
}
static const char *sideabkz(side * s, bool truename)
{
static char sideabkz_buf[8]; /* STATIC_RESULT: used for return, not across calls */
const faction *f = (s->stealthfaction
&& !truename) ? s->stealthfaction : s->faction;
str_strlcpy(sideabkz_buf, itoa36(f->no), sizeof(sideabkz_buf));
return sideabkz_buf;
}
void battle_message_faction(battle * b, faction * f, struct message *m)
{
region *r = b->region;
assert(f);
if (f->battles == NULL || f->battles->r != r) {
struct bmsg *bm = (struct bmsg *)calloc(1, sizeof(struct bmsg));
assert_alloc(bm);
bm->next = f->battles;
f->battles = bm;
bm->r = r;
}
add_message(&f->battles->msgs, m);
}
void message_all(battle * b, message * m)
{
bfaction *bf;
for (bf = b->factions; bf; bf = bf->next) {
assert(bf->faction);
battle_message_faction(b, bf->faction, m);
}
}
static void fbattlerecord(battle * b, faction * f, const char *s)
{
message *m = msg_message("battle_msg", "string", s);
battle_message_faction(b, f, m);
msg_release(m);
}
/* being an enemy or a friend is (and must always be!) symmetrical */
#define enemy_i(as, di) (as->relations[di]&E_ENEMY)
#define friendly_i(as, di) (as->relations[di]&E_FRIEND)
#define enemy(as, ds) (as->relations[ds->index]&E_ENEMY)
#define friendly(as, ds) (as->relations[ds->index]&E_FRIEND)
static bool set_enemy(side * as, side * ds, bool attacking)
{
int i;
assert(as && ds);
for (i = 0; i != MAXSIDES; ++i) {
if (ds->enemies[i] == NULL)
ds->enemies[i] = as;
if (ds->enemies[i] == as)
break;
}
for (i = 0; i != MAXSIDES; ++i) {
if (as->enemies[i] == NULL)
as->enemies[i] = ds;
if (as->enemies[i] == ds)
break;
}
assert(i != MAXSIDES);
if (attacking)
as->relations[ds->index] |= E_ATTACKING;
if ((ds->relations[as->index] & E_ENEMY) == 0) {
/* enemy-relation are always symmetrical */
assert((as->relations[ds->index] & (E_ENEMY | E_FRIEND)) == 0);
ds->relations[as->index] |= E_ENEMY;
as->relations[ds->index] |= E_ENEMY;
return true;
}
return false;
}
static void set_friendly(side * as, side * ds)
{
assert((as->relations[ds->index] & E_ENEMY) == 0);
ds->relations[as->index] |= E_FRIEND;
as->relations[ds->index] |= E_FRIEND;
}
static bool alliedside(const side * s, const faction * f, int mode)
{
if (s->faction == f) {
return true;
}
if (s->group) {
return alliedgroup(s->faction, f, s->group, mode) != 0;
}
return alliedfaction(s->faction, f, mode) != 0;
}
static int dead_fighters(const fighter * df)
{
return df->unit->number - df->alive - df->run.number;
}
fighter *select_corpse(battle * b, fighter * af)
/* Waehlt eine Leiche aus, der af hilft. casualties ist die Anzahl der
* Toten auf allen Seiten (im Array). Wenn af == NULL, wird die
* Parteizugehoerigkeit ignoriert, und irgendeine Leiche genommen.
*
* Untote werden nicht ausgewaehlt (casualties, not dead) */
{
int si, maxcasualties = 0;
fighter *df;
for (si = 0; si != b->nsides; ++si) {
side *s = b->sides + si;
if (af == NULL || (!enemy_i(af->side, si) && alliedside(af->side, s->faction, HELP_FIGHT))) {
maxcasualties += s->casualties;
}
}
if (maxcasualties > 0) {
int di = (int)(rng_int() % maxcasualties);
side *s;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
for (df = s->fighters; df; df = df->next) {
/* Geflohene haben auch 0 hp, duerfen hier aber nicht ausgewaehlt
* werden! */
int dead = dead_fighters(df);
const race *rc = u_race(df->unit);
/* Untote sinc f<>r immer tot */
if (!undeadrace(rc)) {
if (af && !helping(af->side, df->side))
continue;
if (di < dead) {
return df;
}
di -= dead;
}
}
}
}
return NULL;
}
bool helping(const side * as, const side * ds)
{
if (as->faction == ds->faction)
return true;
return (!enemy(as, ds) && alliedside(as, ds->faction, HELP_FIGHT));
}
int statusrow(int status)
{
switch (status) {
case ST_AGGRO:
case ST_FIGHT:
return FIGHT_ROW;
case ST_BEHIND:
case ST_CHICKEN:
return BEHIND_ROW;
case ST_AVOID:
return AVOID_ROW;
case ST_FLEE:
return FLEE_ROW;
default:
assert(!"unknown combatrow");
}
return FIGHT_ROW;
}
static double hpflee(int status)
/* if hp drop below this percentage, run away */
{
switch (status) {
case ST_AGGRO:
return 0.0;
case ST_FIGHT:
case ST_BEHIND:
return 0.2;
case ST_CHICKEN:
case ST_AVOID:
return 0.9;
case ST_FLEE:
return 1.0;
default:
assert(!"unknown combatrow");
}
return 0.0;
}
static int get_row(const side * s, int row, const side * vs)
{
bool counted[MAXSIDES];
int enemyfront = 0;
int line, result;
int retreat = 0;
int size[NUMROWS];
battle *b = s->battle;
memset(counted, 0, sizeof(counted));
memset(size, 0, sizeof(size));
for (line = FIRST_ROW; line != NUMROWS; ++line) {
int si, sa_i;
/* how many enemies are there in the first row? */
for (si = 0; s->enemies[si]; ++si) {
side *se = s->enemies[si];
if (se->size[line] > 0) {
enemyfront += se->size[line];
/* - s->nonblockers[line] (nicht, weil angreifer) */
}
}
for (sa_i = 0; sa_i != b->nsides; ++sa_i) {
side *sa = b->sides + sa_i;
/* count people that like me, but don't like my enemy */
if (friendly_i(s, sa_i) && enemy_i(vs, sa_i)) {
if (!counted[sa_i]) {
int i;
for (i = 0; i != NUMROWS; ++i) {
size[i] += sa->size[i] - sa->nonblockers[i];
}
counted[sa_i] = true;
}
}
}
if (enemyfront)
break;
}
if (enemyfront) {
int front = 0;
for (line = FIRST_ROW; line != NUMROWS; ++line) {
front += size[line];
if (!front || front < enemyfront / ROW_FACTOR)
++retreat;
else if (front)
break;
}
}
/* every entry in the size[] array means someone trying to defend us.
* 'retreat' is the number of rows falling.
*/
result = row - retreat;
if (result < FIRST_ROW) result = FIRST_ROW;
return result;
}
int get_unitrow(const fighter * af, const side * vs)
{
int row = statusrow(af->status);
if (vs == NULL) {
int i;
for (i = FIGHT_ROW; i != row; ++i)
if (af->side->size[i])
break;
return FIGHT_ROW + (row - i);
}
else {
battle *b = vs->battle;
if (row != b->rowcache.row || b->alive != b->rowcache.alive
|| af->side != b->rowcache.as || vs != b->rowcache.vs) {
b->rowcache.alive = b->alive;
b->rowcache.as = af->side;
b->rowcache.vs = vs;
b->rowcache.row = row;
b->rowcache.result = get_row(af->side, row, vs);
return b->rowcache.result;
}
return b->rowcache.result;
}
}
static void reportcasualties(battle * b, fighter * fig, int dead)
{
struct message *m;
region *r = NULL;
if (fig->alive == fig->unit->number)
return;
m = msg_message("casualties", "unit runto run alive fallen",
fig->unit, r, fig->run.number, fig->alive, dead);
message_all(b, m);
msg_release(m);
}
static int
contest_classic(int skilldiff, const armor_type * ar, const armor_type * sh)
{
int p, vw = BASE_CHANCE - TDIFF_CHANGE * skilldiff;
double mod = 1.0;
if (ar != NULL)
mod *= (1 + ar->penalty);
if (sh != NULL)
mod *= (1 + sh->penalty);
vw = (int)(100.0 - ((100.0 - (double)vw) * mod));
do {
p = (int)(rng_int() % 100);
vw -= p;
} while (vw >= 0 && p >= 90);
return (vw <= 0);
}
/** new rule for Eressea 1.5
* \param skilldiff - the attack skill with every modifier applied
*/
static int
contest_new(int skilldiff, const troop dt, const armor_type * ar,
const armor_type * sh)
{
double tohit = 0.5 + skilldiff * 0.1;
UNUSED_ARG(sh);
UNUSED_ARG(ar);
if (tohit < 0.5)
tohit = 0.5;
if (chance(tohit)) {
int defense = effskill(dt.fighter->unit, SK_STAMINA, dt.fighter->unit->region);
double tosave = defense * 0.05;
return !chance(tosave);
}
return 0;
}
static int
contest(int skdiff, const troop dt, const armor_type * ar,
const armor_type * sh)
{
if (skill_formula == FORMULA_ORIG) {
return contest_classic(skdiff, ar, sh);
}
else {
return contest_new(skdiff, dt, ar, sh);
}
}
static bool is_riding(const troop t)
{
if (t.fighter->building != NULL)
return false;
if (t.fighter->horses + t.fighter->elvenhorses > t.index)
return true;
return false;
}
static weapon *preferred_weapon(const troop t, bool attacking)
{
weapon *missile = t.fighter->person[t.index].missile;
weapon *melee = t.fighter->person[t.index].melee;
if (attacking) {
if (melee == NULL || (missile && missile->attackskill > melee->attackskill)) {
return missile;
}
}
else {
if (melee == NULL || (missile
&& missile->defenseskill > melee->defenseskill)) {
return missile;
}
}
return melee;
}
weapon *select_weapon(const troop t, bool attacking, bool ismissile)
/* select the primary weapon for this trooper */
{
if (attacking) {
if (ismissile) {
/* from the back rows, have to use your missile weapon */
return t.fighter->person[t.index].missile;
}
}
else {
if (!ismissile) {
/* have to use your melee weapon if it's melee */
return t.fighter->person[t.index].melee;
}
}
return preferred_weapon(t, attacking);
}
static bool i_canuse(const unit * u, const item_type * itype)
{
return rc_can_use(u_race(u), itype);
}
static int
weapon_skill(const weapon_type * wtype, const unit * u, bool attacking)
/* the 'pure' skill when using this weapon to attack or defend.
* only undiscriminate modifiers (not affected by troops or enemies)
* are taken into account, e.g. no horses, magic, etc. */
{
int skill;
const race * rc = u_race(u);
if (wtype == NULL) {
skill = effskill(u, SK_WEAPONLESS, NULL);
int def = attacking ? rc->at_default : rc->df_default;
if (skill <= 0) {
/* wenn kein waffenloser kampf, dann den rassen-defaultwert */
if (rc == get_race(RC_ORC)) {
int sword = effskill(u, SK_MELEE, NULL);
int spear = effskill(u, SK_SPEAR, NULL);
skill = ((sword > spear) ? sword : spear) - 3;
}
}
if (def > skill) skill = def;
if (attacking) {
skill += rc->at_bonus;
if (fval(u->region->terrain, SEA_REGION) && u->ship)
skill += u->ship->type->at_bonus;
}
else {
skill += rc->df_bonus;
if (fval(u->region->terrain, SEA_REGION) && u->ship)
skill += u->ship->type->df_bonus;
}
}
else {
/* changed: if we own a weapon, we have at least a skill of 0 */
if (!i_canuse(u, wtype->itype))
return -1;
skill = effskill(u, wtype->skill, NULL);
if (skill > 0) {
if (attacking) {
skill += rc->at_bonus;
}
else {
skill += rc->df_bonus;
}
}
if (attacking) {
skill += wtype->offmod;
}
else {
skill += wtype->defmod;
}
}
return skill;
}
static int CavalrySkill(void)
{
return rule_cavalry_skill;
}
#define BONUS_SKILL 1
#define BONUS_DAMAGE 2
static int CavalryBonus(const unit * u, troop enemy, int type)
{
if (rule_cavalry_mode == 0) {
/* old rule, Eressea 1.0 compat */
return (type == BONUS_SKILL) ? 2 : 0;
}
else {
/* new rule, chargers in Eressea 1.1 */
int skl = effskill(u, SK_RIDING, NULL);
/* only half against trolls */
if (skl > 0) {
if (type == BONUS_SKILL) {
int dmg = (skl < 8) ? skl : 8;
if (u_race(enemy.fighter->unit) == get_race(RC_TROLL)) {
dmg = dmg / 4;
}
else {
dmg = dmg / 2;
}
return dmg;
}
else {
skl = skl / 2;
if (skl > 4) skl = 4;
return skl;
}
}
}
return 0;
}
/**
* Effektiver Waffenskill waehrend des Kampfes.
*/
static int
weapon_effskill(troop t, troop enemy, const weapon * w,
bool attacking, bool missile)
{
fighter *tf = t.fighter;
unit *tu = t.fighter->unit;
/* Alle Modifier berechnen, die fig durch die Waffen bekommt. */
if (w) {
int skill = 0;
const weapon_type *wtype = w->type;
if (attacking) {
skill = w->attackskill;
}
else {
skill = w->defenseskill;
}
if (wtype->modifiers != NULL) {
/* Pferdebonus, Lanzenbonus, usw. */
const race *rc = u_race(tu);
int m;
unsigned int flags =
WMF_SKILL | (attacking ? WMF_OFFENSIVE : WMF_DEFENSIVE);
if (is_riding(t))
flags |= WMF_RIDING;
else
flags |= WMF_WALKING;
if (is_riding(enemy))
flags |= WMF_AGAINST_RIDING;
else
flags |= WMF_AGAINST_WALKING;
for (m = 0; wtype->modifiers[m].value; ++m) {
if ((wtype->modifiers[m].flags & flags) == flags) {
int mask = wtype->modifiers[m].race_mask;
if ((mask == 0) || (mask & rc->mask_item)) {
skill += wtype->modifiers[m].value;
}
}
}
}
/* Burgenbonus, Pferdebonus */
if (is_riding(t) && (wtype == NULL || (fval(wtype, WTF_HORSEBONUS)
&& !fval(wtype, WTF_MISSILE)))) {
skill += CavalryBonus(tu, enemy, BONUS_SKILL);
}
if (t.index < tf->elvenhorses) {
/* Elfenpferde: Helfen dem Reiter, egal ob und welche Waffe. Das ist
* eleganter, und vor allem einfacher, sonst muss man noch ein
* WMF_ELVENHORSE einbauen. */
skill += 2;
}
if (skill > 0 && !attacking && missile) {
/*
* Wenn ich verteidige, und nicht direkt meinem Feind gegenueberstehe,
* halbiert sich mein Skill: (z.B. gegen Fernkaempfer. Nahkaempfer
* koennen mich eh nicht treffen)
*/
skill /= 2;
}
return skill;
}
/* no weapon: fight weaponless */
return weapon_skill(NULL, tu, attacking);
}
const armor_type *select_armor(troop t, bool shield)
{
unsigned int type = shield ? ATF_SHIELD : 0;
unit *u = t.fighter->unit;
const armor *a = t.fighter->armors;
int geschuetzt = 0;
/* some monsters should not use armor (dragons in chainmail? ha!) */
if (!(u_race(u)->battle_flags & BF_EQUIPMENT))
return NULL;
/* ... neither do werewolves */
if (fval(u, UFL_WERE)) {
return NULL;
}
for (; a; a = a->next) {
if ((a->atype->flags & ATF_SHIELD) == type) {
geschuetzt += a->count;
if (geschuetzt > t.index) {
/* unser Kandidat wird geschuetzt */
return a->atype;
}
}
}
return NULL;
}
/* Hier ist zu beachten, ob und wie sich Zauber und Artefakte, die
* Ruestungschutz geben, addieren.
* - Artefakt "trollbelt" gibt Ruestung +1
* - Zauber Rindenhaut gibt Ruestung +3
*/
static int trollbelts(const unit *u) {
const struct resource_type *belt = rt_find("trollbelt");
return belt ? i_get(u->items, belt->itype) : 0;
}
int select_magicarmor(troop t)
{
unit *u = t.fighter->unit;
int ma = 0;
if (trollbelts(u) > t.index) /* unser Kandidat wird geschuetzt */
ma += 1;
return ma;
}
/* Sind side ds und Magier des meffect verbuendet, dann return 1*/
bool meffect_protection(battle * b, meffect * s, side * ds)
{
UNUSED_ARG(b);
if (!s->magician->alive)
return false;
if (s->duration <= 0)
return false;
if (enemy(s->magician->side, ds))
return false;
if (alliedside(s->magician->side, ds->faction, HELP_FIGHT))
return true;
return false;
}
/* Sind side as und Magier des meffect verfeindet, dann return 1*/
bool meffect_blocked(battle * b, meffect * s, side * as)
{
UNUSED_ARG(b);
if (!s->magician->alive)
return false;
if (s->duration <= 0)
return false;
if (enemy(s->magician->side, as))
return true;
return false;
}
/* rmfighter wird schon im PRAECOMBAT gebraucht, da gibt es noch keine
* troops */
void rmfighter(fighter * df, int i)
{
side *ds = df->side;
/* nicht mehr personen abziehen, als in der Einheit am Leben sind */
assert(df->alive >= i);
assert(df->alive <= df->unit->number);
/* erst ziehen wir die Anzahl der Personen von den Kaempfern in der
* Schlacht, dann von denen auf dieser Seite ab*/
df->side->alive -= i;
df->side->battle->alive -= i;
/* Dann die Kampfreihen aktualisieren */
ds->size[SUM_ROW] -= i;
ds->size[statusrow(df->status)] -= i;
/* Spezialwirkungen, z.B. Schattenritter */
if (u_race(df->unit)->battle_flags & BF_NOBLOCK) {
ds->nonblockers[SUM_ROW] -= i;
ds->nonblockers[statusrow(df->status)] -= i;
}
/* und die Einheit selbst aktualisieren */
df->alive -= i;
}
static void rmtroop(troop dt)
{
fighter *df = dt.fighter;
/* troop ist immer eine einzelne Person */
rmfighter(df, 1);
assert(dt.index >= 0 && dt.index < df->unit->number);
if (dt.index != df->alive - df->removed) {
df->person[dt.index] = df->person[df->alive - df->removed];
}
if (df->removed) {
df->person[df->alive - df->removed] = df->person[df->alive];
}
df->person[df->alive].hp = 0;
}
void remove_troop(troop dt)
{
fighter *df = dt.fighter;
struct person p = df->person[dt.index];
battle *b = df->side->battle;
b->fast.alive = -1; /* invalidate cached value */
b->rowcache.alive = -1; /* invalidate cached value */
++df->removed;
++df->side->removed;
df->person[dt.index] = df->person[df->alive - df->removed];
df->person[df->alive - df->removed] = p;
}
void kill_troop(troop dt)
{
fighter *df = dt.fighter;
unit *du = df->unit;
rmtroop(dt);
if (!df->alive) {
char eqname[64];
const race *rc = u_race(du);
item *drops = item_spoil(rc, du->number - df->run.number);
if (drops != NULL) {
i_merge(&du->items, &drops);
}
sprintf(eqname, "spo_%s", rc->_name);
equip_unit_mask(du, eqname, EQUIP_ITEMS);
}
}
/** reduces the target's exp by an equivalent of n points learning
* 30 points = 1 week
*/
void drain_exp(struct unit *u, int n)
{
skill_t sk = (skill_t)(rng_int() % MAXSKILLS);
skill_t ssk;
/* TODO (enno): we can use u->skill_size to find a random skill */
ssk = sk;
while (get_level(u, sk) == 0) {
sk++;
if (sk == MAXSKILLS)
sk = 0;
if (sk == ssk) {
sk = NOSKILL;
break;
}
}
if (sk != NOSKILL) {
reduce_skill_days(u, sk, n);
}
}
static void vampirism(troop at, int damage)
{
const unit *au = at.fighter->unit;
if (u_race(au) == get_race(RC_DAEMON)) {
if (rule_vampire > 0) {
int gain = damage / rule_vampire;
int chance = damage - rule_vampire * gain;
if (chance > 0 && (rng_int() % rule_vampire < chance))
++gain;
if (gain > 0) {
int maxhp = unit_max_hp(at.fighter->unit);
gain += at.fighter->person[at.index].hp;
if (maxhp > gain) maxhp = gain;
at.fighter->person[at.index].hp = maxhp;
}
}
}
}
static void ship_damage(int turn, unit *du) {
if (turn > 1) {
/* someone on the ship got damaged, damage the ship */
ship *sh = du->ship ? du->ship : leftship(du);
if (sh)
fset(sh, SF_DAMAGED);
}
}
#define MAXRACES 128
int natural_armor(unit * du)
{
const race *rc = u_race(du);
int an;
assert(rc);
an = rc_armor_bonus(rc);
if (an > 0) {
int sk = effskill(du, SK_STAMINA, NULL);
return rc->armor + sk / an;
}
return rc->armor;
}
static int rc_specialdamage(const unit *au, const unit *du, const struct weapon_type *wtype)
{
const race *ar = u_race(au);
int modifier = 0;
if (wtype != NULL) {
if (fval(u_race(du), RCF_DRAGON)) {
static int cache;
static const race *rc_halfling;
if (rc_changed(&cache)) {
rc_halfling = get_race(RC_HALFLING);
}
if (ar == rc_halfling) {
modifier += 5;
}
}
if (wtype->modifiers != NULL) {
int m;
for (m = 0; wtype->modifiers[m].value; ++m) {
/* weapon damage for this weapon, possibly by race */
if (wtype->modifiers[m].flags & WMF_DAMAGE) {
int mask = wtype->modifiers[m].race_mask;
if ((mask == 0) || (mask & ar->mask_item)) {
modifier += wtype->modifiers[m].value;
}
}
}
}
}
return modifier;
}
int calculate_armor(troop dt, const weapon_type *dwtype, const weapon_type *awtype,
const armor_type *armor, const armor_type *shield, bool magic) {
const fighter *df = dt.fighter;
unit *du = df->unit;
int total_armor = 0, nat_armor, magic_armor;
bool missile = awtype && (awtype->flags&WTF_MISSILE);
if (armor) {
total_armor += armor->prot;
if (missile && armor->projectile > 0 && chance(armor->projectile)) {
return -1;
}
}
if (shield) {
total_armor += shield->prot;
if (missile && shield->projectile > 0 && chance(shield->projectile)) {
return -1;
}
}
if (magic) {
/* gegen Magie wirkt nur natuerliche und magische Ruestung */
total_armor = 0;
}
/* natuerliche Ruestung */
nat_armor = natural_armor(du);
/* magische Ruestung durch Artefakte oder Sprueche */
/* Momentan nur Trollguertel und Werwolf-Eigenschaft */
magic_armor = select_magicarmor(dt);
if (rule_nat_armor == 0) {
/* natuerliche Ruestung ist halbkumulativ */
if (total_armor > 0) {
total_armor += nat_armor / 2;
}
else {
total_armor = nat_armor;
}
}
else {
/* use the higher value, add half the other value */
total_armor = (total_armor > nat_armor) ? (total_armor + nat_armor / 2) : (nat_armor + total_armor / 2);
}
if (awtype && fval(awtype, WTF_ARMORPIERCING)) {
/* crossbows */
total_armor /= 2;
}
total_armor += magic_armor;
assert(total_armor >= 0 || !"armor < 0 means hit denied");
return total_armor;
}
int apply_resistance(int damage, troop dt, const weapon_type *dwtype, const armor_type *armor, const armor_type *shield, bool magic) {
const fighter *df = dt.fighter;
unit *du = df->unit;
if (!magic)
return damage;
/* calculate damage multiplier for magical damage */
variant resistance_factor = frac_sub(frac_one, magic_resistance(du));
if (u_race(du)->battle_flags & BF_EQUIPMENT) {
/* der Effekt von Laen steigt nicht linear */
if (armor && fval(armor, ATF_LAEN)) {
resistance_factor = frac_mul(resistance_factor, frac_sub(frac_one, armor->magres));
}
if (shield && fval(shield, ATF_LAEN)) {
resistance_factor = frac_mul(resistance_factor, frac_sub(frac_one, shield->magres));
}
if (dwtype) {
resistance_factor = frac_mul(resistance_factor, frac_sub(frac_one, dwtype->magres));
}
}
if (resistance_factor.sa[0] <= 0) {
return 0;
}
variant reduced_damage = frac_mul(frac_make(damage, 1), resistance_factor);
return reduced_damage.sa[0] / reduced_damage.sa[1];
}
static bool resurrect_troop(troop dt)
{
fighter *df = dt.fighter;
unit *du = df->unit;
if (oldpotiontype[P_HEAL] && !fval(&df->person[dt.index], FL_HEALING_USED)) {
if (i_get(du->items, oldpotiontype[P_HEAL]) > 0) {
fset(&df->person[dt.index], FL_HEALING_USED);
i_change(&du->items, oldpotiontype[P_HEAL], -1);
df->person[dt.index].hp = u_race(du)->hitpoints * 5; /* give the person a buffer */
return true;
}
}
return false;
}
static void demon_dazzle(fighter *af, troop dt) {
const fighter *df = dt.fighter;
if (u_race(af->unit) == get_race(RC_DAEMON)) {
if (!(df->person[dt.index].flags & (FL_COURAGE | FL_DAZZLED))) {
df->person[dt.index].flags |= FL_DAZZLED;
df->person[dt.index].defense--;
}
}
}
static bool survives(fighter *af, troop dt, battle *b) {
const unit *du = af->unit;
const fighter *df = dt.fighter;
if (df->person[dt.index].hp > 0) { /* Hat ueberlebt */
demon_dazzle(af, dt);
return true;
}
/* Sieben Leben */
if (u_race(du) == get_race(RC_CAT) && (chance(1.0 / 7))) {
df->person[dt.index].hp = unit_max_hp(du);
return true;
}
/* healing potions can avert a killing blow */
if (resurrect_troop(dt)) {
message *m = msg_message("potionsave", "unit", du);
battle_message_faction(b, du->faction, m);
msg_release(m);
return true;
}
return false;
}
static void destroy_items(troop dt) {
unit *du = dt.fighter->unit;
item **pitm;
for (pitm = &du->items; *pitm;) {
item *itm = *pitm;
const item_type *itype = itm->type;
if (!(itype->flags & (ITF_CURSED | ITF_NOTLOST)) && dt.index < itm->number) {
/* 25% Grundchance, dass ein Item kaputtgeht. */
if (rng_int() % 4 < 1) {
i_change(pitm, itype, -1);
}
}
if (*pitm == itm) {
pitm = &itm->next;
}
}
}
static void calculate_defense_type(troop at, troop dt, int type, bool missile,
const weapon_type **dwtype, int *defskill)
{
const weapon *weapon;
weapon = select_weapon(dt, false, true); /* missile=true to get the unmodified best weapon she has */
*defskill = weapon_effskill(dt, at, weapon, false, false);
if (weapon != NULL)
*dwtype = weapon->type;
}
static void calculate_attack_type(troop at, troop dt, int type, bool missile,
const weapon_type **awtype, int *attskill, bool *magic) {
const weapon *weapon;
switch (type) {
case AT_STANDARD:
weapon = select_weapon(at, true, missile);
*attskill = weapon_effskill(at, dt, weapon, true, missile);
if (weapon)
*awtype = weapon->type;
if (*awtype && fval(*awtype, WTF_MAGICAL))
*magic = true;
break;
case AT_NATURAL:
*attskill = weapon_effskill(at, dt, NULL, true, missile);
break;
case AT_SPELL:
case AT_COMBATSPELL:
*magic = true;
break;
default:
break;
}
}
static int crit_damage(int attskill, int defskill, const char *damage_formula) {
int damage = 0;
if (rule_damage & DAMAGE_CRITICAL) {
double kritchance = ((double)attskill * 3.0 - (double)defskill) / 200.0;
int maxk = 4;
kritchance = fmax(kritchance, 0.005);
kritchance = fmin(0.9, kritchance);
while (maxk-- && chance(kritchance)) {
damage += dice_rand(damage_formula);
}
}
return damage;
}
static int apply_race_resistance(int reduced_damage, fighter *df,
const weapon_type *awtype, bool magic) {
unit *du = df->unit;
if ((u_race(du)->battle_flags & BF_INV_NONMAGIC) && !magic)
reduced_damage = 0;
else {
unsigned int i = 0;
if (u_race(du)->battle_flags & BF_RES_PIERCE)
i |= WTF_PIERCE;
if (u_race(du)->battle_flags & BF_RES_CUT)
i |= WTF_CUT;
if (u_race(du)->battle_flags & BF_RES_BASH)
i |= WTF_BLUNT;
if (i && awtype && fval(awtype, i))
reduced_damage /= 2;
}
return reduced_damage;
}
static int apply_magicshield(int reduced_damage, fighter *df,
const weapon_type *awtype, battle *b, bool magic) {
side *ds = df->side;
selist *ql;
int qi;
if (reduced_damage <= 0)
return 0;
/* Schilde */
for (qi = 0, ql = b->meffects; ql; selist_advance(&ql, &qi, 1)) {
meffect *me = (meffect *)selist_get(ql, qi);
if (meffect_protection(b, me, ds) != 0) {
assert(0 <= reduced_damage); /* rda sollte hier immer mindestens 0 sein */
/* jeder Schaden wird um effect% reduziert bis der Schild duration
* Trefferpunkte aufgefangen hat */
if (me->typ == SHIELD_REDUCE) {
int hp = reduced_damage * (me->effect / 100);
reduced_damage -= hp;
me->duration -= hp;
}
/* gibt Ruestung +effect fuer duration Treffer */
if (me->typ == SHIELD_ARMOR) {
reduced_damage -= me->effect;
if (reduced_damage < 0) reduced_damage = 0;
me->duration--;
}
}
}
return reduced_damage;
}
bool
terminate(troop dt, troop at, int type, const char *damage_formula, bool missile)
{
fighter *df = dt.fighter;
fighter *af = at.fighter;
unit *au = af->unit;
unit *du = df->unit;
battle *b = df->side->battle;
int armor_value;
const weapon_type *dwtype = NULL;
const weapon_type *awtype = NULL;
const armor_type *armor = NULL;
const armor_type *shield = NULL;
int reduced_damage, attskill = 0, defskill = 0;
bool magic = false;
int damage = dice_rand(damage_formula);
assert(du->number > 0);
++at.fighter->hits;
calculate_attack_type(at, dt, type, missile, &awtype, &attskill, &magic);
calculate_defense_type(at, dt, type, missile, &dwtype, &defskill);
if (is_riding(at) && (awtype == NULL || (fval(awtype, WTF_HORSEBONUS)
&& !fval(awtype, WTF_MISSILE)))) {
damage += CavalryBonus(au, dt, BONUS_DAMAGE);
}
armor = select_armor(dt, false);
shield = select_armor(dt, true);
armor_value = calculate_armor(dt, dwtype, awtype, armor, shield, magic);
if (armor_value < 0) {
return false;
}
damage = apply_resistance(damage, dt, dwtype, armor, shield, magic);
if (type != AT_COMBATSPELL && type != AT_SPELL) {
damage += crit_damage(attskill, defskill, damage_formula);
damage += rc_specialdamage(au, du, awtype);
if (awtype == NULL || !fval(awtype, WTF_MISSILE)) {
/* melee bonus */
damage += af->person[at.index].damage;
}
/* Skilldifferenzbonus */
if (rule_damage & DAMAGE_SKILL_BONUS) {
int b = (attskill - defskill) / DAMAGE_QUOTIENT;
if (b > 0) damage += b;
}
}
reduced_damage = damage - armor_value;
if (reduced_damage < 0) reduced_damage = 0;
reduced_damage = apply_race_resistance(reduced_damage, df, awtype, magic);
reduced_damage = apply_magicshield(reduced_damage, df, awtype, b, magic);
assert(dt.index >= 0 && dt.index < du->number);
if (reduced_damage > 0) {
df->person[dt.index].hp -= reduced_damage;
vampirism(at, reduced_damage);
ship_damage(b->turn, du);
}
if (survives(af, dt, b))
return false;
++at.fighter->kills;
destroy_items(dt);
kill_troop(dt);
return true;
}
static int
count_side(const side * s, const side * vs, int minrow, int maxrow, int select)
{
fighter *fig;
int people = 0;
int unitrow[NUMROWS];
if (maxrow < FIGHT_ROW)
return 0;
if (select & SELECT_ADVANCE) {
memset(unitrow, -1, sizeof(unitrow));
}
for (fig = s->fighters; fig; fig = fig->next) {
if (fig->alive - fig->removed > 0) {
int row = statusrow(fig->status);
if (select & SELECT_ADVANCE) {
if (unitrow[row] == -1) {
unitrow[row] = get_unitrow(fig, vs);
}
row = unitrow[row];
}
if (row >= minrow && row <= maxrow) {
people += fig->alive - fig->removed;
if (people > 0 && (select & SELECT_FIND))
break;
}
}
}
return people;
}
/* return the number of live allies warning: this function only considers
* troops that are still alive, not those that are still fighting although
* dead. */
int
count_allies(const side * as, int minrow, int maxrow, int select, int allytype)
{
battle *b = as->battle;
side *ds;
int count = 0;
for (ds = b->sides; ds != b->sides + b->nsides; ++ds) {
if ((allytype == ALLY_ANY && helping(as, ds)) || (allytype == ALLY_SELF
&& as->faction == ds->faction)) {
count += count_side(ds, NULL, minrow, maxrow, select);
if (count > 0 && (select & SELECT_FIND))
break;
}
}
return count;
}
static int
count_enemies_i(battle * b, const fighter * af, int minrow, int maxrow,
int select)
{
side *es, *as = af->side;
int i = 0;
for (es = b->sides; es != b->sides + b->nsides; ++es) {
if (as == NULL || enemy(es, as)) {
int offset = 0;
if (select & SELECT_DISTANCE) {
offset = get_unitrow(af, es) - FIGHT_ROW;
}
i += count_side(es, as, minrow - offset, maxrow - offset, select);
if (i > 0 && (select & SELECT_FIND))
break;
}
}
return i;
}
int
count_enemies(battle * b, const fighter * af, int minrow, int maxrow,
int select)
{
int sr = statusrow(af->status);
side *as = af->side;
if (b->alive == b->fast.alive && as == b->fast.side && sr == b->fast.status
&& minrow == b->fast.minrow && maxrow == b->fast.maxrow) {
if (b->fast.enemies[select] >= 0) {
return b->fast.enemies[select];
}
else if (select & SELECT_FIND) {
if (b->fast.enemies[select - SELECT_FIND] >= 0) {
return b->fast.enemies[select - SELECT_FIND];
}
}
}
else if (select != SELECT_FIND || b->alive != b->fast.alive) {
b->fast.side = as;
b->fast.status = sr;
b->fast.minrow = minrow;
b->fast.alive = b->alive;
b->fast.maxrow = maxrow;
memset(b->fast.enemies, -1, sizeof(b->fast.enemies));
}
if (maxrow >= FIRST_ROW) {
int i = count_enemies_i(b, af, minrow, maxrow, select);
b->fast.enemies[select] = i;
return i;
}
return 0;
}
troop select_enemy(fighter * af, int minrow, int maxrow, int select)
{
side *as = af->side;
battle *b = as->battle;
int si, selected;
int enemies;
#ifdef DEBUG_SELECT
troop result = no_troop;
#endif
if (u_race(af->unit)->flags & RCF_FLY) {
/* flying races ignore min- and maxrow and can attack anyone fighting
* them */
minrow = FIGHT_ROW;
maxrow = BEHIND_ROW;
}
if (minrow < FIGHT_ROW) minrow = FIGHT_ROW;
enemies = count_enemies(b, af, minrow, maxrow, select);
/* Niemand ist in der angegebenen Entfernung? */
if (enemies <= 0)
return no_troop;
selected = (int)(rng_int() % enemies);
for (si = 0; as->enemies[si]; ++si) {
side *ds = as->enemies[si];
fighter *df;
int unitrow[NUMROWS];
int offset = 0;
if (select & SELECT_DISTANCE)
offset = get_unitrow(af, ds) - FIGHT_ROW;
if (select & SELECT_ADVANCE) {
int ui;
for (ui = 0; ui != NUMROWS; ++ui)
unitrow[ui] = -1;
}
for (df = ds->fighters; df; df = df->next) {
int dr;
dr = statusrow(df->status);
if (select & SELECT_ADVANCE) {
if (unitrow[dr] < 0) {
unitrow[dr] = get_unitrow(df, as);
}
dr = unitrow[dr];
}
if (select & SELECT_DISTANCE)
dr += offset;
if (dr < minrow || dr > maxrow)
continue;
if (df->alive - df->removed > selected) {
#ifdef DEBUG_SELECT
if (result.fighter == NULL) {
result.index = selected;
result.fighter = df;
}
#else
troop dt;
dt.index = selected;
dt.fighter = df;
return dt;
#endif
}
selected -= (df->alive - df->removed);
enemies -= (df->alive - df->removed);
}
}
if (enemies != 0) {
log_error("select_enemies has a bug.\n");
}
#ifdef DEBUG_SELECT
return result;
#else
assert(!selected);
return no_troop;
#endif
}
static int get_tactics(const side * as, const side * ds)
{
battle *b = as->battle;
side *stac;
int result = 0;
int defense = 0;
if (b->max_tactics > 0) {
for (stac = b->sides; stac != b->sides + b->nsides; ++stac) {
if (stac->leader.value > result && helping(stac, as)) {
assert(ds == NULL || !helping(stac, ds));
result = stac->leader.value;
}
if (ds && stac->leader.value > defense && helping(stac, ds)) {
assert(!helping(stac, as));
defense = stac->leader.value;
}
}
}
return result - defense;
}
double tactics_chance(const unit *u, int skilldiff) {
double tacch = 0.1 * skilldiff;
if (fval(u->region->terrain, SEA_REGION)) {
const ship *sh = u->ship;
if (sh) {
tacch *= sh->type->tac_bonus;
}
}
return tacch;
}
static troop select_opponent(battle * b, troop at, int mindist, int maxdist)
{
fighter *af = at.fighter;
troop dt;
if (u_race(af->unit)->flags & RCF_FLY) {
/* flying races ignore min- and maxrow and can attack anyone fighting
* them */
dt = select_enemy(at.fighter, FIGHT_ROW, BEHIND_ROW, SELECT_ADVANCE);
}
else {
if (mindist < FIGHT_ROW) mindist = FIGHT_ROW;
dt = select_enemy(at.fighter, mindist, maxdist, SELECT_ADVANCE);
}
if (b->turn == 0 && dt.fighter) {
if (rule_tactics_formula == 1) {
int tactics = get_tactics(at.fighter->side, dt.fighter->side);
/* percentage chance to get this attack */
if (tactics > 0) {
double tacch = tactics_chance(af->unit, tactics);
if (!chance(tacch)) {
dt.fighter = NULL;
}
}
else {
dt.fighter = NULL;
}
}
}
return dt;
}
selist *select_fighters(battle * b, const side * vs, int mask, select_fun cb, void *cbdata)
{
side *s;
selist *fightervp = 0;
assert(vs != NULL);
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *fig;
if (mask == FS_ENEMY) {
if (!enemy(s, vs))
continue;
}
else if (mask == FS_HELP) {
if (enemy(s, vs) || !alliedside(s, vs->faction, HELP_FIGHT)) {
continue;
}
}
else {
assert(mask == (FS_HELP | FS_ENEMY) || !"invalid alliance state");
}
for (fig = s->fighters; fig; fig = fig->next) {
if (cb(vs, fig, cbdata)) {
selist_push(&fightervp, fig);
}
}
}
return fightervp;
}
struct selector {
int minrow;
int maxrow;
};
static bool select_row(const side *vs, const fighter *fig, void *cbdata)
{
struct selector *sel = (struct selector *)cbdata;
int row = get_unitrow(fig, vs);
return (row >= sel->minrow && row <= sel->maxrow);
}
selist *fighters(battle * b, const side * vs, int minrow, int maxrow, int mask)
{
struct selector sel;
sel.maxrow = maxrow;
sel.minrow = minrow;
return select_fighters(b, vs, mask, select_row, &sel);
}
static void report_failed_spell(struct battle * b, struct unit * mage, const struct spell *sp)
{
message *m = msg_message("spell_failed", "unit spell", mage, sp);
message_all(b, m);
msg_release(m);
}
static castorder * create_castorder_combat(castorder *co, fighter *fig, const spell * sp, int level, double force) {
co = create_castorder(co, fig->unit, 0, sp, fig->unit->region, level, force, 0, 0, 0);
co->magician.fig = fig;
return co;
}
static void summon_igjarjuk(battle *b, spellrank spellranks[]) {
side *s;
castorder *co;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *fig = 0;
if (s->bf->attacker && fval(s->faction, FFL_CURSED)) {
spell *sp = find_spell("igjarjuk");
if (sp) {
int si;
for (si = 0; s->enemies[si]; ++si) {
side *se = s->enemies[si];
if (se && !fval(se->faction, FFL_NPC)) {
fighter *fi;
for (fi = se->fighters; fi; fi = fi->next) {
if (fi && (!fig || fig->unit->number > fi->unit->number)) {
fig = fi;
if (fig->unit->number == 1) {
break;
}
}
}
if (fig && fig->unit->number == 1) {
break;
}
}
}
if (fig) {
co = create_castorder_combat(0, fig, sp, 10, 10);
co->magician.fig = fig;
add_castorder(&spellranks[sp->rank], co);
break;
}
}
}
}
}
void do_combatmagic(battle * b, combatmagic_t was)
{
side *s;
castorder *co;
region *r = b->region;
int level, rank, sl;
spellrank spellranks[MAX_SPELLRANK];
memset(spellranks, 0, sizeof(spellranks));
if (rule_igjarjuk_curse && was == DO_PRECOMBATSPELL) {
summon_igjarjuk(b, spellranks);
}
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *fig;
for (fig = s->fighters; fig; fig = fig->next) {
unit *mage = fig->unit;
unit *caster = mage;
if (fig->alive <= 0)
continue; /* fighter kann im Kampf getoetet worden sein */
level = effskill(mage, SK_MAGIC, r);
if (level > 0) {
double power;
const spell *sp;
const struct locale *lang = mage->faction->locale;
order *ord;
switch (was) {
case DO_PRECOMBATSPELL:
sp = get_combatspell(mage, 0);
sl = get_combatspelllevel(mage, 0);
break;
case DO_POSTCOMBATSPELL:
sp = get_combatspell(mage, 2);
sl = get_combatspelllevel(mage, 2);
break;
default:
/* Fehler! */
return;
}
if (sp == NULL)
continue;
ord = create_order(K_CAST, lang, "'%s'", spell_name(mkname_spell(sp), lang));
if (!cancast(mage, sp, 1, 1, ord)) {
free_order(ord);
continue;
}
level = eff_spelllevel(mage, caster, sp, level, 1);
if (sl > 0 && sl < level) {
level = sl;
}
if (level < 0) {
report_failed_spell(b, mage, sp);
free_order(ord);
continue;
}
power = spellpower(r, mage, sp, level, ord);
free_order(ord);
if (power <= 0) { /* Effekt von Antimagie */
report_failed_spell(b, mage, sp);
pay_spell(mage, NULL, sp, level, 1);
}
else if (fumble(r, mage, sp, level)) {
report_failed_spell(b, mage, sp);
pay_spell(mage, NULL, sp, level, 1);
}
else {
co = create_castorder_combat(0, fig, sp, level, power);
add_castorder(&spellranks[sp->rank], co);
}
}
}
}
for (rank = 0; rank < MAX_SPELLRANK; rank++) {
for (co = spellranks[rank].begin; co; co = co->next) {
fighter *fig = co->magician.fig;
const spell *sp = co->sp;
level = cast_spell(co);
if (level > 0) {
pay_spell(fig->unit, NULL, sp, level, 1);
}
}
}
for (rank = 0; rank < MAX_SPELLRANK; rank++) {
free_castorders(spellranks[rank].begin);
}
}
static int cast_combatspell(troop at, const spell * sp, int level, double force)
{
castorder co;
create_castorder_combat(&co, at.fighter, sp, level, force);
level = cast_spell(&co);
free_castorder(&co);
if (level > 0) {
pay_spell(at.fighter->unit, NULL, sp, level, 1);
}
return level;
}
static void do_combatspell(troop at)
{
const spell *sp;
fighter *fi = at.fighter;
unit *mage = fi->unit;
battle *b = fi->side->battle;
region *r = b->region;
selist *ql;
int level, qi;
double power;
int fumblechance = 0;
order *ord;
int sl;
const struct locale *lang = mage->faction->locale;
sp = get_combatspell(mage, 1);
if (sp == NULL) {
fi->magic = 0; /* Hat keinen Kampfzauber, kaempft nichtmagisch weiter */
return;
}
ord = create_order(K_CAST, lang, "'%s'", spell_name(mkname_spell(sp), lang));
if (!cancast(mage, sp, 1, 1, ord)) {
fi->magic = 0; /* Kann nicht mehr Zaubern, kaempft nichtmagisch weiter */
return;
}
level = eff_spelllevel(mage, mage, sp, fi->magic, 1);
sl = get_combatspelllevel(mage, 1);
if (sl > 0 && sl < level) {
level = sl;
}
if (fumble(r, mage, sp, level)) {
report_failed_spell(b, mage, sp);
pay_spell(mage, NULL, sp, level, 1);
return;
}
for (qi = 0, ql = b->meffects; ql; selist_advance(&ql, &qi, 1)) {
meffect *mblock = (meffect *)selist_get(ql, qi);
if (mblock->typ == SHIELD_BLOCK) {
if (meffect_blocked(b, mblock, fi->side) != 0) {
fumblechance += mblock->duration;
mblock->duration -= mblock->effect;
}
}
}
/* Antimagie die Fehlschlag erhoeht */
if (rng_int() % 100 < fumblechance) {
report_failed_spell(b, mage, sp);
pay_spell(mage, NULL, sp, level, 1);
free_order(ord);
return;
}
power = spellpower(r, mage, sp, level, ord);
free_order(ord);
if (power <= 0) { /* Effekt von Antimagie */
report_failed_spell(b, mage, sp);
pay_spell(mage, NULL, sp, level, 1);
return;
}
level = cast_combatspell(at, sp, level, power);
}
/* Sonderattacken: Monster patzern nicht und zahlen auch keine
* Spruchkosten. Da die Spruchstaerke direkt durch den Level bestimmt
* wird, wirkt auch keine Antimagie (wird sonst in spellpower
* gemacht) */
static void do_extra_spell(troop at, const att * a)
{
const spell *sp = spellref_get(a->data.sp);
if (!sp) {
log_error("no such spell: '%s'", a->data.sp->_name);
}
else {
assert(a->level > 0);
cast_combatspell(at, sp, a->level, a->level);
}
}
int skilldiff(troop at, troop dt, int dist)
{
fighter *af = at.fighter, *df = dt.fighter;
unit *au = af->unit, *du = df->unit;
int is_protected = 0, skdiff = 0;
weapon *awp = select_weapon(at, true, dist > 1);
static int rc_cache;
static const race *rc_halfling, *rc_goblin;
if (rc_changed(&rc_cache)) {
rc_halfling = get_race(RC_HALFLING);
rc_goblin = get_race(RC_GOBLIN);
}
skdiff += af->person[at.index].attack;
skdiff -= df->person[dt.index].defense;
if (df->person[dt.index].flags & FL_SLEEPING)
skdiff += 2;
/* Effekte durch Rassen */
if (awp != NULL && u_race(au) == rc_halfling && dragonrace(u_race(du))) {
skdiff += 5;
}
else if (u_race(au) == rc_goblin) {
if (af->side->size[SUM_ROW] >= df->side->size[SUM_ROW] * rule_goblin_bonus) {
skdiff += 1;
}
}
if (df->building) {
building *b = df->building;
if (b->attribs) {
curse *c = get_curse(b->attribs, &ct_strongwall);
if (curse_active(c)) {
/* wirkt auf alle Gebaeude */
skdiff -= curse_geteffect_int(c);
is_protected = 2;
}
}
if (b->type->flags & BTF_FORTIFICATION) {
int stage = buildingeffsize(b, false);
int beff = building_protection(b->type, stage);
if (beff > 0) {
skdiff -= beff;
is_protected = 2;
if (b->attribs) {
if (curse_active(get_curse(b->attribs, &ct_magicwalls))) {
/* Verdoppelt Burgenbonus */
skdiff -= beff;
}
}
}
}
}
/* Effekte der Waffen */
skdiff += weapon_effskill(at, dt, awp, true, dist > 1);
if (awp && fval(awp->type, WTF_MISSILE)) {
skdiff -= is_protected;
if (awp->type->modifiers) {
int w;
for (w = 0; awp->type->modifiers[w].value != 0; ++w) {
if (awp->type->modifiers[w].flags & WMF_MISSILE_TARGET) {
/* skill decreases by targeting difficulty (bow -2, catapult -4) */
skdiff -= awp->type->modifiers[w].value;
break;
}
}
}
}
if (skill_formula == FORMULA_ORIG) {
weapon *dwp = select_weapon(dt, false, dist > 1);
skdiff -= weapon_effskill(dt, at, dwp, false, dist > 1);
}
return skdiff;
}
static int setreload(troop at)
{
fighter *af = at.fighter;
const weapon_type *wtype = af->person[at.index].missile->type;
if (wtype->reload == 0)
return 0;
return af->person[at.index].reload = wtype->reload;
}
int getreload(troop at)
{
return at.fighter->person[at.index].reload;
}
int hits(troop at, troop dt, weapon * awp)
{
fighter *af = at.fighter, *df = dt.fighter;
const armor_type *armor, *shield = 0;
int skdiff = 0;
int dist = get_unitrow(af, df->side) + get_unitrow(df, af->side) - 1;
weapon *dwp = select_weapon(dt, false, dist > 1);
if (!df->alive)
return 0;
if (getreload(at))
return 0;
if (dist > 1 && (awp == NULL || !fval(awp->type, WTF_MISSILE)))
return 0;
/* mark this person as hit. */
df->person[dt.index].flags |= FL_HIT;
if (af->person[at.index].flags & FL_STUNNED) {
af->person[at.index].flags &= ~FL_STUNNED;
return 0;
}
if ((af->person[at.index].flags & FL_TIRED && rng_int() % 100 < 50)
|| (af->person[at.index].flags & FL_SLEEPING))
return 0;
/* effect of sp_reeling_arrows combatspell */
if (af->side->battle->reelarrow && awp && fval(awp->type, WTF_MISSILE)
&& rng_double() < 0.5) {
return 0;
}
skdiff = skilldiff(at, dt, dist);
/* Verteidiger bekommt eine Ruestung */
armor = select_armor(dt, true);
if (dwp == NULL || (dwp->type->flags & WTF_USESHIELD)) {
shield = select_armor(dt, false);
}
if (contest(skdiff, dt, armor, shield)) {
return 1;
}
return 0;
}
void dazzle(battle * b, troop * td)
{
UNUSED_ARG(b);
/* Nicht kumulativ ! */
if (td->fighter->person[td->index].flags & (FL_COURAGE | FL_DAZZLED)) {
return;
}
td->fighter->person[td->index].flags |= FL_DAZZLED;
td->fighter->person[td->index].defense--;
}
void damage_building(battle * b, building * bldg, int damage_abs)
{
assert(bldg);
bldg->size -= damage_abs;
if (bldg->size < 1) bldg->size = 1;
/* Wenn Burg, dann gucken, ob die Leute alle noch in das Gebaeude passen. */
if (bldg->type->flags & BTF_FORTIFICATION) {
side *s;
bldg->sizeleft = bldg->size;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *fig;
for (fig = s->fighters; fig; fig = fig->next) {
if (fig->building == bldg) {
if (bldg->sizeleft >= fig->unit->number) {
fig->building = bldg;
bldg->sizeleft -= fig->unit->number;
}
else {
fig->building = NULL;
}
}
}
}
}
}
static int attacks_per_round(troop t)
{
return t.fighter->person[t.index].speed;
}
static void make_heroes(battle * b)
{
side *s;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *fig;
for (fig = s->fighters; fig; fig = fig->next) {
unit *u = fig->unit;
if (fval(u, UFL_HERO)) {
int i;
for (i = 0; i != u->number; ++i) {
fig->person[i].speed += (rule_hero_speed - 1);
}
}
}
}
}
static void attack(battle * b, troop ta, const att * a, int numattack)
{
fighter *af = ta.fighter;
troop td;
unit *au = af->unit;
switch (a->type) {
case AT_COMBATSPELL:
/* Magier versuchen immer erstmal zu zaubern, erst wenn das
* fehlschlaegt, wird af->magic == 0 und der Magier kaempft
* konventionell weiter */
if (numattack == 0 && af->magic > 0) {
/* wenn der magier in die potenzielle Reichweite von Attacken des
* Feindes kommt, beginnt er auch bei einem Status von KAEMPFE NICHT,
* Kampfzauber zu schleudern: */
if (count_enemies(b, af, melee_range[0], missile_range[1],
SELECT_ADVANCE | SELECT_DISTANCE | SELECT_FIND)) {
do_combatspell(ta);
}
}
break;
case AT_STANDARD: /* Waffen, mag. Gegenstaende, Kampfzauber */
if (numattack > 0 || af->magic <= 0) {
weapon *wp = ta.fighter->person[ta.index].missile;
int melee =
count_enemies(b, af, melee_range[0], melee_range[1],
SELECT_ADVANCE | SELECT_DISTANCE | SELECT_FIND);
if (melee)
wp = preferred_weapon(ta, true);
/* Sonderbehandlungen */
if (getreload(ta)) {
ta.fighter->person[ta.index].reload--;
}
else {
bool standard_attack = true;
bool reload = false;
/* spezialattacken der waffe nur, wenn erste attacke in der runde.
* sonst helden mit feuerschwertern zu maechtig */
if (numattack == 0 && wp && wp->type->attack) {
int dead = 0;
standard_attack = wp->type->attack(&ta, wp->type, &dead);
if (!standard_attack)
reload = true;
af->catmsg += dead;
if (!standard_attack && af->person[ta.index].last_action < b->turn) {
af->person[ta.index].last_action = b->turn;
}
}
if (standard_attack) {
bool missile = false;
if (wp && fval(wp->type, WTF_MISSILE))
missile = true;
if (missile) {
td = select_opponent(b, ta, missile_range[0], missile_range[1]);
}
else {
td = select_opponent(b, ta, melee_range[0], melee_range[1]);
}
if (!td.fighter)
return;
if (ta.fighter->person[ta.index].last_action < b->turn) {
ta.fighter->person[ta.index].last_action = b->turn;
}
reload = true;
if (hits(ta, td, wp)) {
const char *d;
if (wp == NULL)
d = u_race(au)->def_damage;
else if (is_riding(ta))
d = wp->type->damage[1];
else
d = wp->type->damage[0];
terminate(td, ta, a->type, d, missile);
}
}
if (reload && wp && wp->type->reload && !getreload(ta)) {
setreload(ta);
}
}
}
break;
case AT_SPELL: /* Extra-Sprueche. Kampfzauber in AT_COMBATSPELL! */
do_extra_spell(ta, a);
break;
case AT_NATURAL:
td = select_opponent(b, ta, melee_range[0], melee_range[1]);
if (!td.fighter)
return;
if (ta.fighter->person[ta.index].last_action < b->turn) {
ta.fighter->person[ta.index].last_action = b->turn;
}
if (hits(ta, td, NULL)) {
terminate(td, ta, a->type, a->data.dice, false);
}
break;
case AT_DRAIN_ST:
td = select_opponent(b, ta, melee_range[0], melee_range[1]);
if (!td.fighter)
return;
if (ta.fighter->person[ta.index].last_action < b->turn) {
ta.fighter->person[ta.index].last_action = b->turn;
}
if (hits(ta, td, NULL)) {
int c = dice_rand(a->data.dice);
while (c > 0) {
if (rng_int() % 2) {
td.fighter->person[td.index].attack -= 1;
}
else {
td.fighter->person[td.index].defense -= 1;
}
c--;
}
}
break;
case AT_DRAIN_EXP:
td = select_opponent(b, ta, melee_range[0], melee_range[1]);
if (!td.fighter)
return;
if (ta.fighter->person[ta.index].last_action < b->turn) {
ta.fighter->person[ta.index].last_action = b->turn;
}
if (hits(ta, td, NULL)) {
drain_exp(td.fighter->unit, dice_rand(a->data.dice));
}
break;
case AT_DAZZLE:
td = select_opponent(b, ta, melee_range[0], melee_range[1]);
if (!td.fighter)
return;
if (ta.fighter->person[ta.index].last_action < b->turn) {
ta.fighter->person[ta.index].last_action = b->turn;
}
if (hits(ta, td, NULL)) {
dazzle(b, &td);
}
break;
case AT_STRUCTURAL:
td = select_opponent(b, ta, melee_range[0], melee_range[1]);
if (!td.fighter)
return;
if (ta.fighter->person[ta.index].last_action < b->turn) {
ta.fighter->person[ta.index].last_action = b->turn;
}
if (td.fighter->unit->ship) {
int dice = dice_rand(a->data.dice);
ship * sh = td.fighter->unit->ship;
damage_ship(sh, dice / sh->type->damage / sh->size);
}
else if (td.fighter->unit->building) {
damage_building(b, td.fighter->unit->building, dice_rand(a->data.dice));
}
}
}
void do_attack(fighter * af)
{
troop ta;
unit *au = af->unit;
side *side = af->side;
battle *b = side->battle;
ta.fighter = af;
assert(au && au->number);
/* Da das Zuschlagen auf Einheiten und nicht auf den einzelnen
* Kaempfern beruht, darf die Reihenfolge und Groesse der Einheit keine
* Rolle spielen, Das tut sie nur dann, wenn jeder, der am Anfang der
* Runde lebte, auch zuschlagen darf. Ansonsten ist der, der zufaellig
* mit einer grossen Einheit zuerst drankommt, extrem bevorteilt. */
ta.index = af->fighting;
while (ta.index--) {
/* Wir suchen eine beliebige Feind-Einheit aus. An der koennen
* wir feststellen, ob noch jemand da ist. */
int apr, attacks = attacks_per_round(ta);
if (!count_enemies(b, af, FIGHT_ROW, LAST_ROW, SELECT_FIND))
break;
for (apr = 0; apr != attacks; ++apr) {
int a;
for (a = 0; a < RACE_ATTACKS && u_race(au)->attack[a].type != AT_NONE; ++a) {
if (apr > 0) {
/* Wenn die Waffe nachladen muss, oder es sich nicht um einen
* Waffen-Angriff handelt, dann gilt der Speed nicht. */
/* TODO: allow multiple AT_NATURAL attacks? */
if (u_race(au)->attack[a].type != AT_STANDARD)
continue;
else {
weapon *wp = preferred_weapon(ta, true);
if (wp != NULL && wp->type->reload)
continue;
}
}
attack(b, ta, &(u_race(au)->attack[a]), apr);
}
}
}
/* Der letzte Katapultschuetze setzt die
* Ladezeit neu und generiert die Meldung. */
if (af->catmsg >= 0) {
struct message *m =
msg_message("killed_battle", "unit dead", au, af->catmsg);
message_all(b, m);
msg_release(m);
af->catmsg = -1;
}
}
static void add_tactics(tactics * ta, fighter * fig, int value)
{
if (value == 0 || value < ta->value)
return;
if (value > ta->value) {
selist_free(ta->fighters);
ta->fighters = 0;
}
selist_push(&ta->fighters, fig);
selist_push(&fig->side->battle->leaders, fig);
ta->value = value;
}
static int horse_fleeing_bonus(const unit * u)
{
const item_type *it_horse, *it_elvenhorse, *it_charger;
int n1 = 0, n2 = 0, n3 = 0;
item *itm;
int skl = effskill(u, SK_RIDING, NULL);
const resource_type *rtype;
it_horse = ((rtype = get_resourcetype(R_HORSE)) != NULL) ? rtype->itype : 0;
it_elvenhorse = ((rtype = get_resourcetype(R_UNICORN)) != NULL) ? rtype->itype : 0;
it_charger = ((rtype = get_resourcetype(R_CHARGER)) != NULL) ? rtype->itype : 0;
for (itm = u->items; itm; itm = itm->next) {
if (itm->type->flags & ITF_ANIMAL) {
if (itm->type == it_elvenhorse)
n3 += itm->number;
else if (itm->type == it_charger)
n2 += itm->number;
else if (itm->type == it_horse)
n1 += itm->number;
}
}
if (skl >= 5 && n3 >= u->number)
return 30;
if (skl >= 2 && n2 + n3 >= u->number)
return 20;
if (n1 + n2 + n3 >= u->number)
return 10;
return 0;
}
static int fleechance(unit * u)
{
int p = flee_chance_base; /* Fluchtwahrscheinlichkeit in % */
/* Einheit u versucht, dem Getuemmel zu entkommen */
p += (effskill(u, SK_STEALTH, NULL) * flee_chance_skill_bonus);
p += horse_fleeing_bonus(u);
if (u_race(u) == get_race(RC_HALFLING)) {
p += flee_chance_base;
if (p > flee_chance_max_percent) {
p = flee_chance_max_percent;
}
}
return p;
}
/** add a new army to the conflict.
* beware: armies need to be added _at the beginning_ of the list because
* otherwise join_allies() will get into trouble */
side *make_side(battle * b, const faction * f, const group * g,
unsigned int flags, const faction * stealthfaction)
{
side *s1 = b->sides + b->nsides;
bfaction *bf;
if (fval(b->region->terrain, SEA_REGION)) {
/* every fight in an ocean is short */
flags |= SIDE_HASGUARDS;
}
else {
unit *u;
for (u = b->region->units; u; u = u->next) {
if (is_guard(u)) {
if (alliedunit(u, f, HELP_GUARD)) {
flags |= SIDE_HASGUARDS;
break;
}
}
}
}
s1->battle = b;
s1->group = g;
s1->flags = flags;
s1->stealthfaction = stealthfaction;
for (bf = b->factions; bf; bf = bf->next) {
faction *f2 = bf->faction;
if (f2 == f) {
s1->bf = bf;
s1->faction = f2;
s1->index = b->nsides++;
s1->nextF = bf->sides;
bf->sides = s1;
assert(b->nsides <= MAXSIDES);
break;
}
}
assert(bf);
return s1;
}
troop select_ally(fighter * af, int minrow, int maxrow, int allytype)
{
side *as = af->side;
battle *b = as->battle;
side *ds;
int allies = count_allies(as, minrow, maxrow, SELECT_ADVANCE, allytype);
if (!allies) {
return no_troop;
}
allies = (int)(rng_int() % allies);
for (ds = b->sides; ds != b->sides + b->nsides; ++ds) {
if ((allytype == ALLY_ANY && helping(as, ds)) || (allytype == ALLY_SELF
&& as->faction == ds->faction)) {
fighter *df;
for (df = ds->fighters; df; df = df->next) {
int dr = get_unitrow(df, NULL);
if (dr >= minrow && dr <= maxrow) {
if (df->alive - df->removed > allies) {
troop dt;
assert(allies >= 0);
dt.index = allies;
dt.fighter = df;
return dt;
}
allies -= df->alive;
}
}
}
}
assert(!"we should never have gotten here");
return no_troop;
}
static int loot_quota(const unit * src, const unit * dst,
const item_type * type, int n)
{
UNUSED_ARG(type);
if (dst && src && src->faction != dst->faction) {
double divisor = config_get_flt("rules.items.loot_divisor", 1);
assert(divisor <= 0 || divisor >= 1);
if (divisor >= 1) {
double r = n / divisor;
int x = (int)r;
r = r - x;
if (chance(r))
++x;
return x;
}
}
return n;
}
static void loot_items(fighter * corpse)
{
unit *u = corpse->unit;
item *itm = u->items;
battle *b = corpse->side->battle;
int dead = dead_fighters(corpse);
if (dead <= 0)
return;
while (itm) {
float lootfactor = (float)dead / (float)u->number; /* only loot the dead! */
int maxloot = (int)((float)itm->number * lootfactor);
if (maxloot > 0) {
int i = (maxloot > 10) ? 10 : maxloot;
for (; i != 0; --i) {
int loot = maxloot / i;
if (loot > 0) {
fighter *fig = NULL;
int looting = 0;
int maxrow = 0;
/* mustloot: we absolutely, positively must have somebody loot this thing */
int mustloot = itm->type->flags & (ITF_CURSED | ITF_NOTLOST);
itm->number -= loot;
maxloot -= loot;
if (is_monsters(u->faction) && (rule_loot & LOOT_MONSTERS)) {
looting = 1;
}
else if (rule_loot & LOOT_OTHERS) {
looting = 1;
}
else if (rule_loot & LOOT_SELF) {
looting = 2;
}
if (looting) {
if (mustloot) {
maxrow = LAST_ROW;
}
else if (rule_loot & LOOT_KEEPLOOT) {
int lootchance = 50 + b->keeploot;
if (rng_int() % 100 < lootchance) {
maxrow = BEHIND_ROW;
}
}
else {
maxrow = LAST_ROW;
}
}
if (maxrow > 0) {
if (looting == 1) {
/* enemies get dibs */
fig = select_enemy(corpse, FIGHT_ROW, maxrow, 0).fighter;
}
if (!fig) {
/* self and allies get second pick */
fig = select_ally(corpse, FIGHT_ROW, LAST_ROW, ALLY_SELF).fighter;
}
}
if (fig) {
int trueloot =
mustloot ? loot : loot_quota(corpse->unit, fig->unit, itm->type,
loot);
if (trueloot > 0) {
i_change(&fig->loot, itm->type, trueloot);
}
}
}
}
}
itm = itm->next;
}
}
bool seematrix(const faction * f, const side * s)
{
if (f == s->faction)
return true;
if (s->flags & SIDE_STEALTH)
return false;
return true;
}
static double PopulationDamage(void)
{
return rule_population_damage / 100.0;
}
static void battle_effects(battle * b, int dead_players)
{
region *r = b->region;
int rp = rpeasants(r);
if (rp > 0) {
int dead_peasants = (int)(dead_players * PopulationDamage());
if (dead_peasants > rp) {
dead_peasants = rp;
}
if (dead_peasants) {
deathcounts(r, dead_peasants + dead_players);
rsetpeasants(r, rp - dead_peasants);
}
}
}
static void reorder_fleeing(region * r)
{
unit **usrc = &r->units;
unit **udst = &r->units;
unit *ufirst = NULL;
unit *u;
for (; *udst; udst = &u->next) {
u = *udst;
}
for (u = *usrc; u != ufirst; u = *usrc) {
if (u->next && fval(u, UFL_FLEEING)) {
*usrc = u->next;
*udst = u;
udst = &u->next;
if (!ufirst)
ufirst = u;
}
else {
usrc = &u->next;
}
}
*udst = NULL;
}
static void aftermath(battle * b)
{
region *r = b->region;
side *s;
int dead_players = 0;
bfaction *bf;
bool ships_damaged = (b->turn + (b->has_tactics_turn ? 1 : 0) > 2); /* only used for ship damage! */
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *df;
s->dead = 0;
for (df = s->fighters; df; df = df->next) {
unit *du = df->unit;
int dead = dead_fighters(df);
const race *rc = u_race(du);
/* tote insgesamt: */
s->dead += dead;
/* Tote, die wiederbelebt werde koennen: */
if (!undeadrace(rc)) {
s->casualties += dead;
}
if (df->hits + df->kills) {
struct message *m =
msg_message("killsandhits", "unit hits kills", du, df->hits,
df->kills);
battle_message_faction(b, du->faction, m);
msg_release(m);
}
}
}
/* POSTCOMBAT */
do_combatmagic(b, DO_POSTCOMBATSPELL);
for (s = b->sides; s != b->sides + b->nsides; ++s) {
int snumber = 0;
fighter *df;
bool relevant = false; /* Kampf relevant fuer diese Partei? */
if (!fval(s, SIDE_HASGUARDS)) {
relevant = true;
}
s->flee = 0;
for (df = s->fighters; df; df = df->next) {
unit *du = df->unit;
const race *rc = u_race(du);
int dead = dead_fighters(df);
int sum_hp = 0;
int n;
int flags = 0;
for (n = 0; n != df->alive; ++n) {
if (df->person[n].hp > 0) {
sum_hp += df->person[n].hp;
}
}
snumber += du->number;
if (dead == df->unit->number) {
flags = UFL_DEAD;
}
else if (relevant) {
flags = UFL_LONGACTION;
if ((du->status != ST_FLEE) && (df->run.hp <= 0)) {
flags |= UFL_NOTMOVING;
}
}
if (flags) {
fset(du, flags);
}
if (df->alive && df->alive == du->number) {
du->hp = sum_hp;
continue; /* nichts passiert */
}
else if (df->run.hp) {
if (df->alive == 0) {
/* Report the casualties */
reportcasualties(b, df, dead);
/* Zuerst duerfen die Feinde pluendern, die mitgenommenen Items
* stehen in fig->run.items. Dann werden die Fliehenden auf
* die leere (tote) alte Einheit gemapt */
if (!fval(df, FIG_NOLOOT)) {
loot_items(df);
}
scale_number(du, df->run.number);
du->hp = df->run.hp;
setguard(du, false);
/* must leave ships or buildings, or a stealthy hobbit
* can hold castles indefinitely */
if (!fval(r->terrain, SEA_REGION)) {
leave(du, true); /* even region owners have to flee */
}
fset(du, UFL_FLEEING);
}
else {
/* nur teilweise geflohene Einheiten mergen sich wieder */
df->alive += df->run.number;
s->size[0] += df->run.number;
s->size[statusrow(df->status)] += df->run.number;
s->alive += df->run.number;
sum_hp += df->run.hp;
df->run.number = 0;
df->run.hp = 0;
/* df->run.region = NULL; */
reportcasualties(b, df, dead);
scale_number(du, df->alive);
du->hp = sum_hp;
}
}
else {
if (df->alive == 0) {
/* alle sind tot, niemand geflohen. Einheit aufloesen */
df->run.number = 0;
df->run.hp = 0;
/* Report the casualties */
reportcasualties(b, df, dead);
/* Distribute Loot */
loot_items(df);
setguard(du, false);
scale_number(du, 0);
}
else {
df->run.number = 0;
df->run.hp = 0;
reportcasualties(b, df, dead);
scale_number(du, df->alive);
du->hp = sum_hp;
}
}
s->flee += df->run.number;
if (!undeadrace(rc)) {
/* tote im kampf werden zu regionsuntoten:
* for each of them, a peasant will die as well */
dead_players += dead;
}
if (du->hp < du->number) {
log_error("%s has less hitpoints (%u) than people (%u)\n", itoa36(du->no), du->hp, du->number);
du->hp = du->number;
}
}
s->alive += s->healed;
assert(snumber == s->flee + s->alive + s->dead);
}
battle_effects(b, dead_players);
for (s = b->sides; s != b->sides + b->nsides; ++s) {
message *seen = msg_message("army_report",
"index abbrev dead fled survived",
army_index(s), sideabkz(s, false), s->dead, s->flee, s->alive);
message *unseen = msg_message("army_report",
"index abbrev dead fled survived",
army_index(s), "-?-", s->dead, s->flee, s->alive);
for (bf = b->factions; bf; bf = bf->next) {
faction *f = bf->faction;
message *m = seematrix(f, s) ? seen : unseen;
battle_message_faction(b, f, m);
}
msg_release(seen);
msg_release(unseen);
}
/* Wir benutzen drifted, um uns zu merken, ob ein Schiff
* schonmal Schaden genommen hat. (moved und drifted
* sollten in flags ueberfuehrt werden */
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *df;
for (df = s->fighters; df; df = df->next) {
unit *du = df->unit;
item *l;
/* Beute verteilen */
for (l = df->loot; l; l = l->next) {
const item_type *itype = l->type;
message *m =
msg_message("battle_loot", "unit amount item", du, l->number,
itype->rtype);
battle_message_faction(b, du->faction, m);
msg_release(m);
i_change(&du->items, itype, l->number);
}
/* Wenn sich die Einheit auf einem Schiff befindet, wird
* dieses Schiff beschaedigt. Andernfalls ein Schiff, welches
* evt. zuvor verlassen wurde. */
if (ships_damaged) {
ship *sh;
if (du->ship)
sh = du->ship;
else
sh = leftship(du);
if (sh && fval(sh, SF_DAMAGED)) {
int n = b->turn - 2;
if (n > 0) {
double dmg =
config_get_flt("rules.ship.damage.battleround",
0.05F);
damage_ship(sh, dmg * n);
freset(sh, SF_DAMAGED);
}
}
}
}
}
if (ships_damaged) {
ship **sp = &r->ships;
while (*sp) {
ship *sh = *sp;
freset(sh, SF_DAMAGED);
if (sh->damage >= sh->size * DAMAGE_SCALE) {
sink_ship(sh);
remove_ship(sp, sh);
}
else {
sp = &sh->next;
}
}
}
reorder_fleeing(r);
}
static void battle_punit(unit * u, battle * b)
{
bfaction *bf;
for (bf = b->factions; bf; bf = bf->next) {
faction *f = bf->faction;
strlist *S = 0, *x;
spunit(&S, f, u, 4, seen_battle);
for (x = S; x; x = x->next) {
fbattlerecord(b, f, x->s);
}
if (S)
freestrlist(S);
}
}
static void print_fighters(battle * b, const side * s)
{
fighter *df;
int row;
for (row = 1; row != NUMROWS; ++row) {
message *m = NULL;
for (df = s->fighters; df; df = df->next) {
unit *du = df->unit;
int thisrow = statusrow(df->unit->status);
if (row == thisrow) {
if (m == NULL) {
m = msg_message("battle_row", "row", row);
message_all(b, m);
}
battle_punit(du, b);
}
}
if (m != NULL)
msg_release(m);
}
}
bool is_attacker(const fighter * fig)
{
return fval(fig, FIG_ATTACKER) != 0;
}
static void set_attacker(fighter * fig)
{
fset(fig, FIG_ATTACKER);
}
static void print_stats(battle * b)
{
side *s2;
side *s;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
bfaction *bf;
for (bf = b->factions; bf; bf = bf->next) {
faction *f = bf->faction;
const char *loc_army = LOC(f->locale, "battle_army");
char *bufp;
const char *header;
size_t rsize, size;
int komma;
const char *sname =
seematrix(f, s) ? sidename(s) : LOC(f->locale, "unknown_faction");
message *msg;
char buf[1024];
msg = msg_message("para_army_index", "index name", army_index(s), sname);
battle_message_faction(b, f, msg);
msg_release(msg);
bufp = buf;
size = sizeof(buf);
komma = 0;
header = LOC(f->locale, "battle_opponents");
for (s2 = b->sides; s2 != b->sides + b->nsides; ++s2) {
if (enemy(s2, s)) {
const char *abbrev = seematrix(f, s2) ? sideabkz(s2, false) : "-?-";
rsize = slprintf(bufp, size, "%s %s %d(%s)",
komma++ ? "," : (const char *)header, loc_army, army_index(s2),
abbrev);
if (rsize > size)
rsize = size - 1;
size -= rsize;
bufp += rsize;
}
}
if (komma)
fbattlerecord(b, f, buf);
bufp = buf;
size = sizeof(buf);
komma = 0;
header = LOC(f->locale, "battle_helpers");
for (s2 = b->sides; s2 != b->sides + b->nsides; ++s2) {
if (s2 != s && friendly(s2, s)) {
const char *abbrev = seematrix(f, s2) ? sideabkz(s2, false) : "-?-";
rsize = slprintf(bufp, size, "%s %s %d(%s)",
komma++ ? "," : (const char *)header, loc_army, army_index(s2),
abbrev);
if (rsize > size)
rsize = size - 1;
size -= rsize;
bufp += rsize;
}
}
if (komma)
fbattlerecord(b, f, buf);
bufp = buf;
size = sizeof(buf);
komma = 0;
header = LOC(f->locale, "battle_attack");
for (s2 = b->sides; s2 != b->sides + b->nsides; ++s2) {
if (s->relations[s2->index] & E_ATTACKING) {
const char *abbrev = seematrix(f, s2) ? sideabkz(s2, false) : "-?-";
rsize =
slprintf(bufp, size, "%s %s %d(%s)",
komma++ ? "," : (const char *)header, loc_army, army_index(s2),
abbrev);
if (rsize > size)
rsize = size - 1;
size -= rsize;
bufp += rsize;
}
}
if (komma)
fbattlerecord(b, f, buf);
}
print_fighters(b, s);
}
/* Besten Taktiker ermitteln */
b->max_tactics = 0;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
if (!selist_empty(s->leader.fighters)) {
if (s->leader.value > b->max_tactics) {
b->max_tactics = s->leader.value;
}
}
}
if (b->max_tactics > 0) {
for (s = b->sides; s != b->sides + b->nsides; ++s) {
if (s->leader.value == b->max_tactics) {
selist *ql;
int qi;
for (qi = 0, ql = s->leader.fighters; ql; selist_advance(&ql, &qi, 1)) {
fighter *tf = (fighter *)selist_get(ql, qi);
unit *u = tf->unit;
message *m = NULL;
if (!is_attacker(tf)) {
m = msg_message("para_tactics_lost", "unit", u);
}
else {
m = msg_message("para_tactics_won", "unit", u);
}
message_all(b, m);
msg_release(m);
}
}
}
}
}
static int weapon_weight(const weapon * w, bool missile)
{
if (missile == !!(fval(w->type, WTF_MISSILE))) {
return w->attackskill + w->defenseskill;
}
return 0;
}
side * get_side(battle * b, const struct unit * u)
{
side * s;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
if (s->faction == u->faction) {
fighter * fig;
for (fig = s->fighters; fig; fig = fig->next) {
if (fig->unit == u) {
return s;
}
}
}
}
return 0;
}
side * find_side(battle * b, const faction * f, const group * g, unsigned int flags, const faction * stealthfaction)
{
side * s;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
if (s->faction == f && s->group == g) {
unsigned int s1flags = flags | SIDE_HASGUARDS;
unsigned int s2flags = s->flags | SIDE_HASGUARDS;
if (rule_anon_battle && s->stealthfaction != stealthfaction) {
continue;
}
if (s1flags == s2flags) {
return s;
}
}
}
return 0;
}
fighter *make_fighter(battle * b, unit * u, side * s1, bool attack)
{
#define WMAX 20
weapon weapons[WMAX];
region *r = b->region;
item *itm;
fighter *fig = NULL;
int h, i, tactics = effskill(u, SK_TACTICS, NULL);
int berserk;
int strongmen;
int speeded = 0, speed = 1;
int rest;
const group *g = NULL;
const faction *stealthfaction = get_otherfaction(u);
unsigned int flags = 0;
assert(u->number);
if (fval(u, UFL_ANON_FACTION) != 0)
flags |= SIDE_STEALTH;
if (!(AllianceAuto() & HELP_FIGHT) && fval(u, UFL_GROUP)) {
g = get_group(u);
}
/* Illusionen und Zauber kaempfen nicht */
if (fval(u_race(u), RCF_ILLUSIONARY) || u->number == 0) {
return NULL;
}
if (s1 == NULL) {
s1 = find_side(b, u->faction, g, flags, stealthfaction);
/* aliances are moved out of make_fighter and will be handled later */
if (!s1) {
s1 = make_side(b, u->faction, g, flags, stealthfaction);
}
else if (!stealthfaction) {
s1->stealthfaction = NULL;
}
/* Zu diesem Zeitpunkt ist attacked noch 0, da die Einheit fuer noch
* keinen Kampf ausgewaehlt wurde (sonst wuerde ein fighter existieren) */
}
fig = (struct fighter*)calloc(1, sizeof(struct fighter));
fig->next = s1->fighters;
s1->fighters = fig;
fig->unit = u;
/* In einer Burg muss man a) nicht Angreifer sein, und b) drin sein, und
* c) noch Platz finden. d) menschanaehnlich sein */
if (attack) {
set_attacker(fig);
}
else {
building *bld = u->building;
if (bld && bld->sizeleft >= u->number && humanoidrace(u_race(u))) {
fig->building = bld;
fig->building->sizeleft -= u->number;
}
}
fig->status = u->status;
fig->side = s1;
fig->alive = u->number;
fig->side->alive += u->number;
fig->side->battle->alive += u->number;
fig->catmsg = -1;
/* Freigeben nicht vergessen! */
assert(fig->alive > 0);
fig->person = (struct person*)calloc((size_t)fig->alive, sizeof(struct person));
h = u->hp / u->number;
assert(h);
rest = u->hp % u->number;
/* Effekte von Spruechen */
if (u->attribs) {
curse *c = get_curse(u->attribs, &ct_speed);
if (c) {
speeded = get_cursedmen(u, c);
speed = curse_geteffect_int(c);
}
}
/* Effekte von Alchemie */
berserk = get_effect(u, oldpotiontype[P_BERSERK]);
/* change_effect wird in ageing gemacht */
/* Effekte von Artefakten */
strongmen = trollbelts(u);
if (strongmen > fig->unit->number) strongmen = fig->unit->number;
/* Hitpoints, Attack- und Defense-Boni fuer alle Personen */
for (i = 0; i < fig->alive; i++) {
assert(i < fig->unit->number);
fig->person[i].hp = h;
if (i < rest)
fig->person[i].hp++;
if (i < speeded)
fig->person[i].speed = (unsigned char) speed;
else
fig->person[i].speed = 1;
if (i < berserk) {
fig->person[i].attack++;
}
/* Leute mit Kraftzauber machen +2 Schaden im Nahkampf. */
if (i < strongmen) {
fig->person[i].damage += 2;
}
}
/* Fuer alle Waffengattungen wird bestimmt, wie viele der Personen mit
* ihr kaempfen koennten, und was ihr Wert darin ist. */
if (u_race(u)->battle_flags & BF_EQUIPMENT) {
int owp[WMAX];
int dwp[WMAX];
int wcount[WMAX];
int wused[WMAX];
int oi = 0, di = 0, w = 0;
for (itm = u->items; itm && w != WMAX; itm = itm->next) {
const weapon_type *wtype = resource2weapon(itm->type->rtype);
if (wtype == NULL || itm->number == 0)
continue;
weapons[w].attackskill = weapon_skill(wtype, u, true);
weapons[w].defenseskill = weapon_skill(wtype, u, false);
if (weapons[w].attackskill >= 0 || weapons[w].defenseskill >= 0) {
weapons[w].type = wtype;
wused[w] = 0;
wcount[w] = itm->number;
++w;
}
assert(w != WMAX);
}
assert(w >= 0);
fig->weapons = (weapon *)calloc((size_t)(w + 1), sizeof(weapon));
memcpy(fig->weapons, weapons, (size_t)w * sizeof(weapon));
for (i = 0; i != w; ++i) {
int j, o = 0, d = 0;
for (j = 0; j != i; ++j) {
if (weapon_weight(fig->weapons + j,
true) >= weapon_weight(fig->weapons + i, true))
++d;
if (weapon_weight(fig->weapons + j,
false) >= weapon_weight(fig->weapons + i, false))
++o;
}
for (j = i + 1; j != w; ++j) {
if (weapon_weight(fig->weapons + j,
true) > weapon_weight(fig->weapons + i, true))
++d;
if (weapon_weight(fig->weapons + j,
false) > weapon_weight(fig->weapons + i, false))
++o;
}
owp[o] = i;
dwp[d] = i;
}
/* jetzt enthalten owp und dwp eine absteigend schlechter werdende Liste der Waffen
* oi and di are the current index to the sorted owp/dwp arrays
* owp, dwp contain indices to the figther::weapons array */
/* hand out melee weapons: */
for (i = 0; i != fig->alive; ++i) {
int wpless = weapon_skill(NULL, u, true);
while (oi != w
&& (wused[owp[oi]] == wcount[owp[oi]]
|| fval(fig->weapons[owp[oi]].type, WTF_MISSILE))) {
++oi;
}
if (oi == w)
break; /* no more weapons available */
if (weapon_weight(fig->weapons + owp[oi], false) <= wpless) {
continue; /* we fight better with bare hands */
}
fig->person[i].melee = &fig->weapons[owp[oi]];
++wused[owp[oi]];
}
/* hand out missile weapons (from back to front, in case of mixed troops). */
for (di = 0, i = fig->alive; i-- != 0;) {
while (di != w && (wused[dwp[di]] == wcount[dwp[di]]
|| !fval(fig->weapons[dwp[di]].type, WTF_MISSILE))) {
++di;
}
if (di == w)
break; /* no more weapons available */
if (weapon_weight(fig->weapons + dwp[di], true) > 0) {
fig->person[i].missile = &fig->weapons[dwp[di]];
++wused[dwp[di]];
}
}
}
s1->size[statusrow(fig->status)] += u->number;
s1->size[SUM_ROW] += u->number;
if (u_race(u)->battle_flags & BF_NOBLOCK) {
s1->nonblockers[statusrow(fig->status)] += u->number;
}
if (u_race(fig->unit)->flags & RCF_HORSE) {
fig->horses = fig->unit->number;
fig->elvenhorses = 0;
}
else {
const resource_type *rt_horse = 0;
const resource_type *rt_elvenhorse = 0;
rt_elvenhorse = get_resourcetype(R_UNICORN);
rt_horse = get_resourcetype(R_CHARGER);
if (!rt_horse) {
rt_horse = get_resourcetype(R_HORSE);
}
fig->horses = rt_horse ? i_get(u->items, rt_horse->itype) : 0;
fig->elvenhorses = rt_elvenhorse ? i_get(u->items, rt_elvenhorse->itype) : 0;
}
if (u_race(u)->battle_flags & BF_EQUIPMENT) {
for (itm = u->items; itm; itm = itm->next) {
if (itm->type->rtype->atype) {
if (i_canuse(u, itm->type)) {
struct armor *adata = (struct armor *)malloc(sizeof(armor)), **aptr;
adata->atype = itm->type->rtype->atype;
adata->count = itm->number;
for (aptr = &fig->armors; *aptr; aptr = &(*aptr)->next) {
if (adata->atype->prot > (*aptr)->atype->prot) {
break;
}
}
adata->next = *aptr;
*aptr = adata;
}
}
}
}
/* Jetzt muss noch geschaut werden, wo die Einheit die jeweils besten
* Werte hat, das kommt aber erst irgendwo spaeter. Ich entscheide
* waehrend des Kampfes, welche ich nehme, je nach Gegner. Deswegen auch
* keine addierten boni. */
/* Zuerst mal die Spezialbehandlung gewisser Sonderfaelle. */
fig->magic = effskill(u, SK_MAGIC, NULL);
if (fig->horses) {
if (!fval(r->terrain, CAVALRY_REGION) || r_isforest(r)
|| effskill(u, SK_RIDING, NULL) < CavalrySkill()
|| u_race(u) == get_race(RC_TROLL) || fval(u, UFL_WERE))
fig->horses = 0;
}
if (fig->elvenhorses) {
if (effskill(u, SK_RIDING, NULL) < 5 || u_race(u) == get_race(RC_TROLL)
|| fval(u, UFL_WERE))
fig->elvenhorses = 0;
}
/* Schauen, wie gut wir in Taktik sind. */
if (tactics > 0 && u_race(u) == get_race(RC_INSECT))
tactics -= 1 - (int)log10(fig->side->size[SUM_ROW]);
#ifdef TACTICS_MODIFIER
if (tactics > 0 && statusrow(fig->status) == FIGHT_ROW)
tactics += TACTICS_MODIFIER;
if (tactics > 0 && statusrow(fig->status) > BEHIND_ROW) {
tactics -= TACTICS_MODIFIER;
}
#endif
if (tactics > 0) {
int bonus = 0;
for (i = 0; i < fig->alive; i++) {
int p_bonus = 0;
int rnd;
do {
rnd = (int)(rng_int() % 100);
if (rnd >= 40 && rnd <= 69)
p_bonus += 1;
else if (rnd <= 89)
p_bonus += 2;
else
p_bonus += 3;
} while (rnd >= 97);
if (p_bonus > bonus) p_bonus = bonus;
}
tactics += bonus;
}
add_tactics(&fig->side->leader, fig, tactics);
++b->nfighters;
return fig;
}
int join_battle(battle * b, unit * u, bool attack, fighter ** cp)
{
side *s;
fighter *fc = NULL;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *fig;
if (s->faction == u->faction) {
for (fig = s->fighters; fig; fig = fig->next) {
if (fig->unit == u) {
fc = fig;
if (attack) {
set_attacker(fig);
}
break;
}
}
}
}
if (!fc) {
*cp = make_fighter(b, u, NULL, attack);
return *cp != NULL;
}
*cp = fc;
return false;
}
battle *make_battle(region * r)
{
unit *u;
bfaction *bf;
building * bld;
battle *b = (battle *)calloc(1, sizeof(battle));
assert(b);
/* Alle Mann raus aus der Burg! */
for (bld = r->buildings; bld != NULL; bld = bld->next)
bld->sizeleft = bld->size;
b->region = r;
b->plane = getplane(r);
/* Finde alle Parteien, die den Kampf beobachten koennen: */
for (u = r->units; u; u = u->next) {
if (u->number > 0) {
if (!fval(u->faction, FFL_MARK)) {
fset(u->faction, FFL_MARK);
for (bf = b->factions; bf; bf = bf->next) {
if (bf->faction == u->faction)
break;
}
if (!bf) {
bf = (bfaction *)calloc(1, sizeof(bfaction));
assert(bf);
++b->nfactions;
bf->faction = u->faction;
bf->next = b->factions;
b->factions = bf;
}
}
}
}
for (bf = b->factions; bf; bf = bf->next) {
faction *f = bf->faction;
freset(f, FFL_MARK);
}
return b;
}
static void free_side(side * si)
{
selist_free(si->leader.fighters);
}
static void free_fighter(fighter * fig)
{
armor **ap = &fig->armors;
while (*ap) {
armor *a = *ap;
*ap = a->next;
free(a);
}
while (fig->loot) {
i_free(i_remove(&fig->loot, fig->loot));
}
free(fig->person);
free(fig->weapons);
}
static void battle_free(battle * b) {
side *s;
assert(b);
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter **fp = &s->fighters;
while (*fp) {
fighter *fig = *fp;
*fp = fig->next;
free_fighter(fig);
free(fig);
}
s->fighters = NULL;
free_side(s);
}
free(b);
}
void free_battle(battle * b)
{
while (b->factions) {
bfaction *bf = b->factions;
b->factions = bf->next;
free(bf);
}
selist_free(b->leaders);
selist_foreach(b->meffects, free);
selist_free(b->meffects);
battle_free(b);
}
static int *get_alive(side * s)
{
return s->size;
}
static int battle_report(battle * b)
{
side *s, *s2;
bool cont = false;
bfaction *bf;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
if (s->alive - s->removed > 0) {
for (s2 = b->sides; s2 != b->sides + b->nsides; ++s2) {
if (s2->alive - s2->removed > 0 && enemy(s, s2)) {
cont = true;
break;
}
}
if (cont)
break;
}
}
fflush(stdout);
for (bf = b->factions; bf; bf = bf->next) {
faction *fac = bf->faction;
char buf[32 * MAXSIDES];
message *m;
sbstring sbs;
bool komma = false;
sbs_init(&sbs, buf, sizeof(buf));
if (cont)
m = msg_message("para_lineup_battle", "turn", b->turn);
else
m = msg_message("para_after_battle", "");
battle_message_faction(b, fac, m);
msg_release(m);
for (s = b->sides; s != b->sides + b->nsides; ++s) {
if (s->alive) {
int r, k = 0, *alive = get_alive(s);
int l = FIGHT_ROW;
const char *abbrev = seematrix(fac, s) ? sideabkz(s, false) : "-?-";
const char *loc_army = LOC(fac->locale, "battle_army");
char buffer[32];
if (komma) {
sbs_strcat(&sbs, ", ");
}
snprintf(buffer, sizeof(buffer), "%s %2d(%s): ",
loc_army, army_index(s), abbrev);
sbs_strcat(&sbs, buffer);
for (r = FIGHT_ROW; r != NUMROWS; ++r) {
if (alive[r]) {
if (l != FIGHT_ROW) {
sbs_strcat(&sbs, "+");
}
while (k--) {
sbs_strcat(&sbs, "0+");
}
sprintf(buffer, "%d", alive[r]);
sbs_strcat(&sbs, buffer);
k = 0;
l = r + 1;
}
else
++k;
}
komma = true;
}
}
fbattlerecord(b, fac, buf);
}
return cont;
}
static void join_allies(battle * b)
{
region *r = b->region;
unit *u;
side *s, *s_end = b->sides + b->nsides;
/* make_side might be adding a new faction, but it adds them to the end
* of the list, so we're safe in our iteration here if we remember the end
* up front. */
for (u = r->units; u; u = u->next) {
/* Was ist mit Schiffen? */
if (u->status != ST_FLEE && u->status != ST_AVOID
&& !fval(u, UFL_LONGACTION | UFL_ISNEW) && u->number > 0) {
faction *f = u->faction;
fighter *c = NULL;
for (s = b->sides; s != s_end; ++s) {
side *se;
/* Wenn alle attackierten noch FFL_NOAID haben, dann kaempfe nicht mit. */
if (fval(s->faction, FFL_NOAID))
continue;
if (s->faction != f) {
/* Wenn wir attackiert haben, kommt niemand mehr hinzu: */
if (s->bf->attacker)
continue;
/* alliiert muessen wir schon sein, sonst ist's eh egal : */
if (!alliedunit(u, s->faction, HELP_FIGHT))
continue;
/* wenn die partei verborgen ist, oder gar eine andere
* vorgespiegelt wird, und er sich uns gegenueber nicht zu
* erkennen gibt, helfen wir ihm nicht */
if (s->stealthfaction) {
if (!alliedside(s, u->faction, HELP_FSTEALTH)) {
continue;
}
}
}
/* einen alliierten angreifen duerfen sie nicht, es sei denn, der
* ist mit einem alliierten verfeindet, der nicht attackiert
* hat: */
for (se = b->sides; se != s_end; ++se) {
if (u->faction == se->faction)
continue;
if (alliedunit(u, se->faction, HELP_FIGHT) && !se->bf->attacker) {
continue;
}
if (enemy(s, se))
break;
}
if (se == s_end)
continue;
/* keine Einwaende, also soll er mitmachen: */
if (c == NULL) {
if (!join_battle(b, u, false, &c)) {
continue;
}
}
/* the enemy of my friend is my enemy: */
for (se = b->sides; se != s_end; ++se) {
if (se->faction != u->faction && enemy(s, se)) {
set_enemy(se, c->side, false);
}
}
}
}
}
for (s = b->sides; s != b->sides + b->nsides; ++s) {
int si;
side *sa;
faction *f = s->faction;
/* Den Feinden meiner Feinde gebe ich Deckung (gegen gemeinsame Feinde): */
for (si = 0; s->enemies[si]; ++si) {
side *se = s->enemies[si];
int ai;
for (ai = 0; se->enemies[ai]; ++ai) {
side *as = se->enemies[ai];
if (as == s || !enemy(as, s)) {
set_friendly(as, s);
}
}
}
for (sa = s + 1; sa != b->sides + b->nsides; ++sa) {
if (!enemy(s, sa) && !friendly(s, sa)) {
if (alliedfaction(f, sa->faction, HELP_FIGHT)) {
if (alliedfaction(sa->faction, f, HELP_FIGHT)) {
set_friendly(s, sa);
}
}
}
}
}
}
static void flee(const troop dt)
{
fighter *fig = dt.fighter;
unit *u = fig->unit;
int fchance = fleechance(u);
if (fig->person[dt.index].flags & FL_PANICED) {
fchance += EFFECT_PANIC_SPELL;
}
if (fchance > flee_chance_max_percent) {
fchance = flee_chance_max_percent;
}
if (rng_int() % 100 < fchance) {
fig->run.hp += fig->person[dt.index].hp;
++fig->run.number;
setguard(u, false);
kill_troop(dt);
}
}
static bool is_calmed(const unit *u, const faction *f) {
attrib *a = a_find(u->attribs, &at_curse);
while (a && a->type == &at_curse) {
curse *c = (curse *)a->data.v;
if (c->type == &ct_calmmonster && curse_geteffect_int(c) == f->uid) {
if (curse_active(c)) {
return true;
}
}
a = a->next;
}
return false;
}
static bool start_battle(region * r, battle ** bp)
{
battle *b = NULL;
unit *u;
bool fighting = false;
for (u = r->units; u != NULL; u = u->next) {
if (fval(u, UFL_LONGACTION))
continue;
if (u->number > 0) {
order *ord;
for (ord = u->orders; ord; ord = ord->next) {
if (getkeyword(ord) == K_ATTACK) {
unit *u2;
fighter *c1, *c2;
ship *lsh = NULL;
plane *pl = rplane(r);
if (pl && fval(pl, PFL_NOATTACK)) {
cmistake(u, ord, 271, MSG_BATTLE);
continue;
}
if (u_race(u)->battle_flags & BF_NO_ATTACK) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "race_no_attack",
"race", u_race(u)));
continue;
}
/**
** Fehlerbehandlung Angreifer
**/
if (LongHunger(u)) {
cmistake(u, ord, 225, MSG_BATTLE);
continue;
}
if (u->status == ST_AVOID || u->status == ST_FLEE) {
cmistake(u, ord, 226, MSG_BATTLE);
continue;
}
/* ist ein Fluechtling aus einem andern Kampf */
if (fval(u, UFL_LONGACTION))
continue;
if (curse_active(get_curse(r->attribs, &ct_peacezone))) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "peace_active", ""));
continue;
}
if (curse_active(get_curse(u->attribs, &ct_slavery))) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "slave_active", ""));
continue;
}
if ((u->ship != NULL && !fval(r->terrain, SEA_REGION))
|| (lsh = leftship(u)) != NULL) {
if (is_guarded(r, u)) {
if (lsh) {
cmistake(u, ord, 234, MSG_BATTLE);
}
else {
/* Fehler: "Das Schiff muss erst verlassen werden" */
cmistake(u, ord, 19, MSG_BATTLE);
}
continue;
}
}
/* Ende Fehlerbehandlung Angreifer */
init_order_depr(ord);
/* attackierte Einheit ermitteln */
getunit(r, u->faction, &u2);
/* Beginn Fehlerbehandlung */
/* Fehler: "Die Einheit wurde nicht gefunden" */
if (!u2 || u2->number == 0 || !cansee(u->faction, u->region, u2, 0)) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord,
"feedback_unit_not_found", ""));
continue;
}
/* Fehler: "Die Einheit ist eine der unsrigen" */
if (u2->faction == u->faction) {
cmistake(u, ord, 45, MSG_BATTLE);
continue;
}
/* Fehler: "Die Einheit ist mit uns alliert" */
if (alliedunit(u, u2->faction, HELP_FIGHT)) {
cmistake(u, ord, 47, MSG_BATTLE);
continue;
}
if (IsImmune(u2->faction)) {
add_message(&u->faction->msgs,
msg_feedback(u, u->thisorder, "newbie_immunity_error", "turns",
NewbieImmunity()));
continue;
}
/* Fehler: "Die Einheit ist mit uns alliert" */
if (is_calmed(u, u2->faction)) {
cmistake(u, ord, 47, MSG_BATTLE);
continue;
}
/* Ende Fehlerbehandlung */
if (b == NULL) {
unit *utmp;
for (utmp = r->units; utmp != NULL; utmp = utmp->next) {
fset(utmp->faction, FFL_NOAID);
}
b = make_battle(r);
}
join_battle(b, u, true, &c1);
join_battle(b, u2, false, &c2);
if (u2->attribs) {
if (it_mistletoe) {
int effect = get_effect(u2, it_mistletoe);
if (effect >= u->number) {
change_effect(u2, it_mistletoe, -u2->number);
c2->run.hp = u2->hp;
c2->run.number = u2->number;
c2->side->flee += u2->number;
setguard(u2, false);
rmfighter(c2, u2->number);
}
}
}
/* Hat die attackierte Einheit keinen Noaid-Status,
* wird das Flag von der Faction genommen, andere
* Einheiten greifen ein. */
if (!fval(u2, UFL_NOAID))
freset(u2->faction, FFL_NOAID);
if (c1 && c2 && c2->run.number < c2->unit->number) {
/* Merken, wer Angreifer ist, fuer die Rueckzahlung der
* Praecombataura bei kurzem Kampf. */
c1->side->bf->attacker = true;
set_enemy(c1->side, c2->side, true);
fighting = true;
}
}
}
}
}
*bp = b;
return fighting;
}
/** execute one round of attacks
* fig->fighting is used to determine who attacks, not fig->alive, since
* the latter may be influenced by attacks that already took place.
*/
static void battle_attacks(battle * b)
{
side *s;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *fig;
if (b->turn != 0 || (b->max_tactics > 0
&& get_tactics(s, NULL) == b->max_tactics)) {
for (fig = s->fighters; fig; fig = fig->next) {
/* ist in dieser Einheit noch jemand handlungsfaehig? */
if (fig->fighting <= 0)
continue;
/* Handle the unit's attack on someone */
do_attack(fig);
}
}
}
}
/** updates the number of attacking troops in each fighter struct.
* this has to be calculated _before_ the actual attacks take
* place because otherwise dead troops would not strike in the
* round they die. */
static void battle_update(battle * b)
{
side *s;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *fig;
for (fig = s->fighters; fig; fig = fig->next) {
fig->fighting = fig->alive - fig->removed;
}
}
}
/** attempt to flee from battle before the next round begins
* there's a double attempt before the first round, but only
* one attempt before round zero, the potential tactics round. */
static void battle_flee(battle * b)
{
int attempt, flee_ops = 1;
if (b->turn == 1)
flee_ops = 2;
for (attempt = 1; attempt <= flee_ops; ++attempt) {
side *s;
for (s = b->sides; s != b->sides + b->nsides; ++s) {
fighter *fig;
for (fig = s->fighters; fig; fig = fig->next) {
unit *u = fig->unit;
troop dt;
/* Flucht nicht bei mehr als 600 HP. Damit Wyrme toetbar bleiben. */
int runhp = (int)(0.9 + unit_max_hp(u) * hpflee(u->status));
if (runhp > 600) runhp = 600;
if (u->ship && fval(u->region->terrain, SEA_REGION)) {
/* keine Flucht von Schiffen auf hoher See */
continue;
}
if (fval(u_race(u), RCF_UNDEAD) || u_race(u) == get_race(RC_SHADOWKNIGHT)) {
/* Untote fliehen nicht. Warum eigentlich? */
continue;
}
dt.fighter = fig;
dt.index = fig->alive - fig->removed;
while (s->size[SUM_ROW] && dt.index != 0) {
--dt.index;
assert(dt.index >= 0 && dt.index < fig->unit->number);
assert(fig->person[dt.index].hp > 0);
/* Versuche zu fliehen, wenn
* - Kampfstatus fliehe
* - schwer verwundet und nicht erste kampfrunde
* - in panik (Zauber)
* aber nicht, wenn der Zaubereffekt Held auf dir liegt!
*/
switch (u->status) {
case ST_FLEE:
break;
default:
if ((fig->person[dt.index].flags & FL_HIT) == 0)
continue;
if (fig->person[dt.index].hp <= runhp)
break;
if (fig->person[dt.index].flags & FL_PANICED) {
if ((fig->person[dt.index].flags & FL_COURAGE) == 0)
break;
}
continue;
}
flee(dt);
}
}
}
}
}
static bool is_enemy(battle *b, unit *u1, unit *u2) {
if (u1->faction != u2->faction) {
if (b) {
side *es, *s1 = 0, *s2 = 0;
for (es = b->sides; es != b->sides + b->nsides; ++es) {
if (!s1 && es->faction == u1->faction) s1 = es;
else if (!s2 && es->faction == u2->faction) s2 = es;
if (s1 && s2) {
return enemy(s1, s2);
}
}
}
else {
return !help_enter(u1, u2);
}
}
return false;
}
void force_leave(region *r, battle *b) {
unit *u;
for (u = r->units; u; u = u->next) {
unit *uo = NULL;
if (u->building) {
uo = building_owner(u->building);
}
if (u->ship && r->land) {
uo = ship_owner(u->ship);
}
if (uo && is_enemy(b, uo, u)) {
message *msg = NULL;
if (u->building) {
msg = msg_message("force_leave_building", "unit owner building", u, uo, u->building);
}
else {
msg = msg_message("force_leave_ship", "unit owner ship", u, uo, u->ship);
}
if (msg) {
ADDMSG(&u->faction->msgs, msg);
}
leave(u, false);
}
}
}
static void do_battle(region * r) {
battle *b = NULL;
bool fighting;
ship *sh;
fighting = start_battle(r, &b);
if (b == NULL)
return;
/* Bevor wir die alliierten hineinziehen, sollten wir schauen, *
* Ob jemand fliehen kann. Dann eruebrigt sich das ganze ja
* vielleicht schon. */
report_battle_start(b);
if (!fighting) {
/* Niemand mehr da, Kampf kann nicht stattfinden. */
message *m = msg_message("aborted_battle", "");
message_all(b, m);
msg_release(m);
free_battle(b);
return;
}
join_allies(b);
make_heroes(b);
/* make sure no ships are damaged initially */
for (sh = r->ships; sh; sh = sh->next)
freset(sh, SF_DAMAGED);
/* Gibt es eine Taktikrunde ? */
if (!selist_empty(b->leaders)) {
b->turn = 0;
b->has_tactics_turn = true;
}
else {
b->turn = 1;
b->has_tactics_turn = false;
}
/* PRECOMBATSPELLS */
do_combatmagic(b, DO_PRECOMBATSPELL);
print_stats(b); /* gibt die Kampfaufstellung aus */
log_debug("battle in %s (%d, %d) : ", regionname(r, 0), r->x, r->y);
for (; battle_report(b) && b->turn <= max_turns; ++b->turn) {
battle_flee(b);
battle_update(b);
battle_attacks(b);
}
/* Auswirkungen berechnen: */
aftermath(b);
if (rule_force_leave(FORCE_LEAVE_POSTCOMBAT)) {
force_leave(b->region, b);
}
/* Hier ist das Gefecht beendet, und wir koennen die
* Hilfsstrukturen * wieder loeschen: */
free_battle(b);
}
void do_battles(void) {
region *r;
init_rules();
for (r = regions; r; r = r->next) {
do_battle(r);
}
}
Reference in a new issue View git blame Copy permalink