map_mif.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 SCUMM_HE_MOONBASE_MAP_MIF_H
#define SCUMM_HE_MOONBASE_MAP_MIF_H

#ifdef ENABLE_HE

#include "scumm/he/intern_he.h"

namespace Scumm {

#define MAX_TILE_COUNT 80

#include "common/pack-start.h"  // START STRUCT PACKING

struct PixelLoc {
    uint16 x;
    uint16 y;
};

struct EnergyPoolLoc {
    PixelLoc location;
    PixelLoc dummy;
};


struct MapFile {
    // Header:
    uint16 headerDummy;
    uint16 terrainDimX;
    uint16 terrainDimY;
    uint16 mapType;
    uint16 numEnergyPools;

    uint16 terrainStates[80][161];
    uint8 space1[230];
    char name[17];
    uint8 space2[25837];
    EnergyPoolLoc poolLocs[49];
    PixelLoc lastPool;
    uint16 dummy;
    PixelLoc fourPlayerPoints[4];  // 2^0
    PixelLoc threePlayerPoints[3]; // 2^1
    PixelLoc twoPlayerPoints[2];   // 2^2
    PixelLoc twoVTwoPoints[4];     // 2^3
    PixelLoc oneVThreePoints[4];   // 2^4
    PixelLoc oneVTwoPoints[3];     // 2^5

    MapFile() {
        memset(this, 0, sizeof(MapFile));

        mapType = 1;
        memset(fourPlayerPoints, 0xFF, sizeof(fourPlayerPoints));
        memset(threePlayerPoints, 0xFF, sizeof(threePlayerPoints));
        memset(twoPlayerPoints, 0xFF, sizeof(twoPlayerPoints));
        memset(twoVTwoPoints, 0xFF, sizeof(twoVTwoPoints));
        memset(oneVThreePoints, 0xFF, sizeof(oneVThreePoints));
        memset(oneVTwoPoints, 0xFF, sizeof(oneVTwoPoints));
    }
} PACKED_STRUCT;

#include "common/pack-end.h"    // END STRUCT PACKING

class MIF {
public:
    MIF();

    void generateMap(MapFile *map);

    int _dimension = 0; // 32 (small), 40 (medium), 48 (large), 56 (huge), 64 (SAI)
    int _mapType = 0;
    char _name[17] = {};
    byte _cornerMap[MAX_TILE_COUNT][MAX_TILE_COUNT] = { {}, {} };
    int8 _centerMap[MAX_TILE_COUNT][MAX_TILE_COUNT] = { {}, {} };
private:

    void defineStartLocations(MapFile *map);
    void defineEnergyPools(MapFile *map);
    void makeCraters(MapFile *map);
    uint16 findTileFor(int x, int y);

    inline char tlCenter(int x, int y) const {
        return _centerMap[(0 == x) ? _dimension - 1 : x - 1][(0 == y) ? _dimension - 1 : y - 1];
    }

    inline char tCenter(int x, int y) const {
        return _centerMap[x][(0 == y) ? _dimension - 1 : y - 1];
    }

    inline char trCenter(int x, int y) const {
        return _centerMap[(x + 1) % _dimension][(0 == y) ? _dimension - 1 : y - 1];
    }

    inline char lCenter(int x, int y) const {
        return _centerMap[(0 == x) ? _dimension - 1 : x - 1][y];
    }

    inline char rCenter(int x, int y) const {
        return _centerMap[(x + 1) % _dimension][y];
    }

    inline char blCenter(int x, int y) const {
        return _centerMap[(0 == x) ? _dimension - 1 : x - 1][(y + 1) % _dimension];
    }

    inline char bCenter(int x, int y) const {
        return _centerMap[x][(y + 1) % _dimension];
    }

    inline char brCenter(int x, int y) const {
        return _centerMap[(x + 1) % _dimension][(y + 1) % _dimension];
    }

    inline byte tlCorner(int x, int y) const {
        return _cornerMap[x][y];
    }

    inline byte trCorner(int x, int y) const {
        return _cornerMap[(x + 1) % _dimension][y];
    }

    inline byte blCorner(int x, int y) const {
        return _cornerMap[x][(y + 1) % _dimension];
    }

    inline byte brCorner(int x, int y) const {
        return _cornerMap[(x + 1) % _dimension][(y + 1) % _dimension];
    }

    inline byte ttllCorner(int x, int y) const {
        return tlCorner((x == 0) ? _dimension - 1 : x - 1, (y == 0) ? _dimension - 1: y - 1);
    }

    inline byte ttlCorner(int x, int y) const {
        return trCorner((x == 0) ? _dimension - 1 : x - 1, (y == 0) ? _dimension - 1: y - 1);
    }

    inline byte ttrCorner(int x, int y) const {
        return tlCorner((x + 1) % _dimension, (y == 0) ? _dimension - 1: y - 1);
    }

    inline byte ttrrCorner(int x, int y) const {
        return trCorner((x + 1) % _dimension, (y == 0) ? _dimension - 1: y - 1);
    }

    inline byte tllCorner(int x, int y) const {
        return tlCorner((x == 0) ? _dimension - 1 : x - 1, y);
    }

    inline byte trrCorner(int x, int y) const {
        return trCorner((x + 1) % _dimension, y);
    }

    inline byte bllCorner(int x, int y) const {
        return blCorner((x == 0) ? _dimension - 1 : x - 1, y);
    }

    inline byte brrCorner(int x, int y) const {
        return brCorner((x + 1) % _dimension, y);
    }

    inline byte bbllCorner(int x, int y) const {
        return blCorner((x == 0) ? _dimension - 1 : x - 1, (y + 1) % _dimension);
    }

    inline byte bblCorner(int x, int y) const {
        return brCorner((x == 0) ? _dimension - 1 : x - 1, (y + 1) % _dimension);
    }

    inline byte bbrCorner(int x, int y) const {
        return blCorner((x + 1) % _dimension, (y + 1) % _dimension);
    }

    inline byte bbrrCorner(int x, int y) const {
        return brCorner((x + 1) % _dimension, (y + 1) % _dimension);
    }

};

} // End of namespace Scumm

#endif // ENABLE_HE

#endif // SCUMM_HE_MOONBASE_MAP_MIF_H