server/src/common/gamecode/monster.c

/* vi: set ts=2:
 *
 *
 *	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<EFBFBD>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 "monster.h"

#include "economy.h"

/* kernel includes */
#include <item.h>
#include <reports.h>
#include <message.h>
#include <region.h>
#include <faction.h>
#include <movement.h>
#include <race.h>
#include <magic.h>
#include <skill.h>
#include <build.h>
#include <pool.h>
#include <names.h>
#include <unit.h>
#include <pathfinder.h>

/* util includes */
#include <attrib.h>
#include <base36.h>
#include <event.h>
#include <rand.h>

/* libc includes */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

/* triggers includes */
#include <triggers/removecurse.h>

/* attributes includes */
#include <attributes/targetregion.h>
#include <attributes/hate.h>

/* spezialmonster */
#include <spells/alp.h>

#ifdef HAVE_ZLIB
#include <zlib.h>
static gzFile dragonlog;
#else
static FILE * dragonlog;
#endif

#define UNDEAD_REPRODUCTION         0 	/* vermehrung */
#define MOVECHANCE                  25	/* chance fuer bewegung */

/* ------------------------------------------------------------- */

#define MAXILLUSION_TEXTS   3

/* ------------------------------------------------------------- */

static boolean
is_waiting(const unit * u)
{
	if (fval(u, FL_ISNEW)) return true;
	if (strncasecmp(u->lastorder, "WARTEN", 6) == 0) return true;

	return false;
}

static boolean
monster_attack(unit * u, const unit * target)
{
	char zText[20];
	strlist *S;

	if (u->region!=target->region) return false;
	if (!cansee(u->faction, u->region, target, 0)) return false;
	if (is_waiting(u)) return false;

	sprintf(zText, "%s %s",
		locale_string(u->faction->locale, keywords[K_ATTACK]), unitid(target));
	S = makestrlist(zText);
	addlist(&u->orders, S);
	return true;
}

void
taxed_by_monster(unit * u)
{
	strlist *S;

	S = makestrlist(locale_string(u->faction->locale, keywords[K_TAX]));
	addlist(&u->orders, S);
}

static boolean
get_money_for_dragon(region * r, unit * u, int wanted)
{
	unit *u2;
	int n;

	/* attackiere bewachende einheiten */

	for (u2 = r->units; u2; u2 = u2->next)
		if (u2 != u && getguard(u2)&GUARD_TAX)
			monster_attack(u, u2);

	/* treibe steuern bei den bauern ein */

	taxed_by_monster(u);

	/* falls das genug geld ist, bleibt das monster hier */

	if (rmoney(r) >= wanted)
		return true;

	/* attackiere so lange die fremden, alteingesessenen einheiten mit geld
	 * (einfach die reihenfolge der einheiten), bis das geld da ist. n
	 * zaehlt das so erhaltene geld. */

	n = 0;
	for (u2 = r->units; u2; u2 = u2->next)
		if (u2->faction != u->faction && get_money(u2)) {
			if (monster_attack(u, u2)) {
				n += get_money(u2);

				if (n > wanted)
					break;
			}
		}
	/* falls die einnahmen erreicht werden, bleibt das monster noch eine
	 * runde hier. */

	if (n + rmoney(r) >= wanted)
		return true;

	/* falls das geld, das wir haben, und das der angriffe zum leben
	 * reicht, koennen wir uns fortbewegen. deswegen duerfen wir
	 * steuereinnahmen nicht beruecksichtigen - wir bewegen uns ja fort. */

	if (get_money(u) + n >= MAINTENANCE)
		return false;

	/* falls wir auch mit angriffe nicht genug geld zum wandern haben,
	 * muessen wir wohl oder uebel hier bleiben. vielleicht wurden ja genug
	 * steuern eingetrieben */

	return true;
}

int
money(region * r)
{
	unit *u;
	int m;

	m = rmoney(r);
	for (u = r->units; u; u = u->next)
		m += get_money(u);
	return m;
}

direction_t
richest_neighbour(region * r, int absolut)
{

	/* m - maximum an Geld, d - Richtung, i - index, t = Geld hier */

	double m;
	double t;
	direction_t d = NODIRECTION, i;

	if (absolut == 1 || rpeasants(r) == 0) {
		m = (double) money(r);
	} else {
		m = (double) money(r) / (double) rpeasants(r);
	}

	/* finde die region mit dem meisten geld */

	for (i = 0; i != MAXDIRECTIONS; i++)
		if (rconnect(r, i) && rterrain(rconnect(r, i)) != T_OCEAN) {
			if (absolut == 1 || rpeasants(r) == 0) {
				t = (double) money(rconnect(r, i));
			} else {
				t = (double) money(rconnect(r, i)) / (double) rpeasants(r);
			}

			if (t > m) {
				m = t;
				d = i;
			}
		}
	return d;
}

boolean
room_for_race_in_region(region *r, const race * rc)
{
	unit *u;
	int  c = 0;

	for(u=r->units;u;u=u->next) {
		if(u->race == rc) c += u->number;
	}

	if(c > (rc->splitsize*2))
		return false;

	return true;
}

direction_t
random_neighbour(region * r, unit *u)
{
	direction_t i;
	region *rc;
	int rr, c = 0, c2 = 0;

	/* Nachsehen, wieviele Regionen in Frage kommen */

	for (i = 0; i != MAXDIRECTIONS; i++) {
		rc = rconnect(r, i);
		if (rc && can_survive(u, rc)) {
			if(room_for_race_in_region(rc, u->race)) {
				c++;
			}
			c2++;
		}
	}

	if (c == 0) {
		if(c2 == 0) {
			return NODIRECTION;
		} else {
			c  = c2;
			c2 = 0;		/* c2 == 0 -> room_for_race nicht beachten */
		}
	}

	/* Zuf<75>llig eine ausw<73>hlen */

	rr = rand() % c;

	/* Durchz<68>hlen */

	c = -1;
	for (i = 0; i != MAXDIRECTIONS; i++) {
		rc = rconnect(r, i);
		if (rc && can_survive(u, rc)) {
			if(c2 == 0) {
				c++;
			} else if(room_for_race_in_region(rc, u->race)) {
				c++;
			}
			if (c == rr) return i;
		}
	}

	assert(1 == 0);				/* Bis hierhin sollte er niemals kommen. */
	return NODIRECTION;
}

direction_t
treeman_neighbour(region * r)
{
	direction_t i;
	int rr;
	int c = 0;

	/* Nachsehen, wieviele Regionen in Frage kommen */

	for (i = 0; i != MAXDIRECTIONS; i++) {
		if (rconnect(r, i)
			&& rterrain(rconnect(r, i)) != T_OCEAN
			&& rterrain(rconnect(r, i)) != T_GLACIER
			&& rterrain(rconnect(r, i)) != T_DESERT) {
			c++;
		}
	}

	if (c == 0) {
		return NODIRECTION;
	}
	/* Zuf<75>llig eine ausw<73>hlen */

	rr = rand() % c;

	/* Durchz<68>hlen */

	c = -1;
	for (i = 0; i != MAXDIRECTIONS; i++) {
		if (rconnect(r, i)
			&& rterrain(rconnect(r, i)) != T_OCEAN
			&& rterrain(rconnect(r, i)) != T_GLACIER
			&& rterrain(rconnect(r, i)) != T_DESERT) {
			c++;
			if (c == rr) {
				return i;
			}
		}
	}

	assert(1 == 0);				/* Bis hierhin sollte er niemals kommen. */
	return NODIRECTION;
}

void
move_monster(region * r, unit * u)
{
	direction_t d = NODIRECTION;
	strlist *S;

	switch(old_race(u->race)) {
	case RC_FIREDRAGON:
	case RC_DRAGON:
	case RC_WYRM:
		d = richest_neighbour(r, 1);
		break;
	case RC_TREEMAN:
		d = treeman_neighbour(r);
		break;
	default:
		d = random_neighbour(r,u);
		break;
	}

	/* falls kein geld gefunden wird, zufaellig verreisen, aber nicht in
	 * den ozean */

	if (d == NODIRECTION)
		return;

	sprintf(buf, "%s %s", locale_string(u->faction->locale, keywords[K_MOVE]), locale_string(u->faction->locale, directions[d]));

	S = makestrlist(buf);
	S->next = u->orders;
        u->orders = S;
}

/* Wir machen das mal autoconf-style: */
#ifndef HAVE_DRAND48
#define drand48() (((double)rand()) / RAND_MAX)
#endif

int
dragon_affinity_value(region *r, unit *u)
{
	int m = count_all_money(r);

	if(u->race == new_race[RC_FIREDRAGON]) {
		return (int)(normalvariate(m,m/2));
	} else {
		return (int)(normalvariate(m,m/4));
	}
}

attrib *
set_new_dragon_target(unit * u, region * r, int range)
{
	region *r2;
	int x, y;
	int affinity, max_affinity = 0;
	region *max_region = NULL;

	for (x = r->x - range; x < r->x + range; x++) {
		for (y = r->y - range; y < r->y + range; y++) {
			if (koor_distance (r->x, r->y, x, y) <= range
					&& (r2 = findregion(x, y)) != 0
					&&
					path_exists(r, r2, range, allowed_dragon)
				) {
				affinity = dragon_affinity_value(r2, u);
				if(affinity > max_affinity) {
					max_affinity = affinity;
					max_region = r2;
				}
			}
		}
	}

	if (max_region && max_region != r) {
		attrib * a = a_find(u->attribs, &at_targetregion);
		if (!a) {
			a = a_add(&u->attribs, make_targetregion(max_region));
		} else {
			a->data.v = max_region;
		}
		sprintf(buf, "Kommt aus: %s, Will nach: %s", regionid(r), regionid(max_region));
		usetprivate(u, buf);
		if (dragonlog) {
#ifdef HAVE_ZLIB
			gzprintf(dragonlog, "%s entscheidet sich, von %s nach %s zu wandern.\n", unitname(u), f_regionid(r, u->faction), f_regionid(max_region, u->faction));
#elif HAVE_BZ2LIB
			/* TODO */
#else
			fprintf(dragonlog, "%s entscheidet sich, von %s nach %s zu wandern.\n", unitname(u), f_regionid(r, u->faction), f_regionid(max_region, u->faction));
#endif
		}
		return a;
	}
	return NULL;
}

static boolean
set_movement_order(unit * u, const region * target, int moves, boolean (*allowed)(const region *, const region *))
{
	region * r = u->region;
	region ** plan = path_find(r, target, DRAGON_RANGE, allowed);
	int position = 0;
	char * c;

	if (plan==NULL) {
		if (dragonlog) {
#ifdef HAVE_ZLIB
			gzprintf(dragonlog, "%s fand keinen Weg von %s nach %s\n", unitname(u), f_regionid(r, u->faction), f_regionid(target, u->faction));
#elif HAVE_BZ2LIB
			/* TODO */
#else
			fprintf(dragonlog, "%s fand keinen Weg von %s nach %s\n", unitname(u), f_regionid(r, u->faction), f_regionid(target, u->faction));
#endif
		}
		return false;
	}

	strcpy(buf, locale_string(u->faction->locale, keywords[K_MOVE]));
	c = buf + strlen(buf);

	while (position!=moves && plan[position+1]) {
		region * prev = plan[position];
		region * next = plan[++position];
		direction_t dir = reldirection(prev, next);
		assert(dir!=NODIRECTION);
		*c++ = ' ';
		strcpy(c, locale_string(u->faction->locale, directions[dir]));
		c += strlen(c);
	}

	if (dragonlog) {
#ifdef HAVE_ZLIB
		gzprintf(dragonlog, "%s wandert von %s nach %s: %s\n", unitname(u), f_regionid(r, u->faction), f_regionid(target, u->faction), buf);
#elif HAVE_BZ2LIB
			/* TODO */
#else
		fprintf(dragonlog, "%s wandert von %s nach %s: %s\n", unitname(u), f_regionid(r, u->faction), f_regionid(target, u->faction), buf);
#endif
	}
	set_string(&u->lastorder, buf);
	return true;
}
/* ------------------------------------------------------------- */

