Merge pull request 'Fehlende Info in CreateGroupView' (#107) from bug/73-Fehlende-Info-in-CreateGroupView into development

Reviewed-on: #107
Reviewed-by: Mathis Kirchner <mathis.kirchner.mk@gmail.com>

lib/core/constants.dart

@@ -0,0 +1,2 @@
+/// Minimum duration of all app skeletons
+Duration minimumSkeletonDuration = const Duration(milliseconds: 250);

lib/core/enums.dart

@@ -23,9 +23,23 @@ enum ImportResult {
 /// - [ExportResult.unknownException]: An exception occurred during export.
 enum ExportResult { success, canceled, unknownException }
 
-/// Different rulesets available for games
+/// Different rulesets available for matches
-/// - [Ruleset.singleWinner]: The game is won by a single player
+/// - [Ruleset.singleWinner]: The match is won by a single player
-/// - [Ruleset.singleLoser]: The game is lost by a single player
+/// - [Ruleset.singleLoser]: The match is lost by a single player
 /// - [Ruleset.mostPoints]: The player with the most points wins.
-/// - [Ruleset.lastPoints]: The player with the fewest points wins.
+/// - [Ruleset.leastPoints]: The player with the fewest points wins.
-enum Ruleset { singleWinner, singleLoser, mostPoints, lastPoints }
+enum Ruleset { singleWinner, singleLoser, mostPoints, leastPoints }
+
+/// Translates a [Ruleset] enum value to its corresponding string representation.
+String translateRulesetToString(Ruleset ruleset) {
+  switch (ruleset) {
+    case Ruleset.singleWinner:
+      return 'Single Winner';
+    case Ruleset.singleLoser:
+      return 'Single Loser';
+    case Ruleset.mostPoints:
+      return 'Most Points';
+    case Ruleset.leastPoints:
+      return 'Least Points';
+  }
+}

lib/data/dao/game_dao.dart

@@ -1,320 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/db/tables/game_table.dart';
-import 'package:game_tracker/data/dto/game.dart';
-import 'package:game_tracker/data/dto/group.dart';
-import 'package:game_tracker/data/dto/player.dart';
-
-part 'game_dao.g.dart';
-
-@DriftAccessor(tables: [GameTable])
-class GameDao extends DatabaseAccessor<AppDatabase> with _$GameDaoMixin {
-  GameDao(super.db);
-
-  /// Retrieves all games from the database.
-  Future<List<Game>> getAllGames() async {
-    final query = select(gameTable);
-    final result = await query.get();
-
-    return Future.wait(
-      result.map((row) async {
-        final group = await db.groupGameDao.getGroupOfGame(gameId: row.id);
-        final players = await db.playerGameDao.getPlayersOfGame(gameId: row.id);
-        final winner = row.winnerId != null
-            ? await db.playerDao.getPlayerById(playerId: row.winnerId!)
-            : null;
-        return Game(
-          id: row.id,
-          name: row.name,
-          group: group,
-          players: players,
-          createdAt: row.createdAt,
-          winner: winner,
-        );
-      }),
-    );
-  }
-
-  /// Retrieves a [Game] by its [gameId].
-  Future<Game> getGameById({required String gameId}) async {
-    final query = select(gameTable)..where((g) => g.id.equals(gameId));
-    final result = await query.getSingle();
-
-    List<Player>? players;
-    if (await db.playerGameDao.gameHasPlayers(gameId: gameId)) {
-      players = await db.playerGameDao.getPlayersOfGame(gameId: gameId);
-    }
-    Group? group;
-    if (await db.groupGameDao.gameHasGroup(gameId: gameId)) {
-      group = await db.groupGameDao.getGroupOfGame(gameId: gameId);
-    }
-    Player? winner;
-    if (result.winnerId != null) {
-      winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
-    }
-
-    return Game(
-      id: result.id,
-      name: result.name,
-      players: players,
-      group: group,
-      winner: winner,
-      createdAt: result.createdAt,
-    );
-  }
-
-  /// Adds a new [Game] to the database.
-  /// Also adds associated players and group if they exist.
-  Future<void> addGame({required Game game}) async {
-    await db.transaction(() async {
-      await into(gameTable).insert(
-        GameTableCompanion.insert(
-          id: game.id,
-          name: game.name,
-          winnerId: Value(game.winner?.id),
-          createdAt: game.createdAt,
-        ),
-        mode: InsertMode.insertOrReplace,
-      );
-
-      if (game.players != null) {
-        await db.playerDao.addPlayersAsList(players: game.players!);
-        for (final p in game.players ?? []) {
-          await db.playerGameDao.addPlayerToGame(
-            gameId: game.id,
-            playerId: p.id,
-          );
-        }
-      }
-
-      if (game.group != null) {
-        await db.groupDao.addGroup(group: game.group!);
-        await db.groupGameDao.addGroupToGame(
-          gameId: game.id,
-          groupId: game.group!.id,
-        );
-      }
-    });
-  }
-
-  /// Adds multiple [Game]s to the database in a batch operation.
-  /// Also adds associated players and groups if they exist.
-  /// If the [games] list is empty, the method returns immediately.
-  Future<void> addGamesAsList({required List<Game> games}) async {
-    if (games.isEmpty) return;
-    await db.transaction(() async {
-      // Add all games in batch
-      await db.batch(
-        (b) => b.insertAll(
-          gameTable,
-          games
-              .map(
-                (game) => GameTableCompanion.insert(
-                  id: game.id,
-                  name: game.name,
-                  createdAt: game.createdAt,
-                  winnerId: Value(game.winner?.id),
-                ),
-              )
-              .toList(),
-          mode: InsertMode.insertOrReplace,
-        ),
-      );
-
-      // Add all groups of the games in batch
-      await db.batch(
-        (b) => b.insertAll(
-          db.groupTable,
-          games
-              .where((game) => game.group != null)
-              .map(
-                (game) => GroupTableCompanion.insert(
-                  id: game.group!.id,
-                  name: game.group!.name,
-                  createdAt: game.group!.createdAt,
-                ),
-              )
-              .toList(),
-          mode: InsertMode.insertOrReplace,
-        ),
-      );
-
-      // Add all players of the games in batch (unique)
-      final uniquePlayers = <String, Player>{};
-      for (final game in games) {
-        if (game.players != null) {
-          for (final p in game.players!) {
-            uniquePlayers[p.id] = p;
-          }
-        }
-        // Also include members of groups
-        if (game.group != null) {
-          for (final m in game.group!.members) {
-            uniquePlayers[m.id] = m;
-          }
-        }
-      }
-
-      if (uniquePlayers.isNotEmpty) {
-        await db.batch(
-          (b) => b.insertAll(
-            db.playerTable,
-            uniquePlayers.values
-                .map(
-                  (p) => PlayerTableCompanion.insert(
-                    id: p.id,
-                    name: p.name,
-                    createdAt: p.createdAt,
-                  ),
-                )
-                .toList(),
-            mode: InsertMode.insertOrReplace,
-          ),
-        );
-      }
-
-      // Add all player-game associations in batch
-      await db.batch((b) {
-        for (final game in games) {
-          if (game.players != null) {
-            for (final p in game.players ?? []) {
-              b.insert(
-                db.playerGameTable,
-                PlayerGameTableCompanion.insert(
-                  gameId: game.id,
-                  playerId: p.id,
-                ),
-                mode: InsertMode.insertOrReplace,
-              );
-            }
-          }
-        }
-      });
-
-      // Add all player-group associations in batch
-      await db.batch((b) {
-        for (final game in games) {
-          if (game.group != null) {
-            for (final m in game.group!.members) {
-              b.insert(
-                db.playerGroupTable,
-                PlayerGroupTableCompanion.insert(
-                  playerId: m.id,
-                  groupId: game.group!.id,
-                ),
-                mode: InsertMode.insertOrReplace,
-              );
-            }
-          }
-        }
-      });
-
-      // Add all group-game associations in batch
-      await db.batch((b) {
-        for (final game in games) {
-          if (game.group != null) {
-            b.insert(
-              db.groupGameTable,
-              GroupGameTableCompanion.insert(
-                gameId: game.id,
-                groupId: game.group!.id,
-              ),
-              mode: InsertMode.insertOrReplace,
-            );
-          }
-        }
-      });
-    });
-  }
-
-  /// Deletes the game with the given [gameId] from the database.
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> deleteGame({required String gameId}) async {
-    final query = delete(gameTable)..where((g) => g.id.equals(gameId));
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Retrieves the number of games in the database.
-  Future<int> getGameCount() async {
-    final count =
-        await (selectOnly(gameTable)..addColumns([gameTable.id.count()]))
-            .map((row) => row.read(gameTable.id.count()))
-            .getSingle();
-    return count ?? 0;
-  }
-
-  /// Checks if a game with the given [gameId] exists in the database.
-  /// Returns `true` if the game exists, otherwise `false`.
-  Future<bool> gameExists({required String gameId}) async {
-    final query = select(gameTable)..where((g) => g.id.equals(gameId));
-    final result = await query.getSingleOrNull();
-    return result != null;
-  }
-
-  /// Deletes all games from the database.
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> deleteAllGames() async {
-    final query = delete(gameTable);
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Sets the winner of the game with the given [gameId] to the player with
-  /// the given [winnerId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> setWinner({
-    required String gameId,
-    required String winnerId,
-  }) async {
-    final query = update(gameTable)..where((g) => g.id.equals(gameId));
-    final rowsAffected = await query.write(
-      GameTableCompanion(winnerId: Value(winnerId)),
-    );
-    return rowsAffected > 0;
-  }
-
-  /// Retrieves the winner of the game with the given [gameId].
-  /// Returns the [Player] who won the game, or `null` if no winner is set.
-  Future<Player?> getWinner({required String gameId}) async {
-    final query = select(gameTable)..where((g) => g.id.equals(gameId));
-    final result = await query.getSingleOrNull();
-    if (result == null || result.winnerId == null) {
-      return null;
-    }
-    final winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
-    return winner;
-  }
-
-  /// Removes the winner of the game with the given [gameId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> removeWinner({required String gameId}) async {
-    final query = update(gameTable)..where((g) => g.id.equals(gameId));
-    final rowsAffected = await query.write(
-      const GameTableCompanion(winnerId: Value(null)),
-    );
-    return rowsAffected > 0;
-  }
-
-  /// Checks if the game with the given [gameId] has a winner set.
-  /// Returns `true` if a winner is set, otherwise `false`.
-  Future<bool> hasWinner({required String gameId}) async {
-    final query = select(gameTable)
-      ..where((g) => g.id.equals(gameId) & g.winnerId.isNotNull());
-    final result = await query.getSingleOrNull();
-    return result != null;
-  }
-
-  /// Changes the title of the game with the given [gameId] to [newName].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> updateGameName({
-    required String gameId,
-    required String newName,
-  }) async {
-    final query = update(gameTable)..where((g) => g.id.equals(gameId));
-    final rowsAffected = await query.write(
-      GameTableCompanion(name: Value(newName)),
-    );
-    return rowsAffected > 0;
-  }
-}

lib/data/dao/game_dao.g.dart

@@ -1,8 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'game_dao.dart';
-
-// ignore_for_file: type=lint
-mixin _$GameDaoMixin on DatabaseAccessor<AppDatabase> {
-  $GameTableTable get gameTable => attachedDatabase.gameTable;
-}

lib/data/dao/group_dao.dart

@@ -1,12 +1,13 @@
 import 'package:drift/drift.dart';
 import 'package:game_tracker/data/db/database.dart';
 import 'package:game_tracker/data/db/tables/group_table.dart';
+import 'package:game_tracker/data/db/tables/player_group_table.dart';
 import 'package:game_tracker/data/dto/group.dart';
 import 'package:game_tracker/data/dto/player.dart';
 
 part 'group_dao.g.dart';
 
-@DriftAccessor(tables: [GroupTable])
+@DriftAccessor(tables: [GroupTable, PlayerGroupTable])
 class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
   GroupDao(super.db);
 

lib/data/dao/group_dao.g.dart

@@ -5,4 +5,7 @@ part of 'group_dao.dart';
 // ignore_for_file: type=lint
 mixin _$GroupDaoMixin on DatabaseAccessor<AppDatabase> {
   $GroupTableTable get groupTable => attachedDatabase.groupTable;
+  $PlayerTableTable get playerTable => attachedDatabase.playerTable;
+  $PlayerGroupTableTable get playerGroupTable =>
+      attachedDatabase.playerGroupTable;
 }

lib/data/dao/group_game_dao.dart

@@ -1,98 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/db/tables/group_game_table.dart';
-import 'package:game_tracker/data/dto/group.dart';
-
-part 'group_game_dao.g.dart';
-
-@DriftAccessor(tables: [GroupGameTable])
-class GroupGameDao extends DatabaseAccessor<AppDatabase>
-    with _$GroupGameDaoMixin {
-  GroupGameDao(super.db);
-
-  /// Associates a group with a game by inserting a record into the
-  /// [GroupGameTable].
-  Future<void> addGroupToGame({
-    required String gameId,
-    required String groupId,
-  }) async {
-    if (await gameHasGroup(gameId: gameId)) {
-      throw Exception('Game already has a group');
-    }
-    await into(groupGameTable).insert(
-      GroupGameTableCompanion.insert(groupId: groupId, gameId: gameId),
-      mode: InsertMode.insertOrReplace,
-    );
-  }
-
-  /// Retrieves the [Group] associated with the given [gameId].
-  /// Returns `null` if no group is found.
-  Future<Group?> getGroupOfGame({required String gameId}) async {
-    final result = await (select(
-      groupGameTable,
-    )..where((g) => g.gameId.equals(gameId))).getSingleOrNull();
-
-    if (result == null) {
-      return null;
-    }
-
-    final group = await db.groupDao.getGroupById(groupId: result.groupId);
-    return group;
-  }
-
-  /// Checks if there is a group associated with the given [gameId].
-  /// Returns `true` if there is a group, otherwise `false`.
-  Future<bool> gameHasGroup({required String gameId}) async {
-    final count =
-        await (selectOnly(groupGameTable)
-              ..where(groupGameTable.gameId.equals(gameId))
-              ..addColumns([groupGameTable.groupId.count()]))
-            .map((row) => row.read(groupGameTable.groupId.count()))
-            .getSingle();
-    return (count ?? 0) > 0;
-  }
-
-  /// Checks if a specific group is associated with a specific game.
-  /// Returns `true` if the group is in the game, otherwise `false`.
-  Future<bool> isGroupInGame({
-    required String gameId,
-    required String groupId,
-  }) async {
-    final count =
-        await (selectOnly(groupGameTable)
-              ..where(
-                groupGameTable.gameId.equals(gameId) &
-                    groupGameTable.groupId.equals(groupId),
-              )
-              ..addColumns([groupGameTable.groupId.count()]))
-            .map((row) => row.read(groupGameTable.groupId.count()))
-            .getSingle();
-    return (count ?? 0) > 0;
-  }
-
-  /// Removes the association of a group from a game based on [groupId] and
-  /// [gameId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> removeGroupFromGame({
-    required String gameId,
-    required String groupId,
-  }) async {
-    final query = delete(groupGameTable)
-      ..where((g) => g.gameId.equals(gameId) & g.groupId.equals(groupId));
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Updates the group associated with a game to [newGroupId] based on
-  /// [gameId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> updateGroupOfGame({
-    required String gameId,
-    required String newGroupId,
-  }) async {
-    final updatedRows =
-        await (update(groupGameTable)..where((g) => g.gameId.equals(gameId)))
-            .write(GroupGameTableCompanion(groupId: Value(newGroupId)));
-    return updatedRows > 0;
-  }
-}

lib/data/dao/group_game_dao.g.dart

@@ -1,10 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'group_game_dao.dart';
-
-// ignore_for_file: type=lint
-mixin _$GroupGameDaoMixin on DatabaseAccessor<AppDatabase> {
-  $GroupTableTable get groupTable => attachedDatabase.groupTable;
-  $GameTableTable get gameTable => attachedDatabase.gameTable;
-  $GroupGameTableTable get groupGameTable => attachedDatabase.groupGameTable;
-}

lib/data/dao/group_match_dao.dart

@@ -0,0 +1,98 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/db/tables/group_match_table.dart';
+import 'package:game_tracker/data/dto/group.dart';
+
+part 'group_match_dao.g.dart';
+
+@DriftAccessor(tables: [GroupMatchTable])
+class GroupMatchDao extends DatabaseAccessor<AppDatabase>
+    with _$GroupMatchDaoMixin {
+  GroupMatchDao(super.db);
+
+  /// Associates a group with a match by inserting a record into the
+  /// [GroupMatchTable].
+  Future<void> addGroupToMatch({
+    required String matchId,
+    required String groupId,
+  }) async {
+    if (await matchHasGroup(matchId: matchId)) {
+      throw Exception('Match already has a group');
+    }
+    await into(groupMatchTable).insert(
+      GroupMatchTableCompanion.insert(groupId: groupId, matchId: matchId),
+      mode: InsertMode.insertOrIgnore,
+    );
+  }
+
+  /// Retrieves the [Group] associated with the given [matchId].
+  /// Returns `null` if no group is found.
+  Future<Group?> getGroupOfMatch({required String matchId}) async {
+    final result = await (select(
+      groupMatchTable,
+    )..where((g) => g.matchId.equals(matchId))).getSingleOrNull();
+
+    if (result == null) {
+      return null;
+    }
+
+    final group = await db.groupDao.getGroupById(groupId: result.groupId);
+    return group;
+  }
+
+  /// Checks if there is a group associated with the given [matchId].
+  /// Returns `true` if there is a group, otherwise `false`.
+  Future<bool> matchHasGroup({required String matchId}) async {
+    final count =
+        await (selectOnly(groupMatchTable)
+              ..where(groupMatchTable.matchId.equals(matchId))
+              ..addColumns([groupMatchTable.groupId.count()]))
+            .map((row) => row.read(groupMatchTable.groupId.count()))
+            .getSingle();
+    return (count ?? 0) > 0;
+  }
+
+  /// Checks if a specific group is associated with a specific match.
+  /// Returns `true` if the group is in the match, otherwise `false`.
+  Future<bool> isGroupInMatch({
+    required String matchId,
+    required String groupId,
+  }) async {
+    final count =
+        await (selectOnly(groupMatchTable)
+              ..where(
+                groupMatchTable.matchId.equals(matchId) &
+                    groupMatchTable.groupId.equals(groupId),
+              )
+              ..addColumns([groupMatchTable.groupId.count()]))
+            .map((row) => row.read(groupMatchTable.groupId.count()))
+            .getSingle();
+    return (count ?? 0) > 0;
+  }
+
+  /// Removes the association of a group from a match based on [groupId] and
+  /// [matchId].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> removeGroupFromMatch({
+    required String matchId,
+    required String groupId,
+  }) async {
+    final query = delete(groupMatchTable)
+      ..where((g) => g.matchId.equals(matchId) & g.groupId.equals(groupId));
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  /// Updates the group associated with a match to [newGroupId] based on
+  /// [matchId].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> updateGroupOfMatch({
+    required String matchId,
+    required String newGroupId,
+  }) async {
+    final updatedRows =
+        await (update(groupMatchTable)..where((g) => g.matchId.equals(matchId)))
+            .write(GroupMatchTableCompanion(groupId: Value(newGroupId)));
+    return updatedRows > 0;
+  }
+}

lib/data/dao/group_match_dao.g.dart

@@ -0,0 +1,10 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'group_match_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$GroupMatchDaoMixin on DatabaseAccessor<AppDatabase> {
+  $GroupTableTable get groupTable => attachedDatabase.groupTable;
+  $MatchTableTable get matchTable => attachedDatabase.matchTable;
+  $GroupMatchTableTable get groupMatchTable => attachedDatabase.groupMatchTable;
+}

