Skip to content

Y
YGOMobile
Commit 16bccfc7 authored by fallenstardust's avatar fallenstardust
Browse files
Options

适配Android卡组管理

parent 3a5df330
Hide whitespace changes
Inline Side-by-side
Showing with 907 additions and 210 deletions
Classes/gframe/deck_con.cpp
View file @ 16bccfc7
......@@ -3,6 +3,7 @@
#include "data_manager.h"
#include "deck_manager.h"
#include "image_manager.h"
#include "myfilesystem.h"
#include "game.h"
#include "duelclient.h"
#include <algorithm>
......@@ -59,6 +60,68 @@ static bool check_set_code(const CardDataC& data, int set_code) {
return res;
}
inline bool havePopupWindow() {
return mainGame->wQuery->isVisible() || mainGame->wCategories->isVisible() || mainGame->wLinkMarks->isVisible() || mainGame->wDeckManage->isVisible() || mainGame->wDMQuery->isVisible();
}
inline void refreshDeckList() {
irr::gui::IGUIListBox* lstCategories = mainGame->lstCategories;
irr::gui::IGUIListBox* lstDecks = mainGame->lstDecks;
wchar_t catepath[256];
deckManager.GetCategoryPath(catepath, lstCategories->getSelected(), lstCategories->getListItem(lstCategories->getSelected()));
lstDecks->clear();
FileSystem::TraversalDir(catepath, [lstDecks](const wchar_t* name, bool isdir) {
if(!isdir && wcsrchr(name, '.') && !wcsncasecmp(wcsrchr(name, '.'), L".ydk", 4)) {
size_t len = wcslen(name);
wchar_t deckname[256];
wcsncpy(deckname, name, len - 4);
deckname[len - 4] = 0;
lstDecks->addItem(deckname);
}
});
}
inline void refreshReadonly(int catesel) {
mainGame->deckBuilder.readonly = catesel < 2;
mainGame->btnSaveDeck->setEnabled(!mainGame->deckBuilder.readonly);
mainGame->btnDeleteDeck->setEnabled(!mainGame->deckBuilder.readonly);
mainGame->btnRenameCategory->setEnabled(catesel > 3);
mainGame->btnDeleteCategory->setEnabled(catesel > 3);
mainGame->btnNewDeck->setEnabled(!mainGame->deckBuilder.readonly);
mainGame->btnRenameDeck->setEnabled(!mainGame->deckBuilder.readonly);
mainGame->btnDMDeleteDeck->setEnabled(!mainGame->deckBuilder.readonly);
mainGame->btnMoveDeck->setEnabled(!mainGame->deckBuilder.readonly);
}
inline void changeCategory(int catesel) {
refreshReadonly(catesel);
mainGame->RefreshDeck(mainGame->cbDBCategory, mainGame->cbDBDecks);
mainGame->cbDBDecks->setSelected(0);
deckManager.LoadDeck(mainGame->cbDBCategory, mainGame->cbDBDecks);
mainGame->deckBuilder.is_modified = false;
mainGame->deckBuilder.prev_category = catesel;
mainGame->deckBuilder.prev_deck = 0;
}
inline void showDeckManage() {
mainGame->RefreshCategoryDeck(mainGame->cbDBCategory, mainGame->cbDBDecks, false);
mainGame->cbDBCategory->setSelected(mainGame->deckBuilder.prev_category);
mainGame->RefreshDeck(mainGame->cbDBCategory, mainGame->cbDBDecks);
mainGame->cbDBDecks->setSelected(mainGame->deckBuilder.prev_deck);
irr::gui::IGUIListBox* lstCategories = mainGame->lstCategories;
lstCategories->clear();
lstCategories->addItem(dataManager.GetSysString(1450));
lstCategories->addItem(dataManager.GetSysString(1451));
lstCategories->addItem(dataManager.GetSysString(1452));
lstCategories->addItem(dataManager.GetSysString(1453));
FileSystem::TraversalDir(L"./deck", [lstCategories](const wchar_t* name, bool isdir) {
if(isdir) {
lstCategories->addItem(name);
}
});
lstCategories->setSelected(mainGame->deckBuilder.prev_category);
refreshReadonly(mainGame->deckBuilder.prev_category);
refreshDeckList();
mainGame->lstDecks->setSelected(mainGame->deckBuilder.prev_deck);
mainGame->PopupElement(mainGame->wDeckManage);
}
void DeckBuilder::Initialize() {
mainGame->is_building = true;
mainGame->is_siding = false;
......@@ -75,7 +138,7 @@ void DeckBuilder::Initialize() {
mainGame->btnSideSort->setVisible(false);
mainGame->btnSideReload->setVisible(false);
filterList = deckManager._lfList[0].content;
mainGame->cbDBLFList->setSelected(0);
mainGame->cbLFList->setSelected(0);
ClearSearch();
mouse_pos.set(0, 0);
hovered_code = 0;
......@@ -85,6 +148,10 @@ void DeckBuilder::Initialize() {
is_draging = false;
is_starting_dragging = false;
prev_deck = mainGame->cbDBDecks->getSelected();
prev_category = mainGame->cbDBCategory->getSelected();
readonly = prev_category < 2;
mainGame->btnSaveDeck->setEnabled(!readonly);
mainGame->btnDeleteDeck->setEnabled(!readonly);
prev_operation = 0;
prev_sel = -1;
is_modified = false;
......@@ -104,15 +171,16 @@ void DeckBuilder::Terminate() {
mainGame->device->setEventReceiver(&mainGame->menuHandler);
mainGame->wACMessage->setVisible(false);
mainGame->ClearTextures();
mainGame->SaveConfig();
mainGame->scrFilter->setVisible(false);
int sel = mainGame->cbDBDecks->getSelected();
if(sel >= 0){
BufferIO::CopyWStr(mainGame->cbDBDecks->getItem(sel), mainGame->gameConf.lastdeck, 64);
char linebuf[256];
int catesel = mainGame->cbDBCategory->getSelected();
if(catesel >= 0)
BufferIO::CopyWStr(mainGame->cbDBCategory->getItem(catesel), mainGame->gameConf.lastcategory, 64);
int decksel = mainGame->cbDBDecks->getSelected();
char linebuf[256];
if(decksel >= 0)
BufferIO::EncodeUTF8(mainGame->gameConf.lastdeck, linebuf);
android::setLastDeck(mainGame->appMain, linebuf);
}
mainGame->SaveConfig();
if(exit_on_return)
mainGame->device->closeDevice();
}
......@@ -128,13 +196,25 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
switch(event.EventType) {
case irr::EET_GUI_EVENT: {
s32 id = event.GUIEvent.Caller->getID();
if(mainGame->wCategories->isVisible() && id != BUTTON_CATEGORY_OK)
break;
if(mainGame->wQuery->isVisible() && id != BUTTON_YES && id != BUTTON_NO)
break;
if(mainGame->wLinkMarks->isVisible() && id != BUTTON_MARKERS_OK)
if(((mainGame->wCategories->isVisible() && id != BUTTON_CATEGORY_OK) ||
(mainGame->wQuery->isVisible() && id != BUTTON_YES && id != BUTTON_NO) ||
(mainGame->wLinkMarks->isVisible() && id != BUTTON_MARKERS_OK) ||
(mainGame->wDMQuery->isVisible() && id != BUTTON_DM_OK && id != BUTTON_DM_CANCEL) ||
(mainGame->wDeckManage->isVisible() && !(id >= WINDOW_DECK_MANAGE && id <= COMBOBOX_LFLIST)))
&& event.GUIEvent.EventType != irr::gui::EGET_LISTBOX_CHANGED
&& event.GUIEvent.EventType != irr::gui::EGET_COMBO_BOX_CHANGED) {
if(mainGame->wDMQuery->isVisible())
mainGame->wDMQuery->getParent()->bringToFront(mainGame->wDMQuery);
break;
}
switch(event.GUIEvent.EventType) {
case irr::gui::EGET_ELEMENT_CLOSED: {
if(id == WINDOW_DECK_MANAGE) {
mainGame->HideElement(mainGame->wDeckManage);
return true;
break;
}
}
case irr::gui::EGET_BUTTON_CLICKED: {
switch(id) {
case BUTTON_CLEAR_DECK: {
......@@ -160,7 +240,11 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
}
case BUTTON_SAVE_DECK: {
int sel = mainGame->cbDBDecks->getSelected();
if(sel >= 0 && deckManager.SaveDeck(deckManager.current_deck, mainGame->cbDBDecks->getItem(sel))) {
if(sel == -1)
break;
wchar_t filepath[256];
deckManager.GetDeckFile(filepath, mainGame->cbDBCategory, mainGame->cbDBDecks);
if(deckManager.SaveDeck(deckManager.current_deck, filepath)) {
mainGame->stACMessage->setText(dataManager.GetSysString(1335));
mainGame->PopupElement(mainGame->wACMessage, 20);
is_modified = false;
......@@ -185,7 +269,11 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
mainGame->cbDBDecks->addItem(dname);
mainGame->cbDBDecks->setSelected(mainGame->cbDBDecks->getItemCount() - 1);
}
if(deckManager.SaveDeck(deckManager.current_deck, dname)) {
wchar_t catepath[256];
deckManager.GetCategoryPath(catepath, mainGame->cbDBCategory->getSelected(), mainGame->cbDBCategory->getText());
wchar_t filepath[256];
myswprintf(filepath, L"%ls/%ls.ydk", catepath, dname);
if(deckManager.SaveDeck(deckManager.current_deck, filepath)) {
mainGame->stACMessage->setText(dataManager.GetSysString(1335));
mainGame->PopupElement(mainGame->wACMessage, 20);
is_modified = false;
......@@ -193,49 +281,6 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
}
break;
}
case BUTTON_RENAME_DECK: {
mainGame->soundEffectPlayer->doPressButton();
int sel = mainGame->cbDBDecks->getSelected();
if(sel == -1)
break;
mainGame->gMutex.lock();
mainGame->wRenameDeck->setText(dataManager.GetSysString(1362));
mainGame->ebREName->setText(mainGame->cbDBDecks->getItem(sel));
mainGame->PopupElement(mainGame->wRenameDeck);
mainGame->gMutex.unlock();
prev_operation = id;
prev_sel = sel;
break;
}
case BUTTON_RENAME_DECK_SAVE: {
mainGame->soundEffectPlayer->doSaveDeck();
mainGame->HideElement(mainGame->wRenameDeck);
if(prev_operation == BUTTON_RENAME_DECK) {
wchar_t newname[256];
BufferIO::CopyWStr(mainGame->ebREName->getText(), newname, 256);
if(wcsncasecmp(newname + wcslen(newname) - 4, L"", 4)) {
myswprintf(newname, L"%ls", mainGame->ebREName->getText());
}
if(DeckManager::RenameDeck(mainGame->cbDBDecks->getItem(prev_sel), newname)) {
mainGame->RefreshDeck(mainGame->cbDBDecks);
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(prev_sel));
mainGame->cbDBDecks->setSelected(prev_sel);
mainGame->stACMessage->setText(dataManager.GetSysString(1335));
mainGame->PopupElement(mainGame->wACMessage, 20);
} else {
mainGame->env->addMessageBox(L"", dataManager.GetSysString(1365));
}
}
prev_operation = 0;
prev_sel = -1;
break;
}
case BUTTON_RENAME_DECK_CANCEL: {
mainGame->HideElement(mainGame->wRenameDeck);
prev_operation = 0;
prev_sel = -1;
break;
}
case BUTTON_DELETE_DECK: {
int sel = mainGame->cbDBDecks->getSelected();
if(sel == -1)
......@@ -252,9 +297,9 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
break;
}
case BUTTON_LEAVE_GAME: {
if(is_modified && !mainGame->chkIgnoreDeckChanges->isChecked()) {
if(is_modified && !readonly && !mainGame->chkIgnoreDeckChanges->isChecked()) {
mainGame->gMutex.lock();
mainGame->SetStaticText(mainGame->stQMessage, 310, mainGame->guiFont, dataManager.GetSysString(1356));
mainGame->SetStaticText(mainGame->stQMessage, 370 * mainGame->xScale, mainGame->textFont, dataManager.GetSysString(1356));
mainGame->PopupElement(mainGame->wQuery);
mainGame->gMutex.unlock();
prev_operation = id;
......@@ -292,6 +337,373 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
InstantSearch();
break;
}
case BUTTON_MANAGE_DECK: {
if(is_modified && !readonly && !mainGame->chkIgnoreDeckChanges->isChecked()) {
mainGame->gMutex.lock();
mainGame->SetStaticText(mainGame->stQMessage, 370 * mainGame->xScale, mainGame->guiFont, dataManager.GetSysString(1356));
mainGame->PopupElement(mainGame->wQuery);
mainGame->gMutex.unlock();
prev_operation = id;
break;
}
showDeckManage();
break;
}
case BUTTON_NEW_CATEGORY: {
mainGame->gMutex.lock();
mainGame->stDMMessage->setText(dataManager.GetSysString(1469));
mainGame->ebDMName->setVisible(true);
mainGame->ebDMName->setText(L"");
mainGame->PopupElement(mainGame->wDMQuery);
mainGame->gMutex.unlock();
prev_operation = id;
break;
}
case BUTTON_RENAME_CATEGORY: {
if(mainGame->lstCategories->getSelected() < 4)
break;
mainGame->gMutex.lock();
mainGame->stDMMessage->setText(dataManager.GetSysString(1469));
mainGame->ebDMName->setVisible(true);
mainGame->ebDMName->setText(L"");
mainGame->PopupElement(mainGame->wDMQuery);
mainGame->gMutex.unlock();
prev_operation = id;
break;
}
case BUTTON_DELETE_CATEGORY: {
mainGame->gMutex.lock();
mainGame->stDMMessage->setText(dataManager.GetSysString(1470));
mainGame->stDMMessage2->setVisible(true);
mainGame->stDMMessage2->setText(mainGame->lstCategories->getListItem(mainGame->lstCategories->getSelected()));
mainGame->PopupElement(mainGame->wDMQuery);
mainGame->gMutex.unlock();
prev_operation = id;
break;
}
case BUTTON_NEW_DECK: {
mainGame->gMutex.lock();
mainGame->stDMMessage->setText(dataManager.GetSysString(1471));
mainGame->ebDMName->setVisible(true);
mainGame->ebDMName->setText(L"");
mainGame->PopupElement(mainGame->wDMQuery);
mainGame->gMutex.unlock();
prev_operation = id;
break;
}
case BUTTON_RENAME_DECK: {
mainGame->gMutex.lock();
mainGame->stDMMessage->setText(dataManager.GetSysString(1471));
mainGame->ebDMName->setVisible(true);
mainGame->ebDMName->setText(L"");
mainGame->PopupElement(mainGame->wDMQuery);
mainGame->gMutex.unlock();
prev_operation = id;
break;
}
case BUTTON_DELETE_DECK_DM: {
mainGame->gMutex.lock();
mainGame->stDMMessage->setText(dataManager.GetSysString(1337));
mainGame->stDMMessage2->setVisible(true);
mainGame->stDMMessage2->setText(mainGame->lstDecks->getListItem(mainGame->lstDecks->getSelected()));
mainGame->PopupElement(mainGame->wDMQuery);
mainGame->gMutex.unlock();
prev_operation = id;
break;
}
case BUTTON_MOVE_DECK: {
mainGame->gMutex.lock();
mainGame->stDMMessage->setText(dataManager.GetSysString(1472));
mainGame->cbDMCategory->setVisible(true);
mainGame->cbDMCategory->clear();
int catesel = mainGame->lstCategories->getSelected();
if(catesel != 2)
mainGame->cbDMCategory->addItem(dataManager.GetSysString(1452));
for(int i = 4;i < mainGame->lstCategories->getItemCount();i++) {
if(i != catesel)
mainGame->cbDMCategory->addItem(mainGame->lstCategories->getListItem(i));
}
mainGame->PopupElement(mainGame->wDMQuery);
mainGame->gMutex.unlock();
prev_operation = id;
break;
}
case BUTTON_COPY_DECK: {
mainGame->gMutex.lock();
mainGame->stDMMessage->setText(dataManager.GetSysString(1473));
mainGame->cbDMCategory->setVisible(true);
mainGame->cbDMCategory->clear();
int catesel = mainGame->lstCategories->getSelected();
if(catesel != 2)
mainGame->cbDMCategory->addItem(dataManager.GetSysString(1452));
for(int i = 4;i < mainGame->lstCategories->getItemCount();i++) {
if(i != catesel)
mainGame->cbDMCategory->addItem(mainGame->lstCategories->getListItem(i));
}
mainGame->PopupElement(mainGame->wDMQuery);
mainGame->gMutex.unlock();
prev_operation = id;
break;
}
case BUTTON_DM_OK: {
switch(prev_operation) {
case BUTTON_NEW_CATEGORY: {
int catesel = 0;
const wchar_t* catename = mainGame->ebDMName->getText();
if(deckManager.CreateCategory(catename)) {
mainGame->cbDBCategory->addItem(catename);
mainGame->lstCategories->addItem(catename);
catesel = mainGame->lstCategories->getItemCount() - 1;
}
else {
for(int i = 3;i < mainGame->lstCategories->getItemCount();i++) {
if(!wcsncasecmp(mainGame->lstCategories->getListItem(i), catename, 256)) {
catesel = i;
mainGame->stACMessage->setText(dataManager.GetSysString(1474));
mainGame->PopupElement(mainGame->wACMessage, 20);
break;
}
}
}
if(catesel > 0) {
mainGame->lstCategories->setSelected(catesel);
refreshDeckList();
mainGame->lstDecks->setSelected(0);
mainGame->cbDBCategory->setSelected(catesel);
changeCategory(catesel);
}
break;
}
case BUTTON_RENAME_CATEGORY: {
int catesel = mainGame->lstCategories->getSelected();
const wchar_t* oldcatename = mainGame->lstCategories->getListItem(catesel);
const wchar_t* newcatename = mainGame->ebDMName->getText();
if(deckManager.RenameCategory(oldcatename, newcatename)) {
mainGame->cbDBCategory->removeItem(catesel);
mainGame->cbDBCategory->addItem(newcatename);
mainGame->lstCategories->removeItem(catesel);
mainGame->lstCategories->addItem(newcatename);
catesel = mainGame->lstCategories->getItemCount() - 1;
} else {
catesel = 0;
for(int i = 3;i < mainGame->lstCategories->getItemCount();i++) {
if(!wcsncasecmp(mainGame->lstCategories->getListItem(i), newcatename, 256)) {
catesel = i;
mainGame->stACMessage->setText(dataManager.GetSysString(1474));
mainGame->PopupElement(mainGame->wACMessage, 20);
break;
}
}
}
if(catesel > 0) {
mainGame->lstCategories->setSelected(catesel);
refreshDeckList();
mainGame->lstDecks->setSelected(0);
mainGame->cbDBCategory->setSelected(catesel);
changeCategory(catesel);
}
break;
}
case BUTTON_DELETE_CATEGORY: {
int catesel = mainGame->lstCategories->getSelected();
const wchar_t* catename = mainGame->lstCategories->getListItem(catesel);
if(deckManager.DeleteCategory(catename)) {
mainGame->cbDBCategory->removeItem(catesel);
mainGame->lstCategories->removeItem(catesel);
catesel = 2;
mainGame->lstCategories->setSelected(catesel);
refreshDeckList();
mainGame->lstDecks->setSelected(0);
mainGame->cbDBCategory->setSelected(catesel);
changeCategory(catesel);
} else {
mainGame->stACMessage->setText(dataManager.GetSysString(1476));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
case BUTTON_NEW_DECK: {
const wchar_t* deckname = mainGame->ebDMName->getText();
wchar_t catepath[256];
deckManager.GetCategoryPath(catepath, mainGame->cbDBCategory->getSelected(), mainGame->cbDBCategory->getText());
wchar_t filepath[256];
myswprintf(filepath, L"%ls/%ls.ydk", catepath, deckname);
bool res = false;
if(!FileSystem::IsFileExists(filepath)) {
deckManager.current_deck.main.clear();
deckManager.current_deck.extra.clear();
deckManager.current_deck.side.clear();
res = deckManager.SaveDeck(deckManager.current_deck, filepath);
refreshDeckList();
changeCategory(mainGame->lstCategories->getSelected());
}
for(int i = 0;i < mainGame->lstDecks->getItemCount();i++) {
if(!wcsncasecmp(mainGame->lstDecks->getListItem(i), deckname, 256)) {
deckManager.LoadDeck(filepath);
prev_deck = i;
mainGame->cbDBDecks->setSelected(prev_deck);
mainGame->lstDecks->setSelected(prev_deck);
if(!res) {
mainGame->stACMessage->setText(dataManager.GetSysString(1475));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
}
break;
}
case BUTTON_RENAME_DECK: {
int catesel = mainGame->lstCategories->getSelected();
int decksel = mainGame->lstDecks->getSelected();
const wchar_t* catename = mainGame->lstCategories->getListItem(catesel);
wchar_t oldfilepath[256];
deckManager.GetDeckFile(oldfilepath, mainGame->cbDBCategory, mainGame->cbDBDecks);
const wchar_t* newdeckname = mainGame->ebDMName->getText();
wchar_t newfilepath[256];
if(catesel == 2) {
myswprintf(newfilepath, L"./deck/%ls.ydk", newdeckname);
} else {
myswprintf(newfilepath, L"./deck/%ls/%ls.ydk", catename, newdeckname);
}
bool res = false;
if(!FileSystem::IsFileExists(newfilepath)) {
res = FileSystem::Rename(oldfilepath, newfilepath);
}
refreshDeckList();
changeCategory(catesel);
for(int i = 0;i < mainGame->lstDecks->getItemCount();i++) {
if(!wcsncasecmp(mainGame->lstDecks->getListItem(i), newdeckname, 256)) {
deckManager.LoadDeck(newfilepath);
prev_deck = i;
mainGame->cbDBDecks->setSelected(prev_deck);
mainGame->lstDecks->setSelected(prev_deck);
if(!res) {
mainGame->stACMessage->setText(dataManager.GetSysString(1475));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
}
break;
}
case BUTTON_DELETE_DECK_DM: {
int decksel = mainGame->lstDecks->getSelected();
wchar_t filepath[256];
deckManager.GetDeckFile(filepath, mainGame->cbDBCategory, mainGame->cbDBDecks);
if(deckManager.DeleteDeck(filepath)) {
mainGame->lstDecks->removeItem(decksel);
mainGame->cbDBDecks->removeItem(decksel);
decksel--;
if(decksel == -1) {
decksel = mainGame->lstDecks->getItemCount() - 1;
}
if(decksel != -1) {
mainGame->lstDecks->setSelected(decksel);
mainGame->cbDBDecks->setSelected(decksel);
deckManager.LoadDeck(mainGame->cbDBCategory, mainGame->cbDBDecks);
}
prev_deck = decksel;
} else {
mainGame->stACMessage->setText(dataManager.GetSysString(1476));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
case BUTTON_MOVE_DECK: {
int oldcatesel = mainGame->lstCategories->getSelected();
int newcatesel = mainGame->cbDMCategory->getSelected();
int decksel = mainGame->lstDecks->getSelected();
const wchar_t* newcatename = mainGame->cbDMCategory->getText();
const wchar_t* olddeckname = mainGame->lstDecks->getListItem(decksel);
wchar_t deckname[256];
BufferIO::CopyWStr(olddeckname, deckname, 256);
wchar_t oldfilepath[256];
deckManager.GetDeckFile(oldfilepath, mainGame->cbDBCategory, mainGame->cbDBDecks);
wchar_t newfilepath[256];
if(oldcatesel != 2 && newcatesel == 0) {
myswprintf(newfilepath, L"./deck/%ls.ydk", deckname);
} else {
myswprintf(newfilepath, L"./deck/%ls/%ls.ydk", newcatename, deckname);
}
bool res = false;
if(!FileSystem::IsFileExists(newfilepath)) {
res = FileSystem::Rename(oldfilepath, newfilepath);
}
mainGame->lstCategories->setSelected(newcatename);
int catesel = mainGame->lstCategories->getSelected();
refreshDeckList();
mainGame->cbDBCategory->setSelected(catesel);
changeCategory(catesel);
for(int i = 0;i < mainGame->lstDecks->getItemCount();i++) {
if(!wcsncasecmp(mainGame->lstDecks->getListItem(i), deckname, 256)) {
deckManager.LoadDeck(newfilepath);
prev_deck = i;
mainGame->cbDBDecks->setSelected(prev_deck);
mainGame->lstDecks->setSelected(prev_deck);
if(!res) {
mainGame->stACMessage->setText(dataManager.GetSysString(1475));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
}
break;
}
case BUTTON_COPY_DECK: {
int oldcatesel = mainGame->lstCategories->getSelected();
int newcatesel = mainGame->cbDMCategory->getSelected();
int decksel = mainGame->lstDecks->getSelected();
const wchar_t* newcatename = mainGame->cbDMCategory->getText();
const wchar_t* olddeckname = mainGame->lstDecks->getListItem(decksel);
wchar_t deckname[256];
BufferIO::CopyWStr(olddeckname, deckname, 256);
wchar_t newfilepath[256];
if(oldcatesel != 2 && newcatesel == 0) {
myswprintf(newfilepath, L"./deck/%ls.ydk", deckname);
} else {
myswprintf(newfilepath, L"./deck/%ls/%ls.ydk", newcatename, deckname);
}
bool res = false;
if(!FileSystem::IsFileExists(newfilepath)) {
res = deckManager.SaveDeck(deckManager.current_deck, newfilepath);
}
mainGame->lstCategories->setSelected(newcatename);
int catesel = mainGame->lstCategories->getSelected();
refreshDeckList();
mainGame->cbDBCategory->setSelected(catesel);
changeCategory(catesel);
for(int i = 0;i < mainGame->lstDecks->getItemCount();i++) {
if(!wcsncasecmp(mainGame->lstDecks->getListItem(i), deckname, 256)) {
deckManager.LoadDeck(newfilepath);
prev_deck = i;
mainGame->cbDBDecks->setSelected(prev_deck);
mainGame->lstDecks->setSelected(prev_deck);
if(!res) {
mainGame->stACMessage->setText(dataManager.GetSysString(1475));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
}
break;
}
default:
break;
}
prev_operation = 0;
mainGame->HideElement(mainGame->wDMQuery);
mainGame->stDMMessage2->setVisible(false);
mainGame->ebDMName->setVisible(false);
mainGame->cbDMCategory->setVisible(false);
break;
}
case BUTTON_DM_CANCEL: {
mainGame->HideElement(mainGame->wDMQuery);
mainGame->stDMMessage2->setVisible(false);
mainGame->ebDMName->setVisible(false);
mainGame->cbDMCategory->setVisible(false);
break;
}
case BUTTON_SIDE_OK: {
mainGame->soundEffectPlayer->doPressButton();
if(deckManager.current_deck.main.size() != pre_mainc || deckManager.current_deck.extra.size() != pre_extrac
......@@ -314,7 +726,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
break;
}
case BUTTON_SIDE_RELOAD: {
deckManager.LoadDeck(mainGame->cbDeckSelect->getItem(mainGame->cbDeckSelect->getSelected()));
deckManager.LoadDeck(mainGame->cbCategorySelect, mainGame->cbDeckSelect);
break;
}
case BUTTON_MSG_OK: {
......@@ -333,14 +745,17 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
deckManager.current_deck.side.clear();
} else if(prev_operation == BUTTON_DELETE_DECK) {
int sel = prev_sel;
if(deckManager.DeleteDeck(deckManager.current_deck, mainGame->cbDBDecks->getItem(sel))) {
mainGame->cbDBDecks->setSelected(sel);
wchar_t filepath[256];
deckManager.GetDeckFile(filepath, mainGame->cbDBCategory, mainGame->cbDBDecks);
if(deckManager.DeleteDeck(filepath)) {
mainGame->cbDBDecks->removeItem(sel);
int count = mainGame->cbDBDecks->getItemCount();
if(sel >= count)
sel = count - 1;
mainGame->cbDBDecks->setSelected(sel);
if(sel != -1)
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(sel));
deckManager.LoadDeck(mainGame->cbDBCategory, mainGame->cbDBDecks);
mainGame->stACMessage->setText(dataManager.GetSysString(1338));
mainGame->PopupElement(mainGame->wACMessage, 20);
prev_deck = sel;
......@@ -349,11 +764,16 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
prev_sel = -1;
} else if(prev_operation == BUTTON_LEAVE_GAME) {
Terminate();
} else if(prev_operation == COMBOBOX_DBCATEGORY) {
int catesel = mainGame->cbDBCategory->getSelected();
changeCategory(catesel);
} else if(prev_operation == COMBOBOX_DBDECKS) {
int sel = mainGame->cbDBDecks->getSelected();
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(sel));
prev_deck = sel;
int decksel = mainGame->cbDBDecks->getSelected();
deckManager.LoadDeck(mainGame->cbDBCategory, mainGame->cbDBDecks);
prev_deck = decksel;
is_modified = false;
} else if(prev_operation == BUTTON_MANAGE_DECK) {
showDeckManage();
}
prev_operation = 0;
break;
......@@ -361,7 +781,10 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
case BUTTON_NO: {
mainGame->soundEffectPlayer->doPressButton();
mainGame->HideElement(mainGame->wQuery);
if (prev_operation == COMBOBOX_DBDECKS) {
if(prev_operation == COMBOBOX_DBCATEGORY) {
mainGame->cbDBCategory->setSelected(prev_category);
}
else if(prev_operation == COMBOBOX_DBDECKS) {
mainGame->cbDBDecks->setSelected(prev_deck);
}
prev_operation = 0;
......@@ -426,12 +849,39 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
}
case irr::gui::EGET_COMBO_BOX_CHANGED: {
switch(id) {
case COMBOBOX_DBLFLIST: {
filterList = deckManager._lfList[mainGame->cbDBLFList->getSelected()].content;
case COMBOBOX_LFLIST: {
filterList = deckManager._lfList[mainGame->cbLFList->getSelected()].content;
break;
}
case COMBOBOX_DBCATEGORY: {
if(havePopupWindow()) {
mainGame->cbDBCategory->setSelected(prev_category);
break;
}
int catesel = mainGame->cbDBCategory->getSelected();
if(catesel == 3) {
catesel = 2;
mainGame->cbDBCategory->setSelected(2);
if(prev_category == 2)
break;
}
if(is_modified && !readonly && !mainGame->chkIgnoreDeckChanges->isChecked()) {
mainGame->gMutex.lock();
mainGame->SetStaticText(mainGame->stQMessage, 370 * mainGame->xScale, mainGame->guiFont, dataManager.GetSysString(1356));
mainGame->PopupElement(mainGame->wQuery);
mainGame->gMutex.unlock();
prev_operation = id;
break;
}
changeCategory(catesel);
break;
}
case COMBOBOX_DBDECKS: {
if(is_modified && !mainGame->chkIgnoreDeckChanges->isChecked()) {
if(havePopupWindow()) {
mainGame->cbDBDecks->setSelected(prev_deck);
break;
}
if(is_modified && !readonly && !mainGame->chkIgnoreDeckChanges->isChecked()) {
mainGame->gMutex.lock();
mainGame->SetStaticText(mainGame->stQMessage, 370 * mainGame-> xScale, mainGame->textFont, dataManager.GetSysString(1356));
mainGame->PopupElement(mainGame->wQuery);
......@@ -439,10 +889,11 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
prev_operation = id;
break;
}
int sel = mainGame->cbDBDecks->getSelected();
if(sel >= 0)
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(sel));
prev_deck = sel;
int decksel = mainGame->cbDBDecks->getSelected();
if(decksel >= 0) {
deckManager.LoadDeck(mainGame->cbDBCategory, mainGame->cbDBDecks);
}
prev_deck = decksel;
is_modified = false;
break;
}
......@@ -562,6 +1013,46 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
InstantSearch();
}
}
case irr::gui::EGET_LISTBOX_CHANGED: {
switch(id) {
case LISTBOX_CATEGORIES: {
if(mainGame->wDMQuery->isVisible()) {
mainGame->lstCategories->setSelected(prev_category);
break;
}
int catesel = mainGame->lstCategories->getSelected();
if(catesel == 3) {
catesel = 2;
mainGame->lstCategories->setSelected(catesel);
if(prev_category == catesel)
break;
}
refreshDeckList();
mainGame->lstDecks->setSelected(0);
mainGame->cbDBCategory->setSelected(catesel);
changeCategory(catesel);
break;
}
case LISTBOX_DECKS: {
if(mainGame->wDMQuery->isVisible()) {
mainGame->lstDecks->setSelected(prev_deck);
break;
}
int decksel = mainGame->lstDecks->getSelected();
mainGame->cbDBDecks->setSelected(decksel);
if(decksel == -1)
break;
wchar_t filepath[256];
wchar_t catepath[256];
deckManager.GetCategoryPath(catepath, mainGame->lstCategories->getSelected(), mainGame->lstCategories->getListItem(mainGame->lstCategories->getSelected()));
myswprintf(filepath, L"%ls/%ls.ydk", catepath, mainGame->lstDecks->getListItem(decksel));
deckManager.LoadDeck(filepath);
prev_deck = decksel;
break;
}
}
break;
}
default: break;
}
break;
......@@ -572,7 +1063,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
irr::gui::IGUIElement* root = mainGame->env->getRootGUIElement();
if(root->getElementFromPoint(mouse_pos) != root)
break;
if(mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
if(havePopupWindow())
break;
if(hovered_pos == 0 || hovered_seq == -1)
break;
......@@ -642,7 +1133,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
}
break;
}
if(mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
if(havePopupWindow())
break;
if(!is_draging) {
if(hovered_pos == 0 || hovered_seq == -1)
......@@ -680,7 +1171,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
case irr::EMIE_MMOUSE_LEFT_UP: {
if (mainGame->is_siding)
break;
if (mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
if (havePopupWindow())
break;
if (hovered_pos == 0 || hovered_seq == -1)
break;
......
Classes/gframe/deck_con.h
View file @ 16bccfc7
......@@ -66,10 +66,12 @@ public:
size_t pre_extrac;
size_t pre_sidec;
code_pointer draging_pointer;
int prev_category;
int prev_deck;
s32 prev_operation;
int prev_sel;
bool is_modified;
bool readonly;
std::unordered_map<int, int>* filterList;
std::vector<code_pointer> results;
......
Classes/gframe/deck_manager.cpp
View file @ 16bccfc7
......@@ -2,6 +2,7 @@
#include "data_manager.h"
#include "network.h"
#include "game.h"
#include "myfilesystem.h"
#include <algorithm>
namespace ygo {
......@@ -56,23 +57,6 @@ void DeckManager::LoadLFList(const char* path, bool load_none) {
nolimit.content = new std::unordered_map<int, int>;
_lfList.push_back(nolimit);
}
bool DeckManager::RenameDeck(const wchar_t* oldname, const wchar_t* newname) {
wchar_t oldfname[256];
wchar_t newfname[256];
myswprintf(oldfname, L"./deck/%ls.ydk", oldname);
myswprintf(newfname, L"./deck/%ls.ydk", newname);
#ifdef WIN32
BOOL result = MoveFileW(oldfname, newfname);
return !!result;
#else
char oldfilefn[256];
char newfilefn[256];
BufferIO::EncodeUTF8(oldfname, oldfilefn);
BufferIO::EncodeUTF8(newfname, newfilefn);
int result = rename(oldfilefn, newfilefn);
return result == 0;
#endif
}
wchar_t* DeckManager::GetLFListName(int lfhash) {
for(size_t i = 0; i < _lfList.size(); ++i) {
if(_lfList[i].hash == (unsigned int)lfhash) {
......@@ -206,6 +190,37 @@ bool DeckManager::LoadSide(Deck& deck, int* dbuf, int mainc, int sidec) {
deck = ndeck;
return true;
}
void DeckManager::GetCategoryPath(wchar_t* ret, int index, const wchar_t* text) {
wchar_t catepath[256];
switch(index) {
case 0:
myswprintf(catepath, L"./pack");
break;
case 1:
myswprintf(catepath, L"./windbot/Decks");
break;
case -1:
case 2:
case 3:
myswprintf(catepath, L"./deck");
break;
default:
myswprintf(catepath, L"./deck/%ls", text);
}
BufferIO::CopyWStr(catepath, ret, 256);
}
void DeckManager::GetDeckFile(wchar_t* ret, irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck) {
wchar_t filepath[256];
wchar_t catepath[256];
GetCategoryPath(catepath, cbCategory->getSelected(), cbCategory->getText());
myswprintf(filepath, L"%ls/%ls.ydk", catepath, cbDeck->getItem(cbDeck->getSelected()));
BufferIO::CopyWStr(filepath, ret, 256);
}
bool DeckManager::LoadDeck(irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck) {
wchar_t filepath[256];
GetDeckFile(filepath, cbCategory, cbDeck);
return LoadDeck(filepath);
}
FILE* DeckManager::OpenDeckFile(const wchar_t* file, const char* mode) {
#ifdef WIN32
FILE* fp = _wfopen(file, (wchar_t*)mode);
......@@ -218,11 +233,11 @@ FILE* DeckManager::OpenDeckFile(const wchar_t* file, const char* mode) {
}
bool DeckManager::LoadDeck(const wchar_t* file) {
int sp = 0, ct = 0, mainc = 0, sidec = 0, code;
wchar_t localfile[64];
myswprintf(localfile, L"./deck/%ls.ydk", file);
FILE* fp = OpenDeckFile(localfile, "r");
FILE* fp = OpenDeckFile(file, "r");
if(!fp) {
fp = OpenDeckFile(file, "r");
wchar_t localfile[64];
myswprintf(localfile, L"./deck/%ls.ydk", file);
fp = OpenDeckFile(localfile, "r");
}
if(!fp)
return false;
......@@ -248,9 +263,9 @@ bool DeckManager::LoadDeck(const wchar_t* file) {
LoadDeck(current_deck, cardlist, mainc, sidec);
return true;
}
bool DeckManager::SaveDeck(Deck& deck, const wchar_t* name) {
wchar_t file[64];
myswprintf(file, L"./deck/%ls.ydk", name);
bool DeckManager::SaveDeck(Deck& deck, const wchar_t* file) {
if(!FileSystem::IsDirExists(L"./deck") && !FileSystem::MakeDir(L"./deck"))
return false;
FILE* fp = OpenDeckFile(file, "w");
if(!fp)
return false;
......@@ -266,9 +281,7 @@ bool DeckManager::SaveDeck(Deck& deck, const wchar_t* name) {
fclose(fp);
return true;
}
bool DeckManager::DeleteDeck(Deck& deck, const wchar_t* name) {
wchar_t file[64];
myswprintf(file, L"./deck/%ls.ydk", name);
bool DeckManager::DeleteDeck(const wchar_t* file) {
#ifdef WIN32
BOOL result = DeleteFileW(file);
return !!result;
......@@ -279,6 +292,34 @@ bool DeckManager::DeleteDeck(Deck& deck, const wchar_t* name) {
return result == 0;
#endif
}
bool DeckManager::CreateCategory(const wchar_t* name) {
if(!FileSystem::IsDirExists(L"./deck") && !FileSystem::MakeDir(L"./deck"))
return false;
if(name[0] == 0)
return false;
wchar_t localname[256];
myswprintf(localname, L"./deck/%ls", name);
return FileSystem::MakeDir(localname);
}
bool DeckManager::RenameCategory(const wchar_t* oldname, const wchar_t* newname) {
if(!FileSystem::IsDirExists(L"./deck") && !FileSystem::MakeDir(L"./deck"))
return false;
if(newname[0] == 0)
return false;
wchar_t oldlocalname[256];
wchar_t newlocalname[256];
myswprintf(oldlocalname, L"./deck/%ls", oldname);
myswprintf(newlocalname, L"./deck/%ls", newname);
return FileSystem::Rename(oldlocalname, newlocalname);
}
bool DeckManager::DeleteCategory(const wchar_t* name) {
wchar_t localname[256];
myswprintf(localname, L"./deck/%ls", name);
if(!FileSystem::IsDirExists(localname))
return false;
return FileSystem::DeleteDir(localname);
}
int DeckManager::TypeCount(std::vector<code_pointer> list, unsigned int ctype) {
int res = 0;
for(size_t i = 0; i < list.size(); ++i) {
......@@ -288,4 +329,5 @@ int DeckManager::TypeCount(std::vector<code_pointer> list, unsigned int ctype) {
}
return res;
}
}
Classes/gframe/deck_manager.h
View file @ 16bccfc7
......@@ -40,11 +40,16 @@ public:
int CheckDeck(Deck& deck, int lfhash, bool allow_ocg, bool allow_tcg);
int LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec);
bool LoadSide(Deck& deck, int* dbuf, int mainc, int sidec);
void GetCategoryPath(wchar_t* ret, int index, const wchar_t* text);
void GetDeckFile(wchar_t* ret, irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck);
bool LoadDeck(irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck);
FILE* OpenDeckFile(const wchar_t * file, const char * mode);
bool LoadDeck(const wchar_t* file);
bool SaveDeck(Deck& deck, const wchar_t* name);
bool DeleteDeck(Deck& deck, const wchar_t* name);
static bool RenameDeck(const wchar_t* oldname, const wchar_t* newname);
bool SaveDeck(Deck& deck, const wchar_t* file);
bool DeleteDeck(const wchar_t* file);
bool CreateCategory(const wchar_t* name);
bool RenameCategory(const wchar_t* oldname, const wchar_t* newname);
bool DeleteCategory(const wchar_t* name);
int TypeCount(std::vector<code_pointer> list, unsigned int ctype);
};
......
Classes/gframe/duelclient.cpp
View file @ 16bccfc7
......@@ -308,6 +308,7 @@ void DuelClient::HandleSTOCPacketLan(char* data, unsigned int len) {
}
}
mainGame->env->addMessageBox(L"", msgbuf);
mainGame->cbCategorySelect->setEnabled(true);
mainGame->cbDeckSelect->setEnabled(true);
mainGame->gMutex.unlock();
break;
......@@ -341,7 +342,7 @@ void DuelClient::HandleSTOCPacketLan(char* data, unsigned int len) {
}
case STOC_SELECT_TP: {
mainGame->gMutex.lock();
mainGame->PopupElement(mainGame->wFTSelect);
mainGame->ShowElement(mainGame->wFTSelect);
mainGame->gMutex.unlock();
break;
}
......@@ -471,7 +472,8 @@ void DuelClient::HandleSTOCPacketLan(char* data, unsigned int len) {
mainGame->stHostPrepDuelist[3]->setText(L"");
mainGame->stHostPrepOB->setText(L"");
mainGame->SetStaticText(mainGame->stHostPrepRule, 180 * mainGame->xScale, mainGame->guiFont, str.c_str());
mainGame->RefreshDeck(mainGame->cbDeckSelect);
mainGame->RefreshCategoryDeck(mainGame->cbCategorySelect, mainGame->cbDeckSelect);
mainGame->cbCategorySelect->setEnabled(true);
mainGame->cbDeckSelect->setEnabled(true);
if(mainGame->wCreateHost->isVisible())
mainGame->HideElement(mainGame->wCreateHost);
......
Classes/gframe/game.cpp
View file @ 16bccfc7
......@@ -303,29 +303,30 @@ bool Game::Initialize() {
wHostPrepare->setDraggable(false);
wHostPrepare->getCloseButton()->setVisible(false);
wHostPrepare->setVisible(false);
btnHostPrepDuelist = env->addButton(rect<s32>(10 * xScale, 30 * yScale, 110 * xScale, 70 * yScale), wHostPrepare, BUTTON_HP_DUELIST, dataManager.GetSysString(1251));
btnHostPrepDuelist = env->addButton(rect<s32>(10 * xScale, 30 * yScale, 110 * xScale, 55 * yScale), wHostPrepare, BUTTON_HP_DUELIST, dataManager.GetSysString(1251));
for(int i = 0; i < 2; ++i) {
stHostPrepDuelist[i] = env->addStaticText(L"", rect<s32>(60 * xScale, (80 + i * 45) * yScale, 260 * xScale, (120 + i * 45) * yScale), true, false, wHostPrepare);
stHostPrepDuelist[i] = env->addStaticText(L"", rect<s32>(60 * xScale, (65 + i * 45) * yScale, 260 * xScale, (105 + i * 45) * yScale), true, false, wHostPrepare);
stHostPrepDuelist[i]->setTextAlignment(EGUIA_CENTER, EGUIA_CENTER);
btnHostPrepKick[i] = env->addButton(rect<s32>(10 * xScale, (80 + i * 45) * yScale, 50 * xScale, (120 + i * 45) * yScale), wHostPrepare, BUTTON_HP_KICK, L"X");
chkHostPrepReady[i] = env->addCheckBox(false, rect<s32>(270 * xScale, (80 + i * 45) * yScale, 310 * xScale, (120 + i * 45) * yScale), wHostPrepare, CHECKBOX_HP_READY, L"");
btnHostPrepKick[i] = env->addButton(rect<s32>(10 * xScale, (65 + i * 45) * yScale, 50 * xScale, (105 + i * 45) * yScale), wHostPrepare, BUTTON_HP_KICK, L"X");
chkHostPrepReady[i] = env->addCheckBox(false, rect<s32>(270 * xScale, (65 + i * 45) * yScale, 310 * xScale, (105 + i * 45) * yScale), wHostPrepare, CHECKBOX_HP_READY, L"");
chkHostPrepReady[i]->setEnabled(false);
}
for(int i = 2; i < 4; ++i) {
stHostPrepDuelist[i] = env->addStaticText(L"", rect<s32>(60 * xScale, (105 + i * 45) * yScale, 260 * xScale, (145 + i * 45) * yScale), true, false, wHostPrepare);
stHostPrepDuelist[i] = env->addStaticText(L"", rect<s32>(60 * xScale, (145 + i * 45) * yScale, 260 * xScale, (185 + i * 45) * yScale), true, false, wHostPrepare);
stHostPrepDuelist[i]->setTextAlignment(EGUIA_CENTER, EGUIA_CENTER);
btnHostPrepKick[i] = env->addButton(rect<s32>(10 * xScale, (105 + i * 45) * yScale, 50 * xScale, (145 + i * 45) * yScale), wHostPrepare, BUTTON_HP_KICK, L"X");
chkHostPrepReady[i] = env->addCheckBox(false, rect<s32>(270 * xScale, (105 + i * 45) * yScale, 310 * xScale, (145 + i * 45) * yScale), wHostPrepare, CHECKBOX_HP_READY, L"");
btnHostPrepKick[i] = env->addButton(rect<s32>(10 * xScale, (145 + i * 45) * yScale, 50 * xScale, (185 + i * 45) * yScale), wHostPrepare, BUTTON_HP_KICK, L"X");
chkHostPrepReady[i] = env->addCheckBox(false, rect<s32>(270 * xScale, (145 + i * 45) * yScale, 310 * xScale, (185 + i * 45) * yScale), wHostPrepare, CHECKBOX_HP_READY, L"");
chkHostPrepReady[i]->setEnabled(false);
}
btnHostPrepOB = env->addButton(rect<s32>(10 * xScale, 300 * yScale, 110 * xScale, 340 * yScale), wHostPrepare, BUTTON_HP_OBSERVER, dataManager.GetSysString(1252));
btnHostPrepOB = env->addButton(rect<s32>(10 * xScale, 180 * yScale, 110 * xScale, 205 * yScale), wHostPrepare, BUTTON_HP_OBSERVER, dataManager.GetSysString(1252));
myswprintf(dataManager.strBuffer, L"%ls%d", dataManager.GetSysString(1253), 0);
stHostPrepOB = env->addStaticText(dataManager.strBuffer, rect<s32>(10 * xScale, 340 * yScale, 270 * xScale, 370 * yScale), false, false, wHostPrepare);
stHostPrepOB = env->addStaticText(dataManager.strBuffer, rect<s32>(10 * xScale, 210 * yScale, 270 * xScale, 230 * yScale), false, false, wHostPrepare);
stHostPrepRule = env->addStaticText(L"", rect<s32>(300 * xScale, 30 * yScale, 460 * xScale, 230 * yScale), false, true, wHostPrepare);
env->addStaticText(dataManager.GetSysString(1254), rect<s32>(10 * xScale, 385 * yScale, 110 * xScale, 410 * yScale), false, false, wHostPrepare);
env->addStaticText(dataManager.GetSysString(1254), rect<s32>(10 * xScale, 355 * yScale, 110 * xScale, 385 * yScale), false, false, wHostPrepare);
cbCategorySelect = CAndroidGUIComboBox::addAndroidComboBox(env, rect<s32>(10 * xScale, 380 * yScale, 110 * xScale, 420 * yScale), wHostPrepare, COMBOBOX_HP_CATEGORY);
cbDeckSelect = CAndroidGUIComboBox::addAndroidComboBox(env, rect<s32>(120 * xScale, 380 * yScale, 270 * xScale, 420 * yScale), wHostPrepare);
btnHostPrepReady = env->addButton(rect<s32>(170 * xScale, 300 * yScale, 280 * xScale, 340 * yScale), wHostPrepare, BUTTON_HP_READY, dataManager.GetSysString(1218));
btnHostPrepNotReady = env->addButton(rect<s32>(170 * xScale, 300 * yScale, 280 * xScale, 340 * yScale), wHostPrepare, BUTTON_HP_NOTREADY, dataManager.GetSysString(1219));
btnHostPrepReady = env->addButton(rect<s32>(170 * xScale, 180 * yScale, 280 * xScale, 205 * yScale), wHostPrepare, BUTTON_HP_READY, dataManager.GetSysString(1218));
btnHostPrepNotReady = env->addButton(rect<s32>(170 * xScale, 180 * yScale, 280 * xScale, 205 * yScale), wHostPrepare, BUTTON_HP_NOTREADY, dataManager.GetSysString(1219));
btnHostPrepNotReady->setVisible(false);
btnHostPrepStart = env->addButton(rect<s32>(280 * xScale, 380 * yScale, 390 * xScale, 420 * yScale), wHostPrepare, BUTTON_HP_START, dataManager.GetSysString(1215));
btnHostPrepCancel = env->addButton(rect<s32>(400 * xScale, 380 * yScale, 510 * xScale, 420 * yScale), wHostPrepare, BUTTON_HP_CANCEL, dataManager.GetSysString(1210));
......@@ -630,20 +631,56 @@ bool Game::Initialize() {
//deck edit
wDeckEdit = env->addStaticText(L"", rect<s32>(309 * xScale, 8 * yScale, 605 * xScale, 130 * yScale), true, false, 0, -1, true);
wDeckEdit->setVisible(false);
env->addStaticText(dataManager.GetSysString(1300), rect<s32>(10 * xScale, 9 * yScale, 100 * xScale, 29 * yScale), false, false, wDeckEdit);
#ifdef _IRR_ANDROID_PLATFORM_
cbDBLFList = CAndroidGUIComboBox::addAndroidComboBox(env, rect<s32>(80 * xScale, 5 * yScale, 220 * xScale, 30 * yScale), wDeckEdit, COMBOBOX_DBLFLIST);
#else
cbDBLFList = env->addComboBox(rect<s32>(80 * xScale, 5 * yScale, 220 * xScale, 30 * yScale), wDeckEdit, COMBOBOX_DBLFLIST);
#endif
env->addStaticText(dataManager.GetSysString(1301), rect<s32>(10 * xScale, 39 * yScale, 100 * xScale, 59 * yScale), false, false, wDeckEdit);
#ifdef _IRR_ANDROID_PLATFORM_
cbDBDecks = CAndroidGUIComboBox::addAndroidComboBox(env, rect<s32>(80 * xScale, 35 * yScale, 220 * xScale, 60 * yScale), wDeckEdit, COMBOBOX_DBDECKS);
#else
cbDBDecks = env->addComboBox(rect<s32>(80 * xScale, 35 * yScale, 220 * xScale, 60 * yScale), wDeckEdit, COMBOBOX_DBDECKS);
#endif
btnManageDeck = env->addButton(rect<s32>(225 * xScale, 5 * yScale, 290 * xScale, 30 * yScale), wDeckEdit, BUTTON_MANAGE_DECK, dataManager.GetSysString(1328));
//deck manage
wDeckManage = env->addWindow(rect<s32>(510 * xScale, 100 * yScale, 970 * xScale, 600 * yScale), false, dataManager.GetSysString(1460), 0, WINDOW_DECK_MANAGE);
wDeckManage->setVisible(false);
lstCategories = env->addListBox(rect<s32>(10 * xScale, 30 * yScale, 140 * xScale, 480 * yScale), wDeckManage, LISTBOX_CATEGORIES, true);
lstCategories->setItemHeight(22 * yScale);
lstDecks = env->addListBox(rect<s32>(150 * xScale, 30 * yScale, 340 * xScale, 480 * yScale), wDeckManage, LISTBOX_DECKS, true);
lstCategories->setItemHeight(22 * yScale);
posY = 30;
btnNewCategory = env->addButton(rect<s32>(350 * xScale, posY * yScale, 450 * xScale, (posY + 40) * yScale), wDeckManage, BUTTON_NEW_CATEGORY, dataManager.GetSysString(1461));
posY += 50;
btnRenameCategory = env->addButton(rect<s32>(350 * xScale, posY * yScale, 450 * xScale, (posY + 40) * yScale), wDeckManage, BUTTON_RENAME_CATEGORY, dataManager.GetSysString(1462));
posY += 50;
btnDeleteCategory = env->addButton(rect<s32>(350 * xScale, posY * yScale, 450 * xScale, (posY + 40) * yScale), wDeckManage, BUTTON_DELETE_CATEGORY, dataManager.GetSysString(1463));
posY += 50;
btnNewDeck = env->addButton(rect<s32>(350 * xScale, posY * yScale, 450 * xScale, (posY + 40) * yScale), wDeckManage, BUTTON_NEW_DECK, dataManager.GetSysString(1464));
posY += 50;
btnRenameDeck = env->addButton(rect<s32>(350 * xScale, posY * yScale, 450 * xScale, (posY + 40) * yScale), wDeckManage, BUTTON_RENAME_DECK, dataManager.GetSysString(1465));
posY += 50;
btnDMDeleteDeck = env->addButton(rect<s32>(350 * xScale, posY * yScale, 450 * xScale, (posY + 40) * yScale), wDeckManage, BUTTON_DELETE_DECK_DM, dataManager.GetSysString(1466));
posY += 50;
btnMoveDeck = env->addButton(rect<s32>(350 * xScale, posY * yScale, 450 * xScale, (posY + 40) * yScale), wDeckManage, BUTTON_MOVE_DECK, dataManager.GetSysString(1467));
posY += 50;
btnCopyDeck = env->addButton(rect<s32>(350 * xScale, posY * yScale, 450 * xScale, (posY + 40) * yScale), wDeckManage, BUTTON_COPY_DECK, dataManager.GetSysString(1468));
posY += 60;
cbLFList = CAndroidGUIComboBox::addAndroidComboBox(env, rect<s32>(350 * xScale, posY * yScale, 450 * xScale, (posY + 40) * yScale), wDeckManage, COMBOBOX_LFLIST);
for(unsigned int i = 0; i < deckManager._lfList.size(); ++i)
cbDBLFList->addItem(deckManager._lfList[i].listName);
cbLFList->addItem(deckManager._lfList[i].listName);
//deck manage query
wDMQuery = env->addWindow(rect<s32>(490 * xScale, 180 * yScale, 840 * xScale, 340 * yScale), false, dataManager.GetSysString(1460));
wDMQuery->getCloseButton()->setVisible(false);
wDMQuery->setVisible(false);
stDMMessage = env->addStaticText(L"", rect<s32>(20 * xScale, 25 * yScale, 290 * xScale, 45 * yScale), false, false, wDMQuery);
stDMMessage2 = env->addStaticText(L"", rect<s32>(20 * xScale, 50 * yScale, 330 * xScale, 90 * yScale), false, false, wDMQuery, -1, true);
stDMMessage2->setTextAlignment(irr::gui::EGUIA_CENTER, irr::gui::EGUIA_CENTER);
ebDMName = CAndroidGUIEditBox::addAndroidEditBox(L"", true, env, rect<s32>(20 * xScale, 50 * yScale, 330 * xScale, 90 * yScale), wDMQuery, -1);
ebDMName->setTextAlignment(irr::gui::EGUIA_CENTER, irr::gui::EGUIA_CENTER);
cbDMCategory = CAndroidGUIComboBox::addAndroidComboBox(env, rect<s32>(20 * xScale, 50 * yScale, 330 * xScale, 90 * yScale), wDMQuery, -1);
stDMMessage2->setVisible(false);
ebDMName->setVisible(false);
cbDMCategory->setVisible(false);
cbDMCategory->setMaxSelectionRows(10);
btnDMOK = env->addButton(rect<s32>(70 * xScale, 100 * yScale, 160 * xScale, 150 * yScale), wDMQuery, BUTTON_DM_OK, dataManager.GetSysString(1211));
btnDMCancel = env->addButton(rect<s32>(180 * xScale, 100 * yScale, 270 * xScale, 150 * yScale), wDMQuery, BUTTON_DM_CANCEL, dataManager.GetSysString(1212));
stDBCategory = env->addStaticText(dataManager.GetSysString(1300), rect<s32>(10 * xScale, 9 * yScale, 100 * xScale, 29 * yScale), false, false, wDeckEdit);
cbDBCategory = CAndroidGUIComboBox::addAndroidComboBox(env, rect<s32>(80 * xScale, 5 * yScale, 220 * xScale, 30 * yScale), wDeckEdit, COMBOBOX_DBCATEGORY);
cbDBCategory->setMaxSelectionRows(15);
stDeck = env->addStaticText(dataManager.GetSysString(1301), rect<s32>(10 * xScale, 39 * yScale, 100 * xScale, 59 * yScale), false, false, wDeckEdit);
cbDBDecks = CAndroidGUIComboBox::addAndroidComboBox(env, rect<s32>(80 * xScale, 35 * yScale, 220 * xScale, 60 * yScale), wDeckEdit, COMBOBOX_DBDECKS);
cbDBDecks->setMaxSelectionRows(15);
btnSaveDeck = env->addButton(rect<s32>(225 * xScale, 35 * yScale, 290 * xScale, 60 * yScale), wDeckEdit, BUTTON_SAVE_DECK, dataManager.GetSysString(1302));
ebDeckname = CAndroidGUIEditBox::addAndroidEditBox(L"", true, env, rect<s32>(80 * xScale, 65 * yScale, 220 * xScale, 90 * yScale), wDeckEdit, -1);
ebDeckname->setTextAlignment(irr::gui::EGUIA_CENTER, irr::gui::EGUIA_CENTER);
......@@ -660,21 +697,11 @@ bool Game::Initialize() {
btnSideSort->setVisible(false);
btnSideReload = env->addButton(rect<s32>(440 * xScale, 100 * yScale, 500 * xScale, 130 * yScale), 0, BUTTON_SIDE_RELOAD, dataManager.GetSysString(1309));
btnSideReload->setVisible(false);
btnRenameDeck = env->addButton(rect<s32>(75 * xScale, 95 * yScale, 125 * xScale, 116 * yScale), wDeckEdit, BUTTON_RENAME_DECK, dataManager.GetSysString(1362));
//
scrFilter = env->addScrollBar(false, recti(999 * xScale, 161 * yScale, 1019 * xScale, 629 * yScale), 0, SCROLL_FILTER);
scrFilter->setLargeStep(10);
scrFilter->setSmallStep(1);
scrFilter->setVisible(false);
//rename deck
wRenameDeck = env->addWindow(rect<s32>(490 * xScale, 180 * yScale, 840 * xScale, 340 * yScale), false, dataManager.GetSysString(1367));
wRenameDeck->getCloseButton()->setVisible(false);
wRenameDeck->setVisible(false);
env->addStaticText(dataManager.GetSysString(1280), rect<s32>(20 * xScale, 25 * yScale, 290 * xScale, 45 * yScale), false, false, wRenameDeck);
ebREName = CAndroidGUIEditBox::addAndroidEditBox(L"", true, env, rect<s32>(20 * xScale, 50 * yScale, 330 * xScale, 90 * yScale), wRenameDeck, -1);
ebREName->setTextAlignment(irr::gui::EGUIA_CENTER, irr::gui::EGUIA_CENTER);
btnREYes = env->addButton(rect<s32>(70 * xScale, 100 * yScale, 160 * xScale, 150 * yScale), wRenameDeck, BUTTON_RENAME_DECK_SAVE, dataManager.GetSysString(1341));
btnRENo = env->addButton(rect<s32>(180 * xScale, 100 * yScale, 270 * xScale, 150 * yScale), wRenameDeck, BUTTON_RENAME_DECK_CANCEL, dataManager.GetSysString(1212));
//sort type
wSort = env->addStaticText(L"", rect<s32>(930 * xScale, 132 * yScale, 1020 * xScale, 156 * yScale), true, false, 0, -1, true);
cbSortType = env->addComboBox(rect<s32>(10 * xScale, 2 * yScale, 85 * xScale, 22 * yScale), wSort, COMBOBOX_SORTTYPE);
......@@ -1251,9 +1278,44 @@ void Game::LoadExpansions() {
}
}
}
void Game::RefreshDeck(irr::gui::IGUIComboBox* cbDeck) {
void Game::RefreshCategoryDeck(irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck, bool selectlastused) {
cbCategory->clear();
cbCategory->addItem(dataManager.GetSysString(1450));
cbCategory->addItem(dataManager.GetSysString(1451));
cbCategory->addItem(dataManager.GetSysString(1452));
cbCategory->addItem(dataManager.GetSysString(1453));
FileSystem::TraversalDir(L"./deck", [cbCategory](const wchar_t* name, bool isdir) {
if(isdir) {
cbCategory->addItem(name);
}
});
cbCategory->setSelected(2);
if(selectlastused) {
for(size_t i = 0; i < cbCategory->getItemCount(); ++i) {
if(!wcscmp(cbCategory->getItem(i), gameConf.lastcategory)) {
cbCategory->setSelected(i);
break;
}
}
}
RefreshDeck(cbCategory, cbDeck);
if(selectlastused) {
for(size_t i = 0; i < cbDeck->getItemCount(); ++i) {
if(!wcscmp(cbDeck->getItem(i), gameConf.lastdeck)) {
cbDeck->setSelected(i);
break;
}
}
}
}
void Game::RefreshDeck(irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck) {
wchar_t catepath[256];
deckManager.GetCategoryPath(catepath, cbCategory->getSelected(), cbCategory->getText());
RefreshDeck(catepath, cbDeck);
}
void Game::RefreshDeck(const wchar_t* deckpath, irr::gui::IGUIComboBox* cbDeck) {
cbDeck->clear();
FileSystem::TraversalDir(L"./deck", [cbDeck](const wchar_t* name, bool isdir) {
FileSystem::TraversalDir(deckpath, [cbDeck](const wchar_t* name, bool isdir) {
if(!isdir && wcsrchr(name, '.') && !wcsncasecmp(wcsrchr(name, '.'), L".ydk", 4)) {
size_t len = wcslen(name);
wchar_t deckname[256];
......@@ -1262,12 +1324,6 @@ void Game::RefreshDeck(irr::gui::IGUIComboBox* cbDeck) {
cbDeck->addItem(deckname);
}
});
for(size_t i = 0; i < cbDeck->getItemCount(); ++i) {
if(!wcscmp(cbDeck->getItem(i), gameConf.lastdeck)) {
cbDeck->setSelected(i);
break;
}
}
}
void Game::RefreshReplay() {
lstReplayList->clear();
......@@ -1333,6 +1389,8 @@ void Game::LoadConfig() {
gameConf.textfontsize = 16;
gameConf.nickname[0] = 0;
gameConf.gamename[0] = 0;
gameConf.bot_deck_path[0] = 0;
gameConf.lastcategory[0] = 0;
BufferIO::DecodeUTF8(android::getLastDeck(appMain).c_str(), wstr);
BufferIO::CopyWStr(wstr, gameConf.lastdeck, 64);
irr:os::Printer::log(android::getFontPath(appMain).c_str());
......
Classes/gframe/game.h
View file @ 16bccfc7
......@@ -23,10 +23,12 @@ struct Config {
wchar_t lastport[10];
wchar_t nickname[20];
wchar_t gamename[20];
wchar_t lastcategory[64];
wchar_t lastdeck[64];
wchar_t textfont[256];
wchar_t numfont[256];
wchar_t roompass[20];
wchar_t bot_deck_path[64];
//settings
int chkMAutoPos;
int chkSTAutoPos;
......@@ -119,7 +121,9 @@ public:
void InitStaticText(irr::gui::IGUIStaticText* pControl, u32 cWidth, u32 cHeight, irr::gui::CGUITTFont* font, const wchar_t* text);
void SetStaticText(irr::gui::IGUIStaticText* pControl, u32 cWidth, irr::gui::CGUITTFont* font, const wchar_t* text, u32 pos = 0);
void LoadExpansions();
void RefreshDeck(irr::gui::IGUIComboBox* cbDeck);
void RefreshCategoryDeck(irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck, bool selectlastused = true);
void RefreshDeck(irr::gui::IGUIComboBox* cbCategory, irr::gui::IGUIComboBox* cbDeck);
void RefreshDeck(const wchar_t* deckpath, irr::gui::IGUIComboBox* cbDeck);
void RefreshReplay();
void RefreshSingleplay();
void RefreshBot();
......@@ -302,6 +306,7 @@ public:
irr::gui::IGUIStaticText* stHostPrepDuelist[4];
irr::gui::IGUICheckBox* chkHostPrepReady[4];
irr::gui::IGUIButton* btnHostPrepKick[4];
irr::gui::IGUIComboBox* cbCategorySelect;
irr::gui::IGUIComboBox* cbDeckSelect;
irr::gui::IGUIStaticText* stHostPrepRule;
irr::gui::IGUIStaticText* stHostPrepOB;
......@@ -427,8 +432,9 @@ public:
irr::gui::IGUIButton* btnEP;
//deck edit
irr::gui::IGUIStaticText* wDeckEdit;
irr::gui::IGUIComboBox* cbDBLFList;
irr::gui::IGUIComboBox* cbDBCategory;
irr::gui::IGUIComboBox* cbDBDecks;
irr::gui::IGUIButton* btnManageDeck;
irr::gui::IGUIButton* btnClearDeck;
irr::gui::IGUIButton* btnSortDeck;
irr::gui::IGUIButton* btnShuffleDeck;
......@@ -440,7 +446,7 @@ public:
irr::gui::IGUIButton* btnSideSort;
irr::gui::IGUIButton* btnSideReload;
irr::gui::IGUIEditBox* ebDeckname;
irr::gui::IGUIStaticText* stBanlist;
irr::gui::IGUIStaticText* stDBCategory;
irr::gui::IGUIStaticText* stDeck;
irr::gui::IGUIStaticText* stCategory;
irr::gui::IGUIStaticText* stLimit;
......@@ -451,12 +457,26 @@ public:
irr::gui::IGUIStaticText* stStar;
irr::gui::IGUIStaticText* stSearch;
irr::gui::IGUIStaticText* stScale;
//deck rename
//deck manage
irr::gui::IGUIWindow* wDeckManage;
irr::gui::IGUIListBox* lstCategories;
irr::gui::IGUIListBox* lstDecks;
irr::gui::IGUIButton* btnNewCategory;
irr::gui::IGUIButton* btnRenameCategory;
irr::gui::IGUIButton* btnDeleteCategory;
irr::gui::IGUIButton* btnNewDeck;
irr::gui::IGUIButton* btnRenameDeck;
irr::gui::IGUIWindow* wRenameDeck;
irr::gui::IGUIEditBox* ebREName;
irr::gui::IGUIButton* btnREYes;
irr::gui::IGUIButton* btnRENo;
irr::gui::IGUIButton* btnDMDeleteDeck;
irr::gui::IGUIButton* btnMoveDeck;
irr::gui::IGUIButton* btnCopyDeck;
irr::gui::IGUIWindow* wDMQuery;
irr::gui::IGUIStaticText* stDMMessage;
irr::gui::IGUIStaticText* stDMMessage2;
irr::gui::IGUIEditBox* ebDMName;
irr::gui::IGUIComboBox* cbDMCategory;
irr::gui::IGUIButton* btnDMOK;
irr::gui::IGUIButton* btnDMCancel;
irr::gui::IGUIComboBox* cbLFList;
//filter
irr::gui::IGUIStaticText* wFilter;
irr::gui::IGUIScrollBar* scrFilter;
......@@ -568,6 +588,7 @@ extern Game* mainGame;
#define CHECKBOX_HP_READY 125
#define BUTTON_HP_READY 126
#define BUTTON_HP_NOTREADY 127
#define COMBOBOX_HP_CATEGORY 128
#define LISTBOX_REPLAY_LIST 130
#define BUTTON_LOAD_REPLAY 131
#define BUTTON_CANCEL_REPLAY 132
......@@ -656,8 +677,8 @@ extern Game* mainGame;
#define BUTTON_CARD_DISP_OK 296
#define BUTTON_SURRENDER_YES 297
#define BUTTON_SURRENDER_NO 298
#define COMBOBOX_DBLFLIST 301
#define BUTTON_MANAGE_DECK 300
#define COMBOBOX_DBCATEGORY 301
#define COMBOBOX_DBDECKS 302
#define BUTTON_CLEAR_DECK 303
#define BUTTON_SAVE_DECK 304
......@@ -682,13 +703,26 @@ extern Game* mainGame;
#define BUTTON_MARKERS_OK 323
#define COMBOBOX_SORTTYPE 324
#define WINDOW_DECK_MANAGE 330
#define BUTTON_NEW_CATEGORY 331
#define BUTTON_RENAME_CATEGORY 332
#define BUTTON_DELETE_CATEGORY 333
#define BUTTON_NEW_DECK 334
#define BUTTON_RENAME_DECK 335
#define BUTTON_DELETE_DECK_DM 336
#define BUTTON_MOVE_DECK 337
#define BUTTON_COPY_DECK 338
#define LISTBOX_CATEGORIES 339
#define LISTBOX_DECKS 340
#define BUTTON_DM_OK 341
#define BUTTON_DM_CANCEL 342
#define COMBOBOX_LFLIST 349
#define CHECKBOX_AUTO_SEARCH 360
#define CHECKBOX_DRAW_FIELD_SPELL 361
#define CHECKBOX_MULTI_KEYWORDS 372
#define CHECKBOX_PREFER_EXPANSION 373
#define CHECKBOX_DISABLE_CHAT 364
//ygomobile function
#define BUTTON_RENAME_DECK 365
#define BUTTON_RENAME_DECK_SAVE 366
#define BUTTON_RENAME_DECK_CANCEL 367
#define CHECKBOX_QUICK_ANIMATION 369
#define SCROLL_TAB_HELPER 370
#define SCROLL_TAB_SYSTEM 371
......
Classes/gframe/menu_handler.cpp
View file @ 16bccfc7
......@@ -11,6 +11,8 @@
namespace ygo {
void UpdateDeck() {
BufferIO::CopyWStr(mainGame->cbCategorySelect->getItem(mainGame->cbCategorySelect->getSelected()),
mainGame->gameConf.lastcategory, 64);
BufferIO::CopyWStr(mainGame->cbDeckSelect->getItem(mainGame->cbDeckSelect->getSelected()),
mainGame->gameConf.lastdeck, 64);
......@@ -52,7 +54,6 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
break;
}
switch(event.GUIEvent.EventType) {
//dont merge these cases
case irr::gui::EGET_BUTTON_CLICKED: {
switch(id) {
case BUTTON_MODE_EXIT: {
......@@ -180,18 +181,20 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
}
case BUTTON_HP_READY: {
mainGame->soundEffectPlayer->doPressButton();
if(mainGame->cbDeckSelect->getSelected() == -1 ||
!deckManager.LoadDeck(mainGame->cbDeckSelect->getItem(mainGame->cbDeckSelect->getSelected()))) {
if(mainGame->cbCategorySelect->getSelected() == -1 || mainGame->cbDeckSelect->getSelected() == -1 ||
!deckManager.LoadDeck(mainGame->cbCategorySelect, mainGame->cbDeckSelect)) {
break;
}
UpdateDeck();
DuelClient::SendPacketToServer(CTOS_HS_READY);
mainGame->cbCategorySelect->setEnabled(false);
mainGame->cbDeckSelect->setEnabled(false);
break;
}
case BUTTON_HP_NOTREADY: {
mainGame->soundEffectPlayer->doPressButton();
DuelClient::SendPacketToServer(CTOS_HS_NOTREADY);
mainGame->cbCategorySelect->setEnabled(true);
mainGame->cbDeckSelect->setEnabled(true);
break;
}
......@@ -295,42 +298,6 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
mainGame->ShowElement(mainGame->wMainMenu);
break;
}
case BUTTON_EXPORT_DECK: {
if(mainGame->lstReplayList->getSelected() == -1)
break;
Replay replay;
wchar_t ex_filename[256];
wchar_t namebuf[4][20];
wchar_t filename[256];
myswprintf(ex_filename, L"%ls", mainGame->lstReplayList->getListItem(mainGame->lstReplayList->getSelected()));
if(!replay.OpenReplay(ex_filename))
break;
const ReplayHeader& rh = replay.pheader;
if(rh.flag & REPLAY_SINGLE_MODE)
break;
int max = (rh.flag & REPLAY_TAG) ? 4 : 2;
//player name
for(int i = 0; i < max; ++i)
replay.ReadName(namebuf[i]);
//skip pre infos
for(int i = 0; i < 4; ++i)
replay.ReadInt32();
//deck
for(int i = 0; i < max; ++i) {
int main = replay.ReadInt32();
Deck tmp_deck;
for(int j = 0; j < main; ++j)
tmp_deck.main.push_back(dataManager.GetCodePointer(replay.ReadInt32()));
int extra = replay.ReadInt32();
for(int j = 0; j < extra; ++j)
tmp_deck.extra.push_back(dataManager.GetCodePointer(replay.ReadInt32()));
myswprintf(filename, L"%ls %ls", ex_filename, namebuf[i]);
deckManager.SaveDeck(tmp_deck, filename);
}
mainGame->stACMessage->setText(dataManager.GetSysString(1335));
mainGame->PopupElement(mainGame->wACMessage, 20);
break;
}
//TEST BOT MODE
case BUTTON_BOT_START: {
int sel = mainGame->lstBotList->getSelected();
......@@ -417,11 +384,12 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
break;
}
case BUTTON_DECK_EDIT: {
mainGame->RefreshCategoryDeck(mainGame->cbDBCategory, mainGame->cbDBDecks);
mainGame->soundEffectPlayer->doPressButton();
mainGame->RefreshDeck(mainGame->cbDBDecks);
if(mainGame->cbDBDecks->getSelected() != -1)
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()));
if(mainGame->cbDBCategory->getSelected() != -1 && mainGame->cbDBDecks->getSelected() != -1) {
deckManager.LoadDeck(mainGame->cbDBCategory, mainGame->cbDBDecks);
mainGame->ebDeckname->setText(L"");
}
mainGame->HideElement(mainGame->wMainMenu);
mainGame->deckBuilder.Initialize();
break;
......@@ -574,6 +542,23 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
}
break;
}
case irr::gui::EGET_COMBO_BOX_CHANGED: {
switch(id) {
case COMBOBOX_HP_CATEGORY: {
int catesel = mainGame->cbCategorySelect->getSelected();
if(catesel == 3) {
catesel = 2;
mainGame->cbCategorySelect->setSelected(2);
}
if(catesel >= 0) {
mainGame->RefreshDeck(mainGame->cbCategorySelect, mainGame->cbDeckSelect);
mainGame->cbDeckSelect->setSelected(0);
}
break;
}
}
break;
}
case irr::gui::EGET_CHECKBOX_CHANGED: {
switch(id) {
case CHECKBOX_HP_READY: {
......@@ -581,16 +566,18 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
break;
mainGame->env->setFocus(mainGame->wHostPrepare);
if(static_cast<irr::gui::IGUICheckBox*>(caller)->isChecked()) {
if(mainGame->cbDeckSelect->getSelected() == -1 ||
!deckManager.LoadDeck(mainGame->cbDeckSelect->getItem(mainGame->cbDeckSelect->getSelected()))) {
if(mainGame->cbCategorySelect->getSelected() == -1 || mainGame->cbDeckSelect->getSelected() == -1 ||
!deckManager.LoadDeck(mainGame->cbCategorySelect, mainGame->cbDeckSelect)) {
static_cast<irr::gui::IGUICheckBox*>(caller)->setChecked(false);
break;
}
UpdateDeck();
DuelClient::SendPacketToServer(CTOS_HS_READY);
mainGame->cbCategorySelect->setEnabled(false);
mainGame->cbDeckSelect->setEnabled(false);
} else {
DuelClient::SendPacketToServer(CTOS_HS_NOTREADY);
mainGame->cbCategorySelect->setEnabled(true);
mainGame->cbDeckSelect->setEnabled(true);
}
break;
......
Classes/gframe/myfilesystem.h
View file @ 16bccfc7
......@@ -50,6 +50,37 @@ public:
return MakeDir(wdir);
}
static bool Rename(const wchar_t* woldname, const wchar_t* wnewname) {
return MoveFileW(woldname, wnewname);
}
static bool Rename(const char* oldname, const char* newname) {
wchar_t woldname[1024];
wchar_t wnewname[1024];
BufferIO::DecodeUTF8(oldname, woldname);
BufferIO::DecodeUTF8(newname, wnewname);
return Rename(woldname, wnewname);
}
static bool DeleteDir(const wchar_t* wdir) {
wchar_t pdir[256];
BufferIO::CopyWStr(wdir, pdir, 256);
pdir[wcslen(wdir) + 1] = 0;
SHFILEOPSTRUCTW lpFileOp;
lpFileOp.hwnd = NULL;
lpFileOp.wFunc = FO_DELETE;
lpFileOp.pFrom = pdir;
lpFileOp.pTo = 0;
lpFileOp.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT;
return SHFileOperationW(&lpFileOp) == 0;
}
static bool DeleteDir(const char* dir) {
wchar_t wdir[1024];
BufferIO::DecodeUTF8(dir, wdir);
return DeleteDir(wdir);
}
static void TraversalDir(const wchar_t* wpath, const std::function<void(const wchar_t*, bool)>& cb) {
wchar_t findstr[1024];
wcscpy(findstr, wpath);
......@@ -59,7 +90,8 @@ public:
if(fh == INVALID_HANDLE_VALUE)
return;
do {
cb(fdataw.cFileName, (fdataw.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY));
if(mywcsncasecmp(fdataw.cFileName, L".", 1) && mywcsncasecmp(fdataw.cFileName, L"..", 2))
cb(fdataw.cFileName, (fdataw.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY));
} while(FindNextFileW(fh, &fdataw));
FindClose(fh);
}
......@@ -110,6 +142,48 @@ public:
BufferIO::EncodeUTF8(wdir, dir);
return MakeDir(dir);
}
static bool Rename(const wchar_t* woldname, const wchar_t* wnewname) {
char oldname[1024];
char newname[1024];
BufferIO::EncodeUTF8(woldname, oldname);
BufferIO::EncodeUTF8(wnewname, newname);
return Rename(oldname, newname);
}
static bool Rename(const char* oldname, const char* newname) {
return rename(oldname, newname) == 0;
}
static bool DeleteDir(const wchar_t* wdir) {
char dir[1024];
BufferIO::EncodeUTF8(wdir, dir);
return DeleteDir(dir);
}
static bool DeleteDir(const char* dir) {
bool success = true;
TraversalDir(dir, [dir, &success](const char *name, bool isdir) {
if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
return;
char full_path[256];
sprintf(full_path, "%s/%s", dir, name);
if (isdir)
{
if(!DeleteDir(full_path))
success = false;
}
else
{
if(unlink(full_path) != 0)
success = false;
}
});
if (rmdir(dir) != 0)
success = false;
return success;
}
struct file_unit {
std::string filename;
......@@ -132,6 +206,8 @@ public:
stat(fname, &fileStat);
funit.filename = std::string(dirp->d_name);
funit.is_dir = S_ISDIR(fileStat.st_mode);
if(funit.is_dir && (strcmp(dirp->d_name, ".") == 0 || strcmp(dirp->d_name, "..") == 0))
continue;
file_list.push_back(funit);
}
closedir(dir);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment