/* 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ö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 "region.h"

/* kernel includes */
#include "border.h"
#include "building.h"
#include "curse.h"
#include "faction.h"
#include "item.h"
#include "message.h"
#include "plane.h"
#include "region.h"
#include "resources.h"
#include "unit.h"

/* util includes */
#include <resolve.h>

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

extern int dice_rand(const char *s);

static int g_maxluxuries = 0;

const int delta_x[MAXDIRECTIONS] =
{
	-1, 0, 1, 1, 0, -1
};

const int delta_y[MAXDIRECTIONS] =
{
	1, 1, 0, -1, -1, 0
};

const direction_t back[MAXDIRECTIONS] =
{
	D_SOUTHEAST,
	D_SOUTHWEST,
	D_WEST,
	D_NORTHWEST,
	D_NORTHEAST,
	D_EAST,
};

const char *
regionname(const region * r, const faction * f)
{
	static char buf[65];
	plane *pl = getplane(r);

	if (f == NULL) {
		strncpy(buf, rname(r, NULL), 65);
	} else if (pl && fval(pl, PFL_NOCOORDS)) {
		strncpy(buf, rname(r, f->locale), 65);
	} else {
#ifdef HAVE_SNPRINTF
		snprintf(buf, 65, "%s (%d,%d)", rname(r, f->locale), region_x(r, f), region_y(r, f));
#else
		strncpy(buf, rname(r, f->locale), 50);
		buf[50]=0;
		sprintf(buf+strlen(buf), " (%d,%d)", region_x(r, f), region_y(r, f));
#endif
	}
	buf[64] = 0;
	return buf;
}

int
deathcount(const region * r) {
	attrib * a = a_find(r->attribs, &at_deathcount);
	if (!a) return 0;
	return a->data.i;
}

int
chaoscount(const region * r) {
	attrib * a = a_find(r->attribs, &at_chaoscount);
	if (!a) return 0;
	return a->data.i;
}

int
woodcount(const region * r) {
	attrib * a = a_find(r->attribs, &at_woodcount);
	if (!a) return 0;
	return a->data.i;
}

void
deathcounts (region * r, int fallen) {
	attrib * a;

	if (fallen==0) return;
	if (is_cursed(r->attribs, C_HOLYGROUND,0)) return;

	a = a_find(r->attribs, &at_deathcount);
	if (!a) a = a_add(&r->attribs, a_new(&at_deathcount));
	a->data.i += fallen;

	if (a->data.i<=0) a_remove(&r->attribs, a);
}

void
chaoscounts(region * r, int fallen) {
	attrib * a;

	if (fallen==0) return;

	a = a_find(r->attribs, &at_chaoscount);
	if (!a) a = a_add(&r->attribs, a_new(&at_chaoscount));
	a->data.i += fallen;

	if (a->data.i<=0) a_remove(&r->attribs, a);
}

void
woodcounts(region * r, int fallen) {
	attrib * a;

	if (fallen==0) return;

	a = a_find(r->attribs, &at_woodcount);
	if (!a) a = a_add(&r->attribs, a_new(&at_woodcount));
	a->data.i += fallen;

	if (a->data.i<=0) a_remove(&r->attribs, a);
}

/********************/
/*   at_direction   */
/********************/
void
a_initdirection(attrib *a)
{
	a->data.v = calloc(1, sizeof(spec_direction));
}

int
a_agedirection(attrib *a)
{
	spec_direction *d = (spec_direction *)(a->data.v);

	if(d->duration > 0) d->duration--;
	else d->duration = 0;

	return d->duration;
}

int
a_readdirection(attrib *a, FILE *f)
{
	spec_direction *d = (spec_direction *)(a->data.v);
	fscanf(f, "%d %d %d", &d->x, &d->y, &d->duration);
	fscanf(f, "%s ", buf);
	d->desc = strdup(cstring(buf));
	fscanf(f, "%s ", buf);
	d->keyword = strdup(cstring(buf));
	return AT_READ_OK;
}

void
a_writedirection(const attrib *a, FILE *f)
{
	spec_direction *d = (spec_direction *)(a->data.v);

	fprintf(f, "%d %d %d %s %s ", d->x, d->y, d->duration,
			estring(d->desc), estring(d->keyword));
}

attrib_type at_direction = {
	"direction",
	a_initdirection,
	NULL,
	a_agedirection,
	a_writedirection,
	a_readdirection
};


/* Moveblock wird zur Zeit nicht über Attribute, sondern ein Bitfeld
   r->moveblock gemacht. Sollte umgestellt werden, wenn kompliziertere
	 Dinge gefragt werden. */

/********************/
/*   at_moveblock   */
/********************/
void
a_initmoveblock(attrib *a)
{
	a->data.v = calloc(1, sizeof(moveblock));
}

int
a_readmoveblock(attrib *a, FILE *f)
{
	moveblock *m = (moveblock *)(a->data.v);
	int       i;

	fscanf(f, "%d", &i);
	m->dir = (direction_t)i;
	return AT_READ_OK;
}

void
a_writemoveblock(const attrib *a, FILE *f)
{
	moveblock *m = (moveblock *)(a->data.v);
	fprintf(f, "%d ", (int)m->dir);
}

attrib_type at_moveblock = {
	"moveblock", a_initmoveblock, NULL, NULL, a_writemoveblock, a_readmoveblock
};


#define RMAXHASH 65535
region *regionhash[RMAXHASH];

static region *
rfindhash(int x, int y)
{
	region *old;
	for (old = regionhash[abs(x + 0x100 * y) % RMAXHASH]; old; old = old->nexthash)
		if (old->x == x && old->y == y)
			return old;
	return 0;
}

void
rhash(region * r)
{
	region *old = regionhash[region_hashkey(r) % RMAXHASH];
	regionhash[region_hashkey(r) % RMAXHASH] = r;
	r->nexthash = old;
}

void
runhash(region * r)
{
	region **show;
	for (show = &regionhash[abs(r->x + 0x100 * r->y) % RMAXHASH]; *show; show = &(*show)->nexthash) {
		if ((*show)->x == r->x && (*show)->y == r->y)
			break;
	}
	if (*show) {
		assert(*show == r);
		*show = (*show)->nexthash;
		r->nexthash = 0;
	}
}

region *
rconnect(const region * r, direction_t dir) {
	static int set = 0;
	static region * buffer[MAXDIRECTIONS];
	static const region * last = NULL;
	assert(dir<MAXDIRECTIONS);
	if (r != last) {
		set = 0;
		last = r;
	}
	else
		if (set & (1 << dir)) return buffer[dir];
	buffer[dir] = rfindhash(r->x + delta_x[dir], r->y + delta_y[dir]);
	set |= (1<<dir);
	return buffer[dir];
}

region *
findregion(int x, int y)
{
	return rfindhash(x, y);
}

int
koor_distance(int x1, int y1, int x2, int y2)
{
	/* Contributed by Hubert Mackenberg. Thanks.
	 * x und y Abstand zwischen x1 und x2 berechnen
	 */
	int dx = x1 - x2;
	int dy = y1 - y2;

	/* Bei negativem dy am Ursprung spiegeln, das veraendert
	 * den Abstand nicht
	 */
	if ( dy < 0 )
	{
		dy = -dy;
		dx = -dx;
	}

	/*
	 * dy ist jetzt >=0, fuer dx sind 3 Faelle zu untescheiden
	 */
	if      ( dx >= 0 ) return dx + dy;
	else if (-dx >= dy) return -dx;
	else                return dy;
}

int
distance(const region * r1, const region * r2)
{
	return koor_distance(r1->x, r1->y, r2->x, r2->y);
}

direction_t
koor_reldirection(int ax, int ay, int bx, int by)
{
	direction_t i;
	for (i=0;i!=MAXDIRECTIONS;++i) {
		if (bx-ax == delta_x[i] &&
			by-ay == delta_y[i]) return i;
	}
	return NODIRECTION;
}

