server/src/common/gamecode/randenc.c
2001-02-10 14:18:01 +00:00

1510 lines
38 KiB
C

/* vi: set ts=2:
*
* $Id: randenc.c,v 1.9 2001/02/10 14:18:00 enno Exp $
* Eressea PB(E)M host Copyright (C) 1998-2000
* Christian Schlittchen (corwin@amber.kn-bremen.de)
* Katja Zedel (katze@felidae.kn-bremen.de)
* Henning Peters (faroul@beyond.kn-bremen.de)
* Enno Rehling (enno@eressea-pbem.de)
* Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
*
* based on:
*
* Atlantis v1.0 13 September 1993 Copyright 1993 by Russell Wallace
* Atlantis v1.7 Copyright 1996 by Alex Schröder
*
* This program may not be used, modified or distributed without
* prior permission by the authors of Eressea.
* This program may not be sold or used commercially without prior written
* permission from the authors.
*/
#include <config.h>
#include "eressea.h"
#include "randenc.h"
#include "unit.h"
#include "faction.h"
#include "alchemy.h"
#include "item.h"
#include "plane.h"
#include "economy.h"
#include "building.h"
#include "magic.h"
#include "message.h"
#include "race.h"
#include "monster.h"
#include "creation.h"
#include "names.h"
#include "pool.h"
#include "movement.h"
#include "curse.h"
#include "region.h"
#include "skill.h"
#include "karma.h"
#include "ship.h"
#include "battle.h"
/* util includes */
#include <rand.h>
/* libc includes */
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <attributes/iceberg.h>
extern attrib_type at_unitdissolve;
extern attrib_type at_orcification;
int
nrand(int start, int sub)
{
int res = 0;
do {
if (rand() % 100 < start)
res++;
start -= sub;
} while (start > 0);
return res;
}
/* In a->data.ca[1] steht der Prozentsatz mit dem sich die Einheit
* auflöst, in a->data.ca[0] kann angegeben werden, wohin die Personen
* verschwinden. Passiert bereits in der ersten Runde! */
static void
dissolve_units(void)
{
region *r;
unit *u;
int n;
int i;
for (r=regions;r;r=r->next) {
for (u=r->units;u;u=u->next) {
attrib * a = a_find(u->attribs, &at_unitdissolve);
if (a) {
if (u->age == 0 && a->data.ca[1] < 100) continue;
/* TODO: Durch einzelne Berechnung ersetzen */
if (a->data.ca[1] == 100) {
n = u->number;
} else {
n = 0;
for (i=0;i<u->number;i++) {
if (rand()%100 < a->data.ca[1]) n++;
}
}
/* wenn keiner verschwindet, auch keine Meldung */
if (n == 0) {
continue;
}
scale_number(u,u->number - n);
sprintf(buf, "%s in %s: %d %s ", unitname(u), regionid(r),
n, race[u->race].name[ n == 1 ? 0 : 1]);
switch(a->data.ca[0]) {
case 1:
rsetpeasants(r, rpeasants(r) + n);
if (n == 1) {
scat("kehrte auf sein Feld zurück.");
}else{
scat("kehrten auf ihre Felder zurück.");
}
break;
case 2:
rsettrees(r, rtrees(r) + n);
if (n == 1) {
scat("wurde zum Baum.");
}else{
scat("wurden zu Bäumen.");
}
break;
default:
if (u->race == RC_STONEGOLEM || u->race == RC_IRONGOLEM) {
if (n == 1) {
scat("zerfiel zu Staub.");
}else{
scat("zerfielen zu Staub.");
}
}else{
if (n == 1) {
scat("verschwand über Nacht.");
}else{
scat("verschwanden über Nacht.");
}
}
break;
}
addmessage(r, u->faction, buf, MSG_EVENT, ML_INFO);
}
}
}
remove_empty_units();
}
int
improve_all(faction * f, skill_t s, int g)
{
region *r;
unit *u;
int n = 0;
region *last = lastregion(f);
for (r = firstregion(f); r != last; r = r->next) {
for (u = r->units; u; u = u->next) {
if (u->faction == f && get_skill(u, s) > 0) {
n += u->number;
change_skill(u, s, u->number * g);
}
}
}
return n;
}
void
find_manual(region * r, unit * u)
{
skill_t skill = NOSKILL;
sprintf(buf, "%s stolper%c bei der Erforschung der Region über ",
unitname(u), "nt"[u->number == 1]);
switch (rand() % 4) {
case 0:
scat("die Ruine eines alten Tempels");
break;
case 1:
scat("eine alte Burgruine");
break;
case 2:
scat("ein zerfallenes Bauernhaus");
break;
case 3:
scat("eine Leiche am Wegesrand");
break;
}
scat(". Bei der Durchsuchung ");
if (u->number == 1) {
scat("stößt");
} else {
scat("stoßen");
}
scat(" sie auf das zerfledderte Exemplar eines alten Buches, betitelt ");
switch (rand() % 36) {
case 0:
scat("\'Magie der Elemente\'");
skill = SK_MAGIC;
break;
case 1:
case 2:
case 3:
case 4:
scat("\'Schwerter, Armbrüste, Langbögen\'");
skill = SK_WEAPONSMITH;
break;
case 5:
case 6:
scat("\'Gorms Almanach der Rationellen Kriegsführung\'");
skill = SK_TACTICS;
break;
case 7:
case 8:
case 9:
case 10:
scat("\'Katamarane, Koggen, Karavellen\'");
skill = SK_SHIPBUILDING;
break;
case 11:
case 12:
case 13:
case 14:
scat("\'Wege der Sterne\'");
skill = SK_SAILING;
break;
case 15:
case 16:
case 17:
scat("\'Nadishahs Kleine Gift- und Kräuterkunde\'");
skill = SK_HERBALISM;
break;
case 18:
case 19:
scat("\'Mandricks Kompendium der Alchemie\'");
skill = SK_ALCHEMY;
break;
case 20:
case 21:
case 22:
case 23:
scat("\'Die Konstruktion der Burgen und Schlösser von Zentralandune\'");
skill = SK_BUILDING;
break;
case 24:
case 25:
case 26:
case 27:
scat("\'Die Esse\'");
skill = SK_ARMORER;
break;
case 28:
case 29:
case 30:
case 31:
scat("\'Über die Gewinnung von Erzen\'");
skill = SK_MINING;
break;
case 32:
case 33:
case 34:
case 35:
scat("\'Barinions Lieder, eine Einführung für Unbedarfte\'");
skill = SK_ENTERTAINMENT;
break;
}
scat(". Der Wissensschub ist enorm.");
addmessage(r, u->faction, buf, MSG_EVENT, ML_IMPORTANT);
if (improve_all(u->faction, skill, 90) == 0) {
change_skill(u, skill, 270);
}
}
void
get_unit(region * r, unit * u)
{
unit *newunit;
sprintf(buf, "%s entdeck%s ein kleines Dorf. Die meisten Häuser "
"wurden durch einen über die Ufer getretenen Fluß zerstört. Eine "
"Gruppe der verzweifelten Menschen schließt sich deiner Partei an.",
unitname(u), "en\0t" + (3 - 3 * (u->number == 1)));
addmessage(r, u->faction, buf, MSG_EVENT, ML_IMPORTANT);
newunit = createunit(r, u->faction, rand() % 20 + 3, u->faction->race);
set_string(&newunit->name, "Dorfbewohner");
set_money(newunit, (rand() % 26 + 10) * newunit->number);
fset(newunit, FL_ISNEW);
if (fval(u, FL_PARTEITARNUNG)) fset(newunit, FL_PARTEITARNUNG);
switch (rand() % 4) {
case 0:
set_skill(newunit, SK_MINING, 30 * newunit->number);
break;
case 1:
set_skill(newunit, SK_LUMBERJACK, 30 * newunit->number);
break;
case 2:
set_skill(newunit, SK_CARTMAKER, 30 * newunit->number);
break;
case 3:
set_skill(newunit, SK_QUARRYING, 30 * newunit->number);
break;
}
set_item(newunit, I_WAGON, rand() % 2);
set_item(newunit, I_HORSE, min(get_item(newunit, I_WAGON) * 2, rand() % 5));
}
void
get_allies(region * r, unit * u)
{
unit *newunit = NULL;
switch (rterrain(r)) {
case T_PLAIN:
if (!r_isforest(r)) {
if (get_money(u) / u->number < 100 + rand() % 200)
return;
newunit = createunit(r, u->faction, rand() % 8 + 2, u->faction->race);
set_string(&newunit->name, "Söldner");
set_money(newunit, (rand() % 80 + 20) * newunit->number);
switch (rand() % 4) {
case 0:
set_skill(newunit, SK_SWORD, (30 + rand() % 120) * newunit->number);
set_item(newunit, I_SWORD, newunit->number);
break;
case 1:
set_skill(newunit, SK_SPEAR, (30 + rand() % 120) * newunit->number);
set_item(newunit, I_SPEAR, newunit->number);
break;
case 2:
set_skill(newunit, SK_CROSSBOW, (30 + rand() % 120) * newunit->number);
set_item(newunit, I_CROSSBOW, newunit->number);
break;
case 3:
set_skill(newunit, SK_LONGBOW, (30 + rand() % 120) * newunit->number);
set_item(newunit, I_LONGBOW, newunit->number);
break;
}
if (rand() % 100 < 40) {
set_item(newunit, I_CHAIN_MAIL, rand() % (newunit->number + 1));
}
if (rand() % 100 < 30) {
set_item(newunit, I_HORSE, newunit->number);
set_skill(newunit, SK_RIDING, (30 + rand() % 120) * newunit->number);
}
break;
} else {
if (eff_skill(u, SK_LONGBOW, r) < 3
&& eff_skill(u, SK_HERBALISM, r) < 2
&& eff_skill(u, SK_MAGIC, r) < 2) {
return;
}
newunit = createunit(r, u->faction, rand() % 6 + 2, u->faction->race);
set_string(&newunit->name, "Waldbewohner");
set_money(newunit, (rand() % 20 + 10) * newunit->number);
set_skill(newunit, SK_LONGBOW, (90 + rand() % 210) * newunit->number);
set_item(newunit, I_LONGBOW, newunit->number);
set_skill(newunit, SK_OBSERVATION, (90 + rand() % 110) * newunit->number);
set_skill(newunit, SK_STEALTH, (30 + rand() % 80) * newunit->number);
if (rand() % 100 < 20) {
set_skill(newunit, SK_HERBALISM, (30 + rand() % 10) * newunit->number);
}
}
break;
case T_SWAMP:
if (eff_skill(u, SK_OBSERVATION, r) <= 3) {
return;
}
newunit = createunit(r, u->faction, rand() % 6 + 2, u->faction->race);
set_string(&newunit->name, "Sumpfbewohner");
set_money(newunit, (rand() % 20 + 10) * newunit->number);
set_skill(newunit, SK_SPEAR, (90 + rand() % 210) * newunit->number);
set_item(newunit, I_SPEAR, newunit->number);
set_skill(newunit, SK_STEALTH, (90 + rand() % 120) * newunit->number);
break;
case T_DESERT:
if (eff_skill(u, SK_RIDING, r) <= 2) {
return;
}
newunit = createunit(r, u->faction, rand() % 12 + 2, u->faction->race);
set_string(&newunit->name, "Berber");
set_money(newunit, (rand() % 30 + 20) * newunit->number);
set_skill(newunit, SK_SWORD, (30 + rand() % 60) * newunit->number);
set_item(newunit, I_SWORD, newunit->number);
set_skill(newunit, SK_TRADE, (30 + rand() % 60) * newunit->number);
set_skill(newunit, SK_RIDING, (90 + rand() % 60) * newunit->number);
set_item(newunit, I_HORSE, newunit->number);
set_skill(newunit, SK_HORSE_TRAINING, (90 + rand() % 120) * newunit->number);
break;
case T_HIGHLAND:
if (eff_skill(u, SK_SWORD, r) <= 1) {
return;
}
newunit = createunit(r, u->faction, rand() % 8 + 2, u->faction->race);
set_string(&newunit->name, "Hochlandbarbaren");
set_money(newunit, (rand() % 10 + 20) * newunit->number);
set_skill(newunit, SK_SWORD, (60 + rand() % 60) * newunit->number);
set_item(newunit, I_SWORD, newunit->number);
break;
case T_MOUNTAIN:
if (eff_skill(u, SK_SWORD, r) <= 1
|| eff_skill(u, SK_TRADE, r) <= 2) {
return;
}
newunit = createunit(r, u->faction, rand() % 6 + 2, u->faction->race);
set_string(&newunit->name, "Bergbewohner");
set_money(newunit, (rand() % 40 + 60) * newunit->number);
set_skill(newunit, SK_SWORD, (90 + rand() % 60) * newunit->number);
set_item(newunit, I_SWORD, newunit->number);
set_skill(newunit, SK_ARMORER, (90 + rand() % 60) * newunit->number);
set_skill(newunit, SK_TRADE, (30 + rand() % 120) * newunit->number);
if (rand() % 100 < 60) {
set_item(newunit, I_PLATE_ARMOR, newunit->number);
}
break;
case T_GLACIER:
if (eff_skill(u, SK_SWORD, r) <= 1
|| eff_skill(u, SK_TRADE, r) <= 1) {
return;
}
newunit = createunit(r, u->faction, rand() % 4 + 2, u->faction->race);
set_string(&newunit->name, "Eisleute");
set_money(newunit, (rand() % 20 + 20) * newunit->number);
set_skill(newunit, SK_SWORD, (90 + rand() % 60) * newunit->number);
set_item(newunit, I_SWORD, newunit->number);
set_skill(newunit, SK_ARMORER, (90 + rand() % 60) * newunit->number);
break;
}
u_setfaction(newunit, u->faction);
if (u->race==RC_DAEMON) newunit->irace=u->irace;
if (fval(u, FL_PARTEITARNUNG)) fset(newunit, FL_PARTEITARNUNG);
fset(u, FL_ISNEW);
sprintf(buf, "Plötzlich stolper%c %s über einige %s. Nach kurzem "
"Zögern entschließen sich die %s, sich Deiner Partei anzuschließen.",
u->number == 1 ? 't' : 'n', unitname(u), newunit->name, newunit->name);
addmessage(r, u->faction, buf, MSG_EVENT, ML_IMPORTANT);
}
void
encounter(region * r, unit * u)
{
if (!fval(r, RF_ENCOUNTER)) return;
freset(r, RF_ENCOUNTER);
if (rand() % 100>=ENCCHANCE) return;
switch (rand() % 3) {
case 0:
find_manual(r, u);
break;
case 1:
get_unit(r, u);
break;
case 2:
get_allies(r, u);
break;
}
}
void
encounters(void)
{
region *r;
unit *u;
int n;
int c;
int i;
for (r = regions; r; r = r->next) {
if (rterrain(r) != T_OCEAN && fval(r, RF_ENCOUNTER)) {
c = 0;
for (u = r->units; u; u = u->next) {
c += u->number;
}
if (c > 0) {
n = rand() % c;
u = r->units;
for (i = u->number; i < n; i += u->number) {
u = u->next;
}
encounter(r, u);
}
}
}
}
void
chaos(region * r)
{
unit *u = NULL, *u2;
building *b, *b2;
if (rand() % 100 < 8) {
switch (rand() % 3) {
case 0: /* Untote */
if (rterrain(r) != T_OCEAN) {
u = random_unit(r);
if (u && !nonplayer(u)) {
sprintf(buf, "%s scheint von einer seltsamen Krankheit befallen.",
unitname(u));
addmessage(0, u->faction, buf, MSG_EVENT, ML_IMPORTANT);
u_setfaction(u, findfaction(MONSTER_FACTION));
u->race = RC_GHOUL;
}
}
break;
case 1: /* Drachen */
if (random_unit(r)) {
int mfac = 0;
switch (rand() % 3) {
case 0:
mfac = 100;
u = createunit(r, findfaction(MONSTER_FACTION), rand() % 8 + 1, RC_FIREDRAGON);
if (u->number == 1) {
set_string(&u->name, "Feuerdrache");
} else {
set_string(&u->name, "Feuerdrachen");
}
break;
case 1:
mfac = 500;
u = createunit(r, findfaction(MONSTER_FACTION), rand() % 4 + 1, RC_DRAGON);
if (u->number == 1) {
set_string(&u->name, "Drache");
} else {
set_string(&u->name, "Drachen");
}
break;
case 2:
mfac = 1000;
u = createunit(r, findfaction(MONSTER_FACTION), rand() % 2 + 1, RC_WYRM);
if (u->number == 1) {
set_string(&u->name, "Wyrm");
} else {
set_string(&u->name, "Wyrme");
}
break;
}
if (mfac) set_money(u, u->number * (rand() % mfac));
guard(u, GUARD_ALL);
}
case 2: /* Terrainveränderung */
if (rterrain(r) != T_FIREWALL) {
if (rterrain(r) != T_OCEAN) {
direction_t dir;
for (dir=0;dir!=MAXDIRECTIONS;++dir) {
if (rconnect(r, dir) && rterrain(rconnect(r, dir)) == T_OCEAN) break;
}
if (dir!=MAXDIRECTIONS) {
ship * sh = r->ships;
while (sh) {
ship * nsh = sh->next;
damage_ship(sh, 0.50);
if (sh->damage >= sh->size * DAMAGE_SCALE) destroy_ship(sh, r);
sh = nsh;
}
for (u = r->units; u;) {
u2 = u->next;
if (u->race != RC_SPELL && u->ship == 0) {
set_number(u, 0);
}
u = u2;
}
sprintf(buf, "Ein gewaltige Flutwelle verschlingt %s und "
"alle Bewohner.", regionid(r));
addmessage(r, 0, buf, MSG_EVENT, ML_IMPORTANT);
for (b = rbuildings(r); b;) {
b2 = b->next;
destroy_building(b);
b = b2;
}
terraform(r, T_OCEAN);
}
} else {
direction_t dir;
for (dir=0;dir!=MAXDIRECTIONS;++dir) {
if (rconnect(r, dir) && rterrain(rconnect(r, dir)) != T_OCEAN) break;
}
if (dir!=MAXDIRECTIONS) {
switch (rand() % 8) {
case 0:
terraform(r, T_PLAIN);
break;
case 1:
terraform(r, T_HIGHLAND);
break;
case 2:
terraform(r, T_MOUNTAIN);
break;
case 3:
terraform(r, T_GLACIER);
break;
case 4:
terraform(r, T_DESERT);
break;
default:
terraform(r, T_SWAMP);
break;
}
}
}
}
}
}
}
double
chaosfactor(region * r)
{
attrib * a = a_find(r->attribs, &at_chaoscount);
if (!a) return 0;
return ((double) a->data.i / 1000.0);
}
void
drown(void)
{
region *r;
for (r=regions; r; r=r->next) if (rterrain(r) == T_OCEAN) {
unit ** up = up=&r->units;
while (*up) {
unit *u = *up;
int amphibian_level = fspecial(u->faction, FS_AMPHIBIAN);
if (u->ship) {
up=&u->next;
continue;
}
if (amphibian_level) {
int dead = damage_unit(u, "5d1", false, false);
if (dead) {
add_message(&u->faction->msgs, new_message(u->faction,
"drown_amphibian_dead%d:amount%u:unit",dead, u));
} else {
add_message(&u->faction->msgs, new_message(u->faction,
"drown_amphibian_nodead%u:unit",u));
}
} else if (!canswim(u)) {
scale_number(u, 0);
add_message(&u->faction->msgs, new_message(u->faction,
"drown%u:unit",u));
}
if (*up==u) up=&u->next;
}
remove_empty_units_in_region(r);
}
}
region *
rrandneighbour(region *r)
{
direction_t i;
region *rc = NULL;
int rr, c = 0;
/* Nachsehen, wieviele Regionen in Frage kommen */
for (i = 0; i != MAXDIRECTIONS; i++) {
c++;
}
/* Zufällig eine auswählen */
rr = rand() % c;
/* Durchzählen */
c = -1;
for (i = 0; i != MAXDIRECTIONS; i++) {
rc = rconnect(r, i);
c++;
if (c == rr) break;
}
assert(i!=MAXDIRECTIONS);
return rc;
}
void
volcano_outbreak(region *r)
{
attrib *a;
region *rn;
unit *u, **up;
int dead;
faction *f;
for (u=r->units; u; u=u->next) {
f = u->faction;
freset(f, FL_DH);
}
rn = rrandneighbour(r);
/* Vulkan-Region verwüsten */
rsettrees(r, 0);
a = a_find(r->attribs, &at_reduceproduction);
if (!a) a = a_add(&r->attribs, a_new(&at_reduceproduction));
/* Produktion vierteln ... */
a->data.sa[0] = 25;
/* Für 6-17 Runden */
a->data.sa[1] = (short)(a->data.sa[1] + 6 + rand()%12);
/* Personen bekommen 4W10 Punkte Schaden. */
for (up=&r->units; *up;) {
unit * u = *up;
dead = damage_unit(u, "4d10", true, false);
if (dead) {
add_message(&u->faction->msgs, new_message(u->faction,
"volcano_dead%u:unit%r:region%i:dead", u, r, dead));
}
if (!fval(u->faction, FL_DH)) {
fset(u->faction, FL_DH);
if (rn) {
add_message(&u->faction->msgs, new_message(u->faction,
"volcanooutbreak%r:regionv%r:regionn", r, rn));
} else {
add_message(&u->faction->msgs, new_message(u->faction,
"volcanooutbreaknn%r:region", r));
}
}
if (u==*up) up=&u->next;
}
remove_empty_units_in_region(r);
/* Zufällige Nachbarregion verwüsten */
if (rn) {
rsettrees(r, 0);
a = a_add(&rn->attribs, a_new(&at_reduceproduction));
if (!a) a = a_add(&r->attribs, a_new(&at_reduceproduction));
/* Produktion vierteln ... */
a->data.sa[0] = 25;
/* Für 6-17 Runden */
a->data.sa[1] = (short)(a->data.sa[1] + 6 + rand()%12);
/* Personen bekommen 3W10 Punkte Schaden. */
for (up=&rn->units; *up;) {
unit * u = *up;
dead = damage_unit(u, "3d10", true, false);
if (dead) {
add_message(&u->faction->msgs, new_message(u->faction,
"volcano_dead%u:unit%r:region%i:dead", u, rn, dead));
}
if (!fval(u->faction, FL_DH)) {
add_message(&u->faction->msgs, new_message(u->faction,
"volcano_dead%u:unit%r:region%i:dead", u, r, dead));
fset(u->faction, FL_DH);
}
if (u==*up) up=&u->next;
}
remove_empty_units_in_region(rn);
}
}
static void
move_iceberg(region *r)
{
attrib *a;
direction_t dir;
region *rc;
a = a_find(r->attribs, &at_iceberg);
if (!a) {
dir = (direction_t)(rand()%MAXDIRECTIONS);
a = a_add(&r->attribs, make_iceberg(dir));
} else {
if (rand()%100 < 20) {
dir = (direction_t)(rand()%MAXDIRECTIONS);
a->data.i = dir;
} else {
dir = (direction_t)a->data.i;
}
}
rc = rconnect(r, dir);
if (rc && rterrain(rc) != T_GLACIER && rterrain(rc) != T_ICEBERG
&& rterrain(rc) != T_ICEBERG_SLEEP) {
if (rterrain(rc) == T_OCEAN) { /* Eisberg treibt */
ship *sh, *shn;
unit *u;
int x, y;
for (u=r->units; u; u=u->next) freset(u->faction, FL_DH);
for (u=r->units; u; u=u->next) if (!fval(u->faction, FL_DH)) {
fset(u->faction, FL_DH);
add_message(&u->faction->msgs, new_message(u->faction,
"iceberg_drift%r:region%d:dir", r, dir));
}
x = r->x;
y = r->y;
runhash(r);
runhash(rc);
r->x = rc->x;
r->y = rc->y;
rc->x = x;
rc->y = y;
rhash(rc);
rhash(r);
/* rc ist der Ozean (Ex-Eisberg), r der Eisberg (Ex-Ozean) */
/* Schiffe aus dem Zielozean werden in den Eisberg transferiert
* und nehmen Schaden. */
for (sh = r->ships; sh; sh=sh->next) freset(sh, FL_DH);
for (sh = r->ships; sh; sh = sh->next) {
/* Meldung an Kapitän */
damage_ship(sh, 0.10);
fset(sh, FL_DH);
}
/* Personen, Schiffe und Gebäude verschieben */
while (rc->buildings) {
translist(&rc->buildings, &r->buildings, rc->buildings);
}
while (rc->ships) {
fset(rc->ships, FL_DH);
damage_ship(rc->ships, 0.10);
move_ship(rc->ships, rc, r, NULL);
}
while (rc->units) {
building * b = rc->units->building;
u = rc->units;
move_unit(rc->units, r, NULL);
u->building = b; /* move_unit macht ein leave() */
}
/* Beschädigte Schiffe können sinken */
for (sh = r->ships; sh;) {
shn = sh->next;
if (fval(sh, FL_DH)) {
u = captain(sh, r);
if (sh->damage>=sh->size * DAMAGE_SCALE) {
if (u) add_message(&u->faction->msgs, new_message(u->faction,
"overrun_by_iceberg_des%h:ship", sh));
destroy_ship(sh, r);
} else {
if (u) add_message(&u->faction->msgs, new_message(u->faction,
"overrun_by_iceberg%h:ship", sh));
}
}
sh = shn;
}
} else if (rand()%100 < 20) { /* Eisberg bleibt als Gletscher liegen */
unit *u;
rsetterrain(r, T_GLACIER);
a_remove(&r->attribs, a);
for (u=r->units; u; u=u->next) freset(u->faction, FL_DH);
for (u=r->units; u; u=u->next) if (!fval(u->faction, FL_DH)) {
fset(u->faction, FL_DH);
add_message(&u->faction->msgs, new_message(u->faction,
"iceberg_land%r:region", r));
}
}
}
}
void
move_icebergs(void)
{
region *r;
for (r=regions; r; r=r->next) if (rterrain(r) == T_ICEBERG && !fval(r, RF_DH) && rand()%100 < 60) {
fset(r, RF_DH);
move_iceberg(r);
}
}
void
create_icebergs(void)
{
region *r;
for (r=regions; r; r=r->next) if (rterrain(r) == T_ICEBERG_SLEEP && rand()%100 < 5) {
boolean has_ocean_neighbour = false;
direction_t dir;
region *rc;
unit *u;
for (dir=0; dir < MAXDIRECTIONS; dir++) {
rc = rconnect(r, dir);
if (rc && rterrain(rc) == T_OCEAN) {
has_ocean_neighbour = true;
break;
}
}
if (!has_ocean_neighbour) continue;
rsetterrain(r, T_ICEBERG);
fset(r, RF_DH);
move_iceberg(r);
for (u=r->units; u; u=u->next) freset(u->faction, FL_DH);
for (u=r->units; u; u=u->next) if (!fval(u->faction, FL_DH)) {
fset(u->faction, FL_DH);
add_message(&u->faction->msgs, new_message(u->faction,
"iceberg_create%r:region", r));
}
}
}
void
randomevents(void)
{
region *r;
building *b, *b2;
unit *u, *u2;
int n;
int unfed;
/* Eiseberge */
for (r=regions; r; r=r->next) freset(r, RF_DH);
create_icebergs();
move_icebergs();
drown();
/* Orks vermehren sich */
for (r = regions; r; r = r->next) {
for (u = r->units; u; u = u->next) {
if ( (u->race == RC_ORC || is_cursed(u->attribs, C_ORC, 0))
&& get_skill(u, SK_MAGIC) == 0
&& get_skill(u, SK_ALCHEMY) == 0) {
int increase = 0;
int num, prob;
if (u->race == RC_ORC) {
num = u->number;
prob = 5;
} else {
num = min(get_cursedmen(u->attribs, C_ORC, 0), u->number);
prob = get_curseeffect(u->attribs, C_ORC, 0);
}
for (n = (num - get_item(u, I_CHASTITY_BELT)); n > 0; n--) {
if (rand() % 100 < prob) {
++increase;
}
}
if (increase) {
if (u->race == RC_ORC) {
int s;
s = get_skill(u, SK_SWORD) / (u->number * 2);
change_skill(u, SK_SWORD,
increase * max(30, s));
s = get_skill(u, SK_SPEAR) / (u->number * 2);
change_skill(u, SK_SPEAR,
increase * max(30, s));
s = get_skill(u, SK_TACTICS) / (u->number * 2);
change_skill(u, SK_TACTICS,
increase * s);
s = get_skill(u, SK_LONGBOW) / (u->number * 2);
change_skill(u, SK_LONGBOW,
increase * s);
s = get_skill(u, SK_CROSSBOW) / (u->number * 2);
change_skill(u, SK_CROSSBOW,
increase * s);
s = get_skill(u, SK_CATAPULT) / (u->number * 2);
change_skill(u, SK_CATAPULT,
increase * s);
s = get_skill(u, SK_AUSDAUER) / (u->number * 2);
change_skill(u, SK_AUSDAUER,
increase * s);
}
set_number(u, u->number + increase);
u->hp += unit_max_hp(u) * increase;
add_message(&u->faction->msgs, new_message(u->faction,
"orcgrowth%u:unit%i:amount%s:race",
u, increase, increase == 1 ? race[u->race].name[0] : race[u->race].name[1]));
}
}
}
}
/* Talente von Dämonen verschieben sich und Dämonen fressen Bauern */
for (r = regions; r; r = r->next) {
int bauernblut = 0;
boolean bfind = false;
for (u = r->units; u; u = u->next) {
if (u->race == RC_DAEMON) {
/* Alles Bauernblut der Region zählen.
* warnung: bauernblut einer partei hilft im moment der anderen
* so selten wie das benutzt wird, ist das erstmal wursht,
* aber ein TODO fürs BUGS File.
* Es ist auch deshalb fast egal, weil es ja im Grunde nicht dem Dämon,
* sondern der Region zu gute kommt - und da ist der anwender schnuppe
*/
skill_t sk;
int dc;
if (!bfind) {
unit * ud = u;
while (ud) {
attrib * a = a_find(ud->attribs, &at_bauernblut);
if (a) bauernblut += a->data.i;
do { ud=ud->next; } while (ud && ud->race!=RC_DAEMON);
}
bfind = true;
}
if (r->planep && !fval(r->planep, PFL_NOFEED)) {
unfed = (u->number - bauernblut) - rpeasants(r);
if (unfed > 0) {
#ifdef DAEMON_HUNGER
hunger(u, unfed); /* nicht gefütterte dämonen hungern */
#else
c = 0;
for (n = 0; n < unfed; n++) {
if (rand() % 100 < 10) {
c++;
}
}
if (c) {
scale_number(u, u->number - c);
sprintf(buf, "%d Dämonen von %s sind hungrig in "
"ihre Sphäre zurückgekehrt.", c, unitname(u));
addmessage(0, u->faction, buf, MSG_EVENT, ML_IMPORTANT);
}
#endif
}
}
dc = max(u->number - bauernblut, 0);
dc = min(dc, rpeasants(r));
dc = rpeasants(r) - max(u->number - bauernblut, 0);
dc = max(0, dc);
rsetpeasants(r, dc);
for (sk = 0; sk != MAXSKILLS; sk++) {
if (get_skill(u, sk) > 0 && rand() % 100 < 25) {
if (rand() % 100 < 60) {
change_skill(u, sk, u->number * (rand() % 90 + 1));
} else {
int s = get_skill(u, sk);
int r = u->number * (rand() % 90 + 1);
r = min(s, r);
change_skill(u, sk, -r);
#if 0
/* ist kaputt. weiß nicht, wieso. */
if (r==s) {
sprintf(buf, "Durch Konzentrationsmangel vergißt %s das Talent %s vollständig", unitname(u), skillnames[sk]);
addmessage(0, u->faction, buf, MSG_EVENT, ML_IMPORTANT);
}
#endif
}
}
}
}
}
}
/* Elfen generieren Wald, Personen in Steinkreisen können Einhörner
* bekommen. */
for (r = regions; r; r = r->next) {
if (r->land && !fval(r, RF_MALLORN)) {
int trees = rtrees(r);
int maxgen = (production(r) * MAXPEASANTS_PER_AREA)/8;
for (u = r->units; u && maxgen > 0; u = u->next) {
if (u->race == RC_ELF) {
for (n = u->number; n && maxgen > 0; n--) {
if (rand() % 1000 < 15) { /* 1.5% Chance */
trees++;
}
maxgen--;
}
}
}
rsettrees(r, trees);
}
for (u=r->units; u; u=u->next) {
if (!(race[u->race].ec_flags & NOGIVE)) {
struct building * b = inside_building(u);
const struct building_type * btype = b?b->type:NULL;
if (btype == &bt_blessedstonecircle) {
int n, c = 0;
for (n=0; n<u->number; n++) if (rand()%100 < 2) {
change_item(u, I_UNICORN, 1);
c++;
}
if (c) {
add_message(&u->faction->msgs, new_message(u->faction,
"scunicorn%u:unit%i:amount%s:type",u,c,
locale_string(u->faction->locale, resourcename(olditemtype[I_UNICORN]->rtype, c!=1?NMF_PLURAL:0))));
}
}
}
}
}
/* Orkifizierte Regionen mutieren und mutieren zurück */
for (r = regions; r; r = r->next) {
if (fval(r, RF_ORCIFIED)) {
direction_t dir;
int chance = 0;
for (dir = 0; dir < MAXDIRECTIONS; dir++) {
region *rc = rconnect(r, dir);
if (rc && rpeasants(rc) > 0 && !fval(rc, RF_ORCIFIED)) chance += 2;
}
if (rand()%100 < chance) {
freset(r, RF_ORCIFIED);
for (u2 = r->units; u2; u2 = u2->next ) freset(u2->faction, FL_DH);
for (u2 = r->units; u2; u2 = u2->next ) {
if (!fval(u2->faction, FL_DH)) {
add_message(&r->msgs, new_message(u2->faction,
"deorcified%r:region", r));
fset(u2->faction, FL_DH);
}
}
}
} else {
attrib *a = a_find(r->attribs, &at_orcification);
if (a!=NULL) {
int chance = 0;
if (rpeasants(r) <= 0) continue;
chance = (a->data.i*100)/rpeasants(r);
if (rand()%100 < chance) {
fset(r, RF_ORCIFIED);
a_remove(&r->attribs, a);
for (u2 = r->units; u2; u2 = u2->next) freset(u2->faction, FL_DH);
for (u2 = r->units; u2; u2 = u2->next) {
if (!fval(u2->faction, FL_DH)) {
add_message(&r->msgs, new_message(u2->faction,
"orcified%r:region", r));
fset(u2->faction, FL_DH);
}
}
} else {
a->data.i -= max(10,a->data.i/10);
if (a->data.i <= 0) a_remove(&r->attribs, a);
}
}
}
}
/* Vulkane qualmen, brechen aus ... */
for (r = regions; r; r = r->next) {
switch(rterrain(r)) {
case T_VOLCANO:
if (rand()%100 < 5) {
rsetterrain(r, T_VOLCANO_SMOKING);
/* Meldungen generieren */
for (u = r->units; u; u = u->next ) freset(u->faction, FL_DH);
for (u = r->units; u; u = u->next ) {
if (!fval(u->faction, FL_DH)) {
add_message(&r->msgs, new_message(u->faction,
"volcanostartsmoke%r:region", r));
fset(u->faction, FL_DH);
}
}
}
break;
case T_VOLCANO_SMOKING:
if (rand()%100 < 10) {
rsetterrain(r, T_VOLCANO);
/* Meldungen generieren */
for (u = r->units; u; u = u->next ) freset(u->faction, FL_DH);
for (u = r->units; u; u = u->next ) {
if (!fval(u->faction, FL_DH)) {
add_message(&r->msgs, new_message(u->faction,
"volcanostopsmoke%r:region", r));
fset(u->faction, FL_DH);
}
}
} else if (rand()%100 < 8) {
volcano_outbreak(r);
}
break;
}
}
/* Monumente zerfallen, Schiffe verfaulen */
for (r = regions; r; r = r->next) {
for (b = rbuildings(r); b; b = b2) {
b2 = b->next;
if (fval(b->type, BTF_DECAY) && !buildingowner(r, b)) {
b->size -= max(1, (b->size * 20) / 100);
if (b->size == 0) {
destroy_building(b);
}
}
}
}
/* Drachen und Seeschlangen können entstehen */
printf("\n");
for (r = regions; r; r = r->next) {
unit * u;
if (rterrain(r) == T_OCEAN && rand()%10000 < 1) {
u = createunit(r, findfaction(MONSTER_FACTION), 1, RC_SEASERPENT);
set_skill(u, SK_MAGIC, u->number * 300);
set_skill(u, SK_OBSERVATION, u->number * 180);
set_skill(u, SK_STEALTH, u->number * 90);
set_skill(u, SK_AUSDAUER, u->number * 30);
set_string(&u->name, "Seeschlange");
}
if ((rterrain(r) == T_GLACIER
|| rterrain(r) == T_SWAMP || rterrain(r) == T_DESERT)
&& rand() % 10000 < (5 + 100 * chaosfactor(r))) {
switch (rand() % 10) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
u = createunit(r, findfaction(MONSTER_FACTION), nrand(60, 20) + 1, RC_FIREDRAGON);
break;
default:
u = createunit(r, findfaction(MONSTER_FACTION), nrand(30, 20) + 1, RC_DRAGON);
break;
}
set_money(u, u->number * (rand() % 500 + 100));
set_skill(u, SK_MAGIC, u->number * 300);
set_skill(u, SK_OBSERVATION, u->number * (rand() % 180));
set_skill(u, SK_AUSDAUER, u->number * 30);
set_skill(u, SK_STEALTH, u->number * 30);
fprintf(stderr, "%d %s in %s.\n", u->number,
race[u->race].name[1], tregionid(r, NULL));
name_unit(u);
set_string(&u->lastorder, "WARTEN");
if (u->number == 1) {
sprintf(buf, "Es wurde ein %s gesichtet.",
race[u->race].name[0]);
} else {
sprintf(buf, "Es wurden %d %s gesichtet.",
u->number, race[u->race].name[1]);
}
addmessage(r, 0, buf, MSG_COMMENT, ML_IMPORTANT);
if (u->number == 1) {
sprintf(buf, "In %s wurde ein %s gesichtet.", regionid(r),
race[u->race].name[0]);
} else {
sprintf(buf, "In %s wurden %d %s gesichtet.", regionid(r),
u->number, race[u->race].name[1]);
}
for (u=r->units;u;u=u->next) freset(u->faction, FL_DH);
for (u=r->units;u;u=u->next) {
faction * f = u->faction;
if (!fval(f, FL_DH)) {
addmessage(0, f, buf, MSG_EVENT, ML_IMPORTANT);
fset(f, FL_DH);
}
}
}
}
/* Untote können entstehen */
for (r = regions; r; r = r->next) {
int unburied = deathcount(r);
if(is_cursed(r->attribs, C_HOLYGROUND, 0)) continue;
/* Chance 0.1% * chaosfactor */
if (r->land && unburied > r->land->peasants / 20 && rand() % 10000 < (100 + 100 * chaosfactor(r))) {
/* es ist sinnfrei, wenn irgendwo im Wald 3er-Einheiten Untote entstehen.
* Lieber sammeln lassen, bis sie mindestens 5% der Bevölkerung sind, und
* dann erst auferstehen. */
int undead = unburied / (rand() % 2 + 1);
race_t rc;
int i;
if (!undead || r->age < 20) continue;
switch(rand()%3) {
case 0:
rc = RC_SKELETON; break;
case 1:
rc = RC_ZOMBIE; break;
default:
rc = RC_GHOUL; break;
}
u = createunit(r, findfaction(MONSTER_FACTION), undead, rc);
if ((rc == RC_SKELETON || rc == RC_ZOMBIE) && rand()%10 < 4) {
set_item(u, I_RUSTY_SWORD, undead);
if (rand()%10 < 3) {
set_item(u, I_RUSTY_SHIELD, undead);
}
if (rand()%10 < 2) {
set_item(u, I_RUSTY_CHAIN_MAIL, undead);
}
}
for (i=0;i < MAXSKILLS;i++) {
if (race[rc].bonus[i] >= 1) {
set_skill(u, i, 30 * u->number);
}
}
u->hp = unit_max_hp(u) * u->number;
deathcounts(r, -undead);
set_string(&u->lastorder, "WARTEN");
name_unit(u);
fprintf(stderr, "%d %s in %s.\n", u->number,
race[u->race].name[1], tregionid(r, NULL));
add_message(&r->msgs, new_message(NULL,
"undeadrise%r:region", r));
for (u=r->units;u;u=u->next) freset(u->faction, FL_DH);
for (u=r->units;u;u=u->next) {
if (fval(u->faction, FL_DH)) continue;
fset(u->faction, FL_DH);
add_message(&u->faction->msgs, new_message(NULL,
"undeadrise%r:region", r));
}
} else {
int i = deathcount(r);
if (i) {
/* Gräber verwittern, 3% der Untoten finden die ewige Ruhe */
deathcounts(r, (int)(1+i*0.03));
}
}
}
for (r = regions; r; r=r->next) {
for (u=r->units; u; u=u->next) {
if (u->faction->no != MONSTER_FACTION && (race[u->race].flags & RCF_DESERT)) {
if (rand()%100 < 5) {
add_message(&u->faction->msgs, new_message(u->faction,
"desertion%u:unit%r:region", u, r));
u_setfaction(u, findfaction(MONSTER_FACTION));
}
}
}
}
/* Frühling, die Bäume schlagen aus. */
for (r = regions; r; r = r->next) {
if (fval(r, RF_CHAOTIC) ||(r->x >= -13 && r->x <= -6 && r->y >= 50 && r->y <= 57)) {
if (woodcount(r) >= 40 && rand()%100 < 33) {
int trees = rtrees(r);
int treemen = rand()%(max(50,trees)/3);
treemen = max(25, treemen);
woodcounts(r, -40);
trees = max(0, trees-treemen);
rsettrees(r, trees);
u = createunit(r, findfaction(MONSTER_FACTION),treemen, RC_TREEMAN);
set_string(&u->lastorder, "WARTEN");
/* guard(u, GUARD_ALL); kein auto-guard! erst in monster.c! */
change_skill(u,SK_OBSERVATION,180*u->number);
if (u->number == 1)
set_string(&u->name, "Ein wütender Ent");
else
set_string(&u->name, "Wütende Ents");
fprintf(stderr, "%d Ents in %s.\n", u->number, tregionid(r, NULL));
add_message(&r->msgs, new_message(NULL,
"entrise%r:region", r));
for (u=r->units;u;u=u->next) freset(u->faction, FL_DH);
for (u=r->units;u;u=u->next) {
if (fval(u->faction, FL_DH)) continue;
fset(u->faction, FL_DH);
add_message(&u->faction->msgs, new_message(NULL,
"entrise%r:region", r));
}
}
}
}
/* Chaos */
for (r = regions; r; r = r->next) {
int i;
if (fval(r, RF_CHAOTIC)) {
chaos(r);
}
i = chaoscount(r);
if (!i) continue;
chaoscounts(r, -(int) (i * ((double) (rand() % 10)) / 100.0));
}
#ifdef HERBS_ROT
/* Kräuter verrotten */
for (r = regions; r; r = r->next) {
for (u = r->units; u; u=u->next) {
item **itmp = &u->items, *hbag = *i_find(&u->items, olditemtype[I_SACK_OF_CONSERVATION]);
int rot_chance = HERBROTCHANCE;
if (hbag) rot_chance = (HERBROTCHANCE*2)/5;
while (*itmp) {
item * itm = *itmp;
const herb_type * htype = resource2herb(itm->type->rtype);
int n = itm->number;
double k = n*rot_chance/100.0;
if (htype!=NULL) {
n = (int)(min(n, normalvariate(k, k/4)));
i_change(itmp, itm->type, -n);
}
if (itm==*itmp) itmp=&itm->next;
}
}
}
#endif
dissolve_units();
check_split();
}
void growlaen(void) {
region *r;
regionlist *Berge=NULL, *rl;
unit *u;
int b=0, Laen, z, add;
short *add_laen;
for (r = regions; r; r = r->next) {
if (!fval(r, RF_CHAOTIC) &&
rterrain(r) == T_MOUNTAIN)
{
Berge=add_regionlist(Berge,r);
b++;
}
}
add_laen=(short *)malloc(b*sizeof(short));
memset(add_laen, 0, b*sizeof(short));
Laen=b*MAXLAENPERTURN/14; /* Anzahl Berge * MAXLAENPERTURN/2 * Chance pro Berg */
while(Laen) { /* Laenverteilung über alle Berge */
z = rand()%b;
add = min(10 + rand() % 30, Laen);
add_laen[z] = (short)(add_laen[z]+add);
Laen -= add;
}
z=0;
for (rl=Berge; rl; rl=rl->next, z++) {
region * r = rl->region;
if (add_laen[z]>0) {
if (a_find(rl->region->attribs, &at_laen))
rsetlaen(rl->region, add_laen[z]+rlaen(rl->region));
}
else {
attrib *a=a_new(&at_laen);
a_add(&rl->region->attribs, a);
rsetlaen(rl->region, add_laen[z]);
/* Meldungen generieren */
for (u=r->units;u;u=u->next) freset(u->faction, FL_DH);
for (u = r->units; u; u = u->next ) {
if (!fval(u->faction, FL_DH) && eff_skill(u, SK_MINING, rl->region) >= olditemtype[I_EOG]->minskill)
{
add_message(&rl->region->msgs, new_message(u->faction,
"unveileog%u:unit%r:region", u, rl->region));
fset(u->faction, FL_DH);
}
}
}
}
free(add_laen);
free_regionlist(Berge);
}