Merge branch 'master' of https://github.com/Fluorohydride/ygopro into patch-skip-confirm

.gitignore

@@ -8,6 +8,8 @@
 /pics
 /replay
 /single
+/sound
+!/sound/files.txt
 /WindBot
 /cards.cdb
 /error.log
@@ -30,6 +32,7 @@
 /irrklang
 /ikpmp3
 /lua
+/miniaudio
 /sqlite3
 /gframe/*.ico
 /gframe/ygopro.rc

.gitmodules

 [submodule "ocgcore"]
 	path = ocgcore
-	url = git@github.com:Fluorohydride/ygopro-core.git
+	url = https://github.com/Fluorohydride/ygopro-core.git
 [submodule "script"]
 	path = script
-	url = git@github.com:Fluorohydride/ygopro-scripts.git
+	url = https://github.com/Fluorohydride/ygopro-scripts.git

gframe/CGUIButton.h

-// Copyright (C) 2002-2012 Nikolaus Gebhardt
-// This file is part of the "Irrlicht Engine".
-// For conditions of distribution and use, see copyright notice in irrlicht.h
-
-#ifndef __C_GUI_BUTTON_H_INCLUDED__
-#define __C_GUI_BUTTON_H_INCLUDED__
-
-#include "IrrCompileConfig.h"
-#ifdef _IRR_COMPILE_WITH_GUI_
-
-#include "IGUIButton.h"
-#include "IGUISpriteBank.h"
-#include "SColor.h"
-
-namespace irr
-{
-namespace gui
-{
-
-	class CGUIButton : public IGUIButton
-	{
-	public:
-
-		//! constructor
-		CGUIButton(IGUIEnvironment* environment, IGUIElement* parent,
-			s32 id, core::rect<s32> rectangle, bool noclip=false);
-
-		//! destructor
-		virtual ~CGUIButton();
-
-		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
-
-		//! draws the element and its children
-		virtual void draw();
-
-		//! sets another skin independent font. if this is set to zero, the button uses the font of the skin.
-		virtual void setOverrideFont(IGUIFont* font=0);
-
-		//! Gets the override font (if any)
-		virtual IGUIFont* getOverrideFont() const;
-
-		//! Get the font which is used right now for drawing
-		virtual IGUIFont* getActiveFont() const;
-
-		//! Sets an image which should be displayed on the button when it is in normal state.
-		virtual void setImage(video::ITexture* image=0);
-
-		//! Sets an image which should be displayed on the button when it is in normal state.
-		virtual void setImage(video::ITexture* image, const core::rect<s32>& pos);
-
-		//! Sets an image which should be displayed on the button when it is in pressed state.
-		virtual void setPressedImage(video::ITexture* image=0);
-
-		//! Sets an image which should be displayed on the button when it is in pressed state.
-		virtual void setPressedImage(video::ITexture* image, const core::rect<s32>& pos);
-
-		//! Sets the sprite bank used by the button
-		virtual void setSpriteBank(IGUISpriteBank* bank=0);
-
-		//! Sets the animated sprite for a specific button state
-		/** \param index: Number of the sprite within the sprite bank, use -1 for no sprite
-		\param state: State of the button to set the sprite for
-		\param index: The sprite number from the current sprite bank
-		\param color: The color of the sprite
-		*/
-		virtual void setSprite(EGUI_BUTTON_STATE state, s32 index,
-				video::SColor color=video::SColor(255,255,255,255), bool loop=false);
-
-		//! Sets if the button should behave like a push button. Which means it
-		//! can be in two states: Normal or Pressed. With a click on the button,
-		//! the user can change the state of the button.
-		virtual void setIsPushButton(bool isPushButton=true);
-
-		//! Checks whether the button is a push button
-		virtual bool isPushButton() const;
-
-		//! Sets the pressed state of the button if this is a pushbutton
-		virtual void setPressed(bool pressed=true);
-
-		//! Returns if the button is currently pressed
-		virtual bool isPressed() const;
-
-		//! Sets if the button should use the skin to draw its border
-		virtual void setDrawBorder(bool border=true);
-
-		//! Checks if the button face and border are being drawn
-		virtual bool isDrawingBorder() const;
-
-		//! Sets if the alpha channel should be used for drawing images on the button (default is false)
-		virtual void setUseAlphaChannel(bool useAlphaChannel=true);
-
-		//! Checks if the alpha channel should be used for drawing images on the button
-		virtual bool isAlphaChannelUsed() const;
-
-		//! Sets if the button should scale the button images to fit
-		virtual void setScaleImage(bool scaleImage=true);
-
-		//! Checks whether the button scales the used images
-		virtual bool isScalingImage() const;
-
-		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
-
-		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
-
-	protected:
-
-		struct ButtonSprite
-		{
-			s32 Index;
-			video::SColor Color;
-			bool Loop;
-		};
-
-		ButtonSprite ButtonSprites[EGBS_COUNT];
-
-		IGUISpriteBank* SpriteBank;
-		IGUIFont* OverrideFont;
-
-		video::ITexture* Image;
-		video::ITexture* PressedImage;
-
-		core::rect<s32> ImageRect;
-		core::rect<s32> PressedImageRect;
-
-		u32 ClickTime, HoverTime, FocusTime;
-
-		bool IsPushButton;
-		bool Pressed;
-		bool UseAlphaChannel;
-		bool DrawBorder;
-		bool ScaleImage;
-	};
-
-} // end namespace gui
-} // end namespace irr
-
-#endif // _IRR_COMPILE_WITH_GUI_
-
-#endif // __C_GUI_BUTTON_H_INCLUDED__
-

gframe/CGUIImageButton.h

+// Copyright (C) 2002-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
 #ifndef _C_GUI_IMAGE_BUTTON_H_
 #define _C_GUI_IMAGE_BUTTON_H_
 
-#include <irrlicht.h>
-#include "CGUIButton.h"
+#include <IrrCompileConfig.h>
+#ifdef _IRR_COMPILE_WITH_GUI_
+
+#include <IGUIButton.h>
+#include <SColor.h>
 
 namespace irr {
+namespace video {
+class IVideoDriver;
+class ITexture;
+}
 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);
