一定フレームの間自動で移動する。ゲーム・クラスの設計方法

[YM]

前回ここでフラグの上手な命名法について教えていただきました。
後日クラス化について少し考え直すことがあったのですが，頭の中で思い描く理想的なコードを書き起こすまで至らず，
あるのは目の前にある（形だけ）きちんと動いているごちゃごちゃコードだけ。

考えているのが，自機移動を一定フレームだけ動かす時の処理方法です。
とりあえずこのような自機クラスを私は作りました。(関数外にCjiki jiki というグローバルインスタンスを作っています)

コード:

class Cjiki{
	private:
		int x;
		int y;
		int count;
	public:
		int get_x() {return x;}
		int get_y() {return y;}
		void add_x(int val) { x += val;}
		void add_y(int val) { y += val;}
		void sub_x(int val) { x -= val;}
		void sub_y(int val) { y -= val;}
		void init() {x = 100; y = 100;}
		void add_count() {count ++;}
		void reset_count() {count  = 0;}
		int get_count() {return count;}
};

(add,subは引数を自然数で扱いたかったため)
また，グローバル変数として f.xxxxxというフラグを別の場所にまとめてあります。(struct f { bool xxxxx; } )

★
具体的な話になってしまうのですが，
左キー入力があったとき，初期位置 x = 100 から x = 0 に移動させようと思ったときに，
jiki.sub_x(100) としたら瞬間移動してしまうので，ゆっくり動かすためにjiki.sub_x(10)を10回，1フレーム1回で実行します
左キーが押されたときにフラグ：f.MoveLeft をオンに，jiki_reset_count()実行
（別のところで）f.MoveLeftがオンならばjiki_sub_x(10)とjiki.add_count()，最後 if(count == 10) のときにf.MoveLeftをオフにしています。
他，左キーが押されたときに当たり判定とキー入力を一時的に無効にするフラグも同時にオンにしています（つまり3本オンに）

最近クラス化の概念を改めて見直し，メンバ関数に上記と同じ挙動を実現するvoid move_left()のような関数があるべきだと思いました。
そうすれば左キーが押される⇒jiki.move_left()を実行するだけで10フレームの間動いてくれて，読むほうも分かりやすいかなと。

しかし，10フレームの間動かすということは同じ処理を10回呼び出さないと行けないので，毎フレームのカウンタの取得と移動処理は必須です。
―という自分の考えだとメンバ関数にするメリットがほとんど感じられず，「じゃあ今のままでもいいか…」と悩んでいます。
この場合，どのようにしておくのが良いでしょう？　いろいろと技量不足の状態で作ったプログラム全体を書き換えるのは結構辛いのですが，
自動移動処理を行うナイスな方法があれば教えてください。


また，メンバ関数が大きくなってきたときにちょっと気になったのですが，プログラムで使う全てのクラスの宣言は(上コピペコード) class.h
に書き，メンバ関数の定義を class.cppに書いておいて他ファイルは#include "class.h" するのがいいのか，それとも自機に関する
クラスを jiki.h に書いてクラスも分けた方がいいのでしょうか？
※jiki.cpp/h enemy.cpp/hがあったら，それぞれのヘッダにクラスの宣言，ソースファイルに定義（インスタンス作成）とメンバ関数の定義，その他の一般関数の定義を書いてある状態

[YM]

追記
VC++2010　ＤＸライブラリ　を使っています。忘れていました。

[Dixq (管理人)]

グローバル変数に状態があって、それに依存して自機が動く設計は良くないと思います。
自機の移動計算は自機の内部でやるべきであって、外から座標を計算するかのような設計になっているのは少し疑問です。
また、自機の移動パターンが様々あるのであれば、「動き」を計算するクラスを作り、そこに処理を「委譲」すれば良いかと思います。

今は公開関数があまりに具体的過ぎると思います。
なるべくブラックボックスかのように包み込み、外からは中がどんな仕組みであろうと簡単に操作できる仕組みが理想です。

例えば、テレビのリモコンで例えると、そこに公開している操作は「ボタンを押す」位のものですよね。
それが今は「回路ABCと回路DEFにパルスを走らせる」のような、詳細を熟知している設計者でなければつかえないものになっています。
リモコンを使う人は内部の設計を理解せずとも「ボタンを押す」だけで操作出来た方が便利ですよね。

更に、「自機」はもっと抽象的なものに分けられそうです。きっとボスや雑魚みたいなものも、共通化出来る所があると思いますから、
BaseCharactorのような抽象クラスから派生させると良いかと思います。
今のままではEnemyにもjikiにも似たような変数や処理が重複しそうです。

ということで、状態を表すフラグや、指定時間で既定の処理をする操作は自機の内部に実装してはいかがでしょうか。

[a5ua]

【サンプルコード】

► スポイラーを表示

コード:

#include "DxLib.h"
#include <memory>	// std::unique_ptr

// (x, y) の動きを制御するモーションクラス
class Motion
{
public:
	Motion(bool moving = true)
		: m_moving(moving) // 初期状態を指定（最初からモーションが終了ということは少ないと思うので、デフォルトではtrue）
	{
	}

	// 継承して使うので、デストラクタはvirtual
	virtual ~Motion()
	{
	}

	// モーションが継続中かどうか
	bool moving() const
	{
		return m_moving;
	}

	// モーションが継続中であれば、(x, y) を動かす
	void move(int &x, int &y)
	{
		// 実際の処理はdo_moveが行なう
		if (m_moving) {
			m_moving = do_move(x, y);
		}
	}

protected:
	// 実際に(x, y)を動かす処理
	// 結果がm_movingに代入されるので、 falseを返すと
	// 以降moveを呼び出しても、do_moveは呼ばれなくなる
	// このメンバー関数は、継承先でオーバーライドしなければならない
	virtual bool do_move(int &x, int &y) = 0;

private:
	// モーションが継続中かどうかを表すフラグ
	bool m_moving;
};


// 一定回数だけ、指定した速度で移動を繰り返すモーション
class CountingMoveMotion : public Motion
{
public:
	// (vx, vy) は速度、n は繰り返し回数
	CountingMoveMotion(int vx, int vy, int n)
		: m_vx(vx), m_vy(vy), m_count(0), m_limit(n)
	{
	}

protected:

	bool do_move(int &x, int &y)
	{
		x += m_vx;
		y += m_vy;
		++m_count;
		return m_count < m_limit;	// この条件をみたす間、移動は繰り返される
	}

private:
	int m_vx;
	int m_vy;
	int m_count;
	int m_limit;
};

// unique_ptrに包んで返す
std::unique_ptr<CountingMoveMotion> counting_move(int vx, int vy, int n)
{
	return std::unique_ptr<CountingMoveMotion>(new CountingMoveMotion(vx, vy, n));
}

// 自機クラス
class Jiki
{
public:
	Jiki(int x, int y)
		: m_x(x), m_y(y)
	{
	}

	// 1フレームの処理
	void step()
	{
		// 登録されたモーションに従って位置を更新
		if (m_motion) {
			m_motion->move(m_x, m_y);
		}
	}

	// 新しくモーションを設定する（現在のモーションが継続中の場合はセットされない）
	// 指定したモーションが設定されたかどうかを戻り値で返す
	bool set_motion(std::unique_ptr<Motion> motion)
	{
		if (m_motion && m_motion->moving()) {
			return false;
		}
		m_motion = std::move(motion);
		return true;
	}

	int x() const
	{
		return m_x;
	}

	int y() const
	{
		return m_y;
	}

private:
	int m_x;
	int m_y;
	std::unique_ptr<Motion> m_motion;
};

// おまけ：マウスを追跡するモーション
class MouseTrackingMotion : public Motion
{
protected:
	bool do_move(int &x, int &y)
	{
		GetMousePoint(&x, &y);
		return false;	// 一回の移動でモーション終了
	}
};

std::unique_ptr<MouseTrackingMotion> mouse_tracking()
{
	return std::unique_ptr<MouseTrackingMotion>(new MouseTrackingMotion);
}

// 自機の更新処理
void update_jiki(Jiki &jiki)
{
	// 方向によって、モーションのパラメータを設定
	if (CheckHitKey(KEY_INPUT_LEFT)) {
		jiki.set_motion(counting_move(-10, 0, 10));
	} else if (CheckHitKey(KEY_INPUT_RIGHT)) {
		jiki.set_motion(counting_move(10, 0, 10));
	} else if (CheckHitKey(KEY_INPUT_DOWN)) {
		jiki.set_motion(counting_move(0, 10, 10));
	} else if (CheckHitKey(KEY_INPUT_UP)) {
		jiki.set_motion(counting_move(0, -10, 10));
	}

	// スペースを押している間、マウスに追従
	if (CheckHitKey(KEY_INPUT_SPACE)) {
		jiki.set_motion(mouse_tracking());
	}

	jiki.step();
}

// 自機の描画処理
void draw_jiki(const Jiki &jiki)
{
	DrawFormatString(0, 0, GetColor(255, 255, 255), _T("(%d, %d)"), jiki.x(), jiki.y());
	DrawCircle(jiki.x(), jiki.y(), 16, GetColor(255, 0, 0));
}

int WINAPI _tWinMain(HINSTANCE, HINSTANCE, LPTSTR, int)
{
	ChangeWindowMode(TRUE);
	if (DxLib_Init() != 0) {
		return -1;
	}
	SetDrawScreen(DX_SCREEN_BACK);

	// 初期座標 (100, 100)
	Jiki jiki(100, 100);

	while (ProcessMessage() == 0) {
		if (CheckHitKey(KEY_INPUT_ESCAPE)) {
			break;
		}
		ClearDrawScreen();
		
		update_jiki(jiki);
		draw_jiki(jiki);

		ScreenFlip();
	}

	DxLib_End();

	return 0;
}

初心者にとって、割とわかりにくいコードになってしまいましたが、サンプルコードを書いてみましたので、参考にどうぞ

コードだけだと味気ないので、解説も少々。

また、自機の移動パターンが様々あるのであれば、「動き」を計算するクラスを作り、そこに処理を「委譲」すれば良いかと思います。

基本的には、この考えを実装しています

「動き」を計算するクラスが、Motionクラスであり、
様々な移動パターンに対応するために、Motionクラスから派生して、
CountingMoveMotionクラスやMouseTrackingMotionクラスを作っています。

そして、自機の移動処理（Jiki::step）は、Motionクラスに処理を「委譲」しています。

最近クラス化の概念を改めて見直し，メンバ関数に上記と同じ挙動を実現するvoid move_left()のような関数があるべきだと思いました。
そうすれば左キーが押される⇒jiki.move_left()を実行するだけで10フレームの間動いてくれて，読むほうも分かりやすいかなと。

これを実現しているのが、以下のコードです。

コード:

if (CheckHitKey(KEY_INPUT_LEFT)) {
	jiki.set_motion(counting_move(-10, 0, 10));	// 左に移動を10回繰り返す
}

現在のモーションが継続中の場合は、set_motionが呼び出されてもセットしないという設計にしているので、
キー入力の無効化と同等のことが実現できます。

ちなみに、このように処理の方法を外部から設定する設計は、Strategyパターンと呼ばれています。
Motionクラスは、座標(x, y)を移動させるStrategy（戦略）となっています。


本題とは関係ないですが、上に示したコードでは
Jikiクラスが保持するモーションの型として「Motion *」ではなく、「unique_ptr<Motion>」というクラスを使っています
unique_ptrはコンストラクタでnewした結果を受け取ることで、デストラクタで自動的にdeleteしてくれるクラスです。
unique_ptrを使用する利点は、newしたオブジェクトの所有者が唯一(unique)であることが保証できることです。
Motion *を使うと、そのポインタの所有者がどのオブジェクトにあるのか慎重に見極めなければなりません。
また、所有権の移動はstd::moveという関数で行うことができます。（Jiki::set_motionで使っています。）

[YM]

お二人様ありがとうございます。言われたことを参考に
クラスの継承とやらを参考書で開いていろいろと試行錯誤しながら勉強することにしました（最中）。
そして他の上手な人の具体例を見て学べるのでコードのサンプルはとってもありがたいです。感謝します

ちなみに今後，このことに関して追加の質問があればこちらでよろしいですか？
それとも一度終了してから新しい題材でトピックを建てた方がいいでしょうか？

[YM]

古い投稿を盛り返してすみません。

上記のありがたいサンプルコードを頑張って読み進めたのですが，オブジェクト指向はほぼ未経験だったので難しいばかりでなく，
unique_ptr<>やstd::move()などが使われていて，そこで何が起きているのかイマイチ理解できません。

これを理解できるようになるのは当分先だな，とは感じるのですが，
もしも可能ならばunique_ptrを使わない例と，引数についてもう少し詳しい説明を頂けないでしょうか。

精いっぱいの解釈をしてみました
キーボードを押された時の関数呼び出しの順に追って：
CountingMoveMotion* counting_move(1,2,3)
→ new CountingMoveMotion A される
→ return Aのポインタ(アドレス)　
※unique_ptrならいつかdeleteしてくれるらしい（？）
↓
bool set_motion(Motion* motion)　
引数は基底クラスのポインタで，派生クラスのポインタを扱える。
引数に入るのは派生クラスのインスタンスAへのポインタ
return されたポインタを元に条件分岐するよう。

コード:

if (m_motion && m_motion->moving())    // Motion* m_motion = ?
    return false;
else
    m_motion = std::move(motion);　// ←Motion* m_motion == ？
    return true;

良く分からないけれども，
メンバ変数Motion* m_motionにnewしたインスタンスAのアドレスが入れられた
↓
m_motion->move(m_x,m_y) と・・・。




分かるようで分かりません＞＜
よければよろしくお願いします。

[a5ua]

unique_ptrを使わないバージョンです。といっても全体の構成はほとんど変わりません。
違いは、Jiki::set_motionにnewしたオブジェクトを直接渡していることと、
unique_ptrが行なってくれていたポインタの所有権の管理を自分で行なっている点です。

► スポイラーを表示

コード:

#include <DxLib.h>
#include <memory>

// (x, y) の動きを制御するモーションクラス
class Motion
{
public:
    Motion(bool moving = true)
        : m_moving(moving) // 初期状態を指定（最初からモーションが終了ということは少ないと思うので、デフォルトではtrue）
    {
    }
 
    // 継承して使うので、デストラクタはvirtual
    virtual ~Motion()
    {
    }
 
    // モーションが継続中かどうか
    bool moving() const
    {
        return m_moving;
    }
 
    // モーションが継続中であれば、(x, y) を動かす
    void move(int &x, int &y)
    {
        // 実際の処理はdo_moveが行なう
        if (m_moving) {
            m_moving = do_move(x, y);
        }
    }
 
protected:
    // 実際に(x, y)を動かす処理
    // 結果がm_movingに代入されるので、 falseを返すと
    // 以降moveを呼び出しても、do_moveは呼ばれなくなる
    // このメンバー関数は、継承先でオーバーライドしなければならない
    virtual bool do_move(int &x, int &y) = 0;
 
private:
    // モーションが継続中かどうかを表すフラグ
    bool m_moving;
};
 
 
// 一定回数だけ、指定した速度で移動を繰り返すモーション
class CountingMoveMotion : public Motion
{
public:
    // (vx, vy) は速度、n は繰り返し回数
    CountingMoveMotion(int vx, int vy, int n)
        : m_vx(vx), m_vy(vy), m_count(0), m_limit(n)
    {
    }
 
protected:
 
    bool do_move(int &x, int &y)
    {
        x += m_vx;
        y += m_vy;
        ++m_count;
        return m_count < m_limit;   // この条件をみたす間、移動は繰り返される
    }
 
private:
    int m_vx;
    int m_vy;
    int m_count;
    int m_limit;
};

 
// 自機クラス
class Jiki
{
public:
    Jiki(int x, int y)
        : m_x(x), m_y(y)
		, m_motion(0)
    {
    }

	~Jiki()
	{
		delete m_motion;
	}
 
    // 1フレームの処理
    void step()
    {
        // 登録されたモーションに従って位置を更新
        if (m_motion) {
            m_motion->move(m_x, m_y);
        }
    }
 
