modules/rpg/rpg.module

<?php
// $Id: rpg.module,v 1.59 2008/04/26 01:03:25 aaron Exp $

/**
 *  @mainpage RPG
 *  This module provides a full-featured game engine for Drupal. As the name implies, it may be used to create
 *  an RPG, but may be used for other types of games as well. Various rulesets exist, which may be imported into
 *  the site to give a base to start from, but a new ruleset may be started from scratch if desired.
 */

/**
 *  @file
 *  This module provides the core engine for RPG. It depends on many include files, so has any functions that may be
 *  called directly from a menu item, and the basic functions that should be used when directly accessing the system,
 *  such as rpg_types, rpg_get, rpg_set, etc.
 */

define('RPG_ACTION_ROUND_DURATION', 1);             // default duration of a game turn in real time seconds
define('RPG_ACTION_ROUND_CALENDAR_INCREMENT', 0);   // default seconds the default game calendar is incremented in a game turn
define('RPG_MAX_ACTION_POINTS', 120);               // default number of action points a character has until they must be recharged
define('RPG_ACTION_RECHARGE_RATE', 720);            // default number of rounds that must pass before an action point is restored

require_once(drupal_get_path('module', 'rpg') . '/inc/rpg.theme.inc');

/**
 *  implement hook_menu
 *
 *  As this function is rarely called, and is a relatively large function, we've moved this to another file.
 *  I believe this will be the de facto standard in D6 anyway, makes this an early adopter, I guess....
 *
 *  @see _rpg_menu_cache()
 */
function rpg_menu($may_cache) {
  $items = array();

  if ($may_cache) {
    // include _rpg_menu_cache -- this function defines all the defined menu items
    rpg_include_admin();
    $items = _rpg_menu_cache();
  }
  else {
    // determine things like active char, etc.
    // TODO: move this to a better place to always get called once per page load
    // i think it's changing in drupal 6
    _rpg_set_globals();
  }
  return $items;
}

/**
 *  implement hook_perm
 *  TODO: move this description to an api file
 *  'play rpg' => users may play the rpg
 *  'create pc rpg object' => users may create a new pc to play in the rpg. this may be limited by certain hooks
 *  'administer rpg' => users may administer any aspect of the game, including game settings
 *  'create rpg object' => users may create new rpg objects. this may be limited by certain hooks
 *  'edit own pc rpg object' => users may edit their own pc object
 *  'edit own rpg object' => users may edit their own rpg objects (except the pc object)
 *  'edit pc rpg object' => users may edit any pc object
 *  'edit rpg object' => users may edit any rpg objects, except other pcs
 *  'super in-game rpg' => users have access to special in-game powers, such as teleporting and viewing others' stats,
 *    but may not necessarily edit overall game settings (which is in the domain of 'administer rpg')
 */
function rpg_perm() {
  return array('play rpg', 'view rpg objects', 'create pc rpg object', 'administer rpg', 'create rpg object', 'edit own pc rpg object', 'edit own rpg object', 'edit rpg object', 'super rpg');
}

/**
 *  Is the character (as controlled by the user) allowed to view a specific object? In general, this is called by
 *  rpg/view to determine if an object may be seen. Assuming the user has perms, the character will usually only be
 *  able to view the object if in the same room as it, or similar circumstances.
 *
 *  calls hook_rpg_view_access, which returns FALSE or TRUE. Any modules that return FALSE will deny access, trumping the others.
 */
function rpg_view_access($who = NULL, $object = NULL) {
  if (user_access('administer rpg')) { return TRUE; }
  if (!user_access('view rpg objects')) { return FALSE; }
  if (is_null($who)) {
    global $rpg;
    $who = $rpg['pc'];
  }
  foreach (module_invoke_all('rpg_view_access', $who, $object) as $access) {
    if ($access === FALSE) {
      return FALSE;
    }
  }
  return TRUE;
}

/**
 *  Is the character (as controlled by the user) allowed to edit a specific object? In general, this is called by
 *  rpg/edit to determine if an object is owned by a user. Assuming the user has perms, the character will usually only be
 *  able to edit the object if he created it, or similar circumstances.
 *
 *  calls hook_rpg_edit_access, which returns FALSE or TRUE. Any modules that return FALSE will deny access, trumping the others.
 */
function rpg_edit_access($object = NULL) {
  if (user_access('administer rpg') || user_access('edit rpg object')) { return TRUE; }
  global $user;
  $object = rpg_object($object);
  if ($object->uid == $user->uid) {
    return TRUE;
  }
  return FALSE;
}

function rpg_reset_cache() {
  db_query("DELETE FROM {cache_rpg}");
}

/**
 *  make sure we save any changes to rpg objects
 */
function rpg_exit() {
  _rpg_save_all_marked_objects();
}

/**
 *  this initializes the global $rpg array and loads some included core rpg files.
 *  it also sets other rpg global variables, such as active character
 *  @param $reset
 *    if set to true, this will reset the global $rpg array (after first saving any changes)
 */