direction_t
reldirection(region * from, region * to)
{
	return koor_reldirection(from->x, from->y, to->x, to->y);
}

void
free_regionlist(regionlist *rl)
{
	while (rl) {
		regionlist * rl2 = rl->next;
		free(rl);
		rl = rl2;
	}
}

void
add_regionlist(regionlist **rl, region *r)
{
	regionlist *rl2 = (regionlist*)malloc(sizeof(regionlist));

	rl2->region = r;
	rl2->next   = *rl;

	*rl = rl2;
}

#if AT_SALARY
/*****************/
/*   at_salary   */
/*****************/
attrib_type at_salary = {
	"salary",
	DEFAULT_INIT,
	DEFAULT_FINALIZE,
	DEFAULT_AGE,
	NO_WRITE,
	NO_READ,
	ATF_UNIQUE
};
#endif
/********************/
/*   at_horseluck   */
/********************/
attrib_type at_horseluck = {
	"horseluck",
	DEFAULT_INIT,
	DEFAULT_FINALIZE,
	DEFAULT_AGE,
	NO_WRITE,
	NO_READ,
	ATF_UNIQUE
};


/**********************/
/*   at_peasantluck   */
/**********************/
attrib_type at_peasantluck = {
	"peasantluck",
	DEFAULT_INIT,
	DEFAULT_FINALIZE,
	DEFAULT_AGE,
	NO_WRITE,
	NO_READ,
	ATF_UNIQUE
};

/*********************/
/*   at_chaoscount   */
/*********************/
attrib_type at_chaoscount = {
	"chaoscount",
	DEFAULT_INIT,
	DEFAULT_FINALIZE,
	DEFAULT_AGE,
	DEFAULT_WRITE,
	DEFAULT_READ,
	ATF_UNIQUE
};

/*********************/
/*   at_deathcount   */
/*********************/
attrib_type at_deathcount = {
	"deathcount",
	DEFAULT_INIT,
	DEFAULT_FINALIZE,
	DEFAULT_AGE,
	DEFAULT_WRITE,
	DEFAULT_READ,
	ATF_UNIQUE
};

/*********************/
/*   at_woodcount   */
/*********************/
attrib_type at_woodcount = {
	"woodcount",
	DEFAULT_INIT,
	DEFAULT_FINALIZE,
	DEFAULT_AGE,
	DEFAULT_WRITE,
	DEFAULT_READ,
	ATF_UNIQUE
};

/*********************/
/*   at_travelunit   */
/*********************/
attrib_type at_travelunit = {
	"travelunit",
	DEFAULT_INIT,
	DEFAULT_FINALIZE,
	DEFAULT_AGE,
	NO_WRITE,
	NO_READ
};

#if NEW_RESOURCEGROWTH
extern int laen_read(attrib * a, FILE * F);
# define LAEN_READ laen_read
# define LAEN_WRITE NULL
#else
# define LAEN_READ DEFAULT_READ
# define LAEN_WRITE DEFAULT_WRITE
#endif

/***************/
/*   at_laen   */
/***************/
attrib_type at_laen = {
	"laen",
	DEFAULT_INIT,
	DEFAULT_FINALIZE,
	DEFAULT_AGE,
	LAEN_WRITE,
	LAEN_READ,
	ATF_UNIQUE
};

void
rsetlaen(region * r, int val)
{
	attrib * a = a_find(r->attribs, &at_laen);
	if (!a && val>=0) a = a_add(&r->attribs, a_new(&at_laen));
	else if (a && val<0) a_remove(&r->attribs, a);
	if (val>=0) a->data.i = val;
}

int
rlaen(const region * r)
{
	attrib * a = a_find(r->attribs, &at_laen);
	if (!a) return -1;
	return a->data.i;
}

/***************/
/*   at_road   */
/***************/
attrib_type at_road = {
	"road",
	DEFAULT_INIT,
	DEFAULT_FINALIZE,
	DEFAULT_AGE,
#if RELEASE_VERSION<NEWROAD_VERSION
	DEFAULT_WRITE,
#else
	NULL,
#endif
	DEFAULT_READ
};

