← C++

C++ · 07 / 24

Karteneditor, Undo/Redo und sichere Projektdateien

Du verfolgst einen Editor-Entwurf von der Änderung über Undo/Redo bis zum geprüften Datei-Roundtrip.

  • Groß
  • Anspruchsvoll
  • 120 min

Voraussetzungen: Header, CMake und erste Unit-Tests, Deine erste Qt-Oberfläche mit Signals und Slots

In diesem Tutorial
  1. Den Quellstand vorbereiten
  2. Das Document-Modell lesen
  3. Undo, Redo und gespeicherten Zustand unterscheiden
  4. Das Repository untersuchen
  5. Den Roundtrip ausführen
  6. Die Prüfung nachvollziehen
  7. Den vollständigen Editor prüfen
  8. Übung und Lösung
  9. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

GCC mit C++20 und CMake ab 3.25, Qt ab 6.4. Zusätzlich Python 3 für den gemeinsamen Prüfstart. Entpacke das Lernpaket in einen neuen Ordner und führe dort python3 run_checks.py aus. Das Skript kopiert die enthaltenen Dateien in einen temporären Lernordner. Dort prüft es zuerst das Beispiel und danach die mitgelieferte Lösung. Die Ausgangsdateien bleiben erhalten. Benötigte Pakete werden beim ersten Lauf aus dem Netz geladen.

Setze CMAKE_PREFIX_PATH auf deine Qt-Installation, falls CMake Qt nicht findet. Die benötigten FactoryForge-Quelldateien liegen bereits unter vendor.

Geprüft am 21.10.2026 unter Linux x86_64. Speichern und Laden im temporären Ordner. Die Lösung prüft dirty, undo und den Erhalt des Entwurfs nach fehlgeschlagenem Laden.

Diese Lektion verbindet die Oberfläche mit der Anwendungsschicht des vollständigen Projekts. Die kurze Beispieldatei baut keinen zweiten Editor. Sie verwendet dieselben Document- und Repository-Klassen, die der grafische FactoryForge-Editor benutzt. Dafür brauchst du den kompletten Quellcode aus dem ZIP auf der Projektseite.

Ein Entwurf und eine laufende Simulation sind unterschiedliche Zustände. Document verwaltet den Ausgangsaufbau. Änderungen erzeugen einen neuen Projektwert für die Historie. Eine gespeicherte Referenzkopie bestimmt, ob ungespeicherte Änderungen vorliegen. Die Simulation beginnt später mit einer unabhängigen Kopie. Das verhindert, dass bewegte Fahrzeuge den gespeicherten Kartenaufbau verändern.

Paketinhalt und einzelne Dateien

01Den Quellstand vorbereiten

Entpacke das Lernpaket. Die benötigten FactoryForge-Dateien liegen unter vendor und stammen aus dem verlinkten festen Quellstand. cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug und cmake --build build bauen das eigenständige Beispiel. Das vollständige Projekt-ZIP ist für diese Prüfung nicht zusätzlich nötig.

