Merge branch 'fallenstardust:master' into master

Classes/gframe/client_field.cpp

@@ -470,7 +470,7 @@ void ClientField::ShowSelectCard(bool buttonok, bool chain) {
 			mainGame->imageLoading.insert(std::make_pair(mainGame->btnCardSelect[i], selectable_cards[i]->chain_code));
 		else
 			mainGame->btnCardSelect[i]->setImage(imageManager.tCover[selectable_cards[i]->controler + 2]);
-		mainGame->btnCardSelect[i]->setRelativePosition(rect<s32>((startpos + i * 125) * mainGame->xScale, 65 * mainGame->yScale, (startpos + 120 + i * 125) * mainGame->xScale, 235 * mainGame->yScale));
+		mainGame->btnCardSelect[i]->setRelativePosition(mainGame->Resize(startpos + i * 125, 65, startpos + 120 + i * 125, 235));
 		mainGame->btnCardSelect[i]->setPressed(false);
 		mainGame->btnCardSelect[i]->setVisible(true);
 		if(mainGame->dInfo.curMsg != MSG_SORT_CARD) {
@@ -525,7 +525,7 @@ void ClientField::ShowSelectCard(bool buttonok, bool chain) {
 			mainGame->stCardPos[i]->setBackgroundColor(0xff56649f);
 		}
 		mainGame->stCardPos[i]->setVisible(true);
-		mainGame->stCardPos[i]->setRelativePosition(rect<s32>((startpos + i * 125) * mainGame->xScale, 40 * mainGame->yScale, (startpos + 120 + i * 125) * mainGame->xScale, 60 * mainGame->yScale));
+		mainGame->stCardPos[i]->setRelativePosition(mainGame->Resize(startpos + i * 125, 40, startpos + 120 + i * 125, 60));
 	}
 	if(selectable_cards.size() <= 5) {
 		for(int i = selectable_cards.size(); i < 5; ++i) {
@@ -558,7 +558,7 @@ void ClientField::ShowChainCard() {
 			mainGame->imageLoading.insert(std::make_pair(mainGame->btnCardSelect[i], selectable_cards[i]->code));
 		else
 			mainGame->btnCardSelect[i]->setImage(imageManager.tCover[selectable_cards[i]->controler]);
-		mainGame->btnCardSelect[i]->setRelativePosition(rect<s32>((startpos + i * 125) * mainGame->xScale, 65 * mainGame->yScale, (startpos + 120 + i * 125) * mainGame->xScale, 235 * mainGame->yScale));
+		mainGame->btnCardSelect[i]->setRelativePosition(mainGame->Resize(startpos + i * 125, 65, startpos + 120 + i * 125, 235));
 		mainGame->btnCardSelect[i]->setPressed(false);
 		mainGame->btnCardSelect[i]->setVisible(true);
 		wchar_t formatBuffer[2048];
@@ -577,7 +577,7 @@ void ClientField::ShowChainCard() {
 			else mainGame->stCardPos[i]->setBackgroundColor(0xff56649f);
 		}
 		mainGame->stCardPos[i]->setVisible(true);
-		mainGame->stCardPos[i]->setRelativePosition(rect<s32>((startpos + i * 125) * mainGame->xScale, 40 * mainGame->yScale, (startpos + 120 + i * 125) * mainGame->xScale, 60 * mainGame->yScale));
+		mainGame->stCardPos[i]->setRelativePosition(mainGame->Resize(startpos + i * 125, 40, startpos + 120 + i * 125, 60));
 	} 
 	if(selectable_cards.size() <= 5) {
 		for(int i = selectable_cards.size(); i < 5; ++i) {
@@ -613,7 +613,7 @@ void ClientField::ShowLocationCard() {
 			mainGame->imageLoading.insert(std::make_pair(mainGame->btnCardDisplay[i], display_cards[i]->code));
 		else
 			mainGame->btnCardDisplay[i]->setImage(imageManager.tCover[display_cards[i]->controler]);
-		mainGame->btnCardDisplay[i]->setRelativePosition(rect<s32>((startpos + i * 125) * mainGame->xScale, 65 * mainGame->yScale, (startpos + 120 + i * 125) * mainGame->xScale, 235 * mainGame->yScale));
+		mainGame->btnCardDisplay[i]->setRelativePosition(mainGame->Resize(startpos + i * 125, 65, startpos + 120 + i * 125, 235));
 		mainGame->btnCardDisplay[i]->setPressed(false);
 		mainGame->btnCardDisplay[i]->setVisible(true);
 		wchar_t formatBuffer[2048];
@@ -646,7 +646,7 @@ void ClientField::ShowLocationCard() {
 				mainGame->stDisplayPos[i]->setBackgroundColor(0xff56649f);
 		}
 		mainGame->stDisplayPos[i]->setVisible(true);
-		mainGame->stDisplayPos[i]->setRelativePosition(rect<s32>((startpos + i * 125) * mainGame->xScale, 40 * mainGame->yScale, (startpos + 120 + i * 125) * mainGame->xScale, 60 * mainGame->yScale));
+		mainGame->stDisplayPos[i]->setRelativePosition(mainGame->Resize(startpos + i * 125, 40, startpos + 120 + i * 125, 60));
 	}
 	if(display_cards.size() <= 5) {
 		for(int i = display_cards.size(); i < 5; ++i) {

Classes/gframe/drawing.cpp

@@ -1148,9 +1148,9 @@ void Game::DrawThumb(code_pointer cp, position2di pos, const std::unordered_map<
 	if(img == nullptr)
 		return; //nullptr->getSize() will cause a crash
 	dimension2d<u32> size = img->getOriginalSize();
-	recti dragloc = recti(pos.X, pos.Y, pos.X + CARD_THUMB_WIDTH * mainGame->xScale, pos.Y + CARD_THUMB_HEIGHT * mainGame->yScale);
-	recti limitloc = recti(pos.X, pos.Y, pos.X + 20 * mainGame->xScale, pos.Y + 20 * mainGame->yScale);
-	recti otloc = recti(pos.X + 7 * mainGame->xScale, pos.Y + 50 * mainGame->yScale, pos.X + 37 * mainGame->xScale, pos.Y + 65 * mainGame->yScale);
+	recti dragloc = recti(pos.X, pos.Y, pos.X + CARD_THUMB_WIDTH * mainGame->yScale, pos.Y + CARD_THUMB_HEIGHT * mainGame->yScale);
+	recti limitloc = recti(pos.X, pos.Y, pos.X + 20 * mainGame->yScale, pos.Y + 20 * mainGame->yScale);
+	recti otloc = recti(pos.X + 7 * mainGame->xScale, pos.Y + 50 * mainGame->yScale, pos.X + 37 * mainGame->yScale, pos.Y + 65 * mainGame->yScale);
 
 	driver->draw2DImage(img, dragloc, rect<s32>(0, 0, size.Width, size.Height));
 	if(lflist->count(lcode)) {
@@ -1240,7 +1240,7 @@ void Game::DrawDeckBd() {
 		int j = i + padding;
 		DrawThumb(deckManager.current_deck.main[j], Resize(314 + (i % lx) * dx, 164 + (i / lx) * dy), deckBuilder.filterList);
 		if(deckBuilder.hovered_pos == 1 && deckBuilder.hovered_seq == j)
-			driver->draw2DRectangleOutline(Resize(313 + (i % lx) * dx, 163 + (i / lx) * dy, 359 + (i % lx) * dx, 228 + (i / lx) * dy));
+			driver->draw2DRectangleOutline(recti ((313 + (i % lx) * dx) * xScale, (163 + (i / lx) * dy) * yScale, (313 + (i % lx) * dx) * xScale + (CARD_THUMB_WIDTH + 1) * yScale, (163 + (i / lx) * dy + CARD_THUMB_HEIGHT + 1) * yScale));
 	}
 	if(!deckBuilder.showing_pack) {
 		//extra deck
@@ -1271,7 +1271,7 @@ void Game::DrawDeckBd() {
 		for(size_t i = 0; i < deckManager.current_deck.extra.size(); ++i) {
 			DrawThumb(deckManager.current_deck.extra[i], Resize(314 + i * dx, 466), deckBuilder.filterList);
 			if(deckBuilder.hovered_pos == 2 && deckBuilder.hovered_seq == (int)i)
-				driver->draw2DRectangleOutline(Resize(313 + i * dx, 465, 359 + i * dx, 531));
+				driver->draw2DRectangleOutline(recti((313 + i * dx) * xScale, 465 * yScale, (313 + i * dx) * xScale + (CARD_THUMB_WIDTH + 1) * yScale, (465 + CARD_THUMB_HEIGHT + 1 ) * yScale));
 		}
 		//side deck
 		driver->draw2DRectangle(Resize(310, 537, 410, 557), 0x400000ff, 0x400000ff, 0x40000000, 0x40000000);
@@ -1298,7 +1298,7 @@ void Game::DrawDeckBd() {
 		for(size_t i = 0; i < deckManager.current_deck.side.size(); ++i) {
 			DrawThumb(deckManager.current_deck.side[i], Resize(314 + i * dx, 564), deckBuilder.filterList);
 			if(deckBuilder.hovered_pos == 3 && deckBuilder.hovered_seq == (int)i)
-				driver->draw2DRectangleOutline(Resize(313 + i * dx, 563, 359 + i * dx, 629));
+				driver->draw2DRectangleOutline(recti((313 + i * dx) * xScale, 563 * yScale, (313 + i * dx) * xScale + (CARD_THUMB_WIDTH + 1) * yScale, (563 + CARD_THUMB_HEIGHT + 1) * yScale));
 		}
 	}
 	if(is_siding) {
@@ -1369,7 +1369,7 @@ void Game::DrawDeckBd() {
 		}
 	}
 	if(deckBuilder.is_draging) {
-		DrawThumb(deckBuilder.draging_pointer,position2di(deckBuilder.dragx - 22, deckBuilder.dragy - 32),deckBuilder.filterList, true);
+		DrawThumb(deckBuilder.draging_pointer,position2di(deckBuilder.dragx - CARD_THUMB_WIDTH / 2, deckBuilder.dragy - CARD_THUMB_HEIGHT / 2),deckBuilder.filterList, true);
 	}
 }
 }

Classes/gframe/game.cpp

@@ -786,7 +786,7 @@ bool Game::Initialize(ANDROID_APP app, android::InitOptions *options) {
 		stCardPos[i]->setBackgroundColor(0xffffffff);
 		stCardPos[i]->setTextAlignment(irr::gui::EGUIA_CENTER, irr::gui::EGUIA_CENTER);
 		btnCardSelect[i] = irr::gui::CGUIImageButton::addImageButton(env, Resize(30 + 125 * i, 65, 150 + 125 * i, 235), wCardSelect, BUTTON_CARD_0 + i);
-		btnCardSelect[i]->setImageSize(core::dimension2di(CARD_IMG_WIDTH * 0.6f * xScale, CARD_IMG_HEIGHT * 0.6f * yScale));
+		btnCardSelect[i]->setImageSize(core::dimension2di(CARD_IMG_WIDTH * 0.6f * yScale, CARD_IMG_HEIGHT * 0.6f * yScale));
 	}
 	scrCardList = env->addScrollBar(true, Resize(30, 245, 650, 285), wCardSelect, SCROLL_CARD_SELECT);
 	btnSelectOK = env->addButton(Resize(285, 295, 395, 335), wCardSelect, BUTTON_CARD_SEL_OK, dataManager.GetSysString(1211));
@@ -803,7 +803,7 @@ bool Game::Initialize(ANDROID_APP app, android::InitOptions *options) {
 		stDisplayPos[i]->setBackgroundColor(0xffffffff);
 		stDisplayPos[i]->setTextAlignment(irr::gui::EGUIA_CENTER, irr::gui::EGUIA_CENTER);
 		btnCardDisplay[i] = irr::gui::CGUIImageButton::addImageButton(env, Resize(30 + 125 * i, 65, 150 + 125 * i, 235), wCardDisplay, BUTTON_DISPLAY_0 + i);
-		btnCardDisplay[i]->setImageSize(core::dimension2di(CARD_IMG_WIDTH * 0.6f * xScale, CARD_IMG_HEIGHT * 0.6f * yScale));
+		btnCardDisplay[i]->setImageSize(core::dimension2di(CARD_IMG_WIDTH * 0.6f * yScale, CARD_IMG_HEIGHT * 0.6f * yScale));
 	}
 	scrDisplayList = env->addScrollBar(true, Resize(30, 245, 650, 285), wCardDisplay, SCROLL_CARD_DISPLAY);
 	btnDisplayOK = env->addButton(Resize(285, 295, 395, 335), wCardDisplay, BUTTON_CARD_DISP_OK, dataManager.GetSysString(1211));

Classes/gframe/replay.cpp

@@ -28,7 +28,6 @@ void Replay::BeginRecord() {
 	if(!fp)
 		return;
 #endif
-	pwrite = replay_data;
 	replay_size = 0;
 	comp_size = 0;
 	is_replaying = false;
@@ -44,13 +43,13 @@ void Replay::WriteHeader(ReplayHeader& header) {
 	fflush(fp);
 #endif
 }
-void Replay::WriteData(const void* data, int length, bool flush) {
+void Replay::WriteData(const void* data, size_t length, bool flush) {
 	if(!is_recording)
 		return;
-	if (length < 0 || (int)(pwrite - replay_data) + length > MAX_REPLAY_SIZE)
+	if (replay_size + length > MAX_REPLAY_SIZE)
 		return;
-	std::memcpy(pwrite, data, length);
-	pwrite += length;
+	std::memcpy(replay_data + replay_size, data, length);
+	replay_size += length;
 #ifdef _WIN32
 	DWORD size;
 	WriteFile(recording_fp, data, length, &size, nullptr);
@@ -60,14 +59,8 @@ void Replay::WriteData(const void* data, int length, bool flush) {
 		fflush(fp);
 #endif
 }
-void Replay::WriteInt32(int data, bool flush) {
-	WriteData(&data, sizeof data, flush);
-}
-void Replay::WriteInt16(short data, bool flush) {
-	WriteData(&data, sizeof data, flush);
-}
-void Replay::WriteInt8(char data, bool flush) {
-	WriteData(&data, sizeof data, flush);
+void Replay::WriteInt32(int32_t data, bool flush) {
+	Write<int32_t>(data, flush);
 }
 void Replay::Flush() {
 	if(!is_recording)
@@ -85,7 +78,6 @@ void Replay::EndRecord() {
 #else
 	fclose(fp);
 #endif
-	replay_size = pwrite - replay_data;
 	pheader.datasize = replay_size;
 	pheader.flag |= REPLAY_COMPRESSED;
 	size_t propsize = 5;
@@ -119,7 +111,7 @@ bool Replay::OpenReplay(const wchar_t* name) {
 	if(!rfp)
 		return false;
 
-	pdata = replay_data;
+	data_position = 0;
 	is_recording = false;
 	is_replaying = false;
 	replay_size = 0;
@@ -209,37 +201,26 @@ bool Replay::ReadName(wchar_t* data) {
 	BufferIO::CopyWStr(buffer, data, 20);
 	return true;
 }
-bool Replay::ReadData(void* data, int length) {
+void Replay::ReadHeader(ReplayHeader& header) {
+	header = pheader;
+}
+bool Replay::ReadData(void* data, size_t length) {
 	if(!is_replaying)
 		return false;
-	if (length < 0)
-		return false;
-	if ((int)(pdata - replay_data) + length > (int)replay_size) {
+	if (data_position + length > replay_size) {
 		is_replaying = false;
 		return false;
 	}
-	std::memcpy(data, pdata, length);
-	pdata += length;
+	if (length)
+		std::memcpy(data, &replay_data[data_position], length);
+	data_position += length;
 	return true;
 }
-template<typename T>
-T Replay::ReadValue() {
-	T ret{};
-	if (!ReadData(&ret, sizeof ret))
-		return -1;
-	return ret;
-}
-int Replay::ReadInt32() {
-	return ReadValue<int32_t>();
-}
-short Replay::ReadInt16() {
-	return ReadValue<int16_t>();
-}
-char Replay::ReadInt8() {
-	return ReadValue<char>();
+int32_t Replay::ReadInt32() {
+	return Read<int32_t>();
 }
 void Replay::Rewind() {
-	pdata = replay_data;
+	data_position = 0;
 }
 
 }

Classes/gframe/replay.h

@@ -34,10 +34,12 @@ public:
 	// record
 	void BeginRecord();
 	void WriteHeader(ReplayHeader& header);
-	void WriteData(const void* data, int length, bool flush = true);
-	void WriteInt32(int data, bool flush = true);
-	void WriteInt16(short data, bool flush = true);
-	void WriteInt8(char data, bool flush = true);
+	void WriteData(const void* data, size_t length, bool flush = true);
+	template<typename T>
+	void Write(T data, bool flush = true) {
+		WriteData(&data, sizeof(T), flush);
+	}
+	void WriteInt32(int32_t data, bool flush = true);
 	void Flush();
 	void EndRecord();
 	void SaveReplay(const wchar_t* name);
@@ -49,13 +51,15 @@ public:
 	static bool RenameReplay(const wchar_t* oldname, const wchar_t* newname);
 	bool ReadNextResponse(unsigned char resp[]);
 	bool ReadName(wchar_t* data);
-	//void ReadHeader(ReplayHeader& header);
-	bool ReadData(void* data, int length);
+	void ReadHeader(ReplayHeader& header);
+	bool ReadData(void* data, size_t length);
 	template<typename T>
-	T ReadValue();
-	int ReadInt32();
-	short ReadInt16();
-	char ReadInt8();
+	T Read() {
+		T ret{};
+		ReadData(&ret, sizeof(T));
+		return ret;
+	}
+	int32_t ReadInt32();
 	void Rewind();
 
 	FILE* fp{ nullptr };
@@ -70,8 +74,7 @@ public:
 private:
 	unsigned char* replay_data;
 	size_t replay_size{};
-	unsigned char* pwrite{};
-	unsigned char* pdata{};
+	size_t data_position{};
 	bool is_recording{};
 	bool is_replaying{};
 };

Classes/gframe/replay_mode.cpp

@@ -228,8 +228,8 @@ bool ReplayMode::StartDuel() {
 		}
 	} else {
 		char filename[256];
-		int slen = cur_replay.ReadInt16();
-		if (slen < 0 || slen > 255) {
+		auto slen = cur_replay.Read<uint16_t>();
+		if (slen > sizeof(filename) - 1) {
 			return false;
 		}
 		cur_replay.ReadData(filename, slen);

Classes/gframe/single_duel.cpp

@@ -1413,7 +1413,7 @@ void SingleDuel::GetResponse(DuelPlayer* dp, unsigned char* pdata, unsigned int
 	if (len > SIZE_RETURN_VALUE)
 		len = SIZE_RETURN_VALUE;
 	std::memcpy(resb, pdata, len);
-	last_replay.WriteInt8(len);
+	last_replay.Write<uint8_t>(len);
 	last_replay.WriteData(resb, len);
 	set_responseb(pduel, resb);
 	players[dp->type]->state = 0xff;

Classes/gframe/single_mode.cpp

@@ -25,7 +25,7 @@ void SingleMode::StopPlay(bool is_exiting) {
 void SingleMode::SetResponse(unsigned char* resp, unsigned int len) {
 	if(!pduel)
 		return;
-	last_replay.WriteInt8(len);
+	last_replay.Write<uint8_t>(len);
 	last_replay.WriteData(resp, len);
 	set_responseb(pduel, resp);
 }
@@ -108,7 +108,7 @@ int SingleMode::SinglePlayThread() {
 	last_replay.WriteInt32(start_hand, false);
 	last_replay.WriteInt32(draw_count, false);
 	last_replay.WriteInt32(opt, false);
-	last_replay.WriteInt16(slen, false);
+	last_replay.Write<uint16_t>(slen, false);
 	last_replay.WriteData(filename, slen, false);
 	last_replay.Flush();
 	start_duel(pduel, opt);

Classes/gframe/tag_duel.cpp

@@ -1515,7 +1515,7 @@ void TagDuel::GetResponse(DuelPlayer* dp, unsigned char* pdata, unsigned int len
 	if (len > SIZE_RETURN_VALUE)
 		len = SIZE_RETURN_VALUE;
 	std::memcpy(resb, pdata, len);
-	last_replay.WriteInt8(len);
+	last_replay.Write<uint8_t>(len);
 	last_replay.WriteData(resb, len);
 	set_responseb(pduel, resb);
 	players[dp->type]->state = 0xff;

Classes/ocgcore/card_data.h

@@ -6,16 +6,16 @@
 
 constexpr int CARD_ARTWORK_VERSIONS_OFFSET = 20;
 constexpr int SIZE_SETCODE = 16;
-constexpr uint32 CARD_BLACK_LUSTER_SOLDIER2 = 5405695;
+constexpr uint32_t CARD_BLACK_LUSTER_SOLDIER2 = 5405695;
 
 //double name
-constexpr uint32 CARD_MARINE_DOLPHIN = 78734254;
-constexpr uint32 CARD_TWINKLE_MOSS = 13857930;
-constexpr uint32 CARD_TIMAEUS = 1784686;
-constexpr uint32 CARD_CRITIAS = 11082056;
-constexpr uint32 CARD_HERMOS = 46232525;
+constexpr uint32_t CARD_MARINE_DOLPHIN = 78734254;
+constexpr uint32_t CARD_TWINKLE_MOSS = 13857930;
+constexpr uint32_t CARD_TIMAEUS = 1784686;
+constexpr uint32_t CARD_CRITIAS = 11082056;
+constexpr uint32_t CARD_HERMOS = 46232525;
 
-const std::unordered_map<uint32, uint32> second_code = {
+const std::unordered_map<uint32_t, uint32_t> second_code = {
 	{CARD_MARINE_DOLPHIN, 17955766u},
 	{CARD_TWINKLE_MOSS, 17732278u},
 	{CARD_TIMAEUS, 10000050u},
@@ -24,18 +24,18 @@ const std::unordered_map<uint32, uint32> second_code = {
 };
 
 struct card_data {
-	uint32 code{};
-	uint32 alias{};
+	uint32_t code{};
+	uint32_t alias{};
 	uint16_t setcode[SIZE_SETCODE]{};
-	uint32 type{};
-	uint32 level{};
-	uint32 attribute{};
-	uint32 race{};
-	int32 attack{};
-	int32 defense{};
-	uint32 lscale{};
-	uint32 rscale{};
-	uint32 link_marker{};
+	uint32_t type{};
+	uint32_t level{};
+	uint32_t attribute{};
+	uint32_t race{};
+	int32_t attack{};
+	int32_t defense{};
+	uint32_t lscale{};
+	uint32_t rscale{};
+	uint32_t link_marker{};
 
 	void clear() {
 		code = 0;
@@ -53,7 +53,7 @@ struct card_data {
 		link_marker = 0;
 	}
 
-	bool is_setcode(uint32 value) const {
+	bool is_setcode(uint32_t value) const {
 		uint16_t settype = value & 0x0fff;
 		uint16_t setsubtype = value & 0xf000;
 		for (auto& x : setcode) {
@@ -71,7 +71,7 @@ struct card_data {
 		return alias && (alias < code + CARD_ARTWORK_VERSIONS_OFFSET) && (code < alias + CARD_ARTWORK_VERSIONS_OFFSET);
 	}
 
-	void set_setcode(uint64 value) {
+	void set_setcode(uint64_t value) {
 		int ctr = 0;
 		while (value) {
 			if (value & 0xffff) {
@@ -84,7 +84,7 @@ struct card_data {
 			setcode[i] = 0;
 	}
 
-	uint32 get_original_code() const {
+	uint32_t get_original_code() const {
 		return is_alternative() ? alias : code;
 	}
 };

Classes/ocgcore/common.h

@@ -10,15 +10,11 @@
 
 #include <stdint.h>
 #include <assert.h>
-typedef unsigned long long uint64;
-typedef unsigned int uint32;
-typedef unsigned short uint16;
-typedef unsigned char uint8;
 typedef unsigned char byte;
-typedef long long int64;
-typedef int int32;
-typedef short int16;
-typedef signed char int8;
+
+inline bool check_playerid(int32_t playerid) {
+	return playerid >= 0 && playerid <= 1;
+}
 
 #define MATCH_ALL(x,y) (((x)&(y))==(y))
 #define MATCH_ANY(x,y) ((x)&(y))

Classes/ocgcore/duel.cpp

@@ -48,7 +48,7 @@ void duel::clear() {
 	game_field = new field(this);
 	game_field->temp_card = new_card(0);
 }
-card* duel::new_card(uint32 code) {
+card* duel::new_card(uint32_t code) {
 	card* pcard = new card(this);
 	cards.insert(pcard);
 	if (code != TEMP_CARD_ID)
@@ -97,11 +97,11 @@ void duel::delete_effect(effect* peffect) {
 	effects.erase(peffect);
 	delete peffect;
 }
-int32 duel::read_buffer(byte* buf) {
+int32_t duel::read_buffer(byte* buf) {
 	auto size = buffer_size();
 	if (size)
 		std::memcpy(buf, message_buffer.data(), size);
-	return (int32)size;
+	return (int32_t)size;
 }
 void duel::release_script_group() {
 	for(auto& pgroup : sgroups) {
@@ -121,25 +121,25 @@ void duel::restore_assumes() {
 void duel::write_buffer(const void* data, int size) {
 	vector_write_block(message_buffer, data, size);
 }
-void duel::write_buffer32(uint32 value) {
+void duel::write_buffer32(uint32_t value) {
 	vector_write<uint32_t>(message_buffer, value);
 }
-void duel::write_buffer16(uint16 value) {
+void duel::write_buffer16(uint16_t value) {
 	vector_write<uint16_t>(message_buffer, value);
 }
-void duel::write_buffer8(uint8 value) {
+void duel::write_buffer8(uint8_t value) {
 	vector_write<unsigned char>(message_buffer, value);
 }
 void duel::clear_buffer() {
 	message_buffer.clear();
 }
-void duel::set_responsei(uint32 resp) {
+void duel::set_responsei(uint32_t resp) {
 	game_field->returns.ivalue[0] = resp;
 }
 void duel::set_responseb(byte* resp) {
 	std::memcpy(game_field->returns.bvalue, resp, SIZE_RETURN_VALUE);
 }
-int32 duel::get_next_integer(int32 l, int32 h) {
+int32_t duel::get_next_integer(int32_t l, int32_t h) {
 	if (game_field->core.duel_options & DUEL_OLD_REPLAY) {
 		return random.get_random_integer_old(l, h);
 	}

Classes/ocgcore/duel.h

@@ -41,10 +41,10 @@ public:
 	~duel();
 	void clear();
 	
-	uint32 buffer_size() const {
-		return (uint32)message_buffer.size() & PROCESSOR_BUFFER_LEN;
+	uint32_t buffer_size() const {
+		return (uint32_t)message_buffer.size() & PROCESSOR_BUFFER_LEN;
 	}
-	card* new_card(uint32 code);
+	card* new_card(uint32_t code);
 	group* new_group();
 	group* new_group(card* pcard);
 	group* new_group(const card_set& cset);
@@ -54,15 +54,15 @@ public:
 	void delete_effect(effect* peffect);
 	void release_script_group();
 	void restore_assumes();
-	int32 read_buffer(byte* buf);
+	int32_t read_buffer(byte* buf);
 	void write_buffer(const void* data, int size);
-	void write_buffer32(uint32 value);
-	void write_buffer16(uint16 value);
-	void write_buffer8(uint8 value);
+	void write_buffer32(uint32_t value);
+	void write_buffer16(uint16_t value);
+	void write_buffer8(uint8_t value);
 	void clear_buffer();
-	void set_responsei(uint32 resp);
+	void set_responsei(uint32_t resp);
 	void set_responseb(byte* resp);
-	int32 get_next_integer(int32 l, int32 h);
+	int32_t get_next_integer(int32_t l, int32_t h);
 private:
 	group* register_group(group* pgroup);
 };

Classes/ocgcore/group.h

@@ -27,8 +27,8 @@ public:
 	duel* pduel;
 	card_set container;
 	card_set::iterator it;
-	int32 ref_handle{ 0 };
-	uint32 is_readonly{ GTYPE_DEFAULT };
+	int32_t ref_handle{ 0 };
+	uint32_t is_readonly{ GTYPE_DEFAULT };
 	bool is_iterator_dirty{ true };
 	
 	bool has_card(card* c) {

mobile/assets/data/conf/strings.conf

@@ -447,14 +447,14 @@
 !system 1412 无法解析主机地址。
 !system 1413 「%ls」为OCG独有卡，不允许在当前设定下使用。
 !system 1414 「%ls」为TCG独有卡，不允许在当前设定下使用。
-!system 1415 卡组中「%ls(%d)」不存在于本主机卡池中。
+!system 1415 卡组中「%ls(%d)」尚不支持在本主机使用。
 !system 1416 卡组中「%ls」的总数量超过3张。
 !system 1417 主卡组数量应为40-60张，当前卡组数量为%d张。
 !system 1418 额外卡组数量应不超过15张，当前卡组数量为%d张。
 !system 1419 副卡组数量应不超过15张，当前卡组数量为%d张。
 !system 1420 有额外卡组卡片存在于主卡组，可能是额外卡组数量超过15张。
 !system 1421 操作无效，请重试。
-!system 1422 宣言的卡不符合条件，不存在于本主机卡池中。
+!system 1422 宣言的卡不符合条件，或不支持在本主机使用。
 !system 1423 宣言的属性不符合条件。
 !system 1424 宣言的种族不符合条件
 !system 1425 宣言的数字不符合条件。