lib/data/dao/match_dao.dart

@@ -0,0 +1,322 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/db/tables/match_table.dart';
+import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
+import 'package:game_tracker/data/dto/player.dart';
+
+part 'match_dao.g.dart';
+
+@DriftAccessor(tables: [MatchTable])
+class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
+  MatchDao(super.db);
+
+  /// Retrieves all matches from the database.
+  Future<List<Match>> getAllMatches() async {
+    final query = select(matchTable);
+    final result = await query.get();
+
+    return Future.wait(
+      result.map((row) async {
+        final group = await db.groupMatchDao.getGroupOfMatch(matchId: row.id);
+        final players = await db.playerMatchDao.getPlayersOfMatch(
+          matchId: row.id,
+        );
+        final winner = row.winnerId != null
+            ? await db.playerDao.getPlayerById(playerId: row.winnerId!)
+            : null;
+        return Match(
+          id: row.id,
+          name: row.name,
+          group: group,
+          players: players,
+          createdAt: row.createdAt,
+          winner: winner,
+        );
+      }),
+    );
+  }
+
+  /// Retrieves a [Match] by its [matchId].
+  Future<Match> getMatchById({required String matchId}) async {
+    final query = select(matchTable)..where((g) => g.id.equals(matchId));
+    final result = await query.getSingle();
+
+    List<Player>? players;
+    if (await db.playerMatchDao.matchHasPlayers(matchId: matchId)) {
+      players = await db.playerMatchDao.getPlayersOfMatch(matchId: matchId);
+    }
+    Group? group;
+    if (await db.groupMatchDao.matchHasGroup(matchId: matchId)) {
+      group = await db.groupMatchDao.getGroupOfMatch(matchId: matchId);
+    }
+    Player? winner;
+    if (result.winnerId != null) {
+      winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
+    }
+
+    return Match(
+      id: result.id,
+      name: result.name,
+      players: players,
+      group: group,
+      winner: winner,
+      createdAt: result.createdAt,
+    );
+  }
+
+  /// Adds a new [Match] to the database. Also adds players and group
+  /// associations. This method assumes that the players and groups added to
+  /// this match are already present in the database.
+  Future<void> addMatch({required Match match}) async {
+    await db.transaction(() async {
+      await into(matchTable).insert(
+        MatchTableCompanion.insert(
+          id: match.id,
+          name: match.name,
+          winnerId: Value(match.winner?.id),
+          createdAt: match.createdAt,
+        ),
+        mode: InsertMode.insertOrReplace,
+      );
+
+      if (match.players != null) {
+        for (final p in match.players ?? []) {
+          await db.playerMatchDao.addPlayerToMatch(
+            matchId: match.id,
+            playerId: p.id,
+          );
+        }
+      }
+
+      if (match.group != null) {
+        await db.groupMatchDao.addGroupToMatch(
+          matchId: match.id,
+          groupId: match.group!.id,
+        );
+      }
+    });
+  }
+
+  /// Adds multiple [Match]s to the database in a batch operation.
+  /// Also adds associated players and groups if they exist.
+  /// If the [matches] list is empty, the method returns immediately.
+  /// This Method should only be used to import matches from a different device.
+  Future<void> addMatchAsList({required List<Match> matches}) async {
+    if (matches.isEmpty) return;
+    await db.transaction(() async {
+      // Add all matches in batch
+      await db.batch(
+        (b) => b.insertAll(
+          matchTable,
+          matches
+              .map(
+                (match) => MatchTableCompanion.insert(
+                  id: match.id,
+                  name: match.name,
+                  createdAt: match.createdAt,
+                  winnerId: Value(match.winner?.id),
+                ),
+              )
+              .toList(),
+          mode: InsertMode.insertOrReplace,
+        ),
+      );
+
+      // Add all groups of the matches in batch
+      await db.batch(
+        (b) => b.insertAll(
+          db.groupTable,
+          matches
+              .where((match) => match.group != null)
+              .map(
+                (matches) => GroupTableCompanion.insert(
+                  id: matches.group!.id,
+                  name: matches.group!.name,
+                  createdAt: matches.group!.createdAt,
+                ),
+              )
+              .toList(),
+          mode: InsertMode.insertOrReplace,
+        ),
+      );
+
+      // Add all players of the matches in batch (unique)
+      final uniquePlayers = <String, Player>{};
+      for (final match in matches) {
+        if (match.players != null) {
+          for (final p in match.players!) {
+            uniquePlayers[p.id] = p;
+          }
+        }
+        // Also include members of groups
+        if (match.group != null) {
+          for (final m in match.group!.members) {
+            uniquePlayers[m.id] = m;
+          }
+        }
+      }
+
+      if (uniquePlayers.isNotEmpty) {
+        await db.batch(
+          (b) => b.insertAll(
+            db.playerTable,
+            uniquePlayers.values
+                .map(
+                  (p) => PlayerTableCompanion.insert(
+                    id: p.id,
+                    name: p.name,
+                    createdAt: p.createdAt,
+                  ),
+                )
+                .toList(),
+            mode: InsertMode.insertOrReplace,
+          ),
+        );
+      }
+
+      // Add all player-match associations in batch
+      await db.batch((b) {
+        for (final match in matches) {
+          if (match.players != null) {
+            for (final p in match.players ?? []) {
+              b.insert(
+                db.playerMatchTable,
+                PlayerMatchTableCompanion.insert(
+                  matchId: match.id,
+                  playerId: p.id,
+                ),
+                mode: InsertMode.insertOrIgnore,
+              );
+            }
+          }
+        }
+      });
+
+      // Add all player-group associations in batch
+      await db.batch((b) {
+        for (final match in matches) {
+          if (match.group != null) {
+            for (final m in match.group!.members) {
+              b.insert(
+                db.playerGroupTable,
+                PlayerGroupTableCompanion.insert(
+                  playerId: m.id,
+                  groupId: match.group!.id,
+                ),
+                mode: InsertMode.insertOrIgnore,
+              );
+            }
+          }
+        }
+      });
+
+      // Add all group-match associations in batch
+      await db.batch((b) {
+        for (final match in matches) {
+          if (match.group != null) {
+            b.insert(
+              db.groupMatchTable,
+              GroupMatchTableCompanion.insert(
+                matchId: match.id,
+                groupId: match.group!.id,
+              ),
+              mode: InsertMode.insertOrIgnore,
+            );
+          }
+        }
+      });
+    });
+  }
+
+  /// Deletes the match with the given [matchId] from the database.
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> deleteMatch({required String matchId}) async {
+    final query = delete(matchTable)..where((g) => g.id.equals(matchId));
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  /// Retrieves the number of matches in the database.
+  Future<int> getMatchCount() async {
+    final count =
+        await (selectOnly(matchTable)..addColumns([matchTable.id.count()]))
+            .map((row) => row.read(matchTable.id.count()))
+            .getSingle();
+    return count ?? 0;
+  }
+
+  /// Checks if a match with the given [matchId] exists in the database.
+  /// Returns `true` if the match exists, otherwise `false`.
+  Future<bool> matchExists({required String matchId}) async {
+    final query = select(matchTable)..where((g) => g.id.equals(matchId));
+    final result = await query.getSingleOrNull();
+    return result != null;
+  }
+
+  /// Deletes all matches from the database.
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> deleteAllMatches() async {
+    final query = delete(matchTable);
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  /// Sets the winner of the match with the given [matchId] to the player with
+  /// the given [winnerId].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> setWinner({
+    required String matchId,
+    required String winnerId,
+  }) async {
+    final query = update(matchTable)..where((g) => g.id.equals(matchId));
+    final rowsAffected = await query.write(
+      MatchTableCompanion(winnerId: Value(winnerId)),
+    );
+    return rowsAffected > 0;
+  }
+
+  /// Retrieves the winner of the match with the given [matchId].
+  /// Returns the [Player] who won the match, or `null` if no winner is set.
+  Future<Player?> getWinner({required String matchId}) async {
+    final query = select(matchTable)..where((g) => g.id.equals(matchId));
+    final result = await query.getSingleOrNull();
+    if (result == null || result.winnerId == null) {
+      return null;
+    }
+    final winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
+    return winner;
+  }
+
+  /// Removes the winner of the match with the given [matchId].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> removeWinner({required String matchId}) async {
+    final query = update(matchTable)..where((g) => g.id.equals(matchId));
+    final rowsAffected = await query.write(
+      const MatchTableCompanion(winnerId: Value(null)),
+    );
+    return rowsAffected > 0;
+  }
+
+  /// Checks if the match with the given [matchId] has a winner set.
+  /// Returns `true` if a winner is set, otherwise `false`.
+  Future<bool> hasWinner({required String matchId}) async {
+    final query = select(matchTable)
+      ..where((g) => g.id.equals(matchId) & g.winnerId.isNotNull());
+    final result = await query.getSingleOrNull();
+    return result != null;
+  }
+
+  /// Changes the title of the match with the given [matchId] to [newName].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> updateMatchName({
+    required String matchId,
+    required String newName,
+  }) async {
+    final query = update(matchTable)..where((g) => g.id.equals(matchId));
+    final rowsAffected = await query.write(
+      MatchTableCompanion(name: Value(newName)),
+    );
+    return rowsAffected > 0;
+  }
+}

lib/data/dao/match_dao.g.dart

@@ -0,0 +1,8 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'match_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$MatchDaoMixin on DatabaseAccessor<AppDatabase> {
+  $MatchTableTable get matchTable => attachedDatabase.matchTable;
+}

lib/data/dao/player_game_dao.dart

@@ -1,128 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/db/tables/player_game_table.dart';
-import 'package:game_tracker/data/dto/player.dart';
-
-part 'player_game_dao.g.dart';
-
-@DriftAccessor(tables: [PlayerGameTable])
-class PlayerGameDao extends DatabaseAccessor<AppDatabase>
-    with _$PlayerGameDaoMixin {
-  PlayerGameDao(super.db);
-
-  /// Associates a player with a game by inserting a record into the
-  /// [PlayerGameTable].
-  Future<void> addPlayerToGame({
-    required String gameId,
-    required String playerId,
-  }) async {
-    await into(playerGameTable).insert(
-      PlayerGameTableCompanion.insert(playerId: playerId, gameId: gameId),
-      mode: InsertMode.insertOrReplace,
-    );
-  }
-
-  /// Retrieves a list of [Player]s associated with the given [gameId].
-  /// Returns null if no players are found.
-  Future<List<Player>?> getPlayersOfGame({required String gameId}) async {
-    final result = await (select(
-      playerGameTable,
-    )..where((p) => p.gameId.equals(gameId))).get();
-
-    if (result.isEmpty) return null;
-
-    final futures = result.map(
-      (row) => db.playerDao.getPlayerById(playerId: row.playerId),
-    );
-    final players = await Future.wait(futures);
-    return players;
-  }
-
-  /// Checks if there are any players associated with the given [gameId].
-  /// Returns `true` if there are players, otherwise `false`.
-  Future<bool> gameHasPlayers({required String gameId}) async {
-    final count =
-        await (selectOnly(playerGameTable)
-              ..where(playerGameTable.gameId.equals(gameId))
-              ..addColumns([playerGameTable.playerId.count()]))
-            .map((row) => row.read(playerGameTable.playerId.count()))
-            .getSingle();
-    return (count ?? 0) > 0;
-  }
-
-  /// Checks if a specific player is associated with a specific game.
-  /// Returns `true` if the player is in the game, otherwise `false`.
-  Future<bool> isPlayerInGame({
-    required String gameId,
-    required String playerId,
-  }) async {
-    final count =
-        await (selectOnly(playerGameTable)
-              ..where(playerGameTable.gameId.equals(gameId))
-              ..where(playerGameTable.playerId.equals(playerId))
-              ..addColumns([playerGameTable.playerId.count()]))
-            .map((row) => row.read(playerGameTable.playerId.count()))
-            .getSingle();
-    return (count ?? 0) > 0;
-  }
-
-  /// Removes the association of a player with a game by deleting the record
-  /// from the [PlayerGameTable].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> removePlayerFromGame({
-    required String gameId,
-    required String playerId,
-  }) async {
-    final query = delete(playerGameTable)
-      ..where((pg) => pg.gameId.equals(gameId))
-      ..where((pg) => pg.playerId.equals(playerId));
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Updates the players associated with a game based on the provided
-  /// [newPlayer] list. It adds new players and removes players that are no
-  /// longer associated with the game.
-  Future<void> updatePlayersFromGame({
-    required String gameId,
-    required List<Player> newPlayer,
-  }) async {
-    final currentPlayers = await getPlayersOfGame(gameId: gameId);
-    // Create sets of player IDs for easy comparison
-    final currentPlayerIds = currentPlayers?.map((p) => p.id).toSet() ?? {};
-    final newPlayerIdsSet = newPlayer.map((p) => p.id).toSet();
-
-    // Determine players to add and remove
-    final playersToAdd = newPlayerIdsSet.difference(currentPlayerIds);
-    final playersToRemove = currentPlayerIds.difference(newPlayerIdsSet);
-
-    db.transaction(() async {
-      // Remove old players
-      if (playersToRemove.isNotEmpty) {
-        await (delete(playerGameTable)..where(
-              (pg) =>
-                  pg.gameId.equals(gameId) &
-                  pg.playerId.isIn(playersToRemove.toList()),
-            ))
-            .go();
-      }
-
-      // Add new players
-      if (playersToAdd.isNotEmpty) {
-        final inserts = playersToAdd
-            .map(
-              (id) =>
-                  PlayerGameTableCompanion.insert(playerId: id, gameId: gameId),
-            )
-            .toList();
-        await Future.wait(
-          inserts.map(
-            (c) => into(
-              playerGameTable,
-            ).insert(c, mode: InsertMode.insertOrReplace),
-          ),
-        );
-      }
-    });
-  }
-}

lib/data/dao/player_game_dao.g.dart

@@ -1,10 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'player_game_dao.dart';
-
-// ignore_for_file: type=lint
-mixin _$PlayerGameDaoMixin on DatabaseAccessor<AppDatabase> {
-  $PlayerTableTable get playerTable => attachedDatabase.playerTable;
-  $GameTableTable get gameTable => attachedDatabase.gameTable;
-  $PlayerGameTableTable get playerGameTable => attachedDatabase.playerGameTable;
-}

lib/data/dao/player_group_dao.dart

@@ -1,11 +1,12 @@
 import 'package:drift/drift.dart';
 import 'package:game_tracker/data/db/database.dart';
 import 'package:game_tracker/data/db/tables/player_group_table.dart';
+import 'package:game_tracker/data/db/tables/player_table.dart';
 import 'package:game_tracker/data/dto/player.dart';
 
 part 'player_group_dao.g.dart';
 
-@DriftAccessor(tables: [PlayerGroupTable])
+@DriftAccessor(tables: [PlayerGroupTable, PlayerTable])
 class PlayerGroupDao extends DatabaseAccessor<AppDatabase>
     with _$PlayerGroupDaoMixin {
   PlayerGroupDao(super.db);

lib/data/dao/player_match_dao.dart

@@ -0,0 +1,130 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/db/tables/player_match_table.dart';
+import 'package:game_tracker/data/dto/player.dart';
+
+part 'player_match_dao.g.dart';
+
+@DriftAccessor(tables: [PlayerMatchTable])
+class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
+    with _$PlayerMatchDaoMixin {
+  PlayerMatchDao(super.db);
+
+  /// Associates a player with a match by inserting a record into the
+  /// [PlayerMatchTable].
+  Future<void> addPlayerToMatch({
+    required String matchId,
+    required String playerId,
+  }) async {
+    await into(playerMatchTable).insert(
+      PlayerMatchTableCompanion.insert(playerId: playerId, matchId: matchId),
+      mode: InsertMode.insertOrIgnore,
+    );
+  }
+
+  /// Retrieves a list of [Player]s associated with the given [matchId].
+  /// Returns null if no players are found.
+  Future<List<Player>?> getPlayersOfMatch({required String matchId}) async {
+    final result = await (select(
+      playerMatchTable,
+    )..where((p) => p.matchId.equals(matchId))).get();
+
+    if (result.isEmpty) return null;
+
+    final futures = result.map(
+      (row) => db.playerDao.getPlayerById(playerId: row.playerId),
+    );
+    final players = await Future.wait(futures);
+    return players;
+  }
+
+  /// Checks if there are any players associated with the given [matchId].
+  /// Returns `true` if there are players, otherwise `false`.
+  Future<bool> matchHasPlayers({required String matchId}) async {
+    final count =
+        await (selectOnly(playerMatchTable)
+              ..where(playerMatchTable.matchId.equals(matchId))
+              ..addColumns([playerMatchTable.playerId.count()]))
+            .map((row) => row.read(playerMatchTable.playerId.count()))
+            .getSingle();
+    return (count ?? 0) > 0;
+  }
+
+  /// Checks if a specific player is associated with a specific match.
+  /// Returns `true` if the player is in the match, otherwise `false`.
+  Future<bool> isPlayerInMatch({
+    required String matchId,
+    required String playerId,
+  }) async {
+    final count =
+        await (selectOnly(playerMatchTable)
+              ..where(playerMatchTable.matchId.equals(matchId))
+              ..where(playerMatchTable.playerId.equals(playerId))
+              ..addColumns([playerMatchTable.playerId.count()]))
+            .map((row) => row.read(playerMatchTable.playerId.count()))
+            .getSingle();
+    return (count ?? 0) > 0;
+  }
+
+  /// Removes the association of a player with a match by deleting the record
+  /// from the [PlayerMatchTable].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> removePlayerFromMatch({
+    required String matchId,
+    required String playerId,
+  }) async {
+    final query = delete(playerMatchTable)
+      ..where((pg) => pg.matchId.equals(matchId))
+      ..where((pg) => pg.playerId.equals(playerId));
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  /// Updates the players associated with a match based on the provided
+  /// [newPlayer] list. It adds new players and removes players that are no
+  /// longer associated with the match.
+  Future<void> updatePlayersFromMatch({
+    required String matchId,
+    required List<Player> newPlayer,
+  }) async {
+    final currentPlayers = await getPlayersOfMatch(matchId: matchId);
+    // Create sets of player IDs for easy comparison
+    final currentPlayerIds = currentPlayers?.map((p) => p.id).toSet() ?? {};
+    final newPlayerIdsSet = newPlayer.map((p) => p.id).toSet();
+
+    // Determine players to add and remove
+    final playersToAdd = newPlayerIdsSet.difference(currentPlayerIds);
+    final playersToRemove = currentPlayerIds.difference(newPlayerIdsSet);
+
+    db.transaction(() async {
+      // Remove old players
+      if (playersToRemove.isNotEmpty) {
+        await (delete(playerMatchTable)..where(
+              (pg) =>
+                  pg.matchId.equals(matchId) &
+                  pg.playerId.isIn(playersToRemove.toList()),
+            ))
+            .go();
+      }
+
+      // Add new players
+      if (playersToAdd.isNotEmpty) {
+        final inserts = playersToAdd
+            .map(
+              (id) => PlayerMatchTableCompanion.insert(
+                playerId: id,
+                matchId: matchId,
+              ),
+            )
+            .toList();
+        await Future.wait(
+          inserts.map(
+            (c) => into(
+              playerMatchTable,
+            ).insert(c, mode: InsertMode.insertOrIgnore),
+          ),
+        );
+      }
+    });
+  }
+}

lib/data/dao/player_match_dao.g.dart

@@ -0,0 +1,11 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'player_match_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$PlayerMatchDaoMixin on DatabaseAccessor<AppDatabase> {
+  $PlayerTableTable get playerTable => attachedDatabase.playerTable;
+  $MatchTableTable get matchTable => attachedDatabase.matchTable;
+  $PlayerMatchTableTable get playerMatchTable =>
+      attachedDatabase.playerMatchTable;
+}

