glbdef.h

// Automagically generated by enummaker.exe.
// DO NOT EDIT THIS FILE (Yes, I mean you!)
#ifndef __glbdef_h__
#define __glbdef_h__

#include "mygba.h"
#include "rand.h"

// Definitions for TALK
enum TALK_NAMES
{
    TALK_NONE,
    TALK_ELDER,
    NUM_TALKS
};

// Macros for TALK
#define FOREACH_TALK(x) \
    for ((x) = (TALK_NAMES) 0; \
         (x) < NUM_TALKS; \
         (x) = (TALK_NAMES) ((int)(x)+1))

// Definitions for BRANCH
enum BRANCH_NAMES
{
    BRANCH_NONE,
    BRANCH_MAIN,
    BRANCH_TRIDUDE,
    NUM_BRANCHS
};

// Macros for BRANCH
#define FOREACH_BRANCH(x) \
    for ((x) = (BRANCH_NAMES) 0; \
         (x) < NUM_BRANCHS; \
         (x) = (BRANCH_NAMES) ((int)(x)+1))

struct BRANCH_DEF
{
    const char *welcome;
    u8 symbol;
};

extern const BRANCH_DEF glb_branchdefs[];

// Definitions for SIGNPOST_iPOWDER
enum SIGNPOST_iPOWDER_NAMES
{
    SIGNPOST_iPOWDER_NONE,
    SIGNPOST_iPOWDER_LOOK,
    SIGNPOST_iPOWDER_WELCOME,
    SIGNPOST_iPOWDER_MINIMAP,
    SIGNPOST_iPOWDER_BOULDER,
    SIGNPOST_iPOWDER_MELEE,
    SIGNPOST_iPOWDER_INVENTORY,
    SIGNPOST_iPOWDER_PICKUP,
    SIGNPOST_iPOWDER_DOOR,
    SIGNPOST_iPOWDER_USE,
    SIGNPOST_iPOWDER_WATER,
    SIGNPOST_iPOWDER_SPELLS,
    SIGNPOST_iPOWDER_SEARCH,
    SIGNPOST_iPOWDER_DIP,
    SIGNPOST_iPOWDER_QUIVER,
    SIGNPOST_iPOWDER_DARK,
    SIGNPOST_iPOWDER_DRAGONS,
    SIGNPOST_iPOWDER_WONTUTORIAL,
    SIGNPOST_iPOWDER_KIWI,
    SIGNPOST_iPOWDER_WON,
    NUM_SIGNPOST_iPOWDERS
};

// Macros for SIGNPOST_iPOWDER
#define FOREACH_SIGNPOST_iPOWDER(x) \
    for ((x) = (SIGNPOST_iPOWDER_NAMES) 0; \
         (x) < NUM_SIGNPOST_iPOWDERS; \
         (x) = (SIGNPOST_iPOWDER_NAMES) ((int)(x)+1))

// Definitions for SIGNPOST_SDL
enum SIGNPOST_SDL_NAMES
{
    SIGNPOST_SDL_NONE,
    SIGNPOST_SDL_LOOK,
    SIGNPOST_SDL_WELCOME,
    SIGNPOST_SDL_MINIMAP,
    SIGNPOST_SDL_BOULDER,
    SIGNPOST_SDL_MELEE,
    SIGNPOST_SDL_INVENTORY,
    SIGNPOST_SDL_PICKUP,
    SIGNPOST_SDL_DOOR,
    SIGNPOST_SDL_USE,
    SIGNPOST_SDL_WATER,
    SIGNPOST_SDL_SPELLS,
    SIGNPOST_SDL_SEARCH,
    SIGNPOST_SDL_DIP,
    SIGNPOST_SDL_QUIVER,
    SIGNPOST_SDL_DARK,
    SIGNPOST_SDL_DRAGONS,
    SIGNPOST_SDL_WONTUTORIAL,
    SIGNPOST_SDL_KIWI,
    SIGNPOST_SDL_WON,
    NUM_SIGNPOST_SDLS
};

// Macros for SIGNPOST_SDL
#define FOREACH_SIGNPOST_SDL(x) \
    for ((x) = (SIGNPOST_SDL_NAMES) 0; \
         (x) < NUM_SIGNPOST_SDLS; \
         (x) = (SIGNPOST_SDL_NAMES) ((int)(x)+1))

// Definitions for SIGNPOST_GBA
enum SIGNPOST_GBA_NAMES
{
    SIGNPOST_GBA_NONE,
    SIGNPOST_GBA_LOOK,
    SIGNPOST_GBA_WELCOME,
    SIGNPOST_GBA_MINIMAP,
    SIGNPOST_GBA_BOULDER,
    SIGNPOST_GBA_MELEE,
    SIGNPOST_GBA_INVENTORY,
    SIGNPOST_GBA_PICKUP,
    SIGNPOST_GBA_DOOR,
    SIGNPOST_GBA_USE,
    SIGNPOST_GBA_WATER,
    SIGNPOST_GBA_SPELLS,
    SIGNPOST_GBA_SEARCH,
    SIGNPOST_GBA_DIP,
    SIGNPOST_GBA_QUIVER,
    SIGNPOST_GBA_DARK,
    SIGNPOST_GBA_DRAGONS,
    SIGNPOST_GBA_WONTUTORIAL,
    SIGNPOST_GBA_KIWI,
    SIGNPOST_GBA_WON,
    NUM_SIGNPOST_GBAS
};

// Macros for SIGNPOST_GBA
#define FOREACH_SIGNPOST_GBA(x) \
    for ((x) = (SIGNPOST_GBA_NAMES) 0; \
         (x) < NUM_SIGNPOST_GBAS; \
         (x) = (SIGNPOST_GBA_NAMES) ((int)(x)+1))

// Definitions for SIGNPOST
enum SIGNPOST_NAMES
{
    SIGNPOST_NONE,
    SIGNPOST_LOOK,
    SIGNPOST_WELCOME,
    SIGNPOST_MINIMAP,
    SIGNPOST_BOULDER,
    SIGNPOST_MELEE,
    SIGNPOST_INVENTORY,
    SIGNPOST_PICKUP,
    SIGNPOST_DOOR,
    SIGNPOST_USE,
    SIGNPOST_WATER,
    SIGNPOST_SPELLS,
    SIGNPOST_SEARCH,
    SIGNPOST_DIP,
    SIGNPOST_QUIVER,
    SIGNPOST_DARK,
    SIGNPOST_DRAGONS,
    SIGNPOST_WONTUTORIAL,
    SIGNPOST_KIWI,
    SIGNPOST_WON,
    NUM_SIGNPOSTS
};

// Macros for SIGNPOST
#define FOREACH_SIGNPOST(x) \
    for ((x) = (SIGNPOST_NAMES) 0; \
         (x) < NUM_SIGNPOSTS; \
         (x) = (SIGNPOST_NAMES) ((int)(x)+1))

// Definitions for SENSE
enum SENSE_NAMES
{
    SENSE_NONE,
    SENSE_SIGHT,
    SENSE_HEAR,
    SENSE_ESP,
    SENSE_WARN,
    NUM_SENSES
};

// Macros for SENSE
#define FOREACH_SENSE(x) \
    for ((x) = (SENSE_NAMES) 0; \
         (x) < NUM_SENSES; \
         (x) = (SENSE_NAMES) ((int)(x)+1))

// Definitions for MAGICDOOR
enum MAGICDOOR_NAMES
{
    MAGICDOOR_NOTENOUGHDOORS,
    MAGICDOOR_NOITEMS,
    MAGICDOOR_INSUFFICIENTITEMS,
    MAGICDOOR_SUCCESS,
    NUM_MAGICDOORS
};

// Macros for MAGICDOOR
#define FOREACH_MAGICDOOR(x) \
    for ((x) = (MAGICDOOR_NAMES) 0; \
         (x) < NUM_MAGICDOORS; \
         (x) = (MAGICDOOR_NAMES) ((int)(x)+1))

// Definitions for HELP
enum HELP_NAMES
{
    HELP_NONE,
    HELP_POWDER,
    HELP_KEYBOARD,
    HELP_GAMEBOY,
    HELP_STYLUS,
    HELP_TOUCH,
    HELP_STATUSLINE,
    HELP_SPELL,
    HELP_SKILL,
    HELP_GOD,
    HELP_DEATH,
    HELP_POWDER_LOCKED,
    NUM_HELPS
};

// Macros for HELP
#define FOREACH_HELP(x) \
    for ((x) = (HELP_NAMES) 0; \
         (x) < NUM_HELPS; \
         (x) = (HELP_NAMES) ((int)(x)+1))

struct HELP_DEF
{
    const char *menu;
};

extern const HELP_DEF glb_helpdefs[];

// Definitions for BOON
enum BOON_NAMES
{
    BOON_LICHFORM,
    BOON_SURROUNDATTACK,
    BOON_UNCURSE,
    BOON_HEAL,
    BOON_CURE,
    BOON_UNSTONE,
    BOON_SANCTIFY,
    BOON_ENCHANT_WEAPON,
    BOON_ENCHANT_ARMOUR,
    BOON_GRANT_SPELL,
    BOON_GIFT_WEAPON,
    BOON_GIFT_ARMOUR,
    BOON_GIFT_WAND,
    BOON_GIFT_SPELLBOOK,
    BOON_GIFT_STAFF,
    BOON_IDENTIFY,
    NUM_BOONS
};

// Macros for BOON
#define FOREACH_BOON(x) \
    for ((x) = (BOON_NAMES) 0; \
         (x) < NUM_BOONS; \
         (x) = (BOON_NAMES) ((int)(x)+1))

struct BOON_DEF
{
    u16 points;
    u8 gifttype;
    u8 isrescue;
    const char *god;
};

extern const BOON_DEF glb_boondefs[];

// Definitions for PUNISH
enum PUNISH_NAMES
{
    PUNISH_FLAMESTRIKE,
    PUNISH_SUMMON,
    PUNISH_CURSE_WORN,
    PUNISH_CURSE_ANY,
    PUNISH_DISENCHANT_WEAPON,
    PUNISH_DISENCHANT_ARMOUR,
    PUNISH_POISON,
    PUNISH_PARALYSE,
    PUNISH_SLEEP,
    PUNISH_MANADRAIN,
    PUNISH_POLY,
    PUNISH_POLYWEAPON,
    NUM_PUNISHS
};

// Macros for PUNISH
#define FOREACH_PUNISH(x) \
    for ((x) = (PUNISH_NAMES) 0; \
         (x) < NUM_PUNISHS; \
         (x) = (PUNISH_NAMES) ((int)(x)+1))

struct PUNISH_DEF
{
    u16 points;
    const char *god;
};

extern const PUNISH_DEF glb_punishdefs[];

// Definitions for GOD
enum GOD_NAMES
{
    GOD_AGNOSTIC,
    GOD_FIGHTER,
    GOD_WIZARD,
    GOD_ROGUE,
    GOD_NECRO,
    GOD_BARB,
    GOD_CLERIC,
    GOD_CULTIST,
    NUM_GODS
};

// Macros for GOD
#define FOREACH_GOD(x) \
    for ((x) = (GOD_NAMES) 0; \
         (x) < NUM_GODS; \
         (x) = (GOD_NAMES) ((int)(x)+1))

struct GOD_DEF
{
    const char *name;
    const char *classname;
    const char *whimofxom;
    u8 mental;
    u8 physical;
    u8 mob;
};

extern const GOD_DEF glb_goddefs[];

// Definitions for ACTION
enum ACTION_NAMES
{
    ACTION_NONE,
    ACTION_EQUIP,
    ACTION_DEQUIP,
    ACTION_DROP,
    ACTION_EAT,
    ACTION_BREATHE,
    ACTION_WALK,
    ACTION_MOVE,
    ACTION_RELEASE,
    ACTION_QUAFF,
    ACTION_READ,
    ACTION_FORGET,
    ACTION_FIRE,
    ACTION_QUIVER,
    ACTION_FAVORITE,
    ACTION_DIP,
    ACTION_OPEN,
    ACTION_CLOSE,
    ACTION_HISTORY,
    ACTION_LOCK,
    ACTION_CLIMB,
    ACTION_PICKUP,
    ACTION_SWAP,
    ACTION_SEARCH,
    ACTION_WAIT,
    ACTION_LOOK,
    ACTION_ZAP,
    ACTION_OPTIONS,
    ACTION_HELP,
    ACTION_USE,
    ACTION_JUMP,
    ACTION_THROW,
    ACTION_NAME,
    ACTION_COMMAND,
    ACTION_MINIMAP,
    ACTION_SORT,
    ACTION_SPLITSTACK,
    ACTION_PRAY,
    ACTION_EXAMINE,
    ACTION_SLEEP,
    ACTION_INVENTORY,
    ACTION_VERBLIST,
    ACTION_WISH,
    ACTION_SAFEWALK,
    ACTION_RUN,
    NUM_ACTIONS
};

// Macros for ACTION
#define FOREACH_ACTION(x) \
    for ((x) = (ACTION_NAMES) 0; \
         (x) < NUM_ACTIONS; \
         (x) = (ACTION_NAMES) ((int)(x)+1))

struct ACTION_DEF
{
    const char *name;
    const char *hint;
    u8 tile;
};

