network

gframe/CGUIEditBox.cpp

+// Copyright (C) 2002-2010 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#include "CGUIEditBox.h"
+#ifdef _IRR_COMPILE_WITH_GUI_
+
+#include "IGUISkin.h"
+#include "IGUIEnvironment.h"
+#include "IGUIFont.h"
+#include "IVideoDriver.h"
+#include "rect.h"
+#include "os.h"
+#include "Keycodes.h"
+
+/*
+	todo:
+	optional scrollbars
+	ctrl+left/right to select word
+	double click/ctrl click: word select + drag to select whole words, triple click to select line
+	optional? dragging selected text
+	numerical
+*/
+
+namespace irr
+{
+namespace gui
+{
+
+//! constructor
+CGUIEditBox::CGUIEditBox(const wchar_t* text, bool border,
+		IGUIEnvironment* environment, IGUIElement* parent, s32 id,
+		const core::rect<s32>& rectangle)
+	: IGUIEditBox(environment, parent, id, rectangle), MouseMarking(false),
+	Border(border), OverrideColorEnabled(false), MarkBegin(0), MarkEnd(0),
+	OverrideColor(video::SColor(101,255,255,255)), OverrideFont(0), LastBreakFont(0),
+	Operator(0), BlinkStartTime(0), CursorPos(0), HScrollPos(0), VScrollPos(0), Max(0),
+	WordWrap(false), MultiLine(false), AutoScroll(true), PasswordBox(false),
+	PasswordChar(L'*'), HAlign(EGUIA_UPPERLEFT), VAlign(EGUIA_CENTER),
+	CurrentTextRect(0,0,1,1), FrameRect(rectangle)
+{
+	#ifdef _DEBUG
+	setDebugName("CGUIEditBox");
+	#endif
+
+	Text = text;
+
+	if (Environment)
+		Operator = Environment->getOSOperator();
+
+	if (Operator)
+		Operator->grab();
+
+	// this element can be tabbed to
+	setTabStop(true);
+	setTabOrder(-1);
+
+	IGUISkin *skin = 0;
+	if (Environment)
+		skin = Environment->getSkin();
+	if (Border && skin)
+	{
+		FrameRect.UpperLeftCorner.X += skin->getSize(EGDS_TEXT_DISTANCE_X)+1;
+		FrameRect.UpperLeftCorner.Y += skin->getSize(EGDS_TEXT_DISTANCE_Y)+1;
+		FrameRect.LowerRightCorner.X -= skin->getSize(EGDS_TEXT_DISTANCE_X)+1;
+		FrameRect.LowerRightCorner.Y -= skin->getSize(EGDS_TEXT_DISTANCE_Y)+1;
+	}
+
+	breakText();
+
+	calculateScrollPos();
+}
+
+
+//! destructor
+CGUIEditBox::~CGUIEditBox()
+{
+	if (OverrideFont)
+		OverrideFont->drop();
+
+	if (Operator)
+		Operator->drop();
+}
+
+
+//! Sets another skin independent font.
+void CGUIEditBox::setOverrideFont(IGUIFont* font)
+{
+	if (OverrideFont == font)
+		return;
+
+	if (OverrideFont)
+		OverrideFont->drop();
+
+	OverrideFont = font;
+
+	if (OverrideFont)
+		OverrideFont->grab();
+
+	breakText();
+}
+
+
+//! Sets another color for the text.
+void CGUIEditBox::setOverrideColor(video::SColor color)
+{
+	OverrideColor = color;
+	OverrideColorEnabled = true;
+}
+
+
+//! Turns the border on or off
+void CGUIEditBox::setDrawBorder(bool border)
+{
+	Border = border;
+}
+
+
+//! Sets if the text should use the overide color or the color in the gui skin.
+void CGUIEditBox::enableOverrideColor(bool enable)
+{
+	OverrideColorEnabled = enable;
+}
+
+
+//! Enables or disables word wrap
+void CGUIEditBox::setWordWrap(bool enable)
+{
+	WordWrap = enable;
+	breakText();
+}
+
+
+void CGUIEditBox::updateAbsolutePosition()
+{
+    core::rect<s32> oldAbsoluteRect(AbsoluteRect);
+	IGUIElement::updateAbsolutePosition();
+	if ( oldAbsoluteRect != AbsoluteRect )
+	{
+        breakText();
+	}
+}
+
+
+//! Checks if word wrap is enabled
+bool CGUIEditBox::isWordWrapEnabled() const
+{
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return WordWrap;
+}
+
+
+//! Enables or disables newlines.
+void CGUIEditBox::setMultiLine(bool enable)
+{
+	MultiLine = enable;
+}
+
+
+//! Checks if multi line editing is enabled
+bool CGUIEditBox::isMultiLineEnabled() const
+{
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return MultiLine;
+}
+
+
+void CGUIEditBox::setPasswordBox(bool passwordBox, wchar_t passwordChar)
+{
+	PasswordBox = passwordBox;
+	if (PasswordBox)
+	{
+		PasswordChar = passwordChar;
+		setMultiLine(false);
+		setWordWrap(false);
+		BrokenText.clear();
+	}
+}
+
+
+bool CGUIEditBox::isPasswordBox() const
+{
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return PasswordBox;
+}
+
+
+//! Sets text justification
+void CGUIEditBox::setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical)
+{
+	HAlign = horizontal;
+	VAlign = vertical;
+}
+
+
+//! called if an event happened.
+bool CGUIEditBox::OnEvent(const SEvent& event)
+{
+	if (IsEnabled)
+	{
+
+		switch(event.EventType)
+		{
+		case EET_GUI_EVENT:
+			if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUS_LOST)
+			{
+				if (event.GUIEvent.Caller == this)
+				{
+					MouseMarking = false;
+					setTextMarkers(0,0);
+				}
+			}
+			break;
+		case EET_KEY_INPUT_EVENT:
+			if (processKey(event))
+				return true;
+			break;
+		case EET_MOUSE_INPUT_EVENT:
+			if (processMouse(event))
+				return true;
+			break;
+		default:
+			break;
+		}
+	}
+
+	return IGUIElement::OnEvent(event);
+}
+
+
+bool CGUIEditBox::processKey(const SEvent& event)
+{
+	if (!event.KeyInput.PressedDown)
+		return false;
+
+	bool textChanged = false;
+	s32 newMarkBegin = MarkBegin;
+	s32 newMarkEnd = MarkEnd;
+
+	// control shortcut handling
+
+	if (event.KeyInput.Control)
+	{
+		// german backlash '\' entered with control + '?'
+		if ( event.KeyInput.Char == '\\' )
+		{
+			inputChar(event.KeyInput.Char);
+			return true;
+		}
+
+		switch(event.KeyInput.Key)
+		{
+		case KEY_KEY_A:
+			// select all
+			newMarkBegin = 0;
+			newMarkEnd = Text.size();
+			break;
+		case KEY_KEY_C:
+			// copy to clipboard
+			if (!PasswordBox && Operator && MarkBegin != MarkEnd)
+			{
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+			#ifdef _WIN32
+				Operator->copyToClipboard((c8*)Text.subString(realmbgn, realmend - realmbgn).c_str());
+			#else
+				core::stringc s;
+				s = Text.subString(realmbgn, realmend - realmbgn).c_str();
+				Operator->copyToClipboard(s.c_str());
+			#endif
+			}
+			break;
+		case KEY_KEY_X:
+			// cut to the clipboard
+			if (!PasswordBox && Operator && MarkBegin != MarkEnd)
+			{
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				// copy
+			#ifdef _WIN32
+				Operator->copyToClipboard((c8*)Text.subString(realmbgn, realmend - realmbgn).c_str());
+			#else
+				core::stringc sc;
+				sc = Text.subString(realmbgn, realmend - realmbgn).c_str();
+				Operator->copyToClipboard(sc.c_str());
+			#endif
+				if (IsEnabled)
+				{
+					// delete
+					core::stringw s;
+					s = Text.subString(0, realmbgn);
+					s.append( Text.subString(realmend, Text.size()-realmend) );
+					Text = s;
+
+					CursorPos = realmbgn;
+					newMarkBegin = 0;
+					newMarkEnd = 0;
+					textChanged = true;
+				}
+			}
+			break;
+		case KEY_KEY_V:
+			if ( !IsEnabled )
+				break;
+
+			// paste from the clipboard
+			if (Operator)
+			{
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				// add new character
+			#ifdef _WIN32
+				// using unicode in windows
+				const wchar_t* p = (wchar_t*)Operator->getTextFromClipboard();
+			#else
+				const c8* p = Operator->getTextFromClipboard();
+			#endif
+				if (p)
+				{
+					if (MarkBegin == MarkEnd)
+					{
+						// insert text
+						core::stringw s = Text.subString(0, CursorPos);
+						s.append(p);
+						s.append( Text.subString(CursorPos, Text.size()-CursorPos) );
+
+						if (!Max || s.size()<=Max) // thx to Fish FH for fix
+						{
+							Text = s;
+							s = p;
+							CursorPos += s.size();
+						}
+					}
+					else
+					{
+						// replace text
+
+						core::stringw s = Text.subString(0, realmbgn);
+						s.append(p);
+						s.append( Text.subString(realmend, Text.size()-realmend) );
+
+						if (!Max || s.size()<=Max)  // thx to Fish FH for fix
+						{
+							Text = s;
+							s = p;
+							CursorPos = realmbgn + s.size();
+						}
+					}
+				}
+
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+				textChanged = true;
+			}
+			break;
+		case KEY_HOME:
+			// move/highlight to start of text
+			if (event.KeyInput.Shift)
+			{
+				newMarkEnd = CursorPos;
+				newMarkBegin = 0;
+				CursorPos = 0;
+			}
+			else
+			{
+				CursorPos = 0;
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+			break;
+		case KEY_END:
+			// move/highlight to end of text
+			if (event.KeyInput.Shift)
+			{
+				newMarkBegin = CursorPos;
+				newMarkEnd = Text.size();
+				CursorPos = 0;
+			}
+			else
+			{
+				CursorPos = Text.size();
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+			break;
+		default:
+			return false;
+		}
+	}
+	// default keyboard handling
+	else
+	switch(event.KeyInput.Key)
+	{
+	case KEY_END:
+		{
+			s32 p = Text.size();
+			if (WordWrap || MultiLine)
+			{
+				p = getLineFromPos(CursorPos);
+				p = BrokenTextPositions[p] + (s32)BrokenText[p].size();
+				if (p > 0 && (Text[p-1] == L'\r' || Text[p-1] == L'\n' ))
+					p-=1;
+			}
+
+			if (event.KeyInput.Shift)
+			{
+				if (MarkBegin == MarkEnd)
+					newMarkBegin = CursorPos;
+
+				newMarkEnd = p;
+			}
+			else
+			{
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+			CursorPos = p;
+			BlinkStartTime = os::Timer::getTime();
+		}
+		break;
+	case KEY_HOME:
+		{
+
+			s32 p = 0;
+			if (WordWrap || MultiLine)
+			{
+				p = getLineFromPos(CursorPos);
+				p = BrokenTextPositions[p];
+			}
+
+			if (event.KeyInput.Shift)
+			{
+				if (MarkBegin == MarkEnd)
+					newMarkBegin = CursorPos;
+				newMarkEnd = p;
+			}
+			else
+			{
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+			CursorPos = p;
+			BlinkStartTime = os::Timer::getTime();
+		}
+		break;
+	case KEY_RETURN:
+		if (MultiLine)
+		{
+			inputChar(L'\n');
+			return true;
+		}
+		else
+		{
+		    sendGuiEvent( EGET_EDITBOX_ENTER );
+		}
+		break;
+	case KEY_LEFT:
+
+		if (event.KeyInput.Shift)
+		{
+			if (CursorPos > 0)
+			{
+				if (MarkBegin == MarkEnd)
+					newMarkBegin = CursorPos;
+
+				newMarkEnd = CursorPos-1;
+			}
+		}
+		else
+		{
+			newMarkBegin = 0;
+			newMarkEnd = 0;
+		}
+
+		if (CursorPos > 0) CursorPos--;
+		BlinkStartTime = os::Timer::getTime();
+		break;
+
+	case KEY_RIGHT:
+		if (event.KeyInput.Shift)
+		{
+			if (Text.size() > (u32)CursorPos)
+			{
+				if (MarkBegin == MarkEnd)
+					newMarkBegin = CursorPos;
+
+				newMarkEnd = CursorPos+1;
+			}
+		}
+		else
+		{
+			newMarkBegin = 0;
+			newMarkEnd = 0;
+		}
+
+		if (Text.size() > (u32)CursorPos) CursorPos++;
+		BlinkStartTime = os::Timer::getTime();
+		break;
+	case KEY_UP:
+		if (MultiLine || (WordWrap && BrokenText.size() > 1) )
+		{
+			s32 lineNo = getLineFromPos(CursorPos);
+			s32 mb = (MarkBegin == MarkEnd) ? CursorPos : (MarkBegin > MarkEnd ? MarkBegin : MarkEnd);
+			if (lineNo > 0)
+			{
+				s32 cp = CursorPos - BrokenTextPositions[lineNo];
+				if ((s32)BrokenText[lineNo-1].size() < cp)
+					CursorPos = BrokenTextPositions[lineNo-1] + (s32)BrokenText[lineNo-1].size()-1;
+				else
+					CursorPos = BrokenTextPositions[lineNo-1] + cp;
+			}
+
+			if (event.KeyInput.Shift)
+			{
+				newMarkBegin = mb;
+				newMarkEnd = CursorPos;
+			}
+			else
+			{
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+
+		}
+		else
+		{
+			return false;
+		}
+		break;
+	case KEY_DOWN:
+		if (MultiLine || (WordWrap && BrokenText.size() > 1) )
+		{
+			s32 lineNo = getLineFromPos(CursorPos);
+			s32 mb = (MarkBegin == MarkEnd) ? CursorPos : (MarkBegin < MarkEnd ? MarkBegin : MarkEnd);
+			if (lineNo < (s32)BrokenText.size()-1)
+			{
+				s32 cp = CursorPos - BrokenTextPositions[lineNo];
+				if ((s32)BrokenText[lineNo+1].size() < cp)
+					CursorPos = BrokenTextPositions[lineNo+1] + BrokenText[lineNo+1].size()-1;
+				else
+					CursorPos = BrokenTextPositions[lineNo+1] + cp;
+			}
+
+			if (event.KeyInput.Shift)
+			{
+				newMarkBegin = mb;
+				newMarkEnd = CursorPos;
+			}
+			else
+			{
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+
+		}
+		else
+		{
+			return false;
+		}
+		break;
+
+	case KEY_BACK:
+		if ( !this->IsEnabled )
+			break;
+
+		if (Text.size())
+		{
+			core::stringw s;
+
+			if (MarkBegin != MarkEnd)
+			{
+				// delete marked text
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				s = Text.subString(0, realmbgn);
+				s.append( Text.subString(realmend, Text.size()-realmend) );
+				Text = s;
+
+				CursorPos = realmbgn;
+			}
+			else
+			{
+				// delete text behind cursor
+				if (CursorPos>0)
+					s = Text.subString(0, CursorPos-1);
+				else
+					s = L"";
+				s.append( Text.subString(CursorPos, Text.size()-CursorPos) );
+				Text = s;
+				--CursorPos;
+			}
+
+			if (CursorPos < 0)
+				CursorPos = 0;
+			BlinkStartTime = os::Timer::getTime();
+			newMarkBegin = 0;
+			newMarkEnd = 0;
+			textChanged = true;
+		}
+		break;
+	case KEY_DELETE:
+		if ( !this->IsEnabled )
+			break;
+
+		if (Text.size() != 0)
+		{
+			core::stringw s;
+
+			if (MarkBegin != MarkEnd)
+			{
+				// delete marked text
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				s = Text.subString(0, realmbgn);
+				s.append( Text.subString(realmend, Text.size()-realmend) );
+				Text = s;
+
+				CursorPos = realmbgn;
+			}
+			else
+			{
+				// delete text before cursor
+				s = Text.subString(0, CursorPos);
+				s.append( Text.subString(CursorPos+1, Text.size()-CursorPos-1) );
+				Text = s;
+			}
+
+			if (CursorPos > (s32)Text.size())
+				CursorPos = (s32)Text.size();
+
+			BlinkStartTime = os::Timer::getTime();
+			newMarkBegin = 0;
+			newMarkEnd = 0;
+			textChanged = true;
+		}
+		break;
+
+	case KEY_ESCAPE:
+	case KEY_TAB:
+	case KEY_SHIFT:
+	case KEY_F1:
+	case KEY_F2:
+	case KEY_F3:
+	case KEY_F4:
+	case KEY_F5:
+	case KEY_F6:
+	case KEY_F7:
+	case KEY_F8:
+	case KEY_F9:
+	case KEY_F10:
+	case KEY_F11:
+	case KEY_F12:
+	case KEY_F13:
+	case KEY_F14:
+	case KEY_F15:
+	case KEY_F16:
+	case KEY_F17:
+	case KEY_F18:
+	case KEY_F19:
+	case KEY_F20:
+	case KEY_F21:
+	case KEY_F22:
+	case KEY_F23:
+	case KEY_F24:
+		// ignore these keys
+		return false;
+
+	default:
+		inputChar(event.KeyInput.Char);
+		return true;
+	}
+
+    // Set new text markers
+    setTextMarkers( newMarkBegin, newMarkEnd );
+
+	// break the text if it has changed
+	if (textChanged)
+	{
+		breakText();
+		sendGuiEvent(EGET_EDITBOX_CHANGED);
+	}
+
+	calculateScrollPos();
+
+	return true;
+}
+
+
+//! draws the element and its children
+void CGUIEditBox::draw()
+{
+	if (!IsVisible)
+		return;
+
+	const bool focus = Environment->hasFocus(this);
+
+	IGUISkin* skin = Environment->getSkin();
+	if (!skin)
+		return;
+
+	FrameRect = AbsoluteRect;
+
+	// draw the border
+
+	if (Border)
+	{
+		skin->draw3DSunkenPane(this, skin->getColor(EGDC_WINDOW),
+			false, true, FrameRect, &AbsoluteClippingRect);
+
+		FrameRect.UpperLeftCorner.X += skin->getSize(EGDS_TEXT_DISTANCE_X)+1;
+		FrameRect.UpperLeftCorner.Y += skin->getSize(EGDS_TEXT_DISTANCE_Y)+1;
+		FrameRect.LowerRightCorner.X -= skin->getSize(EGDS_TEXT_DISTANCE_X)+1;
+		FrameRect.LowerRightCorner.Y -= skin->getSize(EGDS_TEXT_DISTANCE_Y)+1;
+	}
+	core::rect<s32> localClipRect = FrameRect;
+	localClipRect.clipAgainst(AbsoluteClippingRect);
+
+	// draw the text
+
+	IGUIFont* font = OverrideFont;
+	if (!OverrideFont)
+		font = skin->getFont();
+
+	s32 cursorLine = 0;
+	s32 charcursorpos = 0;
+
+	if (font)
+	{
+		if (LastBreakFont != font)
+		{
+			breakText();
+		}
+
+		// calculate cursor pos
+
+		core::stringw *txtLine = &Text;
+		s32 startPos = 0;
+
+		core::stringw s, s2;
+
+		// get mark position
+		const bool ml = (!PasswordBox && (WordWrap || MultiLine));
+		const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+		const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+		const s32 hlineStart = ml ? getLineFromPos(realmbgn) : 0;
+		const s32 hlineCount = ml ? getLineFromPos(realmend) - hlineStart + 1 : 1;
+		const s32 lineCount = ml ? BrokenText.size() : 1;
+
+		// Save the override color information.
+		// Then, alter it if the edit box is disabled.
+		const bool prevOver = OverrideColorEnabled;
+		const video::SColor prevColor = OverrideColor;
+
+		if (Text.size())
+		{
+			if (!IsEnabled && !OverrideColorEnabled)
+			{
+				OverrideColorEnabled = true;
+				OverrideColor = skin->getColor(EGDC_GRAY_TEXT);
+			}
+
+			for (s32 i=0; i < lineCount; ++i)
+			{
+				setTextRect(i);
+
+				// clipping test - don't draw anything outside the visible area
+				core::rect<s32> c = localClipRect;
+				c.clipAgainst(CurrentTextRect);
+				if (!c.isValid())
+					continue;
+
+				// get current line
+				if (PasswordBox)
+				{
+					if (BrokenText.size() != 1)
+					{
+						BrokenText.clear();
+						BrokenText.push_back(core::stringw());
+					}
+					if (BrokenText[0].size() != Text.size())
+					{
+						BrokenText[0] = Text;
+						for (u32 q = 0; q < Text.size(); ++q)
+						{
+							BrokenText[0] [q] = PasswordChar;
+						}
+					}
+					txtLine = &BrokenText[0];
+					startPos = 0;
+				}
+				else
+				{
+					txtLine = ml ? &BrokenText[i] : &Text;
+					startPos = ml ? BrokenTextPositions[i] : 0;
+				}
+
+
+				// draw normal text
+				font->draw(txtLine->c_str(), CurrentTextRect,
+					OverrideColorEnabled ? OverrideColor : skin->getColor(EGDC_BUTTON_TEXT),
+					false, true, &localClipRect);
+
+				// draw mark and marked text
+				if (focus && MarkBegin != MarkEnd && i >= hlineStart && i < hlineStart + hlineCount)
+				{
+
+					s32 mbegin = 0, mend = 0;
+					s32 lineStartPos = 0, lineEndPos = txtLine->size();
+
+					if (i == hlineStart)
+					{
+						// highlight start is on this line
+						s = txtLine->subString(0, realmbgn - startPos);
+						mbegin = font->getDimension(s.c_str()).Width;
+
+						// deal with kerning
+						mbegin += font->getKerningWidth(
+							&((*txtLine)[realmbgn - startPos]),
+							realmbgn - startPos > 0 ? &((*txtLine)[realmbgn - startPos - 1]) : 0);
+
+						lineStartPos = realmbgn - startPos;
+					}
+					if (i == hlineStart + hlineCount - 1)
+					{
+						// highlight end is on this line
+						s2 = txtLine->subString(0, realmend - startPos);
+						mend = font->getDimension(s2.c_str()).Width;
+						lineEndPos = (s32)s2.size();
+					}
+					else
+						mend = font->getDimension(txtLine->c_str()).Width;
+
+					CurrentTextRect.UpperLeftCorner.X += mbegin;
+					CurrentTextRect.LowerRightCorner.X = CurrentTextRect.UpperLeftCorner.X + mend - mbegin;
+
+					// draw mark
+					skin->draw2DRectangle(this, skin->getColor(EGDC_HIGH_LIGHT), CurrentTextRect, &localClipRect);
+
+					// draw marked text
+					s = txtLine->subString(lineStartPos, lineEndPos - lineStartPos);
+
+					if (s.size())
+						font->draw(s.c_str(), CurrentTextRect,
+							OverrideColorEnabled ? OverrideColor : skin->getColor(EGDC_HIGH_LIGHT_TEXT),
+							false, true, &localClipRect);
+
+				}
+			}
+
+			// Return the override color information to its previous settings.
+			OverrideColorEnabled = prevOver;
+			OverrideColor = prevColor;
+		}
+
+		// draw cursor
+
+		if (WordWrap || MultiLine)
+		{
+			cursorLine = getLineFromPos(CursorPos);
+			txtLine = &BrokenText[cursorLine];
+			startPos = BrokenTextPositions[cursorLine];
+		}
+		s = txtLine->subString(0,CursorPos-startPos);
+		charcursorpos = font->getDimension(s.c_str()).Width +
+			font->getKerningWidth(L"_", CursorPos-startPos > 0 ? &((*txtLine)[CursorPos-startPos-1]) : 0);
+
+		if (focus && (os::Timer::getTime() - BlinkStartTime) % 700 < 350)
+		{
+			setTextRect(cursorLine);
+			CurrentTextRect.UpperLeftCorner.X += charcursorpos;
+
+			font->draw(L"_", CurrentTextRect,
+				OverrideColorEnabled ? OverrideColor : skin->getColor(EGDC_BUTTON_TEXT),
+				false, true, &localClipRect);
+		}
+	}
+
+	// draw children
+	IGUIElement::draw();
+}
+
+
+//! Sets the new caption of this element.
+void CGUIEditBox::setText(const wchar_t* text)
+{
+	Text = text;
+	if (u32(CursorPos) > Text.size())
+		CursorPos = Text.size();
+	HScrollPos = 0;
+	breakText();
+}
+
+
+//! Enables or disables automatic scrolling with cursor position
+//! \param enable: If set to true, the text will move around with the cursor position
+void CGUIEditBox::setAutoScroll(bool enable)
+{
+	AutoScroll = enable;
+}
+
+
+//! Checks to see if automatic scrolling is enabled
+//! \return true if automatic scrolling is enabled, false if not
+bool CGUIEditBox::isAutoScrollEnabled() const
+{
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return AutoScroll;
+}
+
+
+//! Gets the area of the text in the edit box
+//! \return Returns the size in pixels of the text
+core::dimension2du CGUIEditBox::getTextDimension()
+{
+	core::rect<s32> ret;
+
+	setTextRect(0);
+	ret = CurrentTextRect;
+
+	for (u32 i=1; i < BrokenText.size(); ++i)
+	{
+		setTextRect(i);
+		ret.addInternalPoint(CurrentTextRect.UpperLeftCorner);
+		ret.addInternalPoint(CurrentTextRect.LowerRightCorner);
+	}
+
+	return core::dimension2du(ret.getSize());
+}
+
+
+//! Sets the maximum amount of characters which may be entered in the box.
+//! \param max: Maximum amount of characters. If 0, the character amount is
+//! infinity.
+void CGUIEditBox::setMax(u32 max)
+{
+	Max = max;
+
+	if (Text.size() > Max && Max != 0)
+		Text = Text.subString(0, Max);
+}
+
+
+//! Returns maximum amount of characters, previously set by setMax();
+u32 CGUIEditBox::getMax() const
+{
+	return Max;
+}
+
+
+bool CGUIEditBox::processMouse(const SEvent& event)
+{
+	switch(event.MouseInput.Event)
+	{
+	case irr::EMIE_LMOUSE_LEFT_UP:
+		if (Environment->hasFocus(this))
+		{
+			CursorPos = getCursorPos(event.MouseInput.X, event.MouseInput.Y);
+			if (MouseMarking)
+			{
+			    setTextMarkers( MarkBegin, CursorPos );
+			}
+			MouseMarking = false;
+			calculateScrollPos();
+			return true;
+		}
+		break;
+	case irr::EMIE_MOUSE_MOVED:
+		{
+			if (MouseMarking)
+			{
+				CursorPos = getCursorPos(event.MouseInput.X, event.MouseInput.Y);
+				setTextMarkers( MarkBegin, CursorPos );
+				calculateScrollPos();
+				return true;
+			}
+		}
+		break;
+	case EMIE_LMOUSE_PRESSED_DOWN:
+		if (!Environment->hasFocus(this))
+		{
+			BlinkStartTime = os::Timer::getTime();
+			MouseMarking = true;
+			CursorPos = getCursorPos(event.MouseInput.X, event.MouseInput.Y);
+			setTextMarkers(CursorPos, CursorPos );
+			calculateScrollPos();
+			return true;
+		}
+		else
+		{
+			if (!AbsoluteClippingRect.isPointInside(
+				core::position2d<s32>(event.MouseInput.X, event.MouseInput.Y)))
+			{
+				return false;
+			}
+			else
+			{
+				// move cursor
+				CursorPos = getCursorPos(event.MouseInput.X, event.MouseInput.Y);
+
+                s32 newMarkBegin = MarkBegin;
+				if (!MouseMarking)
+					newMarkBegin = CursorPos;
+
+				MouseMarking = true;
+				setTextMarkers( newMarkBegin, CursorPos);
+				calculateScrollPos();
+				return true;
+			}
+		}
+	default:
+		break;
+	}
+
+	return false;
+}
+
+
+s32 CGUIEditBox::getCursorPos(s32 x, s32 y)
+{
+	IGUIFont* font = OverrideFont;
+	IGUISkin* skin = Environment->getSkin();
+	if (!OverrideFont)
+		font = skin->getFont();
+
+	const u32 lineCount = (WordWrap || MultiLine) ? BrokenText.size() : 1;
+
+	core::stringw *txtLine=0;
+	s32 startPos=0;
+	x+=3;
+
+	for (u32 i=0; i < lineCount; ++i)
+	{
+		setTextRect(i);
+		if (i == 0 && y < CurrentTextRect.UpperLeftCorner.Y)
+			y = CurrentTextRect.UpperLeftCorner.Y;
+		if (i == lineCount - 1 && y > CurrentTextRect.LowerRightCorner.Y )
+			y = CurrentTextRect.LowerRightCorner.Y;
+
+		// is it inside this region?
+		if (y >= CurrentTextRect.UpperLeftCorner.Y && y <= CurrentTextRect.LowerRightCorner.Y)
+		{
+			// we've found the clicked line
+			txtLine = (WordWrap || MultiLine) ? &BrokenText[i] : &Text;
+			startPos = (WordWrap || MultiLine) ? BrokenTextPositions[i] : 0;
+			break;
+		}
+	}
+
+	if (x < CurrentTextRect.UpperLeftCorner.X)
+		x = CurrentTextRect.UpperLeftCorner.X;
+
+	s32 idx = font->getCharacterFromPos(Text.c_str(), x - CurrentTextRect.UpperLeftCorner.X);
+
+	// click was on or left of the line
+	if (idx != -1)
+		return idx + startPos;
+
+	// click was off the right edge of the line, go to end.
+	return txtLine->size() + startPos;
+}
+
+
+//! Breaks the single text line.
+void CGUIEditBox::breakText()
+{
+	IGUISkin* skin = Environment->getSkin();
+
+	if ((!WordWrap && !MultiLine) || !skin)
+		return;
+
+	BrokenText.clear(); // need to reallocate :/
+	BrokenTextPositions.set_used(0);
+
+	IGUIFont* font = OverrideFont;
+	if (!OverrideFont)
+		font = skin->getFont();
+
+	if (!font)
+		return;
+
+	LastBreakFont = font;
+
+	core::stringw line;
+	core::stringw word;
+	core::stringw whitespace;
+	s32 lastLineStart = 0;
+	s32 size = Text.size();
+	s32 length = 0;
+	s32 elWidth = RelativeRect.getWidth() - 6;
+	wchar_t c;
+
+	for (s32 i=0; i<size; ++i)
+	{
+		c = Text[i];
+		bool lineBreak = false;
+
+		if (c == L'\r') // Mac or Windows breaks
+		{
+			lineBreak = true;
+			c = ' ';
+			if (Text[i+1] == L'\n') // Windows breaks
+			{
+				Text.erase(i+1);
+				--size;
+			}
+		}
+		else if (c == L'\n') // Unix breaks
+		{
+			lineBreak = true;
+			c = ' ';
+		}
+
+		// don't break if we're not a multi-line edit box
+		if (!MultiLine)
+			lineBreak = false;
+
+		if (c == L' ' || c == 0 || i == (size-1))
+		{
+			if (word.size())
+			{
+				// here comes the next whitespace, look if
+				// we can break the last word to the next line.
+				s32 whitelgth = font->getDimension(whitespace.c_str()).Width;
+				s32 worldlgth = font->getDimension(word.c_str()).Width;
+
+				if (WordWrap && length + worldlgth + whitelgth > elWidth)
+				{
+					// break to next line
+					length = worldlgth;
+					BrokenText.push_back(line);
+					BrokenTextPositions.push_back(lastLineStart);
+					lastLineStart = i - (s32)word.size();
+					line = word;
+				}
+				else
+				{
+					// add word to line
+					line += whitespace;
+					line += word;
+					length += whitelgth + worldlgth;
+				}
+
+				word = L"";
+				whitespace = L"";
+			}
+
+			whitespace += c;
+
+			// compute line break
+			if (lineBreak)
+			{
+				line += whitespace;
+				line += word;
+				BrokenText.push_back(line);
+				BrokenTextPositions.push_back(lastLineStart);
+				lastLineStart = i+1;
+				line = L"";
+				word = L"";
+				whitespace = L"";
+				length = 0;
+			}
+		}
+		else
+		{
+			// yippee this is a word..
+			word += c;
+		}
+	}
+
+	line += whitespace;
+	line += word;
+	BrokenText.push_back(line);
+	BrokenTextPositions.push_back(lastLineStart);
+}
+
+
+void CGUIEditBox::setTextRect(s32 line)
+{
+	core::dimension2du d;
+
+	IGUISkin* skin = Environment->getSkin();
+	if (!skin)
+		return;
+
+	IGUIFont* font = OverrideFont ? OverrideFont : skin->getFont();
+
+	if (!font)
+		return;
+
+	// get text dimension
+	const u32 lineCount = (WordWrap || MultiLine) ? BrokenText.size() : 1;
+	if (WordWrap || MultiLine)
+	{
+		d = font->getDimension(BrokenText[line].c_str());
+	}
+	else
+	{
+		d = font->getDimension(Text.c_str());
+		d.Height = AbsoluteRect.getHeight();
+	}
+	d.Height += font->getKerningHeight();
+
+	// justification
+	switch (HAlign)
+	{
+	case EGUIA_CENTER:
+		// align to h centre
+		CurrentTextRect.UpperLeftCorner.X = (FrameRect.getWidth()/2) - (d.Width/2);
+		CurrentTextRect.LowerRightCorner.X = (FrameRect.getWidth()/2) + (d.Width/2);
+		break;
+	case EGUIA_LOWERRIGHT:
+		// align to right edge
+		CurrentTextRect.UpperLeftCorner.X = FrameRect.getWidth() - d.Width;
+		CurrentTextRect.LowerRightCorner.X = FrameRect.getWidth();
+		break;
+	default:
+		// align to left edge
+		CurrentTextRect.UpperLeftCorner.X = 0;
+		CurrentTextRect.LowerRightCorner.X = d.Width;
+
+	}
+
+	switch (VAlign)
+	{
+	case EGUIA_CENTER:
+		// align to v centre
+		CurrentTextRect.UpperLeftCorner.Y =
+			(FrameRect.getHeight()/2) - (lineCount*d.Height)/2 + d.Height*line;
+		break;
+	case EGUIA_LOWERRIGHT:
+		// align to bottom edge
+		CurrentTextRect.UpperLeftCorner.Y =
+			FrameRect.getHeight() - lineCount*d.Height + d.Height*line;
+		break;
+	default:
+		// align to top edge
+		CurrentTextRect.UpperLeftCorner.Y = d.Height*line;
+		break;
+	}
+
+	CurrentTextRect.UpperLeftCorner.X  -= HScrollPos;
+	CurrentTextRect.LowerRightCorner.X -= HScrollPos;
+	CurrentTextRect.UpperLeftCorner.Y  -= VScrollPos;
+	CurrentTextRect.LowerRightCorner.Y = CurrentTextRect.UpperLeftCorner.Y + d.Height;
+
+	CurrentTextRect += FrameRect.UpperLeftCorner;
+
+}
+
+
+s32 CGUIEditBox::getLineFromPos(s32 pos)
+{
+	if (!WordWrap && !MultiLine)
+		return 0;
+
+	s32 i=0;
+	while (i < (s32)BrokenTextPositions.size())
+	{
+		if (BrokenTextPositions[i] > pos)
+			return i-1;
+		++i;
+	}
+	return (s32)BrokenTextPositions.size() - 1;
+}
+
+
+void CGUIEditBox::inputChar(wchar_t c)
+{
+	if (!IsEnabled)
+		return;
+
+	if (c != 0)
+	{
+		if (Text.size() < Max || Max == 0)
+		{
+			core::stringw s;
+
+			if (MarkBegin != MarkEnd)
+			{
+				// replace marked text
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				s = Text.subString(0, realmbgn);
+				s.append(c);
+				s.append( Text.subString(realmend, Text.size()-realmend) );
+				Text = s;
+				CursorPos = realmbgn+1;
+			}
+			else
+			{
+				// add new character
+				s = Text.subString(0, CursorPos);
+				s.append(c);
+				s.append( Text.subString(CursorPos, Text.size()-CursorPos) );
+				Text = s;
+				++CursorPos;
+			}
+
+			BlinkStartTime = os::Timer::getTime();
+			setTextMarkers(0, 0);
+		}
+	}
+	breakText();
+	sendGuiEvent(EGET_EDITBOX_CHANGED);
+	calculateScrollPos();
+}
+
+
+void CGUIEditBox::calculateScrollPos()
+{
+	if (!AutoScroll)
+		return;
+
+	// calculate horizontal scroll position
+	s32 cursLine = getLineFromPos(CursorPos);
+	setTextRect(cursLine);
+
+	// don't do horizontal scrolling when wordwrap is enabled.
+	if (!WordWrap)
+	{
+		// get cursor position
+		IGUISkin* skin = Environment->getSkin();
+		if (!skin)
+			return;
+		IGUIFont* font = OverrideFont ? OverrideFont : skin->getFont();
+		if (!font)
+			return;
+
+		core::stringw *txtLine = MultiLine ? &BrokenText[cursLine] : &Text;
+		s32 cPos = MultiLine ? CursorPos - BrokenTextPositions[cursLine] : CursorPos;
+
+		s32 cStart = CurrentTextRect.UpperLeftCorner.X + HScrollPos +
+			font->getDimension(txtLine->subString(0, cPos).c_str()).Width;
+
+		s32 cEnd = cStart + font->getDimension(L"_ ").Width;
+
+		if (FrameRect.LowerRightCorner.X < cEnd)
+			HScrollPos = cEnd - FrameRect.LowerRightCorner.X;
+		else if (FrameRect.UpperLeftCorner.X > cStart)
+			HScrollPos = cStart - FrameRect.UpperLeftCorner.X;
+		else
+			HScrollPos = 0;
+
+		// todo: adjust scrollbar
+	}
+
+	// vertical scroll position
+	if (FrameRect.LowerRightCorner.Y < CurrentTextRect.LowerRightCorner.Y + VScrollPos)
+		VScrollPos = CurrentTextRect.LowerRightCorner.Y - FrameRect.LowerRightCorner.Y + VScrollPos;
+
+	else if (FrameRect.UpperLeftCorner.Y > CurrentTextRect.UpperLeftCorner.Y + VScrollPos)
+		VScrollPos = CurrentTextRect.UpperLeftCorner.Y - FrameRect.UpperLeftCorner.Y + VScrollPos;
+	else
+		VScrollPos = 0;
+
+	// todo: adjust scrollbar
+}
+
+//! set text markers
+void CGUIEditBox::setTextMarkers(s32 begin, s32 end)
+{
+    if ( begin != MarkBegin || end != MarkEnd )
+    {
+        MarkBegin = begin;
+        MarkEnd = end;
+        sendGuiEvent(EGET_EDITBOX_MARKING_CHANGED);
+    }
+}
+
+//! send some gui event to parent
+void CGUIEditBox::sendGuiEvent(EGUI_EVENT_TYPE type)
+{
+	if ( Parent )
+	{
+        SEvent e;
+        e.EventType = EET_GUI_EVENT;
+        e.GUIEvent.Caller = this;
+        e.GUIEvent.Element = 0;
+        e.GUIEvent.EventType = type;
+
+        Parent->OnEvent(e);
+	}
+}
+
+//! Writes attributes of the element.
+void CGUIEditBox::serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const
+{
+	// IGUIEditBox::serializeAttributes(out,options);
+
+	out->addBool  ("OverrideColorEnabled",OverrideColorEnabled );
+	out->addColor ("OverrideColor",       OverrideColor);
+	// out->addFont("OverrideFont",OverrideFont);
+	out->addInt   ("MaxChars",            Max);
+	out->addBool  ("WordWrap",            WordWrap);
+	out->addBool  ("MultiLine",           MultiLine);
+	out->addBool  ("AutoScroll",          AutoScroll);
+	out->addBool  ("PasswordBox",         PasswordBox);
+	core::stringw ch = L" ";
+	ch[0] = PasswordChar;
+	out->addString("PasswordChar",        ch.c_str());
+	out->addEnum  ("HTextAlign",          HAlign, GUIAlignmentNames);
+	out->addEnum  ("VTextAlign",          VAlign, GUIAlignmentNames);
+
+	IGUIEditBox::serializeAttributes(out,options);
+}
+
+
+//! Reads attributes of the element
+void CGUIEditBox::deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0)
+{
+	IGUIEditBox::deserializeAttributes(in,options);
+
+	setOverrideColor(in->getAttributeAsColor("OverrideColor"));
+	enableOverrideColor(in->getAttributeAsBool("OverrideColorEnabled"));
+	setMax(in->getAttributeAsInt("MaxChars"));
+	setWordWrap(in->getAttributeAsBool("WordWrap"));
+	setMultiLine(in->getAttributeAsBool("MultiLine"));
+	setAutoScroll(in->getAttributeAsBool("AutoScroll"));
+	core::stringw ch = in->getAttributeAsStringW("PasswordChar");
+
+	if (!ch.size())
+		setPasswordBox(in->getAttributeAsBool("PasswordBox"));
+	else
+		setPasswordBox(in->getAttributeAsBool("PasswordBox"), ch[0]);
+
+	setTextAlignment( (EGUI_ALIGNMENT) in->getAttributeAsEnumeration("HTextAlign", GUIAlignmentNames),
+			(EGUI_ALIGNMENT) in->getAttributeAsEnumeration("VTextAlign", GUIAlignmentNames));
+
+	// setOverrideFont(in->getAttributeAsFont("OverrideFont"));
+}
+
+
+} // end namespace gui
+} // end namespace irr
+
+#endif // _IRR_COMPILE_WITH_GUI_
+

gframe/CGUIEditBox.h

+// Copyright (C) 2002-2010 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_EDIT_BOX_H_INCLUDED__
+#define __C_GUI_EDIT_BOX_H_INCLUDED__
+
+#include "IrrCompileConfig.h"
+#ifdef _IRR_COMPILE_WITH_GUI_
+
+#include "IGUIEditBox.h"
+#include "irrArray.h"
+#include "IOSOperator.h"
+
+namespace irr
+{
+namespace gui
+{
+	class CGUIEditBox : public IGUIEditBox
+	{
+	public:
+
+		//! constructor
+		CGUIEditBox(const wchar_t* text, bool border, IGUIEnvironment* environment,
+			IGUIElement* parent, s32 id, const core::rect<s32>& rectangle);
+
+		//! destructor
+		virtual ~CGUIEditBox();
+
+		//! Sets another skin independent font.
+		virtual void setOverrideFont(IGUIFont* font=0);
+
+		//! Sets another color for the text.
+		virtual void setOverrideColor(video::SColor color);
+
+		//! Sets if the text should use the overide color or the
+		//! color in the gui skin.
+		virtual void enableOverrideColor(bool enable);
+
+		//! Turns the border on or off
+		virtual void setDrawBorder(bool border);
+
+		//! Enables or disables word wrap for using the edit box as multiline text editor.
+		virtual void setWordWrap(bool enable);
+
+		//! Checks if word wrap is enabled
+		//! \return true if word wrap is enabled, false otherwise
+		virtual bool isWordWrapEnabled() const;
+
+		//! Enables or disables newlines.
+		/** \param enable: If set to true, the EGET_EDITBOX_ENTER event will not be fired,
+		instead a newline character will be inserted. */
+		virtual void setMultiLine(bool enable);
+
+		//! Checks if multi line editing is enabled
+		//! \return true if mult-line is enabled, false otherwise
+		virtual bool isMultiLineEnabled() const;
+
+		//! Enables or disables automatic scrolling with cursor position
+		//! \param enable: If set to true, the text will move around with the cursor position
+		virtual void setAutoScroll(bool enable);
+
+		//! Checks to see if automatic scrolling is enabled
+		//! \return true if automatic scrolling is enabled, false if not
+		virtual bool isAutoScrollEnabled() const;
+
+		//! Gets the size area of the text in the edit box
+		//! \return Returns the size in pixels of the text
+		virtual core::dimension2du getTextDimension();
+
+		//! Sets text justification
+		virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical);
+
+		//! called if an event happened.
+		virtual bool OnEvent(const SEvent& event);
+
+		//! draws the element and its children
+		virtual void draw();
+
+		//! Sets the new caption of this element.
+		virtual void setText(const wchar_t* text);
+
+		//! Sets the maximum amount of characters which may be entered in the box.
+		//! \param max: Maximum amount of characters. If 0, the character amount is
+		//! infinity.
+		virtual void setMax(u32 max);
+
+		//! Returns maximum amount of characters, previously set by setMax();
+		virtual u32 getMax() const;
+
+		//! Sets whether the edit box is a password box. Setting this to true will
+		/** disable MultiLine, WordWrap and the ability to copy with ctrl+c or ctrl+x
+		\param passwordBox: true to enable password, false to disable
+		\param passwordChar: the character that is displayed instead of letters */
+		virtual void setPasswordBox(bool passwordBox, wchar_t passwordChar = L'*');
+
+		//! Returns true if the edit box is currently a password box.
+		virtual bool isPasswordBox() const;
+
+		//! Updates the absolute position, splits text if required
+		virtual void updateAbsolutePosition();
+
+		//! 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:
+		//! Breaks the single text line.
+		void breakText();
+		//! sets the area of the given line
+		void setTextRect(s32 line);
+		//! returns the line number that the cursor is on
+		s32 getLineFromPos(s32 pos);
+		//! adds a letter to the edit box
+		void inputChar(wchar_t c);
+		//! calculates the current scroll position
+		void calculateScrollPos();
+		//! send some gui event to parent
+		void sendGuiEvent(EGUI_EVENT_TYPE type);
+		//! set text markers
+		void setTextMarkers(s32 begin, s32 end);
+
+		bool processKey(const SEvent& event);
+		bool processMouse(const SEvent& event);
+		s32 getCursorPos(s32 x, s32 y);
+
+		bool MouseMarking;
+		bool Border;
+		bool OverrideColorEnabled;
+		s32 MarkBegin;
+		s32 MarkEnd;
+
+		video::SColor OverrideColor;
+		gui::IGUIFont *OverrideFont, *LastBreakFont;
+		IOSOperator* Operator;
+
+		u32 BlinkStartTime;
+		s32 CursorPos;
+		s32 HScrollPos, VScrollPos; // scroll position in characters
+		u32 Max;
+
+		bool WordWrap, MultiLine, AutoScroll, PasswordBox;
+		wchar_t PasswordChar;
+		EGUI_ALIGNMENT HAlign, VAlign;
+
+		core::array< core::stringw > BrokenText;
+		core::array< s32 > BrokenTextPositions;
+
+		core::rect<s32> CurrentTextRect, FrameRect; // temporary values
+	};
+
+
+} // end namespace gui
+} // end namespace irr
+
+#endif // _IRR_COMPILE_WITH_GUI_
+#endif // __C_GUI_EDIT_BOX_H_INCLUDED__
+

gframe/COSOperator.cpp

+// Copyright (C) 2002-2010 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#include "COSOperator.h"
+
+#ifdef _IRR_WINDOWS_API_
+#ifndef _IRR_XBOX_PLATFORM_
+#include <windows.h>
+#endif
+#else
+#include <string.h>
+#include <unistd.h>
+#ifndef _IRR_SOLARIS_PLATFORM_
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#endif
+#endif
+
+#if defined(_IRR_COMPILE_WITH_X11_DEVICE_)
+#include "CIrrDeviceLinux.h"
+#endif
+#ifdef _IRR_COMPILE_WITH_OSX_DEVICE_
+#include "MacOSX/OSXClipboard.h"
+#endif
+
+namespace irr
+{
+
+#if defined(_IRR_COMPILE_WITH_X11_DEVICE_)
+// constructor  linux
+COSOperator::COSOperator(const c8* osversion, CIrrDeviceLinux* device)
+: IrrDeviceLinux(device)
+{
+}
+#endif
+
+// constructor
+COSOperator::COSOperator(const c8* osVersion) : OperatingSystem(osVersion)
+{
+	#ifdef _DEBUG
+	setDebugName("COSOperator");
+	#endif
+}
+
+
+//! returns the current operating system version as string.
+const wchar_t* COSOperator::getOperationSystemVersion() const
+{
+	return OperatingSystem.c_str();
+}
+
+
+//! copies text to the clipboard
+void COSOperator::copyToClipboard(const c8* text) const
+{
+	if (strlen(text)==0)
+		return;
+
+// Windows version
+#if defined(_IRR_XBOX_PLATFORM_)
+#elif defined(_IRR_WINDOWS_API_)
+	if (!OpenClipboard(NULL) || text == 0)
+		return;
+
+	EmptyClipboard();
+
+	HGLOBAL clipbuffer;
+	wchar_t* buffer;
+
+	clipbuffer = GlobalAlloc(GMEM_DDESHARE, (wcslen((wchar_t*)text)+1) * sizeof(wchar_t*));
+	buffer = (wchar_t*)GlobalLock(clipbuffer);
+
+	wcscpy(buffer, (wchar_t*)text);
+
+	GlobalUnlock(clipbuffer);
+	SetClipboardData(CF_UNICODETEXT, clipbuffer);
+	CloseClipboard();
+
+// MacOSX version
+#elif defined(_IRR_COMPILE_WITH_OSX_DEVICE_)
+
+	OSXCopyToClipboard(text);
+
+#elif defined(_IRR_COMPILE_WITH_X11_DEVICE_)
+    if ( IrrDeviceLinux )
+        IrrDeviceLinux->copyToClipboard(text);
+#else
+
+#endif
+}
+
+
+//! gets text from the clipboard
+//! \return Returns 0 if no string is in there.
+const c8* COSOperator::getTextFromClipboard() const
+{
+#if defined(_IRR_XBOX_PLATFORM_)
+		return 0;
+#elif defined(_IRR_WINDOWS_API_)
+	if (!OpenClipboard(NULL))
+		return 0;
+
+	char * buffer = 0;
+
+	HANDLE hData = GetClipboardData(CF_UNICODETEXT);
+	buffer = (char*)GlobalLock( hData );
+	GlobalUnlock( hData );
+	CloseClipboard();
+	return buffer;
+
+#elif defined(_IRR_COMPILE_WITH_OSX_DEVICE_)
+	return (OSXCopyFromClipboard());
+
+#elif defined(_IRR_COMPILE_WITH_X11_DEVICE_)
+    if ( IrrDeviceLinux )
+        return IrrDeviceLinux->getTextFromClipboard();
+    return 0;
+
+#else
+
+	return 0;
+#endif
+}
+
+
+bool COSOperator::getProcessorSpeedMHz(u32* MHz) const
+{
+#if defined(_IRR_WINDOWS_API_) && !defined(_WIN32_WCE ) && !defined (_IRR_XBOX_PLATFORM_)
+	LONG Error;
+
+	HKEY Key;
+	Error = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+			__TEXT("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"),
+			0, KEY_READ, &Key);
+
+	if(Error != ERROR_SUCCESS)
+		return false;
+
+	DWORD Speed = 0;
+	DWORD Size = sizeof(Speed);
+	Error = RegQueryValueEx(Key, __TEXT("~MHz"), NULL, NULL, (LPBYTE)&Speed, &Size);
+
+	RegCloseKey(Key);
+
+	if (Error != ERROR_SUCCESS)
+		return false;
+	else if (MHz)
+		*MHz = Speed;
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return true;
+
+#elif defined(_IRR_OSX_PLATFORM_)
+	struct clockinfo CpuClock;
+	size_t Size = sizeof(clockinfo);
+
+	if (!sysctlbyname("kern.clockrate", &CpuClock, &Size, NULL, 0))
+		return false;
+	else if (MHz)
+		*MHz = CpuClock.hz;
+	return true;
+#else
+	// could probably be read from "/proc/cpuinfo" or "/proc/cpufreq"
+
+	return false;
+#endif
+}
+
+bool COSOperator::getSystemMemory(u32* Total, u32* Avail) const
+{
+#if defined(_IRR_WINDOWS_API_) && !defined (_IRR_XBOX_PLATFORM_)
+	MEMORYSTATUS MemoryStatus;
+	MemoryStatus.dwLength = sizeof(MEMORYSTATUS);
+
+	// cannot fail
+	GlobalMemoryStatus(&MemoryStatus);
+
+	if (Total)
+		*Total = (u32)(MemoryStatus.dwTotalPhys>>10);
+	if (Avail)
+		*Avail = (u32)(MemoryStatus.dwAvailPhys>>10);
+
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return true;
+
+#elif defined(_IRR_POSIX_API_) && !defined(__FreeBSD__)
+#if defined(_SC_PHYS_PAGES) && defined(_SC_AVPHYS_PAGES)
+        long ps = sysconf(_SC_PAGESIZE);
+        long pp = sysconf(_SC_PHYS_PAGES);
+        long ap = sysconf(_SC_AVPHYS_PAGES);
+
+	if ((ps==-1)||(pp==-1)||(ap==-1))
+		return false;
+
+	if (Total)
+		*Total = (u32)((ps*(long long)pp)>>10);
+	if (Avail)
+		*Avail = (u32)((ps*(long long)ap)>>10);
+	return true;
+#else
+	// TODO: implement for non-availablity of symbols/features
+	return false;
+#endif
+#else
+	// TODO: implement for OSX
+	return false;
+#endif
+}
+
+
+} // end namespace

gframe/bufferio.h

@@ -35,6 +35,79 @@ public:
 		*p = val;
 		p++;
 	}
