attributes.c-Dateireferenz

#include <sys_debug.h>
#include <thing/properties.h>
#include <attributes.h>
#include <config.h>

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
Funktionen
nomask public int	SetTimedAttrModifier (string key, mapping modifier, int outdated, object dependent, mixed notify)
nomask public mapping	QueryTimedAttrModifier (string key)
nomask public int	DeleteTimedAttrModifier (string key)
nomask protected void	attribute_hb ()
nomask protected void	notifyExpiredModifiers (mapping nots)
nomask protected void	notifyInvalidModifiers ()
protected nomask void	calculate_valid_modifiers ()
nomask public void	deregister_modifier (object modifier)
nomask public void	register_modifier (object modifier)
protected void	add_offsets (mapping arr)
public void	UpdateAttributes ()
protected void	create ()
static mixed	_query_timed_attr_mod ()
static mapping	_set_attributes (mapping arr)
static mapping	_query_attributes ()
static mapping	_set_attributes_offsets (mapping arr)
static mapping	_query_attributes_offsets ()
static mixed	_set_attributes_modifier (mixed arr)
static mapping	_query_attributes_modifier ()
public int	SetAttr (string attr, int val)
public int	SetAttribute (string attr, int val)
public int	QueryAttribute (string attr)
public int	QueryRealAttribute (string attr)
public int	SetRealAttribute (string attr, int val)
public int	QueryAttributeOffset (string attr)
public status	TestLimitViolation (mapping check)
protected int	_filterattr_str (int val)
protected int	_filterattr_dex (int val)
protected int	_filterattr_int (int val)
protected int	_filterattr_con (int val)
Variablen
mapping	attributes
mapping	attributes_modifier
nosave mixed *	attributes_timed_mods
nosave mapping	attributes_offsets
nosave mapping	used_attributes_offsets
nosave object *	all_modifiers
nosave object *	invalid_modifiers
nosave int	cumulative_mod
nosave int	hp_off
nosave int	sp_off

---

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 31 der Datei attributes.c.

---

Dokumentation der Funktionen

protected int _filterattr_con

(

int

val

)

Definiert in Zeile 661 der Datei attributes.c.

{
  return ( (val<0) ? 0 : (val>20) ? 20 : val );
}

protected int _filterattr_dex

(

int

val

)

Definiert in Zeile 651 der Datei attributes.c.

{
  return ( (val<0) ? 0 : (val>20) ? 20 : val );
}

protected int _filterattr_int

(

int

val

)

Definiert in Zeile 656 der Datei attributes.c.

{
  return ( (val<0) ? 0 : (val>20) ? 20 : val );
}

protected int _filterattr_str

(

int

val

)

Definiert in Zeile 646 der Datei attributes.c.

{
  return ( (val<0) ? 0 : (val>20) ? 20 : val );
}

static mapping _query_attributes

(

)

[static]

Definiert in Zeile 516 der Datei attributes.c.

{
  return deep_copy(Set(P_ATTRIBUTES, attributes)); 
}

static mapping _query_attributes_modifier

(

)

[static]

Definiert in Zeile 568 der Datei attributes.c.

{
  return deep_copy(attributes_modifier);  
}

static mapping _query_attributes_offsets

(

)

[static]

Definiert in Zeile 528 der Datei attributes.c.

{ 
  return deep_copy(Set(P_ATTRIBUTES_OFFSETS, attributes_offsets));
}

static mixed _query_timed_attr_mod

(

)

[static]

Definiert in Zeile 501 der Datei attributes.c.

                                     {
  mixed ret;
  return Set(P_TIMED_ATTR_MOD,      
      ({attributes_timed_mods[0],
                deep_copy(attributes_timed_mods[1]),
                deep_copy(attributes_timed_mods[2])}));
}

static mapping _set_attributes

(

mapping

arr

)

[static]

Definiert in Zeile 509 der Datei attributes.c.

{
  Set(P_ATTRIBUTES, attributes=arr);
  UpdateAttributes();
  return arr;
}

static mixed _set_attributes_modifier

(

mixed

arr

)

[static]

Definiert in Zeile 533 der Datei attributes.c.

{ string fn;
  mixed pre;
  mapping map_ldfied;
  
  if ( pointerp(arr) && (sizeof(arr)>=2) )
  {
    pre=arr[0];
    map_ldfied=arr[1];
  }
  else 
  {
    pre=previous_object();
    map_ldfied=arr;
  }

  if ( objectp(pre) )
    fn=old_explode(object_name(pre),"#")[0];
  else
    fn=pre;

  if ( !stringp(fn) )
    return 0;

  // wenn Modifier kein mapping oder ein leeres Mapping: loeschen
  if ( !mappingp(map_ldfied) || !sizeof(map_ldfied))
    efun::m_delete(attributes_modifier,fn);
  else
    attributes_modifier[fn]=map_ldfied;

  Set(P_ATTRIBUTES_MODIFIER, attributes_modifier);
  UpdateAttributes();
  return attributes_modifier[fn];
}

static mapping _set_attributes_offsets

(

mapping

arr

)

[static]

Definiert in Zeile 521 der Datei attributes.c.

{
  Set(P_ATTRIBUTES_OFFSETS, attributes_offsets=arr);
  UpdateAttributes();
  return attributes_offsets;
}

protected void add_offsets

(

mapping

arr

)

Definiert in Zeile 435 der Datei attributes.c.

Wird benutzt von calculate_valid_modifiers().

                                        {
  mixed *ind;
  int i;
  
  if ( !mappingp(arr) )
    return;

  foreach(string key, int wert: arr) {
    used_attributes_offsets[key]+=wert;
  }
}

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

nomask protected void attribute_hb

(

)

Definiert in Zeile 149 der Datei attributes.c.

Wird benutzt von heart_beat().