extern const ACTION_DEF glb_actiondefs[];

// Definitions for OPTION
enum OPTION_NAMES
{
    OPTION_NONE,
    OPTION_HELP,
    OPTION_LOAD,
    OPTION_SAVE,
    OPTION_QUIT,
    OPTION_BUTTONS,
    OPTION_TILES,
    OPTION_OPACITY,
    OPTION_FONTS,
    OPTION_AUTOPROMPT,
    OPTION_SAFEWALK,
    OPTION_ACTIONBAR,
    OPTION_COLOUREDFONTS,
    OPTION_CHARDUMP,
    OPTION_KNOWNITEMS,
    OPTION_DEBUGINFO,
    OPTION_COLLAPSE,
    OPTION_DEFAULTS,
    OPTION_FULLSCREEN,
    OPTION_UNLOCKING,
    NUM_OPTIONS
};

// Macros for OPTION
#define FOREACH_OPTION(x) \
    for ((x) = (OPTION_NAMES) 0; \
         (x) < NUM_OPTIONS; \
         (x) = (OPTION_NAMES) ((int)(x)+1))

// Definitions for MAINMENU
enum MAINMENU_NAMES
{
    MAINMENU_NONE,
    MAINMENU_NEWGAME,
    MAINMENU_TUTORIAL,
    MAINMENU_VIEWSCORES,
    MAINMENU_LOAD,
    MAINMENU_OPTIONS,
    MAINMENU_QUIT,
    MAINMENU_SAVESCUM,
    MAINMENU_STRESSTEST,
    MAINMENU_UNLOCK,
    NUM_MAINMENUS
};

// Macros for MAINMENU
#define FOREACH_MAINMENU(x) \
    for ((x) = (MAINMENU_NAMES) 0; \
         (x) < NUM_MAINMENUS; \
         (x) = (MAINMENU_NAMES) ((int)(x)+1))

struct MAINMENU_DEF
{
    const char *name;
};

extern const MAINMENU_DEF glb_mainmenudefs[];

// Definitions for ITEMSLOT
enum ITEMSLOT_NAMES
{
    ITEMSLOT_HEAD,
    ITEMSLOT_AMULET,
    ITEMSLOT_RHAND,
    ITEMSLOT_LHAND,
    ITEMSLOT_BODY,
    ITEMSLOT_RRING,
    ITEMSLOT_LRING,
    ITEMSLOT_FEET,
    NUM_ITEMSLOTS
};

// Macros for ITEMSLOT
#define FOREACH_ITEMSLOT(x) \
    for ((x) = (ITEMSLOT_NAMES) 0; \
         (x) < NUM_ITEMSLOTS; \
         (x) = (ITEMSLOT_NAMES) ((int)(x)+1))

struct ITEMSLOT_DEF
{
    const char *desc1;
    const char *desc2;
    const char *preposition;
    const char *bodypart;
    u16 tile;
    u8 areaweight;
    u8 posx;
    u8 posy;
    bool flipx : 1;
    bool flipy : 1;
};

extern const ITEMSLOT_DEF glb_itemslotdefs[];

// Definitions for ITEMSLOTSET
enum ITEMSLOTSET_NAMES
{
    ITEMSLOTSET_NONE,
    ITEMSLOTSET_HUMANOID,
    ITEMSLOTSET_TREE,
    ITEMSLOTSET_BRAIN,
    ITEMSLOTSET_FIREELEMENTAL,
    ITEMSLOTSET_HEADLESS,
    ITEMSLOTSET_HEADONLY,
    ITEMSLOTSET_ANIMAL,
    ITEMSLOTSET_SNAKE,
    ITEMSLOTSET_LUX,
    ITEMSLOTSET_SLUG,
    ITEMSLOTSET_INSECT,
    ITEMSLOTSET_HUMANOID_ARMOURLESS,
    ITEMSLOTSET_HUMANOID_HUGE,
    ITEMSLOTSET_BIRD,
    ITEMSLOTSET_WINGLESS_BIRD,
    NUM_ITEMSLOTSETS
};

// Macros for ITEMSLOTSET
#define FOREACH_ITEMSLOTSET(x) \
    for ((x) = (ITEMSLOTSET_NAMES) 0; \
         (x) < NUM_ITEMSLOTSETS; \
         (x) = (ITEMSLOTSET_NAMES) ((int)(x)+1))

struct ITEMSLOTSET_DEF
{
    const char *head_name;
    const char *neck_name;
    const char *rhand_name;
    const char *lhand_name;
    const char *body_name;
    const char *rring_name;
    const char *lring_name;
    const char *feet_name;
};

extern const ITEMSLOTSET_DEF glb_itemslotsetdefs[];

// Definitions for ITEM
enum ITEM_NAMES
{
    ITEM_NONE,
    ITEM_KNIFE,
    ITEM_DAGGER,
    ITEM_SILVERDAGGER,
    ITEM_WARHAMMER,
    ITEM_EARTHHAMMER,
    ITEM_SPEAR,
    ITEM_SILVERSPEAR,
    ITEM_CLUB,
    ITEM_SILVERSWORD,
    ITEM_SHORTSWORD,
    ITEM_LONGSWORD,
    ITEM_RAPIER,
    ITEM_LIGHTNINGRAPIER,
    ITEM_FLAMESWORD,
    ITEM_MACE,
    ITEM_ICEMACE,
    ITEM_BOW,
    ITEM_ARROW,
    ITEM_FIREARROW,
    ITEM_HAT,
    ITEM_LEATHERCAP,
    ITEM_HELM,
    ITEM_FEATHERHELM,
    ITEM_SILVERCIRCLET,
    ITEM_GOLDCROWN,
    ITEM_SANDALS,
    ITEM_HIKINGBOOTS,
    ITEM_IRONSHOES,
    ITEM_WINGEDBOOTS,
    ITEM_RIDINGBOOTS,
    ITEM_POINTEDSLIPPERS,
    ITEM_CLOGS,
    ITEM_WOODENSHIELD,
    ITEM_BUCKLER,
    ITEM_ROUNDSHIELD,
    ITEM_KITESHIELD,
    ITEM_TOWERSHIELD,
    ITEM_REFLECTSHIELD,
    ITEM_TORCH,
    ITEM_BLUEPOTION,
    ITEM_REDPOTION,
    ITEM_PURPLEPOTION,
    ITEM_YELLOWPOTION,
    ITEM_GREYPOTION,
    ITEM_WHITEPOTION,
    ITEM_BLACKPOTION,
    ITEM_CYANPOTION,
    ITEM_GLOWINGPOTION,
    ITEM_BLUESPELLBOOK,
    ITEM_REDSPELLBOOK,
    ITEM_LEATHERSPELLBOOK,
    ITEM_PURPLESPELLBOOK,
    ITEM_GREYSPELLBOOK,
    ITEM_PLAIDSPELLBOOK,
    ITEM_BLACKSPELLBOOK,
    ITEM_GOLDSPELLBOOK,
    ITEM_THINBLUESPELLBOOK,
    ITEM_LOCKEDSPELLBOOK,
    ITEM_BLUERUNEDSPELLBOOK,
    ITEM_REDRUNEDSPELLBOOK,
    ITEM_LEATHERRUNEDSPELLBOOK,
    ITEM_GREYRUNEDSPELLBOOK,
    ITEM_WHITESPELLBOOK,
    ITEM_GLASSSPELLBOOK,
    ITEM_BLOODYSPELLBOOK,
    ITEM_THINREDSPELLBOOK,
    ITEM_WOODENSTAFF,
    ITEM_IRONSHODSTAFF,
    ITEM_CROOK,
    ITEM_GNARLYSTAFF,
    ITEM_BEJEWELEDSTAFF,
    ITEM_WATER,
    ITEM_BOTTLE,
    ITEM_ROBE,
    ITEM_LEATHERTUNIC,
    ITEM_STUDDEDLEATHER,
    ITEM_CHAINMAIL,
    ITEM_MITHRILMAIL,
    ITEM_BANDEDMAIL,
    ITEM_SPLINTMAIL,
    ITEM_PLATEMAIL,
    ITEM_CRYSTALPLATE,
    ITEM_BOULDER,
    ITEM_MOUNDFLESH,
    ITEM_ROCK,
    ITEM_MEATBALL,
    ITEM_WOODENRING,
    ITEM_SILVERRING,
    ITEM_IRONRING,
    ITEM_GLASSRING,
    ITEM_RUBYRING,
    ITEM_EMERALDRING,
    ITEM_SAPPHIRERING,
    ITEM_GOLDRING,
    ITEM_AMETHYSTRING,
    ITEM_DIAMONDRING,
    ITEM_MOBIUSRING,
    ITEM_STONERING,
    ITEM_AQUAMARINERING,
    ITEM_JADERING,
    ITEM_ONYXRING,
    ITEM_PEARLNECKLACE,
    ITEM_GOLDNECKLACE,
    ITEM_RUBYNECKLACE,
    ITEM_IRONTORC,
    ITEM_STUDDEDGORGET,
    ITEM_WOODENWAND,
    ITEM_GLASSWAND,
    ITEM_SILVERWAND,
    ITEM_IRONWAND,
    ITEM_CURVEDWAND,
    ITEM_FORKEDWAND,
    ITEM_JEWELEDWAND,
    ITEM_TWISTEDWAND,
    ITEM_PURPLEWAND,
    ITEM_JADEWAND,
    ITEM_GEMENCRUSTEDWAND,
    ITEM_STONEWAND,
    ITEM_GOLDWAND,
    ITEM_SCROLL_FOOBAR,
    ITEM_SCROLL_README,
    ITEM_SCROLL_KARMA,
    ITEM_SCROLL_REDWOP,
    ITEM_SCROLL_FOLLORCS,
    ITEM_SCROLL_BEWARE,
    ITEM_SCROLL_ANCIENTRUNES,
    ITEM_SCROLL_QUIZAR,
    ITEM_SCROLL_XYZZY,
    ITEM_SCROLL_ATARI,
    ITEM_BLACKHEART,
    ITEM_YRUNE,
    ITEM_CORPSE,
    ITEM_BONES,
    ITEM_STATUE,
    ITEM_MINDACIDHAND,
    NUM_ITEMS
};

// Macros for ITEM
#define FOREACH_ITEM(x) \
    for ((x) = (ITEM_NAMES) 0; \
         (x) < NUM_ITEMS; \
         (x) = (ITEM_NAMES) ((int)(x)+1))

struct ITEM_DEF
{
    const char *name;
    DICE stacksize;
    u16 tile;
    u8 flag1;
    u8 material;
    u8 weight;
    s8 ac;
    u8 lightradius;
    u8 attack;
    u8 thrownattack;
    u8 minitile;
    u8 magictype;
    u8 cursechance;
    u8 rarity;
    u8 launcher;
    u8 itemtype;
    u8 size;
    u8 attackskill;
    u8 specialskill;
    u8 noise;
    bool iscarryintrinsic : 1;
    bool isquest : 1;
    bool equipstack : 1;
    const char *intrinsic;
};

extern const ITEM_DEF glb_itemdefs[];

// Definitions for ITEMTYPE
enum ITEMTYPE_NAMES
{
    ITEMTYPE_NONE,
    ITEMTYPE_ANY,
    ITEMTYPE_ARTIFACT,
    ITEMTYPE_AMULET,
    ITEMTYPE_STAFF,
    ITEMTYPE_WEAPON,
    ITEMTYPE_ARMOUR,
    ITEMTYPE_RING,
    ITEMTYPE_SCROLL,
    ITEMTYPE_SPELLBOOK,
    ITEMTYPE_POTION,
    ITEMTYPE_WAND,
    ITEMTYPE_MISC,
    NUM_ITEMTYPES
};

// Macros for ITEMTYPE
#define FOREACH_ITEMTYPE(x) \
    for ((x) = (ITEMTYPE_NAMES) 0; \
         (x) < NUM_ITEMTYPES; \
         (x) = (ITEMTYPE_NAMES) ((int)(x)+1))

struct ITEMTYPE_DEF
{
    const char *name;
    u8 rarity;
};

extern const ITEMTYPE_DEF glb_itemtypedefs[];

// Definitions for STAFF
enum STAFF_NAMES
{
    STAFF_HEALING,
    STAFF_DEATH,
    STAFF_DESTRUCTION,
    STAFF_BOLT,
    STAFF_UTILITY,
    NUM_STAFFS
};

// Macros for STAFF
#define FOREACH_STAFF(x) \
    for ((x) = (STAFF_NAMES) 0; \
         (x) < NUM_STAFFS; \
         (x) = (STAFF_NAMES) ((int)(x)+1))

struct STAFF_DEF
{
    const char *name;
    u8 cursechance;
    const char *intrinsic;
};

extern const STAFF_DEF glb_staffdefs[];

// Definitions for SPELLBOOK
enum SPELLBOOK_NAMES
{
    SPELLBOOK_FIRE,
    SPELLBOOK_COLD,
    SPELLBOOK_SHOCK,
    SPELLBOOK_HEAL,
    SPELLBOOK_FAMILIAR,
    SPELLBOOK_DIVINATION,
    SPELLBOOK_FORCE,
    SPELLBOOK_EARTH,
    SPELLBOOK_DEATH,
    SPELLBOOK_NECRO,
    SPELLBOOK_ACID,
    SPELLBOOK_ARMOUR,
    SPELLBOOK_MATERIAL,
    SPELLBOOK_ROGUE,
    SPELLBOOK_BLADES,
    SPELLBOOK_BASHING,
    SPELLBOOK_SHARPPOINTS,
    SPELLBOOK_BARB,
    NUM_SPELLBOOKS
};

// Macros for SPELLBOOK
#define FOREACH_SPELLBOOK(x) \
    for ((x) = (SPELLBOOK_NAMES) 0; \
         (x) < NUM_SPELLBOOKS; \
         (x) = (SPELLBOOK_NAMES) ((int)(x)+1))

struct SPELLBOOK_DEF
{
    const char *name;
    DICE charges;
    u8 cursechance;
    const char *spells;
    const char *skills;
};

extern const SPELLBOOK_DEF glb_spellbookdefs[];

// Definitions for WAND
enum WAND_NAMES
{
    WAND_TELEPORT,
    WAND_LIGHT,
    WAND_INVISIBLE,
    WAND_FIRE,
    WAND_ICE,
    WAND_NOTHING,
    WAND_DIGGING,
    WAND_CREATETRAP,
    WAND_CREATEMONSTER,
    WAND_POLYMORPH,
    WAND_SLOW,
    WAND_SPEED,
    WAND_SLEEP,
    NUM_WANDS
};

// Macros for WAND
#define FOREACH_WAND(x) \
    for ((x) = (WAND_NAMES) 0; \
         (x) < NUM_WANDS; \
         (x) = (WAND_NAMES) ((int)(x)+1))

struct WAND_DEF
{
    const char *name;
    DICE charges;
    u8 cursechance;
};

extern const WAND_DEF glb_wanddefs[];

// Definitions for AMULET
enum AMULET_NAMES
{
    AMULET_STRANGULATION,
    AMULET_REFLECTION,
    AMULET_LIFESAVING,
    AMULET_POISONRESIST,
    AMULET_UNCHANGING,
    NUM_AMULETS
};

// Macros for AMULET
#define FOREACH_AMULET(x) \
    for ((x) = (AMULET_NAMES) 0; \
         (x) < NUM_AMULETS; \
         (x) = (AMULET_NAMES) ((int)(x)+1))

struct AMULET_DEF
{
    const char *name;
    u8 cursechance;
    u8 coolness;
    const char *intrinsic;
};

extern const AMULET_DEF glb_amuletdefs[];

// Definitions for BOOTS
enum BOOTS_NAMES
{
    BOOTS_WATERWALK,
    BOOTS_SNOWBOOTS,
    BOOTS_JUMP,
    BOOTS_SPEED,
    BOOTS_SQUEAKY,
    NUM_BOOTSS
};

// Macros for BOOTS
#define FOREACH_BOOTS(x) \
    for ((x) = (BOOTS_NAMES) 0; \
         (x) < NUM_BOOTSS; \
         (x) = (BOOTS_NAMES) ((int)(x)+1))

struct BOOTS_DEF
{
    const char *name;
    u8 cursechance;
    const char *intrinsic;
};

extern const BOOTS_DEF glb_bootsdefs[];

// Definitions for HELM
enum HELM_NAMES
{
    HELM_DRAIN,
    HELM_TELEPATHY,
    HELM_WARNING,
    NUM_HELMS
};

// Macros for HELM
#define FOREACH_HELM(x) \
    for ((x) = (HELM_NAMES) 0; \
         (x) < NUM_HELMS; \
         (x) = (HELM_NAMES) ((int)(x)+1))

struct HELM_DEF
{
    const char *name;
    u8 cursechance;
    const char *intrinsic;
};

extern const HELM_DEF glb_helmdefs[];

// Definitions for RING
enum RING_NAMES
{
    RING_WEDDING,
    RING_REGENERATE,
    RING_TELEPORT,
    RING_TELEPORTCONTROL,
    RING_MISSINGFINGER,
    RING_SEARCH,
    RING_FIRE,
    RING_ICE,
    RING_ACID,
    RING_SHOCK,
    RING_LIGHT,
    RING_INVISIBLE,
    RING_SEEINVISIBLE,
    RING_POLYMORPH,
    RING_POLYCONTROL,
    NUM_RINGS
};

// Macros for RING
#define FOREACH_RING(x) \
    for ((x) = (RING_NAMES) 0; \
         (x) < NUM_RINGS; \
         (x) = (RING_NAMES) ((int)(x)+1))

struct RING_DEF
{
    const char *name;
    u8 cursechance;
    u8 coolness;
    const char *intrinsic;
};

extern const RING_DEF glb_ringdefs[];

// Definitions for SCROLL
enum SCROLL_NAMES
{
    SCROLL_ID,
    SCROLL_REMOVECURSE,
    SCROLL_FIRE,
    SCROLL_LIGHT,
    SCROLL_MAP,
    SCROLL_HEAL,
    SCROLL_TELEPORT,
    SCROLL_ENCHANTWEAPON,
    SCROLL_ENCHANTARMOUR,
    SCROLL_MAKEARTIFACT,
    NUM_SCROLLS
};

// Macros for SCROLL
#define FOREACH_SCROLL(x) \
    for ((x) = (SCROLL_NAMES) 0; \
         (x) < NUM_SCROLLS; \
         (x) = (SCROLL_NAMES) ((int)(x)+1))

struct SCROLL_DEF
{
    const char *name;
    u8 cursechance;
    u8 rarity;
    bool autoid : 1;
};

extern const SCROLL_DEF glb_scrolldefs[];

// Definitions for POTION
enum POTION_NAMES
{
    POTION_HEAL,
    POTION_ACID,
    POTION_BLIND,
    POTION_POISON,
    POTION_CURE,
    POTION_GREEKFIRE,
    POTION_ENLIGHTENMENT,
    POTION_SMOKE,
    POTION_MANA,
    NUM_POTIONS
};

// Macros for POTION
#define FOREACH_POTION(x) \
    for ((x) = (POTION_NAMES) 0; \
         (x) < NUM_POTIONS; \
         (x) = (POTION_NAMES) ((int)(x)+1))

struct POTION_DEF
{
    const char *name;
    u8 cursechance;
    u8 grenadeelement;
    bool autoid : 1;
    bool isgrenade : 1;
};

extern const POTION_DEF glb_potiondefs[];

// Definitions for MAGICTYPE
enum MAGICTYPE_NAMES
{
    MAGICTYPE_NONE,
    MAGICTYPE_POTION,
    MAGICTYPE_SCROLL,
    MAGICTYPE_RING,
    MAGICTYPE_HELM,
    MAGICTYPE_WAND,
    MAGICTYPE_AMULET,
    MAGICTYPE_SPELLBOOK,
    MAGICTYPE_BOOTS,
    MAGICTYPE_STAFF,
    NUM_MAGICTYPES
};

// Macros for MAGICTYPE
#define FOREACH_MAGICTYPE(x) \
    for ((x) = (MAGICTYPE_NAMES) 0; \
         (x) < NUM_MAGICTYPES; \
         (x) = (MAGICTYPE_NAMES) ((int)(x)+1))

struct MAGICTYPE_DEF
{
    const char *name;
    const char *cycname;
};

extern const MAGICTYPE_DEF glb_magictypedefs[];

// Definitions for ITEMFLAG1
enum ITEMFLAG1_NAMES
{
    ITEMFLAG1_NONE = 0,
    ITEMFLAG1_ARMORSLOTMASK = 7,
    ITEMFLAG1_ISBOOTS = 1,
    ITEMFLAG1_ISHELMET = 2,
    ITEMFLAG1_ISSHIELD = 3,
    ITEMFLAG1_ISJACKET = 4,
    ITEMFLAG1_ISRING = 5,
    ITEMFLAG1_ISAMULET = 6,
    ITEMFLAG1_ISCURSED = 8,
    ITEMFLAG1_ISBLESSED = 16,
    ITEMFLAG1_ISBLOCKING = 64,
    ITEMFLAG1_ISQUIVERED = 128,
    ITEMFLAG1_ISMAPPED = 256,
    ITEMFLAG1_ISKNOWENCHANT = 512,
    ITEMFLAG1_ISKNOWCHARGES = 1024,
    ITEMFLAG1_ISKNOWPOISON = 2048,
    ITEMFLAG1_ISBELOWGRADE = 4096,
    ITEMFLAG1_ISKNOWCURSE = 8192,
    ITEMFLAG1_ISINVENTORY = 16384,
    ITEMFLAG1_ISARTIFACT = 32768,
    ITEMFLAG1_ISKNOWNOTCURSE = 65536,
    ITEMFLAG1_ISFAVORITE = 131072,
    NUM_ITEMFLAG1S
};

// Macros for ITEMFLAG1
#define FOREACH_ITEMFLAG1(x) \
    for ((x) = (ITEMFLAG1_NAMES) 0; \
         (x) < NUM_ITEMFLAG1S; \
         (x) = (ITEMFLAG1_NAMES) ((int)(x)+1))

// Definitions for MATERIAL
enum MATERIAL_NAMES
{
    MATERIAL_NONE,
    MATERIAL_ETHEREAL,
    MATERIAL_CLOTH,
    MATERIAL_LEATHER,
    MATERIAL_PAPER,
    MATERIAL_WOOD,
    MATERIAL_IRON,
    MATERIAL_GLASS,
    MATERIAL_SILVER,
    MATERIAL_STONE,
    MATERIAL_GOLD,
    MATERIAL_MITHRIL,
    MATERIAL_FLESH,
    MATERIAL_WATER,
    NUM_MATERIALS
};

// Macros for MATERIAL
#define FOREACH_MATERIAL(x) \
    for ((x) = (MATERIAL_NAMES) 0; \
         (x) < NUM_MATERIALS; \
         (x) = (MATERIAL_NAMES) ((int)(x)+1))

struct MATERIAL_DEF
{
    const char *name;
    bool soluble : 1;
    bool burnable : 1;
};

extern const MATERIAL_DEF glb_materialdefs[];

// Definitions for MOB
enum MOB_NAMES
{
    MOB_NONE = 0,
    MOB_AVATAR,
    MOB_GREENDRAGON,
    MOB_WHITEDRAGON,
    MOB_REDDRAGON,
    MOB_BLUEDRAGON,
    MOB_YELLOWDRAGON,
    MOB_COCKATRICE,
    MOB_DAEMON,
    MOB_ICEDAEMON,
    MOB_BAEZLBUB,
    MOB_CRETAN_MINOTAUR,
    MOB_TRIDUDE,
    MOB_REDTRIDUDE,
    MOB_BLUETRIDUDE,
    MOB_PURPLETRIDUDE,
    MOB_GOLDTRIDUDE,
    MOB_FIREBEETLE,
    MOB_GOLDBEETLE,
    MOB_ICESNAKE,
    MOB_GREENSNAKE,
    MOB_FIRESNAKE,
    MOB_MOUSE,
    MOB_RAT,
    MOB_GIANTRAT,
    MOB_GRIDBUG,
    MOB_SHITOMI,
    MOB_TRICERATOP,
    MOB_LUX,
    MOB_BROWNSLUG,
    MOB_PURPLESLUG,
    MOB_DEATHSLUG,
    MOB_FLOATINGEYE,
    MOB_WIZARDSEYE,
    MOB_GELATINOUSCUBE,
    MOB_SCORPION,
    MOB_CAVESPIDER,
    MOB_GIANTSPIDER,
    MOB_KIWI,
    MOB_BAT,
    MOB_LARGEBAT,
    MOB_VAMPIREBAT,
    MOB_STALKER,
    MOB_FROG,
    MOB_SKELETON,
    MOB_ZOMBIE,
    MOB_GHAST,
    MOB_LICH,
    MOB_SOULSUCKER,
    MOB_IMP,
    MOB_KOBOLD,
    MOB_KOBOLDMAGE,
    MOB_KOBOLDFIGHTER,
    MOB_KOBOLDASSASSIN,
    MOB_KOBOLDTHIEF,
    MOB_TROLL,
    MOB_CAVETROLL,
    MOB_LIZARDMAN,
    MOB_TURTLOID,
    MOB_LARGETURTLOID,
    MOB_ORC,
    MOB_HILLORC,
    MOB_HEADLESS,
    MOB_CHAMELEON,
    MOB_LIVINGTREE,
    MOB_EARTHELEMENTAL,
    MOB_AIRELEMENTAL,
    MOB_FIREELEMENTAL,
    MOB_WATERELEMENTAL,
    MOB_FLESHGOLEM,
    MOB_STONEGOLEM,
    MOB_IRONGOLEM,
    MOB_GHOST,
    MOB_LIVINGFROST,
    MOB_ELDER,
    MOB_GOD_KLASKOV,
    MOB_GOD_BELWEIR,
    MOB_GOD_QUIZAR,
    MOB_GOD_TLOSH,
    MOB_GOD_HRUTH,
    MOB_GOD_PAX,
    MOB_GOD_XOM,
    NUM_MOBS
};

// Macros for MOB
#define FOREACH_MOB(x) \
    for ((x) = (MOB_NAMES) 0; \
         (x) < NUM_MOBS; \
         (x) = (MOB_NAMES) ((int)(x)+1))

struct MOB_DEF
{
    const char *name;
    DICE hp;
    DICE mp;
    DICE eatmp;
    DICE breathdelay;
    const char *breathsubstance;
    u16 tile;
    u16 tileur;
    u16 tilell;
    u16 tilelr;
    u8 movetype;
    u8 attack;
    u8 hitdie;
    u8 baseskills;
    u8 mpdie;
    u8 basespells;
    u8 explevel;
    s8 baseac;
    u8 lightradius;
    u8 smarts;
    u8 strength;
    u8 ai;
    u8 naturalfoe;
    u8 size;
    u8 mobtype;
    u8 slotset;
    u8 rarity;
    u8 material;
    u8 breathattack;
    u8 reflex_attack;
    u8 reflex_chance;
    u8 corpsechance;
    u8 noise;
    u8 deathmsg;
    u8 gender;
    u8 evolvetarget;
    u8 evolvelevel;
    bool isboneless : 1;
    bool isbloodless : 1;
    bool acidiccorpse : 1;
    bool canresurrectfromcorpse : 1;
    bool blownbywind : 1;
    bool usenameasprefix : 1;
    bool publish : 1;
    bool spacewalk : 1;
    const char *intrinsic;
    const char *eatgrant;
    const char *loot;
    const char *loottype;
    const char *edible;
};

extern const MOB_DEF glb_mobdefs[];

// Definitions for MOBTYPE
enum MOBTYPE_NAMES
{
    MOBTYPE_NONE,
    MOBTYPE_UNUSUAL,
    MOBTYPE_DRAGON,
    MOBTYPE_SNAKE,
    MOBTYPE_INSECT,
    MOBTYPE_SPIDER,
    MOBTYPE_HUMANOID,
    MOBTYPE_KOBOLD,
    MOBTYPE_TROLL,
    MOBTYPE_RAT,
    MOBTYPE_CONSTRUCT,
    MOBTYPE_DAEMON,
    MOBTYPE_SLUG,
    MOBTYPE_UNDEAD,
    MOBTYPE_BAT,
    MOBTYPE_GOLEM,
    MOBTYPE_ELEMENTAL,
    MOBTYPE_GOD,
    MOBTYPE_TRIDUDE,
    NUM_MOBTYPES
};

// Macros for MOBTYPE
#define FOREACH_MOBTYPE(x) \
    for ((x) = (MOBTYPE_NAMES) 0; \
         (x) < NUM_MOBTYPES; \
         (x) = (MOBTYPE_NAMES) ((int)(x)+1))

struct MOBTYPE_DEF
{
    const char *name;
};

extern const MOBTYPE_DEF glb_mobtypedefs[];

// Definitions for MOBLEVEL
enum MOBLEVEL_NAMES
{
    MOBLEVEL_NONE,
    MOBLEVEL_WEAK,
    MOBLEVEL_NORMAL,
    MOBLEVEL_STRONG,
    MOBLEVEL_OVERPOWERING,
    MOBLEVEL_UNIQUE,
    NUM_MOBLEVELS
};

// Macros for MOBLEVEL
#define FOREACH_MOBLEVEL(x) \
    for ((x) = (MOBLEVEL_NAMES) 0; \
         (x) < NUM_MOBLEVELS; \
         (x) = (MOBLEVEL_NAMES) ((int)(x)+1))

struct MOBLEVEL_DEF
{
    s16 minlevel;
    s16 maxlevel;
};

extern const MOBLEVEL_DEF glb_mobleveldefs[];

// Definitions for GENDERCHANCE
enum GENDERCHANCE_NAMES
{
    GENDERCHANCE_MALE,
    GENDERCHANCE_FEMALE,
    GENDERCHANCE_NEUTER,
    GENDERCHANCE_MORF,
    NUM_GENDERCHANCES
};

// Macros for GENDERCHANCE
#define FOREACH_GENDERCHANCE(x) \
    for ((x) = (GENDERCHANCE_NAMES) 0; \
         (x) < NUM_GENDERCHANCES; \
         (x) = (GENDERCHANCE_NAMES) ((int)(x)+1))

struct GENDERCHANCE_DEF
{
    u8 male;
    u8 female;
    u8 neuter;
};

extern const GENDERCHANCE_DEF glb_genderchancedefs[];

// Definitions for SIZE
enum SIZE_NAMES
{
    SIZE_TINY,
    SIZE_SMALL,
    SIZE_MEDIUM,
    SIZE_LARGE,
    SIZE_HUGE,
    SIZE_GARGANTUAN,
    NUM_SIZES
};

// Macros for SIZE
#define FOREACH_SIZE(x) \
    for ((x) = (SIZE_NAMES) 0; \
         (x) < NUM_SIZES; \
         (x) = (SIZE_NAMES) ((int)(x)+1))

struct SIZE_DEF
{
    const char *name;
    u16 foodval;
};

extern const SIZE_DEF glb_sizedefs[];

// Definitions for AI
enum AI_NAMES
{
    AI_NONE = 0,
    AI_RABID,
    AI_ANIMAL_PACK,
    AI_MOUSE,
    AI_PACK,
    AI_ANIMAL_SPECIEST,
    AI_SPECIEST,
    AI_EVILHUMANOID,
    AI_GOODHUMANOID,
    AI_KOBOLD,
    AI_TROLL,
    AI_SMARTTRIDUDE,
    AI_SCAVENGER,
    AI_FRIENDLY,
    NUM_AIS
};

// Macros for AI
#define FOREACH_AI(x) \
    for ((x) = (AI_NAMES) 0; \
         (x) < NUM_AIS; \
         (x) = (AI_NAMES) ((int)(x)+1))

struct AI_DEF
{
    bool attackavatar : 1;
    bool attackspecies : 1;
    bool attacktype : 1;
    bool attackalien : 1;
    bool useitems : 1;
    bool throwitems : 1;
    bool packrat : 1;
    bool zapwands : 1;
    bool markattackpos : 1;
    bool opendoors : 1;
};

extern const AI_DEF glb_aidefs[];

// Definitions for STRENGTH
enum STRENGTH_NAMES
{
    STRENGTH_NONE = 0,
    STRENGTH_MINIMAL,
    STRENGTH_WEAK,
    STRENGTH_HUMAN,
    STRENGTH_STRONG,
    STRENGTH_DRAGON,
    NUM_STRENGTHS
};

// Macros for STRENGTH
#define FOREACH_STRENGTH(x) \
    for ((x) = (STRENGTH_NAMES) 0; \
         (x) < NUM_STRENGTHS; \
         (x) = (STRENGTH_NAMES) ((int)(x)+1))

// Definitions for SMARTS
enum SMARTS_NAMES
{
    SMARTS_NONE = 0,
    SMARTS_VEGETABLE,
    SMARTS_ANIMAL,
    SMARTS_CUNNINGANIMAL,
    SMARTS_FOOL,
    SMARTS_HUMAN,
    SMARTS_WISE,
    NUM_SMARTSS
};

// Macros for SMARTS
#define FOREACH_SMARTS(x) \
    for ((x) = (SMARTS_NAMES) 0; \
         (x) < NUM_SMARTSS; \
         (x) = (SMARTS_NAMES) ((int)(x)+1))

// Definitions for ATTACK
enum ATTACK_NAMES
{
    ATTACK_NONE = 0,
    ATTACK_INHALE_SMOKE,
    ATTACK_INHALE_STEAM,
    ATTACK_INHALE_POISONSMOKE,
    ATTACK_INHALE_ACIDSMOKE,
    ATTACK_FROGBITE,
    ATTACK_GOLDBEETLE_MANDIBLE,
    ATTACK_GOLDBEETLE_FEELER,
    ATTACK_COCKATRICE_HISS,
    ATTACK_COCKATRICE_BITE,
    ATTACK_FIREBREATH,
    ATTACK_FIREBREATHBALL,
    ATTACK_ICEBREATH,
    ATTACK_GREENDRAGONBITE,
    ATTACK_LIGHTNINGBREATH,
    ATTACK_ACIDBREATH,
    ATTACK_BLEED,
    ATTACK_POISONEFFECT_MILD,
    ATTACK_POISONEFFECT_NORMAL,
    ATTACK_POISONEFFECT_STRONG,
    ATTACK_POISONEFFECT_HARSH,
    ATTACK_POISONEFFECT_DEADLY,
    ATTACK_POISONEFFECT_INSTANTDEATH,
    ATTACK_MISUSED,
    ATTACK_MISUSED_BUTWEAPON,
    ATTACK_MISTHROWN,
    ATTACK_STRANGLED,
    ATTACK_TURNED_TO_STONE,
    ATTACK_TURNED_TO_FLESH,
    ATTACK_LOSTBODY,
    ATTACK_RECLAIM_SOUL,
    ATTACK_DARK_RITUAL_CONSUME,
    ATTACK_SPELL_DARK_RITUAL_NORTH,
    ATTACK_SPELL_DARK_RITUAL_WEST,
    ATTACK_SPELL_DARK_RITUAL_EAST,
    ATTACK_SPELL_DARK_RITUAL_SOUTH,
    ATTACK_BLIZZARD_SOURCE,
    ATTACK_DROWN,
    ATTACK_SUFFOCATE,
    ATTACK_ASPHYXIATE,
    ATTACK_FIREWAND,
    ATTACK_ICEWAND,
    ATTACK_SLEEPWAND,
    ATTACK_DIGEARTHELEMENTAL,
    ATTACK_DOUSEFIREELEMENTAL,
    ATTACK_HOLYWATER,
    ATTACK_CEILINGROCKS,
    ATTACK_PUNCH,
    ATTACK_WHIP,
    ATTACK_CLAW,
    ATTACK_CLUB,
    ATTACK_DOUBLECLUB,
    ATTACK_TRIPLECLUB,
    ATTACK_MACE,
    ATTACK_WARHAMMER,
    ATTACK_EARTHHAMMER,
    ATTACK_KNIFE,
    ATTACK_KNIFETHROWN,
    ATTACK_DAGGER,
    ATTACK_DAGGERTHROWN,
    ATTACK_SPEAR,
    ATTACK_SPEARTHROWN,
    ATTACK_SHORTSWORD,
    ATTACK_LONGSWORD,
    ATTACK_RAPIER,
    ATTACK_LIGHTNINGRAPIER,
    ATTACK_ZAPLIGHTNINGRAPIER,
    ATTACK_ICEMACE,
    ATTACK_WOODENSTAFF,
    ATTACK_IRONSHODSTAFF,
    ATTACK_TORCH,
    ATTACK_TORCHTHROWN,
    ATTACK_ARROWTHROWN,
    ATTACK_FIREARROWTHROWN,
    ATTACK_ROCKTHROWN,
    ATTACK_POTIONTHROWN,
    ATTACK_RINGTHROWN,
    ATTACK_FLAMING_SWORD,
    ATTACK_DEMON_SWORD,
    ATTACK_FREEZING_SWORD,
    ATTACK_MINDACID,
    ATTACK_FIRESPIT,
    ATTACK_MOUSEBITE,
    ATTACK_RATBITE,
    ATTACK_KIWISTAB,
    ATTACK_BATBITE,
    ATTACK_LARGEBATBITE,
    ATTACK_VAMPIREBATBITE,
    ATTACK_GHASTCLAW,
    ATTACK_GIANTRATBITE,
    ATTACK_FIRESNAKEBITE,
    ATTACK_ICESNAKEBITE,
    ATTACK_GREENSNAKEBITE,
    ATTACK_GRIDBUGZAP,
    ATTACK_SHITOMICHU,
    ATTACK_LIGHTWAND,
    ATTACK_LIGHTBLAST,
    ATTACK_SPELL_FLASH,
    ATTACK_SUNFIREBLAST,
    ATTACK_FLAMESTRIKE,
    ATTACK_SURROUNDSMITE,
    ATTACK_SLUGSLIME,
    ATTACK_BROWNSLUG,
    ATTACK_DEATHSLUG,
    ATTACK_SCORPION,
    ATTACK_CAVESPIDER,
    ATTACK_GIANTSPIDER,
    ATTACK_FLOATINGEYE_REFLEX,
    ATTACK_FLOATINGEYE_TRACK,
    ATTACK_GELATINOUSCUBE,
    ATTACK_GELATINOUSCUBE_REFLEX,
    ATTACK_LIVINGTREE,
    ATTACK_TRICERATOPHORN,
    ATTACK_TRICERATOPHORN_2,
    ATTACK_TRICERATOPHORN_3,
    ATTACK_EARTHELEMENTAL,
    ATTACK_EARTHELEMENTAL_2,
    ATTACK_AIRELEMENTAL,
    ATTACK_AIRELEMENTAL_2,
    ATTACK_FIREELEMENTAL,
    ATTACK_WATERELEMENTAL,
    ATTACK_FLESHGOLEM,
    ATTACK_FLESHGOLEM_2,
    ATTACK_STONEGOLEM,
    ATTACK_STONEGOLEM_2,
    ATTACK_IRONGOLEM,
    ATTACK_IRONGOLEM_2,
    ATTACK_GHOST,
    ATTACK_CRETAN_MINOTAUR,
    ATTACK_CRETAN_MINOTAUR_2,
    ATTACK_CRETAN_MINOTAUR_3,
    ATTACK_BAEZELBUB_BITE,
    ATTACK_BAEZLEBUB_SWORDFLAME,
    ATTACK_BEAZELBUG_SWORD,
    ATTACK_GLASSSHARDS,
    ATTACK_GLASSFRAGMENTS,
    ATTACK_ACIDICCORPSE,
    ATTACK_SILVERITEM,
    ATTACK_GOLDITEM,
    ATTACK_ACIDPOTION,
    ATTACK_GREEKFIREPOTION,
    ATTACK_AFLAME,
    ATTACK_LAVABURN,
    ATTACK_FORESTFIRE,
    ATTACK_ACIDPOOLBURN,
    ATTACK_FIRESCROLL,
    ATTACK_ROLLINGBOULDER,
    ATTACK_TRAP_PIT,
    ATTACK_TRAP_SPIKEDPIT,
    ATTACK_DOORSLAM,
    ATTACK_SPELL_FORCEBOLT,
    ATTACK_SPELL_SANDBLAST,
    ATTACK_SPELL_SANDSTORM,
    ATTACK_SPELL_FORCEWALL,
    ATTACK_SPELL_FROSTBOLT,
    ATTACK_LIVINGFROST,
    ATTACK_SPELL_LIGHTNING,
    ATTACK_SPELL_MAGICMISSILE,
    ATTACK_SPELL_CHILL,
    ATTACK_SPELL_SPARK,
    ATTACK_SPELL_FIREBALL,
    ATTACK_SPELL_FIREBALLBALL,
    ATTACK_SPELL_ACIDSPLASH,
    ATTACK_SPELL_CORROSIVEEXPLOSION,
    ATTACK_SPELL_BLIZZARD,
    ATTACK_SPELL_BLIZZARD_PUMMEL,
    ATTACK_SPELL_DISINTEGRATE,
    ATTACK_SPELL_POISONBOLT,
    ATTACK_SPELL_CLOUDKILL,
    ATTACK_SPELL_FINGEROFDEATH,
    NUM_ATTACKS
};

// Macros for ATTACK
#define FOREACH_ATTACK(x) \
    for ((x) = (ATTACK_NAMES) 0; \
         (x) < NUM_ATTACKS; \
         (x) = (ATTACK_NAMES) ((int)(x)+1))

struct ATTACK_DEF
{
    const char *verb;
    const char *deathtext;
    DICE damage;
    const char *explode_name;
    DICE inflict_duration;
    s8 bonustohit;
    u8 element;
    u8 range;
    u8 eat;
    u8 explode_chance;
    u8 explode_attack;
    u8 explode_smoke;
    u8 inflict_intrinsic;
    u8 inflict_chance;
    u8 inflict_resistance;
    u8 inflict_negate;
    u8 nextattack;
    u8 sameattack;
    bool reflect : 1;
    bool stopathit : 1;
    bool alwayshit : 1;
};

extern const ATTACK_DEF glb_attackdefs[];

// Definitions for ATTACKSTYLE
enum ATTACKSTYLE_NAMES
{
    ATTACKSTYLE_MELEE,
    ATTACKSTYLE_THROWN,
    ATTACKSTYLE_SPELL,
    ATTACKSTYLE_WAND,
    ATTACKSTYLE_POISON,
    ATTACKSTYLE_MISC,
    ATTACKSTYLE_MINION,
    NUM_ATTACKSTYLES
};

// Macros for ATTACKSTYLE
#define FOREACH_ATTACKSTYLE(x) \
    for ((x) = (ATTACKSTYLE_NAMES) 0; \
         (x) < NUM_ATTACKSTYLES; \
         (x) = (ATTACKSTYLE_NAMES) ((int)(x)+1))

// Definitions for ATTITUDE
enum ATTITUDE_NAMES
{
    ATTITUDE_HOSTILE,
    ATTITUDE_NEUTRAL,
    ATTITUDE_FRIENDLY,
    NUM_ATTITUDES
};

// Macros for ATTITUDE
#define FOREACH_ATTITUDE(x) \
    for ((x) = (ATTITUDE_NAMES) 0; \
         (x) < NUM_ATTITUDES; \
         (x) = (ATTITUDE_NAMES) ((int)(x)+1))

// Definitions for SPELL
enum SPELL_NAMES
{
    SPELL_NONE,
    SPELL_FLASH,
    SPELL_STICKYFLAMES,
    SPELL_MAGICMISSILE,
    SPELL_CHILL,
    SPELL_SPARK,
    SPELL_FROSTBOLT,
    SPELL_LIVINGFROST,
    SPELL_BLIZZARD,
    SPELL_FIREBALL,
    SPELL_FLAMESTRIKE,
    SPELL_LIGHTNINGBOLT,
    SPELL_CHAINLIGHTNING,
    SPELL_SUNFIRE,
    SPELL_ACIDSPLASH,
    SPELL_ACIDICMIST,
    SPELL_CORROSIVEEXPLOSION,
    SPELL_ACIDPOOL,
    SPELL_MINDACID,
    SPELL_DISINTEGRATE,
    SPELL_REGENERATE,
    SPELL_SLOWPOISON,
    SPELL_HEAL,
    SPELL_CUREPOISON,
    SPELL_MAJORHEAL,
    SPELL_RESURRECT,
    SPELL_SUMMON_FAMILIAR,
    SPELL_TRANSFER_KNOWLEDGE,
    SPELL_LIGHT,
    SPELL_DARKNESS,
    SPELL_KNOCK,
    SPELL_TRACK,
    SPELL_WIZARDSEYE,
    SPELL_DIAGNOSE,
    SPELL_PRESERVE,
    SPELL_POSSESS,
    SPELL_MAGICMAP,
    SPELL_DETECTCURSE,
    SPELL_IDENTIFY,
    SPELL_BLINK,
    SPELL_FETCH,
    SPELL_TELEPORT,
    SPELL_TELEWITHCONTROL,
    SPELL_DIRECTWIND,
    SPELL_FORCEBOLT,
    SPELL_FORCEWALL,
    SPELL_DIG,
    SPELL_CREATEPIT,
    SPELL_SANDSTORM,
    SPELL_GROWFOREST,
    SPELL_ANIMATEFOREST,
    SPELL_DOWNPOUR,
    SPELL_ROLLINGBOULDER,
    SPELL_PETRIFY,
    SPELL_STONETOFLESH,
    SPELL_ENTOMB,
    SPELL_RAISE_UNDEAD,
    SPELL_RECLAIM_SOUL,
    SPELL_DARK_RITUAL,
    SPELL_POISONITEM,
    SPELL_POISONBOLT,
    SPELL_GHASTIFY,
    SPELL_BINDSOUL,
    SPELL_SOULSUCK,
    SPELL_SUMMON_IMP,
    SPELL_SUMMON_DEMON,
    SPELL_CLOUDKILL,
    SPELL_FINGEROFDEATH,
    NUM_SPELLS
};

// Macros for SPELL
#define FOREACH_SPELL(x) \
    for ((x) = (SPELL_NAMES) 0; \
         (x) < NUM_SPELLS; \
         (x) = (SPELL_NAMES) ((int)(x)+1))

struct SPELL_DEF
{
    const char *name;
    u16 xpcost;
    u8 mpcost;
    u8 hpcost;
    u8 type;
    u8 intrinsic;
    u8 tile;
    bool needsdir : 1;
    bool needstarget : 1;
    bool publish : 1;
    const char *prereq;
    const char *god;
};

extern const SPELL_DEF glb_spelldefs[];

// Definitions for SPELLTYPE
enum SPELLTYPE_NAMES
{
    SPELLTYPE_NONE,
    SPELLTYPE_ATTACK,
    SPELLTYPE_HEAL,
    SPELLTYPE_UTILITY,
    SPELLTYPE_DEATH,
    NUM_SPELLTYPES
};

// Macros for SPELLTYPE
#define FOREACH_SPELLTYPE(x) \
    for ((x) = (SPELLTYPE_NAMES) 0; \
         (x) < NUM_SPELLTYPES; \
         (x) = (SPELLTYPE_NAMES) ((int)(x)+1))

struct SPELLTYPE_DEF
{
    const char *name;
};

extern const SPELLTYPE_DEF glb_spelltypedefs[];

// Definitions for SKILL
enum SKILL_NAMES
{
    SKILL_NONE,
    SKILL_DODGE,
    SKILL_MOVINGTARGET,
    SKILL_SEARCH,
    SKILL_EVADETRAP,
    SKILL_ENDUREHUNGER,
    SKILL_BUTCHERY,
    SKILL_CLEANKILL,
    SKILL_CHARGE,
    SKILL_LEAPATTACK,
    SKILL_TWOWEAPON,
    SKILL_AMBIDEXTROUS,
    SKILL_ARMOUR_HELMET,
    SKILL_ARMOUR_SHIELD,
    SKILL_ARMOUR_BODY,
    SKILL_ARMOUR_BOOTS,
    SKILL_ARMOUR_CLOTH,
    SKILL_ARMOUR_LEATHER,
    SKILL_ARMOUR_IRON,
    SKILL_ARMOUR_EXOTIC,
    SKILL_WEAPON_SMALL,
    SKILL_WEAPON_MEDIUM,
    SKILL_WEAPON_LARGE,
    SKILL_WEAPON_RANGED,
    SKILL_WEAPON_EDGED,
    SKILL_WEAPON_BLUNT,
    SKILL_WEAPON_POINTED,
    SKILL_WEAPON_IMPROVISE,
    SKILL_WEAPON_BLEEDINGWOUND,
    SKILL_WEAPON_DISARM,
    SKILL_WEAPON_IMPALE,
    SKILL_WEAPON_TRUEAIM,
    SKILL_WEAPON_RICOCHET,
    SKILL_WEAPON_RIPOSTE,
    SKILL_WEAPON_PARRY,
    SKILL_WEAPON_KNOCKOUT,
    SKILL_WEAPON_STUN,
    SKILL_WEAPON_KNOCKBACK,
    NUM_SKILLS
};

// Macros for SKILL
#define FOREACH_SKILL(x) \
    for ((x) = (SKILL_NAMES) 0; \
         (x) < NUM_SKILLS; \
         (x) = (SKILL_NAMES) ((int)(x)+1))

struct SKILL_DEF
{
    const char *name;
    u8 action;
    u8 intrinsic;
    u8 proc;
    const char *prereq;
    const char *god;
};

extern const SKILL_DEF glb_skilldefs[];

// Definitions for POISON
enum POISON_NAMES
{
    POISON_NONE,
    POISON_MILD,
    POISON_NORMAL,
    POISON_STRONG,
    POISON_HARSH,
    POISON_DEADLY,
    NUM_POISONS
};

// Macros for POISON
#define FOREACH_POISON(x) \
    for ((x) = (POISON_NAMES) 0; \
         (x) < NUM_POISONS; \
         (x) = (POISON_NAMES) ((int)(x)+1))

struct POISON_DEF
{
    const char *name;
    u8 modulus;
    u8 damage;
    u8 finaldamage;
    u8 intrinsic;
};

extern const POISON_DEF glb_poisondefs[];

// Definitions for INTRINSIC
enum INTRINSIC_NAMES
{
    INTRINSIC_NONE,
    INTRINSIC_DEAD,
    INTRINSIC_LEFTHANDED,
    INTRINSIC_FAST,
    INTRINSIC_QUICK,
    INTRINSIC_SLOW,
    INTRINSIC_DIG,
    INTRINSIC_UNCHANGING,
    INTRINSIC_STONING,
    INTRINSIC_RESISTSTONING,
    INTRINSIC_RESISTFIRE,
    INTRINSIC_RESISTCOLD,
    INTRINSIC_RESISTSHOCK,
    INTRINSIC_RESISTACID,
    INTRINSIC_RESISTPOISON,
    INTRINSIC_RESISTPHYSICAL,
    INTRINSIC_TELEPORT,
    INTRINSIC_TELEFIXED,
    INTRINSIC_POSITIONREVEALED,
    INTRINSIC_TELEPORTCONTROL,
    INTRINSIC_MISSINGFINGER,
    INTRINSIC_REGENERATION,
    INTRINSIC_NOREGEN,
    INTRINSIC_BLEED,
    INTRINSIC_MAGICDRAIN,
    INTRINSIC_REFLECTION,
    INTRINSIC_SEARCH,
    INTRINSIC_VULNSILVER,
    INTRINSIC_GOLDALLERGY,
    INTRINSIC_VULNFIRE,
    INTRINSIC_VULNCOLD,
    INTRINSIC_VULNACID,
    INTRINSIC_VULNSHOCK,
    INTRINSIC_VULNPHYSICAL,
    INTRINSIC_CONFUSED,
    INTRINSIC_INVISIBLE,
    INTRINSIC_SEEINVISIBLE,
    INTRINSIC_BLIND,
    INTRINSIC_DEAF,
    INTRINSIC_NOISY,
    INTRINSIC_WARNING,
    INTRINSIC_TELEPATHY,
    INTRINSIC_STRANGLE,
    INTRINSIC_NOBREATH,
    INTRINSIC_LIFESAVE,
    INTRINSIC_TIRED,
    INTRINSIC_ASLEEP,
    INTRINSIC_RESISTSLEEP,
    INTRINSIC_PARALYSED,
    INTRINSIC_FREEDOM,
    INTRINSIC_AFLAME,
    INTRINSIC_WATERWALK,
    INTRINSIC_JUMP,
    INTRINSIC_TAME,
    INTRINSIC_POSSESSED,
    INTRINSIC_BRAINDEAD,
    INTRINSIC_LEADER,
    INTRINSIC_SUMMONED,
    INTRINSIC_FAMILIAR,
    INTRINSIC_INPIT,
    INTRINSIC_INTREE,
    INTRINSIC_SUBMERGED,
    INTRINSIC_POLYMORPH,
    INTRINSIC_POLYCONTROL,
    INTRINSIC_UNIQUE,
    INTRINSIC_AMNESIA,
    INTRINSIC_OFFBALANCE,
    INTRINSIC_LICHFORM,
    INTRINSIC_SKILL_DODGE,
    INTRINSIC_SKILL_MOVINGTARGET,
    INTRINSIC_SKILL_SEARCH,
    INTRINSIC_SKILL_EVADETRAP,
    INTRINSIC_SKILL_ENDUREHUNGER,
    INTRINSIC_SKILL_BUTCHERY,
    INTRINSIC_SKILL_CLEANKILL,
    INTRINSIC_SKILL_CHARGE,
    INTRINSIC_SKILL_LEAPATTACK,
    INTRINSIC_SKILL_TWOWEAPON,
    INTRINSIC_SKILL_AMBIDEXTROUS,
    INTRINSIC_SKILL_ARMOUR_HELMET,
    INTRINSIC_SKILL_ARMOUR_SHIELD,
    INTRINSIC_SKILL_ARMOUR_BODY,
    INTRINSIC_SKILL_ARMOUR_BOOTS,
    INTRINSIC_SKILL_ARMOUR_CLOTH,
    INTRINSIC_SKILL_ARMOUR_LEATHER,
    INTRINSIC_SKILL_ARMOUR_IRON,
    INTRINSIC_SKILL_ARMOUR_EXOTIC,
    INTRINSIC_SKILL_WEAPON_SMALL,
    INTRINSIC_SKILL_WEAPON_MEDIUM,
    INTRINSIC_SKILL_WEAPON_LARGE,
    INTRINSIC_SKILL_WEAPON_RANGED,
    INTRINSIC_SKILL_WEAPON_EDGED,
    INTRINSIC_SKILL_WEAPON_BLUNT,
    INTRINSIC_SKILL_WEAPON_POINTED,
    INTRINSIC_SKILL_WEAPON_IMPROVISE,
    INTRINSIC_SKILL_WEAPON_BLEEDINGWOUND,
    INTRINSIC_SKILL_WEAPON_DISARM,
    INTRINSIC_SKILL_WEAPON_IMPALE,
    INTRINSIC_SKILL_WEAPON_RIPOSTE,
    INTRINSIC_SKILL_WEAPON_TRUEAIM,
    INTRINSIC_SKILL_WEAPON_RICOCHET,
    INTRINSIC_SKILL_WEAPON_PARRY,
    INTRINSIC_SKILL_WEAPON_KNOCKOUT,
    INTRINSIC_SKILL_WEAPON_STUN,
    INTRINSIC_SKILL_WEAPON_KNOCKBACK,
    INTRINSIC_SPELL_FLASH,
    INTRINSIC_SPELL_STICKYFLAMES,
    INTRINSIC_SPELL_MAGICMISSILE,
    INTRINSIC_SPELL_CHILL,
    INTRINSIC_SPELL_SPARK,
    INTRINSIC_SPELL_FROSTBOLT,
    INTRINSIC_SPELL_LIVINGFROST,
    INTRINSIC_SPELL_BLIZZARD,
    INTRINSIC_SPELL_FIREBALL,
    INTRINSIC_SPELL_FLAMESTRIKE,
    INTRINSIC_SPELL_LIGHTNINGBOLT,
    INTRINSIC_SPELL_CHAINLIGHTNING,
    INTRINSIC_SPELL_SUNFIRE,
    INTRINSIC_SPELL_ACIDSPLASH,
    INTRINSIC_SPELL_ACIDICMIST,
    INTRINSIC_SPELL_CORROSIVEEXPLOSION,
    INTRINSIC_SPELL_ACIDPOOL,
    INTRINSIC_SPELL_MINDACID,
    INTRINSIC_SPELL_DISINTEGRATE,
    INTRINSIC_SPELL_REGENERATE,
    INTRINSIC_SPELL_SLOWPOISON,
    INTRINSIC_SPELL_HEAL,
    INTRINSIC_SPELL_CUREPOISON,
    INTRINSIC_SPELL_MAJORHEAL,
    INTRINSIC_SPELL_RESURRECT,
    INTRINSIC_SPELL_SUMMON_FAMILIAR,
    INTRINSIC_SPELL_TRANSFER_KNOWLEDGE,
    INTRINSIC_SPELL_LIGHT,
    INTRINSIC_SPELL_FORCEBOLT,
    INTRINSIC_SPELL_FORCEWALL,
    INTRINSIC_SPELL_DIG,
    INTRINSIC_SPELL_CREATEPIT,
    INTRINSIC_SPELL_SANDSTORM,
    INTRINSIC_SPELL_GROWFOREST,
    INTRINSIC_SPELL_ANIMATEFOREST,
    INTRINSIC_SPELL_DOWNPOUR,
    INTRINSIC_SPELL_ROLLINGBOULDER,
    INTRINSIC_SPELL_ENTOMB,
    INTRINSIC_SPELL_KNOCK,
    INTRINSIC_SPELL_TRACK,
    INTRINSIC_SPELL_WIZARDSEYE,
    INTRINSIC_SPELL_DIAGNOSE,
    INTRINSIC_SPELL_POSSESS,
    INTRINSIC_SPELL_PRESERVE,
    INTRINSIC_SPELL_MAGICMAP,
    INTRINSIC_SPELL_TELEPORT,
    INTRINSIC_SPELL_BLINK,
    INTRINSIC_SPELL_FETCH,
    INTRINSIC_SPELL_IDENTIFY,
    INTRINSIC_SPELL_DETECTCURSE,
    INTRINSIC_SPELL_DIRECTWIND,
    INTRINSIC_SPELL_PETRIFY,
    INTRINSIC_SPELL_FINGEROFDEATH,
    INTRINSIC_SPELL_POISONITEM,
    INTRINSIC_SPELL_POISONBOLT,
    INTRINSIC_SPELL_RAISE_UNDEAD,
    INTRINSIC_SPELL_RECLAIM_SOUL,
    INTRINSIC_SPELL_DARK_RITUAL,
    INTRINSIC_SPELL_GHASTIFY,
    INTRINSIC_SPELL_BINDSOUL,
    INTRINSIC_SPELL_SOULSUCK,
    INTRINSIC_SPELL_SUMMON_IMP,
    INTRINSIC_SPELL_SUMMON_DEMON,
    INTRINSIC_SPELL_CLOUDKILL,
    INTRINSIC_POISON_MILD,
    INTRINSIC_POISON_NORMAL,
    INTRINSIC_POISON_STRONG,
    INTRINSIC_POISON_HARSH,
    INTRINSIC_POISON_DEADLY,
    INTRINSIC_DRESSED_WIZARD,
    INTRINSIC_DRESSED_RANGER,
    INTRINSIC_DRESSED_FIGHTER,
    INTRINSIC_DRESSED_CLERIC,
    INTRINSIC_DRESSED_NECROMANCER,
    INTRINSIC_DRESSED_BARBARIAN,
    NUM_INTRINSICS
};

// Macros for INTRINSIC
#define FOREACH_INTRINSIC(x) \
    for ((x) = (INTRINSIC_NAMES) 0; \
         (x) < NUM_INTRINSICS; \
         (x) = (INTRINSIC_NAMES) ((int)(x)+1))

struct INTRINSIC_DEF
{
    const char *name;
    const char *gaintxt;
    const char *losetxt;
    u8 maxcount;
    u8 resistance;
    bool clearondeath : 1;
    bool survivepoly : 1;
    bool surviveunpoly : 1;
    bool clearonpoly : 1;
    bool visiblechange : 1;
    bool maskchangeifclothed : 1;
    bool ispoison : 1;
    bool isspell : 1;
    bool isskill : 1;
    bool affectappearance : 1;
    bool losewheninflictordies : 1;
};

extern const INTRINSIC_DEF glb_intrinsicdefs[];

// Definitions for ELEMENT
enum ELEMENT_NAMES
{
    ELEMENT_PHYSICAL,
    ELEMENT_FIRE,
    ELEMENT_COLD,
    ELEMENT_SHOCK,
    ELEMENT_ACID,
    ELEMENT_LIGHT,
    ELEMENT_DEATH,
    ELEMENT_POISON,
    ELEMENT_REFLECTIVITY,
    ELEMENT_SLEEP,
    NUM_ELEMENTS
};

// Macros for ELEMENT
#define FOREACH_ELEMENT(x) \
    for ((x) = (ELEMENT_NAMES) 0; \
         (x) < NUM_ELEMENTS; \
         (x) = (ELEMENT_NAMES) ((int)(x)+1))

struct ELEMENT_DEF
{
    const char *name;
};

extern const ELEMENT_DEF glb_elementdefs[];

// Definitions for CURSECHANCE
enum CURSECHANCE_NAMES
{
    CURSECHANCE_ALWAYSCURSE,
    CURSECHANCE_OFTENCURSE,
    CURSECHANCE_NORMAL,
    CURSECHANCE_OFTENBLESS,
    CURSECHANCE_ALWAYSBLESS,
    CURSECHANCE_ALWAYSMUNDANE,
    NUM_CURSECHANCES
};

// Macros for CURSECHANCE
#define FOREACH_CURSECHANCE(x) \
    for ((x) = (CURSECHANCE_NAMES) 0; \
         (x) < NUM_CURSECHANCES; \
         (x) = (CURSECHANCE_NAMES) ((int)(x)+1))

struct CURSECHANCE_DEF
{
    u8 curse;
    u8 normal;
    u8 bless;
};

extern const CURSECHANCE_DEF glb_cursechancedefs[];

// Definitions for MOVE
enum MOVE_NAMES
{
    MOVE_NONE = 0,
    MOVE_WALK = 1,
    MOVE_SWIM = 2,
    MOVE_FLY = 4,
    MOVE_PHASE = 8,
    MOVE_OTHER = 16,
    MOVE_STD_SWIM = 3,
    MOVE_STD_FLY = 7,
    MOVE_STD_PHASE = 13,
    MOVE_ALL = 31,
    NUM_MOVES
};

// Macros for MOVE
#define FOREACH_MOVE(x) \
    for ((x) = (MOVE_NAMES) 0; \
         (x) < NUM_MOVES; \
         (x) = (MOVE_NAMES) ((int)(x)+1))

// Definitions for SQUAREFLAG
enum SQUAREFLAG_NAMES
{
    SQUAREFLAG_NONE = 0,
    SQUAREFLAG_LIT = 1,
    SQUAREFLAG_TEMPLIT = 2,
    SQUAREFLAG_MAPPED = 4,
    SQUAREFLAG_TRAPPED = 8,
    SQUAREFLAG_FOV = 16,
    SQUAREFLAG_SMOKE = 32,
    SQUAREFLAG_NOMOB = 64,
    NUM_SQUAREFLAGS
};

// Macros for SQUAREFLAG
#define FOREACH_SQUAREFLAG(x) \
    for ((x) = (SQUAREFLAG_NAMES) 0; \
         (x) < NUM_SQUAREFLAGS; \
         (x) = (SQUAREFLAG_NAMES) ((int)(x)+1))

// Definitions for MAPFLAG
enum MAPFLAG_NAMES
{
    MAPFLAG_NONE = 0,
    MAPFLAG_DIG = 1,
    MAPFLAG_NEWMOBS = 2,
    MAPFLAG_NOITEMS = 4,
    MAPFLAG_NOTELE = 8,
    NUM_MAPFLAGS
};

// Macros for MAPFLAG
#define FOREACH_MAPFLAG(x) \
    for ((x) = (MAPFLAG_NAMES) 0; \
         (x) < NUM_MAPFLAGS; \
         (x) = (MAPFLAG_NAMES) ((int)(x)+1))

// Definitions for SMOKE
enum SMOKE_NAMES
{
    SMOKE_NONE,
    SMOKE_SMOKE,
    SMOKE_STEAM,
    SMOKE_POISON,
    SMOKE_ACID,
    NUM_SMOKES
};

// Macros for SMOKE
#define FOREACH_SMOKE(x) \
    for ((x) = (SMOKE_NAMES) 0; \
         (x) < NUM_SMOKES; \
         (x) = (SMOKE_NAMES) ((int)(x)+1))

struct SMOKE_DEF
{
    const char *name;
    u16 tile;
    u8 attack;
    u8 decayrate;
};

extern const SMOKE_DEF glb_smokedefs[];

