Merge remote-tracking branch 'origin/master' into server

Conflicts:
	ocgcore
	ocgcore/field.cpp
	ocgcore/field.h
	ocgcore/interpreter.cpp
	ocgcore/libdebug.cpp

gframe/duelclient.cpp

@@ -2930,6 +2930,7 @@ int DuelClient::ClientAnalyze(char * msg, unsigned int len) {
 		int player = mainGame->LocalPlayer(BufferIO::ReadInt8(pbuf));
 		size_t mcount = (size_t)BufferIO::ReadInt8(pbuf);
 		size_t ecount = (size_t)BufferIO::ReadInt8(pbuf);
+		size_t pcount = (size_t)BufferIO::ReadInt8(pbuf);
 		size_t hcount = (size_t)BufferIO::ReadInt8(pbuf);
 		int topcode = BufferIO::ReadInt32(pbuf);
 		if(!mainGame->dInfo.isReplay || !mainGame->dInfo.isReplaySkiping) {
@@ -3004,6 +3005,7 @@ int DuelClient::ClientAnalyze(char * msg, unsigned int len) {
 				mainGame->dField.extra[player].push_back(ccard);
 			}
 		}
+		mainGame->dField.extra_p_count[player] = pcount;
 		if(!mainGame->dInfo.isReplay || !mainGame->dInfo.isReplaySkiping)
 			mainGame->gMutex.Unlock();
 		//
@@ -3027,7 +3029,7 @@ int DuelClient::ClientAnalyze(char * msg, unsigned int len) {
 			}
 			for (auto cit = mainGame->dField.extra[player].begin(); cit != mainGame->dField.extra[player].end(); ++cit) {
 				ClientCard* pcard = *cit;
-				pcard->code = 0;
+				pcard->code = BufferIO::ReadInt32(pbuf) & 0x7fffffff;
 				mainGame->dField.GetCardLocation(pcard, &pcard->curPos, &pcard->curRot);
 				if(player == 0) pcard->curPos.Y += 2.0f;
 				else pcard->curPos.Y -= 3.0f;

gframe/event_handler.cpp

@@ -1501,7 +1501,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 								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", dataManager.GetName(mcard->alias));
+									myswprintf(formatBuffer, L"\n(%ls)", dataManager.GetName(mcard->alias));
 									str.append(formatBuffer);
 								}
 								if(mcard->location == LOCATION_SZONE && (mcard->sequence == 6 || mcard->sequence == 7)) {
@@ -1577,7 +1577,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 			break;
 		}
 		case irr::KEY_KEY_R: {
-			if(!event.KeyInput.PressedDown)
+			if(!event.KeyInput.PressedDown && !mainGame->HasFocus(EGUIET_EDIT_BOX))
 				mainGame->textFont->setTransparency(true);
 			break;
 		}
@@ -1588,7 +1588,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 		case irr::KEY_F6:
 		case irr::KEY_F7: {
 			if(!event.KeyInput.PressedDown && !mainGame->dInfo.isReplay && mainGame->dInfo.player_type != 7 && mainGame->dInfo.isStarted
-					&& !mainGame->wCardDisplay->isVisible()) {
+					&& !mainGame->wCardDisplay->isVisible() && !mainGame->HasFocus(EGUIET_EDIT_BOX)) {
 				int loc_id = 0;
 				display_cards.clear();
 				switch(event.KeyInput.Key) {

gframe/game.h

@@ -98,6 +98,11 @@ public:
 	int LocalPlayer(int player);
 	const wchar_t* LocalName(int local_player);
 
+	bool HasFocus(EGUI_ELEMENT_TYPE type) const {
+		irr::gui::IGUIElement* focus = env->getFocus();
+		return focus && focus->hasType(type);
+	}
+
 	Mutex gMutex;
 	Mutex gBuffer;
 	Signal frameSignal;

gframe/replay_mode.cpp

@@ -653,7 +653,7 @@ bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
 		}
 		case MSG_TAG_SWAP: {
 			player = pbuf[0];
-			pbuf += pbuf[3] * 4 + 8;
+			pbuf += pbuf[2] * 4 + pbuf[4] * 4 + 9;
 			DuelClient::ClientAnalyze(offset, pbuf - offset);
 			ReplayRefreshDeck(player);
 			ReplayRefreshExtra(player);

gframe/single_mode.cpp

@@ -598,7 +598,7 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 		}
 		case MSG_TAG_SWAP: {
 			player = pbuf[0];
-			pbuf += pbuf[3] * 4 + 8;
+			pbuf += pbuf[2] * 4 + pbuf[4] * 4 + 9;
 			DuelClient::ClientAnalyze(offset, pbuf - offset);
 			SinglePlayRefreshDeck(player);
 			SinglePlayRefreshExtra(player);

gframe/tag_duel.cpp

@@ -1355,10 +1355,11 @@ int TagDuel::Analyze(char* msgbuffer, unsigned int len) {
 		case MSG_TAG_SWAP: {
 			player = BufferIO::ReadInt8(pbuf);
 			/*int mcount = */BufferIO::ReadInt8(pbuf);
-			/*int ecount = */BufferIO::ReadInt8(pbuf);
+			int ecount = BufferIO::ReadInt8(pbuf);
+			/*int pcount = */BufferIO::ReadInt8(pbuf);
 			int hcount = BufferIO::ReadInt8(pbuf);
 			pbufw = pbuf + 4;
-			pbuf += hcount * 4 + 4;
+			pbuf += hcount * 4 + ecount * 4 + 4;
 			NetServer::SendBufferToPlayer(cur_player[player], STOC_GAME_MSG, offset, pbuf - offset);
 			for (int i = 0; i < hcount; ++i) {
 				if(!(pbufw[3] & 0x80))
@@ -1366,6 +1367,12 @@ int TagDuel::Analyze(char* msgbuffer, unsigned int len) {
 				else
 					pbufw += 4;
 			}
+			for (int i = 0; i < ecount; ++i) {
+				if(!(pbufw[3] & 0x80))
+					BufferIO::WriteInt32(pbufw, 0);
+				else
+					pbufw += 4;
+			}
 			for(int i = 0; i < 4; ++i)
 				if(players[i] != cur_player[player])
 					NetServer::SendBufferToPlayer(players[i], STOC_GAME_MSG, offset, pbuf - offset);

ocgcore/common.h

-/*
- * common.h
- *
- *  Created on: 2009-1-7
- *      Author: Argon.Sun
- */
-
-#ifndef COMMON_H_
-#define COMMON_H_
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4244)
-#endif
-
-typedef unsigned long uptr;
-typedef unsigned long long uint64;
-typedef unsigned int uint32;
-typedef unsigned short uint16;
-typedef unsigned char uint8;
-typedef unsigned char byte;
-typedef long ptr;
-typedef long long int64;
-typedef int int32;
-typedef short int16;
-typedef char int8;
-typedef int BOOL;
-
-#define MATCH_ALL(x,y) (((x)&(y))==(y))
-#define MATCH_ANY(x,y) ((x)&(y))
-#define ADD_BIT(x,y) ((x)|=(y))
-#define REMOVE_BIT(x,y) ((x)&=~(y))
-
-#define OPERATION_SUCCESS 1
-#define OPERATION_FAIL 0
-#define OPERATION_CANCELED -1
-#define TRUE 1
-#define FALSE 0
-#ifndef NULL
-#define NULL 0
-#endif
-struct card_sort {
-	bool operator()(void* const & c1, void* const & c2) const;
-};
-
-#endif /* COMMON_H_ */

ocgcore/duel.cpp

-/*
- * duel.cpp
- *
- *  Created on: 2010-5-2
- *      Author: Argon
- */
-
-#include "duel.h"
-#include "interpreter.h"
-#include "field.h"
-#include "card.h"
-#include "effect.h"
-#include "group.h"
-#include "ocgapi.h"
-#include <memory.h>
-
-duel::duel() {
-	lua = new interpreter(this);
-	game_field = new field(this);
-	game_field->temp_card = new_card(0);
-	clear_buffer();
-}
-duel::~duel() {
-	for(std::set<card*>::iterator cit = cards.begin(); cit != cards.end(); ++cit)
-		delete *cit;
-	for(std::set<group*>::iterator git = groups.begin(); git != groups.end(); ++git)
-		delete *git;
-	for(std::set<effect*>::iterator eit = effects.begin(); eit != effects.end(); ++eit)
-		delete *eit;
-	delete lua;
-	delete game_field;
-}
-void duel::clear() {
-	for(std::set<card*>::iterator cit = cards.begin(); cit != cards.end(); ++cit)
-		delete *cit;
-	for(std::set<group*>::iterator git = groups.begin(); git != groups.end(); ++git)
-		delete *git;
-	for(std::set<effect*>::iterator eit = effects.begin(); eit != effects.end(); ++eit)
-		delete *eit;
-	delete game_field;
-	cards.clear();
-	groups.clear();
-	effects.clear();
-	game_field = new field(this);
-	game_field->temp_card = new_card(0);
-}
-card* duel::new_card(uint32 code) {
-	card* pcard = new card(this);
-	cards.insert(pcard);
-	if(code)
-		::read_card(code, &(pcard->data));
-	pcard->data.code = code;
-	lua->register_card(pcard);
-	return pcard;
-}
-group* duel::register_group(group* pgroup) {
-	groups.insert(pgroup);
-	if(lua->call_depth)
-		sgroups.insert(pgroup);
-	lua->register_group(pgroup);
-	return pgroup;
-}
-group* duel::new_group() {
-	group* pgroup = new group(this);
-	return register_group(pgroup);
-}
-group* duel::new_group(card* pcard) {
-	group* pgroup = new group(this, pcard);
-	return register_group(pgroup);
-}
-group* duel::new_group(const card_set& cset) {
-	group* pgroup = new group(this, cset);
-	return register_group(pgroup);
-}
-effect* duel::new_effect() {
-	effect* peffect = new effect(this);
-	effects.insert(peffect);
-	lua->register_effect(peffect);
-	return peffect;
-}
-void duel::delete_card(card* pcard) {
-	cards.erase(pcard);
-	delete pcard;
-}
-void duel::delete_group(group* pgroup) {
-	lua->unregister_group(pgroup);
-	groups.erase(pgroup);
-	sgroups.erase(pgroup);
-	delete pgroup;
-}
-void duel::delete_effect(effect* peffect) {
-	lua->unregister_effect(peffect);
-	effects.erase(peffect);
-	delete peffect;
-}
-int32 duel::read_buffer(byte* buf) {
-	memcpy(buf, buffer, bufferlen);
-	return bufferlen;
-}
-void duel::release_script_group() {
-	std::set<group*>::iterator sit;
-	for(sit = sgroups.begin(); sit != sgroups.end(); ++sit) {
-		group* pgroup = *sit;
-		if(pgroup->is_readonly == 0) {
-			lua->unregister_group(pgroup);
-			groups.erase(pgroup);
-			delete pgroup;
-		}
-	}
-	sgroups.clear();
-}
-void duel::restore_assumes() {
-	std::set<card*>::iterator sit;
-	for(sit = assumes.begin(); sit != assumes.end(); ++sit)
-		(*sit)->assume_type = 0;
-	assumes.clear();
-}
-void duel::write_buffer32(uint32 value) {
-	*((uint32*)bufferp) = value;
-	bufferp += 4;
-	bufferlen += 4;
-}
-void duel::write_buffer16(uint16 value) {
-	*((uint16*)bufferp) = value;
-	bufferp += 2;
-	bufferlen += 2;
-}
-void duel::write_buffer8(uint8 value) {
-	*((uint8*)bufferp) = value;
-	bufferp += 1;
-	bufferlen += 1;
-}
-void duel::clear_buffer() {
-	bufferlen = 0;
-	bufferp = buffer;
-}
-void duel::set_responsei(uint32 resp) {
-	game_field->returns.ivalue[0] = resp;
-}
-void duel::set_responseb(byte* resp) {
-	memcpy(game_field->returns.bvalue, resp, 64);
-}
-int32 duel::get_next_integer(int32 l, int32 h) {
-	return (int32) (random.real() * (h - l + 1)) + l;
-}

ocgcore/duel.h

-/*
- * duel.h
- *
- *  Created on: 2010-4-8
- *      Author: Argon
- */
-
-#ifndef DUEL_H_
-#define DUEL_H_
-
-#include "common.h"
-#include "mtrandom.h"
-#include <set>
-
-class card;
-class group;
-class effect;
-class field;
-class interpreter;
-
-struct duel_arg {
-	int16 start_lp;
-	int8 start_hand;
-	int8 draw_count;
-};
-class duel {
-public:
-	typedef std::set<card*, card_sort> card_set;
-	char strbuffer[256];
-	byte buffer[0x1000];
-	uint32 bufferlen;
-	byte* bufferp;
-	interpreter* lua;
-	field* game_field;
-	mtrandom random;
-	std::set<card*> cards;
-	std::set<card*> assumes;
-	std::set<group*> groups;
-	std::set<group*> sgroups;
-	std::set<effect*> effects;
-	std::set<effect*> uncopy;
-	
-	duel();
-	~duel();
-	void clear();
-	
-	card* new_card(uint32 code);
-	group* new_group();
-	group* new_group(card* pcard);
-	group* new_group(const card_set& cset);
-	effect* new_effect();
-	void delete_card(card* pcard);
-	void delete_group(group* pgroup);
-	void delete_effect(effect* peffect);
-	void release_script_group();
-	void restore_assumes();
-	int32 read_buffer(byte* buf);
-	void write_buffer32(uint32 value);
-	void write_buffer16(uint16 value);
-	void write_buffer8(uint8 value);
-	void clear_buffer();
-	void set_responsei(uint32 resp);
-	void set_responseb(byte* resp);
-	int32 get_next_integer(int32 l, int32 h);
-private:
-	group* register_group(group* pgroup);
-};
-
-//Player
-#define PLAYER_NONE		2	//
-#define PLAYER_ALL		3	//
-//Phase
-#define PHASE_DRAW			0x01	//
-#define PHASE_STANDBY		0x02	//
-#define PHASE_MAIN1			0x04	//
-#define PHASE_BATTLE		0x08	//
-#define PHASE_DAMAGE		0x10	//
-#define PHASE_DAMAGE_CAL	0x20	//
-#define PHASE_MAIN2			0x40	//
-#define PHASE_END			0x80	//
-//Options
-#define DUEL_TEST_MODE			0x01
-#define DUEL_ATTACK_FIRST_TURN	0x02
-#define DUEL_NO_CHAIN_HINT		0x04
-#define DUEL_OBSOLETE_RULING	0x08
-#define DUEL_PSEUDO_SHUFFLE		0x10
-#define DUEL_TAG_MODE			0x20
-#define DUEL_SIMPLE_AI			0x40
-#endif /* DUEL_H_ */

ocgcore/effectset.h

-/*
- * effectset.h
- *
- *  Created on: 2011-10-8
- *      Author: Argon
- */
-
-#ifndef EFFECTSET_H_
-#define EFFECTSET_H_
-
-#include <stdlib.h>
-#include <array>
-#include <vector>
-#include <algorithm>
-
-class effect;
-
-bool effect_sort_id(const effect* e1, const effect* e2);
-
-struct effect_set {
-	effect_set(): count(0) {}
-	void add_item(effect* peffect) {
-		if(count >= 64) return;
-		container[count++] = peffect;
-	}
-	void remove_item(int index) {
-		if(index >= count)
-			return;
-		if(index == count - 1) {
-			count--;
-			return;
-		}
-		for(int i = index; i < count - 1; ++i)
-			container[i] = container[i + 1];
-		count--;
-	}
-	void clear() {
-		count = 0;
-	}
-	int size() const {
-		return count;
-	}
-	void sort() {
-		if(count < 2)
-			return;
-		std::sort(container.begin(), container.begin() + count, effect_sort_id);
-	}
-	effect* const& get_last() const {
-		return container[count - 1];
-	}
-	effect*& get_last() {
-		return container[count - 1];
-	}
-	effect* const& operator[] (int index) const {
-		return container[index];
-	}
-	effect*& operator[] (int index) {
-		return container[index];
-	}
-	effect* const& at(int index) const {
-		return container[index];
-	}
-	effect*& at(int index) {
-		return container[index];
-	}
-private:
-	std::array<effect*, 64> container;
-	int count;
-};
-
-struct effect_set_v {
-	effect_set_v(): count(0) {}
-	void add_item(effect* peffect) {
-		container.push_back(peffect);
-		count++;
-	}
-	void remove_item(int index) {
-		if(index >= count)
-			return;
-		container.erase(container.begin() + index);
-		count--;
-	}
-	void clear() {
-		container.clear();
-		count = 0;
-	}
-	void sort() {
-		if(count < 2)
-			return;
-		std::sort(container.begin(), container.begin() + count, effect_sort_id);
-	}
-	effect*& get_last() {
-		return container[count - 1];
-	}
-	effect*& operator[] (int index) {
-		return container[index];
-	}
-	effect*& at(int index) {
-		return container[index];
-	}
-	std::vector<effect*> container;
-	int count;
-};
-
-#endif //EFFECTSET_H_

ocgcore/group.cpp

-/*
- * group.cpp
- *
- *  Created on: 2010-8-3
- *      Author: Argon
- */
-
-#include "group.h"
-#include "card.h"
-#include "duel.h"
-
-group::group(duel* pd) {
-	scrtype = 2;
-	ref_handle = 0;
-	pduel = pd;
-	is_readonly = FALSE;
-}
-group::group(duel* pd, card* pcard) {
-	container.insert(pcard);
-	scrtype = 2;
-	ref_handle = 0;
-	pduel = pd;
-	is_readonly = FALSE;
-}
-group::group(duel* pd, const card_set& cset): container(cset) {
-	scrtype = 2;
-	ref_handle = 0;
-	pduel = pd;
-	is_readonly = FALSE;
-}
-group::~group() {
-
-}

ocgcore/group.h

-/*
- * group.h
- *
- *  Created on: 2010-5-6
- *      Author: Argon
- */
-
-#ifndef GROUP_H_
-#define GROUP_H_
-
-#include "common.h"
-#include <set>
-#include <list>
-
-class card;
-class duel;
-
-class group {
-public:
-	typedef std::set<card*, card_sort> card_set;
-	int32 scrtype;
-	int32 ref_handle;
-	duel* pduel;
-	card_set container;
-	card_set::iterator it;
-	uint32 is_readonly;
-	
-	inline bool has_card(card* c) {
-		return container.find(c) != container.end();
-	}
-	
-	explicit group(duel* pd);
-	group(duel* pd, card* pcard);
-	group(duel* pd, const card_set& cset);
-	~group();
-};
-
-#endif /* GROUP_H_ */

ocgcore/mem.cpp

-/*
- * mem.cpp
- *
- *  Created on: 2011-9-8
- *      Author: argon
- */
-//#define USE_TCMALLOC
-
-#ifdef USE_TCMALLOC
-
-#define PERFTOOLS_DLL_DECL
-#include <tcmalloc.h>
-
-void* operator new(size_t size) {
-	return tc_malloc(size);
-}
-void* operator new[](size_t size) {
-	return tc_malloc(size);
-}
-void* operator new(size_t size, const std::nothrow_t& nt) {
-	return tc_malloc(size);
-}
-void* operator new[](size_t size, const std::nothrow_t& nt) {
-	return tc_malloc(size);
-}
-void operator delete(void* p) {
-	return tc_free(p);
-}
-void operator delete[](void* p) {
-	return tc_free(p);
-}
-void operator delete(void* p, const std::nothrow_t& nt) {
-	return tc_free(p);
-}
-void operator delete[](void* p, const std::nothrow_t& nt) {
-	return tc_free(p);
-}
-
-#endif //USE_TCMALLOC