Your browser must have JavaScript enabled in order to view this page.
> >
 
Welcome Guest#215 Login/register    Go to Bottom


INSTALL | LICENSE | README | CHANGES | Class Tree | Index
Go to Top

Source for file DpObject.php

Documentation is available at DpObject.php

  1. <?php
  2. /**
  3.  * The standard object which is built upon by all other objects
  4.  *
  5.  * DutchPIPE version 0.4; PHP version 5
  6.  *
  7.  * LICENSE: This source file is subject to version 1.0 of the DutchPIPE license.
  8.  * If you did not receive a copy of the DutchPIPE license, you can obtain one at
  9.  * http://dutchpipe.org/license/1_0.txt or by sending a note to
  10.  * license@dutchpipe.org, in which case you will be mailed a copy immediately.
  11.  *
  12.  * @package    DutchPIPE
  13.  * @subpackage dpuniverse_std
  14.  * @author     Lennert Stock <ls@dutchpipe.org>
  15.  * @copyright  2006, 2007 Lennert Stock
  16.  * @license    http://dutchpipe.org/license/1_0.txt  DutchPIPE License
  17.  * @version    Subversion: $Id: DpObject.php 311 2007-09-03 12:48:09Z ls $
  18.  * @link       http://dutchpipe.org/manual/package/DutchPIPE
  19.  */
  20.  
  21. /**
  22.  * The DutchPIPE property and coinherit system which all objects extend on
  23.  */
  24. inherit(DPUNIVERSE_STD_PATH . 'DpProperties.php');
  25.  
  26. /**
  27.  * Gets moving constants
  28.  */
  29. inherit(DPUNIVERSE_INCLUDE_PATH . 'move.php');
  30.  
  31. /**
  32.  * Gets events constants
  33.  */
  34. inherit(DPUNIVERSE_INCLUDE_PATH . 'events.php');
  35.  
  36. /**
  37.  * Gets action constants
  38.  */
  39. inherit(DPUNIVERSE_INCLUDE_PATH . 'actions.php');
  40.  
  41. /**
  42.  * Gets title type constants
  43.  */
  44. inherit(DPUNIVERSE_INCLUDE_PATH . 'title_types.php');
  45.  
  46. /**
  47.  * Gets mass constants
  48.  */
  49. inherit(DPUNIVERSE_INCLUDE_PATH . 'mass.php');
  50.  
  51. /**
  52.  * The standard object which is built upon by all other objects
  53.  *
  54.  * Creates the following DutchPIPE properties:<br />
  55.  *
  56.  * - string <b>uniqueId</b> - Unique Id for this instance, for example
  57.  *   'object_436'
  58.  * - integer <b>resetTime</b> - UNIX timestamp of next reset
  59.  * - string <b>location</b> - Location in dpuniverse, for example
  60.  *   '/page/manual.php'
  61.  * - string <b>sublocation</b> - Optional sublocation, for example
  62.  *   'introduction'
  63.  * - int|float <b>credits</b> - Credits contained, integer or float depending
  64.  *   on type, initially 0
  65.  * - string <b>template</b> - Optional replacement for dpdefault.tpl,
  66.  *   absolute path on server
  67.  * - string <b>title</b> - Title for this object, "beer", used for object
  68.  *   labels, etc.
  69.  * - string <b>titleDefinite</b> - Definite title for this object, "the beer"
  70.  * - string <b>titleIndefinite</b> - Indefinite title for this object, "a beer"
  71.  * - string <b>titleType</b> - Type of this object's title
  72.  * - string <b>titleImg</b> - URL for the avatar or other image representing
  73.  *   this object
  74.  * - int <b>titleImgWidth</b> - Width of the title image in pixels, you can
  75.  *   optionally set this by hand for extra speed but it is not mandatory
  76.  * - int <b>titleImgHeight</b> - Height of the title image in pixels, you can
  77.  *   optionally set this by hand for extra speed but it is not mandatory
  78.  * - boolean <b>isDraggable</b> - Can we be dragged on the screen by a given
  79.  *   user? Experimental
  80.  * - string <b>body</b> - HTML content of this object
  81.  * - integer <b>creationTime</b> - UNIX timestamp when this object instance was
  82.  *   created
  83.  * - integer <b>lastEventTime</b> - UNIX timestamp of last event, used by
  84.  *   cleanup mechanism
  85.  * - string <b>navigationTrailHtml</b> - HTML with a navigation trail for this
  86.  *   page
  87.  * - int|float <b>value</b> - Monetary value, integer or float depending on
  88.  *   type, initially 0
  89.  * - boolean <b>isRemoved</b> - TRUE if removed from universe but not destructed
  90.  *   yet by PHP
  91.  * - integer <b>lastActionTime</b> - UNIX timestamp of last action performed by
  92.  *   this object
  93.  *
  94.  * @package    DutchPIPE
  95.  * @subpackage dpuniverse_std
  96.  * @author     Lennert Stock <ls@dutchpipe.org>
  97.  * @copyright  2006, 2007 Lennert Stock
  98.  * @license    http://dutchpipe.org/license/1_0.txt  DutchPIPE License
  99.  * @version    Release: 0.2.1
  100.  * @link       http://dutchpipe.org/manual/package/DutchPIPE
  101.  */
  102. class DpObject extends DpProperties
  103. {
  104.     /**
  105.      * Public ids for this object, 'beer', 'cool beer'
  106.      *
  107.      * @var        array 
  108.      * @access     private
  109.      */
  110.     private $mIds = array();
  111.  
  112.     /**
  113.      * Actions defined by this object, see addAction
  114.      *
  115.      * @var        array 
  116.      * @access     private
  117.      */
  118.     private $mActions = array();
  119.  
  120.     /**
  121.      * Aliases used for actions, for example 'exa' for 'examine'
  122.      *
  123.      * @var        array 
  124.      * @access     private
  125.      */
  126.     private $mActionAliases = array();
  127.  
  128.     /**
  129.      * Image map areas, enables actions to be defined on areas of images
  130.      *
  131.      * @var        array 
  132.      * @access     private
  133.      */
  134.     private $mMapAreas = array();
  135.  
  136.     /**
  137.      * Clickable actions on definable areas of images
  138.      *
  139.      * @var        array 
  140.      * @access     private
  141.      */
  142.     private $mMapAreaActions = array();
  143.  
  144.     /**
  145.      * 'Items' on this object which can be examined
  146.      *
  147.      * @var        array 
  148.      * @access     private
  149.      */
  150.     private $mItems = array();
  151.  
  152.     /**
  153.      * Aliases used for items
  154.      *
  155.      * @var        array 
  156.      * @access     private
  157.      */
  158.     private $mItemAliases = array();
  159.  
  160.     /**
  161.      * Objects to be checked for presence in our inventory during reset
  162.      *
  163.      * @var        array 
  164.      * @access     private
  165.      */
  166.     private $mCheckPresentObjects = array();
  167.  
  168.     /**
  169.      * Array of strings with method names which the DutchPIPE client may call
  170.      *
  171.      * @var        array 
  172.      * @access     private
  173.      * @see        addValidClientCall, removeValidClientCall, isValidClientCall
  174.      * @since      DutchPIPE 0.4.0
  175.      */
  176.     private $mValidClientCalls = array();
  177.  
  178.     /**
  179.      * Creates this object
  180.      *
  181.      * Called by the universe object when the object is created.
  182.      * Calls {@link createDpObject()} in the inheriting class.
  183.      *
  184.      * :WARNING: Use get_current_dpuniverse()->newDpObject only to create
  185.      * objects, do not use 'new'.
  186.      *
  187.      * :WARNING: It is unlikely you need to call this function directly
  188.      *
  189.      * @access     private
  190.      * @param      string    $unique_id   A unique id for this object
  191.      * @param      int       $reset_time  The UNIX reet time for this object
  192.      * @param      string    $location    Location, e.g. /page/cms.php
  193.      * @param      string    $sublocation Sublocation, e.g. 96
  194.      * @see        __construct2, createDpObject
  195.      */
  196.     final function __construct($unique_id, $reset_time, $location,
  197.             $sublocation = FALSE)
  198.     {
  199.         /* This method may only be called once, at creation time */
  200.         if (isset($this->creationTime)) {
  201.             return;
  202.         }
  203.  
  204.         /*
  205.          * Sets a unique internal id for this object
  206.          *
  207.          * This method is called by __construct with a string such as
  208.          * 'object_628' to set a unique id. This id is used in HTML output as
  209.          * the id of the DIV element spanning this object's HTML appearance, by
  210.          * the AJAX engine to operate on the object, et cetera.
  211.          *
  212.          * WARNING: Don't call this method. Only __construct should call it.
  213.          */
  214.         $this->uniqueId = new_dp_property('object_' . $unique_id);
  215.  
  216.         $this->resetTime = new_dp_property($reset_time);
  217.         $this->location = new_dp_property($location);
  218.  
  219.         if (FALSE !== $sublocation) {
  220.             $this->sublocation = new_dp_property($sublocation);
  221.         }
  222.  
  223.         /* Standard setup calls to set some default values */
  224.  
  225.         $this->credits = new_dp_property(0);
  226.  
  227.         /*
  228.          * Path to non-default XHTML template file for this object, if any
  229.          */
  230.         $this->template = new_dp_property(NULL);
  231.  
  232.         $this->addId(dp_text('object'));
  233.  
  234.         /*
  235.          * Title, 'Cool, fresh beer'
  236.          */
  237.         $this->title = new_dp_property(NULL);
  238.  
  239.         /*
  240.          * Definite title, 'The cool, fresh beer'
  241.          */
  242.         $this->titleDefinite = new_dp_property(NULL);
  243.  
  244.         /*
  245.          * Indefinite title, 'A cool, fresh beer'
  246.          */
  247.         $this->titleIndefinite = new_dp_property(NULL);
  248.  
  249.         /*
  250.          * Type of title, 'A beer', 'The beer', etc.
  251.          */
  252.         $this->titleType = new_dp_property(DPUNIVERSE_TITLE_TYPE_INDEFINITE);
  253.  
  254.         /*
  255.          * Path to the avatar or object image
  256.          */
  257.         $this->titleImg = new_dp_property(DPUNIVERSE_IMAGE_URL . 'object.gif');
  258.         $this->titleImgWidth = new_dp_property(NULL);
  259.         $this->titleImgHeight = new_dp_property(NULL);
  260.  
  261.         $this->isDraggable = new_dp_property(TRUE);
  262.  
  263.         /*
  264.          * The long description or page content
  265.          */
  266.         $this->body = new_dp_property(
  267.             dp_text('You see nothing special.<br />'));
  268.  
  269.         $this->creationTime = new_dp_property(time(), FALSE);
  270.         $this->lastEventTime = new_dp_property(time());
  271.  
  272.         $this->navigationTrailHtml = new_dp_property(NULL, FALSE);
  273.         $this->value = new_dp_property(0);
  274.  
  275.         $this->addValidClientCall('getActionsMenu');
  276.         $this->addValidClientCall('reportMove');
  277.     }
  278.  
  279.     /**
  280.      * Creates this object, continued
  281.      *
  282.      * Called by the universe object when the object is created.
  283.      * Calls {@link createDpObject()} in the inheriting class.
  284.      *
  285.      * :WARNING: It is unlikely you need to call this function directly
  286.      *
  287.      * @access     private
  288.      * @see        __construct, createDpObject
  289.      */
  290.     final function __construct2()
  291.     {
  292.         /* Call CreateDpObjects for objects that extend on this object */
  293.         $this->createDpObject();
  294.  
  295.         if (!isset($this->title)) {
  296.             $this->title = dp_text('initialized object');
  297.             $this->titleDefinite = dp_text('the initialized object');
  298.             $this->titleIndefinite = dp_text('an initialized object');
  299.         }
  300.  
  301.         $this->resetDpObject();
  302.     }
  303.  
  304.     /**
  305.      * Sets this object up at the time it is created
  306.      *
  307.      * An empty function which can be redefined by the class extending on
  308.      * DpObject. When the object is created, it has no title, HTML body, etc.,
  309.      * so here methods such as $this->setTitle() are called.
  310.      * Building blocks extending on DpObject may define their own create
  311.      * function. For example, DpPage defines createDpPage.
  312.      *
  313.      * @see        resetDpObject
  314.      */
  315.     function createDpObject()
  316.     {
  317.     }
  318.  
  319.     /**
  320.      * Resets this object
  321.      *
  322.      * Called by the universe object at regular intervals as defined in
  323.      * {@link dpuniverse-ini.php}. Calls the method 'resetDpObject' in this
  324.      * object. You can redefine that function to periodically do stuff such as
  325.      * alter the state of this object.
  326.      *
  327.      * @access     private
  328.      * @see        resetDpObject
  329.      */
  330.     final function __reset()
  331.     {
  332.         $this->resetDpObject();
  333.     }
  334.  
  335.     /**
  336.      * Resets this object
  337.      *
  338.      * Called by this object at regular intervals as defined in
  339.      * dpuniverse-ini.php. An empty function which can be redefined by the
  340.      * class extending on DpObject. To be used to periodically do stuff such as
  341.      * alter the state of this object.
  342.      *
  343.      * @see        createDpObject
  344.      */
  345.     function resetDpObject()
  346.     {
  347.     }
  348.  
  349.     /**
  350.      * Called by PHP when this object is destroyed, handles events
  351.      *
  352.      * Called by PHP when this object is destroyed. removeDpObject should be
  353.      * called in this object to remove it from the universe. Don't use
  354.      * unset to remove objects. On a PHP level, __destruct will then be called
  355.      * in this object.
  356.      *
  357.      * Calls the event method in this object and its environment, if any, when
  358.      * defined, using constants from events.php.
  359.      *
  360.      * Triggers the EVENT_LEFT_INV event in the environment of this object with
  361.      * "from" ($this) and "to" (0) parameters:
  362.      * $environment->event(EVENT_LEFT_INV, $this, 0);
  363.      *
  364.      * Triggers the EVENT_CHANGED_ENV event in this object with "from" (the
  365.      * environment) and "to" (0) parameters:
  366.      * $this->event(EVENT_CHANGED_ENV, $environment, 0);
  367.      *
  368.      * If the object had no environment, the above two events are not called,
  369.      * instead the EVENT_CHANGED_ENV event is triggered in this object with only
  370.      * a "from" (0) parameter:
  371.      * $this->event(EVENT_CHANGED_ENV, 0);
  372.      *
  373.      * Last, the EVENT_DESTROYING_OBJ event is triggered in this object:
  374.      * $this->event(EVENT_DESTROYING_OBJ);
  375.      *
  376.      * @see        removeDpObject, events.php
  377.      */
  378.     function __destruct()
  379.     {
  380.         if (!isset($this->isRemoved) || TRUE !== $this->isRemoved) {
  381.             $this->removeDpObject();
  382.         }
  383.  
  384.         echo sprintf(dp_text("__destruct() called in object %s (%s).\n"),
  385.             $this->uniqueId,
  386.             $this->getTitle(DPUNIVERSE_TITLE_TYPE_INDEFINITE));
  387.     }
  388.  
  389.     /**
  390.      * Removes this object from the universe
  391.      *
  392.      * The object is destroyed and no longer part of the universe. Don't use
  393.      * unset to remove objects. Removes the object from browsers viewing the
  394.      * same environment. On a PHP level, __destruct will then be called in this
  395.      * object.
  396.      *
  397.      * @see        __destruct
  398.      */
  399.     function removeDpObject()
  400.     {
  401.         echo dp_text("removeDpObject() called in object " . $this->title
  402.             . ".\n");
  403.  
  404.         foreach ($this->mCheckPresentObjects as $key => &$ob) {
  405.             unset($this->mCheckPresentObjects[$key]);
  406.         }
  407.  
  408.         $this->mCheckPresentObjects = array();
  409.         $this->mActions = array();
  410.         $this->mActionAliases = array();
  411.  
  412.         $env = $this;
  413.         while (FALSE !== $env->getEnvironment()) {
  414.             $env = $env->getEnvironment();
  415.         }
  416.         $env->tell('<removeDpElement id="' . $this->uniqueId
  417.             . '">&#160;</removeDpElement>');
  418.  
  419.         $this->isRemoved = new_dp_property(TRUE);
  420.  
  421.         if (FALSE !== ($env = $this->getEnvironment())) {
  422.             $env->event(EVENT_LEFT_INV, $this, 0);
  423.             $this->event(EVENT_CHANGED_ENV, $env, 0);
  424.         }
  425.         else {
  426.             $this->event(EVENT_CHANGED_ENV, 0);
  427.         }
  428.  
  429.         $this->event(EVENT_DESTROYING_OBJ);
  430.  
  431.         /* :TODO: Move all users somewhere so they don't get destroyed */
  432.         $inv = $this->getInventory();
  433.  
  434.         foreach ($inv as &$ob) {
  435.             if ($ob->isUser) {
  436.                 $ob->moveDpObject(DPUNIVERSE_PAGE_PATH . 'index.php');
  437.             } else {
  438.                 $ob->removeDpobject();
  439.             }
  440.         }
  441.         get_current_dpuniverse()->removeDpObject($this);
  442.         DpProperties::removeDpProperties();
  443.         unset($this);
  444.     }
  445.  
  446.     /**
  447.      * Moves this object into the inventory of another object
  448.      *
  449.      * @param   mixed   &$target_ob path or object to move into to
  450.      * @param   boolean $simple     skip some checks
  451.      * @return  int     TRUE for success, an error code for failure
  452.      */
  453.     function moveDpObject(&$target_ob, $simple = FALSE)
  454.     {
  455.         /* Retrieve the target object, or fail */
  456.         if ((!is_string($target_ob) && !is_object($target_ob))
  457.                 || (is_string($target_ob)
  458.                 && !($target_ob =
  459.                     get_current_dpuniverse()->getDpObject($target_ob)))) {
  460.             return E_MOVEOBJECT_BADDEST;
  461.         }
  462.         if (isset($this->isLiving) && TRUE === $this->isLiving) {
  463.             $this->lastActionTime = !isset($this->lastActionTime)
  464.                 ? new_dp_property(time()) : time();
  465.         }
  466.  
  467.         $curr_env = $this->getEnvironment();
  468.  
  469.         /* Do more checking? */
  470.         if (FALSE === $simple) {
  471.             /* Checks if the living carrying this object may not drop it: */
  472.             if (FALSE !== $curr_env && $curr_env->isLiving
  473.                     && (bool)$curr_env->noDrop) {
  474.                 return E_MOVEOBJECT_NODROP;
  475.             }
  476.  
  477.             /* Checks if target is neither a page nor a living */
  478.             if (FALSE !== $target_ob->getEnvironment() &&
  479.                     FALSE === $target_ob->isLiving) {
  480.                 /*
  481.                  * Checks if the object may be inserted into containers, for
  482.                  * instance, drinks could disallow this, to prevent 'spilling':
  483.                  */
  484.                 if (method_exists($this, 'preventInsert')
  485.                         && (bool)$this->preventInsert()) {
  486.                     return E_MOVEOBJECT_NOSRCINS;
  487.                 }
  488.  
  489.                 /* Checks if the target is a container, or fail */
  490.                 if (FALSE === ((bool)$target_ob->isContainer)) {
  491.                     return E_MOVEOBJECT_NODSTINS;
  492.                 }
  493.             }
  494.  
  495.             /* Checks if the object may be taken by livings */
  496.             if ($target_ob->isLiving && (bool)$this->noTake) {
  497.                 return E_MOVEOBJECT_NOGET;
  498.             }
  499.  
  500.             if (WEIGHT_TYPE_NONE !== WEIGHT_TYPE) {
  501.                 if (isset($this->weight) && isset($target_ob->maxWeightCarry)
  502.                         && $this->weight > 0
  503.                         && $target_ob->weightCarry + $this->weight >
  504.                         $target_ob->maxWeightCarry) {
  505.                     return E_MOVEOBJECT_HEAVY;
  506.                 }
  507.             }
  508.             if (VOLUME_TYPE_NONE !== VOLUME_TYPE) {
  509.                 if (isset($this->volume) && isset($target_ob->maxVolumeCarry)
  510.                         && $this->volume > 0
  511.                         && $target_ob->volumeCarry + $this->volume >
  512.                         $target_ob->maxVolumeCarry) {
  513.                     return E_MOVEOBJECT_VOLUME;
  514.                 }
  515.             }
  516.         }
  517.  
  518.         /*
  519.          * If we're moving to a new environment, check for user defined
  520.          * functions to prevent movement
  521.          */
  522.         if ($curr_env !== $target_ob) {
  523.             if (method_exists($this, 'preventMove') && ($move_err =
  524.                     $this->preventMove($curr_env, $target_ob))) {
  525.                 return $move_err;
  526.             }
  527.             if (!is_null($curr_env)) {
  528.                 if (method_exists($this, 'preventLeave') && ($move_err =
  529.                         (int)$curr_env->preventLeave($this, $target_ob))) {
  530.                     return $move_err;
  531.                 }
  532.             }
  533.             if (method_exists($this, 'preventEnter') && ($move_err =
  534.                     (int)$target_ob->preventEnter($this, $curr_env))) {
  535.                 return $move_err;
  536.             }
  537.         }
  538.  
  539.         /* Move the object */
  540.         get_current_dpuniverse()->moveDpObject($this, $target_ob);
  541.  
  542.         /* Post-movement stuff */
  543.         if ($curr_env !== $target_ob) {
  544.             $this->event(EVENT_CHANGED_ENV, $curr_env, $target_ob);
  545.             if ($this->isRemoved) {
  546.                 return E_MOVEOBJECT_REMOVED;
  547.             }
  548.             if (FALSE !== ($curr_env)) {
  549.                 $old_page = $curr_env;
  550.                 while (FALSE !== $old_page->getEnvironment()) {
  551.                     $old_page = $old_page->getEnvironment();
  552.                 }
  553.                 $curr_env->event(EVENT_LEFT_INV, $this, $target_ob);
  554.             }
  555.             $new_page = $target_ob;
  556.             while (FALSE !== $new_page->getEnvironment()) {
  557.                 $new_page = $new_page->getEnvironment();
  558.             }
  559.  
  560.             $abstract_class = FALSE === $target_ob->getEnvironment()
  561.                 ? 'dpobject' : 'dpobject2';
  562.  
  563.             if (isset($old_page) && $old_page === $new_page) {
  564.                 $new_page->tell(array(
  565.                     'abstract' => '<moveDpElement id="'
  566.                         . $this->uniqueId
  567.                         . '" where="' . $target_ob->uniqueId
  568.                         . '" class="' . $abstract_class
  569.                         . '">&#160;</moveDpElement>'));
  570.                 if ($target_ob === $new_page) {
  571.                     $new_page->tell(array(
  572.                         'graphical' => '<addDpElement id="'
  573.                             . $this->uniqueId . '" where="'
  574.                             . $target_ob->uniqueId
  575.                             . '" class="title_img draggable" '
  576.                             . 'css="width: '
  577.                             . (DPSERVER_OBJECT_IMAGE_MAX_WIDTH + 5)
  578.                             . 'px; height: '
  579.                             . (DPSERVER_OBJECT_IMAGE_MAX_HEIGHT + 26) . 'px">'
  580.                             . $this->getAppearance(1, FALSE, $new_page,
  581.                             'graphical') . '</addDpElement>'));
  582.                 } else {
  583.                     $new_page->tell(array(
  584.                         'graphical' => '<removeDpElement id="'
  585.                         . $this->uniqueId
  586.                         . '">&#160;</removeDpElement>'));
  587.                 }
  588.             }
  589.             else {
  590.                 if (isset($old_page)) {
  591.                     $old_page->tell('<removeDpElement id="'
  592.                         . $this->uniqueId
  593.                         . '">&#160;</removeDpElement>');
  594.                 }
  595.                 if ($target_ob === $new_page) {
  596.                     $new_page->tell(array('abstract' => '<addDpElement id="'
  597.                         . $this->uniqueId . '" where="'
  598.                         . $target_ob->uniqueId . '" class="'
  599.                         . $abstract_class . '">' . $this->getAppearance(1,
  600.                         FALSE, $new_page, 'abstract') . '</addDpElement>',
  601.                         'graphical' => '<addDpElement id="'
  602.                         . $this->uniqueId . '" where="'
  603.                         . $target_ob->uniqueId
  604.                         . '" class="title_img draggable" '
  605.                         . 'css="width: '
  606.                         . (DPSERVER_OBJECT_IMAGE_MAX_WIDTH + 5)
  607.                         . 'px; height: '
  608.                         . (DPSERVER_OBJECT_IMAGE_MAX_HEIGHT + 26) . 'px">'
  609.                         . $this->getAppearance(1, FALSE, $new_page, 'graphical')
  610.                         . '</addDpElement>'), $this);
  611.                 }
  612.             }
  613.             $target_ob->event(EVENT_ENTERED_INV, $this, $curr_env);
  614.             $dest_all = $target_ob->getInventory();
  615.             foreach ($dest_all as &$ob) {
  616.                 $ob->event(EVENT_ENTERED_ENV, $this, $curr_env);
  617.             }
  618.         }
  619.  
  620.         if (!isset($this->_GET) || !isset($this->_GET['getdivs'])) {
  621.             $body = isset($this->_GET) && isset($this->_GET['ajax'])
  622.                 /* Back/forward button is used */
  623.                 ? $target_ob->getAppearanceInventory(0, TRUE, NULL,
  624.                     $this->displayMode) . '<div class="dpclr">&nbsp;</div>'
  625.                 : $target_ob->getAppearance(0, TRUE, NULL,
  626.                     $this->displayMode);
  627.             if (FALSE !== $body) {
  628.                 $template_path = is_null($target_ob->template) ? ''
  629.                     : ' template="' . $target_ob->template . '"';
  630.                 $this->tell('<div id="'
  631.                     . (isset($this->_GET) && isset($this->_GET['ajax'])
  632.                     ? 'dpinventory' . '"' : 'dppage' . '"' . $template_path)
  633.                     . '>' . $body . '</div>');
  634.                 $this->tell('<inputpersistent persistent="'
  635.                     . (!$this->inputPersistent ? 'off' : $this->inputPersistent)
  636.                     . '">&nbsp;</inputpersistent>');
  637.  
  638.                 if ($this->isUser && ($type = $target_ob->isMovingArea)) {
  639.                     if (!isset($this->_GET) || !isset($this->_GET['ajax'])) {
  640.                         $this->tell('<script type="text/javascript" src="'
  641.                             . DPUNIVERSE_WWW_URL
  642.                             . 'interface/iutil.js"></script>');
  643.                         $this->tell('<script type="text/javascript" src="'
  644.                             . DPUNIVERSE_WWW_URL
  645.                             . 'interface/idrag.js"></script>');
  646.                     }
  647.                     $containment = $type === 1 ? "containment : 'parent',\n"
  648.                         : '';
  649.                     $cssfix = $type == 1 ? '.dpinventory, .dpinventory2'
  650.                         : '.dpinventory';
  651.                     $this->tell("<script>
  652. function init_drag() {
  653.     if (\$.iDrag == undefined) return;
  654.     \$('div.draggable').DraggableDestroy();
  655.     \$('div.draggable').Draggable({
  656.         handle: 'img.draggable',
  657.         zIndex: 1000,
  658.         ghosting: true,
  659.         opacity: 0.7,{$containment}
  660.         onChange : function() { stopdrag(this) }
  661.     });
  662.     \$('{$cssfix}').css('position', 'relative');
  663.     \$('{$cssfix}').css('overflow', 'hidden');
  664. }
  665. \$(function(){init_drag();});</script>\n");
  666.                 }
  667.             }
  668.         }
  669.  
  670.         return TRUE;
  671.     }
  672.  
  673.     /**
  674.      * Checks if an object is present in this object's inventory
  675.      *
  676.      * If $what is a string, searches for an object with that id. If $what is an
  677.      * object, searches for that object. Searches are done in the inventory of
  678.      * this object.
  679.      *
  680.      * @param      mixed     $what       string (id) or object to search for
  681.      * @return     boolean   TRUE if $what is in our inventory, FALSE otherwise
  682.      */
  683.     function isPresent($what)
  684.     {
  685.         return get_current_dpuniverse()->isPresent($what, $this);
  686.     }
  687.  
  688.     /**
  689.      * Makes sure an object is present in this object's inventory
  690.      *
  691.      * Replenishes this object's inventory up to $number instances of $what.
  692.      * This method is usually called from the reset method of pages and npc's.
  693.      *
  694.      * If $what is a string, searches for an object with that id. If $what is an
  695.      * object, searches for that object. Searches are done in the inventory of
  696.      * this object.
  697.      *
  698.      * A $number can be given to search for more objects instead of just one.
  699.      * For example, it could check for the presence of 5 roses, and if there
  700.      * are only 3, create another 2.
  701.      *
  702.      * If $mustBeHere is FALSE (it is TRUE by default), it will not replenish
  703.      * objects which are still in another part of the universe, instead of
  704.      * having been destroyed. For example, the 2 missing roses could have been
  705.      * taken by a user who is now on another page, and with this argument set
  706.      * to FALSE, no extra objects will be created.
  707.      *
  708.      * If $mustBeHere is TRUE, $moveHere can be set to TRUE (it is FALSE by
  709.      * default) to move objects which still exist but are located in another
  710.      * part of the universe, back to this object, its original location.
  711.      *
  712.      * @param      mixed     $what       string (id) or object to search for
  713.      * @param      int       $number     number of such objects to search for
  714.      * @param      boolean   $mustBeHere search only here for object?
  715.      * @param      boolean   $moveHere   replenish from objects elsewhere?
  716.      */
  717.     function makePresent($what, $number = 1, $mustBeHere = TRUE,
  718.             $moveHere = FALSE)
  719.     {
  720.         $found = 0;
  721.         if (0 < count($this->mCheckPresentObjects)) {
  722.             $keys = array_keys($this->mCheckPresentObjects);
  723.             foreach ($keys as $key) {
  724.                 if (!isset($this->mCheckPresentObjects[$key])) {
  725.                     continue;
  726.                 }
  727.                 if (empty($this->mCheckPresentObjects[$key])
  728.                         || $this->mCheckPresentObjects[$key]->isRemoved) {
  729.                     unset($this->mCheckPresentObjects[$key]);
  730.                     continue;
  731.                 }
  732.                 $ob = $this->mCheckPresentObjects[$key];
  733.                 if ((is_object($what) && $ob === $what)
  734.                         || (is_string($what) && $ob->location === $what)) {
  735.                     if ($mustBeHere) {
  736.                         if (!$this->isPresent($ob)) {
  737.                             if ($moveHere) {
  738.                                 $ob->moveDpObject($this);
  739.                                 if (++$found === $number) {
  740.                                     return;
  741.                                 }
  742.                             }
  743.                         } elseif (++$found === $number) {
  744.                             return;
  745.                         }
  746.                     }
  747.                     elseif (++$found === $number) {
  748.                         return;
  749.                     }
  750.                 }
  751.             }
  752.         }
  753.         while ($found < $number) {
  754.             $ob = get_current_dpuniverse()->newDpObject($what);
  755.             $ob->moveDpObject($this);
  756.             $this->mCheckPresentObjects[] =& $ob;
  757.             $found++;
  758.         }
  759.     }
  760.  
  761.     /**
  762.      * Gets the object reference to the environment of this object
  763.      *
  764.      * @return     mixed     object reference or FALSE for no environment
  765.      */
  766.     function &getEnvironment()
  767.     {
  768.         return get_current_dpuniverse()->getEnvironment($this);
  769.     }
  770.  
  771.     /**
  772.      * Gets an array with object references to all objects in our inventory
  773.      *
  774.      * If this object contains no other objects, an empty array is returned.
  775.      *
  776.      * @return     array     object references to objects in our inventory
  777.      */
  778.     function &getInventory()
  779.     {
  780.         return get_current_dpuniverse()->getInventory($this);
  781.     }
  782.  
  783.     /**
  784.      * Calls the given method after the given number of seconds
  785.      *
  786.      * Use this to perform delayed method calls in this object. Note that
  787.      * functions such as get_current_dpuser() can be totally different when the
  788.      * method is called. Also note that the actual delay is not exact science.
  789.      *
  790.      * @param      string    $method     name of method to call in this object
  791.      * @param      int       $secs       delay in seconds
  792.      */
  793.     function setTimeout($method, $secs)
  794.     {
  795.         if (func_num_args() <= 2) {
  796.             get_current_dpuniverse()->setTimeout($this, $method, $secs);
  797.         } else {
  798.             $args = func_get_args();
  799.  
  800.             call_user_func_array(array(get_current_dpuniverse(), 'setTimeout'),
  801.                 array_merge(array(&$this, $method, $secs),
  802.                 array_slice($args, 2)));
  803.         }
  804.     }
  805.  
  806.     /**
  807.      * Tells data (message, window, location, ...) to this object
  808.      *
  809.      * Tells a message to this object, for instance a chat line. Handled by
  810.      * by default.
  811.      *
  812.      * @param      string    $data      message string
  813.      */
  814.     function tell($data)
  815.     {
  816.     }
  817.  
  818.     /**
  819.      * Sets an array of names used to refer to this object
  820.      *
  821.      * Overwrites previous set ids. Ids are case insensitive and all turned
  822.      * into lowercase.
  823.      *
  824.      * @param      array     $ids        array of name strings
  825.      * @see        addId(), removeId(), getIds(), isId()
  826.      */
  827.     function setIds($ids)
  828.     {
  829.         $this->mIds = array();
  830.         foreach ($ids as $id) {
  831.             $this->mIds[dp_strtolower($id)] = TRUE;
  832.         }
  833.     }
  834.  
  835.     /**
  836.      * Adds one or more ids for this object
  837.      *
  838.      * A single id can be added at a time, or an array with ids can be given,
  839.      * or multiple arguments can be given (strings or array of strings).
  840.      *
  841.      * @param      string|array $id     name string or array of name strings
  842.      * @see        setIds(), removeId(), getIds(), isId()
  843.      */
  844.     function addId($id)
  845.     {
  846.         if ($sz = func_num_args()) {
  847.             for ($i = 0; $i < $sz; $i++) {
  848.                 $ids = func_get_arg($i);
  849.                 if (FALSE === is_array($ids)) {
  850.                     if (dp_strlen($ids)) {
  851.                         $this->mIds[dp_strtolower($ids)] = TRUE;
  852.                     }
  853.                 } else {
  854.                     foreach ($ids as $id) {
  855.                         if (dp_strlen($id)) {
  856.                             $this->mIds[dp_strtolower($id)] = TRUE;
  857.                         }
  858.                     }
  859.                 }
  860.             }
  861.         }
  862.     }
  863.  
  864.     /**
  865.      * Removes one or more ids for this object
  866.      *
  867.      * A single id can be removed at a time, or an array with ids can be given,
  868.      * or multiple arguments can be given (strings or array of strings).
  869.      *
  870.      * @param      string|array $id     name string or array of name strings
  871.      * @see        setIds(), addId(), getIds(), isId()
  872.      */
  873.     function removeId($id)
  874.     {
  875.         if ($sz = func_num_args()) {
  876.             for ($i = 0; $i < $sz && sizeof($this->mIds); $i++) {
  877.                 $ids = func_get_arg($i);
  878.                 if (FALSE === is_array($ids)) {
  879.                     if (dp_strlen($ids) && isset($this->mIds[$ids])) {
  880.                         unset($this->mIds[$ids]);
  881.                     }
  882.                 } else {
  883.                     foreach ($ids as $id) {
  884.                         if (dp_strlen($id) && isset($this->mIds[$id])) {
  885.                             unset($this->mIds[$id]);
  886.                         }
  887.                     }
  888.                 }
  889.             }
  890.         }
  891.     }
  892.  
  893.     /**
  894.      * Gets the array of ids for this object, or an empty array for no ids
  895.      *
  896.      * @return     array     array of name strings
  897.      * @see        setIds(), addId(), removeId(), isId()
  898.      */
  899.     function getIds()
  900.     {
  901.         return $this->mIds;
  902.     }
  903.  
  904.     /**
  905.      * Checks if the given id is a valid id for this object
  906.      *
  907.      * For example, a barkeeper object was set up like this:
  908.      * $this->addId('barkeeper');
  909.      * Now isId('barkeeper') called in this object will return TRUE, but
  910.      * 'the barkeeper' and 'a barkeeper' will also return TRUE.
  911.      * The disable the last behaviour, set $checkWithArticle to FALSE.
  912.      *
  913.      * @param      string    $id                name string to check
  914.      * @param      string    $checkWithArticle  also check ids with articles
  915.      * @return     boolean   TRUE if the id is valid, FALSE otherwise
  916.      * @see        setIds(), addId(), removeId(), getIds()
  917.      */
  918.     function isId($id, $checkWithArticle = TRUE)
  919.     {
  920.         $id = trim($id);
  921.         return dp_strlen($id) && (isset($this->mIds[$id = dp_strtolower($id)])
  922.             || $id == dp_strtolower($this->title))
  923.             || $id == $this->uniqueId
  924.             || ($checkWithArticle && $this->_isIdWithArticle($id));
  925.     }
  926.  
  927.     /**
  928.      * Checks if the given id is a valid id when articles are stripped off
  929.      *
  930.      * Strips off 'a', 'an' and 'the' (for English), and checks is the remainder
  931.      * is a valid id for this object.
  932.      *
  933.      * @access     private
  934.      * @param      string    $id                name string to check
  935.      * @return     boolean   TRUE if the id is valid, FALSE otherwise
  936.      * @see        isId()
  937.      */
  938.     private function _isIdWithArticle($id)
  939.     {
  940.         $articles = explode('#', dp_text('a#an#the'));
  941.         $space_pos = dp_strpos($id, ' ');
  942.         if (FALSE === $space_pos) {
  943.             return FALSE;
  944.         }
  945.  
  946.         $first_word = dp_substr($id, 0, $space_pos);
  947.         $rest = dp_substr($id, $space_pos + 1);
  948.         return in_array($first_word, $articles) && $this->isId($rest, FALSE);
  949.     }
  950.  
  951.     /**
  952.      * Sets the title for this object, "beer", used for object labels, etc.
  953.      *
  954.      * This title is used for object labels, page titles, messages, et cetera.
  955.      * Objects are visualized using two mechanisms: the object's "title" and
  956.      * the object's "body". The title is used when the object is nearby, for
  957.      * instance in the environment of a user that sees it. The body is used
  958.      * when we're in the object (a page) or examining the object. In other
  959.      * words, the object's title is a very abstract way to describe the object
  960.      * when looking at it from a greater distance.
  961.      *
  962.      * In plain language, this function controls the avatar or object image,
  963.      * and the label under it.
  964.      *
  965.      * The $title should be a short description like "beer" without "a" or "the"
  966.      * in front.
  967.      *
  968.      * The $title_img should be a URL to the image shown to represent this
  969.      * object.
  970.      *
  971.      * The second argument, $type, should be a constant as defined in
  972.      * include/title_types.php and is used by the framework to, for example,
  973.      * construct lines such as "Lennert takes a cool, fresh beer" instead of
  974.      * "A Lennert takes a cool fresh, beer" or "The Lennert takes a cool, fresh
  975.      * beer".
  976.      *
  977.      * DPUNIVERSE_TITLE_TYPE_INDEFINITE - the title is indefinite, "a beer"
  978.      * DPUNIVERSE_TITLE_TYPE_DEFINITE - the title is definite, "the hulk"
  979.      * DPUNIVERSE_TITLE_TYPE_NAME - the title is a name, "Lennert"
  980.      * DPUNIVERSE_TITLE_TYPE_PLURAL - the title is plural, "sweets" (not yet
  981.      * implemented)
  982.      *
  983.      * @param      string    $title      short description, "beer"
  984.      * @param      string    $titleType  noun type, use the constants above
  985.      * @param      string    $titleImg   URL to avatar or object image
  986.      */
  987.     public function setTitle($title, $titleType = FALSE, $titleImg = FALSE)
  988.     {
  989.         $this->setDpProperty('title', $title);
  990.         $this->titleDefinite = NULL;
  991.         $this->titleIndefinite = NULL;
  992.  
  993.         if (FALSE !== $titleType) {
  994.             $this->titleType = $titleType;
  995.         }
  996.  
  997.         if (FALSE !== $titleImg) {
  998.             $this->titleImg = $titleImg;
  999.         }
  1000.     }
  1001.  
  1002.     /**
  1003.      * Gets the object's title with optional prefixes such as 'a' and 'the'
  1004.      *
  1005.      * Gets the title as set with setTitle, for example "barkeeper" if no $type
  1006.      * is given.
  1007.      *
  1008.      * If $type is DPUNIVERSE_TITLE_TYPE_INDEFINITE, "a ..." or "an ..." is
  1009.      * put in front if the object's title type has been set to indefinite. So
  1010.      * for a barkeeper this returns "a barkeeper", for me it returns "Lennert".
  1011.      *
  1012.      * If $type is DPUNIVERSE_TITLE_TYPE_DEFINITE, "the" is put in front if the
  1013.      * object's title type is not DPUNIVERSE_TITLE_TYPE_NAME. So for a barkeeper
  1014.      * this returns "the barkeeper", for me it returns "Lennert".
  1015.      *
  1016.      * @param      string    $type       noun type, use the constants above
  1017.      * @return     string    the object's title
  1018.      */
  1019.     public function getTitle($type = NULL)
  1020.     {
  1021.         switch ($type) {
  1022.         case DPUNIVERSE_TITLE_TYPE_INDEFINITE:
  1023.             switch ($this->getTitleType()) {
  1024.             case DPUNIVERSE_TITLE_TYPE_DEFINITE:
  1025.                 return !is_null($this->titleDefinite) ? $this->titleDefinite
  1026.                     : sprintf(dp_text('the %s'), $this->getDpProperty('title'));
  1027.             case DPUNIVERSE_TITLE_TYPE_NAME: case DPUNIVERSE_TITLE_TYPE_PLURAL:
  1028.                 return $this->getDpProperty('title');
  1029.             default:
  1030.                 if (!is_null($this->titleIndefinite)) {
  1031.                     return $this->titleIndefinite;
  1032.                 }
  1033.                 $title = $this->getDpProperty('title');
  1034.                 return (FALSE === dp_strpos(dp_text('aeioux'),
  1035.                     dp_strtolower($title{0}))
  1036.                     ? sprintf(dp_text('a %s'), $title)
  1037.                     : sprintf(dp_text('an %s'), $title));
  1038.             }
  1039.         case DPUNIVERSE_TITLE_TYPE_DEFINITE:
  1040.             switch ($this->getTitleType()) {
  1041.             case DPUNIVERSE_TITLE_TYPE_NAME:
  1042.                 return $this->getDpProperty('title');
  1043.             default:
  1044.                 return !is_null($this->titleDefinite) ? $this->titleDefinite
  1045.                     : sprintf(dp_text('the %s'), $this->getDpProperty('title'));
  1046.             }
  1047.         default:
  1048.             return $this->getDpProperty('title');
  1049.         }
  1050.     }
  1051.  
  1052.     /**
  1053.      * Sets the HTML content of this object
  1054.      *
  1055.      * If this is a page, this defines the page content. For other objects, it
  1056.      * defines what you see when examining the object or moving into the object
  1057.      * (which makes the object behave like a page).
  1058.      *
  1059.      * When a single argument is given, sets the HTML content to the given text.
  1060.      *
  1061.      * Pairs of arguments can be given to set the content in other ways, with
  1062.      * the second argument the type, and the first the data (what the data is
  1063.      * depends on the type).
  1064.      *
  1065.      * Types are:
  1066.      * string (default, raw data)
  1067.      * file (read content of given filename)
  1068.      *
  1069.      * Examples:
  1070.      * $this->setBody('Hello world');
  1071.      * $this->setBody('helloworld.html', 'file');
  1072.      * $this->setBody('Prefix', 'string', 'helloworld.html', 'file', 'Postfix',
  1073.      *     'string')
  1074.      *
  1075.      * When a file is read, the following strings are replaced by their
  1076.      * corresponding constants:
  1077.      * /dpclient.php, /page/ and /images/
  1078.      *
  1079.      * Instead of text or a path, a method to call whenever the body property is
  1080.      * requested can be given using an array two elements: an object and a
  1081.      * method name. Depending on the type, the method should return text or a
  1082.      * path.
  1083.      *
  1084.      * @param       string    $body       content data or method
  1085.      * @param       string    $type       content type
  1086.      * @see         getBody
  1087.      */
  1088.     public function setBody($body, $type = 'text')
  1089.     {
  1090.         $num_args = func_num_args();
  1091.         if (1 == $num_args) {
  1092.             $this->setDpProperty('body', $body);
  1093.             return;
  1094.         }
  1095.         $tmp = array();
  1096.         for ($i = 0; $i < $num_args; $i += 2) {
  1097.             $tmp[] = array(func_get_arg($i), func_get_arg($i + 1));
  1098.         }
  1099.         $this->setDpProperty('body', $tmp);
  1100.     }
  1101.  
  1102.     /**
  1103.      * Gets the HTML content of this object
  1104.      *
  1105.      * @return     string    HTML content of this object
  1106.      * @see        setBody
  1107.      */
  1108.     public function getBody()
  1109.     {
  1110.         $body = $this->getDpProperty('body');
  1111.         parse_dp_callable($body, $this);
  1112.  
  1113.         if (!is_array($body)) {
  1114.             return $this->getMapAreaHtml() . "\n" . $body;
  1115.         }
  1116.  
  1117.         $rval = '';
  1118.  
  1119.         foreach ($body as &$b) {
  1120.             $data = $b[0];
  1121.             parse_dp_callable($data, $this);
  1122.             $type = $b[1];
  1123.             if ($type === 'text') {
  1124.                 $rval .= $data;
  1125.             }
  1126.             elseif ($type === 'file') {
  1127.                 $tmp = dp_file_get_contents($data);
  1128.  
  1129.                 if (FALSE !== $tmp) {
  1130.                     $rval .= str_replace(array('/dpclient.php',
  1131.                         '/page/', '/images/'),
  1132.                         array(DPSERVER_CLIENT_URL, DPUNIVERSE_PAGE_PATH,
  1133.                         DPUNIVERSE_IMAGE_URL), $tmp);
  1134.                 }
  1135.             } elseif ($type === 'url') {
  1136.                 /* Experimental, ignore */
  1137.                 $rval .= $this->getBodyUrl($data);
  1138.             }
  1139.         }
  1140.         return $this->getMapAreaHtml() . "\n" . $rval;
  1141.     }
  1142.  
  1143.     /**
  1144.      * Gets the HTML content of this object
  1145.      *
  1146.      * Experimental, ignore.
  1147.      *
  1148.      * @access     private
  1149.      * @param      string    $url             location of contents
  1150.      * @return     string    HTML content of this object
  1151.      */
  1152.     private function _getBodyUrl($url)
  1153.     {
  1154.         echo dp_text("Getting mailman contents\n");
  1155.  
  1156.         inherit(DPUNIVERSE_STD_PATH . 'mailman.php');
  1157.  
  1158.         $config = array
  1159.         (
  1160.             'url_var_name'             => 'q',
  1161.             'flags_var_name'           => 'hl',
  1162.             'get_form_name'            => '__script_get_form',
  1163.             'proxy_url_form_name'      => 'poxy_url_form',
  1164.             'proxy_settings_form_name' => 'poxy_settings_form',
  1165.             'max_file_size'            => -1
  1166.         );
  1167.         $flags = '0011100000';
  1168.         $PHProxy =  new PHProxy($config, $flags);
  1169.         $PHProxy->start_transfer($data);
  1170.         $tmp = $PHProxy->return_response();
  1171.  
  1172.         /*
  1173.         $fp = fopen($data, "rb");
  1174.  
  1175.         if (!$fp) {
  1176.            return false;
  1177.         }
  1178.  
  1179.         $tmp = "";
  1180.         while (! feof($fp)) {
  1181.            $tmp .= fread($fp, 4096);
  1182.         }
  1183.  
  1184.         $meta_data = stream_get_meta_data($fp);
  1185.         fclose($fp);
  1186.         foreach($meta_data['wrapper_data'] as $response) {
  1187.             $tmp .= htmlentities($response) . '<br />';
  1188.         }
  1189.         */
  1190.         $pos1 = stripos($tmp, '<title>');
  1191.         $pos2 = stripos($tmp, '</title>');
  1192.         $len = dp_strlen($tmp);
  1193.         if (FALSE !== $pos1 && FALSE !== $pos2) {
  1194.             $this->setTitle($tmp2 = dp_substr($tmp, $pos1 + 7, $pos2 -
  1195.                 ($pos1 + 7)));
  1196.             $this->setNavigationTrail(array(DPUNIVERSE_NAVLOGO, ''),
  1197.                 $tmp2);
  1198.         }
  1199.         $tmp = str_replace(array('/mailman2/', '="100%"'),
  1200.             array('/mailman/', '="90%"'), $tmp);
  1201.         $rval .= $tmp;
  1202.     }
  1203.  
  1204.     /**
  1205.      * Gets the HTML "appearance" of this object
  1206.      *
  1207.      * Gets HTML to represent the object to another objects. That is, other
  1208.      * objects call this method in order to "see" it, and HTML is returned. How
  1209.      * an object is seen depends on how the object is related to the object that
  1210.      * is viewing it in terms of "physical" location.
  1211.      *
  1212.      * In other words, a level of 0 means this object is seen by something in
  1213.      * its inventory (a user sees a page). Level 1 means this object is seen by
  1214.      * an object in its environment (a user sees another user). Level 2 means
  1215.      * this object is in the inventory of the object that is seeing it.
  1216.      *
  1217.      * @param      int       $level           level of visibility
  1218.      * @param      boolean   $include_div     include div with id around HTML?
  1219.      * @param      object    $from            experimental
  1220.      * @param      string    $displayMode     'abstract' or 'graphical'
  1221.      * @param      boolean   $displayTitlebar display title bar for pages?
  1222.      * @param      boolean   $elementId       to be used as html element id
  1223.      * @return     string    HTML "appearance" of this object
  1224.      * @see        getAppearanceTitle
  1225.      */
  1226.     public function getAppearance($level = 0, $include_div = TRUE,
  1227.             $from = NULL, $displayMode = 'abstract',
  1228.             $displayTitlebar = TRUE, $elementId = 'dppage')
  1229.     {
  1230.         $user = get_current_dpobject();
  1231.         if (empty($user)) {
  1232.             $user = get_current_dpuser();
  1233.         }
  1234.         $body = $inventory = '';
  1235.         $titlebar = '';
  1236.         if (0 === $level) {
  1237.             if (TRUE === $displayTitlebar) {
  1238.                 $template_path = is_null($this->template) ? ''
  1239.                     : ' template="' . $this->template . '"';
  1240.                 $navtrail = $this->getNavigationTrailHtml();
  1241.                 if (FALSE === $user) {
  1242.                     $titlebar = $navtrail;
  1243.                 } else {
  1244.                     $login_link = !isset($user->isRegistered)
  1245.                         || TRUE !== $user->isRegistered
  1246.                         ? '<a href="' . DPSERVER_CLIENT_URL . '?location='
  1247.                         . DPUNIVERSE_PAGE_PATH. 'login.php" style='
  1248.                         . '"padding-left: 4px">' . dp_text('Login/register')
  1249.                         . '</a>'
  1250.                         : '<a href="' . DPSERVER_CLIENT_URL . '?location='
  1251.                         . DPUNIVERSE_PAGE_PATH . 'login.php&amp;act=logout" '
  1252.                         . 'style="padding-left: 4px">' . dp_text('Logout')
  1253.                         . '</a>';
  1254.                     $bottom = dp_text('Go to Bottom');
  1255.                     $titlebar = '<div id="titlebarleft">' .
  1256.                         $navtrail . '</div><div id='
  1257.                         . '"titlebarright">&#160;<div id="dploginout">'
  1258.                         .sprintf(dp_text('Welcome %s'), '<span id="username">'
  1259.                         . $user->title . '</span>')
  1260.                         . ' <span id="loginlink">'
  1261.                         . $login_link . '</span>&#160;&#160;&#160;&#160;'
  1262.                         . '<img id="butbottom" src="' . DPUNIVERSE_IMAGE_URL
  1263.                         . 'bottom.gif" '
  1264.                         . 'align="absbottom" width="11" height="11" border="0" '
  1265.                         . 'alt="' . $bottom . '" title="' . $bottom . '" '
  1266.                         . 'onclick="_gel(\'dpaction\').focus(); '
  1267.                         . 'scroll(0, 999999)" /></div></div>';
  1268.                 }
  1269.                 $titlebar = '<div id="titlebar">' . $titlebar . '</div>';
  1270.             } else {
  1271.                 $template_path = '';
  1272.             }
  1273.  
  1274.             $body = '<div id="' . $elementId . '"' . $template_path
  1275.                 . '><div id="' . $elementId . '_inner1">' . $titlebar
  1276.                 . '<div class="' . $elementId . '_inner2" id="' . $elementId
  1277.                 . '_inner2">' . '<div id="dppage_body">'
  1278.                 . ($displayTitlebar === -1 ? '' : $this->getBody()
  1279.                 . '</div><br />');
  1280.  
  1281.             $inventory = $this->getAppearanceInventory($level, $include_div,
  1282.                 $from, $displayMode, $displayTitlebar, $elementId)
  1283.                 . '<div class="dpclr">&nbsp;</div>';
  1284.  
  1285.             if (isset($this->isLiving) && TRUE === $this->isLiving) {
  1286.                 $reguser_age = $inactive_time = $session_age = '';
  1287.                 if ($displayTitlebar !== -1) {
  1288.                     if (isset($this->isUser) && TRUE === $this->isUser) {
  1289.                         $session_age = (get_current_dpobject()
  1290.                             && get_current_dpobject() === $this
  1291.                             ? (!isset($this->isRegistered)
  1292.                                 || TRUE !== $this->isRegistered
  1293.                                 ? dp_text("You have been %s on this site.",
  1294.                                 $this->sessionAge)
  1295.                                 : dp_text("This session, you have been %s on this site.",
  1296.                                 $this->sessionAge))
  1297.                             : (!isset($this->isRegistered)
  1298.                                 || TRUE !== $this->isRegistered ? ucfirst(
  1299.                                 dp_text("%s has been %s on this site.",
  1300.                                 $this->getTitle(DPUNIVERSE_TITLE_TYPE_DEFINITE),
  1301.                                 $this->sessionAge))
  1302.                                 : dp_text("This session, %s has been %s on this site.",
  1303.                                 $this->getTitle(DPUNIVERSE_TITLE_TYPE_DEFINITE),
  1304.                                 $this->sessionAge))) . '<br /><br />';
  1305.                     }
  1306.  
  1307.                     $reguser_age = !isset($this->isRegistered)
  1308.                         || TRUE !== $this->isRegistered
  1309.                         ? '' : (get_current_dpobject()
  1310.                         && get_current_dpobject() === $this ?
  1311.                         dp_text("In total, you have been %s on this site.",
  1312.                         $this->age)
  1313.                         : dp_text("In total, %s has been %s on this site.",
  1314.                         $this->getTitle(DPUNIVERSE_TITLE_TYPE_DEFINITE),
  1315.                         $this->age)) . '<br /><br />';
  1316.  
  1317.                     $inactive_time = !isset($this->isInactive)
  1318.                         || TRUE !== $this->isInactive ? ''
  1319.                         : dp_text('%s has been inactive for %s.',
  1320.                         $this->getTitle(DPUNIVERSE_TITLE_TYPE_DEFINITE),
  1321.                         $this->inactive) . '<br /><br />';
  1322.                 }
  1323.  
  1324.                 return $body . $session_age . $reguser_age . $inactive_time .
  1325.                     (get_current_dpobject() && get_current_dpobject() === $this
  1326.                     ? dp_text('You are carrying:')
  1327.                     : ucfirst(dp_text('%s is carrying:',
  1328.                         $this->getTitle(DPUNIVERSE_TITLE_TYPE_DEFINITE))))
  1329.                     . '<br />'
  1330.                     . ($inventory == '' ? dp_text('Nothing') : $inventory)
  1331.                     . '</div></div></div>';
  1332.             }
  1333.             $body .= $inventory . '</div></div></div>';
  1334.             return $body;
  1335.         } elseif (1 === $level) {
  1336.             $status = !isset($this->status) || FALSE === $this->status
  1337.                 ? '' : ' (' . $this->status . ')';
  1338.  
  1339.             if (is_null($from)) {
  1340.                 $from = $user;
  1341.             }
  1342.  
  1343.             if ($displayMode === 'graphical' && isset($this->titleImg)) {
  1344.                 $title_img = $this->getAppearanceTitle($user);
  1345.  
  1346.                 return FALSE === $include_div ? $title_img
  1347.                     : '<div id="' . $this->uniqueId . '" '
  1348.                     . 'class="title_img' . ($from !== $this ? '' : '_me')
  1349.                     . ' draggable" style="width: '
  1350.                     . (DPSERVER_OBJECT_IMAGE_MAX_WIDTH + 5)
  1351.                     . 'px; height: ' . (DPSERVER_OBJECT_IMAGE_MAX_HEIGHT + 26)
  1352.                     . 'px">' . $title_img . '</div>';
  1353.             }
  1354.  
  1355.             $body = $from === $this ? '<span class="me">'
  1356.                 . ucfirst($this->getTitle(DPUNIVERSE_TITLE_TYPE_INDEFINITE))
  1357.                 . $status . '</span>'
  1358.                 : ucfirst($this->getTitle(DPUNIVERSE_TITLE_TYPE_INDEFINITE))
  1359.                 . $status;
  1360.  
  1361.             $inv = $this->getInventory();
  1362.             foreach ($inv as &$ob) {
  1363.                 $inventory .= $ob->getAppearance($level + 1, $include_div,
  1364.                     $from, $displayMode);
  1365.             }
  1366.  
  1367.             return FALSE === $include_div ? $body . $inventory
  1368.                 : '<div id="' . $this->uniqueId
  1369.                 . '" class="dpobject" onclick="get_actions(\''
  1370.                 . $this->uniqueId . '\', event)">'
  1371.                 . $body . $inventory . '</div>';
  1372.         } elseif (2 === $level) {
  1373.             $status = !isset($this->status) || FALSE === $this->status
  1374.                 ? '' : ' (' . $this->status . ')';
  1375.             return FALSE === $include_div
  1376.                 ? ucfirst($this->getTitle(DPUNIVERSE_TITLE_TYPE_INDEFINITE))
  1377.                 . $status
  1378.                 : '<div id="' . $this->uniqueId
  1379.                 . '" class="dpobject2" onclick="get_actions(\''
  1380.                 . $this->uniqueId . '\')">'
  1381.                 . ucfirst($this->getTitle(DPUNIVERSE_TITLE_TYPE_INDEFINITE))
  1382.                 . $status . '</div>';
  1383.         }
  1384.         return $body . (0 === dp_strlen($inventory) ? "" : $inventory)
  1385.             . '</div></div></div>';
  1386.     }
  1387.  
  1388.     /**
  1389.      * Gets the graphical appearance in HTML for this object
  1390.      *
  1391.      * Returns the HTML with the image and the title of the object. The method
  1392.      * filterAppearance($level, &$from, $appearance, &$user) is called in the
  1393.      * environments of the object if defined. $level is 1, $from is an array
  1394.      * starting with this object, followed by elements defining a path to the
  1395.      * current object being called, $appearance the default appearance HTML and
  1396.      * $user the user for which we're getting the appearance of the object. If
  1397.      * you define it, it should return a string with the HTML for the
  1398.      * appearance, just like getAppearanceTitle does itself.
  1399.      *
  1400.      * @param      object    &$user        performer of actions
  1401.      * @return     string    the graphical appearance in HTML for this object
  1402.      * @see        getAppearanceTitle
  1403.      * @since      DutchPIPE 0.3.0
  1404.      */
  1405.     function getAppearanceTitle(&$user)
  1406.     {
  1407.  
  1408.         $status = !isset($this->status) || FALSE === $this->status
  1409.             ? '' : ' (' . $this->status . ')';
  1410.         $title_pre = $title_post = '';
  1411.         $title_img_class = "dpimage";
  1412.         if ($this->isDraggable($user)) {
  1413.             $title_img_class .= ' draggable';
  1414.         }
  1415.         if ($this->isInactive) {
  1416.             $title_img_class .= ' dpinactive';
  1417.             $title_pre = '<span class="dpinactive_txt">';
  1418.             $title_post = '</span>';
  1419.         }
  1420.         $alt = dp_text('Click me!');
  1421.  
  1422.         $width_html = FALSE === ($width = $this->getTitleImgWidth()) ? ''
  1423.             : ' width="' . $width . '"';
  1424.         $height_html =  FALSE === ($height = $this->getTitleImgHeight()) ? ''
  1425.             : ' height="' . $height . '"';
  1426.         $margin_top = FALSE === $height
  1427.             || $height >= DPSERVER_OBJECT_IMAGE_MAX_HEIGHT ? ''
  1428.             : ' style="margin-top: '
  1429.             . (DPSERVER_OBJECT_IMAGE_MAX_HEIGHT - $height) . 'px"';
  1430.  
  1431.         $img_title = '<img src="' . $this->titleImg . '" '
  1432.             . 'border="0"' . $width_html . $height_html . $margin_top
  1433.             . ' class="' . $title_img_class . '" ' . 'onclick="get_actions(\''
  1434.             . $this->uniqueId . '\', event)" ' . 'alt="' . $alt . '" title="'
  1435.             . $alt . '" /> <br />' . $title_pre  /* IE6 needs space before br */
  1436.             . ucfirst($this->getTitle( DPUNIVERSE_TITLE_TYPE_INDEFINITE))
  1437.             . $status . $title_post;
  1438.  
  1439.         $env =& $this;
  1440.         $from = array();
  1441.         do {
  1442.             $from[] = $env;
  1443.             if (method_exists($env, 'filterAppearance')) {
  1444.                 $img_title = $env->filterAppearance(1, $from, $img_title,
  1445.                     $user);
  1446.             }
  1447.  
  1448.             $env = $env->getEnvironment();
  1449.         } while ($env);
  1450.  
  1451.         return $img_title;
  1452.     }
  1453.  
  1454.     /**
  1455.      * Gets the HTML "appearance" of all objects in this object's inventory
  1456.      *
  1457.      * Gets HTML to represents the all objects in this object's inventory using
  1458.      * getAppearance.
  1459.      *
  1460.      * @param      int       $level           level of visibility of this object
  1461.      * @param      boolean   $include_div     include div with id around HTML?
  1462.      * @param      object    $from            expiremental
  1463.      * @param      string    $displayMode     'abstract' or 'graphical'
  1464.      * @return     string    HTML "appearances" of this object's inventory
  1465.      */
  1466.     function getAppearanceInventory($level = 0, $include_div = TRUE,
  1467.             $from = NULL, $displayMode = 'abstract', $displayTitlebar = TRUE,
  1468.             $elementId = 'dppage')
  1469.     {
  1470.         $inv = $this->getInventory();
  1471.         $inventory = '';
  1472.         foreach ($inv as &$ob) {
  1473.             $inventory .= $ob->getAppearance($level + 1, $include_div, $from,
  1474.                 $displayMode, $displayTitlebar, $elementId);
  1475.         }
  1476.         $div_id = 'dppage' === $elementId ? 'dpinventory' : 'dpobinv';
  1477.  
  1478.         return $inventory == '' ? ''
  1479.             : "<div id=\"$div_id\"><div class=\"dpinventory2\" id=\""
  1480.                 . "{$this->uniqueId}\">$inventory</div><div class=\"dpclr\">"
  1481.                 . "&nbsp;</div></div>";
  1482.     }
  1483.  
  1484.     /**
  1485.      * Gets a HTML navigation trail for this object
  1486.      *
  1487.      * By default, a 'Home' link is always present.
  1488.      *
  1489.      * @return     string    HTML for navigation trail
  1490.      */
  1491.     function getNavigationTrailHtml()
  1492.     {
  1493.         return '<div id="navlink">' . DPUNIVERSE_NAVLOGO . '</div>';
  1494.     }
  1495.  
  1496.     /**
  1497.      * Adds an examinable 'item' to this object
  1498.      *
  1499.      * 'Items' in objects allow you to perform some basic actions, such as
  1500.      * examine, without making new objects.
  1501.      *
  1502.      * For example, consider this page with the following description:<br />
  1503.      * You are in front of a house. You see a sign.
  1504.      *
  1505.      * The following call will make the house examinable:<br />
  1506.      * <code>add_item('house', 'It is a big, brick house.<br />');</code>
  1507.      *
  1508.      * The $item can be an identifier string or an array with strings with
  1509.      * identifiers, for example array('house', 'brick house'). Such aliases can
  1510.      * be used from the command line, for example 'examine brick house'.
  1511.      *
  1512.      * The $description should be a string with the textual description.
  1513.      *
  1514.      * The $method is optional and should be a string containing a method or an
  1515.      * array with two elements: an object to call and a string with the method.
  1516.      * This method is called at runtime to obtain the description. It should be
  1517.      * defined like this:<br />
  1518.      * <code>function <methodName>($item)</code>
  1519.      * and return a string.<br />
  1520.      * When the $description is NULL, only the result from this method will be
  1521.      * shown. With the $description is a normal string, the result of the method
  1522.      * is appended. When the description has the %s token in it, the result of
  1523.      * the method is inserted there. Example:<br />
  1524.      * <code>add_item('door', 'A solid door. It is %s.', 'getOpenOrClosed');</code>
  1525.      *
  1526.      * The optional $mapArea can be given to make this item accessible on an
  1527.      * imagemap, so people can click on it to examine it. Otherwise the item
  1528.      * can only be examined by using the command line. It should be a map area
  1529.      * id if you set one earlier with setMapArea, or an array with the arguments
  1530.      * to setMapArea to define a new one (see setMapArea documentation for more
  1531.      * information).
  1532.      *
  1533.      * If a map area is used, the action on the imagemap is labelled 'examine'.
  1534.      * This can be overruled by supplying $mapAreaActionMenu, which should be
  1535.      * a string with an alternative label.
  1536.      *
  1537.      * @param      mixed     $item              string or array of strings with
  1538.      *                                          item ids
  1539.      * @param      string    $description       item description
  1540.      * @param      mixed     $method            method for dynamic description
  1541.      * @param      mixed     $mapArea           imagemap area id or definition
  1542.      * @param      mixed     $mapAreaActionMenu action to appear on menu
  1543.      * @see        getItem, getItemDescription, getItems, addAction, setMapArea
  1544.      * @since      DutchPIPE 0.2.0
  1545.      */
  1546.     function addItem($item, $description, $method = NULL, $mapArea = NULL,
  1547.             $mapAreaActionMenu = NULL)
  1548.     {
  1549.         if (is_array($item)) {
  1550.             $tmp = $item[0];
  1551.             if (1 < ($sz = sizeof($item))) {
  1552.                 for ($i = 1; $i < $sz; $i++) {
  1553.                     $this->mItemAliases[$item[$i]] = $tmp;
  1554.                 }
  1555.             }
  1556.             $item = $tmp;
  1557.         }
  1558.         $this->mItems[$item] = array($description, $method);
  1559.  
  1560.         if (is_null($mapArea)) {
  1561.             return;
  1562.         }
  1563.         if (is_array($mapArea)) {
  1564.             call_user_func_array(array(&$this, 'setMapArea'), $mapArea);
  1565.             $mapArea = $mapArea[1];
  1566.         }
  1567.         if (is_null($mapAreaActionMenu)) {
  1568.             $mapAreaActionMenu = dp_text('examine');
  1569.         }
  1570.         $this->addMapAreaAction($mapArea, $mapAreaActionMenu,
  1571.             sprintf(dp_text("examine %s"), $item));
  1572.     }
  1573.  
  1574.     /**
  1575.      * Gets an array with data about an item
  1576.      *
  1577.      * An array is returned with two elements: the item description and the item
  1578.      * method. Either can be NULL. If the item was not found, FALSE is returned.
  1579.      *
  1580.      * @param      string    $item            the item id to search for
  1581.      * @return     array     array with data about the given item, or FALSE
  1582.      * @see        addItem, getItemDescription, getItems, addAction, setMapArea
  1583.      * @since      DutchPIPE 0.2.0
  1584.      */
  1585.     function getItem($item)
  1586.     {
  1587.         if (isset($this->mItems[$item])) {
  1588.             return $this->mItems[$item];
  1589.         } elseif (isset($this->mItemAliases[$item])) {
  1590.             return $this->mItems[$this->mItemAliases[$item]];
  1591.         }
  1592.  
  1593.         $articles = explode('#', dp_text('a#an#the'));
  1594.         $space_pos = dp_strpos($item, ' ');
  1595.         if (FALSE !== $space_pos) {
  1596.             $first_word = dp_substr($item, 0, $space_pos);
  1597.             $rest = dp_substr($item, $space_pos + 1);
  1598.             if (in_array($first_word, $articles)) {
  1599.                 return $this->getItem($item);
  1600.             }
  1601.         }
  1602.         return FALSE;
  1603.     }
  1604.  
  1605.     /**
  1606.      * Gets the description of a given item
  1607.      *
  1608.      * Returns the description of the given item, or FALSE if no such item was
  1609.      * found. Items can be added with a method to call (see addItem), here this
  1610.      * method is processed.
  1611.      *
  1612.      * @param      string    $item            the item id to search for
  1613.      * @return     mixed     string with description or FALSE
  1614.      * @see        addItem, getItem, getItems, addAction, setMapArea
  1615.      * @since      DutchPIPE 0.2.0
  1616.      */
  1617.     function getItemDescription($item)
  1618.     {
  1619.         if (isset($this->mItems[$item])) {
  1620.             $item_data =& $this->mItems[$item];
  1621.         } elseif (isset($this->mItemAliases[$item])) {
  1622.             $item_data =& $this->mItems[$this->mItemAliases[$item]];
  1623.         } else {
  1624.             $articles = explode('#', dp_text('a#an#the'));
  1625.             $space_pos = dp_strpos($item, ' ');
  1626.             if (FALSE !== $space_pos) {
  1627.                 $first_word = dp_substr($item, 0, $space_pos);
  1628.                 $rest = dp_substr($item, $space_pos + 1);
  1629.                 if (in_array($first_word, $articles)) {
  1630.                     return $this->getItemDescription($item);
  1631.                 }
  1632.             }
  1633.  
  1634.             return FALSE;
  1635.         }
  1636.  
  1637.         $description = $item_data[0];
  1638.         $method = $item_data[1];
  1639.  
  1640.         if (is_null($method)) {
  1641.             return $description;
  1642.         }
  1643.  
  1644.         $method_description = !is_array($method) ? $this->{$method}($item)
  1645.             : $method[0]->{$method[1]}($item);
  1646.  
  1647.         if (is_null($description) || '' === $description) {
  1648.             return $method_description;
  1649.         }
  1650.  
  1651.         $combined_description = sprintf($description, $method_description);
  1652.  
  1653.         return $combined_description != $description ? $combined_description :
  1654.             $description . $method_description;
  1655.     }
  1656.  
  1657. /**    
  1658.      * Gets an array with all item data added to this object
  1659.      *
  1660.      * @return     array     all items added to this object
  1661.      * @see        addItem, getItem, getItemDescription, addAction, setMapArea
  1662.      * @since      DutchPIPE 0.2.0
  1663.      */
  1664.     function getItems()
  1665.     {
  1666.         return $this->mItems;
  1667.     }
  1668.  
  1669. /**    
  1670.      * Adds an action to the object
  1671.      *
  1672.      * Use this method to have actions added to the menus you get when clicking
  1673.      * on items (the "action menu"), and at the same time to add actions you can
  1674.      * type. See DpLiving.php for some good examples.
  1675.      *
  1676.      * Because of the complexity of this method, it has its own manual page.
  1677.      * See {@tutorial DutchPIPE/actions.pkg} for further information.
  1678.      *
  1679.      * @param      mixed     $actionMenu        title of clickable menu item
  1680.      * @param      mixed     $actionVerb        alternative verb to type
  1681.      * @param      mixed     $actionMethod      method called to perform action
  1682.      * @param      mixed     $actionOperant     on who/what does it have effect?
  1683.      * @param      mixed     $actionTarget      where should menu item appear?
  1684.      * @param      mixed     $actionAuthorized  who may perform this action?
  1685.      * @param      mixed     $actionScope       who sees action to begin with?
  1686.      * @param      mixed     $mapArea           imagemap area id or definition
  1687.      * @param      string    $mapAreaAction     specific action to use
  1688.      * @see        removeAction, getActionData,  getActionsMenu, setMapArea
  1689.      * @tutorial   DutchPIPE/actions.pkg
  1690.      */
  1691.     final public function addAction($actionMenu, $actionVerb, $actionMethod,
  1692.             $actionOperant = DP_ACTION_OPERANT_MENU,
  1693.             $actionTarget = DP_ACTION_TARGET_SELF,
  1694.             $actionAuthorized = DP_ACTION_AUTHORIZED_ALL,
  1695.             $actionScope = DP_ACTION_SCOPE_ALL,
  1696.             $mapArea = NULL,
  1697.             $mapAreaAction = NULL)
  1698.     {
  1699.         if (is_array($actionVerb)) {
  1700.             $tmp = $actionVerb[0];
  1701.             if (!isset($this->mActions[$tmp])) {
  1702.                 $new_key = 0;
  1703.             } else {
  1704.                 end($this->mActions[$tmp]);
  1705.                 $new_key = key($this->mActions[$tmp]) + 1;
  1706.                 reset($this->mActions[$tmp]);
  1707.             }
  1708.             if (1 < ($sz = sizeof($actionVerb))) {
  1709.                 for ($i = 1; $i < $sz; $i++) {
  1710.                     if (!isset($this->mActionAliases[$actionVerb[$i]])) {
  1711.                         $this->mActionAliases[$actionVerb[$i]] = array();
  1712.                     }
  1713.                     $this->mActionAliases[$actionVerb[$i]][] =
  1714.                         array($tmp, $new_key);
  1715.                 }
  1716.             }
  1717.             $actionVerb = $tmp;
  1718.         }
  1719.  
  1720.         if (!isset($this->mActions[$actionVerb])) {
  1721.             $this->mActions[$actionVerb] = array();
  1722.         }
  1723.         $this->mActions[$actionVerb][] = array($actionMenu, $actionMethod,
  1724.             $actionOperant, $actionTarget, $actionAuthorized, $actionScope,
  1725.             $mapArea, $mapAreaAction);
  1726.         end($this->mActions[$actionVerb]);
  1727.         if (!is_null($mapArea)) {
  1728.             if (is_array($mapArea)) {
  1729.                 call_user_func_array(array(&$this, 'setMapArea'), $mapArea);
  1730.                 $mapArea = $mapArea[1];
  1731.             }
  1732.             if (is_null($mapAreaAction)) {
  1733.                 $mapAreaAction = "{$actionVerb} {$this->uniqueId}";
  1734.             }
  1735.  
  1736.             $this->addMapAreaAction($mapArea, $actionMenu,
  1737.                 $mapAreaAction, $actionVerb,
  1738.                 key($this->mActions[$actionVerb]));
  1739.         }
  1740.     }
  1741.  
  1742.     /**
  1743.      * Removes the given action.
  1744.      *
  1745.      * Removes the action associated to the given $actionVerb. If the action was
  1746.      * linked to an imagemap area, provide the area id with $mapAreaId to
  1747.      * delete this information as well.
  1748.      *
  1749.      * @param      boolean   $actionVerb  alternative command to type
  1750.      * @param      string    $mapAreaId   imagemap area id
  1751.      * @see        addAction, getActionData, getActionsMenu
  1752.      * @since      DutchPIPE 0.2.0
  1753.      */
  1754.     final public function removeAction($actionVerb, $mapAreaId = NULL)
  1755.     {
  1756.         $action_nr = -1;
  1757.         if (isset($this->mActionAliases[$actionVerb])) {
  1758.             $actionVerb = $this->mActionAliases[$actionVerb][0];
  1759.             $action_nr = $this->mActionAliases[$actionVerb][1];
  1760.         }
  1761.  
  1762.         if (isset($this->mActions[$actionVerb])) {
  1763.             if (isset($this->mActions[$actionVerb][$action_nr])) {
  1764.                 $this->_removeAction($actionVerb, $action_nr);
  1765.             }
  1766.             foreach ($this->mActions[$actionVerb] as
  1767.                     $action_nr => &$action_data) {
  1768.                 $this->_removeAction($actionVerb, $action_nr, $mapAreaId);
  1769.             }
  1770.         }
  1771.     }
  1772.  
  1773.     /**
  1774.      * Helper method for removeAction
  1775.      *
  1776.      * @access     private
  1777.      * @param      boolean   $actionVerb  alternative command to type
  1778.      * @param      integer   &$action_nr  index of the verb in alternatives list
  1779.      * @param      string    $mapAreaId   imagemap area id
  1780.      * @see        removeAction
  1781.      * @since      DutchPIPE 0.2.0
  1782.      */
  1783.     private function _removeAction($actionVerb, $actionNr, $mapAreaId = NULL)
  1784.     {
  1785.         $action_data =& $this->mActions[$actionVerb][$actionNr];
  1786.  
  1787.         $map_area_id = $action_data[6];
  1788.         if (is_null($mapAreaId) || (!is_null($map_area_id)
  1789.                 && $mapAreaId === $map_area_id)) {
  1790.             if (!is_null($map_area_id)) {
  1791.                 $this->removeMapAreaAction($map_area_id,
  1792.                     $action_data[0],
  1793.                     $action_data[7]);
  1794.             }
  1795.             unset($this->mActions[$actionVerb][$actionNr]);
  1796.             if (0 === count($this->mActions[$actionVerb])) {
  1797.                 unset($this->mActions[$actionVerb]);
  1798.             }
  1799.         }
  1800.     }
  1801.  
  1802.     /**
  1803.      * Gets data of one, multiple or all actions
  1804.      *
  1805.      * Without arguments, an array is returned with each element of pair
  1806.      * consisting of:
  1807.      * verb => array(menulabel, method, operant, target, authorized, scope)
  1808.      * with operant one of DP_ACTION_OPERANT_, target one of DP_ACTION_TARGET_,
  1809.      * authorized one of DP_ACTION_AUTHORIZED_ and scope one of DP_ACTION_SCOPE_
  1810.      * from dpuniverse/include/actions.php, for example:
  1811.      * 'read' => array('read me!', 'actionRead', DP_ACTION_OPERANT_MENU,
  1812.      *     DP_ACTION_TARGET_SELF, DP_ACTION_AUTHORIZED_ALL, DP_ACTION_SCOPE_ALL)
  1813.      *
  1814.      * You can narrow the result set down by supplying a verb, in which case an
  1815.      * array with one or more results is returned, or FALSE if the given verb is
  1816.      * not defined as an action.
  1817.      *
  1818.      * Narrow it down further by giving a number, usually 0, to get the data at
  1819.      * the index of the array you would get without supplying a number.
  1820.      *
  1821.      * @param      boolean   $actionVerb  alternative command to type
  1822.      * @param      integer   &$actionNr   index of the verb in alternatives list
  1823.      * @return     array     array with actions, can be empty
  1824.      * @see        addAction, removeAction, getActionsMenu
  1825.      * @since      DutchPIPE 0.2.1
  1826.      */
  1827.     final function getActionData($actionVerb = NULL, $actionNr = NULL)
  1828.     {
  1829.         if (is_null($actionVerb)) {
  1830.             return $this->mActions;
  1831.         }
  1832.  
  1833.         if (!isset($this->mActions[$actionVerb])) {
  1834.             return FALSE;
  1835.         }
  1836.  
  1837.         if (is_null($actionNr)) {
  1838.             return $this->mActions[$actionVerb];
  1839.         }
  1840.  
  1841.         if (!isset($this->mActions[$actionVerb][$actionNr])) {
  1842.             return FALSE;
  1843.         }
  1844.  
  1845.         return $this->mActions[$actionVerb][$actionNr];
  1846.     }
  1847.  
  1848.     /**
  1849.      * Tells the current user the HTML with the action menu for this object
  1850.      *
  1851.      * @see        addAction, removeAction, getActionData, getTargettedActions
  1852.      */
  1853.     function getActionsMenu()
  1854.     {
  1855.         /*
  1856.          * A checksum is bounced back so the client can find the right
  1857.          * response
  1858.          */
  1859.         if (!($user = get_current_dpuser())
  1860.                 || !isset($user->_GET['checksum'])) {
  1861.             return;
  1862.         }
  1863.  
  1864.         $user->lastActionTime = !isset($user->lastActionTime)
  1865.             ? new_dp_property(time()) : time();
  1866.  
  1867.         if (!($rval = $this->_getActionsMenuLevels($user))) {
  1868.             return;
  1869.         }
  1870.         list($lvl_titles, $lvl_cnt, $lvl_last_title) = $rval;
  1871.  
  1872.         if (!isset($user->_GET['map_name'])
  1873.                 || !isset($user->_GET['map_area_id'])) {
  1874.             $actions = $this->getTargettedActions($user,
  1875.                 is_null($lvl_last_title) ? NULL : $lvl_titles);
  1876.         } else {
  1877.             $actions = $this->getTargettedActions($user,
  1878.                 (is_null($lvl_last_title) ? NULL : $lvl_titles),
  1879.                 $user->_GET['map_area_id']);
  1880.             /*
  1881.              * For map area actions, when there's only one action, don't show a
  1882.              * menu, but execute action immediately
  1883.              */
  1884.             if (1 === count($actions) && 0 === $lvl_cnt) {
  1885.                 reset($actions);
  1886.                 $user->_GET['menuaction'] = '1';
  1887.                 $user->performAction($actions[key($actions)][0]);
  1888.                 return;
  1889.             }
  1890.         }
  1891.  
  1892.         if (!count($actions)) {
  1893.             return;
  1894.         }
  1895.  
  1896.         $action_menu = '';
  1897.  
  1898.         $icon_used = $submenu_used = FALSE;
  1899.         foreach ($actions as $action_menu_title => &$action_data) {
  1900.             /* If set to FALSE, inserts action into the command line */
  1901.             $get_operant = FALSE;
  1902.             $is_submenu = is_array($action_data) && $action_data[6];
  1903.  
  1904.             $icon = '&nbsp;';
  1905.             $icon_over = FALSE;
  1906.  
  1907.             if (is_array($action_data) && $action_data[4]) {
  1908.                 $icon = $action_data[4];
  1909.                 if ($action_data[5]) {
  1910.                     $icon_over = $action_data[5];
  1911.                 }
  1912.                 $icon_used = TRUE;
  1913.             }
  1914.  
  1915.             list($actionstr, $send_action, $ghosted) =
  1916.                 $this->_getActionsMenuFullAction($action_data, $user);
  1917.  
  1918.             if ((!isset($user->inputMode) || 'say' !== $user->inputMode)
  1919.                     && '' === $actionstr) {
  1920.                 $get_operant = $is_submenu = TRUE;
  1921.             }
  1922.  
  1923.             if (!$ghosted) {
  1924.                 $gstyle = $gdstyle = $gdsstyle = '';
  1925.             } else {
  1926.                 $gstyle = ' am_ghosted';
  1927.                 $gdstyle = ' am_deep_ghosted';
  1928.                 $gdsstyle = ' am_deep_selected_ghosted';
  1929.             }
  1930.  
  1931.             $mouseover = "if (action_over(this)) { ";
  1932.             $add_to_mouseover = '';
  1933.             $mouseout = $mouseclick = '';
  1934.  
  1935.             if (!$lvl_cnt && !$is_submenu) {
  1936.                 $mouseover .= "jQuery('div.am_deep_selected')."
  1937.                     . "removeClass('am_deep_selected am_selected$gdsstyle')";
  1938.                 $add_to_mouseover = '; ';
  1939.             }
  1940.             if (!$is_submenu || $ghosted) {
  1941.                 $mouseout = "am_target_out = this";
  1942.                 $mouseclick = $ghosted ? 'am_no_close = true'
  1943.                     : ((FALSE === $send_action ? 'show_input'
  1944.                     : 'send_action2server') . "('" .
  1945.                     addslashes(htmlspecialchars($actionstr)) . "')");
  1946.             } else {
  1947.                 $submenu_used = TRUE;
  1948.                 $mouseover .= $add_to_mouseover
  1949.                     . "jQuery(this).addClass('am_deep_selected" . $gdsstyle
  1950.                     . "'); " . (isset($user->_GET['map_area_id'])
  1951.                     ? "get_map_area_actions('{$user->_GET['map_name']}', "
  1952.                     . "'{$user->_GET['map_area_id']}', "
  1953.                     : "get_actions(")
  1954.                     . "'{$this->uniqueId}', event, ";
  1955.  
  1956.                 for ($i = 0; $i < $lvl_cnt; $i++) {
  1957.                     $mouseover .= "'"
  1958.                         . addslashes(htmlspecialchars($lvl_titles[$i])) . "', ";
  1959.                 }
  1960.  
  1961.                 $mouseover .= "'"
  1962.                     . addslashes(htmlspecialchars($action_menu_title)) . "')";
  1963.  
  1964.                 $add_to_mouseover = '; ';
  1965.                 $mouseclick = 'am_no_close = true';
  1966.             }
  1967.  
  1968.             if ($icon_over) {
  1969.                 $mouseover .= $add_to_mouseover
  1970.                     . "jQuery('span.am_icon', this).attr('id', "
  1971.                     . "jQuery('span.am_icon > img', this).attr('src')); "
  1972.                     . "jQuery('span.am_icon > img', this).attr('src', "
  1973.                     . "'{$icon_over}')";
  1974.             }
  1975.  
  1976.             $mouseover .= '}';
  1977.  
  1978.             $action_menu .= '<div id="action_menu' . $lvl_cnt . '" '
  1979.                 . 'class="am' . (!$is_submenu ? '' : ' am_deep' . $gdstyle)
  1980.                 . $gstyle . '" onmouseover="' . $mouseover
  1981.                 . '" onmouseout="' . $mouseout
  1982.                 . '" onclick="' . $mouseclick . '">'
  1983.                 . '<span class="AM_ICON" id=' . $icon_over . '>' . $icon
  1984.                 . '</span>'
  1985.                 . '<span class="am_title">' . $action_menu_title . '</span>'
  1986.                 . '<span class="AM_SUBMENU">&nbsp;</span>&nbsp;'
  1987.                 . '<br clear="all" /></div>' . "\n";
  1988.         }
  1989.  
  1990.         $action_menu = str_replace(array('AM_ICON', 'AM_SUBMENU'),
  1991.             array((!$icon_used ? 'am_empty' : 'am_icon'),
  1992.             (!$submenu_used ? 'am_empty2' : 'am_submenu')), $action_menu);
  1993.  
  1994.         $user->tell('<actions id="' . $this->uniqueId
  1995.             . '" level="' . $lvl_cnt . '" checksum="' . $user->_GET['checksum']
  1996.             . '"><div class="actionwindow_inner">' . $action_menu
  1997.             . '</div></actions>');
  1998.     }
  1999.  
  2000.     /**
  2001.      * Gets information about the current trail of menu and submenus
  2002.      *
  2003.      * Used by getActionsMenu.
  2004.      *
  2005.      * @access     private
  2006.      * @param      object    &$user        performer of actions
  2007.      * @return     array     data structure with level info
  2008.      * @see        getActionsMenu
  2009.      * @since      DutchPIPE 0.3.0
  2010.      */
  2011.     private function &_getActionsMenuLevels(&$user)
  2012.     {
  2013.         /*
  2014.          * If the user is navigating to submenus, the client passes each menu
  2015.          * title leading to the submenu, for example:
  2016.          * &l1=foo&l2=bar
  2017.          */
  2018.         $lvl_titles = array();
  2019.         $lvl_cnt = 0;
  2020.         $lvl_last_title = NULL;
  2021.         while (isset($user->_GET['l' . ($lvl_cnt + 1)])) {
  2022.             $lvl_cnt++;
  2023.             $lvl_titles[] = $lvl_last_title = $user->_GET['l' . $lvl_cnt];
  2024.         }
  2025.         $rval = array($lvl_titles, $lvl_cnt, $lvl_last_title);
  2026.  
  2027.         return $rval;
  2028.     }
  2029.  
  2030.     /**
  2031.      * Gets actions which can be performed on this object, for action menu
  2032.      *
  2033.      * Gets an array with actions which can be performed on this object, so
  2034.      * we can make a menu when hovering over the object image with the mouse.
  2035.      * This includes actions that are defined by other objects but appear in
  2036.      * this object's action menu.
  2037.      *
  2038.      * An array is returned, empty if there are no menu actions found, with
  2039.      * key-value pairs. Each key is the (first) menu title associated with the
  2040.      * action pair, each value an array of three elements: the verb, the
  2041.      * "operant" as defined with addAction and a boolean indicating whether this
  2042.      * menu item is ghosted.
  2043.      *
  2044.      * @param      object    &$user      user getting the menu
  2045.      * @param      array     $levels     current path of user in (sub)menu
  2046.      * @param      string    $mapAreaId  id of area in imagemap
  2047.      * @return     array     array with menu actions, can be empty
  2048.      * @see        getActionsMenu
  2049.      */
  2050.     function &getTargettedActions(&$user, $levels = NULL, $mapAreaId = NULL)
  2051.     {
  2052.         /* Gets menu actions on this object defined by this object */
  2053.         $actions = $this->_getTargettedActions($this, $user, $levels,
  2054.             $mapAreaId);
  2055.  
  2056.         /*
  2057.          * Gets menu actions on this object defined by objects in inventory:
  2058.          */
  2059.         $inv = $this->getInventory();
  2060.         foreach ($inv as &$ob) {
  2061.             $actions = array_merge($actions,
  2062.                 $this->_getTargettedActions($ob, $user, $levels, $mapAreaId));
  2063.         }
  2064.  
  2065.         /*
  2066.          * Gets menu actions on this object defined by objects in this
  2067.          * object's environment:
  2068.          */
  2069.         $env = $this->getEnvironment();
  2070.         if (FALSE !== $env) {
  2071.             $inv = $env->getInventory();
  2072.             foreach ($inv as &$ob) {
  2073.                 if ($ob !== $this) {
  2074.                     $actions = array_merge($actions,
  2075.                         $this->_getTargettedActions($ob, $user, $levels,
  2076.                         $mapAreaId));
  2077.                 }
  2078.             }
  2079.  
  2080.             /*
  2081.              * Gets menu actions on this object defined by the object's
  2082.              * environment:
  2083.              */
  2084.             $actions = array_merge($actions,
  2085.                 $this->_getTargettedActions($env, $user, $levels, $mapAreaId));
  2086.         }
  2087.  
  2088.         return $actions;
  2089.     }
  2090.  
  2091.     /**
  2092.      * Gets actions that can be performed on a given object by a given user
  2093.      *
  2094.      * An array is returned with each element a pair consisting of:
  2095.      *     menulabel => array(verb, operant, ghosted)
  2096.      * with operant one of DP_ACTION_OPERANT_ from
  2097.      * dpuniverse/include/actions.php, for example:
  2098.      * 'read me!' => array('read', DP_ACTION_OPERANT_MENU, FALSE)
  2099.      *
  2100.      * @access     private
  2101.      * @param      object    &$ob        target of actions
  2102.      * @param      object    &$user      performer of actions
  2103.      * @param      array     $levels     current path of user in (sub)menu
  2104.      * @param      string    $mapAreaId  id of area in imagemap
  2105.      * @return     array     array with actions, can be empty
  2106.      * @see        getTargettedActions, _checkTargettedAction
  2107.      * @since      DutchPIPE 0.3.0
  2108.      */
  2109.     private function &_getTargettedActions(&$ob, &$user, $levels = NULL,
  2110.             $mapAreaId = NULL)
  2111.     {
  2112.         $ob_actions = is_null($mapAreaId) ? $ob->getActionData()
  2113.             : $ob->getMapAreaActions($mapAreaId);
  2114.  
  2115.         if (FALSE === $ob_actions || !count($ob_actions)) {
  2116.             $ob_actions = array();
  2117.             return $ob_actions;
  2118.         }
  2119.         $t_actions = array();
  2120.  
  2121.         $is_registered = isset($user->isRegistered)
  2122.             && $this->isRegistered === TRUE;
  2123.         $is_admin = isset($user->isAdmin) && $user->isAdmin === TRUE;
  2124.  
  2125.         $level = !is_array($levels) ? 0 : count($levels);
  2126.         if (is_null($mapAreaId)) {
  2127.             foreach ($ob_actions as $verb => &$a_d) {
  2128.                 foreach ($a_d as $action_data) {
  2129.                     if (FALSE === $this->_addTargettedAction($t_actions,
  2130.                             $verb, $action_data, $ob, $user, $level, $levels,
  2131.                             $is_registered, $is_admin)) {
  2132.                         continue;
  2133.                     }
  2134.                 }
  2135.             }
  2136.         } else {
  2137.             foreach ($ob_actions as $action_data) {
  2138.                 if (FALSE === $this->_addTargettedAction($t_actions, NULL,
  2139.                         $action_data, $ob, $user, $level, $levels,
  2140.                         $is_registered, $is_admin)) {
  2141.                     continue;
  2142.                 }
  2143.             }
  2144.         }
  2145.         return $t_actions;
  2146.     }
  2147.  
  2148.     /**
  2149.      * Adds action that can be performed on a given object by a given user
  2150.      *
  2151.      * Used by _getTargettedActions.
  2152.      *
  2153.      * @access     private
  2154.      * @param      array     &$t_actions   targetted actions found so far
  2155.      * @param      string    $verb         associated verb for this action
  2156.      * @param      array     &$actionData  complete action data
  2157.      * @param      object    &$ob          target of actions
  2158.      * @param      object    &$user        performer of actions
  2159.      * @param      integer   $level        submenu level, starts at 0
  2160.      * @param      array     $levels       sublevel titles
  2161.      * @param      boolean   $isRegistered is performer a registered user?
  2162.      * @param      boolean   $isAdmin      is performer an administrator?
  2163.      * @return     array     array with actions, can be empty
  2164.      * @see        _getTargettedActions
  2165.      * @since      DutchPIPE 0.3.0
  2166.      */
  2167.     private function _addTargettedAction(&$t_actions, $verb, &$actionData,
  2168.             &$ob, &$user, $level, &$levels, $isRegistered, $isAdmin)
  2169.     {
  2170.         $get_operant = FALSE;
  2171.         $add_operant = 0;
  2172.         $verb_data = $operant = NULL;
  2173.  
  2174.         $is_map_area = is_null($verb);
  2175.         if (1 || $level) {
  2176.             if ($is_map_area) {
  2177.                 if (!is_null($actionData[2]) && !is_null($actionData[3])) {
  2178.                     $verb_data = $ob->getActionData($actionData[2],
  2179.                         $actionData[3]);
  2180.                     $operant = $verb_data[2];
  2181.                     $verb = $verb_data[2];
  2182.                 } else {
  2183.                     $operant = <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_OPERANT_MENU">DP_ACTION_OPERANT_MENU</a>;
  2184.                     $verb = $actionData[1];
  2185.                 }
  2186.             } else {
  2187.                 $operant = $actionData[2];
  2188.             }
  2189.  
  2190.             parse_dp_callable($actionData[0], $verb, $this, $ob, $user);
  2191.  
  2192.             if (is_array($operant) && 2 === count($operant)
  2193.                     && is_object($operant[0])) {
  2194.                 $operant = $operant[0]->{$operant[1]}($verb, $this, $ob,
  2195.                     $user);
  2196.             } elseif (DP_ACTION_OPERANT_METHOD === $operant) {
  2197.                 $operant = $this->getActionOperant($verb, $this, $ob,
  2198.                     $user);
  2199.             }
  2200.             if (is_array($operant) ||
  2201.                     DP_ACTION_OPERANT_METHOD_MENU === $operant) {
  2202.                 $get_operant = TRUE;
  2203.                 $add_operant = 1;
  2204.                 if (is_array($actionData[0]) && count($actionData[0])
  2205.                         < $level - $add_operant) {
  2206.                     return FALSE;
  2207.                 }
  2208.             } elseif (is_array($actionData[0])
  2209.                     && count($actionData[0]) < $level) {
  2210.                 return FALSE;
  2211.             }
  2212.  
  2213.             for ($i = 0; $i < $level; $i++) {
  2214.                 $action_menu_title = !is_array($actionData[0])
  2215.                     ? $actionData[0] : $actionData[0][$i];
  2216.                 if (FALSE !== ($pos = dp_strrpos($action_menu_title, '#'))) {
  2217.                     $action_menu_title = dp_substr($action_menu_title,
  2218.                         $pos + 1);
  2219.                 }
  2220.  
  2221.                 if (!is_array($actionData[0])) {
  2222.                     if (0 === $i && $levels[0] === $action_menu_title) {
  2223.                         continue;
  2224.                     }
  2225.                     return FALSE;
  2226.                 }
  2227.                 if ($levels[$i] <> $action_menu_title) {
  2228.                     return FALSE;
  2229.                 }
  2230.             }
  2231.         }
  2232.  
  2233.         $ghosted = FALSE;
  2234.         if (!$is_map_area) {
  2235.             if (FALSE ===
  2236.                     $this->_checkTargettedAction($verb, $actionData, $ob,
  2237.                     $user, $isRegistered, $isAdmin)) {
  2238.                 return FALSE;
  2239.             }
  2240.             parse_dp_callable($actionData[4], $verb, $this, $ob, $user);
  2241.             $ghosted = <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_AUTHORIZED_DISABLED">DP_ACTION_AUTHORIZED_DISABLED</a> & $actionData[4];
  2242.         } else {
  2243.             if (!is_null($actionData[2]) && !is_null($actionData[3])) {
  2244.                 if (is_null($verb_data)) {
  2245.                     $verb_data = $ob->getActionData($actionData[2],
  2246.                         $actionData[3]);
  2247.                 }
  2248.  
  2249.                 if (!$get_operant && FALSE === $this->_checkTargettedAction(
  2250.                         $actionData[2], $verb_data, $ob, $user, $isRegistered,
  2251.                         $isAdmin)) {
  2252.                     return FALSE;
  2253.                 }
  2254.                 if (is_array($verb_data)) {
  2255.                     parse_dp_callable($verb_data[4], $verb, $this, $ob, $user);
  2256.                     $ghosted = <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_AUTHORIZED_DISABLED">DP_ACTION_AUTHORIZED_DISABLED</a> & $verb_data[4];
  2257.                 }
  2258.             }
  2259.         }
  2260.  
  2261.         if (!$get_operant || $ghosted || ($level < (!is_array($actionData[0])
  2262.                 ? 1 : count($actionData[0])))) {
  2263.             $titles =& $actionData[0];
  2264.             if (is_string($titles)) {
  2265.                 $title = $titles;
  2266.             } elseif (is_array($titles)) {
  2267.                 if (2 !== count($titles) || !is_object($titles[0])) {
  2268.                     parse_dp_callable($titles[$level], $verb, $this,
  2269.                         $ob, $user);
  2270.                 } else {
  2271.                     parse_dp_callable($titles, $verb, $this, $ob,
  2272.                         $user);
  2273.                 }
  2274.  
  2275.                 $title = !is_array($titles) ? $titles : $titles[$level];
  2276.             } else {
  2277.                 return FALSE;
  2278.             }
  2279.  
  2280.             $icon = $icon_over = FALSE;
  2281.             if (FALSE !== dp_strpos($title, '#')) {
  2282.                 $tmp = explode('#', $title);
  2283.                 if (2 == count($tmp)) {
  2284.                     $icon = $tmp[0];
  2285.                     $title = $tmp[1];
  2286.                 } elseif (3 == count($tmp)) {
  2287.                     $icon = $tmp[0];
  2288.                     $icon_over = $tmp[1];
  2289.                     $title = $tmp[2];
  2290.                 }
  2291.             }
  2292.  
  2293.             $cnt = !is_array($titles) ? 1 : count($titles);
  2294.             $is_submenu = $cnt > $level + 1
  2295.                 - ($ghosted && $level + 1 === $cnt ? 0 : $add_operant);
  2296.  
  2297.             $data = !$is_map_area
  2298.                 ? array($verb, $actionData[2], $ghosted, $ob, $icon,
  2299.                     $icon_over, $is_submenu)
  2300.                 : array($actionData[1], (is_null($verb_data)
  2301.                     ? <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_OPERANT_MENU">DP_ACTION_OPERANT_MENU</a> : $verb_data[2]), $ghosted, $ob,
  2302.                     $icon, $icon_over, $is_submenu);
  2303.  
  2304.             $t_actions[$title] = $data;
  2305.         } elseif ($get_operant) {
  2306.             if (is_array($operant) && 2 === count($operant)
  2307.                     && is_object($operant[0])) {
  2308.                 $data = $operant[0]->{$operant[1]}($verb, $this, $ob,
  2309.                     $user);
  2310.             } elseif (DP_ACTION_OPERANT_METHOD_MENU === $operant) {
  2311.                 $data = $ob->getActionOperantMenu($verb, $this, $ob,
  2312.                     $user);
  2313.             }
  2314.             if ($data && is_array($data)) {
  2315.                 $t_actions += $data;
  2316.             }
  2317.         }
  2318.  
  2319.         return TRUE;
  2320.     }
  2321.  
  2322. /**    
  2323.      * Checks if an action can be included in an action menu
  2324.      *
  2325.      * Processes DP_ACTION_TARGET_, DP_ACTION_SCOPE_ and DP_ACTION_AUTHORIZED_
  2326.      * directives of the action.
  2327.      *
  2328.      * @access     private
  2329.      * @param      string    $verb          associated verb for this action
  2330.      * @param      array     &$actionData   complete action data
  2331.      * @param      object    &$ob           target of actions
  2332.      * @param      object    &$user         performer of actions
  2333.      * @param      boolean   $isRegistered  is performer a registered user?
  2334.      * @param      boolean   $isAdmin       is performer an administrator?
  2335.      * @return     boolean   TRUE to include action, FALSE to exclude
  2336.      * @see        getTargettedActions, _getTargettedActions
  2337.      * @since      DutchPIPE 0.2.1
  2338.      */
  2339.     private function _checkTargettedAction($verb, &$actionData, &$ob, &$user,
  2340.             $isRegistered = FALSE, $isAdmin = FALSE)
  2341.     {
  2342.         $target =& $actionData[3];
  2343.         parse_dp_callable($target, $verb, $this, $ob, $user);
  2344.  
  2345.         if (is_array($target) && 2 === count($target) && isset($target[0])
  2346.                 && is_object($target[0]) && isset($target[1])
  2347.                 && is_integer($target[1])) {
  2348.             $ob =& $target[0];
  2349.             $target = $target[1];
  2350.         }
  2351.  
  2352.         if ($target === <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_TARGET_NONE">DP_ACTION_TARGET_NONE</a>) {
  2353.             return FALSE;
  2354.         }
  2355.  
  2356.         $compare = 0;
  2357.  
  2358.         if ($ob === $this) {
  2359.             $compare = $compare | <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_TARGET_SELF">DP_ACTION_TARGET_SELF</a>;
  2360.         } else {
  2361.             if (isset($this->isLiving) && TRUE === $this->isLiving) {
  2362.                 $compare = $compare | <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_TARGET_LIVING">DP_ACTION_TARGET_LIVING</a>;
  2363.  
  2364.                 if (isset($this->isUser) && TRUE === $this->isUser) {
  2365.                     $compare = $compare | <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_TARGET_USER">DP_ACTION_TARGET_USER</a>;
  2366.                 }
  2367.             } elseif (FALSE !== ($this_env = $this->getEnvironment())
  2368.                     && FALSE !== ($ob_env = $ob->getEnvironment())
  2369.                     && $this_env === $ob_env) {
  2370.                 $compare = $compare | <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_TARGET_OBJENV">DP_ACTION_TARGET_OBJENV</a>;
  2371.             } elseif (FALSE !== ($this_env = $this->getEnvironment())
  2372.                     && $this_env === $ob) {
  2373.                 $compare = $compare | <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_TARGET_OBJINV">DP_ACTION_TARGET_OBJINV</a>;
  2374.             }
  2375.         }
  2376.  
  2377.         if (!($target & $compare)) {
  2378.             return FALSE;
  2379.         }
  2380.  
  2381.         $scope =& $actionData[5];
  2382.         parse_dp_callable($scope, $verb, $this, $ob, $user);
  2383.  
  2384.         if (is_array($scope) && 2 === count($scope) && isset($scope[0])
  2385.                 && is_object($scope[0]) && isset($scope[1])
  2386.                 && is_integer($scope[1])) {
  2387.             $ob =& $scope[0];
  2388.             $scope = $scope[1];
  2389.         }
  2390.  
  2391.         if ($scope & <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_SCOPE_SELF">DP_ACTION_SCOPE_SELF</a>) {
  2392.             if ($user !== $ob) {
  2393.                 return FALSE;
  2394.             }
  2395.         }
  2396.         if ($scope & <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_SCOPE_INVENTORY">DP_ACTION_SCOPE_INVENTORY</a>) {
  2397.             if ($user->getEnvironment() !== $ob) {
  2398.                 return FALSE;
  2399.             }
  2400.         }
  2401.         if ($scope & <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_SCOPE_ENVIRONMENT">DP_ACTION_SCOPE_ENVIRONMENT</a>) {
  2402.             if ($user->getEnvironment() !== $ob->getEnvironment()) {
  2403.                 return FALSE;
  2404.             }
  2405.         }
  2406.  
  2407.         $auth =& $actionData[4];
  2408.         parse_dp_callable($auth, $verb, $this, $ob, $user);
  2409.  
  2410.         if ($auth & <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_AUTHORIZED_GUEST">DP_ACTION_AUTHORIZED_GUEST</a>) {
  2411.             if (TRUE === $isRegistered) {
  2412.                 return FALSE;
  2413.             }
  2414.         } elseif ($auth & <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_AUTHORIZED_REGISTERED">DP_ACTION_AUTHORIZED_REGISTERED</a>) {
  2415.             if (TRUE !== $isRegistered) {
  2416.                 return FALSE;
  2417.             }
  2418.         } elseif ($auth & <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_AUTHORIZED_ADMIN">DP_ACTION_AUTHORIZED_ADMIN</a>) {
  2419.             if (TRUE !== $isAdmin) {
  2420.                 return FALSE;
  2421.             }
  2422.         }
  2423.  
  2424.         return TRUE;
  2425.     }
  2426.  
  2427. /**    
  2428.      * Gets the full action string for an action and some other data
  2429.      *
  2430.      * Used by getActionsMenu.
  2431.      *
  2432.      * @access     private
  2433.      * @param      array     &$actionData   action data array
  2434.      * @param      object    &$user          performer of actions
  2435.      * @return     array     data structure with action info
  2436.      * @see        getActionsMenu
  2437.      * @since      DutchPIPE 0.3.0
  2438.      */
  2439.     private function _getActionsMenuFullAction(&$actionData, $user)
  2440.     {
  2441.         $send_action = TRUE;
  2442.         $is_submenu = is_array($actionData) && $actionData[6];
  2443.         $gstyle = $gdstyle = $gdsstyle = '';
  2444.         $ghosted = FALSE;
  2445.  
  2446.         if (!$is_submenu && is_array($actionData)) {
  2447.             $action = $actionData[0];
  2448.             $operant = $actionData[1];
  2449.             $ghosted = $actionData[2];
  2450.             $defined_by = $actionData[3];
  2451.             if ($ghosted) {
  2452.                 $actionstr = '';
  2453.             } else {
  2454.                 if (is_array($operant) && 2 === count($operant)
  2455.                         && is_object($operant[0])) {
  2456.                     $operant = $operant[0]->{$operant[1]}($action, $this,
  2457.                         $defined_by, $user);
  2458.                 } elseif (DP_ACTION_OPERANT_METHOD === $operant) {
  2459.                     $operant = $this->getActionOperant($action, $this,
  2460.                         $defined_by, $user);
  2461.                 }
  2462.                 if (is_array($operant) ||
  2463.                         DP_ACTION_OPERANT_METHOD_MENU === $operant) {
  2464.                     $actionstr = '';
  2465.                 } elseif (<a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_OPERANT_MENU">DP_ACTION_OPERANT_MENU</a> === $operant) {
  2466.                     $actionstr = isset($user->_GET['map_area_id']) ? $action
  2467.                         : $action . ' ' . $this->uniqueId;
  2468.                 } elseif (<a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_OPERANT_NONE">DP_ACTION_OPERANT_NONE</a> === $operant) {
  2469.                     $actionstr = $action;
  2470.                 } elseif (is_string($operant)) {
  2471.                     $actionstr = $action . ' ' . $operant;
  2472.                     if (dp_strlen($actionstr)
  2473.                             && ' ' === dp_substr($actionstr, -1)) {
  2474.                         if (isset($user->inputMode)
  2475.                                 && 'say' === $user->inputMode
  2476.                                 && dp_text('say') !== $action) {
  2477.                             $actionstr = '/' . $actionstr;
  2478.                         }
  2479.                         $send_action = FALSE;
  2480.                     }
  2481.                 } else {
  2482.                     /* DP_ACTION_OPERANT_COMPLETE */
  2483.                     $actionstr = $action . ' ';
  2484.                     if (isset($user->inputMode) && 'say' === $user->inputMode) {
  2485.                         $actionstr = dp_text('say') === $action ? ''
  2486.                             : '/' . $actionstr;
  2487.                     }
  2488.                     $send_action = FALSE;
  2489.                 }
  2490.             }
  2491.         } else {
  2492.             $actionstr = is_string($actionData) ? $actionData : '';
  2493.         }
  2494.  
  2495.         return array($actionstr, $send_action, $ghosted, $gstyle, $gdstyle,
  2496.             $gdsstyle);
  2497.     }
  2498.  
  2499. /**    
  2500.      * Creates a new imagemap area which can be used by actions
  2501.      *
  2502.      * Creates an area for the imagemap $mapName. Make sure the right <map> and
  2503.      * <area> HTML is included when this object is viewed. The image should have
  2504.      * the following tag:
  2505.      *     usemap="#<map name>"
  2506.      *
  2507.      * The id given with $mapAreaId can be used by others methods, such as
  2508.      * addItem or addAction to refer to this area.
  2509.      *
  2510.      * The shape of the imagemap given with $mapAreaShape is one of:
  2511.      *     circle, poly, rect
  2512.      * See your HTML reference for a full explanation of these types.
  2513.      *
  2514.      * The coordinates of the shape should be given with $mapAreaCoords, for
  2515.      * example, the coordinates for a rectangle:
  2516.      *     128,132,241,179
  2517.      * See your HTML reference for a full explanation about coordinates.
  2518.      *
  2519.      * An optional tooltip can be shown when hovering over this area with the
  2520.      * mouse with $mapAreaAlt.
  2521.      *
  2522.      * @param      string    $mapName        name of imagemap
  2523.      * @param      string    $mapAreaId      id of area in this map
  2524.      * @param      string    $mapAreaShape   cirlce, poly, rect
  2525.      * @param      string    $mapAreaCoords  x,y,... (depends on shape)
  2526.      * @param      string    $mapAreaAlt     mouse tooltip for this area
  2527.      * @see        getMapArea, addMapAreaAction, removeMapAreaAction,
  2528.      *              getMapAreaActions, getMapAreaHtml, getActionsMenu
  2529.      * @since      DutchPIPE 0.2.0
  2530.      */
  2531.     function setMapArea($mapName, $mapAreaId, $mapAreaShape, $mapAreaCoords,
  2532.             $mapAreaAlt = '')
  2533.     {
  2534.         if (!isset($this->mMapAreas[$mapName])) {
  2535.             $this->mMapAreas[$mapName] = array();
  2536.         }
  2537.         $this->mMapAreas[$mapName][$mapAreaId] =
  2538.             array($mapAreaShape, $mapAreaCoords, $mapAreaAlt);
  2539.     }
  2540.  
  2541. /**    
  2542.      * Gets data of one, multiple or all imagemap areas
  2543.      *
  2544.      * If no arguments are given data of all imagemap areas is returned. If an
  2545.      * imagemap name is given, all data for that map is returned, or FALSE if
  2546.      * the imagemap is not defined. If both the map name and an id of the area
  2547.      * in the map are given, data for that area is returned, or FALSE if not
  2548.      * defined.
  2549.      *
  2550.      * @param      string    $mapName    name of imagemap
  2551.      * @param      string    $mapAreaId  id of area in imagemap
  2552.      * @return     mixed     array with imagemap areas, can be empty, or FALSE
  2553.      * @see        setMapArea, addMapAreaAction, removeMapAreaAction,
  2554.      *              getMapAreaActions, getMapAreaHtml, getActionsMenu
  2555.      * @since      DutchPIPE 0.2.0
  2556.      */
  2557.     function getMapArea($mapName = NULL, $mapAreaId = NULL)
  2558.     {
  2559.         if (is_null($mapName)) {
  2560.             return $this->mMapAreas;
  2561.         }
  2562.  
  2563.         if (is_null($mapAreaId)) {
  2564.             return !isset($this->mMapAreas[$mapName]) ? FALSE
  2565.                 : $this->mMapAreas[$mapName];
  2566.         }
  2567.  
  2568.         return !isset($this->mMapAreas[$mapName])
  2569.             || !isset($this->mMapAreas[$mapName][$mapAreaId]) ? FALSE
  2570.             : $this->mMapAreas[$mapName][$mapAreaId];
  2571.     }
  2572.  
  2573. /**    
  2574.      * Adds an action to a map area so it becomes clickable there
  2575.      *
  2576.      * Creates a menu item labelled $actionMenuTitle on the imagemap area with
  2577.      * id $mapAreaId. When clicked, executes $action for that user.
  2578.      *
  2579.      * Can optionally be associated with an existing action by giving an
  2580.      * $actionVerb and $actionVerbKey. Normal map area menu actions always
  2581.      * appear. By associating it to a regular action, all its settings such as
  2582.      * scope, target and authorization are used. Use addAction to set up such
  2583.      * a map area action, as addAction will call addMapAreaAction with the right
  2584.      * verb and verb key (a verb key is needed because there can be multiple
  2585.      * indentical verbs).
  2586.  
  2587.      * @param      string    $mapAreaId        id of area in imagemap
  2588.      * @param      string    $actionMenuTitle  title of menu item
  2589.      * @param      string    $action           action executed when clicked
  2590.      * @param      string    $actionVerb       optional associated verb
  2591.      * @param      string    $actionVerbKey    optional index of this verb
  2592.      * @see        setMapArea, getMapArea, removeMapAreaAction,
  2593.      8             getMapAreaActions, getMapAreaHtml, getActionsMenu
  2594.      * @since      DutchPIPE 0.2.0
  2595.      */
  2596.     function addMapAreaAction($mapAreaId, $actionMenuTitle, $action,
  2597.             $actionVerb = NULL, $actionVerbKey = NULL)
  2598.     {
  2599.         if (!isset($this->mMapAreaActions[$mapAreaId])) {
  2600.             $this->mMapAreaActions[$mapAreaId] = array();
  2601.         }
  2602.         $new_area_data = array($actionMenuTitle, $action, $actionVerb,
  2603.             $actionVerbKey);
  2604.         foreach ($this->mMapAreaActions[$mapAreaId] as $area_data) {
  2605.             if ($area_data === $new_area_data) {
  2606.                 return;
  2607.             }
  2608.         }
  2609.  
  2610.         $this->mMapAreaActions[$mapAreaId][] = $new_area_data;
  2611.     }
  2612.  
  2613. /**    
  2614.      * Removes a map area action
  2615.      *
  2616.      * Either 1) the action menu title, 2) the executed action string when
  2617.      * clicked (while the title is NULL) or 3) both can be given. Removes the
  2618.      * first found match.
  2619.      *
  2620.      * @param      string    $mapAreaId        id of area in imagemap
  2621.      * @param      string    $actionMenuTitle  title of menu item
  2622.      * @param      string    $action           action executed when clicked
  2623.      * @see        setMapArea, getMapArea, addMapAreaAction, getMapAreaActions,
  2624.      *              getMapAreaHtml, getActionsMenu
  2625.      * @since      DutchPIPE 0.2.0
  2626.      */
  2627.     function removeMapAreaAction($mapAreaId, $actionMenuTitle, $action = NULL)
  2628.     {
  2629.         if (!isset($this->mMapAreaActions[$mapAreaId])
  2630.                 || (is_null($actionMenuTitle) && is_null($action))) {
  2631.             return;
  2632.         }
  2633.  
  2634.         foreach ($this->mMapAreaActions[$mapAreaId] as $i => &$area_data) {
  2635.             if ((is_null($actionMenuTitle)
  2636.                     || $area_data[0] === $actionMenuTitle)
  2637.                     && (is_null($action) || $area_data[1] === $action)) {
  2638.                 unset($this->mMapAreaActions[$mapAreaId][$i]);
  2639.                 return;
  2640.             }
  2641.         }
  2642.     }
  2643.  
  2644. /**    
  2645.      * Gets all map area actions for all areas or for a given area
  2646.      *
  2647.      * @param      string    $mapAreaId  id of area in imagemap
  2648.      * @return     array     array with map area data, can be empty
  2649.      * @see        setMapArea, getMapArea, addMapAreaAction,
  2650.      *              removeMapAreaAction, getMapAreaHtml, getActionsMenu
  2651.      * @since      DutchPIPE 0.2.0
  2652.      */
  2653.     function getMapAreaActions($mapAreaId = NULL)
  2654.     {
  2655.         if (is_null($mapAreaId)) {
  2656.             return $this->mMapAreaActions;
  2657.         }
  2658.  
  2659.         return !isset($this->mMapAreaActions[$mapAreaId]) ? FALSE
  2660.             : $this->mMapAreaActions[$mapAreaId];
  2661.     }
  2662.  
  2663. /**    
  2664.      * Gets HTML for all imagemaps or the given imagemap for inclusion in page
  2665.      *
  2666.      * Constructs the right HTML with <map> and <area> tags and onclick events.
  2667.      * Returns an empty string of no map data was found. Used by getBody.
  2668.      *
  2669.      * @param      string    $mapName        name of imagemap
  2670.      * @return     string    HTML for one or more imagemaps, or empty string.
  2671.      * @see        getBody, setMapArea, getMapArea, addMapAreaAction,
  2672.      *              removeMapAreaAction, getMapAreaActions, getActionsMenu
  2673.      * @since      DutchPIPE 0.2.0
  2674.      */
  2675.     function getMapAreaHtml($mapName = NULL)
  2676.     {
  2677.         if (is_null($mapName)) {
  2678.             $rval = '';
  2679.             $map_names = array_keys($this->mMapAreas);
  2680.             foreach ($map_names as $map_name) {
  2681.                 $rval .= $this->getMapAreaHtml($map_name);
  2682.             }
  2683.  
  2684.             return $rval;
  2685.         }
  2686.  
  2687.         if (!isset($this->mMapAreas[$mapName])) {
  2688.             return '';
  2689.         }
  2690.  
  2691.  
  2692.         $rval = "<map name=\"{$mapName}\">\n";
  2693.         foreach ($this->mMapAreas[$mapName] as
  2694.                 $map_area_id => &$map_area_data) {
  2695.             $actions = $this->getMapAreaActions($map_area_id);
  2696.             $nr_of_actions = count($actions);
  2697.             if (0 === $nr_of_actions) {
  2698.                 $alt = '';
  2699.             } elseif (1 === $nr_of_actions) {
  2700.                 reset($actions);
  2701.                 $action = current($actions);
  2702.                 $alt = $action[0];
  2703.             } else {
  2704.                 $alt = dp_text('Click for menu');
  2705.             }
  2706.             $rval .= "<area shape=\"{$map_area_data[0]}\" "
  2707.                 . "coords=\"{$map_area_data[1]}}\" "
  2708.                 . "href=\"javascript:void(0)\" "
  2709.                 . "alt=\"{$alt}\" title=\"{$alt}\" "
  2710.                 . "onclick=\"get_map_area_actions('{$mapName}', "
  2711.                 . "'{$map_area_id}', '{$this->uniqueId}', event)\" "
  2712.                 . "style=\"cursor: pointer\" />\n";
  2713.         }
  2714.         $rval .= '</map>';
  2715.  
  2716.         return $rval;
  2717.     }
  2718.  
  2719. /**    
  2720.      * Tries if a user action can be performed on this object
  2721.      *
  2722.      * When a user doesn't use the action menu, but gives a command such as
  2723.      * 'take beer', or when an NPC performs an action, the system doesn't know
  2724.      * which object defines the action. Therefore, it calls this method in all
  2725.      * objects which are eligable to perform this action. Objects are searched
  2726.      * for, in this order, in the object performing the action, its inventory,
  2727.      * in its environment, and the environment itself.
  2728.      *
  2729.      * performActionSubject returns TRUE if the action was completed by this
  2730.      * object, or FALSE if this action was not directed at this object, in which
  2731.      * case the system will try the next object, if any.
  2732.      *
  2733.      * @param      string    $action     the complete input string
  2734.      * @param      object    &$living    user or npc performing the action
  2735.      * @return     boolean   TRUE for action completed, FALSE otherwise
  2736.      */
  2737.     final public function performActionSubject($action, &$living)
  2738.     {
  2739.         if (dp_strlen($action) >= 1 && dp_substr($action, 0, 1) == "'") {
  2740.             $say = dp_text('say');
  2741.             $action = dp_strlen($action) == 1 ? $say : $say . ' '
  2742.                 . dp_substr($action, 1);
  2743.         } elseif (dp_strlen($action) >= 1 && dp_substr($action, 0, 1) == '"') {
  2744.             $tell = dp_text('tell');
  2745.             $action = dp_strlen($action) == 1 ? $tell : $tell . ' '
  2746.                 . dp_substr($action, 1);
  2747.         }
  2748.  
  2749.         if (FALSE !== ($x = dp_strpos($action, ' '))) {
  2750.             $verb = dp_substr($action, 0, $x);
  2751.             $noun = trim(dp_substr($action, $x));
  2752.             if (!dp_strlen($noun)) {
  2753.                 $noun = null;
  2754.             }
  2755.         } else {
  2756.             $verb = trim($action);
  2757.             $noun = null;
  2758.         }
  2759.  
  2760.         if (isset($this->isLiving) && TRUE === $this->isLiving
  2761.                 && $living === $this) {
  2762.             /* Try inventory and environment */
  2763.             $inv = $this->getInventory();
  2764.             foreach ($inv as &$ob) {
  2765.                 if (TRUE === (bool)$ob->performActionSubject($action,
  2766.                         $living)) {
  2767.                     return TRUE;
  2768.                 }
  2769.             }
  2770.             $env = $this->getEnvironment();
  2771.             $inv = $env->getInventory();
  2772.             foreach ($inv as &$ob) {
  2773.                 if ($ob !== $this && TRUE ===
  2774.                         (bool)$ob->performActionSubject($action, $living)) {
  2775.                     return TRUE;
  2776.                 }
  2777.             }
  2778.             if ((boolean)$env->performActionSubject($action, $living)) {
  2779.                 return TRUE;
  2780.             }
  2781.         }
  2782.  
  2783.         $is_phrase = FALSE;
  2784.  
  2785.         if (isset($this->mActions[$verb])) {
  2786.             reset($this->mActions[$verb]);
  2787.             $action_data = $this->mActions[$verb][key($this->mActions[$verb])];
  2788.         } elseif (isset($this->mActions[$action])) {
  2789.             $is_phrase = TRUE;
  2790.             reset($this->mActions[$verb]);
  2791.             $action_data = $this->mActions[$action]
  2792.                 [key($this->mActions[$verb])];
  2793.         } elseif (isset($this->mActionAliases[$verb])) {
  2794.             reset($this->mActionAliases[$verb]);
  2795.             $alias =& $this->mActionAliases[$verb]
  2796.                 [key($this->mActionAliases[$verb])];
  2797.             $action_data = $this->mActions[$alias[0]][$alias[1]];
  2798.         } elseif (isset($this->mActionAliases[$action])) {
  2799.             $is_phrase = TRUE;
  2800.             reset($this->mActionAliases[$verb]);
  2801.             $alias =& $this->mActionAliases[$action]
  2802.                 [key($this->mActionAliases[$verb])];
  2803.             $action_data = $this->mActions[$alias[0]][$alias[1]];
  2804.         } else {
  2805.             return FALSE;
  2806.         }
  2807.  
  2808.         $scope =& $action_data[5];
  2809.         parse_dp_callable($scope, $verb, NULL, $this, $living);
  2810.  
  2811.         if ($scope & <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_SCOPE_SELF">DP_ACTION_SCOPE_SELF</a>) {
  2812.             if ($living !== $this) {
  2813.                 return FALSE;
  2814.             }
  2815.         }
  2816.         if ($scope & <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_SCOPE_INVENTORY">DP_ACTION_SCOPE_INVENTORY</a>) {
  2817.             if ($living->getEnvironment() !== $this) {
  2818.                 return FALSE;
  2819.             }
  2820.         }
  2821.         if ($scope & <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_SCOPE_ENVIRONMENT">DP_ACTION_SCOPE_ENVIRONMENT</a>) {
  2822.             if ($living->getEnvironment() !== $this->getEnvironment()) {
  2823.                 return FALSE;
  2824.             }
  2825.         }
  2826.  
  2827.         $auth =& $action_data[4];
  2828.         parse_dp_callable($auth, $verb, NULL, $this, $living);
  2829.  
  2830.         if ($auth === <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_AUTHORIZED_GUEST">DP_ACTION_AUTHORIZED_GUEST</a>) {
  2831.             if (TRUE === $living->isRegistered) {
  2832.                 return FALSE;
  2833.             }
  2834.         } elseif ($auth === <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_AUTHORIZED_REGISTERED">DP_ACTION_AUTHORIZED_REGISTERED</a>) {
  2835.             if (TRUE !== $living->isRegistered) {
  2836.                 return FALSE;
  2837.             }
  2838.         } elseif ($auth === <a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---actions.php.html#defineDP_ACTION_AUTHORIZED_ADMIN">DP_ACTION_AUTHORIZED_ADMIN</a>) {
  2839.             if (TRUE !== $living->isAdmin) {
  2840.                 return FALSE;
  2841.             }
  2842.         }
  2843.  
  2844.         if (!is_dp_callable($action_data[1])) {
  2845.             $call_obj =& $this;
  2846.             $call_method = $action_data[1];
  2847.         } else {
  2848.             $call_obj =& $action_data[1][0];
  2849.             $call_method = $action_data[1][1];
  2850.         }
  2851.  
  2852.         return method_exists($call_obj, $call_method) &&
  2853.             (bool)$call_obj->{$call_method}(!$is_phrase ? $verb : $action,
  2854.             $noun);
  2855.     }
  2856.  
  2857. /**    
  2858.      * Reports an event
  2859.      *
  2860.      * Called when certain events occur, given with $name. The property
  2861.      * lastEventTime is set to a unix time stamp. Calls eventDpObject.
  2862.      *
  2863.      * @param      object    $name       Name of event
  2864.      * @param      mixed     $args       One or more arguments, depends on event
  2865.      */
  2866.     final function event($name)
  2867.     {
  2868.         $this->lastEventTime = time();
  2869.         $args = func_get_args();
  2870.         call_user_func_array(array($this, 'eventDpObject'), $args);
  2871.     }
  2872.  
  2873. /**    
  2874.      * Reports an event
  2875.      *
  2876.      * Called when certain events occur, given with $name.
  2877.      *
  2878.      * @param      object    $name       Name of event
  2879.      * @param      mixed     $args       One or more arguments, depends on event
  2880.      * @since      DutchPIPE 0.2.0
  2881.      */
  2882.     function eventDpObject($name)
  2883.     {
  2884.     }
  2885.  
  2886. /**    
  2887.      * Called by the universe object, checks if this object can be removed.
  2888.      *
  2889.      * To save some memory, the universe object will call this method in objects
  2890.      * with no environment, which haven't been referenced for a while.
  2891.      *
  2892.      * If no users or special object using the isNoCleanUp property are present,
  2893.      * the object and all of its inventory is destroyed.
  2894.      *
  2895.      * @since      DutchPIPE 0.2.0
  2896.      */
  2897.     function handleCleanUp()
  2898.     {
  2899.         foreach ($this->mCheckPresentObjects as $i => &$ob) {
  2900.             if ($ob->getEnvironment() !== $this) {
  2901.                 echo sprintf(
  2902.                     dp_text("handleCleanUp() called in %s: not removed",
  2903.                     $this->title));
  2904.                 return;
  2905.             }
  2906.         }
  2907.  
  2908.         $inv = $this->getInventory();
  2909.         foreach ($inv as &$ob) {
  2910.             if ($ob->isUser || $ob->isNoCleanUp) {
  2911.                 echo sprintf(
  2912.                     dp_text("handleCleanUp() called in %s: not removed",
  2913.                     $this->title));
  2914.                 return;
  2915.             }
  2916.         }
  2917.  
  2918.         echo sprintf(dp_text("handleCleanUp() called in %s: removing\n",
  2919.             $this->title));
  2920.         $this->removeDpObject();
  2921.     }
  2922.  
  2923. /**    
  2924.      * Can we be dragged on the screen by the given user?
  2925.      *
  2926.      * Experimental mouse dragging of objects.
  2927.      *
  2928.      * @param      object    &$by_who    subject that wants to drag us
  2929.      * @return     boolean   TRUE if $by_who may drag us, FALSE otherwise
  2930.      * @since      DutchPIPE 0.2.0
  2931.      */
  2932.     function isDraggable(&$by_who)
  2933.     {
  2934.         return $this->getDpProperty('isDraggable');
  2935.     }
  2936.  
  2937. /**    
  2938.      * Reports graphical movement of this object to other objects
  2939.      *
  2940.      * Called by the client-side dpclient-js.php script after an object was
  2941.      * dragged by a user. Coordinates are passed as 'x' and 'y' in a GET
  2942.      * request and passed on to other users in the same environment.
  2943.      *
  2944.      * @see        dpclient-js.php
  2945.      * @since      DutchPIPE 0.2.0
  2946.      */
  2947.     function reportMove()
  2948.     {
  2949.         if (!($user = get_current_dpuser())
  2950.                 || !($env = $user->getEnvironment())
  2951.                 || !($inv = $env->getInventory())) {
  2952.             return;
  2953.         }
  2954.  
  2955.         foreach ($inv as &$ob) {
  2956.             if ($ob !== $user && $ob->isUser) {
  2957.                 if ($user !== $this) {
  2958.                     $ob->tell(sprintf(dp_text("%s moves %s around.<br />"),
  2959.                         $user->getTitle(<a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---title_types.php.html#defineDPUNIVERSE_TITLE_TYPE_DEFINITE">DPUNIVERSE_TITLE_TYPE_DEFINITE</a>),
  2960.                         $this->getTitle(<a href="../DutchPIPE/dpuniverse_include/_dpuniverse---include---title_types.php.html#defineDPUNIVERSE_TITLE_TYPE_DEFINITE">DPUNIVERSE_TITLE_TYPE_DEFINITE</a>)));
  2961.                 }
  2962.                 $ob->tell('<reportmove id="' . $this->uniqueId . '" left="'
  2963.                     . $user->_GET['x'] . '" top="' . $user->_GET['y']
  2964.                     . '">&#160;</reportmove>');
  2965.             }
  2966.         }
  2967.     }
  2968.  
  2969. /**    
  2970.      * Sets a heap object of a given amount in this object
  2971.      *
  2972.      * @param      string    $pathname   path to code from universe base path
  2973.      * @param      string    $idProperty unique property to identify heap object
  2974.      * @param      int|float$amount     amount, depends on heap type
  2975.      * @return     boolean   TRUE for success, FALSE otherwise
  2976.      * @since      DutchPIPE 0.2.0
  2977.      */
  2978.     function setHeapAmount($pathname, $idProperty, $amount)
  2979.     {
  2980.         $inv = $this->getInventory();
  2981.  
  2982.         foreach ($inv as &$ob) {
  2983.             if ($ob->{$idProperty}) {
  2984.                 $ob->amount = $amount;
  2985.                 return TRUE;
  2986.             }
  2987.         }
  2988.  
  2989.         $heap_ob = get_current_dpuniverse()->newDpObject($pathname);
  2990.         $heap_ob->amount = $amount;
  2991.         $heap_ob->moveDpObject($this);
  2992.         return TRUE;
  2993.     }
  2994.  
  2995. /**    
  2996.      * Gets the amount of a given heap object
  2997.      *
  2998.      * @param      string    $idProperty unique property to identify heap object
  2999.      * @return     int|floatamount, depends on heap type
  3000.      * @since      DutchPIPE 0.2.0
  3001.      */
  3002.     function getHeapAmount($idProperty)
  3003.     {
  3004.         $inv = $this->getInventory();
  3005.         $amount = 0;
  3006.  
  3007.         foreach ($inv as &$ob) {
  3008.             if ($ob->{$idProperty}) {
  3009.                 $amount += $ob->amount;
  3010.             }
  3011.         }
  3012.  
  3013.         return $amount;
  3014.     }
  3015.  
  3016. /**    
  3017.      * Sets the amount of credits in the inventory of this object
  3018.      *
  3019.      * @param      int|float$credits    amount of credits
  3020.      * @return     boolean   TRUE for success, FALSE otherwise
  3021.      * @see        getCredits
  3022.      * @since      DutchPIPE 0.2.0
  3023.      */
  3024.     function setCredits($credits)
  3025.     {
  3026.         return $this->setHeapAmount(<a href="../DutchPIPE/config/_config---dpuniverse-ini.php.html#defineDPUNIVERSE_OBJ_PATH">DPUNIVERSE_OBJ_PATH</a> . 'credits.php',
  3027.             'isCredits', $credits);
  3028.     }
  3029.  
  3030. /**    
  3031.      * Gets the amount of credits in the inventory of this object
  3032.      *
  3033.      * @return     int|floatamount of credits
  3034.      * @see        setCredits
  3035.      * @since      DutchPIPE 0.2.0
  3036.      */
  3037.     function getCredits()
  3038.     {
  3039.         return $this->getHeapAmount('isCredits');
  3040.     }
  3041.  
  3042. /**    
  3043.      * Makes the given method callable from the DutchPIPE client
  3044.      *
  3045.      * @param      string    $methodName  method to add
  3046.      * @see        removeValidClientCall, isValidClientCall
  3047.      * @since      DutchPIPE 0.4.0
  3048.      */
  3049.     protected final function addValidClientCall($methodName)
  3050.     {
  3051.         $this->mValidClientCalls[] = $methodName;
  3052.     }
  3053.  
  3054. /**    
  3055.      * Removes the given method from callable methods from the DutchPIPE client
  3056.      *
  3057.      * @param      string    $methodName  method to remove
  3058.      * @see        addValidClientCall, isValidClientCall
  3059.      * @since      DutchPIPE 0.4.0
  3060.      */
  3061.     protected final function removeValidClientCall($methodName)
  3062.     {
  3063.         if (in_array($methodName, $this->mValidClientCalls, TRUE)) {
  3064.             unset($this->mValidClientCalls[$methodName]);
  3065.         }
  3066.     }
  3067.  
  3068. /**    
  3069.      * May the given method be called in this object from the DutchPIPE client?
  3070.      *
  3071.      * @param      string    $methodName  method to check
  3072.      * @return     boolean   TRUE if the method can be called, FALSE otherwise
  3073.      * @see        addValidClientCall, removeValidClientCall
  3074.      * @since      DutchPIPE 0.4.0
  3075.      */
  3076.     final function isValidClientCall($methodName)
  3077.     {
  3078.         return in_array($methodName, $this->mValidClientCalls, TRUE);
  3079.     }
  3080.  
  3081. /**    
  3082.      * Gets the width in pixels of the title image
  3083.      *
  3084.      * @return     mixed     Integer with width in pixels, FALSE for unknown
  3085.      * @see        getTitleImgHeight
  3086.      * @since      DutchPIPE 0.4.1
  3087.      */
  3088.     function getTitleImgWidth()
  3089.     {
  3090.         $this->_initTitleImgDimensions();
  3091.  
  3092.         $title_img_width = $this->getDpProperty('titleImgWidth');
  3093.         return is_null($title_img_width) ? FALSE : $title_img_width;
  3094.     }
  3095.  
  3096. /**    
  3097.      * Gets the height in pixels of the title image
  3098.      *
  3099.      * @return     mixed     Integer with height in pixels, FALSE for unknown
  3100.      * @see        getTitleImgWidth
  3101.      * @since      DutchPIPE 0.4.1
  3102.      */
  3103.     function getTitleImgHeight()
  3104.     {
  3105.         $this->_initTitleImgDimensions();
  3106.  
  3107.         $title_img_height = $this->getDpProperty('titleImgHeight');
  3108.         return is_null($title_img_height) ? FALSE : $title_img_height;
  3109.     }
  3110.  
  3111. /**    
  3112.      * Sets the titleImgWidth and titleImgHeight properties
  3113.      *
  3114.      * Sets these properties in this object if they aren't set and if PHP is
  3115.      * installed with the GD library.
  3116.      *
  3117.      * @access     private
  3118.      * @see        getTitleImgWidth, getTitleImgHeight
  3119.      * @since      DutchPIPE 0.4.1
  3120.      */
  3121.     private function _initTitleImgDimensions()
  3122.     {
  3123.         $title_img_width = $this->getDpProperty('titleImgWidth');
  3124.         $title_img_height = $this->getDpProperty('titleImgHeight');
  3125.  
  3126.         if (!is_null($title_img_width) && !is_null($title_img_height)) {
  3127.             return;
  3128.         }
  3129.         if (!function_exists('gd_info')) {
  3130.             return;
  3131.         }
  3132.         $url2path = array(
  3133.             <a href="../DutchPIPE/config/_config---dpuniverse-ini.php.html#defineDPUNIVERSE_AVATAR_STD_URL">DPUNIVERSE_AVATAR_STD_URL</a>
  3134.                 => <a href="../DutchPIPE/config/_config---dpuniverse-ini.php.html#defineDPUNIVERSE_AVATAR_STD_PATH">DPUNIVERSE_AVATAR_STD_PATH</a>,
  3135.             <a href="../DutchPIPE/config/_config---dpuniverse-ini.php.html#defineDPUNIVERSE_AVATAR_CUSTOM_GUEST_URL">DPUNIVERSE_AVATAR_CUSTOM_GUEST_URL</a>
  3136.                 => <a href="../DutchPIPE/config/_config---dpuniverse-ini.php.html#defineDPUNIVERSE_AVATAR_CUSTOM_GUEST_PATH">DPUNIVERSE_AVATAR_CUSTOM_GUEST_PATH</a>,
  3137.             <a href="../DutchPIPE/config/_config---dpuniverse-ini.php.html#defineDPUNIVERSE_AVATAR_CUSTOM_REG_URL">DPUNIVERSE_AVATAR_CUSTOM_REG_URL</a>
  3138.                 => <a href="../DutchPIPE/config/_config---dpuniverse-ini.php.html#defineDPUNIVERSE_AVATAR_CUSTOM_REG_PATH">DPUNIVERSE_AVATAR_CUSTOM_REG_PATH</a>,
  3139.             <a href="../DutchPIPE/config/_config---dpuniverse-ini.php.html#defineDPUNIVERSE_IMAGE_URL">DPUNIVERSE_IMAGE_URL</a>
  3140.                 => <a href="../DutchPIPE/config/_config---dpuniverse-ini.php.html#defineDPUNIVERSE_IMAGE_PATH">DPUNIVERSE_IMAGE_PATH</a>
  3141.         );
  3142.  
  3143.         foreach ($url2path as $url => $path) {
  3144.             $title_img = str_replace($url, $path, $this->titleImg);
  3145.             if ($this->titleImg !== $title_img) {
  3146.                 break;
  3147.             }
  3148.         }
  3149.  
  3150.         $image_info = getimagesize($title_img);
  3151.         if (!is_array($image_info)) {
  3152.             return;
  3153.         }
  3154.  
  3155.         list($width, $height) = $image_info;
  3156.         if (is_null($title_img_width)) {
  3157.             $this->titleImgWidth = new_dp_property($width);
  3158.         }
  3159.         if (is_null($title_img_height)) {
  3160.             $this->titleImgHeight = new_dp_property($height);
  3161.         }
  3162.     }
  3163. }
Documentation generated on Mon, 03 Sep 2007 22:20:18 +0200 by phpDocumentor 1.3.0RC6

Click me!
Guest#215
 
 
 
  Go to Top
 
 
 Input Field OptionsClose Input Field Go to Top
 
Legal Notices | Copyright © 2006, 2007 Lennert Stock. All rights reserved. Last update: Mon Sep 03 2007, 21:50 CET.