+	template<typename T1, typename T2>
+	inline static int CopyWStr(T1* src, T2* pstr, int bufsize) {
+		int l = 0;
+		while(src[l] && l < bufsize - 1) {
+			pstr[l] = src[l];
+			l++;
+		}
+		pstr[l] = 0;
+		return l;
+	}
+	template<typename T1, typename T2>
+	inline static int CopyWStrRef(T1* src, T2*& pstr, int bufsize) {
+		int l = 0;
+		while(src[l] && l < bufsize - 1) {
+			pstr[l] = src[l];
+			l++;
+		}
+		pstr += l;
+		*pstr = 0;
+		return l;
+	}
+	static int EncodeUTF8(const wchar_t * wsrc, char * str) {
+		char* pstr = str;
+		while(*wsrc != 0) {
+			if(*wsrc < 0x80) {
+				*str = *wsrc;
+				++str;
+			} else if(*wsrc < 0x800) {
+				str[0] = (*wsrc >> 6) & 0x1f | 0xc0;
+				str[1] = (*wsrc) & 0x3f | 0x80;
+				str += 2;
+			} else {
+				str[0] = (*wsrc >> 12) & 0xf | 0xe0;
+				str[1] = (*wsrc >> 6) & 0x3f | 0x80;
+				str[2] = (*wsrc) & 0x3f | 0x80;
+				str += 3;
+			}
+			wsrc++;
+		}
+		*str = 0;
+		return str - pstr;
+	}
+	static int DecodeUTF8(const char * src, wchar_t * wstr) {
+		char* p = (char*)src;
+		wchar_t* wp = wstr;
+		while(*p != 0) {
+			if((*p & 0x80) == 0) {
+				*wp = *p;
+				p++;
+			} else if((*p & 0xe0) == 0xc0) {
+				*wp = (((int)p[0] & 0x1f) << 6) | ((int)p[1] & 0x3f);
+				p += 2;
+			} else if((*p & 0xf0) == 0xe0) {
+				*wp = (((int)p[0] & 0xf) << 12) | (((int)p[1] & 0x3f) << 6) | ((int)p[2] & 0x3f);
+				p += 3;
+			} else if((*p & 0xf8) == 0xf0) {
+				*wp = (((int)p[0] & 0x7) << 18) | (((int)p[1] & 0x3f) << 12) | (((int)p[2] & 0x3f) << 6) | ((int)p[3] & 0x3f);
+				p += 4;
+			} else
+				p++;
+			wp++;
+		}
+		*wp = 0;
+		return wp - wstr;
+	}
+	static int GetVal(const wchar_t* pstr) {
+		int ret = 0;
+		while(*pstr >= L'0' && *pstr <= L'9') {
+			ret = ret * 10 + (*pstr - L'0');
+			pstr++;
+		}
+		return ret;
+	}
 };
 
 #endif //BUFFERIO_H

