/*___________________________________________________________________________*
)()( DalekenMUD 1.12 (C) 2000 )()(
`][' by Martin Thomson, Lee Brooks, `]['
|| Ken Herbert and David Jacques ||
|| ----------------------------------------------------------------- ||
|| Envy Diku Mud improvements copyright (C) 1994 by Michael Quan, ||
|| David Love, Guilherme 'Willie' Arnold, and Mitchell Tse. ||
|| Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael ||
|| Chastain, Michael Quan, and Mitchell Tse. ||
|| Original Diku Mud copyright (C) 1990, 1991 ||
|| by Sebastian Hammer, Michael Seifert, Hans Henrik St{rfeldt, ||
|| Tom Madsen, and Katja Nyboe. ||
|| ----------------------------------------------------------------- ||
|| Any use of this software must follow the licenses of the ||
|| creators. Much time and thought has gone into this software and ||
|| you are benefitting. We hope that you share your changes too. ||
|| What goes around, comes around. ||
|| ----------------------------------------------------------------- ||
|| bit.c ||
|| Integer mapping tables and functions. ||
*_/<>\_________________________________________________________________/<>\_*/
/*
The code below uses a table lookup system that is based on suggestions
from Russ Taylor. There are many routines in handler.c that would benefit
with the use of tables. You may consider simplifying your code base by
implementing a system like below with such functions. -Jason Dinkel
*/
#include "mud.h"
#include "olc.h"
#include "event.h"
/*
* This table contains all bit structures, neatly indexed by name.
* ------------------------------------------------------------------
*/
const struct bit_table_type bit_table[] =
{
{ "room", room_flags, BIT_FLAG,
"Room attributes." },
{ "sector", sector_flags, BIT_STAT,
"Sector types, terrain." },
{ "extra", extra_flags, BIT_FLAG,
"Object attributes." },
{ "wear", wear_flags, BIT_FLAG,
"Possible locations to wear an object." },
{ "wear-loc", wear_loc_flags, BIT_STAT,
"Possible locations to wear an object." },
{ "apply", apply_flags, BIT_STAT,
"Spell application slot." },
{ "affect", affect_flags, BIT_VECTOR,
"Special spell effect bits." },
{ "act", act_flags, BIT_VECTOR,
"Mobile attributes." },
{ "evextra", event_extra_flags, BIT_FLAG,
"Event extra flags." },
{ "type", type_flags, BIT_STAT,
"Types of objects." },
{ "materials", material_flags, BIT_STAT,
"Types of item materials." },
{ "exit", exit_flags, BIT_FLAG,
"Exit types." },
{ "sex", sex_flags, BIT_STAT,
"Sexes." },
{ "limbs", body_part_flags, BIT_FLAG,
"Different body parts." },
{ "class", class_flags, BIT_STAT,
"Classes available." },
{ "mudprogs", mud_prog_flags, BIT_STAT,
"Types of MudProgs." },
{ "area", area_flags, BIT_FLAG,
"Area attributes." },
{ "dir", exit_direction_flags, BIT_STAT,
"Direction names." },
{ "clan", clan_type_flags, BIT_STAT,
"Different clan types." },
{ "magic", magic_flags, BIT_STAT,
"Magic spheres." },
{ "sacrifice", sac_event_flags, BIT_FLAG,
"Sacrificial events." },
{ "pcact", pc_act_flags, BIT_VECTOR,
"Player attributes." },
{ "channel", channel_flags, BIT_FLAG | BIT_INVISIBLE,
"Talk channel flags." },
{ "weapon", weapon_flags, BIT_STAT,
"Type of weapon." },
{ "container", container_flags, BIT_FLAG,
"Container status." },
{ "furniture", furniture_flags, BIT_FLAG,
"Furniture type." },
{ "mor", mor_type_flags, BIT_FLAG | BIT_INVISIBLE,
"Mob/Object/Room flags." },
{ "sysinfo", sysinfo_flags, BIT_FLAG | BIT_INVISIBLE,
"System configuration flags." },
{ "apply-name", apply_name_flags, BIT_STAT,
"Spell application slot." },
{ "wear-loc-long", wear_loc_strings, BIT_STAT,
"Possible locations to wear an object (long)." },
{ "raceperm", race_perm_flags, BIT_FLAG,
"Permanent racial attributes." },
{ "language", language_flags, BIT_STAT,
"All the languages." },
{ "position", position_flags, BIT_STAT | BIT_INVISIBLE,
"Character position." },
{ "liquid", NULL, BIT_STAT,
"Types of liquids." },
{ "spec", NULL, BIT_STAT,
"Available special programs." },
{ "spells", NULL, BIT_STAT,
"Names of current spells." },
{ "", NULL, BIT_STAT, "" }
};
/*****************************************************************************
Name: is_stat( table )
Purpose: Returns TRUE if the table is a stat table and FALSE if flag.
Called by: flag_value and flag_string.
Note: This function is local and used only in bit.c.
****************************************************************************/
bool is_stat( const struct flag_type *flag_table )
{
int flag;
for( flag = 0; bit_table[flag].structure; flag++ )
{
if( bit_table[flag].structure == flag_table
&& ( bit_table[flag].flags & BIT_TYPE_MASK ) == BIT_STAT )
return TRUE;
}
return FALSE;
}
bool is_vector( const struct flag_type *flag_table )
{
int flag;
for( flag = 0; bit_table[flag].structure; flag++ )
{
if( bit_table[flag].structure == flag_table
&& ( bit_table[flag].flags & BIT_TYPE_MASK ) == BIT_VECTOR )
return TRUE;
}
return FALSE;
}
/*
* This function is Russ Taylor's creation. Thanks Russ!
* All code copyright (C) Russ Taylor, permission to use and/or distribute
* has NOT been granted. Use only in this OLC package has been granted.
*/
/*****************************************************************************
Name: flag_lookup( flag, table )
Purpose: Returns the value of a single, settable flag from the table.
Called by: flag_value and flag_string.
Note: This function is local and used only in bit.c.
****************************************************************************/
int flag_lookup( const char *name, const struct flag_type *flag_table )
{
int flag;
for( flag = 0; *flag_table[flag].name; flag++ ) /* OLC 1.1b */
{
if( !str_cmp( name, flag_table[flag].name )
&& ( flag_table[flag].settable || fBootDb ) )
return flag_table[flag].bit;
}
return NO_FLAG;
}
/*****************************************************************************
Name: flag_value( table, flag )
Purpose: Returns the value of the flags entered. Multi-flags accepted.
Called by: olc.c and olc_act.c.
****************************************************************************/
int flag_value( int *target, const struct flag_type *flag_table,
const char *argument)
{
char word[MAX_INPUT_LENGTH];
int bit;
int marked = 0;
bool found = FALSE, vect = FALSE;
if( is_stat( flag_table ) )
{
one_argument( argument, word );
bit = flag_lookup( word, flag_table );
if( target )
*target = bit;
return bit;
}
/*
* Accept multiple flags.
*/
if( is_vector( flag_table ) )
{
vzero( target );
vect = TRUE;
}
for( ;; )
{
argument = one_argument( argument, word );
if ( word[0] == '\0' )
break;
if ( ( bit = flag_lookup( word, flag_table ) ) != NO_FLAG )
{
if( vect )
xSET_BIT( target, bit );
else
SET_BIT( marked, bit );
found = TRUE;
}
}
if( found )
{
if( vect )
return *target;
else if( target )
*target = marked;
return marked;
}
else
return NO_FLAG;
}
/*****************************************************************************
Name: flag_string( table, flags/stat )
Purpose: Returns string with name(s) of the flags or stat entered.
Called by: olc_act.c, olc.c, and olc_save.c.
****************************************************************************/
const char *flag_string( const struct flag_type *flag_table, int * bits )
{
static char buf[MAX_INPUT_LENGTH];
int flag;
bool vect = FALSE, stat = FALSE;
buf[0] = '\0';
if( is_vector( flag_table ) )
vect = TRUE;
if( is_stat( flag_table ) )
stat = TRUE;
for( flag = 0; *flag_table[flag].name; flag++ ) /* OLC 1.1b */
{
if( ( vect && xIS_SET( bits, flag_table[flag].bit ) )
|| ( !vect && !stat
&& IS_SET( *bits, flag_table[flag].bit ) ) )
{
strcat( buf, " " );
strcat( buf, flag_table[flag].name );
}
else if( !vect && flag_table[flag].bit == *bits )
{
strcat( buf, " " );
strcat( buf, flag_table[flag].name );
break;
}
}
return (buf[0] != '\0') ? buf+1 : "none";
}
/*****************************************************************************
Name: get_lookup
Purpose: uses two strings to find the value of a lookup string.
Called by: load_* (db.c)
****************************************************************************/
int get_lookup( int *target, const char *table, const char *flags )
{
int i, check;
/* check a few of the 'manual' lookup functions first. */
if( !str_cmp( table, "skill" ) )
{
i = skill_lookup( flags );
if( target )
*target = i;
return i;
}
if( !str_cmp( table, "race" ) )
{
i = race_lookup( flags );
if( target )
*target = i;
return i;
}
if( !str_cmp( table, "liquid" ) )
{
i = liquid_lookup( flags );
if( target )
*target = i;
return i;
}
if( !str_cmp( table, "event" ) )
{
struct event_table_type *tab;
tab = event_table_lookup( flags );
if( !tab )
i = NO_FLAG;
else
i = *tab->type;
if( target )
*target = i;
return i;
}
for( i = 0; bit_table[i].desc && bit_table[i].desc[0]; ++i )
if( !str_prefix( table, bit_table[i].command ) )
break;
if( !bit_table[i].desc || bit_table[i].desc[0] == '\0'
|| !bit_table[i].structure )
return NO_FLAG;
check = flag_value( target, (struct flag_type *)bit_table[i].structure, flags );
if( *target == NO_FLAG
&& !is_stat( (struct flag_type *)bit_table[i].structure ) )
return 0;
else
return check;
}
const struct flag_type area_flags[] =
{
{ "none", AREA_NONE, FALSE },
{ "changed", AREA_CHANGED, FALSE },
{ "added", AREA_ADDED, FALSE },
{ "loading", AREA_LOADING, FALSE },
{ "verbose-save", AREA_VERBOSE, FALSE },
{ "verbose", AREA_ALWAYS_VERBOSE, TRUE },
{ "deleted", AREA_DELETED, TRUE },
{ "hidden", AREA_HIDE, TRUE },
{ "finished", AREA_NOSAVE, TRUE },
{ "sentinel", AREA_SENTINEL, TRUE },
{ "no-flood", AREA_NO_FLOOD, TRUE },
{ "", 0, 0 }
};
const struct flag_type sex_flags[] =
{
{ "male", SEX_MALE, TRUE },
{ "female", SEX_FEMALE, TRUE },
{ "neutral", SEX_NEUTRAL, TRUE },
{ "", 0, 0 }
};
const struct flag_type exit_flags[] =
{
{ "door", EX_ISDOOR, TRUE },
{ "closed", EX_CLOSED, TRUE },
{ "locked", EX_LOCKED, TRUE },
{ "bashed", EX_BASHED, FALSE },
{ "bashproof", EX_BASHPROOF, TRUE },
{ "pickproof", EX_PICKPROOF, TRUE },
{ "hardpick", EX_HARDPICK, TRUE },
{ "passproof", EX_PASSPROOF, TRUE },
{ "trapped", EX_TRAPPED, TRUE },
{ "hidden", EX_HIDDEN, TRUE },
{ "eat-key", EX_EAT_KEY, TRUE },
{ "temporary", EX_TEMPORARY, FALSE },
{ "noshadow", EX_NOSHADOW, TRUE },
{ "", 0, 0 }
};
const struct flag_type room_flags[] =
{
{ "dark", ROOM_DARK, TRUE },
{ "no_mob", ROOM_NO_MOB, TRUE },
{ "indoors", ROOM_INDOORS, TRUE },
{ "underground", ROOM_UNDERGROUND, TRUE },
{ "private", ROOM_PRIVATE, TRUE },
{ "safe", ROOM_SAFE, TRUE },
{ "solitary", ROOM_SOLITARY, TRUE },
{ "pet_shop", ROOM_PET_SHOP, TRUE },
{ "no_recall", ROOM_NO_RECALL, TRUE },
{ "no_portal", ROOM_NO_PORTAL, TRUE },
{ "cone_of_silence", ROOM_CONE_OF_SILENCE, TRUE },
{ "arena", ROOM_ARENA, TRUE },
{ "fall", ROOM_FALL, TRUE },
{ "hot", ROOM_HOT, TRUE },
{ "cold", ROOM_COLD, TRUE },
{ "forage", ROOM_FORAGE, TRUE },
{ "flooded", ROOM_FLOODED, FALSE },
{ "", 0, 0 }
};
const struct flag_type sector_flags[] =
{
{ "inside", SECT_INSIDE, TRUE },
{ "city", SECT_CITY, TRUE },
{ "field", SECT_FIELD, TRUE },
{ "forest", SECT_FOREST, TRUE },
{ "hills", SECT_HILLS, TRUE },
{ "mountain", SECT_MOUNTAIN, TRUE },
{ "water", SECT_WATER_SWIM, TRUE },
{ "noswim", SECT_WATER_NOSWIM, TRUE },
{ "underwater", SECT_UNDERWATER, TRUE },
{ "air", SECT_AIR, TRUE },
{ "desert", SECT_DESERT, TRUE },
{ "space", SECT_SPACE, TRUE },
{ "swamp", SECT_SWAMP, TRUE },
{ "", 0, 0 }
};
const struct flag_type type_flags[] =
{
{ "light", ITEM_LIGHT, TRUE },
{ "scroll", ITEM_SCROLL, TRUE },
{ "wand", ITEM_WAND, TRUE },
{ "staff", ITEM_STAFF, TRUE },
{ "weapon", ITEM_WEAPON, TRUE },
{ "treasure", ITEM_TREASURE, TRUE },
{ "armour", ITEM_ARMOUR, TRUE },
{ "armor", ITEM_ARMOUR, TRUE },
{ "potion", ITEM_POTION, TRUE },
{ "furniture", ITEM_FURNITURE, TRUE },
{ "trash", ITEM_TRASH, TRUE },
{ "container", ITEM_CONTAINER, TRUE },
{ "drink-container", ITEM_DRINK_CON, TRUE },
{ "key", ITEM_KEY, TRUE },
{ "food", ITEM_FOOD, TRUE },
{ "money", ITEM_MONEY, TRUE },
{ "boat", ITEM_BOAT, TRUE },
{ "npc corpse", ITEM_CORPSE_NPC, TRUE },
{ "pc corpse", ITEM_CORPSE_PC, FALSE },
{ "fountain", ITEM_FOUNTAIN, TRUE },
{ "pill", ITEM_PILL, TRUE },
{ "explosive", ITEM_EXPLOSIVE, TRUE },
{ "portal", ITEM_PORTAL, TRUE },
{ "plant", ITEM_PLANT, TRUE },
{ "limb", ITEM_LIMB, TRUE },
{ "book", ITEM_BOOK, TRUE },
{ "gem", ITEM_GEM, TRUE },
{ "", 0, 0 }
};
const struct flag_type extra_flags[] =
{
{ "glow", ITEM_GLOW, TRUE },
{ "hum", ITEM_HUM, TRUE },
{ "dark", ITEM_DARK, TRUE },
{ "quest", ITEM_QUEST, FALSE },
{ "evil", ITEM_EVIL, TRUE },
{ "invis", ITEM_INVIS, TRUE },
{ "magic", ITEM_MAGIC, TRUE },
{ "nodrop", ITEM_NODROP, TRUE },
{ "bless", ITEM_BLESS, TRUE },
{ "anti-good", ITEM_ANTI_GOOD, TRUE },
{ "anti-evil", ITEM_ANTI_EVIL, TRUE },
{ "anti-neutral", ITEM_ANTI_NEUTRAL, TRUE },
{ "noremove", ITEM_NOREMOVE, TRUE },
{ "inventory", ITEM_INVENTORY, TRUE },
{ "poisoned", ITEM_POISONED, TRUE },
{ "vampire-bane", ITEM_VAMPIRE_BANE, TRUE },
{ "holy", ITEM_HOLY, TRUE },
{ "charged", ITEM_CHARGED, FALSE },
{ "sharp", ITEM_SHARP, TRUE },
{ "horned", ITEM_HORNED, TRUE },
{ "owner", ITEM_OWNER, TRUE },
{ "no-cast", ITEM_NO_CAST, TRUE },
{ "runed", ITEM_RUNED, TRUE },
{ "buried", ITEM_BURIED, TRUE },
{ "no-id", ITEM_NO_IDENTIFY, TRUE },
{ "fragile", ITEM_FRAGILE, TRUE },
{ "", 0, 0 }
};
const struct flag_type wear_flags[] =
{
{ "take", ITEM_TAKE, TRUE },
{ "finger", ITEM_WEAR_FINGER, TRUE },
{ "neck", ITEM_WEAR_NECK, TRUE },
{ "body", ITEM_WEAR_BODY, TRUE },
{ "head", ITEM_WEAR_HEAD, TRUE },
{ "legs", ITEM_WEAR_LEGS, TRUE },
{ "feet", ITEM_WEAR_FEET, TRUE },
{ "hands", ITEM_WEAR_HANDS, TRUE },
{ "arms", ITEM_WEAR_ARMS, TRUE },
{ "shield", ITEM_WEAR_SHIELD, TRUE },
{ "shoulders", ITEM_WEAR_SHOULDERS, TRUE },
{ "waist", ITEM_WEAR_WAIST, TRUE },
{ "wrist", ITEM_WEAR_WRIST, TRUE },
{ "wield", ITEM_WIELD, TRUE },
{ "double", ITEM_WIELD_DOUBLE, TRUE },
{ "hold", ITEM_HOLD, TRUE },
{ "face", ITEM_WEAR_FACE, TRUE },
{ "float", ITEM_FLOAT, TRUE },
{ "ankle", ITEM_WEAR_ANKLE, TRUE },
{ "horns", ITEM_WEAR_HORNS, TRUE },
{ "wings", ITEM_WEAR_WINGS, TRUE },
{ "ear", ITEM_WEAR_EAR, TRUE },
{ "nose", ITEM_WEAR_NOSE, TRUE },
{ "", 0, 0 }
};
const struct flag_type act_flags[] =
{
{ "npc", ACT_IS_NPC, FALSE },
{ "sentinel", ACT_SENTINEL, TRUE },
{ "scavenger", ACT_SCAVENGER, TRUE },
{ "aggressive", ACT_AGGRESSIVE, TRUE },
{ "stay_area", ACT_STAY_AREA, TRUE },
{ "wimpy", ACT_WIMPY, TRUE },
{ "pet", ACT_PET, TRUE },
{ "train", ACT_TRAIN, TRUE },
{ "practice", ACT_PRACTICE, TRUE },
{ "gamble", ACT_GAMBLE, TRUE },
{ "banker", ACT_BANKER, TRUE },
{ "mercenary", ACT_MERCENARY, TRUE },
{ "assist", ACT_ASSIST, TRUE },
{ "buried", ACT_BURIED, TRUE },
{ "racist", ACT_RACIST, TRUE },
{ "hunter", ACT_HUNTER, TRUE },
{ "questmaster", ACT_QUESTMASTER, TRUE },
{ "healer", ACT_HEALER, TRUE },
{ "delayed", ACT_DELAYED, FALSE },
{ "smith", ACT_SMITH, TRUE },
{ "prac-air", ACT_PRAC_AIR, TRUE },
{ "prac-earth", ACT_PRAC_EARTH, TRUE },
{ "prac-fire", ACT_PRAC_FIRE, TRUE },
{ "prac-spirit", ACT_PRAC_SPIRIT, TRUE },
{ "prac-water", ACT_PRAC_WATER, TRUE },
{ "!mudprog-error!", ACT_MUDPROG, FALSE },
{ "", 0, 0 }
};
const struct flag_type pc_act_flags[] =
{
{ "!npc!", PLR_IS_NPC, FALSE },
{ "afk", PLR_AFK, TRUE },
{ "autoexit", PLR_AUTOEXIT, TRUE },
{ "autogold", PLR_AUTOGOLD, TRUE },
{ "autoloot", PLR_AUTOLOOT, TRUE },
{ "autosac", PLR_AUTOSAC, TRUE },
{ "autosplit", PLR_AUTOSPLIT, TRUE },
{ "battle", PLR_BATTLE, TRUE },
{ "battleself", PLR_BATTLESELF, TRUE },
{ "battleother", PLR_BATTLEOTHER, TRUE },
{ "blank", PLR_BLANK, TRUE },
{ "bought-pet", PLR_BOUGHT_PET, TRUE },
{ "brief", PLR_BRIEF, TRUE },
{ "busy", PLR_BUSY, TRUE },
{ "colour", PLR_COLOUR, TRUE },
{ "combine", PLR_COMBINE, TRUE },
{ "denied", PLR_DENY, TRUE },
{ "frozen", PLR_FREEZE, TRUE },
{ "holylight", PLR_HOLYLIGHT, TRUE },
{ "info", PLR_INFO, TRUE },
{ "keylock", PLR_KEYLOCK, TRUE },
{ "logged", PLR_LOG, TRUE },
{ "moved", PLR_MOVED, FALSE },
{ "no-emote", PLR_NO_EMOTE, TRUE },
{ "no-tell", PLR_NO_TELL, TRUE },
{ "nolag", PLR_NO_LAG, TRUE },
{ "nosave", PLR_NOSAVE, FALSE },
{ "outlaw", PLR_OUTLAW, TRUE },
{ "prompt", PLR_PROMPT, TRUE },
{ "silence", PLR_SILENCE, TRUE },
{ "telnetga", PLR_TELNET_GA, TRUE },
{ "vt100", PLR_VT100, TRUE },
{ "wizbit", PLR_WIZBIT, TRUE },
{ "wizinvis", PLR_WIZINVIS, TRUE },
{ "", 0, 0 }
};
const struct flag_type affect_flags[] =
{
{ "blind", AFF_BLIND, TRUE },
{ "invisible", AFF_INVISIBLE, TRUE },
{ "detect-evil", AFF_DETECT_EVIL, TRUE },
{ "detect-invis", AFF_DETECT_INVIS, TRUE },
{ "detect-magic", AFF_DETECT_MAGIC, TRUE },
{ "detect-hidden", AFF_DETECT_HIDDEN, TRUE },
{ "hold", AFF_HOLD, TRUE },
{ "sanctuary", AFF_SANCTUARY, TRUE },
{ "faerie-fire", AFF_FAERIE_FIRE, TRUE },
{ "infrared", AFF_INFRARED, TRUE },
{ "mind-mist", AFF_MIND_MIST, TRUE },
{ "flying", AFF_FLYING, TRUE },
{ "plague", AFF_PLAGUE, TRUE },
{ "poison", AFF_POISON, TRUE },
{ "protect", AFF_PROTECT, TRUE },
{ "sneak", AFF_SNEAK, TRUE },
{ "hide", AFF_HIDE, TRUE },
{ "sleep", AFF_SLEEP, TRUE },
{ "charm", AFF_CHARM, TRUE },
{ "pass-door", AFF_PASS_DOOR, TRUE },
{ "bleeding", AFF_BLEEDING, TRUE },
{ "mute", AFF_MUTE, TRUE },
{ "vamp-bite", AFF_VAMP_BITE, TRUE },
{ "ghoul", AFF_GHOUL, TRUE },
{ "flaming", AFF_ATTACKSHIELD, TRUE },
{ "haste", AFF_HASTE, TRUE },
{ "fast-talk", AFF_FAST_TALK, TRUE },
{ "warp-flesh", AFF_WARP_FLESH, TRUE },
{ "breathing", AFF_BREATHING, TRUE },
{ "aura-sight", AFF_AURA_SIGHT, TRUE },
{ "polymorph", AFF_POLYMORPH, TRUE },
{ "berserk", AFF_BERSERK, TRUE },
{ "taunt", AFF_TAUNT, TRUE },
{ "never-miss", AFF_NEVERMISS, TRUE },
{ "magic-hands", AFF_MAGICHANDS, TRUE },
{ "darkness", AFF_DARKNESS, TRUE },
{ "poison-resist", AFF_POISONRESIST, TRUE },
{ "confusion", AFF_CONFUSION, TRUE },
{ "dead", AFF_DEAD, TRUE },
{ "calm", AFF_CALM, TRUE },
{ "sense-life", AFF_SENSE_LIFE, TRUE },
{ "", 0, 0 }
};
/*
* Used when adding an affect to tell where it goes.
* See addaffect and delaffect in act_olc.c
*/
const struct flag_type apply_flags[] =
{
{ "none", APPLY_NONE, TRUE },
{ "strength", APPLY_STR, TRUE },
{ "dexterity", APPLY_DEX, TRUE },
{ "intelligence", APPLY_INT, TRUE },
{ "wisdom", APPLY_WIS, TRUE },
{ "constitution", APPLY_CON, TRUE },
{ "sex", APPLY_SEX, TRUE },
{ "class", APPLY_CLASS, TRUE },
{ "level", APPLY_LEVEL, TRUE },
{ "age", APPLY_AGE, TRUE },
{ "height", APPLY_HEIGHT, TRUE },
{ "weight", APPLY_WEIGHT, TRUE },
{ "hp", APPLY_HIT, TRUE },
{ "move", APPLY_MOVE, TRUE },
{ "gold", APPLY_GOLD, TRUE },
{ "experience", APPLY_EXP, TRUE },
{ "ac", APPLY_AC, TRUE },
{ "hitroll", APPLY_HITROLL, TRUE },
{ "damroll", APPLY_DAMROLL, TRUE },
{ "race", APPLY_RACE, TRUE },
{ "resilience", APPLY_RESILIENCE, TRUE },
{ "appearance", APPLY_APPEARANCE, TRUE },
{ "body-temp", APPLY_BODY_TEMP, TRUE },
{ "body-part", APPLY_BODY_PART, TRUE },
{ "speed", APPLY_SPEED, TRUE },
{ "size", APPLY_SIZE, TRUE },
{ "air", APPLY_AIR, TRUE },
{ "earth", APPLY_EARTH, TRUE },
{ "fire", APPLY_FIRE, TRUE },
{ "spirit", APPLY_SPIRIT, TRUE },
{ "water", APPLY_WATER, TRUE },
{ "mana-air", APPLY_MANA_AIR, TRUE },
{ "mana-earth", APPLY_MANA_EARTH, TRUE },
{ "mana-fire", APPLY_MANA_FIRE, TRUE },
{ "mana-spirit", APPLY_MANA_SPIRIT, TRUE },
{ "mana-water", APPLY_MANA_WATER, TRUE },
{ "magic-resist", APPLY_MAGIC_RESIST, TRUE },
{ "", 0, 0 }
};
const struct flag_type apply_name_flags[] =
{
{ "none", APPLY_NONE, TRUE },
{ "strength", APPLY_STR, TRUE },
{ "dexterity", APPLY_DEX, TRUE },
{ "intelligence", APPLY_INT, TRUE },
{ "wisdom", APPLY_WIS, TRUE },
{ "constitution", APPLY_CON, TRUE },
{ "sex", APPLY_SEX, TRUE },
{ "class", APPLY_CLASS, TRUE },
{ "level", APPLY_LEVEL, TRUE },
{ "age", APPLY_AGE, TRUE },
{ "height", APPLY_HEIGHT, TRUE },
{ "weight", APPLY_WEIGHT, TRUE },
{ "hp", APPLY_HIT, TRUE },
{ "move", APPLY_MOVE, TRUE },
{ "gold", APPLY_GOLD, TRUE },
{ "experience", APPLY_EXP, TRUE },
{ "armour class", APPLY_AC, TRUE },
{ "attack roll", APPLY_HITROLL, TRUE },
{ "damage roll", APPLY_DAMROLL, TRUE },
{ "air magic", APPLY_AIR, TRUE },
{ "earth magic", APPLY_EARTH, TRUE },
{ "fire magic", APPLY_FIRE, TRUE },
{ "spirit magic", APPLY_SPIRIT, TRUE },
{ "water magic", APPLY_WATER, TRUE },
{ "air mana", APPLY_MANA_AIR, TRUE },
{ "earth mana", APPLY_MANA_EARTH, TRUE },
{ "fire mana", APPLY_MANA_FIRE, TRUE },
{ "spirit mana", APPLY_MANA_SPIRIT, TRUE },
{ "water mana", APPLY_MANA_WATER, TRUE },
{ "magic resistance", APPLY_MAGIC_RESIST, TRUE },
{ "race", APPLY_RACE, TRUE },
{ "resilience", APPLY_RESILIENCE, TRUE },
{ "appearance", APPLY_APPEARANCE, TRUE },
{ "body temperature", APPLY_BODY_TEMP, TRUE },
{ "body parts", APPLY_BODY_PART, TRUE },
{ "speed", APPLY_SPEED, TRUE },
{ "size", APPLY_SIZE, TRUE },
{ "", 0, 0 }
};
/*
* What is seen.
*/
const struct flag_type wear_loc_strings[] =
{
{ "in the inventory", WEAR_NONE, TRUE },
{ "on the head", WEAR_HEAD, TRUE },
{ "on the horns", WEAR_HORNS, TRUE },
{ "on the nose", WEAR_NOSE, TRUE },
{ "on the left ear", WEAR_EAR_L, TRUE },
{ "on the right ear", WEAR_EAR_R, TRUE },
{ "over the face", WEAR_FACE, TRUE },
{ "around the neck (1)", WEAR_NECK_1, TRUE },
{ "around the neck (2)", WEAR_NECK_2, TRUE },
{ "about the shoulders", WEAR_SHOULDERS, TRUE },
{ "on the wings", WEAR_WINGS, TRUE },
{ "floating above left shoulder", WEAR_FLOAT_L, TRUE },
{ "floating above right shoulder", WEAR_FLOAT_R, TRUE },
{ "on the arms", WEAR_ARMS, TRUE },
{ "on the left wrist", WEAR_WRIST_L, TRUE },
{ "on the right wrist", WEAR_WRIST_R, TRUE },
{ "on the hands", WEAR_HANDS, TRUE },
{ "on the left finger", WEAR_FINGER_L, TRUE },
{ "on the right finger", WEAR_FINGER_R, TRUE },
{ "wielded in right hand", WEAR_WIELD_R, TRUE },
{ "held in the left hand", WEAR_HOLD_L, TRUE },
{ "held in the right hand", WEAR_HOLD_R, TRUE },
{ "as a shield", WEAR_SHIELD, TRUE },
{ "wielded in the left hand", WEAR_WIELD_L, TRUE },
{ "wielded two-handed", WEAR_WIELD_DOUBLE, TRUE },
{ "on the body", WEAR_BODY, TRUE },
{ "around the waist", WEAR_WAIST, TRUE },
{ "on the left ankle", WEAR_ANKLE_L, TRUE },
{ "on the right ankle", WEAR_ANKLE_R, TRUE },
{ "on the legs", WEAR_LEGS, TRUE },
{ "on the feet", WEAR_FEET, TRUE },
{ "juggled over the head", WEAR_JUGGLED, TRUE },
{ "", 0 }
};
/*
* What is typed.
* Neck2 should not be settable for loaded mobiles, bah -- Sym
*/
const struct flag_type wear_loc_flags[] =
{
{ "none", WEAR_NONE, TRUE },
{ "head", WEAR_HEAD, TRUE },
{ "horns", WEAR_HORNS, TRUE },
{ "nose", WEAR_NOSE, TRUE },
{ "lear", WEAR_EAR_L, TRUE },
{ "rear", WEAR_EAR_R, TRUE },
{ "face", WEAR_FACE, TRUE },
{ "neck1", WEAR_NECK_1, TRUE },
{ "neck2", WEAR_NECK_2, TRUE },
{ "shoulders", WEAR_SHOULDERS, TRUE },
{ "wings", WEAR_WINGS, TRUE },
{ "rfloat", WEAR_FLOAT_R, TRUE },
{ "lfloat", WEAR_FLOAT_L, TRUE },
{ "arms", WEAR_ARMS, TRUE },
{ "lwrist", WEAR_WRIST_L, TRUE },
{ "rwrist", WEAR_WRIST_R, TRUE },
{ "hands", WEAR_HANDS, TRUE },
{ "lfinger", WEAR_FINGER_L, TRUE },
{ "rfinger", WEAR_FINGER_R, TRUE },
{ "rwielded", WEAR_WIELD_R, TRUE },
{ "lwielded", WEAR_WIELD_L, TRUE },
{ "two-handed", WEAR_WIELD_DOUBLE, TRUE },
{ "lhold", WEAR_HOLD_L, TRUE },
{ "rhold", WEAR_HOLD_R, TRUE },
{ "shield", WEAR_SHIELD, TRUE },
{ "body", WEAR_BODY, TRUE },
{ "waist", WEAR_WAIST, TRUE },
{ "legs", WEAR_LEGS, TRUE },
{ "lankle", WEAR_ANKLE_L, TRUE },
{ "rankle", WEAR_ANKLE_R, TRUE },
{ "feet", WEAR_FEET, TRUE },
{ "juggled", WEAR_JUGGLED, FALSE },
{ "", 0, 0 }
};
const struct flag_type weapon_flags[] =
{
{ "hit", 0, TRUE },
{ "slice", 1, TRUE },
{ "stab", 2, TRUE },
{ "slash", 3, TRUE },
{ "whip", 4, TRUE },
{ "claw", 5, TRUE },
{ "blast", 6, TRUE },
{ "pound", 7, TRUE },
{ "crush", 8, TRUE },
{ "rip", 9, TRUE },
{ "bite", 10, TRUE },
{ "pierce", 11, TRUE },
{ "suction", 12, TRUE },
{ "chop", 13, TRUE },
{ "rake", 14, TRUE },
{ "bludgeon", 15, TRUE },
{ "sting", 16, TRUE },
{ "maul", 17, TRUE },
{ "", 0, 0 }
};
const struct flag_type container_flags[] =
{
{ "closeable", CONT_CLOSEABLE, TRUE },
{ "pickproof", CONT_PICKPROOF, TRUE },
{ "hardpick", CONT_HARDPICK, TRUE },
{ "closed", CONT_CLOSED, TRUE },
{ "locked", CONT_LOCKED, TRUE },
{ "trapped", CONT_TRAPPED, TRUE },
{ "weightless", CONT_WEIGHTLESS,TRUE },
{ "hungry", CONT_HUNGRY, TRUE },
{ "holey", CONT_HOLEY, TRUE },
{ "eat-key", CONT_EAT_KEY, TRUE },
{ "", 0, 0 }
};
const struct flag_type furniture_flags[] =
{
{ "stand-on", FURN_STAND_ON, TRUE },
{ "stand-in", FURN_STAND_IN, TRUE },
{ "stand-at", FURN_STAND_AT, TRUE },
{ "rest-on", FURN_REST_ON, TRUE },
{ "rest-in", FURN_REST_IN, TRUE },
{ "rest-at", FURN_REST_AT, TRUE },
{ "sleep-on", FURN_SLEEP_ON, TRUE },
{ "sleep-in", FURN_SLEEP_IN, TRUE },
{ "sleep-at", FURN_SLEEP_AT, TRUE },
{ "", 0, 0 }
};
const struct flag_type liquid_flags[] =
{
{ "water", 0, TRUE },
{ "beer", 1, TRUE },
{ "wine", 2, TRUE },
{ "ale", 3, TRUE },
{ "dark-ale", 4, TRUE },
{ "whisky", 5, TRUE },
{ "lemonade", 6, TRUE },
{ "firebreather", 7, TRUE },
{ "local-specialty", 8, TRUE },
{ "slime-mold-juice", 9, TRUE },
{ "milk", 10, TRUE },
{ "tea", 11, TRUE },
{ "coffee", 12, TRUE },
{ "blood", 13, TRUE },
{ "salt-water", 14, TRUE },
{ "cola", 15, TRUE },
{ "urine", 16, TRUE },
{ "fruit-juice", 17, TRUE },
{ "turpentine", 18, TRUE },
{ "tabasco-sauce", 19, TRUE },
{ "absinth", 20, TRUE },
{ "brandy", 21, TRUE },
{ "schnapps", 22, TRUE },
{ "orange juice", 23, TRUE },
{ "sherry", 24, TRUE },
{ "rum", 25, TRUE },
{ "port", 26, TRUE },
{ "vodka", 27, TRUE },
{ "white wine", 28, TRUE },
{ "root beer", 29, TRUE },
{ "champagne", 30, TRUE },
{ "", 0, 0 }
};
const struct flag_type body_part_flags[] =
{
{ "torso", BODY_PART_TORSO, TRUE },
{ "head", BODY_PART_HEAD, TRUE },
{ "eyes", BODY_PART_EYES, TRUE },
{ "nose", BODY_PART_NOSE, TRUE },
{ "left-ear", BODY_PART_EAR_L, TRUE },
{ "right-ear", BODY_PART_EAR_R, TRUE },
{ "left-arm", BODY_PART_ARM_L, TRUE },
{ "right-arm", BODY_PART_ARM_R, TRUE },
{ "left-hand", BODY_PART_HAND_L, TRUE },
{ "right-hand", BODY_PART_HAND_R, TRUE },
{ "left-fingers", BODY_PART_FINGERS_L, TRUE },
{ "right-fingers", BODY_PART_FINGERS_R, TRUE },
{ "left-leg", BODY_PART_LEG_L, TRUE },
{ "right-leg", BODY_PART_LEG_R, TRUE },
{ "left-foot", BODY_PART_FOOT_L, TRUE },
{ "right-foot", BODY_PART_FOOT_R, TRUE },
{ "tail", BODY_PART_TAIL, TRUE },
{ "horns", BODY_PART_HORNS, TRUE },
{ "wings", BODY_PART_WINGS, TRUE },
{ "lungs", BODY_PART_LUNGS, TRUE },
{ "gills", BODY_PART_GILLS, TRUE },
{ "", 0, 0 }
};
const struct flag_type mud_prog_flags[] =
{
{ "global_prog", GLOBAL_PROG, TRUE },
{ "sub_prog", SUB_PROG, TRUE },
{ "act_prog", ACT_PROG, TRUE },
{ "speech_prog", SPEECH_PROG, TRUE },
{ "rand_prog", RAND_PROG, TRUE },
{ "greet_prog", GREET_PROG, TRUE },
{ "all_greet_prog", ALL_GREET_PROG, TRUE },
{ "leave_prog", LEAVE_PROG, TRUE },
{ "time_prog", TIME_PROG, TRUE },
{ "repop_prog", REPOP_PROG, TRUE },
{ "look_prog", LOOK_PROG, TRUE },
{ "command_prog", COMMAND_PROG, TRUE },
{ "fight_prog", FIGHT_PROG, TRUE },
{ "hitprcnt_prog", HITPRCNT_PROG, TRUE },
{ "death_prog", DEATH_PROG, TRUE },
{ "entry_prog", ENTRY_PROG, TRUE },
{ "give_prog", GIVE_PROG, TRUE },
{ "bribe_prog", BRIBE_PROG, TRUE },
{ "attack_prog", ATTACK_PROG, TRUE },
{ "delay_prog", DELAY_PROG, TRUE },
{ "wear_prog", WEAR_PROG, TRUE },
{ "remove_prog", REMOVE_PROG, TRUE },
{ "sac_prog", SAC_PROG, TRUE },
{ "examine_prog", EXAMINE_PROG, TRUE },
{ "use_prog", USE_PROG, TRUE },
{ "get_prog", GET_PROG, TRUE },
{ "drop_prog", DROP_PROG, TRUE },
{ "damage_prog", DAMAGE_PROG, TRUE },
{ "repair_prog", REPAIR_PROG, TRUE },
{ "open_prog", OPEN_PROG, TRUE },
{ "close_prog", CLOSE_PROG, TRUE },
{ "loot_prog", LOOT_PROG, TRUE },
{ "putin_prog", PUTIN_PROG, TRUE },
{ "sleep_prog", SLEEP_PROG, TRUE },
{ "rest_prog", REST_PROG, TRUE },
{ "", 0, 0 }
};
const struct flag_type material_flags[] =
{
{ "eternium", 0, TRUE },
{ "adamantite", 5, TRUE },
{ "mithril", 10, TRUE },
{ "diamond", 20, TRUE },
{ "steel", 50, TRUE },
{ "energy", 51, TRUE },
{ "flame", 52, TRUE },
{ "enamel", 55, TRUE },
{ "crystal", 60, TRUE },
{ "dragonskin", 70, TRUE },
{ "marble", 80, TRUE },
{ "corundum", 100, TRUE },
{ "quartz", 115, TRUE },
{ "iron", 120, TRUE },
{ "lodestone", 125, TRUE },
{ "granite", 130, TRUE },
{ "obsidian", 135, TRUE },
{ "silver", 140, TRUE },
{ "air", 150, TRUE },
{ "water", 151, TRUE },
{ "copper", 160, TRUE },
{ "electrum", 165, TRUE },
{ "brass", 170, TRUE },
{ "sandstone", 172, TRUE },
{ "pewter", 175, TRUE },
{ "lead", 180, TRUE },
{ "ebony", 200, TRUE },
{ "bronze", 220, TRUE },
{ "platinum", 235, TRUE },
{ "gold", 240, TRUE },
{ "aluminium", 250, TRUE },
{ "flint", 255, TRUE },
{ "tin", 260, TRUE },
{ "wire", 262, TRUE },
{ "laen", 265, TRUE },
{ "rubber", 270, TRUE },
{ "shell", 275, TRUE },
{ "horn", 285, TRUE },
{ "carbon", 290, TRUE },
{ "ivory", 300, TRUE },
{ "pottery", 305, TRUE },
{ "hard leather", 310, TRUE },
{ "bone", 320, TRUE },
{ "leather", 330, TRUE },
{ "bamboo", 350, TRUE },
{ "wood", 360, TRUE },
{ "canvas", 370, TRUE },
{ "kid leather", 380, TRUE },
{ "snakeskin", 385, TRUE },
{ "fur", 400, TRUE },
{ "ice", 410, TRUE },
{ "plastic", 420, TRUE },
{ "hemp", 435, TRUE },
{ "clay", 440, TRUE },
{ "coal", 445, TRUE },
{ "cork", 450, TRUE },
{ "linen", 455, TRUE },
{ "earth", 457, TRUE },
{ "gut", 460, TRUE },
{ "wool", 470, TRUE },
{ "cotton", 475, TRUE },
{ "velvet", 485, TRUE },
{ "satin", 490, TRUE },
{ "silk", 510, TRUE },
{ "lace", 540, TRUE },
{ "organic", 560, TRUE },
{ "feathers", 590, TRUE },
{ "sponge", 640, TRUE },
{ "glass", 750, TRUE },
{ "porcelain", 820, TRUE },
{ "wax", 950, TRUE },
{ "parchment", 980, TRUE },
{ "paper", 1000, TRUE },
{ "vellum", 1010, TRUE },
{ "slime", 2000, TRUE },
{ "mucus", 3000, TRUE },
{ "", 0, 0 }
};
const struct flag_type class_flags[] =
{
{ "none", CLASS_NONE, TRUE },
{ "Mage", CLASS_MAGE, TRUE },
{ "Cleric", CLASS_CLERIC, TRUE },
{ "Thief", CLASS_THIEF, TRUE },
{ "Warrior", CLASS_WARRIOR, TRUE },
{ "Martial Artist", CLASS_MARTIAL_ARTIST, TRUE },
{ "Sorceror", CLASS_SORCEROR, TRUE },
{ "Warlock", CLASS_WARLOCK, TRUE },
{ "Illusionist", CLASS_ILLUSIONIST, TRUE },
{ "Ranger", CLASS_RANGER, TRUE },
{ "Psionicist", CLASS_PSIONICIST, TRUE },
{ "Bishop", CLASS_BISHOP, TRUE },
{ "Jester", CLASS_JESTER, TRUE },
{ "Paladin", CLASS_PALADIN, TRUE },
{ "Monk", CLASS_MONK, TRUE },
{ "Assassin", CLASS_ASSASSIN, TRUE },
{ "Crusader", CLASS_CRUSADER, TRUE },
{ "Ninja", CLASS_NINJA, TRUE },
{ "Knight", CLASS_KNIGHT, TRUE },
{ "Samurai", CLASS_SAMURAI, TRUE },
{ "Mystic", CLASS_MYSTIC, TRUE },
{ "Builder", CLASS_BUILDER, TRUE },
{ "Angel", CLASS_ANGEL, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type direction_flags[] = {
{ "north", 1<<DIR_NORTH, TRUE },
{ "east", 1<<DIR_EAST, TRUE },
{ "south", 1<<DIR_SOUTH, TRUE },
{ "west", 1<<DIR_WEST, TRUE },
{ "up", 1<<DIR_UP, TRUE },
{ "down", 1<<DIR_DOWN, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type exit_direction_flags[] = {
{ "north", DIR_NORTH, TRUE },
{ "east", DIR_EAST, TRUE },
{ "south", DIR_SOUTH, TRUE },
{ "west", DIR_WEST, TRUE },
{ "up", DIR_UP, TRUE },
{ "down", DIR_DOWN, TRUE },
{ "n", DIR_NORTH, TRUE },
{ "e", DIR_EAST, TRUE },
{ "s", DIR_SOUTH, TRUE },
{ "w", DIR_WEST, TRUE },
{ "u", DIR_UP, TRUE },
{ "d", DIR_DOWN, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type race_perm_flags[] = {
{ "NPC_Only", RACE_NPC_ONLY, TRUE },
{ "No_Breathing", RACE_BREATHING, TRUE },
{ "Passdoor", RACE_PASSDOOR, TRUE },
{ "Infravision", RACE_INFRAVISION, TRUE },
{ "Detect_Align", RACE_DETECT_ALIGN, TRUE },
{ "Detect_Invis", RACE_DETECT_INVIS, TRUE },
{ "Detect_Hidden", RACE_DETECT_HIDDEN, TRUE },
{ "Protection", RACE_PROTECTION, TRUE },
{ "Sanctuary", RACE_SANCT, TRUE },
{ "No_Wield_Weapon", RACE_NO_WEAPON_WIELD, TRUE },
{ "Mute", RACE_MUTE, TRUE },
{ "No-Sun", RACE_NO_SUN, TRUE },
{ "Dual_Wield", RACE_DUAL_WIELD, TRUE },
{ "No-Poison", RACE_NO_POISON, TRUE },
{ "Dark_Sight", RACE_DARK_SIGHT, TRUE },
{ "Swim", RACE_SWIM, TRUE },
{ "Undead", RACE_UNDEAD, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type language_flags [] = {
{ "Common", LANG_COMMON, TRUE },
{ "Faerie", LANG_FAERIE, TRUE },
{ "Dwarven", LANG_DWARVEN, TRUE },
{ "Orcish", LANG_ORCISH, TRUE },
{ "Elven", LANG_ELVEN, TRUE },
{ "Varthan", LANG_VARTHAN, TRUE },
{ "Astral", LANG_ASTRAL, TRUE },
{ "Elemental", LANG_ELEMENTAL, TRUE },
{ "Gibberish", LANG_GIBBERISH, TRUE },
{ "Bad", LANG_BAD, TRUE },
{ "Archaic", LANG_ARCHAIC, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type clan_type_flags [] = {
{ "clan", CLAN_NORMAL, TRUE },
{ "order", CLAN_ORDER, TRUE },
{ "guild", CLAN_GUILD, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type sac_event_flags [] = {
{ "gold", (1<<SAC_EVENT_GOLD), TRUE },
{ "bless", (1<<SAC_EVENT_BLESS), TRUE },
{ "hex", (1<<SAC_EVENT_CURSE), TRUE },
{ "armour", (1<<SAC_EVENT_ARMOUR), TRUE },
{ "heal", (1<<SAC_EVENT_HEAL), TRUE },
{ "dispel-evil", (1<<SAC_EVENT_DISPEL_EVIL), TRUE },
{ "blind", (1<<SAC_EVENT_BLIND), TRUE },
{ "bamf", (1<<SAC_EVENT_BAMF), TRUE },
{ "mana", (1<<SAC_EVENT_MANA), TRUE },
{ "food", (1<<SAC_EVENT_FOOD), TRUE },
{ "water", (1<<SAC_EVENT_WATER), TRUE },
{ "drunk", (1<<SAC_EVENT_DRUNK), TRUE },
{ "raise", (1<<SAC_EVENT_RAISE), TRUE },
{ "plague", (1<<SAC_EVENT_PLAGUE), TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type sysinfo_flags [] = {
{ "reboot", SYSINFO_REBOOT, TRUE },
{ "logall", SYSINFO_LOGALL, TRUE },
{ "nofight", SYSINFO_NOFIGHT, FALSE },
{ "wizlock", SYSINFO_WIZLOCK, TRUE },
{ "mobtrigger", SYSINFO_ACT_TRIGGER, FALSE },
{ "verbose", SYSINFO_VERBOSE_LOG, TRUE },
{ "saveall", SYSINFO_SAVEALL, TRUE },
{ "ispell", SYSINFO_ISPELL, TRUE },
{ "fortunes", SYSINFO_FORTUNES, TRUE },
{ "HolyWar", SYSINFO_HOLYWAR, TRUE },
{ "nocpulimit", SYSINFO_NOCPULIMIT, TRUE },
{ "lognohelp", SYSINFO_LOGNOHELP, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type channel_flags [] = {
{ "master", CHANNEL_DEAF, TRUE },
{ "auction", CHANNEL_AUCTION, TRUE },
{ "chat", CHANNEL_CHAT, TRUE },
{ "immtalk", CHANNEL_IMMTALK, TRUE },
{ "music", CHANNEL_MUSIC, TRUE },
{ "question", CHANNEL_QUESTION, TRUE },
{ "shout", CHANNEL_SHOUT, TRUE },
{ "yell", CHANNEL_YELL, TRUE },
{ "info", CHANNEL_INFO, TRUE },
{ "senior", CHANNEL_SENIORTALK, TRUE },
{ "gratz", CHANNEL_GRATZ, TRUE },
{ "clan", CHANNEL_CLANTALK, TRUE },
{ "wiznet", WIZ_ON, TRUE },
{ "log", WIZ_LOG, TRUE },
{ "logins", WIZ_LOGINS, TRUE },
{ "deaths", WIZ_DEATHS, TRUE },
{ "levels", WIZ_LEVELS, TRUE },
{ "ticks", WIZ_TICKS, TRUE },
{ "commands", WIZ_COMMANDS, TRUE },
{ "misc", WIZ_MISC, TRUE },
{ "create", WIZ_CREATE, TRUE },
{ "wizclan", WIZ_CLAN, TRUE },
{ "debug", WIZ_DEBUG, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type magic_flags [] = {
{ "air", MAGIC_AIR, TRUE },
{ "earth", MAGIC_EARTH, TRUE },
{ "fire", MAGIC_FIRE, TRUE },
{ "spirit", MAGIC_SPIRIT, TRUE },
{ "water", MAGIC_WATER, TRUE },
{ "generic", MAGIC_GENERIC, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type event_extra_flags [] = {
{ "loading", EVENT_LOADING, },
{ "temp", EVENT_TEMPORARY, TRUE },
{ "death-remove", EVENT_DEATH_REMOVE, TRUE },
{ "no-quit", EVENT_NO_QUIT, TRUE },
{ "stackable", EVENT_STACKABLE, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type position_flags [] = {
{ "dead", POS_DEAD, TRUE },
{ "mortallly wounded", POS_MORTAL, TRUE },
{ "incapacitated", POS_INCAP, TRUE },
{ "stunned", POS_STUNNED, TRUE },
{ "sleeping", POS_SLEEPING, TRUE },
{ "meditating", POS_MEDITATING, TRUE },
{ "resting", POS_RESTING, TRUE },
{ "sitting", POS_SITTING, TRUE },
{ "smashed", POS_SMASHED, TRUE },
{ "getting up", POS_GETTING_UP, TRUE },
{ "fighting", POS_FIGHTING, FALSE },
{ "standing", POS_STANDING, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type skill_type_flags [] = {
{ "magic", SKILL_TYPE_MAGIC, TRUE },
{ "fire", SKILL_TYPE_FIRE, TRUE },
{ "ice", SKILL_TYPE_ICE, TRUE },
{ "no-resil", SKILL_TYPE_NO_RESIL, TRUE },
{ "mob-action", SKILL_TYPE_ACTION, TRUE },
{ "enchant", SKILL_TYPE_ENCHANTMENT, TRUE },
{ "weapon", SKILL_TYPE_WEAPONSTRIKE, TRUE },
{ "dodgeable", SKILL_TYPE_DODGEABLE, TRUE },
{ "", NO_FLAG, TRUE }
};
const struct flag_type mor_type_flags [] = {
{ "mob", MPROG_GLOBAL_MOB, TRUE },
{ "mobile", MPROG_GLOBAL_MOB, TRUE },
{ "object", MPROG_GLOBAL_OBJ, TRUE },
{ "room", MPROG_GLOBAL_ROOM, TRUE },
{ "", NO_FLAG, TRUE }
};