CMakeLists.txt · cmakeDatei öffnen
cmake_minimum_required(VERSION 3.25)
project(DocumentLesson LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
get_filename_component(FACTORYFORGE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/vendor/factory-forge" ABSOLUTE CACHE)
find_package(Qt6 6.4 REQUIRED COMPONENTS Core)
add_executable(lesson main.cpp
  "${FACTORYFORGE_SOURCE_DIR}/src/core/project.cpp"
  "${FACTORYFORGE_SOURCE_DIR}/src/core/pathfinder.cpp"
  "${FACTORYFORGE_SOURCE_DIR}/src/core/puzzles.cpp"
  "${FACTORYFORGE_SOURCE_DIR}/src/application/document.cpp"
  "${FACTORYFORGE_SOURCE_DIR}/src/data/json_project_repository.cpp")
target_include_directories(lesson PRIVATE "${FACTORYFORGE_SOURCE_DIR}/include")
target_link_libraries(lesson PRIVATE Qt6::Core)

02Das Document-Modell lesen

Das Beispiel erzeugt ein Repository und ein Document. replace lädt eine geprüfte Musterlösung als Ausgangszustand. edit erhält eine kleine Änderungsfunktion und arbeitet zuerst auf einer Kopie. Ein misslungener Änderungsaufruf verändert den bisherigen Entwurf nicht. Der grafische Editor benutzt dasselbe Prinzip für Rasterwerkzeuge und Einstellungen.

main.cpp · cppDatei öffnen
#include "factory/application/document.h"
#include "factory/core/puzzles.h"
#include "factory/data/json_project_repository.h"
#include <QCoreApplication>
#include <QTemporaryDir>
#include <iostream>
int main(int argc, char **argv) {
  QCoreApplication app(argc, argv);
  auto repository = std::make_shared<factory::JsonProjectRepository>();
  factory::Document document(repository);
  document.replace(factory::makePuzzle(0, true));
  document.edit(
      [](factory::Project &project) { project.name = "Warehouse experiment"; });
  document.undo();
  document.redo();
  QTemporaryDir directory;
  if (!directory.isValid())
    return 1;
  const auto path = directory.filePath("example.factoryforge").toStdString();
  document.save(path);
  document.load(path);
  std::cout << "project=" << document.project().name << '\n';
  std::cout << std::boolalpha << "dirty=" << document.dirty() << '\n';
}

Starten / prüfen

cmake -S . -B build -G Ninja -DFACTORYFORGE_SOURCE_DIR=/path/to/factory-forge
cmake --build build
./build/lesson

03Undo, Redo und gespeicherten Zustand unterscheiden

undo bewegt die aktuelle Historienposition zurück, redo wieder vor. Eine neue Änderung nach undo verwirft den nicht mehr passenden Redo-Zweig. dirty vergleicht den aktuellen Projektwert mit dem zuletzt gespeicherten Wert. Ein bloßer Zähler seit dem letzten Tastendruck würde den Fall Rückgängig bis zum gespeicherten Zustand falsch behandeln.

04Das Repository untersuchen

ProjectRepository beschreibt load und save, ohne Qt vorauszusetzen. JsonProjectRepository übernimmt JSON und QSaveFile. Formatversion, Dimensionen, Datentypen und eindeutige IDs werden vor der Übernahme geprüft. Ein Entwurf darf noch unvollständig sein. Vor dem Spielstart prüft preflight zusätzlich Ziele, Budgets und erreichbare Verbindungen.

05Den Roundtrip ausführen

Das Beispiel schreibt in QTemporaryDir. Diese temporäre Umgebung ist unabhängig von deinen eigenen Projektdateien und wird nach dem Lauf entfernt. save aktualisiert den gespeicherten Vergleichswert erst nach erfolgreichem Schreiben. load übernimmt erst ein vollständig eingelesenes Projekt. Konfiguriere, baue und starte das Beispiel mit den Befehlen unter main.cpp.

Erwartetes Ergebnis

project=Warehouse experiment dirty=false

06Die Prüfung nachvollziehen

Speichern und Laden im temporären Ordner. Die Lösung prüft dirty, undo und den Erhalt des Entwurfs nach fehlgeschlagenem Laden. Starte python3 run_checks.py aus dem entpackten Paket. Vergleiche die Test-Erwartungen mit der Übung, bevor du die Lösung öffnest.

Erwartetes Ergebnis

Beispiel und automatisierte Lösung bestehen. Die genannten manuellen Prüfungen bleiben getrennt.

07Den vollständigen Editor prüfen

Starte die App, baue einen Weg, mache ihn rückgängig und wiederhole die Änderung. Speichere den Aufbau, öffne ihn erneut und vergleiche die Stationen. Tippe einen neuen Namen in einer eigenen Karte und brich anschließend das Schließen ab. Der Text und der Entwurf müssen erhalten bleiben. Die Desktop- und Repository-Tests prüfen diese Zusagen.

Deine Übung

Füge nach dem Speichern eine weitere Namensänderung ein. Prüfe dirty, mache die Änderung rückgängig und prüfe erneut. Versuche danach, eine nicht vorhandene Datei zu laden.

Lösung mit Erklärung anzeigen

Nach der zusätzlichen Änderung ist dirty wahr. undo kehrt zum gespeicherten Projektwert zurück und dirty ist wieder falsch. Ein fehlgeschlagenes load wirft einen Fehler, bevor replace aufgerufen wird. Fange diesen Fehler ab und überprüfe anschließend den bisherigen Namen. Benutze dafür weiterhin die temporäre Umgebung und keine wertvollen Dateien.

solution/main.cpp · cppDatei öffnen
#include "factory/application/document.h"
#include "factory/core/puzzles.h"
#include "factory/data/json_project_repository.h"
#include <QCoreApplication>
#include <QTemporaryDir>
#include <cassert>
#include <iostream>
int main(int argc, char **argv) {
  QCoreApplication app(argc, argv);
  auto repository = std::make_shared<factory::JsonProjectRepository>();
  factory::Document document(repository);
  document.replace(factory::makePuzzle(0, true));
  document.edit(
      [](factory::Project &project) { project.name = "Warehouse experiment"; });
  document.undo();
  document.redo();
  QTemporaryDir directory;
  if (!directory.isValid())
    return 1;
  const auto path = directory.filePath("example.factoryforge").toStdString();
  document.save(path);
  document.load(path);
  assert(!document.dirty());
  document.edit([](factory::Project &project) { project.name = "Changed"; });
  assert(document.dirty());
  document.undo();
  assert(!document.dirty());
  try {
    document.load(path + ".missing");
    return 2;
  } catch (const std::exception &) {
  }
  assert(document.project().name == "Warehouse experiment");
  std::cout << "project=" << document.project().name << '\n';
  std::cout << std::boolalpha << "dirty=" << document.dirty() << '\n';
}

Projektbezug und Quellen

Die ersten sechs Beispiele sind eigenständige Lernprogramme. Lektionen 7 bis 9 nutzen den vollständigen FactoryForge-Quellstand. Quellcode, Übungen und überprüfte Vereinfachungen sind getrennt beschrieben. Die Projektseite bietet ein Quellcode-ZIP, solange das GitHub-Repository noch nicht veröffentlicht ist.