scene.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef MADS_SCENE_H
#define MADS_SCENE_H

#include "common/scummsys.h"
#include "common/array.h"
#include "common/rect.h"
#include "mads/nebular/core/assets.h"
#include "mads/nebular/core/screen.h"
#include "mads/nebular/core/hotspots.h"
#include "mads/nebular/core/messages.h"
#include "mads/nebular/core/msurface.h"
#include "mads/nebular/core/scene_data.h"
#include "mads/nebular/core/animation.h"
#include "mads/nebular/core/rails.h"
#include "mads/nebular/core/sequence.h"
#include "mads/nebular/core/sprites.h"
#include "mads/nebular/core/user_interface.h"

namespace MADS {
namespace Nebular {

enum {
    RETURNING_FROM_DIALOG = -2, RETURNING_FROM_LOADING = -1
};

class Scene {
private:
    int activeVocabIndexOf(int vocabId);

    void loadVocabStrings();

    void doFrame();

    void doPreactions();

    void doAction();

    void doSceneStep();

    void checkKeyboard();

    void updateCursor();
protected:
    RexNebularEngine *_vm;
public:
    SceneLogic *_sceneLogic;
    MSurface _sceneSurface;
    int _priorSceneId;
    int _nextSceneId;
    int _currentSceneId;
    Common::Array<VerbInit> _verbList;
    TextDisplayList _textDisplay;
    SpriteSlots _spriteSlots;
    SpriteSets _sprites;
    DynamicHotspots _dynamicHotspots;
    Common::Array<int> _activeVocabs;
    SequenceList _sequences;
    KernelMessages _kernelMessages;
    Rails _rails;
    Common::String _talkFont;
    int _textSpacing;
    Hotspots _hotspots;
    DirtyAreas _dirtyAreas;
    int _variant;
    SceneInfo *_sceneInfo;
    MSurface _backgroundSurface;
    DepthSurface _depthSurface;
    UserInterface _userInterface;
    bool _cyclingActive;
    int _cyclingThreshold;
    int _cyclingDelay;
    int _totalCycleColors;
    Common::Array<uint32> _cycleTicks;
    Common::Array<PaletteCycle> _paletteCycles;
    Common::StringArray _vocabStrings;
    Animation *_animationData;
    Animation *_animation[10];
    bool _freeAnimationFlag;
    int _depthStyle;
    int _bandsRange;
    int _scaleRange;
    int _interfaceY;
    int _spritesCount;
    MADSAction _action;
    bool _roomChanged;
    bool _reloadSceneFlag;
    Common::Point _posAdjust;
    uint32 _frameStartTime;
    ScreenMode _mode;
    bool _lookFlag;
    Common::Point _customDest;
    Common::Array<PaletteUsage::UsageEntry> _paletteUsageF;
    Common::Array<PaletteUsage::UsageEntry> _scenePaletteUsage;
    Scene(RexNebularEngine *vm);

    ~Scene();

    void restrictScene();

    void clearVocab();

    void addActiveVocab(int vocabId);

    uint32 getVocabStringsCount() const;

    void clearSequenceList();

    void clearMessageList();

    void loadSceneLogic();

    void loadScene(int sceneId, const Common::Path &prefix, bool palFlag);

    void loadHotspots();

    void loadVocab();

    bool getDepthHighBits(const Common::Point &pt);

    void loop();

    void drawElements(ScreenTransition transitionType, bool surfaceFlag);

    /*
    * Initializes the data for palette animation within the scene
    */
    void initPaletteAnimation(Common::Array<PaletteCycle> &palCycles, bool animFlag);

    void animatePalette();

    int loadAnimation(const Common::Path &resName, int trigger = 0);

    Common::String getVocab(int vocabId) {
        return _vocabStrings[vocabId - 1];
    }

    void freeCurrentScene();

    void changeVariant(int variant);

    void resetScene();

    void removeSprites();

    void freeAnimation();

    void freeAnimation(int idx);

    void synchronize(Common::Serializer &s);

    void setAnimFrame(int id, int val);
    int getAnimFrame(int id);

    void setDynamicAnim(int id, int anim_id, int segment);
    void setCamera(Common::Point pos);
    void drawToBackground(int spriteId, int frameId, Common::Point pos, int depth, int scale);
    void deleteSequence(int idx);
    void loadSpeech(int idx);
    void playSpeech(int idx);
    void sceneScale(int yFront, int maxScale, int yBack, int minScale);
    void animations_tick();

    int _speechReady;
};

} // namespace Nebular
} // namespace MADS

#endif