penetration.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/>.
 *
 *
 * This file is dual-licensed.
 * In addition to the GPLv3 license mentioned above, this code is also
 * licensed under LGPL 2.1. See LICENSES/COPYING.LGPL file for the
 * full text of the license.
 *
 */
 
#ifndef GOB_MINIGAMES_GEISHA_PENETRATION_H
#define GOB_MINIGAMES_GEISHA_PENETRATION_H
 
#include "common/system.h"
#include "common/list.h"
 
#include "gob/sound/sounddesc.h"
 
#include "gob/minigames/geisha/submarine.h"
 
namespace Gob {
 
class GobEngine;
class Surface;
class CMPFile;
class ANIFile;
 
namespace Geisha {
 
class Meter;
class Mouth;
 
class Penetration {
public:
    Penetration(GobEngine *vm);
    ~Penetration();
 
    bool play(bool hasAccessPass, bool hasMaxEnergy, bool testMode);
 
    bool isPlaying() const;
    void cheatWin();
 
private:
    static const int kModeCount  = 2;
    static const int kFloorCount = 3;
 
    static const int kMapWidth  = 17;
    static const int kMapHeight = 13;
 
    static const int kPaletteSize = 16;
 
    static const byte kPalettes[kFloorCount][3 * kPaletteSize];
    static const byte kMaps[kModeCount][kFloorCount][kMapWidth * kMapHeight];
 
    static const int kEnemyCount     =  9;
    static const int kMaxBulletCount = 10;
 
    struct MapObject {
        uint16 tileX;
        uint16 tileY;
 
        uint16 mapX;
        uint16 mapY;
 
        uint16 width;
        uint16 height;
 
        bool isBlocking;
 
        MapObject(uint16 tX, uint16 tY, uint16 mX, uint16 mY, uint16 w, uint16 h);
        MapObject(uint16 tX, uint16 tY, uint16 w, uint16 h);
 
        void setTileFromMapPosition();
        void setMapFromTilePosition();
 
        bool isIn(uint16 mX, uint16 mY) const;
        bool isIn(uint16 mX, uint16 mY, uint16 w, uint16 h) const;
        bool isIn(const MapObject &obj) const;
    };
 
    enum MouthType {
        kMouthTypeBite,
        kMouthTypeKiss
    };
 
    struct ManagedMouth : public MapObject {
        Mouth *mouth;
 
        MouthType type;
 
        ManagedMouth(uint16 tX, uint16 tY, MouthType t);
        ~ManagedMouth();
    };
 
    struct ManagedSub : public MapObject {
        Submarine *sub;
 
        ManagedSub(uint16 tX, uint16 tY);
        ~ManagedSub();
    };
 
    struct ManagedEnemy : public MapObject {
        ANIObject *enemy;
 
        bool dead;
 
        ManagedEnemy();
        ~ManagedEnemy();
 
        void clear();
    };
 
    struct ManagedBullet : public MapObject {
        ANIObject *bullet;
 
        int16 deltaX;
        int16 deltaY;
 
        ManagedBullet();
        ~ManagedBullet();
 
        void clear();
    };
 
    enum Keys {
        kKeyUp = 0,
        kKeyDown,
        kKeyLeft,
        kKeyRight,
        kKeySpace,
        kKeyCount
    };
 
    GobEngine *_vm;
 
    bool _hasAccessPass;
    bool _hasMaxEnergy;
    bool _testMode;
 
    bool _needFadeIn;
 
    bool _quit;
    bool _keys[kKeyCount];
 
    Surface *_background;
    CMPFile *_sprites;
    ANIFile *_objects;
 
    Common::List<ANIObject *> _anims;
    Common::List<ANIObject *> _mapAnims;
 
    Meter *_shieldMeter;
    Meter *_healthMeter;
 
    uint8 _floor;
 
    Surface *_map;
 
    ManagedSub *_sub;
 
    Common::List<MapObject>    _walls;
    Common::List<MapObject>    _exits;
    Common::List<MapObject>    _shields;
    Common::List<ManagedMouth> _mouths;
 
    ManagedEnemy  _enemies[kEnemyCount];
    ManagedBullet _bullets[kMaxBulletCount];
 
    Common::List<MapObject *> _blockingObjects;
 
    uint8 _shotCoolDown;
 
    SoundDesc _soundShield;
    SoundDesc _soundBite;
    SoundDesc _soundKiss;
    SoundDesc _soundShoot;
    SoundDesc _soundExit;
    SoundDesc _soundExplode;
 
    bool _isPlaying;
 
 
    void init();
    void deinit();
 
    void clearMap();
    void createMap();
 
    void initScreen();
 
    void setPalette();
    void fadeIn();
 
    void drawFloorText();
    void drawEndText();
 
    bool isBlocked(const MapObject &self, int16 x, int16 y, MapObject **blockedBy = 0);
    void findPath(MapObject &obj, int x, int y, MapObject **blockedBy = 0);
 
    void updateAnims();
 
    void checkInput();
 
    Submarine::Direction getDirection(int &x, int &y) const;
 
    void handleSub();
    void subMove(int x, int y, Submarine::Direction direction);
    void subShoot();
 
    int findEmptyBulletSlot() const;
    uint16 directionToBullet(Submarine::Direction direction) const;
    void setBulletPosition(const ManagedSub &sub, ManagedBullet &bullet) const;
 
    void bulletsMove();
    void bulletMove(ManagedBullet &bullet);
    void checkShotEnemy(MapObject &shotObject);
 
    void checkExits();
    void checkShields();
    void checkMouths();
 
    void healthGain(int amount);
    void healthLose(int amount);
 
    void checkExited();
 
    void enemiesCreate();
    void enemiesMove();
    void enemyMove(ManagedEnemy &enemy, int x, int y);
    void enemyAttack(ManagedEnemy &enemy);
    void enemyExplode(ManagedEnemy &enemy);
 
    bool isDead() const;
    bool hasWon() const;
 
    int getLanguage() const;
};
 
} // End of namespace Geisha
 
} // End of namespace Gob
 
#endif // GOB_MINIGAMES_GEISHA_PENETRATION_H