Horizon::Zone::Map Class Reference

The class Map is the representation of a map in the game. It contains all the cells and the grid holder. It also contains the A* pathfinder. It is the main class for the map. It is used to get the cells, the grid holder and the pathfinder, and perform a variety of operations on them. More...

#include <Map.hpp>

Inheritance diagram for Horizon::Zone::Map:

Collaboration diagram for Horizon::Zone::Map:

Public Member Functions
	Map (std::weak_ptr< GameLogicProcess >, std::string const &, uint16_t, uint16_t, std::vector< uint8_t > const &)
	~Map ()
std::shared_ptr< GameLogicProcess >	container ()
std::string const &	get_name ()
int	get_area ()
uint16_t	get_width ()
uint16_t	get_height ()
map_cell_types	get_cell_type (MapCoords coords)
GridHolderType &	getGridHolder ()
template<class T >
bool	ensure_grid_for_unit (T *unit, MapCoords coords)
template<class T , class CONTAINER >
void	visit (int grid_x, int grid_y, GridReferenceContainerVisitor< T, CONTAINER > &visitor)
template<class T , class CONTAINER >
void	visit (GridCoords const &lower_bound, GridCoords const &upper_bound, GridReferenceContainerVisitor< T, CONTAINER > &visitor)
template<class T , class CONTAINER >
void	visit_in_range (MapCoords const &map_coords, GridReferenceContainerVisitor< T, CONTAINER > &visitor, uint16_t range=MAX_VIEW_RANGE)
AStar::Generator &	get_pathfinder ()
bool	has_obstruction_at (int16_t x, int16_t y)
MapCoords	get_random_accessible_coordinates ()
MapCoords	get_random_coordinates_in_walkable_range (uint16_t x, uint16_t y, int16_t min, int16_t max)
MapCoords	get_random_coordinates_in_walkable_area (uint16_t x, uint16_t y, int16_t xs, int16_t ys)
void	set_user_count (int32_t count)
int32_t	get_user_count ()
void	add_user_count ()
void	sub_user_count ()
void	add_item_drop (int item_id, MapCoords map_coords, int amount, int identified)
void	add_item_drop (std::shared_ptr< item_entry_data > entry, int32_t amount, MapCoords map_coords)

Private Attributes
std::weak_ptr< GameLogicProcess >	_container
std::string	_name {""}
uint16_t	_width {0}
uint16_t	_height {0}
GridCoords	_max_grids
Cell	_cells [MAX_CELLS_PER_MAP][MAX_CELLS_PER_MAP] {{0}}
GridHolderType	_gridholder
AStar::Generator	_pathfinder
int32_t	_user_count { 0 }

Detailed Description

The class Map is the representation of a map in the game. It contains all the cells and the grid holder. It also contains the A* pathfinder. It is the main class for the map. It is used to get the cells, the grid holder and the pathfinder, and perform a variety of operations on them.

Parameters

_container	The container that contains this map.
_name	The name of the map.
_width	The width of the map.
_height	The height of the map.
_cells	The cells of the map.
_gridholder	The grid holder of the map.
_pathfinder	The A* pathfinder of the map.
_obstructions	The obstructions of the map.

Constructor & Destructor Documentation

Map()

Map::Map	(	std::weak_ptr< GameLogicProcess >	container,
		std::string const &	name,
		uint16_t	width,
		uint16_t	height,
		std::vector< uint8_t > const &	cells
	)

: _container(container), _name(name), _width(width), _height(height),
  _max_grids((width / MAX_CELLS_PER_GRID), (height / MAX_CELLS_PER_GRID)),
  _gridholder((width / MAX_CELLS_PER_GRID) + 1, (height / MAX_CELLS_PER_GRID) + 1), // add 1 because 0,0 is included.
  _pathfinder(AStar::Generator(MapCoords(width, height), std::bind(&Map::has_obstruction_at, this, std::placeholders::_1, std::placeholders::_2), true, &AStar::Heuristic::manhattan))
{
    for (int y = height - 1; y >= 0; --y) {
        for (int x = 0; x < width; ++x) {
            _cells[x][y] = Cell(cells.at(y * width + x));
        }
    }
}

References _cells.

~Map()

Map::~Map

(

)

{
    for (int y = _height - 1; y >= 0; --y) {
        for (int x = 0; x < _width; ++x) {
            _cells[x][y].~Cell();
        }
    }
}

References _cells, _height, _width, and Horizon::Zone::Cell::~Cell().

Here is the call graph for this function:

Member Function Documentation

add_item_drop() [1/2]

void Map::add_item_drop	(	int	item_id,
		MapCoords	map_coords,
		int	amount,
		int	identified
	)

{
    std::shared_ptr<const item_config_data> item_d = ItemDB->get_item_by_id(item_id);
 
    if (item_d == nullptr) {
        HLog(warning) << "Map::add_item_drop: Tried to drop non-existent item with ID: " << item_id << ".";
        return;
    }
 
    int r = std::rand();
    
    int64_t uuid = sZone->to_uuid(UNIT_ITEM, ++_last_np_unit_guid, 0, 0);
    std::shared_ptr<Horizon::Zone::Units::Item> item = std::make_shared<Horizon::Zone::Units::Item>(uuid, shared_from_this(), map_coords, identified, amount, item_d);
    item->initialize();
 
    s_grid_notify_item_drop_entry entry;
    entry.guid = item->guid();
    entry.item_id = item->config()->item_id;
    entry.type = item->config()->type;
    entry.is_identified = identified;
    entry.x = item->map_coords().x();
    entry.y = item->map_coords().y();
    entry.amount = amount;
    item->set_x_area((r & 3) * 3 + 3);
    item->set_y_area(((r >> 2) & 3) * 3 + 3);
    entry.x_area = item->x_area();
    entry.y_area = item->y_area();
    entry.show_drop_effect = item->config()->config.show_drop_effect;
    entry.drop_effect_mode = item->config()->drop_effect_mode;
    item->notify_nearby_players_of_item_drop(entry);
 
    this->container()->get_resource_manager().add<RESOURCE_PRIORITY_TERTIARY>(item->uuid(), item);
}

References _last_np_unit_guid(), s_grid_notify_item_drop_entry::amount, container(), s_grid_notify_item_drop_entry::drop_effect_mode, s_grid_notify_item_drop_entry::guid, HLog, s_grid_notify_item_drop_entry::is_identified, s_grid_notify_item_drop_entry::item_id, ItemDB, RESOURCE_PRIORITY_TERTIARY, s_grid_notify_item_drop_entry::show_drop_effect, sZone, s_grid_notify_item_drop_entry::type, UNIT_ITEM, s_grid_notify_item_drop_entry::x, s_grid_notify_item_drop_entry::x_area, s_grid_notify_item_drop_entry::y, and s_grid_notify_item_drop_entry::y_area.

Referenced by Horizon::Zone::MapComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

add_item_drop() [2/2]

void Map::add_item_drop	(	std::shared_ptr< item_entry_data >	entry,
		int32_t	amount,
		MapCoords	map_coords
	)

{   
    int64_t uuid = sZone->to_uuid(UNIT_ITEM, ++_last_np_unit_guid, 0, 0);
    std::shared_ptr<Horizon::Zone::Units::Item> floor_item = std::make_shared<Horizon::Zone::Units::Item>(uuid, entry, amount, shared_from_this(), map_coords);
    floor_item->initialize();
 
    s_grid_notify_item_drop_entry notif_config;
 
    int r = std::rand();
 
    notif_config.guid = floor_item->guid();
    notif_config.item_id = floor_item->config()->item_id;
    notif_config.type = floor_item->config()->type;
    notif_config.is_identified = floor_item->is_identified();
    notif_config.x = floor_item->map_coords().x();
    notif_config.y = floor_item->map_coords().y();
    notif_config.amount = amount;
    floor_item->set_x_area((r & 3) * 3 + 3);
    floor_item->set_y_area(((r >> 2) & 3) * 3 + 3);
    notif_config.x_area = floor_item->x_area();
    notif_config.y_area = floor_item->y_area();
    notif_config.show_drop_effect = floor_item->config()->config.show_drop_effect;
    notif_config.drop_effect_mode = floor_item->config()->drop_effect_mode;
 
    floor_item->notify_nearby_players_of_item_drop(notif_config);
 
    this->container()->get_resource_manager().add<RESOURCE_PRIORITY_TERTIARY>(floor_item->uuid(), floor_item);
}

