Marc/server
1
0
Fork 0
forked from github/server
Code Issues Pull requests Projects Releases Wiki Activity
server/src/common/kernel/save.c
Enno Rehling b0e5f436cd - lots of memory leaks fixed.
2006-01-29 01:55:36 +00:00

2109 lines
44 KiB
C
Raw Blame History

/* vi: set ts=2:
*
* Eressea PB(E)M host Copyright (C) 1998-2003
* 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 "save.h"
#include "alchemy.h"
#include "alliance.h"
#include "attrib.h"
#include "border.h"
#include "building.h"
#include "faction.h"
#include "group.h"
#include "item.h"
#include "karma.h"
#include "magic.h"
#include "message.h"
#include "movement.h"
#include "objtypes.h"
#include "order.h"
#include "pathfinder.h"
#include "plane.h"
#include "race.h"
#include "region.h"
#include "resources.h"
#include "ship.h"
#include "skill.h"
#include "spell.h"
#include "terrain.h"
#include "terrainid.h" /* only for conversion code */
#include "unit.h"
/* attributes includes */
#include <attributes/key.h>
/* util includes */
#include <attrib.h>
#include <base36.h>
#include <event.h>
#include <util/goodies.h>
#include <resolve.h>
#include <sql.h>
#include <rand.h>
#include <umlaut.h>
/* libc includes */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>
#define xisdigit(c) (((c) >= '0' && (c) <= '9') || (c) == '-')
#define COMMENT_CHAR ';'
#define ESCAPE_FIX
#define MAXORDERS 256
#define MAXPERSISTENT 128
/* exported symbols symbols */
const char * xmlfile = "eressea.xml";
const char * g_datadir;
int firstx = 0, firsty = 0;
/* local symbols */
static region * current_region;
#if RESOURCE_CONVERSION
int laen_read(attrib * a, FILE * F)
{
int laen;
fscanf(F, "%d", &laen);
read_laen(current_region, laen);
return AT_READ_FAIL;
}
#endif
char *
rns(FILE * f, char *c, size_t size)
{
char * s = c;
do {
*s = (char) getc(f);
} while (*s!='"');
for (;;) {
*s = (char) getc(f);
if (*s=='"') break;
if (s<c+size) ++s;
}
*s = 0;
return c;
}
extern unsigned int __at_hashkey(const char* s);
FILE *
cfopen(const char *filename, const char *mode)
{
FILE * F = fopen(filename, mode);
if (F == 0) {
perror(filename);
return NULL;
}
setvbuf(F, 0, _IOFBF, 32 * 1024); /* 32 kb buffer size */
return F;
}
/* ------------------------------------------------------------- */
/* Dummy-Funktion für die Kompatibilität */
#define rid(F) ri36(F)
static int nextc;
#define rc(F) (nextc = getc(F))
#undef CONVERT_DBLINK
#ifdef CONVERT_DBLINK
typedef struct uniquenode {
struct uniquenode * next;
int id;
faction * f;
} uniquenode;
#define HASHSIZE 2039
static uniquenode * uniquehash[HASHSIZE];
static faction *
uniquefaction(int id)
{
uniquenode * node = uniquehash[id%HASHSIZE];
while (node && node->id!=id) node=node->next;
return node?node->f:NULL;
}
static void
addunique(int id, faction * f)
{
uniquenode * fnode = calloc(1, sizeof(uniquenode));
fnode->f = f;
fnode->id = id;
fnode->next = uniquehash[id%HASHSIZE];
uniquehash[id%HASHSIZE] = fnode;
}
typedef struct mapnode {
struct mapnode * next;
int fno;
int subscription;
} mapnode;
static mapnode * subscriptions[HASHSIZE];
void
convertunique(faction * f)
{
int unique = f->subscription;
static FILE * F = NULL;
mapnode * mnode;
addunique(unique, f);
if (F==NULL) {
static char zText[MAX_PATH];
strcat(strcpy(zText, basepath()), "/subscriptions");
F = fopen(zText, "r");
if (F==NULL) {
log_warning(("could not open %s.\n", zText));
abort();
}
for (;;) {
char zFaction[5];
int subscription, fno;
if (fscanf(F, "%d %s", &subscription, zFaction)<=0) break;
mnode = calloc(1, sizeof(mapnode));
fno = atoi36(zFaction);
mnode->next = subscriptions[fno%HASHSIZE];
mnode->fno = fno;
mnode->subscription = subscription;
subscriptions[fno%HASHSIZE] = mnode;
}
}
mnode = subscriptions[f->no%HASHSIZE];
while (mnode!=NULL && mnode->fno!=f->no) mnode = mnode->next;
if (mnode) f->subscription = mnode->subscription;
else {
log_printf("%s %s %s %s\n",
itoa36(f->no), f->email, f->override, dbrace(f->race));
}
}
#endif
void
rds(FILE * F, char **ds)
{
static char buffer[DISPLAYSIZE + 1]; /*Platz für null-char nicht vergessen!*/
char *s = &buffer[0];
while (nextc != '"') {
if (nextc == EOF) {
*s = 0;
fprintf(stderr, "Die Datei bricht vorzeitig ab.\n");
abort();
}
rc(F);
}
rc(F);
while (nextc != '"') {
if (nextc == EOF) {
*s = 0;
fprintf(stderr, "Die Datei bricht vorzeitig ab.\n");
abort();
}
if (s - buffer < DISPLAYSIZE) {
*s++ = (char)nextc;
}
rc(F);
}
rc(F);
*s = 0;
if (ds) {
*ds = realloc(*ds, sizeof(char) * (strlen(buffer) + 1));
strcpy(*ds, buffer);
}
}
#define rcf(F) (getc(F));
void
rsf(FILE * F, char *s, size_t len)
{
char * begin = s;
int nextc;
do {
nextc = rcf(F);
if (nextc == EOF) {
puts("Die Datei bricht vorzeitig ab.");
abort();
}
} while (nextc != '"');
for (;;) {
nextc = rcf(F);
if (nextc == '"') break;
else if (nextc == EOF) {
puts("Die Datei bricht vorzeitig ab.");
abort();
}
if (s-begin<(int)len-1)
*s++ = (char)nextc;
}
*s = 0;
}
static void
rs(FILE * F, char *s)
{
boolean apos = false;
while (isspace(nextc)) rc(F);
if (nextc=='"') {
apos=true;
rc(F);
}
for (;;) {
if (nextc=='"') {
rc(F);
break;
} else if (!apos && isspace(nextc)) break;
*s++ = (char)nextc;
rc(F);
}
*s = 0;
}
static int
ri(FILE * F)
{
int i = 0, vz = 1;
while (!xisdigit(nextc)) {
if (nextc == EOF) {
puts("Die Datei bricht vorzeitig ab.");
abort();
}
rc(F);
}
while (xisdigit(nextc)) {
if (nextc == '-')
vz = -1;
else
i = 10 * i + (nextc - '0');
rc(F);
}
return i * vz;
}
static int
ri36(FILE * F)
{
char buf[64];
int i = 0;
rc(F);
while (!isalnum(nextc)) rc(F);
while (isalnum(nextc)) {
buf[i++]=(char)nextc;
rc(F);
}
buf[i]=0;
i = atoi36(buf);
return i;
}
#define MAXLINE 4096*16
static char lbuf[MAXLINE];
static char *
getbuf(FILE * F)
{
boolean cont = false;
boolean quote = false;
boolean comment = false;
char * cp = buf;
lbuf[MAXLINE-1] = '@';
do {
boolean eatwhite = true;
boolean start = true;
unsigned char * end;
unsigned char * bp = (unsigned char * )fgets(lbuf, MAXLINE, F);
comment = (boolean)(comment && cont);
if (!bp) return NULL;
end = bp + strlen((const char *)bp);
if (*(end-1)=='\n') *(--end) = 0;
else {
/* wenn die zeile länger als erlaubt war, ist sie ungültig,
* und wird mit dem rest weggeworfen: */
for (;;) {
bp = (unsigned char *)fgets(lbuf, MAXLINE, F);
if (bp==NULL) break;
end = bp + strlen((const char *)bp);
if (*(end-1)=='\n') break;
lbuf[MAXLINE-1] = 0;
}
comment = false;
bp = NULL;
}
cont = false;
while (bp!=NULL && *bp && cp!=buf+MAXLINE && (char*)bp!=lbuf+MAXLINE) {
if (isspace(*bp)) {
if (eatwhite) {
do { ++bp; } while ((char*)bp!=lbuf+MAXLINE && isspace(*bp));
if (!quote && !start && !comment) *(cp++)=' ';
}
else {
if (!comment) *(cp++)=*(bp++);
while (cp!=buf+MAXLINE && (char*)bp!=lbuf+MAXLINE && isspace(*bp)) {
if (!comment) *(cp++)=*bp;
++bp;
}
if (*bp==0) --cp;
}
}
else if (iscntrl(*bp)) {
*(cp++) = '?';
++bp;
} else {
cont = false;
if (*bp==COMMENT_CHAR && !quote) {
/* bp = max(end-1, bp+1); */
comment=true;
}
else {
if (*bp=='"') {
quote = (boolean)!quote;
*cp++ = *bp;
eatwhite=true;
}
else if (*bp=='\\') cont=true;
else {
if (!comment) *(cp++) = *bp;
eatwhite = (boolean)!quote;
}
}
++bp;
}
start = false;
}
if (cp==buf+MAXLINE) {
--cp;
}
*cp=0;
} while (cont || cp==buf);
return buf;
}
#ifdef ENEMIES
static void
read_enemies(FILE * F, faction * f)
{
if (global.data_version<ENEMIES_VERSION) return;
f->enemies = NULL;
for (;;) {
char zText[32];
fscanf(F, "%s", zText);
if (strcmp(zText, "end")==0) break;
else {
int fno = atoi36(zText);
faction_list * flist = malloc(sizeof(faction_list));
flist->next = f->enemies;
f->enemies = flist;
ur_add((void*)fno, (void**)&flist->data, resolve_faction);
}
}
}
static void
write_enemies(FILE * F, const faction_list * flist)
{
while (flist) {
fprintf(F, "%s ", itoa36(flist->data->no));
}
fputs("end \n", F);
}
#endif
static unit *
unitorders(FILE * F, struct faction * f)
{
int i;
unit *u;
if (!f) return NULL;
i = getid();
u = findunitg(i, NULL);
if (u && u->race == new_race[RC_SPELL]) return NULL;
if (u && u->faction == f) {
order ** ordp;
if (!quiet) {
printf(",_%4s_", itoa36(u->no));
fflush(stdout);
}
if (!fval(u, UFL_ORDERS)) {
/* alle wiederholbaren, langen befehle werden gesichert: */
fset(u, UFL_ORDERS);
u->old_orders = u->orders;
ordp = &u->old_orders;
while (*ordp) {
order * ord = *ordp;
if (!is_repeated(ord)) {
*ordp = ord->next;
ord->next = NULL;
free_order(ord);
} else {
ordp = &ord->next;
}
}
} else {
free_orders(&u->orders);
}
u->orders = 0;
ordp = &u->orders;
for (;;) {
const char * s;
/* Erst wenn wir sicher sind, dass kein Befehl
* eingegeben wurde, checken wir, ob nun eine neue
* Einheit oder ein neuer Spieler drankommt */
if (!getbuf(F)) break;
init_tokens_str(buf);
s = getstrtoken();
if (findkeyword(s, u->faction->locale) == NOKEYWORD) {
boolean quit = false;
switch (findparam(s, u->faction->locale)) {
case P_UNIT:
case P_REGION:
case P_FACTION:
case P_NEXT:
case P_GAMENAME:
quit = true;
}
if (quit) break;
}
if (buf[0]) {
/* Nun wird der Befehl erzeut und eingehängt */
*ordp = parse_order(buf, u->faction->locale);
if (*ordp) ordp = &(*ordp)->next;
}
}
} else {
/* cmistake(?, buf, 160, MSG_EVENT); */
return NULL;
}
return u;
}
static faction *
factionorders(void)
{
char b[16];
char * fid = strnzcpy(b, getstrtoken(), 15);
const char * pass = getstrtoken();
faction *f;
f = findfaction(atoi36(fid));
if (f!=NULL) {
/* Kontrolliere, ob das Passwort richtig eingegeben wurde. Es
* muß in "Gänsefüßchen" stehen!! */
/* War vorher in main.c:getgarbage() */
if (!quiet) {
printf(" %4s;", factionid(f));
fflush(stdout);
}
if (checkpasswd(f, pass, true) == false) {
log_warning(("Invalid password for faction %s\n", fid));
ADDMSG(&f->msgs, msg_message("msg_errors", "string",
"Das Passwort wurde falsch eingegeben"));
return 0;
}
/* Die Partei hat sich zumindest gemeldet, so daß sie noch
* nicht als untätig gilt */
/* TODO: +1 ist ein Workaround, weil turn erst in process_orders
* incrementiert wird. */
f->lastorders = global.data_turn+1;
} else
log_warning(("Befehle für die ungültige Partei %s\n", fid));
return f;
}
double
version(void)
{
return RELEASE_VERSION * 0.1;
}
/* ------------------------------------------------------------- */
static param_t
igetparam (const char *s, const struct locale *lang)
{
return findparam (igetstrtoken (s), lang);
}
int
readorders(const char *filename)
{
FILE * F = NULL;
char *b;
int nfactions=0;
struct faction *f = NULL;
if (filename) F = cfopen(filename, "rt");
if (F==NULL) return 0;
puts(" - lese Befehlsdatei...\n");
b = getbuf(F);
/* Auffinden der ersten Partei, und danach abarbeiten bis zur letzten
* Partei */
while (b) {
const struct locale * lang = f?f->locale:default_locale;
int p;
const char * s;
switch (igetparam(b, lang)) {
case P_LOCALE:
s = getstrtoken();
#undef LOCALE_CHANGE
#ifdef LOCALE_CHANGE
if (f && find_locale(s)) {
f->locale = find_locale(s);
}
#endif
b = getbuf(F);
break;
case P_GAMENAME:
case P_FACTION:
f = factionorders();
if (f) {
++nfactions;
}
b = getbuf(F);
break;
/* in factionorders wird nur eine zeile gelesen:
* diejenige mit dem passwort. Die befehle der units
* werden geloescht, und die Partei wird als aktiv
* vermerkt. */
case P_UNIT:
if (!f || !unitorders(F, f)) do {
b = getbuf(F);
if (!b) break;
p = igetparam(b, lang);
} while ((p != P_UNIT || !f) && p != P_FACTION && p != P_NEXT && p != P_GAMENAME);
break;
/* Falls in unitorders() abgebrochen wird, steht dort entweder eine neue
* Partei, eine neue Einheit oder das File-Ende. Das switch() wird erneut
* durchlaufen, und die entsprechende Funktion aufgerufen. Man darf buf
* auf alle Fälle nicht überschreiben! Bei allen anderen Einträgen hier
* muß buf erneut gefüllt werden, da die betreffende Information in nur
* einer Zeile steht, und nun die nächste gelesen werden muß. */
case P_NEXT:
f = NULL;
b = getbuf(F);
break;
default:
b = getbuf(F);
break;
}
}
fclose(F);
puts("\n");
log_printf(" %d Befehlsdateien gelesen\n", nfactions);
return 0;
}
/* ------------------------------------------------------------- */
/* #define INNER_WORLD */
/* fürs debuggen nur den inneren Teil der Welt laden */
/* -9;-27;-1;-19;Sumpfloch */
int
inner_world(region * r)
{
static int xy[2] =
{18, -45};
static int size[2] =
{27, 27};
if (r->x >= xy[0] && r->x < xy[0] + size[0] && r->y >= xy[1] && r->y < xy[1] + size[1])
return 2;
if (r->x >= xy[0] - 9 && r->x < xy[0] + size[0] + 9 && r->y >= xy[1] - 9 && r->y < xy[1] + size[1] + 9)
return 1;
return 0;
}
int maxregions = -1;
int loadplane = 0;
boolean dirtyload = false;
boolean incomplete_data = false;
enum {
U_MAN,
U_UNDEAD,
U_ILLUSION,
U_FIREDRAGON,
U_DRAGON,
U_WYRM,
U_SPELL,
U_TAVERNE,
U_MONSTER,
U_BIRTHDAYDRAGON,
U_TREEMAN,
MAXTYPES
};
race_t
typus2race(unsigned char typus)
{
if (typus>0 && typus <=11) return (race_t)(typus-1);
return NORACE;
}
void
create_backup(char *file)
{
#ifdef HAVE_UNISTD_H
char bfile[MAX_PATH];
int c = 1;
do {
sprintf(bfile, "%s.backup%d", file, c);
c++;
} while(access(bfile, R_OK) == 0);
link(file, bfile);
#endif
}
const char *
datapath(void)
{
static char zText[MAX_PATH];
if (g_datadir) return g_datadir;
return strcat(strcpy(zText, basepath()), "/data");
}
void
read_items(FILE *F, item **ilist)
{
for (;;) {
const item_type * itype;
rs(F, buf);
if (!strcmp("end", buf)) break;
itype = it_find(buf);
assert(itype!=NULL);
if (itype!=NULL) {
i_change(ilist, itype, ri(F));
}
}
}
#if RESOURCE_CONVERSION
struct attrib_type at_resources = {
"resources", NULL, NULL, NULL, NULL, NULL, ATF_UNIQUE
};
void
read_iron(struct region * r, int iron)
{
attrib * a = a_find(r->attribs, &at_resources);
assert(iron>=0);
if (a==NULL) {
a = a_add(&r->attribs, a_new(&at_resources));
a->data.sa[1] = -1;
}
a->data.sa[0] = (short)iron;
}
void
read_laen(struct region * r, int laen)
{
attrib * a = a_find(r->attribs, &at_resources);
assert(laen>=0);
if (a==NULL) {
a = a_add(&r->attribs, a_new(&at_resources));
a->data.sa[0] = -1;
}
a->data.sa[1] = (short)laen;
}
#endif
static void
read_alliances(FILE * F)
{
char pbuf[32];
if (global.data_version<SAVEALLIANCE_VERSION) {
if (!AllianceRestricted() && !AllianceAuto()) return;
}
rs(F, pbuf);
while (strcmp(pbuf, "end")!=0) {
rs(F, buf);
makealliance(atoi36(pbuf), buf);
rs(F, pbuf);
}
}
#define wc(F, c) putc(c, F);
#define wnl(F) putc('\n', F);
#define whs(F, s) fputs(s, F); putc(' ', F)
void
wsn(FILE * F, const char *s)
{
if (!s)
return;
while (*s)
wc(F, *s++);
}
void
ws(FILE * F, const char *s)
{
fputc('"', F);
wsn(F, s);
fputs("\" ", F);
}
static void
wi(FILE * F, int n)
{
fprintf(F, "%d ", n);
}
static void
wi36(FILE * F, int n)
{
fprintf(F, "%s ", itoa36(n));
}
void
write_alliances(FILE * F)
{
alliance * al = alliances;
while (al) {
wi36(F, al->id);
ws(F, al->name);
al = al->next;
wnl(F);
}
fprintf(F, "end ");
wnl(F);
}
void
write_items(FILE *F, item *ilist)
{
item * itm;
for (itm=ilist;itm;itm=itm->next) if (itm->number) {
fprintf(F, "%s %i ", resourcename(itm->type->rtype, 0), itm->number);
}
fputs("end ", F);
}
#ifdef USE_PLAYERS
static void
export_players(const char * path)
{
FILE * F;
player * p = get_players();
if (p==NULL) return;
F = cfopen(path, "w");
if (F==NULL) return;
fputs("name;email;passwd;faction;info\n", F);
while (p) {
/* name */
fputc('\"', F);
if (p->name) fputs(p->name, F);
/* email */
fputs("\";\"", F);
if (p->email) fputs(p->email, F);
else if (p->faction) fputs(p->faction->email, F);
fputs("\";\"", F);
/* passwd */
fputs("\";\"", F);
if (p->faction) fputs(p->faction->passw, F);
/* faction */
fputs("\";\"", F);
if (p->faction) fputs(itoa36(p->faction->no), F);
/* info */
fputs("\";\"", F);
if (p->info) fputs(p->info, F);
else if (p->faction) fputs(p->faction->banner, F);
fputs("\"\n", F);
p = next_player(p);
}
fclose(F);
}
#endif
int
lastturn(void)
{
int turn = 0;
#ifdef HAVE_READDIR
DIR *data_dir = NULL;
struct dirent *entry = NULL;
const char * dir = datapath();
data_dir = opendir(dir);
if (data_dir != NULL) {
entry = readdir(data_dir);
}
if (data_dir != NULL && entry != NULL) {
turn = 0;
do {
int i = atoi(entry->d_name);
if (i > turn)
turn = i;
entry = readdir(data_dir);
} while (entry != NULL);
#ifdef HAVE_CLOSEDIR
closedir(data_dir);
#endif
}
#else
# error "requires dirent.h or an equivalent to compile!"
#endif
return turn;
}
void
fwriteorder(FILE * F, const order * ord, const struct locale * lang)
{
write_order(ord, lang, buf, sizeof(buf));
if (buf[0]) fwritestr(F, buf);
}
unit *
readunit(FILE * F)
{
skill_t sk;
unit * u;
int number, n, p;
order ** orderp;
n = rid(F);
u = findunit(n);
if (u==NULL) {
u = calloc(sizeof(unit), 1);
u->no = n;
uhash(u);
} else {
while (u->attribs) a_remove(&u->attribs, u->attribs);
while (u->items) i_free(i_remove(&u->items, u->items));
free(u->skills);
u->skills = 0;
u->skill_size = 0;
u_setfaction(u, NULL);
}
{
int n = rid(F);
faction * f = findfaction(n);
if (f!=u->faction) u_setfaction(u, f);
}
rds(F, &u->name);
if (lomem) rds(F, 0);
else rds(F, &u->display);
#ifndef NDEBUG
if (strlen(u->name)>=NAMESIZE) u->name[NAMESIZE] = 0;
if (u->display && strlen(u->display)>=DISPLAYSIZE) u->display[DISPLAYSIZE] = 0;
#endif
number = ri(F);
u->age = (short)ri(F);
if (global.data_version<NEWRACE_VERSION) {
u->race = new_race[(race_t)ri(F)];
u->irace = new_race[(race_t)ri(F)];
} else {
char * space;
rs(F, buf);
space = strchr(buf, ' ');
if (space!=NULL) {
char * inc = space+1;
char * outc = space;
do {
while (*inc==' ') ++inc;
while (*inc) {
*outc++ = *inc++;
if (*inc==' ') break;
}
} while (*inc);
*outc = 0;
}
u->race = rc_find(buf);
assert(u->race);
rs(F, buf);
if (strlen(buf)) u->irace = rc_find(buf);
else u->irace = u->race;
}
if (u->faction == NULL) {
log_error(("unit %s has faction == NULL\n", unitname(u)));
u_setfaction(u, findfaction(MONSTER_FACTION));
set_number(u, 0);
}
if (playerrace(u->race)) {
u->faction->no_units++;
}
set_number(u, number);
u->building = findbuilding(rid(F));
u->ship = findship(rid(F));
if (global.data_version <= 73) {
if (ri(F)) {
fset(u, UFL_OWNER);
} else {
freset(u, UFL_OWNER);
}
}
u->status = (status_t) ri(F);
if (global.data_version < NEWSTATUS_VERSION) {
switch (u->status) {
case 0: u->status = ST_FIGHT; break;
case 1: u->status = ST_BEHIND; break;
case 2: u->status = ST_AVOID; break;
case 3: u->status = ST_FLEE; break;
default: assert(0);
}
}
if (global.data_version <= 73) {
if (ri(F)) {
guard(u, GUARD_ALL);
} else {
guard(u, GUARD_NONE);
}
} else {
u->flags = ri(F) & ~UFL_DEBUG;
u->flags &= UFL_SAVEMASK;
}
/* Persistente Befehle einlesen */
free_orders(&u->orders);
freadstr(F, buf, sizeof(buf));
p = n = 0;
orderp = &u->orders;
while (*buf != 0) {
order * ord = parse_order(buf, u->faction->locale);
if (ord!=NULL) {
if (++n<MAXORDERS) {
if (!is_persistent(ord) || ++p<MAXPERSISTENT) {
*orderp = ord;
orderp = &ord->next;
ord = NULL;
} else if (p==MAXPERSISTENT) {
log_error(("%s had %d or more persistent orders\n", unitname(u), MAXPERSISTENT));
}
} else if (n==MAXORDERS) {
log_error(("%s had %d or more orders\n", unitname(u), MAXORDERS));
}
if (ord!=NULL) free_order(ord);
}
freadstr(F, buf, sizeof(buf));
}
if (global.data_version<NOLASTORDER_VERSION) {
order * ord;
freadstr(F, buf, sizeof(buf));
ord = parse_order(buf, u->faction->locale);
if (ord!=NULL) {
#ifdef LASTORDER
set_order(&u->lastorder, ord);
#else
addlist(&u->orders, ord);
#endif
}
}
set_order(&u->thisorder, NULL);
assert(u->number <= UNIT_MAXSIZE);
assert(u->race);
if (global.data_version<NEWSKILL_VERSION) {
/* convert old data */
while ((sk = (skill_t) ri(F)) != NOSKILL) {
int days = ri(F) / u->number;
int lvl = level(days);
int weeks = lvl + 1 - (days - level_days(lvl))/30;
assert(weeks>0 && weeks<=lvl+1);
if (lvl) {
skill * sv = add_skill(u, sk);
sv->level = sv->old = (unsigned char)lvl;
sv->weeks = (unsigned char)weeks;
}
}
} else {
while ((sk = (skill_t) ri(F)) != NOSKILL) {
int level = ri(F);
int weeks = ri(F);
if (level) {
skill * sv = add_skill(u, sk);
sv->level = sv->old = (unsigned char)level;
sv->weeks = (unsigned char)weeks;
}
}
}
read_items(F, &u->items);
u->hp = ri(F);
if (u->hp < u->number) {
log_error(("Einheit %s hat %u Personen, und %u Trefferpunkte\n", itoa36(u->no),
u->number, u->hp));
u->hp=u->number;
}
if (global.data_version < MAGE_ATTRIB_VERSION) {
int i = ri(F);
if (i != -1){
attrib * a;
int csp = 0;
sc_mage * mage = calloc(1, sizeof(sc_mage));
mage->magietyp = (magic_t) i;
mage->spellpoints = ri(F);
mage->spchange = ri(F);
while ((i = ri(F)) != -1) {
mage->combatspells[csp].sp = find_spellbyid(mage->magietyp, (spellid_t)i);
mage->combatspells[csp].level = ri(F);
csp++;
}
while ((i = ri(F)) != -1) {
add_spell(mage, find_spellbyid(mage->magietyp, (spellid_t)i));
}
mage->spellcount = 0;
a = a_add(&u->attribs, a_new(&at_mage));
a->data.v = mage;
}
}
a_read(F, &u->attribs);
return u;
}
void
writeunit(FILE * F, const unit * u)
{
order * ord;
int i, p = 0;
wi36(F, u->no);
wi36(F, u->faction->no);
ws(F, u->name);
ws(F, u->display?u->display:"");
wi(F, u->number);
wi(F, u->age);
ws(F, u->race->_name[0]);
ws(F, u->irace!=u->race?u->irace->_name[0]:"");
if (u->building)
wi36(F, u->building->no);
else
wi(F, 0);
if (u->ship) wi36(F, u->ship->no);
else wi36(F, 0);
wi(F, u->status);
wi(F, u->flags & UFL_SAVEMASK);
wnl(F);
#ifndef LASTORDER
for (ord = u->old_orders; ord; ord=ord->next) {
if (++p<MAXPERSISTENT) {
fwriteorder(F, ord, u->faction->locale);
fputc(' ', F);
} else {
log_error(("%s had %d or more persistent orders\n", unitname(u), MAXPERSISTENT));
break;
}
}
#endif
for (ord = u->orders; ord; ord=ord->next) {
if (u->old_orders && is_repeated(ord)) continue; /* has new defaults */
if (is_persistent(ord)) {
if (++p<MAXPERSISTENT) {
fwriteorder(F, ord, u->faction->locale);
fputc(' ', F);
} else {
log_error(("%s had %d or more persistent orders\n", unitname(u), MAXPERSISTENT));
break;
}
}
}
/* write an empty string to terminate the list */
fputs("\"\"", F);
wnl(F);
#if RELEASE_VERSION<NOLASTORDER_VERSION
/* the current default order */
fwriteorder(F, u->lastorder, u->faction->locale);
wnl(F);
#endif
assert(u->number <= UNIT_MAXSIZE);
assert(u->race);
for (i=0;i!=u->skill_size;++i) {
skill * sv = u->skills+i;
assert(sv->weeks<=sv->level*2+1);
if (sv->level>0) {
wi(F, sv->id);
wi(F, sv->level);
wi(F, sv->weeks);
}
}
wi(F, -1);
wnl(F);
write_items(F, u->items);
wnl(F);
if (u->hp == 0) {
log_error(("Einheit %s hat 0 Trefferpunkte\n", itoa36(u->no)));
((unit*)u)->hp = 1;
}
wi(F, u->hp);
wnl(F);
a_write(F, u->attribs);
wnl(F);
}
region *
readregion(FILE * F, short x, short y)
{
region * r = findregion(x, y);
const terrain_type * terrain;
if (r==NULL) {
r = new_region(x, y);
} else {
current_region = r;
while (r->attribs) a_remove(&r->attribs, r->attribs);
if (r->land) {
free(r->land); /* mem leak */
r->land->demands = 0; /* mem leak */
}
while (r->resources) {
rawmaterial * rm = r->resources;
r->resources = rm->next;
free(rm);
}
r->land = 0;
}
if (lomem) rds(F, 0);
else rds(F, &r->display);
if (global.data_version < TERRAIN_VERSION) {
int ter = ri(F);
if (global.data_version < NOFOREST_VERSION) {
if (ter>T_PLAIN) --ter;
}
terrain = newterrain((terrain_t)ter);
} else {
char name[64];
rs(F, name);
terrain = get_terrain(name);
if (terrain==NULL) {
log_error(("Unknown terrain '%s'\n", name));
assert(!"unknown terrain");
}
}
r->terrain = terrain;
r->flags = (char) ri(F);
if (global.data_version >= REGIONAGE_VERSION)
r->age = (unsigned short) ri(F);
else
r->age = 0;
if (fval(r->terrain, LAND_REGION)) {
r->land = calloc(1, sizeof(land_region));
rds(F, &r->land->name);
#ifndef NDEBUG
if (strlen(r->land->name)>=NAMESIZE) r->land->name[NAMESIZE] = 0;
#endif
}
if (r->land) {
int i;
if(global.data_version < GROWTREE_VERSION) {
i = ri(F); rsettrees(r, 2, i);
} else {
i = ri(F);
if (i<0) {
log_error(("number of trees in %s is %d.\n",
regionname(r, NULL), i));
i=0;
}
rsettrees(r, 0, i);
i = ri(F);
if (i<0) {
log_error(("number of young trees in %s is %d.\n",
regionname(r, NULL), i));
i=0;
}
rsettrees(r, 1, i);
i = ri(F);
if (i<0) {
log_error(("number of seeds in %s is %d.\n",
regionname(r, NULL), i));
i=0;
}
rsettrees(r, 2, i);
}
i = ri(F); rsethorses(r, i);
if (global.data_version < NEWRESOURCE_VERSION) {
i = ri(F);
#if RESOURCE_CONVERSION
if (i!=0) read_iron(r, i);
#endif
} else {
rawmaterial ** pres = &r->resources;
assert(*pres==NULL);
for (;;) {
rawmaterial * res;
rs(F, buf);
if (strcmp(buf, "end")==0) break;
res = calloc(sizeof(rawmaterial), 1);
res->type = rmt_find(buf);
assert(res->type!=NULL);
res->level = ri(F);
res->amount = ri(F);
if(global.data_version >= RANDOMIZED_RESOURCES_VERSION) {
res->startlevel = ri(F);
res->base = ri(F);
res->divisor = ri(F);
} else {
int i;
for (i=0;r->terrain->production[i].type;++i) {
if (res->type->rtype == r->terrain->production[i].type) break;
}
res->base = dice_rand(r->terrain->production[i].base);
res->divisor = dice_rand(r->terrain->production[i].divisor);
res->startlevel = 1;
}
*pres = res;
pres=&res->next;
}
}
rs(F, buf);
if (strcmp(buf, "noherb") != 0) {
const resource_type * rtype = rt_find(buf);
assert(rtype && rtype->itype && fval(rtype->itype, ITF_HERB));
rsetherbtype(r, rtype->itype);
} else {
rsetherbtype(r, NULL);
}
rsetherbs(r, (short)ri(F));
rsetpeasants(r, ri(F));
rsetmoney(r, ri(F));
}
assert(r->terrain!=NULL);
assert(rhorses(r) >= 0);
assert(rpeasants(r) >= 0);
assert(rmoney(r) >= 0);
if (r->land) {
for (;;) {
const struct item_type * itype;
rs(F, buf);
if (!strcmp(buf, "end")) break;
itype = it_find(buf);
assert(itype->rtype->ltype);
r_setdemand(r, itype->rtype->ltype, ri(F));
}
if (global.data_version>=REGIONITEMS_VERSION) {
read_items(F, &r->land->items);
}
}
a_read(F, &r->attribs);
return r;
}
void
writeregion(FILE * F, const region * r)
{
ws(F, r->display?r->display:"");
ws(F, r->terrain->_name);
wi(F, r->flags & RF_SAVEMASK);
wi(F, r->age);
wnl(F);
if (fval(r->terrain, LAND_REGION)) {
const item_type *rht;
struct demand * demand;
rawmaterial * res = r->resources;
ws(F, r->land->name);
assert(rtrees(r,0)>=0);
assert(rtrees(r,1)>=0);
assert(rtrees(r,2)>=0);
wi(F, rtrees(r,0));
wi(F, rtrees(r,1));
wi(F, rtrees(r,2));
wi(F, rhorses(r));
while (res) {
ws(F, res->type->name);
wi(F, res->level);
wi(F, res->amount);
wi(F, res->startlevel);
wi(F, res->base);
wi(F, res->divisor);
res = res->next;
}
fputs("end ", F);
rht = rherbtype(r);
if (rht) {
ws(F, resourcename(rht->rtype, 0));
} else {
ws(F, "noherb");
}
wi(F, rherbs(r));
wi(F, rpeasants(r));
wi(F, rmoney(r));
if (r->land) for (demand=r->land->demands; demand; demand=demand->next) {
ws(F, resourcename(demand->type->itype->rtype, 0));
wi(F, demand->value);
}
fputs("end \n", F);
#if RELEASE_VERSION>=REGIONITEMS_VERSION
write_items(F, r->land->items);
wnl(F);
#endif
}
a_write(F, r->attribs);
wnl(F);
}
static ally **
addally(const faction * f, ally ** sfp, int aid, int state)
{
struct faction * af = findfaction(aid);
ally * sf;
state &= ~HELP_OBSERVE;
#ifndef REGIONOWNERS
state &= ~HELP_TRAVEL;
#endif
if (state==0) return sfp;
sf = calloc(1, sizeof(ally));
sf->faction = af;
if (!sf->faction) {
variant id;
id.i = aid;
ur_add(id, (void**)&sf->faction, resolve_faction);
}
sf->status = state & HELP_ALL;
while (*sfp) sfp=&(*sfp)->next;
*sfp = sf;
return &sf->next;
}
/** Reads a faction from a file.
* This function requires no context, can be called in any state. The
* faction may not already exist, however.
*/
faction *
readfaction(FILE * F)
{
ally **sfp;
int planes;
int i = rid(F);
faction * f = findfaction(i);
char * email = NULL;
if (f==NULL) {
f = (faction *) calloc(1, sizeof(faction));
f->no = i;
} else {
#ifdef MSG_LEVELS
f->warnings = NULL; /* mem leak */
#endif
f->allies = NULL; /* mem leak */
while (f->attribs) a_remove(&f->attribs, f->attribs);
}
f->subscription = ri(F);
if (alliances!=NULL) {
int allianceid = rid(F);
if (allianceid!=0) f->alliance = findalliance(allianceid);
if (f->alliance) {
faction_list * flist = malloc(sizeof(faction_list));
flist->data = f;
flist->next = f->alliance->members;
f->alliance->members = flist;
}
}
rds(F, &f->name);
rds(F, &f->banner);
#ifndef NDEBUG
if (strlen(f->name)>=NAMESIZE) f->name[NAMESIZE] = 0;
if (strlen(f->banner)>=DISPLAYSIZE) f->banner[DISPLAYSIZE] = 0;
#endif
if (!quiet) printf(" - Lese Partei %s (%s)\n", f->name, factionid(f));
rds(F, &email);
if (set_email(&f->email, email)!=0) {
log_error(("Invalid email address for faction %s: %s\n", itoa36(f->no), email));
set_email(&f->email, "");
}
free(email);
rds(F, &f->passw);
if (global.data_version >= OVERRIDE_VERSION) {
rds(F, &f->override);
} else {
f->override = strdup(itoa36(rand()));
}
if (global.data_version < LOCALE_VERSION) {
f->locale = find_locale("de");
} else {
rs(F, buf);
f->locale = find_locale(buf);
}
f->lastorders = ri(F);
f->age = ri(F);
if (global.data_version < NEWRACE_VERSION) {
race_t rc = (char) ri(F);
f->race = new_race[rc];
} else {
rs(F, buf);
f->race = rc_find(buf);
assert(f->race);
}
#ifdef CONVERT_DBLINK
convertunique(f);
#endif
f->magiegebiet = (magic_t)ri(F);
f->karma = ri(F);
f->flags = ri(F);
freset(f, FFL_OVERRIDE);
a_read(F, &f->attribs);
if (global.data_version>=CLAIM_VERSION) {
read_items(F, &f->items);
}
#ifdef MSG_LEVELS
read_msglevels(&f->warnings, F);
#else
for (;;) {
int level;
fscanf(F, "%s", buf);
if (strcmp("end", buf)==0) break;
fscanf(F, "%d ", &level);
}
#endif
planes = ri(F);
while(--planes >= 0) {
int id = ri(F);
short ux = (short)ri(F);
short uy = (short)ri(F);
set_ursprung(f, id, ux, uy);
}
f->newbies = 0;
i = f->options = ri(F);
if ((i & ((1<<O_REPORT)|(1<<O_COMPUTER)))==0 && f->no!=MONSTER_FACTION) {
/* Kein Report eingestellt, Fehler */
f->options = f->options | Pow(O_REPORT) | Pow(O_ZUGVORLAGE);
}
if (global.data_version < TYPES_VERSION) {
int sk = ri(F); /* f->seenspell überspringen */
spell_list * slist;
for (slist=spells;slist!=NULL;slist=slist->next) {
spell * sp = slist->data;
if (sp->magietyp==f->magiegebiet && sp->level<=sk) {
a_add(&f->attribs, a_new(&at_seenspell))->data.v = sp;
}
}
}
sfp = &f->allies;
if (global.data_version<ALLIANCES_VERSION) {
int p = ri(F);
while (--p >= 0) {
int aid = rid(F);
int state = ri(F);
sfp = addally(f, sfp, aid, state);
}
} else {
for (;;) {
rs(F, buf);
if (strcmp(buf, "end")==0) break;
else {
int aid = atoi36(buf);
int state = ri(F);
sfp = addally(f, sfp, aid, state);
}
}
}
read_groups(F, f);
#ifdef ENEMIES
read_enemies(F, f);
#endif
return f;
}
void
writefaction(FILE * F, const faction * f)
{
ally *sf;
ursprung *ur;
wi36(F, f->no);
wi(F, f->subscription);
if (alliances!=NULL) {
if (f->alliance) wi36(F, f->alliance->id);
else wi36(F, 0);
}
ws(F, f->name);
ws(F, f->banner);
ws(F, f->email);
ws(F, f->passw);
ws(F, f->override);
ws(F, locale_name(f->locale));
wi(F, f->lastorders);
wi(F, f->age);
ws(F, f->race->_name[0]);
wnl(F);
wi(F, f->magiegebiet);
wi(F, f->karma);
wi(F, f->flags);
a_write(F, f->attribs);
wnl(F);
#if RELEASE_VERSION>=CLAIM_VERSION
write_items(F, f->items);
wnl(F);
#endif
#ifdef MSG_LEVELS
write_msglevels(f->warnings, F);
#else
fputs("end ", F);
#endif
wnl(F);
wi(F, listlen(f->ursprung));
for(ur = f->ursprung;ur;ur=ur->next) {
wi(F, ur->id);
wi(F, ur->x);
wi(F, ur->y);
}
wnl(F);
wi(F, f->options & ~Pow(O_DEBUG));
wnl(F);
for (sf = f->allies; sf; sf = sf->next) {
int no = (sf->faction!=NULL)?sf->faction->no:0;
int status = alliedfaction(NULL, f, sf->faction, HELP_ALL);
if (status!=0) {
wi36(F, no);
wi(F, sf->status);
}
}
fprintf(F, "end ");
wnl(F);
write_groups(F, f->groups);
#ifdef ENEMIES
write_enemies(F, f->enemies);
#endif
}
int
readgame(const char * filename, int backup)
{
int i, n, p;
faction *f, **fp;
region *r;
building *b, **bp;
ship *sh, **shp;
unit *u;
FILE * F;
int rmax = maxregions;
sprintf(buf, "%s/%s", datapath(), filename);
log_printf("- reading game data from %s\n", filename);
if (backup) create_backup(buf);
F = cfopen(buf, "r");
if (F==NULL) {
log_error(("Keine Spieldaten gefunden.\n"));
return -1;
}
rc(F);
/* globale Variablen */
global.data_version = ri(F);
assert(global.data_version>=MIN_VERSION || !"unsupported data format");
assert(global.data_version<=RELEASE_VERSION || !"unsupported data format");
assert(global.data_version >= NEWSOURCE_VERSION);
if(global.data_version >= SAVEXMLNAME_VERSION) {
char basefile[1024];
const char *basearg = "(null)";
rs(F, basefile);
assert(xmlfile != NULL);
basearg = strrchr(xmlfile, '/');
if (basearg==NULL) {
basearg = xmlfile;
} else {
++basearg;
}
if (strcmp(basearg, basefile)!=0) {
log_warning(("xmlfile mismatch: datafile contains %s, argument/default is %s\n", basefile, basearg));
printf("WARNING: any key to continue, Ctrl-C to stop\n");
getchar();
}
}
if (global.data_version >= GLOBAL_ATTRIB_VERSION) {
a_read(F, &global.attribs);
}
global.data_turn = turn = ri(F);
ri(F); /* max_unique_id = */
nextborder = ri(F);
/* Planes */
planes = NULL;
n = ri(F);
while(--n >= 0) {
plane *pl = calloc(1, sizeof(plane));
pl->id = ri(F);
rds(F, &pl->name);
pl->minx = (short)ri(F);
pl->maxx = (short)ri(F);
pl->miny = (short)ri(F);
pl->maxy = (short)ri(F);
pl->flags = ri(F);
if (global.data_version>WATCHERS_VERSION) {
rs(F, buf);
while (strcmp(buf, "end")!=0) {
watcher * w = calloc(sizeof(watcher),1);
variant fno;
fno.i = atoi36(buf);
w->mode = (unsigned char)ri(F);
w->next = pl->watchers;
pl->watchers = w;
ur_add(fno, (void**)&w->faction, resolve_faction);
rs(F, buf);
}
}
a_read(F, &pl->attribs);
addlist(&planes, pl);
}
/* Read factions */
if (global.data_version>=ALLIANCES_VERSION) {
read_alliances(F);
}
n = ri(F);
printf(" - Einzulesende Parteien: %d\n", n);
fp = &factions;
while (*fp) fp=&(*fp)->next;
/* fflush (stdout); */
while (--n >= 0) {
faction * f = readfaction(F);
addlist2(fp, f);
fhash(f);
}
*fp = 0;
/* Benutzte Faction-Ids */
no_used_faction_ids = ri(F);
/* used_faction_ids = gc_add(malloc(no_used_faction_ids*sizeof(int))); */
used_faction_ids = malloc(no_used_faction_ids*sizeof(int));
for(i=0; i < no_used_faction_ids; i++) {
used_faction_ids[i] = ri(F);
}
/* Regionen */
n = ri(F);
if (rmax<0) rmax = n;
printf(" - Einzulesende Regionen: %d/%d\r", rmax, n);
if (loadplane || dirtyload || firstx || firsty || maxregions>=0) {
incomplete_data = true;
}
while (--n >= 0) {
unit **up;
boolean skip = false;
short x = (short)ri(F);
short y = (short)ri(F);
plane * pl = findplane(x, y);
if (firstx || firsty) {
if (x!=firstx || y!=firsty) {
skip = true;
} else {
firstx=0;
firsty=0;
if (rmax>0) rmax = min(n, rmax)-1;
}
}
if (loadplane && (!pl || pl->id!=loadplane)) skip = true;
if (rmax==0) {
if (dirtyload) break;
skip = true;
}
if ((n%1024)==0) { /* das spart extrem Zeit */
printf(" - Einzulesende Regionen: %d/%d ", rmax, n);
printf("* %d,%d \r", x, y);
}
if (skip) {
char * r;
do {
r = fgets(buf, BUFSIZE, F); /* skip region */
} while (r && buf[0]!='\n');
continue;
}
--rmax;
r = readregion(F, x, y);
/* Burgen */
p = ri(F);
bp = &r->buildings;
while (--p >= 0) {
b = (building *) calloc(1, sizeof(building));
b->no = rid(F);
bhash(b);
rds(F, &b->name);
if (lomem) rds(F, 0);
else rds(F, &b->display);
#ifndef NDEBUG
if (strlen(b->name)>=NAMESIZE) b->name[NAMESIZE] = 0;
if (b->display && strlen(b->display)>=DISPLAYSIZE) b->display[DISPLAYSIZE] = 0;
#endif
b->size = ri(F);
if (global.data_version < TYPES_VERSION) {
assert(!"data format is no longer supported");
/* b->type = oldbuildings[ri(F)]; */
}
else {
rs(F, buf);
b->type = bt_find(buf);
}
b->region = r;
a_read(F, &b->attribs);
addlist2(bp, b);
}
/* Schiffe */
p = ri(F);
shp = &r->ships;
while (--p >= 0) {
sh = (ship *) calloc(1, sizeof(ship));
sh->region = r;
sh->no = rid(F);
shash(sh);
rds(F, &sh->name);
if (lomem) rds(F, 0);
else rds(F, &sh->display);
#ifndef NDEBUG
if (sh->name && strlen(sh->name)>=NAMESIZE) sh->name[NAMESIZE] = 0;
if (sh->display && strlen(sh->display)>=DISPLAYSIZE) sh->display[DISPLAYSIZE] = 0;
#endif
rs(F, buf);
sh->type = st_find(buf);
assert(sh->type || !"ship_type not registered!");
sh->size = ri(F);
sh->damage = ri(F);
/* Attribute rekursiv einlesen */
sh->coast = (direction_t)ri(F);
a_read(F, &sh->attribs);
addlist2(shp, sh);
}
*shp = 0;
/* Einheiten */
p = ri(F);
up = &r->units;
while (--p >= 0) {
unit * u = readunit(F);
assert(u->region==NULL);
u->region = r;
addlist2(up,u);
update_interval(u->faction, u->region);
}
}
printf("\n");
if (!dirtyload) {
read_borders(F);
}
fclose(F);
/* Unaufgeloeste Zeiger initialisieren */
printf("\n - Referenzen initialisieren...\n");
resolve();
printf("\n - Leere Gruppen löschen...\n");
for (f=factions; f; f=f->next) {
group ** gp = &f->groups;
while (*gp) {
group * g = *gp;
if (g->members==0) {
*gp = g->next;
free_group(g);
} else
gp = &g->next;
}
}
for (r=regions;r;r=r->next) {
building * b;
for (b=r->buildings;b;b=b->next) update_lighthouse(b);
}
printf(" - Regionen initialisieren & verbinden...\n");
for (f = factions; f; f = f->next) {
for (u = f->units; u; u = u->nextF) {
if (u->number>0) {
f->alive = 1;
break;
}
}
}
if (findfaction(0)) {
findfaction(0)->alive = 1;
}
if (loadplane || maxregions>=0) {
remove_empty_factions(false);
}
return 0;
}
int
writegame(const char *filename, char quiet)
{
char *base;
int i,n;
faction *f;
region *r;
building *b;
ship *sh;
unit *u;
plane *pl;
FILE * F;
#ifdef USE_PLAYERS
char playerfile[MAX_PATH];
#endif
#ifdef USE_PLAYERS
sprintf(buf, "%s/%d.players", datapath(), turn);
export_players(playerfile);
#endif
sprintf(buf, "%s/%s", datapath(), filename);
#ifdef HAVE_UNISTD_H
if (access(buf, R_OK) == 0) {
/* make sure we don't overwrite some hardlinkedfile */
unlink(buf);
}
#endif
F = cfopen(buf, "w");
if (F==NULL)
return -1;
if (!quiet)
printf("Schreibe die %d. Runde...\n", turn);
/* globale Variablen */
wi(F, RELEASE_VERSION);
wnl(F);
base = strrchr(xmlfile, '/');
if(base) {
ws(F, base+1);
} else {
ws(F, xmlfile);
}
wnl(F);
a_write(F, global.attribs);
wnl(F);
wi(F, turn);
wi(F, 0/*max_unique_id*/);
wi(F, nextborder);
/* Write planes */
wnl(F);
wi(F, listlen(planes));
wnl(F);
for(pl = planes; pl; pl=pl->next) {
watcher * w;
wi(F, pl->id);
ws(F, pl->name);
wi(F, pl->minx);
wi(F, pl->maxx);
wi(F, pl->miny);
wi(F, pl->maxy);
wi(F, pl->flags);
w = pl->watchers;
while (w) {
if (w->faction) {
wi36(F, w->faction->no);
wi(F, w->mode);
}
w = w->next;
}
fputs("end ", F);
a_write(F, pl->attribs);
wnl(F);
}
/* Write factions */
#if RELEASE_VERSION>=ALLIANCES_VERSION
write_alliances(F);
#endif
n = listlen(factions);
wi(F, n);
wnl(F);
printf(" - Schreibe %d Parteien...\n",n);
for (f = factions; f; f = f->next) {
writefaction(F, f);
}
wi(F, no_used_faction_ids);
wnl(F);
for(i=0; i<no_used_faction_ids; i++) {
wi(F, used_faction_ids[i]);
wnl(F);
}
wnl(F);
/* Write regions */
n=listlen(regions);
wi(F, n);
wnl(F);
printf(" - Schreibe Regionen: %d \r", n);
for (r = regions; r; r = r->next, --n) {
/* plus leerzeile */
if ((n%1024)==0) { /* das spart extrem Zeit */
printf(" - Schreibe Regionen: %d \r", n);
fflush(stdout);
}
wnl(F);
wi(F, r->x);
wi(F, r->y);
writeregion(F, r);
wi(F, listlen(r->buildings));
wnl(F);
for (b = r->buildings; b; b = b->next) {
wi36(F, b->no);
ws(F, b->name);
ws(F, b->display?b->display:"");
wi(F, b->size);
ws(F, b->type->_name);
wnl(F);
a_write(F, b->attribs);
wnl(F);
}
wi(F, listlen(r->ships));
wnl(F);
for (sh = r->ships; sh; sh = sh->next) {
assert(sh->region == r);
wi36(F, sh->no);
ws(F, sh->name);
ws(F, sh->display?sh->display:"");
ws(F, sh->type->name[0]);
wi(F, sh->size);
wi(F, sh->damage);
wi(F, sh->coast);
wnl(F);
a_write(F, sh->attribs);
wnl(F);
}
wi(F, listlen(r->units));
wnl(F);
for (u = r->units; u; u = u->next) {
writeunit(F, u);
}
}
wnl(F);
write_borders(F);
wnl(F);
fclose(F);
printf("\nOk.\n");
return 0;
}
Reference in a new issue View git blame Copy permalink