spellbook.c-Dateireferenz

#include <thing/properties.h>
#include <wizlevels.h>
#include <new_skills.h>
#include <spellbook.h>

Include-Abhängigkeitsdiagramm für spellbook.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	ME   this_object()
#define	SMUL(x, y)   ((x<0 && y<0)?(-1*x*y):(x*y))
Funktionen
void	create ()
mapping	_query_sb_spells ()
mapping	QuerySpell (string spell)
varargs int	AddSpell (string verb, int kosten, mixed ski)
int	TryAttackSpell (object victim, int damage, mixed dtypes, mixed is_spell, object caster, mapping sinfo)
varargs int	TryDefaultAttackSpell (object victim, object caster, mapping sinfo, mixed si_spell)
int	SpellSuccess (object caster, mapping sinfo)
int	CanTrySpell (object caster, mapping sinfo)
void	Learn (object caster, string spell, mapping sinfo)
void	Erfolg (object caster, string spell, mapping sinfo)
void	Misserfolg (object caster, string spell, mapping sinfo)
string	SelectSpell (string spell, mapping sinfo)
varargs void	prepare_spell (object caster, string spell, mapping sinfo)
varargs int	UseSpell (object caster, string spell, mapping sinfo)
object *	FindGroup (object pl, int who)
object *	FindGroupN (object pl, int who, int n)
object *	FindGroupP (object pl, int who, int pr)
varargs mixed	FindDistantGroups (object pl, int dist, int dy, int dx)
varargs object *	FindDistantGroup (object pl, int who, int dist, int dy, int dx)
static varargs object	find_victim (string wen, object pl)
varargs object	FindVictim (string wen, object pl, string msg)
varargs object	FindLivingVictim (string wen, object pl, string msg)
static private varargs object	DoFindEnemyVictim (string wen, object pl, string msg, mixed func, int min, int max)
varargs object	FindEnemyVictim (string wen, object pl, string msg)
varargs object	FindNearEnemyVictim (string wen, object pl, string msg)
varargs object	FindFarEnemyVictim (string wen, object pl, string msg, int min, int max)
varargs object	FindDistantEnemyVictim (string wen, object pl, string msg, int dist, int dy)
varargs int	TryGlobalAttackSpell (object caster, mapping sinfo, int suc, int damage, mixed dt, mixed is_spell, int dist, int depth, int width)
Variablen
inherit std	thing
inherit std	restriction_checker
inherit std player	pklog

---

Makro-Dokumentation

#define ME   this_object()

Definiert in Zeile 23 der Datei spellbook.c.

#define SMUL	(	x,
		y		)	((x<0 && y<0)?(-1*x*y):(x*y))

Definiert in Zeile 177 der Datei spellbook.c.

---

Dokumentation der Funktionen

mapping _query_sb_spells

(

)

Definiert in Zeile 34 der Datei spellbook.c.

Benutzt F_VALUE, P_SB_SPELLS und Query().

                           {
    // Kopie liefern, da sonst versehentlich schnell eine Aenderung des
    // originalen Mappings hier passieren kann.
    return(deep_copy(Query(P_SB_SPELLS, F_VALUE)));
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs int AddSpell	(	string	verb,
		int	kosten,
		mixed	ski
	)

Definiert in Zeile 53 der Datei spellbook.c.

Benutzt AddSkillMappings(), F_VALUE, level, P_GLOBAL_SKILLPROPS, P_LEVEL, P_SB_SPELLS, Query(), QueryProp(), SetProp(), SI_SKILLRESTR_LEARN, SI_SPELL, SI_SPELLCOST und SP_NAME.

                                             {
  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:([]) ]);
  // gleiches SP_NAME in Skillmapping und SI_SPELL-Mapping eintragen. *seufz*
  // Noetig, weil es in der Vergangenheit offenbar eine grosse Verwirrung
  // gegeben hat, wo SP_NAME hingehoert (in SI_SPELL) und min. das halbe Mud
  // falsch prueft. TODO: Wenn der Rest vom mud richtig prueft, sollte
  // sichergestellt werden, dass SP_NAME nur noch in SI_SPELL drinsteht.
  if (!stringp(ski[SP_NAME]) && !stringp(ski[SI_SPELL][SP_NAME])) {
      ski[SP_NAME] = verb;
      ski[SI_SPELL][SP_NAME] = verb;
  }
  else if (stringp(ski[SP_NAME]) && !stringp(ski[SI_SPELL][SP_NAME]) )
      ski[SI_SPELL][SP_NAME] = ski[SP_NAME];
  else if (stringp(ski[SI_SPELL][SP_NAME]) && !stringp(ski[SP_NAME]) )
      ski[SP_NAME] = ski[SI_SPELL][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);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int CanTrySpell	(	object	caster,
		mapping	sinfo
	)

