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

umlaut substitutions

This commit is contained in:
Enno Rehling 2019-02-08 11:37:32 +01:00
parent 9e44b8a989
commit debb86601b
11 changed files with 170 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/chaos.c
View File

@ -136,7 +136,7 @@ static void chaos(region * r)
u->flags |= (UFL_ISNEW | UFL_MOVED); u->flags |= (UFL_ISNEW | UFL_MOVED);
} }
break; break;
case 2: /* Terrainver<EFBFBD>nderung */ case 2: /* Terrainveraenderung */
if (!(r->terrain->flags & FORBIDDEN_REGION)) { if (!(r->terrain->flags & FORBIDDEN_REGION)) {
if (!(r->terrain->flags & SEA_REGION)) { if (!(r->terrain->flags & SEA_REGION)) {
direction_t dir; direction_t dir;

2
src/economy.test.c
View File

@ -232,7 +232,7 @@ static unit *setup_trade_unit(CuTest *tc, region *r, const struct race *rc) {
} }
static void test_trade_insect(CuTest *tc) { static void test_trade_insect(CuTest *tc) {
/* Insekten k<EFBFBD>nnen in W<>sten und S<>mpfen auch ohne Burgen handeln. */ /* Insekten koennen in Wuesten und Suempfen auch ohne Burgen handeln. */
unit *u; unit *u;
region *r; region *r;
const item_type *it_luxury; const item_type *it_luxury;

8
src/items.c
View File

@ -136,15 +136,15 @@ struct order *ord)
UNUSED_ARG(ord); UNUSED_ARG(ord);
assert(sp); assert(sp);
/* Reduziert die St<EFBFBD>rke jedes Spruchs um effect */ /* Reduziert die Staerke jedes Spruchs um effect */
effect = 5; effect = 5;
/* H<EFBFBD>lt Spr<70>che bis zu einem summierten Gesamtlevel von power aus. /* Haelt Sprueche bis zu einem summierten Gesamtlevel von power aus.
* Jeder Zauber reduziert die 'Lebenskraft' (vigour) der Antimagiezone * Jeder Zauber reduziert die 'Lebenskraft' (vigour) der Antimagiezone
* um seine Stufe */ * um seine Stufe */
force = effect * 20.0; /* Stufe 5 =~ 100 */ force = effect * 20.0; /* Stufe 5 =~ 100 */
/* Regionszauber aufl<EFBFBD>sen */ /* Regionszauber aufloesen */
while (*ap && force > 0) { while (*ap && force > 0) {
curse *c; curse *c;
attrib *a = *ap; attrib *a = *ap;
@ -156,7 +156,7 @@ struct order *ord)
} }
c = (curse *)a->data.v; c = (curse *)a->data.v;
/* Immunit<EFBFBD>t pr<70>fen */ /* Immunitaet pruefen */
if (c_flags(c) & CURSE_IMMUNE) { if (c_flags(c) & CURSE_IMMUNE) {
do { do {
ap = &(*ap)->next; ap = &(*ap)->next;

2
src/lighthouse.c
View File

@ -16,7 +16,7 @@
attrib_type at_lighthouse = { attrib_type at_lighthouse = {
"lighthouse" "lighthouse"
/* Rest ist NULL; tempor<EFBFBD>res, nicht alterndes Attribut */ /* Rest ist NULL; temporaeres, nicht alterndes Attribut */
}; };
bool is_lighthouse(const building_type *btype) bool is_lighthouse(const building_type *btype)

204
src/magic.c
View File

@ -289,7 +289,7 @@ int get_spell_level_mage(const spell * sp, void * cbdata)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* aus dem alten System übriggebliegene Funktionen, die bei der /* aus dem alten System uebriggebliegene Funktionen, die bei der
* Umwandlung von alt nach neu gebraucht werden */ * Umwandlung von alt nach neu gebraucht werden */
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -502,7 +502,7 @@ sc_mage *create_mage(unit * u, magic_t mtyp)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Funktionen für die Bearbeitung der List-of-known-spells */ /* Funktionen fuer die Bearbeitung der List-of-known-spells */
int u_hasspell(const unit *u, const struct spell *sp) int u_hasspell(const unit *u, const struct spell *sp)
{ {
@ -531,7 +531,7 @@ int get_combatspelllevel(const unit * u, int nr)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Kampfzauber ermitteln, setzen oder löschen */ /* Kampfzauber ermitteln, setzen oder loeschen */
const spell *get_combatspell(const unit * u, int nr) const spell *get_combatspell(const unit * u, int nr)
{ {
@ -591,8 +591,9 @@ void unset_combatspell(unit * u, spell * sp)
return; return;
} }
/* ------------------------------------------------------------- */ /**
/* Gibt die aktuelle Anzahl der Magiepunkte der Einheit zurück */ * Gibt die aktuelle Anzahl der Magiepunkte der Einheit zurueck
*/
int get_spellpoints(const unit * u) int get_spellpoints(const unit * u)
{ {
return mage_get_spellpoints(get_mage(u)); return mage_get_spellpoints(get_mage(u));
@ -606,15 +607,16 @@ void set_spellpoints(unit * u, int sp)
} }
} }
/* /**
* verändert die Anzahl der Magiepunkte der Einheit um +mp * Veraendert die Anzahl der Magiepunkte der Einheit um +mp
*/ */
int change_spellpoints(unit * u, int mp) int change_spellpoints(unit * u, int mp)
{ {
return mage_change_spellpoints(get_mage(u), mp); return mage_change_spellpoints(get_mage(u), mp);
} }
/* bietet die Möglichkeit, die maximale Anzahl der Magiepunkte mit /**
* Bietet die Moeglichkeit, die maximale Anzahl der Magiepunkte mit
* Regionszaubern oder Attributen zu beinflussen * Regionszaubern oder Attributen zu beinflussen
*/ */
static int get_spchange(const unit * u) static int get_spchange(const unit * u)
@ -627,13 +629,13 @@ static int get_spchange(const unit * u)
/* ein Magier kann normalerweise maximal Stufe^2.1/1.2+1 Magiepunkte /* ein Magier kann normalerweise maximal Stufe^2.1/1.2+1 Magiepunkte
* haben. * haben.
* Manche Rassen haben einen zusätzlichen Multiplikator * Manche Rassen haben einen zusaetzlichen Multiplikator
* Durch Talentverlust (zB Insekten im Berg) können negative Werte * Durch Talentverlust (zB Insekten im Berg) koennen negative Werte
* entstehen * entstehen
*/ */
/* Artefakt der Stärke /* Artefakt der Staerke
* Ermöglicht dem Magier mehr Magiepunkte zu 'speichern' * Ermoeglicht dem Magier mehr Magiepunkte zu 'speichern'
*/ */
/** TODO: at_skillmod daraus machen */ /** TODO: at_skillmod daraus machen */
static int use_item_aura(const region * r, const unit * u) static int use_item_aura(const region * r, const unit * u)
@ -687,7 +689,7 @@ int change_maxspellpoints(unit * u, int csp)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Counter für die bereits gezauberte Anzahl Sprüche pro Runde. /* Counter fuer die bereits gezauberte Anzahl Sprueche pro Runde.
*/ */
int countspells(unit * u, int step) int countspells(unit * u, int step)
{ {
@ -710,8 +712,8 @@ int spellcount(const unit *u) {
} }
/** /**
* Die Grundkosten pro Stufe werden um 2^count erhöht. countspells(u) * Die Grundkosten pro Stufe werden um 2^count erhoeht. countspells(u)
* ist dabei die Anzahl der bereits gezauberten Sprüche * ist dabei die Anzahl der bereits gezauberten Sprueche
*/ */
int aura_multiplier(const unit * u) { int aura_multiplier(const unit * u) {
int count = spellcount(u); int count = spellcount(u);
@ -729,7 +731,7 @@ int spellcost(const unit * caster, const struct spell_component *spc)
} }
/** /**
* Die für den Spruch benötigte Aura pro Stufe. * Die fuer den Spruch benoetigte Aura pro Stufe.
*/ */
int auracost(const unit *caster, const spell *sp) { int auracost(const unit *caster, const spell *sp) {
const resource_type *r_aura = get_resourcetype(R_AURA); const resource_type *r_aura = get_resourcetype(R_AURA);
@ -746,12 +748,12 @@ int auracost(const unit *caster, const spell *sp) {
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* SPC_LINEAR ist am höchstwertigen, dann müssen Komponenten für die /* SPC_LINEAR ist am hoechstwertigen, dann muessen Komponenten fuer die
* Stufe des Magiers vorhanden sein. * Stufe des Magiers vorhanden sein.
* SPC_LINEAR hat die gewünschte Stufe als multiplikator, * SPC_LINEAR hat die gewuenschte Stufe als multiplikator,
* nur SPC_FIX muss nur einmal vorhanden sein, ist also am * nur SPC_FIX muss nur einmal vorhanden sein, ist also am
* niedrigstwertigen und sollte von den beiden anderen Typen * niedrigstwertigen und sollte von den beiden anderen Typen
* überschrieben werden */ * ueberschrieben werden */
static int spl_costtyp(const spell * sp) static int spl_costtyp(const spell * sp)
{ {
int k; int k;
@ -765,7 +767,7 @@ static int spl_costtyp(const spell * sp)
return SPC_LINEAR; return SPC_LINEAR;
} }
/* wenn keine Fixkosten, Typ übernehmen */ /* wenn keine Fixkosten, Typ uebernehmen */
if (sp->components[k].cost != SPC_FIX) { if (sp->components[k].cost != SPC_FIX) {
costtyp = sp->components[k].cost; costtyp = sp->components[k].cost;
} }
@ -774,10 +776,10 @@ static int spl_costtyp(const spell * sp)
} }
/** /**
* Durch Komponenten und cast_level begrenzter maximal möglicherLevel. * Durch Komponenten und cast_level begrenzter maximal moeglicher Level.
* *
* Da die Funktion nicht alle Komponenten durchprobiert sondern beim * Da die Funktion nicht alle Komponenten durchprobiert sondern beim
* ersten Fehler abbricht, muss die Fehlermeldung später mit cancast() * ersten Fehler abbricht, muss die Fehlermeldung spaeter mit cancast()
* generiert werden. * generiert werden.
*/ */
int eff_spelllevel(unit * u, unit *caster, const spell * sp, int cast_level, int range) int eff_spelllevel(unit * u, unit *caster, const spell * sp, int cast_level, int range)
@ -802,20 +804,20 @@ int eff_spelllevel(unit * u, unit *caster, const spell * sp, int cast_level, int
level_cost * cast_level) / level_cost; level_cost * cast_level) / level_cost;
/* sind die Kosten fix, so muss die Komponente nur einmal vorhanden /* sind die Kosten fix, so muss die Komponente nur einmal vorhanden
* sein und der cast_level ändert sich nicht */ * sein und der cast_level aendert sich nicht */
if (sp->components[k].cost == SPC_FIX) { if (sp->components[k].cost == SPC_FIX) {
if (maxlevel < 1) if (maxlevel < 1)
cast_level = 0; cast_level = 0;
/* ansonsten wird das Minimum aus maximal möglicher Stufe und der /* ansonsten wird das Minimum aus maximal moeglicher Stufe und der
* gewünschten gebildet */ * gewuenschten gebildet */
} }
else if (sp->components[k].cost == SPC_LEVEL) { else if (sp->components[k].cost == SPC_LEVEL) {
costtyp = SPC_LEVEL; costtyp = SPC_LEVEL;
if (maxlevel < cast_level) { if (maxlevel < cast_level) {
cast_level = maxlevel; cast_level = maxlevel;
} }
/* bei Typ Linear müssen die Kosten in Höhe der Stufe vorhanden /* bei Typ Linear muessen die Kosten in Hoehe der Stufe vorhanden
* sein, ansonsten schlägt der Spruch fehl */ * sein, ansonsten schlaegt der Spruch fehl */
} }
else if (sp->components[k].cost == SPC_LINEAR) { else if (sp->components[k].cost == SPC_LINEAR) {
costtyp = SPC_LINEAR; costtyp = SPC_LINEAR;
@ -844,7 +846,7 @@ int eff_spelllevel(unit * u, unit *caster, const spell * sp, int cast_level, int
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Die Spruchgrundkosten werden mit der Entfernung (Farcasting) /* Die Spruchgrundkosten werden mit der Entfernung (Farcasting)
* multipliziert, wobei die Aurakosten ein Sonderfall sind, da sie sich * multipliziert, wobei die Aurakosten ein Sonderfall sind, da sie sich
* auch durch die Menge der bereits gezauberten Sprüche erhöht. * auch durch die Menge der bereits gezauberten Sprueche erhoeht.
* Je nach Kostenart werden dann die Komponenten noch mit cast_level * Je nach Kostenart werden dann die Komponenten noch mit cast_level
* multipliziert. * multipliziert.
*/ */
@ -868,7 +870,7 @@ void pay_spell(unit * mage, const unit *caster, const spell * sp, int cast_level
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Ein Magier kennt den Spruch und kann sich die Beschreibung anzeigen /* Ein Magier kennt den Spruch und kann sich die Beschreibung anzeigen
* lassen, wenn diese in seiner Spruchliste steht. Zaubern muss er ihn * lassen, wenn diese in seiner Spruchliste steht. Zaubern muss er ihn
* aber dann immer noch nicht können, vieleicht ist seine Stufe derzeit * aber dann immer noch nicht koennen, vieleicht ist seine Stufe derzeit
* nicht ausreichend oder die Komponenten fehlen. * nicht ausreichend oder die Komponenten fehlen.
*/ */
bool knowsspell(const region * r, const unit * u, const spell * sp) bool knowsspell(const region * r, const unit * u, const spell * sp)
@ -882,7 +884,7 @@ bool knowsspell(const region * r, const unit * u, const spell * sp)
/* Um einen Spruch zu beherrschen, muss der Magier die Stufe des /* Um einen Spruch zu beherrschen, muss der Magier die Stufe des
* Spruchs besitzen, nicht nur wissen, das es ihn gibt (also den Spruch * Spruchs besitzen, nicht nur wissen, das es ihn gibt (also den Spruch
* in seiner Spruchliste haben). * in seiner Spruchliste haben).
* Kosten für einen Spruch können Magiepunkte, Silber, Kraeuter * Kosten fuer einen Spruch koennen Magiepunkte, Silber, Kraeuter
* und sonstige Gegenstaende sein. * und sonstige Gegenstaende sein.
*/ */
@ -899,7 +901,7 @@ cancast(unit * u, const spell * sp, int level, int range, struct order * ord)
} }
/* reicht die Stufe aus? */ /* reicht die Stufe aus? */
if (effskill(u, SK_MAGIC, NULL) < level) { if (effskill(u, SK_MAGIC, NULL) < level) {
/* die Einheit ist nicht erfahren genug für diesen Zauber */ /* die Einheit ist nicht erfahren genug fuer diesen Zauber */
cmistake(u, ord, 169, MSG_MAGIC); cmistake(u, ord, 169, MSG_MAGIC);
return false; return false;
} }
@ -910,11 +912,11 @@ cancast(unit * u, const spell * sp, int level, int range, struct order * ord)
const resource_type *rtype = spc->type; const resource_type *rtype = spc->type;
int itemhave, itemanz; int itemhave, itemanz;
/* Die Kosten für Aura sind auch von der Zahl der bereits /* Die Kosten fuer Aura sind auch von der Zahl der bereits
* gezauberten Sprüche abhängig */ * gezauberten Sprueche abhaengig */
itemanz = spellcost(u, spc) * range; itemanz = spellcost(u, spc) * range;
/* sind die Kosten stufenabhängig, so muss itemanz noch mit dem /* sind die Kosten stufenabhaengig, so muss itemanz noch mit dem
* level multipliziert werden */ * level multipliziert werden */
switch (spc->cost) { switch (spc->cost) {
case SPC_LEVEL: case SPC_LEVEL:
@ -957,7 +959,7 @@ cancast(unit * u, const spell * sp, int level, int range, struct order * ord)
* Spruchitems und Antimagiefeldern zusammen. Es koennen noch die * Spruchitems und Antimagiefeldern zusammen. Es koennen noch die
* Stufe des Spruchs und Magiekosten mit einfliessen. * Stufe des Spruchs und Magiekosten mit einfliessen.
* *
* Die effektive Spruchstärke und ihre Auswirkungen werden in der * Die effektive Spruchstaerke und ihre Auswirkungen werden in der
* Spruchfunktionsroutine ermittelt. * Spruchfunktionsroutine ermittelt.
*/ */
@ -1041,7 +1043,7 @@ spellpower(region * r, unit * u, const spell * sp, int cast_level, struct order
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* farcasting() == 1 -> gleiche Region, da man mit Null nicht vernünfigt /* farcasting() == 1 -> gleiche Region, da man mit Null nicht vernuenfigt
* rechnen kann */ * rechnen kann */
static int farcasting(unit * magician, region * r) static int farcasting(unit * magician, region * r)
{ {
@ -1136,7 +1138,7 @@ variant magic_resistance(unit * target)
/* Bonus durch Artefakte */ /* Bonus durch Artefakte */
/* TODO (noch gibs keine) */ /* TODO (noch gibs keine) */
/* Bonus durch Gebäude */ /* Bonus durch Gebaeude */
{ {
struct building *b = inside_building(target); struct building *b = inside_building(target);
const struct building_type *btype = building_is_active(b) ? b->type : NULL; const struct building_type *btype = building_is_active(b) ? b->type : NULL;
@ -1157,14 +1159,14 @@ variant magic_resistance(unit * target)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Prüft, ob das Objekt dem Zauber widerstehen kann. /* Prueft, ob das Objekt dem Zauber widerstehen kann.
* Objekte können Regionen, Units, Gebäude oder Schiffe sein. * Objekte koennen Regionen, Units, Gebaeude oder Schiffe sein.
* TYP_UNIT: * TYP_UNIT:
* Das höchste Talent des Ziels ist sein 'Magieresistenz-Talent', Magier * Das hoechste Talent des Ziels ist sein 'Magieresistenz-Talent', Magier
* bekommen einen Bonus. Grundchance ist 50%, für jede Stufe * bekommen einen Bonus. Grundchance ist 50%, fuer jede Stufe
* Unterschied gibt es 5%, minimalchance ist 5% für jeden (5-95%) * Unterschied gibt es 5%, minimalchance ist 5% fuer jeden (5-95%)
* Scheitert der Spruch an der Magieresistenz, so gibt die Funktion * Scheitert der Spruch an der Magieresistenz, so gibt die Funktion
* true zurück * true zurueck
*/ */
bool bool
@ -1238,8 +1240,8 @@ target_resists_magic(unit * magician, void *obj, int objtyp, int t_bonus)
} }
/* gibt true, wenn die Zufallszahl kleiner als die chance ist und /* gibt true, wenn die Zufallszahl kleiner als die chance ist und
* false, wenn sie gleich oder größer ist, dh je größer die * false, wenn sie gleich oder groesser ist, dh je groesser die
* Magieresistenz (chance) desto eher gibt die Funktion true zurück */ * Magieresistenz (chance) desto eher gibt die Funktion true zurueck */
return rng_int() % prob.sa[1] < prob.sa[0]; return rng_int() % prob.sa[1] < prob.sa[0];
} }
@ -1266,7 +1268,7 @@ bool fumble(region * r, unit * u, const spell * sp, int cast_grade)
{ {
/* X ergibt Zahl zwischen 1 und 0, je kleiner, desto besser der Magier. /* X ergibt Zahl zwischen 1 und 0, je kleiner, desto besser der Magier.
* 0,5*40-20=0, dh wenn der Magier doppelt so gut ist, wie der Spruch * 0,5*40-20=0, dh wenn der Magier doppelt so gut ist, wie der Spruch
* benötigt, gelingt er immer, ist er gleich gut, gelingt der Spruch mit * benoetigt, gelingt er immer, ist er gleich gut, gelingt der Spruch mit
* 20% Warscheinlichkeit nicht * 20% Warscheinlichkeit nicht
* */ * */
@ -1298,8 +1300,8 @@ bool fumble(region * r, unit * u, const spell * sp, int cast_grade)
fumble_chance += CHAOSPATZERCHANCE; fumble_chance += CHAOSPATZERCHANCE;
} }
/* wenn die Chance kleiner als 0 ist, können wir gleich false /* wenn die Chance kleiner als 0 ist, koennen wir gleich false
* zurückgeben */ * zurueckgeben */
if (fumble_chance <= 0) { if (fumble_chance <= 0) {
return false; return false;
} }
@ -1309,7 +1311,7 @@ bool fumble(region * r, unit * u, const spell * sp, int cast_grade)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Dummy-Zauberpatzer, Platzhalter für speziell auf die Sprüche /* Dummy-Zauberpatzer, Platzhalter fuer speziell auf die Sprueche
* zugeschnittene Patzer */ * zugeschnittene Patzer */
static void fumble_default(castorder * co) static void fumble_default(castorder * co)
{ {
@ -1320,7 +1322,7 @@ static void fumble_default(castorder * co)
return; return;
} }
/* Die normalen Spruchkosten müssen immer bezahlt werden, hier noch /* Die normalen Spruchkosten muessen immer bezahlt werden, hier noch
* alle weiteren Folgen eines Patzers * alle weiteren Folgen eines Patzers
*/ */
@ -1391,7 +1393,7 @@ static void do_fumble(castorder * co)
break; break;
case 3: case 3:
case 4: case 4:
/* Spruch schlägt fehl, alle Magiepunkte weg */ /* Spruch schlaegt fehl, alle Magiepunkte weg */
set_spellpoints(mage, 0); set_spellpoints(mage, 0);
ADDMSG(&mage->faction->msgs, msg_message("patzer3", "unit region spell", ADDMSG(&mage->faction->msgs, msg_message("patzer3", "unit region spell",
mage, r, sp)); mage, r, sp));
@ -1410,7 +1412,7 @@ static void do_fumble(castorder * co)
case 8: case 8:
case 9: case 9:
default: default:
/* Spruch gelingt, alle nachfolgenden Sprüche werden 2^4 so teuer */ /* Spruch gelingt, alle nachfolgenden Sprueche werden 2^4 so teuer */
co->level = cast_spell(co); co->level = cast_spell(co);
ADDMSG(&mage->faction->msgs, msg_message("patzer5", "unit region spell", ADDMSG(&mage->faction->msgs, msg_message("patzer5", "unit region spell",
mage, r, sp)); mage, r, sp));
@ -1423,7 +1425,7 @@ static void do_fumble(castorder * co)
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Ein Magier regeneriert pro Woche W(Stufe^1.5/2+1), mindestens 1 /* Ein Magier regeneriert pro Woche W(Stufe^1.5/2+1), mindestens 1
* Zwerge nur die Hälfte * Zwerge nur die Haelfte
*/ */
static double regeneration(unit * u) static double regeneration(unit * u)
{ {
@ -1440,7 +1442,7 @@ static double regeneration(unit * u)
/* Einfluss von Artefakten */ /* Einfluss von Artefakten */
/* TODO (noch gibs keine) */ /* TODO (noch gibs keine) */
/* Würfeln */ /* Wuerfeln */
aura = (rng_double() * d + rng_double() * d) / 2 + 1; aura = (rng_double() * d + rng_double() * d) / 2 + 1;
aura *= MagicRegeneration(); aura *= MagicRegeneration();
@ -1470,8 +1472,8 @@ void regenerate_aura(void)
const struct building_type *btype = building_is_active(b) ? b->type : NULL; const struct building_type *btype = building_is_active(b) ? b->type : NULL;
reg_aura = regeneration(u); reg_aura = regeneration(u);
/* Magierturm erhöht die Regeneration um 75% */ /* Magierturm erhoeht die Regeneration um 75% */
/* Steinkreis erhöht die Regeneration um 50% */ /* Steinkreis erhoeht die Regeneration um 50% */
if (btype) if (btype)
reg_aura *= btype->auraregen; reg_aura *= btype->auraregen;
@ -1613,14 +1615,14 @@ verify_unit(region * r, unit * mage, const spell * sp, spllprm * spobj,
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Zuerst wird versucht alle noch nicht gefundenen Objekte zu finden /* Zuerst wird versucht alle noch nicht gefundenen Objekte zu finden
* oder zu prüfen, ob das gefundene Objekt wirklich hätte gefunden * oder zu pruefen, ob das gefundene Objekt wirklich haette gefunden
* werden dürfen (nicht alle Zauber wirken global). Dabei zählen wir die * werden duerfen (nicht alle Zauber wirken global). Dabei zaehlen wir die
* Misserfolge (failed). * Misserfolge (failed).
* Dann folgen die Tests der gefundenen Objekte auf Magieresistenz und * Dann folgen die Tests der gefundenen Objekte auf Magieresistenz und
* Sichtbarkeit. Dabei zählen wir die magieresistenten (resists) * Sichtbarkeit. Dabei zaehlen wir die magieresistenten (resists)
* Objekte. Alle anderen werten wir als Erfolge (success) */ * Objekte. Alle anderen werten wir als Erfolge (success) */
/* gibt bei Misserfolg 0 zurück, bei Magieresistenz zumindeste eines /* gibt bei Misserfolg 0 zurueck, bei Magieresistenz zumindeste eines
* Objektes 1 und bei Erfolg auf ganzer Linie 2 */ * Objektes 1 und bei Erfolg auf ganzer Linie 2 */
static void static void
verify_targets(castorder * co, int *invalid, int *resist, int *success) verify_targets(castorder * co, int *invalid, int *resist, int *success)
@ -1638,8 +1640,8 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success)
int i; int i;
/* zuerst versuchen wir vorher nicht gefundene Objekte zu finden. /* zuerst versuchen wir vorher nicht gefundene Objekte zu finden.
* Wurde ein Objekt durch globalsuche gefunden, obwohl der Zauber * Wurde ein Objekt durch globalsuche gefunden, obwohl der Zauber
* gar nicht global hätte suchen dürften, setzen wir das Objekt * gar nicht global haette suchen duerften, setzen wir das Objekt
* zurück. */ * zurueck. */
for (i = 0; i < sa->length; i++) { for (i = 0; i < sa->length; i++) {
spllprm *spobj = sa->param[i]; spllprm *spobj = sa->param[i];
@ -1723,7 +1725,7 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success)
case SPP_REGION: case SPP_REGION:
/* haben wir ein Regionsobjekt, dann wird auch dieses und /* haben wir ein Regionsobjekt, dann wird auch dieses und
nicht target_r überprüft. */ nicht target_r ueberprueft. */
tr = spobj->data.r; tr = spobj->data.r;
if ((sp->sptyp & TESTRESISTANCE) if ((sp->sptyp & TESTRESISTANCE)
@ -1749,7 +1751,7 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success)
else { else {
/* der Zauber hat keine expliziten Parameter/Ziele, es kann sich /* der Zauber hat keine expliziten Parameter/Ziele, es kann sich
* aber um einen Regionszauber handeln. Wenn notwendig hier die * aber um einen Regionszauber handeln. Wenn notwendig hier die
* Magieresistenz der Region prüfen. */ * Magieresistenz der Region pruefen. */
if ((sp->sptyp & REGIONSPELL)) { if ((sp->sptyp & REGIONSPELL)) {
/* Zielobjekt Region anlegen */ /* Zielobjekt Region anlegen */
spllprm *spobj = (spllprm *)malloc(sizeof(spllprm)); spllprm *spobj = (spllprm *)malloc(sizeof(spllprm));
@ -1788,7 +1790,7 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Hilfsstrukturen für ZAUBERE */ /* Hilfsstrukturen fuer ZAUBERE */
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
static void free_spellparameter(spellparameter * pa) static void free_spellparameter(spellparameter * pa)
@ -1979,7 +1981,7 @@ static spellparameter *add_spellparameter(region * target_r, unit * u,
break; break;
case '+': case '+':
/* das vorhergehende Element kommt ein oder mehrmals vor, wir /* das vorhergehende Element kommt ein oder mehrmals vor, wir
* springen zum key zurück */ * springen zum key zurueck */
j = 0; j = 0;
--c; --c;
break; break;
@ -2116,7 +2118,7 @@ void free_castorder(struct castorder *co)
if (co->order) free_order(co->order); if (co->order) free_order(co->order);
} }
/* 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 add_castorder(spellrank * cll, castorder * co) void add_castorder(spellrank * cll, castorder * co)
{ {
if (cll->begin == NULL) { if (cll->begin == NULL) {
@ -2546,7 +2548,7 @@ static castorder *cast_cmd(unit * u, order * ord)
init_order_depr(ord); init_order_depr(ord);
s = gettoken(token, sizeof(token)); s = gettoken(token, sizeof(token));
param = findparam(s, u->faction->locale); param = findparam(s, u->faction->locale);
/* für Syntax ' STUFE x REGION y z ' */ /* fuer Syntax ' STUFE x REGION y z ' */
if (param == P_LEVEL) { if (param == P_LEVEL) {
int p = getint(); int p = getint();
if (level > p) level = p; if (level > p) level = p;
@ -2575,8 +2577,8 @@ static castorder *cast_cmd(unit * u, order * ord)
s = gettoken(token, sizeof(token)); s = gettoken(token, sizeof(token));
param = findparam(s, u->faction->locale); param = findparam(s, u->faction->locale);
} }
/* für Syntax ' REGION x y STUFE z ' /* fuer Syntax ' REGION x y STUFE z '
* hier nach REGION nochmal auf STUFE prüfen */ * hier nach REGION nochmal auf STUFE pruefen */
if (param == P_LEVEL) { if (param == P_LEVEL) {
int p = getint(); int p = getint();
if (level > p) level = p; if (level > p) level = p;
@ -2595,8 +2597,8 @@ static castorder *cast_cmd(unit * u, order * ord)
sp = unit_getspell(u, s, u->faction->locale); sp = unit_getspell(u, s, u->faction->locale);
/* Vertraute können auch Zauber sprechen, die sie selbst nicht /* Vertraute koennen auch Zauber sprechen, die sie selbst nicht
* können. unit_getspell findet aber nur jene Sprüche, die * koennen. unit_getspell findet aber nur jene Sprueche, die
* die Einheit beherrscht. */ * die Einheit beherrscht. */
if (!sp && is_familiar(u)) { if (!sp && is_familiar(u)) {
mage = get_familiar_mage(u); mage = get_familiar_mage(u);
@ -2619,7 +2621,7 @@ static castorder *cast_cmd(unit * u, order * ord)
/* um testen auf spruchnamen zu unterbinden sollte vor allen /* um testen auf spruchnamen zu unterbinden sollte vor allen
* fehlermeldungen die anzeigen das der magier diesen Spruch * fehlermeldungen die anzeigen das der magier diesen Spruch
* nur in diese Situation nicht anwenden kann, noch eine * nur in diese Situation nicht anwenden kann, noch eine
* einfache Sicherheitsprüfung kommen */ * einfache Sicherheitspruefung kommen */
if (!knowsspell(r, u, sp)) { if (!knowsspell(r, u, sp)) {
/* vorsicht! u kann der familiar sein */ /* vorsicht! u kann der familiar sein */
if (!familiar) { if (!familiar) {
@ -2632,9 +2634,9 @@ static castorder *cast_cmd(unit * u, order * ord)
cmistake(u, ord, 174, MSG_MAGIC); cmistake(u, ord, 174, MSG_MAGIC);
return 0; return 0;
} }
/* Auf dem Ozean Zaubern als quasi-langer Befehl können /* Auf dem Ozean Zaubern als quasi-langer Befehl koennen
* normalerweise nur Meermenschen, ausgenommen explizit als * normalerweise nur Meermenschen, ausgenommen explizit als
* OCEANCASTABLE deklarierte Sprüche */ * OCEANCASTABLE deklarierte Sprueche */
if (fval(r->terrain, SEA_REGION)) { if (fval(r->terrain, SEA_REGION)) {
if (u_race(u) != get_race(RC_AQUARIAN) if (u_race(u) != get_race(RC_AQUARIAN)
&& !fval(u_race(u), RCF_SWIM) && !fval(u_race(u), RCF_SWIM)
@ -2657,7 +2659,7 @@ static castorder *cast_cmd(unit * u, order * ord)
} }
} }
} }
/* Farcasting bei nicht farcastbaren Sprüchen abfangen */ /* Farcasting bei nicht farcastbaren Spruechen abfangen */
range = farcasting(u, target_r); range = farcasting(u, target_r);
if (range > 1) { if (range > 1) {
if (!(sp->sptyp & FARCASTING)) { if (!(sp->sptyp & FARCASTING)) {
@ -2672,7 +2674,7 @@ static castorder *cast_cmd(unit * u, order * ord)
return 0; return 0;
} }
} }
/* Stufenangabe bei nicht Stufenvariierbaren Sprüchen abfangen */ /* Stufenangabe bei nicht Stufenvariierbaren Spruechen abfangen */
if (!(sp->sptyp & SPELLLEVEL)) { if (!(sp->sptyp & SPELLLEVEL)) {
int ilevel = effskill(u, SK_MAGIC, NULL); int ilevel = effskill(u, SK_MAGIC, NULL);
if (ilevel != level) { if (ilevel != level) {
@ -2707,7 +2709,7 @@ static castorder *cast_cmd(unit * u, order * ord)
"mage", mage)); "mage", mage));
return 0; return 0;
} }
/* mage auf magier setzen, level anpassen, range für Erhöhung /* mage auf magier setzen, level anpassen, range fuer Erhoehung
* der Spruchkosten nutzen */ * der Spruchkosten nutzen */
range *= 2; range *= 2;
sk /= 2; sk /= 2;
@ -2747,19 +2749,19 @@ static castorder *cast_cmd(unit * u, order * ord)
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Damit man keine Rituale in fremden Gebiet machen kann, diese vor /* Damit man keine Rituale in fremden Gebiet machen kann, diese vor
* Bewegung zaubern. Magier sind also in einem fremden Gebiet eine Runde * Bewegung zaubern. Magier sind also in einem fremden Gebiet eine Runde
* lang verletzlich, da sie es betreten, und angegriffen werden können, * lang verletzlich, da sie es betreten, und angegriffen werden koennen,
* bevor sie ein Ritual machen können. * bevor sie ein Ritual machen koennen.
* *
* Syntax: ZAUBER [REGION X Y] [STUFE <stufe>] "Spruchname" [Einheit-1 * Syntax: ZAUBER [REGION X Y] [STUFE <stufe>] "Spruchname" [Einheit-1
* Einheit-2 ..] * Einheit-2 ..]
* *
* Nach Priorität geordnet die Zauber global auswerten. * Nach Prioritaet geordnet die Zauber global auswerten.
* *
* Die Kosten für Farcasting multiplizieren sich mit der Entfernung, * Die Kosten fuer Farcasting multiplizieren sich mit der Entfernung,
* cast_level gibt die virtuelle Stufe an, die den durch das Farcasten * cast_level gibt die virtuelle Stufe an, die den durch das Farcasten
* entstandenen Spruchkosten entspricht. Sind die Spruchkosten nicht * entstandenen Spruchkosten entspricht. Sind die Spruchkosten nicht
* levelabhängig, so sind die Kosten nur von der Entfernung bestimmt, * levelabhaengig, so sind die Kosten nur von der Entfernung bestimmt,
* die Stärke/Level durch den realen Skill des Magiers * die Staerke/Level durch den realen Skill des Magiers
*/ */
void magic(void) void magic(void)
@ -2800,11 +2802,11 @@ void magic(void)
} }
} }
/* Da sich die Aura und Komponenten in der Zwischenzeit verändert /* Da sich die Aura und Komponenten in der Zwischenzeit veraendert
* haben können und sich durch vorherige Sprüche das Zaubern * haben koennen und sich durch vorherige Sprueche das Zaubern
* erschwert haben kann, muss beim zaubern erneut geprüft werden, ob der * erschwert haben kann, muss beim zaubern erneut geprueft werden, ob der
* Spruch überhaupt gezaubert werden kann. * Spruch ueberhaupt gezaubert werden kann.
* (level) die effektive Stärke des Spruchs (= Stufe, auf der der * (level) die effektive Staerke des Spruchs (= Stufe, auf der der
* Spruch gezaubert wird) */ * Spruch gezaubert wird) */
for (rank = 0; rank < MAX_SPELLRANK; rank++) { for (rank = 0; rank < MAX_SPELLRANK; rank++) {
@ -2828,30 +2830,30 @@ void magic(void)
} }
if (cast_level > co->level) { if (cast_level > co->level) {
/* Sprüche mit Fixkosten werden immer auf Stufe des Spruchs /* Sprueche mit Fixkosten werden immer auf Stufe des Spruchs
* gezaubert, co->level ist aber defaultmäßig Stufe des Magiers */ * gezaubert, co->level ist aber defaultmaessig Stufe des Magiers */
if (spl_costtyp(sp) != SPC_FIX) { if (spl_costtyp(sp) != SPC_FIX) {
ADDMSG(&mage->faction->msgs, msg_message("missing_components", ADDMSG(&mage->faction->msgs, msg_message("missing_components",
"unit spell level", mage, sp, cast_level)); "unit spell level", mage, sp, cast_level));
} }
} }
/* Prüfen, ob die realen Kosten für die gewünschten Stufe bezahlt /* Pruefen, ob die realen Kosten fuer die gewuenschten Stufe bezahlt
* werden können */ * werden koennen */
if (!cancast(mage, sp, co->level, co->distance, ord)) { if (!cancast(mage, sp, co->level, co->distance, ord)) {
/* die Fehlermeldung wird in cancast generiert */ /* die Fehlermeldung wird in cancast generiert */
continue; continue;
} }
co->force = MagicPower(spellpower(target_r, mage, sp, co->level, ord)); co->force = MagicPower(spellpower(target_r, mage, sp, co->level, ord));
/* die Stärke kann durch Antimagie auf 0 sinken */ /* die Staerke kann durch Antimagie auf 0 sinken */
if (co->force <= 0) { if (co->force <= 0) {
co->force = 0; co->force = 0;
ADDMSG(&mage->faction->msgs, msg_message("missing_force", ADDMSG(&mage->faction->msgs, msg_message("missing_force",
"unit spell level", mage, sp, co->level)); "unit spell level", mage, sp, co->level));
} }
/* Ziele auf Existenz prüfen und Magieresistenz feststellen. Wurde /* Ziele auf Existenz pruefen und Magieresistenz feststellen. Wurde
* kein Ziel gefunden, so ist verify_targets=0. Scheitert der * kein Ziel gefunden, so ist verify_targets=0. Scheitert der
* Spruch an der Magieresistenz, so ist verify_targets = 1, bei * Spruch an der Magieresistenz, so ist verify_targets = 1, bei
* Erfolg auf ganzer Linie ist verify_targets= 2 * Erfolg auf ganzer Linie ist verify_targets= 2
@ -2859,8 +2861,8 @@ void magic(void)
verify_targets(co, &invalid, &resist, &success); verify_targets(co, &invalid, &resist, &success);
if (success + resist == 0) { if (success + resist == 0) {
/* kein Ziel gefunden, Fehlermeldungen sind in verify_targets */ /* kein Ziel gefunden, Fehlermeldungen sind in verify_targets */
/* keine kosten für den zauber */ /* keine kosten fuer den zauber */
continue; /* äußere Schleife, nächster Zauberer */ continue; /* aeussere Schleife, naechster Zauberer */
} }
else if (co->force > 0 && resist > 0) { else if (co->force > 0 && resist > 0) {
/* einige oder alle Ziele waren magieresistent */ /* einige oder alle Ziele waren magieresistent */
@ -2873,8 +2875,8 @@ void magic(void)
} }
} }
/* Auch für Patzer gibt es Erfahrung, müssen die Spruchkosten /* Auch fuer Patzer gibt es Erfahrung, muessen die Spruchkosten
* bezahlt werden und die nachfolgenden Sprüche werden teurer */ * bezahlt werden und die nachfolgenden Sprueche werden teurer */
if (co->force > 0) { if (co->force > 0) {
if (fumble(target_r, mage, sp, co->level)) { if (fumble(target_r, mage, sp, co->level)) {
/* zuerst bezahlen, dann evt in do_fumble alle Aura verlieren */ /* zuerst bezahlen, dann evt in do_fumble alle Aura verlieren */
@ -2883,12 +2885,12 @@ void magic(void)
else { else {
co->level = cast_spell(co); co->level = cast_spell(co);
if (co->level <= 0) { if (co->level <= 0) {
/* Kosten nur für real benötige Stufe berechnen */ /* Kosten nur fuer real benoetige Stufe berechnen */
continue; continue;
} }
} }
} }
/* erst bezahlen, dann Kostenzähler erhöhen */ /* erst bezahlen, dann Kostenzaehler erhoehen */
if (co->level > 0) { if (co->level > 0) {
pay_spell(mage, caster, sp, co->level, co->distance); pay_spell(mage, caster, sp, co->level, co->distance);
} }

72
src/move.c
View File

@ -108,7 +108,7 @@ static attrib_type at_traveldir = {
"traveldir", "traveldir",
DEFAULT_INIT, DEFAULT_INIT,
DEFAULT_FINALIZE, DEFAULT_FINALIZE,
DEFAULT_AGE, /* Weil normales Aging an ungünstiger Stelle */ DEFAULT_AGE, /* Weil normales Aging an unguenstiger Stelle */
a_writechars, a_writechars,
a_readchars a_readchars
}; };
@ -267,8 +267,8 @@ static int ridingcapacity(const unit * u)
get_transporters(u->items, &animals, &acap, &vehicles, &vcap); get_transporters(u->items, &animals, &acap, &vehicles, &vcap);
/* Man trägt sein eigenes Gewicht plus seine Kapazität! Die Menschen /* Man traegt sein eigenes Gewicht plus seine Kapazitaet! Die Menschen
** tragen nichts (siehe walkingcapacity). Ein Wagen zählt nur, wenn er ** tragen nichts (siehe walkingcapacity). Ein Wagen zaehlt nur, wenn er
** von zwei Pferden gezogen wird */ ** von zwei Pferden gezogen wird */
horses = effskill(u, SK_RIDING, NULL) * u->number * 2; horses = effskill(u, SK_RIDING, NULL) * u->number * 2;
@ -277,7 +277,7 @@ static int ridingcapacity(const unit * u)
if (fval(u_race(u), RCF_HORSE)) if (fval(u_race(u), RCF_HORSE))
animals += u->number; animals += u->number;
/* maximal diese Pferde können zum Ziehen benutzt werden */ /* maximal diese Pferde koennen zum Ziehen benutzt werden */
horses = animals / HORSES_PER_CART; horses = animals / HORSES_PER_CART;
if (horses < vehicles) vehicles = horses; if (horses < vehicles) vehicles = horses;
@ -308,7 +308,7 @@ int walkingcapacity(const struct unit *u)
people = u->number; people = u->number;
} }
/* maximal diese Pferde können zum Ziehen benutzt werden */ /* maximal diese Pferde koennen zum Ziehen benutzt werden */
horses = pferde_fuer_wagen / HORSES_PER_CART; horses = pferde_fuer_wagen / HORSES_PER_CART;
wagen_mit_pferden = (vehicles < horses) ? vehicles : horses; wagen_mit_pferden = (vehicles < horses) ? vehicles : horses;
@ -326,7 +326,7 @@ int walkingcapacity(const struct unit *u)
wagen_mit_trollen = wagen_ohne_pferde; wagen_mit_trollen = wagen_ohne_pferde;
} }
/* Wagenkapazität hinzuzählen */ /* Wagenkapazitaet hinzuzaehlen */
n += wagen_mit_trollen * vcap; n += wagen_mit_trollen * vcap;
} }
@ -390,15 +390,15 @@ static int canwalk(unit * u)
if (walkingcapacity(u) - eff_weight(u) >= 0) if (walkingcapacity(u) - eff_weight(u) >= 0)
return E_CANWALK_OK; return E_CANWALK_OK;
/* Stimmt das Gewicht, impliziert dies hier, daß alle Wagen ohne /* Stimmt das Gewicht, impliziert dies hier, dass alle Wagen ohne
* Zugpferde/-trolle als Fracht aufgeladen wurden: zu viele Pferde hat * Zugpferde/-trolle als Fracht aufgeladen wurden: zu viele Pferde hat
* die Einheit nicht zum Ziehen benutzt, also nicht mehr Wagen gezogen * die Einheit nicht zum Ziehen benutzt, also nicht mehr Wagen gezogen
* als erlaubt. */ * als erlaubt. */
if (vehicles > maxwagen) if (vehicles > maxwagen)
return E_CANWALK_TOOMANYCARTS; return E_CANWALK_TOOMANYCARTS;
/* Es muß nicht zwingend an den Wagen liegen, aber egal... (man /* Es muss nicht zwingend an den Wagen liegen, aber egal... (man
* könnte z.B. auch 8 Eisen abladen, damit ein weiterer Wagen als * koennte z.B. auch 8 Eisen abladen, damit ein weiterer Wagen als
* Fracht draufpasst) */ * Fracht draufpasst) */
return E_CANWALK_TOOHEAVY; return E_CANWALK_TOOHEAVY;
@ -682,7 +682,7 @@ int check_ship_allowed(struct ship *sh, const region * r)
const building_type *bt_harbour = bt_find("harbour"); const building_type *bt_harbour = bt_find("harbour");
if (sh->region && r_insectstalled(r)) { if (sh->region && r_insectstalled(r)) {
/* insekten dürfen nicht hier rein. haben wir welche? */ /* insekten duerfen nicht hier rein. haben wir welche? */
unit *u = ship_owner(sh); unit *u = ship_owner(sh);
if (u && is_freezing(u)) { if (u && is_freezing(u)) {
@ -828,19 +828,19 @@ static void drifting_ships(region * r)
sh->flags |= SF_FISHING; sh->flags |= SF_FISHING;
} }
/* Schiff schon abgetrieben oder durch Zauber geschützt? */ /* Schiff schon abgetrieben oder durch Zauber geschuetzt? */
if (!drift || fval(sh, SF_DRIFTED) || is_cursed(sh->attribs, &ct_nodrift)) { if (!drift || fval(sh, SF_DRIFTED) || is_cursed(sh->attribs, &ct_nodrift)) {
shp = &sh->next; shp = &sh->next;
continue; continue;
} }
/* Kapitän bestimmen */ /* Kapitaen bestimmen */
captain = ship_owner(sh); captain = ship_owner(sh);
if (captain && effskill(captain, SK_SAILING, r) < sh->type->cptskill) if (captain && effskill(captain, SK_SAILING, r) < sh->type->cptskill)
captain = NULL; captain = NULL;
/* Kapitän da? Beschädigt? Genügend Matrosen? /* Kapitaen da? Beschaedigt? Genuegend Matrosen?
* Genügend leicht? Dann ist alles OK. */ * Genuegend leicht? Dann ist alles OK. */
if (captain && sh->size == sh->type->construction->maxsize if (captain && sh->size == sh->type->construction->maxsize
&& enoughsailors(sh, crew_skill(sh)) && cansail(r, sh)) { && enoughsailors(sh, crew_skill(sh)) && cansail(r, sh)) {
@ -851,7 +851,7 @@ static void drifting_ships(region * r)
ovl = overload(r, sh); ovl = overload(r, sh);
if (ovl < overload_start()) { if (ovl < overload_start()) {
/* Auswahl einer Richtung: Zuerst auf Land, dann /* Auswahl einer Richtung: Zuerst auf Land, dann
* zufällig. Falls unmögliches Resultat: vergiß es. */ * zufaellig. Falls unmoegliches Resultat: vergiss es. */
dir = drift_target(sh); dir = drift_target(sh);
if (dir != NODIRECTION) { if (dir != NODIRECTION) {
rnext = rconnect(sh->region, dir); rnext = rconnect(sh->region, dir);
@ -1388,12 +1388,12 @@ static void make_route(unit * u, order * ord, region_list ** routep)
/** calculate the speed of a unit /** calculate the speed of a unit
* *
* zu Fuß reist man 1 Region, zu Pferd 2 Regionen. Mit Straßen reist * zu Fuss reist man 1 Region, zu Pferd 2 Regionen. Mit Strassen reist
* man zu Fuß 2, mit Pferden 3 weit. * man zu Fuss 2, mit Pferden 3 weit.
* *
* Berechnet wird das mit BPs. Zu Fuß hat man 4 BPs, zu Pferd 6. * Berechnet wird das mit BPs. Zu Fuss hat man 4 BPs, zu Pferd 6.
* Normalerweise verliert man 3 BP pro Region, bei Straßen nur 2 BP. * Normalerweise verliert man 3 BP pro Region, bei Strassen nur 2 BP.
* Außerdem: Wenn Einheit transportiert, nur halbe BP * Ausserdem: Wenn Einheit transportiert, nur halbe BP
*/ */
int movement_speed(const unit * u) int movement_speed(const unit * u)
{ {
@ -1514,7 +1514,7 @@ static const region_list *travel_route(unit * u,
landing = true; landing = true;
} }
else if ((u_race(u)->flags & RCF_WALK) == 0) { else if ((u_race(u)->flags & RCF_WALK) == 0) {
/* Spezialeinheiten, die nicht laufen können. */ /* Spezialeinheiten, die nicht laufen koennen. */
ADDMSG(&u->faction->msgs, msg_message("detectocean", ADDMSG(&u->faction->msgs, msg_message("detectocean",
"unit region terrain", u, next, terrain_name(next))); "unit region terrain", u, next, terrain_name(next)));
break; break;
@ -1527,7 +1527,7 @@ static const region_list *travel_route(unit * u,
} }
} }
else { else {
/* Ozeanfelder können nur von Einheiten mit Schwimmen und ohne /* Ozeanfelder koennen nur von Einheiten mit Schwimmen und ohne
* Pferde betreten werden. */ * Pferde betreten werden. */
if (!(canswim(u) || canfly(u))) { if (!(canswim(u) || canfly(u))) {
ADDMSG(&u->faction->msgs, msg_message("detectocean", ADDMSG(&u->faction->msgs, msg_message("detectocean",
@ -1626,7 +1626,7 @@ static const region_list *travel_route(unit * u,
walkmode = 2; walkmode = 2;
} }
/* Berichte über Durchreiseregionen */ /* Berichte ueber Durchreiseregionen */
if (mode != TRAVEL_TRANSPORTED) { if (mode != TRAVEL_TRANSPORTED) {
arg_regions *ar = var_copy_regions(route_begin, steps - 1); arg_regions *ar = var_copy_regions(route_begin, steps - 1);
@ -1690,7 +1690,7 @@ unit *owner_buildingtyp(const region * r, const building_type * bt)
return NULL; return NULL;
} }
/* Prüft, ob Ablegen von einer Küste in eine der erlaubten Richtungen erfolgt. */ /* Prueft, ob Ablegen von einer Kueste in eine der erlaubten Richtungen erfolgt. */
bool can_takeoff(const ship * sh, const region * from, const region * to) bool can_takeoff(const ship * sh, const region * from, const region * to)
{ {
if (!fval(from->terrain, SEA_REGION) && sh->coast != NODIRECTION) { if (!fval(from->terrain, SEA_REGION) && sh->coast != NODIRECTION) {
@ -1742,18 +1742,18 @@ static void sail(unit * u, order * ord, region_list ** routep, bool drifting)
return; return;
/* Wir suchen so lange nach neuen Richtungen, wie es geht. Diese werden /* Wir suchen so lange nach neuen Richtungen, wie es geht. Diese werden
* dann nacheinander ausgeführt. */ * dann nacheinander ausgefuehrt. */
k = shipspeed(sh, u); k = shipspeed(sh, u);
last_point = starting_point; last_point = starting_point;
current_point = starting_point; current_point = starting_point;
/* die nächste Region, in die man segelt, wird durch movewhere () aus der /* die naechste Region, in die man segelt, wird durch movewhere () aus der
* letzten Region bestimmt. * letzten Region bestimmt.
* *
* Anfangen tun wir bei starting_point. next_point ist beim ersten * Anfangen tun wir bei starting_point. next_point ist beim ersten
* Durchlauf schon gesetzt (Parameter!). current_point ist die letzte gültige, * Durchlauf schon gesetzt (Parameter!). current_point ist die letzte gueltige,
* befahrene Region. */ * befahrene Region. */
while (next_point && current_point != next_point && step < k) { while (next_point && current_point != next_point && step < k) {
@ -1795,7 +1795,7 @@ static void sail(unit * u, order * ord, region_list ** routep, bool drifting)
bool storm = true; bool storm = true;
int d_offset = rng_int() % MAXDIRECTIONS; int d_offset = rng_int() % MAXDIRECTIONS;
direction_t d; direction_t d;
/* Sturm nur, wenn nächste Region Hochsee ist. */ /* Sturm nur, wenn naechste Region Hochsee ist. */
for (d = 0; d != MAXDIRECTIONS; ++d) { for (d = 0; d != MAXDIRECTIONS; ++d) {
direction_t dnext = (direction_t)((d + d_offset) % MAXDIRECTIONS); direction_t dnext = (direction_t)((d + d_offset) % MAXDIRECTIONS);
region *rn = rconnect(current_point, dnext); region *rn = rconnect(current_point, dnext);
@ -1933,16 +1933,16 @@ static void sail(unit * u, order * ord, region_list ** routep, bool drifting)
sh = NULL; sh = NULL;
} }
/* Nun enthält current_point die Region, in der das Schiff seine Runde /* Nun enthaelt current_point die Region, in der das Schiff seine Runde
* beendet hat. Wir generieren hier ein Ereignis für den Spieler, das * beendet hat. Wir generieren hier ein Ereignis fuer den Spieler, das
* ihm sagt, bis wohin er gesegelt ist, falls er überhaupt vom Fleck * ihm sagt, bis wohin er gesegelt ist, falls er ueberhaupt vom Fleck
* gekommen ist. Das ist nicht der Fall, wenn er von der Küste ins * gekommen ist. Das ist nicht der Fall, wenn er von der Kueste ins
* Inland zu segeln versuchte */ * Inland zu segeln versuchte */
if (sh != NULL && fval(sh, SF_MOVED)) { if (sh != NULL && fval(sh, SF_MOVED)) {
unit *harbourmaster; unit *harbourmaster;
/* nachdem alle Richtungen abgearbeitet wurden, und alle Einheiten /* nachdem alle Richtungen abgearbeitet wurden, und alle Einheiten
* transferiert wurden, kann der aktuelle Befehl gelöscht werden. */ * transferiert wurden, kann der aktuelle Befehl geloescht werden. */
if (getkeyword(ord) == K_ROUTE) { if (getkeyword(ord) == K_ROUTE) {
order * norder = cycle_route(ord, u->faction->locale, step); order * norder = cycle_route(ord, u->faction->locale, step);
replace_order(&u->orders, ord, norder); replace_order(&u->orders, ord, norder);
@ -1969,7 +1969,7 @@ static void sail(unit * u, order * ord, region_list ** routep, bool drifting)
move_ship(sh, starting_point, current_point, routep ? *routep : NULL); move_ship(sh, starting_point, current_point, routep ? *routep : NULL);
/* Hafengebühren ? */ /* Hafengebuehren ? */
harbourmaster = owner_buildingtyp(current_point, bt_find("harbour")); harbourmaster = owner_buildingtyp(current_point, bt_find("harbour"));
if (harbourmaster != NULL) { if (harbourmaster != NULL) {
@ -2316,7 +2316,7 @@ int follow_ship(unit * u, order * ord)
/* NACH ignorieren und Parsing initialisieren. */ /* NACH ignorieren und Parsing initialisieren. */
init_tokens_str(command); init_tokens_str(command);
getstrtoken(); getstrtoken();
/* NACH ausführen */ /* NACH ausfuehren */
move_cmd(u, ord); move_cmd(u, ord);
return 1; /* true -> Einheitenliste von vorne durchgehen */ return 1; /* true -> Einheitenliste von vorne durchgehen */
} }
@ -2499,7 +2499,7 @@ void movement(void)
if (repeat) if (repeat)
continue; continue;
if (ships == 0) { if (ships == 0) {
/* Abtreiben von beschädigten, unterbemannten, überladenen Schiffen */ /* Abtreiben von beschaedigten, unterbemannten, ueberladenen Schiffen */
drifting_ships(r); drifting_ships(r);
} }
r = r->next; r = r->next;

15
src/orderfile.c
View File

@ -108,7 +108,7 @@ static void unitorders(input *in, faction *f)
} }
} }
} }
/* Nun wird der Befehl erzeut und eingeh<EFBFBD>ngt */ /* Nun wird der Befehl erzeut und eingehaengt */
*ordp = parse_order(s, u->faction->locale); *ordp = parse_order(s, u->faction->locale);
if (*ordp) { if (*ordp) {
ordp = &(*ordp)->next; ordp = &(*ordp)->next;
@ -137,7 +137,7 @@ static faction *factionorders(void)
return 0; return 0;
} }
/* Die Partei hat sich zumindest gemeldet, so dass sie noch /* Die Partei hat sich zumindest gemeldet, so dass sie noch
* nicht als unt<EFBFBD>tig gilt */ * nicht als untaetig gilt */
f->lastorders = turn; f->lastorders = turn;
} }
@ -201,11 +201,12 @@ int read_orders(input *in)
break; break;
/* Falls in unitorders() abgebrochen wird, steht dort entweder eine neue /* Falls in unitorders() abgebrochen wird, steht dort entweder eine neue
* Partei, eine neue Einheit oder das File-Ende. Das switch() wird erneut * Partei, eine neue Einheit oder das File-Ende. Das switch() wird erneut
* durchlaufen, und die entsprechende Funktion aufgerufen. Man darf buf * durchlaufen, und die entsprechende Funktion aufgerufen. Man darf buf
* auf alle F<EFBFBD>lle nicht <EFBFBD>berschreiben! Bei allen anderen Eintr<EFBFBD>gen hier * auf alle Faelle nicht ueberschreiben! Bei allen anderen Eintraegen hier
* muss buf erneut gef<EFBFBD>llt werden, da die betreffende Information in nur * muss buf erneut gefaellt werden, da die betreffende Information in nur
* einer Zeile steht, und nun die n<EFBFBD>chste gelesen werden muss. */ * einer Zeile steht, und nun die naechste gelesen werden muss.
*/
case P_NEXT: case P_NEXT:
f = NULL; f = NULL;

2
src/races/races.c
View File

@ -75,7 +75,7 @@ void equip_newunits(struct unit *u)
} }
} }
/* Die Funktionen werden <EFBFBD>ber den hier registrierten Namen in races.xml /* Die Funktionen werden ueber den hier registrierten Namen in races.xml
* in die jeweilige Rassendefiniton eingebunden */ * in die jeweilige Rassendefiniton eingebunden */
void register_races(void) void register_races(void)
{ {

16
src/randenc.c
View File

@ -75,7 +75,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
extern struct attrib_type at_unitdissolve; extern struct attrib_type at_unitdissolve;
/* In a->data.ca[1] steht der Prozentsatz mit dem sich die Einheit /* In a->data.ca[1] steht der Prozentsatz mit dem sich die Einheit
* aufl<EFBFBD>st, in a->data.ca[0] kann angegeben werden, wohin die Personen * aufloest, in a->data.ca[0] kann angegeben werden, wohin die Personen
* verschwinden. Passiert bereits in der ersten Runde! */ * verschwinden. Passiert bereits in der ersten Runde! */
static void dissolve_units(void) static void dissolve_units(void)
{ {
@ -187,12 +187,12 @@ static void melt_iceberg(region * r, const terrain_type *t_ocean)
ADDMSG(&u->faction->msgs, msg_message("iceberg_melt", "region", r)); ADDMSG(&u->faction->msgs, msg_message("iceberg_melt", "region", r));
} }
/* driftrichtung l<EFBFBD>schen */ /* driftrichtung loeschen */
a = a_find(r->attribs, &at_iceberg); a = a_find(r->attribs, &at_iceberg);
if (a) if (a)
a_remove(&r->attribs, a); a_remove(&r->attribs, a);
/* Geb<EFBFBD>ude l<>schen */ /* Gebaeude loeschen */
while (r->buildings) { while (r->buildings) {
remove_building(&r->buildings, r->buildings); remove_building(&r->buildings, r->buildings);
} }
@ -260,13 +260,13 @@ static void move_iceberg(region * r)
freset(sh, SF_SELECT); freset(sh, SF_SELECT);
for (sh = r->ships; sh; sh = sh->next) { for (sh = r->ships; sh; sh = sh->next) {
/* Meldung an Kapit<EFBFBD>n */ /* Meldung an Kapitaen */
double dmg = config_get_flt("rules.ship.damage.intoiceberg", 0.1); double dmg = config_get_flt("rules.ship.damage.intoiceberg", 0.1);
damage_ship(sh, dmg); damage_ship(sh, dmg);
fset(sh, SF_SELECT); fset(sh, SF_SELECT);
} }
/* Personen, Schiffe und Geb<EFBFBD>ude verschieben */ /* Personen, Schiffe und Gebaeude verschieben */
while (rc->buildings) { while (rc->buildings) {
rc->buildings->region = r; rc->buildings->region = r;
translist(&rc->buildings, &r->buildings, rc->buildings); translist(&rc->buildings, &r->buildings, rc->buildings);
@ -285,7 +285,7 @@ static void move_iceberg(region * r)
u_set_building(u, b); /* undo leave-prevention */ u_set_building(u, b); /* undo leave-prevention */
} }
/* Besch<EFBFBD>digte Schiffe k<>nnen sinken */ /* Beschaedigte Schiffe koennen sinken */
for (sh = r->ships; sh;) { for (sh = r->ships; sh;) {
shn = sh->next; shn = sh->next;
@ -475,7 +475,7 @@ static void orc_growth(void)
} }
} }
/** Talente von D<EFBFBD>monen verschieben sich. /** Talente von Daemonen verschieben sich.
*/ */
static void demon_skillchanges(void) static void demon_skillchanges(void)
{ {
@ -505,7 +505,7 @@ static void icebergs(void)
move_icebergs(); move_icebergs();
} }
#define HERBROTCHANCE 5 /* Verrottchance f<EFBFBD>r Kr<4B>uter (ifdef HERBS_ROT) */ #define HERBROTCHANCE 5 /* Verrottchance fuer Kraeuter (ifdef HERBS_ROT) */
static void rotting_herbs(void) static void rotting_herbs(void)
{ {

6
src/tools/namegen.c
View File

@ -125,7 +125,7 @@ static char *entish_syllable2[] = {
}; };
static char *entish_syllable3[] = { static char *entish_syllable3[] = {
"Hueter", "Pflanzer", "Hirte", "Waechter", "Wachser", "Beschützer", "H\xc3\xbcter", "Pflanzer", "Hirte", "W\xc3\xa4chter", "Wachser", "Besch\xc3\xbctzer",
}; };
static char *cthuloid_syllable1[] = { static char *cthuloid_syllable1[] = {
@ -200,13 +200,13 @@ static char *create_random_name(race_t race)
strcat(name, strcat(name,
orc_syllable3[rand() % (sizeof(orc_syllable3) / sizeof(char *))]); orc_syllable3[rand() % (sizeof(orc_syllable3) / sizeof(char *))]);
break; break;
/*
case RC_TREEMAN: case RC_TREEMAN:
strcpy(name, entish_syllable1[rand()%(sizeof(entish_syllable1) / sizeof(char*))]); strcpy(name, entish_syllable1[rand()%(sizeof(entish_syllable1) / sizeof(char*))]);
strcat(name, entish_syllable2[rand()%(sizeof(entish_syllable2) / sizeof(char*))]); strcat(name, entish_syllable2[rand()%(sizeof(entish_syllable2) / sizeof(char*))]);
strcat(name, entish_syllable3[rand()%(sizeof(entish_syllable3) / sizeof(char*))]); strcat(name, entish_syllable3[rand()%(sizeof(entish_syllable3) / sizeof(char*))]);
break; break;
*/
case RC_DAEMON: case RC_DAEMON:
case RC_INSECT: case RC_INSECT:
strcpy(name, strcpy(name,

8
src/volcano.c
View File

@ -55,7 +55,7 @@ static int nb_armor(const unit * u, int index)
if (!(u_race(u)->battle_flags & BF_EQUIPMENT)) if (!(u_race(u)->battle_flags & BF_EQUIPMENT))
return 0; return 0;
/* Normale R<EFBFBD>stung */ /* Normale Ruestung */
for (itm = u->items; itm; itm = itm->next) { for (itm = u->items; itm; itm = itm->next) {
const armor_type *atype = itm->type->rtype->atype; const armor_type *atype = itm->type->rtype->atype;
@ -186,11 +186,11 @@ static region *rrandneighbour(region * r)
for (i = 0; i != MAXDIRECTIONS; i++) { for (i = 0; i != MAXDIRECTIONS; i++) {
c++; c++;
} }
/* Zuf<EFBFBD>llig eine ausw<73>hlen */ /* Zufaellig eine auswaehlen */
rr = rng_int() % c; rr = rng_int() % c;
/* Durchz<EFBFBD>hlen */ /* Durchzaehlen */
c = -1; c = -1;
for (i = 0; i != MAXDIRECTIONS; i++) { for (i = 0; i != MAXDIRECTIONS; i++) {
@ -221,7 +221,7 @@ volcano_destruction(region * volcano, region * r, const char *damage)
else { else {
/* Produktion vierteln ... */ /* Produktion vierteln ... */
a->data.sa[0] = (short)percent; a->data.sa[0] = (short)percent;
/* F<EFBFBD>r 6-17 Runden */ /* Fuer 6-17 Runden */
a->data.sa[1] = (short)(a->data.sa[1] + time); a->data.sa[1] = (short)(a->data.sa[1] + time);
} }