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

annotate with finds from PVS Studio trial static analysis

Browse source
This commit is contained in:
Enno Rehling 2015-07-06 21:31:27 +02:00
parent 09db2fe278
commit 05ec74f9ec
11 changed files with 132 additions and 132 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/creport.c
View file

@ -755,7 +755,7 @@ static void cr_output_unit(FILE * F, const region * r, const faction * f,
itemcloak_ct = ct_find("itemcloak"); itemcloak_ct = ct_find("itemcloak");
} }
if (itemcloak_ct != NULL) { if (itemcloak_ct != NULL) {
itemcloak = curse_active(get_curse(u->attribs, itemcloak_ct)); itemcloak = curse_active(get_curse(u->attribs, itemcloak_ct)); //TODO: V595 http://www.viva64.com/en/V595 The 'u' pointer was utilized before it was verified against nullptr. Check lines: 758, 761.
} }
assert(u && u->number); assert(u && u->number);

2
src/give.c
View file

@ -400,7 +400,7 @@ message * disband_men(int n, unit * u, struct order *ord) {
void give_unit(unit * u, unit * u2, order * ord) void give_unit(unit * u, unit * u2, order * ord)
{ {
region *r = u->region; region *r = u->region; //TODO: V595 http://www.viva64.com/en/V595 The 'u' pointer was utilized before it was verified against nullptr. Check lines: 403, 406.
int maxt = max_transfers(); int maxt = max_transfers();
assert(u); assert(u);

2
src/kernel/item.c
View file

@ -333,7 +333,7 @@ potion_type *new_potiontype(item_type * itype, int level)
void it_set_appearance(item_type *itype, const char *appearance) { void it_set_appearance(item_type *itype, const char *appearance) {
assert(itype && itype->rtype && appearance); assert(itype && itype->rtype && appearance);
itype->_appearance[0] = _strdup(appearance); itype->_appearance[0] = _strdup(appearance); //TODO: V595 http://www.viva64.com/en/V595 The 'appearance' pointer was utilized before it was verified against nullptr. Check lines: 336, 337.
itype->_appearance[1] = appearance ? itype->_appearance[1] = appearance ?
strcat(strcpy((char *)malloc(strlen((char *)appearance) + 3), (char *)appearance), "_p") : 0; strcat(strcpy((char *)malloc(strlen((char *)appearance) + 3), (char *)appearance), "_p") : 0;
} }

2
src/kernel/save.c
View file

@ -990,7 +990,7 @@ void writeregion(struct gamedata *data, const region * r)
rawmaterial *res = r->resources; rawmaterial *res = r->resources;
assert(r->land); assert(r->land);
WRITE_STR(data->store, (const char *)r->land->name); WRITE_STR(data->store, (const char *)r->land->name); //TODO: V595 http://www.viva64.com/en/V595 The 'r->land' pointer was utilized before it was verified against nullptr. Check lines: 993, 1023.
assert(rtrees(r, 0) >= 0); assert(rtrees(r, 0) >= 0);
assert(rtrees(r, 1) >= 0); assert(rtrees(r, 1) >= 0);
assert(rtrees(r, 2) >= 0); assert(rtrees(r, 2) >= 0);

8
src/laws.c
View file

@ -1741,7 +1741,7 @@ int name_cmd(struct unit *u, struct order *ord)
for (; lang; lang = nextlocale(lang)) { for (; lang; lang = nextlocale(lang)) {
const char *fdname = LOC(lang, "factiondefault"); const char *fdname = LOC(lang, "factiondefault");
size_t fdlen = strlen(fdname); size_t fdlen = strlen(fdname);
if (strlen(f->name) >= fdlen && strncmp(f->name, fdname, fdlen) == 0) { if (strlen(f->name) >= fdlen && strncmp(f->name, fdname, fdlen) == 0) { //TODO: V814 http://www.viva64.com/en/V814 Decreased performance. The 'strlen' function was called multiple times inside the body of a loop.
break; break;
} }
} }
@ -1778,14 +1778,14 @@ int name_cmd(struct unit *u, struct order *ord)
for (; lang; lang = nextlocale(lang)) { for (; lang; lang = nextlocale(lang)) {
const char *sdname = LOC(lang, sh->type->_name); const char *sdname = LOC(lang, sh->type->_name);
size_t sdlen = strlen(sdname); size_t sdlen = strlen(sdname);
if (strlen(sh->name) >= sdlen if (strlen(sh->name) >= sdlen //TODO: V814 http://www.viva64.com/en/V814 Decreased performance. The 'strlen' function was called multiple times inside the body of a loop.
&& strncmp(sh->name, sdname, sdlen) == 0) { && strncmp(sh->name, sdname, sdlen) == 0) {
break; break;
} }
sdname = LOC(lang, parameters[P_SHIP]); sdname = LOC(lang, parameters[P_SHIP]);
sdlen = strlen(sdname); sdlen = strlen(sdname);
if (strlen(sh->name) >= sdlen if (strlen(sh->name) >= sdlen //TODO: V814 http://www.viva64.com/en/V814 Decreased performance. The 'strlen' function was called multiple times inside the body of a loop.
&& strncmp(sh->name, sdname, sdlen) == 0) { && strncmp(sh->name, sdname, sdlen) == 0) {
break; break;
} }
@ -2718,7 +2718,7 @@ int guard_on_cmd(unit * u, struct order *ord)
init_order(ord); init_order(ord);
/* GUARD NOT is handled in goard_off_cmd earlier in the turn */ /* GUARD NOT is handled in goard_off_cmd earlier in the turn */
if (getparam(u->faction->locale) == P_NOT) if (getparam(u->faction->locale) == P_NOT) //TODO: V595 http://www.viva64.com/en/V595 The 'u->faction' pointer was utilized before it was verified against nullptr. Check lines: 2721, 2737.
return 0; return 0;
if (fval(u->region->terrain, SEA_REGION)) { if (fval(u->region->terrain, SEA_REGION)) {

218
src/magic.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
@ -193,7 +193,7 @@ attrib_type at_icastle = {
extern int dice(int count, int value); extern int dice(int count, int value);
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* aus dem alten System übriggebliegene Funktionen, die bei der /* aus dem alten System übriggebliegene Funktionen, die bei der
* Umwandlung von alt nach neu gebraucht werden */ * Umwandlung von alt nach neu gebraucht werden */
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -352,9 +352,9 @@ sc_mage *get_mage(const unit * u)
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Ausgabe der Spruchbeschreibungen /* Ausgabe der Spruchbeschreibungen
* Anzeige des Spruchs nur, wenn die Stufe des besten Magiers vorher * Anzeige des Spruchs nur, wenn die Stufe des besten Magiers vorher
* kleiner war (u->faction->seenspells). Ansonsten muss nur geprüft * kleiner war (u->faction->seenspells). Ansonsten muss nur geprüft
* werden, ob dieser Magier den Spruch schon kennt, und andernfalls der * werden, ob dieser Magier den Spruch schon kennt, und andernfalls der
* Spruch zu seiner List-of-known-spells hinzugefügt werden. * Spruch zu seiner List-of-known-spells hinzugefügt werden.
*/ */
static int read_seenspell(attrib * a, void *owner, struct storage *store) static int read_seenspell(attrib * a, void *owner, struct storage *store)
@ -507,7 +507,7 @@ sc_mage *create_mage(unit * u, magic_t mtyp)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Funktionen für die Bearbeitung der List-of-known-spells */ /* Funktionen für die Bearbeitung der List-of-known-spells */
int u_hasspell(const unit *u, const struct spell *sp) int u_hasspell(const unit *u, const struct spell *sp)
{ {
@ -535,7 +535,7 @@ int get_combatspelllevel(const unit * u, int nr)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Kampfzauber ermitteln, setzen oder löschen */ /* Kampfzauber ermitteln, setzen oder löschen */
const spell *get_combatspell(const unit * u, int nr) const spell *get_combatspell(const unit * u, int nr)
{ {
@ -560,7 +560,7 @@ void set_combatspell(unit * u, spell * sp, struct order *ord, int level)
assert(mage || !"trying to set a combat spell for non-mage"); assert(mage || !"trying to set a combat spell for non-mage");
/* knowsspell prüft auf ist_magier, ist_spruch, kennt_spruch */ /* knowsspell prüft 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);
@ -626,7 +626,7 @@ void unset_combatspell(unit * u, spell * sp)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Gibt die aktuelle Anzahl der Magiepunkte der Einheit zurück */ /* Gibt die aktuelle Anzahl der Magiepunkte der Einheit zurück */
int get_spellpoints(const unit * u) int get_spellpoints(const unit * u)
{ {
sc_mage *m; sc_mage *m;
@ -652,7 +652,7 @@ void set_spellpoints(unit * u, int sp)
} }
/* /*
* verändert die Anzahl der Magiepunkte der Einheit um +mp * verändert die Anzahl der Magiepunkte der Einheit um +mp
*/ */
int change_spellpoints(unit * u, int mp) int change_spellpoints(unit * u, int mp)
{ {
@ -671,7 +671,7 @@ int change_spellpoints(unit * u, int mp)
return sp; return sp;
} }
/* bietet die Möglichkeit, die maximale Anzahl der Magiepunkte mit /* bietet die Möglichkeit, die maximale Anzahl der Magiepunkte mit
* Regionszaubern oder Attributen zu beinflussen * Regionszaubern oder Attributen zu beinflussen
*/ */
static int get_spchange(const unit * u) static int get_spchange(const unit * u)
@ -687,13 +687,13 @@ static int get_spchange(const unit * u)
/* ein Magier kann normalerweise maximal Stufe^2.1/1.2+1 Magiepunkte /* ein Magier kann normalerweise maximal Stufe^2.1/1.2+1 Magiepunkte
* haben. * haben.
* Manche Rassen haben einen zusätzlichen Multiplikator * Manche Rassen haben einen zusätzlichen Multiplikator
* Durch Talentverlust (zB Insekten im Berg) können negative Werte * Durch Talentverlust (zB Insekten im Berg) können negative Werte
* entstehen * entstehen
*/ */
/* Artefakt der Stärke /* Artefakt der Stärke
* Ermöglicht dem Magier mehr Magiepunkte zu 'speichern' * Ermöglicht dem Magier mehr Magiepunkte zu 'speichern'
*/ */
/** TODO: at_skillmod daraus machen */ /** TODO: at_skillmod daraus machen */
static int use_item_aura(const region * r, const unit * u) static int use_item_aura(const region * r, const unit * u)
@ -741,8 +741,8 @@ int change_maxspellpoints(unit * u, int csp)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Counter für die bereits gezauberte Anzahl Sprüche pro Runde. /* Counter für die bereits gezauberte Anzahl Sprüche pro Runde.
* Um nur die Zahl der bereits gezauberten Sprüche zu ermitteln mit * Um nur die Zahl der bereits gezauberten Sprüche zu ermitteln mit
* step = 0 aufrufen. * step = 0 aufrufen.
*/ */
int countspells(unit * u, int step) int countspells(unit * u, int step)
@ -766,9 +766,9 @@ int countspells(unit * u, int step)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Die für den Spruch benötigte Aura pro Stufe. /* Die für den Spruch benötigte Aura pro Stufe.
* Die Grundkosten pro Stufe werden hier um 2^count erhöht. Der * Die Grundkosten pro Stufe werden hier um 2^count erhöht. Der
* Parameter count ist dabei die Anzahl der bereits gezauberten Sprüche * Parameter count ist dabei die Anzahl der bereits gezauberten Sprüche
*/ */
int spellcost(unit * u, const spell * sp) int spellcost(unit * u, const spell * sp)
{ {
@ -786,12 +786,12 @@ int spellcost(unit * u, const spell * sp)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* SPC_LINEAR ist am höchstwertigen, dann müssen Komponenten für die /* SPC_LINEAR ist am höchstwertigen, dann müssen Komponenten für die
* Stufe des Magiers vorhanden sein. * Stufe des Magiers vorhanden sein.
* SPC_LINEAR hat die gewünschte Stufe als multiplikator, * SPC_LINEAR hat die gewünschte Stufe als multiplikator,
* nur SPC_FIX muss nur einmal vorhanden sein, ist also am * nur SPC_FIX muss nur einmal vorhanden sein, ist also am
* niedrigstwertigen und sollte von den beiden anderen Typen * niedrigstwertigen und sollte von den beiden anderen Typen
* überschrieben werden */ * überschrieben werden */
static int spl_costtyp(const spell * sp) static int spl_costtyp(const spell * sp)
{ {
int k; int k;
@ -805,7 +805,7 @@ static int spl_costtyp(const spell * sp)
return SPC_LINEAR; return SPC_LINEAR;
} }
/* wenn keine Fixkosten, Typ übernehmen */ /* wenn keine Fixkosten, Typ übernehmen */
if (sp->components[k].cost != SPC_FIX) { if (sp->components[k].cost != SPC_FIX) {
costtyp = sp->components[k].cost; costtyp = sp->components[k].cost;
} }
@ -814,10 +814,10 @@ static int spl_costtyp(const spell * sp)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* durch Komponenten und cast_level begrenzter maximal möglicher /* durch Komponenten und cast_level begrenzter maximal möglicher
* Level * Level
* Da die Funktion nicht alle Komponenten durchprobiert sondern beim * Da die Funktion nicht alle Komponenten durchprobiert sondern beim
* ersten Fehler abbricht, muss die Fehlermeldung später mit cancast() * ersten Fehler abbricht, muss die Fehlermeldung später mit cancast()
* generiert werden. * generiert werden.
* */ * */
int eff_spelllevel(unit * u, const spell * sp, int cast_level, int range) int eff_spelllevel(unit * u, const spell * sp, int cast_level, int range)
@ -831,8 +831,8 @@ int eff_spelllevel(unit * u, const spell * sp, int cast_level, int range)
return 0; return 0;
if (sp->components[k].amount > 0) { if (sp->components[k].amount > 0) {
/* Die Kosten für Aura sind auch von der Zahl der bereits /* Die Kosten für Aura sind auch von der Zahl der bereits
* gezauberten Sprüche abhängig */ * gezauberten Sprüche abhängig */
if (sp->components[k].type == r_aura) { if (sp->components[k].type == r_aura) {
needplevel = spellcost(u, sp) * range; needplevel = spellcost(u, sp) * range;
} }
@ -844,18 +844,18 @@ int eff_spelllevel(unit * u, const spell * sp, int cast_level, int range)
needplevel * cast_level) / needplevel; needplevel * cast_level) / needplevel;
/* sind die Kosten fix, so muss die Komponente nur einmal vorhanden /* sind die Kosten fix, so muss die Komponente nur einmal vorhanden
* sein und der cast_level ändert sich nicht */ * sein und der cast_level ändert sich nicht */
if (sp->components[k].cost == SPC_FIX) { if (sp->components[k].cost == SPC_FIX) {
if (maxlevel < 1) if (maxlevel < 1)
cast_level = 0; cast_level = 0;
/* ansonsten wird das Minimum aus maximal möglicher Stufe und der /* ansonsten wird das Minimum aus maximal möglicher Stufe und der
* gewünschten gebildet */ * gewünschten gebildet */
} }
else if (sp->components[k].cost == SPC_LEVEL) { else if (sp->components[k].cost == SPC_LEVEL) {
costtyp = SPC_LEVEL; costtyp = SPC_LEVEL;
cast_level = _min(cast_level, maxlevel); cast_level = _min(cast_level, maxlevel);
/* bei Typ Linear müssen die Kosten in Höhe der Stufe vorhanden /* bei Typ Linear müssen die Kosten in Höhe der Stufe vorhanden
* sein, ansonsten schlägt der Spruch fehl */ * sein, ansonsten schlägt der Spruch fehl */
} }
else if (sp->components[k].cost == SPC_LINEAR) { else if (sp->components[k].cost == SPC_LINEAR) {
costtyp = SPC_LINEAR; costtyp = SPC_LINEAR;
@ -882,7 +882,7 @@ int eff_spelllevel(unit * u, const spell * sp, int cast_level, int range)
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Die Spruchgrundkosten werden mit der Entfernung (Farcasting) /* Die Spruchgrundkosten werden mit der Entfernung (Farcasting)
* multipliziert, wobei die Aurakosten ein Sonderfall sind, da sie sich * multipliziert, wobei die Aurakosten ein Sonderfall sind, da sie sich
* auch durch die Menge der bereits gezauberten Sprüche erhöht. * auch durch die Menge der bereits gezauberten Sprüche erhöht.
* Je nach Kostenart werden dann die Komponenten noch mit cast_level * Je nach Kostenart werden dann die Komponenten noch mit cast_level
* multipliziert. * multipliziert.
*/ */
@ -913,12 +913,12 @@ void pay_spell(unit * u, const spell * sp, int cast_level, int range)
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Ein Magier kennt den Spruch und kann sich die Beschreibung anzeigen /* Ein Magier kennt den Spruch und kann sich die Beschreibung anzeigen
* lassen, wenn diese in seiner Spruchliste steht. Zaubern muss er ihn * lassen, wenn diese in seiner Spruchliste steht. Zaubern muss er ihn
* aber dann immer noch nicht können, vieleicht ist seine Stufe derzeit * aber dann immer noch nicht können, vieleicht ist seine Stufe derzeit
* nicht ausreichend oder die Komponenten fehlen. * nicht ausreichend oder die Komponenten fehlen.
*/ */
bool knowsspell(const region * r, const unit * u, const spell * sp) bool knowsspell(const region * r, const unit * u, const spell * sp)
{ {
/* Ist überhaupt ein gültiger Spruch angegeben? */ /* Ist überhaupt ein gültiger Spruch angegeben? */
if (!sp || sp->id == 0) { if (!sp || sp->id == 0) {
return false; return false;
} }
@ -929,7 +929,7 @@ bool knowsspell(const region * r, const unit * u, const spell * sp)
/* Um einen Spruch zu beherrschen, muss der Magier die Stufe des /* Um einen Spruch zu beherrschen, muss der Magier die Stufe des
* Spruchs besitzen, nicht nur wissen, das es ihn gibt (also den Spruch * Spruchs besitzen, nicht nur wissen, das es ihn gibt (also den Spruch
* in seiner Spruchliste haben). * in seiner Spruchliste haben).
* Kosten für einen Spruch können Magiepunkte, Silber, Kraeuter * Kosten für einen Spruch können Magiepunkte, Silber, Kraeuter
* und sonstige Gegenstaende sein. * und sonstige Gegenstaende sein.
*/ */
@ -948,7 +948,7 @@ cancast(unit * u, const spell * sp, int level, int range, struct order * ord)
} }
/* reicht die Stufe aus? */ /* reicht die Stufe aus? */
if (eff_skill(u, SK_MAGIC, u->region) < level) { if (eff_skill(u, SK_MAGIC, u->region) < level) {
/* die Einheit ist nicht erfahren genug für diesen Zauber */ /* die Einheit ist nicht erfahren genug für diesen Zauber */
cmistake(u, ord, 169, MSG_MAGIC); cmistake(u, ord, 169, MSG_MAGIC);
return false; return false;
} }
@ -958,8 +958,8 @@ cancast(unit * u, const spell * sp, int level, int range, struct order * ord)
const resource_type *rtype = sp->components[k].type; const resource_type *rtype = sp->components[k].type;
int itemhave; int itemhave;
/* Die Kosten für Aura sind auch von der Zahl der bereits /* Die Kosten für Aura sind auch von der Zahl der bereits
* gezauberten Sprüche abhängig */ * gezauberten Sprüche abhängig */
if (rtype == r_aura) { if (rtype == r_aura) {
itemanz = spellcost(u, sp) * range; itemanz = spellcost(u, sp) * range;
} }
@ -967,7 +967,7 @@ cancast(unit * u, const spell * sp, int level, int range, struct order * ord)
itemanz = sp->components[k].amount * range; itemanz = sp->components[k].amount * range;
} }
/* sind die Kosten stufenabhängig, so muss itemanz noch mit dem /* sind die Kosten stufenabhängig, so muss itemanz noch mit dem
* level multipliziert werden */ * level multipliziert werden */
switch (sp->components[k].cost) { switch (sp->components[k].cost) {
case SPC_LEVEL: case SPC_LEVEL:
@ -1004,7 +1004,7 @@ cancast(unit * u, const spell * sp, int level, int range, struct order * ord)
* Spruchitems und Antimagiefeldern zusammen. Es koennen noch die * Spruchitems und Antimagiefeldern zusammen. Es koennen noch die
* Stufe des Spruchs und Magiekosten mit einfliessen. * Stufe des Spruchs und Magiekosten mit einfliessen.
* *
* Die effektive Spruchstärke und ihre Auswirkungen werden in der * Die effektive Spruchstärke und ihre Auswirkungen werden in der
* Spruchfunktionsroutine ermittelt. * Spruchfunktionsroutine ermittelt.
*/ */
@ -1080,7 +1080,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 vernünfigt
* rechnen kann */ * rechnen kann */
static int farcasting(unit * magician, region * r) static int farcasting(unit * magician, region * r)
{ {
@ -1166,7 +1166,7 @@ double magic_resistance(unit * target)
/* Bonus durch Artefakte */ /* Bonus durch Artefakte */
/* TODO (noch gibs keine) */ /* TODO (noch gibs keine) */
/* Bonus durch Gebäude */ /* Bonus durch Gebäude */
{ {
struct building *b = inside_building(target); struct building *b = inside_building(target);
const struct building_type *btype = b ? b->type : NULL; const struct building_type *btype = b ? b->type : NULL;
@ -1179,14 +1179,14 @@ double magic_resistance(unit * target)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Prüft, ob das Objekt dem Zauber widerstehen kann. /* Prüft, ob das Objekt dem Zauber widerstehen kann.
* Objekte können Regionen, Units, Gebäude oder Schiffe sein. * Objekte können Regionen, Units, Gebäude oder Schiffe sein.
* TYP_UNIT: * TYP_UNIT:
* Das höchste Talent des Ziels ist sein 'Magieresistenz-Talent', Magier * Das höchste Talent des Ziels ist sein 'Magieresistenz-Talent', Magier
* bekommen einen Bonus. Grundchance ist 50%, für jede Stufe * bekommen einen Bonus. Grundchance ist 50%, für jede Stufe
* Unterschied gibt es 5%, minimalchance ist 5% für jeden (5-95%) * Unterschied gibt es 5%, minimalchance ist 5% für jeden (5-95%)
* Scheitert der Spruch an der Magieresistenz, so gibt die Funktion * Scheitert der Spruch an der Magieresistenz, so gibt die Funktion
* true zurück * true zurück
*/ */
bool bool
@ -1248,8 +1248,8 @@ target_resists_magic(unit * magician, void *obj, int objtyp, int t_bonus)
probability = _min(0.98, probability); probability = _min(0.98, probability);
/* gibt true, wenn die Zufallszahl kleiner als die chance ist und /* gibt true, wenn die Zufallszahl kleiner als die chance ist und
* false, wenn sie gleich oder größer ist, dh je größer die * false, wenn sie gleich oder größer ist, dh je größer die
* Magieresistenz (chance) desto eher gibt die Funktion true zurück */ * Magieresistenz (chance) desto eher gibt die Funktion true zurück */
return chance(probability); return chance(probability);
} }
@ -1276,7 +1276,7 @@ bool fumble(region * r, unit * u, const spell * sp, int cast_grade)
{ {
/* X ergibt Zahl zwischen 1 und 0, je kleiner, desto besser der Magier. /* X ergibt Zahl zwischen 1 und 0, je kleiner, desto besser der Magier.
* 0,5*40-20=0, dh wenn der Magier doppelt so gut ist, wie der Spruch * 0,5*40-20=0, dh wenn der Magier doppelt so gut ist, wie der Spruch
* benötigt, gelingt er immer, ist er gleich gut, gelingt der Spruch mit * benötigt, gelingt er immer, ist er gleich gut, gelingt der Spruch mit
* 20% Warscheinlichkeit nicht * 20% Warscheinlichkeit nicht
* */ * */
@ -1306,8 +1306,8 @@ bool fumble(region * r, unit * u, const spell * sp, int cast_grade)
fumble_chance += CHAOSPATZERCHANCE; fumble_chance += CHAOSPATZERCHANCE;
} }
/* wenn die Chance kleiner als 0 ist, können wir gleich false /* wenn die Chance kleiner als 0 ist, können wir gleich false
* zurückgeben */ * zurückgeben */
if (fumble_chance <= 0) { if (fumble_chance <= 0) {
return false; return false;
} }
@ -1317,7 +1317,7 @@ bool fumble(region * r, unit * u, const spell * sp, int cast_grade)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Dummy-Zauberpatzer, Platzhalter für speziel auf die Sprüche /* Dummy-Zauberpatzer, Platzhalter für speziel auf die Sprüche
* zugeschnittene Patzer */ * zugeschnittene Patzer */
static void fumble_default(castorder * co) static void fumble_default(castorder * co)
{ {
@ -1328,7 +1328,7 @@ static void fumble_default(castorder * co)
return; return;
} }
/* Die normalen Spruchkosten müssen immer bezahlt werden, hier noch /* Die normalen Spruchkosten müssen immer bezahlt werden, hier noch
* alle weiteren Folgen eines Patzers * alle weiteren Folgen eines Patzers
*/ */
@ -1390,7 +1390,7 @@ static void do_fumble(castorder * co)
break; break;
case 3: case 3:
case 4: case 4:
/* Spruch schlägt fehl, alle Magiepunkte weg */ /* Spruch schlägt fehl, alle Magiepunkte weg */
set_spellpoints(u, 0); set_spellpoints(u, 0);
ADDMSG(&u->faction->msgs, msg_message("patzer3", "unit region spell", ADDMSG(&u->faction->msgs, msg_message("patzer3", "unit region spell",
u, r, sp)); u, r, sp));
@ -1409,7 +1409,7 @@ static void do_fumble(castorder * co)
case 8: case 8:
case 9: case 9:
default: default:
/* Spruch gelingt, alle nachfolgenden Sprüche werden 2^4 so teuer */ /* Spruch gelingt, alle nachfolgenden Sprüche werden 2^4 so teuer */
co->level = sp->cast(co); co->level = sp->cast(co);
ADDMSG(&u->faction->msgs, msg_message("patzer5", "unit region spell", ADDMSG(&u->faction->msgs, msg_message("patzer5", "unit region spell",
u, r, sp)); u, r, sp));
@ -1422,7 +1422,7 @@ static void do_fumble(castorder * co)
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Ein Magier regeneriert pro Woche W(Stufe^1.5/2+1), mindestens 1 /* Ein Magier regeneriert pro Woche W(Stufe^1.5/2+1), mindestens 1
* Zwerge nur die Hälfte * Zwerge nur die Hälfte
*/ */
static double regeneration(unit * u) static double regeneration(unit * u)
{ {
@ -1439,7 +1439,7 @@ static double regeneration(unit * u)
/* Einfluss von Artefakten */ /* Einfluss von Artefakten */
/* TODO (noch gibs keine) */ /* TODO (noch gibs keine) */
/* Würfeln */ /* Würfeln */
aura = (rng_double() * d + rng_double() * d) / 2 + 1; aura = (rng_double() * d + rng_double() * d) / 2 + 1;
aura *= MagicRegeneration(); aura *= MagicRegeneration();
@ -1469,8 +1469,8 @@ void regenerate_aura(void)
const struct building_type *btype = b ? b->type : NULL; const struct building_type *btype = b ? b->type : NULL;
reg_aura = regeneration(u); reg_aura = regeneration(u);
/* Magierturm erhöht die Regeneration um 75% */ /* Magierturm erhöht die Regeneration um 75% */
/* Steinkreis erhöht die Regeneration um 50% */ /* Steinkreis erhöht die Regeneration um 50% */
if (btype) if (btype)
reg_aura *= btype->auraregen; reg_aura *= btype->auraregen;
@ -1609,14 +1609,14 @@ order * ord)
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Zuerst wird versucht alle noch nicht gefundenen Objekte zu finden /* Zuerst wird versucht alle noch nicht gefundenen Objekte zu finden
* oder zu prüfen, ob das gefundene Objekt wirklich hätte gefunden * oder zu prüfen, ob das gefundene Objekt wirklich hätte gefunden
* werden dürfen (nicht alle Zauber wirken global). Dabei zählen wir die * werden dürfen (nicht alle Zauber wirken global). Dabei zählen wir die
* Misserfolge (failed). * Misserfolge (failed).
* Dann folgen die Tests der gefundenen Objekte auf Magieresistenz und * Dann folgen die Tests der gefundenen Objekte auf Magieresistenz und
* Sichtbarkeit. Dabei zählen wir die magieresistenten (resists) * Sichtbarkeit. Dabei zählen wir die magieresistenten (resists)
* Objekte. Alle anderen werten wir als Erfolge (success) */ * Objekte. Alle anderen werten wir als Erfolge (success) */
/* gibt bei Misserfolg 0 zurück, bei Magieresistenz zumindeste eines /* gibt bei Misserfolg 0 zurück, bei Magieresistenz zumindeste eines
* Objektes 1 und bei Erfolg auf ganzer Linie 2 */ * Objektes 1 und bei Erfolg auf ganzer Linie 2 */
static void static void
verify_targets(castorder * co, int *invalid, int *resist, int *success) verify_targets(castorder * co, int *invalid, int *resist, int *success)
@ -1634,8 +1634,8 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success)
if (sa && sa->length) { if (sa && sa->length) {
/* zuerst versuchen wir vorher nicht gefundene Objekte zu finden. /* zuerst versuchen wir vorher nicht gefundene Objekte zu finden.
* Wurde ein Objekt durch globalsuche gefunden, obwohl der Zauber * Wurde ein Objekt durch globalsuche gefunden, obwohl der Zauber
* gar nicht global hätte suchen dürften, setzen wir das Objekt * gar nicht global hätte suchen dürften, setzen wir das Objekt
* zurück. */ * zurück. */
for (i = 0; i < sa->length; i++) { for (i = 0; i < sa->length; i++) {
spllprm *spobj = sa->param[i]; spllprm *spobj = sa->param[i];
@ -1719,7 +1719,7 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success)
case SPP_REGION: case SPP_REGION:
/* haben wir ein Regionsobjekt, dann wird auch dieses und /* haben wir ein Regionsobjekt, dann wird auch dieses und
nicht target_r überprüft. */ nicht target_r überprüft. */
tr = spobj->data.r; tr = spobj->data.r;
if ((sp->sptyp & TESTRESISTANCE) if ((sp->sptyp & TESTRESISTANCE)
@ -1745,7 +1745,7 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success)
else { else {
/* der Zauber hat keine expliziten Parameter/Ziele, es kann sich /* der Zauber hat keine expliziten Parameter/Ziele, es kann sich
* aber um einen Regionszauber handeln. Wenn notwendig hier die * aber um einen Regionszauber handeln. Wenn notwendig hier die
* Magieresistenz der Region prüfen. */ * Magieresistenz der Region prüfen. */
if ((sp->sptyp & REGIONSPELL)) { if ((sp->sptyp & REGIONSPELL)) {
/* Zielobjekt Region anlegen */ /* Zielobjekt Region anlegen */
spllprm *spobj = (spllprm *)malloc(sizeof(spllprm)); spllprm *spobj = (spllprm *)malloc(sizeof(spllprm));
@ -1782,7 +1782,7 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success)
} }
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Hilfsstrukturen für ZAUBERE */ /* Hilfsstrukturen für ZAUBERE */
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
static void free_spellparameter(spellparameter * pa) static void free_spellparameter(spellparameter * pa)
@ -1799,7 +1799,7 @@ static void free_spellparameter(spellparameter * pa)
default: default:
break; break;
} }
free(pa->param[i]); free(pa->param[i]); //TODO: V595 http://www.viva64.com/en/V595 The 'pa->param' pointer was utilized before it was verified against nullptr. Check lines: 1802, 1805.
} }
if (pa->param) if (pa->param)
@ -1966,7 +1966,7 @@ static spellparameter *add_spellparameter(region * target_r, unit * u,
break; break;
case '+': case '+':
/* das vorhergehende Element kommt ein oder mehrmals vor, wir /* das vorhergehende Element kommt ein oder mehrmals vor, wir
* springen zum key zurück */ * springen zum key zurück */
j = 0; j = 0;
--c; --c;
break; break;
@ -2090,7 +2090,7 @@ void free_castorder(struct castorder *co)
if (co->order) free_order(co->order); if (co->order) free_order(co->order);
} }
/* Hänge c-order co an die letze c-order von cll an */ /* Hänge c-order co an die letze c-order von cll an */
void add_castorder(spellrank * cll, castorder * co) void add_castorder(spellrank * cll, castorder * co)
{ {
if (cll->begin == NULL) { if (cll->begin == NULL) {
@ -2521,7 +2521,7 @@ static castorder *cast_cmd(unit * u, order * ord)
init_order(ord); init_order(ord);
s = gettoken(token, sizeof(token)); s = gettoken(token, sizeof(token));
param = findparam(s, u->faction->locale); param = findparam(s, u->faction->locale);
/* für Syntax ' STUFE x REGION y z ' */ /* für Syntax ' STUFE x REGION y z ' */
if (param == P_LEVEL) { if (param == P_LEVEL) {
int p = getint(); int p = getint();
level = _min(p, level); level = _min(p, level);
@ -2550,8 +2550,8 @@ static castorder *cast_cmd(unit * u, order * ord)
s = gettoken(token, sizeof(token)); s = gettoken(token, sizeof(token));
param = findparam(s, u->faction->locale); param = findparam(s, u->faction->locale);
} }
/* für Syntax ' REGION x y STUFE z ' /* für Syntax ' REGION x y STUFE z '
* hier nach REGION nochmal auf STUFE prüfen */ * hier nach REGION nochmal auf STUFE prüfen */
if (param == P_LEVEL) { if (param == P_LEVEL) {
int p = getint(); int p = getint();
level = _min(p, level); level = _min(p, level);
@ -2570,8 +2570,8 @@ static castorder *cast_cmd(unit * u, order * ord)
sp = unit_getspell(u, s, u->faction->locale); sp = unit_getspell(u, s, u->faction->locale);
/* Vertraute können auch Zauber sprechen, die sie selbst nicht /* Vertraute können auch Zauber sprechen, die sie selbst nicht
* können. unit_getspell findet aber nur jene Sprüche, die * können. unit_getspell findet aber nur jene Sprüche, die
* die Einheit beherrscht. */ * die Einheit beherrscht. */
if (!sp && is_familiar(u)) { if (!sp && is_familiar(u)) {
caster = get_familiar_mage(u); caster = get_familiar_mage(u);
@ -2594,7 +2594,7 @@ static castorder *cast_cmd(unit * u, order * ord)
/* um testen auf spruchnamen zu unterbinden sollte vor allen /* um testen auf spruchnamen zu unterbinden sollte vor allen
* fehlermeldungen die anzeigen das der magier diesen Spruch * fehlermeldungen die anzeigen das der magier diesen Spruch
* nur in diese Situation nicht anwenden kann, noch eine * nur in diese Situation nicht anwenden kann, noch eine
* einfache Sicherheitsprüfung kommen */ * einfache Sicherheitsprüfung kommen */
if (!knowsspell(r, u, sp)) { if (!knowsspell(r, u, sp)) {
/* vorsicht! u kann der familiar sein */ /* vorsicht! u kann der familiar sein */
if (!familiar) { if (!familiar) {
@ -2607,9 +2607,9 @@ static castorder *cast_cmd(unit * u, order * ord)
cmistake(u, ord, 174, MSG_MAGIC); cmistake(u, ord, 174, MSG_MAGIC);
return 0; return 0;
} }
/* Auf dem Ozean Zaubern als quasi-langer Befehl können /* Auf dem Ozean Zaubern als quasi-langer Befehl können
* normalerweise nur Meermenschen, ausgenommen explizit als * normalerweise nur Meermenschen, ausgenommen explizit als
* OCEANCASTABLE deklarierte Sprüche */ * OCEANCASTABLE deklarierte Sprüche */
if (fval(r->terrain, SEA_REGION)) { if (fval(r->terrain, SEA_REGION)) {
if (u_race(u) != get_race(RC_AQUARIAN) if (u_race(u) != get_race(RC_AQUARIAN)
&& !fval(u_race(u), RCF_SWIM) && !fval(u_race(u), RCF_SWIM)
@ -2632,7 +2632,7 @@ static castorder *cast_cmd(unit * u, order * ord)
} }
} }
} }
/* Farcasting bei nicht farcastbaren Sprüchen abfangen */ /* Farcasting bei nicht farcastbaren Sprüchen abfangen */
range = farcasting(u, target_r); range = farcasting(u, target_r);
if (range > 1) { if (range > 1) {
if (!(sp->sptyp & FARCASTING)) { if (!(sp->sptyp & FARCASTING)) {
@ -2647,7 +2647,7 @@ static castorder *cast_cmd(unit * u, order * ord)
return 0; return 0;
} }
} }
/* Stufenangabe bei nicht Stufenvariierbaren Sprüchen abfangen */ /* Stufenangabe bei nicht Stufenvariierbaren Sprüchen abfangen */
if (!(sp->sptyp & SPELLLEVEL)) { if (!(sp->sptyp & SPELLLEVEL)) {
int ilevel = eff_skill(u, SK_MAGIC, u->region); int ilevel = eff_skill(u, SK_MAGIC, u->region);
if (ilevel != level) { if (ilevel != level) {
@ -2680,9 +2680,9 @@ static castorder *cast_cmd(unit * u, order * ord)
"mage", caster)); "mage", caster));
return 0; return 0;
} }
/* mage auf magier setzen, level anpassen, range für Erhöhung /* mage auf magier setzen, level anpassen, range für Erhöhung
* der Spruchkosten nutzen, langen Befehl des Magiers * der Spruchkosten nutzen, langen Befehl des Magiers
* löschen, zaubern kann er noch */ * löschen, zaubern kann er noch */
range *= 2; range *= 2;
set_order(&caster->thisorder, NULL); set_order(&caster->thisorder, NULL);
level = _min(level, eff_skill(caster, SK_MAGIC, caster->region) / 2); level = _min(level, eff_skill(caster, SK_MAGIC, caster->region) / 2);
@ -2721,19 +2721,19 @@ static castorder *cast_cmd(unit * u, order * ord)
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Damit man keine Rituale in fremden Gebiet machen kann, diese vor /* Damit man keine Rituale in fremden Gebiet machen kann, diese vor
* Bewegung zaubern. Magier sind also in einem fremden Gebiet eine Runde * Bewegung zaubern. Magier sind also in einem fremden Gebiet eine Runde
* lang verletzlich, da sie es betreten, und angegriffen werden können, * lang verletzlich, da sie es betreten, und angegriffen werden können,
* bevor sie ein Ritual machen können. * bevor sie ein Ritual machen können.
* *
* Syntax: ZAUBER [REGION X Y] [STUFE <stufe>] "Spruchname" [Einheit-1 * Syntax: ZAUBER [REGION X Y] [STUFE <stufe>] "Spruchname" [Einheit-1
* Einheit-2 ..] * Einheit-2 ..]
* *
* Nach Priorität geordnet die Zauber global auswerten. * Nach Priorität geordnet die Zauber global auswerten.
* *
* Die Kosten für Farcasting multiplizieren sich mit der Entfernung, * Die Kosten für Farcasting multiplizieren sich mit der Entfernung,
* cast_level gibt die virtuelle Stufe an, die den durch das Farcasten * cast_level gibt die virtuelle Stufe an, die den durch das Farcasten
* entstandenen Spruchkosten entspricht. Sind die Spruchkosten nicht * entstandenen Spruchkosten entspricht. Sind die Spruchkosten nicht
* levelabhängig, so sind die Kosten nur von der Entfernung bestimmt, * levelabhängig, so sind die Kosten nur von der Entfernung bestimmt,
* die Stärke/Level durch den realen Skill des Magiers * die Stärke/Level durch den realen Skill des Magiers
*/ */
void magic(void) void magic(void)
@ -2776,11 +2776,11 @@ void magic(void)
} }
} }
/* Da sich die Aura und Komponenten in der Zwischenzeit verändert /* Da sich die Aura und Komponenten in der Zwischenzeit verändert
* haben können und sich durch vorherige Sprüche das Zaubern * haben können und sich durch vorherige Sprüche das Zaubern
* erschwert haben kann, muss beim zaubern erneut geprüft werden, ob der * erschwert haben kann, muss beim zaubern erneut geprüft werden, ob der
* Spruch überhaupt gezaubert werden kann. * Spruch überhaupt gezaubert werden kann.
* (level) die effektive Stärke des Spruchs (= Stufe, auf der der * (level) die effektive Stärke des Spruchs (= Stufe, auf der der
* Spruch gezaubert wird) */ * Spruch gezaubert wird) */
for (rank = 0; rank < MAX_SPELLRANK; rank++) { for (rank = 0; rank < MAX_SPELLRANK; rank++) {
@ -2802,30 +2802,30 @@ void magic(void)
} }
if (cast_level > co->level) { if (cast_level > co->level) {
/* Sprüche mit Fixkosten werden immer auf Stufe des Spruchs /* Sprüche mit Fixkosten werden immer auf Stufe des Spruchs
* gezaubert, co->level ist aber defaultmäßig Stufe des Magiers */ * gezaubert, co->level ist aber defaultmäßig Stufe des Magiers */
if (spl_costtyp(sp) != SPC_FIX) { if (spl_costtyp(sp) != SPC_FIX) {
ADDMSG(&u->faction->msgs, msg_message("missing_components", ADDMSG(&u->faction->msgs, msg_message("missing_components",
"unit spell level", u, sp, cast_level)); "unit spell level", u, sp, cast_level));
} }
} }
/* Prüfen, ob die realen Kosten für die gewünschten Stufe bezahlt /* Prüfen, ob die realen Kosten für die gewünschten Stufe bezahlt
* werden können */ * werden können */
if (!cancast(u, sp, co->level, co->distance, ord)) { if (!cancast(u, sp, co->level, co->distance, ord)) {
/* die Fehlermeldung wird in cancast generiert */ /* die Fehlermeldung wird in cancast generiert */
continue; continue;
} }
co->force = spellpower(target_r, u, sp, co->level, ord); co->force = spellpower(target_r, u, sp, co->level, ord);
/* die Stärke kann durch Antimagie auf 0 sinken */ /* die Stärke kann durch Antimagie auf 0 sinken */
if (co->force <= 0) { if (co->force <= 0) {
co->force = 0; co->force = 0;
ADDMSG(&u->faction->msgs, msg_message("missing_force", ADDMSG(&u->faction->msgs, msg_message("missing_force",
"unit spell level", u, sp, co->level)); "unit spell level", u, sp, co->level));
} }
/* Ziele auf Existenz prüfen und Magieresistenz feststellen. Wurde /* Ziele auf Existenz prüfen und Magieresistenz feststellen. Wurde
* kein Ziel gefunden, so ist verify_targets=0. Scheitert der * kein Ziel gefunden, so ist verify_targets=0. Scheitert der
* Spruch an der Magieresistenz, so ist verify_targets = 1, bei * Spruch an der Magieresistenz, so ist verify_targets = 1, bei
* Erfolg auf ganzer Linie ist verify_targets= 2 * Erfolg auf ganzer Linie ist verify_targets= 2
@ -2833,8 +2833,8 @@ void magic(void)
verify_targets(co, &invalid, &resist, &success); verify_targets(co, &invalid, &resist, &success);
if (success + resist == 0) { if (success + resist == 0) {
/* kein Ziel gefunden, Fehlermeldungen sind in verify_targets */ /* kein Ziel gefunden, Fehlermeldungen sind in verify_targets */
/* keine kosten für den zauber */ /* keine kosten für den zauber */
continue; /* äußere Schleife, nächster Zauberer */ continue; /* äußere Schleife, nächster Zauberer */
} }
else if (co->force > 0 && resist > 0) { else if (co->force > 0 && resist > 0) {
/* einige oder alle Ziele waren magieresistent */ /* einige oder alle Ziele waren magieresistent */
@ -2847,8 +2847,8 @@ void magic(void)
} }
} }
/* Auch für Patzer gibt es Erfahrung, müssen die Spruchkosten /* Auch für Patzer gibt es Erfahrung, müssen die Spruchkosten
* bezahlt werden und die nachfolgenden Sprüche werden teurer */ * bezahlt werden und die nachfolgenden Sprüche werden teurer */
if (co->force > 0) { if (co->force > 0) {
if (fumble(target_r, u, sp, co->level)) { if (fumble(target_r, u, sp, co->level)) {
/* zuerst bezahlen, dann evt in do_fumble alle Aura verlieren */ /* zuerst bezahlen, dann evt in do_fumble alle Aura verlieren */
@ -2857,12 +2857,12 @@ void magic(void)
else { else {
co->level = sp->cast(co); co->level = sp->cast(co);
if (co->level <= 0) { if (co->level <= 0) {
/* Kosten nur für real benötige Stufe berechnen */ /* Kosten nur für real benötige Stufe berechnen */
continue; continue;
} }
} }
} }
/* erst bezahlen, dann Kostenzähler erhöhen */ /* erst bezahlen, dann Kostenzähler erhöhen */
if (co->level > 0) { if (co->level > 0) {
pay_spell(u, sp, co->level, co->distance); pay_spell(u, sp, co->level, co->distance);
} }

10
src/report.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>
@ -552,9 +552,9 @@ static void nr_curses(stream *out, int indent, const faction *viewer, objtype_t
region *r; region *r;
/* Die Sichtbarkeit eines Zaubers und die Zaubermeldung sind bei /* Die Sichtbarkeit eines Zaubers und die Zaubermeldung sind bei
* Gebäuden und Schiffen je nach, ob man Besitzer ist, verschieden. * Gebäuden und Schiffen je nach, ob man Besitzer ist, verschieden.
* Bei Einheiten sieht man Wirkungen auf eigene Einheiten immer. * Bei Einheiten sieht man Wirkungen auf eigene Einheiten immer.
* Spezialfälle (besonderes Talent, verursachender Magier usw. werde * Spezialfälle (besonderes Talent, verursachender Magier usw. werde
* bei jedem curse gesondert behandelt. */ * bei jedem curse gesondert behandelt. */
if (typ == TYP_SHIP) { if (typ == TYP_SHIP) {
ship *sh = (ship *)obj; ship *sh = (ship *)obj;
@ -945,7 +945,7 @@ static void describe(stream *out, const seen_region * sr, faction * f)
bytes = (int)strlcpy(bufp, LOC(f->locale, "nr_tree"), size); bytes = (int)strlcpy(bufp, LOC(f->locale, "nr_tree"), size);
} }
else { else {
bytes = (int)strlcpy(bufp, LOC(f->locale, "nr_tree_p"), size); bytes = (int)strlcpy(bufp, LOC(f->locale, "nr_tree_p"), size); //TODO: V595 http://www.viva64.com/en/V595 The 'f' pointer was utilized before it was verified against nullptr. Check lines: 948, 956.
} }
if (wrptr(&bufp, &size, bytes) != 0) if (wrptr(&bufp, &size, bytes) != 0)
WARN_STATIC_BUFFER(); WARN_STATIC_BUFFER();
@ -1188,7 +1188,7 @@ static void describe(stream *out, const seen_region * sr, faction * f)
} }
} }
/* Wirkungen permanenter Sprüche */ /* Wirkungen permanenter Sprüche */
nr_curses(out, 0, f, TYP_REGION, r); nr_curses(out, 0, f, TYP_REGION, r);
n = 0; n = 0;

4
src/spy.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>
@ -375,7 +375,7 @@ static int try_destruction(unit * u, unit * u2, const ship * sh, int skilldiff)
} }
else if (skilldiff < 0) { else if (skilldiff < 0) {
/* tell the unit that the attempt was detected: */ /* tell the unit that the attempt was detected: */
ADDMSG(&u2->faction->msgs, msg_message(destruction_detected_msg, ADDMSG(&u2->faction->msgs, msg_message(destruction_detected_msg, //TODO: V595 http://www.viva64.com/en/V595 The 'u2' pointer was utilized before it was verified against nullptr. Check lines: 378, 381.
"ship unit", sh, u)); "ship unit", sh, u));
/* tell the enemy whodunit: */ /* tell the enemy whodunit: */
if (u2) { if (u2) {

4
src/study.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>
@ -743,7 +743,7 @@ int learn_cmd(unit * u, order * ord)
multi *= study_speedup(u, sk, speed_rule); multi *= study_speedup(u, sk, speed_rule);
days = study_days(u, sk); days = study_days(u, sk);
days = (int)((days + teach->value) * multi); days = (int)((days + teach->value) * multi); //TODO: V595 http://www.viva64.com/en/V595 The 'teach' pointer was utilized before it was verified against nullptr. Check lines: 746, 772.
/* the artacademy currently improves the learning of entertainment /* the artacademy currently improves the learning of entertainment
of all units in the region, to be able to make it cumulative with of all units in the region, to be able to make it cumulative with

4
src/summary.c
View file

@ -1,4 +1,4 @@
/* /*
* +-------------------+ Christian Schlittchen <corwin@amber.kn-bremen.de> * +-------------------+ Christian Schlittchen <corwin@amber.kn-bremen.de>
* | | Enno Rehling <enno@eressea.de> * | | Enno Rehling <enno@eressea.de>
* | Eressea PBEM host | Katja Zedel <katze@felidae.kn-bremen.de> * | Eressea PBEM host | Katja Zedel <katze@felidae.kn-bremen.de>
@ -356,7 +356,7 @@ summary *make_summary(void)
const struct resource_type *rhorse = get_resourcetype(R_HORSE); const struct resource_type *rhorse = get_resourcetype(R_HORSE);
for (f = factions; f; f = f->next) { for (f = factions; f; f = f->next) {
const struct locale *lang = f->locale; const struct locale *lang = f->locale; //TODO: V595 http://www.viva64.com/en/V595 The 'f' pointer was utilized before it was verified against nullptr. Check lines: 359, 376.
struct language *plang = s->languages; struct language *plang = s->languages;
while (plang && plang->locale != lang) while (plang && plang->locale != lang)
plang = plang->next; plang = plang->next;

8
src/util/attrib.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>
@ -69,7 +69,7 @@ static attrib_type *at_find(unsigned int hk)
{ {
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: früher verzaubert, jetzt curse */
{ NULL, NULL } { NULL, NULL }
}; };
attrib_type *find = at_hash[hk % MAXATHASH]; attrib_type *find = at_hash[hk % MAXATHASH];
@ -110,7 +110,7 @@ const attrib *a_findc(const attrib * a, const attrib_type * at)
static attrib *a_insert(attrib * head, attrib * a) static attrib *a_insert(attrib * head, attrib * a)
{ {
attrib **pa = &head->next; attrib **pa = &head->next; //TODO: V595 http://www.viva64.com/en/V595 The 'head' pointer was utilized before it was verified against nullptr. Check lines: 113, 116.
assert(!(a->type->flags & ATF_UNIQUE)); assert(!(a->type->flags & ATF_UNIQUE));
assert(head && head->type == a->type); assert(head && head->type == a->type);
@ -250,7 +250,7 @@ int a_age(attrib ** p)
{ {
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 Einfluß auf den Besitzer */
while (*ap) { while (*ap) {
attrib *a = *ap; attrib *a = *ap;
if (a->type->age) { if (a->type->age) {