{
  int now,i,k,update,outdated;
  string* keys;
  mapping tonotify;
                
  // initialize
  now=time();
  tonotify=([]);

  keys=m_indices(attributes_timed_mods[TATTR_ENTRIES]);
  
  // delete outdated 
  for(i=sizeof(attributes_timed_mods[TATTR_OUTDATE])-1;i>=0;i--)
  {
                outdated=attributes_timed_mods[TATTR_OUTDATE][i];
                if(outdated>now)
                {
                  break;
                }
                
                for(k=sizeof(keys)-1;k>=0;k--)
                {
                  if(attributes_timed_mods[TATTR_ENTRIES][keys[k],TATTR_OUTDATED]==outdated)
                  {
                    // bei fehlendem notifier wurde das zum verhaengnis
                    // dank an gloinson
                    /*
                    if(objectp(attributes_timed_mods[TATTR_ENTRIES][keys[k],TATTR_NOTIFY]))
                    {
                    */
                    tonotify+=([keys[k]:attributes_timed_mods[TATTR_ENTRIES][keys[k],TATTR_NOTIFY]]);
                    //}
                    
                    attributes_timed_mods[TATTR_DEPENDENTS]-=([keys[k]]);
                    attributes_timed_mods[TATTR_ENTRIES]-=([keys[k]]);
                    keys-=({keys[k]});
                  }
                }
                
                attributes_timed_mods[TATTR_OUTDATE]-=({outdated});
  }
  
  // delete depending
  keys=m_indices(attributes_timed_mods[TATTR_DEPENDENTS]);
  for(i=sizeof(keys)-1;i>=0;i--)
  {
                if(!objectp(attributes_timed_mods[TATTR_DEPENDENTS][keys[i]]))
                {
                    // siehe oben
                    /*
                    if(objectp(attributes_timed_mods[TATTR_ENTRIES][keys[i],TATTR_NOTIFY]))
                    {
                    */
                    tonotify+=([keys[i]:attributes_timed_mods[TATTR_ENTRIES][keys[i],TATTR_NOTIFY]]);
                    //}

                    attributes_timed_mods[TATTR_DEPENDENTS]-=([keys[i]]);
                    attributes_timed_mods[TATTR_ENTRIES]-=([keys[i]]);
                    keys-=({keys[i]});
                }
  }
  
  
  // update
  if(sizeof(tonotify))
  {
    UpdateAttributes();
    call_out(#'notifyExpiredModifiers,0,tonotify);
  }
}

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

protected nomask void calculate_valid_modifiers

(

)

Definiert in Zeile 259 der Datei attributes.c.

Benutzt add_offsets(), all_modifiers, attributes_offsets, call_out(), CUMULATIVE_ATTR_LIMIT, cumulative_mod, hp_off, invalid_modifiers, ob(), P_HP, P_M_ATTR_MOD, P_M_HEALTH_MOD, P_SP, P_WIELDED, P_WORN, P_X_ATTR_MOD, P_X_HEALTH_MOD, qp, sp_off und used_attributes_offsets.

                                                  {
  closure qp;
  mapping res;  
  string key;   
  int wert;
  // Unterscheidung Bonus <-> Malus, weil der Malus voll eingehen soll          
  int hp_malus, sp_malus;
 
  used_attributes_offsets=([]);
  cumulative_mod=0;
  hp_off=sp_off=0;
  invalid_modifiers=({});

  // rassenspezifische boni P_ATTRIBUTES_OFFSETS  
  if ( mappingp(attributes_offsets) )
    used_attributes_offsets+=attributes_offsets;

  if (!pointerp(all_modifiers) || !sizeof(all_modifiers)) {
    // in diesem Fall koennen wir hier direkt mit dieser Funktion Schluss
    // machen. ;-)
    return;
  }
  else
    all_modifiers-=({0}); //zerstoerte Objekte rauswerfen.
    
  // einmal ueber alle modifizierenden Objekt iterieren und aufaddieren
  foreach(object ob: all_modifiers) {
    qp = symbol_function("QueryProp",ob);
 
    if (!objectp(ob) || environment(ob)!=this_object()) {
      all_modifiers-=({ob});
      continue;
    }
                                
    // ext. Attribut-Modifier
    if ( mappingp(res=funcall(qp,P_X_ATTR_MOD)) ) {                             
      foreach(key, wert: res) {
        cumulative_mod+=wert;
      }
    }

    // magic Attribut-Modifier
    if ( mappingp(res=funcall(qp,P_M_ATTR_MOD))
        && ( funcall(qp,P_WORN)
            || funcall(qp,P_WIELDED) ) ) {                      
      foreach(key, wert: res) {
        cumulative_mod+=wert;
      }
    }
    // Magic Health-Modifier                    
    if ( mappingp(res=funcall(qp,P_M_HEALTH_MOD))
        && ( funcall(qp,P_WORN)
            || funcall(qp,P_WIELDED) ) ) {
      if (res[P_HP] < 0)
        hp_malus += res[P_HP];
      else
        hp_off+=res[P_HP];

      if (res[P_SP] < 0)
        sp_malus += res[P_SP];
      else
        sp_off+=res[P_SP];
      }
                      
    // external Health Modifier
    if ( mappingp(res=funcall(qp,P_X_HEALTH_MOD)) ) {
      if (res[P_HP] < 0)
        hp_malus += res[P_HP];
      else
        hp_off+=res[P_HP];

      if (res[P_SP] < 0)
        sp_malus += res[P_SP];
      else
        sp_off+=res[P_SP];          
    }           
  
  } // Ende 1. foreach()
  
 
  // und nochmal, soviele Objekt wieder rausschmeissen, bis das Limit wieder
  // unterschritten wird. (Verbesserungsvorschlaege erwuenscht.) :-(
  foreach(object ob: all_modifiers) {

    qp = symbol_function("QueryProp",ob);
 
    if ( mappingp(res=funcall(qp,P_X_ATTR_MOD)) ) {
      if(cumulative_mod>CUMULATIVE_ATTR_LIMIT) { 
        invalid_modifiers+=({ob});                
                foreach(key, wert: res) {
          cumulative_mod-=wert;
        }
      }
      else {
        add_offsets(res);
      }
    }

    if ( mappingp(res=funcall(qp,P_M_ATTR_MOD))
        && ( funcall(qp,P_WORN)
            || funcall(qp,P_WIELDED) ) ) {
      if(cumulative_mod>CUMULATIVE_ATTR_LIMIT) {     
        if(member(invalid_modifiers,ob)==-1) {
          invalid_modifiers+=({ob});
        }                                       
                foreach(key, wert: res) {
          cumulative_mod-=wert;
        }
      }
      else {
        add_offsets(res);
      }
    }
  }

  // HEALTH_MOD werden durch eine Formel 'entschaerft', damit man nur schwer
  // das Maximum von 150 erreichen kann. (Formel von Humni, beschlossen auf 3.
  // EM-Treffen)
  // Mali gehen aber voll ein
  hp_off = (int)(150 - (150*150.0/(150 + hp_off))) + hp_malus;
  sp_off = (int)(150 - (150*150.0/(150 + sp_off))) + sp_malus;

  /* alte Version
    hp_off += hp_malus;
    sp_off += sp_malus;
  */
 
  // notify invalid modifiers
  if(sizeof(invalid_modifiers)>0) {
    call_out(#'notifyInvalidModifiers,0);
  }
}

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

protected void create

(

)

Definiert in Zeile 484 der Datei attributes.c.

                        {
  hp_off=sp_off=0;
  used_attributes_offsets=([]);
  all_modifiers=({});
  invalid_modifiers=({});
  cumulative_mod=0;
  
  Set(P_ATTRIBUTES_MODIFIER, attributes_modifier=([])); // nicht geschuetzt
  Set(P_ATTRIBUTES_OFFSETS, attributes_offsets=([]));
  Set(P_ATTRIBUTES_OFFSETS, PROTECTED, F_MODE);
  Set(P_ATTRIBUTES, attributes=([]));
  Set(P_ATTRIBUTES, PROTECTED, F_MODE);

  Set(P_TIMED_ATTR_MOD, attributes_timed_mods=({ ({}),([]),([]) }));
  Set(P_TIMED_ATTR_MOD, NOSETMETHOD|SECURED, F_MODE_AS);
}

nomask public int DeleteTimedAttrModifier

(

string

key

)

Definiert in Zeile 130 der Datei attributes.c.

{
  if(!key || key=="")
  {
    return TATTR_INVALID_ARGS;
  }

  if(!member(attributes_timed_mods[TATTR_ENTRIES],key))
  { 
    return TATTR_NO_SUCH_MODIFIER;
  }
  
  attributes_timed_mods[TATTR_DEPENDENTS]-=([key]);
  attributes_timed_mods[TATTR_ENTRIES]-=([key]);
  UpdateAttributes();
  
  return TATTR_OK;
}

nomask public void deregister_modifier

(

object

modifier

)

Definiert in Zeile 393 der Datei attributes.c.

Wird benutzt von RemoveSensitiveObject().

{ 
  if (!pointerp(all_modifiers)) {
    return;
  }

  // valid object?
  if (!objectp(modifier) || member(all_modifiers,modifier)==-1) {
    return;
  }
  
  all_modifiers-=({modifier});
  if (invalid_modifiers) {
    invalid_modifiers-=({modifier});
  }
}

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

nomask protected void notifyExpiredModifiers

(

mapping

nots

)

Definiert in Zeile 221 der Datei attributes.c.

Benutzt i und keys.

{
  int i;
  string* keys;
  while(remove_call_out(#'notifyExpiredModifiers)!=-1);
  
  if(!nots)
  {
    return;
  }
  
  keys=m_indices(nots);
  for(i=sizeof(nots)-1;i>=0;i--)
  {
                if(nots[keys[i]] && 
                    ( objectp(nots[keys[i]])||stringp(nots[keys[i]]) ) )
                {
                   call_other(nots[keys[i]],"NotifyTimedAttrModExpired",keys[i]);
                }
  }
}

nomask protected void notifyInvalidModifiers

(

)

Definiert in Zeile 245 der Datei attributes.c.

Benutzt invalid_modifiers.

                                               {

  while(remove_call_out(#'notifyInvalidModifiers)!=-1);
  
  if(!invalid_modifiers) {
    invalid_modifiers=({});
  }
  
  call_other(invalid_modifiers,"NotifyXMAttrModLimitViolation");

}

public int QueryAttribute

(

string

attr

)

Definiert in Zeile 589 der Datei attributes.c.

Wird benutzt von _query_max_weight(), _query_total_ac(), _query_total_wc(), Attack(), Pacify(), ShortRangeSkill(), StdSkill_Bihand(), StdSkill_Fight_hands() und StdSkill_Fight_sword().

{ int re;

  re=attributes[attr]+used_attributes_offsets[attr];

  if ( query_once_interactive(this_object()) && (re>30) )
    re=30;

  return re;
}

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

public int QueryAttributeOffset

(

string

attr

)

Definiert in Zeile 610 der Datei attributes.c.

{
  return used_attributes_offsets[attr];
}

public int QueryRealAttribute

(

string

attr

)

Definiert in Zeile 600 der Datei attributes.c.

Wird benutzt von ask_question(), raise(), score() und SelectWhich().

{
  return attributes[attr];
}

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

nomask public mapping QueryTimedAttrModifier

(

string

key

)

Definiert in Zeile 105 der Datei attributes.c.

{
  int outdated;
  object dependent;
  mixed notify;
  mapping mod;
  
  if(!key || key=="")
  {
    return ([]);
  }

  if(!member(attributes_timed_mods[TATTR_ENTRIES],key))
  { 
    return ([]);
  }

  mod=deep_copy(attributes_timed_mods[TATTR_ENTRIES][key,TATTR_MOD]);
  outdated=attributes_timed_mods[TATTR_ENTRIES][key,TATTR_OUTDATED];
  dependent=attributes_timed_mods[TATTR_ENTRIES][key,TATTR_DEPENDENT];
  notify=attributes_timed_mods[TATTR_ENTRIES][key,TATTR_NOTIFY];
  
  return ([key:mod;outdated;dependent;notify ]);
}

nomask public void register_modifier

(

object

modifier

)

Definiert in Zeile 411 der Datei attributes.c.

Wird benutzt von InsertSensitiveObject().

                                                      { 
  closure qp;
  
  if (!pointerp(all_modifiers)) {
    all_modifiers=({});
  }

  // valid object?
  if (!objectp(modifier) || environment(modifier)!=this_object() || 
      member(all_modifiers,modifier)!=-1) {
    return;
  }
  
  qp = symbol_function("QueryProp",modifier);
  // modifier after all? Die P_M_* muessen getragen/gezueckt sein.
  if(mappingp(funcall(qp,P_X_ATTR_MOD)) ||
     mappingp(funcall(qp,P_X_HEALTH_MOD)) ||
    ((mappingp(funcall(qp,P_M_ATTR_MOD)) ||
       mappingp(funcall(qp,P_M_HEALTH_MOD))) &&
      (funcall(qp,P_WORN) || funcall(qp,P_WIELDED)) ) ) {
    all_modifiers+=({modifier});
  }
}

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

public int SetAttr	(	string	attr,
		int	val
	)

Definiert in Zeile 573 der Datei attributes.c.

Wird benutzt von _set_level().

{ closure filter_ldfied;

  if ( filter_ldfied = symbol_function("_filterattr_"+attr, this_object()) ) 
    val = funcall(filter_ldfied, val );

  attributes[attr] = val;
  UpdateAttributes();
}

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

public int SetAttribute	(	string	attr,
		int	val
	)

Definiert in Zeile 583 der Datei attributes.c.

{
  return SetAttr(attr, val-used_attributes_offsets[attr]);
}

public int SetRealAttribute	(	string	attr,
		int	val
	)

Definiert in Zeile 605 der Datei attributes.c.

Wird benutzt von raise().

{
  return SetAttr(attr, val);
}

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

nomask public int SetTimedAttrModifier	(	string	key,
		mapping	modifier,
		int	outdated,
		object	dependent,
		mixed	notify
	)

Definiert in Zeile 51 der Datei attributes.c.

Benutzt attributes_timed_mods, TATTR_DEPENDENT, TATTR_ENTRIES, TATTR_INVALID_ARGS, TATTR_MOD, TATTR_NOTIFY, TATTR_OUTDATE und TATTR_OUTDATED.

                                                  {
  if(!key || key=="" || !modifier || (outdated>0 && outdated<time()) || 
      (notify && !stringp(notify) && !objectp(notify)) ) {
    return TATTR_INVALID_ARGS;
  }
  
  
  if(member(attributes_timed_mods[TATTR_ENTRIES],key)) {
    // change entry
    attributes_timed_mods[TATTR_ENTRIES][key,TATTR_MOD]=modifier;
    attributes_timed_mods[TATTR_ENTRIES][key,TATTR_OUTDATED]=outdated;
    attributes_timed_mods[TATTR_ENTRIES][key,TATTR_DEPENDENT]=dependent;
    attributes_timed_mods[TATTR_ENTRIES][key,TATTR_NOTIFY]=notify;
  }
  else {
    // add entry
    attributes_timed_mods[TATTR_ENTRIES]+=([key:modifier;outdated;dependent;notify]);
  }
  
  // add outdate
  if(outdated>0 && member(attributes_timed_mods[TATTR_OUTDATE],outdated)==-1)
  {
    attributes_timed_mods[TATTR_OUTDATE]+=({outdated});
    attributes_timed_mods[TATTR_OUTDATE]=
      sort_array(attributes_timed_mods[TATTR_OUTDATE],#'<);
  }
  
  // add dependent
  if(objectp(dependent))
  {
                if(member(attributes_timed_mods[TATTR_DEPENDENTS],key))
                {
                  attributes_timed_mods[TATTR_DEPENDENTS][key]=dependent;
                }
                else
                {
          attributes_timed_mods[TATTR_DEPENDENTS]+=([key:dependent]);
                }
  }
  else
  {
                // remove previously set dependent
                if(member(attributes_timed_mods[TATTR_DEPENDENTS],key))
                {
                  attributes_timed_mods[TATTR_DEPENDENTS]-=([key]);
                }
  }
  
  UpdateAttributes();

  return TATTR_OK;
}

public status TestLimitViolation

(

mapping

check

)

Definiert in Zeile 615 der Datei attributes.c.

{
  int k,test;
  mixed* ind;
    
  if(!check || !mappingp(check))
  {
    return 0;
  }

  test=0;
  ind=m_indices(check);
  for( k=sizeof(ind)-1 ; k>=0 ; k-- )
  {
    test+=check[ind[k]];
  }
  
  test+=cumulative_mod;
  if(test>CUMULATIVE_ATTR_LIMIT)
  {
    return 1;
  }
  
  return 0;
}

public void UpdateAttributes

(

)

Definiert in Zeile 447 der Datei attributes.c.

Wird benutzt von InsertSensitiveObject().

                               {
  mixed   *ind;
  int     i;
  
  // alle gueltigen Modifier ermitteln aus Objekten im Inventar.
  calculate_valid_modifiers();

  // persistente modifier drauf (frosch zb)
  // aus P_ATTRIBUTES_MODIFIERS
  if ( mappingp(attributes_modifier) ) {
    foreach(mixed key, mapping wert: attributes_modifier) {
      add_offsets(wert); // Modifier addieren...                                
    }
  }
  // timed modifier drauf aus P_TIMED_ATTR_MOD
  ind=m_indices(attributes_timed_mods[TATTR_ENTRIES]);
  for ( i=sizeof(ind)-1 ; i>=0 ; i-- ) {
    // Modifier addieren...
    add_offsets(attributes_timed_mods[TATTR_ENTRIES][ind[i],0]);
  }
  // Bei Monstern werden die HP/SP ueblicherweise selbst gesetzt
  if ( !query_once_interactive(this_object()))
    return;

  SetProp(P_MAX_HP, ((int)QueryAttribute(A_CON))*8+42+hp_off);
  SetProp(P_MAX_SP, ((int)QueryAttribute(A_INT))*8+42+sp_off);
  
  if(QueryProp(P_HP)>QueryProp(P_MAX_HP)) {
    SetProp(P_HP,QueryProp(P_MAX_HP));
  }
  
  if(QueryProp(P_SP)>QueryProp(P_MAX_SP)) {
    SetProp(P_SP,QueryProp(P_MAX_SP));
  }
}

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

---

Variablen-Dokumentation

nosave object* all_modifiers

Definiert in Zeile 44 der Datei attributes.c.

Wird benutzt von calculate_valid_modifiers().

mapping attributes

Definiert in Zeile 39 der Datei attributes.c.

mapping attributes_modifier

Definiert in Zeile 40 der Datei attributes.c.

nosave mapping attributes_offsets

Definiert in Zeile 42 der Datei attributes.c.

Wird benutzt von calculate_valid_modifiers().

nosave mixed* attributes_timed_mods

Definiert in Zeile 41 der Datei attributes.c.

Wird benutzt von SetTimedAttrModifier().

nosave int cumulative_mod

Definiert in Zeile 46 der Datei attributes.c.

Wird benutzt von calculate_valid_modifiers().

nosave int hp_off

Definiert in Zeile 47 der Datei attributes.c.

Wird benutzt von calculate_valid_modifiers().

nosave object* invalid_modifiers

Definiert in Zeile 45 der Datei attributes.c.

Wird benutzt von calculate_valid_modifiers() und notifyInvalidModifiers().

nosave int sp_off

Definiert in Zeile 48 der Datei attributes.c.

Wird benutzt von calculate_valid_modifiers().

nosave mapping used_attributes_offsets

Definiert in Zeile 43 der Datei attributes.c.

Wird benutzt von calculate_valid_modifiers() und create().