move 'Kills.h' -> 'kills.h', 'Kills.cc' -> 'kills.cc' for file naming consistency

Signed-off-by: Steven Noonan <steven@uplinklabs.net>

1 files changed, 199 insertions, 0 deletions

diff --git a/crawl-ref/source/kills.h b/crawl-ref/source/kills.h
new file mode 100644
index 0000000000..febaa13e77
--- /dev/null
+++ b/crawl-ref/source/kills.h
@@ -0,0 +1,199 @@
+/*
+ *  File:       kills.h
+ *  Summary:    Tracks monsters the player has killed.
+ *  Written by: Darshan Shaligram
+ *
+ *  Modified for Crawl Reference by $Author$ on $Date$
+ */
+
+#ifndef KILLS_H
+#define KILLS_H
+
+#include <vector>
+#include <string>
+#include <map>
+#include <stdio.h>
+#include "enum.h"
+
+std::string apostrophise(const std::string &name);
+std::string apostrophise_fixup(const std::string &sentence);
+
+class monsters;
+class reader;
+class writer;
+
+// Not intended for external use!
+struct kill_monster_desc
+{
+    kill_monster_desc(const monsters *);
+    kill_monster_desc() { }
+
+    void save(writer&) const;
+    void load(reader&);
+
+    enum name_modifier
+    {
+        M_NORMAL, M_ZOMBIE, M_SKELETON, M_SIMULACRUM, M_SPECTRE,
+        M_SHAPESHIFTER  // A shapeshifter pretending to be 'monnum'
+    };
+
+    int monnum;                 // Number of the beast
+    name_modifier modifier;     // Nature of the beast
+
+    struct less_than
+    {
+        bool operator () ( const kill_monster_desc &m1,
+                           const kill_monster_desc &m2) const
+        {
+            return m1.monnum < m2.monnum ||
+                (m1.monnum == m2.monnum && m1.modifier < m2.modifier);
+        }
+    };
+};
+
+#define PLACE_LIMIT 5   // How many unique kill places we're prepared to track
+class kill_def
+{
+public:
+    kill_def(const monsters *mon);
+    kill_def() : kills(0), exp(0)
+    {
+        // This object just says to the world that it's uninitialised
+    }
+
+    void save(writer&) const;
+    void load(reader&);
+
+    void add_kill(const monsters *mon, unsigned short place);
+    void add_place(unsigned short place, bool force = false);
+
+    void merge(const kill_def &k, bool unique_monster);
+
+    std::string info(const kill_monster_desc &md) const;
+    std::string base_name(const kill_monster_desc &md) const;
+
+    unsigned short kills;           // How many kills does the player have?
+    int            exp;             // Experience gained for slaying the beast.
+                                    // Only set *once*, even for shapeshifters.
+
+    std::vector<unsigned short> places; // Places where we've killed the beast.
+private:
+    std::string append_places(const kill_monster_desc &md,
+            const std::string &name) const;
+};
+
+// Ghosts and random Pandemonium demons.
+class kill_ghost
+{
+public:
+    kill_ghost(const monsters *mon);
+    kill_ghost() { }
+
+    void save(writer&) const;
+    void load(reader&);
+
+    std::string info() const;
+
+    std::string ghost_name;
+    int exp;
+    unsigned short place;
+};
+
+// This is the structure that Lua sees.
+struct kill_exp
+{
+    int nkills;
+    int exp;
+    std::string base_name;
+    std::string desc;
+
+    int monnum;       // Number of the beast
+    int modifier;     // Nature of the beast
+
+    std::vector<unsigned short> places;
+
+    kill_exp(const kill_def &k, const kill_monster_desc &md)
+        : nkills(k.kills), exp(k.exp), base_name(k.base_name(md)),
+          desc(k.info(md)),
+          monnum(md.monnum), modifier(md.modifier)
+    {
+        places = k.places;
+    }
+
+    kill_exp(const kill_ghost &kg)
+        : nkills(1), exp(kg.exp), base_name(), desc(kg.info()),
+          monnum(-1), modifier(0)
+    {
+        places.push_back(kg.place);
+    }
+
+    // operator< is implemented for a descending sort.
+    bool operator < ( const kill_exp &b) const
+    {
+        return exp == b.exp? (base_name < b.base_name) : (exp > b.exp);
+    }
+};
+
+class Kills
+{
+public:
+    void record_kill(const monsters *mon);
+    void merge(const Kills &k);
+
+    bool empty() const;
+    void save(writer&) const;
+    void load(reader&);
+
+    long get_kills(std::vector<kill_exp> &v) const;
+    int num_kills(const monsters *mon) const;
+private:
+    typedef std::map<kill_monster_desc,
+                     kill_def,
+                     kill_monster_desc::less_than> kill_map;
+    typedef std::vector<kill_ghost> ghost_vec;
+
+    kill_map    kills;
+    ghost_vec   ghosts;
+
+    void record_ghost_kill(const monsters *mon);
+};
+
+class KillMaster
+{
+public:
+    KillMaster();
+    KillMaster(const KillMaster& other);
+    ~KillMaster();
+
+    void record_kill(const monsters *mon, int killer, bool ispet);
+
+    bool empty() const;
+    void save(writer&) const;
+    void load(reader&);
+
+    // Number of kills, by category.
+    long num_kills(const monsters *mon, kill_category cat) const;
+    // Number of kills, any category.
+    long num_kills(const monsters *mon) const;
+
+    long total_kills() const;
+
+    std::string kill_info() const;
+private:
+    const char *category_name(kill_category kc) const;
+
+    Kills categorized_kills[KC_NCATEGORIES];
+private:
+    void add_kill_info(std::string &, std::vector<kill_exp> &,
+                       long count, const char *c, bool separator)
+        const;
+};
+
+enum KILL_DUMP_OPTIONS
+{
+    KDO_NO_PLACES,          // Don't dump places at all
+    KDO_ONE_PLACE,          // Show places only for single kills and uniques.
+    KDO_ALL_PLACES          // Show all available place information
+};
+
+#endif