void
monster_seeks_target(region *r, unit *u)
{
	direction_t d;
	strlist *S, **SP;
	unit *target = NULL;
	int dist, dist2;
	direction_t i;
	region *nr;

	/* Das Monster sucht ein bestimmtes Opfer. Welches, steht
	 * in einer Referenz/attribut
	 * derzeit gibt es nur den alp
	 */

	switch( old_race(u->race) ) {
		case RC_ALP:
			target = alp_target(u);
			break;
		default:
			assert(!"Seeker-Monster gibt kein Ziel an");
	}

	/* TODO: pr<70>fen, ob target <20>berhaupt noch existiert... */
	if(!target) return; /* this is a bug workaround! remove!! */

	if(r == target->region ) { /* Wir haben ihn! */
		if (u->race == new_race[RC_ALP]) {
			alp_findet_opfer(u, r);
		}
		else {
			assert(!"Seeker-Monster hat keine Aktion fuer Ziel");
		}
		return;
	}

	/* Simpler Ansatz: Nachbarregion mit gerinster Distanz suchen.
	 * Sinnvoll momentan nur bei Monstern, die sich nicht um das
	 * Terrain k<EFBFBD>mmern.  Nebelw<EFBFBD>nde & Co machen derzeit auch nix...
	 */
	dist2 = distance(r, target->region);
	d = NODIRECTION;
	for( i = 0; i < MAXDIRECTIONS; i++ ) {
		nr = rconnect(r, i);
		assert(nr);
		dist = distance(nr, target->region);
		if( dist < dist2 ) {
			dist2 = dist;
			d = i;
		}
	}
	assert(d != NODIRECTION );

	if (u->race == new_race[RC_ALP]) {
		if( (u->age % 2) )		/* bewegt sich nur jede zweite Runde */
			d = NODIRECTION;
	}

	if( d == NODIRECTION )
		return;
	sprintf(buf, "%s %s", locale_string(u->faction->locale, keywords[K_MOVE]), locale_string(u->faction->locale, directions[d]));
	SP = &u->orders;
	S = makestrlist(buf);
	addlist2(SP, S);
	*SP = 0;
}
/* ------------------------------------------------------------- */

unit *
random_unit(const region * r)
{
	int c = 0;
	int n;
	unit *u;

	for (u = r->units; u; u = u->next) {
		if (u->race != new_race[RC_SPELL]) {
			c += u->number;
		}
	}

	if (c == 0) {
		return NULL;
	}
	n = rand() % c;
	c = 0;
	u = r->units;

	while (u && c < n) {
		if (u->race != new_race[RC_SPELL]) {
			c += u->number;
		}
		u = u->next;
	}

	return u;
}

static boolean
random_attack_by_monster(const region * r, unit * u)
{
	boolean success = false;
	unit *target;
	int kill, max;
	int tries = 0;
	int attacked = 0;

	switch (old_race(u->race)) {
	case RC_FIREDRAGON:
		kill = 25;
		max = 50;
		break;
	case RC_DRAGON:
		kill = 100;
		max = 200;
		break;
	case RC_WYRM:
		kill = 400;
		max = 800;
		break;
	default:
		kill = 1;
		max = 1;
	}

	kill *= u->number;
	max *= u->number;

	do {
		tries++;
		target = random_unit(r);
		if (target
		    && target != u
		    && humanoidrace(target->race)
			 && !illusionaryrace(target->race)
		    && target->number <= max)
		{
			if (monster_attack(u, target)) {
				unit * u2;
				success = true;
				for (u2 = r->units; u2; u2 = u2->next) {
					if (u2->faction->no == MONSTER_FACTION
						&& rand() % 100 < 75)
					{
						monster_attack(u2, target);
					}
				}
				attacked += target->number;
			}
		}
	}
	while (attacked < kill && tries < 10);
	return success;
}

void
eaten_by_monster(unit * u)
{
	int n = 0;
	int horse = 0;

	switch (old_race(u->race)) {
	case RC_FIREDRAGON:
		n = rand()%80 * u->number;
		horse = get_item(u, I_HORSE);
		break;
	case RC_DRAGON:
		n = rand()%200 * u->number;
		horse = get_item(u, I_HORSE);
		break;
	case RC_WYRM:
		n = rand()%500 * u->number;
		horse = get_item(u, I_HORSE);
		break;
	default:
		n = rand()%(u->number/20+1);
	}

	if (n > 0) {
		n = lovar(n);
		n = min(rpeasants(u->region), n);

		if(n > 0) {
			deathcounts(u->region, n);
			rsetpeasants(u->region, rpeasants(u->region) - n);
			add_message(&u->region->msgs, new_message(NULL,
				"eatpeasants%u:unit%i:amount", u, n));
		}
	}
	if (horse > 0) {
		set_item(u, I_HORSE, 0);
		add_message(&u->region->msgs, new_message(NULL,
					"eathorse%u:unit%i:amount", u, horse));
	}
}

void
absorbed_by_monster(unit * u)
{
	int n;

	switch (old_race(u->race)) {
	default:
		n = rand()%(u->number/20+1);
	}

	if(n > 0) {
		n = lovar(n);
		n = min(rpeasants(u->region), n);
		if(n > 0){
			rsetpeasants(u->region, rpeasants(u->region) - n);
			scale_number(u, u->number + n);
			add_message(&u->region->msgs, new_message(NULL,
				"absorbpeasants%u:unit%i:amount", u, n));
		}
	}
}

