combat.c-Dateireferenz

#include <sys_debug.h>
#include <thing/properties.h>
#include <thing/commands.h>
#include <thing/description.h>
#include <language.h>
#include <combat.h>
#include <attributes.h>
#include <defines.h>
#include <moving.h>
#include <new_skills.h>

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
Funktionen
void	create ()
void	doWieldMessage ()
void	doUnwieldMessage (object wielded_by)
protected void	InformWield (object pl, int silent)
protected void	InformUnwield (object pl, int silent)
varargs int	wield_me (int silent)
varargs int	DoWield (int silent)
varargs int	DoUnwield (int silent)
varargs int	wield (string str, int silent)
int	unwield (string str)
int	QueryDamage (object enemy)
int	QueryDefend (string *dam_type, mixed spell, object enemy)
int	_set_nr_hands (int arg)
mixed	_set_dam_type (mixed arg)
mixed	_set_item_damaged (mixed arg)
mixed	_set_hit_func (mixed arg)
mixed	_set_defend_func (mixed arg)
int	_query_max_wc ()
int	Damage (int new_dam)
varargs void	TakeFlaw (object enemy)
mixed *	QueryFlaw ()
Variablen
int	ftime
int	flaw
static private int	logged
static private closure	defend_cl
static private closure	hit_cl

---

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 15 der Datei combat.c.

---

Dokumentation der Funktionen

int _query_max_wc

(

)

Definiert in Zeile 693 der Datei combat.c.

Benutzt P_DAMAGED, P_EFFECTIVE_WC, P_WC und QueryProp().

{   int a,b;

    a=QueryProp(P_WC)+QueryProp(P_DAMAGED);
    b=QueryProp(P_EFFECTIVE_WC);
    if (b>a)
        return b;
    return a;
}

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

mixed _set_dam_type

(

mixed

arg

)

Definiert in Zeile 645 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:

mixed _set_defend_func

(

mixed

arg

)

Definiert in Zeile 684 der Datei combat.c.

Benutzt defend_cl, F_VALUE, P_DEFEND_FUNC und Set().

{
    defend_cl=0;
    return Set(P_DEFEND_FUNC, arg, F_VALUE);
}

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

mixed _set_hit_func

(

mixed

arg

)

Definiert in Zeile 676 der Datei combat.c.

Benutzt F_VALUE, hit_cl, P_HIT_FUNC und Set().

{
    hit_cl=0;
    return Set(P_HIT_FUNC, arg, F_VALUE);
}

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

mixed _set_item_damaged

(

mixed

arg

)

Definiert in Zeile 660 der Datei combat.c.

Benutzt F_VALUE, P_DAMAGED, Query(), QueryProp() und Set().

{
    if (arg && !intp(arg))
    {
        return Query(P_DAMAGED, F_VALUE);
    }

    if (previous_object(1))
      call_other("/secure/awmaster","RegisterDamager",
            previous_object(1),QueryProp(P_DAMAGED),arg);
    
    return Set(P_DAMAGED,arg,F_VALUE);
}

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

int _set_nr_hands

(

int

arg

)

Definiert in Zeile 636 der Datei combat.c.

Benutzt F_VALUE, Query() und Set().

{
    if (!intp(arg) || (arg<1) )
        return Query(P_NR_HANDS, F_VALUE);
    return Set(P_NR_HANDS, arg, F_VALUE);
}

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

void create

(

)

Definiert in Zeile 33 der Datei combat.c.

Benutzt AddCmd(), defend_cl, DT_BLUDGEON, F_MODE_AS, F_VALUE, flaw, ftime, hit_cl, logged, P_AC, P_DAM_TYPE, P_DAMAGED, P_LAST_USE, P_PARRY, P_RESTRICTIONS, P_WEAPON_TYPE, P_WIELDED, PARRY_NOT, PROTECTED, Set(), SetProp() und WT_CLUB.

{
    // Variablen initialisieren
    logged=ftime=flaw=0;
    defend_cl=0;
    hit_cl=0;

    // Einige Grundwerte setzen
    SetProp(P_WEAPON_TYPE, WT_CLUB);
    SetProp(P_DAM_TYPE, ({DT_BLUDGEON}));
    SetProp(P_NR_HANDS, 2);
    SetProp(P_PARRY,PARRY_NOT);
    SetProp(P_AC,0);
    Set(P_RESTRICTIONS,([]),F_VALUE);
    Set(P_LAST_USE,time(),F_VALUE);

    // Einige Properties sollten nicht von aussen gesetzt werden koennen
    Set(P_PARRY,   PROTECTED, F_MODE_AS);
    Set(P_WIELDED, PROTECTED, F_MODE_AS);
    Set(P_LAST_USE,PROTECTED, F_MODE_AS);
    
    // Diese kann von aussen gesetzt werden (noch), aber bitte nur ueber die
    // hier definierte Setmethode.
    Set(P_DAMAGED, PROTECTED, F_MODE_AS);

    // Eine Waffe benoetigt Kommandos, mit denen man sie zuecken 
    // und wegstecken kann
    AddCmd( ({"zueck","zuecke","zieh","ziehe"}), "wield" );
    AddCmd( ({"steck","stecke"}), "unwield" );
}

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

int Damage

(

int

new_dam

)

Definiert in Zeile 707 der Datei combat.c.

Benutzt F_VALUE, MAX_PARRY_CLASS, MAX_WEAPON_CLASS, MIN_PARRY_CLASS, MIN_WEAPON_CLASS, P_AC, P_DAMAGED, P_PARRY, P_TOTAL_AC, P_TOTAL_WC, P_WC, P_WIELDED, PARRY_ONLY, QueryProp(), Set() und SetProp().

{   int    wc,old_dam;
    object w;

    // Uebergebenes Argument pruefen
    if (!new_dam || !intp(new_dam))
    {
        return 0;
    }

    // Bei Waffen, die nicht ausschliesslich zur Parade eingesetzt werden,
    // geht die Beschaedigung auf die Kampfkraft, sprich: P_WC
    if (QueryProp(P_PARRY)<PARRY_ONLY)
    {
        if ((wc=QueryProp(P_WC))<=MIN_WEAPON_CLASS && new_dam>0)
        {
            // Sonst wuerde Beschaedigung zur Reparatur fuehren
            return 0;
        }

        // Min-WC und Max-WC beachten
        if ((wc-new_dam) < MIN_WEAPON_CLASS)
        {
            new_dam = wc-MIN_WEAPON_CLASS;
        }
        else if ((wc-new_dam) > MAX_WEAPON_CLASS)
        {
            new_dam = wc-MAX_WEAPON_CLASS;
        }

        // Nie mehr als 100% reparieren
        if (((old_dam=QueryProp(P_DAMAGED))<-new_dam) && new_dam<0)
        {
            new_dam=-old_dam;
        }

        // Aenderungen an der Waffenklasse und der dem Beschaedigungswert
        // durchfuehren
        SetProp(P_WC,(wc-new_dam));
        // Ausnahmeweise Set, um die loggende Setmethode zu umgehen.
                // TODO: SetProp, sobald direktes Beschaedigen raus ist.
                Set(P_DAMAGED, old_dam+new_dam, F_VALUE);

        // P_TOTAL_WC im Traeger updaten, so vorhanden
        if (objectp(w=QueryProp(P_WIELDED)))
            w->QueryProp(P_TOTAL_WC);

        // Rueckgabewert: Durchgefuehrte Aenderung an P_DAMAGE
        return new_dam;
    }

    // Bei reinen Parierwaffen geht die Beschaedigung auf die
    // Schutzwirkung, sprich: P_AC

    if ((wc=QueryProp(P_AC))<=0 && new_dam>0)
    {
        // Sonst wuerde Beschaedigung zur Reparatur fuehren
        return 0;
    }
    
    // Min-AC=0 und Max-AC beachten
    if ((wc-new_dam) < MIN_PARRY_CLASS)
    {
        new_dam = wc-MIN_PARRY_CLASS;
    }
    else if ((wc-new_dam) > MAX_PARRY_CLASS)
    {
        new_dam = wc-MAX_PARRY_CLASS;
    }
 
    // Nie mehr als 100% reparieren
    if (((old_dam=QueryProp(P_DAMAGED))<-new_dam) && new_dam<0)
    {
        new_dam=-old_dam;
    }

    // Aenderungen an der Ruestungsklasse und dem Beschaedigungswert
    // durchfuehren
    SetProp(P_AC,wc-new_dam);
    // Ausnahmeweise Set, um die loggende Setmethode zu umgehen.
    // TODO: SetProp, sobald direktes Beschaedigen raus ist.
    Set(P_DAMAGED,old_dam+new_dam, F_VALUE);

    // P_TOTAL_AC im Traeger updaten, so vorhanden
    if (objectp(w=QueryProp(P_WIELDED)))
        w->QueryProp(P_TOTAL_AC);
    
    // Rueckgabewert: Durchgefuehrte Aenderung an P_DAMAGE
    return new_dam;
}

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

varargs int DoUnwield

(

int

silent

)

Definiert in Zeile 403 der Datei combat.c.

Benutzt break_string(), cl, doUnwieldMessage(), InformUnwield(), M_NOCHECK, ME, name, P_CURSED, P_PARRY, P_PARRY_WEAPON, P_TOTAL_AC, P_TOTAL_WC, P_UNWIELD_FUNC, P_UNWIELD_TIME, P_WEAPON, P_WIELDED, PARRY_NOT, PARRY_ONLY, QueryProp(), SetProp() und WEN.

Wird benutzt von move(), remove() und unwield().

{   closure cl;
    int     parry;
    mixed   res;
    object  wielded_by;

    // Waffen, die nicht gezueckt sind, kann man natuerlich nicht
    // wegstecken
    if (!objectp(wielded_by=QueryProp(P_WIELDED)))
    {
        return 0;
    }

    // Ist eine UnwieldFunc gesetzt, wird diese aufgerufen
    if ( objectp(res=QueryProp(P_UNWIELD_FUNC)) &&
         !(res->UnwieldFunc(ME,silent,wielded_by)) ) 
    {
        // Eine Meldung muss die UnwieldFunc schon selbst ausgeben.
        return 1;
    }

    // Eine verfluchte Waffe kann man natuerlich nicht wegstecken - aber
    // auch da gibts Ausnahmefaelle, wie z.B. den Tod eines Spielers
    if ((res=QueryProp(P_CURSED)) && !(silent&M_NOCHECK)) 
    {
        if (stringp(res))
        {
            // Stand in P_CURSED ein String? Dann diesen ausgeben
            tell_object(wielded_by, 
                (res[<1]=='\n' ? res : break_string(res,78)));
        }
        else
        {
            // Sonst eine Standard-Meldung ausgeben
            tell_object(wielded_by, break_string(
                "Du kannst "+name(WEN)+" nicht wegstecken.",78));
        }
        return 1;
    }

    // Ok, jetzt ist alles klar, die (Parier)Waffe wird weggesteckt
    parry=QueryProp(P_PARRY);
    cl=symbol_function("SetProp",wielded_by);

    if (parry<PARRY_ONLY)
    {
        // Eintrag als Waffe im Spieler loeschen
        funcall(cl,P_WEAPON, 0);
    }
    if (parry>PARRY_NOT)
    {
        // Eintrag als Parierwaffe im Spieler loeschen
        funcall(cl,P_PARRY_WEAPON, 0);
    }

    // Im Spieler die Zeit setzen, zu der er zuletzt eine Waffe weggesteckt
    // hat.
    funcall(cl,P_UNWIELD_TIME,time());

    // Meldung ausgeben, wenn silent-Flag nicht gesetzt ist
    if (!silent) 
    {
        doUnwieldMessage(wielded_by);
    } 

    // Die Haende, die bisher von der Waffe benutzt wurden, freigeben
    wielded_by->FreeHands(ME);
    SetProp(P_WIELDED, 0);

    // Waffen koennen Attribute aendern/blockieren. Also muessen diese
    // nach dem Wegstecken aktualisiert werden
    wielded_by->deregister_modifier(ME);
    wielded_by->UpdateAttributes();

    // P_TOTAL_AC/P_TOTAL_WC im Spieler aktualisieren. Da dort Attribute
    // eingehen, kann das erst hier gemacht werden.
    if (parry<PARRY_ONLY)
    {
        wielded_by->QueryProp(P_TOTAL_WC);
    }
    if (parry>PARRY_NOT)
    {
        wielded_by->QueryProp(P_TOTAL_AC);
    }

    // Inform-Funktion aufrufen
    InformUnwield(wielded_by, silent);

    // Fertig mit dem Wegstecken
    return 1;
}

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

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

void doUnwieldMessage

(

object

wielded_by

)

Definiert in Zeile 138 der Datei combat.c.

Benutzt break_string(), BS_LEAVE_MY_LFS, name, P_UNWIELD_MSG, QueryProp(), replace_personal(), WEN und WER.

Wird benutzt von DoUnwield().

{
  string *str,s1;

  if(!objectp(wielded_by))  // Hoops! Gar nicht gezueckt? Abbruch!
  {
    return;
  }

  if(QueryProp(P_UNWIELD_MSG))  // Hier gibt es eine UnwieldMsg.
  {
    if(closurep(QueryProp(P_UNWIELD_MSG)))  // Sogar als Closure, wow :-)
    {
      str = funcall(QueryProp(P_UNWIELD_MSG),wielded_by);

      if(interactive(wielded_by))
      {
        tell_object(wielded_by,break_string(str[0],78, 0, BS_LEAVE_MY_LFS));
      }
      //(Zesstra): say() ist hier bloed, weil es an das Env vom this_player()
      //ausgibt, sofern der existiert. So koennen Spieler die meldung kriegen,
      //obwohl die laengst woanders sind (z.B. Sequenzen)
      //Daher nun Ausgabe an das Env vom Env (es ist fuer tell_room() egal,
      //ob das nen Raum ist oder nicht, daher keine Pruefung, ob es wirklich
      //ein Raum ist. ;-)
      //say(break_string(str[1],78,0, BS_LEAVE_MY_LFS),({ wielded_by }));
      if ( objectp(environment()) && objectp(environment(environment())) )
                  tell_room(environment(environment()),
                      break_string(str[1],78,0, BS_LEAVE_MY_LFS),({ wielded_by }) );
    
      return;
    }
  
    else if(interactive(wielded_by))
    {
      s1 = replace_personal(sprintf(QueryProp(P_UNWIELD_MSG)[0],"@WEN2"),
                                      ({this_player(),this_object()}), 1);
    
      tell_object(wielded_by,break_string(s1,78, 0 , BS_LEAVE_MY_LFS));
    }

    s1 = replace_personal(sprintf(QueryProp(P_UNWIELD_MSG)[1],"@WEN1","@WEN2"),
                                    ({wielded_by, this_object()}), 1);
    
    //s.o., ersetzt durch tell_toom()
    //say(break_string(s1,78, 0, BS_LEAVE_MY_LFS ),({ wielded_by }));
    if ( objectp(environment()) && objectp(environment(environment())) )
                tell_room(environment(environment()),
                    break_string(s1,78, 0, BS_LEAVE_MY_LFS ),({ wielded_by }) );
    
    return;
  }
  /*
   * Keine UnwieldMsg, also Default-Meldungen ausgeben.
   */
  else if(interactive(wielded_by))
  {
    tell_object(wielded_by,break_string("Du steckst "
     +name(WEN,1)+" zurueck.",78));
  }
  //s.o., ersetzt durch tell_room()
  //say(break_string(wielded_by->Name(WER)+" steckt "
  // +name(WEN,0)+" zurueck.",78),({ wielded_by }));
  if ( objectp(environment()) && objectp(environment(environment())) )
      tell_room(environment(environment()),break_string(wielded_by->Name(WER)
                    +" steckt "+name(WEN,0)+" zurueck.",78),
                  ({wielded_by }) );
}

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

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

varargs int DoWield

(

int

silent

)

Definiert in Zeile 229 der Datei combat.c.

Benutzt _notify_fail(), A_DEX, break_string(), cl, doWieldMessage(), InformWield(), logged, MAX_PARRY_CLASS, MAX_WEAPON_CLASS, ME, name, notify_fail(), P_AC, P_EQUIP_TIME, P_M_ATTR_MOD, P_PARRY, P_PARRY_WEAPON, P_RESTRICTIONS, P_TOTAL_AC, P_TOTAL_WC, P_WC, P_WEAPON, P_WIELD_FUNC, P_WIELDED, PARRY_NOT, PARRY_ONLY, PL, QueryProp(), SetProp(), WEM und WEN.

Wird benutzt von wield().

{   int     dex, parry;
    closure cl;
    mixed   res;
  
    // Man kann nur Waffen zuecken, die man auch im Inventory hat.
    if (environment()!=PL) 
    {
        _notify_fail( break_string(
            "Du musst "+name(WEN,1)+" schon erst nehmen!",78) );
        return 0;
    }

    // Eine gezueckte Waffe kann man natuerlich nicht nochmal zuecken
    if (QueryProp(P_WIELDED)) 
    {
        notify_fail("Das hast Du schon gemacht!\n");
        return 0;
    }

    // Waffen, die ein oder mehrere Attribut veraendern und gegen
    // das gesetzte Limit verstossen, haben keine Wirkung bezueglich der
    // Attribute.
    if ( mappingp(res=QueryProp(P_M_ATTR_MOD)) && PL->TestLimitViolation(res) )
    {
        write(break_string(
            "Irgendetwas an Deiner Ausruestung verhindert, dass Du Dich mit "+
            name(WEM,1)+" so richtig wohl fuehlst.",78));
    }

    // Ueber P_RESTRICTIONS kann man einige Restriktionen definieren, ohne
    // gleich auf eine WieldFunc zurueckgreifen zu muessen.
    // Die Auswertung erfolgt ueber den RestrictionChecker
    if ( (res=QueryProp(P_RESTRICTIONS)) && mappingp(res) &&
         (res=(string)call_other("/std/restriction_checker","check_restrictions",
             PL,res)) && stringp(res) ) 
    {
        notify_fail(res);
        return 0;
    }

    parry=(int)QueryProp(P_PARRY);
    dex=(int)PL->QueryAttribute(A_DEX);

    // Testen, ob der Spieler die noetige Geschicklichkeit besitzt, um
    // mit dieser (Parier)Waffe umgehen zu koennen
    if ( ((parry<PARRY_ONLY) && ((dex+8)*10)<QueryProp(P_WC)) || 
         ((parry>PARRY_NOT)  && ((dex+5)*2 )<QueryProp(P_AC)) )
    {
        notify_fail(
            "Du bist nicht geschickt genug, um mit dieser Waffe umzugehen.\n");
        return 0;
    }

    // Eine Gezueckte Waffe muss natuerlich erst mal weggesteckt werden.
    if ( (parry<PARRY_ONLY) && objectp(res=(object)PL->QueryProp(P_WEAPON)) )
    {
        if ( (res->DoUnwield(silent)) && !((object)PL->QueryProp(P_WEAPON)) )
        {
            // Wenn die alte Waffe weggesteckt werden konnte, nochmal
            // versuchen zu zuecken
            return DoWield(silent);
        }
        else 
        {
            // Sonst Meldung ausgeben
            notify_fail("Das geht nicht, solange Du noch eine andere "+
                 "Waffe gezueckt hast.\n");
            return 0;
        }
    }
    // Das gleiche gilt natuerlich fuer Parierwaffen
    if ( (parry>PARRY_NOT) && objectp(res=(object)PL->QueryProp(P_PARRY_WEAPON)) )
    {
        if ( (res->DoUnwield(silent)) && !(PL->QueryProp(P_PARRY_WEAPON)) )
        {
            // Wenn die alte Parierwaffe weggesteckt werden konnte, nochmal
            // versuchen zu zuecken
            return DoWield(silent);
        }
        else 
        {
            // Sonst Meldung ausgeben
            notify_fail("Das geht nicht, solange Du noch eine andere "+
                 "Paierwaffe gezueckt hast.\n");
            return 0;
        }
    }

    // Ist eine WieldFunc gesetzt, wird diese aufgerufen.
    if (objectp(res=QueryProp(P_WIELD_FUNC)) 
                && !(res->WieldFunc(ME,silent,environment())))
    {
        // Eine Meldung sollte schon von der WieldFunc ausgegeben werden.
        return 1;
    }

    // Die zulaessigen Hoechstwerte duerfen natuerlich nicht
    // ueberschritten werden.
    if ( (parry<PARRY_ONLY) && (QueryProp(P_WC)>MAX_WEAPON_CLASS) )
    {
        notify_fail(
            "Ungueltige Waffenklasse, bitte Erzmagier verstaendigen.\n");
        return 0;
    }
    if ( (parry>PARRY_NOT) && (QueryProp(P_AC)>MAX_PARRY_CLASS) )
    {
        notify_fail(
            "Ungueltige Parierklasse, bitte Erzmagier verstaendigen.\n");
        return 0;
    }

    // Testen, ob der Zuecker genug Haende frei hat.  
    if (!(PL->UseHands(ME,QueryProp(P_NR_HANDS))))
    {
        notify_fail("Du hast keine Hand mehr frei.\n");
        return 0;
    }

    // Ok, jetzt ist alles klar, die (Parier)Waffe wird gezueckt
    SetProp(P_WIELDED, PL);
    SetProp(P_EQUIP_TIME,time());

    cl=symbol_function("SetProp",PL);

    if (parry<PARRY_ONLY)
    {
        // Dieses Objekt als Waffe setzen
        funcall(cl,P_WEAPON, ME );
    }
    if (parry>PARRY_NOT)
    {
        // Dieses Objekt als Parierwaffe setzen
        funcall(cl,P_PARRY_WEAPON, ME );
    }

    // Waffen koennen Attribute aendern/blockieren. Also muessen diese
    // nach dem Zuecken aktualisiert werden
    PL->register_modifier(ME);
    PL->UpdateAttributes();

    // P_TOTAL_AC/P_TOTAL_WC im Spieler aktualisieren. Da dort Attribute
    // eingehen, kann das erst hier gemacht werden.
    if (parry<PARRY_ONLY)
    {
        PL->QueryProp(P_TOTAL_WC);
    }
    if (parry>PARRY_NOT)
    {
        PL->QueryProp(P_TOTAL_AC);
    }

    // Zueck-Meldung ausgeben, wenn das silent-Flag nicht gesetzt ist
    if (!silent)
    {
        doWieldMessage();
    }

    // Alle Waffen werden im awmaster registriert, sobald sie von einem
    // Spieler gezueckt werden
    if (!logged && query_once_interactive(PL)) 
    {
        call_other("/secure/awmaster","RegisterWeapon",ME);
        logged=1;
    }

    // Inform-Funktion aufrufen
    InformWield(PL,silent);

    // Fertig mit dem Zuecken
    return 1;
}

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

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

void doWieldMessage

(

)

Definiert in Zeile 68 der Datei combat.c.

Benutzt break_string(), BS_LEAVE_MY_LFS, Name(), name, P_WIELD_MSG, QueryProp(), replace_personal(), WEN und WER.

Wird benutzt von DoWield().

{
  string *str, s1;
  
  if(QueryProp(P_WIELD_MSG))  // Ist eine WieldMsg gesetzt?
  {
    if(closurep(QueryProp(P_WIELD_MSG)))  // Sogar als eigene Fkt.?
    {
      str = funcall(QueryProp(P_WIELD_MSG),this_player());

      if(interactive(this_player()))
      {
        write(break_string(str[0],78, 0, BS_LEAVE_MY_LFS));
      }
    
      //(Zesstra): say() ist hier bloed, weil es an das Env vom this_player()
      //ausgibt, sofern der existiert. So koennen Spieler die meldung kriegen,
      //obwohl die laengst woanders sind (z.B. Sequenzen)
      //Daher nun Ausgabe an das Env vom Env (es ist fuer tell_room() egal, 
      //ob das nen Raum ist oder nicht, daher keine Pruefung, ob es wirklich
      //ein Raum ist. ;-)
      //say(break_string(str[1],78, 0, BS_LEAVE_MY_LFS),({ this_player() }));
      if ( objectp(environment()) && objectp(environment(environment())) )
          tell_room(environment(environment()),
                    break_string(str[1],78, 0, BS_LEAVE_MY_LFS),({ this_player()}) );
    
      return;
    }
  
    else if(interactive(this_player()))
    {
      s1 = replace_personal(sprintf(QueryProp(P_WIELD_MSG)[0],"@WEN2"),
                                      ({this_player(),this_object()}), 1);

      write(break_string(s1,78, 0, BS_LEAVE_MY_LFS));
    }

    // Abwaertskompatibel: Das erste %s wird zu WEN1, das zweite zu WEN2
    s1 = replace_personal(sprintf(QueryProp(P_WIELD_MSG)[1],"@WEN1","@WEN2"),
                                    ({this_player(), this_object()}), 1);
   
    //s.o., ersetzt durch tell_room()
    //say(break_string(s1,78, 0, BS_LEAVE_MY_LFS ),({ this_player() }));
    if ( objectp(environment()) && objectp(environment(environment())) )
                tell_room(environment(environment()),
                  break_string(s1,78, 0, BS_LEAVE_MY_LFS ),({this_player()}) );
    
    return;
  }
  /*
   * Keine WieldMsg gesetzt, Ausgabe der Default-Meldungen.
   */
  else if(interactive(this_player()))
  {
    write(break_string("Du zueckst "+name(WEN,1)+".",78));
  }
  
  //s.o. ersetzt durch tell_room()
  //say(break_string(this_player()->Name(WER)+" zueckt "
  // +name(WEN,0)+".",78),({ this_player() }));
  if ( objectp(environment()) && objectp(environment(environment())) )
      tell_room(environment(environment()),break_string(
                  this_player()->Name(WER)+" zueckt "+name(WEN,0)
                  +".",78),({ this_player() }));
}

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

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

