From 02e676c54b79af25f219e346119c84c4e1d17618 Mon Sep 17 00:00:00 2001
From: twanvl <twanvl@0fc631ac-6414-0410-93d0-97cfa31319b6>
Date: Fri, 9 Jan 2009 00:04:24 +0000
Subject: [PATCH] the new pack system now actually works (yay!)

git-svn-id: svn://svn.code.sf.net/p/magicseteditor/code/trunk@1309 0fc631ac-6414-0410-93d0-97cfa31319b6
---
 src/data/pack.cpp                 | 570 +++++++++++++-----------------
 src/data/pack.hpp                 | 149 ++++----
 src/gui/set/random_pack_panel.cpp |  77 ++--
 src/gui/set/random_pack_panel.hpp |   5 +-
 4 files changed, 354 insertions(+), 447 deletions(-)

diff --git a/src/data/pack.cpp b/src/data/pack.cpp
index fdba8cc3..453cf0f9 100644
--- a/src/data/pack.cpp
+++ b/src/data/pack.cpp
@@ -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,10 +183,35 @@ 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;
+		}
+	}
 }
 
+IMPLEMENT_REFLECTION(PackItem) {
+	REFLECT(name);
+	REFLECT(amount);
+	REFLECT(probability);
+}
+
+
+PackType::PackType()
+	: enabled(true)
+	, selectable(true)
+	, summary(true)
+	, select(SELECT_AUTO)
+{}
+
+PackItem::PackItem()
+	: amount(1)
+{}
+
+
 bool PackType::update(Context& ctx) {
 	bool change = enabled.update(ctx);
 	FOR_EACH(item, items) {
@@ -194,120 +220,95 @@ bool PackType::update(Context& ctx) {
 	return change;
 }
 
-// ----------------------------------------------------------------------------- : PackItem
-
-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);
+	return amount.update(ctx)
+	     | probability.update(ctx);
 }
 
-// ----------------------------------------------------------------------------- : PackItemCache
 
-ScriptValueP PackItemCache::cardsFor(const ScriptValueP& generate) {
-	// lookup name
-	ScriptValueP& value = item_cards[generate];
-	if (!value) {
-		value = generate->eval(set.getContext());
-	}
-	return value;
-}
+// ----------------------------------------------------------------------------- : PackInstance
 
-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;
+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;
-		}
-		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;
-		}
-		return p;
-	}
-}
-double PackItemCounter::probabilityNonEmpty(const PackItem& item) {
-	return item.amount <= 0 ? 0 : probabilityNonEmpty(pack(item.pack));
-}
-
-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);
+	// 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;
+			}
 		}
 	} else {
-		throw InternalError(_("unknown OneMany value"));
+		count = cards.size();
+		FOR_EACH_CONST(item, pack_type.items) {
+			count += parent.get(item->name).count;
+		}
+	}
+	// 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 PackItem& item, double copies) {
-	addCountRecursive(pack(item.pack), item.amount * 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);
+		}
+	}
 }
 
-
-// ----------------------------------------------------------------------------- : Generating
-
-DECLARE_TYPEOF(PackItemGenerator::OfTypeCount);
+void PackInstance::request_copy(size_t copies) {
+	requested_copies += copies;
+}
 
 /// Random generator with random numbers in a range
 template <typename Gen>
@@ -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;
-	}
-	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;
+		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;
+			}
 		}
-	} else {
+		throw Error(_ERROR_1_("pack type not found",name));
 	}
 }
-
-// ----------------------------------------------------------------------------- : PackItem
-
-IMPLEMENT_REFLECTION(PackItem) {
-	REFLECT(name);
-	REFLECT(filter);
+PackInstance& PackGenerator::get(const PackTypeP& type) {
+	return get(type->name);
 }
 
-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::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);
+			}
 		}
 	}
 }
 
-// ----------------------------------------------------------------------------- : PackItemCache
-
-PackItemCache::PackItemCache(Set& set)
-	: set(set)
-{}*/
+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);
+			}
+		}
+	}
+}
 
 #endif
diff --git a/src/data/pack.hpp b/src/data/pack.hpp
index 86f6a210..a73a8579 100644
--- a/src/data/pack.hpp
+++ b/src/data/pack.hpp
@@ -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
-
-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
diff --git a/src/gui/set/random_pack_panel.cpp b/src/gui/set/random_pack_panel.cpp
index 4c2c8476..de01100c 100644
--- a/src/gui/set/random_pack_panel.cpp
+++ b/src/gui/set/random_pack_panel.cpp
@@ -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
diff --git a/src/gui/set/random_pack_panel.hpp b/src/gui/set/random_pack_panel.hpp
index d3bb6f2f..ba9fd0d1 100644
--- a/src/gui/set/random_pack_panel.hpp
+++ b/src/gui/set/random_pack_panel.hpp
@@ -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();