defs.h

//Let the record show, that Alan, Jack, and I think that Google runs thepiratebay.se
//6/7/2014

#ifndef DEFS_H
#define DEFS_H
#include <color_def.h>
#include <string>
#include <ctime>
#include <stdlib.h>
#include <vector>
#define DEBUG 1

enum STATS
{
    HEALTH,
    ATTACK,
    ENDURANCE,
    STRENGTH,
    DEXTERITY,
    INTELLIGENCE
};

const int NUM_STATS = 6;

extern std::string STAT_NAMES[NUM_STATS]; 

/*--------------------------
 *   TERRAIN DEFS
 -------------------------*/

struct Tile {
    int char_count;

    int tile_id;

    int color;

    bool can_be_moved_through;

    bool visible;

    bool opaque;

    bool seen;

    bool operator==(const Tile& rhs) const {
        return this->tile_id == rhs.tile_id;
    }
    
    bool operator!=(const Tile& rhs) const{
        return this->tile_id != rhs.tile_id;
    }
};

namespace tiledef {
    static const int TILE_TYPE_COUNT = 32;
    extern Tile TILE_INDEX[TILE_TYPE_COUNT]; //CHANGE THIS WHEN YOU ADD TILES!
    extern Tile OVERWORLD_DIRT; //YOU'RE NOT MY MOM!
    extern Tile DIRT;
    extern Tile DUNGEON_BORDER;
    extern Tile ROOM_WALL;
    extern Tile EMPTY;
    //static const Tile PATH = {88, 'X', true};
    //static const Tile PATH = {111, 'o', true};
    extern Tile PATH;
    extern Tile MAIN_CHAR;
    extern Tile MAIN_CHAR2;
    extern Tile MAIN_CHAR3;
    extern Tile MAIN_CHAR4;
    extern Tile TREE;
    extern Tile BLOCK_WALL;
    extern Tile DOWN_STAIR;
    extern Tile UP_STAIR;
    extern Tile KOBOLD;
    extern Tile KOBOLD_SPAWNER;
    extern Tile WATER;
    extern Tile LIGHT_WATER;
    extern Tile SAND1;
    extern Tile SAND2;
    extern Tile BIG_TREE;
    extern Tile GRASS_DIRT;
    extern Tile KOBOLD_CORPSE;
    extern Tile BOOTS;
    extern Tile RABBIT;
    extern Tile RABBIT_CORPSE;
    extern Tile SWORD;
    extern Tile POTATO;
    extern Tile PLANT;
    extern Tile WOOD_WALL;
    extern Tile WOOD_FLOOR;
    extern Tile DOOR;
}

struct MapTile {
    int char_count;

    int color;

    int id;

    bool does_spawn;

    bool operator==(const MapTile& rhs) const {
        return this->id == rhs.id;
    }

    bool operator!=(const MapTile& rhs) const {
        return !(this->id == rhs.id);
    }
};

namespace map_tile {
    extern MapTile MAP_TILE_INDEX[5];
    extern MapTile MAP_DEFAULT;
    extern MapTile MAP_WATER;
    extern MapTile CURSOR;
    extern MapTile MAP_FOREST;
    extern MapTile MAP_BEACH;
}

/*--------------------------
 -       ITEM DEFS
 -------------------------*/
struct EquipType
{
    float weight;

    Tile sprite;

    std::string name;

    std::string description;

    int rarity;

    int body_part;

    int type;

    int hit[3];

    float dam[3];

    bool use;

    int size;

    bool operator==(const EquipType& rhs) const
    {
        return this->name==rhs.name;
    }
};

struct WeaponType
{
    float weight;

    Tile sprite;

    std::string name;

    std::string description;

    int rarity;

    int damage;

    int type;



    int range;

    bool use;
    
    int size;

    bool operator==(const WeaponType& rhs) const
    {
        return this->name==rhs.name;
    }
};

struct ConsumableType
{
    float weight;

    Tile sprite;

    std::string name;

    std::string description;

    bool use;

    int rarity;

    int stat;

    int value;

    int type;

    int size;

    bool operator==(const ConsumableType& rhs) const
    {
        return this->name==rhs.name;
    }
};

struct MiscType
{
    float weight;

    Tile sprite;

    std::string name;

    std::string description;

    bool use;

    int rarity;

    int size;

    bool operator==(const MiscType& rhs) const
    {
        return this->name==rhs.name;
    }
};


namespace equipment
{
    extern EquipType boots;
}

namespace weapons
{
    extern WeaponType dagger;
}

namespace consumables
{
    extern ConsumableType potato;
    static const int NUM_CONSUMABLES = 1;
    extern ConsumableType CONSUMABLE_LIST[NUM_CONSUMABLES];
    enum ConsumableTypes
    {
        RESTORE,
        FORTIFY,
        DROP,
        INCREASE
    };
}

namespace misc
{
    extern MiscType kobold_corpse;
    extern MiscType rabbit_corpse;
    extern MiscType player_corpse;
}



/*--------------------------
 *   ENEMY DEFS
 -------------------------*/

struct EnemyType
{
    int moral;
     
    std::vector<int> stats;

    int id;

    int sight;

    int view;

    int speed;

    std::string name;

    Tile sprite;

    MiscType corpse;

    std::vector<EquipType> eq;

    std::vector<WeaponType> wep;

    bool operator==(const EnemyType& rhs) const
    {
        return this->id==rhs.id;
    }
};

namespace enemies
{
    extern EnemyType kobold;
    extern EnemyType rabbit;
    extern EnemyType ENEMY_LIST[2];
    extern int NUM_ENEMIES;
}

#endif