gframe/client_field.cpp

 #include "client_field.h"
 #include "client_card.h"
+#include "data_manager.h"
+#include "image_manager.h"
 #include "game.h"
 #include "../ocgcore/field.h"
 
@@ -320,12 +322,12 @@ void ClientField::ShowSelectCard(bool buttonok) {
 			if(selectable_cards[i]->code)
 				mainGame->imageLoading.insert(std::make_pair(mainGame->btnCardSelect[i], selectable_cards[i]->code));
 			else
-				mainGame->btnCardSelect[i]->setImage(mainGame->imageManager.tCover);
+				mainGame->btnCardSelect[i]->setImage(imageManager.tCover);
 			mainGame->btnCardSelect[i]->setRelativePosition(rect<s32>(startpos + i * 125, 55, startpos + 120 + i * 125, 225));
 			mainGame->btnCardSelect[i]->setPressed(false);
 			mainGame->btnCardSelect[i]->setVisible(true);
 			if(mainGame->dInfo.curMsg != MSG_SORT_CHAIN && mainGame->dInfo.curMsg != MSG_SORT_CARD) {
-				myswprintf(formatBuffer, L"%ls[%d]", mainGame->dataManager.FormatLocation(selectable_cards[i]->location), selectable_cards[i]->sequence + 1);
+				myswprintf(formatBuffer, L"%ls[%d]", dataManager.FormatLocation(selectable_cards[i]->location), selectable_cards[i]->sequence + 1);
 				mainGame->stCardPos[i]->setText(formatBuffer);
 				mainGame->stCardPos[i]->setVisible(true);;
 				if(selectable_cards[i]->controler)
@@ -351,12 +353,12 @@ void ClientField::ShowSelectCard(bool buttonok) {
 			if(selectable_cards[i]->code)
 				mainGame->imageLoading.insert(std::make_pair(mainGame->btnCardSelect[i], selectable_cards[i]->code));
 			else
-				mainGame->btnCardSelect[i]->setImage(mainGame->imageManager.tCover);
+				mainGame->btnCardSelect[i]->setImage(imageManager.tCover);
 			mainGame->btnCardSelect[i]->setRelativePosition(rect<s32>(30 + i * 125, 55, 30 + 120 + i * 125, 225));
 			mainGame->btnCardSelect[i]->setPressed(false);
 			mainGame->btnCardSelect[i]->setVisible(true);
 			if(mainGame->dInfo.curMsg != MSG_SORT_CHAIN && mainGame->dInfo.curMsg != MSG_SORT_CARD) {
-				myswprintf(formatBuffer, L"%ls[%d]", mainGame->dataManager.FormatLocation(selectable_cards[i]->location), selectable_cards[i]->sequence + 1);
+				myswprintf(formatBuffer, L"%ls[%d]", dataManager.FormatLocation(selectable_cards[i]->location), selectable_cards[i]->sequence + 1);
 				mainGame->stCardPos[i]->setText(formatBuffer);
 				mainGame->stCardPos[i]->setVisible(true);
 				if(selectable_cards[i]->controler)

gframe/config.h

@@ -59,4 +59,6 @@ using namespace video;
 using namespace io;
 using namespace gui;
 
+extern const unsigned short PRO_VERSION;
+
 #endif

gframe/data_manager.cpp

 #include "data_manager.h"
 #include <stdio.h>
+
 namespace ygo {
-const wchar_t* DataManager::unknown_string = L"???";
 	
+const wchar_t* DataManager::unknown_string = L"???";
 wchar_t DataManager::strBuffer[2048];
+DataManager dataManager;
 
 bool DataManager::LoadDates(const char* file) {
 	sqlite3* pDB;
@@ -36,12 +38,12 @@ bool DataManager::LoadDates(const char* file) {
 			cd.attribute = sqlite3_column_int(pStmt, 9);
 			cd.category = sqlite3_column_int(pStmt, 10);
 			_datas.insert(std::make_pair(cd.code, cd));
-			len = DecodeUTF8((const char*)sqlite3_column_text(pStmt, 12), strBuffer);
+			len = BufferIO::DecodeUTF8((const char*)sqlite3_column_text(pStmt, 12), strBuffer);
 			if(len) {
 				cs.name = new wchar_t[len + 1];
 				memcpy(cs.name, strBuffer, (len + 1)*sizeof(wchar_t));
 			} else cs.name = 0;
-			len = DecodeUTF8((const char*)sqlite3_column_text(pStmt, 13), strBuffer);
+			len = BufferIO::DecodeUTF8((const char*)sqlite3_column_text(pStmt, 13), strBuffer);
 			if(len) {
 				cs.text = new wchar_t[len + 1];
 				memcpy(cs.text, strBuffer, (len + 1)*sizeof(wchar_t));
@@ -50,7 +52,7 @@ bool DataManager::LoadDates(const char* file) {
 				cs.text[0] = 0;
 			}
 			for(int i = 14; i < 30; ++i) {
-				len = DecodeUTF8((const char*)sqlite3_column_text(pStmt, i), strBuffer);
+				len = BufferIO::DecodeUTF8((const char*)sqlite3_column_text(pStmt, i), strBuffer);
 				if(len) {
 					cs.desc[i - 14] = new wchar_t[len + 1];
 					memcpy(cs.desc[i - 14], strBuffer, (len + 1)*sizeof(wchar_t));
@@ -78,19 +80,19 @@ bool DataManager::LoadDates(const char* file) {
 		sscanf(linebuf, "!%s", strbuf);
 		if(!strcmp(strbuf, "system")) {
 			sscanf(&linebuf[7], "%d %s", &value, strbuf);
-			int len = DecodeUTF8(strbuf, strBuffer);
+			int len = BufferIO::DecodeUTF8(strbuf, strBuffer);
 			wchar_t* pbuf = new wchar_t[len + 1];
 			wcscpy(pbuf, strBuffer);
 			_sysStrings[value] = pbuf;
 		} else if(!strcmp(strbuf, "victory")) {
 			sscanf(&linebuf[8], "%x %s", &value, strbuf);
-			int len = DecodeUTF8(strbuf, strBuffer);
+			int len = BufferIO::DecodeUTF8(strbuf, strBuffer);
 			wchar_t* pbuf = new wchar_t[len + 1];
 			wcscpy(pbuf, strBuffer);
 			_victoryStrings[value] = pbuf;
 		} else if(!strcmp(strbuf, "counter")) {
 			sscanf(&linebuf[8], "%x %s", &value, strbuf);
-			int len = DecodeUTF8(strbuf, strBuffer);
+			int len = BufferIO::DecodeUTF8(strbuf, strBuffer);
 			wchar_t* pbuf = new wchar_t[len + 1];
 			wcscpy(pbuf, strBuffer);
 			_counterStrings[value] = pbuf;
@@ -102,7 +104,7 @@ bool DataManager::LoadDates(const char* file) {
 	return true;
 }
 bool DataManager::Error(sqlite3* pDB, sqlite3_stmt* pStmt) {
-	DecodeUTF8(sqlite3_errmsg(pDB), strBuffer);
+	BufferIO::DecodeUTF8(sqlite3_errmsg(pDB), strBuffer);
 	if(pStmt)
 		sqlite3_finalize(pStmt);
 	sqlite3_close(pDB);
@@ -177,68 +179,6 @@ const wchar_t* DataManager::GetCounterName(int code) {
 const wchar_t* DataManager::GetNumString(int num) {
 	return numStrings[num];
 }
-int DataManager::EncodeUTF8(const wchar_t * wsrc, char * str) {
-	char* pstr = str;
-	while(*wsrc != 0) {
-		if(*wsrc < 0x80) {
-			*str = *wsrc;
-			++str;
-		} else if(*wsrc < 0x800) {
-			str[0] = (*wsrc >> 6) & 0x1f | 0xc0;
-			str[1] = (*wsrc) & 0x3f | 0x80;
-			str += 2;
-		} else {
-			str[0] = (*wsrc >> 12) & 0xf | 0xe0;
-			str[1] = (*wsrc >> 6) & 0x3f | 0x80;
-			str[2] = (*wsrc) & 0x3f | 0x80;
-			str += 3;
-		}
-		wsrc++;
-	}
-	*str = 0;
-	return str - pstr;
-}
-int DataManager::DecodeUTF8(const char * src, wchar_t * wstr) {
-	char* p = (char*)src;
-	wchar_t* wp = wstr;
-	while(*p != 0) {
-		if((*p & 0x80) == 0) {
-			*wp = *p;
-			p++;
-		} else if((*p & 0xe0) == 0xc0) {
-			*wp = (((int)p[0] & 0x1f) << 6) | ((int)p[1] & 0x3f);
-			p += 2;
-		} else if((*p & 0xf0) == 0xe0) {
-			*wp = (((int)p[0] & 0xf) << 12) | (((int)p[1] & 0x3f) << 6) | ((int)p[2] & 0x3f);
-			p += 3;
-		} else if((*p & 0xf8) == 0xf0) {
-			*wp = (((int)p[0] & 0x7) << 18) | (((int)p[1] & 0x3f) << 12) | (((int)p[2] & 0x3f) << 6) | ((int)p[3] & 0x3f);
-			p += 4;
-		} else
-			p++;
-		wp++;
-	}
-	*wp = 0;
-	return wp - wstr;
-}
-int DataManager::GetVal(const wchar_t* pstr) {
-	int ret = 0;
-	while(*pstr >= L'0' && *pstr <= L'9') {
-		ret = ret * 10 + (*pstr - L'0');
-		pstr++;
-	}
-	return ret;
-}
-int DataManager::CopyStr(const wchar_t* src, wchar_t*& pstr, int maxlen) {
-	int l = 0;
-	while(src[l] && l < maxlen) {
-		pstr[l] = src[l];
-		l++;
-	}
-	pstr += l;
-	*pstr = 0;
-	return l;
-}
 const wchar_t* DataManager::FormatLocation(int location) {
 	int filter = 1, i = 1000;
 	while(filter != location) {
@@ -255,7 +195,7 @@ const wchar_t* DataManager::FormatAttribute(int attribute) {
 	int filter = 1, i = 1010;
 	for(; filter != 0x80; filter <<= 1, ++i) {
 		if(attribute & filter) {
-			CopyStr(GetSysString(i), p, 16);
+			BufferIO::CopyWStrRef(GetSysString(i), p, 16);
 			*p = L'|';
 			*++p = 0;
 		}
@@ -269,7 +209,7 @@ const wchar_t* DataManager::FormatRace(int race) {
 	int filter = 1, i = 1020;
 	for(; filter != 0x800000; filter <<= 1, ++i) {
 		if(race & filter) {
-			CopyStr(GetSysString(i), p, 16);
+			BufferIO::CopyWStrRef(GetSysString(i), p, 16);
 			*p = L'|';
 			*++p = 0;
 		}
@@ -283,7 +223,7 @@ const wchar_t* DataManager::FormatType(int type) {
 	int filter = 1, i = 1050;
 	for(; filter != 0x1000000; filter <<= 1, ++i) {
 		if(type & filter) {
-			CopyStr(GetSysString(i), p, 16);
+			BufferIO::CopyWStrRef(GetSysString(i), p, 16);
 			*p = L'|';
 			*++p = 0;
 		}

gframe/data_manager.h

@@ -10,10 +10,6 @@ namespace ygo {
 
 class DataManager {
 public:
-	DataManager() {
-	}
-	~DataManager() {
-	}
 	bool LoadDates(const char* file);
 	bool Error(sqlite3* pDB, sqlite3_stmt* pStmt = 0);
 	bool GetData(int code, CardData* pData);
@@ -30,10 +26,6 @@ public:
 	const wchar_t* FormatAttribute(int attribute);
 	const wchar_t* FormatRace(int race);
 	const wchar_t* FormatType(int type);
-	static int EncodeUTF8(const wchar_t * wsrc, char * str);
-	static int DecodeUTF8(const char * src, wchar_t * wstr);
-	static int GetVal(const wchar_t* pstr);
-	static int CopyStr(const wchar_t* src, wchar_t*& pstr, int maxlen);
 
 	std::unordered_map<unsigned int, CardDataC> _datas;
 	std::unordered_map<unsigned int, CardString> _strings;
@@ -48,8 +40,11 @@ public:
 
 	static wchar_t strBuffer[2048];
 	static const wchar_t* unknown_string;
+	
 };
 
+extern DataManager dataManager;
+
 }
 
 #endif // DATAMANAGER_H

gframe/deck_con.cpp

 #include "config.h"
 #include "deck_con.h"
+#include "data_manager.h"
+#include "deck_manager.h"
+#include "image_manager.h"
 #include "game.h"
 #include <algorithm>
 
@@ -14,19 +17,19 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 		case irr::gui::EGET_BUTTON_CLICKED: {
 			switch(id) {
 			case BUTTON_CLEAR_DECK: {
-				mainGame->deckManager.deckhost.main.clear();
-				mainGame->deckManager.deckhost.extra.clear();
-				mainGame->deckManager.deckhost.side.clear();
+				deckManager.deckhost.main.clear();
+				deckManager.deckhost.extra.clear();
+				deckManager.deckhost.side.clear();
 				break;
 			}
 			case BUTTON_SORT_DECK: {
-				std::sort(mainGame->deckManager.deckhost.main.begin(), mainGame->deckManager.deckhost.main.end(), ClientCard::deck_sort_lv);
-				std::sort(mainGame->deckManager.deckhost.extra.begin(), mainGame->deckManager.deckhost.extra.end(), ClientCard::deck_sort_lv);
-				std::sort(mainGame->deckManager.deckhost.side.begin(), mainGame->deckManager.deckhost.side.end(), ClientCard::deck_sort_lv);
+				std::sort(deckManager.deckhost.main.begin(), deckManager.deckhost.main.end(), ClientCard::deck_sort_lv);
+				std::sort(deckManager.deckhost.extra.begin(), deckManager.deckhost.extra.end(), ClientCard::deck_sort_lv);
+				std::sort(deckManager.deckhost.side.begin(), deckManager.deckhost.side.end(), ClientCard::deck_sort_lv);
 				break;
 			}
 			case BUTTON_SAVE_DECK: {
-				mainGame->deckManager.SaveDeck(mainGame->deckManager.deckhost, mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()));
+				deckManager.SaveDeck(deckManager.deckhost, mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()));
 				mainGame->stACMessage->setText(L"保存成功");
 				mainGame->PopupElement(mainGame->wACMessage, 20);
 				break;
@@ -48,7 +51,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 					mainGame->cbDBDecks->addItem(dname);
 					mainGame->cbDBDecks->setSelected(mainGame->cbDBDecks->getItemCount() - 1);
 				}
-				mainGame->deckManager.SaveDeck(mainGame->deckManager.deckhost, dname);
+				deckManager.SaveDeck(deckManager.deckhost, dname);
 				mainGame->ebDeckname->setText(L"");
 				mainGame->stACMessage->setText(L"保存成功");
 				mainGame->PopupElement(mainGame->wACMessage, 20);
@@ -63,11 +66,10 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				mainGame->wInfos->setVisible(false);
 				mainGame->PopupElement(mainGame->wMainMenu);
 				mainGame->device->setEventReceiver(&mainGame->menuHandler);
-				mainGame->imageManager.ClearTexture();
+				imageManager.ClearTexture();
 				mainGame->scrFilter->setVisible(false);
-				wchar_t* p = mainGame->gameConf.lastdeck;
 				if(mainGame->cbDBDecks->getSelected() != -1) {
-					DataManager::CopyStr(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()), p, 63);
+					BufferIO::CopyWStr(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()), mainGame->gameConf.lastdeck, 64);
 				}
 				break;
 			}
@@ -90,25 +92,25 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				else {
 					if(*pstr == L'=') {
 						filter_atktype = 1;
-						filter_atk = DataManager::GetVal(pstr + 1);
+						filter_atk = BufferIO::GetVal(pstr + 1);
 					} else if(*pstr >= L'0' && *pstr <= L'9') {
 						filter_atktype = 1;
-						filter_atk = DataManager::GetVal(pstr);
+						filter_atk = BufferIO::GetVal(pstr);
 					} else if(*pstr == L'>') {
 						if(*(pstr + 1) == L'=') {
 							filter_atktype = 2;
-							filter_atk = DataManager::GetVal(pstr + 2);
+							filter_atk = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_atktype = 3;
-							filter_atk = DataManager::GetVal(pstr + 1);
+							filter_atk = BufferIO::GetVal(pstr + 1);
 						}
 					} else if(*pstr == L'<') {
 						if(*(pstr + 1) == L'=') {
 							filter_atktype = 4;
-							filter_atk = DataManager::GetVal(pstr + 2);
+							filter_atk = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_atktype = 5;
-							filter_atk = DataManager::GetVal(pstr + 1);
+							filter_atk = BufferIO::GetVal(pstr + 1);
 						}
 					} else if(*pstr == L'?') {
 						filter_atktype = 6;
@@ -119,25 +121,25 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				else {
 					if(*pstr == L'=') {
 						filter_deftype = 1;
-						filter_def = DataManager::GetVal(pstr + 1);
+						filter_def = BufferIO::GetVal(pstr + 1);
 					} else if(*pstr >= L'0' && *pstr <= L'9') {
 						filter_deftype = 1;
-						filter_def = DataManager::GetVal(pstr);
+						filter_def = BufferIO::GetVal(pstr);
 					} else if(*pstr == L'>') {
 						if(*(pstr + 1) == L'=') {
 							filter_deftype = 2;
-							filter_def = DataManager::GetVal(pstr + 2);
+							filter_def = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_deftype = 3;
-							filter_def = DataManager::GetVal(pstr + 1);
+							filter_def = BufferIO::GetVal(pstr + 1);
 						}
 					} else if(*pstr == L'<') {
 						if(*(pstr + 1) == L'=') {
 							filter_deftype = 4;
-							filter_def = DataManager::GetVal(pstr + 2);
+							filter_def = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_deftype = 5;
-							filter_def = DataManager::GetVal(pstr + 1);
+							filter_def = BufferIO::GetVal(pstr + 1);
 						}
 					} else if(*pstr == L'?') {
 						filter_deftype = 6;
@@ -148,25 +150,25 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				else {
 					if(*pstr == L'=') {
 						filter_lvtype = 1;
-						filter_lv = DataManager::GetVal(pstr + 1);
+						filter_lv = BufferIO::GetVal(pstr + 1);
 					} else if(*pstr >= L'0' && *pstr <= L'9') {
 						filter_lvtype = 1;
-						filter_lv = DataManager::GetVal(pstr);
+						filter_lv = BufferIO::GetVal(pstr);
 					} else if(*pstr == L'>') {
 						if(*(pstr + 1) == L'=') {
 							filter_lvtype = 2;
-							filter_lv = DataManager::GetVal(pstr + 2);
+							filter_lv = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_lvtype = 3;
-							filter_lv = DataManager::GetVal(pstr + 1);
+							filter_lv = BufferIO::GetVal(pstr + 1);
 						}
 					} else if(*pstr == L'<') {
 						if(*(pstr + 1) == L'=') {
 							filter_lvtype = 4;
-							filter_lv = DataManager::GetVal(pstr + 2);
+							filter_lv = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_lvtype = 5;
-							filter_lv = DataManager::GetVal(pstr + 1);
+							filter_lv = BufferIO::GetVal(pstr + 1);
 						}
 					} else filter_lvtype = 0;
 				}
@@ -188,25 +190,25 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				else {
 					if(*pstr == L'=') {
 						filter_atktype = 1;
-						filter_atk = DataManager::GetVal(pstr + 1);
+						filter_atk = BufferIO::GetVal(pstr + 1);
 					} else if(*pstr >= L'0' && *pstr <= L'9') {
 						filter_atktype = 1;
-						filter_atk = DataManager::GetVal(pstr);
+						filter_atk = BufferIO::GetVal(pstr);
 					} else if(*pstr == L'>') {
 						if(*(pstr + 1) == L'=') {
 							filter_atktype = 2;
-							filter_atk = DataManager::GetVal(pstr + 2);
+							filter_atk = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_atktype = 3;
-							filter_atk = DataManager::GetVal(pstr + 1);
+							filter_atk = BufferIO::GetVal(pstr + 1);
 						}
 					} else if(*pstr == L'<') {
 						if(*(pstr + 1) == L'=') {
 							filter_atktype = 4;
-							filter_atk = DataManager::GetVal(pstr + 2);
+							filter_atk = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_atktype = 5;
-							filter_atk = DataManager::GetVal(pstr + 1);
+							filter_atk = BufferIO::GetVal(pstr + 1);
 						}
 					} else if(*pstr == L'?') {
 						filter_atktype = 6;
@@ -217,25 +219,25 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				else {
 					if(*pstr == L'=') {
 						filter_deftype = 1;
-						filter_def = DataManager::GetVal(pstr + 1);
+						filter_def = BufferIO::GetVal(pstr + 1);
 					} else if(*pstr >= L'0' && *pstr <= L'9') {
 						filter_deftype = 1;
-						filter_def = DataManager::GetVal(pstr);
+						filter_def = BufferIO::GetVal(pstr);
 					} else if(*pstr == L'>') {
 						if(*(pstr + 1) == L'=') {
 							filter_deftype = 2;
-							filter_def = DataManager::GetVal(pstr + 2);
+							filter_def = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_deftype = 3;
-							filter_def = DataManager::GetVal(pstr + 1);
+							filter_def = BufferIO::GetVal(pstr + 1);
 						}
 					} else if(*pstr == L'<') {
 						if(*(pstr + 1) == L'=') {
 							filter_deftype = 4;
-							filter_def = DataManager::GetVal(pstr + 2);
+							filter_def = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_deftype = 5;
-							filter_def = DataManager::GetVal(pstr + 1);
+							filter_def = BufferIO::GetVal(pstr + 1);
 						}
 					} else if(*pstr == L'?') {
 						filter_deftype = 6;
@@ -246,25 +248,25 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				else {
 					if(*pstr == L'=') {
 						filter_lvtype = 1;
-						filter_lv = DataManager::GetVal(pstr + 1);
+						filter_lv = BufferIO::GetVal(pstr + 1);
 					} else if(*pstr >= L'0' && *pstr <= L'9') {
 						filter_lvtype = 1;
-						filter_lv = DataManager::GetVal(pstr);
+						filter_lv = BufferIO::GetVal(pstr);
 					} else if(*pstr == L'>') {
 						if(*(pstr + 1) == L'=') {
 							filter_lvtype = 2;
-							filter_lv = DataManager::GetVal(pstr + 2);
+							filter_lv = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_lvtype = 3;
-							filter_lv = DataManager::GetVal(pstr + 1);
+							filter_lv = BufferIO::GetVal(pstr + 1);
 						}
 					} else if(*pstr == L'<') {
 						if(*(pstr + 1) == L'=') {
 							filter_lvtype = 4;
-							filter_lv = DataManager::GetVal(pstr + 2);
+							filter_lv = BufferIO::GetVal(pstr + 2);
 						} else {
 							filter_lvtype = 5;
-							filter_lv = DataManager::GetVal(pstr + 1);
+							filter_lv = BufferIO::GetVal(pstr + 1);
 						}
 					} else filter_lvtype = 0;
 				}
@@ -300,11 +302,11 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 		case irr::gui::EGET_COMBO_BOX_CHANGED: {
 			switch(id) {
 			case COMBOBOX_DBLFLIST: {
-				filterList = mainGame->deckManager._lfList[mainGame->cbDBLFList->getSelected()].content;
+				filterList = deckManager._lfList[mainGame->cbDBLFList->getSelected()].content;
 				break;
 			}
 			case COMBOBOX_DBDECKS: {
-				mainGame->deckManager.LoadDeck(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()));
+				deckManager.LoadDeck(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()));
 				break;
 			}
 			case COMBOBOX_MAINTYPE: {
@@ -389,33 +391,33 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 			click_pos = hovered_pos;
 			dragx = event.MouseInput.X;
 			dragy = event.MouseInput.Y;
-			draging_pointer = mainGame->dataManager.GetCodePointer(hovered_code);
+			draging_pointer = dataManager.GetCodePointer(hovered_code);
 			int limitcode = draging_pointer->second.alias ? draging_pointer->second.alias : draging_pointer->first;
 			if(hovered_pos == 4) {
 				int limit = 3;
 				if(filterList->count(limitcode))
 					limit = (*filterList)[limitcode];
-				for(int i = 0; i < mainGame->deckManager.deckhost.main.size(); ++i)
-					if(mainGame->deckManager.deckhost.main[i]->first == limitcode
-					        || mainGame->deckManager.deckhost.main[i]->second.alias == limitcode)
+				for(int i = 0; i < deckManager.deckhost.main.size(); ++i)
+					if(deckManager.deckhost.main[i]->first == limitcode
+					        || deckManager.deckhost.main[i]->second.alias == limitcode)
 						limit--;
-				for(int i = 0; i < mainGame->deckManager.deckhost.extra.size(); ++i)
-					if(mainGame->deckManager.deckhost.extra[i]->first == limitcode
-					        || mainGame->deckManager.deckhost.extra[i]->second.alias == limitcode)
+				for(int i = 0; i < deckManager.deckhost.extra.size(); ++i)
+					if(deckManager.deckhost.extra[i]->first == limitcode
+					        || deckManager.deckhost.extra[i]->second.alias == limitcode)
 						limit--;
-				for(int i = 0; i < mainGame->deckManager.deckhost.side.size(); ++i)
-					if(mainGame->deckManager.deckhost.side[i]->first == limitcode
-					        || mainGame->deckManager.deckhost.side[i]->second.alias == limitcode)
+				for(int i = 0; i < deckManager.deckhost.side.size(); ++i)
+					if(deckManager.deckhost.side[i]->first == limitcode
+					        || deckManager.deckhost.side[i]->second.alias == limitcode)
 						limit--;
 				if(limit <= 0)
 					break;
 			}
 			if(hovered_pos == 1)
-				mainGame->deckManager.deckhost.main.erase(mainGame->deckManager.deckhost.main.begin() + hovered_seq);
+				deckManager.deckhost.main.erase(deckManager.deckhost.main.begin() + hovered_seq);
 			else if(hovered_pos == 2)
-				mainGame->deckManager.deckhost.extra.erase(mainGame->deckManager.deckhost.extra.begin() + hovered_seq);
+				deckManager.deckhost.extra.erase(deckManager.deckhost.extra.begin() + hovered_seq);
 			else if(hovered_pos == 3)
-				mainGame->deckManager.deckhost.side.erase(mainGame->deckManager.deckhost.side.begin() + hovered_seq);
+				deckManager.deckhost.side.erase(deckManager.deckhost.side.begin() + hovered_seq);
 			is_draging = true;
 			break;
 		}
@@ -425,18 +427,18 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 			is_draging = false;
 			if((hovered_pos == 1 && (draging_pointer->second.type & 0x802040)) || (hovered_pos == 2 && !(draging_pointer->second.type & 0x802040)))
 				hovered_pos = 0;
-			if((hovered_pos == 1 || (hovered_pos == 0 && click_pos == 1)) && mainGame->deckManager.deckhost.main.size() < 60) {
-				if(hovered_seq < mainGame->deckManager.deckhost.main.size())
-					mainGame->deckManager.deckhost.main.insert(mainGame->deckManager.deckhost.main.begin() + hovered_seq, draging_pointer);
-				else mainGame->deckManager.deckhost.main.push_back(draging_pointer);
-			} else if((hovered_pos == 2 || (hovered_pos == 0 && click_pos == 2)) && mainGame->deckManager.deckhost.extra.size() < 15) {
-				if(hovered_seq < mainGame->deckManager.deckhost.extra.size())
-					mainGame->deckManager.deckhost.extra.insert(mainGame->deckManager.deckhost.extra.begin() + hovered_seq, draging_pointer);
-				else mainGame->deckManager.deckhost.extra.push_back(draging_pointer);
-			} else if((hovered_pos == 3 || (hovered_pos == 0 && click_pos == 3)) && mainGame->deckManager.deckhost.side.size() < 15) {
-				if(hovered_seq < mainGame->deckManager.deckhost.side.size())
-					mainGame->deckManager.deckhost.side.insert(mainGame->deckManager.deckhost.side.begin() + hovered_seq, draging_pointer);
-				else mainGame->deckManager.deckhost.side.push_back(draging_pointer);
+			if((hovered_pos == 1 || (hovered_pos == 0 && click_pos == 1)) && deckManager.deckhost.main.size() < 60) {
+				if(hovered_seq < deckManager.deckhost.main.size())
+					deckManager.deckhost.main.insert(deckManager.deckhost.main.begin() + hovered_seq, draging_pointer);
+				else deckManager.deckhost.main.push_back(draging_pointer);
+			} else if((hovered_pos == 2 || (hovered_pos == 0 && click_pos == 2)) && deckManager.deckhost.extra.size() < 15) {
+				if(hovered_seq < deckManager.deckhost.extra.size())
+					deckManager.deckhost.extra.insert(deckManager.deckhost.extra.begin() + hovered_seq, draging_pointer);
+				else deckManager.deckhost.extra.push_back(draging_pointer);
+			} else if((hovered_pos == 3 || (hovered_pos == 0 && click_pos == 3)) && deckManager.deckhost.side.size() < 15) {
+				if(hovered_seq < deckManager.deckhost.side.size())
+					deckManager.deckhost.side.insert(deckManager.deckhost.side.begin() + hovered_seq, draging_pointer);
+				else deckManager.deckhost.side.push_back(draging_pointer);
 			}
 			break;
 		}
@@ -446,37 +448,37 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 			if(hovered_pos == 0 || hovered_seq == -1)
 				break;
 			if(!is_draging)
-				draging_pointer = mainGame->dataManager.GetCodePointer(hovered_code);
+				draging_pointer = dataManager.GetCodePointer(hovered_code);
 			if(hovered_pos == 1) {
 				if(!is_draging)
-					mainGame->deckManager.deckhost.main.erase(mainGame->deckManager.deckhost.main.begin() + hovered_seq);
-				else if(mainGame->deckManager.deckhost.side.size() < 15) {
-					mainGame->deckManager.deckhost.side.push_back(draging_pointer);
+					deckManager.deckhost.main.erase(deckManager.deckhost.main.begin() + hovered_seq);
+				else if(deckManager.deckhost.side.size() < 15) {
+					deckManager.deckhost.side.push_back(draging_pointer);
 					is_draging = false;
 				}
 			} else if(hovered_pos == 2) {
 				if(!is_draging)
-					mainGame->deckManager.deckhost.extra.erase(mainGame->deckManager.deckhost.extra.begin() + hovered_seq);
-				else if(mainGame->deckManager.deckhost.side.size() < 15) {
-					mainGame->deckManager.deckhost.side.push_back(draging_pointer);
+					deckManager.deckhost.extra.erase(deckManager.deckhost.extra.begin() + hovered_seq);
+				else if(deckManager.deckhost.side.size() < 15) {
+					deckManager.deckhost.side.push_back(draging_pointer);
 					is_draging = false;
 				}
 			} else if(hovered_pos == 3) {
 				if(!is_draging)
-					mainGame->deckManager.deckhost.side.erase(mainGame->deckManager.deckhost.side.begin() + hovered_seq);
+					deckManager.deckhost.side.erase(deckManager.deckhost.side.begin() + hovered_seq);
 				else {
-					if((draging_pointer->second.type & 0x802040) && mainGame->deckManager.deckhost.extra.size() < 15) {
-						mainGame->deckManager.deckhost.extra.push_back(draging_pointer);
+					if((draging_pointer->second.type & 0x802040) && deckManager.deckhost.extra.size() < 15) {
+						deckManager.deckhost.extra.push_back(draging_pointer);
 						is_draging = false;
-					} else if(!(draging_pointer->second.type & 0x802040) && mainGame->deckManager.deckhost.main.size() < 60) {
-						mainGame->deckManager.deckhost.main.push_back(draging_pointer);
+					} else if(!(draging_pointer->second.type & 0x802040) && deckManager.deckhost.main.size() < 60) {
+						deckManager.deckhost.main.push_back(draging_pointer);
 						is_draging = false;
 					}
 				}
 			} else {
 				if(is_draging) {
-					if(mainGame->deckManager.deckhost.side.size() < 15) {
-						mainGame->deckManager.deckhost.side.push_back(draging_pointer);
+					if(deckManager.deckhost.side.size() < 15) {
+						deckManager.deckhost.side.push_back(draging_pointer);
 						is_draging = false;
 					}
 				} else {
@@ -484,24 +486,24 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 					int limit = 3;
 					if(filterList->count(limitcode))
 						limit = (*filterList)[limitcode];
-					for(int i = 0; i < mainGame->deckManager.deckhost.main.size(); ++i)
-						if(mainGame->deckManager.deckhost.main[i]->first == limitcode
-						        || mainGame->deckManager.deckhost.main[i]->second.alias == limitcode)
+					for(int i = 0; i < deckManager.deckhost.main.size(); ++i)
+						if(deckManager.deckhost.main[i]->first == limitcode
+						        || deckManager.deckhost.main[i]->second.alias == limitcode)
 							limit--;
-					for(int i = 0; i < mainGame->deckManager.deckhost.extra.size(); ++i)
-						if(mainGame->deckManager.deckhost.extra[i]->first == limitcode
-						        || mainGame->deckManager.deckhost.extra[i]->second.alias == limitcode)
+					for(int i = 0; i < deckManager.deckhost.extra.size(); ++i)
+						if(deckManager.deckhost.extra[i]->first == limitcode
+						        || deckManager.deckhost.extra[i]->second.alias == limitcode)
 							limit--;
-					for(int i = 0; i < mainGame->deckManager.deckhost.side.size(); ++i)
-						if(mainGame->deckManager.deckhost.side[i]->first == limitcode
-						        || mainGame->deckManager.deckhost.side[i]->second.alias == limitcode)
+					for(int i = 0; i < deckManager.deckhost.side.size(); ++i)
+						if(deckManager.deckhost.side[i]->first == limitcode
+						        || deckManager.deckhost.side[i]->second.alias == limitcode)
 							limit--;
 					if(limit <= 0)
 						break;
-					if((draging_pointer->second.type & 0x802040) && mainGame->deckManager.deckhost.extra.size() < 15) {
-						mainGame->deckManager.deckhost.extra.push_back(draging_pointer);
-					} else if(!(draging_pointer->second.type & 0x802040) && mainGame->deckManager.deckhost.main.size() < 60) {
-						mainGame->deckManager.deckhost.main.push_back(draging_pointer);
+					if((draging_pointer->second.type & 0x802040) && deckManager.deckhost.extra.size() < 15) {
+						deckManager.deckhost.extra.push_back(draging_pointer);
+					} else if(!(draging_pointer->second.type & 0x802040) && deckManager.deckhost.main.size() < 60) {
+						deckManager.deckhost.main.push_back(draging_pointer);
 					}
 				}
 			}
@@ -514,45 +516,45 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 			if(x >= 314 && x <= 794 && y >= 164 && y <= 435) {
 				int lx = 10, px, py = (y - 164) / 68;
 				hovered_pos = 1;
-				if(mainGame->deckManager.deckhost.main.size() > 40)
-					lx = (mainGame->deckManager.deckhost.main.size() - 41) / 4 + 11;
+				if(deckManager.deckhost.main.size() > 40)
+					lx = (deckManager.deckhost.main.size() - 41) / 4 + 11;
 				if(x >= 750)
 					px = lx - 1;
 				else px = (x - 314) * (lx - 1) / 436;
-				if(py*lx + px >= mainGame->deckManager.deckhost.main.size()) {
+				if(py*lx + px >= deckManager.deckhost.main.size()) {
 					hovered_seq = -1;
 					hovered_code = 0;
 				} else {
 					hovered_seq = py * lx + px;
-					hovered_code = mainGame->deckManager.deckhost.main[hovered_seq]->first;
+					hovered_code = deckManager.deckhost.main[hovered_seq]->first;
 				}
 			} else if(x >= 314 && x <= 794 && y >= 466 && y <= 530) {
-				int lx = mainGame->deckManager.deckhost.extra.size();
+				int lx = deckManager.deckhost.extra.size();
 				hovered_pos = 2;
 				if(lx < 10)
 					lx = 10;
 				if(x >= 750)
 					hovered_seq = lx - 1;
 				else hovered_seq = (x - 314) * (lx - 1) / 436;
-				if(hovered_seq >= mainGame->deckManager.deckhost.extra.size()) {
+				if(hovered_seq >= deckManager.deckhost.extra.size()) {
 					hovered_seq = -1;
 					hovered_code = 0;
 				} else {
-					hovered_code = mainGame->deckManager.deckhost.extra[hovered_seq]->first;
+					hovered_code = deckManager.deckhost.extra[hovered_seq]->first;
 				}
 			} else if (x >= 314 && x <= 794 && y >= 564 && y <= 628) {
-				int lx = mainGame->deckManager.deckhost.side.size();
+				int lx = deckManager.deckhost.side.size();
 				hovered_pos = 3;
 				if(lx < 10)
 					lx = 10;
 				if(x >= 750)
 					hovered_seq = lx - 1;
 				else hovered_seq = (x - 314) * (lx - 1) / 436;
-				if(hovered_seq >= mainGame->deckManager.deckhost.side.size()) {
+				if(hovered_seq >= deckManager.deckhost.side.size()) {
 					hovered_seq = -1;
 					hovered_code = 0;
 				} else {
-					hovered_code = mainGame->deckManager.deckhost.side[hovered_seq]->first;
+					hovered_code = deckManager.deckhost.side[hovered_seq]->first;
 				}
 			} else if(x >= 810 && x <= 995 && y >= 165 && y <= 626) {
 				hovered_pos = 4;
@@ -576,7 +578,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 					mainGame->ShowCardInfo(hovered_code);
 				}
 				if(pre_code)
-					mainGame->imageManager.RemoveTexture(pre_code);
+					imageManager.RemoveTexture(pre_code);
 			}
 			break;
 		}
@@ -618,9 +620,9 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 void DeckBuilder::FilterCards() {
 	results.clear();
 	const wchar_t* pstr = mainGame->ebCardName->getText();
-	int trycode = DataManager::GetVal(pstr);
-	if(mainGame->dataManager.GetData(trycode, 0)) {
-		auto ptr = mainGame->dataManager.GetCodePointer(trycode);
+	int trycode = BufferIO::GetVal(pstr);
+	if(dataManager.GetData(trycode, 0)) {
+		auto ptr = dataManager.GetCodePointer(trycode);
 		results.push_back(ptr);
 		mainGame->scrFilter->setVisible(false);
 		mainGame->scrFilter->setPos(0);
@@ -629,8 +631,8 @@ void DeckBuilder::FilterCards() {
 	}
 	if(pstr[0] == 0)
 		pstr = 0;
-	auto strpointer = mainGame->dataManager._strings.begin();
-	for(code_pointer ptr = mainGame->dataManager._datas.begin(); ptr != mainGame->dataManager._datas.end(); ++ptr, ++strpointer) {
+	auto strpointer = dataManager._strings.begin();
+	for(code_pointer ptr = dataManager._datas.begin(); ptr != dataManager._datas.end(); ++ptr, ++strpointer) {
 		CardDataC& data = ptr->second;
 		CardString& text = strpointer->second;
 		if(data.type & TYPE_TOKEN)
@@ -714,10 +716,10 @@ void DeckBuilder::FilterCards() {
 void DeckBuilder::FilterCardsFromResult() {
 	int offset = 0;
 	const wchar_t* pstr = mainGame->ebCardName->getText();
-	int trycode = DataManager::GetVal(pstr);
-	if(mainGame->dataManager.GetData(trycode, 0)) {
+	int trycode = BufferIO::GetVal(pstr);
+	if(dataManager.GetData(trycode, 0)) {
 		results.clear();
-		auto ptr = mainGame->dataManager.GetCodePointer(trycode);
+		auto ptr = dataManager.GetCodePointer(trycode);
 		results.push_back(ptr);
 		mainGame->scrFilter->setVisible(false);
 		mainGame->scrFilter->setPos(0);
@@ -781,7 +783,7 @@ void DeckBuilder::FilterCardsFromResult() {
 		if(filter_effect && !(data.category & filter_effect))
 			continue;
 		if(pstr) {
-			CardString& text = mainGame->dataManager._strings[data.code];
+			CardString& text = dataManager._strings[data.code];
 			if(wcsstr(text.name, pstr) == 0 && wcsstr(text.text, pstr) == 0)
 				continue;
 		}

gframe/deck_manager.cpp

@@ -5,6 +5,8 @@
 
 namespace ygo {
 
+DeckManager deckManager;
+
 void DeckManager::LoadLFList() {
 	LFList* cur;
 	FILE* fp = fopen("lflist.conf", "r");
@@ -21,7 +23,7 @@ void DeckManager::LoadLFList() {
 				continue;
 			int p = 0, sa = 0, code, count;
 			if(linebuf[0] == '!') {
-				sa = DataManager::DecodeUTF8((const char*)(&linebuf[1]), strBuffer);
+				sa = BufferIO::DecodeUTF8((const char*)(&linebuf[1]), strBuffer);
 				while(strBuffer[sa - 1] == L'\r' || strBuffer[sa - 1] == L'\n' ) sa--;
 				LFList newlist;
 				_lfList.push_back(newlist);
@@ -62,7 +64,7 @@ bool DeckManager::CheckLFList(Deck& deck, int lfindex) {
 	if(deck.main.size() < 40 || deck.main.size() > 60 || deck.extra.size() > 15 || deck.side.size() > 15)
 		return false;
 	for(int i = 0; i < deck.main.size(); ++i) {
-		code_pointer cit = mainGame->dataManager.GetCodePointer(deck.main[i]->first);
+		code_pointer cit = dataManager.GetCodePointer(deck.main[i]->first);
 		int code = cit->second.alias ? cit->second.alias : cit->first;
 		ccount[code]++;
 		dc = ccount[code];
@@ -71,7 +73,7 @@ bool DeckManager::CheckLFList(Deck& deck, int lfindex) {
 			return false;
 	}
 	for(int i = 0; i < deck.extra.size(); ++i) {
-		code_pointer cit = mainGame->dataManager.GetCodePointer(deck.extra[i]->first);
+		code_pointer cit = dataManager.GetCodePointer(deck.extra[i]->first);
 		int code = cit->second.alias ? cit->second.alias : cit->first;
 		ccount[code]++;
 		dc = ccount[code];
@@ -80,7 +82,7 @@ bool DeckManager::CheckLFList(Deck& deck, int lfindex) {
 			return false;
 	}
 	for(int i = 0; i < deck.side.size(); ++i) {
-		code_pointer cit = mainGame->dataManager.GetCodePointer(deck.side[i]->first);
+		code_pointer cit = dataManager.GetCodePointer(deck.side[i]->first);
 		int code = cit->second.alias ? cit->second.alias : cit->first;
 		ccount[code]++;
 		dc = ccount[code];
@@ -98,24 +100,24 @@ void DeckManager::LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec) {
 	CardData cd;
 	for(int i = 0; i < mainc; ++i) {
 		code = dbuf[i];
-		if(!mainGame->dataManager.GetData(code, &cd))
+		if(!dataManager.GetData(code, &cd))
 			continue;
 		if(cd.type & TYPE_TOKEN)
 			continue;
 		else if(cd.type & 0x802040 && deck.extra.size() < 15) {
-			deck.extra.push_back(mainGame->dataManager.GetCodePointer(code));
+			deck.extra.push_back(dataManager.GetCodePointer(code));
 		} else if(deck.main.size() < 60) {
-			deck.main.push_back(mainGame->dataManager.GetCodePointer(code));
+			deck.main.push_back(dataManager.GetCodePointer(code));
 		}
 	}
 	for(int i = 0; i < sidec; ++i) {
 		code = dbuf[mainc + i];
-		if(!mainGame->dataManager.GetData(code, &cd))
+		if(!dataManager.GetData(code, &cd))
 			continue;
 		if(cd.type & TYPE_TOKEN)
 			continue;
 		if(deck.side.size() < 15)
-			deck.side.push_back(mainGame->dataManager.GetCodePointer(code));
+			deck.side.push_back(dataManager.GetCodePointer(code));
 	}
 }
 

gframe/deck_manager.h

@@ -32,6 +32,8 @@ public:
 	void SaveDeck(Deck& deck, const wchar_t* name);
 };
 
+extern DeckManager deckManager;
+
 }
 
 #endif //DECKMANAGER_H

gframe/drawing.cpp

 #include "game.h"
+#include "materials.h"
+#include "image_manager.h"
+#include "deck_manager.h"
 #include "../ocgcore/field.h"
 
 namespace ygo {

gframe/duelclient.cpp

@@ -4,15 +4,14 @@
 namespace ygo {
 
 unsigned DuelClient::connect_state = 0;
-int DuelClient::responseI;
-unsigned char DuelClient::responseB[64];
+unsigned char DuelClient::response_buf[64];
 bool DuelClient::is_responseB;
 unsigned char DuelClient::response_len;
 event_base* DuelClient::client_base = 0;
 bufferevent* DuelClient::client_bev = 0;
 char DuelClient::duel_client_read[0x2000];
 char DuelClient::duel_client_write[0x2000];
-bool DuelClient::is_host = false;
+bool DuelClient::is_closing = false;
 
 bool DuelClient::StartClient(unsigned int ip, unsigned short port) {
 	if(connect_state)
@@ -35,14 +34,17 @@ bool DuelClient::StartClient(unsigned int ip, unsigned short port) {
 	Thread::NewThread(ClientThread, 0);
 	return true;
 }
-void DuelClient::StopClient() {
+void DuelClient::StopClient(bool is_exiting) {
 	if(connect_state != 2)
 		return;
+	is_closing = is_exiting;
+	if(!is_closing) {
 		irr::SEvent sevt;
 		sevt.EventType = irr::EET_USER_EVENT;
 		sevt.UserEvent.UserData1 = UEVENT_EXIT;
 		sevt.UserEvent.UserData2 = 1;
 		mainGame->device->postEventFromUser(sevt);
+	}
 	event_base_loopexit(client_base, NULL);
 }
 void DuelClient::ClientRead(bufferevent* bev, void* ctx) {
@@ -57,7 +59,7 @@ void DuelClient::ClientRead(bufferevent* bev, void* ctx) {
 			return;
 		evbuffer_remove(input, duel_client_read, packet_len + 2);
 		if(packet_len)
-			HandleSTOCPacket(&duel_client_read[2], packet_len);
+			HandleSTOCPacketLan(&duel_client_read[2], packet_len);
 		len -= packet_len + 2;
 	}
 }
@@ -65,17 +67,12 @@ void DuelClient::ClientEvent(bufferevent *bev, short events, void *ptr) {
 	if (events & BEV_EVENT_CONNECTED) {
 		mainGame->HideElement(mainGame->wCreateHost);
 		mainGame->WaitFrameSignal(10);
+		CTOS_PlayerInfo cspi;
+		BufferIO::CopyWStr(mainGame->ebNickName->getText(), cspi.name, 20);
+		SendPacketToServer(CTOS_PLAYER_INFO, cspi);
 		CTOS_CreateGame cscg;
-		const wchar_t* phstr = mainGame->ebServerName->getText();
-		int i = 0;
-		while(i < 19 && phstr[i])
-			cscg.name[i] = phstr[i++];
-		cscg.name[i] = 0;
-		phstr = mainGame->ebServerPass->getText();
-		i = 0;
-		while(i < 19 && phstr[i])
-			cscg.pass[i] = phstr[i++];
-		cscg.pass[i] = 0;
+		BufferIO::CopyWStr(mainGame->ebServerName->getText(), cscg.name, 20);
+		BufferIO::CopyWStr(mainGame->ebServerPass->getText(), cscg.pass, 20);
 		cscg.info.rule = mainGame->cbRule->getSelected();
 		cscg.info.mode = mainGame->cbMatchMode->getSelected();
 		cscg.info.start_hand = _wtoi(mainGame->ebStartHand->getText());
@@ -85,28 +82,70 @@ void DuelClient::ClientEvent(bufferevent *bev, short events, void *ptr) {
 		cscg.info.no_check_deck = mainGame->chkNoCheckDeck->isChecked();
 		cscg.info.no_shuffle_deck = mainGame->chkNoShuffleDeck->isChecked();
 		SendPacketToServer(CTOS_CREATE_GAME, cscg);
+		bufferevent_enable(bev, EV_READ);
 		connect_state = 2;
 	} else if (events & BEV_EVENT_ERROR) {
+		if(!is_closing) {
+			if(connect_state == 1) {
 				mainGame->env->addMessageBox(L"", L"无法连接到主机。");
 				mainGame->btnCreateHost->setEnabled(true);
 				mainGame->btnJoinHost->setEnabled(true);
 				mainGame->btnJoinCancel->setEnabled(true);
+			} else if(connect_state == 2) {
+				mainGame->env->addMessageBox(L"", L"已断开连接。");
+				irr::SEvent sevt;
+				sevt.EventType = irr::EET_USER_EVENT;
+				sevt.UserEvent.UserData1 = UEVENT_EXIT;
+				sevt.UserEvent.UserData2 = 2;
+				mainGame->device->postEventFromUser(sevt);
+			}
+		}
 		event_base_loopexit(client_base, NULL);
 	}
 }
 int DuelClient::ClientThread(void* param) {
 	event_base_dispatch(client_base);
-	event_base_free(client_base);
 	bufferevent_free(client_bev);
+	event_base_free(client_base);
 	client_base = 0;
 	connect_state = 0;
 }
-void DuelClient::HandleSTOCPacket(char* data, unsigned int len) {
+void DuelClient::HandleSTOCPacketLan(char* data, unsigned int len) {
 	char* pdata = data;
+	static unsigned int watching = 0;
+	static unsigned char selftype = 0;
+	static bool is_host = false;
 	unsigned char pktType = BufferIO::ReadUInt8(pdata);
 	switch(pktType) {
+	case STOC_GAME_MSG: {
+		break;
+	}
+	case STOC_DECK_ERROR: {
+		STOC_DeckError* pkt = (STOC_DeckError*)pdata;
+		break;
+	}
 	case STOC_JOIN_GAME: {
 		STOC_JoinGame* pkt = (STOC_JoinGame*)pdata;
+		mainGame->btnHostSingleStart->setEnabled(true);
+		mainGame->btnHostSingleCancel->setEnabled(true);
+		selftype = pkt->type & 0xf;
+		is_host = (pkt->type >> 4) & 0xf;
+		if(is_host) {
+			mainGame->btnHostSingleStart->setVisible(true);
+			mainGame->btnHostSingleKick[0]->setEnabled(true);
+			mainGame->btnHostSingleKick[1]->setEnabled(true);
+		} else {
+			mainGame->btnHostSingleStart->setVisible(false);
+			mainGame->btnHostSingleKick[0]->setEnabled(false);
+			mainGame->btnHostSingleKick[1]->setEnabled(false);
+		}
+		mainGame->chkHostSingleReady[0]->setEnabled(false);
+		mainGame->chkHostSingleReady[0]->setChecked(false);
+		mainGame->chkHostSingleReady[1]->setEnabled(false);
+		mainGame->chkHostSingleReady[1]->setChecked(false);
+		if(selftype < 2)
+			mainGame->chkHostSingleReady[selftype]->setEnabled(true);
+		mainGame->WaitFrameSignal(10);
 		mainGame->ShowElement(mainGame->wHostSingle);
 		mainGame->WaitFrameSignal(10);
 		break;
@@ -124,20 +163,51 @@ void DuelClient::HandleSTOCPacket(char* data, unsigned int len) {
 		mainGame->btnJoinCancel->setEnabled(true);
 		break;
 	}
-	case STOC_HS_PLAYER_ENTER:
+	case STOC_HS_PLAYER_ENTER: {
+		STOC_HS_PlayerEnter* pkt = (STOC_HS_PlayerEnter*)pdata;
+		if(pkt->pos > 1)
 			break;
-	case STOC_HS_PLAYER_CHANGE:
+		wchar_t name[20];
+		BufferIO::CopyWStr(pkt->name, name, 20);
+		mainGame->stHostSingleDuelist[pkt->pos]->setText(name);
 		break;
+	}
+	case STOC_HS_PLAYER_CHANGE: {
+		STOC_HS_PlayerChange* pkt = (STOC_HS_PlayerChange*)pdata;
+		unsigned char pos = (pkt->status >> 4) & 0xf;
+		unsigned char state = pkt->status & 0xf;
+		if(pos > 1)
+			break;
+		if(state == PLAYERCHANGE_READY) {
+			mainGame->chkHostSingleReady[pos]->setChecked(true);
+		} else if(state == PLAYERCHANGE_NOTREADY) {
+			mainGame->chkHostSingleReady[pos]->setChecked(false);
+		} else if(state == PLAYERCHANGE_LEAVE) {
+			mainGame->stHostSingleDuelist[pos]->setText(L"");
+			mainGame->chkHostSingleReady[pos]->setChecked(false);
+		} else if(state == PLAYERCHANGE_OBSERVE) {
+			mainGame->stHostSingleDuelist[pos]->setText(L"");
+			mainGame->chkHostSingleReady[pos]->setChecked(false);
+			watching++;
+			wchar_t watchbuf[32];
+			myswprintf(watchbuf, L"%ls %d", dataManager.GetSysString(1253), watching);
+		}
+		break;
+	}
 	case STOC_HS_WATCH_CHANGE:
+		STOC_HS_WatchChange* pkt = (STOC_HS_WatchChange*)pdata;
+		watching = pkt->watch_count;
+		wchar_t watchbuf[32];
+		myswprintf(watchbuf, L"当前观战人数：%d", watching);
 		break;
 	}
 }
 void DuelClient::SetResponseI(int respI) {
-	responseI = respI;
+	*((int*)response_buf) = respI;
 	is_responseB = false;
 }
 void DuelClient::SetResponseB(unsigned char* respB, unsigned char len) {
-	memcpy(responseB, respB, len);
+	memcpy(response_buf, respB, len);
 	is_responseB = true;
 	response_len = len;
 }

gframe/duelclient.h

@@ -16,38 +16,43 @@ namespace ygo {
 class DuelClient {
 private:
 	static unsigned int connect_state;
-	static int responseI;
-	static unsigned char responseB[64];
+	static unsigned char response_buf[64];
 	static bool is_responseB;
 	static unsigned char response_len;
 	static event_base* client_base;
 	static bufferevent* client_bev;
 	static char duel_client_read[0x2000];
 	static char duel_client_write[0x2000];
-	static bool is_host;
+	static bool is_closing;
 public:
 	static bool StartClient(unsigned int ip, unsigned short port);
-	static void StopClient();
+	static void StopClient(bool is_exiting = false);
 	static void ClientRead(bufferevent* bev, void* ctx);
 	static void ClientEvent(bufferevent *bev, short events, void *ptr);
 	static int ClientThread(void* param);
-	static void HandleSTOCPacket(char* data, unsigned int len);
+	static void HandleSTOCPacketLan(char* data, unsigned int len);
 	static void SetResponseI(int respI);
 	static void SetResponseB(unsigned char* respB, unsigned char len);
+	static void SendPacketToServer(unsigned char proto) {
+		char* p = duel_client_write;
+		BufferIO::WriteInt16(p, 1);
+		BufferIO::WriteInt8(p, proto);
+		bufferevent_write(client_bev, duel_client_write, 3);
+	}
 	template<typename ST>
 	static void SendPacketToServer(unsigned char proto, ST& st) {
 		char* p = duel_client_write;
 		BufferIO::WriteInt16(p, 1 + sizeof(ST));
 		BufferIO::WriteInt8(p, proto);
 		memcpy(p, &st, sizeof(ST));
-		evbuffer_add(bufferevent_get_output(client_bev), duel_client_write, sizeof(ST) + 3);
+		bufferevent_write(client_bev, duel_client_write, sizeof(ST) + 3);
 	}
 	static void SendBufferToServer(unsigned char proto, void* buffer, size_t len) {
 		char* p = duel_client_write;
 		BufferIO::WriteInt16(p, 1 + len);
 		BufferIO::WriteInt8(p, proto);
 		memcpy(p, buffer, len);
-		evbuffer_add(bufferevent_get_output(client_bev), duel_client_write, len + 3);
+		bufferevent_write(client_bev, duel_client_write, len + 3);
 	}
 };
 

gframe/event_handler.cpp

@@ -3,6 +3,8 @@
 #include "network.h"
 #include "game.h"
 #include "duelclient.h"
+#include "data_manager.h"
+#include "image_manager.h"
 #include "../ocgcore/field.h"
 
 namespace ygo {
@@ -66,11 +68,12 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 			case BUTTON_REPLAY_SAVE: {
 				if(mainGame->ebRSName->getText()[0] == 0)
 					break;
-				mainGame->lastReplay.SaveReplay(mainGame->ebRSName->getText());
+				mainGame->actionParam = 1;
 				mainGame->HideElement(mainGame->wReplaySave, true);
 				break;
 			}
 			case BUTTON_REPLAY_CANCEL: {
+				mainGame->actionParam = 0;
 				mainGame->HideElement(mainGame->wReplaySave, true);
 				break;
 			}
@@ -150,7 +153,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 				mainGame->btnOptionn->setVisible(true);
 				if(selected_option == 0)
 					mainGame->btnOptionp->setVisible(false);
-				mainGame->SetStaticText(mainGame->stOptions, 310, mainGame->textFont, (wchar_t*)mainGame->dataManager.GetDesc(select_options[selected_option]));
+				mainGame->SetStaticText(mainGame->stOptions, 310, mainGame->textFont, (wchar_t*)dataManager.GetDesc(select_options[selected_option]));
 				break;
 			}
 			case BUTTON_OPTION_NEXT: {
@@ -158,7 +161,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 				mainGame->btnOptionp->setVisible(true);
 				if(selected_option == select_options.size() - 1)
 					mainGame->btnOptionn->setVisible(false);
-				mainGame->SetStaticText(mainGame->stOptions, 310, mainGame->textFont, (wchar_t*)mainGame->dataManager.GetDesc(select_options[selected_option]));
+				mainGame->SetStaticText(mainGame->stOptions, 310, mainGame->textFont, (wchar_t*)dataManager.GetDesc(select_options[selected_option]));
 				break;
 			}
 			case BUTTON_OPTION_OK: {
@@ -214,7 +217,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 						}
 						mainGame->localAction.Set();
 					} else {
-						mainGame->SetStaticText(mainGame->stOptions, 310, mainGame->textFont, (wchar_t*)mainGame->dataManager.GetDesc(select_options[0]));
+						mainGame->SetStaticText(mainGame->stOptions, 310, mainGame->textFont, (wchar_t*)dataManager.GetDesc(select_options[0]));
 						selected_option = 0;
 						command_card = clicked_card;
 						mainGame->btnOptionp->setVisible(false);
@@ -463,7 +466,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 							}
 							mainGame->HideElement(mainGame->wCardSelect, true);
 						} else {
-							mainGame->SetStaticText(mainGame->stOptions, 310, mainGame->textFont, (wchar_t*)mainGame->dataManager.GetDesc(select_options[0]));
+							mainGame->SetStaticText(mainGame->stOptions, 310, mainGame->textFont, (wchar_t*)dataManager.GetDesc(select_options[0]));
 							selected_option = 0;
 							mainGame->btnOptionp->setVisible(false);
 							mainGame->btnOptionn->setVisible(true);
@@ -635,11 +638,11 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 				int pos = mainGame->scrCardList->getPos() / 10;
 				for(int i = 0; i < 5; ++i) {
 					if(selectable_cards[i + pos]->code)
-						mainGame->btnCardSelect[i]->setImage(mainGame->imageManager.GetTexture(selectable_cards[i + pos]->code));
+						mainGame->btnCardSelect[i]->setImage(imageManager.GetTexture(selectable_cards[i + pos]->code));
 					else
-						mainGame->btnCardSelect[i]->setImage(mainGame->imageManager.tCover);
+						mainGame->btnCardSelect[i]->setImage(imageManager.tCover);
 					mainGame->btnCardSelect[i]->setRelativePosition(rect<s32>(30 + i * 125, 55, 30 + 120 + i * 125, 225));
-					myswprintf(formatBuffer, L"%ls[%d]", mainGame->dataManager.FormatLocation(selectable_cards[i + pos]->location),
+					myswprintf(formatBuffer, L"%ls[%d]", dataManager.FormatLocation(selectable_cards[i + pos]->location),
 					           selectable_cards[i + pos]->sequence + 1);
 					mainGame->stCardPos[i]->setText(formatBuffer);
 					if(selectable_cards[i + pos]->is_selected)
@@ -657,9 +660,9 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 			switch(id) {
 			case EDITBOX_ANCARD: {
 				const wchar_t* pname = mainGame->ebANCard->getText();
-				int trycode = DataManager::GetVal(pname);
+				int trycode = BufferIO::GetVal(pname);
 				CardString cstr;
-				if(mainGame->dataManager.GetString(trycode, &cstr)) {
+				if(dataManager.GetString(trycode, &cstr)) {
 					mainGame->lstANCard->clear();
 					ancard.clear();
 					mainGame->lstANCard->addItem(cstr.name);
@@ -670,7 +673,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 					break;
 				mainGame->lstANCard->clear();
 				ancard.clear();
-				for(auto cit = mainGame->dataManager._strings.begin(); cit != mainGame->dataManager._strings.end(); ++cit) {
+				for(auto cit = dataManager._strings.begin(); cit != dataManager._strings.end(); ++cit) {
 					if(wcsstr(cit->second.name, pname) != 0) {
 						mainGame->lstANCard->addItem(cit->second.name);
 						ancard.push_back(cit->first);
@@ -685,9 +688,9 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 			switch(id) {
 			case EDITBOX_ANCARD: {
 				const wchar_t* pname = mainGame->ebANCard->getText();
-				int trycode = DataManager::GetVal(pname);
+				int trycode = BufferIO::GetVal(pname);
 				CardString cstr;
-				if(mainGame->dataManager.GetString(trycode, &cstr)) {
+				if(dataManager.GetString(trycode, &cstr)) {
 					mainGame->lstANCard->clear();
 					ancard.clear();
 					mainGame->lstANCard->addItem(cstr.name);
@@ -698,7 +701,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 					break;
 				mainGame->lstANCard->clear();
 				ancard.clear();
-				for(auto cit = mainGame->dataManager._strings.begin(); cit != mainGame->dataManager._strings.end(); ++cit) {
+				for(auto cit = dataManager._strings.begin(); cit != dataManager._strings.end(); ++cit) {
 					if(wcsstr(cit->second.name, pname) != 0) {
 						mainGame->lstANCard->addItem(cit->second.name);
 						ancard.push_back(cit->first);
@@ -716,7 +719,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 				if(mcard->code) {
 					mainGame->ShowCardInfo(mcard->code);
 				} else {
-					mainGame->imgCard->setImage(mainGame->imageManager.tCover);
+					mainGame->imgCard->setImage(imageManager.tCover);
 					mainGame->stName->setText(L"");
 					mainGame->stInfo->setText(L"");
 					mainGame->stDataInfo->setText(L"");
@@ -970,7 +973,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 					DuelClient::SetResponseB(respbuf, selectable_cards.size());
 					mainGame->localAction.Set();
 				} else {
-					myswprintf(formatBuffer, L"请移除%d个[%ls]:", select_counter_count, mainGame->dataManager.GetCounterName(select_counter_type));
+					myswprintf(formatBuffer, L"请移除%d个[%ls]:", select_counter_count, dataManager.GetCounterName(select_counter_type));
 					mainGame->stHintMsg->setText(formatBuffer);
 				}
 				break;
@@ -1169,19 +1172,19 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 						if(mcard->location & 0xe) {
 							std::wstring str;
 							if(mcard->type & TYPE_MONSTER) {
-								myswprintf(formatBuffer, L"%ls", mainGame->dataManager.GetName(mcard->code));
+								myswprintf(formatBuffer, L"%ls", dataManager.GetName(mcard->code));
 								str.append(formatBuffer);
 								if(mcard->alias && (mcard->alias < mcard->code - 10 || mcard->alias > mcard->code + 10)) {
-									myswprintf(formatBuffer, L"\n(%ls)", mainGame->dataManager.GetName(mcard->alias));
+									myswprintf(formatBuffer, L"\n(%ls)", dataManager.GetName(mcard->alias));
 									str.append(formatBuffer);
 								}
 								myswprintf(formatBuffer, L"\n%ls/%ls", mcard->atkstring, mcard->defstring);
 								str.append(formatBuffer);
-								myswprintf(formatBuffer, L"\n★%d %ls/%ls", (mcard->level ? mcard->level : mcard->rank), mainGame->dataManager.FormatRace(mcard->race), mainGame->dataManager.FormatAttribute(mcard->attribute));
+								myswprintf(formatBuffer, L"\n★%d %ls/%ls", (mcard->level ? mcard->level : mcard->rank), dataManager.FormatRace(mcard->race), dataManager.FormatAttribute(mcard->attribute));
 								str.append(formatBuffer);
 								if(mcard->counters.size()) {
 									for(std::map<int, int>::iterator ctit = mcard->counters.begin(); ctit != mcard->counters.end(); ++ctit) {
-										myswprintf(formatBuffer, L"\n[%ls]：%d", mainGame->dataManager.GetCounterName(ctit->first), ctit->second);
+										myswprintf(formatBuffer, L"\n[%ls]：%d", dataManager.GetCounterName(ctit->first), ctit->second);
 										str.append(formatBuffer);
 									}
 								}
@@ -1190,15 +1193,15 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 									str.append(formatBuffer);
 								}
 							} else {
-								myswprintf(formatBuffer, L"%ls", mainGame->dataManager.GetName(mcard->code));
+								myswprintf(formatBuffer, L"%ls", dataManager.GetName(mcard->code));
 								str.append(formatBuffer);
 								if(mcard->alias && (mcard->alias < mcard->code - 10 || mcard->alias > mcard->code + 10)) {
-									myswprintf(formatBuffer, L"\n%ls", mainGame->dataManager.GetName(mcard->alias));
+									myswprintf(formatBuffer, L"\n%ls", dataManager.GetName(mcard->alias));
 									str.append(formatBuffer);
 								}
 								if(mcard->counters.size()) {
 									for(std::map<int, int>::iterator ctit = mcard->counters.begin(); ctit != mcard->counters.end(); ++ctit) {
-										myswprintf(formatBuffer, L"\n[%ls]：%d", mainGame->dataManager.GetCounterName(ctit->first), ctit->second);
+										myswprintf(formatBuffer, L"\n[%ls]：%d", dataManager.GetCounterName(ctit->first), ctit->second);
 										str.append(formatBuffer);
 									}
 								}
@@ -1214,7 +1217,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 						}
 					} else {
 						mainGame->stTip->setVisible(false);
-						mainGame->imgCard->setImage(mainGame->imageManager.tCover);
+						mainGame->imgCard->setImage(imageManager.tCover);
 						mainGame->stName->setText(L"");
 						mainGame->stInfo->setText(L"");
 						mainGame->stDataInfo->setText(L"");
@@ -1473,11 +1476,11 @@ void ClientField::ShowMenu(int flag, int x, int y) {
 	} else mainGame->btnSSet->setVisible(false);
 	if(flag & COMMAND_REPOS) {
 		if(clicked_card->position & POS_FACEDOWN)
-			mainGame->btnRepos->setText(mainGame->dataManager.GetSysString(1154));
+			mainGame->btnRepos->setText(dataManager.GetSysString(1154));
 		else if(clicked_card->position & POS_ATTACK)
-			mainGame->btnRepos->setText(mainGame->dataManager.GetSysString(1155));
+			mainGame->btnRepos->setText(dataManager.GetSysString(1155));
 		else
-			mainGame->btnRepos->setText(mainGame->dataManager.GetSysString(1156));
+			mainGame->btnRepos->setText(dataManager.GetSysString(1156));
 		mainGame->btnRepos->setVisible(true);
 		mainGame->btnRepos->setRelativePosition(position2di(1, height));
 		height += 21;

gframe/game.cpp

 #include "config.h"
 #include "game.h"
-#include "network.h"
+#include "image_manager.h"
+#include "data_manager.h"
+#include "deck_manager.h"
+#include "replay.h"
+#include "materials.h"
 
 #ifndef WIN32
 #include <sys/types.h>
@@ -8,14 +12,12 @@
 #include "replay.h"
 #endif
 
+const unsigned short PRO_VERSION = 0x1020;
+
 namespace ygo {
 
 Game* mainGame;
 
-Game::Game() {
-}
-Game::~Game() {
-}
 bool Game::Initialize() {
 	LoadConfig();
 	irr::SIrrlichtCreationParameters params = irr::SIrrlichtCreationParameters();
@@ -43,10 +45,10 @@ bool Game::Initialize() {
 	driver = device->getVideoDriver();
 	driver->setTextureCreationFlag(irr::video::ETCF_CREATE_MIP_MAPS, false);
 	imageManager.SetDevice(device);
-	if(!dataManager.LoadDates("cards.cdb"))
-		return false;
 	if(!imageManager.Initial())
 		return false;
+	if(!dataManager.LoadDates("cards.cdb"))
+		return false;
 	env = device->getGUIEnvironment();
 	numFont = irr::gui::CGUITTFont::createTTFont(env, gameConf.numfont, 16);
 	adFont = irr::gui::CGUITTFont::createTTFont(env, gameConf.numfont, 12);
@@ -57,8 +59,9 @@ bool Game::Initialize() {
 	device->setWindowCaption(L"[---]");
 	device->setResizable(false);
 	//main menu
-	myswprintf(dataManager.strBuffer, L"YGOPro Version:0x%X)", PROTO_VERSION);
-	wMainMenu = env->addWindow(rect<s32>(370, 200, 650, 450), false, dataManager.strBuffer);
+	wchar_t strbuf[256];
+	myswprintf(strbuf, L"YGOPro Version:0x%X)", PRO_VERSION);
+	wMainMenu = env->addWindow(rect<s32>(370, 200, 650, 450), false, strbuf);
 	wMainMenu->getCloseButton()->setVisible(false);
 	btnLanMode = env->addButton(rect<s32>(10, 30, 270, 60), wMainMenu, BUTTON_LAN_MODE, dataManager.GetSysString(1200));
 	btnServerMode = env->addButton(rect<s32>(10, 65, 270, 95), wMainMenu, BUTTON_SERVER_MODE, dataManager.GetSysString(1201));
@@ -110,16 +113,16 @@ bool Game::Initialize() {
 	chkNoCheckDeck = env->addCheckBox(false, rect<s32>(20, 180, 170, 200), wCreateHost, -1, dataManager.GetSysString(1229));
 	chkNoShuffleDeck = env->addCheckBox(false, rect<s32>(180, 180, 360, 200), wCreateHost, -1, dataManager.GetSysString(1230));
 	env->addStaticText(dataManager.GetSysString(1231), rect<s32>(20, 210, 320, 230), false, false, wCreateHost);
-	myswprintf(dataManager.strBuffer, L"%d", 8000);
-	ebStartLP = env->addEditBox(dataManager.strBuffer, rect<s32>(140, 210, 220, 230), true, wCreateHost);
+	myswprintf(strbuf, L"%d", 8000);
+	ebStartLP = env->addEditBox(strbuf, rect<s32>(140, 210, 220, 230), true, wCreateHost);
 	ebStartLP->setTextAlignment(irr::gui::EGUIA_CENTER, irr::gui::EGUIA_CENTER);
 	env->addStaticText(dataManager.GetSysString(1232), rect<s32>(20, 240, 320, 260), false, false, wCreateHost);
-	myswprintf(dataManager.strBuffer, L"%d", 5);
-	ebStartHand = env->addEditBox(dataManager.strBuffer, rect<s32>(140, 240, 220, 260), true, wCreateHost);
+	myswprintf(strbuf, L"%d", 5);
+	ebStartHand = env->addEditBox(strbuf, rect<s32>(140, 240, 220, 260), true, wCreateHost);
 	ebStartHand->setTextAlignment(irr::gui::EGUIA_CENTER, irr::gui::EGUIA_CENTER);
 	env->addStaticText(dataManager.GetSysString(1233), rect<s32>(20, 270, 320, 290), false, false, wCreateHost);
-	myswprintf(dataManager.strBuffer, L"%d", 1);
-	ebDrawCount = env->addEditBox(dataManager.strBuffer, rect<s32>(140, 270, 220, 290), true, wCreateHost);
+	myswprintf(strbuf, L"%d", 1);
+	ebDrawCount = env->addEditBox(strbuf, rect<s32>(140, 270, 220, 290), true, wCreateHost);
 	ebDrawCount->setTextAlignment(irr::gui::EGUIA_CENTER, irr::gui::EGUIA_CENTER);
 	env->addStaticText(dataManager.GetSysString(1234), rect<s32>(10, 360, 220, 380), false, false, wCreateHost);
 	ebServerName = env->addEditBox(gameConf.gamename, rect<s32>(110, 355, 250, 380), true, wCreateHost);
@@ -136,11 +139,11 @@ bool Game::Initialize() {
 	btnHostSingleDuelist = env->addButton(rect<s32>(10, 30, 110, 55), wHostSingle, BUTTON_HS_DUELIST, dataManager.GetSysString(1251));
 	stHostSingleDuelist[0] = env->addStaticText(L"", rect<s32>(40, 65, 240, 85), true, false, wHostSingle);
 	btnHostSingleKick[0] = env->addButton(rect<s32>(10, 65, 30, 85), wHostSingle, BUTTON_HS_KICK, L"X");
-	chkHostSingleReady[0] = env->addCheckBox(false, rect<s32>(250, 65, 270, 85), wHostSingle, -1, L"");
+	chkHostSingleReady[0] = env->addCheckBox(false, rect<s32>(250, 65, 270, 85), wHostSingle, CHECKBOX_HS_READY, L"");
 	chkHostSingleReady[0]->setEnabled(false);
 	stHostSingleDuelist[1] = env->addStaticText(L"", rect<s32>(40, 90, 240, 110), true, false, wHostSingle);
 	btnHostSingleKick[1] = env->addButton(rect<s32>(10, 90, 30, 110), wHostSingle, BUTTON_HS_KICK, L"X");
-	chkHostSingleReady[1] = env->addCheckBox(false, rect<s32>(250, 90, 270, 110), wHostSingle, -1, L"");
+	chkHostSingleReady[1] = env->addCheckBox(false, rect<s32>(250, 90, 270, 110), wHostSingle, CHECKBOX_HS_READY, L"");
 	chkHostSingleReady[1]->setEnabled(false);
 	btnHostSingleOB = env->addButton(rect<s32>(10, 120, 110, 145), wHostSingle, BUTTON_HS_OBSERVER, dataManager.GetSysString(1252));
 	myswprintf(dataManager.strBuffer, L"%ls%d", dataManager.GetSysString(1253), 0);
@@ -148,7 +151,6 @@ bool Game::Initialize() {
 	stHostSingleRule = env->addStaticText(L"", rect<s32>(280, 30, 460, 230), false, true, wHostSingle);
 	env->addStaticText(dataManager.GetSysString(1254), rect<s32>(10, 185, 110, 205), false, false, wHostSingle);
 	cbDeckSelect = env->addComboBox(rect<s32>(120, 180, 270, 205), wHostSingle);
-	btnHostSingleReady = env->addButton(rect<s32>(120, 215, 270, 240), wHostSingle, BUTTON_HS_START, dataManager.GetSysString(1255));
 	btnHostSingleStart = env->addButton(rect<s32>(230, 260, 340, 285), wHostSingle, BUTTON_HS_START, dataManager.GetSysString(1215));
 	btnHostSingleCancel = env->addButton(rect<s32>(350, 260, 460, 285), wHostSingle, BUTTON_HS_CANCEL, dataManager.GetSysString(1212));
 	//img
@@ -413,7 +415,6 @@ bool Game::Initialize() {
 }
 void Game::MainLoop() {
 	wchar_t cap[256];
-	is_closing = false;
 	camera = smgr->addCameraSceneNode(0);
 	irr::core::matrix4 mProjection;
 	BuildProjectionMatrix(mProjection, -0.81f, 0.44f, -0.42f, 0.42f, 1.0f, 100.0f);
@@ -427,7 +428,7 @@ void Game::MainLoop() {
 	irr::ITimer* timer = device->getTimer();
 	timer->setTime(0);
 	int fps = 0;
-	unsigned int last_time = 0, cur_time = 0;
+	unsigned int cur_time = 0;
 	while(device->run()) {
 		linePattern = (linePattern << 1) | (linePattern >> 15);
 		atkframe += 0.1f;
@@ -476,7 +477,7 @@ void Game::MainLoop() {
 #ifdef _WIN32
 			Sleep(20);
 #else
-			usleep(20000000);
+			usleep(20000);
 #endif
 		if(cur_time >= 1000) {
 			myswprintf(cap, L"FPS: %d", fps);
@@ -486,7 +487,6 @@ void Game::MainLoop() {
 			timer->setTime(0);
 		}
 	}
-	is_closing = true;
 	SaveConfig();
 	device->drop();
 }
@@ -546,7 +546,7 @@ void Game::RefreshDeck(irr::gui::IGUIComboBox* cbDeck) {
 			continue;
 		dirp->d_name[len - 4] = 0;
 		wchar_t wname[256];
-		DataManager::DecodeUTF8(dirp->d_name, wname);
+		BufferIO::DecodeUTF8(dirp->d_name, wname);
 		cbDeck->addItem(wname);
 	}
 #endif
@@ -565,7 +565,7 @@ void Game::RefreshReplay() {
 	if(fh == INVALID_HANDLE_VALUE)
 		return;
 	do {
-		if(!(fdataw.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && lastReplay.CheckReplay(fdataw.cFileName)) {
+		if(!(fdataw.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && Replay::CheckReplay(fdataw.cFileName)) {
 			lstReplayList->addItem(fdataw.cFileName);
 		}
 	} while(FindNextFileW(fh, &fdataw));
@@ -580,7 +580,7 @@ void Game::RefreshReplay() {
 		if(len < 5 || strcasecmp(dirp->d_name + len - 4, ".yrp") != 0)
 			continue;
 		wchar_t wname[256];
-		DataManager::DecodeUTF8(dirp->d_name, wname);
+		BufferIO::DecodeUTF8(dirp->d_name, wname);
 		if(lastReplay.CheckReplay(dirp->d_name));
 		lstReplayList->addItem(wname);
 	}
@@ -594,7 +594,6 @@ void Game::LoadConfig() {
 	char strbuf[32];
 	char valbuf[256];
 	wchar_t wstr[256];
-	wchar_t* p;
 	int value;
 	gameConf.antialias = 0;
 	gameConf.serverport = 7911;
@@ -614,35 +613,28 @@ void Game::LoadConfig() {
 		if(!strcmp(strbuf, "antialias")) {
 			gameConf.antialias = atoi(valbuf);
 		} else if(!strcmp(strbuf, "nickname")) {
-			DataManager::DecodeUTF8(valbuf, wstr);
-			p = gameConf.nickname;
-			DataManager::CopyStr(wstr, p, 19);
+			BufferIO::DecodeUTF8(valbuf, wstr);
+			BufferIO::CopyWStr(wstr, gameConf.nickname, 20);
 		} else if(!strcmp(strbuf, "gamename")) {
-			DataManager::DecodeUTF8(valbuf, wstr);
-			p = gameConf.gamename;
-			DataManager::CopyStr(wstr, p, 19);
+			BufferIO::DecodeUTF8(valbuf, wstr);
+			BufferIO::CopyWStr(wstr, gameConf.gamename, 20);
 		} else if(!strcmp(strbuf, "lastdeck")) {
-			DataManager::DecodeUTF8(valbuf, wstr);
-			p = gameConf.lastdeck;
-			DataManager::CopyStr(wstr, p, 63);
+			BufferIO::DecodeUTF8(valbuf, wstr);
+			BufferIO::CopyWStr(wstr, gameConf.lastdeck, 64);
 		} else if(!strcmp(strbuf, "textfont")) {
-			DataManager::DecodeUTF8(valbuf, wstr);
-			p = gameConf.textfont;
-			DataManager::CopyStr(wstr, p, 255);
+			BufferIO::DecodeUTF8(valbuf, wstr);
+			BufferIO::CopyWStr(wstr, gameConf.textfont, 256);
 		} else if(!strcmp(strbuf, "numfont")) {
-			DataManager::DecodeUTF8(valbuf, wstr);
-			p = gameConf.numfont;
-			DataManager::CopyStr(wstr, p, 255);
+			BufferIO::DecodeUTF8(valbuf, wstr);
+			BufferIO::CopyWStr(wstr, gameConf.numfont, 256);
 		} else if(!strcmp(strbuf, "servport")) {
 			gameConf.serverport = atoi(valbuf);
 		} else if(!strcmp(strbuf, "lastip")) {
-			DataManager::DecodeUTF8(valbuf, wstr);
-			p = gameConf.lastip;
-			DataManager::CopyStr(wstr, p, 19);
+			BufferIO::DecodeUTF8(valbuf, wstr);
+			BufferIO::CopyWStr(wstr, gameConf.lastip, 20);
 		} else if(!strcmp(strbuf, "lastport")) {
-			DataManager::DecodeUTF8(valbuf, wstr);
-			p = gameConf.lastport;
-			DataManager::CopyStr(wstr, p, 9);
+			BufferIO::DecodeUTF8(valbuf, wstr);
+			BufferIO::CopyWStr(wstr, gameConf.lastport, 20);
 		}
 	}
 	fclose(fp);
@@ -652,22 +644,21 @@ void Game::SaveConfig() {
 	fprintf(fp, "#config file\n#nickname & gamename should be less than 20 characters\n");
 	char linebuf[256];
 	fprintf(fp, "antialias = %d\n", gameConf.antialias);
-	wchar_t* p = gameConf.nickname;
-	DataManager::CopyStr(ebNickName->getText(), p, 20);
-	DataManager::EncodeUTF8(gameConf.nickname, linebuf);
+	BufferIO::CopyWStr(ebNickName->getText(), gameConf.nickname, 20);
+	BufferIO::EncodeUTF8(gameConf.nickname, linebuf);
 	fprintf(fp, "nickname = %s\n", linebuf);
-	DataManager::EncodeUTF8(gameConf.gamename, linebuf);
+	BufferIO::EncodeUTF8(gameConf.gamename, linebuf);
 	fprintf(fp, "gamename = %s\n", linebuf);
-	DataManager::EncodeUTF8(gameConf.lastdeck, linebuf);
+	BufferIO::EncodeUTF8(gameConf.lastdeck, linebuf);
 	fprintf(fp, "lastdeck = %s\n", linebuf);
-	DataManager::EncodeUTF8(gameConf.textfont, linebuf);
+	BufferIO::EncodeUTF8(gameConf.textfont, linebuf);
 	fprintf(fp, "textfont = %s\n", linebuf);
-	DataManager::EncodeUTF8(gameConf.numfont, linebuf);
+	BufferIO::EncodeUTF8(gameConf.numfont, linebuf);
 	fprintf(fp, "numfont = %s\n", linebuf);
 	fprintf(fp, "serverport = %d\n", gameConf.serverport);
-	DataManager::EncodeUTF8(gameConf.lastip, linebuf);
+	BufferIO::EncodeUTF8(gameConf.lastip, linebuf);
 	fprintf(fp, "lastip = %s\n", linebuf);
-	DataManager::EncodeUTF8(gameConf.lastport, linebuf);
+	BufferIO::EncodeUTF8(gameConf.lastport, linebuf);
 	fprintf(fp, "lastport = %s\n", linebuf);
 	fclose(fp);
 }
@@ -706,5 +697,17 @@ void Game::ShowCardInfo(int code) {
 	}
 	SetStaticText(stText, 270, textFont, (wchar_t*)dataManager.GetText(code));
 }
+void Game::ClearTextures() {
+	matManager.mCard.setTexture(0, 0);
+	mainGame->imgCard->setImage(0);
+	mainGame->btnPSAU->setImage();
+	mainGame->btnPSDU->setImage();
+	mainGame->btnCardSelect[0]->setImage();
+	mainGame->btnCardSelect[1]->setImage();
+	mainGame->btnCardSelect[2]->setImage();
+	mainGame->btnCardSelect[3]->setImage();
+	mainGame->btnCardSelect[4]->setImage();
+	imageManager.ClearTexture();
+}
 
 }

gframe/game.h

@@ -2,15 +2,10 @@
 #define GAME_H
 
 #include "config.h"
-#include "data_manager.h"
-#include "image_manager.h"
-#include "materials.h"
 #include "client_card.h"
 #include "client_field.h"
 #include "deck_con.h"
 #include "menu_handler.h"
-#include "deck_manager.h"
-#include "replay.h"
 #include <string>
 #include "../ocgcore/mtrandom.h"
 #include <unordered_map>
@@ -59,9 +54,6 @@ struct DuelInfo {
 class Game {
 
 public:
-	Game();
-	~Game();
-
 	bool Initialize();
 	void MainLoop();
 	void BuildProjectionMatrix(irr::core::matrix4& mProjection, f32 left, f32 right, f32 bottom, f32 top, f32 znear, f32 zfar);
@@ -84,6 +76,7 @@ public:
 	void LoadConfig();
 	void SaveConfig();
 	void ShowCardInfo(int code);
+	void ClearTextures();
 	
 	int LocalPlayer(int player);
 	const wchar_t* LocalName(int local_player);
@@ -113,21 +106,13 @@ public:
 	char msgBuffer[0x1000];
 	char queryBuffer[0x1000];
 
-	bool is_closing;
-	bool is_refreshing;
 	mtrandom rnd;
 	Mutex gMutex;
 	Mutex gBuffer;
 	Signal frameSignal;
-	Signal localMessage;
-	Signal localResponse;
 	Signal localAction;
 	Config gameConf;
-	DataManager dataManager;
-	ImageManager imageManager;
-	DeckManager deckManager;
-	Materials matManager;
-	Replay lastReplay;
+	DuelInfo dInfo;
 
 	std::vector<int> logParam;
 	unsigned short linePattern;
@@ -135,6 +120,7 @@ public:
 	int signalFrame;
 	bool isFadein;
 	bool signalAction;
+	int actionParam;
 	irr::gui::IGUIElement* guiFading;
 	irr::gui::IGUIElement* guiNext;
 	int fadingFrame;
@@ -163,7 +149,6 @@ public:
 
 	bool is_building;
 
-	DuelInfo dInfo;
 	ClientField dField;
 	DeckBuilder deckBuilder;
 	MenuHandler menuHandler;
@@ -241,7 +226,6 @@ public:
 	irr::gui::IGUIComboBox* cbDeckSelect;
 	irr::gui::IGUIStaticText* stHostSingleRule;
 	irr::gui::IGUIStaticText* stHostSingleOB;
-	irr::gui::IGUIButton* btnHostSingleReady;
 	irr::gui::IGUIButton* btnHostSingleStart;
 	irr::gui::IGUIButton* btnHostSingleCancel;
 	//replay
@@ -384,10 +368,10 @@ extern Game* mainGame;
 #define BUTTON_HOST_CANCEL			115
 #define BUTTON_HS_DUELIST			120
 #define BUTTON_HS_OBSERVER			121
-#define BUTTON_HS_READY				122
-#define BUTTON_HS_START				123
-#define BUTTON_HS_CANCEL			124
-#define BUTTON_HS_KICK				125
+#define BUTTON_HS_START				122
+#define BUTTON_HS_CANCEL			123
+#define BUTTON_HS_KICK				124
+#define CHECKBOX_HS_READY			125
 #define BUTTON_MSG_OK				200
 #define BUTTON_YES					201
 #define BUTTON_NO					202

gframe/image_manager.cpp

 #include "image_manager.h"
-#include "game.h"
 
 namespace ygo {
 	
+ImageManager imageManager;
+
 bool ImageManager::Initial() {
 	tCover = driver->getTexture("textures/cover.jpg");
 	tAct = driver->getTexture("textures/act.png");
@@ -24,15 +25,6 @@ void ImageManager::SetDevice(irr::IrrlichtDevice* dev) {
 	driver = dev->getVideoDriver();
 }
 void ImageManager::ClearTexture() {
-	mainGame->matManager.mCard.setTexture(0, 0);
-	mainGame->imgCard->setImage(0);
-	mainGame->btnPSAU->setImage();
-	mainGame->btnPSDU->setImage();
-	mainGame->btnCardSelect[0]->setImage();
-	mainGame->btnCardSelect[1]->setImage();
-	mainGame->btnCardSelect[2]->setImage();
-	mainGame->btnCardSelect[3]->setImage();
-	mainGame->btnCardSelect[4]->setImage();
 	for(auto tit = tMap.begin(); tit != tMap.end(); ++tit) {
 		if(tit->second)
 			driver->removeTexture(tit->second);

gframe/image_manager.h

@@ -8,7 +8,6 @@
 namespace ygo {
 
 class ImageManager {
-
 public:
 	bool Initial();
 	void SetDevice(irr::IrrlichtDevice* dev);
@@ -36,6 +35,8 @@ public:
 	irr::video::ITexture* tBackGround;
 };
 
+extern ImageManager imageManager;
+
 }
 
 #endif // IMAGEMANAGER_H

gframe/materials.cpp

+#include "materials.h"
+
+namespace ygo {
+
+Materials matManager;
+
+Materials::Materials() {
+	vCardFront[0] = S3DVertex(vector3df(-0.35, -0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vCardFront[1] = S3DVertex(vector3df(0.35, -0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
+	vCardFront[2] = S3DVertex(vector3df(-0.35, 0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
+	vCardFront[3] = S3DVertex(vector3df(0.35, 0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
+	vCardOutline[0] = S3DVertex(vector3df(-0.375, -0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vCardOutline[1] = S3DVertex(vector3df(0.37, -0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
+	vCardOutline[2] = S3DVertex(vector3df(-0.375, 0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
+	vCardOutline[3] = S3DVertex(vector3df(0.37, 0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
+	vCardOutliner[0] = S3DVertex(vector3df(0.37, -0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vCardOutliner[1] = S3DVertex(vector3df(-0.375, -0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
+	vCardOutliner[2] = S3DVertex(vector3df(0.37, 0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
+	vCardOutliner[3] = S3DVertex(vector3df(-0.375, 0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
+	vCardBack[0] = S3DVertex(vector3df(0.35, -0.5, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vCardBack[1] = S3DVertex(vector3df(-0.35, -0.5, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(1, 0));
+	vCardBack[2] = S3DVertex(vector3df(0.35, 0.5, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(0, 1));
+	vCardBack[3] = S3DVertex(vector3df(-0.35, 0.5, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(1, 1));
+	vSymbol[0] = S3DVertex(vector3df(-0.35, -0.35, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vSymbol[1] = S3DVertex(vector3df(0.35, -0.35, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
+	vSymbol[2] = S3DVertex(vector3df(-0.35, 0.35, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
+	vSymbol[3] = S3DVertex(vector3df(0.35, 0.35, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
+	vNegate[0] = S3DVertex(vector3df(-0.25, -0.28, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vNegate[1] = S3DVertex(vector3df(0.25, -0.28, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
+	vNegate[2] = S3DVertex(vector3df(-0.25, 0.22, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
+	vNegate[3] = S3DVertex(vector3df(0.25, 0.22, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
+	vChainNum[0] = S3DVertex(vector3df(-0.35, -0.35, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vChainNum[1] = S3DVertex(vector3df(0.35, -0.35, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0.19375f, 0));
+	vChainNum[2] = S3DVertex(vector3df(-0.35, 0.35, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0.2421875f));
+	vChainNum[3] = S3DVertex(vector3df(0.35, 0.35, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0.19375f, 0.2421875f));
+	vActivate[0] = S3DVertex(vector3df(-0.5, -0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vActivate[1] = S3DVertex(vector3df(0.5, -0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
+	vActivate[2] = S3DVertex(vector3df(-0.5, 0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
+	vActivate[3] = S3DVertex(vector3df(0.5, 0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
+	//background grids
+	for (int i = 0; i < 6; ++i) {
+		vBackLine[i * 6 + 0] = S3DVertex(vector3df(1.2f + i * 1.1f, 0.5f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+		vBackLine[i * 6 + 1] = S3DVertex(vector3df(1.2f + i * 1.1f, -0.5f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+		vBackLine[i * 6 + 2] = S3DVertex(vector3df(1.2f + i * 1.1f, 1.7f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+		vBackLine[i * 6 + 3] = S3DVertex(vector3df(1.2f + i * 1.1f, -1.7f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+		vBackLine[i * 6 + 4] = S3DVertex(vector3df(1.2f + i * 1.1f, 2.9f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+		vBackLine[i * 6 + 5] = S3DVertex(vector3df(1.2f + i * 1.1f, -2.9f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	}
+	for(int i = 0; i < 6; ++i) {
+		iBackLine[i * 4 + 0] = i * 6 + 0;
+		iBackLine[i * 4 + 1] = i * 6 + 4;
+		iBackLine[i * 4 + 2] = i * 6 + 1;
+		iBackLine[i * 4 + 3] = i * 6 + 5;
+		iBackLine[i * 2 + 24] = i;
+		iBackLine[i * 2 + 25] = 30 + i;
+	}
+	//extra0
+	vBackLine[36] = S3DVertex(vector3df(0.2f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[37] = S3DVertex(vector3df(1.0f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[38] = S3DVertex(vector3df(0.2f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[39] = S3DVertex(vector3df(1.0f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	iBackLine[36] = 36;
+	iBackLine[37] = 37;
+	iBackLine[38] = 36;
+	iBackLine[39] = 38;
+	iBackLine[40] = 37;
+	iBackLine[41] = 39;
+	iBackLine[42] = 38;
+	iBackLine[43] = 39;
+	//field0
+	vBackLine[40] = S3DVertex(vector3df(0.2f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[41] = S3DVertex(vector3df(1.0f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[42] = S3DVertex(vector3df(0.2f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[43] = S3DVertex(vector3df(1.0f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	iBackLine[44] = 40;
+	iBackLine[45] = 41;
+	iBackLine[46] = 40;
+	iBackLine[47] = 42;
+	iBackLine[48] = 41;
+	iBackLine[49] = 43;
+	iBackLine[50] = 42;
+	iBackLine[51] = 43;
+	//deck0
+	vBackLine[44] = S3DVertex(vector3df(6.9f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[45] = S3DVertex(vector3df(7.7f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[46] = S3DVertex(vector3df(6.9f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[47] = S3DVertex(vector3df(7.7f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	iBackLine[52] = 44;
+	iBackLine[53] = 45;
+	iBackLine[54] = 44;
+	iBackLine[55] = 46;
+	iBackLine[56] = 45;
+	iBackLine[57] = 47;
+	iBackLine[58] = 46;
+	iBackLine[59] = 47;
+	//grave0
+	vBackLine[48] = S3DVertex(vector3df(6.9f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[49] = S3DVertex(vector3df(7.7f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[50] = S3DVertex(vector3df(6.9f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[51] = S3DVertex(vector3df(7.7f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	iBackLine[60] = 48;
+	iBackLine[61] = 49;
+	iBackLine[62] = 48;
+	iBackLine[63] = 50;
+	iBackLine[64] = 49;
+	iBackLine[65] = 51;
+	iBackLine[66] = 50;
+	iBackLine[67] = 51;
+	//remove0
+	vBackLine[52] = S3DVertex(vector3df(6.9f, -0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[53] = S3DVertex(vector3df(7.7f, -0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[54] = S3DVertex(vector3df(6.9f, 1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[55] = S3DVertex(vector3df(7.7f, 1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	iBackLine[68] = 52;
+	iBackLine[69] = 53;
+	iBackLine[70] = 52;
+	iBackLine[71] = 54;
+	iBackLine[72] = 53;
+	iBackLine[73] = 55;
+	iBackLine[74] = 54;
+	iBackLine[75] = 55;
+	//extra1
+	vBackLine[56] = S3DVertex(vector3df(6.9f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[57] = S3DVertex(vector3df(7.7f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[58] = S3DVertex(vector3df(6.9f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[59] = S3DVertex(vector3df(7.7f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	iBackLine[76] = 56;
+	iBackLine[77] = 57;
+	iBackLine[78] = 56;
+	iBackLine[79] = 58;
+	iBackLine[80] = 57;
+	iBackLine[81] = 59;
+	iBackLine[82] = 58;
+	iBackLine[83] = 59;
+	//field1
+	vBackLine[60] = S3DVertex(vector3df(6.9f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[61] = S3DVertex(vector3df(7.7f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[62] = S3DVertex(vector3df(6.9f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[63] = S3DVertex(vector3df(7.7f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	iBackLine[84] = 60;
+	iBackLine[85] = 61;
+	iBackLine[86] = 60;
+	iBackLine[87] = 62;
+	iBackLine[88] = 61;
+	iBackLine[89] = 63;
+	iBackLine[90] = 62;
+	iBackLine[91] = 63;
+	//deck1
+	vBackLine[64] = S3DVertex(vector3df(0.2f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[65] = S3DVertex(vector3df(1.0f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[66] = S3DVertex(vector3df(0.2f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[67] = S3DVertex(vector3df(1.0f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	iBackLine[92] = 64;
+	iBackLine[93] = 65;
+	iBackLine[94] = 64;
+	iBackLine[95] = 66;
+	iBackLine[96] = 65;
+	iBackLine[97] = 67;
+	iBackLine[98] = 66;
+	iBackLine[99] = 67;
+	//grave1
+	vBackLine[68] = S3DVertex(vector3df(0.2f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[69] = S3DVertex(vector3df(1.0f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[70] = S3DVertex(vector3df(0.2f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[71] = S3DVertex(vector3df(1.0f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	iBackLine[100] = 68;
+	iBackLine[101] = 69;
+	iBackLine[102] = 68;
+	iBackLine[103] = 70;
+	iBackLine[104] = 69;
+	iBackLine[105] = 71;
+	iBackLine[106] = 70;
+	iBackLine[107] = 71;
+	//remove1
+	vBackLine[72] = S3DVertex(vector3df(0.2f, 0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[73] = S3DVertex(vector3df(1.0f, 0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[74] = S3DVertex(vector3df(0.2f, -1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vBackLine[75] = S3DVertex(vector3df(1.0f, -1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	iBackLine[108] = 72;
+	iBackLine[109] = 73;
+	iBackLine[110] = 72;
+	iBackLine[111] = 74;
+	iBackLine[112] = 73;
+	iBackLine[113] = 75;
+	iBackLine[114] = 74;
+	iBackLine[115] = 75;
+
+	iRectangle[0] = 0;
+	iRectangle[1] = 1;
+	iRectangle[2] = 2;
+	iRectangle[3] = 2;
+	iRectangle[4] = 1;
+	iRectangle[5] = 3;
+
+	//deck0
+	vFields[0] = S3DVertex(vector3df(6.9f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[1] = S3DVertex(vector3df(7.7f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[2] = S3DVertex(vector3df(6.9f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[3] = S3DVertex(vector3df(7.7f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//grave0
+	vFields[4] = S3DVertex(vector3df(6.9f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[5] = S3DVertex(vector3df(7.7f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[6] = S3DVertex(vector3df(6.9f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[7] = S3DVertex(vector3df(7.7f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//extra0
+	vFields[8] = S3DVertex(vector3df(0.2f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[9] = S3DVertex(vector3df(1.0f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[10] = S3DVertex(vector3df(0.2f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[11] = S3DVertex(vector3df(1.0f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//remove0
+	vFields[12] = S3DVertex(vector3df(6.9f, -0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[13] = S3DVertex(vector3df(7.7f, -0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[14] = S3DVertex(vector3df(6.9f, 1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[15] = S3DVertex(vector3df(7.7f, 1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//mzone0
+	vFields[16] = S3DVertex(vector3df(1.2f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[17] = S3DVertex(vector3df(2.3f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[18] = S3DVertex(vector3df(1.2f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[19] = S3DVertex(vector3df(2.3f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[20] = S3DVertex(vector3df(2.3f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[21] = S3DVertex(vector3df(3.4f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[22] = S3DVertex(vector3df(2.3f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[23] = S3DVertex(vector3df(3.4f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[24] = S3DVertex(vector3df(3.4f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[25] = S3DVertex(vector3df(4.5f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[26] = S3DVertex(vector3df(3.4f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[27] = S3DVertex(vector3df(4.5f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[28] = S3DVertex(vector3df(4.5f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[29] = S3DVertex(vector3df(5.6f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[30] = S3DVertex(vector3df(4.5f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[31] = S3DVertex(vector3df(5.6f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[32] = S3DVertex(vector3df(5.6f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[33] = S3DVertex(vector3df(6.7f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[34] = S3DVertex(vector3df(5.6f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[35] = S3DVertex(vector3df(6.7f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//szone0
+	vFields[36] = S3DVertex(vector3df(1.2f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[37] = S3DVertex(vector3df(2.3f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[38] = S3DVertex(vector3df(1.2f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[39] = S3DVertex(vector3df(2.3f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[40] = S3DVertex(vector3df(2.3f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[41] = S3DVertex(vector3df(3.4f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[42] = S3DVertex(vector3df(2.3f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[43] = S3DVertex(vector3df(3.4f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[44] = S3DVertex(vector3df(3.4f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[45] = S3DVertex(vector3df(4.5f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[46] = S3DVertex(vector3df(3.4f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[47] = S3DVertex(vector3df(4.5f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[48] = S3DVertex(vector3df(4.5f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[49] = S3DVertex(vector3df(5.6f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[50] = S3DVertex(vector3df(4.5f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[51] = S3DVertex(vector3df(5.6f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[52] = S3DVertex(vector3df(5.6f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[53] = S3DVertex(vector3df(6.7f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[54] = S3DVertex(vector3df(5.6f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[55] = S3DVertex(vector3df(6.7f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[56] = S3DVertex(vector3df(0.2f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[57] = S3DVertex(vector3df(1.0f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[58] = S3DVertex(vector3df(0.2f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[59] = S3DVertex(vector3df(1.0f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//deck1
+	vFields[60] = S3DVertex(vector3df(1.0f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[61] = S3DVertex(vector3df(0.2f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[62] = S3DVertex(vector3df(1.0f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[63] = S3DVertex(vector3df(0.2f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//grave1
+	vFields[64] = S3DVertex(vector3df(1.0f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[65] = S3DVertex(vector3df(0.2f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[66] = S3DVertex(vector3df(1.0f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[67] = S3DVertex(vector3df(0.2f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//extra1
+	vFields[68] = S3DVertex(vector3df(7.7f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[69] = S3DVertex(vector3df(6.9f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[70] = S3DVertex(vector3df(7.7f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[71] = S3DVertex(vector3df(6.9f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//remove1
+	vFields[72] = S3DVertex(vector3df(1.0f, 0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[73] = S3DVertex(vector3df(0.2f, 0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[74] = S3DVertex(vector3df(1.0f, -1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[75] = S3DVertex(vector3df(0.2f, -1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//mzone1
+	vFields[76] = S3DVertex(vector3df(6.7f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[77] = S3DVertex(vector3df(5.6f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[78] = S3DVertex(vector3df(6.7f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[79] = S3DVertex(vector3df(5.6f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[80] = S3DVertex(vector3df(5.6f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[81] = S3DVertex(vector3df(4.5f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[82] = S3DVertex(vector3df(5.6f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[83] = S3DVertex(vector3df(4.5f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[84] = S3DVertex(vector3df(4.5f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[85] = S3DVertex(vector3df(3.4f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[86] = S3DVertex(vector3df(4.5f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[87] = S3DVertex(vector3df(3.4f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[88] = S3DVertex(vector3df(3.4f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[89] = S3DVertex(vector3df(2.3f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[90] = S3DVertex(vector3df(3.4f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[91] = S3DVertex(vector3df(2.3f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[92] = S3DVertex(vector3df(2.3f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[93] = S3DVertex(vector3df(1.2f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[94] = S3DVertex(vector3df(2.3f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[95] = S3DVertex(vector3df(1.2f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	//szone1
+	vFields[96] = S3DVertex(vector3df(6.7f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[97] = S3DVertex(vector3df(5.6f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[98] = S3DVertex(vector3df(6.7f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[99] = S3DVertex(vector3df(5.6f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[100] = S3DVertex(vector3df(5.6f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[101] = S3DVertex(vector3df(4.5f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[102] = S3DVertex(vector3df(5.6f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[103] = S3DVertex(vector3df(4.5f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[104] = S3DVertex(vector3df(4.5f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[105] = S3DVertex(vector3df(3.4f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[106] = S3DVertex(vector3df(4.5f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[107] = S3DVertex(vector3df(3.4f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[108] = S3DVertex(vector3df(3.4f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[109] = S3DVertex(vector3df(2.3f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[110] = S3DVertex(vector3df(3.4f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[111] = S3DVertex(vector3df(2.3f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[112] = S3DVertex(vector3df(2.3f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[113] = S3DVertex(vector3df(1.2f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[114] = S3DVertex(vector3df(2.3f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[115] = S3DVertex(vector3df(1.2f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[116] = S3DVertex(vector3df(7.7f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[117] = S3DVertex(vector3df(6.9f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[118] = S3DVertex(vector3df(7.7f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+	vFields[119] = S3DVertex(vector3df(6.9f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
+
+	for(int i = 0; i < 40; ++i)
+		iArrow[i] = i;
+
+	mCard.AmbientColor = 0xffffffff;
+	mCard.DiffuseColor = 0xff000000;
+	mCard.ColorMaterial = irr::video::ECM_NONE;
+	mCard.MaterialType = irr::video::EMT_ONETEXTURE_BLEND;
+	mCard.MaterialTypeParam = pack_texureBlendFunc(EBF_SRC_ALPHA, EBF_ONE_MINUS_SRC_ALPHA, EMFN_MODULATE_1X, EAS_VERTEX_COLOR);
+	mTexture.AmbientColor = 0xffffffff;
+	mTexture.DiffuseColor = 0xff000000;
+	mTexture.ColorMaterial = irr::video::ECM_NONE;
+	mTexture.MaterialType = irr::video::EMT_TRANSPARENT_ALPHA_CHANNEL;
+	mBackLine.ColorMaterial = irr::video::ECM_NONE;
+	mBackLine.AmbientColor = 0xffffffff;
+	mBackLine.DiffuseColor = 0xc0000000;
+	mBackLine.AntiAliasing = EAAM_FULL_BASIC;
+	mBackLine.MaterialType = irr::video::EMT_ONETEXTURE_BLEND;
+	mBackLine.MaterialTypeParam = pack_texureBlendFunc(EBF_SRC_ALPHA, EBF_ONE_MINUS_SRC_ALPHA, EMFN_MODULATE_1X, EAS_VERTEX_COLOR);
+	mBackLine.Thickness = 2;
+	mSelField.ColorMaterial = irr::video::ECM_NONE;
+	mSelField.AmbientColor = 0xffffffff;
+	mSelField.DiffuseColor = 0xff000000;
+	mSelField.MaterialType = irr::video::EMT_ONETEXTURE_BLEND;
+	mSelField.MaterialTypeParam = pack_texureBlendFunc(EBF_SRC_ALPHA, EBF_ONE_MINUS_SRC_ALPHA, EMFN_MODULATE_1X, EAS_VERTEX_COLOR);
+	mOutLine.Thickness = 2;
+	mTRTexture = mTexture;
+	mTRTexture.AmbientColor = 0xffffff00;
+	mATK.ColorMaterial = irr::video::ECM_AMBIENT;
+	mATK.DiffuseColor = 0x80000000;
+	mATK.setFlag(EMF_BACK_FACE_CULLING, FALSE);
+	mATK.MaterialType = irr::video::EMT_ONETEXTURE_BLEND;
+	mATK.MaterialTypeParam = pack_texureBlendFunc(EBF_SRC_ALPHA, EBF_ONE_MINUS_SRC_ALPHA, EMFN_MODULATE_1X, EAS_VERTEX_COLOR);
+}
+void Materials::GenArrow(float y) {
+	float ay = 1.0f;
+	for (int i = 0; i < 19; ++i) {
+		vArrow[i * 2] = S3DVertex(vector3df(0.1f, ay * y, -2.0f * (ay * ay - 1.0f)), vector3df(0, ay * y, 1), 0xc000ff00, vector2df(0, 0));
+		vArrow[i * 2 + 1] = S3DVertex(vector3df(-0.1f, ay * y, -2.0f * (ay * ay - 1.0f)), vector3df(0, ay * y, 1), 0xc000ff00, vector2df(0, 0));
+		ay -= 0.1f;
+	}
+	vArrow[36].Pos.X = 0.2f;
+	vArrow[36].Pos.Y = vArrow[34].Pos.Y - 0.01f;
+	vArrow[36].Pos.Z = vArrow[34].Pos.Z - 0.01f;
+	vArrow[37].Pos.X = -0.2f;
+	vArrow[37].Pos.Y = vArrow[35].Pos.Y - 0.01f;
+	vArrow[37].Pos.Z = vArrow[35].Pos.Z - 0.01f;
+	vArrow[38] = S3DVertex(vector3df(0.0f, -1.0f * y, 0.0f), vector3df(0.0f, -1.0f, -1.0f), 0xc0ffffff, vector2df(0, 0));
+	vArrow[39] = vArrow[38];
+}
+
+}

gframe/materials.h

@@ -2,377 +2,11 @@
 
 namespace ygo {
 
-struct Materials {
-	Materials() {
-		vCardFront[0] = S3DVertex(vector3df(-0.35, -0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vCardFront[1] = S3DVertex(vector3df(0.35, -0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
-		vCardFront[2] = S3DVertex(vector3df(-0.35, 0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
-		vCardFront[3] = S3DVertex(vector3df(0.35, 0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
-		vCardOutline[0] = S3DVertex(vector3df(-0.375, -0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vCardOutline[1] = S3DVertex(vector3df(0.37, -0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
-		vCardOutline[2] = S3DVertex(vector3df(-0.375, 0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
-		vCardOutline[3] = S3DVertex(vector3df(0.37, 0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
-		vCardOutliner[0] = S3DVertex(vector3df(0.37, -0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vCardOutliner[1] = S3DVertex(vector3df(-0.375, -0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
-		vCardOutliner[2] = S3DVertex(vector3df(0.37, 0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
-		vCardOutliner[3] = S3DVertex(vector3df(-0.375, 0.54, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
-		vCardBack[0] = S3DVertex(vector3df(0.35, -0.5, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vCardBack[1] = S3DVertex(vector3df(-0.35, -0.5, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(1, 0));
-		vCardBack[2] = S3DVertex(vector3df(0.35, 0.5, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(0, 1));
-		vCardBack[3] = S3DVertex(vector3df(-0.35, 0.5, 0), vector3df(0, 0, -1), SColor(255, 255, 255, 255), vector2df(1, 1));
-		vSymbol[0] = S3DVertex(vector3df(-0.35, -0.35, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vSymbol[1] = S3DVertex(vector3df(0.35, -0.35, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
-		vSymbol[2] = S3DVertex(vector3df(-0.35, 0.35, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
-		vSymbol[3] = S3DVertex(vector3df(0.35, 0.35, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
-		vNegate[0] = S3DVertex(vector3df(-0.25, -0.28, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vNegate[1] = S3DVertex(vector3df(0.25, -0.28, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
-		vNegate[2] = S3DVertex(vector3df(-0.25, 0.22, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
-		vNegate[3] = S3DVertex(vector3df(0.25, 0.22, 0.01), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
-		vChainNum[0] = S3DVertex(vector3df(-0.35, -0.35, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vChainNum[1] = S3DVertex(vector3df(0.35, -0.35, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0.19375f, 0));
-		vChainNum[2] = S3DVertex(vector3df(-0.35, 0.35, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0.2421875f));
-		vChainNum[3] = S3DVertex(vector3df(0.35, 0.35, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0.19375f, 0.2421875f));
-		vActivate[0] = S3DVertex(vector3df(-0.5, -0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vActivate[1] = S3DVertex(vector3df(0.5, -0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 0));
-		vActivate[2] = S3DVertex(vector3df(-0.5, 0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 1));
-		vActivate[3] = S3DVertex(vector3df(0.5, 0.5, 0), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(1, 1));
-		//background grids
-		for (int i = 0; i < 6; ++i) {
-			vBackLine[i * 6 + 0] = S3DVertex(vector3df(1.2f + i * 1.1f, 0.5f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-			vBackLine[i * 6 + 1] = S3DVertex(vector3df(1.2f + i * 1.1f, -0.5f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-			vBackLine[i * 6 + 2] = S3DVertex(vector3df(1.2f + i * 1.1f, 1.7f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-			vBackLine[i * 6 + 3] = S3DVertex(vector3df(1.2f + i * 1.1f, -1.7f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-			vBackLine[i * 6 + 4] = S3DVertex(vector3df(1.2f + i * 1.1f, 2.9f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-			vBackLine[i * 6 + 5] = S3DVertex(vector3df(1.2f + i * 1.1f, -2.9f, -0.01f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		}
-		for(int i = 0; i < 6; ++i) {
-			iBackLine[i * 4 + 0] = i * 6 + 0;
-			iBackLine[i * 4 + 1] = i * 6 + 4;
-			iBackLine[i * 4 + 2] = i * 6 + 1;
-			iBackLine[i * 4 + 3] = i * 6 + 5;
-			iBackLine[i * 2 + 24] = i;
-			iBackLine[i * 2 + 25] = 30 + i;
-		}
-		//extra0
-		vBackLine[36] = S3DVertex(vector3df(0.2f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[37] = S3DVertex(vector3df(1.0f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[38] = S3DVertex(vector3df(0.2f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[39] = S3DVertex(vector3df(1.0f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		iBackLine[36] = 36;
-		iBackLine[37] = 37;
-		iBackLine[38] = 36;
-		iBackLine[39] = 38;
-		iBackLine[40] = 37;
-		iBackLine[41] = 39;
-		iBackLine[42] = 38;
-		iBackLine[43] = 39;
-		//field0
-		vBackLine[40] = S3DVertex(vector3df(0.2f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[41] = S3DVertex(vector3df(1.0f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[42] = S3DVertex(vector3df(0.2f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[43] = S3DVertex(vector3df(1.0f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		iBackLine[44] = 40;
-		iBackLine[45] = 41;
-		iBackLine[46] = 40;
-		iBackLine[47] = 42;
-		iBackLine[48] = 41;
-		iBackLine[49] = 43;
-		iBackLine[50] = 42;
-		iBackLine[51] = 43;
-		//deck0
-		vBackLine[44] = S3DVertex(vector3df(6.9f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[45] = S3DVertex(vector3df(7.7f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[46] = S3DVertex(vector3df(6.9f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[47] = S3DVertex(vector3df(7.7f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		iBackLine[52] = 44;
-		iBackLine[53] = 45;
-		iBackLine[54] = 44;
-		iBackLine[55] = 46;
-		iBackLine[56] = 45;
-		iBackLine[57] = 47;
-		iBackLine[58] = 46;
-		iBackLine[59] = 47;
-		//grave0
-		vBackLine[48] = S3DVertex(vector3df(6.9f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[49] = S3DVertex(vector3df(7.7f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[50] = S3DVertex(vector3df(6.9f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[51] = S3DVertex(vector3df(7.7f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		iBackLine[60] = 48;
-		iBackLine[61] = 49;
-		iBackLine[62] = 48;
-		iBackLine[63] = 50;
-		iBackLine[64] = 49;
-		iBackLine[65] = 51;
-		iBackLine[66] = 50;
-		iBackLine[67] = 51;
-		//remove0
-		vBackLine[52] = S3DVertex(vector3df(6.9f, -0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[53] = S3DVertex(vector3df(7.7f, -0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[54] = S3DVertex(vector3df(6.9f, 1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[55] = S3DVertex(vector3df(7.7f, 1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		iBackLine[68] = 52;
-		iBackLine[69] = 53;
-		iBackLine[70] = 52;
-		iBackLine[71] = 54;
-		iBackLine[72] = 53;
-		iBackLine[73] = 55;
-		iBackLine[74] = 54;
-		iBackLine[75] = 55;
-		//extra1
-		vBackLine[56] = S3DVertex(vector3df(6.9f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[57] = S3DVertex(vector3df(7.7f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[58] = S3DVertex(vector3df(6.9f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[59] = S3DVertex(vector3df(7.7f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		iBackLine[76] = 56;
-		iBackLine[77] = 57;
-		iBackLine[78] = 56;
-		iBackLine[79] = 58;
-		iBackLine[80] = 57;
-		iBackLine[81] = 59;
-		iBackLine[82] = 58;
-		iBackLine[83] = 59;
-		//field1
-		vBackLine[60] = S3DVertex(vector3df(6.9f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[61] = S3DVertex(vector3df(7.7f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[62] = S3DVertex(vector3df(6.9f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[63] = S3DVertex(vector3df(7.7f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		iBackLine[84] = 60;
-		iBackLine[85] = 61;
-		iBackLine[86] = 60;
-		iBackLine[87] = 62;
-		iBackLine[88] = 61;
-		iBackLine[89] = 63;
-		iBackLine[90] = 62;
-		iBackLine[91] = 63;
-		//deck1
-		vBackLine[64] = S3DVertex(vector3df(0.2f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[65] = S3DVertex(vector3df(1.0f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[66] = S3DVertex(vector3df(0.2f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[67] = S3DVertex(vector3df(1.0f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		iBackLine[92] = 64;
-		iBackLine[93] = 65;
-		iBackLine[94] = 64;
-		iBackLine[95] = 66;
-		iBackLine[96] = 65;
-		iBackLine[97] = 67;
-		iBackLine[98] = 66;
-		iBackLine[99] = 67;
-		//grave1
-		vBackLine[68] = S3DVertex(vector3df(0.2f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[69] = S3DVertex(vector3df(1.0f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[70] = S3DVertex(vector3df(0.2f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[71] = S3DVertex(vector3df(1.0f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		iBackLine[100] = 68;
-		iBackLine[101] = 69;
-		iBackLine[102] = 68;
-		iBackLine[103] = 70;
-		iBackLine[104] = 69;
-		iBackLine[105] = 71;
-		iBackLine[106] = 70;
-		iBackLine[107] = 71;
-		//remove1
-		vBackLine[72] = S3DVertex(vector3df(0.2f, 0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[73] = S3DVertex(vector3df(1.0f, 0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[74] = S3DVertex(vector3df(0.2f, -1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vBackLine[75] = S3DVertex(vector3df(1.0f, -1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		iBackLine[108] = 72;
-		iBackLine[109] = 73;
-		iBackLine[110] = 72;
-		iBackLine[111] = 74;
-		iBackLine[112] = 73;
-		iBackLine[113] = 75;
-		iBackLine[114] = 74;
-		iBackLine[115] = 75;
+class Materials {
+public:
+	Materials();
+	void GenArrow(float y);
 	
-		iRectangle[0] = 0;
-		iRectangle[1] = 1;
-		iRectangle[2] = 2;
-		iRectangle[3] = 2;
-		iRectangle[4] = 1;
-		iRectangle[5] = 3;
-
-		//deck0
-		vFields[0] = S3DVertex(vector3df(6.9f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[1] = S3DVertex(vector3df(7.7f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[2] = S3DVertex(vector3df(6.9f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[3] = S3DVertex(vector3df(7.7f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//grave0
-		vFields[4] = S3DVertex(vector3df(6.9f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[5] = S3DVertex(vector3df(7.7f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[6] = S3DVertex(vector3df(6.9f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[7] = S3DVertex(vector3df(7.7f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//extra0
-		vFields[8] = S3DVertex(vector3df(0.2f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[9] = S3DVertex(vector3df(1.0f, 2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[10] = S3DVertex(vector3df(0.2f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[11] = S3DVertex(vector3df(1.0f, 3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//remove0
-		vFields[12] = S3DVertex(vector3df(6.9f, -0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[13] = S3DVertex(vector3df(7.7f, -0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[14] = S3DVertex(vector3df(6.9f, 1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[15] = S3DVertex(vector3df(7.7f, 1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//mzone0
-		vFields[16] = S3DVertex(vector3df(1.2f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[17] = S3DVertex(vector3df(2.3f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[18] = S3DVertex(vector3df(1.2f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[19] = S3DVertex(vector3df(2.3f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[20] = S3DVertex(vector3df(2.3f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[21] = S3DVertex(vector3df(3.4f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[22] = S3DVertex(vector3df(2.3f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[23] = S3DVertex(vector3df(3.4f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[24] = S3DVertex(vector3df(3.4f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[25] = S3DVertex(vector3df(4.5f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[26] = S3DVertex(vector3df(3.4f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[27] = S3DVertex(vector3df(4.5f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[28] = S3DVertex(vector3df(4.5f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[29] = S3DVertex(vector3df(5.6f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[30] = S3DVertex(vector3df(4.5f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[31] = S3DVertex(vector3df(5.6f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[32] = S3DVertex(vector3df(5.6f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[33] = S3DVertex(vector3df(6.7f, 0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[34] = S3DVertex(vector3df(5.6f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[35] = S3DVertex(vector3df(6.7f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//szone0
-		vFields[36] = S3DVertex(vector3df(1.2f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[37] = S3DVertex(vector3df(2.3f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[38] = S3DVertex(vector3df(1.2f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[39] = S3DVertex(vector3df(2.3f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[40] = S3DVertex(vector3df(2.3f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[41] = S3DVertex(vector3df(3.4f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[42] = S3DVertex(vector3df(2.3f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[43] = S3DVertex(vector3df(3.4f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[44] = S3DVertex(vector3df(3.4f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[45] = S3DVertex(vector3df(4.5f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[46] = S3DVertex(vector3df(3.4f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[47] = S3DVertex(vector3df(4.5f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[48] = S3DVertex(vector3df(4.5f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[49] = S3DVertex(vector3df(5.6f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[50] = S3DVertex(vector3df(4.5f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[51] = S3DVertex(vector3df(5.6f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[52] = S3DVertex(vector3df(5.6f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[53] = S3DVertex(vector3df(6.7f, 1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[54] = S3DVertex(vector3df(5.6f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[55] = S3DVertex(vector3df(6.7f, 2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[56] = S3DVertex(vector3df(0.2f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[57] = S3DVertex(vector3df(1.0f, 1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[58] = S3DVertex(vector3df(0.2f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[59] = S3DVertex(vector3df(1.0f, 2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//deck1
-		vFields[60] = S3DVertex(vector3df(1.0f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[61] = S3DVertex(vector3df(0.2f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[62] = S3DVertex(vector3df(1.0f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[63] = S3DVertex(vector3df(0.2f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//grave1
-		vFields[64] = S3DVertex(vector3df(1.0f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[65] = S3DVertex(vector3df(0.2f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[66] = S3DVertex(vector3df(1.0f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[67] = S3DVertex(vector3df(0.2f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//extra1
-		vFields[68] = S3DVertex(vector3df(7.7f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[69] = S3DVertex(vector3df(6.9f, -2.4f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[70] = S3DVertex(vector3df(7.7f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[71] = S3DVertex(vector3df(6.9f, -3.6f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//remove1
-		vFields[72] = S3DVertex(vector3df(1.0f, 0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[73] = S3DVertex(vector3df(0.2f, 0.2f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[74] = S3DVertex(vector3df(1.0f, -1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[75] = S3DVertex(vector3df(0.2f, -1.0f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//mzone1
-		vFields[76] = S3DVertex(vector3df(6.7f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[77] = S3DVertex(vector3df(5.6f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[78] = S3DVertex(vector3df(6.7f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[79] = S3DVertex(vector3df(5.6f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[80] = S3DVertex(vector3df(5.6f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[81] = S3DVertex(vector3df(4.5f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[82] = S3DVertex(vector3df(5.6f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[83] = S3DVertex(vector3df(4.5f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[84] = S3DVertex(vector3df(4.5f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[85] = S3DVertex(vector3df(3.4f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[86] = S3DVertex(vector3df(4.5f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[87] = S3DVertex(vector3df(3.4f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[88] = S3DVertex(vector3df(3.4f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[89] = S3DVertex(vector3df(2.3f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[90] = S3DVertex(vector3df(3.4f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[91] = S3DVertex(vector3df(2.3f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[92] = S3DVertex(vector3df(2.3f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[93] = S3DVertex(vector3df(1.2f, -0.5f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[94] = S3DVertex(vector3df(2.3f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[95] = S3DVertex(vector3df(1.2f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		//szone1
-		vFields[96] = S3DVertex(vector3df(6.7f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[97] = S3DVertex(vector3df(5.6f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[98] = S3DVertex(vector3df(6.7f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[99] = S3DVertex(vector3df(5.6f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[100] = S3DVertex(vector3df(5.6f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[101] = S3DVertex(vector3df(4.5f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[102] = S3DVertex(vector3df(5.6f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[103] = S3DVertex(vector3df(4.5f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[104] = S3DVertex(vector3df(4.5f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[105] = S3DVertex(vector3df(3.4f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[106] = S3DVertex(vector3df(4.5f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[107] = S3DVertex(vector3df(3.4f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[108] = S3DVertex(vector3df(3.4f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[109] = S3DVertex(vector3df(2.3f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[110] = S3DVertex(vector3df(3.4f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[111] = S3DVertex(vector3df(2.3f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[112] = S3DVertex(vector3df(2.3f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[113] = S3DVertex(vector3df(1.2f, -1.7f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[114] = S3DVertex(vector3df(2.3f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[115] = S3DVertex(vector3df(1.2f, -2.9f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[116] = S3DVertex(vector3df(7.7f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[117] = S3DVertex(vector3df(6.9f, -1.1f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[118] = S3DVertex(vector3df(7.7f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-		vFields[119] = S3DVertex(vector3df(6.9f, -2.3f, 0.0f), vector3df(0, 0, 1), SColor(255, 255, 255, 255), vector2df(0, 0));
-
-		for(int i = 0; i < 40; ++i)
-			iArrow[i] = i;
-
-		mCard.AmbientColor = 0xffffffff;
-		mCard.DiffuseColor = 0xff000000;
-		mCard.ColorMaterial = irr::video::ECM_NONE;
-		mCard.MaterialType = irr::video::EMT_ONETEXTURE_BLEND;
-		mCard.MaterialTypeParam = pack_texureBlendFunc(EBF_SRC_ALPHA, EBF_ONE_MINUS_SRC_ALPHA, EMFN_MODULATE_1X, EAS_VERTEX_COLOR);
-		mTexture.AmbientColor = 0xffffffff;
-		mTexture.DiffuseColor = 0xff000000;
-		mTexture.ColorMaterial = irr::video::ECM_NONE;
-		mTexture.MaterialType = irr::video::EMT_TRANSPARENT_ALPHA_CHANNEL;
-		mBackLine.ColorMaterial = irr::video::ECM_NONE;
-		mBackLine.AmbientColor = 0xffffffff;
-		mBackLine.DiffuseColor = 0xc0000000;
-		mBackLine.AntiAliasing = EAAM_FULL_BASIC;
-		mBackLine.MaterialType = irr::video::EMT_ONETEXTURE_BLEND;
-		mBackLine.MaterialTypeParam = pack_texureBlendFunc(EBF_SRC_ALPHA, EBF_ONE_MINUS_SRC_ALPHA, EMFN_MODULATE_1X, EAS_VERTEX_COLOR);
-		mBackLine.Thickness = 2;
-		mSelField.ColorMaterial = irr::video::ECM_NONE;
-		mSelField.AmbientColor = 0xffffffff;
-		mSelField.DiffuseColor = 0xff000000;
-		mSelField.MaterialType = irr::video::EMT_ONETEXTURE_BLEND;
-		mSelField.MaterialTypeParam = pack_texureBlendFunc(EBF_SRC_ALPHA, EBF_ONE_MINUS_SRC_ALPHA, EMFN_MODULATE_1X, EAS_VERTEX_COLOR);
-		mOutLine.Thickness = 2;
-		mTRTexture = mTexture;
-		mTRTexture.AmbientColor = 0xffffff00;
-		mATK.ColorMaterial = irr::video::ECM_AMBIENT;
-		mATK.DiffuseColor = 0x80000000;
-		mATK.setFlag(EMF_BACK_FACE_CULLING, FALSE);
-		mATK.MaterialType = irr::video::EMT_ONETEXTURE_BLEND;
-		mATK.MaterialTypeParam = pack_texureBlendFunc(EBF_SRC_ALPHA, EBF_ONE_MINUS_SRC_ALPHA, EMFN_MODULATE_1X, EAS_VERTEX_COLOR);
-	}
-	void GenArrow(float y) {
-		float ay = 1.0f;
-		for (int i = 0; i < 19; ++i) {
-			vArrow[i * 2] = S3DVertex(vector3df(0.1f, ay * y, -2.0f * (ay * ay - 1.0f)), vector3df(0, ay * y, 1), 0xc000ff00, vector2df(0, 0));
-			vArrow[i * 2 + 1] = S3DVertex(vector3df(-0.1f, ay * y, -2.0f * (ay * ay - 1.0f)), vector3df(0, ay * y, 1), 0xc000ff00, vector2df(0, 0));
-			ay -= 0.1f;
-		}
-		vArrow[36].Pos.X = 0.2f;
-		vArrow[36].Pos.Y = vArrow[34].Pos.Y - 0.01f;
-		vArrow[36].Pos.Z = vArrow[34].Pos.Z - 0.01f;
-		vArrow[37].Pos.X = -0.2f;
-		vArrow[37].Pos.Y = vArrow[35].Pos.Y - 0.01f;
-		vArrow[37].Pos.Z = vArrow[35].Pos.Z - 0.01f;
-		vArrow[38] = S3DVertex(vector3df(0.0f, -1.0f * y, 0.0f), vector3df(0.0f, -1.0f, -1.0f), 0xc0ffffff, vector2df(0, 0));
-		vArrow[39] = vArrow[38];
-	}
 	S3DVertex vCardFront[4];
 	S3DVertex vCardOutline[4];
 	S3DVertex vCardOutliner[4];
@@ -397,4 +31,6 @@ struct Materials {
 	irr::video::SMaterial mATK;
 };
 
+extern Materials matManager;
+
 }

gframe/menu_handler.cpp

@@ -2,6 +2,7 @@
 #include "menu_handler.h"
 #include "netserver.h"
 #include "duelclient.h"
+#include "deck_manager.h"
 #include "game.h"
 
 namespace ygo {
@@ -9,7 +10,8 @@ namespace ygo {
 bool MenuHandler::OnEvent(const irr::SEvent& event) {
 	switch(event.EventType) {
 	case irr::EET_GUI_EVENT: {
-		s32 id = event.GUIEvent.Caller->getID();
+		irr::gui::IGUIElement* caller = event.GUIEvent.Caller;
+		s32 id = caller->getID();
 		irr::gui::IGUIEnvironment* env = mainGame->device->getGUIEnvironment();
 		switch(event.GUIEvent.EventType) {
 		case irr::gui::EGET_BUTTON_CLICKED: {
@@ -39,7 +41,7 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 				break;
 			}
 			case BUTTON_HOST_CONFIRM: {
-				if(NetServer::StartServer(mainGame->gameConf.serverport))
+				if(!NetServer::StartServer(mainGame->gameConf.serverport))
 					break;
 				if(!DuelClient::StartClient(0x7f000001, mainGame->gameConf.serverport)) {
 					NetServer::StopServer();
@@ -59,10 +61,12 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 			case BUTTON_HS_OBSERVER: {
 				break;
 			}
-			case BUTTON_HS_READY: {
-				break;
-			}
 			case BUTTON_HS_KICK: {
+				int id = caller - static_cast<IGUIElement*>(mainGame->btnHostSingleKick[0]);
+				if(id == 0)
+					DuelClient::SendPacketToServer(CTOS_HS_KICK1);
+				else
+					DuelClient::SendPacketToServer(CTOS_HS_KICK2);
 				break;
 			}
 			case BUTTON_HS_START: {
@@ -74,14 +78,14 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 			case BUTTON_DECK_EDIT: {
 				mainGame->RefreshDeck(mainGame->cbDBDecks);
 				if(mainGame->cbDBDecks->getSelected() != -1)
-					mainGame->deckManager.LoadDeck(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()));
+					deckManager.LoadDeck(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()));
 				mainGame->HideElement(mainGame->wMainMenu);
 				mainGame->is_building = true;
 				mainGame->wInfos->setVisible(true);
 				mainGame->wCardImg->setVisible(true);
 				mainGame->wDeckEdit->setVisible(true);
 				mainGame->wFilter->setVisible(true);
-				mainGame->deckBuilder.filterList = mainGame->deckManager._lfList[0].content;;
+				mainGame->deckBuilder.filterList = deckManager._lfList[0].content;;
 				mainGame->cbDBLFList->setSelected(0);
 				mainGame->device->setEventReceiver(&mainGame->deckBuilder);
 				mainGame->cbCardType->setSelected(0);
@@ -109,12 +113,12 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 			/*			case BUTTON_LAN_START_SERVER: {
 							if(mainGame->cbDeckSel->getSelected() == -1)
 								break;
-							if(!mainGame->deckManager.LoadDeck(mainGame->cbDeckSel->getItem(mainGame->cbDeckSel->getSelected()))) {
+							if(!deckManager.LoadDeck(mainGame->cbDeckSel->getItem(mainGame->cbDeckSel->getSelected()))) {
 								mainGame->stModeStatus->setText(L"无效卡组");
 								break;
 							}
 							if(!mainGame->chkNoCheckDeck->isChecked()
-							        && !mainGame->deckManager.CheckLFList(mainGame->deckManager.deckhost, mainGame->cbLFlist->getSelected())) {
+							        && !deckManager.CheckLFList(deckManager.deckhost, mainGame->cbLFlist->getSelected())) {
 								mainGame->stModeStatus->setText(L"无效卡组或者卡组不符合禁卡表规范");
 								break;
 							}
@@ -153,7 +157,7 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 						case BUTTON_LAN_CONNECT: {
 							if(mainGame->cbDeckSel->getSelected() == -1)
 								break;
-							if(!mainGame->deckManager.LoadDeck(mainGame->cbDeckSel->getItem(mainGame->cbDeckSel->getSelected()))) {
+							if(!deckManager.LoadDeck(mainGame->cbDeckSel->getItem(mainGame->cbDeckSel->getSelected()))) {
 								mainGame->stModeStatus->setText(L"无效卡组");
 								break;
 							}
@@ -181,9 +185,20 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 						*/
 			}
 		}
+		case irr::gui::EGET_CHECKBOX_CHANGED: {
+			switch(id) {
+			case CHECKBOX_HS_READY: {
+				if(!caller->isEnabled())
+					break;
+				DuelClient::SendPacketToServer(CTOS_HS_READY);
 				break;
 			}
-		return false;
+			}
+			break;
+		}
+		break;
+		}
+		break;
 	}
 	case irr::EET_KEY_INPUT_EVENT: {
 		switch(event.KeyInput.Key) {

gframe/netserver.cpp

@@ -48,7 +48,7 @@ void NetServer::ServerAccept(evconnlistener* listener, evutil_socket_t fd, socka
 	dp.bev = bev;
 	users[bev] = dp;
 	bufferevent_setcb(bev, ServerEchoRead, NULL, ServerEchoEvent, NULL);
-	bufferevent_enable(bev, EV_READ | EV_WRITE);
+	bufferevent_enable(bev, EV_READ);
 }
 void NetServer::ServerAcceptError(evconnlistener* listener, void* ctx) {
 	event_base_loopexit(net_evbase, NULL);
@@ -71,15 +71,18 @@ void NetServer::ServerEchoRead(bufferevent *bev, void *ctx) {
 }
 void NetServer::ServerEchoEvent(bufferevent* bev, short events, void* ctx) {
 	if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) {
+		bufferevent_disable(bev, EV_READ);
 		bufferevent_free(bev);
 		users.erase(bev);
 	}
 }
 int NetServer::ServerThread(void* param) {
 	event_base_dispatch(net_evbase);
-	event_base_free(net_evbase);
-	for(auto bit = users.begin(); bit != users.end(); ++bit)
+	for(auto bit = users.begin(); bit != users.end(); ++bit){
+		bufferevent_disable(bit->first, EV_READ);
 		bufferevent_free(bit->first);
+	}
+	event_base_free(net_evbase);
 	net_evbase = 0;
 	return 0;
 }
@@ -87,6 +90,7 @@ void NetServer::DisconnectPlayer(DuelPlayer* dp) {
 	auto bit = users.find(dp->bev);
 	if(bit != users.end()) {
 		users.erase(bit);
+		bufferevent_disable(dp->bev, EV_READ);
 		bufferevent_free(dp->bev);
 	}
 }
@@ -115,6 +119,10 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len) {
 		} else {
 			duel_mode = new MatchDuel;
 		}
+		if(pkt->info.rule > 3)
+			pkt->info.rule = 0;
+		if(pkt->info.mode > 1)
+			pkt->info.rule = 0;
 		duel_mode->host_info = pkt->info;
 		for(int i = 0; i < 20; ++i) {
 			duel_mode->name[i] = pkt->name[i];
@@ -150,10 +158,14 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len) {
 			STOC_HS_PlayerEnter scpe;
 			for(int i = 0; i < 20; ++i)
 				scpe.name[i] = dp->name[1];
-			if(duel_mode->players[0])
+			if(duel_mode->players[0]) {
+				scpe.pos = 0;
 				NetServer::SendPacketToPlayer(duel_mode->players[0], STOC_HS_PLAYER_ENTER, scpe);
-			if(duel_mode->players[1])
+			}
+			if(duel_mode->players[1]) {
+				scpe.pos = 1;
 				NetServer::SendPacketToPlayer(duel_mode->players[1], STOC_HS_PLAYER_ENTER, scpe);
+			}
 			for(auto pit = duel_mode->observers.begin(); pit != duel_mode->observers.end(); ++pit)
 				NetServer::SendPacketToPlayer(*pit, STOC_HS_PLAYER_ENTER, scpe);
 			if(!duel_mode->players[0]) {
@@ -182,7 +194,8 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len) {
 		if(duel_mode->players[0]) {
 			STOC_HS_PlayerEnter scpe;
 			for(int i = 0; i < 20; ++i)
-				scpe.name[i] = duel_mode->players[0]->name[1];
+				scpe.name[i] = duel_mode->players[0]->name[i];
+			scpe.pos = 0;
 			NetServer::SendPacketToPlayer(dp, STOC_HS_PLAYER_ENTER, scpe);
 			if(duel_mode->ready[0]) {
 				STOC_HS_PlayerChange scpc;
@@ -193,7 +206,8 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len) {
 		if(duel_mode->players[1]) {
 			STOC_HS_PlayerEnter scpe;
 			for(int i = 0; i < 20; ++i)
-				scpe.name[i] = duel_mode->players[1]->name[1];
+				scpe.name[i] = duel_mode->players[1]->name[i];
+			scpe.pos = 1;
 			NetServer::SendPacketToPlayer(dp, STOC_HS_PLAYER_ENTER, scpe);
 			if(duel_mode->ready[1]) {
 				STOC_HS_PlayerChange scpc;
@@ -208,19 +222,57 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len) {
 		}
 		break;
 	}
-	case CTOS_EXIT_GAME:
+	case CTOS_EXIT_GAME: {
 		break;
-	case CTOS_HS_TODUELIST:
+	}
+	case CTOS_HS_TODUELIST: {
+		if(duel_mode->pduel)
 			break;
-	case CTOS_HS_TOOBSERVER:
 		break;
-	case CTOS_HS_READY:
+	}
+	case CTOS_HS_TOOBSERVER: {
+		if(duel_mode->pduel)
+			break;
+		break;
+	}
+	case CTOS_HS_READY: {
+		if(duel_mode->pduel)
 			break;
+		if(dp->type > 1)
+			break;
+		duel_mode->ready[dp->type] = !duel_mode->ready[dp->type] ;
+		STOC_HS_PlayerChange scpc;
+		scpc.status = (dp->type << 4) | duel_mode->ready[dp->type] ? PLAYERCHANGE_READY : PLAYERCHANGE_NOTREADY;
+		if(duel_mode->players[1 - dp->type])
+			NetServer::SendPacketToPlayer(duel_mode->players[1 - dp->type], STOC_HS_PLAYER_CHANGE, scpc);
+		for(auto pit = duel_mode->observers.begin(); pit != duel_mode->observers.end(); ++pit)
+			NetServer::SendPacketToPlayer(*pit, STOC_HS_PLAYER_CHANGE, scpc);
+		break;
+	}
 	case CTOS_HS_KICK1:
+	case CTOS_HS_KICK2: {
+		if(duel_mode->pduel)
+			break;
+		unsigned char pos = pktType - CTOS_HS_KICK1;
+		if(dp != duel_mode->host_player)
 			break;
-	case CTOS_HS_KICK2:
+		if(dp == duel_mode->players[pos])
 			break;
+		STOC_HS_PlayerChange scpc;
+		scpc.status = (pos << 4) | PLAYERCHANGE_LEAVE;
+		if(duel_mode->players[0])
+			NetServer::SendPacketToPlayer(duel_mode->players[0], STOC_HS_PLAYER_CHANGE, scpc);
+		if(duel_mode->players[1])
+			NetServer::SendPacketToPlayer(duel_mode->players[1], STOC_HS_PLAYER_CHANGE, scpc);
+		for(auto pit = duel_mode->observers.begin(); pit != duel_mode->observers.end(); ++pit)
+			NetServer::SendPacketToPlayer(*pit, STOC_HS_PLAYER_CHANGE, scpc);
+		duel_mode->players[pos] = 0;
+		DisconnectPlayer(duel_mode->players[pos]);
+		break;
+	}
 	case CTOS_HS_START: {
+		if(duel_mode->pduel)
+			break;
 		evconnlistener_disable(listener);
 		break;
 	}

gframe/netserver.h

@@ -77,6 +77,13 @@ public:
 	static int ServerThread(void* param);
 	static void DisconnectPlayer(DuelPlayer* dp);
 	static void HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len);
+	static void SendPacketToPlayer(DuelPlayer* dp, unsigned char proto) {
+		char* p = net_server_write;
+		BufferIO::WriteInt16(p, 1);
+		BufferIO::WriteInt8(p, proto);
+		last_sent = 3;
+		bufferevent_write(dp->bev, net_server_write, last_sent);
+	}
 	template<typename ST>
 	static void SendPacketToPlayer(DuelPlayer* dp, unsigned char proto, ST& st) {
 		char* p = net_server_write;
@@ -84,7 +91,7 @@ public:
 		BufferIO::WriteInt8(p, proto);
 		memcpy(p, &st, sizeof(ST));
 		last_sent = sizeof(ST) + 3;
-		evbuffer_add(bufferevent_get_output(dp->bev), net_server_write, last_sent);
+		bufferevent_write(dp->bev, net_server_write, last_sent);
 	}
 	static void SendBufferToPlayer(DuelPlayer* dp, unsigned char proto, void* buffer, size_t len) {
 		char* p = net_server_write;
@@ -92,10 +99,10 @@ public:
 		BufferIO::WriteInt8(p, proto);
 		memcpy(p, buffer, len);
 		last_sent = len + 3;
-		evbuffer_add(bufferevent_get_output(dp->bev), net_server_write, last_sent);
+		bufferevent_write(dp->bev, net_server_write, last_sent);
 	}
 	static void ReSendToPlayer(DuelPlayer* dp) {
-		evbuffer_add(bufferevent_get_output(dp->bev), net_server_write, last_sent);
+		bufferevent_write(dp->bev, net_server_write, last_sent);
 	}
 };
 

gframe/network.cpp

 #include "network.h"
-#include "game.h"
 
 namespace ygo {
 
-const unsigned short PROTO_VERSION = 0x1020;
 /*
 int NetManager::GetLocalAddress() {
 	char hname[256];

gframe/network.h

@@ -46,6 +46,10 @@ struct CTOS_JoinGame {
 	unsigned int gameid;
 	unsigned short pass[20];
 };
+struct STOC_DeckError {
+	unsigned char reason;
+	unsigned int code;
+};
 struct STOC_CreateGame {
 	unsigned int gameid;
 };
@@ -63,16 +67,16 @@ struct STOC_JoinFail {
 };
 struct STOC_HS_PlayerEnter {
 	unsigned short name[20];
+	unsigned char pos;
 };
 struct STOC_HS_PlayerChange {
+	//pos<<4 | state
 	unsigned char status;
 };
 struct STOC_HS_WatchChange {
 	unsigned short watch_count;
 };
 
-extern const unsigned short PROTO_VERSION;
-
 }
 
 #define NETWORK_SERVER_ID	0x7428
@@ -91,10 +95,13 @@ extern const unsigned short PROTO_VERSION;
 #define CTOS_HS_KICK2		0x24
 #define CTOS_HS_START		0x25
 
+#define STOC_GAME_MSG		0x1
+#define STOC_DECK_ERROR		0x2
 #define STOC_CREATE_GAME	0x11
 #define STOC_JOIN_GAME		0x12
 #define STOC_EXIT_GAME		0x13
 #define STOC_JOIN_FAIL		0x14
+#define STOC_GAME_START		0x15
 #define STOC_HS_PLAYER_ENTER	0x20
 #define STOC_HS_PLAYER_CHANGE	0x21
 #define STOC_HS_WATCH_CHANGE	0x22

gframe/replay.cpp

@@ -10,7 +10,7 @@ Replay::Replay() {
 	is_recording = false;
 	is_replaying = false;
 	replay_data = new unsigned char[0x20000];
-	comp_data = new unsigned char[0x1000];
+	comp_data = new unsigned char[0x2000];
 }
 Replay::~Replay() {
 	delete replay_data;
@@ -133,17 +133,18 @@ bool Replay::CheckReplay(const wchar_t* name) {
 	wchar_t fname[64];
 	myswprintf(fname, L"./replay/%ls", name);
 #ifdef WIN32
-	fp = _wfopen(fname, L"rb");
+	FILE* rfp = _wfopen(fname, L"rb");
 #else
 	char fname2[256];
-	DataManager::EncodeUTF8(fname, fname2);
-	fp = fopen(fname2, "rb");
+	BufferIO::EncodeUTF8(fname, fname2);
+	FILE* rfp = fopen(fname2, "rb");
 #endif
-	if(!fp)
+	if(!rfp)
 		return false;
-	fread(&pheader, sizeof(pheader), 1, fp);
-	fclose(fp);
-	return pheader.id == 0x31707279 && pheader.version >= 0x1008;
+	ReplayHeader rheader;
+	fread(&rheader, sizeof(ReplayHeader), 1, rfp);
+	fclose(rfp);
+	return rheader.id == 0x31707279 && rheader.version >= 0x1020;
 }
 bool Replay::ReadNextResponse(unsigned char resp[64]) {
 	char resType = *pdata++;

gframe/replay.h

@@ -32,7 +32,7 @@ public:
 	void EndRecord();
 	void SaveReplay(const wchar_t* name);
 	bool OpenReplay(const wchar_t* name);
-	bool CheckReplay(const wchar_t* name);
+	static bool CheckReplay(const wchar_t* name);
 	bool ReadNextResponse(unsigned char resp[64]);
 	void ReadHeader(ReplayHeader& header);
 	void ReadData(void* data, unsigned int length);

script/c21454943.lua

@@ -61,6 +61,6 @@ function c21454943.operation(e,tp,eg,ep,ev,re,r,rp,chk)
 	e1:SetValue(e:GetLabel())
 	tc:RegisterEffect(e1)
 	local e2=e1:Clone()
-	e1:SetCode(EFFECT_UPDATE_DEFENCE)
+	e2:SetCode(EFFECT_UPDATE_DEFENCE)
 	tc:RegisterEffect(e2)
 end

script/c58120309.lua

@@ -30,11 +30,10 @@ function c58120309.target(e,tp,eg,ep,ev,re,r,rp,chk)
 end
 function c58120309.activate(e,tp,eg,ep,ev,re,r,rp)
 	Duel.NegateEffect(ev)
-	if re:GetHandler():IsRelateToEffect(re) then
-		Duel.Destroy(eg,REASON_EFFECT)
-	end
+	if re:GetHandler():IsRelateToEffect(re) and Duel.Destroy(eg,REASON_EFFECT)~=0 then
 		local sc=Duel.GetFirstMatchingCard(c58120309.sfilter,tp,LOCATION_EXTRA,0,nil,e,tp)
-	if sc~=nil and Duel.GetLocationCount(tp,LOCATION_MZONE)>0 and Duel.SelectYesNo(tp,aux.Stringid(58120309,0)) then
+		if sc and Duel.GetLocationCount(tp,LOCATION_MZONE)>0 and Duel.SelectYesNo(tp,aux.Stringid(58120309,0)) then
 			Duel.SpecialSummon(sc,0,tp,tp,false,false,POS_FACEUP)
 		end
+	end
 end

script/c98358303.lua

@@ -44,8 +44,8 @@ function c98358303.rmop(e,tp,eg,ep,ev,re,r,rp)
 	if tc then
 		Duel.Remove(tc,POS_FACEUP,REASON_EFFECT)
 		if c:IsRelateToEffect(e) then
-			c:RegisterFlagEffect(98358303,RESET_EVENT+0x1fe0000+RESET_PHASE+PHASE_END+RESET_SELF_TURN,0,2)
-			tc:RegisterFlagEffect(98358303,RESET_EVENT+0x1fe0000+RESET_PHASE+PHASE_END+RESET_SELF_TURN,0,2)
+			c:RegisterFlagEffect(98358303,RESET_EVENT+0x1fe0000+RESET_PHASE+PHASE_END,0,2)
+			tc:RegisterFlagEffect(98358303,RESET_EVENT+0x1fe0000+RESET_PHASE+PHASE_END,0,2)
 			e:SetLabelObject(tc)
 		end
 	end
@@ -53,7 +53,7 @@ end
 function c98358303.spcon(e,tp,eg,ep,ev,re,r,rp)
 	local tc=e:GetLabelObject():GetLabelObject()
 	local c=e:GetHandler()
-	return tc and Duel.GetTurnPlayer()==tp and Duel.GetTurnCount()~=tc:GetTurnID()
+	return tc and Duel.GetTurnCount()~=tc:GetTurnID()
 		and c:GetFlagEffect(98358303)~=0 and tc:GetFlagEffect(98358303)~=0
 end
 function c98358303.sptg(e,tp,eg,ep,ev,re,r,rp,chk)

system.conf

 #config file
 #nickname & gamename should be less than 20 characters
 antialias = 2
-nickname = Player1
+nickname = Player1锈蚀水雾
 gamename = Game
 lastdeck = infernity
 textfont = c:/windows/fonts/simsun.ttc