diff --git a/std/spellbook.c b/std/spellbook.c
new file mode 100644
index 0000000..24f824f
--- /dev/null
+++ b/std/spellbook.c
@@ -0,0 +1,785 @@
+// MorgenGrauen MUDlib
+//
+// spellbook.c -- Grundlegende Funktionen fuer Zaubersprueche
+//
+// $Id: spellbook.c 9142 2015-02-04 22:17:29Z Zesstra $
+#pragma strict_types
+#pragma save_types
+#pragma no_shadow
+#pragma no_clone
+#pragma pedantic
+#pragma range_check
+
+//#define NEED_PROTOTYPES
+inherit "/std/thing";
+inherit "/std/restriction_checker";
+inherit "/std/player/pklog";
+
+#include <thing/properties.h>
+#include <properties.h>
+#include <wizlevels.h>
+#include <new_skills.h>
+#include <spellbook.h>
+#define ME this_object()
+
+void create() {
+  seteuid(getuid());
+  // diese Prop sollte von aussen nicht direkt geaendert werden koennen.
+  Set(P_SB_SPELLS,([]),F_VALUE);
+  Set(P_SB_SPELLS,PROTECTED,F_MODE_AS);
+
+  ::create();
+}
+
+mapping _query_sb_spells() {
+    // Kopie liefern, da sonst versehentlich schnell eine Aenderung des
+    // originalen Mappings hier passieren kann.
+    return(deep_copy(Query(P_SB_SPELLS, F_VALUE)));
+}
+
+mapping QuerySpell(string spell) {
+  mapping spi;
+
+  //Query-Methode umgehen, damit nur ein Spellmapping kopiert werden muss und
+  //nicht das ganzen Mapping mit allen Spells.
+  if (!spell
+      || !(spi=Query(P_SB_SPELLS))
+      || !(spi=spi[spell]))
+    return 0;
+  return deep_copy(spi);
+}
+
+varargs int
+AddSpell(string verb, int kosten, mixed ski) {
+  int level;
+  mapping spells;
+
+  if (!verb || kosten<0)
+    return 0;
+  
+  verb=lower_case(verb);
+  level=(intp(ski))?ski:0;
+
+  if (!mappingp(ski)) ski=([]);
+  // Zur Sicherheit eine Kopie machen, wer weiss, was da uebergeben wird, bzw.
+  // was der Setzende mit ski hinterher noch macht.
+  else ski=deep_copy(ski);
+
+  ski=AddSkillMappings(QueryProp(P_GLOBAL_SKILLPROPS),ski);
+  ski+=([SI_SPELLCOST:kosten]);
+  // SI_SPELL-Submapping hinzufuegen, wenn nicht da.
+  if (!member(ski,SI_SPELL))
+      ski+=([SI_SPELL:([]) ]);
+  // ski[SI_SPELL][SP_NAME] ergaenzen, ggf. aus ski verschieben
+  if (!stringp(ski[SI_SPELL][SP_NAME]) && stringp(ski[SP_NAME])) {
+      ski[SI_SPELL][SP_NAME] = ski[SP_NAME];
+      m_delete(ski, SP_NAME);
+  }
+  else if (!stringp(ski[SI_SPELL][SP_NAME])) {
+      ski[SI_SPELL][SP_NAME] = verb;
+  }
+  if (stringp(ski[SP_NAME])) {
+      m_delete(ski, SP_NAME);
+  }
+
+  if (level)
+    ski=AddSkillMappings(ski,([SI_SKILLRESTR_LEARN:([P_LEVEL:level])]));
+  
+  // Abfrage per Query(), um das Mapping als Referenz, nicht als Kopie zu
+  // bekommen, das spart etwas Zeit.
+  if (!(spells=Query(P_SB_SPELLS,F_VALUE))) {
+    spells=([]);
+    SetProp(P_SB_SPELLS,spells);
+  }
+  // Spell setzen...
+  spells[verb]=ski;
+  // Set() nicht noetig, da Query() an spell das Originalmapping geliefert hat
+  // und dieses bereits jetzt geaendert wurde. ;-)
+  //Set(P_SB_SPELLS,spells+([verb:ski]),F_VALUE);
+
+  // hat wohl geklappt...
+  return(1);
+}
+
+int
+TryAttackSpell(object victim, int damage, mixed dtypes,
+               mixed is_spell, object caster, mapping sinfo) {
+  mixed no_attack;
+  int nomag;
+
+  if (no_attack = (mixed)victim->QueryProp(P_NO_ATTACK)) {
+    if (stringp(no_attack))
+      write(no_attack);
+    else
+      write(victim->Name(WER,1)+" laesst sich nicht angreifen!\n");
+    return 0;
+  }
+  if (victim->QueryProp(P_GHOST)) {
+    write(victim->Name(WER,1)+" ist ein Geist!\n");
+    return 0;
+  }
+
+  damage=(damage*(int)caster->QuerySkillAttribute(SA_DAMAGE))/100;
+
+  // ggf. Loggen von PK-Versuchen und ggf. ausserdem Angriff abbrechen.
+  // BTW: Aufruf von InsertEnemy() gibt 0 zurueck, wenn der Gegner nicht
+  // eingetragen wurde. Allerdings tut es das auch, wenn der Gegner schon
+  // Feind war. Daher muss noch geprueft werden, ob nach dem InsertEnemy() die
+  // beiden Spieler Feinde sind. Wenn nicht, wird der Spell auch abgebrochen
+  // und eine Meldung ausgegeben.
+  if (query_once_interactive(caster) && query_once_interactive(victim)
+      && CheckPlayerAttack(caster, victim, 
+        sprintf("Spellbook: %O, Spell: %O\n",
+                object_name(this_object()),
+                ((mappingp(sinfo) && is_spell) ? sinfo[SP_NAME]  : "")))
+      && !caster->IsEnemy(victim)
+      && !caster->InsertEnemy(victim)
+      )
+  {
+    tell_object(ME, "Ein goettlicher Einfluss schuetzt Deinen Gegner.\n");
+    return 0;
+  }
+
+  nomag=(int)victim->QueryProp(P_NOMAGIC);
+  if ((sinfo[SI_NOMAGIC] < nomag) &&
+      nomag*100 > random(100)*(int)caster->QuerySkillAttribute(SA_ENEMY_SAVE)) {
+    printf("%s wehrt Deinen Zauber ab.\n", capitalize((string)victim->name(WER, 1)));
+    return 0;
+  }
+  else {
+    return (int)victim->Defend(damage, dtypes, is_spell, caster);
+  }
+}
+
+varargs int
+TryDefaultAttackSpell(object victim, object caster, mapping sinfo, 
+                      mixed si_spell) {
+  object team;
+  int row;
+  
+  if (!si_spell) si_spell=sinfo[SI_SPELL];
+  // Wenn der Spieler in einem Team ist, die Teamreihen-Boni
+  // beruecksichtigen. Wenn nicht, eben nicht.
+  if (!team=((object)caster->QueryProp(P_TEAM)))
+  return TryAttackSpell(victim,
+                        GetRandFValueO(SI_SKILLDAMAGE,sinfo,caster),
+                        GetData(SI_SKILLDAMAGE_TYPE,sinfo,caster),
+                        si_spell,
+                        caster,
+                        sinfo);
+  else
+  {
+	  row=(int)caster->PresentPosition();
+	  return TryAttackSpell(victim,
+		  GetRandFValueO(SI_SKILLDAMAGE,sinfo,caster)+
+		  // Nur wenn SI_SKILLDAMAGE_BY_ROW ein mapping ist, 
+		  // randomisiert addieren
+		  (mappingp(sinfo[SI_SKILLDAMAGE_BY_ROW])?
+		   random(sinfo[SI_SKILLDAMAGE_BY_ROW][row]):0)+
+		  // Nur wenn das OFFSET davon ein mapping ist,
+		  // nicht randomisiert addieren.
+		  (mappingp(sinfo[OFFSET(SI_SKILLDAMAGE_BY_ROW)])?
+		   sinfo[OFFSET(SI_SKILLDAMAGE_BY_ROW)][row] : 0),
+		   GetData(SI_SKILLDAMAGE_TYPE,sinfo,caster),
+		   si_spell,caster,sinfo);
+   }
+}
+
+#define SMUL(x,y) ((x<0 && y<0)?(-1*x*y):(x*y))
+int
+SpellSuccess(object caster, mapping sinfo) {
+  int cval,abil,res;
+
+  abil=sinfo[SI_SKILLABILITY];
+  cval=(int)caster->UseSkill(SK_CASTING);
+  res=abil + (SMUL(abil,cval)) / MAX_ABILITY - random(MAX_ABILITY);
+  if (cval && res>MAX_ABILITY) // besonders gut gelungen?
+    caster->LearnSkill(SK_CASTING,1+(res-MAX_ABILITY)/2000);
+  return res;
+}
+
+int
+CanTrySpell(object caster, mapping sinfo) {
+  mapping rmap;
+  string res;
+
+  if (caster->QueryProp(P_GHOST)) {
+    write("Als Geist kannst Du nicht zaubern.\n");
+    return 0;
+  }
+  if ((rmap=sinfo[SI_SKILLRESTR_USE])
+      && (res=check_restrictions(caster,rmap))) {
+    write(res);
+    return 0;
+  }
+  return 1;
+}
+
+void
+Learn(object caster, string spell, mapping sinfo) {
+  int val,diff,attval;
+  mapping attr;
+ 
+  // gar nicht lernen?
+  if (sinfo[SI_NO_LEARN])
+    return;
+
+ // Attribut sollte int sein, wenn nicht anders angegeben
+ if (mappingp(sinfo[SI_LEARN_ATTRIBUTE]))
+ {
+	attr=sinfo[SI_LEARN_ATTRIBUTE];
+	// Direkt in einem durch berechnen.
+	// Ich gehe davon aus, dass wir nie nie nie
+	// ein weiteres Attribut ins MG einfuegen.
+	// Wir berechnen den Mittelwert
+	attval=((int)caster->QueryAttribute(A_INT)*attr[A_INT]+
+		(int)caster->QueryAttribute(A_DEX)*attr[A_DEX]+
+		(int)caster->QueryAttribute(A_STR)*attr[A_STR]+
+		(int)caster->QueryAttribute(A_CON)*attr[A_CON])
+		/(attr[A_CON]+attr[A_INT]+attr[A_STR]+attr[A_DEX]);
+		
+	 
+ } else {
+	 attval=(int)caster->QueryAttribute(A_INT);
+ }
+
+  
+  val=((attval/2)*GetFValue(SI_SKILLLEARN,sinfo,caster)+
+       GetOffset(SI_SKILLLEARN,sinfo,caster));
+  if (!(diff=GetFValueO(SI_DIFFICULTY,sinfo,caster)))
+    diff=GetFValueO(SI_SPELLCOST,sinfo,caster);
+  caster->LearnSkill(spell,val,diff);
+}
+
+void
+Erfolg(object caster, string spell, mapping sinfo) {
+  object env;
+  if(env=environment(caster))
+     env->SpellInform(caster,spell,sinfo);
+}
+
+void
+Misserfolg(object caster, string spell, mapping sinfo) {
+  write("Der Zauberspruch ist missglueckt.\n");
+  write("Du lernst aus Deinem Fehler.\n");
+  Learn(caster,spell,sinfo);
+}
+
+string
+SelectSpell(string spell, mapping sinfo) {
+  if (sinfo && sinfo[SI_SKILLFUNC])
+    return sinfo[SI_SKILLFUNC];
+  return spell;
+}
+
+varargs void
+prepare_spell(object caster, string spell, mapping sinfo) {
+  string txt;
+
+  if (!caster || !spell) return ;
+  if (!mappingp(sinfo) || !stringp(txt=sinfo[SI_PREPARE_MSG]))
+    txt="Du bereitest Dich auf den Spruch ``%s'' vor.\n";
+  tell_object(caster,sprintf(txt,spell));
+}
+
+varargs int
+UseSpell(object caster, string spell, mapping sinfo) {
+  mapping ski,tmp;
+  string spellbook,sname,fname,txt;
+  int res,fat,cost;
+  mixed ps;
+
+  if (!caster || !spell)
+    return 0;
+  // Spell kann in der Gilde anderen Namen haben
+  sname=SelectSpell(spell,sinfo);
+  if (!(ski=QuerySpell(sname))) // Existiert dieser Spell?
+    return 0;
+  // Gildeneigenschaften sollen Spelleigenschaften ueberschreiben koennen
+  ski=AddSkillMappings(ski,sinfo);
+  // Fuer verschiedene Rassen unterschiedliche Eigenschaften
+  ski=race_modifier(caster,ski);
+
+  // printf("Spellinfo: %O\n",ski);
+
+  if (!CanTrySpell(caster, ski))
+    return 1;
+
+  if (caster->QueryProp(P_SP) < (cost=GetFValueO(SI_SPELLCOST,ski,caster))) {
+    if(txt=ski[SI_SP_LOW_MSG])write(txt);
+    else write("Du hast zu wenig Zauberpunkte fuer diesen Spruch.\n");
+    return 1;
+  }
+  // printf("cost: %d\n",cost);
+
+  if (mappingp(ski[SI_X_SPELLFATIGUE])) {
+    // fuer jeden Key die Spellfatigue pruefen, wenn das Mapping hinterher
+    // nicht leer ist, ist man zu erschoepft.
+    tmp = filter(ski[SI_X_SPELLFATIGUE],
+        function int (string key, int val)
+        { return (int)caster->CheckSpellFatigue(key); } );
+    if (sizeof(tmp)) {
+        write(ski[SI_TIME_MSG] ||
+            "Du bist noch zu erschoepft von Deinem letzten Spruch.\n");
+      return 1;
+    }
+  }
+  else {
+    if (caster->CheckSpellFatigue()) {
+        write(ski[SI_TIME_MSG] ||
+            "Du bist noch zu erschoepft von Deinem letzten Spruch.\n");
+      return 1;
+    }
+  }
+
+  if (!(ski[SI_NO_ATTACK_BUSY]&NO_ATTACK_BUSY_QUERY) &&
+      caster->QueryProp(P_ATTACK_BUSY)) {
+    if (txt=ski[SI_ATTACK_BUSY_MSG]) write(txt);
+    else write("Du bist schon zu sehr beschaeftigt.\n");
+    return 1;
+  }
+
+  // Spruchvorbereitung
+  if (pointerp(ps=(mixed)caster->QueryProp(P_PREPARED_SPELL)) // Ausstehender Spruch
+      && sizeof(ps)>=3 && intp(ps[0] && stringp(ps[1]))) {
+    if (ps[1]==spell) { // Dieser Spruch wird noch vorbereitet
+      if (time()<ps[0]) {
+        if (!stringp(txt=ski[SI_PREPARE_BUSY_MSG]))
+          txt="Du bist noch mit der Spruchvorbereitung beschaeftigt.\n";
+        write(txt);
+        return 1;
+      }
+    }
+    else { // Andere Sprueche brechen die Vorbereitung ab
+      if (!mappingp(tmp=QuerySpell(ps[1])) || // richtige Meldung holen...
+          !stringp(txt=tmp[SI_PREPARE_ABORT_MSG]))
+        txt="Du brichst die Spruchvorbereitung fuer `%s' ab.\n";
+      printf(txt,ps[1]);
+      if (fat=GetValue(SI_PREPARE_TIME,ski,caster)) {
+        // Spruch braucht vorbereitungszeit
+        caster->SetProp(P_PREPARED_SPELL,({time()+fat,spell,ski[SI_SKILLARG]}));
+        prepare_spell(caster,spell,ski);
+        return 1;
+      }
+    }
+  }
+  else {
+    if (fat=GetValue(SI_PREPARE_TIME,ski,caster)) {
+      // Spruch braucht vorbereitungszeit
+      caster->SetProp(P_PREPARED_SPELL,({time()+fat,spell,ski[SI_SKILLARG]}));
+      prepare_spell(caster,spell,ski);
+      return 1;
+    }
+  }
+  if (ps)
+    caster->SetProp(P_PREPARED_SPELL,0);
+  
+  // Funktion kann anderen Namen haben als Spell
+  if (!(fname=sinfo[SI_SKILLFUNC]))
+    fname=sname;
+
+  if((ski[SI_NOMAGIC] < environment(caster)->QueryProp(P_NOMAGIC)) &&
+      random(100) < environment(caster)->QueryProp(P_NOMAGIC)) {
+    if (txt=ski[SI_NOMAGIC_MSG])
+      write(txt);
+    else
+      write("Dein Zauberspruch verpufft im Nichts.\n");
+    res=ABGEWEHRT;
+  }
+  else {
+    // Spruch ausfuehren.
+    res=(int)call_other(this_object(),fname,caster,ski);
+  }
+  // TODO: Wenn die ausgefuehrte Spellfunktion eine 0 zurueckgibt, sollen jetzt
+  // noch notify_fails zum Zuge kommen koennen. Daher in diesem Fall auch 0
+  // zurueckgeben.
+  if (!res || !caster)
+    return 1;
+
+  if (!(ski[SI_NO_ATTACK_BUSY]&NO_ATTACK_BUSY_QUERY))
+  	{
+	if (!ski[SI_ATTACK_BUSY_AMOUNT])  
+    		caster->SetProp(P_ATTACK_BUSY,1);
+	else
+		caster->SetProp(P_ATTACK_BUSY,ski[SI_ATTACK_BUSY_AMOUNT]);
+  	}
+
+  caster->restore_spell_points(-1*cost);
+
+  if (mappingp(ski[SI_X_SPELLFATIGUE])) {
+    // fuer jeden Key die Spellfatigue setzen. Keys mit Dauer 0 loesen keine
+    // Spellfatigue aus.
+    filter(ski[SI_X_SPELLFATIGUE],
+        function int (string key, int val)
+        { return (int)caster->SetSpellFatigue(val, key); } );
+  }
+  else {
+    if ((fat=GetFValueO(SI_SPELLFATIGUE,ski,caster))<0)
+      fat=1;
+    caster->SetSpellFatigue(fat);
+  }
+
+
+  if (res==ERFOLG)
+    Erfolg(caster,spell,ski);
+  else
+  if (res==MISSERFOLG)
+    Misserfolg(caster,spell,ski);
+  return 1;
+}
+
+object *
+FindGroup(object pl, int who) {
+  object *res,ob,env,team;
+  int p1,p2;
+  closure qp;
+
+  res=({});
+  if (!pl || !(env=environment(pl))) return res;
+  p1 = query_once_interactive(pl) ? 1 : -1;
+  team=(object)pl->QueryProp(P_TEAM);
+  for (ob=first_inventory(env);ob;ob=next_inventory(ob)) {
+    if (!living(ob)) continue;
+    qp=symbol_function("QueryProp",ob);
+    if (pl->IsEnemy(ob)) // Feinde sind immer Gegner
+      p2=-1*p1;
+    else if (objectp(team) && funcall(qp,P_TEAM)==team)
+      p2=p1; // Teammitglieder sind immer auf Seite des Spielers
+    else
+      p2 = (query_once_interactive(ob)||funcall(qp,P_FRIEND)) ? 1 : -1;
+    if (p2>0 && !interactive(ob) && query_once_interactive(ob))
+      continue; // keine Netztoten.
+    if (funcall(qp,P_GHOST))
+      continue;
+    if ( who<0 && (funcall(qp,P_NO_ATTACK) || funcall(qp,P_NO_GLOBAL_ATTACK)) )
+      continue;
+    if (IS_LEARNING(ob) &&
+        (funcall(qp,P_INVIS) || (who<0 && !pl->IsEnemy(ob))))
+      continue;
+    if (p1*p2*who >=0)
+      res+=({ob});
+  }
+  return res;
+}
+
+object *
+FindGroupN(object pl, int who, int n) {
+  if (!pl) return ({});
+  n=(n*(int)pl->QuerySkillAttribute(SA_EXTENSION))/100;
+  if (n<1) n=1;
+  return FindGroup(pl,who)[0..(n-1)];
+}
+
+object *
+FindGroupP(object pl, int who, int pr) {
+  object *res,*nres;
+  int i;
+
+  nres=({});
+  if (!pl) return nres;
+  pr=(pr*(int)pl->QuerySkillAttribute(SA_EXTENSION))/100;
+  if (pr<0) return nres;
+  res=FindGroup(pl,who);
+  for (i=sizeof(res)-1;i>=0;i--)
+    if (pr>=random(100))
+      nres+=({res[i]});
+  return nres;
+}
+
+// Findet feindliche und freundliche GRUPPEN im angegebenen Bereich.
+varargs mixed
+FindDistantGroups(object pl, int dist, int dy, int dx) {
+  mapping pos;
+  object ob,enteam,myteam;
+  int p1,min,max,i;
+  mixed *b_rows,x;
+  closure is_enemy, qp;
+
+  if (!objectp(pl) || !environment(pl))
+    return ({({}),({})});
+  if (!dy) dy=100;
+  if (!dx) dx=MAX_TEAM_ROWLEN*100;
+  x=(int)pl->QuerySkillAttribute(SA_EXTENSION);
+  dx=(dx*x)/100;dy=(dy*x)/100;
+  dist=(dist*(int)pl->QuerySkillAttribute(SA_RANGE))/100;
+  min=dist-dy/2;
+  max=dist+dy/2;
+
+  pos=([]);
+  p1=query_once_interactive(pl) ? 1 : -1;
+  is_enemy=symbol_function("IsEnemy",pl); // zur Beschleunigung
+  myteam=(object)pl->QueryProp(P_TEAM);
+  for (ob=first_inventory(environment(pl));ob;ob=next_inventory(ob)) {
+    if (!living(ob)) continue;
+    qp=symbol_function("QueryProp",ob); // zur Beschleunigung
+
+    // Zuerst mal die Position feststellen:
+    if (!objectp(enteam=funcall(qp,P_TEAM)))
+      pos[ob]=1;
+    else if (!pos[ob] && mappingp(x=(mapping)ob->PresentTeamPositions()))
+      pos+=x;
+    // PresentTeamPositions wird nur einmal pro Team ausgerechnet, weil
+    // anschliessend jedes anwesende Teammitglied pos[ob]!=0 hat.
+
+    pos[ob]=(2*pos[ob])-1;
+    // Reihen sollen Abstand 2 haben, auch Reihen 1 und -1 (nach Umrechnung)
+
+    // Feindliche Reihen an Y-Achse spiegeln, also gegenueber hinstellen:
+    if (funcall(is_enemy,ob))
+      pos[ob]*=-1; // Ist auf jeden Fall Feind
+    else if (objectp(myteam) && myteam==enteam)
+        ;            // Teammitglieder sind immer auf eigener Seite
+    else
+      pos[ob]*=(p1*((int)(query_once_interactive(ob)||
+                          funcall(qp,P_FRIEND))?1:-1));
+
+    // Den Spieler auf keinen Fall entfernen
+    if (ob==pl)
+      continue;
+    // Netztote, Geister  und unsichtbare Magier nicht beruecksichtigen,
+    // nicht (global) angreifbare Monster und nicht-feindliche Magier
+    // von feindlicher Seite entfernen.
+    if ((!interactive(ob) && query_once_interactive(ob)) // Netztote raus
+        || funcall(qp,P_GHOST)
+        || (IS_LEARNING(ob) && funcall(qp,P_INVIS))   // Bin nicht da :-)
+        || (pos[ob]<0 && (funcall(qp,P_NO_GLOBAL_ATTACK) // Nicht angreifen
+                          || funcall(qp,P_NO_ATTACK)
+                          || (IS_LEARNING(ob) && !funcall(is_enemy,ob)))))
+      m_delete(pos,ob);
+  }
+
+  // Reihen aufstellen
+  // Kampfreihe: |   5     4     3     2     1 ||  1     2     3     4     5|
+  // Arrays:     |0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19|
+  //             |<----------- Freunde ------->||<--------- Feinde -------->|
+  b_rows=EMPTY_TEAMARRAY+EMPTY_TEAMARRAY+EMPTY_TEAMARRAY+EMPTY_TEAMARRAY;
+  x=m_indices(pos);
+  for (i=sizeof(x)-1;i>=0;i--) {
+    p1=2*MAX_TEAMROWS-pos[ob=x[i]];
+    pos[ob]=p1;
+    if (p1>=0 && p1<4*MAX_TEAMROWS) {
+      if (random(100)<50)             // Damit gut gemischt wird...
+        b_rows[p1]=b_rows[p1]+({ob}); // zufaellig hinten anfuegen
+      else
+        b_rows[p1]=({ob})+b_rows[p1]; // oder vorne anfuegen.
+    }
+  }
+
+  // Umrechnung von Min, Max auf Reihen
+  // ... -2: -124..-75, -1:-74..-25, 0:-24..24, 1:25..74 2:75..124 ...
+  // Das muss man machen, wenn man keine vernuenftige Rundungsfunktion hat:
+  if (min<0) min=-1*((25-min)/50); else min=(25+min)/50;
+  if (max<0) max=-1*((25-max)/50); else max=(25+max)/50;
+  // Relativ zur Position des Spielers verschieben:
+  p1=pos[pl];min+=p1;max+=p1;
+  // Umrechnung von Breite auf Anzahl:
+  dx=((dx+50)/100)-1;if (dx<0) dx=0;
+
+  x=({({}),({})});
+  for (i=0;i<2*MAX_TEAMROWS;i++)
+    if (i>=min && i<=max)
+      x[1]+=b_rows[i][0..dx]; // Freunde
+  for (i=2*MAX_TEAMROWS+1;i<4*MAX_TEAMROWS;i++)
+    if (i>=min && i<=max)
+      x[0]+=b_rows[i][0..dx]; // Feinde
+
+  return x;
+}
+
+// Findet feindliche oder freundliche Gruppe (oder Summe beider) im
+// angegebenen Bereich.
+varargs object *
+FindDistantGroup(object pl, int who, int dist, int dy, int dx) {
+  mixed *x;
+
+  x=FindDistantGroups(pl,dist,dy,dx);
+  if (who<0)
+    return x[0];
+  else if (who>0)
+    return x[1];
+  return x[0]+x[1];
+}
+
+
+static varargs object
+find_victim(string wen, object pl) {
+  object victim;
+
+  if (!pl) return 0;
+  if (!sizeof(wen)) {
+    if (victim = (object)pl->SelectEnemy())
+      return victim;
+    else
+      return 0;
+  }
+  if (victim = present(wen, environment(pl)))
+    return victim;
+  else if (victim = present(wen, pl))
+    return victim;
+  else
+    return 0;
+}
+varargs object
+FindVictim(string wen, object pl, string msg) {
+  object vic;
+
+  if (!(vic=find_victim(wen,pl)) && msg)
+    write(msg);
+  return vic;
+}
+varargs object
+FindLivingVictim(string wen, object pl, string msg) {
+  object vic;
+
+  if (!(vic=FindVictim(wen,pl,msg)))
+    return 0;
+  if (!living(vic) || vic->QueryProp(P_GHOST)) {
+    printf("%s lebt doch nicht!\n", capitalize((string)vic->name()));
+    return 0;
+  }
+  return vic;
+}
+
+private varargs object
+DoFindEnemyVictim(string wen, object pl, string msg,
+                  mixed func, int min, int max) {
+  object vic;
+  mixed no_attack;
+  int row;
+
+  if (!(vic=FindLivingVictim(wen,pl,msg))) {
+    if ((stringp(wen) && wen!="") || !objectp(pl))
+      return 0;
+    if (pointerp(func)) { // Soll einer DIESER Gegner genommen werden?
+      if (!(vic=(object)pl->SelectEnemy(func))) // Dann daraus auswaehlen
+        return 0;
+    } else {
+      if (!stringp(func))
+        func="SelectEnemy";
+      if (!(vic=(object)call_other(pl,func,0,min,max)))
+        return 0;
+    }
+    func=0; // kein zweites Mal pruefen.
+  }
+  if (no_attack = (mixed)vic->QueryProp(P_NO_ATTACK)) {
+    if (stringp(no_attack))
+      write(no_attack);
+    else
+      write(vic->Name(WER,1)+" laesst sich nicht angreifen.\n");
+    return 0;
+  }
+  if (vic==pl) {
+    write("Du koenntest Dir dabei wehtun.\n");
+    return 0;
+  }
+  if (stringp(func)) {
+    switch(func) {
+    case "SelectNearEnemy":
+      if (pl->PresentPosition()>1) {
+        write("Du stehst nicht in der ersten Kampfreihe.\n");
+        return 0;
+      }
+      if (vic->PresentPosition()>1) {
+        write(vic->Name(WER,1)+" ist in einer hinteren Kampfreihe.\n");
+        return 0;
+      }
+      break;
+    case "SelectFarEnemy":
+      if (row=(int)vic->PresentPosition())
+        row--;
+      if (row>=min && row<=max)
+        break;
+      if (row<min)
+        write(vic->Name(WER,1)+" ist zu nahe.\n");
+      else if (row>max)
+        write(vic->Name(WER,1)+" ist zu weit weg.\n");
+      else
+        write(vic->Name(WER,1)+" ist unerreichbar.\n");
+      return 0;
+    default:;
+    }
+  } else if (pointerp(func)) {
+    if (member(func,vic)<0) {
+      write(vic->Name(WER,1)+" ist unerreichbar.\n");
+      return 0;
+    }
+  }
+
+  if (!pl->IsEnemy(vic)) // War es bisher kein Feind?
+    pl->Kill(vic);       // Dann ist es jetzt einer.
+  return vic;
+}
+
+varargs object
+FindEnemyVictim(string wen, object pl, string msg) {
+  return DoFindEnemyVictim(wen,pl,msg,"SelectEnemy");
+}
+
+// Wie FindEnemyVictim, aber nur im Nahkampf erreichbare Feinde werden
+// gefunden.
+varargs object
+FindNearEnemyVictim(string wen, object pl, string msg) {
+  return DoFindEnemyVictim(wen,pl,msg,"SelectNearEnemy");
+}
+
+// Wie FindEnemyVictim, aber nur Feinde im Bereich der angegebenen Reihen
+// (min,max) werden gefunden.
+varargs object
+FindFarEnemyVictim(string wen, object pl, string msg,
+                   int min, int max) {
+  return DoFindEnemyVictim(wen,pl,msg,"SelectFarEnemy",min,max);
+}
+
+// Wie FindEnemyVictim, findet aber nur Feinde in
+// FindDistantGroup(GEGNER,entfernung,abweichung)
+varargs object
+FindDistantEnemyVictim(string wen, object pl, string msg,
+                       int dist, int dy) {
+  return DoFindEnemyVictim(wen,pl,msg,
+                           FindDistantGroup(pl,-1,dist,dy,10000));
+}
+
+varargs int
+TryGlobalAttackSpell(object caster, mapping sinfo, int suc,
+                     int damage, mixed dt, mixed is_spell,
+                     int dist, int depth, int width) {
+  int i;
+  mixed x,coldam;
+  object *obs,ob;
+
+  if (!suc) suc=random(sinfo[SI_SKILLABILITY]);
+  if (!dt) dt=GetData(SI_SKILLDAMAGE_TYPE,sinfo,caster);
+  if (!is_spell) is_spell=GetData(SI_SPELL,sinfo,caster);
+  if (!dist) dist=GetRandFValueO(SI_DISTANCE,sinfo,caster);
+  if (!depth) depth=GetRandFValueO(SI_DEPTH,sinfo,caster);
+  if (!width) width=GetRandFValueO(SI_WIDTH,sinfo,caster);
+
+  if (!depth && width) depth=width;
+  if (!width && depth) width=depth;
+  if (!mappingp(is_spell)) is_spell=([]);
+  is_spell[SP_GLOBAL_ATTACK]=1;
+
+  x=FindDistantGroups(caster,dist,depth,width);
+  sinfo[SI_NUMBER_ENEMIES]=sizeof(x[0]);
+  sinfo[SI_NUMBER_FRIENDS]=sizeof(x[1]);
+
+  obs=x[0];
+  for (i=sizeof(obs)-1;i>=0;i--)
+    if (objectp(ob=obs[i]) && suc>=ob->SpellDefend(caster,sinfo))
+      TryAttackSpell(ob,(damage?random(damage):
+                         GetRandFValueO(SI_SKILLDAMAGE,sinfo,caster)),
+                     dt,is_spell,caster,sinfo);
+
+  if (!intp(coldam=sinfo[SI_COLLATERAL_DAMAGE]) || !coldam)
+    return 1;
+  obs=x[1];
+  for (i=sizeof(obs)-1;i>=0;i--)
+    if (objectp(ob=obs[i]) && suc>=ob->SpellDefend(caster,sinfo))
+      ob->reduce_hit_points(((damage?random(damage):
+                              GetRandFValueO(SI_SKILLDAMAGE,sinfo,caster))
+                             *coldam)/10);
+  // 10 statt 100 ist Absicht, weil reduce_hit_points schon um Faktor
+  // 10 staerker wirkt als Defend.
+
+  return 1;
+}