@lpc-lang/core 1.1.2-5.1

package/src/efuns/fluffos/misc.h

@@ -0,0 +1,43 @@
+// test_bit.md.h
+
+/**
+ * test_bit
+ * set_bit() - set a bit in a bitstring
+ *
+ * Return 0 or 1 of bit 'n' was set in string 'str'.
+ *
+ */
+int test_bit( string str, int n );
+
+// test_load.md.h
+
+/**
+ * test_load
+ * test_load - test if a file is loadable
+ *
+ * Tests if a file is loadable. Will return 1 if a file is loadable,
+otherwise 0. If a file attempting to be loaded contains errors,
+they will be reported, in which case, you may need to wrap the
+function call in a catch statement to retrieve the 0 result.
+ *
+ */
+int test_load( string filename );
+
+
+/**
+ * set_notify_destruct() - et the object to be notified when it is destructed
+ * @param flag If the flag is set to 1, the object will
+ *  receive a call to the function on_destruct() when it is destructed. If the
+ *  flag is set to 0, the object will not receive this notification.
+ * @details
+ *  Toggles a flag in an object that determines whether or not it will be
+ *  notified when it is destructed. If the flag is set to 1, the object will
+ *  receive a call to the function on_destruct() when it is destructed. If the
+ *  flag is set to 0, the object will not receive this notification.
+ *  Objects do not receive this notification by default. To receive the call to
+ *  on_destruct(), the object must call set_notify_destruct(1) at some point
+ *  during its lifetime.
+ *  The set_notify_destruct() efun may only be called from within the object
+ *  that would like to receive the notification.
+ */
+void set_notify_destruct(int flag);

package/src/efuns/fluffos/mudlib.h

