game.h

#ifndef _CANVAS_H
#define _CANVAS_H

#include <stdlib.h>
#include <vector>
#include <assert.h>

#include <chunk.h>
#include <chunk_matrix.h>
#include <constants.h>
#include <bresenham.h>
#include <enemy.h>
#include <defs.h>
#include <character.h>
#include <world_map.h>
#include <helper.h>
#include <item.h>
#include <animation.h>
#include <animation_defs.h>

namespace td=tiledef;

class Game
{
    typedef std::vector<std::vector<Tile> > TileMatrix;
    typedef std::vector<std::vector<Tile*> > TilePointerMatrix;
    typedef std::vector<std::vector<MapTile> > MapTileMatrix;

    private:

        //BASE Data/Models
        bool initialized;

        bool paused;

        MapTileMatrix world_map;

        ChunkMatrix chunk_map;

        Tile tile_index[td::TILE_TYPE_COUNT];
        
        std::vector<Animation> anim_queue;

        //BASE model access functions
        void point_assertions(int row, int col);

        
        void set_tile(int row, int col, Tile* tile);

        void set_tile(IntPoint point, Tile* tile);

        Item* item_at_coords(IntPoint, IntPoint, int);

        Tile* get_tile(int row, int col);

        Tile* get_tile(IntPoint point);

        bool out_of_bounds(IntPoint point);

        bool out_of_bounds(int row, int col);

        bool in_buffer(int row, int col);

        bool in_range(IntPoint chunk, IntPoint coords, IntPoint range_chunk, IntPoint center, IntPoint radius);

        void update_main_char_chunk();
        IntPoint get_canvas_coords(IntPoint, IntPoint);
        IntPoint get_buffer_coords(IntPoint, IntPoint);
        Character* enemy_at_loc(IntPoint, IntPoint);

        //RENDERING Data/Models
        TilePointerMatrix canvas;
        TilePointerMatrix buffer;
        std::vector<std::vector<IntPoint> > bresenham_lines;


        //ENEMY Data/Models
        std::vector<Enemy*> enemy_list;

        //ENEMY Functionality

public:
        Game();
        ~Game();
        void init(const MapTileMatrix&, IntPoint);

        //BASE Data/Models
        Main_Character main_char;

        //BASE Model access
        Chunk* get_current_chunk();
        bool is_initialized();
        void act(long);
        bool is_paused();
        void pause();
        void unpause();
        void toggle_pause();
        //RENDERING Functionality
        const std::vector<std::vector<Tile*> >& get_canvas();
        IntPoint get_vis_coords(IntPoint, IntPoint);
        std::vector<Enemy*> get_vis_enemies();
        void show_vis_items();
        std::vector<Animation>& get_animations();
        void tick_animations(long delta_ms); 
        bool is_vis(IntPoint coords);
        void refresh();
        void recalculate_visibility_lines(int radius);
        void update_buffer(IntPoint);
        void update_chunk_map(IntPoint);
        void draw_visibility_lines();
        void undo_visibility();

        //ENEMY Functionality
        void run_spawners();
        void run_enemies(long);
        void remove_targets(Character* enem);
        std::vector<Enemy*>& get_enemies();
        //MAIN CHAR Functionality
        void change_depth(int, Character*);
        void move_char(int, int, Character*) ;
        void get_item(Character*);
        void drop_item(Item*, Character*);

        //DEBUG FUNCTIONS
        void spawn_enemy(int, int, int, int, int, int);

        void teleport(int chunk_x, int chunk_y, int x, int y);

        //ANIMATION FUNCTIONS
        void create_explosion(int x, int y, int chunk_x, int chunk_y);
};

#endif