function _rpg_set_globals($reset = false) {
  global $rpg, $user;
  static $loaded;

  if ($loaded && !$reset) {
    return;
  }

  // load functions that are used internally, but only when accessing an rpg page
  // TODO: remove these and put the calls in proper places
  require_once(drupal_get_path('module', 'rpg') . '/inc/rpg.db.inc');
  require_once(drupal_get_path('module', 'rpg') . '/inc/rpg.invoke.inc');
  require_once(drupal_get_path('module', 'rpg') . '/inc/rpg.t.inc');

  // if we've previously loaded any objects, make sure to save any changes before resetting our global array
  if (is_array($rpg)) {
    rpg_include_db();
    _rpg_save_all_marked_objects();
  }

  // initialize our global array of rpg objects
  $rpg = array();

  // if we're logged in, get the active pc (if any)
  if ($user->uid && user_access('play rpg')) {
    $sql = "SELECT rid FROM {rpg_pc} WHERE uid=%d AND active=1";
    $rid = db_result(db_query($sql, $user->uid));
    if ($rid) {
      $rpg['pc'] = $rid;
    }
  }
  $loaded = true;
}

// callback for the game admin page menu item
function rpg_admin_game() {
  rpg_include_admin();
  $form = _rpg_admin_game();
  return system_settings_form($form);
}

/**
 *  FAPI definition for the RPG Type admin screen callback. Called with /admin/rpg/types
 *
 *  This is the rpg type admin screen callback. Technically not a form, although it is called as one. This page
 *  displays a table outlining the various types available, with several actions available for each type from the screen,
 *  such as edit, delete, attributes, and actions.
 *
 *  @ingroup forms
 *  @ingroup types
 *
 *  @see theme_rpg_admin_types
 */
function rpg_admin_types() {
  $types = rpg_types(NULL, false);
  return theme('rpg_admin_types', $types);
}

/**
 *  FAPI definition for the 'Add RPG Type' form. Called with /admin/rpg/types/type/add
 *
 *  This defines the screen used by admins to add a new RPG type. All objects are defined from types, and types may
 *  inherit from one or more types. Each type will have its own set of attributes and actions, which are also
 *  inherited, and may be overridden.
 *
 * @ingroup forms
 * @ingroup types
 *
 * @see _rpg_admin_type_form()
 * @see rpg_admin_type_add_validate()
 * @see rpg_admin_type_add_submit()
 */
function rpg_admin_type_add() {
  rpg_include_admin();
  $type = rpg_new_type();
  $form = _rpg_admin_type_form($type);
  $form['new'] = array(
    '#type' => 'value',
    '#value' => true,
  );
  return $form;
}

/**
 *  FAPI definition for the 'Edit RPG Type' form. Called with /admin/rpg/types/type/[TYPE]/edit
 *
 *  This defines the screen used by admins to edit an existing RPG type. All objects are defined from types, and types may
 *  inherit from one or more types. Each type will have its own set of attributes and actions, which are also
 *  inherited, and may be overridden.
 *
 *  @param $type
 *  The string of the type to edit, such as 'tangible' or 'actor'. Called as arg(4) in the url above.
 *
 * @ingroup forms
 * @ingroup types
 *
 * @see _rpg_admin_type_form()
 * @see rpg_admin_type_edit_validate()
 * @see rpg_admin_type_edit_submit()
 */
function rpg_admin_type_edit($type) {
  rpg_include_admin();
  $type = rpg_types($type, false);
  if (!$type['type']) {
    drupal_not_found();
  }
  $form = _rpg_admin_type_form($type);
  return $form;
}

/**
 *  Create an empty type array.
 *
 *  Called when adding a new type, whether programatically or from a form. It is not added to the database yet.
 *
 *  @return
 *  An empty array with key values for each of the expected values.
 */
function rpg_new_type() {
  $type = array();
  $type['type'] = '';
  $type['name'] = '';
  $type['parents'] = array();
  $type['shortdesc'] = '';
  $type['longdesc'] = '';
  return $type;
}

/**
 * validate callback for the 'add type' form
 */
function rpg_admin_type_add_validate($form_id, $form_values) {
  $type = rpg_types($form_values['type']);
  // if someone's already added the type we're trying to add...
  if ($type['type']) {
    form_set_error('type', t('The %type type has already been defined. Please choose another machine-readable name.', array('%type' => $type['type'])));
  }
}

/**
 * submit callback for the 'add type' form
 */
function rpg_admin_type_add_submit($form_id, $form_values) {
  $type['type'] = $form_values['type'];
  $type['name'] = $form_values['name'];
  $type['parents'] = $form_values['parents'];
  $type['shortdesc'] = $form_values['shortdesc'];
  $type['longdesc'] = $form_values['longdesc'];

  // rpg_save_type is in an external include file
  rpg_include_loadcache();
  // save our new type
  rpg_save_type($type);

  drupal_set_message(t('Your changes to the object type have been saved.'));

  return 'admin/rpg/types/type/' . $type['type'];
}

/**
 * validate callback for the 'edit type' form
 */
function rpg_admin_type_edit_validate($form_id, $form_values) {
  $type = rpg_types($form_values['type']);
  // if type type we're editing has been deleted since we began editing...
  if (!$type['type']) {
    form_set_error('type', t('There was an error in processing your form; that type is no longer in the database.'));
  }
}

/**
 * submit callback for the 'edit type' form
 */
