using effect_set = std::vector<effect*>

card.cpp

@@ -430,7 +430,7 @@ uint32_t card::get_code() {
 	temp.code = code;
 	filter_effect(EFFECT_CHANGE_CODE, &effects);
 	if (effects.size())
-		code = effects.get_last()->get_value(this);
+		code = effects.back()->get_value(this);
 	temp.code = UINT32_MAX;
 	return code;
 }
@@ -450,7 +450,7 @@ uint32_t card::get_another_code() {
 	filter_effect(EFFECT_ADD_CODE, &eset);
 	if(!eset.size())
 		return code2;
-	uint32_t otcode = eset.get_last()->get_value(this);
+	uint32_t otcode = eset.back()->get_value(this);
 	if(code1 != otcode)
 		return otcode;
 	return 0;
@@ -642,7 +642,7 @@ std::pair<int32_t, int32_t> card::get_base_atk_def() {
 		filter_effect(EFFECT_SET_BASE_DEFENSE, &eset, FALSE);
 		filter_effect(EFFECT_SET_BASE_DEFENSE_FINAL, &eset, FALSE);
 	}
-	eset.sort();
+	std::sort(eset.begin(), eset.end(), effect_sort_id);
 	// calculate single effects of this first
 	for(int32_t i = 0; i < eset.size();) {
 		if (eset[i]->type & EFFECT_TYPE_SINGLE) {
@@ -652,14 +652,14 @@ std::pair<int32_t, int32_t> card::get_base_atk_def() {
 				if(batk < 0)
 					batk = 0;
 				temp.base_attack = batk;
-				eset.remove_item(i);
+				eset.erase(eset.begin() + i);
 				continue;
 			case EFFECT_SET_BASE_DEFENSE:
 				bdef = eset[i]->get_value(this);
 				if(bdef < 0)
 					bdef = 0;
 				temp.base_defense = bdef;
-				eset.remove_item(i);
+				eset.erase(eset.begin() + i);
 				continue;
 			}
 		}
@@ -746,7 +746,7 @@ std::pair<int32_t, int32_t> card::get_atk_def() {
 		filter_effect(EFFECT_SET_DEFENSE, &eset, FALSE);
 		filter_effect(EFFECT_SET_DEFENSE_FINAL, &eset, FALSE);
 	}
-	eset.sort();
+	std::sort(eset.begin(), eset.end(), effect_sort_id);
 	bool rev = false;
 	if (is_affected_by_effect(EFFECT_REVERSE_UPDATE))
 		rev = true;
@@ -758,14 +758,14 @@ std::pair<int32_t, int32_t> card::get_atk_def() {
 				if (atk < 0)
 					atk = 0;
 				temp.attack = atk;
-				eset.remove_item(i);
+				eset.erase(eset.begin() + i);
 				continue;
 			case EFFECT_SET_DEFENSE:
 				def = eset[i]->get_value(this);
 				if (def < 0)
 					def = 0;
 				temp.defense = def;
-				eset.remove_item(i);
+				eset.erase(eset.begin() + i);
 				continue;
 			}
 		}
@@ -775,7 +775,7 @@ std::pair<int32_t, int32_t> card::get_atk_def() {
 		switch (eset[i]->code) {
 		case EFFECT_UPDATE_ATTACK:
 			if (eset[i]->is_flag(EFFECT_FLAG2_REPEAT_UPDATE))
-				effects_repeat_update_atk.add_item(eset[i]);
+				effects_repeat_update_atk.push_back(eset[i]);
 			else if ((eset[i]->type & EFFECT_TYPE_SINGLE) && !eset[i]->is_flag(EFFECT_FLAG_SINGLE_RANGE))
 				up_atk += eset[i]->get_value(this);
 			else
@@ -796,19 +796,19 @@ std::pair<int32_t, int32_t> card::get_atk_def() {
 				upc_atk = 0;
 			}
 			else if (eset[i]->is_flag(EFFECT_FLAG2_OPTION)) {
-				effects_atk_option.add_item(eset[i]);
+				effects_atk_option.push_back(eset[i]);
 			}
 			else if (eset[i]->is_flag(EFFECT_FLAG2_WICKED)) {
-				effects_atk_wicked.add_item(eset[i]);
+				effects_atk_wicked.push_back(eset[i]);
 			}
 			else {
-				effects_atk_final.add_item(eset[i]);
+				effects_atk_final.push_back(eset[i]);
 			}
 			break;
 		// def
 		case EFFECT_UPDATE_DEFENSE:
 			if (eset[i]->is_flag(EFFECT_FLAG2_REPEAT_UPDATE))
-				effects_repeat_update_def.add_item(eset[i]);
+				effects_repeat_update_def.push_back(eset[i]);
 			else if ((eset[i]->type & EFFECT_TYPE_SINGLE) && !eset[i]->is_flag(EFFECT_FLAG_SINGLE_RANGE))
 				up_def += eset[i]->get_value(this);
 			else
@@ -829,13 +829,13 @@ std::pair<int32_t, int32_t> card::get_atk_def() {
 				upc_def = 0;
 			}
 			else if (eset[i]->is_flag(EFFECT_FLAG2_OPTION)) {
-				effects_def_option.add_item(eset[i]);
+				effects_def_option.push_back(eset[i]);
 			}
 			else if (eset[i]->is_flag(EFFECT_FLAG2_WICKED)) {
-				effects_def_wicked.add_item(eset[i]);
+				effects_def_wicked.push_back(eset[i]);
 			}
 			else {
-				effects_def_final.add_item(eset[i]);
+				effects_def_final.push_back(eset[i]);
 			}
 			break;
 		case EFFECT_SWAP_AD:
@@ -927,7 +927,7 @@ int32_t card::get_battle_attack() {
 	effect_set eset;
 	filter_effect(EFFECT_SET_BATTLE_ATTACK, &eset);
 	if (eset.size()) {
-		int32_t atk = eset.get_last()->get_value(this);
+		int32_t atk = eset.back()->get_value(this);
 		if (atk < 0)
 			atk = 0;
 		return atk;
@@ -939,7 +939,7 @@ int32_t card::get_battle_defense() {
 	effect_set eset;
 	filter_effect(EFFECT_SET_BATTLE_DEFENSE, &eset);
 	if (eset.size()) {
-		int32_t def = eset.get_last()->get_value(this);
+		int32_t def = eset.back()->get_value(this);
 		if (def < 0)
 			def = 0;
 		return def;
@@ -2200,7 +2200,7 @@ std::tuple<uint8_t, effect*> card::refresh_control_status() {
 	effect_set eset;
 	filter_effect(EFFECT_SET_CONTROL, &eset);
 	if(eset.size()) {
-		effect* peffect = eset.get_last();
+		effect* peffect = eset.back();
 		if(peffect->id >= last_id) {
 			final = (uint8_t)peffect->get_value(this);
 			ceffect = peffect;
@@ -2339,7 +2339,7 @@ int32_t card::add_counter(uint8_t playerid, uint16_t countertype, uint16_t count
 		int32_t limit = 0;
 		filter_effect(EFFECT_COUNTER_LIMIT + cttype, &eset);
 		if (eset.size())
-			limit = eset.get_last()->get_value();
+			limit = eset.back()->get_value();
 		if(limit) {
 			int32_t mcount = limit - get_counter(cttype);
 			if (mcount < 0)
@@ -2409,7 +2409,7 @@ int32_t card::is_can_add_counter(uint8_t playerid, uint16_t countertype, uint16_
 		cur = cmit->second;
 	filter_effect(EFFECT_COUNTER_LIMIT + countertype, &eset);
 	if (eset.size())
-		limit = eset.get_last()->get_value();
+		limit = eset.back()->get_value();
 	if(limit > 0 && (cur + (singly ? 1 : count) > limit))
 		return FALSE;
 	return TRUE;
@@ -2596,7 +2596,7 @@ void card::filter_effect_container(const effect_container& container, uint32_t c
 	auto rg = container.equal_range(code);
 	for (auto it = rg.first; it != rg.second; ++it) {
 		if (f(this, it->second))
-			eset.add_item(it->second);
+			eset.push_back(it->second);
 	}
 }
 void card::filter_effect_container(const effect_container& container, uint32_t code, effect_filter f, effect_collection& eset) {
@@ -2616,7 +2616,7 @@ void card::filter_effect(uint32_t code, effect_set* eset, uint8_t sort) {
 		filter_effect_container(pcard->xmaterial_effect, code, default_xmaterial_filter, *eset);
 	filter_effect_container(pduel->game_field->effects.aura_effect, code, default_aura_filter, *eset);
 	if(sort)
-		eset->sort();
+		std::sort(eset->begin(), eset->end(), effect_sort_id);
 }
 void card::filter_single_continuous_effect(uint32_t code, effect_set* eset, uint8_t sort) {
 	filter_effect_container(single_effect, code, accept_filter, *eset);
@@ -2633,7 +2633,7 @@ void card::filter_single_continuous_effect(uint32_t code, effect_set* eset, uint
 	for (auto& pcard : xyz_materials)
 		filter_effect_container(pcard->xmaterial_effect, code, xmaterial_filter, *eset);
 	if(sort)
-		eset->sort();
+		std::sort(eset->begin(), eset->end(), effect_sort_id);
 }
 void card::filter_self_effect(uint32_t code, effect_set* eset, uint8_t sort) {
 	auto single_filter = [](card* c, effect* peffect) -> bool {
@@ -2646,7 +2646,7 @@ void card::filter_self_effect(uint32_t code, effect_set* eset, uint8_t sort) {
 	for (auto& pcard : xyz_materials)
 		filter_effect_container(pcard->xmaterial_effect, code, xmaterial_filter, *eset);
 	if (sort)
-		eset->sort();
+		std::sort(eset->begin(), eset->end(), effect_sort_id);
 }
 // refresh this->immune_effect
 void card::filter_immune_effect() {
@@ -2665,7 +2665,7 @@ void card::filter_immune_effect() {
 	for (auto& pcard : xyz_materials)
 		filter_effect_container(pcard->xmaterial_effect, EFFECT_IMMUNE_EFFECT, xmaterial_filter, immune_effect);
 	filter_effect_container(pduel->game_field->effects.aura_effect, EFFECT_IMMUNE_EFFECT, target_filter, immune_effect);
-	immune_effect.sort();
+	std::sort(immune_effect.begin(), immune_effect.end(), effect_sort_id);
 }
 // for all disable-related peffect of this,
 // 1. Insert all cards in the target of peffect into effects.disable_check_list.
@@ -2700,7 +2700,7 @@ int32_t card::filter_summon_procedure(uint8_t playerid, effect_set* peset, uint8
 	if(eset.size()) {
 		for(int32_t i = 0; i < eset.size(); ++i) {
 			if(check_summon_procedure(eset[i], playerid, ignore_count, min_tribute, zone))
-				peset->add_item(eset[i]);
+				peset->push_back(eset[i]);
 		}
 		if(peset->size())
 			return -1;
@@ -2710,7 +2710,7 @@ int32_t card::filter_summon_procedure(uint8_t playerid, effect_set* peset, uint8
 	filter_effect(EFFECT_SUMMON_PROC, &eset);
 	for(int32_t i = 0; i < eset.size(); ++i) {
 		if(check_summon_procedure(eset[i], playerid, ignore_count, min_tribute, zone))
-			peset->add_item(eset[i]);
+			peset->push_back(eset[i]);
 	}
 	// ordinary summon
 	if(!pduel->game_field->is_player_can_summon(SUMMON_TYPE_NORMAL, playerid, this, playerid))
@@ -2786,7 +2786,7 @@ int32_t card::filter_set_procedure(uint8_t playerid, effect_set* peset, uint8_t
 	if(eset.size()) {
 		for(int32_t i = 0; i < eset.size(); ++i) {
 			if(check_set_procedure(eset[i], playerid, ignore_count, min_tribute, zone))
-				peset->add_item(eset[i]);
+				peset->push_back(eset[i]);
 		}
 		if(peset->size())
 			return -1;
@@ -2796,7 +2796,7 @@ int32_t card::filter_set_procedure(uint8_t playerid, effect_set* peset, uint8_t
 	filter_effect(EFFECT_SET_PROC, &eset);
 	for(int32_t i = 0; i < eset.size(); ++i) {
 		if(check_set_procedure(eset[i], playerid, ignore_count, min_tribute, zone))
-			peset->add_item(eset[i]);
+			peset->push_back(eset[i]);
 	}
 	if(!pduel->game_field->is_player_can_mset(SUMMON_TYPE_NORMAL, playerid, this, playerid))
 		return FALSE;
@@ -2883,7 +2883,7 @@ void card::filter_spsummon_procedure(uint8_t playerid, effect_set* peset, uint32
 			uint32_t sumtype = peffect->get_value(this);
 			if((!summon_type || summon_type == sumtype)
 			        && pduel->game_field->is_player_can_spsummon(sumeffect, sumtype, topos, playerid, toplayer, this))
-				peset->add_item(peffect);
+				peset->push_back(peffect);
 		}
 	}
 }
@@ -2903,7 +2903,7 @@ void card::filter_spsummon_procedure_g(uint8_t playerid, effect_set* peset) {
 		pduel->lua->add_param(peffect, PARAM_TYPE_EFFECT);
 		pduel->lua->add_param(this, PARAM_TYPE_CARD);
 		if(pduel->lua->check_condition(peffect->condition, 2))
-			peset->add_item(peffect);
+			peset->push_back(peffect);
 		pduel->game_field->restore_lp_cost();
 		pduel->game_field->core.reason_effect = oreason;
 		pduel->game_field->core.reason_player = op;

effect.cpp

@@ -232,7 +232,7 @@ int32_t effect::get_required_handorset_effects(effect_set* eset, uint8_t playeri
 			pduel->lua->add_param(this, PARAM_TYPE_EFFECT);
 			if(pduel->lua->check_condition(peffect->cost, 10)) {
 				available = 2;
-				eset->add_item(peffect);
+				eset->push_back(peffect);
 			}
 		}
 	}

effect.h

@@ -18,8 +18,6 @@ class duel;
 class group;
 class effect;
 struct tevent;
-struct effect_set;
-struct effect_set_v;
 enum effect_flag : uint64_t;
 enum effect_flag2 : uint64_t;
 enum effect_category :uint64_t;

effectset.h

@@ -8,7 +8,6 @@
 #ifndef EFFECTSET_H_
 #define EFFECTSET_H_
 
-#include <array>
 #include <vector>
 #include <algorithm>
 
@@ -16,96 +15,7 @@ class effect;
 
 bool effect_sort_id(const effect* e1, const effect* e2);
 
-// std::array<effect*, 64>
-struct effect_set {
-	void add_item(effect* peffect) {
-		if (count >= 64)
-			return;
-		container[count++] = peffect;
-	}
-	void remove_item(int index) {
-		if (index < 0 || index >= count)
-			return;
-		for(int i = index; i < count - 1; ++i)
-			container[i] = container[i + 1];
-		--count;
-	}
-	void clear() {
-		count = 0;
-	}
-	int size() const {
-		return count;
-	}
-	void sort() {
-		if(count < 2)
-			return;
-		std::sort(container.begin(), container.begin() + count, effect_sort_id);
-	}
-	effect* const& get_last() const {
-		assert(count);
-		return container[count - 1];
-	}
-	effect*& get_last() {
-		assert(count);
-		return container[count - 1];
-	}
-	effect* const& operator[] (int index) const {
-		return container[index];
-	}
-	effect*& operator[] (int index) {
-		return container[index];
-	}
-	effect* const& at(int index) const {
-		return container[index];
-	}
-	effect*& at(int index) {
-		return container[index];
-	}
-private:
-	std::array<effect*, 64> container{ nullptr };
-	int count{ 0 };
-};
-
-struct effect_set_v {
-	void add_item(effect* peffect) {
-		container.push_back(peffect);
-	}
-	void remove_item(int index) {
-		if (index < 0 || index >= (int)container.size())
-			return;
-		container.erase(container.begin() + index);
-	}
-	void clear() {
-		container.clear();
-	}
-	int size() const {
-		return (int)container.size();
-	}
-	void sort() {
-		std::sort(container.begin(), container.end(), effect_sort_id);
-	}
-	effect* const& get_last() const {
-		assert(container.size());
-		return container.back();
-	}
-	effect*& get_last() {
-		assert(container.size());
-		return container.back();
-	}
-	effect* const& operator[] (int index) const {
-		return container[index];
-	}
-	effect*& operator[] (int index) {
-		return container[index];
-	}
-	effect* const& at(int index) const {
-		return container[index];
-	}
-	effect*& at(int index) {
-		return container[index];
-	}
-private:
-	std::vector<effect*> container;
-};
+using effect_set = std::vector<effect*>;
+using effect_set_v = effect_set;
 
 #endif //EFFECTSET_H_

field.cpp

@@ -1372,10 +1372,10 @@ void field::filter_field_effect(uint32_t code, effect_set* eset, uint8_t sort) {
 		effect* peffect = rg.first->second;
 		++rg.first;
 		if (peffect->is_available())
-			eset->add_item(peffect);
+			eset->push_back(peffect);
 	}
 	if(sort)
-		eset->sort();
+		std::sort(eset->begin(), eset->end(), effect_sort_id);
 }
 //Get all cards in the target range of a EFFECT_TYPE_FIELD effect
 void field::filter_affected_cards(effect* peffect, card_set* cset) {
@@ -1451,10 +1451,10 @@ void field::filter_player_effect(uint8_t playerid, uint32_t code, effect_set* es
 	for (; rg.first != rg.second; ++rg.first) {
 		effect* peffect = rg.first->second;
 		if (peffect->is_target_player(playerid) && peffect->is_available())
-			eset->add_item(peffect);
+			eset->push_back(peffect);
 	}
 	if(sort)
-		eset->sort();
+		std::sort(eset->begin(), eset->end(), effect_sort_id);
 }
 int32_t field::filter_matching_card(lua_State* L, int32_t findex, uint8_t self, uint32_t location1, uint32_t location2, group* pgroup, card* pexception, group* pexgroup, uint32_t extraargs, card** pret, int32_t fcount, int32_t is_target) {
 	if(self != 0 && self != 1)

libduel.cpp

@@ -1249,7 +1249,7 @@ int32_t scriptlib::duel_is_environment(lua_State *L) {
 		effect_set eset;
 		pduel->game_field->filter_field_effect(EFFECT_CHANGE_ENVIRONMENT, &eset);
 		if(eset.size()) {
-			effect* peffect = eset.get_last();
+			effect* peffect = eset.back();
 			if(code == (uint32_t)peffect->get_value() && (playerid == peffect->get_handler_player() || playerid == PLAYER_ALL))
 				ret = 1;
 		}

processor.cpp

@@ -1233,7 +1233,7 @@ int32_t field::process_phase_event(int16_t step, int32_t phase) {
 		effect_set eset;
 		filter_player_effect(infos.turn_player, EFFECT_HAND_LIMIT, &eset);
 		if(eset.size())
-			limit = eset.get_last()->get_value();
+			limit = eset.back()->get_value();
 		int32_t hd = (int32_t)player[infos.turn_player].list_hand.size();
 		if(hd <= limit) {
 			core.units.begin()->step = 24;
@@ -3479,7 +3479,7 @@ void field::calculate_battle_damage(effect** pdamchange, card** preason_card, ui
 					core.attack_target->filter_effect(EFFECT_CHANGE_INVOLVING_BATTLE_DAMAGE, &change_effects, FALSE);
 					filter_player_effect(pa, EFFECT_CHANGE_BATTLE_DAMAGE, &change_effects, FALSE);
 					filter_player_effect(1 - pa, EFFECT_CHANGE_BATTLE_DAMAGE, &change_effects, FALSE);
-					change_effects.sort();
+					std::sort(change_effects.begin(), change_effects.end(), effect_sort_id);
 					for(uint8_t p = 0; p < 2; ++p) {
 						bool double_dam = false;
 						bool half_dam = false;
@@ -3600,7 +3600,7 @@ void field::calculate_battle_damage(effect** pdamchange, card** preason_card, ui
 			dam_card->filter_effect(EFFECT_CHANGE_INVOLVING_BATTLE_DAMAGE, &eset, FALSE);
 		filter_player_effect(damaged_player, EFFECT_CHANGE_BATTLE_DAMAGE, &eset, FALSE);
 		filter_player_effect(1 - damaged_player, EFFECT_CHANGE_BATTLE_DAMAGE, &eset, FALSE);
-		eset.sort();
+		std::sort(eset.begin(), eset.end(), effect_sort_id);
 		for(uint8_t p = 0; p < 2; ++p) {
 			bool double_dam = false;
 			bool half_dam = false;
@@ -4653,7 +4653,7 @@ int32_t field::refresh_location_info(uint16_t step) {
 				player[0].disabled_location |= value & 0x1f7f;
 				player[1].disabled_location |= (value >> 16) & 0x1f7f;
 			} else
-				core.disfield_effects.add_item(eset[i]);
+				core.disfield_effects.push_back(eset[i]);
 		}
 		eset.clear();
 		filter_field_effect(EFFECT_USE_EXTRA_MZONE, &eset);
@@ -4662,7 +4662,7 @@ int32_t field::refresh_location_info(uint16_t step) {
 			uint32_t value = eset[i]->get_value();
 			player[p].disabled_location |= (value >> 16) & 0x1f;
 			if((uint32_t)field_used_count[(value >> 16) & 0x1f] < (value & 0xffff))
-				core.extra_mzone_effects.add_item(eset[i]);
+				core.extra_mzone_effects.push_back(eset[i]);
 		}
 		eset.clear();
 		filter_field_effect(EFFECT_USE_EXTRA_SZONE, &eset);
@@ -4671,7 +4671,7 @@ int32_t field::refresh_location_info(uint16_t step) {
 			uint32_t value = eset[i]->get_value();
 			player[p].disabled_location |= (value >> 8) & 0x1f00;
 			if((uint32_t)field_used_count[(value >> 16) & 0x1f] < (value & 0xffff))
-				core.extra_szone_effects.add_item(eset[i]);
+				core.extra_szone_effects.push_back(eset[i]);
 		}
 		return FALSE;
 	}
@@ -4682,7 +4682,7 @@ int32_t field::refresh_location_info(uint16_t step) {
 		}
 		effect* peffect = core.disfield_effects[0];
 		core.units.begin()->peffect = peffect;
-		core.disfield_effects.remove_item(0);
+		core.disfield_effects.erase(core.disfield_effects.begin());
 		if(!peffect->operation) {
 			peffect->value = 0x80;
 			core.units.begin()->step = 0;
@@ -4715,7 +4715,7 @@ int32_t field::refresh_location_info(uint16_t step) {
 		}
 		effect* peffect = core.extra_mzone_effects[0];
 		core.units.begin()->peffect = peffect;
-		core.extra_mzone_effects.remove_item(0);
+		core.extra_mzone_effects.erase(core.extra_mzone_effects.begin());
 		uint32_t p = peffect->get_handler_player();
 		uint32_t mzone_flag = (player[p].disabled_location | player[p].used_location) & 0x1f;
 		if(mzone_flag == 0x1f) {
@@ -4754,7 +4754,7 @@ int32_t field::refresh_location_info(uint16_t step) {
 		}
 		effect* peffect = core.extra_szone_effects[0];
 		core.units.begin()->peffect = peffect;
-		core.extra_szone_effects.remove_item(0);
+		core.extra_szone_effects.erase(core.extra_szone_effects.begin());
 		uint32_t p = peffect->get_handler_player();
 		uint32_t szone_flag = ((player[p].disabled_location | player[p].used_location) >> 8) & 0x1f;
 		if(szone_flag == 0x1f) {
@@ -4997,7 +4997,7 @@ int32_t field::adjust_step(uint16_t step) {
 				eset.clear();
 				pcard->filter_effect(EFFECT_SET_POSITION, &eset);
 				if(eset.size()) {
-					pos = eset.get_last()->get_value();
+					pos = eset.back()->get_value();
 					if((pos & 0xff) != pcard->current.position) {
 						pos_adjust.insert(pcard);
 						pcard->position_param = pos;