Merge branch 'master' of https://github.com/Fluorohydride/ygopro-core

card.cpp

@@ -403,6 +403,26 @@ int32 card::is_fusion_set_card(uint32 set_code) {
 	}
 	return FALSE;
 }
+int32 card::is_link_set_card(uint32 set_code) {
+	if(is_set_card(set_code))
+		return TRUE;
+	uint32 settype = set_code & 0xfff;
+	uint32 setsubtype = set_code & 0xf000;
+	effect_set eset;
+	filter_effect(EFFECT_ADD_LINK_CODE, &eset);
+	for(int32 i = 0; i < eset.size(); ++i) {
+		uint32 code = eset[i]->get_value(this);
+		card_data dat;
+		::read_card(code, &dat);
+		uint64 setcode = dat.setcode;
+		while(setcode) {
+			if ((setcode & 0xfff) == settype && (setcode & 0xf000 & setsubtype) == setsubtype)
+				return TRUE;
+			setcode = setcode >> 16;
+		}
+	}
+	return FALSE;
+}
 uint32 card::get_type() {
 	if(assume_type == ASSUME_TYPE)
 		return assume_value;
@@ -1026,6 +1046,16 @@ uint32 card::get_fusion_attribute(uint8 playerid) {
 	}
 	return attribute;
 }
+uint32 card::get_link_attribute(uint8 playerid) {
+	effect_set effects;
+	filter_effect(EFFECT_ADD_LINK_ATTRIBUTE, &effects);
+	uint32 attribute = get_attribute();
+	for (int32 i = 0; i < effects.size(); ++i) {
+		pduel->lua->add_param(playerid, PARAM_TYPE_INT);
+		attribute |= effects[i]->get_value(this, 1);
+	}
+	return attribute;
+}
 // see get_level()
 uint32 card::get_race() {
 	if(assume_type == ASSUME_RACE)
@@ -1055,6 +1085,16 @@ uint32 card::get_race() {
 	temp.race = 0xffffffff;
 	return race;
 }
+uint32 card::get_link_race(uint8 playerid) {
+	effect_set effects;
+	filter_effect(EFFECT_ADD_LINK_RACE, &effects);
+	uint32 race = get_race();
+	for (int32 i = 0; i < effects.size(); ++i) {
+		pduel->lua->add_param(playerid, PARAM_TYPE_INT);
+		race |= effects[i]->get_value(this, 1);
+	}
+	return race;
+}
 uint32 card::get_lscale() {
 	if(!current.is_location(LOCATION_PZONE))
 		return data.lscale;

card.h

@@ -195,6 +195,7 @@ public:
 	int32 is_origin_set_card(uint32 set_code);
 	int32 is_pre_set_card(uint32 set_code);
 	int32 is_fusion_set_card(uint32 set_code);
+	int32 is_link_set_card(uint32 set_code);
 	uint32 get_type();
 	uint32 get_fusion_type();
 	uint32 get_synchro_type();
@@ -212,7 +213,9 @@ public:
 	uint32 check_xyz_level(card* pcard, uint32 lv);
 	uint32 get_attribute();
 	uint32 get_fusion_attribute(uint8 playerid);
+	uint32 get_link_attribute(uint8 playerid);
 	uint32 get_race();
+	uint32 get_link_race(uint8 playerid);
 	uint32 get_lscale();
 	uint32 get_rscale();
 	uint32 get_link_marker();

effect.h

@@ -431,6 +431,10 @@ inline effect_flag operator|(effect_flag flag1, effect_flag flag2)
 #define EFFECT_CHANGE_FUSION_ATTRIBUTE	351
 #define EFFECT_EXTRA_FUSION_MATERIAL	352
 #define EFFECT_TUNER_MATERIAL_LIMIT		353
+#define EFFECT_ADD_LINK_CODE				354
+//#define EFFECT_ADD_LINK_SETCODE			355
+#define EFFECT_ADD_LINK_ATTRIBUTE		356
+#define EFFECT_ADD_LINK_RACE				357
 
 #define EVENT_STARTUP		1000
 #define EVENT_FLIP			1001

field.cpp

@@ -215,10 +215,13 @@ void field::add_card(uint8 playerid, card* pcard, uint8 location, uint8 sequence
 		break;
 	}
 	case LOCATION_EXTRA: {
-		player[playerid].list_extra.push_back(pcard);
-		pcard->current.sequence = player[playerid].list_extra.size() - 1;
+		if(player[playerid].extra_p_count == 0 || (pcard->data.type & TYPE_PENDULUM) && (pcard->sendto_param.position & POS_FACEUP))
+			player[playerid].list_extra.push_back(pcard);
+		else
+			player[playerid].list_extra.insert(player[playerid].list_extra.end() - player[playerid].extra_p_count, pcard);
 		if((pcard->data.type & TYPE_PENDULUM) && (pcard->sendto_param.position & POS_FACEUP))
 			++player[playerid].extra_p_count;
+		reset_sequence(playerid, LOCATION_EXTRA);
 		break;
 	}
 	}
@@ -825,9 +828,9 @@ void field::get_cards_in_zone(card_set* cset, uint32 zone, int32 playerid, int32
 	}
 }
 void field::shuffle(uint8 playerid, uint8 location) {
-	if(!(location & (LOCATION_HAND | LOCATION_DECK)))
+	if(!(location & (LOCATION_HAND | LOCATION_DECK | LOCATION_EXTRA)))
 		return;
-	card_vector& svector = (location == LOCATION_HAND) ? player[playerid].list_hand : player[playerid].list_main;
+	card_vector& svector = (location == LOCATION_HAND) ? player[playerid].list_hand : (location == LOCATION_DECK) ? player[playerid].list_main : player[playerid].list_extra;
 	if(svector.size() == 0)
 		return;
 	if(location == LOCATION_HAND) {
@@ -841,8 +844,11 @@ void field::shuffle(uint8 playerid, uint8 location) {
 		}
 	}
 	if(location == LOCATION_HAND || !(core.duel_options & DUEL_PSEUDO_SHUFFLE)) {
-		if(svector.size() > 1) {
-			uint32 i = 0, s = svector.size(), r;
+		uint32 s = svector.size();
+		if(location == LOCATION_EXTRA)
+			s = s - player[playerid].extra_p_count;
+		if(s > 1) {
+			uint32 i = 0, r;
 			for(i = 0; i < s - 1; ++i) {
 				r = pduel->get_next_integer(i, s - 1);
 				card* t = svector[i];
@@ -852,13 +858,14 @@ void field::shuffle(uint8 playerid, uint8 location) {
 			reset_sequence(playerid, location);
 		}
 	}
-	if(location == LOCATION_HAND) {
-		pduel->write_buffer8(MSG_SHUFFLE_HAND);
+	if(location == LOCATION_HAND || location == LOCATION_EXTRA) {
+		pduel->write_buffer8((location == LOCATION_HAND) ? MSG_SHUFFLE_HAND : MSG_SHUFFLE_EXTRA);
 		pduel->write_buffer8(playerid);
-		pduel->write_buffer8(player[playerid].list_hand.size());
+		pduel->write_buffer8(svector.size());
 		for(auto cit = svector.begin(); cit != svector.end(); ++cit)
 			pduel->write_buffer32((*cit)->data.code);
-		core.shuffle_hand_check[playerid] = FALSE;
+		if(location == LOCATION_HAND)
+			core.shuffle_hand_check[playerid] = FALSE;
 	} else {
 		pduel->write_buffer8(MSG_SHUFFLE_DECK);
 		pduel->write_buffer8(playerid);

field.h

@@ -839,8 +839,10 @@ public:
 #define MSG_SHUFFLE_SET_CARD	36
 #define MSG_REVERSE_DECK		37
 #define MSG_DECK_TOP			38
+#define MSG_SHUFFLE_EXTRA		39
 #define MSG_NEW_TURN			40
 #define MSG_NEW_PHASE			41
+#define MSG_CONFIRM_EXTRATOP	42
 #define MSG_MOVE				50
 #define MSG_POS_CHANGE			53
 #define MSG_SET					54

interpreter.cpp

@@ -20,11 +20,14 @@ static const struct luaL_Reg cardlib[] = {
 	{ "GetOriginalCode", scriptlib::card_get_origin_code },
 	{ "GetOriginalCodeRule", scriptlib::card_get_origin_code_rule },
 	{ "GetFusionCode", scriptlib::card_get_fusion_code },
+	{ "GetLinkCode", scriptlib::card_get_link_code },
 	{ "IsFusionCode", scriptlib::card_is_fusion_code },
+	{ "IsLinkCode", scriptlib::card_is_link_code },
 	{ "IsSetCard", scriptlib::card_is_set_card },
 	{ "IsOriginalSetCard", scriptlib::card_is_origin_set_card },
 	{ "IsPreviousSetCard", scriptlib::card_is_pre_set_card },
 	{ "IsFusionSetCard", scriptlib::card_is_fusion_set_card },
+	{ "IsLinkSetCard", scriptlib::card_is_link_set_card },
 	{ "GetType", scriptlib::card_get_type },
 	{ "GetOriginalType", scriptlib::card_get_origin_type },
 	{ "GetFusionType", scriptlib::card_get_fusion_type },
@@ -58,8 +61,10 @@ static const struct luaL_Reg cardlib[] = {
 	{ "GetAttribute", scriptlib::card_get_attribute },
 	{ "GetOriginalAttribute", scriptlib::card_get_origin_attribute },
 	{ "GetFusionAttribute", scriptlib::card_get_fusion_attribute },
+	{ "GetLinkAttribute", scriptlib::card_get_link_attribute },
 	{ "GetRace", scriptlib::card_get_race },
 	{ "GetOriginalRace", scriptlib::card_get_origin_race },
+	{ "GetLinkRace", scriptlib::card_get_link_race },
 	{ "GetAttack", scriptlib::card_get_attack },
 	{ "GetBaseAttack", scriptlib::card_get_origin_attack },
 	{ "GetTextAttack", scriptlib::card_get_text_attack },
@@ -106,8 +111,10 @@ static const struct luaL_Reg cardlib[] = {
 	{ "IsRank", scriptlib::card_is_rank },
 	{ "IsLink", scriptlib::card_is_link },
 	{ "IsRace", scriptlib::card_is_race },
+	{ "IsLinkRace", scriptlib::card_is_link_race },
 	{ "IsAttribute", scriptlib::card_is_attribute },
 	{ "IsFusionAttribute", scriptlib::card_is_fusion_attribute },
+	{ "IsLinkAttribute", scriptlib::card_is_link_attribute },
 	{ "IsReason", scriptlib::card_is_reason },
 	{ "IsSummonType", scriptlib::card_is_summon_type },
 	{ "IsStatus", scriptlib::card_is_status },
@@ -392,6 +399,7 @@ static const struct luaL_Reg duellib[] = {
 	{ "SetChainLimitTillChainEnd", scriptlib::duel_set_chain_limit_p },
 	{ "GetChainMaterial", scriptlib::duel_get_chain_material },
 	{ "ConfirmDecktop", scriptlib::duel_confirm_decktop },
+	{ "ConfirmExtratop", scriptlib::duel_confirm_extratop },
 	{ "ConfirmCards", scriptlib::duel_confirm_cards },
 	{ "SortDecktop", scriptlib::duel_sort_decktop },
 	{ "CheckEvent", scriptlib::duel_check_event },
@@ -415,6 +423,7 @@ static const struct luaL_Reg duellib[] = {
 	{ "DiscardHand", scriptlib::duel_discard_hand },
 	{ "DisableShuffleCheck", scriptlib::duel_disable_shuffle_check },
 	{ "ShuffleDeck", scriptlib::duel_shuffle_deck },
+	{ "ShuffleExtra", scriptlib::duel_shuffle_extra },
 	{ "ShuffleHand", scriptlib::duel_shuffle_hand },
 	{ "ShuffleSetCard", scriptlib::duel_shuffle_setcard },
 	{ "ChangeAttacker", scriptlib::duel_change_attacker },
@@ -458,6 +467,7 @@ static const struct luaL_Reg duellib[] = {
 	{ "GetFieldGroup", scriptlib::duel_get_field_group },
 	{ "GetFieldGroupCount", scriptlib::duel_get_field_group_count },
 	{ "GetDecktopGroup", scriptlib::duel_get_decktop_group },
+	{ "GetExtraTopGroup", scriptlib::duel_get_extratop_group },
 	{ "GetMatchingGroup", scriptlib::duel_get_matching_group },
 	{ "GetMatchingGroupCount", scriptlib::duel_get_matching_count },
 	{ "GetFirstMatchingCard", scriptlib::duel_get_first_matching_card },

libcard.cpp

@@ -78,6 +78,23 @@ int32 scriptlib::card_get_fusion_code(lua_State *L) {
 		lua_pushinteger(L, eset[i]->get_value(pcard));
 	return count + eset.size();
 }
+int32 scriptlib::card_get_link_code(lua_State *L) {
+	check_param_count(L, 1);
+	check_param(L, PARAM_TYPE_CARD, 1);
+	card* pcard = *(card**) lua_touserdata(L, 1);
+	lua_pushinteger(L, pcard->get_code());
+	int32 count = 1;
+	uint32 otcode = pcard->get_another_code();
+	if(otcode) {
+		lua_pushinteger(L, otcode);
+		count++;
+	}
+	effect_set eset;
+	pcard->filter_effect(EFFECT_ADD_LINK_CODE, &eset);
+	for(int32 i = 0; i < eset.size(); ++i)
+		lua_pushinteger(L, eset[i]->get_value(pcard));
+	return count + eset.size();
+}
 int32 scriptlib::card_is_fusion_code(lua_State *L) {
 	check_param_count(L, 2);
 	check_param(L, PARAM_TYPE_CARD, 1);
@@ -108,6 +125,36 @@ int32 scriptlib::card_is_fusion_code(lua_State *L) {
 	lua_pushboolean(L, result);
 	return 1;
 }
+int32 scriptlib::card_is_link_code(lua_State *L) {
+	check_param_count(L, 2);
+	check_param(L, PARAM_TYPE_CARD, 1);
+	card* pcard = *(card**) lua_touserdata(L, 1);
+	effect_set eset;
+	pcard->filter_effect(EFFECT_ADD_LINK_CODE, &eset);
+	if(!eset.size())
+		return card_is_code(L);
+	uint32 code1 = pcard->get_code();
+	uint32 code2 = pcard->get_another_code();
+	std::unordered_set<uint32> fcode;
+	fcode.insert(code1);
+	if(code2)
+		fcode.insert(code2);
+	for(int32 i = 0; i < eset.size(); ++i)
+		fcode.insert(eset[i]->get_value(pcard));
+	uint32 count = lua_gettop(L) - 1;
+	uint32 result = FALSE;
+	for(uint32 i = 0; i < count; ++i) {
+		if(lua_isnil(L, i + 2))
+			continue;
+		uint32 tcode = lua_tointeger(L, i + 2);
+		if(fcode.find(tcode) != fcode.end()) {
+			result = TRUE;
+			break;
+		}
+	}
+	lua_pushboolean(L, result);
+	return 1;
+}
 int32 scriptlib::card_is_set_card(lua_State *L) {
 	check_param_count(L, 2);
 	check_param(L, PARAM_TYPE_CARD, 1);
@@ -140,6 +187,14 @@ int32 scriptlib::card_is_fusion_set_card(lua_State *L) {
 	lua_pushboolean(L, pcard->is_fusion_set_card(set_code));
 	return 1;
 }
+int32 scriptlib::card_is_link_set_card(lua_State *L) {
+	check_param_count(L, 2);
+	check_param(L, PARAM_TYPE_CARD, 1);
+	card* pcard = *(card**) lua_touserdata(L, 1);
+	uint32 set_code = lua_tointeger(L, 2);
+	lua_pushboolean(L, pcard->is_link_set_card(set_code));
+	return 1;
+}
 int32 scriptlib::card_get_type(lua_State *L) {
 	check_param_count(L, 1);
 	check_param(L, PARAM_TYPE_CARD, 1);
@@ -396,7 +451,7 @@ int32 scriptlib::card_get_column_zone(lua_State *L) {
 	int32 loc = lua_tointeger(L, 2);
 	int32 left = 0;
 	int32 right = 0;
-	int32 cp = pcard->current.controler;	
+	int32 cp = pcard->current.controler;
 	if(lua_gettop(L) >= 3)
 		left = lua_tointeger(L, 3);
 	if(lua_gettop(L) >= 4)
@@ -446,6 +501,18 @@ int32 scriptlib::card_get_fusion_attribute(lua_State *L) {
 	lua_pushinteger(L, pcard->get_fusion_attribute(playerid));
 	return 1;
 }
+int32 scriptlib::card_get_link_attribute(lua_State *L) {
+	check_param_count(L, 1);
+	check_param(L, PARAM_TYPE_CARD, 1);
+	card* pcard = *(card**)lua_touserdata(L, 1);
+	int32 playerid = PLAYER_NONE;
+	if(lua_gettop(L) > 1 && !lua_isnil(L, 2))
+		playerid = lua_tointeger(L, 2);
+	else
+		playerid = pcard->pduel->game_field->core.reason_player;
+	lua_pushinteger(L, pcard->get_link_attribute(playerid));
+	return 1;
+}
 int32 scriptlib::card_get_race(lua_State *L) {
 	check_param_count(L, 1);
 	check_param(L, PARAM_TYPE_CARD, 1);
@@ -463,6 +530,18 @@ int32 scriptlib::card_get_origin_race(lua_State *L) {
 		lua_pushinteger(L, pcard->data.race);
 	return 1;
 }
+int32 scriptlib::card_get_link_race(lua_State *L) {
+	check_param_count(L, 1);
+	check_param(L, PARAM_TYPE_CARD, 1);
+	card* pcard = *(card**)lua_touserdata(L, 1);
+	int32 playerid = PLAYER_NONE;
+	if(lua_gettop(L) > 1 && !lua_isnil(L, 2))
+		playerid = lua_tointeger(L, 2);
+	else
+		playerid = pcard->pduel->game_field->core.reason_player;
+	lua_pushinteger(L, pcard->get_link_race(playerid));
+	return 1;
+}
 int32 scriptlib::card_get_attack(lua_State *L) {
 	check_param_count(L, 1);
 	check_param(L, PARAM_TYPE_CARD, 1);
@@ -847,6 +926,22 @@ int32 scriptlib::card_is_race(lua_State *L) {
 		lua_pushboolean(L, 0);
 	return 1;
 }
+int32 scriptlib::card_is_link_race(lua_State *L) {
+	check_param_count(L, 2);
+	check_param(L, PARAM_TYPE_CARD, 1);
+	card* pcard = *(card**)lua_touserdata(L, 1);
+	uint32 trace = lua_tointeger(L, 2);
+	int32 playerid = PLAYER_NONE;
+	if(lua_gettop(L) > 2 && !lua_isnil(L, 3))
+		playerid = lua_tointeger(L, 3);
+	else
+		playerid = pcard->pduel->game_field->core.reason_player;
+	if(pcard->get_link_race(playerid) & trace)
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
 int32 scriptlib::card_is_attribute(lua_State *L) {
 	check_param_count(L, 2);
 	check_param(L, PARAM_TYPE_CARD, 1);
@@ -874,6 +969,22 @@ int32 scriptlib::card_is_fusion_attribute(lua_State *L) {
 		lua_pushboolean(L, 0);
 	return 1;
 }
+int32 scriptlib::card_is_link_attribute(lua_State *L) {
+	check_param_count(L, 2);
+	check_param(L, PARAM_TYPE_CARD, 1);
+	card* pcard = *(card**)lua_touserdata(L, 1);
+	uint32 tattrib = lua_tointeger(L, 2);
+	int32 playerid = PLAYER_NONE;
+	if(lua_gettop(L) > 2 && !lua_isnil(L, 3))
+		playerid = lua_tointeger(L, 3);
+	else
+		playerid = pcard->pduel->game_field->core.reason_player;
+	if(pcard->get_link_attribute(playerid) & tattrib)
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
 int32 scriptlib::card_is_reason(lua_State *L) {
 	check_param_count(L, 2);
 	check_param(L, PARAM_TYPE_CARD, 1);

libduel.cpp

@@ -805,6 +805,28 @@ int32 scriptlib::duel_confirm_decktop(lua_State *L) {
 	pduel->game_field->add_process(PROCESSOR_WAIT, 0, 0, 0, 0, 0);
 	return lua_yield(L, 0);
 }
+int32 scriptlib::duel_confirm_extratop(lua_State *L) {
+	check_param_count(L, 2);
+	int32 playerid = lua_tointeger(L, 1);
+	if(playerid != 0 && playerid != 1)
+		return 0;
+	uint32 count = lua_tointeger(L, 2);
+	duel* pduel = interpreter::get_duel_info(L);
+	if(count >= pduel->game_field->player[playerid].list_extra.size() - pduel->game_field->player[playerid].extra_p_count)
+		count = pduel->game_field->player[playerid].list_extra.size() - pduel->game_field->player[playerid].extra_p_count;
+	auto cit = pduel->game_field->player[playerid].list_extra.rbegin() + pduel->game_field->player[playerid].extra_p_count;
+	pduel->write_buffer8(MSG_CONFIRM_EXTRATOP);
+	pduel->write_buffer8(playerid);
+	pduel->write_buffer8(count);
+	for(uint32 i = 0; i < count && cit != pduel->game_field->player[playerid].list_extra.rend(); ++i, ++cit) {
+		pduel->write_buffer32((*cit)->data.code);
+		pduel->write_buffer8((*cit)->current.controler);
+		pduel->write_buffer8((*cit)->current.location);
+		pduel->write_buffer8((*cit)->current.sequence);
+	}
+	pduel->game_field->add_process(PROCESSOR_WAIT, 0, 0, 0, 0, 0);
+	return lua_yield(L, 0);
+}
 int32 scriptlib::duel_confirm_cards(lua_State *L) {
 	check_param_count(L, 2);
 	int32 playerid = lua_tointeger(L, 1);
@@ -1287,6 +1309,15 @@ int32 scriptlib::duel_shuffle_deck(lua_State *L) {
 	pduel->game_field->shuffle(playerid, LOCATION_DECK);
 	return 0;
 }
+int32 scriptlib::duel_shuffle_extra(lua_State *L) {
+	check_param_count(L, 1);
+	uint32 playerid = lua_tointeger(L, 1);
+	if (playerid != 0 && playerid != 1)
+		return 0;
+	duel* pduel = interpreter::get_duel_info(L);
+	pduel->game_field->shuffle(playerid, LOCATION_EXTRA);
+	return 0;
+}
 int32 scriptlib::duel_shuffle_hand(lua_State *L) {
 	check_param_count(L, 1);
 	uint32 playerid = lua_tointeger(L, 1);
@@ -2033,6 +2064,23 @@ int32 scriptlib::duel_get_decktop_group(lua_State *L) {
 	interpreter::group2value(L, pgroup);
 	return 1;
 }
+/**
+ * \brief Duel.GetExtraTopGroup
+ * \param playerid, count
+ * \return Group
+ */
+int32 scriptlib::duel_get_extratop_group(lua_State *L) {
+	check_param_count(L, 2);
+	uint32 playerid = lua_tointeger(L, 1);
+	uint32 count = lua_tointeger(L, 2);
+	duel* pduel = interpreter::get_duel_info(L);
+	group* pgroup = pduel->new_group();
+	auto cit = pduel->game_field->player[playerid].list_extra.rbegin() + pduel->game_field->player[playerid].extra_p_count;
+	for(uint32 i = 0; i < count && cit != pduel->game_field->player[playerid].list_extra.rend(); ++i, ++cit)
+		pgroup->container.insert(*cit);
+	interpreter::group2value(L, pgroup);
+	return 1;
+}
 /**
 * \brief Duel.GetMatchingGroup
 * \param filter_func, self, location1, location2, exception card, (extraargs...)

processor.cpp

@@ -1654,7 +1654,8 @@ int32 field::process_point_event(int16 step, int32 skip_trigger, int32 skip_free
 	}
 	case 2: {
 		//forced trigger
-		for (auto clit = core.new_fchain_s.begin(); clit != core.new_fchain_s.end(); ++clit) {
+		core.select_chains.clear();
+		for (auto clit = core.new_fchain_s.begin(); clit != core.new_fchain_s.end(); ) {
 			effect* peffect = clit->triggering_effect;
 			card* phandler = peffect->get_handler();
 			if(!peffect->is_flag(EFFECT_FLAG_EVENT_PLAYER | EFFECT_FLAG_BOTH_SIDE) && phandler->is_has_relation(*clit)) {
@@ -1664,236 +1665,150 @@ int32 field::process_point_event(int16 step, int32 skip_trigger, int32 skip_free
 			uint8 tp = clit->triggering_player;
 			bool act = true;
 			if(peffect->is_chainable(tp) && peffect->is_activateable(tp, clit->evt, TRUE)
-					&& (!(peffect->type & EFFECT_TYPE_FIELD) || phandler->is_has_relation(*clit))
-					&& (peffect->code == EVENT_FLIP && infos.phase == PHASE_DAMAGE || (clit->triggering_location & 0x43)
-						|| !(phandler->current.location & 0x43) || phandler->is_position(POS_FACEUP))) {
+				&& (!(peffect->type & EFFECT_TYPE_FIELD) || phandler->is_has_relation(*clit))
+				&& (peffect->code == EVENT_FLIP && infos.phase == PHASE_DAMAGE
+					|| (clit->triggering_location & 0x43) && (clit->triggering_position & POS_FACEDOWN)
+					|| !(phandler->current.location & 0x43) || phandler->is_position(POS_FACEUP))) {
 				if(peffect->is_flag(EFFECT_FLAG_CHAIN_UNIQUE)) {
-					if(tp == infos.turn_player) {
-						for(auto tpit = core.tpchain.begin(); tpit != core.tpchain.end(); ++tpit) {
-							if(tpit->triggering_effect->get_handler()->data.code == phandler->data.code) {
-								act = false;
-								break;
-							}
-						}
-					} else {
-						for(auto ntpit = core.ntpchain.begin(); ntpit != core.ntpchain.end(); ++ntpit) {
-							if(ntpit->triggering_effect->get_handler()->data.code == phandler->data.code) {
-								act = false;
-								break;
-							}
+					for(auto tpit = core.current_chain.begin(); tpit != core.current_chain.end(); ++tpit) {
+						if(tpit->triggering_effect->get_handler()->data.code == phandler->data.code && tpit->triggering_player == tp) {
+							act = false;
+							break;
 						}
 					}
 				}
 			} else
 				act = false;
 			if(act) {
-				if(tp == infos.turn_player)
-					core.tpchain.push_back(*clit);
-				else
-					core.ntpchain.push_back(*clit);
-				phandler->set_status(STATUS_CHAINING, TRUE);
-				peffect->dec_count(tp);
-				if(peffect->is_flag(EFFECT_FLAG_CVAL_CHECK))
-					peffect->get_value();
+				if(tp == core.current_player)
+					core.select_chains.push_back(*clit);
+			} else {
+				core.new_fchain_s.erase(clit++);
+				continue;
 			}
+			++clit;
 		}
-		core.new_fchain_s.clear();
-		if(core.current_player == infos.turn_player) {
-			if(core.tpchain.size() > 1)
-				add_process(PROCESSOR_SORT_CHAIN, 0, 0, 0, 1, infos.turn_player);
+		if(core.select_chains.size() == 0) {
+			returns.ivalue[0] = -1;
+		} else if(core.select_chains.size() == 1) {
+			returns.ivalue[0] = 0;
 		} else {
-			if(core.ntpchain.size() > 1)
-				add_process(PROCESSOR_SORT_CHAIN, 0, 0, 0, 0, infos.turn_player);
+			add_process(PROCESSOR_SELECT_CHAIN, 0, 0, 0, core.current_player, 0x7f | 0x10000);
 		}
 		return FALSE;
 	}
 	case 3: {
-		if(core.current_player == infos.turn_player) {
-			core.new_chains.splice(core.new_chains.end(), core.tpchain);
-			if(core.new_chains.size())
-				add_process(PROCESSOR_ADD_CHAIN, 0, 0, 0, 0, 0);
-			core.current_player = 1 - infos.turn_player;
-			core.units.begin()->step = 1;
-		} else {
-			core.new_chains.splice(core.new_chains.end(), core.ntpchain);
-			if(core.new_chains.size())
-				add_process(PROCESSOR_ADD_CHAIN, 0, 0, 0, 0, 0);
+		if(returns.ivalue[0] == -1) {
+			if(core.new_fchain_s.size()) {
+				core.current_player = 1 - infos.turn_player;
+				core.units.begin()->step = 1;
+			} else {
+				core.current_player = infos.turn_player;
+			}
+			return FALSE;
 		}
+		chain newchain = core.select_chains[returns.ivalue[0]];
+		effect* peffect = newchain.triggering_effect;
+		uint8 tp = newchain.triggering_player;
+		peffect->get_handler()->set_status(STATUS_CHAINING, TRUE);
+		peffect->dec_count(tp);
+		core.new_chains.push_back(newchain);
+		add_process(PROCESSOR_ADD_CHAIN, 0, 0, 0, 0, 0);
+		core.new_fchain_s.remove_if([=](chain ch) { return ch.chain_id == newchain.chain_id; });
+		core.units.begin()->step = 1;
 		return FALSE;
 	}
 	case 4: {
 		//optional trigger
-		if(core.new_ochain_s.size() == 0) {
-			core.units.begin()->step = 6;
-			return FALSE;
-		}
-		for (auto clit = core.new_ochain_s.begin(); clit != core.new_ochain_s.end(); ++clit) {
+		core.select_chains.clear();
+		for (auto clit = core.new_ochain_s.begin(); clit != core.new_ochain_s.end(); ) {
 			effect* peffect = clit->triggering_effect;
 			card* phandler = peffect->get_handler();
 			if((!peffect->is_flag(EFFECT_FLAG_EVENT_PLAYER | EFFECT_FLAG_BOTH_SIDE) && phandler->is_has_relation(*clit))
-			        || (!peffect->is_flag(EFFECT_FLAG_FIELD_ONLY) && (peffect->type & EFFECT_TYPE_FIELD)
-			            && (peffect->range & LOCATION_HAND) && phandler->current.location == LOCATION_HAND)) {
+				|| (!peffect->is_flag(EFFECT_FLAG_FIELD_ONLY) && (peffect->type & EFFECT_TYPE_FIELD)
+					&& (peffect->range & LOCATION_HAND) && phandler->current.location == LOCATION_HAND)) {
 				if(!phandler->is_has_relation(*clit))
 					phandler->create_relation(*clit);
 				clit->triggering_player = phandler->current.controler;
 				clit->set_triggering_place(phandler);
 			}
-			if(clit->triggering_player == infos.turn_player)
-				core.tpchain.push_back(*clit);
-			else
-				core.ntpchain.push_back(*clit);
-		}
-		core.new_ochain_s.clear();
-		core.new_ochain_s.splice(core.new_ochain_s.end(), core.tpchain);
-		core.new_ochain_s.splice(core.new_ochain_s.end(), core.ntpchain);
-		core.new_ochain_h.clear();
-		core.tmp_chain.clear();
-		core.current_player = infos.turn_player;
-		return FALSE;
-	}
-	case 5: {
-		if(core.new_ochain_s.size() == 0) {
-			if(core.current_player == infos.turn_player) {
-				if(core.tpchain.size() > 1)
-					add_process(PROCESSOR_SORT_CHAIN, 0, 0, 0, 1, infos.turn_player);
-				core.new_ochain_s.splice(core.new_ochain_s.end(), core.tmp_chain);
-			} else {
-				if(core.ntpchain.size() > 1)
-					add_process(PROCESSOR_SORT_CHAIN, 0, 0, 0, 0, infos.turn_player);
-			}
-			core.units.begin()->step = 6;
-			return FALSE;
-		}
-		auto clit = core.new_ochain_s.begin();
-		effect* peffect = clit->triggering_effect;
-		card* phandler = peffect->get_handler();
-		uint8 tp = clit->triggering_player;
-		bool act = true;
-		if(peffect->is_chainable(tp) && peffect->is_activateable(tp, clit->evt, TRUE)
+			uint8 tp = clit->triggering_player;
+			bool act = true;
+			if(peffect->is_chainable(tp) && peffect->is_activateable(tp, clit->evt, TRUE)
 				&& (!(peffect->type & EFFECT_TYPE_FIELD) || phandler->is_has_relation(*clit))
-				&& (peffect->code == EVENT_FLIP && infos.phase == PHASE_DAMAGE || (clit->triggering_location & 0x43)
-		            || !(phandler->current.location & 0x43) || phandler->is_position(POS_FACEUP))) {
-			if(!peffect->is_flag(EFFECT_FLAG_FIELD_ONLY) && clit->triggering_location == LOCATION_HAND && (peffect->range & LOCATION_HAND)) {
-				core.new_ochain_h.push_back(*clit);
-				act = false;
-			} else if(peffect->is_flag(EFFECT_FLAG_FIELD_ONLY) || !(peffect->type & EFFECT_TYPE_FIELD)
-		            || peffect->in_range(*clit)) {
-				if(peffect->is_flag(EFFECT_FLAG_CHAIN_UNIQUE)) {
-					if(tp == infos.turn_player) {
-						for(auto tpit = core.tpchain.begin(); tpit != core.tpchain.end(); ++tpit) {
-							if(tpit->triggering_effect->get_handler()->data.code == phandler->data.code) {
-								act = false;
-								break;
-							}
-						}
-					} else {
-						for(auto ntpit = core.ntpchain.begin(); ntpit != core.ntpchain.end(); ++ntpit) {
-							if(ntpit->triggering_effect->get_handler()->data.code == phandler->data.code) {
+				&& (peffect->code == EVENT_FLIP && infos.phase == PHASE_DAMAGE
+					|| (clit->triggering_location & 0x43) && (clit->triggering_position & POS_FACEDOWN)
+					|| !(phandler->current.location & 0x43) || phandler->is_position(POS_FACEUP))) {
+				if(!peffect->is_flag(EFFECT_FLAG_FIELD_ONLY) && clit->triggering_location == LOCATION_HAND
+					&& (((peffect->type & EFFECT_TYPE_SINGLE) && !peffect->is_flag(EFFECT_FLAG_SINGLE_RANGE) && phandler->is_has_relation(*clit))
+						|| (peffect->range & LOCATION_HAND))) {
+					core.new_ochain_h.push_back(*clit);
+					act = false;
+				} else if(peffect->is_flag(EFFECT_FLAG_FIELD_ONLY) || !(peffect->type & EFFECT_TYPE_FIELD) || peffect->in_range(*clit)) {
+					if(peffect->is_flag(EFFECT_FLAG_CHAIN_UNIQUE)) {
+						for(auto tpit = core.current_chain.begin(); tpit != core.current_chain.end(); ++tpit) {
+							if(tpit->triggering_effect->get_handler()->data.code == phandler->data.code && tpit->triggering_player == tp) {
 								act = false;
 								break;
 							}
 						}
 					}
-				}
-			} else
-				act = false;
-		} else act = false;
-		if(act) {
-			if(tp == core.current_player)
-				add_process(PROCESSOR_SELECT_EFFECTYN, 0, 0, (group*)phandler, tp, 0);
-			else {
-				core.tmp_chain.push_back(*clit);
-				returns.ivalue[0] = FALSE;
+				} else
+					act = false;
+			} else act = false;
+			if(act) {
+				if(tp == core.current_player)
+					core.select_chains.push_back(*clit);
+			} else {
+				core.new_ochain_s.erase(clit++);
+				continue;
 			}
-		} else returns.ivalue[0] = FALSE;
+			++clit;
+		}
+		if(core.select_chains.size() == 0) {
+			returns.ivalue[0] = -1;
+			core.units.begin()->step = 5;
+			return FALSE;
+		} else if(core.select_chains.size() == 1 && !core.current_chain.size()) {
+			add_process(PROCESSOR_SELECT_EFFECTYN, 0, 0, (group*)core.select_chains[0].triggering_effect->get_handler(), core.current_player, 0);
+			return FALSE;
+		} else {
+			add_process(PROCESSOR_SELECT_CHAIN, 0, 0, 0, core.current_player, 0x7f);
+			core.units.begin()->step = 5;
+			return FALSE;
+		}
+		return FALSE;
+	}
+	case 5: {
+		returns.ivalue[0]--;
 		return FALSE;
 	}
 	case 6: {
-		if(!returns.ivalue[0]) {
-			core.new_ochain_s.pop_front();
-			core.units.begin()->step = 4;
-			return FALSE;
-		}
-		auto clit = core.new_ochain_s.begin();
-		effect* peffect = clit->triggering_effect;
-		card* pcard = peffect->get_handler();
-		uint8 tp = clit->triggering_player;
-		core.select_effects.clear();
-		core.select_options.clear();
-		uintptr_t index = 0;
-		core.select_effects.push_back((effect*)index);
-		core.select_options.push_back(peffect->description);
-		while(++clit != core.new_ochain_s.end()) {
-			++index;
-			peffect = clit->triggering_effect;
-			card* phandler = peffect->get_handler();
-			if(pcard != phandler)
-				continue;
-			bool act = true;
-			if(peffect->is_chainable(tp) && peffect->is_activateable(tp, clit->evt, TRUE)
-					&& (!(peffect->type & EFFECT_TYPE_FIELD) || phandler->is_has_relation(*clit))
-					&& (peffect->code == EVENT_FLIP && infos.phase == PHASE_DAMAGE || (clit->triggering_location & 0x43)
-			            || !(phandler->current.location & 0x43) || phandler->is_position(POS_FACEUP))) {
-				if(!peffect->is_flag(EFFECT_FLAG_FIELD_ONLY) && clit->triggering_location == LOCATION_HAND && (peffect->range & LOCATION_HAND)) {
-					continue;
-				} else if(peffect->is_flag(EFFECT_FLAG_FIELD_ONLY) || !(peffect->type & EFFECT_TYPE_FIELD)
-			            || peffect->in_range(*clit)) {
-					if(peffect->is_flag(EFFECT_FLAG_CHAIN_UNIQUE)) {
-						if(tp == infos.turn_player) {
-							for(auto tpit = core.tpchain.begin(); tpit != core.tpchain.end(); ++tpit) {
-								if(tpit->triggering_effect->get_handler()->data.code == phandler->data.code) {
-									act = false;
-									break;
-								}
-							}
-						} else {
-							for(auto ntpit = core.ntpchain.begin(); ntpit != core.ntpchain.end(); ++ntpit) {
-								if(ntpit->triggering_effect->get_handler()->data.code == phandler->data.code) {
-									act = false;
-									break;
-								}
-							}
-						}
-					}
-				} else
-					continue;
-			} else continue;
-			if(act) {
-				core.select_effects.push_back((effect*)index);
-				core.select_options.push_back(peffect->description);
+		if(returns.ivalue[0] == -1) {
+			for(auto cit = core.select_chains.begin(); cit != core.select_chains.end(); ++cit)
+				core.new_ochain_s.remove_if([=](chain ch) { return ch.chain_id == cit->chain_id; });
+			if(core.new_ochain_s.size()) {
+				core.current_player = 1 - infos.turn_player;
+				core.units.begin()->step = 3;
+			} else {
+				core.current_player = infos.turn_player;
+				core.units.begin()->step = 6;
 			}
-		}
-		if(core.select_options.size() > 1) {
-			add_process(PROCESSOR_SELECT_OPTION, 0, 0, 0, tp, 0);
-			core.units.begin()->step = 19;
 			return FALSE;
 		}
-		clit = core.new_ochain_s.begin();
-		peffect = clit->triggering_effect;
+		chain newchain = core.select_chains[returns.ivalue[0]];
+		effect* peffect = newchain.triggering_effect;
+		uint8 tp = newchain.triggering_player;
 		peffect->get_handler()->set_status(STATUS_CHAINING, TRUE);
 		peffect->dec_count(tp);
-		if(tp == infos.turn_player)
-			core.tpchain.push_back(*clit);
-		else
-			core.ntpchain.push_back(*clit);
-		if(peffect->is_flag(EFFECT_FLAG_CVAL_CHECK))
-			peffect->get_value();
-		core.new_ochain_s.pop_front();
-		core.units.begin()->step = 4;
+		core.new_chains.push_back(newchain);
+		add_process(PROCESSOR_ADD_CHAIN, 0, 0, 0, 0, 0);
+		core.new_ochain_s.remove_if([=](chain ch) { return ch.chain_id == newchain.chain_id; });
+		core.units.begin()->step = 3;
 		return FALSE;
 	}
 	case 7: {
-		if(core.current_player == infos.turn_player) {
-			core.new_chains.splice(core.new_chains.end(), core.tpchain);
-			if(core.new_chains.size())
-				add_process(PROCESSOR_ADD_CHAIN, 0, 0, 0, 0, 0);
-			core.current_player = 1 - infos.turn_player;
-			core.units.begin()->step = 4;
-		} else {
-			core.new_chains.splice(core.new_chains.end(), core.ntpchain);
-			if(core.new_chains.size())
-				add_process(PROCESSOR_ADD_CHAIN, 0, 0, 0, 0, 0);
-		}
+		core.select_chains.clear();
 		return FALSE;
 	}
 	case 8: {
@@ -1960,24 +1875,6 @@ int32 field::process_point_event(int16 step, int32 skip_trigger, int32 skip_free
 		}
 		return TRUE;
 	}
-	case 20: {
-		uintptr_t index = (uintptr_t)core.select_effects[returns.ivalue[0]];
-		auto clit = core.new_ochain_s.begin();
-		std::advance(clit, index);
-		effect* peffect = clit->triggering_effect;
-		uint8 tp = clit->triggering_player;
-		peffect->get_handler()->set_status(STATUS_CHAINING, TRUE);
-		peffect->dec_count(tp);
-		if(tp == infos.turn_player)
-			core.tpchain.push_back(*clit);
-		else
-			core.ntpchain.push_back(*clit);
-		if(peffect->is_flag(EFFECT_FLAG_CVAL_CHECK))
-			peffect->get_value();
-		core.new_ochain_s.erase(clit);
-		core.units.begin()->step = 4;
-		return FALSE;
-	}
 	case 30: {
 		int32 check_player = infos.turn_player;
 		nil_event.event_code = EVENT_FREE_CHAIN;
@@ -2032,8 +1929,10 @@ int32 field::process_point_event(int16 step, int32 skip_trigger, int32 skip_free
 		return FALSE;
 	}
 	case 33: {
-		if(returns.ivalue[0] == -1)
+		if(returns.ivalue[0] == -1) {
+			core.units.begin()->step = -1;
 			return FALSE;
+		}
 		const chain& newchain = core.select_chains[returns.ivalue[0]];
 		effect* peffect = newchain.triggering_effect;
 		core.select_chains.clear();
@@ -2168,9 +2067,7 @@ int32 field::process_quick_effect(int16 step, int32 skip_freechain, uint8 priori
 				        && peffect->is_chainable(priority) && peffect->is_activateable(priority, clit->evt, TRUE)) {
 					for(auto cait = core.current_chain.begin(); cait != core.current_chain.end(); ++cait) {
 						if(cait->triggering_player == priority) {
-							effect* pchaineff = cait->triggering_effect;
-							if(!pchaineff->is_flag(EFFECT_FLAG_FIELD_ONLY) && (pchaineff->type & EFFECT_TYPE_TRIGGER_O)
-							        && cait->triggering_location == LOCATION_HAND && (pchaineff->range & LOCATION_HAND)) {
+							if(std::any_of(core.new_ochain_h.begin(), core.new_ochain_h.end(), [=](chain ch) { return ch.chain_id == cait->chain_id; })) {
 								act = false;
 								break;
 							}

scriptlib.h

@@ -22,11 +22,14 @@ public:
 	static int32 card_get_origin_code(lua_State *L);
 	static int32 card_get_origin_code_rule(lua_State *L);
 	static int32 card_get_fusion_code(lua_State *L);
+	static int32 card_get_link_code(lua_State *L);
 	static int32 card_is_fusion_code(lua_State *L);
+	static int32 card_is_link_code(lua_State *L);
 	static int32 card_is_set_card(lua_State *L);
 	static int32 card_is_origin_set_card(lua_State *L);
 	static int32 card_is_pre_set_card(lua_State *L);
 	static int32 card_is_fusion_set_card(lua_State *L);
+	static int32 card_is_link_set_card(lua_State *L);
 	static int32 card_get_type(lua_State *L);
 	static int32 card_get_origin_type(lua_State *L);
 	static int32 card_get_fusion_type(lua_State *L);
@@ -60,8 +63,10 @@ public:
 	static int32 card_get_attribute(lua_State *L);
 	static int32 card_get_origin_attribute(lua_State *L);
 	static int32 card_get_fusion_attribute(lua_State *L);
+	static int32 card_get_link_attribute(lua_State *L);
 	static int32 card_get_race(lua_State *L);
 	static int32 card_get_origin_race(lua_State *L);
+	static int32 card_get_link_race(lua_State *L);
 	static int32 card_get_attack(lua_State *L);
 	static int32 card_get_origin_attack(lua_State *L);
 	static int32 card_get_text_attack(lua_State *L);
@@ -108,8 +113,10 @@ public:
 	static int32 card_is_rank(lua_State *L);
 	static int32 card_is_link(lua_State *L);
 	static int32 card_is_race(lua_State *L);
+	static int32 card_is_link_race(lua_State *L);
 	static int32 card_is_attribute(lua_State *L);
 	static int32 card_is_fusion_attribute(lua_State *L);
+	static int32 card_is_link_attribute(lua_State *L);
 	static int32 card_is_reason(lua_State *L);
 	static int32 card_is_summon_type(lua_State *L);
 	static int32 card_is_status(lua_State *L);
@@ -388,6 +395,7 @@ public:
 	static int32 duel_set_chain_limit_p(lua_State *L);
 	static int32 duel_get_chain_material(lua_State *L);
 	static int32 duel_confirm_decktop(lua_State *L);
+	static int32 duel_confirm_extratop(lua_State *L);
 	static int32 duel_confirm_cards(lua_State *L);
 	static int32 duel_sort_decktop(lua_State *L);
 	static int32 duel_check_event(lua_State *L);
@@ -412,6 +420,7 @@ public:
 	static int32 duel_discard_hand(lua_State *L);
 	static int32 duel_disable_shuffle_check(lua_State *L);
 	static int32 duel_shuffle_deck(lua_State *L);
+	static int32 duel_shuffle_extra(lua_State *L);
 	static int32 duel_shuffle_hand(lua_State *L);
 	static int32 duel_shuffle_setcard(lua_State *L);
 	static int32 duel_change_attacker(lua_State *L);
@@ -456,6 +465,7 @@ public:
 	static int32 duel_get_field_group(lua_State *L);
 	static int32 duel_get_field_group_count(lua_State *L);
 	static int32 duel_get_decktop_group(lua_State *L);
+	static int32 duel_get_extratop_group(lua_State *L);
 	static int32 duel_get_matching_group(lua_State *L);
 	static int32 duel_get_matching_count(lua_State *L);
 	static int32 duel_get_first_matching_card(lua_State *L);