wear.c-Dateireferenz

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

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
Funktionen
void	create ()
protected void	msg (string str, mixed fl)
varargs void	doWearMessage (int all)
void	doUnwearMessage (object worn_by, int all)
protected void	InformWear (object pl, int silent, int all)
protected void	InformUnwear (object pl, int silent, int all)
protected int	_check_wear_restrictions (int silent, int all)
protected void	_wear ()
protected void	_informwear (int silent, int all)
varargs int	DoWear (int silent, int all)
protected int	_check_unwear_restrictions (object worn_by, int silent, int all)
protected void	_unwear (object worn_by)
protected void	_informunwear (object worn_by, int silent, int all)
varargs int	DoUnwear (int silent, int all)
protected int	_do_wear (string str, int silent, int all)
varargs int	do_wear (string str, int silent)
protected int	_do_unwear (string str, int silent, int all)
varargs int	do_unwear (string str, int silent)
int	ziehe (string str)
static mixed	_set_item_damaged (mixed arg)
int	Damage (int new_dam)
varargs void	TakeFlaw (mixed dam_types, mapping einfos)
mixed *	QueryFlaw ()
public status	IsClothing ()
Variablen
nosave int	flaw
nosave int	ftime

---

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 13 der Datei wear.c.

---

Dokumentation der Funktionen

protected int _check_unwear_restrictions	(	object	worn_by,
		int	silent,
		int	all
	)

Definiert in Zeile 322 der Datei wear.c.

Benutzt break_string(), M_NOCHECK, ME, name, Name(), P_CURSED, P_REMOVE_FUNC, QueryPronoun(), QueryProp(), WEN und WER.

                                                     {
  mixed   res;

  // Nicht getragene Ruestungen kann man auch nicht ausziehen
  if (!objectp(worn_by)) {
      return(-2);
  }

  // Ist eine RemoveFunc gesetzt, wird diese aufgerufen
  if (objectp(res=QueryProp(P_REMOVE_FUNC)) && 
      !(res->RemoveFunc(ME,silent,worn_by))) {
      // Eine Meldung muss von der RemoveFunc ausgegeben werden
      return(-2);
  }

  // Eine verfluchte Ruestung kann man natuerlich nicht ausziehen - 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(worn_by,      
          (res[<1]=='\n' ? res : break_string(res,78,
            (all?(Name(WER)+": "):0))));
    }
    else {
      // Sonst eine Standard-Meldung ausgeben
      tell_object(worn_by,break_string(
          "Du kannst " + name(WEN) + " nicht ausziehen, " + QueryPronoun(WER)
          + " ist verflucht worden.\n",78,(all?(Name(WER)+": "):0)));
    }
    return(-2);
  }

  // Ausziehen moeglich
  return(1);
}

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

protected int _check_wear_restrictions	(	int	silent,
		int	all
	)

Definiert in Zeile 189 der Datei wear.c.

Benutzt armours, break_string(), check_restrictions(), ME, msg(), Name(), name, P_RESTRICTIONS, P_WEAR_FUNC, P_WORN, PL, QueryProp(), WEN und WER.

                                                            {
  mixed   type,res;
  object  *armours;

  // Man kann nur Kram anziehen, die man bei sich traegt
  if (environment()!=PL) {            
    msg(break_string("Du musst "+name(WEN,1)+" erst nehmen!",78,
            (all?(Name(WER)+": "):0)), all);
    return(-1);
  }

  // Eine getragene Ruestung kann man nicht nochmal anziehen
  if (QueryProp(P_WORN)) {
    msg(break_string("Du traegst "+name(WEN,1)+" bereits.",78,
          (all?(Name(WER)+": "):0)), all);
    return(-1);
  }

  // Ueber P_RESTRICTIONS kann man einige Restriktionen definieren, ohne
  // gleich auf eine WearFunc zurueckgreifen zu muessen.
  // Die Auswertung erfolgt ueber den RestrictionChecker
  if ((res=QueryProp(P_RESTRICTIONS)) && mappingp(res) &&
      (res=(string)"/std/restriction_checker"->check_restrictions(PL,res))
      && stringp(res)) {  
    msg(break_string(res,78,(all?(Name(WER)+": "):0)),all);
    return(-1);
  }

  // Ist eine WearFunc gesetzt, wird diese aufgerufen.
  if (objectp(res=QueryProp(P_WEAR_FUNC)) && 
      !(res->WearFunc(ME, silent, environment()))) {
    // Eine Meldung muss von der WearFunc ausgegeben werden
    return(-2);
  }

  // scheinbar darf man das hier anziehen. ;-)
  return 0;
}

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