Definiert in Zeile 191 der Datei spellbook.c.

Benutzt check_restrictions(), P_GHOST und SI_SKILLRESTR_USE.

Wird benutzt von UseSpell().

                                          {
  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;
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void create

(

)

Definiert in Zeile 25 der Datei spellbook.c.

Benutzt create(), F_MODE_AS, F_VALUE, P_SB_SPELLS, PROTECTED und Set().

              {
  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();
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static private varargs object DoFindEnemyVictim	(	string	wen,
		object	pl,
		string	msg,
		mixed	func,
		int	min,
		int	max
	)			[static]

Definiert in Zeile 596 der Datei spellbook.c.

Benutzt FindLivingVictim(), no_attack(), P_NO_ATTACK und WER.

Wird benutzt von FindDistantEnemyVictim(), FindEnemyVictim(), FindFarEnemyVictim() und FindNearEnemyVictim().

                                                {
  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;
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void Erfolg	(	object	caster,
		string	spell,
		mapping	sinfo
	)

Definiert in Zeile 240 der Datei spellbook.c.

Benutzt env().

Wird benutzt von UseSpell().

                                                   {
  object env;
  if(env=environment(caster))
     env->SpellInform(caster,spell,sinfo);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static varargs object find_victim	(	string	wen,
		object	pl
	)			[static]

Definiert in Zeile 557 der Datei spellbook.c.

Wird benutzt von FindVictim().

                                   {
  object victim;

  if (!pl) return 0;
  if (!strlen(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;
}

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs object FindDistantEnemyVictim	(	string	wen,
		object	pl,
		string	msg,
		int	dist,
		int	dy
	)

Definiert in Zeile 682 der Datei spellbook.c.

Benutzt DoFindEnemyVictim() und FindDistantGroup().

                                         {
  return DoFindEnemyVictim(wen,pl,msg,
                           FindDistantGroup(pl,-1,dist,dy,10000));
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs object* FindDistantGroup	(	object	pl,
		int	who,
		int	dist,
		int	dy,
		int	dx
	)

Definiert in Zeile 544 der Datei spellbook.c.

Benutzt FindDistantGroups().

Wird benutzt von FindDistantEnemyVictim().

                                                               {
  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];
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs mixed FindDistantGroups	(	object	pl,
		int	dist,
		int	dy,
		int	dx
	)

Definiert in Zeile 445 der Datei spellbook.c.

Benutzt EMPTY_TEAMARRAY, i, IS_LEARNING, m_delete(), MAX_TEAM_ROWLEN, MAX_TEAMROWS, min, ob(), P_FRIEND, P_GHOST, P_NO_ATTACK, P_NO_GLOBAL_ATTACK, P_TEAM, qp, SA_EXTENSION, SA_RANGE und x.

Wird benutzt von FindDistantGroup() und TryGlobalAttackSpell().

                                                       {
  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)))))
      efun::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;
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs object FindEnemyVictim	(	string	wen,
		object	pl,
		string	msg
	)

Definiert in Zeile 666 der Datei spellbook.c.

Benutzt DoFindEnemyVictim().

Wird benutzt von feuerball(), kampfschrei(), pfeil() und saeurestrahl().

                                                   {
  return DoFindEnemyVictim(wen,pl,msg,"SelectEnemy");
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs object FindFarEnemyVictim	(	string	wen,
		object	pl,
		string	msg,
		int	min,
		int	max
	)

Definiert in Zeile 676 der Datei spellbook.c.

Benutzt DoFindEnemyVictim().

                                     {
  return DoFindEnemyVictim(wen,pl,msg,"SelectFarEnemy",min,max);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

object* FindGroup	(	object	pl,
		int	who
	)

Definiert in Zeile 387 der Datei spellbook.c.

Benutzt env(), IS_LEARNING, ob(), P_FRIEND, P_GHOST, P_NO_ATTACK, P_NO_GLOBAL_ATTACK, P_TEAM, qp und team.

Wird benutzt von FindGroupN() und FindGroupP().

                              {
  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;
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

object* FindGroupN	(	object	pl,
		int	who,
		int	n
	)

Definiert in Zeile 421 der Datei spellbook.c.

Benutzt FindGroup() und SA_EXTENSION.

                                      {
  if (!pl) return ({});
  n=(n*(int)pl->QuerySkillAttribute(SA_EXTENSION))/100;
  if (n<1) n=1;
  return FindGroup(pl,who)[0..(n-1)];
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

object* FindGroupP	(	object	pl,
		int	who,
		int	pr
	)

Definiert in Zeile 429 der Datei spellbook.c.

Benutzt FindGroup(), i und SA_EXTENSION.

                                       {
  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;
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs object FindLivingVictim	(	string	wen,
		object	pl,
		string	msg
	)

Definiert in Zeile 583 der Datei spellbook.c.

Benutzt FindVictim() und P_GHOST.

Wird benutzt von DoFindEnemyVictim() und schaetz().

                                                    {
  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;
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs object FindNearEnemyVictim	(	string	wen,
		object	pl,
		string	msg
	)

Definiert in Zeile 671 der Datei spellbook.c.

Benutzt DoFindEnemyVictim().

                                                       {
  return DoFindEnemyVictim(wen,pl,msg,"SelectNearEnemy");
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs object FindVictim	(	string	wen,
		object	pl,
		string	msg
	)

Definiert in Zeile 575 der Datei spellbook.c.

Benutzt find_victim().

Wird benutzt von FindLivingVictim() und identifiziere().

                                              {
  object vic;

  if (!(vic=find_victim(wen,pl)) && msg)
    write(msg);
  return vic;
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void Learn	(	object	caster,
		string	spell,
		mapping	sinfo
	)

Definiert in Zeile 208 der Datei spellbook.c.

Benutzt A_CON, A_DEX, A_INT, A_STR, GetFValue(), GetFValueO(), GetOffset(), SI_DIFFICULTY, SI_LEARN_ATTRIBUTE, SI_SKILLLEARN und SI_SPELLCOST.

Wird benutzt von Misserfolg().

                                                  {
  int val,diff,attval;
  mapping attr;
  
  // 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);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void Misserfolg	(	object	caster,
		string	spell,
		mapping	sinfo
	)

Definiert in Zeile 247 der Datei spellbook.c.

Benutzt Learn().

Wird benutzt von UseSpell().

                                                       {
  write("Der Zauberspruch ist missglueckt.\n");
  write("Du lernst aus Deinem Fehler.\n");
  Learn(caster,spell,sinfo);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs void prepare_spell	(	object	caster,
		string	spell,
		mapping	sinfo
	)

Definiert in Zeile 261 der Datei spellbook.c.

Benutzt SI_PREPARE_MSG.

Wird benutzt von UseSpell().

                                                          {
  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));
}

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

mapping QuerySpell

(

string

spell

)

Definiert in Zeile 40 der Datei spellbook.c.

Benutzt P_SB_SPELLS und Query().

                                 {
  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);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

string SelectSpell	(	string	spell,
		mapping	sinfo
	)

Definiert in Zeile 254 der Datei spellbook.c.

Benutzt SI_SKILLFUNC.

Wird benutzt von UseSpell().

                                         {
  if (sinfo && sinfo[SI_SKILLFUNC])
    return sinfo[SI_SKILLFUNC];
  return spell;
}

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int SpellSuccess	(	object	caster,
		mapping	sinfo
	)

Definiert in Zeile 179 der Datei spellbook.c.

Benutzt MAX_ABILITY, SI_SKILLABILITY, SK_CASTING und SMUL.

Wird benutzt von ausweichen(), feuerball(), identifiziere(), kampfschrei(), licht(), pfeil(), saeurestrahl(), schaetz() und schnell().

                                           {
  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;
}

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int TryAttackSpell	(	object	victim,
		int	damage,
		mixed	dtypes,
		mixed	is_spell,
		object	caster,
		mapping	sinfo
	)

Definiert in Zeile 107 der Datei spellbook.c.

Benutzt CheckPlayerAttack(), no_attack(), P_GHOST, P_NO_ATTACK, P_NOMAGIC, SA_DAMAGE, SA_ENEMY_SAVE, SI_NOMAGIC, SP_NAME und WER.

Wird benutzt von TryDefaultAttackSpell() und TryGlobalAttackSpell().

                                                             {
  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
  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]  : "") ) );

  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);
  }
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int TryDefaultAttackSpell	(	object	victim,
		object	caster,
		mapping	sinfo,
		mixed	si_spell
	)

Definiert in Zeile 144 der Datei spellbook.c.

Benutzt GetData(), GetRandFValueO(), OFFSET, P_TEAM, SI_SKILLDAMAGE, SI_SKILLDAMAGE_BY_ROW, SI_SKILLDAMAGE_TYPE, SI_SPELL, team und TryAttackSpell().

Wird benutzt von feuerball(), pfeil() und saeurestrahl().

                                      {
  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);
   }
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int TryGlobalAttackSpell	(	object	caster,
		mapping	sinfo,
		int	suc,
		int	damage,
		mixed	dt,
		mixed	is_spell,
		int	dist,
		int	depth,
		int	width
	)

Definiert in Zeile 689 der Datei spellbook.c.

Benutzt FindDistantGroups(), GetData(), GetRandFValueO(), obs, SI_COLLATERAL_DAMAGE, SI_DEPTH, SI_DISTANCE, SI_NUMBER_ENEMIES, SI_NUMBER_FRIENDS, SI_SKILLABILITY, SI_SKILLDAMAGE, SI_SKILLDAMAGE_TYPE, SI_SPELL, SI_WIDTH, SP_GLOBAL_ATTACK und TryAttackSpell().

                                                     {
  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;
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs int UseSpell	(	object	caster,
		string	spell,
		mapping	sinfo
	)

Definiert in Zeile 271 der Datei spellbook.c.

Benutzt ABGEWEHRT, AddSkillMappings(), CanTrySpell(), Erfolg(), ERFOLG, GetFValueO(), GetValue(), Misserfolg(), MISSERFOLG, NO_ATTACK_BUSY_QUERY, P_ATTACK_BUSY, P_NEXT_SPELL_TIME, P_NOMAGIC, P_PREPARED_SPELL, P_SP, prepare_spell(), QueryProp(), QuerySpell(), race_modifier(), SelectSpell(), SI_ATTACK_BUSY_AMOUNT, SI_ATTACK_BUSY_MSG, SI_NO_ATTACK_BUSY, SI_NOMAGIC, SI_NOMAGIC_MSG, SI_PREPARE_ABORT_MSG, SI_PREPARE_BUSY_MSG, SI_PREPARE_TIME, SI_SKILLARG, SI_SKILLFUNC, SI_SP_LOW_MSG, SI_SPELLCOST, SI_SPELLFATIGUE, SI_TIME_MSG und spellbook.

                                                     {
  mapping ski,tmp;
  string spellbook,sname,fname,txt;
  int res,fat,cost;
  mixed ps;

  if (!caster || !spell)
    return 0;
  sname=SelectSpell(spell,sinfo);
  // Spell kann in der Gilde anderen Namen haben
  if (!(ski=QuerySpell(sname))) // Existiert dieser Spell?
    return 0;
  ski=AddSkillMappings(ski,sinfo);
  // Gildeneigenschaften sollen Spelleigenschaften ueberschreiben koennen
  ski=race_modifier(caster,ski);
  // Fuer verschiedene Rassen unterschiedliche Eigenschaften

  // 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 __BOOT_TIME__ < 1268687556
  if (time()<caster->QueryProp(P_NEXT_SPELL_TIME)) {
#else
  if (caster->CheckSpellFatigue()) {
#endif
    if(txt=ski[SI_TIME_MSG]) write(txt);
    else write("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);

  if (!(fname=sinfo[SI_SKILLFUNC]))
    fname=sname;
  // Funktion kann anderen Namen haben als Spell
  res=0;
  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 {
    res=(int)call_other(this_object(),fname,caster,ski);
  }
  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]);
                }
  if ((fat=GetFValueO(SI_SPELLFATIGUE,ski,caster))<0)
    fat=1;
  caster->restore_spell_points(-1*cost);
#if __BOOT_TIME < 1268687556
  caster->SetProp(P_NEXT_SPELL_TIME,time()+fat);
#else
  caster->SetSpellFatigue(fat);
#endif

  if (res==ERFOLG)
    Erfolg(caster,spell,ski);
  else
  if (res==MISSERFOLG)
    Misserfolg(caster,spell,ski);
  return 1;
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

---

Variablen-Dokumentation

inherit std player pklog

Definiert in Zeile 16 der Datei spellbook.c.

inherit std restriction_checker

Definiert in Zeile 15 der Datei spellbook.c.

inherit std thing

Definiert in Zeile 14 der Datei spellbook.c.