    // 新しくモーションを設定する（現在のモーションが継続中の場合はセットされない）
    // 指定したモーションが設定されたかどうかを戻り値で返す
	// 引数に渡すときは、newしたオブジェクトを渡すこと！（オブジェクトの所有権は自機クラスが持つ）
    bool set_motion(Motion *motion)
    {
        if (m_motion && m_motion->moving()) {
			delete motion;	// 移動中は設定しないので、引数で渡されたモーションを削除
            return false;
        }
		delete m_motion;	// 前回のモーションを削除
		m_motion = motion;	// モーションを再設定
        return true;
    }
 
    int x() const
    {
        return m_x;
    }
 
    int y() const
    {
        return m_y;
    }
 
private:
    int m_x;
    int m_y;
    Motion *m_motion;
};
 
// おまけ：マウスを追跡するモーション
class MouseTrackingMotion : public Motion
{
protected:
    bool do_move(int &x, int &y)
    {
        GetMousePoint(&x, &y);
        return false;   // 一回の移動でモーション終了
    }
};
 
// 自機の更新処理
void update_jiki(Jiki &jiki)
{
    // 方向によって、モーションのパラメータを設定
    if (CheckHitKey(KEY_INPUT_LEFT)) {
		jiki.set_motion(new CountingMoveMotion(-10, 0, 10));
    } else if (CheckHitKey(KEY_INPUT_RIGHT)) {
        jiki.set_motion(new CountingMoveMotion(10, 0, 10));
    } else if (CheckHitKey(KEY_INPUT_DOWN)) {
        jiki.set_motion(new CountingMoveMotion(0, 10, 10));
    } else if (CheckHitKey(KEY_INPUT_UP)) {
        jiki.set_motion(new CountingMoveMotion(0, -10, 10));
    }
 
    // スペースを押している間、マウスに追従
    if (CheckHitKey(KEY_INPUT_SPACE)) {
		jiki.set_motion(new MouseTrackingMotion());
    }
 
    jiki.step();
}
 
// 自機の描画処理
void draw_jiki(const Jiki &jiki)
{
    DrawFormatString(0, 0, GetColor(255, 255, 255), _T("(%d, %d)"), jiki.x(), jiki.y());
    DrawCircle(jiki.x(), jiki.y(), 16, GetColor(255, 0, 0));
}
 
int WINAPI _tWinMain(HINSTANCE, HINSTANCE, LPTSTR, int)
{
    ChangeWindowMode(TRUE);
    if (DxLib_Init() != 0) {
        return -1;
    }
    SetDrawScreen(DX_SCREEN_BACK);
 
    // 初期座標 (100, 100)
    Jiki jiki(100, 100);
 
    while (ProcessMessage() == 0) {
        if (CheckHitKey(KEY_INPUT_ESCAPE)) {
            break;
        }
        ClearDrawScreen();
        
        update_jiki(jiki);
        draw_jiki(jiki);
 
        ScreenFlip();
    }
 
    DxLib_End();
 
    return 0;
}

コード:

if (m_motion) {
	// 何か処理
}

という記述は、m_motionがヌルポインタでない場合処理をするという意味になります。
このコードは、以下の3つのコードと同じ意味です。

コード:

if (m_motion != NULL) {
	// 何か処理
}
if (m_motion != 0) {
	// 何か処理
}
if (m_motion != nullptr) {
	// 何か処理
}

コード:

if (m_motion && m_motion->moving()) {
	// 何か処理
}

このコードは、m_motionがヌルポインタの場合、
m_motion->moving()でヌルポインタにアクセスすることを避けるためです。
短絡評価により、m_motionがヌルポインタの場合、m_motion->moving()は評価されません。

[YM]

2回目もありがとうございますｍｍ　これを原点に複数のクラスを使った処理の書き方や流れを勉強してみます

ちなみにC++では混乱したので，全て忘れて最初からオブジェクト指向性が強いらしい？C#を一からお試し中です。
ある程度学んで，再びC++に戻ってくる頃には少しは理解がはかどるのではないか，と信じて。