🔫
Entity Container Shareable: ゲーム開発のための新しいアプローチ

2025/03/02に公開
Game
gamedev
architecture
tech
AI (Cline) に自分の主張をまとめさせたらいい感じになったので投稿してみます。以下全部Clineが生成したもので、Chatはしたけど直接人力で編集した箇所は一個もありません。

 Entity Container Shareable: ゲーム開発のための新しいアプローチ
 はじめにゲーム開発において、エンティティ管理は常に重要な課題です。従来のEntity Component System（ECS）は広く採用されていますが、実装時にはいくつかの課題に直面することがあります。この記事では、従来のECSの課題を振り返りながら、より実用的なアプローチである「Entity Container Shareable」について紹介します。

 従来のEntity Component Systemの課題従来のECSは優れた設計思想を持っていますが、実際の開発現場では以下のような課題に直面することがあります：
目的の多様性: ECSが解決しようとする問題（メモリ効率、コード可読性、並列処理など）について、開発者間で認識が異なることがあります。これにより、実装方法や設計方針が一貫しないことがあります。
メモリ効率の現実: コンポーネントのメモリレイアウトを最適化するには、かなりの工夫が必要です。ECSを採用するだけで自動的にパフォーマンスが向上するわけではありません。
型の扱いの複雑さ: 多くのECS実装では、コンポーネントの取得時に型アサーション（型の明示的な変換）が必要になり、コードの安全性や可読性に影響することがあります。
データ共有の難しさ: 位置情報のような複数のシステムで共有される情報をどのコンポーネントに配置するかという設計判断が難しく、どのような選択をしても効率面でトレードオフが生じます。
これらの課題は、ECSの概念自体が悪いというわけではなく、理想と実装の間にギャップがあることを示しています。

 Entity Container ShareableとはEntity Container Shareable（ECS、ただし従来のEntity Component Systemとは異なります）は、「複数のコンテナでエンティティを共有する」という明確で実用的な目標に焦点を当てたアプローチです。シンプルな設計思想により、上記の課題を回避しながら、エンティティ管理の主要な利点を活かすことができます。

 従来のECSとの違い

従来のECS
Entity Container Shareable


エンティティはIDのみ
エンティティは具体的なオブジェクト

コンポーネントはデータのみ
エンティティ自体がメソッド（振る舞い）を持つ

システムがロジックを実装
機能別インターフェースとイテレータでロジックを実行

単一のエンティティマネージャー
複数のコンテナに同じエンティティを共有


 主な特徴
コンテナベースのアプローチ: 従来のECSとは異なり、エンティティは複数の異なるコンテナに格納され共有されます

Shareableインターフェース: エンティティの削除状態を管理し、複数のコンテナ間で共有するための核心的なインターフェース

機能別インターフェース: 必要な機能に応じたインターフェースを定義し、柔軟な設計が可能

型安全: 言語の型システムを活用した型安全な実装ができます

 Shareableインターフェース：Entity Container Shareableの核心Entity Container Shareableの本質は、Shareableインターフェースにあります。このインターフェースは、エンティティの削除状態を管理し、複数のコンテナ間でその状態を共有することを可能にします。
Shareableインターフェースは、通常以下の機能を提供します：
エンティティが削除されたかどうかを確認する機能
エンティティを削除する機能
このシンプルなインターフェースにより、同じエンティティが複数のコンテナに存在する場合でも、一度削除すればすべてのコンテナでその削除状態が共有されます。これにより、エンティティの一貫した管理が可能になります。

 実装例以下に、Go言語でのEntity Container Shareableの実装例を示します。ただし、この概念は特定の言語に依存せず、様々なプログラミング言語で実装可能です。

 基本的なインターフェースとユーティリティpackage ecs

// Shareable は削除可能なエンティティのインターフェース
type Shareable interface {
	Deleted() bool
	Delete()
}

// ShareableImpl は Shareable インターフェースの基本実装
type ShareableImpl struct {
	deleted bool
}

func (s *ShareableImpl) Deleted() bool {
	return s.deleted
}

func (s *ShareableImpl) Delete() {
	s.deleted = true
}

// CompactingAll は削除されたエンティティをスキップしながらコンテナを圧縮するユーティリティ関数の例
func CompactingAll[T Shareable](s *[]T) func(yield func(int, T) bool) {
	return func(yield func(int, T) bool) {
		j := 0
		cont := true
		for i, v := range *s {
			if v.Deleted() {
				continue
			}
			if j < i {
				(*s)[j] = v
			}
			if cont {
				cont = yield(j, v)
			}
			if v.Deleted() {
				continue
			}
			j++
		}
		*s = (*s)[:j]
	}
}

 基本的な使用例package main

import (
	"fmt"
)

// 機能別インターフェースを定義
type Drawable interface {
	Shareable
	Draw()
}

type Updatable interface {
	Shareable
	Update()
}

// エンティティの定義
type Bullet struct {
	ShareableImpl // 削除管理の基本実装を埋め込み
}

func (b *Bullet) Draw() {
	fmt.Println("Bullet drawn")
}

func (b *Bullet) Update() {
	fmt.Println("Bullet updated")
}

func main() {
	// 機能別のコンテナを定義
	var drawables []Drawable
	var updatables []Updatable
	
	// エンティティの作成と複数のコンテナへの追加
	bullet := &Bullet{}
	drawables = append(drawables, bullet)
	updatables = append(updatables, bullet)
	
	// 各コンテナに対して処理を実行
	for _, d := range CompactingAll(&drawables) {
		d.Draw()
	}
	
	for _, u := range CompactingAll(&updatables) {
		u.Update()
	}
	
	// エンティティの削除（すべてのコンテナで共有される削除状態）
	bullet.Delete()
	
	// 次のイテレーションでは、削除されたエンティティは自動的にスキップされる
	for _, d := range CompactingAll(&drawables) {
		d.Draw() // bulletは削除されているため呼び出されない
	}
	
	for _, u := range CompactingAll(&updatables) {
		u.Update() // bulletは削除されているため呼び出されない
	}
	
	// 注: CompactingAll関数は実装例の一つであり、削除されたエンティティをスキップしながら
	// コンテナを圧縮するユーティリティとして使用できます
}

 ゲーム開発での実践的な使用例// 機能別インターフェース
type drawable interface {
	Shareable
	Draw()
}

type updatable interface {
	Shareable
	Update(dt float64)
}

type collidable interface {
	Shareable
	GetBounds() rect
	OnCollision(other collidable)
}

type destructible interface {
	Shareable
	TakeDamage(amount int)
	IsDead() bool
}

// 位置と速度の構造体
type position struct {
	x, y float64
}

type velocity struct {
	dx, dy float64
}

type rect struct {
	x, y, w, h float64
}

// エンティティの例
type player struct {
	ShareableImpl
	pos    position
	vel    velocity
	health int
}

func (p *player) Draw() {
	// プレイヤーの描画ロジック
	fmt.Println("Drawing player at", p.pos.x, p.pos.y)
}

func (p *player) Update(dt float64) {
	// 位置の更新
	p.pos.x += p.vel.dx * dt
	p.pos.y += p.vel.dy * dt
}

func (p *player) GetBounds() rect {
	return rect{p.pos.x - 10, p.pos.y - 10, 20, 20}
}

func (p *player) OnCollision(other collidable) {
	// 衝突時の処理
	fmt.Println("Player collided with something")
}

func (p *player) TakeDamage(amount int) {
	p.health -= amount
	if p.health <= 0 {
		fmt.Println("Player died")
		p.Delete() // すべてのコンテナから削除される
	}
}

func (p *player) IsDead() bool {
	return p.health <= 0
}

// ゲームの基本コンテナ
var (
	drawables     []drawable     // 描画可能なエンティティ
	updatables    []updatable    // 更新可能なエンティティ
	collidables   []collidable   // 衝突判定可能なエンティティ
	destructibles []destructible // 破壊可能なエンティティ
)

