Thirsty

01 — 概要

ゲーム用の世界シミュレータ

Thirsty Engine — a world simulator for game development

RimWorld、Elona、SimCity のように、多数の対象が相互作用するゲームのための基盤です。世界のデータと、それに働く処理を別々に追加し、共通の契約を通して組み合わせます。

  • Tauto で component と処理、Eure で entity と実行順を定義します。
  • コンテンツと Mod は同じ仕組みで追加でき、コードもデータも hot reload できます。
  • ロジックは固定 tick。直列・競合を避けた並列・投機的な並列実行を選べます。
  • MVCC でデータの版を管理し、transaction の分離レベルを system ごとに指定できます。
  • VM で実行を管理し、JIT で計算処理を機械語にして高速化する構成です。
  • 世界を分岐させ、本番と同じ処理で行動案をシミュレーションできます。
直交して追加されるコンテンツ 木を切る処理、体力、alice の初期データ、そして後から足す火は、互いのファイルを編集せず、世界と可燃性の契約を介して接続する。 effect 木を切る component 体力 entity alice あとから足す effect 火 世界 primary 契約
火は別ファイルです。可燃性のような共有 component を持つ entity に作用します。

既存のコードを変えずに追加

燃える処理を一つ書けば、可燃性を持つ木や建物に使えます。Mod も同じ書き方です。

ECS とコンテンツの追加

再起動せずに変更を確認

コードやデータを編集すると、実行中のゲームに反映されます。プレイ中に変わった値は上書きされません。

Hot reload とデータの保存

行動を選ぶ前にシミュレーション

世界を分岐させて、戦う場合と逃げる場合を試せます。本番と同じ処理を使い、結果を判断する AI を自分で書けます。

Namespace でのシミュレーション

02 — ECS で世界を組み立てる

ECS で世界を組み立てる

まず世界の構成要素を押さえ、ファイルを独立して追加できる理由を見ます。

ECS:対象、データ、処理を分ける

ECS は Entity・Component・System の略です。「人クラス」「木クラス」にそれぞれ振る舞いを閉じ込めず、必要なデータを持つ対象に同じ処理を適用します。人も木も Health を持てば、同じ回復処理の対象になります。

概念役割Thirsty の例
Entity世界に存在する一つの対象の識別子。持つデータの組み合わせは変えられる。人間、木、太陽、土地。識別には ID と namespace を使う。
Componententity に付く型付きデータ。処理そのものは持たない。Health、Position、Burning。Tauto の struct / enum で型を定義する。
System必要なデータを読み、世界を変更する関数。空腹の周期処理、回復の一回の処理。変更は update などの effect を通す。
Querycomponent の組み合わせで対象を絞り、必要な値を取り出す窓口。Health を持ち、Dead を持たない entity を列挙する。
同じ Query が人と木を選ぶ alice は Position と Health、木は Position と Health と Flammable、岩は Position を持つ。Health を要求する Query は alice と木を選び、回復処理へ渡す。岩は選ばない。 alicePosition + Health 木Position + Health + Flammable 岩Position Query { health: &Health } 回復処理 update(entity, value) 対象の名前ではなく、持っているデータで選ぶ。
新しい種類の entity も、同じ component を持てば既存の処理に参加できます。

archetype:同じ構成の entity をまとめる

同じ component 型と version の組を持つ entity が、一つの archetype に属します。Query は一致する構成を絞ってから対象を走査できます。Health の値を変えても構成は同じですが、Burning を追加すると所属する構成が変わります。古い型と新しい型は version を区別して共存でき、migration で移行します。

archetype は entity の component 構成からエンジンが扱う分類です。template は初期データの再利用に使います。

何を、どのファイルに書くか

追加するもの書く場所世界への入り方
componentTauto の struct / enum登録 ID を持つデータ型
行動、恒常処理、反応、介入Tauto の関数effect / system / trigger / middleware
entity の初期データ、scheduleEureインスタンスと実行順
Mod同じ tote と Eure標準コンテンツと同じ経路

共有するのは契約です。可燃性のような共通 component があれば、火の tote は既存ファイルを変えずに、その component を持つ entity を燃やします。

tote は Tauto の package 単位です。属性マクロが登録処理を生成するので明示的な登録は不要です。システムの登録とスケジュールは分離されていて、Eure にデータとしてスケジュールを書き、そこに書かなかったものはデフォルトのスケジュールで動きます。

03 — コンテンツを書く

コンテンツを書く

型と初期データから始め、行動・周期処理・反応を組み合わせます。以下は設計上のコード例です。

component

survival::health は、tote 名とローカル ID です。version はここには書きません。

survival/health.tautTAUTO
@component!("health") => def Health::component
pub struct Health {
  current: i64,
  maximum: i64,
}

@component!("activity") => def Activity::component
pub enum Activity {
  Idle,
  Working(remaining: i64),
}
survival/agent.eureEURE
$variant: template
id: agent

components {
  @ "survival::health"
  current = 100
  maximum = 100

  @ "survival::activity"
  $variant: Idle
}
survival/alice.eureEURE
$variant: entity
id: alice
$world.update: keep_dirty

inherits[]: agent

components {
  @ "survival::activity"
  $variant: Working
  remaining = 3
}

entity と template

template は世界に生成しません。entity は合成結果から生成します。上書きは component 全体です。keep_dirty は、最後に反映した定義値から実行中に変わっていなければ反映し、変わっていれば維持します。

合成の順

inherits が参照できるのは template だけです。多段と、tote をまたぐ参照を許します。循環と不明な参照は登録時に拒否します。親を記述順に重ね、最後に自身を重ねます。合成後の component は、Tauto の型に照らして検査します。

template と entity の合成 agent の health と Idle の上に、alice の activity 全体を重ねる。health は残り、activity は Working に置き換わる。 template agent health 100 / 100 activity Idle 先 entity alice activity Working remaining 3 後 合成結果 health 100 / 100 activity Working remaining 3 フィールド単位ではマージしない。activity は alice の component 全体で置き換わる。

effect と Query

定義TAUTO
pub struct HealArg {
  entity: Entity,
}

@effect!("heal") => replace fn heal
pub fn heal(
  arg: HealArg,
  healths: Query({
    entity: Entity,
    health: &Health,
  }),
): Unit ! { entity_not_found, update(Health) } {
  let target := healths.get(arg.entity)
  perform update(
    target.entity,
    Health {
      current: target.health.current + 1,
      maximum: target.health.maximum,
    },
  )
}
呼び出しTAUTO
heal(HealArg { entity: arg.target })

再開量の既定は resume <=1 です。ω を属性で明示することもできます。ゲーム effect は、生成した module 内の pub(handle) effect として再公開します。直接の perform は拒否し、行への記載と handle は許します。

Query の要素

記法一致
&Tその component が必須。共有参照を返す
Option(&T)有無では絞らない
With(T) / Without(T)存在 / 不在。値は空
Has(T)有無では絞らず、存在を Bool として扱える値を返す。取得後に有無が変わっても、その値は変わらない
積 / レコードすべてを満たす AND
A | BQuery が枝を検査して先に一致したものを一つ返す。両方持っていても entity は一度。両方の一致を区別したいときは Or を使う
Or(A, B)Left / Right / Both。両方なしは不一致
filterTAUTO
targets: Query({
  entity: Entity,
  health: &Health,
  armor: Option(&Armor),
  burning: Has(Burning),
  _filter: Without(Dead)
    × (With(Burning) | With(Poisoned)),
})

列挙

  • iter() は開始時に候補 ID を固定する。
  • 各要素は取得時の状態で条件を確認し、外れたものは飛ばす。
  • 走査の開始後に生まれた entity は、その走査に入らない。
  • 有限 for 自体は Div を要求しない。

mutation

effect対象がある対象がない
insertcomponent_already_exists追加する
update値を置き換える。欠落は追加で埋めないcomponent_not_found
remove削除するcomponent_not_found

entity がなければ entity_not_found です。Rust の Option に対する ? のような局所的な早期終了です。失敗した操作はその変更を行わず、それ以前の mutation は巻き戻しません。

Query は現在の namespace。QueryAcross は primary を含む、実行中の namespace です。停止中のnamespaceは含みません。Entity は id と namespace を持ちます。

恒常 system

@system! は schedule に従って起動する関数です。引数はすべて Query などの extractor で、エンジンが供給します。

一回の実行を一つの tick に収める必要はありません。途中で perform wait(20) と書けば、20 tick 後にその続きから処理できます。待っている間も世界の tick と他の system は進みます。

同じ namespace の同じ system は、一回の実行が完了するまで新しく発火しません。例えば 10 tick ごとに起動する system が tick 0 で wait(20) すると、tick 10 では新規起動せず、tick 20 で元の処理の続きを実行します。再開と周期が重なっても二重には起動しません。

trigger と effect は発火・呼び出しごとの実行です。前の実行が wait 中でも、別の発火・呼び出しを受け付けます。

system の singleton と trigger の別インスタンス hunger は tick 0 で開始して wait し、tick 10 の周期では新規起動しない。tick 20 で同じインスタンスを再開する。trigger は tick 0 の実行が残っていても、tick 10 の発火を別インスタンスで受ける。 tick 0 10 20 system hunger 開始、wait 新規起動しない 同じインスタンスを再開 trigger 発火 1 発火 2 並列に走れるかは、アクセス競合と schedule に従います。

trigger と middleware

第一引数は出来事の query、以降は extractor です。条件の成否だけの判定関数は分けず、追加の判断は本体に書きます。middleware は、対象 effect の一回の呼び出しを囲みます。結果型はその呼び出しの戻り値に固定し、呼び出し元の残りまでは囲みません。

middleware は本体の前後に処理を挟み、戻り値を変更できます。後続への委譲には Tauto の継続を使います。生成される Execute は入力と extractor を、Ret は本体を省略した戻り値を持ちます。

survival/clamp_health.tautTAUTO
@trigger!("clamp_health") => def clamp_health::registration
pub fn clamp_health(
  trigger: Added(Health),
  targets: Query({ entity: Entity, health: &Health }),
): Unit ! { entity_not_found, update(Health) } {
  for entity in trigger.list {
    let target := targets.get(entity)
    if target.health.current > target.health.maximum {
      perform update(entity, Health {
        current: target.health.maximum,
        maximum: target.health.maximum,
      })
    }
  }
}

middleware の列

実行は一列のチェーンです。リストの先頭が最も外側で、後処理は逆順です。順序は schedule の tree で指定します。記載のない middleware も自動登録されて参加します。middleware は指定した順に呼ばれます。先頭が最も外側になり、後処理は逆順に実行されます。

middleware のチェーン 先頭の middleware が最も外側。本体のあと、後処理は逆順で戻る。 先頭の middleware 最も外側 次の middleware effect の本体 後処理は、本体のあと、次、先頭の順で戻ります。

出来事の query

出来事の query には Spawned、Added、Removed、Performed などがあります。集約地点は、該当する変更 effect を行に持つ system の終了時です。行にあっても、実際に変更していなければ発火しません。

query渡すもの
Added(A)その集約範囲で A が追加された entity の一覧
Added(A) ∧ Added(B)同じ tick の二つの一覧。両方に対象があれば一度渡す。entity は別でもよい
Added(A × B)同じ entity に A と B が追加された一覧
Or(Added(A), Added(B))A だけなら Left、B だけなら Right、両方なら Both。各枝に対応する出来事の値を渡す
連言と積の違い Added A かつ Added B は二つの一覧を一度渡す。Added A 掛ける B は、同じ entity に両方が付いた一覧だけを渡す。 Added(A) ∧ Added(B) 一覧 A: e1 一覧 B: e2 一度渡す Added(A × B) e1 に A と B e2 は A だけ 組ごとの直積では発火しない。必要な組み合わせは本体が計算する。

Or(Added(A), Added(B)) は、同じ集約範囲でどちらの出来事があったかを区別します。Left は A の出来事とその entity 一覧、Right は B の出来事とその一覧、Both は両方の出来事とそれぞれの一覧を持ちます。両方ともなければ発火しないため、Neither は不要です。

Both の二つの一覧は、別の entity を含んでいても構いません。同じ entity に両方が追加されたことを条件にする場合は Added(A × B) を使います。

何をきっかけに動くか

例えば、一回にまとめて渡す出来事の中で、同じ木に Burning が追加され、削除され、もう一度追加されたとします。Added(Burning) の一覧には、その木が一度だけ入ります。

その出来事で trigger を動かしたあとは、新しい出来事があるまで同じ trigger を再び動かしません。trigger が隣の木に Burning を追加すれば、それは新しい出来事なので、さらに反応が続きます。

反応が続きすぎたら止める

A の反応が B を呼び、B の反応がまた A を呼ぶ、といった処理が続いてもゲームが止まらないよう、最初の出来事から続く処理全体に実行量の上限を設けます。別の trigger に移ったり、途中で変更を確定したりしても、上限は数え直しません。

上限に達したら、その一連の処理を止めて原因を報告します。実行中の transaction でまだ確定していない変更は取り消し、すでに世界へ反映した変更は残します。

04 — 時間と実行順を決める

時間と実行順を決める

schedule はデータ、処理は Tauto の関数です。固定 tick の上で、実行順と変更の確定境界を定めます。

schedule

複数ファイルの tree を合成した DAG です。phase の ID は tote::schedule::phase の一つで、record の記載順が実行順です。

survival/schedule.eureEURE
@ schedules.primary.phases {
  First = {}
  PreUpdate = {}
  Update = {}
  PostUpdate = {}
  Last = {}
}

@ systems[] {
  phase: survival::primary::Update
  every = 10
  offset = 0

  order {
    mode: sequence

    @ children[]
    target: survival::hunger

    @ children[]
    target: survival::starvation
    every = 5
  }
}

hunger は 10 tick ごと
starvation は 5 tick ごと

tickこの tick で動く処理(上から順)
0hunger↓starvation
5starvation
10hunger↓starvation
15starvation
両方が動く tick では hunger → starvation の順。starvation だけが動く tick では、hunger を待たずに実行します。
規則内容
頂点同じ登録 ID の leaf は同じ頂点。同じ leaf を複数回書いても、実行回数は増えない。循環、参照先不明、対象の不一致は指定側のエラー。
sequence隣り合う子のまとまりの間に前後関係を作る。
parallel順序制約を足さない。実際に並列で走れるかはアクセス競合で判断する。
every / offset近い指定がフィールドごとに上書きする。周期を書かない経路は順序だけを追加する。どこにも周期がなければ every = 1、offset = 0。同じ system への異なる周期の明示はエラー。
複数tickにまたがるsystemその tick に実行する処理の完了だけを待つ。wait で預けた継続の完了までは待たない。
既定配置未指定の恒常 system は Thirsty.eure の既定 phase へ入る。明示した配置は既定から移す。両方では実行しない。
子 scheduleEURE
@ schedules.custom {
  between: (
    "survival::primary::PreUpdate",
    "survival::primary::PostUpdate"
  )

  phases {
    Sense = {}
    Think = {}
  }
}
PreUpdate の後に分岐し、PostUpdate の前に合流する 親 schedule は Update を実行する。子 schedule は Sense、Think の順に実行する。二つの経路は並行して進められ、両方が完了してから PostUpdate を開始する。 親 schedule:primary 子 schedule:custom PreUpdate Update Sense Think PostUpdate
PreUpdate が終わると二つの経路に分かれます。親は Update、子は Sense → Think を実行し、両方が終わってから PostUpdate へ進みます。実際の並列実行は execution mode とアクセス競合に従います。

Execution mode:どの処理を並列に進めるか

schedule が決めるのは処理の前後関係です。その制約の中で、どう実行するかを execution mode で選びます。namespace 内の実行方法を指定するもので、別々の namespace が同時に動くこととは独立しています。

モード実行方法特徴
Serial一つずつ実行する。処理の順を追いやすく、動作確認の基準にできる。
ScheduledQuery と effect のアクセス情報から、競合しない処理を並列に進める。競合を事前に避ける。アクセスが重なる処理は順に実行する。
Speculative競合する可能性のある処理も並列に進め、commit 時に検証する。競合が少なければ並列性を増やせる。競合した区間は retry するため、常に速くなるわけではない。

run_namespaces([virtual1, virtual2], simulate, Scheduled) のように要求ごとに明示します。その要求の run_ticks・run_system・run_schedule は同じモードを使います。

MVCC:読み取った値を保ちながら更新する

MVCC は、データの複数の版を保持する仕組みです。Health を更新しても、別の処理が借用している古い Health は書き換えません。読み取りに必要な版を残し、新しい値を別の版として管理します。

transaction 内の変更は、確定するまで他の処理へ公開しません。commit に成功するとまとめて公開し、競合で retry する場合は未確定の変更を捨てて、その区間をやり直します。component だけでなく、State と WorldState の更新も同じ transaction に参加します。

分離レベルと relaxed

execution mode とは別に、system ごとの分離レベルで読み取りの保証を選びます。既定は committed です。transaction を使う場合は自分の変更も読み取れます。relaxed は、自分では transaction を開始しない指定です。

分離レベル読み取りと保証
relaxed外側に transaction がなければ、変更をその都度反映する。処理全体をまとめて取り消す保証は持たない。外側に transaction があれば、その transaction に参加する。
committed取得するたびに、その時点の commit 済みの値を読む。取得済みの参照は元の版を指し続ける。
snapshottransaction 開始時の一貫した状態を読む。途中で他の処理が commit しても、読み取りの基準は変わらない。書き込み競合での retry はあり得る。
serializable確定した読み書きを、いずれかの直列実行順で説明できるように検証する。個々の値だけでなく、Query の条件に一致する対象の変化も検証対象になる。

例えば Health が 100 のときに読み取り、別の処理が 80 を commit した場合、committed で新しく取得すると 80、同じ transaction の snapshot では 100 を読みます。最初に取得した参照は、どちらでも 100 のままです。

別の effect を呼んだとき

下の表は、実行中の処理から別の effect を呼ぶ場合です。transaction 内では、呼び出した先も同じ transaction に参加します。relaxed を呼んでも、途中で変更を独立して確定することはありません。

呼び出し元 ↓ / 呼び出し先 →relaxedcommittedsnapshotserializable
relaxed(外側の transaction なし)そのまま実行committed を開始snapshot を開始serializable を開始
committed外側に参加外側に参加コンパイルエラーコンパイルエラー
snapshot外側に参加外側に参加外側に参加コンパイルエラー
serializable外側に参加外側に参加外側に参加外側に参加

例えば snapshot の処理から relaxed の回復処理を呼ぶと、HP の変更も外側の snapshot に含まれます。外側が retry するなら、その回復も一緒にやり直します。逆に transaction のない relaxed から committed の回復処理を呼ぶと、その呼び出しで transaction を開始し、完了時に commit してから呼び出し元へ戻ります。

呼び出し先が外側より強い保証を要求する場合は、effect 行を通してコンパイル時に拒否します。途中に relaxed の呼び出しを挟んでも、この検査は変わりません。表の「外側に参加」では読み取りも外側に従い、snapshot 内から committed を呼んでも読み取りの基準は snapshot のままです。

呼び出しの途中に wait がある場合は、そこで区間を commit してから待機し、再開後を新しい transaction として続けます。この表は通常の呼び出しの規則で、trigger の inherit/独立実行のタイミングは別途 schedule に従います。

execution level は effect 行で伝わる

例えば、回復処理を relaxed で定義します。マクロが生成する呼び出し側の行には、操作の heal と実行レベルの relaxed が入ります。

