skills.c-Dateireferenz

#include <living/skills.h>
#include <living/skill_attributes.h>
#include <player/life.h>
#include <thing/properties.h>
#include <new_skills.h>
#include <wizlevels.h>

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
#define	SMUL(x, y)   ((x<0 && y<0)?(-1*x*y):(x*y))
Funktionen
private void	expire_spell_fatigues ()
	Loescht abgelaufene Keys aus dem spell_fatigue mapping.
protected void	create ()
nomask protected int	security_check ()
public int	is_deactivated_skill (string sname, string gilde)
static string	_set_guild (string gildenname)
static string	_query_guild ()
static string	_query_visible_guild ()
static string	_query_visible_subguild_title ()
static int	_set_guild_level (int num)
static int	_query_guild_level ()
static mixed	_query_guild_prepareblock ()
static mixed	_set_guild_prepareblock (mixed arg)
static string	_set_guild_title (string t)
static string	_query_guild_title ()
static string	_query_title ()
nomask private int	valid_setskills (string gilde)
private mapping	internal_set_newskills (mapping value, string gilde)
private mapping	internal_query_newskills (string gilde)
static varargs mapping	_set_newskills (mapping value, string gilde)
static varargs mapping	_query_newskills (string gilde)
private mapping	InternalQuerySkill (string sname, string gilde)
public varargs mapping	QuerySkill (string sname, string gilde)
public varargs int	QuerySkillAbility (mixed sname, mixed argl)
protected varargs mixed	LimitAbility (mixed sinfo, int diff)
public varargs void	ModifySkill (string sname, mixed val, int diff, string gilde)
public varargs void	LearnSkill (string sname, int add, int diff)
public varargs int	UseSpell (string str, string spell)
public varargs mixed	UseSkill (string skill, mapping args)
public varargs int	CheckSpellFatigue (string key)
public varargs int	SetSpellFatigue (int duration, string key)
	Speichert eine Spellfatigue von <duration> Sekunden fuer <key>.
public void	DeleteSpellFatigue (string key)
static int	_set_next_spell (int fatigue)
	Setmethode fuer P_NEXT_SPELL_TIME.
static int	_query_next_spell ()
	Querymethode fuer P_NEXT_SPELL_TIME.
Variablen
inherit std living	std_skills
private mapping	spell_fatigues = ([])
private nosave int	valid_setskills_override

---

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 14 der Datei skills.c.

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

Definiert in Zeile 427 der Datei skills.c.

Wird benutzt von SpellSuccess().

---

Dokumentation der Funktionen

static string _query_guild

(

)

[static]

Definiert in Zeile 74 der Datei skills.c.

{ string res;

  if ( !(res=Query(P_GUILD)) && query_once_interactive(this_object()) )
  {
    // Spieler, die keiner Gilde angehoeren, gehoeren zur Abenteurergilde
    if ( !(res=QueryProp(P_DEFAULT_GUILD)) )
      return DEFAULT_GUILD;
    else
      Set(P_GUILD,res);
    return res;
  }

  return res;
}

static int _query_guild_level

(

)

[static]

Definiert in Zeile 124 der Datei skills.c.

{ string  gilde;
  mapping levels;

  if ( !(gilde=QueryProp(P_GUILD)) )
    return 0;

  if ( gilde=="abenteurer" || gilde=="katzenkrieger" )
      return _set_guild_level(QueryProp(P_LEVEL));

  if ( !mappingp(levels=Query(P_GUILD_LEVEL)) )
      return 0;

  return levels[gilde];
}

static mixed _query_guild_prepareblock

(

)

[static]

Definiert in Zeile 140 der Datei skills.c.

{ mapping res;
  string  gilde;

  if ( !stringp(gilde=QueryProp(P_GUILD)) )
    return 0;
  if ( !mappingp(res=Query(P_GUILD_PREPAREBLOCK)) 
      || !member(res,gilde) )
    return 0;
  return res[gilde];
}

static string _query_guild_title

(

)

[static]

Definiert in Zeile 183 der Datei skills.c.

