From d5e5340c3926d1cf97f6cba151ffaecb20bfb35f Mon Sep 17 00:00:00 2001 From: dshaligram Date: Wed, 2 Aug 2006 12:54:15 +0000 Subject: Integrated travel patch as of 20060727 git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@7 c06c8d41-db1a-0410-9941-cceddc491573 --- trunk/source/stash.h | 327 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 327 insertions(+) create mode 100644 trunk/source/stash.h (limited to 'trunk/source/stash.h') diff --git a/trunk/source/stash.h b/trunk/source/stash.h new file mode 100644 index 0000000000..5e36eb4a61 --- /dev/null +++ b/trunk/source/stash.h @@ -0,0 +1,327 @@ +/* + * File: stash.h + * Summary: Classes tracking player stashes + * Written by: Darshan Shaligram + */ +#ifndef STASH_H +#define STASH_H + +#include "AppHdr.h" +#include "shopping.h" +#include + +#ifdef STASH_TRACKING + +#include +#include +#include + +#include "externs.h" +#include "travel.h" + +// Stash definitions + +enum STASH_TRACK_MODES +{ + STM_NONE, // Stashes are not tracked + STM_EXPLICIT, // Only explicitly marked stashes are tracked + STM_DROPPED, // Dropped items and explicitly marked stashes are + // tracked + STM_ALL // All seen items are tracked +}; + +struct stash_search_result; +class Stash +{ +public: + Stash(int xp = -1, int yp = -1); + + static void filter(unsigned char base_type, unsigned char sub_type); + static void filter(const std::string &filt); + + static std::string stash_item_name(const item_def &item); + void update(); + void save(FILE*) const; + void load(FILE*); + + std::string description() const; + + bool show_menu(const std::string &place, bool can_travel) const; + + bool matches_search(const std::string &prefix, + const base_pattern &search, + stash_search_result &res) + const; + + void write(std::ostream &os, int refx = 0, int refy = 0, + std::string place = "", + bool identify = false) const; + + bool empty() const + { + return items.empty() && enabled; + } + + bool isAt(int xp, int yp) const { return x == xp && y == yp; } + int abs_pos() const { return abspos; } + int getX() const { return (int) x; } + int getY() const { return (int) y; } + + bool is_verified() const { return verified; } + + bool enabled; // If false, this Stash will neither track + // items nor dump itself. Disabled stashes are + // also never removed from the level's map of + // stashes. +private: + bool verified; // Is this correct to the best of our knowledge? + unsigned char x, y; + int abspos; + std::vector items; + + /* + * If true (the default), the stash-tracker is a lot more likely to consider + * squares that the player is not standing on as correctly-verified. This + * will lead to cleaner dumps, but the chance of stashes not accurately + * reflecting what's in the dungeon also increases. + */ + static bool aggressive_verify; + static std::vector filters; + + static bool are_items_same(const item_def &, const item_def &); + static bool is_filtered(const item_def &item); +}; + +class ShopInfo +{ +public: + ShopInfo(int xp, int yp); + + bool matches_search(const std::string &prefix, + const base_pattern &search, + stash_search_result &res) + const; + + std::string description() const; + + // Note that we aren't bothering to use virtual functions here. + void save(FILE*) const; + void load(FILE*); + + bool show_menu(const std::string &place, bool can_travel) const; + bool is_visited() const { return items.size() || visited; } + + void write(std::ostream &os, bool identify = false) const; + + void reset() { items.clear(); visited = true; } + void set_name(const char *s) { name = s; } + + void add_item(const item_def &item, unsigned price); + + bool isAt(int xp, int yp) const { return x == xp && y == yp; } + +private: + int x, y; + std::string name; + + int shoptype; + + // Set true if the player has visited this shop + bool visited; + + // Messy! + struct shop_item + { + item_def item; + unsigned price; + }; + std::vector items; + + std::string shop_item_name(const shop_item &si) const; + std::string shop_item_desc(const shop_item &si) const; + void describe_shop_item(const shop_item &si) const; + + class ShopId { + public: + ShopId(int stype); + ~ShopId(); + private: + int shoptype; + id_fix_arr id; + }; +}; + +struct stash_search_result +{ + // What level is this stash or shop on. + level_id level; + + coord_def pos; + + // Number of levels the player must cross to reach the level the stash/shop + // is on. + int player_distance; + + // Number of items in the stash that match the search. + int matches; + + // Count of items stacks in the stash that matched. This will be the same as + // matches if each matching stack's quantity is 1. + int count; + + // First item in stash that matched + std::string match; + + // The stash or shop in question. + const Stash *stash; + const ShopInfo *shop; + + stash_search_result() : level(), player_distance(0), matches(0), + count(0), match(), stash(NULL), shop(NULL) + { + } + + bool operator < ( const stash_search_result &ssr ) const + { + return player_distance < ssr.player_distance || + (player_distance == ssr.player_distance && + matches > ssr.matches); + } +}; + +extern std::ostream &operator << (std::ostream &, const Stash &); + +class LevelStashes +{ +public: + LevelStashes(); + + Stash *find_stash(int x = -1, int y = -1); + ShopInfo &get_shop(int x, int y); + const ShopInfo *find_shop(int x, int y) const; + + void get_matching_stashes(const base_pattern &search, + std::vector &results) const; + + // Update stash at (x,y) on current level, defaulting to player's current + // location if no parameters are supplied. + bool update_stash(int x = -1, int y = -1); + + // Add stash at (x,y), or player's current location if no parameters are + // supplied + void add_stash(int x = -1, int y = -1); + + // Mark square (x,y) as not stashworthy. The player's current location is + // used if no parameters are supplied. + void no_stash(int x = -1, int y = -1); + + void kill_stash(const Stash &s); + + void save(FILE *) const; + void load(FILE *); + + void write(std::ostream &os, bool identify = false) const; + std::string level_name() const; + std::string short_level_name() const; + bool in_hell() const; + bool in_branch(int) const; + + int stash_count() const { return stashes.size() + shops.size(); } + int visible_stash_count() const { return count_stashes() + shops.size(); } + + bool isCurrent() const; + bool isBelowPlayer() const; + bool operator < (const LevelStashes &lev) const; +private: + // which level + unsigned char branch; + int depth; + + typedef std::map c_stashes; + typedef std::vector c_shops; + + c_stashes stashes; + c_shops shops; + + int count_stashes() const; +}; + +extern std::ostream &operator << (std::ostream &, const LevelStashes &); + +class StashTracker +{ +public: + static bool is_level_untrackable() + { + return you.level_type == LEVEL_LABYRINTH + || you.level_type == LEVEL_ABYSS; + } + + StashTracker() : levels() + { + } + + void search_stashes(); + + LevelStashes &get_current_level(); + LevelStashes *find_current_level(); + + ShopInfo &get_shop(int x, int y) + { + return get_current_level().get_shop(x, y); + } + + void remove_level(const LevelStashes &ls); + + enum stash_update_mode + { + ST_PASSIVE, // Maintain existing stashes only. + ST_AGGRESSIVE // Create stashes for each square containing + // objects, even if those squares were not + // previously marked as stashes. + }; + + void update_visible_stashes(StashTracker::stash_update_mode = ST_PASSIVE); + + // Update stash at (x,y) on current level, defaulting to player's current + // location if no parameters are supplied, return true if a stash was + // updated. + bool update_stash(int x = -1, int y = -1); + + // Add stash at (x,y), or player's current location if no parameters are + // supplied + void add_stash(int x = -1, int y = -1, bool verbose = false); + + // Mark square (x,y) as not stashworthy. The player's current location is + // used if no parameters are supplied. + void no_stash(int x = -1, int y = -1); + + void save(FILE*) const; + void load(FILE*); + + void write(std::ostream &os, bool identify = false) const; + + void dump(const char *filename, bool identify = false) const; +private: + std::vector levels; + + void get_matching_stashes(const base_pattern &search, + std::vector &results) const; + void display_search_results(std::vector &results); +}; + +extern StashTracker stashes; + +bool is_stash(int x, int y); +void describe_stash(int x, int y); + +#endif // STASH_TRACKING + +std::string branch_level_name(unsigned char branch, int sub_depth); + +std::string branch_level_name(unsigned short packed_place); + +std::string userdef_annotate_item(const char *s, const item_def *item, + bool exclusive = false); + +#endif -- cgit v1.2.3-54-g00ecf