// ゲームループの例
func updateGame(dt float64) {
	// すべての更新可能なエンティティを更新
	for _, u := range CompactingAll(&updatables) {
		u.Update(dt)
	}
	
	// 衝突判定
	for i, c1 := range CompactingAll(&collidables) {
		for _, c2 := range collidables[i+1:] {
			if c2.Deleted() {
				continue
			}
			
			bounds1 := c1.GetBounds()
			bounds2 := c2.GetBounds()
			
			// 簡易的な衝突判定
			if bounds1.x < bounds2.x+bounds2.w &&
				bounds1.x+bounds1.w > bounds2.x &&
				bounds1.y < bounds2.y+bounds2.h &&
				bounds1.y+bounds1.h > bounds2.y {
				c1.OnCollision(c2)
				c2.OnCollision(c1)
			}
		}
	}
	
	// 破壊可能なエンティティの確認
	for _, d := range CompactingAll(&destructibles) {
		if d.IsDead() {
			d.Delete()
		}
	}
}

func drawGame() {
	// すべての描画可能なエンティティを描画
	for _, d := range CompactingAll(&drawables) {
		d.Draw()
	}
}

 他の言語での実装例Entity Container Shareableの概念は、様々なプログラミング言語で実装可能です。以下に、TypeScriptでの実装例を示します。
// Shareableインターフェース
interface Shareable {
  isDeleted(): boolean;
  delete(): void;
}

// 基本実装クラス
class ShareableImpl implements Shareable {
  private deleted: boolean = false;
  
  isDeleted(): boolean {
    return this.deleted;
  }
  
  delete(): void {
    this.deleted = true;
  }
}

// 機能別インターフェース
interface Drawable extends Shareable {
  draw(): void;
}

interface Updatable extends Shareable {
  update(dt: number): void;
}

// エンティティの例
class Bullet extends ShareableImpl implements Drawable, Updatable {
  draw(): void {
    console.log("Bullet drawn");
  }
  
  update(dt: number): void {
    console.log("Bullet updated");
  }
}

// 使用例
const drawables: Drawable[] = [];
const updatables: Updatable[] = [];

const bullet = new Bullet();
drawables.push(bullet);
updatables.push(bullet);

// コンテナをフィルタリングして処理する関数
function compactingAll<T extends Shareable>(array: T[]): T[] {
  // 削除されていないエンティティだけをフィルタリング
  const filtered = array.filter(item => !item.isDeleted());
  
  // 元の配列を更新（圧縮）
  array.length = 0;
  array.push(...filtered);
  
  return filtered;
}

// 各コンテナに対して処理を実行
for (const drawable of compactingAll(drawables)) {
  drawable.draw();
}

for (const updatable of compactingAll(updatables)) {
  updatable.update(0.16);
}

// エンティティの削除（すべてのコンテナで共有される削除状態）
bullet.delete();

// 次のイテレーションでは、削除されたエンティティは自動的にスキップされる
for (const drawable of compactingAll(drawables)) {
  drawable.draw(); // bulletは削除されているため呼び出されない
}

 メリットEntity Container Shareableアプローチには、以下のようなメリットがあります：

シンプルな概念: 「複数のコンテナでエンティティを共有する」という明確な目的に焦点を当てています。

一貫した削除管理: Shareableインターフェースにより、エンティティの削除状態がすべてのコンテナで共有されます。

型安全: 言語の型システムを活用することで、型安全なコードを書くことができます。

柔軟な設計: 機能別インターフェースにより、必要な機能だけを実装できます。

実装の容易さ: 複雑な概念や抽象化を避け、実用的な問題に対する明確なアプローチを提供します。

言語非依存: 概念自体は特定の言語に依存せず、様々なプログラミング言語で実装可能です。

効率的なイテレーション: CompactingAllのようなユーティリティを使用することで、削除チェックとコンテナの圧縮を同時に行うことができます。

 より深掘りしたい内容
 メモリ戦略と最適化Entity Container Shareableは具体的なメモリ戦略について明示的に言及していません。これは魔法のように便利になる仕組みを提供するわけではありませんが、その代わりに以下のような具体的な最適化を適用しやすい設計となっています：

エンティティのバッチ確保: エンティティ作成時に複数個まとめてメモリを確保することで、メモリ断片化を減らし、キャッシュ効率を向上させることができます。

コンテナごとの最適化: 各コンテナは独立しているため、アクセスパターンに応じた最適化が可能です。

