enemy.h

#ifndef ENEMY_H
#define ENEMY_H
#include <character.h>
#include <defs.h>
#include <constants.h>
#include <string>
#include <vector>
#include <helper.h>
#include <constants.h>
#include <math_helper.h>
#include <bresenham.h>

using namespace enemies;

struct ATile
{
    int parent;

    IntPoint coords;

    int f;

    int g;

    int h;

    ATile()
    {
        f = -1;
        g = -1;
        h = -1;
    }

    ATile(int _parent, IntPoint _coords)
    {
        parent = _parent;
        coords = _coords;
        f = 0;
        g = 0;
        h = 0;
    }
};

class Enemy : public Character
{
    typedef std::vector<std::vector<Tile*> > TilePointerMatrix;
    protected:
        int id;

        int sight;

        int direction;

        int view;
        

        bool spooked;

        IntPoint direction_spooked;

        int time_spooked;

        std::string name;

        std::vector<Equipment*> generate_equipment(std::vector<EquipType> equipment_list);

        Weapon* generate_weapon(std::vector<WeaponType>);

        void move(int x_change, int y_change);

        IntPoint get_next_step(IntPoint goal, TilePointerMatrix& surroundings, IntPoint cur_coords);

        int is_in(IntPoint point, std::vector<ATile> list);

        std::vector<IntPoint> a_star(IntPoint start, IntPoint goal, TilePointerMatrix &surroundings);

        int manhattan(IntPoint, IntPoint);

        int get_smallest_f(std::vector<ATile>& list);

        IntPoint get_sur_coords(IntPoint sur_chunk, IntPoint sur_coords, IntPoint _chunk, IntPoint _coords);

        Character* find_best_target(int target_id, int selectability, std::vector<Character*> enemy_list);

        Character* passive_best_target(int target_id, int selectability, std::vector<Character*> enemy_list);


        IntPoint get_spooked(IntPoint abs_coords, IntPoint target_abs);
       
        bool in_sight_range(IntPoint _coords, IntPoint _chunk);

        bool in_sight(IntPoint _coords, IntPoint _chunk);
        
        void turn(IntPoint coords);

         IntPoint get_fov();
    public:
        Enemy();

        Enemy(int _x, int _y, int _chunk_x , int _chunk_y, int _depth, EnemyType enemy);

        void run_ai(TilePointerMatrix &surroundings, IntPoint sur_chunk, IntPoint sur_coords, std::vector<Character*> char_list, long delta_ms);

        bool validate_target();
        
        
        void aggressive_ai(TilePointerMatrix&, IntPoint sur_chunk, IntPoint sur_coords, std::vector<Character*> char_list, long delta_ms);

        void passive_ai(TilePointerMatrix &surroundings, IntPoint sur_chunk, IntPoint sur_coords, std::vector<Character*> char_list, long delta_ms);

        int get_sight();

        int get_id();

        void dump_matrix(TilePointerMatrix& map, IntPoint tl, IntPoint br);

        std::vector<IntPoint> sight_tiles();
};


#endif