References _last_np_unit_guid(), s_grid_notify_item_drop_entry::amount, container(), s_grid_notify_item_drop_entry::drop_effect_mode, s_grid_notify_item_drop_entry::guid, s_grid_notify_item_drop_entry::is_identified, s_grid_notify_item_drop_entry::item_id, RESOURCE_PRIORITY_TERTIARY, s_grid_notify_item_drop_entry::show_drop_effect, sZone, s_grid_notify_item_drop_entry::type, UNIT_ITEM, s_grid_notify_item_drop_entry::x, s_grid_notify_item_drop_entry::x_area, s_grid_notify_item_drop_entry::y, and s_grid_notify_item_drop_entry::y_area.

Here is the call graph for this function:

add_user_count()

void Map::add_user_count

(

)

                         {
    _user_count++; 
    if (get_user_count() == 1)
        container()->get_monster_spawn_agent().spawn_monsters(get_name());
    HLog(debug) << "Map::add_user_count: " << get_user_count();
}

References _user_count, container(), get_name(), get_user_count(), and HLog.

Here is the call graph for this function:

container()

std::shared_ptr< GameLogicProcess > Horizon::Zone::Map::container ( )

inline

{ return _container.expired() == false ? _container.lock() : nullptr; }

References _container.

Referenced by add_item_drop(), add_user_count(), and sub_user_count().

Here is the caller graph for this function:

ensure_grid_for_unit()

template<class T >

bool Horizon::Zone::Map::ensure_grid_for_unit	(	T *	unit,
		MapCoords	coords
	)

{
    std::string const &new_map_name = unit->map()->get_name();
    GridCoords new_gcoords = mcoords.scale<MAX_CELLS_PER_GRID, MAX_GRIDS_PER_MAP>();
 
    if (new_map_name.compare(get_name()) == 0 && unit->grid_coords() == new_gcoords)
        return false;
 
    if (unit->has_valid_grid_reference())
        unit->remove_grid_reference();
 
    unit->set_grid_coords(new_gcoords);
 
    _gridholder.get_grid(new_gcoords.x(), new_gcoords.y()).add_object(unit);
 
    return true;
}

References _gridholder, GridHolder< ZONE_OBJECT_TYPES >::get_grid(), get_name(), MAX_CELLS_PER_GRID, MAX_GRIDS_PER_MAP, Coordinates< MAX_COORDINATES >::scale(), Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Here is the call graph for this function:

get_area()

int Horizon::Zone::Map::get_area ( )

inline

{ return _width * _height; }

References _height, and _width.

get_cell_type()

map_cell_types Horizon::Zone::Map::get_cell_type ( MapCoords  coords )

inline

{ return _cells[coords.x()][coords.y()].get_type(); }

References _cells, Horizon::Zone::Cell::get_type(), Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Here is the call graph for this function:

get_height()

uint16_t Horizon::Zone::Map::get_height ( )

inline

{ return _height; }

References _height.

Referenced by Horizon::Zone::MapComponent::sync_data_types().

Here is the caller graph for this function:

get_name()

std::string const & Horizon::Zone::Map::get_name ( )

inline

{ return _name; }

References _name.

Referenced by add_user_count(), ensure_grid_for_unit(), sub_user_count(), and Horizon::Zone::MapComponent::sync_data_types().

Here is the caller graph for this function:

get_pathfinder()

AStar::Generator & Horizon::Zone::Map::get_pathfinder ( )

inline

{ return _pathfinder; }

References _pathfinder.

get_random_accessible_coordinates()

MapCoords Horizon::Zone::Map::get_random_accessible_coordinates ( )

inline

    {
        int16_t x = 0;
        int16_t y = 0;
 
        do {
            x = rand() % _width;
            y = rand() % _height;
        } while (has_obstruction_at(x, y));
 
        return { x, y };
    }

References _height, _width, and has_obstruction_at().

Here is the call graph for this function:

get_random_coordinates_in_walkable_area()

MapCoords Horizon::Zone::Map::get_random_coordinates_in_walkable_area ( uint16_t  x, uint16_t  y, int16_t  xs, int16_t  ys  )

inline

    {
        std::vector<MapCoords> available_cells;
 
        assert(xs >= 0);
        assert(ys >= 0);
 
        for (int i = std::max(x - xs, 0); i < std::min(x + xs, (int) _width); i++) {
            for (int j = std::max(y - ys, 0); j < std::min(y + ys,(int) _height); j++) {
                if (i == x && j == y)
                    continue;
                if (!has_obstruction_at(i, j))
                    available_cells.push_back(MapCoords(i, j));
            }
        }
 
        if (available_cells.size() == 0)
            return MapCoords(0, 0);
 
        int rnd = rand() % available_cells.size();
 
        return available_cells.at(rnd);
    }

References _height, _width, and has_obstruction_at().

Referenced by Horizon::Zone::MapComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

get_random_coordinates_in_walkable_range()

MapCoords Horizon::Zone::Map::get_random_coordinates_in_walkable_range ( uint16_t  x, uint16_t  y, int16_t  min, int16_t  max  )

inline

    {
        int a = 0, b = 0;
        int r = std::rand();
        int d = r % (max - min + 1) + min;
        int i = 0;
 
        do {
            a = r % (d * 2 + 1) - d;
            b = r / (d * 2 + 1) % (d * 2 + 1) - d;
 
            a += x;
            b += y;
            i++;
        } while(has_obstruction_at(a, b) && i < 20);
 
        if (i == 20) return MapCoords(0, 0);
 
        return MapCoords(a, b);
    }

References has_obstruction_at().

Referenced by Horizon::Zone::MapComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

get_user_count()

int32_t Horizon::Zone::Map::get_user_count ( )

inline

{ return _user_count; }

References _user_count.

Referenced by add_user_count(), and sub_user_count().

Here is the caller graph for this function:

get_width()

uint16_t Horizon::Zone::Map::get_width ( )

inline

{ return _width; }

References _width.

Referenced by Horizon::Zone::MapComponent::sync_data_types().

Here is the caller graph for this function:

getGridHolder()

GridHolderType & Horizon::Zone::Map::getGridHolder ( )

inline

{ return _gridholder; }

References _gridholder.

has_obstruction_at()

bool Map::has_obstruction_at	(	int16_t	x,
		int16_t	y
	)

{
    if (x < 0 || y < 0 || x > _width || y > _height)
        return true;
 
    Cell c = _cells[x][y];
    
    if (!c.isWalkable())
        return true;
 
    return false;
}

References _cells, _height, _width, and Horizon::Zone::Cell::isWalkable().

Referenced by get_random_accessible_coordinates(), get_random_coordinates_in_walkable_area(), get_random_coordinates_in_walkable_range(), and Horizon::Zone::MapComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

set_user_count()

void Horizon::Zone::Map::set_user_count ( int32_t  count )

inline

{ _user_count = count; }

References _user_count, and GridTypeListIterator::count().

Here is the call graph for this function:

sub_user_count()

void Map::sub_user_count

(

)

                         { 
    _user_count--; 
    if (get_user_count() == 0)
        container()->get_monster_spawn_agent().despawn_monsters(get_name());
    HLog(debug) << "Map::sub_user_count: " << get_user_count();
}

References _user_count, container(), get_name(), get_user_count(), and HLog.

Here is the call graph for this function:

visit() [1/2]

template<class T , class CONTAINER >