relaxed の回復処理TAUTO
@effect!("heal", execution: relaxed) => replace fn heal
pub fn heal(
  arg: HealArg,
  healths: Query({ entity: Entity, health: &Health }),
): Unit ! { entity_not_found, update(Health) } {
  let target := healths.get(arg.entity)
  perform update(target.entity, Health {
    current: target.health.current + 1,
    maximum: target.health.maximum,
  })
}

// 生成される呼び出し口の型
// heal: (HealArg) -> Unit ! { heal, relaxed }
snapshot から relaxed を呼ぶTAUTO
@effect!("heal_snapshot", execution: snapshot)
  => replace fn heal_snapshot
pub fn heal_snapshot(
  arg: HealArg,
): Unit ! { heal, relaxed } {
  heal(arg)
}

// 呼び出し口の型
// heal_snapshot: (HealArg) -> Unit
//   ! { heal_snapshot, snapshot, heal, relaxed }
committed から snapshot を呼ぶとエラーTAUTO
@effect!("heal_committed", execution: committed)
  => replace fn heal_committed
pub fn heal_committed(
  arg: HealArg,
): Unit ! {
  heal_snapshot, snapshot, heal, relaxed
} {
  heal_snapshot(arg)
}
// エラー:committed の処理から
// snapshot を要求する処理は呼べない

heal_snapshot の中の heal は、外側の snapshot に参加します。一方、heal_committed の行には呼び出し先が要求する snapshot が現れるため、マクロが committed との不整合を診断できます。snapshot を行から消すと、今度は関数本体との不一致を Tauto の型検査が検出します。

wait は transaction の境界です。待つ前の区間を commit し、再開後は新しい transaction を開始します。再開後に競合しても、待つ前に確定した変更まで巻き戻しません。継続と retry の関係は次の節で説明します。

固定 tick

ゲーム内の時間は perform time()、現実に流れている時間は perform realtime() で取得します。ゲームの進行と描画のフレームレートを切り離して扱えます。

perform time()perform realtime()
返す時間実行先 namespace の現在 tick現実の時間
進み方シミュレーションの tick が進むと変わる。同じ tick 内では一定tick の進行とは独立して進む。同じ tick 内でも取得時点で変わる
用途空腹、行動の所要時間など、ゲームのルール描画のアニメーション、実時間での処理時間の計測
retry同じ tick なら同じ値。後の tick で再実行すると新しい tick の値取得し直した時点の時間。retry でも巻き戻らない
高速シミュレーションnamespace を速く進めた分だけ tick が進むシミュレーションを速くしても現実の時間の進み方は変わらない

例えば sandbox で 100 tick を実時間 1 秒で計算した場合、time() は 100 tick 進み、realtime() の差は約 1 秒です。ゲーム内で「10 tick 待つ」処理は perform wait(10) で書きます。

処理が遅れても tick は飛ばしません。連続して追いつく実行には上限を置き、描画と入力へ制御を返したあと、残りの tick を続けます。

ゲーム内 tick と現実時間 ゲーム内の 5 tick は等幅。現実側は処理の重さで幅が変わるが、tick 番号は飛ばない。 ゲーム内 現実 tick 1 tick 2 tick 3 tick 4 tick 5 1 2 3 4 5 追いつくための連続実行には上限を置き、残りは後のフレームで続ける。

wait は commit の境界

wait でそこまでを確定し、継続を保存します。競合した区間は、その入口からやり直します。

wait で区切られる transaction 区間 A を commit して 10 tick 待ち、区間 B を commit する。B が競合したら B の先頭から再開し、A は巻き戻さない。 区間 A スタミナを消費 確定 wait(10) 区間 B 木材を生む 確定 競合時は B の入口へ戻る
wait が捕捉する継続は ω です。ω は再開の権限であり、巻き戻しは transaction が行います。ω の継続が捕捉できない Affine な資源は、wait をまたげません。この保証は Tauto の検査に任せます。
規則内容
commitその区間の inherit trigger まで処理し、変更と、wait 後の継続と再開予定を一体として確定する。成功したら schedule 上の後続を実行可能にする。
retry失敗した区間は、直前の確定済み境界から、同じ継続でやり直す。commit 済みの区間と、それによって解放した後続は巻き戻さない。
relaxed操作ごとに確定し、区間全体の retry をしない。途中までの変更は残る。
乱数列の識別は tick、登録 ID、論理的な実行番号。スレッドの完了順や実時間には依存させない。retry では、やり直す区間の列を先頭から使う。commit 済みの区間は振り直さない。
競合優先は schedule と登録順。CPU 上で先に終わった方は勝たない。登録順は、ロードや実行が完了した順では決めない。
アクセス集合直接の query に加え、呼ぶ effect、middleware、inherit trigger、WorldState を含める。読み取りと書き込み、query の一致集合を変える操作も競合である。静的に絞れない部分は、最初は保守的に直列化する。
中断wait に後始末関数は付けない。中断は、保存した継続を再開しないことで表す。継続を検索・破棄する API はコンテンツに公開しない。

trigger のタイミング

execution の既定は inherit です。発火元の終了処理として、commit 前に同じ実行環境で走ります。実行モードを明示した trigger は、発火元の commit 成功後に、その指定で独立して始まります。発火元が失敗したら起動しません。inherit は非 inherit より前、という順序を engine が固定します。逆向きを schedule に書くと、指定側のエラーになります。順序は実際に発火する処理に適用し、未発火の trigger は待たせません。

inherit と独立 trigger 発火元、inherit trigger、commit、その後の独立 trigger の順。逆順の schedule 指定はエラー。 発火元の処理 inherit trigger commit 独立した trigger inherit を後に置く指定は、指定側のエラー

effect の展開

handler が Execute で入力と extractor を返すと、関数側が元の本体を実行します。Ret はその値で戻り、本体は実行しません。本体から呼ぶ effect は、通常の行規則で外側へ伝播します。

展開の骨子TAUTO
enum HealExecution {
  Execute(arg: HealArg, healths: HealthQuery),
  Ret(ret: Unit),
}

pub(handle) effect heal(arg: HealArg): HealExecution
  resume <=1

時間と State

