/*  Okay, your going to need to add a few things into interp.c & interp.h,
I believe just bitflag, bitshow & qinfo.  They are at the end of this (the stuff you put into act_info and act_wiz.)  Other than that, read on, add & enjoy.

The only credit I require is keeping the headers in the code, sending me an email letting me know if you liked the code, any bug fixes so I can fix them for everyone and if you want any improvements (I know a bunch of it is long as hell and can probably be done better with a loop or something, but i'm no good with that stuff. :P)

You can reach me via email at learycm@gmail.com
You can reach me via AIM at cmleary0919

Or you can also log into my mud: swayingbalance.com 9999
*/

//Add the following lines into merc.h (or whatever you may have renamed it to)

// Put these wherever you want.
/*
 * QST bits for players (tierup/sidequests)
 */
#define QST_TIERONE_ONE (A)
#define QST_TIERTWO_ONE (B)
#define QST_TIERTHR_ONE (C)
#define QST_TIERFOU_ONE (D)
#define QST_TIERFIV_ONE (E)
#define QST_TIERSIX_ONE (F)

#define SDE_QSTONE_ONE (A)
#define SDE_QSTTWO_ONE (B)
/*
 * RCE_ bits for lpayers (race based quests)
 */
#define RCE_MINOTAUR_ONE (A)
#define RCE_TROLL_ONE   (B)
#define RCE_CENTAUR_ONE (C)
#define RCE_IMP_ONE     (D)
#define RCE_GOBLIN_ONE  (E)
#define RCE_GNOME_ONE   (F)
#define RCE_FAERY_ONE   (G)
#define RCE_AAROK_ONE   (H)
#define RCE_OGRE_ONE    (I)
#define RCE_DWARF_ONE   (J)
#define RCE_ELF_ONE     (K)
#define RCE_HUMAN_ONE   (L)
#define RCE_MINOTAUR_TWO (M)
#define RCE_TROLL_TWO   (N)
#define RCE_CENTAUR_TWO (O)
#define RCE_IMP_TWO    (P)
#define RCE_GOBLIN_TWO (Q)
#define RCE_GNOME_TWO  (R)
#define RCE_FAERY_TWO  (S)
#define RCE_AAROK_TWO  (T)
#define RCE_OGRE_TWO   (U)
#define RCE_DWARF_TWO  (V)
#define RCE_ELF_TWO    (W)
#define RCE_HUMAN_TWO  (X)

//Under struct     char_data
    long               qst;
    long               sde;
    long               rce;
//Search for act_bit_name and add these
char *          qst_bit_name            args( ( int qst_flags ) );
char *          sde_bit_name            args( ( int sde_flags ) );
char *          rce_bit_name            args( ( int rce_flags ) );

//Add the following lines into mob_prog.c

//Put these under "act" in the fn_keyword table
    "qst",              
    "rce",
    "sde",

//Search for CHK_ACT
        case CHK_QST:   
            return( lval_char != NULL
                &&  IS_SET(lval_char->qst, flag_lookup(buf, qst_flags)) );
        case CHK_RCE:
            return( lval_char != NULL
                &&  IS_SET(lval_char->rce, flag_lookup(buf, rce_flags)) );
        case CHK_SDE:   
            return( lval_char != NULL
                &&  IS_SET(lval_char->sde, flag_lookup(buf, sde_flags)) );
//Add the following lines into save.c

//In fread_char
//Under Case Q
                     KEY( "Qst", ch->qst, fread_flag (fp));
//Under Case R
                KEY ("Rce", ch->rce, fread_flag(fp));
//Under Case S
                KEY ("Sde", ch->sde, fread_flag(fp));
//In fwrite_char, I put them just above vnum/password.
    if (ch->qst != 0)
        fprintf (fp, "Qst  %s\n", print_flags (ch->qst));
    if (ch->rce != 0)
        fprintf (fp, "Rce  %s\n", print_flags (ch->rce));
    if (ch->sde != 0)
        fprintf (fp, "Sde  %s\n", print_flags (ch->sde));
    if (ch->tog != 0)       

//Add the following lines into handler.c  .. I put them near  act_bit_name

char *sde_bit_name (int sde_flags)
{
    static char buf[512];

    buf[0] = '\0';

    if (sde_flags & SDE_QSTONE_ONE)
        strcat (buf, " sideqst11");
    if (sde_flags & SDE_QSTTWO_ONE)
        strcat (buf, " sideqst21");

    return (buf[0] != '\0') ? buf + 1 : "none";
}
char *rce_bit_name (int rce_flags)
{
    static char buf[512];

    buf[0] = '\0';

    if (rce_flags & RCE_MINOTAUR_ONE) 
        strcat (buf, " minotaur1");
    if (rce_flags & RCE_TROLL_ONE)
        strcat (buf, " troll1");
    if (rce_flags & RCE_CENTAUR_ONE)
        strcat (buf, " centaur1");
    if (rce_flags & RCE_IMP_ONE)
        strcat (buf, " imp1");
    if (rce_flags & RCE_GOBLIN_ONE)
        strcat (buf, " goblin1");
    if (rce_flags & RCE_GNOME_ONE)
        strcat (buf, " gnome1");
    if (rce_flags & RCE_FAERY_ONE)
        strcat (buf, " faery1");
    if (rce_flags & RCE_AAROK_ONE)
        strcat (buf, " aarokcra1");
    if (rce_flags & RCE_OGRE_ONE)
        strcat (buf, " ogre1");
    if (rce_flags & RCE_DWARF_ONE)
        strcat (buf, " dwarf1");
    if (rce_flags & RCE_ELF_ONE)
        strcat (buf, " elf1");
    if (rce_flags & RCE_HUMAN_ONE)
        strcat (buf, " human1");
    if (rce_flags & RCE_MINOTAUR_TWO)
        strcat (buf, " minotaur2");
    if (rce_flags & RCE_TROLL_TWO)
        strcat (buf, " troll2");
    if (rce_flags & RCE_CENTAUR_TWO)
        strcat (buf, " centaur2");
    if (rce_flags & RCE_IMP_TWO)
        strcat (buf, " imp2");
    if (rce_flags & RCE_GOBLIN_TWO)
        strcat (buf, " goblin2");
    if (rce_flags & RCE_GNOME_TWO)
        strcat (buf, " gnome2");
    if (rce_flags & RCE_FAERY_TWO)
        strcat (buf, " faery2");
    if (rce_flags & RCE_AAROK_TWO)
        strcat (buf, " aarokcra2");
    if (rce_flags & RCE_OGRE_TWO)
        strcat (buf, " ogre2");
    if (rce_flags & RCE_DWARF_TWO)
        strcat (buf, " dwarf2");
    if (rce_flags & RCE_ELF_TWO)
        strcat (buf, " elf2");
    if (rce_flags & RCE_HUMAN_TWO)
        strcat (buf, " human2");

    return (buf[0] != '\0') ? buf + 1 : "none";
}
char *qst_bit_name (int qst_flags)
{
    static char buf[512];

    buf[0] = '\0';

    if (qst_flags & QST_TIERONE_ONE)
        strcat (buf, " tier1-1");
    if (qst_flags & QST_TIERTWO_ONE)
        strcat (buf, " tier2-1");
    if (qst_flags & QST_TIERTHR_ONE)
        strcat (buf, " tier3-1");
    if (qst_flags & QST_TIERFOU_ONE)
        strcat (buf, " tier4-1");
    if (qst_flags & QST_TIERFIV_ONE)
        strcat (buf, " tier5-1");
    if (qst_flags & QST_TIERSIX_ONE)
        strcat (buf, " tier6-1");
    return (buf[0] != '\0') ? buf + 1 : "none";
}

//Add the following line into your mobprog mob command table in mob_cmds.c

    {   "bitflag",      do_bitflag      },

// Add the following line into your mob_cmds.h command table, look for something like DECLARE_DO_FUN( do_

DECLARE_DO_FUN( do_bitflag);

//Add the following into tables.h

extern  const   struct  flag_type       sde_flags[];
extern  const   struct  flag_type       rce_flags[];
extern  const   struct  flag_type       qst_flags[];

//Add the following tables into table.c

const struct flag_type sde_flags[] = {
        {"sideqst11",   A,      TRUE},
        {"sideqst21",   B,      TRUE},
        {NULL,          0,      TRUE}
};  
const struct flag_type rce_flags[] = {
        {"minotaurone",         A,      TRUE},
        {"trollone",    B,      TRUE},
        {"centaurone",  C,      TRUE},
        {"impone",      D,      TRUE},
        {"goblinone",   E,      TRUE},
        {"gnomeone",    F,      TRUE},
        {"faeryone",    G,      TRUE},
        {"aarokcraone", H,      TRUE},
        {"ogreone",     I,      TRUE},
        {"dwarfone",    J,      TRUE},
        {"elfone",      K,      TRUE},
        {"humanone",    L,      TRUE},
        {"minotaurtwo", M,      TRUE},
        {"trolltwo",    N,      TRUE},
        {"centaurtwo",  O,      TRUE},
        {"imptwo",      P,      TRUE},
        {"goblintwo",   Q,      TRUE},
        {"gnometwo",    R,      TRUE},
        {"faerytwo",    S,      TRUE},
        {"aarokcratwo", T,      TRUE},
        {"ogretwo",     U,      TRUE},
        {"ogretwo",     V,      TRUE},
        {"dwarftwo",    W,      TRUE},
        {"elftwo",      X,      TRUE},
        {"humantwo",    Y,      TRUE},
        {NULL,          0,      TRUE}
};  
const struct flag_type qst_flags[] = {
        {"tier11",      A,      TRUE},
        {"tier21",      B,      TRUE},
        {"tier31",      C,      TRUE},
        {"tier41",      D,      TRUE},
        {"tier51",      E,      TRUE},
        {"tier61",      F,      TRUE},
        {NULL,          0,      TRUE}
};

// Add this into act_info.c, anywhere.  It is alot, but there is one more thing to do after this, so be careful.

/*
 * Mortal command to show them which quests they have completed.
 */
    
void do_mqstshow (CHAR_DATA *ch, char *argument)
{
 char arg[MAX_INPUT_LENGTH];
    
 argument = one_argument (argument, arg);
             
   if (arg[0] == '\0' || argument[0] == '\0')
   {
    send_to_char("{GCompleted Quests{W\n\r", ch);
    send_to_char("{W----------------{x\n\r", ch);

    send_to_char("{GTier Quests{W:{g\n\r", ch);

    if(IS_SET(ch->qst, QST_TIERONE_ONE))
     send_to_char("{gYou have completed the first part of the tier one quest.{x\n\r", ch);
    if(IS_SET(ch->qst, QST_TIERTWO_ONE))
     send_to_char("{gYou have completed the first part of the tier two quest.{x\n\r", ch);
    if(IS_SET(ch->qst, QST_TIERTHR_ONE))
     send_to_char("{gYou have completed the first part of the tier three quest.{x\n\r", ch);
    if(IS_SET(ch->qst, QST_TIERFOU_ONE))
     send_to_char("{gYou have completed the first part of the tier four quest.{x\n\r", ch);
    if(IS_SET(ch->qst, QST_TIERFIV_ONE))
     send_to_char("{gYou have completed the first part of the tier five quest.{x\n\r", ch);
    if(IS_SET(ch->qst, QST_TIERSIX_ONE))
     send_to_char("{gYou have completed the first part of the tier six quest.{x\n\r", ch);
    if(!IS_SET(ch->qst, QST_TIERONE_ONE) &&
        !IS_SET(ch->qst, QST_TIERTWO_ONE) &&
        !IS_SET(ch->qst, QST_TIERTHR_ONE) &&
        !IS_SET(ch->qst, QST_TIERFOU_ONE) &&
        !IS_SET(ch->qst, QST_TIERFIV_ONE) &&
        !IS_SET(ch->qst, QST_TIERSIX_ONE))
    send_to_char("{gYou have not completed any of the tier based quests.{x\n\r", ch);
    send_to_char("{G\n\rRacial Quests{W:{g\n\r", ch);
    if(IS_SET(ch->rce, RCE_MINOTAUR_ONE))
     send_to_char("{gYou have completed the first part of the minotaur quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_TROLL_ONE))
     send_to_char("{gYou have completed the first part of the troll quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_CENTAUR_ONE))
     send_to_char("{gYou have completed the first part of the centaur quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_IMP_ONE))
     send_to_char("{gYou have completed the first part of the imp quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_GOBLIN_ONE))
     send_to_char("{gYou have completed the first part of the goblin quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_GNOME_ONE))
     send_to_char("{gYou have completed the first part of the gnome quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_FAERY_ONE))
     send_to_char("{gYou have completed the first part of the faery quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_AAROK_ONE))
     send_to_char("{gYou have completed the first part of the aarokcra quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_OGRE_ONE))
     send_to_char("{gYou have completed the first part of the ogre quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_DWARF_ONE))
     send_to_char("{gYou have completed the first part of the dwarf quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_ELF_ONE))
     send_to_char("{gYou have completed the first part of the elf quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_HUMAN_ONE))
     send_to_char("{gYou have completed the first part of the human quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_MINOTAUR_TWO))
     send_to_char("{gYou have completed the second part of the minotaur quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_TROLL_TWO))
     send_to_char("{gYou have completed the second part of the troll quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_CENTAUR_TWO))
     send_to_char("{gYou have completed the second part of the centaur quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_IMP_TWO))
     send_to_char("{gYou have completed the second part of the imp quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_GOBLIN_TWO))
     send_to_char("{gYou have completed the second part of the goblin quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_GNOME_TWO))
     send_to_char("{gYou have completed the second part of the gnome quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_FAERY_TWO))
     send_to_char("{gYou have completed the second part of the faery quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_AAROK_TWO))
     send_to_char("{gYou have completed the second part of the aarokcra quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_OGRE_TWO))
     send_to_char("{gYou have completed the second part of the ogre quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_DWARF_TWO))
     send_to_char("{gYou have completed the second part of the dwarf quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_ELF_TWO))
     send_to_char("{gYou have completed the second part of the elf quest.{x\n\r", ch);
    if(IS_SET(ch->rce, RCE_HUMAN_TWO))
     send_to_char("{gYou have completed the second part of the human quest.{x\n\r", ch);
    if(!IS_SET(ch->rce, RCE_MINOTAUR_ONE) &&
        !IS_SET(ch->rce, RCE_TROLL_ONE) &&
        !IS_SET(ch->rce, RCE_CENTAUR_ONE) &&
        !IS_SET(ch->rce, RCE_IMP_ONE) &&
        !IS_SET(ch->rce, RCE_GOBLIN_ONE) &&
        !IS_SET(ch->rce, RCE_GNOME_ONE) &&
        !IS_SET(ch->rce, RCE_FAERY_ONE) &&
        !IS_SET(ch->rce, RCE_AAROK_ONE) &&
        !IS_SET(ch->rce, RCE_OGRE_ONE) &&
        !IS_SET(ch->rce, RCE_DWARF_ONE) &&
        !IS_SET(ch->rce, RCE_ELF_ONE) &&
        !IS_SET(ch->rce, RCE_HUMAN_ONE) &&
        !IS_SET(ch->rce, RCE_MINOTAUR_TWO) &&
        !IS_SET(ch->rce, RCE_TROLL_TWO) &&
        !IS_SET(ch->rce, RCE_CENTAUR_TWO) &&
        !IS_SET(ch->rce, RCE_IMP_TWO) &&
        !IS_SET(ch->rce, RCE_GOBLIN_TWO) &&
        !IS_SET(ch->rce, RCE_GNOME_TWO) &&
        !IS_SET(ch->rce, RCE_FAERY_TWO) &&
        !IS_SET(ch->rce, RCE_AAROK_TWO) &&
        !IS_SET(ch->rce, RCE_OGRE_TWO) &&
        !IS_SET(ch->rce, RCE_DWARF_TWO) &&
        !IS_SET(ch->rce, RCE_ELF_TWO) &&
        !IS_SET(ch->rce, RCE_HUMAN_TWO))
    send_to_char("{gYou have not completed any of the racial quests yet.\n\r{x", ch);

    send_to_char("{G\n\rSide Quests{W:{g\n\r", ch);
    if(IS_SET(ch->sde, SDE_QSTONE_ONE))
     send_to_char("{gYou have completed the first side quest.{x\n\r", ch);
    if(IS_SET(ch->sde, SDE_QSTTWO_ONE))
     send_to_char("{gYou have completed the second side quest.{x\n\r", ch);
    if(!IS_SET(ch->sde, SDE_QSTONE_ONE) &&
        !IS_SET(ch->sde, SDE_QSTTWO_ONE))
     send_to_char("{gYou have not completed any of the side quests yet.\n\r{x", ch);
    }
}

// Now add everything below this line into the bottom of act_wiz.c and your done.

// Add the following into act_wiz.c at the bottom

/***************************************************************************************
 *                                                                                     *
 * The following two commands are for use with the new bit flag QST_XX_XX to go with   *
 * the quest system for tiering up and possible side quests which was coded in Jan 07. *
 *                                                                                     *
 * Other files of interest for QST_ Flags: swaybal.h, handler.c, interp.c, interp.h       *
 * mob_cmds.c, mob_cmds.h, tables.c, act_info.c (qinfo)                                *
 *                                                                                     *
 ***************************************************************************************/
// This command is also used for the RCE_ and SDE_ and soon to be CLS_ quests. 
/* 
 * do_bitflag by Taemos 01/07: Used to set QST_ flags
 * 
 * Other files: interp.c, interp.h, mob_cmds.c, mob_cmds.h, tables.c, tables.h
 * mob_prog.c
 * 
 * Thanks to Skol from Ansalon (ansalonmud.com:8679) for help w/ debugging.
 */
   
void do_bitflag (CHAR_DATA * ch, char *argument)
{
 char buf[MSL];
 char arg1[MIL];
 char arg2[MIL];                
 CHAR_DATA *victim; 
    
 argument = one_argument(argument, arg1);
 argument = one_argument(argument, arg2); 

   if (arg1[0] == '\0' || arg2[0] == '\0') 
   {
    send_to_char("Syntax: bitflag <player> <qstflag>\n\r", ch);
    return;    
   }
   /* Checking to see if the player is logged in. */
   if ((victim = get_char_world (ch, arg1)) == NULL)
   {
    send_to_char ("Players must be logged in to have a bit flag set.\n\r", ch);
    return;
   }    
   /* Mobs arent coded for QST_ flags. */
   if (IS_NPC (victim))
   {
    send_to_char ("Mobiles cannot have quest bit flags set.\n\r", ch);
    return;
   }
   /* No reason to use the argument of all. */
   if ( !str_cmp( arg1, "all" ) )
   {
    send_to_char("That will NOT be done.", ch);
   }
   /*Checking to see for QST_TIERONE_ONE */
   if (!str_cmp (arg2, "tieroneone") || !str_cmp (arg2, "tier11"))
   {
     if(IS_SET(victim->qst, QST_TIERONE_ONE))
     {
      send_to_char("QST_TIERONE_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->qst, QST_TIERONE_ONE);
      return;
     }
     send_to_char("QST_TIERONE_ONE is being set.\n\r", ch);
     SET_BIT(victim->qst, QST_TIERONE_ONE);
     return;
   }
 /*Checking to see for QST_TIERTWO_ONE */
  if (!str_cmp (arg2, "tiertwoone") || !str_cmp (arg2, "tier21"))
   {
     if(IS_SET(victim->qst, QST_TIERTWO_ONE))
     {
      send_to_char("QST_TIERTWO_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->qst, QST_TIERTWO_ONE);
      return;
     }
     send_to_char("QST_TIERTWO_ONE is being set.\n\r", ch);
     SET_BIT(victim->qst, QST_TIERTWO_ONE);
     return;
   }
  /*Checking to see for QST_TIERTHR_ONE */
  if (!str_cmp (arg2, "tierthreeone") || !str_cmp (arg2, "tier31"))
   {
    if(IS_SET(victim->qst, QST_TIERTHR_ONE))
     {
      send_to_char("QST_TIERTHR_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->qst, QST_TIERTHR_ONE);
      return;
     }
     send_to_char("QST_TIERTHR_ONE is being set.\n\r", ch);
     SET_BIT(victim->qst, QST_TIERTHR_ONE);
     return;
   }
  /*Checking to see for QST_TIERFOU_ONE */
  if (!str_cmp (arg2, "tierfourone") || !str_cmp (arg2, "tier41"))
   {
     if(IS_SET(victim->qst, QST_TIERFOU_ONE))
     {
      send_to_char("QST_TIERFOU_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->qst, QST_TIERFOU_ONE);
      return;
     }
     send_to_char("QST_TIERFOU_ONE is being set.\n\r", ch);
     SET_BIT(victim->qst, QST_TIERFOU_ONE);
     return;
   }
  /*Checking to see for QST_TIERFIV_ONE */
  if (!str_cmp (arg2, "tierfiveone") || !str_cmp (arg2, "tier51"))
   {
     if(IS_SET(victim->qst, QST_TIERFIV_ONE))
     {
      send_to_char("QST_TIERFIV_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->qst, QST_TIERFIV_ONE);
      return;
     }
     send_to_char("QST_TIERFIV_ONE is being set.\n\r", ch);
     SET_BIT(victim->qst, QST_TIERFIV_ONE);
     return;
   }
  /*Checking to see for QST_TIERSIX_ONE */
  if (!str_cmp (arg2, "tiersixone") || !str_cmp (arg2, "tier61"))
   {
     if(IS_SET(victim->qst, QST_TIERSIX_ONE))
     {
      send_to_char("QST_TIERSIX_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->qst, QST_TIERSIX_ONE);
      return;
     }
     send_to_char("QST_TIERSIX_ONE is being set.\n\r", ch);
     SET_BIT(victim->qst, QST_TIERSIX_ONE);
     return;
   }
/* CHECKING FOR RACE QUEST BIT FLAGS */
  /*Checking to see for RCE_MINOTAUR_ONE */
  if (!str_cmp (arg2, "minotaur1") || !str_cmp (arg2, "minotaurone"))
   {
     if(IS_SET(victim->rce, RCE_MINOTAUR_ONE))
     {
      send_to_char("RCE_MINOTAUR_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_MINOTAUR_ONE);
      return;
     }
     send_to_char("RCE_MINOTAUR_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_MINOTAUR_ONE);
     return;
   }
  /*Checking to see for RCE_MINOTAUR_TWO */
  if (!str_cmp (arg2, "minotaur2") || !str_cmp (arg2, "minotaurtwo"))
   {
     if(IS_SET(victim->rce, RCE_MINOTAUR_TWO))
     {
      send_to_char("RCE_MINOTAUR_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_MINOTAUR_TWO);
      return;
     }
     send_to_char("RCE_MINOTAUR_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_MINOTAUR_TWO);
     return;
   }
  /*Checking to see for RCE_TROLL_ONE */
  if (!str_cmp (arg2, "troll1") || !str_cmp (arg2, "trollone"))
   {
     if(IS_SET(victim->rce, RCE_TROLL_ONE))
     {
      send_to_char("RCE_TROLL_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_TROLL_ONE);
      return;
     }
     send_to_char("RCE_TROLL_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_TROLL_ONE);
     return;
   }
  /*Checking to see for RCE_CENTAUR_ONE*/
  if (!str_cmp (arg2, "centaur1") || !str_cmp (arg2, "centaurone"))
   {
     if(IS_SET(victim->rce, RCE_CENTAUR_ONE))
     {
      send_to_char("RCE_CENTAUR_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_CENTAUR_ONE);
      return;
     }
     send_to_char("RCE_CENTAUR_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_CENTAUR_ONE);
     return;
   }
  /*Checking to see for RCE_CENTAUR_TWO*/
  if (!str_cmp (arg2, "centaur2") || !str_cmp (arg2, "centaurtwo"))
   {
     if(IS_SET(victim->rce, RCE_CENTAUR_TWO))
     {
      send_to_char("RCE_CENTAUR_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_CENTAUR_TWO);
      return;
     }
     send_to_char("RCE_CENTAUR_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_CENTAUR_TWO);
     return;
   }
  /*Checking to see for RCE_IMP_ONE*/
  if (!str_cmp (arg2, "imp1") || !str_cmp (arg2, "impone"))
   {
     if(IS_SET(victim->rce, RCE_IMP_ONE))
     {
      send_to_char("RCE_IMP_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_IMP_ONE);
      return;
     }
     send_to_char("RCE_IMP_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_IMP_ONE);
     return;
   }
  /*Checking to see for RCE_IMP_TWO*/
  if (!str_cmp (arg2, "imp2") || !str_cmp (arg2, "imptwo"))
   {
     if(IS_SET(victim->rce, RCE_IMP_TWO))
     {
      send_to_char("RCE_IMP_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_IMP_TWO);
      return;
     }
     send_to_char("RCE_IMP_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_IMP_TWO);
     return;
   }
  /*Checking to see for RCE_GOBLIN_ONE*/
  if (!str_cmp (arg2, "goblin1") || !str_cmp (arg2, "goblinone"))
   {
     if(IS_SET(victim->rce, RCE_GOBLIN_ONE))
     {
      send_to_char("RCE_GOBLIN_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_GOBLIN_ONE);
      return;
     }
     send_to_char("RCE_GOBLIN_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_GOBLIN_ONE);
     return;
   }
  /*Checking to see for RCE_GOBLIN_TWO*/
  if (!str_cmp (arg2, "goblin2") || !str_cmp (arg2, "goblintwo"))
   {
     if(IS_SET(victim->rce, RCE_GOBLIN_TWO))
     {
      send_to_char("RCE_GOBLIN_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_GOBLIN_TWO);
      return;
     }
     send_to_char("RCE_GOBLIN_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_GOBLIN_TWO);
     return;
   }
  /*Checking to see for RCE_GNOME_ONE*/
  if (!str_cmp (arg2, "gnome1") || !str_cmp (arg2, "gnomeone"))
   {
     if(IS_SET(victim->rce, RCE_GNOME_ONE))
     {
      send_to_char("RCE_GNOME_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_GNOME_ONE);
      return;
     }
     send_to_char("RCE_GNOME_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_GNOME_ONE);
     return;
   }
  /*Checking to see for RCE_GNOME_TWO*/
  if (!str_cmp (arg2, "gnome2") || !str_cmp (arg2, "gnometwo"))
   {
     if(IS_SET(victim->rce, RCE_GNOME_TWO))
     {
      send_to_char("RCE_GNOME_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_GNOME_TWO);
      return;
     }
     send_to_char("RCE_GNOME_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_GNOME_TWO);
     return;
   }
  /*Checking to see for RCE_FAERY_ONE*/
  if (!str_cmp (arg2, "faery1") || !str_cmp (arg2, "faeryone"))
   {
     if(IS_SET(victim->rce, RCE_FAERY_ONE))
     {
      send_to_char("RCE_FAERY_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_FAERY_ONE);
      return;
     }
     send_to_char("RCE_FAERY_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_FAERY_ONE);
     return;
   }
  /*Checking to see for RCE_FAERY_TWO*/
  if (!str_cmp (arg2, "faerytwo") || !str_cmp (arg2, "faery2"))
   {
     if(IS_SET(victim->rce, RCE_FAERY_TWO))
     {
      send_to_char("RCE_FAERY_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_FAERY_TWO);
      return;
     }
     send_to_char("RCE_FAERY_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_FAERY_TWO);
     return;
   }
  /*Checking to see for RCE_AAROK_ONE*/
  if (!str_cmp (arg2, "aarokcra1") || !str_cmp (arg2, "aarokcraone"))
   {
     if(IS_SET(victim->rce, RCE_AAROK_ONE))
     {
      send_to_char("RCE_AAROK_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_AAROK_ONE);
      return;
     }
     send_to_char("RCE_AAROK_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_AAROK_ONE);
     return;
   }
/*Checking to see for RCE_AAROK_TWO */
  if (!str_cmp (arg2, "aarokcra2") || !str_cmp (arg2, "aarokcratwo"))
   {
     if(IS_SET(victim->rce, RCE_AAROK_TWO))
     {
      send_to_char("RCE_AAROK_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_AAROK_TWO);
      return;
     }
     send_to_char("RCE_AAROK_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_AAROK_TWO);
     return;
   }
  /*Checking to see for RCE_OGRE_ONE*/
  if (!str_cmp (arg2, "ogreone") || !str_cmp (arg2, "ogre1"))
   {
     if(IS_SET(victim->rce, RCE_OGRE_ONE))
     {
      send_to_char("RCE_OGRE_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_OGRE_ONE);
      return;
     }
     send_to_char("RCE_OGRE_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_OGRE_ONE);
     return;
   }
  /*Checking to see for RCE_OGRE_TWO*/
  if (!str_cmp (arg2, "ogretwo") || !str_cmp (arg2, "ogre2"))
   {
     if(IS_SET(victim->rce, RCE_OGRE_TWO))
     {
      send_to_char("RCE_OGRE_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_OGRE_TWO);
      return;
     }
     send_to_char("RCE_OGRE_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_OGRE_TWO);
     return;
   }
  /*Checking to see for RCE_DWARF_ONE*/
  if (!str_cmp (arg2, "dwarfone") || !str_cmp (arg2, "dwarf1"))
   {
     if(IS_SET(victim->rce, RCE_DWARF_ONE))
     {
      send_to_char("RCE_DWARF_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_DWARF_ONE);
      return;
     }
     send_to_char("RCE_DWARF_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_DWARF_ONE);
     return;
   }
  /*Checking to see for RCE_DWARF_TWO*/
  if (!str_cmp (arg2, "dwarftwo") || !str_cmp (arg2, "dwarf2"))
   {
     if(IS_SET(victim->rce, RCE_DWARF_TWO))
     {
      send_to_char("RCE_DWARF_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_DWARF_TWO);
      return;
     }
     send_to_char("RCE_DWARF_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_DWARF_TWO);
     return;
   }
  /*Checking to see for RCE_ELF_ONE*/
  if (!str_cmp (arg2, "elfone") || !str_cmp (arg2, "elf1"))
   {
     if(IS_SET(victim->rce, RCE_ELF_ONE))
     {
      send_to_char("RCE_ELF_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_ELF_ONE);
      return;
     }
     send_to_char("RCE_ELF_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_ELF_ONE);
     return;
   }
  /*Checking to see for RCE_ELF_TWO*/
  if (!str_cmp (arg2, "elftwo") || !str_cmp (arg2, "elf2"))
   {
     if(IS_SET(victim->rce, RCE_ELF_TWO))
     {
      send_to_char("RCE_ELF_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_ELF_TWO);
      return;
     }
     send_to_char("RCE_ELF_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_ELF_TWO);
     return;
   }
  /*Checking to see for RCE_HUMAN_ONE*/
  if (!str_cmp (arg2, "humanone") || !str_cmp (arg2, "human1"))
   {
     if(IS_SET(victim->rce, RCE_HUMAN_ONE))
     {
      send_to_char("RCE_HUMAN_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_HUMAN_ONE);
      return;
     }
     send_to_char("RCE_HUMAN_ONE is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_HUMAN_ONE);
     return;
   }
  /*Checking to see for RCE_HUMAN_TWO*/
  if (!str_cmp (arg2, "humantwo") || !str_cmp (arg2, "human2"))
   {
     if(IS_SET(victim->rce, RCE_HUMAN_TWO))
     {
      send_to_char("RCE_HUMAN_TWO is being removed.\n\r", ch);
      REMOVE_BIT(victim->rce, RCE_HUMAN_TWO);
      return;
     }
     send_to_char("RCE_HUMAN_TWO is being set.\n\r", ch);
     SET_BIT(victim->rce, RCE_HUMAN_TWO);
     return;
   }

/* CHECKING FOR SIDE QUEST BIT FLAGS */

  /*Checking to see for SDE_QSTONE_ONE */
  if (!str_cmp (arg2, "sidequestoneone") || !str_cmp (arg2, "sq11"))
   {
     if(IS_SET(victim->sde, SDE_QSTONE_ONE))
     {
      send_to_char("SDE_QSTONE_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->sde, SDE_QSTONE_ONE);
      return;
     }
     send_to_char("SDE_QSTONE_ONE is being set.\n\r", ch);
     SET_BIT(victim->sde, SDE_QSTONE_ONE);
     return;
   }
  /*Checking to see for SDE_QSTTWO_ONE */
  if (!str_cmp (arg2, "sidequesttwoone") || !str_cmp (arg2, "sq21"))
   {
     if(IS_SET(victim->sde, SDE_QSTTWO_ONE))
     {
      send_to_char("SDE_QSTTWO_ONE is being removed.\n\r", ch);
      REMOVE_BIT(victim->sde, SDE_QSTTWO_ONE);
      return;
     }
     send_to_char("SDE_QSTTWO_ONE is being set.\n\r", ch);
     SET_BIT(victim->sde, SDE_QSTTWO_ONE);
     return;
   }
 /* Testing to see why this wont work. */
 sprintf(buf, "Player %s and flag %s are invalid arguments, please see help bitflag.", arg1, arg2);
 send_to_char (buf,ch);
}

/* 
 * do_bitshow by Taemos 01/07 (Used to display a player's QST_, RCE_, and SDE_ flags
 * 
 * Other Files: interp.c, interp.h
 */  
     
void do_bitshow (CHAR_DATA *ch, char *argument)
{    
 char buf[MAX_STRING_LENGTH];
 char arg[MAX_INPUT_LENGTH];
 CHAR_DATA *victim;
     
 argument = one_argument (argument, arg);
   /* Making sure the player is logged in. */
   if ((victim = get_char_world (ch, arg)) == NULL)
   { 
    send_to_char ("They aren't here.\n\r", ch);
    return;
   }
   /* Showing the victim's QST_, RCE_, and SDE_ flags */
   if (arg[0] == '\0' || argument[0] == '\0')
   {    
    sprintf (buf, "{gBit Flags for {G%s{x:\n\r{g-------------------------{x\n\r", victim->name);
        send_to_char(buf, ch);
    sprintf (buf, "  {GTier {W:{g %s{x\n\r", qst_bit_name (victim->qst));
        send_to_char(buf, ch);
    sprintf (buf, "{GRacial {W:{g %s{x\n\r", rce_bit_name (victim->rce));
        send_to_char(buf, ch);
    sprintf (buf, "{G  Side {W:{g %s\n\r",   sde_bit_name (victim->sde));
        send_to_char(buf, ch);
    return;
   }  
   /* Would be waaay too spammy. */
   if (!str_cmp (arg, "all") || !str_cmp (argument, "all"))
   {  
    send_to_char ("We wont be doing that.", ch);
    return;
   }
   /* Making sure the command says something if syntax is invalid. */
   send_to_char ("Check who's questflags?", ch);
   return;
}