/* ************************************************************************
 *   File: Guild.c                                                         *
 *  Usage: GuildMaster's: loading files, assigning spec_procs, and handling*
 *                        practicing.                                      *
 *                                                                         *
 * Based on shop.c.  As such, the CircleMud License applies                *
 * Written by Jason Goodwin.   jgoodwin@expert.cc.purdue.edu               *
 ************************************************************************ */


#include "conf.h"
#include "sysdep.h"

#include "structs.h"
#include "utils.h"

#include "comm.h"
#include "constants.h"
#include "db.h"
#include "guild.h"
#include "handler.h"
#include "interpreter.h"
#include "spells.h"
#include "screen.h"
#include "gengld.h"
#include "shop.h"


/* extern variables */
extern struct spell_info_type spell_info[];
extern struct time_info_data time_info;
extern const char *trade_letters[];
extern int cmd_say, cmd_tell;

/* extern function prototypes */
ACMD(do_tell);
ACMD(do_say);

/* Local variables */
struct guild_data *guild_index;
int spell_sort_info[MAX_SKILLS + 1];
int top_guild = -1;
char *guild_customer_string(int guild_nr, int detailed);

const char *how_good(int percent)
{
  if (percent < 0)
    return " error)";
  if (percent == 0)
    return "(@Mnot@n)";
  if (percent <= 10)
    return "(@rawful@n)";
  if (percent <= 20)
    return "(@Rbad@n)";
  if (percent <= 40)
    return "(@ypoor@n)";
  if (percent <= 55)
    return "(@Yaverage@n)";
  if (percent <= 70)
    return "(@gfair@n)";
  if (percent <= 80)
    return "(@Ggood@n)";
  if (percent <= 85)
    return "(@bgreat@n)";
  if (percent <= 100)
    return "(@Bsuperb@n)";

  return "(@rinate@n)";
}

const char *prac_types[] = {
  "spell",
  "skill"
};


int compare_spells(const void *x, const void *y)
{
  int	a = *(const int *)x,
	b = *(const int *)y;

  return strcmp(spell_info[a].name, spell_info[b].name);
}


void list_skills_perct(struct char_data *ch, struct char_data *vict)
{
  const char *overflow = "\r\n**OVERFLOW**\r\n";
  int i, sortpos;
  size_t len = 0, nlen;
  char buf2[MAX_STRING_LENGTH];

  if (!GET_PRACTICES(vict)) {
    send_to_char(ch, "They have no practice sessions remaining.\r\n");
    return;
  }

  len = snprintf(buf2, sizeof(buf2), 
					  "%s has %d practice session%s remaining.\r\n"
					  "They know of the following skills:\r\n", 
					  GET_NAME(vict), GET_PRACTICES(vict),
					  GET_PRACTICES(vict) == 1 ? "" : "s");
  
  for (sortpos = MAX_SPELLS + 1; sortpos <= MIN_LANGUAGES - 1; sortpos++) {
    i = sortpos; /* spell_sort_info[sortpos]; */
    if (GET_LEVEL(vict) >= spell_info[i].min_level[(int) GET_CLASS(vict)] || GET_LEVEL(ch) >= spell_info[i].min_rlevel[(int) GET_RACE(ch)]) {
      nlen = snprintf(buf2 + len, sizeof(buf2) - len, 
							 "%-20s %3d\r\n", 
							 spell_info[i].name, GET_SKILL(vict, i));
      if (len + nlen >= sizeof(buf2) || nlen < 0)
        break;
      len += nlen;
    }
  }

  len += snprintf(buf2 + len, sizeof(buf2) - len,
						"\r\nand the following spells:\r\n");
  for (sortpos = 1; sortpos <= MAX_SPELLS; sortpos++) {
    i = sortpos; /* spell_sort_info[sortpos]; */
    if (GET_LEVEL(vict) >= spell_info[i].min_level[(int) GET_CLASS(vict)] || GET_LEVEL(ch) >= spell_info[i].min_rlevel[(int) GET_RACE(ch)]) {
      nlen = snprintf(buf2 + len, sizeof(buf2) - len, 
							 "%-20s %3d\r\n", 
							 spell_info[i].name, GET_SKILL(vict, i));
      if (len + nlen >= sizeof(buf2) || nlen < 0)
        break;
      len += nlen;
    }
  }

        if (CONFIG_ENABLE_LANGUAGES) {
  	len += snprintf(buf2 + len, sizeof(buf2) - len,
						 "\r\nand the following languages:\r\n");
	for (sortpos = MIN_LANGUAGES ; sortpos <= MAX_LANGUAGES ; sortpos++) {
		i = sortpos; /* spell_sort_info[sortpos]; */
		if (GET_LEVEL(ch) >= spell_info[i].min_level[(int) GET_CLASS(ch)] || GET_LEVEL(ch) >= spell_info[i].min_rlevel[(int) GET_RACE(ch)]) {
			nlen = snprintf(buf2 + len, sizeof(buf2) - len, 
								 "%-20s %s\r\n", 
								 spell_info[i].name, how_good(GET_SKILL(ch, i)));
			if (len + nlen >= sizeof(buf2) || nlen < 0)
				break;
			len += nlen;
		}
	}
        }

  if (len >= sizeof(buf2))
    strcpy(buf2 + sizeof(buf2) - strlen(overflow) - 1, overflow); /* strcpy: OK */

  page_string(ch->desc, buf2, TRUE);
}


void list_skills(struct char_data *ch)
{
  const char *overflow = "\r\n**OVERFLOW**\r\n";
  int i, sortpos;
  size_t len = 0, nlen;
  char buf2[MAX_STRING_LENGTH];

  /* if (!GET_PRACTICES(ch)) {
    send_to_char(ch, "You have no practice sessions remaining.\r\n");
    return;
  } */

  len = snprintf(buf2, sizeof(buf2), 
					  "You have %d practice session%s remaining.\r\n"
					  "You know of the following skills:\r\n", GET_PRACTICES(ch),
					  GET_PRACTICES(ch) == 1 ? "" : "s");
  
  for (sortpos = MAX_SPELLS + 1; sortpos <= MIN_LANGUAGES - 1; sortpos++) {
    i = sortpos; /* spell_sort_info[sortpos]; */
    if (GET_LEVEL(ch) >= spell_info[i].min_level[(int) GET_CLASS(ch)] || GET_LEVEL(ch) >= spell_info[i].min_rlevel[(int) GET_RACE(ch)]) {
      nlen = snprintf(buf2 + len, sizeof(buf2) - len, 
							 "%-20s %s\r\n", 
							 spell_info[i].name, how_good(GET_SKILL(ch, i)));
      if (len + nlen >= sizeof(buf2) || nlen < 0)
        break;
      len += nlen;
    }
  }

  len += snprintf(buf2 + len, sizeof(buf2) - len,
						"\r\n\r\nand the following spells:\r\n");
  for (sortpos = 1; sortpos <= MAX_SPELLS; sortpos++) {
    i = sortpos; /* spell_sort_info[sortpos]; */
    if (GET_LEVEL(ch) >= spell_info[i].min_level[(int) GET_CLASS(ch)] || GET_LEVEL(ch) >= spell_info[i].min_rlevel[(int) GET_RACE(ch)]) {
      nlen = snprintf(buf2 + len, sizeof(buf2) - len, 
							 "%-20s %s\r\n", 
							 spell_info[i].name, how_good(GET_SKILL(ch, i)));
      if (len + nlen >= sizeof(buf2) || nlen < 0)
        break;
      len += nlen;
    }
  }

        if (CONFIG_ENABLE_LANGUAGES) {
  	len += snprintf(buf2 + len, sizeof(buf2) - len,
						 "\r\nand the following languages:\r\n");
	for (sortpos = MIN_LANGUAGES ; sortpos <= MAX_LANGUAGES ; sortpos++) {
		i = sortpos; /* spell_sort_info[sortpos]; */
		if (GET_LEVEL(ch) >= spell_info[i].min_level[(int) GET_CLASS(ch)] || GET_LEVEL(ch) >= spell_info[i].min_rlevel[(int) GET_RACE(ch)]) {
			nlen = snprintf(buf2 + len, sizeof(buf2) - len, 
								 "%-20s %s\r\n", 
								 spell_info[i].name, how_good(GET_SKILL(ch, i)));
			if (len + nlen >= sizeof(buf2) || nlen < 0)
				break;
			len += nlen;
		}
	}
        }

  if (len >= sizeof(buf2))
    strcpy(buf2 + sizeof(buf2) - strlen(overflow) - 1, overflow); /* strcpy: OK */

  page_string(ch->desc, buf2, TRUE);
}


int is_guild_open(struct char_data *keeper, int guild_nr, int msg)
{
	char buf[200];
	*buf = 0;

	if (GM_OPEN(guild_nr) > time_info.hours &&
		 GM_CLOSE(guild_nr) < time_info.hours)
		strlcpy(buf, MSG_TRAINER_NOT_OPEN, sizeof(buf));

	if (!*buf)
		return (TRUE);
	if (msg)
		do_say(keeper, buf, cmd_tell, 0);

	return (FALSE);
}


int is_guild_ok_char(struct char_data * keeper, struct char_data * ch, int guild_nr)
{
	char buf[200];

	if (!(CAN_SEE(keeper, ch))) {
		do_say(keeper, MSG_TRAINER_NO_SEE_CH, cmd_say, 0);
		return (FALSE);
	}

	if (GET_LEVEL(ch) >= LVL_IMMORT) {
		snprintf(buf, sizeof(buf), "%s %s", 
					GET_NAME(ch), "You should be training me!");
		do_tell(keeper, buf, cmd_tell, 0); 
		return (FALSE);
	}
		
	
	if (GET_LEVEL(ch) < GM_MINLVL(guild_nr)) {
				snprintf(buf, sizeof(buf), "%s %s", 
					GET_NAME(ch), MSG_TRAINER_MINLVL);
		do_tell(keeper, buf, cmd_tell, 0); 
		return (FALSE);
	}


	if ((IS_GOOD(ch) && NOTRAIN_GOOD(guild_nr)) ||
		 (IS_EVIL(ch) && NOTRAIN_EVIL(guild_nr)) ||
		 (IS_NEUTRAL(ch) && NOTRAIN_NEUTRAL(guild_nr))) {
		snprintf(buf, sizeof(buf), "%s %s", 
					GET_NAME(ch), MSG_TRAINER_DISLIKE_ALIGN);
		do_tell(keeper, buf, cmd_tell, 0);
		return (FALSE);
	}

	if (IS_NPC(ch))
		return (FALSE);

	if ((IS_MAGIC_USER(ch) && NOTRAIN_MAGIC_USER(guild_nr)) ||
		(IS_CLERIC(ch) && NOTRAIN_CLERIC(guild_nr)) ||
		(IS_THIEF(ch) && NOTRAIN_THIEF(guild_nr)) ||
		(IS_WARRIOR(ch) && NOTRAIN_WARRIOR(guild_nr))) {
		snprintf(buf, sizeof(buf), "%s %s", 
					GET_NAME(ch), MSG_TRAINER_DISLIKE_CLASS);
		do_tell(keeper, buf, cmd_tell, 0);
		return (FALSE);
	}

	if ((IS_HUMAN(ch) && NOTRAIN_HUMAN(guild_nr)) ||
		 (IS_ELF(ch)   && NOTRAIN_ELF(guild_nr)) ||
		 (IS_GNOME(ch) && NOTRAIN_GNOME(guild_nr)) ||
		 (IS_DWARF(ch) && NOTRAIN_DWARF(guild_nr))) {
		snprintf(buf, sizeof(buf), "%s %s", 
					GET_NAME(ch), MSG_TRAINER_DISLIKE_RACE);
		do_tell(keeper, buf, cmd_tell, 0);
		return (FALSE);
	}
	return (TRUE);
}


int is_guild_ok(struct char_data * keeper, struct char_data * ch, int guild_nr)
{
	if (is_guild_open(keeper, guild_nr, TRUE))
		return (is_guild_ok_char(keeper, ch, guild_nr));

	return (FALSE);
}


int does_guild_know(int guild_nr, int i)
{
	return ((int)(guild_index[guild_nr].skills_and_spells[i]));
}


void sort_spells(void)
{
  int a;

  /* initialize array, avoiding reserved. */
  for (a = 1; a <= MAX_SKILLS; a++)
    spell_sort_info[a] = a;

  qsort(&spell_sort_info[1], MAX_SKILLS, sizeof(int), compare_spells);
}


/* this and list skills should probally be combined.  perhaps in the
 * next release?  */
void what_does_guild_know(int guild_nr, struct char_data * ch)
{
  const char *overflow = "\r\n**OVERFLOW**\r\n";
  char buf2[MAX_STRING_LENGTH];
  int i, sortpos;
  size_t nlen = 0, len = 0;

  /*if (!GET_PRACTICES(ch)) {
    send_to_char(ch, "You have no practice sessions remaining.\r\n");
    return;
  }*/

  len = snprintf(buf2, sizeof(buf2), "You have %d practice session%s remaining.\r\n", GET_PRACTICES(ch), GET_PRACTICES(ch) == 1 ? "" : "s"); // ???

  nlen = snprintf(buf2 + len, sizeof(buf2) - len, "I can teach you the following skills:\r\n");
  len += nlen;
  
  /* Need to check if trainer can train doesnt do it now ??? */
  for (sortpos = MAX_SPELLS + 1; sortpos <= MIN_LANGUAGES - 1; sortpos++) {
    i = sortpos; /* spell_sort_info[sortpos]; */
    if (does_guild_know(guild_nr, sortpos)) {
      if (GET_LEVEL(ch) >= spell_info[i].min_level[(int) GET_CLASS(ch)] || GET_LEVEL(ch) >= spell_info[i].min_rlevel[(int) GET_RACE(ch)]) {
        if (GET_SKILL(ch, i) < LEARNED(ch)) {
          nlen = snprintf(buf2 + len, sizeof(buf2) - len, "%-20s %s\r\n", spell_info[i].name, how_good(GET_SKILL(ch, i)));
          if (len + nlen >= sizeof(buf2) || nlen < 0)
            break;
          len += nlen;
        }
      }
    }
  }

  len += snprintf(buf2 + len, sizeof(buf2) - len, "\r\n\r\nand the following spells:\r\n");

  for (sortpos = 1; sortpos <= MAX_SPELLS; sortpos++) {
    i = sortpos; /* spell_sort_info[sortpos]; */
      if (does_guild_know(guild_nr, sortpos)) {
        if (GET_LEVEL(ch) >= spell_info[i].min_level[(int) GET_CLASS(ch)] || GET_LEVEL(ch) >= spell_info[i].min_rlevel[(int) GET_RACE(ch)]) {
          if (GET_SKILL(ch, i) < LEARNED(ch)) {
            nlen = snprintf(buf2 + len, sizeof(buf2) - len, "%-20s %s\r\n", spell_info[i].name, how_good(GET_SKILL(ch, i)));
            if (len + nlen >= sizeof(buf2) || nlen < 0)
              break;
            len += nlen;
          }
        }
      }
  }

  if (CONFIG_ENABLE_LANGUAGES) {
  len += snprintf(buf2 + len, sizeof(buf2) - len, "\r\nand the following languages:\r\n");

  for (sortpos = MIN_LANGUAGES ; sortpos <= MAX_LANGUAGES ; sortpos++) {
    i = sortpos; /* spell_sort_info[sortpos]; */
    if (does_guild_know(guild_nr, sortpos)) {
      if (GET_LEVEL(ch) >= spell_info[i].min_level[(int) GET_CLASS(ch)] || GET_LEVEL(ch) >= spell_info[i].min_rlevel[(int) GET_RACE(ch)]) {
        if (GET_SKILL(ch, i) < LEARNED(ch)) {
          nlen = snprintf(buf2 + len, sizeof(buf2) - len, "%-20s %s\r\n", spell_info[i].name, how_good(GET_SKILL(ch, i)));
          if (len + nlen >= sizeof(buf2) || nlen < 0)
            break;
          len += nlen;
        }
      }
    }
  }
  }
  if (len >= sizeof(buf2))
    strcpy(buf2 + sizeof(buf2) - strlen(overflow) - 1, overflow); /* strcpy: OK */

  page_string(ch->desc, buf2, TRUE);
}


SPECIAL(guild)
{
	char arg[MAX_INPUT_LENGTH];
	char buf1[MAX_STRING_LENGTH], buf2[MAX_STRING_LENGTH];
	int skill_num, percent;
	int guild_nr;
	struct char_data *keeper = (struct char_data *) me;

	for (guild_nr = 0; guild_nr <= top_guild; guild_nr++)
		if (GM_TRAINER(guild_nr) == keeper->nr)
			break;

	if (guild_nr > top_guild)
		return (FALSE);

	if (GM_FUNC(guild_nr))
		if ((GM_FUNC(guild_nr)) (ch, me, cmd, arg))
			return (TRUE);


	if (/*IS_NPC(ch) || */!CMD_IS("practice"))
		return (FALSE);

	skip_spaces(&argument);

/*** Is the GM able to train?    ****/
	if (!AWAKE(keeper))
		return (FALSE);

	if (!(is_guild_ok(keeper, ch, guild_nr)))
      return (TRUE);

	if (!*argument) {
		what_does_guild_know(guild_nr, ch);
		return (TRUE);
	}

	if (GET_PRACTICES(ch) <= 0) {
		send_to_char(ch, "You do not seem to be able to practice now.\r\n");
		return (TRUE);
	}

	skill_num = find_skill_num(argument);

/****  Does the GM know the skill the player wants to learn?  ****/
	if (!(does_guild_know(guild_nr, skill_num))) {
		snprintf(buf2, sizeof(buf2), 
					guild_index[guild_nr].no_such_skill, GET_NAME(ch));
		do_tell(keeper, buf2, cmd_tell, 0);
		return (TRUE);
	}

/**** Can the player learn the skill if the GM knows it?  ****/ 
	if (skill_num < 1 ||
		 GET_LEVEL(ch) < spell_info[skill_num].min_level[(int) GET_CLASS(ch)]) {
		send_to_char(ch, "You do not know of that %s.\r\n", SPLSKL(ch));
		return (TRUE);
	}

/****  Is the player maxxed out with the skill?  ****/
	if (GET_SKILL(ch, skill_num) >= LEARNED(ch)) {
		send_to_char(ch, "You are already learned in that area.\r\n");
		return (TRUE);
	}

/****  Does the Player have enough gold to train?  ****/
	if (GET_GOLD(ch) < (GM_COST(guild_nr,skill_num,ch))) {
		snprintf(buf1, sizeof(buf1), 
					guild_index[guild_nr].not_enough_gold, GET_NAME(ch));
		do_tell(keeper, buf1, cmd_tell, 0);
		return (TRUE);
	}

/****  If we've made it this far, then its time to practice  ****/
	send_to_char(ch, "You practice for a while...\r\n");
	GET_PRACTICES(ch)--;

	GET_GOLD(ch) -= GM_COST(guild_nr,skill_num,ch);

	percent = GET_SKILL(ch, skill_num);
	percent += MIN(MAXGAIN(ch), MAX(MINGAIN(ch), int_app[GET_INT(ch)].learn));

	SET_SKILL(ch, skill_num, MIN(LEARNED(ch), percent));

	if (GET_SKILL(ch, skill_num) >= LEARNED(ch))
		send_to_char(ch, "You are now learned in that area.\r\n");

	return (TRUE);
}


/**** This function is here just because I'm extremely paranoid.  Take
      it out if you aren't ;)  ****/
void clear_skills(int index)
{
	int i;

	for  (i = 0; i < MAX_SKILLS + 2; i++) 
		guild_index[index].skills_and_spells[i] = 0;
}


/****  This is ripped off of read_line from shop.c.  They could be
 *  combined. But why? ****/

void read_guild_line(FILE * gm_f, char *string, void *data, char *type)
{
	char buf[MAX_STRING_LENGTH];
	
	if (!get_line(gm_f, buf) || !sscanf(buf, string, data)) {
		fprintf(stderr, "Error in guild #%d, Could not get %s\n", GM_NUM(top_guild), type);
		exit(1);
	}
}


void boot_the_guilds(FILE * gm_f, char *filename, int rec_count)
{
	char *buf, buf2[256];
	int temp;
	int done = FALSE;

	snprintf(buf2, sizeof(buf2), "beginning of GM file %s", filename);

	while (!done) {
		buf = fread_string(gm_f, buf2);
		if (*buf == '#') {		/* New Trainer */
			sscanf(buf, "#%d\n", &temp);
			snprintf(buf2, sizeof(buf2), "GM #%d in GM file %s", temp, filename);
			free(buf);		/* Plug memory leak! */
			top_guild++;
			if (!top_guild)
				CREATE(guild_index, struct guild_data, rec_count);
			GM_NUM(top_guild) = temp;

			clear_skills(top_guild);    
			read_guild_line(gm_f, "%d", &temp, "TEMP1");
			while( temp > -1) {
				guild_index[top_guild].skills_and_spells[(int)temp] = 1;
				read_guild_line(gm_f, "%d", &temp, "TEMP2");
			}
                   
			read_guild_line(gm_f, "%f", &GM_CHARGE(top_guild), "GM_CHARGE");

			guild_index[top_guild].no_such_skill = fread_string(gm_f, buf2);
			guild_index[top_guild].not_enough_gold = fread_string(gm_f, buf2);

			read_guild_line(gm_f, "%d", &GM_MINLVL(top_guild), "GM_MINLVL");
			read_guild_line(gm_f, "%d", &GM_TRAINER(top_guild), "GM_TRAINER");

			GM_TRAINER(top_guild) = real_mobile(GM_TRAINER(top_guild));
			read_guild_line(gm_f, "%d", &GM_WITH_WHO(top_guild), "GM_WITH_WHO");

			read_guild_line(gm_f, "%d", &GM_OPEN(top_guild), "GM_OPEN");
			read_guild_line(gm_f, "%d", &GM_CLOSE(top_guild), "GM_CLOSE");

			GM_FUNC(top_guild) = NULL;
		} else {
			if (*buf == '$')		/* EOF */
				done = TRUE;
			free(buf);		/* Plug memory leak! */
		}
	}
}


void assign_the_guilds(void)
{
	int index;

	cmd_say = find_command("say");
	cmd_tell = find_command("tell");

	for (index = 0; index <= top_guild; index++) {
		if (GM_TRAINER(index) == NOBODY)
			continue;
		if (mob_index[GM_TRAINER(index)].func)
			GM_FUNC(index) = mob_index[GM_TRAINER(index)].func;
		mob_index[GM_TRAINER(index)].func = guild;
	}
}

char *guild_customer_string(int guild_nr, int detailed)
{
  int gindex = 0, flag = 1, nlen;
  size_t len = 0;
  static char buf[MAX_STRING_LENGTH];

  while (*trade_letters[gindex] != '\n' && len + 1 < sizeof(buf)) {
    if (detailed) {
      if (!IS_SET(flag, GM_WITH_WHO(guild_nr))) {
	nlen = snprintf(buf + len, sizeof(buf) - len, ", %s", trade_letters[gindex]);

        if (len + nlen >= sizeof(buf) || nlen < 0)
          break;

        len += nlen;
      }
    } else {
      buf[len++] = (IS_SET(flag, GM_WITH_WHO(guild_nr)) ? '_' : *trade_letters[gindex]);
      buf[len] = '\0';

      if (len >= sizeof(buf))
        break;
    }

    gindex++;
    flag <<= 1;
  }

  buf[sizeof(buf) - 1] = '\0';
  return (buf);
}

void list_all_guilds(struct char_data *ch)
{
  const char *list_all_guilds_header =
  "Virtual   G.Master	Charge   Members\r\n"
  "-------------------------------------------------------------\r\n";
  int gm_nr, headerlen = strlen(list_all_guilds_header);
  size_t len = 0;
  char buf[MAX_STRING_LENGTH], buf1[16];

  *buf = '\0';
  for (gm_nr = 0; gm_nr <= top_guild && len < sizeof(buf); gm_nr++) {
  /* New page in page_string() mechanism, print the header again. */
    if (!(gm_nr % (PAGE_LENGTH - 2))) {
    /*
     * If we don't have enough room for the header, or all we have room left
     * for is the header, then don't add it and just quit now.
     */
    if (len + headerlen + 1 >= sizeof(buf))
      break;
    strcpy(buf + len, list_all_guilds_header);	/* strcpy: OK (length checked above) */
    len += headerlen;
    }

    if (GM_TRAINER(gm_nr) == NOBODY)
      strcpy(buf1, "<NONE>");  /* strcpy: OK (for 'buf1 >= 7') */
    else
      sprintf(buf1, "%6d", mob_index[GM_TRAINER(gm_nr)].vnum);  /* sprintf: OK (for 'buf1 >= 11', 32-bit int) */	

    len += snprintf(buf + len, sizeof(buf) - len, "%6d	%s		%5.2f	%s\r\n",
      GM_NUM(gm_nr), buf1, GM_CHARGE(gm_nr), guild_customer_string(gm_nr, FALSE));
  }

  page_string(ch->desc, buf, TRUE);
}


void list_detailed_guild(struct char_data * ch, int gm_nr)
{
  int i;
  char buf[MAX_STRING_LENGTH];
  char buf1[MAX_STRING_LENGTH], buf2[MAX_STRING_LENGTH];

  if (GM_TRAINER(gm_nr) < 0)
    strcpy(buf1, "<NONE>");
  else
    sprintf(buf1, "%6d   ", mob_index[GM_TRAINER(gm_nr)].vnum);

  sprintf(buf, " Guild Master: %s\r\n", buf1);
  sprintf(buf, "%s Hours: %4d to %4d,  Surcharge: %5.2f\r\n", buf,
			  GM_OPEN(gm_nr), GM_CLOSE(gm_nr), GM_CHARGE(gm_nr));
  sprintf(buf, "%s Min Level will train: %d\r\n", buf, GM_MINLVL(gm_nr));
  sprintf(buf, "%s Whom will train: %s\r\n", buf, guild_customer_string(gm_nr, TRUE));

   /* now for the REAL reason why someone would want to see a Guild :) */

  sprintf(buf, "%s The GM can teach the following:\r\n", buf);

  *buf2 = '\0';
  for (i = 0; i <= MAX_SKILLS; i++) {
    if (does_guild_know(gm_nr, i))
      sprintf(buf2, "%s %s \r\n", buf2, spell_info[i].name);
  }
 
  strcat(buf, buf2);

  page_string(ch->desc, buf, 1);
}
  

void show_guild(struct char_data * ch, char *arg)
{
  int gm_nr, gm_num;

  if (!*arg)
    list_all_guilds(ch);
  else {
    if (is_number(arg))
      gm_num = atoi(arg);
    else
      gm_num = -1;

    if (gm_num > 0) {
      for (gm_nr = 0; gm_nr <= top_guild; gm_nr++) {
      if (gm_num == GM_NUM(gm_nr))
        break; 
      }

      if (gm_num < 0 || gm_nr > top_guild) {
        send_to_char(ch, "Illegal guild master number.\n\r");
        return;
      }
      list_detailed_guild(ch, gm_nr);
    }
  }
}

/*
 * List all guilds in a zone.                              
 */                                                                           
void list_guilds(struct char_data *ch, zone_rnum rnum, guild_vnum vmin, guild_vnum vmax)
{
  int i, bottom, top, counter = 0;
  
  if (rnum != NOWHERE) {
    bottom = zone_table[rnum].bot;
    top    = zone_table[rnum].top;
  } else {
    bottom = vmin;
    top    = vmax;
  }
  
  /****************************************************************************/
  /** Store the header for the guild listing.                                 **/
  /****************************************************************************/
  send_to_char (ch,
  "Index VNum    Guild Master\r\n"
  "----- ------- ---------------------------------------------\r\n");
  
  for (i = 0; i <= top_guild; i++) {
    if (GM_NUM(i) >= bottom && GM_NUM(i) <= top) {
      counter++;
      
      send_to_char(ch, "%s%4d%s) [%s%-5d%s]",
        QGRN, counter, QNRM, QGRN, GM_NUM(i), QNRM);

      /************************************************************************/
      /** Retrieve the list of rooms for this guild.                          **/
      /************************************************************************/

		send_to_char(ch, " %s[%s%d%s]%s %s%s", 
			
			QCYN, QYEL, 
			(GM_TRAINER(i) == -1) ?
			  -1 : mob_index[GM_TRAINER(i)].vnum, QCYN, QYEL,
			(GM_TRAINER(i) == -1) ?
			  "" : mob_proto[GM_TRAINER(i)].player.short_descr, QNRM); 
      
      send_to_char(ch, "\r\n");
    }
  }
  
  if (counter == 0)
    send_to_char(ch, "None found.\r\n");
}

void destroy_guilds(void)
{
  ssize_t cnt/*, itr*/;

  if (!guild_index)
    return;

  for (cnt = 0; cnt <= top_guild; cnt++) {
    if (guild_index[cnt].no_such_skill)
      free(guild_index[cnt].no_such_skill);
    if (guild_index[cnt].not_enough_gold)
      free(guild_index[cnt].not_enough_gold);

    /*if (guild_index[cnt].type) {
      for (itr = 0; BUY_TYPE(guild_index[cnt].type[itr]) != NOTHING; itr++)
        if (BUY_WORD(guild_index[cnt].type[itr]))
          free(BUY_WORD(guild_index[cnt].type[itr]));
      free(shop_index[cnt].type);
    } */
  }

  free(guild_index);
  guild_index = NULL;
  top_guild = -1;
}


int count_guilds(guild_vnum low, guild_vnum high)
{
  int i, j;
  
  for (i = j = 0; GM_NUM(i) <= high; i++)
    if (GM_NUM(i) >= low)
      j++;
 
  return j;
}