life.c-Dateireferenz

#include <hook.h>
#include <living/skills.h>
#include <thing/properties.h>
#include <thing.h>
#include <config.h>
#include <health.h>
#include <wizlevels.h>
#include <language.h>
#include <moving.h>
#include <defines.h>
#include <combat.h>
#include <new_skills.h>
#include <living.h>
#include <scoremaster.h>
#include <defuel.h>
#include <debug_info.h>
#include <events.h>

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
#define	ALCOHOL_VALUE(n)   n
Funktionen
private void	DistributeExp (object enemy, int exp_to_give)
protected void	create ()
public int	do_damage (int dam, mixed enemy)
private void	_transfer (object *obs, mixed dest, int flag)
public varargs void	transfer_all_to (mixed dest, int isnpc)
protected varargs void	create_kill_log_entry (string killer, object enemy)
protected object	GiveKillScore (object pl, int npcnum)
public int	death_suffering ()
varargs protected int	second_life (object corpse)
public varargs void	die (int poisondeath, int extern)
public void	heal_self (int h)
public int	defuel_food ()
public int	defuel_drink ()
public void	reduce_spell_points (int h)
public void	restore_spell_points (int h)
public int	reduce_hit_points (int dam)
public int	restore_hit_points (int heal)
public varargs int	drink_alcohol (int strength, int testonly, string mytext)
public varargs int	drink_soft (int strength, int testonly, string mytext)
public varargs int	eat_food (int strength, int testonly, string mytext)
public int	buffer_hp (int val, int rate)
public int	buffer_sp (int val, int rate)
protected void	update_buffers ()
public int	check_and_update_timed_key (int duration, string key)
protected void	expire_timing_map ()
protected void	heart_beat ()
public void	show_age ()
public int	AddExp (int e)
static mixed *	_set_last_xp (mixed last)
static int	_set_align (int a)
static int	_set_hp (int hp)
static int	_set_sp (int sp)
static int	_set_alcohol (int n)
static int	_set_drink (int n)
static int	_set_food (int n)
static int	_set_poison (int n)
static int	_query_age ()
static int	_set_xp (int xp)
static mixed	_set_die_hook (mixed hook)
static mapping	_query_enemy_damage ()
static mapping	_query_timing_map ()
public varargs int	consume (mapping cinfo, int testonly)
Variablen
int	age
nosave int	delay_alcohol
nosave int	delay_drink
nosave int	delay_food
nosave int	delay_heal
nosave int	delay_sp
nosave int	delay_poison
nosave int	drop_poison
nosave mapping	enemy_damage
nosave mapping	hp_buffer
nosave mapping	sp_buffer
nosave int	remove_me
int	nextdefueltimefood
int	nextdefueltimedrink

---

Makro-Dokumentation

#define ALCOHOL_VALUE

(

n

)

n

Definiert in Zeile 45 der Datei life.c.

Wird benutzt von drink_alcohol().

#define NEED_PROTOTYPES

Definiert in Zeile 27 der Datei life.c.

---

Dokumentation der Funktionen

static int _query_age

(

)

[static]

Definiert in Zeile 1443 der Datei life.c.

Benutzt age, F_VALUE, P_AGE und Set().

{ return Set(P_AGE, age, F_VALUE); }

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

static mapping _query_enemy_damage

(

)

[static]

Definiert in Zeile 1458 der Datei life.c.

Benutzt enemy_damage.

{
  return copy(enemy_damage);
}

static mapping _query_timing_map

(

)

[static]

Definiert in Zeile 1464 der Datei life.c.

Benutzt P_TIMING_MAP und Query().

                                   {
  return copy(Query(P_TIMING_MAP));
}

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

static int _set_alcohol

(

int

n

)

[static]

Definiert in Zeile 1273 der Datei life.c.

Benutzt F_VALUE, H_ALTERED, H_CANCELLED, H_HOOK_ALCOHOL, H_RETCODE, H_RETDATA, HookFlow(), P_ALCOHOL, P_GHOST, Query(), QueryProp() und Set().

{
  if(!intp(n))
      raise_error(sprintf(
        "_set_alcohol(): expected <int>, got %.50O\n", n));

  if (QueryProp(P_GHOST))
    return Query(P_ALCOHOL, F_VALUE);

  // nur Änderungen und Werte >=0 werden gesetzt...
  n = n < 0 ? 0 : n;
  int old = Query(P_ALCOHOL, F_VALUE);
  if ( old == n)
    return old;

  // Hooks aufrufen
  int *ret = HookFlow(H_HOOK_ALCOHOL, n);
  // Bei Abbruch alten Wert zurueckgeben
  switch (ret[H_RETCODE]) {
    case H_CANCELLED:
      return old;
    case H_ALTERED:
      // sonst neuen Wert setzen
      if(!intp(ret[H_RETDATA]))
          raise_error(sprintf(
            "_set_alcohol(): data from HookFlow() != <int>: %.50O\n",
            ret[H_RETDATA]));
      n = ret[H_RETDATA];
      n = n < 0 ? 0 : n;

    // H_NO_MOD is fallthrough
  }

  return Set(P_ALCOHOL, n, F_VALUE);
}

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

static int _set_align

(

int

a

)

[static]

Definiert in Zeile 1215 der Datei life.c.

Benutzt P_ALIGN und Set().

{
  if (a<-1000) a = -1000;
  if (a>1000) a = 1000;
  return Set(P_ALIGN, a);
}

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

static mixed _set_die_hook

(

mixed

hook

)

[static]

Definiert in Zeile 1447 der Datei life.c.

Benutzt dtime(), F_VALUE, log_file, P_TMP_DIE_HOOK und Set().

{
  if(hook && query_once_interactive(this_object()))
    log_file("DIE_HOOK",
             sprintf("%s : DIE_HOOK gesetzt von %O in %O (%s)\n",
                     dtime(time())[5..],
                     (previous_object(2) ? previous_object(2):previous_object(1)),
                     this_object(),getuid(this_object())));
  return Set(P_TMP_DIE_HOOK,hook, F_VALUE);
}

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

static int _set_drink

(

int

n

)

[static]

Definiert in Zeile 1309 der Datei life.c.

Benutzt F_VALUE, H_ALTERED, H_CANCELLED, H_HOOK_DRINK, H_RETCODE, H_RETDATA, HookFlow(), P_DRINK, P_GHOST, Query(), QueryProp() und Set().

{
  if(!intp(n))
      raise_error(sprintf(
        "_set_drink(): expected <int>, got %.50O\n", n));

  if (QueryProp(P_GHOST))
    return Query(P_DRINK, F_VALUE);

  // nur Änderungen und Werte >=0 werden gesetzt...
  n = n < 0 ? 0 : n;
  int old = Query(P_DRINK, F_VALUE);
  if ( old == n)
    return old;

  // Hooks aufrufen
  int *ret = HookFlow(H_HOOK_DRINK, n);
  // Bei Abbruch alten Wert zurueckgeben
  switch (ret[H_RETCODE]) {
    case H_CANCELLED:
      return old;
    case H_ALTERED:
      // sonst neuen Wert setzen
      if(!intp(ret[H_RETDATA]))
          raise_error(sprintf(
            "_set_drink(): data from HookFlow() != <int>: %.50O\n",
            ret[H_RETDATA]));
      n = ret[H_RETDATA];
      n = n < 0 ? 0 : n;

    // H_NO_MOD is fallthrough
  }

  return Set(P_DRINK, n, F_VALUE);
}

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

static int _set_food

(

int

n

)

[static]

Definiert in Zeile 1345 der Datei life.c.

Benutzt F_VALUE, H_ALTERED, H_CANCELLED, H_HOOK_FOOD, H_RETCODE, H_RETDATA, HookFlow(), P_FOOD, P_GHOST, Query(), QueryProp() und Set().

{
  if(!intp(n))
      raise_error(sprintf(
        "_set_food(): expected <int>, got %.50O\n", n));

  if (QueryProp(P_GHOST))
    return Query(P_FOOD, F_VALUE);

  // nur Änderungen und Werte >=0 werden gesetzt...
  n = n < 0 ? 0 : n;
  int old = Query(P_FOOD, F_VALUE);
  if ( old == n)
    return old;

  // Hooks aufrufen
  int *ret = HookFlow(H_HOOK_FOOD, n);
  // Bei Abbruch alten Wert zurueckgeben
  switch (ret[H_RETCODE]) {
    case H_CANCELLED:
      return old;
    case H_ALTERED:
      // sonst neuen Wert setzen
      if(!intp(ret[H_RETDATA]))
          raise_error(sprintf(
            "_set_food(): data from HookFlow() != <int>: %.50O\n",
            ret[H_RETDATA]));
      n = ret[H_RETDATA];
      n = n < 0 ? 0 : n;

    // H_NO_MOD is fallthrough
  }

  return Set(P_FOOD, n, F_VALUE);
}

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