protected void InformUnwield	(	object	pl,
		int	silent
	)

Definiert in Zeile 215 der Datei combat.c.

Wird benutzt von DoUnwield().

{
    return;
}

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

protected void InformWield	(	object	pl,
		int	silent
	)

Definiert in Zeile 208 der Datei combat.c.

Wird benutzt von DoWield().

{
    return;
}

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

int QueryDamage

(

object

enemy

)

Definiert in Zeile 556 der Datei combat.c.

Benutzt A_STR, hit_cl, P_HIT_FUNC, P_LAST_USE, P_WC, P_WIELDED, QueryProp() und SetProp().

Wird benutzt von Attack().

{   int    dam;
    mixed  hit_func;
    object wielder;

    // Nur gezueckte Waffen machen Schaden
    if (!objectp(wielder=QueryProp(P_WIELDED)))
        return 0;

    // Den Basis-Schaden berechnen. Die Staerke des Benutzers wird
    // hier beruecksichtigt.
    dam = (2*QueryProp(P_WC)+10*((int)wielder->QueryAttribute(A_STR)))/3;

    // Wie gut man getroffen hat, wird ueber ein random() simuliert
    dam = random(1+dam);

    // Ist eine HitFunc gesetzt, dann wird diese ausgewertet. Der 
    // Rueckgabe-Wert wird zum Schaden addiert
    if (!hit_cl || !get_type_info(hit_cl,2))
    {
        if (objectp(hit_func=QueryProp(P_HIT_FUNC)))
        {
            hit_cl=symbol_function("HitFunc",hit_func);
        }
    }
    if (hit_cl && get_type_info(hit_cl,2))
    {
        dam += funcall(hit_cl,enemy);
    }

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

    // Berechneten Schaden zurueckgeben
    return dam;
}

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

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

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

Definiert in Zeile 594 der Datei combat.c.

Benutzt defend_cl, P_AC, P_DEFEND_FUNC, P_LAST_USE, P_WIELDED, PHYSICAL_DAMAGE_TYPES, pl, QueryProp(), SetProp() und SP_PHYSICAL_ATTACK.

{   int     prot;
    mixed   def_func;
    object  pl;

    prot = 0;

    // Ruestungen schuetzen nur gegen physikalischen Schaden
    if (!spell || (mappingp(spell) && spell[SP_PHYSICAL_ATTACK]))
    {
        if (sizeof(filter(dam_type,PHYSICAL_DAMAGE_TYPES)))
        {
            prot = random(1+QueryProp(P_AC));
        }
    }

    // Ist eine DefendFunc gesetzt, wird diese ausgewertet
    if (!defend_cl || !get_type_info(defend_cl,2))
    {
        if (objectp(def_func=QueryProp(P_DEFEND_FUNC))) 
        {
            defend_cl=symbol_function("DefendFunc",def_func);
        }
    }
    //Bei Netztoten keine (zurueckschlagende) DefendFunc
    if (defend_cl && get_type_info(defend_cl,2) &&
        objectp(pl=QueryProp(P_WIELDED)) && (!query_once_interactive(pl) ||
        interactive(pl)) )
    {
        // Der Rueckgabewert der DefendFunc wird zum Schutz addiert
        prot += funcall(defend_cl, dam_type, spell, enemy);
    }

    // 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:

mixed* QueryFlaw

(

)

Definiert in Zeile 817 der Datei combat.c.

Benutzt dtime(), flaw und ftime.

{
    return({flaw,ftime,dtime(ftime)});
}

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

varargs void TakeFlaw

(

object

enemy

)

Definiert in Zeile 800 der Datei combat.c.

Benutzt c, Damage(), flaw, ftime, P_QUALITY und QueryProp().

{   int c;

    // Flaw-Wert erhoehen
    flaw++;

    // Ist der Waffe eine Qualitaet gesetzt worden, so kann es zu einer
    // allmaehlichen Beschaedigung der Waffe kommen
    if ((c=QueryProp(P_QUALITY)) && !(flaw%c))
        Damage(1);

    // Zeitpunkt des ersten Aufrufes festhalten
    if (!ftime)
        ftime=time();
}

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

int unwield

(

string

str

)

Definiert in Zeile 514 der Datei combat.c.

Benutzt _notify_fail(), DoUnwield(), ME, P_PARRY, P_PARRY_WEAPON, P_WEAPON, P_WIELDED, PARRY_NOT, PARRY_ONLY, PL und QueryProp().

{   int    parry;
    string dummy;

    // Erstmal die Eingabe auswerten. Ist dies wirklich ein Kommando
    // zum Wegstecken?
    if ( !stringp(str) || (sscanf(str,"%s weg",     dummy)!=1  && 
                           sscanf(str,"%s ein",     dummy)!=1  &&
                           sscanf(str,"%s zurueck", dummy)!=1 ) )
    {
        return 0;
    }

    str = dummy;
    parry=QueryProp(P_PARRY);

    // Ist wirklich diese Waffe gemeint?
    if ( !stringp(str) || !id(str) ||
         ((parry<PARRY_ONLY)&&((object)PL->QueryProp(P_WEAPON)!=ME)) ||
         ((parry>PARRY_NOT)&&((object)PL->QueryProp(P_PARRY_WEAPON)!=ME)) )
    {
        return 0;
    }

    // Man kann nur Waffen wegstecken, die man auch bei sich hat
    if (environment() != PL) 
    {
        _notify_fail("Diese Waffe gehoert Dir nicht!\n");
        return 0;
    }

    // Und natuerlich geht das auch nur, wenn die Waffe gezueckt ist.
    if (!QueryProp(P_WIELDED)) 
    {
        _notify_fail("Diese Waffe hast Du gar nicht gezueckt ...\n");
        return 0;
    }

    return DoUnwield();
}

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

varargs int wield	(	string	str,
		int	silent
	)

Definiert in Zeile 496 der Datei combat.c.

Benutzt _notify_fail() und DoWield().

{
    if ( !stringp(str) ||
         (query_verb()[0..3]=="zieh" && sscanf(str,"%s hervor",str)!=1) )
    {
        return 0;
    }

    if (!id(str)) 
    {
        _notify_fail("Du hast sowas nicht.\n");
        return 0;
    }

    return DoWield(silent);
}

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

varargs int wield_me

(

int

silent

)

Definiert in Zeile 222 der Datei combat.c.

{
  raise_error("wield_me() ist veraltet. Bitte nutze DoWield()\n");
  return 1;
}

---

Variablen-Dokumentation

private closure defend_cl [static]

Definiert in Zeile 31 der Datei combat.c.

int flaw

Definiert in Zeile 29 der Datei combat.c.

int ftime

Definiert in Zeile 29 der Datei combat.c.

private closure hit_cl [static]

Definiert in Zeile 31 der Datei combat.c.

Wird benutzt von _set_hit_func(), create() und QueryDamage().

private int logged [static]

Definiert in Zeile 30 der Datei combat.c.