diff --git a/src/creport.c b/src/creport.c index 2396a7476..7db0fdee3 100644 --- a/src/creport.c +++ b/src/creport.c @@ -755,7 +755,7 @@ static void cr_output_unit(FILE * F, const region * r, const faction * f, itemcloak_ct = ct_find("itemcloak"); } 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); diff --git a/src/give.c b/src/give.c index c5d4f5a27..95361b5ca 100644 --- a/src/give.c +++ b/src/give.c @@ -400,7 +400,7 @@ message * disband_men(int n, unit * u, struct 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(); assert(u); diff --git a/src/kernel/item.c b/src/kernel/item.c index 5ac160881..6c37ebad2 100644 --- a/src/kernel/item.c +++ b/src/kernel/item.c @@ -333,7 +333,7 @@ potion_type *new_potiontype(item_type * itype, int level) void it_set_appearance(item_type *itype, const char *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 ? strcat(strcpy((char *)malloc(strlen((char *)appearance) + 3), (char *)appearance), "_p") : 0; } diff --git a/src/kernel/save.c b/src/kernel/save.c index 0e0225f83..04575797b 100644 --- a/src/kernel/save.c +++ b/src/kernel/save.c @@ -990,7 +990,7 @@ void writeregion(struct gamedata *data, const region * r) rawmaterial *res = r->resources; 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, 1) >= 0); assert(rtrees(r, 2) >= 0); diff --git a/src/laws.c b/src/laws.c index 06b2a0a1e..65219792f 100755 --- a/src/laws.c +++ b/src/laws.c @@ -1741,7 +1741,7 @@ int name_cmd(struct unit *u, struct order *ord) for (; lang; lang = nextlocale(lang)) { const char *fdname = LOC(lang, "factiondefault"); 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; } } @@ -1778,14 +1778,14 @@ int name_cmd(struct unit *u, struct order *ord) for (; lang; lang = nextlocale(lang)) { const char *sdname = LOC(lang, sh->type->_name); 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) { break; } sdname = LOC(lang, parameters[P_SHIP]); 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) { break; } @@ -2718,7 +2718,7 @@ int guard_on_cmd(unit * u, struct order *ord) init_order(ord); /* 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; if (fval(u->region->terrain, SEA_REGION)) { diff --git a/src/magic.c b/src/magic.c index d91bd9658..5c9e3edc3 100644 --- a/src/magic.c +++ b/src/magic.c @@ -1,4 +1,4 @@ -/* +/* Copyright (c) 1998-2014, Enno Rehling Katja Zedel 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 -* 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) @@ -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) { @@ -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) { @@ -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"); - /* 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)) { /* Fehler 'Spell not found' */ 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) { 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) { @@ -671,7 +671,7 @@ int change_spellpoints(unit * u, int mp) 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 */ 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 * haben. - * Manche Rassen haben einen zusätzlichen Multiplikator - * Durch Talentverlust (zB Insekten im Berg) können negative Werte + * Manche Rassen haben einen zusätzlichen Multiplikator + * Durch Talentverlust (zB Insekten im Berg) können negative Werte * entstehen */ -/* Artefakt der Stärke - * Ermöglicht dem Magier mehr Magiepunkte zu 'speichern' +/* Artefakt der Stärke + * Ermöglicht dem Magier mehr Magiepunkte zu 'speichern' */ /** TODO: at_skillmod daraus machen */ 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. - * Um nur die Zahl der bereits gezauberten Sprüche zu ermitteln mit +/* Counter für die bereits gezauberte Anzahl Sprüche pro Runde. + * Um nur die Zahl der bereits gezauberten Sprüche zu ermitteln mit * step = 0 aufrufen. */ 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 Grundkosten pro Stufe werden hier um 2^count erhöht. Der - * Parameter count ist dabei die Anzahl der bereits gezauberten Sprüche +/* Die für den Spruch benötigte Aura pro Stufe. + * Die Grundkosten pro Stufe werden hier um 2^count erhöht. Der + * Parameter count ist dabei die Anzahl der bereits gezauberten Sprüche */ 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. - * 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 * niedrigstwertigen und sollte von den beiden anderen Typen - * überschrieben werden */ + * überschrieben werden */ static int spl_costtyp(const spell * sp) { int k; @@ -805,7 +805,7 @@ static int spl_costtyp(const spell * sp) return SPC_LINEAR; } - /* wenn keine Fixkosten, Typ übernehmen */ + /* wenn keine Fixkosten, Typ übernehmen */ if (sp->components[k].cost != SPC_FIX) { 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 * 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. * */ 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; if (sp->components[k].amount > 0) { - /* Die Kosten für Aura sind auch von der Zahl der bereits - * gezauberten Sprüche abhängig */ + /* Die Kosten für Aura sind auch von der Zahl der bereits + * gezauberten Sprüche abhängig */ if (sp->components[k].type == r_aura) { 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; /* 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 (maxlevel < 1) cast_level = 0; - /* ansonsten wird das Minimum aus maximal möglicher Stufe und der - * gewünschten gebildet */ + /* ansonsten wird das Minimum aus maximal möglicher Stufe und der + * gewünschten gebildet */ } else if (sp->components[k].cost == SPC_LEVEL) { costtyp = SPC_LEVEL; cast_level = _min(cast_level, maxlevel); - /* bei Typ Linear müssen die Kosten in Höhe der Stufe vorhanden - * sein, ansonsten schlägt der Spruch fehl */ + /* bei Typ Linear müssen die Kosten in Höhe der Stufe vorhanden + * sein, ansonsten schlägt der Spruch fehl */ } else if (sp->components[k].cost == 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) * 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 * 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 * 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. */ 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) { 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 * Spruchs besitzen, nicht nur wissen, das es ihn gibt (also den Spruch * in seiner Spruchliste haben). - * Kosten für einen Spruch können Magiepunkte, Silber, Kraeuter + * Kosten für einen Spruch können Magiepunkte, Silber, Kraeuter * 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? */ 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); 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; int itemhave; - /* Die Kosten für Aura sind auch von der Zahl der bereits - * gezauberten Sprüche abhängig */ + /* Die Kosten für Aura sind auch von der Zahl der bereits + * gezauberten Sprüche abhängig */ if (rtype == r_aura) { 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; } - /* 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 */ switch (sp->components[k].cost) { 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 * 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. */ @@ -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 */ static int farcasting(unit * magician, region * r) { @@ -1166,7 +1166,7 @@ double magic_resistance(unit * target) /* Bonus durch Artefakte */ /* TODO (noch gibs keine) */ - /* Bonus durch Gebäude */ + /* Bonus durch Gebäude */ { struct building *b = inside_building(target); 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. - * Objekte können Regionen, Units, Gebäude oder Schiffe sein. +/* Prüft, ob das Objekt dem Zauber widerstehen kann. + * Objekte können Regionen, Units, Gebäude oder Schiffe sein. * TYP_UNIT: - * Das höchste Talent des Ziels ist sein 'Magieresistenz-Talent', Magier - * bekommen einen Bonus. Grundchance ist 50%, für jede Stufe - * Unterschied gibt es 5%, minimalchance ist 5% für jeden (5-95%) + * Das höchste Talent des Ziels ist sein 'Magieresistenz-Talent', Magier + * bekommen einen Bonus. Grundchance ist 50%, für jede Stufe + * Unterschied gibt es 5%, minimalchance ist 5% für jeden (5-95%) * Scheitert der Spruch an der Magieresistenz, so gibt die Funktion - * true zurück + * true zurück */ bool @@ -1248,8 +1248,8 @@ target_resists_magic(unit * magician, void *obj, int objtyp, int t_bonus) probability = _min(0.98, probability); /* gibt true, wenn die Zufallszahl kleiner als die chance ist und - * false, wenn sie gleich oder größer ist, dh je größer die - * Magieresistenz (chance) desto eher gibt die Funktion true zurück */ + * false, wenn sie gleich oder größer ist, dh je größer die + * Magieresistenz (chance) desto eher gibt die Funktion true zurück */ 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. * 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 * */ @@ -1306,8 +1306,8 @@ bool fumble(region * r, unit * u, const spell * sp, int cast_grade) fumble_chance += CHAOSPATZERCHANCE; } - /* wenn die Chance kleiner als 0 ist, können wir gleich false - * zurückgeben */ + /* wenn die Chance kleiner als 0 ist, können wir gleich false + * zurückgeben */ if (fumble_chance <= 0) { 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 */ static void fumble_default(castorder * co) { @@ -1328,7 +1328,7 @@ static void fumble_default(castorder * co) 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 */ @@ -1390,7 +1390,7 @@ static void do_fumble(castorder * co) break; case 3: case 4: - /* Spruch schlägt fehl, alle Magiepunkte weg */ + /* Spruch schlägt fehl, alle Magiepunkte weg */ set_spellpoints(u, 0); ADDMSG(&u->faction->msgs, msg_message("patzer3", "unit region spell", u, r, sp)); @@ -1409,7 +1409,7 @@ static void do_fumble(castorder * co) case 8: case 9: default: - /* Spruch gelingt, alle nachfolgenden Sprüche werden 2^4 so teuer */ + /* Spruch gelingt, alle nachfolgenden Sprüche werden 2^4 so teuer */ co->level = sp->cast(co); ADDMSG(&u->faction->msgs, msg_message("patzer5", "unit region spell", 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 - * Zwerge nur die Hälfte + * Zwerge nur die Hälfte */ static double regeneration(unit * u) { @@ -1439,7 +1439,7 @@ static double regeneration(unit * u) /* Einfluss von Artefakten */ /* TODO (noch gibs keine) */ - /* Würfeln */ + /* Würfeln */ aura = (rng_double() * d + rng_double() * d) / 2 + 1; aura *= MagicRegeneration(); @@ -1469,8 +1469,8 @@ void regenerate_aura(void) const struct building_type *btype = b ? b->type : NULL; reg_aura = regeneration(u); - /* Magierturm erhöht die Regeneration um 75% */ - /* Steinkreis erhöht die Regeneration um 50% */ + /* Magierturm erhöht die Regeneration um 75% */ + /* Steinkreis erhöht die Regeneration um 50% */ if (btype) reg_aura *= btype->auraregen; @@ -1609,14 +1609,14 @@ order * ord) /* ------------------------------------------------------------- */ /* Zuerst wird versucht alle noch nicht gefundenen Objekte zu finden - * oder zu prüfen, ob das gefundene Objekt wirklich hätte gefunden - * werden dürfen (nicht alle Zauber wirken global). Dabei zählen wir die + * oder zu prüfen, ob das gefundene Objekt wirklich hätte gefunden + * werden dürfen (nicht alle Zauber wirken global). Dabei zählen wir die * Misserfolge (failed). * 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) */ -/* 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 */ static void 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) { /* zuerst versuchen wir vorher nicht gefundene Objekte zu finden. * Wurde ein Objekt durch globalsuche gefunden, obwohl der Zauber - * gar nicht global hätte suchen dürften, setzen wir das Objekt - * zurück. */ + * gar nicht global hätte suchen dürften, setzen wir das Objekt + * zurück. */ for (i = 0; i < sa->length; i++) { spllprm *spobj = sa->param[i]; @@ -1719,7 +1719,7 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success) case SPP_REGION: /* haben wir ein Regionsobjekt, dann wird auch dieses und - nicht target_r überprüft. */ + nicht target_r überprüft. */ tr = spobj->data.r; if ((sp->sptyp & TESTRESISTANCE) @@ -1745,7 +1745,7 @@ verify_targets(castorder * co, int *invalid, int *resist, int *success) else { /* der Zauber hat keine expliziten Parameter/Ziele, es kann sich * aber um einen Regionszauber handeln. Wenn notwendig hier die - * Magieresistenz der Region prüfen. */ + * Magieresistenz der Region prüfen. */ if ((sp->sptyp & REGIONSPELL)) { /* Zielobjekt Region anlegen */ 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) @@ -1799,7 +1799,7 @@ static void free_spellparameter(spellparameter * pa) default: 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) @@ -1966,7 +1966,7 @@ static spellparameter *add_spellparameter(region * target_r, unit * u, break; case '+': /* das vorhergehende Element kommt ein oder mehrmals vor, wir - * springen zum key zurück */ + * springen zum key zurück */ j = 0; --c; break; @@ -2090,7 +2090,7 @@ void free_castorder(struct castorder *co) if (co->order) free_order(co->order); } -/* Hänge c-order co an die letze c-order von cll an */ +/* Hänge c-order co an die letze c-order von cll an */ void add_castorder(spellrank * cll, castorder * co) { if (cll->begin == NULL) { @@ -2521,7 +2521,7 @@ static castorder *cast_cmd(unit * u, order * ord) init_order(ord); s = gettoken(token, sizeof(token)); 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) { int p = getint(); level = _min(p, level); @@ -2550,8 +2550,8 @@ static castorder *cast_cmd(unit * u, order * ord) s = gettoken(token, sizeof(token)); param = findparam(s, u->faction->locale); } - /* für Syntax ' REGION x y STUFE z ' - * hier nach REGION nochmal auf STUFE prüfen */ + /* für Syntax ' REGION x y STUFE z ' + * hier nach REGION nochmal auf STUFE prüfen */ if (param == P_LEVEL) { int p = getint(); level = _min(p, level); @@ -2570,8 +2570,8 @@ static castorder *cast_cmd(unit * u, order * ord) sp = unit_getspell(u, s, u->faction->locale); - /* Vertraute können auch Zauber sprechen, die sie selbst nicht - * können. unit_getspell findet aber nur jene Sprüche, die + /* Vertraute können auch Zauber sprechen, die sie selbst nicht + * können. unit_getspell findet aber nur jene Sprüche, die * die Einheit beherrscht. */ if (!sp && is_familiar(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 * fehlermeldungen die anzeigen das der magier diesen Spruch * nur in diese Situation nicht anwenden kann, noch eine - * einfache Sicherheitsprüfung kommen */ + * einfache Sicherheitsprüfung kommen */ if (!knowsspell(r, u, sp)) { /* vorsicht! u kann der familiar sein */ if (!familiar) { @@ -2607,9 +2607,9 @@ static castorder *cast_cmd(unit * u, order * ord) cmistake(u, ord, 174, MSG_MAGIC); return 0; } - /* Auf dem Ozean Zaubern als quasi-langer Befehl können + /* Auf dem Ozean Zaubern als quasi-langer Befehl können * normalerweise nur Meermenschen, ausgenommen explizit als - * OCEANCASTABLE deklarierte Sprüche */ + * OCEANCASTABLE deklarierte Sprüche */ if (fval(r->terrain, SEA_REGION)) { if (u_race(u) != get_race(RC_AQUARIAN) && !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); if (range > 1) { if (!(sp->sptyp & FARCASTING)) { @@ -2647,7 +2647,7 @@ static castorder *cast_cmd(unit * u, order * ord) return 0; } } - /* Stufenangabe bei nicht Stufenvariierbaren Sprüchen abfangen */ + /* Stufenangabe bei nicht Stufenvariierbaren Sprüchen abfangen */ if (!(sp->sptyp & SPELLLEVEL)) { int ilevel = eff_skill(u, SK_MAGIC, u->region); if (ilevel != level) { @@ -2680,9 +2680,9 @@ static castorder *cast_cmd(unit * u, order * ord) "mage", caster)); 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 - * löschen, zaubern kann er noch */ + * löschen, zaubern kann er noch */ range *= 2; set_order(&caster->thisorder, NULL); 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 * Bewegung zaubern. Magier sind also in einem fremden Gebiet eine Runde - * lang verletzlich, da sie es betreten, und angegriffen werden können, - * bevor sie ein Ritual machen können. + * lang verletzlich, da sie es betreten, und angegriffen werden können, + * bevor sie ein Ritual machen können. * * Syntax: ZAUBER [REGION X Y] [STUFE ] "Spruchname" [Einheit-1 * 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 * entstandenen Spruchkosten entspricht. Sind die Spruchkosten nicht - * levelabhängig, so sind die Kosten nur von der Entfernung bestimmt, - * die Stärke/Level durch den realen Skill des Magiers + * levelabhängig, so sind die Kosten nur von der Entfernung bestimmt, + * die Stärke/Level durch den realen Skill des Magiers */ void magic(void) @@ -2776,11 +2776,11 @@ void magic(void) } } - /* Da sich die Aura und Komponenten in der Zwischenzeit verändert - * haben können und sich durch vorherige Sprüche das Zaubern - * erschwert haben kann, muss beim zaubern erneut geprüft werden, ob der - * Spruch überhaupt gezaubert werden kann. - * (level) die effektive Stärke des Spruchs (= Stufe, auf der der + /* Da sich die Aura und Komponenten in der Zwischenzeit verändert + * haben können und sich durch vorherige Sprüche das Zaubern + * erschwert haben kann, muss beim zaubern erneut geprüft werden, ob der + * Spruch überhaupt gezaubert werden kann. + * (level) die effektive Stärke des Spruchs (= Stufe, auf der der * Spruch gezaubert wird) */ for (rank = 0; rank < MAX_SPELLRANK; rank++) { @@ -2802,30 +2802,30 @@ void magic(void) } if (cast_level > co->level) { - /* Sprüche mit Fixkosten werden immer auf Stufe des Spruchs - * gezaubert, co->level ist aber defaultmäßig Stufe des Magiers */ + /* Sprüche mit Fixkosten werden immer auf Stufe des Spruchs + * gezaubert, co->level ist aber defaultmäßig Stufe des Magiers */ if (spl_costtyp(sp) != SPC_FIX) { ADDMSG(&u->faction->msgs, msg_message("missing_components", "unit spell level", u, sp, cast_level)); } } - /* Prüfen, ob die realen Kosten für die gewünschten Stufe bezahlt - * werden können */ + /* Prüfen, ob die realen Kosten für die gewünschten Stufe bezahlt + * werden können */ if (!cancast(u, sp, co->level, co->distance, ord)) { /* die Fehlermeldung wird in cancast generiert */ continue; } 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) { co->force = 0; ADDMSG(&u->faction->msgs, msg_message("missing_force", "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 * Spruch an der Magieresistenz, so ist verify_targets = 1, bei * Erfolg auf ganzer Linie ist verify_targets= 2 @@ -2833,8 +2833,8 @@ void magic(void) verify_targets(co, &invalid, &resist, &success); if (success + resist == 0) { /* kein Ziel gefunden, Fehlermeldungen sind in verify_targets */ - /* keine kosten für den zauber */ - continue; /* äußere Schleife, nächster Zauberer */ + /* keine kosten für den zauber */ + continue; /* äußere Schleife, nächster Zauberer */ } else if (co->force > 0 && resist > 0) { /* einige oder alle Ziele waren magieresistent */ @@ -2847,8 +2847,8 @@ void magic(void) } } - /* Auch für Patzer gibt es Erfahrung, müssen die Spruchkosten - * bezahlt werden und die nachfolgenden Sprüche werden teurer */ + /* Auch für Patzer gibt es Erfahrung, müssen die Spruchkosten + * bezahlt werden und die nachfolgenden Sprüche werden teurer */ if (co->force > 0) { if (fumble(target_r, u, sp, co->level)) { /* zuerst bezahlen, dann evt in do_fumble alle Aura verlieren */ @@ -2857,12 +2857,12 @@ void magic(void) else { co->level = sp->cast(co); if (co->level <= 0) { - /* Kosten nur für real benötige Stufe berechnen */ + /* Kosten nur für real benötige Stufe berechnen */ continue; } } } - /* erst bezahlen, dann Kostenzähler erhöhen */ + /* erst bezahlen, dann Kostenzähler erhöhen */ if (co->level > 0) { pay_spell(u, sp, co->level, co->distance); } diff --git a/src/report.c b/src/report.c index 0644df62b..f476a5c7f 100644 --- a/src/report.c +++ b/src/report.c @@ -1,4 +1,4 @@ -/* +/* Copyright (c) 1998-2015, Enno Rehling Katja Zedel @@ -552,9 +552,9 @@ static void nr_curses(stream *out, int indent, const faction *viewer, objtype_t region *r; /* 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. - * Spezialfälle (besonderes Talent, verursachender Magier usw. werde + * Spezialfälle (besonderes Talent, verursachender Magier usw. werde * bei jedem curse gesondert behandelt. */ if (typ == TYP_SHIP) { 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); } 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) 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); n = 0; diff --git a/src/spy.c b/src/spy.c index a7e481954..a247b6c66 100644 --- a/src/spy.c +++ b/src/spy.c @@ -1,4 +1,4 @@ -/* +/* Copyright (c) 1998-2015, Enno Rehling Katja Zedel @@ -375,7 +375,7 @@ static int try_destruction(unit * u, unit * u2, const ship * sh, int skilldiff) } else if (skilldiff < 0) { /* 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)); /* tell the enemy whodunit: */ if (u2) { diff --git a/src/study.c b/src/study.c index 467939dbf..a302737fa 100644 --- a/src/study.c +++ b/src/study.c @@ -1,4 +1,4 @@ -/* +/* Copyright (c) 1998-2015, Enno Rehling Katja Zedel @@ -743,7 +743,7 @@ int learn_cmd(unit * u, order * ord) multi *= study_speedup(u, sk, speed_rule); 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 of all units in the region, to be able to make it cumulative with diff --git a/src/summary.c b/src/summary.c index 92405db33..deb05b08f 100644 --- a/src/summary.c +++ b/src/summary.c @@ -1,4 +1,4 @@ -/* +/* * +-------------------+ Christian Schlittchen * | | Enno Rehling * | Eressea PBEM host | Katja Zedel @@ -356,7 +356,7 @@ summary *make_summary(void) const struct resource_type *rhorse = get_resourcetype(R_HORSE); 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; while (plang && plang->locale != lang) plang = plang->next; diff --git a/src/util/attrib.c b/src/util/attrib.c index dd1120b5c..e76a42898 100644 --- a/src/util/attrib.c +++ b/src/util/attrib.c @@ -1,4 +1,4 @@ -/* +/* Copyright (c) 1998-2015, Enno Rehling Katja Zedel @@ -69,7 +69,7 @@ static attrib_type *at_find(unsigned int hk) { const char *translate[3][2] = { { "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 } }; 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) { - 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(head && head->type == a->type); @@ -250,7 +250,7 @@ int a_age(attrib ** p) { attrib **ap = p; /* Attribute altern, und die Entfernung (age()==0) eines Attributs - * hat Einfluß auf den Besitzer */ + * hat Einfluß auf den Besitzer */ while (*ap) { attrib *a = *ap; if (a->type->age) {