int
scareaway(region * r, int anzahl)
{
	int n, p, d = 0, emigrants[MAXDIRECTIONS];
	direction_t i;

	anzahl = min(max(1, anzahl),rpeasants(r));

	/* Wandern am Ende der Woche (normal) oder wegen Monster. Die
	 * Wanderung wird erst am Ende von demographics () ausgefuehrt.
	 * emigrants[] ist local, weil r->newpeasants durch die Monster
	 * vielleicht schon hochgezaehlt worden ist. */

	for (i = 0; i != MAXDIRECTIONS; i++)
		emigrants[i] = 0;

	p = rpeasants(r);
	assert(p >= 0 && anzahl >= 0);
	for (n = min(p, anzahl); n; n--) {
		direction_t dir = (direction_t)(rand() % MAXDIRECTIONS);
		region * c = rconnect(r, dir);

		if (c && landregion(rterrain(c))) {
			d++;
			c->land->newpeasants++;
			emigrants[dir]++;
		}
	}
	rsetpeasants(r, p-d);
	assert(p >= d);
	return d;
}

void
scared_by_monster(unit * u)
{
	int n;

	switch (old_race(u->race)) {
	case RC_FIREDRAGON:
		n = rand()%160 * u->number;
		break;
	case RC_DRAGON:
		n = rand()%400 * u->number;
		break;
	case RC_WYRM:
		n = rand()%1000 * u->number;
		break;
	default:
		n = rand()%(u->number/4+1);
	}

	if(n > 0) {
		n = lovar(n);
		n = min(rpeasants(u->region), n);
		if(n > 0) {
			n = scareaway(u->region, n);
			if(n > 0) {
				add_message(&u->region->msgs,
							new_message(NULL,
										"fleescared%i:amount%u:unit", n, u));
			}
		}
	}
}

const char *
random_growl(void)
{
	switch(rand()%5) {
	case 0:
		return "Groammm";
	case 1:
		return "Roaaarrrr";
	case 2:
		return "Chhhhhhhhhh";
	case 3:
		return "Tschrrrkk";
	case 4:
		return "Schhhh";
	}
	return "";
}

extern attrib_type at_direction;

void
make_ponnuki(void)
{
	int ponn = atoi36("ponn");
	unit * u = ufindhash(ponn);
	region * r = findregion(-67,-5);
	if (u || !r) return;
	u = createunit(r, findfaction(MONSTER_FACTION), 1, new_race[RC_ILLUSION]);
	u->irace = new_race[RC_GOBLIN];
	set_string(&u->name, "Ponnuki");
	set_string(&u->display, "Go, Ponnuki, Go.");
    uunhash(u);
	u->no = ponn;
	uhash(u);

	/* 'andere' ponnukis mit eigener nummer */
	ponn = atoi36("255x");
	do {
		u = ufindhash(ponn);
		if (!u) break;
		uunhash(u);
		u->no = newunitid();
		uhash(u);
	} while (u);
}

