Skip to content

M
magicseteditor
Commit 1cf4d1c8 authored by twanvl's avatar twanvl
Browse files
Options

the new pack system now actually works (yay!)

parent 41b7ae72
Hide whitespace changes
Inline Side-by-side
Showing with 353 additions and 446 deletions
src/data/pack.cpp
View file @ 1cf4d1c8
......@@ -153,26 +153,27 @@ vector<CardP>& PackItemCache::cardsFor(const String& name) {
}
#else
// =================================================================================================== NEW
DECLARE_TYPEOF_COLLECTION(PackTypeP);
DECLARE_TYPEOF_COLLECTION(PackItemP);
DECLARE_TYPEOF_COLLECTION(CardP);
DECLARE_TYPEOF_CONST(map<String COMMA PackInstanceP>);
// ----------------------------------------------------------------------------- : PackType
PackType::PackType()
: enabled(true)
, selectable(true)
, summary(true)
, select(SELECT_ALL)
{}
IMPLEMENT_REFLECTION_ENUM(OneMany) {
IMPLEMENT_REFLECTION_ENUM(PackSelectType) {
VALUE_N("auto", SELECT_AUTO);
VALUE_N("all", SELECT_ALL);
VALUE_N("at most one", SELECT_ONE_OR_EMPTY);
VALUE_N("one", SELECT_ONE);
VALUE_N("replace", SELECT_REPLACE);
VALUE_N("no replace", SELECT_NO_REPLACE);
VALUE_N("cyclic", SELECT_CYCLIC);
VALUE_N("one", SELECT_PROPORTIONAL);
VALUE_N("nonempty", SELECT_NONEMPTY);
VALUE_N("first", SELECT_FIRST);
}
......@@ -182,133 +183,133 @@ IMPLEMENT_REFLECTION(PackType) {
REFLECT(selectable);
REFLECT(summary);
REFLECT(select);
REFLECT(cards);
REFLECT(filter);
REFLECT(items);
REFLECT_IF_READING {
if (select == SELECT_AUTO) {
if (filter) select = SELECT_NO_REPLACE;
else if (!items.empty()) select = SELECT_ALL;
}
}
}
bool PackType::update(Context& ctx) {
bool change = enabled.update(ctx);
FOR_EACH(item, items) {
change |= item->update(ctx);
}
return change;
IMPLEMENT_REFLECTION(PackItem) {
REFLECT(name);
REFLECT(amount);
REFLECT(probability);
}
// ----------------------------------------------------------------------------- : PackItem
PackType::PackType()
: enabled(true)
, selectable(true)
, summary(true)
, select(SELECT_AUTO)
{}
PackItem::PackItem()
: amount(1)
, type(PACK_REF_INHERIT)
{}
IMPLEMENT_REFLECTION_ENUM(PackSelectType) {
VALUE_N("inherit", PACK_REF_INHERIT);
VALUE_N("replace", PACK_REF_REPLACE);
VALUE_N("no replace", PACK_REF_NO_REPLACE);
VALUE_N("cyclic", PACK_REF_CYCLIC);
}
IMPLEMENT_REFLECTION(PackItem) {
REFLECT(pack);
REFLECT(amount);
REFLECT(type);
}
bool PackItem::update(Context& ctx) {
return amount.update(ctx);
}
// ----------------------------------------------------------------------------- : PackItemCache
ScriptValueP PackItemCache::cardsFor(const ScriptValueP& generate) {
// lookup name
ScriptValueP& value = item_cards[generate];
if (!value) {
value = generate->eval(set.getContext());
bool PackType::update(Context& ctx) {
bool change = enabled.update(ctx);
FOR_EACH(item, items) {
change |= item->update(ctx);
}
return value;
return change;
}
const PackType& PackItemCache::pack(const String& name) {
// not used before, generate list and cache
FOR_EACH(pack, set.game->pack_types) {
if (pack->name == name) {
return *pack;
bool PackItem::update(Context& ctx) {
return amount.update(ctx)
| probability.update(ctx);
}
// ----------------------------------------------------------------------------- : PackInstance
PackInstance::PackInstance(const PackType& pack_type, PackGenerator& parent)
: pack_type(pack_type)
, parent(parent)
, requested_copies(0)
, card_copies(0)
, expected_copies(0)
{
// Filter cards
if (pack_type.filter) {
FOR_EACH(card, parent.set->cards) {
Context& ctx = parent.set->getContext(card);
bool keep = *pack_type.filter.invoke(ctx);
if (keep) {
cards.push_back(card);
}
}
}
// not found
throw Error(_ERROR_1_("pack type not found", name));
}
// ----------------------------------------------------------------------------- : Counting expected cards
double PackItemCounter::probabilityNonEmpty(const PackType& pack) {
// TODO: cache?
if (pack.cards) {
return cardsFor(pack.cards.getScriptP())->itemCount();
} else if (pack.select == SELECT_ONE_OR_EMPTY) {
// weighted avarage
double p = 0.0;
double total_weight = 0.0;
FOR_EACH_CONST(i,pack.items) {
p += i->weight * probabilityNonEmpty(*i);
total_weight += i->weight;
// Count items
if (pack_type.select == SELECT_FIRST) {
// count = count of first nonempty thing
if (!cards.empty()) {
count = 1;
} else {
FOR_EACH_CONST(item, pack_type.items) {
count += parent.get(item->name).count;
if (count > 0) break;
}
}
return p / total_weight;
} else { // SELECT_ONE, SELECT_FIRST, SELECT_ALL
// disjunction
double p = 0.0;
FOR_EACH_CONST(i,pack.items) {
// either already non-empty, or all previous items were empty so pick this one
p += (1-p) * probabilityNonEmpty(*i);
if (p >= 1 - 1e-6) return 1.0;
} else {
count = cards.size();
FOR_EACH_CONST(item, pack_type.items) {
count += parent.get(item->name).count;
}
return p;
}
}
double PackItemCounter::probabilityNonEmpty(const PackItem& item) {
return item.amount <= 0 ? 0 : probabilityNonEmpty(pack(item.pack));
// Sum of probabilities
total_probability = cards.size();
FOR_EACH_CONST(item, pack_type.items) {
if (pack_type.select == SELECT_PROPORTIONAL) {
total_probability += item->probability * parent.get(item->name).count;
} else if (pack_type.select == SELECT_NONEMPTY) {
if (parent.get(item->name).count > 0) {
total_probability += item->probability;
}
} else {
total_probability += item->probability;
}
}
// Depth
depth = 0;
FOR_EACH_CONST(item, pack_type.items) {
depth = max(depth, 1 + parent.get(item->name).depth);
}
}
void PackItemCounter::addCountRecursive(const PackType& pack, double copies) {
// add
counts[&pack] += copies * probabilityNonEmpty(pack);
// recurse
if (pack.cards) {
// done
} else if (pack.select == SELECT_FIRST) {
double p = 1;
FOR_EACH_CONST(i, pack.items) {
addCountRecursive(*i, p * copies);
p *= 1 - probabilityNonEmpty(*i);
if (p < 1e-6) return;
}
} else if (pack.select == SELECT_ONE_OR_EMPTY || pack.select == SELECT_ONE) {
double total_weight = 0.0;
FOR_EACH_CONST(i, pack.items) {
total_weight += i->weight * (pack.select == SELECT_ONE ? probabilityNonEmpty(*i) : 1.0);
}
FOR_EACH_CONST(i, pack.items) {
addCountRecursive(*i, copies * i->weight / total_weight);
}
} else if (pack.select == SELECT_ALL) {
FOR_EACH_CONST(i, pack.items) {
addCountRecursive(*i, copies);
void PackInstance::expect_copy(double copies) {
this->expected_copies += copies;
// propagate
FOR_EACH_CONST(item, pack_type.items) {
PackInstance& i = parent.get(item->name);
if (pack_type.select == SELECT_ALL) {
i.expect_copy(copies * item->amount);
} else if (pack_type.select == SELECT_PROPORTIONAL) {
i.expect_copy(copies * item->amount * item->probability * i.count / total_probability);
} else if (pack_type.select == SELECT_NONEMPTY) {
if (i.count >= 0) {
i.expect_copy(copies * item->amount * item->probability / total_probability);
}
} else if (pack_type.select == SELECT_FIRST) {
if (i.count >= 0 && cards.empty()) {
i.expect_copy(copies * item->amount);
break;
}
} else {
i.expect_copy(copies * item->amount * item->probability / total_probability);
}
} else {
throw InternalError(_("unknown OneMany value"));
}
}
void PackItemCounter::addCountRecursive(const PackItem& item, double copies) {
addCountRecursive(pack(item.pack), item.amount * copies);
void PackInstance::request_copy(size_t copies) {
requested_copies += copies;
}
// ----------------------------------------------------------------------------- : Generating
DECLARE_TYPEOF(PackItemGenerator::OfTypeCount);
/// Random generator with random numbers in a range
template <typename Gen>
struct RandomRange {
......@@ -317,256 +318,161 @@ struct RandomRange {
Gen& gen;
};
bool PackItemGenerator::generateCount(const PackType& pack, int copies, PackSelectType type, OfTypeCount& out) {
if (copies <= 0) return false;
bool non_empty = false;
if (pack.cards) {
ScriptValueP the_cards = cardsFor(pack.cards.getScriptP());
non_empty = the_cards->itemCount() > 0;
if (non_empty) {
out[make_pair(the_cards,type)] += copies;
}
} else if (pack.select == SELECT_ALL) {
// just generate all
FOR_EACH_CONST(i, pack.items) {
non_empty |= generateCount(*i, 1, type, out);
}
} else {
// generate each copy separately
for (int j = 0 ; j < copies ; ++j) {
non_empty |= generateSingleCount(pack, type, out);
}
}
return non_empty;
}
bool PackItemGenerator::generateSingleCount(const PackType& pack, PackSelectType type, OfTypeCount& out) {
if (pack.select == SELECT_ONE_OR_EMPTY) {
// pick a random item by weight
double total_weight = 0.0;
FOR_EACH_CONST(i, pack.items) {
total_weight += i->weight;
}
double choice = gen() * total_weight / gen.max();
FOR_EACH_CONST(i, pack.items) {
if ((choice -= i->weight) <= 0) {
// pick this one
return generateCount(*i, 1, type, out);
void PackInstance::generate(vector<CardP>* out) {
card_copies = 0;
if (pack_type.select == SELECT_ALL) {
// add all cards
card_copies += requested_copies * cards.size();
if (out) {
for (size_t i = 0 ; i < requested_copies ; ++i) {
out->insert(out->end(), cards.begin(), cards.end());
}
}
} else if (pack.select == SELECT_ONE) {
// pick a random item by weight that is not empty
UInt possible = 0; // bitmask
double total_weight = 0.0;
for (size_t i = 0 ; i < pack.items.size() ; ++i) {
total_weight += pack.items[i]->weight;
possible |= 1 << i;
// and all items
FOR_EACH_CONST(item, pack_type.items) {
PackInstance& i = parent.get(item->name);
i.request_copy(requested_copies * item->amount);
}
while (possible) {
// try to make a choice we have not made before
int choice = gen() * total_weight / gen.max();
for (size_t i = 0 ; i < pack.items.size() ; ++i) {
const PackItem& item = *pack.items[i];
if (!(possible & (1<<i))) continue; // already tried this item?
if ((choice -= item.weight) <= 0) {
bool non_empty = generateCount(item, 1, type, out);
if (non_empty) {
// found a non-empty choice, done
return true;
} else {
// try again, exclude this item
possible &= ~(1 << i);
total_weight -= item.weight;
} else if (pack_type.select == SELECT_REPLACE
|| pack_type.select == SELECT_PROPORTIONAL
|| pack_type.select == SELECT_NONEMPTY) {
// multiple copies
for (size_t i = 0 ; i < requested_copies ; ++i) {
double r = rand() * total_probability;
if (r < cards.size()) {
// pick a card
card_copies++;
if (out) {
int i = (int)r;
out->push_back(cards[i]);
}
} else {
// pick an item
r -= cards.size();
FOR_EACH_CONST(item, pack_type.items) {
PackInstance& i = parent.get(item->name);
if (pack_type.select == SELECT_REPLACE) {
r -= item->probability;
} else if (pack_type.select == SELECT_PROPORTIONAL) {
r -= item->probability * i.count;
} else { // SELECT_NONEMPTY
if (i.count > 0) r -= item->probability;
}
// have we reached the item we were looking for?
if (r < 0) {
i.request_copy(requested_copies * item->amount);
break;
}
}
}
}
} else if (pack.select == SELECT_FIRST) {
// pick the first one that is not empty
FOR_EACH_CONST(i, pack.items) {
bool non_empty = generateCount(*i, 1, type, out);
if (non_empty) return true;
}
} else {
throw InternalError(_("unknown OneMany value"));
}
return false;
}
bool PackItemGenerator::generateCount(const PackItem& item, int copies, PackSelectType type, OfTypeCount& out) {
return generateCount(pack(item.pack), copies * item.amount, item.type == PACK_REF_INHERIT ? type : item.type, out);
}
void PackItemGenerator::generate(const PackType& pack) {
// first determine how many cards of each basic type we need
OfTypeCount counts;
generateCount(pack, 1, PACK_REF_NO_REPLACE, counts);
// now select these cards
FOR_EACH(c, counts) {
pickCards(c.first.first, c.first.second, c.second);
}
}
void PackItemGenerator::pickCards(const ScriptValueP& cards, PackSelectType type, int amount) {
// generate 'amount' cards and add them to out
int cards_size = cards->itemCount();
if (cards_size <= 0) return;
RandomRange<boost::mt19937> gen_range(gen);
if (type == PACK_REF_REPLACE) {
// amount random numbers
for (int i = 0 ; i < amount ; ++i) {
int index = gen_range(cards_size);
out.push_back(from_script<CardP>(cards->getIndex(index)));
}
} else if (type == PACK_REF_NO_REPLACE) {
// random shuffle
// to prevent us from being too predictable for small sets, periodically reshuffle
int max_per_batch = (cards_size + 1) / 2;
while (amount > 0) {
int to_add = min(amount, max_per_batch);
size_t old_out_size = out.size();
// add all to output temporarily
ScriptValueP it = cards->makeIterator(cards);
while (ScriptValueP card = it->next()) {
out.push_back(from_script<CardP>(card));
} else if (pack_type.select == SELECT_NO_REPLACE) {
card_copies += requested_copies;
// NOTE: there is no way to pick items without replacement
if (out) {
// to prevent us from being too predictable for small sets, periodically reshuffle
RandomRange<boost::mt19937> gen_range(parent.gen);
int max_per_batch = ((int)cards.size() + 1) / 2;
int rem = (int)requested_copies;
while (rem > 0) {
random_shuffle(cards.begin(), cards.end(), gen_range);
out->insert(out->end(), cards.begin(), cards.begin() + min(rem, max_per_batch));
rem -= max_per_batch;
}
// shuffle and keep only the first to_add
random_shuffle(out.begin() + old_out_size, out.end(), gen_range);
out.resize(old_out_size + to_add);
amount -= to_add;
}
} else if (type == PACK_REF_CYCLIC) {
// multiple copies
int copies = amount / cards_size;
ScriptValueP it = cards->makeIterator(cards);
while (ScriptValueP card = it->next()) {
out.insert(out.end(), copies, from_script<CardP>(card));
}
amount -= copies * cards_size;
// if amount is not a multiple of the number of cards, pick the rest at random
for (int i = 0 ; i < amount ; ++i) {
int index = gen_range(cards_size);
out.push_back(from_script<CardP>(cards->getIndex(index)));
}
}
}
/*//%
// ----------------------------------------------------------------------------- : PackItem
void PackItemCounter::count(const String& name, double amount) {
map<PackItemRef*,double>::iterator it = sizes.find(name);
if (it != sizes.end()) return it->second;
size *= amount * probability;
return sizes[&item] = size;
}
void PackItemCounter::count(const PackType& pack, int copies) {
double size = 0;
if (pack.select = ONE) {
double total_size;
FOR_EACH(item, pack.items) {
double item_size = size(item);
if (item->type == OTHER_IF_EMPTY) {
// is it empty?
total_size += item_size > 0 ? 1 : 0;
max_size += 1;
} else if (item->type == WEIGHTED) {
total_size += item_size;
max_size += item_size;
} else if (pack_type.select == SELECT_CYCLIC) {
size_t total = cards.size() + pack_type.items.size();
size_t div = requested_copies / total;
size_t rem = requested_copies % total;
for (size_t i = 0 ; i < total ; ++i) {
// how many copies of this card/item do we need?
size_t copies = div + (i < rem ? 1 : 0);
if (i < cards.size()) {
card_copies += copies;
if (out) out->insert(out->end(), copies, cards[i]);
} else {
total_size += 1;
max_size += 1;
const PackItemP& item = pack_type.items[i];
parent.get(item->name).request_copy(copies * item->amount);
}
}
size += total_size / max_size;
// count
FOR_EACH(item, pack.items) {
double item_size = size(item);
if (item_size > 0 && !item->cards) {
if (item->type == OTHER_IF_EMPTY) {
// is it empty?
total_size += item_size > 0 ? 1 : 0;
max_size += 1;
} else if (item->type == WEIGHTED) {
total_size += item_size;
max_size += item_size;
} else {
total_size += 1;
max_size += 1;
} else if (pack_type.select == SELECT_FIRST) {
if (!cards.empty()) {
// there is a card, pick it
card_copies += requested_copies;
if (out) out->push_back(cards.front());
} else {
// pick first nonempty item
FOR_EACH_CONST(item, pack_type.items) {
PackInstance& i = parent.get(item->name);
if (i.count >= 0) {
i.request_copy(requested_copies * item->amount);
break;
}
}
}
} else { // MANY
}
amounts[pack.name] += amount;
requested_copies = 0;
}
double PackItemCounter::size(const String& name) {
map<PackItemRef*,double>::iterator it = sizes.find(name);
if (it != sizes.end()) return it->second;
double the_size = 0;
FOR_EACH() {
the_size += size(item);
}
return sizes[&item] = the_size;
// ----------------------------------------------------------------------------- : PackGenerator
void PackGenerator::reset(const SetP& set, int seed) {
this->set = set;
gen.seed((unsigned)seed);
max_depth = 0;
instances.clear();
}
double PackItemCounter::size(const PackItemRef& item) {
String the_name;
double the_size;
if (cards) {
the_size = cards.invokeOn(ctx)->itemCount() > 0 ? 1 : 0;
PackInstance& PackGenerator::get(const String& name) {
PackInstanceP& instance = instances[name];
if (instance) {
return *instance;
} else {
the_size = size(name);
the_name = name;
}
if (the_size == 0 && !if_empty.empty())
the_name = if_empty;
the_size = size(if_empty);
}
if (!the_name.empty()) {
counts[the_name] += amount * probability;
FOR_EACH_CONST(type, set->game->pack_types) {
if (type->name == name) {
instance = PackInstanceP(new PackInstance(*type,*this));
max_depth = max(max_depth, instance->get_depth());
return *instance;
}
}
throw Error(_ERROR_1_("pack type not found",name));
}
return the_size * amount * probability;
}
void PackItemCounter::count(const PackType& pack, int copies, type) {
if (pack.cards) {
//
cards =..
if (!cards.empty()) {
return true;
} else {
return false;
PackInstance& PackGenerator::get(const PackTypeP& type) {
return get(type->name);
}
void PackGenerator::generate(vector<CardP>& out) {
if (!set) return;
// We generate from depth max_depth to 0
// instances can refer to other instances of lower depth, and generate
// can change the number of copies of those lower depth instances
for (int depth = max_depth ; depth >= 0 ; --depth) {
// in game file order
FOR_EACH_CONST(type, set->game->pack_types) {
PackInstance& i = get(type);
if (i.get_depth() == depth) {
i.generate(&out);
}
}
} else {
}
}
// ----------------------------------------------------------------------------- : PackItem
IMPLEMENT_REFLECTION(PackItem) {
REFLECT(name);
REFLECT(filter);
}
void PackItem::generate(Set& set, vector<CardP>& out) const {
FOR_EACH(card, set.cards) {
Context& ctx = set.getContext(card);
bool keep = *filter.invoke(ctx);
if (keep) {
out.push_back(card);
void PackGenerator::update_card_counts() {
if (!set) return;
// update card_counts by using generate()
for (int depth = max_depth ; depth >= 0 ; --depth) {
FOR_EACH_CONST(i,instances) {
if (i.second->get_depth() == depth) {
i.second->generate(nullptr);
}
}
}
}
// ----------------------------------------------------------------------------- : PackItemCache
PackItemCache::PackItemCache(Set& set)
: set(set)
{}*/
#endif
src/data/pack.hpp
View file @ 1cf4d1c8
......@@ -14,7 +14,7 @@
#include <script/scriptable.hpp>
#include <boost/random/mersenne_twister.hpp>
#define USE_NEW_PACK_SYSTEM 0
#define USE_NEW_PACK_SYSTEM 1
#if !USE_NEW_PACK_SYSTEM
// =================================================================================================== OLD
......@@ -103,20 +103,29 @@ class PackItemCache {
};
#else
// =================================================================================================== NEW
DECLARE_POINTER_TYPE(PackType);
DECLARE_POINTER_TYPE(PackItem);
DECLARE_POINTER_TYPE(PackInstance);
DECLARE_POINTER_TYPE(Card);
class Set;
DECLARE_POINTER_TYPE(Set);
class PackGenerator;
// ----------------------------------------------------------------------------- : PackType
enum OneMany
{ SELECT_ONE_OR_EMPTY
, SELECT_ONE
, SELECT_FIRST
enum PackSelectType
{ SELECT_AUTO
, SELECT_ALL
, SELECT_REPLACE
, SELECT_NO_REPLACE
, SELECT_CYCLIC
, SELECT_PROPORTIONAL
, SELECT_NONEMPTY
, SELECT_FIRST
};
/// A card pack description for playtesting
......@@ -128,8 +137,7 @@ class PackType : public IntrusivePtrBase<PackType> {
Scriptable<bool> enabled; ///< Is this pack enabled?
bool selectable; ///< Is this pack listed in the UI?
bool summary; ///< Should the total be listed for this type?
OneMany select; ///< Select one or many?
OptionalScript cards; ///< Script to select this type of cards (there are no items)
PackSelectType select; ///< What cards/items to select
OptionalScript filter; ///< Filter to select this type of cards
vector<PackItemP> items; ///< Subpacks in this pack
......@@ -140,24 +148,14 @@ class PackType : public IntrusivePtrBase<PackType> {
DECLARE_REFLECTION();
};
// ----------------------------------------------------------------------------- : PackItem
enum PackSelectType
{ PACK_REF_INHERIT
, PACK_REF_REPLACE
, PACK_REF_NO_REPLACE
, PACK_REF_CYCLIC
};
/// An item in a PackType
class PackItem : public IntrusivePtrBase<PackItem> {
public:
PackItem();
String pack; ///< Name of the pack to select cards from
Scriptable<int> amount; ///< Number of cards of this type
Scriptable<double> weight; ///< Relative probability of picking this item
PackSelectType type;
String name; ///< Name of the pack to select cards from
Scriptable<int> amount; ///< Number of cards of this type
Scriptable<double> probability; ///< Relative probability of picking this item
/// Update scripts, returns true if there is a change
bool update(Context& ctx);
......@@ -166,86 +164,65 @@ class PackItem : public IntrusivePtrBase<PackItem> {
DECLARE_REFLECTION();
};
// ----------------------------------------------------------------------------- : Generating / counting
// --------------------------------------------------- : PackItemCache
// ----------------------------------------------------------------------------- : Generating / counting
class PackItemCache {
// A PackType that is instantiated for a particular Set,
// i.e. we now know the actual cards
class PackInstance : public IntrusivePtrBase<PackInstance> {
public:
PackItemCache(Set& set) : set(set) {}
PackInstance(const PackType& pack_type, PackGenerator& parent);
/// Look up a pack type by name
const PackType& pack(const String& name);
/// Expect to pick this many copies from this pack, updates expected_copies
void expect_copy(double copies = 1);
/// Request some copies of this pack
void request_copy(size_t copies = 1);
protected:
Set& set;
/// Generate cards if depth == at_depth
/** Some cards are (optionally) added to out and card_copies
* And also the copies of referenced items might be incremented
*
* Resets the count of this instance to 0 */
void generate(vector<CardP>* out);
/// The cards for a given PackItem
ScriptValueP cardsFor(const ScriptValueP& cards_script);
inline int get_depth() const { return depth; }
inline bool has_cards() const { return !cards.empty(); }
inline size_t get_card_copies() const { return card_copies; }
inline double get_expected_copies() const { return expected_copies; }
private:
/// Lookup PackTypes by name
//%%
/// Cards for each PackType
map<ScriptValueP,ScriptValueP> item_cards;
const PackType& pack_type;
PackGenerator& parent;
int depth; //< 0 = no items, otherwise 1+max depth of items refered to
vector<CardP> cards; //< All cards that pass the filter
size_t count; //< Total number of non-empty cards/items
double total_probability; //< Sum of item and card probabilities
size_t requested_copies; //< The requested number of copies of this pack
size_t card_copies; //< The number of cards that were chosen to come from this pack
double expected_copies;
};
// --------------------------------------------------- : Counting expected cards
/// Class for determining the *expected* number of cards from each type
class PackItemCounter : PackItemCache {
class PackGenerator {
public:
PackItemCounter(Set& set, map<const PackType*,double>& counts)
: PackItemCache(set), counts(counts)
{}
/// Reset the generator, possibly switching the set or reseeding
void reset(const SetP& set, int seed);
/// Add a number of copies of the PackType to the counts, recurse into child items
void addCountRecursive(const PackType& pack, double copies);
void addCountRecursive(const PackItem& item, double copies);
/// Find the PackInstance for the PackType with the given name
PackInstance& get(const String& name);
PackInstance& get(const PackTypeP& type);
/// The probability that the given pack is non-empty
double probabilityNonEmpty(const PackType& pack);
double probabilityNonEmpty(const PackItem& item);
/// The counts will be stored here
map<const PackType*,double>& counts;
/// Generate all cards, resets copies
void generate(vector<CardP>& out);
/// Update all card_copies counters, resets copies
void update_card_counts();
// only for PackInstance
SetP set; ///< The set
boost::mt19937 gen; ///< Random generator
private:
/// The probability that a pack type is empty (cache)
//%map<const PackItem*,double> probability_empty;
};
// --------------------------------------------------- : PackItemCounter
/// Class for generating card packs
class PackItemGenerator : PackItemCache {
public:
PackItemGenerator(Set& set, vector<CardP>& cards, boost::mt19937& gen)
: PackItemCache(set), out(cards), gen(gen)
{}
/// Generate a pack, adding it to cards
void generate(const PackType& pack);
/// Number of cards of a type
typedef map<pair<ScriptValueP,PackSelectType>,int> OfTypeCount;
/// Determine what *types* of cards to pick (store in out)
/** Does NOT add cards yet.
* Returns true if non-empty.
*/
bool generateCount(const PackType& pack, int copies, PackSelectType type, OfTypeCount& out);
bool generateCount(const PackItem& item, int copies, PackSelectType type, OfTypeCount& out);
bool generateSingleCount(const PackType& pack, PackSelectType type, OfTypeCount& out);
/// Pick cards from a list
void pickCards(const ScriptValueP& cards, PackSelectType type, int amount);
/// The cards will be stored here
vector<CardP>& out;
/// Random generator
boost::mt19937& gen;
/// Details for each PackType
map<String,PackInstanceP> instances;
int max_depth;
};
// ----------------------------------------------------------------------------- : EOF
......
src/gui/set/random_pack_panel.cpp
View file @ 1cf4d1c8
......@@ -88,10 +88,14 @@ void RandomCardList::getItems(vector<VoidP>& out) const {
class PackTotalsPanel : public wxPanel {
public:
#if USE_NEW_PACK_SYSTEM
PackTotalsPanel(Window* parent, int id, PackGenerator& generator) : wxPanel(parent,id), generator(generator) {}
#else
PackTotalsPanel(Window* parent, int id) : wxPanel(parent,id) {}
#endif
void setGame(const GameP& game);
void clear();
#if !USE_NEW_PACK_SYSTEM
void clear();
void addPack(PackType& pack, int copies);
void addItemRef(PackItemRef& item, int copies);
#endif
......@@ -101,12 +105,11 @@ class PackTotalsPanel : public wxPanel {
void onPaint(wxPaintEvent&);
void draw(DC& dc);
void drawItem(DC& dc, int& y, const String& name, double value);
#if USE_NEW_PACK_SYSTEM
public:
map<const PackType*,double> amounts;
#else
#if USE_NEW_PACK_SYSTEM
PackGenerator& generator;
#else
map<String,int> amounts;
#endif
#endif
};
void PackTotalsPanel::onPaint(wxPaintEvent&) {
......@@ -126,10 +129,10 @@ void PackTotalsPanel::draw(DC& dc) {
int total = 0;
#if USE_NEW_PACK_SYSTEM
FOR_EACH(pack, game->pack_types) {
if (pack->summary) {
int value = amounts[pack.get()];
drawItem(dc, y, tr(*game, pack->name, capitalize), value);
total += value;
PackInstance& i = generator.get(pack);
if (pack->summary && i.has_cards()) {
drawItem(dc, y, tr(*game, pack->name, capitalize), i.get_card_copies());
total += (int)i.get_card_copies();
}
}
#else
......@@ -160,12 +163,14 @@ void PackTotalsPanel::drawItem(DC& dc, int& y, const String& name, double value
void PackTotalsPanel::setGame(const GameP& game) {
this->game = game;
#if !USE_NEW_PACK_SYSTEM
clear();
}
void PackTotalsPanel::clear() {
amounts.clear();
#endif
}
#if !USE_NEW_PACK_SYSTEM
void PackTotalsPanel::clear() {
amounts.clear();
}
void PackTotalsPanel::addPack(PackType& pack, int copies) {
FOR_EACH(item,pack.items) {
addItemRef(*item, copies * item->amount);
......@@ -196,7 +201,11 @@ void RandomPackPanel::initControls() {
seed_random = new wxRadioButton(this, ID_SEED_RANDOM, _BUTTON_("random seed"));
seed_fixed = new wxRadioButton(this, ID_SEED_FIXED, _BUTTON_("fixed seed"));
seed = new wxTextCtrl(this, wxID_ANY);
#if USE_NEW_PACK_SYSTEM
totals = new PackTotalsPanel(this, wxID_ANY, generator);
#else
totals = new PackTotalsPanel(this, wxID_ANY);
#endif
static_cast<SetWindow*>(GetParent())->setControlStatusText(seed_random, _HELP_("random seed"));
static_cast<SetWindow*>(GetParent())->setControlStatusText(seed_fixed, _HELP_("fixed seed"));
static_cast<SetWindow*>(GetParent())->setControlStatusText(seed, _HELP_("seed"));
......@@ -259,13 +268,19 @@ void RandomPackPanel::onChangeSet() {
// add pack controls
FOR_EACH(pack, set->game->pack_types) {
PackItem i;
i.pack = pack;
i.label = new wxStaticText(this, wxID_ANY, capitalize_sentence(pack->name));
i.value = new wxSpinCtrl(this, ID_PACK_AMOUNT, _("0"), wxDefaultPosition, wxSize(50,-1));
packsSizer->Add(i.label, 0, wxALIGN_CENTER_VERTICAL);
packsSizer->Add(i.value, 0, wxEXPAND | wxALIGN_CENTER);
packs.push_back(i);
#if NEW_PACK_SYSTEM
if (pack->selectable) {
#endif
PackItem i;
i.pack = pack;
i.label = new wxStaticText(this, wxID_ANY, capitalize_sentence(pack->name));
i.value = new wxSpinCtrl(this, ID_PACK_AMOUNT, _("0"), wxDefaultPosition, wxSize(50,-1));
packsSizer->Add(i.label, 0, wxALIGN_CENTER_VERTICAL);
packsSizer->Add(i.value, 0, wxEXPAND | wxALIGN_CENTER);
packs.push_back(i);
#if NEW_PACK_SYSTEM
}
#endif
}
Layout();
......@@ -280,6 +295,9 @@ void RandomPackPanel::onChangeSet() {
i.value->SetValue(gs.pack_amounts[i.pack->name]);
}
#if USE_NEW_PACK_SYSTEM
generator.reset(set,0);
#endif
updateTotals();
}
......@@ -328,20 +346,22 @@ void RandomPackPanel::onCommand(int id) {
// ----------------------------------------------------------------------------- : Generating
void RandomPackPanel::updateTotals() {
#if USE_NEW_PACK_SYSTEM
PackItemCounter counter(*set, totals->amounts);
#endif
#if !USE_NEW_PACK_SYSTEM
totals->clear();
total_packs = 0;
#endif
int total_packs = 0;
FOR_EACH(i,packs) {
int copies = i.value->GetValue();
total_packs += copies;
#if USE_NEW_PACK_SYSTEM
counter.addCountRecursive(*i.pack, copies);
generator.get(i.pack).request_copy(copies);
#else
totals->addPack(*i.pack, copies);
#endif
}
#if USE_NEW_PACK_SYSTEM
generator.update_card_counts();
#endif
// update UI
totals->Refresh(false);
generate_button->Enable(total_packs > 0);
......@@ -373,10 +393,10 @@ void RandomPackPanel::setSeed(int seed) {
}
void RandomPackPanel::generate() {
boost::mt19937 gen((unsigned)getSeed());
#if USE_NEW_PACK_SYSTEM
PackItemGenerator generator(*set, card_list->cards, gen);
generator.reset(set,getSeed());
#else
boost::mt19937 gen((unsigned)getSeed());
PackItemCache pack_cache(*set);
#endif
// add packs to card list
......@@ -385,7 +405,8 @@ void RandomPackPanel::generate() {
int copies = item.value->GetValue();
for (int i = 0 ; i < copies ; ++i) {
#if USE_NEW_PACK_SYSTEM
generator.generate(*item.pack);
generator.get(item.pack).request_copy();
generator.generate(card_list->cards);
#else
card_list->add(pack_cache, gen, *item.pack);
#endif
......
src/gui/set/random_pack_panel.hpp
View file @ 1cf4d1c8
......@@ -11,6 +11,7 @@
#include <util/prec.hpp>
#include <gui/set/panel.hpp>
#include <data/pack.hpp>
#include <wx/spinctrl.h>
class CardViewer;
......@@ -66,7 +67,9 @@ class RandomPackPanel : public SetWindowPanel {
};
vector<PackItem> packs;
int total_packs;
#if USE_NEW_PACK_SYSTEM
PackGenerator generator;
#endif
/// Actual intialization of the controls
void initControls();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment