use unordered_map/unordered_set instead of map/set

card.cpp

@@ -165,8 +165,7 @@ uint32 card::get_infos(byte* buf, int32 query_flag, int32 use_cache) {
 	}
 	if(query_flag & QUERY_COUNTERS) {
 		*p++ = counters.size();
-		counter_map::iterator cmit;
-		for(cmit = counters.begin(); cmit != counters.end(); ++cmit)
+		for(auto cmit = counters.begin(); cmit != counters.end(); ++cmit)
 			*p++ = cmit->first + (cmit->second << 16);
 	}
 	if(query_flag & QUERY_OWNER)
@@ -1408,7 +1407,7 @@ int32 card::add_counter(uint8 playerid, uint16 countertype, uint16 count) {
 	return TRUE;
 }
 int32 card::remove_counter(uint16 countertype, uint16 count) {
-	counter_map::iterator cmit = counters.find(countertype);
+	auto cmit = counters.find(countertype);
 	if(cmit == counters.end())
 		return FALSE;
 	if(cmit->second <= count)
@@ -1434,7 +1433,7 @@ int32 card::is_can_add_counter(uint8 playerid, uint16 countertype, uint16 count)
 		return FALSE;
 	int32 limit = -1;
 	int32 cur = 0;
-	counter_map::iterator cmit = counters.find(countertype);
+	auto cmit = counters.find(countertype);
 	if(cmit != counters.end())
 		cur = cmit->second;
 	filter_effect(EFFECT_COUNTER_LIMIT + countertype, &eset);
@@ -1445,7 +1444,7 @@ int32 card::is_can_add_counter(uint8 playerid, uint16 countertype, uint16 count)
 	return TRUE;
 }
 int32 card::get_counter(uint16 countertype) {
-	counter_map::iterator cmit = counters.find(countertype);
+	auto cmit = counters.find(countertype);
 	if(cmit == counters.end())
 		return 0;
 	return cmit->second;

card.h

@@ -12,6 +12,7 @@
 #include "effectset.h"
 #include <set>
 #include <map>
+#include <unordered_map>
 
 class card;
 class duel;
@@ -80,11 +81,11 @@ public:
 	typedef std::vector<card*> card_vector;
 	typedef std::multimap<uint32, effect*> effect_container;
 	typedef std::set<card*, card_sort> card_set;
-	typedef std::map<effect*, effect_container::iterator> effect_indexer;
-	typedef std::map<effect*, uint32> effect_relation;
-	typedef std::map<card*, uint32> relation_map;
+	typedef std::unordered_map<effect*, effect_container::iterator> effect_indexer;
+	typedef std::unordered_map<effect*, uint32> effect_relation;
+	typedef std::unordered_map<card*, uint32> relation_map;
 	typedef std::map<uint16, uint16> counter_map;
-	typedef std::map<uint16, card*> attacker_map;
+	typedef std::unordered_map<uint16, card*> attacker_map;
 	int32 scrtype;
 	int32 ref_handle;
 	duel* pduel;

duel.cpp

@@ -21,21 +21,21 @@ duel::duel() {
 	clear_buffer();
 }
 duel::~duel() {
-	for(std::set<card*>::iterator cit = cards.begin(); cit != cards.end(); ++cit)
+	for(auto cit = cards.begin(); cit != cards.end(); ++cit)
 		delete *cit;
-	for(std::set<group*>::iterator git = groups.begin(); git != groups.end(); ++git)
+	for(auto git = groups.begin(); git != groups.end(); ++git)
 		delete *git;
-	for(std::set<effect*>::iterator eit = effects.begin(); eit != effects.end(); ++eit)
+	for(auto eit = effects.begin(); eit != effects.end(); ++eit)
 		delete *eit;
 	delete lua;
 	delete game_field;
 }
 void duel::clear() {
-	for(std::set<card*>::iterator cit = cards.begin(); cit != cards.end(); ++cit)
+	for(auto cit = cards.begin(); cit != cards.end(); ++cit)
 		delete *cit;
-	for(std::set<group*>::iterator git = groups.begin(); git != groups.end(); ++git)
+	for(auto git = groups.begin(); git != groups.end(); ++git)
 		delete *git;
-	for(std::set<effect*>::iterator eit = effects.begin(); eit != effects.end(); ++eit)
+	for(auto eit = effects.begin(); eit != effects.end(); ++eit)
 		delete *eit;
 	delete game_field;
 	cards.clear();
@@ -98,8 +98,7 @@ int32 duel::read_buffer(byte* buf) {
 	return bufferlen;
 }
 void duel::release_script_group() {
-	std::set<group*>::iterator sit;
-	for(sit = sgroups.begin(); sit != sgroups.end(); ++sit) {
+	for(auto sit = sgroups.begin(); sit != sgroups.end(); ++sit) {
 		group* pgroup = *sit;
 		if(pgroup->is_readonly == 0) {
 			lua->unregister_group(pgroup);
@@ -110,8 +109,7 @@ void duel::release_script_group() {
 	sgroups.clear();
 }
 void duel::restore_assumes() {
-	std::set<card*>::iterator sit;
-	for(sit = assumes.begin(); sit != assumes.end(); ++sit)
+	for(auto sit = assumes.begin(); sit != assumes.end(); ++sit)
 		(*sit)->assume_type = 0;
 	assumes.clear();
 }

duel.h

@@ -11,6 +11,7 @@
 #include "common.h"
 #include "mtrandom.h"
 #include <set>
+#include <unordered_set>
 
 class card;
 class group;
@@ -33,12 +34,12 @@ public:
 	interpreter* lua;
 	field* game_field;
 	mtrandom random;
-	std::set<card*> cards;
-	std::set<card*> assumes;
-	std::set<group*> groups;
-	std::set<group*> sgroups;
-	std::set<effect*> effects;
-	std::set<effect*> uncopy;
+	std::unordered_set<card*> cards;
+	std::unordered_set<card*> assumes;
+	std::unordered_set<group*> groups;
+	std::unordered_set<group*> sgroups;
+	std::unordered_set<effect*> effects;
+	std::unordered_set<effect*> uncopy;
 	
 	duel();
 	~duel();

field.h

@@ -44,7 +44,7 @@ struct optarget {
 	int32 op_param;
 };
 struct chain {
-	typedef std::map<uint32, optarget > opmap;
+	typedef std::unordered_map<uint32, optarget> opmap;
 	uint16 chain_id;
 	uint8 chain_count;
 	uint8 triggering_player;
@@ -86,9 +86,9 @@ struct player_info {
 };
 struct field_effect {
 	typedef std::multimap<uint32, effect*> effect_container;
-	typedef std::map<effect*, effect_container::iterator> effect_indexer;
-	typedef std::map<effect*, effect*> oath_effects;
-	typedef std::set<effect*> effect_collection;
+	typedef std::unordered_map<effect*, effect_container::iterator> effect_indexer;
+	typedef std::unordered_map<effect*, effect*> oath_effects;
+	typedef std::unordered_set<effect*> effect_collection;
 
 	effect_container aura_effect;
 	effect_container ignition_effect;
@@ -106,7 +106,7 @@ struct field_effect {
 	effect_collection spsummon_count_eff;
 	
 	std::list<card*> disable_check_list;
-	std::set<card*, card_sort> disable_check_set;
+	std::unordered_set<card*> disable_check_set;
 };
 struct field_info {
 	int32 field_id;
@@ -148,7 +148,6 @@ struct processor {
 	typedef std::vector<chain> chain_array;
 	typedef std::list<processor_unit> processor_list;
 	typedef std::set<card*, card_sort> card_set;
-	typedef std::set<effect*> effect_collection;
 	typedef std::set<std::pair<effect*, tevent> > delayed_effect_collection;
 
 	processor_list units;
@@ -299,7 +298,6 @@ struct processor {
 class field {
 public:
 	typedef std::multimap<uint32, effect*> effect_container;
-	typedef std::map<effect*, effect_container::iterator> effect_indexer;
 	typedef std::set<card*, card_sort> card_set;
 	typedef std::vector<effect*> effect_vector;
 	typedef std::vector<card*> card_vector;
@@ -309,7 +307,6 @@ public:
 	typedef std::map<effect*, chain> instant_f_list;
 	typedef std::vector<chain> chain_array;
 	typedef std::list<processor_unit> processor_list;
-	typedef std::map<effect*, effect*> oath_effects;
 
 	duel* pduel;
 	player_info player[2];

libcard.cpp

@@ -743,8 +743,7 @@ int32 scriptlib::card_get_attacked_group(lua_State *L) {
 	check_param(L, PARAM_TYPE_CARD, 1);
 	card* pcard = *(card**) lua_touserdata(L, 1);
 	group* pgroup = pcard->pduel->new_group();
-	card::attacker_map::iterator cit;
-	for(cit = pcard->attacked_cards.begin(); cit != pcard->attacked_cards.end(); ++cit) {
+	for(auto cit = pcard->attacked_cards.begin(); cit != pcard->attacked_cards.end(); ++cit) {
 		if(cit->second)
 			pgroup->container.insert(cit->second);
 	}
@@ -770,8 +769,7 @@ int32 scriptlib::card_get_battled_group(lua_State *L) {
 	check_param(L, PARAM_TYPE_CARD, 1);
 	card* pcard = *(card**) lua_touserdata(L, 1);
 	group* pgroup = pcard->pduel->new_group();
-	card::attacker_map::iterator cit;
-	for(cit = pcard->battled_cards.begin(); cit != pcard->battled_cards.end(); ++cit) {
+	for(auto cit = pcard->battled_cards.begin(); cit != pcard->battled_cards.end(); ++cit) {
 		if(cit->second)
 			pgroup->container.insert(cit->second);
 	}

libduel.cpp

@@ -2328,8 +2328,8 @@ int32 scriptlib::duel_set_operation_info(lua_State *L) {
 	opt.op_player = playerid;
 	opt.op_param = param;
 	if(ct == 0 && pduel->game_field->core.continuous_chain.size()) {
-		field::chain_list::reverse_iterator clit = pduel->game_field->core.continuous_chain.rbegin();
-		chain::opmap::iterator omit = clit->opinfos.find(cate);
+		auto clit = pduel->game_field->core.continuous_chain.rbegin();
+		auto omit = clit->opinfos.find(cate);
 		if(omit != clit->opinfos.end() && omit->second.op_cards)
 			pduel->delete_group(omit->second.op_cards);
 		clit->opinfos[cate] = opt;
@@ -2337,14 +2337,14 @@ int32 scriptlib::duel_set_operation_info(lua_State *L) {
 		if (pduel->game_field->core.current_chain.size() == 0)
 			return 0;
 		if(ct < 1 || ct > pduel->game_field->core.current_chain.size()) {
-			field::chain_array::reverse_iterator cait = pduel->game_field->core.current_chain.rbegin();
-			chain::opmap::iterator omit = cait->opinfos.find(cate);
+			auto cait = pduel->game_field->core.current_chain.rbegin();
+			auto omit = cait->opinfos.find(cate);
 			if(omit != cait->opinfos.end() && omit->second.op_cards)
 				pduel->delete_group(omit->second.op_cards);
 			cait->opinfos[cate] = opt;
 		} else {
 			chain* ch = &pduel->game_field->core.current_chain[ct - 1];
-			chain::opmap::iterator omit = ch->opinfos.find(cate);
+			auto omit = ch->opinfos.find(cate);
 			if(omit != ch->opinfos.end() && omit->second.op_cards)
 				pduel->delete_group(omit->second.op_cards);
 			ch->opinfos[cate] = opt;

operations.cpp

@@ -3925,8 +3925,7 @@ int32 field::operation_replace(uint16 step, effect * replace_effect, group * tar
 	case 3: {
 		if(core.continuous_chain.rbegin()->target_cards)
 			pduel->delete_group(core.continuous_chain.rbegin()->target_cards);
-		chain::opmap::iterator oit;
-		for(oit = core.continuous_chain.rbegin()->opinfos.begin(); oit != core.continuous_chain.rbegin()->opinfos.end(); ++oit) {
+		for(auto oit = core.continuous_chain.rbegin()->opinfos.begin(); oit != core.continuous_chain.rbegin()->opinfos.end(); ++oit) {
 			if(oit->second.op_cards)
 				pduel->delete_group(oit->second.op_cards);
 		}
@@ -3995,8 +3994,7 @@ int32 field::operation_replace(uint16 step, effect * replace_effect, group * tar
 	case 8: {
 		if(core.continuous_chain.rbegin()->target_cards)
 			pduel->delete_group(core.continuous_chain.rbegin()->target_cards);
-		chain::opmap::iterator oit;
-		for(oit = core.continuous_chain.rbegin()->opinfos.begin(); oit != core.continuous_chain.rbegin()->opinfos.end(); ++oit) {
+		for(auto oit = core.continuous_chain.rbegin()->opinfos.begin(); oit != core.continuous_chain.rbegin()->opinfos.end(); ++oit) {
 			if(oit->second.op_cards)
 				pduel->delete_group(oit->second.op_cards);
 		}