Game Class Reference

#include <game.h>

Public Member Functions
	Game ()
	~Game ()
void	logic ()
void	slowLogic ()
void	handleInput ()
void	handleMove ()
void	changeMap (const std::string &mapName)
void	updateFrameRate (int fpsLimit)
Map *	getCurrentMap () const
const std::string &	getCurrentMapName () const
void	setValidSpeed ()
void	adjustPerfomance ()
void	resetAdjustLevel ()
void	setAdjustLevel (const int n)
bool	getValidSpeed () const
void	updateHistory (const SDL_Event &event)
void	checkKeys ()

Static Public Member Functions
static Game *	instance ()
static void	clearInstance ()
static void	videoResized (const int width, const int height)
static void	moveInDirection (const unsigned char direction)
static bool	createScreenshot (const std::string &prefix)
static void	addWatermark ()
static bool	saveScreenshot (SDL_Surface *const screenshot, const std::string &prefix)

Private Member Functions
void	clearKeysArray ()

Private Attributes
Map *	mCurrentMap
std::string	mMapName
bool	mValidSpeed
LastKey	mLastKeys [MAX_LASTKEYS]
time_t	mNextAdjustTime
int	mAdjustLevel
bool	mAdjustPerfomance
int	mLowerCounter
int	mPing
time_t	mTime
time_t	mTime2

Static Private Attributes
static Game *	mInstance = 0

Detailed Description

The main class responsible for running the game. The game starts after you have selected your character.

Definition at line 63 of file game.h.

Constructor & Destructor Documentation

Game()

Game::Game

(

)

Constructs the game, creating all the managers, handlers, engines and GUI windows that make up the game.

Definition at line 405 of file game.cpp.

           :
    mCurrentMap(nullptr),
    mMapName(""),
    mValidSpeed(true),
    mNextAdjustTime(cur_time + adjustDelay),
    mAdjustLevel(0),
    mAdjustPerfomance(config.getBoolValue("adjustPerfomance")),
    mLowerCounter(0),
    mPing(0),
    mTime(cur_time + 1),
    mTime2(cur_time + 10)
{
    touchManager.setInGame(true);
 
//    assert(!mInstance);
    if (mInstance != nullptr)
        logger->log("error: double game creation");
    mInstance = this;
 
    config.incValue("gamecount");
 
    disconnectedDialog = nullptr;
 
    // Create the viewport
    viewport = new Viewport;
    viewport->setSize(mainGraphics->mWidth, mainGraphics->mHeight);
    PlayerInfo::clear();
 
    emptyBeingSlot = new BeingSlot;
 
    BasicContainer2 *const top = static_cast<BasicContainer2*>(gui->getTop());
    if (top != nullptr)
        top->add(viewport);
    viewport->requestMoveToBottom();
 
    AnimatedSprite::setEnableCache(
        mainGraphics->getOpenGL() != RENDER_SOFTWARE &&
        config.getBoolValue("enableDelayedAnimations"));
 
    CompoundSprite::setEnableDelay(
        config.getBoolValue("enableCompoundSpriteDelay"));
 
    createGuiWindows();
    windowMenu = new WindowMenu(nullptr);
 
    if (windowContainer != nullptr)
        windowContainer->add(windowMenu);
 
#ifdef USE_OPENGL
    MapReader::loadEmptyAtlas();
#endif  // USE_OPENGL
 
    initEngines();
 
    chatWindow->postConnection();
    mailWindow->postConnection();
 
    // Initialize beings
    if (actorManager != nullptr)
        actorManager->setPlayer(localPlayer);
 
    gameHandler->ping(tick_time);
 
    if (setupWindow != nullptr)
        setupWindow->setInGame(true);
    clearKeysArray();
 
#ifdef TMWA_SUPPORT
    if (guildManager != nullptr && GuildManager::getEnableGuildBot())
        guildManager->requestGuildInfo();
#endif  // TMWA_SUPPORT
 
    settings.disableLoggingInGame = config.getBoolValue(
        "disableLoggingInGame");
}

References actorManager, BasicContainer2::add(), chatWindow, PlayerInfo::clear(), clearKeysArray(), config, createGuiWindows(), Settings::disableLoggingInGame, disconnectedDialog, emptyBeingSlot, gameHandler, Configuration::getBoolValue(), GuildManager::getEnableGuildBot(), Graphics::getOpenGL(), Gui::getTop(), gui, guildManager, Configuration::incValue(), initEngines(), MapReader::loadEmptyAtlas(), localPlayer, Logger::log(), logger, mailWindow, mainGraphics, Graphics::mHeight, mInstance, Graphics::mWidth, Net::GameHandler::ping(), ChatWindow::postConnection(), MailWindow::postConnection(), RENDER_SOFTWARE, GuildManager::requestGuildInfo(), Widget::requestMoveToBottom(), AnimatedSprite::setEnableCache(), CompoundSprite::setEnableDelay(), TouchManager::setInGame(), SetupWindow::setInGame(), ActorManager::setPlayer(), Widget::setSize(), settings, setupWindow, tick_time, top, touchManager, viewport, windowContainer, and windowMenu.

~Game()

Game::~Game

(

)

Destructor, cleans up the game.

Definition at line 481 of file game.cpp.

{
#ifdef USE_OPENGL
    MapReader::unloadEmptyAtlas();
#endif  // USE_OPENGL
 
    settings.disableLoggingInGame = false;
    touchManager.setInGame(false);
    config.write();
    serverConfig.write();
    resetAdjustLevel();
    destroyGuiWindows();
 
    AnimatedSprite::setEnableCache(false);
 
    delete2(actorManager)
    if (client->getState() != State::CHANGE_MAP)
        delete2(localPlayer)
    if (effectManager != nullptr)
        effectManager->clear();
    delete2(effectManager)
    delete2(particleEngine)
    delete2(viewport)
    delete2(mCurrentMap)
#ifdef TMWA_SUPPORT
    delete2(guildManager)
#endif  // TMWA_SUPPORT
#ifdef USE_MUMBLE
    delete2(mumbleManager)
#endif  // USE_MUMBLE
 
    delete2(crazyMoves)
    delete2(emptyBeingSlot)
 
    Being::clearCache();
    mInstance = nullptr;
    PlayerInfo::gameDestroyed();
}

References actorManager, State::CHANGE_MAP, EffectManager::clear(), Being::clearCache(), client, config, crazyMoves, delete2, destroyGuiWindows(), Settings::disableLoggingInGame, effectManager, emptyBeingSlot, PlayerInfo::gameDestroyed(), Client::getState(), guildManager, localPlayer, mCurrentMap, mInstance, particleEngine, resetAdjustLevel(), serverConfig, AnimatedSprite::setEnableCache(), TouchManager::setInGame(), settings, touchManager, MapReader::unloadEmptyAtlas(), viewport, and Configuration::write().

Member Function Documentation

addWatermark()

void Game::addWatermark ( )

static

Definition at line 520 of file game.cpp.

{
    if ((boldFont == nullptr) || !config.getBoolValue("addwatermark"))
        return;
 
    const Color &color1 = theme->getColor(ThemeColorId::TEXT, 255);
    const Color &color2 = theme->getColor(ThemeColorId::TEXT_OUTLINE, 255);
 
    boldFont->drawString(mainGraphics,
        color1,
        color2,
        settings.serverName,
        100, 50);
}

References boldFont, config, Font::drawString(), Configuration::getBoolValue(), Theme::getColor(), mainGraphics, Settings::serverName, settings, QuestType::TEXT, and theme.

Referenced by createScreenshot().

adjustPerfomance()

void Game::adjustPerfomance

(

)

Definition at line 782 of file game.cpp.

{
    FUNC_BLOCK("Game::adjustPerfomance", 1)
    const time_t time = cur_time;
    if (mNextAdjustTime <= adjustDelay)
    {
        mNextAdjustTime = time + adjustDelay;
    }
    else if (mNextAdjustTime < time)
    {
        mNextAdjustTime = time + adjustDelay;
 
        if (mAdjustLevel > 3 ||
            localPlayer == nullptr ||
            localPlayer->getHalfAway() ||
            settings.awayMode)
        {
            return;
        }
 
        int maxFps = WindowManager::getFramerate();
        if (maxFps != config.getIntValue("fpslimit"))
            return;
 
        if (maxFps == 0)
            maxFps = 30;
        else if (maxFps < 10)
            return;
 
        if (fps < maxFps - 10)
        {
            if (mLowerCounter < 2)
            {
                mLowerCounter ++;
                mNextAdjustTime = cur_time + 1;
                return;
            }
            mLowerCounter = 0;
            mAdjustLevel ++;
            switch (mAdjustLevel)
            {
                case 1:
                {
                    if (config.getBoolValue("beingopacity"))
                    {
                        config.setValue("beingopacity", false);
                        config.setSilent("beingopacity", true);
                        if (localChatTab != nullptr)
                        {
                            localChatTab->chatLog(
                                // TRANSLATORS: auto adjust settings message
                                _("Auto disable Show beings transparency"),
                                ChatMsgType::BY_SERVER,
                                IgnoreRecord_false,
                                TryRemoveColors_true);
                        }
                    }
                    else
                    {
                        mNextAdjustTime = time + 1;
                        mLowerCounter = 2;
                    }
                    break;
                }
                case 2:
                    if (ParticleEngine::emitterSkip < 4)
                    {
                        ParticleEngine::emitterSkip = 4;
                        if (localChatTab != nullptr)
                        {
                            localChatTab->chatLog(
                                // TRANSLATORS: auto adjust settings message
                                _("Auto lower Particle effects"),
                                ChatMsgType::BY_SERVER,
                                IgnoreRecord_false,
                                TryRemoveColors_true);
                        }
                    }
                    else
                    {
                        mNextAdjustTime = time + 1;
                        mLowerCounter = 2;
                    }
                    break;
                case 3:
                    if (!config.getBoolValue("alphaCache"))
                    {
                        config.setValue("alphaCache", true);
                        config.setSilent("alphaCache", false);
                        if (localChatTab != nullptr)
                        {
                            localChatTab->chatLog(
                                // TRANSLATORS: auto adjust settings message
                                _("Auto enable opacity cache"),
                                ChatMsgType::BY_SERVER,
                                IgnoreRecord_false,
                                TryRemoveColors_true);
                        }
                    }
                    break;
                default:
                    break;
            }
        }
    }
}

