あまやどり

VST SDKとかのメモ

2011-08-19T14:53:00.004+09:00

VSTエフェクトを使ってみたいなーと思ったので調べてみたメモ。

SDKは下記からダウンロードできる。ユーザ登録が必要。
http://www.steinberg.net/en/company/developer.html

2.4とかと3.5とかがあるけど、3.x系のプラグインをあまり知らないので、ひとまずは2.4で。

ちなみにライセンスを読んだところ、英文だから合ってるか怪しいけど、SDK使って作ったものを公開するときは連絡しろよ的なことが書いてあった気がするので、ちゃんと調べた方がよさげ。
VSTプラグインをつくるのにはユニークなベンダーID的なものが必要らしいのでなおのこと注意。

SDKをダウンロードすると、ドキュメントとサンプルがついていて、VST hostについてもminihostというサンプルがあるので、それを参考に。

基本的には
　・DLLを読み込む
　・エフェクトのインスタンスを作成
　・初期化
　・入力バッファにデータを入れて渡すと出力バッファにデータが入って帰ってくる
　・上記の出力バッファを元に鳴らす

入出力データは 1サンプルあたり float いっこ。PCMからだと変換が必要。
サンプリングレートやブロックサイズ(一気に処理する量)は初期化時に設定。

バッファのIn/Outに同じアドレスを渡していいかは調べてない。プラグインごとの実装に依りそうな気もするので、とりあえず別にしてる。

DAWで見るVSTごとの設定画面も作ってくれる。作らないままでもいられる。

CubaseについてたVST Effectを挿してみようと思ったら、Cubaseから使ってね的なエラーがでて、とてもがっかりした。

VSTiについてはまたそのうち。

C#からC++にプロセス間通信したメモ

2010-06-06T15:20:00.011+09:00

C++で作ってるゲームをC#で作ったデバッグ用フロントエンドから操作するためにプロセス間通信をしたメモ。

通信の仕方
WM_COPYDATAをSendMessageなどで送る。


[DllImport("user32.dll")]
private static extern uint SendMessage(IntPtr hWnd, int msg, IntPtr wParam, ref COPYDATASTRUCT lParam);

private const Int32 WM_COPYDATA = 0x4A;

struct COPYDATASTRUCT
{
    public IntPtr dwData;
    public UInt32 cbData;
    public IntPtr lpData;
}

COPYDATASTRUCT data = new COPYDATASTRUCT();
{
    // 色々設定
}

// 通信する
SendMessage(hTargetWindow, WM_COPYDATA, hMyWindow, ref data);

文字列を送る
Unicode文字を送る。


// 送る側 (C#)
COPYDATASTRUCT data = new COPYDATASTRUCT();
data.lpData = Marshal.StringToBSTR(msg);
data.cbData = (uint)msg.Length*sizeof(char);

SendMessage(hTargetWindow, WM_COPYDATA, hMyWindow, ref data);

Marshal.FreeBSTR(data.lpData);


// 受け取る側 (C++)
switch(msg) {
    case WM_COPYDATA:
    {
        COPYDATASTRUCT * const pData = reinterpret_cast<COPYDATASTRUCT *>(lp);
        wstring str;
        str.assign(reinterpret_cast<wchar_t *>(pData->lpData), pData->cbData/sizeof(wchar_t));
    }
    break;
}

試験受けてきたんですけど

2010-05-30T18:19:00.001+09:00

いつもこんな感じで体のどこかが痛くなって困ります。

premake4を使ってみたメモ

2010-05-16T14:43:00.007+09:00

定義ファイルから.slnとかmakefileとかを自動生成するのにpremake4を使ってみたメモ。

公式
http://industriousone.com/premake

こんな感じのバッチを書いて
@set PATH=%PATH%;%CD%\path\to\tool\premake4
@premake4 --file=YourDefinitionFile.lua vs2008
@YourSolutionFile.sln
そのバッチを起動するとVS2008用の.slnを自動生成して勝手に起動するようにしてみている。

定義ファイルの書き方
公式の解説が充実している。

てきとーにメモ。

設定の適用範囲
definesとかbuildoptionsとかみたいなのは、projectに対して書くと全てのビルド構成に、configuration "Debug"の下に書くとDebugビルド時のみに適用されるようになる。

ファイル追加
*はワイルドマーク
**は下位のディレクトリも探査するワイルドマーク
excludesで無視も指定できる。ただし、あらかた探査した上で除外するようで、生成が軽くはならない。

出力先のディレクトリ
$(OutDir): targetdir
$(IntDir): objdir

依存するライブラリ
.libとかの拡張子はつけずに指定する。

プロジェクトの設定
flags で指定する。
目的のものがない場合は buildoptions や linkoptions で無理やり指定する。

プリコンパイル済みヘッダ
使用するヘッダ: pchheader
作成するソース: pchsource
その他のソースは全て「プリコンパイル済みヘッダを使用する」になる
強制インクルード: buildoptionsで"/FI stdafx.h"とでも指定する

シンボルを残しつつリリース版のランタイムライブラリを使いたい
flagsでSymbolsを指定すると/MTdになってしまう。
やり方がわからなかったので linkoptions で /MTを指定。
リンク時にwarningがでてしまうけど、/MTが優先されてるので妥協する。

Hudsonのplugiに手を加えてみたメモ

2010-05-11T23:24:00.003+09:00

このたび必要に駆られてHudsonのpluginに手を入れてビルドしなおしてみたのでメモしておきます。
Java文化よくわかんない……。そのうち勉強する。

ちなみに、実際にやった修正はその場しのぎ的な対応を入れるためのものなので、元のプロジェクトにフィードバックはできそうにないです……。

とても参考にさせていただきました
http://d.hatena.ne.jp/fits/20080502/1209726765

本家
http://wiki.hudson-ci.org/display/JA/Extend+Hudson

1. とても参考にさせていただいたサイトを参考にmavenとかを入れたり環境をセットアップ。
2. https://svn.dev.java.net/svn/hudson/trunk/hudson/plugins/ 以下のお目当てのpluginをSVNでチェックアウト。
2-1. リポジトリから取ると新しすぎたりするので、ログをみてよさげなリビジョンに戻す。
3. ソースをいじる。
4. mvn package
5. hpiとかplugin名のフォルダをHudsonのpluginsフォルダに上書き。

DIALOG IN THE DARKに参加してきました

2010-03-27T18:11:00.002+09:00

暗闇からでたとき、何か残念な気持ちがよぎりました。

公式の受け売りで説明すると、DIALOG IN THE DARKは、本当の闇の中でのコミュニケーションを体験できるエンターテインメントです。
暗闇のエキスパートである視覚障碍者のアテンドに案内されて、目を開けても閉じても変わらない本当の闇の中を過ごします。

面白みは大きく二つあると思いました。
印象が視覚情報に影響されない。
助け合う必然性がある。

助け合う必然性があると、人は自信を持って友好的になれます。
今の世の中、よかれと思ってやったことさえ、時として迷惑にとられてしまったり。
労力を割いてまで嫌な思いをするリスクを負いたくありませんよね。

自力でできて然るべきという基準が高い気もします。
そして自力でできることを頼ることなかれという感じもします。
だからちょっと忘れかけてるのかもしれませんが、
助け合う必然性があると、人は自信を持って友好的になれます。

暗闇の中でのあの一体感は不思議でした。
数分前に出会ったばかりだというのに。
暗闇からでたとき、何か残念な気持ちがよぎりました。
何だかみんな、それぞれ自分の世界に帰っていったような気がしまして。
アテンドの方だけは、そのままそこにいるのに。

DIALOG IN THE DARK
http://www.dialoginthedark.com/

GamePM #7 に参加してきました

2010-03-21T17:55:00.005+09:00

ゲーム制作おもにプロジェクトマネジメントに関する勉強会に参加してきました。
詳しくはGamePM勉強会のWebサイトをご参照ください。

また、今回の内容については第7回GamePM勉強会に参加してきたというエントリが参考になります。
なので感想中心で。

発表について
　全然知らない世界の話とかレアなケースの話とかが聞けて面白かったです。喋るのうまいわスライドも凝ってるわ、本気すぎます。
　発表の内容を題材にディスカッションみたいなかたちがあっても面白いかもなぁと思いました。

「３DCG映像製作の現場の声とマネージメントの声」
　よく熾烈を極めるという噂を聞く、アニメ業界の話。
　めりこみ直しを新人にっていうのは参考になりました。一昨年くらいのCEDECであった『メインプログラマーはボトルネック？』でも似たような話があった気がします。