// Definitions for SQUARE
enum SQUARE_NAMES
{
    SQUARE_EMPTY = 0,
    SQUARE_WALL,
    SQUARE_METALWALL,
    SQUARE_VIEWPORT,
    SQUARE_BROKENVIEWPORT,
    SQUARE_METALFLOOR,
    SQUARE_DIMDOOR,
    SQUARE_REINFORCEDWALL,
    SQUARE_STARS1,
    SQUARE_STARS2,
    SQUARE_STARS3,
    SQUARE_STARS4,
    SQUARE_STARS5,
    SQUARE_FLOOR,
    SQUARE_FLOORALTAR,
    SQUARE_FLOORHOLE,
    SQUARE_PATHHOLE,
    SQUARE_WATER,
    SQUARE_ICE,
    SQUARE_DOOR,
    SQUARE_BLOCKEDDOOR,
    SQUARE_MAGICDOOR,
    SQUARE_OPENDOOR,
    SQUARE_SECRETDOOR,
    SQUARE_CORRIDOR,
    SQUARE_LADDERDOWN,
    SQUARE_LADDERUP,
    SQUARE_FLOORPIT,
    SQUARE_PATHPIT,
    SQUARE_FLOORSPIKEDPIT,
    SQUARE_PATHSPIKEDPIT,
    SQUARE_SECRETFLOORSPIKEDPIT,
    SQUARE_SECRETPATHSPIKEDPIT,
    SQUARE_SECRETFLOORPIT,
    SQUARE_SECRETPATHPIT,
    SQUARE_SECRETFLOORHOLE,
    SQUARE_SECRETPATHHOLE,
    SQUARE_FLOORPOISONVENT,
    SQUARE_PATHPOISONVENT,
    SQUARE_FLOORSMOKEVENT,
    SQUARE_PATHSMOKEVENT,
    SQUARE_SECRETFLOORPOISONVENT,
    SQUARE_SECRETFLOORSMOKEVENT,
    SQUARE_SECRETPATHPOISONVENT,
    SQUARE_SECRETPATHSMOKEVENT,
    SQUARE_PATHTELEPORTER,
    SQUARE_FLOORTELEPORTER,
    SQUARE_SECRETFLOORTELEPORTER,
    SQUARE_SECRETPATHTELEPORTER,
    SQUARE_LAVA,
    SQUARE_ACID,
    SQUARE_GRASS,
    SQUARE_MOUNTAIN,
    SQUARE_HILLS,
    SQUARE_FOREST,
    SQUARE_FORESTFIRE,
    SQUARE_SIGNPOST,
    NUM_SQUARES
};

// Macros for SQUARE
#define FOREACH_SQUARE(x) \
    for ((x) = (SQUARE_NAMES) 0; \
         (x) < NUM_SQUARES; \
         (x) = (SQUARE_NAMES) ((int)(x)+1))

struct SQUARE_DEF
{
    const char *description;
    u16 tile;
    u8 trap;
    u8 movetype;
    u8 minicolour;
    u8 findchance;
    u8 hiddensquare;
    u8 invissquare;
    u8 disarmsquare;
    u8 submergeattack;
    bool invulnerable : 1;
    bool transparent : 1;
    bool promptclimb : 1;
    bool islit : 1;
    bool isforest : 1;
    bool isstars : 1;
};

extern const SQUARE_DEF glb_squaredefs[];

// Definitions for DEATHMSG
enum DEATHMSG_NAMES
{
    DEATHMSG_BLOOD,
    DEATHMSG_DUST,
    DEATHMSG_WOOD,
    DEATHMSG_SPARK,
    DEATHMSG_ICHOR,
    DEATHMSG_FLAME,
    DEATHMSG_WATER,
    DEATHMSG_INCORPREAL,
    NUM_DEATHMSGS
};

// Macros for DEATHMSG
#define FOREACH_DEATHMSG(x) \
    for ((x) = (DEATHMSG_NAMES) 0; \
         (x) < NUM_DEATHMSGS; \
         (x) = (DEATHMSG_NAMES) ((int)(x)+1))

struct DEATHMSG_DEF
{
    const char *msglist;
};

extern const DEATHMSG_DEF glb_deathmsgdefs[];

// Definitions for DEATHMSG_MSG
enum DEATHMSG_MSG_NAMES
{
    DEATHMSG_MSG_NONE = 0,
    DEATHMSG_MSG_DIE,
    DEATHMSG_MSG_HEAP,
    DEATHMSG_MSG_BLOOD,
    DEATHMSG_MSG_DUST,
    DEATHMSG_MSG_WOOD,
    DEATHMSG_MSG_SPARK,
    DEATHMSG_MSG_ICHOR,
    DEATHMSG_MSG_FLAME,
    DEATHMSG_MSG_FADE,
    DEATHMSG_MSG_WISP,
    DEATHMSG_MSG_WATER,
    NUM_DEATHMSG_MSGS
};

// Macros for DEATHMSG_MSG
#define FOREACH_DEATHMSG_MSG(x) \
    for ((x) = (DEATHMSG_MSG_NAMES) 0; \
         (x) < NUM_DEATHMSG_MSGS; \
         (x) = (DEATHMSG_MSG_NAMES) ((int)(x)+1))

struct DEATHMSG_MSG_DEF
{
    const char *msg;
};

extern const DEATHMSG_MSG_DEF glb_deathmsg_msgdefs[];

// Definitions for HUNGER
enum HUNGER_NAMES
{
    HUNGER_STARVING,
    HUNGER_HUNGRY,
    HUNGER_FORAGE,
    HUNGER_NORMAL,
    HUNGER_FULL,
    NUM_HUNGERS
};

// Macros for HUNGER
#define FOREACH_HUNGER(x) \
    for ((x) = (HUNGER_NAMES) 0; \
         (x) < NUM_HUNGERS; \
         (x) = (HUNGER_NAMES) ((int)(x)+1))

struct HUNGER_DEF
{
    const char *name;
    u16 foodlevel;
};

extern const HUNGER_DEF glb_hungerdefs[];

// Definitions for COLOUR
enum COLOUR_NAMES
{
    COLOUR_INVISIBLE = 0,
    COLOUR_BLACK,
    COLOUR_LIGHTBLACK,
    COLOUR_WHITE,
    COLOUR_RED,
    COLOUR_LIGHTRED,
    COLOUR_GREEN,
    COLOUR_LIGHTGREEN,
    COLOUR_BLUE,
    COLOUR_YELLOW,
    COLOUR_LIGHTYELLOW,
    COLOUR_CYAN,
    COLOUR_MAGENTA,
    COLOUR_GREY,
    COLOUR_BROWN,
    COLOUR_DARKGREEN,
    COLOUR_DARKRED,
    NUM_COLOURS
};

// Macros for COLOUR
#define FOREACH_COLOUR(x) \
    for ((x) = (COLOUR_NAMES) 0; \
         (x) < NUM_COLOURS; \
         (x) = (COLOUR_NAMES) ((int)(x)+1))

struct COLOUR_DEF
{
    u8 red;
    u8 green;
    u8 blue;
};

extern const COLOUR_DEF glb_colourdefs[];

// Definitions for TRAP
enum TRAP_NAMES
{
    TRAP_NONE,
    TRAP_HOLE,
    TRAP_PIT,
    TRAP_SPIKEDPIT,
    TRAP_SMOKEVENT,
    TRAP_POISONVENT,
    TRAP_TELEPORT,
    NUM_TRAPS
};

// Macros for TRAP
#define FOREACH_TRAP(x) \
    for ((x) = (TRAP_NAMES) 0; \
         (x) < NUM_TRAPS; \
         (x) = (TRAP_NAMES) ((int)(x)+1))

struct TRAP_DEF
{
    const char *name;
    u8 attack;
    u8 triggerchance;
    u8 moveevade;
    u8 level;
};

extern const TRAP_DEF glb_trapdefs[];

// Definitions for MINI
enum MINI_NAMES
{
    MINI_NAKED,
    MINI_HELM,
    MINI_HAT,
    MINI_BLUEROBE,
    MINI_LEATHERTUNIC,
    MINI_STUDDEDTUNIC,
    MINI_CHAINTUNIC,
    MINI_SWORD,
    MINI_CLUB,
    MINI_MACE,
    MINI_REDSHIELD,
    MINI_SANDALS,
    MINI_BOOTS,
    MINI_LEATHERHELM,
    MINI_SILVERCIRCLET,
    MINI_CRYSTALPLATE,
    MINI_FEATHEREDHELM,
    MINI_PLATEMAIL,
    MINI_FLAMINGSWORD,
    MINI_WARHAMMER,
    MINI_SPEAR,
    MINI_MIRRORSHIELD,
    MINI_TOWERSHIELD,
    MINI_WOODENSHIELD,
    MINI_BUCKLER,
    MINI_ROUNDSHIELD,
    MINI_TORCH,
    MINI_IRONSHOES,
    MINI_POINTEDSLIPPERS,
    MINI_RIDINGBOOTS,
    MINI_WINGEDBOOTS,
    MINI_STAFF,
    MINI_POTION,
    MINI_BOW,
    MINI_GOLDCROWN,
    MINI_CLOGS,
    MINI_MINDACIDHAND,
    MINI_BOOK,
    MINI_SCROLL,
    MINI_SHORTSWORD,
    MINI_DAGGER,
    MINI_KNIFE,
    MINI_PEARLNECKLACE,
    MINI_GOLDNECKLACE,
    MINI_RUBYNECKLACE,
    MINI_IRONTORC,
    MINI_STUDDEDGORGET,
    MINI_WAND,
    MINI_LIGHTNINGRAPIER,
    MINI_ICEMACE,
    MINI_RAPIER,
    MINI_EARTHHAMMER,
    MINI_NAKEDPOISON,
    MINI_NAKEDSTONE,
    MINI_NONE,
    NUM_MINIS
};

// Macros for MINI
#define FOREACH_MINI(x) \
    for ((x) = (MINI_NAMES) 0; \
         (x) < NUM_MINIS; \
         (x) = (MINI_NAMES) ((int)(x)+1))

struct MINI_DEF
{
    u8 slot;
};

extern const MINI_DEF glb_minidefs[];

// Definitions for SPRITE
enum SPRITE_NAMES
{
    SPRITE_INVALID = 65535,
    SPRITE_EQUIP = 0,
    SPRITE_DEQUIP,
    SPRITE_DROP,
    SPRITE_EAT,
    SPRITE_BREATHE,
    SPRITE_WALK,
    SPRITE_LOOK,
    SPRITE_QUAFF,
    SPRITE_READ,
    SPRITE_ZAP,
    SPRITE_FIRE,
    SPRITE_QUIVER,
    SPRITE_HELP,
    SPRITE_UNUSED,
    SPRITE_DIP,
    SPRITE_OPEN,
    SPRITE_CLOSE,
    SPRITE_HISTORY,
    SPRITE_INVENTORY,
    SPRITE_CLIMB,
    SPRITE_PICKUP,
    SPRITE_NAME,
    SPRITE_FORGET,
    SPRITE_MINIMAP,
    SPRITE_NORTH,
    SPRITE_SOUTH,
    SPRITE_EAST,
    SPRITE_WEST,
    SPRITE_NORTHWEST,
    SPRITE_NORTHEAST,
    SPRITE_SOUTHEAST,
    SPRITE_SOUTHWEST,
    SPRITE_UP,
    SPRITE_DOWN,
    SPRITE_TEXT,
    SPRITE_TILE,
    SPRITE_CANCEL,
    SPRITE_VOID,
    SPRITE_CURSOR,
    SPRITE_COMMAND,
    SPRITE_PRAY,
    SPRITE_SORT,
    SPRITE_SLEEP,
    SPRITE_SPLITSTACK,
    SPRITE_JUMP,
    SPRITE_SWAP,
    SPRITE_VERBLIST,
    SPRITE_OPTIONS,
    SPRITE_RELEASE,
    SPRITE_WAIT,
    SPRITE_SEARCH,
    SPRITE_EMPTYSLOT,
    SPRITE_UNUSEDSPELL,
    SPRITE_STICKYFLAMES,
    SPRITE_MAGICMISSILE,
    SPRITE_CHILL,
    SPRITE_SPARK,
    SPRITE_FROSTBOLT,
    SPRITE_LIVINGFROST,
    SPRITE_BLIZZARD,
    SPRITE_FIREBALL,
    SPRITE_FLAMESTRIKE,
    SPRITE_LIGHTNINGBOLT,
    SPRITE_CHAINLIGHTNING,
    SPRITE_SUNFIRE,
    SPRITE_ACIDSPLASH,
    SPRITE_ACIDICMIST,
    SPRITE_CORROSIVEEXPLOSION,
    SPRITE_ACIDPOOL,
    SPRITE_MINDACID,
    SPRITE_DISINTEGRATE,
    SPRITE_REGENERATE,
    SPRITE_SLOWPOISON,
    SPRITE_HEAL,
    SPRITE_CUREPOISON,
    SPRITE_MAJORHEAL,
    SPRITE_RESURRECT,
    SPRITE_SUMMON_FAMILIAR,
    SPRITE_TRANSFER_KNOWLEDGE,
    SPRITE_LIGHT,
    SPRITE_DARKNESS,
    SPRITE_KNOCK,
    SPRITE_TRACK,
    SPRITE_WIZARDSEYE,
    SPRITE_DIAGNOSE,
    SPRITE_PRESERVE,
    SPRITE_POSSESS,
    SPRITE_MAGICMAP,
    SPRITE_DETECTCURSE,
    SPRITE_IDENTIFY,
    SPRITE_BLINK,
    SPRITE_FETCH,
    SPRITE_TELEPORT,
    SPRITE_TELEWITHCONTROL,
    SPRITE_DIRECTWIND,
    SPRITE_FORCEBOLT,
    SPRITE_FORCEWALL,
    SPRITE_DIG,
    SPRITE_CREATEPIT,
    SPRITE_ROLLINGBOULDER,
    SPRITE_PETRIFY,
    SPRITE_STONETOFLESH,
    SPRITE_ENTOMB,
    SPRITE_RAISE_UNDEAD,
    SPRITE_RECLAIM_SOUL,
    SPRITE_DARK_RITUAL,
    SPRITE_POISONITEM,
    SPRITE_POISONBOLT,
    SPRITE_GHASTIFY,
    SPRITE_BINDSOUL,
    SPRITE_SOULSUCK,
    SPRITE_SUMMON_IMP,
    SPRITE_SUMMON_DEMON,
    SPRITE_CLOUDKILL,
    SPRITE_FINGEROFDEATH,
    SPRITE_YESWAY,
    SPRITE_NOWAY,
    SPRITE_WISH,
    SPRITE_FLASH,
    SPRITE_GROWFOREST,
    SPRITE_DOWNPOUR,
    SPRITE_SPELLREADY,
    SPRITE_ANIMATEFOREST,
    SPRITE_SANDSTORM,
    NUM_SPRITES
};

// Macros for SPRITE
#define FOREACH_SPRITE(x) \
    for ((x) = (SPRITE_NAMES) 0; \
         (x) < NUM_SPRITES; \
         (x) = (SPRITE_NAMES) ((int)(x)+1))

// Definitions for TILE
enum TILE_NAMES
{
    TILE_INVALID = 65535,
    TILE_VOID = 0,
    TILE_FLOOR,
    TILE_WALL,
    TILE_DOOR,
    TILE_AVATAR,
    TILE_LONGSWORD,
    TILE_SHIELD,
    TILE_GREENDRAGON,
    TILE_PATH,
    TILE_WATER,
    TILE_OPENDOOR,
    TILE_TRIDUDE,
    TILE_FIREBEETLE,
    TILE_SHADOW,
    TILE_LADDERDOWN,
    TILE_LADDERUP,
    TILE_ICESNAKE,
    TILE_FIRESNAKE,
    TILE_RAT,
    TILE_BLOOD,
    TILE_GRIDBUG,
    TILE_SHITOMI,
    TILE_BOOT,
    TILE_SANDAL,
    TILE_WELL,
    TILE_LUX,
    TILE_PURPLESLUG,
    TILE_BLUEPOTION,
    TILE_CURSOR,
    TILE_EMPTYSLOT,
    TILE_HELM,
    TILE_BOTTLE,
    TILE_CHAINTUNIC,
    TILE_BLUEROBE,
    TILE_LEATHERTUNIC,
    TILE_STUDDEDTUNIC,
    TILE_PURPLEPOTION,
    TILE_BOULDER,
    TILE_SCROLL,
    TILE_SILVERRING,
    TILE_IRONRING,
    TILE_WOODENRING,
    TILE_GLASSRING,
    TILE_RUBYRING,
    TILE_DAEMON,
    TILE_DIAMONDRING,
    TILE_EMERALDRING,
    TILE_SAPPHIRERING,
    TILE_GOLDRING,
    TILE_AMETHYSTRING,
    TILE_CLEARPOTION,
    TILE_MOBIUSRING,
    TILE_BAEZLEBUBUL,
    TILE_BAEZLEBUBUR,
    TILE_STONERING,
    TILE_AQUAMARINERING,
    TILE_BLUEDRAGON,
    TILE_PLATETUNIC,
    TILE_GLASSTUNIC,
    TILE_INVISIBLESTALKER,
    TILE_REDPOTION,
    TILE_YELLOWPOTION,
    TILE_GREYPOTION,
    TILE_WHITEPOTION,
    TILE_BLACKPOTION,
    TILE_CYANPOTION,
    TILE_RAYSLASH,
    TILE_RAYPIPE,
    TILE_RAYDASH,
    TILE_RAYBACKSLASH,
    TILE_PEARLNECKLACE,
    TILE_GOLDNECKLACE,
    TILE_RUBYNECKLACE,
    TILE_GIANTRAT,
    TILE_WOODENWAND,
    TILE_GLASSWAND,
    TILE_BAEZLEBUBLL,
    TILE_BAEZLEBUBLR,
    TILE_SILVERWAND,
    TILE_IRONWAND,
    TILE_CURVEDWAND,
    TILE_FORKEDWAND,
    TILE_KIWI,
    TILE_BAT,
    TILE_LARGEBAT,
    TILE_BROWNSLUG,
    TILE_DEATHSLUG,
    TILE_SOLIDEARTH,
    TILE_CRETAN_MINOTAUR_UL,
    TILE_CRETAN_MINOTAUR_UR,
    TILE_GOLDTRIDUDE_UL,
    TILE_GOLDTRIDUDE_UR,
    TILE_HUGE3_UL,
    TILE_HUGE3_UR,
    TILE_HUGE4_UL,
    TILE_HUGE4_UR,
    TILE_SILVERSWORD,
    TILE_WARHAMMER,
    TILE_SILVERDAGGER,
    TILE_DAGGER,
    TILE_SPEAR,
    TILE_SILVERSPEAR,
    TILE_CLUB,
    TILE_FLAMINGSWORD,
    TILE_MACE,
    TILE_SHORTSWORD,
    TILE_KNIFE,
    TILE_NOTILE,
    TILE_FLOATINGEYE,
    TILE_SCORPION,
    TILE_CAVESPIDER,
    TILE_GIANTSPIDER,
    TILE_CRETAN_MINOTAUR_LL,
    TILE_CRETAN_MINOTAUR_LR,
    TILE_GOLDTRIDUDE_LL,
    TILE_GOLDTRIDUDE_LR,
    TILE_HUGE3_LL,
    TILE_HUGE3_LR,
    TILE_HUGE4_LL,
    TILE_HUGE4_LR,
    TILE_GREENSNAKE,
    TILE_IRONTORC,
    TILE_SILVERCIRCLET,
    TILE_FEATHEREDHELM,
    TILE_FLOPPYHAT,
    TILE_BLUESPELLBOOK,
    TILE_REDSPELLBOOK,
    TILE_LEATHERSPELLBOOK,
    TILE_PURPLESPELLBOOK,
    TILE_GREYSPELLBOOK,
    TILE_PLAIDSPELLBOOK,
    TILE_BLACKSPELLBOOK,
    TILE_GOLDSPELLBOOK,
    TILE_THINBLUESPELLBOOK,
    TILE_LOCKEDSPELLBOOK,
    TILE_BLUERUNEDSPELLBOOK,
    TILE_REDRUNEDSPELLBOOK,
    TILE_LEATHERRUNEDSPELLBOOK,
    TILE_PURPLERUNEDSPELLBOOK,
    TILE_GREYRUNEDSPELLBOOK,
    TILE_JEWELEDWAND,
    TILE_TWISTEDWAND,
    TILE_FLOORHOLE,
    TILE_PATHHOLE,
    TILE_PATHPIT,
    TILE_WHITESPELLBOOK,
    TILE_BLOODYSPELLBOOK,
    TILE_GLASSSPELLBOOK,
    TILE_THINREDSPELLBOOK,
    TILE_WHITEDRAGON,
    TILE_REDDRAGON,
    TILE_ICEDAEMON,
    TILE_PATHSPIKEDPIT,
    TILE_FLOORPIT,
    TILE_FLOORSPIKEDPIT,
    TILE_LAVA,
    TILE_ICE,
    TILE_TORCH,
    TILE_PURPLEWAND,
    TILE_POINTEDSLIPPER,
    TILE_RIDINGBOOT,
    TILE_IRONSHOE,
    TILE_WINGEDBOOT,
    TILE_FROG,
    TILE_KOBOLD,
    TILE_TROLL,
    TILE_LIZARDMAN,
    TILE_BLACKHEART,
    TILE_GRASS,
    TILE_MOUNTAIN,
    TILE_HILLS,
    TILE_FOREST,
    TILE_GELATINOUSCUBE,
    TILE_HEADLESS,
    TILE_KOBOLDMAGE,
    TILE_WOODENSTAFF,
    TILE_IRONSHODSTAFF,
    TILE_HOOKEDSTAFF,
    TILE_GNARLEDSTAFF,
    TILE_BEJEWELEDSTAFF,
    TILE_SKELETON,
    TILE_VAMPIREBAT,
    TILE_IMP,
    TILE_ZOMBIE,
    TILE_LICH,
    TILE_GHAST,
    TILE_CORPSE,
    TILE_BONES,
    TILE_STUDDEDGORGET,
    TILE_THINLEATHERSPELLBOOK,
    TILE_THINPURPLESPELLBOOK,
    TILE_THINGREYSPELLBOOK,
    TILE_JADEWAND,
    TILE_JADERING,
    TILE_INVALIDSLOT,
    TILE_CHAMELEON,
    TILE_MOUSE,
    TILE_EARTHELEMENTAL,
    TILE_IRONGOLEM,
    TILE_STONEGOLEM,
    TILE_FLESHGOLEM,
    TILE_AIRELEMENTAL,
    TILE_FIREELEMENTAL,
    TILE_WATERELEMENTAL,
    TILE_INVISIBLEAVATAR,
    TILE_STATUE,
    TILE_COCKATRICE,
    TILE_MOUNDFLESH,
    TILE_ROCK,
    TILE_MEATBALL,
    TILE_SMOKE,
    TILE_GEMENCRUSTEDWAND,
    TILE_STONEWAND,
    TILE_GOLDWAND,
    TILE_REDWAND,
    TILE_BLUEWAND,
    TILE_POISONSMOKE,
    TILE_ACIDSMOKE,
    TILE_YELLOWDRAGON,
    TILE_THINPLAIDSPELLBOOK,
    TILE_THINBLACKSPELLBOOK,
    TILE_THINGOLDSPELLBOOK,
    TILE_SHADOW_HEAR,
    TILE_SHADOW_SMELL,
    TILE_SHADOW_ESP,
    TILE_STEAMSMOKE,
    TILE_KOBOLDFIGHTER,
    TILE_CAVETROLL,
    TILE_FLOORSMOKEVENT,
    TILE_FLOORPOISONVENT,
    TILE_FLOORTELEPORTER,
    TILE_PATHSMOKEVENT,
    TILE_PATHPOISONVENT,
    TILE_PATHTELEPORTER,
    TILE_BOW,
    TILE_ARROW,
    TILE_TURTLOID,
    TILE_LARGETURTLOID,
    TILE_HILLORC,
    TILE_ORC,
    TILE_SCROLL_BACK,
    TILE_SCROLL_TOP,
    TILE_SCROLL_BOTTOM,
    TILE_UNKNOWN,
    TILE_GOLDCROWN,
    TILE_CLOGS,
    TILE_GHOST,
    TILE_ACIDPOOL,
    TILE_MINDACIDHAND,
    TILE_KOBOLDASSASSIN,
    TILE_GLOWINGPOTION,
    TILE_BROWNPOTION,
    TILE_GREENPOTION,
    TILE_LIVINGFROST,
    TILE_REINFORCEDWALL,
    TILE_FLOORALTAR,
    TILE_MAGICDOOR,
    TILE_SOULSUCKER,
    TILE_SIGNPOST,
    TILE_GOLDBEETLE,
    TILE_METALFLOOR,
    TILE_METALWALL,
    TILE_DIMDOOR,
    TILE_YRUNE,
    TILE_BLUETRIDUDE,
    TILE_REDTRIDUDE,
    TILE_PURPLETRIDUDE,
    TILE_STARS1,
    TILE_STARS2,
    TILE_STARS3,
    TILE_STARS4,
    TILE_STARS5,
    TILE_VIEWPORT,
    TILE_ONYXRING,
    TILE_RAPIER,
    TILE_FORESTFIRE,
    TILE_FIREARROW,
    TILE_LIGHTNINGRAPIER,
    TILE_ICEMACE,
    TILE_KOBOLDTHIEF,
    TILE_LEATHERHELM,
    TILE_EARTHHAMMER,
    TILE_AFLAME,
    TILE_BROKENVIEWPORT,
    TILE_LIVINGTREE,
    TILE_CURSEDSLOT,
    TILE_HOLYSLOT,
    TILE_NORMALSLOT,
    TILE_FAVORITESLOT,
    TILE_UNIQUEMOB,
    TILE_TAMEMOB,
    TILE_MIRRORSHIELD,
    TILE_TOWERSHIELD,
    TILE_KITESHIELD,
    TILE_WOODENSHIELD,
    TILE_BUCKLER,
    TILE_TRICERATOPS,
    TILE_ASLEEP,
    TILE_ELDER,
    NUM_TILES
};

// Macros for TILE
#define FOREACH_TILE(x) \
    for ((x) = (TILE_NAMES) 0; \
         (x) < NUM_TILES; \
         (x) = (TILE_NAMES) ((int)(x)+1))
#endif