create-eigen-game 0.14.2 → 0.15.0

package/templates/app-overlay/lib/game/v1/local_rules.dart.template

@@ -0,0 +1,115 @@
+import 'package:eigen_flutter/eigen_flutter.dart';
+
+import '../generated/payloads.dart';
+
+/// The offline half of version 1: the same four hooks the Worker owns,
+/// transcribed so the game can be played on the device with no network.
+///
+/// Entirely optional. Delete this file and the `local` override in
+/// `rules.dart` and the game is unchanged, minus on-device play. What it buys
+/// is a match a player can start on a train: the device commits every move
+/// through these hooks, and the server replays the whole log through the
+/// TypeScript unit when the device is next online, which is why the two must
+/// agree move for move. The shared fixtures under `test/game/fixtures/` are
+/// what keeps them agreeing.
+///
+/// Read it beside `server/src/module/v1.ts`; the hook and parameter names are
+/// deliberately identical.
+class ExampleGameLocalRulesV1 extends ExampleGameV1LocalRulesBase {
+  const ExampleGameLocalRulesV1();
+
+  @override
+  Envelope<ExampleGameV1State> initialState({
+    required ExampleGameV1Config config,
+    required Rng rng,
+    required int playerCount,
+  }) => Envelope(
+    state: ExampleGameV1State(count: 0),
+    pendingPlayers: const [0],
+  );
+
+  @override
+  Envelope<ExampleGameV1State> applyAction({
+    required ExampleGameV1State state,
+    required List<int> pending,
+    required ExampleGameV1Action data,
+    required int playerIndex,
+    required Rng rng,
+    required ExampleGameV1Config config,
+  }) {
+    final count = state.count + data.amount;
+    final finished = count >= config.target;
+    return Envelope(
+      state: ExampleGameV1State(count: count),
+      pendingPlayers: finished ? const [] : [1 - playerIndex],
+      outcome: finished ? _outcome(playerIndex) : null,
+    );
+  }
+
+  @override
+  Envelope<ExampleGameV1State> applyLifecycle({
+    required ExampleGameV1State state,
+    required List<int> pending,
+    required LifecycleType type,
+    required LifecycleAction data,
+    required Rng rng,
+    required ExampleGameV1Config config,
+  }) {
+    final loser = type == LifecycleType.timeout
+        ? (pending.isEmpty ? 0 : pending.first)
+        : data.playerIndex!;
+    return Envelope(
+      state: state,
+      pendingPlayers: const [],
+      outcome: _outcome(1 - loser),
+    );
+  }
+
+  @override
+  ObservationSlice<ExampleGameV1Observation> computeObservation({
+    required ExampleGameV1State state,
+    required List<int> pending,
+    required int? playerIndex,
+    required int participantCount,
+    required TransitionCause<ExampleGameV1Action> cause,
+    required bool isReplay,
+    required ExampleGameV1Config config,
+  }) => ObservationSlice(
+    data: ExampleGameV1Observation(count: state.count),
+    pendingPlayers: pending,
+  );
+
+  /// The brains this build can run, keyed by the bot registry's `username`.
+  ///
+  /// An operator registers a row with this username and type `local`, and it
+  /// becomes an opponent in the solo picker's untimed mode. A username that
+  /// also has a TypeScript `botActions` entry is one bot playable both on the
+  /// device and on the server.
+  @override
+  Map<
+    String,
+    LocalBotAction<
+      ExampleGameV1Action,
+      ExampleGameV1Observation,
+      ExampleGameV1Config
+    >
+  >
+  get botActions => {
+    'example-bot': (args) => ExampleGameV1Action(amount: 1),
+  };
+}
+
+List<Outcome> _outcome(int winner) => [
+  Outcome(
+    playerIndex: winner,
+    result: OutcomeResultEnum.win,
+    placement: 1,
+    teamIndex: winner,
+  ),
+  Outcome(
+    playerIndex: 1 - winner,
+    result: OutcomeResultEnum.loss,
+    placement: 2,
+    teamIndex: 1 - winner,
+  ),
+];

package/templates/app-overlay/lib/game/v1/rules.dart.template

@@ -2,6 +2,7 @@ import 'package:eigen_flutter/eigen_flutter.dart';
 import 'package:flutter/material.dart';
 
 import '../generated/payloads.dart';
+import 'local_rules.dart';
 
 class ExampleGameRulesV1 extends ExampleGameV1RulesBase {
   const ExampleGameRulesV1();
@@ -40,6 +41,11 @@ class ExampleGameRulesV1 extends ExampleGameV1RulesBase {
 
   @override
   bool botSeatable(BotSeatableArgs args) => true;
+
+  /// Offline play, opt-in. Remove this override and `local_rules.dart` if the
+  /// game should only ever be played against the server.
+  @override
+  ExampleGameLocalRulesV1 get local => const ExampleGameLocalRulesV1();
 }
 
 class _CounterBoard extends StatelessWidget {

package/templates/app-overlay/web/README.md

@@ -0,0 +1,11 @@
+# Web assets
+
+`sqlite3.wasm` and `drift_worker.js` are drift's web runtime, taken verbatim
+from the [drift 2.35.0
+release](https://github.com/simolus3/drift/releases/tag/drift-2.35.0). They are
+served from the app's own origin because that is where `LocalDatabase` looks for
+them, and they are what gives a browser the storage offline play needs.
+
+Replace both together whenever the `drift` constraint in `eigen_flutter`'s
+pubspec moves, and take them from the matching release: the worker and the
+module are one pair.