-class CGUIImageButton : public CGUIButton {
+                     core::vector2d<s32> corner[4], bool useAlphaChannel = true, video::SColor color = 0xffffffff);
+
+class CGUIImageButton : public IGUIButton {
 public:
-	CGUIImageButton(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle);
-	static CGUIImageButton* addImageButton(IGUIEnvironment *env, const core::rect<s32>& rectangle, IGUIElement* parent, s32 id);
-	virtual void draw();
-	virtual void setImage(video::ITexture* image = 0);
-	virtual void setDrawImage(bool b);
-	virtual void setImageRotation(f32 r);
-	virtual void setImageScale(core::vector2df s);
-	virtual void setImageSize(core::dimension2di s);
-	virtual IGUIFont* getOverrideFont(void) const;
-	virtual IGUIFont* getActiveFont() const;
-
-private:
+	static CGUIImageButton* addImageButton(IGUIEnvironment* env, const core::rect<s32>& rectangle, IGUIElement* parent, s32 id);
+	
+	//! constructor
+	CGUIImageButton(IGUIEnvironment* environment, IGUIElement* parent,
+		s32 id, core::rect<s32> rectangle, bool noclip = false);
+	
+	//! destructor
+	~CGUIImageButton() override;
+
+	//! called if an event happened.
+	bool OnEvent(const SEvent& event) override;
+
+	//! draws the element and its children
+	void draw() override;
+
+	//! sets another skin independent font. if this is set to zero, the button uses the font of the skin.
+	void setOverrideFont(IGUIFont* font = 0) override;
+
+	//! Gets the override font (if any)
+	IGUIFont* getOverrideFont() const override;
+
+	//! Get the font which is used right now for drawing
+	IGUIFont* getActiveFont() const override;
+
+	//! Sets an image which should be displayed on the button when it is in normal state.
+	void setImage(video::ITexture* image = 0) override;
+
+	//! Sets an image which should be displayed on the button when it is in normal state.
+	void setImage(video::ITexture* image, const core::rect<s32>& pos) override;
+
+	//! Sets an image which should be displayed on the button when it is in pressed state.
+	void setPressedImage(video::ITexture* image = 0) override;
+
+	//! Sets an image which should be displayed on the button when it is in pressed state.
+	void setPressedImage(video::ITexture* image, const core::rect<s32>& pos) override;
+
+	//! Sets the sprite bank used by the button
+	void setSpriteBank(IGUISpriteBank* bank = 0) override;
+
+	//! Sets the animated sprite for a specific button state
+	/** \param index: Number of the sprite within the sprite bank, use -1 for no sprite
+	\param state: State of the button to set the sprite for
+	\param index: The sprite number from the current sprite bank
+	\param color: The color of the sprite
+	*/
+	void setSprite(EGUI_BUTTON_STATE state, s32 index,
+		video::SColor color = video::SColor(255, 255, 255, 255), bool loop = false) override;
+
+	//! Sets if the button should behave like a push button. Which means it
+	//! can be in two states: Normal or Pressed. With a click on the button,
+	//! the user can change the state of the button.
+	void setIsPushButton(bool isPushButton = true) override;
+
+	//! Checks whether the button is a push button
+	bool isPushButton() const override;
+
+	//! Sets the pressed state of the button if this is a pushbutton
+	void setPressed(bool pressed = true) override;
+
+	//! Returns if the button is currently pressed
+	bool isPressed() const override;
+
+	//! Sets if the button should use the skin to draw its border
+	void setDrawBorder(bool border = true) override;
+
+	//! Checks if the button face and border are being drawn
+	bool isDrawingBorder() const override;
+
+	//! Sets if the alpha channel should be used for drawing images on the button (default is false)
+	void setUseAlphaChannel(bool useAlphaChannel = true) override;
+
+	//! Checks if the alpha channel should be used for drawing images on the button
+	bool isAlphaChannelUsed() const override;
+
+	//! Sets if the button should scale the button images to fit
+	void setScaleImage(bool scaleImage = true) override;
+
+	//! Checks whether the button scales the used images
+	bool isScalingImage() const override;
+
+	//! Writes attributes of the element.
+	void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const override;
+
+	//! Reads attributes of the element
+	void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) override;
+
+	// from ygopro
+	void setDrawImage(bool b);
+	void setImageRotation(f32 r);
+	void setImageScale(core::vector2df s);
+	void setImageSize(core::dimension2di s);
+
+protected:
+	struct ButtonSprite
+	{
+		s32 Index;
+		video::SColor Color;
+		bool Loop;
+	};
+
+	ButtonSprite ButtonSprites[EGBS_COUNT];
+
+	IGUISpriteBank* SpriteBank;
+	IGUIFont* OverrideFont;
+
+	video::ITexture* Image;
+	video::ITexture* PressedImage;
+
+	core::rect<s32> ImageRect;
+	core::rect<s32> PressedImageRect;
+
+	bool IsPushButton;
+	bool Pressed;
+	bool UseAlphaChannel;
+	bool DrawBorder;
+	bool ScaleImage;
+	
+	// from ygopro
 	bool isDrawImage;
 	bool isFixedSize;
 	f32 imageRotation;
@@ -36,4 +155,6 @@ private:
 }
 }
 
+#endif // _IRR_COMPILE_WITH_GUI_
+
 #endif //_C_GUI_IMAGE_BUTTON_H_

gframe/CGUITTFont.h