「Scrum 始めました」
　まず言いだしっぺが上の層というのが羨ましいです。
　イテレーション内の仕様追加の拒否についてはやっぱり難しく、「検証」をタスクに積むっていうのを提案しましたが、それもどれだけで見積もればいいのかが難点です。これこれこういう案がいくつあって、それを試す、というかたちになっていると見積もりやすいんですが、何々したいのでそれの検証、とかだけだと不味い予感がします。案を出すために何々を試す、とかになっていてほしいです。
　あとは、ときおり繰り出される高橋メソッドがいちいちツボに入ってやばかったです。

ライトニングトーク
　短い時間での説明なため要点が絞られていて興味をひきやすいと思いました。

「認定スクラムマスターについて」
　まずScrumPrimerを読んでおいてそっから講習を受けるとあったので、ググってみました。
　http://www.rallydev.com/documents/scrumprimer.pdf
　英語ですが、日本語化プロジェクトもあるみたいですね。

「５分でわかるARG」
　オリエンテーリングとARGの違いという質問への答え（「非現実感」や「ストーリー」）は、将棋とコンピュータゲームのストラテジとの違いみたいなものかなぁと思いました。
　ARG楽しいよARG.

「Vimエディタを使おう」
　Vimを勧めるのにVimを使ってプレゼンっていうのは素敵でした。
　多分、次回はEmacsを使おうっていうLTがあるんじゃないでしょうか。

ワークショップ
　チームでも振り返りはある程度の区切りごとにやりたいなぁと思いました。

交流
　同僚がいて笑いました。上司がいてびびった方もいたそうです。
　個人用の名刺にTwitterとかFacebookのアカウントを書いておけばよかったと思いました。ウィルコムでトマトっぽいメールアドレスなのが私です。

その他
　今回は、IGDAのページにあった紹介記事で知りました。
　みんなIDGAとかDiGRAはフィードに入れておくといいと思うんですよ。

共用リポジトリとWindowsでGit

2010-02-24T19:45:00.007+09:00

自分用メモ。

[サーバ] Gitのインストール
ググると出てきます。

TortoiseGitのインストール
これもググると出てきます。
SSHクライアントにはTortoisePLinkを使うようにします。

[サーバ] 共用リポジトリの作成
Git用のユーザをつくって作業。
Git用のユーザは鍵認証でSSHからログインできるようにしておきます。

server$ mkdir /path/to/shared/repository
server$ cd /path/to/shared/repository
server$ git init --bare --shared
(1.5.2.1では git --bare init --shared じゃないとだめだった)

server$ mkdir /path/to/temp/repository
server$ cd /path/to/temp/repository
server$ git init
(適当にコミットする)
server$ git push /path/to/shared/repository master

server$ cd /path/to/shared/repository
server$ git log
(コミットログが確認できる)

作業環境から共用リポジトリにアクセスできるようにする
『TortoiseGitでOpenSSHの鍵を使う』のまんまやりました。

作業環境にCloneする
適当なフォルダで右クリック→TortoiseGit→Clone
urlには
ssh://username@hostname/path/to/shared/repository

その後
push/pullしたりする度にどの鍵を使うか聞かれる場合は、右クリック→TortoiseGit→Settings→Remote→origin→Putty Keyで指定。

外部参照
Submodule

その他
アクセスするユーザが増えるたびにLinuxのユーザを増やすのも嫌なので、同じユーザを使いまわすか、gitosisを使うかしようかと。
sshでログインできてしまうのでchrootします。

TortoiseGitへの疑惑
Addしたやつは次のCommitに強制的に含まれる？
Addしてチェックせずにコミット→Addだけコミットされる
Addしてチェックしてコミット→AddとModifyがコミットされる

イノシシって何て鳴くんですか

2010-02-23T00:15:00.000+09:00

今年の干支にまったくちなまず、イノシシをつくってみました。

なんでイノシシかというと、これまた深い理由がまったくないのですが、参考にした入門記事の題材だったからです……。

Skypeとかで自分の声とPCで再生している音との両方を送りたいのですが

2010-02-19T02:05:00.008+09:00

マウスのクリック音に合わせて歌を口ずさむとかそういう需要がきっとあると思うんですよ。

データの流れを極端に簡単にいうと次のような感じ：

再生する場合
プレイヤーなど→Audio OUT→スピーカーなど

自分の声など
マイクなど→Audio IN→Skypeなど

なので、Audio OUTへの出力を、Audio INに入力されたことにすればいいわけです。
方法としては、

1. 物理的につなぐ
スピーカーで出した音をマイクで拾うとか、LINE OUTをLINE INにつなぐとか。
＜完＞

2. ハードウェア的になんとかする
サウンドカードにそういう機能があるものもあるらしいけど、うちのオーディオI/Fにはそんなものはありません。
＜完＞

3. ソフトウェア的になんとかする

3-1. なんとかするソフト
TiVSoundというソフトで仮想デバイスをつくれ、その仮想デバイスのOUTに出力すると、仮想デバイスのINから入力したことにできます。
詳しい使い方はReadmeなどで。
Skypeでオーディオ設定のマイクを TiVSound Wave にしましょう。
ちなみにスピーカーの設定は今までどおりにしておいたほうが良いと思われます。

3-2. スピーカーからも流す
再生すべきデータを仮想デバイスのOUTに送ってしまうと、今度はスピーカーから音がでなくなりますが、TiVSoundは仮想デバイスへのOUTを他のデバイスにも送れます。今まで使ってたAudio OUTに送ってやりましょう。

3-3. マイクで喋った声も流す
仮想デバイスのOUTに出力したものが相手に送られるので、マイクからの入力を仮想デバイスのOUTに出力すれば、自分の声も相手に送れます。
猿ちぃというソフトでやってみたところ、ピッチをかえる機能があったので、ピッチを下げて社会の闇的なことを言ったり、ピッチを上げて裏声で喋ったりして遊びまくりました。

3-4. 遅延
諦めましょう。

入手した本を読む合い間から

2009-12-06T15:25:00.005+09:00

第九回文学フリマに行ってきました。

　ゲームプログラマという分類的には理系の私ですが、小中高と最も得意かつ好きな教科は国語でした。理系とか文系とかいう分類なんてナンセンスですよね。大学も情報系に進んだものの、科目等履修生として他大の文学部に紛れ込んだり、一時期は物書き志望の真似事のようなこともしていました。私は文章や言語による創作・表現が好きです。
　好きだというのなら、なぜゲームプログラマになったの。創作を仕事にしないのならまだしも、別の創作を仕事に選ぶなんて、あなた、やっぱり私のことが好きだったなんて、口だけだったのね。
　そんな、違うんです。私は今でも貴方のことが大好きで……ただ、自活して身を立てなければならない状況に際して、ゲームプログラミングについてだけは職業人としてやっていける甲斐性があっただけなんです。
　じゃあ本当はゲームプログラミングなんか好きじゃないっていうの？
　いえ。ゲームプログラミングも大好きです。
　サイテー！　バチーン。

　次回はひっそりとサークル参加してみたいですね。

Hudsonでジョブの結果をメール以外で通知したい

2009-11-29T15:23:00.007+09:00

ジョブ実行後の通知をメール以外の手段で行いたく、Pluginを探してみたところ、Twitterにつぶやくとかはあるのに、任意のリクエストを発行できるものがなさそうです……。
pluginを自作しようかと、丁寧な導入記事があったので参考にしつつ環境まで整えましたが、何かそこまでがんばらなくてもできることに途中で気づきました。

ジョブの結果を取得する
HudsonのAPI を使えば取得できます。
ジョブ名やビルドナンバーは環境変数から取得できます。こいつらをパラメータとして渡してやれば良さげ。

ジョブ実行後の処理
しかし「ビルド」の項目から外部のスクリプトを呼んでAPI経由でデータを取ろうとしても、まだ処理が終わっていないので、結果が取得できません(resultのないデータが帰ってきます)。

ご心配ありません。Post build taskを使うことで、ジョブ実行後に処理を行えます。
コンソール出力では結果より先にPost build taskの内容が表示されていますが、Post build taskの処理されるタイミングでAPIをたたくと、結果もちゃんと取得できます。（逆に言うと、Post build taskはジョブの成功／失敗に影響を与えられません。)

あとはAPI経由で引っ張ってきたデータをみて、お好きな手段で通知すればO.K.です。

OAuthで認証してTwitterでつぶやいてみた

2009-11-23T22:52:00.017+09:00

先日の記事で取り上げたTwiticaを、OAuthでの認証に対応してみました。

JavaとかPerlとかPythonとかRubyとかC#ではサンプルがさくっと見つかったりライブラリがあったりするのですが、C++は見つからず。C++/CLIなら.Net用のものが使えるみたいですが。しかしTwiticaがネイティブC++で書かれているので、そのまま貫き通します。

OAuthの手順
下記の記事は大変参考になりました。ありがとうございます。

OAuthで認証してつぶやくのに必要なもの

BASE64
URLエンコード (ただし16進数のアルファベットは大文字, 非対象文字は英数字 - _ . ~)
HMAC-SHA1

自分で書きたくない場合は、『CLX C++ Libraries』などを使うと良いかと。jsonのパーサーもあるので、処理結果をいじるのにも使えます。

つぶやくときに送信するもの
OAuthでの認証に必要なパラメータをHTTPリクエストヘッダのAuthorizationで渡し、つぶやきに必要なパラメータをメッセージボディで渡します。

Authorizationはこんな感じ:

Authorization: OAuth realm="", oauth_consumer_key="***", oauth_nonce="***", oauth_signature="***", oauth_signature_method="HMAC-SHA1", oauth_timestamp="***", oauth_token="***", oauth_version="1.0"

各パラメータの内容は前述のリンク先でご確認ください。

署名(oauth_signature)の作り方
どこがエンコード対象になるのかわかりづらいのでまとめてみました。

HMACの鍵 = URLENCODE(Consumer secret) + "&" + URLENCODE(Access token secret);

REQUEST_METHOD = "POST" とか "GET" とか;

REQUEST_URL = リクエストを投げる先のurl;

　※ http://から書き, ポート番号は含むけど80と443の場合は含めず、すべて小文字で書く。

PARAMETERS = URLENCODE("oauth_consumer_key") + "=" + URLENCODE(Consumer Key) + "&" + .... + "&" + URLENCODE("oauth_version") + "=" + URLENCODE("1.0") + "&" + URLENCODE("status") + "=" + URLENCODE(つぶやきの内容);

　※ OAuth認証に必要なパラメータとリクエストに必要なパラメータに対し、キーと値をURLエンコードして = で結び、そのすべてをソートして & でつなぐ。

SIGNATURE_BASE_STRING = URLENCODE(REQUEST_METHOD) + "&" + URLENCODE(REQUEST_URL) + "&" + URLENCODE(PARAMETERS);

DIGEST = HMAC_SHA1(HMACの鍵, SIGNATURE_BASE_STRING);

oauth_signature = URLENCODE(BASE64(DIGEST));

やったーできたよー。
あんまりわかりやすくならなかった……。

CLX C++ ライブラリを使う場合
まず、CLX C++ ライブラリのURLエンコードはJavaScriptのencodeURI相当らしいので、少しいじらないといけません。
安直ですが、is_reserved()の中身を書き換えたり、encode()にstd::uppercaseを足したりすれば、とりあえず要件を満たせます。
※追記(2010/06/26): エンコード処理のインターフェース - Life like a clownを参考にしてください。


// 右辺値に前の項目での変数名を流用
std::string strHmacKey = HMACの鍵;
std::string strSignatureBaseString = SIGNATURE_BASE_STRING;
const clx::sha1 &digest = clx::hmac<clx::sha1>(strHmacKey, strSignatureBaseString);
std::string strOAuthSignature = clx::uri::encode(clx::base64::encode(reinterpret_cast<const char *>(digest.code()), digest.size()));

余談
最近WPFをいじってみだしたのですが、何かアプリをつくるときはもうC#で書こうかな……。

Twitica

2009-10-17T21:52:00.005+09:00

知人に頼まれて作った投稿専用のTwitterクライアントに、久しぶりに手を入れました。
UIがどんどんシンプルになっていきます。

Twiticaと命名しましたが、申請を出していないので、こいつでつぶやいてもクライアント名は反映されません。
OAuthはそのうち気が向いたら調べます。

Bloggerは画像しか置けないみたいなので、スクリーンショットのみ。

Windows API + Winsock2でゴリ押し気味に作りました。
URLエンコードとか Base64エンコードとかすら手書き。.NET系統の何かとか覚えた方がいいのかな。

以下、メモ

どこでもウィンドウ移動
WM_NCHITTESTでHTCAPTIONを返す。

ウィンドウを左右にしかリサイズさせない
WM_SIZINGで飛んでくるlParamがRECT *なので無理やり書き換える。
wParamでウィンドウのどの辺でリサイズしているかわかる(WMSZ_LEFTとか)。

HudsonによるCIのメモ

2009-10-10T15:25:00.013+09:00

導入と必要そうな設定までを書きます。
環境は Windows XP, Hudson ver. 1.328

インストールというか実行
hudson.warをダウンロードしてきて java -jar hudson.war するだけです。
Hudsonはブラウザから管理画面にアクセスするためにHTTPサーバになりますが、そのポート番号を変えるには --httpPort=N (Nは数値)のオプションを加えます。
環境変数HUDSON_HOMEで指定したディレクトリにいろいろ置かれるので、@set HUDSON_HOME=好きなところみたいなのの後に起動するバッチでも書いておきましょう。
Windows XPでのデフォルトでは C:\Documents and Settings\UserName\.hudson というディレクトリになりますが、他のツールのことを考えて、. やスペースを含まないディレクトリにしておいたほうが無難でしょう。

アクセス
ブラウザで http://your-host:port/ を開きます。
Ajaxなどが使われているので、無効にしている人は、ブラウザのセキュリティ設定を下げる必要があります。

管理画面
「Hudsonの管理」→「システムの管理」から各種設定を変更できます。
あとでビルドを壊した個人に通知するため、「セキュリティを有効化」にチェックをつけて、サインアップ/ログインを有効にましょう。
「E-mail 通知」で「SMTPサーバ」を設定しておかないと、レポートを送信できません。

プロジェクト
「新規ジョブの作成」から新しいプロジェクトを作成できます。

Hudsonではプロジェクト単位でビルドの成否をチェックします。
ビルドの成否は「最後に実行したコマンドの返り値が0なら成功、そうでなければ失敗」という風に判定されます。
成否をチェックしたいもの一つにつきプロジェクトを一つつくる必要があります。
ちなみに、プロジェクトはできるだけ細かく分割するほうが良いそうです。

デバッグビルドとリリースビルド
ビルドごとにプロジェクトをつくるのは面倒です。
こういうときは「マルチ構成プロジェクトのビルド」を使用しましょう。

マルチ構成プロジェクトでは、「設定」に「構成マトリックス」という項目が増えています。
ここの構成軸の「名前」と同じ環境変数に、「値」の設定値を順に設定して、ビルドを実行します。
名前: BuildType
値: Debug, Release
という風に設定すると、同じ処理を%ByuldType%の値だけ変えて実行できます。

三軸、四軸の設定もできます。

他のプロジェクトを続けて実行
プロジェクトごとの「設定」から「他のプロジェクトのビルド」を指定できます。

SCMからどこにチェックアウトしよう？
プロジェクトごとにチェックアウトするので、そのプロジェクトに必要な部分だけチェックアウトするようにするか、「設定」の「ローカルモジュールディレクトリ」で無理やり位置を変えるかすると良いと思います。

ちなみに、マルチ構成プロジェクトでは、一つのビルドごとに一つチェックアウトします。
BuildTypeにDebugとReleaseを指定していたら、その両方のワークディレクトリにチェックアウトされます。

コマンドラインからビルドする
コマンドライン用のインターフェイスが用意されてないとビルドできません。

VisualStudioならdevenvをコマンドラインから叩けます。
MSDNオンラインにコマンド一覧が載っています。
/build /rebuild /runexit を使えば何とかなると思います。

ターゲットに実行ファイルを送る
多分、ドキュメントにコピーするコマンドが載ってると思うので、それでコピーします。

結果を通知したい
プロジェクトごとの「設定」の「ビルド後の処理」から「E-mail通知」にチェックをつけてください。
「宛先」に指定されている人と、ビルドを壊した個人にメールを送ることができます。

ビルドを壊した個人はどうやって特定するの？
そのビルドに関連するSCMの更新に関わった人が、ビルドを壊した容疑者になります。
SCMでのユーザ名とHudsonでのユーザ名を合わせておかないといけません。