protected int _do_unwear	(	string	str,
		int	silent,
		int	all
	)

Definiert in Zeile 486 der Datei wear.c.

Benutzt break_string(), DoUnwear(), last, name, notify_fail(), P_ARTICLE, P_LAST_WEAR_ACTION, P_WORN, PL, Query(), QueryProp(), WA_WEAR und WEN.

Wird benutzt von do_unwear() und setzen().

                                                          {
  int * last;

  // Ist diese Ruestung ueberhaupt gemeint? Und hat dieser Spieler sie
  // auch wirklich an?
  if (!stringp(str) || (!all && !id(str))) {
    return 0;
  }

  if (!QueryProp(P_WORN)) { 
    if (all) {  
      notify_fail("Alles ausgezogen, was ging.\n");
      return 0;
    }
    if (!Query(P_ARTICLE)) {
      notify_fail( break_string(
            "Du traegst k"+name(WEN,0)+".",78) );
    }
    else {    
      notify_fail( break_string(
           "Du traegst "+name(WEN,1)+" nicht.",78) );  
    }
    return 0;
  }

  // Vielleicht darf der Spieler ja gar nichts mehr ausziehen.
  if ((object)PL->InFight()) {
    last=(int*)PL->QueryProp(P_LAST_WEAR_ACTION);
    if (pointerp(last) && (last[0]==WA_WEAR) && ((time()-last[1])<2)) {
      notify_fail("Du hast doch gerade erst etwas angezogen!\n"              
          "So schnell bist Du nicht!\n");
      return 0;
    }
  }
  // Auf zum eigentlichen Ausziehen
  return DoUnwear(silent, all);
}

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

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

protected int _do_wear	(	string	str,
		int	silent,
		int	all
	)

Definiert in Zeile 448 der Datei wear.c.

Benutzt DoWear(), last, notify_fail(), P_LAST_WEAR_ACTION, PL und WA_UNWEAR.

Wird benutzt von do_wear() und setzen().

                                                        {
  int *last;

  // Standard-Notfiy-Fail setzen.
  if (all)
    notify_fail("Alles angezogen, was ging.\n");

  // Ist diese Ruestung ueberhaupt gemeint? Bei "trage alles" ist dies
  // natuerlich immer der Fall
  if (!str || (!all && !id(str))) {
      return 0;
  }

  // Vielleicht darf der Spieler ja gar nix mehr anziehen.
  if ((object)PL->InFight()) {        
    last=(int*)PL->QueryProp(P_LAST_WEAR_ACTION);
      if (pointerp(last) && (last[0]==WA_UNWEAR) && ((time()-last[1])<2)) {
        notify_fail("Du hast doch gerade erst etwas ausgezogen!\n"
            "So schnell bist Du nicht!\n");        
        return 0;        
      }
  }

  // Auf zum eigentlichen Anziehen
  return DoWear(silent, all);

}

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

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

protected void _informunwear	(	object	worn_by,
		int	silent,
		int	all
	)

Definiert in Zeile 369 der Datei wear.c.

Benutzt doUnwearMessage(), InformUnwear() und M_SILENT.

                                                                  {

  // Inform-Funktion aufrufen
  InformUnwear(worn_by, silent, all);

  // Meldung ausgeben, wenn das silent-Flag nicht gesetzt ist
  if (!(silent&M_SILENT)) {
    doUnwearMessage( worn_by, all );
  }
}

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

protected void _informwear	(	int	silent,
		int	all
	)

Definiert in Zeile 243 der Datei wear.c.

