scene_data.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_DATA_H
#define MADS_SCENE_DATA_H

#include "common/scummsys.h"
#include "common/array.h"
#include "common/serializer.h"
#include "common/str.h"
#include "common/str-array.h"
#include "common/rect.h"
#include "mads/nebular/core/action.h"
#include "mads/nebular/core/assets.h"
#include "mads/nebular/core/events.h"
#include "mads/nebular/core/game_data.h"
#include "mads/nebular/core/hotspots.h"
#include "mads/nebular/core/messages.h"
#include "mads/nebular/core/rails.h"
#include "mads/nebular/core/user_interface.h"

namespace MADS {
namespace Nebular {

class MADSEngine;
class Scene;
class SpriteSlot;

#define MADS_INTERFACE_HEIGHT 44
#define MADS_SCENE_HEIGHT 156

#define DEPTH_BANDS_SIZE 15

#define SPRITE_SLOTS_MAX_SIZE 50
#define TEXT_DISPLAY_MAX_SIZE 40
#define DIRTY_AREAS_SIZE (SPRITE_SLOTS_MAX_SIZE + TEXT_DISPLAY_MAX_SIZE)

enum {
    SCENEFLAG_DITHER = 0x01,     // Dither to 16 colors
    SCENEFLAG_LOAD_SHADOW = 0x10,       // Load hard shadows
    SCENEFLAG_TRANSLATE = 0x10000   // Translate palette of loaded background
};

class VerbInit {
public:
    int _id;
    VerbType _verbType;
    PrepType _prepType;

    VerbInit() {
    }
    VerbInit(int id, VerbType verbType, PrepType prepType)
        : _id(id), _verbType(verbType), _prepType(prepType) {
    }
};

class SceneLogic {
protected:
    RexNebularEngine *_vm;
    Scene *_scene;
public:
    SceneLogic(RexNebularEngine *vm);

    virtual ~SceneLogic() {
    }

    virtual void setup() = 0;

    virtual void enter() = 0;

    virtual void step() {
    }

    virtual void preActions() {
    }

    virtual void actions() = 0;

    virtual void postActions() {
    }

    virtual void unhandledAction() {
    }

    virtual void synchronize(Common::Serializer &s) {
    }
};

struct ARTHeader {
    int _width;
    int _height;
    Common::Array<RGB6> _palette;
    Common::Array<PaletteCycle> _paletteCycles;

    void load(Common::SeekableReadStream *f, bool isV2);
};

class SceneInfo {
    class SpriteInfo {
    public:
        int _spriteSetIndex;
        Common::Point _position;
        int _frameNumber;
        int _depth;
        int _scale;

        void load(Common::SeekableReadStream *f);
    };
protected:
    RexNebularEngine *_vm;

    SceneInfo(RexNebularEngine *vm);
public:
    int _sceneId;
    int _artFileNum;
    int _depthStyle;
    int _width;
    int _height;

    int _yBandsEnd;
    int _yBandsStart;
    int _maxScale;
    int _minScale;
    int _depthList[DEPTH_BANDS_SIZE];
    int _field4A; // Useless field ?

    int _usageIndex;
    Common::Array<PaletteCycle> _paletteCycles;
    WalkNodeList _nodes;
public:
    virtual ~SceneInfo() {
    }

    static SceneInfo *init(RexNebularEngine *vm);

    void load(int sceneId, int variant, const Common::String &resName, int flags,
        DepthSurface &depthSurface, BaseSurface &bgSurface);

    void loadPalette(int sceneId, int artFileNum, const Common::String &resName, int flags, BaseSurface &bgSurface);

    void loadMadsV1Background(int sceneId, const Common::String &resName, int flags, BaseSurface &bgSurface);

    void loadMadsV2Background(int sceneId, const Common::String &resName, int flags, BaseSurface &bgSurface);

    virtual void loadCodes(BaseSurface &depthSurface, int variant) = 0;

    virtual void loadCodes(BaseSurface &depthSurface, Common::SeekableReadStream *stream) = 0;
};

} // namespace Nebular
} // namespace MADS

#endif