他のプロジェクトを続けて実行した場合、次のプロジェクトには、前のプロジェクトでの容疑者は引き継がれません。
マルチ構成プロジェクトでは、全部の回で同じユーザが容疑者になります。

個人ごとのメールアドレスは「人々」から辿って設定できます。

SCMにコミットしたら自動でビルドする
お使いのSCMのドキュメントを読んで、コミット後の処理を行う方法を調べましょう。

Subversionではpost-commitに wget -O /dev/null -q http://your-host:port/job/JOB-NAME/build?delay=Nsec と書きます。
NsecのNの部分は数値に置き換えてください。
ビルドの実行はN秒だけ待ってから行われます。
これは、何回かに分けてコミットしたとき、まとめて一回のビルドにするためのオプションです。

プラグイン
色々あるみたいですが、英語を読むのが面倒なので、あまり試していません。

その他
CppUnit-xでのテスト結果をJUnitのXML形式にしたりするプラグインがあると便利なのかなぁとか思っています。
（CppUnitのXMLレポートをJUnit形式にするプラグインはあるみたいです。）

ユニットテストのメモ

2009-10-03T08:45:00.011+09:00

今年の頭くらいから、ユニットテストとかCIとかをやりましょうよと言っていて、ようやく最近、導入するチャンスがあったので、職場でやってみています。

最初に考えたこと
リリースにテストが含まれないようにすべきです。使われていないコードは最適化で消えてくれるとしても、CppUnitやCppUnit-xはLGPLなので、配布するバイナリにはリンクしないようにします。
あと、テストの追加と実行を容易にしないと、きっとみんなテストしてくれません。

ユニットテストフレームワーク
CppUnitとCppUnit-xという選択肢があります。
あまり厳密には比較していませんが、内作のゲームフレームワークの都合上、CppUnit-xを使わせていただいています。VCでもgccでも簡単にビルドできるし、C++の機能の一部を制限できるのが魅力だと思います。
テスト結果の出力方法を変えるために custdio.h に手を入れたのと、テストに stdint.h 相当の型を使うために多少の修正を加える必要はありました。
static link libraryにしてリンクしています。

テストの実行方法
テストを手軽に行うため、実行したらすぐに結果が得られるのが良いと思います。そのため、テスト時は、main()からすぐにTestRunnerを呼びます（そのあとは即終了していますが、デバッグメニューに行ってもいいかもしれませんね）。

それぞれのテスト
別のプログラマの書いたテストの影響を受けるとうざいので、テストランナーはそれぞれ書いたものを実行するようにしています。単純ですが、SCMに登録しないプライベートなファイルで各自ラベルを書き換えるようにして切り替えています。
ビルドPCでテストを行う際は、すべてのテストを実施します。

テストケース置き場
基本的にすべての機能にテストを書くことを前提にしていますので、ソースツリーと同じ構成でテストケース置き場をつくっています。
　：
├src
│├Foo
│├└Bar.cpp/.h
│Hoge
├testcase
│├Foo
│├└Bar_Test.cpp/.h
│Hoge
　：

テストファースト
ここまでは特に問題なくできていたのですが、テストファーストはちょっと厳しい印象です。
ターゲットによってはビルドに時間がかかるので、いちいち失敗させるのが手間です。コンパイルは修正範囲が狭ければ問題ありませんが、リンクも重かったりしてイライラします（インクリメンタルリンクは有効にしているのですが……）。
「失敗させながら」のところだけ省略して、テストケースは先に書くようにするのもありかと思います。

どこまでテストを書くか
まだ手探りです。「可能な限り書く」というルールにしています。

その他
今はテストもIDEから実行していますが、裏でコマンドラインからビルドして実行するなり、邪魔されないようにした方がいいのかもしれません。

参考情報
CEDEC2009の『バグを限りなくゼロにする方法』がゲーム業界に特化した内容もあって参考になります。

刺激を受けてきました

2009-09-26T16:52:00.002+09:00

昨日、東京ゲームショウ2009とSENSE OF WANDER NIGHT2009に行ってきました。

毎年、業務としてショーに行くべき理由とは何だろうかと考えています。私自身はゲームが好きなので、ショーに行くこと自体は楽しうございます。年に一度のお祭りに参加できてご満悦です。しかし、これを業務として行う理由は何なのでしょうか。話題作は大体記事になりますし、プレイアブル出展されているものは、大抵、しばらく待てば発売されてしまいます。チケットをとり交通費を出して就業時間に行かせる、そんな許可を出している人は、何を期待して、許可を出しているのでしょうか。

聞いてみたら、一番は「刺激を受けてがんばってもらうため」と言われました。いい話だなー。

刺激を受けたという意味では、ちょっと変わったアイディアのゲームが好きな私には、SOWNが大変面白うございました。後日、会場の様子を動画で配信するとのことなので、それでプレゼンテーションの内容も確認できると思います。

会社で知り合いと、「毎日１アイディア」みたいなことをやっていて、その中で、ちょっと面白いアイディアがあったりもするのですが、大抵、実際にはつくられません。今回SOWNで面白いと感じたのは、どれも実際に動いていたからだと思います。CEDEC2009の『ゲェムのカタチ』のセッションで藤木淳氏が言っていたことですが、不思議なものが実際に動く何らかの原理があるはずで、それが知的好奇心をかき立てる、これは確かにその通りだとあらためて実感しました。

もっと手を動かさないとね。

蔵書管理

2009-09-23T21:25:00.003+09:00

メディアマーカーで手持ちの本を管理してみることにしました。
本棚に並べると場所をとって仕方がないことと、大半の本は参照する機会が稀なことから、リストだけ見やすくしておいて、本自体は収納スペースに押し込もうという魂胆です。
本棚は辞書類の置き場兼テンポラリという扱いにしようと思います。
テンポラリのはずがどんどんカオスにならなければ良いのですが……。

Visitor

2009-09-21T11:40:00.002+09:00

概要
オブジェクトに変更を加えることなくオペレーションを追加する。

例
所持品の種類ごとに異なる価格、重量を計算する。

雰囲気


// Visitor
class IVisitor {
public:
    virtual void VisitItem(Item *) = 0;
    virtual void VisitEquip(Equip *) = 0;
};

// ConcreteVisitor
/*
   所持品の重量を求める
*/
class TotalWeight : public IVisitor {
public:
    virtual void VisitItem(Item *pItem)
    {
        const int weight = pItem->GetWeight();
        const int num = pItem->GetNum();
        m_weight += (weight * num);
    }

    virtual void VisitEquip(Equip *pEquip)
    {
        m_weight += pEquip->GetWeight();
        const Array<Item*> aItem = pEquip->GetItems();
        foreach (Item *pItem, aItem) { // aItemの全要素を辿る
            m_weight += pItem->GetWeight();
        }
    }

    void GetWeight() const
    {
        return m_weight;
    }

private:
    int m_weight;
};

/*
    所持品の価格を求める
*/
class TotalPrice : public IVisitor {
public:
    virtual void VisitItem(Item *pItem)
    {
        const int price = pItem->GetPrice();
        const int num = pItem->GetNum();
        m_price += (price * num);
    }

    virtual void VisitEquip(Equip *pEquip)
    {
        m_price += pEquip->GetPrice();
        const Array<Item*> aItem = pEquip->GetItems();
        foreach (Item *pItem, aItem) { // aItemの全要素を辿る
            if (pItem->GetID() == SPECIAL_ITEM) {
                // 特殊なアイテムと組み合わせると割り増しになる.
                m_price += VALUE_ADDED;
            }
            m_price += pItem->GetPrice();
        }
    }

    void GetPrice() const
    {
        return m_price;
    }

private:
    int m_price;
};

// Element
class IElement {
public:
    virtual void Visit(IVisitor *) = 0;
};

// ConcreteElement
/*
    消費アイテム, 同じアイテムを複数個所持できる.
*/
class Item : public IElement {
public:
    ItemID GetID() const;  // アイテムのID
    int GetNum() const;    // 所持数
    int GetWeight() const; // 単体の重量
    int GetPrice() const;  // 単価

    virtual void Visit(IVisit *pVisit)
    {
        pVisit->VisitItem(this);
    }
};

/*
    装備アイテム, 同じ装備でも別々に一個ずつ所持する.
    更に装備にはアイテムを付加して特殊効果を付与でき, それによって重量や価格も変わる.
*/
clas Equip : public IElement {
public:
    int GetWeight() const; // 単体の重量
    int GetPrice() const;  // 単価

    const Array<Item*> GetItems() const;

    virtual void Visit(IVisit *pVisit)
    {
        pVisit->VisitEquip(this);
    }
};

