@ -1,4 +1,4 @@
/*
/*
Copyright ( c ) 1998 - 2014 ,
Enno Rehling < enno @ eressea . de >
Katja Zedel < katze @ felidae . kn - bremen . de
@ -193,7 +193,7 @@ attrib_type at_icastle = {
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 */
/* ------------------------------------------------------------- */
@ -352,9 +352,9 @@ sc_mage *get_mage(const unit * u)
/* ------------------------------------------------------------- */
/* Ausgabe der Spruchbeschreibungen
* 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
* 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 < 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 ) ;
}
Enno Rehling