base.c-Dateireferenz

#include <sys_debug.h>
#include <logging.h>
#include <werliste.h>
#include <time.h>
#include <player/skills.h>
#include <player.h>
#include <properties.h>
#include <udp.h>
#include <config.h>
#include <ansi.h>
#include <wizlevels.h>
#include <living.h>
#include <attributes.h>
#include <language.h>
#include <moving.h>
#include <defines.h>
#include <terminal.h>
#include <new_skills.h>
#include <pager.h>
#include <combat.h>
#include "/secure/questmaster.h"
#include "/secure/lepmaster.h"
#include <events.h>

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
#define	NAME(who)   capitalize(getuid(who))
#define	SAFE_FOR_AUTOLOADER   __MAX_EVAL_COST__/4
#define	MUDS_BAR   "\-------------------------------------------------------------------------------"
Funktionen
static int	_set_level (int i)
static int	_set_invis (int a)
static string	_set_tty (string str)
static mixed	_set_fraternitasdonoarchmagorum (mixed arg)
static string	al_to_title (int a)
static void	ndead_revive ()
	Belebt einen netztoten Spieler wieder.
static int	wegmeldung (string player)
int	quit ()
	Speichert den Spieler und loggt ihn aus (Spielerkommando 'ende').
void	save_me (mixed value_items)
varargs int	remove (mixed arg)
mixed	RaceDefault (string arg)
	Setzt Defaultwerte fuer Rassen - wird von den Shells ueberschrieben.
protected void	create ()
	Setzt Defaultwerte vor dem Laden des Savefiles.
void	reset ()
string	Forschung ()
void	checkConsistency ()
	Prueft Spielerobjekt auf Konsistenz.
varargs int	remove (int silent)
	Bittet das Spielerobjekt, sich zu zerstoeren.
static varargs void	stop_heart_beats (mixed obs)
	Schaltet in allen Objekten im Inv HBs aus.
static void	restart_heart_beats ()
	Schaltet HBs in Objekten im Inv wieder ein.
static int	CheckDailyPlaytime ()
	Prueft auf abgelaufene Spielzeit.
static void	Show_WaitFor_Reason (string who, int invis)
	Gibt Erwartemeldung mit Grund aus.
static void	ListAwaited ()
	Gibt Liste der Erwarteten Spieler an this_player() aus.
static void	delayed_notify (string wer)
	Teilt Merlin mit, wer reingekommen ist.
static int	call_init (object ob, int logout)
	Ruft im uebergebenen Objekt ein init() auf, sofern notwendig.
static void	inits_nachholen (int logout, object *obs)
	Holt seit dem letzten Ausloggen ausgefallene Inits nach.
varargs void	Reconnect (int silent, string ip)
	Velebt einen Netztoten wieder.
void	NetDead ()
	Loggt einen Spieler aus und macht ihn netztot.
protected int	CheckTelnetKeepAlive ()
	Sendet ggf.
static void	ndead_move_me ()
	Bewegt einen netztoten Spieler in den Netztotenraum Gerufen von heartbeat().
protected void	heart_beat ()
	Heartbeat des Spielerobjektes.
varargs int	id (string str, int lvl)
	ID-Funktion fuer Spielerobjekte.
static int	set_homepage (string str)
	Setzt Spielerhomepage (Spielerkommando).
static int	set_location (string str)
	Setzt Spieler-Wohnort (Spielerkommando).
static int	set_icq (string str)
	Setzt ICQ-UIN des Spielers (Spielerkommando).
static int	set_messenger (string str)
	Setzt Instant Messanger vom Spieler (Spielerkommando).
static mixed	set_email (string str)
	Setzt Email-Adresse des Spielers (Spielerkommando).
static int	self_delete ()
	Spielerkommando 'selbstloeschung'.
int	self_delete2 (string str)
	Spielerkommando 'selbstloeschung'.
static int	spieldauer (string str)
	Setzt neue taegliche Spieldauer (Spielerkommando).
private int	InterpretTime (string a)
	Interpretiert Angabe des Spielers fuer Spielpause.
static int	spielpause (string str)
	Setzt neue Spielpause (Spielerkommando).
static void	spielpause2 (string str, int days)
	Setzt neue taegliche Spieldauer, wird ueber spielpause() gerufen.
static int	change_password ()
	Setzt neues Passwort (Spielerkommando).
static int	change_password2 (string str)
	Setzt neues Passwort (Spielerkommando).
static int	change_password3 (string str)
	Setzt neues Passwort (Spielerkommando).
static int	change_password4 (string str)
	Setzt neues Passwort (Spielerkommando).
static int	bug (string str)
	Setzt eine Fehlermeldung an Magier ab (Spielerkommando).
static int	bug2 (string str)
	Setzt eine Fehlermeldung an Magier ab (Spielerkommando).
static int	typo (string str)
	Setzt eine Typomeldung an Magier ab (Spielerkommando).
static int	typo2 (string str)
	Setzt eine Fehlermeldung an Magier ab (Spielerkommando).
static int	idea (string str)
	Setzt eine Idee an Magier ab (Spielerkommando).
static int	idea2 (string str)
	Setzt eine Idee an Magier ab (Spielerkommando).
static int	md (string str)
	Setzt ein fehlendes Detail an Magier ab (Spielerkommando).
static int	md2 (string str)
	Setzt ein fehlendes Detail an Magier ab (Spielerkommando).
void	smart_log (string myname, string str)
	Loggt eine Spielermeldung an Magier.
static int	new_quit ()
	Wrapper im quit() herum, verhindert 'ende', falls Spieler kaempft.
static int	score (string arg)
	Gibt die Infos ueber den Char an den Spieler aus (Spielerkommando 'info').
static int	short_score (string arg)
	Gibt eine kuerzere Info ueber den Char aus (Spielerkommando punkte|score).
static int	very_short_score (string arg)
	Gibt eine Miniinfo ueber LP / KP aus (Spielerkommando: kurzinfo).
static string	getmanpage (string dir, string page)
	Gibt eine Manpage/Hilfeseite an den Spieler aus.
static int	help (string str)
	Gibt eine Hilfeseite an den Spieler aus (Spielerkommando hilfe|man).
static mixed	filter_who_options (string str)
	Ermittelt angebene Optionen fuer das Spielerkommando 'wer'.
static int	who (string str)
	Spielerkommando 'wer', fragt /obj/werliste ab.
static int	kwho (string str)
	Spielerkommando 'kwer', fragt /obj/werliste ab.
static varargs int	kkwho (string str)
	Spielerkommando 'kkwer', gibt eine einfache Liste der Anwesenden aus.
static int	kill (string str)
	Spielerkommando 'toete'.
static int	stop (string str)
	Spielerkommando 'stop'.
int	emote (string str, int genitiv)
	Spielerkommando fuers emoten ':'.
static int	remote (string str, int flag)
	Spielerkommando fuers remoten 'r:'.
static int	gemote (string str)
	Spielerkommando fuers emoten im Genitiv ';'.
static int	gremote (string str)
	Spielerkommando fuers remoten im Genitiv 'r;'.
static void	load_auto_objects (mapping map_ldfied)
private void	InitPlayer ()
	Setzt die Spielerinitialisierung nach start_player() fort.
private void	InitPlayer2 ()
	Prueft Geschlecht des Spielers und fragt ggf.
private void	InitPlayer3 ()
	Prueft Terminaltyp des Spielers und fragt ggf.
private int	RandomSize ()
	Gibt eine Zufallszahl um P_AVERAGE_SIZE herum zurueck.
private void	updates_after_restore (int newflag)
	Setzt bestimmte Props im Spieler, falls diese nicht gesetzt sind.
varargs nomask void	set_hc_play (string str, int val)
	Setzt den HC-Modus.
nomask int	query_hc_play ()
	gibt den HC-Modus zurueck.
varargs nomask int	start_player (string str, string ip)
	Initialisiert und aktiviert das Spielerobjekt.
private void	InitPlayer4 ()
	Letzte Phase der Spielerinitialisierung beim Laden des Charakters.
static void	getmailaddr (string maddr)
	liest eMail-Adresse vom Spieler ein und speichert sie.
static void	getgender (string gender_string)
	Liest Spielerantwort auf die Frage nach dem Geschlecht des Chars ein.
static void	gettty (string ttystr)
	Liest Spielerantwort auf die Frage nach dem Terminaltyp ein.
nomask string	query_real_name ()
	Liefert die UID des Charakters zurueck, also den Charakternamen.
int	review ()
static int	setmin (string str)
static int	setmout (string str)
static int	setmmin (string str)
static int	setmmout (string str)
static int	setcmsg (string str)
static int	setdmsg (string str)
static int	set_title (string str)
static int	extra_input (string str, string look)
static int	extralook (mixed str)
static void	calculate_value ()
int	save_character ()
static varargs void	log_autoload (string file, string reason, mixed data, string error)
private void	load_auto_object (string file, mixed data)
static int	toggle_whimpy_dir (string str)
static int	toggle_whimpy (string str)
varargs nomask int	query_prevent_shadow (object obj)
	Bestimmt, ob das Spielerobjekt beschattet werden darf.
static int	uhrzeit ()
string	SetDefaultHome (string str)
string	QueryDefaultHome ()
string	SetPrayRoom (string str)
string	QueryPrayRoom ()
void	_restart_beat ()
static int	weg (string str)
static string	timediff (int time)
static int	idlezeit (string player)
int	QueryGuest ()
	Ist dieser Character ein Gast?
int	disconnect (string str)
	Spielerkommando 'schlafe ein'.
static int	finger (string str)
string	lalign (string str, int wid)
private void	format (mixed mud, mixed hosts, string output)
static int	muds ()
static int	stty (string str)
int	set_ascii_art (string str)
int	_set_shell_version (int arg)
int	_query_shell_version ()
int	more (string str)
static int	set_visualbell (string str)
static int	set_screensize (string str)
static int	_query_screensize ()
static int	presay (string str)
static int	sethands (string str)
static int	inform (string str)
void	delayed_write (mixed *what)
void	notify_player_change (string who, int rein, int invis)
static int	erwarte (string str)
static int	uhrmeldung (string str)
static int	zeitzone (string str)
static int	emailanzeige (string str)
static int	zaubertraenke ()
static varargs int	angriffsmeldung (string arg)
static string *	_query_localcmds ()
static int	_check_keep (object ob)
static mixed	_set_testplayer (mixed arg)
int	zweitiemarkierung (string arg)
int	topliste (string arg)
int	show_telnegs (string arg)
int	set_keep_alive (string str)
int	spotte (string str)
int	behalte (string str)
static int	_query_lep ()
nomask void	set_realip (string str)
nomask string	query_realip ()
mixed	_query_netdead_env ()
Variablen
inherit std	hook_provider
inherit std player	restrictions
inherit std living	attributes
inherit std living	put_and_get
inherit std living	clothing
inherit std thing	properties
inherit std player	util
inherit std thing	language
inherit std player	travel
inherit std player	combat
inherit std player	description
inherit std player	moving
inherit std player	life
inherit std player	comm
inherit std player	viewcmd
inherit std living	moneyhandler
inherit std player	command
inherit std living	skill_attributes
inherit std player	skills
inherit std player	quests
inherit std player	potion
inherit std player	soul
inherit std	more
inherit std	user_filter
inherit std player telnetneg	c
inherit std player	guide
inherit std player	reputation
mapping	autoload
int	hc_play
private nosave mapping	autoload_rest
private nosave string *	autoload_error
private nosave string	realip
private nosave string	passw
private nosave string	passwold
private int	telnet_tm_counter
nosave string	default_home
nosave int	ndead_lasttime
nosave mixed	ndead_location
nosave string	ndead_l_filename
nosave int	ndead_currently
nosave int	ndead_next_check
nosave object *	hb_obs
nosave string	pray_room
nosave mixed	env_ndead_info

---

Makro-Dokumentation

#define MUDS_BAR   "\-------------------------------------------------------------------------------"

Definiert in Zeile 3289 der Datei base.c.

#define NAME

(

who

)

capitalize(getuid(who))

Definiert in Zeile 68 der Datei base.c.

#define NEED_PROTOTYPES

Definiert in Zeile 45 der Datei base.c.

#define SAFE_FOR_AUTOLOADER   __MAX_EVAL_COST__/4

Definiert in Zeile 2788 der Datei base.c.

---

Dokumentation der Funktionen

static int _check_keep

(

object

ob

)

[static]

Definiert in Zeile 3948 der Datei base.c.

{
  return (ob->QueryProp(P_KEEP_ON_SELL))==geteuid(ME);
}

static int _query_lep

(

)

[static]

Definiert in Zeile 4126 der Datei base.c.

Benutzt LEPMASTER, P_LEP und Set().

{
  int val;
  val = LEPMASTER->QueryLEP();
  Set( P_LEP, val );
  return val;
}

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

static string* _query_localcmds

(

)

[static]

Definiert in Zeile 3863 der Datei base.c.

Wird benutzt von _query_localcmds().

{
  return ({({"zeilen","set_screensize",0,0}),
           ({"email","set_email",0,0}),
           ({"url","set_homepage",0,0}),
           ({"icq","set_icq",0,0}),
                   ({"messenger", "set_messenger", 0, 0}), 
           ({"ort","set_location",0,0}),
           ({"punkte","short_score",0,0}),
           ({"score","short_score",0,0}),
           ({"info","score",0,0}),
           ({"kurzinfo","very_short_score",0,0}),
           ({"quit","new_quit",0,0}),
           ({"ende","new_quit",0,0}),
           ({"disconnect","disconnect",0,0}),
           ({"schlaf","disconnect",1,0}),
           ({"speichern","save_character",0,0}),
           ({"save","save_character",0,0}),
           ({"toete","kill",0,0}),
           ({"angriffsmeldung","angriffsmeldung",0,0}),
           ({"passw","change_password",1,0}),
           ({"hilfe","help",1,0}),
           ({"selbstloeschung","self_delete",0,0}),
           ({"spielpause","spielpause",0,0}),
           ({"spieldauer","spieldauer",0,0}),
           ({"idee","idea",0,0}),
           ({"typo","typo",0,0}),
           ({"bug","bug",0,0}),
           ({"fehler","bug",0,0}),
           ({"md","md",0,0}),
           ({"detail","md",0,0}),
           ({"vorsicht","toggle_whimpy",0,0}),
           ({"stop","stop",0,0}),
           ({"kwho","kwho",0,0}),
           ({"kwer","kwho",0,0}),
           ({"kkwer","kkwho",0,0}),
           ({"kkwho","kkwho",0,0}),
           ({"who","who",0,0}),
           ({"wer","who",0,0}),
           ({"zeit","uhrzeit",0,0}),
           ({"uhrzeit","uhrzeit",0,0}),
           ({"weg","weg",0,0}),
           ({"wegmeldung", "wegmeldung", 0, 0}),
           ({"idlezeit", "idlezeit", 0, 0}),
           ({"finger","finger",0,0}),
           ({"muds","muds",0,0}),
           ({"emote","emote",0,0}),
           ({":","emote",1,0}),
           ({";","emote",1,0}),
           ({"remote","remote",0,SEER_LVL}),
           ({"r:","remote",1,0}),
           ({"r;","gremote",1,0}),
           ({"titel","set_title",0,0}),
           ({"review","review",0,SEER_LVL}),
           ({"setmin","setmin",0,SEER_LVL}),
           ({"setmout","setmout",0,SEER_LVL}),
           ({"setmmin","setmmin",0,SEER_LVL}),
           ({"setmmout","setmmout",0,SEER_LVL}),
           ({"sethands","sethands",0,SEER_LVL}),
           ({"presay","presay",0,SEER_LVL}),
           ({"extralook","extralook",0,SEER_LVL}),
           ({"fluchtrichtung","toggle_whimpy_dir",0,SEER_LVL}),
           ({"inform","inform",0,0}),
           ({"erwarte","erwarte",0,0}),
           ({"stty","stty",0,0}),
                   ({"grafik", "set_ascii_art", 0, 0}), 
           ({"uhrmeldung","uhrmeldung",0,0}),
           ({"zeitzone","zeitzone",0,0}),
           ({"behalte","behalte",0,0}),
           ({"zweitiemarkierung","zweitiemarkierung",0,0}),
           ({"emailanzeige","emailanzeige",0,0}),
           ({"topliste","topliste",0,0}),
           ({"ton","set_visualbell",0,0}),
           ({"telnegs","show_telnegs",0,0}),
           ({"spotte", "spotte", 0, 0}),
           ({"reise","reise",0,0}),
           ({"zaubertraenke","zaubertraenke",0,0}),
                   ({"keepalive","set_keep_alive",0,0}),
     })+
     command::_query_localcmds()+
     viewcmd::_query_localcmds()+
     comm::_query_localcmds()+
     skills::_query_localcmds();
}

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

mixed _query_netdead_env

(

)

Definiert in Zeile 4162 der Datei base.c.

Benutzt ndead_l_filename und ndead_location.

                           {
                return ndead_location || ndead_l_filename;
}

static int _query_screensize

(

)

[static]

Definiert in Zeile 3523 der Datei base.c.

{
    int sz,rows;

    if ( (sz=Query(P_SCREENSIZE)) >= 0 )
        return sz;

    if ( !rows=QueryProp(P_TTY_ROWS) )
        return 20;

    return (rows+=sz) >= 5 ? rows : 5;
}

int _query_shell_version

(

)

Definiert in Zeile 3401 der Datei base.c.

{   mixed sv;

    if (!(sv=Query(P_SHELL_VERSION)) || !pointerp(sv) || sizeof(sv)!=2 ||
        sv[0]!=QueryProp(P_RACE) || !intp(sv[1]))
      return 0;
    return sv[1];
}

void _restart_beat

(

)

Definiert in Zeile 2991 der Datei base.c.

{
  tell_object(ME,
      "Der GameDriver teilt Dir mit: Dein Herzschlag hat wieder eingesetzt.\n");
  set_heart_beat(1);
}

static mixed _set_fraternitasdonoarchmagorum

(

mixed

arg

)

[static]

Definiert in Zeile 4134 der Datei base.c.

Benutzt dtime(), FAO_MASTER, IS_ARCH, log_file, P_FAO, query_real_name() und Set().

{
  if (!intp(arg)) return -1;

  if ((!previous_object(1)||object_name(previous_object(1))!=FAO_MASTER) && 
      (!this_interactive() || !IS_ARCH(this_interactive())))
    return -1;

  if (!intp(arg)) return -1;

  log_file("fao/P_FAO",sprintf("%s - %s P_FAO gesetzt auf %O\n",
                dtime(time()),query_real_name(),arg) );
  return Set(P_FAO,arg);
}

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

static int _set_invis

(

int

a

)

[static]

Definiert in Zeile 3323 der Datei base.c.

{
  return Set(P_INVIS, intp(a) ? a : !Query(P_INVIS));
}

static int _set_level

(

int

i

)

[static]

Definiert in Zeile 3316 der Datei base.c.

{
  if (!intp(i)) return -1;
  if (i<1 || i>200) return -1;
  return Set(P_LEVEL, i);
}

int _set_shell_version

(

int

arg

)

Definiert in Zeile 3393 der Datei base.c.

{
  if (!intp(arg))
    return -1;
  Set(P_SHELL_VERSION,({QueryProp(P_RACE),arg}));
  return 1;
}

static mixed _set_testplayer

(

mixed

arg

)

[static]

Definiert in Zeile 3953 der Datei base.c.

                                        {
  mixed res;
  object setob;

  setob=this_player();
  if (!objectp(setob) || !query_once_interactive(setob))
    setob=this_interactive();
  if (!objectp(setob))
    setob=previous_object();
  if (setob && !IS_DEPUTY(setob)) {
    arg=geteuid(setob);
    if (!arg || arg=="NOBODY")
      arg=getuid(setob);
    arg=capitalize(arg);
  }
  res=Set(P_TESTPLAYER,arg);
  Set(P_TESTPLAYER,PROTECTED,F_MODE_AS);
  return res;
}

static string _set_tty

(

string

str

)

[static]

Definiert in Zeile 3330 der Datei base.c.

                                   {
  if(str != "dumb" && str != "vt100" && str != "ansi")
    return Query(P_TTY);
  return Set(P_TTY, str);
}

static string al_to_title

(

int

a

)

[static]

Definiert in Zeile 2871 der Datei base.c.

Wird benutzt von score().

{
  if (a >= KILL_NEUTRAL_ALIGNMENT * 100)
    return "heilig";
  if (a > KILL_NEUTRAL_ALIGNMENT * 20)
    return "gut";
  if (a > KILL_NEUTRAL_ALIGNMENT * 4)
    return "nett";
  if (a > - KILL_NEUTRAL_ALIGNMENT * 4)
    return "neutral";
  if (a > - KILL_NEUTRAL_ALIGNMENT * 20)
    return "frech";
  if (a > - KILL_NEUTRAL_ALIGNMENT * 100)
    return "boese";
  return "satanisch";
}

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

static varargs int angriffsmeldung

(

string

arg

)

[static]

Definiert in Zeile 3851 der Datei base.c.

                                               {
  if (arg=="ein" || arg=="an")
    SetProp(P_SHOW_ATTACK_MSG,1);
  else if (arg=="aus")
    SetProp(P_SHOW_ATTACK_MSG,0);
  if (QueryProp(P_SHOW_ATTACK_MSG))
    write("Du siehst saemtliche Angriffsmeldungen von Dir.\n");
  else
    write("Du siehst nur neue Angriffsmeldungen von Dir.\n");
  return 1;
}

int behalte

(

string

str

)

Definiert in Zeile 4082 der Datei base.c.

{
  object ob,*obs;
  string s;

  if (str)
  {
    if (str=="alles") {
      filter_objects(all_inventory(), "SetProp", P_KEEP_ON_SELL, getuid());
      write("Ok!\n");
      return 1;
    }
    if (str=="nichts") {
      filter_objects(all_inventory(), "SetProp", P_KEEP_ON_SELL, 0);
      write("Ok!\n");
      return 1;
    }
    if (!sizeof(obs=find_obs(str,PUT_GET_NONE)))
    {
      _notify_fail("Aber sowas hast Du nicht dabei!\n");
      return 0;
    }
    else ob=obs[0];

    if (ob->QueryProp(P_KEEP_ON_SELL)==geteuid(ME))
        ob->SetProp(P_KEEP_ON_SELL,0);
    else
        ob->SetProp(P_KEEP_ON_SELL,geteuid(ME));

    // erneut abfragen, da sich der Wert nicht geaendert haben muss
    if (ob->QueryProp(P_KEEP_ON_SELL)==geteuid(ME))
        write(break_string(sprintf("Ok, Du wirst %s jetzt bei 'verkaufe alles' "
                                   "behalten.\n",ob->name(WEN)),78));
    else
        write(break_string(sprintf("Ok, Du wirst %s beim naechsten 'verkaufe "
                                   "alles' mitverkaufen!\n",ob->name(WEN)),78));

    return 1;
  }
  s=make_invlist(ME,filter(all_inventory(ME),#'_check_keep)); //'));
  More(s);
  return 1;
}

static int bug

(

string

str

)

[static]

Setzt eine Fehlermeldung an Magier ab (Spielerkommando).

Fragt nach der Fehlermeldung und liest sie via bug2() ein, fall der Spieler kein Argument angeben hat.

Parameter:

[in]

str

optionale Spielereingabe der Fehlerbeschreibung

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

bug2(string)

Definiert in Zeile 1205 der Datei base.c.

Benutzt _unparsed_args(), input_to() und smart_log().

                           {
  if (!(str=_unparsed_args())) {
    write( "Wie sieht der Fehler denn aus?\n]" );
    input_to("bug2");
    return 1;
  }
  write("Vielen Dank fuer die Hilfe.\n");
  smart_log("BUGS",str);
  return 1;
}

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

static int bug2

(

string

str

)

[static]

Setzt eine Fehlermeldung an Magier ab (Spielerkommando).

Lies Fehlerbeschreibung ein und speichert sie ab.

Parameter:

[in]

str

Spielereingabe der Fehlerbeschreibung.

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

bug(string)

Definiert in Zeile 1222 der Datei base.c.

Benutzt smart_log().

                            {
  if (!str || str == "") {
    write("Bug abgebrochen...\n");
    return 1;
  }
  write("Vielen Dank fuer die Hilfe.\n");
  smart_log("BUGS",str);
  return 1;
}

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

static void calculate_value

(

)

[static]

Definiert in Zeile 2713 der Datei base.c.

{
  int i, carried_value, value;

  carried_value=0;
  foreach(object ob: deep_inventory(ME)) {
    if (!ob->QueryProp(P_AUTOLOADOBJ))
      carried_value+=((value=(int)ob->QueryProp(P_VALUE)) > 1000 ? 1000 : value);
  }
  SetProp(P_CARRIED_VALUE, carried_value);
}

static int call_init	(	object	ob,
		int	logout
	)			[static]

Ruft im uebergebenen Objekt ein init() auf, sofern notwendig.

Ruft in ob ein init() auf, falls das Objekt nach dem letzten Ausloggen geschaffen wurde.

Parameter:

[in]	ob	object - Objekt, in dem init() gerufen wird.
[in]	logout	int - Letzter Logout

Rückgabe:

1, falls init() gerufen wurde. 0 sonst.

Definiert in Zeile 480 der Datei base.c.

{
    if ( objectp(ob) && object_time(ob) > logout )
        return catch(ob->init(); publish), 1;
    return(0);
}

static int change_password

(

)

[static]

Setzt neues Passwort (Spielerkommando).

Fragt nach altem Passwort und ruft change_password2().

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

change_password2(), change_password3(), change_password4()

Definiert in Zeile 1099 der Datei base.c.

Benutzt input_to().

                             {
  string verb;
  verb=query_verb();
  if (verb!="passwd"&&verb!="password"&&verb!="passwort")
    return 0;
  write("Bitte das ALTE Passwort angeben: ");
  input_to("change_password2",1);
  return 1;
}

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

static int change_password2

(

string

str

)

[static]

Setzt neues Passwort (Spielerkommando).

Prueft altes Passwort, fragt nach neuem Passwort und ruft change_password3().

Parameter:

[in]

str

Spielereingabe des alten Passwortes

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

change_password(), change_password3(), change_password4()

Definiert in Zeile 1116 der Datei base.c.

Benutzt input_to(), MASTER und passwold.

                                        {
  write("\n");
  if (!str)
    str="";
  if (MASTER->update_password(str,str) == 0) {
    write("Falsches Passwort!\n");
    return 1;
  }
  passwold = str;
  write("Bitte das NEUE Passwort eingeben: ");
  input_to("change_password3",1);
  return 1;
}

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

static int change_password3

(

string

str

)

[static]

Setzt neues Passwort (Spielerkommando).

Prueft neues Passwort, fragt nach Bestaetigung des neues Passwortes und ruft change_password4().

Parameter:

[in]

str

Spielereingabe des neuen Passwortes

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

change_password(), change_password2(), change_password4()

Definiert in Zeile 1137 der Datei base.c.

Benutzt input_to(), MASTER, ME, passw und passwold.

{
    write( "\n" );

    if ( !str || str == "" ){
        write( "Abgebrochen !\n" );
        passwold = passw = 0;
        return 1;
    }

    if ( passwold == str ){
        write( "Das war Dein altes Passwort.\n"
               "Bitte das NEUE Passwort eingeben (zum Abbruch Return "
               "druecken): " );
        input_to( "change_password3", 1 );
        return 1;
    }

    if ( !MASTER->good_password( str, getuid(ME) ) ){
        write( "Bitte das NEUE Passwort eingeben: " );
        input_to( "change_password3", 1 );
        return 1;
    }

    passw = str;
    write( "Nochmal: " );
    input_to( "change_password4", 1 );
    return 1;
}

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

static int change_password4

(

string

str

)

[static]

Setzt neues Passwort (Spielerkommando).

Prueft neues Passwort und setzt neues Passwort.

Parameter:

[in]

str

Spielereingabe des neuen Passwortes

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

change_password(), change_password2(), change_password3()

Definiert in Zeile 1173 der Datei base.c.

Benutzt MASTER, passw und passwold.

{
    write( "\n" );

    if ( !str || str != passw ){
        write( "Das war verschieden! Passwort NICHT geaendert.\n" );
        passwold = passw = 0;
        return 1;
    }

    if ( MASTER->update_password( passwold, passw ) )
        write( "Passwort geaendert.\n" );
    else
        write( "Hat nicht geklappt!\n" );

    passwold = passw = 0;
    return 1;
}

void checkConsistency

(

)

Prueft Spielerobjekt auf Konsistenz.

Ueberprueft das Spielerobjekt nach kompletter Initialisierung (im callout) auf korrekte Werte einiger Props.

Definiert in Zeile 286 der Datei base.c.

Benutzt dtime(), F_MODE, F_MODE_AD, F_MODE_AS, F_VALUE, h, IS_LEARNER, log_file, P_BODY, P_HANDS, P_SECOND_MARK, P_TTY_COLS, P_TTY_ROWS, P_TTY_SHOW, P_TTY_TYPE, PROTECTED, Query(), RaceDefault(), SAVE und Set().

{ mixed h;
  int   m;

  if (pointerp(h=RaceDefault(P_HANDS)) && sizeof(h)>1)
    m=(int)h[1];
  else
    m=30;
  if((h=Query(P_HANDS))[1] > m && !IS_LEARNER(this_object())) {
    log_file("inconsistent", sprintf(
      "[%s] %O: HANDS: %d\n", dtime(time()), this_player(), h[1]));
    h[1] = m;
    Set(P_HANDS,h);
  }

  if (Query(P_BODY)!=(m=RaceDefault(P_BODY)))
     Set(P_BODY,m);

  if (!Query(P_SECOND_MARK,F_MODE))
    Set(P_SECOND_MARK,SAVE|PROTECTED,F_MODE_AS);
  if (!Query(P_TTY_SHOW,F_MODE)&SAVE)
  {
    Set(P_TTY_SHOW,0,F_VALUE);
    Set(P_TTY_SHOW,SAVE,F_MODE_AS);
  }
  if (Query(P_TTY_COLS,F_MODE)&SAVE)
  {
    Set(P_TTY_COLS,SAVE,F_MODE_AD);
    Set(P_TTY_ROWS,SAVE,F_MODE_AD);
    Set(P_TTY_TYPE,SAVE,F_MODE_AD);
  }
}

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

static int CheckDailyPlaytime

(

)

[static]

Prueft auf abgelaufene Spielzeit.

Prueft in Spielerobjekten, ob die taegliche Maximalspielzeit abgelaufen ist. Wird im heart_beat() gerufen.

Rückgabe:

int - Flag, ob Spielzeit abgelaufen und Logout erfolgen soll

Definiert in Zeile 380 der Datei base.c.

Benutzt ME, Name(), P_DAILY_PLAYTIME, Query(), remove_interactive(), Set(), spieldauer() und WER.

Wird benutzt von heart_beat().

                                {
  int *spieldauer,d;

  if (!pointerp(spieldauer=Query(P_DAILY_PLAYTIME)))
    return 0;
  // 0:Minuten pro Tag, 1:Nr. des letzen Tages, 2:Nr. des angefangenen Tages,
  // 3:letzte Zeitpruefung, 4:verbleibende Zeit
  d=time()/86400;
  if (spieldauer[1]<=d) { // Ende der zeitbeschraenkten Tage?
    Set(P_DAILY_PLAYTIME,0);
    return 0;
  } else if (spieldauer[2]!=d) { // Neuer Tag?
    spieldauer[4]=spieldauer[0];
    spieldauer[2]=d;
  } else {
    spieldauer[4]-=(time()-spieldauer[3]);
  }
  spieldauer[3]=time();  // Letzte Zeitpruefung
  Set(P_DAILY_PLAYTIME,spieldauer);
  if (spieldauer[4]<0) { // Keine Zeit mehr uebrig fuer heute
    if (!interactive(ME))
      return 1;
    write("Du hast lange genug gemuddet fuer heute.\n");
    say(Name(WER)+" hat fuer heute genug gemuddet.\n");
    remove_interactive(ME);
    return 1;
  }
  return 0;
}

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

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

protected int CheckTelnetKeepAlive

(

)

Sendet ggf.

Telnet Timing Marks als Keep-Alive Pakete an den Client. Wird in heart_beat() gerufen.

Rückgabe:

1, falls der Spieler Keep-Alive Paket wuenscht, sonst 0.

Siehe auch:

heart_beat()

Definiert in Zeile 684 der Datei base.c.

Benutzt send_telnet_timing_mark() und telnet_tm_counter.

Wird benutzt von heart_beat().

                                     {
  if (telnet_tm_counter > 0) {
    // Spieler hat offenbar ein Keep-Alive konfiguriert ...
    if (!(--telnet_tm_counter)) {
      // und das Intervall ist gerade abgelaufen.
      // Prop offenbar gesetzt, FEature ist wirklich gewuenscht,
      // Telnet Timing Mark senden 
      send_telnet_timing_mark();
      // alle 300 HBs (600s, 10min).
      telnet_tm_counter = 300;
    }
    return 1; // Keep-Alive ist eingeschaltet
  }
  return 0;
}

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

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

protected void create

(

)

Setzt Defaultwerte vor dem Laden des Savefiles.

Definiert in Zeile 117 der Datei base.c.

Benutzt AddId(), autoload, autoload_error, autoload_rest, call_out(), create(), F_MODE, F_MODE_AD, F_MODE_AS, F_SET_METHOD, hc_play, ndead_currently, ndead_l_filename, ndead_lasttime, ndead_location, ndead_next_check, NETDEAD_CHECK_TIME, NEUTER, NOSETMETHOD, P_ALIGN, P_ALLOWED_SHADOW, P_ARTICLE, P_CALLED_FROM_IP, P_CAN_FLAGS, P_CARRIED_VALUE, P_CLOCKMSG, P_CLONE_MSG, P_CMSG, P_DAILY_PLAYTIME, P_DEADS, P_DESTRUCT_MSG, P_DMSG, P_EXTRA_LOOK, P_FAO, P_FAO_PORTALS, P_GENDER, P_GHOST, P_GUILD, P_GUILD_LEVEL, P_GUILD_RATING, P_GUILD_TITLE, P_HANDS, P_HOMEPAGE, P_ICQ, P_INFORMME, P_LAST_LOGIN, P_LAST_LOGOUT, P_LAST_QUIT, P_LEVEL, P_LOCATION, P_LONG, P_MAILADDR, P_MARRIED, P_MAX_ALCOHOL, P_MAX_DRINK, P_MAX_FOOD, P_MAX_HANDS, P_MAX_HP, P_MAX_POISON, P_MAX_SP, P_MESSENGER, P_MORE_FLAGS, P_NEEDED_QP, P_NETDEAD_ENV, P_NEWBIE_GUIDE, P_NEWSKILLS, P_NO_ASCII_ART, P_PROMPT, P_READ_NEWS, P_SCREENSIZE, P_SECOND, P_SHOW_EXITS, P_SHOWEMAIL, P_START_HOME, P_TELNET_KEEP_ALIVE, P_TESTPLAYER, P_TIMEZONE, P_TITLE, P_TTY, P_VISUALBELL, P_WAITFOR, P_WAITFOR_REASON, P_WANTS_TO_LEARN, P_WEIGHT, P_WEIGHT_PERCENT, PROTECTED, QueryProp(), realip, REQ_QP, SAVE, SECURED, Set() und SetProp().

{
  if(QueryProp(P_LEVEL)) 
  {
    return; // darf nur EINMAL gemacht werden
  }
  call_out("checkConsistency", 0);

  ndead_next_check=NETDEAD_CHECK_TIME;
  ndead_lasttime=0;
  ndead_location=0;
  ndead_l_filename=0;
  ndead_currently=0;
  ndead_next_check=0;
  hc_play=0;
  
  command::create();
  properties::create();
  description::create();
  attributes::create();
  clothing::create();
  combat::create();
  life::create();
  comm::create();
  viewcmd::create();
  quests::create();
  restrictions::create();
  moving::create();
  travel::create();
  skills::create();
   
  SetProp(P_LEVEL, -1);
  Set(P_LEVEL, SAVE|SECURED, F_MODE_AS);
  Set(P_GHOST, SAVE, F_MODE_AS);
  SetProp(P_SCREENSIZE, 20);
  Set(P_SCREENSIZE, SAVE,F_MODE_AS);
  Set(P_MORE_FLAGS, SAVE, F_MODE_AS);
  SetProp(P_WEIGHT_PERCENT,100);
  SetProp(P_LONG, 0);
  SetProp(P_TITLE, "der hoffnungsvolle Anfaenger");
  SetProp(P_ALIGN, 0);
  SetProp(P_GENDER, NEUTER);
  Set(P_GENDER, SAVE, F_MODE_AS);
  SetProp(P_TTY, "vt100");
  Set(P_TTY, SAVE, F_MODE_AS);
  SetProp(P_WEIGHT, 75000);
  SetProp(P_MAX_HP,50);
  SetProp(P_MAX_SP,50);
  SetProp(P_MAX_FOOD,100);
  SetProp(P_MAX_DRINK,100);
  SetProp(P_MAX_ALCOHOL,100);
  SetProp(P_MAX_POISON,10);
  SetProp(P_HANDS, ({" mit blossen Haenden", 30}));
  Set(P_HANDS, SAVE, F_MODE_AS);
  SetProp(P_MAX_HANDS, 2);

  Set(P_MARRIED, SAVE, F_MODE_AS);
  Set(P_EXTRA_LOOK, SAVE, F_MODE_AS);
  Set(P_SHOW_EXITS, SAVE, F_MODE_AS);
  Set(P_SHOW_EXITS, 1);
  Set(P_WANTS_TO_LEARN, SAVE, F_MODE_AS);
  Set(P_CAN_FLAGS, SAVE, F_MODE_AS);
  Set(P_TESTPLAYER, SAVE|PROTECTED, F_MODE_AS);
  Set(P_ALLOWED_SHADOW, SAVE|SECURED, F_MODE_AS);
  Set(P_SECOND, SAVE, F_MODE_AS);
  Set(P_INVIS, SAVE, F_MODE_AS);
  Set(P_READ_NEWS, SAVE, F_MODE_AS);
  Set(P_START_HOME, SAVE, F_MODE_AS);
  Set(P_MAILADDR, SAVE, F_MODE_AS);
  Set(P_HOMEPAGE, SAVE, F_MODE_AS);
  Set(P_ICQ, SAVE, F_MODE_AS);
  Set(P_MESSENGER, SAVE, F_MODE_AS);
  Set(P_LOCATION, SAVE, F_MODE_AS);

  Set(P_NO_ASCII_ART, SAVE, F_MODE_AS);

  Set(P_VISUALBELL, SAVE, F_MODE_AS);
  Set(P_CARRIED_VALUE, SAVE, F_MODE_AS);

  Set(P_PROMPT, "> ");
  Set(P_PROMPT, SAVE, F_MODE_AS);
  Set(P_CALLED_FROM_IP, SAVE, F_MODE_AS);
  Set(P_INFORMME,SAVE|PROTECTED,F_MODE_AS);
  Set(P_WAITFOR,SAVE|PROTECTED,F_MODE_AS);
  Set(P_WAITFOR_REASON,SAVE|PROTECTED,F_MODE_AS);
  Set(P_DAILY_PLAYTIME,SAVE|PROTECTED,F_MODE_AS);
  Set(P_NETDEAD_ENV, PROTECTED|NOSETMETHOD, F_MODE_AS);
  
  autoload = ([]);
  autoload_rest = ([]);
  autoload_error = ({});
  SetProp(P_ARTICLE,0);
  Set(P_GUILD,SAVE,F_MODE_AS);
  Set(P_GUILD_TITLE,SAVE,F_MODE_AS);
  Set(P_GUILD_LEVEL,SAVE,F_MODE_AS);
  Set(P_GUILD_RATING,SAVE,F_MODE_AS);
  Set(P_NEWSKILLS,SAVE,F_MODE_AS);
  Set(P_NEEDED_QP,REQ_QP);
  Set(P_DEADS,0);
  Set(P_DEADS, NOSETMETHOD,F_SET_METHOD);
  Set(P_DEADS,SAVE|PROTECTED|SECURED,F_MODE_AS);
  Set(P_LAST_LOGIN,-1);
  Set(P_LAST_LOGIN, NOSETMETHOD,F_SET_METHOD);
  Set(P_LAST_LOGIN,SAVE|PROTECTED|SECURED,F_MODE_AS);
  Set(P_LAST_LOGOUT,-1);
  Set(P_LAST_LOGOUT, NOSETMETHOD,F_SET_METHOD);
  Set(P_LAST_LOGOUT,SAVE|PROTECTED|SECURED,F_MODE_AS);
  Set(P_CLOCKMSG,SAVE,F_MODE_AS);
  Set(P_TIMEZONE,SAVE,F_MODE_AS);
  Set(P_SHOWEMAIL,SAVE,F_MODE_AS);
  Set(P_LAST_QUIT,SAVE|PROTECTED|SECURED,F_MODE_AS);

  Set(P_CMSG, 0, F_MODE); // to clean out the old clone messages
  Set(P_DMSG, 0, F_MODE);
  Set(P_CLONE_MSG, SAVE, F_MODE);
  SetProp(P_CLONE_MSG, "zaubert etwas hervor");
  Set(P_DESTRUCT_MSG, SAVE, F_MODE);
  SetProp(P_DESTRUCT_MSG, "verschwindet einfach");
  
  Set(P_FAO, SAVE|SECURED, F_MODE_AS);
  Set(P_FAO_PORTALS, SAVE, F_MODE_AS);

  SetProp(P_NEWBIE_GUIDE,0);
  Set(P_NEWBIE_GUIDE,SAVE,F_MODE_AS);
 
  //TODO: Remove - Property ist not needed any more.
  Set(P_TELNET_KEEP_ALIVE, PROTECTED|SAVE, F_MODE_AD);
  SetProp(P_TELNET_KEEP_ALIVE, 0);

  AddId("Interactive");
  
  realip="";
}

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

static void delayed_notify

(

string

wer

)

[static]

Teilt Merlin mit, wer reingekommen ist.

Ruft in /secure/merlin notify_player_enter() auf. Merlin loest dann zeitverzoegert in anwesenden Spielern die Ausgabe der Erwartemeldung aus.

Parameter:

[in]

wer

string - Name des reinkommenden Spielers

Definiert in Zeile 468 der Datei base.c.

{
  catch("/secure/merlin"->notify_player_enter(wer);publish);
}

void delayed_write

(

mixed *

what

)

Definiert in Zeile 3597 der Datei base.c.

Wird benutzt von notify_player_change().

{
  if (!pointerp(what)||!sizeof(what)||!pointerp(what[0]))
    return;
  tell_object(ME,what[0][0]);
  if (sizeof(what)>1&&sizeof(what[0])>1)
    call_out("delayed_write",what[0][1],what[1..]);
}

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

int disconnect

(

string

str

)

Spielerkommando 'schlafe ein'.

Ruft remove_interactive() bei Spielern, bei Magiern wird quit() gerufen, um das Magierobjekt zu zerstoeren.

Siehe auch:

quit()

Definiert in Zeile 3217 der Datei base.c.

{ 
  string verb;

  verb=query_verb();
  if (!verb)
    verb="AUTOCALL";
  if (verb[0..5]=="schlaf" && str!="ein")
  {
    notify_fail(
      "\"schlafe ein\" beendet Deine Verbindung mit "MUDNAME". Du behaeltst "
     +"Deine\nSachen, aber Vorsicht: Wenn "MUDNAME" abstuerzt, waehrend Du "
     +"weg bist,\nverlierst Du sie doch, genauso, als wenn Du Deine Verbindung "
     +"mit \"ende\"\nbeendet haettest (allerdings bekommst Du dann eine "
     +"finanzielle Entschaedigung).\n"
     +"ABER: BENUTZUNG AUF EIGENE GEFAHR !!!\n" );
    return 0;
  }
  if (IS_LEARNER(this_object()))
    return quit();
  tell_object(this_object(),
    "Dieser Befehl beendet Deine Verbindung mit "MUDNAME". Du behaeltst Deine"
   +"\nSachen, aber Vorsicht: Wenn "MUDNAME" abstuerzt, waehrend Du weg bist," +"\nverlierst Du sie doch, genauso, als wenn Du Deine Verbindung mit \"ende\""
   +"\nbeendet haettest (allerdings bekommst Du dann eine finanzielle "
   +"Entschaedigung).\n"
   +"ABER: BENUTZUNG AUF EIGENE GEFAHR !!!\n" );
  if (clonep(environment()) && !environment()->QueryProp(P_NETDEAD_INFO))
    tell_object(this_object(),"\nACHTUNG: Wenn Du hier laenger als ETWA 10 Minuten schlaefst, kommst Du nicht\nan diesen Ort zurueck !\n");
  say(capitalize(name(WER))+" hat gerade die Verbindung zu "MUDNAME" gekappt.\n");
  remove_interactive(ME);
  call_out(#'clear_tell_history,4);
  return 1;
}

static int emailanzeige

(

string

str

)

[static]

Definiert in Zeile 3820 der Datei base.c.

                                   {
  notify_fail("Syntax: emailanzeige [alle|freunde|niemand]\n");
  if(!str || str==""){
    if(!(str=QueryProp(P_SHOWEMAIL)))str="Niemandem";
    else if(str=="alle")str="allen";
    else if(str=="freunde")str="Deinen Freunden";
    else if(str=="niemand")str="niemandem";
    else{
      SetProp(P_SHOWEMAIL,0);
      str="Niemandem";
    }
    write("Deine Email wird "+str+" angezeigt.\n");
    return 1;
  }
  else if(member(({"alle","freunde","niemand"}),str)==-1)return 0;

  SetProp(P_SHOWEMAIL,str);

  if(str=="alle")str="allen";
  else if(str=="freunde")str="Deinen Freunden";
  else str="niemandem";
  write("Deine Email wird "+str+" angezeigt.\n");
  return 1;
}

int emote	(	string	str,
		int	genitiv
	)

Spielerkommando fuers emoten ':'.

Parameter:

[in]	str	Spielereingabe
[in]	genitiv	Genetivflag

Rückgabe:

1 oder 0, falls Spieler nicht emoten kann (kein CAN_EMOTE Flag in P_CAN_FLAGS).

Definiert in Zeile 1893 der Datei base.c.

{
  string *commands,message,verb;
  object living;
  int i,size;

  if (!(Query(P_CAN_FLAGS)&CAN_EMOTE)) return 0;
  if (query_verb()[0]==';') genitiv=1;
  if (query_verb()[0]==':'||query_verb()[0]==';')
    verb=query_verb()[1..]+" ";
  else
    verb="";
  str=this_player()->_unparsed_args();
  commands=explode(verb+(str||""),"#");
  message=break_string((IS_SEER(ME) ? "" : ">")
                       +capitalize(genitiv ? name(WESSEN) :
                                   name())
                       +" "+commands[0],78);
  size=sizeof(commands);
  if(size>=3)
  {
    living=find_living(lower_case(commands[1]));
    if(!living || environment(living)!=environment() ||
       (living->QueryProp(P_INVIS)) && !IS_LEARNER(ME))
    {
      write(capitalize(commands[1])+" sehe ich hier nicht!\n");
      return 1;
    }
    if(living!=this_object())
      tell_object(living,break_string((IS_SEER(this_player()) ? "" : ">")
                                    +capitalize(genitiv ?
                                                this_player()->name(WESSEN) :
                                                this_player()->name())
                                    +" "+commands[2],78));
  }
  if(size>=4)
    write(break_string(commands[3],78));
  else
    write(message);
  tell_room(environment(),message,({this_object(),living}));
  return 1;
}

static int erwarte

(

string

str

)

[static]

Definiert in Zeile 3639 der Datei base.c.

{
  string *list,*str1;
  mixed mlist;
  int i;

  if (!mappingp(mlist=QueryProp(P_WAITFOR_REASON)))
     mlist=([]);
  if (!pointerp(list=Query(P_WAITFOR)))
     list=({});

  if (!str || str=="-u")
  {
     if(Query(P_WAITFOR_FLAGS)&0x01)
       write("Du hast 'erwarte' temporaer deaktiviert.\n");
     write("Du erwartest jetzt");
     if (!sizeof(list))
        write(" niemanden mehr.\n");
     else
     {
        write(":\n");
        if (!str) list=sort_array(list,#'>);
        More(break_string(CountUp(list),78));
     }
     return 1;
  }
  if(str=="aus"){
    Set(P_WAITFOR_FLAGS,Query(P_WAITFOR_FLAGS)|0x01);
    write("Erwarte ist jetzt deaktiviert.\n");
    return 1;
  }
  if(str=="an" || str=="ein"){
    Set(P_WAITFOR_FLAGS,Query(P_WAITFOR_FLAGS)&0xFE);
    write("Erwarte ist jetzt aktiv.\n");
    return 1;
  }

  str1=explode(_unparsed_args()||""," ");
  if (sizeof(str1)==1)
  {
     if (str1[0]!="wegen")
     {
        str=capitalize(lower_case(str));
        if (member(list,str)!=-1)
        {
           SetProp(P_WAITFOR_REASON,m_delete(mlist,str));
           list-=({str});
           write(str+" aus der Liste entfernt.\n");
        } else
        {
           if (sizeof(list)>1000)
           {
             write("Du erwartest schon genuegend!\n");
             return 1;
           }
           list+=({str});
           write(str+" an die Liste angehaengt.\n");
        }
        Set(P_WAITFOR,list);
     }
     else
     {
        if (sizeof(mlist) && sizeof(list=m_indices(mlist)))
        {
           write("Du erwartest aus einem bestimmten Grund:\n");
           write(break_string(CountUp(sort_array(list,#'>))+".",78));
        }
        else write("Du erwartest niemanden aus einem bestimmten Grund.\n");
     }
     return 1;
  }
  notify_fail("Falsche Syntax, siehe 'hilfe erwarte'!\n");
  if (str1[1]!="wegen") return 0;
  if (sizeof(str1)==2)
     Show_WaitFor_Reason(capitalize(lower_case(str1[0])),0);
  else {
     string s=capitalize(lower_case(str1[0]));
     if (sizeof(str1)==3 && (str1[2]=="nichts" || str1[2]=="loeschen"))
        if (!mlist[s])
           write("Du hast "+s+" aus keinem bestimmten Grund erwartet!\n");
        else
        {
           SetProp(P_WAITFOR_REASON,m_delete(mlist,s));
           write("Du erwartest "+s+" aus keinem bestimmten Grund mehr!\n");
        }
     else
     {
        if (IS_ARCH(ME)) i=80; else if (IS_LEARNER(ME)) i=40;
        else if (IS_SEER(ME)) i=20; else i=10;
        if (!mlist[s] && sizeof(mlist)>=i)
           write("Sorry, aber Du erwartest schon genuegend Leute!\n");
        else
        {
           SetProp(P_WAITFOR_REASON,mlist+([s:implode(str1[2..]," ")]));
           Show_WaitFor_Reason(s,0);
        }
     }
  }
  return 1;
}

static int extra_input	(	string	str,
		string	look
	)			[static]

Definiert in Zeile 2684 der Datei base.c.

{
  if (str=="**")
  {
    if (look=="")
      SetProp(P_EXTRA_LOOK,0);
    else
      SetProp(P_EXTRA_LOOK,look);
    write("Ok.\n");
    return 1;
  }
  input_to("extra_input",0,look+str+"\n");
  write("]");
  return 1;
}

static int extralook

(

mixed

str

)

[static]

Definiert in Zeile 2700 der Datei base.c.

{
  if( str=="?" )
  {
    write( "Dein Extralook ist : "+QueryProp(P_EXTRA_LOOK) + "\n");
    return 1;
  }
  write("Bitte gib Deinen Extra-Look ein. Beenden mit **:\n");
  input_to("extra_input",0,"");
  write("]");
  return 1;
}

static mixed filter_who_options

(

string

str

)

[static]

Ermittelt angebene Optionen fuer das Spielerkommando 'wer'.

Parameter:

[in]

str

vom Spieler spezifizierter String von Filteroptionen: -k, -v, -a, -s (+ Langformen).

Rückgabe:

Array von Spieleroptionen als veroderte Int-Flags und Rest der Spielereingabe ohne die Optionen.

Definiert in Zeile 1678 der Datei base.c.

Benutzt i, len, WHO_ALPHA, WHO_PLAYER_VIEW, WHO_SHORT und WHO_VERTICAL.

Wird benutzt von kwho() und who().

{
  string* opt, *ans;
  int i,len,res;

  opt = explode(str," "); len=sizeof(opt);
  ans = ({});
  res = 0;
  for(i=0;i<len;i++)
    switch(opt[i]){
      case "-k":
      case "-kurz":
      res |= WHO_SHORT; break;
      case "-v":
      case "-vertikal":
      res |= WHO_VERTICAL; break;
      case "-alphabetisch":
      case "-a":
      case "-alpha":
      res |= WHO_ALPHA; break;
      case "-s":
      case "-spieler":
      res |= WHO_PLAYER_VIEW; break;
      default:
      return ({ res, implode(opt[i..]," ") });
    }
  return ({ res, 0 });

}

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

static int finger

(

string

str

)

[static]

Definiert in Zeile 3251 der Datei base.c.

{
  string ret;
  mixed xname;

  if (!str||str==""||sizeof(explode(str," ")-({"-n","-p","-s","-v"}))>1)
  {
    write("finger <spielername> oder finger <spielername@mudname>\n"+
      "Bitte nur den reinen Spielernamen verwenden, keine Namensvorsaetze oder Titel\n");
    return 1;
  }
  xname=explode(str,"@");
  if(sizeof(xname)==2)
  {
    if (xname[0]=="-n " || xname[0]=="-p " || xname[0]=="-s ")  {
      write("finger <spielername>@<mudname> - der Spielername fehlt.\n");
      return 1;
    }
    if (ret=INETD->_send_udp(xname[1],([
                   REQUEST: "finger",
                   SENDER: getuid(ME),
                   DATA: (explode(xname[0]," ")-({"-n","-p","-s"}))[0]
                   ]), 1))
            write(ret);
        else
      write("Anfrage abgeschickt.\n");
    return 1;
  }
  "/p/daemon/finger"->finger_single(str,1);
  return 1;
}

private void format	(	mixed	mud,
		mixed	hosts,
		string	output
	)

Definiert in Zeile 3292 der Datei base.c.

Wird benutzt von _inventory(), liste() und QuarterReached().

{
  output += lalign(hosts[mud][HOST_NAME], 20) + "  " +
        (hosts[mud][HOST_STATUS] ?
           hosts[mud][HOST_STATUS] > 0 ?
             "UP       " + ctime(hosts[mud][HOST_STATUS])[4..15] :
             "DOWN     " + ctime(-hosts[mud][HOST_STATUS])[4..15]
         : "UNKNOWN  Never accessed.") + "\n";
}

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

string Forschung

(

)

Definiert in Zeile 261 der Datei base.c.

Benutzt LEPMASTER.

Wird benutzt von score().

{
  return LEPMASTER->QueryForschung();
}

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

static int gemote

(

string

str

)

[static]

Spielerkommando fuers emoten im Genitiv ';'.

Ruft emote(string,int) auf.

Definiert in Zeile 2002 der Datei base.c.

{
  return emote(str, 1);
}

static void getgender

(

string

gender_string

)

[static]

Liest Spielerantwort auf die Frage nach dem Geschlecht des Chars ein.

Wird gerufen von input_to(). Uebergibt an InitPlayer3().

Siehe auch:

InitPlayer3().

Definiert in Zeile 2489 der Datei base.c.

{
    gender_string = lower_case( gender_string );

    if ( strlen(gender_string)==1 && gender_string[0] == 'm' ){
        write( "Willkommen, mein Herr!\n" );
        SetProp( P_GENDER, MALE );
    }
    else if ( strlen(gender_string)==1 && gender_string[0] == 'w' ){    
                write( "Willkommen, gnae' Frau!\n" );
        SetProp( P_GENDER, FEMALE );    
    }    
    else {
                write( "Wie? Was? Verstehe ich nicht!\n" );  
                write( "Bist Du maennlich oder weiblich? (tippe m oder w): " );    
                input_to( "getgender" );    
                return;
    }

    InitPlayer3();
}

static void getmailaddr

(

string

maddr

)

[static]

liest eMail-Adresse vom Spieler ein und speichert sie.

Uebergibt anschliessend an InitPlayer2()

Parameter:

[in]

maddr

Spielereingabe der Emailadresse.

Siehe auch:

InitPlayer2().

Definiert in Zeile 2459 der Datei base.c.

{
    if ( !stringp(maddr) || !strlen(maddr) )
        maddr = "none";

    Set( P_MAILADDR, maddr );
    InitPlayer2();
}

static string getmanpage	(	string	dir,
		string	page
	)			[static]

Gibt eine Manpage/Hilfeseite an den Spieler aus.

Beruecksichtigt hierbei die Synonymliste aus dir/.synonym, um die richtige Manpage auszugeben.

Parameter:

[in]	dir	Verzeichnis der gewuenschten Manpage
[in]	page	Name der gewuenschten Manpage

Rückgabe:

String der gewuenschten Manpage

Definiert in Zeile 1569 der Datei base.c.

Benutzt i und text().

Wird benutzt von help().

{
  string text, *syn;
  int i;

  if (dir[<1] != '/')
    dir += "/";

  if ((text=read_file(dir+page)) && strlen(text))
    return text;

  if (text = read_file(dir+".synonym")) {
    syn = regexplode(text, "([ \t][ \t]*|\n)");
    if ((i=member(syn, page))!=-1)
      return read_file(dir+syn[i+2]);
  }
  return 0;
}

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

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

static void gettty

(

string

ttystr

)

[static]

Liest Spielerantwort auf die Frage nach dem Terminaltyp ein.

Wird gerufen von input_to(). Uebergibt an InitPlayer4().

Siehe auch:

InitPlayer4().

Definiert in Zeile 2533 der Datei base.c.

{
    if ( !ttystr || ttystr == "" )
        ttystr = "dumb";

    ttystr = lower_case(ttystr);

    if ( ttystr == "vt100" ){
        write( "Dies sollte " + ANSI_BOLD + "fett" + ANSI_NORMAL + " sein.\n" );
        SetProp( P_TTY, ttystr );
    }
    else
        if ( ttystr == "ansi" ){
            write( "Dies sollte " + ANSI_RED + "rot" + ANSI_NORMAL +
                   " sein.\n" );
            SetProp( P_TTY, "ansi" );
        }
        else if ( ttystr == "dumb" ){
            write( "Ohje, oede! Besorg Dir ein besseres Terminal!\n" );
            SetProp( P_TTY, "dumb" );
        }
        else {
            write( "Dieser Terminaltyp wird nicht unterstuetzt. Nimm bitte "
                   "einen aus:\nvt100, ansi or dumb (default is dumb): " );
            input_to( "gettty" );
            return;
        }

    InitPlayer4();
}

static int gremote

(

string

str

)

[static]

Spielerkommando fuers remoten im Genitiv 'r;'.

Ruft remote(string, int) auf.

Definiert in Zeile 2010 der Datei base.c.

{
  return remote(str, 1);
}

protected void heart_beat

(

)

Heartbeat des Spielerobjektes.

Prueft taegliche Spielzeit, speichert regelmaessig den Spieler, bewegt Netztote in den Netztodenraum, ruft die HBs aus living/combat und player/life.

Definiert in Zeile 707 der Datei base.c.

Benutzt CheckDailyPlaytime(), CheckTelnetKeepAlive(), destruct(), heart_beat(), IS_LEARNER, ME, ndead_currently, ndead_lasttime, ndead_location, ndead_move_me(), ndead_next_check, ndead_revive(), NETDEAD_CHECK_TIME, quit() und save_me().

                            {
  if (!ME)
    return;
  if (ndead_currently)
  {
    if (interactive(ME))
    {
      ndead_revive();
      ndead_location=0;
    }
    else return;
  }
  else
    if (!(ndead_next_check--))
    {
      ndead_next_check=NETDEAD_CHECK_TIME;
      if (!interactive(ME))
        if (ndead_lasttime)
        {
          save_me(1);
          if (IS_LEARNER(ME))
          {
            quit();
            if (ME)
              remove();
            if (ME)
              destruct(ME);
            return;
          }
          ndead_move_me();
                  // Zumindest bei Gaesten ist das Objekt jetzt zerstoert
                  if (!objectp(this_object()))
                    return;
        }
        else
          ndead_lasttime=1;
    }
  if (ME && ndead_lasttime && interactive(ME))
    ndead_lasttime=0;
  if (CheckDailyPlaytime())
    return;

  CheckTelnetKeepAlive();

  life::heart_beat();
  combat::heart_beat();
  skills::heart_beat();
}

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

static int help

(

string

str

)

[static]

Gibt eine Hilfeseite an den Spieler aus (Spielerkommando hilfe|man).

Die Hilfeseite wird in div. Verzeichnissen gesucht (je nach Gilde, Magier-/Spielerstatus).

Parameter:

[in]

str

Name der gewuenschten Hilfeseite.

Rückgabe:

1

Definiert in Zeile 1594 der Datei base.c.

Benutzt getmanpage(), gilde, IS_LEARNER, IS_SEER, More(), P_GUILD, PL, QueryProp() und text().

                            {
  string verb, rest, text, gilde;
  mixed found;

  found=0;
  text = "";
  if (str) {
    str = implode( explode(str, ".." ), "");

    if ( sscanf( str, "gilde %s %s", gilde, rest)==2)
      str=rest;
    else
      gilde=QueryProp(P_GUILD);
    if (!gilde) gilde="abenteurer";

    if ( sscanf( str, "%s %s",verb,rest )==2 ) str = verb;

    if ((IS_LEARNER(PL)) ) {
      if (rest = getmanpage("/doc/wiz/",str)) {
        found = 1;
        text += rest;
      }
      else if (rest = getmanpage("/doc/mcmd/", str)) {
        found = 1;
        text += rest;
      }
    }

    if ((IS_SEER(PL)) /*&& !found*/ ) {
      if (rest = getmanpage("/doc/scmd/",str)) {
        if (found)
          text += "\n--------------------\n";
        found = 1;
        text += rest;
      }
    }

    if (rest = getmanpage("/doc/g."+gilde+"/",str)) {
      if (found)
        text += "\n--------------------\n";
      found = 1;
      text += rest;
    } else {
      if (rest = getmanpage("/doc/help/",str)) {
        if (found)
          text += "\n--------------------\n";
        found = 1;
        text += rest;
      }
      else if (rest = getmanpage("/doc/pcmd/",str)) {
        if (found)
          text += "\n--------------------\n";
        found = 1;
        text += rest;
      }
      else if (rest = getmanpage("/doc/REGELN/",str)) {
        if (found)
          text += "\n--------------------\n";
        found = 1;
        text += rest;
      }
    }

    if (!found)
      text = "Dazu ist keine Hilfe verfuegbar.\n";

    More(text,0);
    return 1;
  }
  if (IS_LEARNER(PL))
    text = read_file("/doc/hilfe.magier");
  else if (IS_SEER(PL))
    text = read_file("/doc/hilfe.seher");

  More(text + read_file("/doc/hilfe.spieler"), 0);
  return 1;
}

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

varargs int id	(	string	str,
		int	lvl
	)

ID-Funktion fuer Spielerobjekte.

id() fuer Spieler. Besondere Behandlung fuer Froesche und Geister, sowie Invis-Status. Gibt immer 0 zurueck, wenn P_INVIS && lvl < P_LEVEL

Parameter:

[in]	str	angefragter ID-String
[in]	lvl	Level des Anfragenden

Rückgabe:

1, falls str auf den Spieler zutrifft, 0 sonst.

Definiert in Zeile 764 der Datei base.c.

Benutzt P_FROG, P_GHOST, P_LEVEL, P_NAME, Query() und QueryProp().

{
  if (::id(str))
    return 1;
  if (Query(P_INVIS) && lvl < QueryProp(P_LEVEL))
    return 0;
  if (QueryProp(P_GHOST)&& str == "geist von "+ lower_case(QueryProp(P_NAME)))
    return 1;
  if (QueryProp(P_FROG) && str == "frosch") return 1;
  return(0);
}

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

static int idea

(

string

str

)

[static]

Setzt eine Idee an Magier ab (Spielerkommando).

Fragt nach der Idee und liest sie via idee2() ein, falls der Spieler kein Argument angeben hat.

Parameter:

[in]

str

optionale Spielereingabe der Idee

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

idea2(string)

Definiert in Zeile 1273 der Datei base.c.

Benutzt _unparsed_args(), input_to() und smart_log().

                            {
  if (!(str=_unparsed_args())) {
    write( "Was fuer eine Idee hast Du denn?\n]" );
    input_to("idea2");
    return 1;
  }
  write("Vielen Dank fuer die Hilfe.\n");
  smart_log("IDEA",str);
  return 1;
}

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

static int idea2

(

string

str

)

[static]

Setzt eine Idee an Magier ab (Spielerkommando).

Liest die Idee ein und speichert sie.

Parameter:

[in]

str

Spielereingabe der Idee

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

idea(string)

Definiert in Zeile 1290 der Datei base.c.

Benutzt smart_log().

                             {
  if (!str || str == "") {
    write("Idee abgebrochen...\n");
    return 1;
  }
  write("Vielen Dank fuer die Hilfe.\n");
  smart_log("IDEA",str);
  return 1;
}

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

static int idlezeit

(

string

player

)

[static]

Definiert in Zeile 3074 der Datei base.c.

{

  object player_ob;
  int idle;

  if ( !player || player=="" || 
       player==lowerstring(this_player()->QueryProp(P_NAME)))
  {
    write ("Du bist selber natuerlich gerade nicht idle.\n");
    return 1;  
  }

  // Welcher Spieler ist gemeint?
  player_ob=find_player(player);

  // Spieler nicht da oder Invis und Anfrager is kein Magier
  if (!player_ob || 
      (player_ob->QueryProp(P_INVIS) && !IS_LEARNER(this_player()))) 
  {
    write(capitalize(player)+" ist gerade nicht im Spiel.\n");
    return 1;
  }

  idle=query_idle(player_ob);

        // player_ob->Name() gibt bei invis-Magiern "Jemand" zurueck
  write (player_ob->QueryProp(P_NAME)+" ist "+
         (idle>=60?timediff(idle):"nicht")+" passiv.\n");

  return 1;
}

static int inform

(

string

str

)

[static]

Definiert in Zeile 3565 der Datei base.c.

{
  switch (str) {
    case "on":
    case "ein":
    case "an":
      if (Query(P_INFORMME))
    write("Das hattest Du schon so eingestellt.\n");
      else
      {
    write("Kuenftig wirst Du informiert, wenn jemand das "MUDNAME" verlaesst/betritt.\n");
    Set(P_INFORMME,1);
      }
      return 1;
    case "aus":
    case "off":
      if (!Query(P_INFORMME))
    write("Das hattest Du schon so eingestellt.\n");
      else
      {
    write("Ok.\n");
    Set(P_INFORMME,0);
      }
      return 1;
    case 0:
      write("Inform-Mode ist "+(Query(P_INFORMME)?"an":"aus")+"geschaltet.\n");
      return 1;
    }
  write("inform an oder inform aus, bitte.\n");
  return 1;
}

private void InitPlayer

(

)

Setzt die Spielerinitialisierung nach start_player() fort.

Prueft den Wert der vom Spieler getragenen Sachen (fuer Entschaedigung nach Reboot). Setzt div. Properties des "Spielerkoerpers", die eigentlich gespeichert werden, nach einem Reboot zurueck. Fragt ggf. nach eMail-Adresse und uebergibt per input_to an InitPlayer2().

Siehe auch:

InitPlayer3(),InitPlayer2(), InitPlayer(), start_player().

Definiert in Zeile 2420 der Datei base.c.

{
    string mailaddr;

    if ( QueryProp(P_CARRIED_VALUE) > 0 ){
        ndead_lasttime = QueryProp(P_CARRIED_VALUE);
        SetProp( P_CARRIED_VALUE, 0 );
    }

    // wenn es einen Crash gab, sollen Spieler nicht noch extra bestraft werden
    if ( file_time( "/save/" + getuid()[0..0] + "/" + getuid() + ".o" )
         < last_reboot_time() ){
        SetProp( P_FOOD, 0 );
        SetProp( P_DRINK, 0 );
        SetProp( P_ALCOHOL, 0 );
        SetProp( P_BLIND, 0 );
        SetProp( P_DEAF, 0 );
        SetProp( P_POISON, 0 );
        SetProp( P_GHOST, 0 );
        SetProp( P_FROG, 0 );
        SetProp( P_HP, QueryProp(P_MAX_HP) );
        SetProp( P_SP, QueryProp(P_MAX_SP) );
    }

    if ( QueryGuest() )
        Set( P_MAILADDR, "none" );
    else if ( !(mailaddr = Query(P_MAILADDR)) || mailaddr == "" ) {
            write( "Gib bitte Deine EMail-Adresse an (oder 'none'): " ); 
            input_to( "getmailaddr" );
            return;
    }
    InitPlayer2();
}

private void InitPlayer2

(

)

Prueft Geschlecht des Spielers und fragt ggf.

beim Spieler nach. Uebergibt an InitPlayer3() oder get_gender().

Siehe auch:

InitPlayer3(), get_gender().

Definiert in Zeile 2473 der Datei base.c.

{
    if( member_array( QueryProp(P_GENDER), ({ MALE, FEMALE }) ) == -1 ){
        write( "Bist Du maennlich oder weiblich: " );
        input_to( "getgender", 0 );
        return;
    }

    InitPlayer3();
}

private void InitPlayer3

(

)

Prueft Terminaltyp des Spielers und fragt ggf.

beim Spieler nach. Uebergibt an InitPlayer4() oder gettty().

Siehe auch:

InitPlayer4(), gettty().

Definiert in Zeile 2516 der Datei base.c.

{
    if ( !QueryProp(P_TTY) || QueryProp(P_TTY) == "none" ){
        write( "Waehle einen Terminaltyp (kann spaeter mit <stty> geaendert "
               "werden)\nvt100, ansi, dumb [dumb] " );
        input_to( "gettty", 0 );
        return;
    }

    InitPlayer4();
}

private void InitPlayer4

(

)

Letzte Phase der Spielerinitialisierung beim Laden des Charakters.

Ruft enable_commands(), aktiviert den Heartbeat und aktiviert die Kommandos aus den geerbten command.c, put_and_get.c, team.c, soul.c, guide.c, setzt den Living Name. Registriert UseSpell() als Catchall-Kommando. Laesst den Spieler ggf. einen Level per /std/gilde aufsteigen, ruft verzoegert delayed_notify(), loest Login-Event aus. Gibt Willkommenstexte, News und neue Mails aus. Findet den Startraum und bewegt den Spieler dorthin. Ruft FinalSetup() (aus den Rassenshells). Begrenzt Geldmenge im Spieler (wegen Bankzweities) nach Tragkraft und erstattet Geld bei Reboot. Ruft set_is_wizard(). Startet Clonen der Autoloader.

Siehe auch:

InitPlayer3(),InitPlayer2(), InitPlayer(), start_player().

Definiert in Zeile 2241 der Datei base.c.

{
    int num, str, ski;
    string err, called_from_ip;
    mixed start_place;
    object mon;

    enable_commands();
    set_heart_beat(1);
    command::initialize();
    add_put_and_get_commands();
    add_team_commands();
    add_soul_commands();
    add_guide_commands();
    add_action( "UseSpell", "", 1 );
    set_living_name( getuid() );
    while ( remove_call_out("disconnect") != -1 )
        ;

    if ( QueryProp(P_LEVEL) == -1 ){
        Set( P_LEVEL, 0 );
        catch( "/std/gilde"->advance();publish );
        Set( P_LEVEL, 1 );
    }

    if ( query_once_interactive(ME) )
        call_out( "delayed_notify", 0, getuid(ME) );

    if ( interactive(this_object()) ) {
        cat( "/etc/NEWS" );

                NewbieIntroMsg();

        if ( QueryProp(P_INVIS) && !IS_WIZARD(ME) )
            SetProp( P_INVIS, 0 );

        catch( num = "secure/mailer"->FingerMail(getuid());publish );

        if ( num )
            write( "Du hast " + num + " neue" +
                   (num == 1 ? "n Brief" : " Briefe")+" im Postamt liegen.\n" );

        catch( RegisterChannels();publish );

        if ( (called_from_ip = Query(P_CALLED_FROM_IP)) &&
             query_ip_number(ME) != called_from_ip ){
            string tmp;

            if ( stringp(tmp = query_ip_name(called_from_ip)) &&
                 tmp != called_from_ip )
                tmp = " [" + tmp + "]";
            else
                tmp = "";

            write( "Das letzte Mal kamst Du von " + called_from_ip
                   + tmp + ".\n" );
        }

        Set( P_CALLED_FROM_IP, query_ip_number(ME) );
    }

    if ( !stringp(default_home) || default_home == "" )
        default_home = "gilden/abenteurer";

    if ( IS_SEER(ME) && !IS_LEARNER(ME) )
        catch( start_place = HAUSVERWALTER->FindeHaus(getuid(ME));publish );
    else
        start_place = 0;

    if ( !start_place )
        start_place = QueryProp(P_START_HOME);

    if( objectp(start_place) || (stringp(start_place) && start_place != "" ) ){
        if ((err = catch(move( start_place, M_GO|M_SILENT|M_NO_SHOW );publish)) 
                    || !environment() )
            err = catch(move( default_home, M_GO|M_SILENT|M_NO_SHOW );publish);
    }
    else
        err = catch(move( default_home, M_GO|M_SILENT|M_NO_SHOW );publish);

    if ( err )
        catch(move( "gilden/abenteurer", M_GO|M_SILENT|M_NO_SHOW );publish);

    // Die Shell muss FinalSetup() nicht implementieren. Daher Callother
    catch( ME->FinalSetup();publish );

    // Login-event ausloesen
    EVENTD->TriggerEvent(EVT_LIB_LOGIN, ([
                  E_OBJECT: ME,
                  E_PLNAME: getuid(ME),
                  E_ENVIRONMENT: environment() ]) );

    // Schonmal sichern, falls ein Bug (Evalcost...) dazwischen kommen sollte.
    autoload_rest = autoload;

    // Um Geld-Xties mit illegal viel Geld zu vermeiden, kommt ein Check:
    if ( !IS_LEARNER(ME) && !Query(P_TESTPLAYER) &&
         mon = present( "\ngeld", ME ) ){
        // maximale Kraft, die der Spieler haette haben koennen
        str = QueryAttribute(A_STR) + 4;
        if ( Query(P_FROG) )
            str += 30;
        if ( str < 1 )
            str = QueryRealAttribute(A_STR) + 4;
        if ( str > 30 )
            str = 30;

        // Trageskill beachten
        ski = to_int(UseSkill( SK_CARRY, ([SI_SKILLARG : str ]) ));
        if ( !intp(ski) )
            ski = 0;

        // Wieviel konnte der Spieler insgesamt maximal tragen?
        num = 9200 + str * 800 + ski;
        if ( num < 3000 )
            num = 3000;

        // Verdoppeln fuer einen guten Container und nochmal 20% draufschlagen
        // zur Sicherheit. Das Ganze danach *4, um die maximale Anzahl Muenzen
        // zu erhalten.
        num = (int) (num * 8.8);

        // Geld, das zuviel ist, auf den Maximalwert kuerzen.
        // Zur Sicherheit wird mitgeloggt. Falls ein Spieler sich (zu recht)
        // beschwert, kann man immer noch wieder die Summe korrigieren ;-)
        if ( (str = mon->QueryProp(P_AMOUNT)) > num ){
            mon->SetProp( P_AMOUNT, num );
            log_file( "ZUVIEL_GELD", sprintf( "%s: %s hatte %d Muenzen bei "
                                              "sich. Korrigiert auf %d.\n ",
                                              ctime(time())[4..],
                                              capitalize(getuid(ME)),
                                              str, num ) );
        }
    }

    if ( ndead_lasttime ){
        write( "Du findest " + ndead_lasttime +
               " Muenzen, die Du beim letzten Mal verloren hast.\n" );

        if ( MayAddWeight( ndead_lasttime / 4 ) ){
            write( "Weil Du nicht mehr soviel tragen kannst, spendest Du den "+
                   "Rest der Zentralbank.\n" );

            num = (QueryProp(P_MAX_WEIGHT) - query_weight_contents()) * 4;
            ndead_lasttime = (num < 0) ? 0 : num;
        }

        AddMoney( ndead_lasttime );
        ndead_lasttime=0;
    }

    if ( !QueryProp(P_INVIS) )
        say( capitalize(name(WER)) + " betritt diese Welt.\n" );
    else
        write( "DU BIST UNSICHTBAR!\n\n" );

    if ( IS_WIZARD(getuid(ME)) )
        set_is_wizard( ME, 1 );
    else
        set_is_wizard( ME, 0 );

    if ( query_once_interactive(ME) )
        ListAwaited();

    // Autoloader werden ganz zum Schluss geclont, da das bis zum bitteren
    // (Evalcost-)Ende geschieht und danach u.U. keine Rechenzeit fuer
    // andere Aktionen mehr ueber ist
    load_auto_objects( autoload );
}

static void inits_nachholen	(	int	logout,
		object *	obs
	)			[static]

Holt seit dem letzten Ausloggen ausgefallene Inits nach.

Ruft in den uebergebenen Objekten call_init(), was einen init() ausloest, falls das Objekt seit dem letzten Ausloggen erstellt wurde.

Parameter:

[in]	logout	Zeitpunkt des letzten Logouts
[in]	obs	Array von Objekten

Siehe auch:

call_init()

Definiert in Zeile 494 der Datei base.c.

{
    filter( obs, "call_init", ME, logout );
}

private int InterpretTime

(

string

a

)

Interpretiert Angabe des Spielers fuer Spielpause.

Parameter:

[in]

a

Zeitangabe fuer Spielpause.

Rückgabe:

Zeitpunkt, Ende der Spielpause.

Definiert in Zeile 998 der Datei base.c.

Benutzt i, TM_MDAY, TM_MON, TM_YEAR und zeit.

                                   {
  // akzeptiert folgende Formate:
  //   dd.mm.jj     (Rueckgabe: 0:00 des entsprechenden Tages)

  int *ts = allocate(9);
  int i,j,k,nrargs;

  if ((nrargs=sscanf(a,"%d.%d.%d",i,j,k))==3 ||
      (nrargs=sscanf(a,"%d.%d.",i,j))==2) {
    // wenn kein jahr angegeben ist, das aktuelle nehmen.
    if (nrargs == 2)
       ts[TM_YEAR] = localtime()[TM_YEAR];
    else {
       // Zwei-Ziffern-Angabe des Jahres...
       if (k<100)
                   k += 2000;
       ts[TM_YEAR] = k;
    }
    ts[TM_MDAY] = i;
    ts[TM_MON] = j - 1;

    int zeit = mktime(ts);

    // negative und vergangene Zeiten pruefen.
    if (zeit <= time()) {
      write("Dieser Zeitpunkt liegt in der Vergangenheit.\n");
      return 0;
    }
    return zeit;
  }
  return 0;
}

static int kill

(

string

str

)

[static]

Spielerkommando 'toete'.

Prueft auf Geist, Gast, toten HC-Spieler, Waffe/freie Hand. Versucht einen Gegner zu finden und ruft dann Kill(string).

Parameter:

[in]

str

Spielereingabe

Rückgabe:

1 oder 0, falls kein potentieller Gegner bei 'toete alle' gefunden wird.

Definiert in Zeile 1795 der Datei base.c.

                            {
  object eob,wob;

  if (QueryProp(P_GHOST))
  {
    write("Das kannst Du in Deinem immateriellen Zustand nicht.\n");
    return 1;
  }
  
  if(hc_play>1)
  {
    write("DAS HAST DU HINTER DIR.\n");
    return 1;
  }
  
  if (QueryGuest())
  {
    write("Du bist doch nur Gast hier.\n");
    return 1;
  }
  if (!str || str == "") {
    write("WEN willst Du toeten?\n");
    return 1;
  }
  if( !QueryProp(P_WEAPON) && QueryProp(P_FREE_HANDS)==0 ) {
    write(
      "Dazu solltest Du eine Waffe gezueckt oder eine Hand frei haben.\n");
    return 1;
  }
  str=lower_case(str);
  if (str=="alle") {
    object livs;
    livs=filter(all_inventory(environment(PL)),
                function int (object ob) {
                    if (living(ob) && !query_once_interactive(ob)
                          && !ob->QueryProp(P_NO_GLOBAL_ATTACK)
                                  && !ob->QueryProp(P_FRIEND)) {
                                Kill(ob);
                                return 1;
                    }
                    return 0;
                } );
    // wenn Gegner gefunden, raus, ansonsten kommt die Fehlermeldung unten.
    if (sizeof(livs)) return 1;
  }
  else {
    int i=1;
    while(objectp(eob = present(str,i++,environment(PL)))) {
      if (living(eob)) break;
    }
  }
  if (!objectp(eob)) {
    // per write und return 1 ist hier mal ok, weil dies Kommando im Spieler
    // eh zuletzt in der Kommandokette ausgefuehrt wird und per return 0 eh
    // kein anderes mehr zum Zug kommt.
    write("Du siehst hier kein derartiges Wesen!\n");
    return 1;
  }
  else if (eob == PL) {
    write("Selbstmord ist keine Loesung!\n");
    return 1;
  }

  /* Kill him */
  Kill(eob);
  return 1;
}

static varargs int kkwho

(

string

str

)

[static]

Spielerkommando 'kkwer', gibt eine einfache Liste der Anwesenden aus.

Filtert unsichtbare Spieler aus, falls SPielerobjekt kein Magier ist.

Parameter:

[in]

str

Spielereingabe mit Optionen fuer wer.

Rückgabe:

1

Definiert in Zeile 1762 der Datei base.c.

Benutzt break_string(), CountUp(), filter_users(), IS_LEARNER und obs.

                                     {
  object *obs;
  string *namen;

  obs=filter_users(str);
  namen=({});
  if (IS_LEARNER(this_player())) {
    foreach(object ob: obs) {
      if (environment(ob))
        namen+=({capitalize(geteuid(ob))});
    }
  } 
  else {
    foreach(object ob: obs) {
      if (!ob->QueryProp(P_INVIS) && environment(ob))
        namen+=({capitalize(geteuid(ob))});
    }
  }
  if (sizeof(namen))
    write(break_string(CountUp(sort_array(namen,#'>),", ", ", ")+".",75));
  else
    write("Keine passenden Spieler gefunden.\n");
  
  return 1;
}

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

static int kwho

(

string

str

)

[static]

Spielerkommando 'kwer', fragt /obj/werliste ab.

Parameter:

[in]

str

Spielereingabe mit Optionen fuer wer.

Rückgabe:

1

Definiert in Zeile 1741 der Datei base.c.

Benutzt filter_who_options(), IS_LEARNER, ME, More(), P_WANTS_TO_LEARN, QueryProp(), QueryWhoListe() und WHO_SHORT.

{
  int shrt;
  mixed res;

  if(str) {
    res = filter_who_options(str);
    shrt = res[0];
    str = res[1];
  }
  More(implode( "/obj/werliste"->QueryWhoListe(
      IS_LEARNER(ME) && QueryProp(P_WANTS_TO_LEARN), shrt|WHO_SHORT ,0,str),
    "\n")+"\n\n",0);
  return 1;
}

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

string lalign	(	string	str,
		int	wid
	)

Definiert in Zeile 3283 der Datei base.c.

{
  return (str+"                                                   "+
      "                                                   ")[0..wid-1];
}

static void ListAwaited

(

)

[static]

Gibt Liste der Erwarteten Spieler an this_player() aus.

Definiert in Zeile 430 der Datei base.c.

Benutzt CountUp(), find_player(), IS_LEARNER, list, ME, ob(), P_WAITFOR und QueryProp().

{
    string *list;
    mixed mlist;
    object ob;
    int mag;

    mag=IS_LEARNER(ME);

    list=({});
    foreach(string erwartet : QueryProp(P_WAITFOR)) {
        if (objectp(ob=find_player(lower_case(erwartet)))) {
                    if (ob->QueryProp(P_INVIS)) {
                                if (mag) list+=({ sprintf("(%s)",erwartet) });
                    }
                    else list+=({erwartet});
                }
    }
    if (sizeof(list))
        printf("Anwesende Erwartete: %s.\n",
                    CountUp(sort_array(list,#'>)));

    if ((mappingp(mlist=QueryProp(P_WAITFOR_REASON))) && (sizeof(mlist)))
        {
                  foreach(string erwartet : mlist) {
                if (!(ob=find_player(lower_case(erwartet))) ||
                    (!mag && ob->QueryProp(P_INVIS)));
                else Show_WaitFor_Reason(erwartet,ob->QueryProp(P_INVIS));
                  }
                }
}

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

private void load_auto_object	(	string	file,
		mixed	data
	)

Definiert in Zeile 2790 der Datei base.c.

{
    object ob;
    string error;
   
    if( get_eval_cost() < SAFE_FOR_AUTOLOADER ) return;
    efun::m_delete( autoload_rest, file );
    autoload_error-=({file});
 
    ob = find_object(file);
    
    if (!ob)
    {
        if (file_size(file+".c")<0&&
           file_size(implode(explode(file,"/")[0..<2],"/")+
                     "/virtual_compiler.c")<0)
        {
                   log_autoload(file,"find",data,0);
           return;
        }
        if (error = catch(load_object(file);publish))
                {
                   log_autoload(file,"load",data,error);
           return;
                }
    }
    if ( error = catch(ob = clone_object(file); publish) )
    {
                log_autoload(file,"clone",data, error);
        return;
    }
    
    if ( error = catch(ob->move( ME, M_NOCHECK );publish) ) {
                log_autoload(file,"move",data, error);
        ob->remove();
        if(ob) destruct(ob);
        return;
    }
    
    if (ob)
        (void) catch(ob->SetProp( P_AUTOLOADOBJ, data );publish);
}

static void load_auto_objects

(

mapping

map_ldfied

)

[static]

Definiert in Zeile 2833 der Datei base.c.

{
    if ( (!mappingp(map_ldfied) || !sizeof(map_ldfied)) && !sizeof(autoload_rest) )
        return;

    // Mit Netztoten Spielern rechnen manche Autoloader nicht. Also
    // das Clonen unterbrechen und in Reconnect() wieder anwerfen.
    if ( !interactive() )
        return;

    // Kleiner Hack: autoload_rest ist eine globale Variable, die beim
    // Clonen der einzelnen Autoloader direkt veraendert wird.
    // So lange das Mapping noch Eintraege hat, muessen wir noch fehlende
    // Autoloader clonen.
    if ( !sizeof(autoload_rest) )
        autoload_rest = map_ldfied;

    // Schon hier einen call_out() zum "Nach"clonen von noch nicht geclonten
    // Autoloadern starten, da spaeter u.U. keine Rechenzeit mehr dafuer da ist.
    while ( remove_call_out("load_auto_objects") != -1 )
        /* do nothing */;
    
    // Mit Parameter '0' aufrufen, da das globale Mapping benutzt wird.
    // Verzoegerung 0 in rekursiven Callouts ist bloed, also 1s Delay
    call_out( "load_auto_objects", 2, 0 );
    
    // Mit catch() gegen die Evalcost-Falle!
    // Mit Absicht das walk_mapping() aus der "alten" Version erhalten und
    // nicht durch eine (einfachere) Schleife inkl. get_eval_cost() ersetzt,
    // da eine Schleife gegenueber der walk_mapping()-Loesung den Aufbau
    // der previous_object()-Kette veraendern wuerde; darauf testen aber
    // manche Objekte.
    catch( walk_mapping( autoload_rest, #'load_auto_object/*'*/ ) );
}

static varargs void log_autoload	(	string	file,
		string	reason,
		mixed	data,
		string	error
	)			[static]

Definiert in Zeile 2778 der Datei base.c.

{
  if (member(autoload_error,file)!=-1) return;
  log_file(SHELLLOG("NO_AUTO_FILE"),sprintf("%s: %s: %s\nreason: cannot %s file\ndata: %O\n%s\n",
           ctime()[4..15],capitalize(getuid()),file,reason,data,
                   (error?"Fehlermeldung: "+error+"\n":"")));
  autoload_error+=({file});
}

static int md

(

string

str

)

[static]

Setzt ein fehlendes Detail an Magier ab (Spielerkommando).

Fragt nach dem Detail und liest es via idee2() ein, falls der Spieler kein Argument angeben hat.

Parameter:

[in]

str

optionale Spielereingabe des fehlenden Details

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

md2(string)

Definiert in Zeile 1307 der Datei base.c.

Benutzt _unparsed_args(), input_to() und smart_log().

                          {
  if (!(str=_unparsed_args())) {
    write( "Fuer welches Detail fehlt denn die Beschreibung?\n]" );
    input_to("md2");
    return 1;
  }
  write("Vielen Dank fuer die Hilfe.\n");
  smart_log("DETAILS",str);
  return 1;
}

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

static int md2

(

string

str

)

[static]

Setzt ein fehlendes Detail an Magier ab (Spielerkommando).

Liest das Detail ein und speichert es.

Parameter:

[in]

str

Spielereingabe des fehlenden Details.

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

md(string)

Definiert in Zeile 1324 der Datei base.c.

Benutzt smart_log().

                           {
  if (!str || str == "") {
    write("Details abgebrochen...\n");
    return 1;
  }
  write("Vielen Dank fuer die Hilfe.\n");
  smart_log("DETAILS",str);
  return 1;
}

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

int more

(

string

str

)

Definiert in Zeile 3412 der Datei base.c.

{
  if(!str)
  {
    notify_fail("Usage: more <file>\n");
    return 0;
  }
  if (file_size(str) <= 0) {
    notify_fail(str+": No such file\n");
    return 0;
  }
  More(str, 1);
  return 1;
}

static int muds

(

)

[static]

Definiert in Zeile 3302 der Datei base.c.

Wird benutzt von Request().

                  {
  mapping hosts;
  int i;
  mixed muds, output;

  output = lalign("Mudname", 20) + "  Status   Last access";
  output += "\n" + MUDS_BAR[0..strlen(output)] + "\n";
  muds = sort_array(m_indices(hosts = INETD->query("hosts")),#'>);
  map(muds, #'format, hosts, &output);
  More(output);
  return 1;
}

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

static void ndead_move_me

(

)

[static]

Bewegt einen netztoten Spieler in den Netztotenraum Gerufen von heartbeat().

Zerstoert Gaeste, verlaesst ggf. das Team, ermittelt, ob der Spieler beim Aufwachen in das alte Environment bewegt werden soll oder in einen anderen Raum, hierzu wird im Environment P_NETDEAD_INFO abgefragt. Deaktiviert die Kommandos per disable_commands().

Definiert in Zeile 3164 der Datei base.c.

Wird benutzt von heart_beat().

                            {
  object team;
  mixed amem;

  set_heart_beat(0);
  stop_heart_beats();
  if (QueryGuest()) {
    quit();
    if (ME)
      remove();
    if (ME)
      destruct(ME);
    return;
  }
  ndead_next_check=NETDEAD_CHECK_TIME;
  ndead_currently=1;
  ndead_lasttime=0;
  ndead_location=environment();
  if (objectp(ndead_location))
    ndead_l_filename=object_name(ndead_location);
  
  if (objectp(environment())
      && sizeof(explode(object_name(environment()),"#")) > 1)
    env_ndead_info=environment()->QueryProp(P_NETDEAD_INFO);
  else
    env_ndead_info=0;
  
  if ( objectp(team=Query(P_TEAM)) )
      // Der Test auf assoziierte Teammitglieder (== FolgeNPCs)
      // verhindert, dass Spieler nach "schlafe ein" aus dem
      // Team ausgetragen werden. -- 29.01.2002 Tiamak
      //      && !objectp(amem=Query(P_TEAM_ASSOC_MEMBERS))
      //      && !(pointerp(amem) && sizeof(amem)))
    team->RemoveMember(ME);
  
  disable_commands();
  move(NETDEAD_ROOM,M_GO|M_NO_ATTACK|M_NOCHECK,"ins Reich der Netztoten");
}

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

static void ndead_revive

(

)

[static]

Belebt einen netztoten Spieler wieder.

Reaktiviert Heartbeats, bewegt den Spieler zurueck an den Ort, der eim Einschlafen zum Aufwachen ermittelt wurde (im einfachsten Fall der Raum, wo man eingeschlafen ist).

Definiert in Zeile 3113 der Datei base.c.

Wird benutzt von heart_beat().

{
    string fname;
    int ret;

    set_heart_beat(1);
    ndead_next_check = NETDEAD_CHECK_TIME;
    ndead_currently = 0;
    ndead_lasttime = 0;

    if ( !objectp(ndead_location) && 
         stringp(ndead_l_filename) && strlen(ndead_l_filename)) {
        
        if ( member( ndead_l_filename, '#' ) == -1 ){
            catch(load_object( ndead_l_filename); publish);
            ndead_location = find_object(ndead_l_filename);
        }
        else {
            ndead_location = find_object(ndead_l_filename);
            if ( !ndead_location && env_ndead_info ){
                fname = explode( ndead_l_filename, "#" )[0];
                catch(ndead_location = 
                    (load_object(fname)->SetProp(P_NETDEAD_INFO, env_ndead_info));
                    publish);
                if ( !objectp(ndead_location) ){
                    catch(load_object( ndead_location);publish);
                    ndead_location = find_object(ndead_location);
                }
            }
        }
    }

    if ( !objectp(ndead_location)
        || catch(ret = move( ndead_location, M_GO|M_SILENT );publish) 
        || ret != 1 ) {
        move( "gilden/abenteurer", M_GO|M_SILENT );
        ndead_location = environment();
    }

    //  ndead_location=0;
    ndead_l_filename = 0;
    env_ndead_info = 0;
}

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

void NetDead

(

)

Loggt einen Spieler aus und macht ihn netztot.

Bewegt einen Spieler in den Netztotenraum, deaktiviert Heartbeats im Inventar, ruft BecomesNetDead(), loest Erwartemeldungen aus, triggert Ausloggevent.

Definiert in Zeile 630 der Datei base.c.

Benutzt _set_netdead(), E_ENVIRONMENT, E_OBJECT, E_PLNAME, EVENTD, EVT_LIB_LOGOUT, ME, ndead_location, notify_player_leave(), P_LAST_LOGOUT, P_NAME, query_hc_play(), QueryProp(), remove_living_name(), RemoveChannels(), Set() und set_next_reset().

{
  object *inv;
  int num;

  catch(RemoveChannels();publish);
  
  if(query_hc_play()>1)
    say("Ploetzlich weicht alle spirituelle Energie aus "+QueryProp(P_NAME)+".\n");
  else
    say("Ploetzlich weicht alles Leben aus "+QueryProp(P_NAME)+".\n");

  _set_netdead();
  remove_call_out("quit");
  remove_living_name();
  // Wird zwar im save_me() gemacht, aber die Zeitunterschiede beim
  // fingern direkt nach dem Ausloggen fuehren immer wieder zu Verwirrungen
  if(query_once_interactive(ME) && !QueryProp(P_INVIS))
      Set(P_LAST_LOGOUT,time());
  if (ME)
    ndead_location = environment();
  if (query_once_interactive(ME))
    catch("secure/merlin"->notify_player_leave(geteuid(ME));publish);
   
  // Logout-event ausloesen
  EVENTD->TriggerEvent(EVT_LIB_LOGOUT, ([
                  E_OBJECT: ME,
                  E_PLNAME: getuid(ME),
                  E_ENVIRONMENT: environment() ]) );

  set_next_reset(900);
  /* Bei Nicht-Magier-Shells wird comm::reset() aufgerufen, das prueft, ob
     der Spieler immer noch netztot ist, und falls ja, die tmhist loescht.
     Die Methode wird von /std/shells/magier.c ueberschrieben, netztote
     Magier (die eigentlich schon anderweitig beseitigt worden sein sollten)
     werden remove()d und destruct()ed. --Amynthor 05.05.2008 */

  if (environment()) {
    catch(environment()->BecomesNetDead(ME);publish);
    inv = deep_inventory(ME)+all_inventory(environment());
  }
  else inv=deep_inventory(ME);
  foreach(object ob: inv) {
      if (objectp(ob)) //man weiss nie was BND() macht...
                  catch( call_other(ob, "BecomesNetDead", ME);publish );
  }
}

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

static int new_quit

(

)

[static]

Wrapper im quit() herum, verhindert 'ende', falls Spieler kaempft.

Rückgabe:

0 oder Rueckgabewert von quit()

Siehe auch:

quit()

Definiert in Zeile 1417 der Datei base.c.

Benutzt IS_LEARNING, ME, notify_fail(), P_LAST_COMBAT_TIME, Query() und quit().

                      {
  notify_fail("Du bist in Gedanken noch bei Deinem letzten Kampf.\n"+
              "Warte noch etwas bevor Du das Spiel verlaesst,\n"+
              "damit Du so nicht in RL weitermachst...\n");
  if (time()-Query(P_LAST_COMBAT_TIME)<120 && !IS_LEARNING(ME))
    return 0;
  return quit();
}

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

void notify_player_change	(	string	who,
		int	rein,
		int	invis
	)

Definiert in Zeile 3606 der Datei base.c.

{
  string *list,name;
  mixed mlist;

  if (invis) name="("+who+")";
    else name=who;

  if (Query(P_INFORMME))
  {
      if (rein)
        tell_object(ME,name+" ist gerade ins "MUDNAME" gekommen.\n");
      else
        tell_object(ME,name+" hat gerade das "MUDNAME" verlassen.\n");
  }

  if(Query(P_WAITFOR_FLAGS) & (0x01))return ;

  if(pointerp(list=Query(P_WAITFOR)) && sizeof(list)
      && member(list,who)!=-1) {
      if (!QueryProp(P_VISUALBELL))
                  name+=sprintf("%c",7); // Char fuer Pieps an den String anhaengen.
      delayed_write(
            ({ ({sprintf("%s   I S T   J E T Z T   %sD A !!!\n",
                                                 name,(rein?"":"N I C H T   M E H R   ")),1}) 
                    }));  
  }

  if (rein && (sizeof(mlist=QueryProp(P_WAITFOR_REASON))) &&
     (mappingp(mlist)) && (mlist[who]))
        Show_WaitFor_Reason(who,invis);
}

static int presay

(

string

str

)

[static]

Definiert in Zeile 3536 der Datei base.c.

Wird benutzt von _query_presay().

{
  if (!str=_unparsed_args())
    write("Dein Presay ist jetzt geloescht.\n");
  else
    printf("Dein Presay lautet jetzt: \"%s\".\n",str=capitalize(str));
  SetProp(P_PRESAY,str);
  return 1;
}

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

nomask int query_hc_play

(

)

gibt den HC-Modus zurueck.

Definiert in Zeile 2086 der Datei base.c.

Wird benutzt von bete() und NetDead().

{
  return hc_play;
}

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

varargs nomask int query_prevent_shadow

(

object

obj

)

Bestimmt, ob das Spielerobjekt beschattet werden darf.

Beschatten ist nur fuer Objekte erlaubt, die in /std/player/shadows abgelegt sind. Ausnahme: Testspieler mit gesetztem P_ALLOWED_SHADOW

Parameter:

[in]

obj

Objekt, was beschatten moechte.

Rückgabe:

0, wenn Beschatten erlaubt, 1 sonst.

Definiert in Zeile 2924 der Datei base.c.

{
  string what, allowed_shadow;
  int    dummy;

//  if ( Query(P_TESTPLAYER) )
//      return 0;
  
  if (obj){
    what=object_name(obj);
    if (what && what != "" &&
        sscanf(what,"/std/player/shadows/%s#%d",what,dummy)==2)
      return 0;
    
    // Einem Testspieler kann man P_ALLOWED_SHADOW auf einen zu testenden
    // Shadow setzen.
    if ( Query(P_TESTPLAYER) && 
                 stringp(what) && 
                 stringp(allowed_shadow=Query(P_ALLOWED_SHADOW) &&
                 strstr(what, allowed_shadow)==0))
                    return 0;
  }
  return 1;
}

nomask string query_real_name

(

)

Liefert die UID des Charakters zurueck, also den Charakternamen.

Rückgabe:

UID des Objekts (Charaktername).

Definiert in Zeile 2568 der Datei base.c.

                                {
  /* ACHTUNG !! DIES LFUN DARF NICHT ENTFERNT WERDEN !!! */
  /* Sie wird vom Gamedriver (zB bei F_ED) aufgerufen !! */
  /* Ich bin da zwar nicht so ueberzeugt von, dass der Driver die heutzutage
   * noch ruft, aber die halbe Mudlib ruft sie. ;-) (Zesstra, 27.4.08)
   */
  return getuid();
}

nomask string query_realip

(

)

Definiert in Zeile 4157 der Datei base.c.

Benutzt realip.

{
  return realip ? realip : "";
}

string QueryDefaultHome

(

)

Definiert in Zeile 2964 der Datei base.c.

{
  return default_home;
}

int QueryGuest

(

)

Ist dieser Character ein Gast?

Rückgabe:

1, wenn Gast, 0 sonst.

Definiert in Zeile 3206 der Datei base.c.

Wird benutzt von GiveExplorationPoint() und quit().

{
  string dummy;
  return sscanf(getuid(),"gast%d",dummy);
}

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

string QueryPrayRoom

(

)

Definiert in Zeile 2979 der Datei base.c.

Wird benutzt von init().

{
  if(hc_play>1)
  {
    return "/room/nirvana";
  }
  if(QueryProp(P_GUILD)=="chaos")
    return "/d/polar/files.chaos/swift/room/cl2tu4_3";
  if (pray_room) return pray_room;
  else return default_home;
}

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

int quit

(

)

Speichert den Spieler und loggt ihn aus (Spielerkommando 'ende').

Der Spieler wird vollstaendig ausgeloggt, d.h. das Spielerobjekt zerstoert.

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

disconnect()

Definiert in Zeile 1395 der Datei base.c.

Benutzt destruct(), ME, notify_player_leave(), P_LAST_QUIT, P_NAME, QueryGuest(), QueryProp(), remove_living_name(), RemoveChannels(), save_me() und SetProp().

Wird benutzt von heart_beat(), new_quit() und reset().

{
  int arg;
  SetProp(P_LAST_QUIT,time());
  catch(RemoveChannels();publish);
  if(!QueryGuest())
  {
    save_me(0);
    tell_object(ME,"Speichere "+QueryProp(P_NAME)+".\n");
  }
  if(environment()) catch(environment()->PlayerQuit(ME);publish);
  if (interactive(ME) && query_once_interactive(ME)) 
    catch("secure/merlin"->notify_player_leave(geteuid(ME));publish);
  remove_living_name();
  if(catch(remove();publish)) destruct(ME);
  return 1;
}

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

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

mixed RaceDefault

(

string

arg

)

Setzt Defaultwerte fuer Rassen - wird von den Shells ueberschrieben.

Definiert in Zeile 268 der Datei base.c.

Benutzt DT_BLUDGEON, P_BODY und P_HANDS.

Wird benutzt von checkConsistency() und RaceDefault().

{
  if (!arg)
    return 0;
  switch(arg)
  {
    case P_HANDS :
      return ({" mit blossen Haenden",30,DT_BLUDGEON});
    case P_BODY :
      return 0;
  }
  return 0;
}

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

private int RandomSize

(

)

Gibt eine Zufallszahl um P_AVERAGE_SIZE herum zurueck.

Rückgabe:

Zufaellige Groesse.

Definiert in Zeile 2024 der Datei base.c.

{
  return (100+random(13)-random(13)+random(13)-random(13))*
    (QueryProp(P_AVERAGE_SIZE)||170)/100;
}

varargs void Reconnect	(	int	silent,
		string	ip
	)

Velebt einen Netztoten wieder.

Wird im Login gerufen, wenn der Spieler netztot war. Aequivalent zu start_player()

Parameter:

[in]	silent	Wenn Flag gesetzt, werden keine Meldung an den Raum ausgegeben.
[in]	ip	Textuelle Repraesentation der IP-Adresse, von der der Spieler kommt.

Siehe auch:

start_player()

Definiert in Zeile 508 der Datei base.c.

Benutzt inv(), ME und ndead_location.

Wird benutzt von Reconnect().

{
    int num;
    string called_from_ip;
    object *inv;

    if ( query_once_interactive(ME) ){
        startup_telnet_negs();
        Set( P_LAST_LOGIN, time() );
    }

    enable_commands();
    set_living_name( getuid() );
    _remove_netdead();
    set_heart_beat(1);
    // Hunttimes aktualisieren und ggf. Feinde vergessen.
    update_hunt_times((time()-QueryProp(P_LAST_LOGOUT)) /__HEART_BEAT_INTERVAL__);
    // Heartbeats in Objekten im Inv reaktiveren.
    restart_heart_beats();
    // life.c will ggf. was aufraeumen
    life::reconnect();

    log_file( "REENTER", sprintf( "%-11s %s, %-15s (%s).\n",
                                  capitalize(getuid(ME)), ctime(time())[4..15],
                                  query_ip_number(ME)||"Unknown",
                                                                  query_ip_name(ME)||"Unknown" ),
              200000 );

    if ( ndead_currently )
        ndead_revive();

    if ( !silent && query_once_interactive(ME) )
        delayed_notify( getuid(ME) );

    command::reconnect();
    if ( query_once_interactive(ME) )
        modify_prompt();

    // Login-event ausloesen
    EVENTD->TriggerEvent(EVT_LIB_LOGIN, ([
                  E_OBJECT: ME,
                  E_PLNAME: getuid(ME),
                  E_ENVIRONMENT: environment() ]) );

    catch( num = "secure/mailer"->FingerMail(geteuid());publish );

    if ( num )
        write( "Du hast " + num + " neue" + (num == 1 ? "n Brief" : " Briefe")
               + " im Postamt liegen.\n" );

    if ( QueryProp(P_AWAY) )
        write( break_string( "Du bist als abwesend gekennzeichnet: " +
                             QueryProp(P_AWAY) + ".", 78 ) );

    catch( RegisterChannels(); publish );

    if ( (called_from_ip = Query(P_CALLED_FROM_IP)) &&
         query_ip_number(ME) != called_from_ip ) {
        string tmp;

        if ( stringp(tmp = query_ip_name(called_from_ip)) &&
             tmp != called_from_ip )
            tmp = " [" + tmp + "]";
        else
            tmp = "";

        write( "Das letzte Mal kamst Du von " + called_from_ip + tmp + ".\n" );
    }

    Set( P_CALLED_FROM_IP, query_ip_number(ME) );

    // falls Gegenstaende mit 'upd -ar' upgedated wurden, muessen die
    // "verloren gegangenen" init()'s nachgeholt werden
    if ( query_once_interactive(ME) && !IS_LEARNER(ME) )
        call_out( "inits_nachholen", 0, Query(P_LAST_LOGOUT),
                  all_inventory(ME) );

    // noch nicht geclonte Autoloader "nach"clonen
    while ( remove_call_out("load_auto_objects") != -1 )
        /* do nothing */;

    if ( sizeof(autoload_rest) )
        call_out( "load_auto_objects", 0, autoload_rest );

    if (ndead_location) {
      catch( ndead_location->BecomesNetAlive(ME);publish );
      inv = all_inventory(ndead_location);
      ndead_location = 0;
    }
    else
      inv = ({});

    inv += deep_inventory(ME);

    //ZZ foreach statt call_other(), damit nen bug in BNA nicht die anderen
    //BNA verhindert.
    foreach(object ob: inv) {
                //es ist nicht auszuschliessen, dass Items durch BecomesNetAlive()
                //eines anderen zerstoert werden.
                if (objectp(ob))
          catch( call_other(ob, "BecomesNetAlive", ME);publish );
    }

    // Erst an dieser Stelle, weil der Spieler u.U. durch ein BecomesNetAlive()
    // noch bewegt wurde.
    if ( !silent && environment() && object_name(environment()) != NETDEAD_ROOM )
    {
        if(query_hc_play()<=1)
          tell_room(environment(),QueryProp(P_NAME) + " weilt wieder unter den Lebenden.\n",({ME}) );
        else 
          tell_room(environment(),QueryProp(P_NAME) + " weilt wieder unter den Verstorbenen.\n",({ME}) );
    }
    
    if ( query_once_interactive(ME) )
        ListAwaited();
}

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

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

static int remote	(	string	str,
		int	flag
	)			[static]

Spielerkommando fuers remoten 'r:'.

Parameter:

[in]	str	Spielereingabe
[in]	flag	Genetivflag

Rückgabe:

1 oder 0, falls Spieler nicht emoten kann (kein CAN_REMOTE Flag in P_CAN_FLAGS).

Definiert in Zeile 1942 der Datei base.c.

{
  int m;
  string tmp, dest;
  string *exstr;
  object destpl;

  if ( !(Query(P_CAN_FLAGS) & CAN_REMOTE) )
      return 0;

  if ( !(str=_unparsed_args()) ||
       sizeof( (exstr=explode(str," ")) - ({""}) ) <= 1 ){
      write("Was willst Du zu wem `emoten`?\n");
      return 1;
  }

  dest = lower_case(exstr[0]);

  if( !(destpl=find_player( dest ) ) ||
      (destpl->QueryProp(P_INVIS) && !IS_LEARNER(ME)) ){
    write("Einen solchen Spieler gibt es derzeit nicht.\n");
    return 1;
  }

  tmp = implode( exstr[1..], " " );

  tmp = regreplace( tmp, "(^|[^#])#($|[^#])", "\\1aus der Ferne\\2", 1 );
  tmp = regreplace( tmp, "(^|[^\\^])\\^($|[^\\^])", "\\1in der Ferne\\2", 1 );
  tmp = regreplace( tmp, "##", "#", 1 );
  tmp = regreplace( tmp, "\\^\\^", "^", 1 );

  if ( strstr( tmp, "aus der Ferne" ) == -1
       && strstr( tmp, "in der Ferne" ) == -1 )
      tmp += " aus der Ferne";

  if ( QueryProp(P_INVIS) && IS_LEARNER(destpl) ){
      str = "(" + capitalize(getuid(ME));
      if ( flag )
          str += member( "sxz", str[<1] ) == -1 ? "s" : "'";
      str += ")";
  }
  else
      str = (flag ? capitalize(name(WESSEN)) : capitalize(name(WER)));

  str += " " + tmp + (member( ".?!", tmp[<1] ) == -1 ? "." : "") + "\n";

  if ( (m = destpl->Message( break_string(str,78), MSGFLAG_REMOTE )) > 0 )
      _recv(destpl, capitalize(destpl->name()) + "->" + str, MSGFLAG_REMOTE);
  else if (m == MESSAGE_CACHE)
      write( capitalize(destpl->name(WER) + " ist gerade beschaeftigt.\n") );
  else if (m == MESSAGE_IGNORE_YOU)
      write( capitalize(destpl->name(WER) + " ignoriert Dich.\n") );
  else
      write( capitalize(destpl->name(WER) + " ignoriert Deine Meldung.\n") );
  return 1;
}

varargs int remove

(

int

silent

)

Bittet das Spielerobjekt, sich zu zerstoeren.

Parameter:

[in]

silent

Flag, ob ohne Textausgaben zerstoert werden soll

Rückgabe:

Erfolg der Selbstzerstoerung

Definiert in Zeile 323 der Datei base.c.

Benutzt remove().

{
  return moving::remove(silent);
}

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

varargs int remove

(

mixed

arg

)

void reset

(

void

)

Definiert in Zeile 253 der Datei base.c.

Benutzt reset() und set_next_reset().

             { 
  comm::reset();
  // momentan kann der Reset jetzt abgeschaltet werden, da er nur die
  // TM-History loescht und ggf. von Netdead() und Disconnect() reaktiviert
  // wird.
  set_next_reset(-1);
}

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

static void restart_heart_beats

(

)

[static]

Schaltet HBs in Objekten im Inv wieder ein.

Schaltet in allen Objekten in hb_obs den Heartbeat ein. In hb_obs (glob. Var.) stehen alle Objekte, die beim letzten Aufruf von stop_heart_beats() einen HB hatten.

Siehe auch:

stop_heart_beats

Definiert in Zeile 362 der Datei base.c.

Benutzt hb_obs, i, ob() und set_object_heart_beat().

{
  int i;

  if (pointerp(hb_obs))
  {
    foreach(object ob: hb_obs)
      set_object_heart_beat(ob,1);
    hb_obs=0;
  }
}

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

int review

(

)

Definiert in Zeile 2580 der Datei base.c.

             {
  string *msg;
  write(short());
  write("Deine Bewegungen werden wie folgt gemeldet:\n"+
        "mout:  "+name(WER)+" "+(msg=explode(QueryProp(P_MSGOUT),"#"))[0]
       +" <Richtung>"+(sizeof(msg)>1 ? msg[1] : "")+".\n"+
        "min:   "+name(WER)+" "+QueryProp(P_MSGIN)+".\n"+
        "mmout: "+name(WER)+" "+QueryProp(P_MMSGOUT)+".\n"+
        "mmin:  "+name(WER)+" "+QueryProp(P_MMSGIN)+".\n"+
        (IS_LEARNER(ME) ?
         "cmsg:  "+name(WER)+" "+QueryProp(P_CLONE_MSG)+".\n"+
         "dmsg:  <Irgendetwas> "+QueryProp(P_DESTRUCT_MSG)+".\n"
         : "")+
        "Wenn Du jemanden angreifst, sieht das so aus:\n"+
        name(WER)+" greift Dich"+QueryProp(P_HANDS)[0]+" an.\n");
  return 1;
}

int save_character

(

)

Definiert in Zeile 2726 der Datei base.c.

                     {
  save_me(1);
  write("Ok.\n");
  return 1;
}

void save_me

(

mixed

value_items

)

Definiert in Zeile 2732 der Datei base.c.

{
  mixed val;
  string obnam, dummy;
  int i;

  // Gaeste werden nicht gespeichert
  if( getuid()[0..3]=="gast" )
    return;
 
  // Autoloader identifizieren und speichern
  autoload=([]);
  foreach(object ob: deep_inventory(ME)) {
    if( val = ob->QueryProp( P_AUTOLOADOBJ ) )
    {
      if( sscanf( object_name( ob ), "%s#%s", obnam, dummy )==2  )
      {
        if (obnam=="/obj/money")
          autoload[obnam] += val;
        else
          autoload += ([obnam:val]);
      }
    }
  }
  // An noch nicht geclonte Autoloader denken!
  autoload += autoload_rest;
  
  // Im Bedarfsfall Wert des Inventory bestimmen
  if (value_items)
    calculate_value();
  else
    SetProp(P_CARRIED_VALUE, 0);

  // Logout-Zeit speichern
  if(query_once_interactive(ME) && !QueryProp(P_INVIS))
    Set(P_LAST_LOGOUT,time());

  // Funktion zur Bestimmung des Gildenrating aufrufen
  dummy=GUILD_DIR+QueryProp(P_GUILD);
  if (find_object(dummy) || file_size(dummy+".c")>-1)
    catch(call_other(dummy,"GuildRating",this_object());publish);

  // Speichern des Spielers
  save_object("/"+SAVEPATH+extract(getuid(),0,0)+"/" + getuid());
}

static int score

(

string

arg

)

[static]

Gibt die Infos ueber den Char an den Spieler aus (Spielerkommando 'info').

Parameter:

[in]

arg

Wenn arg=="short", wird eine Kurzuebersicht ausgegeben.

Rückgabe:

1

Siehe auch:

short_score()

Definiert in Zeile 1431 der Datei base.c.

Benutzt al_to_title(), break_string(), CountUp(), death_suffering(), FEMALE, Forschung(), gender, i, IS_LEARNING, MALE, ME, NEUTER, P_ALIGN, P_ATTRIBUTES, P_AWAY, P_GENDER, P_GHOST, P_GUILD, P_GUILD_LEVEL, P_HP, P_LAST_COMBAT_TIME, P_LEP, P_LEVEL, P_MAX_HP, P_MAX_SP, P_POISON, P_QP, P_RACE, P_SIZE, P_SP, P_WEIGHT, P_WIMPY, P_WIMPY_DIRECTION, P_XP, QM, Query(), QueryAttributeOffset(), QueryEnemies(), QueryProp(), QueryRealAttribute(), show_age(), TeamPrefix() und WEN.

Wird benutzt von LiquidateEK() und short_score().

                             {
  string tmp, gender;
  int i,sz,val, plev;
  mixed ind;
  object *enem1, *enem2, *inv;

  if (QueryProp(P_GHOST)) {
    write("Im ewigen Leben gibt es keine Punkte.\n");
    return 1;
  }

  if((plev = QueryProp(P_LEP)/100) < 0) plev = 1;
  switch(tmp = QueryProp(P_GENDER)) {
  case MALE: gender = "maennlich"; break;
  case FEMALE: gender = "weiblich"; break;
  case NEUTER: gender = "neutral"; break;
  default: gender = lower_case(tmp);
  }

  ind = m_indices(QueryProp(P_ATTRIBUTES));
  tmp = "";
  foreach(string index: ind) {
    string aname;
    switch (index) {
      case "int": aname = "Intelligenz"; break;
      case "con": aname = "Ausdauer"; break;
      case "dex": aname = "Geschicklichkeit"; break;
      case "str": aname = "Kraft"; break;
      default:
        if(stringp(index)) aname = capitalize(index);
        else aname = "Unbekannt";
    }
    aname = sprintf("%-18'.'s %2.2d", aname+" ", QueryRealAttribute(index));
    if((val = QueryAttributeOffset(index)))
      aname += sprintf(" (%s%d)", (val>=0?"+":""), val);
    tmp += aname + "\n";
  }

  printf("- %-'-'68s\n",
         TeamPrefix()+capitalize(implode(explode(short()||"","\n"),""))+" ");
  if(arg!="short") {
    printf("Rasse ............ %-' '18s Abenteuer ........ %d %s\n",
           QueryProp(P_RACE), QueryProp(P_QP),
           (val = QM->QueryTotalQP()) == QueryProp(P_QP) ? "" : "("+val+")");
    printf("Geschlecht ....... %-' '18s Groesse .......... %d cm\n",
           gender, QueryProp(P_SIZE));
    printf("Stufe ............ %-3.3d %-' '14s Gewicht .......... %d kg\n",
           QueryProp(P_LEVEL), (QueryProp(P_LEVEL) < plev ? "("+plev+")" : ""),
           QueryProp(P_WEIGHT) / 1000);
    printf("Gilde ............ %-' '18s Gildenstufe ...... %d\n",
         capitalize(QueryProp(P_GUILD)), QueryProp(P_GUILD_LEVEL));
  }
  printf("Erfahrung ........ %-' '18s Charakter ........ %-s\n\n",
         QueryProp(P_XP)+ " Punkte", al_to_title(QueryProp(P_ALIGN)));
  printf("%#-76.2s\n\n", tmp);
  printf("Gesundheit ....... %-3.3d %-' '14s Gift ............. %s\n",
         QueryProp(P_HP),
         (QueryProp(P_HP) == (val = QueryProp(P_MAX_HP)) ? "" : "("+val+")"),
         ((val = QueryProp(P_POISON)) ?
          (val < 4 ? "leicht" : "gefaehrlich") : "gesund"));
  printf("Konzentration .... %-3.3d %-' '14s Vorsicht ......... %s\n",
         QueryProp(P_SP),
         (QueryProp(P_SP) == (val = QueryProp(P_MAX_SP)) ? "" : "("+val+")"),
         ((ind = QueryProp(P_WIMPY)) ? ""+ind : "mutig"));
  printf("Todesfolgen....... %-' '18s %s\n",
         ((val = death_suffering()) ? ""+((val+9)/10) : "kein Malus"),
         (QueryProp(P_WIMPY) && ind=QueryProp(P_WIMPY_DIRECTION))
         ? sprintf("Fluchtrichtung ... %O", ind) : "");
  printf("%s",
         (time()-Query(P_LAST_COMBAT_TIME)<120 && !IS_LEARNING(ME)) ?
         "Spiel verlassen .. nicht moeglich\n" : ""
         );

  if(arg!="short") {
    write(break_string(Forschung(), 70));
    if(ind=QueryProp(P_AWAY))
      printf("Du bist nicht ansprechbar: %O\n",ind);
  }

  if(sizeof(enem1=((mixed)QueryEnemies())[0])) {
    enem2=({});
    inv=all_inventory(environment(ME));
    foreach(object en: enem1) {
      if (member(inv,en)==-1) // Ist unser Feind und ist nicht hier
        enem2+=({en});
    }
    if(sizeof(enem2)) {
      write("Du verfolgst ");
      write(break_string(CountUp(map_objects(enem2, "name", WEN))+".", 78));
    }
  }
  if(arg!="short") show_age();
  printf("%-'-'70s\n", "");
  return 1;
}

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

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

static int self_delete

(

)

[static]

Spielerkommando 'selbstloeschung'.

Gibt Meldung aus und fragt nach einer Bestaetigung.

Rückgabe:

1 bei Erfolg, 0 sonst.

Definiert in Zeile 907 der Datei base.c.

Benutzt input_to() und MUDNAME.

{
  write(
    "     B I S T  D U  D I R  W I R K L I C H  S I C H E R ????????????\n"+
    "Wenn Du Dich selbstloeschen willst, ist Dein Charakter UNWIDERRUFLICH\n"+
    "verloren. Es gibt KEINE Moeglichkeit ihn wiederzuerschaffen. Solltest\n"+
    "Du nur zeitweilig vom "MUDNAME" wegbleiben wollen, so benutze bitte\n"+
    "den Befehl 'spielpause'.\n"+
    "Fallst Du Dich immer noch selbstloeschen willst, gib Dein Password ein."+
    "\n\n");
  write("Bitte das Password angeben: ");
  input_to("self_delete2",1);
  return 1;
}

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

int self_delete2

(

string

str

)

Spielerkommando 'selbstloeschung'.

Empfaengt Bestaetigung des Spielers und ruft Loeschfunktion in /secure/master auf.

Parameter:

[in]

str

Spielereingabe

Rückgabe:

1 bei Erfolg, 0 sonst.

Definiert in Zeile 928 der Datei base.c.

Benutzt delete_player(), E_ENVIRONMENT, E_GUILDNAME, E_PLNAME, EVENTD, EVT_LIB_PLAYER_DELETION, GUILD_DIR, ME, name, P_DEADS, P_GUILD, PL, QueryProp() und WER.

{
  int ret;
  ret=(int)"secure/master"->delete_player(str, getuid(PL));
  if (!ret)
  {
    write("Das hat nicht hingehauen (Gott sei Dank ....)\n");
    return 1;
  }
  if (QueryProp(P_GUILD)&&file_size(GUILD_DIR+QueryProp(P_GUILD)+".c")>-1)
    catch(call_other(GUILD_DIR+QueryProp(P_GUILD), "austreten");publish);

  if (QueryProp(P_DEADS) < 5) {
    write("Adios! Man sieht sich.\n");
    say(name(WER,1)+" hat sich gerade selbst zerstoert.\n");
  }
  else {
    write(
      "\nTod kommt auf seinem weissen Pferd angeritten.\n"
     +"Er steigt ab, baut sich drohend vor Dir auf und mustert Dich schadenfroh.\n"
     +"\nTod sagt: ENDLICH! NUN KANN DIR AUCH LARS NICHT MEHR HELFEN!\n"
     +"\nTod holt weit mit seiner Sense aus. Mit grossem Schwung laesst er sie auf\n"
     +"Dich zusausen und dann...\n");
    say(name(WER,1)+" schied gerade endgueltig von uns.\n");
  }

  // Event ausloesen. ;-)
  EVENTD->TriggerEvent(EVT_LIB_PLAYER_DELETION, ([
                E_PLNAME: getuid(ME),
                E_ENVIRONMENT: environment(),
                E_GUILDNAME: QueryProp(P_GUILD) ]) );

  remove(1);
  return 1;
}

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

int set_ascii_art

(

string

str

)

Definiert in Zeile 3371 der Datei base.c.

{
  if (str!="ein"&&str!="aus")
  {
     printf("Du moechtest 'Grafik' "+(QueryProp(P_NO_ASCII_ART)?"NICHT ":"")+
                                     "sehen.\n");
  }

  if (str=="ein") {
    SetProp(P_NO_ASCII_ART, 0);
    printf("Zukuenftig moechtest Du 'Grafik' sehen.\n");
  }

  if (str=="aus") {
    SetProp(P_NO_ASCII_ART, 1);
    printf("Zukuenftig moechtest Du KEINE 'Grafik' mehr sehen.\n");
  }


  return 1;
}

static mixed set_email

(

string

str

)

[static]

Setzt Email-Adresse des Spielers (Spielerkommando).

Parameter:

[in]

str

Spielereingabe

Rückgabe:

1 bei Erfolg, 0 sonst.

Definiert in Zeile 890 der Datei base.c.

Benutzt _unparsed_args(), P_MAILADDR, QueryProp() und SetProp().

{
  if (!(str=_unparsed_args())) {
    write("Deine offizielle Email-Adresse lautet: " + QueryProp(P_MAILADDR)
          +"\n");
    return 1;
  }
  write("Deine offizielle Email-Adresse wurde geaendert.\n");
  if (str=="keine") str="none";
  SetProp(P_MAILADDR, str); // rumata: return entfernt
  return 1;
}

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

varargs nomask void set_hc_play	(	string	str,
		int	val
	)

Setzt den HC-Modus.

Definiert in Zeile 2065 der Datei base.c.

{
   string str1;

    str1 = explode( object_name(previous_object()), "#" )[0];
    
    if ( str1 != "/secure/login" &&
         previous_object()!=this_object() &&
         extern_call() &&
         (!geteuid(ME) || geteuid(ME) != getuid(ME) ||
          capitalize(geteuid(ME)) != str ||
          geteuid(ME) != geteuid(previous_object())) ){
        write( "DIESER VERSUCH WAR ILLEGAL !!\n" );
        return;
    }
    
    hc_play=val;
}

static int set_homepage

(

string

str

)

[static]

Setzt Spielerhomepage (Spielerkommando).

Parameter:

[in]

str

Spielereingabe

Rückgabe:

1 bei Erfolg, 0 sonst.

Definiert in Zeile 780 der Datei base.c.

Benutzt _unparsed_args(), P_HOMEPAGE, QueryProp() und SetProp().

{
  mixed tmp;
  if (!(str=_unparsed_args())) {
    if (!QueryProp(P_HOMEPAGE))
      write("Du hast keine URL-Adresse gesetzt!\n");
    else
      write("Deine offizielle URL-Adresse lautet: " + QueryProp(P_HOMEPAGE)
            +"\n");
    return 1;
  }
  write("Deine offizielle URL-Adresse wurde geaendert.\n");
  if (str=="keine") 
    SetProp(P_HOMEPAGE, 0);
  else {
    tmp = filter(regexplode(str, "[<][^>]*[>]"),
                       lambda(({'e}), ({#'!=, ({#'[, 'e, 0}), '<'})));
    write("Sie lautet jetzt: "+(str = implode(tmp, ""))+"\n");
    SetProp(P_HOMEPAGE, str);
  }
  return 1;
}

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

static int set_icq

(

string

str

)

[static]

Setzt ICQ-UIN des Spielers (Spielerkommando).

Parameter:

[in]

str

Spielereingabe

Rückgabe:

1 bei Erfolg, 0 sonst.

Definiert in Zeile 836 der Datei base.c.

Benutzt P_ICQ, QueryProp() und SetProp().

                               {
  int num;

  if (!str || str=="") {
    if (!num=QueryProp(P_ICQ))
      write("Du hast keine ICQ-Nummer gesetzt!\n");
    else
      printf("Deine ICQ-Nummer lautet: %d\n",num);
    return 1;
  }
  if (sscanf(str,"%d",num)!=1 || !num) {
    write("Deine ICQ-Nummer wurde geloescht.\n");
    SetProp(P_ICQ, 0);
  } else {
    write("Deine ICQ-Nummer wurde geaendert.\n");
    printf("Sie lautet jetzt: %d\n",num);
    SetProp(P_ICQ, num);
  }
  return 1;
}

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

int set_keep_alive

(

string

str

)

Definiert in Zeile 4049 der Datei base.c.

                               {
  if (str == "ein") {
    telnet_tm_counter = 600 / __HEART_BEAT_INTERVAL__;
    tell_object(this_object(), break_string(
                "An Deinen Client werden jetzt alle 10 Minuten unsichtbare Daten "
                "geschickt, um zu verhindern, dass Deine Verbindung zum "MUDNAME
                " beendet wird.", 78));
  }
  else if (str == "aus") {
    telnet_tm_counter = 0;
    tell_object(this_object(),break_string(
                "Du hast das Senden von unsichtbaren Daten (Keep-Alive-Pakete) an "
                "Deinen Client ausgeschaltet.",78));
  }
  else {
    if (!telnet_tm_counter)
      tell_object(this_object(), break_string(
                "An Deinen Client werden keine Keep-Alive-Pakete geschickt.",78));
    else
      tell_object(this_object(), break_string(
                "An Deinen Client werden alle 10 Minuten " 
                "unsichtbare Daten geschicht, damit Deine Verbindung "
                "zum "MUDNAME" nicht beendet wird.",78));
  }
  return 1;
}

static int set_location

(

string

str

)

[static]

Setzt Spieler-Wohnort (Spielerkommando).

Parameter:

[in]

str

Spielereingabe

Rückgabe:

1 bei Erfolg, 0 sonst.

Definiert in Zeile 807 der Datei base.c.

Benutzt _unparsed_args(), F_VALUE, P_LOCATION, Query() und Set().

{
    mixed ort;

    if ( str == "0" || str == "loeschen" ){
        Set( P_LOCATION, 0 );
        write( "Du loescht Deine Ortsangabe.\n" );
        return 1;
    }

    if ( stringp(str = _unparsed_args()) && str != "" ){
        Set( P_LOCATION, capitalize(str) );
        printf( "Du aenderst Deine Ortsangabe auf \"%s\".\n",
                Query(P_LOCATION) );
    }
    else if ( stringp(ort = Query(P_LOCATION)) )
        printf( "Deine Ortsangabe lautet \"%s\".\n", Query(P_LOCATION) );
    else{
        Set( P_LOCATION, 0, F_VALUE );
        write( "Du hast keine Ortsangabe gesetzt.\n" );
    }

    return 1;
}

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

static int set_messenger

(

string

str

)

[static]

Setzt Instant Messanger vom Spieler (Spielerkommando).

Parameter:

[in]

str

Spielereingabe

Rückgabe:

1 bei Erfolg, 0 sonst.

Definiert in Zeile 861 der Datei base.c.

Benutzt _unparsed_args(), P_ICQ, P_MESSENGER, QueryProp() und SetProp().

                                     {
  int num;
  string s;

  if (!str || str=="") {
    if (!s=QueryProp(P_MESSENGER))
      if (!num=QueryProp(P_ICQ)) 
        write("Du hast keine Messenger-ID gesetzt.\n");
      else 
        printf("Du hast keine Messenger-ID gesetzt, aber eine ICQ-Nummer: %d\n", num);
    else
      printf("Deine Messenger-ID lautet: %s\n", s);
    return 1;
  }
  if (str=="loeschen" || str=="keine") {
    write("Deine Messenger-ID wurde geloescht.\n");
    SetProp(P_MESSENGER, 0);
  } else {
    s = _unparsed_args();
    printf("Deine Messenger-ID lautet nun: %s\n", s);
    SetProp(P_MESSENGER, s);
  }
  return 1;
}                                     

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

nomask void set_realip

(

string

str

)

Definiert in Zeile 4149 der Datei base.c.

Benutzt realip.

{
  if(previous_object() && strstr(object_name(previous_object()),"/secure")==0)
  {
    realip=str;
  }
}

static int set_screensize

(

string

str

)

[static]

Definiert in Zeile 3461 der Datei base.c.

{
  int size;

  if (str && (str[0..2] == "abs" || str[0..2]=="rel")) {
    size = QueryProp(P_MORE_FLAGS);
    if (str[0..2] == "abs") {
      size |= E_ABS;
      write("Es wird beim Prompt die Zeilenzahl des Textes angegeben.\n");
    }
    else {
      size &= ~E_ABS;
      write("Es wird beim Prompt der prozentuale Anteil des Textes angegeben.\n");
    }
    SetProp(P_MORE_FLAGS, size);
    return 1;
  }

  if ( str && (str=="auto" || sscanf( str, "auto %d", size )) ){
      if ( size > 0 ){
          write("Ungueltiger Wert! "
                "In Verbindung mit 'auto' sind nur negative Werte erlaubt.\n");
          return 1;
      }

      SetProp( P_SCREENSIZE, size-1 );

      write("Ok, Deine Zeilenzahl wird nun automatisch ermittelt (derzeit "+
            QueryProp(P_SCREENSIZE)+").\n"+
            break_string("Bitte beachte, dass dies nur einwandfrei "
                         "funktioniert, wenn Dein Client Telnetnegotiations "
                         "unterstuetzt (siehe auch \"hilfe telnegs\").") );
    return 1;
  }

  if ( !str || str=="" || !sscanf( str, "%d", size ) || size < 0 || size > 100){
      write(break_string(
            sprintf("Mit dem Befehl 'zeilen <groesse>' kannst Du einstellen, "
            "wieviele Zeilen bei mehrseitigen Texten auf einmal ausgegeben "
            "werden. Die angegebene Groesse muss zwischen 0 und 100 liegen. "
            "Bei Groesse 0 wird einfach alles ausgegeben (ohne Pause). Mit "
            "der Einstellung 'auto' wird die Groesse automatisch ueber "
            "die Telnetnegotiations ermittelt (siehe auch 'hilfe telnegs'). "
            "Um nach einer Seite Text noch etwas Platz zu haben, kann man z.B. "
            "'zeilen auto -3' einstellen.\n"
            "Die Voreinstellung ist 20 Zeilen.\n"
            "Mit 'zeilen abs[olut]' und 'zeilen rel[ativ]' kannst Du fest"
            "legen, ob im Prompt bei langen Texten die aktuelle Zeilennummer "
            "oder eine prozentuale Angabe ausgegeben wird.\n"
            "Deine aktuelle Einstellung ist %d%s Zeilen (%s).",
            QueryProp(P_SCREENSIZE),
            Query(P_SCREENSIZE) < 0 ? " 'automatische'" : "",
            QueryProp(P_MORE_FLAGS) & E_ABS ? "absolut" : "relativ"),78,0,1));
    return 1;
  }

  SetProp( P_SCREENSIZE, size );

  printf( "Okay, Deine Zeilenzahl steht nun auf %d.\n", size );
  return 1;
}

static int set_title

(

string

str

)

[static]

Definiert in Zeile 2659 der Datei base.c.

{
  string bonus;
  
  if(!IS_SEER(this_object()) && !FAO_HAS_TITLE_GIFT(this_object()) )
  {
    return 0;
  }
  
  bonus = "";
  if (!(str=_unparsed_args()))
    str = "";
  else if( str[0..2]=="\\b," || str[0..2]=="\\b'" )
  {
    bonus = "\b"; // ein backspace fuer ein (hoch)komma ist ok! :-)
    str = str[2..];
  }
  if(str=="0")  // damit der Gildentitel zum Vorschein kommen kann
    SetProp(P_TITLE, 0);
  else
    SetProp(P_TITLE, bonus+str);
  write("Ok.\n");
  return 1;
}

static int set_visualbell

(

string

str

)

[static]

Definiert in Zeile 3427 der Datei base.c.

{
  if(!str)
  {
    write("Derzeitige Einstellung fuer Tonausgabe: "+
         (QueryProp(P_VISUALBELL)?"AUS":"EIN")+".\n");
    return 1;
  }
  if (str=="ein")
  {
    if(!QueryProp(P_VISUALBELL))
      write("Die Tonausgabe stand schon auf EIN.\n");
    else
      {
  SetProp(P_VISUALBELL,0);
        write("OK, Tonausgabe auf EIN gestellt.\n");
      }
  }
  else
    if (str=="aus")
    {
      if(QueryProp(P_VISUALBELL))
        write("Die Tonausgabe stand schon auf AUS.\n");
      else
        {
          SetProp(P_VISUALBELL,1);
    write("OK, Tonausgabe auf AUS gestellt.\n");
  }
    }
    else
      write("Syntax: ton [ein|aus]\n");
  return 1;
}

static int setcmsg

(

string

str

)

[static]

Definiert in Zeile 2643 der Datei base.c.

{
  SetProp(P_CLONE_MSG, _unparsed_args()||"zaubert etwas aus "
          + QueryPossPronoun(MALE,WEM) + " Aermel hervor");
  write("Ok.\n");
  return 1;
}

string SetDefaultHome

(

string

str

)

Definiert in Zeile 2955 der Datei base.c.

Wird benutzt von create().

{
  if(hc_play>1)
  {
    pray_room="/room/nirvana";
  }
  return default_home=str;
}

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

static int setdmsg

(

string

str

)

[static]

Definiert in Zeile 2651 der Datei base.c.

{
  SetProp(P_DESTRUCT_MSG, _unparsed_args()||"wird von " + name(WER,1)
          + " zerstaeubt");
  write("Ok.\n");
  return 1;
}

static int sethands

(

string

str

)

[static]

Definiert in Zeile 3546 der Datei base.c.

{
  mixed *hands;

  if (!(str=_unparsed_args()))
  {
    write("sethands <message>\n");
    return 1;
  }
  if (str=="0")
      hands=RaceDefault(P_HANDS);
  if (!hands || !pointerp(hands))
      hands=Query(P_HANDS);
  hands[0]=" "+str;
  Set(P_HANDS,hands);
  write("Ok.\n");
  return 1;
}

static int setmin

(

string

str

)

[static]

Definiert in Zeile 2602 der Datei base.c.

{
  SetProp(P_MSGIN, _unparsed_args()||"kommt an");
  write("Ok.\n");
  return 1;
}

static int setmmin

(

string

str

)

[static]

Definiert in Zeile 2629 der Datei base.c.

{
  SetProp(P_MMSGIN, _unparsed_args()||"erscheint");
  write("Ok.\n");
  return 1;
}

static int setmmout

(

string

str

)

[static]

Definiert in Zeile 2636 der Datei base.c.

{
  SetProp(P_MMSGOUT, _unparsed_args()||"verschwindet");
  write("Ok.\n");
  return 1;
}

static int setmout

(

string

str

)

[static]

Definiert in Zeile 2609 der Datei base.c.

{
  string *msg;

  if(sizeof(msg=explode((_unparsed_args()||"geht"),"#"))>2)
  {
    write("Du darfst nur einmal '#' fuer die Richtung angeben.\n");
    return 1;
  }
  if(sizeof(msg)>1)
  {
    if (msg[0]!="" && msg[0][<1]==' ') msg[0]=msg[0][0..<2];
    SetProp(P_MSGOUT, msg[0]+"#"+msg[1]);
  }
  else
    SetProp(P_MSGOUT, _unparsed_args()||"geht");
  write("Ok.\n");
  return 1;
}

string SetPrayRoom

(

string

str

)

Definiert in Zeile 2969 der Datei base.c.

Wird benutzt von create().

{
  if(hc_play>1)
  {
    pray_room="/room/nirvana";
  }
  pray_room=str;
  return(str);
}

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

static int short_score

(

string

arg

)

[static]

Gibt eine kuerzere Info ueber den Char aus (Spielerkommando punkte|score).

Ruft score("short").

Parameter:

[in]

arg

UNUSED

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

score(string), very_short_score()

Definiert in Zeile 1533 der Datei base.c.

Benutzt score().

                                   {
  return score("short");
}

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

int show_telnegs

(

string

arg

)

Definiert in Zeile 4022 der Datei base.c.

{
    if (!arg)
    {
        write("Du bekommst Aenderungen Deiner Fenstergroesse "+
              (QueryProp(P_TTY_SHOW)?"":"nicht ")+"angezeigt.\n");
        return 1;
    }
    if (member(({"ein","an","aus"}),arg)==-1)
    {
        write("Syntax: telnegs [ein|aus]\n");
        return 1;
    }
    if (arg=="ein" || arg=="an")
    {
        write("Du bekommst "+(QueryProp(P_TTY_SHOW)?"":"nun ")+
              "Aenderungen Deiner Fenstergroesse angezeigt.\n");
        Set(P_TTY_SHOW,1);
        return 1;
    }
    write("Du bekommst "+(QueryProp(P_TTY_SHOW)?"nun ":"")+
          "Aenderungen Deiner Fenstergroesse nicht "+
          (QueryProp(P_TTY_SHOW)?"mehr ":"")+"angezeigt.\n");
    Set(P_TTY_SHOW,0);
    return 1;
}

static void Show_WaitFor_Reason	(	string	who,
		int	invis
	)			[static]

Gibt Erwartemeldung mit Grund aus.

Parameter:

[in]	who	string - Wer ist hereingekommen?
[in]	invis	int - Ist der Spieler Invis?

Definiert in Zeile 414 der Datei base.c.

Benutzt list, ME, name, P_WAITFOR_REASON und QueryProp().

Wird benutzt von notify_player_change().

{
  mixed list;
  string reason,name;

  if (invis) name="("+who+")";
    else name=who;
  if ((mappingp(list=QueryProp(P_WAITFOR_REASON))) && (reason=list[who]))
    tell_object(ME,sprintf("\nDu erwartest %s wegen:\n%s\n",name,reason));
  else
    tell_object(ME,sprintf("Du erwartest %s aus keinem bestimmten Grund.\n",
      name));
}

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

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

void smart_log	(	string	myname,
		string	str
	)

Loggt eine Spielermeldung an Magier.

Loggt die Spielermeldung in das passende File unter /log/report/ oder im vom Magier gewuenschten File. Hierbei werden Fehler, Ideen, MDs und Typos in getrennte Files sortiert.

Parameter:

[in]	str	Spielermeldung
[in]	myname	Art der Spielermeldung (DETAILS, BUG, TYPO, MD)

Siehe auch:

md(string), idea(string), bug(string), typo(string)

Definiert in Zeile 1342 der Datei base.c.

Benutzt creat(), log_file, MASTER, P_LOG_FILE, P_REFERENCE_OBJECT, QueryProp(), ROOTID und strftime().

Wird benutzt von bug(), bug2(), idea(), idea2(), md(), md2(), typo() und typo2().

{
  string creat, creat_det, date, filext, obnam, rest;
  object obj;

  if( sscanf(str,"%s:%s",obnam,rest)==2 &&
      ((obj=present(obnam,environment())) || (obj=present(obnam)) )
      )
    str = rest;
  else {
    obj = QueryProp(P_REFERENCE_OBJECT);
    if (!obj || !present(obj))
      obj = environment(this_interactive());
  }

  date = strftime("%d. %b %Y");

  if(!(creat = obj->QueryProp(P_LOG_FILE))){
    creat = MASTER->creator_file(obj);
    if (member(creat, '.')!=-1) creat=explode(creat, ".")[<1];

    if (creat == ROOTID)
      creat = "ROOT";
    else if( !creat || creat[0]==' ' )
      creat="STD";
    switch(myname)
    {
      case "DETAIL":
      filext = ".det"; break;
      default:
      filext = ".rep"; break;
    }

    creat=regreplace(creat,":","_",1);
    creat_det = "report/" + creat + "_" + myname + filext;
    creat = "report/" + creat + filext;
  }

  if (!obj->SmartLog(creat, myname, str, date)) {
    str = myname + " von " + getuid(this_interactive()) + " [" 
      + object_name(obj) + "] (" + date + "):\n" + str + "\n";
    log_file(creat, str);
    // Noch einmal im spezialisierten Logfile
    log_file( creat_det, str );
  }
}

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

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

static int spieldauer

(

string

str

)

[static]

Setzt neue taegliche Spieldauer (Spielerkommando).

Parameter:

[in]

str

Spielereingabe

Rückgabe:

1 bei Erfolg, 0 sonst.

Definiert in Zeile 968 der Datei base.c.

Benutzt min, notify_fail(), P_DAILY_PLAYTIME und Set().

Wird benutzt von CheckDailyPlaytime().

                                  {
  int min,day;
  string foo;

  notify_fail("  spieldauer <x> minuten fuer %d tage\noder\n"+
              "  spieldauer <x> stunden fuer %d tage\n");
  if (!str)
    return 0;
  if (sscanf(str,"%d stunde%s fuer %d tag%s",min,foo,day,foo)==4)
    min*=60;
  else if (sscanf(str,"%d minute%s fuer %d tag%s",min,foo,day,foo)!=4)
    return 0;
  if (min<5)
    min=5;
  if (min>=1440)
    return notify_fail("Witzbold.\n"),0;

  Set(P_DAILY_PLAYTIME,
      ({min*60,time()/86400+day,time()/86400,time(),min*60}));
  // 0:Minuten pro Tag, 1:Nr. des letzen Tages, 2:Nr. des angefangenen Tages,
  // 3:letzte Zeitpruefung, 4:verbleibende Zeit
  printf("Du darfst die naechsten %d Tag(e) nur noch\n"+
   "%d Minuten am Tag mudden.\n",day,min);
  return 1;
}

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

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

static int spielpause

(

string

str

)

[static]

Setzt neue Spielpause (Spielerkommando).

Fragt vorher nach Bestaetigung durch den Spieler.

Parameter:

[in]

str

Spielereingabe

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

spielpause2()

Definiert in Zeile 1037 der Datei base.c.

Benutzt _unparsed_args(), input_to(), InterpretTime(), master, notify_fail() und strftime().

{
  int days,endezeit;
  string foo;

  notify_fail("spielpause <x> tage          oder\n"+
              "spielpause bis tt.mm[.jj]\n");
  if (!str) return 0;
  if(sscanf(_unparsed_args(),"bis %s",foo)==1) {
    endezeit = InterpretTime(foo);
    if (endezeit == 0) 
                return 0;
    days = ((endezeit - time()) / 86400) + 1;
  }
  else if(sscanf(str, "%d tag%s", days, foo) == 2) {
    if (days < 0)
                days = -1;
    else
                endezeit = (time()/86400) * 86400 + days * 86400;
  }
  else return 0;

  if (days > 0)
    write(strftime("Du wirst Dich erst wieder am %d.%m.%Y einloggen koennen!\n",
                  endezeit));
  else if (days < 0)
    write( "Du wirst Dich auf unbestimmte Zeit nicht mehr einloggen koennen.\n"
          +"Wenn Du wieder spielen willst, musst Du Dich an einen Gott oder\n"
          +"Erzmagier wenden (mit einem Gast oder Mail von aussen).\n" );
  else {
    write( "Die Spielpause ist aufgehoben.\n" );
    master()->TBanishName(getuid(this_object()), 0);
    return 1;
  }
  write( "Wenn Du das wirklich willst, gib jetzt 'ja' ein.\n]" );
  input_to( "spielpause2", 0, days);
  return 1;
}

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

static void spielpause2	(	string	str,
		int	days
	)			[static]

Setzt neue taegliche Spieldauer, wird ueber spielpause() gerufen.

Parameter:

[in]	str	Spielereingabe, Bestaetigung
[in]	days	Dauer der Spielpause (in Tagen).

Siehe auch:

spielpause()

Definiert in Zeile 1081 der Datei base.c.

Benutzt master.

{
  if (str && (str == "ja" || str == "Ja" || str == "JA")) {
    master()->TBanishName(getuid(this_object()), days);
    write(
      "Ok, die Spielpause wird mit dem naechsten Ausloggen wirksam.\n"
     +"Solltest Du es Dir bis dahin noch einmal ueberlegt haben, so kannst\n"
     +"Du den Vorgang mit 'spielpause 0 tage' wieder rueckgaengig machen.\n" );
    return;
  }
  write("Vorgang wurde abgebrochen.\n" );
}

int spotte

(

string

str

)

Definiert in Zeile 4076 der Datei base.c.

{
    _notify_fail( "Hier ist nichts, was Du verspotten koenntest!\n" );
    return 0;
}

varargs nomask int start_player	(	string	str,
		string	ip
	)

Initialisiert und aktiviert das Spielerobjekt.

Kann nur von /secure/login oder /secure/master gerufen werden. Startet Telnet Negotiation, laedt Savefile, setzt einige Props. Ruft updates_after_restore(), um div. Daten zu aktualisieren/reparieren. Ruft create() aus /std/player/potion.c. Bei neuem Spieler wird der entsprechende Event ausgeloest die Attribute auf die Startwerte gesetzt. Prueft Zweitiemarkierungen. Ruft InitPlayer().

Parameter:

[in]	str	Name des Charakters, der geladen werden soll.
[in]	ip	textuelle Repraesentation der IP-Adresse des Spielers.

Rückgabe:

1 bei Erfolg, 0 sonst.

Noch zu erledigen:

Div. Reparaturen/Updates nach updates_after_restore() auslagern.

Definiert in Zeile 2105 der Datei base.c.

{
    mixed second;
    int newflag;  /* could player be restored? */
    string str1;

    if ( query_once_interactive(ME) ){
        startup_telnet_negs();
        modify_prompt();
    }

    call_out( "disconnect", 600 );

    str1 = explode( object_name(previous_object()), "#" )[0];

    if ( str1 != "/secure/login" &&
         str1 != "/secure/master" &&
         (!geteuid(ME) || geteuid(ME) != getuid(ME) ||
          capitalize(geteuid(ME)) != str ||
          geteuid(ME) != geteuid(previous_object())) ){
        write( "DIESER VERSUCH WAR ILLEGAL !!\n" );
        destruct(ME);
        return 0;
    }

    /* try to restore player. If it doesn't exist, set the new flag */
    Set( P_WIMPY, 20 );
    newflag = !restore_object( "/" + SAVEPATH + lower_case(str)[0..0] + "/"
                               +lower_case(str) );

    updates_after_restore(newflag);

    if ( query_once_interactive(ME) )
        Set( P_LAST_LOGIN, time() );

    Set( P_WANTS_TO_LEARN, 1 ); // 1 sollte der default sein !!!
    Set( P_WANTS_TO_LEARN, PROTECTED, F_MODE_AS );
    // Eingefuegt 18.11.99, kann nach einem Jahr wieder raus:
    Set( P_TESTPLAYER, PROTECTED, F_MODE_AS );

    if ( IS_LEARNER(ME) )
        SetProp( P_CAN_FLAGS, QueryProp(P_CAN_FLAGS)|CAN_REMOTE );

    Set( P_NAME, str );
    Set( P_NAME, SECURED, F_MODE_AS );

    if ( !QueryProp(P_NEEDED_QP) )
        SetProp( P_NEEDED_QP, REQ_QP );

    Set( P_NEEDED_QP, NOSETMETHOD, F_SET_METHOD );
    Set( P_NEEDED_QP, SAVE|SECURED, F_MODE_AS );

    /* autosave the player after 500 heartbeats */
    time_to_save = age + 500;
    potion::create(); /* DO IT HERE AFTER THE RESTORE !! */

    AddId( getuid() );
    SetProp( P_AC, 0 );
    SetProp( P_WEAPON, 0 );

    /* Set some things which wont be set when all is OK */
    SetProp( P_MAX_HP, (QueryAttribute(A_CON) * 8 + 42 ));
    SetProp( P_MAX_SP, (QueryAttribute(A_INT) * 8 + 42 ));

    catch( bb = "/secure/bbmaster"->query_bb() );

    /* If this is a new character, we call the adventurers guild to get
     * our first title !
     */
    if ( newflag ) {
        if ( QueryGuest())
            SetProp( P_TITLE, "ueberkommt das "MUDNAME" ..." );

        Set( P_LEVEL, -1 );
        SetProp( P_ATTRIBUTES, ([ A_STR:1, A_CON:1, A_INT:1, A_DEX:1 ]) );
        SetProp( P_HP, QueryProp(P_MAX_HP) );

                // Event ausloesen
                EVENTD->TriggerEvent(EVT_LIB_PLAYER_CREATION, ([
                      E_OBJECT: ME,
                      E_PLNAME: getuid(ME) ]) );
    }
    
    InitPlayer();

    // Padreic 01.02.1999
    if ( !IS_LEARNER(ME) && second = QueryProp(P_SECOND) ) {
        if ( stringp(second) && lower_case(second)[0..3] == "von " ) {
            second = lower_case(second[4..]);
            SetProp( P_SECOND, second );
        }

        if ( !stringp(second ) ||
             file_size( "/save/" + second[0..0] + "/" + second + ".o" ) <= 0 ){
            if ( stringp(second) &&
                 file_size( "/save/" + lower_case(second[0..0]) + "/" +
                            lower_case(second) + ".o" ) >0 ){
                SetProp( P_SECOND, lower_case(second) );
                log_file( "WRONG_SECOND",
                          sprintf( "%s: %s: P_SECOND = %O -> Automatisch "
                                   "korrigiert,\n",
                                                                   dtime(time()), object_name(), second ) );
            }
            else {
                tell_object( ME,
                             "*\n*\n* Deine Zweitiemarkierung ist ungueltig, "
                             "bitte aendere diese und sprich im\n* Zweifel "
                             "bitte einen Erzmagier an.\n*\n*\n" );

                log_file( "WRONG_SECOND",
                          sprintf( "%s: %s: P_SECOND = %O\n",
                                   dtime(time()), object_name(), second ) );
                // ein bisschen deutlicher auffordern.. Padreic 08.04.1999
                move( "/d/gebirge/room/zwafflad", M_GO );
            }
        }
    }
    return(0);
}

static int stop

(

string

str

)

[static]

Spielerkommando 'stop'.

Loescht die Gegnerliste, sofern man nicht InFight() ist.

Parameter:

[in]

str

Spielereingabe, wird ignoriert.

Rückgabe:

1

Definiert in Zeile 1868 der Datei base.c.

{
    if ( InFight() ){
        write( "Das geht nicht mitten im Kampf.\n" );
        return 1;
    }

    if ( !str ){
        StopHuntingMode();
        write( "Ok.\n" );
        return 1;
    }

    if ( !StopHuntID(str) )
        write( "So jemanden verfolgst Du nicht!\n" );

    return 1;
}

static varargs void stop_heart_beats

(

mixed

obs

)

[static]

Schaltet in allen Objekten im Inv HBs aus.

Schaltet im Inv in allen Objekten (rekursiv, deep_inventory) die Heartbeats aus. Falls obs uebergeben wird, werden diese Objekte statt des Inventars benutzt. Speichert die Objekte, die einen HB hatten, in der glob. Var. hb_obs.

Parameter:

[in]

obs

mixed - Objekte, in denen der HB abgeschaltet werden soll. Container werden rekursiv behandelt.

Achtung:

Achtung! Niemals zweimal hintereinander rufen, ohne zwischendurch restart_heart_beats() gerufen zu haben!

Siehe auch:

restart_heart_beats

Definiert in Zeile 339 der Datei base.c.

Benutzt hb_obs, i, ME, ob() und set_object_heart_beat().

{
  int i;

  if (!obs)
  {
    hb_obs=({});
    obs=deep_inventory(ME);
  } 
  foreach(mixed ob: obs) {
    if (pointerp(ob))
                stop_heart_beats(ob);
    else if (set_object_heart_beat(ob,0))  
                hb_obs+=({ob});
  }
}

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

static int stty

(

string

str

)

[static]

Definiert in Zeile 3336 der Datei base.c.

{
  if(str!="dumb"&&str!="vt100"&&str!="ansi"&&str!="reset")
  {
    write("Kommando: stty dumb|vt100|ansi oder reset\n");
  }
  if(str == "reset") {
      printf("Dieser Text sollte lesbar sein!\n");
      return 1;
  }

  write("TTY steht jetzt auf "+SetProp(P_TTY,str)+".\n");
  if(str == "ansi" || str == "vt100") {
      printf("Terminal Test:\n");
      printf("VT100: fett unterstrichen "+
             "blinkend invers\n");
      if(str == "ansi") {
          printf("ANSI Farben und VT100 Attribute:\n");
          foreach(int fg: 30 .. 37) {
                      foreach(int bg: 40 .. 47) {
                  printf("[%d;%dm@", fg, bg);
                  printf("[%d;%dm@", fg, bg);
                  printf("[%d;%dm@", fg, bg);
                  printf("[%d;%dm@", fg, bg);
              }
              printf("\n");
          }
          printf("Sollte dieser Text hier nicht richtig lesbar\nsein,"+
                 "benutze das Kommando stty reset!\n");
      }

  }
  return 1;
}

static string timediff

(

int

time

)

[static]

Definiert in Zeile 3052 der Datei base.c.

{
  string ret;

  ret="";
  if(time>=86400) {
    ret+=time/86400+"d ";
    time%=86400;
  }
  if(time<36000) ret+="0";
  ret+=time/3600+":";
  time%=3600;
  if(time<600) ret+="0";
  ret+=time/60+":";
  time%=60;
  if(time<10) ret+="0";
  ret+=time+"";
  return ret;
}

static int toggle_whimpy

(

string

str

)

[static]

Definiert in Zeile 2897 der Datei base.c.

{
  int i;

  if(!str || str=="" || (sscanf(str,"%d",i)<0))
  {
    write("vorsicht <hp>, 0<=hp<"+QueryProp(P_MAX_HP)+"\n");
    return 1;
  }
  if(i>=QueryProp(P_MAX_HP) || i<0)
  {
    write("Der Wert ist nicht erlaubt.\n");
    return 1;
  }
  if(!i) write("Prinz Eisenherz-Modus.\n");
  else write("Vorsicht-Modus ("+i+")\n");
  SetProp(P_WIMPY,i);
  return 1;
}

static int toggle_whimpy_dir

(

string

str

)

[static]

Definiert in Zeile 2888 der Datei base.c.

                                         {
  SetProp(P_WIMPY_DIRECTION,str=_unparsed_args()||str);
  if (str)
    printf("Ok, Fluchtrichtung %O.\n",str);
  else
    printf("Ok, bevorzugte Fluchtrichtung deaktiviert.\n");
  return 1;
}

int topliste

(

string

arg

)

Definiert in Zeile 3998 der Datei base.c.

{
    if (!arg)
    {
        printf("Du hast Dich fuer die Topliste %s.\n",
            (QueryProp(P_NO_TOPLIST) ? "gesperrt" : "freigegeben"));
        return 1;
    }
    else if (member(({"j","ja","n","nein"}),arg)==-1)
        return _notify_fail("Syntax: topliste [ja|nein]\n"),0;
    if (arg[0]=='j')
    {
        SetProp(P_NO_TOPLIST,0);
        write("Du kannst jetzt (theoretisch) in der Topliste auftauchen.\n");
    }
    else
    {
        SetProp(P_NO_TOPLIST,1);
        write("Du wirst jetzt nicht in der Topliste auftauchen.\n");
    }
    Set(P_NO_TOPLIST,SAVE|PROTECTED,F_MODE_AS);
    return 1;
}

static int typo

(

string

str

)

[static]

Setzt eine Typomeldung an Magier ab (Spielerkommando).

Fragt nach der Typomeldung und liest sie via typo2() ein, fall der Spieler kein Argument angeben hat.

Parameter:

[in]

str

optionale Spielereingabe der Typobeschreibung

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

typo2(string)

Definiert in Zeile 1239 der Datei base.c.

Benutzt _unparsed_args(), input_to() und smart_log().

                            {
  if (!(str=_unparsed_args())) {
    write( "Wo ist denn der Tippfehler?\n]" );
    input_to("typo2");
    return 1;
  }
  write("Vielen Dank fuer die Hilfe.\n");
  smart_log("TYPO",str);
  return 1;
}

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

static int typo2

(

string

str

)

[static]

Setzt eine Fehlermeldung an Magier ab (Spielerkommando).

Liest die Typobeschreibung ein und speichert sie.

Parameter:

[in]

str

Spielereingabe der Typobeschreibung

Rückgabe:

1 bei Erfolg, 0 sonst.

Siehe auch:

typo(string)

Definiert in Zeile 1256 der Datei base.c.

Benutzt smart_log().

                             {
  if (!str || str == "") {
    write("Typo abgebrochen...\n");
    return 1;
  }
  smart_log("TYPO",str);
  write("Vielen Dank fuer die Hilfe.\n");
  return 1;
}

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

static int uhrmeldung

(

string

str

)

[static]

Definiert in Zeile 3740 der Datei base.c.

{
  if (!(str=_unparsed_args()))
  {
    str=QueryProp(P_CLOCKMSG);
    if (!str)
    {
      write("Du hast die Standard-Uhrmeldung.\n");
      return 1;
    }
        if( !stringp(str) ) str = sprintf("%O\n",str);
    printf("Deine Uhrmeldung ist:\n%s\n",str[0..<2]);
    return 1;
  }
  if (str=="0")
  {
    SetProp(P_CLOCKMSG,0);
    write("Ok, Du hast jetzt wieder die Standard-Meldung.\n");
    return 1;
  }
  if (sizeof(explode(str,"%d"))>2)
  {
    write("Fehler, es darf nur ein %d in der Meldung vorkommen.\n");
    return 1;
  }
  /* Mehrere %-Parameter verursachen das Abschalten der Uhr zur vollen Stunde.
   */
  if (sizeof(explode(str,"%"))>2)
  {
    write("Fehler: Zuviele %-Parameter in der Meldung.\n");
    return 1;
  }
  /* Nur ein %-Parameter, aber der falsche: nicht sinnvoll. */
  else
  {
    int i = strstr(str,"%",0);
    if ( i>-1 && ( i==strlen(str)-1 || str[i+1]!='d'))
    {
      write("Fehler: Falscher %-Parameter in der Meldung.\n");
      return 1;
    }
  }
  str+="\n";
  SetProp(P_CLOCKMSG,str);
  write("Ok.\n");
  return 1;
}

static int uhrzeit

(

)

[static]

Definiert in Zeile 2949 der Datei base.c.

{
  write(dtime(time()+QueryProp(P_TIMEZONE)*3600)+".\n");
  return 1;
}

private void updates_after_restore

(

int

newflag

)

Setzt bestimmte Props im Spieler, falls diese nicht gesetzt sind.

Wird von start_player() gerufen. Momentan wird ggf. nur die Groesse gesetzt, falls sie bisher 0 ist und die Skills des Spielers initialisiert bzw. repariert oder auf die aktuellste Version des Skillsystems aktualisiert und der SAVE-Status der Prop P_GUILD_PREVENTS_RACESKILL geloescht. Ruft ggf. InitSkills() und FixSkills().

Parameter:

[in]

newflag

Gibt an, ob es ein neuerstellter Spieler ist.

Siehe auch:

start_player(), InitSkills(), FixSkills()

Definiert in Zeile 2040 der Datei base.c.

                                                {
  int size;
  attributes::UpdateAttributes();
  size=Query(P_SIZE);
  if (!size) size=RandomSize();
  while(size==QueryProp(P_AVERAGE_SIZE))
    size=RandomSize();
  Set(P_SIZE,size);

  //Allgemeine Waffenskills aktivieren, wenn noetig
  //set_weapon_skills();
  // Wird nun von InitSkills bzw. FixSkills uebernommen, falls noetig.
  if (newflag) {
    InitSkills();
  }
  else if (QueryProp(P_SKILLSVERSION) != CURRENT_SKILL_VERSION) {
    // Falls noetig, Skills fixen/updaten. *grummel*
    FixSkills();
  }
  // Prop gibt es nicht mehr. SAVE-Status loeschen. 
  Set(P_GUILD_PREVENTS_RACESKILL,SAVE,F_MODE_AD);
}

static int very_short_score

(

string

arg

)

[static]

Gibt eine Miniinfo ueber LP / KP aus (Spielerkommando: kurzinfo).

Rückgabe:

1

Siehe auch:

score(string), short_score(string)

Definiert in Zeile 1541 der Datei base.c.

Benutzt P_HP, P_MAX_HP, P_MAX_SP, P_NO_ASCII_ART, P_SP und QueryProp().

                                        {
  int    lp,mlp,xlp,kp,mkp,xkp;
  string bar;

  lp=QueryProp(P_HP); mlp=QueryProp(P_MAX_HP);
  kp=QueryProp(P_SP); mkp=QueryProp(P_MAX_SP);
  xlp=(lp*40/mlp);
  xkp=(kp*40/mkp);
  bar="  .    .    .    .    .    .    .    .  ";
  if (QueryProp(P_NO_ASCII_ART) || arg == "-k")
    printf("Gesundheit: %3.3d (%3.3d), Konzentration: %3.3d (%3.3d)\n",
                   lp, mlp, kp, mkp);
  else
    printf("Gesundheit:    0 |%'#'40.40s| %3.3d%s\n"+
                   "Konzentration: 0 |%'#'40.40s| %3.3d%s\n",
                   (xlp<0?bar:bar[xlp..]),lp,(lp==mlp?"":sprintf(" (%d)",mlp)),
                   (xkp<0?bar:bar[xkp..]),kp,(kp==mkp?"":sprintf(" (%d)",mkp))
                   );
  return 1;
}

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

static int weg

(

string

str

)

[static]

Definiert in Zeile 2998 der Datei base.c.

{
  if (!(str=_unparsed_args()))
  {
    printf("Du bist nicht%s als abwesend gekennzeichnet.\n",
           QueryProp(P_AWAY) ? " mehr" : "");
    SetProp(P_AWAY, 0);
    return 1;
  }
  write("Du bist jetzt als abwesend gekennzeichnet.\n");
  SetProp(P_AWAY, str);
  return 1;
}

static int wegmeldung

(

string

player

)

[static]

Definiert in Zeile 3013 der Datei base.c.

{

  object player_ob;
  string weg;

  if ( !player || player=="" || 
       player==lowerstring(this_player()->QueryProp(P_NAME)))
  {
    weg=this_player()->QueryProp(P_AWAY);
    write ("Du bist "+(weg?"":"nicht ")+"als abwesend gekennzeichnet.\n");
    if (weg)
      write(break_string(weg, 78,"Grund: ",BS_INDENT_ONCE));
    return 1;  
  }

  // Welcher Spieler ist gemeint?
  player_ob=find_player(player);

  // Spieler nicht da oder Invis und Anfrager is kein Magier
  if (!player_ob || 
      (player_ob->QueryProp(P_INVIS) && !IS_LEARNER(this_player()))) 
  {
    write(capitalize(player)+" ist gerade nicht im Spiel.\n");
    return 1;
  }

  weg=player_ob->QueryProp(P_AWAY);

        // player_ob->Name() gibt bei invis-Magiern "Jemand" zurueck
  write (player_ob->QueryProp(P_NAME)+" ist "+
         (weg?"":"nicht ")+"als abwesend gekennzeichnet.\n");

  if (weg)
    write(break_string(weg, 78,"Grund: ",BS_INDENT_ONCE));

  return 1;
}

static int who

(

string

str

)

[static]

Spielerkommando 'wer', fragt /obj/werliste ab.

Parameter:

[in]

str

Spielereingabe mit Optionen fuer wer.

Rückgabe:

1

Definiert in Zeile 1712 der Datei base.c.

Benutzt _unparsed_args(), filter_who_options(), i, INETD, IS_LEARNER, ME, More(), P_WANTS_TO_LEARN, QueryProp(), QueryWhoListe(), REQUEST und SENDER.

                           {
  int i,shrt;
  string ret;
  mixed ans;

  if ((str=_unparsed_args())&&str[0..0]!="-") {
    ans = filter_who_options(str);
    shrt = ans[0];
    str = ans[1];
    if (!shrt) {
      if (ret=INETD->_send_udp(str,
                              ([ REQUEST: "who", SENDER: getuid(ME) ]), 1 ))
        write(ret);
      else
        write("Anfrage abgeschickt.\n");
      return 1;
    }
  }
  if (str) i=(member(str,'o')>0); else i=0;
  if (strlen(str)>1 && str[0] == '-') str = str[1..1];
  More(implode( "/obj/werliste"->QueryWhoListe(
    IS_LEARNER(ME) && QueryProp(P_WANTS_TO_LEARN),shrt,0,str,i),"\n"),0);
  return 1;
}

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

static int zaubertraenke

(

)

[static]

Definiert in Zeile 3845 der Datei base.c.

{
  More("/room/orakel"->TipListe());
  return 1;
}

static int zeitzone

(

string

str

)

[static]

Definiert in Zeile 3788 der Datei base.c.

{
  int zt;
  if(!str || str==""){
    if(!(zt=QueryProp(P_TIMEZONE)))
      write("Du hast derzeit die gleiche Zeitzone wie das "MUDNAME" "+
            "eingestellt.\n");
    else if(zt>0)
      printf("Deine Zeitzone ist auf %d Stunden vor (oestlich) von Berlin "+
             "eingestellt.\n",zt);
    else
      printf("Deine Zeitzone ist auf %d Stunden nach (westlich) von "+
             "Berlin eingestellt.\n",-zt);
    return 1;
  }
  if(sscanf(str,"utc %d",zt)==1)  zt=(zt-1)%24;
  else zt=to_int(str)%24;

  SetProp(P_TIMEZONE,zt);

  if(!zt)
    write("Du hast derzeit die gleiche Zeitzone wie das "MUDNAME" "+
          "eingestellt.\n");
  else if(zt>0)
    printf("Deine Zeitzone ist auf %d Stunden vor (oestlich) von Berlin "+
           "eingestellt.\n",zt);
  else
    printf("Deine Zeitzone ist auf %d Stunden nach (westlich) von "+
           "Berlin eingestellt.\n",-zt);
  return 1;
}

int zweitiemarkierung

(

string

arg

)

Definiert in Zeile 3973 der Datei base.c.

{
  if (!QueryProp(P_SECOND))
    return _notify_fail("Aber Du bist doch gar kein Zweiti.\n"),0;
  notify_fail("Syntax: zweitiemarkierung [unsichtbar|sichtbar|name]\n");
  if (!arg)
    return 0;
  switch (arg)
  {
    case "unsichtbar" :
      SetProp(P_SECOND_MARK,-1);
      write("Jetzt sieht kein Spieler mehr, dass Du ein Zweiti bist.\n");
      return 1;
    case "sichtbar" :
      SetProp(P_SECOND_MARK,0);
      write("Jetzt sieht kein Spieler mehr, wessen Zweiti Du bist.\n");
      return 1;
    case "name" :
      SetProp(P_SECOND_MARK,1);
      write("Jetzt koennen alle sehen, wessen Zweiti Du bist.\n");
      return 1;
  }
  return 0;
}

---

Variablen-Dokumentation

inherit std living attributes

Definiert in Zeile 19 der Datei base.c.

mapping autoload

Definiert in Zeile 70 der Datei base.c.

private nosave string* autoload_error

Definiert in Zeile 74 der Datei base.c.

Wird benutzt von create().

private nosave mapping autoload_rest

Definiert in Zeile 73 der Datei base.c.

Wird benutzt von create().

inherit std player telnetneg c

Definiert in Zeile 41 der Datei base.c.

inherit std living clothing

Definiert in Zeile 21 der Datei base.c.

inherit std player combat

Definiert in Zeile 26 der Datei base.c.

inherit std player comm

Definiert in Zeile 30 der Datei base.c.

inherit std player command

Definiert in Zeile 33 der Datei base.c.

Wird benutzt von _clone_items(), _move_base(), AddArmour(), AddWeapon(), alias(), command_me(), do_list(), DoTeamAttack(), DoTeamFollow(), Drink(), Flee(), more(), nextStep(), reise(), reset(), use_best_combat_command() und walk_random().

nosave string default_home

Definiert in Zeile 85 der Datei base.c.

inherit std player description

Definiert in Zeile 27 der Datei base.c.

nosave mixed env_ndead_info

Definiert in Zeile 96 der Datei base.c.

inherit std player guide

Definiert in Zeile 42 der Datei base.c.

nosave object* hb_obs

Definiert in Zeile 92 der Datei base.c.

Wird benutzt von restart_heart_beats() und stop_heart_beats().

int hc_play

Definiert in Zeile 71 der Datei base.c.

inherit std hook_provider

Definiert in Zeile 17 der Datei base.c.

inherit std thing language

Definiert in Zeile 24 der Datei base.c.

inherit std player life

Definiert in Zeile 29 der Datei base.c.

inherit std living moneyhandler

Definiert in Zeile 32 der Datei base.c.

inherit std more

Definiert in Zeile 39 der Datei base.c.

inherit std player moving

Definiert in Zeile 28 der Datei base.c.

nosave int ndead_currently

Definiert in Zeile 90 der Datei base.c.

Wird benutzt von create() und heart_beat().

nosave string ndead_l_filename

Definiert in Zeile 89 der Datei base.c.

Wird benutzt von _query_netdead_env() und create().

nosave int ndead_lasttime

Definiert in Zeile 87 der Datei base.c.

Wird benutzt von create() und heart_beat().

nosave mixed ndead_location

Definiert in Zeile 88 der Datei base.c.

Wird benutzt von _query_netdead_env(), create(), heart_beat(), NetDead() und Reconnect().

nosave int ndead_next_check

Definiert in Zeile 91 der Datei base.c.

Wird benutzt von create() und heart_beat().

private nosave string passw

Definiert in Zeile 77 der Datei base.c.

Wird benutzt von change_password3() und change_password4().

private nosave string passwold

Definiert in Zeile 78 der Datei base.c.

Wird benutzt von change_password2(), change_password3() und change_password4().

inherit std player potion

Definiert in Zeile 37 der Datei base.c.

nosave string pray_room

Definiert in Zeile 94 der Datei base.c.

inherit std thing properties

Definiert in Zeile 22 der Datei base.c.

inherit std living put_and_get

Definiert in Zeile 20 der Datei base.c.

inherit std player quests

Definiert in Zeile 36 der Datei base.c.

private nosave string realip

Definiert in Zeile 75 der Datei base.c.

Wird benutzt von create(), query_realip() und set_realip().

inherit std player reputation

Definiert in Zeile 43 der Datei base.c.

inherit std player restrictions

Definiert in Zeile 18 der Datei base.c.

inherit std living skill_attributes

Definiert in Zeile 34 der Datei base.c.

inherit std player skills

Definiert in Zeile 35 der Datei base.c.

inherit std player soul

Definiert in Zeile 38 der Datei base.c.

private int telnet_tm_counter

Definiert in Zeile 83 der Datei base.c.

Wird benutzt von CheckTelnetKeepAlive().

inherit std player travel

Definiert in Zeile 25 der Datei base.c.

inherit std user_filter

Definiert in Zeile 40 der Datei base.c.

inherit std player util

Definiert in Zeile 23 der Datei base.c.

inherit std player viewcmd

Definiert in Zeile 31 der Datei base.c.