Merge remote-tracking branch 'upstream/master'

card.cpp

@@ -95,7 +95,7 @@ bool card::card_operation_sort(card* c1, card* c2) {
 			return c1->overlay_target->current.sequence < c2->overlay_target->current.sequence;
 		else
 			return c1->current.sequence < c2->current.sequence;
-	} else if (c1->current.location & LOCATION_DECK && cp1 == pduel->game_field->core.selecting_player && !pduel->game_field->core.select_deck_seq_preserved) {
+	} else if (c1->current.location & LOCATION_DECK && pduel->game_field->is_select_hide_deck_sequence(cp1)) {
 		// if deck reversed and the card being at the top, it should go first
 		if(pduel->game_field->core.deck_reversed) {
 			if(c1->current.sequence == pduel->game_field->player[cp1].list_main.size() - 1)
@@ -176,7 +176,7 @@ card::card(duel* pd) {
 	xyz_materials_previous_count_onfield = 0;
 	current.controler = PLAYER_NONE;
 }
-inline void update_cache(uint32& tdata, uint32& cache, byte*& p, uint32& query_flag, const uint32 flag) {
+inline void update_cache(uint32 tdata, uint32& cache, byte*& p, uint32& query_flag, uint32 flag) {
 	if (tdata != cache) {
 		cache = tdata;
 		buffer_write<uint32_t>(p, tdata);
@@ -1511,7 +1511,7 @@ int32 card::is_all_column() {
 	return FALSE;
 }
 uint8 card::get_select_sequence(uint8 *deck_seq_pointer) {
-	if(current.location == LOCATION_DECK && current.controler == pduel->game_field->core.selecting_player && !pduel->game_field->core.select_deck_seq_preserved) {
+	if(current.location == LOCATION_DECK && pduel->game_field->is_select_hide_deck_sequence(current.controler)) {
 		return (*deck_seq_pointer)++;
 	} else {
 		return current.sequence;

common.h

@@ -43,6 +43,7 @@ typedef signed char int8;
 #define NULL 0
 #endif
 
+#define MASTER_RULE3		3	//Master Rule 3 (2014)
 #define NEW_MASTER_RULE		4	//New Master Rule (2017)
 #define MASTER_RULE_2020	5	//Master Rule 2020
 #define CURRENT_RULE		5
@@ -418,6 +419,7 @@ typedef signed char int8;
 #define DUEL_TAG_MODE			0x20
 #define DUEL_SIMPLE_AI			0x40
 #define DUEL_RETURN_DECK_TOP	0x80
+#define DUEL_REVEAL_DECK_SEQ	0x100
 
 //Activity
 #define ACTIVITY_SUMMON			1

field.cpp

@@ -55,25 +55,7 @@ bool tevent::operator< (const tevent& v) const {
 }
 field::field(duel* pduel) {
 	this->pduel = pduel;
-	infos.field_id = 1;
-	infos.copy_id = 1;
-	infos.can_shuffle = TRUE;
-	infos.turn_id = 0;
-	infos.turn_id_by_player[0] = 0;
-	infos.turn_id_by_player[1] = 0;
-	infos.card_id = 1;
-	infos.phase = 0;
-	infos.turn_player = 0;
 	for (int32 i = 0; i < 2; ++i) {
-		//cost[i].count = 0;
-		//cost[i].amount = 0;
-		player[i].lp = 8000;
-		player[i].start_count = 5;
-		player[i].draw_count = 1;
-		player[i].disabled_location = 0;
-		player[i].used_location = 0;
-		player[i].extra_p_count = 0;
-		player[i].tag_extra_p_count = 0;
 		player[i].list_mzone.resize(7, 0);
 		player[i].list_szone.resize(8, 0);
 		player[i].list_main.reserve(60);
@@ -82,8 +64,6 @@ field::field(duel* pduel) {
 		player[i].list_remove.reserve(75);
 		player[i].list_extra.reserve(30);
 	}
-	returns = { 0 };
-	temp_card = nullptr;
 }
 void field::reload_field_info() {
 	pduel->write_buffer8(MSG_RELOAD_FIELD);
@@ -300,10 +280,10 @@ void field::move_card(uint8 playerid, card* pcard, uint8 location, uint8 sequenc
 				if (playerid == preplayer && sequence == presequence)
 					return;
 				if(location == LOCATION_MZONE) {
-					if(sequence >= player[playerid].list_mzone.size() || player[playerid].list_mzone[sequence])
+					if(sequence >= (int32)player[playerid].list_mzone.size() || player[playerid].list_mzone[sequence])
 						return;
 				} else {
-					if(sequence >= player[playerid].list_szone.size() || player[playerid].list_szone[sequence])
+					if(sequence >= player[playerid].szone_size || player[playerid].list_szone[sequence])
 						return;
 				}
 				if(preplayer == playerid) {
@@ -511,14 +491,14 @@ card* field::get_field_card(uint8 playerid, uint32 general_location, uint8 seque
 		return nullptr;
 	switch(general_location) {
 	case LOCATION_MZONE: {
-		if(sequence < player[playerid].list_mzone.size())
+		if(sequence < (int32)player[playerid].list_mzone.size())
 			return player[playerid].list_mzone[sequence];
 		else
 			return nullptr;
 		break;
 	}
 	case LOCATION_SZONE: {
-		if(sequence < player[playerid].list_szone.size())
+		if(sequence < player[playerid].szone_size)
 			return player[playerid].list_szone[sequence];
 		else
 			return nullptr;
@@ -585,7 +565,7 @@ int32 field::is_location_useable(uint8 playerid, uint32 general_location, uint8
 		return FALSE;
 	uint32 flag = player[playerid].disabled_location | player[playerid].used_location;
 	if (general_location == LOCATION_MZONE) {
-		if (sequence >= (int32)player[0].list_mzone.size())
+		if (sequence >= (int32)player[playerid].list_mzone.size())
 			return FALSE;
 		if(flag & (0x1u << sequence))
 			return FALSE;
@@ -595,7 +575,7 @@ int32 field::is_location_useable(uint8 playerid, uint32 general_location, uint8
 				return FALSE;
 		}
 	} else if (general_location == LOCATION_SZONE) {
-		if (sequence >= (int32)player[0].list_szone.size())
+		if (sequence >= player[playerid].szone_size)
 			return FALSE;
 		if(flag & (0x100u << sequence))
 			return FALSE;
@@ -1127,7 +1107,7 @@ void field::refresh_player_info(uint8 playerid) {
 		if (player[playerid].list_mzone[i])
 			used_flag |= 0x1U << i;
 	}
-	for (int32 i = 0; i < (int32)player[playerid].list_szone.size(); ++i) {
+	for (int32 i = 0; i < player[playerid].szone_size; ++i) {
 		if (player[playerid].list_szone[i])
 			used_flag |= 0x100U << i;
 	}
@@ -2293,6 +2273,9 @@ int32 field::check_spsummon_counter(uint8 playerid, uint8 ct) {
 	}
 	return TRUE;
 }
+bool field::is_select_hide_deck_sequence(uint8 playerid) {
+	return !core.select_deck_sequence_revealed && !(core.duel_options & DUEL_REVEAL_DECK_SEQ) && playerid == core.selecting_player;
+}
 int32 field::check_lp_cost(uint8 playerid, uint32 lp, uint32 must_pay) {
 	effect_set eset;
 	int32 val = lp;

field.h

@@ -80,13 +80,14 @@ struct chain {
 };
 
 struct player_info {
-	int32 lp{ 0 };
-	int32 start_count{ 0 };
-	int32 draw_count{ 0 };
+	int32 lp{ 8000 };
+	int32 start_count{ 5 };
+	int32 draw_count{ 1 };
 	uint32 used_location{ 0 };
 	uint32 disabled_location{ 0 };
 	uint32 extra_p_count{ 0 };
 	uint32 tag_extra_p_count{ 0 };
+	int32 szone_size{ 6 };
 	card_vector list_mzone;
 	card_vector list_szone;
 	card_vector list_main;
@@ -127,19 +128,19 @@ struct field_effect {
 	grant_effect_container grant_effect;
 };
 struct field_info {
-	int32 field_id{ 0 };
-	int16 copy_id{ 0 };
-	int16 turn_id{ 0 };
+	int32 field_id{ 1 };
+	int16 copy_id{ 1 };
+	int16 turn_id{};
 	int16 turn_id_by_player[2]{};
-	int16 card_id{ 0 };
-	uint16 phase{ 0 };
-	uint8 turn_player{ 0 };
+	int16 card_id{ 1 };
+	uint16 phase{};
+	uint8 turn_player{};
 	uint8 priorities[2]{};
 	uint8 can_shuffle{ TRUE };
 };
 struct lpcost {
-	int32 count{ 0 };
-	int32 amount{ 0 };
+	int32 count{};
+	int32 amount{};
 	int32 lpstack[8]{};
 };
 struct processor_unit {
@@ -306,7 +307,7 @@ struct processor {
 	uint8 extra_summon[2]{};
 	int32 spe_effect[2]{};
 	int32 last_select_hint[2]{ 0 };
-	int32 duel_options{ 0 };
+	uint32 duel_options{ 0 };
 	int32 duel_rule{ CURRENT_RULE };
 	uint32 copy_reset{ 0 };
 	int32 copy_reset_count{ 0 };
@@ -350,7 +351,7 @@ struct processor {
 	uint32 hint_timing[2]{};
 	uint8 current_player{ PLAYER_NONE };
 	uint8 conti_player{ PLAYER_NONE };
-	uint8 select_deck_seq_preserved{ FALSE };
+	uint8 select_deck_sequence_revealed{ FALSE };
 	uint8 selecting_player{ PLAYER_NONE };
 	std::unordered_map<uint32, std::pair<uint32, uint32>> summon_counter;
 	std::unordered_map<uint32, std::pair<uint32, uint32>> normalsummon_counter;
@@ -374,12 +375,12 @@ class field {
 
 	duel* pduel;
 	player_info player[2];
-	card* temp_card;
+	card* temp_card{};
 	field_info infos;
 	//lpcost cost[2];
 	field_effect effects;
 	processor core;
-	return_value returns;
+	return_value returns{};
 	tevent nil_event;
 
 	static int32 field_used_count[32];
@@ -463,6 +464,7 @@ class field {
 	void check_chain_counter(effect* peffect, int32 playerid, int32 chainid, bool cancel = false);
 	void set_spsummon_counter(uint8 playerid);
 	int32 check_spsummon_counter(uint8 playerid, uint8 ct = 1);
+	bool is_select_hide_deck_sequence(uint8 playerid);
 
 	int32 check_lp_cost(uint8 playerid, uint32 cost, uint32 must_pay);
 	void save_lp_cost() {}

libdebug.cpp

@@ -148,6 +148,10 @@ int32 scriptlib::debug_reload_field_begin(lua_State *L) {
 		pduel->game_field->core.duel_rule = 1;
 	else
 		pduel->game_field->core.duel_rule = CURRENT_RULE;
+	if (pduel->game_field->core.duel_rule == MASTER_RULE3) {
+		pduel->game_field->player[0].szone_size = 8;
+		pduel->game_field->player[1].szone_size = 8;
+	}
 	return 0;
 }
 int32 scriptlib::debug_reload_field_end(lua_State *L) {

libduel.cpp

@@ -1546,12 +1546,12 @@ int32 scriptlib::duel_disable_self_destroy_check(lua_State* L) {
 	pduel->game_field->core.selfdes_disabled = disable;
 	return 0;
 }
-int32 scriptlib::duel_preserve_select_deck_seq(lua_State* L) {
+int32 scriptlib::duel_reveal_select_deck_sequence(lua_State* L) {
 	duel* pduel = interpreter::get_duel_info(L);
-	uint8 preserve = TRUE;
+	uint8 reveal = TRUE;
 	if(lua_gettop(L) > 0)
-		preserve = lua_toboolean(L, 1);
-	pduel->game_field->core.select_deck_seq_preserved = preserve;
+		reveal = lua_toboolean(L, 1);
+	pduel->game_field->core.select_deck_sequence_revealed = reveal;
 	return 0;
 }
 int32 scriptlib::duel_shuffle_deck(lua_State *L) {
@@ -4876,7 +4876,7 @@ static const struct luaL_Reg duellib[] = {
 	{ "DiscardHand", scriptlib::duel_discard_hand },
 	{ "DisableShuffleCheck", scriptlib::duel_disable_shuffle_check },
 	{ "DisableSelfDestroyCheck", scriptlib::duel_disable_self_destroy_check },
-	{ "PreserveSelectDeckSequence", scriptlib::duel_preserve_select_deck_seq },
+	{ "RevealSelectDeckSequence", scriptlib::duel_reveal_select_deck_sequence },
 	{ "ShuffleDeck", scriptlib::duel_shuffle_deck },
 	{ "ShuffleExtra", scriptlib::duel_shuffle_extra },
 	{ "ShuffleHand", scriptlib::duel_shuffle_hand },

mtrandom.h

@@ -9,6 +9,8 @@
 #define MTRANDOM_H_
 
 #include <random>
+#include <vector>
+#include <utility>
 
 class mt19937 {
 public:

ocgapi.cpp

@@ -64,16 +64,20 @@ extern "C" DECL_DLLEXPORT intptr_t create_duel(uint_fast32_t seed) {
 	pduel->random.reset(seed);
 	return (intptr_t)pduel;
 }
-extern "C" DECL_DLLEXPORT void start_duel(intptr_t pduel, int32 options) {
+extern "C" DECL_DLLEXPORT void start_duel(intptr_t pduel, uint32 options) {
 	duel* pd = (duel*)pduel;
 	pd->game_field->core.duel_options |= options & 0xffff;
 	int32 duel_rule = options >> 16;
 	if(duel_rule)
 		pd->game_field->core.duel_rule = duel_rule;
 	else if(options & DUEL_OBSOLETE_RULING)		//provide backward compatibility with replay
 		pd->game_field->core.duel_rule = 1;
-	else if(!pd->game_field->core.duel_rule)
+	if (pd->game_field->core.duel_rule < 1 || pd->game_field->core.duel_rule > CURRENT_RULE)
 		pd->game_field->core.duel_rule = CURRENT_RULE;
+	if (pd->game_field->core.duel_rule == MASTER_RULE3) {
+		pd->game_field->player[0].szone_size = 8;
+		pd->game_field->player[1].szone_size = 8;
+	}
 	pd->game_field->core.shuffle_hand_check[0] = FALSE;
 	pd->game_field->core.shuffle_hand_check[1] = FALSE;
 	pd->game_field->core.shuffle_deck_check[0] = FALSE;

ocgapi.h

@@ -39,7 +39,7 @@ uint32 read_card(uint32 code, card_data* data);
 uint32 handle_message(void* pduel, uint32 message_type);
 
 extern "C" DECL_DLLEXPORT intptr_t create_duel(uint_fast32_t seed);
-extern "C" DECL_DLLEXPORT void start_duel(intptr_t pduel, int32 options);
+extern "C" DECL_DLLEXPORT void start_duel(intptr_t pduel, uint32 options);
 extern "C" DECL_DLLEXPORT void end_duel(intptr_t pduel);
 extern "C" DECL_DLLEXPORT void set_player_info(intptr_t pduel, int32 playerid, int32 lp, int32 startcount, int32 drawcount);
 extern "C" DECL_DLLEXPORT void get_log_message(intptr_t pduel, char* buf);

scriptlib.h

@@ -462,7 +462,7 @@ class scriptlib {
 	static int32 duel_discard_hand(lua_State *L);
 	static int32 duel_disable_shuffle_check(lua_State *L);
 	static int32 duel_disable_self_destroy_check(lua_State *L);
-	static int32 duel_preserve_select_deck_seq(lua_State *L);
+	static int32 duel_reveal_select_deck_sequence(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);