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

Merge pull request #261 from ennorehling/hotfix/bug-2123-gbdream-no-mage 

Hotfix 3.5.4 (against master)
This commit is contained in:
Enno Rehling 2015-08-02 23:22:28 +02:00
parent 65b7fc7ff8 9938b3fb66
commit 6727b0cbe4
7 changed files with 151 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/buildno.h
View File

@ -1,3 +1,3 @@
#define VERSION_MAJOR 3 #define VERSION_MAJOR 3
#define VERSION_MINOR 5 #define VERSION_MINOR 5
#define VERSION_BUILD 3 #define VERSION_BUILD 4

2
src/kernel/config.c
View File

@ -530,6 +530,8 @@ int alliedunit(const unit * u, const faction * f2, int mode)
ally *sf; ally *sf;
int automode; int automode;
assert(u);
assert(f2);
assert(u->region); /* the unit should be in a region, but it's possible that u->number==0 (TEMP units) */ assert(u->region); /* the unit should be in a region, but it's possible that u->number==0 (TEMP units) */
if (u->faction == f2) if (u->faction == f2)
return mode; return mode;

50
src/kernel/save.c
View File

@ -1,4 +1,4 @@
/* /*
Copyright (c) 1998-2015, Enno Rehling <enno@eressea.de> Copyright (c) 1998-2015, Enno Rehling <enno@eressea.de>
Katja Zedel <katze@felidae.kn-bremen.de Katja Zedel <katze@felidae.kn-bremen.de
Christian Schlittchen <corwin@amber.kn-bremen.de> Christian Schlittchen <corwin@amber.kn-bremen.de>
@ -200,7 +200,7 @@ static unit *unitorders(FILE * F, int enc, struct faction *f)
} }
} }
} }
/* Nun wird der Befehl erzeut und eingehängt */ /* Nun wird der Befehl erzeut und eingehängt */
*ordp = parse_order(s, u->faction->locale); *ordp = parse_order(s, u->faction->locale);
if (*ordp) { if (*ordp) {
ordp = &(*ordp)->next; ordp = &(*ordp)->next;
@ -233,8 +233,8 @@ static faction *factionorders(void)
f->no, pass)); f->no, pass));
return 0; return 0;
} }
/* Die Partei hat sich zumindest gemeldet, so daß sie noch /* Die Partei hat sich zumindest gemeldet, so dass sie noch
* nicht als untätig gilt */ * nicht als untätig gilt */
/* TODO: +1 ist ein Workaround, weil cturn erst in process_orders /* TODO: +1 ist ein Workaround, weil cturn erst in process_orders
* incrementiert wird. */ * incrementiert wird. */
@ -308,9 +308,9 @@ int readorders(const char *filename)
/* 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älle nicht überschreiben! Bei allen anderen Einträgen hier * auf alle Fälle nicht überschreiben! Bei allen anderen Einträgen hier
* muß buf erneut gefüllt werden, da die betreffende Information in nur * muss buf erneut gefüllt werden, da die betreffende Information in nur
* einer Zeile steht, und nun die nächste gelesen werden muß. */ * einer Zeile steht, und nun die nächste gelesen werden muss. */
case P_NEXT: case P_NEXT:
f = NULL; f = NULL;
@ -331,7 +331,7 @@ int readorders(const char *filename)
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* #define INNER_WORLD */ /* #define INNER_WORLD */
/* fürs debuggen nur den inneren Teil der Welt laden */ /* fürs debuggen nur den inneren Teil der Welt laden */
/* -9;-27;-1;-19;Sumpfloch */ /* -9;-27;-1;-19;Sumpfloch */
int inner_world(region * r) int inner_world(region * r)
{ {
@ -1600,7 +1600,6 @@ int readgame(const char *filename, int backup)
while (--p >= 0) { while (--p >= 0) {
unit *u = read_unit(&gdata); unit *u = read_unit(&gdata);
sc_mage *mage;
if (gdata.version < JSON_REPORT_VERSION) { if (gdata.version < JSON_REPORT_VERSION) {
if (u->_name && fval(u->faction, FFL_NPC)) { if (u->_name && fval(u->faction, FFL_NPC)) {
@ -1615,21 +1614,6 @@ int readgame(const char *filename, int backup)
up = &u->next; up = &u->next;
update_interval(u->faction, u->region); update_interval(u->faction, u->region);
mage = get_mage(u);
if (mage) {
faction *f = u->faction;
int skl = effskill(u, SK_MAGIC);
if (!fval(f, FFL_NPC) && f->magiegebiet == M_GRAY) {
log_error("faction %s had magic=gray, fixing (%s)\n", factionname(f), magic_school[mage->magietyp]);
f->magiegebiet = mage->magietyp;
}
if (f->max_spelllevel < skl) {
f->max_spelllevel = skl;
}
if (mage->spellcount < 0) {
mage->spellcount = 0;
}
}
} }
} }
log_printf(stdout, "\n"); log_printf(stdout, "\n");
@ -1653,6 +1637,7 @@ int readgame(const char *filename, int backup)
for (f = factions; f; f = f->next) { for (f = factions; f; f = f->next) {
if (f->flags & FFL_NPC) { if (f->flags & FFL_NPC) {
f->alive = 1; f->alive = 1;
f->magiegebiet = M_GRAY;
if (f->no == 0) { if (f->no == 0) {
int no = 666; int no = 666;
while (findfaction(no)) while (findfaction(no))
@ -1663,8 +1648,23 @@ int readgame(const char *filename, int backup)
} }
else { else {
for (u = f->units; u; u = u->nextF) { for (u = f->units; u; u = u->nextF) {
sc_mage *mage = get_mage(u);
if (mage) {
faction *f = u->faction;
int skl = effskill(u, SK_MAGIC);
if (f->magiegebiet == M_GRAY) {
log_error("faction %s had magic=gray, fixing (%s)\n", factionname(f), magic_school[mage->magietyp]);
f->magiegebiet = mage->magietyp;
}
if (f->max_spelllevel < skl) {
f->max_spelllevel = skl;
}
if (mage->spellcount < 0) {
mage->spellcount = 0;
}
}
if (u->number > 0) { if (u->number > 0) {
f->alive = 1; f->alive = true;
break; break;
} }
} }

33
src/kernel/unit.c
View File

@ -1274,25 +1274,10 @@ static int item_modification(const unit * u, skill_t sk, int val)
return val; return val;
} }
static int update_gbdream(const unit * u, int bonus, curse *c, const curse_type *gbdream_ct, int sign){ static int att_modification(const unit * u, skill_t sk)
if (curse_active(c) && c->type == gbdream_ct) {
double effect = curse_geteffect(c);
unit *mage = c->magician;
/* wir suchen jeweils den groessten Bonus und den groestsen Malus */
if (sign * effect > sign * bonus) {
if (mage == NULL || mage->number == 0
|| sign>0?alliedunit(mage, u->faction, HELP_GUARD):!alliedunit(mage, u->faction, HELP_GUARD)) {
bonus = (int)effect;
}
}
}
return bonus;
}
int att_modification(const unit * u, skill_t sk)
{ {
double result = 0; double result = 0;
static bool init = false; static bool init = false; // TODO: static variables are bad global state
static const curse_type *skillmod_ct, *gbdream_ct, *worse_ct; static const curse_type *skillmod_ct, *gbdream_ct, *worse_ct;
curse *c; curse *c;
@ -1321,15 +1306,21 @@ int att_modification(const unit * u, skill_t sk)
/* TODO hier kann nicht mit get/iscursed gearbeitet werden, da nur der /* TODO hier kann nicht mit get/iscursed gearbeitet werden, da nur der
* jeweils erste vom Typ C_GBDREAM zurueckgegen wird, wir aber alle * jeweils erste vom Typ C_GBDREAM zurueckgegen wird, wir aber alle
* durchsuchen und aufaddieren muessen */ * durchsuchen und aufaddieren muessen */
if (u->region) { if (gbdream_ct && u->region) {
int bonus = 0, malus = 0; int bonus = 0, malus = 0;
attrib *a = a_find(u->region->attribs, &at_curse); attrib *a = a_find(u->region->attribs, &at_curse);
while (a && a->type == &at_curse) { while (a && a->type == &at_curse) {
curse *c = (curse *)a->data.v; curse *c = (curse *)a->data.v;
bonus = update_gbdream(u, bonus, c, gbdream_ct, 1); if (curse_active(c) && c->type == gbdream_ct) {
malus = update_gbdream(u, malus, c, gbdream_ct, -1); int effect = curse_geteffect_int(c);
bool allied = alliedunit(c->magician, u->faction, HELP_GUARD);
if (allied) {
if (effect > bonus) bonus = effect;
} else {
if (effect < malus) malus = effect;
}
}
a = a->next; a = a->next;
} }
result = result + bonus + malus; result = result + bonus + malus;

130
src/laws.c
View File

@ -1,4 +1,4 @@
/* /*
Copyright (c) 1998-2014, Copyright (c) 1998-2014,
Enno Rehling <enno@eressea.de> Enno Rehling <enno@eressea.de>
Katja Zedel <katze@felidae.kn-bremen.de Katja Zedel <katze@felidae.kn-bremen.de
@ -175,7 +175,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 nächste
* Element bestimmen */ * Element bestimmen */
int effect = get_effect(u, oldpotiontype[P_FOOL]); int effect = get_effect(u, oldpotiontype[P_FOOL]);
@ -193,7 +193,7 @@ static void live(region * r)
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 weiß, kann nix vergessen... */ } /* sonst Glück gehabt: wer nix weiss, kann nix vergessen... */
change_effect(u, oldpotiontype[P_FOOL], -effect); change_effect(u, oldpotiontype[P_FOOL], -effect);
} }
age_unit(r, u); age_unit(r, u);
@ -337,16 +337,16 @@ static void peasants(region * r)
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 für die es auch Geld gibt */
satiated = _min(peasants, money / maintenance_cost(NULL)); satiated = _min(peasants, money / maintenance_cost(NULL));
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, * Großteil. dead kann nie größer als rpeasants(r) - satiated werden,
* so dass rpeasants(r) >= 0 bleiben muß. */ * so dass rpeasants(r) >= 0 bleiben muß. */
/* Es verhungert maximal die unterernährten Bevölkerung. */ /* Es verhungert maximal die unterernährten Bevölkerung. */
n = _min(peasants - satiated, rpeasants(r)); n = _min(peasants - satiated, rpeasants(r));
dead += (int)(0.5F + n * PEASANT_STARVATION_CHANCE); dead += (int)(0.5F + n * PEASANT_STARVATION_CHANCE);
@ -411,10 +411,10 @@ 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 abhängig von der
* Auswertungsreihenfolge der regionen, * Auswertungsreihenfolge der regionen,
* das hatte ich geändert. jemand hat es wieder gelöscht, toll. * das hatte ich geändert. jemand hat es wieder gelöscht, toll.
* ich habe es wieder aktiviert, muß getestet werden. * ich habe es wieder aktiviert, muss getestet werden.
*/ */
*hp = m->next; *hp = m->next;
m->next = free_migrants; m->next = free_migrants;
@ -454,8 +454,8 @@ static void horses(region * r)
/* Pferde wandern in Nachbarregionen. /* Pferde wandern in Nachbarregionen.
* Falls die Nachbarregion noch berechnet * Falls die Nachbarregion noch berechnet
* werden muß, 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 einfließt.
*/ */
for (n = 0; n != MAXDIRECTIONS; n++) { for (n = 0; n != MAXDIRECTIONS; n++) {
@ -469,7 +469,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, müssen wir sie suchen.
* Wandernde Pferde vermehren sich nicht. * Wandernde Pferde vermehren sich nicht.
*/ */
nb = get_migrants(r2); nb = get_migrants(r2);
@ -565,11 +565,11 @@ 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, Sprößlinge wachsen */
sprout = _min(a->data.sa[1], rtrees(r, 1)); sprout = _min(a->data.sa[1], rtrees(r, 1));
/* aus dem gesamt Sprößlingepool abziehen */ /* aus dem gesamt Sprößlingepool abziehen */
rsettrees(r, 1, rtrees(r, 1) - sprout); rsettrees(r, 1, rtrees(r, 1) - sprout);
/* zu den Bäumen hinzufügen */ /* zu den Bäumen hinzufügen */
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);
@ -585,7 +585,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 erhöht die Chance marginal */
elves = _min(elves, production(r) / 8); elves = _min(elves, production(r) / 8);
if (elves) { if (elves) {
seedchance += 1.0 - pow(0.99999, elves * RESOURCE_QUANTITY); seedchance += 1.0 - pow(0.99999, elves * RESOURCE_QUANTITY);
@ -606,19 +606,19 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
} }
} }
/* Bäume breiten sich in Nachbarregionen aus. */ /* Bäume 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 Bäume 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 Stück Boden finden, in dem sie
* keimen können, hängt von der Bewuchsdichte und der * keimen können, hängt von der Bewuchsdichte und der
* verfügbaren Fläche ab. In Gletschern gibt es weniger * verfügbaren Fläche ab. In Gletschern gibt es weniger
* Möglichkeiten als in Ebenen. */ * Möglichkeiten als in Ebenen. */
sprout = 0; sprout = 0;
seedchance = (1000 * maxworkingpeasants(r2)) / r2->terrain->size; seedchance = (1000 * maxworkingpeasants(r2)) / r2->terrain->size;
for (i = 0; i < seeds / MAXDIRECTIONS; i++) { for (i = 0; i < seeds / MAXDIRECTIONS; i++) {
@ -635,8 +635,8 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
if (is_cursed(r->attribs, C_CURSED_BY_THE_GODS, 0)) if (is_cursed(r->attribs, C_CURSED_BY_THE_GODS, 0))
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 Sprößlinge, die
* dieses Jahr älter werden dürfen, damit nicht ein Same im selben * dieses Jahr älter werden dürfen, 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) {
@ -644,13 +644,13 @@ growing_trees(region * r, const int current_season, const int last_weeks_season)
a->data.sa[0] = (short)rtrees(r, 0); a->data.sa[0] = (short)rtrees(r, 0);
a->data.sa[1] = (short)rtrees(r, 1); a->data.sa[1] = (short)rtrees(r, 1);
} }
/* wir haben 6 Wochen zum wachsen, jeder Same/Sproß hat 18% Chance /* wir haben 6 Wochen zum wachsen, jeder Same/Spross hat 18% Chance
* zu wachsen, damit sollten nach 5-6 Wochen alle gewachsen sein */ * zu wachsen, damit sollten nach 5-6 Wochen alle gewachsen sein */
growth = 1800; growth = 1800;
/* Samenwachstum */ /* Samenwachstum */
/* Raubbau abfangen, es dürfen nie mehr Samen wachsen, als aktuell /* Raubbau abfangen, es dürfen nie mehr Samen wachsen, als aktuell
* in der Region sind */ * in der Region sind */
seeds = _min(a->data.sa[0], rtrees(r, 0)); seeds = _min(a->data.sa[0], rtrees(r, 0));
sprout = 0; sprout = 0;
@ -663,15 +663,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 Sprößlinge hinzufügen */
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 Jungbäume nicht ohne weiteres aus
* der Region entfernt werden können, da Jungbäume in der gleichen * der Region entfernt werden können, da Jungbäume in der gleichen
* Runde nachwachsen, wir also nicht mehr zwischen diesjährigen und * Runde nachwachsen, wir also nicht mehr zwischen diesjährigen und
* 'alten' Jungbäumen unterscheiden könnten */ * 'alten' Jungbäumen unterscheiden könnten */
sprout = _min(a->data.sa[1], rtrees(r, 1)); sprout = _min(a->data.sa[1], rtrees(r, 1));
grownup_trees = 0; grownup_trees = 0;
@ -679,11 +679,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 Sprößlingepool 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 Sprößlingepool 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 bäumen hinzufügen */
rsettrees(r, 2, rtrees(r, 2) + grownup_trees); rsettrees(r, 2, rtrees(r, 2) + grownup_trees);
} }
} }
@ -691,10 +691,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 Kräutervermehrung. Vermehrt wird logistisch:
* *
* Jedes Kraut hat eine Wahrscheinlichkeit von (100-(vorhandene * Jedes Kraut hat eine Wahrscheinlichkeit von (100-(vorhandene
* Kräuter))% sich zu vermehren. */ * Kräuter))% sich zu vermehren. */
if (current_season != SEASON_WINTER) { if (current_season != SEASON_WINTER) {
int i; int i;
for (i = rherbs(r); i > 0; i--) { for (i = rherbs(r); i > 0; i--) {
@ -1072,7 +1072,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 können keine Gebäude betreten, außer 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)) {
@ -1188,8 +1188,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 löschen ihn, damit er im
* zweiten Versuch nicht nochmal ausgeführt wird. */ * zweiten Versuch nicht nochmal ausgeführt wird. */
*ordp = ord->next; *ordp = ord->next;
ord->next = NULL; ord->next = NULL;
free_order(ord); free_order(ord);
@ -1963,13 +1963,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" muß wegfallen, da gültige Nummer! */ * das Füllwort "AN" muss wegfallen, da gültige 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 */ /* können 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);
@ -2322,7 +2322,7 @@ static bool display_race(faction * f, unit * u, const race * rc)
if (wrptr(&bufp, &size, bytes) != 0) if (wrptr(&bufp, &size, bytes) != 0)
WARN_STATIC_BUFFER(); WARN_STATIC_BUFFER();
/* b_armor : Rüstung */ /* b_armor : Rüstung */
if (rc->armor > 0) { if (rc->armor > 0) {
bytes = bytes =
slprintf(bufp, size, ", %s: %d", LOC(f->locale, "stat_armor"), rc->armor); slprintf(bufp, size, ", %s: %d", LOC(f->locale, "stat_armor"), rc->armor);
@ -2633,7 +2633,7 @@ int combatspell_cmd(unit * u, struct order *ord)
init_order(ord); init_order(ord);
s = gettoken(token, sizeof(token)); s = gettoken(token, sizeof(token));
/* KAMPFZAUBER [NICHT] löscht alle gesetzten Kampfzauber */ /* KAMPFZAUBER [NICHT] löscht 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;
@ -2641,7 +2641,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 später */
level = getint(); level = getint();
level = _max(0, level); level = _max(0, level);
s = gettoken(token, sizeof(token)); s = gettoken(token, sizeof(token));
@ -2656,7 +2656,7 @@ 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 löscht diesen speziellen
* Kampfzauber */ * Kampfzauber */
unset_combatspell(u, sp); unset_combatspell(u, sp);
return 0; return 0;
@ -2671,7 +2671,7 @@ int combatspell_cmd(unit * u, struct order *ord)
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Beachten: einige Monster sollen auch unbewaffent die Region bewachen /* Beachten: einige Monster sollen auch unbewaffent die Region bewachen
* können */ * können */
enum { E_GUARD_OK, E_GUARD_UNARMED, E_GUARD_NEWBIE, E_GUARD_FLEEING }; enum { E_GUARD_OK, E_GUARD_UNARMED, E_GUARD_NEWBIE, E_GUARD_FLEEING };
@ -2733,7 +2733,7 @@ int guard_on_cmd(unit * u, struct order *ord)
cmistake(u, ord, 95, MSG_EVENT); cmistake(u, ord, 95, MSG_EVENT);
} }
else { else {
/* Monster der Monsterpartei dürfen immer bewachen */ /* Monster der Monsterpartei dürfen immer bewachen */
if (is_monsters(u->faction)) { if (is_monsters(u->faction)) {
guard(u, GUARD_ALL); guard(u, GUARD_ALL);
} }
@ -2767,7 +2767,7 @@ void sinkships(struct region * r)
if (!sh->type->construction || sh->size >= sh->type->construction->maxsize) { if (!sh->type->construction || sh->size >= sh->type->construction->maxsize) {
if (fval(r->terrain, SEA_REGION) && (!enoughsailors(sh, r) if (fval(r->terrain, SEA_REGION) && (!enoughsailors(sh, r)
|| get_captain(sh) == NULL)) { || get_captain(sh) == NULL)) {
/* Schiff nicht seetüchtig */ /* Schiff nicht seetüchtig */
float dmg = get_param_flt(global.parameters, float dmg = get_param_flt(global.parameters,
"rules.ship.damage.nocrewocean", "rules.ship.damage.nocrewocean",
0.30F); 0.30F);
@ -3224,7 +3224,7 @@ static void ageing(void)
sp = &(*sp)->next; sp = &(*sp)->next;
} }
/* Gebäude */ /* Gebäude */
for (bp = &r->buildings; *bp;) { for (bp = &r->buildings; *bp;) {
building *b = *bp; building *b = *bp;
age_building(b); age_building(b);
@ -3430,7 +3430,7 @@ void update_long_order(unit * u)
freset(u, UFL_MOVED); freset(u, UFL_MOVED);
freset(u, UFL_LONGACTION); freset(u, UFL_LONGACTION);
if (hunger) { if (hunger) {
/* Hungernde Einheiten führen NUR den default-Befehl aus */ /* Hungernde Einheiten führen NUR den default-Befehl aus */
set_order(&u->thisorder, default_order(u->faction->locale)); set_order(&u->thisorder, default_order(u->faction->locale));
} }
else { else {
@ -3451,7 +3451,7 @@ void update_long_order(unit * u)
continue; continue;
if (is_exclusive(ord)) { if (is_exclusive(ord)) {
/* Über dieser Zeile nur Befehle, die auch eine idle Faction machen darf */ /* über dieser Zeile nur Befehle, die auch eine idle Faction machen darf */
if (idle(u->faction)) { if (idle(u->faction)) {
set_order(&u->thisorder, default_order(u->faction->locale)); set_order(&u->thisorder, default_order(u->faction->locale));
} }
@ -3463,13 +3463,13 @@ void update_long_order(unit * u)
else { else {
keyword_t keyword = getkeyword(ord); keyword_t keyword = getkeyword(ord);
switch (keyword) { switch (keyword) {
/* Wenn gehandelt wird, darf kein langer Befehl ausgeführt /* Wenn gehandelt wird, darf kein langer Befehl ausgeführt
* werden. Da Handel erst nach anderen langen Befehlen kommt, * werden. Da Handel erst nach anderen langen Befehlen kommt,
* muß 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. */
case K_BUY: case K_BUY:
case K_SELL: case K_SELL:
/* Wenn die Einheit handelt, muß der Default-Befehl gelöscht /* Wenn die Einheit handelt, muss der Default-Befehl gelöscht
* werden. * werden.
* Wird je diese Ausschliesslichkeit aufgehoben, muss man aufpassen * Wird je diese Ausschliesslichkeit aufgehoben, muss man aufpassen
* mit der Reihenfolge von Kaufen, Verkaufen etc., damit es Spielern * mit der Reihenfolge von Kaufen, Verkaufen etc., damit es Spielern
@ -3479,7 +3479,7 @@ void update_long_order(unit * u)
case K_CAST: case K_CAST:
/* dient dazu, das neben Zaubern kein weiterer Befehl /* dient dazu, das neben Zaubern kein weiterer Befehl
* ausgeführt werden kann, Zaubern ist ein kurzer Befehl */ * ausgeführt werden kann, Zaubern ist ein kurzer Befehl */
set_order(&u->thisorder, copy_order(ord)); set_order(&u->thisorder, copy_order(ord));
break; break;
@ -3492,7 +3492,7 @@ void update_long_order(unit * u)
if (hunger) { if (hunger) {
return; return;
} }
/* Wenn die Einheit handelt, muß der Default-Befehl gelöscht /* Wenn die Einheit handelt, muss der Default-Befehl gelöscht
* werden. */ * werden. */
if (trade) { if (trade) {
@ -3568,7 +3568,7 @@ void monthly_healing(void)
double healingcurse = 0; double healingcurse = 0;
if (heal_ct != NULL) { if (heal_ct != NULL) {
/* bonus zurücksetzen */ /* bonus zurücksetzen */
curse *c = get_curse(r->attribs, heal_ct); curse *c = get_curse(r->attribs, heal_ct);
if (c != NULL) { if (c != NULL) {
healingcurse = curse_geteffect(c); healingcurse = curse_geteffect(c);
@ -3578,8 +3578,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 über Maximum bauen sich ab. Wird zb durch Elixier der Macht
* oder verändertes Ausdauertalent verursacht */ * oder verändertes Ausdauertalent verursacht */
if (u->hp > umhp) { if (u->hp > umhp) {
u->hp -= (int)ceil((u->hp - umhp) / 2.0); u->hp -= (int)ceil((u->hp - umhp) / 2.0);
if (u->hp < umhp) if (u->hp < umhp)
@ -3606,7 +3606,7 @@ void monthly_healing(void)
if (btype == bt_find("inn")) { if (btype == bt_find("inn")) {
p *= 1.5; p *= 1.5;
} }
/* pro punkt 5% höher */ /* pro punkt 5% höher */
p *= (1.0 + healingcurse * 0.05); p *= (1.0 + healingcurse * 0.05);
maxheal = p * maxheal; maxheal = p * maxheal;
@ -3618,7 +3618,7 @@ void monthly_healing(void)
/* Aufaddieren der geheilten HP. */ /* Aufaddieren der geheilten HP. */
u->hp = _min(u->hp + addhp, umhp); u->hp = _min(u->hp + addhp, umhp);
/* soll man an negativer regeneration sterben können? */ /* soll man an negativer regeneration sterben können? */
assert(u->hp > 0); assert(u->hp > 0);
} }
} }
@ -3665,7 +3665,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 löschen zu gunsten des neuen */
remove_exclusive(&u->orders); remove_exclusive(&u->orders);
remove_exclusive(&u->old_orders); remove_exclusive(&u->old_orders);
neworders = true; neworders = true;
@ -4548,8 +4548,8 @@ void processorders(void)
wormholes_update(); wormholes_update();
} }
/* immer ausführen, wenn neue Sprüche dazugekommen sind, oder sich /* immer ausführen, wenn neue Sprüche dazugekommen sind, oder sich
* Beschreibungen geändert haben */ * Beschreibungen geändert haben */
update_spells(); update_spells();
warn_password(); warn_password();
} }

80
src/move.c
View File

@ -1,4 +1,4 @@
/* /*
Copyright (c) 1998-2014, Copyright (c) 1998-2014,
Enno Rehling <enno@eressea.de> Enno Rehling <enno@eressea.de>
Katja Zedel <katze@felidae.kn-bremen.de Katja Zedel <katze@felidae.kn-bremen.de
@ -90,7 +90,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 ungünstiger Stelle */
a_writechars, a_writechars,
a_readchars a_readchars
}; };
@ -245,15 +245,15 @@ static int ridingcapacity(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 tr<EFBFBD>gt sein eigenes Gewicht plus seine Kapazit<69>t! Die Menschen
** tragen nichts (siehe walkingcapacity). Ein Wagen zählt nur, wenn er ** tragen nichts (siehe walkingcapacity). Ein Wagen z<EFBFBD>hlt nur, wenn er
** von zwei Pferden gezogen wird */ ** von zwei Pferden gezogen wird */
animals = _min(animals, effskill(u, SK_RIDING) * u->number * 2); animals = _min(animals, effskill(u, SK_RIDING) * u->number * 2);
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 k<EFBFBD>nnen zum Ziehen benutzt werden */
vehicles = _min(animals / HORSESNEEDED, vehicles); vehicles = _min(animals / HORSESNEEDED, vehicles);
return vehicles * vcap + animals * acap; return vehicles * vcap + animals * acap;
@ -282,7 +282,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 k<EFBFBD>nnen zum Ziehen benutzt werden */
wagen_mit_pferden = _min(vehicles, pferde_fuer_wagen / HORSESNEEDED); wagen_mit_pferden = _min(vehicles, pferde_fuer_wagen / HORSESNEEDED);
n = wagen_mit_pferden * vcap; n = wagen_mit_pferden * vcap;
@ -295,7 +295,7 @@ int walkingcapacity(const struct unit *u)
/* Genug Trolle, um die Restwagen zu ziehen? */ /* Genug Trolle, um die Restwagen zu ziehen? */
wagen_mit_trollen = _min(u->number / 4, wagen_ohne_pferde); wagen_mit_trollen = _min(u->number / 4, wagen_ohne_pferde);
/* Wagenkapazität hinzuzählen */ /* Wagenkapazit<EFBFBD>t hinzuz<75>hlen */
n += wagen_mit_trollen * vcap; n += wagen_mit_trollen * vcap;
wagen_ohne_pferde -= wagen_mit_trollen; wagen_ohne_pferde -= wagen_mit_trollen;
} }
@ -357,16 +357,16 @@ 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, da<EFBFBD> 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 mu<EFBFBD> nicht zwingend an den Wagen liegen, aber egal... (man
* könnte z.B. auch 8 Eisen abladen, damit ein weiterer Wagen als * k<EFBFBD>nnte z.B. auch 8 Eisen abladen, damit ein weiterer Wagen als
* Fracht draufpaßt) */ * Fracht draufpa<EFBFBD>t) */
return E_CANWALK_TOOHEAVY; return E_CANWALK_TOOHEAVY;
} }
@ -663,7 +663,7 @@ int check_ship_allowed(struct ship *sh, const region * r)
bt_harbour = bt_find("harbour"); 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 d<EFBFBD>rfen nicht hier rein. haben wir welche? */
unit *u; unit *u;
for (u = sh->region->units; u != NULL; u = u->next) { for (u = sh->region->units; u != NULL; u = u->next) {
@ -757,13 +757,13 @@ 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 gesch<EFBFBD>tzt? */
if (!drift || fval(sh, SF_DRIFTED) || is_cursed(sh->attribs, C_SHIP_NODRIFT, 0)) { if (!drift || fval(sh, SF_DRIFTED) || is_cursed(sh->attribs, C_SHIP_NODRIFT, 0)) {
shp = &sh->next; shp = &sh->next;
continue; continue;
} }
/* Kapitän bestimmen */ /* Kapit<EFBFBD>n bestimmen */
for (captain = r->units; captain; captain = captain->next) { for (captain = r->units; captain; captain = captain->next) {
if (captain->ship != sh) if (captain->ship != sh)
continue; continue;
@ -773,8 +773,8 @@ static void drifting_ships(region * r)
break; break;
} }
} }
/* Kapitän da? Beschädigt? Genügend Matrosen? /* Kapit<EFBFBD>n da? Besch<63>digt? Gen<65>gend Matrosen?
* Genügend leicht? Dann ist alles OK. */ * Gen<EFBFBD>gend leicht? Dann ist alles OK. */
assert(sh->type->construction->improvement == NULL); /* sonst ist construction::size nicht ship_type::maxsize */ assert(sh->type->construction->improvement == NULL); /* sonst ist construction::size nicht ship_type::maxsize */
if (captain && sh->size == sh->type->construction->maxsize if (captain && sh->size == sh->type->construction->maxsize
@ -784,7 +784,7 @@ static void drifting_ships(region * r)
} }
/* Auswahl einer Richtung: Zuerst auf Land, dann /* Auswahl einer Richtung: Zuerst auf Land, dann
* zufällig. Falls unmögliches Resultat: vergiß es. */ * zuf<EFBFBD>llig. Falls unm<EFBFBD>gliches Resultat: vergi<EFBFBD> es. */
d_offset = rng_int() % MAXDIRECTIONS; d_offset = rng_int() % MAXDIRECTIONS;
for (d = 0; d != MAXDIRECTIONS; ++d) { for (d = 0; d != MAXDIRECTIONS; ++d) {
region *rn; region *rn;
@ -1475,12 +1475,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 Fu<EFBFBD> reist man 1 Region, zu Pferd 2 Regionen. Mit Stra<EFBFBD>en reist
* man zu Fuß 2, mit Pferden 3 weit. * man zu Fu<EFBFBD> 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 Fu<EFBFBD> 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 Stra<EFBFBD>en nur 2 BP.
* Außerdem: Wenn Einheit transportiert, nur halbe BP * Au<EFBFBD>erdem: Wenn Einheit transportiert, nur halbe BP
*/ */
static int movement_speed(unit * u) static int movement_speed(unit * u)
{ {
@ -1620,7 +1620,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 k<EFBFBD>nnen. */
ADDMSG(&u->faction->msgs, msg_message("detectocean", ADDMSG(&u->faction->msgs, msg_message("detectocean",
"unit region", u, next)); "unit region", u, next));
break; break;
@ -1633,7 +1633,7 @@ static const region_list *travel_route(unit * u,
} }
} }
else { else {
/* Ozeanfelder können nur von Einheiten mit Schwimmen und ohne /* Ozeanfelder k<EFBFBD>nnen 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",
@ -1728,7 +1728,7 @@ static const region_list *travel_route(unit * u,
walkmode = 2; walkmode = 2;
} }
/* Berichte über Durchreiseregionen */ /* Berichte <EFBFBD>ber 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);
@ -1807,7 +1807,7 @@ buildingtype_exists(const region * r, const building_type * bt, bool working)
return false; return false;
} }
/* Prüft, ob Ablegen von einer Küste in eine der erlaubten Richtungen erfolgt. */ /* Pr<EFBFBD>ft, ob Ablegen von einer K<>ste in eine der erlaubten Richtungen erfolgt. */
static bool check_takeoff(ship * sh, region * from, region * to) static bool check_takeoff(ship * sh, region * from, region * to)
{ {
@ -1857,18 +1857,18 @@ sail(unit * u, order * ord, bool move_on_land, region_list ** routep)
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 ausgef<EFBFBD>hrt. */
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 n<EFBFBD>chste 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 g<EFBFBD>ltige,
* befahrene Region. */ * befahrene Region. */
while (next_point && current_point != next_point && step < k) { while (next_point && current_point != next_point && step < k) {
@ -1920,7 +1920,7 @@ sail(unit * u, order * ord, bool move_on_land, region_list ** routep)
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 n<EFBFBD>chste 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);
@ -2056,16 +2056,16 @@ sail(unit * u, order * ord, bool move_on_land, region_list ** routep)
sh = NULL; sh = NULL;
} }
/* Nun enthält current_point die Region, in der das Schiff seine Runde /* Nun enth<EFBFBD>lt 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 f<EFBFBD>r den Spieler, das
* ihm sagt, bis wohin er gesegelt ist, falls er überhaupt vom Fleck * ihm sagt, bis wohin er gesegelt ist, falls er <EFBFBD>berhaupt 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 K<EFBFBD>ste 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 gel<EFBFBD>scht werden. */
cycle_route(ord, u, step); cycle_route(ord, u, step);
set_order(&u->thisorder, NULL); set_order(&u->thisorder, NULL);
if (!move_on_land) { if (!move_on_land) {
@ -2090,7 +2090,7 @@ sail(unit * u, order * ord, bool move_on_land, region_list ** routep)
sh = move_ship(sh, starting_point, current_point, *routep); sh = move_ship(sh, starting_point, current_point, *routep);
/* Hafengebühren ? */ /* Hafengeb<EFBFBD>hren ? */
harbourmaster = owner_buildingtyp(current_point, bt_find("harbour")); harbourmaster = owner_buildingtyp(current_point, bt_find("harbour"));
if (sh && harbourmaster != NULL) { if (sh && harbourmaster != NULL) {
@ -2438,7 +2438,7 @@ static void piracy_cmd(unit * u, struct order *ord)
/* Wenn nicht, sehen wir, ob wir ein Ziel finden. */ /* Wenn nicht, sehen wir, ob wir ein Ziel finden. */
if (target_dir == NODIRECTION) { if (target_dir == NODIRECTION) {
/* Einheit ist also Kapitän. Jetzt gucken, in wievielen /* Einheit ist also Kapit<EFBFBD>n. Jetzt gucken, in wievielen
* Nachbarregionen potentielle Opfer sind. */ * Nachbarregionen potentielle Opfer sind. */
for (dir = 0; dir < MAXDIRECTIONS; dir++) { for (dir = 0; dir < MAXDIRECTIONS; dir++) {
@ -2497,7 +2497,7 @@ static void piracy_cmd(unit * u, struct order *ord)
set_order(&u->thisorder, create_order(K_MOVE, u->faction->locale, "%s", set_order(&u->thisorder, create_order(K_MOVE, u->faction->locale, "%s",
LOC(u->faction->locale, directions[target_dir]))); LOC(u->faction->locale, directions[target_dir])));
/* Bewegung ausführen */ /* Bewegung ausf<EFBFBD>hren */
init_order(u->thisorder); init_order(u->thisorder);
move(u, true); move(u, true);
} }
@ -2607,7 +2607,7 @@ static int hunt(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 ausf<EFBFBD>hren */
move(u, false); move(u, false);
return 1; /* true -> Einheitenliste von vorne durchgehen */ return 1; /* true -> Einheitenliste von vorne durchgehen */
} }
@ -2806,7 +2806,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 besch<EFBFBD>digten, unterbemannten, <20>berladenen Schiffen */
drifting_ships(r); drifting_ships(r);
} }
r = r->next; r = r->next;

15
src/spells.test.c
View File

@ -20,13 +20,10 @@
#include <assert.h> #include <assert.h>
static struct castorder *test_create_castorder(castorder *order, unit *u, const char *name, int level, float force, int range) { static void test_create_castorder(castorder *order, unit *u, int level, float force, int range) {
struct locale * lang; struct locale * lang;
spell *sp;
lang = get_or_create_locale("en"); lang = get_or_create_locale("en");
sp = create_spell(name, 0); create_castorder(order, u, NULL, NULL, u->region, level, force, range, create_order(K_CAST, lang, ""), NULL);
return order = create_castorder(order, u, NULL, sp, u->region, level, force, range, create_order(K_CAST, lang, ""), NULL);
} }
static void test_dreams(CuTest *tc) { static void test_dreams(CuTest *tc) {
@ -39,12 +36,12 @@ static void test_dreams(CuTest *tc) {
test_cleanup(); test_cleanup();
test_create_world(); test_create_world();
r=findregion(0, 0); r=findregion(0, 0);
f1 = test_create_faction(test_create_race("human")); f1 = test_create_faction(0);
f2 = test_create_faction(test_create_race("human")); f2 = test_create_faction(0);
u1 = test_create_unit(f1, r); u1 = test_create_unit(f1, r);
u2 = test_create_unit(f2, r); u2 = test_create_unit(f2, r);
test_create_castorder(&order, u1, "goodreams", 10, 10., 0); test_create_castorder(&order, u1, 10, 10., 0);
level = sp_gooddreams(&order); level = sp_gooddreams(&order);
CuAssertIntEquals(tc, 10, level); CuAssertIntEquals(tc, 10, level);
@ -57,7 +54,7 @@ static void test_dreams(CuTest *tc) {
CuAssertIntEquals(tc, 1, get_modifier(u1, SK_MELEE, 11, r, false)); CuAssertIntEquals(tc, 1, get_modifier(u1, SK_MELEE, 11, r, false));
CuAssertIntEquals(tc, 0, get_modifier(u2, SK_MELEE, 11, r, false)); CuAssertIntEquals(tc, 0, get_modifier(u2, SK_MELEE, 11, r, false));
test_create_castorder(&order, u1, "baddreams", 10, 10., 0); test_create_castorder(&order, u1, 10, 10., 0);
level = sp_baddreams(&order); level = sp_baddreams(&order);
CuAssertIntEquals(tc, 10, level); CuAssertIntEquals(tc, 10, level);