Wortpuzzle mit Flutter erstellen

1. Hinweis

Stellen Sie sich vor, Sie werden gefragt, ob es möglich ist, das weltweit größte Kreuzworträtsel zu lösen. Sie erinnern sich an einige KI-Techniken, die Sie in der Schule erlernt haben, und fragen sich, ob Sie mit Flutter die algorithmischen Optionen für Lösungen für rechenintensive Probleme untersuchen können.

In diesem Codelab machen Sie genau das. Am Ende bauen Sie ein Tool, mit dem Sie Algorithmen zum Erstellen von Wortraster-Rätseln einsetzen können. Es gibt viele verschiedene Definitionen dafür, was ein gültiges Kreuzworträtsel ist, und die Techniken helfen dir, Rätsel zu erstellen, die deiner Definition entsprechen.

Mit diesem Tool als Basis stellst du dann ein Kreuzworträtsel, bei dem der Nutzer mithilfe des Kreuzworträtsel-Generators ein Rätsel erarbeitet, das er lösen kann. Dieses Rätsel kann unter Android, iOS, Windows, macOS und Linux verwendet werden. Auf Android-Geräten:

Vorbereitung

• Abschluss des Codelabs Ihre erste Flutter-App

Lerninhalte

• Hier erfahren Sie, wie Sie Isolierungen verwenden, um rechenintensive Aufgaben zu erledigen, ohne die Renderingschleife von Flutter zu beeinträchtigen. Dazu kombinieren Sie die compute-Funktion von Flutter und die select-Neuerstellung des Filters für die Wert-Caching-Funktion von Riverpod.
• Erfahren Sie, wie Sie unveränderliche Datenstrukturen mit built_value und built_collection nutzen, um die suchbasierten Methoden der Good Old Fashioned AI (GOFAI) wie die Tiefensuche und Backtracking einfach zu implementieren.
• Hier erfahren Sie, wie Sie die Funktionen des two_dimensional_scrollables-Pakets nutzen, um Rasterdaten schnell und intuitiv darzustellen.

Voraussetzungen

• Das Flutter SDK.
• Visual Studio Code (VS Code) mit den Flutter- und Dart-Plug-ins.
• Compiler-Software für dein gewähltes Entwicklungsziel. Dieses Codelab funktioniert für alle Desktop-Plattformen, Android und iOS. Sie benötigen VS Code für Windows, Xcode für macOS oder iOS und Android Studio für Android.

2. Projekt erstellen

Erstes Flutter-Projekt erstellen

1. Starten Sie VS Code.
2. Geben Sie in der Befehlszeile flutter new ein und wählen Sie dann im Menü Flutter: New Project aus.

3. Wählen Sie Leere Anwendung und dann ein Verzeichnis aus, in dem Ihr Projekt erstellt werden soll. Dies sollte ein beliebiges Verzeichnis sein, für das keine erhöhten Berechtigungen erforderlich sind oder das ein Leerzeichen im Pfad hat. Beispiele hierfür sind Ihr Basisverzeichnis oder C:\src\.

4. Geben Sie dem Projekt den Namen generate_crossword. Für den Rest dieses Codelabs wird vorausgesetzt, dass Sie der App den Namen generate_crossword gegeben haben.

Flutter erstellt nun Ihren Projektordner und öffnet ihn in VS Code. Sie überschreiben nun den Inhalt von zwei Dateien mit einem einfachen Gerüst der Anwendung.

Ursprüngliche App kopieren und einfügen

1. Klicken Sie im linken Bereich von VS Code auf Explorer und öffnen Sie die Datei pubspec.yaml.

2. Ersetzen Sie den Inhalt dieser Datei durch Folgendes:

pubspec.yaml

name: generate_crossword
description: "A new Flutter project."
publish_to: 'none'
version: 0.1.0

environment:
  sdk: '>=3.3.3 <4.0.0'

dependencies:
  built_collection: ^5.1.1
  built_value: ^8.9.2
  characters: ^1.3.0
  flutter:
    sdk: flutter
  flutter_riverpod: ^2.5.1
  intl: ^0.19.0
  riverpod: ^2.5.1
  riverpod_annotation: ^2.3.5
  two_dimensional_scrollables: ^0.2.0

dev_dependencies:
  flutter_test:
    sdk: flutter
  flutter_lints: ^3.0.0
  build_runner: ^2.4.9
  built_value_generator: ^8.9.2
  custom_lint: ^0.6.4
  riverpod_generator: ^2.4.0
  riverpod_lint: ^2.3.10

flutter:
  uses-material-design: true

Die Datei pubspec.yaml gibt grundlegende Informationen zu Ihrer Anwendung an, z. B. die aktuelle Version und die Abhängigkeiten. Sie sehen eine Sammlung von Abhängigkeiten, die nicht Teil einer normalen leeren Flutter-Anwendung sind. In den nächsten Schritten profitierst du von all diesen Paketen.

3. Öffnen Sie die Datei main.dart im Verzeichnis lib/.

4. Ersetzen Sie den Inhalt dieser Datei durch Folgendes:

lib/main.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

void main() {
  runApp(
    ProviderScope(
      child: MaterialApp(
        title: 'Crossword Builder',
        debugShowCheckedModeBanner: false,
        theme: ThemeData(
          useMaterial3: true,
          colorSchemeSeed: Colors.blueGrey,
          brightness: Brightness.light,
        ),
        home: Scaffold(
          body: Center(
            child: Text(
              'Hello, World!',
              style: TextStyle(fontSize: 24),
            ),
          ),
        ),
      ),
    ),
  );
}

5. Führen Sie diesen Code aus, um zu prüfen, ob alles funktioniert. Es sollte überall ein neues Fenster mit der obligatorischen Startformulierung für jedes neue Projekt angezeigt werden. Ein ProviderScope gibt an, dass diese App riverpod für die Statusverwaltung verwendet.

Hinweis: Der Effekt für die Inhaltsansicht unter macOS in Originalgröße wurde erreicht, indem die XML-Datei macos/Runner/Base.lproj/MainMenu.xib durch Hinzufügen der Attribute titlebarAppearsTransparent="YES" und titleVisibility="hidden" zum XML-Knoten //document/objects/window und fullSizeContentView="YES" zum XML-Knoten //document/objects/window/windowStyleMask hinzugefügt wurde. Weitere Informationen dazu, wie Sie Ihre Flutter-Apps unter macOS optimieren können, finden Sie in den Flutter-Paketen macos_window_utils und macos_ui.

3. Wörter hinzufügen

Bausteine für ein Kreuzworträtsel

Ein Kreuzworträtsel ist im Grunde eine Liste von Wörtern. Die Wörter sind in einem Raster angeordnet, einige quer, andere nach unten, sodass die Wörter ineinandergreifen. Die Lösung eines Wortes gibt Hinweise auf die Wörter, die mit dem ersten Wort kreuzen. Der erste Baustein muss also eine Liste von Wörtern sein.

Eine gute Quelle für diese Begriffe ist Peter Norvigs Natural Language Corpus Data-Seite. Die SOWPODS-Liste mit ihren 267.750 Wörtern ist ein nützlicher Ausgangspunkt.

In diesem Schritt laden Sie eine Liste mit Wörtern herunter, fügen sie Ihrer Flutter-App als Asset hinzu und organisieren einen Riverpod-Anbieter, der die Liste beim Start in die App lädt.

Führen Sie zunächst die folgenden Schritte aus:

1. Ändere die Datei pubspec.yaml deines Projekts so, dass die folgende Asset-Deklaration für die ausgewählte Wortliste hinzugefügt wird. In diesem Eintrag wird nur die Flatter-Stanza der Konfiguration Ihrer App angezeigt, da der Rest gleich geblieben ist.

pubspec.yaml

flutter:
  uses-material-design: true
  assets:                                       // Add this line
    - assets/words.txt                          // And this one.

Ihr Editor wird diese letzte Zeile wahrscheinlich mit einer Warnung hervorheben, da Sie diese Datei noch nicht erstellt haben.

2. Erstellen Sie in Ihrem Browser und Editor ein assets-Verzeichnis auf der obersten Ebene Ihres Projekts und erstellen Sie darin eine words.txt-Datei mit einer der oben verlinkten Wortlisten.

Dieser Code wurde auf der Basis der oben erwähnten SOWPODS-Liste entwickelt, sollte aber mit jeder Wortliste funktionieren, die nur aus den Zeichen A bis Z besteht. Die Erweiterung dieser Codebasis, um mit verschiedenen Zeichensätzen zu arbeiten, bleibt dem Leser als Übung überlassen.

Wörter laden

So schreiben Sie den Code für das Laden der Wortliste beim Start der App:

1. Erstellen Sie im Verzeichnis lib eine Datei providers.dart.
2. Fügen Sie der Datei Folgendes hinzu.

lib/providers.dart

import 'dart:convert';

import 'package:built_collection/built_collection.dart';
import 'package:flutter/services.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'providers.g.dart';

/// A provider for the wordlist to use when generating the crossword.
@riverpod
Future<BuiltSet<String>> wordList(WordListRef ref) async {
  // This codebase requires that all words consist of lowercase characters
  // in the range 'a'-'z'. Words containing uppercase letters will be
  // lowercased, and words containing runes outside this range will
  // be removed.

  final re = RegExp(r'^[a-z]+$');
  final words = await rootBundle.loadString('assets/words.txt');
  return const LineSplitter().convert(words).toBuiltSet().rebuild((b) => b
    ..map((word) => word.toLowerCase().trim())
    ..where((word) => word.length > 2)
    ..where((word) => re.hasMatch(word)));
}

Dies ist Ihr erster Riverpod-Anbieter für diese Codebasis. Sie werden feststellen, dass es mehrere Bereiche gibt, über die sich Ihr Editor entweder als nicht definierte Klasse oder als nicht generiertes Ziel beschwert. In diesem Projekt wird Codegenerierung für mehrere Abhängigkeiten verwendet, einschließlich Riverpod. Daher sind die nicht definierten Klassenfehler zu erwarten.

3. Führen Sie den folgenden Befehl aus, um mit der Codegenerierung zu beginnen:

$ dart run build_runner watch -d
[INFO] Generating build script completed, took 174ms
[INFO] Setting up file watchers completed, took 5ms
[INFO] Waiting for all file watchers to be ready completed, took 202ms
[INFO] Reading cached asset graph completed, took 65ms
[INFO] Checking for updates since last build completed, took 680ms
[INFO] Running build completed, took 2.3s
[INFO] Caching finalized dependency graph completed, took 42ms
[INFO] Succeeded after 2.3s with 122 outputs (243 actions)

Es wird weiterhin im Hintergrund ausgeführt und aktualisiert generierte Dateien, während Sie Änderungen am Projekt vornehmen. Sobald dieser Befehl den Code in providers.g.dart generiert hat, sollte Ihr Editor mit dem Code zufrieden sein, den Sie oben zu providers.dart hinzugefügt haben.

In Riverpod werden Anbieter wie die oben definierte wordList-Funktion in der Regel verzögert instanziiert. Für diese App muss die Wortliste jedoch eifrig geladen werden. Die Riverpod-Dokumentation enthält einen Vorschlag für den folgenden Ansatz für den Umgang mit Anbietern, die sofort geladen werden müssen. Sie werden dies jetzt implementieren.

4. Erstellen Sie eine crossword_generator_app.dart-Datei in einem lib/widgets-Verzeichnis.
5. Fügen Sie der Datei Folgendes hinzu.

lib/widgets/crossword_generator_app.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

import '../providers.dart';

class CrosswordGeneratorApp extends StatelessWidget {
  const CrosswordGeneratorApp({super.key});

  @override
  Widget build(BuildContext context) {
    return _EagerInitialization(
      child: Scaffold(
        appBar: AppBar(
          titleTextStyle: TextStyle(
            color: Theme.of(context).colorScheme.primary,
            fontSize: 16,
            fontWeight: FontWeight.bold,
          ),
          title: Text('Crossword Generator'),
        ),
        body: SafeArea(
          child: Consumer(
            builder: (context, ref, _) {
              final wordListAsync = ref.watch(wordListProvider);
              return wordListAsync.when(
                data: (wordList) => ListView.builder(
                  itemCount: wordList.length,
                  itemBuilder: (context, index) {
                    return ListTile(
                      title: Text(wordList.elementAt(index)),
                    );
                  },
                ),
                error: (error, stackTrace) => Center(
                  child: Text('$error'),
                ),
                loading: () => Center(
                  child: CircularProgressIndicator(),
                ),
              );
            },
          ),
        ),
      ),
    );
  }
}

class _EagerInitialization extends ConsumerWidget {
  const _EagerInitialization({required this.child});
  final Widget child;

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    ref.watch(wordListProvider);
    return child;
  }
}

Diese Datei ist aus zwei unterschiedlichen Richtungen interessant. Das erste ist das _EagerInitialization-Widget. Es hat die einzige Aufgabe, dass der oben erstellte wordList-Anbieter die Wortliste laden muss. Dieses Widget erreicht dieses Ziel, indem es den Anbieter über den Aufruf ref.watch() hört. Weitere Informationen zu dieser Technik finden Sie in der Riverpod-Dokumentation zur Eager-Initialisierung von Anbietern.

Der zweite interessante Punkt in dieser Datei ist, wie Riverpod asynchrone Inhalte verarbeitet. Wie Sie sich vielleicht erinnern, ist der Anbieter wordList als asynchrone Funktion definiert, da das Laden von Inhalten von der Festplatte langsam ist. Wenn Sie den Wortlistenanbieter in diesem Code beobachten, erhalten Sie eine AsyncValue<BuiltSet<String>>. Der AsyncValue-Teil dieses Typs ist ein Adapter zwischen der asynchronen Welt der Anbieter und der synchronen Welt der build-Methode des Widgets.

Die Methode when von AsyncValue verarbeitet die drei potenziellen Status, in denen sich der zukünftige Wert befinden könnte. Das Future wurde möglicherweise erfolgreich aufgelöst. In diesem Fall wird der data-Callback aufgerufen, oder er befindet sich möglicherweise in einem Fehlerstatus. In diesem Fall wird der error-Callback aufgerufen, oder schließlich wird er noch geladen. Die Rückgabetypen der drei Callbacks müssen kompatible Rückgabetypen haben, da die Rückgabe des aufgerufenen Callbacks von der when-Methode zurückgegeben wird. In diesem Fall wird das Ergebnis der when-Methode als body des Scaffold-Widgets angezeigt.

Apps mit nahezu unendlicher Liste erstellen

So integrierst du das CrosswordGeneratorApp-Widget in deine App:

1. Aktualisieren Sie die Datei lib/main.dart, indem Sie den folgenden Code hinzufügen:

lib/main.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

import 'widgets/crossword_generator_app.dart';             // Add this import

void main() {
  runApp(
    ProviderScope(
      child: MaterialApp(
        title: 'Crossword Builder',
        debugShowCheckedModeBanner: false,
        theme: ThemeData(
          useMaterial3: true,
          colorSchemeSeed: Colors.blueGrey,
          brightness: Brightness.light,
        ),
        home: CrosswordGeneratorApp(),                     // Remove what was here and replace
      ),
    ),
  );
}

2. Starte die App neu. Sie sollten eine scrollbare Liste sehen, die fast endlos weiterläuft.

4. Wörter in einem Raster darstellen

In diesem Schritt erstellen Sie mit den Paketen built_value und built_collection eine Datenstruktur zum Erstellen eines Kreuzworträtsels. Diese beiden Pakete ermöglichen die Konstruktion von Datenstrukturen als unveränderliche Werte, was sowohl für die einfache Übertragung von Daten zwischen Isolaten als auch für die Implementierung der Tiefensuche und des Backtrackings sehr nützlich ist.

Führen Sie zunächst die folgenden Schritte aus:

1. Erstellen Sie im Verzeichnis lib eine model.dart-Datei und fügen Sie ihr den folgenden Inhalt hinzu:

lib/model.dart

import 'package:built_collection/built_collection.dart';
import 'package:built_value/built_value.dart';
import 'package:built_value/serializer.dart';
import 'package:characters/characters.dart';

part 'model.g.dart';

/// A location in a crossword.
abstract class Location implements Built<Location, LocationBuilder> {
  static Serializer<Location> get serializer => _$locationSerializer;

  /// The horizontal part of the location. The location is 0 based.
  int get x;

  /// The vertical part of the location. The location is 0 based.
  int get y;

  /// Returns a new location that is one step to the left of this location.
  Location get left => rebuild((b) => b.x = x - 1);

  /// Returns a new location that is one step to the right of this location.
  Location get right => rebuild((b) => b.x = x + 1);

  /// Returns a new location that is one step up from this location.
  Location get up => rebuild((b) => b.y = y - 1);

  /// Returns a new location that is one step down from this location.
  Location get down => rebuild((b) => b.y = y + 1);

  /// Returns a new location that is [offset] steps to the left of this location.
  Location leftOffset(int offset) => rebuild((b) => b.x = x - offset);

  /// Returns a new location that is [offset] steps to the right of this location.
  Location rightOffset(int offset) => rebuild((b) => b.x = x + offset);

  /// Returns a new location that is [offset] steps up from this location.
  Location upOffset(int offset) => rebuild((b) => b.y = y - offset);

  /// Returns a new location that is [offset] steps down from this location.
  Location downOffset(int offset) => rebuild((b) => b.y = y + offset);

  /// Pretty print a location as a (x,y) coordinate.
  String prettyPrint() => '($x,$y)';

  /// Returns a new location built from [updates]. Both [x] and [y] are
  /// required to be non-null.
  factory Location([void Function(LocationBuilder)? updates]) = _$Location;
  Location._();

  /// Returns a location at the given coordinates.
  factory Location.at(int x, int y) {
    return Location((b) {
      b
        ..x = x
        ..y = y;
    });
  }
}

/// The direction of a word in a crossword.
enum Direction {
  across,
  down;

  @override
  String toString() => name;
}

/// A word in a crossword. This is a word at a location in a crossword, in either
/// the across or down direction.
abstract class CrosswordWord
    implements Built<CrosswordWord, CrosswordWordBuilder> {
  static Serializer<CrosswordWord> get serializer => _$crosswordWordSerializer;

  /// The word itself.
  String get word;

  /// The location of this word in the crossword.
  Location get location;

  /// The direction of this word in the crossword.
  Direction get direction;

  /// Compare two CrosswordWord by coordinates, x then y.
  static int locationComparator(CrosswordWord a, CrosswordWord b) {
    final compareRows = a.location.y.compareTo(b.location.y);
    final compareColumns = a.location.x.compareTo(b.location.x);
    return switch (compareColumns) { 0 => compareRows, _ => compareColumns };
  }

  /// Constructor for [CrosswordWord].
  factory CrosswordWord.word({
    required String word,
    required Location location,
    required Direction direction,
  }) {
    return CrosswordWord((b) => b
      ..word = word
      ..direction = direction
      ..location.replace(location));
  }

  /// Constructor for [CrosswordWord].
  /// Use [CrosswordWord.word] instead.
  factory CrosswordWord([void Function(CrosswordWordBuilder)? updates]) =
      _$CrosswordWord;
  CrosswordWord._();
}

/// A character in a crossword. This is a single character at a location in a
/// crossword. It may be part of an across word, a down word, both, but not
/// neither. The neither constraint is enforced elsewhere.
abstract class CrosswordCharacter
    implements Built<CrosswordCharacter, CrosswordCharacterBuilder> {
  static Serializer<CrosswordCharacter> get serializer =>
      _$crosswordCharacterSerializer;

  /// The character at this location.
  String get character;

  /// The across word that this character is a part of.
  CrosswordWord? get acrossWord;

  /// The down word that this character is a part of.
  CrosswordWord? get downWord;

  /// Constructor for [CrosswordCharacter].
  /// [acrossWord] and [downWord] are optional.
  factory CrosswordCharacter.character({
    required String character,
    CrosswordWord? acrossWord,
    CrosswordWord? downWord,
  }) {
    return CrosswordCharacter((b) {
      b.character = character;
      if (acrossWord != null) {
        b.acrossWord.replace(acrossWord);
      }
      if (downWord != null) {
        b.downWord.replace(downWord);
      }
    });
  }

  /// Constructor for [CrosswordCharacter].
  /// Use [CrosswordCharacter.character] instead.
  factory CrosswordCharacter(
          [void Function(CrosswordCharacterBuilder)? updates]) =
      _$CrosswordCharacter;
  CrosswordCharacter._();
}

/// A crossword puzzle. This is a grid of characters with words placed in it.
/// The puzzle constraint is in the English crossword puzzle tradition.
abstract class Crossword implements Built<Crossword, CrosswordBuilder> {
  /// Serializes and deserializes the [Crossword] class.
  static Serializer<Crossword> get serializer => _$crosswordSerializer;

  /// Width across the [Crossword] puzzle.
  int get width;

  /// Height down the [Crossword] puzzle.
  int get height;

  /// The words in the crossword.
  BuiltList<CrosswordWord> get words;

  /// The characters by location. Useful for displaying the crossword.
  BuiltMap<Location, CrosswordCharacter> get characters;

  /// Add a word to the crossword at the given location and direction.
  Crossword addWord({
    required Location location,
    required String word,
    required Direction direction,
  }) {
    return rebuild(
      (b) => b
        ..words.add(
          CrosswordWord.word(
            word: word,
            direction: direction,
            location: location,
          ),
        ),
    );
  }

  /// As a finalize step, fill in the characters map.
  @BuiltValueHook(finalizeBuilder: true)
  static void _fillCharacters(CrosswordBuilder b) {
    b.characters.clear();

    for (final word in b.words.build()) {
      for (final (idx, character) in word.word.characters.indexed) {
        switch (word.direction) {
          case Direction.across:
            b.characters.updateValue(
              word.location.rightOffset(idx),
              (b) => b.rebuild((bInner) => bInner.acrossWord.replace(word)),
              ifAbsent: () => CrosswordCharacter.character(
                acrossWord: word,
                character: character,
              ),
            );
          case Direction.down:
            b.characters.updateValue(
              word.location.downOffset(idx),
              (b) => b.rebuild((bInner) => bInner.downWord.replace(word)),
              ifAbsent: () => CrosswordCharacter.character(
                downWord: word,
                character: character,
              ),
            );
        }
      }
    }
  }

  /// Pretty print a crossword. Generates the character grid, and lists
  /// the down words and across words sorted by location.
  String prettyPrintCrossword() {
    final buffer = StringBuffer();
    final grid = List.generate(
      height,
      (_) => List.generate(
        width, (_) => '░', // https://www.compart.com/en/unicode/U+2591
      ),
    );

    for (final MapEntry(key: Location(:x, :y), value: character)
        in characters.entries) {
      grid[y][x] = character.character;
    }

    for (final row in grid) {
      buffer.writeln(row.join());
    }

    buffer.writeln();
    buffer.writeln('Across:');
    for (final word
        in words.where((word) => word.direction == Direction.across).toList()
          ..sort(CrosswordWord.locationComparator)) {
      buffer.writeln('${word.location.prettyPrint()}: ${word.word}');
    }

    buffer.writeln();
    buffer.writeln('Down:');
    for (final word
        in words.where((word) => word.direction == Direction.down).toList()
          ..sort(CrosswordWord.locationComparator)) {
      buffer.writeln('${word.location.prettyPrint()}: ${word.word}');
    }

    return buffer.toString();
  }

  /// Constructor for [Crossword].
  factory Crossword.crossword({
    required int width,
    required int height,
    Iterable<CrosswordWord>? words,
  }) {
    return Crossword((b) {
      b
        ..width = width
        ..height = height;
      if (words != null) {
        b.words.addAll(words);
      }
    });
  }

  /// Constructor for [Crossword].
  /// Use [Crossword.crossword] instead.
  factory Crossword([void Function(CrosswordBuilder)? updates]) = _$Crossword;
  Crossword._();
}

/// Construct the serialization/deserialization code for the data model.
@SerializersFor([
  Location,
  Crossword,
  CrosswordWord,
  CrosswordCharacter,
])
final Serializers serializers = _$serializers;

Hinweis: Wenn der Dartlauf build_runner watch -d aus dem vorherigen Schritt noch läuft, wird die Datei model.g.dart angezeigt. Falls nicht, ist jetzt ein guter Zeitpunkt, build_runner wieder zu starten.

Diese Datei beschreibt den Anfang der Datenstruktur, die Sie zum Erstellen von Kreuzworträtseln verwenden. Im Kern besteht ein Kreuzworträtsel aus einer Reihe von horizontalen und vertikalen Wörtern, die in einem Raster verschränkt sind. Um diese Datenstruktur zu verwenden, konstruieren Sie eine Crossword der entsprechenden Größe mit dem benannten Crossword.crossword-Konstruktor und fügen dann Wörter mit der addWord-Methode hinzu. Im Rahmen der Erstellung des endgültigen Werts wird mit der Methode _fillCharacters ein Raster aus CrosswordCharacters erstellt.

Achtung: Derzeit werden die hinzugefügten Wörter nicht validiert, um sicherzustellen, dass sie mit den anderen Wörtern im Kreuzworträtsel übereinstimmen. Dies wird in den nächsten Schritten behoben.

So verwenden Sie diese Datenstruktur:

1. Erstellen Sie im Verzeichnis lib eine utils-Datei und fügen Sie ihr den folgenden Inhalt hinzu:

lib/utils.dart

import 'dart:math';

import 'package:built_collection/built_collection.dart';

/// A [Random] instance for generating random numbers.
final _random = Random();

/// An extension on [BuiltSet] that adds a method to get a random element.
extension RandomElements<E> on BuiltSet<E> {
  E randomElement() {
    return elementAt(_random.nextInt(length));
  }
}

Dies ist eine Erweiterung von BuiltSet, mit der ein zufälliges Element des Satzes mühelos abgerufen werden kann. Erweiterungsmethoden machen es einfach, Klassen mit zusätzlichen Funktionen zu erweitern. Sie müssen der Erweiterung einen Namen geben, damit sie außerhalb der Datei utils.dart verfügbar ist.

2. Fügen Sie der Datei lib/providers.dart die folgenden Importe hinzu:

lib/providers.dart

import 'dart:convert';
import 'dart:math';                                        // Add this import

import 'package:built_collection/built_collection.dart';
import 'package:flutter/foundation.dart';                  // Add this import
import 'package:flutter/services.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';

import 'model.dart' as model;                              // And this import
import 'utils.dart';                                       // And this one

part 'providers.g.dart';