@@ -0,0 +1,228 @@
+// mudlib.h
+
+/**
+ * wizardp()  - determines if a given object had enable_wizard() performed
+in it
+ *
+ * Returns 1 if the arg had enable_wizard() performed on it.
+ *
+ */
+int wizardp( object );
+
+/**
+ * seteuid() - set the effective user id (euid) of an object
+ *
+ * Set effective uid to 'str'.  valid_seteuid() in master.c controls which
+ * values the euid of an object may be set to.
+ * 
+ * When this value is 0, then the current object's uid can be  changed  by
+ * export_uid(), and only then.
+ * 
+ * But,  when  the  value is 0, no objects can be loaded or cloned by this
+ * object.
+ *
+ */
+int seteuid( string str );
+
+/**
+ * set_privs() - set the privs string for an object
+ *
+ * Sets the privs string for 'ob' to 'privs'.
+ * 
+ * This efun is only available if PRIVS is defined at driver compile time.
+ *
+ */
+void set_privs( object ob, string privs );
+
+/**
+ * set_living_name() - set a living name for a living object
+ *
+ * Set  a  living  name  on  an object that is living. After this has been
+ * done, the object can be found with "find_living()".
+ *
+ */
+void set_living_name( string name );
+
+/**
+ * set_light() - update or query an object's light level
+ *
+ * Passing  <light_level_adjustment>  as  0  queries  the object's current
+ * light level.  A positive number will increase the light level, while  a
+ * negative number will decrease the light level.
+ *
+ */
+int set_light( int light_level_adjustment );
+
+/**
+ * set_author - set the author associated with an object.
+ *
+ * Every object has both an author and a domain associated with it for the
+ * purposes of tracking statistics for authors and domains.   Domains  may
+ * only  be  set  in  the  master  object function domain_file(4), however
+ * authors are different.  They can be initialized to some  default  value
+ * by  author_file(4)  in the master object, but can also be changed using
+ * the set_author efun.
+ * 
+ * set_author changes the author of the object that it is  called  within.
+ * That  author will get credit for all future actions of that object that
+ * affect mudlib statistics.  Note that this may cause some weird  numbers
+ * to occur in the categories "objects" and "array_size", since the object
+ * may have initialized arrays or been created under the original author's
+ * credit,  but  it could be destructed or free the arrays that it's using
+ * under another author, thus reducing numbers from a  count  that  didn't
+ * have  those  same  numbers added previously.  To rememdy this, only use
+ * set_author within create(4), and use it before any arrays are allocated
+ * if at all possible.
+ *
+ */
+void set_author( string author );
+
+/**
+ * query_privs() - return the privs string for an object
+ *
+ * Returns the privs string for an object.  The privs string is determined
+ * at compile time via a call to privs_file() in the  master  object,  and
+ * changeable via the set_privs() efun.
+ * 
+ * This efun is only available if PRIVS is defined at driver compile time.
+ *
+ */
+varargs string query_privs( object ob );
+
+/**
+ * livings() - return an array of all living objects
+ *
+ * Returns  an  array of pointers to all living objects (objects that have
+ * had enable_commands() called in them).
+ *
+ */
+object *livings( void );
+
+/**
+ * living() - detects whether or not a given object is "living"
+ *
+ * @returns true if `ob` is a living object (that is, if `enable_commands()` has been called by `ob`).
+ * @param ob - the object to check
+ */
+varargs int living( object ob );
+
+/**
+ * getuid() - return the user id (uid) of an object
+ *
+ * Returns  the  user id of an object.  The uid of an object is determined
+ * at object creation by the creator_file() function.
+ *
+ */
+string getuid( object ob );
+
+/**
+ * geteuid() - return the effective user id of an object or function
+ *
+ * If  given  an  object  argument,  geteuid returns the effective user id
+ * (euid) of the object.  If given an  argument  of  type  'function',  it
+ * returns  the  euid of the object that created that 'function' variable.
+ * If the object, at the time of the function variable's construction, had
+ * no euid, the object's uid is stored instead.
+ *
+ */
+string geteuid( object|function );
+
+/**
+ * find_living() - find a living object matching a given id
+ *
+ * Find  first  the object that is marked as living, and answers to the id
+ * <str>.  A living object is an object that has called enable_commands().
+ * The  object  must  have  set a name with set_living_name(), so its name
+ * will be entered into the hash table used to speed  up  the  search  for
+ * living objects.
+ *
+ */
+object find_living( string str );
+
+/**
+ * export_uid() - set the uid of another object
+ *
+ * Set  the  uid of <ob> to the effective uid of this_object(). It is only
+ * possible when <ob> has an effective uid of 0.
+ *
+ */
+int export_uid( object ob );
+
+/**
+ * enable_wizard() - give wizard priveleges to an object
+ *
+ * 
+ *
+ */
+void enable_wizard( void );
+
+/**
+ * domain_stats() - returns statistics gathered on domains
+ *
+ * Both  domain_stats()  and author_stats() return information stored in a
+ * mapping.  If no argument is specified, then information is returned  on
+ * all  domains  (or  on  all  authors)  with  one map entry per domain or
+ * author.  If an argument is specified, then a map is returned that  cor‐
+ * responds  to  that  domain  or  author  with keys: moves, cost, errors,
+ * heart_beats, worth, array_size, and objects.   Each  of  these  map  to
+ * integer  values.   Moves  is the number of objects that have moved into
+ * objects in the  given  domain.   Cost  is  the  number  of  evaluations
+ * (eval_cost)  accumulated  by objects with the given domain (or author).
+ * Errors is the number of errors  incurred  by  objects  with  the  given
+ * domain.   Heart_beats  is the number of heartbeat calls made on objects
+ * having the  given  domain.   Worth  is  the  value  maintained  by  the
+ * add_worth(3)  efunction (this is usually used to keep track of how much
+ * money a given wizard has given out vs. taken in).   Array_size  is  the
+ * size  (in bytes) of the arrays allocated by the domain.  Objects is the
+ * number of objects created by the given domain.   When  called  with  no
+ * arguments, the returned mapping has a form like this:
+ * 
+ * ([ domain0 : info0, domain1 : info1, ... ])
+ * 
+ * while info0 has the form:
+ * 
+ * ([ "moves" : moves, "cost" : cost, "errors" : errors,
+ * "heart_beats" : heart_beats, "worth" : worth,
+ * "array_size" : array_size, "objects" : objects ])
+ * 
+ * When  called  with an argument, the returned mapping will have the form
+ * of info0.
+ *
+ */
+mapping domain_stats( void|string domain  );
+
+/**
+ * author_stats() - returns statistics gathered on authors
+ *
+ * Both  domain_stats()  and author_stats() return information stored in a
+ * mapping.  If no argument is specified, then information is returned  on
+ * all  domains  (or  on  all  authors)  with  one map entry per domain or
+ * author.  If an argument is specified, then a map is returned that  cor‐
+ * responds  to  that  domain  or  author  with keys: moves, cost, errors,
+ * heart_beats, worth, array_size, and objects.   Each  of  these  map  to
+ * integer  values.   Moves  is the number of objects that have moved into
+ * objects in the  given  domain.   Cost  is  the  number  of  evaluations
+ * (eval_cost)  accumulated  by objects with the given domain (or author).
+ * Errors is the number of errors  incurred  by  objects  with  the  given
+ * domain.   Heart_beats  is the number of heartbeat calls made on objects
+ * having the  given  domain.   Worth  is  the  value  maintained  by  the
+ * add_worth(3)  efunction (this is usually used to keep track of how much
+ * money a given wizard has given out vs. taken in).   Array_size  is  the
+ * size  (in bytes) of the arrays allocated by the domain.  Objects is the
+ * number of objects created by the given domain.   When  called  with  no
+ * arguments, the returned mapping has a form like this:
+ * 
+ * ([ domain0 : info0, domain1 : info1, ... ])
+ * 
+ * while info0 has the form:
+ * 
+ * ([ "moves" : moves, "cost" : cost, "errors" : errors,
+ * "heart_beats" : heart_beats, "worth" : worth,
+ * "array_size" : array_size, "objects" : objects ])
+ * 
+ * When  called  with an argument, the returned mapping will have the form
+ * of info0.
+ *
+ */
+mapping author_stats( void|string domain  );
+

