// 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 POTION
enum POTION_NAMES
{
    POTION_NONE,
    POTION_HEAL,
    POTION_CURE,
    POTION_POISON,
    POTION_JUICE,
    POTION_ACID,
    POTION_SPEED,
    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;
};

extern const POTION_DEF glb_potiondefs[];

// Definitions for RING
enum RING_NAMES
{
    RING_NONE,
    RING_RESISTCOLD,
    RING_VULNCOLD,
    RING_RESISTACID,
    RING_VULNACID,
    RING_DEFLECT,
    RING_MAGNET,
    RING_SEARCH,
    RING_RESISTPOISON,
    RING_VULNPOISON,
    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;
    s16 resist_amt;
    s16 deflect;
    u8 resist;
};

extern const RING_DEF glb_ringdefs[];

// Definitions for WORLDSTATE
enum WORLDSTATE_NAMES
{
    WORLDSTATE_CHOOSEQUEST,
    WORLDSTATE_QUEST,
    WORLDSTATE_ENDQUEST,
    WORLDSTATE_WON,
    WORLDSTATE_LOST,
    NUM_WORLDSTATES
};

// Macros for WORLDSTATE
#define FOREACH_WORLDSTATE(x) \
    for ((x) = (WORLDSTATE_NAMES) 0; \
         (x) < NUM_WORLDSTATES; \
         (x) = (WORLDSTATE_NAMES) ((int)(x)+1))

struct WORLDSTATE_DEF
{
    const char *name;
};

extern const WORLDSTATE_DEF glb_worldstatedefs[];

// Definitions for QUEST
enum QUEST_NAMES
{
    QUEST_NONE,
    QUEST_GRAIN,
    QUEST_CURE,
    QUEST_WATERFILTER,
    QUEST_PASTEURIZATION,
    QUEST_FIRE,
    QUEST_BRIMSTONE,
    QUEST_POISON,
    QUEST_TREBUCHET,
    QUEST_BFG,
    NUM_QUESTS
};

// Macros for QUEST
#define FOREACH_QUEST(x) \
    for ((x) = (QUEST_NAMES) 0; \
         (x) < NUM_QUESTS; \
         (x) = (QUEST_NAMES) ((int)(x)+1))

struct QUEST_DEF
{
    const char *name;
    const char *descr;
    u8 level;
    u8 giver;
    u8 questitem;
    u8 atlas;
    u8 popgrowth;
    u8 attack;
};

extern const QUEST_DEF glb_questdefs[];

// Definitions for MAGICMOVE
enum MAGICMOVE_NAMES
{
    MAGICMOVE_NONE,
    MAGICMOVE_PIERCE,
    MAGICMOVE_BLADEWALL,
    MAGICMOVE_CHARGE,
    MAGICMOVE_LEAPATTACK,
    MAGICMOVE_FLASH,
    NUM_MAGICMOVES
};

// Macros for MAGICMOVE
#define FOREACH_MAGICMOVE(x) \
    for ((x) = (MAGICMOVE_NAMES) 0; \
         (x) < NUM_MAGICMOVES; \
         (x) = (MAGICMOVE_NAMES) ((int)(x)+1))

struct MAGICMOVE_DEF
{
    const char *name;
    const char *pattern;
    u8 blood;
    u8 damage;
    u8 key;
};

extern const MAGICMOVE_DEF glb_magicmovedefs[];

// Definitions for SPELL
enum SPELL_NAMES
{
    SPELL_NONE,
    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;
    u8 mana;
    u8 item;
    bool needsdir : 1;
};

extern const SPELL_DEF glb_spelldefs[];