function rpg_admin_type_edit_submit($form_id, $form_values) {
  $type = rpg_types($form_values['type']);

  $type['name'] = $form_values['name'];
  $type['parents'] = $form_values['parents'];
  $type['shortdesc'] = $form_values['shortdesc'];
  $type['longdesc'] = $form_values['longdesc'];

  // rpg_save_type is in an external include file
  rpg_include_loadcache();
  rpg_save_type($type);

  drupal_set_message(t('Your changes to the object type have been saved.'));
}

function rpg_admin_type_attributes_form($type) {
  $type = rpg_types($type);
  if (!$type['type']) {
    drupal_not_found();
  }

  drupal_set_title(t('Attributes for @type', array('@type' => $type['name'])));

  // include the include file w/ our helper function
  rpg_include_admin();

  return _rpg_admin_type_attributes_form($type);
}

/**
 *  FAPI definition for the 'Add new RPG Attribute' form. Called with /admin/rpg/types/type/[TYPE]/attributes/add/[[ATTRIBUTE]]
 *
 *  This defines the screen used by admins to add an attribute for an existing RPG type. If called with an optional
 *  $attribute string of an existing attribute defined by a parent of the type, then this screen defines an overridden
 *  attribute.
 *
 *  @param $type
 *  The string of the type to edit, such as 'tangible' or 'actor'. Called as arg(4) in the url above.
 *  @param $attribute
 *  If given (as the last arg), then it's a string of the attribute to override. Otherwise, it will add a new attribute.
 *
 * @ingroup forms
 * @ingroup attributes
 *
 * @see _rpg_admin_type_attribute_add()
 * @see rpg_admin_type_attribute_add_validate()
 * @see rpg_admin_type_attribute_add_submit()
 */
function rpg_admin_type_attribute_add($type, $attribute = NULL) {
  $type = rpg_types($type);
  if (!$type['type']) {
    drupal_not_found();
  }

  // include the include file w/ our helper function
  rpg_include_admin();

  return _rpg_admin_type_attribute_add($type, $attribute);
}

/**
 *  FAPI definition for the 'Add new RPG Action' form. Called with /admin/rpg/types/type/[TYPE]/actions/add/[[ACTION]]
 *
 *  This defines the screen used by admins to add an action for an existing RPG type. If called with an optional
 *  $action string of an existing action defined by a parent of the type, then this screen defines an overridden
 *  action.
 *
 *  @param $type
 *  The string of the type to edit, such as 'tangible' or 'actor'. Called as arg(4) in the url above.
 *  @param $action
 *  If given (as the last arg), then it's a string of the action to override. Otherwise, it will add a new action.
 *
 * @ingroup forms
 * @ingroup attributes
 *
 * @see _rpg_admin_type_action_add()
 * @see rpg_admin_type_action_add_validate()
 * @see rpg_admin_type_action_add_submit()
 */
function rpg_admin_type_action_add($type, $action = NULL) {
  $type = rpg_types($type);
  if (!$type['type']) {
    drupal_not_found();
  }

  // include the include file w/ our helper function
  rpg_include_admin();

  return _rpg_admin_type_action_add($type, $action);
}

/**
 *  FAPI definition for the 'Add new RPG Event' form. Called with /admin/rpg/types/type/[TYPE]/events/add/[[ACTION]]
 *
 *  This defines the screen used by admins to add an event for an existing RPG type. If called with an optional
 *  $event string of an existing event defined by a parent of the type, then this screen defines an overridden
 *  event.
 *
 *  @param $type
 *  The string of the type to edit, such as 'tangible' or 'actor'. Called as arg(4) in the url above.
 *  @param $event
 *  If given (as the last arg), then it's a string of the event to override. Otherwise, it will add a new event.
 *
 * @ingroup forms
 * @ingroup attributes
 *
 * @see _rpg_admin_type_event_add()
 * @see rpg_admin_type_event_add_validate()
 * @see rpg_admin_type_event_add_submit()
 */
function rpg_admin_type_event_add($type, $event = NULL) {
  $type = rpg_types($type);
  if (!$type['type']) {
    drupal_not_found();
  }

  // include the include file w/ our helper function
  rpg_include_admin();

  return _rpg_admin_type_event_add($type, $event);
}

function rpg_admin_type_attribute_edit($type, $attribute) {
  $type = rpg_types($type);
  $attribute = rpg_attributes($attribute);
  if (!isset($type['type']) || !isset($attribute['attribute']) || !isset($type['attributes']['defined'][$attribute['attribute']])) {
    drupal_not_found();
  }

  drupal_set_title(t('Edit @attribute Attribute', array('@attribute' => $attribute['name'])));
  rpg_include_admin();
  return _rpg_admin_attribute_edit_form($type, $type['attributes']['defined'][$attribute['attribute']]);
}

function rpg_admin_type_action_edit($type, $action) {
  $type = rpg_types($type);
  $action = rpg_actions($action);
  if (!isset($type['type']) || !isset($action['action']) || !isset($type['actions']['defined'][$action['action']])) {
    drupal_not_found();
  }

  drupal_set_title(t('Edit @action action', array('@action' => $action['name'])));
  rpg_include_admin();
  return _rpg_admin_action_edit_form($type, $type['actions']['defined'][$action['action']]);
}

function rpg_admin_type_event_edit($type, $event) {
  $type = rpg_types($type);
  $event = rpg_events($event);
  if (!isset($type['type']) || !isset($event['event']) || !isset($type['events']['defined'][$event['event']])) {
    drupal_not_found();
  }

  drupal_set_title(t('Edit @event event', array('@event' => $event['name'])));
  rpg_include_admin();
  return _rpg_admin_event_edit_form($type, $type['events']['defined'][$event['event']]);
}

function rpg_admin_type_attribute_add_submit($form_id, $form_values) {
  // include rpg_attribute_add
  rpg_include_loadcache();

  $attribute = array();
  $attribute['attribute'] = $form_values['attribute'];
  $attribute['name'] = $form_values['name'];
  $attribute['class'] = $form_values['class'];
  $attribute['get'] = $form_values['get'];
  $attribute['verify'] = $form_values['verify'];
  $attribute['set'] = $form_values['set'];
  $attribute['default_value'] = $form_values['default_value'];
  $attribute['form_display'] = $form_values['form_display'];

  $attribute = rpg_attribute_add($form_values['type'], $attribute);
//   $attribute = rpg_attribute_add($form_values['type'], $form_values['class'], $form_values['attribute'], $form_values['name']);

  if (isset($attribute)) {
    drupal_set_message(t("The attribute '@attribute' has been added.", array('@attribute' => $form_values['name'])));
    return 'admin/rpg/types/type/' . $form_values['type'] . '/attributes/edit/' . $attribute['attribute'];
  }
}

function rpg_admin_type_attribute_edit_submit($form_id, $form_values) {
  // include rpg_attribute_edit
  rpg_include_loadcache();

  $attribute = array();
  $attribute['attribute'] = $form_values['attribute'];
  $attribute['name'] = $form_values['name'];
  $attribute['class'] = $form_values['class'];
  $attribute['description'] = $form_values['description'];
  $attribute['get'] = $form_values['get'];
  $attribute['verify'] = $form_values['verify'];
  $attribute['set'] = $form_values['set'];
  $attribute['default_value'] = $form_values['default_value'];
  $attribute['form_display'] = $form_values['form_display'];

  $class = rpg_attribute_classes($attribute['class']);

  $settings = module_invoke($class['module'], 'rpg_attribute_class_settings', 'save', $class['class']);

  foreach ((array)($settings) as $key => $setting) {
    $attribute[$setting] = $form_values[$setting];
  }

  $attribute = _rpg_attribute_edit($form_values['type'], $attribute);

  drupal_set_message(t('Your changes have been recorded.'));
  return 'admin/rpg/types/type/' . $form_values['type'] . '/attributes/edit/' . $attribute['attribute'];
}

function rpg_admin_type_action_add_submit($form_id, $form_values) {
  // include _rpg_action_add
  rpg_include_loadcache();

  $action = array();
  $action['action'] = $form_values['action'];
  $action['name'] = $form_values['name'];

  $action = _rpg_action_add($form_values['type'], $action); //$form_values['action'], $form_values['name']);

  drupal_set_message(t("The action '@action' has been added.", array('@action' => $form_values['name'])));
  return 'admin/rpg/types/type/' . $form_values['type'] . '/actions/edit/' . $action['action'];
}

/**
 *  This is when you submit the action edit admin screen. makes any changes to that action, which will
 *  be inherited by inherited types.
 */
function rpg_admin_type_action_edit_submit($form_id, $form_values) {
  // include rpg_action_edit
  rpg_include_loadcache();
  $type = rpg_types($form_values['type']);

  $action = array(
    'action' => $form_values['action'],
    'name' => $form_values['name'],
    'type' => $type['type'],
    'description' => $form_values['description'],
    'php' => $form_values['php'],
    'expose' => $form_values['expose'],
  );

  $action = _rpg_action_edit($type['type'], $action);

  drupal_set_message(t('Your changes have been recorded.'));
  return 'admin/rpg/types/type/' . $form_values['type'] . '/actions/edit/' . $action['action'];
}

function rpg_admin_type_event_add_submit($form_id, $form_values) {
  // include _rpg_event_add
  rpg_include_loadcache();

  $event = array();
  $event['event'] = $form_values['event'];
  $event['name'] = $form_values['name'];

  $event = _rpg_event_add($form_values['type'], $event); //$form_values['event'], $form_values['name']);

  drupal_set_message(t("The event '@event' has been added.", array('@event' => $form_values['name'])));
  return 'admin/rpg/types/type/' . $form_values['type'] . '/events/edit/' . $event['event'];
}

/**
 *  This is when you submit the event edit admin screen. makes any changes to that event, which will
 *  be inherited by inherited types.
 */
function rpg_admin_type_event_edit_submit($form_id, $form_values) {
  // include rpg_event_edit
  rpg_include_loadcache();
  $type = rpg_types($form_values['type']);

  $event = array(
    'event' => $form_values['event'],
    'name' => $form_values['name'],
    'type' => $type['type'],
    'description' => $form_values['description'],
    'php' => $form_values['php'],
    'expose' => $form_values['expose'],
  );

  $event = _rpg_event_edit($type['type'], $event);

  drupal_set_message(t('Your changes have been recorded.'));
  return 'admin/rpg/types/type/' . $form_values['type'] . '/events/edit/' . $event['event'];
}

