Merge branch 'master' into raw-video

gframe/CGUITTFont.cpp

@@ -527,29 +527,28 @@ void CGUITTFont::draw(const core::stringw& text, const core::rect<s32>& position
 	core::ustring::const_iterator iter(utext);
 	while (!iter.atEnd()) {
 		uchar32_t currentChar = *iter;
+
+		bool lineBreak = false;
+		if (currentChar == L'\r') { // Mac or Windows breaks
+			lineBreak = true;
+			if (*(iter + 1) == L'\n')	// Windows line breaks.
+				currentChar = *(++iter);
+		} else if (currentChar == L'\n') { // Unix breaks
+			lineBreak = true;
+		}
+		if (lineBreak) {
+			previousChar = 0;
+			offset.Y += supposed_line_height; //font_metrics.ascender / 64;
+			offset.X = position.UpperLeftCorner.X;
+			if (hcenter)
+				offset.X += (position.getWidth() - textDimension.Width) >> 1;
+			++iter;
+			continue;
+		}
+
 		n = getGlyphIndexByChar(currentChar);
 		bool visible = (Invisible.findFirst(currentChar) == -1);
 		if (n > 0 && visible) {
-			bool lineBreak = false;
-			if (currentChar == L'\r') { // Mac or Windows breaks
-				lineBreak = true;
-				if (*(iter + 1) == (uchar32_t)'\n')	// Windows line breaks.
-					currentChar = *(++iter);
-			} else if (currentChar == (uchar32_t)'\n') { // Unix breaks
-				lineBreak = true;
-			}
-
-			if (lineBreak) {
-				previousChar = 0;
-				offset.Y += supposed_line_height; //font_metrics.ascender / 64;
-				offset.X = position.UpperLeftCorner.X;
-
-				if (hcenter)
-					offset.X += (position.getWidth() - textDimension.Width) >> 1;
-				++iter;
-				continue;
-			}
-
 			// Calculate the glyph offset.
 			s32 offx = Glyphs[n - 1].offset.X;
 			s32 offy = (font_metrics.ascender / 64) - Glyphs[n - 1].offset.Y;

gframe/bufferio.h

 #ifndef BUFFERIO_H
 #define BUFFERIO_H
 
-#ifdef _MSC_VER
-#pragma warning(disable: 4244)
-#endif
+#include <cstdint>
+#include "../ocgcore/buffer.h"
 
 class BufferIO {
 public:
 	inline static int ReadInt32(unsigned char*& p) {
-		int ret = *(int*)p;
-		p += 4;
-		return ret;
+		return buffer_read<int32_t>(p);
 	}
 	inline static unsigned int ReadUInt32(unsigned char*& p) {
 		unsigned int ret = *(unsigned int*)p;
@@ -18,9 +15,7 @@ public:
 		return ret;
 	}
 	inline static short ReadInt16(unsigned char*& p) {
-		short ret = *(short*)p;
-		p += 2;
-		return ret;
+		return buffer_read<int16_t>(p);
 	}
 	inline static unsigned short ReadUInt16(unsigned char*& p) {
 		unsigned short ret = *(unsigned short*)p;
@@ -28,42 +23,36 @@ public:
 		return ret;
 	}
 	inline static char ReadInt8(unsigned char*& p) {
-		char ret = *(char*)p;
-		p++;
-		return ret;
+		return buffer_read<char>(p);
 	}
 	inline static unsigned char ReadUInt8(unsigned char*& p) {
-		unsigned char ret = *(unsigned char*)p;
-		p++;
-		return ret;
+		return buffer_read<unsigned char>(p);
 	}
 	inline static void WriteInt32(unsigned char*& p, int val) {
-		(*(int*)p) = val;
-		p += 4;
+		buffer_write<int32_t>(p, val);
 	}
 	inline static void WriteInt16(unsigned char*& p, short val) {
-		(*(short*)p) = val;
-		p += 2;
+		buffer_write<int16_t>(p, val);
 	}
 	inline static void WriteInt8(unsigned char*& p, char val) {
-		*p = val;
-		p++;
+		buffer_write<char>(p, val);
 	}
+	// return: string length
 	template<typename T1, typename T2>
-	inline static int CopyWStr(T1* src, T2* pstr, int bufsize) {
+	inline static int CopyWStr(const T1* src, T2* pstr, int bufsize) {
 		int l = 0;
 		while(src[l] && l < bufsize - 1) {
-			pstr[l] = src[l];
+			pstr[l] = (T2)src[l];
 			l++;
 		}
 		pstr[l] = 0;
 		return l;
 	}
 	template<typename T1, typename T2>
-	inline static int CopyWStrRef(T1* src, T2*& pstr, int bufsize) {
+	inline static int CopyWStrRef(const T1* src, T2*& pstr, int bufsize) {
 		int l = 0;
 		while(src[l] && l < bufsize - 1) {
-			pstr[l] = src[l];
+			pstr[l] = (T2)src[l];
 			l++;
 		}
 		pstr += l;
@@ -71,67 +60,93 @@ public:
 		return l;
 	}
 	// UTF-16/UTF-32 to UTF-8
-	static int EncodeUTF8(const wchar_t * wsrc, char * str) {
+	// return: string length
+	static int EncodeUTF8String(const wchar_t* wsrc, char* str, int size) {
 		char* pstr = str;
-		while(*wsrc != 0) {
-			if(*wsrc < 0x80) {
-				*str = *wsrc;
-				++str;
-			} else if(*wsrc < 0x800) {
-				str[0] = ((*wsrc >> 6) & 0x1f) | 0xc0;
-				str[1] = ((*wsrc) & 0x3f) | 0x80;
-				str += 2;
-			} else if(*wsrc < 0x10000 && (*wsrc < 0xd800 || *wsrc > 0xdfff)) {
-				str[0] = ((*wsrc >> 12) & 0xf) | 0xe0;
-				str[1] = ((*wsrc >> 6) & 0x3f) | 0x80;
-				str[2] = ((*wsrc) & 0x3f) | 0x80;
-				str += 3;
-			} else {
-#ifdef _WIN32
-				unsigned unicode = 0;
-				unicode |= (*wsrc++ & 0x3ff) << 10;
-				unicode |= *wsrc & 0x3ff;
-				unicode += 0x10000;
-				str[0] = ((unicode >> 18) & 0x7) | 0xf0;
-				str[1] = ((unicode >> 12) & 0x3f) | 0x80;
-				str[2] = ((unicode >> 6) & 0x3f) | 0x80;
-				str[3] = ((unicode) & 0x3f) | 0x80;
-#else
-				str[0] = ((*wsrc >> 18) & 0x7) | 0xf0;
-				str[1] = ((*wsrc >> 12) & 0x3f) | 0x80;
-				str[2] = ((*wsrc >> 6) & 0x3f) | 0x80;
-				str[3] = ((*wsrc) & 0x3f) | 0x80;
-#endif // _WIN32
-				str += 4;
+		while (*wsrc != 0) {
+			unsigned cur = *wsrc;
+			int codepoint_size = 0;
+			if (cur < 0x80U)
+				codepoint_size = 1;
+			else if (cur < 0x800U)
+				codepoint_size = 2;
+			else if (cur < 0x10000U && (cur < 0xd800U || cur > 0xdfffU))
+				codepoint_size = 3;
+			else
+				codepoint_size = 4;
+			if (pstr - str + codepoint_size > size - 1)
+				break;
+			switch (codepoint_size) {
+			case 1:
+				*pstr = (char)cur;
+				break;
+			case 2:
+				pstr[0] = ((cur >> 6) & 0x1f) | 0xc0;
+				pstr[1] = (cur & 0x3f) | 0x80;
+				break;
+			case 3:
+				pstr[0] = ((cur >> 12) & 0xf) | 0xe0;
+				pstr[1] = ((cur >> 6) & 0x3f) | 0x80;
+				pstr[2] = (cur & 0x3f) | 0x80;
+				break;
+			case 4:
+				if (sizeof(wchar_t) == 2) {
+					cur = 0;
+					cur |= ((unsigned)*wsrc & 0x3ff) << 10;
+					++wsrc;
+					cur |= (unsigned)*wsrc & 0x3ff;
+					cur += 0x10000;
+				}
+				pstr[0] = ((cur >> 18) & 0x7) | 0xf0;
+				pstr[1] = ((cur >> 12) & 0x3f) | 0x80;
+				pstr[2] = ((cur >> 6) & 0x3f) | 0x80;
+				pstr[3] = (cur & 0x3f) | 0x80;
+				break;
+			default:
+				break;
 			}
+			pstr += codepoint_size;
 			wsrc++;
 		}
-		*str = 0;
-		return str - pstr;
+		*pstr = 0;
+		return pstr - str;
 	}
 	// UTF-8 to UTF-16/UTF-32
-	static int DecodeUTF8(const char * src, wchar_t * wstr) {
+	// return: string length
+	static int DecodeUTF8String(const char* src, wchar_t* wstr, int size) {
 		const char* p = src;
 		wchar_t* wp = wstr;
 		while(*p != 0) {
-			if((*p & 0x80) == 0) {
+			const unsigned cur = (unsigned)*p & 0xff;
+			int codepoint_size = 0;
+			if ((cur & 0xf8) == 0xf0) {
+				if (sizeof(wchar_t) == 2)
+					codepoint_size = 2;
+				else
+					codepoint_size = 1;
+			}
+			else
+				codepoint_size = 1;
+			if (wp - wstr + codepoint_size > size - 1)
+				break;
+			if((cur & 0x80) == 0) {
 				*wp = *p;
 				p++;
-			} else if((*p & 0xe0) == 0xc0) {
+			} else if((cur & 0xe0) == 0xc0) {
 				*wp = (((unsigned)p[0] & 0x1f) << 6) | ((unsigned)p[1] & 0x3f);
 				p += 2;
-			} else if((*p & 0xf0) == 0xe0) {
+			} else if((cur & 0xf0) == 0xe0) {
 				*wp = (((unsigned)p[0] & 0xf) << 12) | (((unsigned)p[1] & 0x3f) << 6) | ((unsigned)p[2] & 0x3f);
 				p += 3;
-			} else if((*p & 0xf8) == 0xf0) {
-#ifdef _WIN32
-				unsigned unicode = (((unsigned)p[0] & 0x7) << 18) | (((unsigned)p[1] & 0x3f) << 12) | (((unsigned)p[2] & 0x3f) << 6) | ((unsigned)p[3] & 0x3f);
-				unicode -= 0x10000;
-				*wp++ = (unicode >> 10) | 0xd800;
-				*wp = (unicode & 0x3ff) | 0xdc00;
-#else
-				*wp = (((unsigned)p[0] & 0x7) << 18) | (((unsigned)p[1] & 0x3f) << 12) | (((unsigned)p[2] & 0x3f) << 6) | ((unsigned)p[3] & 0x3f);
-#endif // _WIN32
+			} else if((cur & 0xf8) == 0xf0) {
+				if (sizeof(wchar_t) == 2) {
+					unsigned unicode = (((unsigned)p[0] & 0x7) << 18) | (((unsigned)p[1] & 0x3f) << 12) | (((unsigned)p[2] & 0x3f) << 6) | ((unsigned)p[3] & 0x3f);
+					unicode -= 0x10000;
+					*wp++ = (unicode >> 10) | 0xd800;
+					*wp = (unicode & 0x3ff) | 0xdc00;
+				} else {
+					*wp = (((unsigned)p[0] & 0x7) << 18) | (((unsigned)p[1] & 0x3f) << 12) | (((unsigned)p[2] & 0x3f) << 6) | ((unsigned)p[3] & 0x3f);
+				}
 				p += 4;
 			} else
 				p++;
@@ -140,13 +155,23 @@ public:
 		*wp = 0;
 		return wp - wstr;
 	}
+	template<size_t N>
+	static int EncodeUTF8(const wchar_t* src, char(&dst)[N]) {
+		return EncodeUTF8String(src, dst, N);
+	}
+	template<size_t N>
+	static int DecodeUTF8(const char* src, wchar_t(&dst)[N]) {
+		return DecodeUTF8String(src, dst, N);
+	}
 	static int GetVal(const wchar_t* pstr) {
-		int ret = 0;
+		unsigned int ret = 0;
 		while(*pstr >= L'0' && *pstr <= L'9') {
 			ret = ret * 10 + (*pstr - L'0');
 			pstr++;
 		}
-		return ret;
+		if (*pstr == 0)
+			return (int)ret;
+		return 0;
 	}
 };
 

gframe/client_card.cpp

@@ -113,10 +113,10 @@ void ClientCard::UpdateInfo(unsigned char* buf) {
 	if(flag & QUERY_REASON_CARD)
 		buf += 4;
 	if(flag & QUERY_EQUIP_CARD) {
-		int c = BufferIO::ReadInt8(buf);
-		int l = BufferIO::ReadInt8(buf);
-		int s = BufferIO::ReadInt8(buf);
-		BufferIO::ReadInt8(buf);
+		int c = BufferIO::ReadUInt8(buf);
+		unsigned int l = BufferIO::ReadUInt8(buf);
+		int s = BufferIO::ReadUInt8(buf);
+		BufferIO::ReadUInt8(buf);
 		ClientCard* ecard = mainGame->dField.GetCard(mainGame->LocalPlayer(c), l, s);
 		if (ecard) {
 			equipTarget = ecard;
@@ -126,10 +126,10 @@ void ClientCard::UpdateInfo(unsigned char* buf) {
 	if(flag & QUERY_TARGET_CARD) {
 		int count = BufferIO::ReadInt32(buf);
 		for(int i = 0; i < count; ++i) {
-			int c = BufferIO::ReadInt8(buf);
-			int l = BufferIO::ReadInt8(buf);
-			int s = BufferIO::ReadInt8(buf);
-			BufferIO::ReadInt8(buf);
+			int c = BufferIO::ReadUInt8(buf);
+			unsigned int l = BufferIO::ReadUInt8(buf);
+			int s = BufferIO::ReadUInt8(buf);
+			BufferIO::ReadUInt8(buf);
 			ClientCard* tcard = mainGame->dField.GetCard(mainGame->LocalPlayer(c), l, s);
 			if (tcard) {
 				cardTarget.insert(tcard);

gframe/client_card.h

@@ -14,6 +14,14 @@ using CardData = card_data;
 struct CardDataC : card_data {
 	unsigned int ot{};
 	unsigned int category{};
+
+	bool is_setcodes(std::vector <uint32> values) const {
+		for (auto& value : values) {
+			if (is_setcode(value))
+				return true;
+		}
+		return false;
+	}
 };
 struct CardString {
 	std::wstring name;

gframe/client_field.cpp

@@ -120,6 +120,8 @@ void ClientField::Clear() {
 	conti_act = false;
 	deck_reversed = false;
 	cant_check_grave = false;
+	tag_surrender = false;
+	tag_teammate_surrender = false;
 	RefreshCardCountDisplay();
 }
 void ClientField::Initial(int player, int deckc, int extrac) {
@@ -197,7 +199,7 @@ void ClientField::AddCard(ClientCard* pcard, int controler, int location, int se
 	case LOCATION_DECK: {
 		if (sequence != 0 || deck[controler].size() == 0) {
 			deck[controler].push_back(pcard);
-			pcard->sequence = deck[controler].size() - 1;
+			pcard->sequence = (unsigned char)(deck[controler].size() - 1);
 		} else {
 			deck[controler].push_back(0);
 			for(int i = deck[controler].size() - 1; i > 0; --i) {
@@ -212,7 +214,7 @@ void ClientField::AddCard(ClientCard* pcard, int controler, int location, int se
 	}
 	case LOCATION_HAND: {
 		hand[controler].push_back(pcard);
-		pcard->sequence = hand[controler].size() - 1;
+		pcard->sequence = (unsigned char)(hand[controler].size() - 1);
 		break;
 	}
 	case LOCATION_MZONE: {
@@ -225,18 +227,18 @@ void ClientField::AddCard(ClientCard* pcard, int controler, int location, int se
 	}
 	case LOCATION_GRAVE: {
 		grave[controler].push_back(pcard);
-		pcard->sequence = grave[controler].size() - 1;
+		pcard->sequence = (unsigned char)(grave[controler].size() - 1);
 		break;
 	}
 	case LOCATION_REMOVED: {
 		remove[controler].push_back(pcard);
-		pcard->sequence = remove[controler].size() - 1;
+		pcard->sequence = (unsigned char)(remove[controler].size() - 1);
 		break;
 	}
 	case LOCATION_EXTRA: {
 		if(extra_p_count[controler] == 0 || (pcard->position & POS_FACEUP)) {
 			extra[controler].push_back(pcard);
-			pcard->sequence = extra[controler].size() - 1;
+			pcard->sequence = (unsigned char)(extra[controler].size() - 1);
 		} else {
 			extra[controler].push_back(0);
 			int p = extra[controler].size() - extra_p_count[controler] - 1;
@@ -691,8 +693,7 @@ void ClientField::ShowSelectOption(int select_hint) {
 		pos.LowerRightCorner.Y = pos.UpperLeftCorner.Y + newheight;
 		mainGame->wOptions->setRelativePosition(pos);
 	} else {
-		mainGame->SetStaticText(mainGame->stOptions, 310, mainGame->guiFont,
-			(wchar_t*)dataManager.GetDesc(select_options[0]));
+		mainGame->SetStaticText(mainGame->stOptions, 310, mainGame->guiFont, dataManager.GetDesc(select_options[0]));
 		mainGame->stOptions->setVisible(true);
 		mainGame->btnOptionp->setVisible(false);
 		mainGame->btnOptionn->setVisible(count > 1);
@@ -1075,21 +1076,22 @@ void ClientField::GetCardLocation(ClientCard* pcard, irr::core::vector3df* t, ir
 		break;
 	}
 	case LOCATION_OVERLAY: {
-		if (pcard->overlayTarget->location != LOCATION_MZONE) {
+		if (!(pcard->overlayTarget->location & LOCATION_ONFIELD)) {
 			return;
 		}
 		int oseq = pcard->overlayTarget->sequence;
 		int mseq = (sequence < MAX_LAYER_COUNT) ? sequence : (MAX_LAYER_COUNT - 1);
+		auto vFieldZone = (pcard->overlayTarget->location == LOCATION_MZONE) ? matManager.vFieldMzone[pcard->overlayTarget->controler][oseq] : matManager.vFieldSzone[pcard->overlayTarget->controler][oseq][rule];
 		if (pcard->overlayTarget->controler == 0) {
-			t->X = (matManager.vFieldMzone[0][oseq][0].Pos.X + matManager.vFieldMzone[0][oseq][1].Pos.X) / 2 - 0.12f + 0.06f * mseq;
-			t->Y = (matManager.vFieldMzone[0][oseq][0].Pos.Y + matManager.vFieldMzone[0][oseq][2].Pos.Y) / 2 + 0.05f;
+			t->X = (vFieldZone[0].Pos.X + vFieldZone[1].Pos.X) / 2 - 0.12f + 0.06f * mseq;
+			t->Y = (vFieldZone[0].Pos.Y + vFieldZone[2].Pos.Y) / 2 + 0.05f;
 			t->Z = overlay_buttom + mseq * material_height;
 			r->X = 0.0f;
 			r->Y = 0.0f;
 			r->Z = 0.0f;
 		} else {
-			t->X = (matManager.vFieldMzone[1][oseq][0].Pos.X + matManager.vFieldMzone[1][oseq][1].Pos.X) / 2 + 0.12f - 0.06f * mseq;
-			t->Y = (matManager.vFieldMzone[1][oseq][0].Pos.Y + matManager.vFieldMzone[1][oseq][2].Pos.Y) / 2 - 0.05f;
+			t->X = (vFieldZone[0].Pos.X + vFieldZone[1].Pos.X) / 2 + 0.12f - 0.06f * mseq;
+			t->Y = (vFieldZone[0].Pos.Y + vFieldZone[2].Pos.Y) / 2 - 0.05f;
 			t->Z = overlay_buttom + mseq * material_height;
 			r->X = 0.0f;
 			r->Y = 0.0f;

gframe/client_field.h

@@ -87,6 +87,8 @@ public:
 	bool deck_reversed{ false };
 	bool conti_selecting{ false };
 	bool cant_check_grave{ false };
+	bool tag_surrender{ false };
+	bool tag_teammate_surrender{ false };
 	mt19937 rnd;
 
 	ClientField();

gframe/config.h

@@ -86,10 +86,8 @@ using namespace video;
 using namespace io;
 using namespace gui;
 
-typedef int BOOL;
-
 extern unsigned short PRO_VERSION;
-extern int enable_log;
+extern unsigned int enable_log;
 extern bool exit_on_return;
 extern bool auto_watch_mode;
 extern bool auto_record_mode;

gframe/data_manager.cpp

@@ -61,7 +61,7 @@ bool DataManager::LoadDB(const wchar_t* wfile) {
 					if (len > SIZE_SETCODE)
 						len = SIZE_SETCODE;
 					if (len)
-						memcpy(cd.setcode, it->second.data(), len * sizeof(uint16_t));
+						std::memcpy(cd.setcode, it->second.data(), len * sizeof(uint16_t));
 				}
 				else
 					cd.set_setcode(setcode);
@@ -139,24 +139,30 @@ bool DataManager::LoadStrings(IReadFile* reader) {
 void DataManager::ReadStringConfLine(const char* linebuf) {
 	if(linebuf[0] != '!')
 		return;
-	char strbuf[256];
-	int value;
-	wchar_t strBuffer[4096];
-	sscanf(linebuf, "!%s", strbuf);
+	char strbuf[256]{};
+	int value{};
+	wchar_t strBuffer[4096]{};
+	if (sscanf(linebuf, "!%63s", strbuf) != 1)
+		return;
 	if(!strcmp(strbuf, "system")) {
-		sscanf(&linebuf[7], "%d %240[^\n]", &value, strbuf);
+		if (sscanf(&linebuf[7], "%d %240[^\n]", &value, strbuf) != 2)
+			return;
 		BufferIO::DecodeUTF8(strbuf, strBuffer);
 		_sysStrings[value] = strBuffer;
 	} else if(!strcmp(strbuf, "victory")) {
-		sscanf(&linebuf[8], "%x %240[^\n]", &value, strbuf);
+		if (sscanf(&linebuf[8], "%x %240[^\n]", &value, strbuf) != 2)
+			return;
 		BufferIO::DecodeUTF8(strbuf, strBuffer);
 		_victoryStrings[value] = strBuffer;
 	} else if(!strcmp(strbuf, "counter")) {
-		sscanf(&linebuf[8], "%x %240[^\n]", &value, strbuf);
+		if (sscanf(&linebuf[8], "%x %240[^\n]", &value, strbuf) != 2)
+			return;
 		BufferIO::DecodeUTF8(strbuf, strBuffer);
 		_counterStrings[value] = strBuffer;
 	} else if(!strcmp(strbuf, "setname")) {
-		sscanf(&linebuf[8], "%x %240[^\t\n]", &value, strbuf);//using tab for comment
+		//using tab for comment
+		if (sscanf(&linebuf[8], "%x %240[^\t\n]", &value, strbuf) != 2)
+			return;
 		BufferIO::DecodeUTF8(strbuf, strBuffer);
 		_setnameStrings[value] = strBuffer;
 	}
@@ -178,7 +184,7 @@ bool DataManager::GetData(unsigned int code, CardData* pData) {
 	if (pData) {
 		pData->code = data.code;
 		pData->alias = data.alias;
-		memcpy(pData->setcode, data.setcode, SIZE_SETCODE);
+		std::memcpy(pData->setcode, data.setcode, SIZE_SETCODE);
 		pData->type = data.type;
 		pData->level = data.level;
 		pData->attribute = data.attribute;
@@ -197,7 +203,7 @@ code_pointer DataManager::GetCodePointer(unsigned int code) const {
 string_pointer DataManager::GetStringPointer(unsigned int code) const {
 	return _strings.find(code);
 }
-bool DataManager::GetString(int code, CardString* pStr) {
+bool DataManager::GetString(unsigned int code, CardString* pStr) {
 	auto csit = _strings.find(code);
 	if(csit == _strings.end()) {
 		pStr->name = unknown_string;
@@ -207,7 +213,7 @@ bool DataManager::GetString(int code, CardString* pStr) {
 	*pStr = csit->second;
 	return true;
 }
-const wchar_t* DataManager::GetName(int code) {
+const wchar_t* DataManager::GetName(unsigned int code) {
 	auto csit = _strings.find(code);
 	if(csit == _strings.end())
 		return unknown_string;
@@ -215,7 +221,7 @@ const wchar_t* DataManager::GetName(int code) {
 		return csit->second.name.c_str();
 	return unknown_string;
 }
-const wchar_t* DataManager::GetText(int code) {
+const wchar_t* DataManager::GetText(unsigned int code) {
 	auto csit = _strings.find(code);
 	if(csit == _strings.end())
 		return unknown_string;
@@ -224,7 +230,7 @@ const wchar_t* DataManager::GetText(int code) {
 	return unknown_string;
 }
 const wchar_t* DataManager::GetDesc(unsigned int strCode) {
-	if(strCode < 10000u)
+	if (strCode < (MIN_CARD_ID << 4))
 		return GetSysString(strCode);
 	unsigned int code = (strCode >> 4) & 0x0fffffff;
 	unsigned int offset = strCode & 0xf;
@@ -236,7 +242,7 @@ const wchar_t* DataManager::GetDesc(unsigned int strCode) {
 	return unknown_string;
 }
 const wchar_t* DataManager::GetSysString(int code) {
-	if(code < 0 || code >= 2048)
+	if (code < 0 || code > MAX_STRING_ID)
 		return unknown_string;
 	auto csit = _sysStrings.find(code);
 	if(csit == _sysStrings.end())
@@ -261,13 +267,25 @@ const wchar_t* DataManager::GetSetName(int code) {
 		return NULL;
 	return csit->second.c_str();
 }
-unsigned int DataManager::GetSetCode(const wchar_t* setname) {
+std::vector<unsigned int> DataManager::GetSetCodes(std::wstring setname) {
+	std::vector<unsigned int> matchingCodes;
 	for(auto csit = _setnameStrings.begin(); csit != _setnameStrings.end(); ++csit) {
 		auto xpos = csit->second.find_first_of(L'|');//setname|another setname or extra info
-		if(csit->second.compare(0, xpos, setname) == 0 || csit->second.compare(xpos + 1, csit->second.length(), setname) == 0 || mainGame->CheckRegEx(csit->second, setname, true))
-			return csit->first;
+		if (mainGame->CheckRegEx(csit->second, setname, true)) {
+			matchingCodes.push_back(csit->first);
+		}
+		else if(setname.size() < 2) {
+			if(csit->second.compare(0, xpos, setname) == 0
+				|| csit->second.compare(xpos + 1, csit->second.length(), setname) == 0)
+				matchingCodes.push_back(csit->first);
+		} else {
+			if(csit->second.substr(0, xpos).find(setname) != std::wstring::npos
+				|| csit->second.substr(xpos + 1).find(setname) != std::wstring::npos) {
+				matchingCodes.push_back(csit->first);
+			}
+		}
 	}
-	return 0;
+	return matchingCodes;
 }
 const wchar_t* DataManager::GetNumString(int num, bool bracket) {
 	if(!bracket)
@@ -409,12 +427,12 @@ byte* DataManager::ScriptReaderEx(const char* script_name, int* slen) {
 }
 byte* DataManager::ScriptReaderExSingle(const char* path, const char* script_name, int* slen, int pre_len) {
 	char sname[256];
-	sprintf(sname, "%s%s", path, script_name + pre_len); //default script name: ./script/c%d.lua
+	snprintf(sname, sizeof sname, "%s%s", path, script_name + pre_len); //default script name: ./script/c%d.lua
 	return ScriptReader(sname, slen);
 }
 byte* DataManager::ScriptReader(const char* script_name, int* slen) {
 #ifdef _WIN32
-	wchar_t fname[256];
+	wchar_t fname[256]{};
 	BufferIO::DecodeUTF8(script_name, fname);
 	IReadFile* reader = FileSystem->createAndOpenFile(fname);
 #else

gframe/data_manager.h

@@ -8,6 +8,8 @@
 #include <unordered_map>
 
 namespace ygo {
+	constexpr int MAX_STRING_ID = 0x7ff;
+	constexpr unsigned int MIN_CARD_ID = (unsigned int)(MAX_STRING_ID + 1) >> 4;
 
 class DataManager {
 public:
@@ -20,15 +22,15 @@ public:
 	bool GetData(unsigned int code, CardData* pData);
 	code_pointer GetCodePointer(unsigned int code) const;
 	string_pointer GetStringPointer(unsigned int code) const;
-	bool GetString(int code, CardString* pStr);
-	const wchar_t* GetName(int code);
-	const wchar_t* GetText(int code);
+	bool GetString(unsigned int code, CardString* pStr);
+	const wchar_t* GetName(unsigned int code);
+	const wchar_t* GetText(unsigned int code);
 	const wchar_t* GetDesc(unsigned int strCode);
 	const wchar_t* GetSysString(int code);
 	const wchar_t* GetVictoryString(int code);
 	const wchar_t* GetCounterName(int code);
 	const wchar_t* GetSetName(int code);
-	unsigned int GetSetCode(const wchar_t* setname);
+	std::vector<unsigned int> GetSetCodes(std::wstring setname);
 	const wchar_t* GetNumString(int num, bool bracket = false);
 	const wchar_t* FormatLocation(int location, int sequence);
 	const wchar_t* FormatAttribute(int attribute);

gframe/deck_con.cpp

@@ -94,6 +94,7 @@ void DeckBuilder::Terminate() {
 	mainGame->btnBigCardZoomIn->setVisible(false);
 	mainGame->btnBigCardZoomOut->setVisible(false);
 	mainGame->btnBigCardClose->setVisible(false);
+	mainGame->ResizeChatInputWindow();
 	mainGame->PopupElement(mainGame->wMainMenu);
 	mainGame->device->setEventReceiver(&mainGame->menuHandler);
 	mainGame->wACMessage->setVisible(false);
@@ -232,9 +233,11 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				mainGame->HideElement(mainGame->wDeckCode);
 				if(prev_operation == BUTTON_DECK_CODE) {
 					Deck new_deck;
+					char pcode[1024];
+					BufferIO::EncodeUTF8(mainGame->ebDeckCode->getText(), pcode);
 					unsigned char deck_code[1024];
-					BufferIO::EncodeUTF8(mainGame->ebDeckCode->getText(), (char*)deck_code);
-					if(deckManager.LoadDeckFromCode(new_deck, deck_code, strlen((char*)deck_code)))
+					memcpy(deck_code, pcode, 1024);
+					if(deckManager.LoadDeckFromCode(new_deck, deck_code, strlen(pcode)))
 						deckManager.current_deck = new_deck;
 					else
 						mainGame->env->addMessageBox(L"", dataManager.GetSysString(1389));
@@ -1289,7 +1292,7 @@ void DeckBuilder::GetHoveredCard() {
 		} else if(y >= 164 && y <= 435) {
 			int lx = 10, px, py = (y - 164) / 68;
 			hovered_pos = 1;
-			if(deckManager.current_deck.main.size() > 40)
+			if(deckManager.current_deck.main.size() > DECK_MIN_SIZE)
 				lx = (deckManager.current_deck.main.size() - 41) / 4 + 11;
 			if(x >= 750)
 				px = lx - 1;
@@ -1377,14 +1380,14 @@ void DeckBuilder::FilterCards() {
 	results.clear();
 	struct element_t {
 		std::wstring keyword;
-		unsigned int setcode;
+		std::vector<unsigned int> setcodes;
 		enum class type_t {
 			all,
 			name,
 			setcode
 		} type;
 		bool exclude;
-		element_t(): setcode(0), type(type_t::all), exclude(false) {}
+		element_t(): type(type_t::all), exclude(false) {}
 	};
 	const wchar_t* pstr = mainGame->ebCardName->getText();
 	std::wstring str = std::wstring(pstr);
@@ -1425,7 +1428,7 @@ void DeckBuilder::FilterCards() {
 				element.keyword = str.substr(element_start, length);
 			} else
 				element.keyword = str.substr(element_start);
-			element.setcode = dataManager.GetSetCode(element.keyword.c_str());
+			element.setcodes = dataManager.GetSetCodes(element.keyword);
 			query_elements.push_back(element);
 			if(element_end == std::wstring::npos)
 				break;
@@ -1443,7 +1446,7 @@ void DeckBuilder::FilterCards() {
 		}
 		if(element_start < str.size()) {
 			element.keyword = str.substr(element_start);
-			element.setcode = dataManager.GetSetCode(element.keyword.c_str());
+			element.setcodes = dataManager.GetSetCodes(element.keyword);
 			query_elements.push_back(element);
 		}
 	}
@@ -1530,7 +1533,7 @@ void DeckBuilder::FilterCards() {
 			if (elements_iterator->type == element_t::type_t::name) {
 				match = CardNameContains(text.name.c_str(), elements_iterator->keyword.c_str());
 			} else if (elements_iterator->type == element_t::type_t::setcode) {
-				match = elements_iterator->setcode && data.is_setcode(elements_iterator->setcode);
+				match = data.is_setcodes(elements_iterator->setcodes);
 			} else {
 				int trycode = BufferIO::GetVal(elements_iterator->keyword.c_str());
 				bool tryresult = dataManager.GetData(trycode, 0);
@@ -1538,7 +1541,7 @@ void DeckBuilder::FilterCards() {
 					match = CardNameContains(text.name.c_str(), elements_iterator->keyword.c_str())
 						|| text.text.find(elements_iterator->keyword) != std::wstring::npos
 						|| mainGame->CheckRegEx(text.text, elements_iterator->keyword)
-						|| (elements_iterator->setcode && data.is_setcode(elements_iterator->setcode));
+						|| data.is_setcodes(elements_iterator->setcodes);
 				} else {
 					match = data.code == trycode || data.alias == trycode;
 				}
@@ -1800,7 +1803,7 @@ bool DeckBuilder::push_main(code_pointer pointer, int seq) {
 	if(pointer->second.type & (TYPE_FUSION | TYPE_SYNCHRO | TYPE_XYZ | TYPE_LINK))
 		return false;
 	auto& container = deckManager.current_deck.main;
-	int maxc = mainGame->is_siding ? YGOPRO_MAX_DECK + 5 : YGOPRO_MAX_DECK;
+	int maxc = mainGame->is_siding ? DECK_MAX_SIZE + 4 : DECK_MAX_SIZE;
 	if((int)container.size() >= maxc)
 		return false;
 	if(seq >= 0 && seq < (int)container.size())
@@ -1815,7 +1818,7 @@ bool DeckBuilder::push_extra(code_pointer pointer, int seq) {
 	if(!(pointer->second.type & (TYPE_FUSION | TYPE_SYNCHRO | TYPE_XYZ | TYPE_LINK)))
 		return false;
 	auto& container = deckManager.current_deck.extra;
-	int maxc = mainGame->is_siding ? YGOPRO_MAX_EXTRA + 5 : YGOPRO_MAX_EXTRA;
+	int maxc = mainGame->is_siding ? EXTRA_MAX_SIZE + 5 : EXTRA_MAX_SIZE;
 	if((int)container.size() >= maxc)
 		return false;
 	if(seq >= 0 && seq < (int)container.size())
@@ -1828,7 +1831,7 @@ bool DeckBuilder::push_extra(code_pointer pointer, int seq) {
 }
 bool DeckBuilder::push_side(code_pointer pointer, int seq) {
 	auto& container = deckManager.current_deck.side;
-	int maxc = mainGame->is_siding ? YGOPRO_MAX_SIDE + 5 : YGOPRO_MAX_SIDE;
+	int maxc = mainGame->is_siding ? SIDE_MAX_SIZE + 5 : SIDE_MAX_SIZE;
 	if((int)container.size() >= maxc)
 		return false;
 	if(seq >= 0 && seq < (int)container.size())

gframe/deck_con.h

@@ -41,49 +41,49 @@ public:
 	void pop_side(int seq);
 	bool check_limit(code_pointer pointer);
 
-	long long filter_effect;
-	unsigned int filter_type;
-	unsigned int filter_type2;
-	unsigned int filter_attrib;
-	unsigned int filter_race;
-	unsigned int filter_atktype;
-	int filter_atk;
-	unsigned int filter_deftype;
-	int filter_def;
-	unsigned int filter_lvtype;
-	unsigned int filter_lv;
-	unsigned int filter_scltype;
-	unsigned int filter_scl;
-	unsigned int filter_marks;
-	int filter_lm;
+	long long filter_effect{};
+	unsigned int filter_type{};
+	unsigned int filter_type2{};
+	unsigned int filter_attrib{};
+	unsigned int filter_race{};
+	unsigned int filter_atktype{};
+	int filter_atk{};
+	unsigned int filter_deftype{};
+	int filter_def{};
+	unsigned int filter_lvtype{};
+	unsigned int filter_lv{};
+	unsigned int filter_scltype{};
+	unsigned int filter_scl{};
+	unsigned int filter_marks{};
+	int filter_lm{};
 	position2di mouse_pos;
-	int hovered_code;
-	int hovered_pos;
-	int hovered_seq;
-	int is_lastcard;
-	int click_pos;
-	bool is_draging;
-	bool is_starting_dragging;
-	int dragx;
-	int dragy;
-	int bigcard_code;
-	float bigcard_zoom;
-	size_t pre_mainc;
-	size_t pre_extrac;
-	size_t pre_sidec;
+	int hovered_code{};
+	int hovered_pos{};
+	int hovered_seq{ -1 };
+	int is_lastcard{};
+	int click_pos{};
+	bool is_draging{};
+	bool is_starting_dragging{};
+	int dragx{};
+	int dragy{};
+	int bigcard_code{};
+	float bigcard_zoom{};
+	size_t pre_mainc{};
+	size_t pre_extrac{};
+	size_t pre_sidec{};
 	code_pointer draging_pointer;
-	int prev_category;
-	int prev_deck;
-	s32 prev_operation;
-	int prev_sel;
-	bool is_modified;
-	bool readonly;
-	bool showing_pack;
+	int prev_category{};
+	int prev_deck{};
+	s32 prev_operation{};
+	int prev_sel{ -1 };
+	bool is_modified{};
+	bool readonly{};
+	bool showing_pack{};
 	mt19937 rnd;
 
 	const std::unordered_map<int, int>* filterList;
 	std::vector<code_pointer> results;
-	wchar_t result_string[8];
+	wchar_t result_string[8]{};
 	std::vector<std::wstring> expansionPacks;
 };
 

gframe/deck_manager.cpp

@@ -6,21 +6,22 @@
 
 namespace ygo {
 
-char DeckManager::deckBuffer[0x10000];
+char DeckManager::deckBuffer[0x10000]{};
 DeckManager deckManager;
 
 void DeckManager::LoadLFListSingle(const char* path) {
 	LFList* cur = nullptr;
 	FILE* fp = fopen(path, "r");
-	char linebuf[256];
-	wchar_t strBuffer[256];
+	char linebuf[256]{};
+	wchar_t strBuffer[256]{};
 	if(fp) {
 		while(fgets(linebuf, 256, fp)) {
 			if(linebuf[0] == '#')
 				continue;
 			if(linebuf[0] == '!') {
 				int sa = BufferIO::DecodeUTF8(&linebuf[1], strBuffer);
-				while(strBuffer[sa - 1] == L'\r' || strBuffer[sa - 1] == L'\n' ) sa--;
+				while(strBuffer[sa - 1] == L'\r' || strBuffer[sa - 1] == L'\n' )
+					sa--;
 				strBuffer[sa] = 0;
 				LFList newlist;
 				_lfList.push_back(newlist);
@@ -29,20 +30,18 @@ void DeckManager::LoadLFListSingle(const char* path) {
 				cur->hash = 0x7dfcee6a;
 				continue;
 			}
-			int p = 0;
-			while(linebuf[p] != ' ' && linebuf[p] != '\t' && linebuf[p] != 0) p++;
-			if(linebuf[p] == 0)
+			if(linebuf[0] == 0)
 				continue;
-			linebuf[p++] = 0;
-			int sa = p;
-			int code = atoi(linebuf);
-			if(code == 0)
+			int code = 0;
+			int count = -1;
+			if (sscanf(linebuf, "%d %d", &code, &count) != 2)
+				continue;
+			if (code <= 0 || code > 0xfffffff)
+				continue;
+			if (count < 0 || count > 2)
+				continue;
+			if (!cur)
 				continue;
-			while(linebuf[p] == ' ' || linebuf[p] == '\t') p++;
-			while(linebuf[p] != ' ' && linebuf[p] != '\t' && linebuf[p] != 0) p++;
-			linebuf[p] = 0;
-			int count = atoi(&linebuf[sa]);
-			if(!cur) continue;
 			cur->content[code] = count;
 			cur->hash = cur->hash ^ ((code << 18) | (code >> 14)) ^ ((code << (27 + count)) | (code >> (5 - count)));
 		}
@@ -90,11 +89,11 @@ int DeckManager::CheckDeck(Deck& deck, int lfhash, int rule) {
 	if(!list)
 		return 0;
 	int dc = 0;
-	if(deck.main.size() < YGOPRO_MIN_DECK || deck.main.size() > YGOPRO_MAX_DECK)
+	if(deck.main.size() < DECK_MIN_SIZE || deck.main.size() > DECK_MAX_SIZE)
 		return (DECKERROR_MAINCOUNT << 28) + deck.main.size();
-	if(deck.extra.size() > YGOPRO_MAX_EXTRA)
+	if(deck.extra.size() > EXTRA_MAX_SIZE)
 		return (DECKERROR_EXTRACOUNT << 28) + deck.extra.size();
-	if(deck.side.size() > YGOPRO_MAX_SIDE)
+	if(deck.side.size() > SIDE_MAX_SIZE)
 		return (DECKERROR_SIDECOUNT << 28) + deck.side.size();
 	const int rule_map[6] = { AVAIL_OCG, AVAIL_TCG, AVAIL_SC, AVAIL_CUSTOM, AVAIL_OCGTCG, 0 };
 	int avail = rule_map[rule];
@@ -162,10 +161,10 @@ int DeckManager::LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec, bool is_p
 			continue;
 		}
 		else if(cd.type & (TYPE_FUSION | TYPE_SYNCHRO | TYPE_XYZ | TYPE_LINK)) {
-			if(deck.extra.size() >= YGOPRO_MAX_EXTRA)
+			if(deck.extra.size() >= EXTRA_MAX_SIZE)
 				continue;
 			deck.extra.push_back(dataManager.GetCodePointer(code));
-		} else if(deck.main.size() < YGOPRO_MAX_DECK) {
+		} else if(deck.main.size() < DECK_MAX_SIZE) {
 			deck.main.push_back(dataManager.GetCodePointer(code));
 		}
 	}
@@ -233,7 +232,7 @@ void DeckManager::GetCategoryPath(wchar_t* ret, int index, const wchar_t* text)
 void DeckManager::GetDeckFile(wchar_t* ret, irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck) {
 	wchar_t filepath[256];
 	wchar_t catepath[256];
-	wchar_t* deckname = (wchar_t*)cbDeck->getItem(cbDeck->getSelected());
+	const wchar_t* deckname = cbDeck->getItem(cbDeck->getSelected());
 	if(deckname != NULL) {
 		GetCategoryPath(catepath, cbCategory->getSelected(), cbCategory->getText());
 		myswprintf(filepath, L"%ls/%ls.ydk", catepath, deckname);
@@ -254,7 +253,9 @@ bool DeckManager::LoadDeck(irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUICom
 }
 FILE* DeckManager::OpenDeckFile(const wchar_t* file, const char* mode) {
 #ifdef WIN32
-	FILE* fp = _wfopen(file, (wchar_t*)mode);
+	wchar_t wmode[20]{};
+	BufferIO::CopyWStr(mode, wmode, sizeof(wmode) / sizeof(wchar_t));
+	FILE* fp = _wfopen(file, wmode);
 #else
 	char file2[256];
 	BufferIO::EncodeUTF8(file, file2);

gframe/deck_manager.h

@@ -7,10 +7,30 @@
 #include <vector>
 #include <sstream>
 
+#ifndef YGOPRO_MAX_DECK
+#define YGOPRO_MAX_DECK					60
+#endif
+
+#ifndef YGOPRO_MIN_DECK
+#define YGOPRO_MIN_DECK					40
+#endif
+
+#ifndef YGOPRO_MAX_EXTRA
+#define YGOPRO_MAX_EXTRA					15
+#endif
+
+#ifndef YGOPRO_MAX_SIDE
+#define YGOPRO_MAX_SIDE					15
+#endif
+
 namespace ygo {
+	constexpr int DECK_MAX_SIZE = YGOPRO_MAX_DECK;
+	constexpr int DECK_MIN_SIZE = YGOPRO_MIN_DECK;
+	constexpr int EXTRA_MAX_SIZE = YGOPRO_MAX_EXTRA;
+	constexpr int SIDE_MAX_SIZE = YGOPRO_MAX_SIDE;
 
 struct LFList {
-	unsigned int hash;
+	unsigned int hash{};
 	std::wstring listName;
 	std::unordered_map<int, int> content;
 };

gframe/drawing.cpp

@@ -18,10 +18,10 @@ void Game::DrawSelectionLine(irr::video::S3DVertex* vec, bool strip, int width,
 		glDisable(GL_TEXTURE_2D);
 		glMaterialfv(GL_FRONT, GL_AMBIENT, cv);
 		glBegin(GL_LINE_LOOP);
-		glVertex3fv((float*)&vec[0].Pos);
-		glVertex3fv((float*)&vec[1].Pos);
-		glVertex3fv((float*)&vec[3].Pos);
-		glVertex3fv((float*)&vec[2].Pos);
+		glVertex3fv(&vec[0].Pos.X);
+		glVertex3fv(&vec[1].Pos.X);
+		glVertex3fv(&vec[3].Pos.X);
+		glVertex3fv(&vec[2].Pos.X);
 		glEnd();
 		glMaterialfv(GL_FRONT, GL_AMBIENT, origin);
 		glDisable(GL_LINE_STIPPLE);
@@ -559,6 +559,8 @@ void Game::DrawMisc() {
 	//finish button
 	if(btnCancelOrFinish->isVisible() && dField.select_ready)
 		DrawSelectionLine(btnCancelOrFinish, 2, 0xffffff00);
+	if(btnLeaveGame->isVisible() && dField.tag_teammate_surrender)
+		DrawSelectionLine(btnLeaveGame, 2, 0xffffff00);
 	//lp bar
 	if((dInfo.turn % 2 && dInfo.isFirst && !dInfo.is_swapped) || (!(dInfo.turn % 2) && !dInfo.isFirst && !dInfo.is_swapped) || (!(dInfo.turn % 2) && dInfo.isFirst && dInfo.is_swapped) || (dInfo.turn % 2 && !dInfo.isFirst && dInfo.is_swapped)) {
 		driver->draw2DRectangle(0xa0000000, Resize(327, 8, 630, 51));
@@ -1065,26 +1067,40 @@ void Game::DrawSpec() {
 	    showChat = false;
 	    hideChatTimer--;
 	}
+	int chatRectY = 0;
 	for(int i = 0; i < 8; ++i) {
 		static unsigned int chatColor[] = {0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xff8080ff, 0xffff4040, 0xffff4040,
 		                                   0xffff4040, 0xff40ff40, 0xff4040ff, 0xff40ffff, 0xffff40ff, 0xffffff40, 0xffffffff, 0xff808080, 0xff404040};
 		if(chatTiming[i]) {
 			chatTiming[i]--;
-			if(mainGame->dInfo.isStarted && i >= 5)
-				continue;
-			if(!showChat && i > 2)
-				continue;
-			int w = guiFont->getDimension(chatMsg[i].c_str()).Width;
+			if(!is_building) {
+				if(dInfo.isStarted && i >= 5)
+					continue;
+				if(!showChat && i > 2)
+					continue;
+			}
+
+			int x = wChat->getRelativePosition().UpperLeftCorner.X;
+			int y = window_size.Height - 25;
+			int maxwidth = 705 * xScale;
+			if(is_building) {
+				x = 810 * xScale;
+				maxwidth = 205 * xScale;
+			}
+
+			std::wstring msg = SetStaticText(nullptr, maxwidth, guiFont, chatMsg[i].c_str());
+			int w = guiFont->getDimension(msg).Width;
+			int h = guiFont->getDimension(msg).Height + 2;
 
-			recti rectloc(mainGame->wChat->getRelativePosition().UpperLeftCorner.X, mainGame->window_size.Height - 45, mainGame->wChat->getRelativePosition().UpperLeftCorner.X + 2 + w, mainGame->window_size.Height - 25);
-			rectloc -= position2di(0, i * 20);
-			recti msgloc(mainGame->wChat->getRelativePosition().UpperLeftCorner.X, mainGame->window_size.Height - 45, mainGame->wChat->getRelativePosition().UpperLeftCorner.X - 4, mainGame->window_size.Height - 25);
-			msgloc -= position2di(0, i * 20);
+			recti rectloc(x, y - chatRectY - h, x + 2 + w, y - chatRectY);
+			recti msgloc(x, y - chatRectY - h, x - 4, y - chatRectY);
 			recti shadowloc = msgloc + position2di(1, 1);
 
 			driver->draw2DRectangle(rectloc, 0xa0000000, 0xa0000000, 0xa0000000, 0xa0000000);
-			guiFont->draw(chatMsg[i].c_str(), msgloc, 0xff000000, false, false);
-			guiFont->draw(chatMsg[i].c_str(), shadowloc, chatColor[chatType[i]], false, false);
+			guiFont->draw(msg.c_str(), msgloc, 0xff000000, false, false);
+			guiFont->draw(msg.c_str(), shadowloc, chatColor[chatType[i]], false, false);
+
+			chatRectY += h;
 		}
 	}
 }
@@ -1366,13 +1382,19 @@ void Game::DrawDeckBd() {
 				driver->draw2DRectangleOutline(Resize(313 + i * dx, 563, 359 + i * dx, 629));
 		}
 	}
-	//search result
-	driver->draw2DRectangle(Resize(805, 137, 926, 157), 0x400000ff, 0x400000ff, 0x40000000, 0x40000000);
-	driver->draw2DRectangleOutline(Resize(804, 136, 926, 157));
-	DrawShadowText(textFont, dataManager.GetSysString(1333), Resize(810, 137, 915, 157), Resize(1, 1, 1, 1), 0xffffffff, 0xff000000, false, true);
-	DrawShadowText(numFont, deckBuilder.result_string, Resize(875, 137, 935, 157), Resize(1, 1, 1, 1), 0xffffffff, 0xff000000, false, true);
-	driver->draw2DRectangle(Resize(805, 160, 1020, 630), 0x400000ff, 0x400000ff, 0x40000000, 0x40000000);
-	driver->draw2DRectangleOutline(Resize(804, 159, 1020, 630));
+	if(is_siding) {
+		// side chat background
+		driver->draw2DRectangle(Resize(805, 10, 1020, 630), 0x400000ff, 0x400000ff, 0x40000000, 0x40000000);
+		driver->draw2DRectangleOutline(Resize(804, 9, 1020, 630));
+	} else {
+		//search result
+		driver->draw2DRectangle(Resize(805, 137, 926, 157), 0x400000ff, 0x400000ff, 0x40000000, 0x40000000);
+		driver->draw2DRectangleOutline(Resize(804, 136, 926, 157));
+		DrawShadowText(textFont, dataManager.GetSysString(1333), Resize(810, 137, 915, 157), Resize(1, 1, 1, 1), 0xffffffff, 0xff000000, false, true);
+		DrawShadowText(numFont, deckBuilder.result_string, Resize(875, 137, 935, 157), Resize(1, 1, 1, 1), 0xffffffff, 0xff000000, false, true);
+		driver->draw2DRectangle(Resize(805, 160, 1020, 630), 0x400000ff, 0x400000ff, 0x40000000, 0x40000000);
+		driver->draw2DRectangleOutline(Resize(804, 159, 1020, 630));
+	}
 	for(size_t i = 0; i < 9 && i + scrFilter->getPos() < deckBuilder.results.size(); ++i) {
 		code_pointer ptr = deckBuilder.results[i + scrFilter->getPos()];
 		if(i >= 7)

gframe/duelclient.h

@@ -5,11 +5,6 @@
 #include <vector>
 #include <set>
 #include <utility>
-#include <event2/event.h>
-#include <event2/listener.h>
-#include <event2/bufferevent.h>
-#include <event2/buffer.h>
-#include <event2/thread.h>
 #include "network.h"
 #include "data_manager.h"
 #include "deck_manager.h"
@@ -62,11 +57,11 @@ private:
 	static unsigned char response_buf[SIZE_RETURN_VALUE];
 	static unsigned int response_len;
 	static unsigned int watching;
-	static unsigned char selftype;
 	static bool is_host;
 	static event_base* client_base;
 	static bufferevent* client_bev;
 	static unsigned char duel_client_read[SIZE_NETWORK_BUFFER];
+	static int read_len;
 	static unsigned char duel_client_write[SIZE_NETWORK_BUFFER];
 	static bool is_closing;
 	static bool is_swapping;
@@ -82,14 +77,14 @@ public:
 	static unsigned short temp_port;
 	static unsigned short temp_ver;
 	static bool try_needed;
-	
+	static unsigned char selftype;
 	static bool StartClient(unsigned int ip, unsigned short port, bool create_game = true);
 	static void ConnectTimeout(evutil_socket_t fd, short events, void* arg);
 	static void StopClient(bool is_exiting = false);
 	static void ClientRead(bufferevent* bev, void* ctx);
 	static void ClientEvent(bufferevent *bev, short events, void *ctx);
 	static int ClientThread();
-	static void HandleSTOCPacketLan(unsigned char* data, unsigned int len);
+	static void HandleSTOCPacketLan(unsigned char* data, int len);
 	static int ClientAnalyze(unsigned char* msg, unsigned int len);
 	static void SwapField();
 	static void SetResponseI(int respI);
@@ -113,10 +108,10 @@ public:
 		auto p = duel_client_write;
 		int blen = sizeof(ST);
 		if (blen > MAX_DATA_SIZE)
-			blen = MAX_DATA_SIZE;
+			return;
 		BufferIO::WriteInt16(p, (short)(1 + blen));
 		BufferIO::WriteInt8(p, proto);
-		memcpy(p, &st, blen);
+		std::memcpy(p, &st, blen);
 #ifdef YGOPRO_MESSAGE_DEBUG
 		printf("CTOS: %d Length: %ld\n", proto, sizeof(ST));
 #endif
@@ -131,7 +126,7 @@ public:
 			blen = MAX_DATA_SIZE;
 		BufferIO::WriteInt16(p, (short)(1 + blen));
 		BufferIO::WriteInt8(p, proto);
-		memcpy(p, buffer, blen);
+		std::memcpy(p, buffer, blen);
 #ifdef YGOPRO_MESSAGE_DEBUG
 		printf("CTOS: %d Length: %ld\n", proto, len);
 #endif

gframe/event_handler.cpp

@@ -127,6 +127,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 				if(mainGame->dInfo.player_type == 7) {
 					DuelClient::StopClient();
 					mainGame->dInfo.isStarted = false;
+					mainGame->dInfo.isInDuel = false;
 					mainGame->dInfo.isFinished = false;
 					mainGame->device->setEventReceiver(&mainGame->menuHandler);
 					mainGame->CloseDuelWindow();
@@ -142,7 +143,8 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 					if(exit_on_return)
 						mainGame->device->closeDevice();
 				} else {
-					mainGame->PopupElement(mainGame->wSurrender);
+					if(!(mainGame->dInfo.isTag && mainGame->dField.tag_surrender))
+						mainGame->PopupElement(mainGame->wSurrender);
 				}
 				break;
 			}
@@ -150,10 +152,12 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 				soundManager.PlaySoundEffect(SOUND_BUTTON);
 				DuelClient::SendPacketToServer(CTOS_SURRENDER);
 				mainGame->HideElement(mainGame->wSurrender);
+				mainGame->dField.tag_surrender = true;
 				break;
 			}
 			case BUTTON_SURRENDER_NO: {
 				soundManager.PlaySoundEffect(SOUND_BUTTON);
+				mainGame->dField.tag_teammate_surrender = false;
 				mainGame->HideElement(mainGame->wSurrender);
 				break;
 			}
@@ -522,7 +526,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 						current_mset_param = (i << 16) + 3;
 						if(mainGame->gameConf.ask_mset) {
 							wchar_t wbuf[256];
-							myswprintf(wbuf, dataManager.GetSysString(1355), dataManager.GetName(clicked_card->code));
+							myswprintf(wbuf, dataManager.GetSysString(1368), dataManager.GetName(clicked_card->code));
 							mainGame->stQMessage->setText(wbuf);
 							mainGame->PopupElement(mainGame->wQuery);
 						} else {
@@ -1947,7 +1951,7 @@ bool ClientField::OnCommonEvent(const irr::SEvent& event) {
 			}
 #endif
 			case CHECKBOX_DISABLE_CHAT: {
-				bool show = !mainGame->is_building;
+				bool show = (mainGame->is_building && !mainGame->is_siding) ? false : true;
 				mainGame->wChat->setVisible(show);
 				/*
 				if(!show)
@@ -2083,9 +2087,9 @@ bool ClientField::OnCommonEvent(const irr::SEvent& event) {
 					break;
 				const wchar_t* input = mainGame->ebChatInput->getText();
 				if(input[0]) {
-					unsigned short msgbuf[256];
-					int len = BufferIO::CopyWStr(input, msgbuf, 256);
-					DuelClient::SendBufferToServer(CTOS_CHAT, msgbuf, (len + 1) * sizeof(short));
+					uint16_t msgbuf[LEN_CHAT_MSG];
+					int len = BufferIO::CopyWStr(input, msgbuf, LEN_CHAT_MSG);
+					DuelClient::SendBufferToServer(CTOS_CHAT, msgbuf, (len + 1) * sizeof(uint16_t));
 					mainGame->ebChatInput->setText(L"");
 					return true;
 				}

gframe/game.h

@@ -14,22 +14,6 @@
 #define YGOPRO_DEFAULT_DUEL_RULE			5
 #endif
 
-#ifndef YGOPRO_MAX_DECK
-#define YGOPRO_MAX_DECK					60
-#endif
-
-#ifndef YGOPRO_MIN_DECK
-#define YGOPRO_MIN_DECK					40
-#endif
-
-#ifndef YGOPRO_MAX_EXTRA
-#define YGOPRO_MAX_EXTRA					15
-#endif
-
-#ifndef YGOPRO_MAX_SIDE
-#define YGOPRO_MAX_SIDE					15
-#endif
-
 namespace ygo {
 
 struct Config {
@@ -93,7 +77,8 @@ struct Config {
 
 struct DuelInfo {
 	bool isStarted{ false };
-	bool isFinished{ false };
+	bool isInDuel{ false };
+	bool isFinished{false};
 	bool isReplay{ false };
 	bool isReplaySkiping{ false };
 	bool isFirst{ false };
@@ -196,7 +181,7 @@ public:
 	void ShowCardInfo(int code, bool resize = false);
 	void ClearCardInfo(int player = 0);
 	void AddLog(const wchar_t* msg, int param = 0);
-	void AddChatMsg(const wchar_t* msg, int player);
+	void AddChatMsg(const wchar_t* msg, int player, bool play_sound = false);
 	void ClearChatMsg();
 	void AddDebugMsg(const char* msgbuf);
 	void ErrorLog(const char* msgbuf);
@@ -206,7 +191,9 @@ public:
 	void CloseGameWindow();
 	void CloseDuelWindow();
 
-	int LocalPlayer(int player);
+	int LocalPlayer(int player) const;
+	int OppositePlayer(int player);
+	int ChatLocalPlayer(int player);
 	const wchar_t* LocalName(int local_player);
 	const char* GetLocaleDir(const char* dir);
 	const wchar_t* GetLocaleDirWide(const char* dir);
@@ -224,6 +211,7 @@ public:
 	}
 
 	void OnResize();
+	void ResizeChatInputWindow();
 	recti Resize(s32 x, s32 y, s32 x2, s32 y2);
 	recti Resize(s32 x, s32 y, s32 x2, s32 y2, s32 dx, s32 dy, s32 dx2, s32 dy2);
 	position2di Resize(s32 x, s32 y);

gframe/gframe.cpp

@@ -7,7 +7,7 @@
 #import <CoreFoundation/CoreFoundation.h>
 #endif
 
-int enable_log = 0;
+unsigned int enable_log = 0x3;
 bool exit_on_return = false;
 bool auto_watch_mode = false;
 bool auto_record_mode = false;

gframe/image_manager.cpp

@@ -323,26 +323,26 @@ irr::video::ITexture* ImageManager::GetTexture(int code, bool fit) {
 	auto tit = tMap[fit ? 1 : 0].find(code);
 	if(tit == tMap[fit ? 1 : 0].end()) {
 		char file[256];
-		sprintf(file, "expansions/pics/%d.png", code);
+		snprintf(file, sizeof file, "expansions/pics/%d.png", code);
 		irr::video::ITexture* img = GetTextureFromFile(file, width, height);
 		if(img == NULL) {
-			sprintf(file, "expansions/pics/%d.jpg", code);
+			snprintf(file, sizeof file, "expansions/pics/%d.jpg", code);
 			img = GetTextureFromFile(file, width, height);
 		}
 		if(img == NULL) {
-			sprintf(file, mainGame->GetLocaleDir("pics/%d.png"), code);
+			snprintf(file, sizeof file, mainGame->GetLocaleDir("pics/%d.png"), code);
 			img = GetTextureFromFile(file, width, height);
 		}
 		if(img == NULL) {
-			sprintf(file, mainGame->GetLocaleDir("pics/%d.jpg"), code);
+			snprintf(file, sizeof file, mainGame->GetLocaleDir("pics/%d.jpg"), code);
 			img = GetTextureFromFile(file, width, height);
 		}
 		if(img == NULL) {
-			sprintf(file, "pics/%d.png", code);
+			snprintf(file, sizeof file, "pics/%d.png", code);
 			img = GetTextureFromFile(file, width, height);
 		}
 		if(img == NULL) {
-			sprintf(file, "pics/%d.jpg", code);
+			snprintf(file, sizeof file, "pics/%d.jpg", code);
 			img = GetTextureFromFile(file, width, height);
 		}
 		if(img == NULL && !mainGame->gameConf.use_image_scale) {
@@ -366,10 +366,10 @@ irr::video::ITexture* ImageManager::GetBigPicture(int code, float zoom) {
 	}
 	irr::video::ITexture* texture;
 	char file[256];
-	sprintf(file, "expansions/pics/%d.jpg", code);
+	snprintf(file, sizeof file, "expansions/pics/%d.jpg", code);
 	irr::video::IImage* srcimg = driver->createImageFromFile(file);
 	if(srcimg == NULL) {
-		sprintf(file, "pics/%d.jpg", code);
+		snprintf(file, sizeof file, "pics/%d.jpg", code);
 		srcimg = driver->createImageFromFile(file);
 	}
 	if(srcimg == NULL) {
@@ -395,49 +395,49 @@ int ImageManager::LoadThumbThread() {
 		imageManager.tThumbLoadingCodes.pop();
 		imageManager.tThumbLoadingMutex.unlock();
 		char file[256];
-		sprintf(file, "expansions/pics/thumbnail/%d.png", code);
+		snprintf(file, sizeof file, "expansions/pics/thumbnail/%d.png", code);
 		irr::video::IImage* img = imageManager.driver->createImageFromFile(file);
 		if(img == NULL) {
-			sprintf(file, "expansions/pics/thumbnail/%d.jpg", code);
+			snprintf(file, sizeof file, "expansions/pics/thumbnail/%d.jpg", code);
 			img = imageManager.driver->createImageFromFile(file);
 		}
 		if(img == NULL) {
-			sprintf(file, mainGame->GetLocaleDir("pics/thumbnail/%d.png"), code);
+			snprintf(file, sizeof file, mainGame->GetLocaleDir("pics/thumbnail/%d.png"), code);
 			img = imageManager.driver->createImageFromFile(file);
 		}
 		if(img == NULL) {
-			sprintf(file, mainGame->GetLocaleDir("pics/thumbnail/%d.jpg"), code);
+			snprintf(file, sizeof file, mainGame->GetLocaleDir("pics/thumbnail/%d.jpg"), code);
 			img = imageManager.driver->createImageFromFile(file);
 		}
 		if(img == NULL) {
-			sprintf(file, "pics/thumbnail/%d.png", code);
+			snprintf(file, sizeof file, "pics/thumbnail/%d.png", code);
 			img = imageManager.driver->createImageFromFile(file);
 		}
 		if(img == NULL) {
-			sprintf(file, "pics/thumbnail/%d.jpg", code);
+			snprintf(file, sizeof file, "pics/thumbnail/%d.jpg", code);
 			img = imageManager.driver->createImageFromFile(file);
 		}
 		if(img == NULL && mainGame->gameConf.use_image_scale) {
-			sprintf(file, "expansions/pics/%d.png", code);
+			snprintf(file, sizeof file, "expansions/pics/%d.png", code);
 			img = imageManager.driver->createImageFromFile(file);
 			if(img == NULL) {
-				sprintf(file, "expansions/pics/%d.jpg", code);
+				snprintf(file, sizeof file, "expansions/pics/%d.jpg", code);
 				img = imageManager.driver->createImageFromFile(file);
 			}
 			if(img == NULL) {
-				sprintf(file, mainGame->GetLocaleDir("pics/%d.png"), code);
+				snprintf(file, sizeof file, mainGame->GetLocaleDir("pics/%d.png"), code);
 				img = imageManager.driver->createImageFromFile(file);
 			}
 			if(img == NULL) {
-				sprintf(file, mainGame->GetLocaleDir("pics/%d.jpg"), code);
+				snprintf(file, sizeof file, mainGame->GetLocaleDir("pics/%d.jpg"), code);
 				img = imageManager.driver->createImageFromFile(file);
 			}
 			if(img == NULL) {
-				sprintf(file, "pics/%d.png", code);
+				snprintf(file, sizeof file, "pics/%d.png", code);
 				img = imageManager.driver->createImageFromFile(file);
 			}
 			if(img == NULL) {
-				sprintf(file, "pics/%d.jpg", code);
+				snprintf(file, sizeof file, "pics/%d.jpg", code);
 				img = imageManager.driver->createImageFromFile(file);
 			}
 		}
@@ -483,7 +483,7 @@ irr::video::ITexture* ImageManager::GetTextureThumb(int code) {
 	if(lit != tThumbLoading.end()) {
 		if(lit->second != NULL) {
 			char file[256];
-			sprintf(file, "pics/thumbnail/%d.jpg", code);
+			snprintf(file, sizeof file, "pics/thumbnail/%d.jpg", code);
 			irr::video::ITexture* texture = driver->addTexture(file, lit->second); // textures must be added in the main thread due to OpenGL
 			lit->second->drop();
 			tThumb[code] = texture;
@@ -513,26 +513,26 @@ irr::video::ITexture* ImageManager::GetTextureThumb(int code) {
 	auto tit = tFields.find(code);
 	if(tit == tFields.end()) {
 		char file[256];
-		sprintf(file, "expansions/pics/field/%d.png", code);
+		snprintf(file, sizeof file, "expansions/pics/field/%d.png", code);
 		irr::video::ITexture* img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 		if(img == NULL) {
-			sprintf(file, "expansions/pics/field/%d.jpg", code);
+			snprintf(file, sizeof file, "expansions/pics/field/%d.jpg", code);
 			img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 		}
 		if(img == NULL) {
-			sprintf(file, mainGame->GetLocaleDir("pics/field/%d.png"), code);
+			snprintf(file, sizeof file, mainGame->GetLocaleDir("pics/field/%d.png"), code);
 			img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 		}
 		if(img == NULL) {
-			sprintf(file, mainGame->GetLocaleDir("pics/field/%d.jpg"), code);
+			snprintf(file, sizeof file, mainGame->GetLocaleDir("pics/field/%d.jpg"), code);
 			img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 		}
 		if(img == NULL) {
-			sprintf(file, "pics/field/%d.png", code);
+			snprintf(file, sizeof file, "pics/field/%d.png", code);
 			img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 		}
 		if(img == NULL) {
-			sprintf(file, "pics/field/%d.jpg", code);
+			snprintf(file, sizeof file, "pics/field/%d.jpg", code);
 			img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 			if(img == NULL) {
 				tFields[code] = NULL;
@@ -557,26 +557,26 @@ irr::video::ITexture* ImageManager::GetTextureField(int code) {
 	auto tit = tFields.find(code);
 	if(tit == tFields.end()) {
 		char file[256];
-		sprintf(file, "expansions/pics/field/%d.png", code);
+		snprintf(file, sizeof file, "expansions/pics/field/%d.png", code);
 		irr::video::ITexture* img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 		if(img == NULL) {
-			sprintf(file, "expansions/pics/field/%d.jpg", code);
+			snprintf(file, sizeof file, "expansions/pics/field/%d.jpg", code);
 			img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 		}
 		if(img == NULL) {
-			sprintf(file, mainGame->GetLocaleDir("pics/field/%d.png"), code);
+			snprintf(file, sizeof file, mainGame->GetLocaleDir("pics/field/%d.png"), code);
 			img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 		}
 		if(img == NULL) {
-			sprintf(file, mainGame->GetLocaleDir("pics/field/%d.jpg"), code);
+			snprintf(file, sizeof file, mainGame->GetLocaleDir("pics/field/%d.jpg"), code);
 			img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 		}
 		if(img == NULL) {
-			sprintf(file, "pics/field/%d.png", code);
+			snprintf(file, sizeof file, "pics/field/%d.png", code);
 			img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 		}
 		if(img == NULL) {
-			sprintf(file, "pics/field/%d.jpg", code);
+			snprintf(file, sizeof file, "pics/field/%d.jpg", code);
 			img = GetTextureFromFile(file, 512 * mainGame->xScale, 512 * mainGame->yScale);
 			if(img == NULL) {
 				tFields[code] = NULL;

gframe/irrUString.h

@@ -31,12 +31,8 @@
 #ifndef __IRR_USTRING_H_INCLUDED__
 #define __IRR_USTRING_H_INCLUDED__
 
-#if (__cplusplus > 199711L) || (_MSC_VER >= 1600) || defined(__GXX_EXPERIMENTAL_CXX0X__)
-#	define USTRING_CPP0X
-#	if defined(__GXX_EXPERIMENTAL_CXX0X__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)))
-#		define USTRING_CPP0X_NEWLITERALS
-#	endif
-#endif
+#define USTRING_CPP0X
+#define USTRING_CPP0X_NEWLITERALS
 
 #include <stdio.h>
 #include <string.h>

gframe/menu_handler.cpp

@@ -386,9 +386,9 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 					int flag = 0;
 					flag += (mainGame->chkBotHand->isChecked() ? 0x1 : 0);
 					char arg2[8];
-					sprintf(arg2, "%d", flag);
+					snprintf(arg2, sizeof arg2, "%d", flag);
 					char arg3[8];
-					sprintf(arg3, "%d", mainGame->gameConf.serverport);
+					snprintf(arg3, sizeof arg3, "%d", mainGame->gameConf.serverport);
 					execl("./bot", "bot", arg1, arg2, arg3, NULL);
 					exit(0);
 				} else {

gframe/myfilesystem.h

@@ -176,7 +176,7 @@ public:
 		bool success = true;
 		TraversalDir(dir, [dir, &success](const char *name, bool isdir) {
 			char full_path[256];
-			sprintf(full_path, "%s/%s", dir, name);
+			snprintf(full_path, sizeof full_path, "%s/%s", dir, name);
 			if (isdir)
 			{
 				if(!DeleteDir(full_path))

gframe/netserver.cpp

@@ -10,6 +10,7 @@ event* NetServer::broadcast_ev = 0;
 evconnlistener* NetServer::listener = 0;
 DuelMode* NetServer::duel_mode = 0;
 unsigned char NetServer::net_server_read[SIZE_NETWORK_BUFFER];
+int NetServer::read_len = 0;
 unsigned char NetServer::net_server_write[SIZE_NETWORK_BUFFER];
 unsigned short NetServer::last_sent = 0;
 
@@ -84,7 +85,9 @@ void NetServer::BroadcastEvent(evutil_socket_t fd, short events, void* arg) {
 	int ret = recvfrom(fd, buf, 256, 0, (sockaddr*)&bc_addr, &sz);
 	if(ret == -1)
 		return;
-	HostRequest* pHR = (HostRequest*)buf;
+	HostRequest packet;
+	std::memcpy(&packet, buf, sizeof packet);
+	const HostRequest* pHR = &packet;
 	if(pHR->identifier == NETWORK_CLIENT_ID) {
 		SOCKADDR_IN sockTo;
 		sockTo.sin_addr.s_addr = bc_addr.sin_addr.s_addr;
@@ -112,19 +115,30 @@ void NetServer::ServerAccept(evconnlistener* listener, evutil_socket_t fd, socka
 void NetServer::ServerAcceptError(evconnlistener* listener, void* ctx) {
 	event_base_loopexit(net_evbase, 0);
 }
+/*
+* packet_len: 2 bytes
+* proto: 1 byte
+* [data]: (packet_len - 1) bytes
+*/
 void NetServer::ServerEchoRead(bufferevent *bev, void *ctx) {
 	evbuffer* input = bufferevent_get_input(bev);
-	size_t len = evbuffer_get_length(input);
+	int len = evbuffer_get_length(input);
 	unsigned short packet_len = 0;
 	while(true) {
 		if(len < 2)
 			return;
 		evbuffer_copyout(input, &packet_len, 2);
-		if(len < (size_t)packet_len + 2)
+		if (packet_len + 2 > SIZE_NETWORK_BUFFER) {
+			ServerEchoEvent(bev, BEV_EVENT_ERROR, 0);
 			return;
-		evbuffer_remove(input, net_server_read, packet_len + 2);
-		if(packet_len)
-			HandleCTOSPacket(&users[bev], &net_server_read[2], packet_len);
+		}
+		if (len < packet_len + 2)
+			return;
+		if (packet_len < 1)
+			return;
+		read_len = evbuffer_remove(input, net_server_read, packet_len + 2);
+		if (read_len >= 3)
+			HandleCTOSPacket(&users[bev], &net_server_read[2], read_len - 2);
 		len -= packet_len + 2;
 	}
 }
@@ -134,7 +148,8 @@ void NetServer::ServerEchoEvent(bufferevent* bev, short events, void* ctx) {
 		DuelMode* dm = dp->game;
 		if(dm)
 			dm->LeaveGame(dp);
-		else DisconnectPlayer(dp);
+		else
+			DisconnectPlayer(dp);
 	}
 }
 int NetServer::ServerThread() {
@@ -171,7 +186,7 @@ void NetServer::DisconnectPlayer(DuelPlayer* dp) {
 		users.erase(bit);
 	}
 }
-void NetServer::HandleCTOSPacket(DuelPlayer* dp, unsigned char* data, unsigned int len) {
+void NetServer::HandleCTOSPacket(DuelPlayer* dp, unsigned char* data, int len) {
 	auto pdata = data;
 	unsigned char pktType = BufferIO::ReadUInt8(pdata);
 	if((pktType != CTOS_SURRENDER) && (pktType != CTOS_CHAT) && (dp->state == 0xff || (dp->state && dp->state != pktType)))
@@ -180,6 +195,8 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, unsigned char* data, unsigned i
 	case CTOS_RESPONSE: {
 		if(!dp->game || !duel_mode->pduel)
 			return;
+		if (len < 1 + (int)sizeof(unsigned char))
+			return;
 		duel_mode->GetResponse(dp, pdata, len - 1);
 		break;
 	}
@@ -192,38 +209,58 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, unsigned char* data, unsigned i
 	case CTOS_CHAT: {
 		if(!dp->game)
 			return;
+		if (len < 1 + (int)sizeof(unsigned char))
+			return;
 		duel_mode->Chat(dp, pdata, len - 1);
 		break;
 	}
 	case CTOS_UPDATE_DECK: {
 		if(!dp->game)
 			return;
+		if (len < 1 + (int)sizeof(unsigned char))
+			return;
 		duel_mode->UpdateDeck(dp, pdata, len - 1);
 		break;
 	}
 	case CTOS_HAND_RESULT: {
 		if(!dp->game)
 			return;
-		CTOS_HandResult* pkt = (CTOS_HandResult*)pdata;
+		if (len < 1 + (int)sizeof(CTOS_HandResult))
+			return;
+		CTOS_HandResult packet;
+		std::memcpy(&packet, pdata, sizeof packet);
+		const auto* pkt = &packet;
 		dp->game->HandResult(dp, pkt->res);
 		break;
 	}
 	case CTOS_TP_RESULT: {
 		if(!dp->game)
 			return;
-		CTOS_TPResult* pkt = (CTOS_TPResult*)pdata;
+		if (len < 1 + (int)sizeof(CTOS_TPResult))
+			return;
+		CTOS_TPResult packet;
+		std::memcpy(&packet, pdata, sizeof packet);
+		const auto* pkt = &packet;
 		dp->game->TPResult(dp, pkt->res);
 		break;
 	}
 	case CTOS_PLAYER_INFO: {
-		CTOS_PlayerInfo* pkt = (CTOS_PlayerInfo*)pdata;
+		if (len < 1 + (int)sizeof(CTOS_PlayerInfo))
+			return;
+		CTOS_PlayerInfo packet;
+		std::memcpy(&packet, pdata, sizeof packet);
+		const auto* pkt = &packet;
 		BufferIO::CopyWStr(pkt->name, dp->name, 20);
 		break;
 	}
 	case CTOS_CREATE_GAME: {
 		if(dp->game || duel_mode)
 			return;
-		CTOS_CreateGame* pkt = (CTOS_CreateGame*)pdata;
+		if (len < 1 + (int)sizeof(CTOS_CreateGame))
+			return;
+		CTOS_CreateGame packet;
+		std::memcpy(&packet, pdata, sizeof packet);
+		auto pkt = &packet;
 		if(pkt->info.mode == MODE_SINGLE) {
 			duel_mode = new SingleDuel(false);
 			duel_mode->etimer = event_new(net_evbase, 0, EV_TIMEOUT | EV_PERSIST, SingleDuel::SingleTimer, duel_mode);
@@ -247,6 +284,7 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, unsigned char* data, unsigned i
 		}
 		if(hash == 1)
 			pkt->info.lflist = deckManager._lfList[0].hash;
+		std::memcpy(pdata, &packet, sizeof packet);
 		duel_mode->host_info = pkt->info;
 		BufferIO::CopyWStr(pkt->name, duel_mode->name, 20);
 		BufferIO::CopyWStr(pkt->pass, duel_mode->pass, 20);
@@ -255,56 +293,76 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, unsigned char* data, unsigned i
 		break;
 	}
 	case CTOS_JOIN_GAME: {
-		if(!duel_mode)
-			break;
+		if (!duel_mode)
+			return;
+		if (len < 1 + (int)sizeof(CTOS_JoinGame))
+			return;
 		duel_mode->JoinGame(dp, pdata, false);
 		break;
 	}
 	case CTOS_LEAVE_GAME: {
-		if(!duel_mode)
-			break;
+		if (!duel_mode)
+			return;
 		duel_mode->LeaveGame(dp);
 		break;
 	}
 	case CTOS_SURRENDER: {
-		if(!duel_mode)
-			break;
+		if (!duel_mode)
+			return;
 		duel_mode->Surrender(dp);
 		break;
 	}
 	case CTOS_HS_TODUELIST: {
-		if(!duel_mode || duel_mode->pduel)
-			break;
+		if (!duel_mode || duel_mode->pduel)
+			return;
 		duel_mode->ToDuelist(dp);
 		break;
 	}
 	case CTOS_HS_TOOBSERVER: {
-		if(!duel_mode || duel_mode->pduel)
-			break;
+		if (!duel_mode || duel_mode->pduel)
+			return;
 		duel_mode->ToObserver(dp);
 		break;
 	}
 	case CTOS_HS_READY:
 	case CTOS_HS_NOTREADY: {
-		if(!duel_mode || duel_mode->pduel)
-			break;
+		if (!duel_mode || duel_mode->pduel)
+			return;
 		duel_mode->PlayerReady(dp, (CTOS_HS_NOTREADY - pktType) != 0);
 		break;
 	}
 	case CTOS_HS_KICK: {
-		if(!duel_mode || duel_mode->pduel)
-			break;
-		CTOS_Kick* pkt = (CTOS_Kick*)pdata;
+		if (!duel_mode || duel_mode->pduel)
+			return;
+		if (len < 1 + (int)sizeof(CTOS_Kick))
+			return;
+		CTOS_Kick packet;
+		std::memcpy(&packet, pdata, sizeof packet);
+		const auto* pkt = &packet;
 		duel_mode->PlayerKick(dp, pkt->pos);
 		break;
 	}
 	case CTOS_HS_START: {
-		if(!duel_mode || duel_mode->pduel)
-			break;
+		if (!duel_mode || duel_mode->pduel)
+			return;
 		duel_mode->StartDuel(dp);
 		break;
 	}
 	}
 }
+size_t NetServer::CreateChatPacket(unsigned char* src, int src_size, unsigned char* dst, uint16_t dst_player_type) {
+	if (!check_msg_size(src_size))
+		return 0;
+	uint16_t src_msg[LEN_CHAT_MSG];
+	std::memcpy(src_msg, src, src_size);
+	const int src_len = src_size / sizeof(uint16_t);
+	if (src_msg[src_len - 1] != 0)
+		return 0;
+	// STOC_Chat packet
+	auto pdst = dst;
+	buffer_write<uint16_t>(pdst, dst_player_type);
+	buffer_write_block(pdst, src_msg, src_size);
+	return sizeof(dst_player_type) + src_size;
+}
 
 }

gframe/netserver.h

@@ -19,6 +19,7 @@ private:
 	static evconnlistener* listener;
 	static DuelMode* duel_mode;
 	static unsigned char net_server_read[SIZE_NETWORK_BUFFER];
+	static int read_len;
 	static unsigned char net_server_write[SIZE_NETWORK_BUFFER];
 	static unsigned short last_sent;
 
@@ -35,7 +36,8 @@ public:
 	static void ServerEchoEvent(bufferevent* bev, short events, void* ctx);
 	static int ServerThread();
 	static void DisconnectPlayer(DuelPlayer* dp);
-	static void HandleCTOSPacket(DuelPlayer* dp, unsigned char* data, unsigned int len);
+	static void HandleCTOSPacket(DuelPlayer* dp, unsigned char* data, int len);
+	static size_t CreateChatPacket(unsigned char* src, int src_size, unsigned char* dst, uint16_t dst_player_type);
 	static void SendPacketToPlayer(DuelPlayer* dp, unsigned char proto) {
 		auto p = net_server_write;
 		BufferIO::WriteInt16(p, 1);
@@ -50,10 +52,10 @@ public:
 		auto p = net_server_write;
 		int blen = sizeof(ST);
 		if (blen > MAX_DATA_SIZE)
-			blen = MAX_DATA_SIZE;
+			return;
 		BufferIO::WriteInt16(p, (short)(1 + blen));
 		BufferIO::WriteInt8(p, proto);
-		memcpy(p, &st, blen);
+		std::memcpy(p, &st, blen);
 		last_sent = blen + 3;
 		if (dp)
 			bufferevent_write(dp->bev, net_server_write, blen + 3);
@@ -67,7 +69,7 @@ public:
 			blen = MAX_DATA_SIZE;
 		BufferIO::WriteInt16(p, (short)(1 + blen));
 		BufferIO::WriteInt8(p, proto);
-		memcpy(p, buffer, blen);
+		std::memcpy(p, buffer, blen);
 		last_sent = blen + 3;
 		if (dp)
 			bufferevent_write(dp->bev, net_server_write, blen + 3);

gframe/replay.cpp

 #include "replay.h"
-#include "../ocgcore/ocgapi.h"
-#include "../ocgcore/common.h"
 #include "lzma/LzmaLib.h"
 #include "base64.h"
 
 namespace ygo {
 
-Replay::Replay()
-	: fp(nullptr), pheader(), pdata(nullptr), replay_size(0), comp_size(0), is_recording(false), is_replaying(false) {
-	#ifdef _WIN32
-		recording_fp = nullptr;
-	#endif
+Replay::Replay() {
 	replay_data = new unsigned char[MAX_REPLAY_SIZE];
 	comp_data = new unsigned char[MAX_COMP_SIZE];
 }
@@ -55,7 +49,7 @@ void Replay::WriteData(const void* data, int length, bool flush) {
 		return;
 	if (length < 0 || (pdata - replay_data) + length > MAX_REPLAY_SIZE)
 		return;
-	memcpy(pdata, data, length);
+	std::memcpy(pdata, data, length);
 	pdata += length;
 #ifdef _WIN32
 	DWORD size;
@@ -71,8 +65,7 @@ void Replay::WriteInt32(int data, bool flush) {
 		return;
 	if ((pdata - replay_data) + 4 > MAX_REPLAY_SIZE)
 		return;
-	*((int*)(pdata)) = data;
-	pdata += 4;
+	BufferIO::WriteInt32(pdata, data);
 #ifdef _WIN32
 	DWORD size;
 	WriteFile(recording_fp, &data, sizeof(int), &size, NULL);
@@ -87,8 +80,7 @@ void Replay::WriteInt16(short data, bool flush) {
 		return;
 	if ((pdata - replay_data) + 2 > MAX_REPLAY_SIZE)
 		return;
-	*((short*)(pdata)) = data;
-	pdata += 2;
+	BufferIO::WriteInt16(pdata, data);
 #ifdef _WIN32
 	DWORD size;
 	WriteFile(recording_fp, &data, sizeof(short), &size, NULL);
@@ -103,8 +95,7 @@ void Replay::WriteInt8(char data, bool flush) {
 		return;
 	if ((pdata - replay_data) + 1 > MAX_REPLAY_SIZE)
 		return;
-	*pdata = data;
-	pdata++;
+	BufferIO::WriteInt8(pdata, data);
 #ifdef _WIN32
 	DWORD size;
 	WriteFile(recording_fp, &data, sizeof(char), &size, NULL);
@@ -140,8 +131,8 @@ void Replay::EndRecord() {
 	comp_size = MAX_COMP_SIZE;
 	int ret = LzmaCompress(comp_data, &comp_size, replay_data, replay_size, pheader.props, &propsize, 5, 1 << 24, 3, 0, 2, 32, 1);
 	if (ret != SZ_OK) {
-		*((int*)(comp_data)) = ret;
-		comp_size = sizeof(ret);
+		std::memcpy(comp_data, &ret, sizeof ret);
+		comp_size = sizeof ret;
 	}
 	is_recording = false;
 }
@@ -291,7 +282,7 @@ bool Replay::ReadNextResponse(unsigned char resp[]) {
 	int len = *pdata++;
 	if(len > SIZE_RETURN_VALUE)
 		return false;
-	memcpy(resp, pdata, len);
+	std::memcpy(resp, pdata, len);
 	pdata += len;
 	return true;
 }
@@ -305,27 +296,26 @@ void Replay::ReadName(wchar_t* data) {
 void Replay::ReadData(void* data, int length) {
 	if(!is_replaying)
 		return;
-	memcpy(data, pdata, length);
+	std::memcpy(data, pdata, length);
 	pdata += length;
 }
 int Replay::ReadInt32() {
 	if(!is_replaying)
 		return -1;
-	int ret = *((int*)pdata);
-	pdata += 4;
+	int ret = BufferIO::ReadInt32(pdata);
 	return ret;
 }
 short Replay::ReadInt16() {
 	if(!is_replaying)
 		return -1;
-	short ret = *((short*)pdata);
-	pdata += 2;
+	short ret = BufferIO::ReadInt16(pdata);
 	return ret;
 }
 char Replay::ReadInt8() {
 	if(!is_replaying)
 		return -1;
-	return *pdata++;
+	char ret= BufferIO::ReadInt8(pdata);
+	return ret;
 }
 void Replay::Rewind() {
 	pdata = replay_data;

gframe/replay.h

@@ -17,16 +17,13 @@ namespace ygo {
 #define MAX_COMP_SIZE	0x2000
 
 struct ReplayHeader {
-	unsigned int id;
-	unsigned int version;
-	unsigned int flag;
-	unsigned int seed;
-	unsigned int datasize;
-	unsigned int start_time;
-	unsigned char props[8];
-
-	ReplayHeader()
-		: id(0), version(0), flag(0), seed(0), datasize(0), start_time(0), props{ 0 } {}
+	unsigned int id{};
+	unsigned int version{};
+	unsigned int flag{};
+	unsigned int seed{};
+	unsigned int datasize{};
+	unsigned int start_time{};
+	unsigned char props[8]{};
 };
 
 class Replay {
@@ -60,21 +57,21 @@ public:
 	char ReadInt8();
 	void Rewind();
 
-	FILE* fp;
+	FILE* fp{ nullptr };
 #ifdef _WIN32
-	HANDLE recording_fp;
+	HANDLE recording_fp{ nullptr };
 #endif
 
 	ReplayHeader pheader;
 	unsigned char* replay_data;
 	unsigned char* comp_data;
-	size_t replay_size;
-	size_t comp_size;
+	size_t replay_size{};
+	size_t comp_size{};
 
 private:
-	unsigned char* pdata;
-	bool is_recording;
-	bool is_replaying;
+	unsigned char* pdata{ nullptr };
+	bool is_recording{};
+	bool is_replaying{};
 };
 
 }

gframe/single_duel.h

@@ -11,21 +11,21 @@ class SingleDuel: public DuelMode {
 public:
 	SingleDuel(bool is_match);
 	virtual ~SingleDuel();
-	virtual void Chat(DuelPlayer* dp, void* pdata, int len);
-	virtual void JoinGame(DuelPlayer* dp, void* pdata, bool is_creater);
+	virtual void Chat(DuelPlayer* dp, unsigned char* pdata, int len);
+	virtual void JoinGame(DuelPlayer* dp, unsigned char* pdata, bool is_creater);
 	virtual void LeaveGame(DuelPlayer* dp);
 	virtual void ToDuelist(DuelPlayer* dp);
 	virtual void ToObserver(DuelPlayer* dp);
 	virtual void PlayerReady(DuelPlayer* dp, bool ready);
 	virtual void PlayerKick(DuelPlayer* dp, unsigned char pos);
-	virtual void UpdateDeck(DuelPlayer* dp, void* pdata, unsigned int len);
+	virtual void UpdateDeck(DuelPlayer* dp, unsigned char* pdata, int len);
 	virtual void StartDuel(DuelPlayer* dp);
 	virtual void HandResult(DuelPlayer* dp, unsigned char res);
 	virtual void TPResult(DuelPlayer* dp, unsigned char tp);
 	virtual void Process();
 	virtual void Surrender(DuelPlayer* dp);
 	virtual int Analyze(unsigned char* msgbuffer, unsigned int len);
-	virtual void GetResponse(DuelPlayer* dp, void* pdata, unsigned int len);
+	virtual void GetResponse(DuelPlayer* dp, unsigned char* pdata, unsigned int len);
 	virtual void TimeConfirm(DuelPlayer* dp);
 	virtual void EndDuel();
 	

gframe/tag_duel.h

@@ -11,21 +11,21 @@ class TagDuel: public DuelMode {
 public:
 	TagDuel();
 	virtual ~TagDuel();
-	virtual void Chat(DuelPlayer* dp, void* pdata, int len);
-	virtual void JoinGame(DuelPlayer* dp, void* pdata, bool is_creater);
+	virtual void Chat(DuelPlayer* dp, unsigned char* pdata, int len);
+	virtual void JoinGame(DuelPlayer* dp, unsigned char* pdata, bool is_creater);
 	virtual void LeaveGame(DuelPlayer* dp);
 	virtual void ToDuelist(DuelPlayer* dp);
 	virtual void ToObserver(DuelPlayer* dp);
 	virtual void PlayerReady(DuelPlayer* dp, bool ready);
 	virtual void PlayerKick(DuelPlayer* dp, unsigned char pos);
-	virtual void UpdateDeck(DuelPlayer* dp, void* pdata, unsigned int len);
+	virtual void UpdateDeck(DuelPlayer* dp, unsigned char* pdata, int len);
 	virtual void StartDuel(DuelPlayer* dp);
 	virtual void HandResult(DuelPlayer* dp, unsigned char res);
 	virtual void TPResult(DuelPlayer* dp, unsigned char tp);
 	virtual void Process();
 	virtual void Surrender(DuelPlayer* dp);
 	virtual int Analyze(unsigned char* msgbuffer, unsigned int len);
-	virtual void GetResponse(DuelPlayer* dp, void* pdata, unsigned int len);
+	virtual void GetResponse(DuelPlayer* dp, unsigned char* pdata, unsigned int len);
 	virtual void TimeConfirm(DuelPlayer* dp);
 	virtual void EndDuel();
 	
@@ -50,6 +50,7 @@ protected:
 	DuelPlayer* cur_player[2];
 	std::set<DuelPlayer*> observers;
 	bool ready[4];
+	bool surrender[4];
 	Deck pdeck[4];
 	int deck_error[4];
 	unsigned char hand_result[2];

ocgcore @ c4b71bb2

-Subproject commit cd52e97d861f8e52a710de42681db76e6fab6e4b
+Subproject commit c4b71bb212232a75ae13a61ce8d0fc67191d0116

premake/gframe/ygopro.rc

 1 ICON "ygopro.ico"
 
 1 VERSIONINFO
-FILEVERSION 1, 0, 36, 0
-PRODUCTVERSION 1, 0, 36, 0
+FILEVERSION 1, 0, 36, 1
+PRODUCTVERSION 1, 0, 36, 1
 FILEOS 0x4
 FILETYPE 0x1
 
@@ -16,8 +16,8 @@ VALUE "InternalName", "KoishiPro"
 VALUE "LegalCopyright", "Copyright (C) 2023 Nanahira"
 VALUE "OriginalFilename", "ygopro.exe"
 VALUE "ProductName", "KoishiPro"
-VALUE "FileVersion", "Snowdream"
-VALUE "ProductVersion", "Snowdream"
+VALUE "FileVersion", "GIGALODOON"
+VALUE "ProductVersion", "GIGALODOON"
 END
 END
 BLOCK "VarFileInfo"

premake5.lua

@@ -58,16 +58,15 @@ boolOptions = {
     "compat-mycard",
     "no-lua-safe",
     "message-debug",
-    "default-duel-rule",
     "no-side-check",
 }
 
 for _, boolOption in ipairs(boolOptions) do
-    newoption { trigger = boolOption, category = "YGOPro - Koishi", description = "" }
+    newoption { trigger = boolOption, category = "YGOPro - options", description = "" }
 end
 
 numberOptions = {
-    "default-rule",
+    "default-duel-rule",
     "max-deck",
     "min-deck",
     "max-extra",
@@ -75,7 +74,7 @@ numberOptions = {
 }
 
 for _, numberOption in ipairs(numberOptions) do
-    newoption { trigger = numberOption, category = "YGOPro - Koishi", description = "", value = "NUMBER" }
+    newoption { trigger = numberOption, category = "YGOPro - options", description = "", value = "NUMBER" }
 end
 
 function GetParam(param)
@@ -255,7 +254,7 @@ workspace "YGOPro"
     filter { "configurations:Release", "action:vs*" }
         flags { "LinkTimeOptimization" }
         staticruntime "On"
-        disablewarnings { "4244", "4267", "4838", "4577", "4819", "4018", "4996", "4477", "4091", "4828", "4800", "6011", "6031", "6054", "6262" }
+        disablewarnings { "4244", "4267", "4838", "4577", "4018", "4996", "4477", "4091", "4800", "6011", "6031", "6054", "6262" }
 
     filter { "configurations:Release", "not action:vs*" }
         symbols "On"
@@ -265,7 +264,7 @@ workspace "YGOPro"
         end
 
     filter { "configurations:Debug", "action:vs*" }
-        disablewarnings { "4819", "4828", "6011", "6031", "6054", "6262" }
+        disablewarnings { "6011", "6031", "6054", "6262" }
 
     filter "action:vs*"
         vectorextensions "SSE2"

script @ 6aff241a

-Subproject commit 88558cde6f5fe24604ba496d128bbad58f4b8be0
+Subproject commit 6aff241a80b38289696a1fc52b7fcc754f6eb4b5

system.conf

@@ -2,7 +2,7 @@
 #nickname & gamename should be less than 20 characters
 use_d3d = 0
 use_image_scale = 1
-pro_version = 4960
+pro_version = 4961
 antialias = 2
 errorlog = 3
 nickname = Komeiji Koishi