Merge branch 'master' into patch-miniaudio

gframe/CGUIImageButton.cpp

@@ -15,7 +15,7 @@ namespace irr {
 namespace gui {
 
 void Draw2DImageRotation(video::IVideoDriver* driver, video::ITexture* image, core::rect<s32> sourceRect,
-                         core::position2d<s32> position, core::position2d<s32> rotationPoint, f32 rotation, core::vector2df scale, bool useAlphaChannel, video::SColor color) {
+                         core::vector2d<s32> position, core::vector2d<s32> rotationPoint, f32 rotation, core::vector2df scale, bool useAlphaChannel, video::SColor color) {
 	irr::video::SMaterial material;
 	irr::core::matrix4 oldProjMat = driver->getTransform(irr::video::ETS_PROJECTION);
 	driver->setTransform(irr::video::ETS_PROJECTION, irr::core::matrix4());
@@ -63,7 +63,7 @@ void Draw2DImageRotation(video::IVideoDriver* driver, video::ITexture* image, co
 	driver->setTransform(irr::video::ETS_VIEW, oldViewMat);
 }
 void Draw2DImageQuad(video::IVideoDriver* driver, video::ITexture* image, core::rect<s32> sourceRect,
-                         core::position2d<s32> corner[4], bool useAlphaChannel, video::SColor color) {
+                         core::vector2d<s32> corner[4], bool useAlphaChannel, video::SColor color) {
 	irr::video::SMaterial material;
 	irr::core::matrix4 oldProjMat = driver->getTransform(irr::video::ETS_PROJECTION);
 	driver->setTransform(irr::video::ETS_PROJECTION, irr::core::matrix4());
@@ -255,7 +255,7 @@ bool CGUIImageButton::OnEvent(const SEvent& event)
 		if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
 		{
 			if (Environment->hasFocus(this) &&
-				!AbsoluteClippingRect.isPointInside(core::position2d<s32>(event.MouseInput.X, event.MouseInput.Y)))
+				!AbsoluteClippingRect.isPointInside(core::vector2d<s32>(event.MouseInput.X, event.MouseInput.Y)))
 			{
 				Environment->removeFocus(this);
 				return false;
@@ -272,7 +272,7 @@ bool CGUIImageButton::OnEvent(const SEvent& event)
 			{
 				bool wasPressed = Pressed;
 
-				if (!AbsoluteClippingRect.isPointInside(core::position2d<s32>(event.MouseInput.X, event.MouseInput.Y)))
+				if (!AbsoluteClippingRect.isPointInside(core::vector2d<s32>(event.MouseInput.X, event.MouseInput.Y)))
 				{
 					if (!IsPushButton)
 						setPressed(false);
@@ -313,8 +313,8 @@ void CGUIImageButton::draw() {
 		return;
 	IGUISkin* skin = Environment->getSkin();
 	video::IVideoDriver* driver = Environment->getVideoDriver();
-	core::position2di center = AbsoluteRect.getCenter();
-	core::position2di pos = center;
+	irr::core::vector2di center = AbsoluteRect.getCenter();
+	irr::core::vector2di pos = center;
 	pos.X -= (s32)(ImageRect.getWidth() * imageScale.X * 0.5f);
 	pos.Y -= (s32)(ImageRect.getHeight() * imageScale.Y * 0.5f);
 	if(Pressed) {
@@ -341,7 +341,7 @@ void CGUIImageButton::setImage(video::ITexture* image)
 
 	Image = image;
 	if(image) {
-		ImageRect = core::rect<s32>(core::position2d<s32>(0, 0), image->getOriginalSize());
+		ImageRect = core::rect<s32>(core::vector2d<s32>(0, 0), image->getOriginalSize());
 		if(isFixedSize)
 			imageScale = core::vector2df((irr::f32)imageSize.Width / image->getSize().Width, (irr::f32)imageSize.Height / image->getSize().Height);
 	}
@@ -413,7 +413,7 @@ void CGUIImageButton::setPressedImage(video::ITexture* image)
 
 	PressedImage = image;
 	if (image)
-		PressedImageRect = core::rect<s32>(core::position2d<s32>(0, 0), image->getOriginalSize());
+		PressedImageRect = core::rect<s32>(core::vector2d<s32>(0, 0), image->getOriginalSize());
 }
 
 

gframe/CGUIImageButton.h

@@ -20,10 +20,10 @@ namespace gui {
 class IGUISpriteBank;
 
 void Draw2DImageRotation(video::IVideoDriver* driver, video::ITexture* image, core::rect<s32> sourceRect,
-                         core::position2d<s32> position, core::position2d<s32> rotationPoint, f32 rotation = 0.0f,
+                         core::vector2d<s32> position, core::vector2d<s32> rotationPoint, f32 rotation = 0.0f,
                          core::vector2df scale = core::vector2df(1.0, 1.0), bool useAlphaChannel = true, video::SColor color = 0xffffffff);
 void Draw2DImageQuad(video::IVideoDriver* driver, video::ITexture* image, core::rect<s32> sourceRect,
-                     core::position2d<s32> corner[4], bool useAlphaChannel = true, video::SColor color = 0xffffffff);
+                     core::vector2d<s32> corner[4], bool useAlphaChannel = true, video::SColor color = 0xffffffff);
 
 class CGUIImageButton : public IGUIButton {
 public:

gframe/CGUITTFont.cpp

@@ -505,7 +505,7 @@ void CGUITTFont::drawUstring(const core::ustring& utext, const core::rect<s32>&p
 
 	// Set up some variables.
 	core::dimension2d<s32> textDimension;
-	core::position2d<s32> offset = position.UpperLeftCorner;
+	core::vector2d<s32> offset = position.UpperLeftCorner;
 
 	// Determine offset positions.
 	if (hcenter || vcenter) {
@@ -561,7 +561,7 @@ void CGUITTFont::drawUstring(const core::ustring& utext, const core::rect<s32>&p
 			// Determine rendering information.
 			SGUITTGlyph& glyph = Glyphs[n - 1];
 			CGUITTGlyphPage* const page = Glyph_Pages[glyph.glyph_page];
-			page->render_positions.push_back(core::position2di(offset.X + offx, offset.Y + offy));
+			page->render_positions.push_back(irr::core::vector2di(offset.X + offx, offset.Y + offy));
 			page->render_source_rects.push_back(glyph.source_rect);
 			Render_Map.set(glyph.glyph_page, page);
 		}
@@ -832,7 +832,7 @@ video::IImage* CGUITTFont::createTextureFromChar(const uchar32_t& ch) {
 	// Copy the image data out of the page texture.
 	core::dimension2du glyph_size(glyph.source_rect.getSize());
 	video::IImage* image = Driver->createImage(format, glyph_size);
-	pageholder->copyTo(image, core::position2di(0, 0), glyph.source_rect);
+	pageholder->copyTo(image, irr::core::vector2di(0, 0), glyph.source_rect);
 
 	tex->unlock();
 	return image;
@@ -854,17 +854,14 @@ void CGUITTFont::createSharedPlane() {
 		0---1
 	*/
 
-	using namespace core;
-	using namespace video;
-	using namespace scene;
-	S3DVertex vertices[4];
+	video::S3DVertex vertices[4];
 	u16 indices[6] = {0, 2, 3, 3, 1, 0};
-	vertices[0] = S3DVertex(vector3df(0, -1, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(0, 1));
-	vertices[1] = S3DVertex(vector3df(1, -1, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(1, 1));
-	vertices[2] = S3DVertex(vector3df(0, 0, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(0, 0));
-	vertices[3] = S3DVertex(vector3df(1, 0, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(1, 0));
+	vertices[0] = video::S3DVertex(core::vector3df(0, -1, 0), core::vector3df(0, 0, -1), video::SColor(255, 255, 255, 255), core::vector2df(0, 1));
+	vertices[1] = video::S3DVertex(core::vector3df(1, -1, 0), core::vector3df(0, 0, -1), video::SColor(255, 255, 255, 255), core::vector2df(1, 1));
+	vertices[2] = video::S3DVertex(core::vector3df(0, 0, 0), core::vector3df(0, 0, -1), video::SColor(255, 255, 255, 255), core::vector2df(0, 0));
+	vertices[3] = video::S3DVertex(core::vector3df(1, 0, 0), core::vector3df(0, 0, -1), video::SColor(255, 255, 255, 255), core::vector2df(1, 0));
 
-	SMeshBuffer* buf = new SMeshBuffer();
+	scene::SMeshBuffer* buf = new scene::SMeshBuffer();
 	buf->append(vertices, 4, indices, 6);
 
 	shared_plane_.addMeshBuffer( buf );
@@ -882,11 +879,7 @@ core::dimension2d<u32> CGUITTFont::getDimensionUntilEndOfLine(const wchar_t* p)
 }
 
 core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text, scene::ISceneManager* smgr, scene::ISceneNode* parent, const video::SColor& color, bool center) {
-	using namespace core;
-	using namespace video;
-	using namespace scene;
-
-	array<scene::ISceneNode*> container;
+	core::array<scene::ISceneNode*> container;
 
 	if (!Driver || !smgr) return container;
 	if (!parent)
@@ -897,8 +890,8 @@ core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text
 	if (!shared_plane_ptr_) //this points to a static mesh that contains the plane
 		createSharedPlane(); //if it's not initialized, we create one.
 
-	dimension2d<s32> text_size(getDimension(text)); //convert from unsigned to signed.
-	vector3df start_point(0, 0, 0), offset;
+	core::dimension2d<s32> text_size(getDimension(text)); //convert from unsigned to signed.
+	core::vector3df start_point(0, 0, 0), offset;
 
 	/** NOTICE:
 		Because we are considering adding texts into 3D world, all Y axis vectors are inverted.
@@ -912,7 +905,7 @@ core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text
 	}
 
 	// the default font material
-	SMaterial mat;
+	video::SMaterial mat;
 	mat.setFlag(video::EMF_LIGHTING, true);
 	mat.setFlag(video::EMF_ZWRITE_ENABLE, false);
 	mat.setFlag(video::EMF_NORMALIZE_NORMALS, true);
@@ -924,7 +917,7 @@ core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text
 	wchar_t current_char = 0, previous_char = 0;
 	u32 n = 0;
 
-	array<u32> glyph_indices;
+	core::array<u32> glyph_indices;
 
 	while (*text) {
 		current_char = *text;
@@ -957,23 +950,23 @@ core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text
 				s32 offy = (font_metrics.ascender / 64) - glyph.offset.Y;
 
 				// Apply kerning.
-				vector2di k = getKerning(current_char, previous_char);
+				core::vector2di k = getKerning(current_char, previous_char);
 				offset.X += k.X;
 				offset.Y += k.Y;
 
-				vector3df current_pos(offset.X + offx, offset.Y - offy, 0);
-				dimension2d<u32> letter_size = dimension2d<u32>(texw, texh);
+				core::vector3df current_pos(offset.X + offx, offset.Y - offy, 0);
+				core::dimension2d<u32> letter_size = core::dimension2d<u32>(texw, texh);
 
 				// Now we copy planes corresponding to the letter size.
-				IMeshManipulator* mani = smgr->getMeshManipulator();
-				IMesh* meshcopy = mani->createMeshCopy(shared_plane_ptr_);
-				mani->scale(meshcopy, vector3df((f32)letter_size.Width, (f32)letter_size.Height, 1));
+				scene::IMeshManipulator* mani = smgr->getMeshManipulator();
+				scene::IMesh* meshcopy = mani->createMeshCopy(shared_plane_ptr_);
+				mani->scale(meshcopy, core::vector3df((f32)letter_size.Width, (f32)letter_size.Height, 1));
 
-				ISceneNode* current_node = smgr->addMeshSceneNode(meshcopy, parent, -1, current_pos);
+				scene::ISceneNode* current_node = smgr->addMeshSceneNode(meshcopy, parent, -1, current_pos);
 				meshcopy->drop();
 
 				current_node->getMaterial(0) = mat;
-				current_node->setAutomaticCulling(EAC_OFF);
+				current_node->setAutomaticCulling(scene::EAC_OFF);
 				current_node->setIsDebugObject(true);  //so the picking won't have any effect on individual letter
 				//current_node->setDebugDataVisible(EDS_BBOX); //de-comment this when debugging
 
@@ -991,7 +984,7 @@ core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text
 	for (u32 i = 0; i < glyph_indices.size(); ++i) {
 		u32 n = glyph_indices[i];
 		SGUITTGlyph const& glyph = Glyphs[n - 1];
-		ITexture* current_tex = Glyph_Pages[glyph.glyph_page]->texture;
+		video::ITexture* current_tex = Glyph_Pages[glyph.glyph_page]->texture;
 		f32 page_texture_size = (f32)current_tex->getSize().Width;
 		//Now we calculate the UV position according to the texture size and the source rect.
 		//
@@ -1007,15 +1000,15 @@ core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text
 		f32 v2 = v1 + (glyph.source_rect.getHeight() / page_texture_size);
 
 		//we can be quite sure that this is IMeshSceneNode, because we just added them in the above loop.
-		IMeshSceneNode* node = static_cast<IMeshSceneNode*>(container[i]);
+		scene::IMeshSceneNode* node = static_cast<scene::IMeshSceneNode*>(container[i]);
 
-		S3DVertex* pv = static_cast<S3DVertex*>(node->getMesh()->getMeshBuffer(0)->getVertices());
+		video::S3DVertex* pv = static_cast<video::S3DVertex*>(node->getMesh()->getMeshBuffer(0)->getVertices());
 		//pv[0].TCoords.Y = pv[1].TCoords.Y = (letter_size.Height - 1) / static_cast<f32>(letter_size.Height);
 		//pv[1].TCoords.X = pv[3].TCoords.X = (letter_size.Width - 1)  / static_cast<f32>(letter_size.Width);
-		pv[0].TCoords = vector2df(u1, v2);
-		pv[1].TCoords = vector2df(u2, v2);
-		pv[2].TCoords = vector2df(u1, v1);
-		pv[3].TCoords = vector2df(u2, v1);
+		pv[0].TCoords = core::vector2df(u1, v2);
+		pv[1].TCoords = core::vector2df(u2, v2);
+		pv[2].TCoords = core::vector2df(u1, v1);
+		pv[3].TCoords = core::vector2df(u2, v1);
 
 		container[i]->getMaterial(0).setTexture(0, current_tex);
 	}

gframe/client_card.cpp

@@ -56,7 +56,7 @@ void ClientCard::UpdateInfo(unsigned char* buf) {
 	}
 	if(flag & QUERY_POSITION) {
 		int pdata = (BufferIO::ReadInt32(buf) >> 24) & 0xff;
-		if((location & (LOCATION_EXTRA | LOCATION_REMOVED)) && (u8)pdata != position) {
+		if((location & (LOCATION_EXTRA | LOCATION_REMOVED)) && pdata != position) {
 			position = pdata;
 			mainGame->dField.MoveCard(this, 1);
 		} else

gframe/client_card.h

@@ -15,9 +15,9 @@ public:
 	irr::core::vector3df curRot;
 	irr::core::vector3df dPos;
 	irr::core::vector3df dRot;
-	u32 curAlpha{ 255 };
-	u32 dAlpha{ 0 };
-	u32 aniFrame{ 0 };
+	irr::u32 curAlpha{ 255 };
+	irr::u32 dAlpha{ 0 };
+	irr::u32 aniFrame{ 0 };
 	bool is_moving{ false };
 	bool is_fading{ false };
 	bool is_hovered{ false };

gframe/client_field.h

@@ -96,6 +96,7 @@ public:
 	~ClientField();
 	void Clear();
 	void Initial(int player, int deckc, int extrac);
+	void ResetSequence(std::vector<ClientCard*>& list, bool reset_height);
 	ClientCard* GetCard(int controler, int location, int sequence, int sub_seq = 0);
 	void AddCard(ClientCard* pcard, int controler, int location, int sequence);
 	ClientCard* RemoveCard(int controler, int location, int sequence);

gframe/config.h

@@ -3,6 +3,9 @@
 
 #define _IRR_STATIC_LIB_
 #define IRR_COMPILE_WITH_DX9_DEV_PACK
+
+#include <cerrno>
+
 #ifdef _WIN32
 
 #define NOMINMAX
@@ -22,7 +25,6 @@
 
 #else //_WIN32
 
-#include <errno.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
@@ -44,7 +46,7 @@
 #endif
 
 #include <cstdio>
-#include <stdlib.h>
+#include <cstdlib>
 #include <iostream>
 #include <algorithm>
 #include <string>
@@ -71,12 +73,6 @@ inline FILE* mywfopen(const wchar_t* filename, const char* mode) {
 }
 
 #include <irrlicht.h>
-using namespace irr;
-using namespace core;
-using namespace scene;
-using namespace video;
-using namespace io;
-using namespace gui;
 
 extern const unsigned short PRO_VERSION;
 extern unsigned int enable_log;

gframe/data_manager.cpp

@@ -13,23 +13,21 @@ DataManager::DataManager() : _datas(32768), _strings(32768) {
 	extra_setcode = { {8512558u, {0x8f, 0x54, 0x59, 0x82, 0x13a}}, };
 }
 bool DataManager::ReadDB(sqlite3* pDB) {
-	sqlite3_stmt* pStmt{};
+	sqlite3_stmt* pStmt = nullptr;
 	const char* sql = "select * from datas,texts where datas.id=texts.id";
 	if (sqlite3_prepare_v2(pDB, sql, -1, &pStmt, 0) != SQLITE_OK)
-		return Error(pDB);
+		return Error(pDB, pStmt);
 	wchar_t strBuffer[4096];
 	int step = 0;
 	do {
 		CardDataC cd;
 		CardString cs;
 		step = sqlite3_step(pStmt);
-		if (step == SQLITE_BUSY || step == SQLITE_ERROR || step == SQLITE_MISUSE)
-			return Error(pDB, pStmt);
-		else if (step == SQLITE_ROW) {
+		if (step == SQLITE_ROW) {
 			cd.code = sqlite3_column_int(pStmt, 0);
 			cd.ot = sqlite3_column_int(pStmt, 1);
 			cd.alias = sqlite3_column_int(pStmt, 2);
-			auto setcode = sqlite3_column_int64(pStmt, 3);
+			uint64_t setcode = static_cast<uint64_t>(sqlite3_column_int64(pStmt, 3));
 			if (setcode) {
 				auto it = extra_setcode.find(cd.code);
 				if (it != extra_setcode.end()) {
@@ -42,7 +40,7 @@ bool DataManager::ReadDB(sqlite3* pDB) {
 				else
 					cd.set_setcode(setcode);
 			}
-			cd.type = sqlite3_column_int(pStmt, 4);
+			cd.type = static_cast<decltype(cd.type)>(sqlite3_column_int64(pStmt, 4));
 			cd.attack = sqlite3_column_int(pStmt, 5);
 			cd.defense = sqlite3_column_int(pStmt, 6);
 			if (cd.type & TYPE_LINK) {
@@ -51,13 +49,13 @@ bool DataManager::ReadDB(sqlite3* pDB) {
 			}
 			else
 				cd.link_marker = 0;
-			unsigned int level = sqlite3_column_int(pStmt, 7);
+			uint32_t level = static_cast<uint32_t>(sqlite3_column_int(pStmt, 7));
 			cd.level = level & 0xff;
 			cd.lscale = (level >> 24) & 0xff;
 			cd.rscale = (level >> 16) & 0xff;
-			cd.race = sqlite3_column_int(pStmt, 8);
-			cd.attribute = sqlite3_column_int(pStmt, 9);
-			cd.category = sqlite3_column_int(pStmt, 10);
+			cd.race = static_cast<decltype(cd.race)>(sqlite3_column_int64(pStmt, 8));
+			cd.attribute = static_cast<decltype(cd.attribute)>(sqlite3_column_int64(pStmt, 9));
+			cd.category = static_cast<decltype(cd.category)>(sqlite3_column_int64(pStmt, 10));
 			_datas[cd.code] = cd;
 			if (const char* text = (const char*)sqlite3_column_text(pStmt, 12)) {
 				BufferIO::DecodeUTF8(text, strBuffer);
@@ -76,7 +74,9 @@ bool DataManager::ReadDB(sqlite3* pDB) {
 			}
 			_strings[cd.code] = cs;
 		}
-	} while (step != SQLITE_DONE);
+		else if (step != SQLITE_DONE)
+			return Error(pDB, pStmt);
+	} while (step == SQLITE_ROW);
 	sqlite3_finalize(pStmt);
 	return true;
 }
@@ -84,17 +84,17 @@ bool DataManager::LoadDB(const wchar_t* wfile) {
 	char file[256];
 	BufferIO::EncodeUTF8(wfile, file);
 #ifdef _WIN32
-	IReadFile* reader = FileSystem->createAndOpenFile(wfile);
+	auto reader = FileSystem->createAndOpenFile(wfile);
 #else
-	IReadFile* reader = FileSystem->createAndOpenFile(file);
+	auto reader = FileSystem->createAndOpenFile(file);
 #endif
 	if(reader == nullptr)
 		return false;
 	spmemvfs_db_t db;
-	spmembuffer_t* mem = (spmembuffer_t*)calloc(sizeof(spmembuffer_t), 1);
+	spmembuffer_t* mem = (spmembuffer_t*)std::calloc(sizeof(spmembuffer_t), 1);
 	spmemvfs_env_init();
 	mem->total = mem->used = reader->getSize();
-	mem->data = (char*)malloc(mem->total + 1);
+	mem->data = (char*)std::malloc(mem->total + 1);
 	reader->read(mem->data, mem->total);
 	reader->drop();
 	(mem->data)[mem->total] = '\0';
@@ -417,9 +417,9 @@ unsigned char* DataManager::ReadScriptFromIrrFS(const char* script_name, int* sl
 #ifdef _WIN32
 	wchar_t fname[256]{};
 	BufferIO::DecodeUTF8(script_name, fname);
-	IReadFile* reader = FileSystem->createAndOpenFile(fname);
+	auto reader = FileSystem->createAndOpenFile(fname);
 #else
-	IReadFile* reader = FileSystem->createAndOpenFile(script_name);
+	auto reader = FileSystem->createAndOpenFile(script_name);
 #endif
 	if (!reader)
 		return nullptr;
@@ -431,7 +431,9 @@ unsigned char* DataManager::ReadScriptFromIrrFS(const char* script_name, int* sl
 	return scriptBuffer;
 }
 unsigned char* DataManager::ReadScriptFromFile(const char* script_name, int* slen) {
-	FILE* fp = std::fopen(script_name, "rb");
+	wchar_t fname[256]{};
+	BufferIO::DecodeUTF8(script_name, fname);
+	FILE* fp = mywfopen(fname, "rb");
 	if (!fp)
 		return nullptr;
 	size_t len = std::fread(scriptBuffer, 1, sizeof scriptBuffer, fp);

gframe/deck_con.cpp

@@ -69,7 +69,18 @@ void DeckBuilder::Initialize() {
 	mainGame->btnSideShuffle->setVisible(false);
 	mainGame->btnSideSort->setVisible(false);
 	mainGame->btnSideReload->setVisible(false);
-	filterList = &deckManager._lfList[mainGame->gameConf.use_lflist ? mainGame->gameConf.default_lflist : deckManager._lfList.size() - 1].content;
+	if (mainGame->gameConf.use_lflist) {
+		if (mainGame->gameConf.default_lflist >= 0 && mainGame->gameConf.default_lflist < (int)deckManager._lfList.size()) {
+			filterList = &deckManager._lfList[mainGame->gameConf.default_lflist];
+		}
+		else {
+			mainGame->gameConf.default_lflist = 0;
+			filterList = &deckManager._lfList.front();
+		}
+	}
+	else {
+		filterList = &deckManager._lfList.back();
+	}
 	ClearSearch();
 	rnd.reset((uint_fast32_t)std::time(nullptr));
 	mouse_pos.set(0, 0);
@@ -126,7 +137,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 		return false;
 	switch(event.EventType) {
 	case irr::EET_GUI_EVENT: {
-		s32 id = event.GUIEvent.Caller->getID();
+		irr::s32 id = event.GUIEvent.Caller->getID();
 		if(((mainGame->wCategories->isVisible() && id != BUTTON_CATEGORY_OK) ||
 			(mainGame->wQuery->isVisible() && id != BUTTON_YES && id != BUTTON_NO) ||
 			(mainGame->wLinkMarks->isVisible() && id != BUTTON_MARKERS_OK) ||
@@ -1224,7 +1235,7 @@ void DeckBuilder::GetHoveredCard() {
 	irr::gui::IGUIElement* root = mainGame->env->getRootGUIElement();
 	if(root->getElementFromPoint(mouse_pos) != root)
 		return;
-	position2di pos = mainGame->ResizeReverse(mouse_pos.X, mouse_pos.Y);
+	irr::core::vector2di pos = mainGame->ResizeReverse(mouse_pos.X, mouse_pos.Y);
 	int x = pos.X;
 	int y = pos.Y;
 	is_lastcard = 0;
@@ -1480,7 +1491,7 @@ void DeckBuilder::FilterCards() {
 		if(filter_marks && (data.link_marker & filter_marks) != filter_marks)
 			continue;
 		if(filter_lm) {
-			if(filter_lm <= 3 && (!filterList->count(ptr->first) || (*filterList).at(ptr->first) != filter_lm - 1))
+			if(filter_lm <= 3 && (!filterList->content.count(ptr->first) || filterList->content.at(ptr->first) != filter_lm - 1))
 				continue;
 			if(filter_lm == 4 && !(data.ot & AVAIL_OCG))
 				continue;
@@ -1669,13 +1680,13 @@ void DeckBuilder::ShowDeckManage() {
 void DeckBuilder::ShowBigCard(int code, float zoom) {
 	bigcard_code = code;
 	bigcard_zoom = zoom;
-	ITexture* img = imageManager.GetBigPicture(code, zoom);
+	auto img = imageManager.GetBigPicture(code, zoom);
 	mainGame->imgBigCard->setImage(img);
 	auto size = img->getSize();
-	s32 left = mainGame->window_size.Width / 2 - size.Width / 2;
-	s32 top = mainGame->window_size.Height / 2 - size.Height / 2;
-	mainGame->imgBigCard->setRelativePosition(recti(0, 0, size.Width, size.Height));
-	mainGame->wBigCard->setRelativePosition(recti(left, top, left + size.Width, top + size.Height));
+	irr::s32 left = mainGame->window_size.Width / 2 - size.Width / 2;
+	irr::s32 top = mainGame->window_size.Height / 2 - size.Height / 2;
+	mainGame->imgBigCard->setRelativePosition(irr::core::recti(0, 0, size.Width, size.Height));
+	mainGame->wBigCard->setRelativePosition(irr::core::recti(left, top, left + size.Width, top + size.Height));
 	mainGame->gMutex.lock();
 	mainGame->btnBigCardOriginalSize->setVisible(true);
 	mainGame->btnBigCardZoomIn->setVisible(true);
@@ -1685,12 +1696,12 @@ void DeckBuilder::ShowBigCard(int code, float zoom) {
 	mainGame->env->getRootGUIElement()->bringToFront(mainGame->wBigCard);
 	mainGame->gMutex.unlock();
 }
-void DeckBuilder::ZoomBigCard(s32 centerx, s32 centery) {
+void DeckBuilder::ZoomBigCard(irr::s32 centerx, irr::s32 centery) {
 	if(bigcard_zoom >= 4)
 		bigcard_zoom = 4;
 	if(bigcard_zoom <= 0.2f)
 		bigcard_zoom = 0.2f;
-	ITexture* img = imageManager.GetBigPicture(bigcard_code, bigcard_zoom);
+	auto img = imageManager.GetBigPicture(bigcard_code, bigcard_zoom);
 	mainGame->imgBigCard->setImage(img);
 	auto size = img->getSize();
 	auto pos = mainGame->wBigCard->getRelativePosition();
@@ -1700,10 +1711,10 @@ void DeckBuilder::ZoomBigCard(s32 centerx, s32 centery) {
 	}
 	float posx = (float)(centerx - pos.UpperLeftCorner.X) / pos.getWidth();
 	float posy = (float)(centery - pos.UpperLeftCorner.Y) / pos.getHeight();
-	s32 left = centerx - size.Width * posx;
-	s32 top = centery - size.Height * posy;
-	mainGame->imgBigCard->setRelativePosition(recti(0, 0, size.Width, size.Height));
-	mainGame->wBigCard->setRelativePosition(recti(left, top, left + size.Width, top + size.Height));
+	irr::s32 left = centerx - size.Width * posx;
+	irr::s32 top = centery - size.Height * posy;
+	mainGame->imgBigCard->setRelativePosition(irr::core::recti(0, 0, size.Width, size.Height));
+	mainGame->wBigCard->setRelativePosition(irr::core::recti(left, top, left + size.Width, top + size.Height));
 }
 void DeckBuilder::CloseBigCard() {
 	mainGame->HideElement(mainGame->wBigCard);
@@ -1822,8 +1833,8 @@ void DeckBuilder::pop_side(int seq) {
 bool DeckBuilder::check_limit(code_pointer pointer) {
 	unsigned int limitcode = pointer->second.alias ? pointer->second.alias : pointer->first;
 	int limit = 3;
-	auto flit = filterList->find(limitcode);
-	if(flit != filterList->end())
+	auto flit = filterList->content.find(limitcode);
+	if(flit != filterList->content.end())
 		limit = flit->second;
 	for(auto it = deckManager.current_deck.main.begin(); it != deckManager.current_deck.main.end(); ++it) {
 		if((*it)->first == limitcode || (*it)->second.alias == limitcode)

gframe/deck_con.h

 #ifndef DECK_CON_H
 #define DECK_CON_H
 
-#include "config.h"
 #include <unordered_map>
 #include <vector>
+#include <irrlicht.h>
 #include "data_manager.h"
+#include "deck_manager.h"
 #include "../ocgcore/mtrandom.h"
 
 namespace ygo {
@@ -28,7 +29,7 @@ public:
 	void ChangeCategory(int catesel);
 	void ShowDeckManage();
 	void ShowBigCard(int code, float zoom);
-	void ZoomBigCard(s32 centerx = -1, s32 centery = -1);
+	void ZoomBigCard(irr::s32 centerx = -1, irr::s32 centery = -1);
 	void CloseBigCard();
 
 	bool CardNameContains(const wchar_t *haystack, const wchar_t *needle);
@@ -56,7 +57,7 @@ public:
 	unsigned int filter_scl{};
 	unsigned int filter_marks{};
 	int filter_lm{};
-	position2di mouse_pos;
+	irr::core::vector2di mouse_pos;
 	int hovered_code{};
 	int hovered_pos{};
 	int hovered_seq{ -1 };
@@ -74,14 +75,14 @@ public:
 	code_pointer draging_pointer;
 	int prev_category{};
 	int prev_deck{};
-	s32 prev_operation{};
+	irr::s32 prev_operation{};
 	int prev_sel{ -1 };
 	bool is_modified{};
 	bool readonly{};
 	bool showing_pack{};
 	mt19937 rnd;
 
-	const std::unordered_map<int, int>* filterList;
+	const LFList* filterList{};
 	std::vector<code_pointer> results;
 	wchar_t result_string[8]{};
 	std::vector<std::wstring> expansionPacks;

gframe/deck_manager.cpp

@@ -14,7 +14,7 @@ void DeckManager::LoadLFListSingle(const char* path) {
 	char linebuf[256]{};
 	wchar_t strBuffer[256]{};
 	if(fp) {
-		while(std::fgets(linebuf, 256, fp)) {
+		while(std::fgets(linebuf, sizeof linebuf, fp)) {
 			if(linebuf[0] == '#')
 				continue;
 			if(linebuf[0] == '!') {
@@ -28,19 +28,16 @@ void DeckManager::LoadLFListSingle(const char* path) {
 				cur = _lfList.rbegin();
 				continue;
 			}
-			int code = 0;
-			int count = -1;
-			if (std::sscanf(linebuf, "%d %d", &code, &count) != 2)
+			if (cur == _lfList.rend())
 				continue;
-			if (code <= 0 || code > MAX_CARD_ID)
+			unsigned int code = 0;
+			int count = -1;
+			if (std::sscanf(linebuf, "%9u%*[ ]%9d", &code, &count) != 2)
 				continue;
 			if (count < 0 || count > 2)
 				continue;
-			if (cur == _lfList.rend())
-				continue;
-			unsigned int hcode = code;
 			cur->content[code] = count;
-			cur->hash = cur->hash ^ ((hcode << 18) | (hcode >> 14)) ^ ((hcode << (27 + count)) | (hcode >> (5 - count)));
+			cur->hash = cur->hash ^ ((code << 18) | (code >> 14)) ^ ((code << (27 + count)) | (code >> (5 - count)));
 		}
 		std::fclose(fp);
 	}
@@ -53,7 +50,7 @@ void DeckManager::LoadLFList() {
 	nolimit.hash = 0;
 	_lfList.push_back(nolimit);
 }
-const wchar_t* DeckManager::GetLFListName(int lfhash) {
+const wchar_t* DeckManager::GetLFListName(unsigned int lfhash) {
 	auto lit = std::find_if(_lfList.begin(), _lfList.end(), [lfhash](const ygo::LFList& list) {
 		return list.hash == lfhash;
 	});
@@ -61,12 +58,12 @@ const wchar_t* DeckManager::GetLFListName(int lfhash) {
 		return lit->listName.c_str();
 	return dataManager.unknown_string;
 }
-const std::unordered_map<int, int>* DeckManager::GetLFListContent(int lfhash) {
+const LFList* DeckManager::GetLFList(unsigned int lfhash) {
 	auto lit = std::find_if(_lfList.begin(), _lfList.end(), [lfhash](const ygo::LFList& list) {
 		return list.hash == lfhash;
 	});
-	if(lit != _lfList.end())
-		return &lit->content;
+	if (lit != _lfList.end())
+		return &(*lit);
 	return nullptr;
 }
 static unsigned int checkAvail(unsigned int ot, unsigned int avail) {
@@ -87,9 +84,10 @@ unsigned int DeckManager::CheckDeck(Deck& deck, int lfhash, int rule) {
 		return (DECKERROR_EXTRACOUNT << 28) | (unsigned)deck.extra.size();
 	if(deck.side.size() > SIDE_MAX_SIZE)
 		return (DECKERROR_SIDECOUNT << 28) | (unsigned)deck.side.size();
-	auto list = GetLFListContent(lfhash);
-	if (!list)
+	auto lflist = GetLFList(lfhash);
+	if (!lflist)
 		return 0;
+	auto& list = lflist->content;
 	const unsigned int rule_map[6] = { AVAIL_OCG, AVAIL_TCG, AVAIL_SC, AVAIL_CUSTOM, AVAIL_OCGTCG, 0 };
 	unsigned int avail = 0;
 	if (rule >= 0 && rule < (int)(sizeof rule_map / sizeof rule_map[0]))
@@ -105,8 +103,8 @@ unsigned int DeckManager::CheckDeck(Deck& deck, int lfhash, int rule) {
 		int dc = ccount[code];
 		if(dc > 3)
 			return (DECKERROR_CARDCOUNT << 28) | cit->first;
-		auto it = list->find(code);
-		if(it != list->end() && dc > it->second)
+		auto it = list.find(code);
+		if(it != list.end() && dc > it->second)
 			return (DECKERROR_LFLIST << 28) | cit->first;
 	}
 	for (auto& cit : deck.extra) {
@@ -120,8 +118,8 @@ unsigned int DeckManager::CheckDeck(Deck& deck, int lfhash, int rule) {
 		int dc = ccount[code];
 		if(dc > 3)
 			return (DECKERROR_CARDCOUNT << 28) | cit->first;
-		auto it = list->find(code);
-		if(it != list->end() && dc > it->second)
+		auto it = list.find(code);
+		if(it != list.end() && dc > it->second)
 			return (DECKERROR_LFLIST << 28) | cit->first;
 	}
 	for (auto& cit : deck.side) {
@@ -135,8 +133,8 @@ unsigned int DeckManager::CheckDeck(Deck& deck, int lfhash, int rule) {
 		int dc = ccount[code];
 		if(dc > 3)
 			return (DECKERROR_CARDCOUNT << 28) | cit->first;
-		auto it = list->find(code);
-		if(it != list->end() && dc > it->second)
+		auto it = list.find(code);
+		if(it != list.end() && dc > it->second)
 			return (DECKERROR_LFLIST << 28) | cit->first;
 	}
 	return 0;
@@ -185,25 +183,29 @@ int DeckManager::LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec, bool is_p
 	return errorcode;
 }
 int DeckManager::LoadDeck(Deck& deck, std::istringstream& deckStream, bool is_packlist) {
-	int ct = 0, mainc = 0, sidec = 0, code = 0;
+	size_t ct = 0;
+	int mainc = 0, sidec = 0, code = 0;
 	int cardlist[PACK_MAX_SIZE]{};
 	bool is_side = false;
 	std::string linebuf;
-	while (std::getline(deckStream, linebuf, '\n') && ct < (int)(sizeof cardlist / sizeof cardlist[0])) {
+	while (std::getline(deckStream, linebuf, '\n') && ct < (sizeof cardlist / sizeof cardlist[0])) {
 		if (linebuf[0] == '!') {
 			is_side = true;
 			continue;
 		}
 		if (linebuf[0] < '0' || linebuf[0] > '9')
 			continue;
-		code = std::stoi(linebuf);
+		errno = 0;
+		code = std::strtol(linebuf.c_str(), nullptr, 10);
+		if (errno == ERANGE)
+			continue;
 		cardlist[ct++] = code;
 		if (is_side)
 			++sidec;
 		else
 			++mainc;
 	}
-	return LoadDeck(current_deck, cardlist, mainc, sidec, is_packlist);
+	return LoadDeck(deck, cardlist, mainc, sidec, is_packlist);
 }
 bool DeckManager::LoadSide(Deck& deck, int* dbuf, int mainc, int sidec) {
 	std::unordered_map<int, int> pcount;
@@ -277,7 +279,7 @@ irr::io::IReadFile* DeckManager::OpenDeckReader(const wchar_t* file) {
 }
 bool DeckManager::LoadCurrentDeck(const wchar_t* file, bool is_packlist) {
 	current_deck.clear();
-	IReadFile* reader = OpenDeckReader(file);
+	auto reader = OpenDeckReader(file);
 	if(!reader) {
 		wchar_t localfile[256];
 		myswprintf(localfile, L"./deck/%ls.ydk", file);

gframe/deck_manager.h

@@ -16,13 +16,13 @@ namespace ygo {
 struct LFList {
 	unsigned int hash{};
 	std::wstring listName;
-	std::unordered_map<int, int> content;
+	std::unordered_map<unsigned int, int> content;
 };
 struct Deck {
 	std::vector<code_pointer> main;
 	std::vector<code_pointer> extra;
 	std::vector<code_pointer> side;
-	Deck() {}
+	Deck() = default;
 	Deck(const Deck& ndeck) {
 		main = ndeck.main;
 		extra = ndeck.extra;
@@ -44,8 +44,8 @@ public:
 
 	void LoadLFListSingle(const char* path);
 	void LoadLFList();
-	const wchar_t* GetLFListName(int lfhash);
-	const std::unordered_map<int, int>* GetLFListContent(int lfhash);
+	const wchar_t* GetLFListName(unsigned int lfhash);
+	const LFList* GetLFList(unsigned int lfhash);
 	unsigned int CheckDeck(Deck& deck, int lfhash, int rule);
 	int LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec, bool is_packlist = false);
 	int LoadDeck(Deck& deck, std::istringstream& deckStream, bool is_packlist = false);

gframe/duelclient.cpp

@@ -500,9 +500,9 @@ void DuelClient::HandleSTOCPacketLan(unsigned char* data, int len) {
 		mainGame->dInfo.time_limit = pkt->info.time_limit;
 		mainGame->dInfo.time_left[0] = 0;
 		mainGame->dInfo.time_left[1] = 0;
-		mainGame->deckBuilder.filterList = deckManager.GetLFListContent(pkt->info.lflist);
+		mainGame->deckBuilder.filterList = deckManager.GetLFList(pkt->info.lflist);
 		if(mainGame->deckBuilder.filterList == nullptr)
-			mainGame->deckBuilder.filterList = &deckManager._lfList[0].content;
+			mainGame->deckBuilder.filterList = &deckManager._lfList[0];
 		mainGame->stHostPrepOB->setText(L"");
 		mainGame->SetStaticText(mainGame->stHostPrepRule, 180, mainGame->guiFont, str.c_str());
 		mainGame->RefreshCategoryDeck(mainGame->cbCategorySelect, mainGame->cbDeckSelect);
@@ -1900,23 +1900,23 @@ bool DuelClient::ClientAnalyze(unsigned char* msg, int len) {
 		else startpos = 155;
 		if(positions & 0x1) {
 			mainGame->imageLoading.insert(std::make_pair(mainGame->btnPSAU, code));
-			mainGame->btnPSAU->setRelativePosition(rect<s32>(startpos, 45, startpos + 140, 185));
+			mainGame->btnPSAU->setRelativePosition(irr::core::rect<irr::s32>(startpos, 45, startpos + 140, 185));
 			mainGame->btnPSAU->setVisible(true);
 			startpos += 145;
 		} else mainGame->btnPSAU->setVisible(false);
 		if(positions & 0x2) {
-			mainGame->btnPSAD->setRelativePosition(rect<s32>(startpos, 45, startpos + 140, 185));
+			mainGame->btnPSAD->setRelativePosition(irr::core::rect<irr::s32>(startpos, 45, startpos + 140, 185));
 			mainGame->btnPSAD->setVisible(true);
 			startpos += 145;
 		} else mainGame->btnPSAD->setVisible(false);
 		if(positions & 0x4) {
 			mainGame->imageLoading.insert(std::make_pair(mainGame->btnPSDU, code));
-			mainGame->btnPSDU->setRelativePosition(rect<s32>(startpos, 45, startpos + 140, 185));
+			mainGame->btnPSDU->setRelativePosition(irr::core::rect<irr::s32>(startpos, 45, startpos + 140, 185));
 			mainGame->btnPSDU->setVisible(true);
 			startpos += 145;
 		} else mainGame->btnPSDU->setVisible(false);
 		if(positions & 0x8) {
-			mainGame->btnPSDD->setRelativePosition(rect<s32>(startpos, 45, startpos + 140, 185));
+			mainGame->btnPSDD->setRelativePosition(irr::core::rect<irr::s32>(startpos, 45, startpos + 140, 185));
 			mainGame->btnPSDD->setVisible(true);
 			startpos += 145;
 		} else mainGame->btnPSDD->setVisible(false);
@@ -3428,11 +3428,11 @@ bool DuelClient::ClientAnalyze(unsigned char* msg, int len) {
 			float xd = mainGame->dField.attack_target->curPos.X;
 			float yd = mainGame->dField.attack_target->curPos.Y;
 			sy = (float)sqrt((xa - xd) * (xa - xd) + (ya - yd) * (ya - yd)) / 2;
-			mainGame->atk_t = vector3df((xa + xd) / 2, (ya + yd) / 2, 0);
+			mainGame->atk_t = irr::core::vector3df((xa + xd) / 2, (ya + yd) / 2, 0);
 			if (ca == 0)
-				mainGame->atk_r = vector3df(0, 0, -atan((xd - xa) / (yd - ya)));
+				mainGame->atk_r = irr::core::vector3df(0, 0, -atan((xd - xa) / (yd - ya)));
 			else
-				mainGame->atk_r = vector3df(0, 0, 3.1415926 - atan((xd - xa) / (yd - ya)));
+				mainGame->atk_r = irr::core::vector3df(0, 0, 3.1415926 - atan((xd - xa) / (yd - ya)));
 		} else {
 			soundManager.PlaySoundEffect(SOUND_DIRECT_ATTACK);
 			myswprintf(event_string, dataManager.GetSysString(1620), dataManager.GetName(mainGame->dField.attacker->code));
@@ -3443,11 +3443,11 @@ bool DuelClient::ClientAnalyze(unsigned char* msg, int len) {
 			if (ca == 0)
 				yd = -3.5f;
 			sy = (float)sqrt((xa - xd) * (xa - xd) + (ya - yd) * (ya - yd)) / 2;
-			mainGame->atk_t = vector3df((xa + xd) / 2, (ya + yd) / 2, 0);
+			mainGame->atk_t = irr::core::vector3df((xa + xd) / 2, (ya + yd) / 2, 0);
 			if (ca == 0)
-				mainGame->atk_r = vector3df(0, 0, -atan((xd - xa) / (yd - ya)));
+				mainGame->atk_r = irr::core::vector3df(0, 0, -atan((xd - xa) / (yd - ya)));
 			else
-				mainGame->atk_r = vector3df(0, 0, 3.1415926 - atan((xd - xa) / (yd - ya)));
+				mainGame->atk_r = irr::core::vector3df(0, 0, 3.1415926 - atan((xd - xa) / (yd - ya)));
 		}
 		matManager.GenArrow(sy);
 		mainGame->attack_sv = 0;
@@ -3672,9 +3672,9 @@ bool DuelClient::ClientAnalyze(unsigned char* msg, int len) {
 		mainGame->cbANNumber->setSelected(0);
 		if(quickmode) {
 			mainGame->cbANNumber->setVisible(false);
-			mainGame->btnANNumberOK->setRelativePosition(rect<s32>(20, 195, 210, 230));
+			mainGame->btnANNumberOK->setRelativePosition(irr::core::rect<irr::s32>(20, 195, 210, 230));
 			mainGame->btnANNumberOK->setEnabled(false);
-			recti pos = mainGame->wANNumber->getRelativePosition();
+			irr::core::recti pos = mainGame->wANNumber->getRelativePosition();
 			pos.LowerRightCorner.Y = pos.UpperLeftCorner.Y + 250;
 			mainGame->wANNumber->setRelativePosition(pos);
 		} else {
@@ -3682,8 +3682,8 @@ bool DuelClient::ClientAnalyze(unsigned char* msg, int len) {
 				mainGame->btnANNumber[i]->setVisible(false);
 			}
 			mainGame->cbANNumber->setVisible(true);
-			mainGame->btnANNumberOK->setRelativePosition(rect<s32>(80, 60, 150, 85));
-			recti pos = mainGame->wANNumber->getRelativePosition();
+			mainGame->btnANNumberOK->setRelativePosition(irr::core::rect<irr::s32>(80, 60, 150, 85));
+			irr::core::recti pos = mainGame->wANNumber->getRelativePosition();
 			pos.LowerRightCorner.Y = pos.UpperLeftCorner.Y + 95;
 			mainGame->wANNumber->setRelativePosition(pos);
 		}

gframe/duelclient.h

@@ -53,7 +53,7 @@ public:
 		bufferevent_write(client_bev, duel_client_write, 3);
 	}
 	template<typename ST>
-	static void SendPacketToServer(unsigned char proto, ST& st) {
+	static void SendPacketToServer(unsigned char proto, const ST& st) {
 		auto p = duel_client_write;
 		if (sizeof(ST) > MAX_DATA_SIZE)
 			return;

gframe/game.h

@@ -29,6 +29,7 @@ constexpr int TEXT_LINE_SIZE = 256;
 namespace ygo {
 
 bool IsExtension(const wchar_t* filename, const wchar_t* extension);
+bool IsExtension(const char* filename, const char* extension);
 
 struct Config {
 	bool use_d3d{ false };
@@ -143,9 +144,9 @@ class Game {
 public:
 	bool Initialize();
 	void MainLoop();
-	void BuildProjectionMatrix(irr::core::matrix4& mProjection, f32 left, f32 right, f32 bottom, f32 top, f32 znear, f32 zfar);
-	void InitStaticText(irr::gui::IGUIStaticText* pControl, u32 cWidth, u32 cHeight, irr::gui::CGUITTFont* font, const wchar_t* text);
-	std::wstring SetStaticText(irr::gui::IGUIStaticText* pControl, u32 cWidth, irr::gui::CGUITTFont* font, const wchar_t* text, u32 pos = 0);
+	void BuildProjectionMatrix(irr::core::matrix4& mProjection, irr::f32 left, irr::f32 right, irr::f32 bottom, irr::f32 top, irr::f32 znear, irr::f32 zfar);
+	void InitStaticText(irr::gui::IGUIStaticText* pControl, irr::u32 cWidth, irr::u32 cHeight, irr::gui::CGUITTFont* font, const wchar_t* text);
+	std::wstring SetStaticText(irr::gui::IGUIStaticText* pControl, irr::u32 cWidth, irr::gui::CGUITTFont* font, const wchar_t* text, irr::u32 pos = 0);
 	void LoadExpansions();
 	void RefreshCategoryDeck(irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck, bool selectlastused = true);
 	void RefreshDeck(irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck);
@@ -169,7 +170,7 @@ public:
 	void HideElement(irr::gui::IGUIElement* element, bool set_action = false);
 	void PopupElement(irr::gui::IGUIElement* element, int hideframe = 0);
 	void WaitFrameSignal(int frame);
-	void DrawThumb(code_pointer cp, position2di pos, const std::unordered_map<int,int>* lflist, bool drag = false);
+	void DrawThumb(code_pointer cp, irr::core::vector2di pos, const LFList* lflist, bool drag = false);
 	void DrawDeckBd();
 	void LoadConfig();
 	void SaveConfig();
@@ -190,7 +191,7 @@ public:
 	int ChatLocalPlayer(int player);
 	const wchar_t* LocalName(int local_player);
 
-	bool HasFocus(EGUI_ELEMENT_TYPE type) const {
+	bool HasFocus(irr::gui::EGUI_ELEMENT_TYPE type) const {
 		irr::gui::IGUIElement* focus = env->getFocus();
 		return focus && focus->hasType(type);
 	}
@@ -203,26 +204,26 @@ 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);
-	position2di ResizeReverse(s32 x, s32 y);
-	recti ResizePhaseHint(s32 x, s32 y, s32 x2, s32 y2, s32 width);
-	recti ResizeWin(s32 x, s32 y, s32 x2, s32 y2);
-	recti ResizeCardImgWin(s32 x, s32 y, s32 mx, s32 my);
-	recti ResizeCardHint(s32 x, s32 y, s32 x2, s32 y2);
-	position2di ResizeCardHint(s32 x, s32 y);
-	recti ResizeCardMid(s32 x, s32 y, s32 x2, s32 y2, s32 midx, s32 midy);
-	position2di ResizeCardMid(s32 x, s32 y, s32 midx, s32 midy);
-	recti ResizeFit(s32 x, s32 y, s32 x2, s32 y2);
+	irr::core::recti Resize(irr::s32 x, irr::s32 y, irr::s32 x2, irr::s32 y2);
+	irr::core::recti Resize(irr::s32 x, irr::s32 y, irr::s32 x2, irr::s32 y2, irr::s32 dx, irr::s32 dy, irr::s32 dx2, irr::s32 dy2);
+	irr::core::vector2di Resize(irr::s32 x, irr::s32 y);
+	irr::core::vector2di ResizeReverse(irr::s32 x, irr::s32 y);
+	irr::core::recti ResizePhaseHint(irr::s32 x, irr::s32 y, irr::s32 x2, irr::s32 y2, irr::s32 width);
+	irr::core::recti ResizeWin(irr::s32 x, irr::s32 y, irr::s32 x2, irr::s32 y2);
+	irr::core::recti ResizeCardImgWin(irr::s32 x, irr::s32 y, irr::s32 mx, irr::s32 my);
+	irr::core::recti ResizeCardHint(irr::s32 x, irr::s32 y, irr::s32 x2, irr::s32 y2);
+	irr::core::vector2di ResizeCardHint(irr::s32 x, irr::s32 y);
+	irr::core::recti ResizeCardMid(irr::s32 x, irr::s32 y, irr::s32 x2, irr::s32 y2, irr::s32 midx, irr::s32 midy);
+	irr::core::vector2di ResizeCardMid(irr::s32 x, irr::s32 y, irr::s32 midx, irr::s32 midy);
+	irr::core::recti ResizeFit(irr::s32 x, irr::s32 y, irr::s32 x2, irr::s32 y2);
 
 	void SetWindowsIcon();
 	void SetWindowsScale(float scale);
 	void FlashWindow();
-	void SetCursor(ECURSOR_ICON icon);
+	void SetCursor(irr::gui::ECURSOR_ICON icon);
 	template<typename T>
-	static void DrawShadowText(irr::gui::CGUITTFont* font, const T& text, const core::rect<s32>& position, const core::rect<s32>& padding,
-		video::SColor color = 0xffffffff, video::SColor shadowcolor = 0xff000000, bool hcenter = false, bool vcenter = false, const core::rect<s32>* clip = nullptr);
+	static void DrawShadowText(irr::gui::CGUITTFont* font, const T& text, const irr::core::rect<irr::s32>& position, const irr::core::rect<irr::s32>& padding,
+		irr::video::SColor color = 0xffffffff, irr::video::SColor shadowcolor = 0xff000000, bool hcenter = false, bool vcenter = false, const irr::core::rect<irr::s32>* clip = nullptr);
 
 	std::mutex gMutex;
 	Signal frameSignal;
@@ -239,41 +240,41 @@ public:
 	std::wstring chatMsg[8];
 	std::vector<BotInfo> botInfo;
 
-	int hideChatTimer;
-	bool hideChat;
+	int hideChatTimer{};
+	bool hideChat{};
 	int chatTiming[8]{};
 	int chatType[8]{};
-	unsigned short linePatternD3D;
-	unsigned short linePatternGL;
-	int waitFrame;
-	int signalFrame;
-	int actionParam;
-	int showingcode;
-	const wchar_t* showingtext;
-	int showcard;
-	int showcardcode;
-	int showcarddif;
-	int showcardp;
-	int is_attacking;
-	int attack_sv;
+	unsigned short linePatternD3D{};
+	unsigned short linePatternGL{ 0x0f0f };
+	int waitFrame{};
+	int signalFrame{};
+	int actionParam{};
+	int showingcode{};
+	const wchar_t* showingtext{};
+	int showcard{};
+	int showcardcode{};
+	int showcarddif{};
+	int showcardp{};
+	int is_attacking{};
+	int attack_sv{};
 	irr::core::vector3df atk_r;
 	irr::core::vector3df atk_t;
-	float atkdy;
-	int lpframe;
-	int lpd;
-	int lpplayer;
-	int lpccolor;
+	float atkdy{};
+	int lpframe{};
+	int lpd{};
+	int lpplayer{};
+	int lpccolor{};
 	std::wstring lpcstring;
-	bool always_chain;
-	bool ignore_chain;
-	bool chain_when_avail;
+	bool always_chain{};
+	bool ignore_chain{};
+	bool chain_when_avail{};
 
-	bool is_building;
-	bool is_siding;
+	bool is_building{};
+	bool is_siding{};
 
 	irr::core::dimension2d<irr::u32> window_size;
-	float xScale;
-	float yScale;
+	float xScale{ 1.0f };
+	float yScale{ 1.0f };
 
 	ClientField dField;
 	DeckBuilder deckBuilder;

gframe/gframe.cpp

@@ -2,7 +2,7 @@
 #include "game.h"
 #include "data_manager.h"
 #include <event2/thread.h>
-#include <locale.h>
+#include <clocale>
 #include <memory>
 #ifdef __APPLE__
 #import <CoreFoundation/CoreFoundation.h>
@@ -24,7 +24,7 @@ void ClickButton(irr::gui::IGUIElement* btn) {
 
 int main(int argc, char* argv[]) {
 #ifndef _WIN32
-	setlocale(LC_CTYPE, "UTF-8");
+	std::setlocale(LC_CTYPE, "UTF-8");
 #endif
 #ifdef __APPLE__
 	CFURLRef bundle_url = CFBundleCopyBundleURL(CFBundleGetMainBundle());
@@ -36,17 +36,15 @@ int main(int argc, char* argv[]) {
 	CFRelease(path);
 #endif //__APPLE__
 #ifdef _WIN32
-#ifndef _DEBUG
-	char* pstrext;
-	if(argc == 2 && (pstrext = std::strrchr(argv[1], '.'))
-		&& (!mystrncasecmp(pstrext, ".ydk", 4) || !mystrncasecmp(pstrext, ".yrp", 4))) {
+	if (argc == 2 && (ygo::IsExtension(argv[1], ".ydk") || ygo::IsExtension(argv[1], ".yrp"))) { // open file from explorer
 		wchar_t exepath[MAX_PATH];
 		GetModuleFileNameW(nullptr, exepath, MAX_PATH);
-		wchar_t* p = std::wcsrchr(exepath, '\\');
-		*p = '\0';
-		SetCurrentDirectoryW(exepath);
+		wchar_t* p = std::wcsrchr(exepath, L'\\');
+		if (p) {
+			*p = 0;
+			SetCurrentDirectoryW(exepath);
+		}
 	}
-#endif //_DEBUG
 #endif //_WIN32
 #ifdef _WIN32
 	WORD wVersionRequested;
@@ -63,7 +61,7 @@ int main(int argc, char* argv[]) {
 		return 0;
 
 #ifdef _WIN32
-	int wargc;
+	int wargc = 0;
 	std::unique_ptr<wchar_t*[], void(*)(wchar_t**)> wargv(CommandLineToArgvW(GetCommandLineW(), &wargc), [](wchar_t** wargv) {
 		LocalFree(wargv);
 	});
@@ -78,6 +76,24 @@ int main(int argc, char* argv[]) {
 	bool keep_on_return = false;
 	bool deckCategorySpecified = false;
 	for(int i = 1; i < wargc; ++i) {
+		if (wargc == 2 && std::wcslen(wargv[1]) >= 4) {
+			wchar_t* pstrext = wargv[1] + std::wcslen(wargv[1]) - 4;
+			if (!mywcsncasecmp(pstrext, L".ydk", 4)) {
+				open_file = true;
+				BufferIO::CopyWideString(wargv[1], open_file_name);
+				exit_on_return = true;
+				ClickButton(ygo::mainGame->btnDeckEdit);
+				break;
+			}
+			if (!mywcsncasecmp(pstrext, L".yrp", 4)) {
+				open_file = true;
+				BufferIO::CopyWideString(wargv[1], open_file_name);
+				exit_on_return = true;
+				ClickButton(ygo::mainGame->btnReplayMode);
+				ClickButton(ygo::mainGame->btnLoadReplay);
+				break;
+			}
+		}
 		if(wargv[i][0] == L'-' && wargv[i][1] == L'e' && wargv[i][2] != L'\0') {
 			ygo::dataManager.LoadDB(&wargv[i][2]);
 			continue;
@@ -173,23 +189,6 @@ int main(int argc, char* argv[]) {
 			if(open_file)
 				ClickButton(ygo::mainGame->btnLoadSinglePlay);
 			break;
-		} else if(wargc == 2 && std::wcslen(wargv[1]) >= 4) {
-			wchar_t* pstrext = wargv[1] + std::wcslen(wargv[1]) - 4;
-			if(!mywcsncasecmp(pstrext, L".ydk", 4)) {
-				open_file = true;
-				BufferIO::CopyWideString(wargv[i], open_file_name);
-				exit_on_return = !keep_on_return;
-				ClickButton(ygo::mainGame->btnDeckEdit);
-				break;
-			}
-			if(!mywcsncasecmp(pstrext, L".yrp", 4)) {
-				open_file = true;
-				BufferIO::CopyWideString(wargv[i], open_file_name);
-				exit_on_return = !keep_on_return;
-				ClickButton(ygo::mainGame->btnReplayMode);
-				ClickButton(ygo::mainGame->btnLoadReplay);
-				break;
-			}
 		}
 	}
 	ygo::mainGame->MainLoop();

gframe/image_manager.cpp

@@ -129,7 +129,7 @@ void ImageManager::ResizeTexture() {
 // function by Warr1024, from https://github.com/minetest/minetest/issues/2419 , modified
 void imageScaleNNAA(irr::video::IImage *src, irr::video::IImage *dest) {
 	double sx, sy, minsx, maxsx, minsy, maxsy, area, ra, ga, ba, aa, pw, ph, pa;
-	u32 dy, dx;
+	irr::u32 dy, dx;
 	irr::video::SColor pxl;
 
 	// Cache rectsngle boundaries.
@@ -138,7 +138,7 @@ void imageScaleNNAA(irr::video::IImage *src, irr::video::IImage *dest) {
 
 	// Walk each destination image pixel.
 	// Note: loop y around x for better cache locality.
-	irr::core::dimension2d<u32> dim = dest->getDimension();
+	irr::core::dimension2d<irr::u32> dim = dest->getDimension();
 	for(dy = 0; dy < dim.Height; dy++)
 		for(dx = 0; dx < dim.Width; dx++) {
 
@@ -176,7 +176,7 @@ void imageScaleNNAA(irr::video::IImage *src, irr::video::IImage *dest) {
 
 					// Get source pixel and add it to totals, weighted
 					// by covered area and alpha.
-					pxl = src->getPixel((u32)sx, (u32)sy);
+					pxl = src->getPixel((irr::u32)sx, (irr::u32)sy);
 					area += pa;
 					ra += pa * pxl.getRed();
 					ga += pa * pxl.getGreen();
@@ -199,16 +199,16 @@ void imageScaleNNAA(irr::video::IImage *src, irr::video::IImage *dest) {
 			dest->setPixel(dx, dy, pxl);
 		}
 }
-irr::video::ITexture* ImageManager::GetTextureFromFile(const char* file, s32 width, s32 height) {
+irr::video::ITexture* ImageManager::GetTextureFromFile(const char* file, irr::s32 width, irr::s32 height) {
 	if(mainGame->gameConf.use_image_scale) {
 		irr::video::ITexture* texture;
 		irr::video::IImage* srcimg = driver->createImageFromFile(file);
 		if(srcimg == nullptr)
 			return nullptr;
-		if(srcimg->getDimension() == irr::core::dimension2d<u32>(width, height)) {
+		if(srcimg->getDimension() == irr::core::dimension2d<irr::u32>(width, height)) {
 			texture = driver->addTexture(file, srcimg);
 		} else {
-			video::IImage *destimg = driver->createImage(srcimg->getColorFormat(), irr::core::dimension2d<u32>(width, height));
+			irr::video::IImage *destimg = driver->createImage(srcimg->getColorFormat(), irr::core::dimension2d<irr::u32>(width, height));
 			imageScaleNNAA(srcimg, destimg);
 			texture = driver->addTexture(file, destimg);
 			destimg->drop();
@@ -274,7 +274,7 @@ irr::video::ITexture* ImageManager::GetBigPicture(int code, float zoom) {
 		texture = driver->addTexture(file, srcimg);
 	} else {
 		auto origsize = srcimg->getDimension();
-		video::IImage* destimg = driver->createImage(srcimg->getColorFormat(), irr::core::dimension2d<u32>(origsize.Width * zoom, origsize.Height * zoom));
+		irr::video::IImage* destimg = driver->createImage(srcimg->getColorFormat(), irr::core::dimension2d<irr::u32>(origsize.Width * zoom, origsize.Height * zoom));
 		imageScaleNNAA(srcimg, destimg);
 		texture = driver->addTexture(file, destimg);
 		destimg->drop();
@@ -307,14 +307,14 @@ int ImageManager::LoadThumbThread() {
 		if(img != nullptr) {
 			int width = CARD_THUMB_WIDTH * mainGame->xScale;
 			int height = CARD_THUMB_HEIGHT * mainGame->yScale;
-			if(img->getDimension() == irr::core::dimension2d<u32>(width, height)) {
+			if(img->getDimension() == irr::core::dimension2d<irr::u32>(width, height)) {
 				img->grab();
 				imageManager.tThumbLoadingMutex.lock();
 				if(imageManager.tThumbLoadingThreadRunning)
 					imageManager.tThumbLoading[code] = img;
 				imageManager.tThumbLoadingMutex.unlock();
 			} else {
-				irr::video::IImage *destimg = imageManager.driver->createImage(img->getColorFormat(), irr::core::dimension2d<u32>(width, height));
+				irr::video::IImage *destimg = imageManager.driver->createImage(img->getColorFormat(), irr::core::dimension2d<irr::u32>(width, height));
 				imageScaleNNAA(img, destimg);
 				img->drop();
 				destimg->grab();

gframe/image_manager.h

@@ -16,7 +16,7 @@ public:
 	void ClearTexture();
 	void RemoveTexture(int code);
 	void ResizeTexture();
-	irr::video::ITexture* GetTextureFromFile(const char* file, s32 width, s32 height);
+	irr::video::ITexture* GetTextureFromFile(const char* file, irr::s32 width, irr::s32 height);
 	irr::video::ITexture* GetTexture(int code, bool fit = false);
 	irr::video::ITexture* GetBigPicture(int code, float zoom);
 	irr::video::ITexture* GetTextureThumb(int code);

gframe/lzma/premake5.lua

 project "clzma"
     kind "StaticLib"
+    cdialect "C11"
     files { "*.c", "*.h" }

gframe/materials.h

-#include "config.h"
+#ifndef MATERIALS_H
+#define MATERIALS_H
+
+#include <irrlicht.h>
 
 namespace ygo {
 
@@ -7,31 +10,31 @@ public:
 	Materials();
 	void GenArrow(float y);
 	
-	S3DVertex vCardFront[4];
-	S3DVertex vCardOutline[4];
-	S3DVertex vCardOutliner[4];
-	S3DVertex vCardBack[4];
-	S3DVertex vSymbol[4];
-	S3DVertex vNegate[4];
-	S3DVertex vChainNum[4];
-	S3DVertex vActivate[4];
-	S3DVertex vField[4];
-	S3DVertex vFieldSpell[4];
-	S3DVertex vFieldSpell1[4];
-	S3DVertex vFieldSpell2[4];
-	//S3DVertex vBackLine[76];
-	S3DVertex vFieldDeck[2][4];
-	S3DVertex vFieldGrave[2][2][4];    //[player][rule], rule = 0: dule_rule <= 3, 1: dule_rule >= 4
-	S3DVertex vFieldExtra[2][4];
-	S3DVertex vFieldRemove[2][2][4];   //[player][rule]
-	S3DVertex vFieldMzone[2][7][4];    //[player][sequence]
-	S3DVertex vFieldSzone[2][8][2][4]; //[player][sequence][rule]
+	irr::video::S3DVertex vCardFront[4];
+	irr::video::S3DVertex vCardOutline[4];
+	irr::video::S3DVertex vCardOutliner[4];
+	irr::video::S3DVertex vCardBack[4];
+	irr::video::S3DVertex vSymbol[4];
+	irr::video::S3DVertex vNegate[4];
+	irr::video::S3DVertex vChainNum[4];
+	irr::video::S3DVertex vActivate[4];
+	irr::video::S3DVertex vField[4];
+	irr::video::S3DVertex vFieldSpell[4];
+	irr::video::S3DVertex vFieldSpell1[4];
+	irr::video::S3DVertex vFieldSpell2[4];
+	//irr::video::S3DVertex vBackLine[76];
+	irr::video::S3DVertex vFieldDeck[2][4];
+	irr::video::S3DVertex vFieldGrave[2][2][4];    //[player][rule], rule = 0: dule_rule <= 3, 1: dule_rule >= 4
+	irr::video::S3DVertex vFieldExtra[2][4];
+	irr::video::S3DVertex vFieldRemove[2][2][4];   //[player][rule]
+	irr::video::S3DVertex vFieldMzone[2][7][4];    //[player][sequence]
+	irr::video::S3DVertex vFieldSzone[2][8][2][4]; //[player][sequence][rule]
 	irr::core::vector3df vFieldContiAct[4];
-	S3DVertex vArrow[40];
-	SColor c2d[4];
-	u16 iRectangle[6];
-	//u16 iBackLine[116];
-	u16 iArrow[40];
+	irr::video::S3DVertex vArrow[40];
+	irr::video::SColor c2d[4];
+	irr::u16 iRectangle[6];
+	//irr::u16 iBackLine[116];
+	irr::u16 iArrow[40];
 	irr::video::SMaterial mCard;
 	irr::video::SMaterial mTexture;
 	irr::video::SMaterial mBackLine;
@@ -44,3 +47,5 @@ public:
 extern Materials matManager;
 
 }
+
+#endif //MATERIALS_H

gframe/menu_handler.cpp

@@ -33,7 +33,7 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 	switch(event.EventType) {
 	case irr::EET_GUI_EVENT: {
 		irr::gui::IGUIElement* caller = event.GUIEvent.Caller;
-		s32 id = caller->getID();
+		irr::s32 id = caller->getID();
 		if(mainGame->wQuery->isVisible() && id != BUTTON_YES && id != BUTTON_NO) {
 			mainGame->wQuery->getParent()->bringToFront(mainGame->wQuery);
 			break;
@@ -400,7 +400,7 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 					char arg3[8];
 					std::snprintf(arg3, sizeof arg3, "%d", mainGame->gameConf.serverport);
 					execl("./bot", "bot", arg1, arg2, arg3, nullptr);
-					exit(0);
+					std::exit(0);
 				} else {
 					if(!NetServer::StartServer(mainGame->gameConf.serverport)) {
 						soundManager.PlaySoundEffect(SOUND_INFO);

gframe/menu_handler.h

 #ifndef MENU_HANDLER_H
 #define MENU_HANDLER_H
 
-#include "config.h"
+#include <irrlicht.h>
 
 namespace ygo {
 
 class MenuHandler: public irr::IEventReceiver {
 public:
 	bool OnEvent(const irr::SEvent& event) override;
-	s32 prev_operation;
-	int prev_sel;
+	irr::s32 prev_operation{ 0 };
+	int prev_sel{ -1 };
 
 };
 

gframe/netserver.h

@@ -41,7 +41,7 @@ public:
 			bufferevent_write(dp->bev, net_server_write, 3);
 	}
 	template<typename ST>
-	static void SendPacketToPlayer(DuelPlayer* dp, unsigned char proto, ST& st) {
+	static void SendPacketToPlayer(DuelPlayer* dp, unsigned char proto, const ST& st) {
 		auto p = net_server_write;
 		if (sizeof(ST) > MAX_DATA_SIZE)
 			return;

gframe/premake5.lua

@@ -6,6 +6,8 @@ end
 
 project "YGOPro"
     kind "WindowedApp"
+    cdialect "C11"
+    cppdialect "C++14"
 
     files { "*.cpp", "*.h" }
     includedirs { "../ocgcore" }
@@ -50,7 +52,7 @@ project "YGOPro"
         libdirs { "$(DXSDK_DIR)Lib/x86" }
         links { "opengl32", "ws2_32", "winmm", "gdi32", "kernel32", "user32", "imm32" }
     filter "not action:vs*"
-        buildoptions { "-std=c++14", "-fno-rtti" }
+        buildoptions { "-fno-rtti" }
     filter "not system:windows"
         links { "event_pthreads", "dl", "pthread" }
     filter "system:macosx"

gframe/replay_mode.h

 #ifndef REPLAY_MODE_H
 #define REPLAY_MODE_H
 
-#include <stdint.h>
+#include <cstdint>
 #include <vector>
 #include "replay.h"
 

gframe/single_mode.h

 #ifndef SINGLE_MODE_H
 #define SINGLE_MODE_H
 
-#include <stdint.h>
+#include <cstdint>
 #include <vector>
 #include "replay.h"
 

gframe/spmemvfs/premake5.lua

 project "cspmemvfs"
     kind "StaticLib"
+    cdialect "C11"
     files { "*.c", "*.h" }
 
     if BUILD_SQLITE then

premake/event/premake5.lua

 project "event"
     kind "StaticLib"
+    cdialect "C11"
 
     includedirs { "include", "compat" }
 

premake/freetype/premake5.lua

 project "freetype"
     kind "StaticLib"
+    cdialect "C11"
 
     includedirs { "include" }
     defines { "FT2_BUILD_LIBRARY" }
@@ -43,6 +44,10 @@ project "freetype"
             "src/type42/type42.c",
             "src/winfonts/winfnt.c" }
 
+    if os.isfile("src/svg/svg.c") then
+        files { "src/svg/svg.c" }
+    end
+
     filter "system:windows"
         files { "builds/windows/ftsystem.c",
                 "builds/windows/ftdebug.c" }

premake/gframe/ygopro.rc

 1 ICON "ygopro.ico"
 
 1 VERSIONINFO
-FILEVERSION 1, 0, 35, 3
-PRODUCTVERSION 1, 0, 35, 3
+FILEVERSION 1, 0, 36, 1
+PRODUCTVERSION 1, 0, 36, 1
 FILEOS 0x4
 FILETYPE 0x1
 
@@ -13,11 +13,11 @@ BLOCK "080404b0"
 BEGIN
 VALUE "FileDescription", "YGOPro"
 VALUE "InternalName", "YGOPro"
-VALUE "LegalCopyright", "Copyright (C) 2022 Fluorohydride"
+VALUE "LegalCopyright", "Copyright (C) 2025 Fluorohydride"
 VALUE "OriginalFilename", "YGOPro.exe"
 VALUE "ProductName", "YGOPro"
-VALUE "FileVersion", "1.035.3"
-VALUE "ProductVersion", "1.035.3"
+VALUE "FileVersion", "1.036.1"
+VALUE "ProductVersion", "1.036.1"
 END
 END
 BLOCK "VarFileInfo"

premake/irrlicht/premake5.lua

 project "irrlicht"
     kind "StaticLib"
+    cdialect "C11"
+    cppdialect "C++14"
 
     includedirs { "include", "source/Irrlicht", "source/Irrlicht/jpeglib", "source/Irrlicht/libpng", "source/Irrlicht/zlib" }
     

premake/lua/premake5.lua

 project "lua"
     kind "StaticLib"
+    cdialect "C11"
+    cppdialect "C++14"
 
     files { "src/*.c", "src/*.h", "src/*.hpp" }
     removefiles { "src/lua.c", "src/luac.c" }

premake/sqlite3/premake5.lua

 project "sqlite3"
     kind "StaticLib"
+    cdialect "C11"
 
     files { "sqlite3.c", "sqlite3.h" }