/// A provider for the wordlist to use when generating the crossword.
@riverpod
Future<BuiltSet<String>> wordList(WordListRef ref) async {

Durch diese Importe wird das oben definierte Modell den Anbietern, die Sie erstellen werden, verfügbar gemacht. Der Import dart:math ist für Random enthalten, der Import flutter/foundation.dart ist für debugPrint, model.dart für das Modell und utils.dart für die Erweiterung BuiltSet enthalten.

3. Fügen Sie am Ende derselben Datei die folgenden Anbieter hinzu:

lib/providers.dart

/// An enumeration for different sizes of [model.Crossword]s.
enum CrosswordSize {
  small(width: 20, height: 11),
  medium(width: 40, height: 22),
  large(width: 80, height: 44),
  xlarge(width: 160, height: 88),
  xxlarge(width: 500, height: 500);

  const CrosswordSize({
    required this.width,
    required this.height,
  });

  final int width;
  final int height;
  String get label => '$width x $height';
}

/// A provider that holds the current size of the crossword to generate.
@Riverpod(keepAlive: true)
class Size extends _$Size {
  var _size = CrosswordSize.medium;

  @override
  CrosswordSize build() => _size;

  void setSize(CrosswordSize size) {
    _size = size;
    ref.invalidateSelf();
  }
}

final _random = Random();

@riverpod
Stream<model.Crossword> crossword(CrosswordRef ref) async* {
  final size = ref.watch(sizeProvider);
  final wordListAsync = ref.watch(wordListProvider);

  var crossword =
      model.Crossword.crossword(width: size.width, height: size.height);

  yield* wordListAsync.when(
    data: (wordList) async* {
      while (crossword.characters.length < size.width * size.height * 0.8) {
        final word = wordList.randomElement();
        final direction =
            _random.nextBool() ? model.Direction.across : model.Direction.down;
        final location = model.Location.at(
            _random.nextInt(size.width), _random.nextInt(size.height));

        crossword = crossword.addWord(
            word: word, direction: direction, location: location);
        yield crossword;
        await Future.delayed(Duration(milliseconds: 100));
      }

      yield crossword;
    },
    error: (error, stackTrace) async* {
      debugPrint('Error loading word list: $error');
      yield crossword;
    },
    loading: () async* {
      yield crossword;
    },
  );
}

Durch diese Änderungen werden deiner App zwei Anbieter hinzugefügt. Die erste ist Size. Dabei handelt es sich um eine globale Variable, die den aktuell ausgewählten Wert der Aufzählung CrosswordSize enthält. Dadurch kann die Benutzeroberfläche sowohl die Größe des Kreuzworträtsels anzeigen als auch die Größe des Kreuzworträtsels festlegen. Der zweite Anbieter, crossword, ist etwas interessanter. Dies ist eine Funktion, die eine Reihe von Crosswords zurückgibt. Sie basiert auf der Dart-Unterstützung für Generatoren, wie durch die async* in der Funktion gekennzeichnet. Dies bedeutet, dass nicht mit einer Rückgabe enden wird, sondern eine Reihe von Crosswords generiert wird. Dies ist viel einfacher, eine Berechnung zu schreiben, die Zwischenergebnisse zurückgibt.

Da zu Beginn der crossword-Anbieterfunktion zwei ref.watch-Aufrufe vorhanden sind, wird der Stream der Crosswords jedes Mal, wenn sich die ausgewählte Größe des Kreuzworträtsels ändert, und wenn die Wortliste fertig geladen wurde, vom Riverpod-System neu gestartet.

Sie haben nun Code zum Generieren von Kreuzworträtseln, wenn auch voller zufälliger Wörter. Es wäre schön, sie den Nutzenden des Tools zu zeigen.

4. Erstellen Sie im Verzeichnis lib/widgets eine crossword_widget.dart-Datei mit folgendem Inhalt:

lib/widgets/crossword_widget.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:two_dimensional_scrollables/two_dimensional_scrollables.dart';

import '../model.dart';
import '../providers.dart';

class CrosswordWidget extends ConsumerWidget {
  const CrosswordWidget({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final size = ref.watch(sizeProvider);
    return TableView.builder(
      diagonalDragBehavior: DiagonalDragBehavior.free,
      cellBuilder: _buildCell,
      columnCount: size.width,
      columnBuilder: (index) => _buildSpan(context, index),
      rowCount: size.height,
      rowBuilder: (index) => _buildSpan(context, index),
    );
  }

  TableViewCell _buildCell(BuildContext context, TableVicinity vicinity) {
    final location = Location.at(vicinity.column, vicinity.row);

    return TableViewCell(
      child: Consumer(
        builder: (context, ref, _) {
          final character = ref.watch(
            crosswordProvider.select(
              (crosswordAsync) => crosswordAsync.when(
                data: (crossword) => crossword.characters[location],
                error: (error, stackTrace) => null,
                loading: () => null,
              ),
            ),
          );

          if (character != null) {
            return Container(
              color: Theme.of(context).colorScheme.onPrimary,
              child: Center(
                child: Text(
                  character.character,
                  style: TextStyle(
                    fontSize: 24,
                    color: Theme.of(context).colorScheme.primary,
                  ),
                ),
              ),
            );
          }

          return ColoredBox(
            color: Theme.of(context).colorScheme.primaryContainer,
          );
        },
      ),
    );
  }

  TableSpan _buildSpan(BuildContext context, int index) {
    return TableSpan(
      extent: FixedTableSpanExtent(32),
      foregroundDecoration: TableSpanDecoration(
        border: TableSpanBorder(
          leading: BorderSide(
              color: Theme.of(context).colorScheme.onPrimaryContainer),
          trailing: BorderSide(
              color: Theme.of(context).colorScheme.onPrimaryContainer),
        ),
      ),
    );
  }
}

Dieses Widget, das ein ConsumerWidget ist, kann sich direkt auf den Size-Anbieter verlassen, um die Größe des Rasters zu bestimmen, in dem die Zeichen von Crossword angezeigt werden. Dieses Raster wird mit dem TableView-Widget aus dem two_dimensional_scrollables-Paket angezeigt.

Hinweis: Die einzelnen Zellen, die von den _buildCell-Hilfsfunktionen gerendert werden, enthalten jeweils ein Consumer-Widget in ihrer zurückgegebenen Widget-Struktur. Dies dient als Begrenzung für die Aktualisierung. Alles im Consumer-Widget wird neu erstellt, wenn sich der von ref.watch zurückgegebene Wert ändert. Es ist verlockend, bei jeder Änderung von Crossword den gesamten Baum neu zu erstellen. Dies führt jedoch zu einem großen Rechenaufwand, der bei dieser Konfiguration übersprungen werden kann.

Wenn Sie sich den Parameter ref.watch ansehen, stellen Sie fest, dass eine Neuberechnung von Layouts durch die Verwendung von crosswordProvider.select eine weitere Ebene vermieden wird. Das bedeutet, dass ref.watch nur dann eine Neuerstellung des Inhalts von TableViewCell auslöst, wenn sich das Zeichen, das die Zelle für das Rendern verantwortlich ist, ändert. Diese Reduzierung des erneuten Renderings trägt wesentlich dazu bei, dass die Benutzeroberfläche reaktionsschnell bleibt.

Wenn Sie die Anbieter CrosswordWidget und Size für den Nutzer freigeben möchten, ändern Sie die Datei crossword_generator_app.dart so:

lib/widgets/crossword_generator_app.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

import '../providers.dart';
import 'crossword_widget.dart';                               // Add this import

class CrosswordGeneratorApp extends StatelessWidget {
  const CrosswordGeneratorApp({super.key});

  @override
  Widget build(BuildContext context) {
    return _EagerInitialization(
      child: Scaffold(
        appBar: AppBar(
          actions: [_CrosswordGeneratorMenu()],               // Add this line
          titleTextStyle: TextStyle(
            color: Theme.of(context).colorScheme.primary,
            fontSize: 16,
            fontWeight: FontWeight.bold,
          ),
          title: Text('Crossword Generator'),
        ),
        body: SafeArea(
          child: CrosswordWidget(),                           // Replaces everything that was here before
        ),
      ),
    );
  }
}

class _EagerInitialization extends ConsumerWidget {
  const _EagerInitialization({required this.child});
  final Widget child;

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    ref.watch(wordListProvider);
    return child;
  }
}

class _CrosswordGeneratorMenu extends ConsumerWidget {        // Add from here
  @override
  Widget build(BuildContext context, WidgetRef ref) => MenuAnchor(
        menuChildren: [
          for (final entry in CrosswordSize.values)
            MenuItemButton(
              onPressed: () => ref.read(sizeProvider.notifier).setSize(entry),
              leadingIcon: entry == ref.watch(sizeProvider)
                  ? Icon(Icons.radio_button_checked_outlined)
                  : Icon(Icons.radio_button_unchecked_outlined),
              child: Text(entry.label),
            ),
        ],
        builder: (context, controller, child) => IconButton(
          onPressed: () => controller.open(),
          icon: Icon(Icons.settings),
        ),
      );                                                      // To here.
}

Hier hat sich einiges geändert. Zunächst wurde der Code für das Rendern der wordList als ListView durch einen Aufruf von CrosswordWidget ersetzt, der in der vorherigen Datei definiert wurde. Die andere große Änderung ist der Anfang eines Menüs, mit dem das Verhalten der App geändert werden kann. Zuerst wird dabei die Größe des Kreuzworträtsels geändert. In Zukunft werden weitere MenuItemButtons hinzugefügt. Führen Sie Ihre App aus. Sie sehen in etwa Folgendes:

Es werden Zeichen in einem Raster und ein Menü angezeigt, über das Nutzende die Größe des Rasters ändern können. Aber die Worte sind nicht wie in einem Kreuzworträtsel angeordnet. Das liegt daran, dass keine Einschränkungen für das Hinzufügen von Wörtern zum Kreuzworträtsel gelten. Kurz gesagt, es ist ein Chaos. Etwas, das Sie im nächsten Schritt unter Kontrolle bringen werden!

5. Einschränkungen erzwingen

Ziel dieses Schritts ist es, dem Modell Code hinzuzufügen, um Kreuzworträtsel-Einschränkungen zu erzwingen. Es gibt viele verschiedene Arten von Kreuzworträtseln und der Stil, den dieses Codelab durchsetzt, entspricht den Traditionen der englischen Kreuzworträtsel. Das Ändern dieses Codes, um andere Arten von Kreuzworträtseln zu generieren, bleibt wie immer als Übung für den Leser übrig.

Führen Sie zunächst die folgenden Schritte aus:

1. Öffnen Sie die Datei model.dart und ersetzen Sie das Modell Crossword durch Folgendes:

lib/model.dart

/// A crossword puzzle. This is a grid of characters with words placed in it.
/// The puzzle constraint is in the English crossword puzzle tradition.
abstract class Crossword implements Built<Crossword, CrosswordBuilder> {
  /// Serializes and deserializes the [Crossword] class.
  static Serializer<Crossword> get serializer => _$crosswordSerializer;

  /// Width across the [Crossword] puzzle.
  int get width;

  /// Height down the [Crossword] puzzle.
  int get height;

  /// The words in the crossword.
  BuiltList<CrosswordWord> get words;

  /// The characters by location. Useful for displaying the crossword,
  /// or checking the proposed solution.
  BuiltMap<Location, CrosswordCharacter> get characters;

  /// Checks if this crossword is valid.
  bool get valid {
    // Check that there are no duplicate words.
    final wordSet = words.map((word) => word.word).toBuiltSet();
    if (wordSet.length != words.length) {
      return false;
    }

    for (final MapEntry(key: location, value: character)
        in characters.entries) {
      // All characters must be a part of an across or down word.
      if (character.acrossWord == null && character.downWord == null) {
        return false;
      }

      // All characters must be within the crossword puzzle.
      // No drawing outside the lines.
      if (location.x < 0 ||
          location.y < 0 ||
          location.x >= width ||
          location.y >= height) {
        return false;
      }

      // Characters above and below this character must be related
      // by a vertical word
      if (characters[location.up] case final up?) {
        if (character.downWord == null) {
          return false;
        }
        if (up.downWord != character.downWord) {
          return false;
        }
      }

      if (characters[location.down] case final down?) {
        if (character.downWord == null) {
          return false;
        }
        if (down.downWord != character.downWord) {
          return false;
        }
      }

      // Characters to the left and right of this character must be
      // related by a horizontal word
      final left = characters[location.left];
      if (left != null) {
        if (character.acrossWord == null) {
          return false;
        }
        if (left.acrossWord != character.acrossWord) {
          return false;
        }
      }

      final right = characters[location.right];
      if (right != null) {
        if (character.acrossWord == null) {
          return false;
        }
        if (right.acrossWord != character.acrossWord) {
          return false;
        }
      }
    }

    return true;
  }

  /// Add a word to the crossword at the given location and direction.
  Crossword? addWord({
    required Location location,
    required String word,
    required Direction direction,
  }) {
    // Require that the word is not already in the crossword.
    if (words.map((crosswordWord) => crosswordWord.word).contains(word)) {
      return null;
    }

    final wordCharacters = word.characters;
    bool overlap = false;

    // Check that the word fits in the crossword.
    for (final (index, character) in wordCharacters.indexed) {
      final characterLocation = switch (direction) {
        Direction.across => location.rightOffset(index),
        Direction.down => location.downOffset(index),
      };

      final target = characters[characterLocation];
      if (target != null) {
        overlap = true;
        if (target.character != character) {
          return null;
        }
        if (direction == Direction.across && target.acrossWord != null ||
            direction == Direction.down && target.downWord != null) {
          return null;
        }
      }
    }
    if (words.isNotEmpty && !overlap) {
      return null;
    }

    final candidate = rebuild(
      (b) => b
        ..words.add(
          CrosswordWord.word(
            word: word,
            direction: direction,
            location: location,
          ),
        ),
    );

    if (candidate.valid) {
      return candidate;
    } else {
      return null;
    }
  }

  /// As a finalize step, fill in the characters map.
  @BuiltValueHook(finalizeBuilder: true)
  static void _fillCharacters(CrosswordBuilder b) {
    b.characters.clear();

    for (final word in b.words.build()) {
      for (final (idx, character) in word.word.characters.indexed) {
        switch (word.direction) {
          case Direction.across:
            b.characters.updateValue(
              word.location.rightOffset(idx),
              (b) => b.rebuild((bInner) => bInner.acrossWord.replace(word)),
              ifAbsent: () => CrosswordCharacter.character(
                acrossWord: word,
                character: character,
              ),
            );
          case Direction.down:
            b.characters.updateValue(
              word.location.downOffset(idx),
              (b) => b.rebuild((bInner) => bInner.downWord.replace(word)),
              ifAbsent: () => CrosswordCharacter.character(
                downWord: word,
                character: character,
              ),
            );
        }
      }
    }
  }

  /// Pretty print a crossword. Generates the character grid, and lists
  /// the down words and across words sorted by location.
  String prettyPrintCrossword() {
    final buffer = StringBuffer();
    final grid = List.generate(
      height,
      (_) => List.generate(
        width, (_) => '░', // https://www.compart.com/en/unicode/U+2591
      ),
    );

    for (final MapEntry(key: Location(:x, :y), value: character)
        in characters.entries) {
      grid[y][x] = character.character;
    }

    for (final row in grid) {
      buffer.writeln(row.join());
    }

    buffer.writeln();
    buffer.writeln('Across:');
    for (final word
        in words.where((word) => word.direction == Direction.across).toList()
          ..sort(CrosswordWord.locationComparator)) {
      buffer.writeln('${word.location.prettyPrint()}: ${word.word}');
    }

    buffer.writeln();
    buffer.writeln('Down:');
    for (final word
        in words.where((word) => word.direction == Direction.down).toList()
          ..sort(CrosswordWord.locationComparator)) {
      buffer.writeln('${word.location.prettyPrint()}: ${word.word}');
    }

    return buffer.toString();
  }

  /// Constructor for [Crossword].
  factory Crossword.crossword({
    required int width,
    required int height,
    Iterable<CrosswordWord>? words,
  }) {
    return Crossword((b) {
      b
        ..width = width
        ..height = height;
      if (words != null) {
        b.words.addAll(words);
      }
    });
  }

  /// Constructor for [Crossword].
  /// Use [Crossword.crossword] instead.
  factory Crossword([void Function(CrosswordBuilder)? updates]) = _$Crossword;
  Crossword._();
}

Zur Erinnerung: Für die Änderungen, die Sie an den Dateien model.dart und providers.dart vornehmen, muss build_runner ausgeführt werden, damit die entsprechenden Dateien model.g.dart und providers.g.dart aktualisiert werden können. Wenn diese Dateien nicht automatisch aktualisiert wurden, ist jetzt ein guter Zeitpunkt, build_runner mit dart run build_runner watch -d neu zu starten.

Wenn Sie diese neue Funktion in der Modellebene nutzen möchten, müssen Sie die Anbieterebene entsprechend aktualisieren.

2. Bearbeiten Sie die Datei providers.dart so:

lib/providers.dart

import 'dart:convert';
import 'dart:math';

import 'package:built_collection/built_collection.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';

import 'model.dart' as model;
import 'utils.dart';

part 'providers.g.dart';

/// A provider for the wordlist to use when generating the crossword.
@riverpod
Future<BuiltSet<String>> wordList(WordListRef ref) async {
  // This codebase requires that all words consist of lowercase characters
  // in the range 'a'-'z'. Words containing uppercase letters will be
  // lowercased, and words containing runes outside this range will
  // be removed.

  final re = RegExp(r'^[a-z]+$');
  final words = await rootBundle.loadString('assets/words.txt');
  return const LineSplitter().convert(words).toBuiltSet().rebuild((b) => b
    ..map((word) => word.toLowerCase().trim())
    ..where((word) => word.length > 2)
    ..where((word) => re.hasMatch(word)));
}

/// An enumeration for different sizes of [model.Crossword]s.
enum CrosswordSize {
  small(width: 20, height: 11),
  medium(width: 40, height: 22),
  large(width: 80, height: 44),
  xlarge(width: 160, height: 88),
  xxlarge(width: 500, height: 500);

  const CrosswordSize({
    required this.width,
    required this.height,
  });

  final int width;
  final int height;
  String get label => '$width x $height';
}

/// A provider that holds the current size of the crossword to generate.
@Riverpod(keepAlive: true)
class Size extends _$Size {
  var _size = CrosswordSize.medium;

  @override
  CrosswordSize build() => _size;

  void setSize(CrosswordSize size) {
    _size = size;
    ref.invalidateSelf();
  }
}

final _random = Random();

@riverpod
Stream<model.Crossword> crossword(CrosswordRef ref) async* {
  final size = ref.watch(sizeProvider);
  final wordListAsync = ref.watch(wordListProvider);

  var crossword =
      model.Crossword.crossword(width: size.width, height: size.height);

  yield* wordListAsync.when(
    data: (wordList) async* {
      while (crossword.characters.length < size.width * size.height * 0.8) {
        final word = wordList.randomElement();
        final direction =
            _random.nextBool() ? model.Direction.across : model.Direction.down;
        final location = model.Location.at(
            _random.nextInt(size.width), _random.nextInt(size.height));

        var candidate = crossword.addWord(                 // Edit from here
            word: word, direction: direction, location: location);
        await Future.delayed(Duration(milliseconds: 10));
        if (candidate != null) {
          debugPrint('Added word: $word');
          crossword = candidate;
          yield crossword;
        } else {
          debugPrint('Failed to add word: $word');
        }                                                  // To here.
      }

      yield crossword;
    },
    error: (error, stackTrace) async* {
      debugPrint('Error loading word list: $error');
      yield crossword;
    },
    loading: () async* {
      yield crossword;
    },
  );
}

3. Führen Sie Ihre App aus. In der Benutzeroberfläche passiert nicht viel, aber es passiert viel, wenn Sie sich die Logs ansehen.

Wenn man darüber nachdenkt, was hier passiert, erscheint zufällig ein Kreuzworträtsel. Die Methode addWord im Modell Crossword lehnt jedes vorgeschlagene Wort ab, das nicht in das aktuelle Kreuzworträtsel passt. Daher ist es erstaunlich, dass überhaupt etwas angezeigt wird.

Als Vorbereitung auf die methodische Auswahl der Wörter, die wo verwendet werden sollen, wäre es sehr hilfreich, diese Berechnung aus dem UI-Thread in eine Hintergrundisolierung zu verlagern. Flutter hat einen sehr nützlichen Wrapper, mit dem Sie einen Teil einer Arbeit in einer Hintergrundisolierung ausführen können: die Funktion compute.

4. Ändern Sie in der Datei providers.dart den Kreuzworträtselanbieter so:

lib/providers.dart

@riverpod
Stream<model.Crossword> crossword(CrosswordRef ref) async* {
  final size = ref.watch(sizeProvider);
  final wordListAsync = ref.watch(wordListProvider);

  var crossword =
      model.Crossword.crossword(width: size.width, height: size.height);

  yield* wordListAsync.when(
    data: (wordList) async* {
      while (crossword.characters.length < size.width * size.height * 0.8) {
        final word = wordList.randomElement();
        final direction =
            _random.nextBool() ? model.Direction.across : model.Direction.down;
        final location = model.Location.at(
            _random.nextInt(size.width), _random.nextInt(size.height));
        try {
          var candidate = await compute(                   // Edit from here.
              ((String, model.Direction, model.Location) wordToAdd) {
            final (word, direction, location) = wordToAdd;
            return crossword.addWord(
                word: word, direction: direction, location: location);
          }, (word, direction, location));

          if (candidate != null) {
            crossword = candidate;
            yield crossword;
          }
        } catch (e) {
          debugPrint('Error running isolate: $e');
        }                                                  // To here.
      }

      yield crossword;
    },
    error: (error, stackTrace) async* {
      debugPrint('Error loading word list: $error');
      yield crossword;
    },
    loading: () async* {
      yield crossword;
    },
  );
}

Dieser Code funktioniert. Sie enthält jedoch eine Falle. Wenn Sie diesen Pfad beibehalten, wird letztendlich ein protokollierter Fehler wie der folgende angezeigt:

flutter: Error running isolate: Invalid argument(s): Illegal argument in isolate message: object is unsendable - Library:'dart:async' Class: _Future@4048458 (see restrictions listed at `SendPort.send()` documentation for more information)
flutter:  <- Instance of 'AutoDisposeStreamProviderElement<Crossword>' (from package:riverpod/src/stream_provider.dart)
flutter:  <- Context num_variables: 2 <- Context num_variables: 1 parent:{ Context num_variables: 2 }
flutter:  <- Context num_variables: 1 parent:{ Context num_variables: 1 parent:{ Context num_variables: 2 } }
flutter:  <- Closure: () => Crossword? (from package:generate_crossword/providers.dart)

Dies ist das Ergebnis der Schließung, die compute an die Hintergrundisolierung über einen Anbieter übergibt, die nicht über SendPort.send() gesendet werden kann. Eine Lösung für dieses Problem besteht darin, sicherzustellen, dass es für die Schließung nichts gibt, das nicht besendebar ist.

In einem ersten Schritt werden die Anbieter vom Isolieren-Code getrennt.

5. Erstellen Sie eine isolates.dart-Datei in Ihrem lib-Verzeichnis und fügen Sie ihr folgenden Inhalt hinzu:

lib/isolates.dart

import 'dart:math';

import 'package:built_collection/built_collection.dart';
import 'package:flutter/foundation.dart';

import 'model.dart';
import 'utils.dart';

final _random = Random();

Stream<Crossword> exploreCrosswordSolutions({
  required Crossword crossword,
  required BuiltSet<String> wordList,
}) async* {
  while (
      crossword.characters.length < crossword.width * crossword.height * 0.8) {
    final word = wordList.randomElement();
    final direction = _random.nextBool() ? Direction.across : Direction.down;
    final location = Location.at(
        _random.nextInt(crossword.width), _random.nextInt(crossword.height));
    try {
      var candidate = await compute(((String, Direction, Location) wordToAdd) {
        final (word, direction, location) = wordToAdd;
        return crossword.addWord(
            word: word, direction: direction, location: location);
      }, (word, direction, location));

      if (candidate != null) {
        crossword = candidate;
        yield crossword;
      }
    } catch (e) {
      debugPrint('Error running isolate: $e');
    }
  }
}

Dieser Code sollte Ihnen bekannt vorkommen. Er bildet den Kern dessen, was der crossword-Anbieter war, aber jetzt als eigenständige Generatorfunktion. Jetzt können Sie die Datei providers.dart aktualisieren, um diese neue Funktion zur Instanziierung der Hintergrundisolierung zu verwenden.

lib/providers.dart

// Drop the dart:math import, the _random instance moved to isolates.dart
import 'dart:convert';

import 'package:built_collection/built_collection.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';

import 'isolates.dart';                                    // Add this import
import 'model.dart' as model;
                                                           // Drop the utils.dart import

part 'providers.g.dart';

/// A provider for the wordlist to use when generating the crossword.
@riverpod
Future<BuiltSet<String>> wordList(WordListRef ref) async {
  // This codebase requires that all words consist of lowercase characters
  // in the range 'a'-'z'. Words containing uppercase letters will be
  // lowercased, and words containing runes outside this range will
  // be removed.

  final re = RegExp(r'^[a-z]+$');
  final words = await rootBundle.loadString('assets/words.txt');
  return const LineSplitter().convert(words).toBuiltSet().rebuild((b) => b
    ..map((word) => word.toLowerCase().trim())
    ..where((word) => word.length > 2)
    ..where((word) => re.hasMatch(word)));
}

/// An enumeration for different sizes of [model.Crossword]s.
enum CrosswordSize {
  small(width: 20, height: 11),
  medium(width: 40, height: 22),
  large(width: 80, height: 44),
  xlarge(width: 160, height: 88),
  xxlarge(width: 500, height: 500);

  const CrosswordSize({
    required this.width,
    required this.height,
  });

  final int width;
  final int height;
  String get label => '$width x $height';
}

/// A provider that holds the current size of the crossword to generate.
@Riverpod(keepAlive: true)
class Size extends _$Size {
  var _size = CrosswordSize.medium;

  @override
  CrosswordSize build() => _size;

  void setSize(CrosswordSize size) {
    _size = size;
    ref.invalidateSelf();
  }
}
                                                           // Drop the _random instance
@riverpod
Stream<model.Crossword> crossword(CrosswordRef ref) async* {
  final size = ref.watch(sizeProvider);
  final wordListAsync = ref.watch(wordListProvider);

  final emptyCrossword =                                   // Edit from here
      model.Crossword.crossword(width: size.width, height: size.height);

  yield* wordListAsync.when(
    data: (wordList) => exploreCrosswordSolutions(
      crossword: emptyCrossword,
      wordList: wordList,
    ),
    error: (error, stackTrace) async* {
      debugPrint('Error loading word list: $error');
      yield emptyCrossword;
    },
    loading: () async* {
      yield emptyCrossword;                                // To here.
    },
  );
}

Damit hast du jetzt ein Tool, mit dem du Kreuzworträtsel unterschiedlicher Größe erstellen kannst. Mit compute kannst du das Rätsel herausfinden, das in einem Hintergrundisolierung stattfindet. Könnte nur der Code effizienter sein, wenn es darum geht, welche Wörter dem Kreuzworträtsel hinzugefügt werden sollen?

6. Aufgabenliste verwalten

Ein Teil des Problems des jetzigen Codes ist, dass das zu lösende Problem tatsächlich ein Suchproblem ist und die aktuelle Lösung blinde Suchen ist. Wenn sich der Code darauf konzentriert, Wörter zu finden, die an die aktuellen Wörter angehängt werden können, anstatt nach dem Zufallsprinzip zu versuchen, Wörter irgendwo im Raster zu platzieren, würde das System schneller Lösungen finden. Eine Möglichkeit, dies zu erreichen, besteht darin, eine Warteschlange mit Standorten einzurichten, um nach Wörtern zu suchen.

Der Code erstellt derzeit mögliche Lösungen, überprüft, ob die Kandidatenlösung gültig ist, und je nach Gültigkeit wird der Kandidaten entweder integriert oder verworfen. Dies ist eine Beispielimplementierung aus der Backtracking-Algorithmusfamilie. Diese Implementierung wird durch built_value und built_collection erheblich erleichtert. Sie ermöglichen die Erstellung neuer unveränderlicher Werte, die einen gemeinsamen Zustand mit dem unveränderlichen Wert, aus dem sie abgeleitet wurden, ableiten und somit denselben gemeinsamen Zustand haben. Dies ermöglicht die kostengünstige Ausnutzung potenzieller Kandidaten ohne die Speicherkosten, die für ein tiefes Kopieren erforderlich sind.

Hinweis: Was ist Backtracking? Laut Wikipedia ist Backtracking eine Klasse von Algorithmen, die Lösungen für einige Rechenprobleme finden, insbesondere Probleme bei der Einschränkung der Zufriedenheit, die inkrementell Kandidaten für die Lösungen erstellen und einen Kandidaten verwerfen oder Backtracks ausführen, sobald sie feststellen, dass der Kandidat möglicherweise nicht zu einer gültigen Lösung abgeschlossen werden kann. Weitere Informationen finden Sie unter Backtracking.

Führen Sie zunächst die folgenden Schritte aus:

1. Öffnen Sie die Datei model.dart und fügen Sie die folgende WorkQueue-Definition hinzu:

lib/model.dart

  /// Constructor for [Crossword].
  /// Use [Crossword.crossword] instead.
  factory Crossword([void Function(CrosswordBuilder)? updates]) = _$Crossword;
  Crossword._();
}
                                                           // Add from here
/// A work queue for a worker to process. The work queue contains a crossword
/// and a list of locations to try, along with candidate words to add to the
/// crossword.
abstract class WorkQueue implements Built<WorkQueue, WorkQueueBuilder> {
  static Serializer<WorkQueue> get serializer => _$workQueueSerializer;

  /// The crossword the worker is working on.
  Crossword get crossword;

  /// The outstanding queue of locations to try.
  BuiltMap<Location, Direction> get locationsToTry;

  /// Known bad locations.
  BuiltSet<Location> get badLocations;

  /// The list of unused candidate words that can be added to this crossword.
  BuiltSet<String> get candidateWords;

  /// Returns true if the work queue is complete.
  bool get isCompleted => locationsToTry.isEmpty || candidateWords.isEmpty;

  /// Create a work queue from a crossword.
  static WorkQueue from({
    required Crossword crossword,
    required Iterable<String> candidateWords,
    required Location startLocation,
  }) =>
      WorkQueue((b) {
        if (crossword.words.isEmpty) {
          // Strip candidate words too long to fit in the crossword
          b.candidateWords.addAll(candidateWords
              .where((word) => word.characters.length <= crossword.width));

          b.crossword.replace(crossword);

          b.locationsToTry.addAll({startLocation: Direction.across});
        } else {
          // Assuming words have already been stripped to length
          b.candidateWords.addAll(
            candidateWords.toBuiltSet().rebuild(
                (b) => b.removeAll(crossword.words.map((word) => word.word))),
          );
          b.crossword.replace(crossword);
          crossword.characters
              .rebuild((b) => b.removeWhere((location, character) {
                    if (character.acrossWord != null &&
                        character.downWord != null) {
                      return true;
                    }
                    final left = crossword.characters[location.left];
                    if (left != null && left.downWord != null) return true;
                    final right = crossword.characters[location.right];
                    if (right != null && right.downWord != null) return true;
                    final up = crossword.characters[location.up];
                    if (up != null && up.acrossWord != null) return true;
                    final down = crossword.characters[location.down];
                    if (down != null && down.acrossWord != null) return true;
                    return false;
                  }))
              .forEach((location, character) {
            b.locationsToTry.addAll({
              location: switch ((character.acrossWord, character.downWord)) {
                (null, null) =>
                  throw StateError('Character is not part of a word'),
                (null, _) => Direction.across,
                (_, null) => Direction.down,
                (_, _) => throw StateError('Character is part of two words'),
              }
            });
          });
        }
      });

  WorkQueue remove(Location location) => rebuild((b) => b
    ..locationsToTry.remove(location)
    ..badLocations.add(location));

  /// Update the work queue from a crossword derived from the current crossword
  /// that this work queue is built from.
  WorkQueue updateFrom(final Crossword crossword) => WorkQueue.from(
        crossword: crossword,
        candidateWords: candidateWords,
        startLocation: locationsToTry.isNotEmpty
            ? locationsToTry.keys.first
            : Location.at(0, 0),
      ).rebuild((b) => b
        ..badLocations.addAll(badLocations)
        ..locationsToTry
            .removeWhere((location, _) => badLocations.contains(location)));

  /// Factory constructor for [WorkQueue]
  factory WorkQueue([void Function(WorkQueueBuilder)? updates]) = _$WorkQueue;

  WorkQueue._();
}                                                          // To here.

/// Construct the serialization/deserialization code for the data model.
@SerializersFor([
  Location,
  Crossword,
  CrosswordWord,
  CrosswordCharacter,
  WorkQueue,                                               // Add this line
])
final Serializers serializers = _$serializers;

2. Wenn in der Datei noch rote Schnörkel vorhanden sind, nachdem Sie den neuen Inhalt länger als ein paar Sekunden hinzugefügt haben, prüfen Sie, ob build_runner noch ausgeführt wird. Ist dies nicht der Fall, führen Sie den Befehl dart run build_runner watch -d aus.

In dem Code führen Sie das Logging ein, um zu zeigen, wie lange es dauert, Kreuzworträtsel in verschiedenen Größen zu erstellen. Es wäre toll, wenn die Dauer auch schön formatiert wäre. Glücklicherweise können wir mit Erweiterungsmethoden genau die von uns benötigte Methode hinzufügen.

3. Bearbeiten Sie die Datei utils.dartso:

lib/utils.dart

import 'dart:math';

import 'package:built_collection/built_collection.dart';

/// A [Random] instance for generating random numbers.
final _random = Random();

/// An extension on [BuiltSet] that adds a method to get a random element.
extension RandomElements<E> on BuiltSet<E> {
  E randomElement() {
    return elementAt(_random.nextInt(length));
  }
}
                                                              // Add from here
/// An extension on [Duration] that adds a method to format the duration.
extension DurationFormat on Duration {
  /// A human-readable string representation of the duration.
  /// This format is tuned for durations in the seconds to days range.
  String get formatted {
    final hours = inHours.remainder(24).toString().padLeft(2, '0');
    final minutes = inMinutes.remainder(60).toString().padLeft(2, '0');
    final seconds = inSeconds.remainder(60).toString().padLeft(2, '0');
    return switch ((inDays, inHours, inMinutes, inSeconds)) {
      (0, 0, 0, _) => '${inSeconds}s',
      (0, 0, _, _) => '$inMinutes:$seconds',
      (0, _, _, _) => '$inHours:$minutes:$seconds',
      _ => '$inDays days, $hours:$minutes:$seconds',
    };
  }
}                                                             // To here.

Diese Erweiterungsmethode nutzt Switch-Ausdrücke und einen Musterabgleich über Datensätze, um die geeignete Methode zur Anzeige verschiedener Zeiträume von Sekunden bis Tagen auszuwählen. Weitere Informationen zu diesem Code-Stil finden Sie im Codelab Die Muster und Datensätze von Dart kennenlernen.

4. Ersetzen Sie zum Einbinden dieser neuen Funktion die Datei isolates.dart, um die Definition der Funktion exploreCrosswordSolutions so neu zu definieren:

lib/isolates.dart

import 'package:built_collection/built_collection.dart';
import 'package:characters/characters.dart';
import 'package:flutter/foundation.dart';

import 'model.dart';
import 'utils.dart';

Stream<Crossword> exploreCrosswordSolutions({
  required Crossword crossword,
  required BuiltSet<String> wordList,
}) async* {
  final start = DateTime.now();
  var workQueue = WorkQueue.from(
    crossword: crossword,
    candidateWords: wordList,
    startLocation: Location.at(0, 0),
  );
  while (!workQueue.isCompleted) {
    final location = workQueue.locationsToTry.keys.toBuiltSet().randomElement();
    try {
      final crossword = await compute(((WorkQueue, Location) workMessage) {
        final (workQueue, location) = workMessage;
        final direction = workQueue.locationsToTry[location]!;
        final target = workQueue.crossword.characters[location];
        if (target == null) {
          return workQueue.crossword.addWord(
            direction: direction,
            location: location,
            word: workQueue.candidateWords.randomElement(),
          );
        }
        var words = workQueue.candidateWords.toBuiltList().rebuild((b) => b
          ..where((b) => b.characters.contains(target.character))
          ..shuffle());
        int tryCount = 0;
        for (final word in words) {
          tryCount++;
          for (final (index, character) in word.characters.indexed) {
            if (character != target.character) continue;

            final candidate = workQueue.crossword.addWord(
              location: switch (direction) {
                Direction.across => location.leftOffset(index),
                Direction.down => location.upOffset(index),
              },
              word: word,
              direction: direction,
            );
            if (candidate != null) {
              return candidate;
            }
          }
          if (tryCount > 1000) {
            break;
          }
        }
      }, (workQueue, location));
      if (crossword != null) {
        workQueue = workQueue.updateFrom(crossword);
        yield crossword;
      } else {
        workQueue = workQueue.remove(location);
      }
    } catch (e) {
      debugPrint('Error running isolate: $e');
    }
  }
  debugPrint('${crossword.width} x ${crossword.height} Crossword generated in '
      '${DateTime.now().difference(start).formatted}');
}

Wenn Sie diesen Code ausführen, sieht die App oberflächlich identisch aus. Der Unterschied besteht jedoch darin, wie lange es dauert, ein fertiges Kreuzworträtsel zu finden. Hier ist ein Kreuzworträtsel im Format 80 × 44, das in 1 Minute und 29 Sekunden erstellt wurde.

Die offensichtliche Frage ist natürlich: Können wir schneller vorankommen? Oh ja, ja.

7. Oberflächenstatistiken

Um etwas schnell zu machen, hilft es, zu sehen, was vor sich geht. Dabei hilft es, Informationen über den laufenden Prozess bereitzustellen. Jetzt ist es an der Zeit, eine Instrumentierung hinzuzufügen und diese Informationen als Infobereich einzublenden, die den Mauszeiger darüber bewegt.

Die angezeigten Informationen müssen aus der WorkQueue extrahiert und auf der Benutzeroberfläche angezeigt werden.

Ein hilfreicher erster Schritt besteht darin, eine neue Modellklasse zu definieren, die die Informationen enthält, die Sie anzeigen möchten.

Führen Sie zunächst die folgenden Schritte aus:

1. Bearbeiten Sie die Datei model.dart so, um die Klasse DisplayInfo hinzuzufügen:

lib/model.dart

import 'package:built_collection/built_collection.dart';
import 'package:built_value/built_value.dart';
import 'package:built_value/serializer.dart';
import 'package:characters/characters.dart';
import 'package:intl/intl.dart';                           // Add this import

part 'model.g.dart';

/// A location in a crossword.
abstract class Location implements Built<Location, LocationBuilder> {

2. Nehmen Sie am Ende der Datei die folgenden Änderungen vor, um die Klasse DisplayInfo hinzuzufügen:

lib/model.dart

  /// Factory constructor for [WorkQueue]
  factory WorkQueue([void Function(WorkQueueBuilder)? updates]) = _$WorkQueue;

  WorkQueue._();
}
                                                           // Add from here.
/// Display information for the current state of the crossword solve.
abstract class DisplayInfo implements Built<DisplayInfo, DisplayInfoBuilder> {
  static Serializer<DisplayInfo> get serializer => _$displayInfoSerializer;

  /// The number of words in the grid.
  String get wordsInGridCount;

  /// The number of candidate words.
  String get candidateWordsCount;

  /// The number of locations to explore.
  String get locationsToExploreCount;

  /// The number of known bad locations.
  String get knownBadLocationsCount;

  /// The percentage of the grid filled.
  String get gridFilledPercentage;

  /// Construct a [DisplayInfo] instance from a [WorkQueue].
  factory DisplayInfo.from({required WorkQueue workQueue}) {
    final gridFilled = (workQueue.crossword.characters.length /
        (workQueue.crossword.width * workQueue.crossword.height));
    final fmt = NumberFormat.decimalPattern();

    return DisplayInfo((b) => b
      ..wordsInGridCount = fmt.format(workQueue.crossword.words.length)
      ..candidateWordsCount = fmt.format(workQueue.candidateWords.length)
      ..locationsToExploreCount = fmt.format(workQueue.locationsToTry.length)
      ..knownBadLocationsCount = fmt.format(workQueue.badLocations.length)
      ..gridFilledPercentage = '${(gridFilled * 100).toStringAsFixed(2)}%');
  }

  /// An empty [DisplayInfo] instance.
  static DisplayInfo get empty => DisplayInfo((b) => b
    ..wordsInGridCount = '0'
    ..candidateWordsCount = '0'
    ..locationsToExploreCount = '0'
    ..knownBadLocationsCount = '0'
    ..gridFilledPercentage = '0%');

  factory DisplayInfo([void Function(DisplayInfoBuilder)? updates]) =
      _$DisplayInfo;
  DisplayInfo._();
}                                                          // To here.

/// Construct the serialization/deserialization code for the data model.
@SerializersFor([
  Location,
  Crossword,
  CrosswordWord,
  CrosswordCharacter,
  WorkQueue,
  DisplayInfo,                                             // Add this line.
])
final Serializers serializers = _$serializers;

3. Ändern Sie die Datei isolates.dart so, dass das Modell WorkQueue verfügbar ist:

lib/isolates.dart

import 'package:built_collection/built_collection.dart';
import 'package:characters/characters.dart';
import 'package:flutter/foundation.dart';

import 'model.dart';
import 'utils.dart';

Stream<WorkQueue> exploreCrosswordSolutions({              // Modify this line
  required Crossword crossword,
  required BuiltSet<String> wordList,
}) async* {
  final start = DateTime.now();
  var workQueue = WorkQueue.from(
    crossword: crossword,
    candidateWords: wordList,
    startLocation: Location.at(0, 0),
  );
  while (!workQueue.isCompleted) {
    final location = workQueue.locationsToTry.keys.toBuiltSet().randomElement();
    try {
      final crossword = await compute(((WorkQueue, Location) workMessage) {
        final (workQueue, location) = workMessage;
        final direction = workQueue.locationsToTry[location]!;
        final target = workQueue.crossword.characters[location];
        if (target == null) {
          return workQueue.crossword.addWord(
            direction: direction,
            location: location,
            word: workQueue.candidateWords.randomElement(),
          );
        }
        var words = workQueue.candidateWords.toBuiltList().rebuild((b) => b
          ..where((b) => b.characters.contains(target.character))
          ..shuffle());
        int tryCount = 0;
        for (final word in words) {
          tryCount++;
          for (final (index, character) in word.characters.indexed) {
            if (character != target.character) continue;

            final candidate = workQueue.crossword.addWord(
              location: switch (direction) {
                Direction.across => location.leftOffset(index),
                Direction.down => location.upOffset(index),
              },
              word: word,
              direction: direction,
            );
            if (candidate != null) {
              return candidate;
            }
          }
          if (tryCount > 1000) {
            break;
          }
        }
      }, (workQueue, location));
      if (crossword != null) {
        workQueue = workQueue.updateFrom(crossword);       // Drop the yield crossword;
      } else {
        workQueue = workQueue.remove(location);
      }
      yield workQueue;                                     // Add this line.
    } catch (e) {
      debugPrint('Error running isolate: $e');
    }
  }
  debugPrint('${crossword.width} x ${crossword.height} Crossword generated in '
      '${DateTime.now().difference(start).formatted}');
}

Da die Hintergrundisolierung nun die Arbeitswarteschlange offenlegt, geht es nun um die Frage, wie und wo Statistiken aus dieser Datenquelle abgeleitet werden können.

4. Ersetzen Sie den alten Kreuzworträtsel-Anbieter durch einen Anbieter für Arbeitswarteschlangen. Fügen Sie dann weitere Anbieter hinzu, die Informationen aus dem Stream des Anbieters für Arbeitswarteschlangen ableiten:

lib/providers.dart

import 'dart:convert';
import 'dart:math';                                        // Add this import

import 'package:built_collection/built_collection.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';

import 'isolates.dart';
import 'model.dart' as model;

part 'providers.g.dart';

/// A provider for the wordlist to use when generating the crossword.
@riverpod
Future<BuiltSet<String>> wordList(WordListRef ref) async {
  // This codebase requires that all words consist of lowercase characters
  // in the range 'a'-'z'. Words containing uppercase letters will be
  // lowercased, and words containing runes outside this range will
  // be removed.

  final re = RegExp(r'^[a-z]+$');
  final words = await rootBundle.loadString('assets/words.txt');
  return const LineSplitter().convert(words).toBuiltSet().rebuild((b) => b
    ..map((word) => word.toLowerCase().trim())
    ..where((word) => word.length > 2)
    ..where((word) => re.hasMatch(word)));
}

/// An enumeration for different sizes of [model.Crossword]s.
enum CrosswordSize {
  small(width: 20, height: 11),
  medium(width: 40, height: 22),
  large(width: 80, height: 44),
  xlarge(width: 160, height: 88),
  xxlarge(width: 500, height: 500);

  const CrosswordSize({
    required this.width,
    required this.height,
  });

  final int width;
  final int height;
  String get label => '$width x $height';
}

/// A provider that holds the current size of the crossword to generate.
@Riverpod(keepAlive: true)
class Size extends _$Size {
  var _size = CrosswordSize.medium;

  @override
  CrosswordSize build() => _size;

  void setSize(CrosswordSize size) {
    _size = size;
    ref.invalidateSelf();
  }
}

@riverpod
Stream<model.WorkQueue> workQueue(WorkQueueRef ref) async* { // Modify this provider
  final size = ref.watch(sizeProvider);
  final wordListAsync = ref.watch(wordListProvider);
  final emptyCrossword =
      model.Crossword.crossword(width: size.width, height: size.height);
  final emptyWorkQueue = model.WorkQueue.from(
    crossword: emptyCrossword,
    candidateWords: BuiltSet<String>(),
    startLocation: model.Location.at(0, 0),
  );

  ref.read(startTimeProvider.notifier).start();
  ref.read(endTimeProvider.notifier).clear();

  yield* wordListAsync.when(
    data: (wordList) => exploreCrosswordSolutions(
      crossword: emptyCrossword,
      wordList: wordList,
    ),
    error: (error, stackTrace) async* {
      debugPrint('Error loading word list: $error');
      yield emptyWorkQueue;
    },
    loading: () async* {
      yield emptyWorkQueue;
    },
  );

  ref.read(endTimeProvider.notifier).end();
}                                                          // To here.

@Riverpod(keepAlive: true)                                 // Add from here to end of file
class StartTime extends _$StartTime {
  @override
  DateTime? build() => _start;

  DateTime? _start;

  void start() {
    _start = DateTime.now();
    ref.invalidateSelf();
  }
}

@Riverpod(keepAlive: true)
class EndTime extends _$EndTime {
  @override
  DateTime? build() => _end;

  DateTime? _end;

  void clear() {
    _end = null;
    ref.invalidateSelf();
  }

  void end() {
    _end = DateTime.now();
    ref.invalidateSelf();
  }
}

const _estimatedTotalCoverage = 0.54;

@riverpod
Duration expectedRemainingTime(ExpectedRemainingTimeRef ref) {
  final startTime = ref.watch(startTimeProvider);
  final endTime = ref.watch(endTimeProvider);
  final workQueueAsync = ref.watch(workQueueProvider);

  return workQueueAsync.when(
    data: (workQueue) {
      if (startTime == null || endTime != null || workQueue.isCompleted) {
        return Duration.zero;
      }
      try {
        final soFar = DateTime.now().difference(startTime);
        final completedPercentage = min(
            0.99,
            (workQueue.crossword.characters.length /
                (workQueue.crossword.width * workQueue.crossword.height) /
                _estimatedTotalCoverage));
        final expectedTotal = soFar.inSeconds / completedPercentage;
        final expectedRemaining = expectedTotal - soFar.inSeconds;
        return Duration(seconds: expectedRemaining.toInt());
      } catch (e) {
        return Duration.zero;
      }
    },
    error: (error, stackTrace) => Duration.zero,
    loading: () => Duration.zero,
  );
}

/// A provider that holds whether to display info.
@Riverpod(keepAlive: true)
class ShowDisplayInfo extends _$ShowDisplayInfo {
  var _display = true;

  @override
  bool build() => _display;

  void toggle() {
    _display = !_display;
    ref.invalidateSelf();
  }
}

/// A provider that summarise the DisplayInfo from a [model.WorkQueue].
@riverpod
class DisplayInfo extends _$DisplayInfo {
  @override
  model.DisplayInfo build() => ref.watch(workQueueProvider).when(
        data: (workQueue) => model.DisplayInfo.from(workQueue: workQueue),
        error: (error, stackTrace) => model.DisplayInfo.empty,
        loading: () => model.DisplayInfo.empty,
      );
}

Bei den neuen Anbietern handelt es sich um eine Mischung aus globalen Bundesstaaten und abgeleiteten Daten wie der Laufzeit der Kreuzworträtselgenerierung. All dies wird dadurch kompliziert, dass Listener für einige dieser Status vorübergehend sind. Wenn die Informationsanzeige ausgeblendet ist, wird nichts auf die Start- und Endzeiten der Kreuzworträtselberechnung zurückgeführt, aber sie müssen im Speicher bleiben, wenn die Berechnung bei der Anzeige der Informationen präzise sein soll. Der Parameter keepAlive des Attributs Riverpod ist in diesem Fall sehr nützlich.

Die Infoanzeige zeigt eine leichte Falten. Wir möchten die Möglichkeit haben, die aktuell verstrichene Laufzeit anzuzeigen, aber es gibt hier nichts, um die ständige Aktualisierung der aktuell verstrichenen Zeit einfach zu erzwingen. Im Codelab zum Erstellen von Benutzeroberflächen der nächsten Generation in Flutter finden Sie hier ein nützliches Widget, das genau diese Anforderung erfüllt.

5. Erstellen Sie eine ticker_builder.dart-Datei im Verzeichnis lib/widgets und fügen Sie ihr folgenden Inhalt hinzu:

lib/widgets/ticker_builder.dart

import 'package:flutter/material.dart';
import 'package:flutter/scheduler.dart';

/// A Builder widget that invokes its [builder] function on every animation frame.
class TickerBuilder extends StatefulWidget {
  const TickerBuilder({super.key, required this.builder});
  final Widget Function(BuildContext context) builder;
  @override
  State<TickerBuilder> createState() => _TickerBuilderState();
}

class _TickerBuilderState extends State<TickerBuilder>
    with SingleTickerProviderStateMixin {
  late final Ticker _ticker;

  @override
  void initState() {
    super.initState();
    _ticker = createTicker(_handleTick)..start();
  }

  @override
  void dispose() {
    _ticker.dispose();
    super.dispose();
  }

  void _handleTick(Duration elapsed) {
    setState(() {
      // Force a rebuild without changing the widget tree.
    });
  }

  @override
  Widget build(BuildContext context) => widget.builder.call(context);
}

Dieses Widget ist ein Vorschlaghammer. Der Inhalt wird in jedem Frame neu erstellt. Das ist in der Regel unangenehm, aber im Vergleich zur Rechenleistung, die bei der Suche nach Kreuzworträtseln erforderlich ist, verschwindet der Rechenaufwand durch die Neuerstellung der verstrichenen Zeit für jeden Frame wahrscheinlich im Hintergrund. Um diese neu abgeleiteten Informationen nutzen zu können, ist es an der Zeit, ein neues Widget zu erstellen.

6. Erstellen Sie eine crossword_info_widget.dart-Datei in Ihrem lib/widgets-Verzeichnis und fügen Sie ihr folgenden Inhalt hinzu:

lib/widgets/crossword_info_widget.dart

class CrosswordInfoWidget extends ConsumerWidget {
  const CrosswordInfoWidget({
    super.key,
  });

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final size = ref.watch(sizeProvider);
    final displayInfo = ref.watch(displayInfoProvider);
    final startTime = ref.watch(startTimeProvider);
    final endTime = ref.watch(endTimeProvider);
    final remaining = ref.watch(expectedRemainingTimeProvider);

    return Align(
      alignment: Alignment.bottomRight,
      child: Padding(
        padding: const EdgeInsets.only(
          right: 32.0,
          bottom: 32.0,
        ),
        child: ClipRRect(
          borderRadius: BorderRadius.circular(8),
          child: ColoredBox(
            color: Theme.of(context).colorScheme.onPrimary.withAlpha(230),
            child: Padding(
              padding: const EdgeInsets.symmetric(
                horizontal: 12,
                vertical: 8,
              ),
              child: DefaultTextStyle(
                style: TextStyle(
                    fontSize: 16, color: Theme.of(context).colorScheme.primary),
                child: Column(
                  mainAxisSize: MainAxisSize.min,
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    _CrosswordInfoRichText(
                        label: 'Grid Size',
                        value: '${size.width} x ${size.height}'),
                    _CrosswordInfoRichText(
                        label: 'Words in grid',
                        value: displayInfo.wordsInGridCount),
                    _CrosswordInfoRichText(
                        label: 'Candidate words',
                        value: displayInfo.candidateWordsCount),
                    _CrosswordInfoRichText(
                        label: 'Locations to explore',
                        value: displayInfo.locationsToExploreCount),
                    _CrosswordInfoRichText(
                        label: 'Known bad locations',
                        value: displayInfo.knownBadLocationsCount),
                    _CrosswordInfoRichText(
                        label: 'Grid filled',
                        value: displayInfo.gridFilledPercentage),
                    switch ((startTime, endTime)) {
                      (null, _) => _CrosswordInfoRichText(
                          label: 'Time elapsed',
                          value: 'Not started yet',
                        ),
                      (DateTime start, null) => TickerBuilder(
                          builder: (context) => _CrosswordInfoRichText(
                            label: 'Time elapsed',
                            value: DateTime.now().difference(start).formatted,
                          ),
                        ),
                      (DateTime start, DateTime end) => _CrosswordInfoRichText(
                          label: 'Completed in',
                          value: end.difference(start).formatted),
                    },
                    if (startTime != null && endTime == null)
                      _CrosswordInfoRichText(
                          label: 'Est. remaining', value: remaining.formatted),
                  ],
                ),
              ),
            ),
          ),
        ),
      ),
    );
  }
}

class _CrosswordInfoRichText extends StatelessWidget {
  final String label;
  final String value;

  const _CrosswordInfoRichText({required this.label, required this.value});

  @override
  Widget build(BuildContext context) => RichText(
        text: TextSpan(
          children: [
            TextSpan(
              text: '$label ',
              style: DefaultTextStyle.of(context).style,
            ),
            TextSpan(
              text: value,
              style: DefaultTextStyle.of(context)
                  .style
                  .copyWith(fontWeight: FontWeight.bold),
            ),
          ],
        ),
      );
}

Dieses Widget ist ein hervorragendes Beispiel für die Möglichkeiten der Anbieter von Riverpod. Dieses Widget wird für die Neuerstellung markiert, sobald einer der fünf Anbieter aktualisiert wird. Die letzte erforderliche Änderung in diesem Schritt ist die Integration dieses neuen Widgets in die Benutzeroberfläche.

7. Bearbeiten Sie die Datei crossword_generator_app.dart so:

lib/widgets/crossword_generator_app.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

import '../providers.dart';
import 'crossword_info_widget.dart';                       // Add this import
import 'crossword_widget.dart';

class CrosswordGeneratorApp extends StatelessWidget {
  const CrosswordGeneratorApp({super.key});