{ string gilde,t;
  object g;
  mapping titles;

  if ( !(gilde=QueryProp(P_GUILD)) )
    return 0;

  if ( !mappingp(titles=Query(P_GUILD_TITLE)) )
    titles=([]);

  t=titles[gilde];
  if ( !t && query_once_interactive(this_object())
      && objectp(g=find_object("/gilden/"+gilde)) )
  {
    g->adjust_title(this_object());
    SetProp(P_TITLE,0);

    if ( !mappingp(titles=Query(P_GUILD_TITLE)) )
      return 0;

    t=titles[gilde];
  }

  return t;
}

static varargs mapping _query_newskills

(

string

gilde

)

[static]

Definiert in Zeile 357 der Datei skills.c.

                                                      {

  // sonst Kopie des spellmappings liefern! Kostet zwar, aber verhindert
  // einige andere Bugs und versehentliche Aenderungen an den Skills!
  return(deep_copy(internal_query_newskills(gilde)));
}

static int _query_next_spell

(

)

[static]

Querymethode fuer P_NEXT_SPELL_TIME.

Definiert in Zeile 750 der Datei skills.c.

                               {
  return CheckSpellFatigue();
}

static string _query_title

(

)

[static]

Definiert in Zeile 210 der Datei skills.c.

{ string ti;

  if ( stringp(ti=Query(P_TITLE)) )
    return ti;

  return QueryProp(P_GUILD_TITLE);
}

static string _query_visible_guild

(

)

[static]

Definiert in Zeile 90 der Datei skills.c.

{ string res;

  if ( stringp(res=Query(P_VISIBLE_GUILD)) )
    return res;

  return QueryProp(P_GUILD);
}

static string _query_visible_subguild_title

(

)

[static]

Definiert in Zeile 99 der Datei skills.c.

{ string res;

  if ( stringp(res=Query(P_VISIBLE_SUBGUILD_TITLE)) )
    return res;

  return QueryProp(P_SUBGUILD_TITLE);
}

static string _set_guild

(

string

gildenname

)

[static]

Definiert in Zeile 58 der Datei skills.c.

{ object pre;

  if (!objectp(pre=previous_object()))
    return 0;

  if ( pre!=this_object() // Das Lebewesen selber darf die Gilde setzen,
      && object_name(pre)!=GUILDMASTER  // der Gildenmaster auch
      && !security_check() )          // und auch Erzmagier.
    return 0;

  Set(P_GUILD,gildenname);

  return gildenname;
}

static int _set_guild_level

(

int

num

)

[static]

Definiert in Zeile 108 der Datei skills.c.

{ string gilde;
  mapping levels;

  if ( !(gilde=QueryProp(P_GUILD)) )
    return 0;

  if ( !mappingp(levels=Query(P_GUILD_LEVEL)) )
    levels=([]);

  levels[gilde]=num;
  Set(P_GUILD_LEVEL,levels);

  return num;
}

static mixed _set_guild_prepareblock

(

mixed

arg

)

[static]

Definiert in Zeile 152 der Datei skills.c.

{ mapping res;
  string  gilde;

  if ( !stringp(gilde=QueryProp(P_GUILD)) )
    return 0;
  if ( !mappingp(res=Query(P_GUILD_PREPAREBLOCK)) )
    res=([]);

  res[gilde]=arg;
  Set(P_GUILD_PREPAREBLOCK,res);

  return arg;
}

static string _set_guild_title

(

string

t

)

[static]

Definiert in Zeile 167 der Datei skills.c.

{ string gilde;
  mapping titles;

  if ( !(gilde=QueryProp(P_GUILD)) )
    return 0;

  if ( !mappingp(titles=Query(P_GUILD_TITLE)) )
    titles=([]);

  titles[gilde]=t;
  Set(P_GUILD_TITLE,titles);

  return t;
}

static varargs mapping _set_newskills	(	mapping	value,
		string	gilde
	)			[static]

Definiert in Zeile 339 der Datei skills.c.

                                                                   {

  // value auf Mappings normalisieren, ggf. Kopieren
  if ( !mappingp(value) )
      value=([]);
  else
      //zur Sicherheit, wer weiss, was der setzende noch damit macht...
      value=deep_copy(value);

  // und setzen...
  internal_set_newskills(value, gilde);

  // und noch ne Kopie von dem Liefern, was wir gesetzt haben (keine Referenz,
  // sonst koennte der Aufrufende ja noch im Nachhinein aendern).
  return(_query_newskills(gilde));
}

static int _set_next_spell

(

int

fatigue

)

[static]

Setmethode fuer P_NEXT_SPELL_TIME.

Definiert in Zeile 745 der Datei skills.c.

                                        {
  return SetSpellFatigue(fatigue - time());
}

public varargs int CheckSpellFatigue

(

string

key

)

Definiert in Zeile 699 der Datei skills.c.

                                                 {
  // key==0 is the (default) global spellfatigue.
  if (spell_fatigues[key] > time())
    return spell_fatigues[key]; // Ablaufzeit zurueckgeben.

  return 0; // ok, keine Sperre.
}

protected void create

(

)

Definiert in Zeile 31 der Datei skills.c.

Benutzt call_out().

{
  // mainly necessary for players, but there may be some NPC with savefiles.
  // Additionally, it simplifies expiration of old keys to have it here.
  call_out(#'expire_spell_fatigues, 4);
}

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

public void DeleteSpellFatigue

(

string

key

)

Definiert in Zeile 729 der Datei skills.c.

                                           {
  // key==0 is the (default) global spellfatigue.
  efun::m_delete(spell_fatigues, key);
}

private void expire_spell_fatigues

(

)

Loescht abgelaufene Keys aus dem spell_fatigue mapping.

Definiert in Zeile 736 der Datei skills.c.

                                     {
  foreach(string key, int endtime: spell_fatigues) {
    if (endtime <= time())
      efun::m_delete(spell_fatigues, key);
  }
}

private mapping internal_query_newskills

(

string

gilde

)

Definiert in Zeile 323 der Datei skills.c.

                                                       {
  mapping skills;

  // richtige Gilde abfragen.
  if ( !gilde && !(gilde=QueryProp(P_GUILD)) )
    gilde="ANY";

  skills=Query(P_NEWSKILLS);

  if (!mappingp(skills) || !mappingp(skills=skills[gilde]) )
    return ([]);

  return(skills);
}

private mapping internal_set_newskills	(	mapping	value,
		string	gilde
	)

Definiert in Zeile 296 der Datei skills.c.

                                                                    {
  mapping skills;

  // in der richtigen Gilde setzen.
  if ( !gilde && !(gilde=QueryProp(P_GUILD)) )
    gilde="ANY";

  // Query(), hier ist eine Kopie nicht sinnvoll.
  if ( !mappingp(skills=Query(P_NEWSKILLS,F_VALUE)) ) {
    skills=([]);
    Set(P_NEWSKILLS, skills, F_VALUE);
  }

  // Falls dies hier mal ausgewertet werden sollte, nicht vergessen, dass
  // einige Funktion hier im File die Prop evtl. via
  // internal_query_newskills() abrufen und direkt aendern...
  valid_setskills(gilde); // Sicherheitsueberpruefung
  
  // Skills setzen. Set() unnoetig, weil wir das von Query() gelieferte
  // Mapping aendern und das ja via Referenz bekommen haben.
  skills[gilde]=value;
  //Set(P_NEWSKILLS,skills);

  return(value);
}

private mapping InternalQuerySkill	(	string	sname,
		string	gilde
	)

Definiert in Zeile 364 der Datei skills.c.

                                                               {
  mixed skill, skills;
  // In is_any wird gespeichert, ob es ein gildenunabhaengier Skill ist,
  // fuer die is_deactivate_skill-Abfrage.
  int is_any;

  // Skills komplett abfragen, keine spez. Gilde
  if (!mappingp(skills=Query(P_NEWSKILLS,F_VALUE)))
      return 0;

  if (stringp(gilde) && strlen(gilde)) {
    //bestimmte Gilde angegeben, gut, dort gucken.
    if (mappingp(skills[gilde]))
      skill=skills[gilde][sname]; 
  }
  else {
    gilde=QueryProp(P_GUILD); //reale Gilde holen
    if (gilde && mappingp(skills[gilde]) && 
                (skill=skills[gilde][sname])) {
      // gibt es den Spell in der Gilde des Spielers?
      // dann hier nix machen...
    }
    else if (mappingp(skills["ANY"])) {
     // Zum Schluss: Gibt es den Skill vielleicht Gildenunabhaengig?
      skill=skills["ANY"][sname];
      // wenn man hier reinkommt, dann spaeter mit is_deactivated_skill() 
      // pruefen!
      is_any=1;
    }
  }

  // wenn kein Skill gefunden, mit 0 direkt raus
  if (!skill) return 0;

  // ggf. Skills auf Mappings normalisieren und auch direkt im Skillmapping
  // 'upgraden'
  if ( !mappingp(skill) ) {
    skill=([SI_SKILLABILITY:skill]);
    skills[gilde][sname]=skill;
  }

  // Bei gildenunabhaengigen auch im Skillmapping vermerken
  if ( is_any ) {               
      skill+=([SI_GUILD:"ANY"]);                
      // Ist er vielleicht in der Gilde des Spielers deaktiviert?                               
      // Dies kann nur der Fall sein, wenn es kein Gildenskill ist.                             
      if (is_deactivated_skill(sname,gilde)) {                      
                  return 0;                     
      }
  }

  return(skill);
}

public int is_deactivated_skill	(	string	sname,
		string	gilde
	)

Definiert in Zeile 53 der Datei skills.c.

{
                return 0;
}

public varargs void LearnSkill	(	string	sname,
		int	add,
		int	diff
	)

Definiert in Zeile 566 der Datei skills.c.

{ mapping skill;
  string skill2,gilde;
  int val;


  // Spieler sollen nur lernen, wenn sie interactive sind. Das soll
  // natuerlich nur fuer Spieler gelten.
  if (query_once_interactive(this_object()) && !interactive())
                  return;

  if ( add>MAX_SKILLEARN )
    add=MAX_SKILLEARN;
  else if ( add<1 )
    add=1;

  // Skillmapping ermitteln (hier kommt keine Kopie zurueck)
  skill=InternalQuerySkill(sname, 0);

  if (mappingp(skill))
  {
    val=skill[SI_SKILLABILITY];
    gilde=skill[SI_GUILD];
  }
  else
  {
    val=0;
    gilde=0;
  }

  val+=add;

  // Faehigkeit soll durch Erhoehung nicht verschwinden.
  if ( !val && add )
    val=1;

  ModifySkill(sname,val,diff,gilde);
  if ( mappingp(skill) && skill2=skill[SI_INHERIT] )
    LearnSkill(skill2,add/3,diff);
}

protected varargs mixed LimitAbility	(	mixed	sinfo,
		int	diff
	)

Definiert in Zeile 452 der Datei skills.c.

{ mixed abil;
  int max,old,d2;

  abil=(mappingp(sinfo)?sinfo[SI_SKILLABILITY]:sinfo);

  if ( !intp(abil) )
    return sinfo;
  old=abil;

  // Beim Spieler eingetragene Schwierigkeit gilt vor angegebener.
  if ( mappingp(sinfo) && (d2=sinfo[SI_DIFFICULTY]) )
    diff=d2;

  // diff <-100 soll nicht hemmen und macht keinen Sinn
  diff=(diff<(-100))?(-100):diff;
  
  max=MAX_ABILITY-(diff+100)*(35-QueryProp(P_LEVEL));

// diff|lvl 1:|   3:|           7:| 10:| 13:| 16:| 19:| 22:| 25:| 28:| 31:| 34:|
// ----+------+-----+-----+----+----+----+----+----+----+----+----+----+
//  -50|   83%|  84%|  86%| 87%| 89%| 90%| 92%| 93%| 95%| 96%| 98%| 99%|
//  -10|   69%|  72%|  74%| 77%| 80%| 82%| 85%| 88%| 91%| 93%| 96%| 99%|
//    0|   66%|  69%|  72%| 75%| 78%| 81%| 84%| 87%| 90%| 93%| 96%| 99%|
//   10|   62%|  65%|  69%| 72%| 75%| 79%| 82%| 85%| 89%| 92%| 95%| 98%|
//   20|   59%|  62%|  66%| 70%| 73%| 77%| 80%| 84%| 88%| 91%| 95%| 98%|
//   30|   55%|  59%|  63%| 67%| 71%| 75%| 79%| 83%| 87%| 90%| 94%| 98%|
//   40|   52%|  56%|  60%| 65%| 69%| 73%| 77%| 81%| 86%| 90%| 94%| 98%|
//   50|   49%|  53%|  58%| 62%| 67%| 71%| 76%| 80%| 85%| 89%| 94%| 98%|
//  100|   32%|  38%|  44%| 50%| 56%| 62%| 68%| 74%| 80%| 86%| 92%| 98%|
//  150|   15%|  22%|  30%| 37%| 45%| 52%| 60%| 67%| 75%| 82%| 90%| 97%|
//  200|   -2%|   7%|  16%| 25%| 34%| 43%| 52%| 61%| 70%| 79%| 88%| 97%|
//  250|  -19%|  -8%|           2%| 12%| 23%| 33%| 44%| 54%| 65%| 75%| 86%| 96%|
//  300|  -36%| -24%| -12%|  0%| 12%| 24%| 36%| 48%| 60%| 72%| 84%| 96%|
//  400|  -70%| -55%| -40%|-25%|-10%|  5%| 20%| 35%| 50%| 65%| 80%| 95%|
//  500| -104%| -86%| -68%|-50%|-32%|-14%|  4%| 22%| 40%| 58%| 76%| 94%|
//  600| -138%|-117%| -96%|-75%|-54%|-33%|-12%|  9%| 30%| 51%| 72%| 93%|

  if ( abil>max )
    abil=max;
  if ( abil>MAX_ABILITY
    ) abil=MAX_ABILITY;
  else if ( abil<-MAX_ABILITY )
    abil=-MAX_ABILITY;

  if ( old && !abil )
    abil=1;
  // Faehigkeiten sollen nicht durch die Begrenzung verschwinden

  if ( !mappingp(sinfo) )
    return abil;

  sinfo[SI_SKILLABILITY]=abil;

  return sinfo;
}

public varargs void ModifySkill	(	string	sname,
		mixed	val,
		int	diff,
		string	gilde
	)

Definiert in Zeile 509 der Datei skills.c.

Wird benutzt von FinalSetup(), set_weapon_skills() und StdSkill_Nightvision().

{ 
  mapping skills;
  mixed skill;

  if ( !stringp(sname) || !strlen(sname) )
    return;

  // internal_query_newskills() macht keine Kopie
  skills=internal_query_newskills(gilde);

  // Skill ermitteln, wenn nicht existiert, wird er angelegt.
  if (!skill=skills[sname]) {
      skill=([]); 
  }
  
  // Zur Sicherheit mal das Mapping kopieren, wer weiss, was der                
  // Aufrufende dieer Funktion selber spaeter damit noch macht.
  // ist ok, wenn val kein Mapping ist, dann macht deep_copy nix.
  val=deep_copy(val);

  // Skill und val normalisieren und vereinigen
  if ( mappingp(skill) )
  {
    if ( mappingp(val) )
      skill+=val;
    else
      skill[SI_SKILLABILITY]=val;
  }
  else
  {
    if ( mappingp(val) )
      skill=([SI_SKILLABILITY:skill])+val;
    else
      if (!diff)
                skill=([SI_SKILLABILITY:val]);
      else
                skill=([SI_SKILLABILITY:val,SI_DIFFICULTY:diff]);
  }

  // Lernen entsprechend SI_DIFFICULTY begrenzen.
  if(diff && !member(skill,SI_DIFFICULTY))
    skill[SI_DIFFICULTY]=diff;
  skill=LimitAbility(skill,diff || skill[SI_DIFFICULTY]);
  
  // schliesslich im Skillmapping vermerken. Im Normalfall ist der Skill jetzt
  // schon geaendert, nicht erst nach dem internal_set_newskills().
  skills[sname]=skill;

  // explizites Abspeichern fast ueberfluessig, weil wir oben eine Referenz
  // auf das Skillmapping gekriegt haben...
  // Aber es koennte sein, dass dies der erste Skill fuer diese Gilde ist,
  // dann ist es noetig. Zum anderen wird internal_set_newskills() nochmal
  // geloggt.
  internal_set_newskills(skills,gilde);
}

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

public varargs mapping QuerySkill	(	string	sname,
		string	gilde
	)

Definiert in Zeile 418 der Datei skills.c.

                                                              {
 
    if (!stringp(sname) || !strlen(sname))
                return 0;

    //Kopie zurueckliefern
    return(deep_copy(InternalQuerySkill(sname,gilde)));
}

public varargs int QuerySkillAbility	(	mixed	sname,
		mixed	argl
	)

Definiert in Zeile 428 der Datei skills.c.

Wird benutzt von set_weapon_skills().

{ mapping skill;
  string skill2;
  mixed val;

  if ( objectp(sname) && stringp(argl) )
    sname = argl;

  if ( !(skill=InternalQuerySkill(sname, 0)) )
    return 0;

  if ( !intp(val=skill[SI_SKILLABILITY]) )
    return deep_copy(val);

  if (skill2=skill[SI_INHERIT])
  {
    int val2;
    val2=QuerySkillAbility(skill2);
    val=(val*MAX_ABILITY+SMUL(val,val2))/(2*MAX_ABILITY);
  }

  return val;
}

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

nomask protected int security_check

(

)

Definiert in Zeile 38 der Datei skills.c.

{ object tp;

  if ( !objectp(tp=this_player())
      || tp!=this_interactive()
      || !interactive(tp)
      || !IS_ARCH(tp) )
    return 0;

  return 1;
}

public varargs int SetSpellFatigue	(	int	duration,
		string	key
	)

Speichert eine Spellfatigue von <duration> Sekunden fuer <key>.

<key> darf 0 sein und bezeichnet das globale Spellfatigue. Rueckgabewert: Ablaufzeit der gesetzten Sperre -1, wenn noch eine nicht-abgelaufene Sperre auf dem <key> lag. 0, wenn duration 0 ist.

Definiert in Zeile 713 der Datei skills.c.

Wird benutzt von SetSpellFatigue().

                                                             {
  // aktuelle Sperre abgelaufen?
  if (CheckSpellFatigue(key))
    return -1; // alte Sperre noch aktiv.

  duration += time();
  // 0 is OK for <key>, it is the key for global spell fatigues
  spell_fatigues[key] = duration;
  return duration;
}

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

public varargs mixed UseSkill	(	string	skill,
		mapping	args
	)

Definiert in Zeile 645 der Datei skills.c.

Wird benutzt von _query_max_weight(), Attack(), CannotSee(), DefendOther(), drink_alcohol(), InformDefend() und SpellDefend().

{ mapping sinfo;
  string gilde, func,skill2;
  mixed res;
  closure cl;
  
  if ( !skill ||
       QueryProp(P_GHOST))
    return 0;

  skill=capitalize(skill);
  // QuerySkill() liefert eine Kopie des Skillmappings
  if ( !(sinfo=QuerySkill(skill,0)) )
    return 0;

  if (args)
    sinfo+=args;

  if ( !closurep(cl=sinfo[SI_CLOSURE]) )
  {
    if ( !(func=sinfo[SI_SKILLFUNC])    // Keine Funktion angegeben?
        || !(gilde=QueryProp(P_GUILD))) // Keine Gilde angegeben?
    {
      // Dann Standard-Funktion nehmen, wenn es die nicht gibt, den
      // Ability-Wert zurueckliefern.
      if (!closurep(cl = symbol_function("StdSkill_"+skill,this_object())))
        cl=symbol_function("QuerySkillAbility",this_object());
    }
    else
    {
      // Sonst diese Funktion im Gildenobjekt aufrufen
      cl=symbol_function(func,GUILD_DIR+gilde);
    }

    sinfo[SI_CLOSURE]=cl;
    valid_setskills_override=1;
    ModifySkill(skill,([SI_CLOSURE:cl]),0,sinfo[SI_GUILD]);
    valid_setskills_override=0;
  }

  res=funcall(cl,this_object(),skill,sinfo);
  if ( (skill2=sinfo[SI_INHERIT]) && mappingp(res) )
    res=UseSkill(skill2,res); // Fuer Skills, die von anderen abhaengen

  return res;
}

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

public varargs int UseSpell	(	string	str,
		string	spell
	)

Definiert in Zeile 607 der Datei skills.c.

{ string gilde,sbook;
  mapping sinfo;
  closure cl;
  
  if ( !spell && !(spell=query_verb()) )
    return 0;

  spell=lower_case(spell);

  // QuerySkill() liefert eine Kopie des Skillmappings.
  if ( !(sinfo=QuerySkill(spell,0)) )
    return 0;

  sinfo[SI_SKILLARG]=str; // Argument eintragen

  if ( !closurep(cl=sinfo[SI_CLOSURE]) )
  {
    // Wenn ein Spellbook angegeben ist wird der Spell direkt ausgefuehrt
    if ( stringp(sbook=sinfo[SI_SPELLBOOK]) )
      cl=symbol_function("UseSpell",SPELLBOOK_DIR+sbook);

    // Wenn der Spieler in einer Gilde ist, so weiss diese, in welchem
    // Spellbook der Spell zu finden ist...
    else if ( (gilde=QueryProp(P_GUILD)) && 
      ( find_object(GUILD_DIR+gilde) || file_size(GUILD_DIR+gilde+".c")>-1))
      cl=symbol_function("UseSpell",GUILD_DIR+gilde);
    else
      cl=function int () {return 0;};

    sinfo[SI_CLOSURE]=cl;
    valid_setskills_override=1;
    ModifySkill(spell,([SI_CLOSURE:cl]),0,sinfo[SI_GUILD]);
    valid_setskills_override=0;
  }
  return funcall(cl,this_object(),spell,sinfo);
}

nomask private int valid_setskills

(

string

gilde

)

Definiert in Zeile 222 der Datei skills.c.

{ string fn;

  if ( !query_once_interactive(this_object()) )
    return 1; // Monster duerfen sich selber Skills setzen :)

  if ( QueryProp(P_TESTPLAYER) || IS_WIZARD(this_object()) )
      return 1; // Testspieler und Magier sind schutzlose Opfer ;-)

  if ( previous_object() )
  {
    if ( previous_object()==this_object()
        && this_interactive()==this_object() )
      return 1;

    fn=object_name(previous_object());
    if ( fn[0..7]=="/gilden/"
        || fn[0..11]=="/spellbooks/"
        || fn[0..7]=="/secure/"
        || fn[0..11]=="/p/zauberer/" )
      return 1; // Die sollten problemlos aendern duerfen

    if ( file_size("/gilden/access_rights")>0
       && call_other("/gilden/access_rights",
                    "access_rights",
                    getuid(previous_object()),
                    gilde+".c"))
      return 1; // Setzendes Objekt kommt vom Gildenprogrammierer

    if ( file_size("/gilden/"+gilde+".c")>0
        && call_other("/gilden/"+gilde,
                      "valid_setskills",
                        explode(fn,"#")[0]) )
      return 1; // Die Gilde selber kann Ausnahmen zulassen
  }

  if (valid_setskills_override)
  {
    valid_setskills_override=0;
    return 1; // Fuers Setzen der Closure
  }

  if ( this_interactive() )
  {
    if ( IS_ARCH(this_interactive()) )
      return 1; // Erzmagier duerfen immer aendern

    if ( call_other("/gilden/access_rights",
                    "access_rights",
                    getuid(this_interactive()),
                    gilde+".c"))
      return 1;  // Der Gildenprogrammierer selber auch
  }

  // Fuer die Waffenskills, die sollen sich selbst auch setzen duerfen
  if (!this_interactive() && this_object()==previous_object())
                  return 1;
  
  
  log_file("SETSKILLS",sprintf("*****\n%s PO:%O->TO:%O TI:%O\n GUILD:%s VERB_ARGS:'%s'\n",
            ctime(time())[4..15],
            previous_object(),
            this_object(),
            this_interactive(),
            gilde,
            ( this_interactive() ? query_verb() + " " +
                this_interactive()->_unparsed_args() : "") ));

  return 0;
}

---

Variablen-Dokumentation

private mapping spell_fatigues = ([])

Definiert in Zeile 26 der Datei skills.c.

inherit std living std_skills

Definiert in Zeile 12 der Datei skills.c.

private nosave int valid_setskills_override

Definiert in Zeile 219 der Datei skills.c.