Rustでゲームプログラ厶を組む場合、Entity Component System（以下ECS）による設計が有力な候補となります。
RustのECSライブラリ/フレームワークはいくつかありますが、抽象化の恩恵を得るために、内部はダイナミックな機構が使われていることが多いようです。
しかし、せっかくゼロコスト抽象化を謳っているRustなので、スタティックなECSを作りたい！と思い立って、作り始めました。
そして、だいたい形になったので、今回はその紹介をさせていただきます。
できたもの
先に、できたものの見た目を紹介します。
例えばこんなコンポーネントを作ったとして、
struct Input(f32,f32); //アナログコントローラ入力
struct AI{ state: i32 }; //敵のAI とりあえず例として、何かのステートを持つ
struct Velocity(f32,f32); //速度 x,y
struct Position(f32,f32); //位置 x,y
下記の様に、ワールドを定義、生成します。
world!(
//型名
World {
//コンポーネント型を列挙
Input,
AI,
Velocity,
Position,
}
}
//ワールドを生成
let world = World::default();
エンティティーの追加
//プレイヤーキャラ（エンティティ）の作成
add_entity!(
world;
Input::default(),
Velocity::default(),
Position::default(),
);
//敵（エンティティ）の作成
add_entity!(
world;
AI::default(),
Velocity::default(),
Position::default(),
);
システムの定義と呼び出し
//ゲームループ
while !game_end() {
//Inputを参照してVelocityを計算するシステム
system!(
world,
//ラムダ式風の書式で、
//|エンティティIDを受け取る変数, 更新対象の変数:型, 参照する変数:型, 参照する変数:型...|
|entity_id, vel:&Velocity, input:&Input| {
//inputの5倍を速度とする
let mut new_vel = vel.clone();
new_vel.0 = input.0 * 5f32;
new_vel.1 = input.1 * 5f32;
//計算後の値を返す
new_vel
}
);
//AIからVelocityを計算するシステム
system!(
world,
|entity_id, vel:&Velocity, ai: &AI| {
let mut new_vel = vel.clone();
//aiの情報を使って、new_velを決める
// ... 何かのロジック ...
//計算後の値を返す
new_vel
}
);
//VelocityからPositionを計算するシステム
system!(
world,
|entity_id, pos:&Position, vel:&Velocity| {
//位置に速度を加算
let mut new_pos = pos.clone();
new_pos.0 += vel.0;
new_pos.1 += vel.1;
//計算後の値を返す
new_pos
}
);
}
こんな感じになりました。
上記の例は、システムが「同じエンティティーIDを持つコンポーネントだけを参照する場合」ですが、もっと複雑なロジックを書くこともできます。
中身の説明
では中身の説明に入っていきます。
まず試しに、素直な実装でECSを組んでみると、こんな感じになると思います。
//コンポーネント１種類を管理するコンテナを作って
struct ComponentContainer<T> {
components: Vec<T>,
//管理情報など
}
//ワールドの定義
struct World {
inputs: ComponentContainer<Input>,
ais: ComponentContainer<AI>,
velocities: ComponentContainer<Velocity>,
positions: ComponentContainer<Position>,
}
ここでまず、構造体のフィールド名と、コンポーネント型を１対１で対応させることになります。
positions: ComponentContainer<Position>,
^^^ここと ^^^ここが
同じになるので、わざわざ書くのが面倒な気持ちになります。
特にコンポーネントの種類が増えてくると、煩わしいですね。
かといってタプルを使って
type World = (
ComponentContainer<Input>,
ComponentContainer<AI>,
ComponentContainer<Velocity>,
ComponentContainer<Position>,
);
としても、使うときに、えーとVelocityは何番目だったっけ・・・てなりますね。
なんとか、型名だけを覚えていれば使えるようにできないものでしょうか？
concat_idents (https://doc.rust-lang.org/std/macro.concat_idents.html) を使えばいけそうな気もしますが、型名をidentityにつなげることは無理な様でした。
そこで、考案したのがこちら
macro_rules! recursive_tuple {
( $t: ty ) => {
($t, ())
};
( $th:ty, $( $tt: ty ),+ $(,)? ) => {
($th, recursive_tuple!($($tt),+))
};
}
これは、例えば
recursive_tuple!(i32, f32, u32)
と書くと
(i32, (f32, (u32, ())))
こんな風に展開されます。（再帰的なタプル）
これだと、例えば
type IntFloatUint = recursive_tuple!(i32, f32, u32);
let ifu = IntFloatUint::default();
としたとして、
//i32を参照するには
ifu.0
//f32を参照するには
ifu.1.0
//u32を参照するには
ifu.1.1.0
このように、再帰的に 1. を繰り返すことで、目的の型を持つデータを参照できます。
そして、型を指定して参照するようにしたい場合は、ジェネリックなtraitを用いて、下記のようにできます。
trait TypeRef<T> {
fn type_ref(&self) -> &T;
}
impl TypeRef<i32> for IntFloatUint {
fn type_ref(&self) -> &i32 {
&self.0
}
}
impl TypeRef<f32> for IntFloatUint {
fn type_ref(&self) -> &f32 {
&self.1.0
}
}
impl TypeRef<u32> for IntFloatUint {
fn type_ref(&self) -> &u32 {
&self.1.1.0
}
}
このimpl をマクロで定義できるようにしてみます。
macro_rules! impl_typeref {
( $torg:ty, $t: ty ) => {
impl TypeRef<$t> for $torg {
fn type_ref(&self) -> &$t {
&self.0
}
}
};
( $torg:ty, $th:ty, $( $tt: ty ),+ $(,)? ) => {
impl TypeRef<$th> for $torg {
fn type_ref(&self) -> &$th {
&self.0
}
}
$(
impl TypeRef<$tt> for $torg {
fn type_ref(&self) -> &$tt {
self.1.type_ref()
}
}
)+
impl_typeref!{ recursive_tuple!($($tt),+), $($tt),+ }
};
}
説明します。
impl_typeref!(IntFloatUint, i32, f32, u32)
と書くと、以下のように再帰的に展開されます。
//展開 第一段階
impl TypeRef<i32> for IntFloatUint {
fn type_ref(&self) -> &i32 {
&self.0
}
}
impl TypeRef<f32> for IntFloatUint {
fn type_ref(&self) -> &f32 {
self.1.type_ref()
}
}
impl TypeRef<u32> for IntFloatUint {
fn type_ref(&self) -> &u32 {
self.1.type_ref()
}
}
impl_typeref!( recursive_tuple!(f32, u32) ); // (f32, (u32, ()))に対して再帰
//展開第二段階
impl TypeRef<f32> for (f32, (u32, ())) {
fn type_ref(&self) -> &f32 {
&self.0
}
}
impl TypeRef<u32> for (f32, (u32, ())) {
fn type_ref(&self) -> &u32 {
self.1.type_ref()
}
}
impl_typeref!( recursive_tuple!(u32) ); // (u32, ())に対して再帰
//第三段階
impl TypeRef<u32> for (u32, ()) {
fn type_ref(&self) -> &u32 {
&self.0
}
}
そうすると、下記のように型を指定してアクセスできるようになります。
let i = TypeRef::<i32>::type_ref(&ifu);
これもちょっと煩わしいので、マクロにします。
macro_rules! typeref {
($e:expr, $t:ty) => {
TypeRef::<$t>::type_ref(&$e);
};
}
そうすると
let i = typeref!(ifu, i32);
このように「型を指定するだけでフィールドを参照できるタプル」を作ることができます。
なお、型は同じものが２つ使われていないことが前提です。
もし使おうとすると、impl Traitのところで二重定義のエラーがでます。
これをECSのコンポーネントの管理に使うことで、最初に紹介した様な、スタティックにコンポーネントにアクセスするECSの仕組みができました。
ソースはこちらで公開しています（まだ開発中です）
https://github.com/mas-yo/static_ecs
これを使ってサンプルゲームも作っています。
https://github.com/mas-yo/rust-ecs-game
さいごに
私もまだまだ勉強中なので、それならこんなクレートを使えば便利だよ！とか、ここはこうしたらいいんじゃない？とかあったら、教えてください。
いやーRustって、本当に、面白いものですね。
ではまた、お会いしましょう♪