forked from github/server
umlaut substitutions
This commit is contained in:
Enno Rehling
parent
9e44b8a989
commit
debb86601b
|
|
@ -136,7 +136,7 @@ static void chaos(region * r)
|
|||
u->flags |= (UFL_ISNEW | UFL_MOVED);
|
||||
}
|
||||
break;
|
||||
case 2: /* Terrainver<EFBFBD>nderung */
|
||||
case 2: /* Terrainveraenderung */
|
||||
if (!(r->terrain->flags & FORBIDDEN_REGION)) {
|
||||
if (!(r->terrain->flags & SEA_REGION)) {
|
||||
direction_t dir;
|
||||
|
|
|
|||
|
|
@ -232,7 +232,7 @@ static unit *setup_trade_unit(CuTest *tc, region *r, const struct race *rc) {
|
|||
}
|
||||
|
||||
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;
|
||||
region *r;
|
||||
const item_type *it_luxury;
|
||||
|
|
|
|||
|
|
@ -136,15 +136,15 @@ struct order *ord)
|
|||
UNUSED_ARG(ord);
|
||||
assert(sp);
|
||||
|
||||
/* Reduziert die St<EFBFBD>rke jedes Spruchs um effect */
|
||||
/* Reduziert die Staerke jedes Spruchs um effect */
|
||||
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
|
||||
* um seine Stufe */
|
||||
force = effect * 20.0; /* Stufe 5 =~ 100 */
|
||||
|
||||
/* Regionszauber aufl<EFBFBD>sen */
|
||||
/* Regionszauber aufloesen */
|
||||
while (*ap && force > 0) {
|
||||
curse *c;
|
||||
attrib *a = *ap;
|
||||
|
|
@ -156,7 +156,7 @@ struct order *ord)
|
|||
}
|
||||
c = (curse *)a->data.v;
|
||||
|
||||
/* Immunit<EFBFBD>t pr<70>fen */
|
||||
/* Immunitaet pruefen */
|
||||
if (c_flags(c) & CURSE_IMMUNE) {
|
||||
do {
|
||||
ap = &(*ap)->next;
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@
|
|||
|
||||
attrib_type at_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)
|
||||
|
|
|
|||
204
src/magic.c
204
src/magic.c
|
|
@ -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 */
|
||||
/* ------------------------------------------------------------- */
|
||||
|
||||
|
|
@ -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)
|
||||
{
|
||||
|
|
@ -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)
|
||||
{
|
||||
|
|
@ -591,8 +591,9 @@ void unset_combatspell(unit * u, spell * sp)
|
|||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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
|
||||
*/
|
||||
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
|
||||
* haben.
|
||||
* Manche Rassen haben einen zusätzlichen Multiplikator
|
||||
* Durch Talentverlust (zB Insekten im Berg) können negative Werte
|
||||
* Manche Rassen haben einen zusaetzlichen Multiplikator
|
||||
* Durch Talentverlust (zB Insekten im Berg) koennen negative Werte
|
||||
* entstehen
|
||||
*/
|
||||
|
||||
/* Artefakt der Stärke
|
||||
* Ermöglicht dem Magier mehr Magiepunkte zu 'speichern'
|
||||
/* Artefakt der Staerke
|
||||
* Ermoeglicht dem Magier mehr Magiepunkte zu 'speichern'
|
||||
*/
|
||||
/** TODO: at_skillmod daraus machen */
|
||||
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)
|
||||
{
|
||||
|
|
@ -710,8 +712,8 @@ int spellcount(const unit *u) {
|
|||
}
|
||||
|
||||
/**
|
||||
* Die Grundkosten pro Stufe werden um 2^count erhöht. countspells(u)
|
||||
* ist dabei die Anzahl der bereits gezauberten Sprüche
|
||||
* Die Grundkosten pro Stufe werden um 2^count erhoeht. countspells(u)
|
||||
* ist dabei die Anzahl der bereits gezauberten Sprueche
|
||||
*/
|
||||
int aura_multiplier(const unit * 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) {
|
||||
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.
|
||||
* 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
|
||||
* niedrigstwertigen und sollte von den beiden anderen Typen
|
||||
* überschrieben werden */
|
||||
* ueberschrieben werden */
|
||||
static int spl_costtyp(const spell * sp)
|
||||
{
|
||||
int k;
|
||||
|
|
@ -765,7 +767,7 @@ static int spl_costtyp(const spell * sp)
|
|||
return SPC_LINEAR;
|
||||
}
|
||||
|
||||
/* wenn keine Fixkosten, Typ übernehmen */
|
||||
/* wenn keine Fixkosten, Typ uebernehmen */
|
||||
if (sp->components[k].cost != SPC_FIX) {
|
||||
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
|
||||
* ersten Fehler abbricht, muss die Fehlermeldung später mit cancast()
|
||||
* ersten Fehler abbricht, muss die Fehlermeldung spaeter mit cancast()
|
||||
* generiert werden.
|
||||
*/
|
||||
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;
|
||||
|
||||
/* 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 (maxlevel < 1)
|
||||
cast_level = 0;
|
||||
/* ansonsten wird das Minimum aus maximal möglicher Stufe und der
|
||||
* gewünschten gebildet */
|
||||
/* ansonsten wird das Minimum aus maximal moeglicher Stufe und der
|
||||
* gewuenschten gebildet */
|
||||
}
|
||||
else if (sp->components[k].cost == SPC_LEVEL) {
|
||||
costtyp = SPC_LEVEL;
|
||||
if (maxlevel < cast_level) {
|
||||
cast_level = maxlevel;
|
||||
}
|
||||
/* bei Typ Linear müssen die Kosten in Höhe der Stufe vorhanden
|
||||
* sein, ansonsten schlägt der Spruch fehl */
|
||||
/* bei Typ Linear muessen die Kosten in Hoehe der Stufe vorhanden
|
||||
* sein, ansonsten schlaegt der Spruch fehl */
|
||||
}
|
||||
else if (sp->components[k].cost == 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)
|
||||
* 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
|
||||
* 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
|
||||
* 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.
|
||||
*/
|
||||
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
|
||||
* Spruchs besitzen, nicht nur wissen, das es ihn gibt (also den Spruch
|
||||
* 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.
|
||||
*/
|
||||
|
||||
|
|
@ -899,7 +901,7 @@ cancast(unit * u, const spell * sp, int level, int range, struct order * ord)
|
|||
}
|
||||
/* reicht die Stufe aus? */
|
||||
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);
|
||||
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;
|
||||
int itemhave, itemanz;
|
||||
|
||||
/* Die Kosten für Aura sind auch von der Zahl der bereits
|
||||
* gezauberten Sprüche abhängig */
|
||||
/* Die Kosten fuer Aura sind auch von der Zahl der bereits
|
||||
* gezauberten Sprueche abhaengig */
|
||||
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 */
|
||||
switch (spc->cost) {
|
||||
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
|
||||
* 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.
|
||||
*/
|
||||
|
||||
|
|
@ -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 */
|
||||
static int farcasting(unit * magician, region * r)
|
||||
{
|
||||
|
|
@ -1136,7 +1138,7 @@ variant magic_resistance(unit * target)
|
|||
/* Bonus durch Artefakte */
|
||||
/* TODO (noch gibs keine) */
|
||||
|
||||
/* Bonus durch Gebäude */
|
||||
/* Bonus durch Gebaeude */
|
||||
{
|
||||
struct building *b = inside_building(target);
|
||||
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.
|
||||
* Objekte können Regionen, Units, Gebäude oder Schiffe sein.
|
||||
/* Prueft, ob das Objekt dem Zauber widerstehen kann.
|
||||
* Objekte koennen Regionen, Units, Gebaeude oder Schiffe sein.
|
||||
* TYP_UNIT:
|
||||
* Das höchste Talent des Ziels ist sein 'Magieresistenz-Talent', Magier
|
||||
* bekommen einen Bonus. Grundchance ist 50%, für jede Stufe
|
||||
* Unterschied gibt es 5%, minimalchance ist 5% für jeden (5-95%)
|
||||
* Das hoechste Talent des Ziels ist sein 'Magieresistenz-Talent', Magier
|
||||
* bekommen einen Bonus. Grundchance ist 50%, fuer jede Stufe
|
||||
* Unterschied gibt es 5%, minimalchance ist 5% fuer jeden (5-95%)
|
||||
* Scheitert der Spruch an der Magieresistenz, so gibt die Funktion
|
||||
* true zurück
|
||||
* true zurueck
|
||||
*/
|
||||
|
||||
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
|
||||
* false, wenn sie gleich oder größer ist, dh je größer die
|
||||
* Magieresistenz (chance) desto eher gibt die Funktion true zurück */
|
||||
* false, wenn sie gleich oder groesser ist, dh je groesser die
|
||||
* Magieresistenz (chance) desto eher gibt die Funktion true zurueck */
|
||||
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.
|
||||
* 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
|
||||
* */
|
||||
|
||||
|
|
@ -1298,8 +1300,8 @@ bool fumble(region * r, unit * u, const spell * sp, int cast_grade)
|
|||
fumble_chance += CHAOSPATZERCHANCE;
|
||||
}
|
||||
|
||||
/* wenn die Chance kleiner als 0 ist, können wir gleich false
|
||||
* zurückgeben */
|
||||
/* wenn die Chance kleiner als 0 ist, koennen wir gleich false
|
||||
* zurueckgeben */
|
||||
if (fumble_chance <= 0) {
|
||||
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 */
|
||||
static void fumble_default(castorder * co)
|
||||
{
|
||||
|
|
@ -1320,7 +1322,7 @@ static void fumble_default(castorder * co)
|
|||
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
|
||||
*/
|
||||
|
||||
|
|
@ -1391,7 +1393,7 @@ static void do_fumble(castorder * co)
|
|||
break;
|
||||
case 3:
|
||||
case 4:
|
||||
/* Spruch schlägt fehl, alle Magiepunkte weg */
|
||||
/* Spruch schlaegt fehl, alle Magiepunkte weg */
|
||||
set_spellpoints(mage, 0);
|
||||
ADDMSG(&mage->faction->msgs, msg_message("patzer3", "unit region spell",
|
||||
mage, r, sp));
|
||||
|
|
@ -1410,7 +1412,7 @@ static void do_fumble(castorder * co)
|
|||
case 8:
|
||||
case 9:
|
||||
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);
|
||||
ADDMSG(&mage->faction->msgs, msg_message("patzer5", "unit region spell",
|
||||
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
|
||||
* Zwerge nur die Hälfte
|
||||
* Zwerge nur die Haelfte
|
||||
*/
|
||||
static double regeneration(unit * u)
|
||||
{
|
||||
|
|
@ -1440,7 +1442,7 @@ static double regeneration(unit * u)
|
|||
/* Einfluss von Artefakten */
|
||||
/* TODO (noch gibs keine) */
|
||||
|
||||
/* Würfeln */
|
||||
/* Wuerfeln */
|
||||
aura = (rng_double() * d + rng_double() * d) / 2 + 1;
|
||||
|
||||
aura *= MagicRegeneration();
|
||||
|
|
@ -1470,8 +1472,8 @@ void regenerate_aura(void)
|
|||
const struct building_type *btype = building_is_active(b) ? b->type : NULL;
|
||||
reg_aura = regeneration(u);
|
||||
|
||||
/* Magierturm erhöht die Regeneration um 75% */
|
||||
/* Steinkreis erhöht die Regeneration um 50% */
|
||||
/* Magierturm erhoeht die Regeneration um 75% */
|
||||
/* Steinkreis erhoeht die Regeneration um 50% */
|
||||
if (btype)
|
||||
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
|
||||
* oder zu prüfen, ob das gefundene Objekt wirklich hätte gefunden
|
||||
* werden dürfen (nicht alle Zauber wirken global). Dabei zählen wir die
|
||||
* oder zu pruefen, ob das gefundene Objekt wirklich haette gefunden
|
||||
* werden duerfen (nicht alle Zauber wirken global). Dabei zaehlen wir die
|
||||
* Misserfolge (failed).
|
||||
* 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) */
|
||||
|
||||
/* 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 */
|
||||
static void
|
||||
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;
|
||||
/* zuerst versuchen wir vorher nicht gefundene Objekte zu finden.
|
||||
* Wurde ein Objekt durch globalsuche gefunden, obwohl der Zauber
|
||||
* gar nicht global hätte suchen dürften, setzen wir das Objekt
|
||||
* zurück. */
|
||||
* gar nicht global haette suchen duerften, setzen wir das Objekt
|
||||
* zurueck. */
|
||||
for (i = 0; i < sa->length; i++) {
|
||||
spllprm *spobj = sa->param[i];
|
||||
|
||||
|
|
@ -1723,7 +1725,7 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success)
|
|||
|
||||
case SPP_REGION:
|
||||
/* haben wir ein Regionsobjekt, dann wird auch dieses und
|
||||
nicht target_r überprüft. */
|
||||
nicht target_r ueberprueft. */
|
||||
tr = spobj->data.r;
|
||||
|
||||
if ((sp->sptyp & TESTRESISTANCE)
|
||||
|
|
@ -1749,7 +1751,7 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success)
|
|||
else {
|
||||
/* der Zauber hat keine expliziten Parameter/Ziele, es kann sich
|
||||
* aber um einen Regionszauber handeln. Wenn notwendig hier die
|
||||
* Magieresistenz der Region prüfen. */
|
||||
* Magieresistenz der Region pruefen. */
|
||||
if ((sp->sptyp & REGIONSPELL)) {
|
||||
/* Zielobjekt Region anlegen */
|
||||
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)
|
||||
|
|
@ -1979,7 +1981,7 @@ static spellparameter *add_spellparameter(region * target_r, unit * u,
|
|||
break;
|
||||
case '+':
|
||||
/* das vorhergehende Element kommt ein oder mehrmals vor, wir
|
||||
* springen zum key zurück */
|
||||
* springen zum key zurueck */
|
||||
j = 0;
|
||||
--c;
|
||||
break;
|
||||
|
|
@ -2116,7 +2118,7 @@ void free_castorder(struct castorder *co)
|
|||
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)
|
||||
{
|
||||
if (cll->begin == NULL) {
|
||||
|
|
@ -2546,7 +2548,7 @@ static castorder *cast_cmd(unit * u, order * ord)
|
|||
init_order_depr(ord);
|
||||
s = gettoken(token, sizeof(token));
|
||||
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) {
|
||||
int p = getint();
|
||||
if (level > p) level = p;
|
||||
|
|
@ -2575,8 +2577,8 @@ static castorder *cast_cmd(unit * u, order * ord)
|
|||
s = gettoken(token, sizeof(token));
|
||||
param = findparam(s, u->faction->locale);
|
||||
}
|
||||
/* für Syntax ' REGION x y STUFE z '
|
||||
* hier nach REGION nochmal auf STUFE prüfen */
|
||||
/* fuer Syntax ' REGION x y STUFE z '
|
||||
* hier nach REGION nochmal auf STUFE pruefen */
|
||||
if (param == P_LEVEL) {
|
||||
int p = getint();
|
||||
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);
|
||||
|
||||
/* Vertraute können auch Zauber sprechen, die sie selbst nicht
|
||||
* können. unit_getspell findet aber nur jene Sprüche, die
|
||||
/* Vertraute koennen auch Zauber sprechen, die sie selbst nicht
|
||||
* koennen. unit_getspell findet aber nur jene Sprueche, die
|
||||
* die Einheit beherrscht. */
|
||||
if (!sp && is_familiar(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
|
||||
* fehlermeldungen die anzeigen das der magier diesen Spruch
|
||||
* nur in diese Situation nicht anwenden kann, noch eine
|
||||
* einfache Sicherheitsprüfung kommen */
|
||||
* einfache Sicherheitspruefung kommen */
|
||||
if (!knowsspell(r, u, sp)) {
|
||||
/* vorsicht! u kann der familiar sein */
|
||||
if (!familiar) {
|
||||
|
|
@ -2632,9 +2634,9 @@ static castorder *cast_cmd(unit * u, order * ord)
|
|||
cmistake(u, ord, 174, MSG_MAGIC);
|
||||
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
|
||||
* OCEANCASTABLE deklarierte Sprüche */
|
||||
* OCEANCASTABLE deklarierte Sprueche */
|
||||
if (fval(r->terrain, SEA_REGION)) {
|
||||
if (u_race(u) != get_race(RC_AQUARIAN)
|
||||
&& !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);
|
||||
if (range > 1) {
|
||||
if (!(sp->sptyp & FARCASTING)) {
|
||||
|
|
@ -2672,7 +2674,7 @@ static castorder *cast_cmd(unit * u, order * ord)
|
|||
return 0;
|
||||
}
|
||||
}
|
||||
/* Stufenangabe bei nicht Stufenvariierbaren Sprüchen abfangen */
|
||||
/* Stufenangabe bei nicht Stufenvariierbaren Spruechen abfangen */
|
||||
if (!(sp->sptyp & SPELLLEVEL)) {
|
||||
int ilevel = effskill(u, SK_MAGIC, NULL);
|
||||
if (ilevel != level) {
|
||||
|
|
@ -2707,7 +2709,7 @@ static castorder *cast_cmd(unit * u, order * ord)
|
|||
"mage", mage));
|
||||
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 */
|
||||
range *= 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
|
||||
* Bewegung zaubern. Magier sind also in einem fremden Gebiet eine Runde
|
||||
* lang verletzlich, da sie es betreten, und angegriffen werden können,
|
||||
* bevor sie ein Ritual machen können.
|
||||
* lang verletzlich, da sie es betreten, und angegriffen werden koennen,
|
||||
* bevor sie ein Ritual machen koennen.
|
||||
*
|
||||
* Syntax: ZAUBER [REGION X Y] [STUFE <stufe>] "Spruchname" [Einheit-1
|
||||
* 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
|
||||
* entstandenen Spruchkosten entspricht. Sind die Spruchkosten nicht
|
||||
* levelabhängig, so sind die Kosten nur von der Entfernung bestimmt,
|
||||
* die Stärke/Level durch den realen Skill des Magiers
|
||||
* levelabhaengig, so sind die Kosten nur von der Entfernung bestimmt,
|
||||
* die Staerke/Level durch den realen Skill des Magiers
|
||||
*/
|
||||
|
||||
void magic(void)
|
||||
|
|
@ -2800,11 +2802,11 @@ void magic(void)
|
|||
}
|
||||
}
|
||||
|
||||
/* Da sich die Aura und Komponenten in der Zwischenzeit verändert
|
||||
* haben können und sich durch vorherige Sprüche das Zaubern
|
||||
* erschwert haben kann, muss beim zaubern erneut geprüft werden, ob der
|
||||
* Spruch überhaupt gezaubert werden kann.
|
||||
* (level) die effektive Stärke des Spruchs (= Stufe, auf der der
|
||||
/* Da sich die Aura und Komponenten in der Zwischenzeit veraendert
|
||||
* haben koennen und sich durch vorherige Sprueche das Zaubern
|
||||
* erschwert haben kann, muss beim zaubern erneut geprueft werden, ob der
|
||||
* Spruch ueberhaupt gezaubert werden kann.
|
||||
* (level) die effektive Staerke des Spruchs (= Stufe, auf der der
|
||||
* Spruch gezaubert wird) */
|
||||
|
||||
for (rank = 0; rank < MAX_SPELLRANK; rank++) {
|
||||
|
|
@ -2828,30 +2830,30 @@ void magic(void)
|
|||
}
|
||||
|
||||
if (cast_level > co->level) {
|
||||
/* Sprüche mit Fixkosten werden immer auf Stufe des Spruchs
|
||||
* gezaubert, co->level ist aber defaultmäßig Stufe des Magiers */
|
||||
/* Sprueche mit Fixkosten werden immer auf Stufe des Spruchs
|
||||
* gezaubert, co->level ist aber defaultmaessig Stufe des Magiers */
|
||||
if (spl_costtyp(sp) != SPC_FIX) {
|
||||
ADDMSG(&mage->faction->msgs, msg_message("missing_components",
|
||||
"unit spell level", mage, sp, cast_level));
|
||||
}
|
||||
}
|
||||
|
||||
/* Prüfen, ob die realen Kosten für die gewünschten Stufe bezahlt
|
||||
* werden können */
|
||||
/* Pruefen, ob die realen Kosten fuer die gewuenschten Stufe bezahlt
|
||||
* werden koennen */
|
||||
if (!cancast(mage, sp, co->level, co->distance, ord)) {
|
||||
/* die Fehlermeldung wird in cancast generiert */
|
||||
continue;
|
||||
}
|
||||
|
||||
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) {
|
||||
co->force = 0;
|
||||
ADDMSG(&mage->faction->msgs, msg_message("missing_force",
|
||||
"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
|
||||
* Spruch an der Magieresistenz, so ist verify_targets = 1, bei
|
||||
* Erfolg auf ganzer Linie ist verify_targets= 2
|
||||
|
|
@ -2859,8 +2861,8 @@ void magic(void)
|
|||
verify_targets(co, &invalid, &resist, &success);
|
||||
if (success + resist == 0) {
|
||||
/* kein Ziel gefunden, Fehlermeldungen sind in verify_targets */
|
||||
/* keine kosten für den zauber */
|
||||
continue; /* äußere Schleife, nächster Zauberer */
|
||||
/* keine kosten fuer den zauber */
|
||||
continue; /* aeussere Schleife, naechster Zauberer */
|
||||
}
|
||||
else if (co->force > 0 && resist > 0) {
|
||||
/* einige oder alle Ziele waren magieresistent */
|
||||
|
|
@ -2873,8 +2875,8 @@ void magic(void)
|
|||
}
|
||||
}
|
||||
|
||||
/* Auch für Patzer gibt es Erfahrung, müssen die Spruchkosten
|
||||
* bezahlt werden und die nachfolgenden Sprüche werden teurer */
|
||||
/* Auch fuer Patzer gibt es Erfahrung, muessen die Spruchkosten
|
||||
* bezahlt werden und die nachfolgenden Sprueche werden teurer */
|
||||
if (co->force > 0) {
|
||||
if (fumble(target_r, mage, sp, co->level)) {
|
||||
/* zuerst bezahlen, dann evt in do_fumble alle Aura verlieren */
|
||||
|
|
@ -2883,12 +2885,12 @@ void magic(void)
|
|||
else {
|
||||
co->level = cast_spell(co);
|
||||
if (co->level <= 0) {
|
||||
/* Kosten nur für real benötige Stufe berechnen */
|
||||
/* Kosten nur fuer real benoetige Stufe berechnen */
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* erst bezahlen, dann Kostenzähler erhöhen */
|
||||
/* erst bezahlen, dann Kostenzaehler erhoehen */
|
||||
if (co->level > 0) {
|
||||
pay_spell(mage, caster, sp, co->level, co->distance);
|
||||
}
|
||||
|
|
|
|||
72
src/move.c
72
src/move.c
|
|
@ -108,7 +108,7 @@ static attrib_type at_traveldir = {
|
|||
"traveldir",
|
||||
DEFAULT_INIT,
|
||||
DEFAULT_FINALIZE,
|
||||
DEFAULT_AGE, /* Weil normales Aging an ungünstiger Stelle */
|
||||
DEFAULT_AGE, /* Weil normales Aging an unguenstiger Stelle */
|
||||
a_writechars,
|
||||
a_readchars
|
||||
};
|
||||
|
|
@ -267,8 +267,8 @@ static int ridingcapacity(const unit * u)
|
|||
|
||||
get_transporters(u->items, &animals, &acap, &vehicles, &vcap);
|
||||
|
||||
/* Man trägt sein eigenes Gewicht plus seine Kapazität! Die Menschen
|
||||
** tragen nichts (siehe walkingcapacity). Ein Wagen zählt nur, wenn er
|
||||
/* Man traegt sein eigenes Gewicht plus seine Kapazitaet! Die Menschen
|
||||
** tragen nichts (siehe walkingcapacity). Ein Wagen zaehlt nur, wenn er
|
||||
** von zwei Pferden gezogen wird */
|
||||
|
||||
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))
|
||||
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;
|
||||
if (horses < vehicles) vehicles = horses;
|
||||
|
||||
|
|
@ -308,7 +308,7 @@ int walkingcapacity(const struct unit *u)
|
|||
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;
|
||||
wagen_mit_pferden = (vehicles < horses) ? vehicles : horses;
|
||||
|
||||
|
|
@ -326,7 +326,7 @@ int walkingcapacity(const struct unit *u)
|
|||
wagen_mit_trollen = wagen_ohne_pferde;
|
||||
}
|
||||
|
||||
/* Wagenkapazität hinzuzählen */
|
||||
/* Wagenkapazitaet hinzuzaehlen */
|
||||
n += wagen_mit_trollen * vcap;
|
||||
}
|
||||
|
||||
|
|
@ -390,15 +390,15 @@ static int canwalk(unit * u)
|
|||
if (walkingcapacity(u) - eff_weight(u) >= 0)
|
||||
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
|
||||
* die Einheit nicht zum Ziehen benutzt, also nicht mehr Wagen gezogen
|
||||
* als erlaubt. */
|
||||
|
||||
if (vehicles > maxwagen)
|
||||
return E_CANWALK_TOOMANYCARTS;
|
||||
/* Es muß nicht zwingend an den Wagen liegen, aber egal... (man
|
||||
* könnte z.B. auch 8 Eisen abladen, damit ein weiterer Wagen als
|
||||
/* Es muss nicht zwingend an den Wagen liegen, aber egal... (man
|
||||
* koennte z.B. auch 8 Eisen abladen, damit ein weiterer Wagen als
|
||||
* Fracht draufpasst) */
|
||||
|
||||
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");
|
||||
|
||||
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);
|
||||
|
||||
if (u && is_freezing(u)) {
|
||||
|
|
@ -828,19 +828,19 @@ static void drifting_ships(region * r)
|
|||
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)) {
|
||||
shp = &sh->next;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Kapitän bestimmen */
|
||||
/* Kapitaen bestimmen */
|
||||
captain = ship_owner(sh);
|
||||
if (captain && effskill(captain, SK_SAILING, r) < sh->type->cptskill)
|
||||
captain = NULL;
|
||||
|
||||
/* Kapitän da? Beschädigt? Genügend Matrosen?
|
||||
* Genügend leicht? Dann ist alles OK. */
|
||||
/* Kapitaen da? Beschaedigt? Genuegend Matrosen?
|
||||
* Genuegend leicht? Dann ist alles OK. */
|
||||
|
||||
if (captain && sh->size == sh->type->construction->maxsize
|
||||
&& enoughsailors(sh, crew_skill(sh)) && cansail(r, sh)) {
|
||||
|
|
@ -851,7 +851,7 @@ static void drifting_ships(region * r)
|
|||
ovl = overload(r, sh);
|
||||
if (ovl < overload_start()) {
|
||||
/* 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);
|
||||
if (dir != NODIRECTION) {
|
||||
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
|
||||
*
|
||||
* zu Fuß reist man 1 Region, zu Pferd 2 Regionen. Mit Straßen reist
|
||||
* man zu Fuß 2, mit Pferden 3 weit.
|
||||
* zu Fuss reist man 1 Region, zu Pferd 2 Regionen. Mit Strassen reist
|
||||
* man zu Fuss 2, mit Pferden 3 weit.
|
||||
*
|
||||
* Berechnet wird das mit BPs. Zu Fuß hat man 4 BPs, zu Pferd 6.
|
||||
* Normalerweise verliert man 3 BP pro Region, bei Straßen nur 2 BP.
|
||||
* Außerdem: Wenn Einheit transportiert, nur halbe BP
|
||||
* Berechnet wird das mit BPs. Zu Fuss hat man 4 BPs, zu Pferd 6.
|
||||
* Normalerweise verliert man 3 BP pro Region, bei Strassen nur 2 BP.
|
||||
* Ausserdem: Wenn Einheit transportiert, nur halbe BP
|
||||
*/
|
||||
int movement_speed(const unit * u)
|
||||
{
|
||||
|
|
@ -1514,7 +1514,7 @@ static const region_list *travel_route(unit * u,
|
|||
landing = true;
|
||||
}
|
||||
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",
|
||||
"unit region terrain", u, next, terrain_name(next)));
|
||||
break;
|
||||
|
|
@ -1527,7 +1527,7 @@ static const region_list *travel_route(unit * u,
|
|||
}
|
||||
}
|
||||
else {
|
||||
/* Ozeanfelder können nur von Einheiten mit Schwimmen und ohne
|
||||
/* Ozeanfelder koennen nur von Einheiten mit Schwimmen und ohne
|
||||
* Pferde betreten werden. */
|
||||
if (!(canswim(u) || canfly(u))) {
|
||||
ADDMSG(&u->faction->msgs, msg_message("detectocean",
|
||||
|
|
@ -1626,7 +1626,7 @@ static const region_list *travel_route(unit * u,
|
|||
walkmode = 2;
|
||||
}
|
||||
|
||||
/* Berichte über Durchreiseregionen */
|
||||
/* Berichte ueber Durchreiseregionen */
|
||||
|
||||
if (mode != TRAVEL_TRANSPORTED) {
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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)
|
||||
{
|
||||
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;
|
||||
|
||||
/* Wir suchen so lange nach neuen Richtungen, wie es geht. Diese werden
|
||||
* dann nacheinander ausgeführt. */
|
||||
* dann nacheinander ausgefuehrt. */
|
||||
|
||||
k = shipspeed(sh, u);
|
||||
|
||||
last_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.
|
||||
*
|
||||
* 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. */
|
||||
|
||||
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;
|
||||
int d_offset = rng_int() % MAXDIRECTIONS;
|
||||
direction_t d;
|
||||
/* Sturm nur, wenn nächste Region Hochsee ist. */
|
||||
/* Sturm nur, wenn naechste Region Hochsee ist. */
|
||||
for (d = 0; d != MAXDIRECTIONS; ++d) {
|
||||
direction_t dnext = (direction_t)((d + d_offset) % MAXDIRECTIONS);
|
||||
region *rn = rconnect(current_point, dnext);
|
||||
|
|
@ -1933,16 +1933,16 @@ static void sail(unit * u, order * ord, region_list ** routep, bool drifting)
|
|||
sh = NULL;
|
||||
}
|
||||
|
||||
/* Nun enthält current_point die Region, in der das Schiff seine Runde
|
||||
* beendet hat. Wir generieren hier ein Ereignis für den Spieler, das
|
||||
* ihm sagt, bis wohin er gesegelt ist, falls er überhaupt vom Fleck
|
||||
* gekommen ist. Das ist nicht der Fall, wenn er von der Küste ins
|
||||
/* Nun enthaelt current_point die Region, in der das Schiff seine Runde
|
||||
* beendet hat. Wir generieren hier ein Ereignis fuer den Spieler, das
|
||||
* ihm sagt, bis wohin er gesegelt ist, falls er ueberhaupt vom Fleck
|
||||
* gekommen ist. Das ist nicht der Fall, wenn er von der Kueste ins
|
||||
* Inland zu segeln versuchte */
|
||||
|
||||
if (sh != NULL && fval(sh, SF_MOVED)) {
|
||||
unit *harbourmaster;
|
||||
/* 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) {
|
||||
order * norder = cycle_route(ord, u->faction->locale, step);
|
||||
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);
|
||||
|
||||
/* Hafengebühren ? */
|
||||
/* Hafengebuehren ? */
|
||||
|
||||
harbourmaster = owner_buildingtyp(current_point, bt_find("harbour"));
|
||||
if (harbourmaster != NULL) {
|
||||
|
|
@ -2316,7 +2316,7 @@ int follow_ship(unit * u, order * ord)
|
|||
/* NACH ignorieren und Parsing initialisieren. */
|
||||
init_tokens_str(command);
|
||||
getstrtoken();
|
||||
/* NACH ausführen */
|
||||
/* NACH ausfuehren */
|
||||
move_cmd(u, ord);
|
||||
return 1; /* true -> Einheitenliste von vorne durchgehen */
|
||||
}
|
||||
|
|
@ -2499,7 +2499,7 @@ void movement(void)
|
|||
if (repeat)
|
||||
continue;
|
||||
if (ships == 0) {
|
||||
/* Abtreiben von beschädigten, unterbemannten, überladenen Schiffen */
|
||||
/* Abtreiben von beschaedigten, unterbemannten, ueberladenen Schiffen */
|
||||
drifting_ships(r);
|
||||
}
|
||||
r = r->next;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
if (*ordp) {
|
||||
ordp = &(*ordp)->next;
|
||||
|
|
@ -137,7 +137,7 @@ static faction *factionorders(void)
|
|||
return 0;
|
||||
}
|
||||
/* Die Partei hat sich zumindest gemeldet, so dass sie noch
|
||||
* nicht als unt<EFBFBD>tig gilt */
|
||||
* nicht als untaetig gilt */
|
||||
f->lastorders = turn;
|
||||
|
||||
}
|
||||
|
|
@ -201,11 +201,12 @@ int read_orders(input *in)
|
|||
break;
|
||||
|
||||
/* Falls in unitorders() abgebrochen wird, steht dort entweder eine neue
|
||||
* Partei, eine neue Einheit oder das File-Ende. Das switch() wird erneut
|
||||
* durchlaufen, und die entsprechende Funktion aufgerufen. Man darf buf
|
||||
* auf alle F<EFBFBD>lle nicht <EFBFBD>berschreiben! Bei allen anderen Eintr<EFBFBD>gen hier
|
||||
* muss buf erneut gef<EFBFBD>llt werden, da die betreffende Information in nur
|
||||
* einer Zeile steht, und nun die n<EFBFBD>chste gelesen werden muss. */
|
||||
* Partei, eine neue Einheit oder das File-Ende. Das switch() wird erneut
|
||||
* durchlaufen, und die entsprechende Funktion aufgerufen. Man darf buf
|
||||
* auf alle Faelle nicht ueberschreiben! Bei allen anderen Eintraegen hier
|
||||
* muss buf erneut gefaellt werden, da die betreffende Information in nur
|
||||
* einer Zeile steht, und nun die naechste gelesen werden muss.
|
||||
*/
|
||||
|
||||
case P_NEXT:
|
||||
f = NULL;
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
void register_races(void)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|||
extern struct attrib_type at_unitdissolve;
|
||||
|
||||
/* 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! */
|
||||
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));
|
||||
}
|
||||
|
||||
/* driftrichtung l<EFBFBD>schen */
|
||||
/* driftrichtung loeschen */
|
||||
a = a_find(r->attribs, &at_iceberg);
|
||||
if (a)
|
||||
a_remove(&r->attribs, a);
|
||||
|
||||
/* Geb<EFBFBD>ude l<>schen */
|
||||
/* Gebaeude loeschen */
|
||||
while (r->buildings) {
|
||||
remove_building(&r->buildings, r->buildings);
|
||||
}
|
||||
|
|
@ -260,13 +260,13 @@ static void move_iceberg(region * r)
|
|||
freset(sh, SF_SELECT);
|
||||
|
||||
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);
|
||||
damage_ship(sh, dmg);
|
||||
fset(sh, SF_SELECT);
|
||||
}
|
||||
|
||||
/* Personen, Schiffe und Geb<EFBFBD>ude verschieben */
|
||||
/* Personen, Schiffe und Gebaeude verschieben */
|
||||
while (rc->buildings) {
|
||||
rc->buildings->region = r;
|
||||
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 */
|
||||
}
|
||||
|
||||
/* Besch<EFBFBD>digte Schiffe k<>nnen sinken */
|
||||
/* Beschaedigte Schiffe koennen sinken */
|
||||
|
||||
for (sh = r->ships; sh;) {
|
||||
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)
|
||||
{
|
||||
|
|
@ -505,7 +505,7 @@ static void icebergs(void)
|
|||
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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -125,7 +125,7 @@ static char *entish_syllable2[] = {
|
|||
};
|
||||
|
||||
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[] = {
|
||||
|
|
@ -200,13 +200,13 @@ static char *create_random_name(race_t race)
|
|||
strcat(name,
|
||||
orc_syllable3[rand() % (sizeof(orc_syllable3) / sizeof(char *))]);
|
||||
break;
|
||||
/*
|
||||
|
||||
case RC_TREEMAN:
|
||||
strcpy(name, entish_syllable1[rand()%(sizeof(entish_syllable1) / sizeof(char*))]);
|
||||
strcat(name, entish_syllable2[rand()%(sizeof(entish_syllable2) / sizeof(char*))]);
|
||||
strcat(name, entish_syllable3[rand()%(sizeof(entish_syllable3) / sizeof(char*))]);
|
||||
break;
|
||||
*/
|
||||
|
||||
case RC_DAEMON:
|
||||
case RC_INSECT:
|
||||
strcpy(name,
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ static int nb_armor(const unit * u, int index)
|
|||
if (!(u_race(u)->battle_flags & BF_EQUIPMENT))
|
||||
return 0;
|
||||
|
||||
/* Normale R<EFBFBD>stung */
|
||||
/* Normale Ruestung */
|
||||
|
||||
for (itm = u->items; itm; itm = itm->next) {
|
||||
const armor_type *atype = itm->type->rtype->atype;
|
||||
|
|
@ -186,11 +186,11 @@ static region *rrandneighbour(region * r)
|
|||
for (i = 0; i != MAXDIRECTIONS; i++) {
|
||||
c++;
|
||||
}
|
||||
/* Zuf<EFBFBD>llig eine ausw<73>hlen */
|
||||
/* Zufaellig eine auswaehlen */
|
||||
|
||||
rr = rng_int() % c;
|
||||
|
||||
/* Durchz<EFBFBD>hlen */
|
||||
/* Durchzaehlen */
|
||||
|
||||
c = -1;
|
||||
for (i = 0; i != MAXDIRECTIONS; i++) {
|
||||
|
|
@ -221,7 +221,7 @@ volcano_destruction(region * volcano, region * r, const char *damage)
|
|||
else {
|
||||
/* Produktion vierteln ... */
|
||||
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);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue