modules/fsgame/fsgame.module

<?php
// $Id: fsgame.module,v 1.54 2008/09/28 14:16:36 aaron Exp $

/**
 * @file
 * Enables the 5 Second Game (inspired by rock-paper-scissors).
 *
 * @todo implement some sort of cluetip thingy for the classes.
 */

/**
 * Implementation of hook_help().
 */
function fsgame_help($path, $arg) {
  switch ($path) {
    case 'admin/settings/fsgame':
      return '<p>'. t('Configure 5 Second Game with these settings.') .'</p>';
  }
}

/**
 * Implementation of hook_menu().
 */
function fsgame_menu() {
  $items = array();

  $items['admin/settings/fsgame'] = array(
    'access arguments'  => array('administer 5 Second Game'),
    'description'       => 'Configure 5 Second Game with these settings.',
    'file'              => 'fsgame.admin.inc',
    'page callback'     => 'drupal_get_form',
    'page arguments'    => array('fsgame_settings'),
    'title'             => '5 Second Game',
  );
  $items['fsgame/contest'] = array(
    'access arguments'  => array('create 5 Second Game character'),
    'description'       => 'Competition between two 5 Second Game characters.',
    'file'              => 'fsgame.pages.inc',
    'page callback'     => 'drupal_get_form',
    'page arguments'    => array('fsgame_contest_form'),
    'title'             => '5 Second Game Contest',
  );
  $items['fsgame/autocomplete'] = array(
    'access arguments'  => array('access content'),
    'file'              => 'fsgame.pages.inc',
    'page callback'     => 'fsgame_autocomplete',
    'title'             => '5 Second Game autocomplete',
    'type'              => MENU_CALLBACK,
  );
  $items['fsgame/autocomplete-exclude'] = array(
    'access arguments'  => array('access content'),
    'file'              => 'fsgame.pages.inc',
    'page callback'     => 'fsgame_autocomplete_exclude',
    'title'             => '5 Second Game autocomplete (exclude)',
    'type'              => MENU_CALLBACK,
  );
  $items['fsgame/claim/%node'] = array(
    'access'            => 'fsgame_claim_access',
    'access arguments'  => array(2),
    'file'              => 'fsgame.pages.inc',
    'page callback'     => 'fsgame_character_claim',
    'page arguments'    => array(2),
    'title'             => 'Claim 5 Second Game character',
    'type'              => MENU_CALLBACK,
  );
  $items['fsgame/js/form'] = array(
    'page callback' => 'fsgame_form_update',
    'access arguments' => array('access content'),
    'type' => MENU_CALLBACK,
  );

  return $items;
}

function fsgame_form_update() {
  $class = $_POST['fsgame']['character']['class'];
  if ($form = form_get_cache($_POST['form_build_id'], $form_state)) {
    // Validate the bid.
    if (isset($form['fsgame']['character']['classes']['class']['#options'][$class])) {
      // Get the new options and update the cache.
      $form['fsgame']['character']['skill-wrapper']['skills'] = _fsgame_skill_select($class);
      form_set_cache($_POST['form_build_id'], $form, $form_state);

      // Build and render the new select element, then return it in JSON format.
      $form_state = array();
      $form['#post'] = array();
      $form = form_builder($form['form_id']['#value'] , $form, $form_state);
      $output = drupal_render($form['fsgame']['character']['skill-wrapper']['skills']);
      drupal_json(array('status' => TRUE, 'data' => $output));
    }
    else {
      drupal_json(array('status' => FALSE, 'data' => ''));
    }
  }
  else {
    drupal_json(array('status' => FALSE, 'data' => ''));
  }
  exit();
}

function _fsgame_skill_select($class = '') {
  $class = fsgame_world_load('classes', $class);
  if (!$class) {
    return;
  }

  if (!is_array($class['preferred modes'])) {
    $class['preferred modes'] = isset($class['preferred modes']) ? (array) $class['preferred modes'] : array();
  }
  if (!is_array($class['preferred skills'])) {
    $class['preferred skills'] = isset($class['preferred skills']) ? (array) $class['preferred skills'] : array();
  }

  // Also allow a skill selection.
  $skill_options = array();
  foreach (fsgame_world_load('skills') as $skill) {
    if ($skill['contest'] == 'attack' && (in_array($skill['skill mode'], $class['preferred modes']) || in_array($skill['id'], $class['preferred skills']))) {
      $skill_options[$skill['id']] = $skill['title'];
    }
  }

  $form = array(
    '#options'      => $skill_options,
    // when the form is submitted, make it a key of 'character'.
    '#parents'      => array('fsgame', 'character', 'skill'),
    '#required'     => TRUE,
    '#title'        => t('Beginning attack skill'),
    '#type'         => 'select',
  );
  return $form;
}


/**
 * Implementation of hook_perm().
 */
function fsgame_perm() {
  return array(
    'administer 5 Second Game',
    'claim 5 Second Game character',
    'create 5 Second Game character',
    'edit own 5 Second Game character',
    'edit any 5 Second Game character',
    'delete any 5 Second Game character',
    'delete own 5 Second Game character',
  );
}

function fsgame_claim_access($node) {
  global $user;
  return $user->uid && user_access('claim 5 Second Game character') && ($node->type == 'fsgame_character') && (!$node->uid) && ($_SESSION['fsgame_contest_anonymous_character'] == $node->nid);
}

/**
 *  Implementation of hook_theme().
 */
function fsgame_theme($existing, $type, $theme, $path) {
  return array(
    'fsgame_character_class' => array(
      'arguments' => array('node' => NULL),
      'file' => 'fsgame.theme.inc',
    ),
    'fsgame_character_attributes' => array(
      'arguments' => array('node' => NULL),
      'file' => 'fsgame.theme.inc',
    ),
    'fsgame_contest_selectors_character' => array(
      'arguments' => array('character_nid' => 'latest', 'opponent_nid' => 'latest'),
      'file' => 'fsgame.theme.inc',
    ),
    'fsgame_contest_selectors_opponent' => array(
      'arguments' => array('character_nid' => 'latest', 'opponent_nid' => 'latest'),
      'file' => 'fsgame.theme.inc',
    ),
    'test' => array(
      'arguments' => array('file' => NULL),
      'file' => 'fsgame.theme.inc',
    ),
  );
}

function phptemplate_preprocess_test($variables) {
  $variables['file'] = 'override';
}

/**
 * Implementation of hook_node_info().
 */
function fsgame_node_info() {
  $types = array();

  $types['fsgame_character'] = array(
    'name'          => t('Character'),
    'module'        => 'fsgame_character',
    'description'   => t('A <em>character</em> defines who you play as in the 5 Second Game.'),
    'title_label'   => t('Name'),
    'body_label'    => t('Description'),
    'locked'        => TRUE,
  );

  return $types;
}

/**
 * Implementation of hook_access for characters.
 */
function fsgame_character_access($op, $node, $account) {
  if ($op == 'create') {
    return user_access('create 5 Second Game character', $account);
  }

  if ($op == 'update') {
    if (user_access('edit any 5 Second Game character', $account) ||
        (user_access('edit own 5 Second Game character', $account) && ($account->uid == $node->uid))) {
      return TRUE;
    }
  }

  if ($op == 'delete') {
    if (user_access('delete any 5 Second Game character', $account) ||
        (user_access('delete own 5 Second Game Character', $account) && ($account->uid == $node->uid))) {
      return TRUE;
    }
  }
}

/**
 * Implementation of hook_form() for characters.
 */
function fsgame_character_form(&$node, &$param) {
  drupal_add_css(drupal_get_path('module', 'fsgame') .'/fsgame.css');
  $type = node_get_types('type', $node);

  $form['title'] = array(
    '#default_value'  => isset($node->title) ? $node->title : '',
    '#title'          => check_plain($type->title_label),
    '#type'           => 'textfield',
    '#required'       => TRUE,
  );

  $form['fsgame'] = array('#tree' => TRUE);
  $form['fsgame']['character']['attributes'] = array(
    '#collapsible'  => TRUE,
    '#description'  => t("Your character's attributes affect how well the character performs in contests against other characters."),
    '#title'        => t('Attributes'),
    '#type'         => 'fieldset',
  );
  foreach (fsgame_base_attributes() as $attribute) {
    $form['fsgame']['character']['attributes'][$attribute['id']] = array(
      '#default_value'  => isset($node->fsgame['character'][$attribute['id']]) ? $node->fsgame['character'][$attribute['id']] : $attribute['default_value'],
      '#description'    => $attribute['description'],
      // when the form is submitted, make them keys of 'character'.
      '#parents'        => array('fsgame', 'character', $attribute['id']),
      '#title'          => $attribute['title'],
      '#type'           => 'textfield',
    );

    // disable attribute alteration if non-admin.
    if (!user_access('administer 5 Second Game')) {
      // #input has to be true so that these items get sent via a POST.
      // this saves us the effort of reloading the defaults in the 'insert'.
      $form['fsgame']['character']['attributes'][$attribute['id']]['#input'] = TRUE;
      $form['fsgame']['character']['attributes'][$attribute['id']]['#type']  = 'item';
      $form['fsgame']['character']['attributes'][$attribute['id']]['#value'] = $form['fsgame']['character']['attributes'][$attribute['id']]['#default_value'];
    }
  }

  // CSS wizardry to allow "centering" and larger sizes.
  $form['fsgame']['character']['attributes']['rock']['#prefix'] = '<div class="fsgame-character-attributes">';
  $form['fsgame']['character']['attributes']['scissors']['#suffix'] = '</div>';

  $form['fsgame']['character']['classes'] = array(
    '#collapsible'  => TRUE,
    '#title'        => t('Character class'),
    '#type'         => 'fieldset',
  );

//   $form['fsgame']['character']['skills'] = array(
//     '#collapsible'  => TRUE,
//     '#title'        => t('Character skills'),
//     '#type'         => 'fieldset',
//   );

    // Wrapper for fieldset contents (used by ahah.js).
  $form['fsgame']['character']['skill-wrapper'] = array(
    '#type' => 'item',
    '#prefix' => '<div id="fsgame-character-skill-wrapper">',
    '#suffix' => '</div>',
  );

//   $form['fsgame']['character']['skills'] = _fsgame_skill_select();

  // Need this for AJAX.
  $form['#cache'] = TRUE;
  drupal_add_js("if (Drupal.jsEnabled) { $(document).ready(function() { $('#edit-fsgame-character-pick-class').css('display', 'none'); }); }", 'inline');

  $form['fsgame']['character']['pick-class'] = array(
    '#type' => 'submit',
    '#value' => t('Change class (update list of skills)'),
      // Submit the node form so the parent select options get updated.
      // This is typically only used when JS is disabled.  Since the parent options
      // won't be changed via AJAX, a button is provided in the node form to submit
      // the form and generate options in the parent select corresponding to the
      // selected book.  This is similar to what happens during a node preview.
    '#submit' => array('node_form_submit_build_node'),
    '#weight' => 20,
  );


  // new character, so pick a class, bub.
  if (!$node->nid) {
    $class_checkboxes = array();
    foreach (fsgame_world_load('classes') as $class) {
      $class_checkboxes[$class['id']] = fsgame_attributes_modifiers_string($class);
    }

    if (count($class_checkboxes) == 0) {
      drupal_set_message(t("No character classes found; a site administrator needs to enable a 5 Second Game world."), 'error');
      return; // if the user hasn't enabled any game worlds, we need to exit immediately. classes are compulsory.
    }

    $form['fsgame']['character']['classes']['class'] = array(
      '#options'      => $class_checkboxes,
      // when the form is submitted, make it a key of 'character'.
      '#parents'      => array('fsgame', 'character', 'class'),
      '#required'     => TRUE,
      '#title'        => t('Character class'),
      '#type'         => 'radios',
      '#ahah' => array(
        'path' => 'fsgame/js/form',
        'wrapper' => 'fsgame-character-skill-wrapper',
        'effect' => 'slide',
      ),
    );
  }
  else { // existing character so stare at your stats, bub.
    $class = fsgame_world_load('classes', $node->fsgame['character']['class']);

    if (!$class) {
      drupal_set_message("This character's class was not found; please contact a site administrator.", 'error');
      return; // if this character no longer is plausible, complain loudly to the site admin cos they broke something.
    }

    $form['fsgame']['character']['classes']['class'] = array(
      '#type'         => 'item',
      '#value'        => t('Level @level !class_and_modifiers.',
        array(
          '@level' => $node->fsgame['character']['level'],
          '!class_and_modifiers' => fsgame_attributes_modifiers_string($class),
        )
      ),
    );

    foreach ($node->fsgame['character']['skills'] as $type => $skill) {
    }
//     $form['fsgame']['character']['skills']['skill'] = array(
//       '#type'         => 'item',
//       '#value'        => t('Level @level !class_and_modifiers.',
//         array(
//           '@level' => $node->fsgame['character']['level'],
//           '!class_and_modifiers' => fsgame_attributes_modifiers_string($class),
//         )
//       ),
//     );
  }

  $form['body'] = array(
    '#default_value'  => isset($node->body) ? $node->body : '',
    '#title'          => check_plain($type->body_label),
    '#type'           => 'textarea',
    '#required'       => FALSE,
    '#rows'           => 10,
  );

  $form['#validate'][] = 'fsgame_character_node_form_validate';

  return $form;
}

/**
 * FormAPI #validate for fsgame_character_form().
 */
function fsgame_character_node_form_validate($form, &$form_state) {
  foreach (fsgame_base_attributes() as $attribute) {
    if (!is_numeric($form_state['values']['fsgame']['character'][$attribute['id']])) {
      form_set_error('fsgame][character]['. $attribute['id'], t('The %attribute attribute must be a number.', array('%attribute' => fsgame_base_attributes($attribute['id'], 'title'))));
    }
  }
}

/**
 * Implementation of hook_load() for characters.
 */
function fsgame_character_load($node) {
  $character = db_fetch_array(db_query("SELECT * FROM {fsgame_character} WHERE nid = %d", $node->nid));
  return array('fsgame' => array('character' => $character));
}

/**
 * Implementation of hook_view() for characters.
 */
function fsgame_character_view($node, $teaser = FALSE, $page = FALSE) {
  drupal_add_css(drupal_get_path('module', 'fsgame') .'/fsgame.css');

  $node = node_prepare($node, $teaser);
  $node->content['fsgame_class'] = array(
    '#value' => theme('fsgame_character_class', $node),
  );

  $node->content['fsgame_attributes'] = array(
    '#value' => theme('fsgame_character_attributes', $node),
  );

  return $node;
}

/**
 * Implementation of hook_insert() for characters.
 */
function fsgame_character_insert($node) {
  global $user;

  $node->fsgame['character']['nid'] = $node->nid;

  // modify the attributes permanently based on the user's class.
  $class = fsgame_world_load('classes', $node->fsgame['character']['class']);
  if (isset($class['permanent modifiers'])) { // presuming, of course, they exist.
    foreach ($class['permanent modifiers'] as $attribute_id => $modifier) {
      $node->fsgame['character'][$attribute_id] += $modifier;
    }
  }

  drupal_write_record('fsgame_character', $node->fsgame['character']);

  $node->fsgame['character']['skills'][$node->fsgame['character']['skill']] = 1;
  $skill = array();
  $skill['skill'] = $node->fsgame['character']['skill'];
  $skill['level'] = 1;
  $skill['nid'] = $node->nid;
  unset($node->fsgame['character']['skill']);

  drupal_write_record('fsgame_character_skills', $skill);

  // If this is an anonymous user, then set the session to this character.
  if (!$user->uid) {
    $_SESSION['fsgame_contest_anonymous_character'] = $node->nid;
  }
  else {
    // Otherwise, this now counts as our latest character.
    fsgame_user_set_latest_character($user->uid, $node->nid);
  }
}

/**
 * Implementation of hook_update() for characters.
 */
function fsgame_character_update($node) {
  $node->fsgame['character']['nid'] = $node->nid;
  drupal_write_record('fsgame_character', $node->fsgame['character'], 'nid');
}

/**
 * Implementation of hook_delete() for characters.
 */
function fsgame_character_delete($node) {
  db_query('DELETE FROM {fsgame_character} WHERE nid = %d', $node->nid);
}

/**
 * Return the base definitions of our attributes.
 *
 * @param $attribute
 *   Defaults to NULL; one of 'rock', 'paper', or 'scissors'.
 * @param $key
 *   Defaults to NULL; one of 'title', 'description', 'default_value', 'maximum' or 'minimum'.
 * @return $array_or_string
 *   With no params, an array of 'rock', 'paper', and 'scissors', each containing:
 *     'title' => The title assigned by the administrator to the attribute.
 *     'description' => The description assigned by the administrator (default: none).
 *     'default_value' => The value the attribute will default to for a new character.
 *     'minimum' => The minimum value allowed. Normally the same as default_value.
 *     'maximum' => The maximum value allowed. 0 means there is no maximum.
 *     'trumps' => The internal attribute ID that this attribute beats in a tie.
 *     'id' => The internal ID of the attribute.
 *
 *   With an $attribute passed in, returns just the attribute specific keys above.
 *   With an $attribute and $key passed, the specific value of that key.
 */
function fsgame_base_attributes($attribute = NULL, $key = NULL) {
  $internal_ids = array('rock', 'paper', 'scissors');
  $trumps = array('scissors', 'rock', 'paper');
  static $attributes = array();

  if (!$attributes) {
    foreach ($internal_ids as $internal_key => $internal_id) {
      $attributes[$internal_id] = array(
        'title' => variable_get('fsgame_attributes_'. $internal_id .'_title', t(drupal_ucfirst($internal_id))),
        'description' => variable_get('fsgame_attributes_'. $internal_id .'_description', ''),
        'default_value' => variable_get('fsgame_attributes_'. $internal_id .'_default', 1),
        'minimum' => variable_get('fsgame_attributes_'. $internal_id .'_minimum', 1),
        'maximum' => variable_get('fsgame_attributes_'. $internal_id .'_maximum', 0),
        'trumps' => variable_get('fsgame_attributes_'. $attribute['id'] .'_trumps', $trumps[$internal_key]),
        'id' => $internal_id, // make it explicit for easier array looping.
      );
    }
  }

  return $attribute ? ($key ? $attributes[$attribute][$key] : $attributes[$attribute]) : $attributes;
}

/**
 * Return a list of attributes, suitable for use as FAPI #options.
 */
function fsgame_base_attributes_fapi() {
  $options = array();
  foreach (fsgame_base_attributes() as $attribute) {
    $options[$attribute['id']] = t(drupal_ucfirst($attribute['title']));
  } // this is not magick. we're just slightly lazy.
  return $options;
}

/**
 * Turn world data modifier into a human-readable string.
 *
 * The goal is ideally a string like: (Rock) (+2 Rock; -1 Paper).
 * where the first "(Rock)" is the primary attribute of this item
 * (or, in the case of classes, "(Rock/Paper/Paper)"), and then
 * any modifiers (either permanent or temporary) semi-colon spliced.
 *
 * @param $world_data
 *   The array containing information about the world data item.
 * @param $type
 *   What kind of human-readable data to return: defaults to "all".
 *   Can also be "permanent", "active", or "attributes". If you choose
 *   "all", the name of the world_data is also returned in the string.
 * @return $string
 *   A string suitable for printing.
 */
function fsgame_attributes_modifiers_string($world_data = array(), $type = 'all') {
  $attributes = array();
  if (is_array($world_data['attributes'])) {
    foreach ($world_data['attributes'] as $attribute_id) {
      $attributes[] = fsgame_base_attributes($attribute_id, 'title');
    } // build this item's attribute list (single or tri).
  }

  // permanent modifiers can never be removed once they're appended to the character.
  // active modifiers only apply when the world data is in use (an equipped item, etc.).
  foreach (array('permanent', 'active') as $modifier_type) {
    if (!isset($world_data[$modifier_type .' modifiers'])) { continue; }
    foreach ($world_data[$modifier_type .' modifiers'] as $attribute_id => $attribute_modifier) {
      if ($attribute_modifier > 0) { $attribute_modifier = '+'. $attribute_modifier; } // math symbolism goOOOd.
      $modifiers[$modifier_type][] = t('@attribute @modifier', array('@attribute' => fsgame_base_attributes($attribute_id, 'title'), '@modifier' => $attribute_modifier));
    } // if we've got some modifiers, we'll bundle them all together into a happy string, overwriting the interim array we've created. they then get inserted into the final string we return below.
    $modifiers[$modifier_type] = count($modifiers[$modifier_type]) > 0 ? t('<strong>@modifier_type</strong>: @modifiers', array('@modifier_type' => drupal_ucfirst($modifier_type), '@modifiers' => implode(', ', $modifiers[$modifier_type]))) : '';
  }

  switch ($type) {
    case 'all':
      return t('@title (@attributes!permanent_modifiers!active_modifiers)',
        array(
          '@title' => $world_data['title'],
          '@attributes' => implode('/', $attributes),
          '!permanent_modifiers' => $modifiers['permanent'] ? '; ' . $modifiers['permanent'] : '',
          '!active_modifiers' => $modifiers['active'] ? '; ' . $modifiers['active'] : '',
        )
      );
    case 'attributes':
      return t('@attributes', array('@attributes' => implode('/', $attributes)));
    case 'permanent':
      return t('!permanent_modifiers', array('!permanent_modifiers' => $modifiers['permanent']));
    case 'active':
      return t('!active_modifiers', array('!active_modifiers' => $modifiers['active']));
  }
}

/**
 *  This is the basic fight between two characters.
 *
 *  When running the contest, all stats are determined
 *
 *  @param &$contest
 *  This array will contain at a minimum the following elements. Modules implementing hook_fsgame_contest_alter may add to and alter
 *  this array at various stages in the contest.
 *
 *  At a minimum, the array must contain the following elements:
 *    'character' => A valid fsgame_character object owned by the current user.
 *    'opponent' => A valid fsgame_character object not owned by the current user.
 *    'character attack',
 *    'character defense',
 *    'opponent attack',
 *    'opponent defense' => Arrays containing the selected attacks and defenses of the characters.
 *      These will each contain at least the following:
 *      'skill' => the machine-name of the skill being used
 *      'attribute' => the stat the skill uses
 *      'title' => the human readable title of the skill being used
 *      'modifiers' => an array with modifiers to the specific attack or defense.
 *        these will be created by modules invoking hook_fsgame_contest_alter, and each key of the 'mods' sub-array must
 *        at least contain the following:
 *          'unique_modifier_id' => array('title' => A string describing the modifier, 'level' => The amount by which to modify the skill)
 *
 *  Throughout the contest, as hook_fsgame_contest is invoked, the current stage of the contest will be sent as an additional parameter.
 *
 *  After resolving the contest, a 'results' key in $contest will contain an array with information concerning the results.
 *  If that key is empty, then the contest was not resolved. Otherwise, it will contain at least the following elements:
 *    'character' => the final result of the character's attack
 *    'opponent' => the final result of the opponent's attack
 *    'win' => either the character object, the opponent object, or the string 'draw'
 */
function fsgame_contest(&$contest) {
  $contest['results'] = array();

  if (!fsgame_contest_allow($contest)) {
    // Set the win to disallowed. Additionally, a disallowing module may set an explanation string in $contest['results']['disallow'].
    $contest['results']['win'] = 'disallowed';
    return FALSE;
  }

  _fsgame_contest_select_opponent_modes($contest);

  // modules may add modifiers here
  drupal_alter('fsgame_contest', $contest, 'before');

  // tally the modifiers
  foreach (array('character', 'opponent') as $which) {
    foreach (array('attack', 'defense') as $element) {
      _fsgame_contest_tally_mid_results($contest, $which, $element);
    }
  }

  // modules may affect the initial results here
  drupal_alter('fsgame_contest', $contest, 'during');

  // tally final results, deducting valid defense from attacks and comparing final results
  foreach (array('character' => 'opponent', 'opponent' => 'character') as $defense => $attack) {
    if ($contest["$defense defense"]['attribute'] == $contest["$attack attack"]['attribute']) {
      $contest["$attack attack"]['result'] -= $contest["$defense defense"]['result'];
      drupal_set_message("defense against {$contest["$defense defense"]['attribute']}: $attack attack modified to {$contest["$attack attack"]['result']}.");
    }
  }

  _fsgame_contest_determine_winner($contest);

  // modules may act on the final results here
  drupal_alter('fsgame_contest', $contest, 'after');

  fsgame_character_set_latest_opponent($contest['character']->nid, $contest['opponent']->nid);
}

/**
 *  Implement hook_fsgame_contest.
 */
function fsgame_fsgame_contest(&$contest, $stage) {
  switch ($stage) {
    case 'allow':
      global $user;
      // Unless the user is an admin or the game otherwise allows, fail if the characters belong to the same user.
      if (!user_access('administer 5 Second Game') && !variable_get('fsgame_contest_allow_same_user', FALSE) && ($contest['character']->uid == $contest['opponent']->uid)) {
        $contest['results']['disallow'] = variable_get('fsgame_contest_disallow_same_user_message', t('You may not fight another character that you own.'));
        return FALSE;
      }
      return TRUE;
    case 'during':
      // TODO: add admin-determined dice rolls to results
  }
}

/**
 *  Determine the opponent's contest modes.
 */
function _fsgame_contest_select_opponent_modes(&$contest) {
  $attributes = fsgame_base_attributes();
  foreach ($attributes as $key => $attribute) {
    $attacks[$key] = $attribute['title'];
    $defenses[$key] = $attribute['title'];
  }
  // Allow modules implementing hook_fsgame_available_modes_alter to add/remove their own skills to/from the selectors.
  drupal_alter('fsgame_available_modes', $attacks, 'opponent', 'attack', $contest['character'], $contest['opponent']);
  drupal_alter('fsgame_available_modes', $defenses, 'opponent', 'defense', $contest['character'], $contest['opponent']);

  // select a random attack/defense from the remaining options
  $contest['opponent attack'] = fsgame_contest_select_mode('attack', array_rand($attacks), $contest['opponent'], $contest['character']);
  $contest['opponent defense'] = fsgame_contest_select_mode('defense', array_rand($defenses), $contest['opponent'], $contest['character']);
}

/**
 *  This will populate the appropriate array with the skill & modifiers for a contest.
 *  @param $mode
 *    'attack' or 'defense'
 *  @param $skill
 *    A string with the key to a skill.
 *  @param $character
 *    The character node whose skill this is. Note that this may refer to a contest's character or opponent.
 *  @param $opponent
 *    The character node opposing the character.
 */
function fsgame_contest_select_mode($mode, $skill, $character, $opponent) {
  return array(
    'skill' => $skill,
    'attribute' => $skill,
    'title' => 'The skill title',
    'modifiers' => array(
      'base' => array(
        'title' => 'A random modifier',
        'level' => fsgame_dice('1d6'),
      ),
    ),
  );
}

/**
 *  Allow modules to disallow a contest between characters.
 *  If a module implements hook_fsgame_allow_contest, then that hook will be invoked.
 *  If any hook returns FALSE, then the contest will be disallowed, halting further processing.
 *  @param $contest
 *    A contest array, as outlined in fsgame_contest.
 */
function fsgame_contest_allow(&$contest) {
  // don't allow nodes that are not fsgame_character type to continue, or if they are the same character.
  if ($contest['character']->type != 'fsgame_character' || $contest['opponent']->type != 'fsgame_character') {
    $contest['results']['disallow'] = variable_get('fsgame_contest_disallow_illegal_type_message', t('Illegal character types.'));
    return FALSE;
  }
  if ($contest['character']->nid == $contest['opponent']->nid) {
    $contest['results']['disallow'] = variable_get('fsgame_contest_disallow_self_contest_message', t('You may not fight yourself.'));
    return FALSE;
  }
  foreach (module_implements('fsgame_contest') as $module) {
    if (!module_invoke($module, 'fsgame_contest', $contest, 'allow')) {
      // If a module disallows a contest, it may send an explanation to $contest['results']['disallow'].
      return FALSE;
    }
  }
  return TRUE;
}

function _fsgame_contest_determine_winner(&$contest) {
  foreach (array('character' => 'opponent', 'opponent' => 'character') as $attacker => $defender) {
    $contest['results'][$attacker] = $contest["$attacker attack"]['result'];
    if (fsgame_base_attributes($contest["$attacker attack"]['attribute'], 'trumps') == $contest["$defender attack"]['attribute']) {
      $contest['results'][$attacker] = intval($contest['results'][$attacker] * variable_get('fsgame_trump_multiplier', 1.5));
      drupal_set_message("$attacker {$contest["$attacker attack"]['attribute']} trumps {$contest["$defender attack"]['attribute']}: X 1.5 = {$contest['results'][$attacker]}.");
    }
  }
  if ($contest['results']['character'] > $contest['results']['opponent']) {
    $contest['results']['win'] = $contest['character'];
  }
  else if ($contest['results']['opponent'] > $contest['results']['character']) {
    $contest['results']['win'] = $contest['opponent'];
  }
  else if (variable_get('fsgame_allow_draws', TRUE)) {
    $contest['results']['win'] = 'draw';
  }
  else {
    $contest['results']['win'] = $contest['opponent'];
  }
}

function _fsgame_contest_tally_mid_results(&$contest, $which, $element) {
//   $value = isset($contest[$which .' '. $element]['attribute']) ? $contest[$which]->{$contest[$which .' '. $element]['attribute']} : 0;
  $contest[$which .' '. $element]['result'] = intval($value) + _fsgame_contest_apply_modifiers($contest[$which .' '. $element]);
  drupal_set_message("$which $element: {$contest[$which .' '. $element]['result']} ({$contest[$which .' '. $element]['attribute']})");
}

function _fsgame_contest_apply_modifiers($mode) {
  $level = 0;
  if (is_array($mode['modifiers'])) {
    foreach ($mode['modifiers'] as $modifier) {
      $level += intval($modifier['level']);
    }
  }
  return $level;
}

/**
 * Load and cache our various world data.
 *
 * This is a generic world loading function so that new modules
 * can benefit from this API, and the cache that it creates.
 *
 * @param $type
 *   The type of data to load (classes, items, arenas, etc.).
 * @param $id
 *   If passed, the ID of $type that should be returned.
 * @param $refresh
 *   Forces a refresh of the cached $type data.
 * @return $items
 *   If $type not passed, all world data currently loaded.
 *   If $type is passed, an array of all known world data of that type.
 *   If $type and $id passed, the specific data of $type to return.
 */
function fsgame_world_load($type = NULL, $id = NULL, $refresh = FALSE) {
  static $world = array();

  if (!$world[$type] || $refresh) {
    if (!$refresh && $cache = cache_get('fsgame_world_'. $type)) {
      $world[$type] = unserialize($cache->data);
    }
    else {
      $world[$type] = module_invoke_all('fsgame_world_'. $type);
      foreach ($world[$type] as $type_id => $type_info) {
        // store the ID inside for easier reference.
        $world[$type][$type_id]['id'] = $type_id;
      } // cache this world type data for one hour.
      arsort($world[$type]); // alphabetical order please.
      cache_set('fsgame_world_'. $type, serialize($world[$type]), 'cache', time() + 3600);
    }
  }

  return $type ? ($id ? $world[$type][$id] : $world[$type]) : $world;
}

/**
 * Roll dice and return the sum. Simple enough, eh?
 *
 * The only parameter is a string in traditional RPG dice notation. Examples
 * include 4d6, 3d8, 3^5d6 (weighted, taking the highest 3 of 5 dice rolled),
 * 1d100+50, 6d6-6, 1d50+50*4-1, and so on and so forth.
 */
function fsgame_dice($notation) {

  // remove whitespace and turn "x" to "*".
  $notation = str_replace('x', '*', $notation);
  $notation = preg_replace('/\s/', '', $notation);

  // if we're keeping high rolls, find out how many and store in $keep_highest.
  if (strstr($notation, '^')) { list($keep_highest, $notation) = explode('^', $notation); }

  // split our notation on the "d". nothing magical.
  list($num_rolls, $remainder) = explode('d', $notation);

  // if there are operations to be done after the dice roll,
  // split at the first one so we can get the number of sides,
  // and save the rest into $modifiers for eval()ing later on.
  if (preg_match('/^\d*([\+\-\*\/])/', $remainder)) {
    $matches = preg_split('/([\+\-\*\/])/', $remainder, -1, PREG_SPLIT_DELIM_CAPTURE);
    $num_sides = array_shift($matches); $modifiers = implode('', $matches);
  } else { $num_sides = $remainder; $modifiers = NULL; }

  // roll however many times necessary and $keep_highest as needed.
  for ($ctr = 0; $ctr < $num_rolls; $ctr++) { $virgins[] = rand(1, $num_sides); }
  if (isset($keep_highest)) { rsort($virgins); $virgins = array_splice($virgins, 0, $keep_highest); }
  $rolling_result = array_sum($virgins);

  // eval is simply easiest here so if we have to run one,
  // we'll remove anything not a number or math-related.
  if (isset($modifiers)) {
    // TODO: i think the "d" is misleading -- makes it seem like it processes multiple dice events,
    // when it's actually ignored and fails everything after. -winborn
    $modifiers = preg_replace('/[^(\d|\+|\-|\*|\/|\(|\))]/', '', $modifiers);
    eval("\$final_result = $rolling_result $modifiers;"); // ssshShHhh.
  } else { $final_result = $rolling_result; }

  return $final_result;
}

/**
 *  Implement hook_user.
 *  @TODO: This doesn't seem to work properly.
 */
function fsgame_user($op, &$edit, &$account, $category = NULL) {
  switch ($op) {
    case 'login':
      if ($_SESSION['fsgame_contest_anonymous_character']) {
        $node = node_load($_SESSION['fsgame_contest_anonymous_character']);
        if (fsgame_claim_access($node)) {
          drupal_set_message(t("The character %title was created anonymously from this computer. You may not use the character again unless you !claim. If you do not claim that character before logging off, then it may not be used again.", array('%title' => $node->title, '!claim' => l(t('claim the character'), 'fsgame/claim/'. $node->nid))));
        }
      }
      break;
    case 'logout':
      unset($_SESSION['fsgame_contest_anonymous_character']);
      break;
    case 'load':
      $account->fsgame_latest_character = fsgame_user_get_latest_character($account->uid);
      break;
    case 'save':
      fsgame_user_set_latest_character($account->uid, $account->fsgame_latest_character);
      break;
    case 'delete':
      db_query('DELETE FROM {fsgame_user} WHERE uid = %d', $account->uid);
      break;
  }
}

/**
 *  Set the most recently accessed character of a user's account.
 *  @param $uid
 *    The account uid to set the latest character.
 *    If it equals $global $user->uid, then we also set $user->fsgame_latest_character to that character.
 *  @param $nid
 *    The nid of the character node.
 *  @return
 *    FALSE if unsuccessful. Otherwise SAVED_NEW or SAVED_UPDATED.
 */
function fsgame_user_set_latest_character($uid, $nid) {
  if ($uid && is_numeric($uid) && $nid && is_numeric($nid)) {
    global $user;
    if ($uid == $user->uid) {
      $user->fsgame_latest_character = $nid;
    }
    if (db_result(db_query("SELECT uid FROM {fsgame_user} WHERE uid=%d", $uid))) {
      return drupal_write_record('fsgame_user', $user, 'fsgame_latest_character');
//       db_query("UPDATE {fsgame_user} SET latest_character = %d WHERE uid = %d", $nid, $uid);
    }
    else {
      return drupal_write_record('fsgame_user', $user);
//       db_query("INSERT INTO {fsgame_user} (uid, latest_character) VALUES (%d, %d)", $uid, $nid);
    }
  }
  return FALSE;
}

/**
 *  Return the most recently accessed character of an account.
 *  @param $uid
 *    The account to check for the latest character.
 *  @return
 *    The nid of the account's latest character node.
 */
function fsgame_user_get_latest_character($uid) {
  return db_result(db_query("SELECT fsgame_latest_character FROM {fsgame_user} WHERE uid=%d", $uid));
}

/**
 *  Return the most recently fought opponent of a character.
 *  @param $nid
 *    The character to check for the latest opponent.
 *  @return
 *    The nid of the character's latest opponent node.
 */
function fsgame_character_get_latest_opponent($nid) {
  return db_result(db_query("SELECT latest_opponent FROM {fsgame_character} WHERE nid=%d", $nid));
}

/**
 *  Set the most recently fought opponent of a character.
 *  @param $character_nid
 *    The nid of the character node.
 *  @param $opponent_nid
 *    The nid of the opponent node.
 */
function fsgame_character_set_latest_opponent($character_nid, $opponent_nid) {
  if ($character_nid && is_numeric($character_nid) && $opponent_nid && is_numeric($opponent_nid)) {
    db_query("UPDATE {fsgame_character} SET latest_opponent = %d WHERE nid = %d", $opponent_nid, $character_nid);
  }
}