th_map.h

Go to the documentation of this file.

/*
Copyright (c) 2009 Peter "Corsix" Cawley
 
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
#ifndef CORSIX_TH_TH_MAP_H_
#define CORSIX_TH_TH_MAP_H_
#include "config.h"
 
#include <list>
#include <string>
#include <utility>
#include <vector>
 
#include "th.h"
 
class lua_persist_reader;
class lua_persist_writer;
class map_overlay;
class render_target;
class sprite_sheet;
struct drawable;
 
/*
    Object type enumeration uses same values as original TH does.
    See game string table section 39 for proof. Section 1 also has
    names in this order.
*/
enum class object_type : uint8_t {
  no_object = 0,
  desk = 1,
  cabinet = 2,
  door = 3,
  bench = 4,
  table = 5,  // Not in game
  chair = 6,
  drinks_machine = 7,
  bed = 8,
  inflator = 9,
  pool_table = 10,
  reception_desk = 11,
  b_table = 12,  // Not in game?
  cardio = 13,
  scanner = 14,
  scanner_console = 15,
  screen = 16,
  litter_bomb = 17,
  couch = 18,
  sofa = 19,
  crash = 20,  // The trolley in general diagnosis
  tv = 21,
  ultrascan = 22,
  dna_fixer = 23,
  cast_remover = 24,
  hair_restorer = 25,
  slicer = 26,
  xray = 27,
  radiation_shield = 28,
  xray_viewer = 29,
  op_table = 30,
  lamp = 31,  // Not in game?
  sink = 32,
  op_sink1 = 33,
  op_sink2 = 34,
  surgeon_screen = 35,
  lecture_chair = 36,
  projector = 37,
  // 38 is unused
  pharmacy = 39,
  computer = 40,
  chemical_mixer = 41,
  blood_machine = 42,
  extinguisher = 43,
  radiator = 44,
  plant = 45,
  electro = 46,
  jelly_vat = 47,
  hell = 48,
  // 49 is unused
  bin = 50,
  loo = 51,
  double_door1 = 52,
  double_door2 = 53,
  decon_shower = 54,
  autopsy = 55,
  bookcase = 56,
  video_game = 57,
  entrance_left_door = 58,
  entrance_right_door = 59,
  skeleton = 60,
  comfy_chair = 61,
  litter = 62,
  helicopter = 63,
  rathole = 64,
  // 65 through 255 are unused
};
 
struct map_tile_flags {
  enum class key : uint32_t {
    passable_mask = 1 << 0,
    can_travel_n_mask = 1 << 1,
    can_travel_e_mask = 1 << 2,
    can_travel_s_mask = 1 << 3,
    can_travel_w_mask = 1 << 4,
    hospital_mask = 1 << 5,
    buildable_mask = 1 << 6,
    passable_if_not_for_blueprint_mask = 1 << 7,
    room_mask = 1 << 8,
    shadow_half_mask = 1 << 9,
    shadow_full_mask = 1 << 10,
    shadow_wall_mask = 1 << 11,
    door_north_mask = 1 << 12,
    door_west_mask = 1 << 13,
    do_not_idle_mask = 1 << 14,
    tall_north_mask = 1 << 15,
    tall_west_mask = 1 << 16,
    buildable_n_mask = 1 << 17,
    buildable_e_mask = 1 << 18,
    buildable_s_mask = 1 << 19,
    buildable_w_mask = 1 << 20,
  };
 
  bool passable;      
  bool can_travel_n;  
  bool can_travel_e;  
  bool can_travel_s;  
  bool can_travel_w;  
  bool hospital;      
  bool buildable;     
  bool passable_if_not_for_blueprint;
  bool room;         
  bool shadow_half;  
  bool shadow_full;  
  bool shadow_wall;  
  bool door_north;   
  bool door_west;    
  bool do_not_idle;  
  bool tall_north;   
  bool tall_west;    
  bool buildable_n;  
  bool buildable_e;  
  bool buildable_s;  
  bool buildable_w;  
 
  map_tile_flags& operator=(uint32_t raw);
 
  bool& operator[](map_tile_flags::key key);
 
  const bool& operator[](map_tile_flags::key key) const;
 
  operator uint32_t() const;
};
 
enum class temperature_theme {
  red,           
  multi_colour,  
  yellow_red     
};
 
enum tile_layer : uint8_t {
  ground = 0,
  north_wall = 1,
  west_wall = 2,
  ui = 3,
 
  num_tile_layers = 4  
};
 
struct map_tile {
  map_tile() = default;
  ~map_tile() = default;
 
  // Linked list for entities rendered at this tile
  link_list entities;
 