// ObjectStructure
class ElementContainer {
public:
    void Visit(IVisitor *pVisit)
    {
        foreach (IElement *pElement, m_aElement) { // m_aElementの全要素を辿る
            pElement->Visit(pVisit);
        }
    }

private:
    Array<IElement*> m_aElement;
};

// 使用例
void GetTotalPrice()
{
    ElementContainer &elements = GetElementContainer();
    TotalPrice visitor;
    elements.Visit(&visitor);
    const int price = visitor.GetPrice();
}

Template Method

2009-09-20T22:52:00.001+09:00

概要
基本となる処理を実装しておき、異なる部分だけサブクラスで実装する。

例
各画面の、遷移など共通部分は基底クラスで実装しておき、画面ごとの処理はサブクラスで実装する。

雰囲気


// AbstructClass
class ModeBase {
public:
    virtual void Update();     // 画面遷移中のフェードや状態管理などを行う
    virtual void Draw();       // 上記に伴った描画処理を行う
    virtual void AddUpdater(); // 独自の更新関数を追加する
    virtual void AddDrawer();  // 独自の描画関数を追加する

    // template methods
    virtual void OnInitialized() {} // 初期化直後
    virtual void OnOpening() {}     // 遷移が終わってこのモードが始まる際の
    virtual void OnEnding() {}      // このモードが終わって次の画面に移る際の処理
    virtual void OnTerminated() {}  // 終了処理の直後
};

// ConcreteClass
class ModeTitle {
public:
    virual void OnOpening()
    {
        // タイトル画面で何十秒か放置すると,
        // 自動でデモ画面に行くようにしたいので,
        // 画面の開始時にタイマをリセットしておく.
        m_timer.Reset();
    }

private:
    Timer m_timer;
}

Strategy

2009-09-20T22:50:00.003+09:00

概要
アルゴリズムをカプセル化し、目的に応じて選択できるようにする。

例
難易度ごとに異なるアルゴリズムで実装されたA.I.を切り替えられるようにする。

雰囲気


// Strategy
class IAiStrategy {
public:
    virtual int Think() = 0;
};

// ConcreteStrategy
/*
    常にランダムな手を返す
*/
class Ai_Monkey {
public:
    virtual int Think()
    {
        return RANDOM();
    }
};

/*
    過去の手を考慮して返す
*/
class Ai_EvalPastMove {
public:
    virtual int Think()
    {
        return EvalPastMove();
    }

private:
    int EvalPastMove(); // 過去の手を考慮して次の手を導く
};

// Context
class IPlayer;
class ComPlayer : IPlayer {
public:
    ComPlayer(IAiStrategy *pAi)
        : m_pAi(pAi)
    {
        ASSERT(pAi);
    }

    virtual int GetNextMove()
    {
        const int result = m_pAi->Think();
        return result;
    }

private:
    IAiStrategy *m_pAi;
};

State

2009-09-20T22:34:00.001+09:00

概要
内部状態に合わせて異なる振る舞いのオブジェクトを適用する。

例
各モードの画面遷移を実装する。

雰囲気


// State
class ISequence {
public:
    virtual void Update() = 0;
    virtual void Draw() = 0;

protected:
    SequenceControler * getCtrl();
};

// ConcreteState
/*
    タイトル画面.
    何らかのキーを押すと次の画面に進む.
*/
class TitleSequence : public ISequence {
public:
    virtual void Update()
    {
        if (IsPushAnyKey()) {
           getCtrl()->ChangeSequence(new MenuSequence);
        }
    }
    virtual void Draw();
};

/*
    トップメニュー画面
*/
class MenuSequence : public ISequence;

// Context
class SequenceControler {
public:
    void MainLoop()
    {
        m_pSequence->Update();
        m_pSequence->Draw();

        if (m_pNextSequence != NULL) {
            SAFE_DELETE(m_pSequence);
            m_pSequence = m_pNextSequence;
            m_pNextSequence = NULL;
        }
    }

    void ChangeSequence(ISequence *pNext)
    {
        ASSERT(m_pNextSequence);
        m_pNextSequence = pNext;
    }

private:
    ISequence *m_pSequence;
    ISequence *m_pNextSequence;
};

Singleton

2009-09-19T23:05:00.001+09:00

概要
インスタンスが常に一つである事を保障する。

例
同じ資源を多重に読み込まないようにするリソースマネージャなど、一つしか存在してはならないことを表現する。

雰囲気


// singleton
template<class T>
class singleton {
public:
    T * GetInstance()
    {
        if (m_pInstance == NULL) {
            HANDLE h = BeginCriticalSection();
            if (m_pInstance == NULL) {
                m_pInstance = new T;
            }
            EndCriticalSection(h);
        }

        return m_pInstance;
    }

    T * operator ->()
    {
        return GetInstance();
    }

private:
    static T * m_pInstance;
};

// 使用例
class Sample {
public:
    void DoSomething();

private:
    friend singleton<Foo>;
    Sample();
    ~Sample();
    Sample(const Sample &);
    Sample & operator =(const Sample &);
};

void Exsample()
{
    singleton<Sample> foo;
    foo->DoSomething();
}

Proxy

2009-09-19T10:10:00.000+09:00

概要
オブジェクトの間を仲介し、処理を隠蔽したり制限したりする。

例
remote proxy
DBサーバ上に保存されているデータを、ローカルデータと同じように扱えるようにする。

virtual proxy
ディスクからのロード中は仮のモデルやテクスチャを出し、ロードが完了し次第リソースを使用する。

protection proxy
ディスク上のデータと書き換え可能な外部メモリ上のデータを同じインターフェイスで扱い、ディスク上のデータについてはREAD ONLYにし、外部メモリ上のデータは権限情報に基づいて扱いを変える。

smart reference
スマートポインタを実現する。

雰囲気


// 
// virtual proxy
// 

// Subject
class IImage {
public:
    virtual void Load(FILENAME) = 0;
    virtual void Update() = 0;
    virtual void Draw() = 0;
};

// RealSubject
class Image : public IImage {
    virtual void Load(FILENAME);
    virtual void Update();
    virtual void Draw();
};

// Proxy
class ImageDelayLoad : public IImage {
public:
    virtual void Load(FILENAME)
    {
        m_image.Load(FILENAME); // m_imageのロードを発行する
    }

    virtual void Update()
    {
        // m_imageのロードも行う
    }

    virtual void Draw()
    {
        if (m_image.IsLoaded()) {
            m_image.Draw();

        } else {
            DrawDummy();
        }
    }

private:
    Image m_image;
};

Prototype

2009-09-18T14:20:00.003+09:00

概要
プロトタイプとなるオブジェクトを生成しておき、そのコピーを元に新たなオブジェクトを作成する。

例
敵オブジェクトの生成には設定ファイルの解釈に大きなコストがかかるため、読み込み済みのオブジェクトを原型とし、他のオブジェクトは原型をコピーして生成する。

雰囲気


// Prototype
class IObjectBase {
public:
    virtual void Initialize(int x, int y)
    {
        m_x = x, m_y = y;
    }
    virtual void Update() = 0;
    virtual void Draw() = 0;

    virtual IObjectBase * Copy() const = 0;

private:
    int m_x, m_y;
};

// ConcretePrototype
class EnemyObject : public IObjectBase {
public:
    EnemyObject();
    virtual IObjectBase * Copy() const
    {
        return new EnemyObject(*this);
    }

    virtual void LoadFile(FILENAME);
    virtual void Update();
    virtual void Draw();

private:
    explicit EnemyObject(const EnemyObject &); // copy constructor

private:
    COMPLEX_PARAM m_param; // 設定ファイルなどを処理して決定される, 複雑な設定値
};

// Client
class ObjectFactory {
public:
    explicit ObjectFactory(const IObjectBase &prototype)
        : IObjectBase(prototype)
    {}

    IObjectBase * Create(int x, int y) const
    {
        IObjectBase * pClone = m_prototype.Copy();
        pClone->Initialize(x, y);
        return pClone;
    }

private:
    const IObjectBase & m_prototype;
};

void SetEnemyPrototype()
{
    Enemy * const pEnemy = new Enemy;
    pEnemy->LoadFile(FILENAME); // 設定ファイルを読み込み、複雑な処理の後、パラメータが決定される

    ObjectFactory &objFactory = CreateObjectFactory(pEnemy);
    RegistorEnemyFactory(objFactory);
}

void CreateNewEnemy()
{
    const ObjectFactory &objFactory = GetEnemyFactory();
    IObjectBase * pNewObject = objFactory.Create(X, Y);
}

Observer

2009-09-18T14:17:00.001+09:00

概要
あるオブジェクトが更新されたとき、依存するオブジェクトに通知し、矛盾状態にならないようにする。

例
ゲーム中自立して動くオブジェクトを、ポーズしたときには止めるようにする。

雰囲気


// Subject
class ISubjectBase {
public:
    virtual void Attach(IObserver &); // m_aObserverに追加する
    virtual void Detach(IObserver &); // m_aObserverから取り除く
    virtual void Notify();            // m_aObserverに通知する

private:
    Array<IObserver &;> m_aObserver;
};

class GameController : public ISubjectBase {
public:
    virtual void SetPause(bool pause)
    {
        m_isPaused = pause;
        Notify();
    }

    virtual bool IsPaused() const { return m_isPaused; }

private:
    bool m_isPaused;
};

// Observer
class IObserver {
public:
    virtual void Update() = 0;
};

class ObjectBase : public IObserver {
public:
    Object(const GameController &gameCtrl)
        : m_GameController(gameCtrl)
    {
        m_GameController.Attach(this);
    }

    virtual void Update()
    {
        if (m_GameController.IsPaused()) {
            Pause();

        } else {
            Restart();
        }
    }

    virtual void Pause();
    virtual void Restart();

private:
    const GameController &m_GameController;
};

Memento

2009-09-17T13:09:00.003+09:00

概要
カプセル化破壊せずに、内部情報を外部に保存する。
保存しておいた情報から以前の状態を復元できる。

例
ターン性ストラテジで、ユニットを動かした後、ターン終了前であれば移動をキャンセルできるようにする。

雰囲気


// Originator
class Unit {
public:
    const UnitMement * CreateMemento() const
    void SetMement(const UnitMement *);

    // ユニットを移動する
    void Move(const POSITION &next);
private:
    POSITION m_pos;
};

// Memento
class UnitMemento {
public:
    ~UnitMemento();

private:
    friend Unit;
    UnitMement();

    void setPos(const POSITION &pos);
    const POSITION & getPos() const;

private:
    POSITION m_pos;
};

// Caretaker
void Move()
{
    Unit &unit = GetUnit();
    UnitMement * const pMement = unit.CreateMement();
    RegistorMement(pMement);

    const POSITION & next = GetNextPos();
    unit.Move(next);
}
void Cancel()
{
    Unit &unit = GetUnit();
    UnitMement * const pMement = GetRegistoredMement();
    unit.SetMement(pMement);
}

Mediator

2009-09-17T12:32:00.003+09:00

概要
オブジェクト間の複雑な依存関係を一箇所に集中させる。
それにより個々のオブジェクトの再利用性を高める。

例
装備画面で、キャラクターを選択すると装備できるアイテムのみがハイライトされる。

雰囲気


// Mediator
/*
    アイテムの選択に関する振る舞いを取りまとめる.
    装備の選択, 消費アイテムの選択など, 必要に応じて具象クラスを作成する.
*/
class IItemDirector {
public:
    virtual void OnSelect(Chara *) = 0;
    virtual void OnSelect(IItem *) = 0;
};

// ConcreteMediator
class EquipDirector : public IItemDirector {
public:
    /*
        キャラクターを選んだので、装備可能なアイテムをハイライトする。
    */
    virtual void OnSelect(Chara *pChara)
    {
        foreach (Equip *pEquip, m_aEquip) {       // 各要素をpEquipに入れつつm_aEquipの全要素を辿る
            const ItemID id = pEquip->GetID();
            const bool canEquip = pChara->canEquip(id);
            pEquip->SetHilight(canEquip);
        }
    }

    virtual void OnSelect(IItem *pItem);  // 逆に装備を先に選ぶと、装備可能なキャラクターがハイライトされる。

private:
    Array<Chara*> m_aChara; // パーティにいるキャラ
    Array<Equip*> m_aEquip; // 所持している装備
}

// Colleague
class Chara {
public:
    explicit Chara(IItemDirector &mediator)
        : m_meiator(mediator)
    {}

    bool canEquip(ItemID) const;

    void OnSelect()
    {
        m_mediator->OnSelect(this);
    }

    IItemDirector &m_mediator;
};

class IItem;
class Equip : public IItem {
public:
    explicit Equip(IItemDirector &mediator)
        : m_meiator(mediator)
    {}

    virtual ItemID GetID() const;

private:
    IItemDirector &m_mediator;
};

Iterator

2009-09-16T14:47:00.002+09:00

概要
コンテナクラスを順に処理するための共通のインターフェイスを提供する。
STLの汎用コンテナクラスでも使われている。

例
順序なしリストとそのイテレータをつくる。

雰囲気


// Aggregate
template <class T>
class IContainer {
public:
    virtual IIterator<T> * Create() = 0;
}

// ConcreteAggregate
template <class T>
class Crowd : public IContainer {
public:
    virtual IIterator<T> * Create()
    {
        return CrowdIterator<T>::Create(this);
    }

    T * Get(unsigned int index) const;
    unsigned int GetNum() const;
};

// Iterator
template <class T>
class IIterator {
public:
    virtual T * Get() const = 0;
    virtual void Prev() = 0;
    virtual void Next() = 0;
    virtual bool IsEnd() const = 0;
};

// ConcreteIterator
template <class T>
class CrowdIterator : public IIterator<T> {
public:
    static IIterator * Create(const Crowd<T> &);

    virtual T * Get() const
    {
        return (IsEnd() ? NULL : m_container.Get(m_index));
    }

    virtual void Prev()
    {
        if (m_index > 0) {
            --m_index;
        }
    }

    virtual void Next()
    {
        if (! IsEnd())
            ++m_index;
        }
    }

    virtual bool IsEnd() const
    {
        return (m_index >= m_continer.GetNum());
    }

private:
    unsigned int m_index;
    const Crowd<T> &m_container;
};

Interpreter

2009-09-16T14:44:00.002+09:00

概要
簡単な文法とそのインタプリタを定義する。

例
設定値を式で表現する。

雰囲気


// AbstractExpression
class IExpression {
public:
    virtual int Evaluate(const Context &) const = 0;
};

// TerminalExpression
/*
     定数
*/
class Constant : public IExpression {
public:
    Constant(int value)
        : m_value(value)
    {}
    virtual int Evaluate(const Context &) const
    {
        return m_value;
    }

private:
     const int m_value;
};

/*
     変数
*/
class Variable : public IExpression {
public:
     Variable(LABEL label)
     {}
     virtual int Evaluate(const Context & context) const
     {
          retrn context.GetValue(m_label);
     }

private:
     const LABEL m_label;
};

// NonterminalExpression
/*
    加算
*/
class Plus : public IExpression {
public:
    Plus(const IExpression &lh, const IExpression &rh)
        : m_lh(lh), m_rh(rh)
    {}
    virtual int Evaluate(const Context &context)
    {
        return (m_lh.Evaluate(context) + m_rh.Evaluate(context));
    }

private:
    const IExpression & m_lh, &m_rh;
};

/*
    減算、乗算、除算も、加算と同じように実装する。
*/

// Client
void Calc()
{
    // 3+X*Y
    IExpression &exp = Plus(Constant(3), Multi(Variable(X), Variable(Y)));

    // 評価時のContextの内容に応じて算出される
    const int value = exp.Evaluate(GetContext());
}

Flyweight

2009-09-16T14:41:00.001+09:00

概要
オブジェクトを使いまわしてメモリを節約する。
内部状態を共有されても構わない内部に保持する情報(intrinsic)と、使用時毎に異なる外から与えられる情報(extrinsic)とにわけ、instrinsicだけ内部に持つようにする。

例
弾幕を描画する際に、同じ種類の弾の画像のインスタンスはひとつだけ作成し、使いまわすようにする。

雰囲気


// FlyweightFactory
class ImageLoader {
public:
    // 同じ画像は多重に読み込まないようにする
    IImage * Load(FILENAME file)
    {
        if (m_aImage[file].exist) {
            return m_aImage[file].get();

        } else {
            return LoadInner(file);
        }
    }

private:
    IImage * LoadInner(FILENAME);          // FILENAMEの画像を読み込む
    Hash<FILENME, IImage*> m_aImage; // ハッシュテーブル的な
};

// Flyweight
class IImage {
public:
    void Draw(const BulletContext &);
};

// ConcreteFlyweight
class SpriteAnime : public IImage;

// extrinsic Context
class BulletContext;  // 描画位置やアニメの状態などを持っている

// Client
/*
    生成した弾幕の各弾の位置を計算し、BulletContextを作成し、弾を描画する
*/
class BulletManager {
public:
    unsigned int GetNum() const;

    void Draw()
    {
     const unsigned int num = GetNum();
     for (unsigned int i = 0; i < num; ++i) {
         const Image & img = GetImage(i);
         const ddddContext & context = GetContext(i);

         img.Draw(ddddContext);
     }
    }

private:
    const IImage & GetImage(unsigned int index) const;
    const BulletContext & GetContext(unsigned int index) const;
};

備考
共有しない UnsharedConcreteFlyweight もあり得る。

Factory Method

2009-09-15T10:11:00.003+09:00

概要
オブジェクトを作成するインターフェイスを用意し、実際に何を作るかはサブクラスに任せる。

例
マップ上にオブジェクトを設置でき、そのオブジェクトの種類を動的に切り替えられるようにする。

雰囲気


// Creator
class IObjectFactory {
public:
    void PutObject()
    {
        IObject * const pObject = createObject();

        // Objectを管理しているクラスに任せる
        GetObjectManager().add(pObject);
    }

protected:
    // factory method
    virtual IObject * createObject() = 0;
};

// ConcreteCreator
template<class T>   // IObjectの具象クラスを指定する
class StandardObject : public IObjectFactory {
protected:
    virtual IObject * createObject()
    {
        return T::Create();
    }
};

// Product
class IObject;

// ConcreteProduct
class HouseObject : public IObject {
public:
    static IObject * Create();
};

class ParkObject : public IObject {
public:
    static IObject * Create();
};

Facade

2009-09-14T12:30:00.003+09:00

概要
複雑なサブシステムを簡易に使うための窓口を用意する。

例
ソケット通信、暗号化、独自パケットの作成をまとめて、簡単に通信処理を行えるようにする。

雰囲気


// Subsystem classes
/*
    ソケット通信を行う
*/
class SocketWrapper {
public:
    void Send(const void *pBuffer, unsigned int size);
};

/*
    暗号化を行う
*/
namespace Crypto {
void Encrypto(void *pOut, unsigned int sizeOut, const void *pIn, unsigned int sizeIn);

unsigned int GetEncryptedSize(unsigned int) const; // 暗号後のサイズを求める
};

/*
    パケットデータを作成する
*/
class PacketStream {
public:
    // パケットの種類
    typedef enum {
        PACKET_DATA,

        PACKET_NUM,
    } ePACKET_KIND;

    PacketStream(ePACKET_KIND kind); // パケットを作成する
    void AddData(Data data);         // データを追加する

    unsigned int GetSize() const;    // パケットデータのサイズを得る
    const void * GetBuffer() const;  // パケットデータを得る
};

// Facade
/*
    パケット化、暗号化、送信をまとめて簡単に扱えるようにする。
*/
class PacketSender {
public:
    void SendData(const Data *pData, unsigned int numData)
    {
        ASSERT(pData != NULL);

        PacketStream packet(PacketStream::PACKET_DATA);
        for (unsigned int i = 0; i < numData; ++i) {
            packet.AddData(pData[i]);
        }

        const unsigned int sizePacket = packet.GetSize();
        const void * const pPacketData = packet.GetBuffer();

        const unsigned int sizeTemp = Crypto::GetEncryptedSize(sizePacket);
        void * const pTemp = GetTempBuffer(sizeTemp); // これで一時バッファを作成できるとする

        Crypto::Encrypto(pTemp, sizeTemp, pPacketData, sizePacket);

        m_socket.Send(pTemp, sizeTemp);
    }

private:
    SocketWrapper m_socket;
};

Decorator

2009-09-14T11:01:00.003+09:00

概要
同じインターフェイスのままオブジェクトに機能を追加する。
クラスの全てに追加するわけでなく、オブジェクト単位で機能の追加を行える。
インターフェイスが同じなので、使う側は違いを意識しなくて良い。

例
動作ファイルを再生したりキーフレームアニメファイルを再生するだけのオブジェクトに、ゲーム内のデザインに合わせた枠を追加する。

雰囲気


// Component
class IUiObject {
public:
    virtual void Update();
    virtual void Draw();
};

// ConcreteComponent
class MovieObject;         // 動画ファイルを再生するだけ
class KeyframeAnimeOBject; // キーフレームアニメファイルを再生するだけ

// Decorator
class IUiDecoratorBase : public IUiObject {
public:
    IUiDecoratorBase(IUiBase &component)
        : m_component(component)
    {}

    virtual void Update()
    {
        m_component.Update();
    }

    virtual void Draw()
    {
        m_component.Draw();
    }

private:
    IUiObject & m_component;
};

// ConcreteDecorator
class FrameDecorator : public IUiDecoratorBase {
public:
    FrameDecorator(IUiObject & component)
        : IUiDecoratorBase(component)
    {}

    virtual void Draw()
    {
        IUiDecoratorBase::Draw();
        drawFrame();
    }

private:
    void drawFrame(); // 枠を描画する
};

// Client
void CreateFramedObjects()
{
    AddObject(FrameDecorator(MovieObject()));
    AddObject(FrameDecorator(KeyframeAnimeObject()));
}

Composit

2009-09-14T00:23:00.007+09:00

概要
入れ子状に連なる単体のオブジェクトと複数のオブジェクトとを、その違いを意識することなく扱える。

例
単独で行動するキャラと、複数のキャラで行動する部隊とを同じように扱う。

雰囲気


// Component
class IChara {
public:
    virtual void DoSomething() = 0;

protected:
    virtual void AddChild(IChara * pChild) {}
    virtual void RemoveChild(IChara * pChild) {}
};

// Composit
class IUnitBase: public IChara {
public:
    virtual void DoSomething()
    {
        // m_aChildのすべてのDoSomething()を呼ぶ.
    }

    virtual void AddChild(IChara * pChild)
    {
        m_aChild.add(pChild);
    }

    virtual void RemoveChild(IChara * pChild)
    {
        m_aChild.remove(pChild);
    }

protected:
    Array<IChara> m_aChild; // 何らかのコンテナ的な 
};

class Unit : public IUnitBase {
public:
    virtual void DoSomething()
    {
        // 何らかの部隊としての行動

        // 個々の行動
        IUnitBase::DoSomething();
    }
};

// Leaf
class Chara : public IChara {
public:
    virtual void DoSomething()
    {
        // このキャラの行動
    }
};

// Client
void CreateChara()
{
    // 単独のキャラを追加
    AddChara(MakeChara());  // ICharaを受け取る

    // 部隊を追加
    IUnitBase * const pUnit = FormUnit();
    pUnit->AddChara(MakeChara());
    pUnit->AddChara(MakeChara());
    AddChara(pUnit);        // ICharaを受け取る
}
void DoSomething()
{
    // AddChara(IChara *) で追加したキャラ全てを動かす
}

Command

2009-09-12T23:45:00.007+09:00

概要
要求を出す側がその実際の処理を知ることなく要求を出すことができる。
状態の保存と逆処理を行えるようにすることで、UnDoとReDoをサポートできる。

例
いくつかのスキルをもったキャラクターがおり、メニューからそのスキルを使用する。

雰囲気


// Command
class ISpecialSkill {
public:
    virtual Result Execute(Chara &target) const {};
};

// ConcreteCommand
/*
    指定したキャラの所持金を増やす
*/
class Skill_GetMoneyRandom {
public:
    virtual Result Execute(Chara &target) const
    {
        target.AddMoney();
    }
};

/*
    指定したキャラの体力を回復させる
*/ 
class Skill_Heal {
public:
    virtual Result Execute(Chara &target) const
    {
        target.RecoverLifePoint();
    }
};

// Receiver
class IChara {
public:
    virtual void AddMoney();
    virtual void RecoverLifePoint();
};

// Invoker
class SkillMenuItem {
public:
    SkillMenuItem(const ISpecialSkill &skill)
        : m_skill(skill)
    {}

    Result OnSelected(Chara &target) const
    {
        return skill.Execute(target);
    }

private:
    const ISpecialSkill &m_skill;
};