References _, adjustDelay, Settings::awayMode, ChatMsgType::BY_SERVER, ChatTab::chatLog(), config, cur_time, ParticleEngine::emitterSkip, fps, FUNC_BLOCK, Configuration::getBoolValue(), WindowManager::getFramerate(), LocalPlayer::getHalfAway(), Configuration::getIntValue(), IgnoreRecord_false, localChatTab, localPlayer, mAdjustLevel, mLowerCounter, mNextAdjustTime, Configuration::setSilent(), settings, Configuration::setValue(), and TryRemoveColors_true.

Referenced by slowLogic().

changeMap()

void Game::changeMap

(

const std::string &

mapPath

)

Changes the currently active map. Should only be called while the game is running.

Definition at line 1093 of file game.cpp.

{
    BLOCK_START("Game::changeMap")
 
    skipPerfFrames = 3;
    resetAdjustLevel();
    ResourceManager::cleanProtected();
 
    PopupManager::clearPopup();
    PopupManager::closePopupMenu();
 
    // Clean up floor items, beings and particles
    if (actorManager != nullptr)
        actorManager->clear();
 
    // Close the popup menu on map change so that invalid options can't be
    // executed.
    if (viewport != nullptr)
        viewport->cleanHoverItems();
 
    // Unset the map of the player so that its particles are cleared before
    // being deleted in the next step
    if (localPlayer != nullptr)
        localPlayer->setMap(nullptr);
 
    if (particleEngine != nullptr)
        particleEngine->clear();
 
    mMapName = mapPath;
 
    std::string fullMap = pathJoin(paths.getValue("maps", "maps/"),
        mMapName).append(".tmx");
    std::string realFullMap = pathJoin(paths.getValue("maps", "maps/"),
        MapDB::getMapName(mMapName)).append(".tmx");
 
    if (!VirtFs::exists(realFullMap))
        realFullMap.append(".gz");
 
    // Attempt to load the new map
    Map *const newMap = MapReader::readMap(fullMap, realFullMap);
 
    if (mCurrentMap != nullptr)
        mCurrentMap->saveExtraLayer();
 
    if (newMap != nullptr)
        newMap->addExtraLayer();
 
    if (socialWindow != nullptr)
        socialWindow->setMap(newMap);
 
    // Notify the minimap and actorManager about the map change
    if (minimap != nullptr)
        minimap->setMap(newMap);
    if (actorManager != nullptr)
        actorManager->setMap(newMap);
    if (particleEngine != nullptr)
        particleEngine->setMap(newMap);
    if (viewport != nullptr)
        viewport->setMap(newMap);
 
    // Initialize map-based particle effects
    if (newMap != nullptr)
        newMap->initializeParticleEffects();
 
    // Start playing new music file when necessary
    const std::string oldMusic = mCurrentMap != nullptr
        ? mCurrentMap->getMusicFile() : "";
    const std::string newMusic = newMap != nullptr ?
        newMap->getMusicFile() : "";
    if (newMusic != oldMusic)
    {
        if (newMusic.empty())
            soundManager.fadeOutMusic(1000);
        else
            soundManager.fadeOutAndPlayMusic(newMusic, 1000);
    }
 
    if (mCurrentMap != nullptr)
        mCurrentMap->saveExtraLayer();
 
    delete mCurrentMap;
    mCurrentMap = newMap;
 
    if (questsWindow != nullptr)
        questsWindow->setMap(mCurrentMap);
 
#ifdef USE_MUMBLE
    if (mumbleManager)
        mumbleManager->setMap(mapPath);
#endif  // USE_MUMBLE
 
    if (localPlayer != nullptr)
        localPlayer->recreateItemParticles();
 
    gameHandler->mapLoadedEvent();
    Perf::init();
    BLOCK_END("Game::changeMap")
}

References actorManager, Map::addExtraLayer(), BLOCK_END, BLOCK_START, Viewport::cleanHoverItems(), ResourceManager::cleanProtected(), ActorManager::clear(), ParticleEngine::clear(), PopupManager::clearPopup(), PopupManager::closePopupMenu(), VirtFs::exists(), SoundManager::fadeOutAndPlayMusic(), SoundManager::fadeOutMusic(), gameHandler, MapDB::getMapName(), Map::getMusicFile(), ConfigurationObject::getValue(), Perf::init(), Map::initializeParticleEffects(), localPlayer, Net::GameHandler::mapLoadedEvent(), mCurrentMap, minimap, mMapName, particleEngine, pathJoin(), paths, questsWindow, MapReader::readMap(), Being::recreateItemParticles(), resetAdjustLevel(), Map::saveExtraLayer(), Minimap::setMap(), QuestsWindow::setMap(), ActorManager::setMap(), LocalPlayer::setMap(), SocialWindow::setMap(), ParticleEngine::setMap(), Viewport::setMap(), skipPerfFrames, socialWindow, soundManager, and viewport.

Referenced by Ea::GameHandler::initEngines(), and Ea::PlayerRecv::processPlayerWarp().

checkKeys()

void Game::checkKeys

(

)

Definition at line 1249 of file game.cpp.

