logo.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 SHERLOCK_SCALPEL_TSAGE_LOGO_H
#define SHERLOCK_SCALPEL_TSAGE_LOGO_H

#include "common/scummsys.h"
#include "common/array.h"
#include "common/file.h"
#include "common/list.h"
#include "common/str.h"
#include "common/str-array.h"
#include "common/util.h"
#include "graphics/surface.h"
#include "sherlock/scalpel/tsage/resources.h"
#include "sherlock/screen.h"

namespace Sherlock {
namespace Scalpel {

class ScalpelEngine;

namespace TsAGE {

class ObjectSurface : public Surface {
public:
    Common::Point _centroid;
public:
    ObjectSurface() : Surface() {}
    ~ObjectSurface() override {}
};

class Visage {
private:
    Common::SeekableReadStream *_stream;

    void surfaceFromRes(ObjectSurface &s);
public:
    static TLib *_tLib;
    int _resNum;
    int _rlbNum;
public:
    Visage();
    ~Visage();

    void setVisage(int resNum, int rlbNum = 9999);

    void clear();

    void getFrame(ObjectSurface &s, int frameNum);

    int getFrameCount() const;

    bool isLoaded() const;
};

class Object {
private:
    Visage _visage;
    uint32 _updateStartFrame;
    bool _isAnimating;
    bool _finished;
    uint32 _walkStartFrame;
    int _angle;
    int _changeCtr;
    int _majorDiff, _minorDiff;
    Common::Point _moveDelta;
    Common::Point _moveSign;

    int changeFrame();

    int getNewFrame();

    void calculateMoveAngle();

    void move();

    bool dontMove() const;

    void endMove();
public:
    static ScalpelEngine *_vm;
    Common::Point _position;
    Common::Point _destination;
    Common::Rect _oldBounds;
    int _frame;
    int _numFrames;
    int _frameChange;
public:
    Object();

    void setVisage(int visage, int strip);

    void setAnimMode(bool isAnimating);

    void setDestination(const Common::Point &pt);

    bool isAnimEnded() const;

    bool isMoving() const;

    void erase();

    void update();

    void remove() { _visage.clear(); }
};

struct AnimationFrame {
    int frame;
    int x;
    int y;
};

class Logo {
private:
    ScalpelEngine *_vm;
    TLib _lib;
    int _counter, _frameCounter;
    bool _finished;
    byte _originalPalette[PALETTE_SIZE];
    byte _palette1[PALETTE_SIZE];
    byte _palette2[PALETTE_SIZE];
    byte _palette3[PALETTE_SIZE];
    Object _objects[4];
    uint _waitFrames;
    uint32 _waitStartFrame;
    int _animateObject;
    uint32 _animateStartFrame;
    uint _animateFrameDelay;
    const AnimationFrame *_animateFrames;
    uint _animateFrame;

    Logo(ScalpelEngine *vm);
    ~Logo();

    void nextFrame();

    bool finished() const;

    void waitFrames(uint frames);

    void startAnimation(uint object, uint frameDelay, const AnimationFrame *frames);

    void loadBackground();

    void fade(const byte palette[PALETTE_SIZE], int step = 6);
public:
    static bool show(ScalpelEngine *vm);
};

} // end of namespace TsAGE
} // end of namespace Scalpel
} // end of namespace Sherlock

#endif