Benutzt doWearMessage(), InformWear() und PL.

                                                {

  // Eine Meldung ausgeben, wenn das silent-Flag nicht gesetzt ist
  if (!silent) {
    doWearMessage(all);
  }

  // Inform-Funktion aufrufen
  InformWear(PL, silent, all);
}

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

static mixed _set_item_damaged

(

mixed

arg

)

[static]

Definiert in Zeile 562 der Datei wear.c.

Benutzt P_DAMAGED und QueryProp().

                                          {
  return(QueryProp(P_DAMAGED));
}

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

protected void _unwear

(

object

worn_by

)

Definiert in Zeile 361 der Datei wear.c.

Benutzt clothing, ME und P_CLOTHING.

                                       {
  // Kleidung beim Spieler austragen
  object *clothing;
  clothing = (object*)worn_by->QueryProp(P_CLOTHING) - ({ME,0});
  worn_by->SetProp(P_CLOTHING, clothing);
}

protected void _wear

(

)

Definiert in Zeile 229 der Datei wear.c.

Benutzt clothing, ME, P_CLOTHING und PL.

                       {
// macht nur das lowlevel Eintragen in P_CLOTHING, damit dieses
// hier in armours sauber ueberschrieben werden kann.
  object *clothing=(object*)PL->QueryProp(P_CLOTHING);
  if (!pointerp(clothing))
    clothing=({ME});
  else
    clothing+=({ME});

  PL->SetProp(P_CLOTHING, clothing);
  return;
}

void create

(

)

Definiert in Zeile 29 der Datei wear.c.

Benutzt AddCmd(), F_MODE, F_MODE_AS, F_VALUE, P_LAST_USE, P_RESTRICTIONS, P_WORN, PROTECTED und Set().

{
  // Einige Properties sollten nicht von aussen gesetzt werden koennen
  Set(P_WORN, PROTECTED, F_MODE);
  Set(P_LAST_USE, PROTECTED, F_MODE_AS);
  Set(P_RESTRICTIONS,([]),F_VALUE);

  // Bekleidung benoetigt Kommandos, mit denen man sie an- und
  // ausziehen kann
  AddCmd( ({"zieh","ziehe"}),"ziehe" );
  AddCmd( ({"trag","trage"}),"do_wear" );
}

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

int Damage

(

int

new_dam

)

Definiert in Zeile 570 der Datei wear.c.

                        {
  return 0;
}

varargs int do_unwear	(	string	str,
		int	silent
	)

Definiert in Zeile 525 der Datei wear.c.

Benutzt _do_unwear() und all.

                                              {
  int all;

  all=(str=="alles" || str=="alle kleidung" || str=="alle bekleidung");

  return(_do_unwear(str,silent,all));
}

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

varargs int do_wear	(	string	str,
		int	silent
	)

Definiert in Zeile 477 der Datei wear.c.

Benutzt _do_wear() und all.

                                            {  
  int all;  

  // Hat der Spieler "trage alles" eingegeben?
  all=(str=="alles" || str=="alle kleidung" || str=="alle bekleidung");
  
  return(_do_wear(str,silent,all));
}

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

varargs int DoUnwear	(	int	silent,
		int	all
	)

Definiert in Zeile 384 der Datei wear.c.