/**
 *  This loads all defined attributes into the system.
 *  @param $attribute
 *    If given, then return an array defining that attribute (by machine-readable name).
 *    Otherwise, return an array of all attributes.
 *  @param $cached
 *    If false, then force the cache to be reloaded. Otherwise, simply return the attribute(s)
 *    from the cache.
 */
function rpg_attributes($attribute = NULL, $cached = true) {
  static $attributes;
  if (!isset($attributes) || !$cached) {
    if ($cached && $cache = cache_get('rpg_attributes', 'cache_rpg')) {
      $attributes = unserialize($cache->data);
    }
    else {
      // define _rpg_load_attributes();
      rpg_include_loadcache();
      $attributes = _rpg_load_attributes();
      cache_set('rpg_attributes', 'cache_rpg', serialize($attributes));
    }
  }
  if (isset($attribute)) {
    return $attributes[$attribute];
  }
  return $attributes;
}

/**
 *  This loads all defined actions into the system.
 *  @param $action
 *    If given, then return an array defining that action (by machine-readable name).
 *    Otherwise, return an array of all actions.
 *  @param $cached
 *    If false, then force the cache to be reloaded. Otherwise, simply return the action(s)
 *    from the cache.
 */
function rpg_actions($action = NULL, $cached = true) {
  static $actions;
  if (!isset($actions) || !$cached) {
    if ($cached && $cache = cache_get('rpg_actions', 'cache_rpg')) {
      $actions = unserialize($cache->data);
    }
    else {
      // define _rpg_load_actions();
      rpg_include_loadcache();
      $actions = _rpg_load_actions();
      cache_set('rpg_actions', 'cache_rpg', serialize($actions));
    }
  }
  if (isset($action)) {
    return $actions[$action];
  }
  return $actions;
}

/**
 *  This loads all defined events into the system.
 *  @param $event
 *    If given, then return an array defining that event (by machine-readable name).
 *    Otherwise, return an array of all events.
 *  @param $cached
 *    If false, then force the cache to be reloaded. Otherwise, simply return the event(s)
 *    from the cache.
 */
function rpg_events($event = NULL, $cached = true) {
  static $events;
  if (!isset($events) || !$cached) {
    if ($cached && $cache = cache_get('rpg_events', 'cache_rpg')) {
      $events = unserialize($cache->data);
    }
    else {
      // define _rpg_load_events();
      rpg_include_loadcache();
      $events = _rpg_load_events();
      cache_set('rpg_events', 'cache_rpg', serialize($events));
    }
  }
  if (isset($event)) {
    return $events[$event];
  }
  return $events;
}

function rpg_admin_type_actions($type) {
  $type = rpg_types($type);
  if (!$type['type']) {
    drupal_not_found();
  }

  drupal_set_title(t('Actions for @type', array('@type' => $type['name'])));

  // include the include file w/ our helper function
  rpg_include_admin();

  return _rpg_admin_type_actions_form($type);
}

function rpg_admin_type_events($type) {
  $type = rpg_types($type);
  if (!$type['type']) {
    drupal_not_found();
  }

  drupal_set_title(t('Events for @type', array('@type' => $type['name'])));

  // include the include file w/ our helper function
  rpg_include_admin();

  return _rpg_admin_type_events_form($type);
}

/**
 *  this is the main function called to play each turn, from the /rpg/play menu item
 */
function rpg_play($object = NULL, $action = NULL, $who = NULL, $target = NULL, $item = NULL) {
  global $rpg, $user;
  // if we already have a character, process the action. otherwise, show a select screen
  if ($rpg['pc']) {
    // allow modules to hijack the process, such as during character creation
    // in fact, character selection can happen elsewhere as well!
    module_invoke_all('rpg_play', $rpg['pc']);

    // if we have an action, such as rpg/play/88/drop/53/88, then process it
    // TODO: move this to rpg_action? and add all args to the module_invoke, thus this function will have no args!
    if (isset($action)) {
      $action = array(
        '#object' => $object,
        '#action' => $action,
        '#who' => $who ? $who : $rpg['pc'],
        '#target' => $target,
        '#what' => $item,
      );
       rpg_action_process($action);
      // make sure the pc is able to act (next action round, etc)
/*      if (rpg_may_act($pc)) {
        // create the event from the action, saving it to check later
        $event = rpg_create_event($pc, $action, $target, $what);

        // process our new event
        rpg_event_process_threads(1);

        // make sure it's been processed. if not, we'll set a message to that effect
        rpg_event_check_if_processed($event);
      }
      else {
        // create a message saying the pc isn't able to act yet
        // TODO: seperate from rpg_message.module. maybe make it simply a drupal_set_message? or better yet, a theme function
        $message = array(
          '#who' => $pc,
          '#message' => t('You may not yet act.'),
        );
        rpg_message($message);
      }*/
    }
    // display our game play page
    return theme('rpg_play', $rpg['pc']);
  }
  else {
    // we don't have a character yet, so go to the character selection page
    drupal_goto('rpg/select');
  }
}