  @override
  Widget build(BuildContext context) {
    return _EagerInitialization(
      child: Scaffold(
        appBar: AppBar(
          actions: [_CrosswordGeneratorMenu()],
          titleTextStyle: TextStyle(
            color: Theme.of(context).colorScheme.primary,
            fontSize: 16,
            fontWeight: FontWeight.bold,
          ),
          title: Text('Crossword Generator'),
        ),
        body: SafeArea(
          child: Consumer(                                 // Modify from here
            builder: (context, ref, child) {
              return Stack(
                children: [
                  Positioned.fill(
                    child: CrosswordWidget(),
                  ),
                  if (ref.watch(showDisplayInfoProvider)) CrosswordInfoWidget(),
                ],
              );
            },
          ),                                               // To here.
        ),
      ),
    );
  }
}

class _EagerInitialization extends ConsumerWidget {
  const _EagerInitialization({required this.child});
  final Widget child;

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    ref.watch(wordListProvider);
    return child;
  }
}

class _CrosswordGeneratorMenu extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) => MenuAnchor(
        menu Children: [
          for (final entry in CrosswordSize.values)
            MenuItemButton(
              onPressed: () => ref.read(sizeProvider.notifier).setSize(entry),
              leadingIcon: entry == ref.watch(sizeProvider)
                  ? Icon(Icons.radio_button_checked_outlined)
                  : Icon(Icons.radio_button_unchecked_outlined),
              child: Text(entry.label),
            ),
          MenuItemButton(                                  // Add from here
            leadingIcon: ref.watch(showDisplayInfoProvider)
                ? Icon(Icons.check_box_outlined)
                : Icon(Icons.check_box_outline_blank_outlined),
            onPressed: () =>
                ref.read(showDisplayInfoProvider.notifier).toggle(),
            child: Text('Display Info'),
          ),                                               // To here.
        ],
        builder: (context, controller, child) => IconButton(
          onPressed: () => controller.open(),
          icon: Icon(Icons.settings),
        ),
      );
}

Die beiden hier dargestellten Änderungen zeigen unterschiedliche Ansätze für die Integration von Anbietern. In der Methode build der CrosswordGeneratorApp haben Sie einen neuen Consumer-Builder eingeführt, der den Bereich enthält, der neu erstellt werden muss, wenn die Infoanzeige ein- oder ausgeblendet wird. Das gesamte Drop-down-Menü hingegen besteht aus einem ConsumerWidget, das neu aufgebaut wird, unabhängig davon, ob es sich um die Größenänderung des Kreuzworträtsels oder das Ein- oder Ausblenden der Infoanzeige handelt. Welcher Ansatz zu wählen ist, bedeutet immer einen Kompromiss zwischen der Einfachheit und den Kosten der Neuberechnung von Layouts von neu erstellten Widget-Bäumen.

Wenn die App jetzt ausgeführt wird, erhalten Nutzer einen besseren Einblick in den Fortschritt der Kreuzworträtselgenerierung. Gegen Ende der Kreuzworträtsel-Generation ändern sich die Zahlen immer wieder, aber nur sehr wenige Änderungen am Zeichenraster.

Es wäre hilfreich, zusätzliche Erkenntnisse darüber zu erhalten, was passiert und warum.

8. Mit Threads parallelisieren

Um zu verstehen, warum die Dinge am Ende langsam werden, ist es hilfreich, die Leistung des Algorithmus zu visualisieren. Ein wichtiger Teil sind die ausstehenden locationsToTry in der WorkQueue. Die Tabellenansicht bietet uns eine hilfreiche Methode, dies zu untersuchen. Wir können die Zellenfarbe ändern, je nachdem, ob sie sich in locationsToTry befindet.

Führen Sie zunächst die folgenden Schritte aus:

1. Ändern Sie die Datei crossword_widget.dart so:

lib/widgets/crossword_widget.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:two_dimensional_scrollables/two_dimensional_scrollables.dart';

import '../model.dart';
import '../providers.dart';

class CrosswordWidget extends ConsumerWidget {
  const CrosswordWidget({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final size = ref.watch(sizeProvider);
    return TableView.builder(
      diagonalDragBehavior: DiagonalDragBehavior.free,
      cellBuilder: _buildCell,
      columnCount: size.width,
      columnBuilder: (index) => _buildSpan(context, index),
      rowCount: size.height,
      rowBuilder: (index) => _buildSpan(context, index),
    );
  }

  TableViewCell _buildCell(BuildContext context, TableVicinity vicinity) {
    final location = Location.at(vicinity.column, vicinity.row);

    return TableViewCell(
      child: Consumer(
        builder: (context, ref, _) {
          final character = ref.watch(
            workQueueProvider.select(
              (workQueueAsync) => workQueueAsync.when(
                data: (workQueue) => workQueue.crossword.characters[location],
                error: (error, stackTrace) => null,
                loading: () => null,
              ),
            ),
          );

          final explorationCell = ref.watch(               // Add from here
            workQueueProvider.select(
              (workQueueAsync) => workQueueAsync.when(
                data: (workQueue) =>
                    workQueue.locationsToTry.keys.contains(location),
                error: (error, stackTrace) => false,
                loading: () => false,
              ),
            ),
          );                                               // To here.

          if (character != null) {                         // Modify from here
            return AnimatedContainer(
              duration: Durations.extralong1,
              curve: Curves.easeInOut,
              color: explorationCell
                  ? Theme.of(context).colorScheme.primary
                  : Theme.of(context).colorScheme.onPrimary,
              child: Center(
                child: AnimatedDefaultTextStyle(
                  duration: Durations.extralong1,
                  curve: Curves.easeInOut,
                  style: TextStyle(
                    fontSize: 24,
                    color: explorationCell
                        ? Theme.of(context).colorScheme.onPrimary
                        : Theme.of(context).colorScheme.primary,
                  ),
                  child: Text(character.character),
                ),                                          // To here.
              ),
            );
          }

          return ColoredBox(
            color: Theme.of(context).colorScheme.primaryContainer,
          );
        },
      ),
    );
  }

  TableSpan _buildSpan(BuildContext context, int index) {
    return TableSpan(
      extent: FixedTableSpanExtent(32),
      foregroundDecoration: TableSpanDecoration(
        border: TableSpanBorder(
          leading: BorderSide(
              color: Theme.of(context).colorScheme.onPrimaryContainer),
          trailing: BorderSide(
              color: Theme.of(context).colorScheme.onPrimaryContainer),
        ),
      ),
    );
  }
}

Wenn Sie diesen Code ausführen, sehen Sie eine Visualisierung der ausstehenden Standorte, die vom Algorithmus noch untersucht werden müssen.

Das Interessante dabei ist, das Kreuzworträtsel näher zu beobachten: Es gibt noch eine Reihe von Punkten, die untersucht werden müssen und die nichts Nützliches bringen. Dafür gibt es mehrere Möglichkeiten: Erstens: die Untersuchung begrenzen, sobald ein bestimmter Prozentsatz der Kreuzworträtsel-Zellen ausgefüllt ist, und die zweite darin, mehrere POIs gleichzeitig zu untersuchen. Der zweite Pfad klingt besser, also machen wir das.

2. Bearbeiten Sie die Datei isolates.dart. Dies ist eine fast vollständige Neuschreibung des Codes, um das, was in einem Hintergrundisolation berechnet wurde, in einen Pool von N Hintergrundisolierungen aufzuteilen.

lib/isolates.dart

import 'package:built_collection/built_collection.dart';
import 'package:characters/characters.dart';
import 'package:flutter/foundation.dart';

import 'model.dart';
import 'utils.dart';

Stream<WorkQueue> exploreCrosswordSolutions({
  required Crossword crossword,
  required BuiltSet<String> wordList,
  required int maxWorkerCount,
}) async* {
  final start = DateTime.now();
  var workQueue = WorkQueue.from(
    crossword: crossword,
    candidateWords: wordList,
    startLocation: Location.at(0, 0),
  );
  while (!workQueue.isCompleted) {
    try {
      workQueue = await compute(_generate, (workQueue, maxWorkerCount));
      yield workQueue;
    } catch (e) {
      debugPrint('Error running isolate: $e');
    }
  }

  debugPrint('Generated ${workQueue.crossword.width} x '
      '${workQueue.crossword.height} crossword in '
      '${DateTime.now().difference(start).formatted} '
      'with $maxWorkerCount workers.');
}

Future<WorkQueue> _generate((WorkQueue, int) workMessage) async {
  var (workQueue, maxWorkerCount) = workMessage;
  final candidateGeneratorFutures = <Future<(Location, Direction, String?)>>[];
  final locations = workQueue.locationsToTry.keys.toBuiltList().rebuild((b) => b
    ..shuffle()
    ..take(maxWorkerCount));

  for (final location in locations) {
    final direction = workQueue.locationsToTry[location]!;

    candidateGeneratorFutures.add(compute(_generateCandidate,
        (workQueue.crossword, workQueue.candidateWords, location, direction)));
  }

  try {
    final results = await candidateGeneratorFutures.wait;
    var crossword = workQueue.crossword;
    for (final (location, direction, word) in results) {
      if (word != null) {
        final candidate = crossword.addWord(
            location: location, word: word, direction: direction);
        if (candidate != null) {
          crossword = candidate;
        }
      } else {
        workQueue = workQueue.remove(location);
      }
    }

    workQueue = workQueue.updateFrom(crossword);
  } catch (e) {
    debugPrint('$e');
  }

  return workQueue;
}

(Location, Direction, String?) _generateCandidate(
    (Crossword, BuiltSet<String>, Location, Direction) searchDetailMessage) {
  final (crossword, candidateWords, location, direction) = searchDetailMessage;

  final target = crossword.characters[location];
  if (target == null) {
    return (location, direction, candidateWords.randomElement());
  }

  // Filter down the candidate word list to those that contain the letter
  // at the current location
  final words = candidateWords.toBuiltList().rebuild((b) => b
    ..where((b) => b.characters.contains(target.character))
    ..shuffle());
  int tryCount = 0;
  final start = DateTime.now();
  for (final word in words) {
    tryCount++;
    for (final (index, character) in word.characters.indexed) {
      if (character != target.character) continue;

      final candidate = crossword.addWord(
        location: switch (direction) {
          Direction.across => location.leftOffset(index),
          Direction.down => location.upOffset(index),
        },
        word: word,
        direction: direction,
      );
      if (candidate != null) {
        return switch (direction) {
          Direction.across => (location.leftOffset(index), direction, word),
          Direction.down => (location.upOffset(index), direction, word),
        };
      }
      final deltaTime = DateTime.now().difference(start);
      if (tryCount >= 1000 || deltaTime > Duration(seconds: 10)) {
        return (location, direction, null);
      }
    }
  }

  return (location, direction, null);
}

Der größte Teil dieses Codes sollte vertraut sein, da sich die zentrale Geschäftslogik nicht geändert hat. Was sich geändert hat, ist, dass es jetzt zwei Ebenen von compute-Aufrufen gibt. Die erste Ebene ist für das Aussortieren einzelner Positionen zuständig, um nach N Worker-Isolationen zu suchen und die Ergebnisse anschließend neu zu kombinieren, wenn alle N Worker-Isolationen abgeschlossen sind. Die zweite Schicht besteht aus den N-Worker-Isolationen. Die Feinabstimmung N zum Erzielen der besten Leistung hängt sowohl von Ihrem Computer als auch von den betreffenden Daten ab. Je größer das Raster, desto mehr Arbeiter können zusammenarbeiten, ohne sich gegenseitig zu stören.

Eine interessante Fälschung besteht darin, dass dieser Code nun das Problem von Schließungen handhabt, in denen Dinge erfasst werden, die nicht erfasst werden sollten. Es gibt jetzt keine Schließungen. Die Funktionen _generate und _generateWorker sind als Funktionen der obersten Ebene definiert, die keine Umgebung haben, aus der sie erfasst werden können. Die Argumente in und die Ergebnisse dieser beiden Funktionen liegen in Form von Dart-Datensätzen vor. Auf diese Weise lässt sich die Semantik des compute-Aufrufs einfach umgehen.

Sie haben jetzt die Möglichkeit, einen Pool von Hintergrund-Workern zu erstellen, um nach Wörtern zu suchen, die sich in einem Raster zu einem Kreuzworträtsel verstecken. Jetzt ist es an der Zeit, diese Funktion dem Rest des Kreuzworträtsel-Generators zur Verfügung zu stellen.

3. Bearbeiten Sie die Datei providers.dart, indem Sie den WorkQueue-Anbieter so bearbeiten:

lib/providers.dart

@riverpod
Stream<model.WorkQueue> workQueue(WorkQueueRef ref) async* {
  final workers = ref.watch(workerCountProvider);          // Add this line
  final size = ref.watch(sizeProvider);
  final wordListAsync = ref.watch(wordListProvider);
  final emptyCrossword =
      model.Crossword.crossword(width: size.width, height: size.height);
  final emptyWorkQueue = model.WorkQueue.from(
    crossword: emptyCrossword,
    candidateWords: BuiltSet<String>(),
    startLocation: model.Location.at(0, 0),
  );

  ref.read(startTimeProvider.notifier).start();
  ref.read(endTimeProvider.notifier).clear();

  yield* wordListAsync.when(
    data: (wordList) => exploreCrosswordSolutions(
      crossword: emptyCrossword,
      wordList: wordList,
      maxWorkerCount: workers.count,                       // Add this line
    ),
    error: (error, stackTrace) async* {
      debugPrint('Error loading word list: $error');
      yield emptyWorkQueue;
    },
    loading: () async* {
      yield emptyWorkQueue;
    },
  );

  ref.read(endTimeProvider.notifier).end();
}

4. Fügen Sie den Anbieter WorkerCount am Ende der Datei so hinzu:

lib/providers.dart

/// A provider that summarise the DisplayInfo from a [model.WorkQueue].
@riverpod
class DisplayInfo extends _$DisplayInfo {
  @override
  model.DisplayInfo build() => ref.watch(workQueueProvider).when(
        data: (workQueue) => model.DisplayInfo.from(workQueue: workQueue),
        error: (error, stackTrace) => model.DisplayInfo.empty,
        loading: () => model.DisplayInfo.empty,
      );
}

enum BackgroundWorkers {                                   // Add from here 
  one(1),
  two(2),
  four(4),
  eight(8),
  sixteen(16),
  thirtyTwo(32),
  sixtyFour(64),
  oneTwentyEight(128);

  const BackgroundWorkers(this.count);

  final int count;
  String get label => count.toString();
}

/// A provider that holds the current number of background workers to use.
@Riverpod(keepAlive: true)
class WorkerCount extends _$WorkerCount {
  var _count = BackgroundWorkers.four;

  @override
  BackgroundWorkers build() => _count;

  void setCount(BackgroundWorkers count) {
    _count = count;
    ref.invalidateSelf();
  }
}                                                          // To here.

Mit diesen beiden Änderungen bietet die Anbieterebene jetzt eine Möglichkeit, die maximale Worker-Anzahl für den Hintergrundisolierungspool so festzulegen, dass die Isolationsfunktionen korrekt konfiguriert sind.

5. Aktualisieren Sie die Datei crossword_info_widget.dart, indem Sie das CrosswordInfoWidget so ändern:

lib/widgets/crossword_info_widget.dart

class CrosswordInfoWidget extends ConsumerWidget {
  const CrosswordInfoWidget({
    super.key,
  });

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final size = ref.watch(sizeProvider);
    final displayInfo = ref.watch(displayInfoProvider);
    final workerCount = ref.watch(workerCountProvider).label;  // Add this line
    final startTime = ref.watch(startTimeProvider);
    final endTime = ref.watch(endTimeProvider);
    final remaining = ref.watch(expectedRemainingTimeProvider);

    return Align(
      alignment: Alignment.bottomRight,
      child: Padding(
        padding: const EdgeInsets.only(
          right: 32.0,
          bottom: 32.0,
        ),
        child: ClipRRect(
          borderRadius: BorderRadius.circular(8),
          child: ColoredBox(
            color: Theme.of(context).colorScheme.onPrimary.withAlpha(230),
            child: Padding(
              padding: const EdgeInsets.symmetric(
                horizontal: 12,
                vertical: 8,
              ),
              child: DefaultTextStyle(
                style: TextStyle(
                    fontSize: 16, color: Theme.of(context).colorScheme.primary),
                child: Column(
                  mainAxisSize: MainAxisSize.min,
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    _CrosswordInfoRichText(
                        label: 'Grid Size',
                        value: '${size.width} x ${size.height}'),
                    _CrosswordInfoRichText(
                        label: 'Words in grid',
                        value: displayInfo.wordsInGridCount),
                    _CrosswordInfoRichText(
                        label: 'Candidate words',
                        value: displayInfo.candidateWordsCount),
                    _CrosswordInfoRichText(
                        label: 'Locations to explore',
                        value: displayInfo.locationsToExploreCount),
                    _CrosswordInfoRichText(
                        label: 'Known bad locations',
                        value: displayInfo.knownBadLocationsCount),
                    _CrosswordInfoRichText(
                        label: 'Grid filled',
                        value: displayInfo.gridFilledPercentage),
                    _CrosswordInfoRichText(               // Add these two lines
                        label: 'Max worker count', value: workerCount),
                    switch ((startTime, endTime)) {
                      (null, _) => _CrosswordInfoRichText(
                          label: 'Time elapsed',
                          value: 'Not started yet',
                        ),
                      (DateTime start, null) => TickerBuilder(
                          builder: (context) => _CrosswordInfoRichText(
                            label: 'Time elapsed',
                            value: DateTime.now().difference(start).formatted,
                          ),
                        ),
                      (DateTime start, DateTime end) => _CrosswordInfoRichText(
                          label: 'Completed in',
                          value: end.difference(start).formatted),
                    },
                    if (startTime != null && endTime == null)
                      _CrosswordInfoRichText(
                          label: 'Est. remaining', value: remaining.formatted),
                  ],
                ),
              ),
            ),
          ),
        ),
      ),
    );
  }
}