Benutzt _check_unwear_restrictions(), _informunwear(), _unwear(), M_NOCHECK, M_SILENT, ME, notify_fail(), P_ATTACK_BUSY, P_EQUIP_TIME, P_LAST_WEAR_ACTION, P_WEAPON_TYPE, P_WORN, PL, QueryProp(), SetProp() und WA_UNWEAR.

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

                                          {
  object worn_by;
  int nh;

  // Das Flag "silent" wird in der RemoveFunc() etwas anders behandelt
  // als ueberall anders. Deshalb wird M_SILENT gesetzt, sofern "silent"
  // _irgendeinen_ Wert ausser M_NOCHECK hatte.
  if ( silent & ~M_NOCHECK )
      silent |= M_SILENT;

  // Standard-Notfiyfail setzen.
  if (all)
    notify_fail("Alles ausgezogen, was ging.\n");

  // Hat das Objekt Haende "benutzt"? Steht da auch wirklich ein
  // Integer-Wert drin? Wenn nicht, mach ich nen raise_error(), das duerfte
  // eigentlich gar nicht passieren. Pruefung mal am Anfang machen, bevor
  // irgendwas anderes (RemoveFunc()) passiert ist.
  if (!intp(nh=QueryProp(P_NR_HANDS))) {
    raise_error(sprintf("Invalid P_NR_HANDS in %O",object_name()));
  }

  worn_by=QueryProp(P_WORN);
  // darf ausgezogen werden? Wenn nicht, Ende.
  int res = _check_unwear_restrictions(worn_by,silent,all);
  if (res < 0)
    return(!all);

  // OK, alles klar, die Ruestung wird ausgezogen
#if __BOOT_TIME__ < 1234737458
  _unwear(worn_by);
#else
  worn_by->Unwear(ME);
#endif

  // Benutzte Haende wieder freigeben
  if (nh>0) {
    worn_by->FreeHands(ME);
  }

  worn_by->SetProp(P_EQUIP_TIME, time());
  SetProp(P_WORN, 0);

  // Flag noch setzen, Spieler hat ja was ausgezogen
  // Aber nur wenns auch der Spieler selbst ist.
  // und wenn das wirklich eine Ruestung und kein SMS o.ae. ist.
  if (PL && PL==worn_by && !QueryProp(P_WEAPON_TYPE)) {
    //Behinderung beim Wechsel nur fuer Spieler
    if (query_once_interactive(PL)) {
      PL->SetProp(P_LAST_WEAR_ACTION,({WA_UNWEAR,time()}));
      if (PL->InFight()) { 
        PL->SetProp(P_ATTACK_BUSY,1);
      }
    }
  }

  // ok, nun noch andere Objekte informieren.
  _informunwear(worn_by,silent,all);

  // Fertig mit dem Anziehen. Vorgang beenden bzw. mit anderen
  // Ruestungen fortfahren
  return !all;
}

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

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

void doUnwearMessage	(	object	worn_by,
		int	all
	)

Definiert in Zeile 116 der Datei wear.c.

Benutzt break_string(), BS_LEAVE_MY_LFS, ME, msg(), name, Name(), P_UNWEAR_MSG, QueryProp(), replace_personal(), WEN und WER.