規則内容
tickプロジェクトルートの Thirsty.eure で幅を決める。遅延時も番号を飛ばさない。
時刻perform time() は namespace の現在 tick、perform realtime() は現実の時間。ゲームのルールは tick を基準にする。
乱数perform rand()。列は論理的な実行単位ごと。やり直す区間は列の先頭から使う。
競合の順序schedule と登録順。CPU 上で先に終わった方は勝たない。
systemnamespace と登録 ID ごとに同時に一つ。wait で tick をまたいでも、その実行が完了するまで新規発火しない。引数は extractor のみ。
State(T)namespace・恒常 system の登録 ID・型 ID の組ごとに一つ。
WorldState(T)world 内で型 ID ごとに一つ。どの種別からでも使える。
get / setget は共有借用。未設定なら effect のない default を保存して返す。初期化も transaction に参加し、abort すれば破棄する。set は現在の値を差し替え、取得済みの借用は元の値を指し続ける。借用が生きている間、engine は古い値を保持する。
Timer / RealTimerどちらもコンテンツの component。経過 tick の履歴は engine が持たない。人物や行動ごとの時間は Timer、描画用の実時間は RealTimer。ロジックの判断は Timer と time() を使う。
実行コンテキストeffect で、登録 ID、種類、その回の論理的な実行 ID を取得できる。取得は実行権限の獲得にはならない。
分離レベルcommitted / snapshot / serializable。実行戦略とは別に、読み取りと競合検出の契約を定める。
Thirsty.eureEURE
@ simulation
tick-duration-ms = 50

@ defaults.schedule
phase: survival::primary::Update
StateTAUTO
let value := perform get()
perform set(value)
let time := perform time()
let rand := perform rand()

State の初期値は、未初期化のときに effect を持たない State::default() から得ます。hot reload でも同じ識別子の保存済みの値は維持し、default の編集は未初期化の状態にだけ反映します。同じ値型で別々の状態が必要なら、用途別の wrapper 型を定義します。探索用 namespace では State と WorldState も分岐します。

実行戦略は「どこまで並列に進めるか」、分離レベルは「どの状態を読み、どの競合を検出するか」です。retry では区間の乱数列を戻しますが、読み取りや分岐が変われば結果も変わります。time() は現在 tick なので、別の tick での再実行では時刻も変わります。

05 — 別の世界で試す

別の世界で試す

namespace は世界の実行先です。本番の primary と、差分を持つ sandbox を分けます。探索手法や評価関数は利用者が書きます。

本番から分けたシミュレーション

namespaceの ID は定義時に固定します。数個のnamespaceを、多数のエージェントが queue で順番に使います。割り当てはゲーム側の system が書きます。

同じ規則で先を進める

oneshot の中で run_ticks、run_system、run_schedule を呼べます。空腹も火も、本番に登録した処理が動きます。そのnamespaceの perform time() と perform rand() は、そのnamespaceの tick と乱数列です。

複数の仮説を並べる

一つの要求に複数のnamespaceを渡せます。基準は sync 時点の primary の確定版です。その後の変更はnamespaceごとの差分です。開始は各 queue に従い、namespaceのあいだで時刻を揃えません。指定したnamespaceが全部終わると、呼び出し元が再開します。要求開始時の sync に必要な間だけ、primary と対象のnamespaceを quiescent にします。その後は primary も進行します。対象以外のnamespaceは動き続けます。

進んでいるあいだに読む

評価の回収は、running 中の QueryAcross です。取得元は entity.namespace です。同じ EntityId でもnamespaceが違えば別の Entity です。tick はnamespaceごとにずれ得るので、比べたい時点は component に持たせます。

本番に書き戻さない

分岐で変えた component、State、WorldState、tick、乱数はその版のものです。primary が分岐の後に足したり消したりしても、分岐側の query の一致集合は変わりません。分岐で消した entity は、primary の新しい状態からは復活しません。

namespaceを空けて次に使う

要求が終わると、その要求の継続、起床、未 commit の変更を捨てます。primary の継続には触れません。次の要求は、そのときの primary の確定版へ sync してから始まります。queue が空のnamespaceには CPU を割り当てません。

セーブを分岐に持ち込まない

save、load、file_read は primary_only の行が要ります。その行を持つ処理を非 primary に置くと登録を拒否します。探索で扱う effect は handler で明示します。

それぞれの sync 時点から二つの仮説 sync 時点の primary を virtual1 と virtual2 が共有する。virtual1 は火の差分、virtual2 は火を足さない差分。QueryAcross は実行中の両方を読む。次の sync で差分は捨てる。 primary の確定版 virtual1 火を足した差分 virtual2 火を足さない差分 実行中は QueryAcross で両方の体力を読む 次の sync で差分を捨て、そのときの primary に張り直す

実時間で最大 10 秒、かつ最大 100 tick のように実行を制限します。先に到達した上限で要求を終了し、後から再開しません。上限到達は実行エラーではありません。待機中の継続は、quiescent な sync では分岐へ持ち込みません。

実行要求

virtual1 と virtual2 で、本番と同じ処理を数 tick 進めます。extractor は実行先のnamespaceが供給します。mode は要求ごとに明示し、その中の run_ticks、run_system、run_schedule へ引き継ぎます。途中では切り替えません。

探索側の指示TAUTO
perform run_namespaces(
  [virtual1, virtual2],
  simulate,
  Scheduled,
)

fn simulate(
  actors: Query({
    entity: Entity,
    actor: &Actor,
  }),
): Unit ! { run_ticks, run_system } {
  perform run_ticks(3)
  perform run_system(movement::registration)
}

namespace の状態

namespace は定義時に ID を固定した pool です。実行要求が queue にあるときだけ CPU を割り当てます。sync は CoW の変更を捨て、primary の commit 済み状態を新しい基準にします。待機中の継続は、quiescent であるため分岐へ持ち込みません。

一つの実行要求 queue から取り出し、primary と対象を quiescent にし、sync してから oneshot をその namespace で実行する。queue が空なら休止し、次があれば再び quiesce と sync を行う。 queue quiesce sync oneshot 次へ、または休止 空なら CPU を外す 他の namespace は動かし続けます。要求本体は、その要求が進める schedule には含めません。

query は、その namespace から見える一つの状態へ解決してから照合します。

namespace の CoW primary は最新版。virtual1 と virtual2 は同じ分岐時点の版を共有し、各自の変更だけを別に持つ。 primary 最新の確定版 sync 時点 分岐時点の共有版 virtual1 差分 virtual2 別の差分 削除した entity は、primary の新しい状態からは復活しない。
見えるもの解決
変更した値その namespace の値を使う
未変更の値分岐時点の版を使う
その namespace で削除した component と entityprimary へ戻して復活させない
primary の分岐後の追加と削除その namespace の query の一致集合を変えない
archetype、entity の存在、State、WorldState、tick、乱数版で分ける

要求が終わったら、その要求の中で残っている継続、起床予定、未 commit の変更を破棄します。commit 済みの状態は次の sync まで保持します。終わった namespace は QueryAcross の対象外です。破棄はゲーム上のキャンセルイベントを自動発火しません。primary と他の namespace の継続には触れません。時間または tick の上限到達も要求の終了として扱い、後から再開しません。VM の quantum は、wait でも transaction の commit でも論理 tick の進行でもありません。

namespace の契約

項目規則
poolID は定義時に固定する。
要求run_namespaces(一覧, oneshot, mode)。extractor は実行先で供給する。
modeSerial / Scheduled / Speculative を要求ごとに明示し、途中で切り替えない。
同期の範囲primary と対象だけを quiescent にする。他の namespace は動かし続ける。
観測oneshot の戻り値は trivial。比較は running 中の QueryAcross で行う。
配置省略時は [primary]。列挙と、primary 以外の全部を指定できる。後者の記法は未確定。sandbox で動かす処理は namespace を明示する。
primary_onlyeffect 行のマーカーであり、属性のフラグとしては書かない。行にある処理は primary の実行環境だけが扱う。マーカーを消して実操作を通すことは許さない。非 primary へ配置したら登録を拒否する。file_read、save、load を要求するのにマーカーがなければ、登録マクロが検査済みの行を見て診断する。
予算実時間と tick 数の上限で終了する。例:最大 10 秒、最大 100 tick。再開 API は設けない。
tick をまたぐ行現時点では wait、save、load、実行要求、namespace の進行操作。
primary だけTAUTO
fn autosave(path: FilePath): Unit ! { primary_only, save } {
  perform save(path)
}

06 — Hot reload とセーブ・ロード

Hot reload とセーブ・ロード

データの hot reload、型の migration、世界の save / load を分けて扱います。

hot reload

エンジンが読む Tauto と Eure はすべて hot reload の対象です。反映は package 単位です。コードの更新は best-effort で、実行中の継続は旧コードで完了してよく、安全に切り替えられる地点から新しいコードを使います。型の非互換変更を、稼働中の同じ version へ直接適用することはしません。

Update policy の指定単位

$world.update は、Eure の定義を編集したときに実行中の値をどう扱うかを指定します。field の値の更新、component 全体の追加・削除、entity 全体の削除は、それぞれの位置に書いた方針で判断します。省略時は keep_dirty です。

survival/alice.eureEURE
$variant: entity
id: alice
$world.update: keep_dirty

components {
  @ "survival::health"
  $world.update: keep_dirty

  current = 100
  current.$world.update: never

  maximum = 100
  maximum.$world.update: force

  @ "survival::activity"
  $world.update: keep_dirty
  $variant: Working
  remaining = 3
  remaining.$world.update: keep_dirty
}

現在の HP を残し、上限を調整する

current は生成時に 100 で初期化し、以後のファイル編集では上書きしません。maximum の定義を 120 に変えると、実行中の上限も 120 に変わります。

Health 自体を定義から削除した場合は、field の方針ではなく component に書いた keep_dirty を使います。alice の定義ごと削除した場合は、ルートの方針を使います。

force を指定しても、無関係なファイルを保存するたびに値を初期化しません。その値または更新方針が変更されたときに適用します。

keep_dirty の比較 最後に反映した定義値と現在値が同じなら新しい定義を反映する。違っていれば現在値を維持し、見送りのときに基準を新しい定義へ進めない。 前回の定義値 = 現在値 新しい定義を反映する 前回の定義値 ≠ 現在値 現在値を維持する 見送りでは、比較の基準を新しい定義へ進めません。同じ variant の中はフィールドごと、variant が変わるときは値全体です。
$world.update反映
force定義値で上書き、追加、削除、despawn する
never初期生成時だけ使い、以後の reload では変えない
keep_dirty既定。最後に反映した定義値から実行中に変わっていなければ反映する。変わっていれば維持する

keep_dirty の例

最後に反映した HP が 100、プレイ中に減った現在値が 60、新しい定義が 120 なら、keep_dirty は 60 を残します。現在値がまだ 100 なら 120 に更新します。判定は「一度でも変更されたか」ではなく、最後に反映した値と現在値が等しいかです。

component の追加・削除と entity の削除

定義の変更forceneverkeep_dirty
component を追加定義値を追加。実行中に既にあれば全体を置換既存 entity には追加しない。新規 entity の生成時だけ使うなければ追加。実行中に既に作られた値は維持
component を削除世界からも削除世界に残すcomponent 全体が反映時と同じなら削除。変わっていれば残す
entity の定義を削除despawn する世界に残すcomponent の構成と値が反映時と同じなら despawn。変わっていれば残す

追加は新しい定義、削除は削除前の定義に書かれた方針を使います。判定するのは template を合成した後の定義です。alice 側の上書きを消しても、親 template に同じ component があれば、削除ではなく値の変更になります。

enum の variant が変わる場合

Working から Idle へ切り替えるときは、enum 全体の方針で置き換えます。現在値だけが別の variant になっている場合も同様です。異なる variant の field は混ぜません。旧定義・新定義・現在値が同じ variant なら、field ごとの方針で更新します。

template の継承は component 全体の上書きです。ここで説明している field ごとの更新は、その合成結果と実行中の世界を同期する処理です。更新後の component を組み立てて検査し、原子的に反映します。実際に追加・更新・削除したものだけが lifecycle trigger の対象になります。

維持はエラーにしません。型不一致などの不正は package を拒否します。定義から消えても維持した component や entity は、以後の定義同期の対象から外し、削除を毎回再試行しません。判定はファイルパスではなく登録 ID です。template を消しても、そこから生成済みの entity をまとめて despawn しません。schedule は実行途中の並びを差し替えず、次の実行境界から使います。tick 番号は維持します。固定 tick 幅の変更も次の実行境界から反映します。現在の tick 番号、Timer の tick 値、wait の期限 tick は変えず、以後の tick の実時間間隔だけを変えます。

quiescent:実行途中の処理がなくなった状態

save や load のとき、木を切っている途中のような処理が残ったままだと、世界のデータだけを保存・交換しても、その続きとの整合が取れません。そこで、対象の世界で実行中の処理を終わらせ、確定済みのデータだけになった境界を作ります。この状態を quiescent と呼びます。

save を要求してから、通常実行に戻るまで
  1. 1. save を要求

    perform save(path)
    呼び出し元は保存の完了を待つ。

  2. 2. 進行中の処理を終える

    wait を行に持つ system の新規発火を止める。tick は進め、既存の処理を続きから実行する。

  3. 3. quiescent

    待機中・実行中のゲーム処理がなくなり、変更が確定した境界で世界を保存する。

  4. 4. 通常実行へ戻る

    新規発火の制限を解除し、save を呼んだ処理の続きを実行する。