  link_list oEarlyEntities;
 
  uint16_t tile_layers[tile_layer::num_tile_layers]{};
 
  uint16_t iParcelId{0};
 
  uint16_t iRoomId{0};
 
  uint16_t aiTemperature[2]{8192, 8192};
 
  map_tile_flags flags{};
 
  std::list<object_type> objects;
 
  static constexpr int raw_length = 8;
 
  std::uint8_t raw[raw_length]{};
};
 
 
typedef void (*map_load_object_callback_fn)(void*, int, int, object_type,
                                            uint8_t);
 
class level_map {
 public:
  level_map() = default;
  ~level_map();
 
  bool set_size(int iWidth, int iHeight);
  bool load_blank();
  bool load_from_th_file(const uint8_t* pData, size_t iDataLength,
                         map_load_object_callback_fn fnObjectCallback,
                         void* pCallbackToken);
 
  void save(const std::string& filename);
 
 
  void set_block_sheet(sprite_sheet* pSheet);
 
 
  void set_all_wall_draw_flags(uint8_t iFlags);
 
  void update_pathfinding();
  void update_shadows();
  void set_temperature_display(temperature_theme eTempDisplay);
  inline temperature_theme get_temperature_display() const {
    return current_temperature_theme;
  }
  void update_temperatures(uint16_t iAirTemperature,
                           uint16_t iRadiatorTemperature);
 
  inline int get_width() const { return width; }
 
  inline int get_height() const { return height; }
 
  inline int get_parcel_count() const { return parcel_count - 1; }
 
  inline int get_player_count() const { return player_count; }
 
  void set_player_count(int count);
 
  bool get_player_camera_tile(int iPlayer, int* pX, int* pY) const;
  bool get_player_heliport_tile(int iPlayer, int* pX, int* pY) const;
  void set_player_camera_tile(int iPlayer, int iX, int iY);
  void set_player_heliport_tile(int iPlayer, int iX, int iY);
 
  int get_parcel_tile_count(int iParcelId) const;
 
 
  std::vector<std::pair<int, int>> set_parcel_owner(int iParcelId, int iOwner);
 
 
  int get_parcel_owner(int iParcelId) const;
 
 
  bool are_parcels_adjacent(int iParcel1, int iParcel2);
 
 
  bool is_parcel_purchasable(int iParcelId, int iPlayer);
 
 
  void draw(render_target* pCanvas, int iScreenX, int iScreenY, int iWidth,
            int iHeight, int iCanvasX, int iCanvasY) const;
 
 
  drawable* hit_test(int iTestX, int iTestY) const;
 
  // When using the unchecked versions, the map coordinates MUST be valid.
  // When using the normal versions, nullptr is returned for invalid co-ords.
  map_tile* get_tile(int iX, int iY);
  const map_tile* get_tile(int iX, int iY) const;
  const map_tile* get_original_tile(int iX, int iY) const;
  map_tile* get_tile_unchecked(int iX, int iY);
  const map_tile* get_tile_unchecked(int iX, int iY) const;
  const map_tile* get_original_tile_unchecked(int iX, int iY) const;
 
  uint16_t get_tile_temperature(const map_tile* pNode) const;
  int get_tile_owner(const map_tile* pNode) const;
 
  template <typename T>
  static inline void world_to_screen(T& x, T& y) {
    T x_(x);
    x = (T)32 * (x_ - y);
    y = (T)16 * (x_ + y);
  }
 
  template <typename T>
  static inline void screen_to_world(T& x, T& y) {
    T x_(x);
    x = y / (T)32 + x_ / (T)64;
    y = y / (T)32 - x_ / (T)64;
  }
 
  void persist(lua_persist_writer* pWriter) const;
  void depersist(lua_persist_reader* pReader);
 
  void set_overlay(map_overlay* pOverlay, bool bTakeOwnership);
 
 private:
  void draw_floor(render_target* pCanvas, int iScreenX, int iScreenY,
                  int iWidth, int iHeight, int iCanvasX, int iCanvasY) const;
  void draw_north_wall(const map_tile* tile, int tile_x, int tile_y,
                       render_target* pCanvas) const;
 
  int draw_layer(const map_tile* tile, int tile_x, int tile_y, tile_layer layer,
                 render_target* pCanvas) const;
 
  /*
   *  @param layer Layer to investigate.
   *  @param [out] height Height of the sprite if the method returns \c true.
   *  @return Whether the sprite exists and is not empty.
   */
  bool layer_exists(uint16_t layer, int& height) const;
 