// Client
void RegisterSkillMenu()
{
    AddSkillMenu(SkillMenuItem(Skill_GetMoneyRandom()));
    AddSkillMenu(SkillMenuItem(Skill_Heal()));
}
void ClickSkillMenu()
{
    const SkillMenuItem & item = GetSelectedSkillMenuItem();
    Chara & target = GetSelectedTarget();
    item.OnSelected(target);
}

Chain of Responsibility

2009-09-06T12:51:00.005+09:00

概要
オブジェクトを階層状につなげ、自分が処理できない要求は連鎖的に上位層に渡す。

例
項目を選ぶとポップアップが開くオプションメニューがあり、
オプション自体もポップアップで、「サウンド」を選ぶとその上にサウンド関連のメニューが重なり、「BGM」「SE」「VIOCE」などを選ぶとそれぞれの調整画面が開くとする。
入力は最前面のポップアップのみが受け取るが、一気にオプションから抜けるなど、下のポップアップ（上位層）に任される処理も存在する。

雰囲気


// Handler
class InputHandler {
protected:
    virtual void handleRequest(BUTTON);  // 入力したボタン情報を受け取る

private:
    InputHandler * m_pSuccessor; // successorへのリンク
};

class IPopup : public InputHandler { // ポップアップのインターフェイス
public:
    virtual void Update() {} // 更新処理
    virtual void Input() {}  // 入力処理, 最前面のもののみ呼ばれる
    virtual void Draw() {}   // 描画処理
};

// ConcreteHandler
class PopupOption : public IPopup;      // オプションウィンドウ
class PopupSoundMenu : public IPopup;   // サウンドメニュー
class PopupSoundAdjust : public IPopup; // 音量調整

// Client
void PopupSoundAdjust::Input()
{
    // モードから一気に抜けるボタンを押した
    if (pad.isClicked(ESCAPE)) {
        handleRequest(ESCAPE);
    }
}

void PopupSoundAdjust::handleRequest(BUTTON button)
{
    switch (button) {
    default:
        /*
            処理できないのでsuccessorに任せる.
            上には → PopupSoundMenu → PopupOption がいる.
        */
        InputHandler::handleRequest(button);
        break;

    case DECIDE:
        // 決定処理
        break;

    case CANCEL:
        // キャンセル処理
        break;
    }
} 

/*
    自分で処理できないときはsuccessorに任せる.
*/
void InputHandler::handleRequest(BUTTON button)
{
    if (m_pSuccessor) {
        m_pSuccessor->handleRequest(button);
    }
}

Builder

2009-09-06T05:50:00.004+09:00

概要
表現形式に依存せず同じ手順でオブジェクトを生成する。

例
プレイ中のスクリーンショットを撮影し、ファイルに保存する。
保存するファイル形式は複数種類から選べ、今後も増える可能性があるので、
ファイル形式ごとのBuilderで生成を行う。

雰囲気


// Director
/*
    フレームバッファを取得し、指定した画像形式のBuilderでエンコードする.
*/
class ScreenCapture {
public:
    ScreenCapture(ImageEncorder &);
};

// Builder
class ImageEncorder; // 画像を何らかのフォーマットにエンコードする

// ConcreteBuilder
class BmpEncorder : public ImageEncorder;  // Bitmapファイル形式にエンコードする
class PngEncorder : public ImageEncorder { // PNGファイル形式にエンコードする
public:
    const Png * GetResult() const;
};

// Product
class Bitmap;
class Png {
public:
    void SaveToFile(const std::string & filename) const; // ファイルに保存する
};

// Client
void CreateSnapShot()
{
    PngEncorder builder;
    ScreenCapture capture(builder); // Builderを指定する

    // 結果を取得する
    const Png * const pData = builder.GetResult();
    pData->SaveToFile(FILENAME);
}

Bridge

2009-09-06T05:06:00.006+09:00

概要
実装を分離することで、クラスの拡張性を高めるとともに、実装を隠蔽し、コンパイル時の依存性を下げることができる。

例
動画ファイルの再生、キーフレームアニメ、スプライトアニメを同列に扱いアニメーションを表示したい。
ただし、使用箇所に合わせて何らかの拡張を行うことが考えられるため、実装は分離する。

雰囲気


// Abstruction
class AnimeBase {
   /*
       アニメの基本機能はAnimeImplで実装する.
   */
   AnimeImpl * m_pAnime;
};

// RefinedAbstruction
class AnimeOnBackground : public AnimeBase;    // ゲームの背景素材としてアニメを表示する
class AnimeOnDisplayInGame : public AnimeBase; // ゲーム空間内のディスプレイにアニメを表示する

// Implementor
class AnimeImpl; // アニメの実装のインターフェイス

// ConcreteImplementor
class MovieAnimeImpl : public AnimeImpl;    // 動画ファイル
class KeyFrameAnimeImpl : public AnimeImpl; // キーフレームアニメーション
class SpriteAnimeImpl : public AnimeImpl;   // スプライトアニメ

Adaptor

2009-09-06T04:06:00.007+09:00

概要
あるクラスのインターフェイスを、必要とされるインターフェイスに変換する。

例
様々な形式の設定ファイルを読み込むために、IParserの具象化クラスで解析するようにしている。
XMLから読み込む必要が生まれたので、既にあるXmlParserを使用して実装したい。
XmlParserはIParserのサブクラスではないが、Adaptorを作成することで使用できるようになる。

雰囲気


// Target
class IParser;

// Adaptee
class XmlParser;

// Adaptor
class XmlParserAdaptor : public IParser {
    /*
        IParserの機能はXmlParserを使って実装する.
    */
    XmlParser m_parser;
}

// Client
/*
    IParserを使って設定ファイルを読み込む.
    XmlParserは使用できないが, Adaptor(XmlParserAdaptor)なら使用できる.
*/
void LoadConfig(IParser &);

その他
オブジェクトコンポジション、多重継承の二通りの方法で実現できる。

Abstruct Factory

2009-09-06T00:10:00.012+09:00

概要
複数のオブジェクトを使って実現する機能があるとき、そのまとまり単位で生成するようにする。
そのまとまりを丸ごと違うものと入れ替えられるようにする。
使う側は実際に生成されるオブジェクトの違いを意識しなくて良い。

例
16:9と4:3ではメニュー画面の異なるゲームがあり、
メニュー画面には「メニューそのもの」「背景」「説明テキスト欄」があるとする。
16:9と4:3とのそれぞれのオブジェクトとFactoryを用意し、呼び出す際に画面の設定を見て作成するほうを決める。

雰囲気


// AbstructFactory
class IModeMenuFactory; // Factoryのインターフェイス

// AbstructProduct
class IMenu;       // メニューのインターフェイス
class IBackground; // 背景のインターフェイス
class IExplain;    // 説明テキスト欄のインターフェイス

// ConcreteFactory
class NormlModeMenuFactory : public IModeMenuFactory; // 4:3でのメニュー画面
class WideModeMenuFactory: public IModeMenuFactory;   // 16:9でのメニュー画面

// ConcreteProduct
class NormalMenu  : public IMenu;            // 4:3でのメニュー
class NormalBackground : public IBackground; // 4:3での背景
class NormalExplain : public IExplain;       // 4:3での説明テキスト欄

class WideMenu : public IMenu;             // 16:9でのメニュー
class WideBackground : public IBackground; // 16:9での背景
class WideExplain : public IExplain;       // 16:9での説明テキスト欄

// Client
/*
    ConcreteFactory(4:3ならNormalModeMenuFactory, 16:9ならWideModeMenuFactoryのインスタンス)を受け取りメニュー画面を作成する.
    内部ではConcreteFactoryが生成したConcreteProductをアップキャストしたAbstructProduct(IMenu, IBackground, IExplain)を使う.
    受け渡しがAbstructFactory, 使用するのがAbstructProductと抽象化されているので, 丸ごと差し替えられる.
    ClientはConcreteProductについて知らなくても良い.
*/
void CreateModeMenu(const IModeMenuFactory & factory)
{
    IMenu * const pMenu = factory.CreateMenu();
    IBackground * const pBg = factory.CreateBackground();
    IExplain * const pExplain = factory.CreateExplain();

    SetModeMenuObjects(pMenu, pBg, pExplain);
}

デザインパターン: カテゴリの説明

2009-09-06T00:09:00.005+09:00

デザインパターンについてのメモを書きます。
ちまちま増やしていきたいと思います。

『オブジェクト指向における再利用のためのデザインパターン改訂版』を読みながらやっています。
勉強しつつなので、間違ってたらごめんねって感じですね。