例:木を切る処理が wait 中に保存を要求 → tick を進めて伐採を完了 → 伐採後の世界を保存。

「処理を止めて凍結する」のではなく、まず処理を終えられるところまで進めます。そのため、保存されるのは save を要求した瞬間ではなく、待機が終わったあとの世界です。終わらない処理があれば、その完了を待つ保存も完了しません。

どんなときに使うか

きっかけquiescent で行うこと
perform save(path)primary の確定済みデータを保存する。ゲーム処理の継続はファイルに保存しない。
perform load(path)global schedule の終了と次の開始の間で、現在の世界をロードしたデータへ置き換える。
型変更に伴う migration起動時・ロード時・hot reload 時に、通常の schedule の外で古いデータを移行する。必要な migration が足りなければ静止したまま編集を待つ。
namespace の実行要求の開始primary と対象 namespace を quiescent にして sync する。sync 後は両方とも実行を進める。対象以外の namespace は動き続ける。

save・load などの完了後に呼び出し元へ戻るため、エンジン自身が預かる継続は残します。quiescent に入るときに完了を待つのは、対象の世界で進行中のゲーム処理です。

version と migration

検出マクロ展開と名前解決のあとの正規化した定義が、記録済みの最新と違う。
採番その型 ID の version を一つ進める。履歴は一本の連番。
静止quiescent で migration だけを走らせる。通常の trigger は起動しない。
再開旧 version が残らず成功したら、新しい世代を公開する。不足なら編集を待つ
migrationTAUTO
@migration!("survival::health", 1)
  => def migrate_health_v1::registration

二つの保存

World のセーブは、値とその version を持ちます。最新の定義と採番履歴は、World とは別の Eure に置き、ロードでは巻き戻りません。

import path から外した tote のデータは、セーブの中に残し、世界へは展開しません。再び import path に入り、型検査が通れば復元対象に戻ります。

採番扱い
番号を進めるfield や variant の追加、削除、改名、型の変更。field と variant の順序は有意
番号を進めない空白、コメント、span、import の別名、関数本体だけの変更
同一性実体は (型 ID, version)。同じ公開 ID の異なる version は別の component。fingerprint は比較の補助であり、型の同一性の証明にはしない
migrationキーは (data id, 移行元 version)。同じキーへの複数登録はエラー。順序木はなく、古い version から直列に進む。移行先は同じ型の次番号に限らない
失敗コンパイル失敗、実行失敗、旧データの残存、連鎖の循環があれば、移行前の world を維持する。失敗途中の状態からは再試行しない

Mod を外したセーブを読み込む

tote を import path から外すと、そのコードは実行されず、所属する component や State は世界へ展開されません。データは保存時の型定義・version と結び付けたまま保留し、次のセーブにも残します。

tote を再び有効にすると、保留データを復元対象に戻し、必要な migration を適用します。その間に別の tote を更新しても、保留データを勝手に新しい型として扱いません。既に削除された entity は、保留 component があるだけでは復活しません。

save、load、migration

保存するのは primary だけです。sandbox の状態や実行途中の継続はセーブに含めません。

quiescent

save、load、migration は、進行中のゲーム処理を終えてから実行します。quiescent に移る流れを参照してください。

save / loadTAUTO
perform save(path)
perform load(path)

hot reload の値

  • force は定義値で上書き、追加、削除する。
  • never は初期生成のときだけ使う。
  • keep_dirty が既定。実行中に汚れた値は残す。
  • variant が変わるときは、値全体で判断する。
操作規則
savewait の継続がすべて終わるまで tick を進め、その境界の世界を書く。save 自身の継続はファイルに含めない。
loadglobal schedule の終わりと次の始まりのあいだで世界の中身を置き換え、呼び出し元を再開する。
同時実行save または load の途中で、別の save / load を perform すると実行エラー。
migration@migration!(data id, 移行元 version)。同じキーは一つ。順序木はなく、古い version から直列に進める。
失敗移行前の世界を維持し、停止したまま hot reload を受け付ける。通常 trigger は移行中に起動せず、イベントも持ち越さない。
無効な tote無効化は import path から外すこと。データはセーブに残し、世界へは出さない。

07 — Tauto とエンジンの役割

Tauto とエンジンの役割

コンテンツの書き味を、コンパイラ・VM・ECS がどのように支えるかを整理します。

三つの役割

compiler、実行器、Thirsty compiler が検査と NIR を出し、実行器が effect と継続を動かし、Thirsty が世界の状態を扱う。依存は Thirsty から Tauto へ向かう。 Compiler / CLI / LSP 型・所有権・effect の検査 増分コンパイル、診断、NIR 正規化した型定義 実行器 perform / handle 継続と再開量 既存 VM と新規 VM を比較 Thirsty entity、query、schedule tick、namespace、save version と migration 整合した一世代の成果物を、一つの世界へ登録する

代数的 effect をどこで使うか

Thirsty では、世界への操作を effect として要求し、handler が実行先や実行方法を決めます。effect 行は「この関数を呼ぶと、何が起こり得るか」を表します。補助関数や Mod を何段挟んでも、未処理の要求は呼び出し元の行へ伝わります。

例えば「回復 → 演出 → ファイル読み取り」という呼び出しなら、回復の入口にも primary_only の要求が現れます。「移動 → ドアを開く → wait」なら、移動も tick をまたぎ得ると分かります。作者が別の登録リストへ転記する必要はありません。