{
    const int timeRange = 120;
    const int cntInTime = 130;
 
    if ((localPlayer == nullptr) || (settings.attackType == 0U))
        return;
 
    const time_t time = cur_time;
    for (int f = 0; f < MAX_LASTKEYS; f ++)
    {
        LastKey &lastKey = mLastKeys[f];
        if (lastKey.key != InputAction::NO_VALUE)
        {
            if (lastKey.time + timeRange < time)
            {
                if (lastKey.cnt > cntInTime)
                    mValidSpeed = false;
                lastKey.key = InputAction::NO_VALUE;
            }
        }
    }
}

References Settings::attackType, LastKey::cnt, cur_time, LastKey::key, localPlayer, MAX_LASTKEYS, mLastKeys, mValidSpeed, InputAction::NO_VALUE, settings, and LastKey::time.

clearInstance()

static void Game::clearInstance ( )

inlinestatic

Definition at line 85 of file game.h.

        { mInstance = nullptr; }

References mInstance.

clearKeysArray()

void Game::clearKeysArray ( )

private

Definition at line 1279 of file game.cpp.

{
    for (int f = 0; f < MAX_LASTKEYS; f ++)
    {
        mLastKeys[f].time = 0;
        mLastKeys[f].key = InputAction::NO_VALUE;
        mLastKeys[f].cnt = 0;
    }
}

References LastKey::cnt, LastKey::key, MAX_LASTKEYS, mLastKeys, InputAction::NO_VALUE, and LastKey::time.

Referenced by Game(), and setValidSpeed().

createScreenshot()

bool Game::createScreenshot ( const std::string &  prefix )

static

Definition at line 535 of file game.cpp.

{
    if ((mainGraphics == nullptr) || (screenshortHelper == nullptr))
        return false;
 
    SDL_Surface *screenshot = nullptr;
 
    if (!config.getBoolValue("showip") && (gui != nullptr))
    {
        mainGraphics->setSecure(true);
        screenshortHelper->prepare();
        gui->draw();
        addWatermark();
        screenshot = screenshortHelper->getScreenshot();
        mainGraphics->setSecure(false);
    }
    else
    {
        addWatermark();
        screenshot = screenshortHelper->getScreenshot();
    }
 
    if (screenshot == nullptr)
        return false;
 
    return saveScreenshot(screenshot, prefix);
}

References addWatermark(), config, Gui::draw(), Configuration::getBoolValue(), ScreenshotHelper::getScreenshot(), gui, mainGraphics, ScreenshotHelper::prepare(), saveScreenshot(), screenshortHelper, Actions::screenshot(), and Graphics::setSecure().

Referenced by TradeWindow::completeTrade().

getCurrentMap()

Map* Game::getCurrentMap ( ) const

inline

Returns the currently active map.

Definition at line 107 of file game.h.

        { return mCurrentMap; }

References mCurrentMap.

Referenced by ActorManager::findNearestPvpPlayer(), MapDebugTab::logic(), Ea::PlayerRecv::processMapMask(), EAthena::BeingRecv::processMapTypeProperty(), Ea::PlayerRecv::processPlayerWarp(), Ea::BeingRecv::processPvpMapMode(), and CompoundSprite::redraw().

getCurrentMapName()

const std::string& Game::getCurrentMapName ( ) const

inline

Definition at line 110 of file game.h.

        { return mMapName; }

References mMapName.

Referenced by Ea::PlayerRecv::processPlayerWarp().

getValidSpeed()

bool Game::getValidSpeed ( ) const

inline

Definition at line 124 of file game.h.

        { return mValidSpeed; }

References mValidSpeed.

handleInput()

void Game::handleInput

(

)

The huge input handling method.

Definition at line 1060 of file game.cpp.

{
    BLOCK_START("Game::handleInput 1")
    if (joystick != nullptr)
        joystick->logic();
 
    eventsManager.handleGameEvents();
 
    // If the user is configuring the keys then don't respond.
    if (!keyboard.isEnabled() || settings.awayMode)
    {
        BLOCK_END("Game::handleInput 1")
        return;
    }
 
    // If pressed outfits keys, stop processing keys.
    if (inputManager.isActionActive(InputAction::WEAR_OUTFIT)
        || inputManager.isActionActive(InputAction::COPY_OUTFIT)
        || ((setupWindow != nullptr) && setupWindow->isWindowVisible()))
    {
        BLOCK_END("Game::handleInput 1")
        return;
    }
 
    handleMove();
    InputManager::handleRepeat();
    BLOCK_END("Game::handleInput 1")
}

References Settings::awayMode, BLOCK_END, BLOCK_START, InputAction::COPY_OUTFIT, eventsManager, EventsManager::handleGameEvents(), handleMove(), InputManager::handleRepeat(), inputManager, InputManager::isActionActive(), KeyboardConfig::isEnabled(), Window::isWindowVisible(), joystick, keyboard, Joystick::logic(), settings, setupWindow, and InputAction::WEAR_OUTFIT.

Referenced by EventsManager::handleEvents(), and logic().

handleMove()

void Game::handleMove

(

)

Definition at line 920 of file game.cpp.

