Marc
/
server
forked from github/server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix source encodings, break umlauts, ASCII everywhere

This commit is contained in:
Enno Rehling 2018-12-17 12:07:38 +01:00
parent 4fee151f35
commit a848a1b2ee
20 changed files with 149 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
src/.report.c.swp Normal file
View File

Binary file not shown.

2
src/attributes/attributes.c
View File

@ -169,7 +169,7 @@ static int read_ext(variant *var, void *owner, gamedata *data)
void register_attributes(void) void register_attributes(void)
{ {
/* Alle speicherbaren Attribute müssen hier registriert werden */ /* Alle speicherbaren Attribute muessen hier registriert werden */
at_register(&at_shiptrail); at_register(&at_shiptrail);
at_register(&at_familiar); at_register(&at_familiar);
at_register(&at_familiarmage); at_register(&at_familiarmage);

4
src/direction.c
View File

@ -25,8 +25,8 @@ void init_direction(const struct locale *lang, direction_t dir, const char *str)
} }
void init_directions(struct locale *lang) { void init_directions(struct locale *lang) {
/* mit dieser routine kann man mehrere namen für eine direction geben, /* mit dieser routine kann man mehrere namen fuer eine direction geben,
* das ist für die hexes ideal. */ * das ist fuer die hexes ideal. */
const struct { const struct {
const char *name; const char *name;
direction_t direction; direction_t direction;

36
src/kernel/curse.c
View File

@ -333,8 +333,8 @@ void ct_checknames(void) {
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* get_curse identifiziert eine Verzauberung über die ID und gibt /* get_curse identifiziert eine Verzauberung ueber die ID und gibt
* einen pointer auf die struct zurück. * einen pointer auf die struct zurueck.
*/ */
static bool cmp_curse(const attrib * a, const void *data) static bool cmp_curse(const attrib * a, const void *data)
@ -387,7 +387,7 @@ bool remove_curse(attrib ** ap, const curse * c)
return a && a_remove(ap, a) == 1; return a && a_remove(ap, a) == 1;
} }
/* gibt die allgemeine Stärke der Verzauberung zurück. id2 wird wie /* gibt die allgemeine Staerke der Verzauberung zurueck. id2 wird wie
* oben benutzt. Dies ist nicht die Wirkung, sondern die Kraft und * oben benutzt. Dies ist nicht die Wirkung, sondern die Kraft und
* damit der gegen Antimagie wirkende Widerstand einer Verzauberung */ * damit der gegen Antimagie wirkende Widerstand einer Verzauberung */
static double get_cursevigour(const curse * c) static double get_cursevigour(const curse * c)
@ -395,15 +395,15 @@ static double get_cursevigour(const curse * c)
return c ? c->vigour : 0; return c ? c->vigour : 0;
} }
/* setzt die Stärke der Verzauberung auf i */ /* setzt die Staerke der Verzauberung auf i */
static void set_cursevigour(curse * c, double vigour) static void set_cursevigour(curse * c, double vigour)
{ {
assert(c && vigour > 0); assert(c && vigour > 0);
c->vigour = vigour; c->vigour = vigour;
} }
/* verändert die Stärke der Verzauberung um +i und gibt die neue /* veraendert die Stärke der Verzauberung um +i und gibt die neue
* Stärke zurück. Sollte die Zauberstärke unter Null sinken, löst er * Staerke zurueck. Sollte die Zauberstärke unter Null sinken, loest er
* sich auf. * sich auf.
*/ */
double curse_changevigour(attrib ** ap, curse * c, double vigour) double curse_changevigour(attrib ** ap, curse * c, double vigour)
@ -453,8 +453,8 @@ set_curseingmagician(struct unit *magician, struct attrib *ap_target,
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* gibt bei Personenbeschränkten Verzauberungen die Anzahl der /* gibt bei Personenbeschraenkten Verzauberungen die Anzahl der
* betroffenen Personen zurück. Ansonsten wird 0 zurückgegeben. */ * betroffenen Personen zurueck. Ansonsten wird 0 zurückgegeben. */
int get_cursedmen(const unit * u, const curse * c) int get_cursedmen(const unit * u, const curse * c)
{ {
int cursedmen = u->number; int cursedmen = u->number;
@ -502,7 +502,7 @@ static int newcurseid(void) {
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Legt eine neue Verzauberung an. Sollte es schon einen Zauber /* Legt eine neue Verzauberung an. Sollte es schon einen Zauber
* dieses Typs geben, gibt es den bestehenden zurück. * dieses Typs geben, gibt es den bestehenden zurueck.
*/ */
static curse *make_curse(unit * mage, attrib ** ap, const curse_type * ct, static curse *make_curse(unit * mage, attrib ** ap, const curse_type * ct,
double vigour, int duration, double effect, int men) double vigour, int duration, double effect, int men)
@ -535,7 +535,7 @@ static curse *make_curse(unit * mage, attrib ** ap, const curse_type * ct,
return c; return c;
} }
/* Mapperfunktion für das Anlegen neuer curse. Automatisch wird zum /* Mapperfunktion fuer das Anlegen neuer curse. Automatisch wird zum
* passenden Typ verzweigt und die relevanten Variablen weitergegeben. * passenden Typ verzweigt und die relevanten Variablen weitergegeben.
*/ */
curse *create_curse(unit * magician, attrib ** ap, const curse_type * ct, curse *create_curse(unit * magician, attrib ** ap, const curse_type * ct,
@ -585,8 +585,8 @@ curse *create_curse(unit * magician, attrib ** ap, const curse_type * ct,
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* hier müssen alle c-typen, die auf Einheiten gezaubert werden können, /* hier muessen alle c-typen, die auf Einheiten gezaubert werden koennen,
* berücksichtigt werden */ * beruecksichtigt werden */
static void do_transfer_curse(curse * c, const unit * u, unit * u2, int n) static void do_transfer_curse(curse * c, const unit * u, unit * u2, int n)
{ {
@ -705,15 +705,15 @@ message *cinfo_simple(const void *obj, objtype_t typ, const struct curse * c,
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Antimagie - curse auflösen */ /* Antimagie - curse aufloesen */
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Wenn der Curse schwächer ist als der cast_level, dann wird er /* Wenn der Curse schwaecher ist als der cast_level, dann wird er
* aufgelöst, bzw seine Kraft (vigour) auf 0 gesetzt. * aufgeloest, bzw seine Kraft (vigour) auf 0 gesetzt.
* Ist der cast_level zu gering, hat die Antimagie nur mit einer Chance * Ist der cast_level zu gering, hat die Antimagie nur mit einer Chance
* von 100-20*Stufenunterschied % eine Wirkung auf den Curse. Dann wird * von 100-20*Stufenunterschied % eine Wirkung auf den Curse. Dann wird
* die Kraft des Curse um die halbe Stärke der Antimagie reduziert. * die Kraft des Curse um die halbe Staerke der Antimagie reduziert.
* Zurückgegeben wird der noch unverbrauchte Rest von force. * Zurueckgegeben wird der noch unverbrauchte Rest von force.
*/ */
double destr_curse(curse * c, int cast_level, double force) double destr_curse(curse * c, int cast_level, double force)
{ {
@ -730,7 +730,7 @@ double destr_curse(curse * c, int cast_level, double force)
} }
} }
} }
else { /* Zauber ist stärker als curse */ else { /* Zauber ist staerker als curse */
if (force >= c->vigour) { /* reicht die Kraft noch aus? */ if (force >= c->vigour) { /* reicht die Kraft noch aus? */
force -= c->vigour; force -= c->vigour;
if (c->type->change_vigour) { if (c->type->change_vigour) {

82
src/kernel/curse.h
View File

@ -39,37 +39,37 @@ extern "C" {
* (struct attribute) * (struct attribute)
*/ */
/* Brainstorming Überarbeitung curse /* Brainstorming Überarbeitung curse
* *
* Ziel: Keine Enum-Liste, flexible, leicht erweiterbare Curse-Objekte * Ziel: Keine Enum-Liste, flexible, leicht erweiterbare Curse-Objekte
* *
* Was wird gebraucht? * Was wird gebraucht?
* - Eindeutige Kennung für globale Suche * - Eindeutige Kennung fuer globale Suche
* - eine Wirkung, die sich einfach 'anwenden' läßt, dabei flexibel ist, * - eine Wirkung, die sich einfach 'anwenden' laesst, dabei flexibel ist,
* Raum läßt für variable Boni, Anzahl betroffener Personen, * Raum laesst fuer variable Boni, Anzahl betroffener Personen,
* spezielle Effekte oder anderes * spezielle Effekte oder anderes
* - einfacher Zugriff auf allgemeine Funktionen wie zb Alterung, aber * - einfacher Zugriff auf allgemeine Funktionen wie zb Alterung, aber
* auch Antimagieverhalten * auch Antimagieverhalten
* - Ausgabe von Beschreibungen in verschiedenen Sprachen * - Ausgabe von Beschreibungen in verschiedenen Sprachen
* - definiertes gekapseltes Verhalten zb bei Zusammenlegung von * - definiertes gekapseltes Verhalten zb bei Zusammenlegung von
* Einheiten, Übergabe von Personen, Mehrfachverzauberung * Einheiten, Übergabe von Personen, Mehrfachverzauberung
* - (Rück-)Referenzen auf Objekt, Verursacher (Magier), ? * - (Rueck-)Referenzen auf Objekt, Verursacher (Magier), ?
* *
* Vieleicht wäre ein Wirkungsklassensystem sinnvoll, so das im übrigen * Vieleicht waere ein Wirkungsklassensystem sinnvoll, so das im uebrigen
* source einfach alle curse-attribs abgefragt werden können und bei * source einfach alle curse-attribs abgefragt werden koennen und bei
* gewünschter Wirkungsklasse angewendet, also nicht für jeden curse * gewuenschter Wirkungsklasse angewendet, also nicht für jeden curse
* spezielle Änderungen im übrigen source notwendig sind. * spezielle Änderungen im uebrigen source notwendig sind.
* *
* Die (Wirkungs-)Typen sollten die wichtigen Funktionen speziell * Die (Wirkungs-)Typen sollten die wichtigen Funktionen speziell
* belegen können, zb Alterung, Ausgabetexte, Merge-Verhalten * belegen koennen, zb Alterung, Ausgabetexte, Merge-Verhalten
* *
* Was sind wichtige individuelle Eigenschaften? * Was sind wichtige individuelle Eigenschaften?
* - Referenzen auf Objekt und Verursacher * - Referenzen auf Objekt und Verursacher
* - Referenzen für globale Liste * - Referenzen fuer globale Liste
* > die Wirkung: * > die Wirkung:
* - Dauer * - Dauer
* - Widerstandskraft, zb gegen Antimagie * - Widerstandskraft, zb gegen Antimagie
* - Seiteneffekte zb Flag ONLYONE, Unverträglichkeiten * - Seiteneffekte zb Flag ONLYONE, Unvertraeglichkeiten
* - Alterungsverhalten zb Flag NOAGE * - Alterungsverhalten zb Flag NOAGE
* - Effektverhalten, zb Bonus (variabel) * - Effektverhalten, zb Bonus (variabel)
* - bei Einheitenzaubern die Zahl der betroffenen Personen * - bei Einheitenzaubern die Zahl der betroffenen Personen
@ -77,16 +77,16 @@ extern "C" {
* Dabei sind nur die beiden letzten Punkte wirklich reine individuelle * Dabei sind nur die beiden letzten Punkte wirklich reine individuelle
* Wirkung, die anderen sind eher allgemeine Kennzeichen eines jeden * Wirkung, die anderen sind eher allgemeine Kennzeichen eines jeden
* Curse, die individuell belegt sind. * Curse, die individuell belegt sind.
* ONLYONE und NOAGE könnten auch Eigenschaften des Typs sein, nicht des * ONLYONE und NOAGE koennten auch Eigenschaften des Typs sein, nicht des
* individuellen curse. Allgemein ist Alterung wohl eher eine * individuellen curse. Allgemein ist Alterung wohl eher eine
* Typeigenschaft als die eines individuellen curse. * Typeigenschaft als die eines individuellen curse.
* Dagegen ist der Widerstand gegen Antimagie sowohl abhängig von der * Dagegen ist der Widerstand gegen Antimagie sowohl abhaengig von der
* Güte des Verursachers, also des Magiers zum Zeitpunkt des Zaubers, * Guete des Verursachers, also des Magiers zum Zeitpunkt des Zaubers,
* als auch vom Typ, der gegen bestimmte Arten des 'Fluchbrechens' immun * als auch vom Typ, der gegen bestimmte Arten des 'Fluchbrechens' immun
* sein könnte. * sein koennte.
* *
* Was sind wichtige Typeigenschaften? * Was sind wichtige Typeigenschaften?
* - Verhalten bei Personenübergaben * - Verhalten bei Personenuebergaben
* - allgemeine Wirkung * - allgemeine Wirkung
* - Beschreibungstexte * - Beschreibungstexte
* - Verhalten bei Antimagie * - Verhalten bei Antimagie
@ -94,8 +94,8 @@ extern "C" {
* - Speicherung des C-Objekts * - Speicherung des C-Objekts
* - Laden des C-Objekts * - Laden des C-Objekts
* - Erzeugen des C-Objekts * - Erzeugen des C-Objekts
* - Löschen und Aufräumen des C-Objekts * - Loeschen und Aufraeumen des C-Objekts
* - Funktionen zur Änderung der Werte * - Funktionen zur Änderung der Werte
* *
* */ * */
@ -118,17 +118,17 @@ extern "C" {
C_BADLEARN, C_BADLEARN,
C_SHIP_SPEEDUP, /* 9 - Sturmwind-Zauber */ C_SHIP_SPEEDUP, /* 9 - Sturmwind-Zauber */
C_SHIP_FLYING, /* 10 - Luftschiff-Zauber */ C_SHIP_FLYING, /* 10 - Luftschiff-Zauber */
C_SHIP_NODRIFT, /* 11 - GünstigeWinde-Zauber */ C_SHIP_NODRIFT, /* 11 - GuenstigeWinde-Zauber */
C_DEPRESSION, C_DEPRESSION,
C_MAGICWALLS, /* 13 - Heimstein */ C_MAGICWALLS, /* 13 - Heimstein */
C_STRONGWALL, /* 14 - Feste Mauer - Precombat */ C_STRONGWALL, /* 14 - Feste Mauer - Precombat */
C_ASTRALBLOCK, /* 15 - Astralblock */ C_ASTRALBLOCK, /* 15 - Astralblock */
C_GENEROUS, /* 16 - Unterhaltung vermehren */ C_GENEROUS, /* 16 - Unterhaltung vermehren */
C_PEACE, /* 17 - Regionsweit Attacken verhindern */ C_PEACE, /* 17 - Regionsweit Attacken verhindern */
C_MAGICSTREET, /* 19 - magisches Straßennetz */ C_MAGICSTREET, /* 19 - magisches Strassennetz */
C_RESIST_MAGIC, /* 20 - verändert Magieresistenz von Objekten */ C_RESIST_MAGIC, /* 20 - veraendert Magieresistenz von Objekten */
C_SONG_BADMR, /* 21 - verändert Magieresistenz */ C_SONG_BADMR, /* 21 - veraendert Magieresistenz */
C_SONG_GOODMR, /* 22 - verändert Magieresistenz */ C_SONG_GOODMR, /* 22 - veraendert Magieresistenz */
C_SLAVE, /* 23 - dient fremder Partei */ C_SLAVE, /* 23 - dient fremder Partei */
C_CALM, /* 25 - Beinflussung */ C_CALM, /* 25 - Beinflussung */
C_OLDRACE, C_OLDRACE,
@ -145,7 +145,7 @@ extern "C" {
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Flags */ /* Flags */
/* Verhalten von Zaubern auf Units beim Übergeben von Personen */ /* Verhalten von Zaubern auf Units beim Übergeben von Personen */
typedef enum { typedef enum {
CURSE_ISNEW = 0x01, /* wirkt in der zauberrunde nicht (default) */ CURSE_ISNEW = 0x01, /* wirkt in der zauberrunde nicht (default) */
CURSE_NOAGE = 0x02, /* wirkt ewig */ CURSE_NOAGE = 0x02, /* wirkt ewig */
@ -153,10 +153,10 @@ extern "C" {
CURSE_ONLYONE = 0x08, /* Verhindert, das ein weiterer Zauber dieser Art auf das Objekt gezaubert wird */ CURSE_ONLYONE = 0x08, /* Verhindert, das ein weiterer Zauber dieser Art auf das Objekt gezaubert wird */
/* the following are mutually exclusive */ /* the following are mutually exclusive */
CURSE_SPREADNEVER = 0x00, /* wird nie mit übertragen */ CURSE_SPREADNEVER = 0x00, /* wird nie mit uebertragen */
CURSE_SPREADALWAYS = 0x10, /* wird immer mit übertragen */ CURSE_SPREADALWAYS = 0x10, /* wird immer mit uebertragen */
CURSE_SPREADMODULO = 0x20, /* personenweise weitergabe */ CURSE_SPREADMODULO = 0x20, /* personenweise weitergabe */
CURSE_SPREADCHANCE = 0x30 /* Ansteckungschance je nach Mengenverhältnis */ CURSE_SPREADCHANCE = 0x30 /* Ansteckungschance je nach Mengenverhaeltnis */
} curseflags; } curseflags;
#define CURSE_FLAGSMASK 0x0F #define CURSE_FLAGSMASK 0x0F
@ -180,8 +180,8 @@ extern "C" {
#define M_SUMEFFECT 8 /* der Effekt summiert sich */ #define M_SUMEFFECT 8 /* der Effekt summiert sich */
#define M_MEN 16 /* die Anzahl der betroffenen Personen summiert #define M_MEN 16 /* die Anzahl der betroffenen Personen summiert
sich */ sich */
#define M_VIGOUR 32 /* das Maximum der beiden Stärken wird die #define M_VIGOUR 32 /* das Maximum der beiden Staerken wird die
Stärke des neuen Zaubers */ Staerke des neuen Zaubers */
#define M_VIGOUR_ADD 64 /* Vigour wird addiert */ #define M_VIGOUR_ADD 64 /* Vigour wird addiert */
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -212,7 +212,7 @@ extern "C" {
struct curse *nexthash; struct curse *nexthash;
const curse_type *type; /* Zeiger auf ein curse_type-struct */ const curse_type *type; /* Zeiger auf ein curse_type-struct */
struct unit *magician; /* Pointer auf den Magier, der den Spruch gewirkt hat */ struct unit *magician; /* Pointer auf den Magier, der den Spruch gewirkt hat */
double vigour; /* Stärke der Verzauberung, Widerstand gegen Antimagie */ double vigour; /* Staerke der Verzauberung, Widerstand gegen Antimagie */
double effect; double effect;
int no; /* 'Einheitennummer' dieses Curse */ int no; /* 'Einheitennummer' dieses Curse */
int mask; /* This is XORed with type->flags, see c_flags()! */ int mask; /* This is XORed with type->flags, see c_flags()! */
@ -251,35 +251,35 @@ extern "C" {
/* ignoriert CURSE_ISNEW */ /* ignoriert CURSE_ISNEW */
bool is_cursed_internal(struct attrib *ap, const curse_type * ctype); bool is_cursed_internal(struct attrib *ap, const curse_type * ctype);
/* löscht einen konkreten Spruch auf einem Objekt. */ /* loescht einen konkreten Spruch auf einem Objekt. */
bool remove_curse(struct attrib **ap, const struct curse *c); bool remove_curse(struct attrib **ap, const struct curse *c);
/* gibt die Auswirkungen der Verzauberungen zurück. zB bei /* gibt die Auswirkungen der Verzauberungen zurueck. zB bei
* Skillmodifiziernden Verzauberungen ist hier der Modifizierer * Skillmodifiziernden Verzauberungen ist hier der Modifizierer
* gespeichert. Wird automatisch beim Anlegen eines neuen curse * gespeichert. Wird automatisch beim Anlegen eines neuen curse
* gesetzt. Gibt immer den ersten Treffer von ap aus zurück. * gesetzt. Gibt immer den ersten Treffer von ap aus zurueck.
*/ */
int curse_geteffect_int(const struct curse *c); int curse_geteffect_int(const struct curse *c);
double curse_geteffect(const struct curse *c); double curse_geteffect(const struct curse *c);
/* verändert die Stärke der Verzauberung um i */ /* veraendert die Stärke der Verzauberung um i */
double curse_changevigour(struct attrib **ap, curse * c, double delta); double curse_changevigour(struct attrib **ap, curse * c, double delta);
/* gibt bei Personenbeschränkten Verzauberungen die Anzahl der /* gibt bei Personenbeschraenkten Verzauberungen die Anzahl der
* betroffenen Personen zurück. Ansonsten wird 0 zurückgegeben. */ * betroffenen Personen zurueck. Ansonsten wird 0 zurückgegeben. */
int get_cursedmen(const struct unit *u, const struct curse *c); int get_cursedmen(const struct unit *u, const struct curse *c);
/* setzt/loescht Spezialflag einer Verzauberung (zB 'dauert ewig') */ /* setzt/loescht Spezialflag einer Verzauberung (zB 'dauert ewig') */
void c_setflag(curse * c, unsigned int flag); void c_setflag(curse * c, unsigned int flag);
void c_clearflag(curse * c, unsigned int flags); void c_clearflag(curse * c, unsigned int flags);
/* sorgt dafür, das bei der Übergabe von Personen die curse-attribute /* sorgt dafuer, das bei der Übergabe von Personen die curse-attribute
* korrekt gehandhabt werden. Je nach internen Flag kann dies * korrekt gehandhabt werden. Je nach internen Flag kann dies
* unterschiedlich gewünscht sein * unterschiedlich gewuenscht sein
* */ * */
void transfer_curse(const struct unit *u, struct unit *u2, int n); void transfer_curse(const struct unit *u, struct unit *u2, int n);
/* gibt pointer auf die erste curse-struct zurück, deren Typ ctype ist, /* gibt pointer auf die erste curse-struct zurueck, deren Typ ctype ist,
* oder einen NULL-pointer * oder einen NULL-pointer
* */ * */
struct curse *get_curse(struct attrib *ap, const curse_type * ctype); struct curse *get_curse(struct attrib *ap, const curse_type * ctype);

14
src/kernel/plane.h
View File

@ -32,14 +32,14 @@ extern "C" {
#define PFL_NORECRUITS 2 /* cannot recruit */ #define PFL_NORECRUITS 2 /* cannot recruit */
#define PFL_NOALLIANCES 4 /* not implemented */ #define PFL_NOALLIANCES 4 /* not implemented */
#define PFL_LOWSTEALING 8 /* not implemented */ #define PFL_LOWSTEALING 8 /* not implemented */
#define PFL_NOGIVE 16 /* Übergaben sind unmöglich */ #define PFL_NOGIVE 16 /* Übergaben sind unmoeglich */
#define PFL_NOATTACK 32 /* Angriffe und Diebstähle sind unmöglich */ #define PFL_NOATTACK 32 /* Angriffe und Diebstaehle sind unmoeglich */
#define PFL_NOTERRAIN 64 /* Terraintyp wird nicht angezeigt TODO? */ #define PFL_NOTERRAIN 64 /* Terraintyp wird nicht angezeigt TODO? */
#define PFL_NOMAGIC 128 /* Zaubern ist unmöglich */ #define PFL_NOMAGIC 128 /* Zaubern ist unmoeglich */
#define PFL_NOSTEALTH 256 /* Tarnung außer Betrieb */ #define PFL_NOSTEALTH 256 /* Tarnung ausser Betrieb */
#define PFL_NOTEACH 512 /* Lehre außer Betrieb */ #define PFL_NOTEACH 512 /* Lehre ausser Betrieb */
#define PFL_NOBUILD 1024 /* Bauen außer Betrieb */ #define PFL_NOBUILD 1024 /* Bauen ausser Betrieb */
#define PFL_NOFEED 2048 /* Kein Unterhalt nötig */ #define PFL_NOFEED 2048 /* Kein Unterhalt noetig */
#define PFL_FRIENDLY 4096 /* not implemented */ #define PFL_FRIENDLY 4096 /* not implemented */
#define PFL_NOORCGROWTH 8192 /* orcs don't grow */ #define PFL_NOORCGROWTH 8192 /* orcs don't grow */
#define PFL_NOMONSTERS 16384 /* no monster randenc */ #define PFL_NOMONSTERS 16384 /* no monster randenc */

8
src/kernel/region.c
View File

@ -175,7 +175,7 @@ void deathcounts(region * r, int fallen)
} }
} }
/* Moveblock wird zur Zeit nicht über Attribute, sondern ein Bitfeld /* Moveblock wird zur Zeit nicht ueber Attribute, sondern ein Bitfeld
r->moveblock gemacht. Sollte umgestellt werden, wenn kompliziertere r->moveblock gemacht. Sollte umgestellt werden, wenn kompliziertere
Dinge gefragt werden. */ Dinge gefragt werden. */
@ -992,7 +992,7 @@ static char *makename(void)
*handle_end = "nlrdst", *handle_end = "nlrdst",
*vowels = "aaaaaaaaaaaeeeeeeeeeeeeiiiiiiiiiiioooooooooooouuuuuuuuuuyy"; *vowels = "aaaaaaaaaaaeeeeeeeeeeeeiiiiiiiiiiioooooooooooouuuuuuuuuuyy";
/* const char * vowels_latin1 = "aaaaaaaaaàâeeeeeeeeeéèêiiiiiiiiiíîoooooooooóòôuuuuuuuuuúyy"; */ /* const char * vowels_latin1 = "aaaaaaaaaàâeeeeeeeeeéèêiiiiiiiiiíîoooooooooóòôuuuuuuuuuúyy"; */
nk = strlen(kons); nk = strlen(kons);
ne = strlen(handle_end); ne = strlen(handle_end);
@ -1105,7 +1105,7 @@ void init_region(region *r)
void terraform_region(region * r, const terrain_type * terrain) void terraform_region(region * r, const terrain_type * terrain)
{ {
/* Resourcen, die nicht mehr vorkommen können, löschen */ /* Resourcen, die nicht mehr vorkommen koennen, löschen */
const terrain_type *oldterrain = r->terrain; const terrain_type *oldterrain = r->terrain;
rawmaterial **lrm = &r->resources; rawmaterial **lrm = &r->resources;
@ -1266,7 +1266,7 @@ void terraform_region(region * r, const terrain_type * terrain)
#include "curse.h" #include "curse.h"
int max_production(const region * r) int max_production(const region * r)
{ {
/* muß rterrain(r) sein, nicht rterrain() wegen rekursion */ /* muss rterrain(r) sein, nicht rterrain() wegen rekursion */
int p = r->terrain->size; int p = r->terrain->size;
if (curse_active(get_curse(r->attribs, &ct_drought))) { if (curse_active(get_curse(r->attribs, &ct_drought))) {
p /= 2; p /= 2;

4
src/kernel/terrain.h
View File

@ -24,10 +24,10 @@ extern "C" {
#endif #endif
/* diverse Flags */ /* diverse Flags */
/* Strassen und Gebäude können gebaut werden, wenn max_road > 0 */ /* Strassen und Gebaeude koennen gebaut werden, wenn max_road > 0 */
#define LAND_REGION (1<<0) /* Standard-Land-struct region */ #define LAND_REGION (1<<0) /* Standard-Land-struct region */
#define SEA_REGION (1<<1) /* hier braucht man ein Boot */ #define SEA_REGION (1<<1) /* hier braucht man ein Boot */
#define FOREST_REGION (1<<2) /* Elfen- und Kampfvorteil durch Bäume */ #define FOREST_REGION (1<<2) /* Elfen- und Kampfvorteil durch Baeume */
#define ARCTIC_REGION (1<<3) /* Gletscher & co = Keine Insekten! */ #define ARCTIC_REGION (1<<3) /* Gletscher & co = Keine Insekten! */
#define CAVALRY_REGION (1<<4) /* riding in combat is possible */ #define CAVALRY_REGION (1<<4) /* riding in combat is possible */
/* Achtung: SEA_REGION ist nicht das Gegenteil von LAND_REGION. Die zwei schliessen sich nichtmal aus! */ /* Achtung: SEA_REGION ist nicht das Gegenteil von LAND_REGION. Die zwei schliessen sich nichtmal aus! */

2
src/kernel/types.h
View File

@ -113,7 +113,7 @@ enum {
O_ADRESSEN, /* 512 */ O_ADRESSEN, /* 512 */
O_BZIP2, /* 1024 - compress as bzip2 */ O_BZIP2, /* 1024 - compress as bzip2 */
O_SCORE, /* 2048 - punkte anzeigen? */ O_SCORE, /* 2048 - punkte anzeigen? */
O_SHOWSKCHANGE, /* 4096 - Skillveränderungen anzeigen? */ O_SHOWSKCHANGE, /* 4096 - Skillveraenderungen anzeigen? */
MAXOPTIONS MAXOPTIONS
}; };

8
src/kernel/unit.h
View File

@ -47,7 +47,7 @@ extern "C" {
#define UFL_MOVED (1<<8) #define UFL_MOVED (1<<8)
#define UFL_NOTMOVING (1<<9) /* Die Einheit kann sich wg. langen Kampfes nicht bewegen */ #define UFL_NOTMOVING (1<<9) /* Die Einheit kann sich wg. langen Kampfes nicht bewegen */
#define UFL_DEFENDER (1<<10) #define UFL_DEFENDER (1<<10)
#define UFL_HUNGER (1<<11) /* kann im Folgemonat keinen langen Befehl außer ARBEITE ausführen */ #define UFL_HUNGER (1<<11) /* kann im Folgemonat keinen langen Befehl ausser ARBEITE ausfuehren */
#define UFL_TARGET (1<<13) /* speedup: hat ein target, siehe attribut */ #define UFL_TARGET (1<<13) /* speedup: hat ein target, siehe attribut */
#define UFL_WERE (1<<14) #define UFL_WERE (1<<14)
#define UFL_ENTER (1<<15) /* unit has entered a ship/building and will not leave it */ #define UFL_ENTER (1<<15) /* unit has entered a ship/building and will not leave it */
@ -55,14 +55,14 @@ extern "C" {
/* warning: von 512/1024 gewechslet, wegen konflikt mit NEW_FOLLOW */ /* warning: von 512/1024 gewechslet, wegen konflikt mit NEW_FOLLOW */
#define UFL_LOCKED (1<<16) /* Einheit kann keine Personen aufnehmen oder weggeben, nicht rekrutieren. */ #define UFL_LOCKED (1<<16) /* Einheit kann keine Personen aufnehmen oder weggeben, nicht rekrutieren. */
#define UFL_FLEEING (1<<17) /* unit was in a battle, fleeing. */ #define UFL_FLEEING (1<<17) /* unit was in a battle, fleeing. */
#define UFL_STORM (1<<19) /* Kapitän war in einem Sturm */ #define UFL_STORM (1<<19) /* Kapitaen war in einem Sturm */
#define UFL_FOLLOWING (1<<20) #define UFL_FOLLOWING (1<<20)
#define UFL_FOLLOWED (1<<21) #define UFL_FOLLOWED (1<<21)
#define UFL_NOAID (1<<22) /* Einheit hat Noaid-Status */ #define UFL_NOAID (1<<22) /* Einheit hat Noaid-Status */
#define UFL_MARK (1<<23) /* same as FL_MARK */ #define UFL_MARK (1<<23) /* same as FL_MARK */
#define UFL_ORDERS (1<<24) /* Einheit hat Befehle erhalten */ #define UFL_ORDERS (1<<24) /* Einheit hat Befehle erhalten */
#define UFL_TAKEALL (1<<25) /* Einheit nimmt alle Gegenstände an */ #define UFL_TAKEALL (1<<25) /* Einheit nimmt alle Gegenstaende an */
/* flags that speed up attribute access: */ /* flags that speed up attribute access: */
#define UFL_STEALTH (1<<26) #define UFL_STEALTH (1<<26)
@ -84,7 +84,7 @@ extern "C" {
typedef struct unit { typedef struct unit {
struct unit *next; /* needs to be first entry, for region's unitlist */ struct unit *next; /* needs to be first entry, for region's unitlist */
struct unit *nextF; /* nächste Einheit der Partei */ struct unit *nextF; /* naechste Einheit der Partei */
struct unit *prevF; /* vorherige Einheit der Partei */ struct unit *prevF; /* vorherige Einheit der Partei */
struct region *region; struct region *region;
int no; /* id */ int no; /* id */

94
src/magic.h
View File

@ -45,7 +45,7 @@ extern "C" {
/* Spruchparameter /* Spruchparameter
* Wir suchen beim Parsen des Befehls erstmal nach lokalen Objekten, * Wir suchen beim Parsen des Befehls erstmal nach lokalen Objekten,
* erst in verify_targets wird dann global gesucht, da in den meisten * erst in verify_targets wird dann global gesucht, da in den meisten
* Fällen das Zielobjekt lokal sein dürfte */ * Faellen das Zielobjekt lokal sein duerfte */
/* siehe auch objtype_t in objtypes.h */ /* siehe auch objtype_t in objtypes.h */
typedef enum { typedef enum {
@ -90,10 +90,10 @@ extern "C" {
* - Magierichtung * - Magierichtung
* - Magiepunkte derzeit * - Magiepunkte derzeit
* - Malus (neg. Wert)/ Bonus (pos. Wert) auf maximale Magiepunkte * - Malus (neg. Wert)/ Bonus (pos. Wert) auf maximale Magiepunkte
* (können sich durch Questen absolut verändern und durch Gegenstände * (koennen sich durch Questen absolut veraendern und durch Gegenstände
* temporär). Auch für Artefakt benötigt man permanente MP * temporaer). Auch fuer Artefakt benoetigt man permanente MP
* - Anzahl bereits gezauberte Sprüche diese Runde * - Anzahl bereits gezauberte Sprueche diese Runde
* - Kampfzauber (3) (vor/während/nach) * - Kampfzauber (3) (vor/waehrend/nach)
* - Spruchliste * - Spruchliste
*/ */
@ -115,12 +115,12 @@ extern "C" {
struct unit *_familiar; /* Vertrauter, gesetzt, wenn der Spruch durch struct unit *_familiar; /* Vertrauter, gesetzt, wenn der Spruch durch
den Vertrauten gezaubert wird */ den Vertrauten gezaubert wird */
const struct spell *sp; /* Spruch */ const struct spell *sp; /* Spruch */
int level; /* gewünschte Stufe oder Stufe des Magiers */ int level; /* gewuenschte Stufe oder Stufe des Magiers */
double force; /* Stärke des Zaubers */ double force; /* Staerke des Zaubers */
struct region *_rtarget; /* Zielregion des Spruchs */ struct region *_rtarget; /* Zielregion des Spruchs */
int distance; /* Entfernung zur Zielregion */ int distance; /* Entfernung zur Zielregion */
struct order *order; /* Befehl */ struct order *order; /* Befehl */
struct spellparameter *par; /* für weitere Parameter */ struct spellparameter *par; /* fuer weitere Parameter */
} castorder; } castorder;
struct unit * co_get_caster(const struct castorder * co); struct unit * co_get_caster(const struct castorder * co);
@ -139,27 +139,27 @@ extern "C" {
#define FARCASTING (1<<0) /* ZAUBER [struct region x y] */ #define FARCASTING (1<<0) /* ZAUBER [struct region x y] */
#define SPELLLEVEL (1<<1) /* ZAUBER [STUFE x] */ #define SPELLLEVEL (1<<1) /* ZAUBER [STUFE x] */
#define OCEANCASTABLE (1<<2) /* Können auch nicht-Meermenschen auf #define OCEANCASTABLE (1<<2) /* Koennen auch nicht-Meermenschen auf
hoher See zaubern */ hoher See zaubern */
#define ONSHIPCAST (1<<3) /* kann auch auf von Land ablegenden #define ONSHIPCAST (1<<3) /* kann auch auf von Land ablegenden
Schiffen stehend gezaubert werden */ Schiffen stehend gezaubert werden */
#define TESTCANSEE (1<<4) /* alle Zielunits auf cansee prüfen */ #define TESTCANSEE (1<<4) /* alle Zielunits auf cansee pruefen */
/* ID's können zu drei unterschiedlichen Entitäten gehören: Einheiten, /* ID's koennen zu drei unterschiedlichen Entitaeten gehören: Einheiten,
* Gebäuden und Schiffen. */ * Gebaeuden und Schiffen. */
#define UNITSPELL (1<<5) /* ZAUBER .. <Einheit-Nr> [<Einheit-Nr> ..] */ #define UNITSPELL (1<<5) /* ZAUBER .. <Einheit-Nr> [<Einheit-Nr> ..] */
#define SHIPSPELL (1<<6) /* ZAUBER .. <Schiff-Nr> [<Schiff-Nr> ..] */ #define SHIPSPELL (1<<6) /* ZAUBER .. <Schiff-Nr> [<Schiff-Nr> ..] */
#define BUILDINGSPELL (1<<7) /* ZAUBER .. <Gebaeude-Nr> [<Gebaeude-Nr> ..] */ #define BUILDINGSPELL (1<<7) /* ZAUBER .. <Gebaeude-Nr> [<Gebaeude-Nr> ..] */
#define REGIONSPELL (1<<8) /* wirkt auf struct region */ #define REGIONSPELL (1<<8) /* wirkt auf struct region */
#define GLOBALTARGET (1<<9) /* Ziel kann ausserhalb der region sein */ #define GLOBALTARGET (1<<9) /* Ziel kann ausserhalb der region sein */
#define PRECOMBATSPELL (1<<10) /* PRÄKAMPFZAUBER .. */ #define PRECOMBATSPELL (1<<10) /* PRÄKAMPFZAUBER .. */
#define COMBATSPELL (1<<11) /* KAMPFZAUBER .. */ #define COMBATSPELL (1<<11) /* KAMPFZAUBER .. */
#define POSTCOMBATSPELL (1<<12) /* POSTKAMPFZAUBER .. */ #define POSTCOMBATSPELL (1<<12) /* POSTKAMPFZAUBER .. */
#define ISCOMBATSPELL (PRECOMBATSPELL|COMBATSPELL|POSTCOMBATSPELL) #define ISCOMBATSPELL (PRECOMBATSPELL|COMBATSPELL|POSTCOMBATSPELL)
#define TESTRESISTANCE (1<<13) /* Zielobjekte auf Magieresistenz prüfen. not used in XML? */ #define TESTRESISTANCE (1<<13) /* Zielobjekte auf Magieresistenz pruefen. not used in XML? */
#define NOTFAMILIARCAST (1<<14) /* not used by XML? */ #define NOTFAMILIARCAST (1<<14) /* not used by XML? */
#define ANYTARGET (UNITSPELL|REGIONSPELL|BUILDINGSPELL|SHIPSPELL) /* wirkt auf alle objekttypen (unit, ship, building, region) */ #define ANYTARGET (UNITSPELL|REGIONSPELL|BUILDINGSPELL|SHIPSPELL) /* wirkt auf alle objekttypen (unit, ship, building, region) */
@ -167,7 +167,7 @@ extern "C" {
enum { enum {
SPC_FIX, /* Fixkosten */ SPC_FIX, /* Fixkosten */
SPC_LEVEL, /* Komponenten pro Level */ SPC_LEVEL, /* Komponenten pro Level */
SPC_LINEAR /* Komponenten pro Level und müssen vorhanden sein */ SPC_LINEAR /* Komponenten pro Level und muessen vorhanden sein */
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -192,8 +192,8 @@ extern "C" {
* *
* Spruchzauberrei und Gegenstandszauberrei werden getrennt behandelt. * Spruchzauberrei und Gegenstandszauberrei werden getrennt behandelt.
* Das macht u.a. bestimmte Fehlermeldungen einfacher, das * Das macht u.a. bestimmte Fehlermeldungen einfacher, das
* identifizieren der Komponennten über den Missversuch ist nicht * identifizieren der Komponennten ueber den Missversuch ist nicht
* möglich * moeglich
* Spruchzauberrei: 'ZAUBER [struct region x y] [STUFE a] "Spruchname" [Ziel]' * Spruchzauberrei: 'ZAUBER [struct region x y] [STUFE a] "Spruchname" [Ziel]'
* Gegenstandszauberrei: 'BENUTZE "Gegenstand" [Ziel]' * Gegenstandszauberrei: 'BENUTZE "Gegenstand" [Ziel]'
* *
@ -222,46 +222,46 @@ extern "C" {
bool is_familiar(const struct unit *u); bool is_familiar(const struct unit *u);
/* gibt true, wenn eine Familiar-Relation besteht. */ /* gibt true, wenn eine Familiar-Relation besteht. */
/* Sprüche */ /* Sprueche */
int get_combatspelllevel(const struct unit *u, int nr); int get_combatspelllevel(const struct unit *u, int nr);
/* versucht, eine eingestellte maximale Kampfzauberstufe /* versucht, eine eingestellte maximale Kampfzauberstufe
* zurückzugeben. 0 = Maximum, -1 u ist kein Magier. */ * zurueckzugeben. 0 = Maximum, -1 u ist kein Magier. */
const struct spell *get_combatspell(const struct unit *u, int nr); const struct spell *get_combatspell(const struct unit *u, int nr);
/* gibt den Kampfzauber nr [pre/kampf/post] oder NULL zurück */ /* gibt den Kampfzauber nr [pre/kampf/post] oder NULL zurueck */
void set_combatspell(struct unit *u, struct spell * sp, struct order *ord, void set_combatspell(struct unit *u, struct spell * sp, struct order *ord,
int level); int level);
/* setzt Kampfzauber */ /* setzt Kampfzauber */
void unset_combatspell(struct unit *u, struct spell * sp); void unset_combatspell(struct unit *u, struct spell * sp);
/* löscht Kampfzauber */ /* loescht Kampfzauber */
/* fügt den Spruch mit der Id spellid der Spruchliste der Einheit hinzu. */ /* fuegt den Spruch mit der Id spellid der Spruchliste der Einheit hinzu. */
int u_hasspell(const struct unit *u, const struct spell *sp); int u_hasspell(const struct unit *u, const struct spell *sp);
/* prüft, ob der Spruch in der Spruchliste der Einheit steht. */ /* prueft, ob der Spruch in der Spruchliste der Einheit steht. */
void pick_random_spells(struct faction *f, int level, struct spellbook * book, int num_spells); void pick_random_spells(struct faction *f, int level, struct spellbook * book, int num_spells);
bool knowsspell(const struct region *r, const struct unit *u, bool knowsspell(const struct region *r, const struct unit *u,
const struct spell * sp); const struct spell * sp);
/* prüft, ob die Einheit diesen Spruch gerade beherrscht, dh /* prueft, ob die Einheit diesen Spruch gerade beherrscht, dh
* mindestens die erforderliche Stufe hat. Hier können auch Abfragen * mindestens die erforderliche Stufe hat. Hier koennen auch Abfragen
* auf spezielle Antimagiezauber auf Regionen oder Einheiten eingefügt * auf spezielle Antimagiezauber auf Regionen oder Einheiten eingefuegt
* werden * werden
*/ */
/* Magiepunkte */ /* Magiepunkte */
int get_spellpoints(const struct unit *u); int get_spellpoints(const struct unit *u);
/* Gibt die aktuelle Anzahl der Magiepunkte der Einheit zurück */ /* Gibt die aktuelle Anzahl der Magiepunkte der Einheit zurueck */
void set_spellpoints(struct unit *u, int sp); void set_spellpoints(struct unit *u, int sp);
/* setzt die Magiepunkte auf sp */ /* setzt die Magiepunkte auf sp */
int change_spellpoints(struct unit *u, int mp); int change_spellpoints(struct unit *u, int mp);
/* verändert die Anzahl der Magiepunkte der Einheit um +mp */ /* veraendert die Anzahl der Magiepunkte der Einheit um +mp */
int max_spellpoints_depr(const struct region *r, const struct unit *u); int max_spellpoints_depr(const struct region *r, const struct unit *u);
int max_spellpoints(const struct unit *u, const struct region *r); int max_spellpoints(const struct unit *u, const struct region *r);
/* gibt die aktuell maximal möglichen Magiepunkte der Einheit zurück */ /* gibt die aktuell maximal moeglichen Magiepunkte der Einheit zurueck */
int change_maxspellpoints(struct unit *u, int csp); int change_maxspellpoints(struct unit *u, int csp);
/* verändert die maximalen Magiepunkte einer Einheit */ /* veraendert die maximalen Magiepunkte einer Einheit */
/* Zaubern */ /* Zaubern */
extern double spellpower(struct region *r, struct unit *u, const struct spell * sp, extern double spellpower(struct region *r, struct unit *u, const struct spell * sp,
int cast_level, struct order *ord); int cast_level, struct order *ord);
/* ermittelt die Stärke eines Spruchs */ /* ermittelt die Staerke eines Spruchs */
bool fumble(struct region *r, struct unit *u, const struct spell * sp, bool fumble(struct region *r, struct unit *u, const struct spell * sp,
int cast_level); int cast_level);
/* true, wenn der Zauber misslingt, bei false gelingt der Zauber */ /* true, wenn der Zauber misslingt, bei false gelingt der Zauber */
@ -275,51 +275,51 @@ extern "C" {
struct unit * familiar, const struct spell * sp, struct region * r, struct unit * familiar, const struct spell * sp, struct region * r,
int lev, double force, int range, struct order * ord, struct spellparameter * p); int lev, double force, int range, struct order * ord, struct spellparameter * p);
void free_castorder(struct castorder *co); void free_castorder(struct castorder *co);
/* Zwischenspreicher für Zauberbefehle, notwendig für Prioritäten */ /* Zwischenspreicher fuer Zauberbefehle, notwendig für Prioritaeten */
void add_castorder(struct spellrank *cll, struct castorder *co); void add_castorder(struct spellrank *cll, struct castorder *co);
/* Hänge c-order co an die letze c-order von cll an */ /* Haenge c-order co an die letze c-order von cll an */
void free_castorders(struct castorder *co); void free_castorders(struct castorder *co);
/* Speicher wieder freigeben */ /* Speicher wieder freigeben */
int cast_spell(struct castorder *co); int cast_spell(struct castorder *co);
/* Prüfroutinen für Zaubern */ /* Pruefroutinen für Zaubern */
int countspells(struct unit *u, int step); int countspells(struct unit *u, int step);
int spellcount(const struct unit *u); int spellcount(const struct unit *u);
/* erhöht den Counter für Zaubersprüche um 'step' und gibt die neue /* erhoeht den Counter fuer Zaubersprüche um 'step' und gibt die neue
* Anzahl der gezauberten Sprüche zurück. */ * Anzahl der gezauberten Sprueche zurück. */
int auracost(const struct unit *caster, const struct spell *sp); int auracost(const struct unit *caster, const struct spell *sp);
int spellcost(const struct unit *caster, const struct spell_component *spc); int spellcost(const struct unit *caster, const struct spell_component *spc);
/* gibt die für diesen Spruch derzeit notwendigen Magiepunkte auf der /* gibt die fuer diesen Spruch derzeit notwendigen Magiepunkte auf der
* geringstmöglichen Stufe zurück, schon um den Faktor der bereits * geringstmoeglichen Stufe zurueck, schon um den Faktor der bereits
* zuvor gezauberten Sprüche erhöht */ * zuvor gezauberten Sprueche erhoeht */
bool cancast(struct unit *u, const struct spell * spruch, int eff_stufe, bool cancast(struct unit *u, const struct spell * spruch, int eff_stufe,
int distance, struct order *ord); int distance, struct order *ord);
/* true, wenn Einheit alle Komponenten des Zaubers (incl. MP) für die /* true, wenn Einheit alle Komponenten des Zaubers (incl. MP) fuer die
* geringstmögliche Stufe hat und den Spruch beherrscht */ * geringstmoegliche Stufe hat und den Spruch beherrscht */
void pay_spell(struct unit *mage, const struct unit *caster, const struct spell * sp, int eff_stufe, int distance); void pay_spell(struct unit *mage, const struct unit *caster, const struct spell * sp, int eff_stufe, int distance);
/* zieht die Komponenten des Zaubers aus dem Inventory der Einheit /* zieht die Komponenten des Zaubers aus dem Inventory der Einheit
* ab. Die effektive Stufe des gezauberten Spruchs ist wichtig für * ab. Die effektive Stufe des gezauberten Spruchs ist wichtig fuer
* die korrekte Bestimmung der Magiepunktkosten */ * die korrekte Bestimmung der Magiepunktkosten */
int eff_spelllevel(struct unit *mage, struct unit *caster, int eff_spelllevel(struct unit *mage, struct unit *caster,
const struct spell * sp, int cast_level, int distance); const struct spell * sp, int cast_level, int distance);
/* ermittelt die effektive Stufe des Zaubers. Dabei ist cast_level /* ermittelt die effektive Stufe des Zaubers. Dabei ist cast_level
* die gewünschte maximale Stufe (im Normalfall Stufe des Magiers, * die gewuenschte maximale Stufe (im Normalfall Stufe des Magiers,
* bei Farcasting Stufe*2^Entfernung) */ * bei Farcasting Stufe*2^Entfernung) */
bool is_magic_resistant(struct unit *magician, struct unit *target, int bool is_magic_resistant(struct unit *magician, struct unit *target, int
resist_bonus); resist_bonus);
/* Mapperfunktion für target_resists_magic() vom Typ struct unit. */ /* Mapperfunktion fuer target_resists_magic() vom Typ struct unit. */
variant magic_resistance(struct unit *target); variant magic_resistance(struct unit *target);
/* gibt die Chance an, mit der einem Zauber widerstanden wird. Je /* gibt die Chance an, mit der einem Zauber widerstanden wird. Je
* größer, desto resistenter ist da Opfer */ * groesser, desto resistenter ist da Opfer */
bool target_resists_magic(struct unit *magician, void *obj, int objtyp, bool target_resists_magic(struct unit *magician, void *obj, int objtyp,
int resist_bonus); int resist_bonus);
/* gibt false zurück, wenn der Zauber gelingt, true, wenn das Ziel /* gibt false zurueck, wenn der Zauber gelingt, true, wenn das Ziel
* widersteht */ * widersteht */
extern struct spell * unit_getspell(struct unit *u, const char *s, extern struct spell * unit_getspell(struct unit *u, const char *s,
const struct locale *lang); const struct locale *lang);
const char *magic_name(magic_t mtype, const struct locale *lang); const char *magic_name(magic_t mtype, const struct locale *lang);
/* Sprüche in der struct region */ /* Sprueche in der struct region */
/* (sind in curse) */ /* (sind in curse) */
void set_familiar(struct unit * mage, struct unit * familiar); void set_familiar(struct unit * mage, struct unit * familiar);
struct unit *get_familiar(const struct unit *u); struct unit *get_familiar(const struct unit *u);

10
src/modules/museum.c
View File

@ -141,7 +141,7 @@ order * ord)
UNUSED_ARG(amount); UNUSED_ARG(amount);
/* Prüfen ob in Eingangshalle */ /* Pruefen ob in Eingangshalle */
if (u->region->x != 9525 || u->region->y != 9525) { if (u->region->x != 9525 || u->region->y != 9525) {
cmistake(u, ord, 266, MSG_MAGIC); cmistake(u, ord, 266, MSG_MAGIC);
return 0; return 0;
@ -152,7 +152,7 @@ order * ord)
r = findregion(a->data.sa[0], a->data.sa[1]); r = findregion(a->data.sa[0], a->data.sa[1]);
assert(r); assert(r);
a_remove(&u->attribs, a); a_remove(&u->attribs, a);
/* Ãœbergebene Gegenstände zurückgeben */ /* Übergebene Gegenstände zurückgeben */
a = a_find(u->attribs, &at_museumgivebackcookie); a = a_find(u->attribs, &at_museumgivebackcookie);
if (a) { if (a) {
@ -177,7 +177,7 @@ order * ord)
} }
} }
/* Benutzer zurück teleportieren */ /* Benutzer zurueck teleportieren */
move_unit(u, r, NULL); move_unit(u, r, NULL);
/* Exitticket abziehen */ /* Exitticket abziehen */
@ -210,8 +210,8 @@ order * ord)
return 0; return 0;
} }
/* In diesem Attribut merken wir uns, wohin die Einheit zurückgesetzt /* In diesem Attribut merken wir uns, wohin die Einheit zurueckgesetzt
* wird, wenn sie das Museum verläßt. */ * wird, wenn sie das Museum verlaesst. */
a = a_add(&u->attribs, a_new(&at_museumexit)); a = a_add(&u->attribs, a_new(&at_museumexit));
a->data.sa[0] = (short)r->x; a->data.sa[0] = (short)r->x;

4
src/move.h
View File

@ -46,11 +46,11 @@ extern "C" {
#define BP_NORMAL 3 #define BP_NORMAL 3
#define BP_ROAD 2 #define BP_ROAD 2
/* die Zahlen sind genau äquivalent zu den race Flags */ /* die Zahlen sind genau aequivalent zu den race Flags */
#define MV_CANNOTMOVE (1<<5) #define MV_CANNOTMOVE (1<<5)
#define MV_FLY (1<<7) /* kann fliegen */ #define MV_FLY (1<<7) /* kann fliegen */
#define MV_SWIM (1<<8) /* kann schwimmen */ #define MV_SWIM (1<<8) /* kann schwimmen */
#define MV_WALK (1<<9) /* kann über Land gehen */ #define MV_WALK (1<<9) /* kann ueber Land gehen */
#define HORSES_PER_CART 2 /* number of horses for a cart */ #define HORSES_PER_CART 2 /* number of horses for a cart */
#define STRENGTHMULTIPLIER 50 /* multiplier for trollbelt */ #define STRENGTHMULTIPLIER 50 /* multiplier for trollbelt */

4
src/piracy.c
View File

@ -140,7 +140,7 @@ void piracy_cmd(unit * u)
if (target_dir == NODIRECTION) { if (target_dir == NODIRECTION) {
int saff = 0; int saff = 0;
direction_t dir; direction_t dir;
/* Einheit ist also Kapitän. Jetzt gucken, in wievielen /* Einheit ist also Kapitaen. Jetzt gucken, in wievielen
* Nachbarregionen potentielle Opfer sind. */ * Nachbarregionen potentielle Opfer sind. */
for (dir = 0; dir < MAXDIRECTIONS; dir++) { for (dir = 0; dir < MAXDIRECTIONS; dir++) {
@ -205,7 +205,7 @@ void piracy_cmd(unit * u)
/* FIXME: when u->thisorder == ord, set_order calls free, destroys both. */ /* FIXME: when u->thisorder == ord, set_order calls free, destroys both. */
ord = create_order(K_MOVE, u->faction->locale, "%s", LOC(u->faction->locale, directions[target_dir])); ord = create_order(K_MOVE, u->faction->locale, "%s", LOC(u->faction->locale, directions[target_dir]));
/* Bewegung ausführen */ /* Bewegung ausfuehren */
init_order_depr(ord); init_order_depr(ord);
move_cmd(u, ord); move_cmd(u, ord);
free_order(ord); free_order(ord);

2
src/reports.c
View File

@ -409,7 +409,7 @@ void report_raceinfo(const struct race *rc, const struct locale *lang, struct sb
sbs_strcat(sbp, ": "); sbs_strcat(sbp, ": ");
sbs_strcat(sbp, str_itoa(rc->df_default + rc->df_bonus)); sbs_strcat(sbp, str_itoa(rc->df_default + rc->df_bonus));
/* b_armor : Rüstung */ /* b_armor : Ruestung */
if (rc->armor > 0) { if (rc->armor > 0) {
sbs_strcat(sbp, ", "); sbs_strcat(sbp, ", ");
sbs_strcat(sbp, LOC(lang, "stat_armor")); sbs_strcat(sbp, LOC(lang, "stat_armor"));

4
src/spells/borders.h
View File

@ -9,8 +9,8 @@ extern "C" {
extern void register_borders(void); extern void register_borders(void);
/* für Feuerwände: in movement muß das noch explizit getestet werden. /* fuer Feuerwaende: in movement muss das noch explizit getestet werden.
** besser wäre eine blcok_type::move() routine, die den effekt ** besser waere eine blcok_type::move() routine, die den effekt
** der Bewegung auf eine struct unit anwendet. ** der Bewegung auf eine struct unit anwendet.
**/ **/
extern struct border_type bt_chaosgate; extern struct border_type bt_chaosgate;

2
src/spells/buildingcurse.c
View File

@ -80,7 +80,7 @@ const struct curse_type ct_magicwalls = { "magicwalls",
CURSETYP_NORM, CURSE_ONLYONE|CURSE_NOAGE, NO_MERGE, cinfo_building CURSETYP_NORM, CURSE_ONLYONE|CURSE_NOAGE, NO_MERGE, cinfo_building
}; };
/* Feste Mauer - Präkampfzauber, wirkt nur 1 Runde */ /* Feste Mauer - Praekampfzauber, wirkt nur 1 Runde */
const struct curse_type ct_strongwall = { "strongwall", const struct curse_type ct_strongwall = { "strongwall",
CURSETYP_NORM, 0, NO_MERGE, NULL CURSETYP_NORM, 0, NO_MERGE, NULL
}; };

14
src/spells/regioncurse.c
View File

@ -87,7 +87,7 @@ const struct curse_type ct_gbdream = {
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
/* /*
* C_MAGICSTREET * C_MAGICSTREET
* erzeugt Straßennetz * erzeugt Strassennetz
*/ */
static message *cinfo_magicstreet(const void *obj, objtype_t typ, const curse * c, static message *cinfo_magicstreet(const void *obj, objtype_t typ, const curse * c,
int self) int self)
@ -97,7 +97,7 @@ static message *cinfo_magicstreet(const void *obj, objtype_t typ, const curse *
UNUSED_ARG(obj); UNUSED_ARG(obj);
assert(typ == TYP_REGION); assert(typ == TYP_REGION);
/* Warnung vor Auflösung */ /* Warnung vor Aufloesung */
if (c->duration >= 2) { if (c->duration >= 2) {
return msg_message("curseinfo::magicstreet", "id", c->no); return msg_message("curseinfo::magicstreet", "id", c->no);
} }
@ -120,7 +120,7 @@ static message *cinfo_antimagiczone(const void *obj, objtype_t typ, const curse
UNUSED_ARG(obj); UNUSED_ARG(obj);
assert(typ == TYP_REGION); assert(typ == TYP_REGION);
/* Magier spüren eine Antimagiezone */ /* Magier spueren eine Antimagiezone */
if (self != 0) { if (self != 0) {
return msg_message("curseinfo::antimagiczone", "id", c->no); return msg_message("curseinfo::antimagiczone", "id", c->no);
} }
@ -128,7 +128,7 @@ static message *cinfo_antimagiczone(const void *obj, objtype_t typ, const curse
return NULL; return NULL;
} }
/* alle Magier können eine Antimagiezone wahrnehmen */ /* alle Magier koennen eine Antimagiezone wahrnehmen */
static int static int
cansee_antimagiczone(const struct faction *viewer, const void *obj, objtype_t typ, cansee_antimagiczone(const struct faction *viewer, const void *obj, objtype_t typ,
const curse * c, int self) const curse * c, int self)
@ -170,7 +170,7 @@ static message *cinfo_farvision(const void *obj, objtype_t typ, const curse * c,
assert(typ == TYP_REGION); assert(typ == TYP_REGION);
/* Magier spüren eine farvision */ /* Magier spueren eine farvision */
if (self != 0) { if (self != 0) {
return msg_message("curseinfo::farvision", "id", c->no); return msg_message("curseinfo::farvision", "id", c->no);
} }
@ -232,7 +232,7 @@ const struct curse_type ct_badlearn = {
cinfo_simple cinfo_simple
}; };
/* Trübsal-Zauber */ /* Truebsal-Zauber */
const struct curse_type ct_depression = { const struct curse_type ct_depression = {
"depression", "depression",
CURSETYP_NORM, 0, (M_DURATION | M_VIGOUR), CURSETYP_NORM, 0, (M_DURATION | M_VIGOUR),
@ -268,7 +268,7 @@ const struct curse_type ct_badmagicresistancezone = {
cinfo_simple cinfo_simple
}; };
/* erhöht Magieresistenz von aliierten Einheiten, wirkt nur 1x pro /* erhoeht Magieresistenz von aliierten Einheiten, wirkt nur 1x pro
* Einheit */ * Einheit */
const struct curse_type ct_goodmagicresistancezone = { const struct curse_type ct_goodmagicresistancezone = {
"goodmagicresistancezone", "goodmagicresistancezone",

2
src/spells/unitcurse.c
View File

@ -42,7 +42,7 @@
/* /*
* C_AURA * C_AURA
*/ */
/* erhöht/senkt regeneration und maxaura um effect% */ /* erhoeht/senkt regeneration und maxaura um effect% */
static message *cinfo_auraboost(const void *obj, objtype_t typ, const curse * c, static message *cinfo_auraboost(const void *obj, objtype_t typ, const curse * c,
int self) int self)
{ {

2
src/tools/namegen.c
View File

@ -125,7 +125,7 @@ static char *entish_syllable2[] = {
}; };
static char *entish_syllable3[] = { static char *entish_syllable3[] = {
"Hüter", "Pflanzer", "Hirte", "Wächter", "Wachser", "Beschützer", "Hueter", "Pflanzer", "Hirte", "Waechter", "Wachser", "Beschützer",
}; };
static char *cthuloid_syllable1[] = { static char *cthuloid_syllable1[] = {