- http://eressea.upb.de/mantis/bug_view_page.php?bug_id=0000079

Zauber, die von antimagiezonen komplett blockiert werden, kosten trotzdem Aura

src/common/kernel/magic.c

@@ -2667,9 +2667,7 @@ magic(void)
   const char *s;
   strlist *so;
   int spellrank;
-	int level, success;
   int range, t_x, t_y;
-	double force;
   int skiptokens;
   castorder *co;
   castorder *cll[MAX_SPELLRANK];
@@ -2681,6 +2679,7 @@ magic(void)
 
   for (r = regions; r; r = r->next) {
     for (u = r->units; u; u = u->next) {
+      int level;
       boolean casted = false;
 
       if (old_race(u->race) == RC_SPELL || fval(u, UFL_LONGACTION))
@@ -2903,115 +2902,109 @@ magic(void)
       if (casted) fset(u, UFL_LONGACTION);
     }
   }
-	for (spellrank = 0; spellrank < MAX_SPELLRANK; spellrank++) {
-		for (co = cll[spellrank]; co; co = co->next) {
-			char *cmd = co->order;
-
-			u = (unit *)co->magician;
-			sp = co->sp;
-			level = co->level; /* Talent des Magiers oder gewünschte Stufe */
-			target_r = co->rt;
 
   /* 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 hier erneut geprüft werden, ob der
+  * 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 (spellrank = 0; spellrank < MAX_SPELLRANK; spellrank++) {
+    for (co = cll[spellrank]; co; co = co->next) {
+      char *cmd = co->order;
+      int verify, cast_level = co->level;
+      boolean fumbled = false;
+      unit * u = (unit *)co->magician;
+      spell * sp = co->sp;
+      region * target_r = co->rt;
+
       /* reichen die Komponenten nicht, wird der Level reduziert. */
-			level = eff_spelllevel(u, sp, level, co->distance);
+      co->level = eff_spelllevel(u, sp, cast_level, co->distance);       
-			if (level < 1) {
+
+      if (co->level < 1) {
         /* Fehlermeldung mit Komponenten generieren */
         cancast(u, sp, co->level, co->distance, cmd);
         continue;
       }
-			if (level < co->level){
+
+      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 */
         if (spl_costtyp(sp) != SPC_FIX) {
           sprintf(buf, "%s hat nur genügend Komponenten um %s auf Stufe %d "
-							"zu zaubern.", unitname(u), 
+            "zu zaubern.", unitname(u), spell_name(sp, u->faction->locale), 
-							spell_name(sp, u->faction->locale), level);
+            co->level);
           addmessage(0, u->faction, buf, MSG_MAGIC, ML_INFO);
         }
       }
-			co->level = level;
 
       /* Prüfen, ob die realen Kosten für die gewünschten Stufe bezahlt
       * werden können */
-			if (cancast(u, sp, level, co->distance, cmd) == false) {
+      if (cancast(u, sp, co->level, co->distance, cmd) == false) {
         /* die Fehlermeldung wird in cancast generiert */
         continue;
       }
 
+      co->force = spellpower(target_r, u, sp, co->level);
       /* die Stärke kann durch Antimagie auf 0 sinken */
-			force = spellpower(target_r, u, sp, level);
+      if (co->force <= 0) {
-			if (force <= 0) {
+        co->force = 0;
         sprintf(buf, "%s schafft es nicht genügend Kraft aufzubringen "
           "um %s dennoch zu zaubern.", unitname(u), 
           spell_name(sp, u->faction->locale));
         addmessage(0, u->faction, buf, MSG_MAGIC, ML_MISTAKE);
-				continue;
       }
-			co->force = force;
 
       /* 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
       */
-			switch (verify_targets(co)){
+      verify = verify_targets(co);
-				case 0:
+      if (verify==0) {
         /* kein Ziel gefunden, Fehlermeldungen sind in verify_targets */
+        /* keine kosten für den zauber */
         continue; /* äußere Schleife, nächster Zauberer */
-				case 1:
+      } else if (co->force>0 && verify==1) {
-				{ /* einige oder alle Ziele waren magieresistent */
+        /* einige oder alle Ziele waren magieresistent */
         spellparameter *pa = co->par;
         int n;
         for (n=0; n!=pa->length;++n) {
-						if(pa->param[n]->flag != TARGET_RESISTS
+          if ((pa->param[n]->flag & (TARGET_RESISTS|TARGET_NOTFOUND)) ==0) {
-								&& pa->param[n]->flag != TARGET_NOTFOUND)
+            /* mindestens ein erfolgreicher Zauberversuch, wir machen normal weiter */
-						{ /* mindestens ein erfolgreicher Zauberversuch, wir machen
-								 normal weiter */
             break;
           }
         }
         if (n==pa->length) {
+          co->force = 0;
           /* zwar wurde mindestens ein Ziel gefunden, das widerstand
             * jedoch dem Zauber. Kosten abziehen und abbrechen. */
-            pay_spell(u, sp, level, co->distance);
-            countspells(u, 1);
           sprintf(buf, "%s gelingt es %s zu zaubern, doch der Spruch zeigt "
             "keine Wirkung.", unitname(u), 
             spell_name(sp, u->faction->locale));
           addmessage(0, u->faction, buf, MSG_MAGIC, ML_MISTAKE);
-            continue; /* äußere Schleife, nächster Zauberer */
+          co->force = 0;
         }
-          break;
-				}
-				case 2:
-				default:
-					/* Zauber war erfolgreich */
-					break;
       }
 
       /* Auch für Patzer gibt es Erfahrung, müssen die Spruchkosten
       * bezahlt werden und die nachfolgenden Sprüche werden teurer */
-			if (fumble(target_r, u, sp, level) == true) {
+      if (co->force>0 && fumble(target_r, u, sp, co->level)) {
         /* zuerst bezahlen, dann evt in do_fumble alle Aura verlieren */
-				pay_spell(u, sp, level, co->distance);
+        fumbled = true;
-				do_fumble(co);
+        co->force = 0;
-				countspells(u, 1);
+      } else if (co->force>0) {
+        co->level = ((nspell_f)sp->sp_function)(co);
+        if (co->level <= 0) {
+          /* Kosten nur für real benötige Stufe berechnen */
           continue;
         }
-			success = ((nspell_f)sp->sp_function)(co);
-			if (success > 0) {
-				/* Kosten nur für real benötige Stufe berechnen */
-				pay_spell(u, sp, success, co->distance);
-				/* erst bezahlen, dann Kostenzähler erhöhen */
-				countspells(u,1);
       }
+      pay_spell(u, sp, co->level, co->distance);
+      /* erst bezahlen, dann Kostenzähler erhöhen */
+      if (fumbled) do_fumble(co);
+      countspells(u, 1);
     }
   }