map.h

来自「一个symbian 冒险游戏代码」· C头文件 代码 · 共 264 行

#ifndef _MAP_H
#define _MAP_H


#include "Def.h"
#include "MapProps.h"
#include "BlockInfo.h"
#include "Enemy.h"
#include "FixVec2.h"
#include "LevelTrigger.h"
#include "TextTrigger.h"
#include "EnableTrigger.h"
#include "ScreenTrigger.h"
#include "SpriteTrigger.h"
#include "ItemTrigger.h"
#include "CharStateTrigger.h"
#include "SpecialTrigger.h"
#include "dprintf.h"
#include "LineList.h"
#include <stdint.h>
#include <lang/Array.h>
#include <lang/String.h>

#ifdef WIN32_CONVERT
#include <lua/LuaObject.h>
#endif


class Surface;
class MapObject;
class Player;


namespace io {
	class InputStream;}


class Map

#ifdef WIN32_CONVERT
	: public lua::LuaObject
#endif

{
public:
	enum MapLoadingPhase
	{
		LOAD_NONE				= -1,
		LOAD_START				= 0,
		LOAD_START_REFRESH,
		LOAD_PROPERTIES,
		LOAD_BITMAP,
		LOAD_FINISH,
		LOAD_COUNT
	};

#ifdef DEBUG_INFO
	mutable LineList viewportLines;
#endif

	FixVec2		startBlock;

#ifndef WIN32_CONVERT
	explicit Map( void* p = 0 );
#else
	//Conversion constructor
	explicit Map( lua::LuaState* luastate = 0 );
#endif

	virtual ~Map();
	
	virtual void	save( lang::String filename );
	virtual void	load( lang::String filename );

	void	clear();

	bool	load();

	void	setAmbientSound( lang::String basename );

	void	render( Surface& dst );
	
	void	addPlayer( MapObject* obj );

	void	removePlayer();

	void	setPlayerStartPosition( const FixVec2& blockpos )	{m_playerStartPosition = blockpos;}
	
	void	addObject( MapObject* obj );
	
	void	removeObject( MapObject* obj );

	void	removeObjects();

	void	drawBlockBound( Surface& dst, const FixVec2& block );

	bool	testPointCollision( const FixVec2& pos, const FixVec2& delta, const FixVec2& dir ) const;

	int		getTriggers( const char* name, Trigger** triggerlist, int size );	// returns 0 if none found

	void	resetTriggers();

	MapObject*	player() const					{return m_player;}

	int		objects() const						{return m_objs;}
	int		getMapBlock( int x, int y ) const	{return m_map[y*m_props.mapWidth+x];}
	int		mapWidth() const					{return m_props.mapWidth;}
	int		mapHeight() const					{return m_props.mapHeight;}
	int		blockWidth() const					{return m_props.blockWidth;}
	int		blockHeight() const					{return m_props.blockHeight;}
	int		numBlockStr() const					{return m_props.numBlockStr;}
	int		numBlockGfx() const					{return m_props.numBlockGfx;}
	int		blockGapX() const					{return m_props.blockGapX;}
	int		blockGapY() const					{return m_props.blockGapY;}
	int		blockStaggerX() const				{return m_props.blockStaggerX;}
	int		blockStaggerY() const				{return m_props.blockStaggerY;}
	Fix		blockDimensionsRatio() const		{return m_blockDimensionsRatio;}
	bool	hasPlayer() const					{return ( m_player != 0 );}
	bool	isLoadingDone() const				{return m_loadingDone;}

	const char*	debugPrint() const				{return &m_debugPrint[0];}

	bool	isMapBlock( int x, int y ) const	{return unsigned(x) < unsigned(m_props.mapWidth) && unsigned(y) < unsigned(m_props.mapHeight);}

	// in map slots
	int		boundMinX() const					{return m_boundX0;}
	int		boundMinY() const					{return m_boundY0;}
	int		boundMaxX() const					{return m_boundX1;}
	int		boundMaxY() const					{return m_boundY1;}

	const char*	name() const					{return m_name;}
	lang::Array<Enemy> enemies() const;

	const char*	ambientSound() const			{return m_ambientSound;}

	MapObject*			getObject( int i ) const;
	const BlockInfo&	getBlockInfo( int block ) const		{return m_blocks[block];}

	FixVec2		pixelToBlock( const FixVec2& pos, bool* out_rightHalf = 0, bool* out_lowerHalf = 0, bool* out_oddBlock = 0 ) const;
	FixVec2		blockToPixel( const FixVec2& pos ) const;

	const lang::Array<LevelTrigger>&		levelTriggers() const		{return m_levelTriggers;}

	const lang::Array<TextTrigger>&			textTriggers() const		{return m_textTriggers;}

	const lang::Array<EnableTrigger>&		enableTriggers() const		{return m_enableTriggers;}

	const lang::Array<SpriteTrigger>&		spriteTriggers() const		{return m_spriteTriggers;}

	const lang::Array<ScreenTrigger>&		screenTriggers() const		{return m_screenTriggers;}

	const lang::Array<ItemTrigger>&			itemTriggers() const		{return m_itemTriggers;}

	const lang::Array<CharStateTrigger>&	charStateTriggers() const	{return m_charStateTriggers;}

	const lang::Array<SpecialTrigger>&		specialTriggers() const		{return m_specialTriggers;}

	lang::Array<ScreenTrigger>&				screenTriggers()			{return m_screenTriggers;}

#ifdef WIN32_CONVERT
	//Conversion functions
	//-------

	void	setStartBlock( float x, float y );
	
	void	addLevelTrigger( lang::String name, float x, float y, lang::String filename, float x1, float y1 );

	void	addTextTrigger( lang::String name, float x, float y, lang::String text, float time );

	void	addEnableTrigger( lang::String name, float x, float y, lang::String targetname, float enabled );

	void	setTriggerByItem( lang::String name, lang::String targetname );

	void	setTriggerByItems( lang::String name, lang::String otherItem, lang::String targetname );

	void	setTriggerReverseByItem( lang::String name, lang::String targetname );

	void	setTriggerByObjectState( lang::String name, lang::String statename, lang::String targetname );

	void	setTriggerReverseByObjectState( lang::String name, lang::String statename, lang::String targetname );

	void	addSpriteTrigger( lang::String name, float x, float y, lang::String sprite );

	void	addScreenTrigger( lang::String name, float x, float y, lang::String screen );

	void	addItemTrigger( lang::String name, float x, float y, lang::String item );

	void	removeItemTrigger( lang::String name, float x, float y, lang::String item );

	void	addCharStateTrigger( lang::String name, float x, float y, lang::String statename );
	
	void	addSpecialTrigger( lang::String name, lang::String type, float x, float y, lang::String parameterString, float parameterValue );

	void	disableTrigger( lang::String name );

	float	addEnemy(	lang::String name, float x, float y, float angle, lang::String type, float hitpoints,
						float speed, float attackdamage, float attackskill, float aggression );

	//-------

#endif

protected:
	enum
	{
		MAX_OBJECTS = 100,
	};

	MapProps						m_props;
	lang::Array<BlockInfo>			m_blocks;
	lang::Array<uint16_t>			m_map;
	int								m_boundX0;
	int								m_boundY0;
	int								m_boundX1;
	int								m_boundY1;
	lang::Array<LevelTrigger>		m_levelTriggers;
	lang::Array<TextTrigger>		m_textTriggers;
	lang::Array<EnableTrigger>		m_enableTriggers;
	lang::Array<SpriteTrigger>		m_spriteTriggers;
	lang::Array<ScreenTrigger>		m_screenTriggers;
	lang::Array<ItemTrigger>		m_itemTriggers;
	lang::Array<CharStateTrigger>	m_charStateTriggers;
	lang::Array<SpecialTrigger>		m_specialTriggers;
	lang::Array<Enemy>				m_enemies;
	MapObject*						m_objlist[MAX_OBJECTS];
	
	int								m_objBlockPosX0[MAX_OBJECTS];
	int								m_objBlockPosY0[MAX_OBJECTS];
	int								m_objBlockPosX1[MAX_OBJECTS];
	int								m_objBlockPosY1[MAX_OBJECTS];
	
	int								m_objs;
	
	Fix								m_blockDimensionsRatio;
	
	void							computeIntermediates();
	void							drawBlock( Surface& dst, int dstx, int dsty, int blockgfx );
	static void						checkId( io::InputStream* in, int okid );
	int								getCollisionLines( int x, int y, FixVec2* linelist ) const;

private:
	int			m_loadingPhase;
	char		m_name[32];
	char		m_fileName[1024];
	char		m_ambientSound[32];
	char		m_debugPrint[1024];
	FixVec2		m_playerStartPosition;
	MapObject*	m_player;
	bool		m_loadingDone;

	Map( const Map& );
	Map& operator=( const Map& );
};


inline MapObject* Map::getObject( int i ) const
{
	assert( i >= 0 && i < m_objs );
	return m_objlist[i];
}


#endif // _MAP_H