Implemented badges

README.md

@@ -1,7 +1,15 @@
 # Game Tracker
 
-![Version](https://img.shields.io/badge/Version-0.3.0-orange)
+![Flutter](https://img.shields.io/badge/Created_by-Liquid_Development-027DFD?logo=data:image/svg+xml;base64,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)
-![Flutter](https://img.shields.io/badge/Flutter-3.32.1-blue?logo=flutter)
+
-![Dart](https://img.shields.io/badge/Dart-3.8.1-blue?logo=dart)
+![Version](https://img.shields.io/badge/App--Version-MVP-orange)
+![Flutter](https://img.shields.io/badge/Flutter-3.35.6-027DFD?logo=flutter)
+![Dart](https://img.shields.io/badge/Dart-3.9.2-027DFD?logo=dart)
+
+### Versions Supported
+
+![iOS18](https://img.shields.io/badge/iOS-18.7.1-white?logo=apple)
+![iOS26](https://img.shields.io/badge/iOS-26.1-white?logo=apple)
+![Android16](https://img.shields.io/badge/Android-16-3DDC84?logo=android)
 
 A all-in-one app to track card- and board games, manage players and groups and get statistics about your played games.

lib/core/constants.dart

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

lib/core/enums.dart

@@ -23,23 +23,9 @@ enum ImportResult {
 /// - [ExportResult.unknownException]: An exception occurred during export.
 enum ExportResult { success, canceled, unknownException }
 
-/// Different rulesets available for matches
+/// Different rulesets available for games
-/// - [Ruleset.singleWinner]: The match is won by a single player
+/// - [Ruleset.singleWinner]: The game is won by a single player
-/// - [Ruleset.singleLoser]: The match is lost by a single player
+/// - [Ruleset.singleLoser]: The game is lost by a single player
 /// - [Ruleset.mostPoints]: The player with the most points wins.
-/// - [Ruleset.leastPoints]: The player with the fewest points wins.
+/// - [Ruleset.lastPoints]: The player with the fewest points wins.
-enum Ruleset { singleWinner, singleLoser, mostPoints, leastPoints }
+enum Ruleset { singleWinner, singleLoser, mostPoints, lastPoints }
-
-/// 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

@@ -0,0 +1,320 @@
+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

@@ -0,0 +1,8 @@
+// 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,13 +1,12 @@
 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, PlayerGroupTable])
+@DriftAccessor(tables: [GroupTable])
 class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
   GroupDao(super.db);
 

lib/data/dao/group_dao.g.dart

@@ -5,7 +5,4 @@ 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

@@ -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_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

@@ -0,0 +1,10 @@
+// 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

@@ -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_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.insertOrReplace,
-    );
-  }
-
-  /// 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

@@ -1,10 +0,0 @@
-// 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

@@ -1,322 +0,0 @@
-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 associated players and group if they exist.
-  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) {
-        await db.playerDao.addPlayersAsList(players: match.players!);
-        for (final p in match.players ?? []) {
-          await db.playerMatchDao.addPlayerToMatch(
-            matchId: match.id,
-            playerId: p.id,
-          );
-        }
-      }
-
-      if (match.group != null) {
-        await db.groupDao.addGroup(group: match.group!);
-        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.
-  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.insertOrReplace,
-              );
-            }
-          }
-        }
-      });
-
-      // 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.insertOrReplace,
-              );
-            }
-          }
-        }
-      });
-
-      // 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.insertOrReplace,
-            );
-          }
-        }
-      });
-    });
-  }
-
-  /// 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

@@ -1,8 +0,0 @@
-// 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

@@ -0,0 +1,128 @@
+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

@@ -0,0 +1,10 @@
+// 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,12 +1,11 @@
 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, PlayerTable])
+@DriftAccessor(tables: [PlayerGroupTable])
 class PlayerGroupDao extends DatabaseAccessor<AppDatabase>
     with _$PlayerGroupDaoMixin {
   PlayerGroupDao(super.db);

lib/data/dao/player_match_dao.dart

@@ -1,130 +0,0 @@
-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.insertOrReplace,
-    );
-  }
-
-  /// 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.insertOrReplace),
-          ),
-        );
-      }
-    });
-  }
-}

lib/data/dao/player_match_dao.g.dart

@@ -1,11 +0,0 @@
-// 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_match_dao.dart';
+import 'package:game_tracker/data/dao/group_game_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/dao/player_match_dao.dart';
+import 'package:game_tracker/data/db/tables/game_table.dart';
-import 'package:game_tracker/data/db/tables/group_match_table.dart';
+import 'package:game_tracker/data/db/tables/group_game_table.dart';
 import 'package:game_tracker/data/db/tables/group_table.dart';
-import 'package:game_tracker/data/db/tables/match_table.dart';
+import 'package:game_tracker/data/db/tables/player_game_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,
-    MatchTable,
+    GameTable,
     PlayerGroupTable,
