/**************************************************************************
*  Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,        *
*  Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe.   *
*                                                                         *
*  Merc Diku Mud improvements copyright (C) 1992, 1993 by Michael         *
*  Chastain, Michael Quan, and Mitchell Tse.                              *
*                                                                         *
*  In order to use any part of this Merc Diku Mud, you must comply with   *
*  both the original Diku license in 'license.doc' as well the Merc       *
*  license in 'license.txt'.  In particular, you may not remove either of *
*  these copyright notices.                                               *
*                                                                         *
*  Much time and thought has gone into this software and you are          *
*  benefiting.  We hope that you share your changes too.  What goes       *
*  around, comes around.                                                  *
***************************************************************************
*       ROM 2.4 is copyright 1993-1998 Russ Taylor                        *
*       ROM has been brought to you by the ROM consortium                 *
*           Russ Taylor (rtaylor@hypercube.org)                           *
*           Gabrielle Taylor (gtaylor@hypercube.org)                      *
*           Brian Moore (zump@rom.org)                                    *
*       By using this code, you have agreed to follow the terms of the    *
*       ROM license, in the file Rom24/doc/rom.license                    *
***************************************************************************
*          1stMud ROM Derivative (c) 2001-2004 by Markanth                *
*            http://www.firstmud.com/  <markanth@firstmud.com>            *
*         By using this code you have agreed to follow the term of        *
*             the 1stMud license in ../doc/1stMud/LICENSE                 *
***************************************************************************/

#include "merc.h"
#include "tables.h"
#include "recycle.h"
#include "interp.h"
#include "vnums.h"

Proto (void death_cry, (CharData *));

Do_Fun (do_arena_challenge)
{
  CharData *victim;

  if (IsNPC (ch))
    return;

  if (!str_cmp (argument, "self") || !str_cmp (argument, "drop"))
    {
      extract_arena (ch);
      chprintln (ch, "You retract your challenge.");
      return;
    }

  if (mud_info.arena == FIGHT_START)
    {
      chprintln
	(ch,
	 "Sorry, some one else has already started a challenge, please try later.");
      return;
    }

  if (mud_info.arena == FIGHT_BUSY)
    {
      chprintln
	(ch,
	 "Sorry, there is a fight in progress, please wait a few moments.");
      return;
    }

  if (mud_info.arena == FIGHT_LOCK)
    {
      chprintln (ch, "Sorry, the arena is currently locked from use.");
      return;
    }

  if (ch->pcdata->challenger)
    {
      chprintlnf
	(ch,
	 "You have already been challenged, either ACCEPT or DECLINE %s first.",
	 ch->pcdata->challenger->name);
      return;
    }

  if (ch->hit < ch->max_hit)
    {
      chprintln (ch, "You must be fully healed to fight in the arena.");
      return;
    }

  if (NullStr (argument))
    {
      chprintln (ch, "You must specify whom you wish to challenge.");
      return;
    }

  if ((victim = get_char_world (ch, argument)) == NULL)
    {
      chprintln (ch, "They are not playing.");
      return;
    }

  if (IsNPC (victim) || IsImmortal (victim) || victim == ch)
    {
      chprintln (ch, "You cannot challenge NPC's or yourself.");
      return;
    }

  if (!can_see (victim, ch))
    {
      chprintln (ch, "They can't see you.");
      return;
    }

  if (victim->pcdata->challenger)
    {
      chprintln (ch, "They have already challenged someone else.");
      return;
    }

  if (victim->fighting != NULL)
    {
      chprintln (ch, "That person is engaged in battle right now.");
      return;
    }

  if (victim->hit < victim->max_hit)
    {
      chprintln (ch, "That player is not healthy enough to fight right now.");
      return;
    }

  if (victim->desc == NULL)
    {
      chprintln (ch,
		 "That player is linkdead at the moment, try them later.");
      return;
    }

  ch->pcdata->challenged = victim;
  victim->pcdata->challenger = ch;
  mud_info.arena = FIGHT_START;
  chprintlnf
    (ch,
     "Challenge has been sent.  Type '%s drop' to cancel the challenge.",
     n_fun);
  act ("{R$n has challenged you to a death match.", ch, NULL, victim,
       TO_VICT);
  announce (victim, INFO_ARENA, "%s has challenged $n to a duel.", ch->name);
  chprintlnf (victim, "Type: ARENA ACCEPT %s to meet the challenge.",
	      ch->name);
  chprintlnf (victim, "Type: ARENA DECLINE %s to chicken out.{x", ch->name);
  return;
}

Do_Fun (do_arena_accept)
{
  float odd1, odd2;
  float lvl1, lvl2;
  CharData *victim;
  RoomIndex *random1;
  RoomIndex *random2;

  random1 =
    get_room_index ((number_range
		     (ROOM_VNUM_DUEL_START, ROOM_VNUM_DUEL_END)));
  random2 =
    get_room_index ((number_range
		     (ROOM_VNUM_DUEL_START, ROOM_VNUM_DUEL_END)));

  if (IsNPC (ch))
    return;

  if (!ch->pcdata->challenger)
    {
      chprintln (ch, "You have not been challenged.");
      return;
    }

  if (mud_info.arena == FIGHT_BUSY)
    {
      chprintln
	(ch,
	 "Sorry, there is a fight in progress, please wait a few moments.");
      return;
    }

  if (mud_info.arena == FIGHT_LOCK)
    {
      chprintln (ch, "Sorry, the arena is currently locked from use.");
      return;
    }

  if (NullStr (argument))
    {
      chprintln (ch, "You must specify whose challenge you wish to accept.");
      return;
    }

  if ((victim = get_char_world (ch, argument)) == NULL)
    {
      chprintln (ch, "They aren't logged in!");
      return;
    }

  if (victim == ch)
    {
      chprintln (ch, "You haven't challenged yourself!");
      return;
    }

  if (!victim->pcdata->challenged || victim != ch->pcdata->challenger)
    {
      chprintln (ch, "That player hasn't challenged you!");
      return;
    }

  chprintln (ch, "You have accepted the challenge!");
  act ("$n accepts your challenge!", ch, NULL, victim, TO_VICT);

  lvl1 = ch->hit + 1;
  lvl2 = victim->hit + 1;
  odd1 = (lvl1 / lvl2);
  odd2 = (lvl2 / lvl1);
  announce (NULL, INFO_ARENA, "%s (%d wins) (%d losses) Payoff odds %.2f",
	    victim->name, victim->pcdata->awins, victim->pcdata->alosses,
	    odd1);
  announce (NULL, INFO_ARENA, "%s (%d wins) (%d losses) Payoff odds %.2f",
	    ch->name, ch->pcdata->awins, ch->pcdata->alosses, odd2);
  announce (NULL, INFO_ARENA,
	    "To wager on the fight, type: arena bet (amount) (player name)");

  chprintln (ch, "You make your way into the arena.");
  char_from_room (ch);
  char_to_room (ch, random1);
  do_function (ch, &do_look, "auto");
  chprintln (victim, "You make your way to the arena.");
  char_from_room (victim);
  char_to_room (victim, random2);
  do_function (victim, &do_look, "auto");
  mud_info.arena = FIGHT_BUSY;
  return;
}

Do_Fun (do_arena_decline)
{
  CharData *victim;

  if (IsNPC (ch))
    return;

  if (!ch->pcdata->challenger)
    {
      chprintln (ch, "You have not been challenged.");
      return;
    }

  if (NullStr (argument))
    {
      chprintln (ch, "You must specify whose challenge you wish to decline.");
      return;
    }

  if ((victim = get_char_world (ch, argument)) == NULL)
    {
      chprintln (ch, "They aren't logged in!");
      return;
    }

  if (!victim->pcdata->challenged || victim != ch->pcdata->challenger)
    {
      chprintln (ch, "That player hasn't challenged you.");
      return;
    }

  if (victim == ch)
    return;

  ch->pcdata->challenged = NULL;
  victim->pcdata->challenged = NULL;
  ch->pcdata->challenger = NULL;
  victim->pcdata->challenger = NULL;
  mud_info.arena = FIGHT_OPEN;
  chprintln (ch, "Challenge declined!");
  act ("$n has declined your challenge.", ch, NULL, victim, TO_VICT);
  announce (ch, INFO_ARENA, "$n has declined %s's challenge.", victim->name);

  return;
}

Do_Fun (do_arena_bet)
{
  char arg[MIL];
  CharData *fighter;
  money_t wager;

  if (IsNPC (ch))
    return;

  argument = one_argument (argument, arg);

  if (NullStr (argument) || !is_number (arg))
    {
      cmd_syntax (ch, NULL, n_fun, "[amount] [player]", NULL);
      return;
    }

  if (ch->pcdata->gladiator != NULL)
    {
      chprintln (ch, "You have already placed a bet on this fight.");
      return;
    }

  if (ch->pcdata->challenger || ch->pcdata->challenged)
    {
      chprintln (ch, "You can't bet on this battle.");
      return;
    }

  fighter = get_char_world (ch, argument);

  if (fighter == NULL)
    {
      chprintln (ch, "That player is not logged in.");
      return;
    }

  if (IsNPC (fighter))
    {
      chprintln (ch, "Why bet on a mob? They aren't fighting...");
      return;
    }

  if (!IsSet (fighter->in_room->room_flags, ROOM_ARENA))
    {
      chprintln (ch, "That player is not in the arena.");
      return;
    }

  if (!str_prefix ("-", arg))
    {
      chprintln (ch, "Error: Invalid argument!");
      return;
    }

  wager = atoi (arg);

  if (wager > 5000 || wager < 1)
    {
      chprintln (ch, "Wager range is between 1 and 5,000");
      return;
    }

  if (!check_worth (ch, wager, VALUE_GOLD))
    {
      chprintln (ch, "You don't have that much gold to wager!");
      return;
    }

  ch->pcdata->gladiator = fighter;
  ch->pcdata->plr_wager = wager;
  chprintlnf (ch, "You have placed a %ld gold wager on %s",
	      wager, fighter->name);
  return;
}

void
check_arena (CharData * ch, CharData * victim)
{
  CharData *wch;
  float odds;
  float lvl1, lvl2;
  money_t payoff = 0;

  if (IsNPC (ch) || IsNPC (victim))
    return;
  announce (victim, INFO_ARENA, "%s has defeated $n!", ch->name);
  ch->pcdata->awins += 1;
  victim->pcdata->alosses += 1;
  lvl1 = ch->hit + 1;
  lvl2 = victim->hit + 1;
  odds = (lvl2 / lvl1);
  for (wch = player_first; wch; wch = wch->next_player)
    {
      if (wch->pcdata->gladiator == ch)
	{
	  payoff = wch->pcdata->plr_wager * (Max ((money_t) odds + 1, 2));
	  chprintlnf (wch, "You won! Your wager: %ld, payoff: %ld",
		      wch->pcdata->plr_wager, payoff);
	  add_cost (wch, Max (0, payoff), VALUE_GOLD);
	  wch->pcdata->gladiator = NULL;
	  wch->pcdata->plr_wager = 0;
	  payoff = 0;
	}
      if (wch->pcdata->gladiator && wch->pcdata->gladiator != ch
	  && wch->pcdata->plr_wager >= 1)
	{
	  chprintlnf (wch, "You lost! Your wager: %ld",
		      wch->pcdata->plr_wager);
	  deduct_cost (wch, wch->pcdata->plr_wager, VALUE_GOLD);

	  wch->pcdata->gladiator = NULL;
	  wch->pcdata->plr_wager = 0;
	}
    }

  stop_fighting (victim, true);
  death_cry (victim);
  char_from_room (victim);
  char_to_room (victim, get_room_index (ROOM_VNUM_DUEL_LOSER));
  victim->hit = victim->max_hit;
  victim->mana = victim->max_mana;
  victim->move = victim->max_move;
  update_pos (victim);
  do_function (victim, &do_look, "auto");
  stop_fighting (ch, true);
  char_from_room (ch);
  char_to_room (ch, get_room_index (ROOM_VNUM_DUEL_WINNER));
  ch->hit = ch->max_hit;
  ch->mana = ch->max_mana;
  ch->move = ch->max_move;
  update_pos (ch);
  do_function (ch, &do_look, "auto");

  ch->pcdata->challenger = NULL;
  ch->pcdata->challenged = NULL;
  victim->pcdata->challenger = NULL;
  victim->pcdata->challenged = NULL;

  mud_info.arena = FIGHT_OPEN;

  return;
}

void
extract_arena (CharData * ch)
{
  if (mud_info.arena == FIGHT_START && ch->pcdata->challenger != NULL)
    do_function (ch, &do_arena_decline, ch->pcdata->challenger->name);
  if (mud_info.arena == FIGHT_START && ch->pcdata->challenged != NULL)
    {
      ch->pcdata->challenged->pcdata->challenger = NULL;
      ch->pcdata->challenged = NULL;
      mud_info.arena = FIGHT_OPEN;
    }
}

bool
IS_IN_ARENA (CharData * ch)
{
  if (!ch)
    return false;

  if (IsNPC (ch))
    return false;

  if (!ch->pcdata->challenged && !ch->pcdata->challenger)
    return false;

  if (!ch->in_room)
    return false;

  if (!IsSet (ch->in_room->room_flags, ROOM_ARENA))
    return false;

  return true;
}

Do_Fun (do_arena_help)
{
  cmd_syntax (ch, NULL, n_fun, "challenge <name>|drop",
	      "accept <name>", "decline <name>", "bet <name>", NULL);

  if (IsImmortal (ch))
    {
      cmd_syntax (ch, NULL, n_fun, "clear|lock|busy>", NULL);
      switch (mud_info.arena)
	{
	case FIGHT_OPEN:
	  chprintln (ch, "Arena is [CLEAR]");
	  break;

	case FIGHT_START:
	  chprintln (ch, "A challenge has been started.");
	  break;

	case FIGHT_BUSY:
	  chprintln (ch, "Arena is [BUSY]");
	  break;

	case FIGHT_LOCK:
	  chprintln (ch, "Arena is [LOCKED]");
	}
    }
  return;
}

Do_Fun (do_arena_clear)
{
  Descriptor *d;

  if (!IsImmortal (ch))
    {
      do_arena_help (n_fun, ch, "");
      return;
    }
  mud_info.arena = FIGHT_OPEN;
  chprintln (ch, "Arena now set [CLEARED]");
  announce (NULL, INFO_ARENA, "The arena has been opened.");
  for (d = descriptor_first; d != NULL; d = d->next)
    {
      if (d->connected == CON_PLAYING && d->character)
	{
	  d->character->pcdata->challenger = NULL;
	  d->character->pcdata->challenged = NULL;
	  if (IsSet (d->character->in_room->room_flags, ROOM_ARENA))
	    {
	      char_from_room (ch);
	      char_to_room (ch, get_room_index (ROOM_VNUM_TEMPLE));
	      chprintln (d->character,
			 "You re-appear in the Temple of Midgaard.");
	    }
	}
    }
  return;
}

Do_Fun (do_arena_busy)
{
  if (!IsImmortal (ch))
    {
      do_arena_help (n_fun, ch, "");
      return;
    }
  mud_info.arena = FIGHT_BUSY;
  chprintln (ch, "Arena now set [BUSY]");
  announce (NULL, INFO_ARENA, "The arena is now busy.");
  return;

}

Do_Fun (do_arena_lock)
{
  if (!IsImmortal (ch))
    {
      do_arena_help (n_fun, ch, "");
      return;
    }
  mud_info.arena = FIGHT_LOCK;
  chprintln (ch, "Arena now set [LOCKED]");
  announce (NULL, INFO_ARENA, "The arena has been locked.");
  return;
}

Do_Fun (do_arena)
{
  vinterpret (ch, n_fun, argument, "challenge", do_arena_challenge,
	      "decline", do_arena_decline, "accept", do_arena_accept,
	      "bet", do_arena_bet, "clear", do_arena_clear, "busy",
	      do_arena_busy, "lock", do_arena_lock, NULL, do_arena_help);
}