tu_optimize/deck.h at master · draquila/tu_optimize · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#ifndef DECK_H_INCLUDED
#define DECK_H_INCLUDED

#include <deque>
#include <list>
#include <map>
#include <random>
#include <vector>
#include "tyrant.h"
#include "card.h"

class Cards;

std::string deck_hash(const Card* commander, std::vector<const Card*> cards, bool is_ordered);

//---------------------- $30 Deck: a commander + a sequence of cards -----------
// Can be shuffled.
// Implementations: random player and raid decks, ordered player decks.
//------------------------------------------------------------------------------
namespace DeckStrategy
{
enum DeckStrategy
{
    random,
    ordered,
    exact_ordered,
    num_deckstrategies
};
}

namespace DeckEncoding
{
enum DeckEncoding
{
    wmt_b64,
    ddd_b64,
    num_deckencodings
};
}
//------------------------------------------------------------------------------
// No support for ordered raid decks

extern DeckEncoding::DeckEncoding deck_encoding;

extern std::map<signed, char> empty_marks;
class Deck
{
public:
    DeckType::DeckType decktype;
    unsigned id;
    std::string name;
    DeckStrategy::DeckStrategy strategy;
    Effect effect; // for quests

    const Card* commander;
    const Card* fortress1{nullptr};
    const Card* fortress2{nullptr};

    std::vector<const Card*> cards;

    std::map<signed, char> card_marks;  // <positions of card, prefix mark>: -1 indicating the commander. E.g, used as a mark to be kept in attacking deck when optimizing.
    std::deque<const Card*> shuffled_cards;
    // card id -> card order
    std::map<unsigned, std::list<unsigned>> order;
    std::vector<std::pair<unsigned, std::vector<const Card*>>> raid_cards;
    std::vector<const Card*> reward_cards;
    unsigned mission_req;

    std::string deck_string;
    std::vector<unsigned> given_hand;

    Deck(
        DeckType::DeckType decktype_ = DeckType::deck,
        unsigned id_ = 0,
        std::string name_ = "",
        DeckStrategy::DeckStrategy strategy_ = DeckStrategy::random) :
        decktype(decktype_),
        id(id_),
        name(name_),
        strategy(strategy_),
        effect(Effect::none),
        commander(nullptr),
        mission_req(0)
    {
    }

    ~Deck() {}

    void set(
        const Card* commander_,
        const std::vector<const Card*>& cards_,
        std::vector<std::pair<unsigned, std::vector<const Card*>>> raid_cards_ = {},
        std::vector<const Card*> reward_cards_ = {},
        unsigned mission_req_ = 0)
    {
        commander = commander_;
        cards = std::vector<const Card*>(std::begin(cards_), std::end(cards_));
        raid_cards = std::vector<std::pair<unsigned, std::vector<const Card*>>>(raid_cards_);
        reward_cards = std::vector<const Card*>(reward_cards_);
        mission_req = mission_req_;
    }

    void set(const Cards& all_cards, const std::vector<unsigned>& ids, const std::map<signed, char> &marks = empty_marks);
    void set(const Cards& all_cards, const std::string& deck_string_);
    void resolve(const Cards& all_cards);
    void set_given_hand(const Cards& all_cards, const std::string& deck_string_);

    template<class Container>
    Container card_ids() const
    {
        Container results;
        results.insert(results.end(), commander->m_id);
        for(auto card: cards)
        {
            results.insert(results.end(), card->m_id);
        }
        return(results);
    }

    Deck* clone() const;
    std::string short_description() const;
    std::string medium_description() const;
    std::string long_description(const Cards& all_cards) const;
    const Card* get_commander();
    const Card* get_fortress1();
    void set_fortress1(const Card* card);
    const Card* get_fortress2();
    void set_fortress2(const Card* card);
    const Card* next();
    void shuffle(std::mt19937& re);
    void place_at_bottom(const Card* card);
};

// + also the custom decks
class Decks
{
public:
    std::list<Deck> decks;
    std::map<std::pair<DeckType::DeckType, unsigned>, Deck*> by_type_id;
    std::map<std::string, Deck*> by_name;
    std::map<std::string, std::string> custom_decks;
};

#endif