function rpg_character_select_page() {
  global $user;

  // clear any old characters (effective 'logging off' the character)
  $sql = "UPDATE {rpg_pc} SET active=0 WHERE uid=%d";
  db_query($sql, $user->uid);

  $pcs = rpg_user_pcs($user);
  $selected = arg(2);

  // if we have selected a pc, then set the active pc for that user to it and go to rpg/play
  if ($selected && in_array($selected, $pcs)) {
    $sql = "UPDATE {rpg_pc} SET active=1 WHERE uid=%d AND rid=%d";
    db_query($sql, $user->uid, $selected);
    drupal_goto('rpg/play');
  }

  // print our list of available characters for this user
  $output .= theme('rpg_character_select_page', $user, $pcs);
  return $output;
}

/**
 *  this will return an array of the pc object id's owned by a certain user $account
 */
function rpg_user_pcs($account) {
  static $pcs = array();
  if (!isset($pcs[$account->uid])) {
    $pcs[$account->uid] = array();
    $sql = "SELECT rid FROM {rpg_pc} WHERE uid=%d";
    $results = db_query($sql, $account->uid);
    while ($result = db_fetch_array($results)) {
      $pcs[$account->uid][] = $result['rid'];
    }
  }
  return $pcs[$account->uid];
}

/**
 *  callback for rpg/create/[TYPE]
 *
 *  this either displays a list of types, or the form to create an object of the specified type.
 */
function rpg_create_page() {
  $type = arg(3);
  if (arg(2) == 'pc') {
    return rpg_create_pc_page();
  }
  if (!$type) {
    global $user;
    $types = rpg_types();
    $pc_types = rpg_available_pc_types($user);
    $admin_access = user_access('rpg admin');
    if (empty($types) && $admin_access) {
      $output .= t('There are currently no RPG object types defined. You may define these at the !admin.', array('!admin' => l(t('types admin page'), 'admin/rpg/types')));
    }
    foreach ($types as $type) {
      $link = '';
      $is_pc_type = isset($pc_types[$type['type']]);
      // TODO: this needs to be redone; actor is now in the realm of rulesets
      if ($is_pc_type && ($admin_access || (rpg_user_access('create pc', $type) && rpg_may_create_pc($user, $type)))) {
        $link = l($type['name'], 'rpg/create/pc/' . $type['type']);
      }
      else if (!$is_pc_type && ($admin_access || rpg_user_access('create', $type))) {
        $link = l($type['name'], 'rpg/create/type/' . $type['type']);
      }
      if ($link) {
        $output .= '<p>' . $link . '<br />' . $type['shortdesc'] . '</p>';
      }
    }

    if ($output) {
      // TODO: theme this
      return $output;
    }
    else {
      drupal_access_denied();
    }
  }
  else {
    return rpg_create_object_page($type, arg(4));
  }
}

function rpg_edit_page() {
  if (arg(2) && is_numeric(arg(2))) {
    $object = rpg_object(arg(2));
    if ($object->rid) {
      if (!rpg_edit_access($object)) {
        drupal_access_denied();
      }
      $form = drupal_get_form('rpg_form_object', $object);
      return theme('rpg_edit_object_page', $object, $form);
    }
  }
  drupal_not_found();
}

function rpg_view_page() {
  if (is_numeric(arg(2))) {
    $object = arg(2);
    global $rpg;
    if (!rpg_view_access($rpg['pc'], $object)) {
      drupal_access_denied();
    }
    if (!rpg_id($object)) {
      drupal_not_found();
    }
    return theme('rpg_view_object_page', $object);
  }
  else {
    if (!user_access('administer rpg')) {
      drupal_access_denied();
    }
    $sql = "SELECT rid FROM {rpg} ORDER BY created DESC";
    $limit = variable_get('rpg_browse_object_limit', 20);
    $results = pager_query($sql, $limit);
    $objects = array();
    while ($rid = db_fetch_array($results)) {
      $objects[$rid['rid']] = $rid['rid'];
    }
    return theme('rpg_browse_page', $objects);
  }
  drupal_not_found();
}

/**
 *  this displays the form to create an object of $type
 *
 *  @param $type
 *  This is the string of the object.
 *  @param $subtype
 *  This will set the object type as $subtype, assuming $subtype is a child of $type.
 */
function rpg_create_object_page($type, $subtype = NULL) {
  global $user;
  $type = rpg_types($type);
  if ($subtype) {
    $subtype = rpg_types($subtype);
    if (!rpg_type_is_a($subtype, $type['type'])) {
      drupal_not_found();
    }
    else {
      $type = $subtype;
    }
  }
  if (!user_access('admin rpg') && !rpg_user_access('create', $type)) {
    drupal_access_denied();
  }
  $object = rpg_new_rpg_object($type, $user);
  $form = drupal_get_form('rpg_form_object', $object);
  return theme('rpg_create_object_page', $object, $type, $form);
}

function rpg_available_pc_types($user) {
  static $avail;

  if (!isset($avail)) {
    $avail = array();
    $pc_types = module_invoke_all('rpg_pc_types', $user);
    $types = rpg_types();
    foreach ($pc_types as $type) {
      if (isset($types[$type])) {
        $avail[$type] = $types[$type];
      }
    }
  }
  return $avail;
}