-    PlayerMatchTable,
+    PlayerGameTable,
-    GroupMatchTable,
+    GroupGameTable,
   ],
   daos: [
     PlayerDao,
     GroupDao,
-    MatchDao,
+    GameDao,
     PlayerGroupDao,
-    PlayerMatchDao,
+    PlayerGameDao,
-    GroupMatchDao,
+    GroupGameDao,
   ],
 )
 class AppDatabase extends _$AppDatabase {

lib/data/db/tables/game_table.dart

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

lib/data/db/tables/group_game_table.dart

@@ -0,0 +1,13 @@
+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

@@ -1,13 +0,0 @@
-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/player_game_table.dart

@@ -0,0 +1,13 @@
+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

@@ -1,13 +0,0 @@
-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/game.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 Match {
+class Game {
   final String id;
   final DateTime createdAt;
   final String name;
@@ -11,7 +11,7 @@ class Match {
   final Group? group;
   final Player? winner;
 
-  Match({
+  Game({
     String? id,
     DateTime? createdAt,
     required this.name,
@@ -23,11 +23,11 @@ class Match {
 
   @override
   String toString() {
-    return 'Match{\n\tid: $id,\n\tname: $name,\n\tplayers: $players,\n\tgroup: $group,\n\twinner: $winner\n}';
+    return 'Game{\n\tid: $id,\n\tname: $name,\n\tplayers: $players,\n\tgroup: $group,\n\twinner: $winner\n}';
   }
 
-  /// Creates a Match instance from a JSON object.
+  /// Creates a Game instance from a JSON object.
-  Match.fromJson(Map<String, dynamic> json)
+  Game.fromJson(Map<String, dynamic> json)
     : id = json['id'],
       name = json['name'],
       createdAt = DateTime.parse(json['createdAt']),
@@ -39,7 +39,7 @@ class Match {
       group = json['group'] != null ? Group.fromJson(json['group']) : null,
       winner = json['winner'] != null ? Player.fromJson(json['winner']) : null;
 
-  /// Converts the Match instance to a JSON object.
+  /// Converts the Game 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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,120 @@
+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/create_game/create_game_view.dart

@@ -1,33 +1,35 @@
-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/match_view/create_match/choose_game_view.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_group_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_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 CreateMatchView extends StatefulWidget {
+class CreateGameView extends StatefulWidget {
-  final VoidCallback? onWinnerChanged;
+  const CreateGameView({super.key});
-  const CreateMatchView({super.key, this.onWinnerChanged});
 
   @override
-  State<CreateMatchView> createState() => _CreateMatchViewState();
+  State<CreateGameView> createState() => _CreateGameViewState();
 }
 
-class _CreateMatchViewState extends State<CreateMatchView> {
+class _CreateGameViewState extends State<CreateGameView> {
   /// 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();
 
@@ -37,18 +39,12 @@ class _CreateMatchViewState extends State<CreateMatchView> {
   /// 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]
-  String selectedGroupId = '';
+  int selectedGroupIndex = -1;
 
   /// The currently selected ruleset
   Ruleset? selectedRuleset;
@@ -57,58 +53,46 @@ class _CreateMatchViewState extends State<CreateMatchView> {
   /// 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 descriptions
+  /// List of available rulesets with their display names and descriptions
-  /// as tuples of (Ruleset, String)
+  /// as tuples of (Ruleset, String, String)
-  /// TODO: Replace when rulesets are implemented
+  List<(Ruleset, String, String)> rulesets = [
-  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.leastPoints,
+      Ruleset.lastPoints,
+      '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);
 
-    Future.wait([
+    _allGroupsFuture = db.groupDao.getAllGroups();
-      db.groupDao.getAllGroups(),
+    _allPlayersFuture = db.playerDao.getAllPlayers();
-      db.playerDao.getAllPlayers(),
+
-    ]).then((result) async {
+    Future.wait([_allGroupsFuture, _allPlayersFuture]).then((result) async {
       groupsList = result[0] as List<Group>;
       playerList = result[1] as List<Player>;
     });
-    filteredPlayerList = List.from(playerList);
   }
 
   @override
@@ -129,38 +113,15 @@ class _CreateMatchViewState extends State<CreateMatchView> {
           mainAxisAlignment: MainAxisAlignment.start,
           children: [
             Container(
-              margin: const EdgeInsets.symmetric(horizontal: 12, vertical: 5),
+              margin: const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
               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
@@ -178,7 +139,6 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                 selectedRulesetIndex = rulesets.indexWhere(
                   (r) => r.$1 == selectedRuleset,
                 );
-                selectedGameIndex = -1;
                 setState(() {});
               },
             ),
@@ -192,28 +152,28 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                   MaterialPageRoute(
                     builder: (context) => ChooseGroupView(
                       groups: groupsList,
-                      initialGroupId: selectedGroupId,
+                      initialGroupIndex: selectedGroupIndex,
                     ),
                   ),
                 );
-                selectedGroupId = selectedGroup?.id ?? '';
+                selectedGroupIndex = groupsList.indexWhere(
-                if (selectedGroup != null) {
+                  (g) => g.id == selectedGroup?.id,
-                  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'),
-                initialSelectedPlayers: selectedPlayers ?? [],
+                initialPlayers: selectedGroup == null
-                availablePlayers: filteredPlayerList,
+                    ? playerList
+                    : playerList
+                          .where(
+                            (p) => !selectedGroup!.members.any(
+                              (m) => m.id == p.id,
+                            ),
+                          )
+                          .toList(),
                 onChanged: (value) {
                   setState(() {
                     selectedPlayers = value;
@@ -221,46 +181,52 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                 },
               ),
             ),
+
             CustomWidthButton(
               text: 'Create game',
               sizeRelativeToWidth: 0.95,
               buttonType: ButtonType.primary,
               onPressed: _enableCreateGameButton()
                   ? () async {
-                      Match match = Match(
+                      Game game = Game(
                         name: _gameNameController.text.trim(),
                         createdAt: DateTime.now(),
-                        group: selectedGroup,
+                        group: selectedGroup!,
                         players: selectedPlayers,
                       );
-                      await db.matchDao.addMatch(match: match);
+                      // TODO: Replace with navigation to GameResultView()
-                      if (context.mounted) {
+                      print('Created game: $game');
-                        Navigator.pushReplacement(
+                      Navigator.pop(context);
-                          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!.length > 1)) &&
+            (selectedPlayers != null && selectedPlayers!.isNotEmpty)) &&
         selectedRuleset != null;
   }
 }

lib/presentation/views/main_menu/create_group_view.dart

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

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/group_view/groups_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/game_history_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('matches_$tabKeyCount'),
+        key: ValueKey('games_$tabKeyCount'),
-        child: const MatchView(),
+        child: const GameHistoryView(),
       ),
       KeyedSubtree(
         key: ValueKey('groups_$tabKeyCount'),
@@ -96,7 +96,7 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
                     index: 1,
                     isSelected: currentIndex == 1,
                     icon: Icons.gamepad_rounded,
-                    label: 'Matches',
+                    label: 'Games',
                     onTabTapped: onTabTapped,
                   ),
                   NavbarItem(
@@ -133,7 +133,7 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
       case 0:
         return 'Home';
       case 1:
-        return 'Matches';
+        return 'Game History';
       case 2:
         return 'Groups';
       case 3:

lib/presentation/views/main_menu/game_history_view.dart

@@ -0,0 +1,150 @@
+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/game_result_view.dart

@@ -1,17 +1,16 @@
 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/match.dart';
+import 'package:game_tracker/data/dto/game.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 Match match;
+  final Game game;
 
-  final VoidCallback? onWinnerChanged;
+  const GameResultView({super.key, required this.game});
 
-  const GameResultView({super.key, required this.match, this.onWinnerChanged});
   @override
   State<GameResultView> createState() => _GameResultViewState();
 }
@@ -24,10 +23,10 @@ class _GameResultViewState extends State<GameResultView> {
   @override
   void initState() {
     db = Provider.of<AppDatabase>(context, listen: false);
-    allPlayers = getAllPlayers(widget.match);
+    allPlayers = getAllPlayers(widget.game);
-    if (widget.match.winner != null) {
+    if (widget.game.winner != null) {
       _selectedPlayer = allPlayers.firstWhere(
-        (p) => p.id == widget.match.winner!.id,
+        (p) => p.id == widget.game.winner!.id,
       );
     }
     super.initState();
@@ -41,7 +40,7 @@ class _GameResultViewState extends State<GameResultView> {
         backgroundColor: CustomTheme.backgroundColor,
         scrolledUnderElevation: 0,
         title: Text(
-          widget.match.name,
+          widget.game.name,
           style: const TextStyle(
             fontSize: 20,
             fontWeight: FontWeight.bold,
@@ -125,17 +124,16 @@ class _GameResultViewState extends State<GameResultView> {
 
   Future<void> _handleWinnerSaving() async {
     if (_selectedPlayer == null) {
-      await db.matchDao.removeWinner(matchId: widget.match.id);
+      await db.gameDao.removeWinner(gameId: widget.game.id);
     } else {
-      await db.matchDao.setWinner(
+      await db.gameDao.setWinner(
-        matchId: widget.match.id,
+        gameId: widget.game.id,
         winnerId: _selectedPlayer!.id,
       );
     }
-    widget.onWinnerChanged?.call();
   }
 
-  List<Player> getAllPlayers(Match game) {
+  List<Player> getAllPlayers(Game game) {
     if (game.group == null && game.players != null) {
       return [...game.players!];
     } else if (game.group != null && game.players != null) {

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

@@ -1,115 +0,0 @@
-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

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

@@ -1,86 +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/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

@@ -1,128 +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/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: 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

@@ -1,78 +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/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/match_view.dart

@@ -1,132 +0,0 @@
-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,7 +1,6 @@
 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/match.dart';
+import 'package:game_tracker/data/dto/game.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';
@@ -15,8 +14,10 @@ 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)> matchCounts = List.filled(6, ('Skeleton Player', 1));
+  List<(String, int)> gameCounts = List.filled(6, ('Skeleton Player', 1));
   List<(String, double)> winRates = List.filled(6, ('Skeleton Player', 1));
   bool isLoading = true;
 
@@ -24,17 +25,16 @@ 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([
+    Future.wait([_gamesFuture, _playersFuture]).then((results) async {
-      db.matchDao.getAllMatches(),
+      await Future.delayed(const Duration(milliseconds: 250));
-      db.playerDao.getAllPlayers(),
+      final games = results[0] as List<Game>;
-      Future.delayed(minimumSkeletonDuration),
-    ]).then((results) async {
-      final matches = results[0] as List<Match>;
       final players = results[1] as List<Player>;
-      winCounts = _calculateWinsForAllPlayers(matches, players);
+      winCounts = _calculateWinsForAllPlayers(games, players);
-      matchCounts = _calculateMatchAmountsForAllPlayers(matches, players);
+      gameCounts = _calculateGameAmountsForAllPlayers(games, players);
-      winRates = computeWinRatePercent(wins: winCounts, matches: matchCounts);
+      winRates = computeWinRatePercent(wins: winCounts, games: gameCounts);
       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',
+                    title: 'Wins per Player',
                     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',
+                    title: 'Winrate per Player',
                     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: 'Amount of Matches',
+                    title: 'Games per Player',
                     width: constraints.maxWidth * 0.95,
-                    values: matchCounts,
+                    values: gameCounts,
                     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<Match> matches,
+    List<Game> games,
     List<Player> players,
   ) {
     List<(String, int)> winCounts = [];
 
     // Getting the winners
-    for (var match in matches) {
+    for (var game in games) {
-      final winner = match.winner;
+      final winner = game.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 matches played for each player
+  /// Calculates the number of games played for each player
-  /// and returns a sorted list of tuples (playerName, matchCount)
+  /// and returns a sorted list of tuples (playerName, gameCount)
-  List<(String, int)> _calculateMatchAmountsForAllPlayers(
+  List<(String, int)> _calculateGameAmountsForAllPlayers(
-    List<Match> matches,
+    List<Game> games,
     List<Player> players,
   ) {
-    List<(String, int)> matchCounts = [];
+    List<(String, int)> gameCounts = [];
 
-    // Counting matches for each player
+    // Counting games for each player
-    for (var match in matches) {
+    for (var game in games) {
-      if (match.group != null) {
+      if (game.group != null) {
-        final members = match.group!.members.map((p) => p.id).toList();
+        final members = game.group!.members.map((p) => p.id).toList();
         for (var playerId in members) {
-          final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
+          final index = gameCounts.indexWhere((entry) => entry.$1 == playerId);
-          // -1 means player not found in matchCounts
+          // -1 means player not found in gameCounts
           if (index != -1) {
-            final current = matchCounts[index].$2;
+            final current = gameCounts[index].$2;
-            matchCounts[index] = (playerId, current + 1);
+            gameCounts[index] = (playerId, current + 1);
           } else {
-            matchCounts.add((playerId, 1));
+            gameCounts.add((playerId, 1));
           }
         }
       }
-      if (match.players != null) {
+      if (game.players != null) {
-        final members = match.players!.map((p) => p.id).toList();
+        final members = game.players!.map((p) => p.id).toList();
         for (var playerId in members) {
-          final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
+          final index = gameCounts.indexWhere((entry) => entry.$1 == playerId);
-          // -1 means player not found in matchCounts
+          // -1 means player not found in gameCounts
           if (index != -1) {
-            final current = matchCounts[index].$2;
+            final current = gameCounts[index].$2;
-            matchCounts[index] = (playerId, current + 1);
+            gameCounts[index] = (playerId, current + 1);
           } else {
-            matchCounts.add((playerId, 1));
+            gameCounts.add((playerId, 1));
           }
         }
       }
     }
 
-    // Adding all players with zero matches
+    // Adding all players with zero games
     for (var player in players) {
-      final index = matchCounts.indexWhere((entry) => entry.$1 == player.id);
+      final index = gameCounts.indexWhere((entry) => entry.$1 == player.id);
-      // -1 means player not found in matchCounts
+      // -1 means player not found in gameCounts
       if (index == -1) {
-        matchCounts.add((player.id, 0));
+        gameCounts.add((player.id, 0));
       }
     }
 
     // Replace player IDs with names
-    for (int i = 0; i < matchCounts.length; i++) {
+    for (int i = 0; i < gameCounts.length; i++) {
-      final playerId = matchCounts[i].$1;
+      final playerId = gameCounts[i].$1;
       final player = players.firstWhere(
         (p) => p.id == playerId,
         orElse: () => Player(id: playerId, name: 'N.a.'),
       );
-      matchCounts[i] = (player.name, matchCounts[i].$2);
+      gameCounts[i] = (player.name, gameCounts[i].$2);
     }
 
-    matchCounts.sort((a, b) => b.$2.compareTo(a.$2));
+    gameCounts.sort((a, b) => b.$2.compareTo(a.$2));
 
-    return matchCounts;
+    return gameCounts;
   }
 
   // dart
   List<(String, double)> computeWinRatePercent({
     required List<(String, int)> wins,
-    required List<(String, int)> matches,
+    required List<(String, int)> games,
   }) {
     final Map<String, int> winsMap = {for (var e in wins) e.$1: e.$2};
-    final Map<String, int> matchesMap = {for (var e in matches) e.$1: e.$2};
+    final Map<String, int> gamesMap = {for (var e in games) e.$1: e.$2};
 
     // Get all unique player names
-    final names = {...winsMap.keys, ...matchesMap.keys};
+    final names = {...winsMap.keys, ...gamesMap.keys};
 
     // Calculate win rates
     final result = names.map((name) {
       final int w = winsMap[name] ?? 0;
-      final int g = matchesMap[name] ?? 0;
+      final int g = gamesMap[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,5 +1,4 @@
 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';
@@ -12,14 +11,12 @@ import 'package:provider/provider.dart';
 
 class PlayerSelection extends StatefulWidget {
   final Function(List<Player> value) onChanged;
-  final List<Player> availablePlayers;
+  final List<Player> initialPlayers;
-  final List<Player>? initialSelectedPlayers;
 
   const PlayerSelection({
     super.key,
     required this.onChanged,
-    this.availablePlayers = const [],
+    this.initialPlayers = const [],
-    this.initialSelectedPlayers,
   });
 
   @override
@@ -30,7 +27,6 @@ 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;
@@ -44,44 +40,27 @@ class _PlayerSelectionState extends State<PlayerSelection> {
   void initState() {
     super.initState();
     db = Provider.of<AppDatabase>(context, listen: false);
-    suggestedPlayers = skeletonData;
     loadPlayerList();
   }
 
   void loadPlayerList() {
-    _allPlayersFuture = Future.wait([
+    _allPlayersFuture = Future.delayed(
-      db.playerDao.getAllPlayers(),
+      const Duration(milliseconds: 250),
-      Future.delayed(minimumSkeletonDuration),
+      () => db.playerDao.getAllPlayers(),
-    ]).then((results) => results[0] as List<Player>);
+    );
-    if (mounted) {
+    suggestedPlayers = skeletonData;
-      _allPlayersFuture.then((loadedPlayers) {
+    _allPlayersFuture.then((loadedPlayers) {
-        setState(() {
+      setState(() {
-          // If a list of available players is provided, use that list.
+        if (widget.initialPlayers.isNotEmpty) {
-          if (widget.availablePlayers.isNotEmpty) {
+          allPlayers = [...widget.initialPlayers];
-            widget.availablePlayers.sort((a, b) => a.name.compareTo(b.name));
+          suggestedPlayers = [...widget.initialPlayers];
-            allPlayers = [...widget.availablePlayers];
+        } else {
-            suggestedPlayers = [...allPlayers];
+          loadedPlayers.sort((a, b) => a.name.compareTo(b.name));
-
+          allPlayers = [...loadedPlayers];
-            if (widget.initialSelectedPlayers != null) {
+          suggestedPlayers = [...loadedPlayers];
-              // 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
@@ -167,44 +146,75 @@ class _PlayerSelectionState extends State<PlayerSelection> {
             style: TextStyle(fontSize: 16, fontWeight: FontWeight.bold),
           ),
           const SizedBox(height: 10),
-          /*
+          FutureBuilder(
-
+            future: _allPlayersFuture,
-           */
+            builder:
-          Expanded(
+                (BuildContext context, AsyncSnapshot<List<Player>> snapshot) {
-            child: AppSkeleton(
+                  if (snapshot.hasError) {
-              enabled: isLoading,
+                    return const Center(
-              child: Visibility(
+                      child: TopCenteredMessage(
-                visible: suggestedPlayers.isNotEmpty,
+                        icon: Icons.report,
-                replacement: TopCenteredMessage(
+                        title: 'Error',
-                  icon: Icons.info,
+                        message: 'Player data couldn\'t\nbe loaded.',
-                  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(
-                      text: suggestedPlayers[index].name,
-                      onPressed: () {
-                        setState(() {
-                          if (!selectedPlayers.contains(
-                            suggestedPlayers[index],
-                          )) {
-                            selectedPlayers.add(suggestedPlayers[index]);
-                            widget.onChanged([...selectedPlayers]);
-                            suggestedPlayers.remove(suggestedPlayers[index]);
-                          }
-                        });
-                      },
                     );
-                  },
+                  }
-                ),
+                  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:
+                            (suggestedPlayers.isEmpty && allPlayers.isNotEmpty),
+                        replacement: ListView.builder(
+                          itemCount: suggestedPlayers.length,
+                          itemBuilder: (BuildContext context, int index) {
+                            return TextIconListTile(
+                              text: suggestedPlayers[index].name,
+                              onPressed: () {
+                                setState(() {
+                                  if (!selectedPlayers.contains(
+                                    suggestedPlayers[index],
+                                  )) {
+                                    selectedPlayers.add(
+                                      suggestedPlayers[index],
+                                    );
+                                    widget.onChanged([...selectedPlayers]);
+                                    suggestedPlayers.remove(
+                                      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: onChanged,
+      onChanged: trailingButtonEnabled ? onChanged : null,
       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/match.dart';
+import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/presentation/widgets/tiles/text_icon_tile.dart';
 import 'package:intl/intl.dart';
 
 class GameHistoryTile extends StatefulWidget {
-  final Match match;
+  final Game game;
   final VoidCallback onTap;
 
-  const GameHistoryTile({super.key, required this.match, required this.onTap});
+  const GameHistoryTile({super.key, required this.game, 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.match.group;
+    final group = widget.game.group;
-    final winner = widget.match.winner;
+    final winner = widget.game.winner;
     final allPlayers = _getAllPlayers();
 
     return GestureDetector(
@@ -39,7 +39,7 @@ class _GameHistoryTileState extends State<GameHistoryTile> {
               children: [
                 Expanded(
                   child: Text(
-                    widget.match.name,
+                    widget.game.name,
                     style: const TextStyle(
                       fontSize: 18,
                       fontWeight: FontWeight.bold,
@@ -48,7 +48,7 @@ class _GameHistoryTileState extends State<GameHistoryTile> {
                   ),
                 ),
                 Text(
-                  _formatDate(widget.match.createdAt),
+                  _formatDate(widget.game.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.match.players != null) {
+    if (widget.game.players != null) {
-      for (var player in widget.match.players!) {
+      for (var player in widget.game.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.match.group?.members != null) {
+    if (widget.game.group?.members != null) {
-      for (var player in widget.match.group!.members) {
+      for (var player in widget.game.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 MatchTile extends StatefulWidget {
+class GameTile extends StatefulWidget {
-  final String matchTitle;
+  final String gameTitle;
-  final String game;
+  final String gameType;
   final String ruleset;
   final String players;
   final String winner;
 
-  const MatchTile({
+  const GameTile({
     super.key,
-    required this.matchTitle,
+    required this.gameTitle,
-    required this.game,
+    required this.gameType,
     required this.ruleset,
     required this.players,
     required this.winner,
   });
 
   @override
-  State<MatchTile> createState() => _MatchTileState();
+  State<GameTile> createState() => _GameTileState();
 }
 
-class _MatchTileState extends State<MatchTile> {
+class _GameTileState extends State<GameTile> {
   @override
   Widget build(BuildContext context) {
     return Column(
@@ -31,12 +31,12 @@ class _MatchTileState extends State<MatchTile> {
         Row(
           children: [
             Text(
-              widget.matchTitle,
+              widget.gameTitle,
               style: const TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
             ),
             const SizedBox(width: 5),
             Text(
-              widget.game,
+              widget.gameType,
               style: const TextStyle(fontSize: 14, color: Colors.grey),
             ),
           ],

lib/presentation/widgets/tiles/ruleset_list_tile.dart

@@ -0,0 +1,55 @@
+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 maxMatches = values.isNotEmpty ? values[0].$2 : 0;
+              final maxGames = values.isNotEmpty ? values[0].$2 : 0;
 
               /// Fraction of wins
-              final double fraction = (maxMatches > 0)
+              final double fraction = (maxGames > 0)
-                  ? (values[index].$2 / maxMatches)
+                  ? (values[index].$2 / maxGames)
                   : 0.0;
 
               /// Calculated width for current the bar

lib/presentation/widgets/tiles/title_description_list_tile.dart

@@ -1,92 +0,0 @@
-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.matchDao.deleteAllMatches();
+    await db.gameDao.deleteAllGames();
     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 matches = await db.matchDao.getAllMatches();
+    final games = await db.gameDao.getAllGames();
     final groups = await db.groupDao.getAllGroups();
     final players = await db.playerDao.getAllPlayers();
 
     // Construct a JSON representation of the data
     final Map<String, dynamic> jsonMap = {
-      'matches': matches.map((match) => match.toJson()).toList(),
+      'games': games.map((game) => game.toJson()).toList(),
       'groups': groups.map((group) => group.toJson()).toList(),
       'players': players.map((player) => player.toJson()).toList(),
     };
@@ -89,15 +89,14 @@ class DataTransferService {
         final Map<String, dynamic> jsonData =
             json.decode(jsonString) as Map<String, dynamic>;
 
-        final List<dynamic>? matchesJson =
+        final List<dynamic>? gamesJson = jsonData['games'] as List<dynamic>?;
-            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<Match> importedMatches =
+        final List<Game> importedGames =
-            matchesJson
+            gamesJson
-                ?.map((g) => Match.fromJson(g as Map<String, dynamic>))
+                ?.map((g) => Game.fromJson(g as Map<String, dynamic>))
                 .toList() ??
             [];
         final List<Group> importedGroups =
@@ -113,7 +112,7 @@ class DataTransferService {
 
         await db.playerDao.addPlayersAsList(players: importedPlayers);
         await db.groupDao.addGroupsAsList(groups: importedGroups);
-        await db.matchDao.addMatchAsList(matches: importedMatches);
+        await db.gameDao.addGamesAsList(games: importedGames);
       } 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,10 +16,10 @@ void main() {
   late Player testPlayer5;
   late Group testGroup1;
   late Group testGroup2;
-  late Match testMatch1;
+  late Game testGame1;
-  late Match testMatch2;
+  late Game testGame2;
-  late Match testMatchOnlyPlayers;
+  late Game testGameOnlyPlayers;
-  late Match testMatchOnlyGroup;
+  late Game testGameOnlyGroup;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
@@ -46,51 +46,46 @@ void main() {
         name: 'Test Group 2',
         members: [testPlayer4, testPlayer5],
       );
-      testMatch1 = Match(
+      testGame1 = Game(
-        name: 'First Test Match',
+        name: 'First Test Game',
         group: testGroup1,
         players: [testPlayer4, testPlayer5],
         winner: testPlayer4,
       );
-      testMatch2 = Match(
+      testGame2 = Game(
-        name: 'Second Test Match',
+        name: 'Second Test Game',
         group: testGroup2,
         players: [testPlayer1, testPlayer2, testPlayer3],
         winner: testPlayer2,
       );
-      testMatchOnlyPlayers = Match(
+      testGameOnlyPlayers = Game(
-        name: 'Test Match with Players',
+        name: 'Test Game with Players',
         players: [testPlayer1, testPlayer2, testPlayer3],
         winner: testPlayer3,
       );
-      testMatchOnlyGroup = Match(
+      testGameOnlyGroup = Game(name: 'Test Game with Group', group: testGroup2);
-        name: 'Test Match with Group',
-        group: testGroup2,
-      );
     });
   });
   tearDown(() async {
     await database.close();
   });
 
-  group('Match Tests', () {
+  group('Game Tests', () {
-    test('Adding and fetching single match works correctly', () async {
+    test('Adding and fetching single game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatch1);
+      await database.gameDao.addGame(game: testGame1);
 
-      final result = await database.matchDao.getMatchById(
+      final result = await database.gameDao.getGameById(gameId: testGame1.id);
-        matchId: testMatch1.id,
-      );
 
-      expect(result.id, testMatch1.id);
+      expect(result.id, testGame1.id);
-      expect(result.name, testMatch1.name);
+      expect(result.name, testGame1.name);
-      expect(result.createdAt, testMatch1.createdAt);
+      expect(result.createdAt, testGame1.createdAt);
 
-      if (result.winner != null && testMatch1.winner != null) {
+      if (result.winner != null && testGame1.winner != null) {
-        expect(result.winner!.id, testMatch1.winner!.id);
+        expect(result.winner!.id, testGame1.winner!.id);
-        expect(result.winner!.name, testMatch1.winner!.name);
+        expect(result.winner!.name, testGame1.winner!.name);
-        expect(result.winner!.createdAt, testMatch1.winner!.createdAt);
+        expect(result.winner!.createdAt, testGame1.winner!.createdAt);
       } else {
-        expect(result.winner, testMatch1.winner);
+        expect(result.winner, testGame1.winner);
       }
 
       if (result.group != null) {
@@ -104,203 +99,188 @@ void main() {
         fail('Group is null');
       }
       if (result.players != null) {
-        expect(result.players!.length, testMatch1.players!.length);
+        expect(result.players!.length, testGame1.players!.length);
 
-        for (int i = 0; i < testMatch1.players!.length; i++) {
+        for (int i = 0; i < testGame1.players!.length; i++) {
-          expect(result.players![i].id, testMatch1.players![i].id);
+          expect(result.players![i].id, testGame1.players![i].id);
-          expect(result.players![i].name, testMatch1.players![i].name);
+          expect(result.players![i].name, testGame1.players![i].name);
-          expect(
+          expect(result.players![i].createdAt, testGame1.players![i].createdAt);
-            result.players![i].createdAt,
-            testMatch1.players![i].createdAt,
-          );
         }
       } else {
         fail('Players is null');
       }
     });
 
-    test('Adding and fetching multiple matches works correctly', () async {
+    test('Adding and fetching multiple games works correctly', () async {
-      await database.matchDao.addMatchAsList(
+      await database.gameDao.addGamesAsList(
-        matches: [
+        games: [testGame1, testGame2, testGameOnlyGroup, testGameOnlyPlayers],
-          testMatch1,
-          testMatch2,
-          testMatchOnlyGroup,
-          testMatchOnlyPlayers,
-        ],
       );
 
-      final allMatches = await database.matchDao.getAllMatches();
+      final allGames = await database.gameDao.getAllGames();
-      expect(allMatches.length, 4);
+      expect(allGames.length, 4);
 
-      final testMatches = {
+      final testGames = {
-        testMatch1.id: testMatch1,
+        testGame1.id: testGame1,
-        testMatch2.id: testMatch2,
+        testGame2.id: testGame2,
-        testMatchOnlyGroup.id: testMatchOnlyGroup,
+        testGameOnlyGroup.id: testGameOnlyGroup,
-        testMatchOnlyPlayers.id: testMatchOnlyPlayers,
+        testGameOnlyPlayers.id: testGameOnlyPlayers,
       };
 
-      for (final match in allMatches) {
+      for (final game in allGames) {
-        final testMatch = testMatches[match.id]!;
+        final testGame = testGames[game.id]!;
 
-        // Match-Checks
+        // Game-Checks
-        expect(match.id, testMatch.id);
+        expect(game.id, testGame.id);
-        expect(match.name, testMatch.name);
+        expect(game.name, testGame.name);
-        expect(match.createdAt, testMatch.createdAt);
+        expect(game.createdAt, testGame.createdAt);
-        if (match.winner != null && testMatch.winner != null) {
+        if (game.winner != null && testGame.winner != null) {
-          expect(match.winner!.id, testMatch.winner!.id);
+          expect(game.winner!.id, testGame.winner!.id);
-          expect(match.winner!.name, testMatch.winner!.name);
+          expect(game.winner!.name, testGame.winner!.name);
-          expect(match.winner!.createdAt, testMatch.winner!.createdAt);
+          expect(game.winner!.createdAt, testGame.winner!.createdAt);
         } else {
-          expect(match.winner, testMatch.winner);
+          expect(game.winner, testGame.winner);
         }
 
         // Group-Checks
-        if (testMatch.group != null) {
+        if (testGame.group != null) {
-          expect(match.group!.id, testMatch.group!.id);
+          expect(game.group!.id, testGame.group!.id);
-          expect(match.group!.name, testMatch.group!.name);
+          expect(game.group!.name, testGame.group!.name);
-          expect(match.group!.createdAt, testMatch.group!.createdAt);
+          expect(game.group!.createdAt, testGame.group!.createdAt);
 
           // Group Members-Checks
-          expect(match.group!.members.length, testMatch.group!.members.length);
+          expect(game.group!.members.length, testGame.group!.members.length);
-          for (int i = 0; i < testMatch.group!.members.length; i++) {
+          for (int i = 0; i < testGame.group!.members.length; i++) {
-            expect(match.group!.members[i].id, testMatch.group!.members[i].id);
+            expect(game.group!.members[i].id, testGame.group!.members[i].id);
             expect(
-              match.group!.members[i].name,
+              game.group!.members[i].name,
-              testMatch.group!.members[i].name,
+              testGame.group!.members[i].name,
             );
             expect(
-              match.group!.members[i].createdAt,
+              game.group!.members[i].createdAt,
-              testMatch.group!.members[i].createdAt,
+              testGame.group!.members[i].createdAt,
             );
           }
         } else {
-          expect(match.group, null);
+          expect(game.group, null);
         }
 
         // Players-Checks
-        if (testMatch.players != null) {
+        if (testGame.players != null) {
-          expect(match.players!.length, testMatch.players!.length);
+          expect(game.players!.length, testGame.players!.length);
-          for (int i = 0; i < testMatch.players!.length; i++) {
+          for (int i = 0; i < testGame.players!.length; i++) {
-            expect(match.players![i].id, testMatch.players![i].id);
+            expect(game.players![i].id, testGame.players![i].id);
-            expect(match.players![i].name, testMatch.players![i].name);
+            expect(game.players![i].name, testGame.players![i].name);
-            expect(
+            expect(game.players![i].createdAt, testGame.players![i].createdAt);
-              match.players![i].createdAt,
-              testMatch.players![i].createdAt,
-            );
           }
         } else {
-          expect(match.players, null);
+          expect(game.players, null);
         }
       }
     });
 
-    test('Adding the same match twice does not create duplicates', () async {
+    test('Adding the same game twice does not create duplicates', () async {
-      await database.matchDao.addMatch(match: testMatch1);
+      await database.gameDao.addGame(game: testGame1);
-      await database.matchDao.addMatch(match: testMatch1);
+      await database.gameDao.addGame(game: testGame1);
 
-      final matchCount = await database.matchDao.getMatchCount();
+      final gameCount = await database.gameDao.getGameCount();
-      expect(matchCount, 1);
+      expect(gameCount, 1);
     });
 
-    test('Match existence check works correctly', () async {
+    test('Game existence check works correctly', () async {
-      var matchExists = await database.matchDao.matchExists(
+      var gameExists = await database.gameDao.gameExists(gameId: testGame1.id);
-        matchId: testMatch1.id,
+      expect(gameExists, false);
+
+      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(matchExists, false);
+      expect(gameDeleted, true);
 
-      await database.matchDao.addMatch(match: testMatch1);
+      final gameExists = await database.gameDao.gameExists(
-
+        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(matchDeleted, true);
+      expect(gameExists, false);
-
-      final matchExists = await database.matchDao.matchExists(
-        matchId: testMatch1.id,
-      );
-      expect(matchExists, false);
     });
 
-    test('Getting the match count works correctly', () async {
+    test('Getting the game count works correctly', () async {
-      var matchCount = await database.matchDao.getMatchCount();
+      var gameCount = await database.gameDao.getGameCount();
-      expect(matchCount, 0);
+      expect(gameCount, 0);
 
-      await database.matchDao.addMatch(match: testMatch1);
+      await database.gameDao.addGame(game: testGame1);
 
-      matchCount = await database.matchDao.getMatchCount();
+      gameCount = await database.gameDao.getGameCount();
-      expect(matchCount, 1);
+      expect(gameCount, 1);
 
-      await database.matchDao.addMatch(match: testMatch2);
+      await database.gameDao.addGame(game: testGame2);
 
-      matchCount = await database.matchDao.getMatchCount();
+      gameCount = await database.gameDao.getGameCount();
-      expect(matchCount, 2);
+      expect(gameCount, 2);
 
-      await database.matchDao.deleteMatch(matchId: testMatch1.id);
+      await database.gameDao.deleteGame(gameId: testGame1.id);
 
-      matchCount = await database.matchDao.getMatchCount();
+      gameCount = await database.gameDao.getGameCount();
-      expect(matchCount, 1);
+      expect(gameCount, 1);
 
-      await database.matchDao.deleteMatch(matchId: testMatch2.id);
+      await database.gameDao.deleteGame(gameId: testGame2.id);
 
-      matchCount = await database.matchDao.getMatchCount();
+      gameCount = await database.gameDao.getGameCount();
-      expect(matchCount, 0);
+      expect(gameCount, 0);
     });
 
-    test('Checking if match has winner works correclty', () async {
+    test('Checking if game has winner works correclty', () async {
-      await database.matchDao.addMatch(match: testMatch1);
+      await database.gameDao.addGame(game: testGame1);
-      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.gameDao.addGame(game: testGameOnlyGroup);
 
-      var hasWinner = await database.matchDao.hasWinner(matchId: testMatch1.id);
+      var hasWinner = await database.gameDao.hasWinner(gameId: testGame1.id);
       expect(hasWinner, true);
 
-      hasWinner = await database.matchDao.hasWinner(
+      hasWinner = await database.gameDao.hasWinner(
-        matchId: testMatchOnlyGroup.id,
+        gameId: testGameOnlyGroup.id,
       );
       expect(hasWinner, false);
     });
 
-    test('Fetching the winner of a match works correctly', () async {
+    test('Fetching the winner of a game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatch1);
+      await database.gameDao.addGame(game: testGame1);
 
-      final winner = await database.matchDao.getWinner(matchId: testMatch1.id);
+      final winner = await database.gameDao.getWinner(gameId: testGame1.id);
       if (winner == null) {
         fail('Winner is null');
       } else {
-        expect(winner.id, testMatch1.winner!.id);
+        expect(winner.id, testGame1.winner!.id);
-        expect(winner.name, testMatch1.winner!.name);
+        expect(winner.name, testGame1.winner!.name);
-        expect(winner.createdAt, testMatch1.winner!.createdAt);
+        expect(winner.createdAt, testGame1.winner!.createdAt);
       }
     });
 
-    test('Updating the winner of a match works correctly', () async {
+    test('Updating the winner of a game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatch1);
+      await database.gameDao.addGame(game: testGame1);
 
-      final winner = await database.matchDao.getWinner(matchId: testMatch1.id);
+      final winner = await database.gameDao.getWinner(gameId: testGame1.id);
       if (winner == null) {
         fail('Winner is null');
       } else {
-        expect(winner.id, testMatch1.winner!.id);
+        expect(winner.id, testGame1.winner!.id);
-        expect(winner.name, testMatch1.winner!.name);
+        expect(winner.name, testGame1.winner!.name);
-        expect(winner.createdAt, testMatch1.winner!.createdAt);
+        expect(winner.createdAt, testGame1.winner!.createdAt);
         expect(winner.id, testPlayer4.id);
         expect(winner.id != testPlayer5.id, true);
       }
 
-      await database.matchDao.setWinner(
+      await database.gameDao.setWinner(
-        matchId: testMatch1.id,
+        gameId: testGame1.id,
         winnerId: testPlayer5.id,
       );
 
-      final newWinner = await database.matchDao.getWinner(
+      final newWinner = await database.gameDao.getWinner(gameId: testGame1.id);
-        matchId: testMatch1.id,
-      );
 
       if (newWinner == null) {
         fail('New winner is null');
@@ -312,41 +292,39 @@ void main() {
     });
 
     test('Removing a winner works correctly', () async {
-      await database.matchDao.addMatch(match: testMatch2);
+      await database.gameDao.addGame(game: testGame2);
 
-      var hasWinner = await database.matchDao.hasWinner(matchId: testMatch2.id);
+      var hasWinner = await database.gameDao.hasWinner(gameId: testGame2.id);
       expect(hasWinner, true);
 
-      await database.matchDao.removeWinner(matchId: testMatch2.id);
+      await database.gameDao.removeWinner(gameId: testGame2.id);
 
-      hasWinner = await database.matchDao.hasWinner(matchId: testMatch2.id);
+      hasWinner = await database.gameDao.hasWinner(gameId: testGame2.id);
       expect(hasWinner, false);
 
-      final removedWinner = await database.matchDao.getWinner(
+      final removedWinner = await database.gameDao.getWinner(
-        matchId: testMatch2.id,
+        gameId: testGame2.id,
       );
 
       expect(removedWinner, null);
     });
 
-    test('Renaming a match works correctly', () async {
+    test('Renaming a game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatch1);
+      await database.gameDao.addGame(game: testGame1);
 
-      var fetchedMatch = await database.matchDao.getMatchById(
+      var fetchedGame = await database.gameDao.getGameById(
-        matchId: testMatch1.id,
+        gameId: testGame1.id,
       );
-      expect(fetchedMatch.name, testMatch1.name);
+      expect(fetchedGame.name, testGame1.name);
 
-      const newName = 'Updated Match Name';
+      const newName = 'Updated Game Name';
-      await database.matchDao.updateMatchName(
+      await database.gameDao.updateGameName(
-        matchId: testMatch1.id,
+        gameId: testGame1.id,
         newName: newName,
       );
 
-      fetchedMatch = await database.matchDao.getMatchById(
+      fetchedGame = await database.gameDao.getGameById(gameId: testGame1.id);
-        matchId: testMatch1.id,
+      expect(fetchedGame.name, newName);
-      );
-      expect(fetchedMatch.name, newName);
     });
   });
 }

test/db_tests/group_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,8 +16,8 @@ void main() {
   late Player testPlayer5;
   late Group testGroup1;
   late Group testGroup2;
-  late Match testMatchWithGroup;
+  late Game testgameWithGroup;
-  late Match testMatchWithPlayers;
+  late Game testgameWithPlayers;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
@@ -44,84 +44,81 @@ void main() {
         name: 'Test Group',
         members: [testPlayer3, testPlayer2],
       );
-      testMatchWithPlayers = Match(
+      testgameWithPlayers = Game(
-        name: 'Test Match with Players',
+        name: 'Test Game with Players',
         players: [testPlayer4, testPlayer5],
       );
-      testMatchWithGroup = Match(
+      testgameWithGroup = Game(name: 'Test Game with Group', group: testGroup1);
-        name: 'Test Match with Group',
-        group: testGroup1,
-      );
     });
   });
   tearDown(() async {
     await database.close();
   });
-  group('Group-Match Tests', () {
+  group('Group-Game Tests', () {
-    test('matchHasGroup() has group works correctly', () async {
+    test('Game has group works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchWithPlayers);
+      await database.gameDao.addGame(game: testgameWithPlayers);
       await database.groupDao.addGroup(group: testGroup1);
 
-      var matchHasGroup = await database.groupMatchDao.matchHasGroup(
+      var gameHasGroup = await database.groupGameDao.gameHasGroup(
-        matchId: testMatchWithPlayers.id,
+        gameId: testgameWithPlayers.id,
       );
 
-      expect(matchHasGroup, false);
+      expect(gameHasGroup, false);
 
-      await database.groupMatchDao.addGroupToMatch(
+      await database.groupGameDao.addGroupToGame(
-        matchId: testMatchWithPlayers.id,
+        gameId: testgameWithPlayers.id,
         groupId: testGroup1.id,
       );
 
-      matchHasGroup = await database.groupMatchDao.matchHasGroup(
+      gameHasGroup = await database.groupGameDao.gameHasGroup(
-        matchId: testMatchWithPlayers.id,
+        gameId: testgameWithPlayers.id,
       );
 
-      expect(matchHasGroup, true);
+      expect(gameHasGroup, true);
     });
 
-    test('Adding a group to a match works correctly', () async {
+    test('Adding a group to a game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchWithPlayers);
+      await database.gameDao.addGame(game: testgameWithPlayers);
       await database.groupDao.addGroup(group: testGroup1);
-      await database.groupMatchDao.addGroupToMatch(
+      await database.groupGameDao.addGroupToGame(
-        matchId: testMatchWithPlayers.id,
+        gameId: testgameWithPlayers.id,
         groupId: testGroup1.id,
       );
 
-      var groupAdded = await database.groupMatchDao.isGroupInMatch(
+      var groupAdded = await database.groupGameDao.isGroupInGame(
-        matchId: testMatchWithPlayers.id,
+        gameId: testgameWithPlayers.id,
         groupId: testGroup1.id,
       );
       expect(groupAdded, true);
 
-      groupAdded = await database.groupMatchDao.isGroupInMatch(
+      groupAdded = await database.groupGameDao.isGroupInGame(
-        matchId: testMatchWithPlayers.id,
+        gameId: testgameWithPlayers.id,
         groupId: '',
       );
       expect(groupAdded, false);
     });
 
-    test('Removing group from match works correctly', () async {
+    test('Removing group from game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchWithGroup);
+      await database.gameDao.addGame(game: testgameWithGroup);
 
-      final groupToRemove = testMatchWithGroup.group!;
+      final groupToRemove = testgameWithGroup.group!;
 
-      final removed = await database.groupMatchDao.removeGroupFromMatch(
+      final removed = await database.groupGameDao.removeGroupFromGame(
         groupId: groupToRemove.id,
-        matchId: testMatchWithGroup.id,
+        gameId: testgameWithGroup.id,
       );
       expect(removed, true);
 
-      final result = await database.matchDao.getMatchById(
+      final result = await database.gameDao.getGameById(
-        matchId: testMatchWithGroup.id,
+        gameId: testgameWithGroup.id,
       );
       expect(result.group, null);
     });
 
-    test('Retrieving group of a match works correctly', () async {
+    test('Retrieving group of a game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchWithGroup);
+      await database.gameDao.addGame(game: testgameWithGroup);
-      final group = await database.groupMatchDao.getGroupOfMatch(
+      final group = await database.groupGameDao.getGroupOfGame(
-        matchId: testMatchWithGroup.id,
+        gameId: testgameWithGroup.id,
       );
 
       if (group == null) {
@@ -139,11 +136,11 @@ void main() {
       }
     });
 
-    test('Updating the group of a match works correctly', () async {
+    test('Updating the group of a game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchWithGroup);
+      await database.gameDao.addGame(game: testgameWithGroup);
 
-      var group = await database.groupMatchDao.getGroupOfMatch(
+      var group = await database.groupGameDao.getGroupOfGame(
-        matchId: testMatchWithGroup.id,
+        gameId: testgameWithGroup.id,
       );
 
       if (group == null) {
@@ -156,13 +153,13 @@ void main() {
       }
 
       await database.groupDao.addGroup(group: testGroup2);
-      await database.groupMatchDao.updateGroupOfMatch(
+      await database.groupGameDao.updateGroupOfGame(
-        matchId: testMatchWithGroup.id,
+        gameId: testgameWithGroup.id,
         newGroupId: testGroup2.id,
       );
 
-      group = await database.groupMatchDao.getGroupOfMatch(
+      group = await database.groupGameDao.getGroupOfGame(
-        matchId: testMatchWithGroup.id,
+        gameId: testgameWithGroup.id,
       );
 
       if (group == null) {

test/db_tests/player_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,8 +16,8 @@ void main() {
   late Player testPlayer5;
   late Player testPlayer6;
   late Group testgroup;
-  late Match testMatchOnlyGroup;
+  late Game testGameOnlyGroup;
-  late Match testMatchOnlyPlayers;
+  late Game testGameOnlyPlayers;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
@@ -41,12 +41,9 @@ void main() {
         name: 'Test Group',
         members: [testPlayer1, testPlayer2, testPlayer3],
       );
-      testMatchOnlyGroup = Match(
+      testGameOnlyGroup = Game(name: 'Test Game with Group', group: testgroup);
-        name: 'Test Match with Group',
+      testGameOnlyPlayers = Game(
-        group: testgroup,
+        name: 'Test Game with Players',
-      );
-      testMatchOnlyPlayers = Match(
-        name: 'Test Match with Players',
         players: [testPlayer4, testPlayer5, testPlayer6],
       );
     });
@@ -55,67 +52,67 @@ void main() {
     await database.close();
   });
 
-  group('Player-Match Tests', () {
+  group('Player-Game Tests', () {
-    test('Match has player works correctly', () async {
+    test('Game has player works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.gameDao.addGame(game: testGameOnlyGroup);
       await database.playerDao.addPlayer(player: testPlayer1);
 
-      var matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
+      var gameHasPlayers = await database.playerGameDao.gameHasPlayers(
-        matchId: testMatchOnlyGroup.id,
+        gameId: testGameOnlyGroup.id,
       );
 
-      expect(matchHasPlayers, false);
+      expect(gameHasPlayers, false);
 
-      await database.playerMatchDao.addPlayerToMatch(
+      await database.playerGameDao.addPlayerToGame(
-        matchId: testMatchOnlyGroup.id,
+        gameId: testGameOnlyGroup.id,
         playerId: testPlayer1.id,
       );
 
-      matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
+      gameHasPlayers = await database.playerGameDao.gameHasPlayers(
-        matchId: testMatchOnlyGroup.id,
+        gameId: testGameOnlyGroup.id,
       );
 
-      expect(matchHasPlayers, true);
+      expect(gameHasPlayers, true);
     });
 
-    test('Adding a player to a match works correctly', () async {
+    test('Adding a player to a game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyGroup);
+      await database.gameDao.addGame(game: testGameOnlyGroup);
       await database.playerDao.addPlayer(player: testPlayer5);
-      await database.playerMatchDao.addPlayerToMatch(
+      await database.playerGameDao.addPlayerToGame(
-        matchId: testMatchOnlyGroup.id,
+        gameId: testGameOnlyGroup.id,
         playerId: testPlayer5.id,
       );
 
-      var playerAdded = await database.playerMatchDao.isPlayerInMatch(
+      var playerAdded = await database.playerGameDao.isPlayerInGame(
-        matchId: testMatchOnlyGroup.id,
+        gameId: testGameOnlyGroup.id,
         playerId: testPlayer5.id,
       );
 
       expect(playerAdded, true);
 
-      playerAdded = await database.playerMatchDao.isPlayerInMatch(
+      playerAdded = await database.playerGameDao.isPlayerInGame(
-        matchId: testMatchOnlyGroup.id,
+        gameId: testGameOnlyGroup.id,
         playerId: '',
       );
 
       expect(playerAdded, false);
     });
 
-    test('Removing player from match works correctly', () async {
+    test('Removing player from game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+      await database.gameDao.addGame(game: testGameOnlyPlayers);
 
-      final playerToRemove = testMatchOnlyPlayers.players![0];
+      final playerToRemove = testGameOnlyPlayers.players![0];
 
-      final removed = await database.playerMatchDao.removePlayerFromMatch(
+      final removed = await database.playerGameDao.removePlayerFromGame(
         playerId: playerToRemove.id,
-        matchId: testMatchOnlyPlayers.id,
+        gameId: testGameOnlyPlayers.id,
       );
       expect(removed, true);
 
-      final result = await database.matchDao.getMatchById(
+      final result = await database.gameDao.getGameById(
-        matchId: testMatchOnlyPlayers.id,
+        gameId: testGameOnlyPlayers.id,
       );
-      expect(result.players!.length, testMatchOnlyPlayers.players!.length - 1);
+      expect(result.players!.length, testGameOnlyPlayers.players!.length - 1);
 
       final playerExists = result.players!.any(
         (p) => p.id == playerToRemove.id,
@@ -123,10 +120,10 @@ void main() {
       expect(playerExists, false);
     });
 
-    test('Retrieving players of a match works correctly', () async {
+    test('Retrieving players of a game works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+      await database.gameDao.addGame(game: testGameOnlyPlayers);
-      final players = await database.playerMatchDao.getPlayersOfMatch(
+      final players = await database.playerGameDao.getPlayersOfGame(
-        matchId: testMatchOnlyPlayers.id,
+        gameId: testGameOnlyPlayers.id,
       );
 
       if (players == null) {
@@ -134,37 +131,34 @@ void main() {
       }
 
       for (int i = 0; i < players.length; i++) {
-        expect(players[i].id, testMatchOnlyPlayers.players![i].id);
+        expect(players[i].id, testGameOnlyPlayers.players![i].id);
-        expect(players[i].name, testMatchOnlyPlayers.players![i].name);
+        expect(players[i].name, testGameOnlyPlayers.players![i].name);
-        expect(
+        expect(players[i].createdAt, testGameOnlyPlayers.players![i].createdAt);
-          players[i].createdAt,
-          testMatchOnlyPlayers.players![i].createdAt,
-        );
       }
     });
 
-    test('Updating the match players works coreclty', () async {
+    test('Updating the games players works coreclty', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+      await database.gameDao.addGame(game: testGameOnlyPlayers);
 
       final newPlayers = [testPlayer1, testPlayer2, testPlayer4];
       await database.playerDao.addPlayersAsList(players: newPlayers);
 
       // First, remove all existing players
-      final existingPlayers = await database.playerMatchDao.getPlayersOfMatch(
+      final existingPlayers = await database.playerGameDao.getPlayersOfGame(
-        matchId: testMatchOnlyPlayers.id,
+        gameId: testGameOnlyPlayers.id,
       );
 
       if (existingPlayers == null || existingPlayers.isEmpty) {
         fail('Existing players should not be null or empty');
       }
 
-      await database.playerMatchDao.updatePlayersFromMatch(
+      await database.playerGameDao.updatePlayersFromGame(
-        matchId: testMatchOnlyPlayers.id,
+        gameId: testGameOnlyPlayers.id,
         newPlayer: newPlayers,
       );
 
-      final updatedPlayers = await database.playerMatchDao.getPlayersOfMatch(
+      final updatedPlayers = await database.playerGameDao.getPlayersOfGame(
-        matchId: testMatchOnlyPlayers.id,
+        gameId: testGameOnlyPlayers.id,
       );
 
       if (updatedPlayers == null) {