lib/data/db/database.dart

@@ -1,16 +1,16 @@
 import 'package:drift/drift.dart';
 import 'package:drift_flutter/drift_flutter.dart';
-import 'package:game_tracker/data/dao/game_dao.dart';
 import 'package:game_tracker/data/dao/group_dao.dart';
-import 'package:game_tracker/data/dao/group_game_dao.dart';
+import 'package:game_tracker/data/dao/group_match_dao.dart';
+import 'package:game_tracker/data/dao/match_dao.dart';
 import 'package:game_tracker/data/dao/player_dao.dart';
-import 'package:game_tracker/data/dao/player_game_dao.dart';
 import 'package:game_tracker/data/dao/player_group_dao.dart';
-import 'package:game_tracker/data/db/tables/game_table.dart';
+import 'package:game_tracker/data/dao/player_match_dao.dart';
-import 'package:game_tracker/data/db/tables/group_game_table.dart';
+import 'package:game_tracker/data/db/tables/group_match_table.dart';
 import 'package:game_tracker/data/db/tables/group_table.dart';
-import 'package:game_tracker/data/db/tables/player_game_table.dart';
+import 'package:game_tracker/data/db/tables/match_table.dart';
 import 'package:game_tracker/data/db/tables/player_group_table.dart';
+import 'package:game_tracker/data/db/tables/player_match_table.dart';
 import 'package:game_tracker/data/db/tables/player_table.dart';
 import 'package:path_provider/path_provider.dart';
 
