CODE:

class IMapData
{
public:
	virtual ~IMapData(){}
public:
	virtual int Width() const = 0;
	virtual int Height() const = 0;
	virtual unsigned char At( int x, int y ) const = 0;
};

CODE:

enum MapChipType
{
	Wall,	//壁．侵入不可
	Free,	//何もない場所．侵入可．
	Mine	//地雷がある場所．侵入可．
};

class MapData : public IMapData
{
private:
	static constexpr int W = 20;
	static constexpr int H = 16;
	unsigned char m_Data[H][W];
public:
	MapData()
	{
		for( int y=0; y<H; ++y )
		{
			for( int x=0; x<W; ++x )
			{	m_Data[y][x] = Free;	}
		}
		m_Data[4][4] = m_Data[3][5] = m_Data[3][6] = m_Data[3][8] = m_Data[4][8] = Wall;
		m_Data[2][2] = m_Data[6][10] = Mine;
	}
public:	//IMapData Implementation
	virtual int Width() const override {	return W;	}
	virtual int Height() const override {	return H;	}
	virtual unsigned char At(int x, int y) const override
	{
		if( x<0 || x>=W || y<0 || y>=H )return Wall;
		return m_Data[y][x];
	}
public:
	unsigned char At( const Vec2i &Pos ) const {	return At( Pos[0], Pos[1] );	}
};

CODE:

//表示スクロール関係
//	てきとーな言葉の定義：
//		表示したい物全体のことを "Content", その一部を "Image" として見る（描画する）っていう話を考える．
//		（e.g. マップ全体のうちの一部だけを描画するよね，っていう話）

//Content の指定箇所を着目するようなスクロール量を求む．
//	「スクロール量」とは Image 上での座標0 に対応した Content 上の座標値のこと．
//典型的には Image の中心に着目点が来るようなスクロール量を返すが，
//着目点が Content の端付近である場合には，なるべく Image 内に Content の内容を多く含むように調整した値を求む．
//（e.g. 着目点として座標0を指定した場合，そこを Image の中央に捉えるのではなく，Contentの端(0)とImageの端(0)を一致させるようにする）
inline int CalcScrollAmountToFocus( int ContentSize, int FocusPosOnContent, int ImageSize )
{
	int RawScroll = FocusPosOnContent - ImageSize/2;
	if( RawScroll<0 )return 0;
	if( RawScroll + ImageSize > ContentSize )return (std::max)( 0, ContentSize-ImageSize);
	return RawScroll;
}

//Content上の座標に対応したImage内の座標
inline int ImagePos( int ContentPos, int ScrollAmount ){	return ContentPos - ScrollAmount;	}
//Image内の座標に対応したContent上の座標
inline int ContentPos( int ImagePos, int ScrollAmount ){	return ImagePos + ScrollAmount;	}

CODE:

//Mapの描画に必要な座標変換手段
//	｛スクロール，１マスをどんなpixelサイズで描画するのか｝というあたりの計算を解決する．
template< int MAP_CELL_PIXEL_SIZE >	//マップの１マスの描画サイズ（縦横共通）[pixel]
class ICoordinateTrans
{
public:
	virtual ~ICoordinateTrans(){}
public:
	//ContentPix : スクロールと無関係なPixel座標（≒マップ全体を一枚の絵に描画した場合の座標）
	//ImagePix : スクロールの影響を受けたPixel座標（表示用画像の上での座標）

		//マップのマスの左上に対する ContentPix
	static Vec2i MapCellTL_to_ContentPix( const Vec2i &MapPos ){	return MapPos*MAP_CELL_PIXEL_SIZE;	}
		//マップのマスの中心に対する ContentPix
	static Vec2i MapCellCenter_to_ContentPix( const Vec2i &MapPos )
	{	return MapCellTL_to_ContentPix(MapPos) + Vec2i(MAP_CELL_PIXEL_SIZE/2, MAP_CELL_PIXEL_SIZE/2);	}
		//ContentPix がどのマップのマス内か
	static Vec2i ContentPix_to_MapCell( const Vec2i &ContentPixPos ){	return ContentPixPos/MAP_CELL_PIXEL_SIZE;	}

	//ContentPix ←→ ImagePix （スクロールに関する演算）
	virtual Vec2i ContentPix_to_ImagePix( const Vec2i &ContentPixPos ) const = 0;
	virtual Vec2i ImagePix_to_ContentPix( const Vec2i &ImagePixPos ) const = 0;
};

CODE:

//Mapの描画処理．
//スクロール状態的に見ていている範囲を描画する処理
template< int MAP_CELL_PIXEL_SIZE >	//マップの１マスの描画サイズ（縦横共通）[pixel]
void DrawMap(
	HDC hdc, int W, int H,	//描画先hdc と，そこに選択されているbitmapのサイズ(＝描画対象画像のサイズ)
	const IMapData &MapData,
	const ICoordinateTrans<MAP_CELL_PIXEL_SIZE> &CT,
	const COLORREF *Colors	//※IMapData::At()の値に対する描画色を得るための配列
);

CODE:

//ゲーム処理側から表示器に対して表示物を登録する手段
class IDispItemRegistration
{
public:
	~IDispItemRegistration(){}
public:
	enum class Layer
	{
		Constant=0,	//Mapとか，基本ずっと表示しているような物
		Effect=1	//エフェクト用
	};

	//表示物を登録．
	//* 同一 layer に複数登録した場合，Paint()メソッドの呼び出し順は登録した順になる．
	//* Finished()がtrueを返す状態になった物は登録解除される．
	virtual void RegisterDisplayItem( Layer layer, std::shared_ptr<IDispItem> DispItem ) = 0;
};

CODE:

//表示物取り扱いの具体実装
class Painter : public IDispItemRegistration
{
private:
	DispItemList m_Layers[2];

public:	//IDispItemRegistration Implementation
	virtual void RegisterDisplayItem( Layer layer, std::shared_ptr<IDispItem> DispItem ) override {	m_Layers[(int)layer].AddDispItem(DispItem);	}
public:
	bool Update()
	{
		bool Ret = false;
		for( auto &L : m_Layers ){	Ret |= L.Update();	}
		return Ret;
	}

	void Paint( HDC hdc, int W, int H ) const
	{
		{//clear with Black
			RECT rect{ 0,0, W, H };
			::FillRect( hdc, &rect, (HBRUSH)::GetStockObject(BLACK_BRUSH) );
		}
		for( const auto &L : m_Layers ){	L.Paint( hdc, W,H );	}
	}
};

CODE:

//ゲームの進行処理
UpdateResult Update( const Input_b &rInput, IDispItemRegistration &IDIR )
{
	//エフェクト待ち状態ならreturn
	if( m_EffectWaitCounter )return UpdateResult(false);

	bool NeedToRedraw = false;
	//キー入力による移動処理
	if( Walk( rInput, IDIR ) ){	NeedToRedraw = true;	}

	return UpdateResult( NeedToRedraw );
}

CODE:

//UnitDir には，押したキーに対応した方向の単位ベクトルが与えられる．
//例えば，右方向なら (1,0) になる．
bool StartWalking( const Vec2i &UnitDir, IDispItemRegistration &IDIR )
{
	//移動先のマスの属性を調べる．「壁」なら移動できないからreturn．
	Vec2i TgtPos = m_WalkerPos + UnitDir;
	unsigned char TgtMapCellAttr = m_Map.At( TgtPos );
	if( TgtMapCellAttr == Wall )return false;

	{//Effect
		auto upRawEffectSeq = std::make_unique< DispItemSeq >();
		upRawEffectSeq->PushDispItem( std::make_unique<WalkingEffect>( *this, m_WalkerPos, TgtPos, 4 ) );

		if( TgtMapCellAttr == Mine )  //地雷を踏んだら
		{	upRawEffectSeq->PushDispItem( std::make_unique<ExplosionEffect<32,6> >( *this, TgtPos, 12 ) );	}

		IDIR.RegisterDisplayItem(
			IDispItemRegistration::Layer::Effect,
			std::make_unique<WaitableDispItem>( std::move(upRawEffectSeq), [this]()->bool{	return this->OnWalkFinished();	} )
		);

		//「待ち」状態にするためにカウンタを更新
		++m_EffectWaitCounter;
		//通常時にキャラクターを丸で描いているやつの描画を止める
		m_spWalkerPainter->SetVisibility(false);
	}

	//ゲーム進行としての必要な処理はコレだけ．
	m_WalkerPos = TgtPos;	//キャラクターの座標を更新
	return true;
}

CODE:

//移動のエフェクト表示が終わったとき
bool OnWalkFinished()
{
	m_spWalkerPainter->SetVisibility(true);  //通常時のキャラクタ描画を再開
	--m_EffectWaitCounter;  //待ちカウンタを減らす
	FocusTo( MapCellCenter_to_ContentPix( m_WalkerPos ) );  //念のためスクロール位置をキャラクタ位置に基づいて設定
	return true;
}

CODE:

std::make_unique<WalkingEffect>( *this, m_WalkerPos, TgtPos, 4 )

CODE:

//何らかの値を N ステップで初期値から目標値まで動かす
template< class POS_T >
class LinearTransition
{
private:
	POS_T m_From;
	POS_T m_To;
	int m_nSteps = 0;

	POS_T m_Curr;
	int m_StepCounter;
public:
	LinearTransition( const POS_T &From, const POS_T &To, int nSteps )
		: m_From(From), m_To(To), m_nSteps( (std::max)(nSteps,1) )
		, m_Curr(From), m_StepCounter(0)
	{}

	bool Reached() const {	return (m_StepCounter >= m_nSteps);	}
	const POS_T &CurrPos() const {	return m_Curr;	}

	void Step()
	{
		if( Reached() )return;
		++m_StepCounter;
		m_Curr = m_From  +  m_StepCounter*(m_To-m_From)/m_nSteps;
	}
};