遅延削除と一括圧縮: 削除フラグを使用することで、安全な遅延削除と効率的な一括圧縮が実現できます。

 Shareableインターフェースの本質Shareableインターフェースは、より広い文脈で見ると興味深い特性を持っています：

状態共有メカニズム: Shareableインターフェースは、削除状態という重要な情報を複数のコンテナ間で共有するメカニズムを提供します。これは参照カウントとは異なりますが、オブジェクトの状態を追跡するという点で類似した目的を持ちます。

分散型ライフサイクル管理: 単一の管理システムではなく、エンティティ自身が削除状態を管理することで、分散型のライフサイクル管理が可能になります。

 他の分野での類似パターン「一つのオブジェクトを複数のコンテナから参照する」というパターンは、様々な分野で見られます：

C++のMulti-index Container: Boostライブラリのmulti-index containerは、同じオブジェクトに対して複数の異なるインデックス（アクセス方法）を提供します。

データベースのインデックス: リレーショナルデータベースでは、プライマリキー以外にも複数のインデックスを作成することで、同じレコードに対して複数の検索パスを提供します。これは「一つのエンティティを複数の方法で検索する」という点でEntity Container Shareableに概念的に似ています。

イベントシステム: 多くのゲームエンジンやUIフレームワークでは、同じオブジェクトが複数のイベントリスナーリストに登録されることがあります。

空間分割データ構造: 四分木やBSP木などの空間分割データ構造では、オブジェクトの参照やポインタが複数の空間セルに存在することがあります。特に、大きなオブジェクトや境界をまたぐオブジェクトの場合、効率的な衝突検出のために複数のセルからアクセスできるようにします。

ECS内のタグシステム: 一部のECS実装では、エンティティに複数のタグを付けることができ、それぞれのタグごとにコレクションが存在します。
Webアプリケーションではリクエストごとにメモリを破棄するため、インメモリでオブジェクトを複数のコンテナに共有する方法はあまり使われません。一方、ゲーム開発では長時間実行されるプロセス内でのメモリ管理が重要であり、Entity Container Shareableのようなアプローチが特に有用です。
ゲームプログラミングはWebアプリケーション開発と比較して、特定の設計パターンに関する研究が遅れがちな面もありますが、Entity Container Shareableのような実用的なアプローチは、ゲーム開発特有の問題に対する効果的な解決策となり得ます。

 まとめEntity Container Shareableは、従来のEntity Component Systemの課題を解決するための実用的なアプローチです。「複数のコンテナでエンティティを共有する」という明確な目標に焦点を当て、シンプルかつ効率的なエンティティ管理を実現します。
このアプローチの核心は、Shareableインターフェースにあります。このインターフェースにより、エンティティの削除状態を複数のコンテナ間で共有することができ、一貫したエンティティ管理が可能になります。
大きな概念を実用的な部分に分解し、実際の開発ニーズに合わせて適用するという考え方は、ソフトウェア開発において重要です。Entity Container Shareableは、この考え方に基づいた実践的なアプローチであり、ゲーム開発における効率的なエンティティ管理を可能にします。
従来のECSに代わる新しい選択肢として、Entity Container Shareableを検討してみてはいかがでしょうか。
従来のECS	Entity Container Shareable
エンティティはIDのみ	エンティティは具体的なオブジェクト
コンポーネントはデータのみ	エンティティ自体がメソッド（振る舞い）を持つ
システムがロジックを実装	機能別インターフェースとイテレータでロジックを実行
単一のエンティティマネージャー	複数のコンテナに同じエンティティを共有
Entity Container Shareable: ゲーム開発のための新しいアプローチ

はじめに

従来のEntity Component Systemの課題

Entity Container Shareableとは

従来のECSとの違い

主な特徴

Shareableインターフェース：Entity Container Shareableの核心

実装例

基本的なインターフェースとユーティリティ

基本的な使用例

ゲーム開発での実践的な使用例

他の言語での実装例

メリット

より深掘りしたい内容

メモリ戦略と最適化

Shareableインターフェースの本質

他の分野での類似パターン

まとめ

Discussion