{
    BLOCK_START("Game::handleMove")
    if (localPlayer == nullptr)
    {
        BLOCK_END("Game::handleMove")
        return;
    }
 
    // Moving player around
    if ((chatWindow != nullptr) &&
        (quitDialog == nullptr) &&
        localPlayer->canMove() &&
        !chatWindow->isInputFocused() &&
        !InventoryWindow::isAnyInputFocused() &&
        !popupMenu->isPopupVisible())
    {
        NpcDialog *const dialog = NpcDialog::getActive();
        if (dialog != nullptr)
        {
            BLOCK_END("Game::handleMove")
            return;
        }
 
        // Ignore input if either "ignore" key is pressed
        // Stops the character moving about if the user's window manager
        // uses "ignore+arrow key" to switch virtual desktops.
        if (inputManager.isActionActive(InputAction::IGNORE_INPUT_1) ||
            inputManager.isActionActive(InputAction::IGNORE_INPUT_2))
        {
            BLOCK_END("Game::handleMove")
            return;
        }
 
        unsigned char direction = 0;
 
        // Translate pressed keys to movement and direction
        if (inputManager.isActionActive(InputAction::MOVE_UP) ||
            ((joystick != nullptr) && joystick->isUp()))
        {
            direction |= BeingDirection::UP;
            setValidSpeed();
            localPlayer->cancelFollow();
        }
        else if (inputManager.isActionActive(InputAction::MOVE_DOWN) ||
                 ((joystick != nullptr) && joystick->isDown()))
        {
            direction |= BeingDirection::DOWN;
            setValidSpeed();
            localPlayer->cancelFollow();
        }
 
        if (inputManager.isActionActive(InputAction::MOVE_LEFT) ||
            ((joystick != nullptr) && joystick->isLeft()))
        {
            direction |= BeingDirection::LEFT;
            setValidSpeed();
            localPlayer->cancelFollow();
        }
        else if (inputManager.isActionActive(InputAction::MOVE_RIGHT) ||
                 ((joystick != nullptr) && joystick->isRight()))
        {
            direction |= BeingDirection::RIGHT;
            setValidSpeed();
            localPlayer->cancelFollow();
        }
        else if (inputManager.isActionActive(InputAction::MOVE_FORWARD))
        {
            direction = localPlayer->getDirection();
            setValidSpeed();
            localPlayer->cancelFollow();
        }
 
        if ((!inputManager.isActionActive(InputAction::EMOTE)
            && !inputManager.isActionActive(InputAction::PET_EMOTE)
            && !inputManager.isActionActive(InputAction::HOMUN_EMOTE)
            && !inputManager.isActionActive(InputAction::STOP_ATTACK))
            || direction == 0)
        {
            moveInDirection(direction);
        }
    }
    BLOCK_END("Game::handleMove")
}

References BLOCK_END, BLOCK_START, LocalPlayer::cancelFollow(), LocalPlayer::canMove(), chatWindow, BeingDirection::DOWN, InputAction::EMOTE, NpcDialog::getActive(), Being::getDirection(), InputAction::HOMUN_EMOTE, InputAction::IGNORE_INPUT_1, InputAction::IGNORE_INPUT_2, inputManager, InputManager::isActionActive(), InventoryWindow::isAnyInputFocused(), Joystick::isDown(), ChatWindow::isInputFocused(), Joystick::isLeft(), Popup::isPopupVisible(), Joystick::isRight(), Joystick::isUp(), joystick, BeingDirection::LEFT, localPlayer, InputAction::MOVE_DOWN, InputAction::MOVE_FORWARD, InputAction::MOVE_LEFT, InputAction::MOVE_RIGHT, InputAction::MOVE_UP, moveInDirection(), InputAction::PET_EMOTE, popupMenu, quitDialog, BeingDirection::RIGHT, setValidSpeed(), InputAction::STOP_ATTACK, and BeingDirection::UP.

Referenced by handleInput().

instance()

static Game* Game::instance ( )

inlinestatic

Provides access to the game instance.

Definition at line 82 of file game.h.

        { return mInstance; }

References mInstance.

Referenced by OutfitWindow::action(), SetupWindow::action(), GameModifiers::changeAwayMode(), ChatWindow::chatInput(), ActorManager::findNearestPvpPlayer(), EventsManager::handleActive(), EventsManager::handleEvents(), EventsManager::handleGameEvents(), Ea::GameHandler::initEngines(), MapDebugTab::logic(), Ea::PlayerRecv::processMapMask(), EAthena::BeingRecv::processMapTypeProperty(), Ea::PlayerRecv::processPlayerWarp(), Ea::BeingRecv::processPvpMapMode(), CompoundSprite::redraw(), WindowManager::resizeVideo(), TmwAthena::AdminHandler::slide(), InputManager::updateConditionMask(), and Viewport::validateSpeed().

logic()

void Game::logic

(

)

This method takes the game a small step further. It is called 100 times per second.

Definition at line 663 of file game.cpp.

{
    BLOCK_START("Game::logic")
    handleInput();
 
    // Handle all necessary game logic
    if (actorManager != nullptr)
        actorManager->logic();
    if (particleEngine != nullptr)
        particleEngine->update();
    if (mCurrentMap != nullptr)
        mCurrentMap->update(1);
 
    BLOCK_END("Game::logic")
}

References actorManager, BLOCK_END, BLOCK_START, handleInput(), ActorManager::logic(), mCurrentMap, particleEngine, ParticleEngine::update(), and Map::update().

moveInDirection()

void Game::moveInDirection ( const unsigned char  direction )

static

Definition at line 1005 of file game.cpp.