void ponnuki(unit * u)
{
	const char* joke[] = {
		"Ein Bummerang ist, wenn man ihn wegwirft und er kommt nicht wieder, dann war's keiner.",

		"Ein Riese und ein Zwerg sitzen an der Bar und trinken Bier. Der Zwerg spuckt - tftftf - dem Riesen ins Bier.\n"
		"Riese: H<>r auf, oder ich rei<65> Dir ein Ohr ab!\n"
		"Zwerg: Mir egal, bei uns Zwergen wachsen die Ohren nach! - tftftf\n"
		"Riese: Wenn Du nicht sofort aufh<66>rst, rei<65>e ich Dir ein Bein aus!\n"
		"Zwerg: Na und, bei uns Zwergen wachsen Beine nach - tftftf\n"
		"Riese: Jetzt reichts aber wirklich! Schlu<6C>, oder ich rei<65>e Dir den\n"
		"Schniedel aus.\n"
		"Zwerg: Probier's doch, wir Zwerge haben gar keinen Schniedel - tftftf\n"
		"Riese (verbl<62>fft): So, und wie pinkelt Ihr dann???\n"
		"Zwerg: tftftf",

		"Ein Ingenieur und ein Mathematiker sitzen zusammen in einem Vortrag <20>ber Kulza-Klein Theorie, die sich mit\n"
		"11, 12 und sogar h<>heren Dimensionen besch<63>ftig. Der Mathematiker geniesst die Vorlesung, w<>hrend der\n"
		"Ingenieur immer mehr verwirrt aussieht. Als der Vortrag zu ende ist, hat der Ingenieur schreckliche\n"
		"Kopfschmerzen davon.\n"
		"\n"
		"Ingenieur: Wie kannst du nur diesen schrecklichen, abgehobenen Vortrag verstehen?\n"
		"Mathematiker: Ich stelle mir das ganze einfach vor.\n"
		"Ingenieur: Wie kannst du dir einen 11-dimensionalen Raum vorstellen???\n"
		"Mathematiker: Nun, ich stelle mir einen n-dimensionalen Raum vor und lasse dann n gegen 11 gehen..",

		"Merke: Mit Schwabenwitzen soll man ganz sparsam sein.",

		"F: Was bekommt man, wenn man Katzen und Elfen kreuzt?\nA: Elfen ohne Rheuma.",

		"F: Was bekommt man, wenn man Insekten und Katzen kreuzt?\nA: Tiger, die Crisan benutzen.",

		NULL };
	int jokes = 0;

	/*
	attrib * a = a_find(u->attribs, &at_direction);

	if (!a) {
		a_add(&u->attribs, a = a_new(&at_direction));
		a->data.i = D_NORTHWEST;
	}
	if (rand() % 10 == 0) a->data.i = rand() % MAXDIRECTIONS;

	travel(u->region, u, u->region->connect[a->data.i], false);
	*/

	/* Rausgenommen, <20>bergibt irgendwann NULL, das f<>hrt zu einem
	 * SegFault. */

	while(joke[jokes]) jokes++;
	if (jokes) addmessage(u->region, 0, joke[rand() % jokes], MSG_MESSAGE, ML_IMPORTANT);

}

extern void make_ponnuki(void);

void
learn_monster(unit *u)
{
	int c = 0;
	int n;
	skill_t sk;

	/* Monster lernt ein zuf<75>lliges Talent aus allen, in denen es schon
	 * Lerntage hat. */

	for(sk=0;sk<MAXSKILLS;sk++)
		if (get_skill(u, sk)) c++;

	if(c == 0) return;

	n = rand()%c + 1;
	c = 0;

	for (sk=0;sk<MAXSKILLS;sk++) {
		if (get_skill(u, sk)) {
			c++;
			if(c == n) {
				sprintf(buf, "%s %s", locale_string(u->faction->locale, keywords[K_STUDY]),
					skillname(sk, u->faction->locale));
				set_string(&u->thisorder, buf);
				break;
			}
		}
	}
}

void
monsters_kill_peasants(void)
{
	region *r;
	unit *u;

	for (r = regions; r; r = r->next) {
		for (u = r->units; u; u = u->next) if(!fval(u, FL_MOVED)) {
			if(u->race->flags & RCF_SCAREPEASANTS) {
				scared_by_monster(u);
			}
			if(u->race->flags & RCF_KILLPEASANTS) {
				eaten_by_monster(u);
			}
			if(u->race->flags & RCF_ABSORBPEASANTS) {
				absorbed_by_monster(u);
			}
		}
	}
}

