Merge branch 'master' into 'tmp-coccvo'

update

See merge request !5

.ci/asset-branch

+export ASSET_BRANCH_NAME="master"
+
+# if $CI_COMMIT_REF_NAME includes develop or pre, then we use the develop branch
+if [[ "$CI_COMMIT_REF_NAME" == *"develop"* || "$CI_COMMIT_REF_NAME" == *".pre"* ]]; then
+  export ASSET_BRANCH_NAME="develop"
+fi

.ci/assets-locale.sh

 #!/bin/bash
 set -x
 set -o errexit
+source .ci/asset-branch
 # ygopro-database
-apt update && apt -y install wget git libarchive-tools
-git clone --depth=1 https://code.mycard.moe/nanahira/ygopro-database
-cp -rf ./ygopro-database/locales/$TARGET_LOCALE/* .
+apt update && apt -y install wget git libarchive-tools sqlite3
+git clone --depth=1 -b master https://code.moenext.com/nanahira/ygopro-database
+cp -rf ./ygopro-database/locales/$TARGET_LOCALE/strings.conf .
+cp -rf ./ygopro-database/locales/$TARGET_LOCALE/servers.conf .
+rm -f cards.cdb
+sqlite3 ./ygopro-database/locales/$TARGET_LOCALE/cards.cdb .dump | sqlite3 cards.cdb
 # ygopro-images
 mkdir pics
-wget -O - https://cdn01.moecube.com/images/ygopro-images-${TARGET_LOCALE}.zip | bsdtar -C pics -xf -
+if [[ "$ASSET_BRANCH_NAME" == "develop" ]]; then
+  echo "This is a pre-release, skipping download."
+else
+  wget -O - https://cdn02.moecube.com:444/images/ygopro-images-${TARGET_LOCALE}.zip | bsdtar -C pics -xf -
+fi

.ci/configure-audio.sh

+#!/bin/bash
+
+libs_to_configure=(
+  "ogg"
+  # "opus"
+)
+
+cd miniaudio/external
+for lib in "${libs_to_configure[@]}"; do
+  cd $lib
+  ./configure
+  cd ..
+done

.ci/configure-libevent.sh

+#!/bin/sh
+set -x
+set -o errexit
+
+cd event
+./configure --disable-openssl --enable-static=yes --enable-shared=no
+sed -f make-event-config.sed < config.h > ./include/event2/event-config.h
+cd ..

.ci/exec-macos-platform.sh

@@ -4,21 +4,19 @@ set -o errexit
 
 TARGET_PLATFORM=$(arch)
 TARGET_YGOPRO_BINARY_PATH=./ygopro-platforms/ygopro-platform-$TARGET_PLATFORM
-export EVENT_INCLUDE_DIR=$PWD/libevent-stable/include
-export EVENT_LIB_DIR=$PWD/libevent-stable/lib
-export IRRLICHT_INCLUDE_DIR=$PWD/irrlicht/include
-export IRRLICHT_LIB_DIR=$PWD/irrlicht/lib/$(arch)
 
-./.ci/libevent-prebuild.sh
+./.ci/configure-audio.sh
 
-./premake5 gmake --cc=clang --build-freetype --build-sqlite --no-use-irrklang
+rm -rf sqlite3/VERSION sqlite3/version
+
+./premake5 gmake --cc=clang
 
 cd build
-make config=release -j4
+make config=release -j$(sysctl -n hw.ncpu)
 cd ..
 
 mkdir ygopro-platforms
-mv bin/release/YGOPro.app $TARGET_YGOPRO_BINARY_PATH
+mv bin/release/YGOPro $TARGET_YGOPRO_BINARY_PATH
 
 #if [[ $TARGET_PLATFORM == "x86" ]]; then
 #  install_name_tool -change /usr/local/lib/libirrklang.dylib @executable_path/../Frameworks/libirrklang.dylib $TARGET_YGOPRO_BINARY_PATH

.ci/pack-linux-dlc.sh

@@ -2,9 +2,15 @@
 set -x
 set -o errexit
 
-ARCHIVE_FILES=(ygopro lib cards.cdb locales fonts sound textures strings.conf system.conf pack)
+ARCHIVE_FILES=(ygopro cards.cdb locales fonts sound textures strings.conf system.conf servers.conf pack)
 
-TARGET_PLATFORM=linux
+if [[ -z "$TARGET_PLATFORM" ]]; then
+    TARGET_PLATFORM=linux
+fi
+
+#if [[ "$TARGET_PLATFORM" != "linuxarm" ]]; then
+    ARCHIVE_FILES+=(sound)
+#fi
 
 apt update && apt -y install tar zstd
 mkdir dist replay

.ci/pack-linux.sh

@@ -2,11 +2,17 @@
 set -x
 set -o errexit
 
-ARCHIVE_FILES=(ygopro LICENSE README.md lib lflist.conf strings.conf system.conf cards.cdb script textures deck single pics replay sound windbot bot bot.conf locales fonts pack)
+ARCHIVE_FILES=(ygopro LICENSE README.md lflist.conf strings.conf system.conf servers.conf cards.cdb script textures deck single pics replay windbot bot bot.conf locales fonts pack)
 
 # TARGET_LOCALE
 # ARCHIVE_SUFFIX
-TARGET_PLATFORM=linux
+if [[ -z "$TARGET_PLATFORM" ]]; then
+    TARGET_PLATFORM=linux
+fi
+
+if [[ "$TARGET_PLATFORM" != "linuxarm" ]]; then
+    ARCHIVE_FILES+=(sound)
+fi
 
 apt update && apt -y install tar git zstd
 mkdir dist replay

.ci/pack-macos-dlc.sh

@@ -2,9 +2,11 @@
 set -x
 set -o errexit
 
-ARCHIVE_FILES=(ygopro.app cards.cdb locales fonts textures strings.conf system.conf pack)
+ARCHIVE_FILES=(ygopro.app cards.cdb locales fonts sound textures strings.conf system.conf servers.conf pack)
 
-TARGET_PLATFORM=darwin
+if [[ -z "$TARGET_PLATFORM" ]]; then
+    TARGET_PLATFORM=darwin
+fi
 
 apt update && apt -y install tar zstd
 mkdir dist replay

.ci/pack-macos.sh

@@ -2,11 +2,13 @@
 set -x
 set -o errexit
 
-ARCHIVE_FILES=(ygopro.app LICENSE README.md lflist.conf strings.conf system.conf cards.cdb script textures deck single pics replay windbot bot bot.conf locales fonts pack)
+ARCHIVE_FILES=(ygopro.app LICENSE README.md lflist.conf strings.conf system.conf servers.conf cards.cdb script textures deck single pics replay sound windbot bot bot.conf locales fonts pack)
 
 # TARGET_LOCALE
 # ARCHIVE_SUFFIX
-TARGET_PLATFORM=darwin
+if [[ -z "$TARGET_PLATFORM" ]]; then
+    TARGET_PLATFORM=darwin
+fi
 
 apt update && apt -y install tar git zstd
 mkdir dist replay

.ci/pack-windows-7z.sh

@@ -2,14 +2,16 @@
 set -x
 set -o errexit
 
-ARCHIVE_FILES=(ygopro.exe LICENSE README.md lflist.conf strings.conf system.conf cards.cdb script textures deck single pics replay sound bot.conf Bot.exe WindBot locales fonts skin pack)
+ARCHIVE_FILES=(ygopro.exe vcomp140.dll LICENSE README.md lflist.conf strings.conf system.conf servers.conf cards.cdb script textures deck single pics replay sound bot.conf Bot.exe WindBot locales fonts skin pack)
 
 if [[ "$TARGET_LOCALE" == "zh-CN" ]]; then
 	ARCHIVE_FILES=("${ARCHIVE_FILES[@]}" update-koishipro)
 fi
 
 # TARGET_LOCALE
-TARGET_PLATFORM=win32
+if [[ -z "$TARGET_PLATFORM" ]]; then
+    TARGET_PLATFORM=win32
+fi
 
 apt update && apt -y install p7zip-full git
 mkdir dist replay

.ci/pack-windows-dlc.sh

@@ -2,9 +2,11 @@
 set -x
 set -o errexit
 
-ARCHIVE_FILES=(ygopro.exe cards.cdb locales fonts sound textures strings.conf system.conf skin pack)
+ARCHIVE_FILES=(ygopro.exe vcomp140.dll cards.cdb locales fonts sound textures strings.conf system.conf servers.conf skin pack)
 
-TARGET_PLATFORM=win32
+if [[ -z "$TARGET_PLATFORM" ]]; then
+    TARGET_PLATFORM=win32
+fi
 
 apt update && apt -y install tar zstd
 mkdir dist replay

.ci/pack-windows.sh

@@ -2,7 +2,7 @@
 set -x
 set -o errexit
 
-ARCHIVE_FILES=(ygopro.exe LICENSE README.md lflist.conf strings.conf system.conf cards.cdb script textures deck single pics replay sound bot.conf Bot.exe WindBot locales fonts skin pack)
+ARCHIVE_FILES=(ygopro.exe vcomp140.dll LICENSE README.md lflist.conf strings.conf system.conf servers.conf cards.cdb script textures deck single pics replay sound bot.conf Bot.exe WindBot locales fonts skin pack)
 
 if [[ "$TARGET_LOCALE" == "zh-CN" && "$ARCHIVE_SUFFIX" != "zst" ]]; then
 	ARCHIVE_FILES=("${ARCHIVE_FILES[@]}" update-koishipro)
@@ -10,7 +10,9 @@ fi
 
 # TARGET_LOCALE
 # ARCHIVE_SUFFIX
-TARGET_PLATFORM=win32
+if [[ -z "$TARGET_PLATFORM" ]]; then
+    TARGET_PLATFORM=win32
+fi
 
 apt update && apt -y install tar git zstd
 mkdir dist replay

.ci/prepare-irrlicht.sh

+#!/bin/bash
+set -x
+set -o errexit
+
+source .ci/prepare-repo
+prepare_repo "https://code.moenext.com/mycard/irrlicht-new.git" "irrlicht"

.ci/prepare-miniaudio.sh

+#!/bin/bash
+set -x
+set -o errexit
+
+source .ci/prepare-repo
+prepare_repo "https://code.moenext.com/mycard/miniaudio.git" "miniaudio"
+
+cp -rf miniaudio/extras/miniaudio_split/miniaudio.* miniaudio/
+
+mkdir -p miniaudio/external
+
+install_external() {
+  dir="$1"
+  url="$2"
+  if [ ! -d "miniaudio/external/$dir" ]; then
+    mkdir -p "miniaudio/external/$dir"
+    # Download the external library and strip one level of directories from the archive
+    wget -O - "$url" | tar --strip-components=1 -C "miniaudio/external/$dir" -zxf -
+  fi
+}
+
+install_external "ogg" "https://mat-cacher.moenext.com/https://github.com/xiph/ogg/releases/download/v1.3.5/libogg-1.3.5.tar.gz"
+install_external "opus" "https://mat-cacher.moenext.com/https://github.com/xiph/opus/releases/download/v1.5.2/opus-1.5.2.tar.gz"
+install_external "opusfile" "https://mat-cacher.moenext.com/https://github.com/xiph/opusfile/releases/download/v0.12/opusfile-0.12.tar.gz"
+install_external "vorbis" "https://mat-cacher.moenext.com/https://github.com/xiph/vorbis/releases/download/v1.3.7/libvorbis-1.3.7.tar.gz"

.ci/prepare-repo

+source .ci/asset-branch
+BRANCH_NAME="$ASSET_BRANCH_NAME"
+
+prepare_repo() {
+  REPO_URL="$1"
+  TARGET_DIR_NAME="$2"
+
+  if [ ! -d "$TARGET_DIR_NAME" ]; then
+    echo "Cloning repository $REPO_URL branch $BRANCH_NAME into $TARGET_DIR_NAME"
+    git clone --depth=1 --branch "$BRANCH_NAME" "$REPO_URL" "$TARGET_DIR_NAME"
+  else
+    echo "Repository $REPO_URL already exists in $TARGET_DIR_NAME, updating to $BRANCH_NAME..."
+    cd "$TARGET_DIR_NAME"
+    git remote set-url origin "$REPO_URL"
+    git fetch origin "$BRANCH_NAME"
+    git checkout "$BRANCH_NAME"
+    git reset --hard origin/"$BRANCH_NAME"
+    cd ..
+  fi
+}

.ci/upload-packager.sh

@@ -33,9 +33,15 @@ runForDepot() {
   echo "$result" | jq .
 }
 
-runForDepot win32 zh-CN
-runForDepot linux zh-CN
-runForDepot darwin zh-CN
-runForDepot win32 en-US
-runForDepot linux en-US
-runForDepot darwin en-US
+source .ci/asset-branch
+
+if [[ "$ASSET_BRANCH_NAME" == "develop" ]]; then
+  echo "This is a pre-release, skipping upload."
+else
+  runForDepot win32 zh-CN
+  runForDepot linux zh-CN
+  runForDepot darwin zh-CN
+  runForDepot win32 en-US
+  runForDepot linux en-US
+  runForDepot darwin en-US
+fi

.gitignore

@@ -16,6 +16,7 @@ build
 /irrklang
 /irrlicht*
 /lua
+/miniaudio
 
 # gframe additionals
 /gframe/ygopro.ico
@@ -76,7 +77,7 @@ build
 /ygopro_*.app
 /premake4
 /premake4.exe
-/premake5
+/premake5*
 /premake5.exe
 
 # others

cmake/CMakeLists.txt

+project (ygo)
+
+cmake_minimum_required (VERSION 3.8)
+
+if(NOT CMAKE_BUILD_TYPE)
+    message(STATUS "Setting build type to 'Debug' as none was specified.")
+    set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/macros")
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+include (AutoFiles)
+
+include (platform/settings)
+
+if (MSVC)
+    add_subdirectory (event)
+    add_subdirectory (freetype)
+    add_subdirectory (irrlicht)
+    add_subdirectory (sqlite3)
+    add_subdirectory (lua)
+else ()
+    find_package(LibEvent REQUIRED)
+    find_package(Freetype REQUIRED)
+    find_package(Irrlicht REQUIRED)
+    find_package(Sqlite REQUIRED)
+    find_package(Lua REQUIRED)
+    find_package(OpenGL REQUIRED)
+endif ()
+
+option(USE_IRRKLANG "Use irrKlang sound library" OFF)
+if (USE_IRRKLANG)
+    set(IRRKLANG_DIR ${CMAKE_SOURCE_DIR}/irrKlang)
+endif ()
+
+add_subdirectory (ocgcore)
+add_subdirectory (gframe)

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

@@ -2,44 +2,47 @@
 #define BUFFERIO_H
 
 #include <cstdint>
+#include <cwchar>
 #include "../ocgcore/buffer.h"
 
 class BufferIO {
 public:
-	inline static int ReadInt32(unsigned char*& p) {
+	static int ReadInt32(unsigned char*& p) {
 		return buffer_read<int32_t>(p);
 	}
-	inline static unsigned int ReadUInt32(unsigned char*& p) {
-		unsigned int ret = *(unsigned int*)p;
-		p += 4;
-		return ret;
+	static unsigned int ReadUInt32(unsigned char*& p) {
+		return buffer_read<uint32_t>(p);
 	}
-	inline static short ReadInt16(unsigned char*& p) {
+	static short ReadInt16(unsigned char*& p) {
 		return buffer_read<int16_t>(p);
 	}
-	inline static unsigned short ReadUInt16(unsigned char*& p) {
-		unsigned short ret = *(unsigned short*)p;
-		p += 2;
-		return ret;
+	static unsigned short ReadUInt16(unsigned char*& p) {
+		return buffer_read<uint16_t>(p);
 	}
-	inline static char ReadInt8(unsigned char*& p) {
+	static char ReadInt8(unsigned char*& p) {
 		return buffer_read<char>(p);
 	}
-	inline static unsigned char ReadUInt8(unsigned char*& p) {
+	static unsigned char ReadUInt8(unsigned char*& p) {
 		return buffer_read<unsigned char>(p);
 	}
-	inline static void WriteInt32(unsigned char*& p, int val) {
+	static void WriteInt32(unsigned char*& p, int val) {
 		buffer_write<int32_t>(p, val);
 	}
-	inline static void WriteInt16(unsigned char*& p, short val) {
+	static void WriteInt16(unsigned char*& p, short val) {
 		buffer_write<int16_t>(p, val);
 	}
-	inline static void WriteInt8(unsigned char*& p, char val) {
+	static void WriteInt8(unsigned char*& p, char val) {
 		buffer_write<char>(p, val);
 	}
-	// return: string length
+	/**
+	* @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(const 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] = (T2)src[l];
@@ -49,7 +52,7 @@ public:
 		return l;
 	}
 	template<typename T1, typename T2>
-	inline static int CopyWStrRef(const 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] = (T2)src[l];
@@ -59,22 +62,131 @@ public:
 		*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
 	// return: string length
 	static int EncodeUTF8String(const wchar_t* wsrc, char* str, int size) {
-		char* pstr = str;
-		while (*wsrc != 0) {
-			unsigned cur = *wsrc;
+		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 && (cur < 0xd800U || cur > 0xdfffU))
+			else if (cur < 0x10000U)
 				codepoint_size = 3;
 			else
 				codepoint_size = 4;
-			if (pstr - str + codepoint_size > size - 1)
+			if ((int)(pstr - str) + codepoint_size > size - 1)
 				break;
 			switch (codepoint_size) {
 			case 1:
@@ -90,13 +202,6 @@ public:
 				pstr[2] = (cur & 0x3f) | 0x80;
 				break;
 			case 4:
-				if (sizeof(wchar_t) == 2) {
-					cur = 0;
-					cur |= ((unsigned)*wsrc & 0x3ff) << 10;
-					++wsrc;
-					cur |= (unsigned)*wsrc & 0x3ff;
-					cur += 0x10000;
-				}
 				pstr[0] = ((cur >> 18) & 0x7) | 0xf0;
 				pstr[1] = ((cur >> 12) & 0x3f) | 0x80;
 				pstr[2] = ((cur >> 6) & 0x3f) | 0x80;
@@ -106,10 +211,9 @@ public:
 				break;
 			}
 			pstr += codepoint_size;
-			wsrc++;
 		}
 		*pstr = 0;
-		return pstr - str;
+		return (int)(pstr - str);
 	}
 	// UTF-8 to UTF-16/UTF-32
 	// return: string length
@@ -117,9 +221,11 @@ public:
 		const char* p = src;
 		wchar_t* wp = wstr;
 		while(*p != 0) {
-			const unsigned cur = (unsigned)*p & 0xff;
+			unsigned int cur = ConvertUTF8(p);
 			int codepoint_size = 0;
-			if ((cur & 0xf8) == 0xf0) {
+			if (!IsUnicodeChar(cur))
+				continue;
+			if (cur >= 0x10000) {
 				if (sizeof(wchar_t) == 2)
 					codepoint_size = 2;
 				else
@@ -127,30 +233,18 @@ public:
 			}
 			else
 				codepoint_size = 1;
-			if (wp - wstr + codepoint_size > size - 1)
+			if ((int)(wp - wstr) + codepoint_size > size - 1)
 				break;
-			if((cur & 0x80) == 0) {
-				*wp = *p;
-				p++;
-			} else if((cur & 0xe0) == 0xc0) {
-				*wp = (((unsigned)p[0] & 0x1f) << 6) | ((unsigned)p[1] & 0x3f);
-				p += 2;
-			} else if((cur & 0xf0) == 0xe0) {
-				*wp = (((unsigned)p[0] & 0xf) << 12) | (((unsigned)p[1] & 0x3f) << 6) | ((unsigned)p[2] & 0x3f);
-				p += 3;
-			} else if((cur & 0xf8) == 0xf0) {
-				if (sizeof(wchar_t) == 2) {
-					unsigned unicode = (((unsigned)p[0] & 0x7) << 18) | (((unsigned)p[1] & 0x3f) << 12) | (((unsigned)p[2] & 0x3f) << 6) | ((unsigned)p[3] & 0x3f);
-					unicode -= 0x10000;
-					*wp++ = (unicode >> 10) | 0xd800;
-					*wp = (unicode & 0x3ff) | 0xdc00;
-				} else {
-					*wp = (((unsigned)p[0] & 0x7) << 18) | (((unsigned)p[1] & 0x3f) << 12) | (((unsigned)p[2] & 0x3f) << 6) | ((unsigned)p[3] & 0x3f);
-				}
-				p += 4;
-			} else
-				p++;
-			wp++;
+			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;
@@ -168,14 +262,18 @@ public:
 		str[N - 1] = 0;
 	}
 	static int GetVal(const wchar_t* pstr) {
-		unsigned 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;
 		}
-		if (*pstr == 0)
-			return (int)ret;
-		return 0;
+		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
@@ -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,35 +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{};
-
-	bool is_setcodes(std::vector <uint32> values) const {
-		for (auto& value : values) {
-			if (is_setcode(value))
-				return true;
-		}
-		return false;
-	}
-};
-struct CardString {
-	std::wstring name;
-	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;
@@ -38,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 };
@@ -98,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>
@@ -58,9 +58,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 };
@@ -71,15 +74,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;
@@ -89,12 +92,13 @@ public:
 	bool cant_check_grave{ false };
 	bool tag_surrender{ false };
 	bool tag_teammate_surrender{ false };
-	mt19937 rnd;
+	std::mt19937 rnd;
 
 	ClientField();
 	~ClientField();
 	void Clear();
-	void Initial(int player, int deckc, int extrac);
+	void Initial(int player, int deckc, int extrac, int sidec = 0);
+	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);
@@ -117,6 +121,7 @@ public:
 	bool ShowSelectSum(bool panelmode);
 	bool CheckSelectSum();
 	bool CheckSelectTribute();
+	void get_sum_params(unsigned int opParam, int& op1, int& op2);
 	bool check_min(const std::set<ClientCard*>& left, std::set<ClientCard*>::const_iterator index, int min, int max);
 	bool check_sel_sum_s(const std::set<ClientCard*>& left, int index, int acc);
 	void check_sel_sum_t(const std::set<ClientCard*>& left, int acc);
@@ -129,9 +134,6 @@ public:
 	void RefreshCardCountDisplay();
 
 	irr::gui::IGUIElement* panel{ nullptr };
-	bool is_dragging_cardtext{ false };
-	int dragging_cardtext_start_pos{ 0 };
-	int dragging_cardtext_start_y{ 0 };
 	std::vector<int> ancard;
 	int hovered_controler{ 0 };
 	int hovered_location{ 0 };
@@ -147,8 +149,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();
@@ -164,8 +166,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,7 +25,6 @@
 
 #else //_WIN32
 
-#include <errno.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
@@ -41,49 +41,71 @@
 #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...);
+#ifndef _WIN32
+#include <wchar.h>
+inline int _wtoi(const wchar_t * str){
+	return (int)wcstol(str, 0, 10);
 }
+#endif
 
-#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 <iostream>
-#include <stdio.h>
+// load env things
+#ifdef _WIN32
+#include <windows.h>
+#include <string>
+#else
+#include <unistd.h>
 #include <stdlib.h>
-#include <time.h>
-#include <thread>
-#include <mutex>
+
+extern char** environ;
+#endif
+
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
 #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;
+}
+
+#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 unsigned short PRO_VERSION;
 extern unsigned int enable_log;
@@ -92,5 +114,7 @@ extern bool auto_watch_mode;
 extern bool open_file;
 extern wchar_t open_file_name[256];
 extern bool bot_mode;
+extern bool expansions_specified;
+extern std::vector<std::wstring> expansions_list;
 
 #endif

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 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 LoadDB(irr::io::IReadFile* reader);
 	bool LoadStrings(const char* file);
-	bool LoadStrings(IReadFile* reader);
+	bool LoadStrings(const wchar_t* file);
+	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 LoadServerList(const char* file);
+	bool LoadServerList(const wchar_t* file);
+	bool LoadServerList(irr::io::IReadFile* reader);
+	void ReadServerConfLine(const char* linebuf);
+	bool LoadCorresSrvIni(const char* file);
+	bool LoadCorresSrvIni(const wchar_t* file);
+	bool LoadCorresSrvIni(irr::io::IReadFile* reader);
+	void ReadCorresSrvIniLine(const char* linebuf);
+	std::wstring GetINIValue(const char* line, const char* key);
+	void InsertServerList();
+	bool Error(sqlite3* pDB, sqlite3_stmt* pStmt = nullptr);
+
 	code_pointer GetCodePointer(unsigned int code) const;
 	string_pointer GetStringPointer(unsigned int code) const;
-	bool GetString(unsigned int code, CardString* pStr);
-	const wchar_t* GetName(unsigned int code);
-	const wchar_t* GetText(unsigned int code);
-	const wchar_t* GetDesc(unsigned int strCode);
-	const wchar_t* GetSysString(int code);
-	const wchar_t* GetVictoryString(int code);
-	const wchar_t* GetCounterName(int code);
-	const wchar_t* GetSetName(int code);
-	std::vector<unsigned int> GetSetCodes(std::wstring setname);
-	const wchar_t* GetNumString(int num, bool bracket = false);
-	const wchar_t* FormatLocation(int location, int sequence);
-	const wchar_t* FormatAttribute(int attribute);
-	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;
+	std::vector<std::pair<std::wstring, std::wstring>> _serverStrings;
+	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* ScriptReaderExSingle(const char* path, const char* script_name, int* slen, int pre_len = 2);
-	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_name, int* slen);
+	static unsigned char* ScriptReaderExSingle(const char* path, const char* script_name, int* slen, int pre_len = 2, unsigned int use_irr = FALSE);
+	
+	//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;
 	std::unordered_map<unsigned int, CardString> _strings;
 	std::unordered_map<unsigned int, std::vector<uint16_t>> extra_setcode;
+	std::wstring iniName;
+	std::wstring iniHost;
+	std::wstring iniPort;
 };
 
 extern DataManager dataManager;

gframe/deck_con.h

 #ifndef DECK_CON_H
 #define DECK_CON_H
 
-#include "config.h"
 #include <unordered_map>
 #include <vector>
-#include "client_card.h"
-#include "../ocgcore/mtrandom.h"
+#include <random>
+#include <irrlicht.h>
+#include "data_manager.h"
+#include "deck_manager.h"
 
 namespace ygo {
 
 class DeckBuilder: public irr::IEventReceiver {
 public:
-	virtual bool OnEvent(const irr::SEvent& event);
+	DeckBuilder();
+	bool OnEvent(const irr::SEvent& event) override;
 	void Initialize();
 	void Terminate();
 	void GetHoveredCard();
@@ -28,7 +30,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);
@@ -41,7 +43,7 @@ public:
 	void pop_side(int seq);
 	bool check_limit(code_pointer pointer);
 
-	long long filter_effect{};
+	unsigned long long filter_effect{};
 	unsigned int filter_type{};
 	unsigned int filter_type2{};
 	unsigned int filter_attrib{};
@@ -56,7 +58,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 +76,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;
+	std::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.h

 #ifndef DECKMANAGER_H
 #define DECKMANAGER_H
 
-#include "config.h"
-#include "client_card.h"
 #include <unordered_map>
 #include <vector>
 #include <sstream>
+#include "data_manager.h"
+#include "bufferio.h"
 
 #ifndef YGOPRO_MAX_DECK
 #define YGOPRO_MAX_DECK					60
@@ -28,17 +28,18 @@ namespace ygo {
 	constexpr int DECK_MIN_SIZE = YGOPRO_MIN_DECK;
 	constexpr int EXTRA_MAX_SIZE = YGOPRO_MAX_EXTRA;
 	constexpr int SIDE_MAX_SIZE = YGOPRO_MAX_SIDE;
+	constexpr int PACK_MAX_SIZE = 1000;
 
 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;
@@ -51,6 +52,12 @@ struct Deck {
 	}
 };
 
+struct DeckArray {
+	std::vector<uint32_t> main;
+	std::vector<uint32_t> extra;
+	std::vector<uint32_t> side;
+};
+
 class DeckManager {
 public:
 	Deck current_deck;
@@ -58,29 +65,78 @@ public:
 
 	static char deckBuffer[0x10000];
 
-	void LoadLFListSingle(const char* path);
+	void LoadLFListSingle(const char* path, bool insert = false);
+	void LoadLFListSingle(const wchar_t* path, bool insert = false);
+	void LoadLFListSingle(irr::io::IReadFile* reader, bool insert = false);
 	void LoadLFList();
-	const wchar_t* GetLFListName(int lfhash);
-	const std::unordered_map<int, int>* GetLFListContent(int lfhash);
-	int CheckDeck(Deck& deck, int lfhash, int rule);
-	int LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec, bool is_packlist = false);
-	bool LoadSide(Deck& deck, int* dbuf, int mainc, int sidec);
-	void GetCategoryPath(wchar_t* ret, int index, const wchar_t* text);
-	void GetDeckFile(wchar_t* ret, irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck);
-	bool LoadDeck(irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck);
-	FILE* OpenDeckFile(const wchar_t* file, const char* mode);
-	IReadFile* OpenDeckReader(const wchar_t* file);
-	bool LoadDeck(const wchar_t* file, bool is_packlist = false);
-	bool LoadDeck(std::istringstream* deckStream, bool is_packlist = false);
-	bool SaveDeck(Deck& deck, const wchar_t* file);
-	bool DeleteDeck(const wchar_t* file);
+	const wchar_t* GetLFListName(unsigned int lfhash);
+	const LFList* GetLFList(unsigned int lfhash);
+	unsigned int CheckDeck(const Deck& deck, unsigned int lfhash, int rule);
+	bool LoadCurrentDeck(const wchar_t* file, bool is_packlist = false);
+	bool LoadCurrentDeck(int category_index, const wchar_t* category_name, const wchar_t* deckname);
+	bool LoadCurrentDeck(std::istringstream& deckStream, bool is_packlist = false);
 	wchar_t DeckFormatBuffer[128];
 	int TypeCount(std::vector<code_pointer> list, unsigned int ctype);
 	bool LoadDeckFromCode(Deck& deck, const unsigned char *code, int len);
 	int SaveDeckToCode(Deck &deck, unsigned char *code);
-	bool CreateCategory(const wchar_t* name);
-	bool RenameCategory(const wchar_t* oldname, const wchar_t* newname);
-	bool DeleteCategory(const wchar_t* name);
+
+	static uint32_t LoadDeck(Deck& deck, uint32_t dbuf[], int mainc, int sidec, bool is_packlist = false);
+	static uint32_t LoadDeckFromStream(Deck& deck, std::istringstream& deckStream, bool is_packlist = false);
+	static bool LoadSide(Deck& deck, uint32_t dbuf[], int mainc, int sidec);
+	static void GetCategoryPath(wchar_t* ret, int index, const wchar_t* text);
+	static void GetDeckFile(wchar_t* ret, int category_index, const wchar_t* category_name, const wchar_t* deckname);
+	static FILE* OpenDeckFile(const wchar_t* file, const char* mode);
+	static irr::io::IReadFile* OpenDeckReader(const wchar_t* file);
+	static bool SaveDeck(const Deck& deck, const wchar_t* file);
+	static void SaveDeck(const Deck& deck, std::stringstream& deckStream);
+	static bool DeleteDeck(const wchar_t* file);
+	static bool CreateCategory(const wchar_t* name);
+	static bool RenameCategory(const wchar_t* oldname, const wchar_t* newname);
+	static bool DeleteCategory(const wchar_t* name);
+	static bool SaveDeckArray(const DeckArray& deck, const wchar_t* name);
+
+private:
+	template<typename LineProvider>
+	void _LoadLFListFromLineProvider(LineProvider getLine, bool insert = false) {
+		std::vector<LFList> loadedLists;
+		auto cur = loadedLists.rend(); // 注意：在临时 list 上操作
+		char line[256]{};
+		wchar_t strBuffer[256]{};
+		char str1[16]{};
+
+		while (getLine(line, sizeof(line))) {
+			if (line[0] == '#')
+				continue;
+			if (line[0] == '!') {
+				auto len = std::strcspn(line, "\r\n");
+				line[len] = 0;
+				BufferIO::DecodeUTF8(&line[1], strBuffer);
+				LFList newlist;
+				newlist.listName = strBuffer;
+				newlist.hash = 0x7dfcee6a;
+				loadedLists.push_back(newlist);
+				cur = loadedLists.rbegin();
+				continue;
+			}
+			if (cur == loadedLists.rend())
+				continue;
+			unsigned int code = 0;
+			int count = -1;
+			if (std::sscanf(line, "%10s%*[ ]%1d", str1, &count) != 2)
+				continue;
+			if (count < 0 || count > 2)
+				continue;
+			code = std::strtoul(str1, nullptr, 10);
+			cur->content[code] = count;
+			cur->hash = cur->hash ^ ((code << 18) | (code >> 14)) ^ ((code << (27 + count)) | (code >> (5 - count)));
+		}
+
+		if (insert) {
+			_lfList.insert(_lfList.begin(), loadedLists.begin(), loadedLists.end());
+		} else {
+			_lfList.insert(_lfList.end(), loadedLists.begin(), loadedLists.end());
+		}
+	}
 };
 
 extern DeckManager deckManager;

gframe/duelclient.h

 #ifndef DUELCLIENT_H
 #define DUELCLIENT_H
 
-#include "config.h"
 #include <vector>
 #include <set>
-#include <utility>
+#include <random>
 #include "network.h"
-#include "data_manager.h"
-#include "deck_manager.h"
-#include "../ocgcore/mtrandom.h"
 
 namespace ygo {
 
@@ -55,7 +51,7 @@ class DuelClient {
 private:
 	static unsigned int connect_state;
 	static unsigned char response_buf[SIZE_RETURN_VALUE];
-	static unsigned int response_len;
+	static size_t response_len;
 	static unsigned int watching;
 	static bool is_host;
 	static event_base* client_base;
@@ -66,10 +62,16 @@ private:
 	static int select_hint;
 	static int select_unselect_hint;
 	static int last_select_hint;
-	static unsigned char last_successful_msg[0x2000];
-	static unsigned int last_successful_msg_length;
+	static unsigned char last_successful_msg[SIZE_NETWORK_BUFFER];
+	static size_t last_successful_msg_length;
 	static wchar_t event_string[256];
-	static mt19937 rnd;
+	static std::mt19937 rnd;
+	static std::uniform_real_distribution<float> real_dist;
+	static bool is_refreshing;
+	static int match_kill;
+	static event* resp_event;
+	static std::set<std::pair<unsigned int, unsigned short>> remotes;
+
 public:
 	static unsigned int temp_ip;
 	static unsigned short temp_port;
@@ -80,34 +82,33 @@ public:
 	static void ConnectTimeout(evutil_socket_t fd, short events, void* arg);
 	static void StopClient(bool is_exiting = false);
 	static void ClientRead(bufferevent* bev, void* ctx);
-	static void ClientEvent(bufferevent *bev, short events, void *ctx);
+	static void ClientEvent(bufferevent* bev, short events, void* ctx);
 	static int ClientThread();
 	static void HandleSTOCPacketLan(unsigned char* data, int len);
-	static int ClientAnalyze(unsigned char* msg, unsigned int len);
+	static bool ClientAnalyze(unsigned char* msg, int len);
 	static void SwapField();
-	static void SetResponseI(int respI);
-	static void SetResponseB(void* respB, unsigned int len);
+	static void SetResponseI(int32_t respI);
+	static void SetResponseB(void* respB, size_t len);
 	static void SendResponse();
 	static unsigned int LookupHost(char *host);
 	static bool LookupSRV(char *hostname, HostResult* result);
 	static bool CheckHostnameSplitter(char *hostname, HostResult *result);
-	static HostResult ParseHost(char *hostname, unsigned short port);
+	static HostResult ParseHost(char *hostname);
 	static void SendPacketToServer(unsigned char proto) {
 		auto p = duel_client_write;
-		BufferIO::WriteInt16(p, 1);
-		BufferIO::WriteInt8(p, proto);
+		buffer_write<uint16_t>(p, 1);
+		buffer_write<uint8_t>(p, proto);
 #ifdef YGOPRO_MESSAGE_DEBUG
 		printf("CTOS: %d\n", proto);
 #endif
 		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 ((int)sizeof(ST) > MAX_DATA_SIZE)
-			return;
-		BufferIO::WriteInt16(p, (short)(1 + sizeof(ST)));
-		BufferIO::WriteInt8(p, proto);
+		static_assert(sizeof(ST) <= MAX_DATA_SIZE, "Packet size is too large.");
+		buffer_write<uint16_t>(p, (uint16_t)(1 + sizeof(ST)));
+		buffer_write<uint8_t>(p, proto);
 		std::memcpy(p, &st, sizeof(ST));
 #ifdef YGOPRO_MESSAGE_DEBUG
 		printf("CTOS: %d Length: %ld\n", proto, sizeof(ST));
@@ -116,27 +117,18 @@ public:
 	}
 	static void SendBufferToServer(unsigned char proto, void* buffer, size_t len) {
 		auto p = duel_client_write;
-		int blen = len;
-		if (blen < 0)
-			return;
-		if (blen > MAX_DATA_SIZE)
-			blen = MAX_DATA_SIZE;
-		BufferIO::WriteInt16(p, (short)(1 + blen));
-		BufferIO::WriteInt8(p, proto);
-		std::memcpy(p, buffer, blen);
+		if (len > MAX_DATA_SIZE)
+			len = MAX_DATA_SIZE;
+		buffer_write<uint16_t>(p, (uint16_t)(1 + len));
+		buffer_write<uint8_t>(p, proto);
+		std::memcpy(p, buffer, len);
 #ifdef YGOPRO_MESSAGE_DEBUG
 		printf("CTOS: %d Length: %ld\n", proto, len);
 #endif
-		bufferevent_write(client_bev, duel_client_write, blen + 3);
+		bufferevent_write(client_bev, duel_client_write, len + 3);
 	}
-	
-protected:
-	static bool is_refreshing;
-	static int match_kill;
-	static event* resp_event;
-	static std::set<std::pair<unsigned int, unsigned short>> remotes;
-public:
-	static std::vector<HostPacket> hosts;
+
+	static std::vector<std::wstring> hosts;
 	static std::vector<std::wstring> hosts_srvpro;
 	static bool is_srvpro;
 	static void BeginRefreshHost();

gframe/image_manager.h

@@ -5,6 +5,7 @@
 #include "data_manager.h"
 #include <unordered_map>
 #include <queue>
+#include <mutex>
 
 namespace ygo {
 
@@ -15,14 +16,14 @@ public:
 	bool Initial();
 	//random image
 	irr::video::ITexture* GetRandomImage(int image_type);
-	irr::video::ITexture* GetRandomImage(int image_type, s32 width, s32 height);
+	irr::video::ITexture* GetRandomImage(int image_type, irr::s32 width, irr::s32 height);
 	void RefreshRandomImageList();
 	void RefreshImageDir(std::wstring path, int image_type);
 	void SetDevice(irr::IrrlichtDevice* dev);
 	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,32 +10,32 @@ public:
 	Materials();
 	void GenArrow(float y);
 	
-	S3DVertex vCardFront[4];
-	S3DVertex vCardOutline[4];
-	S3DVertex vCardOutliner[4];
-	S3DVertex vCardBack[4];
-	S3DVertex vPScale[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 vPScale[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;
@@ -45,3 +48,5 @@ public:
 extern Materials matManager;
 
 }
+
+#endif //MATERIALS_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/netserver.h

 #ifndef NETSERVER_H
 #define NETSERVER_H
 
-#include "config.h"
 #include "network.h"
-#include "data_manager.h"
-#include "deck_manager.h"
-#include <set>
 #include <unordered_map>
 
 namespace ygo {
@@ -19,7 +15,7 @@ private:
 	static evconnlistener* listener;
 	static DuelMode* duel_mode;
 	static unsigned char net_server_write[SIZE_NETWORK_BUFFER];
-	static unsigned short last_sent;
+	static size_t last_sent;
 
 public:
 	static bool StartServer(unsigned short port);
@@ -38,20 +34,18 @@ public:
 	static size_t CreateChatPacket(unsigned char* src, int src_size, unsigned char* dst, uint16_t dst_player_type);
 	static void SendPacketToPlayer(DuelPlayer* dp, unsigned char proto) {
 		auto p = net_server_write;
-		BufferIO::WriteInt16(p, 1);
-		BufferIO::WriteInt8(p, proto);
+		buffer_write<uint16_t>(p, 1);
+		buffer_write<uint8_t>(p, proto);
 		last_sent = 3;
-		if(!dp)
-			return;
-		bufferevent_write(dp->bev, net_server_write, 3);
+		if (dp)
+			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 ((int)sizeof(ST) > MAX_DATA_SIZE)
-			return;
-		BufferIO::WriteInt16(p, (short)(1 + sizeof(ST)));
-		BufferIO::WriteInt8(p, proto);
+		static_assert(sizeof(ST) <= MAX_DATA_SIZE, "Packet size is too large.");
+		buffer_write<uint16_t>(p, (uint16_t)(1 + sizeof(ST)));
+		buffer_write<uint8_t>(p, proto);
 		std::memcpy(p, &st, sizeof(ST));
 		last_sent = sizeof(ST) + 3;
 		if (dp)
@@ -59,17 +53,14 @@ public:
 	}
 	static void SendBufferToPlayer(DuelPlayer* dp, unsigned char proto, void* buffer, size_t len) {
 		auto p = net_server_write;
-		int blen = len;
-		if (blen < 0)
-			return;
-		if (blen > MAX_DATA_SIZE)
-			blen = MAX_DATA_SIZE;
-		BufferIO::WriteInt16(p, (short)(1 + blen));
-		BufferIO::WriteInt8(p, proto);
-		std::memcpy(p, buffer, blen);
-		last_sent = blen + 3;
+		if (len > MAX_DATA_SIZE)
+			len = MAX_DATA_SIZE;
+		buffer_write<uint16_t>(p, (uint16_t)(1 + len));
+		buffer_write<uint8_t>(p, proto);
+		std::memcpy(p, buffer, len);
+		last_sent = len + 3;
 		if (dp)
-			bufferevent_write(dp->bev, net_server_write, blen + 3);
+			bufferevent_write(dp->bev, net_server_write, len + 3);
 	}
 	static void ReSendToPlayer(DuelPlayer* dp) {
 		if(dp)

gframe/replay_mode.h

 #ifndef REPLAY_MODE_H
 #define REPLAY_MODE_H
 
-#include <stdint.h>
+#include <cstdint>
 #include <vector>
 #include "replay.h"
 
@@ -25,7 +25,6 @@ private:
 public:
 	static Replay cur_replay;
 	
-public:
 	static bool StartReplay(int skipturn);
 	static void StopReplay(bool is_exiting = false);
 	static void SwapField();
@@ -47,7 +46,7 @@ public:
 	static void ReplayRefreshSingle(int player, int location, int sequence, int flag = 0xf81fff);
 	static void ReplayReload();
 
-	static uint32 MessageHandler(intptr_t fduel, uint32 type);
+	static uint32_t MessageHandler(intptr_t fduel, uint32_t type);
 };
 
 }

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;