function rpg_create_pc_page() {
  global $user;
  $pc_types = rpg_available_pc_types($user);
  $pc_type = arg(3);
  if ($pc_type && isset($pc_types[$pc_type])) {
    $type = $pc_types[$pc_type];
  }
  else if ($pc_type) {
    drupal_not_found();
  }
  if (isset($type['type'])) {
    // we call this, because an admin might set certain user roles to have only a limited number of pc's
    // or maybe, for instance, only one of each race or class
    if (user_access('admin rpg') || (rpg_user_access('create pc', $type) && rpg_may_create_pc($user, $type))) {
      $pc = rpg_new_rpg_object($type, $user);
      $form = drupal_get_form('rpg_form_object', $pc);
      return theme('rpg_create_pc_page', $pc, $type, $form);
    }
    else {
      drupal_access_denied();
    }
  }
  $available_types = array();
  foreach($pc_types as $type) {
    // we call this, because an admin might set certain user roles to have only a limited number of pc's
    // or maybe, for instance, only one of each race or class
    if (rpg_may_create_pc($user, $type)) {
      $available_types[] = l($type['name'], 'rpg/create/pc/' . $type['type']) . '<br />' . $type['shortdesc'];
    }
  }
  $output .= theme('item_list', $available_types);
  return $output;
}

function rpg_form_object($object) {
  // make sure we have all data loaded
  if (!$object->is_new) {
    $object = rpg_object($object, FALSE, TRUE);
  }

  $form = array();

  // TODO: make this a username lookup instead
  $form['uid'] = array(
    '#type' => 'value',
    '#value' => $object->uid,
  );
  $form['types'] = array(
     '#type' => 'value',
     '#value' => $object->types,
  );
  if (user_access('administer rpg')) {
    $options = array();
    foreach (rpg_types() as $type) {
      $options[$type['type']] = $type['name'];
    }
    $form['types'] = array(
      '#type' => 'select',
      '#title' => t('Types'),
      '#options' => $options,
      '#default_value' => $object->types,
      '#description' => t('Select the type(s) for this object. Note that conflicts may arise when using multiple types.'),
      '#multiple' => TRUE,
    );
  }
  $form['created'] = array(
    '#type' => 'value',
    '#value' => $object->created,
  );
  $form['is_new'] = array(
    '#type' => 'value',
    '#value' => $object->is_new,
  );
  $form['rid'] = array(
    '#type' => 'value',
    '#value' => $object->rid,
  );
  $form['data'] = array(
    '#tree' => true,
  );

  if (is_array($object->data)) {
    foreach ($object->data as $attr => $value) {
      $attribute = rpg_object_attributes($object->rid, $attr);
      $attribute['value'] = $value;
      $attribute['object'] = $object;
      $class = rpg_attribute_classes($attribute['class']);
      $form['data'][$attr] = module_invoke($class['module'], 'rpg_attribute_class_settings', 'form', $class['class'], $attribute);
      if (is_null($form['data'][$attr])) {
        // display our default form data
        $form['data'][$attr] = array(
          '#type' => 'textfield',
          '#title' => $attribute['name'],
          '#default_value' => $attribute['value'],
          '#description' => $attribute['description'],
        );
      }
      $display = _rpg_call_function('form_display', $attr, $object->rid);
      if ($display === FALSE) {
        $form['data'][$attr]['#type'] = 'value';
        $form['data'][$attr]['#value'] = $form['data'][$attr]['#default_value'];
      }
    }
  }

  $form['submit'] = array('#type' => 'submit', '#value' => t('Submit'), '#weight' => 45);

  return $form;
}

// TODO: make sure inserts work ok
function rpg_form_object_submit($form_id, $form_values) {
  if ($form_values['is_new']) {
    $object = rpg_create($form_values['types'], (array)$form_values['data']);
  }
  else {
    $object = array(
      'types' => $form_values['types'],
      'uid' => $form_values['uid'],
      'created' => ($form_values['created'] ? $form_values['created'] : time()),
      'changed' => time(),
      'rid' => $form_values['rid'],
      'data' => array(),
    );

    $object = (object) $object;
    rpg_save_rpg($object);//print_r($form_values);//exit();
    foreach(rpg_object_attributes($object) as $attribute) {//print_r($attribute);
      if (isset($form_values['data'][$attribute['attribute']])) {drupal_set_message('attr: ' . $attribute['attribute'].', '.$form_values['data'][$attribute['attribute']]);
        rpg_set($attribute['attribute'], $object, $form_values['data'][$attribute['attribute']]);
      }
      else if ($attribute['default_value']) {drupal_set_message('attr: '.$attribute['attribute'].', default: '.$attribute['default']);
        rpg_set($attribute['attribute'], $object, $attribute['default_value']);
      }
    }
//     foreach ((array)$form_values['data'] as $attr => $value) {
//       rpg_set($attr, $object, $value);
//     }
  }

  _rpg_save_all_marked_objects();
  if (arg(2) == 'pc') {
    return 'rpg/select/' . $object->rid;
  }
  return 'rpg/view/' . $object->rid;
}