void
rsetroad(region * r, direction_t d, int val)
{
	int rval;
	border * b;
	region * r2 = rconnect(r, d);

	if (!r2) return;
	b = get_borders(r, r2);
	while (b && b->type!=&bt_road) b = b->next;
	if (!b) b = new_border(&bt_road, r, r2);
	rval = (int)b->data;
	if (b->from==r)
		rval = (rval & 0xFFFF) | (val<<16);
	else
		rval = (rval & 0xFFFF0000) | val;
	b->data = (void*)rval;
}

int
rroad(const region * r, direction_t d)
{
	int rval;
	border * b;
	region * r2 = rconnect(r, d);

	if (!r2) return 0;
	b = get_borders(r, r2);
	while (b && b->type!=&bt_road) b = b->next;
	if (!b) return 0;
	rval = (int)b->data;
	if (b->to==r)
		rval = (rval & 0xFFFF);
	else
		rval = (rval & 0xFFFF0000) >> 16;
	return rval;
}

boolean
r_isforest(const region * r)
{
#if GROWING_TREES
	if (r->terrain==T_PLAIN && rtrees(r,2) + rtrees(r,1) >= 600) return true;
#else
	if (r->terrain==T_PLAIN && rtrees(r) >= 600) return true;
#endif
	return false;
}

boolean
r_issea(const region * r)
{
	direction_t d;

	for(d=0; d < MAXDIRECTIONS; d++) {
		region *rc = rconnect(r,d);
		if(rc && rterrain(rc) == T_OCEAN) return false;
	}
	return true;
}

boolean
r_isglacier(const region * r)
{
	if (r->terrain==T_GLACIER || r->terrain==T_ICEBERG_SLEEP) return true;
	return false;
}

int
is_coastregion(region *r)
{
	direction_t i;
	int res = 0;

	for(i=0;i<MAXDIRECTIONS;i++) {
		if(rconnect(r,i) && rconnect(r,i)->terrain == T_OCEAN) res++;
	}
	return res;
}

int
rpeasants(const region * r)
{
	return ((r)->land?(r)->land->peasants:0);
}

void
rsetpeasants(region * r, int value)
{
	((r)->land?((r)->land->peasants=(value)):(assert((value)>=0), (value)),0);
}

int
rmoney(const region * r)
{
	return ((r)->land?(r)->land->money:0);
}

void
rsethorses(const region *r, int value)
{
	assert(value >= 0);
	if(r->land)
		r->land->horses = value;
}

int
rhorses(const region *r)
{
	return r->land?r->land->horses:0;
}

void
rsetmoney(region * r, int value)
{
	((r)->land?((r)->land->money=(value)):(assert((value)>=0), (value)),0);
}

void
r_setdemand(region * r, const luxury_type * ltype, int value)
{
	struct demand * d, ** dp = &r->land->demands;
	while (*dp && (*dp)->type != ltype) dp = &(*dp)->next;
	d = *dp;
	if (!d) {
		d = *dp = calloc(sizeof(struct demand), 1);
		d->type = ltype;
	}
	d->value = value;
}

int
r_demand(const region * r, const luxury_type * ltype)
{
	struct demand * d = r->land->demands;
	while (d && d->type != ltype) d = d->next;
	if (!d) return -1;
	return d->value;
}

const char *
rname(const region * r, const struct locale * lang) {
	if (r->land)
		return r->land->name;
	return locale_string(lang, terrain[rterrain(r)].name);
}

#if GROWING_TREES
int
rtrees(const region *r, int ageclass)
{
	return ((r)->land?(r)->land->trees[ageclass]:0);
}

int
rsettrees(const region *r, int ageclass, int value)
{
	if (!r->land) assert(value==0);
	else {
		assert(value>=0);
		return r->land->trees[ageclass]=value;
	}
	return 0;
}
#else
int
rtrees(const region *r)
{
	return ((r)->land?(r)->land->trees:0);
}

