216 lines
6.3 KiB
C++
216 lines
6.3 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#ifndef NUVIE_CORE_MAP_H
|
|
#define NUVIE_CORE_MAP_H
|
|
|
|
#include "ultima/shared/std/string.h"
|
|
#include "ultima/nuvie/core/obj_manager.h"
|
|
|
|
namespace Ultima {
|
|
namespace Nuvie {
|
|
|
|
class Configuration;
|
|
class U6LList;
|
|
class Actor;
|
|
class ActorManager;
|
|
class MapCoord;
|
|
class TileManager;
|
|
class Screen;
|
|
|
|
#define MAP_ORIGINAL_TILE true
|
|
|
|
enum LineTestFlags {
|
|
LT_HitActors = (1 << 0),
|
|
LT_HitUnpassable = (1 << 1),
|
|
LT_HitForcedPassable = (1 << 2),
|
|
LT_HitLocation = (1 << 3), /* hit location in Result */
|
|
LT_HitObjects = (1 << 4), /* hit any object */
|
|
LT_HitMissileBoundary = (1 << 5)
|
|
};
|
|
|
|
class LineTestResult {
|
|
public:
|
|
LineTestResult() { // clears properties not set by init() (SB-X)
|
|
hit_x = 0;
|
|
hit_y = 0;
|
|
hit_level = 0;
|
|
hitActor = nullptr;
|
|
hitObj = nullptr;
|
|
hitLoc = nullptr;
|
|
loc_to_hit = nullptr;
|
|
}
|
|
void init(int x, int y, uint8 level, Actor *actorHit, Obj *objHit) {
|
|
hit_x = x;
|
|
hit_y = y;
|
|
hit_level = level;
|
|
hitActor = actorHit;
|
|
hitObj = objHit;
|
|
}
|
|
|
|
int hit_x; // x coord where object / actor was hit
|
|
int hit_y; // y coord where object / actor was hit
|
|
int pre_hit_x;
|
|
int pre_hit_y;
|
|
uint8 hit_level; // map level where object / actor was hit
|
|
Actor *hitActor;
|
|
Obj *hitObj;
|
|
MapCoord *hitLoc;
|
|
MapCoord *loc_to_hit; // set hitLoc if hit x,y (z changes)
|
|
};
|
|
|
|
//typedef (*LineTestFilter)(int x, int y, int level, LineTestResult &Result);
|
|
|
|
/* Map Location with 2D X,Y coordinates and plane (map number)
|
|
*/
|
|
class MapCoord {
|
|
public:
|
|
union {
|
|
uint16 x;
|
|
sint16 sx;
|
|
};
|
|
union {
|
|
uint16 y;
|
|
sint16 sy;
|
|
};
|
|
uint8 z; // plane
|
|
|
|
MapCoord(uint16 nx, uint16 ny, uint16 nz = 0) {
|
|
x = nx;
|
|
y = ny;
|
|
z = nz;
|
|
}
|
|
MapCoord(Obj *obj) {
|
|
x = obj->x;
|
|
y = obj->y;
|
|
z = obj->z;
|
|
}
|
|
MapCoord() : x(0), y(0), z(0) { }
|
|
|
|
uint32 xdistance(const MapCoord &c2) const {
|
|
uint32 dist = abs(c2.x - x);
|
|
if (dist > 512)
|
|
dist = 1024 - dist;
|
|
|
|
return dist;
|
|
}
|
|
uint32 ydistance(const MapCoord &c2) const {
|
|
return abs(c2.y - y);
|
|
}
|
|
// greatest 2D distance X or Y (estimate of shortest)
|
|
uint32 distance(const MapCoord &c2) const {
|
|
uint16 dx = xdistance(c2), dy = ydistance(c2);
|
|
return (dx >= dy ? dx : dy);
|
|
}
|
|
// get absolute coordinates for relative destination (dx,dy)
|
|
MapCoord abs_coords(sint16 dx, sint16 dy) const;
|
|
// location is on screen?
|
|
bool is_visible() const;
|
|
void print_d(DebugLevelType level) const {
|
|
DEBUG(1, level, "%d, %d, %d", x, y, z);
|
|
}
|
|
void print_h(DebugLevelType level) const {
|
|
DEBUG(1, level, "%x, %x, %x", x, y, z);
|
|
}
|
|
void print_s(DebugLevelType level) const {
|
|
DEBUG(1, level, "%d, %d", sx, sy);
|
|
}
|
|
|
|
bool operator==(const MapCoord &c2) const {
|
|
return (x == c2.x && y == c2.y && z == c2.z);
|
|
}
|
|
bool operator!=(const MapCoord &c2) const {
|
|
return (!(*this == c2));
|
|
}
|
|
// MapCoord operator+(MapCoord &c2) { return(abs_coords(c2)); }
|
|
};
|
|
|
|
|
|
class Map {
|
|
const Configuration *config;
|
|
TileManager *tile_manager;
|
|
ObjManager *obj_manager;
|
|
ActorManager *actor_manager;
|
|
|
|
uint8 *surface;
|
|
uint8 *dungeons[5];
|
|
|
|
bool roof_mode;
|
|
uint16 *roof_surface;
|
|
|
|
public:
|
|
|
|
Map(const Configuration *cfg);
|
|
~Map();
|
|
|
|
void set_actor_manager(ActorManager *am) {
|
|
actor_manager = am;
|
|
}
|
|
Actor *get_actor(uint16 x, uint16 y, uint8 z, bool inc_surrounding_objs = true);
|
|
|
|
bool loadMap(TileManager *tm, ObjManager *om);
|
|
byte *get_map_data(uint8 level);
|
|
uint16 *get_roof_data(uint8 level);
|
|
const Tile *get_tile(uint16 x, uint16 y, uint8 level, bool original_tile = false);
|
|
uint16 get_width(uint8 level) const;
|
|
bool is_passable(uint16 x, uint16 y, uint8 level);
|
|
bool is_water(uint16 x, uint16 y, uint16 level, bool ignore_objects = false);
|
|
bool is_boundary(uint16 x, uint16 y, uint8 level);
|
|
bool is_missile_boundary(uint16 x, uint16 y, uint8 level, Obj *excluded_obj = nullptr);
|
|
bool is_damaging(uint16 x, uint16 y, uint8 level, bool ignore_objects = false);
|
|
bool can_put_obj(uint16 x, uint16 y, uint8 level);
|
|
bool actor_at_location(uint16 x, uint16 y, uint8 level, bool inc_surrounding_objs = true);
|
|
uint8 get_impedance(uint16 x, uint16 y, uint8 level, bool ignore_objects = false);
|
|
const Tile *get_dmg_tile(uint16 x, uint16 y, uint8 level);
|
|
bool is_passable(uint16 x, uint16 y, uint8 level, NuvieDir dir);
|
|
bool is_passable(uint16 x1, uint16 y1, uint16 x2, uint16 y2, uint8 level);
|
|
bool is_passable_from_dir(uint16 x, uint16 y, uint8 level, NuvieDir dir);
|
|
bool has_roof(uint16 x, uint16 y, uint8 level) const;
|
|
void set_roof_mode(bool roofs);
|
|
|
|
const char *look(uint16 x, uint16 y, uint8 level);
|
|
|
|
bool lineTest(int start_x, int start_y, int end_x, int end_y, uint8 level,
|
|
uint8 flags, LineTestResult &Result, uint32 skip = 0, Obj *excluded_obj = nullptr, bool want_screen_space = false); // excluded_obj only works for LT_HitUnpassable
|
|
|
|
bool testIntersection(int x, int y, uint8 level, uint8 flags, LineTestResult &Result, Obj *excluded_obj = nullptr); // excluded_obj only works for LT_HitUnpassable
|
|
|
|
void saveRoofData();
|
|
Common::Path getRoofTilesetFilename() const;
|
|
|
|
protected:
|
|
Common::Path getRoofDataFilename() const;
|
|
void insertSurfaceSuperChunk(const unsigned char *schunk_ptr, const unsigned char *chunk_data, uint8 schunk_num);
|
|
void insertSurfaceChunk(const unsigned char *chunk, uint16 x, uint16 y);
|
|
|
|
void insertDungeonSuperChunk(const unsigned char *schunk_ptr, const unsigned char *chunk_data, uint8 level);
|
|
void insertDungeonChunk(const unsigned char *chunk, uint16 x, uint16 y, uint8 level);
|
|
|
|
|
|
void loadRoofData();
|
|
|
|
};
|
|
|
|
} // End of namespace Nuvie
|
|
} // End of namespace Ultima
|
|
|
|
#endif
|