Manpages aus Driver aktualisiert.
Hierbei handelt es sich um Manpages, welche vom MG
modifiziert wurden.
Die Bemerkungen und Beispiele wurden ausgelagert in
separate Manpages, um zukuenftige Aktualisierungen
aus dem Driver zu erleichtern.
Change-Id: I5a6248cd65a8cd841831617a92aa1ee191dbf661
diff --git a/doc/efun/add_action b/doc/efun/add_action
index 8b0f778..19813d2 100644
--- a/doc/efun/add_action
+++ b/doc/efun/add_action
@@ -1,97 +1,72 @@
-add_action(E)
-FUNKTION:
- void add_action(string fun, string cmd)
- void add_action(string fun, string cmd, int flag)
+SYNOPSIS
+ #include <commands.h>
-ARGUMENTE:
- fun
- gerufene Methode
- cmd
- ausloesendes Verb
- flag
- Flag fuer unscharfe Interpretation
+ void add_action(string|closure fun, string cmd);
+ void add_action(string|closure fun, string cmd, int flag);
+ void add_action(string|closure fun); /* veraltet */
-BESCHREIBUNG:
- Generell: Das Verhalten dieser efun wird durch AddCmd aus
- /std/thing/commands.c komfortabler widergespiegelt.
- Darauf sollte man zurueckgreifen.
+BESCHREIBUNG
+ Setzt eine lokale Funktion fun, die aufgerufen wird, wenn der Spieler
+ das Kommandos <cmd< eintippt. Der Funktion werden die Argumente des
+ vom Spieler eingegebenen Kommandos als string uebergeben. Die
+ Funktion muss entweder 1 zurueck geben, wenn das Kommando erfolgreich
+ ausgefuehrt werden konnte, sonst 0.
- Legt fuer "cmd" (ein Kommandoverb) eine im entsprechenden Objekt
- zu rufende Methode fest.
+ Wenn das Kommando nicht erfolgreich ausgefuehrt werden konnte, sucht
+ der Parser weiter nach einer passenden Funktion, bis eine solche
+ 1 zurueck liefert. Falls der Parser keine Funktion findet, wird an
+ den Spieler eine Fehlermeldung ausgegeben. ("Wie bitte?")
- Diese Methode bekommt die Argumente als String uebergeben und
- muss 0 (fuer einen Fehler) oder 1 (fuer Erfolg) zurueckgeben.
+ Wenn add_action() ohne das zweite Argument (string cmd) aufgerufen
+ wird, muss dieses mit add_verb() oder add_xverb() angegeben werden.
+ DIESE DEKLARATION IST JEDOCH VERALTET UND SOLLTE NICHT VERWENDET
+ WERDEN. Sie funktioniert auch nur, wenn USE_DEPRECATED gesetzt ist.
- Der Parser durchsucht bei einer Spielereingabe die Liste der
- eingetragenen Kommandos nach passenden Kommandos und ruft die
- zugehoerigen Methoden in den Objekten bis eine der Methoden
- 1 zurueckgibt oder die Liste durchlaufen wurde. In dem Fall
- kommt die Fehlermeldung (notify_fail()) zum Einsatz.
+ Die Funktion fun wird mit einem string als Argument aufgerufen, der
+ die Worte nach dem Verb in der Inputzeile enthaelt. Das Verb kann
+ mit der Efun query_verb() abgefragt werden. Das Verb ist immer das
+ erste Wort in der Inputzeile bis zum ersten Leerschlag.
- Mit Werten != 0 fuer "flag" legt man eine unscharfe Auswertung
- fest, im Beispiel: Die Methode "action_fun" bei einem
- add_action("action_fun", "hops", 1);
- wird sowohl beim Kommando "hops" als auch bei Kommandos wie
- "hopse", "hopseblub", ... gerufen werden.
- Dieses Flag sollte vorsichtig verwendet werden.
+ add_action() muss immer aus einer init() Routine heraus aufgerufen
+ werden. Das Objekt, welches das Kommando cmd definiert, muss sich in
+ der Umgebung des Spielers befinden; also entweder der Spieler selbst,
+ im Inventar des Spielers, der Raum, in dem sich der Spieler befindet
+ oder ein Objekt im gleichen Raum wie der Spieler. Wenn der Spieler
+ die Umgebung des Objekts verlaesst, werden alle von add_action()
+ definierten Kommandos automatisch entfernt.
- Es gibt drei moegliche Verhaltensweise, die per "flag" eingeschaltet
- werden koennen:
- Wenn das Argument <flag> AA_SHORT (d.h. 1) ist, koennen Argumente von
- cmd ohne einen Leerschlag an cmd angehaengt sein. An die Funktion fun
- werden alle Zeichen nach dem ersten Leerschlag als Argument
- uebergeben.
+ Die Kommandos lassen sich auch manuell entfernen. Die Efun dazu lautet
+ remove_actions().
- Wenn <flag> AA_NOSPACE (d.h. 2) ist, koennen die Argumente wiederum
- ohne Leerschlag ans Verb angehaengt sein. Im Unterschied zu AA_SHORT
- werden alle Zeichen nach dem Verb als Argument an die Funktion
- uebergeben. Die Zeichen, welche nicht durch einen Leerschlag vom
- Verb getrennt sind, werden ZUSAETZLICH von query_verb() zurueck
- gegeben.
+ Wenn das Argument <flag> AA_SHORT (d.h. 1) ist, koennen Argumente von
+ cmd ohne einen Leerschlag an cmd angehaengt sein. An die Funktion fun
+ werden alle Zeichen nach dem ersten Leerschlag als Argument
+ uebergeben.
- Wenn <flag> AA_IMM_ARGS (3) ist, werden alle Zeichen nach dem Verb
- als Argument uebergeben, nicht aber von query_verb() beruecksichtigt.
+ Wenn <flag> AA_NOSPACE (d.h. 2) ist, koennen die Argumente wiederum
+ ohne Leerschlag ans Verb angehaengt sein. Im Unterschied zu AA_SHORT
+ werden alle Zeichen nach dem Verb als Argument an die Funktion
+ uebergeben. Die Zeichen, welche nicht durch einen Leerschlag vom
+ Verb getrennt sind, werden ZUSAETZLICH von query_verb() zurueck
+ gegeben.
+ Wenn <flag> AA_IMM_ARGS (3) ist, werden alle Zeichen nach dem Verb
+ als Argument uebergeben, nicht aber von query_verb() beruecksichtigt.
-BEMERKUNGEN:
- (1) add_action() sollte immer innerhalb von init() benutzt werden
- (2) das definierende Objekt muss im inventory des Spielers oder
- environment() des kommandogebenden Lebewesens sein
- (3) im init() spaeter eingetragene Kommandos oder spaeter hinzu-
- kommende Objekte werden bei der Kommandoauswertung VOR den
- alten beruecksichtigt
- (Daher bewegt sich das Xtool der Magier regelmaessing neu in
- das Inventory, um immer "erstes" Objekt zu sein.)
+ Wenn -<flag> eine negative Zahl ist, muss das vom Spieler eingegebene
+ Kommando nur mit den ersten <flag> Zeichen von cmd uebereinstimmen.
-BEISPIELE:
- // ein Kommando in einem Schirm
- void init() {
- ::init();
- add_action("action_oeffne", "oeffne");
- }
+ Als Name fuer die Funktion fun duerfen keine geschuetzten Namen wie
+ zum Beispiel create, init, reset, heart_beat etc. verwendet werden
+ (eine vollstaendige Liste findet man unter /doc/applied/).
- int action_oeffne(string str) {
- if(stringp(str) && id(str)) // Argument da und bin ich gemeint?
- write("Du oeffnest den Schirm.\n");
- say(break_string(this_player()->Name(WER)+" oeffnet einen Schirm.",78));
- return 1;
- }
- notify_fail("Was willst Du oeffnen?\n");
- return 0;
- }
+BEISPIELE
+ add_action("geh_rein", "betrete");
- // frueher beliebt um Spieler lahmzulegen, da es _alle_ Kommandos
- // triggert -> siehe heute jedoch dafuer eher P_DISABLE_COMMANDS
- // Achtung: siehe Implikation von (3)
- add_action("action_nothing", "",1 );
- ...
- int action_nothing(string str) {
- write("Dir sind die Haende gebunden.\n");
- return 1;
- }
+ Wenn der Spieler "betrete" eintippt, wird die Funktion geh_rein()
+ aufgerufen.
- Beispiele fuer die Verwendung des Argumentes "flag":
- add_action("disfunc", "disconnect", AA_NOSPACE);
+ add_action("disfunc", "disconnect", AA_NOSPACE);
Die Funktion disfunc() wird aufgerufen, wenn der Spieler "disconnect"
oder eine Abkuerzung davon (zum Beispiel "di" oder "discon") eingibt.
@@ -99,14 +74,15 @@
Um rauszufinden, was der Spieler tatsaechlich eingegeben hat, muss
query_verb() aufgerufen werden.
- add_action("fun", "cmd");
- add_action("fun", "scmd", AA_SHORT);
- add_action("fun", "ncmd", AA_NOSPACE);
- add_action("fun", "icmd", AA_IMM_ARGS);
+ add_action("fun", "cmd");
+ add_action("fun", "scmd", AA_SHORT);
+ add_action("fun", "ncmd", AA_NOSPACE);
+ add_action("fun", "icmd", AA_IMM_ARGS);
Die folgende Tabelle zeigt, was die oben aufgefuehrten Kommandos bzw.
<flag> fuer Werte an query_verb() und als Argumente an die Funktion
fun uebergeben:
+
|-------------------|--------------|----------------------------|
| Eingabe | query_verb() | Argument der Funktion fun |
|-------------------|--------------|----------------------------|
@@ -132,18 +108,10 @@
| "icmdbla fasel" | "icmd" | "bla fasel" |
|-------------------|--------------|----------------------------|
-
GESCHICHTE
Das Argument <flag> < 0 wird seit 3.2@127 unterstuetzt, aber erst ab
LDMud 3.2.8 richtig implementiert. LDMud 3.2.9 fuehrte das AA_IMM_ARGS
Flag ein. Ab LDMud 3.5 kann man Closures als Funktionen uebergeben.
-SIEHE AUCH:
- remove_action(E), init(E), enable_commands(E)
- Fehlermeldung: notify_fail(E), _notify_fail(E)
- Argumentstring: query_verb(E), _unparsed_args(L)
- obsolet: add_verb(E), add_xverb(E)
- alternativ: AddAction(L), AddCmd(L)
- P_DISABLE_COMMANDS
-
-24. Maerz 2004 Gloinson@MG
+SIEHE AUCH
+ query_verb(E), query_command(E), add_verb(E), add_xverb(E), init(A)
diff --git a/doc/efun/all_inventory b/doc/efun/all_inventory
index ad6eea1..212c530 100644
--- a/doc/efun/all_inventory
+++ b/doc/efun/all_inventory
@@ -1,17 +1,12 @@
-all_inventory
-FUNKTION:
- object *all_inventory()
- object *all_inventory(object ob)
+SYNOPSIS
+ object * all_inventory()
+ object * all_inventory(object ob)
-BESCHREIBUNG:
- Liefert ein Feld (Array) mit allen Objekten, die sich im Objekt ob
- befinden (bzw. in this_object(), sofern kein Argument angegeben
- wurde).
- Gerade bei sehr vollen Objekten bietet sich eher first_inventory(),
- next_inventory() an.
+BESCHREIBUNG
+ Liefert ein Feld (Array) mit allen Objekten, die sich im Objekt ob
+ befinden (bzw. in this_object(), sofern kein Argument angegeben
+ wurde).
-SIEHE AUCH:
- first_inventory(E), next_inventory(E), deep_inventory(E),
- all_environment(E), environment(E)
-
-22. Maerz 2004 Gloinson
+SIEHE AUCH
+ first_inventory(E), next_inventory(E), deep_inventory(E),
+ all_environment(E), environment(E)
diff --git a/doc/efun/call_out b/doc/efun/call_out
index dba28b3..0293b3e 100644
--- a/doc/efun/call_out
+++ b/doc/efun/call_out
@@ -2,53 +2,48 @@
void call_out(string fun, int delay, mixed arg, ...)
void call_out(closure cl, int delay, mixed arg, ...)
-DESCRIPTION
- Set up a call to function fun in the current object, or to
- closure cl. The call will take place in delay seconds, with the
- remaining argument list provided. delay can be 0, but be careful!
+BESCHREIBUNG
+ Ruft zeitverzoegert die Funktion <fun> im aktuellen Objekt oder
+ die Closure <cl> auf. Der Aufruf erfolgt in <delay> Sekunden.
+ Die Funktion / Closure wird mit den <arg> Argumenten aufgerufen.
+ Die minimale Verzoegerung ist 0 (negative <delay> werden implizit als
+ 0 behandelt). Allerdings ist die reale Verzoegerung etwas zwischen
+ <delay> und __ALARM_TIME__.
- call_out() saves and restores the current user. It is now
- possible to use say() or write() which rely on a current
- user to be something useful.
+ call_out() merkt sich den aktuellen User und ruft die Funktion
+ entsprechend auf. call_out() kann nur Funktionen aufrufen, die
+ oeffentlich zugaenglich sind, das heisst "public" und "static"
+ deklarierte Funtionen. "private" und "protected" deklarierte
+ Funktionen koennen nicht aufgerufen werden.
- call_out() can only call functions which are publicly accessible,
- i.e. "public" and "static" functions. "private" and "protected"
- functions can't be called.
+ Die Ausfuehrung von call_out()s erfordert einen einfachen (nicht
+ zu aufwendigen) Schutz gegen Rabbits: die Evalkosten aller
+ gleichzeitig anstehenden call_out()s werden auf einer pro-UID-Basis
+ summiert. Uebersteigt die Summe ein vorgegebenes Maximum, wird
+ ein Fehler 'too long evaluation' erzeugt, und es werden alle
+ call_out()s des betreffenden Benutzers, die zur gleichen Zeit
+ faellig werden, entfernt.
- The execution of the call_out()s implies a simple (not
- exhaustive) measure against rabbits: the evaluation costs of
- those call_outs() executing at the same time are summed up on
- a per-UID base. If the summed-up costs exceed the given maximum,
- a 'too long evaluation' error will occur and any remaining
- call_outs() of this user scheduled for the same time are
- discarded.
+ Wenn zwei call_out()s zum gleichen Zeitpunkt ausgefuehrt werden
+ sollen, wird der zuerst gestartete zuerst ausgefuehrt.
- Callouts are executed every 2s, therefore your delay may be bigger
- than the you specified. In fact, a Callout with delay==0 is
- executed within 2s from the function call to call_out().
-
-WARNING
- Please never use call_out(...,0) in recursive Callouts and be at least
- very careful in other cases. That Callout would be executed directly
- after your current function and you really get 0 delay.
-
-EXAMPLE
+BEISPIELE
call_out("RefreshMe", 10);
- This will call the function RefreshMe() in 10 seconds without
- any arguments. The function RefreshMe() can then call out
- itself again which will result in a loop (not in a recursion)
- which can be used to check or set up things in the object in
- intervals. Be aware that callouts are stored in a linear
- list, and so are somewhat expensive for the driver.
+ Dies ruft die Funktion RefreshMe() nach Ablauf von 10 Sekunden ohne
+ irgendwelche Argumente auf. Die Funktion RefresMe() kann dann
+ wiederum selbst call_out()s starten, auch auf sich selbst, was
+ eine Schleife erzeugt (keine Rekursion). Mit einer solchen Schleife
+ koennen Anweisungen in einem Objekt in regelmaessigen Zeitintervallen
+ ausgefuehrt werden. Es ist allerdings zu beachten, dass call_out()s
+ in einer linearen Liste gespeichert werden, und deshalb ziemlich
+ rechenaufwendig fuer den Treiber sind.
- And YES: self-replicating call_out()s, where each call_out()
- creates two or more other call_out()s in a loop (so called
- 'rabbits') slow the mud down very fast, and are even able
- to crash it. No need to try it yourself.
+ Und JA: selbst-replizierende call_out()s, bei denen jeder call_out()
+ selbst zwei oder mehr call_out()s in einem Loop erzeugt (sogenannte
+ Rabbits) verlangsamen das Mud ungemein und koennen es sogar zum
+ Crash bringen. Kein Grund, es selbst auszuprobieren.
-SEE ALSO
+SIEHE AUCH
remove_call_out(E), call_out_info(E), find_call_out(E),
this_player(E), reset(A), heart_beat(A)
-
-05.11.06 Zesstra
diff --git a/doc/efun/count_bits b/doc/efun/count_bits
index 1b725d0..67e6dd4 100644
--- a/doc/efun/count_bits
+++ b/doc/efun/count_bits
@@ -1,20 +1,15 @@
SYNOPSIS
- int count_bits(string str);
+ int count_bits(string str)
BESCHREIBUNG
- Diese Funktion zaehlt die Anzahl gesetzer Bits im Bitstring <str> und
- liefert die Anzahl als Resultat zurueck.
+ Diese Funktion zaehlt die Anzahl gesetzer Bits im Bitstring <str> und
+ liefert die Anzahl als Resultat zurueck.
-BEMERKUNGEN
- Arbeitet eigentlich nur sinnvoll auf Bitstrings :)
-
-BEISPIEL
- string s;
- s = set_bit("", 3); s = set_bit(s, 15);
- count_bits(s) --> liefert 2
+BEISPIELE
+ string s;
+ s = set_bit("", 3); s = set_bit(s, 15);
+ count_bits(s) --> liefert 2
SIEHE AUCH
- clear_bit(E), set_bit(E), test_bit(E), next_bit(E), last_bit(E),
- or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E), bitstrings (C)
-
-10.Apr.2007 Gloinson
+ clear_bit(E), set_bit(E), test_bit(E), next_bit(E), last_bit(E),
+ or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
diff --git a/doc/efun/environment b/doc/efun/environment
index ea10b3d..38ca58e 100644
--- a/doc/efun/environment
+++ b/doc/efun/environment
@@ -1,69 +1,22 @@
SYNOPSIS
- object environment();
- object environment(object obj);
- object environment(string obj);
+ object environment()
+ object environment(object obj)
+ object environment(string obj)
-ARGUMENTE:
- obj
- Objekt oder Pfad-String eines Objektes dessen Umgebungsobjekt
- gesucht ist
+BESCHREIBUNG
+ Gibt das umgebende Objekt von <obj> wider. Das Objekt <obj> kann
+ direkt angegeben werden oder ueber seinen Namen als String. Wenn
+ kein Argument angegeben wird, wird die Umgebung des aktuellen
+ Objekts zurueck gegeben.
-BESCHREIBUNG:
- Es wird das Objekt bestimmt, in dem sich obj aufhaelt.
- Wird obj nicht angegeben, so wird this_object() als Objekt angenommen.
+ Zerstoerte Objekte haben kein Environment.
- Zerstoerte Objekte haben kein Environment.
+BEISPIELE
+ object room;
+ room = environment(this_player());
-BEMERKUNGEN:
- - Blueprints, wie zum Beispiel Raeume haben oft kein environment(). Man
- sollte daher ueberpruefen, ob ein environment() existiert, wenn man
- darin oder darauf eine Funktion aufrufen will.
+ Dies liefert den Raum, in dem sich der Spieler im Moment aufhaelt.
-BEISPIELE:
- // In der Variable "raum" steht der Raum, in dem sich der Spieler derzeit
- // aufhaelt - das kann auch 0 sein!
- raum = environment(this_player());
-
- // Dieses Objekt hat noch kein environment, da es eben erst geclont
- // wurde. Ergo steht in env eine 0.
- obj = clone_object("/std/thing");
- env = environment(obj);
-
- // alle Methoden die auf Environment arbeiten, sollten das vorher
- // pruefen - insbesondere tell_room()
- if(this_player() && environment(this_player()) &&
- objectp(o=present("schild",environment(this_player()))) {
-
- write("Du klebst Deine Plakette auf "+o->name(WEN)+".\n");
- tell_room(environment(this_player()), break_string(
- this_player()->Name(WER)+" pappt einen Aufkleber auf "+
- o->name(WEN)+".",78),
- ({this_player()}));
- }
-
- // wenn Dinge sehr offensichtlich in Leuten kaputtgehen wird es
- // komplexer (man kann das natuerlich noch weiter schachteln oder
- // ueber all_environment() versuchen zu loesen
- if(environment()) {
- object ee;
- ee=environment(environment());
- if(living(environment())) {
- tell_object(environment(),Name(WER)+" zerfaellt.\n");
- if(ee)
- tell_room(ee,
- environment()->Name(WESSEN)+" "+name(RAW)+" zerfaellt.\n",
- ({environment()}));
- } else if(ee && living(ee))
- if(environment()->QueryProp(P_TRANSPARENT))
- tell_object(ee, Name(WER)+" zerfaellt in Deine"+
- (environment()->QueryProp(P_PLURAL)?"n":
- (environment()->QueryProp(P_GENDER)==FEMALE?"r":"m"))+
- environment()->name(RAW)+".\n");
- } else tell_room(environment(),Name(WER)+" zerfaellt.\n");
- }
-
-SIEHE AUCH:
- first_inventory(E), next_inventory(E), all_inventory(E)
+SIEHE AUCH
+ first_inventory(E), next_inventory(E), all_inventory(E),
all_environment(E)
-
-20. Sep. 2002 Gloinson@MG
\ No newline at end of file
diff --git a/doc/efun/file_size b/doc/efun/file_size
index d49dd53..59a1ec3 100644
--- a/doc/efun/file_size
+++ b/doc/efun/file_size
@@ -1,35 +1,17 @@
-FUNKTION:
+SYNOPSIS
+ #include <files.h>
+
int file_size(string file)
-BESCHREIBUNG:
- Liefert die Groesse des Files in Bytes.
-
-RUECKGABEWERT:
+BESCHREIBUNG
Liefert die Dateigroesse in Bytes.
- Davon abweichend kann auch folgendes als Rueckgabewert vor-
- kommen:
+ Existiert die angegebene Datei nicht oder ist fuer das aufrufende
+ Objekt bzw. den aufrufenden Benutzer nicht lesbar, so wird
+ FSIZE_NOFILE (-1) zurueckgeliefert.
- FSIZE_NOFILE Das File ist entweder nicht vorhanden oder das
- (-1) abfragende Objekt besitzt keine Leserechte dafuer.
- FSIZE_DIR Es handelt sich nicht um ein File sondern um
- (-2) ein Verzeichnis.
+ Verzeichnisse haben die Groesse FSIZE_DIR (-2).
-BEISPIELE:
- Ein Spieler soll seinen Plan abfragen koennen:
-
- #include <sys/files.h>
- if(file_size("/p/service/loco/plans/"+
- getuid(this_player())+".plan") <= FSIZE_NOFILE)
- {
- write("Du hast keinen eigenen Plan festgelegt.\n");
- return 1;
- }
-
- this_player()->More(read_file("/p/service/loco/plans/"+
- getuid(this_player())+".plan");
-
-SIEHE AUCH:
- file_time(S), write_file(E), cat(E), get_dir(E), ls()
-
-03.08.2007, Zesstra
+SIEHE AUCH
+ write_file(E), write_bytes(E), read_file(E), read_bytes(E),
+ get_dir(E)
diff --git a/doc/efun/filter b/doc/efun/filter
index 449f144..f75b98d 100644
--- a/doc/efun/filter
+++ b/doc/efun/filter
@@ -1,168 +1,69 @@
-filter(E)
+SYNOPSIS
+ mixed * filter(mixed *arg, string fun, string|object ob
+ , mixed extra...)
+ mixed * filter(mixed *arg, closure cl, mixed extra...)
+ mixed * filter(mixed *arg, mapping map, mixed extra...)
-FUNKTION:
- mixed * filter(mixed *arg, string fun, string|object ob
- , mixed extra...)
- mixed * filter(mixed *arg, closure cl, mixed extra...)
- mixed * filter(mixed *arg, mapping map, mixed extra...)
+ string filter(string arg, string fun, string|object ob
+ , mixed extra...)
+ string filter(string arg, closure cl, mixed extra...)
+ string filter(string arg, mapping map, mixed extra...)
- string filter(string arg, string fun, string|object ob
- , mixed extra...)
- string filter(string arg, closure cl, mixed extra...)
- string filter(string arg, mapping map, mixed extra...)
+ mapping filter(mapping arg, string func, string|object ob
+ , mixed extra...)
+ mapping filter(mapping arg, closure cl, mixed extra...)
- mapping filter(mapping arg, string func, string|object ob
- , mixed extra...)
- mapping filter(mapping arg, closure cl, mixed extra...)
+BESCHREIBUNG
+ Ruft fuer jedes Element des Arrays oder Mappings <arg> die Funktion
+ <ob>-><func>() bzw. die Closure <cl> auf und liefert jene Elemente,
+ fuer die die Funktion / Closure TRUE ergeben hat. Die <extra>
+ Argumente werden als zusaetzliche Parameter an die Funktion
+ uebergeben und duerfen keine Referenzen von Array- oder Mapping-
+ Elementen sein (wie &(i[1]) ).
+ Wird <ob> nicht angegeben oder ist es weder ein String noch ein
+ Objekt, wird standardmaessig this_object() verwendet.
-PARAMETER:
- arr - zu filterndes Array/Mapping/String
- fun/cl - zu rufende Methode/Closure
- map - filterndes Mapping
- ob - Objekt/Dateiname, an dem Methode gerufen werden soll
- extra - weitere Parameter fuer Methode/Closure
+ Ist <arg> ein Array oder struct, wird <fun> mit jedem Element des
+ Arrays/der struct als ersten Parameter aufgerufen, gefolgt von den
+ <extra> Argumenten. Wenn das Resultat der Funktion TRUE ergibt, wird
+ das Element in das Ergebnis der filter() Operation mit einbezogen.
-BESCHREIBUNG:
- Ruft fuer jedes Element des Arrays oder Mappings <arg> die Funktion
- <ob>-><func>() bzw. die Closure <cl> auf und liefert jene Elemente,
- fuer die die Funktion / Closure TRUE ergeben hat. Die <extra>
- Argumente werden als zusaetzliche Parameter an die Funktion
- uebergeben und duerfen keine Referenzen von Array- oder Mapping-
- Elementen sein (wie &(i[1]) ).
+ Wird filter() mit einem Mapping <map> anstelle der Funktion <func>
+ aufgerufen, wird jedes Element im Array <arg>, das ein Key von <map>
+ ist, ins Ergebnis mit einbezogen.
- Wird <ob> nicht angegeben oder ist es weder ein String noch ein
- Objekt, wird standardmaessig this_object() verwendet.
+ Wenn <arg> ein Mapping ist, wird die Funktion <func> mit jedem Key
+ als erstem und (falls vorhanden) den Werten dieses Keys als zweitem
+ Parameter, gefolgt von den <extra> Argumenten, aufgerufen. Wenn die
+ Funktion TRUE ergibt, wird das betreffende Element des Mappings ins
+ Ergebnis aufgenommen.
- Ist <arg> ein Array oder struct, wird <fun> mit jedem Element des
- Arrays/der struct als ersten Parameter aufgerufen, gefolgt von den
- <extra> Argumenten. Wenn das Resultat der Funktion TRUE ergibt, wird
- das Element in das Ergebnis der filter() Operation mit einbezogen.
+ Abhaengig von der Groesse des Mappings <arg> erfolgt der Aufruf der
+ Funktion auf drei unterschiedliche Arten:
- Wird filter() mit einem Mapping <map> anstelle der Funktion <func>
- aufgerufen, wird jedes Element im Array <arg>, das ein Key von <map>
- ist, ins Ergebnis mit einbezogen.
+ widthof(arg) == 0: ob->func(key, 0, extra...)
+ == 1: ob->func(key, arg[key], extra...)
+ > 1: ob->func( key
+ , ({ arg[key,0] ...arg[key,width-1] })
+ , extra...)
- Wenn <arg> ein Mapping ist, wird die Funktion <func> mit jedem Key
- als erstem und (falls vorhanden) den Werten dieses Keys als zweitem
- Parameter, gefolgt von den <extra> Argumenten, aufgerufen. Wenn die
- Funktion TRUE ergibt, wird das betreffende Element des Mappings ins
- Ergebnis aufgenommen.
+ Der Vorteil dieser Vorgehensweise ist, dass beide Typen von
+ multidimensionalen Mappings (Mappings mit mehreren Werte pro Key und
+ Mappings aus Arrays) gleich verarbeitet werden koennen.
- Abhaengig von der Groesse des Mappings <arg> erfolgt der Aufruf der
- Funktion auf drei unterschiedliche Arten:
+ Ist <arg> ein String, werden der Filterfunktion die einzelnen Zeichen
+ des Strings uebergeben und nur jene Zeichen im zurueckgegebenen
+ String aufgenommen, fuer die die Filterfunkton != 0 zurueckgibt.
- widthof(arg) == 0: ob->func(key, 0, extra...)
- == 1: ob->func(key, arg[key], extra...)
- > 1: ob->func( key
- , ({ arg[key,0] ...arg[key,width-1] })
- , extra...)
+ANMERKUNGEN
- Der Vorteil dieser Vorgehensweise ist, dass beide Typen von
- multidimensionalen Mappings (Mappings mit mehreren Werte pro Key und
- Mappings aus Arrays) gleich verarbeitet werden koennen.
+ Fuer Arrays wirkt filter() wie filter_array(), fuer Mappings stellt
+ filter() eine Verallgemeinerung von filter_indices() dar.
- Ist <arg> ein String, werden der Filterfunktion die einzelnen Zeichen
- des Strings uebergeben und nur jene Zeichen im zurueckgegebenen
- String aufgenommen, fuer die die Filterfunkton != 0 zurueckgibt.
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.6. Die Funktion loest filter_array() ab.
-
-AENDERUNGEN
- Eingefuehrt in LDMud 3.2.6. Die Funktion loest filter_array() ab.
-
-RUeCKGABEWERT:
- Gefiltertes Array mit allen die Filterbedingung erfuellenden Elementen.
-
-BEMERKUNGEN:
- (1) Achtung, die Elemente in 'arr' werden nicht tief kopiert, sind sie
- also selbst Arrays oder Mappings, so fuehrt eine spaetere Aenderung im
- Rueckgabe-Arrays zur Aenderung im Ursprungsarray:
-
- int *i, *j;
- i=({({1,2,3}),({4,5,6})});
- j=filter(i, #'sizeof); // filtert leere Arrays heraus
- j[0][0]=8;
-
- fuehrt zu: i==j==({({8,2,3}),({4,5,6})});
-
- (2) Das Kopieren in das Rueckgabemapping erfolgt fuer jedes Element nach
- Ausfuehrung der Filtermethode. Aenderungen der Werte im Array in dieser
- Methode (globale Variable/Uebergabe als Referenz an filter)
- schlagen sich also im Rueckgabearray nieder.
-
- (3) Fuer Arrays wirkt filter() wie filter_array(), fuer Mappings stellt
- filter() eine Verallgemeinerung von filter_indices() dar.
-
-BEISPIEL:
- ### Filtere alle Lebewesen in einem Raum in ein Array ###
- filter(all_inventory(this_object()),#'living);
-
- ### Filtere alle tauben Spieler im Raum in ein Array ###
- static int filter_isdeaf(object who) {
- return (interactive(who) && who->QueryProp(P_DEAF));
- }
-
- filter(all_inventory(this_object()), #'filter_isdeaf);
-
-
- ### Filtern von Idlern (>=1 Sekunde idle) ###
- // Folgend identische Resultate, aber andere Ansaetze:
-
- #1: nutzt die Efun query_idle() als Lfun-Closure (ideal hier)
- idle_usr = filter(users(), #'query_idle );
-
- #2: mit Filtermethode
- int check_if_idle(object user) {
- return query_idle(user);
- }
-
- #2a: filtert mittels der Lfun im selben Objekt die Idler in das
- Rueckgabearray
- idle_usr = filter(users(), "check_if_idle");
- idle_usr = filter(users(), "check_if_idle", this_object());
-
- #2b: ruft die Lfun check_if_idle() als Lfun-Closure (Funktions-
- pointer)
- idle_usr = filter(users(), #'check_if_idle );
-
- #3: Nutzt eine Inline-Closure
- idle_usr = filter(users(), function int (object user) {
- return query_idle(user);
- } );
-
- ### Filtern von Idlern (>=20 Sekunden idle) mit Extraparameter ###
- // Folgend identische Resultate, aber andere Ansaetze:
-
- #1: die Efun koennen wir nicht mehr direkt nutzen, weil sie
- diesen Parameter nicht unterstuetzt
- // idle_usr = filter(users(), #'query_idle );
-
- #2: mit separater Filtermethode ... mit neuem Parameter
- int check_if_idle(object user, int length) {
- return query_idle(user)>length;
- }
-
- #2a: filtert mittels der Lfun im selben Objekt die Idler in das
- Rueckgabearray ... mit drittem Parameter!
- idle_usr = filter(users(), "check_if_idle", this_object(), 20);
-
- #2b: ruft die Lfun check_if_idle() als Lfun-Closure (Funktions-
- pointer)
- idle_usr = filter(users(), #'check_if_idle, 20);
-
- #3: Nutzt eine Inline-Closure
- idle_usr = filter(users(), function int (object user, int length) {
- return (query_idle(user) > length);
- }, 20);
-
-SIEHE AUCH:
- Arrays: map(E)
- Objektarrays: filter_objects(E), map_objects(E)
- Mappings: filter_indices(E), map_indices(E)
- walk_mapping(E), member(E)
-
- Sonstiges: sort_array(E), unique_array()
- transpose_array(E)
-
-----------------------------------------------------------------------------
-23.09.2019, Zesstra
+SIEHE AUCH
+ filter(E), filter_indices(E), map(E), walk_mapping(E), member(E),
+ m_contains(E)
diff --git a/doc/efun/filter_objects b/doc/efun/filter_objects
index 9fb6922..87c96f6 100644
--- a/doc/efun/filter_objects
+++ b/doc/efun/filter_objects
@@ -1,59 +1,11 @@
-filter_objects(E)
+SYNOPSIS
+ object * filter_objects(object *arr, string fun, mixed extra, ...)
-FUNKTION:
- object *filter_objects(mixed *arr, string fun, [, mixed extra, ...])
+BESCHREIBUNG
+ Diese Efun ist aehnlich wie filter(), es wird aber
+ arr[n]->fun(extra,...) aufgerufen. Wenn der Aufruf einen Wert != 0
+ liefert, wird das Objekt arr[n] in das Resultat uebernommen.
+ 0-Eintraege in <arr> werden ignoriert.
-PARAMETER:
- arr - zu filterndes Array von Objekten/Objektpfaden
- fun - an Objekten zu rufende Methode
- extra - weitere Parameter fuer Methode
-
-BESCHREIBUNG:
- Filtert die Elemente aus 'arr' durch den Aufruf der Methode 'fun' an
- jedem der Elemente von 'arr'. 0-Eintraege werden ignoriert.
-
- Wenn der Aufruf
- arr[n]->fun([extra1, extra2, ...])
- als Rueckgabewert !=0 zurueckgibt dann wird das Element in das neue
- Array aufgenommen, sonst nicht.
-
-RUeCKGABEWERT:
- Gefiltertes Array mit Filterbedingung erfuellenden Objekten.
-
-BEMERKUNGEN:
- Werden Pfade angegeben, so wird versucht ein Objekt zu laden, falls
- dieses nicht existiert.
-
-BEISPIEL:
- // gibt alle tauben Personen wieder
- deaf=filter_objects(users(), "QueryProp", P_DEAF);
-
- // gibt alle blinden Personen wieder
- blind=filter_objects(users(), "QueryProp", P_BLIND);
-
- // filtert alle Objekte auf eine bestimmte ID (-> present)
- idmatch=filter_objects(arr, "id", "irgendwasID");
-
- // gibt alle Autoloader wieder
- al=filter_objects(all_inventory(this_player()),
- "QueryProp", P_AUTOLOADOBJ);
-
-AeQUIVALENZCODE (nicht empfohlen, nur zum Verstaendnis!):
- int i;
- object *ret; mixed *input;
-
- ret=allocate(0);
- i=sizeof(input);
- while(i--)
- if(input[i]->fun([extra1, extra2, ...]))
- ret+=({input[i]});
-
-SIEHE AUCH:
- Arrays: filter(E), map(E)
- Objektarrays: map_objects(E)
- Mappings: filter_indices(E), map_indices(E)
-
- Sonstiges: sort_array(E), unique_array()
- alist, transpose_array(E)
-
-20.Jan 2005 Gloinson
+SIEHE AUCH
+ filter(E), map(E), map_objects(E)
diff --git a/doc/efun/find_call_out b/doc/efun/find_call_out
index 3517518..6716a04 100644
--- a/doc/efun/find_call_out
+++ b/doc/efun/find_call_out
@@ -1,37 +1,28 @@
-FUNKTION:
- int find_call_out(string func)
- int find_call_out(closure cl)
+SYNOPSIS
+ int find_call_out(string fun)
+ int find_call_out(closur cl)
-BESCHREIBUNG:
- Findet den ersten call_out() auf die Funktion 'func' im aktuellen Objekt
- (bzw. auf die Closure 'cl') der ausgefuehrt werden soll.
- Zurueck gegeben wird die verbleibende Zeit bis zum Aufruf in Sekunden.
- Wenn kein call_out() gefunden wird, wird -1 zurueck gegeben.
+BESCHREIBUNG
+ Findet den ersten call_out() auf die Funktion fun im aktuellen Objekt
+ (bzw. auf die Closure cl) der ausgefuehrt werden soll. Zurueck gegeben
+ wird die verbleibende Zeit bis zum Aufruf. Wenn kein call_out()
+ anhaengig ist, wird -1 zurueck gegeben.
-BEISPIELE:
- // Findet sich kein call_out auf die Funktion 'func', so kann er
- // gestartet werden. (Wichtig falls der call_out nicht mehrfach
- // aufgerufen werden soll).
-
- if(find_call_out("func")==-1)
- call_out("func",5);
+FEHLER
+ Die Suche nach call_out()s auf Closures funktioniert nur, wenn der
+ genaue Wert der Closure gesucht wird.
- // Die Suche nach call_out()s auf Closures funktioniert nur, wenn der
- // genaue Wert der Closure gesucht wird.
-
- // Das funktioniert:
+ Das funktioniert:
closure cl = symbol_function("main", obj);
call_out(cl, 2);
find_call_out(cl);
- // Das funktioniert nicht:
+ Das funktioniert nicht:
call_out(symbol_function("main", obj), 2);
find_call_out(symbol_function("main", obj));
- Ein Codebeispiel, um alle call_out()s auf eine Funktion zu entfernen,
- findet sich in der Manpage zu remove_call_out().
+GESCHICHTE
+ Die Suche nach call_out()s auf Closures wurde in 3.2.1@45 eingefuehrt.
-SIEHE AUCH:
+SIEHE AUCH
call_out(E), remove_call_out(E), call_out_info(E)
-
-25.08.2016, Arathorn
diff --git a/doc/efun/get_eval_cost b/doc/efun/get_eval_cost
index 50bc012..ac3ab9d 100644
--- a/doc/efun/get_eval_cost
+++ b/doc/efun/get_eval_cost
@@ -1,33 +1,16 @@
-FUNKTION:
- int get_eval_cost(void)
+SYNOPSIS
+ int get_eval_cost()
-BESCHREIBUNG:
+BESCHREIBUNG
Liefert die noch verbleibenden Eval Kosten, die das momentane
Kommando noch verbrauchen darf.
- Der Maximalwert betraegt zur Zeit 1.500.000 Ticks (Stand: 2007).
- Sollten die Kosten bei der Ausfuehrung irgendwo groesser werden,
- wird ein Fehler der Art "too long eval" erzeugt. Diese Funktion
- dient dazu, solche Fehler genau zu lokalisieren bzw.
- herauszufinden, an welchen Stellen im Code wieviel Rechenzeit
- verbraucht wird.
-
-BEISPIELE
- void foo()
- {
- int prev, used, i;
-
- prev=get_eval_cost(); // Merken, was bis hierhin verbraucht wurde
- for (i=0;i<=1000;i++) // Dann kommt der zu testende Code, zB eine
- { // Schleife
- ...
- }
- used=prev-get_eval_cost(); // Berechnung der Differenz
- printf("Die Schleife verbrauchte %d Ticks.\n", used);
- }
+ Das Resultat beginnt bei einer hohen, vom Treiber festgelegten Zahl
+ und nimmt fuer jede ausgefuehrte Anweisung ab.
-SIEHE AUCH:
- caller_stack_depth(E), rusage(E), command(E), query_limits(E)
- Konstante: __MAX_EVAL_COST__
+GESCHICHTE
+ Der Anfangswert, also die vom Treiber zur Verfuegung gestellten Evals,
+ sind seit 3.2.6 in LDMud als Makro verfuegbar.
-4.Aug 2007 Gloinson
+SIEHE AUCH
+ rusage(E), command(E), query_limits(E)
diff --git a/doc/efun/lambda b/doc/efun/lambda
index b156798..14a709f 100644
--- a/doc/efun/lambda
+++ b/doc/efun/lambda
@@ -1,5 +1,5 @@
SYNOPSIS
- closure lambda(mixed *arr, mixed);
+ closure lambda(mixed *arr, mixed)
BESCHREIBUNG
Erzeugt eine Lambda Closure, entsprechend den Lamda Closures in LISP.
@@ -10,19 +10,8 @@
beschreibt, die der Closure bei ihrer Auswertung durch funcall()
oder apply() uebergeben werden.
- Von der Verwendung wird aus Lesbarkeits- und Wartungsgruenden dringend
- abgeraten.
-
-BEISPIEL
- // Lambdas werden gern eingesetzt, um komplexere Filter zu schreiben
- // Allerdings kann jede Lambda dabei auch durch eine Inline-Closure
- // oder eine LFun-Closure ersetzt werden.
- filter(users(),
- lambda(({'x}),
- ({#'==,
- ({#'call_other,'x,"QueryProp",P_SECOND}),"gloinson"
- })));
+GESCHICHTE
+ Eingefuehrt in 3.2@70.
SIEHE AUCH
- Verwandt: unbound_lambda(E), apply(E), funcall(E), bind_lambda(E)
- Generell: closures-abstract(LPC), closures(LPC)
+ closures(LPC), unbound_lambda(E), apply(E), funcall(E), bind_lambda(E)
diff --git a/doc/efun/limited b/doc/efun/limited
index c967812..1155af1 100644
--- a/doc/efun/limited
+++ b/doc/efun/limited
@@ -1,30 +1,32 @@
VORLAEUFIG, GESCHUETZT
SYNOPSIS
- #include <sys/rtlimits.h>
+ #include <rtlimits.h>
- mixed limited(closure fun);
- mixed limited(closure fun, int tag, int value, ...);
- mixed limited(closure fun, int *limits [, mixed *args]);
+ mixed limited(closure fun)
+ mixed limited(closure fun, int tag, int value, ...)
+ mixed limited(closure fun, int *limits)
+ mixed limited(closure fun, int *limits, mixed *args)
BESCHREIBUNG
limited() ruft die Funktion <fun> mit den bezeichneten Argumenten
- <args> auf und fuehrt sie mit den gegebenen Laufzeitlimiten aus.
+ <args> auf und fuehrt sie mit den gegebenen Laufzeitlimitierungen aus.
Beim Ende der Funktion <fun> werden die momentan aktiven
- Laufzeitlimiten wiederhergestellt. limited() liefert den
+ Laufzeitlimitierungen wiederhergestellt. limited() liefert den
Rueckgabewert der Closure <fun> zurueck.
- Die Laufzeitlimiten koennen in zwei Formen angegeben werden: als
- Array (wie es von query_limits() geliefert wird) oder als Liste von
- Werten mit Tags. Wird limited() ohne Angabe von Limits aufgerufen,
- gelten die Laufzeitlimiten als 'unlimitiert'.
+ Die Laufzeitlimitierungen koennen in zwei Formen angegeben werden:
+ * als Array (wie es von query_limits() geliefert wird) oder
+ * als Liste von Werten mit Tags.
+ Wird limited() ohne Angabe von Limits aufgerufen, gelten die
+ Laufzeitlimiten als 'unlimitiert'.
- Die Limiteneinstellung kennt drei spezielle Werte aus <rtlimits.h>:
+ Die Limitierung kennt drei spezielle Werte aus <rtlimits.h>:
LIMIT_UNLIMITED: es gibt kein Limit
LIMIT_KEEP: das zuletzt gesetzte Limit wird beibehalten
- LIMIT_DEFAULT: die 'globalen' Limiten werden verwendet
+ LIMIT_DEFAULT: die 'globalen' Limitierungen werden verwendet
- Fuer LIMIT_COST, die Spezialwerte haben diese Bedeutung:
+ Fuer LIMIT_COST haben folgende Spezialwerte eine Bedeutung:
LIMIT_UNLIMITED: die Ausfuehrung kosten lediglich einen Tick
LIMIT_KEEP: LIMIT_COST wird auf 0 gesetzt
LIMIT_DEFAULT: LIMIT_COST wird auf -100 gesetzt
@@ -32,33 +34,23 @@
limited() erzeugt eine Schutzverletzung ("limited", current_object,
fun, limits-array).
-BEMERKUNGEN:
- Diese Funktion kann bei uns mudlibweit genutzt werden. Allerdings wird
- nur die _Reduktion_ von LIMIT_EVAL zugelassen, alle anderen Limits
- duerfen _nicht_ veraendert werden. Hierbei ist zu beachten, dass das
- Limit fuer LIMIT_EVAL um min. 1000 Ticks unter den noch verfuegbaren
- Ticks liegen muss (get_eval_cost()).
- Fuer LIMIT_COST sind nur 0 und -100 zugelassen.
BEISPIELE
limited(#'function)
- --> fuehrt die Funktion ohne Limiten aus.
+ --> fuehrt die Funktion ohne Limits aus.
limited(#'function, ({ 200000 }), "foo")
- --> fuehrt die Funktion mit einem Eval-Kosten Limit von 200000 Ticks
+ --> fuehrt die Funktion mit einem Eval-Kosten-Limit von 200000 Ticks
aus. Die Funktion wird als 'function("foo")' aufgerufen.
limited(lambda(0, ({#'function, "foo"})), LIMIT_EVAL, 200000)
- --> fuehrt die Funktion mit einem Eval-Kosten Limit von 200000 Ticks
+ --> fuehrt die Funktion mit einem Eval-Kosten-Limit von 200000 Ticks
aus. Die Funktion wird als 'function("foo")' aufgerufen.
-AENDERUNGEN
+GESCHICHTE
Eingefuehrt in LDMud 3.2.7.
LDMud 3.3.563 fuehrte LIMIT_COST ein.
+ LDMud 3.5.0 fuehrte LIMIT_MEMORY ein.
SIEHE AUCH
query_limits(E), set_limits(E)
- get_eval_cost(E)
-
-16.05.2007, Zesstra
-
diff --git a/doc/efun/map_indices b/doc/efun/map_indices
deleted file mode 100644
index de3b15f..0000000
--- a/doc/efun/map_indices
+++ /dev/null
@@ -1,75 +0,0 @@
-map_indices(E)
-
-FUNKTION:
- mapping map_indices(mapping m, string fun, object ob [, mixed extra])
- mapping map_indices(mapping m, closure cl [, mixed extra])
-
-PARAMETER:
- arr - zu mappendes Array
- fun/cl - zu rufende Methode/Closure
- ob - Objekt/Dateiname, an dem Methode gerufen werden soll
- extra - weitere Parameter fuer Methode/Closure
-
-BESCHREIBUNG:
- Mapped die Elemente (jeweils Schluessel) aus 'map' durch die Methode
- 'fun' oder die Closure 'cl' in ein neues Mapping.
- Fuer jedes Element aus 'm' wird 'fun' oder 'cl' mit dem Schluessel als
- erstem Parameter [und folgend den optionalen Extra-Parametern] gerufen.
-
- Der Rueckgabewert der Methode/Closure wird in fuer den Schluessel als
- Datenwert in das neue Mapping eingetragen.
-
- ACHTUNG: Alle anderen Daten bei Mapping mit Breite>1 verfallen!
-
- Verwendung von Methoden:
- Wenn bei der Angabe von 'fun' kein Objekt 'ob' in Form eines Strings
- oder Objekts angegeben wird, wird this_object() angenommen.
-
- Verwendung von Closures:
- Es koennen sowohl Lfun-Closures als auch Lambda-Closures verwendet
- werden. Lfun-Closures koennen, wenn im selben Objekt vorhanden auch
- 'private' oder/und 'static' deklariert sein, muessen aber zu dem
- Zeitpunkt der Verwendung bekannt sein (Funktionsprototypen benutzen).
-
-RUeCKGABEWERT:
- Mapping mit Schluessel:Rueckgabewerten der Methode/Closure.
-
-BEISPIELE:
- // ersetze in einem Mapping die Datenwerte durch das Doppelte,
- // nutze dabei die Datenwerte des Altmappings durch Uebergabe als
- // extra-Parameter
-
- // Anmerkung: Das geht mit walk_mapping() eleganter!
-
- int do_double(string key, mapping m, int mult) {
- return m[key]*mult;
- }
-
- mapping x, y;
- x=(["a":2, "b":3]);
- y=map_indices((["a":2, "b":3]), #'do_double, &x, 3);
-
- y == (["a":6,"b":9])
-
-AeQUIVALENZCODE (nicht empfohlen, nur zum Verstaendnis!):
- int i;
- mapping ret; mapping input;
- mixed *index;
-
- ret=m_allocate(0, 1);
- index=m_indices(input);
- i=sizeof(index);
- while(i--)
- ret[index[i]]=ob->fun(index[i] [, extra1, extra2, ...]))
- // ret[index[i]]=funcall(cl, index[i] [, extra1, extra2, ...]);
-
-SIEHE AUCH:
- Arrays: filter(E), map(E)
- Objektarrays: filter_objects(E), map_objects(E)
- Mappings: filter_indices(E)
-
- Sonstiges: walk_mapping(E), m_contains(E)
- member()
- m_indices(E), m_values(E)
-
-29.10.2006 Zesstra
diff --git a/doc/efun/map_objects b/doc/efun/map_objects
index 4543a2e..a0961f9 100644
--- a/doc/efun/map_objects
+++ b/doc/efun/map_objects
@@ -1,51 +1,15 @@
-map_objects(E)
+SYNOPSIS
+ mixed * map_objects(object *arr, string fun, mixed extra, ...)
+ mixed * map_objects(string *arr, string fun, mixed extra, ...)
-FUNKTION:
- object *map_objects(object *arr, string fun [, mixed extra])
+BESCHREIBUNG
+ map_objects() verhaelt sich aehnlich wie map(), ruft jedoch
+ arr[n]->fun(extra, ...) auf. Der Rueckgabewert ersetzt das Objekt bzw.
+ den Objektnamen in <arr>.
+ <arr> kann auch eine Mischung aus Objekten und Objektnamen enthalten.
+ Es ist eine beliebige Anzahl <extra> Argumente erlaubt, welche alle an
+ die Funktion <fun> uebergeben werden.
+ 0-Eintraege in <arr> werden ignoriert.
-PARAMETER:
- arr - zu mappendes Array von Objekten/Objektpfaden
- fun - an Objekten zu rufende Methode
- extra - weitere Parameter fuer Methode
-
-BESCHREIBUNG:
- Mapped die Elemente aus 'arr' durch den Aufruf der Methode 'fun' an
- jedem der Elemente von 'arr' in ein neues Array.
- 0-Eintraege werden ignoriert.
-
- Der Rueckgabewert von
- arr[n]->fun([extra1, extra2, ...])
- wird an der Indexposition des Elementes in das neue Array eingetragen.
-
-RUeCKGABEWERT:
- Array mit Resultaten der Funktionsaufrufe am jeweiligen Objekt.
-
-BEMERKUNGEN:
- Werden Pfade angegeben, so wird versucht ein Objekt zu laden, falls
- dieses nicht existiert.
-
-BEISPIEL:
- // ersetze alle Objekte durch ihre Namen
- arr=map_objects(inputarr, "name");
-
- // ersetze alle Objekte durch ihre Namen im Genitiv
- arr=map_objects(inputarr, "name", WESSEN);
-
-AeQUIVALENZCODE (nicht empfohlen, nur zum Verstaendnis!):
- int i;
- object *ret; mixed *input;
-
- i=sizeof(input);
- ret=allocate(i);
- while(i--)
- ret[i]=input[i]->fun([extra1, extra2, ...]);
-
-SIEHE AUCH:
- Arrays: filter(E), map(E)
- Objektarrays: filter_objects(E)
- Mappings: filter_indices(E), map_indices(E)
-
- Sonstiges: sort_array(E), unique_array()
- alist, transpose_array(E)
-
-20.Jan 2005 Gloinson
+SIEHE AUCH
+ map(E), filter(E), filter_objects(E)
diff --git a/doc/efun/raise_error b/doc/efun/raise_error
index 40ac234..e063420 100644
--- a/doc/efun/raise_error
+++ b/doc/efun/raise_error
@@ -1,5 +1,5 @@
SYNOPSIS
- void raise_error(string arg);
+ void raise_error(string arg)
BESCHREIBUNG
Bricht die Ausfuehrung des laufenden Programms ab. Wenn das Programm
@@ -14,10 +14,5 @@
einschliesslich der Erzeugung eines Stack Backtraces, ist diese
Funktion sehr zeitintensiv.
-BEMERKUNGEN
- Der String sollte umgebrochen oder wenigstens mit einem \n terminiert
- werden, da die Ausgabe direkt an den interaktiven Magier erfolgen
- kann bzw. auf dem Debug-Kanal das letzte Zeichen entfernt wird.
-
SIEHE AUCH
catch(E), throw(E)
diff --git a/doc/efun/random b/doc/efun/random
index a98542b..d3f876f 100644
--- a/doc/efun/random
+++ b/doc/efun/random
@@ -1,42 +1,16 @@
-FUNKTION:
+SYNOPSIS
int random(int n)
-ARGUMENTE:
- n: Zahlen-Bereich aus dem gewaehlt werden soll.
+BESCHREIBUNG
+ Liefert eine Zufallszahl im Bereich [0 .. n-1].
-BESCHREIBUNG:
- Gibt eine zufaellige Zahl im Bereich von 0..(n-1) zurueck.
+ Dieser Zufallszahlgenerator liefert eine gleichmaessige Verteilung von
+ Zahlen ueber einen grossen Bereich, ohne Wiederholung von Sequenzen
+ waehrend einer langen Zeit. Der Nachteil dieser (wuenschenswerten)
+ Qualitaeten ist, dass wenn viele Zahlen in einem kleinen Bereich in
+ kurzer Zeit generiert werden, einige Zahlen sehr viel haeufiger
+ auftreten als andere.
-BEMERKUNGEN:
- Der Nachteil der Zufaelligkeit (ueber grosse Zahlen) ist, dass wenn
- viele Zahlen in einem kleinen Bereich in kurzer Zeit generiert
- werden, einige Zahlen sehr viel haeufiger auftreten als andere.
-
- Es sei nochmal darauf hingewiesen, dass der Bereich immer bei 0
- und NICHT bei 1 anfaengt. Ein random(10) geht also nicht von
- 1..10 sondern von 0..9!
-
-BEISPIELE:
- // Einfache Abfrage z.B. aus der HitFunc einer Waffe:
-
- if(random(101) >= 70) return random(11);
- else return 0;
-
- // Spieler soll in einen zufaellig ausgewaehlten Raum gemovt
- // werden:
-
- string *dest = ({ "raum1","raum2","raum3","raum4","raum5" });
- this_player()->move(dest[random(sizeof(dest))],M_GO|M_NOCHECK);
-
- // Es soll eine zufaellige Meldung ausgegeben werden:
-
- tell_object(this_player(),
- ({ "Es knackt.\n", "Dir ist kalt.\n", "Du schwitzt.\n",
- "Du bekommst Angst.\n", "Hinter Dir knackt es im Gebuesch.\n",
- "Ein kuehler Wind kommt auf.\n" })[random(6)]);
-
- Wie man sieht, gibt es fuer random() viele schoene Einsatz-
- moeglichkeiten. Wobei letzteres Beispiel ueber AddRoomMessage
- (fuer Raeume) viel einfacher umzusetzen ist.
-
-7.Aug 2007 Gloinson
+ Die einzige Loesung hierzu ist eine spezielle simul_efun, die geeignete
+ Schritte unternimmt, um eine gleichmaessige Verteilung ueber kleine
+ Bereiche in kurzen Zeitraeumen zu erreichen.
diff --git a/doc/efun/regexplode b/doc/efun/regexplode
index 595e9df..ca67db8 100644
--- a/doc/efun/regexplode
+++ b/doc/efun/regexplode
@@ -1,8 +1,8 @@
SYNOPSIS
#include <regexp.h>
- string *regexplode (string text, string pattern)
- string *regexplode (string text, string pattern, int opt)
+ string * regexplode(string text, string pattern)
+ string * regexplode(string text, string pattern, int opt)
DESCRIPTION
This function is similar to explode but accepts a regular
@@ -19,9 +19,11 @@
regexplode("abcdef", "cde", RE_OMIT_DELIM) -> ({ "ab", "f" })
HISTORY
- Introduced in 3.2@61
+ Introduced in 3.2@61.
LDMud 3.3 added the optional <opt> argument and the RE_OMIT_DELIM
flag.
+ Since 3.5.0 a error is raised if RE_PCRE is specified in <opt>, but
+ the driver lacks PCRE support.
SEE ALSO
explode(E), regexp(E), regmatch(E), regreplace(E),
diff --git a/doc/efun/replace_program b/doc/efun/replace_program
index 4812d4e..d2f41b4 100644
--- a/doc/efun/replace_program
+++ b/doc/efun/replace_program
@@ -1,6 +1,6 @@
SYNOPSIS
- void replace_program();
- void replace_program(string program);
+ void replace_program()
+ void replace_program(string program)
BESCHREIBUNG
Ersetzt ein Programm mit dem geerbten Programm (inherit) <program>.
@@ -36,17 +36,12 @@
verschwundene Lfuns des Objekts referenzieren. Das stellt allerdings
kein Problem dar, solange diese Referenzen nicht ausgefuehrt werden.
-BEMERKUNGEN
- Raeume benutzen replace_program automatisch. Es ist nicht sinnvoll
- oder notwendig, replace_program selbst ohne Konsultaton mit einem
- Erzmagier einzusetzen!
-
-BUGS
+FEHLER
Wenn ein ersetzendes Programm virtuell geerbte Variablen enthaelt,
muss dieses Programm als erstes geerbt werden. Ohne diese
Einschraenkung ueberleben die falschen Variablen den
Ersetzungsprozess.
-AENDERUNGEN
+GESCHICHTE
LDMud 3.2.9 liess zu, dass das Argument <program> weggelassen wird,
wenn nur ein Inherit existiert.
diff --git a/doc/efun/save_object b/doc/efun/save_object
index 681946b..2ec83b2 100644
--- a/doc/efun/save_object
+++ b/doc/efun/save_object
@@ -1,10 +1,10 @@
SYNOPSIS
- int save_object(string name [, int format]);
- string save_object([int format]);
+ int save_object(string name [, int format])
+ string save_object([int format])
BESCHREIBUNG
- Codiert die speicherbaren (s.u.) Variablen des aktuellen Objekts in
- einen String.
+ Codiert die speicherbaren Variablen des aktuellen Objekts in einen
+ String.
In der ersten Form wir der String in die Datei <name> geschrieben. Eine
Endung ".c" in <name> wird entfernt, dafuer kann eine Endung ".o"
@@ -24,23 +24,17 @@
0: das Originalformat nach Amylaar's LPMud und LDMud <=3.2.8
1: LDMud >= 3.2.9: Non-Lambda Closures, Symbole und gequotete
Arrays koennen gespeichert werden
+ 2: LDMUd >= 3.5.0: Gleitkommazahlen werden in einem neuen Format
+ geschrieben, welches kompakter ist die Gleitkommazahlen aus
+ 3.5.x verlustfrei speichern kann.
+
+ Es wird empfohlen, die Angabe des Formats wegzulassen oder in Version
+ 2 (oder hoeher) zu speichern.
Eine Variable wird als 'speicherbar' betrachtet, wenn sie nicht als
'nosave' oder 'static' deklariert ist.
- Bitte beachten, dass diese efun im MG durch eine Sefun ueberschrieben
- wird und deren Manpage auch lesen!
-
-BEMERKUNGEN:
- Damit ein Objekt in Verzeichnisse der Region/des Magiers schreiben
- kann, muss es entsprechende Rechte, also eine gueltige EUID
- besitzen. Im create() sollte daher ein:
-
- seteuid(getuid(this_object()));
-
- stehen.
-
-AENDERUNGEN
+GESCHICHTE
Seit LDMud 3.2.8 liefert save_object() einen fixen Wert bei Erfolg.
Das direkte Abspeichern in einen String wurde in LDMud 3.2.8
eingefuehrt, wird aber in Zukunft eventuell in eine separate Efun
@@ -49,6 +43,7 @@
Closures, Symbolen und gequoteten Arrays. Dazu wurde ein neues
Format fuer die Speicherdatei eingefuehrt.
LDMud 3.2.10 fuehrte das Argument <format> ein.
+ LDMud 3.5.0 fuehrte Formatversion 2 ein.
SIEHE AUCH
- restore_object(E), save_value(E), save_object (Sefun)
+ restore_object(E), save_value(E)
diff --git a/doc/efun/say b/doc/efun/say
index 6f0958f..61dc373 100644
--- a/doc/efun/say
+++ b/doc/efun/say
@@ -1,11 +1,11 @@
SYNOPSIS
- void say(string str);
- void say(string str, object exclude);
- void say(string str, object *excludes);
+ void say(string str)
+ void say(string str, object exclude)
+ void say(string str, object *excludes)
- void say(mixed *|mapping|struct|object msg);
- void say(mixed *|mapping|struct|object msg, object exclude);
- void say(mixed *|mapping|struct|object msg, object *excludes);
+ void say(mixed *|mapping|struct|object msg)
+ void say(mixed *|mapping|struct|object msg, object exclude)
+ void say(mixed *|mapping|struct|object msg, object *excludes)
BESCHREIBUNG
Es bestehen zwei Hauptanwendungen fuer say():
@@ -14,21 +14,22 @@
lebendigen Objekte im aktuellen Raum gesendet, ausser zum Objekt,
das die Funktion aufgerufen hat.
- Ist die Nachricht ein String, wird der Text an interaktive Objekte
- direkt ausgegeben, fuer andere Objekte wird die lfun catch_tell()
- in diesen aufgerufen.
- Falls ein Lewebesen die Funktion catch_tell() definiert (-> shadow),
- so wird der Text hier ausgewertet und nicht an den User ausgegeben.
+ Wenn das erste Argument ein nicht-String <msg> ist, wird die Lfun
+ catch_msg() in allen lebendigen Objekt im Raum aufgerufen, ausser im
+ Objekt, das say() aufgerufen hat. Der Wert <msg> wird als erstes
+ Argument an catch_msg() uebergeben, das aufrufende Objekt als zweites
+ Argument.
- Wenn das zweite Argument, die Nachricht, kein String ist, wird in
- allen Lebewesen, die den Text erhalten, catch_msg() anstatt
- catch_tell() aufgerufen.
+ MERKE: Wenn die Lfun catch_msg() den Wert <msg> veraendert, erhalten
+ alle nachfolgenden Objekte das veraenderte <msg>.
- Mit dem Array <*exclude> kann man verhindern, dass die Nachricht an
- die darin enthaltenen Objekte gesendet wird. Der Sender muss nicht
- noch einmal aufgefuehrt werden.
- Das ist sinnvoll, wenn zB eine Spielergruppe Ausloeser einer Meldung
- ist und diese selbst nicht erhalten soll.
+ Wird der Efun say() ein zweites Argument angegeben, kann man andere
+ Objekte als nur das aufrufende Objekt ausschliessen. Wenn das zweite
+ Argument ein einzelnes Objekt <exclude> ist, werden das aufrufende
+ Objekt und <exclude> von der Meldung ausgeschlossen. Wenn das zweite
+ Argument ein Array <excludes> ist, werden alle Objekte aus dieser
+ Liste zusaetzlich zum aufrufenden Objekt als Empfaenger von say()
+ ausgeschlossen.
Das aufrufende Objekt wird nach folgenden Regeln bestimmt:
- Wenn say() aus einem lebendigen Objekt aufgerufen wird, gilt
@@ -37,62 +38,61 @@
Handlung eines Benutzers aufgerufen wird (das heisst,
this_player() ist gueltig), gilt this_player() als aufrufendes
Objekt.
- - In allen anderen Faellen (Aufruf aus reset zB) gilt das Objekt,
- das say() aufgerufen hat, als aufrufendes Objekt.
-
-BEMERKUNGEN
- - fuer laengere Meldungen sollte break_string() verwendet werden
- - wird in einem catch_msg() der Wert von <msg> veraendert, erhalten
- alle nachfolgenden Objekte das veraenderte <msg> (Referenz!)
-
- - say(<str>) ist verhaltensgleich zu
- tell_room(environment(), <str>, ({this_player()||this_object()}))
+ - In allen anderen Faellen gilt das Objekt, das say() aufgerufen
+ hat, als aufrufendes Objekt.
BEISPIELE
- // Folgende Aufrufe sind gleich, wenn sie durch ein Spielerkommando
- // in einem nicht lebendigen Objekt aufgeloest werden:
+ Folgende Aufrufe sind gleich, wenn sie aus einem nicht lebendigen
+ Objekt aufgerufen werden:
say("Hi!\n");
say("Hi!\n", this_player());
- // Das folgende Beispiel zeigt, wie say() zusammen mit catch_tell()
- // funktioniert. Das zweite Objekt darf nicht lebendig sein, damit
- // write() an den aktuellen Benutzer geht.
+ Das folgende Beispiel zeigt, wie say() zusammen mit catch_tell()
+ funktioniert. Das zweite Objekt darf nicht lebendig sein, sodass
+ write() an den aktuellen Benutzer geht.
Objekt 1 (living):
- void catch_tell(string str) {
+ void catch_tell(string str)
+ {
write("Empfangen: "+str+"\n");
}
Objekt 2 (nicht living):
- void func() {
+ void func()
+ {
...
say("HiHo!\n");
...
}
- // Ein etwas komplexeres Beispiel zeigt das Zusammenspiel von say()
- // und catch_msg(). Auch hier wird ein nicht-lebendiges Objekt
- // verwendet, das die Nachricht ausgibt, sodass das 'wer' in
- // catch_msg() auf den aktuellen Benutzer zeigt.
+ Ein etwas komplexeres Beispiel zeigt das Zusammenspiel von say()
+ und catch_msg(). Auch hier wird ein nicht-lebendiges Objekt
+ verwendet, das die Nachricht ausgibt, sodass das 'wer' in
+ catch_msg() auf den aktuellen Benutzer zeigt.
Object 1 (living):
void catch_msg(mixed *arr, object who) {
- foreach(mixed element: arr)
- tell_object(who, sprintf("%O\n", element));
+ int i;
+ if (!arr) return;
+ for (i=0;i<sizeof(arr);i++)
+ tell_object(who, (stringp(arr[i]) ? arr[i] : "-/-")+"\n");
}
Object 2 (nicht living):
void func() {
...
- say( ({ "Hello", "there!" }) );
+ say(({ "Hello", "there!" }));
...
}
-SIEHE AUCH
- Aehnlich: tell_room(E), write(E), shout(E), tell_object(E),
- printf(E)
- Verwandt: catch_tell(E), catch_msg(A)
- Sonstiges: object_name(E)
+ANMERKUNGEN
+ Wenn die Lfun catch_msg() den Wert <msg> veraendert, erhalten alle
+ nachfolgenden Objekte das veraenderte <msg>.
-7.Aug 2007 Gloinson
\ No newline at end of file
+GESCHICHTE
+ LDMud 3.3.686 erlaubt die Verwendung eines mapping/struct/object als
+ zweites Argument.
+
+SIEHE AUCH
+ write(E), tell_object(E), tell_room(E)
diff --git a/doc/efun/set_next_reset b/doc/efun/set_next_reset
index 89e09c5..20961ea 100644
--- a/doc/efun/set_next_reset
+++ b/doc/efun/set_next_reset
@@ -1,55 +1,26 @@
-FUNKTION
- int set_next_reset(int delay)
-
-ARGUMENTE
- delay - minimale Zeit bis zum naechsten Reset des Objektes
+SYNOPSIS
+ int set_next_reset(int delay)
BESCHREIBUNG
- Mit dieser efun ist es moeglich Einfluss auf das Resetverhalten des
- Objektes zu nehmen:
+ Weist den Gamedriver an, im Objekt nicht vor Ablauf von <delay>
+ Sekunden einen Reset durchzufuehren. Wird fuer <delay> ein negativer
+ Wert angegeben, wird nie ein Reset im Objekt durchgefuehrt (sinnvoll
+ fuer Blueprints). Wird fuer <delay> 0 angegeben, wird die
+ Reset-Zeit des Objekts nicht veraendert.
- Das Objekt bekommt einen reset()-Aufruf fruehestens in <delay> Sekunden.
- Bei Angabe eines Wertes <0 wird der reset() für das Objekt abgeschaltet,
- was fuer Blueprints gelegentlich sinnvoll ist.
+ Die Funktion gibt die verbleibende Zeit bis zum naechsten Reset
+ zurueck, bevor <delay> gesetzt wurde. Der Wert kann auch negativ
+ sein, wenn der Reset ueberfaellig war.
- Intern wird in gleichbleibenden Abstaenden (derzeit: in der Regel 2s,
- kann sich aber auch verzoegern, wenn der Driver viel zu hat, z.B. auf
- 4s) geprueft ob die Zeit zum zum naechsten reset() abgelaufen ist.
- Sollte dies der Fall sein, wird die Funktion reset() im Objekt
- aufgerufen.
-
- Die Funktion gibt die verbleibende Zeit bis zum naechsten Reset
- zurueck, bevor <delay> gesetzt wurde. Der Wert kann auch negativ
- sein, wenn der Reset ueberfaellig war.
-
- Achtung: die tatsaechliche Zeit, wann der Reset im Objekt durchgefuehrt
- wird, haengt auch davon ab, ob das Objekt nach Ablauf von <delay>
- verwendet wird.
+ Merke: die tatsaechliche Zeit, wann der Reset im Objekt
+ durchgefuehrt wird, haengt davon ab, ob das Objekt nach Ablauf
+ von <delay> verwendet wird.
BEISPIELE
- // ein Objekt mit verkuerzter reset()-Zeit
- void create() {
- ...
- set_next_reset(15*60); // ~ 15 Minuten
- ...
- }
+ set_next_reset(15*60); Der naechste Reset erfolgt nach
+ fruehestens 15 Minuten.
+ set_next_reset(0); Gibt die verbleibende Zeit zum naechsten
+ Reset zurueck.
- void reset() {
- set_next_reset(900); // die muss im reset() immer wieder
- ::reset(); // neu gesetzt werden
- }
-
- // ein Objekt, dessen Blueprint keinen reset() bekommen soll
- void create() {
- if(!clonep(this_object())) {
- set_next_reset(-1);
- return;
- }
- ::create();
- ...
- }
-
-SIEHE AUCH
- call_out(E), object_info(E), reset(L), query_next_reset(E)
-
-7.Aug 2007 Gloinson
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.6, angepasst von Morgengrauen.
diff --git a/doc/efun/sort_array b/doc/efun/sort_array
index 80837b7..3316a0c 100644
--- a/doc/efun/sort_array
+++ b/doc/efun/sort_array
@@ -1,108 +1,74 @@
-sort_array(E)
-
-FUNKTION:
- mixed *sort_array(mixed *arr, mixed func [, mixed ob])
-
-PARAMETER:
- arr - zu sortierendes Array
- func - zu rufende Methode; kann als String (Funktionsname) oder
- Closure uebergeben werden
- ob - Objekt, an dem Methode gerufen werden soll; kann als String
- (Filename) oder Objektpointer uebergeben werden
+SYNOPSIS
+ mixed * sort_array(mixed *arr, string wrong_order)
+ mixed * sort_array(mixed *arr, string wrong_order, object|string ob)
+ mixed * sort_array(mixed *arr, string wrong_order, object|string ob,
+ mixed extra...)
+ mixed * sort_array(mixed *arr, closure cl)
+ mixed * sort_array(mixed *arr, closure cl, mixed extra...)
BESCHREIBUNG
- Erzeugt eine (flache) Kopie des Arrays 'arr' und sortiert diese mit der
- Sortierfunktion 'func'. Die sortierte Kopie wird dann zurueckgegeben.
+ Sortiert das Array <arr> entweder nach der Ordnungsfunktion
+ <ob->wrong_order(a, b)> oder nach der Closure cl.
- Die Elemente des zu sortierenden Arrays werden paarweise an die
- Sortierfunktion als Argumente uebergeben.
- Die Sortierfunktion sollte eine Zahl
- - >0 zurueckgeben, wenn die Elemente in der falschen
- Reihenfolge sind
- - <=0 zurueckgeben, wenn die Elemente in der richtigen
- Reihenfolge sind.
+ Normalerweise wird zuerst eine flache Kopie des Arrays <arr> erstellt
+ und die sortierte Kopie als Ergebnis zurueckgeliefert. Wird <arr>
+ jedoch als Referenz uebergeben, wird keine implizite Kopie erstellt
+ und das Originalarray sortiert.
- Verwendung von Methoden:
- Wenn bei der Angabe von 'func' kein Objekt 'ob' in Form eines Strings
- oder Objekts angegeben wird, wird this_object() angenommen.
+ Wenn das Argument <arr> 0 ist, ist das Resultat der Funktion auch 0.
- Verwendung von Closures:
- Es koennen Lfun-, Lambda- und Inline-Closures verwendet werden.
- Lfun-Closures koennen, wenn im selben Objekt vorhanden, auch
- 'private' oder/und 'static' deklariert sein, muessen aber zu dem
- Zeitpunkt der Verwendung bekannt sein (Funktionsprototypen benutzen).
- Von der Verwendung von Lambda-Closures wird ausdruecklich abgeraten.
+ <ob> ist das Objekt, in dem die Ordnungsfunktion <wrong_order()>
+ aufgerufen wird. <ob> kann das Objekt als solches enthalten, oder
+ einen String mit dem Objektnamen. Wird <ob> nicht angegeben, oder
+ enthaelt es weder einen String noch ein Objekt, wird stattdessen
+ this_object() verwendet.
-BEMERKUNGEN:
- (1) sort_array() unterstuetzt keinen extra-Parameter
+ Die Elemente von <arr> werden paarweise an die Ordnungsfunktion
+ <wrong_order()> als Argumente uebergeben, gefolgt von den <extra>
+ Argumenten, falls vorhanden. Die Ordnungsfunktion <wrong_order> sollte
+ eine positve Zahl liefern, wenn die paarweisen Elemente in der
+ falschen Reihenfolge waren, 0 oder eine negative Zahl sonst.
- (2) Achtung, die Elemente in 'arr' werden nicht tief kopiert, sind sie
- also selbst Arrays oder Mappings, so fuehrt eine Aenderung im Rueckgabe-
- Array zur Aenderung im Ursprungsarray:
+BEISPIELE
+ Um folgendes Array in aufsteigender Reihenfolge zu ordnen:
- int *i, *j;
- i=({({1}),({2,3}),({4,5,6})});
- j=sort_array(i, // sortiert der Groesse nach absteigend
- function int ( mixed x, mixed y ) {
- return sizeof(x) < sizeof(y); }
- );
-
- Zu diesem Zeitpunkt ist i == ({ ({1}),({2,3}),({4,5,6}) })
- j == ({ ({4,5,6}),({2,3}),({1}) })
-
- Fuehrt man jetzt die Zuweisung j[0][0]=8; aus
+ arr = ({ 3, 8, 1, 3 })
- resultieren folgende Arrays: i == ({ ({1}),({2,3}),({8,5,6}) })
- j == ({ ({8,5,6}),({2,3}),({1}) })
+ wird als Ordnungsfunktion ist_groesser() verwendet:
-BEISPIELE:
- ### Sortieren von Zahlen in aufsteigender Reihenfolge ###
-
- int *arr = ({ 3, 8, 1, 3 })
+ int ist_groesser(int a, int b) {
+ return a > b;
+ }
- // Folgend identische Resultate, aber andere Ansaetze:
+ Folgende Aufrufe von sort_array() sind alle aequivalent:
- #1: nutzt die 'Efun' > als Lfun-Closure (ideal hier):
- sort_array(arr, #'>);
+ arr = sort_array(arr, "ist_groesser", this_object())
+ arr = sort_array(arr, "ist_groesser")
+ arr = sort_array(arr, #'ist_groesser)
+ arr = sort_array(arr, #'>) //dies ist die bevorzugte Variante :-)
+ arr = sort_array(arr, lambda(({'a, 'b}), ({#'>, 'a, 'b})))
- #2: mit Sortierfunktion im selben Objekt:
- int is_greater (int a, int b) {
- return a > b;
- }
-
- #2a: sortiert mittels der Lfun im selben Objekt die Elemente in das
- Rueckgabearray
- sort_array(arr, "is_greater", this_object())
- sort_array(arr, "is_greater")
+ Soll direkt das Original <arr> statt einer impliziten Kopie sortiert
+ werden:
- #2b: nutzt die Lfun is_greater() als Lfun-Closure (Funktionspointer)
- sort_array(arr, #'is_greater)
+ sort_array(&arr, #'>)
- #3: Nutzt eine Inline-Closure
- sort_array(arr, function int (int a, int b) {
- return a > b; } );
+ Etwas komplizierter ist es, folgendes Array aufsteigend nach dem
+ zweiten Argument jedes Teilarrays zu ordnen:
- Resultat in allen Faellen: ({1,3,3,8})
+ arr = ({ ({ "foo", 3 }), ({ "quux", 1 }), ... })
- ### Sortieren von geschachtelten Arrays ###
+ Dafuer muss die Ordnungsfunktion folgende Form annehmen:
- arr = ({ ({ "foo", 3 }), ({ "quux", 1 }), ... })
+ int ist_groesser(mixed *a, mixed *b) {
+ return a[1] > b[1];
+ }
- // Vorgehen identisch, allerdings muss die Sortierfunktion
- // angepasst werden (siehe auch das Beispiel unter Verwendung von
- // Inline-Closures oben unter "Bemerkungen"):
-
- int is_greater (mixed *a, mixed *b) {
- return a[1] > b[1];
- }
+GESCHICHTE
+ LDMud 3.2.8 fuehrte die Moeglichkeit ein, zusaetzliche Argumente
+ <extra> zu uebergeben.
+ LDMud 3.3.720 unterstuetzt die Uebergabe von <arr> als Referenz und
+ sortiert das Original statt einer impliziten flachen Kopie.
-SIEHE AUCH:
- Arrays: filter(E), map(E)
- Objektarrays: filter_objects(E), map_objects(E)
- Mappings: filter_indices(E), map_indices(E)
-
- Sonstiges: unique_array()
- alist, transpose_array(E)
-
-----------------------------------------------------------------------------
-Last modified: Mon Feb 18 23:09 2008 by Arathorn
+SIEHE AUCH
+ transpose_array(E), filter(E), map(E), alists(LPC)
diff --git a/doc/efun/tell_object b/doc/efun/tell_object
index e2cfd9c..6a78c8d 100644
--- a/doc/efun/tell_object
+++ b/doc/efun/tell_object
@@ -1,47 +1,48 @@
SYNOPSIS
- void tell_object(object|string obj, string str);
- void tell_object(object|string obj, mixed *|mapping|struct|object msg);
+ void tell_object(object|string obj, string str)
+ void tell_object(object|string obj, mixed *|mapping|struct|object msg)
BESCHREIBUNG
Sendet einen Nachricht an das Objekt <obj> (das auch durch seinen
- Objektnamen angegeben werden kann).
+ Namen angegeben werden kann).
Ist die Nachricht ein String, wird der Text an interaktive Objekte
direkt ausgegeben, fuer andere Objekte wird die lfun catch_tell()
- in diesen aufgerufen.
+ aufgerufen.
Ist die Nachricht ein anderer Typ, wird die lfun catch_msg() im
Empfaenger aufgerufen.
-BEMERKUNGEN
- - wird in einem catch_msg() der Wert von <msg> veraendert, erhalten
- alle nachfolgenden Objekte das veraenderte <msg> (Referenz!)
-
BEISPIELE
- // Dies gibt ein einfaches "Hi!" an den Spieler Thomas aus:
+ Dies gibt ein einfaches "Hi!" an den Spieler Thomas aus:
object wer;
wer = find_player("thomas");
tell_object(wer, "Hi!\n");
- // Ein Beispiel mit zwei Objekten, das zeigt, wie das Zusammenspiel
- // von catch_tell() und tell_object() ablaueft. Objekt1 ist ein
- // Lebewesen mit Namen "Dummymonster", Objekt2 verteilt die Meldung:
+ Ein Beispiel mit zwei Objekten, das zeigt, wie das Zusammenspiel von
+ catch_tell() und tell_object() ablaueft. Objekt1 ist ein Lebewesen
+ mit Namen "Dummymonster", Objekt2 verteilt die Meldung:
Objekt1:
- void catch_tell(string str) {
- write("Erhaltener Text: "+str+"\n");
+ void catch_tell(string str)
+ {
+ wirte("Erhaltener Text: "+str+"\n");
}
Objekt2:
- void fun() {
+ void fun()
+ {
object wer;
wer = find_living("dummymonster");
tell_object(wer, "Folge mir, Sterblicher!\n");
...
}
+GESCHICHTE
+ LDMud 3.2.11 fuehrte die Arrayform aus Symmetriegruenden ein.
+ LDMud 3.3.686 erlaubt die Verwendung eines mapping/struct/object als
+ zweites Argument.
+
SIEHE AUCH
- Aehnlich: write(E), shout(E), say(E), tell_room(E), printf(E)
- Verwandt: catch_tell(E), catch_msg(A)
- Sonstiges: object_name(E)
\ No newline at end of file
+ write(E), say(E), catch_tell(A), catch_msg(A)
diff --git a/doc/efun/tell_room b/doc/efun/tell_room
index 77f302c..0f18ab5 100644
--- a/doc/efun/tell_room
+++ b/doc/efun/tell_room
@@ -1,67 +1,36 @@
-FUNKTION:
- void tell_room(string|object obj, string str);
- void tell_room(string|object obj, string str, object *exclude);
+SYNOPSIS
+ void tell_room(string|object obj, string str)
+ void tell_room(string|object obj, string str, object *exclude)
void tell_room(string|object obj, mixed *|mapping|struct|object msg)
- void tell_room(string|object obj, mixed *|mapping|struct|object msg
- , object *exclude);
+ void tell_room(string|object obj, mixed *|mapping|struct|object msg,
+ object *exclude)
-BESCHREIBUNG:
+BESCHREIBUNG
Gibt einen Text <str> an den Raum <obj> aus. <obj> kann auch der
- Objektname des Raumes als String sein.
- Wenn das Raumobjekt mit seinem Namen angegeben ist, sucht der Driver
- das Objekt unter diesem Namen und laedt es, falls notwendig.
+ Name des Raumes als String sein. Wenn das Objekt, das die Meldung
+ erhaelt, nicht ein interaktives Objekt (also kein User) ist, wird
+ im Empfaenger die Funktion catch_tell() mit dem Text als Argument
+ aufgerufen. Falls ein Lebewesen die Funktion catch_tell() definiert,
+ wird der Text hier ausgewertet und nicht an den User ausgegeben.
+ Wenn das Empfaengerobjekt mit seinem Namen angegeben ist, sucht der
+ Driver das Objekt unter diesem Namen und laedt es, falls notwendig.
+ Wenn das Array <*exclude> angegeben ist, wird der Text an die
+ Objekte in <*exclude> nicht ausgegeben.
- Ist die Nachricht ein String, wird der Text an interaktive Objekte
- direkt ausgegeben, fuer andere Objekte wird die lfun catch_tell()
- in diesen aufgerufen.
- Falls ein Lewebesen die Funktion catch_tell() definiert (-> shadow),
- so wird der Text hier ausgewertet und nicht an den User ausgegeben.
+ Wenn das zweite Argument ein nicht-String ist, wird in allen
+ Lebewesen, die den Text erhalten, catch_msg() aufgerufen (statt
+ catch_tell()).
- Wenn das zweite Argument, die Nachricht, kein String ist, wird in
- allen Lebewesen, die den Text erhalten, catch_msg() anstatt
- catch_tell() aufgerufen.
+BEISPIELE
+ An alle Lebewesen im Raum soll ein simples "Hi!" gesendet werden:
- Mit dem Array <*exclude> kann man verhindern, dass die Nachricht an
- die darin enthaltenen Objekte gesendet wird.
- Das ist sinnvoll, wenn zB ein Spieler Ausloeser einer Meldung ist
- und diese selbst nicht erhalten soll.
+ tell_object(environment(this_player()), "Hi!\n");
-BEMERKUNGEN:
- - der Eintrag von mehreren Anwesenden in *exclude ist moeglich
- - wird in einem catch_msg() der Wert von <msg> veraendert, erhalten
- alle nachfolgenden Objekte das veraenderte <msg> (Referenz!)
+ Folgendes Beispiel zeigt, wie tell_room() zusammen mit catch_tell()
+ funktioniert.
- - say("str") ist verhaltensgleich zu
- tell_room(environment(), "str", ({this_player()||this_object()}))
-
-BEISPIELE:
- // Dies ist ein einfaches Beispiel fuer eine Meldung an alle An-
- // wesenden im Raum.
-
- tell_room(this_object(),"Ein leichter Wind kommt auf.\n");
-
- // Diese Meldung wird im Raum /d/ebene/ark/raum.c ausgegeben, dieser
- // Raum muss nicht derjenige sein, in dem das tell_room() ausgefuehrt
- // wird.
-
- tell_room("/d/ebene/ark/raum","Ein leichter Wind kommt auf.\n");
-
-
- // Diese Meldung wird an alle Anwesenden im Raum AUSSER this_player()
- // (der diese Meldung ausgeloest hat) ausgegeben. Der muss eine ge-
- // sonderte Meldung ueber sein Stolpern per write() oder
- // tell_object() bekommen.
- tell_room(this_object(),
- break_string(this_player()->Name()+" stolpert.", 78),
- ({ this_player() }));
- tell_object(this_player(), "Du stolperst.\n");
-
- // Ein Beispiel mit zwei Objekten, das zeigt, wie das Zusammenspiel
- // von catch_tell() und tell_room() ablaueft. Objekt1 ist ein
- // Lebewesen mit Namen "Dummymonster", Objekt2 verteilt die Meldung:
-
- Objekt1 (ein Lebewesen, steht im Env von this_player()):
+ Objekt1 (ein Lebewesen):
void catch_tell(string str) {
write("Empfangen: "+str+"\n");
}
@@ -71,9 +40,9 @@
tell_room(environment(this_player()), "Hallo Welt!\n");
}
-SIEHE AUCH
- Aehnlich: tell_object(E), write(E), shout(E), say(E), printf(E)
- Verwandt: catch_tell(E), catch_msg(A)
- Sonstiges: object_name(E)
+GESCHICHTE
+ LDMud 3.3.686 erlaubt die Verwendung eines mapping/struct/object als
+ zweites Argument.
-7.Aug 2007 Gloinson
+SIEHE AUCH
+ write(E), say(E), tell_object(E), catch_tell(A), catch_msg(A)
diff --git a/doc/efun/walk_mapping b/doc/efun/walk_mapping
index 7396fcf..3dad60c 100644
--- a/doc/efun/walk_mapping
+++ b/doc/efun/walk_mapping
@@ -1,88 +1,24 @@
-walk_mapping(E)
+SYNOPSIS
+ void walk_mapping(mapping map, string fun, mixed extra, ...)
+ void walk_mapping(mapping map, string fun, string|object obj,
+ mixed extra, ...)
+ void walk_mapping(mapping map, closures cl, mixed extra, ...)
-FUNKTION:
- void walk_mapping(mapping m, string fun [, mixed extra, ...])
- void walk_mapping(mapping m, string fun, string|object ob
- , mixed extra,...)
- void walk_mapping(mapping m, closure cl, mixed extra,...)
+BESCHREIBUNG
+ Ruft obj->fun(key, &value1, ... &valueN, extra, ...) fuer jeden Key
+ im Mapping <map> auf bzw. wendet die Closure <cl> auf jeden Key
+ im Mapping <map> an. Dies Keys werden als Wert uebergeben, die Values
+ als Referenz, entsprechend koennen sie in der Funktion veraendert
+ werden.
-PARAMETER:
- m - durchzugehendes Mapping
- fun/cl - zu rufende Methode/Closure
- ob - Objekt/Dateiname, an dem Methode gerufen werden soll
- extra - weitere Parameter fuer Methode/Closure
+ Es kann eine beliebige Anzahl zusaetzlicher Argumente <extra>
+ uebergeben werden.
-BESCHREIBUNG:
- Ruft die Methode fuer jeden Eintrag im Mapping:
- ob->func(key, value1, ..., valueN, extra,...)
- beziehungsweise fuehrt die Closure fuer jeden dieser Eintraege aus:
- funcall(cl, key, value1, ..., valueN, extra,...)
+ Wird <obj> weggelassen oder enthaelt es weder einen String noch ein
+ Objekt, wird standardmaessig this_object() verwendet.
- Die Schluessel werden als Wert uebergeben und die dazugehoerigen Werte
- per Referenz, diese koennen somit also in der Funktion/Closure geaendert
- werden.
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2@61.
-
- Verwendung von Methoden:
- Wenn bei der Angabe von 'fun' kein Objekt 'ob' in Form eines Strings
- oder Objekts angegeben wird, wird this_object() angenommen.
-
- Verwendung von Closures:
- Es koennen sowohl Lfun-Closures als auch Lambda-Closures verwendet
- werden. Lfun-Closures koennen, wenn im selben Objekt vorhanden auch
- 'private' oder/und 'static' deklariert sein, muessen aber zu dem
- Zeitpunkt der Verwendung bekannt sein (Funktionsprototypen benutzen).
-
-BEISPIELE:
- // Liste mit Spielern durchgehen ...
- mapping x=([ [/human:liafar]: 20,
- [/dwarf:mesirii]: 50,
- [/elf:zarniya]: 40,
- [/feline:turbo]: 30]);
-
- // ... und Werte aendern:
- void add_val(object key, int val, int add) {
- if(key->InFight())
- val+=add;
- else
- val-=add;
- }
-
- // verschiedene Aufrufarten, identisches Resultat:
- walk_mapping(x, "add_val", 0, 10);
- walk_mapping(x, "add_val", this_object(), 10
- walk_mapping(x, "add_val", "/players/jof/addierobjektmitmethode", 10);
-
- walk_mapping(x, #'add_val, 10);
-
-
-AeQUIVALENZCODE (nicht empfohlen, nur zum Verstaendnis!):
- // so richtig aequivalent wird es nur mit einer Closure hier
- int i, width;
- mapping input;
- mixed *index, *param;
-
- width=get_type_info(input)[1];
- param=allocate(width);
- index=m_indices(input);
- i=sizeof(index);
- while(i--) {
- j=width;
- while(j-- > 1)
- param[j]=input[index[i],j];
- j[0]=index[i];
-
- apply(cl, param);
- // fun(index[i], input[index[i],0], input[index[i],1], ...);
- }
-
-SIEHE AUCH:
- Arrays: filter(E), map(E)
- Objektarrays: filter_objects(E), map_objects(E)
- Mappings: filter_indices(E), map_indices(E)
-
- Sonstiges: m_contains(E)
- member()
- m_indices(E), m_values(E)
-
-20.Jan 2005 Gloinson
+SIEHE AUCH
+ map(E), filter(E)