void GameStateCutscene::logic() {
if (!initialized) {
if (settings->music_volume > 0 && !music.empty()) {
// restart music so that game devs can sync with cutscene playback
snd->stopMusic();
snd->loadMusic(music);
}
initialized = true;
}
if (scenes.empty() || scene_index >= scenes.size()) {
if (game_slot != -1) {
showLoading();
GameStatePlay *gsp = new GameStatePlay();
gsp->resetGame();
save_load->setGameSlot(game_slot);
save_load->loadGame();
setRequestedGameState(gsp);
return;
}
// return to previous gamestate
showLoading();
setRequestedGameState(previous_gamestate);
return;
}
// status is processed after we render this scene
if (scene_index < scenes.size())
status = scenes[scene_index]->logic();
}
void GameStateConfigBase::logicAccept() {
if (setMods()) {
snd->unloadMusic();
reload_music = true;
reload_backgrounds = true;
delete mods;
mods = new ModManager(NULL);
loadTilesetSettings();
PREV_SAVE_SLOT = -1;
}
delete msg;
msg = new MessageEngine();
inpt->saveKeyBindings();
inpt->setKeybindNames();
loadMiscSettings();
setStatNames();
refreshFont();
if ((ENABLE_JOYSTICK) && (inpt->getNumJoysticks() > 0)) {
inpt->initJoystick();
}
cleanup();
showLoading();
// need to delete the "Loading..." message here, as we're recreating our render context
if (loading_tip) {
delete loading_tip;
loading_tip = NULL;
}
render_device->createContext();
saveSettings();
setRequestedGameState(new GameStateTitle());
}
void CoverWidget::clearCover() {
currentPosition = 0;
showLoading();
// clear classification
coverClass->set_from_icon_name("gtk-yes", Gtk::ICON_SIZE_SMALL_TOOLBAR);
}
void BaseLayer::onEnter()
{
CCLayer::onEnter();
//注册通知处理函数
if (!_notificationName.empty())
{
CCNotificationCenter::sharedNotificationCenter()->addObserver(this, callfuncO_selector(BaseLayer::receiveBaseMsg), _notificationName.c_str(), NULL);
}
showLoading();
}
void GameStateLoad::logicLoading() {
// load an existing game
inpt->lock_all = true;
delete_items = false;
showLoading();
GameStatePlay* play = new GameStatePlay();
play->resetGame();
save_load->setGameSlot(game_slots[selected_slot]->id);
save_load->loadGame();
loaded = true;
loading = false;
setRequestedGameState(play);
}
void GameStateConfigBase::logicCancel() {
inpt->lock[CANCEL] = true;
loadSettings();
inpt->loadKeyBindings();
delete msg;
msg = new MessageEngine();
loadMiscSettings();
setStatNames();
update();
cleanup();
render_device->windowResize();
render_device->updateTitleBar();
showLoading();
setRequestedGameState(new GameStateTitle());
}
void FileBrowserDialog::fetchDirents(bool force_refresh)
{
if (repo_.encrypted && !data_mgr_->isRepoPasswordSet(repo_.id)) {
SetRepoPasswordDialog password_dialog(repo_, this);
if (password_dialog.exec() != QDialog::Accepted) {
reject();
return;
} else {
data_mgr_->setRepoPasswordSet(repo_.id);
}
}
if (!force_refresh) {
QList<SeafDirent> dirents;
if (data_mgr_->getDirents(repo_.id, current_path_, &dirents)) {
updateTable(dirents);
return;
}
}
showLoading();
data_mgr_->getDirentsFromServer(repo_.id, current_path_);
}
void GameStatePlay::checkTeleport() {
// both map events and player powers can cause teleportation
if (mapr->teleportation || pc->stats.teleportation) {
mapr->collider.unblock(pc->stats.pos.x, pc->stats.pos.y);
if (mapr->teleportation) {
mapr->cam.x = pc->stats.pos.x = mapr->teleport_destination.x;
mapr->cam.y = pc->stats.pos.y = mapr->teleport_destination.y;
}
else {
mapr->cam.x = pc->stats.pos.x = pc->stats.teleport_destination.x;
mapr->cam.y = pc->stats.pos.y = pc->stats.teleport_destination.y;
}
// if we're not changing map, move allies to a the player's new position
// when changing maps, enemies->handleNewMap() does something similar to this
if (mapr->teleport_mapname == "") {
FPoint spawn_pos = mapr->collider.get_random_neighbor(floor(pc->stats.pos), 1, false);
for (unsigned int i=0; i < enemies->enemies.size(); i++) {
if(enemies->enemies[i]->stats.hero_ally && enemies->enemies[i]->stats.alive) {
mapr->collider.unblock(enemies->enemies[i]->stats.pos.x, enemies->enemies[i]->stats.pos.y);
enemies->enemies[i]->stats.pos = spawn_pos;
mapr->collider.block(enemies->enemies[i]->stats.pos.x, enemies->enemies[i]->stats.pos.y, true);
}
}
}
// process intermap teleport
if (mapr->teleportation && mapr->teleport_mapname != "") {
std::string teleport_mapname = mapr->teleport_mapname;
mapr->teleport_mapname = "";
inpt->lock_all = (teleport_mapname == "maps/spawn.txt");
mapr->executeOnMapExitEvents();
showLoading();
mapr->load(teleport_mapname);
setLoadingFrame();
enemies->handleNewMap();
hazards->handleNewMap();
loot->handleNewMap();
powers->handleNewMap(&mapr->collider);
menu->enemy->handleNewMap();
npcs->handleNewMap();
menu->npc->setNPC(NULL);
menu->vendor->setNPC(NULL);
menu->talker->setNPC(NULL);
menu->stash->visible = false;
menu->mini->prerender(&mapr->collider, mapr->w, mapr->h);
npc_id = nearest_npc = -1;
// store this as the new respawn point (provided the tile is open)
if (mapr->collider.is_valid_position(pc->stats.pos.x, pc->stats.pos.y, MOVEMENT_NORMAL, true)) {
mapr->respawn_map = teleport_mapname;
mapr->respawn_point = pc->stats.pos;
}
else {
logError("GameStatePlay: Spawn position (%d, %d) is blocked.", static_cast<int>(pc->stats.pos.x), static_cast<int>(pc->stats.pos.y));
}
// return to title (permadeath) OR auto-save
if (pc->stats.permadeath && pc->stats.corpse) {
removeSaveDir(save_load->getGameSlot());
snd->stopMusic();
delete requestedGameState;
requestedGameState = new GameStateTitle();
}
else if (SAVE_ONLOAD) {
save_load->saveGame();
}
}
mapr->collider.block(pc->stats.pos.x, pc->stats.pos.y, false);
pc->stats.teleportation = false; // teleport spell
}
if (mapr->teleport_mapname == "") mapr->teleportation = false;
}
sidl_bool
impl_sidl_DLL_loadLibrary(
/* in */ sidl_DLL self,
/* in */ const char* uri,
/* in */ sidl_bool loadGlobally,
/* in */ sidl_bool loadLazy,
/* out */ sidl_BaseInterface *_ex)
{
*_ex = 0;
{
/* DO-NOT-DELETE splicer.begin(sidl.DLL.loadLibrary) */
struct sidl_DLL__data *data = sidl_DLL__get_data(self);
int ok = FALSE;
lt_dlhandle handle = NULL;
char* dllfile = NULL;
char* dllname = NULL;
if (data->d_library_handle) {
impl_sidl_DLL_unloadLibrary(self,_ex);
}
if (sidl_String_equals(uri, "main:")) {
dllfile = NULL;
dllname = sidl_String_strdup(uri);
#if !defined(PIC) && defined(SIDL_PURE_STATIC_RUNTIME)
data->d_isGlobal = TRUE;
data->d_isLazy = FALSE;
data->d_library_handle = NULL;
data->d_library_name = dllname;
return TRUE;
#endif
} else if (sidl_String_startsWith(uri, "lib:")) {
char* dll = sidl_String_substring(uri, 4);
dllfile = sidl_String_concat3("lib", dll, ".la");
dllname = sidl_String_strdup(uri);
sidl_String_free(dll);
} else if (sidl_String_startsWith(uri, "file:")) {
dllfile = sidl_String_substring(uri, 5);
dllname = sidl_String_strdup(uri);
#ifdef HAVE_LIBWWW
} else if (sidl_String_startsWith(uri, "ftp:")) {
dllfile = url_to_local_file(uri);
dllname = sidl_String_strdup(uri);
} else if (sidl_String_startsWith(uri, "http:")) {
dllfile = url_to_local_file(uri);
dllname = sidl_String_strdup(uri);
#endif
} else {
dllfile = sidl_String_strdup(uri);
dllname = sidl_String_concat2("file:", uri);
}
if (s_sidl_debug_dlopen) showLoading(dllfile);
check_lt_initialized();
#if defined(PIC) || !defined(SIDL_PURE_STATIC_RUNTIME)
handle = lt_dlopen(dllfile, loadGlobally, loadLazy);
#else
handle = NULL;
#endif
if (s_sidl_debug_dlopen) showLoadResult((void *)handle);
sidl_String_free(dllfile);
if (handle) {
ok = TRUE;
data->d_library_handle = handle;
data->d_library_name = dllname;
data->d_isLazy = loadLazy;
data->d_isGlobal = loadGlobally;
} else {
ok = FALSE;
sidl_String_free(dllname);
}
return ok;
/* DO-NOT-DELETE splicer.end(sidl.DLL.loadLibrary) */
}
}
void BackupDialog::addBackupPressed()
{
showLoading(true);
emit addBackup();
}
void GameStateLoad::logic() {
if (inpt->window_resized)
refreshWidgets();
for (size_t i = 0; i < game_slots.size(); ++i) {
if (static_cast<int>(i) == selected_slot) {
if (game_slots[i]->preview_turn_ticks > 0)
game_slots[i]->preview_turn_ticks--;
if (game_slots[i]->preview_turn_ticks == 0) {
game_slots[i]->preview_turn_ticks = GAMESLOT_PREVIEW_TURN_DURATION;
game_slots[i]->stats.direction++;
if (game_slots[i]->stats.direction > 7)
game_slots[i]->stats.direction = 0;
}
}
game_slots[i]->preview.logic();
}
if (!confirm->visible) {
tablist.logic(true);
if (button_exit->checkClick() || (inpt->pressing[CANCEL] && !inpt->lock[CANCEL])) {
inpt->lock[CANCEL] = true;
showLoading();
setRequestedGameState(new GameStateTitle());
}
if (loading_requested) {
loading = true;
loading_requested = false;
logicLoading();
}
bool outside_scrollbar = true;
if (button_new->checkClick()) {
// create a new game
showLoading();
GameStateNew* newgame = new GameStateNew();
newgame->game_slot = (game_slots.empty() ? 1 : game_slots.back()->id+1);
delete_items = false;
setRequestedGameState(newgame);
}
else if (button_load->checkClick()) {
loading_requested = true;
}
else if (button_delete->checkClick()) {
// Display pop-up to make sure save should be deleted
confirm->visible = true;
confirm->render();
}
else if (game_slots.size() > 0) {
Rect scroll_area = slot_pos[0];
scroll_area.h = slot_pos[0].h * game_slot_max;
if (isWithinRect(scroll_area, inpt->mouse)) {
if (inpt->pressing[MAIN1] && !inpt->lock[MAIN1]) {
for (int i=0; i<visible_slots; ++i) {
if (isWithinRect(slot_pos[i], inpt->mouse)) {
inpt->lock[MAIN1] = true;
setSelectedSlot(i + scroll_offset);
updateButtons();
break;
}
}
}
else if (inpt->scroll_up) {
scrollUp();
}
else if (inpt->scroll_down) {
scrollDown();
}
}
else if (has_scroll_bar) {
switch (scrollbar->checkClick(inpt->mouse.x, inpt->mouse.y)) {
case 1:
scrollUp();
outside_scrollbar = false;
break;
case 2:
scrollDown();
outside_scrollbar = false;
break;
case 3:
scroll_offset = scrollbar->getValue();
if (scroll_offset >= static_cast<int>(game_slots.size()) - visible_slots) {
scroll_offset = static_cast<int>(game_slots.size()) - visible_slots;
}
outside_scrollbar = false;
break;
default:
break;
}
}
if (outside_scrollbar && inpt->pressing[MAIN1] && !inpt->lock[MAIN1]) {
inpt->lock[MAIN1] = true;
setSelectedSlot(-1);
updateButtons();
}
// Allow characters to be navigateable via up/down keys
if (inpt->pressing[UP] && !inpt->lock[UP]) {
inpt->lock[UP] = true;
setSelectedSlot((selected_slot - 1 < 0) ? static_cast<int>(game_slots.size()) - 1 : selected_slot - 1);
scroll_offset = std::min(static_cast<int>(game_slots.size()) - visible_slots, selected_slot);
updateButtons();
}
else if (inpt->pressing[DOWN] && !inpt->lock[DOWN]) {
inpt->lock[DOWN] = true;
setSelectedSlot((selected_slot + 1 == static_cast<int>(game_slots.size())) ? 0 : selected_slot + 1);
scroll_offset = std::max(0, selected_slot-visible_slots+1);
updateButtons();
}
}
}
else if (confirm->visible) {
confirm->logic();
if (confirm->confirmClicked) {
removeSaveDir(game_slots[selected_slot]->id);
delete game_slots[selected_slot];
game_slots[selected_slot] = NULL;
game_slots.erase(game_slots.begin()+selected_slot);
visible_slots = (game_slot_max > static_cast<int>(game_slots.size()) ? static_cast<int>(game_slots.size()) : game_slot_max);
setSelectedSlot(-1);
while (scroll_offset + visible_slots > static_cast<int>(game_slots.size())) {
scroll_offset--;
}
updateButtons();
confirm->visible = false;
confirm->confirmClicked = false;
}
}
}
Playlist::Playlist(PlaylistWidget::ListTypes listType, QString title, quint64 hash, QObject *parent) :
QObject(parent)
{
m_listType = listType;
m_sTitle = title;
m_bCustomTitle = false;
m_Settings = Settings::instance();
connect(m_Settings, SIGNAL(changed()), SLOT(onSettingsChanged()));
m_bLoadingState = false;
m_bShuffleList = m_Settings->getValue("player/shuffle").toInt() > 1 ? true : false;
m_LastTrack = 0;
m_bLoadMeta = false;
m_bUseMeta = false;
m_bTitleByContent = m_Settings->getValue("playlist/tabs_by_content").toBool();
m_Auth = Auth::instance();
connect(m_Auth, SIGNAL(authComplete()), SLOT(update()));
// Set hash
if(hash == 0) {
QDateTime *time = new QDateTime(QDateTime::currentDateTime());
m_Hash = time->toMSecsSinceEpoch();
m_bNewly = true;
} else {
m_Hash = hash;
m_bNewly = false;
}
// Create playlist widget
m_listWidget = new PlaylistWidget(m_listType);
connect(this, SIGNAL(trackAdded()), m_listWidget, SLOT(trackAdded()));
connect(m_listWidget, SIGNAL(trackActivate(Track*)), SLOT(trackActivate(Track*)));
// Connect key events
connect(m_listWidget, SIGNAL(skQueue()), SLOT(addToQueue()));
connect(m_listWidget, SIGNAL(skRemove()), SLOT(removeTrack()));
connect(m_listWidget, SIGNAL(skDownload()), SLOT(downloadTrack()));
// Create object of parser
m_Parser = new Parser(this);
connect(m_Parser, SIGNAL(newTrack(Track*)), SLOT(addTrack(Track*)));
connect(m_Parser, SIGNAL(busy()), SLOT(parserBusy()));
connect(m_Parser, SIGNAL(free()), SLOT(parserFree()));
connect(m_Parser, SIGNAL(savePlaylist()), SLOT(save()));
connect(m_Parser, SIGNAL(busy()), m_listWidget, SLOT(showLoading()));
connect(m_Parser, SIGNAL(free()), m_listWidget, SLOT(hideLoading()));
// Create actions parser
m_vkActions = VkActions::instance();
connect(m_vkActions, SIGNAL(message(QString,QString)), SIGNAL(message(QString,QString)));
switch(m_listType) {
case PlaylistWidget::Search:
connect(m_listWidget, SIGNAL(searchChanged(QString)), SLOT(searchChanged(QString)));
connect(m_listWidget, SIGNAL(loadMore()), m_Parser, SLOT(loadMoreResults()));
break;
case PlaylistWidget::AudioLib:
connect(m_listWidget->friendsList(), SIGNAL(friendSelected(QString,QString,QString)), SLOT(librarySelected(QString,QString,QString)));
connect(m_listWidget, SIGNAL(refresh()), SLOT(refresh()));
break;
case PlaylistWidget::Suggestions:
connect(m_listWidget, SIGNAL(loadMore()), m_Parser, SLOT(loadMoreResults()));
connect(m_listWidget, SIGNAL(refresh()), SLOT(refresh()));
break;
case PlaylistWidget::DbSearch:
connect(m_listWidget, SIGNAL(searchChanged(QString)), SLOT(searchChanged(QString)));
connect(m_listWidget, SIGNAL(newTrack(Track*)), SLOT(addTrack(Track*)));
connect(m_listWidget, SIGNAL(clearList()), SLOT(clearList()));
break;
}
m_Model = new QStandardItemModel(this);
m_ProxyModel = new QSortFilterProxyModel(this);
m_ProxyModel->setSourceModel(m_Model);
m_ProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
m_ProxyModel->setFilterKeyColumn(2);
m_listWidget->setModel(m_ProxyModel);
connect(m_listWidget, SIGNAL(listSearchChanged(QString)), SLOT(setListSearch(QString)));
createMenus();
load();
if(type() == PlaylistWidget::AudioLib &&
m_bNewly &&
m_Settings->getValue("playlist/autoload_library").toBool()
)
librarySelected(m_Auth->vkId(), "0", tr("My Library"));
// Actions on newly created plalylists
if(m_bNewly) {
switch(m_listType) {
case PlaylistWidget::Search:
m_listWidget->focusOnSearch();
break;
case PlaylistWidget::AudioLib:
if(m_Settings->getValue("playlist/autoload_library").toBool())
librarySelected(m_Auth->vkId(), "0", tr("My Library"));
break;
case PlaylistWidget::Suggestions:
refresh();
break;
case PlaylistWidget::DbSearch:
// Unused
break;
}
}
}
void HtmlToolBarControl::onPageFinishLoading()
{
showLoading(false);
}
void HtmlToolBarControl::onPageStartLoading()
{
showLoading(true);
}
