made icon optional and default to empty string & adjust all game instances

# Conflicts:
#	lib/data/dto/game.dart
#	lib/l10n/arb/app_de.arb
#	lib/l10n/arb/app_en.arb
#	lib/l10n/generated/app_localizations.dart
#	lib/l10n/generated/app_localizations_de.dart
#	lib/presentation/views/main_menu/match_view/create_match/choose_game_view.dart
#	lib/presentation/widgets/text_input/text_input_field.dart
#	pubspec.yaml

analysis_options.yaml

@@ -1,5 +1,9 @@
 include: package:flutter_lints/flutter.yaml
 
+analyzer:
+  exclude:
+    - lib/presentation/views/main_menu/settings_view/licenses/oss_licenses.dart
+
 linter:
   rules:
     avoid_print: false

lib/core/common.dart

@@ -1,4 +1,4 @@
-import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/dto/match.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
@@ -20,6 +20,51 @@ String translateRulesetToString(Ruleset ruleset, BuildContext context) {
   }
 }
 
+/// Translates a [GameColor] enum value to its corresponding localized string.
+String translateGameColorToString(GameColor color, BuildContext context) {
+  final loc = AppLocalizations.of(context);
+  switch (color) {
+    case GameColor.red:
+      return loc.color_red;
+    case GameColor.blue:
+      return loc.color_blue;
+    case GameColor.green:
+      return loc.color_green;
+    case GameColor.yellow:
+      return loc.color_yellow;
+    case GameColor.purple:
+      return loc.color_purple;
+    case GameColor.orange:
+      return loc.color_orange;
+    case GameColor.pink:
+      return loc.color_pink;
+    case GameColor.teal:
+      return loc.color_teal;
+  }
+}
+
+/// Returns the [Color] object corresponding to a [GameColor] enum value.
+Color getColorFromGameColor(GameColor color) {
+  switch (color) {
+    case GameColor.red:
+      return Colors.red;
+    case GameColor.blue:
+      return Colors.blue;
+    case GameColor.green:
+      return Colors.green;
+    case GameColor.yellow:
+      return Colors.yellow;
+    case GameColor.purple:
+      return Colors.purple;
+    case GameColor.orange:
+      return Colors.orange;
+    case GameColor.pink:
+      return Colors.pink;
+    case GameColor.teal:
+      return Colors.teal;
+  }
+}
+
 /// Counts how many players in the match are not part of the group
 /// Returns the count as a string, or an empty string if there is no group
 String getExtraPlayerCount(Match match) {

lib/core/constants.dart

@@ -19,4 +19,7 @@ class Constants {
 
   /// Maximum length for team names
   static const int MAX_TEAM_NAME_LENGTH = 32;
+
+  /// Maximum length for game descriptions
+  static const int MAX_GAME_DESCRIPTION_LENGTH = 256;
 }

lib/data/dto/game.dart

@@ -1,6 +1,6 @@
 import 'package:clock/clock.dart';
-import 'package:uuid/uuid.dart';
 import 'package:tallee/core/enums.dart';
+import 'package:uuid/uuid.dart';
 
 class Game {
   final String id;
@@ -18,10 +18,11 @@ class Game {
     required this.ruleset,
     String? description,
     required this.color,
-    required this.icon,
+    String? icon,
   }) : id = id ?? const Uuid().v4(),
        createdAt = createdAt ?? clock.now(),
-       description = description ?? '';
+       description = description ?? '',
+       icon = icon ?? '';
 
   @override
   String toString() {
@@ -49,4 +50,3 @@ class Game {
     'icon': icon,
   };
 }
-

lib/data/dto/match.dart

@@ -40,9 +40,16 @@ class Match {
   Match.fromJson(Map<String, dynamic> json)
     : id = json['id'],
       createdAt = DateTime.parse(json['createdAt']),
-        endedAt = json['endedAt'] != null ? DateTime.parse(json['endedAt']) : null,
+      endedAt = json['endedAt'] != null
+          ? DateTime.parse(json['endedAt'])
+          : null,
       name = json['name'],
-        game = Game(name: '', ruleset: Ruleset.singleWinner, description: '', color: GameColor.blue, icon: ''), // Populated during import via DataTransferService
+      game = Game(
+        name: '',
+        ruleset: Ruleset.singleWinner,
+        description: '',
+        color: GameColor.blue,
+      ), // Populated during import via DataTransferService
       group = null, // Populated during import via DataTransferService
       players = [], // Populated during import via DataTransferService
       notes = json['notes'] ?? '';

lib/l10n/arb/app_de.arb

@@ -9,7 +9,9 @@
   "choose_game": "Spielvorlage wählen",
   "choose_group": "Gruppe wählen",
   "choose_ruleset": "Regelwerk wählen",
+  "choose_color": "Farbe wählen",
   "could_not_add_player": "Spieler:in {playerName} konnte nicht hinzugefügt werden",
+  "create_game": "Spielvorlage erstellen",
   "create_group": "Gruppe erstellen",
   "create_match": "Spiel erstellen",
   "create_new_group": "Neue Gruppe erstellen",
@@ -24,10 +26,15 @@
   "delete_all_data": "Alle Daten löschen",
   "delete_group": "Diese Gruppe löschen",
   "delete_match": "Spiel löschen",
+  "delete_game": "Spielvorlage löschen",
+  "delete_group": "Gruppe löschen",
+  "description": "Beschreibung",
+  "edit_game": "Spielvorlage bearbeiten",
   "edit_group": "Gruppe bearbeiten",
   "edit_match": "Gruppe bearbeiten",
   "enter_results": "Ergebnisse eintragen",
   "error_creating_group": "Fehler beim Erstellen der Gruppe, bitte erneut versuchen",
+  "error_deleting_game": "Fehler beim Löschen der Spielvorlage, bitte erneut versuchen",
   "error_deleting_group": "Fehler beim Löschen der Gruppe, bitte erneut versuchen",
   "error_editing_group": "Fehler beim Bearbeiten der Gruppe, bitte erneut versuchen",
   "error_reading_file": "Fehler beim Lesen der Datei",
@@ -106,5 +113,14 @@
   "winner": "Gewinner:in",
   "winrate": "Siegquote",
   "wins": "Siege",
-  "yesterday_at": "Gestern um"
+  "yesterday_at": "Gestern um",
+  "color_red": "Rot",
+  "color_blue": "Blau",
+  "color_green": "Grün",
+  "color_yellow": "Gelb",
+  "color_purple": "Lila",
+  "color_orange": "Orange",
+  "color_pink": "Rosa",
+  "color_teal": "Türkis",
+  "color": "Farbe"
 }

lib/l10n/arb/app_en.arb

@@ -27,9 +27,15 @@
   "@choose_ruleset": {
     "description": "Label for choosing a ruleset"
   },
+  "@choose_color": {
+    "description": "Label for choosing a color"
+  },
   "@could_not_add_player": {
     "description": "Error message when adding a player fails"
   },
+  "@create_game": {
+    "description": "Button text to create a game"
+  },
   "@create_group": {
     "description": "Button text to create a group"
   },
@@ -71,12 +77,21 @@
   "@delete_all_data": {
     "description": "Confirmation dialog for deleting all data"
   },
+  "@delete_game": {
+    "description": "Button text to delete a game"
+  },
   "@delete_group": {
     "description": "Confirmation dialog for deleting a group"
   },
   "@delete_match": {
     "description": "Button text to delete a match"
   },
+  "description": {
+    "description": "Description label"
+  },
+  "edit_game": {
+    "description": "Button text to edit a game"
+   },
   "@edit_group": {
       "description": "Button & Appbar label for editing a group"
   },
@@ -89,6 +104,9 @@
   "@error_creating_group": {
     "description": "Error message when group creation fails"
   },
+  "@error_deleting_game": {
+    "description": "Error message when game deletion fails"
+  },
   "@error_deleting_group": {
       "description": "Error message when group deletion fails"
   },
@@ -325,6 +343,9 @@
   "@yesterday_at": {
     "description": "Date format for yesterday"
   },
+  "@color": {
+    "description": "Color label"
+  },
   "all_players": "All players",
   "all_players_selected": "All players selected",
   "amount_of_matches": "Amount of Matches",
@@ -334,7 +355,9 @@
   "choose_game": "Choose Game",
   "choose_group": "Choose Group",
   "choose_ruleset": "Choose Ruleset",
+  "choose_color": "Choose Color",
   "could_not_add_player": "Could not add player",
+  "create_game": "Create Game",
   "create_group": "Create Group",
   "create_match": "Create match",
   "create_new_group": "Create new group",
@@ -347,12 +370,16 @@
   "days_ago": "{count} days ago",
   "delete": "Delete",
   "delete_all_data": "Delete all data",
+  "delete_game": "Delete Game",
   "delete_group": "Delete Group",
   "delete_match": "Delete Match",
+  "description": "Description",
+  "edit_game": "Edit Game",
   "edit_group": "Edit Group",
   "edit_match": "Edit Match",
   "enter_results": "Enter Results",
   "error_creating_group": "Error while creating group, please try again",
+  "error_deleting_game": "Error while deleting game, please try again",
   "error_deleting_group": "Error while deleting group, please try again",
   "error_editing_group": "Error while editing group, please try again",
   "error_reading_file": "Error reading file",
@@ -430,5 +457,14 @@
   "winner": "Winner",
   "winrate": "Winrate",
   "wins": "Wins",
-  "yesterday_at": "Yesterday at"
+  "yesterday_at": "Yesterday at",
+  "color_red": "Red",
+  "color_blue": "Blue",
+  "color_green": "Green",
+  "color_yellow": "Yellow",
+  "color_purple": "Purple",
+  "color_orange": "Orange",
+  "color_pink": "Pink",
+  "color_teal": "Teal",
+  "color": "Color"
 }

lib/l10n/generated/app_localizations.dart

@@ -98,6 +98,18 @@ abstract class AppLocalizations {
     Locale('en'),
   ];
 
+  /// No description provided for @description.
+  ///
+  /// In en, this message translates to:
+  /// **'Description'**
+  String get description;
+
+  /// No description provided for @edit_game.
+  ///
+  /// In en, this message translates to:
+  /// **'Edit Game'**
+  String get edit_game;
+
   /// Label for all players list
   ///
   /// In en, this message translates to:
@@ -152,12 +164,24 @@ abstract class AppLocalizations {
   /// **'Choose Ruleset'**
   String get choose_ruleset;
 
+  /// Label for choosing a color
+  ///
+  /// In en, this message translates to:
+  /// **'Choose Color'**
+  String get choose_color;
+
   /// Error message when adding a player fails
   ///
   /// In en, this message translates to:
   /// **'Could not add player'**
   String could_not_add_player(Object playerName);
 
+  /// Button text to create a game
+  ///
+  /// In en, this message translates to:
+  /// **'Create Game'**
+  String get create_game;
+
   /// Button text to create a group
   ///
   /// In en, this message translates to:
@@ -230,6 +254,12 @@ abstract class AppLocalizations {
   /// **'Delete all data'**
   String get delete_all_data;
 
+  /// Button text to delete a game
+  ///
+  /// In en, this message translates to:
+  /// **'Delete Game'**
+  String get delete_game;
+
   /// Confirmation dialog for deleting a group
   ///
   /// In en, this message translates to:
@@ -266,6 +296,12 @@ abstract class AppLocalizations {
   /// **'Error while creating group, please try again'**
   String get error_creating_group;
 
+  /// Error message when game deletion fails
+  ///
+  /// In en, this message translates to:
+  /// **'Error while deleting game, please try again'**
+  String get error_deleting_game;
+
   /// Error message when group deletion fails
   ///
   /// In en, this message translates to:
@@ -733,6 +769,60 @@ abstract class AppLocalizations {
   /// In en, this message translates to:
   /// **'Yesterday at'**
   String get yesterday_at;
+
+  /// No description provided for @color_red.
+  ///
+  /// In en, this message translates to:
+  /// **'Red'**
+  String get color_red;
+
+  /// No description provided for @color_blue.
+  ///
+  /// In en, this message translates to:
+  /// **'Blue'**
+  String get color_blue;
+
+  /// No description provided for @color_green.
+  ///
+  /// In en, this message translates to:
+  /// **'Green'**
+  String get color_green;
+
+  /// No description provided for @color_yellow.
+  ///
+  /// In en, this message translates to:
+  /// **'Yellow'**
+  String get color_yellow;
+
+  /// No description provided for @color_purple.
+  ///
+  /// In en, this message translates to:
+  /// **'Purple'**
+  String get color_purple;
+
+  /// No description provided for @color_orange.
+  ///
+  /// In en, this message translates to:
+  /// **'Orange'**
+  String get color_orange;
+
+  /// No description provided for @color_pink.
+  ///
+  /// In en, this message translates to:
+  /// **'Pink'**
+  String get color_pink;
+
+  /// No description provided for @color_teal.
+  ///
+  /// In en, this message translates to:
+  /// **'Teal'**
+  String get color_teal;
+
+  /// Color label
+  ///
+  /// In en, this message translates to:
+  /// **'Color'**
+  String get color;
 }
 
 class _AppLocalizationsDelegate

lib/l10n/generated/app_localizations_de.dart

@@ -8,6 +8,12 @@ import 'app_localizations.dart';
 class AppLocalizationsDe extends AppLocalizations {
   AppLocalizationsDe([String locale = 'de']) : super(locale);
 
+  @override
+  String get description => 'Beschreibung';
+
+  @override
+  String get edit_game => 'Spielvorlage bearbeiten';
+
   @override
   String get all_players => 'Alle Spieler:innen';
 
@@ -35,11 +41,17 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get choose_ruleset => 'Regelwerk wählen';
 
+  @override
+  String get choose_color => 'Farbe wählen';
+
   @override
   String could_not_add_player(Object playerName) {
     return 'Spieler:in $playerName konnte nicht hinzugefügt werden';
   }
 
+  @override
+  String get create_game => 'Spielvorlage erstellen';
+
   @override
   String get create_group => 'Gruppe erstellen';
 
@@ -79,7 +91,10 @@ class AppLocalizationsDe extends AppLocalizations {
   String get delete_all_data => 'Alle Daten löschen';
 
   @override
-  String get delete_group => 'Diese Gruppe löschen';
+  String get delete_game => 'Spielvorlage löschen';
+
+  @override
+  String get delete_group => 'Gruppe löschen';
 
   @override
   String get delete_match => 'Spiel löschen';
@@ -97,6 +112,10 @@ class AppLocalizationsDe extends AppLocalizations {
   String get error_creating_group =>
       'Fehler beim Erstellen der Gruppe, bitte erneut versuchen';
 
+  @override
+  String get error_deleting_game =>
+      'Fehler beim Löschen der Spielvorlage, bitte erneut versuchen';
+
   @override
   String get error_deleting_group =>
       'Fehler beim Löschen der Gruppe, bitte erneut versuchen';
@@ -343,4 +362,31 @@ class AppLocalizationsDe extends AppLocalizations {
 
   @override
   String get yesterday_at => 'Gestern um';
+
+  @override
+  String get color_red => 'Rot';
+
+  @override
+  String get color_blue => 'Blau';
+
+  @override
+  String get color_green => 'Grün';
+
+  @override
+  String get color_yellow => 'Gelb';
+
+  @override
+  String get color_purple => 'Lila';
+
+  @override
+  String get color_orange => 'Orange';
+
+  @override
+  String get color_pink => 'Rosa';
+
+  @override
+  String get color_teal => 'Türkis';
+
+  @override
+  String get color => 'Farbe';
 }

lib/l10n/generated/app_localizations_en.dart

@@ -8,6 +8,12 @@ import 'app_localizations.dart';
 class AppLocalizationsEn extends AppLocalizations {
   AppLocalizationsEn([String locale = 'en']) : super(locale);
 
+  @override
+  String get description => 'Description';
+
+  @override
+  String get edit_game => 'Edit Game';
+
   @override
   String get all_players => 'All players';
 
@@ -35,11 +41,17 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get choose_ruleset => 'Choose Ruleset';
 
+  @override
+  String get choose_color => 'Choose Color';
+
   @override
   String could_not_add_player(Object playerName) {
     return 'Could not add player';
   }
 
+  @override
+  String get create_game => 'Create Game';
+
   @override
   String get create_group => 'Create Group';
 
@@ -78,6 +90,9 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get delete_all_data => 'Delete all data';
 
+  @override
+  String get delete_game => 'Delete Game';
+
   @override
   String get delete_group => 'Delete Group';
 
@@ -97,6 +112,10 @@ class AppLocalizationsEn extends AppLocalizations {
   String get error_creating_group =>
       'Error while creating group, please try again';
 
+  @override
+  String get error_deleting_game =>
+      'Error while deleting game, please try again';
+
   @override
   String get error_deleting_group =>
       'Error while deleting group, please try again';
@@ -342,4 +361,31 @@ class AppLocalizationsEn extends AppLocalizations {
 
   @override
   String get yesterday_at => 'Yesterday at';
+
+  @override
+  String get color_red => 'Red';
+
+  @override
+  String get color_blue => 'Blue';
+
+  @override
+  String get color_green => 'Green';
+
+  @override
+  String get color_yellow => 'Yellow';
+
+  @override
+  String get color_purple => 'Purple';
+
+  @override
+  String get color_orange => 'Orange';
+
+  @override
+  String get color_pink => 'Pink';
+
+  @override
+  String get color_teal => 'Teal';
+
+  @override
+  String get color => 'Color';
 }

lib/presentation/views/main_menu/home_view.dart

@@ -42,7 +42,12 @@ class _HomeViewState extends State<HomeView> {
     2,
     Match(
       name: 'Skeleton Match',
-      game: Game(name: '', ruleset: Ruleset.singleWinner, description: '', color: GameColor.blue, icon: ''),
+      game: Game(
+        name: '',
+        ruleset: Ruleset.singleWinner,
+        description: '',
+        color: GameColor.blue,
+      ),
       group: Group(
         name: 'Skeleton Group',
         description: '',
@@ -104,7 +109,9 @@ class _HomeViewState extends State<HomeView> {
                         if (recentMatches.isNotEmpty)
                           for (Match match in recentMatches)
                             Padding(
-                              padding: const EdgeInsets.symmetric(vertical: 6.0),
+                              padding: const EdgeInsets.symmetric(
+                                vertical: 6.0,
+                              ),
                               child: MatchTile(
                                 compact: true,
                                 width: constraints.maxWidth * 0.9,
@@ -113,7 +120,8 @@ class _HomeViewState extends State<HomeView> {
                                   await Navigator.of(context).push(
                                     adaptivePageRoute(
                                       fullscreenDialog: true,
-                                      builder: (context) => MatchResultView(match: match),
+                                      builder: (context) =>
+                                          MatchResultView(match: match),
                                     ),
                                   );
                                   await updatedWinnerInRecentMatches(match.id);
@@ -121,7 +129,10 @@ class _HomeViewState extends State<HomeView> {
                               ),
                             )
                         else
-                          Center(heightFactor: 5, child: Text(loc.no_recent_matches_available)),
+                          Center(
+                            heightFactor: 5,
+                            child: Text(loc.no_recent_matches_available),
+                          ),
                       ],
                     ),
                   ),
@@ -137,22 +148,40 @@ class _HomeViewState extends State<HomeView> {
                         Row(
                           mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                           children: [
-                            QuickCreateButton(text: 'Category 1', onPressed: () {}),
+                            QuickCreateButton(
-                            QuickCreateButton(text: 'Category 2', onPressed: () {}),
+                              text: 'Category 1',
+                              onPressed: () {},
+                            ),
+                            QuickCreateButton(
+                              text: 'Category 2',
+                              onPressed: () {},
+                            ),
                           ],
                         ),
                         Row(
                           mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                           children: [
-                            QuickCreateButton(text: 'Category 3', onPressed: () {}),
+                            QuickCreateButton(
-                            QuickCreateButton(text: 'Category 4', onPressed: () {}),
+                              text: 'Category 3',
+                              onPressed: () {},
+                            ),
+                            QuickCreateButton(
+                              text: 'Category 4',
+                              onPressed: () {},
+                            ),
                           ],
                         ),
                         Row(
                           mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                           children: [
-                            QuickCreateButton(text: 'Category 5', onPressed: () {}),
+                            QuickCreateButton(
-                            QuickCreateButton(text: 'Category 6', onPressed: () {}),
+                              text: 'Category 5',
+                              onPressed: () {},
+                            ),
+                            QuickCreateButton(
+                              text: 'Category 6',
+                              onPressed: () {},
+                            ),
                           ],
                         ),
                       ],
@@ -181,7 +210,9 @@ class _HomeViewState extends State<HomeView> {
       matchCount = results[0] as int;
       groupCount = results[1] as int;
       loadedRecentMatches = results[2] as List<Match>;
-      recentMatches = (loadedRecentMatches..sort((a, b) => b.createdAt.compareTo(a.createdAt)))
+      recentMatches =
+          (loadedRecentMatches
+                ..sort((a, b) => b.createdAt.compareTo(a.createdAt)))
               .take(2)
               .toList();
       if (mounted) {

lib/presentation/views/main_menu/match_view/create_match/choose_game_view.dart

@@ -1,26 +1,33 @@
 import 'package:flutter/material.dart';
+import 'package:tallee/core/adaptive_page_route.dart';
 import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
-import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
+import 'package:tallee/presentation/views/main_menu/match_view/create_match/game_view/create_game_view.dart';
 import 'package:tallee/presentation/widgets/text_input/custom_search_bar.dart';
 import 'package:tallee/presentation/widgets/tiles/title_description_list_tile.dart';
 
 class ChooseGameView extends StatefulWidget {
   /// A view that allows the user to choose a game from a list of available games
-  /// - [games]: A list of tuples containing the game name, description and ruleset
+  /// - [games]: The list of available games
-  /// - [initialGameIndex]: The index of the initially selected game
+  /// - [initialSelectedGameId]: The id of the initially selected game
+  /// - [onGamesUpdated]: Optional callback invoked when the games are updated
   const ChooseGameView({
     super.key,
     required this.games,
-    required this.initialGameIndex,
+    required this.initialSelectedGameId,
+    this.onGamesUpdated,
   });
 
   /// A list of tuples containing the game name, description and ruleset
-  final List<(String, String, Ruleset)> games;
+  final List<Game> games;
 
   /// The index of the initially selected game
-  final int initialGameIndex;
+  final String initialSelectedGameId;
+
+  /// Optional callback invoked when the games are updated
+  final VoidCallback? onGamesUpdated;
 
   @override
   State<ChooseGameView> createState() => _ChooseGameViewState();
@@ -30,12 +37,18 @@ class _ChooseGameViewState extends State<ChooseGameView> {
   /// Controller for the search bar
   final TextEditingController searchBarController = TextEditingController();
 
-  /// Currently selected game index
+  /// Currently selected game id
-  late int selectedGameIndex;
+  late String selectedGameId;
+
+  /// Games filtered according to the current search query
+  late List<Game> filteredGames;
 
   @override
   void initState() {
-    selectedGameIndex = widget.initialGameIndex;
+    selectedGameId = widget.initialSelectedGameId;
+
+    // Start with all games visible
+    filteredGames = List<Game>.from(widget.games);
     super.initState();
   }
 
@@ -49,9 +62,32 @@ class _ChooseGameViewState extends State<ChooseGameView> {
         leading: IconButton(
           icon: const Icon(Icons.arrow_back_ios),
           onPressed: () {
-            Navigator.of(context).pop(selectedGameIndex);
+            Navigator.of(context).pop(selectedGameId);
           },
         ),
+        actions: [
+          IconButton(
+            icon: const Icon(Icons.add),
+            onPressed: () async {
+              final result = await Navigator.push(
+                context,
+                adaptivePageRoute(
+                  builder: (context) => CreateGameView(
+                    onGameChanged: () {
+                      widget.onGamesUpdated?.call();
+                    },
+                  ),
+                ),
+              );
+              if (result != null && result.game != null) {
+                setState(() {
+                  widget.games.insert(0, result.game);
+                });
+                _refreshFromSource();
+              }
+            },
+          ),
+        ],
         title: Text(loc.choose_game),
       ),
       body: PopScope(
@@ -62,7 +98,7 @@ class _ChooseGameViewState extends State<ChooseGameView> {
           if (didPop) {
             return;
           }
-          Navigator.of(context).pop(selectedGameIndex);
+          Navigator.of(context).pop(selectedGameId);
         },
         child: Column(
           children: [
@@ -71,30 +107,63 @@ class _ChooseGameViewState extends State<ChooseGameView> {
               child: CustomSearchBar(
                 controller: searchBarController,
                 hintText: loc.game_name,
+                onChanged: (value) {
+                  _applySearchFilter(value);
+                },
               ),
             ),
             const SizedBox(height: 5),
             Expanded(
               child: ListView.builder(
-                itemCount: widget.games.length,
+                itemCount: filteredGames.length,
                 itemBuilder: (BuildContext context, int index) {
+                  final game = filteredGames[index];
                   return TitleDescriptionListTile(
-                    title: widget.games[index].$1,
+                    title: game.name,
-                    description: widget.games[index].$2,
+                    description: game.description,
-                    badgeText: translateRulesetToString(
+                    badgeText: translateRulesetToString(game.ruleset, context),
-                      widget.games[index].$3,
+                    isHighlighted: selectedGameId == game.id,
-                      context,
+                    onTap: () async {
-                    ),
-                    isHighlighted: selectedGameIndex == index,
-                    onPressed: () async {
                       setState(() {
-                        if (selectedGameIndex == index) {
+                        if (selectedGameId == game.id) {
-                          selectedGameIndex = -1;
+                          selectedGameId = '';
                         } else {
-                          selectedGameIndex = index;
+                          selectedGameId = game.id;
                         }
                       });
                     },
+                    onLongPress: () async {
+                      final result = await Navigator.push(
+                        context,
+                        adaptivePageRoute(
+                          builder: (context) => CreateGameView(
+                            gameToEdit: game,
+                            onGameChanged: () {
+                              widget.onGamesUpdated?.call();
+                            },
+                          ),
+                        ),
+                      );
+                      if (result != null && result.game != null) {
+                        // Find the index in the original list to mutate
+                        final originalIndex = widget.games.indexWhere(
+                          (g) => g.id == game.id,
+                        );
+                        if (originalIndex == -1) {
+                          return;
+                        }
+                        if (result.delete) {
+                          setState(() {
+                            widget.games.removeAt(originalIndex);
+                          });
+                        } else {
+                          setState(() {
+                            widget.games[originalIndex] = result.game;
+                          });
+                        }
+                        _refreshFromSource();
+                      }
+                    },
                   );
                 },
               ),
@@ -104,4 +173,28 @@ class _ChooseGameViewState extends State<ChooseGameView> {
       ),
     );
   }
+
+  /// Applies the search filter to the games list based on [query].
+  void _applySearchFilter(String query) {
+    final q = query.toLowerCase().trim();
+    if (q.isEmpty) {
+      setState(() {
+        filteredGames = List<Game>.from(widget.games);
+      });
+      return;
+    }
+
+    setState(() {
+      filteredGames = widget.games.where((game) {
+        final name = game.name.toLowerCase();
+        final description = game.description.toLowerCase();
+        return name.contains(q) || description.contains(q);
+      }).toList();
+    });
+  }
+
+  /// Re-applies the current filter after the underlying games list changed.
+  void _refreshFromSource() {
+    _applySearchFilter(searchBarController.text);
+  }
 }

lib/presentation/views/main_menu/match_view/create_match/create_match_view.dart

@@ -18,9 +18,13 @@ import 'package:tallee/presentation/widgets/player_selection.dart';
 import 'package:tallee/presentation/widgets/text_input/text_input_field.dart';
 import 'package:tallee/presentation/widgets/tiles/choose_tile.dart';
 
+/// A stateful widget for creating or editing a match.
 class CreateMatchView extends StatefulWidget {
-  /// A view that allows creating a new match
+  /// Constructor for `CreateMatchView`.
-  /// [onWinnerChanged]: Optional callback invoked when the winner is changed
+  ///
+  /// [onWinnerChanged] is an optional callback invoked when the winner is changed.
+  /// [matchToEdit] is an optional match to prefill the fields.
+  /// [onMatchUpdated] is an optional callback invoked when the match is updated.
   const CreateMatchView({
     super.key,
     this.onWinnerChanged,
@@ -28,45 +32,49 @@ class CreateMatchView extends StatefulWidget {
     this.onMatchUpdated,
   });
 
-  /// Optional callback invoked when the winner is changed
+  /// Optional callback invoked when the winner is changed.
   final VoidCallback? onWinnerChanged;
 
-  /// Optional callback invoked when the match is updated
+  /// Optional callback invoked when the match is updated.
   final void Function(Match)? onMatchUpdated;
 
-  /// An optional match to prefill the fields
+  /// An optional match to prefill the fields.
   final Match? matchToEdit;
 
   @override
   State<CreateMatchView> createState() => _CreateMatchViewState();
 }
 
+/// The state class for `CreateMatchView`, managing the UI and logic for creating or editing a match.
 class _CreateMatchViewState extends State<CreateMatchView> {
+  /// The database instance for accessing match data.
   late final AppDatabase db;
 
-  /// Controller for the match name input field
+  /// Controller for the match name input field.
   final TextEditingController _matchNameController = TextEditingController();
 
-  /// Hint text for the match name input field
+  /// Hint text for the match name input field.
   String? hintText;
 
-  /// List of all groups from the database
+  /// List of all games from the database.
+  List<Game> gamesList = [];
+
+  /// List of all groups from the database.
   List<Group> groupsList = [];
 
-  /// List of all players from the database
+  /// List of all players from the database.
   List<Player> playerList = [];
 
-  /// The currently selected group
+  /// The currently selected group.
   Group? selectedGroup;
 
-  /// The index of the currently selected game in [games] to mark it in
+  /// The currently selected game.
-  /// the [ChooseGameView]
+  Game? selectedGame;
-  int selectedGameIndex = -1;
 
-  /// The currently selected players
+  /// The currently selected players.
   List<Player> selectedPlayers = [];
 
-  /// GlobalKey for ScaffoldMessenger to show snackbars
+  /// GlobalKey for ScaffoldMessenger to show snackbars.
   final _scaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
 
   @override
@@ -78,14 +86,18 @@ class _CreateMatchViewState extends State<CreateMatchView> {
 
     db = Provider.of<AppDatabase>(context, listen: false);
 
+    // Load games, groups, and players from the database.
     Future.wait([
+      db.gameDao.getAllGames(),
       db.groupDao.getAllGroups(),
       db.playerDao.getAllPlayers(),
     ]).then((result) async {
-      groupsList = result[0] as List<Group>;
+      gamesList = result[0] as List<Game>;
-      playerList = result[1] as List<Player>;
+      gamesList.sort((a, b) => b.createdAt.compareTo(a.createdAt));
+      groupsList = result[1] as List<Group>;
+      playerList = result[2] as List<Player>;
 
-      // If a match is provided, prefill the fields
+      // If a match is provided, prefill the fields.
       if (widget.matchToEdit != null) {
         prefillMatchDetails();
       }
@@ -105,11 +117,6 @@ class _CreateMatchViewState extends State<CreateMatchView> {
     hintText ??= loc.match_name;
   }
 
-  List<(String, String, Ruleset)> games = [
-    ('Example Game 1', 'This is a description', Ruleset.lowestScore),
-    ('Example Game 2', '', Ruleset.singleWinner),
-  ];
-
   @override
   Widget build(BuildContext context) {
     final loc = AppLocalizations.of(context);
@@ -130,6 +137,7 @@ class _CreateMatchViewState extends State<CreateMatchView> {
           child: Column(
             mainAxisAlignment: MainAxisAlignment.start,
             children: [
+              // Match name input field.
               Container(
                 margin: CustomTheme.tileMargin,
                 child: TextInputField(
@@ -138,38 +146,48 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                   maxLength: Constants.MAX_MATCH_NAME_LENGTH,
                 ),
               ),
+              // Game selection tile.
               ChooseTile(
                 title: loc.game,
-                trailingText: selectedGameIndex == -1
+                trailingText: selectedGame == null
                     ? loc.none
-                    : games[selectedGameIndex].$1,
+                    : selectedGame!.name,
                 onPressed: () async {
-                  selectedGameIndex = await Navigator.of(context).push(
+                  final String? selectedGameId = await Navigator.of(context)
+                      .push(
                         adaptivePageRoute(
                           builder: (context) => ChooseGameView(
-                        games: games,
+                            games: gamesList,
-                        initialGameIndex: selectedGameIndex,
+                            initialSelectedGameId: selectedGame?.id ?? '',
+                            onGamesUpdated: loadGames,
                           ),
                         ),
                       );
+
+                  try {
+                    selectedGame = gamesList.firstWhere(
+                      (g) => g.id == selectedGameId,
+                    );
+                  } catch (_) {
+                    selectedGame = null;
+                  }
+
                   setState(() {
-                    if (selectedGameIndex != -1) {
+                    if (selectedGame != null) {
-                      hintText = games[selectedGameIndex].$1;
+                      hintText = selectedGame!.name;
                     } else {
                       hintText = loc.match_name;
                     }
                   });
                 },
               ),
+              // Group selection tile.
               ChooseTile(
                 title: loc.group,
                 trailingText: selectedGroup == null
                     ? loc.none_group
                     : selectedGroup!.name,
                 onPressed: () async {
-                  // Remove all players from the previously selected group from
-                  // the selected players list, in case the user deselects the
-                  // group or selects a different group.
                   selectedPlayers.removeWhere(
                     (player) =>
                         selectedGroup?.members.any(
@@ -196,6 +214,7 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                   });
                 },
               ),
+              // Player selection widget.
               Expanded(
                 child: PlayerSelection(
                   key: ValueKey(selectedGroup?.id ?? 'no_group'),
@@ -208,6 +227,7 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                   },
                 ),
               ),
+              // Create or save button.
               CustomWidthButton(
                 text: buttonText,
                 sizeRelativeToWidth: 0.95,
@@ -229,16 +249,16 @@ class _CreateMatchViewState extends State<CreateMatchView> {
   ///
   /// Returns `true` if:
   /// - A ruleset is selected AND
-  /// - Either a group is selected OR at least 2 players are selected
+  /// - Either a group is selected OR at least 2 players are selected.
   bool _enableCreateGameButton() {
     return (selectedGroup != null ||
-        (selectedPlayers.length > 1) && selectedGameIndex != -1);
+        (selectedPlayers.length > 1) && selectedGame != null);
   }
 
-  // If a match was provided to the view, it updates the match in the database
+  /// Handles navigation when the create or save button is pressed.
-  // and navigates back to the previous screen.
+  ///
-  // If no match was provided, it creates a new match in the database and
+  /// If a match is being edited, updates the match in the database.
-  // navigates to the MatchResultView for the newly created match.
+  /// Otherwise, creates a new match and navigates to the MatchResultView.
   void buttonNavigation(BuildContext context) async {
     if (widget.matchToEdit != null) {
       await updateMatch();
@@ -263,12 +283,8 @@ class _CreateMatchViewState extends State<CreateMatchView> {
     }
   }
 
-  /// Updates attributes of the existing match in the database based on the
+  /// Updates the existing match in the database.
-  /// changes made in the edit view.
   Future<void> updateMatch() async {
-    //TODO: Remove when Games implemented
-    final tempGame = await getTemporaryGame();
-
     final updatedMatch = Match(
       id: widget.matchToEdit!.id,
       name: _matchNameController.text.isEmpty
@@ -276,7 +292,7 @@ class _CreateMatchViewState extends State<CreateMatchView> {
           : _matchNameController.text.trim(),
       group: selectedGroup,
       players: selectedPlayers,
-      game: tempGame,
+      game: selectedGame!,
       winner: widget.matchToEdit!.winner,
       createdAt: widget.matchToEdit!.createdAt,
       endedAt: widget.matchToEdit!.endedAt,
@@ -297,7 +313,13 @@ class _CreateMatchViewState extends State<CreateMatchView> {
       );
     }
 
-    // Add players who are in updatedMatch but not in the original match
+    if (widget.matchToEdit!.game.id != updatedMatch.game.id) {
+      await db.matchDao.updateMatchGame(
+        matchId: widget.matchToEdit!.id,
+        gameId: updatedMatch.game.id,
+      );
+    }
+
     for (var player in updatedMatch.players) {
       if (!widget.matchToEdit!.players.any((p) => p.id == player.id)) {
         await db.playerMatchDao.addPlayerToMatch(
@@ -307,7 +329,6 @@ class _CreateMatchViewState extends State<CreateMatchView> {
       }
     }
 
-    // Remove players who are in the original match but not in updatedMatch
     for (var player in widget.matchToEdit!.players) {
       if (!updatedMatch.players.any((p) => p.id == player.id)) {
         await db.playerMatchDao.removePlayerFromMatch(
@@ -323,11 +344,8 @@ class _CreateMatchViewState extends State<CreateMatchView> {
     widget.onMatchUpdated?.call(updatedMatch);
   }
 
-  // Creates a new match and adds it to the database.
+  /// Creates a new match and adds it to the database.
-  // Returns the created match.
   Future<Match> createMatch() async {
-    final tempGame = await getTemporaryGame();
-
     Match match = Match(
       name: _matchNameController.text.isEmpty
           ? (hintText ?? '')
@@ -335,42 +353,25 @@ class _CreateMatchViewState extends State<CreateMatchView> {
       createdAt: DateTime.now(),
       group: selectedGroup,
       players: selectedPlayers,
-      game: tempGame,
+      game: selectedGame!,
     );
     await db.matchDao.addMatch(match: match);
     return match;
   }
 
-  // TODO: Remove when games fully implemented
+  /// Prefills the input fields if a match was provided to the view.
-  Future<Game> getTemporaryGame() async {
-    Game? game;
-
-    final selectedGame = games[selectedGameIndex];
-    game = Game(
-      name: selectedGame.$1,
-      description: selectedGame.$2,
-      ruleset: selectedGame.$3,
-      color: GameColor.blue,
-      icon: '',
-    );
-
-    await db.gameDao.addGame(game: game);
-    return game;
-  }
-
-  // If a match was provided to the view, this method prefills the input fields
   void prefillMatchDetails() {
     final match = widget.matchToEdit!;
     _matchNameController.text = match.name;
     selectedPlayers = match.players;
+    selectedGame = match.game;
 
     if (match.group != null) {
       selectedGroup = match.group;
     }
   }
 
-  // If none of the selected players are from the currently selected group,
+  /// Removes the group if none of its members are in the selected players list.
-  // the group is also deselected.
   Future<void> removeGroupWhenNoMemberLeft() async {
     if (selectedGroup == null) return;
 
@@ -383,4 +384,13 @@ class _CreateMatchViewState extends State<CreateMatchView> {
       });
     }
   }
+
+  /// Loads all games from the database and updates the state.
+  Future<void> loadGames() async {
+    final result = await db.gameDao.getAllGames();
+    result.sort((a, b) => b.createdAt.compareTo(a.createdAt));
+    setState(() {
+      gamesList = result;
+    });
+  }
 }

lib/presentation/views/main_menu/match_view/create_match/game_view/choose_color_view.dart

@@ -0,0 +1,78 @@
+import 'package:flutter/material.dart';
+import 'package:tallee/core/common.dart';
+import 'package:tallee/core/custom_theme.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/l10n/generated/app_localizations.dart';
+import 'package:tallee/presentation/widgets/tiles/title_description_list_tile.dart';
+
+class ChooseColorView extends StatefulWidget {
+  /// A view that allows the user to choose a color from a list of available game colors
+  /// - [initialColor]: The initially selected color
+  const ChooseColorView({super.key, this.initialColor});
+
+  /// The initially selected color
+  final GameColor? initialColor;
+
+  @override
+  State<ChooseColorView> createState() => _ChooseColorViewState();
+}
+
+class _ChooseColorViewState extends State<ChooseColorView> {
+  /// Currently selected color
+  GameColor? selectedColor;
+
+  @override
+  void initState() {
+    selectedColor = widget.initialColor;
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final loc = AppLocalizations.of(context);
+    const colors = GameColor.values;
+
+    return Scaffold(
+      backgroundColor: CustomTheme.backgroundColor,
+      appBar: AppBar(
+        leading: IconButton(
+          icon: const Icon(Icons.arrow_back_ios),
+          onPressed: () {
+            Navigator.of(context).pop(selectedColor);
+          },
+        ),
+        title: Text(loc.choose_color),
+      ),
+      body: PopScope(
+        canPop: false,
+        onPopInvokedWithResult: (bool didPop, Object? result) {
+          if (didPop) return;
+          Navigator.of(context).pop(selectedColor);
+        },
+        child: ListView.builder(
+          padding: const EdgeInsets.only(bottom: 85),
+          itemCount: colors.length,
+          itemBuilder: (BuildContext context, int index) {
+            final color = colors[index];
+            return TitleDescriptionListTile(
+              onTap: () {
+                setState(() {
+                  if (selectedColor == color) {
+                    selectedColor = null;
+                  } else {
+                    selectedColor = color;
+                  }
+                });
+              },
+              title: translateGameColorToString(color, context),
+              description: '',
+              isHighlighted: selectedColor == color,
+              badgeText: '          ', //Breite für Color Badge
+              badgeColor: getColorFromGameColor(color),
+            );
+          },
+        ),
+      ),
+    );
+  }
+}

lib/presentation/views/main_menu/match_view/create_match/game_view/choose_ruleset_view.dart

@@ -0,0 +1,99 @@
+import 'package:flutter/material.dart';
+import 'package:tallee/core/common.dart';
+import 'package:tallee/core/custom_theme.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/l10n/generated/app_localizations.dart';
+import 'package:tallee/presentation/widgets/tiles/title_description_list_tile.dart';
+
+class ChooseRulesetView extends StatefulWidget {
+  /// A view that allows the user to choose a ruleset from a list of available rulesets
+  /// - [rulesets]: A list of tuples containing the ruleset and its description
+  /// - [initialRulesetIndex]: The index of the initially selected ruleset
+  const ChooseRulesetView({
+    super.key,
+    required this.rulesets,
+    required this.initialRulesetIndex,
+  });
+
+  /// A list of tuples containing the ruleset and its description
+  final List<(Ruleset, String)> rulesets;
+
+  /// The index of the initially selected ruleset
+  final int initialRulesetIndex;
+  @override
+  State<ChooseRulesetView> createState() => _ChooseRulesetViewState();
+}
+
+class _ChooseRulesetViewState extends State<ChooseRulesetView> {
+  /// Currently selected ruleset index
+  late int selectedRulesetIndex;
+
+  @override
+  void initState() {
+    selectedRulesetIndex = widget.initialRulesetIndex;
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final loc = AppLocalizations.of(context);
+    return DefaultTabController(
+      length: 2,
+      initialIndex: 0,
+      child: Scaffold(
+        backgroundColor: CustomTheme.backgroundColor,
+        appBar: AppBar(
+          leading: IconButton(
+            icon: const Icon(Icons.arrow_back_ios),
+            onPressed: () {
+              Navigator.of(context).pop(
+                selectedRulesetIndex == -1
+                    ? null
+                    : widget.rulesets[selectedRulesetIndex].$1,
+              );
+            },
+          ),
+          title: Text(loc.choose_ruleset),
+        ),
+        body: PopScope(
+          // This fixes that the Android Back Gesture didn't return the
+          // selectedRulesetIndex and therefore the selected Ruleset wasn't saved
+          canPop: false,
+          onPopInvokedWithResult: (bool didPop, Object? result) {
+            if (didPop) {
+              return;
+            }
+            Navigator.of(context).pop(
+              selectedRulesetIndex == -1
+                  ? null
+                  : widget.rulesets[selectedRulesetIndex].$1,
+            );
+          },
+          child: ListView.builder(
+            padding: const EdgeInsets.only(bottom: 85),
+            itemCount: widget.rulesets.length,
+            itemBuilder: (BuildContext context, int index) {
+              return TitleDescriptionListTile(
+                onTap: () async {
+                  setState(() {
+                    if (selectedRulesetIndex == index) {
+                      selectedRulesetIndex = -1;
+                    } else {
+                      selectedRulesetIndex = index;
+                    }
+                  });
+                },
+                title: translateRulesetToString(
+                  widget.rulesets[index].$1,
+                  context,
+                ),
+                description: widget.rulesets[index].$2,
+                isHighlighted: selectedRulesetIndex == index,
+              );
+            },
+          ),
+        ),
+      ),
+    );
+  }
+}

lib/presentation/views/main_menu/match_view/create_match/game_view/create_game_view.dart

@@ -0,0 +1,351 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:tallee/core/adaptive_page_route.dart';
+import 'package:tallee/core/common.dart';
+import 'package:tallee/core/constants.dart';
+import 'package:tallee/core/custom_theme.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/l10n/generated/app_localizations.dart';
+import 'package:tallee/presentation/views/main_menu/match_view/create_match/game_view/choose_color_view.dart';
+import 'package:tallee/presentation/views/main_menu/match_view/create_match/game_view/choose_ruleset_view.dart';
+import 'package:tallee/presentation/widgets/buttons/custom_width_button.dart';
+import 'package:tallee/presentation/widgets/custom_alert_dialog.dart';
+import 'package:tallee/presentation/widgets/text_input/text_input_field.dart';
+import 'package:tallee/presentation/widgets/tiles/choose_tile.dart';
+
+/// A stateful widget for creating or editing a game.
+/// - [gameToEdit] An optional game to prefill the fields
+/// - [onGameChanged] Callback to invoke when the game is created or edited
+class CreateGameView extends StatefulWidget {
+  const CreateGameView({
+    super.key,
+    this.gameToEdit,
+    required this.onGameChanged,
+  });
+
+  /// An optional game to prefill the fields
+  final Game? gameToEdit;
+
+  /// Callback to invoke when the game is created or edited
+  final VoidCallback onGameChanged;
+
+  @override
+  State<CreateGameView> createState() => _CreateGameViewState();
+}
+
+class _CreateGameViewState extends State<CreateGameView> {
+  /// GlobalKey for ScaffoldMessenger to show snackbars
+  final _scaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
+
+  /// The database instance for accessing game data.
+  late final AppDatabase db;
+
+  /// The currently selected ruleset for the game.
+  Ruleset? selectedRuleset;
+
+  /// The index of the currently selected ruleset.
+  int selectedRulesetIndex = -1;
+
+  /// A list of available rulesets and their localized names.
+  late List<(Ruleset, String)> _rulesets;
+
+  /// The currently selected color for the game.
+  GameColor? selectedColor;
+
+  /// Controller for the game name input field.
+  final _gameNameController = TextEditingController();
+
+  /// Controller for the game description input field.
+  final _descriptionController = TextEditingController();
+
+  /// The ID of the currently selected group.
+  late String selectedGroupId;
+
+  /// A controller for the search bar input field.
+  final TextEditingController controller = TextEditingController();
+
+  /// A list of groups filtered based on the search query.
+  late final List<Group> filteredGroups;
+
+  @override
+  void initState() {
+    super.initState();
+    db = Provider.of<AppDatabase>(context, listen: false);
+    _gameNameController.addListener(() => setState(() {}));
+  }
+
+  @override
+  void didChangeDependencies() {
+    super.didChangeDependencies();
+    _rulesets = [
+      (
+        Ruleset.singleWinner,
+        translateRulesetToString(Ruleset.singleWinner, context),
+      ),
+      (
+        Ruleset.singleLoser,
+        translateRulesetToString(Ruleset.singleLoser, context),
+      ),
+      (
+        Ruleset.highestScore,
+        translateRulesetToString(Ruleset.highestScore, context),
+      ),
+      (
+        Ruleset.lowestScore,
+        translateRulesetToString(Ruleset.lowestScore, context),
+      ),
+      (
+        Ruleset.multipleWinners,
+        translateRulesetToString(Ruleset.multipleWinners, context),
+      ),
+    ];
+
+    if (widget.gameToEdit != null) {
+      _gameNameController.text = widget.gameToEdit!.name;
+      _descriptionController.text = widget.gameToEdit!.description;
+      selectedRuleset = widget.gameToEdit!.ruleset;
+      selectedColor = widget.gameToEdit!.color;
+
+      selectedRulesetIndex = _rulesets.indexWhere(
+        (r) => r.$1 == selectedRuleset,
+      );
+    }
+  }
+
+  @override
+  void dispose() {
+    _gameNameController.dispose();
+    _descriptionController.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    var loc = AppLocalizations.of(context);
+    final isEditing = widget.gameToEdit != null;
+
+    return ScaffoldMessenger(
+      child: Scaffold(
+        backgroundColor: CustomTheme.backgroundColor,
+        appBar: AppBar(
+          title: Text(isEditing ? loc.edit_game : loc.create_game),
+          actions: widget.gameToEdit == null
+              ? []
+              : [
+                  IconButton(
+                    icon: const Icon(Icons.delete),
+                    onPressed: () async {
+                      if (widget.gameToEdit != null) {
+                        showDialog<bool>(
+                          context: context,
+                          builder: (context) => CustomAlertDialog(
+                            title: loc.delete_game,
+                            content: loc.this_cannot_be_undone,
+                            actions: [
+                              TextButton(
+                                onPressed: () =>
+                                    Navigator.of(context).pop(false),
+                                child: Text(loc.cancel),
+                              ),
+                              TextButton(
+                                onPressed: () =>
+                                    Navigator.of(context).pop(true),
+                                child: Text(loc.delete),
+                              ),
+                            ],
+                          ),
+                        ).then((confirmed) async {
+                          if (confirmed == true && context.mounted) {
+                            bool success = await db.gameDao.deleteGame(
+                              gameId: widget.gameToEdit!.id,
+                            );
+                            if (!context.mounted) return;
+                            if (success) {
+                              widget.onGameChanged.call();
+                              Navigator.of(
+                                context,
+                              ).pop((game: widget.gameToEdit, delete: true));
+                            } else {
+                              if (!mounted) return;
+                              showSnackbar(message: loc.error_deleting_game);
+                            }
+                          }
+                        });
+                      }
+                    },
+                  ),
+                ],
+        ),
+        body: SafeArea(
+          child: Column(
+            children: [
+              Container(
+                margin: CustomTheme.tileMargin,
+                child: TextInputField(
+                  controller: _gameNameController,
+                  maxLength: Constants.MAX_MATCH_NAME_LENGTH,
+                  hintText: loc.game_name,
+                ),
+              ),
+              ChooseTile(
+                title: loc.ruleset,
+                trailingText: selectedRuleset == null
+                    ? loc.none
+                    : translateRulesetToString(selectedRuleset!, context),
+                onPressed: () async {
+                  final result = await Navigator.of(context).push<Ruleset?>(
+                    adaptivePageRoute(
+                      builder: (context) => ChooseRulesetView(
+                        rulesets: _rulesets,
+                        initialRulesetIndex: selectedRulesetIndex,
+                      ),
+                    ),
+                  );
+                  if (mounted) {
+                    setState(() {
+                      selectedRuleset = result;
+                      selectedRulesetIndex = result == null
+                          ? -1
+                          : _rulesets.indexWhere((r) => r.$1 == result);
+                    });
+                  }
+                },
+              ),
+              ChooseTile(
+                title: loc.color,
+                trailingText: selectedColor == null
+                    ? loc.none
+                    : translateGameColorToString(selectedColor!, context),
+                onPressed: () async {
+                  final result = await Navigator.of(context).push<GameColor?>(
+                    adaptivePageRoute(
+                      builder: (context) =>
+                          ChooseColorView(initialColor: selectedColor),
+                    ),
+                  );
+                  if (mounted) {
+                    setState(() {
+                      selectedColor = result;
+                    });
+                  }
+                },
+              ),
+              Container(
+                margin: CustomTheme.tileMargin,
+                child: TextInputField(
+                  controller: _descriptionController,
+                  hintText: loc.description,
+                  minLines: 6,
+                  maxLines: 6,
+                  maxLength: Constants.MAX_GAME_DESCRIPTION_LENGTH,
+                  showCounterText: true,
+                ),
+              ),
+              const Spacer(),
+              Padding(
+                padding: const EdgeInsets.all(12.0),
+                child: CustomWidthButton(
+                  text: isEditing ? loc.edit_game : loc.create_game,
+                  sizeRelativeToWidth: 1,
+                  buttonType: ButtonType.primary,
+                  onPressed:
+                      _gameNameController.text.trim().isNotEmpty &&
+                          selectedRulesetIndex != -1 &&
+                          selectedColor != null
+                      ? () async {
+                          Game newGame = Game(
+                            name: _gameNameController.text.trim(),
+                            description: _descriptionController.text.trim(),
+                            ruleset: selectedRuleset!,
+                            color: selectedColor!,
+                          );
+                          if (isEditing) {
+                            await handleGameUpdate(newGame);
+                          } else {
+                            await handleGameCreation(newGame);
+                          }
+                          widget.onGameChanged.call();
+                          if (context.mounted) {
+                            Navigator.of(
+                              context,
+                            ).pop((game: newGame, delete: false));
+                          }
+                        }
+                      : null,
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+
+  /// Handles updating an existing game in the database.
+  ///
+  /// [newGame] The updated game object.
+  Future<void> handleGameUpdate(Game newGame) async {
+    final oldGame = widget.gameToEdit!;
+
+    if (oldGame.name != newGame.name) {
+      await db.gameDao.updateGameName(
+        gameId: oldGame.id,
+        newName: newGame.name,
+      );
+    }
+
+    if (oldGame.description != newGame.description) {
+      await db.gameDao.updateGameDescription(
+        gameId: oldGame.id,
+        newDescription: newGame.description,
+      );
+    }
+
+    if (oldGame.ruleset != newGame.ruleset) {
+      await db.gameDao.updateGameRuleset(
+        gameId: oldGame.id,
+        newRuleset: newGame.ruleset,
+      );
+    }
+
+    if (oldGame.color != newGame.color) {
+      await db.gameDao.updateGameColor(
+        gameId: oldGame.id,
+        newColor: newGame.color,
+      );
+    }
+
+    if (oldGame.icon != newGame.icon) {
+      await db.gameDao.updateGameIcon(
+        gameId: oldGame.id,
+        newIcon: newGame.icon,
+      );
+    }
+  }
+
+  /// Handles creating a new game in the database.
+  ///
+  /// [newGame] The game object to be created.
+  Future<void> handleGameCreation(Game newGame) async {
+    await db.gameDao.addGame(game: newGame);
+  }
+
+  /// Displays a snackbar with the given message and optional action.
+  ///
+  /// [message] The message to display in the snackbar.
+  void showSnackbar({required String message}) {
+    final messenger = _scaffoldMessengerKey.currentState;
+    if (messenger != null) {
+      messenger.hideCurrentSnackBar();
+      messenger.showSnackBar(
+        SnackBar(
+          content: Text(message, style: const TextStyle(color: Colors.white)),
+          backgroundColor: CustomTheme.boxColor,
+        ),
+      );
+    }
+  }
+}

lib/presentation/views/main_menu/match_view/match_view.dart

@@ -19,7 +19,7 @@ import 'package:tallee/presentation/widgets/tiles/match_tile.dart';
 import 'package:tallee/presentation/widgets/top_centered_message.dart';
 
 class MatchView extends StatefulWidget {
-  /// A view that displays a list of matches
+  /// A view that displays a list of matches.
   const MatchView({super.key});
 
   @override
@@ -27,11 +27,14 @@ class MatchView extends StatefulWidget {
 }
 
 class _MatchViewState extends State<MatchView> {
+  /// Database instance used to access match data.
   late final AppDatabase db;
+
+  /// Indicates whether matches are currently being loaded.
   bool isLoading = true;
 
   /// Loaded matches from the database,
-  /// initially filled with skeleton matches
+  /// initially filled with skeleton matches.
   List<Match> matches = List.filled(
     4,
     Match(
@@ -41,7 +44,6 @@ class _MatchViewState extends State<MatchView> {
         ruleset: Ruleset.singleWinner,
         description: '',
         color: GameColor.blue,
-        icon: '',
       ),
       group: Group(
         name: 'Group name',

lib/presentation/widgets/text_input/text_input_field.dart

@@ -8,12 +8,18 @@ class TextInputField extends StatelessWidget {
   /// - [onChanged]: Optional callback invoked when the text in the field changes.
   /// - [hintText]: The hint text displayed in the text input field when it is empty
   /// - [maxLength]: Optional parameter for maximum length of the input text.
+  /// - [maxLines]: The maximum number of lines for the text input field. Defaults to 1.
+  /// - [minLines]: The minimum number of lines for the text input field. Defaults to 1.
+  /// - [showCounterText]: Whether to show the counter text in the text input field. Defaults to false.
   const TextInputField({
     super.key,
     required this.controller,
     required this.hintText,
     this.onChanged,
     this.maxLength,
+    this.maxLines = 1,
+    this.minLines = 1,
+    this.showCounterText = false,
   });
 
   /// The controller for the text input field.
@@ -28,6 +34,15 @@ class TextInputField extends StatelessWidget {
   /// Optional parameter for maximum length of the input text.
   final int? maxLength;
 
+  /// The maximum number of lines for the text input field.
+  final int? maxLines;
+
+  /// The minimum number of lines for the text input field.
+  final int? minLines;
+
+  /// Whether to show the counter text in the text input field.
+  final bool showCounterText;
+
   @override
   Widget build(BuildContext context) {
     return TextField(
@@ -35,13 +50,14 @@ class TextInputField extends StatelessWidget {
       onChanged: onChanged,
       maxLength: maxLength,
       maxLengthEnforcement: MaxLengthEnforcement.truncateAfterCompositionEnds,
+      maxLines: maxLines,
+      minLines: minLines,
       decoration: InputDecoration(
         filled: true,
         fillColor: CustomTheme.boxColor,
         hintText: hintText,
         hintStyle: const TextStyle(fontSize: 18),
-        // Hides the character counter
+        counterText: showCounterText ? null : '',
-        counterText: '',
         enabledBorder: const OutlineInputBorder(
           borderRadius: BorderRadius.all(Radius.circular(12)),
           borderSide: BorderSide(color: CustomTheme.boxBorderColor),

lib/presentation/widgets/tiles/title_description_list_tile.dart

@@ -6,6 +6,7 @@ class TitleDescriptionListTile extends StatelessWidget {
   /// - [title]: The title text displayed on the tile.
   /// - [description]: The description text displayed below the title.
   /// - [onPressed]: The callback invoked when the tile is tapped.
+  /// - [onLongPress]: The callback invoked when the tile is tapped.
   /// - [isHighlighted]: A boolean to determine if the tile should be highlighted.
   /// - [badgeText]: Optional text to display in a badge on the right side of the title.
   /// - [badgeColor]: Optional color for the badge background.
@@ -13,7 +14,8 @@ class TitleDescriptionListTile extends StatelessWidget {
     super.key,
     required this.title,
     required this.description,
-    this.onPressed,
+    this.onTap,
+    this.onLongPress,
     this.isHighlighted = false,
     this.badgeText,
     this.badgeColor,
@@ -26,7 +28,10 @@ class TitleDescriptionListTile extends StatelessWidget {
   final String description;
 
   /// The callback invoked when the tile is tapped.
-  final VoidCallback? onPressed;
+  final VoidCallback? onTap;
+
+  /// The callback invoked when the tile is long-pressed.
+  final VoidCallback? onLongPress;
 
   /// A boolean to determine if the tile should be highlighted.
   final bool isHighlighted;
@@ -40,7 +45,8 @@ class TitleDescriptionListTile extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return GestureDetector(
-      onTap: onPressed,
+      onTap: onTap,
+      onLongPress: onLongPress,
       child: AnimatedContainer(
         margin: const EdgeInsets.symmetric(vertical: 10, horizontal: 10),
         padding: const EdgeInsets.symmetric(vertical: 6, horizontal: 12),

lib/services/data_transfer_service.dart

@@ -40,24 +40,29 @@ class DataTransferService {
       'players': players.map((p) => p.toJson()).toList(),
       'games': games.map((g) => g.toJson()).toList(),
       'groups': groups
-          .map((g) => {
+          .map(
+            (g) => {
               'id': g.id,
               'name': g.name,
               'description': g.description,
               'createdAt': g.createdAt.toIso8601String(),
               'memberIds': (g.members).map((m) => m.id).toList(),
-      })
+            },
+          )
           .toList(),
       'teams': teams
-          .map((t) => {
+          .map(
+            (t) => {
               'id': t.id,
               'name': t.name,
               'createdAt': t.createdAt.toIso8601String(),
               'memberIds': (t.members).map((m) => m.id).toList(),
-      })
+            },
+          )
           .toList(),
       'matches': matches
-          .map((m) => {
+          .map(
+            (m) => {
               'id': m.id,
               'name': m.name,
               'createdAt': m.createdAt.toIso8601String(),
@@ -66,7 +71,8 @@ class DataTransferService {
               'groupId': m.group?.id,
               'playerIds': m.players.map((p) => p.id).toList(),
               'notes': m.notes,
-      })
+            },
+          )
           .toList(),
     };
 
@@ -80,7 +86,7 @@ class DataTransferService {
   /// [fileName] The desired name for the exported file (without extension).
   static Future<ExportResult> exportData(
     String jsonString,
-      String fileName
+    String fileName,
   ) async {
     try {
       final bytes = Uint8List.fromList(utf8.encode(jsonString));
@@ -94,7 +100,6 @@ class DataTransferService {
       } else {
         return ExportResult.success;
       }
-
     } catch (e, stack) {
       print('[exportData] $e');
       print(stack);
@@ -122,13 +127,19 @@ class DataTransferService {
       final isValid = await _validateJsonSchema(jsonString);
       if (!isValid) return ImportResult.invalidSchema;
 
-      final Map<String, dynamic> decoded = json.decode(jsonString) as Map<String, dynamic>;
+      final Map<String, dynamic> decoded =
+          json.decode(jsonString) as Map<String, dynamic>;
 
-      final List<dynamic> playersJson = (decoded['players'] as List<dynamic>?) ?? [];
+      final List<dynamic> playersJson =
-      final List<dynamic> gamesJson = (decoded['games'] as List<dynamic>?) ?? [];
+          (decoded['players'] as List<dynamic>?) ?? [];
-      final List<dynamic> groupsJson = (decoded['groups'] as List<dynamic>?) ?? [];
+      final List<dynamic> gamesJson =
-      final List<dynamic> teamsJson = (decoded['teams'] as List<dynamic>?) ?? [];
+          (decoded['games'] as List<dynamic>?) ?? [];
-      final List<dynamic> matchesJson = (decoded['matches'] as List<dynamic>?) ?? [];
+      final List<dynamic> groupsJson =
+          (decoded['groups'] as List<dynamic>?) ?? [];
+      final List<dynamic> teamsJson =
+          (decoded['teams'] as List<dynamic>?) ?? [];
+      final List<dynamic> matchesJson =
+          (decoded['matches'] as List<dynamic>?) ?? [];
 
       // Import Players
       final List<Player> importedPlayers = playersJson
@@ -151,7 +162,8 @@ class DataTransferService {
       // Import Groups
       final List<Group> importedGroups = groupsJson.map((g) {
         final map = g as Map<String, dynamic>;
-        final memberIds = (map['memberIds'] as List<dynamic>? ?? []).cast<String>();
+        final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
+            .cast<String>();
 
         final members = memberIds
             .map((id) => playerById[id])
@@ -174,7 +186,8 @@ class DataTransferService {
       // Import Teams
       final List<Team> importedTeams = teamsJson.map((t) {
         final map = t as Map<String, dynamic>;
-        final memberIds = (map['memberIds'] as List<dynamic>? ?? []).cast<String>();
+        final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
+            .cast<String>();
 
         final members = memberIds
             .map((id) => playerById[id])
@@ -195,8 +208,11 @@ class DataTransferService {
 
         final String gameId = map['gameId'] as String;
         final String? groupId = map['groupId'] as String?;
-        final List<String> playerIds = (map['playerIds'] as List<dynamic>? ?? []).cast<String>();
+        final List<String> playerIds =
-        final DateTime? endedAt = map['endedAt'] != null ? DateTime.parse(map['endedAt'] as String) : null;
+            (map['playerIds'] as List<dynamic>? ?? []).cast<String>();
+        final DateTime? endedAt = map['endedAt'] != null
+            ? DateTime.parse(map['endedAt'] as String)
+            : null;
 
         final game = gameById[gameId];
         final group = (groupId == null) ? null : groupById[groupId];
@@ -208,7 +224,14 @@ class DataTransferService {
         return Match(
           id: map['id'] as String,
           name: map['name'] as String,
-          game: game ?? Game(name: 'Unknown', ruleset: Ruleset.singleWinner, description: '', color: GameColor.blue, icon: ''),
+          game:
+              game ??
+              Game(
+                name: 'Unknown',
+                ruleset: Ruleset.singleWinner,
+                description: '',
+                color: GameColor.blue,
+              ),
           group: group,
           players: players,
           createdAt: DateTime.parse(map['createdAt'] as String),

test/db_tests/aggregates/match_test.dart

@@ -56,7 +56,6 @@ void main() {
         ruleset: Ruleset.singleWinner,
         description: 'A test game',
         color: GameColor.blue,
-        icon: '',
       );
       testMatch1 = Match(
         name: 'First Test Match',

test/db_tests/aggregates/team_test.dart

@@ -2,12 +2,12 @@ import 'package:clock/clock.dart';
 import 'package:drift/drift.dart';
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/data/dto/match.dart';
 import 'package:tallee/data/dto/player.dart';
 import 'package:tallee/data/dto/team.dart';
-import 'package:tallee/core/enums.dart';
 
 void main() {
   late AppDatabase database;
@@ -37,20 +37,21 @@ void main() {
       testPlayer2 = Player(name: 'Bob', description: '');
       testPlayer3 = Player(name: 'Charlie', description: '');
       testPlayer4 = Player(name: 'Diana', description: '');
-      testTeam1 = Team(
+      testTeam1 = Team(name: 'Team Alpha', members: [testPlayer1, testPlayer2]);
-        name: 'Team Alpha',
+      testTeam2 = Team(name: 'Team Beta', members: [testPlayer3, testPlayer4]);
-        members: [testPlayer1, testPlayer2],
+      testTeam3 = Team(name: 'Team Gamma', members: [testPlayer1, testPlayer3]);
+      testGame1 = Game(
+        name: 'Game 1',
+        ruleset: Ruleset.singleWinner,
+        description: 'Test game 1',
+        color: GameColor.blue,
       );
-      testTeam2 = Team(
+      testGame2 = Game(
-        name: 'Team Beta',
+        name: 'Game 2',
-        members: [testPlayer3, testPlayer4],
+        ruleset: Ruleset.highestScore,
+        description: 'Test game 2',
+        color: GameColor.red,
       );
-      testTeam3 = Team(
-        name: 'Team Gamma',
-        members: [testPlayer1, testPlayer3],
-      );
-      testGame1 = Game(name: 'Game 1', ruleset: Ruleset.singleWinner, description: 'Test game 1', color: GameColor.blue, icon: '');
-      testGame2 = Game(name: 'Game 2', ruleset: Ruleset.highestScore, description: 'Test game 2', color: GameColor.red, icon: '');
     });
 
     await database.playerDao.addPlayersAsList(
@@ -65,7 +66,6 @@ void main() {
   });
 
   group('Team Tests', () {
-
     // Verifies that a single team can be added and retrieved with all fields intact.
     test('Adding and fetching a single team works correctly', () async {
       final added = await database.teamDao.addTeam(team: testTeam1);
@@ -285,10 +285,7 @@ void main() {
     test('Updating team name to empty string works', () async {
       await database.teamDao.addTeam(team: testTeam1);
 
-      await database.teamDao.updateTeamName(
+      await database.teamDao.updateTeamName(teamId: testTeam1.id, newName: '');
-        teamId: testTeam1.id,
-        newName: '',
-      );
 
       final updatedTeam = await database.teamDao.getTeamById(
         teamId: testTeam1.id,
@@ -350,9 +347,7 @@ void main() {
       await database.matchDao.addMatch(match: match2);
 
       // Add teams to database
-      await database.teamDao.addTeamsAsList(
+      await database.teamDao.addTeamsAsList(teams: [testTeam1, testTeam3]);
-        teams: [testTeam1, testTeam3],
-      );
 
       // Associate players with teams through match1
       // testTeam1: player1, player2
@@ -420,10 +415,11 @@ void main() {
       final allTeams = await database.teamDao.getAllTeams();
 
       expect(allTeams.length, 3);
-      expect(
+      expect(allTeams.map((t) => t.id).toSet(), {
-        allTeams.map((t) => t.id).toSet(),
+        testTeam1.id,
-        {testTeam1.id, testTeam2.id, testTeam3.id},
+        testTeam2.id,
-      );
+        testTeam3.id,
+      });
     });
 
     // Verifies that teamExists returns false for deleted teams.
@@ -462,9 +458,7 @@ void main() {
 
     // Verifies that addTeam after deleteAllTeams works correctly.
     test('Adding team after deleteAllTeams works correctly', () async {
-      await database.teamDao.addTeamsAsList(
+      await database.teamDao.addTeamsAsList(teams: [testTeam1, testTeam2]);
-        teams: [testTeam1, testTeam2],
-      );
       expect(await database.teamDao.getTeamCount(), 2);
 
       await database.teamDao.deleteAllTeams();

test/db_tests/entities/game_test.dart

@@ -44,7 +44,6 @@ void main() {
         ruleset: Ruleset.highestScore,
         description: 'A board game about real estate',
         color: GameColor.orange,
-        icon: '',
       );
     });
   });
@@ -54,7 +53,6 @@ void main() {
   });
 
   group('Game Tests', () {
-
     // Verifies that getAllGames returns an empty list when the database has no games.
     test('getAllGames returns empty list when no games exist', () async {
       final allGames = await database.gameDao.getAllGames();
@@ -134,7 +132,12 @@ void main() {
 
     // Verifies that a game with empty optional fields can be added and retrieved.
     test('addGame handles game with null optional fields', () async {
-      final gameWithNulls = Game(name: 'Simple Game', ruleset: Ruleset.lowestScore, description: 'A simple game', color: GameColor.green, icon: '');
+      final gameWithNulls = Game(
+        name: 'Simple Game',
+        ruleset: Ruleset.lowestScore,
+        description: 'A simple game',
+        color: GameColor.green,
+      );
       final result = await database.gameDao.addGame(game: gameWithNulls);
       expect(result, true);
 
@@ -419,9 +422,7 @@ void main() {
 
     // Verifies that getGameCount updates correctly after deleting a game.
     test('getGameCount updates correctly after deletion', () async {
-      await database.gameDao.addGamesAsList(
+      await database.gameDao.addGamesAsList(games: [testGame1, testGame2]);
-        games: [testGame1, testGame2],
-      );
 
       final countBefore = await database.gameDao.getGameCount();
       expect(countBefore, 2);
@@ -461,7 +462,6 @@ void main() {
         ruleset: Ruleset.multipleWinners,
         description: 'Description with émojis 🎮🎲',
         color: GameColor.purple,
-        icon: '',
       );
       await database.gameDao.addGame(game: specialGame);
 
@@ -478,7 +478,6 @@ void main() {
         name: '',
         ruleset: Ruleset.singleWinner,
         description: '',
-        icon: '',
         color: GameColor.red,
       );
       await database.gameDao.addGame(game: emptyGame);
@@ -500,7 +499,6 @@ void main() {
         description: longString,
         ruleset: Ruleset.multipleWinners,
         color: GameColor.yellow,
-        icon: '',
       );
       await database.gameDao.addGame(game: longGame);
 

test/db_tests/relationships/player_match_test.dart

@@ -48,7 +48,12 @@ void main() {
         description: '',
         members: [testPlayer1, testPlayer2, testPlayer3],
       );
-      testGame = Game(name: 'Test Game', ruleset: Ruleset.singleWinner, description: 'A test game', color: GameColor.blue, icon: '');
+      testGame = Game(
+        name: 'Test Game',
+        ruleset: Ruleset.singleWinner,
+        description: 'A test game',
+        color: GameColor.blue,
+      );
       testMatchOnlyGroup = Match(
         name: 'Test Match with Group',
         game: testGame,
@@ -61,14 +66,8 @@ void main() {
         players: [testPlayer4, testPlayer5, testPlayer6],
         notes: '',
       );
-      testTeam1 = Team(
+      testTeam1 = Team(name: 'Team Alpha', members: [testPlayer1, testPlayer2]);
-        name: 'Team Alpha',
+      testTeam2 = Team(name: 'Team Beta', members: [testPlayer3, testPlayer4]);
-        members: [testPlayer1, testPlayer2],
-      );
-      testTeam2 = Team(
-        name: 'Team Beta',
-        members: [testPlayer3, testPlayer4],
-      );
     });
     await database.playerDao.addPlayersAsList(
       players: [
@@ -88,7 +87,6 @@ void main() {
   });
 
   group('Player-Match Tests', () {
-
     // Verifies that matchHasPlayers returns false initially and true after adding a player.
     test('Match has player works correctly', () async {
       await database.matchDao.addMatch(match: testMatchOnlyGroup);
@@ -153,26 +151,23 @@ void main() {
       );
       expect(result.players.length, testMatchOnlyPlayers.players.length - 1);
 
-      final playerExists = result.players.any(
+      final playerExists = result.players.any((p) => p.id == playerToRemove.id);
-            (p) => p.id == playerToRemove.id,
-      );
       expect(playerExists, false);
     });
 
     // Verifies that getPlayersOfMatch returns all players of a match with correct data.
     test('Retrieving players of a match works correctly', () async {
       await database.matchDao.addMatch(match: testMatchOnlyPlayers);
-      final players = await database.playerMatchDao.getPlayersOfMatch(
+      final players =
+          await database.playerMatchDao.getPlayersOfMatch(
             matchId: testMatchOnlyPlayers.id,
-      ) ?? [];
+          ) ??
+          [];
 
       for (int i = 0; i < players.length; i++) {
         expect(players[i].id, testMatchOnlyPlayers.players[i].id);
         expect(players[i].name, testMatchOnlyPlayers.players[i].name);
-        expect(
+        expect(players[i].createdAt, testMatchOnlyPlayers.players[i].createdAt);
-          players[i].createdAt,
-          testMatchOnlyPlayers.players[i].createdAt,
-        );
       }
     });
 
@@ -225,8 +220,18 @@ void main() {
       'Adding the same player to separate matches works correctly',
       () async {
         final playersList = [testPlayer1, testPlayer2, testPlayer3];
-        final match1 = Match(name: 'Match 1', game: testGame, players: playersList, notes: '');
+        final match1 = Match(
-        final match2 = Match(name: 'Match 2', game: testGame, players: playersList, notes: '');
+          name: 'Match 1',
+          game: testGame,
+          players: playersList,
+          notes: '',
+        );
+        final match2 = Match(
+          name: 'Match 2',
+          game: testGame,
+          players: playersList,
+          notes: '',
+        );
 
         await Future.wait([
           database.matchDao.addMatch(match: match1),
@@ -299,7 +304,9 @@ void main() {
     });
 
     // Verifies that getPlayerScore returns null for non-existent player-match combination.
-    test('getPlayerScore returns null for non-existent player in match', () async {
+    test(
+      'getPlayerScore returns null for non-existent player in match',
+      () async {
         await database.matchDao.addMatch(match: testMatchOnlyGroup);
 
         final score = await database.playerMatchDao.getPlayerScore(
@@ -308,7 +315,8 @@ void main() {
         );
 
         expect(score, isNull);
-    });
+      },
+    );
 
     // Verifies that updatePlayerScore updates the score correctly.
     test('updatePlayerScore updates score correctly', () async {
@@ -331,7 +339,9 @@ void main() {
     });
 
     // Verifies that updatePlayerScore returns false for non-existent player-match.
-    test('updatePlayerScore returns false for non-existent player-match', () async {
+    test(
+      'updatePlayerScore returns false for non-existent player-match',
+      () async {
         await database.matchDao.addMatch(match: testMatchOnlyGroup);
 
         final updated = await database.playerMatchDao.updatePlayerScore(
@@ -341,7 +351,8 @@ void main() {
         );
 
         expect(updated, false);
-    });
+      },
+    );
 
     // Verifies that adding a player with teamId works correctly.
     test('Adding player with teamId works correctly', () async {
@@ -431,7 +442,9 @@ void main() {
     });
 
     // Verifies that updatePlayerTeam returns false for non-existent player-match.
-    test('updatePlayerTeam returns false for non-existent player-match', () async {
+    test(
+      'updatePlayerTeam returns false for non-existent player-match',
+      () async {
         await database.matchDao.addMatch(match: testMatchOnlyGroup);
 
         final updated = await database.playerMatchDao.updatePlayerTeam(
@@ -441,7 +454,8 @@ void main() {
         );
 
         expect(updated, false);
-    });
+      },
+    );
 
     // Verifies that getPlayersInTeam returns empty list for non-existent team.
     test('getPlayersInTeam returns empty list for non-existent team', () async {
@@ -483,7 +497,9 @@ void main() {
     });
 
     // Verifies that removePlayerFromMatch returns false for non-existent player.
-    test('removePlayerFromMatch returns false for non-existent player', () async {
+    test(
+      'removePlayerFromMatch returns false for non-existent player',
+      () async {
         await database.matchDao.addMatch(match: testMatchOnlyPlayers);
 
         final removed = await database.playerMatchDao.removePlayerFromMatch(
@@ -492,7 +508,8 @@ void main() {
         );
 
         expect(removed, false);
-    });
+      },
+    );
 
     // Verifies that adding the same player twice to the same match is ignored.
     test('Adding same player twice to same match is ignored', () async {
@@ -528,7 +545,9 @@ void main() {
     });
 
     // Verifies that updatePlayersFromMatch with empty list removes all players.
-    test('updatePlayersFromMatch with empty list removes all players', () async {
+    test(
+      'updatePlayersFromMatch with empty list removes all players',
+      () async {
         await database.matchDao.addMatch(match: testMatchOnlyPlayers);
 
         // Verify players exist initially
@@ -548,7 +567,8 @@ void main() {
           matchId: testMatchOnlyPlayers.id,
         );
         expect(players, isNull);
-    });
+      },
+    );
 
     // Verifies that updatePlayersFromMatch with same players makes no changes.
     test('updatePlayersFromMatch with same players makes no changes', () async {
@@ -702,7 +722,9 @@ void main() {
     });
 
     // Verifies that getPlayersInTeam returns empty list for non-existent match.
-    test('getPlayersInTeam returns empty list for non-existent match', () async {
+    test(
+      'getPlayersInTeam returns empty list for non-existent match',
+      () async {
         await database.teamDao.addTeam(team: testTeam1);
 
         final players = await database.playerMatchDao.getPlayersInTeam(
@@ -711,7 +733,8 @@ void main() {
         );
 
         expect(players.isEmpty, true);
-    });
+      },
+    );
 
     // Verifies that players in different teams within the same match are returned correctly.
     test('Players in different teams within same match are separate', () async {
@@ -759,8 +782,18 @@ void main() {
     // Verifies that removePlayerFromMatch does not affect other matches.
     test('removePlayerFromMatch does not affect other matches', () async {
       final playersList = [testPlayer1, testPlayer2];
-      final match1 = Match(name: 'Match 1', game: testGame, players: playersList, notes: '');
+      final match1 = Match(
-      final match2 = Match(name: 'Match 2', game: testGame, players: playersList, notes: '');
+        name: 'Match 1',
+        game: testGame,
+        players: playersList,
+        notes: '',
+      );
+      final match2 = Match(
+        name: 'Match 2',
+        game: testGame,
+        players: playersList,
+        notes: '',
+      );
 
       await Future.wait([
         database.matchDao.addMatch(match: match1),
@@ -792,8 +825,18 @@ void main() {
     // Verifies that updating scores for players in different matches are independent.
     test('Player scores are independent across matches', () async {
       final playersList = [testPlayer1];
-      final match1 = Match(name: 'Match 1', game: testGame, players: playersList, notes: '');
+      final match1 = Match(
-      final match2 = Match(name: 'Match 2', game: testGame, players: playersList, notes: '');
+        name: 'Match 1',
+        game: testGame,
+        players: playersList,
+        notes: '',
+      );
+      final match2 = Match(
+        name: 'Match 2',
+        game: testGame,
+        players: playersList,
+        notes: '',
+      );
 
       await Future.wait([
         database.matchDao.addMatch(match: match1),
@@ -829,7 +872,9 @@ void main() {
     });
 
     // Verifies that updatePlayersFromMatch on non-existent match fails with constraint error.
-    test('updatePlayersFromMatch on non-existent match fails with foreign key constraint', () async {
+    test(
+      'updatePlayersFromMatch on non-existent match fails with foreign key constraint',
+      () async {
         // Should throw due to foreign key constraint - match doesn't exist
         await expectLater(
           database.playerMatchDao.updatePlayersFromMatch(
@@ -838,7 +883,8 @@ void main() {
           ),
           throwsA(anything),
         );
-    });
+      },
+    );
 
     // Verifies that a player can be in a match without being assigned to a team.
     test('Player can exist in match without team assignment', () async {

test/db_tests/values/score_test.dart

@@ -2,11 +2,11 @@ import 'package:clock/clock.dart';
 import 'package:drift/drift.dart' hide isNull, isNotNull;
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/dto/game.dart';
 import 'package:tallee/data/dto/match.dart';
 import 'package:tallee/data/dto/player.dart';
-import 'package:tallee/core/enums.dart';
 
 void main() {
   late AppDatabase database;
@@ -32,7 +32,12 @@ void main() {
       testPlayer1 = Player(name: 'Alice', description: '');
       testPlayer2 = Player(name: 'Bob', description: '');
       testPlayer3 = Player(name: 'Charlie', description: '');
-      testGame = Game(name: 'Test Game', ruleset: Ruleset.singleWinner, description: 'A test game', color: GameColor.blue, icon: '');
+      testGame = Game(
+        name: 'Test Game',
+        ruleset: Ruleset.singleWinner,
+        description: 'A test game',
+        color: GameColor.blue,
+      );
       testMatch1 = Match(
         name: 'Test Match 1',
         game: testGame,
@@ -60,7 +65,6 @@ void main() {
   });
 
   group('Score Tests', () {
-
     // Verifies that a score can be added and retrieved with all fields intact.
     test('Adding and fetching a score works correctly', () async {
       await database.scoreDao.addScore(
@@ -431,13 +435,16 @@ void main() {
     });
 
     // Verifies that getScoresForMatch returns empty list for match with no scores.
-    test('Getting scores for match with no scores returns empty list', () async {
+    test(
+      'Getting scores for match with no scores returns empty list',
+      () async {
         final scores = await database.scoreDao.getScoresForMatch(
           matchId: testMatch1.id,
         );
 
         expect(scores.isEmpty, true);
-    });
+      },
+    );
 
     // Verifies that getPlayerScoresInMatch returns empty list when player has no scores.
     test('Getting player scores with no scores returns empty list', () async {
@@ -666,7 +673,9 @@ void main() {
     });
 
     // Verifies that updating one player's score doesn't affect another player's score in same round.
-    test('Updating one player score does not affect other players in same round', () async {
+    test(
+      'Updating one player score does not affect other players in same round',
+      () async {
         await database.scoreDao.addScore(
           playerId: testPlayer1.id,
           matchId: testMatch1.id,
@@ -702,10 +711,20 @@ void main() {
         );
 
         expect(scores.length, 3);
-      expect(scores.where((s) => s.playerId == testPlayer1.id).first.score, 10);
+        expect(
-      expect(scores.where((s) => s.playerId == testPlayer2.id).first.score, 99);
+          scores.where((s) => s.playerId == testPlayer1.id).first.score,
-      expect(scores.where((s) => s.playerId == testPlayer3.id).first.score, 30);
+          10,
-    });
+        );
+        expect(
+          scores.where((s) => s.playerId == testPlayer2.id).first.score,
+          99,
+        );
+        expect(
+          scores.where((s) => s.playerId == testPlayer3.id).first.score,
+          30,
+        );
+      },
+    );
 
     // Verifies that deleting a player's scores only affects that specific player.
     test('Deleting player scores only affects target player', () async {
@@ -724,9 +743,7 @@ void main() {
         change: 20,
       );
 
-      await database.scoreDao.deleteScoresForPlayer(
+      await database.scoreDao.deleteScoresForPlayer(playerId: testPlayer1.id);
-        playerId: testPlayer1.id,
-      );
 
       final match1Scores = await database.scoreDao.getScoresForMatch(
         matchId: testMatch1.id,