プログラマ専用SNS ミクプラ

コード:

class MapBase
{
	//レイヤとして機能するクラスの基底クラス
	//表示方法を変えるために、多態性を使う可能性有り
public:
	//setter
	virtual void Initialize(int width,int height,int thisLayerNum) = 0;
	virtual void FreeThisLayer() = 0;
	//from control
	virtual void DrawMap() = 0;
	virtual void ScrollUpdate() = 0;
	//from actor, dungeon generation
	virtual bool IsPassable(int,int) = 0;
	virtual void SetCell_chipID(int,int,int) = 0;

	virtual ~MapBase() = 0 {}//純粋仮想デストラクタ：定義が必要 (= 0 では仮想関数であることを示すだけ)
};

namespace MapTree
{
	void LoadMapTree();//全マップファイルのパス等を構造体に得る　ゲーム開始時に実行
}

namespace MapData
{
	//loader
	void LoadMap(int mapID);
	void DeleteMap();

	//マップ情報を受けて
	int GetCellID(int x,int y);
	bool IsInsideMap(int x, int y);
	//この2つは、多態性の代わりに分岐を使う。(多態性を使いたかった)。
	//MapBaseから派生するクラスはレイヤとして機能するが、
	//これら2つの関数はレイヤの機能ではないと考えたたため、ここに置いた。
	void ToScreen(int,int,int*,int*,int changePoint = 1,int onMap = 0);//デフォルト引数はオウヴァロード前の値になる、注意
	void ToCell(int,int,int*,int*);//【警告】絶対位置を引数に取る

	//メンバ変数のカプセル化
	bool IsQMap();
	void GetMapSize(int *width, int *height);
	int GetAllLayerNum();
	void GetScroll(int *x,int *y);
	void SetScroll(int x, int y);

	//layer
	namespace MapLayer
	{
		extern MapBase *layer[3];
		//3レイヤを見る関数
		bool IsPassable(int x,int y);
		//fovLayer
		void ResetVisible();
		void SetVisible(int x,int y,bool visible);
		bool IsVisible(int x,int y);
	}

	//マップ上への描画位置の補正用 from actor
	//ここに置くべきか？
	namespace EventData
	{
		int GetEventsNum();
		void GetCharaShift(int *x,int *y);
	}
}

コード:

struct MapDataStruct//MapTree用
{
	char mapName[30];
	char mapFile[30];
	int tileID; int BGM; int BGS;
};
struct TileSetsStruct//MapTree用
{
	char tileFile[30];
	char tileGraph[30];
};

namespace MapTree
{
	MapDataStruct mapDatas[10];
	TileSetsStruct tileSets[10];
	void LoadMapTree();
}

namespace MapData
{
	//Map情報(マップ毎の定数)
	int mapWidth,mapHeight; void GetMapSize(int *width, int *height){*width = mapWidth; *height = mapHeight;}
	int allLayerNum = 3; int GetAllLayerNum(){return(allLayerNum);}

	//MapLoader
	void LoadMap(int mapID);
	void DeleteMap()
	{
		for(int i = 0; i < allLayerNum; i++)
		{
			delete MapLayer::layer[i];//下の名前空間の中身にアクセスしてしまっている
		}
	}

	//定数を受けて
	bool IsInsideMap(int x, int y)
	{
		if(x >= 0 && x < mapWidth &&
			y >= 0 && y < mapHeight    )
		{
			return(TRUE);
		}else
		{
			return(FALSE);
		}
	}
	int GetCellID(int x,int y){return(y*mapWidth + x);}
	void ToScreen(int,int,int*,int*,int changePoint,int onMap);//デフォルト引数はオウヴァロード前の値になる、注意
	void ToCell(int,int,int*,int*);//【警告】絶対位置を引数に取る

	//描画用定数
	bool isQMap; bool IsQMap(){return(isQMap);}
	int mapShiftX,mapShiftY;
	int minScrollX,minScrollY;
	int maxScrollX,maxScrollY;

	//QMap用
	int leftSpace,rightSpace,upSpace,downSpace;

	//一時情報
	int scrollX,scrollY;
	void GetScroll(int *x,int *y){*x = scrollX; *y = scrollY;}
	void SetScroll(int x, int y)
	{
		if(maxScrollX < x) x = maxScrollX;
		if(minScrollX > x) x = minScrollX;
		if(maxScrollY < y) y = maxScrollY;
		if(minScrollY > y) y = minScrollY;
		scrollX = x; scrollY = y;
	}

	namespace TileData
	{
		int tileID;
		int *traffic;
		char *tileGraph;
		int cellWidth,cellHeight;
		int tileWidth,tileHeight;//ピクセル
		int *tileDiv;
		//QMap用
		int qCellWidth,qCellHeight;
	}
	namespace MapLayer
	{
		//layers
		MapBase *layer[3];
		bool IsPassable(int x,int y)//全レイヤを見て返す
		{
			if( IsInsideMap(x,y) == FALSE ) return(0);
			int result = 0;
			for(int i = 0; i < allLayerNum; i++)
			{
				result += layer[i]->IsPassable(x,y);
			}
			if( result == allLayerNum) return(TRUE);//全て通行可能タイル
			else return(FALSE);//少なくとも1つが通行不能タイル
		}

		bool *isVisible;
		void ResetVisible()//使わない？
		{
			int num = mapWidth * mapHeight;
			for(int i = 0; i < num; i++)
			{
				isVisible[i] = 0;
			}
		}
		void SetVisible(int x,int y,bool visible)
		{
			isVisible[ GetCellID(x,y) ] = visible;
		}
		bool IsVisible(int x,int y)
		{
			return( isVisible[ GetCellID(x,y) ] );
		}
	}

	//Event 描画座標の補正用変数はここにおくべきではない？
	namespace EventData
	{
		int charaShiftX,charaShiftY;
		int eventsNum;
		void GetCharaShift(int *x,int *y){*x = charaShiftX; *y = charaShiftY;}
	}
}

コード:

#include <memory>

// Imageは矩形イメージ描画の基となる抽象クラス
class Image
{
public:
	virtual void Draw(int xofs, int yofs) = 0;
};

// 派生クラスは作成関数を公開し実装は非公開
std::shared_ptr<Image> MakeColorImage(int w, int h, int color);
std::shared_ptr<Image> MakeGraphImage(const char *filename);

コード:

#include "image.hpp"
#include "DxLib.h"

/*
  Imageの派生クラスの実装
*/

class ColorImage : public Image
{
private:
	int width, height, color;
public:
	ColorImage(int width, int height, int color)
	: width(width), height(height), color(color)
	{}
	void Draw(int x, int y) {
		DrawBox(x, y, x+width, y+height, color, TRUE);
	}
};

std::shared_ptr<Image> MakeColorImage(int w, int h, int color)
{
	return std::make_shared<ColorImage>(w, h, color);
}

class GraphImage : public Image
{
private:
	int handle;
public:
	GraphImage(const char *filename) {
		handle = LoadGraph(filename);
	}
	void Draw(int x, int y) {
		DrawGraph(x, y, handle, TRUE);
	}
};

std::shared_ptr<Image> MakeGraphImage(const char *filename)
{
	return std::make_shared<GraphImage>(filename);
}

コード:

#include <vector>
#include <memory>

// イメージリストはとりあえずの形
typedef std::vector<std::shared_ptr<Image>> TileImageList;

class TileIndexer
{
public:
	virtual int GetTileIndex(int x, int y) = 0;
	virtual int GetMapWidth() = 0;
	virtual int GetMapHeight() = 0;

	// このサンプルでは適当な場所がないので
	// タイルの大きさを取得するメソッドをとりあえずここに配置
	virtual int GetTileWidth() = 0;
	virtual int GetTileHeight() = 0;
};

class Tilemap : public Image
{
private:
	TileIndexer &idxr;
	TileImageList &imglst;
public:
	Tilemap(int w, int h, TileIndexer &idxr, TileImageList &imglst)
	: idxr(idxr), imglst(imglst) {}
	void Draw(int x, int y) {
		int mw = idxr.GetMapWidth();
		int mh = idxr.GetMapHeight();
		int tx = x, ty = y;
		for (int i=0; i<mh; i++) {
			for (int j=0; j<mw; j++) {
				imglst[idxr.GetTileIndex(j, i)]->Draw(tx, ty);
				tx += idxr.GetTileWidth();
			}
			ty += idxr.GetTileHeight();
			tx = x;
		}
	}
};

コード:

#include "DxLib.h"
#include "image.hpp"
#include "tilemap.hpp"
#include <cstdint>
#include <memory>

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
	ChangeWindowMode(TRUE);
	if (DxLib_Init() != 0) return 0;
	SetDrawScreen(DX_SCREEN_BACK);

	/*
	  タイルマップひとつめ
	*/
	// イメージリスト
	TileImageList imglst20;
	imglst20.push_back(MakeColorImage(8, 8, GetColor(  0,  0,  0)));
	imglst20.push_back(MakeColorImage(8, 8, GetColor(128,192,255)));
	imglst20.push_back(MakeGraphImage("30.png"));
	// マップデータ
	uint32_t mapdata20[8*8] = {
		0,0,1,0,0,0,0,0,
		0,0,0,1,0,0,0,1,
		0,0,1,1,1,1,1,1,
		0,1,1,0,1,2,1,0,
		1,1,1,1,1,1,1,1,
		1,0,1,1,1,1,1,1,
		1,0,1,0,0,0,0,0,
		0,0,0,1,1,0,1,1,
	};
	class TileIndexer20 : public TileIndexer
	{
		uint32_t *mapdata;
	public:
		TileIndexer20(uint32_t *mapdata)
		: mapdata(mapdata) {}
		int GetTileIndex(int x, int y) {
			return mapdata[y*GetMapWidth()+x];
		}
		int GetMapWidth() { return 8; }
		int GetMapHeight() { return 8; }
		int GetTileWidth() { return 8; }
		int GetTileHeight() { return 8; }
	} tileindexer20(mapdata20);
	Tilemap tilemap20(64, 64, tileindexer20, imglst20);
	/*
	  タイルマップその2
	*/
	// イメージリスト
	TileImageList imglst10;
	imglst10.push_back(MakeColorImage(64, 64, GetColor(  0,  0,  0)));
	imglst10.push_back(MakeColorImage(64, 64, GetColor(255,128,192)));
	/*※※※※ イメージリストにタイルマップを登録して入れ子に ※※※※*/
	imglst10.push_back(std::shared_ptr<Image>(new Tilemap(64, 64, tileindexer20, imglst20)));
	// マップデータ
	struct mapdata10_t { /*※※※※ データ形式は自由 ※※※※*/
		int dummy;
		int tileidx;
	} mapdata10[10*8] = {
		{0,0},{0,0},{0,0},{0,0},{0,1},{0,1},{0,1},{0,1},{0,0},{0,0},
		{0,0},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},
		{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},
		{0,1},{0,2},{0,1},{0,0},{0,0},{0,1},{0,1},{0,0},{0,0},{0,1},
		{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},
		{0,0},{0,0},{0,0},{0,1},{0,1},{0,0},{0,0},{0,1},{0,1},{0,0},
		{0,0},{0,0},{0,1},{0,1},{0,0},{0,1},{0,1},{0,0},{0,1},{0,1},
		{0,1},{0,1},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,1},
	};
	class TileIndexer10 : public TileIndexer
	{
		mapdata10_t *mapdata;
	public:
		TileIndexer10(mapdata10_t *mapdata)
		: mapdata(mapdata) {}
		int GetTileIndex(int x, int y) {
			return mapdata[y*GetMapWidth()+x].tileidx;
		}
		int GetMapWidth() { return 10; }
		int GetMapHeight() { return 8; }
		int GetTileWidth() { return 64; }
		int GetTileHeight() { return 64; }
	} tileindexer10(mapdata10);
	// タイルマップ
	Tilemap tilemap10(512, 512, tileindexer10, imglst10);

	while (ProcessMessage() == 0 && ScreenFlip() == 0 && ClearDrawScreen() == 0) {
		tilemap10.Draw(0, 0);
	}
	
	DxLib_End();
	return 0;
}

コード:

#include "DxLib.h"
#include "image.hpp"
#include "tilemap.hpp"
#include "stagecontext.hpp"
#include <cstdint>
#include <memory>

/*
 * 生マップデータ
 */

static uint8_t mapdata_layer1[8*8] = {
	0,0,0,1,1,0,0,0,
	0,0,1,1,1,1,0,0,
	0,1,1,1,1,1,1,0,
	1,1,0,1,1,0,1,1,
	1,1,1,1,1,1,1,1,
	0,0,1,0,0,1,0,0,
	0,1,0,1,1,0,1,0,
	1,0,1,0,0,1,0,1,
};
static uint8_t mapdata_layer2[8*8] = {
	0,0,1,0,0,0,0,0,
	0,0,0,1,0,0,0,1,
	0,0,1,1,1,1,1,1,
	0,1,1,0,1,1,1,0,
	1,1,1,1,1,1,1,1,
	1,0,1,1,1,1,1,1,
	1,0,1,0,0,0,0,0,
	0,0,0,1,1,0,1,1,
};
static uint8_t mapdata_layer3[8*8] = {
	0,0,0,0,1,1,1,1,
	0,1,1,1,1,1,1,1,
	1,1,1,1,1,1,1,1,
	1,1,1,0,0,1,1,0,
	1,1,1,1,1,1,1,1,
	0,0,0,1,1,0,0,1,
	0,0,1,1,0,1,1,0,
	1,1,0,0,0,0,0,0,
};

// 1マス分のタイル情報
struct TileInfo {
	int layer1;
	int layer2;
	int layer3;
};

/*
 * ここから描画用のオブジェクト
 */

class DungeonTileImageList : public TileImageList<TileInfo>
{
public:
	std::vector<std::shared_ptr<Image>> vec;
	int GetTileWidth() { return 32; }
	int GetTileHeight() { return 32; }
	std::shared_ptr<Image> GetImage(TileInfo &info) {
		class Tile : public Image {
		private:
			int width, height;
			DungeonTileImageList *parent;
			TileInfo &info;
		public:
			Tile(int width, int height, DungeonTileImageList *parent, TileInfo &info)
			: width(width), height(height), parent(parent), info(info) {}
			void Draw(int x, int y) {
				if (info.layer3) parent->vec[3]->Draw(x, y);
				if (info.layer2) parent->vec[2]->Draw(x+1, y+1);
				if (info.layer1) parent->vec[1]->Draw(x+2, y+2);
			}
		};
		return std::make_shared<Tile>(32, 32, this, info);
	}
};
static std::shared_ptr<TileImageList<TileInfo>> imglst;

class DungeonTileIndexer : public TileIndexer<TileInfo>
{
	uint8_t *mapdata_layer1;
	uint8_t *mapdata_layer2;
	uint8_t *mapdata_layer3;
public:
	DungeonTileIndexer(uint8_t *mapdata_layer1, uint8_t *mapdata_layer2, uint8_t *mapdata_layer3)
	: mapdata_layer1(mapdata_layer1)
	, mapdata_layer2(mapdata_layer2)
	, mapdata_layer3(mapdata_layer3) {}
	TileInfo GetTileInfo(int x, int y) {
		TileInfo info;
		info.layer1 = mapdata_layer1[y*GetMapWidth()+x];
		info.layer2 = mapdata_layer2[y*GetMapWidth()+x];
		info.layer3 = mapdata_layer3[y*GetMapWidth()+x];
		return info;
	}
	int GetMapWidth() { return 8; }
	int GetMapHeight() { return 8; }
};
static std::shared_ptr<TileIndexer<TileInfo>> tileidxr;

static std::shared_ptr<Tilemap<TileInfo>> tilemap;

/*
 * ここからイベント処理用のオブジェクト
 */

class DungeonMapEventListener : public MapEventListener
{
public:
	void ActionEvent(int x, int y, MapEvent e) {
		switch (e.kind) {
		case MapEvent::Wall_Break: /* 壁を壊す */
			if (x >= 0 && x < 8 && y >= 0 && y < 8) {
				/* 上から順に壁があれば消す */
				if (mapdata_layer1[y*8+x]) {
					mapdata_layer1[y*8+x] = 0;
				} else if (mapdata_layer2[y*8+x]) {
					mapdata_layer2[y*8+x] = 0;
				} else if (mapdata_layer3[y*8+x]) {
					mapdata_layer3[y*8+x] = 0;
				}
			}
		}
	}
};
static std::shared_ptr<MapEventListener> listener;

void dungeonMake()
{
	/*
	 * マップを生成する
	 */
	// (略)

	/*
	 * 描画用タイルマップを準備する
	 */
	/* イメージリスト */
	auto imglst1 = std::make_shared<DungeonTileImageList>();
	// とりあえずvectorに直接突っ込む
	imglst1->vec.push_back(MakeColorImage(32, 32, GetColor(0,0,0)));
	imglst1->vec.push_back(MakeColorImage(28, 28, GetColor(128,255,128)));
	imglst1->vec.push_back(MakeColorImage(30, 30, GetColor(128,128,255)));
	imglst1->vec.push_back(MakeColorImage(32, 32, GetColor(255,128,128)));
	imglst = imglst1;
	/* インデクサ(既に名前と合ってないが) */
	tileidxr = std::make_shared<DungeonTileIndexer>(mapdata_layer1, mapdata_layer2, mapdata_layer3);
	/* タイルマップ */
	tilemap = std::make_shared<Tilemap<TileInfo>>(256, 256, *tileidxr, *imglst);

	/*
	 * イベントのコールバックを処理するオブジェクトを登録
	 */
	listener = std::make_shared<DungeonMapEventListener>();
	GetStageContext().setMapEventListener(listener);
}

