/**************************************************************************
*  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 "vnums.h"
#include "interp.h"

Do_Fun(do_remort)
{
	Descriptor *d;
	CharData *mob;
	void send_race_info(Descriptor *);
	void send_class_info(Descriptor *);

	if (IsNPC(ch) || (d = ch->desc) == NULL)
		return;

	if (ch->in_room->guild == -1 || !is_class(ch, ch->in_room->guild))
	{
		chprintlnf(ch, "You must be at your class%s guild to do that.",
				   IsRemort(ch) ? "(s)" : "");
		return;
	}

	for (mob = ch->in_room->person_first; mob; mob = mob->next_in_room)
	{
		if (IsNPC(mob) && IsSet(mob->act, ACT_TRAIN | ACT_GAIN))
			break;
	}

	if (mob == NULL)
	{
		chprintln(ch, "You can't do that here.");
		return;
	}

	if (ch->level < calc_max_level(ch))
	{
		chprintlnf(ch, "You must be a %s to remort.",
				   high_level_name(calc_max_level(ch), true));
		return;
	}

	if (ch->Class[CLASS_COUNT] == MAX_REMORT
		|| ch->Class[CLASS_COUNT] == top_class)
	{
		chprintln(ch, "You can't remort any more!");
		return;
	}

	if (IsQuester(ch) || Gquester(ch))
	{
		chprintln(ch, "Don't you want to finish your quest first?");
		return;
	}

	if (!check_worth(ch, 500000, VALUE_GOLD)
		|| ch->pcdata->quest.points < 500)
	{
		chprintln(ch,
				  "You need 500,000 gold and 500 quest points to remort.");
		return;
	}

	if (ch->pcdata->confirm_remort)
	{
		if (!NullStr(argument))
		{
			chprintln(ch, "Remort status removed.");
			ch->pcdata->confirm_remort = false;
			return;
		}
		else
		{
			dwraplnf(ch->desc,
					 "You have chosen to remort.  You will now be dropped in at the %s"
					 " selection section of character creation, and will be allowed recreate"
					 " your character with an additional {Cclass{x%s and {Gbonuses{x."
					 NEWLINE
					 "In the unlikely event that you are disconnected or the Mud"
					 " crashes while you are creating your character, log back on and write a"
					 " note to an immortal who will retrieve your backup.",
					 !ch->pcdata->stay_race ? "{BRACE{x" : "{CCLASS{x",
					 !ch->pcdata->stay_race ? ", {brace{x" : "");
			wiznet("$N has remorted.", ch, NULL, 0, true, 0);
			char_from_room(ch);
			char_to_room(ch, get_room_index(ROOM_VNUM_LIMBO));
			UnLink(ch, char, next, prev);

			UnLink(ch, player, next_player, prev_player);

			chprintln(ch, NEWLINE "Now beginning the remorting process.");

			if (!ch->pcdata->stay_race)
			{
				send_race_info(ch->desc);
				chprint(ch,
						NEWLINE
						"What is your race (help for more information)?");
				d->connected = CON_GET_NEW_RACE;
			}
			else
			{
				ch->pcdata->points = ch->race->points;

				send_class_info(ch->desc);
				chprintln(ch, "What is your next class? ");
				d->connected = CON_GET_NEW_CLASS;
			}
			return;
		}
	}

	if (!NullStr(argument))
	{
		chprintln(ch, "Just type remort.  No argument.");
		return;
	}
	dwraplnf(ch->desc,
			 "{RTyping {Gremort{R with an argument will undo remort status."
			 "  Remorting is {Wnot reversable{R, make sure you read help REMORT"
			 " and have an idea of what {Cclass%s{R you want to remort into."
			 "  Type {Gremort{R again to confirm this command.{x",
			 !ch->pcdata->stay_race ? "and {Brace" : "");
	ch->pcdata->confirm_remort = true;
	if (!ch->pcdata->stay_race)
		chprintln(ch,
				  "{f{WWARNING{x{R: IF YOU CHOOSE A RACE DIFFERENT FROM YOUR RACE NOW YOU WILL BE THAT RACE {fFOREVER{x{R.{x");
	wiznet("$N is contemplating remorting.", ch, NULL, 0, false,
		   get_trust(ch));
}

void finish_remort(CharData * ch)
{
	int sn, b = lvl_bonus(ch);
	ObjData *obj, *obj_next;
	AffectData *af, *af_next;

	d_println(ch->desc, "Sucessful Remort!");
	wiznet("Sucessful Remort! $N sighted.", ch, NULL, 0, false, 0);

	Link(ch, char, next, prev);

	Link(ch, player, next_player, prev_player);

	for (af = ch->affect_first; af != NULL; af = af_next)
	{
		af_next = af->next;
		affect_remove(ch, af);
	}
	for (obj = ch->carrying_first; obj != NULL; obj = obj_next)
	{
		obj_next = obj->next_content;
		if (obj->wear_loc != WEAR_NONE)
		{
			unequip_char(ch, obj);
		}
	}
	ch->trust = ch->level;
	ch->level = 1;
	ch->exp = 0;
	ch->pcdata->points = 0;
	deduct_cost(ch, 500000, VALUE_GOLD);
	ch->pcdata->quest.points -= 500;
	ch->max_hit = 100 * b;
	ch->max_mana = 100 * b;
	ch->max_move = 100 * b;
	ch->hit = ch->max_hit;
	ch->mana = ch->max_move;
	ch->move = ch->max_mana;
	ch->pcdata->perm_hit = ch->max_hit;
	ch->pcdata->perm_mana = ch->max_mana;
	ch->pcdata->perm_move = ch->max_move;
	ch->wimpy = ch->max_hit / 5;
	ch->train = 5 * b;
	ch->practice = 7 * b;
	ch->exp = exp_per_level(ch, ch->pcdata->points);
	reset_char(ch);

	if (ch->pet != NULL)
	{
		nuke_pets(ch);
		ch->pet = NULL;
	}

	for (sn = 0; sn < top_skill; sn++)
	{
		if (ch->pcdata->learned[sn] > 0 && ch->pcdata->learned[sn] < 100)
		{
			if (is_race_skill(ch, sn) && !ch->pcdata->stay_race)
				ch->pcdata->learned[sn] = 0;
			else
				ch->pcdata->learned[sn] = 1;
		}
	}
	char_from_room(ch);
	char_to_room(ch, get_room_index(ROOM_VNUM_SCHOOL));
	ch->desc->connected = CON_PLAYING;
	act
		("You are brought back to reality, and you feel quite different now...",
		ch, NULL, NULL, TO_CHAR);
	do_function(ch, &do_outfit, "");
	save_char_obj(ch);
	mud_info.stats.remorts++;
}

bool can_use_skpell(CharData * ch, int sn)
{
	int i;

	if (sn < 0 || sn >= top_skill)
		return false;

	if (IsNPC(ch))
		return true;

	if (is_race_skill(ch, sn))
		return true;

	if (is_deity_skill(ch, sn))
		return true;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
		if (ch->level >= skill_table[sn].skill_level[ch->Class[i]])
			return true;

	return false;
}

bool has_spells(CharData * ch)
{
	int i;

	if (IsNPC(ch))
		return false;
	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
		if (class_table[i].fMana)
			return true;
	return false;
}

bool is_class(CharData * ch, int Class)
{
	int i;

	if (IsNPC(ch))
		return false;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
	{
		if (ch->Class[i] == Class)
			return true;
	}

	return false;
}

bool is_same_class(CharData * ch, CharData * victim)
{
	int i, jClass;

	if (IsNPC(ch) || IsNPC(victim))
		return false;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
	{
		for (jClass = 0; victim->Class[jClass] != -1; jClass++)
			if (ch->Class[i] == victim->Class[jClass])
				return true;
	}

	return false;
}

int prime_class(CharData * ch)
{
	int slot = 0;

	if (!IsNPC(ch))
		slot = Range(0, ch->pcdata->prime_class, ch->Class[CLASS_COUNT] - 1);

	return ch->Class[slot];
}

int current_class(CharData * ch)
{
	return ch->Class[ch->Class[CLASS_COUNT] - 1];
}

int class_slot(CharData * ch, int pclass)
{
	int iClass;

	if (IsNPC(ch))
		return 0;

	for (iClass = 0; ch->Class[iClass] != -1; iClass++)
	{
		if (ch->Class[iClass] == pclass)
			return iClass;
	}

	return -1;
}

int number_classes(CharData * ch)
{
	int i;

	if (IsNPC(ch))
		return number_range(1, MAX_REMORT);

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
		;

	return i;
}

char *class_long(CharData * ch)
{
	static char buf[512];
	int i;

	buf[0] = '\0';
	if (IsNPC(ch))
		return "Mobile";
	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
	{
		strcat(buf, "/");
		strcat(buf, ClassName(ch, ch->Class[i]));
	}
	return buf + 1;
}

char *class_who(CharData * ch)
{
	static char buf[512];

	buf[0] = '\0';
	if (IsNPC(ch))
		return "Mob";

	if (IsRemort(ch))
		sprintf(buf, "%2.2s+%d", ClassName(ch, prime_class(ch)),
				ch->Class[CLASS_COUNT] - 1);
	else
		sprintf(buf, "%4.4s", ClassName(ch, prime_class(ch)));
	return buf;
}

char *class_short(CharData * ch)
{
	static char buf[512];
	int i;

	buf[0] = '\0';
	if (IsNPC(ch))
		return "Mob";
	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
	{
		strcat(buf, "/");
		sprintf(buf + strlen(buf), "%4.4s", ClassName(ch, ch->Class[i]));
	}
	return buf + 1;
}

char *class_numbers(CharData * ch)
{
	static char buf[512];
	char buf2[10];
	int i;

	buf[0] = '\0';

	if (IsNPC(ch))
		return "0";

	for (i = 0; i < MAX_MCLASS; i++)
	{
		strcat(buf, " ");
		sprintf(buf2, "%d", ch->Class[i]);
		strcat(buf, buf2);
	}
	return buf + 1;
}

int skill_level(CharData * ch, int sn)
{
	int i;
	int tempskill = 999;

	if (sn < 0 || sn >= top_skill)
		return MAX_LEVEL + 1;

	if (is_race_skill(ch, sn))
		return 1;

	if (is_deity_skill(ch, sn))
		return 1;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
		tempskill = Min(tempskill, skill_table[sn].skill_level[ch->Class[i]]);

	return tempskill == 999 ? LEVEL_IMMORTAL : tempskill;
}

int skill_rating(CharData * ch, int sn)
{
	int i;
	int temprate = 999;

	if (sn < 0 || sn >= top_skill)
		return 0;

	if (is_race_skill(ch, sn))
		return 2;

	if (is_deity_skill(ch, sn))
		return 2;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
	{
		if (skill_table[sn].rating[ch->Class[i]] < 1)
			continue;

		temprate = Min(temprate, skill_table[sn].rating[ch->Class[i]]);
	}
	return temprate == 999 ? 0 : temprate;
}

int group_rating(CharData * ch, int gn)
{
	int i;
	int temprate = 999;

	if (gn < 0 || gn >= top_group)
		return 0;

	if (is_race_skill(ch, gn))
		return 2;

	if (is_deity_skill(ch, gn))
		return 2;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
	{
		if (group_table[gn].rating[ch->Class[i]] < 1)
			continue;

		temprate = Min(temprate, group_table[gn].rating[ch->Class[i]]);
	}
	return temprate == 999 ? 0 : temprate;
}

int get_hp_gain(CharData * ch)
{
	int i = 0;
	int gain = 0;
	int count = 0;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
	{
		gain =
			Max(gain,
				number_range(class_table[ch->Class[i]].hp_min,
							 class_table[ch->Class[i]].hp_max));
		count++;
	}
	return number_range(gain, gain + count);
}

int hp_max(CharData * ch)
{
	int i;
	int tmp = 0;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
		tmp = Max(tmp, class_table[ch->Class[i]].hp_max);

	return tmp;
}

bool is_prime_stat(CharData * ch, int stat)
{
	int i = 0;

	if (IsNPC(ch))
		return true;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
	{
		if (class_table[ch->Class[i]].attr_prime == stat)
			return true;
	}
	return false;
}

void add_default_groups(CharData * ch)
{
	int i = 0;

	if (IsNPC(ch))
		return;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
		if (class_table[ch->Class[i]].default_group != NULL)
			group_add(ch, class_table[ch->Class[i]].default_group, false);

	ch->pcdata->points += i > 0 ? 50 : 40;
}

void add_base_groups(CharData * ch)
{
	int i = 0;

	if (IsNPC(ch))
		return;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
		if (class_table[ch->Class[i]].base_group != NULL)
			group_add(ch, class_table[ch->Class[i]].base_group, false);
}

bool check_base_group(CharData * ch, int gn)
{
	int i = 0;

	if (IsNPC(ch))
		return false;

	if (gn < 0 || gn >= top_group)
		return false;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
	{
		if (class_table[ch->Class[i]].base_group == NULL)
			continue;

		if (group_lookup(class_table[ch->Class[i]].base_group) == gn)
			return true;
	}
	return false;
}

bool is_base_skill(CharData * ch, int sn)
{
	int i = 0;
	int gn, x;

	if (IsNPC(ch))
		return false;

	if (sn < 0 || sn >= top_skill)
		return false;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
	{
		if (class_table[ch->Class[i]].base_group == NULL)
			continue;

		if ((gn = group_lookup(class_table[ch->Class[i]].base_group)) != -1)
		{
			for (x = 0; x < MAX_IN_GROUP; x++)
			{
				if (group_table[gn].spells[x] == NULL)
					break;

				if (skill_lookup(group_table[gn].spells[x]) == sn)
					return true;
			}
		}
	}
	return false;
}

int get_thac00(CharData * ch)
{
	int temp = 0, i = 0;

	if (IsNPC(ch))
		return 0;
	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
		temp = Max(temp, class_table[ch->Class[i]].thac0_00);

	return temp;
}

int get_thac32(CharData * ch)
{
	int temp = 999, i = 0;

	if (IsNPC(ch))
		return 0;
	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
		temp = Min(temp, class_table[ch->Class[i]].thac0_32);

	return temp;
}

int class_mult(CharData * ch)
{
	int temp = 999, i = 0;

	if (IsNPC(ch))
		return 0;

	for (i = 0; i < ch->Class[CLASS_COUNT]; i++)
		temp = Min(temp, ch->race->class_mult[ch->Class[i]]);

	return temp;
}

int lvl_bonus(CharData * ch)
{
	float adlev, inclev;
	int cntr;

	adlev = ch->Class[CLASS_COUNT];
	inclev = .09;
	for (cntr = 1; cntr < ch->level; cntr++)
	{
		adlev += .9;
		adlev += inclev;
		inclev += .009;
	}
	return (int) (adlev + inclev);
}

bool is_race_skill(CharData * ch, int sn)
{
	int i;

	if (sn < 0 || sn >= top_skill)
		return false;

	for (i = 0; i < MAX_RACE_SKILL; i++)
	{
		if (ch->race->skills[i] == NULL)
			continue;
		if (skill_lookup(ch->race->skills[i]) == sn)
			return true;
		if (group_lookup(ch->race->skills[i]) == sn)
			return true;
	}
	return false;
}

bool is_deity_skill(CharData * ch, int sn)
{
	if (sn < 0 || sn >= top_skill)
		return false;

	if (ch->deity == NULL || IsNPC(ch))
		return false;

	if (NullStr(ch->deity->skillname))
		return false;

	if (skill_lookup(ch->deity->skillname) == sn)
		return true;

	if (group_lookup(ch->deity->skillname) == sn)
		return true;

	return false;
}

Do_Fun(do_prime)
{
	int iClass, iSlot;

	if (NullStr(argument))
	{
		cmd_syntax(ch, NULL, n_fun, "<class>", NULL);
		chprintln(ch,
				  "It costs {R5{x trivia points to change your prime class.");
	}

	if ((iClass = class_lookup(argument)) == -1)
	{
		chprintln(ch, "No such class!");
		return;
	}

	if ((iSlot = class_slot(ch, iClass)) == -1)
	{
		chprintlnf(ch, "You aren't part %s!", class_table[iClass].name);
		return;
	}

	if (iSlot == ch->pcdata->prime_class)
	{
		chprintlnf(ch, "Your prime class is already %s.",
				   class_table[iClass].name);
		return;
	}

	if (ch->pcdata->trivia < 5)
	{
		chprintln(ch,
				  "It costs {R5{x trivia points to change your prime class.");
		return;
	}

	ch->pcdata->prime_class = iSlot;
	ch->pcdata->trivia -= 5;
	chprintlnf(ch,
			   "Your prime class is now %s, and are {R5{x trivia points lighter.",
			   class_table[iClass].name);
	return;
}