void
plan_monsters(void)
{
	region *r;
	faction *f;
	unit *u;
	int ra;
	attrib *ta;
	strlist *S;

	if (!dragonlog) {
		char zText[MAX_PATH];
#ifdef HAVE_ZLIB
		sprintf(zText, "%s/dragonlog.gz", basepath());
		dragonlog = gzopen(zText, "w");
#elif HAVE_BZ2LIB
		sprintf(zText, "%s/dragonlog.bz2", basepath());
		dragonlog = BZ2_bzopen(zText,"w");
#else
		sprintf(zText, "%s/dragonlog", basepath());
		dragonlog = fopen(zText, "w");
#endif
	}
	u = findunitg(atoi36("ponn"), NULL);
	if (!u) make_ponnuki();
	f = findfaction(MONSTER_FACTION);
	if (!f)
		return;

	f->lastorders = turn;

	for (r = regions; r; r = r->next) {
		for (u = r->units; u; u = u->next) {
			region * tr = NULL;
			boolean is_moving = false;

			/* Ab hier nur noch Befehle f<>r NPC-Einheiten. */

			if (u->faction->no != MONSTER_FACTION) continue;

			/* Monster bekommen jede Runde ein paar Tage Wahrnehmung dazu */
			produceexp(u, SK_OBSERVATION, u->number);

			ta = a_find(u->attribs, &at_hate);
			if (ta && strncmp(u->lastorder, "WARTEN", 6) != 0) {
				unit * tu = (unit *)ta->data.v;
				if (tu && tu->region==r) {
					sprintf(buf, "%s %s", locale_string(u->faction->locale, keywords[K_ATTACK]), itoa36(tu->no));
					S = makestrlist(buf);
					addlist(&u->orders, S);
				} else if (tu) {
					tu = findunitg(ta->data.i, NULL);
					if (tu) set_movement_order(u, tu->region, 2, allowed_walk);
				}
				else a_remove(&u->attribs, ta);
			}
#ifdef CONVERT_TRIGGER
			ta = set_new_dragon_target(u, r, DRAGON_RANGE);
#else
			ta = a_find(u->attribs, &at_targetregion);
#endif
			if (ta!=NULL) {
				tr = (region *) ta->data.v;
				if (tr != r) is_moving = true;
			}

			if (!(fval(u, FL_ISNEW)) && r->terrain != T_OCEAN) { /* Monster bewachen immer */
				strlist *S;
				S = makestrlist(locale_string(u->faction->locale, keywords[K_GUARD]));
				addlist(&u->orders, S);
			}

			/* Diese Verkettung ist krank und sollte durch eine 'vern<72>nftige KI'
			 * ersetzt werden. */

			if( (u->race->flags & RCF_MOVERANDOM)
					&& (rand()%100<MOVECHANCE || check_overpopulated(u))) {
				move_monster(r, u);
			} else {
				boolean done = false;
				if((u->race->flags & RCF_ATTACKRANDOM)
					&& rand()%100<MONSTERATTACK
					&& is_moving == false)
				{
					done = random_attack_by_monster(r, u);
				}
				if (!done) {
					if(u->race == new_race[RC_SEASERPENT]) {
						set_string(&u->thisorder, locale_string(u->faction->locale, keywords[K_PIRACY]));
						set_string(&u->lastorder, locale_string(u->faction->locale, keywords[K_PIRACY]));
					} else if(u->race->flags & RCF_LEARN) {
						learn_monster(u);
					}
				}
			}

			/* Ab hier noch nicht generalisierte Spezialbehandlungen. */

			switch (old_race(u->race)) {
			case RC_ILLUSION:
				if (u->no==atoi36("ponn")) ponnuki(u);
				break;
			/* Alp */
			case RC_ALP:
				monster_seeks_target(r, u);
				break;
			case RC_FIREDRAGON:
			case RC_DRAGON:
			case RC_WYRM:

				{
					int horses = get_resource(u,R_HORSE);
					if (horses > 0) {
						change_resource(u, R_HORSE, - min(horses,(u->number*2)));
					}
				}
				set_item(u, I_STONE, 0);
				set_item(u, I_WOOD, 0);
				set_item(u, I_IRON, 0);
				if (rand() % 100 < 4) {
					/* dragon gets bored and looks for a different place to go */
					ta = set_new_dragon_target(u, r, DRAGON_RANGE);
				}
				else ta = a_find(u->attribs, &at_targetregion);
				if (ta!=NULL) {
					tr = (region *) ta->data.v;
					if (tr==NULL || !path_exists(r, tr, DRAGON_RANGE, allowed_dragon)) {
						ta = set_new_dragon_target(u, r, DRAGON_RANGE);
						if (ta) tr = findregion(ta->data.sa[0], ta->data.sa[1]);
					}
				}
				if (tr!=NULL) {
#ifdef NEW_PATH
					switch(old_race(u->race)) {
					case RC_FIREDRAGON:
						set_movement_order(u, tr, 4, allowed_dragon);
						break;
					case RC_DRAGON:
						set_movement_order(u, tr, 3, allowed_dragon);
						break;
					case RC_WYRM:
						set_movement_order(u, tr, 1, allowed_dragon);
						break;
					}
#else
					switch(old_race(u->race)) {
					case RC_FIREDRAGON:
						set_movement_order(u, r, ta->data.sa[0], ta->data.sa[1], 4);
						break;
					case RC_DRAGON:
						set_movement_order(u, r, ta->data.sa[0], ta->data.sa[1], 3);
						break;
					case RC_WYRM:
						set_movement_order(u, r, ta->data.sa[0], ta->data.sa[1], 1);
						break;
					}
#endif
					if (rand()%100 < 15) {
						/* do a growl */
						if (rname(tr, u->faction->locale)) {
							strlist *S;
							sprintf(buf,
								"botschaft an region %s~...~%s~etwas~in~%s.",
								estring(random_growl()), u->number==1?"Ich~rieche":"Wir~riechen",
								estring(rname(tr, u->faction->locale)));
							S = makestrlist(buf);
							addlist(&u->orders, S);
						}
					}
				} else {
					if (!get_money_for_dragon(r, u, income(u))) {
						/* money is gone */
						set_new_dragon_target(u, r, DRAGON_RANGE);
					}
					else if (u->race != new_race[RC_FIREDRAGON] && r->terrain!=T_OCEAN
							&& !(terrain[rterrain(r)].flags & FORBIDDEN_LAND)) {
						ra = 20 + rand() % 100;
						if (get_money(u) > ra * 50 + 100 && rand() % 100 < 50)
						{
							unit *un;
							un = createunit(r, findfaction(MONSTER_FACTION), ra, new_race[RC_DRACOID]);
							name_unit(un);
							change_money(u, -un->number * 50);

							set_level(un, SK_SPEAR, (3 + rand() % 4));
							set_level(un, SK_SWORD, (3 + rand() % 4));
							set_level(un, SK_LONGBOW, (2 + rand() % 3));

							switch (rand() % 3) {
							case 0:
								set_item(un, I_LONGBOW, un->number);
								un->status = ST_BEHIND;
								set_string(&un->lastorder, "LERNE BOGENSCHIESSEN");
								break;
							case 1:
								set_item(un, I_SWORD, un->number);
								un->status = ST_FIGHT;
								set_string(&un->lastorder, "LERNE SCHWERTKAMPF");
								break;
							case 2:
								set_item(un, I_SPEAR, un->number);
								un->status = ST_FIGHT;
								set_string(&un->lastorder, "LERNE SPEERKAMPF");
								break;
							}
						}
						if (is_waiting(u)) {
							set_string(&u->thisorder, "LERNE WAHRNEHMUNG");
							set_string(&u->lastorder, "LERNE WAHRNEHMUNG");
						}
					}
				}
				break;
			}
		}
	}
	if (dragonlog) {
#ifdef HAVE_ZLIB
		gzclose(dragonlog);
#elif HAVE_BZ2LIB
		BZ2_bzclose(dragonlog);
#else
		fclose(dragonlog);
#endif
		dragonlog = NULL;
	}
}

