Merge remote-tracking branch 'upstream/master'

buffer.h

@@ -22,7 +22,7 @@ inline void buffer_write_block(unsigned char*& p, const void* src, size_t size)
 	p += size;
 }
 template<typename T>
-inline void buffer_write(unsigned char*& p, T value) {
+inline void buffer_write(unsigned char*& p, const T& value) {
 	std::memcpy(p, &value, sizeof(T));
 	p += sizeof(T);
 }
@@ -30,10 +30,10 @@ inline void buffer_write(unsigned char*& p, T value) {
 inline void vector_write_block(std::vector<unsigned char>& buffer, const void* src, size_t size) {
 	const auto len = buffer.size();
 	buffer.resize(len + size);
-	std::memcpy(&buffer[len], src, size);
+	std::memcpy(buffer.data() + len, src, size);
 }
 template<typename T>
-inline void vector_write(std::vector<unsigned char>& buffer, T value) {
+inline void vector_write(std::vector<unsigned char>& buffer, const T& value) {
 	vector_write_block(buffer, &value, sizeof(T));
 }
 

effect.h

@@ -263,6 +263,8 @@ enum effect_category : uint64_t {
 	CATEGORY_ANNOUNCE		= 0x20000000,
 	CATEGORY_FUSION_SUMMON	= 0x40000000,
 	CATEGORY_TOEXTRA		= 0x80000000,
+	CATEGORY_MSET			= 0x100000000,
+	CATEGORY_SSET			= 0x200000000,
 };
 
 const std::map<uint64_t, uint64_t> category_checklist{

field.cpp

@@ -498,13 +498,44 @@ int32_t field::get_pzone_sequence(uint8_t pseq) const {
 			return 7;
 	}
 }
+const card_vector* field::get_field_vector(uint8_t playerid, uint8_t location) const {
+	if (!check_playerid(playerid))
+		return nullptr;
+	switch (location) {
+	case LOCATION_MZONE:
+		return &player[playerid].list_mzone;
+	case LOCATION_SZONE:
+		return &player[playerid].list_szone;
+	case LOCATION_DECK:
+		return &player[playerid].list_main;
+	case LOCATION_HAND:
+		return &player[playerid].list_hand;
+	case LOCATION_GRAVE:
+		return &player[playerid].list_grave;
+	case LOCATION_REMOVED:
+		return &player[playerid].list_remove;
+	case LOCATION_EXTRA:
+		return &player[playerid].list_extra;
+	default:
+		return nullptr;
+	}
+}
 card* field::get_field_card(uint8_t playerid, uint32_t general_location, uint8_t sequence) const {
 	if (!check_playerid(playerid))
 		return nullptr;
 	switch(general_location) {
-	case LOCATION_MZONE: {
-		if(sequence < (int32_t)player[playerid].list_mzone.size())
-			return player[playerid].list_mzone[sequence];
+	case LOCATION_MZONE:
+	case LOCATION_DECK:
+	case LOCATION_HAND:
+	case LOCATION_GRAVE:
+	case LOCATION_REMOVED:
+	case LOCATION_EXTRA: {
+		auto ptr = get_field_vector(playerid, general_location);
+		if (!ptr)
+			return nullptr;
+		auto& container = *ptr;
+		if (sequence < container.size())
+			return container[sequence];
 		else
 			return nullptr;
 		break;
@@ -531,41 +562,6 @@ card* field::get_field_card(uint8_t playerid, uint32_t general_location, uint8_t
 			return nullptr;
 		break;
 	}
-	case LOCATION_DECK: {
-		if(sequence < player[playerid].list_main.size())
-			return player[playerid].list_main[sequence];
-		else
-			return nullptr;
-		break;
-	}
-	case LOCATION_HAND: {
-		if(sequence < player[playerid].list_hand.size())
-			return player[playerid].list_hand[sequence];
-		else
-			return nullptr;
-		break;
-	}
-	case LOCATION_GRAVE: {
-		if(sequence < player[playerid].list_grave.size())
-			return player[playerid].list_grave[sequence];
-		else
-			return nullptr;
-		break;
-	}
-	case LOCATION_REMOVED: {
-		if(sequence < player[playerid].list_remove.size())
-			return player[playerid].list_remove[sequence];
-		else
-			return nullptr;
-		break;
-	}
-	case LOCATION_EXTRA: {
-		if(sequence < player[playerid].list_extra.size())
-			return player[playerid].list_extra[sequence];
-		else
-			return nullptr;
-		break;
-	}
 	}
 	return nullptr;
 }
@@ -2692,7 +2688,7 @@ int32_t field::check_tuner_material(lua_State* L, card* pcard, card* tuner, int3
 				++location_count;
 		}
 		if(min == 0) {
-			if(location_count > 0 && check_with_sum_limit_m(nsyn, lv, 0, 0, 0, 0xffff, 2)) {
+			if(location_count > 0 && must_list.size() == 0 && check_with_sum_limit_m(nsyn, lv, 0, 0, 0, 0xffff, 2)) {
 				pduel->restore_assumes();
 				return TRUE;
 			}
@@ -2704,6 +2700,12 @@ int32_t field::check_tuner_material(lua_State* L, card* pcard, card* tuner, int3
 	}
 	if(must_list.size()) {
 		for(auto& mcard : must_list) {
+			if(mg) {
+				if(!mg->has_card(mcard)) {
+					pduel->restore_assumes();
+					return FALSE;
+				}
+			}
 			if(pcheck)
 				pcheck->get_value(mcard);
 			if((mcard->current.location == LOCATION_MZONE && !mcard->is_position(POS_FACEUP)) || !mcard->is_can_be_synchro_material(pcard, tuner)) {

field.h

@@ -383,6 +383,7 @@ public:
 	void set_control(card* pcard, uint8_t playerid, uint16_t reset_phase, uint8_t reset_count);
 
 	int32_t get_pzone_sequence(uint8_t pseq) const;
+	const card_vector* get_field_vector(uint8_t playerid, uint8_t location) const;
 	card* get_field_card(uint8_t playerid, uint32_t general_location, uint8_t sequence) const;
 	int32_t is_location_useable(uint8_t playerid, uint32_t general_location, uint8_t sequence) const;
 	int32_t get_useable_count(card* pcard, uint8_t playerid, uint8_t location, uint8_t uplayer, uint32_t reason, uint32_t zone = 0xff, uint32_t* list = nullptr);

libeffect.cpp

@@ -20,7 +20,7 @@ int32_t scriptlib::get_effect_property(lua_State* L, effect_member type) {
 	if (peffect) {
 		switch (type) {
 		case MEMBER_CATEGORY:
-			value = peffect->category;
+			value = (lua_Integer)peffect->category;
 			break;
 		case MEMBER_CODE:
 			value = peffect->code;
@@ -271,7 +271,7 @@ int32_t scriptlib::effect_set_category(lua_State *L) {
 	check_param_count(L, 2);
 	check_param(L, PARAM_TYPE_EFFECT, 1);
 	effect* peffect = *(effect**) lua_touserdata(L, 1);
-	uint32_t v = (uint32_t)lua_tointeger(L, 2);
+	uint64_t v = (uint64_t)lua_tointeger(L, 2);
 	peffect->category = v;
 	return 0;
 }

mtrandom.h

@@ -59,9 +59,9 @@ public:
 		return l + (int)(x % range);
 	}
 
+#pragma warning(disable:4146)
 	// N % k = (N - k) % k = (-k) % k
 	// discard (N % range) numbers from the left end so that it is a multiple of range
-#pragma warning(disable:4146)
 	int get_random_integer_v2(int l, int h) {
 		uint32_t range = (h - l + 1);
 		uint32_t bound = -range % range;
@@ -75,7 +75,7 @@ public:
 
 	// Fisher-Yates shuffle [first, last)
 	template<typename T>
-	void shuffle_vector(std::vector<T>& v, int first = 0, int last = INT32_MAX, int version = 2) {
+	void shuffle_vector(std::vector<T>& v, int first, int last, int version) {
 		if ((size_t)last > v.size())
 			last = (int)v.size();
 		auto distribution = &mtrandom::get_random_integer_v2;
@@ -87,6 +87,16 @@ public:
 		}
 	}
 
+	template<typename T>
+	void shuffle_vector(std::vector<T>& v) {
+		shuffle_vector(v, 0, (int)v.size(), 2);
+	}
+
+	template<typename T>
+	void shuffle_vector(std::vector<T>& v, int first, int last) {
+		shuffle_vector(v, first, last, 2);
+	}
+
 private:
 	std::mt19937 rng;
 };

ocgapi.cpp

@@ -204,7 +204,7 @@ OCGCORE_API void new_tag_card(intptr_t pduel, uint32_t code, uint8_t owner, uint
 * @param buf int32_t array
 * @return buffer length in bytes
 */
-OCGCORE_API int32_t query_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint8_t sequence, int32_t query_flag, byte* buf, int32_t use_cache) {
+OCGCORE_API int32_t query_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint8_t sequence, uint32_t query_flag, byte* buf, int32_t use_cache) {
 	if (!check_playerid(playerid))
 		return LEN_FAIL;
 	duel* ptduel = (duel*)pduel;
@@ -213,22 +213,13 @@ OCGCORE_API int32_t query_card(intptr_t pduel, uint8_t playerid, uint8_t locatio
 	if (location == LOCATION_MZONE || location == LOCATION_SZONE)
 		pcard = ptduel->game_field->get_field_card(playerid, location, sequence);
 	else {
-		card_vector* lst = nullptr;
-		if (location == LOCATION_HAND)
-			lst = &ptduel->game_field->player[playerid].list_hand;
-		else if (location == LOCATION_GRAVE)
-			lst = &ptduel->game_field->player[playerid].list_grave;
-		else if (location == LOCATION_REMOVED)
-			lst = &ptduel->game_field->player[playerid].list_remove;
-		else if (location == LOCATION_EXTRA)
-			lst = &ptduel->game_field->player[playerid].list_extra;
-		else if (location == LOCATION_DECK)
-			lst = &ptduel->game_field->player[playerid].list_main;
-		else
+		auto ptr = ptduel->game_field->get_field_vector(playerid, location);
+		if(!ptr)
 			return LEN_FAIL;
-		if (sequence >= (int32_t)lst->size())
+		auto& lst = *ptr;
+		if (sequence >= lst.size())
 			return LEN_FAIL;
-		pcard = (*lst)[sequence];
+		pcard = lst[sequence];
 	}
 	if (pcard) {
 		return pcard->get_infos(buf, query_flag, use_cache);

ocgapi.h

@@ -53,7 +53,7 @@ OCGCORE_API int32_t get_message(intptr_t pduel, byte* buf);
 OCGCORE_API uint32_t process(intptr_t pduel);
 OCGCORE_API void new_card(intptr_t pduel, uint32_t code, uint8_t owner, uint8_t playerid, uint8_t location, uint8_t sequence, uint8_t position);
 OCGCORE_API void new_tag_card(intptr_t pduel, uint32_t code, uint8_t owner, uint8_t location);
-OCGCORE_API int32_t query_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint8_t sequence, int32_t query_flag, byte* buf, int32_t use_cache);
+OCGCORE_API int32_t query_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint8_t sequence, uint32_t query_flag, byte* buf, int32_t use_cache);
 OCGCORE_API int32_t query_field_count(intptr_t pduel, uint8_t playerid, uint8_t location);
 OCGCORE_API int32_t query_field_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint32_t query_flag, byte* buf, int32_t use_cache);
 OCGCORE_API int32_t query_field_info(intptr_t pduel, byte* buf);

operations.cpp

@@ -2708,8 +2708,10 @@ int32_t field::special_summon_rule(uint16_t step, uint8_t sumplayer, card* targe
 		info.limit_link_maxc = core.limit_link_maxc;
 		target->filter_spsummon_procedure(sumplayer, &eset, summon_type, info);
 		target->filter_spsummon_procedure_g(sumplayer, &eset);
-		if(!eset.size())
-			return TRUE;
+		if(!eset.size()) {
+			core.units.begin()->step = 17;
+			return FALSE;
+		}
 		core.select_effects.clear();
 		core.select_options.clear();
 		for(effect_set::size_type i = 0; i < eset.size(); ++i) {
@@ -2759,8 +2761,10 @@ int32_t field::special_summon_rule(uint16_t step, uint8_t sumplayer, card* targe
 		return FALSE;
 	}
 	case 2: {
-		if(!returns.ivalue[0])
-			return TRUE;
+		if(!returns.ivalue[0]) {
+			core.units.begin()->step = 17;
+			return FALSE;
+		}
 		effect_set eset;
 		target->filter_effect(EFFECT_SPSUMMON_COST, &eset);
 		if(eset.size()) {
@@ -2982,6 +2986,27 @@ int32_t field::special_summon_rule(uint16_t step, uint8_t sumplayer, card* targe
 		}
 		return TRUE;
 	}
+	case 18: {
+		if(core.limit_tuner) {
+			core.limit_tuner = 0;
+		}
+		if(core.limit_syn) {
+			pduel->delete_group(core.limit_syn);
+			core.limit_syn = 0;
+		}
+		if(core.limit_xyz) {
+			pduel->delete_group(core.limit_xyz);
+			core.limit_xyz = 0;
+		}
+		if(core.limit_link_card) {
+			core.limit_link_card = 0;
+		}
+		if(core.limit_link) {
+			pduel->delete_group(core.limit_link);
+			core.limit_link = 0;
+		}
+		return TRUE;
+	}
 	case 20: {
 		// EFFECT_SPSUMMON_PROC_G (Pendulum Summon)
 		effect* peffect = core.units.begin()->peffect;
@@ -3620,7 +3645,7 @@ int32_t field::destroy(uint16_t step, group * targets, effect * reason_effect, u
 			core.hint_timing[pcard->current.controler] |= TIMING_DESTROY;
 			raise_single_event(pcard, 0, EVENT_DESTROY, pcard->current.reason_effect, pcard->current.reason, pcard->current.reason_player, 0, 0);
 		}
-		adjust_instant();
+		adjust_disable_check_list();
 		process_single_event();
 		raise_event(targets->container, EVENT_DESTROY, reason_effect, reason, reason_player, 0, 0);
 		process_instant_event();
@@ -3655,6 +3680,7 @@ int32_t field::destroy(uint16_t step, group * targets, effect * reason_effect, u
 		}
 		returns.ivalue[0] = (int32_t)core.operated_set.size();
 		pduel->delete_group(targets);
+		adjust_self_destroy_set();
 		return TRUE;
 	}
 	case 10: {
@@ -5304,6 +5330,14 @@ int32_t field::select_synchro_material(int16_t step, uint8_t playerid, card* pca
 	case 0: {
 		if(core.select_cards.size() == 0)
 			return TRUE;
+		if(core.summon_cancelable == FALSE && mg && min == max && mg->container.size() == min + 1) {
+			group* pgroup = pduel->new_group();
+            pgroup->container.insert(mg->container.begin(), mg->container.end());
+			pduel->lua->add_param(pgroup, PARAM_TYPE_GROUP);
+			pduel->restore_assumes();
+			core.limit_tuner = 0;
+			return TRUE;
+		}
 		pduel->write_buffer8(MSG_HINT);
 		pduel->write_buffer8(HINT_SELECTMSG);
 		pduel->write_buffer8(playerid);
@@ -5365,13 +5399,10 @@ int32_t field::select_synchro_material(int16_t step, uint8_t playerid, card* pca
 		}
 		if(!smat)
 			return FALSE;
-		--min;
-		--max;
-		core.units.begin()->arg2 = min + (max << 16);
 		effect* pcheck = tuner->is_affected_by_effect(EFFECT_SYNCHRO_CHECK);
 		if(pcheck)
 			pcheck->get_value(smat);
-		if(min == 0) {
+		if(min == 1 && max == 1) {
 			group* pgroup = pduel->new_group();
 			pgroup->container.insert(tuner);
 			pgroup->container.insert(smat);
@@ -5475,7 +5506,7 @@ int32_t field::select_synchro_material(int16_t step, uint8_t playerid, card* pca
 			card* pm = *cit;
 			if(start != cit)
 				std::iter_swap(start, cit);
-			if(check_other_synchro_material(nsyn, lv, min - 1, max - 1, mcount + 1))
+			if(check_other_synchro_material(nsyn, lv, min - mcount, max - mcount, mcount + 1))
 				core.select_cards.push_back(pm);
 			if(start != cit)
 				std::iter_swap(start, cit);
@@ -5543,6 +5574,7 @@ int32_t field::select_synchro_material(int16_t step, uint8_t playerid, card* pca
 	}
 	case 7: {
 		int32_t lv = pcard->get_level();
+		int32_t mcount = (int32_t)core.must_select_cards.size();
 		if(core.global_flag & GLOBALFLAG_SCRAP_CHIMERA) {
 			effect* peffect = nullptr;
 			for(auto& pm : core.select_cards) {
@@ -5589,7 +5621,7 @@ int32_t field::select_synchro_material(int16_t step, uint8_t playerid, card* pca
 		pduel->write_buffer8(HINT_SELECTMSG);
 		pduel->write_buffer8(playerid);
 		pduel->write_buffer32(512);
-		add_process(PROCESSOR_SELECT_SUM, 0, 0, 0, lv, playerid, min, max);
+		add_process(PROCESSOR_SELECT_SUM, 0, 0, 0, lv, playerid, min - (mcount - 1), max - (mcount - 1));
 		return FALSE;
 	}
 	case 8: {
@@ -5617,6 +5649,7 @@ int32_t field::select_synchro_material(int16_t step, uint8_t playerid, card* pca
 	}
 	case 10: {
 		int32_t lv = pcard->get_level();
+		int32_t mcount = (int32_t)core.must_select_cards.size();
 		if(returns.ivalue[0]) {
 			effect* peffect = nullptr;
 			for(auto& pm : core.select_cards) {
@@ -5642,7 +5675,7 @@ int32_t field::select_synchro_material(int16_t step, uint8_t playerid, card* pca
 		pduel->write_buffer8(HINT_SELECTMSG);
 		pduel->write_buffer8(playerid);
 		pduel->write_buffer32(512);
-		add_process(PROCESSOR_SELECT_SUM, 0, 0, 0, lv, playerid, min, max);
+		add_process(PROCESSOR_SELECT_SUM, 0, 0, 0, lv, playerid, min - (mcount - 1), max - (mcount - 1));
 		core.units.begin()->step = 7;
 		return FALSE;
 	}

processor.cpp

@@ -3919,6 +3919,9 @@ int32_t field::process_turn(uint16_t step, uint8_t turn_player) {
 			}
 			return FALSE;
 		}
+		// ensure "entered 2nd Battle Phase" marker stored in `arg2` do not carry over into Main Phase 2.
+		core.units.begin()->arg2 = 0;
+		
 		core.skip_m2 = FALSE;
 		if(returns.ivalue[0] == 3) { // End Phase
 			core.skip_m2 = TRUE;