6. Ändern Sie die Datei crossword_generator_app.dart, indem Sie dem _CrosswordGeneratorMenu-Widget den folgenden Abschnitt hinzufügen:

lib/widgets/crossword_generator_app.dart

class _CrosswordGeneratorMenu extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) => MenuAnchor(
        menuChildren: [
          for (final entry in CrosswordSize.values)
            MenuItemButton(
              onPressed: () => ref.read(sizeProvider.notifier).setSize(entry),
              leadingIcon: entry == ref.watch(sizeProvider)
                  ? Icon(Icons.radio_button_checked_outlined)
                  : Icon(Icons.radio_button_unchecked_outlined),
              child: Text(entry.label),
            ),
          MenuItemButton(
            leadingIcon: ref.watch(showDisplayInfoProvider)
                ? Icon(Icons.check_box_outlined)
                : Icon(Icons.check_box_outline_blank_outlined),
            onPressed: () =>
                ref.read(showDisplayInfoProvider.notifier).toggle(),
            child: Text('Display Info'),
          ),
          for (final count in BackgroundWorkers.values)    // Add from here
            MenuItemButton(
              leadingIcon: count == ref.watch(workerCountProvider)
                  ? Icon(Icons.radio_button_checked_outlined)
                  : Icon(Icons.radio_button_unchecked_outlined),
              onPressed: () =>
                  ref.read(workerCountProvider.notifier).setCount(count),
              child: Text(count.label),                    // To here.
            ),
        ],
        builder: (context, controller, child) => IconButton(
          onPressed: () => controller.open(),
          icon: Icon(Icons.settings),
        ),
      );
}

Wenn Sie die App jetzt ausführen, können Sie die Anzahl der instanziierten Hintergrundisolation ändern, um nach Wörtern zu suchen, die in das Kreuzworträtsel eingefügt werden.

7. Klicken Sie auf das Zahnradsymbol im , um das Kontextmenü mit der Größenanpassung für das Kreuzworträtsel, zwischen den Statistiken für das aktuell generierte Kreuzworträtsel und der Anzahl der zu verwendenden Isolierungen zu öffnen.

Durch die Ausführung des Kreuzworträtsels konnte die Rechenzeit für ein Kreuzworträtsel der Größe 80 x 44 erheblich reduziert werden, da mehrere Kerne gleichzeitig genutzt werden.

9. In ein Spiel verwandeln

Dieser letzte Abschnitt ist wirklich eine Bonusrunde. Sie wenden alle Techniken an, die Sie beim Erstellen des Kreuzworträtsel-Generators gelernt haben, und wenden diese Techniken an, um ein Spiel zu entwickeln. Sie verwenden den Kreuzworträtsel-Generator, um ein Kreuzworträtsel zu erstellen. Sie verwenden die Bezeichnungen des Kontextmenüs wieder, damit Nutzende Wörter auswählen und die Auswahl aufheben können, um die verschiedenen wortförmigen Löcher im Raster zu platzieren. Und das alles mit dem Ziel, das Kreuzworträtsel zu vervollständigen.

Ich werde nicht sagen, dass das Spiel ausgefeilt oder fertig ist, es ist alles andere als das. Es gibt Gleichgewichts- und Schwierigkeitsprobleme, die durch eine bessere Auswahl der alternativen Wörter gelöst werden können. Es gibt kein Tutorial, in das die Nutzenden eingeleitet werden können, und die Denkanimation lässt viel zu wünschen übrig. Ich werde noch gar nicht erst den Grundstein für „Du hast gewonnen!“ erwähnen. Bildschirm.

Der Nachteil ist hier, dass für die richtige Ausarbeitung dieses Proto-Spiels deutlich mehr Code erforderlich ist. Mehr Code, als in einem einzelnen Codelab vorhanden sein sollten. Stattdessen ist dies ein Schritt zur Geschwindigkeitsausführung, der entwickelt wurde, um die bisher in diesem Codelab erlernten Techniken zu festigen, indem geändert wird, wo und wie sie verwendet werden. Wir hoffen, dass wir dadurch die in diesem Codelab Gelernten untermauern. Alternativ können Sie auf der Grundlage dieses Codes Ihre eigenen Erfahrungen erstellen. Wir würden uns freuen, zu sehen, was Sie daraus machen!

Führen Sie zunächst die folgenden Schritte aus:

1. Löschen Sie alles im Verzeichnis lib/widgets. Sie erstellen brandneue Widgets für Ihr Spiel. Das hat einfach zu viel von den alten Widgets übernommen.
2. Bearbeiten Sie die Datei model.dart, um die addWord-Methode von Crossword so zu aktualisieren:

lib/model.dart

  /// Add a word to the crossword at the given location and direction.
  Crossword? addWord({
    required Location location,
    required String word,
    required Direction direction,
    bool requireOverlap = true,                            // Add this parameter
  }) {
    // Require that the word is not already in the crossword.
    if (words.map((crosswordWord) => crosswordWord.word).contains(word)) {
      return null;
    }

    final wordCharacters = word.characters;
    bool overlap = false;

    // Check that the word fits in the crossword.
    for (final (index, character) in wordCharacters.indexed) {
      final characterLocation = switch (direction) {
        Direction.across => location.rightOffset(index),
        Direction.down => location.downOffset(index),
      };

      final target = characters[characterLocation];
      if (target != null) {
        overlap = true;
        if (target.character != character) {
          return null;
        }
        if (direction == Direction.across && target.acrossWord != null ||
            direction == Direction.down && target.downWord != null) {
          return null;
        }
      }
    }
                                                           // Edit from here
    // If overlap is required, make sure that the word overlaps with an existing
    // word. Skip this test if the crossword is empty.
    if (words.isNotEmpty && !overlap && requireOverlap) {  // To here.
      return null;
    }

    final candidate = rebuild(
      (b) => b
        ..words.add(
          CrosswordWord.word(
            word: word,
            direction: direction,
            location: location,
          ),
        ),
    );

    if (candidate.valid) {
      return candidate;
    } else {
      return null;
    }
  }

Durch diese geringfügige Änderung Ihres Kreuzworträtsel-Modells können Wörter hinzugefügt werden, die sich nicht überschneiden. Spieler sollten überall auf einem Spielfeld spielen und dabei Crossword als Basismodell verwenden können, um ihre Züge zu speichern. Es handelt sich lediglich um eine Liste von Wörtern an bestimmten Stellen in einer bestimmten Richtung.

3. Fügen Sie die Modellklasse CrosswordPuzzleGame am Ende der Datei model.dart hinzu.

lib/model.dart

/// Creates a puzzle from a crossword and a set of candidate words.
abstract class CrosswordPuzzleGame
    implements Built<CrosswordPuzzleGame, CrosswordPuzzleGameBuilder> {
  static Serializer<CrosswordPuzzleGame> get serializer =>
      _$crosswordPuzzleGameSerializer;

  /// The [Crossword] that this puzzle is based on.
  Crossword get crossword;

  /// The alternate words for each [CrosswordWord] in the crossword.
  BuiltMap<Location, BuiltMap<Direction, BuiltList<String>>> get alternateWords;

  /// The player's selected words.
  BuiltList<CrosswordWord> get selectedWords;

  bool canSelectWord({
    required Location location,
    required String word,
    required Direction direction,
  }) {
    final crosswordWord = CrosswordWord.word(
      word: word,
      location: location,
      direction: direction,
    );

    if (selectedWords.contains(crosswordWord)) {
      return true;
    }

    var puzzle = this;

    if (puzzle.selectedWords
        .where((b) => b.direction == direction && b.location == location)
        .isNotEmpty) {
      puzzle = puzzle.rebuild((b) => b
        ..selectedWords.removeWhere(
          (selectedWord) =>
              selectedWord.location == location &&
              selectedWord.direction == direction,
        ));
    }

    return null !=
        puzzle.crosswordFromSelectedWords.addWord(
            location: location,
            word: word,
            direction: direction,
            requireOverlap: false);
  }

  CrosswordPuzzleGame? selectWord({
    required Location location,
    required String word,
    required Direction direction,
  }) {
    final crosswordWord = CrosswordWord.word(
      word: word,
      location: location,
      direction: direction,
    );

    if (selectedWords.contains(crosswordWord)) {
      return rebuild((b) => b.selectedWords.remove(crosswordWord));
    }

    var puzzle = this;

    if (puzzle.selectedWords
        .where((b) => b.direction == direction && b.location == location)
        .isNotEmpty) {
      puzzle = puzzle.rebuild((b) => b
        ..selectedWords.removeWhere(
          (selectedWord) =>
              selectedWord.location == location &&
              selectedWord.direction == direction,
        ));
    }

    // Check if the selected word meshes with the already selected words.
    // Note this version of the crossword does not enforce overlap to
    // allow the player to select words anywhere on the grid. Enforcing words
    // to be solved in order is a possible alternative.
    final updatedSelectedWordsCrossword =
        puzzle.crosswordFromSelectedWords.addWord(
      location: location,
      word: word,
      direction: direction,
      requireOverlap: false,
    );

    // Make sure the selected word is in the crossword or is an alternate word.
    if (updatedSelectedWordsCrossword != null) {
      if (puzzle.crossword.words.contains(crosswordWord) ||
          puzzle.alternateWords[location]?[direction]?.contains(word) == true) {
        return puzzle.rebuild((b) => b
          ..selectedWords.add(CrosswordWord.word(
              word: word, location: location, direction: direction)));
      }
    }
    return null;
  }

  /// The crossword from the selected words.
  Crossword get crosswordFromSelectedWords => Crossword.crossword(
      width: crossword.width, height: crossword.height, words: selectedWords);

  /// Test if the puzzle is solved. Note, this allows for the possibility of
  /// multiple solutions.
  bool get solved =>
      crosswordFromSelectedWords.valid &&
      crosswordFromSelectedWords.words.length == crossword.words.length &&
      crossword.words.isNotEmpty;

  /// Create a crossword puzzle game from a crossword and a set of candidate
  /// words.
  factory CrosswordPuzzleGame.from({
    required Crossword crossword,
    required BuiltSet<String> candidateWords,
  }) {
    // Remove all of the currently used words from the list of candidates
    candidateWords = candidateWords
        .rebuild((p0) => p0.removeAll(crossword.words.map((p1) => p1.word)));

    // This is the list of alternate words for each word in the crossword
    var alternates =
        BuiltMap<Location, BuiltMap<Direction, BuiltList<String>>>();

    // Build the alternate words for each word in the crossword
    for (final crosswordWord in crossword.words) {
      final alternateWords = candidateWords.toBuiltList().rebuild((b) => b
        ..where((b) => b.length == crosswordWord.word.length)
        ..shuffle()
        ..take(4)
        ..sort());

      candidateWords =
          candidateWords.rebuild((b) => b.removeAll(alternateWords));

      alternates = alternates.rebuild(
        (b) => b.updateValue(
          crosswordWord.location,
          (b) => b.rebuild(
            (b) => b.updateValue(
              crosswordWord.direction,
              (b) => b.rebuild((b) => b.replace(alternateWords)),
              ifAbsent: () => alternateWords,
            ),
          ),
          ifAbsent: () => {crosswordWord.direction: alternateWords}.build(),
        ),
      );
    }

    return CrosswordPuzzleGame((b) {
      b
        ..crossword.replace(crossword)
        ..alternateWords.replace(alternates);
    });
  }

  factory CrosswordPuzzleGame(
          [void Function(CrosswordPuzzleGameBuilder)? updates]) =
      _$CrosswordPuzzleGame;
  CrosswordPuzzleGame._();
}

/// Construct the serialization/deserialization code for the data model.
@SerializersFor([
  Location,
  Crossword,
  CrosswordWord,
  CrosswordCharacter,
  WorkQueue,
  DisplayInfo,
  CrosswordPuzzleGame,                                     // Add this line
])
final Serializers serializers = _$serializers;

Die Aktualisierungen an der Datei providers.dart sind eine interessante Fülle an Änderungen. Die meisten Anbieter, die für die Erfassung von Statistiken zur Verfügung standen, wurden entfernt. Die Möglichkeit, die Anzahl der Hintergrundisolierungen zu ändern, wurde entfernt und durch eine Konstante ersetzt. Es gibt auch einen neuen Anbieter, der Zugriff auf das neue CrosswordPuzzleGame-Modell gewährt, das Sie gerade hinzugefügt haben.

lib/providers.dart

import 'dart:convert';
                                                           // Drop the dart:math import

import 'package:built_collection/built_collection.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';

import 'isolates.dart';
import 'model.dart' as model;

part 'providers.g.dart';

const backgroundWorkerCount = 4;                           // Add this line

/// A provider for the wordlist to use when generating the crossword.
@riverpod
Future<BuiltSet<String>> wordList(WordListRef ref) async {
  // This codebase requires that all words consist of lowercase characters
  // in the range 'a'-'z'. Words containing uppercase letters will be
  // lowercased, and words containing runes outside this range will
  // be removed.

  final re = RegExp(r'^[a-z]+$');
  final words = await rootBundle.loadString('assets/words.txt');
  return const LineSplitter().convert(words).toBuiltSet().rebuild((b) => b
    ..map((word) => word.toLowerCase().trim())
    ..where((word) => word.length > 2)
    ..where((word) => re.hasMatch(word)));
}

/// An enumeration for different sizes of [model.Crossword]s.
enum CrosswordSize {
  small(width: 20, height: 11),
  medium(width: 40, height: 22),
  large(width: 80, height: 44),
  xlarge(width: 160, height: 88),
  xxlarge(width: 500, height: 500);

  const CrosswordSize({
    required this.width,
    required this.height,
  });

  final int width;
  final int height;
  String get label => '$width x $height';
}

/// A provider that holds the current size of the crossword to generate.
@Riverpod(keepAlive: true)
class Size extends _$Size {
  var _size = CrosswordSize.medium;

  @override
  CrosswordSize build() => _size;

  void setSize(CrosswordSize size) {
    _size = size;
    ref.invalidateSelf();
  }
}

@riverpod
Stream<model.WorkQueue> workQueue(WorkQueueRef ref) async* {
  final size = ref.watch(sizeProvider);                   // Drop the ref.watch(workerCountProvider)
  final wordListAsync = ref.watch(wordListProvider);
  final emptyCrossword =
      model.Crossword.crossword(width: size.width, height: size.height);
  final emptyWorkQueue = model.WorkQueue.from(
    crossword: emptyCrossword,
    candidateWords: BuiltSet<String>(),
    startLocation: model.Location.at(0, 0),
  );
                                                          // Drop the startTimeProvider and endTimeProvider refs
  yield* wordListAsync.when(
    data: (wordList) => exploreCrosswordSolutions(
      crossword: emptyCrossword,
      wordList: wordList,
      maxWorkerCount: backgroundWorkerCount,              // Edit this line
    ),
    error: (error, stackTrace) async* {
      debugPrint('Error loading word list: $error');
      yield emptyWorkQueue;
    },
    loading: () async* {
      yield emptyWorkQueue;
    },
  );
}                                                         // Drop the endTimeProvider ref

@riverpod                                                 // Add from here to end of file
class Puzzle extends _$Puzzle {
  model.CrosswordPuzzleGame _puzzle = model.CrosswordPuzzleGame.from(
    crossword: model.Crossword.crossword(width: 0, height: 0),
    candidateWords: BuiltSet<String>(),
  );