{
    if (viewport == nullptr)
        return;
 
    if (settings.cameraMode == 0U)
    {
        if (localPlayer != nullptr)
            localPlayer->specialMove(direction);
    }
    else
    {
        int dx = 0;
        int dy = 0;
        if ((direction & BeingDirection::LEFT) != 0)
            dx = -5;
        else if ((direction & BeingDirection::RIGHT) != 0)
            dx = 5;
 
        if ((direction & BeingDirection::UP) != 0)
            dy = -5;
        else if ((direction & BeingDirection::DOWN) != 0)
            dy = 5;
        viewport->moveCamera(dx, dy);
    }
}

References Settings::cameraMode, BeingDirection::DOWN, BeingDirection::LEFT, localPlayer, Viewport::moveCamera(), BeingDirection::RIGHT, settings, LocalPlayer::specialMove(), BeingDirection::UP, and viewport.

Referenced by handleMove().

resetAdjustLevel()

void Game::resetAdjustLevel

(

)

Definition at line 889 of file game.cpp.

{
    if (!mAdjustPerfomance)
        return;
 
    mNextAdjustTime = cur_time + adjustDelay;
    switch (mAdjustLevel)
    {
        case 1:
            config.setValue("beingopacity",
                config.getBoolValue("beingopacity"));
            break;
        case 2:
            config.setValue("beingopacity",
                config.getBoolValue("beingopacity"));
            ParticleEngine::emitterSkip = config.getIntValue(
                "particleEmitterSkip") + 1;
            break;
        default:
        case 3:
            config.setValue("beingopacity",
                config.getBoolValue("beingopacity"));
            ParticleEngine::emitterSkip = config.getIntValue(
                "particleEmitterSkip") + 1;
            config.setValue("alphaCache",
                config.getBoolValue("alphaCache"));
            break;
    }
    mAdjustLevel = 0;
}

References adjustDelay, config, cur_time, ParticleEngine::emitterSkip, Configuration::getBoolValue(), Configuration::getIntValue(), mAdjustLevel, mAdjustPerfomance, mNextAdjustTime, and Configuration::setValue().

Referenced by SetupWindow::action(), changeMap(), and ~Game().

saveScreenshot()

bool Game::saveScreenshot ( SDL_Surface *const  screenshot, const std::string &  prefix  )

static

Definition at line 563 of file game.cpp.

{
    std::string screenshotDirectory = settings.screenshotDir;
    if (mkdir_r(screenshotDirectory.c_str()) != 0)
    {
        logger->log("Directory %s doesn't exist and can't be created! "
                    "Setting screenshot directory to home.",
                    screenshotDirectory.c_str());
        screenshotDirectory = std::string(VirtFs::getUserDir());
    }
 
    // Search for an unused screenshot name
    std::stringstream filename;
    std::fstream testExists;
 
    time_t rawtime;
    char buffer [100];
    time(&rawtime);
    tm *const timeinfo = localtime(&rawtime);
    strftime(buffer, 99, "%Y-%m-%d_%H-%M-%S", timeinfo);
 
    const std::string serverName = settings.serverName;
    std::string screenShortStr;
    if (prefix.empty())
    {
        if (serverName.empty())
        {
            screenShortStr = strprintf("%s_Screenshot_%s_",
                branding.getValue("appName", "ManaPlus").c_str(),
                buffer);
        }
        else
        {
            screenShortStr = strprintf("%s_Screenshot_%s_%s_",
                branding.getValue("appName", "ManaPlus").c_str(),
                serverName.c_str(), buffer);
        }
 
        bool found = false;
        static unsigned int screenshotCount = 0;
        do
        {
            screenshotCount++;
            filename.str("");
            filename << screenshotDirectory << "/";
            filename << screenShortStr << screenshotCount << ".png";
            testExists.open(filename.str().c_str(), std::ios::in);
            found = !testExists.is_open();
            testExists.close();
        }
        while (!found);
    }
    else
    {
        screenShortStr = prefix;
        filename.str("");
        filename << screenshotDirectory << "/";
        filename << screenShortStr;
    }
 
    const std::string fileNameStr = filename.str();
    const bool success = PngLib::writePNG(screenshot, fileNameStr);
#ifdef __native_client__
    std::string nacScreenshotlDir = fileNameStr;
    cutFirst(nacScreenshotlDir, "/persistent");
    naclPostMessage("copy-from-persistent", nacScreenshotlDir);
    logger->log("nacl screenshot path: " + nacScreenshotlDir);
#endif  // __native_client__
 
    if (success)
    {
        if (localChatTab != nullptr)
        {
            // TRANSLATORS: save file message
            std::string str = strprintf(_("Screenshot saved as %s"),
                fileNameStr.c_str());
            localChatTab->chatLog(str,
                ChatMsgType::BY_SERVER,
                IgnoreRecord_false,
                TryRemoveColors_true);
        }
    }
    else
    {
        if (localChatTab != nullptr)
        {
            // TRANSLATORS: save file message
            localChatTab->chatLog(_("Saving screenshot failed!"),
                ChatMsgType::BY_SERVER,
                IgnoreRecord_false,
                TryRemoveColors_true);
        }
        logger->log1("Error: could not save screenshot.");
    }
 
    MSDL_FreeSurface(screenshot);
    return success;
}

References _, branding, ChatMsgType::BY_SERVER, ChatTab::chatLog(), cutFirst(), VirtFs::getUserDir(), ConfigurationObject::getValue(), IgnoreRecord_false, localChatTab, Logger::log(), Logger::log1(), logger, mkdir_r(), MSDL_FreeSurface, Actions::screenshot(), Settings::screenshotDir, Settings::serverName, settings, strprintf(), TryRemoveColors_true, and PngLib::writePNG().

Referenced by createScreenshot().

setAdjustLevel()

void Game::setAdjustLevel ( const int  n )

inline

Definition at line 119 of file game.h.

        { mAdjustLevel = n; }

References mAdjustLevel.

setValidSpeed()

void Game::setValidSpeed

(

)

Definition at line 1273 of file game.cpp.

{
    clearKeysArray();
    mValidSpeed = true;
}

References clearKeysArray(), and mValidSpeed.

Referenced by OutfitWindow::action(), ChatWindow::chatInput(), handleMove(), and Viewport::validateSpeed().

slowLogic()

void Game::slowLogic

(

)

Definition at line 679 of file game.cpp.

{
    BLOCK_START("Game::slowLogic")
    if (localPlayer != nullptr)
        localPlayer->slowLogic();
    const time_t time = cur_time;
    if (mTime != time)
    {
        if (valTest(Updated))
            mValidSpeed = false;
 
        mTime = time + 1;
        if (debugWindow != nullptr)
            debugWindow->slowLogic();
        if (killStats != nullptr)
            killStats->update();
        if (socialWindow != nullptr)
            socialWindow->slowLogic();
        if (whoIsOnline != nullptr)
            whoIsOnline->slowLogic();
        Being::reReadConfig();
        if (killStats != nullptr)
            killStats->recalcStats();
 
        if (time > mTime2 || mTime2 - time > 10)
        {
            mTime2 = time + 10;
            config.writeUpdated();
            serverConfig.writeUpdated();
        }
        if (effectManager != nullptr)
            effectManager->logic();
    }
 
    if (mainGraphics->getOpenGL() != RENDER_SOFTWARE)
        DelayedManager::delayedLoad();
 
#ifdef TMWA_SUPPORT
    if (shopWindow != nullptr)
        shopWindow->updateTimes();
    if (guildManager != nullptr)
        guildManager->slowLogic();
#endif  // TMWA_SUPPORT
 
    if (skillDialog != nullptr)
        skillDialog->slowLogic();
 
    PacketCounters::update();
 
    // Handle network stuff
    if (!gameHandler->isConnected())
    {
        if (client->getState() == State::CHANGE_MAP)
            return;  // Not a problem here
 
        if (client->getState() != State::ERROR)
        {
            if (disconnectedDialog == nullptr)
            {
                // TRANSLATORS: error message text
                errorMessage = _("The connection to the server was lost.");
                disconnectedDialog = DialogsManager::openErrorDialog(
                    // TRANSLATORS: error message header
                    _("Network Error"),
                    errorMessage,
                    Modal_false);
                disconnectedDialog->addActionListener(&errorListener);
                disconnectedDialog->requestMoveToTop();
            }
        }
 
        if ((viewport != nullptr) && !errorMessage.empty())
        {
            const Map *const map = viewport->getMap();
            if (map != nullptr)
                map->saveExtraLayer();
        }
        DialogsManager::closeDialogs();
        WindowManager::setFramerate(config.getIntValue("fpslimit"));
        mNextAdjustTime = cur_time + adjustDelay;
        if (client->getState() != State::ERROR)
            errorMessage.clear();
    }
    else
    {
        if (gameHandler->mustPing()
            && get_elapsed_time1(mPing) > 3000)
        {
            mPing = tick_time;
            gameHandler->ping(tick_time);
        }
 
        if (mAdjustPerfomance)
            adjustPerfomance();
        if (disconnectedDialog != nullptr)
        {
            disconnectedDialog->scheduleDelete();
            disconnectedDialog = nullptr;
        }
    }
    BLOCK_END("Game::slowLogic")
}

References _, Widget::addActionListener(), adjustDelay, adjustPerfomance(), BLOCK_END, BLOCK_START, State::CHANGE_MAP, client, DialogsManager::closeDialogs(), config, cur_time, debugWindow, DelayedManager::delayedLoad(), disconnectedDialog, effectManager, State::ERROR, errorListener, errorMessage, gameHandler, get_elapsed_time1(), Configuration::getIntValue(), Viewport::getMap(), Graphics::getOpenGL(), Client::getState(), guildManager, Net::GameHandler::isConnected(), killStats, localPlayer, EffectManager::logic(), mAdjustPerfomance, mainGraphics, mNextAdjustTime, Modal_false, mPing, mTime, mTime2, Net::GameHandler::mustPing(), mValidSpeed, DialogsManager::openErrorDialog(), Net::GameHandler::ping(), KillStats::recalcStats(), RENDER_SOFTWARE, Widget::requestMoveToTop(), Being::reReadConfig(), Map::saveExtraLayer(), Window::scheduleDelete(), serverConfig, WindowManager::setFramerate(), shopWindow, skillDialog, LocalPlayer::slowLogic(), DebugWindow::slowLogic(), SkillDialog::slowLogic(), SocialWindow::slowLogic(), WhoIsOnline::slowLogic(), GuildManager::slowLogic(), socialWindow, tick_time, KillStats::update(), PacketCounters::update(), ShopWindow::updateTimes(), valTest, viewport, whoIsOnline, and Configuration::writeUpdated().

