skill_attributes.c-Dateireferenz

#include <living/skill_attributes.h>
#include <player/life.h>
#include <thing/properties.h>
#include <defines.h>

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
#define	ZDEBUG(x)
Funktionen
protected void	create ()
mapping	_set_skill_attr (mapping sa)
mapping	_query_skill_attr ()
private void	UpdateSACache (string *attrs)
private int	InternalModifySkillAttribute (object caster, string atrname, mixed value, int duration)
public int	ModifySkillAttribute (string atrname, mixed value, int duration)
public int	RemoveSkillAttributeModifier (object caster, string attrname)
public int	QuerySkillAttribute (string atrname)
public varargs mapping	QuerySkillAttributeModifier (object caster, string *attrnames)
public varargs int	ModifySkillAttributeOld (object caster, string atrname, int value, int duration, mixed fun)
Variablen
inherit std util	executer
private nosave mapping	skillattrs

---

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 14 der Datei skill_attributes.c.

#define ZDEBUG

(

x

)

Definiert in Zeile 24 der Datei skill_attributes.c.

---

Dokumentation der Funktionen

mapping _query_skill_attr

(

)

Definiert in Zeile 49 der Datei skill_attributes.c.

Benutzt skillattrs.

                            {
  return deep_copy(skillattrs);

//TODO: Evtl. ext. Setzen von P_SKILL_ATTRIBUTE_OFFSETS mitloggen?
}

mapping _set_skill_attr

(

mapping

sa

)

Definiert in Zeile 45 der Datei skill_attributes.c.

Benutzt skillattrs.

                                    {
  return deep_copy(skillattrs);
}

protected void create

(

)

Definiert in Zeile 40 der Datei skill_attributes.c.

Benutzt F_MODE_AS, P_SKILL_ATTRIBUTES, SECURED und Set().

                        {
  Set(P_SKILL_ATTRIBUTES, SECURED, F_MODE_AS);
}

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

private int InternalModifySkillAttribute	(	object	caster,
		string	atrname,
		mixed	value,
		int	duration
	)

Definiert in Zeile 112 der Datei skill_attributes.c.

Benutzt m_delete(), ME, SA_MOD_INVALID_ATTR, SA_MOD_INVALID_OBJECT, SA_MOD_INVALID_VALUE, SA_MOD_OK, SA_MOD_TOO_BIG, SA_MOD_TOO_SMALL, SA_TOO_MANY_MODS, SAM_CACHE, SAM_COUNT, SAM_DYNAMIC, SAM_MAX_MODS, SAM_STATIC, SASTATD, skillattrs, strftime(), UpdateSACache(), VALID_SKILL_ATTRIBUTES, ZDEBUG und zeit.

Wird benutzt von ModifySkillAttribute() und ModifySkillAttributeOld().

                                                           {
  int zeit = utime()[1];
  int ticks = get_eval_cost();

  // nur existierende SAs...
  if (!stringp(atrname)
      || member(VALID_SKILL_ATTRIBUTES, atrname) == -1)
    return SA_MOD_INVALID_ATTR;

  if (!objectp(caster)) return SA_MOD_INVALID_OBJECT;

  if (!mappingp(skillattrs)) skillattrs=m_allocate(1,3);
  
  if (!member(skillattrs, atrname)) {
    skillattrs[atrname,SAM_CACHE] = ({0, 0, 0});
    // die meisten Mods sind statisch, daher auf Verdacht hier fuer einen
    // Eintrag Platz reservieren, aber nicht fuer den dyn. Teil.
    skillattrs[atrname,SAM_STATIC] = m_allocate(1,2);
    skillattrs[atrname,SAM_DYNAMIC] = m_allocate(0,2);
  }
  // pruefen, ob Maximalzahl an Eintraegen drin ist
  else if (skillattrs[atrname,SAM_CACHE][SAM_COUNT] >= SAM_MAX_MODS) {
    // letzte Chance: destructete Objekte drin?
    skillattrs[atrname,SAM_CACHE][SAM_COUNT] = 
      sizeof(skillattrs[atrname,SAM_STATIC])
    +sizeof(skillattrs[atrname,SAM_DYNAMIC]);
    // es kann sein, dass noch abgelaufene Objekte drinstehen,
    // aber die Pruefung ist mir gerade zu teuer. TODO
    // nochmal gucken (rest vom cache wird ggf. unten geprueft.)
    if (skillattrs[atrname,SAM_CACHE][SAM_COUNT] >= SAM_MAX_MODS)
      return SA_TOO_MANY_MODS; // dann nicht.
  }

  // Dauer darf nur ein int sein.
  if (!intp(duration))
    raise_error(sprintf("Wrong argument 3 to ModifySkillAttribute: "
    "expected 'int', got %.10O\n", duration));
  // Zeitstempel ermitteln
  duration += time();

  // statischer oder dyn. Modifier?
  if (intp(value)) {
    // Mod darf nicht zu gross oder zu klein sein. TODO: Grenzen?
    if (value < -1000)
      return SA_MOD_TOO_SMALL;
    else if (value > 1000)
      return SA_MOD_TOO_BIG;
    else if (!value)
      return SA_MOD_INVALID_VALUE; 
    // jedes Objekt darf nur einen mod haben. Wenn dieses schon einen dyn.
    // hat, muss der geloescht werden (stat. werden ja eh ersetzt).
    if (member(skillattrs[atrname,SAM_DYNAMIC], caster))
      efun::m_delete(skillattrs[atrname,SAM_DYNAMIC], caster);
    // sonst eintragen
    skillattrs[atrname, SAM_STATIC] += ([caster: value; duration]);
  }
  else if (closurep(value)) {
    // nur ein Mod pro Objekt, s.o.
    if (member(skillattrs[atrname,SAM_STATIC], caster))
      efun::m_delete(skillattrs[atrname,SAM_STATIC], caster);
    // direkt ohne weitere Pruefung eintragen
    skillattrs[atrname, SAM_DYNAMIC] += ([caster: value; duration]);
  }
  else
    raise_error(sprintf("Wrong argument 2 to ModifySkillAttribute(): "
    "expected 'int' or 'closure', got %.10O\n",value));

#ifdef SASETLOG
  if (query_once_interactive(this_object()))
    SASETLOG(sprintf("%s: %O, %s, %O, %O\n", 
        strftime("%y%m%d-%H%M%S"), this_object(), atrname, caster, value));
#endif
#ifdef SASTATD
  object daemon;
  if (query_once_interactive(ME)
      && objectp(daemon=find_object(SASTATD)))
    daemon->LogModifier(caster, atrname, value, duration);
#endif
  // noch den Cache fuer dieses SA neu berechnen
  // TODO: Cache nur invalidieren, damit er erst bei der naechsten Abfrage
  // aktualisiert wird. Spart Zeit, wenn bis dahin mehrere Mods
  // entfernt/addiert werden. Dafuer ist die gecache Anzahl an Mods
  // inkonsistent.
  UpdateSACache( ({atrname}) );

  ZDEBUG(sprintf("MSA: %O, Zeit: %d, Ticks: %d\n",
                this_object(),
                utime()[1]-zeit, ticks-get_eval_cost()));

  return SA_MOD_OK;
}

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

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

public int ModifySkillAttribute	(	string	atrname,
		mixed	value,
		int	duration
	)

Definiert in Zeile 205 der Datei skill_attributes.c.

Benutzt InternalModifySkillAttribute() und ME.

                                                  {
  return InternalModifySkillAttribute(
      (extern_call()?previous_object():ME), atrname, value, duration);
}

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

public varargs int ModifySkillAttributeOld	(	object	caster,
		string	atrname,
		int	value,
		int	duration,
		mixed	fun
	)

Definiert in Zeile 358 der Datei skill_attributes.c.

Benutzt InternalModifySkillAttribute() und ME.

                                                              {
  int res;
  // Caller ermitteln
  if (extern_call()) caster=previous_object();
  else caster=ME;

  // Closures koennen via ModifySkillAttributeOld() nicht mehr gesetzt werden,
  // da deren Rueckgabewert nicht sinnvoll umgerechnet werden koennen. (Man
  // weiss nicht, ob es eine neue oder alte Closure ist.)
  if (pointerp(fun) || closurep(fun))
      raise_error(sprintf("Closures for SA modifiers can't be set by "
      "ModifySkillAttributeOld()! Use ModifySkillAttribute()!\n"));
  
  res = InternalModifySkillAttribute(caster, atrname, value-100, duration);
  // die alte funktion hatte nur 0 fuer ungueltigen Wert und < 0 fuer zu
  // kleines Level als Rueckgabewert. Zu kleines Level gibt nicht mehr, also
  // bleibt nur 0 als Sammel-Fehlercode uebrig. *seufz*
  if (res < 0) return 0;
  return res;
}

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

public int QuerySkillAttribute

(

string

atrname

)

Definiert in Zeile 235 der Datei skill_attributes.c.

Benutzt cl, death_suffering(), m_delete(), ME, ob(), P_SKILL_ATTRIBUTE_OFFSETS, Query(), SA_QUALITY, SAM_CACHE, SAM_CACHE_TIMEOUT, SAM_COUNT, SAM_DYNAMIC, SAM_STATIC, SAM_SUM, skillattrs und UpdateSACache().

Wird benutzt von heart_beat(), LongRangeSkill(), StdSkill_Bihand(), StdSkill_Fight_hands() und StdSkill_Fight_sword().

{
  mixed offsets, attr;
  int modsumme, qual, ret, cval;

  if (!stringp(atrname)) // VALID_SKILL_ATTRIBUTES beruecksichtigen?
    return 100;

  // wenn nicht SA_QUALITY gefragt ist, erstmal jenes ermitteln, weil es den
  // ersten Modifier auf alle anderen SAs darstellt. Sonst den Startwert fuer
  // SA_QUALITY (100) modifiziert durch evtl. Todesfolgen ermitteln.
  if ( atrname != SA_QUALITY )
    qual = QuerySkillAttribute(SA_QUALITY);
  else
    // bei SA_QUALITY gehen die Todesfolgen ein
    qual = to_int(100 * pow(0.9, death_suffering()/10.0));

  // Die Offsets sind sozusagen der Basiswert der SAs. Als erstes verwursten,
  // sofern vorhanden, nen int drinsteht und der offset != 0 ist.
  if ( mappingp(offsets = Query(P_SKILL_ATTRIBUTE_OFFSETS))
       && intp(attr=offsets[atrname]) 
       && attr)
    ret = attr;
  else
    ret = 100;

  // wenn keine Mods gesetzt sind, wars das jetzt. ;-)
  if ( !mappingp(skillattrs)
       || !member(skillattrs, atrname) )
    return (ret*qual)/100;

  // wenn Cache der stat. Mods abgelaufen oder offenbar Objekte zerstoert
  // wurden, muss der Cache neu berechnet werden.
  if ( skillattrs[atrname,SAM_CACHE][SAM_CACHE_TIMEOUT] < time()
      || sizeof(skillattrs[atrname,SAM_STATIC])
         +sizeof(skillattrs[atrname,SAM_DYNAMIC]) !=
           skillattrs[atrname,SAM_CACHE][SAM_COUNT] )
  {
    UpdateSACache( ({atrname}) );
    // UpdateSACache() loescht uU das SA-Mapping oder Eintraege daraus.
    if ( !mappingp(skillattrs)
         || !member(skillattrs, atrname) )
    return (ret*qual)/100;
  }
  // Summe der statischen Mods.
  modsumme = skillattrs[atrname,SAM_CACHE][SAM_SUM];

  // TODO! Evtl. andere Daten als ME an die Funktion uebergeben
  // TODO! bereits nach Addition des Funktionsrueckgabewertes pruefen, ob der
  //       Wertebereich des SA-Modifiers ueberschritten ist, oder freien
  //       Wertebereich erlauben und erst am Ende deckeln (aktuelle Variante)
  // Dynamische Modifier auswerten
  foreach( object ob, closure cl, int duration:
           skillattrs[atrname,SAM_DYNAMIC] )
  {
    if ( duration > time()               // Noch nicht abgelaufen und
         && intp(cval=funcall(cl, ME)) ) // Funktion liefert int zurueck
      modsumme += cval;
    else {
      efun::m_delete(skillattrs[atrname,SAM_DYNAMIC], ob);
      skillattrs[atrname,SAM_CACHE][SAM_COUNT]--;
    }
  }
  ret = ((ret+modsumme)*qual)/100;
  if ( ret < 10 )
    ret = 10;
  else if ( ret > 1000 )
    ret = 1000;

  return ret;
}

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

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

public varargs mapping QuerySkillAttributeModifier	(	object	caster,
		string *	attrnames
	)

Definiert in Zeile 307 der Datei skill_attributes.c.

Benutzt c, SAM_DURATION, SAM_DYNAMIC, SAM_STATIC, SAM_VALUE, skillattrs und UpdateSACache().

                                              {
  
  // auf abgelaufene Modifikatoren pruefen
  if (!pointerp(attrnames))
    UpdateSACache( ({}) );
  else
    UpdateSACache(attrnames);

  if (!mappingp(skillattrs))
    return ([]);
  if (!pointerp(attrnames) || !sizeof(attrnames))
    attrnames = m_indices(skillattrs); // alle durchsuchen
  else // schnittmenge der gew. und vorhandenen bilden
    attrnames = m_indices(skillattrs) & attrnames;
  
  mapping res=m_allocate(sizeof(attrnames), 1);

  foreach(string atr: attrnames) {
    res[atr] = m_allocate(5, 2); // mal fuer 5 Werte Platz reservieren
    if (!objectp(caster)) {
      // wenn kein bestimmter caster angefragt ist, alle mods liefern
      foreach(object c, int value, int dur: skillattrs[atr, SAM_STATIC]) {
                res[atr] += ([c: value; dur]);
      }
      foreach(object c, closure value, int dur: skillattrs[atr, SAM_DYNAMIC]) {
                res[atr] += ([c: value; dur]);
      }
    }
    else {
      // sonst nur den Mod von caster
      if (member(skillattrs[atr, SAM_STATIC], caster)) {
                res[atr] += ([caster: 
                                                 skillattrs[atr, SAM_STATIC][caster, SAM_VALUE];
                                 skillattrs[atr, SAM_STATIC][caster, SAM_DURATION]
                                    ]);
      }
      else if (member(skillattrs[atr, SAM_DYNAMIC], caster)) {
                res[atr] += ([caster:
                                                 skillattrs[atr, SAM_DYNAMIC][caster, SAM_VALUE];
                                 skillattrs[atr, SAM_DYNAMIC][caster, SAM_DURATION]
                                    ]);
      }
    }
  }
  return res;
}

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

public int RemoveSkillAttributeModifier	(	object	caster,
		string	attrname
	)

Definiert in Zeile 211 der Datei skill_attributes.c.

Benutzt m_delete(), SA_MOD_NOT_FOUND, SA_MOD_REMOVED, SAM_DYNAMIC, SAM_STATIC, skillattrs und UpdateSACache().

                                                                        {
  if (!stringp(attrname) || !mappingp(skillattrs) || !objectp(caster)
      || !member(skillattrs, attrname))
    return SA_MOD_NOT_FOUND;
  // TODO: Berechtigung pruefen. ;-)

  if (member(skillattrs[attrname, SAM_STATIC], caster)) {
    efun::m_delete(skillattrs[attrname, SAM_STATIC], caster);
  }
  else if (member(skillattrs[attrname, SAM_DYNAMIC], caster)) {
    efun::m_delete(skillattrs[attrname, SAM_DYNAMIC], caster);
  }
  else
    return SA_MOD_NOT_FOUND;
  
  // TODO: Cache nur invalidieren, damit er erst bei der naechsten Abfrage
  // aktualisiert wird. Spart Zeit, wenn bis dahin mehrere Mods
  // entfernt/addiert werden. Dafuer ist die gecache Anzahl an Mods
  // inkonsistent.
  UpdateSACache( ({attrname}) );

  return SA_MOD_REMOVED;
}

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

private void UpdateSACache

(

string *

attrs

)

Definiert in Zeile 55 der Datei skill_attributes.c.

Benutzt m_delete(), ob(), SAM_CACHE, SAM_CACHE_TIMEOUT, SAM_COUNT, SAM_DYNAMIC, SAM_STATIC, SAM_SUM, skillattrs, stat(), sum und ZDEBUG.

Wird benutzt von InternalModifySkillAttribute(), QuerySkillAttribute(), QuerySkillAttributeModifier() und RemoveSkillAttributeModifier().

                                          {
#ifdef __DEBUG__
    if (getuid(this_object()) == "zesstra")
    ZDEBUG(sprintf("%O\n",skillattrs));
#endif
  if (!mappingp(skillattrs)) return;
  if (!pointerp(attrs) || sizeof(attrs))
    attrs = m_indices(skillattrs); // alle
  // sonst schnittmenge aus existierenden und den uebergebenen.
  attrs = m_indices(skillattrs) & attrs;

  // und jetzt ueber alle gewuenschten SAs drueber
  foreach(string attr : attrs) {
    int *cache = skillattrs[attr, SAM_CACHE];
    mapping stat = skillattrs[attr, SAM_STATIC];
    mapping dyn = skillattrs[attr, SAM_DYNAMIC];
    int sum = 0;
    int timeout = __INT_MAX__;
 
    // ueber stat. Mods iterieren und Aufsummieren, kleinsten Timeout
    // ermitteln.
    foreach(object ob, int value, int duration: stat) {
      // gueltige Mods aufaddieren, abgelaufene rauswerfen
      if (duration >= time()) {
        sum += value;
        if (duration < timeout)
          timeout = duration;
      }
      else
        efun::m_delete(stat, ob); // ja, geht im foreach ;-)
    }
    // Ablaufzeiten der dyn. Mods pruefen, waere hier zwar nicht unbedingt
    // noetig sondern koennte man ausschliesslich im QuerySkillAttribute()
    // machen, aber dann waere die Ermittlung der Summe der Mods schwieriger.
    foreach(object ob, closure value, int duration: dyn) {
      if (duration < time())
        efun::m_delete(dyn, ob); // ungueltig, weg damit.
    }
    // gesamtzahl Mods?
    cache[SAM_COUNT] = sizeof(stat) + sizeof(dyn);
    if (!cache[SAM_COUNT]) {
      // keine mods da, Submapping fuer dieses SA komplett loeschen.
      efun::m_delete(skillattrs, attr);
      continue;
    }
    // sonst die anderen Cache-Werte setzen.
    cache[SAM_SUM] = sum;
    cache[SAM_CACHE_TIMEOUT] = timeout;
  }
  // wenn alle Mods geloescht wurden.
  if (!sizeof(skillattrs)) skillattrs=0;
#ifdef __DEBUG__
  if (getuid(this_object()) == "zesstra")
    ZDEBUG(sprintf("%O\n",skillattrs));
#endif
}

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

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

---

Variablen-Dokumentation

inherit std util executer

Definiert in Zeile 12 der Datei skill_attributes.c.

private nosave mapping skillattrs

Definiert in Zeile 38 der Datei skill_attributes.c.

Wird benutzt von _query_skill_attr(), _set_skill_attr(), InternalModifySkillAttribute(), QuerySkillAttribute(), QuerySkillAttributeModifier(), RemoveSkillAttributeModifier() und UpdateSACache().