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

asciify more files

Browse source
This commit is contained in:
Enno Rehling 2019-02-07 20:33:20 +01:00
parent 35c6f30511
commit 642d043e7c
8 changed files with 86 additions and 85 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/kernel/attrib.c
View file

@ -191,7 +191,7 @@ static attrib_type *at_find_key(unsigned int hk)
if (!find) { if (!find) {
const char *translate[3][2] = { const char *translate[3][2] = {
{ "zielregion", "targetregion" }, /* remapping: from 'zielregion, heute targetregion */ { "zielregion", "targetregion" }, /* remapping: from 'zielregion, heute targetregion */
{ "verzaubert", "curse" }, /* remapping: früher verzaubert, jetzt curse */ { "verzaubert", "curse" }, /* remapping: frueher verzaubert, jetzt curse */
{ NULL, NULL } { NULL, NULL }
}; };
int i = 0; int i = 0;
@ -388,7 +388,7 @@ int a_age(attrib ** p, void *owner)
{ {
attrib **ap = p; attrib **ap = p;
/* Attribute altern, und die Entfernung (age()==0) eines Attributs /* Attribute altern, und die Entfernung (age()==0) eines Attributs
* hat Einfluß auf den Besitzer */ * hat Einfluss auf den Besitzer */
while (*ap) { while (*ap) {
attrib *a = *ap; attrib *a = *ap;
if (a->type->age) { if (a->type->age) {

15
src/kernel/building.c
View file

@ -447,7 +447,7 @@ void remove_building(building ** blist, building * b)
b->size = 0; b->size = 0;
bunhash(b); bunhash(b);
/* Falls Karawanserei, Damm oder Tunnel einst<EFBFBD>rzen, wird die schon /* Falls Karawanserei, Damm oder Tunnel einstuerzen, wird die schon
* gebaute Strasse zur Haelfte vernichtet */ * gebaute Strasse zur Haelfte vernichtet */
if (b->type == bt_caravan || b->type == bt_dam || b->type == bt_tunnel) { if (b->type == bt_caravan || b->type == bt_dam || b->type == bt_tunnel) {
int d; int d;
@ -560,8 +560,8 @@ void building_set_owner(struct unit * owner)
static unit *building_owner_ex(const building * bld, const struct faction * last_owner) static unit *building_owner_ex(const building * bld, const struct faction * last_owner)
{ {
unit *u, *heir = 0; unit *u, *heir = 0;
/* Eigent<EFBFBD>mer tot oder kein Eigent<6E>mer vorhanden. Erste lebende Einheit /* Eigentuemer tot oder kein Eigentuemer vorhanden.
* nehmen. */ * Erste lebende Einheit nehmen. */
for (u = bld->region->units; u; u = u->next) { for (u = bld->region->units; u; u = u->next) {
if (u->building == bld) { if (u->building == bld) {
if (u->number > 0) { if (u->number > 0) {
@ -711,7 +711,7 @@ building *largestbuilding(const region * r, cmp_building_cb cmp_gt,
} }
return best; return best;
} }
/* Lohn bei den einzelnen Burgstufen f<EFBFBD>r Normale Typen, Orks, Bauern */ /* Lohn bei den einzelnen Burgstufen fuer Normale Typen, Orks, Bauern */
static const int wagetable[7][3] = { static const int wagetable[7][3] = {
{ 10, 10, 11 }, /* Baustelle */ { 10, 10, 11 }, /* Baustelle */
@ -770,7 +770,7 @@ default_wage(const region * r, const faction * f, const race * rc, int in_turn)
} }
vm = frac_make(wage, 1); vm = frac_make(wage, 1);
/* Bei einer D<EFBFBD>rre verdient man nur noch ein Viertel */ /* Bei einer Duerre verdient man nur noch ein Viertel */
c = get_curse(r->attribs, &ct_drought); c = get_curse(r->attribs, &ct_drought);
if (c && curse_active(c)) { if (c && curse_active(c)) {
vm = frac_mul(vm, frac_make(1, curse_geteffect_int(c))); vm = frac_mul(vm, frac_make(1, curse_geteffect_int(c)));
@ -794,8 +794,9 @@ minimum_wage(const region * r, const faction * f, const race * rc, int in_turn)
return default_wage(r, f, rc, in_turn); return default_wage(r, f, rc, in_turn);
} }
/* Gibt Arbeitslohn f<>r entsprechende Rasse zur<75>ck, oder f<>r /**
* die Bauern wenn f == NULL. */ * Gibt Arbeitslohn fuer entsprechende Rasse zurueck, oder fuer
* die Bauern wenn f == NULL. */
int wage(const region * r, const faction * f, const race * rc, int in_turn) int wage(const region * r, const faction * f, const race * rc, int in_turn)
{ {
static int config; static int config;

2
src/kernel/connection.c
View file

@ -621,7 +621,7 @@ int read_borders(gamedata *data)
} }
if (type->read) { if (type->read) {
connection *b = new_border(type, from, to); connection *b = new_border(type, from, to);
nextborder--; /* new_border erh<EFBFBD>ht den Wert */ nextborder--; /* new_border erhoeht den Wert */
b->id = bid; b->id = bid;
assert(bid <= nextborder); assert(bid <= nextborder);
type->read(b, data); type->read(b, data);

6
src/kernel/curse.c
View file

@ -402,8 +402,8 @@ static void set_cursevigour(curse * c, double vigour)
c->vigour = vigour; c->vigour = vigour;
} }
/* veraendert die Stärke der Verzauberung um +i und gibt die neue /* veraendert die Staerke der Verzauberung um +i und gibt die neue
* Staerke zurueck. Sollte die Zauberstärke unter Null sinken, loest er * Staerke zurueck. Sollte die Zauberstaerke unter Null sinken, loest er
* sich auf. * sich auf.
*/ */
double curse_changevigour(attrib ** ap, curse * c, double vigour) double curse_changevigour(attrib ** ap, curse * c, double vigour)
@ -454,7 +454,7 @@ set_curseingmagician(struct unit *magician, struct attrib *ap_target,
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* gibt bei Personenbeschraenkten Verzauberungen die Anzahl der /* gibt bei Personenbeschraenkten Verzauberungen die Anzahl der
* betroffenen Personen zurueck. Ansonsten wird 0 zurückgegeben. */ * betroffenen Personen zurueck. Ansonsten wird 0 zurueckgegeben. */
int get_cursedmen(const unit * u, const curse * c) int get_cursedmen(const unit * u, const curse * c)
{ {
int cursedmen = u->number; int cursedmen = u->number;

2
src/kernel/ship.c
View file

@ -442,7 +442,7 @@ static unit * ship_owner_ex(const ship * sh, const struct faction * last_owner)
{ {
unit *u, *heir = 0; unit *u, *heir = 0;
/* Eigent<EFBFBD>mer tot oder kein Eigent<6E>mer vorhanden. Erste lebende Einheit /* Eigentuemer tot oder kein Eigentuemer vorhanden. Erste lebende Einheit
* nehmen. */ * nehmen. */
for (u = sh->region->units; u; u = u->next) { for (u = sh->region->units; u; u = u->next) {
if (u->ship == sh) { if (u->ship == sh) {

20
src/kernel/spell.h
View file

@ -144,34 +144,34 @@ extern "C" {
* *
* u : eine Einheitennummer * u : eine Einheitennummer
* r : hier kommen zwei Regionskoordinaten x y * r : hier kommen zwei Regionskoordinaten x y
* b : Geb<EFBFBD>ude- oder Burgnummer * b : Gebaeude- oder Burgnummer
* s : Schiffsnummer * s : Schiffsnummer
* c : String, wird ohne Weiterverarbeitung <EFBFBD>bergeben * c : String, wird ohne Weiterverarbeitung uebergeben
* i : Zahl (int), wird ohne Weiterverarbeitung <EFBFBD>bergeben * i : Zahl (int), wird ohne Weiterverarbeitung uebergeben
* k : Keywort - dieser String gibt den Paramter an, der folgt. Der * k : Keywort - dieser String gibt den Paramter an, der folgt. Der
* Parameter wird mit findparam() identifiziert. * Parameter wird mit findparam() identifiziert.
* k muss immer von einem c als Platzhalter f<EFBFBD>r das Objekt gefolgt * k muss immer von einem c als Platzhalter fuer das Objekt gefolgt
* werden. * werden.
* Ein gutes Beispiel sind hierf<EFBFBD>r die Spr<EFBFBD>che zur Magieanalyse. * Ein gutes Beispiel sind hierfuer die Sprueche zur Magieanalyse.
* + : gibt an, das der vorherige Parameter mehrfach vorkommen kann. Da * + : gibt an, das der vorherige Parameter mehrfach vorkommen kann. Da
* ein Ende nicht definiert werden kann, muss dies immer am Schluss * ein Ende nicht definiert werden kann, muss dies immer am Schluss
* kommen. * kommen.
* *
* Flags f<EFBFBD>r das Parsing: * Flags fuer das Parsing:
* TESTRESISTANCE : alle Zielobjekte, also alle Parameter vom Typ Unit, * TESTRESISTANCE : alle Zielobjekte, also alle Parameter vom Typ Unit,
* Burg, Schiff oder Region, werden auf ihre * Burg, Schiff oder Region, werden auf ihre
* Magieresistenz <EFBFBD>berpr<EFBFBD>ft * Magieresistenz ueberprueft
* TESTCANSEE : jedes Objekt vom Typ Einheit wird auf seine * TESTCANSEE : jedes Objekt vom Typ Einheit wird auf seine
* Sichtbarkeit <EFBFBD>berpr<EFBFBD>ft * Sichtbarkeit ueberprueft
* SEARCHLOCAL : die Zielobjekte werden nur regional gesucht * SEARCHLOCAL : die Zielobjekte werden nur regional gesucht
* REGIONSPELL : Ziel ist die Region, auch wenn kein Zielobjekt * REGIONSPELL : Ziel ist die Region, auch wenn kein Zielobjekt
* angegeben wird. Ist TESTRESISTANCE gesetzt, so wird * angegeben wird. Ist TESTRESISTANCE gesetzt, so wird
* die Magieresistenz der Region <EFBFBD>berpr<EFBFBD>ft * die Magieresistenz der Region ueberprueft
* *
* Bei fehlendem Ziel oder wenn dieses dem Zauber widersteht, wird die * Bei fehlendem Ziel oder wenn dieses dem Zauber widersteht, wird die
* Spruchfunktion nicht aufgerufen. * Spruchfunktion nicht aufgerufen.
* Sind zu wenig Parameter vorhanden, wird der Zauber ebenfalls nicht * Sind zu wenig Parameter vorhanden, wird der Zauber ebenfalls nicht
* ausgef<EFBFBD>hrt. * ausgefuehrt.
* Ist eins von mehreren Zielobjekten resistent, so wird das Flag * Ist eins von mehreren Zielobjekten resistent, so wird das Flag
* pa->param[n]->flag == TARGET_RESISTS * pa->param[n]->flag == TARGET_RESISTS
* Ist eins von mehreren Zielobjekten nicht gefunden worden, so ist * Ist eins von mehreren Zielobjekten nicht gefunden worden, so ist

108
src/laws.c
View file

@ -202,7 +202,7 @@ static void dumbeffect(unit *u) {
reduce_skill(u, sb, weeks); reduce_skill(u, sb, weeks);
ADDMSG(&u->faction->msgs, msg_message("dumbeffect", ADDMSG(&u->faction->msgs, msg_message("dumbeffect",
"unit weeks skill", u, weeks, (skill_t)sb->id)); "unit weeks skill", u, weeks, (skill_t)sb->id));
} /* sonst Glück gehabt: wer nix weiss, kann nix vergessen... */ } /* sonst Glueck gehabt: wer nix weiss, kann nix vergessen... */
change_effect(u, oldpotiontype[P_FOOL], -effect); change_effect(u, oldpotiontype[P_FOOL], -effect);
} }
} }
@ -249,7 +249,7 @@ static void live(region * r)
while (*up) { while (*up) {
unit *u = *up; unit *u = *up;
/* IUW: age_unit() kann u loeschen, u->next ist dann /* IUW: age_unit() kann u loeschen, u->next ist dann
* undefiniert, also muessen wir hier schon das nächste * undefiniert, also muessen wir hier schon das naechste
* Element bestimmen */ * Element bestimmen */
age_unit(r, u); age_unit(r, u);
if (*up == u) if (*up == u)
@ -378,17 +378,17 @@ static void peasants(region * r, int rule)
peasants += births + luck; peasants += births + luck;
} }
/* Alle werden satt, oder halt soviele für die es auch Geld gibt */ /* Alle werden satt, oder halt soviele fuer die es auch Geld gibt */
satiated = money / maintenance_cost(NULL); satiated = money / maintenance_cost(NULL);
if (satiated > peasants) satiated = peasants; if (satiated > peasants) satiated = peasants;
rsetmoney(r, money - satiated * maintenance_cost(NULL)); rsetmoney(r, money - satiated * maintenance_cost(NULL));
/* Von denjenigen, die nicht satt geworden sind, verhungert der /* Von denjenigen, die nicht satt geworden sind, verhungert der
* Großteil. dead kann nie größer als rpeasants(r) - satiated werden, * Grossteil. dead kann nie groesser als rpeasants(r) - satiated werden,
* so dass rpeasants(r) >= 0 bleiben muß. */ * so dass rpeasants(r) >= 0 bleiben muss. */
/* Es verhungert maximal die unterernährten Bevölkerung. */ /* Es verhungert maximal die unterernaehrten Bevoelkerung. */
n = peasants - satiated; n = peasants - satiated;
if (n > rp) n = rp; if (n > rp) n = rp;
@ -456,9 +456,9 @@ static void migrate(region * r)
rsethorses(r, rhorses(r) + m->horses); rsethorses(r, rhorses(r) + m->horses);
/* Was macht das denn hier? /* Was macht das denn hier?
* Baumwanderung wird in trees() gemacht. * Baumwanderung wird in trees() gemacht.
* wer fragt das? Die Baumwanderung war abhängig von der * wer fragt das? Die Baumwanderung war abhaengig von der
* Auswertungsreihenfolge der regionen, * Auswertungsreihenfolge der regionen,
* das hatte ich geändert. jemand hat es wieder gelöscht, toll. * das hatte ich geaendert. jemand hat es wieder geloescht, toll.
* ich habe es wieder aktiviert, muss getestet werden. * ich habe es wieder aktiviert, muss getestet werden.
*/ */
*hp = m->next; *hp = m->next;
@ -500,7 +500,7 @@ static void horses(region * r)
/* Pferde wandern in Nachbarregionen. /* Pferde wandern in Nachbarregionen.
* Falls die Nachbarregion noch berechnet * Falls die Nachbarregion noch berechnet
* werden muss, wird eine migration-Struktur gebildet, * werden muss, wird eine migration-Struktur gebildet,
* die dann erst in die Berechnung der Nachbarstruktur einfließt. * die dann erst in die Berechnung der Nachbarstruktur einfliesst.
*/ */
for (n = 0; n != MAXDIRECTIONS; n++) { for (n = 0; n != MAXDIRECTIONS; n++) {
@ -514,7 +514,7 @@ static void horses(region * r)
else { else {
migration *nb; migration *nb;
/* haben wir die Migration schonmal benutzt? /* haben wir die Migration schonmal benutzt?
* wenn nicht, müssen wir sie suchen. * wenn nicht, muessen wir sie suchen.
* Wandernde Pferde vermehren sich nicht. * Wandernde Pferde vermehren sich nicht.
*/ */
nb = get_migrants(r2); nb = get_migrants(r2);
@ -620,12 +620,12 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
a = a_find(r->attribs, &at_germs); a = a_find(r->attribs, &at_germs);
if (a && last_weeks_season == SEASON_SPRING) { if (a && last_weeks_season == SEASON_SPRING) {
/* ungekeimte Samen bleiben erhalten, Sprößlinge wachsen */ /* ungekeimte Samen bleiben erhalten, Sproesslinge wachsen */
sprout = rtrees(r, 1); sprout = rtrees(r, 1);
if (sprout > a->data.sa[1]) sprout = a->data.sa[1]; if (sprout > a->data.sa[1]) sprout = a->data.sa[1];
/* aus dem gesamt Sprößlingepool abziehen */ /* aus dem gesamt Sproesslingepool abziehen */
rsettrees(r, 1, rtrees(r, 1) - sprout); rsettrees(r, 1, rtrees(r, 1) - sprout);
/* zu den Bäumen hinzufügen */ /* zu den Baeumen hinzufuegen */
rsettrees(r, 2, rtrees(r, 2) + sprout); rsettrees(r, 2, rtrees(r, 2) + sprout);
a_removeall(&r->attribs, &at_germs); a_removeall(&r->attribs, &at_germs);
@ -642,7 +642,7 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
return; return;
/* Grundchance 1.0% */ /* Grundchance 1.0% */
/* Jeder Elf in der Region erhöht die Chance marginal */ /* Jeder Elf in der Region erhoeht die Chance marginal */
mp = mp / 8; mp = mp / 8;
if (elves > mp) elves = mp; if (elves > mp) elves = mp;
if (elves) { if (elves) {
@ -664,19 +664,19 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
} }
} }
/* Bäume breiten sich in Nachbarregionen aus. */ /* Baeume breiten sich in Nachbarregionen aus. */
/* Gesamtzahl der Samen: /* Gesamtzahl der Samen:
* bis zu 6% (FORESTGROWTH*3) der Bäume samen in die Nachbarregionen */ * bis zu 6% (FORESTGROWTH*3) der Baeume samen in die Nachbarregionen */
seeds = (rtrees(r, 2) * FORESTGROWTH * 3) / 1000000; seeds = (rtrees(r, 2) * FORESTGROWTH * 3) / 1000000;
for (d = 0; d != MAXDIRECTIONS; ++d) { for (d = 0; d != MAXDIRECTIONS; ++d) {
region *r2 = rconnect(r, d); region *r2 = rconnect(r, d);
if (r2 && fval(r2->terrain, LAND_REGION) && r2->terrain->size) { if (r2 && fval(r2->terrain, LAND_REGION) && r2->terrain->size) {
/* Eine Landregion, wir versuchen Samen zu verteilen: /* Eine Landregion, wir versuchen Samen zu verteilen:
* Die Chance, das Samen ein Stück Boden finden, in dem sie * Die Chance, das Samen ein Stueck Boden finden, in dem sie
* keimen können, hängt von der Bewuchsdichte und der * keimen koennen, haengt von der Bewuchsdichte und der
* verfügbaren Fläche ab. In Gletschern gibt es weniger * verfuegbaren Flaeche ab. In Gletschern gibt es weniger
* Möglichkeiten als in Ebenen. */ * Moeglichkeiten als in Ebenen. */
sprout = 0; sprout = 0;
seedchance = (1000.0 * region_maxworkers(r2)) / r2->terrain->size; seedchance = (1000.0 * region_maxworkers(r2)) / r2->terrain->size;
for (i = 0; i < seeds / MAXDIRECTIONS; i++) { for (i = 0; i < seeds / MAXDIRECTIONS; i++) {
@ -694,8 +694,8 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
if (is_cursed(r->attribs, &ct_godcursezone)) if (is_cursed(r->attribs, &ct_godcursezone))
return; return;
/* in at_germs merken uns die Zahl der Samen und Sprößlinge, die /* in at_germs merken uns die Zahl der Samen und Sproesslinge, die
* dieses Jahr älter werden dürfen, damit nicht ein Same im selben * dieses Jahr aelter werden duerfen, damit nicht ein Same im selben
* Zyklus zum Baum werden kann */ * Zyklus zum Baum werden kann */
a = a_find(r->attribs, &at_germs); a = a_find(r->attribs, &at_germs);
if (!a) { if (!a) {
@ -709,7 +709,7 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
/* Samenwachstum */ /* Samenwachstum */
/* Raubbau abfangen, es dürfen nie mehr Samen wachsen, als aktuell /* Raubbau abfangen, es duerfen nie mehr Samen wachsen, als aktuell
* in der Region sind */ * in der Region sind */
seeds = rtrees(r, 0); seeds = rtrees(r, 0);
if (seeds > a->data.sa[0]) seeds = a->data.sa[0]; if (seeds > a->data.sa[0]) seeds = a->data.sa[0];
@ -723,15 +723,15 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
a->data.sa[0] = (short)(seeds - sprout); a->data.sa[0] = (short)(seeds - sprout);
/* aus dem gesamt Samenpool abziehen */ /* aus dem gesamt Samenpool abziehen */
rsettrees(r, 0, rtrees(r, 0) - sprout); rsettrees(r, 0, rtrees(r, 0) - sprout);
/* zu den Sprößlinge hinzufügen */ /* zu den Sproesslinge hinzufuegen */
rsettrees(r, 1, rtrees(r, 1) + sprout); rsettrees(r, 1, rtrees(r, 1) + sprout);
/* Baumwachstum */ /* Baumwachstum */
/* hier gehen wir davon aus, das Jungbäume nicht ohne weiteres aus /* hier gehen wir davon aus, das Jungbaeume nicht ohne weiteres aus
* der Region entfernt werden können, da Jungbäume in der gleichen * der Region entfernt werden koennen, da Jungbaeume in der gleichen
* Runde nachwachsen, wir also nicht mehr zwischen diesjährigen und * Runde nachwachsen, wir also nicht mehr zwischen diesjaehrigen und
* 'alten' Jungbäumen unterscheiden könnten */ * 'alten' Jungbaeumen unterscheiden koennten */
sprout = rtrees(r, 1); sprout = rtrees(r, 1);
if (sprout > a->data.sa[1]) sprout = a->data.sa[1]; if (sprout > a->data.sa[1]) sprout = a->data.sa[1];
grownup_trees = 0; grownup_trees = 0;
@ -740,11 +740,11 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
if (rng_int() % 10000 < growth) if (rng_int() % 10000 < growth)
grownup_trees++; grownup_trees++;
} }
/* aus dem Sprößlingepool dieses Jahres abziehen */ /* aus dem Sproesslingepool dieses Jahres abziehen */
a->data.sa[1] = (short)(sprout - grownup_trees); a->data.sa[1] = (short)(sprout - grownup_trees);
/* aus dem gesamt Sprößlingepool abziehen */ /* aus dem gesamt Sproesslingepool abziehen */
rsettrees(r, 1, rtrees(r, 1) - grownup_trees); rsettrees(r, 1, rtrees(r, 1) - grownup_trees);
/* zu den Bäumen hinzufügen */ /* zu den Baeumen hinzufuegen */
rsettrees(r, 2, rtrees(r, 2) + grownup_trees); rsettrees(r, 2, rtrees(r, 2) + grownup_trees);
} }
} }
@ -752,10 +752,10 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
static void static void
growing_herbs(region * r, const int current_season, const int last_weeks_season) growing_herbs(region * r, const int current_season, const int last_weeks_season)
{ {
/* Jetzt die Kräutervermehrung. Vermehrt wird logistisch: /* Jetzt die Kraeutervermehrung. Vermehrt wird logistisch:
* *
* Jedes Kraut hat eine Wahrscheinlichkeit von (100-(vorhandene * Jedes Kraut hat eine Wahrscheinlichkeit von (100-(vorhandene
* Kräuter))% sich zu vermehren. */ * Kraeuter))% sich zu vermehren. */
UNUSED_ARG(last_weeks_season); UNUSED_ARG(last_weeks_season);
if (current_season != SEASON_WINTER) { if (current_season != SEASON_WINTER) {
int i, herbs = rherbs(r); int i, herbs = rherbs(r);
@ -1060,7 +1060,7 @@ int enter_building(unit * u, order * ord, int id, bool report)
region *r = u->region; region *r = u->region;
building *b; building *b;
/* Schwimmer können keine Gebäude betreten, außer diese sind /* Schwimmer koennen keine Gebaeude betreten, ausser diese sind
* auf dem Ozean */ * auf dem Ozean */
if (!fval(u_race(u), RCF_WALK) && !fval(u_race(u), RCF_FLY)) { if (!fval(u_race(u), RCF_WALK) && !fval(u_race(u), RCF_FLY)) {
if (!fval(r->terrain, SEA_REGION)) { if (!fval(r->terrain, SEA_REGION)) {
@ -1169,8 +1169,8 @@ void do_enter(struct region *r, bool is_final_attempt)
} }
if (ulast != NULL) { if (ulast != NULL) {
/* Wenn wir hier angekommen sind, war der Befehl /* Wenn wir hier angekommen sind, war der Befehl
* erfolgreich und wir löschen ihn, damit er im * erfolgreich und wir loeschen ihn, damit er im
* zweiten Versuch nicht nochmal ausgeführt wird. */ * zweiten Versuch nicht nochmal ausgefuehrt wird. */
*ordp = ord->next; *ordp = ord->next;
ord->next = NULL; ord->next = NULL;
free_order(ord); free_order(ord);
@ -1925,13 +1925,13 @@ int mail_cmd(unit * u, struct order *ord)
s = gettoken(token, sizeof(token)); s = gettoken(token, sizeof(token));
/* Falls kein Parameter, ist das eine Einheitsnummer; /* Falls kein Parameter, ist das eine Einheitsnummer;
* das Füllwort "AN" muss wegfallen, da gültige Nummer! */ * das Fuellwort "AN" muss wegfallen, da gueltige Nummer! */
do { do {
cont = 0; cont = 0;
switch (findparam_ex(s, u->faction->locale)) { switch (findparam_ex(s, u->faction->locale)) {
case P_REGION: case P_REGION:
/* können alle Einheiten in der Region sehen */ /* koennen alle Einheiten in der Region sehen */
s = getstrtoken(); s = getstrtoken();
if (!s || !s[0]) { if (!s || !s[0]) {
cmistake(u, ord, 30, MSG_MESSAGE); cmistake(u, ord, 30, MSG_MESSAGE);
@ -2408,7 +2408,7 @@ int combatspell_cmd(unit * u, struct order *ord)
init_order_depr(ord); init_order_depr(ord);
s = gettoken(token, sizeof(token)); s = gettoken(token, sizeof(token));
/* KAMPFZAUBER [NICHT] löscht alle gesetzten Kampfzauber */ /* KAMPFZAUBER [NICHT] loescht alle gesetzten Kampfzauber */
if (!s || *s == 0 || findparam(s, u->faction->locale) == P_NOT) { if (!s || *s == 0 || findparam(s, u->faction->locale) == P_NOT) {
unset_combatspell(u, 0); unset_combatspell(u, 0);
return 0; return 0;
@ -2416,7 +2416,7 @@ int combatspell_cmd(unit * u, struct order *ord)
/* Optional: STUFE n */ /* Optional: STUFE n */
if (findparam(s, u->faction->locale) == P_LEVEL) { if (findparam(s, u->faction->locale) == P_LEVEL) {
/* Merken, setzen kommt erst später */ /* Merken, setzen kommt erst spaeter */
level = getuint(); level = getuint();
s = gettoken(token, sizeof(token)); s = gettoken(token, sizeof(token));
} }
@ -2430,14 +2430,14 @@ int combatspell_cmd(unit * u, struct order *ord)
s = gettoken(token, sizeof(token)); s = gettoken(token, sizeof(token));
if (findparam(s, u->faction->locale) == P_NOT) { if (findparam(s, u->faction->locale) == P_NOT) {
/* KAMPFZAUBER "<Spruchname>" NICHT löscht diesen speziellen /* KAMPFZAUBER "<Spruchname>" NICHT loescht diesen speziellen
* Kampfzauber */ * Kampfzauber */
unset_combatspell(u, sp); unset_combatspell(u, sp);
return 0; return 0;
} }
else { else {
/* KAMPFZAUBER "<Spruchname>" setzt diesen Kampfzauber */ /* KAMPFZAUBER "<Spruchname>" setzt diesen Kampfzauber */
/* knowsspell prüft auf ist_magier, ist_spruch, kennt_spruch */ /* knowsspell prueft auf ist_magier, ist_spruch, kennt_spruch */
if (!knowsspell(u->region, u, sp)) { if (!knowsspell(u->region, u, sp)) {
/* Fehler 'Spell not found' */ /* Fehler 'Spell not found' */
cmistake(u, ord, 173, MSG_MAGIC); cmistake(u, ord, 173, MSG_MAGIC);
@ -2773,7 +2773,7 @@ static void ageing(void)
sp = &(*sp)->next; sp = &(*sp)->next;
} }
/* Gebäude */ /* Gebaeude */
for (bp = &r->buildings; *bp;) { for (bp = &r->buildings; *bp;) {
building *b = *bp; building *b = *bp;
age_building(b); age_building(b);
@ -2978,7 +2978,7 @@ void update_long_order(unit * u)
/* we have found the (first) long order /* we have found the (first) long order
* some long orders can have multiple instances: */ * some long orders can have multiple instances: */
switch (kwd) { switch (kwd) {
/* Wenn gehandelt wird, darf kein langer Befehl ausgeführt /* Wenn gehandelt wird, darf kein langer Befehl ausgefuehrt
* werden. Da Handel erst nach anderen langen Befehlen kommt, * werden. Da Handel erst nach anderen langen Befehlen kommt,
* muss das vorher abgefangen werden. Wir merken uns also * muss das vorher abgefangen werden. Wir merken uns also
* hier, ob die Einheit handelt. */ * hier, ob die Einheit handelt. */
@ -3034,11 +3034,11 @@ void update_long_order(unit * u)
} }
} }
if (hunger) { if (hunger) {
/* Hungernde Einheiten führen NUR den default-Befehl aus */ /* Hungernde Einheiten fuehren NUR den default-Befehl aus */
set_order(&u->thisorder, default_order(u->faction->locale)); set_order(&u->thisorder, default_order(u->faction->locale));
} }
else if (!exclusive) { else if (!exclusive) {
/* Wenn die Einheit handelt oder zaubert, muss der Default-Befehl gelöscht werden. */ /* Wenn die Einheit handelt oder zaubert, muss der Default-Befehl geloescht werden. */
set_order(&u->thisorder, NULL); set_order(&u->thisorder, NULL);
} }
} }
@ -3075,7 +3075,7 @@ void monthly_healing(void)
double healingcurse = 0; double healingcurse = 0;
if (r->attribs) { if (r->attribs) {
/* bonus zurücksetzen */ /* bonus zuruecksetzen */
curse *c = get_curse(r->attribs, &ct_healing); curse *c = get_curse(r->attribs, &ct_healing);
if (c != NULL) { if (c != NULL) {
healingcurse = curse_geteffect(c); healingcurse = curse_geteffect(c);
@ -3085,8 +3085,8 @@ void monthly_healing(void)
int umhp = unit_max_hp(u) * u->number; int umhp = unit_max_hp(u) * u->number;
double p = 1.0; double p = 1.0;
/* hp über Maximum bauen sich ab. Wird zb durch Elixier der Macht /* hp ueber Maximum bauen sich ab. Wird zb durch Elixier der Macht
* oder verändertes Ausdauertalent verursacht */ * oder veraendertes Ausdauertalent verursacht */
if (u->hp > umhp) { if (u->hp > umhp) {
int diff = u->hp - umhp; int diff = u->hp - umhp;
u->hp -= (int)ceil(diff / 2.0); u->hp -= (int)ceil(diff / 2.0);
@ -3113,7 +3113,7 @@ void monthly_healing(void)
if (active_building(u, bt_find("inn"))) { if (active_building(u, bt_find("inn"))) {
p *= 1.5; p *= 1.5;
} }
/* pro punkt 5% höher */ /* pro punkt 5% hoeher */
p *= (1.0 + healingcurse * 0.05); p *= (1.0 + healingcurse * 0.05);
maxheal = p * maxheal; maxheal = p * maxheal;
@ -3126,7 +3126,7 @@ void monthly_healing(void)
if (umhp > u->hp + addhp) umhp = u->hp + addhp; if (umhp > u->hp + addhp) umhp = u->hp + addhp;
u->hp = umhp; u->hp = umhp;
/* soll man an negativer regeneration sterben können? */ /* soll man an negativer regeneration sterben koennen? */
assert(u->hp > 0); assert(u->hp > 0);
} }
} }
@ -3173,7 +3173,7 @@ void defaultorders(void)
ord->next = NULL; ord->next = NULL;
free_order(ord); free_order(ord);
if (!neworders) { if (!neworders) {
/* lange Befehle aus orders und old_orders löschen zu gunsten des neuen */ /* lange Befehle aus orders und old_orders loeschen zu gunsten des neuen */
/* TODO: why only is_exclusive, not is_long? what about CAST, BUY, SELL? */ /* TODO: why only is_exclusive, not is_long? what about CAST, BUY, SELL? */
remove_exclusive(&u->orders); remove_exclusive(&u->orders);
remove_exclusive(&u->old_orders); remove_exclusive(&u->old_orders);
@ -3981,8 +3981,8 @@ void turn_end(void)
wormholes_update(); wormholes_update();
} }
/* immer ausführen, wenn neue Sprüche dazugekommen sind, oder sich /* immer ausfuehren, wenn neue Sprueche dazugekommen sind, oder sich
* Beschreibungen geändert haben */ * Beschreibungen geaendert haben */
update_spells(); update_spells();
} }

14
src/magic.h
View file

@ -90,7 +90,7 @@ extern "C" {
* - Magierichtung * - Magierichtung
* - Magiepunkte derzeit * - Magiepunkte derzeit
* - Malus (neg. Wert)/ Bonus (pos. Wert) auf maximale Magiepunkte * - Malus (neg. Wert)/ Bonus (pos. Wert) auf maximale Magiepunkte
* (koennen sich durch Questen absolut veraendern und durch Gegenstände * (koennen sich durch Questen absolut veraendern und durch Gegenstaende
* temporaer). Auch fuer Artefakt benoetigt man permanente MP * temporaer). Auch fuer Artefakt benoetigt man permanente MP
* - Anzahl bereits gezauberte Sprueche diese Runde * - Anzahl bereits gezauberte Sprueche diese Runde
* - Kampfzauber (3) (vor/waehrend/nach) * - Kampfzauber (3) (vor/waehrend/nach)
@ -145,7 +145,7 @@ extern "C" {
Schiffen stehend gezaubert werden */ Schiffen stehend gezaubert werden */
#define TESTCANSEE (1<<4) /* alle Zielunits auf cansee pruefen */ #define TESTCANSEE (1<<4) /* alle Zielunits auf cansee pruefen */
/* ID's koennen zu drei unterschiedlichen Entitaeten gehören: Einheiten, /* ID's koennen zu drei unterschiedlichen Entitaeten gehoeren: Einheiten,
* Gebaeuden und Schiffen. */ * Gebaeuden und Schiffen. */
#define UNITSPELL (1<<5) /* ZAUBER .. <Einheit-Nr> [<Einheit-Nr> ..] */ #define UNITSPELL (1<<5) /* ZAUBER .. <Einheit-Nr> [<Einheit-Nr> ..] */
#define SHIPSPELL (1<<6) /* ZAUBER .. <Schiff-Nr> [<Schiff-Nr> ..] */ #define SHIPSPELL (1<<6) /* ZAUBER .. <Schiff-Nr> [<Schiff-Nr> ..] */
@ -153,7 +153,7 @@ extern "C" {
#define REGIONSPELL (1<<8) /* wirkt auf struct region */ #define REGIONSPELL (1<<8) /* wirkt auf struct region */
#define GLOBALTARGET (1<<9) /* Ziel kann ausserhalb der region sein */ #define GLOBALTARGET (1<<9) /* Ziel kann ausserhalb der region sein */
#define PRECOMBATSPELL (1<<10) /* PRÄKAMPFZAUBER .. */ #define PRECOMBATSPELL (1<<10) /* PRAEKAMPFZAUBER .. */
#define COMBATSPELL (1<<11) /* KAMPFZAUBER .. */ #define COMBATSPELL (1<<11) /* KAMPFZAUBER .. */
#define POSTCOMBATSPELL (1<<12) /* POSTKAMPFZAUBER .. */ #define POSTCOMBATSPELL (1<<12) /* POSTKAMPFZAUBER .. */
#define ISCOMBATSPELL (PRECOMBATSPELL|COMBATSPELL|POSTCOMBATSPELL) #define ISCOMBATSPELL (PRECOMBATSPELL|COMBATSPELL|POSTCOMBATSPELL)
@ -275,18 +275,18 @@ extern "C" {
struct unit * familiar, const struct spell * sp, struct region * r, struct unit * familiar, const struct spell * sp, struct region * r,
int lev, double force, int range, struct order * ord, struct spellparameter * p); int lev, double force, int range, struct order * ord, struct spellparameter * p);
void free_castorder(struct castorder *co); void free_castorder(struct castorder *co);
/* Zwischenspreicher fuer Zauberbefehle, notwendig für Prioritaeten */ /* Zwischenspreicher fuer Zauberbefehle, notwendig fuer Prioritaeten */
void add_castorder(struct spellrank *cll, struct castorder *co); void add_castorder(struct spellrank *cll, struct castorder *co);
/* Haenge c-order co an die letze c-order von cll an */ /* Haenge c-order co an die letze c-order von cll an */
void free_castorders(struct castorder *co); void free_castorders(struct castorder *co);
/* Speicher wieder freigeben */ /* Speicher wieder freigeben */
int cast_spell(struct castorder *co); int cast_spell(struct castorder *co);
/* Pruefroutinen für Zaubern */ /* Pruefroutinen fuer Zaubern */
int countspells(struct unit *u, int step); int countspells(struct unit *u, int step);
int spellcount(const struct unit *u); int spellcount(const struct unit *u);
/* erhoeht den Counter fuer Zaubersprüche um 'step' und gibt die neue /* erhoeht den Counter fuer Zaubersprueche um 'step' und gibt die neue
* Anzahl der gezauberten Sprueche zurück. */ * Anzahl der gezauberten Sprueche zurueck. */
int auracost(const struct unit *caster, const struct spell *sp); int auracost(const struct unit *caster, const struct spell *sp);
int spellcost(const struct unit *caster, const struct spell_component *spc); int spellcost(const struct unit *caster, const struct spell_component *spc);
/* gibt die fuer diesen Spruch derzeit notwendigen Magiepunkte auf der /* gibt die fuer diesen Spruch derzeit notwendigen Magiepunkte auf der