void
age_default(unit *u)
{
}

void
age_unit(region * r, unit * u)
{
	if (u->race == new_race[RC_SPELL]) {
		u->age--;
		if (u->age <= 0)
			destroy_unit(u);
	} else {
		u->age++;

		if(u->race->age) {
			u->race->age(u);
		} else {
			age_default(u);
		}
	}
}

void
split_unit(region * r, unit *u)
{
	unit *u2 = createunit(r, u->faction, 0, u->race);
	int newsize = u->number/2;

	set_string(&u2->name, u->name);
	set_string(&u2->display, u->display);
	set_string(&u2->thisorder, "WARTEN");
	set_string(&u2->lastorder, "WARTEN");

	transfermen(u, u2, newsize);
}

boolean
check_overpopulated(unit *u)
{
	unit *u2;
	int c = 0;

	for(u2 = u->region->units; u2; u2 = u2->next) {
		if(u2->race == u->race && u != u2) c += u2->number;
	}

	if(c > u->race->splitsize * 2) return true;

	return false;
}

void
check_split(void)
{
	region *r;
	unit *u;

	for(r=regions;r;r=r->next) {
		for(u=r->units;u;u=u->next) {
			if(u->faction->no == MONSTER_FACTION) {
				if(u->number > u->race->splitsize) {
						split_unit(r, u);
				}
			}
		}
	}
}

void
monsters_leave(void)
{
	region *r;
	unit *u;
	int n;

	for(r=regions;r;r=r->next) {
		for(u=r->units;u;u=u->next) {
			for(n = get_item(u, I_PEGASUS); n > 0; n--) {

			}
			for(n = get_item(u, I_UNICORN); n > 0; n--) {

			}
			for(n = get_item(u, I_DOLPHIN); n > 0; n--) {

			}
		}
	}
}