int
rsettrees(const region *r, int value)
{
	if (!r->land) assert(value==0);
	else {
		assert(value>=0);
		return r->land->trees=value;
	}
	return 0;
}
#endif

static region *last;

region *
new_region(int x, int y)
{
	region *r = rfindhash(x, y);

	if (r) {
		fprintf(stderr, "\ndoppelte regionen entdeckt: %s(%d,%d)\n", regionname(r, NULL), x, y);
		if (r->units)
			fprintf(stderr, "doppelte region enthält einheiten\n");
		return r;
	}
	r = calloc(1, sizeof(region));
	r->x = x;
	r->y = y;
	r->planep = findplane(x, y);
	set_string(&r->display, "");
	rhash(r);
	if (last)
		addlist(&last, r);
	else
		addlist(&regions, r);
	last = r;
	return r;
}

static void
freeland(land_region * lr)
{
	while (lr->demands) {
		struct demand * d = lr->demands;
		lr->demands = d->next;
		free(d);
	}
	if (lr->name) free(lr->name);
	free(lr);
}

void
free_region(region * r)
{
	runhash(r);
	if (last == r) last = NULL;
	free(r->display);
	if (r->land) freeland(r->land);
	while (r->attribs) a_remove (&r->attribs, r->attribs);
	free(r);
}

static char *
makename(void)
{
	int s, v, k, e, p = 0, x = 0;
	int nk, ne, nv, ns;
	static char name[16];
	const char *kons = "bcdfghklmnprstvwz",
		*end = "nlrdst",
		*vokal = "aaaaaaaaaàâeeeeeeeeeéèêiiiiiiiiiíîoooooooooóòôuuuuuuuuuúyy",
		*start = "bcdgtskpvfr";

	nk = strlen(kons);
	ne = strlen(end);
	nv = strlen(vokal);
	ns = strlen(start);

	for (s = rand() % 3 + 2; s > 0; s--) {
		if (x > 0) {
			k = rand() % nk;
			name[p] = kons[k];
			p++;
		} else {
			k = rand() % ns;
			name[p] = start[k];
			p++;
		}
		v = rand() % nv;
		name[p] = vokal[v];
		p++;
		if (rand() % 3 == 2 || s == 1) {
			e = rand() % ne;
			name[p] = end[e];
			p++;
			x = 1;
		} else
			x = 0;
	}
	name[p] = '\0';
	name[0] = (char) toupper(name[0]);
	return name;
}

void 
setluxuries(region * r, const luxury_type * sale)
{
	const luxury_type * ltype;

	assert(r->land);

	if(r->land->demands) freelist(r->land->demands);

	for (ltype=luxurytypes; ltype; ltype=ltype->next) {
		struct demand * dmd = calloc(sizeof(struct demand), 1);
		dmd->type = ltype;
		if (ltype!=sale) dmd->value = 1 + rand() % 5;
		dmd->next = r->land->demands;
		r->land->demands = dmd;
	}
}

