tile.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 ULTIMA4_MAP_TILE_H
#define ULTIMA4_MAP_TILE_H

#include "ultima/ultima4/map/direction.h"
#include "ultima/ultima4/core/types.h"
#include "ultima/ultima4/map/tileset.h"
#include "ultima/shared/std/containers.h"

namespace Ultima {
namespace Ultima4 {

class ConfigElement;
class Image;
class Tileset;
class TileAnim;

/* attr masks */
#define MASK_SHIP                   0x0001
#define MASK_HORSE                  0x0002
#define MASK_BALLOON                0x0004
#define MASK_DISPEL                 0x0008
#define MASK_TALKOVER               0x0010
#define MASK_DOOR                   0x0020
#define MASK_LOCKEDDOOR             0x0040
#define MASK_CHEST                  0x0080
#define MASK_ATTACKOVER             0x0100
#define MASK_CANLANDBALLOON         0x0200
#define MASK_REPLACEMENT            0x0400
#define MASK_WATER_REPLACEMENT      0x0800
#define MASK_FOREGROUND             0x1000
#define MASK_LIVING_THING           0x2000


/* movement masks */
#define MASK_SWIMABLE           0x0001
#define MASK_SAILABLE           0x0002
#define MASK_UNFLYABLE          0x0004
#define MASK_CREATURE_UNWALKABLE 0x0008

class Tile : private Uncopyable {
public:
    Tile(Tileset *tileset);
    ~Tile();

    void loadProperties(const ConfigElement &conf);

    TileId getId() const {
        return _id;
    }
    const Common::String &getName() const {
        return _name;
    }
    int getWidth() const {
        return _w;
    }
    int getHeight() const {
        return _h;
    }
    int getFrames() const {
        return _frames;
    }
    int getScale() const {
        return _scale;
    }
    TileAnim *getAnim() const {
        return _anim;
    }
    Image *getImage();
    const Common::String &getLooksLike() const {
        return _looksLike;
    }

    bool isTiledInDungeon() const {
        return _tiledInDungeon;
    }
    bool isLandForeground() const {
        return _foreground;
    }
    bool isWaterForeground() const {
        return _waterForeground;
    }

    int canWalkOn(Direction d) const {
        return DIR_IN_MASK(d, rule->_walkOnDirs);
    }
    int canWalkOff(Direction d) const {
        return DIR_IN_MASK(d, rule->_walkOffDirs);
    }

    int  canAttackOver() const {
        return isWalkable() || isSwimable() || isSailable() || (rule->_mask & MASK_ATTACKOVER);
    }
    int  canLandBalloon() const {
        return rule->_mask & MASK_CANLANDBALLOON;
    }
    int  isLivingObject() const {
        return rule->_mask & MASK_LIVING_THING;
    }
    int  isReplacement() const {
        return rule->_mask & MASK_REPLACEMENT;
    }
    int  isWaterReplacement() const {
        return rule->_mask & MASK_WATER_REPLACEMENT;
    }

    int  isWalkable() const {
        return rule->_walkOnDirs > 0;
    }
    bool isCreatureWalkable() const {
        return canWalkOn(DIR_ADVANCE) && !(rule->_movementMask & MASK_CREATURE_UNWALKABLE);
    }
    bool isDungeonWalkable() const;
    bool isDungeonFloor() const;
    int  isSwimable() const {
        return rule->_movementMask & MASK_SWIMABLE;
    }
    int  isSailable() const {
        return rule->_movementMask & MASK_SAILABLE;
    }
    bool isWater() const {
        return (isSwimable() || isSailable());
    }
    int  isFlyable() const {
        return !(rule->_movementMask & MASK_UNFLYABLE);
    }
    int  isDoor() const {
        return rule->_mask & MASK_DOOR;
    }
    int  isLockedDoor() const {
        return rule->_mask & MASK_LOCKEDDOOR;
    }
    int  isChest() const {
        return rule->_mask & MASK_CHEST;
    }
    int  isShip() const {
        return rule->_mask & MASK_SHIP;
    }
    bool isPirateShip() const {
        return _name == "pirate_ship";
    }
    int  isHorse() const {
        return rule->_mask & MASK_HORSE;
    }
    int  isBalloon() const {
        return rule->_mask & MASK_BALLOON;
    }
    int  canDispel() const {
        return rule->_mask & MASK_DISPEL;
    }
    int  canTalkOver() const {
        return rule->_mask & MASK_TALKOVER;
    }
    TileSpeed getSpeed() const {
        return rule->_speed;
    }
    TileEffect getEffect() const {
        return rule->_effect;
    }

    bool isOpaque() const;

    bool isForeground() const;
    Direction directionForFrame(int frame) const;
    int frameForDirection(Direction d) const;

    static void resetNextId() {
        _nextId = 0;
    }
    static bool canTalkOverTile(const Tile *tile) {
        return tile->canTalkOver() != 0;
    }
    static bool canAttackOverTile(const Tile *tile) {
        return tile->canAttackOver() != 0;
    }
    void deleteImage();

private:
    void loadImage();

private:
    TileId _id;          
    Common::String _name;        
    Tileset *_tileSet;   
    int _w, _h;           
    int _frames;         
    int _scale;          
    TileAnim *_anim;     
    bool _opaque;        
    bool _foreground;    
    bool _waterForeground;
    TileRule *rule;     
    Common::String _imageName;   
    Common::String _looksLike;  
    Image *_image;       
    bool _tiledInDungeon;
    Std::vector<Direction> _directions;

    Common::String _animationRule;


    static TileId _nextId;
};

} // End of namespace Ultima4
} // End of namespace Ultima

#endif