void dungeonDraw()
{
	tilemap->Draw(0, 0);
	/*
	  管理オブジェクトに優先順位付きで描画オブジェクトを登録して
	  管理オブジェクトが一括して描画する仕組みにすれば
	  個別の描画処理は不要になる

	  マップの屋根でキャラが隠れるような立体的な表示の場合でも、
	  描画オブジェクトを分けて登録すれば良いだけで
	  マップデータそのものに対する処理には影響ない
	*/
}

コード:

#include "DxLib.h"
#include "stagecontext.hpp"

void dungeonMake();
void dungeonDraw();

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
	ChangeWindowMode(TRUE);
	if (DxLib_Init() != 0) return 0;
	SetDrawScreen(DX_SCREEN_BACK);

	int mouse_input_old;
	int mouse_input_new;
	mouse_input_old = GetMouseInput();

	dungeonMake();

	while (ProcessMessage() == 0 && ScreenFlip() == 0 && ClearDrawScreen() == 0)
	{
		/* マウスを使って壁を壊す */
		mouse_input_new = GetMouseInput();
		if ((~mouse_input_old & mouse_input_new) & MOUSE_INPUT_LEFT) {
			int x, y;
			GetMousePoint(&x, &y);
			x /= 32; y /= 32;
			MapEvent e(MapEvent::Wall_Break);
			GetStageContext().makeMapEvent(x, y, e); /* イベント生成 */
			/* マップの座標取得は本来管理オブジェクトで行うべき */
		}
		mouse_input_old = mouse_input_new;

		dungeonDraw();
		DrawString(0, 256, "ドットをクリックすると...", GetColor(255,255,255));
	}

	DxLib_End();
	return 0;
}

コード:

#include <vector>
#include <memory>

template<class T>
class TileImageList
{
public:
	virtual int GetTileWidth() = 0;
	virtual int GetTileHeight() = 0;
	virtual std::shared_ptr<Image> GetImage(T &info) = 0;
};

template<class T>
class TileIndexer
{
public:
	virtual T GetTileInfo(int x, int y) = 0;
	virtual int GetMapWidth() = 0;
	virtual int GetMapHeight() = 0;
};

template<class T>
class Tilemap : public Image
{
private:
	TileIndexer<T> &idxr;
	TileImageList<T> &imglst;
public:
	Tilemap(int w, int h, TileIndexer<T> &idxr, TileImageList<T> &imglst)
	: idxr(idxr), imglst(imglst) {}
	void Draw(int x, int y) {
		int mw = idxr.GetMapWidth();
		int mh = idxr.GetMapHeight();
		int tx = x, ty = y;
		for (int i=0; i<mh; i++) {
			for (int j=0; j<mw; j++) {
				imglst.GetImage(idxr.GetTileInfo(j, i))->Draw(tx, ty);
				tx += imglst.GetTileWidth();
			}
			ty += imglst.GetTileHeight();
			tx = x;
		}
	}
};

コード:

#include <memory>

class MapEvent
{
public:
	enum Kind {
		Wall_Break,
	} kind;
	MapEvent(MapEvent::Kind k)
	: kind(k) {}
};

class MapEventListener
{
public:
	virtual void ActionEvent(int x, int y, MapEvent e) = 0;
};

class StageContext
{
public:
	virtual void setMapEventListener(std::shared_ptr<MapEventListener> listener) = 0;
	virtual void makeMapEvent(int x, int y, MapEvent e) = 0;
};

StageContext &GetStageContext();

コード:

#include "stagecontext.hpp"

class StageContext_impl : public StageContext
{
	std::shared_ptr<MapEventListener> listener;
public:
	void setMapEventListener(std::shared_ptr<MapEventListener> listener) {
		this->listener = listener;
	}
	void makeMapEvent(int x, int y, MapEvent e) {
		listener->ActionEvent(x, y, e);
	}
};

static StageContext_impl context;

StageContext &GetStageContext()
{
	return context;
}