void Horizon::Zone::Map::visit ( GridCoords const &  lower_bound, GridCoords const &  upper_bound, GridReferenceContainerVisitor< T, CONTAINER > &  visitor  )

inline

{
    // Visit all grids in the map, from top to bottom, left to right
    // This is done to ensure that the visitor is called in the same order as the grids are stored in the map
    // This is important for the GridReferenceContainerVisitor, which will add the grid references to a container
    // The container will then be iterated over in the same order as the grids were visited
    // This ensures that the entities are visited in the container in the same order as they are stored in the map
    // We visit all ranges - 0,0 to maximum grids in a map 
    // (the upper range as well, i.e. if the map is 10x10 grids, we visit 0,0 to 10,10 and not 9x9)
    for (int y = lower_bound.y(); y <= upper_bound.y(); y++) {
        for (int x = lower_bound.x(); x <= upper_bound.x(); x++) {
            visit(x, y, visitor);
        }
    }
}

References Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Here is the call graph for this function:

visit() [2/2]

template<class T , class CONTAINER >

void Horizon::Zone::Map::visit ( int  grid_x, int  grid_y, GridReferenceContainerVisitor< T, CONTAINER > &  visitor  )

inline

{
    Grid<AllUnitTypes> &g = _gridholder.get_grid(grid_x, grid_y);
    g.visit(visitor);
}

References Grid< GRID_OBJECT_TYPES >::visit().

Here is the call graph for this function:

visit_in_range()

template<class T , class CONTAINER >

void Horizon::Zone::Map::visit_in_range ( MapCoords const &  map_coords, GridReferenceContainerVisitor< T, CONTAINER > &  visitor, uint16_t  range = MAX_VIEW_RANGE  )

inline

{
    MapCoords lower_bounds = map_coords.at_range<MAX_CELLS_PER_MAP>(-range);
    MapCoords upper_bounds = map_coords.at_range<MAX_CELLS_PER_MAP>(range);
 
    visit(lower_bounds.scale<MAX_CELLS_PER_GRID, MAX_GRIDS_PER_MAP>(), upper_bounds.scale<MAX_CELLS_PER_GRID, MAX_GRIDS_PER_MAP>(), visitor);
}

References Coordinates< MAX_COORDINATES >::at_range(), MAX_CELLS_PER_GRID, MAX_CELLS_PER_MAP, MAX_GRIDS_PER_MAP, and Coordinates< MAX_COORDINATES >::scale().

Here is the call graph for this function:

Member Data Documentation

_cells

Cell Horizon::Zone::Map::_cells[MAX_CELLS_PER_MAP][MAX_CELLS_PER_MAP] {{0}}

private

Referenced by get_cell_type(), has_obstruction_at(), Map(), and ~Map().

_container

std::weak_ptr<GameLogicProcess> Horizon::Zone::Map::_container

private

Referenced by container().

_gridholder

GridHolderType Horizon::Zone::Map::_gridholder

private

Referenced by ensure_grid_for_unit(), and getGridHolder().

_height

uint16_t Horizon::Zone::Map::_height {0}

private

Referenced by get_area(), get_height(), get_random_accessible_coordinates(), get_random_coordinates_in_walkable_area(), has_obstruction_at(), and ~Map().

_max_grids

GridCoords Horizon::Zone::Map::_max_grids

private

_name

std::string Horizon::Zone::Map::_name {""}

private

Referenced by get_name().

_pathfinder

AStar::Generator Horizon::Zone::Map::_pathfinder

private

Referenced by get_pathfinder().

_user_count

int32_t Horizon::Zone::Map::_user_count { 0 }

private

Referenced by add_user_count(), get_user_count(), set_user_count(), and sub_user_count().

_width

uint16_t Horizon::Zone::Map::_width {0}

private

Referenced by get_area(), get_random_accessible_coordinates(), get_random_coordinates_in_walkable_area(), get_width(), has_obstruction_at(), and ~Map().

---

The documentation for this class was generated from the following files:

• src/Server/Zone/Game/Map/Map.hpp
• src/Server/Zone/Game/Map/Map.cpp