機能effect・handler・継続の役割静的な行の追跡で保証すること追跡しなければ何が困るか
execution level の合成呼び出し先を外側の transaction に参加させる。外側がなければ必要な transaction を開始する。committed の処理から snapshot や serializable を要求する経路を、実行前に拒否する。直接の呼び出しだけを調べても、補助関数や Mod の奥にある強い要求を見落とす。実行時に拒否するか、要求する保証を破ることになる。
primary_onlysave・load・外部 I/O などを primary の実行環境で扱う。その要求へ到達し得る system・trigger・effect を sandbox に配置できないようにする。マーカーの除去は engine 内部に限定する。入口だけ sandbox 用に登録しても、深い呼び出し先から外部へ作用できてしまう。別途、実行時の権限検査が必要になる。
Scheduled の並列実行update・insert・remove などの書き込みを、実行先の世界と transaction へ適用する。Query の読み取り情報と mutation の行から、呼び出し先を含めたアクセスの可能性を把握する。作者が書いたアクセス宣言と実際の処理がずれ得る。安全に動かすには広く直列化するか、実行時に競合を扱う必要がある。
wait と quiescentwait は処理の続きを保存し、指定 tick で再開する。quiesce 中は既存の処理を終える。wait を呼び得る入口を判別し、その新規発火を止められる。見た目は短い関数でも、深い呼び出し先が wait すると新しい待機が増える。入口の手書き指定だけでは、待機を増やさない保証ができない。
transaction の retrywait で保存した継続から未確定の区間を再実行し、MVCC 側で未確定の変更を破棄する。行で操作の要求を追跡し、加えて Tauto の ω と所有権の検査で、その継続を複数回使ってよいことを確かめる。普通の callback を保存するだけでは、一度しか使えない資源を再実行で使い回す危険がある。行だけでも不十分で、再開量と所有権の保証が必要になる。
middleware と行動への介入handler が行動を続けるか、Ret で本体を省略するかを選ぶ。middleware は前後処理や戻り値の変更を行う。内側の関数が要求する操作も型に現れ、対応する handler で扱える。継続の再開回数も型で制限する。callback の登録だけでは、さらに内側の行動まで介入可能とは限らない。全呼び出しで共通の規約を守らせる別の仕組みが要る。
namespace で同じ処理を動かす世界への変更、time、rand、State などを、実行先 namespace の環境で扱う。処理が要求する操作を把握し、sandbox で扱えない要求は登録時に検出できる。関数の奥で primary のグローバル状態や時計を直接使うと、分岐した世界の処理にならない。すべての依存を別途渡して検査する必要がある。
trigger の出来事の集約成功した component 変更などを記録し、system の終了時に trigger へ渡す。行から「この system は Added(A) の原因になり得る」と分かり、必要な終了処理を組み込める。宣言と実際の mutation がずれると、通知漏れが起きる。静的に追跡しない方式では、実行時の全操作を捕捉するなどの仕組みが必要になる。

何が代数的 effect による保証なのか

個々の機能は、別の設計でも実現できます。Thirsty が必要としているのは、普通の関数として処理を組み合わせても、必要な操作・実行条件・再開の制約が失われないことです。型付きの effect 行と handler によって、その契約を言語の検査へつなげます。

行は「起こり得ること」を表すので、その操作が実際に起きたかは実行時に判断します。transaction の競合検出は MVCC、処理の順序は scheduler、継続の複製可能性は再開量と所有権検査が担当します。これらを effect 行だけで保証するわけではありません。

VM と JIT

JIT は実行時にコードを機械語へ変換する仕組みです。Thirsty では、VM が effect・継続・実行予算を管理し、JIT が対応する計算処理を高速化する構成にします。execution mode は処理の並べ方、JIT は個々の処理の実行方法なので、別々に扱えます。

まずは計算部分から

NIR を入力に、数値計算などの対応範囲を機械語へ変換します。effect や継続を含む処理は VM で動かします。

更新と実行予算を守る

生成した機械語もコードの世代に結び付けます。hot reload 後も古い継続が参照するコードは保持し、新しい呼び出しから新世代へ切り替えます。予算の検査や VM への復帰を保証できない処理は、VM 側で実行します。

Tauto の既存実装では、Rust VM に Cranelift を使う JIT があり、effect のない整数・Bool・Unit の関数などに対応しています。Tauto 製 VM にはまだ JIT がありません。この既存の経路を再利用できるか確認しながら、Thirsty の実行器に組み込みます。

反映は package 単位

01 編集tote と Eure を保存する。LSP は compiler と同じ検査を使う。
02 検査依存する範囲を再検査し、一世代の成果物と診断を得る。
03 登録候補の registry で重複、型、DAG、effect 行を確認する。
04 公開成功したらまとめて反映する。失敗時は旧世代を維持

識別子と登録

ものID書き場所
component / effect / system / trigger / middlewaretote::ローカルID宣言のそばの属性マクロ
entity / templateファイル名ではなく idEure。$variant で区別
phasetote::schedule::phaseschedule の phases。記載順が実行順
論理的な実行登録 ID とは別system は登録 ID ごとに singleton。trigger と effect は発火ごと

同じ登録集合で ID が重なれば拒否します。Tauto 内部の数値 ID は、セーブの永続 ID にしません。

言語とエンジンの境界

項目決まっていること
依存Thirsty → Tauto。component、登録 ID、schedule、version、namespace の意味は Tauto に入れない。
意味論正本は型検査と effect。NIR は compiler と実行器の交換形式。
入力有効な tote 群を一つの構成として渡す。受け取るのは、増分計算の結果として整合した一世代。
packagetote。標準コンテンツと Mod の読み込み経路は同じ。
登録候補の registry で重複、型、DAG、effect 行を検査してから一括公開する。不正な更新は診断を返し、公開済みの世代を維持する。
effectperform、handle、継続、再開量は Tauto のものを使う。ゲーム上の出来事を、独自のコールバックで代用しない。

エンジン外の処理

利用者が書くengine が渡すもの
評価関数、重み、行動候補の生成、ビームサーチ。補助 tote も付属させない世界の分岐、分岐先での通常コードの実行、破棄、CoW
信念。観測できた component だけを同期し、持たない component を不明とみなす規則。不明は component の不在で表す仮想時間、実行予算、登録情報の取得
手や対象の占有、割り込み、後始末。engine が保証するのは、実行時の読み書きを壊さない短い排他と、schedule の順序探索で処理する effect は handler で明示する。未対応の外部操作を primary へ流さない。任意の外部 I/O を自動で仮想化することはしない
キャンセル。継続を再開しないことと、コンテンツの出来事で表す保存済み継続の検索と破棄はコンテンツに公開しない

08 — 実装へ向けて

実装へ向けて

まず小さな世界で、型検査から実行・更新までをつなぎます。

最初の縦断

最初の到達点は、一つの tote と一つの primary namespace で次が動くことです。

順到達点
1Tauto で component と、mutation を行う処理を定義する。
2Eure の template と entity を読み、合成結果を型検査して世界へ置く。
3compiler の一世代の成果物を package として登録する。不正な更新は拒否し、旧世代を維持する。
4mutation が trigger の出来事になり、inherit の trigger が commit 前に変更後の状態を読む。
5固定 tick の schedule が、既定 phase の恒常 system を順序どおり実行する。
6wait が区間を commit し、期限の tick で同じ継続を再開する。競合時は未 commit の区間だけを、保存した継続からやり直す。

この縦断に、namespace、QueryAcross、save / load、自動採番と migration を順に載せます。世界を分岐できる版管理と、継続を保持できる実行モデルは、最初の状態表現から入れておきます。評価関数と探索は、namespace の実行要求が動いてから利用者コードで書きます。