// Definitions for ITEM
enum ITEM_NAMES
{
    ITEM_NONE,
    ITEM_CORPSE,
    ITEM_GOLD,
    ITEM_ARROW,
    ITEM_QUICKBOOST,
    ITEM_BLIND,
    ITEM_ENRAGED,
    ITEM_POISON,
    ITEM_PLAGUE,
    ITEM_SLOW,
    ITEM_SAUSAGES,
    ITEM_BREAD,
    ITEM_MUSHROOMS,
    ITEM_APPLE,
    ITEM_PICKLE,
    ITEM_INVULNERABLE,
    ITEM_CRUDEBOW,
    ITEM_SHORTBOW,
    ITEM_LONGBOW,
    ITEM_YEWLONGBOW,
    ITEM_KNIFE,
    ITEM_FREYBLADE,
    ITEM_KOBOLDDAGGER,
    ITEM_BRONZESWORD,
    ITEM_IRONSHODSTAFF,
    ITEM_IRONSWORD,
    ITEM_MACE,
    ITEM_STEELSWORD,
    ITEM_WARHAMMER,
    ITEM_CRYSTALSWORD,
    ITEM_CLOTHES,
    ITEM_ARMOUR_LEATHER,
    ITEM_ARMOUR_STUDDEDLEATHER,
    ITEM_ARMOUR_RINGMAIL,
    ITEM_ARMOUR_CHAIN,
    ITEM_ARMOUR_BREASTPLATE,
    ITEM_ARMOUR_PLATE,
    ITEM_ARMOUR_FULLPLATE,
    ITEM_PACIFIER,
    ITEM_DOLL,
    ITEM_TEDDY,
    ITEM_RAG,
    ITEM_QUEST_CURE,
    ITEM_QUEST_GRAIN,
    ITEM_QUEST_WATERFILTER,
    ITEM_QUEST_PASTEURIZATION,
    ITEM_QUEST_FIRESCROLL,
    ITEM_QUEST_EXPLOSIVE,
    ITEM_QUEST_POISON,
    ITEM_QUEST_TREBUCHET,
    ITEM_QUEST_BFG,
    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;
    const char *gaintxt;
    const char *losetxt;
    const char *melee_verb;
    const char *range_verb;
    s16 timer;
    s16 rarity;
    s16 depth;
    s16 ac;
    s16 repaircost;
    u8 symbol;
    u8 attr;
    u8 startstack;
    u8 melee_power;
    u8 melee_consistency;
    u8 melee_accuracy;
    u8 range_range;
    u8 range_power;
    u8 range_consistency;
    u8 range_area;
    u8 range_symbol;
    u8 range_attr;
    u8 ammo;
    bool isflag : 1;
    bool exclusive : 1;
    bool isfood : 1;
    bool ispotion : 1;
    bool isring : 1;
    bool needtarget : 1;
    bool unstackable : 1;
    bool startsbroken : 1;
    bool discardextra : 1;
};

extern const ITEM_DEF glb_itemdefs[];

// Definitions for MOB
enum MOB_NAMES
{
    MOB_NONE,
    MOB_AVATAR,
    MOB_KING,
    MOB_MAPSHOP,
    MOB_ADVISOR_PEACE,
    MOB_ADVISOR_WAR,
    MOB_GUARD,
    MOB_SERVANT,
    MOB_RAT,
    MOB_BAT,
    MOB_GOBLIN,
    MOB_GOBLIN_GUARD,
    MOB_GOBLIN_QUEEN,
    MOB_KOBOLD,
    MOB_KOBOLD_ARCHER,
    MOB_KOBOLD_GUARD,
    MOB_KOBOLD_CHIEF,
    MOB_KOBOLD_BABY,
    MOB_SLIME,
    MOB_BIGSLIME,
    MOB_GIANTSLIME,
    MOB_SLUG,
    MOB_SKELETON,
    MOB_ZOMBIE,
    MOB_SKELETONCAPTAIN,
    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;
    const char *melee_name;
    const char *melee_verb;
    DICE melee_damage;
    const char *range_name;
    const char *range_verb;
    DICE range_damage;
    u8 symbol;
    u8 attr;
    u8 melee_chance;
    u8 melee_item;
    u8 melee_element;
    u8 range_range;
    u8 range_symbol;
    u8 range_chance;
    u8 range_attr;
    u8 range_element;
    u8 max_hp;
    u8 max_mp;
    u8 depth;
    u8 rarity;
    u8 ai;
    u8 sightrange;
    bool isfriendly : 1;
    bool range_valid : 1;
    bool isslow : 1;
    bool isfast : 1;
    bool isvampire : 1;
    bool hidefromlos : 1;
    bool isregenerate : 1;
    bool passwall : 1;
    bool candig : 1;
    bool swallows : 1;
    bool breeder : 1;
    bool isthief : 1;
    bool canleap : 1;
    bool isundead : 1;
};

extern const MOB_DEF glb_mobdefs[];

// Definitions for AI
enum AI_NAMES
{
    AI_NONE,
    AI_STAYHOME,
    AI_HOME,
    AI_CHARGE,
    AI_RAT,
    AI_STRAIGHTLINE,
    AI_PATHTO,
    AI_ORTHO,
    AI_FLANK,
    AI_RANGECOWARD,
    AI_COWARD,
    AI_MOUSE,
    AI_SMARTKOBOLD,
    NUM_AIS
};

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