void
terraform(region * r, terrain_t t)
{
	const struct locale * locale_de = find_locale("de");
#if NEW_RESOURCEGROWTH
	rawmaterial  **lrm;
	int i;
#endif

	/* defaults: */
	rsetterrain(r, t);

#if NEW_RESOURCEGROWTH
	/* Resourcen, die nicht mehr vorkommen können, löschen */
	lrm = &r->resources;
	while (*lrm) {
		rawmaterial *rm = *lrm;
		for (i=0; i!=3; ++i) {
			if(terrain[r->terrain].rawmaterials[i].type == rm->type) break;
		}
		if (i==3) {
			*lrm = rm->next;
			free(rm);
		} else {
			lrm = &rm->next;
		}
	}
#endif

#if NEW_RESOURCEGROWTH == 0
	rsetlaen(r, -1);
	rsetiron(r, 0);
#endif
	if (!landregion(t)) {
		if (r->land) {
			freeland(r->land);
			r->land = NULL;
		}
#if GROWING_TREES
		rsettrees(r, 0, 0);
		rsettrees(r, 1, 0);
		rsettrees(r, 2, 0);
#else
		rsettrees(r, 0);
#endif
		rsethorses(r, 0);
#if NEW_RESOURCEGROWTH == 0
		rsetiron(r, 0);
		rsetlaen(r, -1);
#endif
		rsetpeasants(r, 0);
		rsetmoney(r, 0);
		freset(r, RF_ENCOUNTER);
		freset(r, RF_MALLORN);
		/* Beschreibung und Namen löschen */
		return;
	}

	if (!r->land) {
		static struct surround {
			struct surround * next;
			const luxury_type * type;
			int value;
		} *trash =NULL, *nb = NULL;
		const luxury_type * ltype;
		direction_t d;
		int mnr = 0;

		r->land = calloc(1, sizeof(land_region));
		rsetname(r, makename());
		for (d=0;d!=MAXDIRECTIONS;++d) {
			region * nr = rconnect(r, d);
			if (nr && nr->land) {
				struct demand * sale = r->land->demands;
				while (sale && sale->value!=0) sale=sale->next;
				if (sale) {
					struct surround * sr = nb;
					while (sr && sr->type!=sale->type) sr=sr->next;
					if (!sr) {
						if (trash) {
							sr = trash;
							trash = trash->next;
						} else {
							sr = calloc(1, sizeof(struct surround));
						}
						sr->next = nb;
						sr->type = sale->type;
						sr->value = 1;
						nb = sr;
					} else sr->value++;
					++mnr;
				}
			}
		}
		if (!nb) {
			int i;
			if (g_maxluxuries==0) {
				for (ltype = luxurytypes;ltype;ltype=ltype->next) ++g_maxluxuries;
			}
			i = rand() % g_maxluxuries;
			ltype = luxurytypes;
			while (i--) ltype=ltype->next; 
		} else {
			int i = rand() % mnr;
			struct surround * srd = nb;
			while (i>srd->value) {
				i-=srd->value;
				srd=srd->next;
			}
			setluxuries(r, srd->type);
			while (srd->next!=NULL) srd=srd->next;
			srd->next=trash;
			trash = nb;
			nb = NULL;
		}
	}
	
	if (landregion(t)) {
		const char *name = NULL;
		if (terrain[r->terrain].herbs) {
			int len=0;
			while (terrain[r->terrain].herbs[len]) ++len;
			if (len) name = terrain[r->terrain].herbs[rand()%len];
		}
		if (name != NULL) {
			const item_type * itype = finditemtype(name, locale_de);
			const herb_type * htype = resource2herb(itype->rtype);
			rsetherbtype(r, htype);
			rsetherbs(r, (short)(50+rand()%31));
		}
		else {
			rsetherbtype(r, NULL);
		}
	}

	if (rand() % 100 < ENCCHANCE) {
		fset(r, RF_ENCOUNTER);
	}
	if (rand() % 100 < 3)
		fset(r, RF_MALLORN);
	else
		freset(r, RF_MALLORN);

	switch (t) {
	case T_PLAIN:
		rsethorses(r, rand() % (terrain[t].production_max / 5));
		if(rand()%100 < 40) {
#if GROWING_TREES
			rsettrees(r, 2, terrain[t].production_max * (30+rand()%40)/100);
			rsettrees(r, 1, rtrees(r, 2)/4);
			rsettrees(r, 0, rtrees(r, 2)/2);
#else
			rsettrees(r, terrain[t].production_max * (30+rand()%40)/100);
#endif
		}
		break;
	case T_MOUNTAIN:
#if NEW_RESOURCEGROWTH == 0
		rsetiron(r, IRONSTART);
		if (rand() % 100 < 8) rsetlaen(r, 5 + rand() % 5);
#endif
		break;

	case T_GLACIER:
#if NEW_RESOURCEGROWTH == 0
		if (riron(r) <= 0){
			rsetiron(r, GLIRONSTART);
		}
#endif
		break;

	case T_ICEBERG_SLEEP:
		/* Kann aus Gletscher entstehen und sollte diesem gleichen */
#if NEW_RESOURCEGROWTH == 0
		if (riron(r) <= 0){
			rsetiron(r, GLIRONSTART);
		}
#endif
		break;

	case T_VOLCANO:
	case T_VOLCANO_SMOKING:
		break;
	}

#if GROWING_TREES
	/* Initialisierung irgendwann über rm_-Mechamismus machen */
	if(t != T_PLAIN && rand()%100 < 20) {
		rsettrees(r, 2, terrain[t].production_max * (30 + rand() % 40) / 100);
		rsettrees(r, 1, rtrees(r, 2)/4);
		rsettrees(r, 0, rtrees(r, 2)/2);
	}
#endif

#if NEW_RESOURCEGROWTH
	terraform_resources(r);
#endif

	if (terrain[t].production_max && !fval(r, RF_CHAOTIC)) {
		int peasants;
#if REDUCED_PEASANTGROWTH == 1
		peasants = (maxworkingpeasants(r) * (20+dice_rand("6d10")))/100;
#else
		peasants = MAXPEASANTS_PER_AREA * (rand() % (terrain[t].production_max / 2));
#endif
		rsetpeasants(r, max(100, peasants));
		rsetmoney(r, rpeasants(r) * ((wage(r, NULL, false)+1) + rand() % 5));
	}
}