static int _set_hp

(

int

hp

)

[static]

Definiert in Zeile 1223 der Datei life.c.

Benutzt debug_info(), DINFO_TRACE, DIT_STR_CURRENT, log_file, P_GHOST, P_HP, P_MAX_HP, QueryProp() und Set().

{
    //einige Leute schreiben floats in die P_HP. :-(
    if (!intp(hp)) {
                hp=to_int(hp);
                //ja, es ist teuer. Aber ich will wissen, wers ist. Kann vor
                //naechstem Reboot wieder raus.
                log_file("ILLEGAL_TYPE.log",sprintf(
                      "Versuch, einen nicht-int in P_HP in %O zu schreiben: \n%O\n",
                      this_object(),
                      debug_info(DINFO_TRACE,DIT_STR_CURRENT)));
    }

    if ( QueryProp(P_GHOST) )
        return hp;

    if ( hp < 0 )
        return Set( P_HP, 0 );

    if ( hp > QueryProp(P_MAX_HP) )
        return Set( P_HP, QueryProp(P_MAX_HP) );

    return Set( P_HP, hp );
}

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

static mixed* _set_last_xp

(

mixed

last

)

[static]

Definiert in Zeile 1205 der Datei life.c.

Benutzt P_LAST_XP, Query() und Set().

{
    if ( !pointerp(last) || sizeof(last) != 2 || !stringp(last[0]) ||
         !intp(last[1]) )
        return Query(P_LAST_XP);
    else
        return Set( P_LAST_XP, last );
}

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

static int _set_poison

(

int

n

)

[static]

Definiert in Zeile 1381 der Datei life.c.

Benutzt drop_poison, dtime(), F_VALUE, H_ALTERED, H_CANCELLED, H_HOOK_POISON, H_RETCODE, H_RETDATA, HookFlow(), log_file, MAX_POISON, name, P_GHOST, P_POISON, Query(), QueryProp(), Set() und WER.

{
    if(!intp(n))
      raise_error(sprintf(
        "_set_poison(): expected <int>, got %.50O\n", n));

  if (QueryProp(P_GHOST))
    return Query(P_POISON, F_VALUE);

  n = (n<0 ? 0 : (n>MAX_POISON ? MAX_POISON : n));

  // nur >=0 zulassen.
  n = n < 0 ? 0 : n;

  int old = Query(P_POISON, F_VALUE);
  if ( old == 0 && n == 0)
    return old;

  // Hooks aufrufen
  int *ret = HookFlow(H_HOOK_POISON, n);
  // Bei Abbruch alten Wert zurueckgeben
  switch (ret[H_RETCODE]) {
    case H_CANCELLED:
      return old;
    case H_ALTERED:
      // sonst neuen Wert setzen
      if(!intp(ret[H_RETDATA]))
          raise_error(sprintf(
            "_set_poison(): data from HookFlow() != <int>: %.50O\n",
            ret[H_RETDATA]));
      n = ret[H_RETDATA];
      n = n < 0 ? 0 : n;

    // H_NO_MOD is fallthrough
  }

  // Fuer die Selbstheilung.
  switch(n) {
  case 1:
    drop_poison = 40+random(16);
    break;
  case 2:
    drop_poison = 25+random(8);
    break;
  case 3:
    drop_poison = 18+random(4);
    break;
  }

  log_file("POISON", sprintf("%s - %s: %d von %O (%s)\n",
           dtime(time())[5..],
           (query_once_interactive(this_object()) ?
             capitalize(geteuid(this_object())) :
             capitalize(name(WER))),
           n,
           (previous_object(2) ? previous_object(2) : previous_object(1)),
           (this_player() ? capitalize(geteuid(this_player())) : "???")));

  return Set(P_POISON, n, F_VALUE);

}

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

static int _set_sp

(

int

sp

)

[static]

Definiert in Zeile 1248 der Datei life.c.

Benutzt debug_info(), DINFO_TRACE, DIT_STR_CURRENT, log_file, P_GHOST, P_MAX_SP, P_SP, QueryProp() und Set().

{
    //einige Leute schreiben floats in die P_HP. :-(
    if (!intp(sp)) {
                sp=to_int(sp);
                //ja, es ist teuer. Aber ich will wissen, wers ist. Kann vor
                //naechstem Reboot wieder raus.
                log_file("ILLEGAL_TYPE.log",sprintf(
                      "Versuch, einen nicht-int in P_SP in %O zu schreiben: \n%O\n",
                      this_object(),
                      debug_info(DINFO_TRACE,DIT_STR_CURRENT)));
    }

    if ( QueryProp(P_GHOST) )
        return sp;

    if ( sp < 0 )
        return Set( P_SP, 0 );

    if ( sp > QueryProp(P_MAX_SP) )
        return Set( P_SP, QueryProp(P_MAX_SP) );

    return Set( P_SP, sp );
}

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

static int _set_xp

(

int

xp

)

[static]

Definiert in Zeile 1445 der Datei life.c.

Benutzt F_VALUE, P_XP und Set().

{ return Set(P_XP, xp < 0 ? 0 : xp, F_VALUE); }

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

private void _transfer	(	object *	obs,
		mixed	dest,
		int	flag
	)

Definiert in Zeile 284 der Datei life.c.

Benutzt call_out(), i, move() und P_NEVERDROP.