  drawable* hit_test_drawables(link_list* pListStart, int iXs, int iYs,
                               int iTestX, int iTestY) const;
  void read_tile_index(const uint8_t* pData, int& iX, int& iY) const;
  void write_tile_index(uint8_t* pData, int iX, int iY) const;
 
  uint32_t thermal_neighbour(uint32_t& iNeighbourSum, bool canTravel,
                             std::ptrdiff_t relative_idx, map_tile* pNode,
                             int prevTemp) const;
 
  void make_adjacency_matrix();
 
  void make_purchase_matrix();
 
  void update_purchase_matrix();
 
  int count_parcel_tiles(int iParcelId) const;
 
  map_tile* cells{};
  map_tile* original_cells{};  // Cells at map load time, before any changes
  sprite_sheet* wall_blocks{};
  map_overlay* overlay{};
  bool owns_overlay{};
  int* plot_owner{};  // 0 for unowned, 1 for player 1, etc.
  int width{};
  int height{};
  int player_count{};
  int initial_camera_x[4]{};
  int initial_camera_y[4]{};
  int heliport_x[4]{};
  int heliport_y[4]{};
  int parcel_count{};
  int current_temperature_index{};
  temperature_theme current_temperature_theme{temperature_theme::red};
  int* parcel_tile_counts{};
 
  // 2D symmetric array giving true if there is a path between two parcels
  // which doesn't go into any other parcels.
  bool* parcel_adjacency_matrix{};
 
  // 4 by N matrix giving true if player can purchase parcel.
  bool* purchasable_matrix{};
};
 
enum class map_scanline_iterator_direction {
  forward = 2,
  backward = 0,
};
 
 
class map_tile_iterator {
 public:
  map_tile_iterator() = delete;
 
  map_tile_iterator(const level_map* pMap, int iScreenX, int iScreenY,
                    int iWidth, int iHeight,
                    map_scanline_iterator_direction eScanlineDirection =
                        map_scanline_iterator_direction::forward);
 
  inline operator bool() const { return tile != nullptr; }
 
  inline map_tile_iterator& operator++();
 
  inline const map_tile* operator->() const { return tile; }
 
  inline int tile_x_position_on_screen() const { return x_relative_to_screen; }
 
  inline int tile_y_position_on_screen() const { return y_relative_to_screen; }
 
  inline int tile_x() const { return world_x; }
  inline int tile_y() const { return world_y; }
 
  inline const level_map* get_map() { return container; }
  inline const map_tile* get_map_tile() { return tile; }
  inline int get_scanline_count() { return scanline_count; }
  inline int get_tile_step() {
    return (static_cast<int>(direction) - 1) * (1 - container->get_width());
  }
 
 
  inline bool is_last_on_scanline() const;
 
 private:
  // Maximum extents of the visible parts of a tile (pixel distances relative
  // to the top-most corner of an isometric cell)
  // If set too low, things will disappear when near the screen edge
  // If set too high, rendering will slow down
  static const int margin_top = 150;
  static const int margin_left = 110;
  static const int margin_right = 110;
  static const int margin_bottom = 150;
 
  friend class map_scanline_iterator;
 
  const map_tile* tile{nullptr};
  const level_map* container;
 
  // TODO: Consider removing these, they are trivial to calculate
  int x_relative_to_screen{};
  int y_relative_to_screen{};
 
  const int screen_offset_x;
  const int screen_offset_y;
  const int screen_width;
  const int screen_height;
  int base_x;
  int base_y;
  int world_x;
  int world_y;
  int scanline_count{};
  map_scanline_iterator_direction direction;
 
  void advance_until_visible();
};
 
class map_scanline_iterator {
 public:
  map_scanline_iterator();
 
  map_scanline_iterator(const map_tile_iterator& itrNodes,
                        map_scanline_iterator_direction eDirection,
                        int iXOffset = 0, int iYOffset = 0);
 
  inline operator bool() const { return tile != end_tile; }
  inline map_scanline_iterator& operator++();
 
  inline const map_tile* operator->() const { return tile; }
  inline int x() const { return x_relative_to_screen; }
  inline int y() const { return y_relative_to_screen; }
  inline const map_tile* get_next_tile() { return tile + tile_step; }
  inline const map_tile* get_previous_tile() { return tile - tile_step; }
  map_scanline_iterator operator=(const map_scanline_iterator& iterator);
  inline const map_tile* get_tile() { return tile; }
 
 private:
  const map_tile* tile;
  const map_tile* first_tile;
  const map_tile* end_tile;
  int tile_step;
  int x_step;
  int x_relative_to_screen;
  int y_relative_to_screen;
  int steps_taken{0};
};
 
#endif  // CORSIX_TH_TH_MAP_H_