  @override
  model.CrosswordPuzzleGame build() {
    final size = ref.watch(sizeProvider);
    final wordList = ref.watch(wordListProvider).value;
    final workQueue = ref.watch(workQueueProvider).value;

    if (wordList != null &&
        workQueue != null &&
        workQueue.isCompleted &&
        (_puzzle.crossword.height != size.height ||
            _puzzle.crossword.width != size.width ||
            _puzzle.crossword != workQueue.crossword)) {
      compute(_puzzleFromCrosswordTrampoline, (workQueue.crossword, wordList))
          .then((puzzle) {
        _puzzle = puzzle;
        ref.invalidateSelf();
      });
    }

    return _puzzle;
  }

  Future<void> selectWord({
    required model.Location location,
    required String word,
    required model.Direction direction,
  }) async {
    final candidate = await compute(
        _puzzleSelectWordTrampoline, (_puzzle, location, word, direction));

    if (candidate != null) {
      _puzzle = candidate;
      ref.invalidateSelf();
    } else {
      debugPrint('Invalid word selection: $word');
    }
  }

  bool canSelectWord({
    required model.Location location,
    required String word,
    required model.Direction direction,
  }) {
    return _puzzle.canSelectWord(
      location: location,
      word: word,
      direction: direction,
    );
  }
}

// Trampoline functions to disentangle these Isolate target calls from the
// unsendable reference to the [Puzzle] provider.

Future<model.CrosswordPuzzleGame> _puzzleFromCrosswordTrampoline(
        (model.Crossword, BuiltSet<String>) args) async =>
    model.CrosswordPuzzleGame.from(crossword: args.$1, candidateWords: args.$2);

model.CrosswordPuzzleGame? _puzzleSelectWordTrampoline(
        (
          model.CrosswordPuzzleGame,
          model.Location,
          String,
          model.Direction
        ) args) =>
    args.$1.selectWord(location: args.$2, word: args.$3, direction: args.$4);

Die interessantesten Aspekte des Puzzle-Anbieters sind die Strategien, mit denen die Kosten für die Erstellung der CrosswordPuzzleGame aus einem Crossword und einem wordList sowie die Kosten für die Auswahl eines Wortes berücksichtigt werden. Beide Aktionen, die ohne die Hintergrundisolierung erfolgen, verursachen eine langsame UI-Interaktion. Wenn Sie mit wenig Hand alles erledigen, um ein Zwischenergebnis herauszugeben, während das Endergebnis im Hintergrund berechnet wird, erhalten Sie eine reaktionsschnelle Benutzeroberfläche, während die erforderlichen Berechnungen im Hintergrund ausgeführt werden.

4. Erstellen Sie im jetzt leeren Verzeichnis lib/widgets eine crossword_puzzle_app.dart-Datei mit folgendem Inhalt:

lib/widgets/crossword_puzzle_app.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

import '../providers.dart';
import 'crossword_generator_widget.dart';
import 'crossword_puzzle_widget.dart';
import 'puzzle_completed_widget.dart';

class CrosswordPuzzleApp extends StatelessWidget {
  const CrosswordPuzzleApp({super.key});

  @override
  Widget build(BuildContext context) {
    return _EagerInitialization(
      child: Scaffold(
        appBar: AppBar(
          actions: [_CrosswordPuzzleAppMenu()],
          titleTextStyle: TextStyle(
            color: Theme.of(context).colorScheme.primary,
            fontSize: 16,
            fontWeight: FontWeight.bold,
          ),
          title: Text('Crossword Puzzle'),
        ),
        body: SafeArea(
          child: Consumer(builder: (context, ref, _) {
            final workQueueAsync = ref.watch(workQueueProvider);
            final puzzleSolved =
                ref.watch(puzzleProvider.select((puzzle) => puzzle.solved));

            return workQueueAsync.when(
              data: (workQueue) {
                if (puzzleSolved) {
                  return PuzzleCompletedWidget();
                }
                if (workQueue.isCompleted &&
                    workQueue.crossword.characters.isNotEmpty) {
                  return CrosswordPuzzleWidget();
                }
                return CrosswordGeneratorWidget();
              },
              loading: () => Center(child: CircularProgressIndicator()),
              error: (error, stackTrace) => Center(child: Text('$error')),
            );
          }),
        ),
      ),
    );
  }
}

class _EagerInitialization extends ConsumerWidget {
  const _EagerInitialization({required this.child});
  final Widget child;

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    ref.watch(wordListProvider);
    return child;
  }
}

class _CrosswordPuzzleAppMenu extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) => MenuAnchor(
        menuChildren: [
          for (final entry in CrosswordSize.values)
            MenuItemButton(
              onPressed: () => ref.read(sizeProvider.notifier).setSize(entry),
              leadingIcon: entry == ref.watch(sizeProvider)
                  ? Icon(Icons.radio_button_checked_outlined)
                  : Icon(Icons.radio_button_unchecked_outlined),
              child: Text(entry.label),
            ),
        ],
        builder: (context, controller, child) => IconButton(
          onPressed: () => controller.open(),
          icon: Icon(Icons.settings),
        ),
      );
}

Ein Großteil dieser Datei sollte Ihnen inzwischen ziemlich vertraut sein. Ja, es wird undefinierte Widgets geben, deren Korrektur jetzt beginnt.

5. Erstellen Sie eine crossword_generator_widget.dart-Datei und fügen Sie ihr folgenden Inhalt hinzu:

lib/widgets/crossword_generator_widget.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:two_dimensional_scrollables/two_dimensional_scrollables.dart';

import '../model.dart';
import '../providers.dart';

class CrosswordGeneratorWidget extends ConsumerWidget {
  const CrosswordGeneratorWidget({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final size = ref.watch(sizeProvider);
    return TableView.builder(
      diagonalDragBehavior: DiagonalDragBehavior.free,
      cellBuilder: _buildCell,
      columnCount: size.width,
      columnBuilder: (index) => _buildSpan(context, index),
      rowCount: size.height,
      rowBuilder: (index) => _buildSpan(context, index),
    );
  }

  TableViewCell _buildCell(BuildContext context, TableVicinity vicinity) {
    final location = Location.at(vicinity.column, vicinity.row);

    return TableViewCell(
      child: Consumer(
        builder: (context, ref, _) {
          final character = ref.watch(
            workQueueProvider.select(
              (workQueueAsync) => workQueueAsync.when(
                data: (workQueue) => workQueue.crossword.characters[location],
                error: (error, stackTrace) => null,
                loading: () => null,
              ),
            ),
          );

          final explorationCell = ref.watch(
            workQueueProvider.select(
              (workQueueAsync) => workQueueAsync.when(
                data: (workQueue) =>
                    workQueue.locationsToTry.keys.contains(location),
                error: (error, stackTrace) => false,
                loading: () => false,
              ),
            ),
          );

          if (character != null) {
            return AnimatedContainer(
              duration: Durations.extralong1,
              curve: Curves.easeInOut,
              color: explorationCell
                  ? Theme.of(context).colorScheme.primary
                  : Theme.of(context).colorScheme.onPrimary,
              child: Center(
                child: AnimatedDefaultTextStyle(
                  duration: Durations.extralong1,
                  curve: Curves.easeInOut,
                  style: TextStyle(
                    fontSize: 24,
                    color: explorationCell
                        ? Theme.of(context).colorScheme.onPrimary
                        : Theme.of(context).colorScheme.primary,
                  ),
                  child: Text('•'), // https://www.compart.com/en/unicode/U+2022
                ),
              ),
            );
          }

          return ColoredBox(
            color: Theme.of(context).colorScheme.primaryContainer,
          );
        },
      ),
    );
  }

  TableSpan _buildSpan(BuildContext context, int index) {
    return TableSpan(
      extent: FixedTableSpanExtent(32),
      foregroundDecoration: TableSpanDecoration(
        border: TableSpanBorder(
          leading: BorderSide(
              color: Theme.of(context).colorScheme.onPrimaryContainer),
          trailing: BorderSide(
              color: Theme.of(context).colorScheme.onPrimaryContainer),
        ),
      ),
    );
  }
}

Auch dies sollte Ihnen bekannt vorkommen. Der Hauptunterschied besteht darin, dass anstelle der Zeichen der generierten Wörter jetzt ein Unicode-Zeichen angezeigt wird, um auf das Vorhandensein eines unbekannten Zeichens hinzuweisen. Die Ästhetik könnte dadurch wirklich verbessert werden.

6. Erstellen Sie die Datei crossword_puzzle_widget.dart und fügen Sie ihr den folgenden Inhalt hinzu:

lib/widgets/crossword_puzzle_widget.dart

import 'package:built_collection/built_collection.dart';
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:two_dimensional_scrollables/two_dimensional_scrollables.dart';

import '../model.dart';
import '../providers.dart';

class CrosswordPuzzleWidget extends ConsumerWidget {
  const CrosswordPuzzleWidget({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final size = ref.watch(sizeProvider);
    return TableView.builder(
      diagonalDragBehavior: DiagonalDragBehavior.free,
      cellBuilder: _buildCell,
      columnCount: size.width,
      columnBuilder: (index) => _buildSpan(context, index),
      rowCount: size.height,
      rowBuilder: (index) => _buildSpan(context, index),
    );
  }

  TableViewCell _buildCell(BuildContext context, TableVicinity vicinity) {
    final location = Location.at(vicinity.column, vicinity.row);

    return TableViewCell(
      child: Consumer(
        builder: (context, ref, _) {
          final character = ref.watch(puzzleProvider
              .select((puzzle) => puzzle.crossword.characters[location]));
          final selectedCharacter = ref.watch(puzzleProvider.select((puzzle) =>
              puzzle.crosswordFromSelectedWords.characters[location]));
          final alternateWords = ref
              .watch(puzzleProvider.select((puzzle) => puzzle.alternateWords));

          if (character != null) {
            final acrossWord = character.acrossWord;
            var acrossWords = BuiltList<String>();
            if (acrossWord != null) {
              acrossWords = acrossWords.rebuild((b) => b
                ..add(acrossWord.word)
                ..addAll(alternateWords[acrossWord.location]
                        ?[acrossWord.direction] ??
                    [])
                ..sort());
            }

            final downWord = character.downWord;
            var downWords = BuiltList<String>();
            if (downWord != null) {
              downWords = downWords.rebuild((b) => b
                ..add(downWord.word)
                ..addAll(alternateWords[downWord.location]
                        ?[downWord.direction] ??
                    [])
                ..sort());
            }

            return MenuAnchor(
              builder: (context, controller, _) {
                return GestureDetector(
                  onTapDown: (details) =>
                      controller.open(position: details.localPosition),
                  child: AnimatedContainer(
                    duration: Durations.extralong1,
                    curve: Curves.easeInOut,
                    color: Theme.of(context).colorScheme.onPrimary,
                    child: Center(
                      child: AnimatedDefaultTextStyle(
                        duration: Durations.extralong1,
                        curve: Curves.easeInOut,
                        style: TextStyle(
                          fontSize: 24,
                          color: Theme.of(context).colorScheme.primary,
                        ),
                        child: Text(selectedCharacter?.character ?? ''),
                      ),
                    ),
                  ),
                );
              },
              menuChildren: [
                if (acrossWords.isNotEmpty && downWords.isNotEmpty)
                  Padding(
                    padding: const EdgeInsets.all(4),
                    child: Text('Across'),
                  ),
                for (final word in acrossWords)
                  _WordSelectMenuItem(
                    location: acrossWord!.location,
                    word: word,
                    selectedCharacter: selectedCharacter,
                    direction: Direction.across,
                  ),
                if (acrossWords.isNotEmpty && downWords.isNotEmpty)
                  Padding(
                    padding: const EdgeInsets.all(4),
                    child: Text('Down'),
                  ),
                for (final word in downWords)
                  _WordSelectMenuItem(
                    location: downWord!.location,
                    word: word,
                    selectedCharacter: selectedCharacter,
                    direction: Direction.down,
                  ),
              ],
            );
          }

          return ColoredBox(
            color: Theme.of(context).colorScheme.primaryContainer,
          );
        },
      ),
    );
  }

  TableSpan _buildSpan(BuildContext context, int index) {
    return TableSpan(
      extent: FixedTableSpanExtent(32),
      foregroundDecoration: TableSpanDecoration(
        border: TableSpanBorder(
          leading: BorderSide(
              color: Theme.of(context).colorScheme.onPrimaryContainer),
          trailing: BorderSide(
              color: Theme.of(context).colorScheme.onPrimaryContainer),
        ),
      ),
    );
  }
}

class _WordSelectMenuItem extends ConsumerWidget {
  const _WordSelectMenuItem({
    required this.location,
    required this.word,
    required this.selectedCharacter,
    required this.direction,
  });

  final Location location;
  final String word;
  final CrosswordCharacter? selectedCharacter;
  final Direction direction;

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final notifier = ref.read(puzzleProvider.notifier);
    return MenuItemButton(
      onPressed: ref.watch(puzzleProvider.select((puzzle) =>
              puzzle.canSelectWord(
                  location: location, word: word, direction: direction)))
          ? () => notifier.selectWord(
              location: location, word: word, direction: direction)
          : null,
      leadingIcon: switch (direction) {
        Direction.across => selectedCharacter?.acrossWord?.word == word,
        Direction.down => selectedCharacter?.downWord?.word == word,
      }
          ? Icon(Icons.radio_button_checked_outlined)
          : Icon(Icons.radio_button_unchecked_outlined),
      child: Text(word),
    );
  }
}

Dieses Widget ist etwas intensiver als das letzte, auch wenn es aus Teilen besteht, die Sie in der Vergangenheit an anderen Stellen verwendet haben. Nun wird für jede ausgefüllte Zelle ein Kontextmenü angezeigt, wenn darauf geklickt wird, in dem die Wörter aufgelistet sind, die der Nutzer auswählen kann. Wenn Wörter ausgewählt wurden, können diese nicht ausgewählt werden. Um die Auswahl eines Wortes aufzuheben, tippen Nutzende auf den Menüpunkt für dieses Wort.

Wenn der Spieler Wörter auswählen kann, um das gesamte Kreuzworträtsel zu füllen, benötigen Sie die Schaltfläche „Sie haben gewonnen!“ Bildschirm.

7. Erstellen Sie eine puzzle_completed_widget.dart-Datei und fügen Sie ihr folgenden Inhalt hinzu:

lib/widgets/puzzle_completed_widget.dart

import 'package:flutter/material.dart';

class PuzzleCompletedWidget extends StatelessWidget {
  const PuzzleCompletedWidget({super.key});

  @override
  Widget build(BuildContext context) {
    return Center(
      child: Text(
        'Puzzle Completed!',
        style: TextStyle(
          fontSize: 36,
          fontWeight: FontWeight.bold,
        ),
      ),
    );
  }
}

Ich bin mir sicher, dass Sie dies nehmen und es interessanter machen können. Weitere Informationen zu Animationstools finden Sie im Codelab UIs der nächsten Generation in Flutter erstellen.

8. Bearbeiten Sie die Datei lib/main.dart so:

lib/main.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

import 'widgets/crossword_puzzle_app.dart';                 // Update this line

void main() {
  runApp(
    ProviderScope(
      child: MaterialApp(
        title: 'Crossword Puzzle',                          // Update this line
        debugShowCheckedModeBanner: false,
        theme: ThemeData(
          useMaterial3: true,
          colorSchemeSeed: Colors.blueGrey,
          brightness: Brightness.light,
        ),
        home: CrosswordPuzzleApp(),                         // Update this line
      ),
    ),
  );
}

Wenn Sie diese App ausführen, sehen Sie die Animation, während der Kreuzworträtsel-Generator Ihr Rätsel generiert. Dann wird Ihnen ein leeres Rätsel präsentiert, das Sie lösen müssen. Wenn Sie das Problem gelöst haben, sollte Ihnen ein Bildschirm wie der folgende angezeigt werden:

10. Glückwunsch

Glückwunsch! Sie haben mit Flutter erfolgreich ein Puzzlespiel entwickelt.

Sie haben einen Kreuzworträtsel-Generator gebaut, der zu einem Geduldsspiel wurde. Sie haben es geschafft, Hintergrundberechnungen in einem Pool von Isolierungen auszuführen. Sie haben unveränderliche Datenstrukturen verwendet, um die Implementierung eines Backtracking-Algorithmus zu vereinfachen. Außerdem haben Sie sich mit TableView vertraut gemacht. Diese Funktion wird nützlich sein, wenn Sie das nächste Mal tabellarische Daten anzeigen möchten.

Weitere Informationen

• Muster und Aufzeichnungen von Dart ansehen
• UIs der nächsten Generation in Flutter erstellen
• Langweilig wird deine Flutter-App
• Toolkit für Flutter-Casual Games