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

BIN
src/.report.c.swp Normal file

Binary file not shown.

View File

@ -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);

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) {
/* 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;

View File

@ -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) {

View File

@ -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 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);

View File

@ -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 */

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
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;

View File

@ -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! */

View File

@ -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
};

View File

@ -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 */

View File

@ -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 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 .. <Einheit-Nr> [<Einheit-Nr> ..] */
#define SHIPSPELL (1<<6) /* ZAUBER .. <Schiff-Nr> [<Schiff-Nr> ..] */
#define BUILDINGSPELL (1<<7) /* ZAUBER .. <Gebaeude-Nr> [<Gebaeude-Nr> ..] */
#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);

View File

@ -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;

View File

@ -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 */

View File

@ -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);

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, 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"));

View File

@ -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;

View File

@ -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
};

View File

@ -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",

View File

@ -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)
{

View File

@ -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[] = {