/** ENNO:
 * ich denke, das das hier nicht sein sollte.
 * statt dessen sollte ein attribut an der region sein, das das erledigt,
 * egal ob durch den spell oder anderes angelegt.
 **/
#include "curse.h"
int
production(const region *r)
{
	/* muß r->terrain sein, nicht rterrain() wegen rekursion */
	int p = terrain[r->terrain].production_max;
	if (curse_active(get_curse(r->attribs, ct_find("drought")))) p /= 2;

	return p;
}

int
read_region_reference(region ** r, FILE * F)
{
	int x[2];
	fscanf(F, "%d %d", &x[0], &x[1]);
	if (x[0]==INT_MAX) {
		*r = NULL;
		return AT_READ_FAIL;
	}
	*r = findregion(x[0], x[1]);
	if (*r==NULL) ur_add(memcpy(malloc(sizeof(x)), x, sizeof(x)), (void**)r, resolve_region);
	return AT_READ_OK;
}

void
write_region_reference(const region * r, FILE * F)
{
	if (r) fprintf(F, "%d %d ", r->x, r->y);
	else fprintf(F, "%d %d ", INT_MAX, INT_MAX);
}

void *
resolve_region(void * id) {
	int * c = (int*)id;
	int x = c[0], y = c[1];
	free(c);
	return findregion(x, y);
}


struct message_list *
r_getmessages(const struct region * r, const struct faction * viewer)
{
	struct individual_message * imsg = r->individual_messages;
	while (imsg && (imsg)->viewer!=viewer) imsg = imsg->next;
	if (imsg) return imsg->msgs;
	return NULL;
}

struct message * 
r_addmessage(struct region * r, const struct faction * viewer, struct message * msg)
{
	struct individual_message * imsg;
	assert(r);
	imsg = r->individual_messages;
	while (imsg && imsg->viewer!=viewer) imsg = imsg->next;
	if (imsg==NULL) {
		imsg = malloc(sizeof(struct individual_message));
		imsg->next = r->individual_messages;
		imsg->msgs = NULL;
		r->individual_messages = imsg;
		imsg->viewer = viewer;
	}
	return add_message(&imsg->msgs, msg);
}

struct unit * 
region_owner(const struct region * r)
{
#ifdef REGIONOWNERS
  struct unit * owner = NULL;
  int maxsize = 0;
  building * b = r->buildings;
  for (;b!=NULL;b=b->next) {
    if (b->size>maxsize) {
      unit * u = buildingowner(r, b);
      if (u) {
        owner = u;
        maxsize=b->size;
      }
    }
  }
  return owner;
#else
  return NULL;
#endif
}