combat.c-Dateireferenz

#include <thing/properties.h>
#include <thing/commands.h>
#include <thing/description.h>
#include <config.h>
#include <combat.h>
#include <language.h>
#include <defines.h>
#include <new_skills.h>

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
Funktionen
void	create ()
int	QueryDefend (string *dam_type, mixed spell, object enemy)
static mixed	_set_armour_type (mixed type)
static object	_set_defend_func (object arg)
static mixed	_set_dam_type (mixed arg)
static mixed	_set_resistance_strengths (mixed resmap)
static mapping	_query_resistance_strengths ()
Variablen
private nosave closure	defend_cl
private nosave mapping	resistance_strengths = ([])

---

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 13 der Datei combat.c.

---

Dokumentation der Funktionen

static mapping _query_resistance_strengths

(

)

[static]

Definiert in Zeile 218 der Datei combat.c.

Benutzt resistance_strengths.

                                             {
  return (resistance_strengths||([]));
}

static mixed _set_armour_type

(

mixed

type

)

[static]

Definiert in Zeile 108 der Datei combat.c.

Benutzt AddId(), AT_ILLEGAL, COMBAT_MASTER, F_VALUE, P_ARMOUR_TYPE, resistance_strengths und Set().

                                           {
    if (!COMBAT_MASTER->valid_armour_type(type))
    {
        Set(P_ARMOUR_TYPE, (type=AT_ILLEGAL), F_VALUE);
    }
    else
    {
        Set(P_ARMOUR_TYPE, type);
    }
    AddId(type);

    resistance_strengths=([]);
    return type;
}

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

static mixed _set_dam_type

(

mixed

arg

)

[static]

Definiert in Zeile 138 der Datei combat.c.

Benutzt F_VALUE, P_DAM_TYPE, Query() und Set().

                                      {
    if (pointerp(arg))
    {
        return Set(P_DAM_TYPE, arg, F_VALUE);
    }
    else if (stringp(arg))
    {
        return Set(P_DAM_TYPE, ({ arg }), F_VALUE);
    }
    return Query(P_DAM_TYPE, F_VALUE);
}

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

static object _set_defend_func

(

object

arg

)

[static]

Definiert in Zeile 126 der Datei combat.c.

Benutzt defend_cl, F_VALUE, P_DEFEND_FUNC und Set().

                                           {
  if (objectp(arg) &&
      closurep(defend_cl=symbol_function("DefendFunc",arg))) {  
    return Set(P_DEFEND_FUNC, arg, F_VALUE);
  }
  defend_cl=0;
  return(Set(P_DEFEND_FUNC, 0, F_VALUE));
}

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

static mixed _set_resistance_strengths

(

mixed

resmap

)

[static]

Definiert in Zeile 156 der Datei combat.c.

Benutzt AT_AMULET, AT_ARMOUR, AT_CLOAK, AT_RING, AT_SHIELD, P_ARMOUR_TYPE, P_WORN, QueryProp() und resistance_strengths.

                                                     {
    float  max_res;
    object worn_by;

    // Es duerfen nur mappings angegeben werden
    if (!mappingp(resmap))
    {
        return -1;
    }

    // die Maxwerte muessen jeweils durch -100 geteilt sein, da hinterher
    // mit der Prozentzahl multipliziert wird und die angabe der Vorzeichen
    // hier umgekehrt wie bei den "normalen" Resistenzen ist. Der
    // Maximalwert ist vom Ruestungstyp abhaengig.
    switch (QueryProp(P_ARMOUR_TYPE))
    {
        case AT_CLOAK  :
        case AT_RING   :
        case AT_AMULET : max_res=-0.0010;
                         break;
        case AT_SHIELD :
        case AT_ARMOUR : max_res=-0.0015;
                         break;
        default        : max_res=-0.0005;
    }

    // Resistenz-Mapping aktualisieren
    resistance_strengths=([]);
    foreach(string damtype, int res: resmap)
    {
        if (!intp(res)) res=to_int(res);
        // Mehr als 100 Prozent ist nicht erlaubt
        if (res>100)
        {
            res=100;
        }
        else if (res<0)
        {
             res=(res/4)*5;
             // Man kann auch nicht beliebig negativ werden
             if (res<-1000)
             {
                 res=-1000;
             }
        }
        // Der Resistenzwert berechnet sich aus dem Produkt des
        // Maximalwertes und der Prozentzahl
        resistance_strengths[damtype]=res*max_res;
    }

    // Werden die Resistenzen bei einer getragenen Ruestung geaendert,
    // muss der Traeger davon natuerlich beeinflusst werden.
    if (objectp(worn_by=QueryProp(P_WORN)))
    {
        worn_by->AddResistanceModifier(resistance_strengths,
                                       QueryProp(P_ARMOUR_TYPE));
    }
   return resistance_strengths;
}

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

void create

(

)

Definiert in Zeile 29 der Datei combat.c.

Benutzt AT_ILLEGAL, F_VALUE, P_ARMOUR_TYPE, P_LAST_USE und Set().

              {
    // Einige Grundwerte setzen
    Set(P_ARMOUR_TYPE, AT_ILLEGAL, F_VALUE);
    Set(P_LAST_USE,time(),F_VALUE);
}

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

int QueryDefend	(	string *	dam_type,
		mixed	spell,
		object	enemy
	)

Definiert in Zeile 36 der Datei combat.c.

Benutzt AT_MISC, DEF_ARMOUR_PROT, DEFEND_ARMOURS, defend_cl, DEFEND_CUR_ARMOUR_PROT, EINFO_DEFEND, ME, P_AC, P_ARMOUR_TYPE, P_DEFEND_FUNC, P_LAST_USE, P_WORN, PHYSICAL_DAMAGE_TYPES, pl, QueryProp(), SetProp() und SP_PHYSICAL_ATTACK.

{
    int     prot;
    mixed   def_func;
    object  pl;
    // Zum Cachen von spell[EINFO_DEFEND], haeufiges Lookup aus dem Mapping
    // koennte unnoetig Zeit kosten.
    mapping einfo;

    // AT_MISC-Ruetungen schuetzen normalerweise gar nicht...
    if (QueryProp(P_ARMOUR_TYPE)==AT_MISC) {
                // es sei denn, sie haben eine spezielle DefendFunc
                if (!closurep(defend_cl)) return(0);
    }
    else {
                // ansonsten Ruestungsschutz ermitteln und in EINFO_DEFEND vermerken.
                // (Beides fuer AT_MISC in jedem Fall unnoetig)

                // Ruestungen schuetzen nur gegen physikalischen Schaden
                if ((!spell || (mappingp(spell) && spell[SP_PHYSICAL_ATTACK]))
                    && sizeof(filter(dam_type,PHYSICAL_DAMAGE_TYPES)))
                { 
                  // Schutz bestimmen
                  prot = random(1+QueryProp(P_AC));
                  // ruestungschutz an defendfunc weitermelden
                  if (mappingp(spell) &&
                      mappingp(einfo=spell[EINFO_DEFEND])) {
                      // Schutz d. akt. Ruestung vermerken.
                      einfo[DEFEND_CUR_ARMOUR_PROT]=prot;
                      // daten der Ruestung vermerken.
                      if (mappingp(einfo[DEFEND_ARMOURS])) {
                                einfo[DEFEND_ARMOURS][ME,DEF_ARMOUR_PROT]=prot;
                      }
                  } // ende vom if (mapping(spell) ...)
                } // ende vom if (phys Schaden)

    } // ende vom else (wenn kein AT_MISC) 

    // Ist eine DefendFunc gesetzt, wird diese ausgewertet
    if (closurep(defend_cl)) {
                if (!objectp(get_type_info(defend_cl,2))) {
                    // Closure gesetzt, aber nicht gueltig, schauen, ob wir sie neu
                    // erstellen koennen.
                    if (objectp(def_func=QueryProp(P_DEFEND_FUNC))) {
                                defend_cl=symbol_function("DefendFunc",def_func);
                    }
                    // sonst loeschen, um spaeter diesen Zweig ganz zu sparen.
                    else defend_cl=0;
                }
                // BTW: Es ist ok, wenn defend_cl jetzt 0 ist, dann liefert funcall()
                // auch 0.
                // Bei Netztoten keine (zurueckschlagende) DefendFunc
                if (objectp(pl=QueryProp(P_WORN)) && (!query_once_interactive(pl) ||
                                interactive(pl)) ) {
                  // Der Rueckgabewert der DefendFunc wird zum Schutz addiert
                  prot += funcall(defend_cl, dam_type, spell, enemy);
                  // leider kann die DefendFunc jetzt auch noch das Objekt zerstoert
                  // haben...
                  if (!objectp(this_object()))
                    return prot;
                }
    }

    // Zeitpunkt der letzten Benutzung ausgeben
    SetProp(P_LAST_USE,time());

    // Berechneten Schutz zurueckgeben
    return prot;
}

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

---

Variablen-Dokumentation

private nosave closure defend_cl

Definiert in Zeile 26 der Datei combat.c.

Wird benutzt von _set_defend_func(), create() und QueryDefend().

private nosave mapping resistance_strengths = ([])

Definiert in Zeile 27 der Datei combat.c.

Wird benutzt von _query_resistance_strengths(), _set_armour_type() und _set_resistance_strengths().