{   int i;

    i = sizeof(obs);

    // Eine Schleife ist zwar langsamer als filter() o.ae., aber
    // selbst mit einer noch so schnellen Loesung kann leider nicht
    // ausgeschlossen werden, dass irgendwo ein too-long-eval-Bug dazwischen
    // kommt. Dazu sind die Kaempfe mit Gilden-NPCs etc. einfach zu teuer ...
    // Pruefung auf zerstoerte Objekte, da einige sich evtl. im NotifyPlayerDeath() 
    // zerstoeren.
   while ( i && get_eval_cost() > 300000 )
        if ( objectp(obs[--i]) && !obs[i]->QueryProp(P_NEVERDROP) )
        // Jetzt wird's noch etwas teurer mit catch() - aber manche Sachen
        // duerfen einfach nicht buggen
            catch( obs[i]->move( dest, flag );publish );

    if ( i > 0 )
        // Zuviel Rechenzeit verbraten, es muessen noch Objekte bewegt werden
        call_out( #'_transfer, 0, obs[0..i-1], dest, flag );
    else {
        if ( remove_me )
            remove();
    }
}

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

public int AddExp

(

int

e

)

Definiert in Zeile 1180 der Datei life.c.

Benutzt last, P_KILLS, P_LAST_XP, P_XP, Query(), QueryProp(), Set() und SetProp().

Wird benutzt von DeleteQuest() und GiveQuest().

{
  int experience;
  string fn;
  mixed last;

  experience = QueryProp(P_XP);

  if ( QueryProp(P_KILLS) > 1 && e > 0 )
      return experience;

  fn = implode( explode( object_name( environment() || this_object() ),
                               "/" )[0..<2], "/" );

  if ( pointerp(last = Query(P_LAST_XP)) && sizeof(last) == 2 && last[0] == fn )
      Set( P_LAST_XP, ({ fn, last[1]+e }) );
  else
      Set( P_LAST_XP, ({ fn, e }) );

  if ( (experience += e) < 0 )
      experience = 0;

  return SetProp( P_XP, experience );
}

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

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

public int buffer_hp	(	int	val,
		int	rate
	)

Definiert in Zeile 829 der Datei life.c.

Benutzt hp_buffer, P_MAX_HP und QueryProp().

Wird benutzt von consume().

{
  int dif;

  if(val<=0 || rate<=0)return 0;
  if(val < rate)rate = val;
  if(rate>20) rate=20;

  /* Check for BufferOverflow */
  if((dif=(hp_buffer[0]+val)-QueryProp(P_MAX_HP)) > 0)val-=dif;
  if(val<=0)return 0;

  hp_buffer[0] += val;
  hp_buffer[1+rate] += val;
  if(rate > hp_buffer[1])hp_buffer[1] = rate;

  return hp_buffer[0];
}

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

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

public int buffer_sp	(	int	val,
		int	rate
	)

Definiert in Zeile 848 der Datei life.c.

Benutzt P_MAX_SP, QueryProp() und sp_buffer.

Wird benutzt von consume().

{
  int dif;

  if(val<=0 || rate<=0)return 0;
  if(val < rate)rate = val;
  if(rate>20) rate=20;

  /* Check for BufferOverflow */
  if((dif=(sp_buffer[0]+val)-QueryProp(P_MAX_SP)) > 0)val-=dif;
  if(val<=0)return 0;

  sp_buffer[0] += val;
  sp_buffer[1+rate] += val;
  if(rate > sp_buffer[1])sp_buffer[1] = rate;

  return sp_buffer[0];
}

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

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

public int check_and_update_timed_key	(	int	duration,
		string	key
	)

Definiert in Zeile 899 der Datei life.c.

Benutzt P_TIMING_MAP, Query() und SetProp().

                                                               {
  mapping tmap;

  if (!intp(duration) || !stringp(key))
    return 0;
  if (!mappingp(tmap=Query(P_TIMING_MAP))) {
    tmap=([]);
    SetProp(P_TIMING_MAP, tmap);
  }
  if (duration < 0)
    return tmap[key];
  if (tmap[key] >= time())
    return tmap[key];
  
  tmap[key]=time()+duration;
  
  // speichern per SetProp() unnoetig, da man das Mapping direkt aendert,
  // keine Kopie.
  //SetProp(P_TIMING_MAP, tmap);
  
  return -1;
}

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

public varargs int consume	(	mapping	cinfo,
		int	testonly
	)

Definiert in Zeile 1484 der Datei life.c.

Benutzt buffer_hp(), buffer_sp(), drink_alcohol(), drink_soft(), eat_food(), H_ALLOWED_EFFECTS, H_ALTERED, H_CANCELLED, H_CONDITIONS, H_DISTRIBUTION, H_EFFECTS, H_HOOK_CONSUME, H_RETCODE, H_RETDATA, HC_HOOK_CANCELLATION, HC_MAX_ALCOHOL_REACHED, HC_MAX_DRINK_REACHED, HC_MAX_FOOD_REACHED, HD_INSTANT, HD_STANDARD, HookFlow(), P_ALCOHOL, P_DRINK, P_FOOD, P_HP, P_POISON, P_SP, QueryProp() und SetProp().

{
  int retval = 0;
  // nur was tun, wenn auch Infos reinkommen
  if (mappingp(cinfo) && sizeof(cinfo)) {
    // Hooks aufrufen, sie aendern ggf. noch was in cinfo.
    mixed *hret = HookFlow(H_HOOK_CONSUME, ({cinfo, testonly}) );
    switch(hret[H_RETCODE]) {
        case H_CANCELLED:
          return -HC_HOOK_CANCELLATION;
        case H_ALTERED:
          cinfo = hret[H_RETDATA];
    }
    // Legacy-Mappings (flache) neben strukturierten Mappings zulassen
    // flache Kopien erzeugen (TODO?: und fuer Teilmappings nicht relevante
    // Eintraege loeschen)
    mapping conditions;
    if (mappingp(cinfo[H_CONDITIONS])) {
      conditions = copy(cinfo[H_CONDITIONS]);
    } else {
      conditions = copy(cinfo);
    }
    mapping effects;
    if (mappingp(cinfo[H_EFFECTS])) {
      effects = filter(cinfo[H_EFFECTS], (: member(H_ALLOWED_EFFECTS, $1) > -1 :));
    } else {
      effects = filter(cinfo, (: member(H_ALLOWED_EFFECTS, $1) > -1 :));
    }

    // Bedingungen pruefen
    if (mappingp(conditions) && sizeof(conditions)) {
      // Bedingungen fuer Konsum auswerten
      if (conditions[P_FOOD] && !eat_food(conditions[P_FOOD], 1))
        retval |= HC_MAX_FOOD_REACHED;
      else if (conditions[P_DRINK] && !drink_soft(conditions[P_DRINK], 1))
        retval |= HC_MAX_DRINK_REACHED;
      else if (conditions[P_ALCOHOL] && !drink_alcohol(conditions[P_ALCOHOL], 1))
        retval |= HC_MAX_ALCOHOL_REACHED;
      // retval negativ machen, damit Fehler leicht erkennbar ist
      retval = -retval;
    }
    // Bedingungen wurden abgearbeitet, jetzt die Heilung durchfuehren
    if (!retval) {
      if (!testonly) {
        // Bedingungen erfuellen, wenn alles passt und kein Test
        if (conditions[P_ALCOHOL])
          drink_alcohol(conditions[P_ALCOHOL]);
        if (conditions[P_DRINK])
          drink_soft(conditions[P_DRINK]);
        if (conditions[P_FOOD])
          eat_food(conditions[P_FOOD]);
        // Und jetzt die Wirkungen
        if (effects[P_POISON])
          SetProp(P_POISON, QueryProp(P_POISON) + effects[P_POISON]);
        // Und nun wirklich heilen
        switch (cinfo[H_DISTRIBUTION]) {
        case HD_INSTANT:
          map(effects, (: SetProp($1, QueryProp($1) + $2) :));
          break;
        case 1..50:
          buffer_hp(effects[P_HP], cinfo[H_DISTRIBUTION]);
          buffer_sp(effects[P_SP], cinfo[H_DISTRIBUTION]);
          break;
        default:
          buffer_hp(effects[P_HP], HD_STANDARD);
          buffer_sp(effects[P_SP], HD_STANDARD);
          break;
        }
      }
      retval = 1;
    }
  }
  return retval;
}

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

protected void create

(

)

Definiert in Zeile 73 der Datei life.c.

Benutzt ALCOHOL_DELAY, DRINK_DELAY, enemy_damage, F_MODE, F_MODE_AS, F_SET_METHOD, FOOD_DELAY, H_HOOK_ALCOHOL, H_HOOK_CONSUME, H_HOOK_DIE, H_HOOK_DRINK, H_HOOK_FOOD, H_HOOK_POISON, HEAL_DELAY, hp_buffer, nextdefueltimedrink, nextdefueltimefood, offerHook(), P_AGE, P_ALCOHOL, P_ALCOHOL_DELAY, P_ALIGN, P_CORPSE, P_DEAF, P_DEFUEL_AMOUNT_DRINK, P_DEFUEL_AMOUNT_FOOD, P_DEFUEL_LIMIT_DRINK, P_DEFUEL_LIMIT_FOOD, P_DEFUEL_TIME_DRINK, P_DEFUEL_TIME_FOOD, P_DRINK, P_DRINK_DELAY, P_FOOD, P_FOOD_DELAY, P_FROG, P_GHOST, P_HP, P_HP_DELAY, P_LAST_XP, P_POISON, P_POISON_DELAY, P_SP, P_SP_DELAY, P_XP, POISON_DELAY, PROTECTED, QueryProp(), SAVE, Set(), SetProp() und sp_buffer.

{
  Set(P_GHOST, SAVE, F_MODE);
  Set(P_FROG, SAVE, F_MODE);
  Set(P_ALIGN, SAVE, F_MODE);
  Set(P_HP, SAVE, F_MODE);
  Set(P_SP, SAVE, F_MODE);
  Set(P_XP, SAVE, F_MODE);
  Set( P_LAST_XP, ({ "", 0 }) );
  Set( P_LAST_XP, PROTECTED, F_MODE_AS );

  Set(P_ALCOHOL, SAVE, F_MODE);
  Set(P_DRINK, SAVE, F_MODE);
  Set(P_FOOD, SAVE, F_MODE);
  Set(P_POISON, SAVE, F_MODE);
  Set(P_DEAF, SAVE, F_MODE);

  SetProp(P_FOOD_DELAY, FOOD_DELAY);
  SetProp(P_DRINK_DELAY, DRINK_DELAY);
  SetProp(P_ALCOHOL_DELAY, ALCOHOL_DELAY);
  SetProp(P_HP_DELAY,HEAL_DELAY);
  SetProp(P_SP_DELAY,HEAL_DELAY);
  SetProp(P_POISON_DELAY,POISON_DELAY);

  Set(P_AGE, -1, F_SET_METHOD);
  Set(P_AGE, PROTECTED, F_MODE);
  SetProp(P_CORPSE, "/std/corpse");

  nextdefueltimefood=time()+QueryProp(P_DEFUEL_TIME_FOOD);
  nextdefueltimedrink=time()+QueryProp(P_DEFUEL_TIME_DRINK);

  enemy_damage=([:2 ]);
  hp_buffer=([]);
  sp_buffer=([]);

  SetProp(P_DEFUEL_LIMIT_FOOD,1);
  SetProp(P_DEFUEL_LIMIT_DRINK,1);
  SetProp(P_DEFUEL_TIME_FOOD,1);
  SetProp(P_DEFUEL_TIME_DRINK,1);
  SetProp(P_DEFUEL_AMOUNT_FOOD,1);
  SetProp(P_DEFUEL_AMOUNT_DRINK,1);

  offerHook(H_HOOK_DIE,1);

  offerHook(H_HOOK_FOOD,1);
  offerHook(H_HOOK_DRINK,1);
  offerHook(H_HOOK_ALCOHOL,1);
  offerHook(H_HOOK_POISON,1);
  offerHook(H_HOOK_CONSUME,1);
}

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

protected varargs void create_kill_log_entry	(	string	killer,
		object	enemy
	)

Definiert in Zeile 335 der Datei life.c.

Wird benutzt von heart_beat().

                                                                          {
  int level,lost_exp;

  if ( (level=QueryProp(P_LEVEL))<20 || !IS_SEER(ME) )
    lost_exp = QueryProp(P_XP)/3;
  else
    lost_exp = QueryProp(P_XP)/(level-17);
  
  log_file("KILLS",sprintf("%s %s (%d,%d) %s\n", strftime("%e %b %H:%M"),
               capitalize(REAL_UID(ME)), level, lost_exp/1000, killer));

  catch(call_other("/p/service/rochus/killstat/killmaster","AddKill",enemy);
      publish);
}

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

public int death_suffering

(

)

Definiert in Zeile 407 der Datei life.c.

Wird benutzt von QuerySkillAttribute() und score().

                             {
  return 0; // NPC haben keine Todesfolgen
}

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

public int defuel_drink

(

)

Definiert in Zeile 682 der Datei life.c.

Benutzt alc, DEFUEL_TOO_LOW, DEFUEL_TOO_SOON, nextdefueltimedrink, NO_DEFUEL, P_ALCOHOL, P_DEFUEL_AMOUNT_DRINK, P_DEFUEL_LIMIT_DRINK, P_DEFUEL_TIME_DRINK, P_DRINK, P_MAX_ALCOHOL, P_MAX_DRINK, P_WEIGHT, QueryProp() und SetProp().

Wird benutzt von defuel_drink().

{
  int alc, drink;

  drink=QueryProp(P_DRINK);

// wenn spieler kein drink hat: return 0
  if ( !drink )
   return NO_DEFUEL;

// wenn spieler unter enttank-grenze: return -1
  if ( drink < QueryProp(P_DEFUEL_LIMIT_DRINK) )
   return DEFUEL_TOO_LOW;

// wenn letztes enttanken nicht lange genug zurueckliegt: return -2
  if ( time() < nextdefueltimedrink )
   return DEFUEL_TOO_SOON;
    
  drink=to_int(((drink*QueryProp(P_DEFUEL_AMOUNT_DRINK))/2));
  drink+=random(drink);

// sicherheitshalber
  if ( drink > QueryProp(P_DRINK) )
   drink=QueryProp(P_DRINK);

  SetProp(P_DRINK,(QueryProp(P_DRINK)-drink));

// jedes fluessige Enttanken macht auch etwas nuechterner :^)
// bei sehr kleinen Mengen enttankt man keinen Alkohol
// ansonsten in Abhaengigkeit von enttankter Menge, P_ALCOHOL und P_WEIGHT

  if ( drink > 9 && QueryProp(P_ALCOHOL) > 0 )
   {
    alc=(to_int(exp(log(1.1)*(drink)))*
         to_int(exp(log(0.67)*(QueryProp(P_ALCOHOL)))))/
         (QueryProp(P_MAX_DRINK)*QueryProp(P_MAX_ALCOHOL))*
         (to_int(QueryProp(P_WEIGHT)/1000));

     SetProp(P_ALCOHOL,QueryProp(P_ALCOHOL)-(alc+random(alc)));
   }

  nextdefueltimedrink=time()+QueryProp(P_DEFUEL_TIME_DRINK);
 
  return drink;
}

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

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

public int defuel_food

(

)

Definiert in Zeile 640 der Datei life.c.

Benutzt DEFUEL_TOO_LOW, DEFUEL_TOO_SOON, food, nextdefueltimefood, NO_DEFUEL, P_DEFUEL_AMOUNT_FOOD, P_DEFUEL_LIMIT_FOOD, P_DEFUEL_TIME_FOOD, P_FOOD, QueryProp() und SetProp().

Wird benutzt von defuel_food().

{
  int food;

  food=QueryProp(P_FOOD);

// wenn spieler kein food hat: return 0
  if ( !food )
   return NO_DEFUEL;

// wenn spieler unter enttank-grenze: return -1
  if ( food < QueryProp(P_DEFUEL_LIMIT_FOOD) )
   return DEFUEL_TOO_LOW;

// wenn letztes enttanken nicht lange genug zurueckliegt: return -2
  if ( time() < nextdefueltimefood )
   return DEFUEL_TOO_SOON;

  food=to_int(((food*QueryProp(P_DEFUEL_AMOUNT_FOOD))/2));
  food+=random(food);

// sicherheitshalber
  if ( food > QueryProp(P_FOOD) )
   food=QueryProp(P_FOOD);

  SetProp(P_FOOD,(QueryProp(P_FOOD)-food));

  nextdefueltimefood=time()+QueryProp(P_DEFUEL_TIME_FOOD);

  return food;
}

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

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

public varargs void die	(	int	poisondeath,
		int	extern
	)

Definiert in Zeile 416 der Datei life.c.

{   object corpse;
    string die_msg, tmp;
    mixed res;
    mixed hookData;
    mixed hookRes;

    if ( !objectp(this_object()) || QueryProp(P_GHOST) )
        return; // Ghosts dont die ...

    if ( res = QueryProp(P_TMP_DIE_HOOK) ){
        if ( pointerp(res) && sizeof(res)>=3
            && intp(res[0]) && time()<res[0]
            && objectp(res[1]) && stringp(res[2]) )
        {
            if ( res = call_other( res[1], res[2], poisondeath ) )
              return;
        }
        else
            SetProp(P_TMP_DIE_HOOK,0);
    }

    // trigger die hook
    hookData=poisondeath;
    hookRes=HookFlow(H_HOOK_DIE,hookData);
    if (pointerp(hookRes) && sizeof(hookRes)>H_RETDATA){
      if(hookRes[H_RETCODE]==H_CANCELLED){
        return;
      }
      else if (hookRes[H_RETCODE]==H_ALTERED)
          poisondeath = hookRes[H_RETDATA];
    }

    if ( IS_LEARNING(ME) && query_once_interactive(ME) ){
       tell_object( ME, "Sei froh dass Du unsterblich bist, sonst waere es "
                        "eben Dein Ende gewesen.\n");
       return;
    }

    // direkt von extern aufgerufen und nicht ueber heart_beat() oder
    // do_damage() hierher gelangt?
    if (extern_call() && previous_object() != this_object()) {
      extern=1;
      SetProp(P_KILLER, previous_object());
    }

    // Gegner befrieden.
    map_objects( QueryEnemies()[0], "StopHuntFor", ME, 1 );
    StopHuntingMode(1);

    // Falls die() direkt aufgerufen wurde und dies ein Spieler ist, muss das
    // die() noch Eintraege in /log/KILLS via create_kill_log_entry bzw. in
    // /log/KILLER erstellen.
    if ( query_once_interactive(ME) && extern )
    {
      object killer = QueryProp(P_KILLER) 
                     || previous_object() || this_interactive() || this_player();
      if ( killer && !query_once_interactive(killer) )
      {
          tmp = explode( object_name(killer), "#")[0] + " (direkt !)";

          create_kill_log_entry( tmp + " (" + REAL_UID(killer) + ")", killer );
      }
      else if ( killer && !QueryProp(P_TESTPLAYER) && !IS_LEARNER(ME) )
      {
          log_file( "KILLER", sprintf( "%s %s (%d/%d) toetete %s (%d/%d)\n",
                                       ctime(time()),
                                       capitalize(getuid(killer)),
                                       query_wiz_level(killer),
                                       killer->QueryProp(P_LEVEL),
                                       capitalize(getuid(ME)),
                                       query_wiz_level(ME),
                                       QueryProp(P_LEVEL) ) );

          killer->SetProp( P_KILLS, -1 );
      }
    }

  // Bei NPC EKs vergeben und ggf. in der Gilde des Killers und im Raum
  // NPC_Killed_By() rufen.
  if ( !query_once_interactive(ME) )
  {
    object killer = ((object) QueryProp(P_KILLER)) || previous_object() ||
      this_interactive() || this_player();

    if ( killer && query_once_interactive(killer) )
    {
      if (stringp(res=killer->QueryProp(P_GUILD))
          && objectp(res=find_object("/gilden/"+res)))
        res->NPC_Killed_By(killer);

      if (environment())
          environment()->NPC_Killed_By(killer);

      res = QueryProp(P_XP);
      res = (res < SCORE_LOW_MARK) ? 0 : ((res > SCORE_HIGH_MARK) ? 2 : 1);
      if ( !QueryProp(P_NO_SCORE) && !IS_LEARNER(killer) &&
           // !killer->QueryProp(P_TESTPLAYER) &&
           pointerp( res = SCOREMASTER->QueryNPC(res)) )
        GiveKillScore( killer, res[0] );
    }
  }

  if( !(die_msg = QueryProp(P_DIE_MSG)) )
    if (QueryProp(P_PLURAL))
      die_msg = " fallen tot zu Boden.\n";
    else
      die_msg = " faellt tot zu Boden.\n";

  if ( poisondeath )
  {
      Set( P_LAST_DAMTYPES, ({ DT_POISON }) );
      Set( P_LAST_DAMTIME, time() );
      Set( P_LAST_DAMAGE, 1 );
      die_msg = " wird von Gift hinweggerafft und kippt um.\n";
  }

  say( capitalize(name(WER,1)) + die_msg );

  // Wenn keine Leiche, dann Kram ins Env legen.
  if ( QueryProp(P_NOCORPSE) || !(tmp = QueryProp(P_CORPSE))
      || catch(corpse = clone_object(tmp);publish) 
      || !objectp(corpse) )
  {
      // Magier oder Testspieler behalten ihre Ausruestung.
      // Sonst kaemen u.U. Spieler an Magiertools etc. heran
      if ( !(IS_LEARNER(ME) || (tmp = Query(P_TESTPLAYER)) &&
             (!stringp(tmp) || IS_LEARNER( lower_case(tmp) ))) )
          transfer_all_to( environment(), 0 );
      else
          // Aber sie ziehen sich aus.
          filter_objects(QueryProp(P_ARMOURS),"DoUnwear",1,1);
  }
  else
  // sonst in die Leiche legen.
  {
      corpse->Identify(ME);
      corpse->move( environment(), M_NOCHECK|M_SILENT );
      // Magier oder Testspieler behalten ihre Ausruestung.
      // Sonst kaemen u.U. Spieler an Magiertools etc. heran
      if ( !(IS_LEARNER(ME) || (tmp = Query(P_TESTPLAYER)) &&
             (!stringp(tmp) || IS_LEARNER( lower_case(tmp) ))) )
          transfer_all_to( corpse, !query_once_interactive(ME) );
      else
          // Aber sie ziehen sich aus.
          filter_objects(QueryProp(P_ARMOURS),"DoUnwear",1,1);
  }

  if ( query_once_interactive(ME) ) {
      Set( P_DEADS, Query(P_DEADS) + 1 );
      // Spieler-Tod-event ausloesen
      EVENTD->TriggerEvent(EVT_LIB_PLAYER_DEATH, ([
      E_OBJECT: ME, E_PLNAME: getuid(ME),
      E_ENVIRONMENT: environment(), E_TIME: time(),
      P_KILLER: QueryProp(P_KILLER),
      P_LAST_DAMAGE: QueryProp(P_LAST_DAMAGE),
      P_LAST_DAMTYPES: copy(QueryProp(P_LAST_DAMTYPES)),
      E_EXTERNAL_DEATH: extern,
      E_POISON_DEATH: poisondeath, 
      E_CORPSE: (objectp(corpse)?corpse:0) ]) );
  }
  else {
      // NPC-Todes-Event ausloesen. Div. Mappings/Arrays werden nicht kopiert,
      // weil der NPC ja jetzt eh zerstoert wird.
      mapping data = ([
            E_OBNAME: object_name(ME),
            E_ENVIRONMENT: environment(), E_TIME: time(),
            P_NAME: QueryProp(P_NAME),
            P_KILLER: QueryProp(P_KILLER),
            P_ENEMY_DAMAGE: QueryProp(P_ENEMY_DAMAGE),
            P_LAST_DAMAGE: QueryProp(P_LAST_DAMAGE),
            P_LAST_DAMTYPES: QueryProp(P_LAST_DAMTYPES),
            E_EXTERNAL_DEATH: extern,
            E_POISON_DEATH: poisondeath,
            E_CORPSE: (objectp(corpse)?corpse:0),
            P_XP: QueryProp(P_XP),
            P_ATTRIBUTES: QueryProp(P_ATTRIBUTES),
            P_MAX_HP: QueryProp(P_MAX_HP),
            P_HANDS: QueryProp(P_HANDS),
            P_ALIGN: QueryProp(P_ALIGN),
            P_RACE: QueryProp(P_RACE),
            P_CLASS: QueryProp(P_CLASS),
            ]);
      EVENTD->TriggerEvent(EVT_LIB_NPC_DEATH(""), data);
      EVENTD->TriggerEvent(
          EVT_LIB_NPC_DEATH(load_name(ME)), data);
  }

  // transfer_all_to() ist evtl. (wenn zuviele Objekte bewegt werden mussten)
  // noch nicht ganz fertig und wird per call_out() den Rest erledigen.
  // Sollte die Leiche dann nicht mehr existieren, verbleiben die restlichen
  // Objekte im Spieler.
  // Es bleiben aber auf jeden Fall noch rund 300k Eval-Ticks ueber, damit
  // kein Spieler dank "evalcost too high" ungeschoren davon kommt.
  if ( !(second_life(corpse)) )
  {
      Set( P_GHOST, 1 ); // Fuer korrekte Ausgabe auf Teamkanal.

      if ( find_call_out(#'_transfer) == -1 )
          // Falls kein call_out() mehr laeuft, sofort destructen ...
          remove();
      else
          // ... ansonsten vormerken
          remove_me = 1;
  }
}

private void DistributeExp	(	object	enemy,
		int	exp_to_give
	)

Definiert in Zeile 124 der Datei life.c.

Benutzt enemy_damage, ex, inv(), m_delete() und ob().

Wird benutzt von do_damage().

                                                          {
  int total_damage, tmp, ex;
  mapping present_enemies;

  if ( exp_to_give<=0 )
    return;

  mapping endmg=deep_copy(enemy_damage);

  // Mitglieder im Team des Killers bekommen:
  //
  //                  Gesamtanteil des Teams
  // Eigenen Anteil + ----------------------
  //                  Anzahl  Teammitglieder
  // ---------------------------------------
  //                2
  //
  object *inv = enemy->TeamMembers();
  if ( pointerp(inv) )
  {
    present_enemies=m_allocate(sizeof(inv), 1);
    foreach(object ob: inv)
    {
      if ( objectp(ob) && (environment(ob)==environment()) )
      {
        tmp=endmg[object_name(ob)];
        total_damage+=tmp;
        present_enemies[ob] = tmp/2;
        efun::m_delete(endmg,object_name(ob)); //s.u.
      }
    }
    int mitglieder = sizeof(present_enemies);
    if ( mitglieder )
    {
      tmp=total_damage/(2*mitglieder);
      foreach(object ob, int punkte: &present_enemies)
        punkte += tmp;
    }
  }
  else {
    // ohne Team wird trotzdem ein Mapping gebraucht. Da Groessenveraenderung
    // rel. teuer sind, kann einfach mal fuer 3 Eintraege Platz reservieren.
    present_enemies=m_allocate(3, 1);
  }
  // Und noch die Lebewesen im Raum ohne Team.
  foreach(object ob: all_inventory(environment()))
  {
    if ( tmp=endmg[object_name(ob)] )
    {
      total_damage += tmp;
      present_enemies[ob] = tmp;
      efun::m_delete(endmg,object_name(ob)); // Nur einmal pro Leben Punkte :)
    }
  }
  if ( !total_damage )
  {
    enemy->AddExp(exp_to_give);
  }
  else
  {
    foreach(object ob, int damage: present_enemies)
    {
      if ( !objectp(ob) )
        continue;
      if ( query_once_interactive(ob) && ( !interactive(ob)
              || (query_idle(ob)>600) ) )
        continue;
      //exp_to_give*present_enemies[i][1]/total_damage gibt bei viel Schaden
      //einen numerical overflow. Daher muessen wir hier wohl doch
      //zwischenzeitlich mit floats rechnen, auch wenn das 0-1 XP Verlust
      //durch float->int-Konversion gibt. (ceil() lohnt sich IMHO nicht.)
      ex = (int)(exp_to_give*((float)damage/(float)total_damage));
      ob->AddExp(ex);
    }
  }
}

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

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

public int do_damage	(	int	dam,
		mixed	enemy
	)

Definiert in Zeile 209 der Datei life.c.

Benutzt die(), DistributeExp(), dtime(), enemy_damage, log_file, ME, P_ALIGN, P_ENABLE_IN_ATTACK_OUT, P_GHOST, P_HELPER_NPC, P_HP, P_KILLER, P_LAST_MOVE, P_MAX_HP, P_NO_ATTACK, P_NO_XP, P_TOTAL_WC, P_XP, QueryProp() und SetProp().

{ int hit_point,al,al2;

  if ( extern_call()
      && objectp(enemy)
      && living(enemy)
      && !QueryProp(P_ENABLE_IN_ATTACK_OUT))
  {
    al=time()-enemy->QueryProp(P_LAST_MOVE);
    if (al<3)      // Erste Kampfrunde nach Betreten des Raumes?
      dam/=(4-al); // Gegen Rein-Feuerball-Raus-Taktik
  }

  if ( QueryProp(P_GHOST) || QueryProp(P_NO_ATTACK) || (dam<=0)
      || ( objectp(enemy)
          && ( enemy->QueryProp(P_GHOST)
              || enemy->QueryProp(P_NO_ATTACK) ) ) )
    return 0;

  hit_point = QueryProp(P_HP)-dam;

  if ( QueryProp(P_XP) && objectp(enemy) )
  {
    if ( !QueryProp(P_NO_XP) )
      enemy->AddExp(dam*(int)QueryProp(P_TOTAL_WC)/10);
  }

  if (living(enemy)) {
      string enname = object_name(enemy);
      // Hmpf. Blueprints sind doof. Die Chance ist zwar gering, aber koennte
      // sein, dass ein Unique-NPC mit zwei verschiedenen Spielern am gleichen
      // NPC metzelt.
      // TODO: MHmm. wie gross ist das Risiko wirklich?
      //if (!clonep(enemy))
      //    enname = enname + "_" + to_string(object_time(enemy));
      // nur wenn gegner NPC ist und noch nicht drinsteht: Daten aus
      // P_HELPER_NPC auswerten
      if (!member(enemy_damage,enemy) && !query_once_interactive(enemy)) {
          mixed helper = enemy->QueryProp(P_HELPER_NPC);
          if (pointerp(helper) && objectp(helper[0]))
              enemy_damage[enname,1] = helper[0];
      }
      enemy_damage[enname,0]+=dam;
  }

  SetProp(P_HP, hit_point);

  if ( hit_point<0 )
  {
    if ( enemy )
    {
      enemy->StopHuntFor(ME,1);
      if ( !QueryProp(P_NO_XP) )
        DistributeExp(enemy,QueryProp(P_XP)/100);
      if ( !query_once_interactive(ME) )
        log_file ("NPC_XP", sprintf(
                    "[%s] %s, XP: %d, HP*WC: %d, Killer: %s\n",
                    dtime(time()), object_name(ME), (QueryProp(P_XP)/100),
                  QueryProp(P_TOTAL_WC)*QueryProp(P_MAX_HP)/10,
                  enemy->name()||"NoName" ));
      al = QueryProp(P_ALIGN)/50 + enemy->QueryProp(P_ALIGN)/200;
      if (al>20)
        al=20;
      else if(al<-20)
        al=-20;
      enemy->SetProp(P_ALIGN,enemy->QueryProp(P_ALIGN)-al);
    }
    SetProp(P_KILLER, enemy);
    
    die();
  }
  return dam;
}

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

public varargs int drink_alcohol	(	int	strength,
		int	testonly,
		string	mytext
	)

Definiert in Zeile 770 der Datei life.c.

Benutzt add, alc, ALCOHOL_VALUE, IS_LEARNING, ME, P_ALCOHOL, P_MAX_ALCOHOL, QueryProp(), SetProp(), SI_SKILLARG, SI_TESTFLAG, SK_BOOZE und UseSkill().

Wird benutzt von consume().

{ int alc,add,res;

  add=ALCOHOL_VALUE(strength);
  res=UseSkill(SK_BOOZE,([
      SI_SKILLARG : add,
      SI_TESTFLAG : 1])); // Kann der Spieler gut saufen?
  if (intp(res) && res>0) add=res;
  alc=QueryProp(P_ALCOHOL)+add;
  if ((alc >= QueryProp(P_MAX_ALCOHOL)) && !IS_LEARNING(this_object())){
    if(!testonly)
      tell_object(ME,mytext||"So ein Pech, Du hast alles verschuettet.\n");
    return 0;
  }
  if(testonly)return 1;
  UseSkill(SK_BOOZE,([ SI_SKILLARG : ALCOHOL_VALUE(strength) ]));
  if(alc < 0) alc = 0;
  if(!alc) tell_object(ME, "Du bist stocknuechtern.\n");
  SetProp(P_ALCOHOL, alc);
  return 1;
}

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

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

public varargs int drink_soft	(	int	strength,
		int	testonly,
		string	mytext
	)

Definiert in Zeile 792 der Datei life.c.

Benutzt DRINK_VALUE, IS_LEARNING, ME, P_DRINK, P_MAX_DRINK, QueryProp() und SetProp().

Wird benutzt von consume().

{ int soaked;

  soaked = QueryProp(P_DRINK);
  if((soaked + strength > QueryProp(P_MAX_DRINK)) &&
     !IS_LEARNING(this_object())){
    if(!testonly)
     tell_object(ME, mytext||
       "Nee, so viel kannst Du momentan echt nicht trinken.\n" );
    return 0;
  }
  if(testonly)return 1;
  if((soaked += DRINK_VALUE(strength)) < 0) soaked = 0;
  if(!soaked) tell_object(ME, "Dir klebt die Zunge am Gaumen.\n");
  SetProp(P_DRINK, soaked);
  return 1;
}

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

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

public varargs int eat_food	(	int	strength,
		int	testonly,
		string	mytext
	)

Definiert in Zeile 810 der Datei life.c.

Benutzt FOOD_VALUE, IS_LEARNING, ME, P_FOOD, P_MAX_FOOD, QueryProp() und SetProp().

Wird benutzt von consume().

{ int stuffed;

  stuffed = QueryProp(P_FOOD);
  if ((stuffed + strength > QueryProp(P_MAX_FOOD)) &&
      !IS_LEARNING(this_object()))
  {
    if(!testonly)tell_object(ME, mytext||
    "Das ist viel zu viel fuer Dich! Wie waers mit etwas leichterem?\n");
    return 0;
  }
  if(testonly)return 1;
  stuffed += FOOD_VALUE(strength);
  if(stuffed < 0) stuffed = 0;
  if(!stuffed) tell_object(ME, "Was rumpelt denn da in Deinem Bauch?\n");
  SetProp(P_FOOD, stuffed);
  return 1;
}

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

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

protected void expire_timing_map

(

)

Definiert in Zeile 922 der Datei life.c.

Benutzt F_VALUE, m_delete(), P_TIMING_MAP und Query().

                                   {
  
  mapping tmap = Query(P_TIMING_MAP, F_VALUE);
  if (!mappingp(tmap) || !sizeof(tmap))
    return;
  foreach(string key, int endtime: tmap) {
    if (endtime < time())
      efun::m_delete(tmap, key);
  }
  // speichern per SetProp() unnoetig, da man das Mapping direkt aendert,
  // keine Kopie.
}

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

protected object GiveKillScore	(	object	pl,
		int	npcnum
	)

Definiert in Zeile 350 der Datei life.c.

{
  // Stufenpunkt fuer den Kill vergeben.
  // Falls der Killer den Punkt schon hat, wird
  // zufaellig ein Mitglied seines Teams ausgewaehlt
  // und diesem der Punkt gegeben.
  object *obs,ob;
  mixed *fr;
  int i,j,sz;

  if ( pointerp(obs=pl->TeamMembers()) && (member(obs,pl)>=0) )
  {
    if ( !pointerp(fr=pl->PresentTeamRows())
        || !sizeof(fr)
        || !pointerp(fr=fr[0])) // Erste Reihe des Teams
      fr=({});
    fr-=({pl,0});
    obs-=({pl,0});
    obs-=fr;
    i=sz=sizeof(obs); // restliche Teammitglieder in zufaelliger Reihenfolge:
    for ( --i ; i>=0 ; i-- )
    {
      j=random(sz);
      ob=obs[j];
      obs[j]=obs[0];
      obs[0]=ob;
    }
    i=sz=sizeof(fr);  // Erste Reihe in zufaelliger Reihenfolge:
    for ( --i ; i>=0 ; i-- )
    {
      j=random(sz);
      ob=fr[j];
      fr[j]=fr[0];
      fr[0]=ob;
    }

    obs+=fr;     // Erste Reihe wird vor Rest getestet
    obs+=({pl}); // Killer wird als erstes getestet
  }
  else
  {
    obs=({pl});
  }
  for ( i=sizeof(obs)-1 ; i>=0 ; i-- )
    if ( objectp(ob=obs[i] )
        && interactive(ob)     // Nur netztot dabei stehen gilt nicht :)
        && query_idle(ob)<600  // gegen Leute die sich nur mitschleppen lassen
        && environment(ob)==environment(pl) // Nur anwesende Teammitglieder
        && !IS_LEARNER(ob)
//        && !ob->QueryProp(P_TESTPLAYER)
        && !(SCOREMASTER->HasKill(ob,ME)) )
      return SCOREMASTER->GiveKill(ob,npcnum),ob;

  return SCOREMASTER->GiveKill(pl,npcnum),pl;
}

public void heal_self

(

int

h

)

Definiert in Zeile 623 der Datei life.c.

Benutzt P_HP, P_SP, QueryProp() und SetProp().

Wird benutzt von SelectWhich().

{
  if ( h<=0 )
    return;
  SetProp(P_HP, QueryProp(P_HP)+h);
  SetProp(P_SP, QueryProp(P_SP)+h);
}

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

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

protected void heart_beat

(

)

Definiert in Zeile 935 der Datei life.c.

Benutzt age, alc, ALC_EFFECT_AREA_ENV, ALC_EFFECT_AREA_GUILD, ALC_EFFECT_HICK, ALC_EFFECT_LOOKDRUNK, ALC_EFFECT_RUELPS, ALC_EFFECT_STUMBLE, attribute_hb(), break_string(), create_kill_log_entry(), delay_alcohol, delay_drink, delay_food, delay_heal, delay_poison, delay_sp, die(), drop_poison, FEMALE, gilde, hp_buffer, ME, name, NO_REG_ALCOHOL, NO_REG_BUFFER_HP, NO_REG_BUFFER_SP, NO_REG_DRINK, NO_REG_FOOD, NO_REG_HP, NO_REG_SP, ob(), P_ALCOHOL, P_ALCOHOL_DELAY, P_DRINK, P_DRINK_DELAY, P_FOOD, P_FOOD_DELAY, P_GHOST, P_GUILD, P_HP, P_HP_DELAY, P_KILLER, P_MAX_ALCOHOL, P_MAX_HP, P_NO_REGENERATION, P_POISON, P_POISON_DELAY, P_SP, P_SP_DELAY, POISON_MERCY_DELAY, QueryPossPronoun(), QueryProp(), Set(), SetProp(), log_buffer_s::sp, sp_buffer, update_buffers(), WEN und WER.

{
    int hpoison, alc, rate, val, rlock, hp, sp;

    if ( !this_object() )
        return;

    age++;

    attribute_hb();
    
    // Als Geist leidet man nicht unter so weltlichen Dingen wie
    // Alkohol, Gift&Co ...
    if ( QueryProp(P_GHOST) )
        return;

    hpoison = QueryProp(P_POISON);
    rlock = QueryProp(P_NO_REGENERATION);
    hp = QueryProp(P_HP);
    sp = QueryProp(P_SP);
    
    if ( (alc = QueryProp(P_ALCOHOL)) && !random(40) ){
        int n;
        string gilde;
        object ob;
        
        n = random( 5 * (alc - 1)/QueryProp(P_MAX_ALCOHOL) );

        switch (n){
        case ALC_EFFECT_HICK:
            say( capitalize(name( WER, 1 )) + " sagt: <Hick>!\n" );
            write( "<Hick>! Oh, Tschuldigung.\n" );
            break;
            
        case ALC_EFFECT_STUMBLE:
            say( capitalize(name( WER, 1 )) + " stolpert ueber " +
                 QueryPossPronoun( FEMALE, WEN ) + " Fuesse.\n" );
            write( "Du stolperst.\n" );
            break;
            
        case ALC_EFFECT_LOOKDRUNK:
            say( capitalize(name( WER, 1 )) + " sieht betrunken aus.\n" );
            write( "Du fuehlst Dich benommen.\n" );
            break;
            
        case ALC_EFFECT_RUELPS:
            say( capitalize(name( WER, 1 )) + " ruelpst.\n" );
            write( "Du ruelpst.\n" );
            break;
        }
        
        if ( stringp(gilde = QueryProp(P_GUILD))
             && objectp(ob = find_object( "/gilden/" + gilde )) )
            ob->InformAlcoholEffect( ME, n, ALC_EFFECT_AREA_GUILD );
        
        if ( environment() )
            environment()->InformAlcoholEffect( ME, n, ALC_EFFECT_AREA_ENV );
    }
    
    if ( alc && (--delay_alcohol < 0)
         && !(rlock & NO_REG_ALCOHOL) ){

        SetProp( P_ALCOHOL, alc - 1 );
        
        if ( !hpoison ){
            hp++;
            sp++;
        }
        
        delay_alcohol = QueryProp(P_ALCOHOL_DELAY);
    }

    if ( (--delay_drink < 0) && !(rlock & NO_REG_DRINK) ){
        delay_drink = QueryProp(P_DRINK_DELAY);
        SetProp( P_DRINK, QueryProp(P_DRINK) - 1 );
    }

    if ( (--delay_food < 0) && !(rlock & NO_REG_FOOD) ){
        delay_food = QueryProp(P_FOOD_DELAY);
        SetProp( P_FOOD, QueryProp(P_FOOD) - 1 );
    }

    /* normal regeneration */
    if ( hp_buffer[0] && !(rlock & NO_REG_BUFFER_HP) ){
        rate = hp_buffer[1];
        val = hp_buffer[rate + 1];
        
        if ( val > rate )
            val = rate;
        
        hp_buffer[0] -= val;
        hp_buffer[rate + 1] -= val;
        hp += val;
        
        if ( hp_buffer[rate + 1] <= 0 )
            update_buffers();
    }
    else if ( (--delay_heal < 0) && !(rlock & NO_REG_HP) ){
        delay_heal = QueryProp(P_HP_DELAY);
        
        if ( !hpoison )
            hp++;
    }

    if ( sp_buffer[0] && !(rlock & NO_REG_BUFFER_SP) ){
        rate = sp_buffer[1];
        val = sp_buffer[rate + 1];
        
        if ( val > rate )
            val = rate;
        
        sp_buffer[0] -= val;
        sp_buffer[rate + 1] -= val;
        sp += val;
        
        if ( sp_buffer[rate + 1] <= 0 )
            update_buffers();
    }
    else if ( (--delay_sp < 0) && !(rlock & NO_REG_SP) ){
        delay_sp = QueryProp(P_SP_DELAY);
        
        if ( !hpoison )
            sp++;
    }

    if ( hpoison && (interactive(ME) || !query_once_interactive(ME)) ){
                // Vanion, 26.10.03
                // Wenn _set_poison() per SET_METHOD ueberschrieben wird, kann
                // nicht sichergestellt werden, dass poison immer groesser 0 ist
                // Daher muss hier ein Test rein, so teuer das auch ist :(
                if (--hpoison < 0) hpoison=0;
        
        if ( --delay_poison < 0 ){
            delay_poison = QueryProp(P_POISON_DELAY)
                + random(POISON_MERCY_DELAY);
            hp -= hpoison;

            if ( hp < 0 ){
                tell_object( ME, "Oh weh - das Gift war zuviel fuer Dich!\n"
                             + "Du stirbst.\n" );
                
                if ( query_once_interactive(ME) ){
                    create_kill_log_entry( "Vergiftung", 0 );
                    
                    // Beim Gifttod gibt es keinen Killer. Aber auf diese Art
                    // erkennt der Todesraum die Ursache korrekt und gibt die
                    // richtige Meldung aus.
                    SetProp( P_KILLER, "gift" );
                }
                
                die(1);
                return;
            }
            
            if ( (hpoison < 3 || !query_once_interactive(ME) )
                 && --drop_poison < 0){
                switch (hpoison) {
                case 1:
                    drop_poison += 15 + random(6);  // Das werden etwa 50...
                    
                case 2:
                    drop_poison += 25 + random(10);
                    
                case 0:
                    Set( P_POISON, hpoison );
                    if ( !hpoison )
                        tell_object( ME, "Du scheinst die Vergiftung "
                                     "ueberwunden zu haben.\n" );
                    break;
                    
                default:
                    drop_poison += (20 - 2*hpoison + random(40 - 3*hpoison));
                    Set( P_POISON, hpoison );
                }
            }
        }
        
        if ( hpoison && !random(15) )
            switch ( hp*100/QueryProp(P_MAX_HP) ){
            case 71..100 :
                write( "Du fuehlst Dich nicht gut.\n" );
                say( capitalize(name(WER)) +
                     " sieht etwas benommen aus.\n" );
                break;
                
            case 46..70 :
                write( "Dir ist schwindlig und Dein Magen revoltiert.\n" );
                say( capitalize(name(WER)) + " taumelt ein wenig.\n" );
                break;
                
            case 26..45 :
                write( "Dir ist heiss. Du fuehlst Dich schwach. Kopfweh "
                       "hast Du auch.\n" );
                say( capitalize(name(WER)) + " glueht direkt und scheint "
                     "grosse Schwierigkeiten zu haben.\n" );
                break;
                
            case 11..25 :
                write( "Du fuehlst Dich beschissen. Alles tut weh, und Du "
                       "siehst nur noch unscharf.\n" );
                say( capitalize(name(WER)) + " taumelt und stoehnt und "
                     "kann gerade noch vermeiden, hinzufallen.\n" );
                break;
                
            case 0..10 :
                write( break_string( "Du siehst fast nichts mehr und kannst "
                                     "Dich nur noch unter groessten Schmerzen "
                                     "bewegen. Aber bald tut nichts mehr weh"
                                     "...", 78 ) );
                say( break_string( capitalize(name(WER)) + " glueht wie "
                                   "im Fieber, kann sich kaum noch ruehren "
                                   "und hat ein schmerzverzerrtes Gesicht.\n",
                                   78 ) );
                break;
            }
    }

    SetProp( P_HP, hp );
    SetProp( P_SP, sp );
}

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

public int reduce_hit_points

(

int

dam

)

Definiert in Zeile 740 der Datei life.c.

Benutzt i, log_file, ME, name, P_HP, QueryProp(), SetProp() und WER.

Wird benutzt von restore_hit_points().

{ object o;
  int i;

#ifdef LOG_REDUCE_HP
  if (this_player()!=ME)
  {
    log_file("REDUCE_HP", name()+" by ");
    if(!this_player()) log_file("REDUCE_HP","?\n");
    else {
      log_file("REDUCE_HP",this_player()->name());
      o=previous_object();
      if (o)
        log_file("REDUCE_HP", " " + object_name(o) + ", " +
                 o->name(WER,0) + " (" + creator(o) + ")\n");
      else
        log_file("REDUCE_HP", " ??\n");
    }
  }
#endif
  if ((i=QueryProp(P_HP)) <= dam)
    return SetProp(P_HP,1);
  return SetProp(P_HP, i - dam);
}

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

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

public void reduce_spell_points

(

int

h

)

Definiert in Zeile 729 der Datei life.c.

Benutzt P_SP, QueryProp() und SetProp().

{
  SetProp(P_SP, QueryProp(P_SP)-h);
}

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

public int restore_hit_points

(

int

heal

)

Definiert in Zeile 765 der Datei life.c.

Benutzt reduce_hit_points().

{
  return reduce_hit_points(-heal);
}

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

public void restore_spell_points

(

int

h

)

Definiert in Zeile 734 der Datei life.c.

Benutzt P_SP, QueryProp() und SetProp().

{
  SetProp(P_SP, QueryProp(P_SP)+h);
}

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

varargs protected int second_life

(

object

corpse

)

Definiert in Zeile 412 der Datei life.c.

                                                   {
    return 0;
}

public void show_age

(

)

Definiert in Zeile 1157 der Datei life.c.

Benutzt i, P_AGE und QueryProp().

Wird benutzt von score().

{ int i,j;

  write("Alter:\t");
  i = QueryProp(P_AGE);
  if ((j=i/43200))
  {
    write(j + " Tag"+(j==1?" ":"e "));
    i %= 43200;
  }
  if ((j=i/1800))
  {
    write(j + " Stunde"+(j==1?" ":"n "));
    i %= 1800;
  }
  if ((j=i/30))
  {
    write(j + " Minute"+(j==1?" ":"n "));
    i %= 30;
  }
  write(i*2 + " Sekunden.\n");
}

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

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

public varargs void transfer_all_to	(	mixed	dest,
		int	isnpc
	)

Definiert in Zeile 311 der Datei life.c.

                                                             {
    int flags;
    object *obs;

    if ( !objectp(ME) )
        return;

    // Das Flag "isnpc" ist fuer NPCs gedacht. Deren Ausruestung darf nicht
    // mit M_NOCHECK bewegt werden, da Spieler das bei Nicht-Standard-Leichen
    // sonst u.U. ausnutzen koennten.
    if ( isnpc )
        flags = M_SILENT;
    else
        flags = M_SILENT|M_NOCHECK;

    obs = all_inventory(ME) || ({});

    // unnoetig, weil _transfer() auch auf P_NEVERDROP prueft. Zesstra
    //obs -= filter_objects( obs, "QueryProp", P_NEVERDROP );

    _transfer( obs, dest, flags );
}

protected void update_buffers

(

)

Definiert in Zeile 867 der Datei life.c.

Benutzt hp_buffer, i, m_delete() und sp_buffer.

Wird benutzt von heart_beat().

{ int i, rate, max;

  rate=0;
  max=0;
  for(i=1;i<=20;i++){
    if(member(hp_buffer, i+1))
      if(hp_buffer[i+1]<=0)
        hp_buffer = efun::m_delete(hp_buffer,i+1);
      else{
        max+=hp_buffer[i+1];
        rate=i;
      }
  }

  hp_buffer[0]=max;
  hp_buffer[1]=rate;
  rate=0;
  max=0;
  for(i=1;i<=20;i++){
    if(member(sp_buffer, i+1))
      if(sp_buffer[i+1]<=0)
        sp_buffer = efun::m_delete(sp_buffer,i+1);
      else{
        max+=sp_buffer[i+1];
        rate=i;
      }
  }
  sp_buffer[0]=max;
  sp_buffer[1]=rate;
}

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

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

---

Variablen-Dokumentation

int age

Definiert in Zeile 56 der Datei life.c.

nosave int delay_alcohol

Definiert in Zeile 58 der Datei life.c.

Wird benutzt von heart_beat().

nosave int delay_drink

Definiert in Zeile 59 der Datei life.c.

Wird benutzt von heart_beat().

nosave int delay_food

Definiert in Zeile 60 der Datei life.c.

Wird benutzt von heart_beat().

nosave int delay_heal

Definiert in Zeile 61 der Datei life.c.

Wird benutzt von heart_beat().

nosave int delay_poison

Definiert in Zeile 63 der Datei life.c.

Wird benutzt von heart_beat().

nosave int delay_sp

Definiert in Zeile 62 der Datei life.c.

Wird benutzt von heart_beat().

nosave int drop_poison

Definiert in Zeile 64 der Datei life.c.

Wird benutzt von _set_poison() und heart_beat().

nosave mapping enemy_damage

Definiert in Zeile 65 der Datei life.c.

Wird benutzt von _query_enemy_damage(), create(), DistributeExp() und do_damage().

nosave mapping hp_buffer

Definiert in Zeile 66 der Datei life.c.

Wird benutzt von buffer_hp(), create(), heart_beat() und update_buffers().

int nextdefueltimedrink

Definiert in Zeile 70 der Datei life.c.

Wird benutzt von create() und defuel_drink().

int nextdefueltimefood

Definiert in Zeile 69 der Datei life.c.

Wird benutzt von create() und defuel_food().

nosave int remove_me

Definiert in Zeile 68 der Datei life.c.

nosave mapping sp_buffer

Definiert in Zeile 67 der Datei life.c.

Wird benutzt von buffer_sp(), create(), heart_beat() und update_buffers().