forked from github/server
fix source encodings, break umlauts, ASCII everywhere
This commit is contained in:
Enno Rehling
parent
4fee151f35
commit
a848a1b2ee
Binary file not shown.
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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! */
|
||||
|
|
|
|||
|
|
@ -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
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
94
src/magic.h
94
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 .. <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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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"));
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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[] = {
|
||||
|
|
|
|||
Loading…
Reference in New Issue