{
  string *str,s1;
  mixed msg;

  if(!objectp(worn_by)) { // Na huch, gar nicht angezogen? Abbruch.
    return;
  }

  if(msg=QueryProp(P_UNWEAR_MSG)) { // Ist eine UnwearMsg gesetzt?
    if(closurep(msg)) { // Oho! Gar gleich als Fkt.?

      str = funcall(msg, worn_by);
      if(interactive(worn_by)) {
         tell_object(worn_by,break_string(str[0], 78,
                                 (all?(Name(WER)+": "):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 (wenn das kein Raum sein sollte,
      //macht tell_room() nix). 
      if ( objectp(environment(worn_by)) )
          tell_room(environment(environment()),
              break_string(str[1],78, 0, BS_LEAVE_MY_LFS),({ worn_by }) );
      
      return;
    }
    else if(interactive(worn_by)) {
      s1 = replace_personal(sprintf(msg[0],"@WEN2"),
                      ({worn_by,ME}), 1);

      tell_object(worn_by,break_string(s1,78,
                              (all?(Name(WER)+": "):0), BS_LEAVE_MY_LFS));
    }

    s1 = replace_personal(sprintf(msg[1],"@WER1","@WENU2"),
                    ({worn_by, ME }), 1);

    if ( objectp(environment(worn_by)) )
        tell_room(environment(environment()),
            break_string(s1,78, 0, BS_LEAVE_MY_LFS),({ worn_by }) );
    return;
  }
  /*
   * Keine UnwearMsg gesetzt. Ausgabe der Default-Meldungen.
   */
  else if(interactive(worn_by)) {
    tell_object(worn_by,break_string("Du ziehst " + name(WEN,1) + " aus.",78,
     (all?(Name(WER)+": "):0)));
  }
  if ( objectp(environment(worn_by)) )
      tell_room(environment(environment()), break_string(worn_by->Name(WER)
            + " zieht " + name(WEN,0) + " aus.",78), ({ worn_by }) );
}

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

varargs int DoWear	(	int	silent,
		int	all
	)

Definiert in Zeile 255 der Datei wear.c.

Benutzt _check_wear_restrictions(), _informwear(), _wear(), break_string(), ME, Name(), P_ATTACK_BUSY, P_EQUIP_TIME, P_LAST_WEAR_ACTION, P_WEAPON_TYPE, P_WORN, PL, QueryProp(), SetProp(), WA_WEAR und WER.

Wird benutzt von _do_wear().

                                        {
  int nh;

  // Bedingungen pruefen, _check_restrictions() gibt die notwendigen Meldungen
  // an den Spieler aus.
  int res = _check_wear_restrictions(silent, all);
  if (res == -1)
    return(0);
  else if (res <= -2)
    return(!all);

  // Der Check auf freie Haende muss nach allen anderen Checks aus Kleidung
  // und Ruestung erfolgen und ist im Prinzip identisch fuer beide. Daher wird
  // der hier in dieser Funktion gemacht.
  // Soll das Objekt Haende "benutzen"? Steht da auch wirklich ein
  // Integer-Wert drin? ich mach da jetzt ein raise_error(), das soll
  // schliesslich gefixt werden. Ausserdem spart es nen Workaround beim
  // Ausziehen.
  if (!intp(nh=QueryProp(P_NR_HANDS))) {
    raise_error(sprintf("Invalid P_NR_HANDS in %O",object_name()));
  }
  // Wenn Haende benutzt werden sollen, muss natuerlich auch getestet
  // werden, ob das ueberhaupt geht
  if (nh>0) {
    if (!(PL->UseHands(ME, nh))) {
      // Schade, nicht genug Haende frei -> Meldung ausgeben
      write(break_string("Du hast keine Hand mehr frei.",78,
            (all?(Name(WER)+": "):0)));
      return(!all);
    }
  }

  // OK, die Ruestung kann angezogen werden.
  // Behinderung beim Wechsel nur fuer Spieler
  if (query_once_interactive(PL))
  // Wenn das Ganze ,,wirklich'' eine Kleidung/Ruestung ist und kein SMS
  // oder aehnliches...
  if (!QueryProp(P_WEAPON_TYPE)) {
    // Aktion noch setzen, Spieler hat ja was angezogen
    PL->SetProp(P_LAST_WEAR_ACTION,({WA_WEAR,time()}));
    // Im Kampf verliert der Spieler durch Kleidungswechsel eine Runde.
    if (PL->InFight()) {
      PL->SetProp(P_ATTACK_BUSY,1);
    }
  }
  // Eintragen in P_CLOTHING/P_ARMOURS
#if __BOOT_TIME__ < 1234737458
  _wear();
#else
  PL->Wear(this_object());
#endif

  PL->SetProp(P_EQUIP_TIME,time());
  SetProp(P_WORN, PL);
  SetProp(P_EQUIP_TIME,time());

  // ggf. andere Objekte informieren etc.
  _informwear(silent, all);

  // Fertig mit dem Anziehen. Vorgang beenden bzw. mit anderen
  // Ruestungen fortfahren
  return !all;
}

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

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

varargs void doWearMessage

(

int

all

)

Definiert in Zeile 60 der Datei wear.c.

Benutzt break_string(), BS_LEAVE_MY_LFS, ME, name, Name(), P_WEAR_MSG, PL, QueryProp(), replace_personal(), WEN und WER.

                                    {
  string *str,s1;
  mixed wearmsg;

  if(wearmsg=QueryProp(P_WEAR_MSG)) { // Ist eine WearMsg gesetzt?
    if(closurep(wearmsg)) { // Evtl. gar als extra Fkt.?

      str = funcall(wearmsg, PL);
      if(interactive(PL)) {
         // Im Falle, dass all gesetzt ist, wird als Indent der Name des
         // angezogenen Objektes gesetzt. (trag alles)
         write(break_string(str[0],78,
                (all?(Name(WER)+": "):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 (wenn das kein Raum sein sollte,
      //was durchaus sein koennte, macht tell_room() nix). 
      if ( objectp(environment()) && objectp(environment(environment())) )
          tell_room(environment(environment()),
            break_string(str[1], 78, 0, BS_LEAVE_MY_LFS),({PL}) );

      return;
    }
    else if(interactive(PL)) {
      s1 = replace_personal(sprintf(wearmsg[0],"@WEN2"), ({PL,ME}), 1);

      write(break_string(s1,78,(all?(Name(WER)+": "):0), BS_LEAVE_MY_LFS));
    }

    s1 = replace_personal(sprintf(wearmsg[1],"@WER1","@WENU2"),
                            ({PL, ME}), 1);
 
    if ( objectp(environment()) && objectp(environment(environment())) )
        tell_room(environment(environment()),
            break_string(s1, 78, 0, BS_LEAVE_MY_LFS),({ PL }) );

    return;
  }
  /*
   * Keine WearMsg gesetzt. Ausgabe der Default-Meldungen.
   */
  else if(interactive(PL)) {
    write(break_string("Du ziehst " + name(WEN,1) + " an.",78,
     (all?(Name(WER)+": "):0)));
  }
  if ( objectp(environment()) && objectp(environment(environment())) )
      tell_room(environment(environment()),break_string(PL->Name(WER)
            + " zieht " + name(WEN,0) +" an.",78), ({PL}));
}

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

protected void InformUnwear	(	object	pl,
		int	silent,
		int	all
	)

Definiert in Zeile 181 der Datei wear.c.

Wird benutzt von _informunwear().

                                                            {
    return;
}

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

protected void InformWear	(	object	pl,
		int	silent,
		int	all
	)

Definiert in Zeile 175 der Datei wear.c.

Wird benutzt von _informwear().

                                                          {
    return;
}

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

public status IsClothing

(

)

Definiert in Zeile 598 der Datei wear.c.

{return 1;}

protected void msg	(	string	str,
		mixed	fl
	)

Definiert in Zeile 44 der Datei wear.c.

Benutzt _notify_fail().

                                         {
  if (!stringp(str)) {
    return;
  }
  if (fl) {
    write(str);
  }
  else {
    _notify_fail(str);
  }
}

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

mixed* QueryFlaw

(

)

Definiert in Zeile 594 der Datei wear.c.

Benutzt dtime(), flaw und ftime.

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

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

varargs void TakeFlaw	(	mixed	dam_types,
		mapping	einfos
	)

Definiert in Zeile 578 der Datei wear.c.

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

                                                      {   
  int quality;

  // Ist der Ruestung eine Qualitaet gesetzt worden, so kann es zu einer
  // allmaehlichen Beschaedigung der Ruestung kommen. Im if() flaw gleich
  // hochzaehlen.
  if ((quality=QueryProp(P_QUALITY)) && !((++flaw) % quality)) {      
    Damage(1);
  }

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

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

int ziehe

(

string

str

)

Definiert in Zeile 534 der Datei wear.c.

Benutzt do_unwear(), do_wear() und ob().

                      {   
  string ob;

  // Uebergebenes Argument pruefen
  if (!stringp(str)) {
    return 0;  
  }

  // Ist ANziehen gemeint?
  if (sscanf(str, "%s an", ob)==1) {
      return do_wear(ob );
  }

  // Oder ist AUSziehen gemeint?
  if (sscanf(str, "%s aus", ob)==1 ) { 
      return do_unwear(ob);
  }

  // Ok, es geht wohl weder ums an- noch ums ausziehen
  return 0;
}

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

---

Variablen-Dokumentation

nosave int flaw

Definiert in Zeile 27 der Datei wear.c.

Wird benutzt von create(), QueryFlaw() und TakeFlaw().

nosave int ftime

Definiert in Zeile 27 der Datei wear.c.

Wird benutzt von create(), QueryFlaw() und TakeFlaw().