updateFrameRate()

void Game::updateFrameRate

(

int

fpsLimit

)

Definition at line 1032 of file game.cpp.

{
    if (fpsLimit == 0)
    {
        if (settings.awayMode)
        {
            if (settings.inputFocused != KeyboardFocus::Unfocused ||
                settings.mouseFocused)
            {
                fpsLimit = config.getIntValue("fpslimit");
            }
            else
            {
                fpsLimit = config.getIntValue("altfpslimit");
            }
        }
        else
        {
            fpsLimit = config.getIntValue("fpslimit");
        }
    }
    WindowManager::setFramerate(fpsLimit);
    mNextAdjustTime = cur_time + adjustDelay;
}

References adjustDelay, Settings::awayMode, config, cur_time, Configuration::getIntValue(), Settings::inputFocused, mNextAdjustTime, Settings::mouseFocused, WindowManager::setFramerate(), settings, and KeyboardFocus::Unfocused.

Referenced by GameModifiers::changeAwayMode(), and EventsManager::handleActive().

updateHistory()

void Game::updateHistory

(

const SDL_Event &

event

)

Definition at line 1192 of file game.cpp.

{
    if ((localPlayer == nullptr) || (settings.attackType == 0U))
        return;
 
    if (CAST_S32(event.key.keysym.sym) != -1)
    {
        bool old = false;
 
        const InputActionT key = KeyboardConfig::getKeyIndex(event, 1);
        const time_t time = cur_time;
        int idx = -1;
        for (int f = 0; f < MAX_LASTKEYS; f ++)
        {
            LastKey &lastKey = mLastKeys[f];
            if (lastKey.key == key)
            {
                idx = f;
                old = true;
                break;
            }
            else if (idx >= 0 && lastKey.time < mLastKeys[idx].time)
            {
                idx = f;
            }
        }
        if (idx < 0)
        {
            idx = 0;
            for (int f = 0; f < MAX_LASTKEYS; f ++)
            {
                LastKey &lastKey = mLastKeys[f];
                if (lastKey.key == InputAction::NO_VALUE ||
                    lastKey.time < mLastKeys[idx].time)
                {
                    idx = f;
                }
            }
        }
 
        if (idx < 0)
            idx = 0;
 
        LastKey &keyIdx = mLastKeys[idx];
        if (!old)
        {
            keyIdx.time = time;
            keyIdx.key = key;
            keyIdx.cnt = 0;
        }
        else
        {
            keyIdx.cnt++;
        }
    }
}

References Settings::attackType, CAST_S32, LastKey::cnt, cur_time, KeyboardConfig::getKeyIndex(), LastKey::key, localPlayer, MAX_LASTKEYS, mLastKeys, InputAction::NO_VALUE, settings, and LastKey::time.

videoResized()

void Game::videoResized ( const int  width, const int  height  )

static

Definition at line 1289 of file game.cpp.

{
    if (viewport != nullptr)
        viewport->setSize(width, height);
    if (windowMenu != nullptr)
        windowMenu->setPosition(width - windowMenu->getWidth(), 0);
}

References Widget::getWidth(), Widget::setPosition(), Widget::setSize(), viewport, and windowMenu.

Referenced by WindowManager::resizeVideo().

Field Documentation

mAdjustLevel

int Game::mAdjustLevel

private

Definition at line 148 of file game.h.

Referenced by adjustPerfomance(), resetAdjustLevel(), and setAdjustLevel().

mAdjustPerfomance

bool Game::mAdjustPerfomance

private

Definition at line 149 of file game.h.

Referenced by resetAdjustLevel(), and slowLogic().

mCurrentMap

Map* Game::mCurrentMap

private

Definition at line 143 of file game.h.

Referenced by changeMap(), getCurrentMap(), logic(), and ~Game().

mInstance

Game * Game::mInstance = 0

staticprivate

Definition at line 155 of file game.h.

Referenced by clearInstance(), Game(), instance(), and ~Game().

mLastKeys

LastKey Game::mLastKeys[MAX_LASTKEYS]

private

Definition at line 146 of file game.h.

Referenced by checkKeys(), clearKeysArray(), and updateHistory().

mLowerCounter

int Game::mLowerCounter

private

Definition at line 150 of file game.h.

Referenced by adjustPerfomance().

mMapName

std::string Game::mMapName

private

Definition at line 144 of file game.h.

Referenced by changeMap(), and getCurrentMapName().

mNextAdjustTime

time_t Game::mNextAdjustTime

private

Definition at line 147 of file game.h.

Referenced by adjustPerfomance(), resetAdjustLevel(), slowLogic(), and updateFrameRate().

mPing

int Game::mPing

private

Definition at line 151 of file game.h.

Referenced by slowLogic().

mTime

time_t Game::mTime

private

Definition at line 152 of file game.h.

Referenced by slowLogic().

mTime2

time_t Game::mTime2

private

Definition at line 153 of file game.h.

Referenced by slowLogic().

mValidSpeed

bool Game::mValidSpeed

private

Definition at line 145 of file game.h.

Referenced by checkKeys(), getValidSpeed(), setValidSpeed(), and slowLogic().

---

The documentation for this class was generated from the following files:

• src/game.h (986a3bf)
• src/game.cpp (986a3bf)