/**
 *  creates a new rpg, saves it in the db, with assigned attribute values. then triggers on_create event and returns new object id
 */
function rpg_create($types = array(), $attributes = array()) {
  if (is_string($types)) {
    $types = (array) $types;
  }
  if (is_array($types) && !empty($types)) {
    $object = array(
      'types' => $types,
      'uid' => $user->uid,
      'created' => time(),
      'changed' => time(),
      'data' => (array) $attributes,
      'is_new' => TRUE,
    );
    $object = _rpg_insert_new_rpg((object)$object);
    rpg_trigger('on_create', $object);
    return $object;
  }
}

/**
 *  clones an object, making an identical copy. returns the new object, or NULL if failed
 */
function rpg_clone($object) {
  // load the full object to clone
  $object = rpg_object($object, FALSE, TRUE);
  if ($object->rid) {
    return rpg_create($object->types, $object->data);
  }
}

/**
 *  returns true if the user has specific $op access to the $type
 *  @param $op
 *    'create' => user may create objects of that type
 *    'edit' => user may edit any object of the type
 *    'edit own' => user may edit any object of the type they own
 *  @param $type
 *    the string or type array of the object type to create/edit
 *  @return
 *    true if allowed; false if not allowed
 */
function rpg_user_access($op, $type) {
  $return = user_access($op . ' rpg object') || user_access('admin rpg');
  // TODO: add hooks for specific types
  return $return;
}

/**
 *  is a user allowed to create a pc of the specific type?
 *  we call this, because an admin might set certain user roles to have only a limited number of pc's
 *  or maybe, for instance, only one of each race or class
 *  @param $account
 *    the user account to check
 *  @param $type
 *    the rpg type array to test
 *  @return
 *    true if the user may create a new pc of the type, false if not.
 */
function rpg_may_create_pc($account, $type) {
  if (!user_access('create pc rpg object')) {
    return false;
  }
  // TODO: call hooks to refine access
  return true;
}

/**
 *  return a list of all available rpg types
 *  @param $type
 *    if given, just return the type specified by the string
 *    otherwise, return an array of all types
 *  @param $cached
 *    if true, return the cached value, if it's cached.
 *    otherwise, reload all the type data from include files
 */
function rpg_types($type = NULL, $cached = true) {
  static $types;

  // if it's a cachable request, try to load a cached value
  if (!isset($types) || !$cached) {
    if ($cached && $cache = cache_get('rpg_types', 'cache_rpg')) {
      $types = unserialize($cache->data);
    }
    else {
      // _rpg_type_load_types is in an external include
      rpg_include_loadcache();

      $types = _rpg_type_load_types();
      cache_set('rpg_types', 'cache_rpg', serialize($types));
    }
  }

  // just return the type we're looking for
  if (is_string($type)) {
    return $types[$type];
  }
  else if (isset($type)) {
    return;
  }

  return $types;
}

/**
 *  this will load all module-defined attribute classes, such as node, sprite, map, integer, string, and figured
 *  TODO: cache this!
 *
 *  @param $class
 *  this will return just the specific class if specified. otherwise, it will return an array with all the classes.
 *  @param $refresh
 *  if set to true, it will force the list to be refreshed.
 */
function rpg_attribute_classes($class = NULL, $refresh = FALSE) {
  static $classes;
  if (!isset($classes) || $refresh) {
    $classes = array();
    foreach (module_implements('rpg_attribute_class_settings') as $module) {
      $attributes = module_invoke($module, 'rpg_attribute_class_settings', 'info');
      foreach ($attributes as $attribute_class => $info) {
        $info['class'] = $attribute_class;
        $info['module'] = $module;
        rpg_drupal_alter('rpg_class', $info);
        $classes[$attribute_class] = $info;
      }
    }
  }

  // just return the class we're looking for
  if ($class) {
    return $classes[$class];
  }
  return $classes;
}

/**
 *  load functions that rebuild cached arrays, such as rpg_types and attributes
 */
function rpg_include_loadcache() {
  require_once(drupal_get_path('module', 'rpg') . '/inc/rpg.loadcache.inc');
}

/**
 *  load functions needed for admin pages
 */
function rpg_include_admin() {
  require_once(drupal_get_path('module', 'rpg') . '/inc/rpg.admin.inc');
}

/**
 *  load functions needed for rpg object database, such as getting & setting object attributes to/from the db
 */
function rpg_include_db() {
  require_once(drupal_get_path('module', 'rpg') . '/inc/rpg.db.inc');
}

function rpg_is_a($object, $type) {
  $object = rpg_object($object);
  foreach ((array)$object->types as $ancestor) {
    if (rpg_type_is_a($ancestor, $type)) {
      return true;
    }
  }
  return false;
}

/**
 *  recursive function to check to see if a type has a specific ancestor
 *  @param $type
 *    string containing the type to check OR the array of a type returned by rpg_types($type)
 *  @param $ancestor
 *    string containing the type to see if we're an ancestor of
 */
function rpg_type_is_a($type, $ancestor) {
  if (is_string($type)) {
    $type = rpg_types($type);
  }
  if ($type['type'] == $ancestor) {
    return true;
  }
  foreach ((array)$type['parents'] as $parent) {
    if ($parent == $ancestor) {
      return true;
    }