diff --git a/src/.report.c.swp b/src/.report.c.swp new file mode 100644 index 000000000..c7bb683f3 Binary files /dev/null and b/src/.report.c.swp differ diff --git a/src/attributes/attributes.c b/src/attributes/attributes.c index 12cb9131f..d0be86b0e 100644 --- a/src/attributes/attributes.c +++ b/src/attributes/attributes.c @@ -169,7 +169,7 @@ static int read_ext(variant *var, void *owner, gamedata *data) 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_familiar); at_register(&at_familiarmage); diff --git a/src/direction.c b/src/direction.c index 13feff13b..ba3320b14 100644 --- a/src/direction.c +++ b/src/direction.c @@ -25,8 +25,8 @@ void init_direction(const struct locale *lang, direction_t dir, const char *str) } void init_directions(struct locale *lang) { - /* mit dieser routine kann man mehrere namen für eine direction geben, - * das ist für die hexes ideal. */ + /* mit dieser routine kann man mehrere namen fuer eine direction geben, + * das ist fuer die hexes ideal. */ const struct { const char *name; direction_t direction; diff --git a/src/kernel/curse.c b/src/kernel/curse.c index d6d77a7ea..945f60e7a 100644 --- a/src/kernel/curse.c +++ b/src/kernel/curse.c @@ -333,8 +333,8 @@ void ct_checknames(void) { } /* ------------------------------------------------------------- */ -/* get_curse identifiziert eine Verzauberung über die ID und gibt - * einen pointer auf die struct zurück. +/* get_curse identifiziert eine Verzauberung ueber die ID und gibt + * einen pointer auf die struct zurueck. */ 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; } -/* 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 * damit der gegen Antimagie wirkende Widerstand einer Verzauberung */ static double get_cursevigour(const curse * c) @@ -395,15 +395,15 @@ static double get_cursevigour(const curse * c) 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) { assert(c && vigour > 0); c->vigour = vigour; } -/* verändert 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 +/* veraendert die Stärke der Verzauberung um +i und gibt die neue + * Staerke zurueck. Sollte die Zauberstärke unter Null sinken, loest er * sich auf. */ 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 - * betroffenen Personen zurück. Ansonsten wird 0 zurückgegeben. */ +/* gibt bei Personenbeschraenkten Verzauberungen die Anzahl der + * betroffenen Personen zurueck. Ansonsten wird 0 zurückgegeben. */ int get_cursedmen(const unit * u, const curse * c) { int cursedmen = u->number; @@ -502,7 +502,7 @@ static int newcurseid(void) { /* ------------------------------------------------------------- */ /* 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, 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; } -/* 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. */ 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, - * berücksichtigt werden */ +/* hier muessen alle c-typen, die auf Einheiten gezaubert werden koennen, + * beruecksichtigt werden */ 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 -* aufgelöst, bzw seine Kraft (vigour) auf 0 gesetzt. +/* Wenn der Curse schwaecher ist als der cast_level, dann wird er +* aufgeloest, bzw seine Kraft (vigour) auf 0 gesetzt. * Ist der cast_level zu gering, hat die Antimagie nur mit einer Chance * von 100-20*Stufenunterschied % eine Wirkung auf den Curse. Dann wird -* die Kraft des Curse um die halbe Stärke der Antimagie reduziert. -* Zurückgegeben wird der noch unverbrauchte Rest von force. +* die Kraft des Curse um die halbe Staerke der Antimagie reduziert. +* Zurueckgegeben wird der noch unverbrauchte Rest von 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? */ force -= c->vigour; if (c->type->change_vigour) { diff --git a/src/kernel/curse.h b/src/kernel/curse.h index 36ace2895..53e189be9 100644 --- a/src/kernel/curse.h +++ b/src/kernel/curse.h @@ -39,37 +39,37 @@ extern "C" { * (struct attribute) */ - /* Brainstorming Überarbeitung curse + /* Brainstorming Ãœberarbeitung curse * * Ziel: Keine Enum-Liste, flexible, leicht erweiterbare Curse-Objekte * * Was wird gebraucht? - * - Eindeutige Kennung für globale Suche - * - eine Wirkung, die sich einfach 'anwenden' läßt, dabei flexibel ist, - * Raum läßt für variable Boni, Anzahl betroffener Personen, + * - Eindeutige Kennung fuer globale Suche + * - eine Wirkung, die sich einfach 'anwenden' laesst, dabei flexibel ist, + * Raum laesst fuer variable Boni, Anzahl betroffener Personen, * spezielle Effekte oder anderes * - einfacher Zugriff auf allgemeine Funktionen wie zb Alterung, aber * auch Antimagieverhalten * - Ausgabe von Beschreibungen in verschiedenen Sprachen * - definiertes gekapseltes Verhalten zb bei Zusammenlegung von - * Einheiten, Übergabe von Personen, Mehrfachverzauberung - * - (Rück-)Referenzen auf Objekt, Verursacher (Magier), ? + * Einheiten, Ãœbergabe von Personen, Mehrfachverzauberung + * - (Rueck-)Referenzen auf Objekt, Verursacher (Magier), ? * - * Vieleicht wäre ein Wirkungsklassensystem sinnvoll, so das im übrigen - * source einfach alle curse-attribs abgefragt werden können und bei - * gewünschter Wirkungsklasse angewendet, also nicht für jeden curse - * spezielle Änderungen im übrigen source notwendig sind. + * Vieleicht waere ein Wirkungsklassensystem sinnvoll, so das im uebrigen + * source einfach alle curse-attribs abgefragt werden koennen und bei + * gewuenschter Wirkungsklasse angewendet, also nicht für jeden curse + * spezielle Änderungen im uebrigen source notwendig sind. * * 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? * - Referenzen auf Objekt und Verursacher - * - Referenzen für globale Liste + * - Referenzen fuer globale Liste * > die Wirkung: * - Dauer * - Widerstandskraft, zb gegen Antimagie - * - Seiteneffekte zb Flag ONLYONE, Unverträglichkeiten + * - Seiteneffekte zb Flag ONLYONE, Unvertraeglichkeiten * - Alterungsverhalten zb Flag NOAGE * - Effektverhalten, zb Bonus (variabel) * - bei Einheitenzaubern die Zahl der betroffenen Personen @@ -77,16 +77,16 @@ extern "C" { * Dabei sind nur die beiden letzten Punkte wirklich reine individuelle * Wirkung, die anderen sind eher allgemeine Kennzeichen eines jeden * 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 * Typeigenschaft als die eines individuellen curse. - * Dagegen ist der Widerstand gegen Antimagie sowohl abhängig von der - * Güte des Verursachers, also des Magiers zum Zeitpunkt des Zaubers, + * Dagegen ist der Widerstand gegen Antimagie sowohl abhaengig von der + * Guete des Verursachers, also des Magiers zum Zeitpunkt des Zaubers, * als auch vom Typ, der gegen bestimmte Arten des 'Fluchbrechens' immun - * sein könnte. + * sein koennte. * * Was sind wichtige Typeigenschaften? - * - Verhalten bei Personenübergaben + * - Verhalten bei Personenuebergaben * - allgemeine Wirkung * - Beschreibungstexte * - Verhalten bei Antimagie @@ -94,8 +94,8 @@ extern "C" { * - Speicherung des C-Objekts * - Laden des C-Objekts * - Erzeugen des C-Objekts - * - Löschen und Aufräumen des C-Objekts - * - Funktionen zur Änderung der Werte + * - Loeschen und Aufraeumen des C-Objekts + * - Funktionen zur Änderung der Werte * * */ @@ -118,17 +118,17 @@ extern "C" { C_BADLEARN, C_SHIP_SPEEDUP, /* 9 - Sturmwind-Zauber */ C_SHIP_FLYING, /* 10 - Luftschiff-Zauber */ - C_SHIP_NODRIFT, /* 11 - GünstigeWinde-Zauber */ + C_SHIP_NODRIFT, /* 11 - GuenstigeWinde-Zauber */ C_DEPRESSION, C_MAGICWALLS, /* 13 - Heimstein */ C_STRONGWALL, /* 14 - Feste Mauer - Precombat */ C_ASTRALBLOCK, /* 15 - Astralblock */ C_GENEROUS, /* 16 - Unterhaltung vermehren */ C_PEACE, /* 17 - Regionsweit Attacken verhindern */ - C_MAGICSTREET, /* 19 - magisches Straßennetz */ - C_RESIST_MAGIC, /* 20 - verändert Magieresistenz von Objekten */ - C_SONG_BADMR, /* 21 - verändert Magieresistenz */ - C_SONG_GOODMR, /* 22 - verändert Magieresistenz */ + C_MAGICSTREET, /* 19 - magisches Strassennetz */ + C_RESIST_MAGIC, /* 20 - veraendert Magieresistenz von Objekten */ + C_SONG_BADMR, /* 21 - veraendert Magieresistenz */ + C_SONG_GOODMR, /* 22 - veraendert Magieresistenz */ C_SLAVE, /* 23 - dient fremder Partei */ C_CALM, /* 25 - Beinflussung */ C_OLDRACE, @@ -145,7 +145,7 @@ extern "C" { /* ------------------------------------------------------------- */ /* Flags */ - /* Verhalten von Zaubern auf Units beim Übergeben von Personen */ + /* Verhalten von Zaubern auf Units beim Ãœbergeben von Personen */ typedef enum { CURSE_ISNEW = 0x01, /* wirkt in der zauberrunde nicht (default) */ 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 */ /* the following are mutually exclusive */ - CURSE_SPREADNEVER = 0x00, /* wird nie mit übertragen */ - CURSE_SPREADALWAYS = 0x10, /* wird immer mit übertragen */ + CURSE_SPREADNEVER = 0x00, /* wird nie mit uebertragen */ + CURSE_SPREADALWAYS = 0x10, /* wird immer mit uebertragen */ CURSE_SPREADMODULO = 0x20, /* personenweise weitergabe */ - CURSE_SPREADCHANCE = 0x30 /* Ansteckungschance je nach Mengenverhältnis */ + CURSE_SPREADCHANCE = 0x30 /* Ansteckungschance je nach Mengenverhaeltnis */ } curseflags; #define CURSE_FLAGSMASK 0x0F @@ -180,8 +180,8 @@ extern "C" { #define M_SUMEFFECT 8 /* der Effekt summiert sich */ #define M_MEN 16 /* die Anzahl der betroffenen Personen summiert sich */ -#define M_VIGOUR 32 /* das Maximum der beiden Stärken wird die - Stärke des neuen Zaubers */ +#define M_VIGOUR 32 /* das Maximum der beiden Staerken wird die + Staerke des neuen Zaubers */ #define M_VIGOUR_ADD 64 /* Vigour wird addiert */ /* ------------------------------------------------------------- */ @@ -212,7 +212,7 @@ extern "C" { struct curse *nexthash; const curse_type *type; /* Zeiger auf ein curse_type-struct */ 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; int no; /* 'Einheitennummer' dieses Curse */ int mask; /* This is XORed with type->flags, see c_flags()! */ @@ -251,35 +251,35 @@ extern "C" { /* ignoriert CURSE_ISNEW */ 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); - /* gibt die Auswirkungen der Verzauberungen zurück. zB bei + /* gibt die Auswirkungen der Verzauberungen zurueck. zB bei * Skillmodifiziernden Verzauberungen ist hier der Modifizierer * 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); 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); - /* gibt bei Personenbeschränkten Verzauberungen die Anzahl der - * betroffenen Personen zurück. Ansonsten wird 0 zurückgegeben. */ + /* gibt bei Personenbeschraenkten Verzauberungen die Anzahl der + * betroffenen Personen zurueck. Ansonsten wird 0 zurückgegeben. */ int get_cursedmen(const struct unit *u, const struct curse *c); /* setzt/loescht Spezialflag einer Verzauberung (zB 'dauert ewig') */ void c_setflag(curse * c, unsigned int flag); 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 - * unterschiedlich gewünscht sein + * unterschiedlich gewuenscht sein * */ 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 * */ struct curse *get_curse(struct attrib *ap, const curse_type * ctype); diff --git a/src/kernel/plane.h b/src/kernel/plane.h index faa663a36..bfaaa5dda 100644 --- a/src/kernel/plane.h +++ b/src/kernel/plane.h @@ -32,14 +32,14 @@ extern "C" { #define PFL_NORECRUITS 2 /* cannot recruit */ #define PFL_NOALLIANCES 4 /* not implemented */ #define PFL_LOWSTEALING 8 /* not implemented */ -#define PFL_NOGIVE 16 /* Übergaben sind unmöglich */ -#define PFL_NOATTACK 32 /* Angriffe und Diebstähle sind unmöglich */ +#define PFL_NOGIVE 16 /* Ãœbergaben sind unmoeglich */ +#define PFL_NOATTACK 32 /* Angriffe und Diebstaehle sind unmoeglich */ #define PFL_NOTERRAIN 64 /* Terraintyp wird nicht angezeigt TODO? */ -#define PFL_NOMAGIC 128 /* Zaubern ist unmöglich */ -#define PFL_NOSTEALTH 256 /* Tarnung außer Betrieb */ -#define PFL_NOTEACH 512 /* Lehre außer Betrieb */ -#define PFL_NOBUILD 1024 /* Bauen außer Betrieb */ -#define PFL_NOFEED 2048 /* Kein Unterhalt nötig */ +#define PFL_NOMAGIC 128 /* Zaubern ist unmoeglich */ +#define PFL_NOSTEALTH 256 /* Tarnung ausser Betrieb */ +#define PFL_NOTEACH 512 /* Lehre ausser Betrieb */ +#define PFL_NOBUILD 1024 /* Bauen ausser Betrieb */ +#define PFL_NOFEED 2048 /* Kein Unterhalt noetig */ #define PFL_FRIENDLY 4096 /* not implemented */ #define PFL_NOORCGROWTH 8192 /* orcs don't grow */ #define PFL_NOMONSTERS 16384 /* no monster randenc */ diff --git a/src/kernel/region.c b/src/kernel/region.c index f8ce68ffd..4614f22bc 100644 --- a/src/kernel/region.c +++ b/src/kernel/region.c @@ -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 Dinge gefragt werden. */ @@ -992,7 +992,7 @@ static char *makename(void) *handle_end = "nlrdst", *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); ne = strlen(handle_end); @@ -1105,7 +1105,7 @@ void init_region(region *r) 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; rawmaterial **lrm = &r->resources; @@ -1266,7 +1266,7 @@ void terraform_region(region * r, const terrain_type * terrain) #include "curse.h" 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; if (curse_active(get_curse(r->attribs, &ct_drought))) { p /= 2; diff --git a/src/kernel/terrain.h b/src/kernel/terrain.h index d49d04054..951ff7724 100644 --- a/src/kernel/terrain.h +++ b/src/kernel/terrain.h @@ -24,10 +24,10 @@ extern "C" { #endif /* 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 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 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! */ diff --git a/src/kernel/types.h b/src/kernel/types.h index 2b014bc94..b67ee088a 100644 --- a/src/kernel/types.h +++ b/src/kernel/types.h @@ -113,7 +113,7 @@ enum { O_ADRESSEN, /* 512 */ O_BZIP2, /* 1024 - compress as bzip2 */ O_SCORE, /* 2048 - punkte anzeigen? */ - O_SHOWSKCHANGE, /* 4096 - Skillveränderungen anzeigen? */ + O_SHOWSKCHANGE, /* 4096 - Skillveraenderungen anzeigen? */ MAXOPTIONS }; diff --git a/src/kernel/unit.h b/src/kernel/unit.h index 930574629..46746e3a1 100644 --- a/src/kernel/unit.h +++ b/src/kernel/unit.h @@ -47,7 +47,7 @@ extern "C" { #define UFL_MOVED (1<<8) #define UFL_NOTMOVING (1<<9) /* Die Einheit kann sich wg. langen Kampfes nicht bewegen */ #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_WERE (1<<14) #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 */ #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_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_FOLLOWED (1<<21) #define UFL_NOAID (1<<22) /* Einheit hat Noaid-Status */ #define UFL_MARK (1<<23) /* same as FL_MARK */ #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: */ #define UFL_STEALTH (1<<26) @@ -84,7 +84,7 @@ extern "C" { typedef struct unit { 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 region *region; int no; /* id */ diff --git a/src/magic.h b/src/magic.h index 4a184fe9e..6d181d73d 100644 --- a/src/magic.h +++ b/src/magic.h @@ -45,7 +45,7 @@ extern "C" { /* Spruchparameter * Wir suchen beim Parsen des Befehls erstmal nach lokalen Objekten, * 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 */ typedef enum { @@ -90,10 +90,10 @@ extern "C" { * - Magierichtung * - Magiepunkte derzeit * - Malus (neg. Wert)/ Bonus (pos. Wert) auf maximale Magiepunkte - * (können sich durch Questen absolut verändern und durch Gegenstände - * temporär). Auch für Artefakt benötigt man permanente MP - * - Anzahl bereits gezauberte Sprüche diese Runde - * - Kampfzauber (3) (vor/während/nach) + * (koennen sich durch Questen absolut veraendern und durch Gegenstände + * temporaer). Auch fuer Artefakt benoetigt man permanente MP + * - Anzahl bereits gezauberte Sprueche diese Runde + * - Kampfzauber (3) (vor/waehrend/nach) * - Spruchliste */ @@ -115,12 +115,12 @@ extern "C" { struct unit *_familiar; /* Vertrauter, gesetzt, wenn der Spruch durch den Vertrauten gezaubert wird */ const struct spell *sp; /* Spruch */ - int level; /* gewünschte Stufe oder Stufe des Magiers */ - double force; /* Stärke des Zaubers */ + int level; /* gewuenschte Stufe oder Stufe des Magiers */ + double force; /* Staerke des Zaubers */ struct region *_rtarget; /* Zielregion des Spruchs */ int distance; /* Entfernung zur Zielregion */ struct order *order; /* Befehl */ - struct spellparameter *par; /* für weitere Parameter */ + struct spellparameter *par; /* fuer weitere Parameter */ } castorder; 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 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 */ #define ONSHIPCAST (1<<3) /* kann auch auf von Land ablegenden 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, - * Gebäuden und Schiffen. */ + /* ID's koennen zu drei unterschiedlichen Entitaeten gehören: Einheiten, + * Gebaeuden und Schiffen. */ #define UNITSPELL (1<<5) /* ZAUBER .. [ ..] */ #define SHIPSPELL (1<<6) /* ZAUBER .. [ ..] */ #define BUILDINGSPELL (1<<7) /* ZAUBER .. [ ..] */ #define REGIONSPELL (1<<8) /* wirkt auf struct region */ #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 POSTCOMBATSPELL (1<<12) /* POSTKAMPFZAUBER .. */ #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 ANYTARGET (UNITSPELL|REGIONSPELL|BUILDINGSPELL|SHIPSPELL) /* wirkt auf alle objekttypen (unit, ship, building, region) */ @@ -167,7 +167,7 @@ extern "C" { enum { SPC_FIX, /* Fixkosten */ 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. * Das macht u.a. bestimmte Fehlermeldungen einfacher, das - * identifizieren der Komponennten über den Missversuch ist nicht - * möglich + * identifizieren der Komponennten ueber den Missversuch ist nicht + * moeglich * Spruchzauberrei: 'ZAUBER [struct region x y] [STUFE a] "Spruchname" [Ziel]' * Gegenstandszauberrei: 'BENUTZE "Gegenstand" [Ziel]' * @@ -222,46 +222,46 @@ extern "C" { bool is_familiar(const struct unit *u); /* gibt true, wenn eine Familiar-Relation besteht. */ - /* Sprüche */ + /* Sprueche */ int get_combatspelllevel(const struct unit *u, int nr); /* 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); - /* 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, int level); /* setzt Kampfzauber */ void unset_combatspell(struct unit *u, struct spell * sp); - /* löscht Kampfzauber */ - /* fügt den Spruch mit der Id spellid der Spruchliste der Einheit hinzu. */ + /* loescht Kampfzauber */ + /* fuegt den Spruch mit der Id spellid der Spruchliste der Einheit hinzu. */ 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); bool knowsspell(const struct region *r, const struct unit *u, const struct spell * sp); - /* prüft, ob die Einheit diesen Spruch gerade beherrscht, dh - * mindestens die erforderliche Stufe hat. Hier können auch Abfragen - * auf spezielle Antimagiezauber auf Regionen oder Einheiten eingefügt + /* prueft, ob die Einheit diesen Spruch gerade beherrscht, dh + * mindestens die erforderliche Stufe hat. Hier koennen auch Abfragen + * auf spezielle Antimagiezauber auf Regionen oder Einheiten eingefuegt * werden */ /* Magiepunkte */ 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); /* setzt die Magiepunkte auf sp */ 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(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); - /* verändert die maximalen Magiepunkte einer Einheit */ + /* veraendert die maximalen Magiepunkte einer Einheit */ /* Zaubern */ extern double spellpower(struct region *r, struct unit *u, const struct spell * sp, 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, int cast_level); /* 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, int lev, double force, int range, struct order * ord, struct spellparameter * p); 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); - /* 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); /* Speicher wieder freigeben */ int cast_spell(struct castorder *co); - /* Prüfroutinen für Zaubern */ + /* Pruefroutinen für Zaubern */ int countspells(struct unit *u, int step); int spellcount(const struct unit *u); - /* erhöht den Counter für Zaubersprüche um 'step' und gibt die neue - * Anzahl der gezauberten Sprüche zurück. */ + /* erhoeht den Counter fuer Zaubersprüche um 'step' und gibt die neue + * Anzahl der gezauberten Sprueche zurück. */ int auracost(const struct unit *caster, const struct spell *sp); int spellcost(const struct unit *caster, const struct spell_component *spc); - /* gibt die für diesen Spruch derzeit notwendigen Magiepunkte auf der - * geringstmöglichen Stufe zurück, schon um den Faktor der bereits - * zuvor gezauberten Sprüche erhöht */ + /* gibt die fuer diesen Spruch derzeit notwendigen Magiepunkte auf der + * geringstmoeglichen Stufe zurueck, schon um den Faktor der bereits + * zuvor gezauberten Sprueche erhoeht */ bool cancast(struct unit *u, const struct spell * spruch, int eff_stufe, int distance, struct order *ord); - /* true, wenn Einheit alle Komponenten des Zaubers (incl. MP) für die - * geringstmögliche Stufe hat und den Spruch beherrscht */ + /* true, wenn Einheit alle Komponenten des Zaubers (incl. MP) fuer die + * 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); /* 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 */ int eff_spelllevel(struct unit *mage, struct unit *caster, const struct spell * sp, int cast_level, int distance); /* 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) */ bool is_magic_resistant(struct unit *magician, struct unit *target, int 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); /* 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, 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 */ extern struct spell * unit_getspell(struct unit *u, const char *s, 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) */ void set_familiar(struct unit * mage, struct unit * familiar); struct unit *get_familiar(const struct unit *u); diff --git a/src/modules/museum.c b/src/modules/museum.c index 7e3a04f2d..dcb9fce2f 100644 --- a/src/modules/museum.c +++ b/src/modules/museum.c @@ -141,7 +141,7 @@ order * ord) UNUSED_ARG(amount); - /* Prüfen ob in Eingangshalle */ + /* Pruefen ob in Eingangshalle */ if (u->region->x != 9525 || u->region->y != 9525) { cmistake(u, ord, 266, MSG_MAGIC); return 0; @@ -152,7 +152,7 @@ order * ord) r = findregion(a->data.sa[0], a->data.sa[1]); assert(r); a_remove(&u->attribs, a); - /* Ãœbergebene Gegenstände zurückgeben */ + /* Übergebene Gegenstände zurückgeben */ a = a_find(u->attribs, &at_museumgivebackcookie); if (a) { @@ -177,7 +177,7 @@ order * ord) } } - /* Benutzer zurück teleportieren */ + /* Benutzer zurueck teleportieren */ move_unit(u, r, NULL); /* Exitticket abziehen */ @@ -210,8 +210,8 @@ order * ord) return 0; } - /* In diesem Attribut merken wir uns, wohin die Einheit zurückgesetzt - * wird, wenn sie das Museum verläßt. */ + /* In diesem Attribut merken wir uns, wohin die Einheit zurueckgesetzt + * wird, wenn sie das Museum verlaesst. */ a = a_add(&u->attribs, a_new(&at_museumexit)); a->data.sa[0] = (short)r->x; diff --git a/src/move.h b/src/move.h index 754b708aa..d08a8211d 100644 --- a/src/move.h +++ b/src/move.h @@ -46,11 +46,11 @@ extern "C" { #define BP_NORMAL 3 #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_FLY (1<<7) /* kann fliegen */ #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 STRENGTHMULTIPLIER 50 /* multiplier for trollbelt */ diff --git a/src/piracy.c b/src/piracy.c index b7307c070..ced1f61aa 100644 --- a/src/piracy.c +++ b/src/piracy.c @@ -140,7 +140,7 @@ void piracy_cmd(unit * u) if (target_dir == NODIRECTION) { int saff = 0; direction_t dir; - /* Einheit ist also Kapitän. Jetzt gucken, in wievielen + /* Einheit ist also Kapitaen. Jetzt gucken, in wievielen * Nachbarregionen potentielle Opfer sind. */ 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. */ 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); move_cmd(u, ord); free_order(ord); diff --git a/src/reports.c b/src/reports.c index e120c1c5a..333787663 100644 --- a/src/reports.c +++ b/src/reports.c @@ -409,7 +409,7 @@ void report_raceinfo(const struct race *rc, const struct locale *lang, struct sb sbs_strcat(sbp, ": "); sbs_strcat(sbp, str_itoa(rc->df_default + rc->df_bonus)); - /* b_armor : Rüstung */ + /* b_armor : Ruestung */ if (rc->armor > 0) { sbs_strcat(sbp, ", "); sbs_strcat(sbp, LOC(lang, "stat_armor")); diff --git a/src/spells/borders.h b/src/spells/borders.h index 40bc55682..6c9828216 100644 --- a/src/spells/borders.h +++ b/src/spells/borders.h @@ -9,8 +9,8 @@ extern "C" { extern void register_borders(void); - /* für Feuerwände: in movement muß das noch explizit getestet werden. - ** besser wäre eine blcok_type::move() routine, die den effekt + /* fuer Feuerwaende: in movement muss das noch explizit getestet werden. + ** besser waere eine blcok_type::move() routine, die den effekt ** der Bewegung auf eine struct unit anwendet. **/ extern struct border_type bt_chaosgate; diff --git a/src/spells/buildingcurse.c b/src/spells/buildingcurse.c index e1eff8988..61acfbcee 100644 --- a/src/spells/buildingcurse.c +++ b/src/spells/buildingcurse.c @@ -80,7 +80,7 @@ const struct curse_type ct_magicwalls = { "magicwalls", 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", CURSETYP_NORM, 0, NO_MERGE, NULL }; diff --git a/src/spells/regioncurse.c b/src/spells/regioncurse.c index 7622b536f..d984715c1 100644 --- a/src/spells/regioncurse.c +++ b/src/spells/regioncurse.c @@ -87,7 +87,7 @@ const struct curse_type ct_gbdream = { /* --------------------------------------------------------------------- */ /* * C_MAGICSTREET - * erzeugt Straßennetz + * erzeugt Strassennetz */ static message *cinfo_magicstreet(const void *obj, objtype_t typ, const curse * c, int self) @@ -97,7 +97,7 @@ static message *cinfo_magicstreet(const void *obj, objtype_t typ, const curse * UNUSED_ARG(obj); assert(typ == TYP_REGION); - /* Warnung vor Auflösung */ + /* Warnung vor Aufloesung */ if (c->duration >= 2) { 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); assert(typ == TYP_REGION); - /* Magier spüren eine Antimagiezone */ + /* Magier spueren eine Antimagiezone */ if (self != 0) { 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; } -/* alle Magier können eine Antimagiezone wahrnehmen */ +/* alle Magier koennen eine Antimagiezone wahrnehmen */ static int cansee_antimagiczone(const struct faction *viewer, const void *obj, objtype_t typ, 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); - /* Magier spüren eine farvision */ + /* Magier spueren eine farvision */ if (self != 0) { return msg_message("curseinfo::farvision", "id", c->no); } @@ -232,7 +232,7 @@ const struct curse_type ct_badlearn = { cinfo_simple }; -/* Trübsal-Zauber */ +/* Truebsal-Zauber */ const struct curse_type ct_depression = { "depression", CURSETYP_NORM, 0, (M_DURATION | M_VIGOUR), @@ -268,7 +268,7 @@ const struct curse_type ct_badmagicresistancezone = { cinfo_simple }; -/* erhöht Magieresistenz von aliierten Einheiten, wirkt nur 1x pro +/* erhoeht Magieresistenz von aliierten Einheiten, wirkt nur 1x pro * Einheit */ const struct curse_type ct_goodmagicresistancezone = { "goodmagicresistancezone", diff --git a/src/spells/unitcurse.c b/src/spells/unitcurse.c index d0b381050..1d476a7be 100644 --- a/src/spells/unitcurse.c +++ b/src/spells/unitcurse.c @@ -42,7 +42,7 @@ /* * 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, int self) { diff --git a/src/tools/namegen.c b/src/tools/namegen.c index 2abcd0007..2e277ce0c 100644 --- a/src/tools/namegen.c +++ b/src/tools/namegen.c @@ -125,7 +125,7 @@ static char *entish_syllable2[] = { }; static char *entish_syllable3[] = { - "Hüter", "Pflanzer", "Hirte", "Wächter", "Wachser", "Beschützer", + "Hueter", "Pflanzer", "Hirte", "Waechter", "Wachser", "Beschützer", }; static char *cthuloid_syllable1[] = {