Foundry und Shadowrun – Systementwicklung

In meinen Augen gehört Foundry zu den besten VTT die es derzeit gibt. Das gilt allerdings vor allem mit Systemen wie D&D 5e und Pathfinder, die gut entwickelt und supportet sind. Shadowrun 6 ist derzeit etwas schwierig, nachdem sich über den Systembrowser kein entsprechendes System finden lässt. Was also tun? In meinem Fall: Lernen, wie man ein System für Foundry entwickelt!

Was man können muss um für Foundry zu entwickeln

Der Einstieg in die Entwicklung für Foundry erschien mir, vor allem am Anfang, extrem niedrig. Man braucht kein Softwareentwickler zu sein, um etwas für das VTT zu bauen. Es reichen (am besten gute) Kenntnisse in:

• HTML5
• CSS3 (idealerweise mit SASS oder LESS)
• JavaScript/TypeScript

Das sind die grundlegenden Fähigkeiten, ohne die man in keinem Fall auskommen wird. Für die Dokumentation, Videos und ähnliche Ressourcen empfiehlt sich, gute Englischkenntnisse mitzubringen. Der Content in dem Bereich ist auf Deutsch doch eher rar gesät.

Was das Versions-Management angeht, empfehle ich GitHub, damit man auch alles hübsch an einem Ort hat.

Am Anfang steht der Plan

Obwohl die Einstiegshürde in Foundry sich als niedrig darstellt, ist die Entwicklung eines Systems ein langwieriger und komplexer Prozess. Der eigenen geistigen Gesundheit zuliebe braucht es also einen Schlachtplan!

Damit meine ich keinen kompletten Ablaufplan, sondern ein Herunterbrechen des Systems in einzelne, leicht zu handelnde Aufgaben. Das hat verschiedene Vorteile:

1. Überblick. Sobald man weiß, was man eigentlich alles tun muss, wirkt die Aufgabe nicht mehr so schwierig und überwältigend.
2. Fokus. Zu wissen, welche Aufgabe als nächstes vor einem liegt hilft dabei, sich nicht zu verzetteln.
3. Planbarkeit. Ein Teilbereich einer großen Aufgabe ist viel leichter zu handhaben, als der gesamte Brocken.

Für Shadowrun 6 gehe ich bei meiner Planung so vor, dass ich mir zunächst einen Überblick verschaffe, was alles ins System hinein soll. Dann sortiere ich die jeweiligen Funktionen nach Wichtigkeit. Zum Beispiel möchte ich in SR6 Schaden automatisch auf ein Zieltoken anwenden, wenn es welchen bekommt. Das ist aber wesentlich weniger essenziell, als zum Beispiel die verschiedenen Bögen die das System braucht zur Verfügung zu stellen.

Der Plan für Shadowrun in Foundry

1. Grundlegende Systemfunktionalität. Das System muss von Foundry erkannt werden, und geladen werden können. Ohne diese Funktionalität kann man weitere Dinge überhaupt nicht testen.
2. Verwaltung von Items. Items sind in Foundry nicht nur Gegenstände, sondern praktisch alles was man im Spiel anlegen kann und das kein Token auf dem Tisch braucht. Für Shadowrun sind Items:
   • Rüstungen
   • Modifikationen für Waffen
   • Zauber
   • Critter-Kräfte
   • Komplexe Formen
   • Bio- und Cyberware
   • Adeptenkräfte
   • Vor- und Nachteile
   • Aktionen und Edgehandlungen
   • Geisterkräfte
   • Kontakte
   • SINs
   • Lebensstile
   • Geräte
   • Programme
   • Waffen
   • Drogen
   • Sonstige Ausrüstungsgegenstände
3. Verwaltung von Akteuren. Alles was ein Token haben kann, oder sollte, ist ein Akteuer. Das reicht von NSC über Spielercharaktere bis hin zu Fahrzeugen. Obwohl die Akteuere weniger verschiedene Typen haben, sind sie deutlich komplexer und kleinteiliger als die Items, weshalb ich sie auch hinten anstelle.
4. Würfelsystem. Das Würfelsystem ist in einem VTT relativ wichtig, auch wenn die Spieler natürlich selbst ihre Würfelformeln eingeben könnten, um die gewünschten Ergebnisse zu erhalten. Die Implementierung von Würfeln die aus dem jeweiligen Charakterbogen heraus funktionieren ist dennoch ein wichtiger Meilenstein.
5. Anwendung von Regeln. Hier beginnen die Verbesserungen, die das Leben wirklich leicht machen. Automatische Anpassung von Angriffswert und Schaden durch Munition, Automatisches zufügen von Schaden, Edgeverteilung… all diese Dinge, die das Spiel flüssiger machen, und einfach die richtigen Regeln anwenden, wenn sie nötig sind.
6. Schnörkel und Schleifen. Was bisher vergessen wurde, wird hier dann umgesetzt. Diese Kategorie fungiert als Catch-Up-Kategorie für alles was so anfällt.

Wie man Foundry vom System erzählt

In diesem Beitrag kümmere ich mich ausschließlich um Punkt 1 auf der genannten Liste. Wir bringen also Foundry dazu, unser neues System zu erkennen und uns zur Auswahl anzubieten. Dazu brauchen wir:

• Eine lokale Installation von Foundry VTT
• Einen passenden Code-Editor. Ich persönlich bevorzuge Visual Studio Code, Notepad++ oder ähnliches tun es aber auch.

Für den Anfang brauchen wir jetzt das Verzeichnis, in dem Foundry die Systeme abspeichert. Unter Windows kommt man am leichtesten dorthin, wenn man bei gestartetem Foundry das Symbol in der Taskleiste rechtsklickt und „Browse User Data“ anklickt. In diesem Ordner geht man auf Data -> systems und ist im passenden Ordner.

Hier legt man nun einen weiteren Ordner in maschinensicherer Benennung für das eigene System an. Das bedeutet, dass der Name ausschließlich aus Kleinbuchstaben, Ziffern und eventuellen Bindestrichen bestehen sollte. Der hier gewählte Name ist wichtig, da er auch die ID des Systems ist. Für Shadowrun nenne ich den Ordner schlicht shadowrun6. Im nächsten Schritt legen wir die Dateien an, die Foundry in jedem Fall benötigt.

In unserem neuen Systemordner legen wir jetzt die dateien system.json und template.json an. Unter Windows funktioniert das mit Rechtsklick -> Neu -> Textdokument, aber der Weg über euren Codeeditor ist leichter und sicherer.

system.json im Detail

Das wichtigste Dokument für unser heutiges Ziel ist die system.json, in der wir einen großen Teil der grundlegenden Informationen festhalten, zum Beispiel wie unser System überhaupt heißt. Um euch das Folgen etwas leichter zu machen, habe ich hier den Inhalt des entsprechenden Files OHNE die zugehörigen Definitionen. Dieses Template könnt ihr einfach in eure system.json kopieren, und Schritt für Schritt ausfüllen:

{
    "id": "",
    "title": "",
    "description": "",
    "authors": [
        {
            "name": "",
            "email": "",
            "discord": ""
        }
    ],
    "url": "",
    "bugs": "",
    "version": "0.0.1",
    "compatibility": {
        "minimum": "11",
        "verified": "11"
    },
    "scripts": [],
    "esmodules": [],
    "styles": [],
    "languages": [],
    "packs": [],
    "socket": true,
    "manifest": "",
    "initiative": "",
    "gridDistance": 1,
    "gridUnits": "m",
    "primaryTokenAttribute": "",
    "secondaryTokenAttribute": ""
}

Eintrag für Eintrag

Die „id“ des Systems muss exakt dem Namen des Ordners entsprechen, in dem ihr euer System gespeichert habt. In meinem Fall also „shadowrun6“.

Der „title“ ist eine für Menschen gedachte Bezeichnung für euer System, also gewöhnlich der Name in ausgeschriebener Form. „Shadowrun 6“ ist es in meinem Falle.

Unter „description“ könnt ihr eine kurze Beschreibung dessen eintragen, was ihr da baut. In meinem Fall also „A Shadowrun 6 system for Foundry VTT“.

„authors“ beinhaltet genau das – die Autoren oder Entwickler des Systems. Ihr könnt den inneren Block in den geschweiften Klammern kopieren und erneut, durch ein Komma getrennt, einfügen falls ihr einen weiteren Autor haben solltet.

„url“ und „bugs“ beinhalten Links zur Webseite oder dem GitHub eures Systems, sowie zum Bugtracker. Diese Daten könnt ihr erst einmal als leere Strings belassen. Das gleiche gilt für „manifest„, das Foundry und dem Systembrowser später sagt, wo es eure system.json online finden kann.

„version“ ist ein wichtiger Punkt für die Aktualisierung im späteren Verlauf. Ich persönlich bevorzuge die hier eingetragene Variante als String und erhöhe den Wert einfach um einen Zähler, wenn ich eine neue Version release.

„compatibility“ sagt Foundry, mit welchen Foundry-Versionen euer System funktioniert. „minimum“ sollte dabei die Version sein, bei der ihr mit der Entwicklung beginnt, „verified“ die jeweils aktuelle Version, sobald ihr sichergestellt habt, dass noch alles funktioniert wie es soll.

Die Arrays „scripts„, „esmodules„, „styles„, „languages„, und „packs“ beinhalten Pfade als String, um die wir uns aber erst später kümmern. „gridDistance“ und „gridUnits“ beschreiben die Maßeinheiten für ein Feld auf der Battlemap. Für Shadowrun habe ich 1m je Feld gewählt, aber 5ft oder 1.5m sind ebenfalls Optionen.

Die beiden Felder „primaryTokenAttribute“ und „secondaryTokenAttribute“ zeigen an, welche Werte am Token sichtbar sein sollen. Vorerst bleiben diese beiden Strings leer.

So! Damit ist die system.json fertig! Abspeichern und weiter geht’s.

Die template.json

Da es heute nur darum geht, die entsprechende Welt mit unserem neuen System anzulegen, ist der Inhalt der template.json recht kurz:

{
  "Actor": {},
  "Item": {}
}

Wiederum -> einmal abspeichern und Foundry neu starten. Unter „Game Systems“ in der Benutzeroberfläche solltet ihr jetzt euer System finden und damit eine Welt erstellen können.

Ich hoffe ihr konntet so weit folgen, und freue mich auf das nächste Mal, wenn wir uns an den zweiten Punkt auf meiner Liste machen! Bis dahin, lasst mir doch gern einen Kommentar hier.

Liebe Grüße

Schattenhexe