package/src/efuns/fluffos/numbers.h

@@ -0,0 +1,41 @@
+// numbers.h
+
+/**
+ * to_float - convert an int to a float
+ *
+ * The  to_float() call returns the number of type 'float' that is equiva‐
+ * lent to the int 'i'.
+ *
+ */
+float to_float(int i);
+float to_float(string i);
+
+/**
+ * secure_random() - return a pseudo-random number, this should be
+unpredictable, but maybe slightly slow.
+ *
+ * Return a cryptographically secure random number from the range [0 .. (n -1)] (inclusive).
+ * 
+ * On Linux & OSX, this function explicitly use randomness from /dev/urandom,
+ * on windows it is implementation defined.
+ *
+ */
+int secure_random( int n );
+
+/**
+ * random() - return a pseudo-random number, this is suitable for general
+simulation, but may be predictable.
+ *
+ * Return a pseudo-random number from the range [0 .. (n -1)] (inclusive).
+ *
+ */
+int random( int n );
+
+/**
+ * intp() - determine whether or not a given variable is an integer
+ *
+ * Return 1 if 'arg' is an integer number and zero (0) otherwise.
+ *
+ */
+int intp( mixed arg );
+

package/src/efuns/fluffos/objects.h

@@ -0,0 +1,365 @@
+// objects.h
+
+/**
+ * virtualp()  -  determine  whether  a given variable points to a virtual object
+ *
+ * @returns true (1) if the argument is objectp() and the O_VIRTUAL flag is
+ * set.   The driver sets the O_VIRTUAL flag for those objects created via
+ * the 'compile_object' method in master.c.
+ *
+ */
+varargs int virtualp( object arg );
+
+/**
+ * 
+ *
+ * Send  a message 'str' to object all objects in the room 'ob'.  'ob' can
+ * also be the filename of the room (string).  If 'exclude' is  specified,
+ * all objects in the exclude array will not receive the message.
+ *
+ */
+void tell_room( mixed ob, string str, object *exclude );
+
+/**
+ * tell_object() - send a message to an object
+ *
+ * Send  a message 'str' to object 'ob'. If it is an interactive object (a
+ * player), then the message will go to him, otherwise it will go  to  the
+ * local function "catch_tell()".
+ *
+ */
+void tell_object( object ob, string str );
+
+/**
+ * set_hide() - set the hide flag on a hidable object
+ *
+ * Sets  the  hidden  flag  of an object to 'flag', which should be 0 or 1
+ * (hide disable, or hide enable, respectively).  Only objects  for  which
+ * 'master()->valid_hide(ob)'  returns  true  may  make themselves hidden.
+ * When the object is hidden, only other hidable objects will be  able  to
+ * find  the object with find_object(), or multiple-object returning efuns
+ * such as users(), children(), all_inventory(), etc.
+ *
+ */
+void set_hide( int flag );
+
+/**
+ * set_heart_beat() - enable or disable an object's heartbeat
+ *
+ * Passing 'flag' as 0 disables the object's heart beat.  Passing a 'flag'
+ * of 1 will cause heart_beat() to be called in the object once each heart
+ * beat  (a variable number defined by your local administrator, usually 2
+ * seconds).  Passing a 'flag' of greater than 1 will usually set the num‐
+ * ber  of heart beats inbetween calls to heart_beat(), however your local
+ * administrator may have the system configured to treat any 'flag'  above
+ * 1 as 1.
+ *
+ */
+int set_heart_beat( int flag );
+
+/**
+ * save_object() - save the values of variables in an object into a file
+ *
+ * Save  all  values  of  non-static  variables in this object in the file
+ * 'name'.  valid_write() in the master object determines whether this  is
+ * allowed.   The  optional  second argument is a bitfield: If bit 0 is 1,
+ * then variables that  are  zero  (0)  are  also  saved  (normally,  they
+ * aren't).   Object  variables always save as 0.  If bit 1 is 1, then the
+ * save file will be compressed.
+ *
+ */
+varargs int save_object( string name, int flag );
+
+/**
+ * restore_object()  -  restore  values  of  variables from a file into an
+object
+ *
+ * Restore values of variables for current object from file 'name'. If the
+ * optional second argument is 1, then all of the non-static variables are
+ * not zeroed out prior to restore (normally, they are).
+ * 
+ * In the case of an error, the affected variable will be  left  untouched
+ * and an error given.
+ *
+ */
+varargs int restore_object( string name, int flag );
+
+/**
+ * reload_object() - return an object to its just-loaded state
+ *
+ * When reload_object() is called on 'ob', all the driver-maintained prop‐
+ * erties are re-initialized (heart_beat, call_outs, light, shadows, etc),
+ * all  variables  are  re-initialized,  and create() is called.  It has a
+ * similar effect to destructing/reloading the object,  however,  no  disk
+ * access or parsing is performed.
+ *
+ */
+void reload_object( object ob );
+
+/**
+ * query_heart_beat() - query the status of an object's heartbeat
+ *
+ * Returns  the  value with which set_heart_beat() has been called with on
+ * 'object'.  If object is not given, it defaults to the  current  object.
+ * If the object has no heart beat, 0 will be returned.
+ * 
+ * If no object is supplied, this efun will default to this_object().
+ *
+ */
+varargs int query_heart_beat( object );
+
+/**
+ * present() - find an object by id
+ *
+ * if first argument is string, second argument is missing, searches for
+ * a object in the object's environment using the id() apply where it answers 1
+ * to indicate a match.
+ * 
+ * if  first  argument is string, second argument is object, only searches
+ * for target in that object's inventory using the same strategy as above.
+ * 
+ * "foo 1" means the first "foo" in  the  inventory.   the  first  in  the
+ * inventory is the last object that moved in.
+ * 
+ * if  first  argument  is  object, second argument is missing, check if
+ * object is in this object's inventory, or as a sibling in this  object's
+ * environment's inventory, returns object's parent.
+ * 
+ * if first argument is  object,  second  argument  is  object,  check  if
+ * object1 is in object2 inventory, return object1 if true.
+ * 
+ * If  object  is  hidden (via set_hide()), and current object is not hid‐
+ * able.  returns 0
+ *
+ */
+varargs object present( mixed str, object ob );
+
+/**
+ * objects - return an array of all loaded objects
+ *
+ * An array of every object loaded on the mud is  returned  by  objects().
+ * Note  that if the system's maximum array size is set too low, objects()
+ * will truncate its array, in which case it might not be too useful.
+ * 
+ * If the optional 'func' parameter is given, then func() in this_object()
+ * is  called  with  each  loaded  object as an argument.  If the function
+ * returns nonzero, then that object is returned by  objects(),  otherwise
+ * it isn't.
+ * 
+ * If  'f'  is  given, it will be called on all the objects as above.  For
+ * example, objects( (: clonep :) ) returns a list of all  the  clones  in
+ * existence.
+ *
+ */
+object *objects( void | string | function func );
+
+/**
+ * objectp() - determine whether or not a given variable is an object
+ *
+ * @returns {arg is object} 1 if 'arg' is an object.
+ *
+ */
+int objectp( mixed arg );
+
+/**
+ * next_inventory() - return the next object in the same inventory
+ *
+ * Return the next object in the same inventory as 'ob'.
+ * 
+ * Warning:   If  the  object  'ob'  is  moved  by  "move_object()",  then
+ * "next_inventory()" will return an object from the new inventory.
+ *
+ */
+object next_inventory( object ob );
+
+/**
+ * new() - load a new copy of an object/class
+ *
+ * Clones a new object from `filename`, and give it a new unique name. Returns
+ * the new object. Optionally, additional arguments may be passed to new()
+ * which will be passed to the 'create()' apply in the new object.
+ * 
+ * If the first argument is a class, then a new copy of the class is created
+ * and returned. Optionally, additional parameters may be passed to new()
+ * which will be used to initialize values in the returned class. If you are
+ * passing arguments to the class, you must specify the member name and the
+ * value of the members you would like to initialize.
+ * 
+ * ### Object example:
+ * ```lpc
+ * object ob = new("/obj/torch") ; // clone a torch object
+ * object money = new("/obj/money", 10, "dollars" ) ; // clone a money object and set initial values
+ * ```
+ *
+ * ### Class example:
+ * ```lpc
+ * class ClassPerson {
+ * string name ;
+ * int age ;
+ * }
+ * 
+ * class ClassPerson person = new(class ClassPerson) ;
+ * person.name = "Bob" ;
+ * person.age = 42 ;
+ * // or
+ * class ClassPerson person = new(class ClassPerson, name: "Bob", age: 42) ;
+ * ```
+ */
+varargs object new(string filename, mixed args...);
+varargs class ClassName new(class ClassName, mixed args... ) ;
+
+/**
+ * move_object() - move current object to another environment
+ *
+ * Move the current object into the object `dest'.  dest should either be
+ * a filename or an object.
+ *
+ */
+void move_object( mixed dest );
+
+/**
+ * master() - returns the master object
+ *
+ * Returns a pointer to the master object.
+ * @returns {__LPC_CONFIG_LIBFILES_MASTER}
+ */
+object master( void );
+
+/**
+ * load_object() - find or load an object by file name
+ *
+ * Find  the  object with the file name 'str'.  If the file exists and the
+ * object hasn't been loaded yet, it is loaded and returned (if possible).
+ *
+ */
+object load_object( string str );
+
+/**
+ * first_inventory() - return the first item in an object's inventory
+ *
+ * Return  the first object in the inventory of <ob>, where <ob> is either
+ * an object or the file name of an object.
+ * 
+ * If no object is supplied, this efun will default to this_object().
+ *
+ */
+object first_inventory( mixed ob );
+
+/**
+ * find_object() - find an object by file name
+ *
+ * Find the object with the file name 'str',  which can reference a cloned
+ * object by using the file name format returned by file_name().
+ * 
+ * If 'flag' is 1, find_object() will behave like load_object().
+ *
+ */
+object find_object( string str, void | int flag );
+
+/**
+ * file_name() - get the file name of an object
+ *
+ * file_name()  returns  the  name of the file from which <ob> was loaded.
+ * If the object is a cloned object,  then  file_name()  will  not  be  an
+ * actual  file  on  disk, but will be the name of the file from which the
+ * object was originally cloned, appended with an octothorpe (#)  and  the
+ * object  instance  number.   Object instance numbers start at 0 when the
+ * game is booted, and increase by one for each object cloned,  hence  the
+ * number   is   unique   for   each  cloned  object.   <ob>  defaults  to
+ * this_object() if not specified.
+ *
+ */
+varargs string file_name( object ob );
+
+/**
+ * environment() - return the environment of an object
+ *
+ * Return  the  containing object (environment) of <ob>. If no argument is
+ * given, <ob> defaults to this_object().
+ *
+ */
+varargs object environment( object ob );
+
+/**
+ * destruct() - remove an object from the games
+ *
+ * Completely   destroy   and  remove  object  'ob'.  After  the  call  to
+ * destruct(), no global variables will exist any longer, only locals, and
+ * arguments.   If  'ob' is this_object(), execution will continue, but it
+ * is best to return a value immediately.
+ * 
+ * If no object is supplied, this efun will default to this_object().
+ *
+ */
+varargs void destruct( object ob );
+
+/**
+ * deep_inventory() - return the nested inventory of an object
+ *
+ * Returns  an array of the objects contained in the inventory of <ob> and
+ * all the objects contained in the inventories of those  objects  and  so
+ * on.
+ * 
+ * If no object is supplied, this efun will default to this_object().
+ *
+ */
+varargs object *deep_inventory( object ob );
+
+/**
+ * clonep() - determine whether or not a given variable points to a cloned
+object
+ *
+ * Returns true (1) iff the argument is objectp() and the O_CLONE flag  is
+ * set.   The  driver  sets the O_CLONE flag for those objects created via
+ * new(3) (clone_object(3)).  The clonep() efun will not return true  when
+ * called  on  objects that are the master copy (those that are loaded via
+ * call_other(3)).  Note that if clonep() returns true,  then  file_name()
+ * will   return   a  string  containing  a  '#'.   clonep()  defaults  to
+ * this_object().
+ *
+ */
+int clonep( void | mixed arg );
+
+/**
+ * clone_object() - load a copy of an object
+ *
+ * Load  a  new  object  from  definition <name>, and give it a new unique
+ * name.  Returns the new object.  An object with a nonzero  environment()
+ * cannot be cloned.  Optionally, additional arguments may be passed to
+ * clone_object() which will be passed to 'create()' in the new object.
+ *
+ * object ob = clone_object("/obj/torch") ; // clone a torch object
+ * object money = clone_object("/obj/money", 10, "dollars" ) ; // clone a money object and set initial values
+ *
+ */
+object clone_object( string name, mixed args... );
+
+/**
+ * children() - returns an array of objects cloned from a given object.
+ *
+ * This  efunction  returns an array of objects that have been cloned from
+ * the file named by 'name', as well  as  the  object  'name'  itself,  if
+ * loaded.   An example use of children() is to find all objects that have
+ * been cloned from the user object:
+ * 
+ * ```
+ * object *list;
+ * 
+ * list = children("/obj/user");
+ * ```
+ * This lets you find all users  (both  netdead  and  interactive  whereas
+ * users() only reports interactive users).
+ *
+ */
+object *children( string name );
+
+/**
+ * all_inventory() - return the inventory of an object
+ *
+ * Returns an array of the objects contained in the inventory of <ob>.
+ * 
+ * If ob is not passed, this parameter defaults to this_object().
+ *
+ */
+varargs object *all_inventory( object ob );
+