@@ -54,7 +54,7 @@ public:
 //! Structure representing a single TrueType glyph.
 struct SGUITTGlyph {
 	//! Constructor.
-	SGUITTGlyph() : isLoaded(false), glyph_page(0), surface(0), parent(0) {}
+	SGUITTGlyph() : isLoaded(false), glyph_page(0), advance({}), surface(0), parent(0) {}
 
 	//! Destructor.
 	~SGUITTGlyph() {
@@ -207,93 +207,95 @@ public:
 	static CGUITTFont* create(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
 
 	//! Destructor
-	virtual ~CGUITTFont();
+	~CGUITTFont() override;
 
 	//! Sets the amount of glyphs to batch load.
-	virtual void setBatchLoadSize(u32 batch_size) {
+	void setBatchLoadSize(u32 batch_size) {
 		batch_load_size = batch_size;
 	}
 
 	//! Sets the maximum texture size for a page of glyphs.
-	virtual void setMaxPageTextureSize(const core::dimension2du& texture_size) {
+	void setMaxPageTextureSize(const core::dimension2du& texture_size) {
 		max_page_texture_size = texture_size;
 	}
 
 	//! Get the font size.
-	virtual u32 getFontSize() const {
+	u32 getFontSize() const {
 		return size;
 	}
 
 	//! Check the font's transparency.
-	virtual bool isTransparent() const {
+	bool isTransparent() const {
 		return use_transparency;
 	}
 
 	//! Check if the font auto-hinting is enabled.
 	//! Auto-hinting is FreeType's built-in font hinting engine.
-	virtual bool useAutoHinting() const {
+	bool useAutoHinting() const {
 		return use_auto_hinting;
 	}
 
 	//! Check if the font hinting is enabled.
-	virtual bool useHinting()	 const {
+	bool useHinting() const {
 		return use_hinting;
 	}
 
 	//! Check if the font is being loaded as a monochrome font.
 	//! The font can either be a 256 color grayscale font, or a 2 color monochrome font.
-	virtual bool useMonochrome()  const {
+	bool useMonochrome() const {
 		return use_monochrome;
 	}
 
 	//! Tells the font to allow transparency when rendering.
 	//! Default: true.
 	//! \param flag If true, the font draws using transparency.
-	virtual void setTransparency(const bool flag);
+	void setTransparency(const bool flag);
 
 	//! Tells the font to use monochrome rendering.
 	//! Default: false.
 	//! \param flag If true, the font draws using a monochrome image.  If false, the font uses a grayscale image.
-	virtual void setMonochrome(const bool flag);
+	void setMonochrome(const bool flag);
 
 	//! Enables or disables font hinting.
 	//! Default: Hinting and auto-hinting true.
 	//! \param enable If false, font hinting is turned off. If true, font hinting is turned on.
 	//! \param enable_auto_hinting If true, FreeType uses its own auto-hinting algorithm.  If false, it tries to use the algorithm specified by the font.
-	virtual void setFontHinting(const bool enable, const bool enable_auto_hinting = true);
+	void setFontHinting(const bool enable, const bool enable_auto_hinting = true);
 
 	//! Draws some text and clips it to the specified rectangle if wanted.
-	virtual void draw(const core::stringw& text, const core::rect<s32>& position,
+	void draw(const core::stringw& text, const core::rect<s32>& position,
 	                  video::SColor color, bool hcenter = false, bool vcenter = false,
-	                  const core::rect<s32>* clip = 0);
+	                  const core::rect<s32>* clip = 0) override;
+	void drawUstring(const core::ustring& text, const core::rect<s32>& position,
+					video::SColor color, bool hcenter = false, bool vcenter = false,
+					const core::rect<s32>* clip = 0);
 
 	//! Returns the dimension of a character produced by this font.
-	virtual core::dimension2d<u32> getCharDimension(const wchar_t ch) const;
+	core::dimension2d<u32> getCharDimension(const wchar_t ch) const;
 
 	//! Returns the dimension of a text string.
-	virtual core::dimension2d<u32> getDimension(const wchar_t* text) const;
-	virtual core::dimension2d<u32> getDimension(const core::ustring& text) const;
+	core::dimension2d<u32> getDimension(const wchar_t* text) const override;
+	core::dimension2d<u32> getDimension(const core::ustring& text) const;
 
 	//! Calculates the index of the character in the text which is on a specific position.
-	virtual s32 getCharacterFromPos(const wchar_t* text, s32 pixel_x) const;
-	virtual s32 getCharacterFromPos(const core::ustring& text, s32 pixel_x) const;
+	s32 getCharacterFromPos(const wchar_t* text, s32 pixel_x) const override;
+	s32 getCharacterFromPos(const core::ustring& text, s32 pixel_x) const;
 
 	//! Sets global kerning width for the font.
-	virtual void setKerningWidth(s32 kerning);
+	void setKerningWidth(s32 kerning) override;
 
 	//! Sets global kerning height for the font.
-	virtual void setKerningHeight(s32 kerning);
+	void setKerningHeight(s32 kerning) override;
 
 	//! Gets kerning values (distance between letters) for the font. If no parameters are provided,
-	virtual s32 getKerningWidth(const wchar_t* thisLetter = 0, const wchar_t* previousLetter = 0) const;
-	virtual s32 getKerningWidth(const uchar32_t thisLetter = 0, const uchar32_t previousLetter = 0) const;
+	s32 getKerningWidth(const wchar_t* thisLetter = 0, const wchar_t* previousLetter = 0) const override;
+	s32 getKerningWidth(const uchar32_t thisLetter = 0, const uchar32_t previousLetter = 0) const;
 
 	//! Returns the distance between letters
-	virtual s32 getKerningHeight() const;
+	s32 getKerningHeight() const override;
 
 	//! Define which characters should not be drawn by the font.
-	virtual void setInvisibleCharacters(const wchar_t *s);
-	virtual void setInvisibleCharacters(const core::ustring& s);
+	void setInvisibleCharacters(const wchar_t *s) final;
 
 	//! Get the last glyph page if there's still available slots.
 	//! If not, it will return zero.
@@ -312,14 +314,14 @@ public:
 	//! Create corresponding character's software image copy from the font,
 	//! so you can use this data just like any ordinary video::IImage.
 	//! \param ch The character you need
-	virtual video::IImage* createTextureFromChar(const uchar32_t& ch);
+	video::IImage* createTextureFromChar(const uchar32_t& ch);
 
 	//! This function is for debugging mostly. If the page doesn't exist it returns zero.
 	//! \param page_index Simply return the texture handle of a given page index.
-	virtual video::ITexture* getPageTextureByIndex(const u32& page_index) const;
+	video::ITexture* getPageTextureByIndex(const u32& page_index) const;
 
 	//! Add a list of scene nodes generated by putting font textures on the 3D planes.
-	virtual core::array<scene::ISceneNode*> addTextSceneNode
+	core::array<scene::ISceneNode*> addTextSceneNode
 	(const wchar_t* text, scene::ISceneManager* smgr, scene::ISceneNode* parent = 0,
 	 const video::SColor& color = video::SColor(255, 0, 0, 0), bool center = false );
 
@@ -340,7 +342,7 @@ private:
 	static scene::IMesh* shared_plane_ptr_;
 	static scene::SMesh  shared_plane_;
 
-	CGUITTFont(IGUIEnvironment *env);
+	explicit CGUITTFont(IGUIEnvironment *env);
 	bool load(const io::path& filename, const u32 size, const bool antialias, const bool transparency);
 	void reset_images();
 	void update_glyph_pages() const;

gframe/bufferio.h

 #ifndef BUFFERIO_H
 #define BUFFERIO_H
 
-#ifdef _MSC_VER
-#pragma warning(disable: 4244)
-#endif
+#include <cstdint>
+#include <cwchar>
+#include "../ocgcore/buffer.h"
 
 class BufferIO {
 public:
-	inline static int ReadInt32(unsigned char*& p) {
-		int ret = *(int*)p;
-		p += 4;
-		return ret;
-	}
-	inline static short ReadInt16(unsigned char*& p) {
-		short ret = *(short*)p;
-		p += 2;
-		return ret;
-	}
-	inline static char ReadInt8(unsigned char*& p) {
-		char ret = *(char*)p;
-		p++;
-		return ret;
-	}
-	inline static unsigned char ReadUInt8(unsigned char*& p) {
-		unsigned char ret = *(unsigned char*)p;
-		p++;
-		return ret;
-	}
-	inline static void WriteInt32(unsigned char*& p, int val) {
-		(*(int*)p) = val;
-		p += 4;
-	}
-	inline static void WriteInt16(unsigned char*& p, short val) {
-		(*(short*)p) = val;
-		p += 2;
-	}
-	inline static void WriteInt8(unsigned char*& p, char val) {
-		*p = val;
-		p++;
+	static int ReadInt32(unsigned char*& p) {
+		return buffer_read<int32_t>(p);
 	}
+	static short ReadInt16(unsigned char*& p) {
+		return buffer_read<int16_t>(p);
+	}
+	static char ReadInt8(unsigned char*& p) {
+		return buffer_read<char>(p);
+	}
+	static unsigned char ReadUInt8(unsigned char*& p) {
+		return buffer_read<unsigned char>(p);
+	}
+	static void WriteInt32(unsigned char*& p, int val) {
+		buffer_write<int32_t>(p, val);
+	}
+	static void WriteInt16(unsigned char*& p, short val) {
+		buffer_write<int16_t>(p, val);
+	}
+	static void WriteInt8(unsigned char*& p, char val) {
+		buffer_write<char>(p, val);
+	}
+	/**
+	* @brief Copy a C-style string to another C-style string.
+	* @param src The source wide string
+	* @param pstr The destination char string
+	* @param bufsize The length of the destination buffer
+	* @return The length of the copied string
+	*/
 	template<typename T1, typename T2>
-	inline static int CopyWStr(T1* src, T2* pstr, int bufsize) {
+	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) {
+	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;
 		*pstr = 0;
 		return l;
 	}
+	template<typename T1, typename T2, size_t N>
+	static int CopyCharArray(const T1* src, T2(&dst)[N]) {
+		return CopyWStr(src, dst, N);
+	}
+	template<size_t N>
+	static void CopyString(const char* src, char(&dst)[N]) {
+		std::strncpy(dst, src, N - 1);
+		dst[N - 1] = 0;
+	}
+	template<size_t N>
+	static void CopyWideString(const wchar_t* src, wchar_t(&dst)[N]) {
+		std::wcsncpy(dst, src, N - 1);
+		dst[N - 1] = 0;
+	}
+	template<typename T>
+	static bool CheckUTF8Byte(const T* str, int len) {
+		for (int i = 1; i < len; ++i) {
+			if ((str[i] & 0xc0U) != 0x80U)
+				return false;
+		}
+		return true;
+	}
+	static unsigned int ConvertUTF8(const char*& p) {
+		unsigned int cur = 0;
+		if ((p[0] & 0x80U) == 0) {
+			cur = p[0] & 0xffU;
+			p++;
+		}
+		else if ((p[0] & 0xe0U) == 0xc0U) {
+			if (!CheckUTF8Byte(p, 2)) {
+				p++;
+				return UINT32_MAX;
+			}
+			cur = ((p[0] & 0x1fU) << 6) | (p[1] & 0x3fU);
+			p += 2;
+			if(cur < 0x80U)
+				return UINT32_MAX;
+		}
+		else if ((p[0] & 0xf0U) == 0xe0U) {
+			if (!CheckUTF8Byte(p, 3)) {
+				p++;
+				return UINT32_MAX;
+			}
+			cur = ((p[0] & 0xfU) << 12) | ((p[1] & 0x3fU) << 6) | (p[2] & 0x3fU);
+			p += 3;
+			if (cur < 0x800U)
+				return UINT32_MAX;
+		}
+		else if ((p[0] & 0xf8U) == 0xf0U) {
+			if (!CheckUTF8Byte(p, 4)) {
+				p++;
+				return UINT32_MAX;
+			}
+			cur = ((p[0] & 0x7U) << 18) | ((p[1] & 0x3fU) << 12) | ((p[2] & 0x3fU) << 6) | (p[3] & 0x3fU);
+			p += 4;
+			if (cur < 0x10000U)
+				return UINT32_MAX;
+		}
+		else {
+			p++;
+			return UINT32_MAX;
+		}
+		return cur;
+	}
+	static bool IsHighSurrogate(unsigned int c) {
+		return (c >= 0xd800U && c <= 0xdbffU);
+	}
+	static bool IsLowSurrogate(unsigned int c) {
+		return (c >= 0xdc00U && c <= 0xdfffU);
+	}
+	static bool IsUnicodeChar(unsigned int c) {
+		if(IsHighSurrogate(c))
+			return false;
+		if (IsLowSurrogate(c))
+			return false;
+		if (c > 0x10ffffU)
+			return false;
+		return true;
+	}
 	// UTF-16/UTF-32 to UTF-8
-	static int EncodeUTF8(const wchar_t * wsrc, char * str) {
-		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;
+	// return: string length
+	static int EncodeUTF8String(const wchar_t* wsrc, char* str, int size) {
+		auto pw = wsrc;
+		auto pstr = str;
+		while (*pw != 0) {
+			unsigned cur = 0;
+			int codepoint_size = 0;
+			if (sizeof(wchar_t) == 2) {
+				if (IsHighSurrogate(pw[0])) {
+					if (pw[1] == 0)
+						break;
+					if (IsLowSurrogate(pw[1])) {
+						cur = ((pw[0] & 0x3ffU) << 10) | (pw[1] & 0x3ffU);
+						cur += 0x10000;
+						pw += 2;
+					}
+					else {
+						pw++;
+						continue;
+					}
+				}
+				else if (IsLowSurrogate(pw[0])) {
+					pw++;
+					continue;
+				}
+				else {
+					cur = *pw;
+					pw++;
+				}
+			}
+			else {
+				cur = *pw;
+				pw++;
+			}
+			if (!IsUnicodeChar(cur))
+				continue;
+			if (cur < 0x80U)
+				codepoint_size = 1;
+			else if (cur < 0x800U)
+				codepoint_size = 2;
+			else if (cur < 0x10000U)
+				codepoint_size = 3;
+			else
+				codepoint_size = 4;
+			if ((int)(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:
+				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;
 			}
-			wsrc++;
+			pstr += codepoint_size;
 		}
-		*str = 0;
-		return str - pstr;
+		*pstr = 0;
+		return (int)(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) {
-				*wp = *p;
-				p++;
-			} else if((*p & 0xe0) == 0xc0) {
-				*wp = (((unsigned)p[0] & 0x1f) << 6) | ((unsigned)p[1] & 0x3f);
-				p += 2;
-			} else if((*p & 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
-				p += 4;
-			} else
-				p++;
-			wp++;
+			unsigned int cur = ConvertUTF8(p);
+			int codepoint_size = 0;
+			if (!IsUnicodeChar(cur))
+				continue;
+			if (cur >= 0x10000) {
+				if (sizeof(wchar_t) == 2)
+					codepoint_size = 2;
+				else
+					codepoint_size = 1;
+			}
+			else
+				codepoint_size = 1;
+			if ((int)(wp - wstr) + codepoint_size > size - 1)
+				break;
+			if (codepoint_size == 1) {
+				wp[0] = cur;
+				wp++;
+			}
+			else {
+				cur -= 0x10000U;
+				wp[0] = (cur >> 10) | 0xd800;
+				wp[1] = (cur & 0x3ff) | 0xdc00;
+				wp += 2;
+			}
 		}
 		*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);
+	}
+	template<size_t N, typename T>
+	static void NullTerminate(T(&str)[N]) {
+		str[N - 1] = 0;
+	}
 	static int GetVal(const wchar_t* pstr) {
-		int ret = 0;
-		while(*pstr >= L'0' && *pstr <= L'9') {
-			ret = ret * 10 + (*pstr - L'0');
-			pstr++;
+		if (*pstr >= L'0' && *pstr <= L'9') {
+			int ret{};
+			wchar_t* str_end{};
+			ret = std::wcstol(pstr, &str_end, 10);
+			if (*str_end == 0)
+				return ret;
+			else
+				return 0;
 		}
-		return ret;
+		else
+			return 0;
+	
 	}
 };
 

gframe/client_card.cpp

 #include "client_card.h"
 #include "client_field.h"
-#include "data_manager.h"
 #include "game.h"
 
 namespace ygo {
@@ -32,12 +31,12 @@ ClientCard::~ClientCard() {
 	}
 	overlayed.clear();
 }
-void ClientCard::SetCode(int code) {
-	if((location == LOCATION_HAND) && (this->code != (unsigned int)code)) {
-		this->code = code;
+void ClientCard::SetCode(unsigned int x) {
+	if((location == LOCATION_HAND) && (code != x)) {
+		code = x;
 		mainGame->dField.MoveCard(this, 5);
 	} else
-		this->code = code;
+		code = x;
 }
 void ClientCard::UpdateInfo(unsigned char* buf) {
 	int flag = BufferIO::ReadInt32(buf);
@@ -57,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
@@ -113,10 +112,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 +125,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);
@@ -176,13 +175,13 @@ void ClientCard::UpdateInfo(unsigned char* buf) {
 	}
 }
 void ClientCard::ClearTarget() {
-	for(auto cit = cardTarget.begin(); cit != cardTarget.end(); ++cit) {
-		(*cit)->is_showtarget = false;
-		(*cit)->ownerTarget.erase(this);
+	for (auto& pcard : cardTarget) {
+		pcard->is_showtarget = false;
+		pcard->ownerTarget.erase(this);
 	}
-	for(auto cit = ownerTarget.begin(); cit != ownerTarget.end(); ++cit) {
-		(*cit)->is_showtarget = false;
-		(*cit)->cardTarget.erase(this);
+	for (auto& pcard : ownerTarget) {
+		pcard->is_showtarget = false;
+		pcard->cardTarget.erase(this);
 	}
 	cardTarget.clear();
 	ownerTarget.clear();
@@ -215,101 +214,35 @@ void ClientCard::ClearData() {
 bool ClientCard::client_card_sort(ClientCard* c1, ClientCard* c2) {
 	if(c1->is_selected != c2->is_selected)
 		return c1->is_selected < c2->is_selected;
-	int32 cp1 = c1->overlayTarget ? c1->overlayTarget->controler : c1->controler;
-	int32 cp2 = c2->overlayTarget ? c2->overlayTarget->controler : c2->controler;
+	int cp1 = c1->overlayTarget ? c1->overlayTarget->controler : c1->controler;
+	int cp2 = c2->overlayTarget ? c2->overlayTarget->controler : c2->controler;
 	if(cp1 != cp2)
 		return cp1 < cp2;
 	if(c1->location != c2->location)
 		return c1->location < c2->location;
-	if (c1->location & LOCATION_OVERLAY) {
+	if (c1->location == LOCATION_OVERLAY) {
 		if (c1->overlayTarget != c2->overlayTarget)
 			return c1->overlayTarget->sequence < c2->overlayTarget->sequence;
 		else
 			return c1->sequence < c2->sequence;
 	}
-	else {
-		if(c1->location & (LOCATION_DECK | LOCATION_GRAVE | LOCATION_REMOVED | LOCATION_EXTRA)) {
-			auto it1 = std::find_if(mainGame->dField.chains.rbegin(), mainGame->dField.chains.rend(), [c1](const ChainInfo& ch) {
-				return c1 == ch.chain_card || ch.target.find(c1) != ch.target.end();
-				});
-			auto it2 = std::find_if(mainGame->dField.chains.rbegin(), mainGame->dField.chains.rend(), [c2](const ChainInfo& ch) {
-				return c2 == ch.chain_card || ch.target.find(c2) != ch.target.end();
-				});
-			if(it1 != mainGame->dField.chains.rend() || it2 != mainGame->dField.chains.rend()) {
-				return it1 < it2;
-			}
-			return c1->sequence > c2->sequence;
+	else if (c1->location == LOCATION_DECK) {
+		return c1->sequence > c2->sequence;
+	}
+	else if (c1->location & (LOCATION_GRAVE | LOCATION_REMOVED | LOCATION_EXTRA)) {
+		auto it1 = std::find_if(mainGame->dField.chains.rbegin(), mainGame->dField.chains.rend(), [c1](const ChainInfo& ch) {
+			return c1 == ch.chain_card || ch.target.find(c1) != ch.target.end();
+		});
+		auto it2 = std::find_if(mainGame->dField.chains.rbegin(), mainGame->dField.chains.rend(), [c2](const ChainInfo& ch) {
+			return c2 == ch.chain_card || ch.target.find(c2) != ch.target.end();
+		});
+		if (it1 != mainGame->dField.chains.rend() || it2 != mainGame->dField.chains.rend()) {
+			return it1 < it2;
 		}
-		else
-			return c1->sequence < c2->sequence;
-	}
-}
-bool ClientCard::deck_sort_lv(code_pointer p1, code_pointer p2) {
-	if((p1->second.type & 0x7) != (p2->second.type & 0x7))
-		return (p1->second.type & 0x7) < (p2->second.type & 0x7);
-	if((p1->second.type & 0x7) == 1) {
-		int type1 = (p1->second.type & 0x48020c0) ? (p1->second.type & 0x48020c1) : (p1->second.type & 0x31);
-		int type2 = (p2->second.type & 0x48020c0) ? (p2->second.type & 0x48020c1) : (p2->second.type & 0x31);
-		if(type1 != type2)
-			return type1 < type2;
-		if(p1->second.level != p2->second.level)
-			return p1->second.level > p2->second.level;
-		if(p1->second.attack != p2->second.attack)
-			return p1->second.attack > p2->second.attack;
-		if(p1->second.defense != p2->second.defense)
-			return p1->second.defense > p2->second.defense;
-		return p1->first < p2->first;
+		return c1->sequence > c2->sequence;
 	}
-	if((p1->second.type & 0xfffffff8) != (p2->second.type & 0xfffffff8))
-		return (p1->second.type & 0xfffffff8) < (p2->second.type & 0xfffffff8);
-	return p1->first < p2->first;
-}
-bool ClientCard::deck_sort_atk(code_pointer p1, code_pointer p2) {
-	if((p1->second.type & 0x7) != (p2->second.type & 0x7))
-		return (p1->second.type & 0x7) < (p2->second.type & 0x7);
-	if((p1->second.type & 0x7) == 1) {
-		if(p1->second.attack != p2->second.attack)
-			return p1->second.attack > p2->second.attack;
-		if(p1->second.defense != p2->second.defense)
-			return p1->second.defense > p2->second.defense;
-		if(p1->second.level != p2->second.level)
-			return p1->second.level > p2->second.level;
-		int type1 = (p1->second.type & 0x48020c0) ? (p1->second.type & 0x48020c1) : (p1->second.type & 0x31);
-		int type2 = (p2->second.type & 0x48020c0) ? (p2->second.type & 0x48020c1) : (p2->second.type & 0x31);
-		if(type1 != type2)
-			return type1 < type2;
-		return p1->first < p2->first;
-	}
-	if((p1->second.type & 0xfffffff8) != (p2->second.type & 0xfffffff8))
-		return (p1->second.type & 0xfffffff8) < (p2->second.type & 0xfffffff8);
-	return p1->first < p2->first;
-}
-bool ClientCard::deck_sort_def(code_pointer p1, code_pointer p2) {
-	if((p1->second.type & 0x7) != (p2->second.type & 0x7))
-		return (p1->second.type & 0x7) < (p2->second.type & 0x7);
-	if((p1->second.type & 0x7) == 1) {
-		if(p1->second.defense != p2->second.defense)
-			return p1->second.defense > p2->second.defense;
-		if(p1->second.attack != p2->second.attack)
-			return p1->second.attack > p2->second.attack;
-		if(p1->second.level != p2->second.level)
-			return p1->second.level > p2->second.level;
-		int type1 = (p1->second.type & 0x48020c0) ? (p1->second.type & 0x48020c1) : (p1->second.type & 0x31);
-		int type2 = (p2->second.type & 0x48020c0) ? (p2->second.type & 0x48020c1) : (p2->second.type & 0x31);
-		if(type1 != type2)
-			return type1 < type2;
-		return p1->first < p2->first;
+	else {
+		return c1->sequence < c2->sequence;
 	}
-	if((p1->second.type & 0xfffffff8) != (p2->second.type & 0xfffffff8))
-		return (p1->second.type & 0xfffffff8) < (p2->second.type & 0xfffffff8);
-	return p1->first < p2->first;
-}
-bool ClientCard::deck_sort_name(code_pointer p1, code_pointer p2) {
-	const wchar_t* name1 = dataManager.GetName(p1->first);
-	const wchar_t* name2 = dataManager.GetName(p2->first);
-	int res = wcscmp(name1, name2);
-	if(res != 0)
-		return res < 0;
-	return p1->first < p2->first;
 }
 }

gframe/client_card.h

@@ -2,27 +2,12 @@
 #define CLIENT_CARD_H
 
 #include "config.h"
-#include "../ocgcore/card_data.h"
 #include <vector>
 #include <set>
 #include <map>
-#include <unordered_map>
 
 namespace ygo {
 
-using CardData = card_data;
-struct CardDataC : card_data {
-	unsigned int ot{};
-	unsigned int category{};
-};
-struct CardString {
-	std::wstring name;
-	std::wstring text;
-	std::wstring desc[16];
-};
-typedef std::unordered_map<unsigned int, CardDataC>::const_iterator code_pointer;
-typedef std::unordered_map<unsigned int, CardString>::const_iterator string_pointer;
-
 class ClientCard {
 public:
 	irr::core::matrix4 mTransform;
@@ -30,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 };
@@ -90,15 +75,11 @@ public:
 
 	ClientCard() = default;
 	~ClientCard();
-	void SetCode(int code);
+	void SetCode(unsigned int x);
 	void UpdateInfo(unsigned char* buf);
 	void ClearTarget();
 	void ClearData();
 	static bool client_card_sort(ClientCard* c1, ClientCard* c2);
-	static bool deck_sort_lv(code_pointer l1, code_pointer l2);
-	static bool deck_sort_atk(code_pointer l1, code_pointer l2);
-	static bool deck_sort_def(code_pointer l1, code_pointer l2);
-	static bool deck_sort_name(code_pointer l1, code_pointer l2);
 };
 
 }

gframe/client_field.h

@@ -2,7 +2,7 @@
 #define CLIENT_FIELD_H
 
 #include "config.h"
-#include "../ocgcore/mtrandom.h"
+#include <random>
 #include <vector>
 #include <set>
 #include <map>
@@ -57,9 +57,12 @@ public:
 	int select_min{ 0 };
 	int select_max{ 0 };
 	int must_select_count{ 0 };
+	int select_curval_l{ 0 };
+	int select_curval_h{ 0 };
 	int select_sumval{ 0 };
 	int select_mode{ 0 };
-	bool select_cancelable{ false };
+	int select_hint{0};
+	bool select_cancelable{false};
 	bool select_panalmode{ false };
 	bool select_ready{ false };
 	int announce_count{ 0 };
@@ -69,15 +72,15 @@ public:
 	std::vector<ClientCard*> selected_cards;
 	std::set<ClientCard*> selectsum_cards;
 	std::vector<ClientCard*> selectsum_all;
-	std::vector<int> declare_opcodes;
+	std::vector<unsigned int> declare_opcodes;
 	std::vector<ClientCard*> display_cards;
 	std::vector<int> sort_list;
 	std::map<int, int> player_desc_hints[2];
-	bool grave_act{ false };
-	bool remove_act{ false };
-	bool deck_act{ false };
-	bool extra_act{ false };
-	bool pzone_act[2]{};
+	bool grave_act[2]{ false };
+	bool remove_act[2]{ false };
+	bool deck_act[2]{ false };
+	bool extra_act[2]{ false };
+	bool pzone_act[2]{ false };
 	bool conti_act{ false };
 	bool chain_forced{ false };
 	ChainInfo current_chain;
@@ -85,12 +88,15 @@ public:
 	bool deck_reversed{ false };
 	bool conti_selecting{ false };
 	bool cant_check_grave{ false };
-	mt19937 rnd;
+	bool tag_surrender{ false };
+	bool tag_teammate_surrender{ false };
+	std::mt19937 rnd;
 
 	ClientField();
 	~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);
@@ -139,8 +145,8 @@ public:
 	ClientCard* menu_card{ nullptr };
 	int list_command{ 0 };
 
-	virtual bool OnEvent(const irr::SEvent& event);
-	virtual bool OnCommonEvent(const irr::SEvent& event);
+	bool OnEvent(const irr::SEvent& event) override;
+	bool OnCommonEvent(const irr::SEvent& event);
 	void GetHoverField(int x, int y);
 	void ShowMenu(int flag, int x, int y);
 	void HideMenu();
@@ -156,8 +162,6 @@ public:
 }
 
 //special cards
-#define CARD_MARINE_DOLPHIN	78734254
-#define CARD_TWINKLE_MOSS	13857930
 #define CARD_QUESTION		38723936
 
 #endif //CLIENT_FIELD_H

gframe/config.h

-#ifndef __CONFIG_H
-#define __CONFIG_H
-
-#pragma once
+#ifndef YGOPRO_CONFIG_H
+#define YGOPRO_CONFIG_H
 
 #define _IRR_STATIC_LIB_
 #define IRR_COMPILE_WITH_DX9_DEV_PACK
+
+#include <cerrno>
+
 #ifdef _WIN32
 
 #define NOMINMAX
@@ -12,7 +13,7 @@
 #include <windows.h>
 #include <ws2tcpip.h>
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) or defined(__MINGW32__)
 #define mywcsncasecmp _wcsnicmp
 #define mystrncasecmp _strnicmp
 #else
@@ -24,14 +25,12 @@
 
 #else //_WIN32
 
-#include <errno.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <arpa/inet.h>
 #include <netdb.h>
 #include <unistd.h>
-#include <locale.h>
 
 #define SD_BOTH 2
 #define SOCKET int
@@ -42,54 +41,56 @@
 #define SOCKADDR sockaddr
 #define SOCKET_ERRNO() (errno)
 
-#include <wchar.h>
 #define mywcsncasecmp wcsncasecmp
 #define mystrncasecmp strncasecmp
-inline int _wtoi(const wchar_t * s) {
-	wchar_t * endptr;
-	return (int)wcstol(s, &endptr, 10);
-}
 #endif
 
-template<size_t N, typename... TR>
-inline int myswprintf(wchar_t(&buf)[N], const wchar_t* fmt, TR... args) {
-	return swprintf(buf, N, fmt, args...);
-}
-
-#include <irrlicht.h>
-#ifdef __APPLE__
-#include <OpenGL/gl.h>
-#include <OpenGL/glu.h>
-#else //__APPLE__
-#include <GL/gl.h>
-#include <GL/glu.h>
-#endif //__APPLE__
-#include "CGUITTFont.h"
-#include "CGUIImageButton.h"
+#include <cstdio>
+#include <cstdlib>
 #include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#include <thread>
-#include <mutex>
 #include <algorithm>
+#include <string>
 #include "bufferio.h"
-#include "myfilesystem.h"
-#include "mysignal.h"
 #include "../ocgcore/ocgapi.h"
-#include "../ocgcore/common.h"
 
-using namespace irr;
-using namespace core;
-using namespace scene;
-using namespace video;
-using namespace io;
-using namespace gui;
+template<size_t N, typename... TR>
+inline int myswprintf(wchar_t(&buf)[N], const wchar_t* fmt, TR... args) {
+	return std::swprintf(buf, N, fmt, args...);
+}
+
+inline FILE* mywfopen(const wchar_t* filename, const char* mode) {
+	FILE* fp{};
+#ifdef _WIN32
+	wchar_t wmode[20]{};
+	BufferIO::CopyCharArray(mode, wmode);
+	fp = _wfopen(filename, wmode);
+#else
+	char fname[1024]{};
+	BufferIO::EncodeUTF8(filename, fname);
+	fp = std::fopen(fname, mode);
+#endif
+	return fp;
+}
 
-typedef int BOOL;
+#if !defined(_WIN32)
+#define myfopen std::fopen
+#elif defined(WDK_NTDDI_VERSION) && (WDK_NTDDI_VERSION >= 0x0A000005) // Redstone 4, Version 1803, Build 17134.
+#define FOPEN_WINDOWS_SUPPORT_UTF8
+#define myfopen std::fopen
+#else
+inline FILE* myfopen(const char* filename, const char* mode) {
+	wchar_t wfilename[256]{};
+	BufferIO::DecodeUTF8(filename, wfilename);
+	wchar_t wmode[20]{};
+	BufferIO::CopyCharArray(mode, wmode);
+	return _wfopen(wfilename, wmode);
+}
+#endif
+
+#include <irrlicht.h>
 
 extern const unsigned short PRO_VERSION;
-extern int enable_log;
+extern unsigned int enable_log;
 extern bool exit_on_return;
 extern bool open_file;
 extern wchar_t open_file_name[256];

gframe/data_manager.h

 #ifndef DATAMANAGER_H
 #define DATAMANAGER_H
 
-#include "config.h"
-#include "sqlite3.h"
-#include "spmemvfs/spmemvfs.h"
-#include "client_card.h"
 #include <unordered_map>
+#include <vector>
+#include <string>
+#include <sqlite3.h>
+#include "../ocgcore/card_data.h"
+
+namespace irr {
+	namespace io {
+		class IReadFile;
+		class IFileSystem;
+	}
+}
 
 namespace ygo {
+constexpr int MAX_STRING_ID = 0x7ff;
+constexpr unsigned int MIN_CARD_ID = (unsigned int)(MAX_STRING_ID + 1) >> 4;
+constexpr unsigned int MAX_CARD_ID = 0x0fffffffU;
+	
+using CardData = card_data;
+struct CardDataC : card_data {
+	uint32_t ot{};
+	uint32_t category{};
+
+	bool is_setcodes(const std::vector<unsigned int>& values) const {
+		for (auto& value : values) {
+			if (is_setcode(value))
+				return true;
+		}
+		return false;
+	}
+};
+struct CardString {
+	std::wstring name;
+	std::wstring text;
+	std::wstring desc[16];
+};
+using code_pointer = std::unordered_map<unsigned int, CardDataC>::const_iterator;
+using string_pointer = std::unordered_map<unsigned int, CardString>::const_iterator;
 
 class DataManager {
 public:
 	DataManager();
+	bool ReadDB(sqlite3* pDB);
 	bool LoadDB(const wchar_t* wfile);
 	bool LoadStrings(const char* file);
-	bool LoadStrings(IReadFile* reader);
+	bool LoadStrings(irr::io::IReadFile* reader);
 	void ReadStringConfLine(const char* linebuf);
-	bool Error(spmemvfs_db_t* pDB, sqlite3_stmt* pStmt = 0);
-	bool GetData(unsigned int code, CardData* pData);
+	bool Error(sqlite3* pDB, sqlite3_stmt* pStmt = nullptr);
+
 	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);
-	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);
-	const wchar_t* GetNumString(int num, bool bracket = false);
-	const wchar_t* FormatLocation(int location, int sequence);
-	const wchar_t* FormatAttribute(int attribute);
-	const wchar_t* FormatRace(int race);
-	const wchar_t* FormatType(int type);
-	const wchar_t* FormatSetName(const uint16_t setcode[]);
-	const wchar_t* FormatLinkMarker(int link_marker);
+	code_pointer datas_begin() const;
+	code_pointer datas_end() const;
+	string_pointer strings_begin() const;
+	string_pointer strings_end() const;
+	bool GetData(unsigned int code, CardData* pData) const;
+	bool GetString(unsigned int code, CardString* pStr) const;
+	const wchar_t* GetName(unsigned int code) const;
+	const wchar_t* GetText(unsigned int code) const;
+	const wchar_t* GetDesc(unsigned int strCode) const;
+	const wchar_t* GetSysString(int code) const;
+	const wchar_t* GetVictoryString(int code) const;
+	const wchar_t* GetCounterName(int code) const;
+	const wchar_t* GetSetName(int code) const;
+	std::vector<unsigned int> GetSetCodes(std::wstring setname) const;
+	std::wstring GetNumString(int num, bool bracket = false) const;
+	const wchar_t* FormatLocation(int location, int sequence) const;
+	std::wstring FormatAttribute(unsigned int attribute) const;
+	std::wstring FormatRace(unsigned int race) const;
+	std::wstring FormatType(unsigned int type) const;
+	std::wstring FormatSetName(const uint16_t setcode[]) const;
+	std::wstring FormatLinkMarker(unsigned int link_marker) const;
 
 	std::unordered_map<unsigned int, std::wstring> _counterStrings;
 	std::unordered_map<unsigned int, std::wstring> _victoryStrings;
 	std::unordered_map<unsigned int, std::wstring> _setnameStrings;
 	std::unordered_map<unsigned int, std::wstring> _sysStrings;
-	code_pointer datas_begin;
-	code_pointer datas_end;
-	string_pointer strings_begin;
-	string_pointer strings_end;
+	char errmsg[512]{};
 
-	wchar_t numStrings[301][4];
-	wchar_t numBuffer[6];
-	wchar_t attBuffer[128];
-	wchar_t racBuffer[128];
-	wchar_t tpBuffer[128];
-	wchar_t scBuffer[128];
-	wchar_t lmBuffer[32];
-
-	static byte scriptBuffer[0x20000];
+	static unsigned char scriptBuffer[0x100000];
 	static const wchar_t* unknown_string;
-	static uint32 CardReader(uint32, card_data*);
-	static byte* ScriptReaderEx(const char* script_name, int* slen);
-	static byte* ScriptReader(const char* script_name, int* slen);
-	static IFileSystem* FileSystem;
+	static uint32_t CardReader(uint32_t, card_data*);
+	static unsigned char* ScriptReaderEx(const char* script_path, int* slen);
+	
+	//read by IFileSystem
+	static unsigned char* ReadScriptFromIrrFS(const char* script_name, int* slen);
+	//read by fread
+	static unsigned char* ReadScriptFromFile(const char* script_name, int* slen);
+	
+	static irr::io::IFileSystem* FileSystem;
+
+	static bool deck_sort_lv(code_pointer l1, code_pointer l2);
+	static bool deck_sort_atk(code_pointer l1, code_pointer l2);
+	static bool deck_sort_def(code_pointer l1, code_pointer l2);
+	static bool deck_sort_name(code_pointer l1, code_pointer l2);
 
 private:
 	std::unordered_map<unsigned int, CardDataC> _datas;

gframe/image_manager.h

@@ -5,6 +5,7 @@
 #include "data_manager.h"
 #include <unordered_map>
 #include <queue>
+#include <mutex>
 
 namespace ygo {
 
@@ -15,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/menu_handler.h

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

gframe/single_mode.h

 #ifndef SINGLE_MODE_H
 #define SINGLE_MODE_H
 
-#include <stdint.h>
+#include <cstdint>
 #include <vector>
 #include "replay.h"
 
@@ -30,7 +30,7 @@ public:
 	static void SinglePlayRefreshSingle(int player, int location, int sequence, int flag = 0xf81fff);
 	static void SinglePlayReload();
 
-	static uint32 MessageHandler(intptr_t fduel, uint32 type);
+	static uint32_t MessageHandler(intptr_t fduel, uint32_t type);
 
 protected:
 	static Replay last_replay;

ocgcore @ 2c754979

-Subproject commit 06b41f47d45c6a9b00882aeff21d4e8f380b7bba
+Subproject commit 2c75497923afa6d7e6097cc31ecc3f7f96dc3b8b

script @ a76cc0be

-Subproject commit 78e2d6bc30f435724338a3727aff2e4bd9d7b3c8
+Subproject commit a76cc0be83a3928a726547a239bcca8013ce3225