// Definitions for TILE
enum TILE_NAMES
{
    TILE_INVALID,
    TILE_NONE,
    TILE_STATUE,
    TILE_ALTAR,
    TILE_THRONE,
    TILE_FLOOR,
    TILE_CHAIR,
    TILE_TABLE,
    TILE_MAPTABLE,
    TILE_DOWNSTAIRS,
    TILE_UPSTAIRS,
    TILE_LAVENDERCARPET,
    TILE_GREENCARPET,
    TILE_SNOWYPATH,
    TILE_PATH,
    TILE_GRASS,
    TILE_MEDITATIONSPOT,
    TILE_FIELD,
    TILE_FROZENFIELD,
    TILE_FORGE,
    TILE_FIRE,
    TILE_WALL,
    TILE_CITY_RED,
    TILE_CITY_VIOLET,
    TILE_DESERT,
    TILE_WOODWALL,
    TILE_SOLIDWALL,
    TILE_PORTAL,
    TILE_ORANGEPORTAL,
    TILE_BLUEPORTAL,
    TILE_MOUNTAINPROTOPORTAL,
    TILE_PROTOPORTAL,
    TILE_USERPROTOPORTAL,
    TILE_BROKENWALL,
    TILE_DOOR,
    TILE_SECRETDOOR,
    TILE_MOUNTAIN,
    TILE_ICEMOUNTAIN,
    TILE_SNOWYPASS,
    TILE_BED,
    TILE_WINDOW,
    TILE_PORTCULLIS,
    TILE_CHEST,
    TILE_BRIDGE,
    TILE_WATER,
    TILE_ICE,
    TILE_FOREST,
    TILE_BAREFOREST,
    NUM_TILES
};

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

struct TILE_DEF
{
    const char *legend;
    u8 symbol;
    u8 attr;
    u8 shop;
    u8 armyspeed;
    bool ispassable : 1;
    bool istransparent : 1;
    bool isphaseable : 1;
    bool isdiggable : 1;
    bool roomcolor : 1;
    bool describe : 1;
    bool semitransparent : 1;
    bool forbidrandomwander : 1;
    bool validportalfloor : 1;
};

extern const TILE_DEF glb_tiledefs[];

// Definitions for EVENTTYPE
enum EVENTTYPE_NAMES
{
    EVENTTYPE_NONE = 0,
    EVENTTYPE_FORE = 1,
    EVENTTYPE_BACK = 2,
    EVENTTYPE_SYM = 4,
    EVENTTYPE_FORESYM = 5,
    EVENTTYPE_FOREBACK = 3,
    EVENTTYPE_ALL = 7,
    EVENTTYPE_SHOUT = 8,
    EVENTTYPE_LONG = 128,
    NUM_EVENTTYPES
};

// Macros for EVENTTYPE
#define FOREACH_EVENTTYPE(x) \
    for ((x) = (EVENTTYPE_NAMES) 0; \
         (x) < NUM_EVENTTYPES; \
         (x) = (EVENTTYPE_NAMES) ((int)(x)+1))

// Definitions for TRAP
enum TRAP_NAMES
{
    TRAP_ARROW,
    TRAP_LIGHT,
    TRAP_PIT,
    TRAP_FIRE,
    TRAP_ROCK,
    TRAP_BOULDER,
    TRAP_SPIKEPIT,
    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
{
    DICE damage;
    const char *name;
    u8 sym;
    u8 attr;
    u8 element;
    u8 item;
};

extern const TRAP_DEF glb_trapdefs[];

// Definitions for MAPFLAG
enum MAPFLAG_NAMES
{
    MAPFLAG_NONE = 0,
    MAPFLAG_FOV = 1,
    MAPFLAG_FOVCACHE = 2,
    MAPFLAG_PORTAL = 4,
    MAPFLAG_TRAP = 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 ATTR
enum ATTR_NAMES
{
    ATTR_NONE,
    ATTR_HEALTH,
    ATTR_MANA,
    ATTR_POWERBAR,
    ATTR_BORDER,
    ATTR_VICTORYBORDER,
    ATTR_DEATHBORDER,
    ATTR_DEATHBAR,
    ATTR_WAITBAR,
    ATTR_INVULNERABLE,
    ATTR_HILITE,
    ATTR_AVATARMEDITATE,
    ATTR_ELECTRICBLUE,
    ATTR_METAL,
    ATTR_BLUEPORTAL,
    ATTR_ORANGEPORTAL,
    ATTR_FIRE,
    ATTR_SEARCH,
    ATTR_GOLD,
    ATTR_YELLOW,
    ATTR_SHOUT,
    ATTR_EMOTE,
    ATTR_PINK,
    ATTR_PURPLE,
    ATTR_LAVENDER,
    ATTR_BG_LAVENDER,
    ATTR_BG_DKGREEN,
    ATTR_KOBOLD_ARCHER,
    ATTR_KOBOLD_MAGE,
    ATTR_KOBOLD_GUARD,
    ATTR_KOBOLD_BAKER,
    ATTR_NORMAL,
    ATTR_LIGHTBLACK,
    ATTR_OUTOFFOV,
    ATTR_WHITE,
    ATTR_ORANGE,
    ATTR_LIGHTBROWN,
    ATTR_BROWN,
    ATTR_RED,
    ATTR_CRIMSON,
    ATTR_DKRED,
    ATTR_GREEN,
    ATTR_YELLOWGREEN,
    ATTR_SLIME,
    ATTR_YELLOWSLIME,
    ATTR_GREEN_ISLE,
    ATTR_DKGREEN,
    ATTR_BLUE,
    ATTR_LIGHTBLUE,
    ATTR_TEAL,
    ATTR_CYAN,
    ATTR_DKCYAN,
    ATTR_GREY,
    NUM_ATTRS
};

// Macros for ATTR
#define FOREACH_ATTR(x) \
    for ((x) = (ATTR_NAMES) 0; \
         (x) < NUM_ATTRS; \
         (x) = (ATTR_NAMES) ((int)(x)+1))

struct ATTR_DEF
{
    u8 bg_r;
    u8 bg_g;
    u8 bg_b;
    u8 fg_r;
    u8 fg_g;
    u8 fg_b;
    bool pulse : 1;
};

extern const ATTR_DEF glb_attrdefs[];

// Definitions for GOSSIP
enum GOSSIP_NAMES
{
    GOSSIP_INTRO,
    GOSSIP_MEDITATE,
    GOSSIP_SICKNESS,
    GOSSIP_IMPASS,
    GOSSIP_COLD,
    GOSSIP_ORCS,
    NUM_GOSSIPS
};

// Macros for GOSSIP
#define FOREACH_GOSSIP(x) \
    for ((x) = (GOSSIP_NAMES) 0; \
         (x) < NUM_GOSSIPS; \
         (x) = (GOSSIP_NAMES) ((int)(x)+1))

struct GOSSIP_DEF
{
    const char *name;
};

extern const GOSSIP_DEF glb_gossipdefs[];

// Definitions for SHOP
enum SHOP_NAMES
{
    SHOP_NONE,
    SHOP_HEAL,
    SHOP_FIX,
    SHOP_BUY,
    SHOP_GOSSIP,
    SHOP_ID,
    SHOP_REMOVEITEM,
    SHOP_MAP,
    NUM_SHOPS
};

// Macros for SHOP
#define FOREACH_SHOP(x) \
    for ((x) = (SHOP_NAMES) 0; \
         (x) < NUM_SHOPS; \
         (x) = (SHOP_NAMES) ((int)(x)+1))

// Definitions for ACTION
enum ACTION_NAMES
{
    ACTION_NONE,
    ACTION_RESTART,
    ACTION_STARTQUEST,
    ACTION_ENDQUEST,
    ACTION_WORLDSTATE,
    ACTION_BUMP,
    ACTION_FIRE,
    ACTION_ROTATE,
    ACTION_REBOOTAVATAR,
    ACTION_DROP,
    ACTION_BREAK,
    ACTION_INSPECT,
    ACTION_QUAFF,
    ACTION_EAT,
    ACTION_SUICIDE,
    ACTION_MEDITATE,
    ACTION_SEARCH,
    ACTION_WAIT,
    ACTION_EXAMINE,
    ACTION_SAVE,
    ACTION_CREATEITEM,
    ACTION_CAST,
    ACTION_SHOP,
    ACTION_THROW,
    ACTION_WEAR,
    ACTION_PICKUP,
    ACTION_MAGICMOVE,
    NUM_ACTIONS
};

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

// Definitions for OPTION
enum OPTION_NAMES
{
    OPTION_INSTRUCTIONS,
    OPTION_PLAY,
    OPTION_BLOOD,
    OPTION_FULLSCREEN,
    OPTION_QUIT,
    NUM_OPTIONS
};

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

struct OPTION_DEF
{
    const char *name;
};

extern const OPTION_DEF glb_optiondefs[];

// Definitions for YELL
enum YELL_NAMES
{
    YELL_KEEPOUT,
    YELL_MURDERER,
    YELL_INVADER,
    YELL_KILL,
    YELL_KILLCHASE,
    YELL_LOCATION,
    YELL_HEARDLOCATION,
    YELL_TAUNT,
    YELL_VICTORY,
    YELL_RANGED,
    NUM_YELLS
};

// Macros for YELL
#define FOREACH_YELL(x) \
    for ((x) = (YELL_NAMES) 0; \
         (x) < NUM_YELLS; \
         (x) = (YELL_NAMES) ((int)(x)+1))

// Definitions for ROOMTYPE
enum ROOMTYPE_NAMES
{
    ROOMTYPE_NONE,
    ROOMTYPE_THRONE,
    ROOMTYPE_STRATEGY,
    ROOMTYPE_GOBLIN,
    ROOMTYPE_GOBLIN_START,
    ROOMTYPE_GOBLIN_FINISH,
    ROOMTYPE_KOBOLD,
    ROOMTYPE_KOBOLD_START,
    ROOMTYPE_KOBOLD_FINISH,
    ROOMTYPE_SLIME,
    ROOMTYPE_SLIME_START,
    ROOMTYPE_SLIME_FINISH,
    ROOMTYPE_CRYPT,
    ROOMTYPE_CRYPT_START,
    ROOMTYPE_CRYPT_FINISH,
    NUM_ROOMTYPES
};

// Macros for ROOMTYPE
#define FOREACH_ROOMTYPE(x) \
    for ((x) = (ROOMTYPE_NAMES) 0; \
         (x) < NUM_ROOMTYPES; \
         (x) = (ROOMTYPE_NAMES) ((int)(x)+1))

struct ROOMTYPE_DEF
{
    const char *prefix;
    u8 ngold;
    u8 nitem;
    u8 nmob;
    u8 wall_r;
    u8 wall_g;
    u8 wall_b;
    u8 item_find;
    u8 item_findchance;
    u8 boss;
    u8 portalfloor;
    bool randomorient : 1;
    bool allowportal : 1;
    const char *mandatoryitem;
};

extern const ROOMTYPE_DEF glb_roomtypedefs[];

// Definitions for ATLAS
enum ATLAS_NAMES
{
    ATLAS_NONE,
    ATLAS_THRONE,
    ATLAS_STRATEGY,
    ATLAS_GOBLIN,
    ATLAS_KOBOLD,
    ATLAS_SLIME,
    ATLAS_CRYPT,
    NUM_ATLASS
};

// Macros for ATLAS
#define FOREACH_ATLAS(x) \
    for ((x) = (ATLAS_NAMES) 0; \
         (x) < NUM_ATLASS; \
         (x) = (ATLAS_NAMES) ((int)(x)+1))

struct ATLAS_DEF
{
    const char *name;
    u8 start_roomtype;
    u8 mid_roomtype;
    u8 end_roomtype;
    const char *mobs;
    const char *itemlists;
};

extern const ATLAS_DEF glb_atlasdefs[];

// Definitions for ITEMLIST
enum ITEMLIST_NAMES
{
    ITEMLIST_NONE,
    ITEMLIST_WEAPONS,
    ITEMLIST_FOOD,
    ITEMLIST_KOBOLDTOYS,
    NUM_ITEMLISTS
};

// Macros for ITEMLIST
#define FOREACH_ITEMLIST(x) \
    for ((x) = (ITEMLIST_NAMES) 0; \
         (x) < NUM_ITEMLISTS; \
         (x) = (ITEMLIST_NAMES) ((int)(x)+1))

struct ITEMLIST_DEF
{
    const char *items;
};

extern const ITEMLIST_DEF glb_itemlistdefs[];

// Definitions for ATTACKSTYLE
enum ATTACKSTYLE_NAMES
{
    ATTACKSTYLE_MELEE,
    ATTACKSTYLE_RANGE,
    ATTACKSTYLE_INTERNAL,
    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 ELEMENT
enum ELEMENT_NAMES
{
    ELEMENT_NONE,
    ELEMENT_PHYSICAL,
    ELEMENT_POISON,
    ELEMENT_FIRE,
    ELEMENT_COLD,
    ELEMENT_ACID,
    ELEMENT_LIGHT,
    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[];
#endif