@@ -20,18 +20,18 @@ part 'database.g.dart';
   tables: [
     PlayerTable,
     GroupTable,
-    GameTable,
+    MatchTable,
     PlayerGroupTable,
-    PlayerGameTable,
+    PlayerMatchTable,
-    GroupGameTable,
+    GroupMatchTable,
   ],
   daos: [
     PlayerDao,
     GroupDao,
-    GameDao,
+    MatchDao,
     PlayerGroupDao,
-    PlayerGameDao,
+    PlayerMatchDao,
-    GroupGameDao,
+    GroupMatchDao,
   ],
 )
 class AppDatabase extends _$AppDatabase {

lib/data/db/tables/group_game_table.dart

@@ -1,13 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:game_tracker/data/db/tables/game_table.dart';
-import 'package:game_tracker/data/db/tables/group_table.dart';
-
-class GroupGameTable extends Table {
-  TextColumn get groupId =>
-      text().references(GroupTable, #id, onDelete: KeyAction.cascade)();
-  TextColumn get gameId =>
-      text().references(GameTable, #id, onDelete: KeyAction.cascade)();
-
-  @override
-  Set<Column<Object>> get primaryKey => {groupId, gameId};
-}

lib/data/db/tables/group_match_table.dart

@@ -0,0 +1,13 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/tables/group_table.dart';
+import 'package:game_tracker/data/db/tables/match_table.dart';
+
+class GroupMatchTable extends Table {
+  TextColumn get groupId =>
+      text().references(GroupTable, #id, onDelete: KeyAction.cascade)();
+  TextColumn get matchId =>
+      text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
+
+  @override
+  Set<Column<Object>> get primaryKey => {groupId, matchId};
+}

lib/data/db/tables/match_table.dart

@@ -1,6 +1,6 @@
 import 'package:drift/drift.dart';
 
-class GameTable extends Table {
+class MatchTable extends Table {
   TextColumn get id => text()();
   TextColumn get name => text()();
   late final winnerId = text().nullable()();

lib/data/db/tables/player_game_table.dart

@@ -1,13 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:game_tracker/data/db/tables/game_table.dart';
-import 'package:game_tracker/data/db/tables/player_table.dart';
-
-class PlayerGameTable extends Table {
-  TextColumn get playerId =>
-      text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
-  TextColumn get gameId =>
-      text().references(GameTable, #id, onDelete: KeyAction.cascade)();
-
-  @override
-  Set<Column<Object>> get primaryKey => {playerId, gameId};
-}

lib/data/db/tables/player_match_table.dart

@@ -0,0 +1,13 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/tables/match_table.dart';
+import 'package:game_tracker/data/db/tables/player_table.dart';
+
+class PlayerMatchTable extends Table {
+  TextColumn get playerId =>
+      text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
+  TextColumn get matchId =>
+      text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
+
+  @override
+  Set<Column<Object>> get primaryKey => {playerId, matchId};
+}

lib/data/dto/match.dart

@@ -3,7 +3,7 @@ import 'package:game_tracker/data/dto/group.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:uuid/uuid.dart';
 
-class Game {
+class Match {
   final String id;
   final DateTime createdAt;
   final String name;
@@ -11,7 +11,7 @@ class Game {
   final Group? group;
   final Player? winner;
 
-  Game({
+  Match({
     String? id,
     DateTime? createdAt,
     required this.name,
@@ -23,11 +23,11 @@ class Game {
 
   @override
   String toString() {
-    return 'Game{\n\tid: $id,\n\tname: $name,\n\tplayers: $players,\n\tgroup: $group,\n\twinner: $winner\n}';
+    return 'Match{\n\tid: $id,\n\tname: $name,\n\tplayers: $players,\n\tgroup: $group,\n\twinner: $winner\n}';
   }
 
-  /// Creates a Game instance from a JSON object.
+  /// Creates a Match instance from a JSON object.
-  Game.fromJson(Map<String, dynamic> json)
+  Match.fromJson(Map<String, dynamic> json)
     : id = json['id'],
       name = json['name'],
       createdAt = DateTime.parse(json['createdAt']),
@@ -39,7 +39,7 @@ class Game {
       group = json['group'] != null ? Group.fromJson(json['group']) : null,
       winner = json['winner'] != null ? Player.fromJson(json['winner']) : null;
 
-  /// Converts the Game instance to a JSON object.
+  /// Converts the Match instance to a JSON object.
   Map<String, dynamic> toJson() => {
     'id': id,
     'createdAt': createdAt.toIso8601String(),

lib/presentation/views/main_menu/create_game/choose_group_view.dart

@@ -1,66 +0,0 @@
-import 'package:flutter/material.dart';
-import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/data/dto/group.dart';
-import 'package:game_tracker/presentation/widgets/tiles/group_tile.dart';
-
-class ChooseGroupView extends StatefulWidget {
-  final List<Group> groups;
-  final int initialGroupIndex;
-
-  const ChooseGroupView({
-    super.key,
-    required this.groups,
-    required this.initialGroupIndex,
-  });
-
-  @override
-  State<ChooseGroupView> createState() => _ChooseGroupViewState();
-}
-
-class _ChooseGroupViewState extends State<ChooseGroupView> {
-  late int selectedGroupIndex;
-
-  @override
-  void initState() {
-    selectedGroupIndex = widget.initialGroupIndex;
-    super.initState();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return Scaffold(
-      backgroundColor: CustomTheme.backgroundColor,
-      appBar: AppBar(
-        backgroundColor: CustomTheme.backgroundColor,
-        scrolledUnderElevation: 0,
-        title: const Text(
-          'Choose Group',
-          style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
-        ),
-        centerTitle: true,
-      ),
-      body: ListView.builder(
-        padding: const EdgeInsets.only(bottom: 85),
-        itemCount: widget.groups.length,
-        itemBuilder: (BuildContext context, int index) {
-          return GestureDetector(
-            onTap: () {
-              setState(() {
-                selectedGroupIndex = index;
-              });
-
-              Future.delayed(const Duration(milliseconds: 500), () {
-                if (!context.mounted) return;
-                Navigator.of(context).pop(widget.groups[index]);
-              });
-            },
-            child: GroupTile(
-              group: widget.groups[index],
-              isHighlighted: selectedGroupIndex == index,
-            ),
-          );
-        },
-      ),
-    );
-  }
-}

lib/presentation/views/main_menu/create_game/choose_ruleset_view.dart

@@ -1,120 +0,0 @@
-import 'package:flutter/material.dart';
-import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/core/enums.dart';
-import 'package:game_tracker/presentation/widgets/tiles/ruleset_list_tile.dart';
-
-class ChooseRulesetView extends StatefulWidget {
-  final List<(Ruleset, String, String)> rulesets;
-  final int initialRulesetIndex;
-  const ChooseRulesetView({
-    super.key,
-    required this.rulesets,
-    required this.initialRulesetIndex,
-  });
-
-  @override
-  State<ChooseRulesetView> createState() => _ChooseRulesetViewState();
-}
-
-class _ChooseRulesetViewState extends State<ChooseRulesetView> {
-  late int selectedRulesetIndex;
-
-  @override
-  void initState() {
-    selectedRulesetIndex = widget.initialRulesetIndex;
-    super.initState();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return DefaultTabController(
-      length: 2,
-      initialIndex: 0,
-      child: Scaffold(
-        backgroundColor: CustomTheme.backgroundColor,
-        appBar: AppBar(
-          backgroundColor: CustomTheme.backgroundColor,
-          scrolledUnderElevation: 0,
-          title: const Text(
-            'Choose Ruleset',
-            style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
-          ),
-          centerTitle: true,
-        ),
-        body: Column(
-          children: [
-            Container(
-              color: CustomTheme.backgroundColor,
-              padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
-              child: TabBar(
-                padding: const EdgeInsets.symmetric(horizontal: 5),
-                // Label Settings
-                labelStyle: const TextStyle(
-                  fontSize: 16,
-                  fontWeight: FontWeight.bold,
-                ),
-                labelColor: Colors.white,
-                unselectedLabelStyle: const TextStyle(fontSize: 14),
-                unselectedLabelColor: Colors.white70,
-                // Indicator Settings
-                indicator: CustomTheme.standardBoxDecoration,
-                indicatorSize: TabBarIndicatorSize.tab,
-                indicatorWeight: 1,
-                indicatorPadding: const EdgeInsets.symmetric(
-                  horizontal: 20,
-                  vertical: 0,
-                ),
-                // Divider Settings
-                dividerHeight: 0,
-                tabs: const [
-                  Tab(text: 'Rulesets'),
-                  Tab(text: 'Gametypes'),
-                ],
-              ),
-            ),
-            const Divider(
-              indent: 30,
-              endIndent: 30,
-              thickness: 3,
-              radius: BorderRadius.all(Radius.circular(12)),
-            ),
-            Expanded(
-              child: TabBarView(
-                children: [
-                  ListView.builder(
-                    padding: const EdgeInsets.only(bottom: 85),
-                    itemCount: widget.rulesets.length,
-                    itemBuilder: (BuildContext context, int index) {
-                      return RulesetListTile(
-                        onPressed: () async {
-                          setState(() {
-                            selectedRulesetIndex = index;
-                          });
-                          Future.delayed(const Duration(milliseconds: 500), () {
-                            if (!context.mounted) return;
-                            Navigator.of(
-                              context,
-                            ).pop(widget.rulesets[index].$1);
-                          });
-                        },
-                        title: widget.rulesets[index].$2,
-                        description: widget.rulesets[index].$3,
-                        isHighlighted: selectedRulesetIndex == index,
-                      );
-                    },
-                  ),
-                  const Center(
-                    child: Text(
-                      'No gametypes available',
-                      style: TextStyle(color: Colors.white70),
-                    ),
-                  ),
-                ],
-              ),
-            ),
-          ],
-        ),
-      ),
-    );
-  }
-}

lib/presentation/views/main_menu/custom_navigation_bar.dart

@@ -1,8 +1,8 @@
 import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/presentation/views/main_menu/game_history_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/group_view/groups_view.dart';
-import 'package:game_tracker/presentation/views/main_menu/groups_view.dart';
 import 'package:game_tracker/presentation/views/main_menu/home_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/match_view.dart';
 import 'package:game_tracker/presentation/views/main_menu/settings_view.dart';
 import 'package:game_tracker/presentation/views/main_menu/statistics_view.dart';
 import 'package:game_tracker/presentation/widgets/navbar_item.dart';
@@ -30,8 +30,8 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
     final List<Widget> tabs = [
       KeyedSubtree(key: ValueKey('home_$tabKeyCount'), child: const HomeView()),
       KeyedSubtree(
-        key: ValueKey('games_$tabKeyCount'),
+        key: ValueKey('matches_$tabKeyCount'),
-        child: const GameHistoryView(),
+        child: const MatchView(),
       ),
       KeyedSubtree(
         key: ValueKey('groups_$tabKeyCount'),
@@ -96,7 +96,7 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
                     index: 1,
                     isSelected: currentIndex == 1,
                     icon: Icons.gamepad_rounded,
-                    label: 'Games',
+                    label: 'Matches',
                     onTabTapped: onTabTapped,
                   ),
                   NavbarItem(
@@ -133,7 +133,7 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
       case 0:
         return 'Home';
       case 1:
-        return 'Game History';
+        return 'Matches';
       case 2:
         return 'Groups';
       case 3:

lib/presentation/views/main_menu/game_history_view.dart

@@ -1,150 +0,0 @@
-import 'package:flutter/cupertino.dart';
-import 'package:flutter/material.dart';
-import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
-import 'package:game_tracker/data/dto/group.dart';
-import 'package:game_tracker/data/dto/player.dart';
-import 'package:game_tracker/presentation/views/main_menu/create_group_view.dart';
-import 'package:game_tracker/presentation/views/main_menu/game_result_view.dart';
-import 'package:game_tracker/presentation/widgets/app_skeleton.dart';
-import 'package:game_tracker/presentation/widgets/buttons/custom_width_button.dart';
-import 'package:game_tracker/presentation/widgets/tiles/game_history_tile.dart';
-import 'package:game_tracker/presentation/widgets/top_centered_message.dart';
-import 'package:provider/provider.dart';
-
-class GameHistoryView extends StatefulWidget {
-  const GameHistoryView({super.key});
-
-  @override
-  State<GameHistoryView> createState() => _GameHistoryViewState();
-}
-
-class _GameHistoryViewState extends State<GameHistoryView> {
-  late Future<List<Game>> _gameListFuture;
-  late final AppDatabase db;
-
-  late final List<Game> skeletonData = List.filled(
-    4,
-    Game(
-      name: 'Skeleton Game',
-      group: Group(
-        name: 'Skeleton Group',
-        members: [
-          Player(name: 'Player 1'),
-          Player(name: 'Player 2'),
-          Player(name: 'Player 3'),
-          Player(name: 'Long Name Player 4'),
-          Player(name: 'Player 5'),
-        ],
-      ),
-      winner: Player(name: 'Skeleton Player 1'),
-      players: [Player(name: 'Skeleton Player 6')],
-    ),
-  );
-
-  @override
-  void initState() {
-    super.initState();
-    db = Provider.of<AppDatabase>(context, listen: false);
-    _gameListFuture = Future.delayed(
-      const Duration(milliseconds: 250),
-      () => db.gameDao.getAllGames(),
-    );
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return Scaffold(
-      backgroundColor: CustomTheme.backgroundColor,
-      body: Stack(
-        alignment: Alignment.center,
-        children: [
-          FutureBuilder<List<Game>>(
-            future: _gameListFuture,
-            builder:
-                (BuildContext context, AsyncSnapshot<List<Game>> snapshot) {
-                  if (snapshot.hasError) {
-                    return const Center(
-                      child: TopCenteredMessage(
-                        icon: Icons.report,
-                        title: 'Error',
-                        message: 'Game data could not be loaded',
-                      ),
-                    );
-                  }
-                  if (snapshot.connectionState == ConnectionState.done &&
-                      (!snapshot.hasData || snapshot.data!.isEmpty)) {
-                    return const Center(
-                      child: TopCenteredMessage(
-                        icon: Icons.report,
-                        title: 'Info',
-                        message: 'No games created yet',
-                      ),
-                    );
-                  }
-                  final bool isLoading =
-                      snapshot.connectionState == ConnectionState.waiting;
-                  final List<Game> games =
-                      (isLoading ? skeletonData : (snapshot.data ?? [])
-                            ..sort(
-                              (a, b) => b.createdAt.compareTo(a.createdAt),
-                            ))
-                          .toList();
-                  return AppSkeleton(
-                    enabled: isLoading,
-                    child: ListView.builder(
-                      padding: const EdgeInsets.only(bottom: 85),
-                      itemCount: games.length + 1,
-                      itemBuilder: (BuildContext context, int index) {
-                        if (index == games.length) {
-                          return SizedBox(
-                            height: MediaQuery.paddingOf(context).bottom - 80,
-                          );
-                        }
-                        return GameHistoryTile(
-                          onTap: () async {
-                            await Navigator.push(
-                              context,
-                              CupertinoPageRoute(
-                                fullscreenDialog: true,
-                                builder: (context) =>
-                                    GameResultView(game: games[index]),
-                              ),
-                            );
-                            setState(() {
-                              _gameListFuture = db.gameDao.getAllGames();
-                            });
-                          },
-                          game: games[index],
-                        );
-                      },
-                    ),
-                  );
-                },
-          ),
-          Positioned(
-            bottom: MediaQuery.paddingOf(context).bottom,
-            child: CustomWidthButton(
-              text: 'Create Game',
-              sizeRelativeToWidth: 0.90,
-              onPressed: () async {
-                await Navigator.push(
-                  context,
-                  MaterialPageRoute(
-                    builder: (context) {
-                      return const CreateGroupView();
-                    },
-                  ),
-                );
-                setState(() {
-                  _gameListFuture = db.gameDao.getAllGames();
-                });
-              },
-            ),
-          ),
-        ],
-      ),
-    );
-  }
-}

lib/presentation/views/main_menu/group_view/create_group_view.dart

@@ -66,7 +66,9 @@ class _CreateGroupViewState extends State<CreateGroupView> {
             Expanded(
               child: PlayerSelection(
                 onChanged: (value) {
+                  setState(() {
                     selectedPlayers = [...value];
+                  });
                 },
               ),
             ),
@@ -75,7 +77,8 @@ class _CreateGroupViewState extends State<CreateGroupView> {
               sizeRelativeToWidth: 0.95,
               buttonType: ButtonType.primary,
               onPressed:
-                  (_groupNameController.text.isEmpty || selectedPlayers.isEmpty)
+                  (_groupNameController.text.isEmpty ||
+                      (selectedPlayers.length < 2))
                   ? null
                   : () async {
                       bool success = await db.groupDao.addGroup(

lib/presentation/views/main_menu/group_view/groups_view.dart

@@ -0,0 +1,115 @@
+import 'package:flutter/material.dart';
+import 'package:game_tracker/core/constants.dart';
+import 'package:game_tracker/core/custom_theme.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/player.dart';
+import 'package:game_tracker/presentation/views/main_menu/group_view/create_group_view.dart';
+import 'package:game_tracker/presentation/widgets/app_skeleton.dart';
+import 'package:game_tracker/presentation/widgets/buttons/custom_width_button.dart';
+import 'package:game_tracker/presentation/widgets/tiles/group_tile.dart';
+import 'package:game_tracker/presentation/widgets/top_centered_message.dart';
+import 'package:provider/provider.dart';
+
+class GroupsView extends StatefulWidget {
+  const GroupsView({super.key});
+
+  @override
+  State<GroupsView> createState() => _GroupsViewState();
+}
+
+class _GroupsViewState extends State<GroupsView> {
+  late final AppDatabase db;
+  late List<Group> loadedGroups;
+  bool isLoading = true;
+
+  List<Group> groups = List.filled(
+    7,
+    Group(
+      name: 'Skeleton Group',
+      members: List.filled(6, Player(name: 'Skeleton Player')),
+    ),
+  );
+
+  @override
+  void initState() {
+    super.initState();
+    db = Provider.of<AppDatabase>(context, listen: false);
+    loadGroups();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      backgroundColor: CustomTheme.backgroundColor,
+      body: Stack(
+        alignment: Alignment.center,
+        children: [
+          AppSkeleton(
+            enabled: isLoading,
+            child: Visibility(
+              visible: groups.isNotEmpty,
+              replacement: const Center(
+                child: TopCenteredMessage(
+                  icon: Icons.info,
+                  title: 'Info',
+                  message: 'No groups created yet',
+                ),
+              ),
+              child: ListView.builder(
+                padding: const EdgeInsets.only(bottom: 85),
+                itemCount: groups.length + 1,
+                itemBuilder: (BuildContext context, int index) {
+                  if (index == groups.length) {
+                    return SizedBox(
+                      height: MediaQuery.paddingOf(context).bottom - 20,
+                    );
+                  }
+                  return GroupTile(group: groups[index]);
+                },
+              ),
+            ),
+          ),
+          Positioned(
+            bottom: MediaQuery.paddingOf(context).bottom,
+            child: CustomWidthButton(
+              text: 'Create Group',
+              sizeRelativeToWidth: 0.90,
+              onPressed: () async {
+                await Navigator.push(
+                  context,
+                  MaterialPageRoute(
+                    builder: (context) {
+                      return const CreateGroupView();
+                    },
+                  ),
+                );
+                setState(() {
+                  loadGroups();
+                });
+              },
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void loadGroups() {
+    Future.wait([
+      db.groupDao.getAllGroups(),
+      Future.delayed(minimumSkeletonDuration),
+    ]).then((results) {
+      loadedGroups = results[0] as List<Group>;
+      setState(() {
+        groups = loadedGroups
+          ..sort((a, b) => b.createdAt.compareTo(a.createdAt));
+      });
+      if (mounted) {
+        setState(() {
+          isLoading = false;
+        });
+      }
+    });
+  }
+}

lib/presentation/views/main_menu/groups_view.dart

@@ -1,119 +0,0 @@
-import 'package:flutter/material.dart';
-import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/group.dart';
-import 'package:game_tracker/data/dto/player.dart';
-import 'package:game_tracker/presentation/views/main_menu/create_group_view.dart';
-import 'package:game_tracker/presentation/widgets/app_skeleton.dart';
-import 'package:game_tracker/presentation/widgets/buttons/custom_width_button.dart';
-import 'package:game_tracker/presentation/widgets/tiles/group_tile.dart';
-import 'package:game_tracker/presentation/widgets/top_centered_message.dart';
-import 'package:provider/provider.dart';
-
-class GroupsView extends StatefulWidget {
-  const GroupsView({super.key});
-
-  @override
-  State<GroupsView> createState() => _GroupsViewState();
-}
-
-class _GroupsViewState extends State<GroupsView> {
-  late Future<List<Group>> _allGroupsFuture;
-  late final AppDatabase db;
-
-  final player = Player(name: 'Skeleton Player');
-  late final List<Group> skeletonData = List.filled(
-    7,
-    Group(
-      name: 'Skeleton Game',
-      members: [player, player, player, player, player, player],
-    ),
-  );
-
-  @override
-  void initState() {
-    super.initState();
-    db = Provider.of<AppDatabase>(context, listen: false);
-    _allGroupsFuture = Future.delayed(
-      const Duration(milliseconds: 250),
-      () => db.groupDao.getAllGroups(),
-    );
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return Scaffold(
-      backgroundColor: CustomTheme.backgroundColor,
-      body: Stack(
-        alignment: Alignment.center,
-        children: [
-          FutureBuilder<List<Group>>(
-            future: _allGroupsFuture,
-            builder:
-                (BuildContext context, AsyncSnapshot<List<Group>> snapshot) {
-                  if (snapshot.hasError) {
-                    return const Center(
-                      child: TopCenteredMessage(
-                        icon: Icons.report,
-                        title: 'Error',
-                        message: 'Group data couldn\'t\nbe loaded',
-                      ),
-                    );
-                  }
-                  if (snapshot.connectionState == ConnectionState.done &&
-                      (!snapshot.hasData || snapshot.data!.isEmpty)) {
-                    return const Center(
-                      child: TopCenteredMessage(
-                        icon: Icons.info,
-                        title: 'Info',
-                        message: 'No groups created yet',
-                      ),
-                    );
-                  }
-                  final bool isLoading =
-                      snapshot.connectionState == ConnectionState.waiting;
-                  final List<Group> groups =
-                      isLoading ? skeletonData : (snapshot.data ?? [])
-                        ..sort((a, b) => b.createdAt.compareTo(a.createdAt));
-                  return AppSkeleton(
-                    enabled: isLoading,
-                    child: ListView.builder(
-                      padding: const EdgeInsets.only(bottom: 85),
-                      itemCount: groups.length + 1,
-                      itemBuilder: (BuildContext context, int index) {
-                        if (index == groups.length) {
-                          return SizedBox(
-                            height: MediaQuery.paddingOf(context).bottom - 20,
-                          );
-                        }
-                        return GroupTile(group: groups[index]);
-                      },
-                    ),
-                  );
-                },
-          ),
-          Positioned(
-            bottom: MediaQuery.paddingOf(context).bottom,
-            child: CustomWidthButton(
-              text: 'Create Group',
-              sizeRelativeToWidth: 0.90,
-              onPressed: () async {
-                await Navigator.push(
-                  context,
-                  MaterialPageRoute(
-                    builder: (context) {
-                      return const CreateGroupView();
-                    },
-                  ),
-                );
-                setState(() {
-                  _allGroupsFuture = db.groupDao.getAllGroups();
-                });
-              },
-            ),
-          ),
-        ],
-      ),
-    );
-  }
-}

lib/presentation/views/main_menu/home_view.dart

@@ -1,7 +1,8 @@
 import 'package:flutter/material.dart';
+import 'package:game_tracker/core/constants.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:game_tracker/presentation/widgets/app_skeleton.dart';
 import 'package:game_tracker/presentation/widgets/buttons/quick_create_button.dart';
@@ -18,15 +19,14 @@ class HomeView extends StatefulWidget {
 }
 
 class _HomeViewState extends State<HomeView> {
-  late Future<int> _gameCountFuture;
-  late Future<int> _groupCountFuture;
-  late Future<List<Game>> _recentGamesFuture;
   bool isLoading = true;
-
+  int matchCount = 0;
-  late final List<Game> skeletonData = List.filled(
+  int groupCount = 0;
+  List<Match> loadedRecentMatches = [];
+  List<Match> recentMatches = List.filled(
     2,
-    Game(
+    Match(
-      name: 'Skeleton Game',
+      name: 'Skeleton Match',
       group: Group(
         name: 'Skeleton Group',
         members: [
@@ -39,23 +39,34 @@ class _HomeViewState extends State<HomeView> {
   );
 
   @override
-  initState() {
+  void initState() {
     super.initState();
     final db = Provider.of<AppDatabase>(context, listen: false);
-    _gameCountFuture = db.gameDao.getGameCount();
+    Future.wait([
-    _groupCountFuture = db.groupDao.getGroupCount();
+      db.matchDao.getMatchCount(),
-    _recentGamesFuture = db.gameDao.getAllGames();
+      db.groupDao.getGroupCount(),
-
+      db.matchDao.getAllMatches(),
-    Future.wait([_gameCountFuture, _groupCountFuture, _recentGamesFuture]).then(
+      Future.delayed(minimumSkeletonDuration),
-      (_) async {
+    ]).then((results) {
-        await Future.delayed(const Duration(milliseconds: 250));
+      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)))
+              .take(2)
+              .toList();
+      if (loadedRecentMatches.length < 2) {
+        recentMatches.add(
+          Match(name: 'Dummy Match', winner: null, group: null, players: null),
+        );
+      }
       if (mounted) {
         setState(() {
           isLoading = false;
         });
       }
-      },
+    });
-    );
   }
 
   @override
@@ -63,6 +74,7 @@ class _HomeViewState extends State<HomeView> {
     return LayoutBuilder(
       builder: (BuildContext context, BoxConstraints constraints) {
         return AppSkeleton(
+          fixLayoutBuilder: true,
           enabled: isLoading,
           child: SingleChildScrollView(
             child: Column(
@@ -71,38 +83,20 @@ class _HomeViewState extends State<HomeView> {
                 Row(
                   mainAxisAlignment: MainAxisAlignment.center,
                   children: [
-                    FutureBuilder<int>(
+                    QuickInfoTile(
-                      future: _gameCountFuture,
-                      builder: (context, snapshot) {
-                        final int count = (snapshot.hasData)
-                            ? snapshot.data!
-                            : 0;
-                        return QuickInfoTile(
                       width: constraints.maxWidth * 0.45,
                       height: constraints.maxHeight * 0.15,
-                          title: 'Games',
+                      title: 'Matches',
                       icon: Icons.groups_rounded,
-                          value: count,
+                      value: matchCount,
-                        );
-                      },
                     ),
                     SizedBox(width: constraints.maxWidth * 0.05),
-                    FutureBuilder<int>(
+                    QuickInfoTile(
-                      future: _groupCountFuture,
-                      builder: (context, snapshot) {
-                        final int count =
-                            (snapshot.connectionState == ConnectionState.done &&
-                                snapshot.hasData)
-                            ? snapshot.data!
-                            : 0;
-                        return QuickInfoTile(
                       width: constraints.maxWidth * 0.45,
                       height: constraints.maxHeight * 0.15,
                       title: 'Groups',
                       icon: Icons.groups_rounded,
-                          value: count,
+                      value: groupCount,
-                        );
-                      },
                     ),
                   ],
                 ),
@@ -110,84 +104,52 @@ class _HomeViewState extends State<HomeView> {
                   padding: const EdgeInsets.symmetric(vertical: 16.0),
                   child: InfoTile(
                     width: constraints.maxWidth * 0.95,
-                    title: 'Recent Games',
+                    title: 'Recent Matches',
                     icon: Icons.timer,
                     content: Padding(
                       padding: const EdgeInsets.symmetric(horizontal: 40.0),
-                      child: FutureBuilder(
+                      child: Visibility(
-                        future: _recentGamesFuture,
+                        visible: !isLoading && loadedRecentMatches.isNotEmpty,
-                        builder:
+                        replacement: const Center(
-                            (
+                          heightFactor: 12,
-                              BuildContext context,
+                          child: Text('No recent games available'),
-                              AsyncSnapshot<List<Game>> snapshot,
-                            ) {
-                              if (snapshot.hasError) {
-                                return const Center(
-                                  heightFactor: 4,
-                                  child: Text(
-                                    'Error while loading recent games.',
                         ),
-                                );
+                        child: Column(
-                              }
-                              final List<Game> games =
-                                  (isLoading
-                                            ? skeletonData
-                                            : (snapshot.data ?? [])
-                                        ..sort(
-                                          (a, b) => b.createdAt.compareTo(
-                                            a.createdAt,
-                                          ),
-                                        ))
-                                      .take(2)
-                                      .toList();
-                              if (games.isNotEmpty) {
-                                return Column(
                           mainAxisAlignment: MainAxisAlignment.start,
                           crossAxisAlignment: CrossAxisAlignment.start,
                           children: [
-                                    GameTile(
+                            MatchTile(
-                                      gameTitle: games[0].name,
+                              matchTitle: recentMatches[0].name,
-                                      gameType: 'Winner',
+                              game: 'Winner',
                               ruleset: 'Ruleset',
-                                      players: _getPlayerText(games[0]),
+                              players: _getPlayerText(recentMatches[0]),
-                                      winner: games[0].winner == null
+                              winner: recentMatches[0].winner == null
-                                          ? 'Game in progress...'
+                                  ? 'Match in progress...'
-                                          : games[0].winner!.name,
+                                  : recentMatches[0].winner!.name,
                             ),
                             const Padding(
-                                      padding: EdgeInsets.symmetric(
+                              padding: EdgeInsets.symmetric(vertical: 8.0),
-                                        vertical: 8.0,
-                                      ),
                               child: Divider(),
                             ),
-                                    if (games.length > 1) ...[
+                            if (loadedRecentMatches.length > 1) ...[
-                                      GameTile(
+                              MatchTile(
-                                        gameTitle: games[1].name,
+                                matchTitle: recentMatches[1].name,
-                                        gameType: 'Winner',
+                                game: 'Winner',
                                 ruleset: 'Ruleset',
-                                        players: _getPlayerText(games[1]),
+                                players: _getPlayerText(recentMatches[1]),
-                                        winner: games[1].winner == null
+                                winner: recentMatches[1].winner == null
                                     ? 'Game in progress...'
-                                            : games[1].winner!.name,
+                                    : recentMatches[1].winner!.name,
                               ),
                               const SizedBox(height: 8),
                             ] else ...[
                               const Center(
-                                        heightFactor: 4,
+                                heightFactor: 5.35,
-                                        child: Text(
+                                child: Text('No second game available'),
-                                          'No second game available.',
-                                        ),
                               ),
                             ],
                           ],
-                                );
+                        ),
-                              } else {
-                                return const Center(
-                                  heightFactor: 12,
-                                  child: Text('No recent games available.'),
-                                );
-                              }
-                            },
                       ),
                     ),
                   ),
@@ -197,7 +159,6 @@ class _HomeViewState extends State<HomeView> {
                   title: 'Quick Create',
                   icon: Icons.add_box_rounded,
                   content: Column(
-                    spacing: 8,
                     children: [
                       Row(
                         mainAxisAlignment: MainAxisAlignment.spaceEvenly,
@@ -249,7 +210,7 @@ class _HomeViewState extends State<HomeView> {
     );
   }
 
-  String _getPlayerText(Game game) {
+  String _getPlayerText(Match game) {
     if (game.group == null) {
       final playerCount = game.players?.length ?? 0;
       return '$playerCount Players';

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

@@ -0,0 +1,86 @@
+import 'package:flutter/material.dart';
+import 'package:game_tracker/core/custom_theme.dart';
+import 'package:game_tracker/core/enums.dart';
+import 'package:game_tracker/presentation/widgets/text_input/custom_search_bar.dart';
+import 'package:game_tracker/presentation/widgets/tiles/title_description_list_tile.dart';
+
+class ChooseGameView extends StatefulWidget {
+  final List<(String, String, Ruleset)> games;
+  final int initialGameIndex;
+
+  const ChooseGameView({
+    super.key,
+    required this.games,
+    required this.initialGameIndex,
+  });
+
+  @override
+  State<ChooseGameView> createState() => _ChooseGameViewState();
+}
+
+class _ChooseGameViewState extends State<ChooseGameView> {
+  late int selectedGameIndex;
+  final TextEditingController searchBarController = TextEditingController();
+
+  @override
+  void initState() {
+    selectedGameIndex = widget.initialGameIndex;
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      backgroundColor: CustomTheme.backgroundColor,
+      appBar: AppBar(
+        backgroundColor: CustomTheme.backgroundColor,
+        scrolledUnderElevation: 0,
+        leading: IconButton(
+          icon: const Icon(Icons.arrow_back_ios),
+          onPressed: () {
+            Navigator.of(context).pop(selectedGameIndex);
+          },
+        ),
+        title: const Text(
+          'Choose Game',
+          style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
+        ),
+        centerTitle: true,
+      ),
+      body: Column(
+        children: [
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 10),
+            child: CustomSearchBar(
+              controller: searchBarController,
+              hintText: 'Game Name',
+            ),
+          ),
+          const SizedBox(height: 5),
+          Expanded(
+            child: ListView.builder(
+              itemCount: widget.games.length,
+              itemBuilder: (BuildContext context, int index) {
+                return TitleDescriptionListTile(
+                  title: widget.games[index].$1,
+                  description: widget.games[index].$2,
+                  badgeText: translateRulesetToString(widget.games[index].$3),
+                  isHighlighted: selectedGameIndex == index,
+                  onPressed: () async {
+                    setState(() {
+                      if (selectedGameIndex == index) {
+                        selectedGameIndex = -1;
+                      } else {
+                        selectedGameIndex = index;
+                      }
+                    });
+                  },
+                );
+              },
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

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

@@ -0,0 +1,136 @@
+import 'package:flutter/material.dart';
+import 'package:game_tracker/core/custom_theme.dart';
+import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/presentation/widgets/text_input/custom_search_bar.dart';
+import 'package:game_tracker/presentation/widgets/tiles/group_tile.dart';
+import 'package:game_tracker/presentation/widgets/top_centered_message.dart';
+
+class ChooseGroupView extends StatefulWidget {
+  final List<Group> groups;
+  final String initialGroupId;
+
+  const ChooseGroupView({
+    super.key,
+    required this.groups,
+    required this.initialGroupId,
+  });
+
+  @override
+  State<ChooseGroupView> createState() => _ChooseGroupViewState();
+}
+
+class _ChooseGroupViewState extends State<ChooseGroupView> {
+  late String selectedGroupId;
+  final TextEditingController controller = TextEditingController();
+  final String hintText = 'Group Name';
+  late final List<Group> filteredGroups;
+
+  @override
+  void initState() {
+    selectedGroupId = widget.initialGroupId;
+    filteredGroups = [...widget.groups];
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      backgroundColor: CustomTheme.backgroundColor,
+      appBar: AppBar(
+        backgroundColor: CustomTheme.backgroundColor,
+        scrolledUnderElevation: 0,
+        leading: IconButton(
+          icon: const Icon(Icons.arrow_back_ios),
+          onPressed: () {
+            Navigator.of(context).pop(
+              selectedGroupId == ''
+                  ? null
+                  : widget.groups.firstWhere(
+                      (group) => group.id == selectedGroupId,
+                    ),
+            );
+          },
+        ),
+        title: const Text(
+          'Choose Group',
+          style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
+        ),
+        centerTitle: true,
+      ),
+      body: Column(
+        children: [
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 10),
+            child: CustomSearchBar(
+              controller: controller,
+              hintText: hintText,
+              onChanged: (value) {
+                setState(() {
+                  filterGroups(value);
+                });
+              },
+            ),
+          ),
+          Expanded(
+            child: Visibility(
+              visible: filteredGroups.isNotEmpty,
+              replacement: Visibility(
+                visible: widget.groups.isNotEmpty,
+                replacement: const TopCenteredMessage(
+                  icon: Icons.info,
+                  title: 'Info',
+                  message: 'You have no groups created yet',
+                ),
+                child: const TopCenteredMessage(
+                  icon: Icons.info,
+                  title: 'Info',
+                  message: 'There is no group matching your search',
+                ),
+              ),
+              child: ListView.builder(
+                padding: const EdgeInsets.only(bottom: 85),
+                itemCount: filteredGroups.length,
+                itemBuilder: (BuildContext context, int index) {
+                  return GestureDetector(
+                    onTap: () {
+                      setState(() {
+                        if (selectedGroupId != filteredGroups[index].id) {
+                          selectedGroupId = filteredGroups[index].id;
+                        } else {
+                          selectedGroupId = '';
+                        }
+                      });
+                    },
+                    child: GroupTile(
+                      group: filteredGroups[index],
+                      isHighlighted:
+                          selectedGroupId == filteredGroups[index].id,
+                    ),
+                  );
+                },
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  /// Filters the groups based on the search query.
+  /// TODO: Maybe implement also targetting player names?
+  void filterGroups(String query) {
+    setState(() {
+      if (query.isEmpty) {
+        filteredGroups.clear();
+        filteredGroups.addAll(widget.groups);
+      } else {
+        filteredGroups.clear();
+        filteredGroups.addAll(
+          widget.groups.where(
+            (group) => group.name.toLowerCase().contains(query.toLowerCase()),
+          ),
+        );
+      }
+    });
+  }
+}

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

@@ -0,0 +1,78 @@
+import 'package:flutter/material.dart';
+import 'package:game_tracker/core/custom_theme.dart';
+import 'package:game_tracker/core/enums.dart';
+import 'package:game_tracker/presentation/widgets/tiles/title_description_list_tile.dart';
+
+class ChooseRulesetView extends StatefulWidget {
+  final List<(Ruleset, String)> rulesets;
+  final int initialRulesetIndex;
+
+  const ChooseRulesetView({
+    super.key,
+    required this.rulesets,
+    required this.initialRulesetIndex,
+  });
+
+  @override
+  State<ChooseRulesetView> createState() => _ChooseRulesetViewState();
+}
+
+class _ChooseRulesetViewState extends State<ChooseRulesetView> {
+  late int selectedRulesetIndex;
+
+  @override
+  void initState() {
+    selectedRulesetIndex = widget.initialRulesetIndex;
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return DefaultTabController(
+      length: 2,
+      initialIndex: 0,
+      child: Scaffold(
+        backgroundColor: CustomTheme.backgroundColor,
+        appBar: AppBar(
+          backgroundColor: CustomTheme.backgroundColor,
+          scrolledUnderElevation: 0,
+          leading: IconButton(
+            icon: const Icon(Icons.arrow_back_ios),
+            onPressed: () {
+              Navigator.of(context).pop(
+                selectedRulesetIndex == -1
+                    ? null
+                    : widget.rulesets[selectedRulesetIndex].$1,
+              );
+            },
+          ),
+          title: const Text(
+            'Choose Ruleset',
+            style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
+          ),
+          centerTitle: true,
+        ),
+        body: ListView.builder(
+          padding: const EdgeInsets.only(bottom: 85),
+          itemCount: widget.rulesets.length,
+          itemBuilder: (BuildContext context, int index) {
+            return TitleDescriptionListTile(
+              onPressed: () async {
+                setState(() {
+                  if (selectedRulesetIndex == index) {
+                    selectedRulesetIndex = -1;
+                  } else {
+                    selectedRulesetIndex = index;
+                  }
+                });
+              },
+              title: translateRulesetToString(widget.rulesets[index].$1),
+              description: widget.rulesets[index].$2,
+              isHighlighted: selectedRulesetIndex == index,
+            );
+          },
+        ),
+      ),
+    );
+  }
+}

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

@@ -1,35 +1,33 @@
+import 'package:flutter/cupertino.dart';
 import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/core/enums.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
-import 'package:game_tracker/presentation/views/main_menu/create_game/choose_group_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/choose_game_view.dart';
-import 'package:game_tracker/presentation/views/main_menu/create_game/choose_ruleset_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/choose_group_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/choose_ruleset_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/match_result_view.dart';
 import 'package:game_tracker/presentation/widgets/buttons/custom_width_button.dart';
 import 'package:game_tracker/presentation/widgets/player_selection.dart';
 import 'package:game_tracker/presentation/widgets/text_input/text_input_field.dart';
 import 'package:game_tracker/presentation/widgets/tiles/choose_tile.dart';
 import 'package:provider/provider.dart';
 
-class CreateGameView extends StatefulWidget {
+class CreateMatchView extends StatefulWidget {
-  const CreateGameView({super.key});
+  final VoidCallback? onWinnerChanged;
+  const CreateMatchView({super.key, this.onWinnerChanged});
 
   @override
-  State<CreateGameView> createState() => _CreateGameViewState();
+  State<CreateMatchView> createState() => _CreateMatchViewState();
 }
 
-class _CreateGameViewState extends State<CreateGameView> {
+class _CreateMatchViewState extends State<CreateMatchView> {
   /// Reference to the app database
   late final AppDatabase db;
 
-  /// Futures to load all groups and players from the database
-  late Future<List<Group>> _allGroupsFuture;
-
-  /// Future to load all players from the database
-  late Future<List<Player>> _allPlayersFuture;
-
   /// Controller for the game name input field
   final TextEditingController _gameNameController = TextEditingController();
 
@@ -39,12 +37,18 @@ class _CreateGameViewState extends State<CreateGameView> {
   /// List of all players from the database
   List<Player> playerList = [];
 
+  /// List of players filtered based on the selected group
+  /// If a group is selected, this list contains all players from [playerList]
+  /// who are not members of the selected group. If no group is selected,
+  /// this list is identical to [playerList].
+  List<Player> filteredPlayerList = [];
+
   /// The currently selected group
   Group? selectedGroup;
 
   /// The index of the currently selected group in [groupsList] to mark it in
   /// the [ChooseGroupView]
-  int selectedGroupIndex = -1;
+  String selectedGroupId = '';
 
   /// The currently selected ruleset
   Ruleset? selectedRuleset;
@@ -53,46 +57,58 @@ class _CreateGameViewState extends State<CreateGameView> {
   /// the [ChooseRulesetView]
   int selectedRulesetIndex = -1;
 
+  /// The index of the currently selected game in [games] to mark it in
+  /// the [ChooseGameView]
+  int selectedGameIndex = -1;
+
   /// The currently selected players
   List<Player>? selectedPlayers;
 
-  /// List of available rulesets with their display names and descriptions
+  /// List of available rulesets with their descriptions
-  /// as tuples of (Ruleset, String, String)
+  /// as tuples of (Ruleset, String)
-  List<(Ruleset, String, String)> rulesets = [
+  /// TODO: Replace when rulesets are implemented
+  List<(Ruleset, String)> rulesets = [
     (
       Ruleset.singleWinner,
-      'Single Winner',
       'Exactly one winner is chosen; ties are resolved by a predefined tiebreaker.',
     ),
     (
       Ruleset.singleLoser,
-      'Single Loser',
       'Exactly one loser is determined; last place receives the penalty or consequence.',
     ),
     (
       Ruleset.mostPoints,
-      'Most Points',
       'Traditional ruleset: the player with the most points wins.',
     ),
     (
-      Ruleset.lastPoints,
+      Ruleset.leastPoints,
-      'Least Points',
       'Inverse scoring: the player with the fewest points wins.',
     ),
   ];
 
+  // TODO: Replace when games are implemented
+  List<(String, String, Ruleset)> games = [
+    ('Example Game 1', 'This is a discription', Ruleset.leastPoints),
+    ('Example Game 2', '', Ruleset.singleWinner),
+  ];
+
   @override
   void initState() {
     super.initState();
+    _gameNameController.addListener(() {
+      setState(() {});
+    });
+
     db = Provider.of<AppDatabase>(context, listen: false);
 
-    _allGroupsFuture = db.groupDao.getAllGroups();
+    Future.wait([
-    _allPlayersFuture = db.playerDao.getAllPlayers();
+      db.groupDao.getAllGroups(),
-
+      db.playerDao.getAllPlayers(),
-    Future.wait([_allGroupsFuture, _allPlayersFuture]).then((result) async {
+    ]).then((result) async {
       groupsList = result[0] as List<Group>;
       playerList = result[1] as List<Player>;
     });
+    filteredPlayerList = List.from(playerList);
   }
 
   @override
@@ -113,15 +129,38 @@ class _CreateGameViewState extends State<CreateGameView> {
           mainAxisAlignment: MainAxisAlignment.start,
           children: [
             Container(
-              margin: const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
+              margin: const EdgeInsets.symmetric(horizontal: 12, vertical: 5),
               child: TextInputField(
                 controller: _gameNameController,
                 hintText: 'Game name',
-                onChanged: (value) {
-                  setState(() {});
-                },
               ),
             ),
+            ChooseTile(
+              title: 'Game',
+              trailingText: selectedGameIndex == -1
+                  ? 'None'
+                  : games[selectedGameIndex].$1,
+              onPressed: () async {
+                selectedGameIndex = await Navigator.of(context).push(
+                  MaterialPageRoute(
+                    builder: (context) => ChooseGameView(
+                      games: games,
+                      initialGameIndex: selectedGameIndex,
+                    ),
+                  ),
+                );
+                setState(() {
+                  if (selectedGameIndex != -1) {
+                    selectedRuleset = games[selectedGameIndex].$3;
+                    selectedRulesetIndex = rulesets.indexWhere(
+                      (r) => r.$1 == selectedRuleset,
+                    );
+                  } else {
+                    selectedRuleset = null;
+                  }
+                });
+              },
+            ),
             ChooseTile(
               title: 'Ruleset',
               trailingText: selectedRuleset == null
@@ -139,6 +178,7 @@ class _CreateGameViewState extends State<CreateGameView> {
                 selectedRulesetIndex = rulesets.indexWhere(
                   (r) => r.$1 == selectedRuleset,
                 );
+                selectedGameIndex = -1;
                 setState(() {});
               },
             ),
@@ -152,28 +192,28 @@ class _CreateGameViewState extends State<CreateGameView> {
                   MaterialPageRoute(
                     builder: (context) => ChooseGroupView(
                       groups: groupsList,
-                      initialGroupIndex: selectedGroupIndex,
+                      initialGroupId: selectedGroupId,
                     ),
                   ),
                 );
-                selectedGroupIndex = groupsList.indexWhere(
+                selectedGroupId = selectedGroup?.id ?? '';
-                  (g) => g.id == selectedGroup?.id,
+                if (selectedGroup != null) {
-                );
+                  filteredPlayerList = playerList
+                      .where(
+                        (p) => !selectedGroup!.members.any((m) => m.id == p.id),
+                      )
+                      .toList();
+                } else {
+                  filteredPlayerList = List.from(playerList);
+                }
                 setState(() {});
               },
             ),
             Expanded(
               child: PlayerSelection(
                 key: ValueKey(selectedGroup?.id ?? 'no_group'),
-                initialPlayers: selectedGroup == null
+                initialSelectedPlayers: selectedPlayers ?? [],
-                    ? playerList
+                availablePlayers: filteredPlayerList,
-                    : playerList
-                          .where(
-                            (p) => !selectedGroup!.members.any(
-                              (m) => m.id == p.id,
-                            ),
-                          )
-                          .toList(),
                 onChanged: (value) {
                   setState(() {
                     selectedPlayers = value;
@@ -181,52 +221,46 @@ class _CreateGameViewState extends State<CreateGameView> {
                 },
               ),
             ),
-
             CustomWidthButton(
               text: 'Create game',
               sizeRelativeToWidth: 0.95,
               buttonType: ButtonType.primary,
               onPressed: _enableCreateGameButton()
                   ? () async {
-                      Game game = Game(
+                      Match match = Match(
                         name: _gameNameController.text.trim(),
                         createdAt: DateTime.now(),
-                        group: selectedGroup!,
+                        group: selectedGroup,
                         players: selectedPlayers,
                       );
-                      // TODO: Replace with navigation to GameResultView()
+                      await db.matchDao.addMatch(match: match);
-                      print('Created game: $game');
+                      if (context.mounted) {
-                      Navigator.pop(context);
+                        Navigator.pushReplacement(
+                          context,
+                          CupertinoPageRoute(
+                            fullscreenDialog: true,
+                            builder: (context) => GameResultView(
+                              match: match,
+                              onWinnerChanged: widget.onWinnerChanged,
+                            ),
+                          ),
+                        );
+                      }
                     }
                   : null,
             ),
-            const SizedBox(height: 20),
           ],
         ),
       ),
     );
   }
 
-  /// Translates a [Ruleset] enum value to its corresponding string representation.
-  String translateRulesetToString(Ruleset ruleset) {
-    switch (ruleset) {
-      case Ruleset.singleWinner:
-        return 'Single Winner';
-      case Ruleset.singleLoser:
-        return 'Single Loser';
-      case Ruleset.mostPoints:
-        return 'Most Points';
-      case Ruleset.lastPoints:
-        return 'Least Points';
-    }
-  }
-
   /// Determines whether the "Create Game" button should be enabled based on
   /// the current state of the input fields.
   bool _enableCreateGameButton() {
     return _gameNameController.text.isNotEmpty &&
         (selectedGroup != null ||
-            (selectedPlayers != null && selectedPlayers!.isNotEmpty)) &&
+            (selectedPlayers != null && selectedPlayers!.length > 1)) &&
         selectedRuleset != null;
   }
 }

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

@@ -1,16 +1,17 @@
 import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:game_tracker/presentation/widgets/tiles/custom_radio_list_tile.dart';
 import 'package:provider/provider.dart';
 
 class GameResultView extends StatefulWidget {
-  final Game game;
+  final Match match;
 
-  const GameResultView({super.key, required this.game});
+  final VoidCallback? onWinnerChanged;
 
+  const GameResultView({super.key, required this.match, this.onWinnerChanged});
   @override
   State<GameResultView> createState() => _GameResultViewState();
 }
@@ -23,10 +24,10 @@ class _GameResultViewState extends State<GameResultView> {
   @override
   void initState() {
     db = Provider.of<AppDatabase>(context, listen: false);
-    allPlayers = getAllPlayers(widget.game);
+    allPlayers = getAllPlayers(widget.match);
-    if (widget.game.winner != null) {
+    if (widget.match.winner != null) {
       _selectedPlayer = allPlayers.firstWhere(
-        (p) => p.id == widget.game.winner!.id,
+        (p) => p.id == widget.match.winner!.id,
       );
     }
     super.initState();
@@ -37,10 +38,17 @@ class _GameResultViewState extends State<GameResultView> {
     return Scaffold(
       backgroundColor: CustomTheme.backgroundColor,
       appBar: AppBar(
+        leading: IconButton(
+          icon: const Icon(Icons.close),
+          onPressed: () {
+            widget.onWinnerChanged?.call();
+            Navigator.of(context).pop();
+          },
+        ),
         backgroundColor: CustomTheme.backgroundColor,
         scrolledUnderElevation: 0,
         title: Text(
-          widget.game.name,
+          widget.match.name,
           style: const TextStyle(
             fontSize: 20,
             fontWeight: FontWeight.bold,
@@ -124,16 +132,17 @@ class _GameResultViewState extends State<GameResultView> {
 
   Future<void> _handleWinnerSaving() async {
     if (_selectedPlayer == null) {
-      await db.gameDao.removeWinner(gameId: widget.game.id);
+      await db.matchDao.removeWinner(matchId: widget.match.id);
     } else {
-      await db.gameDao.setWinner(
+      await db.matchDao.setWinner(
-        gameId: widget.game.id,
+        matchId: widget.match.id,
         winnerId: _selectedPlayer!.id,
       );
     }
+    widget.onWinnerChanged?.call();
   }
 
-  List<Player> getAllPlayers(Game game) {
+  List<Player> getAllPlayers(Match game) {
     if (game.group == null && game.players != null) {
       return [...game.players!];
     } else if (game.group != null && game.players != null) {

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

@@ -0,0 +1,132 @@
+import 'dart:core' hide Match;
+
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
+import 'package:game_tracker/core/constants.dart';
+import 'package:game_tracker/core/custom_theme.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
+import 'package:game_tracker/data/dto/player.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/create_match_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/match_result_view.dart';
+import 'package:game_tracker/presentation/widgets/app_skeleton.dart';
+import 'package:game_tracker/presentation/widgets/buttons/custom_width_button.dart';
+import 'package:game_tracker/presentation/widgets/tiles/game_history_tile.dart';
+import 'package:game_tracker/presentation/widgets/top_centered_message.dart';
+import 'package:provider/provider.dart';
+
+class MatchView extends StatefulWidget {
+  const MatchView({super.key});
+
+  @override
+  State<MatchView> createState() => _MatchViewState();
+}
+
+class _MatchViewState extends State<MatchView> {
+  late final AppDatabase db;
+  bool isLoading = true;
+
+  List<Match> matches = List.filled(
+    4,
+    Match(
+      name: 'Skeleton Gamename',
+      group: Group(
+        name: 'Groupname',
+        members: List.filled(5, Player(name: 'Player')),
+      ),
+      winner: Player(name: 'Player'),
+      players: [Player(name: 'Player')],
+    ),
+  );
+
+  @override
+  void initState() {
+    super.initState();
+    db = Provider.of<AppDatabase>(context, listen: false);
+    loadGames();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      backgroundColor: CustomTheme.backgroundColor,
+      body: Stack(
+        alignment: Alignment.center,
+        children: [
+          AppSkeleton(
+            enabled: isLoading,
+            child: Visibility(
+              visible: matches.isNotEmpty,
+              replacement: const Center(
+                child: TopCenteredMessage(
+                  icon: Icons.report,
+                  title: 'Info',
+                  message: 'No games created yet',
+                ),
+              ),
+              child: ListView.builder(
+                padding: const EdgeInsets.only(bottom: 85),
+                itemCount: matches.length + 1,
+                itemBuilder: (BuildContext context, int index) {
+                  if (index == matches.length) {
+                    return SizedBox(
+                      height: MediaQuery.paddingOf(context).bottom - 80,
+                    );
+                  }
+                  return GameHistoryTile(
+                    onTap: () async {
+                      Navigator.push(
+                        context,
+                        CupertinoPageRoute(
+                          fullscreenDialog: true,
+                          builder: (context) => GameResultView(
+                            match: matches[index],
+                            onWinnerChanged: loadGames,
+                          ),
+                        ),
+                      );
+                    },
+                    match: matches[index],
+                  );
+                },
+              ),
+            ),
+          ),
+          Positioned(
+            bottom: MediaQuery.paddingOf(context).bottom,
+            child: CustomWidthButton(
+              text: 'Create Game',
+              sizeRelativeToWidth: 0.90,
+              onPressed: () async {
+                Navigator.push(
+                  context,
+                  MaterialPageRoute(
+                    builder: (context) =>
+                        CreateMatchView(onWinnerChanged: loadGames),
+                  ),
+                );
+              },
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void loadGames() {
+    Future.wait([
+      db.matchDao.getAllMatches(),
+      Future.delayed(minimumSkeletonDuration),
+    ]).then((results) {
+      if (mounted) {
+        setState(() {
+          final loadedMatches = results[0] as List<Match>;
+          matches = loadedMatches
+            ..sort((a, b) => b.createdAt.compareTo(a.createdAt));
+          isLoading = false;
+        });
+      }
+    });
+  }
+}

lib/presentation/views/main_menu/statistics_view.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/material.dart';
+import 'package:game_tracker/core/constants.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:game_tracker/presentation/widgets/app_skeleton.dart';
 import 'package:game_tracker/presentation/widgets/tiles/statistics_tile.dart';
@@ -14,10 +15,8 @@ class StatisticsView extends StatefulWidget {
 }
 
 class _StatisticsViewState extends State<StatisticsView> {
-  late Future<List<Game>> _gamesFuture;
-  late Future<List<Player>> _playersFuture;
   List<(String, int)> winCounts = List.filled(6, ('Skeleton Player', 1));
-  List<(String, int)> gameCounts = List.filled(6, ('Skeleton Player', 1));
+  List<(String, int)> matchCounts = List.filled(6, ('Skeleton Player', 1));
   List<(String, double)> winRates = List.filled(6, ('Skeleton Player', 1));
   bool isLoading = true;
 
@@ -25,16 +24,17 @@ class _StatisticsViewState extends State<StatisticsView> {
   void initState() {
     super.initState();
     final db = Provider.of<AppDatabase>(context, listen: false);
-    _gamesFuture = db.gameDao.getAllGames();
-    _playersFuture = db.playerDao.getAllPlayers();
 
-    Future.wait([_gamesFuture, _playersFuture]).then((results) async {
+    Future.wait([
-      await Future.delayed(const Duration(milliseconds: 250));
+      db.matchDao.getAllMatches(),
-      final games = results[0] as List<Game>;
+      db.playerDao.getAllPlayers(),
+      Future.delayed(minimumSkeletonDuration),
+    ]).then((results) async {
+      final matches = results[0] as List<Match>;
       final players = results[1] as List<Player>;
-      winCounts = _calculateWinsForAllPlayers(games, players);
+      winCounts = _calculateWinsForAllPlayers(matches, players);
-      gameCounts = _calculateGameAmountsForAllPlayers(games, players);
+      matchCounts = _calculateMatchAmountsForAllPlayers(matches, players);
-      winRates = computeWinRatePercent(wins: winCounts, games: gameCounts);
+      winRates = computeWinRatePercent(wins: winCounts, matches: matchCounts);
       if (mounted) {
         setState(() {
           isLoading = false;
@@ -60,7 +60,7 @@ class _StatisticsViewState extends State<StatisticsView> {
                   SizedBox(height: constraints.maxHeight * 0.01),
                   StatisticsTile(
                     icon: Icons.sports_score,
-                    title: 'Wins per Player',
+                    title: 'Wins',
                     width: constraints.maxWidth * 0.95,
                     values: winCounts,
                     itemCount: 3,
@@ -69,7 +69,7 @@ class _StatisticsViewState extends State<StatisticsView> {
                   SizedBox(height: constraints.maxHeight * 0.02),
                   StatisticsTile(
                     icon: Icons.percent,
-                    title: 'Winrate per Player',
+                    title: 'Winrate',
                     width: constraints.maxWidth * 0.95,
                     values: winRates,
                     itemCount: 5,
@@ -78,9 +78,9 @@ class _StatisticsViewState extends State<StatisticsView> {
                   SizedBox(height: constraints.maxHeight * 0.02),
                   StatisticsTile(
                     icon: Icons.casino,
-                    title: 'Games per Player',
+                    title: 'Amount of Matches',
                     width: constraints.maxWidth * 0.95,
-                    values: gameCounts,
+                    values: matchCounts,
                     itemCount: 10,
                     barColor: Colors.green,
                   ),
@@ -97,14 +97,14 @@ class _StatisticsViewState extends State<StatisticsView> {
   /// Calculates the number of wins for each player
   /// and returns a sorted list of tuples (playerName, winCount)
   List<(String, int)> _calculateWinsForAllPlayers(
-    List<Game> games,
+    List<Match> matches,
     List<Player> players,
   ) {
     List<(String, int)> winCounts = [];
 
     // Getting the winners
-    for (var game in games) {
+    for (var match in matches) {
-      final winner = game.winner;
+      final winner = match.winner;
       if (winner != null) {
         final index = winCounts.indexWhere((entry) => entry.$1 == winner.id);
         // -1 means winner not found in winCounts
@@ -141,83 +141,83 @@ class _StatisticsViewState extends State<StatisticsView> {
     return winCounts;
   }
 
-  /// Calculates the number of games played for each player
+  /// Calculates the number of matches played for each player
-  /// and returns a sorted list of tuples (playerName, gameCount)
+  /// and returns a sorted list of tuples (playerName, matchCount)
-  List<(String, int)> _calculateGameAmountsForAllPlayers(
+  List<(String, int)> _calculateMatchAmountsForAllPlayers(
-    List<Game> games,
+    List<Match> matches,
     List<Player> players,
   ) {
-    List<(String, int)> gameCounts = [];
+    List<(String, int)> matchCounts = [];
 
-    // Counting games for each player
+    // Counting matches for each player
-    for (var game in games) {
+    for (var match in matches) {
-      if (game.group != null) {
+      if (match.group != null) {
-        final members = game.group!.members.map((p) => p.id).toList();
+        final members = match.group!.members.map((p) => p.id).toList();
         for (var playerId in members) {
-          final index = gameCounts.indexWhere((entry) => entry.$1 == playerId);
+          final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
-          // -1 means player not found in gameCounts
+          // -1 means player not found in matchCounts
           if (index != -1) {
-            final current = gameCounts[index].$2;
+            final current = matchCounts[index].$2;
-            gameCounts[index] = (playerId, current + 1);
+            matchCounts[index] = (playerId, current + 1);
           } else {
-            gameCounts.add((playerId, 1));
+            matchCounts.add((playerId, 1));
           }
         }
       }
-      if (game.players != null) {
+      if (match.players != null) {
-        final members = game.players!.map((p) => p.id).toList();
+        final members = match.players!.map((p) => p.id).toList();
         for (var playerId in members) {
-          final index = gameCounts.indexWhere((entry) => entry.$1 == playerId);
+          final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
-          // -1 means player not found in gameCounts
+          // -1 means player not found in matchCounts
           if (index != -1) {
-            final current = gameCounts[index].$2;
+            final current = matchCounts[index].$2;
-            gameCounts[index] = (playerId, current + 1);
+            matchCounts[index] = (playerId, current + 1);
           } else {
-            gameCounts.add((playerId, 1));
+            matchCounts.add((playerId, 1));
           }
         }
       }
     }
 
-    // Adding all players with zero games
+    // Adding all players with zero matches
     for (var player in players) {
-      final index = gameCounts.indexWhere((entry) => entry.$1 == player.id);
+      final index = matchCounts.indexWhere((entry) => entry.$1 == player.id);
-      // -1 means player not found in gameCounts
+      // -1 means player not found in matchCounts
       if (index == -1) {
-        gameCounts.add((player.id, 0));
+        matchCounts.add((player.id, 0));
       }
     }
 
     // Replace player IDs with names
-    for (int i = 0; i < gameCounts.length; i++) {
+    for (int i = 0; i < matchCounts.length; i++) {
-      final playerId = gameCounts[i].$1;
+      final playerId = matchCounts[i].$1;
       final player = players.firstWhere(
         (p) => p.id == playerId,
         orElse: () => Player(id: playerId, name: 'N.a.'),
       );
-      gameCounts[i] = (player.name, gameCounts[i].$2);
+      matchCounts[i] = (player.name, matchCounts[i].$2);
     }
 
-    gameCounts.sort((a, b) => b.$2.compareTo(a.$2));
+    matchCounts.sort((a, b) => b.$2.compareTo(a.$2));
 
-    return gameCounts;
+    return matchCounts;
   }
 
   // dart
   List<(String, double)> computeWinRatePercent({
     required List<(String, int)> wins,
-    required List<(String, int)> games,
+    required List<(String, int)> matches,
   }) {
     final Map<String, int> winsMap = {for (var e in wins) e.$1: e.$2};
-    final Map<String, int> gamesMap = {for (var e in games) e.$1: e.$2};
+    final Map<String, int> matchesMap = {for (var e in matches) e.$1: e.$2};
 
     // Get all unique player names
-    final names = {...winsMap.keys, ...gamesMap.keys};
+    final names = {...winsMap.keys, ...matchesMap.keys};
 
     // Calculate win rates
     final result = names.map((name) {
       final int w = winsMap[name] ?? 0;
-      final int g = gamesMap[name] ?? 0;
+      final int g = matchesMap[name] ?? 0;
       // Calculate percentage and round to 2 decimal places
       // Avoid division by zero
       final double percent = (g > 0)

lib/presentation/widgets/player_selection.dart

@@ -1,4 +1,5 @@
 import 'package:flutter/material.dart';
+import 'package:game_tracker/core/constants.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/data/db/database.dart';
 import 'package:game_tracker/data/dto/player.dart';
@@ -11,12 +12,14 @@ import 'package:provider/provider.dart';
 
 class PlayerSelection extends StatefulWidget {
   final Function(List<Player> value) onChanged;
-  final List<Player> initialPlayers;
+  final List<Player> availablePlayers;
+  final List<Player>? initialSelectedPlayers;
 
   const PlayerSelection({
     super.key,
     required this.onChanged,
-    this.initialPlayers = const [],
+    this.availablePlayers = const [],
+    this.initialSelectedPlayers,
   });
 
   @override
@@ -27,6 +30,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
   List<Player> selectedPlayers = [];
   List<Player> suggestedPlayers = [];
   List<Player> allPlayers = [];
+  bool isLoading = true;
   late final TextEditingController _searchBarController =
       TextEditingController();
   late final AppDatabase db;
@@ -40,28 +44,45 @@ class _PlayerSelectionState extends State<PlayerSelection> {
   void initState() {
     super.initState();
     db = Provider.of<AppDatabase>(context, listen: false);
+    suggestedPlayers = skeletonData;
     loadPlayerList();
   }
 
   void loadPlayerList() {
-    _allPlayersFuture = Future.delayed(
+    _allPlayersFuture = Future.wait([
-      const Duration(milliseconds: 250),
+      db.playerDao.getAllPlayers(),
-      () => db.playerDao.getAllPlayers(),
+      Future.delayed(minimumSkeletonDuration),
-    );
+    ]).then((results) => results[0] as List<Player>);
-    suggestedPlayers = skeletonData;
+    if (mounted) {
       _allPlayersFuture.then((loadedPlayers) {
         setState(() {
-        if (widget.initialPlayers.isNotEmpty) {
+          // If a list of available players is provided, use that list.
-          allPlayers = [...widget.initialPlayers];
+          if (widget.availablePlayers.isNotEmpty) {
-          suggestedPlayers = [...widget.initialPlayers];
+            widget.availablePlayers.sort((a, b) => a.name.compareTo(b.name));
+            allPlayers = [...widget.availablePlayers];
+            suggestedPlayers = [...allPlayers];
+
+            if (widget.initialSelectedPlayers != null) {
+              // Ensures that only players available for selection are pre-selected.
+              selectedPlayers = widget.initialSelectedPlayers!
+                  .where(
+                    (p) => widget.availablePlayers.any(
+                      (available) => available.id == p.id,
+                    ),
+                  )
+                  .toList();
+            }
           } else {
+            // Otherwise, use the loaded players from the database.
             loadedPlayers.sort((a, b) => a.name.compareTo(b.name));
             allPlayers = [...loadedPlayers];
             suggestedPlayers = [...loadedPlayers];
           }
+          isLoading = false;
         });
       });
     }
+  }
 
   @override
   Widget build(BuildContext context) {
@@ -112,76 +133,67 @@ class _PlayerSelectionState extends State<PlayerSelection> {
             style: const TextStyle(fontSize: 16, fontWeight: FontWeight.bold),
           ),
           const SizedBox(height: 10),
-          Wrap(
+          SizedBox(
-            alignment: WrapAlignment.start,
+            height: 50,
-            crossAxisAlignment: WrapCrossAlignment.start,
+            child: selectedPlayers.isEmpty
-            spacing: 8.0,
+                ? const Center(child: Text('No players selected'))
-            runSpacing: 8.0,
+                : SingleChildScrollView(
-            children: <Widget>[
+                    scrollDirection: Axis.horizontal,
-              // Generates a TextIconTile for each selected player.
+                    child: Row(
+                      children: [
                         for (var player in selectedPlayers)
-                TextIconTile(
+                          Padding(
+                            padding: const EdgeInsets.only(right: 8.0),
+                            child: TextIconTile(
                               text: player.name,
                               onIconTap: () {
                                 setState(() {
                                   // Removes the player from the selection and notifies the parent.
-                      final currentSearch = _searchBarController.text
+                                  final currentSearch = _searchBarController
+                                      .text
                                       .toLowerCase();
                                   selectedPlayers.remove(player);
                                   widget.onChanged([...selectedPlayers]);
                                   // If the player matches the current search query (or search is empty),
                                   // they are added back to the suggestions and the list is re-sorted.
                                   if (currentSearch.isEmpty ||
-                          player.name.toLowerCase().contains(currentSearch)) {
+                                      player.name.toLowerCase().contains(
+                                        currentSearch,
+                                      )) {
                                     suggestedPlayers.add(player);
                                   }
                                 });
                               },
                             ),
+                          ),
                       ],
                     ),
+                  ),
+          ),
           const SizedBox(height: 10),
           const Text(
             'All players:',
             style: TextStyle(fontSize: 16, fontWeight: FontWeight.bold),
           ),
           const SizedBox(height: 10),
-          FutureBuilder(
+          /*
-            future: _allPlayersFuture,
+
-            builder:
+           */
-                (BuildContext context, AsyncSnapshot<List<Player>> snapshot) {
+          Expanded(
-                  if (snapshot.hasError) {
-                    return const Center(
-                      child: TopCenteredMessage(
-                        icon: Icons.report,
-                        title: 'Error',
-                        message: 'Player data couldn\'t\nbe loaded.',
-                      ),
-                    );
-                  }
-                  bool doneLoading =
-                      snapshot.connectionState == ConnectionState.done;
-                  bool snapshotDataEmpty =
-                      !snapshot.hasData || snapshot.data!.isEmpty;
-                  if (doneLoading &&
-                      (snapshotDataEmpty && allPlayers.isEmpty)) {
-                    return const Center(
-                      child: TopCenteredMessage(
-                        icon: Icons.info,
-                        title: 'Info',
-                        message: 'No players created yet.',
-                      ),
-                    );
-                  }
-                  final bool isLoading =
-                      snapshot.connectionState == ConnectionState.waiting;
-                  return Expanded(
             child: AppSkeleton(
               enabled: isLoading,
               child: Visibility(
-                        visible:
+                visible: suggestedPlayers.isNotEmpty,
-                            (suggestedPlayers.isEmpty && allPlayers.isNotEmpty),
+                replacement: TopCenteredMessage(
-                        replacement: ListView.builder(
+                  icon: Icons.info,
+                  title: 'Info',
+                  message: allPlayers.isEmpty
+                      ? 'No players created yet'
+                      : (selectedPlayers.length == allPlayers.length)
+                      ? 'No more players to add'
+                      : 'No players found with that name',
+                ),
+                child: ListView.builder(
                   itemCount: suggestedPlayers.length,
                   itemBuilder: (BuildContext context, int index) {
                     return TextIconListTile(
@@ -191,31 +203,18 @@ class _PlayerSelectionState extends State<PlayerSelection> {
                           if (!selectedPlayers.contains(
                             suggestedPlayers[index],
                           )) {
-                                    selectedPlayers.add(
+                            selectedPlayers.add(suggestedPlayers[index]);
-                                      suggestedPlayers[index],
-                                    );
                             widget.onChanged([...selectedPlayers]);
-                                    suggestedPlayers.remove(
+                            suggestedPlayers.remove(suggestedPlayers[index]);
-                                      suggestedPlayers[index],
-                                    );
                           }
                         });
                       },
                     );
                   },
                 ),
-                        child: TopCenteredMessage(
-                          icon: Icons.info,
-                          title: 'Info',
-                          message: (selectedPlayers.length == allPlayers.length)
-                              ? 'No more players to add.'
-                              : 'No players found with that name.',
               ),
             ),
           ),
-                  );
-                },
-          ),
         ],
       ),
     );

lib/presentation/widgets/text_input/custom_search_bar.dart

@@ -30,7 +30,7 @@ class CustomSearchBar extends StatelessWidget {
       constraints:
           constraints ?? const BoxConstraints(maxHeight: 45, minHeight: 45),
       hintText: hintText,
-      onChanged: trailingButtonEnabled ? onChanged : null,
+      onChanged: onChanged,
       hintStyle: WidgetStateProperty.all(const TextStyle(fontSize: 16)),
       leading: const Icon(Icons.search),
       trailing: [

lib/presentation/widgets/tiles/game_history_tile.dart

@@ -1,14 +1,14 @@
 import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/data/dto/game.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/presentation/widgets/tiles/text_icon_tile.dart';
 import 'package:intl/intl.dart';
 
 class GameHistoryTile extends StatefulWidget {
-  final Game game;
+  final Match match;
   final VoidCallback onTap;
 
-  const GameHistoryTile({super.key, required this.game, required this.onTap});
+  const GameHistoryTile({super.key, required this.match, required this.onTap});
 
   @override
   State<GameHistoryTile> createState() => _GameHistoryTileState();
@@ -17,8 +17,8 @@ class GameHistoryTile extends StatefulWidget {
 class _GameHistoryTileState extends State<GameHistoryTile> {
   @override
   Widget build(BuildContext context) {
-    final group = widget.game.group;
+    final group = widget.match.group;
-    final winner = widget.game.winner;
+    final winner = widget.match.winner;
     final allPlayers = _getAllPlayers();
 
     return GestureDetector(
@@ -39,7 +39,7 @@ class _GameHistoryTileState extends State<GameHistoryTile> {
               children: [
                 Expanded(
                   child: Text(
-                    widget.game.name,
+                    widget.match.name,
                     style: const TextStyle(
                       fontSize: 18,
                       fontWeight: FontWeight.bold,
@@ -48,7 +48,7 @@ class _GameHistoryTileState extends State<GameHistoryTile> {
                   ),
                 ),
                 Text(
-                  _formatDate(widget.game.createdAt),
+                  _formatDate(widget.match.createdAt),
                   style: const TextStyle(fontSize: 12, color: Colors.grey),
                 ),
               ],
@@ -156,8 +156,8 @@ class _GameHistoryTileState extends State<GameHistoryTile> {
     final playerIds = <String>{};
 
     // Add players from game.players
-    if (widget.game.players != null) {
+    if (widget.match.players != null) {
-      for (var player in widget.game.players!) {
+      for (var player in widget.match.players!) {
         if (!playerIds.contains(player.id)) {
           allPlayers.add(player);
           playerIds.add(player.id);
@@ -166,8 +166,8 @@ class _GameHistoryTileState extends State<GameHistoryTile> {
     }
 
     // Add players from game.group.players
-    if (widget.game.group?.members != null) {
+    if (widget.match.group?.members != null) {
-      for (var player in widget.game.group!.members) {
+      for (var player in widget.match.group!.members) {
         if (!playerIds.contains(player.id)) {
           allPlayers.add(player);
           playerIds.add(player.id);

lib/presentation/widgets/tiles/game_tile.dart

@@ -2,27 +2,27 @@ import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:skeletonizer/skeletonizer.dart';
 
-class GameTile extends StatefulWidget {
+class MatchTile extends StatefulWidget {
-  final String gameTitle;
+  final String matchTitle;
-  final String gameType;
+  final String game;
   final String ruleset;
   final String players;
   final String winner;
 
-  const GameTile({
+  const MatchTile({
     super.key,
-    required this.gameTitle,
+    required this.matchTitle,
-    required this.gameType,
+    required this.game,
     required this.ruleset,
     required this.players,
     required this.winner,
   });
 
   @override
-  State<GameTile> createState() => _GameTileState();
+  State<MatchTile> createState() => _MatchTileState();
 }
 
-class _GameTileState extends State<GameTile> {
+class _MatchTileState extends State<MatchTile> {
   @override
   Widget build(BuildContext context) {
     return Column(
@@ -31,12 +31,12 @@ class _GameTileState extends State<GameTile> {
         Row(
           children: [
             Text(
-              widget.gameTitle,
+              widget.matchTitle,
               style: const TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
             ),
             const SizedBox(width: 5),
             Text(
-              widget.gameType,
+              widget.game,
               style: const TextStyle(fontSize: 14, color: Colors.grey),
             ),
           ],

lib/presentation/widgets/tiles/ruleset_list_tile.dart

@@ -1,55 +0,0 @@
-import 'package:flutter/material.dart';
-import 'package:game_tracker/core/custom_theme.dart';
-
-class RulesetListTile extends StatelessWidget {
-  final String title;
-  final String description;
-  final VoidCallback? onPressed;
-  final bool isHighlighted;
-
-  const RulesetListTile({
-    super.key,
-    required this.title,
-    required this.description,
-    this.onPressed,
-    this.isHighlighted = false,
-  });
-
-  @override
-  Widget build(BuildContext context) {
-    return GestureDetector(
-      onTap: onPressed,
-      child: AnimatedContainer(
-        margin: const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
-        padding: const EdgeInsets.symmetric(vertical: 6, horizontal: 12),
-        decoration: isHighlighted
-            ? CustomTheme.highlightedBoxDecoration
-            : CustomTheme.standardBoxDecoration,
-        duration: const Duration(milliseconds: 200),
-        child: Column(
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            Row(
-              mainAxisAlignment: MainAxisAlignment.spaceBetween,
-              children: [
-                Flexible(
-                  child: Text(
-                    title,
-                    overflow: TextOverflow.ellipsis,
-                    style: const TextStyle(
-                      fontWeight: FontWeight.bold,
-                      fontSize: 18,
-                    ),
-                  ),
-                ),
-              ],
-            ),
-            const SizedBox(height: 5),
-            Text(description, style: const TextStyle(fontSize: 14)),
-            const SizedBox(height: 2.5),
-          ],
-        ),
-      ),
-    );
-  }
-}

lib/presentation/widgets/tiles/statistics_tile.dart

@@ -40,11 +40,11 @@ class StatisticsTile extends StatelessWidget {
           child: Column(
             children: List.generate(min(values.length, itemCount), (index) {
               /// The maximum wins among all players
-              final maxGames = values.isNotEmpty ? values[0].$2 : 0;
+              final maxMatches = values.isNotEmpty ? values[0].$2 : 0;
 
               /// Fraction of wins
-              final double fraction = (maxGames > 0)
+              final double fraction = (maxMatches > 0)
-                  ? (values[index].$2 / maxGames)
+                  ? (values[index].$2 / maxMatches)
                   : 0.0;
 
               /// Calculated width for current the bar

lib/presentation/widgets/tiles/title_description_list_tile.dart

@@ -0,0 +1,92 @@
+import 'package:flutter/material.dart';
+import 'package:game_tracker/core/custom_theme.dart';
+
+class TitleDescriptionListTile extends StatelessWidget {
+  final String title;
+  final String description;
+  final VoidCallback? onPressed;
+  final bool isHighlighted;
+  final String? badgeText;
+  final Color? badgeColor;
+
+  const TitleDescriptionListTile({
+    super.key,
+    required this.title,
+    required this.description,
+    this.onPressed,
+    this.isHighlighted = false,
+    this.badgeText,
+    this.badgeColor,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return GestureDetector(
+      onTap: onPressed,
+      child: AnimatedContainer(
+        margin: const EdgeInsets.symmetric(vertical: 10, horizontal: 10),
+        padding: const EdgeInsets.symmetric(vertical: 6, horizontal: 12),
+        decoration: isHighlighted
+            ? CustomTheme.highlightedBoxDecoration
+            : CustomTheme.standardBoxDecoration,
+        duration: const Duration(milliseconds: 200),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            Row(
+              mainAxisAlignment: MainAxisAlignment.start,
+              crossAxisAlignment: CrossAxisAlignment.center,
+              children: [
+                SizedBox(
+                  width: 230,
+                  child: Text(
+                    title,
+                    overflow: TextOverflow.ellipsis,
+                    maxLines: 1,
+                    softWrap: false,
+                    style: const TextStyle(
+                      fontWeight: FontWeight.bold,
+                      fontSize: 18,
+                    ),
+                  ),
+                ),
+                if (badgeText != null) ...[
+                  const Spacer(),
+                  Container(
+                    constraints: const BoxConstraints(maxWidth: 100),
+                    margin: const EdgeInsets.only(top: 4),
+                    padding: const EdgeInsets.symmetric(
+                      vertical: 2,
+                      horizontal: 6,
+                    ),
+                    decoration: BoxDecoration(
+                      color: badgeColor ?? CustomTheme.primaryColor,
+                      borderRadius: BorderRadius.circular(4),
+                    ),
+                    child: Text(
+                      badgeText!,
+                      overflow: TextOverflow.ellipsis,
+                      maxLines: 1,
+                      softWrap: false,
+                      style: const TextStyle(
+                        color: Colors.white,
+                        fontSize: 12,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                  ),
+                ],
+              ],
+            ),
+            if (description.isNotEmpty) ...[
+              const SizedBox(height: 5),
+              Text(description, style: const TextStyle(fontSize: 14)),
+              const SizedBox(height: 2.5),
+            ],
+          ],
+        ),
+      ),
+    );
+  }
+}

lib/services/data_transfer_service.dart

@@ -6,8 +6,8 @@ import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:game_tracker/core/enums.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:json_schema/json_schema.dart';
 import 'package:provider/provider.dart';
@@ -16,7 +16,7 @@ class DataTransferService {
   /// Deletes all data from the database.
   static Future<void> deleteAllData(BuildContext context) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
-    await db.gameDao.deleteAllGames();
+    await db.matchDao.deleteAllMatches();
     await db.groupDao.deleteAllGroups();
     await db.playerDao.deleteAllPlayers();
   }
@@ -25,13 +25,13 @@ class DataTransferService {
   /// Returns the JSON string representation of the data.
   static Future<String> getAppDataAsJson(BuildContext context) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
-    final games = await db.gameDao.getAllGames();
+    final matches = await db.matchDao.getAllMatches();
     final groups = await db.groupDao.getAllGroups();
     final players = await db.playerDao.getAllPlayers();
 
     // Construct a JSON representation of the data
     final Map<String, dynamic> jsonMap = {
-      'games': games.map((game) => game.toJson()).toList(),
+      'matches': matches.map((match) => match.toJson()).toList(),
       'groups': groups.map((group) => group.toJson()).toList(),
       'players': players.map((player) => player.toJson()).toList(),
     };
@@ -89,14 +89,15 @@ class DataTransferService {
         final Map<String, dynamic> jsonData =
             json.decode(jsonString) as Map<String, dynamic>;
 
-        final List<dynamic>? gamesJson = jsonData['games'] as List<dynamic>?;
+        final List<dynamic>? matchesJson =
+            jsonData['matches'] as List<dynamic>?;
         final List<dynamic>? groupsJson = jsonData['groups'] as List<dynamic>?;
         final List<dynamic>? playersJson =
             jsonData['players'] as List<dynamic>?;
 
-        final List<Game> importedGames =
+        final List<Match> importedMatches =
-            gamesJson
+            matchesJson
-                ?.map((g) => Game.fromJson(g as Map<String, dynamic>))
+                ?.map((g) => Match.fromJson(g as Map<String, dynamic>))
                 .toList() ??
             [];
         final List<Group> importedGroups =
@@ -112,7 +113,7 @@ class DataTransferService {
 
         await db.playerDao.addPlayersAsList(players: importedPlayers);
         await db.groupDao.addGroupsAsList(groups: importedGroups);
-        await db.gameDao.addGamesAsList(games: importedGames);
+        await db.matchDao.addMatchAsList(matches: importedMatches);
       } else {
         return ImportResult.invalidSchema;
       }

test/db_tests/game_test.dart

@@ -3,8 +3,8 @@ import 'package:drift/drift.dart';
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 
 void main() {
@@ -16,14 +16,14 @@ void main() {
   late Player testPlayer5;
   late Group testGroup1;
   late Group testGroup2;
-  late Game testGame1;
+  late Match testMatch1;
-  late Game testGame2;
+  late Match testMatch2;
-  late Game testGameOnlyPlayers;
+  late Match testMatchOnlyPlayers;
-  late Game testGameOnlyGroup;
+  late Match testMatchOnlyGroup;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
-  setUp(() {
+  setUp(() async {
     database = AppDatabase(
       DatabaseConnection(
         NativeDatabase.memory(),
@@ -46,46 +46,61 @@ void main() {
         name: 'Test Group 2',
         members: [testPlayer4, testPlayer5],
       );
-      testGame1 = Game(
+      testMatch1 = Match(
-        name: 'First Test Game',
+        name: 'First Test Match',
         group: testGroup1,
         players: [testPlayer4, testPlayer5],
         winner: testPlayer4,
       );
-      testGame2 = Game(
+      testMatch2 = Match(
-        name: 'Second Test Game',
+        name: 'Second Test Match',
         group: testGroup2,
         players: [testPlayer1, testPlayer2, testPlayer3],
         winner: testPlayer2,
       );
-      testGameOnlyPlayers = Game(
+      testMatchOnlyPlayers = Match(
-        name: 'Test Game with Players',
+        name: 'Test Match with Players',
         players: [testPlayer1, testPlayer2, testPlayer3],
         winner: testPlayer3,
       );
-      testGameOnlyGroup = Game(name: 'Test Game with Group', group: testGroup2);
+      testMatchOnlyGroup = Match(
+        name: 'Test Match with Group',
+        group: testGroup2,
+      );
     });
+    await database.playerDao.addPlayersAsList(
+      players: [
+        testPlayer1,
+        testPlayer2,
+        testPlayer3,
+        testPlayer4,
+        testPlayer5,
+      ],
+    );
+    await database.groupDao.addGroupsAsList(groups: [testGroup1, testGroup2]);
   });
   tearDown(() async {
     await database.close();
   });
 
-  group('Game Tests', () {
+  group('Match Tests', () {
-    test('Adding and fetching single game works correctly', () async {
+    test('Adding and fetching single match works correctly', () async {
-      await database.gameDao.addGame(game: testGame1);
+      await database.matchDao.addMatch(match: testMatch1);
 
-      final result = await database.gameDao.getGameById(gameId: testGame1.id);
+      final result = await database.matchDao.getMatchById(
+        matchId: testMatch1.id,
+      );
 
-      expect(result.id, testGame1.id);
+      expect(result.id, testMatch1.id);
-      expect(result.name, testGame1.name);
+      expect(result.name, testMatch1.name);
-      expect(result.createdAt, testGame1.createdAt);
+      expect(result.createdAt, testMatch1.createdAt);
 
-      if (result.winner != null && testGame1.winner != null) {
+      if (result.winner != null && testMatch1.winner != null) {
-        expect(result.winner!.id, testGame1.winner!.id);
+        expect(result.winner!.id, testMatch1.winner!.id);
-        expect(result.winner!.name, testGame1.winner!.name);
+        expect(result.winner!.name, testMatch1.winner!.name);
-        expect(result.winner!.createdAt, testGame1.winner!.createdAt);
+        expect(result.winner!.createdAt, testMatch1.winner!.createdAt);
       } else {
-        expect(result.winner, testGame1.winner);
+        expect(result.winner, testMatch1.winner);
       }
 
       if (result.group != null) {
@@ -99,188 +114,203 @@ void main() {
         fail('Group is null');
       }
       if (result.players != null) {
-        expect(result.players!.length, testGame1.players!.length);
+        expect(result.players!.length, testMatch1.players!.length);
 
-        for (int i = 0; i < testGame1.players!.length; i++) {
+        for (int i = 0; i < testMatch1.players!.length; i++) {
-          expect(result.players![i].id, testGame1.players![i].id);
+          expect(result.players![i].id, testMatch1.players![i].id);
-          expect(result.players![i].name, testGame1.players![i].name);
+          expect(result.players![i].name, testMatch1.players![i].name);
-          expect(result.players![i].createdAt, testGame1.players![i].createdAt);
+          expect(
+            result.players![i].createdAt,
+            testMatch1.players![i].createdAt,
+          );
         }
       } else {
         fail('Players is null');
       }
     });
 
-    test('Adding and fetching multiple games works correctly', () async {
+    test('Adding and fetching multiple matches works correctly', () async {
-      await database.gameDao.addGamesAsList(
+      await database.matchDao.addMatchAsList(
-        games: [testGame1, testGame2, testGameOnlyGroup, testGameOnlyPlayers],
+        matches: [
+          testMatch1,
+          testMatch2,
+          testMatchOnlyGroup,
+          testMatchOnlyPlayers,
+        ],
       );
 
-      final allGames = await database.gameDao.getAllGames();
+      final allMatches = await database.matchDao.getAllMatches();
-      expect(allGames.length, 4);
+      expect(allMatches.length, 4);
 
-      final testGames = {
+      final testMatches = {
-        testGame1.id: testGame1,
+        testMatch1.id: testMatch1,
-        testGame2.id: testGame2,
+        testMatch2.id: testMatch2,
-        testGameOnlyGroup.id: testGameOnlyGroup,
+        testMatchOnlyGroup.id: testMatchOnlyGroup,
-        testGameOnlyPlayers.id: testGameOnlyPlayers,
+        testMatchOnlyPlayers.id: testMatchOnlyPlayers,
       };
 
-      for (final game in allGames) {
+      for (final match in allMatches) {
-        final testGame = testGames[game.id]!;
+        final testMatch = testMatches[match.id]!;
 
-        // Game-Checks
+        // Match-Checks
-        expect(game.id, testGame.id);
+        expect(match.id, testMatch.id);
-        expect(game.name, testGame.name);
+        expect(match.name, testMatch.name);
-        expect(game.createdAt, testGame.createdAt);
+        expect(match.createdAt, testMatch.createdAt);
-        if (game.winner != null && testGame.winner != null) {
+        if (match.winner != null && testMatch.winner != null) {
-          expect(game.winner!.id, testGame.winner!.id);
+          expect(match.winner!.id, testMatch.winner!.id);
-          expect(game.winner!.name, testGame.winner!.name);
+          expect(match.winner!.name, testMatch.winner!.name);
-          expect(game.winner!.createdAt, testGame.winner!.createdAt);
+          expect(match.winner!.createdAt, testMatch.winner!.createdAt);
         } else {
-          expect(game.winner, testGame.winner);
+          expect(match.winner, testMatch.winner);
         }
 
         // Group-Checks
-        if (testGame.group != null) {
+        if (testMatch.group != null) {
-          expect(game.group!.id, testGame.group!.id);
+          expect(match.group!.id, testMatch.group!.id);
-          expect(game.group!.name, testGame.group!.name);
+          expect(match.group!.name, testMatch.group!.name);
-          expect(game.group!.createdAt, testGame.group!.createdAt);
+          expect(match.group!.createdAt, testMatch.group!.createdAt);
 
           // Group Members-Checks
-          expect(game.group!.members.length, testGame.group!.members.length);
+          expect(match.group!.members.length, testMatch.group!.members.length);
-          for (int i = 0; i < testGame.group!.members.length; i++) {
+          for (int i = 0; i < testMatch.group!.members.length; i++) {
-            expect(game.group!.members[i].id, testGame.group!.members[i].id);
+            expect(match.group!.members[i].id, testMatch.group!.members[i].id);
             expect(
-              game.group!.members[i].name,
+              match.group!.members[i].name,
-              testGame.group!.members[i].name,
+              testMatch.group!.members[i].name,
             );
             expect(
-              game.group!.members[i].createdAt,
+              match.group!.members[i].createdAt,
-              testGame.group!.members[i].createdAt,
+              testMatch.group!.members[i].createdAt,
             );
           }
         } else {
-          expect(game.group, null);
+          expect(match.group, null);
         }
 
         // Players-Checks
-        if (testGame.players != null) {
+        if (testMatch.players != null) {
-          expect(game.players!.length, testGame.players!.length);
+          expect(match.players!.length, testMatch.players!.length);
-          for (int i = 0; i < testGame.players!.length; i++) {
+          for (int i = 0; i < testMatch.players!.length; i++) {
-            expect(game.players![i].id, testGame.players![i].id);
+            expect(match.players![i].id, testMatch.players![i].id);
-            expect(game.players![i].name, testGame.players![i].name);
+            expect(match.players![i].name, testMatch.players![i].name);
-            expect(game.players![i].createdAt, testGame.players![i].createdAt);
+            expect(
+              match.players![i].createdAt,
+              testMatch.players![i].createdAt,
+            );
           }
         } else {
-          expect(game.players, null);
+          expect(match.players, null);
         }
       }
     });
 
-    test('Adding the same game twice does not create duplicates', () async {
+    test('Adding the same match twice does not create duplicates', () async {
-      await database.gameDao.addGame(game: testGame1);
+      await database.matchDao.addMatch(match: testMatch1);
-      await database.gameDao.addGame(game: testGame1);
+      await database.matchDao.addMatch(match: testMatch1);
 
-      final gameCount = await database.gameDao.getGameCount();
+      final matchCount = await database.matchDao.getMatchCount();
-      expect(gameCount, 1);
+      expect(matchCount, 1);
     });
 
-    test('Game existence check works correctly', () async {
+    test('Match existence check works correctly', () async {
-      var gameExists = await database.gameDao.gameExists(gameId: testGame1.id);
+      var matchExists = await database.matchDao.matchExists(
-      expect(gameExists, false);
+        matchId: testMatch1.id,
-
-      await database.gameDao.addGame(game: testGame1);
-
-      gameExists = await database.gameDao.gameExists(gameId: testGame1.id);
-      expect(gameExists, true);
-    });
-
-    test('Deleting a game works correctly', () async {
-      await database.gameDao.addGame(game: testGame1);
-
-      final gameDeleted = await database.gameDao.deleteGame(
-        gameId: testGame1.id,
       );
-      expect(gameDeleted, true);
+      expect(matchExists, false);
 
-      final gameExists = await database.gameDao.gameExists(
+      await database.matchDao.addMatch(match: testMatch1);
-        gameId: testGame1.id,
+
+      matchExists = await database.matchDao.matchExists(matchId: testMatch1.id);
+      expect(matchExists, true);
+    });
+
+    test('Deleting a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatch1);
+
+      final matchDeleted = await database.matchDao.deleteMatch(
+        matchId: testMatch1.id,
       );
-      expect(gameExists, false);
+      expect(matchDeleted, true);
+
+      final matchExists = await database.matchDao.matchExists(
+        matchId: testMatch1.id,
+      );
+      expect(matchExists, false);
     });
 
-    test('Getting the game count works correctly', () async {
+    test('Getting the match count works correctly', () async {
-      var gameCount = await database.gameDao.getGameCount();
+      var matchCount = await database.matchDao.getMatchCount();
-      expect(gameCount, 0);
+      expect(matchCount, 0);
 
-      await database.gameDao.addGame(game: testGame1);
+      await database.matchDao.addMatch(match: testMatch1);
 
-      gameCount = await database.gameDao.getGameCount();
+      matchCount = await database.matchDao.getMatchCount();
-      expect(gameCount, 1);
+      expect(matchCount, 1);
 
-      await database.gameDao.addGame(game: testGame2);
+      await database.matchDao.addMatch(match: testMatch2);
 
-      gameCount = await database.gameDao.getGameCount();
+      matchCount = await database.matchDao.getMatchCount();
-      expect(gameCount, 2);
+      expect(matchCount, 2);
 
-      await database.gameDao.deleteGame(gameId: testGame1.id);
+      await database.matchDao.deleteMatch(matchId: testMatch1.id);
 
-      gameCount = await database.gameDao.getGameCount();
+      matchCount = await database.matchDao.getMatchCount();
-      expect(gameCount, 1);
+      expect(matchCount, 1);
 
-      await database.gameDao.deleteGame(gameId: testGame2.id);
+      await database.matchDao.deleteMatch(matchId: testMatch2.id);
 
-      gameCount = await database.gameDao.getGameCount();
+      matchCount = await database.matchDao.getMatchCount();
-      expect(gameCount, 0);
+      expect(matchCount, 0);
     });
 
-    test('Checking if game has winner works correclty', () async {
+    test('Checking if match has winner works correctly', () async {
-      await database.gameDao.addGame(game: testGame1);
+      await database.matchDao.addMatch(match: testMatch1);
-      await database.gameDao.addGame(game: testGameOnlyGroup);
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
 
-      var hasWinner = await database.gameDao.hasWinner(gameId: testGame1.id);
+      var hasWinner = await database.matchDao.hasWinner(matchId: testMatch1.id);
       expect(hasWinner, true);
 
-      hasWinner = await database.gameDao.hasWinner(
+      hasWinner = await database.matchDao.hasWinner(
-        gameId: testGameOnlyGroup.id,
+        matchId: testMatchOnlyGroup.id,
       );
       expect(hasWinner, false);
     });
 
-    test('Fetching the winner of a game works correctly', () async {
+    test('Fetching the winner of a match works correctly', () async {
-      await database.gameDao.addGame(game: testGame1);
+      await database.matchDao.addMatch(match: testMatch1);
 
-      final winner = await database.gameDao.getWinner(gameId: testGame1.id);
+      final winner = await database.matchDao.getWinner(matchId: testMatch1.id);
       if (winner == null) {
         fail('Winner is null');
       } else {
-        expect(winner.id, testGame1.winner!.id);
+        expect(winner.id, testMatch1.winner!.id);
-        expect(winner.name, testGame1.winner!.name);
+        expect(winner.name, testMatch1.winner!.name);
-        expect(winner.createdAt, testGame1.winner!.createdAt);
+        expect(winner.createdAt, testMatch1.winner!.createdAt);
       }
     });
 
-    test('Updating the winner of a game works correctly', () async {
+    test('Updating the winner of a match works correctly', () async {
-      await database.gameDao.addGame(game: testGame1);
+      await database.matchDao.addMatch(match: testMatch1);
 
-      final winner = await database.gameDao.getWinner(gameId: testGame1.id);
+      final winner = await database.matchDao.getWinner(matchId: testMatch1.id);
       if (winner == null) {
         fail('Winner is null');
       } else {
-        expect(winner.id, testGame1.winner!.id);
+        expect(winner.id, testMatch1.winner!.id);
-        expect(winner.name, testGame1.winner!.name);
+        expect(winner.name, testMatch1.winner!.name);
-        expect(winner.createdAt, testGame1.winner!.createdAt);
+        expect(winner.createdAt, testMatch1.winner!.createdAt);
         expect(winner.id, testPlayer4.id);
         expect(winner.id != testPlayer5.id, true);
       }
 
-      await database.gameDao.setWinner(
+      await database.matchDao.setWinner(
-        gameId: testGame1.id,
+        matchId: testMatch1.id,
         winnerId: testPlayer5.id,
       );
 
-      final newWinner = await database.gameDao.getWinner(gameId: testGame1.id);
+      final newWinner = await database.matchDao.getWinner(
+        matchId: testMatch1.id,
+      );
 
       if (newWinner == null) {
         fail('New winner is null');
@@ -292,39 +322,41 @@ void main() {
     });
 
     test('Removing a winner works correctly', () async {
-      await database.gameDao.addGame(game: testGame2);
+      await database.matchDao.addMatch(match: testMatch2);
 
-      var hasWinner = await database.gameDao.hasWinner(gameId: testGame2.id);
+      var hasWinner = await database.matchDao.hasWinner(matchId: testMatch2.id);
       expect(hasWinner, true);
 
-      await database.gameDao.removeWinner(gameId: testGame2.id);
+      await database.matchDao.removeWinner(matchId: testMatch2.id);
 
-      hasWinner = await database.gameDao.hasWinner(gameId: testGame2.id);
+      hasWinner = await database.matchDao.hasWinner(matchId: testMatch2.id);
       expect(hasWinner, false);
 
-      final removedWinner = await database.gameDao.getWinner(
+      final removedWinner = await database.matchDao.getWinner(
-        gameId: testGame2.id,
+        matchId: testMatch2.id,
       );
 
       expect(removedWinner, null);
     });
 
-    test('Renaming a game works correctly', () async {
+    test('Renaming a match works correctly', () async {
-      await database.gameDao.addGame(game: testGame1);
+      await database.matchDao.addMatch(match: testMatch1);
 
-      var fetchedGame = await database.gameDao.getGameById(
+      var fetchedMatch = await database.matchDao.getMatchById(
-        gameId: testGame1.id,
+        matchId: testMatch1.id,
       );
-      expect(fetchedGame.name, testGame1.name);
+      expect(fetchedMatch.name, testMatch1.name);
 
-      const newName = 'Updated Game Name';
+      const newName = 'Updated Match Name';
-      await database.gameDao.updateGameName(
+      await database.matchDao.updateMatchName(
-        gameId: testGame1.id,
+        matchId: testMatch1.id,
         newName: newName,
       );
 
-      fetchedGame = await database.gameDao.getGameById(gameId: testGame1.id);
+      fetchedMatch = await database.matchDao.getMatchById(
-      expect(fetchedGame.name, newName);
+        matchId: testMatch1.id,
+      );
+      expect(fetchedMatch.name, newName);
     });
   });
 }

test/db_tests/group_game_test.dart

@@ -1,10 +1,10 @@
 import 'package:clock/clock.dart';
-import 'package:drift/drift.dart';
+import 'package:drift/drift.dart' hide isNotNull;
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 
 void main() {
@@ -16,12 +16,12 @@ void main() {
   late Player testPlayer5;
   late Group testGroup1;
   late Group testGroup2;
-  late Game testgameWithGroup;
+  late Match testMatchWithGroup;
-  late Game testgameWithPlayers;
+  late Match testMatchWithPlayers;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
-  setUp(() {
+  setUp(() async {
     database = AppDatabase(
       DatabaseConnection(
         NativeDatabase.memory(),
@@ -44,81 +44,94 @@ void main() {
         name: 'Test Group',
         members: [testPlayer3, testPlayer2],
       );
-      testgameWithPlayers = Game(
+      testMatchWithPlayers = Match(
-        name: 'Test Game with Players',
+        name: 'Test Match with Players',
         players: [testPlayer4, testPlayer5],
       );
-      testgameWithGroup = Game(name: 'Test Game with Group', group: testGroup1);
+      testMatchWithGroup = Match(
+        name: 'Test Match with Group',
+        group: testGroup1,
+      );
     });
+    await database.playerDao.addPlayersAsList(
+      players: [
+        testPlayer1,
+        testPlayer2,
+        testPlayer3,
+        testPlayer4,
+        testPlayer5,
+      ],
+    );
+    await database.groupDao.addGroupsAsList(groups: [testGroup1, testGroup2]);
   });
   tearDown(() async {
     await database.close();
   });
-  group('Group-Game Tests', () {
+  group('Group-Match Tests', () {
-    test('Game has group works correctly', () async {
+    test('matchHasGroup() has group works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithPlayers);
+      await database.matchDao.addMatch(match: testMatchWithPlayers);
       await database.groupDao.addGroup(group: testGroup1);
 
-      var gameHasGroup = await database.groupGameDao.gameHasGroup(
+      var matchHasGroup = await database.groupMatchDao.matchHasGroup(
-        gameId: testgameWithPlayers.id,
+        matchId: testMatchWithPlayers.id,
       );
 
-      expect(gameHasGroup, false);
+      expect(matchHasGroup, false);
 
-      await database.groupGameDao.addGroupToGame(
+      await database.groupMatchDao.addGroupToMatch(
-        gameId: testgameWithPlayers.id,
+        matchId: testMatchWithPlayers.id,
         groupId: testGroup1.id,
       );
 
-      gameHasGroup = await database.groupGameDao.gameHasGroup(
+      matchHasGroup = await database.groupMatchDao.matchHasGroup(
-        gameId: testgameWithPlayers.id,
+        matchId: testMatchWithPlayers.id,
       );
 
-      expect(gameHasGroup, true);
+      expect(matchHasGroup, true);
     });
 
-    test('Adding a group to a game works correctly', () async {
+    test('Adding a group to a match works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithPlayers);
+      await database.matchDao.addMatch(match: testMatchWithPlayers);
       await database.groupDao.addGroup(group: testGroup1);
-      await database.groupGameDao.addGroupToGame(
+      await database.groupMatchDao.addGroupToMatch(
-        gameId: testgameWithPlayers.id,
+        matchId: testMatchWithPlayers.id,
         groupId: testGroup1.id,
       );
 
-      var groupAdded = await database.groupGameDao.isGroupInGame(
+      var groupAdded = await database.groupMatchDao.isGroupInMatch(
-        gameId: testgameWithPlayers.id,
+        matchId: testMatchWithPlayers.id,
         groupId: testGroup1.id,
       );
       expect(groupAdded, true);
 
-      groupAdded = await database.groupGameDao.isGroupInGame(
+      groupAdded = await database.groupMatchDao.isGroupInMatch(
-        gameId: testgameWithPlayers.id,
+        matchId: testMatchWithPlayers.id,
         groupId: '',
       );
       expect(groupAdded, false);
     });
 
-    test('Removing group from game works correctly', () async {
+    test('Removing group from match works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithGroup);
+      await database.matchDao.addMatch(match: testMatchWithGroup);
 
-      final groupToRemove = testgameWithGroup.group!;
+      final groupToRemove = testMatchWithGroup.group!;
 
-      final removed = await database.groupGameDao.removeGroupFromGame(
+      final removed = await database.groupMatchDao.removeGroupFromMatch(
         groupId: groupToRemove.id,
-        gameId: testgameWithGroup.id,
+        matchId: testMatchWithGroup.id,
       );
       expect(removed, true);
 
-      final result = await database.gameDao.getGameById(
+      final result = await database.matchDao.getMatchById(
-        gameId: testgameWithGroup.id,
+        matchId: testMatchWithGroup.id,
       );
       expect(result.group, null);
     });
 
-    test('Retrieving group of a game works correctly', () async {
+    test('Retrieving group of a match works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithGroup);
+      await database.matchDao.addMatch(match: testMatchWithGroup);
-      final group = await database.groupGameDao.getGroupOfGame(
+      final group = await database.groupMatchDao.getGroupOfMatch(
-        gameId: testgameWithGroup.id,
+        matchId: testMatchWithGroup.id,
       );
 
       if (group == null) {
@@ -136,11 +149,11 @@ void main() {
       }
     });
 
-    test('Updating the group of a game works correctly', () async {
+    test('Updating the group of a match works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithGroup);
+      await database.matchDao.addMatch(match: testMatchWithGroup);
 
-      var group = await database.groupGameDao.getGroupOfGame(
+      var group = await database.groupMatchDao.getGroupOfMatch(
-        gameId: testgameWithGroup.id,
+        matchId: testMatchWithGroup.id,
       );
 
       if (group == null) {
@@ -153,13 +166,13 @@ void main() {
       }
 
       await database.groupDao.addGroup(group: testGroup2);
-      await database.groupGameDao.updateGroupOfGame(
+      await database.groupMatchDao.updateGroupOfMatch(
-        gameId: testgameWithGroup.id,
+        matchId: testMatchWithGroup.id,
         newGroupId: testGroup2.id,
       );
 
-      group = await database.groupGameDao.getGroupOfGame(
+      group = await database.groupMatchDao.getGroupOfMatch(
-        gameId: testgameWithGroup.id,
+        matchId: testMatchWithGroup.id,
       );
 
       if (group == null) {
@@ -176,5 +189,33 @@ void main() {
         }
       }
     });
+
+    test('Adding the same group to seperate matches works correctly', () async {
+      final match1 = Match(name: 'Match 1', group: testGroup1);
+      final match2 = Match(name: 'Match 2', group: testGroup1);
+
+      await Future.wait([
+        database.matchDao.addMatch(match: match1),
+        database.matchDao.addMatch(match: match2),
+      ]);
+
+      final group1 = await database.groupMatchDao.getGroupOfMatch(
+        matchId: match1.id,
+      );
+      final group2 = await database.groupMatchDao.getGroupOfMatch(
+        matchId: match2.id,
+      );
+
+      expect(group1, isNotNull);
+      expect(group2, isNotNull);
+
+      final groups = [group1!, group2!];
+      for (final group in groups) {
+        expect(group.members.length, testGroup1.members.length);
+        expect(group.id, testGroup1.id);
+        expect(group.name, testGroup1.name);
+        expect(group.createdAt, testGroup1.createdAt);
+      }
+    });
   });
 }

test/db_tests/player_game_test.dart

@@ -1,10 +1,10 @@
 import 'package:clock/clock.dart';
-import 'package:drift/drift.dart';
+import 'package:drift/drift.dart' hide isNotNull;
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 
 void main() {
@@ -16,12 +16,12 @@ void main() {
   late Player testPlayer5;
   late Player testPlayer6;
   late Group testgroup;
-  late Game testGameOnlyGroup;
+  late Match testMatchOnlyGroup;
-  late Game testGameOnlyPlayers;
+  late Match testMatchOnlyPlayers;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
-  setUp(() {
+  setUp(() async {
     database = AppDatabase(
       DatabaseConnection(
         NativeDatabase.memory(),
@@ -41,78 +41,92 @@ void main() {
         name: 'Test Group',
         members: [testPlayer1, testPlayer2, testPlayer3],
       );
-      testGameOnlyGroup = Game(name: 'Test Game with Group', group: testgroup);
+      testMatchOnlyGroup = Match(
-      testGameOnlyPlayers = Game(
+        name: 'Test Match with Group',
-        name: 'Test Game with Players',
+        group: testgroup,
+      );
+      testMatchOnlyPlayers = Match(
+        name: 'Test Match with Players',
         players: [testPlayer4, testPlayer5, testPlayer6],
       );
     });
+    await database.playerDao.addPlayersAsList(
+      players: [
+        testPlayer1,
+        testPlayer2,
+        testPlayer3,
+        testPlayer4,
+        testPlayer5,
+        testPlayer6,
+      ],
+    );
+    await database.groupDao.addGroup(group: testgroup);
   });
   tearDown(() async {
     await database.close();
   });
 
-  group('Player-Game Tests', () {
+  group('Player-Match Tests', () {
-    test('Game has player works correctly', () async {
+    test('Match has player works correctly', () async {
-      await database.gameDao.addGame(game: testGameOnlyGroup);
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.playerDao.addPlayer(player: testPlayer1);
 
-      var gameHasPlayers = await database.playerGameDao.gameHasPlayers(
+      var matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
-        gameId: testGameOnlyGroup.id,
+        matchId: testMatchOnlyGroup.id,
       );
 
-      expect(gameHasPlayers, false);
+      expect(matchHasPlayers, false);
 
-      await database.playerGameDao.addPlayerToGame(
+      await database.playerMatchDao.addPlayerToMatch(
-        gameId: testGameOnlyGroup.id,
+        matchId: testMatchOnlyGroup.id,
         playerId: testPlayer1.id,
       );
 
-      gameHasPlayers = await database.playerGameDao.gameHasPlayers(
+      matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
-        gameId: testGameOnlyGroup.id,
+        matchId: testMatchOnlyGroup.id,
       );
 
-      expect(gameHasPlayers, true);
+      expect(matchHasPlayers, true);
     });
 
-    test('Adding a player to a game works correctly', () async {
+    test('Adding a player to a match works correctly', () async {
-      await database.gameDao.addGame(game: testGameOnlyGroup);
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.playerDao.addPlayer(player: testPlayer5);
-      await database.playerGameDao.addPlayerToGame(
+      await database.playerMatchDao.addPlayerToMatch(
-        gameId: testGameOnlyGroup.id,
+        matchId: testMatchOnlyGroup.id,
         playerId: testPlayer5.id,
       );
 
-      var playerAdded = await database.playerGameDao.isPlayerInGame(
+      var playerAdded = await database.playerMatchDao.isPlayerInMatch(
-        gameId: testGameOnlyGroup.id,
+        matchId: testMatchOnlyGroup.id,
         playerId: testPlayer5.id,
       );
 
       expect(playerAdded, true);
 
-      playerAdded = await database.playerGameDao.isPlayerInGame(
+      playerAdded = await database.playerMatchDao.isPlayerInMatch(
-        gameId: testGameOnlyGroup.id,
+        matchId: testMatchOnlyGroup.id,
         playerId: '',
       );
 
       expect(playerAdded, false);
     });
 
-    test('Removing player from game works correctly', () async {
+    test('Removing player from match works correctly', () async {
-      await database.gameDao.addGame(game: testGameOnlyPlayers);
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
 
-      final playerToRemove = testGameOnlyPlayers.players![0];
+      final playerToRemove = testMatchOnlyPlayers.players![0];
 
-      final removed = await database.playerGameDao.removePlayerFromGame(
+      final removed = await database.playerMatchDao.removePlayerFromMatch(
         playerId: playerToRemove.id,
-        gameId: testGameOnlyPlayers.id,
+        matchId: testMatchOnlyPlayers.id,
       );
       expect(removed, true);
 
-      final result = await database.gameDao.getGameById(
+      final result = await database.matchDao.getMatchById(
-        gameId: testGameOnlyPlayers.id,
+        matchId: testMatchOnlyPlayers.id,
       );
-      expect(result.players!.length, testGameOnlyPlayers.players!.length - 1);
+      expect(result.players!.length, testMatchOnlyPlayers.players!.length - 1);
 
       final playerExists = result.players!.any(
         (p) => p.id == playerToRemove.id,
@@ -120,10 +134,10 @@ void main() {
       expect(playerExists, false);
     });
 
-    test('Retrieving players of a game works correctly', () async {
+    test('Retrieving players of a match works correctly', () async {
-      await database.gameDao.addGame(game: testGameOnlyPlayers);
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
-      final players = await database.playerGameDao.getPlayersOfGame(
+      final players = await database.playerMatchDao.getPlayersOfMatch(
-        gameId: testGameOnlyPlayers.id,
+        matchId: testMatchOnlyPlayers.id,
       );
 
       if (players == null) {
@@ -131,34 +145,37 @@ void main() {
       }
 
       for (int i = 0; i < players.length; i++) {
-        expect(players[i].id, testGameOnlyPlayers.players![i].id);
+        expect(players[i].id, testMatchOnlyPlayers.players![i].id);
-        expect(players[i].name, testGameOnlyPlayers.players![i].name);
+        expect(players[i].name, testMatchOnlyPlayers.players![i].name);
-        expect(players[i].createdAt, testGameOnlyPlayers.players![i].createdAt);
+        expect(
+          players[i].createdAt,
+          testMatchOnlyPlayers.players![i].createdAt,
+        );
       }
     });
 
-    test('Updating the games players works coreclty', () async {
+    test('Updating the match players works coreclty', () async {
-      await database.gameDao.addGame(game: testGameOnlyPlayers);
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
 
       final newPlayers = [testPlayer1, testPlayer2, testPlayer4];
       await database.playerDao.addPlayersAsList(players: newPlayers);
 
       // First, remove all existing players
-      final existingPlayers = await database.playerGameDao.getPlayersOfGame(
+      final existingPlayers = await database.playerMatchDao.getPlayersOfMatch(
-        gameId: testGameOnlyPlayers.id,
+        matchId: testMatchOnlyPlayers.id,
       );
 
       if (existingPlayers == null || existingPlayers.isEmpty) {
         fail('Existing players should not be null or empty');
       }
 
-      await database.playerGameDao.updatePlayersFromGame(
+      await database.playerMatchDao.updatePlayersFromMatch(
-        gameId: testGameOnlyPlayers.id,
+        matchId: testMatchOnlyPlayers.id,
         newPlayer: newPlayers,
       );
 
-      final updatedPlayers = await database.playerGameDao.getPlayersOfGame(
+      final updatedPlayers = await database.playerMatchDao.getPlayersOfMatch(
-        gameId: testGameOnlyPlayers.id,
+        matchId: testMatchOnlyPlayers.id,
       );
 
       if (updatedPlayers == null) {
@@ -179,5 +196,42 @@ void main() {
         expect(player.createdAt, testPlayer.createdAt);
       }
     });
+
+    test(
+      'Adding the same player to seperate matches works correctly',
+      () async {
+        final playersList = [testPlayer1, testPlayer2, testPlayer3];
+        final match1 = Match(name: 'Match 1', players: playersList);
+        final match2 = Match(name: 'Match 2', players: playersList);
+
+        await Future.wait([
+          database.matchDao.addMatch(match: match1),
+          database.matchDao.addMatch(match: match2),
+        ]);
+
+        final players1 = await database.playerMatchDao.getPlayersOfMatch(
+          matchId: match1.id,
+        );
+        final players2 = await database.playerMatchDao.getPlayersOfMatch(
+          matchId: match2.id,
+        );
+
+        expect(players1, isNotNull);
+        expect(players2, isNotNull);
+
+        expect(
+          players1!.map((p) => p.id).toList(),
+          equals(players2!.map((p) => p.id).toList()),
+        );
+        expect(
+          players1.map((p) => p.name).toList(),
+          equals(players2.map((p) => p.name).toList()),
+        );
+        expect(
+          players1.map((p) => p.createdAt).toList(),
+          equals(players2.map((p) => p.createdAt).toList()),
+        );
+      },
+    );
   });
 }