Konfigurationen in Unity bestimmen, wie ein Projekt aufgebaut ist, welche technischen Eigenschaften das Spiel besitzt und welche Einstellungen während der Laufzeit gelten. Dazu gehören beispielsweise Bildschirmauflösung, Audioausgabe, Eingabesteuerung, Grafikqualität und benutzerdefinierte Spieloptionen.
Unity 2021.1 unterscheidet zwischen Einstellungen, die du während der Entwicklung im Editor festlegst, und Konfigurationen, die dein Spiel selbst verwaltet. Während Project Settings und Preferences die Entwicklungsumgebung beziehungsweise das Projekt beeinflussen, können PlayerPrefs, JSON-Dateien und ScriptableObjects unterschiedliche Aufgaben bei der Verwaltung von Spieldaten übernehmen.
Eine übersichtliche Konfigurationsstruktur erleichtert spätere Änderungen. Außerdem kannst du Einstellungen zentral verwalten, statt dieselben Werte in mehreren Scripts einzeln anzupassen.
Was versteht Unity unter Konfigurationen?
Eine Konfiguration besteht aus Einstellungen und Werten, die das Verhalten eines Systems beeinflussen. Dabei kann es sich um technische Vorgaben für das gesamte Projekt oder um einzelne Parameter einer Spielmechanik handeln.
Beispielsweise bestimmt eine Projekteinstellung, welche Render Pipeline das Spiel verwendet. Eine benutzerdefinierte Spielkonfiguration kann dagegen festlegen, wie schnell sich eine Figur bewegt oder welche Lautstärke beim ersten Start eingestellt ist.
Grundsätzlich lassen sich Konfigurationen nach ihrem Verwendungszweck unterscheiden: Editor-Einstellungen, Projekteinstellungen, Asset-Konfigurationen und Laufzeiteinstellungen.
Project Settings – zentrale Einstellungen des Unity-Projekts
Über Edit > Project Settings öffnest du die zentralen Projekteinstellungen. Sie gelten grundsätzlich für das jeweilige Unity-Projekt und beeinflussen unterschiedliche Bereiche der Engine.
Die verfügbaren Kategorien hängen von der Unity-Version und den installierten Paketen ab. In Unity 2021.1 findest du dort unter anderem Einstellungen für Audio, Physics, Physics 2D, Player, Quality, Time, Tags and Layers sowie weitere Systeme.
Viele dieser Einstellungen wirken sich unmittelbar auf das Verhalten des Spiels aus. Deshalb solltest du Änderungen bewusst vornehmen und anschließend prüfen, ob sie unerwartete Auswirkungen auf vorhandene Szenen oder Komponenten besitzen.
Preferences – persönliche Einstellungen des Unity Editors
Die Preferences unterscheiden sich von den Project Settings. Während Projekteinstellungen zum jeweiligen Projekt gehören, betreffen Preferences hauptsächlich die persönliche Arbeitsumgebung im Unity Editor.
Unter Windows erreichst du sie über Edit > Preferences. Dort kannst du beispielsweise bestimmte Einstellungen für die Editor-Oberfläche und verwendete Entwicklungswerkzeuge verändern.
Solche Einstellungen dienen vor allem dazu, die Arbeit im Editor an deine Bedürfnisse anzupassen. Sie sind nicht automatisch Bestandteil der späteren Spielkonfiguration.
Player Settings für das fertige Spiel
Die Player Settings gehören zu den wichtigsten Konfigurationsbereichen für einen fertigen Build. Dort legst du verschiedene Eigenschaften der Anwendung fest.
Dazu gehören beispielsweise der Produktname, der Unternehmensname, das Anwendungssymbol und plattformspezifische Einstellungen.
Auch Optionen für die Darstellung, die unterstützten Plattformen und bestimmte technische Funktionen befinden sich in diesem Bereich.
Die verfügbaren Optionen unterscheiden sich je nach Zielplattform. Eine Windows-Anwendung benötigt teilweise andere Einstellungen als ein Android- oder WebGL-Spiel.
Quality Settings und die Grafikqualität
Über die Quality Settings kannst du verschiedene Qualitätsstufen für dein Projekt konfigurieren. Sie beeinflussen unter anderem bestimmte Darstellungs- und Rendering-Eigenschaften.
Je nach Render Pipeline und Projektkonfiguration stehen unterschiedliche Optionen zur Verfügung. Einige Einstellungen betreffen beispielsweise Schatten, Texturen oder andere Aspekte der grafischen Darstellung.
Du kannst mehrere Qualitätsstufen definieren und für unterschiedliche Zielplattformen passende Standardeinstellungen festlegen.
Im fertigen Spiel lassen sich Qualitätsstufen auch über Scripts wechseln. So kannst du Spielern eine Auswahl zwischen verschiedenen Grafikeinstellungen anbieten.
Grafikqualität über C# verändern
Unity stellt mit der Klasse QualitySettings verschiedene Funktionen zur Steuerung der Grafikqualität bereit.
Das folgende Beispiel ermöglicht den Wechsel zu einer bestimmten Qualitätsstufe:
using UnityEngine;
public class GraphicsSettingsController : MonoBehaviour
{
public void SetQuality(int qualityIndex)
{
if (qualityIndex < 0 ||
qualityIndex >= QualitySettings.names.Length)
{
return;
}
QualitySettings.SetQualityLevel(
qualityIndex,
true
);
}
}Die Methode erwartet den Index einer vorhandenen Qualitätsstufe. Über QualitySettings.names kannst du prüfen, wie viele Qualitätsstufen im Projekt definiert sind.
Der zweite Parameter von SetQualityLevel() legt fest, ob aufwendige Änderungen bei der Umstellung berücksichtigt werden sollen.
Für ein Einstellungsmenü kannst du die Methode beispielsweise mit einem Dropdown-Feld verbinden. Die verfügbaren Einträge sollten dabei zu den tatsächlichen Qualitätsstufen des Projekts passen.
Bildschirmauflösung und Vollbildmodus konfigurieren
Die Darstellung des Spiels lässt sich über die Klasse Screen beeinflussen. Damit kannst du beispielsweise die Bildschirmauflösung oder den Vollbildmodus verändern.
Welche Einstellungen tatsächlich unterstützt werden, hängt von der Zielplattform und dem verwendeten Anzeigegerät ab.
Das folgende Beispiel verwendet eine festgelegte Auflösung und den Vollbildmodus:
using UnityEngine;
public class DisplaySettingsController : MonoBehaviour
{
public void SetResolution()
{
Screen.SetResolution(
1920,
1080,
FullScreenMode.FullScreenWindow
);
}
public void SetWindowMode()
{
Screen.fullScreenMode =
FullScreenMode.Windowed;
}
}Mit Screen.SetResolution() kannst du eine gewünschte Auflösung und einen Anzeigemodus festlegen. Das Betriebssystem beziehungsweise die Plattform bestimmt, welche Änderungen tatsächlich möglich sind.
Für ein vollständiges Einstellungsmenü solltest du die verfügbaren Auflösungen abfragen, statt ausschließlich feste Werte vorzugeben.
Audio Settings für die Klangverarbeitung
Die Audio Settings beeinflussen die grundlegende Audioverarbeitung innerhalb des Unity-Projekts. Dazu gehören unter anderem Einstellungen für die Audioausgabe und die Verwaltung gleichzeitig aktiver Audiostimmen.
Du findest sie unter Edit > Project Settings > Audio.
Für die Lautstärke von Musik und Soundeffekten sind dagegen häufig Audio Sources und Audio Mixer zuständig. Dadurch kannst du die Audioeinstellungen des Spielers unabhängig von den grundlegenden Projekteinstellungen verwalten.
Die technischen Grundlagen behandelt der Artikel Unity Audio Source – Sounds und Musik in der Szene abspielen.
Physics und Physics 2D konfigurieren
Unity besitzt getrennte Physiksysteme für 3D- und 2D-Spiele. Entsprechend findest du in den Project Settings die Bereiche Physics und Physics 2D.
Dort kannst du beispielsweise bestimmte Einstellungen zur Simulation, Gravitation und Kollisionserkennung verändern.
Die globalen Physikeinstellungen beeinflussen viele Objekte gleichzeitig. Deshalb solltest du beachten, dass eine Veränderung der Gravitation oder anderer grundlegender Parameter Auswirkungen auf bereits vorhandene Spielmechaniken besitzen kann.
Für einzelne Objekte kannst du zusätzliche Einstellungen über Komponenten wie Rigidbody oder Rigidbody2D vornehmen.
Time Settings und die zeitliche Simulation
Die Time Settings bestimmen verschiedene zeitliche Eigenschaften der Simulation. Dazu gehört unter anderem die feste Zeitschrittgröße für Physikaktualisierungen.
Ein wichtiger Wert ist Fixed Timestep. Er beeinflusst, in welchen zeitlichen Abständen Unity reguläre Physikschritte berechnet.
Eine kleinere Schrittweite kann die zeitliche Auflösung der Simulation erhöhen, benötigt jedoch unter Umständen mehr Rechenleistung.
Eine größere Schrittweite reduziert dagegen die Häufigkeit der Physikaktualisierungen. Das kann die Berechnung entlasten, beeinflusst aber möglicherweise die Genauigkeit bestimmter Bewegungen.
Die passende Konfiguration hängt von der Spielmechanik und den Anforderungen der Physiksimulation ab.
Tags und Layers als Projektkonfiguration
Auch Tags und Layers gehören zu den projektweiten Konfigurationsmöglichkeiten von Unity.
Tags ermöglichen die Kennzeichnung von GameObjects. Scripts können dadurch beispielsweise prüfen, ob ein Objekt als Spieler, Gegner oder Sammelgegenstand markiert ist.
Layers dienen unter anderem dazu, Objekte für bestimmte Kameras, Raycasts oder Kollisionseinstellungen zu gruppieren.
Die Einrichtung erfolgt über die entsprechenden Einstellungen des Projekts. Weitere Einzelheiten findest du in den Artikeln Unity Tags und Unity Layers.
Benutzerdefinierte Konfigurationen für Spielmechaniken
Neben den eingebauten Projekteinstellungen kannst du eigene Konfigurationen erstellen. Damit legst du beispielsweise fest, wie schnell eine Spielfigur läuft, wie viele Lebenspunkte ein Gegner besitzt oder wie lange ein bestimmter Effekt dauert.
Solche Werte lassen sich direkt in Scripts definieren. Bei umfangreicheren Projekten ist es jedoch häufig sinnvoll, sie von der eigentlichen Spiellogik zu trennen.
Dadurch kannst du Werte anpassen, ohne die Funktionsweise eines Scripts verändern zu müssen. Außerdem lassen sich dieselben Konfigurationsdaten an mehreren Stellen verwenden.
SerializeField für Einstellungen im Inspector
Eine einfache Möglichkeit besteht darin, private Felder mit [SerializeField] zu kennzeichnen. Dadurch erscheinen sie bei unterstützten Datentypen im Inspector.
using UnityEngine;
public class PlayerConfiguration : MonoBehaviour
{
[SerializeField] private float moveSpeed = 5f;
[SerializeField] private int maxHealth = 100;
[SerializeField] private float jumpForce = 8f;
}Die Werte lassen sich im Inspector bearbeiten, obwohl die Felder innerhalb des Scripts privat bleiben.
Diese Methode eignet sich für Einstellungen, die direkt zu einer bestimmten Komponente gehören. Bei Konfigurationen, die mehrere GameObjects gemeinsam verwenden sollen, können ScriptableObjects sinnvoller sein.
ScriptableObjects als zentrale Konfigurationsdateien
Ein ScriptableObject ermöglicht die Speicherung von Daten in einem eigenen Unity-Asset. Dadurch kannst du Konfigurationswerte unabhängig von einzelnen GameObjects verwalten.
Beispielsweise kannst du eine Konfiguration für die Eigenschaften einer Spielfigur erstellen und sie mehreren Komponenten zur Verfügung stellen.
ScriptableObjects eignen sich besonders für Daten, die du während der Entwicklung im Inspector bearbeiten möchtest. Sie sind jedoch nicht automatisch ein geeignetes System zur dauerhaften Speicherung von Änderungen, die ein Spieler im fertigen Build vornimmt.
Ein ScriptableObject für Spielparameter erstellen
Das folgende Beispiel definiert eine eigene Konfigurationsklasse:
using UnityEngine;
[CreateAssetMenu(
fileName = "GameConfiguration",
menuName = "Game/Configuration"
)]
public class GameConfiguration : ScriptableObject
{
public float playerSpeed = 5f;
public int playerHealth = 100;
public float musicVolume = 0.8f;
}Durch CreateAssetMenu erscheint im Create-Menü des Project-Fensters ein Eintrag zum Erstellen dieser Konfiguration.
Nach dem Erstellen kannst du das Asset auswählen und die Werte im Inspector bearbeiten.
Andere Scripts können eine Referenz auf dieses ScriptableObject erhalten und seine Daten verwenden. Dadurch entsteht eine gemeinsame Grundlage für mehrere Spielsysteme.
ScriptableObject-Konfiguration in einem Script verwenden
Das folgende Beispiel liest Werte aus dem zuvor erstellten Konfigurations-Asset:
using UnityEngine;
public class PlayerSettingsReader : MonoBehaviour
{
[SerializeField] private GameConfiguration config;
private void Start()
{
if (config == null)
{
Debug.LogError(
"Keine Konfiguration zugewiesen."
);
return;
}
Debug.Log(
"Spielergeschwindigkeit: " +
config.playerSpeed
);
Debug.Log(
"Maximale Lebenspunkte: " +
config.playerHealth
);
}
}Im Inspector weist du dem Feld Config das zuvor erstellte ScriptableObject zu.
Das Script liest anschließend die gespeicherten Werte aus. Mehrere Komponenten können auf dasselbe Konfigurations-Asset zugreifen.
Änderst du die Werte im Asset während der Entwicklung, verwenden die referenzierenden Komponenten die angepasste Konfiguration.
PlayerPrefs für einfache Benutzereinstellungen
Mit PlayerPrefs stellt Unity ein einfaches System zur Speicherung kleiner Einstellungswerte bereit. Es unterstützt Integer-, Float- und String-Werte.
PlayerPrefs eignet sich beispielsweise für Musiklautstärke, Soundeffektlautstärke, Spracheinstellungen oder bestimmte Anzeigeoptionen.
Die Werte werden unter einem frei gewählten Schlüssel gespeichert. Beim nächsten Spielstart kannst du sie über denselben Schlüssel erneut abrufen.
PlayerPrefs ist allerdings kein verschlüsselter oder manipulationssicherer Speicher. Vertrauliche Daten und sicherheitskritische Informationen solltest du dort nicht ablegen.
Eine Lautstärkeeinstellung mit PlayerPrefs speichern
Das folgende Beispiel speichert und lädt die Musiklautstärke:
using UnityEngine;
public class MusicSettings : MonoBehaviour
{
[SerializeField] private AudioSource musicSource;
private const string VolumeKey = "MusicVolume";
private void Start()
{
if (musicSource == null)
{
return;
}
float savedVolume =
PlayerPrefs.GetFloat(
VolumeKey,
1f
);
musicSource.volume = savedVolume;
}
public void SetMusicVolume(float volume)
{
if (musicSource == null)
{
return;
}
float safeVolume = Mathf.Clamp01(volume);
musicSource.volume = safeVolume;
PlayerPrefs.SetFloat(
VolumeKey,
safeVolume
);
PlayerPrefs.Save();
}
}Beim Start lädt das Script den gespeicherten Lautstärkewert. Existiert noch kein entsprechender Eintrag, verwendet es den Standardwert 1.
Wenn der Spieler die Lautstärke verändert, aktualisiert das Script die Audio Source und speichert den neuen Wert.
Für größere Audiosysteme kannst du stattdessen einen Audio Mixer verwenden und die gespeicherte Einstellung auf eine entsprechende Mixer-Gruppe anwenden.
JSON-Dateien für umfangreichere Konfigurationen
Wenn eine Konfiguration zahlreiche zusammengehörige Werte enthält, kann eine JSON-Datei sinnvoll sein. Sie ermöglicht die Speicherung strukturierter Daten in einem textbasierten Format.
Unity stellt mit JsonUtility Funktionen bereit, um geeignete C#-Objekte in JSON umzuwandeln und wieder einzulesen.
JSON eignet sich beispielsweise für Spieloptionen, die du gemeinsam speichern und laden möchtest. Auch externe Konfigurationsdateien können dieses Format verwenden.
Eine Konfigurationsklasse für JSON definieren
Das folgende Beispiel enthält mehrere Einstellungen innerhalb einer serialisierbaren Klasse:
using System;
[Serializable]
public class GameSettingsData
{
public float musicVolume = 0.8f;
public float soundVolume = 1f;
public bool fullscreen = true;
public int qualityLevel = 2;
}Die Klasse enthält Werte für Musik, Soundeffekte, Vollbildmodus und Grafikqualität.
Durch das Attribut [Serializable] kann Unity diese Datenstruktur mit JsonUtility verarbeiten.
Die Klasse selbst speichert noch keine Datei. Dafür benötigst du ein zusätzliches Script, das die Daten serialisiert und in einen geeigneten Speicherort schreibt.
Konfigurationen als JSON speichern und laden
Das folgende Script speichert eine Konfiguration im persistenten Datenverzeichnis und lädt sie bei Bedarf erneut:
using System.IO;
using UnityEngine;
public class GameSettingsManager : MonoBehaviour
{
public GameSettingsData settings =
new GameSettingsData();
private string SettingsPath
{
get
{
return Path.Combine(
Application.persistentDataPath,
"settings.json"
);
}
}
public void SaveSettings()
{
string json = JsonUtility.ToJson(
settings,
true
);
File.WriteAllText(
SettingsPath,
json
);
}
public void LoadSettings()
{
if (!File.Exists(SettingsPath))
{
settings = new GameSettingsData();
return;
}
string json = File.ReadAllText(
SettingsPath
);
settings =
JsonUtility.FromJson<GameSettingsData>(
json
);
}
}Mit Application.persistentDataPath verwendet das Script einen von Unity vorgesehenen Speicherort für dauerhaft benötigte Daten.
Die Methode SaveSettings() wandelt die Konfiguration in JSON um und speichert sie. LoadSettings() liest die Datei wieder ein.
Ist noch keine Datei vorhanden, erstellt das Script eine neue Konfiguration mit den definierten Standardwerten.
Für ein fertiges Spiel solltest du zusätzlich mögliche Lese- und Schreibfehler behandeln sowie die geladenen Werte auf gültige Bereiche prüfen. Auch eine fehlerhafte JSON-Datei darf nicht zu einem unkontrollierten Programmabbruch führen.
Standardwerte und benutzerdefinierte Einstellungen trennen
Bei der Konfiguration eines Spiels ist es sinnvoll, zwischen Standardwerten und gespeicherten Benutzereinstellungen zu unterscheiden.
Standardwerte legst du während der Entwicklung fest. Sie bestimmen, wie das Spiel beim ersten Start konfiguriert ist.
Benutzereinstellungen entstehen dagegen, wenn ein Spieler beispielsweise die Lautstärke verändert oder eine andere Grafikqualität auswählt.
Ein möglicher Aufbau verwendet ein ScriptableObject für die Standardkonfiguration und eine JSON-Datei für die individuellen Einstellungen.
Dadurch kannst du die ursprünglichen Vorgaben unabhängig von den gespeicherten Änderungen verwalten.
Einstellungen auf Standardwerte zurücksetzen
Viele Spiele bieten im Einstellungsmenü eine Funktion zum Wiederherstellen der Standardwerte.
Bei einer JSON-basierten Konfiguration kannst du dafür beispielsweise eine neue Instanz deiner Konfigurationsklasse erstellen und ihre Werte anschließend auf die betreffenden Spielsysteme anwenden.
Wichtig ist, dass die Rücksetzung nicht nur die gespeicherten Daten verändert. Auch die aktuell verwendeten Einstellungen müssen entsprechend aktualisiert werden.
Wenn du beispielsweise die Musiklautstärke zurücksetzt, muss die Audio Source beziehungsweise die entsprechende Audio-Mixer-Gruppe den neuen Wert ebenfalls erhalten.
Konfigurationsdateien über StreamingAssets bereitstellen
Der Ordner StreamingAssets ermöglicht es, bestimmte Dateien weitgehend unverändert in einen Build zu übernehmen.
Das kann für Konfigurationsdateien sinnvoll sein, die zusammen mit dem Spiel ausgeliefert und während der Laufzeit eingelesen werden sollen.
Allerdings ist StreamingAssets nicht auf jeder Plattform als gewöhnlicher beschreibbarer Ordner verfügbar. Besonders bei Android und WebGL musst du die plattformspezifischen Zugriffsbedingungen beachten.
Für Einstellungen, die ein Spieler dauerhaft verändern soll, eignet sich deshalb normalerweise persistentDataPath besser.
Konfigurationen zur Laufzeit verändern
Nicht jede Konfiguration muss während der gesamten Spielzeit unverändert bleiben. Manche Einstellungen können sich abhängig vom Spielgeschehen verändern.
Beispielsweise kann ein Schwierigkeitsgrad die Eigenschaften bestimmter Gegner beeinflussen. Eine Musikoption kann die Lautstärke verändern, während ein Grafikmenü unterschiedliche Qualitätsstufen auswählt.
Entscheidend ist, dass deine Scripts auf solche Änderungen reagieren. Das bloße Verändern eines gespeicherten Konfigurationswerts führt nicht automatisch dazu, dass alle beteiligten Spielsysteme ihre Einstellungen aktualisieren.
Bei größeren Projekten kann ein zentraler Settings Manager die Änderungen verteilen und die betroffenen Komponenten aktualisieren.
Konfigurationen zwischen Szenen erhalten
Wenn du eine neue Szene lädst, werden die gewöhnlichen GameObjects der vorherigen Szene normalerweise entfernt. Ein Settings Manager auf einem solchen GameObject würde dadurch ebenfalls verschwinden.
Mit DontDestroyOnLoad() kannst du ein GameObject über Szenenwechsel hinweg erhalten.
Alternativ können Konfigurationsdaten in geeigneten Assets oder zentralen Datenstrukturen bereitstehen. Welche Lösung sinnvoll ist, hängt von der Architektur deines Spiels ab.
Bei dauerhaft bestehenden Managern solltest du verhindern, dass beim Laden weiterer Szenen mehrere Instanzen entstehen. Sonst können sich unterschiedliche Konfigurationszustände gegenseitig beeinflussen.
Konfigurationen für unterschiedliche Plattformen
Unity-Projekte können für verschiedene Zielplattformen erstellt werden. Entsprechend unterscheiden sich bestimmte technische Anforderungen.
Ein mobiles Spiel benötigt beispielsweise möglicherweise andere Grafik- und Eingabeeinstellungen als eine Desktop-Anwendung.
Unity bietet dafür plattformspezifische Projekteinstellungen und Importoptionen. Darüber hinaus kannst du in eigenen Scripts prüfen, auf welcher Plattform das Spiel ausgeführt wird.
Benutzerdefinierte Konfigurationen solltest du trotzdem möglichst so gestalten, dass sie nur die tatsächlich verfügbaren Funktionen anbieten. Ein Vollbildmodus oder eine bestimmte Bildschirmauflösung lässt sich nicht auf jeder Plattform in gleicher Weise verändern.
Konfigurationen und Versionsverwaltung
Viele Projekteinstellungen liegen in Dateien innerhalb des Projektordners. Bei der Verwendung einer Versionsverwaltung wie Git sollten die relevanten Konfigurationsdateien gemeinsam mit dem Projekt verwaltet werden.
Besonders der Ordner ProjectSettings ist dabei wichtig. Er enthält zahlreiche Einstellungen, die für das Verhalten des Projekts maßgeblich sind.
Auch eigene ScriptableObject-Konfigurationen gehören zu den Projektressourcen und sollten zusammen mit ihren Meta-Dateien erhalten bleiben.
Individuelle Benutzereinstellungen, die ein fertiges Spiel unter persistentDataPath speichert, gehören dagegen normalerweise nicht zur Versionsverwaltung des Entwicklungsprojekts.
Typische Fehler bei Konfigurationen in Unity
Probleme mit Konfigurationen entstehen häufig durch fehlende Referenzen, ungültige Werte oder die Verwechslung von Projekt- und Laufzeiteinstellungen.
- Einstellung wirkt nicht: Prüfe, ob der neue Wert tatsächlich auf das betreffende Spielsystem angewendet wird.
- Werte gehen nach dem Neustart verloren: Kontrolliere, ob sie dauerhaft gespeichert wurden.
- ScriptableObject-Änderungen bleiben im Build nicht erhalten: ScriptableObjects sind nicht automatisch ein dauerhaftes Speichersystem für Benutzereinstellungen.
- JSON-Datei kann nicht geladen werden: Prüfe Dateipfad, Dateiformat und Datenstruktur.
- Grafikeinstellung funktioniert nicht: Die gewählte Option wird möglicherweise von der Zielplattform nicht unterstützt.
- Mehrere Settings Manager: Kontrolliere, ob beim Szenenwechsel zusätzliche Instanzen entstehen.
- Ungültige Werte: Begrenze Eingaben auf sinnvolle Bereiche, bevor du sie an Spielsysteme übergibst.
- Unterschiedliche Einstellungen im Team: Prüfe, ob die relevanten Projektdateien korrekt versioniert wurden.
Welche Konfigurationsmethode eignet sich für dein Spiel?
Unity stellt unterschiedliche Möglichkeiten bereit, Konfigurationsdaten zu verwalten. Die passende Lösung hängt davon ab, welche Werte gespeichert werden und wann sie verfügbar sein müssen.
- Project Settings: Für zentrale technische Vorgaben des Unity-Projekts.
- Preferences: Für persönliche Einstellungen der Entwicklungsumgebung.
- SerializeField: Für direkt im Inspector bearbeitbare Komponentenwerte.
- ScriptableObjects: Für wiederverwendbare Konfigurationsdaten innerhalb des Projekts.
- PlayerPrefs: Für einfache, dauerhaft gespeicherte Benutzereinstellungen.
- JSON-Dateien: Für strukturierte Konfigurationen und größere zusammengehörige Datensätze.
- StreamingAssets: Für bestimmte Konfigurationsdateien, die unverändert mit dem Spiel ausgeliefert werden sollen.
- Settings Manager: Für die zentrale Steuerung und Anwendung verschiedener Laufzeiteinstellungen.
Konfigurationen als Grundlage einer übersichtlichen Spielarchitektur
Eine durchdachte Konfiguration trennt veränderbare Einstellungen von der eigentlichen Spiellogik. Dadurch kannst du Werte anpassen, ohne zahlreiche Scripts einzeln bearbeiten zu müssen.
Unity 2021.1 bietet dafür sowohl integrierte Projekteinstellungen als auch verschiedene Möglichkeiten für eigene Datenstrukturen. Während Project Settings die technischen Grundlagen festlegen, eignen sich ScriptableObjects für gemeinsam verwendete Entwicklungsdaten und PlayerPrefs oder JSON-Dateien für dauerhaft gespeicherte Benutzereinstellungen.
Besonders bei umfangreicheren Spielen lohnt sich eine zentrale Verwaltung. Sie erleichtert die Entwicklung eines Einstellungsmenüs, die Speicherung individueller Optionen und die Anpassung an unterschiedliche Plattformen.
Weitere technische Informationen findest du im offiziellen Unity-Handbuch zu den Projekteinstellungen.
