236 lines
8.9 KiB
C++
236 lines
8.9 KiB
C++
/*
|
|
* universe.h
|
|
* BoE
|
|
*
|
|
* Created by Celtic Minstrel on 24/04/09.
|
|
*
|
|
*/
|
|
|
|
#ifndef BOE_DATA_UNIVERSE_H
|
|
#define BOE_DATA_UNIVERSE_H
|
|
|
|
#include <array>
|
|
#include <iosfwd>
|
|
#include <memory>
|
|
#include <set>
|
|
|
|
#include "fields.hpp"
|
|
#include "item.hpp"
|
|
#include "party.hpp"
|
|
#include "pictypes.hpp"
|
|
#include "population.hpp"
|
|
#include "scenario.hpp"
|
|
#include "talking.hpp"
|
|
#include "town.hpp"
|
|
|
|
namespace legacy {
|
|
struct out_info_type;
|
|
struct current_town_type;
|
|
struct town_item_list;
|
|
struct stored_town_maps_type;
|
|
struct stored_outdoor_maps_type;
|
|
struct big_tr_type;
|
|
};
|
|
|
|
class cCurTown {
|
|
short cur_talk_loaded = -1;
|
|
bool free_for_sfx(short x, short y);
|
|
cUniverse& univ;
|
|
cTown* arena;
|
|
cTown*const record() const;
|
|
|
|
template<eFieldType Field> bool test_field(short x, short y) const
|
|
{
|
|
if(!record()->is_on_map(x,y)) return false;
|
|
return fields[x][y] & Field;
|
|
}
|
|
|
|
public:
|
|
bool quickfire_present = false, belt_present = false;
|
|
// formerly current_town_type
|
|
short difficulty;
|
|
cPopulation monst;
|
|
|
|
std::vector<cItem> items; // formerly town_item_list type
|
|
|
|
unsigned long fields[64][64];
|
|
|
|
void import_legacy(legacy::current_town_type const &old);
|
|
void import_legacy(legacy::town_item_list const &old);
|
|
void import_reset_fields_legacy();
|
|
void import_legacy(legacy::big_tr_type const &old);
|
|
|
|
cTown* operator -> ();
|
|
cTown& operator * ();
|
|
explicit cCurTown(cUniverse& univ);
|
|
short countMonsters();
|
|
cSpeech& cur_talk(); // Get the currently loaded speech
|
|
bool prep_talk(short which); // Prepare for loading specified speech, returning true if already loaded
|
|
void prep_arena(); // Set up for a combat arena
|
|
void place_preset_fields();
|
|
|
|
bool is_explored(short x, short y) const { return test_field<SPECIAL_EXPLORED>(x,y); }
|
|
bool is_force_wall(short x, short y) const { return test_field<WALL_FORCE>(x,y); }
|
|
bool is_fire_wall(short x, short y) const { return test_field<WALL_FIRE>(x,y); }
|
|
bool is_antimagic(short x, short y) const { return test_field<FIELD_ANTIMAGIC>(x,y); }
|
|
bool is_scloud(short x, short y) const { return test_field<CLOUD_STINK>(x,y); } // stinking cloud
|
|
bool is_ice_wall(short x, short y) const { return test_field<WALL_ICE>(x,y); }
|
|
bool is_blade_wall(short x, short y) const { return test_field<WALL_BLADES>(x,y); }
|
|
bool is_sleep_cloud(short x, short y) const { return test_field<CLOUD_SLEEP>(x,y); }
|
|
bool is_block(short x, short y) const { return test_field<OBJECT_BLOCK>(x,y); } // currently unused
|
|
bool is_spot(short x, short y) const { return test_field<SPECIAL_SPOT>(x,y); }
|
|
bool is_special(short x, short y) const;
|
|
bool is_web(short x, short y) const { return test_field<FIELD_WEB>(x,y); }
|
|
bool is_crate(short x, short y) const { return test_field<OBJECT_CRATE>(x,y); }
|
|
bool is_barrel(short x, short y) const { return test_field<OBJECT_BARREL>(x,y); }
|
|
bool is_fire_barr(short x, short y) const { return test_field<BARRIER_FIRE>(x,y); }
|
|
bool is_force_barr(short x, short y) const { return test_field<BARRIER_FORCE>(x,y); }
|
|
bool is_quickfire(short x, short y) const { return test_field<FIELD_QUICKFIRE>(x,y); }
|
|
bool is_sm_blood(short x, short y) const { return test_field<SFX_SMALL_BLOOD>(x,y); }
|
|
bool is_med_blood(short x, short y) const { return test_field<SFX_MEDIUM_BLOOD>(x,y); }
|
|
bool is_lg_blood(short x, short y) const { return test_field<SFX_LARGE_BLOOD>(x,y); }
|
|
bool is_sm_slime(short x, short y) const { return test_field<SFX_SMALL_SLIME>(x,y); }
|
|
bool is_lg_slime(short x, short y) const { return test_field<SFX_LARGE_SLIME>(x,y); }
|
|
bool is_ash(short x, short y) const { return test_field<SFX_ASH>(x,y); }
|
|
bool is_bones(short x, short y) const { return test_field<SFX_BONES>(x,y); }
|
|
bool is_rubble(short x, short y) const { return test_field<SFX_RUBBLE>(x,y); }
|
|
bool is_force_cage(short x, short y) const { return test_field<BARRIER_CAGE>(x,y); }
|
|
bool is_road(short x, short y) const { return test_field<SPECIAL_ROAD>(x,y); }
|
|
bool set_explored(short x, short y, bool b);
|
|
bool set_force_wall(short x, short y, bool b);
|
|
bool set_fire_wall(short x, short y, bool b);
|
|
bool set_antimagic(short x, short y, bool b);
|
|
bool set_scloud(short x, short y, bool b); // stinking cloud
|
|
bool set_ice_wall(short x, short y, bool b);
|
|
bool set_blade_wall(short x, short y, bool b);
|
|
bool set_sleep_cloud(short x, short y, bool b);
|
|
bool set_block(short x, short y, bool b); // currently unused
|
|
bool set_spot(short x, short y, bool b);
|
|
bool set_web(short x, short y, bool b);
|
|
bool set_crate(short x, short y, bool b);
|
|
bool set_barrel(short x, short y, bool b);
|
|
bool set_fire_barr(short x, short y, bool b);
|
|
bool set_force_barr(short x, short y, bool b);
|
|
bool set_quickfire(short x, short y, bool b);
|
|
bool set_sm_blood(short x, short y, bool b);
|
|
bool set_med_blood(short x, short y, bool b);
|
|
bool set_lg_blood(short x, short y, bool b);
|
|
bool set_sm_slime(short x, short y, bool b);
|
|
bool set_lg_slime(short x, short y, bool b);
|
|
bool set_ash(short x, short y, bool b);
|
|
bool set_bones(short x, short y, bool b);
|
|
bool set_rubble(short x, short y, bool b);
|
|
bool set_force_cage(short x, short y, bool b);
|
|
bool set_road(short x, short y, bool b);
|
|
bool is_impassable(short x, short y);
|
|
void writeTo(std::ostream& file) const;
|
|
void readFrom(std::istream& file);
|
|
|
|
~cCurTown();
|
|
// It's not directly copyable due to the cUniverse reference, which must always point to the cUniverse that contains it.
|
|
// The cUniverse copy constructor is thus responsible for performing the copy.
|
|
cCurTown(const cCurTown&) = delete;
|
|
cCurTown& operator=(const cCurTown&) = delete;
|
|
// Not movable for similar reasons
|
|
cCurTown(const cCurTown&& other) = delete;
|
|
cCurTown& operator=(const cCurTown&& other) = delete;
|
|
// This implements the actual copy/move.
|
|
void copy(const cCurTown& other);
|
|
void swap(cCurTown& other);
|
|
};
|
|
|
|
class cCurOut {
|
|
cUniverse& univ;
|
|
public:
|
|
ter_num_t out[96][96];
|
|
unsigned char out_e[96][96]; // formerly out_info_type;
|
|
|
|
// These take global coords (ie 0..95)
|
|
bool is_spot(int x, int y);
|
|
bool is_road(int x, int y);
|
|
|
|
void import_legacy(legacy::out_info_type const &old);
|
|
|
|
typedef ter_num_t arr_96[96];
|
|
arr_96& operator [] (size_t i);
|
|
ter_num_t& operator [] (location loc);
|
|
void writeTo(std::ostream& file) const;
|
|
void readFrom(std::istream& file);
|
|
cOutdoors* operator->();
|
|
explicit cCurOut(cUniverse& univ);
|
|
// It's not directly copyable due to the cUniverse reference, which must always point to the cUniverse that contains it.
|
|
// The cUniverse copy constructor is thus responsible for performing the copy.
|
|
cCurOut(const cCurOut&) = delete;
|
|
cCurOut& operator=(const cCurOut&) = delete;
|
|
// Not movable for similar reasons
|
|
cCurOut(const cCurOut&& other) = delete;
|
|
cCurOut& operator=(const cCurOut&& other) = delete;
|
|
// This implements the actual copy/move.
|
|
void copy(const cCurOut& other);
|
|
void swap(cCurOut& other);
|
|
};
|
|
|
|
enum eTargetType {TARG_ANY, TARG_PC, TARG_MONST};
|
|
|
|
class cUniverse{
|
|
// The string buffer currently isn't saved
|
|
std::string strbuf;
|
|
std::map<int,std::string> extrabufs;
|
|
cItem get_random_store_item(int loot_type, bool allow_junk_treasure);
|
|
public:
|
|
void exportSummons();
|
|
void exportGraphics();
|
|
|
|
iLiving& get_target(size_t which);
|
|
iLiving* target_there(location pos, eTargetType type = TARG_ANY);
|
|
size_t get_target_i(iLiving& who);
|
|
|
|
std::string& get_buf() {return strbuf;}
|
|
void swap_buf(int newbuf) {std::swap(strbuf, extrabufs[newbuf]);}
|
|
|
|
unsigned char& cpn_flag(unsigned int x, unsigned int y, std::string id = "");
|
|
|
|
short cur_pc = 0;
|
|
cPlayer& current_pc();
|
|
|
|
cScenario scenario;
|
|
cParty party;
|
|
std::map<long,cPlayer*> stored_pcs;
|
|
cCurTown town;
|
|
cCurOut out;
|
|
fs::path file;
|
|
bool debug_mode { false };
|
|
bool ghost_mode { false };
|
|
bool node_step_through { false };
|
|
|
|
void clear_stored_pcs();
|
|
void import_legacy(legacy::stored_town_maps_type const &old);
|
|
void import_legacy(legacy::stored_outdoor_maps_type const &old);
|
|
void enter_scenario(const std::string& name);
|
|
void refresh_store_items();
|
|
void generate_job_bank(int which, job_bank_t& bank);
|
|
short difficulty_adjust() const;
|
|
explicit cUniverse(ePartyPreset party_type = PARTY_DEFAULT);
|
|
~cUniverse();
|
|
|
|
cItem const &get_item(item_num_t item) const { return scenario.get_item(item); }
|
|
cItem &get_item(item_num_t item) { return scenario.get_item(item); }
|
|
cQuest const &get_quest(int quest) const { return scenario.get_quest(quest); }
|
|
cQuest &get_quest(int quest) { return scenario.get_quest(quest); }
|
|
cShop const &get_shop(int shop) const { return scenario.get_shop(shop); }
|
|
cShop &get_shop(int shop) { return scenario.get_shop(shop); }
|
|
cSpecItem const &get_special_item(item_num_t item) const { return scenario.get_special_item(item); }
|
|
cSpecItem &get_special_item(item_num_t item) { return scenario.get_special_item(item); }
|
|
cTerrain const &get_terrain(ter_num_t ter) const { return scenario.get_terrain(ter); }
|
|
cTerrain &get_terrain(ter_num_t ter) { return scenario.get_terrain(ter); }
|
|
|
|
// Copy-and-swap
|
|
void swap(cUniverse& other);
|
|
cUniverse(const cUniverse& other);
|
|
cUniverse(cUniverse&& other);
|
|
cUniverse& operator=(cUniverse other);
|
|
static void(* print_result)(std::string);
|
|
};
|
|
|
|
#endif
|