Commit fefc9d5b authored by nanahira's avatar nanahira Committed by GitHub

Merge branch 'master' into patch-sum-param

parents d75e2be6 ec24699d
This diff is collapsed.
...@@ -8,6 +8,8 @@ ...@@ -8,6 +8,8 @@
/pics /pics
/replay /replay
/single /single
/sound
!/sound/files.txt
/WindBot /WindBot
/cards.cdb /cards.cdb
/error.log /error.log
...@@ -18,6 +20,8 @@ ...@@ -18,6 +20,8 @@
/ygopro /ygopro
/ygopro.exe /ygopro.exe
/ygopro.app /ygopro.app
/ikpMP3.dll
/irrKlang.dll
/bin /bin
/build /build
...@@ -28,6 +32,7 @@ ...@@ -28,6 +32,7 @@
/irrklang /irrklang
/ikpmp3 /ikpmp3
/lua /lua
/miniaudio
/sqlite3 /sqlite3
/gframe/*.ico /gframe/*.ico
/gframe/ygopro.rc /gframe/ygopro.rc
......
[submodule "ocgcore"] [submodule "ocgcore"]
path = ocgcore path = ocgcore
url = git@github.com:Fluorohydride/ygopro-core.git url = https://github.com/Fluorohydride/ygopro-core.git
[submodule "script"] [submodule "script"]
path = script path = script
url = git@github.com:Fluorohydride/ygopro-scripts.git url = https://github.com/Fluorohydride/ygopro-scripts.git
// 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__
This diff is collapsed.
// 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_ #ifndef _C_GUI_IMAGE_BUTTON_H_
#define _C_GUI_IMAGE_BUTTON_H_ #define _C_GUI_IMAGE_BUTTON_H_
#include <irrlicht.h> #include <IrrCompileConfig.h>
#include "CGUIButton.h" #ifdef _IRR_COMPILE_WITH_GUI_
#include <IGUIButton.h>
#include <SColor.h>
namespace irr { namespace irr {
namespace video {
class IVideoDriver;
class ITexture;
}
namespace gui { namespace gui {
class IGUISpriteBank;
void Draw2DImageRotation(video::IVideoDriver* driver, video::ITexture* image, core::rect<s32> sourceRect, 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); 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, void Draw2DImageQuad(video::IVideoDriver* driver, video::ITexture* image, core::rect<s32> sourceRect,
core::position2d<s32> corner[4], bool useAlphaChannel = true, video::SColor color = 0xffffffff); core::vector2d<s32> corner[4], bool useAlphaChannel = true, video::SColor color = 0xffffffff);
class CGUIImageButton : public CGUIButton {
class CGUIImageButton : public IGUIButton {
public: 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);
static CGUIImageButton* addImageButton(IGUIEnvironment *env, const core::rect<s32>& rectangle, IGUIElement* parent, s32 id);
virtual void draw(); //! constructor
virtual void setImage(video::ITexture* image = 0); CGUIImageButton(IGUIEnvironment* environment, IGUIElement* parent,
virtual void setDrawImage(bool b); s32 id, core::rect<s32> rectangle, bool noclip = false);
virtual void setImageRotation(f32 r);
virtual void setImageScale(core::vector2df s); //! destructor
virtual void setImageSize(core::dimension2di s); ~CGUIImageButton() override;
virtual IGUIFont* getOverrideFont(void) const;
virtual IGUIFont* getActiveFont() const; //! called if an event happened.
bool OnEvent(const SEvent& event) override;
private:
//! 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 isDrawImage;
bool isFixedSize; bool isFixedSize;
f32 imageRotation; f32 imageRotation;
...@@ -36,4 +155,6 @@ private: ...@@ -36,4 +155,6 @@ private:
} }
} }
#endif // _IRR_COMPILE_WITH_GUI_
#endif //_C_GUI_IMAGE_BUTTON_H_ #endif //_C_GUI_IMAGE_BUTTON_H_
This diff is collapsed.
...@@ -54,7 +54,7 @@ public: ...@@ -54,7 +54,7 @@ public:
//! Structure representing a single TrueType glyph. //! Structure representing a single TrueType glyph.
struct SGUITTGlyph { struct SGUITTGlyph {
//! Constructor. //! Constructor.
SGUITTGlyph() : isLoaded(false), glyph_page(0), surface(0), parent(0) {} SGUITTGlyph() : isLoaded(false), glyph_page(0), advance({}), surface(0), parent(0) {}
//! Destructor. //! Destructor.
~SGUITTGlyph() { ~SGUITTGlyph() {
...@@ -207,93 +207,95 @@ public: ...@@ -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); static CGUITTFont* create(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
//! Destructor //! Destructor
virtual ~CGUITTFont(); ~CGUITTFont() override;
//! Sets the amount of glyphs to batch load. //! Sets the amount of glyphs to batch load.
virtual void setBatchLoadSize(u32 batch_size) { void setBatchLoadSize(u32 batch_size) {
batch_load_size = batch_size; batch_load_size = batch_size;
} }
//! Sets the maximum texture size for a page of glyphs. //! 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; max_page_texture_size = texture_size;
} }
//! Get the font size. //! Get the font size.
virtual u32 getFontSize() const { u32 getFontSize() const {
return size; return size;
} }
//! Check the font's transparency. //! Check the font's transparency.
virtual bool isTransparent() const { bool isTransparent() const {
return use_transparency; return use_transparency;
} }
//! Check if the font auto-hinting is enabled. //! Check if the font auto-hinting is enabled.
//! Auto-hinting is FreeType's built-in font hinting engine. //! Auto-hinting is FreeType's built-in font hinting engine.
virtual bool useAutoHinting() const { bool useAutoHinting() const {
return use_auto_hinting; return use_auto_hinting;
} }
//! Check if the font hinting is enabled. //! Check if the font hinting is enabled.
virtual bool useHinting() const { bool useHinting() const {
return use_hinting; return use_hinting;
} }
//! Check if the font is being loaded as a monochrome font. //! 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. //! 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; return use_monochrome;
} }
//! Tells the font to allow transparency when rendering. //! Tells the font to allow transparency when rendering.
//! Default: true. //! Default: true.
//! \param flag If true, the font draws using transparency. //! \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. //! Tells the font to use monochrome rendering.
//! Default: false. //! Default: false.
//! \param flag If true, the font draws using a monochrome image. If false, the font uses a grayscale image. //! \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. //! Enables or disables font hinting.
//! Default: Hinting and auto-hinting true. //! Default: Hinting and auto-hinting true.
//! \param enable If false, font hinting is turned off. If true, font hinting is turned on. //! \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. //! \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. //! 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, 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. //! 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. //! Returns the dimension of a text string.
virtual core::dimension2d<u32> getDimension(const wchar_t* text) const; core::dimension2d<u32> getDimension(const wchar_t* text) const override;
virtual core::dimension2d<u32> getDimension(const core::ustring& text) const; core::dimension2d<u32> getDimension(const core::ustring& text) const;
//! Calculates the index of the character in the text which is on a specific position. //! 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; s32 getCharacterFromPos(const wchar_t* text, s32 pixel_x) const override;
virtual s32 getCharacterFromPos(const core::ustring& text, s32 pixel_x) const; s32 getCharacterFromPos(const core::ustring& text, s32 pixel_x) const;
//! Sets global kerning width for the font. //! Sets global kerning width for the font.
virtual void setKerningWidth(s32 kerning); void setKerningWidth(s32 kerning) override;
//! Sets global kerning height for the font. //! 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, //! 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; s32 getKerningWidth(const wchar_t* thisLetter = 0, const wchar_t* previousLetter = 0) const override;
virtual s32 getKerningWidth(const uchar32_t thisLetter = 0, const uchar32_t previousLetter = 0) const; s32 getKerningWidth(const uchar32_t thisLetter = 0, const uchar32_t previousLetter = 0) const;
//! Returns the distance between letters //! Returns the distance between letters
virtual s32 getKerningHeight() const; s32 getKerningHeight() const override;
//! Define which characters should not be drawn by the font. //! Define which characters should not be drawn by the font.
virtual void setInvisibleCharacters(const wchar_t *s); void setInvisibleCharacters(const wchar_t *s) final;
virtual void setInvisibleCharacters(const core::ustring& s);
//! Get the last glyph page if there's still available slots. //! Get the last glyph page if there's still available slots.
//! If not, it will return zero. //! If not, it will return zero.
...@@ -312,14 +314,14 @@ public: ...@@ -312,14 +314,14 @@ public:
//! Create corresponding character's software image copy from the font, //! Create corresponding character's software image copy from the font,
//! so you can use this data just like any ordinary video::IImage. //! so you can use this data just like any ordinary video::IImage.
//! \param ch The character you need //! \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. //! 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. //! \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. //! 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 wchar_t* text, scene::ISceneManager* smgr, scene::ISceneNode* parent = 0,
const video::SColor& color = video::SColor(255, 0, 0, 0), bool center = false ); const video::SColor& color = video::SColor(255, 0, 0, 0), bool center = false );
...@@ -340,7 +342,7 @@ private: ...@@ -340,7 +342,7 @@ private:
static scene::IMesh* shared_plane_ptr_; static scene::IMesh* shared_plane_ptr_;
static scene::SMesh shared_plane_; 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); bool load(const io::path& filename, const u32 size, const bool antialias, const bool transparency);
void reset_images(); void reset_images();
void update_glyph_pages() const; void update_glyph_pages() const;
......
#ifndef BUFFERIO_H #ifndef BUFFERIO_H
#define BUFFERIO_H #define BUFFERIO_H
#ifdef _MSC_VER #include <cstdint>
#pragma warning(disable: 4244) #include <cwchar>
#endif #include "../ocgcore/buffer.h"
class BufferIO { class BufferIO {
public: public:
inline static int ReadInt32(char*& p) { static int ReadInt32(unsigned char*& p) {
int ret = *(int*)p; return buffer_read<int32_t>(p);
p += 4;
return ret;
}
inline static short ReadInt16(char*& p) {
short ret = *(short*)p;
p += 2;
return ret;
}
inline static char ReadInt8(char*& p) {
char ret = *(char*)p;
p++;
return ret;
}
inline static unsigned char ReadUInt8(char*& p) {
unsigned char ret = *(unsigned char*)p;
p++;
return ret;
}
inline static void WriteInt32(char*& p, int val) {
(*(int*)p) = val;
p += 4;
}
inline static void WriteInt16(char*& p, short val) {
(*(short*)p) = val;
p += 2;
}
inline static void WriteInt8(char*& p, char val) {
*p = val;
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> 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; int l = 0;
while(src[l] && l < bufsize - 1) { while(src[l] && l < bufsize - 1) {
pstr[l] = src[l]; pstr[l] = (T2)src[l];
l++; l++;
} }
pstr[l] = 0; pstr[l] = 0;
return l; return l;
} }
template<typename T1, typename T2> 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; int l = 0;
while(src[l] && l < bufsize - 1) { while(src[l] && l < bufsize - 1) {
pstr[l] = src[l]; pstr[l] = (T2)src[l];
l++; l++;
} }
pstr += l; pstr += l;
*pstr = 0; *pstr = 0;
return l; 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 // UTF-16/UTF-32 to UTF-8
static int EncodeUTF8(const wchar_t * wsrc, char * str) { // return: string length
char* pstr = str; static int EncodeUTF8String(const wchar_t* wsrc, char* str, int size) {
while(*wsrc != 0) { auto pw = wsrc;
if(*wsrc < 0x80) { auto pstr = str;
*str = *wsrc; while (*pw != 0) {
++str; unsigned cur = 0;
} else if(*wsrc < 0x800) { int codepoint_size = 0;
str[0] = ((*wsrc >> 6) & 0x1f) | 0xc0; if (sizeof(wchar_t) == 2) {
str[1] = ((*wsrc) & 0x3f) | 0x80; if (IsHighSurrogate(pw[0])) {
str += 2; if (pw[1] == 0)
} else if(*wsrc < 0x10000 && (*wsrc < 0xd800 || *wsrc > 0xdfff)) { break;
str[0] = ((*wsrc >> 12) & 0xf) | 0xe0; if (IsLowSurrogate(pw[1])) {
str[1] = ((*wsrc >> 6) & 0x3f) | 0x80; cur = ((pw[0] & 0x3ffU) << 10) | (pw[1] & 0x3ffU);
str[2] = ((*wsrc) & 0x3f) | 0x80; cur += 0x10000;
str += 3; pw += 2;
} else { }
#ifdef _WIN32 else {
unsigned unicode = 0; pw++;
unicode |= (*wsrc++ & 0x3ff) << 10; continue;
unicode |= *wsrc & 0x3ff; }
unicode += 0x10000; }
str[0] = ((unicode >> 18) & 0x7) | 0xf0; else if (IsLowSurrogate(pw[0])) {
str[1] = ((unicode >> 12) & 0x3f) | 0x80; pw++;
str[2] = ((unicode >> 6) & 0x3f) | 0x80; continue;
str[3] = ((unicode) & 0x3f) | 0x80; }
#else else {
str[0] = ((*wsrc >> 18) & 0x7) | 0xf0; cur = *pw;
str[1] = ((*wsrc >> 12) & 0x3f) | 0x80; pw++;
str[2] = ((*wsrc >> 6) & 0x3f) | 0x80; }
str[3] = ((*wsrc) & 0x3f) | 0x80; }
#endif // _WIN32 else {
str += 4; 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; *pstr = 0;
return str - pstr; return (int)(pstr - str);
} }
// UTF-8 to UTF-16/UTF-32 // 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; const char* p = src;
wchar_t* wp = wstr; wchar_t* wp = wstr;
while(*p != 0) { while(*p != 0) {
if((*p & 0x80) == 0) { unsigned int cur = ConvertUTF8(p);
*wp = *p; int codepoint_size = 0;
p++; if (!IsUnicodeChar(cur))
} else if((*p & 0xe0) == 0xc0) { continue;
*wp = (((unsigned)p[0] & 0x1f) << 6) | ((unsigned)p[1] & 0x3f); if (cur >= 0x10000) {
p += 2; if (sizeof(wchar_t) == 2)
} else if((*p & 0xf0) == 0xe0) { codepoint_size = 2;
*wp = (((unsigned)p[0] & 0xf) << 12) | (((unsigned)p[1] & 0x3f) << 6) | ((unsigned)p[2] & 0x3f); else
p += 3; codepoint_size = 1;
} else if((*p & 0xf8) == 0xf0) { }
#ifdef _WIN32 else
unsigned unicode = (((unsigned)p[0] & 0x7) << 18) | (((unsigned)p[1] & 0x3f) << 12) | (((unsigned)p[2] & 0x3f) << 6) | ((unsigned)p[3] & 0x3f); codepoint_size = 1;
unicode -= 0x10000; if ((int)(wp - wstr) + codepoint_size > size - 1)
*wp++ = (unicode >> 10) | 0xd800; break;
*wp = (unicode & 0x3ff) | 0xdc00; if (codepoint_size == 1) {
#else wp[0] = cur;
*wp = (((unsigned)p[0] & 0x7) << 18) | (((unsigned)p[1] & 0x3f) << 12) | (((unsigned)p[2] & 0x3f) << 6) | ((unsigned)p[3] & 0x3f); wp++;
#endif // _WIN32 }
p += 4; else {
} else cur -= 0x10000U;
p++; wp[0] = (cur >> 10) | 0xd800;
wp++; wp[1] = (cur & 0x3ff) | 0xdc00;
wp += 2;
}
} }
*wp = 0; *wp = 0;
return wp - wstr; 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) { static int GetVal(const wchar_t* pstr) {
int ret = 0; if (*pstr >= L'0' && *pstr <= L'9') {
while(*pstr >= L'0' && *pstr <= L'9') { int ret{};
ret = ret * 10 + (*pstr - L'0'); wchar_t* str_end{};
pstr++; ret = std::wcstol(pstr, &str_end, 10);
if (*str_end == 0)
return ret;
else
return 0;
} }
return ret; else
return 0;
} }
}; };
......
This diff is collapsed.
...@@ -5,47 +5,9 @@ ...@@ -5,47 +5,9 @@
#include <vector> #include <vector>
#include <set> #include <set>
#include <map> #include <map>
#include <unordered_map>
namespace ygo { namespace ygo {
struct CardData {
unsigned int code;
unsigned int alias;
unsigned long long setcode;
unsigned int type;
unsigned int level;
unsigned int attribute;
unsigned int race;
int attack;
int defense;
unsigned int lscale;
unsigned int rscale;
unsigned int link_marker;
};
struct CardDataC {
unsigned int code;
unsigned int alias;
unsigned long long setcode;
unsigned int type;
unsigned int level;
unsigned int attribute;
unsigned int race;
int attack;
int defense;
unsigned int lscale;
unsigned int rscale;
unsigned int link_marker;
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;
class ClientCard { class ClientCard {
public: public:
irr::core::matrix4 mTransform; irr::core::matrix4 mTransform;
...@@ -53,72 +15,71 @@ public: ...@@ -53,72 +15,71 @@ public:
irr::core::vector3df curRot; irr::core::vector3df curRot;
irr::core::vector3df dPos; irr::core::vector3df dPos;
irr::core::vector3df dRot; irr::core::vector3df dRot;
u32 curAlpha; irr::u32 curAlpha{ 255 };
u32 dAlpha; irr::u32 dAlpha{ 0 };
u32 aniFrame; irr::u32 aniFrame{ 0 };
bool is_moving; bool is_moving{ false };
bool is_fading; bool is_fading{ false };
bool is_hovered; bool is_hovered{ false };
bool is_selectable; bool is_selectable{ false };
bool is_selected; bool is_selected{ false };
bool is_showequip; bool is_showequip{ false };
bool is_showtarget; bool is_showtarget{ false };
bool is_showchaintarget; bool is_showchaintarget{ false };
bool is_highlighting; bool is_highlighting{ false };
bool is_reversed; bool is_reversed{ false };
u32 code;
u32 chain_code; unsigned int code{ 0 };
u32 alias; unsigned int chain_code{ 0 };
u32 type; unsigned int alias{ 0 };
u32 level; unsigned int type{ 0 };
u32 rank; unsigned int level{ 0 };
u32 link; unsigned int rank{ 0 };
u32 attribute; unsigned int link{ 0 };
u32 race; unsigned int attribute{ 0 };
s32 attack; unsigned int race{ 0 };
s32 defense; int attack{ 0 };
s32 base_attack; int defense{ 0 };
s32 base_defense; int base_attack{ 0 };
u32 lscale; int base_defense{ 0 };
u32 rscale; unsigned int lscale{ 0 };
u32 link_marker; unsigned int rscale{ 0 };
u32 reason; unsigned int link_marker{ 0 };
u32 select_seq; unsigned int reason{ 0 };
u8 owner; unsigned int select_seq{ 0 };
u8 controler; unsigned char owner{ PLAYER_NONE };
u8 location; unsigned char controler{ PLAYER_NONE };
u8 sequence; unsigned char location{ 0 };
u8 position; unsigned char sequence{ 0 };
u32 status; unsigned char position{ 0 };
u8 cHint; unsigned int status{ 0 };
u32 chValue; unsigned char cHint{ 0 };
u32 opParam; unsigned int chValue{ 0 };
u32 symbol; unsigned int opParam{ 0 };
u32 cmdFlag; unsigned int symbol{ 0 };
ClientCard* overlayTarget; unsigned int cmdFlag{ 0 };
ClientCard* overlayTarget{ nullptr };
std::vector<ClientCard*> overlayed; std::vector<ClientCard*> overlayed;
ClientCard* equipTarget; ClientCard* equipTarget{ nullptr };
std::set<ClientCard*> equipped; std::set<ClientCard*> equipped;
std::set<ClientCard*> cardTarget; std::set<ClientCard*> cardTarget;
std::set<ClientCard*> ownerTarget; std::set<ClientCard*> ownerTarget;
std::map<int, int> counters; std::map<int, int> counters;
std::map<int, int> desc_hints; std::map<int, int> desc_hints;
wchar_t atkstring[16]; wchar_t atkstring[16]{};
wchar_t defstring[16]; wchar_t defstring[16]{};
wchar_t lvstring[16]; wchar_t lvstring[16]{};
wchar_t linkstring[16]; wchar_t linkstring[16]{};
wchar_t lscstring[16]; wchar_t lscstring[16]{};
wchar_t rscstring[16]; wchar_t rscstring[16]{};
ClientCard(); ClientCard() = default;
void SetCode(int code); ~ClientCard();
void UpdateInfo(char* buf); void SetCode(unsigned int x);
void UpdateInfo(unsigned char* buf);
void ClearTarget(); void ClearTarget();
void ClearData();
static bool client_card_sort(ClientCard* c1, ClientCard* c2); 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);
}; };
} }
......
This diff is collapsed.
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define CLIENT_FIELD_H #define CLIENT_FIELD_H
#include "config.h" #include "config.h"
#include "../ocgcore/mtrandom.h" #include <random>
#include <vector> #include <vector>
#include <set> #include <set>
#include <map> #include <map>
...@@ -13,13 +13,13 @@ class ClientCard; ...@@ -13,13 +13,13 @@ class ClientCard;
struct ChainInfo { struct ChainInfo {
irr::core::vector3df chain_pos; irr::core::vector3df chain_pos;
ClientCard* chain_card; ClientCard* chain_card{ nullptr };
int code; int code{ 0 };
int desc; int desc{ 0 };
int controler; int controler{ 0 };
int location; int location{ 0 };
int sequence; int sequence{ 0 };
bool solved; bool solved{ false };
std::set<ClientCard*> target; std::set<ClientCard*> target;
}; };
...@@ -33,6 +33,7 @@ public: ...@@ -33,6 +33,7 @@ public:
std::vector<ClientCard*> remove[2]; std::vector<ClientCard*> remove[2];
std::vector<ClientCard*> extra[2]; std::vector<ClientCard*> extra[2];
std::set<ClientCard*> overlay_cards; std::set<ClientCard*> overlay_cards;
std::vector<ClientCard*> summonable_cards; std::vector<ClientCard*> summonable_cards;
std::vector<ClientCard*> spsummonable_cards; std::vector<ClientCard*> spsummonable_cards;
std::vector<ClientCard*> msetable_cards; std::vector<ClientCard*> msetable_cards;
...@@ -45,55 +46,62 @@ public: ...@@ -45,55 +46,62 @@ public:
std::vector<int> select_options; std::vector<int> select_options;
std::vector<int> select_options_index; std::vector<int> select_options_index;
std::vector<ChainInfo> chains; std::vector<ChainInfo> chains;
int extra_p_count[2]; int extra_p_count[2]{};
size_t selected_option; size_t selected_option{ 0 };
ClientCard* attacker; ClientCard* attacker{ nullptr };
ClientCard* attack_target; ClientCard* attack_target{ nullptr };
unsigned int disabled_field; unsigned int disabled_field{ 0 };
unsigned int selectable_field; unsigned int selectable_field{ 0 };
unsigned int selected_field; unsigned int selected_field{ 0 };
int select_min; int select_min{ 0 };
int select_max; int select_max{ 0 };
int must_select_count; int must_select_count{ 0 };
int select_sumval; int select_curval_l{ 0 };
int select_mode; int select_curval_h{ 0 };
bool select_cancelable; int select_sumval{ 0 };
bool select_panalmode; int select_mode{ 0 };
bool select_ready; int select_hint{0};
int announce_count; bool select_cancelable{false};
int select_counter_count; bool select_panalmode{ false };
int select_counter_type; bool select_ready{ false };
int announce_count{ 0 };
int select_counter_count{ 0 };
int select_counter_type{ 0 };
std::vector<ClientCard*> selectable_cards; std::vector<ClientCard*> selectable_cards;
std::vector<ClientCard*> selected_cards; std::vector<ClientCard*> selected_cards;
std::set<ClientCard*> selectsum_cards; std::set<ClientCard*> selectsum_cards;
std::vector<ClientCard*> selectsum_all; std::vector<ClientCard*> selectsum_all;
std::vector<int> declare_opcodes; std::vector<unsigned int> declare_opcodes;
std::vector<ClientCard*> display_cards; std::vector<ClientCard*> display_cards;
std::vector<int> sort_list; std::vector<int> sort_list;
std::map<int, int> player_desc_hints[2]; std::map<int, int> player_desc_hints[2];
bool grave_act; bool grave_act[2]{ false };
bool remove_act; bool remove_act[2]{ false };
bool deck_act; bool deck_act[2]{ false };
bool extra_act; bool extra_act[2]{ false };
bool pzone_act[2]; bool pzone_act[2]{ false };
bool conti_act; bool conti_act{ false };
bool chain_forced; bool chain_forced{ false };
ChainInfo current_chain; ChainInfo current_chain;
bool last_chain; bool last_chain{ false };
bool deck_reversed; bool deck_reversed{ false };
bool conti_selecting; bool conti_selecting{ false };
bool cant_check_grave; bool cant_check_grave{ false };
mt19937 rnd; bool tag_surrender{ false };
bool tag_teammate_surrender{ false };
std::mt19937 rnd;
ClientField(); ClientField();
~ClientField();
void Clear(); void Clear();
void Initial(int player, int deckc, int extrac); 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); ClientCard* GetCard(int controler, int location, int sequence, int sub_seq = 0);
void AddCard(ClientCard* pcard, int controler, int location, int sequence); void AddCard(ClientCard* pcard, int controler, int location, int sequence);
ClientCard* RemoveCard(int controler, int location, int sequence); ClientCard* RemoveCard(int controler, int location, int sequence);
void UpdateCard(int controler, int location, int sequence, char* data); void UpdateCard(int controler, int location, int sequence, unsigned char* data);
void UpdateFieldCard(int controler, int location, char* data); void UpdateFieldCard(int controler, int location, unsigned char* data);
void ClearCommandFlag(); void ClearCommandFlag();
void ClearSelect(); void ClearSelect();
void ClearChainSelect(); void ClearChainSelect();
...@@ -121,24 +129,24 @@ public: ...@@ -121,24 +129,24 @@ public:
void UpdateDeclarableList(); void UpdateDeclarableList();
irr::gui::IGUIElement* panel; irr::gui::IGUIElement* panel{ nullptr };
std::vector<int> ancard; std::vector<int> ancard;
int hovered_controler; int hovered_controler{ 0 };
int hovered_location; int hovered_location{ 0 };
size_t hovered_sequence; size_t hovered_sequence{ 0 };
int command_controler; int command_controler{ 0 };
int command_location; int command_location{ 0 };
size_t command_sequence; size_t command_sequence{ 0 };
ClientCard* hovered_card; ClientCard* hovered_card{ nullptr };
int hovered_player; int hovered_player{ 0 };
ClientCard* clicked_card; ClientCard* clicked_card{ nullptr };
ClientCard* command_card; ClientCard* command_card{ nullptr };
ClientCard* highlighting_card; ClientCard* highlighting_card{ nullptr };
ClientCard* menu_card; ClientCard* menu_card{ nullptr };
int list_command; int list_command{ 0 };
virtual bool OnEvent(const irr::SEvent& event); bool OnEvent(const irr::SEvent& event) override;
virtual bool OnCommonEvent(const irr::SEvent& event); bool OnCommonEvent(const irr::SEvent& event);
void GetHoverField(int x, int y); void GetHoverField(int x, int y);
void ShowMenu(int flag, int x, int y); void ShowMenu(int flag, int x, int y);
void HideMenu(); void HideMenu();
...@@ -154,8 +162,6 @@ public: ...@@ -154,8 +162,6 @@ public:
} }
//special cards //special cards
#define CARD_MARINE_DOLPHIN 78734254
#define CARD_TWINKLE_MOSS 13857930
#define CARD_QUESTION 38723936 #define CARD_QUESTION 38723936
#endif //CLIENT_FIELD_H #endif //CLIENT_FIELD_H
#ifndef __CONFIG_H #ifndef YGOPRO_CONFIG_H
#define __CONFIG_H #define YGOPRO_CONFIG_H
#pragma once
#define _IRR_STATIC_LIB_ #define _IRR_STATIC_LIB_
#define IRR_COMPILE_WITH_DX9_DEV_PACK #define IRR_COMPILE_WITH_DX9_DEV_PACK
#include <cerrno>
#ifdef _WIN32 #ifdef _WIN32
#include <WinSock2.h>
#define NOMINMAX #define NOMINMAX
#include <WinSock2.h>
#include <windows.h> #include <windows.h>
#include <ws2tcpip.h> #include <ws2tcpip.h>
#ifdef _MSC_VER #if defined(_MSC_VER) or defined(__MINGW32__)
#define mywcsncasecmp _wcsnicmp #define mywcsncasecmp _wcsnicmp
#define mystrncasecmp _strnicmp #define mystrncasecmp _strnicmp
#else #else
...@@ -24,14 +25,12 @@ ...@@ -24,14 +25,12 @@
#else //_WIN32 #else //_WIN32
#include <errno.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <netdb.h> #include <netdb.h>
#include <unistd.h> #include <unistd.h>
#include <locale.h>
#define SD_BOTH 2 #define SD_BOTH 2
#define SOCKET int #define SOCKET int
...@@ -42,53 +41,56 @@ ...@@ -42,53 +41,56 @@
#define SOCKADDR sockaddr #define SOCKADDR sockaddr
#define SOCKET_ERRNO() (errno) #define SOCKET_ERRNO() (errno)
#include <wchar.h>
#define mywcsncasecmp wcsncasecmp #define mywcsncasecmp wcsncasecmp
#define mystrncasecmp strncasecmp #define mystrncasecmp strncasecmp
inline int _wtoi(const wchar_t * s) {
wchar_t * endptr;
return (int)wcstol(s, &endptr, 10);
}
#endif #endif
template<size_t N, typename... TR> #include <cstdio>
inline int myswprintf(wchar_t(&buf)[N], const wchar_t* fmt, TR... args) { #include <cstdlib>
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 <iostream> #include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <time.h>
#include <thread>
#include <mutex>
#include <algorithm> #include <algorithm>
#include <string>
#include "bufferio.h" #include "bufferio.h"
#include "myfilesystem.h"
#include "mysignal.h"
#include "../ocgcore/ocgapi.h" #include "../ocgcore/ocgapi.h"
#include "../ocgcore/common.h"
using namespace irr; template<size_t N, typename... TR>
using namespace core; inline int myswprintf(wchar_t(&buf)[N], const wchar_t* fmt, TR... args) {
using namespace scene; return std::swprintf(buf, N, fmt, args...);
using namespace video; }
using namespace io;
using namespace gui; 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 const unsigned short PRO_VERSION; extern const unsigned short PRO_VERSION;
extern int enable_log; extern unsigned int enable_log;
extern bool exit_on_return; extern bool exit_on_return;
extern bool open_file; extern bool open_file;
extern wchar_t open_file_name[256]; extern wchar_t open_file_name[256];
......
This diff is collapsed.
#ifndef DATAMANAGER_H #ifndef DATAMANAGER_H
#define DATAMANAGER_H #define DATAMANAGER_H
#include "config.h"
#include "sqlite3.h"
#include "spmemvfs/spmemvfs.h"
#include "client_card.h"
#include <unordered_map> #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 { 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 { class DataManager {
public: public:
DataManager(): _datas(8192), _strings(8192) {} DataManager();
bool ReadDB(sqlite3* pDB);
bool LoadDB(const wchar_t* wfile); bool LoadDB(const wchar_t* wfile);
bool LoadStrings(const char* file); bool LoadStrings(const char* file);
bool LoadStrings(IReadFile* reader); bool LoadStrings(irr::io::IReadFile* reader);
void ReadStringConfLine(const char* linebuf); void ReadStringConfLine(const char* linebuf);
bool Error(spmemvfs_db_t* pDB, sqlite3_stmt* pStmt = 0); bool Error(sqlite3* pDB, sqlite3_stmt* pStmt = nullptr);
bool GetData(int code, CardData* pData);
code_pointer GetCodePointer(int code); code_pointer GetCodePointer(unsigned int code) const;
bool GetString(int code, CardString* pStr); string_pointer GetStringPointer(unsigned int code) const;
const wchar_t* GetName(int code); code_pointer datas_begin() const;
const wchar_t* GetText(int code); code_pointer datas_end() const;
const wchar_t* GetDesc(unsigned int strCode); string_pointer strings_begin() const;
const wchar_t* GetSysString(int code); string_pointer strings_end() const;
const wchar_t* GetVictoryString(int code); bool GetData(unsigned int code, CardData* pData) const;
const wchar_t* GetCounterName(int code); bool GetString(unsigned int code, CardString* pStr) const;
const wchar_t* GetSetName(int code); const wchar_t* GetName(unsigned int code) const;
unsigned int GetSetCode(const wchar_t* setname); const wchar_t* GetText(unsigned int code) const;
const wchar_t* GetNumString(int num, bool bracket = false); const wchar_t* GetDesc(unsigned int strCode) const;
const wchar_t* FormatLocation(int location, int sequence); const wchar_t* GetSysString(int code) const;
const wchar_t* FormatAttribute(int attribute); const wchar_t* GetVictoryString(int code) const;
const wchar_t* FormatRace(int race); const wchar_t* GetCounterName(int code) const;
const wchar_t* FormatType(int type); const wchar_t* GetSetName(int code) const;
const wchar_t* FormatSetName(unsigned long long setcode); std::vector<unsigned int> GetSetCodes(std::wstring setname) const;
const wchar_t* FormatLinkMarker(int link_marker); 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, CardDataC> _datas;
std::unordered_map<unsigned int, CardString> _strings;
std::unordered_map<unsigned int, std::wstring> _counterStrings; std::unordered_map<unsigned int, std::wstring> _counterStrings;
std::unordered_map<unsigned int, std::wstring> _victoryStrings; std::unordered_map<unsigned int, std::wstring> _victoryStrings;
std::unordered_map<unsigned int, std::wstring> _setnameStrings; std::unordered_map<unsigned int, std::wstring> _setnameStrings;
std::unordered_map<unsigned int, std::wstring> _sysStrings; std::unordered_map<unsigned int, std::wstring> _sysStrings;
char errmsg[512]{};
wchar_t numStrings[301][4]; static unsigned char scriptBuffer[0x100000];
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 const wchar_t* unknown_string; static const wchar_t* unknown_string;
static int CardReader(int, void*); static uint32_t CardReader(uint32_t, card_data*);
static byte* ScriptReaderEx(const char* script_name, int* slen); static unsigned char* ScriptReaderEx(const char* script_path, int* slen);
static byte* ScriptReader(const char* script_name, int* slen);
static IFileSystem* FileSystem; //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;
}; };
extern DataManager dataManager; extern DataManager dataManager;
......
This diff is collapsed.
#ifndef DECK_CON_H #ifndef DECK_CON_H
#define DECK_CON_H #define DECK_CON_H
#include "config.h"
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include "client_card.h" #include <random>
#include "../ocgcore/mtrandom.h" #include <irrlicht.h>
#include "data_manager.h"
#include "deck_manager.h"
namespace ygo { namespace ygo {
class DeckBuilder: public irr::IEventReceiver { class DeckBuilder: public irr::IEventReceiver {
public: public:
virtual bool OnEvent(const irr::SEvent& event); DeckBuilder();
bool OnEvent(const irr::SEvent& event) override;
void Initialize(); void Initialize();
void Terminate(); void Terminate();
void GetHoveredCard(); void GetHoveredCard();
...@@ -28,7 +30,7 @@ public: ...@@ -28,7 +30,7 @@ public:
void ChangeCategory(int catesel); void ChangeCategory(int catesel);
void ShowDeckManage(); void ShowDeckManage();
void ShowBigCard(int code, float zoom); 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(); void CloseBigCard();
bool CardNameContains(const wchar_t *haystack, const wchar_t *needle); bool CardNameContains(const wchar_t *haystack, const wchar_t *needle);
...@@ -41,49 +43,49 @@ public: ...@@ -41,49 +43,49 @@ public:
void pop_side(int seq); void pop_side(int seq);
bool check_limit(code_pointer pointer); bool check_limit(code_pointer pointer);
long long filter_effect; unsigned long long filter_effect{};
unsigned int filter_type; unsigned int filter_type{};
unsigned int filter_type2; unsigned int filter_type2{};
unsigned int filter_attrib; unsigned int filter_attrib{};
unsigned int filter_race; unsigned int filter_race{};
unsigned int filter_atktype; unsigned int filter_atktype{};
int filter_atk; int filter_atk{};
unsigned int filter_deftype; unsigned int filter_deftype{};
int filter_def; int filter_def{};
unsigned int filter_lvtype; unsigned int filter_lvtype{};
unsigned int filter_lv; unsigned int filter_lv{};
unsigned int filter_scltype; unsigned int filter_scltype{};
unsigned int filter_scl; unsigned int filter_scl{};
unsigned int filter_marks; unsigned int filter_marks{};
int filter_lm; int filter_lm{};
position2di mouse_pos; irr::core::vector2di mouse_pos;
int hovered_code; int hovered_code{};
int hovered_pos; int hovered_pos{};
int hovered_seq; int hovered_seq{ -1 };
int is_lastcard; int is_lastcard{};
int click_pos; int click_pos{};
bool is_draging; bool is_draging{};
bool is_starting_dragging; bool is_starting_dragging{};
int dragx; int dragx{};
int dragy; int dragy{};
int bigcard_code; int bigcard_code{};
float bigcard_zoom; float bigcard_zoom{};
size_t pre_mainc; size_t pre_mainc{};
size_t pre_extrac; size_t pre_extrac{};
size_t pre_sidec; size_t pre_sidec{};
code_pointer draging_pointer; code_pointer draging_pointer;
int prev_category; int prev_category{};
int prev_deck; int prev_deck{};
s32 prev_operation; irr::s32 prev_operation{};
int prev_sel; int prev_sel{ -1 };
bool is_modified; bool is_modified{};
bool readonly; bool readonly{};
bool showing_pack; bool showing_pack{};
mt19937 rnd; std::mt19937 rnd;
const std::unordered_map<int, int>* filterList; const LFList* filterList{};
std::vector<code_pointer> results; std::vector<code_pointer> results;
wchar_t result_string[8]; wchar_t result_string[8]{};
std::vector<std::wstring> expansionPacks; std::vector<std::wstring> expansionPacks;
}; };
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
#ifndef IMAGEMANAGER_H #ifndef IMAGEMANAGER_H
#define IMAGEMANAGER_H #define IMAGEMANAGER_H
#ifndef _OPENMP
#define YGOPRO_USE_THUMB_LOAD_THREAD
#endif
#include "config.h" #include "config.h"
#include "data_manager.h" #include "data_manager.h"
#include <unordered_map> #include <unordered_map>
#ifdef YGOPRO_USE_THUMB_LOAD_THREAD
#include <queue> #include <queue>
#include <mutex>
#endif
namespace ygo { namespace ygo {
...@@ -15,20 +22,24 @@ public: ...@@ -15,20 +22,24 @@ public:
void ClearTexture(); void ClearTexture();
void RemoveTexture(int code); void RemoveTexture(int code);
void ResizeTexture(); 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* GetTexture(int code, bool fit = false);
irr::video::ITexture* GetBigPicture(int code, float zoom); irr::video::ITexture* GetBigPicture(int code, float zoom);
irr::video::ITexture* GetTextureThumb(int code); irr::video::ITexture* GetTextureThumb(int code);
irr::video::ITexture* GetTextureField(int code); irr::video::ITexture* GetTextureField(int code);
#ifdef YGOPRO_USE_THUMB_LOAD_THREAD
static int LoadThumbThread(); static int LoadThumbThread();
#endif
std::unordered_map<int, irr::video::ITexture*> tMap[2]; std::unordered_map<int, irr::video::ITexture*> tMap[2];
std::unordered_map<int, irr::video::ITexture*> tThumb; std::unordered_map<int, irr::video::ITexture*> tThumb;
std::unordered_map<int, irr::video::ITexture*> tFields; std::unordered_map<int, irr::video::ITexture*> tFields;
#ifdef YGOPRO_USE_THUMB_LOAD_THREAD
std::unordered_map<int, irr::video::IImage*> tThumbLoading; std::unordered_map<int, irr::video::IImage*> tThumbLoading;
std::queue<int> tThumbLoadingCodes; std::queue<int> tThumbLoadingCodes;
std::mutex tThumbLoadingMutex; std::mutex tThumbLoadingMutex;
bool tThumbLoadingThreadRunning; bool tThumbLoadingThreadRunning;
#endif
irr::IrrlichtDevice* device; irr::IrrlichtDevice* device;
irr::video::IVideoDriver* driver; irr::video::IVideoDriver* driver;
irr::video::ITexture* tCover[4]; irr::video::ITexture* tCover[4];
...@@ -36,7 +47,9 @@ public: ...@@ -36,7 +47,9 @@ public:
irr::video::ITexture* tUnknownFit; irr::video::ITexture* tUnknownFit;
irr::video::ITexture* tUnknownThumb; irr::video::ITexture* tUnknownThumb;
irr::video::ITexture* tBigPicture; irr::video::ITexture* tBigPicture;
#ifdef YGOPRO_USE_THUMB_LOAD_THREAD
irr::video::ITexture* tLoading; irr::video::ITexture* tLoading;
#endif
irr::video::ITexture* tAct; irr::video::ITexture* tAct;
irr::video::ITexture* tAttack; irr::video::ITexture* tAttack;
irr::video::ITexture* tNegated; irr::video::ITexture* tNegated;
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment