scummvm/engines/immortal/room.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/>.
 *
 */

/* --- What is a Room ---
 *
 */

// Common/system includes basic things like Array
#include "common/system.h"

// Story is needed by both immortal.h and room.h
#include "immortal/story.h"

// Utilities.h contains many things used by all objects, not just immortal
#include "immortal/utilities.h"
#include "immortal/immortal.h"

#ifndef IMMORTAL_ROOM_H
#define IMMORTAL_ROOM_H

namespace Immortal {

enum RoomTile : uint8 {
	kTileFloor,
	kTileUpper5,
	kTileUpper3,
	kTileCeiling,
	kTileTop1,
	kTileTop7,
	kTileWallFace,
	kTileTopLower13,
	kTileTopLower75,
	kTileLower3,
	kTileLower5,
	kTileCeilingTile = 2 // This duplicate is intentional
};

/* Quick note:
 * This looks entirely redundant and silly, I agree. However
 * this is because the source does more or less the same thing.
 * At compile time, it creates and stores in memory what are the
 * equivalent of structs (or maybe tuples), and then at run time
 * when creating a room, it makes room specific versions that can
 * be changed. So essentially it creates two RAM structs and then
 * treats the first as ROM. As such, that's what I'm doing here.
 * The 'Story' structs are ROM, the 'Room' structs are RAM. There
 * are also slight differences, like how the room Flame has a reference
 * to the Cyc it is using. Although again the Story ones are ram
 * and could do this too.
 */

// Temp
struct Object {
};

// Temp
struct Monster {
};

struct Flame {
	FPattern _p = kFlameOff;
	uint8 _x = 0;
	uint8 _y = 0;
	int _c = 0;
};

struct Chest {
};

struct Bullet {
};

class Room {
private:
	Common::RandomSource _randomSource;

public:
	Room(uint8 x, uint8 y, RoomFlag f);
	~Room() {}

	/*
	 * --- Data ---
	 *
	 */

	// Constants
	const uint8 kLightTorchX  = 10;
	const uint8 kMaxFlameCycs = 16;

	Common::Array<SCycle>  _cycPtrs;
	Common::Array<Flame>   _fset;
	Common::Array<Monster> _monsters;
	Common::Array<Object>  _objects;

	RoomFlag _flags;

	uint8 _xPos      = 0;
	uint8 _yPos      = 0;
	uint8 _holeRoom  = 0;
	uint8 _holeCellX = 0;
	uint8 _holeCellY = 0;
	uint8 _candleTmp = 0;                           // Special case for candle in maze 0
	uint8 _numFlames = 0;
	uint8 _numInRoom = 0;

	/*
	 * --- Methods ---
	 *
	 */

	uint32 getRandomNumber(uint maxNum) {
		return _randomSource.getRandomNumber(maxNum);
	}

	/*
	 * [room.cpp] Functions from Room.GS
	 */

	//void init();
	//void inRoomNew();
	//void getTilePair(uint8 x, uint8 y);           // Modifies a struct of the tile number, aboveTile number, and the cell coordinates of the tile

	void setHole();
	void drawContents(uint16 vX, uint16 vY);
	bool getTilePair(uint8 x, uint8 y, int id);
	bool getWideWallNormal(uint8 x, uint8 y, uint8 xPrev, uint8 yPrev, int id, int spacing);
	bool getWallNormal(uint8 x, uint8 y, uint8 xPrev, uint8 yPrev, int id);
	void addMonster();
	void addObject();
	void removeObject();
	void removeMonster();
	Common::Array<Monster> getMonsterList();
	Common::Array<Object> getObjectList();
	void getXY(uint16 &x, uint16 &y);
	void getCell(uint16 &x, uint16 &y);


	/*
	 * [Cycle.cpp] Functions from Cyc
	 */

	// Init
	int cycleNew(CycID id);                        // Adds a cycle to the current list
	void cycleFree(int c);

	// Getters
	DataSprite *cycleGetDataSprite(int c);          // This takes the place of getFile + getNum
	int cycleGetIndex(int c);
	int cycleGetFrame(int c);
	int cycleGetNumFrames(int c);

	// Setters
	void cycleSetIndex(int c, int f);

	// Misc
	bool cycleAdvance(int c);
	CycID getCycList(int c);

	/* Unnecessary cycle functions
	void cycleInit();
	void cycleFree();
	void cycleGetNumFrames();
	void cycleGetList();*/

	/*
	 * [flameSet.cpp] Functions from flameSet.GS
	 */

	//void flameNew() does not need to exist, because we create the duplicate SFlame in Level, and the array in immortal.h is not accessible from here
	void flameInit();
	void flameDrawAll(uint16 vX, uint16 vY);
	bool roomLighted();
	void lightTorch(uint8 x, uint8 y);
	void flameFreeAll();
	void flameSetRoom(Common::Array<SFlame> &allFlames);
	int flameGetCyc(Flame *f, int first);

	/*
	 * [bullet.cpp] Functions from Bullet.GS
	 */



	/*
	 * [object.cpp] Functions from Object.GS
	 */


	/*
	 * [Univ.cpp] Functions from Univ.GS
	 */

	void univAddSprite(uint16 vX, uint16 vY, uint16 x, uint16 y, SpriteName s, int img, uint16 p);
};

} // namespace Immortal

#endif