254 lines
8.1 KiB
C++
254 lines
8.1 KiB
C++
/*
|
|
* party.h
|
|
* BoE
|
|
*
|
|
* Created by Celtic Minstrel on 24/04/09.
|
|
*
|
|
*/
|
|
|
|
#ifndef BOE_DATA_PARTY_H
|
|
#define BOE_DATA_PARTY_H
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <array>
|
|
#include <map>
|
|
#include <set>
|
|
|
|
#include <boost/iterator/indirect_iterator.hpp>
|
|
|
|
#include "scenario/vehicle.hpp"
|
|
#include "population.hpp"
|
|
#include "scenario/item.hpp"
|
|
#include "pc.hpp"
|
|
#include "scenario/outdoors.hpp"
|
|
#include "scenario/monster.hpp"
|
|
#include "living.hpp"
|
|
#include "scenario/quest.hpp"
|
|
|
|
namespace legacy {
|
|
struct party_record_type;
|
|
struct big_tr_type;
|
|
struct stored_items_list_type;
|
|
struct talk_save_type;
|
|
struct creature_list_type;
|
|
struct pc_record_type;
|
|
struct setup_save_type;
|
|
};
|
|
|
|
template<typename T, size_t x, size_t y>
|
|
using array2d = std::array<std::array<T, y>, x>;
|
|
|
|
struct campaign_flag_type{
|
|
array2d<unsigned char, 25, 25> idx{};
|
|
private:
|
|
using idx_array = decltype(idx);
|
|
public:
|
|
static const int x_max = std::tuple_size<idx_array>::value;
|
|
static const int y_max = std::tuple_size<idx_array::value_type>::value;
|
|
};
|
|
|
|
struct job_bank_t {
|
|
std::array<int,6> jobs;
|
|
int anger = 0;
|
|
bool inited = false;
|
|
};
|
|
|
|
enum eEncNoteType {
|
|
NOTE_SCEN,
|
|
NOTE_OUT,
|
|
NOTE_TOWN,
|
|
};
|
|
|
|
class cUniverse;
|
|
class cItem;
|
|
class cTagFile;
|
|
|
|
class cParty : public iLiving {
|
|
public:
|
|
class cConvers { // conversation; formerly talk_save_type
|
|
public:
|
|
std::string who_said, in_town, the_str1, the_str2, in_scen;
|
|
|
|
void import_legacy(legacy::talk_save_type old, const cScenario& scenario);
|
|
};
|
|
class cJournal {
|
|
public:
|
|
unsigned short day;
|
|
std::string the_str, in_scen;
|
|
};
|
|
class cEncNote {
|
|
public:
|
|
eEncNoteType type;
|
|
std::string the_str, where, in_scen;
|
|
|
|
void import_legacy(int16_t(& old)[2], const cScenario& scenario);
|
|
};
|
|
// formerly party_record_type
|
|
// TODO: Should we make age a long long?
|
|
long next_pc_id = 1000;
|
|
unsigned long age;
|
|
unsigned short gold;
|
|
unsigned short food;
|
|
array2d<unsigned char, 350, 50> stuff_done;
|
|
// These used to be stored as magic SDFs
|
|
unsigned char hostiles_present;
|
|
bool easy_mode = false, less_wm = false;
|
|
// End former magic SDFs
|
|
std::array<unsigned char,90> magic_ptrs;
|
|
short light_level;
|
|
location outdoor_corner;
|
|
location i_w_c;
|
|
location out_loc, town_loc;
|
|
location loc_in_sec;
|
|
short town_num;
|
|
std::vector<cVehicle> boats;
|
|
std::vector<cVehicle> horses;
|
|
std::array<cPopulation,4> creature_save;
|
|
short in_boat;
|
|
short in_horse;
|
|
std::array<cOutdoors::cCreature,10> out_c;
|
|
std::map<int,std::map<int,cItem>> magic_store_items;
|
|
std::map<int,std::map<int,int>> store_limited_stock;
|
|
std::vector<job_bank_t> job_banks;
|
|
std::array<mon_num_t,4> imprisoned_monst; // Soul Crystal
|
|
std::set<mon_num_t> m_noted; // has the monster been scried?
|
|
std::set<mon_num_t> m_seen; // has the monster ever been seen? (this used to have the above meaning)
|
|
std::vector<cJournal> journal;
|
|
std::vector<cEncNote> special_notes;
|
|
std::vector<cConvers> talk_save;
|
|
std::map<ePartyStatus,short> status;
|
|
std::map<int, cJob> active_quests;
|
|
location left_at;
|
|
size_t left_in;
|
|
short at_which_save_slot;
|
|
std::bitset<20> alchemy;
|
|
std::map<int,int> key_times;
|
|
std::vector<cTimer> party_event_timers;
|
|
std::set<int> spec_items;
|
|
long long total_m_killed, total_dam_done, total_xp_gained, total_dam_taken;
|
|
std::string scen_name;
|
|
private:
|
|
std::array<std::unique_ptr<cPlayer>,6> adven;
|
|
public:
|
|
std::array<vector2d<unsigned short>, 4> setup; // formerly setup_save_type
|
|
std::array<std::vector<cItem>,3> stored_items; // formerly stored_items_list_type
|
|
|
|
std::vector<cMonster> summons; // an array of monsters which can be summoned by the party's items yet don't originate from this scenario
|
|
unsigned short scen_won, scen_played; // numbers of scenarios won and played respectively by this party
|
|
std::map<std::string,campaign_flag_type> campaign_flags;
|
|
private:
|
|
std::map<unsigned short,std::pair<unsigned short,unsigned char>> pointers;
|
|
using sd_array = decltype(stuff_done);
|
|
public:
|
|
static const int sdx_max = std::tuple_size<sd_array>::value;
|
|
static const int sdy_max = std::tuple_size<sd_array::value_type>::value;
|
|
|
|
void set_ptr(unsigned short p, unsigned short sdfx, unsigned short sdfy);
|
|
void force_ptr(unsigned short p, unsigned short val);
|
|
void clear_ptr(unsigned short p);
|
|
unsigned char get_ptr(unsigned short p) const;
|
|
|
|
void import_legacy(legacy::party_record_type& old, cUniverse& univ);
|
|
void import_legacy(legacy::big_tr_type& old);
|
|
void import_legacy(legacy::stored_items_list_type& old,short which_list);
|
|
void import_legacy(legacy::setup_save_type& old);
|
|
void import_legacy(legacy::pc_record_type(& old)[6]);
|
|
|
|
bool is_in_scenario() const;
|
|
bool is_alive() const override;
|
|
bool is_friendly() const override;
|
|
bool is_friendly(const iLiving& other) const override;
|
|
bool is_shielded() const override;
|
|
int get_shared_dmg(int base_dmg) const override;
|
|
location get_loc() const override;
|
|
|
|
void apply_status(eStatus which, int how_much) override;
|
|
void heal(int how_much) override;
|
|
void poison(int how_much) override;
|
|
void cure(int how_much) override;
|
|
void acid(int how_much) override;
|
|
void curse(int how_much) override;
|
|
void slow(int how_much) override;
|
|
void web(int how_much) override;
|
|
void disease(int how_much) override;
|
|
void dumbfound(int how_much) override;
|
|
void scare(int how_much) override;
|
|
void sleep(eStatus type, int how_much, int adj) override;
|
|
void clear_bad_status() override;
|
|
void avatar() override;
|
|
void drain_sp(int how_much, bool allow_resist) override;
|
|
void restore_sp(int how_much) override;
|
|
|
|
int get_health() const override;
|
|
int get_magic() const override;
|
|
int get_level() const override;
|
|
int calc_day() const;
|
|
|
|
std::unique_ptr<cPlayer> remove_pc(size_t spot);
|
|
void new_pc(size_t spot);
|
|
void replace_pc(size_t spot, std::unique_ptr<cPlayer> with);
|
|
size_t free_space() const;
|
|
size_t count(eMainStatus type = eMainStatus::ALIVE) const;
|
|
bool save_talk(const std::string& who, const std::string& where, const std::string& str1, const std::string& str2);
|
|
bool add_to_journal(const std::string& event, short day);
|
|
bool record(eEncNoteType type, const std::string& what, const std::string& where);
|
|
bool start_timer(short time, spec_num_t node, eSpecCtxType type);
|
|
cPlayer& operator[](unsigned short n);
|
|
const cPlayer& operator[](unsigned short n) const;
|
|
void writeTo(cTagFile& file) const;
|
|
void readFrom(const cTagFile& file);
|
|
|
|
bool give_item(cItem item,int flags);
|
|
bool forced_give(cItem item,eItemAbil abil,short dat = -1);
|
|
bool has_abil(eItemAbil abil, short dat = -1) const;
|
|
bool take_abil(eItemAbil abil, short dat = -1);
|
|
bool has_class(unsigned int item_class);
|
|
bool take_class(unsigned int item_class) const;
|
|
|
|
bool start_split(short x, short y, snd_num_t noise, short who);
|
|
bool end_split(snd_num_t noise);
|
|
bool is_split() const;
|
|
bool pc_present(short n) const;
|
|
iLiving& pc_present() const; // If only one pc is present, returns that pc. Otherwise returns party.
|
|
void swap_pcs(size_t a, size_t b);
|
|
|
|
bool sd_legit(short a, short b) const;
|
|
void wipe_sdfs();
|
|
|
|
auto begin() -> boost::indirect_iterator<decltype(adven)::iterator> {
|
|
return boost::make_indirect_iterator(adven.begin());
|
|
}
|
|
|
|
auto end() -> boost::indirect_iterator<decltype(adven)::iterator> {
|
|
return boost::make_indirect_iterator(adven.end());
|
|
}
|
|
|
|
auto begin() const -> boost::indirect_iterator<decltype(adven)::const_iterator> {
|
|
return boost::make_indirect_iterator(adven.begin());
|
|
}
|
|
|
|
auto end() const -> boost::indirect_iterator<decltype(adven)::const_iterator> {
|
|
return boost::make_indirect_iterator(adven.end());
|
|
}
|
|
|
|
typedef std::vector<cEncNote>::iterator encIter;
|
|
typedef std::vector<cJournal>::iterator journalIter;
|
|
typedef std::vector<cConvers>::iterator talkIter;
|
|
cParty(ePartyPreset party_preset = PARTY_DEFAULT);
|
|
// Copy-and-swap
|
|
friend void swap(cParty& lhs, cParty& rhs);
|
|
cParty(const cParty& other);
|
|
cParty(cParty&& other);
|
|
cParty& operator=(cParty other);
|
|
};
|
|
|
|
bool operator==(const cParty::cConvers& one, const cParty::cConvers& two);
|
|
bool operator==(const cParty::cJournal& one, const cParty::cJournal& two);
|
|
bool operator==(const cParty::cEncNote& one, const cParty::cEncNote& two);
|
|
|
|
std::istream& operator>>(std::istream& in, eEncNoteType& type);
|
|
std::ostream& operator<<(std::ostream& out, eEncNoteType type);
|
|
|
|
#endif
|