diff --git a/lib/core/enums.dart b/lib/core/enums.dart
index 68752fb..737882e 100644
--- a/lib/core/enums.dart
+++ b/lib/core/enums.dart
@@ -23,9 +23,9 @@ enum ImportResult {
 /// - [ExportResult.unknownException]: An exception occurred during export.
 enum ExportResult { success, canceled, unknownException }
 
-/// Different rulesets available for games
-/// - [Ruleset.singleWinner]: The game is won by a single player
-/// - [Ruleset.singleLoser]: The game is lost by a single player
+/// Different rulesets available for matches
+/// - [Ruleset.singleWinner]: The match is won by a single player
+/// - [Ruleset.singleLoser]: The match is lost by a single player
 /// - [Ruleset.mostPoints]: The player with the most points wins.
 /// - [Ruleset.leastPoints]: The player with the fewest points wins.
 enum Ruleset { singleWinner, singleLoser, mostPoints, leastPoints }
diff --git a/lib/data/dao/game_dao.dart b/lib/data/dao/game_dao.dart
deleted file mode 100644
index c941499..0000000
--- a/lib/data/dao/game_dao.dart
+++ /dev/null
@@ -1,320 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/db/tables/game_table.dart';
-import 'package:game_tracker/data/dto/game.dart';
-import 'package:game_tracker/data/dto/group.dart';
-import 'package:game_tracker/data/dto/player.dart';
-
-part 'game_dao.g.dart';
-
-@DriftAccessor(tables: [GameTable])
-class GameDao extends DatabaseAccessor<AppDatabase> with _$GameDaoMixin {
-  GameDao(super.db);
-
-  /// Retrieves all games from the database.
-  Future<List<Game>> getAllGames() async {
-    final query = select(gameTable);
-    final result = await query.get();
-
-    return Future.wait(
-      result.map((row) async {
-        final group = await db.groupGameDao.getGroupOfGame(gameId: row.id);
-        final players = await db.playerGameDao.getPlayersOfGame(gameId: row.id);
-        final winner = row.winnerId != null
-            ? await db.playerDao.getPlayerById(playerId: row.winnerId!)
-            : null;
-        return Game(
-          id: row.id,
-          name: row.name,
-          group: group,
-          players: players,
-          createdAt: row.createdAt,
-          winner: winner,
-        );
-      }),
-    );
-  }
-
-  /// Retrieves a [Game] by its [gameId].
-  Future<Game> getGameById({required String gameId}) async {
-    final query = select(gameTable)..where((g) => g.id.equals(gameId));
-    final result = await query.getSingle();
-
-    List<Player>? players;
-    if (await db.playerGameDao.gameHasPlayers(gameId: gameId)) {
-      players = await db.playerGameDao.getPlayersOfGame(gameId: gameId);
-    }
-    Group? group;
-    if (await db.groupGameDao.gameHasGroup(gameId: gameId)) {
-      group = await db.groupGameDao.getGroupOfGame(gameId: gameId);
-    }
-    Player? winner;
-    if (result.winnerId != null) {
-      winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
-    }
-
-    return Game(
-      id: result.id,
-      name: result.name,
-      players: players,
-      group: group,
-      winner: winner,
-      createdAt: result.createdAt,
-    );
-  }
-
-  /// Adds a new [Game] to the database.
-  /// Also adds associated players and group if they exist.
-  Future<void> addGame({required Game game}) async {
-    await db.transaction(() async {
-      await into(gameTable).insert(
-        GameTableCompanion.insert(
-          id: game.id,
-          name: game.name,
-          winnerId: Value(game.winner?.id),
-          createdAt: game.createdAt,
-        ),
-        mode: InsertMode.insertOrReplace,
-      );
-
-      if (game.players != null) {
-        await db.playerDao.addPlayersAsList(players: game.players!);
-        for (final p in game.players ?? []) {
-          await db.playerGameDao.addPlayerToGame(
-            gameId: game.id,
-            playerId: p.id,
-          );
-        }
-      }
-
-      if (game.group != null) {
-        await db.groupDao.addGroup(group: game.group!);
-        await db.groupGameDao.addGroupToGame(
-          gameId: game.id,
-          groupId: game.group!.id,
-        );
-      }
-    });
-  }
-
-  /// Adds multiple [Game]s to the database in a batch operation.
-  /// Also adds associated players and groups if they exist.
-  /// If the [games] list is empty, the method returns immediately.
-  Future<void> addGamesAsList({required List<Game> games}) async {
-    if (games.isEmpty) return;
-    await db.transaction(() async {
-      // Add all games in batch
-      await db.batch(
-        (b) => b.insertAll(
-          gameTable,
-          games
-              .map(
-                (game) => GameTableCompanion.insert(
-                  id: game.id,
-                  name: game.name,
-                  createdAt: game.createdAt,
-                  winnerId: Value(game.winner?.id),
-                ),
-              )
-              .toList(),
-          mode: InsertMode.insertOrReplace,
-        ),
-      );
-
-      // Add all groups of the games in batch
-      await db.batch(
-        (b) => b.insertAll(
-          db.groupTable,
-          games
-              .where((game) => game.group != null)
-              .map(
-                (game) => GroupTableCompanion.insert(
-                  id: game.group!.id,
-                  name: game.group!.name,
-                  createdAt: game.group!.createdAt,
-                ),
-              )
-              .toList(),
-          mode: InsertMode.insertOrReplace,
-        ),
-      );
-
-      // Add all players of the games in batch (unique)
-      final uniquePlayers = <String, Player>{};
-      for (final game in games) {
-        if (game.players != null) {
-          for (final p in game.players!) {
-            uniquePlayers[p.id] = p;
-          }
-        }
-        // Also include members of groups
-        if (game.group != null) {
-          for (final m in game.group!.members) {
-            uniquePlayers[m.id] = m;
-          }
-        }
-      }
-
-      if (uniquePlayers.isNotEmpty) {
-        await db.batch(
-          (b) => b.insertAll(
-            db.playerTable,
-            uniquePlayers.values
-                .map(
-                  (p) => PlayerTableCompanion.insert(
-                    id: p.id,
-                    name: p.name,
-                    createdAt: p.createdAt,
-                  ),
-                )
-                .toList(),
-            mode: InsertMode.insertOrReplace,
-          ),
-        );
-      }
-
-      // Add all player-game associations in batch
-      await db.batch((b) {
-        for (final game in games) {
-          if (game.players != null) {
-            for (final p in game.players ?? []) {
-              b.insert(
-                db.playerGameTable,
-                PlayerGameTableCompanion.insert(
-                  gameId: game.id,
-                  playerId: p.id,
-                ),
-                mode: InsertMode.insertOrReplace,
-              );
-            }
-          }
-        }
-      });
-
-      // Add all player-group associations in batch
-      await db.batch((b) {
-        for (final game in games) {
-          if (game.group != null) {
-            for (final m in game.group!.members) {
-              b.insert(
-                db.playerGroupTable,
-                PlayerGroupTableCompanion.insert(
-                  playerId: m.id,
-                  groupId: game.group!.id,
-                ),
-                mode: InsertMode.insertOrReplace,
-              );
-            }
-          }
-        }
-      });
-
-      // Add all group-game associations in batch
-      await db.batch((b) {
-        for (final game in games) {
-          if (game.group != null) {
-            b.insert(
-              db.groupGameTable,
-              GroupGameTableCompanion.insert(
-                gameId: game.id,
-                groupId: game.group!.id,
-              ),
-              mode: InsertMode.insertOrReplace,
-            );
-          }
-        }
-      });
-    });
-  }
-
-  /// Deletes the game with the given [gameId] from the database.
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> deleteGame({required String gameId}) async {
-    final query = delete(gameTable)..where((g) => g.id.equals(gameId));
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Retrieves the number of games in the database.
-  Future<int> getGameCount() async {
-    final count =
-        await (selectOnly(gameTable)..addColumns([gameTable.id.count()]))
-            .map((row) => row.read(gameTable.id.count()))
-            .getSingle();
-    return count ?? 0;
-  }
-
-  /// Checks if a game with the given [gameId] exists in the database.
-  /// Returns `true` if the game exists, otherwise `false`.
-  Future<bool> gameExists({required String gameId}) async {
-    final query = select(gameTable)..where((g) => g.id.equals(gameId));
-    final result = await query.getSingleOrNull();
-    return result != null;
-  }
-
-  /// Deletes all games from the database.
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> deleteAllGames() async {
-    final query = delete(gameTable);
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Sets the winner of the game with the given [gameId] to the player with
-  /// the given [winnerId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> setWinner({
-    required String gameId,
-    required String winnerId,
-  }) async {
-    final query = update(gameTable)..where((g) => g.id.equals(gameId));
-    final rowsAffected = await query.write(
-      GameTableCompanion(winnerId: Value(winnerId)),
-    );
-    return rowsAffected > 0;
-  }
-
-  /// Retrieves the winner of the game with the given [gameId].
-  /// Returns the [Player] who won the game, or `null` if no winner is set.
-  Future<Player?> getWinner({required String gameId}) async {
-    final query = select(gameTable)..where((g) => g.id.equals(gameId));
-    final result = await query.getSingleOrNull();
-    if (result == null || result.winnerId == null) {
-      return null;
-    }
-    final winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
-    return winner;
-  }
-
-  /// Removes the winner of the game with the given [gameId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> removeWinner({required String gameId}) async {
-    final query = update(gameTable)..where((g) => g.id.equals(gameId));
-    final rowsAffected = await query.write(
-      const GameTableCompanion(winnerId: Value(null)),
-    );
-    return rowsAffected > 0;
-  }
-
-  /// Checks if the game with the given [gameId] has a winner set.
-  /// Returns `true` if a winner is set, otherwise `false`.
-  Future<bool> hasWinner({required String gameId}) async {
-    final query = select(gameTable)
-      ..where((g) => g.id.equals(gameId) & g.winnerId.isNotNull());
-    final result = await query.getSingleOrNull();
-    return result != null;
-  }
-
-  /// Changes the title of the game with the given [gameId] to [newName].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> updateGameName({
-    required String gameId,
-    required String newName,
-  }) async {
-    final query = update(gameTable)..where((g) => g.id.equals(gameId));
-    final rowsAffected = await query.write(
-      GameTableCompanion(name: Value(newName)),
-    );
-    return rowsAffected > 0;
-  }
-}
diff --git a/lib/data/dao/game_dao.g.dart b/lib/data/dao/game_dao.g.dart
deleted file mode 100644
index b5a29fe..0000000
--- a/lib/data/dao/game_dao.g.dart
+++ /dev/null
@@ -1,8 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'game_dao.dart';
-
-// ignore_for_file: type=lint
-mixin _$GameDaoMixin on DatabaseAccessor<AppDatabase> {
-  $GameTableTable get gameTable => attachedDatabase.gameTable;
-}
diff --git a/lib/data/dao/group_dao.dart b/lib/data/dao/group_dao.dart
index 643bc88..9802203 100644
--- a/lib/data/dao/group_dao.dart
+++ b/lib/data/dao/group_dao.dart
@@ -1,12 +1,13 @@
 import 'package:drift/drift.dart';
 import 'package:game_tracker/data/db/database.dart';
 import 'package:game_tracker/data/db/tables/group_table.dart';
+import 'package:game_tracker/data/db/tables/player_group_table.dart';
 import 'package:game_tracker/data/dto/group.dart';
 import 'package:game_tracker/data/dto/player.dart';
 
 part 'group_dao.g.dart';
 
-@DriftAccessor(tables: [GroupTable])
+@DriftAccessor(tables: [GroupTable, PlayerGroupTable])
 class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
   GroupDao(super.db);
 
diff --git a/lib/data/dao/group_dao.g.dart b/lib/data/dao/group_dao.g.dart
index 4a09208..b9534b4 100644
--- a/lib/data/dao/group_dao.g.dart
+++ b/lib/data/dao/group_dao.g.dart
@@ -5,4 +5,7 @@ part of 'group_dao.dart';
 // ignore_for_file: type=lint
 mixin _$GroupDaoMixin on DatabaseAccessor<AppDatabase> {
   $GroupTableTable get groupTable => attachedDatabase.groupTable;
+  $PlayerTableTable get playerTable => attachedDatabase.playerTable;
+  $PlayerGroupTableTable get playerGroupTable =>
+      attachedDatabase.playerGroupTable;
 }
diff --git a/lib/data/dao/group_game_dao.dart b/lib/data/dao/group_game_dao.dart
deleted file mode 100644
index da95607..0000000
--- a/lib/data/dao/group_game_dao.dart
+++ /dev/null
@@ -1,98 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/db/tables/group_game_table.dart';
-import 'package:game_tracker/data/dto/group.dart';
-
-part 'group_game_dao.g.dart';
-
-@DriftAccessor(tables: [GroupGameTable])
-class GroupGameDao extends DatabaseAccessor<AppDatabase>
-    with _$GroupGameDaoMixin {
-  GroupGameDao(super.db);
-
-  /// Associates a group with a game by inserting a record into the
-  /// [GroupGameTable].
-  Future<void> addGroupToGame({
-    required String gameId,
-    required String groupId,
-  }) async {
-    if (await gameHasGroup(gameId: gameId)) {
-      throw Exception('Game already has a group');
-    }
-    await into(groupGameTable).insert(
-      GroupGameTableCompanion.insert(groupId: groupId, gameId: gameId),
-      mode: InsertMode.insertOrReplace,
-    );
-  }
-
-  /// Retrieves the [Group] associated with the given [gameId].
-  /// Returns `null` if no group is found.
-  Future<Group?> getGroupOfGame({required String gameId}) async {
-    final result = await (select(
-      groupGameTable,
-    )..where((g) => g.gameId.equals(gameId))).getSingleOrNull();
-
-    if (result == null) {
-      return null;
-    }
-
-    final group = await db.groupDao.getGroupById(groupId: result.groupId);
-    return group;
-  }
-
-  /// Checks if there is a group associated with the given [gameId].
-  /// Returns `true` if there is a group, otherwise `false`.
-  Future<bool> gameHasGroup({required String gameId}) async {
-    final count =
-        await (selectOnly(groupGameTable)
-              ..where(groupGameTable.gameId.equals(gameId))
-              ..addColumns([groupGameTable.groupId.count()]))
-            .map((row) => row.read(groupGameTable.groupId.count()))
-            .getSingle();
-    return (count ?? 0) > 0;
-  }
-
-  /// Checks if a specific group is associated with a specific game.
-  /// Returns `true` if the group is in the game, otherwise `false`.
-  Future<bool> isGroupInGame({
-    required String gameId,
-    required String groupId,
-  }) async {
-    final count =
-        await (selectOnly(groupGameTable)
-              ..where(
-                groupGameTable.gameId.equals(gameId) &
-                    groupGameTable.groupId.equals(groupId),
-              )
-              ..addColumns([groupGameTable.groupId.count()]))
-            .map((row) => row.read(groupGameTable.groupId.count()))
-            .getSingle();
-    return (count ?? 0) > 0;
-  }
-
-  /// Removes the association of a group from a game based on [groupId] and
-  /// [gameId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> removeGroupFromGame({
-    required String gameId,
-    required String groupId,
-  }) async {
-    final query = delete(groupGameTable)
-      ..where((g) => g.gameId.equals(gameId) & g.groupId.equals(groupId));
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Updates the group associated with a game to [newGroupId] based on
-  /// [gameId].
-  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> updateGroupOfGame({
-    required String gameId,
-    required String newGroupId,
-  }) async {
-    final updatedRows =
-        await (update(groupGameTable)..where((g) => g.gameId.equals(gameId)))
-            .write(GroupGameTableCompanion(groupId: Value(newGroupId)));
-    return updatedRows > 0;
-  }
-}
diff --git a/lib/data/dao/group_game_dao.g.dart b/lib/data/dao/group_game_dao.g.dart
deleted file mode 100644
index 735a35f..0000000
--- a/lib/data/dao/group_game_dao.g.dart
+++ /dev/null
@@ -1,10 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'group_game_dao.dart';
-
-// ignore_for_file: type=lint
-mixin _$GroupGameDaoMixin on DatabaseAccessor<AppDatabase> {
-  $GroupTableTable get groupTable => attachedDatabase.groupTable;
-  $GameTableTable get gameTable => attachedDatabase.gameTable;
-  $GroupGameTableTable get groupGameTable => attachedDatabase.groupGameTable;
-}
diff --git a/lib/data/dao/group_match_dao.dart b/lib/data/dao/group_match_dao.dart
new file mode 100644
index 0000000..3c16c83
--- /dev/null
+++ b/lib/data/dao/group_match_dao.dart
@@ -0,0 +1,98 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/db/tables/group_match_table.dart';
+import 'package:game_tracker/data/dto/group.dart';
+
+part 'group_match_dao.g.dart';
+
+@DriftAccessor(tables: [GroupMatchTable])
+class GroupMatchDao extends DatabaseAccessor<AppDatabase>
+    with _$GroupMatchDaoMixin {
+  GroupMatchDao(super.db);
+
+  /// Associates a group with a match by inserting a record into the
+  /// [GroupMatchTable].
+  Future<void> addGroupToMatch({
+    required String matchId,
+    required String groupId,
+  }) async {
+    if (await matchHasGroup(matchId: matchId)) {
+      throw Exception('Match already has a group');
+    }
+    await into(groupMatchTable).insert(
+      GroupMatchTableCompanion.insert(groupId: groupId, matchId: matchId),
+      mode: InsertMode.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;
+  }
+}
diff --git a/lib/data/dao/group_match_dao.g.dart b/lib/data/dao/group_match_dao.g.dart
new file mode 100644
index 0000000..5cc0b82
--- /dev/null
+++ b/lib/data/dao/group_match_dao.g.dart
@@ -0,0 +1,10 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'group_match_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$GroupMatchDaoMixin on DatabaseAccessor<AppDatabase> {
+  $GroupTableTable get groupTable => attachedDatabase.groupTable;
+  $MatchTableTable get matchTable => attachedDatabase.matchTable;
+  $GroupMatchTableTable get groupMatchTable => attachedDatabase.groupMatchTable;
+}
diff --git a/lib/data/dao/match_dao.dart b/lib/data/dao/match_dao.dart
new file mode 100644
index 0000000..32bd323
--- /dev/null
+++ b/lib/data/dao/match_dao.dart
@@ -0,0 +1,322 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/db/tables/match_table.dart';
+import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
+import 'package:game_tracker/data/dto/player.dart';
+
+part 'match_dao.g.dart';
+
+@DriftAccessor(tables: [MatchTable])
+class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
+  MatchDao(super.db);
+
+  /// Retrieves all matches from the database.
+  Future<List<Match>> getAllMatches() async {
+    final query = select(matchTable);
+    final result = await query.get();
+
+    return Future.wait(
+      result.map((row) async {
+        final group = await db.groupMatchDao.getGroupOfMatch(matchId: row.id);
+        final players = await db.playerMatchDao.getPlayersOfMatch(
+          matchId: row.id,
+        );
+        final winner = row.winnerId != null
+            ? await db.playerDao.getPlayerById(playerId: row.winnerId!)
+            : null;
+        return Match(
+          id: row.id,
+          name: row.name,
+          group: group,
+          players: players,
+          createdAt: row.createdAt,
+          winner: winner,
+        );
+      }),
+    );
+  }
+
+  /// Retrieves a [Match] by its [matchId].
+  Future<Match> getMatchById({required String matchId}) async {
+    final query = select(matchTable)..where((g) => g.id.equals(matchId));
+    final result = await query.getSingle();
+
+    List<Player>? players;
+    if (await db.playerMatchDao.matchHasPlayers(matchId: matchId)) {
+      players = await db.playerMatchDao.getPlayersOfMatch(matchId: matchId);
+    }
+    Group? group;
+    if (await db.groupMatchDao.matchHasGroup(matchId: matchId)) {
+      group = await db.groupMatchDao.getGroupOfMatch(matchId: matchId);
+    }
+    Player? winner;
+    if (result.winnerId != null) {
+      winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
+    }
+
+    return Match(
+      id: result.id,
+      name: result.name,
+      players: players,
+      group: group,
+      winner: winner,
+      createdAt: result.createdAt,
+    );
+  }
+
+  /// Adds a new [Match] to the database.
+  /// Also adds 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;
+  }
+}
diff --git a/lib/data/dao/match_dao.g.dart b/lib/data/dao/match_dao.g.dart
new file mode 100644
index 0000000..a9f6f4c
--- /dev/null
+++ b/lib/data/dao/match_dao.g.dart
@@ -0,0 +1,8 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'match_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$MatchDaoMixin on DatabaseAccessor<AppDatabase> {
+  $MatchTableTable get matchTable => attachedDatabase.matchTable;
+}
diff --git a/lib/data/dao/player_game_dao.g.dart b/lib/data/dao/player_game_dao.g.dart
deleted file mode 100644
index 4d0a192..0000000
--- a/lib/data/dao/player_game_dao.g.dart
+++ /dev/null
@@ -1,10 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'player_game_dao.dart';
-
-// ignore_for_file: type=lint
-mixin _$PlayerGameDaoMixin on DatabaseAccessor<AppDatabase> {
-  $PlayerTableTable get playerTable => attachedDatabase.playerTable;
-  $GameTableTable get gameTable => attachedDatabase.gameTable;
-  $PlayerGameTableTable get playerGameTable => attachedDatabase.playerGameTable;
-}
diff --git a/lib/data/dao/player_group_dao.dart b/lib/data/dao/player_group_dao.dart
index 8cf96c2..db45735 100644
--- a/lib/data/dao/player_group_dao.dart
+++ b/lib/data/dao/player_group_dao.dart
@@ -1,11 +1,12 @@
 import 'package:drift/drift.dart';
 import 'package:game_tracker/data/db/database.dart';
 import 'package:game_tracker/data/db/tables/player_group_table.dart';
+import 'package:game_tracker/data/db/tables/player_table.dart';
 import 'package:game_tracker/data/dto/player.dart';
 
 part 'player_group_dao.g.dart';
 
-@DriftAccessor(tables: [PlayerGroupTable])
+@DriftAccessor(tables: [PlayerGroupTable, PlayerTable])
 class PlayerGroupDao extends DatabaseAccessor<AppDatabase>
     with _$PlayerGroupDaoMixin {
   PlayerGroupDao(super.db);
diff --git a/lib/data/dao/player_game_dao.dart b/lib/data/dao/player_match_dao.dart
similarity index 53%
rename from lib/data/dao/player_game_dao.dart
rename to lib/data/dao/player_match_dao.dart
index b7f253f..f42b8bb 100644
--- a/lib/data/dao/player_game_dao.dart
+++ b/lib/data/dao/player_match_dao.dart
@@ -1,33 +1,33 @@
 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/db/tables/player_match_table.dart';
 import 'package:game_tracker/data/dto/player.dart';
 
-part 'player_game_dao.g.dart';
+part 'player_match_dao.g.dart';
 
-@DriftAccessor(tables: [PlayerGameTable])
-class PlayerGameDao extends DatabaseAccessor<AppDatabase>
-    with _$PlayerGameDaoMixin {
-  PlayerGameDao(super.db);
+@DriftAccessor(tables: [PlayerMatchTable])
+class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
+    with _$PlayerMatchDaoMixin {
+  PlayerMatchDao(super.db);
 
-  /// Associates a player with a game by inserting a record into the
-  /// [PlayerGameTable].
-  Future<void> addPlayerToGame({
-    required String gameId,
+  /// 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(playerGameTable).insert(
-      PlayerGameTableCompanion.insert(playerId: playerId, gameId: gameId),
+    await into(playerMatchTable).insert(
+      PlayerMatchTableCompanion.insert(playerId: playerId, matchId: matchId),
       mode: InsertMode.insertOrReplace,
     );
   }
 
-  /// Retrieves a list of [Player]s associated with the given [gameId].
+  /// Retrieves a list of [Player]s associated with the given [matchId].
   /// Returns null if no players are found.
-  Future<List<Player>?> getPlayersOfGame({required String gameId}) async {
+  Future<List<Player>?> getPlayersOfMatch({required String matchId}) async {
     final result = await (select(
-      playerGameTable,
-    )..where((p) => p.gameId.equals(gameId))).get();
+      playerMatchTable,
+    )..where((p) => p.matchId.equals(matchId))).get();
 
     if (result.isEmpty) return null;
 
@@ -38,43 +38,43 @@ class PlayerGameDao extends DatabaseAccessor<AppDatabase>
     return players;
   }
 
-  /// Checks if there are any players associated with the given [gameId].
+  /// Checks if there are any players associated with the given [matchId].
   /// Returns `true` if there are players, otherwise `false`.
-  Future<bool> gameHasPlayers({required String gameId}) async {
+  Future<bool> matchHasPlayers({required String matchId}) async {
     final count =
-        await (selectOnly(playerGameTable)
-              ..where(playerGameTable.gameId.equals(gameId))
-              ..addColumns([playerGameTable.playerId.count()]))
-            .map((row) => row.read(playerGameTable.playerId.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 game.
-  /// Returns `true` if the player is in the game, otherwise `false`.
-  Future<bool> isPlayerInGame({
-    required String gameId,
+  /// 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(playerGameTable)
-              ..where(playerGameTable.gameId.equals(gameId))
-              ..where(playerGameTable.playerId.equals(playerId))
-              ..addColumns([playerGameTable.playerId.count()]))
-            .map((row) => row.read(playerGameTable.playerId.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 game by deleting the record
-  /// from the [PlayerGameTable].
+  /// from the [PlayerMatchTable].
   /// Returns `true` if more than 0 rows were affected, otherwise `false`.
-  Future<bool> removePlayerFromGame({
-    required String gameId,
+  Future<bool> removePlayerFromMatch({
+    required String matchId,
     required String playerId,
   }) async {
-    final query = delete(playerGameTable)
-      ..where((pg) => pg.gameId.equals(gameId))
+    final query = delete(playerMatchTable)
+      ..where((pg) => pg.matchId.equals(matchId))
       ..where((pg) => pg.playerId.equals(playerId));
     final rowsAffected = await query.go();
     return rowsAffected > 0;
@@ -83,11 +83,11 @@ class PlayerGameDao extends DatabaseAccessor<AppDatabase>
   /// 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,
+  Future<void> updatePlayersFromMatch({
+    required String matchId,
     required List<Player> newPlayer,
   }) async {
-    final currentPlayers = await getPlayersOfGame(gameId: gameId);
+    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();
@@ -99,9 +99,9 @@ class PlayerGameDao extends DatabaseAccessor<AppDatabase>
     db.transaction(() async {
       // Remove old players
       if (playersToRemove.isNotEmpty) {
-        await (delete(playerGameTable)..where(
+        await (delete(playerMatchTable)..where(
               (pg) =>
-                  pg.gameId.equals(gameId) &
+                  pg.matchId.equals(matchId) &
                   pg.playerId.isIn(playersToRemove.toList()),
             ))
             .go();
@@ -111,14 +111,16 @@ class PlayerGameDao extends DatabaseAccessor<AppDatabase>
       if (playersToAdd.isNotEmpty) {
         final inserts = playersToAdd
             .map(
-              (id) =>
-                  PlayerGameTableCompanion.insert(playerId: id, gameId: gameId),
+              (id) => PlayerMatchTableCompanion.insert(
+                playerId: id,
+                matchId: matchId,
+              ),
             )
             .toList();
         await Future.wait(
           inserts.map(
             (c) => into(
-              playerGameTable,
+              playerMatchTable,
             ).insert(c, mode: InsertMode.insertOrReplace),
           ),
         );
diff --git a/lib/data/dao/player_match_dao.g.dart b/lib/data/dao/player_match_dao.g.dart
new file mode 100644
index 0000000..bcc8ef7
--- /dev/null
+++ b/lib/data/dao/player_match_dao.g.dart
@@ -0,0 +1,11 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'player_match_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$PlayerMatchDaoMixin on DatabaseAccessor<AppDatabase> {
+  $PlayerTableTable get playerTable => attachedDatabase.playerTable;
+  $MatchTableTable get matchTable => attachedDatabase.matchTable;
+  $PlayerMatchTableTable get playerMatchTable =>
+      attachedDatabase.playerMatchTable;
+}
diff --git a/lib/data/db/database.dart b/lib/data/db/database.dart
index 704e1f0..e6c322f 100644
--- a/lib/data/db/database.dart
+++ b/lib/data/db/database.dart
@@ -1,16 +1,16 @@
 import 'package:drift/drift.dart';
 import 'package:drift_flutter/drift_flutter.dart';
-import 'package:game_tracker/data/dao/game_dao.dart';
 import 'package:game_tracker/data/dao/group_dao.dart';
-import 'package:game_tracker/data/dao/group_game_dao.dart';
+import 'package:game_tracker/data/dao/group_match_dao.dart';
+import 'package:game_tracker/data/dao/match_dao.dart';
 import 'package:game_tracker/data/dao/player_dao.dart';
-import 'package:game_tracker/data/dao/player_game_dao.dart';
 import 'package:game_tracker/data/dao/player_group_dao.dart';
-import 'package:game_tracker/data/db/tables/game_table.dart';
-import 'package:game_tracker/data/db/tables/group_game_table.dart';
+import 'package:game_tracker/data/dao/player_match_dao.dart';
+import 'package:game_tracker/data/db/tables/group_match_table.dart';
 import 'package:game_tracker/data/db/tables/group_table.dart';
-import 'package:game_tracker/data/db/tables/player_game_table.dart';
+import 'package:game_tracker/data/db/tables/match_table.dart';
 import 'package:game_tracker/data/db/tables/player_group_table.dart';
+import 'package:game_tracker/data/db/tables/player_match_table.dart';
 import 'package:game_tracker/data/db/tables/player_table.dart';
 import 'package:path_provider/path_provider.dart';
 
@@ -20,18 +20,18 @@ part 'database.g.dart';
   tables: [
     PlayerTable,
     GroupTable,
-    GameTable,
+    MatchTable,
     PlayerGroupTable,
-    PlayerGameTable,
-    GroupGameTable,
+    PlayerMatchTable,
+    GroupMatchTable,
   ],
   daos: [
     PlayerDao,
     GroupDao,
-    GameDao,
+    MatchDao,
     PlayerGroupDao,
-    PlayerGameDao,
-    GroupGameDao,
+    PlayerMatchDao,
+    GroupMatchDao,
   ],
 )
 class AppDatabase extends _$AppDatabase {
diff --git a/lib/data/db/database.g.dart b/lib/data/db/database.g.dart
index f211d0c..6bc493c 100644
--- a/lib/data/db/database.g.dart
+++ b/lib/data/db/database.g.dart
@@ -521,12 +521,12 @@ class GroupTableCompanion extends UpdateCompanion<GroupTableData> {
   }
 }
 
-class $GameTableTable extends GameTable
-    with TableInfo<$GameTableTable, GameTableData> {
+class $MatchTableTable extends MatchTable
+    with TableInfo<$MatchTableTable, MatchTableData> {
   @override
   final GeneratedDatabase attachedDatabase;
   final String? _alias;
-  $GameTableTable(this.attachedDatabase, [this._alias]);
+  $MatchTableTable(this.attachedDatabase, [this._alias]);
   static const VerificationMeta _idMeta = const VerificationMeta('id');
   @override
   late final GeneratedColumn<String> id = GeneratedColumn<String>(
@@ -573,10 +573,10 @@ class $GameTableTable extends GameTable
   String get aliasedName => _alias ?? actualTableName;
   @override
   String get actualTableName => $name;
-  static const String $name = 'game_table';
+  static const String $name = 'match_table';
   @override
   VerificationContext validateIntegrity(
-    Insertable<GameTableData> instance, {
+    Insertable<MatchTableData> instance, {
     bool isInserting = false,
   }) {
     final context = VerificationContext();
@@ -614,9 +614,9 @@ class $GameTableTable extends GameTable
   @override
   Set<GeneratedColumn> get $primaryKey => {id};
   @override
-  GameTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
+  MatchTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
-    return GameTableData(
+    return MatchTableData(
       id: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}id'],
@@ -637,17 +637,17 @@ class $GameTableTable extends GameTable
   }
 
   @override
-  $GameTableTable createAlias(String alias) {
-    return $GameTableTable(attachedDatabase, alias);
+  $MatchTableTable createAlias(String alias) {
+    return $MatchTableTable(attachedDatabase, alias);
   }
 }
 
-class GameTableData extends DataClass implements Insertable<GameTableData> {
+class MatchTableData extends DataClass implements Insertable<MatchTableData> {
   final String id;
   final String name;
   final String? winnerId;
   final DateTime createdAt;
-  const GameTableData({
+  const MatchTableData({
     required this.id,
     required this.name,
     this.winnerId,
@@ -665,8 +665,8 @@ class GameTableData extends DataClass implements Insertable<GameTableData> {
     return map;
   }
 
-  GameTableCompanion toCompanion(bool nullToAbsent) {
-    return GameTableCompanion(
+  MatchTableCompanion toCompanion(bool nullToAbsent) {
+    return MatchTableCompanion(
       id: Value(id),
       name: Value(name),
       winnerId: winnerId == null && nullToAbsent
@@ -676,12 +676,12 @@ class GameTableData extends DataClass implements Insertable<GameTableData> {
     );
   }
 
-  factory GameTableData.fromJson(
+  factory MatchTableData.fromJson(
     Map<String, dynamic> json, {
     ValueSerializer? serializer,
   }) {
     serializer ??= driftRuntimeOptions.defaultSerializer;
-    return GameTableData(
+    return MatchTableData(
       id: serializer.fromJson<String>(json['id']),
       name: serializer.fromJson<String>(json['name']),
       winnerId: serializer.fromJson<String?>(json['winnerId']),
@@ -699,19 +699,19 @@ class GameTableData extends DataClass implements Insertable<GameTableData> {
     };
   }
 
-  GameTableData copyWith({
+  MatchTableData copyWith({
     String? id,
     String? name,
     Value<String?> winnerId = const Value.absent(),
     DateTime? createdAt,
-  }) => GameTableData(
+  }) => MatchTableData(
     id: id ?? this.id,
     name: name ?? this.name,
     winnerId: winnerId.present ? winnerId.value : this.winnerId,
     createdAt: createdAt ?? this.createdAt,
   );
-  GameTableData copyWithCompanion(GameTableCompanion data) {
-    return GameTableData(
+  MatchTableData copyWithCompanion(MatchTableCompanion data) {
+    return MatchTableData(
       id: data.id.present ? data.id.value : this.id,
       name: data.name.present ? data.name.value : this.name,
       winnerId: data.winnerId.present ? data.winnerId.value : this.winnerId,
@@ -721,7 +721,7 @@ class GameTableData extends DataClass implements Insertable<GameTableData> {
 
   @override
   String toString() {
-    return (StringBuffer('GameTableData(')
+    return (StringBuffer('MatchTableData(')
           ..write('id: $id, ')
           ..write('name: $name, ')
           ..write('winnerId: $winnerId, ')
@@ -735,27 +735,27 @@ class GameTableData extends DataClass implements Insertable<GameTableData> {
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
-      (other is GameTableData &&
+      (other is MatchTableData &&
           other.id == this.id &&
           other.name == this.name &&
           other.winnerId == this.winnerId &&
           other.createdAt == this.createdAt);
 }
 
-class GameTableCompanion extends UpdateCompanion<GameTableData> {
+class MatchTableCompanion extends UpdateCompanion<MatchTableData> {
   final Value<String> id;
   final Value<String> name;
   final Value<String?> winnerId;
   final Value<DateTime> createdAt;
   final Value<int> rowid;
-  const GameTableCompanion({
+  const MatchTableCompanion({
     this.id = const Value.absent(),
     this.name = const Value.absent(),
     this.winnerId = const Value.absent(),
     this.createdAt = const Value.absent(),
     this.rowid = const Value.absent(),
   });
-  GameTableCompanion.insert({
+  MatchTableCompanion.insert({
     required String id,
     required String name,
     this.winnerId = const Value.absent(),
@@ -764,7 +764,7 @@ class GameTableCompanion extends UpdateCompanion<GameTableData> {
   }) : id = Value(id),
        name = Value(name),
        createdAt = Value(createdAt);
-  static Insertable<GameTableData> custom({
+  static Insertable<MatchTableData> custom({
     Expression<String>? id,
     Expression<String>? name,
     Expression<String>? winnerId,
@@ -780,14 +780,14 @@ class GameTableCompanion extends UpdateCompanion<GameTableData> {
     });
   }
 
-  GameTableCompanion copyWith({
+  MatchTableCompanion copyWith({
     Value<String>? id,
     Value<String>? name,
     Value<String?>? winnerId,
     Value<DateTime>? createdAt,
     Value<int>? rowid,
   }) {
-    return GameTableCompanion(
+    return MatchTableCompanion(
       id: id ?? this.id,
       name: name ?? this.name,
       winnerId: winnerId ?? this.winnerId,
@@ -819,7 +819,7 @@ class GameTableCompanion extends UpdateCompanion<GameTableData> {
 
   @override
   String toString() {
-    return (StringBuffer('GameTableCompanion(')
+    return (StringBuffer('MatchTableCompanion(')
           ..write('id: $id, ')
           ..write('name: $name, ')
           ..write('winnerId: $winnerId, ')
@@ -1055,12 +1055,12 @@ class PlayerGroupTableCompanion extends UpdateCompanion<PlayerGroupTableData> {
   }
 }
 
-class $PlayerGameTableTable extends PlayerGameTable
-    with TableInfo<$PlayerGameTableTable, PlayerGameTableData> {
+class $PlayerMatchTableTable extends PlayerMatchTable
+    with TableInfo<$PlayerMatchTableTable, PlayerMatchTableData> {
   @override
   final GeneratedDatabase attachedDatabase;
   final String? _alias;
-  $PlayerGameTableTable(this.attachedDatabase, [this._alias]);
+  $PlayerMatchTableTable(this.attachedDatabase, [this._alias]);
   static const VerificationMeta _playerIdMeta = const VerificationMeta(
     'playerId',
   );
@@ -1075,28 +1075,30 @@ class $PlayerGameTableTable extends PlayerGameTable
       'REFERENCES player_table (id) ON DELETE CASCADE',
     ),
   );
-  static const VerificationMeta _gameIdMeta = const VerificationMeta('gameId');
+  static const VerificationMeta _matchIdMeta = const VerificationMeta(
+    'matchId',
+  );
   @override
-  late final GeneratedColumn<String> gameId = GeneratedColumn<String>(
-    'game_id',
+  late final GeneratedColumn<String> matchId = GeneratedColumn<String>(
+    'match_id',
     aliasedName,
     false,
     type: DriftSqlType.string,
     requiredDuringInsert: true,
     defaultConstraints: GeneratedColumn.constraintIsAlways(
-      'REFERENCES game_table (id) ON DELETE CASCADE',
+      'REFERENCES match_table (id) ON DELETE CASCADE',
     ),
   );
   @override
-  List<GeneratedColumn> get $columns => [playerId, gameId];
+  List<GeneratedColumn> get $columns => [playerId, matchId];
   @override
   String get aliasedName => _alias ?? actualTableName;
   @override
   String get actualTableName => $name;
-  static const String $name = 'player_game_table';
+  static const String $name = 'player_match_table';
   @override
   VerificationContext validateIntegrity(
-    Insertable<PlayerGameTableData> instance, {
+    Insertable<PlayerMatchTableData> instance, {
     bool isInserting = false,
   }) {
     final context = VerificationContext();
@@ -1109,68 +1111,68 @@ class $PlayerGameTableTable extends PlayerGameTable
     } else if (isInserting) {
       context.missing(_playerIdMeta);
     }
-    if (data.containsKey('game_id')) {
+    if (data.containsKey('match_id')) {
       context.handle(
-        _gameIdMeta,
-        gameId.isAcceptableOrUnknown(data['game_id']!, _gameIdMeta),
+        _matchIdMeta,
+        matchId.isAcceptableOrUnknown(data['match_id']!, _matchIdMeta),
       );
     } else if (isInserting) {
-      context.missing(_gameIdMeta);
+      context.missing(_matchIdMeta);
     }
     return context;
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {playerId, gameId};
+  Set<GeneratedColumn> get $primaryKey => {playerId, matchId};
   @override
-  PlayerGameTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
+  PlayerMatchTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
-    return PlayerGameTableData(
+    return PlayerMatchTableData(
       playerId: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}player_id'],
       )!,
-      gameId: attachedDatabase.typeMapping.read(
+      matchId: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
-        data['${effectivePrefix}game_id'],
+        data['${effectivePrefix}match_id'],
       )!,
     );
   }
 
   @override
-  $PlayerGameTableTable createAlias(String alias) {
-    return $PlayerGameTableTable(attachedDatabase, alias);
+  $PlayerMatchTableTable createAlias(String alias) {
+    return $PlayerMatchTableTable(attachedDatabase, alias);
   }
 }
 
-class PlayerGameTableData extends DataClass
-    implements Insertable<PlayerGameTableData> {
+class PlayerMatchTableData extends DataClass
+    implements Insertable<PlayerMatchTableData> {
   final String playerId;
-  final String gameId;
-  const PlayerGameTableData({required this.playerId, required this.gameId});
+  final String matchId;
+  const PlayerMatchTableData({required this.playerId, required this.matchId});
   @override
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['player_id'] = Variable<String>(playerId);
-    map['game_id'] = Variable<String>(gameId);
+    map['match_id'] = Variable<String>(matchId);
     return map;
   }
 
-  PlayerGameTableCompanion toCompanion(bool nullToAbsent) {
-    return PlayerGameTableCompanion(
+  PlayerMatchTableCompanion toCompanion(bool nullToAbsent) {
+    return PlayerMatchTableCompanion(
       playerId: Value(playerId),
-      gameId: Value(gameId),
+      matchId: Value(matchId),
     );
   }
 
-  factory PlayerGameTableData.fromJson(
+  factory PlayerMatchTableData.fromJson(
     Map<String, dynamic> json, {
     ValueSerializer? serializer,
   }) {
     serializer ??= driftRuntimeOptions.defaultSerializer;
-    return PlayerGameTableData(
+    return PlayerMatchTableData(
       playerId: serializer.fromJson<String>(json['playerId']),
-      gameId: serializer.fromJson<String>(json['gameId']),
+      matchId: serializer.fromJson<String>(json['matchId']),
     );
   }
   @override
@@ -1178,76 +1180,76 @@ class PlayerGameTableData extends DataClass
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'playerId': serializer.toJson<String>(playerId),
-      'gameId': serializer.toJson<String>(gameId),
+      'matchId': serializer.toJson<String>(matchId),
     };
   }
 
-  PlayerGameTableData copyWith({String? playerId, String? gameId}) =>
-      PlayerGameTableData(
+  PlayerMatchTableData copyWith({String? playerId, String? matchId}) =>
+      PlayerMatchTableData(
         playerId: playerId ?? this.playerId,
-        gameId: gameId ?? this.gameId,
+        matchId: matchId ?? this.matchId,
       );
-  PlayerGameTableData copyWithCompanion(PlayerGameTableCompanion data) {
-    return PlayerGameTableData(
+  PlayerMatchTableData copyWithCompanion(PlayerMatchTableCompanion data) {
+    return PlayerMatchTableData(
       playerId: data.playerId.present ? data.playerId.value : this.playerId,
-      gameId: data.gameId.present ? data.gameId.value : this.gameId,
+      matchId: data.matchId.present ? data.matchId.value : this.matchId,
     );
   }
 
   @override
   String toString() {
-    return (StringBuffer('PlayerGameTableData(')
+    return (StringBuffer('PlayerMatchTableData(')
           ..write('playerId: $playerId, ')
-          ..write('gameId: $gameId')
+          ..write('matchId: $matchId')
           ..write(')'))
         .toString();
   }
 
   @override
-  int get hashCode => Object.hash(playerId, gameId);
+  int get hashCode => Object.hash(playerId, matchId);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
-      (other is PlayerGameTableData &&
+      (other is PlayerMatchTableData &&
           other.playerId == this.playerId &&
-          other.gameId == this.gameId);
+          other.matchId == this.matchId);
 }
 
-class PlayerGameTableCompanion extends UpdateCompanion<PlayerGameTableData> {
+class PlayerMatchTableCompanion extends UpdateCompanion<PlayerMatchTableData> {
   final Value<String> playerId;
-  final Value<String> gameId;
+  final Value<String> matchId;
   final Value<int> rowid;
-  const PlayerGameTableCompanion({
+  const PlayerMatchTableCompanion({
     this.playerId = const Value.absent(),
-    this.gameId = const Value.absent(),
+    this.matchId = const Value.absent(),
     this.rowid = const Value.absent(),
   });
-  PlayerGameTableCompanion.insert({
+  PlayerMatchTableCompanion.insert({
     required String playerId,
-    required String gameId,
+    required String matchId,
     this.rowid = const Value.absent(),
   }) : playerId = Value(playerId),
-       gameId = Value(gameId);
-  static Insertable<PlayerGameTableData> custom({
+       matchId = Value(matchId);
+  static Insertable<PlayerMatchTableData> custom({
     Expression<String>? playerId,
-    Expression<String>? gameId,
+    Expression<String>? matchId,
     Expression<int>? rowid,
   }) {
     return RawValuesInsertable({
       if (playerId != null) 'player_id': playerId,
-      if (gameId != null) 'game_id': gameId,
+      if (matchId != null) 'match_id': matchId,
       if (rowid != null) 'rowid': rowid,
     });
   }
 
-  PlayerGameTableCompanion copyWith({
+  PlayerMatchTableCompanion copyWith({
     Value<String>? playerId,
-    Value<String>? gameId,
+    Value<String>? matchId,
     Value<int>? rowid,
   }) {
-    return PlayerGameTableCompanion(
+    return PlayerMatchTableCompanion(
       playerId: playerId ?? this.playerId,
-      gameId: gameId ?? this.gameId,
+      matchId: matchId ?? this.matchId,
       rowid: rowid ?? this.rowid,
     );
   }
@@ -1258,8 +1260,8 @@ class PlayerGameTableCompanion extends UpdateCompanion<PlayerGameTableData> {
     if (playerId.present) {
       map['player_id'] = Variable<String>(playerId.value);
     }
-    if (gameId.present) {
-      map['game_id'] = Variable<String>(gameId.value);
+    if (matchId.present) {
+      map['match_id'] = Variable<String>(matchId.value);
     }
     if (rowid.present) {
       map['rowid'] = Variable<int>(rowid.value);
@@ -1269,21 +1271,21 @@ class PlayerGameTableCompanion extends UpdateCompanion<PlayerGameTableData> {
 
   @override
   String toString() {
-    return (StringBuffer('PlayerGameTableCompanion(')
+    return (StringBuffer('PlayerMatchTableCompanion(')
           ..write('playerId: $playerId, ')
-          ..write('gameId: $gameId, ')
+          ..write('matchId: $matchId, ')
           ..write('rowid: $rowid')
           ..write(')'))
         .toString();
   }
 }
 
-class $GroupGameTableTable extends GroupGameTable
-    with TableInfo<$GroupGameTableTable, GroupGameTableData> {
+class $GroupMatchTableTable extends GroupMatchTable
+    with TableInfo<$GroupMatchTableTable, GroupMatchTableData> {
   @override
   final GeneratedDatabase attachedDatabase;
   final String? _alias;
-  $GroupGameTableTable(this.attachedDatabase, [this._alias]);
+  $GroupMatchTableTable(this.attachedDatabase, [this._alias]);
   static const VerificationMeta _groupIdMeta = const VerificationMeta(
     'groupId',
   );
@@ -1298,28 +1300,30 @@ class $GroupGameTableTable extends GroupGameTable
       'REFERENCES group_table (id) ON DELETE CASCADE',
     ),
   );
-  static const VerificationMeta _gameIdMeta = const VerificationMeta('gameId');
+  static const VerificationMeta _matchIdMeta = const VerificationMeta(
+    'matchId',
+  );
   @override
-  late final GeneratedColumn<String> gameId = GeneratedColumn<String>(
-    'game_id',
+  late final GeneratedColumn<String> matchId = GeneratedColumn<String>(
+    'match_id',
     aliasedName,
     false,
     type: DriftSqlType.string,
     requiredDuringInsert: true,
     defaultConstraints: GeneratedColumn.constraintIsAlways(
-      'REFERENCES game_table (id) ON DELETE CASCADE',
+      'REFERENCES match_table (id) ON DELETE CASCADE',
     ),
   );
   @override
-  List<GeneratedColumn> get $columns => [groupId, gameId];
+  List<GeneratedColumn> get $columns => [groupId, matchId];
   @override
   String get aliasedName => _alias ?? actualTableName;
   @override
   String get actualTableName => $name;
-  static const String $name = 'group_game_table';
+  static const String $name = 'group_match_table';
   @override
   VerificationContext validateIntegrity(
-    Insertable<GroupGameTableData> instance, {
+    Insertable<GroupMatchTableData> instance, {
     bool isInserting = false,
   }) {
     final context = VerificationContext();
@@ -1332,68 +1336,68 @@ class $GroupGameTableTable extends GroupGameTable
     } else if (isInserting) {
       context.missing(_groupIdMeta);
     }
-    if (data.containsKey('game_id')) {
+    if (data.containsKey('match_id')) {
       context.handle(
-        _gameIdMeta,
-        gameId.isAcceptableOrUnknown(data['game_id']!, _gameIdMeta),
+        _matchIdMeta,
+        matchId.isAcceptableOrUnknown(data['match_id']!, _matchIdMeta),
       );
     } else if (isInserting) {
-      context.missing(_gameIdMeta);
+      context.missing(_matchIdMeta);
     }
     return context;
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {groupId, gameId};
+  Set<GeneratedColumn> get $primaryKey => {groupId, matchId};
   @override
-  GroupGameTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
+  GroupMatchTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
-    return GroupGameTableData(
+    return GroupMatchTableData(
       groupId: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}group_id'],
       )!,
-      gameId: attachedDatabase.typeMapping.read(
+      matchId: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
-        data['${effectivePrefix}game_id'],
+        data['${effectivePrefix}match_id'],
       )!,
     );
   }
 
   @override
-  $GroupGameTableTable createAlias(String alias) {
-    return $GroupGameTableTable(attachedDatabase, alias);
+  $GroupMatchTableTable createAlias(String alias) {
+    return $GroupMatchTableTable(attachedDatabase, alias);
   }
 }
 
-class GroupGameTableData extends DataClass
-    implements Insertable<GroupGameTableData> {
+class GroupMatchTableData extends DataClass
+    implements Insertable<GroupMatchTableData> {
   final String groupId;
-  final String gameId;
-  const GroupGameTableData({required this.groupId, required this.gameId});
+  final String matchId;
+  const GroupMatchTableData({required this.groupId, required this.matchId});
   @override
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['group_id'] = Variable<String>(groupId);
-    map['game_id'] = Variable<String>(gameId);
+    map['match_id'] = Variable<String>(matchId);
     return map;
   }
 
-  GroupGameTableCompanion toCompanion(bool nullToAbsent) {
-    return GroupGameTableCompanion(
+  GroupMatchTableCompanion toCompanion(bool nullToAbsent) {
+    return GroupMatchTableCompanion(
       groupId: Value(groupId),
-      gameId: Value(gameId),
+      matchId: Value(matchId),
     );
   }
 
-  factory GroupGameTableData.fromJson(
+  factory GroupMatchTableData.fromJson(
     Map<String, dynamic> json, {
     ValueSerializer? serializer,
   }) {
     serializer ??= driftRuntimeOptions.defaultSerializer;
-    return GroupGameTableData(
+    return GroupMatchTableData(
       groupId: serializer.fromJson<String>(json['groupId']),
-      gameId: serializer.fromJson<String>(json['gameId']),
+      matchId: serializer.fromJson<String>(json['matchId']),
     );
   }
   @override
@@ -1401,76 +1405,76 @@ class GroupGameTableData extends DataClass
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'groupId': serializer.toJson<String>(groupId),
-      'gameId': serializer.toJson<String>(gameId),
+      'matchId': serializer.toJson<String>(matchId),
     };
   }
 
-  GroupGameTableData copyWith({String? groupId, String? gameId}) =>
-      GroupGameTableData(
+  GroupMatchTableData copyWith({String? groupId, String? matchId}) =>
+      GroupMatchTableData(
         groupId: groupId ?? this.groupId,
-        gameId: gameId ?? this.gameId,
+        matchId: matchId ?? this.matchId,
       );
-  GroupGameTableData copyWithCompanion(GroupGameTableCompanion data) {
-    return GroupGameTableData(
+  GroupMatchTableData copyWithCompanion(GroupMatchTableCompanion data) {
+    return GroupMatchTableData(
       groupId: data.groupId.present ? data.groupId.value : this.groupId,
-      gameId: data.gameId.present ? data.gameId.value : this.gameId,
+      matchId: data.matchId.present ? data.matchId.value : this.matchId,
     );
   }
 
   @override
   String toString() {
-    return (StringBuffer('GroupGameTableData(')
+    return (StringBuffer('GroupMatchTableData(')
           ..write('groupId: $groupId, ')
-          ..write('gameId: $gameId')
+          ..write('matchId: $matchId')
           ..write(')'))
         .toString();
   }
 
   @override
-  int get hashCode => Object.hash(groupId, gameId);
+  int get hashCode => Object.hash(groupId, matchId);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
-      (other is GroupGameTableData &&
+      (other is GroupMatchTableData &&
           other.groupId == this.groupId &&
-          other.gameId == this.gameId);
+          other.matchId == this.matchId);
 }
 
-class GroupGameTableCompanion extends UpdateCompanion<GroupGameTableData> {
+class GroupMatchTableCompanion extends UpdateCompanion<GroupMatchTableData> {
   final Value<String> groupId;
-  final Value<String> gameId;
+  final Value<String> matchId;
   final Value<int> rowid;
-  const GroupGameTableCompanion({
+  const GroupMatchTableCompanion({
     this.groupId = const Value.absent(),
-    this.gameId = const Value.absent(),
+    this.matchId = const Value.absent(),
     this.rowid = const Value.absent(),
   });
-  GroupGameTableCompanion.insert({
+  GroupMatchTableCompanion.insert({
     required String groupId,
-    required String gameId,
+    required String matchId,
     this.rowid = const Value.absent(),
   }) : groupId = Value(groupId),
-       gameId = Value(gameId);
-  static Insertable<GroupGameTableData> custom({
+       matchId = Value(matchId);
+  static Insertable<GroupMatchTableData> custom({
     Expression<String>? groupId,
-    Expression<String>? gameId,
+    Expression<String>? matchId,
     Expression<int>? rowid,
   }) {
     return RawValuesInsertable({
       if (groupId != null) 'group_id': groupId,
-      if (gameId != null) 'game_id': gameId,
+      if (matchId != null) 'match_id': matchId,
       if (rowid != null) 'rowid': rowid,
     });
   }
 
-  GroupGameTableCompanion copyWith({
+  GroupMatchTableCompanion copyWith({
     Value<String>? groupId,
-    Value<String>? gameId,
+    Value<String>? matchId,
     Value<int>? rowid,
   }) {
-    return GroupGameTableCompanion(
+    return GroupMatchTableCompanion(
       groupId: groupId ?? this.groupId,
-      gameId: gameId ?? this.gameId,
+      matchId: matchId ?? this.matchId,
       rowid: rowid ?? this.rowid,
     );
   }
@@ -1481,8 +1485,8 @@ class GroupGameTableCompanion extends UpdateCompanion<GroupGameTableData> {
     if (groupId.present) {
       map['group_id'] = Variable<String>(groupId.value);
     }
-    if (gameId.present) {
-      map['game_id'] = Variable<String>(gameId.value);
+    if (matchId.present) {
+      map['match_id'] = Variable<String>(matchId.value);
     }
     if (rowid.present) {
       map['rowid'] = Variable<int>(rowid.value);
@@ -1492,9 +1496,9 @@ class GroupGameTableCompanion extends UpdateCompanion<GroupGameTableData> {
 
   @override
   String toString() {
-    return (StringBuffer('GroupGameTableCompanion(')
+    return (StringBuffer('GroupMatchTableCompanion(')
           ..write('groupId: $groupId, ')
-          ..write('gameId: $gameId, ')
+          ..write('matchId: $matchId, ')
           ..write('rowid: $rowid')
           ..write(')'))
         .toString();
@@ -1506,22 +1510,26 @@ abstract class _$AppDatabase extends GeneratedDatabase {
   $AppDatabaseManager get managers => $AppDatabaseManager(this);
   late final $PlayerTableTable playerTable = $PlayerTableTable(this);
   late final $GroupTableTable groupTable = $GroupTableTable(this);
-  late final $GameTableTable gameTable = $GameTableTable(this);
+  late final $MatchTableTable matchTable = $MatchTableTable(this);
   late final $PlayerGroupTableTable playerGroupTable = $PlayerGroupTableTable(
     this,
   );
-  late final $PlayerGameTableTable playerGameTable = $PlayerGameTableTable(
+  late final $PlayerMatchTableTable playerMatchTable = $PlayerMatchTableTable(
+    this,
+  );
+  late final $GroupMatchTableTable groupMatchTable = $GroupMatchTableTable(
     this,
   );
-  late final $GroupGameTableTable groupGameTable = $GroupGameTableTable(this);
   late final PlayerDao playerDao = PlayerDao(this as AppDatabase);
   late final GroupDao groupDao = GroupDao(this as AppDatabase);
-  late final GameDao gameDao = GameDao(this as AppDatabase);
+  late final MatchDao matchDao = MatchDao(this as AppDatabase);
   late final PlayerGroupDao playerGroupDao = PlayerGroupDao(
     this as AppDatabase,
   );
-  late final PlayerGameDao playerGameDao = PlayerGameDao(this as AppDatabase);
-  late final GroupGameDao groupGameDao = GroupGameDao(this as AppDatabase);
+  late final PlayerMatchDao playerMatchDao = PlayerMatchDao(
+    this as AppDatabase,
+  );
+  late final GroupMatchDao groupMatchDao = GroupMatchDao(this as AppDatabase);
   @override
   Iterable<TableInfo<Table, Object?>> get allTables =>
       allSchemaEntities.whereType<TableInfo<Table, Object?>>();
@@ -1529,10 +1537,10 @@ abstract class _$AppDatabase extends GeneratedDatabase {
   List<DatabaseSchemaEntity> get allSchemaEntities => [
     playerTable,
     groupTable,
-    gameTable,
+    matchTable,
     playerGroupTable,
-    playerGameTable,
-    groupGameTable,
+    playerMatchTable,
+    groupMatchTable,
   ];
   @override
   StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules([
@@ -1555,28 +1563,28 @@ abstract class _$AppDatabase extends GeneratedDatabase {
         'player_table',
         limitUpdateKind: UpdateKind.delete,
       ),
-      result: [TableUpdate('player_game_table', kind: UpdateKind.delete)],
+      result: [TableUpdate('player_match_table', kind: UpdateKind.delete)],
     ),
     WritePropagation(
       on: TableUpdateQuery.onTableName(
-        'game_table',
+        'match_table',
         limitUpdateKind: UpdateKind.delete,
       ),
-      result: [TableUpdate('player_game_table', kind: UpdateKind.delete)],
+      result: [TableUpdate('player_match_table', kind: UpdateKind.delete)],
     ),
     WritePropagation(
       on: TableUpdateQuery.onTableName(
         'group_table',
         limitUpdateKind: UpdateKind.delete,
       ),
-      result: [TableUpdate('group_game_table', kind: UpdateKind.delete)],
+      result: [TableUpdate('group_match_table', kind: UpdateKind.delete)],
     ),
     WritePropagation(
       on: TableUpdateQuery.onTableName(
-        'game_table',
+        'match_table',
         limitUpdateKind: UpdateKind.delete,
       ),
-      result: [TableUpdate('group_game_table', kind: UpdateKind.delete)],
+      result: [TableUpdate('group_match_table', kind: UpdateKind.delete)],
     ),
   ]);
 }
@@ -1623,23 +1631,23 @@ final class $$PlayerTableTableReferences
     );
   }
 
-  static MultiTypedResultKey<$PlayerGameTableTable, List<PlayerGameTableData>>
-  _playerGameTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
-    db.playerGameTable,
+  static MultiTypedResultKey<$PlayerMatchTableTable, List<PlayerMatchTableData>>
+  _playerMatchTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
+    db.playerMatchTable,
     aliasName: $_aliasNameGenerator(
       db.playerTable.id,
-      db.playerGameTable.playerId,
+      db.playerMatchTable.playerId,
     ),
   );
 
-  $$PlayerGameTableTableProcessedTableManager get playerGameTableRefs {
-    final manager = $$PlayerGameTableTableTableManager(
+  $$PlayerMatchTableTableProcessedTableManager get playerMatchTableRefs {
+    final manager = $$PlayerMatchTableTableTableManager(
       $_db,
-      $_db.playerGameTable,
+      $_db.playerMatchTable,
     ).filter((f) => f.playerId.id.sqlEquals($_itemColumn<String>('id')!));
 
     final cache = $_typedResult.readTableOrNull(
-      _playerGameTableRefsTable($_db),
+      _playerMatchTableRefsTable($_db),
     );
     return ProcessedTableManager(
       manager.$state.copyWith(prefetchedData: cache),
@@ -1696,22 +1704,22 @@ class $$PlayerTableTableFilterComposer
     return f(composer);
   }
 
-  Expression<bool> playerGameTableRefs(
-    Expression<bool> Function($$PlayerGameTableTableFilterComposer f) f,
+  Expression<bool> playerMatchTableRefs(
+    Expression<bool> Function($$PlayerMatchTableTableFilterComposer f) f,
   ) {
-    final $$PlayerGameTableTableFilterComposer composer = $composerBuilder(
+    final $$PlayerMatchTableTableFilterComposer composer = $composerBuilder(
       composer: this,
       getCurrentColumn: (t) => t.id,
-      referencedTable: $db.playerGameTable,
+      referencedTable: $db.playerMatchTable,
       getReferencedColumn: (t) => t.playerId,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$PlayerGameTableTableFilterComposer(
+          }) => $$PlayerMatchTableTableFilterComposer(
             $db: $db,
-            $table: $db.playerGameTable,
+            $table: $db.playerMatchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -1790,22 +1798,22 @@ class $$PlayerTableTableAnnotationComposer
     return f(composer);
   }
 
-  Expression<T> playerGameTableRefs<T extends Object>(
-    Expression<T> Function($$PlayerGameTableTableAnnotationComposer a) f,
+  Expression<T> playerMatchTableRefs<T extends Object>(
+    Expression<T> Function($$PlayerMatchTableTableAnnotationComposer a) f,
   ) {
-    final $$PlayerGameTableTableAnnotationComposer composer = $composerBuilder(
+    final $$PlayerMatchTableTableAnnotationComposer composer = $composerBuilder(
       composer: this,
       getCurrentColumn: (t) => t.id,
-      referencedTable: $db.playerGameTable,
+      referencedTable: $db.playerMatchTable,
       getReferencedColumn: (t) => t.playerId,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$PlayerGameTableTableAnnotationComposer(
+          }) => $$PlayerMatchTableTableAnnotationComposer(
             $db: $db,
-            $table: $db.playerGameTable,
+            $table: $db.playerMatchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -1831,7 +1839,7 @@ class $$PlayerTableTableTableManager
           PlayerTableData,
           PrefetchHooks Function({
             bool playerGroupTableRefs,
-            bool playerGameTableRefs,
+            bool playerMatchTableRefs,
           })
         > {
   $$PlayerTableTableTableManager(_$AppDatabase db, $PlayerTableTable table)
@@ -1878,12 +1886,12 @@ class $$PlayerTableTableTableManager
               )
               .toList(),
           prefetchHooksCallback:
-              ({playerGroupTableRefs = false, playerGameTableRefs = false}) {
+              ({playerGroupTableRefs = false, playerMatchTableRefs = false}) {
                 return PrefetchHooks(
                   db: db,
                   explicitlyWatchedTables: [
                     if (playerGroupTableRefs) db.playerGroupTable,
-                    if (playerGameTableRefs) db.playerGameTable,
+                    if (playerMatchTableRefs) db.playerMatchTable,
                   ],
                   addJoins: null,
                   getPrefetchedDataCallback: (items) async {
@@ -1909,21 +1917,21 @@ class $$PlayerTableTableTableManager
                               ),
                           typedResults: items,
                         ),
-                      if (playerGameTableRefs)
+                      if (playerMatchTableRefs)
                         await $_getPrefetchedData<
                           PlayerTableData,
                           $PlayerTableTable,
-                          PlayerGameTableData
+                          PlayerMatchTableData
                         >(
                           currentTable: table,
                           referencedTable: $$PlayerTableTableReferences
-                              ._playerGameTableRefsTable(db),
+                              ._playerMatchTableRefsTable(db),
                           managerFromTypedResult: (p0) =>
                               $$PlayerTableTableReferences(
                                 db,
                                 table,
                                 p0,
-                              ).playerGameTableRefs,
+                              ).playerMatchTableRefs,
                           referencedItemsForCurrentItem:
                               (item, referencedItems) => referencedItems.where(
                                 (e) => e.playerId == item.id,
@@ -1952,7 +1960,7 @@ typedef $$PlayerTableTableProcessedTableManager =
       PlayerTableData,
       PrefetchHooks Function({
         bool playerGroupTableRefs,
-        bool playerGameTableRefs,
+        bool playerMatchTableRefs,
       })
     >;
 typedef $$GroupTableTableCreateCompanionBuilder =
@@ -1997,22 +2005,24 @@ final class $$GroupTableTableReferences
     );
   }
 
-  static MultiTypedResultKey<$GroupGameTableTable, List<GroupGameTableData>>
-  _groupGameTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
-    db.groupGameTable,
+  static MultiTypedResultKey<$GroupMatchTableTable, List<GroupMatchTableData>>
+  _groupMatchTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
+    db.groupMatchTable,
     aliasName: $_aliasNameGenerator(
       db.groupTable.id,
-      db.groupGameTable.groupId,
+      db.groupMatchTable.groupId,
     ),
   );
 
-  $$GroupGameTableTableProcessedTableManager get groupGameTableRefs {
-    final manager = $$GroupGameTableTableTableManager(
+  $$GroupMatchTableTableProcessedTableManager get groupMatchTableRefs {
+    final manager = $$GroupMatchTableTableTableManager(
       $_db,
-      $_db.groupGameTable,
+      $_db.groupMatchTable,
     ).filter((f) => f.groupId.id.sqlEquals($_itemColumn<String>('id')!));
 
-    final cache = $_typedResult.readTableOrNull(_groupGameTableRefsTable($_db));
+    final cache = $_typedResult.readTableOrNull(
+      _groupMatchTableRefsTable($_db),
+    );
     return ProcessedTableManager(
       manager.$state.copyWith(prefetchedData: cache),
     );
@@ -2068,22 +2078,22 @@ class $$GroupTableTableFilterComposer
     return f(composer);
   }
 
-  Expression<bool> groupGameTableRefs(
-    Expression<bool> Function($$GroupGameTableTableFilterComposer f) f,
+  Expression<bool> groupMatchTableRefs(
+    Expression<bool> Function($$GroupMatchTableTableFilterComposer f) f,
   ) {
-    final $$GroupGameTableTableFilterComposer composer = $composerBuilder(
+    final $$GroupMatchTableTableFilterComposer composer = $composerBuilder(
       composer: this,
       getCurrentColumn: (t) => t.id,
-      referencedTable: $db.groupGameTable,
+      referencedTable: $db.groupMatchTable,
       getReferencedColumn: (t) => t.groupId,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$GroupGameTableTableFilterComposer(
+          }) => $$GroupMatchTableTableFilterComposer(
             $db: $db,
-            $table: $db.groupGameTable,
+            $table: $db.groupMatchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -2162,22 +2172,22 @@ class $$GroupTableTableAnnotationComposer
     return f(composer);
   }
 
-  Expression<T> groupGameTableRefs<T extends Object>(
-    Expression<T> Function($$GroupGameTableTableAnnotationComposer a) f,
+  Expression<T> groupMatchTableRefs<T extends Object>(
+    Expression<T> Function($$GroupMatchTableTableAnnotationComposer a) f,
   ) {
-    final $$GroupGameTableTableAnnotationComposer composer = $composerBuilder(
+    final $$GroupMatchTableTableAnnotationComposer composer = $composerBuilder(
       composer: this,
       getCurrentColumn: (t) => t.id,
-      referencedTable: $db.groupGameTable,
+      referencedTable: $db.groupMatchTable,
       getReferencedColumn: (t) => t.groupId,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$GroupGameTableTableAnnotationComposer(
+          }) => $$GroupMatchTableTableAnnotationComposer(
             $db: $db,
-            $table: $db.groupGameTable,
+            $table: $db.groupMatchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -2203,7 +2213,7 @@ class $$GroupTableTableTableManager
           GroupTableData,
           PrefetchHooks Function({
             bool playerGroupTableRefs,
-            bool groupGameTableRefs,
+            bool groupMatchTableRefs,
           })
         > {
   $$GroupTableTableTableManager(_$AppDatabase db, $GroupTableTable table)
@@ -2250,12 +2260,12 @@ class $$GroupTableTableTableManager
               )
               .toList(),
           prefetchHooksCallback:
-              ({playerGroupTableRefs = false, groupGameTableRefs = false}) {
+              ({playerGroupTableRefs = false, groupMatchTableRefs = false}) {
                 return PrefetchHooks(
                   db: db,
                   explicitlyWatchedTables: [
                     if (playerGroupTableRefs) db.playerGroupTable,
-                    if (groupGameTableRefs) db.groupGameTable,
+                    if (groupMatchTableRefs) db.groupMatchTable,
                   ],
                   addJoins: null,
                   getPrefetchedDataCallback: (items) async {
@@ -2281,21 +2291,21 @@ class $$GroupTableTableTableManager
                               ),
                           typedResults: items,
                         ),
-                      if (groupGameTableRefs)
+                      if (groupMatchTableRefs)
                         await $_getPrefetchedData<
                           GroupTableData,
                           $GroupTableTable,
-                          GroupGameTableData
+                          GroupMatchTableData
                         >(
                           currentTable: table,
                           referencedTable: $$GroupTableTableReferences
-                              ._groupGameTableRefsTable(db),
+                              ._groupMatchTableRefsTable(db),
                           managerFromTypedResult: (p0) =>
                               $$GroupTableTableReferences(
                                 db,
                                 table,
                                 p0,
-                              ).groupGameTableRefs,
+                              ).groupMatchTableRefs,
                           referencedItemsForCurrentItem:
                               (item, referencedItems) => referencedItems.where(
                                 (e) => e.groupId == item.id,
@@ -2324,19 +2334,19 @@ typedef $$GroupTableTableProcessedTableManager =
       GroupTableData,
       PrefetchHooks Function({
         bool playerGroupTableRefs,
-        bool groupGameTableRefs,
+        bool groupMatchTableRefs,
       })
     >;
-typedef $$GameTableTableCreateCompanionBuilder =
-    GameTableCompanion Function({
+typedef $$MatchTableTableCreateCompanionBuilder =
+    MatchTableCompanion Function({
       required String id,
       required String name,
       Value<String?> winnerId,
       required DateTime createdAt,
       Value<int> rowid,
     });
-typedef $$GameTableTableUpdateCompanionBuilder =
-    GameTableCompanion Function({
+typedef $$MatchTableTableUpdateCompanionBuilder =
+    MatchTableCompanion Function({
       Value<String> id,
       Value<String> name,
       Value<String?> winnerId,
@@ -2344,52 +2354,60 @@ typedef $$GameTableTableUpdateCompanionBuilder =
       Value<int> rowid,
     });
 
-final class $$GameTableTableReferences
-    extends BaseReferences<_$AppDatabase, $GameTableTable, GameTableData> {
-  $$GameTableTableReferences(super.$_db, super.$_table, super.$_typedResult);
+final class $$MatchTableTableReferences
+    extends BaseReferences<_$AppDatabase, $MatchTableTable, MatchTableData> {
+  $$MatchTableTableReferences(super.$_db, super.$_table, super.$_typedResult);
 
-  static MultiTypedResultKey<$PlayerGameTableTable, List<PlayerGameTableData>>
-  _playerGameTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
-    db.playerGameTable,
-    aliasName: $_aliasNameGenerator(db.gameTable.id, db.playerGameTable.gameId),
+  static MultiTypedResultKey<$PlayerMatchTableTable, List<PlayerMatchTableData>>
+  _playerMatchTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
+    db.playerMatchTable,
+    aliasName: $_aliasNameGenerator(
+      db.matchTable.id,
+      db.playerMatchTable.matchId,
+    ),
   );
 
-  $$PlayerGameTableTableProcessedTableManager get playerGameTableRefs {
-    final manager = $$PlayerGameTableTableTableManager(
+  $$PlayerMatchTableTableProcessedTableManager get playerMatchTableRefs {
+    final manager = $$PlayerMatchTableTableTableManager(
       $_db,
-      $_db.playerGameTable,
-    ).filter((f) => f.gameId.id.sqlEquals($_itemColumn<String>('id')!));
+      $_db.playerMatchTable,
+    ).filter((f) => f.matchId.id.sqlEquals($_itemColumn<String>('id')!));
 
     final cache = $_typedResult.readTableOrNull(
-      _playerGameTableRefsTable($_db),
+      _playerMatchTableRefsTable($_db),
     );
     return ProcessedTableManager(
       manager.$state.copyWith(prefetchedData: cache),
     );
   }
 
-  static MultiTypedResultKey<$GroupGameTableTable, List<GroupGameTableData>>
-  _groupGameTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
-    db.groupGameTable,
-    aliasName: $_aliasNameGenerator(db.gameTable.id, db.groupGameTable.gameId),
+  static MultiTypedResultKey<$GroupMatchTableTable, List<GroupMatchTableData>>
+  _groupMatchTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
+    db.groupMatchTable,
+    aliasName: $_aliasNameGenerator(
+      db.matchTable.id,
+      db.groupMatchTable.matchId,
+    ),
   );
 
-  $$GroupGameTableTableProcessedTableManager get groupGameTableRefs {
-    final manager = $$GroupGameTableTableTableManager(
+  $$GroupMatchTableTableProcessedTableManager get groupMatchTableRefs {
+    final manager = $$GroupMatchTableTableTableManager(
       $_db,
-      $_db.groupGameTable,
-    ).filter((f) => f.gameId.id.sqlEquals($_itemColumn<String>('id')!));
+      $_db.groupMatchTable,
+    ).filter((f) => f.matchId.id.sqlEquals($_itemColumn<String>('id')!));
 
-    final cache = $_typedResult.readTableOrNull(_groupGameTableRefsTable($_db));
+    final cache = $_typedResult.readTableOrNull(
+      _groupMatchTableRefsTable($_db),
+    );
     return ProcessedTableManager(
       manager.$state.copyWith(prefetchedData: cache),
     );
   }
 }
 
-class $$GameTableTableFilterComposer
-    extends Composer<_$AppDatabase, $GameTableTable> {
-  $$GameTableTableFilterComposer({
+class $$MatchTableTableFilterComposer
+    extends Composer<_$AppDatabase, $MatchTableTable> {
+  $$MatchTableTableFilterComposer({
     required super.$db,
     required super.$table,
     super.joinBuilder,
@@ -2416,22 +2434,22 @@ class $$GameTableTableFilterComposer
     builder: (column) => ColumnFilters(column),
   );
 
-  Expression<bool> playerGameTableRefs(
-    Expression<bool> Function($$PlayerGameTableTableFilterComposer f) f,
+  Expression<bool> playerMatchTableRefs(
+    Expression<bool> Function($$PlayerMatchTableTableFilterComposer f) f,
   ) {
-    final $$PlayerGameTableTableFilterComposer composer = $composerBuilder(
+    final $$PlayerMatchTableTableFilterComposer composer = $composerBuilder(
       composer: this,
       getCurrentColumn: (t) => t.id,
-      referencedTable: $db.playerGameTable,
-      getReferencedColumn: (t) => t.gameId,
+      referencedTable: $db.playerMatchTable,
+      getReferencedColumn: (t) => t.matchId,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$PlayerGameTableTableFilterComposer(
+          }) => $$PlayerMatchTableTableFilterComposer(
             $db: $db,
-            $table: $db.playerGameTable,
+            $table: $db.playerMatchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -2441,22 +2459,22 @@ class $$GameTableTableFilterComposer
     return f(composer);
   }
 
-  Expression<bool> groupGameTableRefs(
-    Expression<bool> Function($$GroupGameTableTableFilterComposer f) f,
+  Expression<bool> groupMatchTableRefs(
+    Expression<bool> Function($$GroupMatchTableTableFilterComposer f) f,
   ) {
-    final $$GroupGameTableTableFilterComposer composer = $composerBuilder(
+    final $$GroupMatchTableTableFilterComposer composer = $composerBuilder(
       composer: this,
       getCurrentColumn: (t) => t.id,
-      referencedTable: $db.groupGameTable,
-      getReferencedColumn: (t) => t.gameId,
+      referencedTable: $db.groupMatchTable,
+      getReferencedColumn: (t) => t.matchId,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$GroupGameTableTableFilterComposer(
+          }) => $$GroupMatchTableTableFilterComposer(
             $db: $db,
-            $table: $db.groupGameTable,
+            $table: $db.groupMatchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -2467,9 +2485,9 @@ class $$GameTableTableFilterComposer
   }
 }
 
-class $$GameTableTableOrderingComposer
-    extends Composer<_$AppDatabase, $GameTableTable> {
-  $$GameTableTableOrderingComposer({
+class $$MatchTableTableOrderingComposer
+    extends Composer<_$AppDatabase, $MatchTableTable> {
+  $$MatchTableTableOrderingComposer({
     required super.$db,
     required super.$table,
     super.joinBuilder,
@@ -2497,9 +2515,9 @@ class $$GameTableTableOrderingComposer
   );
 }
 
-class $$GameTableTableAnnotationComposer
-    extends Composer<_$AppDatabase, $GameTableTable> {
-  $$GameTableTableAnnotationComposer({
+class $$MatchTableTableAnnotationComposer
+    extends Composer<_$AppDatabase, $MatchTableTable> {
+  $$MatchTableTableAnnotationComposer({
     required super.$db,
     required super.$table,
     super.joinBuilder,
@@ -2518,22 +2536,22 @@ class $$GameTableTableAnnotationComposer
   GeneratedColumn<DateTime> get createdAt =>
       $composableBuilder(column: $table.createdAt, builder: (column) => column);
 
-  Expression<T> playerGameTableRefs<T extends Object>(
-    Expression<T> Function($$PlayerGameTableTableAnnotationComposer a) f,
+  Expression<T> playerMatchTableRefs<T extends Object>(
+    Expression<T> Function($$PlayerMatchTableTableAnnotationComposer a) f,
   ) {
-    final $$PlayerGameTableTableAnnotationComposer composer = $composerBuilder(
+    final $$PlayerMatchTableTableAnnotationComposer composer = $composerBuilder(
       composer: this,
       getCurrentColumn: (t) => t.id,
-      referencedTable: $db.playerGameTable,
-      getReferencedColumn: (t) => t.gameId,
+      referencedTable: $db.playerMatchTable,
+      getReferencedColumn: (t) => t.matchId,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$PlayerGameTableTableAnnotationComposer(
+          }) => $$PlayerMatchTableTableAnnotationComposer(
             $db: $db,
-            $table: $db.playerGameTable,
+            $table: $db.playerMatchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -2543,22 +2561,22 @@ class $$GameTableTableAnnotationComposer
     return f(composer);
   }
 
-  Expression<T> groupGameTableRefs<T extends Object>(
-    Expression<T> Function($$GroupGameTableTableAnnotationComposer a) f,
+  Expression<T> groupMatchTableRefs<T extends Object>(
+    Expression<T> Function($$GroupMatchTableTableAnnotationComposer a) f,
   ) {
-    final $$GroupGameTableTableAnnotationComposer composer = $composerBuilder(
+    final $$GroupMatchTableTableAnnotationComposer composer = $composerBuilder(
       composer: this,
       getCurrentColumn: (t) => t.id,
-      referencedTable: $db.groupGameTable,
-      getReferencedColumn: (t) => t.gameId,
+      referencedTable: $db.groupMatchTable,
+      getReferencedColumn: (t) => t.matchId,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$GroupGameTableTableAnnotationComposer(
+          }) => $$GroupMatchTableTableAnnotationComposer(
             $db: $db,
-            $table: $db.groupGameTable,
+            $table: $db.groupMatchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -2569,35 +2587,35 @@ class $$GameTableTableAnnotationComposer
   }
 }
 
-class $$GameTableTableTableManager
+class $$MatchTableTableTableManager
     extends
         RootTableManager<
           _$AppDatabase,
-          $GameTableTable,
-          GameTableData,
-          $$GameTableTableFilterComposer,
-          $$GameTableTableOrderingComposer,
-          $$GameTableTableAnnotationComposer,
-          $$GameTableTableCreateCompanionBuilder,
-          $$GameTableTableUpdateCompanionBuilder,
-          (GameTableData, $$GameTableTableReferences),
-          GameTableData,
+          $MatchTableTable,
+          MatchTableData,
+          $$MatchTableTableFilterComposer,
+          $$MatchTableTableOrderingComposer,
+          $$MatchTableTableAnnotationComposer,
+          $$MatchTableTableCreateCompanionBuilder,
+          $$MatchTableTableUpdateCompanionBuilder,
+          (MatchTableData, $$MatchTableTableReferences),
+          MatchTableData,
           PrefetchHooks Function({
-            bool playerGameTableRefs,
-            bool groupGameTableRefs,
+            bool playerMatchTableRefs,
+            bool groupMatchTableRefs,
           })
         > {
-  $$GameTableTableTableManager(_$AppDatabase db, $GameTableTable table)
+  $$MatchTableTableTableManager(_$AppDatabase db, $MatchTableTable table)
     : super(
         TableManagerState(
           db: db,
           table: table,
           createFilteringComposer: () =>
-              $$GameTableTableFilterComposer($db: db, $table: table),
+              $$MatchTableTableFilterComposer($db: db, $table: table),
           createOrderingComposer: () =>
-              $$GameTableTableOrderingComposer($db: db, $table: table),
+              $$MatchTableTableOrderingComposer($db: db, $table: table),
           createComputedFieldComposer: () =>
-              $$GameTableTableAnnotationComposer($db: db, $table: table),
+              $$MatchTableTableAnnotationComposer($db: db, $table: table),
           updateCompanionCallback:
               ({
                 Value<String> id = const Value.absent(),
@@ -2605,7 +2623,7 @@ class $$GameTableTableTableManager
                 Value<String?> winnerId = const Value.absent(),
                 Value<DateTime> createdAt = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
-              }) => GameTableCompanion(
+              }) => MatchTableCompanion(
                 id: id,
                 name: name,
                 winnerId: winnerId,
@@ -2619,7 +2637,7 @@ class $$GameTableTableTableManager
                 Value<String?> winnerId = const Value.absent(),
                 required DateTime createdAt,
                 Value<int> rowid = const Value.absent(),
-              }) => GameTableCompanion.insert(
+              }) => MatchTableCompanion.insert(
                 id: id,
                 name: name,
                 winnerId: winnerId,
@@ -2630,60 +2648,60 @@ class $$GameTableTableTableManager
               .map(
                 (e) => (
                   e.readTable(table),
-                  $$GameTableTableReferences(db, table, e),
+                  $$MatchTableTableReferences(db, table, e),
                 ),
               )
               .toList(),
           prefetchHooksCallback:
-              ({playerGameTableRefs = false, groupGameTableRefs = false}) {
+              ({playerMatchTableRefs = false, groupMatchTableRefs = false}) {
                 return PrefetchHooks(
                   db: db,
                   explicitlyWatchedTables: [
-                    if (playerGameTableRefs) db.playerGameTable,
-                    if (groupGameTableRefs) db.groupGameTable,
+                    if (playerMatchTableRefs) db.playerMatchTable,
+                    if (groupMatchTableRefs) db.groupMatchTable,
                   ],
                   addJoins: null,
                   getPrefetchedDataCallback: (items) async {
                     return [
-                      if (playerGameTableRefs)
+                      if (playerMatchTableRefs)
                         await $_getPrefetchedData<
-                          GameTableData,
-                          $GameTableTable,
-                          PlayerGameTableData
+                          MatchTableData,
+                          $MatchTableTable,
+                          PlayerMatchTableData
                         >(
                           currentTable: table,
-                          referencedTable: $$GameTableTableReferences
-                              ._playerGameTableRefsTable(db),
+                          referencedTable: $$MatchTableTableReferences
+                              ._playerMatchTableRefsTable(db),
                           managerFromTypedResult: (p0) =>
-                              $$GameTableTableReferences(
+                              $$MatchTableTableReferences(
                                 db,
                                 table,
                                 p0,
-                              ).playerGameTableRefs,
+                              ).playerMatchTableRefs,
                           referencedItemsForCurrentItem:
                               (item, referencedItems) => referencedItems.where(
-                                (e) => e.gameId == item.id,
+                                (e) => e.matchId == item.id,
                               ),
                           typedResults: items,
                         ),
-                      if (groupGameTableRefs)
+                      if (groupMatchTableRefs)
                         await $_getPrefetchedData<
-                          GameTableData,
-                          $GameTableTable,
-                          GroupGameTableData
+                          MatchTableData,
+                          $MatchTableTable,
+                          GroupMatchTableData
                         >(
                           currentTable: table,
-                          referencedTable: $$GameTableTableReferences
-                              ._groupGameTableRefsTable(db),
+                          referencedTable: $$MatchTableTableReferences
+                              ._groupMatchTableRefsTable(db),
                           managerFromTypedResult: (p0) =>
-                              $$GameTableTableReferences(
+                              $$MatchTableTableReferences(
                                 db,
                                 table,
                                 p0,
-                              ).groupGameTableRefs,
+                              ).groupMatchTableRefs,
                           referencedItemsForCurrentItem:
                               (item, referencedItems) => referencedItems.where(
-                                (e) => e.gameId == item.id,
+                                (e) => e.matchId == item.id,
                               ),
                           typedResults: items,
                         ),
@@ -2695,21 +2713,21 @@ class $$GameTableTableTableManager
       );
 }
 
-typedef $$GameTableTableProcessedTableManager =
+typedef $$MatchTableTableProcessedTableManager =
     ProcessedTableManager<
       _$AppDatabase,
-      $GameTableTable,
-      GameTableData,
-      $$GameTableTableFilterComposer,
-      $$GameTableTableOrderingComposer,
-      $$GameTableTableAnnotationComposer,
-      $$GameTableTableCreateCompanionBuilder,
-      $$GameTableTableUpdateCompanionBuilder,
-      (GameTableData, $$GameTableTableReferences),
-      GameTableData,
+      $MatchTableTable,
+      MatchTableData,
+      $$MatchTableTableFilterComposer,
+      $$MatchTableTableOrderingComposer,
+      $$MatchTableTableAnnotationComposer,
+      $$MatchTableTableCreateCompanionBuilder,
+      $$MatchTableTableUpdateCompanionBuilder,
+      (MatchTableData, $$MatchTableTableReferences),
+      MatchTableData,
       PrefetchHooks Function({
-        bool playerGameTableRefs,
-        bool groupGameTableRefs,
+        bool playerMatchTableRefs,
+        bool groupMatchTableRefs,
       })
     >;
 typedef $$PlayerGroupTableTableCreateCompanionBuilder =
@@ -3077,27 +3095,27 @@ typedef $$PlayerGroupTableTableProcessedTableManager =
       PlayerGroupTableData,
       PrefetchHooks Function({bool playerId, bool groupId})
     >;
-typedef $$PlayerGameTableTableCreateCompanionBuilder =
-    PlayerGameTableCompanion Function({
+typedef $$PlayerMatchTableTableCreateCompanionBuilder =
+    PlayerMatchTableCompanion Function({
       required String playerId,
-      required String gameId,
+      required String matchId,
       Value<int> rowid,
     });
-typedef $$PlayerGameTableTableUpdateCompanionBuilder =
-    PlayerGameTableCompanion Function({
+typedef $$PlayerMatchTableTableUpdateCompanionBuilder =
+    PlayerMatchTableCompanion Function({
       Value<String> playerId,
-      Value<String> gameId,
+      Value<String> matchId,
       Value<int> rowid,
     });
 
-final class $$PlayerGameTableTableReferences
+final class $$PlayerMatchTableTableReferences
     extends
         BaseReferences<
           _$AppDatabase,
-          $PlayerGameTableTable,
-          PlayerGameTableData
+          $PlayerMatchTableTable,
+          PlayerMatchTableData
         > {
-  $$PlayerGameTableTableReferences(
+  $$PlayerMatchTableTableReferences(
     super.$_db,
     super.$_table,
     super.$_typedResult,
@@ -3105,7 +3123,7 @@ final class $$PlayerGameTableTableReferences
 
   static $PlayerTableTable _playerIdTable(_$AppDatabase db) =>
       db.playerTable.createAlias(
-        $_aliasNameGenerator(db.playerGameTable.playerId, db.playerTable.id),
+        $_aliasNameGenerator(db.playerMatchTable.playerId, db.playerTable.id),
       );
 
   $$PlayerTableTableProcessedTableManager get playerId {
@@ -3122,19 +3140,19 @@ final class $$PlayerGameTableTableReferences
     );
   }
 
-  static $GameTableTable _gameIdTable(_$AppDatabase db) =>
-      db.gameTable.createAlias(
-        $_aliasNameGenerator(db.playerGameTable.gameId, db.gameTable.id),
+  static $MatchTableTable _matchIdTable(_$AppDatabase db) =>
+      db.matchTable.createAlias(
+        $_aliasNameGenerator(db.playerMatchTable.matchId, db.matchTable.id),
       );
 
-  $$GameTableTableProcessedTableManager get gameId {
-    final $_column = $_itemColumn<String>('game_id')!;
+  $$MatchTableTableProcessedTableManager get matchId {
+    final $_column = $_itemColumn<String>('match_id')!;
 
-    final manager = $$GameTableTableTableManager(
+    final manager = $$MatchTableTableTableManager(
       $_db,
-      $_db.gameTable,
+      $_db.matchTable,
     ).filter((f) => f.id.sqlEquals($_column));
-    final item = $_typedResult.readTableOrNull(_gameIdTable($_db));
+    final item = $_typedResult.readTableOrNull(_matchIdTable($_db));
     if (item == null) return manager;
     return ProcessedTableManager(
       manager.$state.copyWith(prefetchedData: [item]),
@@ -3142,9 +3160,9 @@ final class $$PlayerGameTableTableReferences
   }
 }
 
-class $$PlayerGameTableTableFilterComposer
-    extends Composer<_$AppDatabase, $PlayerGameTableTable> {
-  $$PlayerGameTableTableFilterComposer({
+class $$PlayerMatchTableTableFilterComposer
+    extends Composer<_$AppDatabase, $PlayerMatchTableTable> {
+  $$PlayerMatchTableTableFilterComposer({
     required super.$db,
     required super.$table,
     super.joinBuilder,
@@ -3174,20 +3192,20 @@ class $$PlayerGameTableTableFilterComposer
     return composer;
   }
 
-  $$GameTableTableFilterComposer get gameId {
-    final $$GameTableTableFilterComposer composer = $composerBuilder(
+  $$MatchTableTableFilterComposer get matchId {
+    final $$MatchTableTableFilterComposer composer = $composerBuilder(
       composer: this,
-      getCurrentColumn: (t) => t.gameId,
-      referencedTable: $db.gameTable,
+      getCurrentColumn: (t) => t.matchId,
+      referencedTable: $db.matchTable,
       getReferencedColumn: (t) => t.id,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$GameTableTableFilterComposer(
+          }) => $$MatchTableTableFilterComposer(
             $db: $db,
-            $table: $db.gameTable,
+            $table: $db.matchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -3198,9 +3216,9 @@ class $$PlayerGameTableTableFilterComposer
   }
 }
 
-class $$PlayerGameTableTableOrderingComposer
-    extends Composer<_$AppDatabase, $PlayerGameTableTable> {
-  $$PlayerGameTableTableOrderingComposer({
+class $$PlayerMatchTableTableOrderingComposer
+    extends Composer<_$AppDatabase, $PlayerMatchTableTable> {
+  $$PlayerMatchTableTableOrderingComposer({
     required super.$db,
     required super.$table,
     super.joinBuilder,
@@ -3230,20 +3248,20 @@ class $$PlayerGameTableTableOrderingComposer
     return composer;
   }
 
-  $$GameTableTableOrderingComposer get gameId {
-    final $$GameTableTableOrderingComposer composer = $composerBuilder(
+  $$MatchTableTableOrderingComposer get matchId {
+    final $$MatchTableTableOrderingComposer composer = $composerBuilder(
       composer: this,
-      getCurrentColumn: (t) => t.gameId,
-      referencedTable: $db.gameTable,
+      getCurrentColumn: (t) => t.matchId,
+      referencedTable: $db.matchTable,
       getReferencedColumn: (t) => t.id,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$GameTableTableOrderingComposer(
+          }) => $$MatchTableTableOrderingComposer(
             $db: $db,
-            $table: $db.gameTable,
+            $table: $db.matchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -3254,9 +3272,9 @@ class $$PlayerGameTableTableOrderingComposer
   }
 }
 
-class $$PlayerGameTableTableAnnotationComposer
-    extends Composer<_$AppDatabase, $PlayerGameTableTable> {
-  $$PlayerGameTableTableAnnotationComposer({
+class $$PlayerMatchTableTableAnnotationComposer
+    extends Composer<_$AppDatabase, $PlayerMatchTableTable> {
+  $$PlayerMatchTableTableAnnotationComposer({
     required super.$db,
     required super.$table,
     super.joinBuilder,
@@ -3286,20 +3304,20 @@ class $$PlayerGameTableTableAnnotationComposer
     return composer;
   }
 
-  $$GameTableTableAnnotationComposer get gameId {
-    final $$GameTableTableAnnotationComposer composer = $composerBuilder(
+  $$MatchTableTableAnnotationComposer get matchId {
+    final $$MatchTableTableAnnotationComposer composer = $composerBuilder(
       composer: this,
-      getCurrentColumn: (t) => t.gameId,
-      referencedTable: $db.gameTable,
+      getCurrentColumn: (t) => t.matchId,
+      referencedTable: $db.matchTable,
       getReferencedColumn: (t) => t.id,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$GameTableTableAnnotationComposer(
+          }) => $$MatchTableTableAnnotationComposer(
             $db: $db,
-            $table: $db.gameTable,
+            $table: $db.matchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -3310,63 +3328,63 @@ class $$PlayerGameTableTableAnnotationComposer
   }
 }
 
-class $$PlayerGameTableTableTableManager
+class $$PlayerMatchTableTableTableManager
     extends
         RootTableManager<
           _$AppDatabase,
-          $PlayerGameTableTable,
-          PlayerGameTableData,
-          $$PlayerGameTableTableFilterComposer,
-          $$PlayerGameTableTableOrderingComposer,
-          $$PlayerGameTableTableAnnotationComposer,
-          $$PlayerGameTableTableCreateCompanionBuilder,
-          $$PlayerGameTableTableUpdateCompanionBuilder,
-          (PlayerGameTableData, $$PlayerGameTableTableReferences),
-          PlayerGameTableData,
-          PrefetchHooks Function({bool playerId, bool gameId})
+          $PlayerMatchTableTable,
+          PlayerMatchTableData,
+          $$PlayerMatchTableTableFilterComposer,
+          $$PlayerMatchTableTableOrderingComposer,
+          $$PlayerMatchTableTableAnnotationComposer,
+          $$PlayerMatchTableTableCreateCompanionBuilder,
+          $$PlayerMatchTableTableUpdateCompanionBuilder,
+          (PlayerMatchTableData, $$PlayerMatchTableTableReferences),
+          PlayerMatchTableData,
+          PrefetchHooks Function({bool playerId, bool matchId})
         > {
-  $$PlayerGameTableTableTableManager(
+  $$PlayerMatchTableTableTableManager(
     _$AppDatabase db,
-    $PlayerGameTableTable table,
+    $PlayerMatchTableTable table,
   ) : super(
         TableManagerState(
           db: db,
           table: table,
           createFilteringComposer: () =>
-              $$PlayerGameTableTableFilterComposer($db: db, $table: table),
+              $$PlayerMatchTableTableFilterComposer($db: db, $table: table),
           createOrderingComposer: () =>
-              $$PlayerGameTableTableOrderingComposer($db: db, $table: table),
+              $$PlayerMatchTableTableOrderingComposer($db: db, $table: table),
           createComputedFieldComposer: () =>
-              $$PlayerGameTableTableAnnotationComposer($db: db, $table: table),
+              $$PlayerMatchTableTableAnnotationComposer($db: db, $table: table),
           updateCompanionCallback:
               ({
                 Value<String> playerId = const Value.absent(),
-                Value<String> gameId = const Value.absent(),
+                Value<String> matchId = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
-              }) => PlayerGameTableCompanion(
+              }) => PlayerMatchTableCompanion(
                 playerId: playerId,
-                gameId: gameId,
+                matchId: matchId,
                 rowid: rowid,
               ),
           createCompanionCallback:
               ({
                 required String playerId,
-                required String gameId,
+                required String matchId,
                 Value<int> rowid = const Value.absent(),
-              }) => PlayerGameTableCompanion.insert(
+              }) => PlayerMatchTableCompanion.insert(
                 playerId: playerId,
-                gameId: gameId,
+                matchId: matchId,
                 rowid: rowid,
               ),
           withReferenceMapper: (p0) => p0
               .map(
                 (e) => (
                   e.readTable(table),
-                  $$PlayerGameTableTableReferences(db, table, e),
+                  $$PlayerMatchTableTableReferences(db, table, e),
                 ),
               )
               .toList(),
-          prefetchHooksCallback: ({playerId = false, gameId = false}) {
+          prefetchHooksCallback: ({playerId = false, matchId = false}) {
             return PrefetchHooks(
               db: db,
               explicitlyWatchedTables: [],
@@ -3392,26 +3410,26 @@ class $$PlayerGameTableTableTableManager
                                 currentTable: table,
                                 currentColumn: table.playerId,
                                 referencedTable:
-                                    $$PlayerGameTableTableReferences
+                                    $$PlayerMatchTableTableReferences
                                         ._playerIdTable(db),
                                 referencedColumn:
-                                    $$PlayerGameTableTableReferences
+                                    $$PlayerMatchTableTableReferences
                                         ._playerIdTable(db)
                                         .id,
                               )
                               as T;
                     }
-                    if (gameId) {
+                    if (matchId) {
                       state =
                           state.withJoin(
                                 currentTable: table,
-                                currentColumn: table.gameId,
+                                currentColumn: table.matchId,
                                 referencedTable:
-                                    $$PlayerGameTableTableReferences
-                                        ._gameIdTable(db),
+                                    $$PlayerMatchTableTableReferences
+                                        ._matchIdTable(db),
                                 referencedColumn:
-                                    $$PlayerGameTableTableReferences
-                                        ._gameIdTable(db)
+                                    $$PlayerMatchTableTableReferences
+                                        ._matchIdTable(db)
                                         .id,
                               )
                               as T;
@@ -3428,41 +3446,41 @@ class $$PlayerGameTableTableTableManager
       );
 }
 
-typedef $$PlayerGameTableTableProcessedTableManager =
+typedef $$PlayerMatchTableTableProcessedTableManager =
     ProcessedTableManager<
       _$AppDatabase,
-      $PlayerGameTableTable,
-      PlayerGameTableData,
-      $$PlayerGameTableTableFilterComposer,
-      $$PlayerGameTableTableOrderingComposer,
-      $$PlayerGameTableTableAnnotationComposer,
-      $$PlayerGameTableTableCreateCompanionBuilder,
-      $$PlayerGameTableTableUpdateCompanionBuilder,
-      (PlayerGameTableData, $$PlayerGameTableTableReferences),
-      PlayerGameTableData,
-      PrefetchHooks Function({bool playerId, bool gameId})
+      $PlayerMatchTableTable,
+      PlayerMatchTableData,
+      $$PlayerMatchTableTableFilterComposer,
+      $$PlayerMatchTableTableOrderingComposer,
+      $$PlayerMatchTableTableAnnotationComposer,
+      $$PlayerMatchTableTableCreateCompanionBuilder,
+      $$PlayerMatchTableTableUpdateCompanionBuilder,
+      (PlayerMatchTableData, $$PlayerMatchTableTableReferences),
+      PlayerMatchTableData,
+      PrefetchHooks Function({bool playerId, bool matchId})
     >;
-typedef $$GroupGameTableTableCreateCompanionBuilder =
-    GroupGameTableCompanion Function({
+typedef $$GroupMatchTableTableCreateCompanionBuilder =
+    GroupMatchTableCompanion Function({
       required String groupId,
-      required String gameId,
+      required String matchId,
       Value<int> rowid,
     });
-typedef $$GroupGameTableTableUpdateCompanionBuilder =
-    GroupGameTableCompanion Function({
+typedef $$GroupMatchTableTableUpdateCompanionBuilder =
+    GroupMatchTableCompanion Function({
       Value<String> groupId,
-      Value<String> gameId,
+      Value<String> matchId,
       Value<int> rowid,
     });
 
-final class $$GroupGameTableTableReferences
+final class $$GroupMatchTableTableReferences
     extends
         BaseReferences<
           _$AppDatabase,
-          $GroupGameTableTable,
-          GroupGameTableData
+          $GroupMatchTableTable,
+          GroupMatchTableData
         > {
-  $$GroupGameTableTableReferences(
+  $$GroupMatchTableTableReferences(
     super.$_db,
     super.$_table,
     super.$_typedResult,
@@ -3470,7 +3488,7 @@ final class $$GroupGameTableTableReferences
 
   static $GroupTableTable _groupIdTable(_$AppDatabase db) =>
       db.groupTable.createAlias(
-        $_aliasNameGenerator(db.groupGameTable.groupId, db.groupTable.id),
+        $_aliasNameGenerator(db.groupMatchTable.groupId, db.groupTable.id),
       );
 
   $$GroupTableTableProcessedTableManager get groupId {
@@ -3487,19 +3505,19 @@ final class $$GroupGameTableTableReferences
     );
   }
 
-  static $GameTableTable _gameIdTable(_$AppDatabase db) =>
-      db.gameTable.createAlias(
-        $_aliasNameGenerator(db.groupGameTable.gameId, db.gameTable.id),
+  static $MatchTableTable _matchIdTable(_$AppDatabase db) =>
+      db.matchTable.createAlias(
+        $_aliasNameGenerator(db.groupMatchTable.matchId, db.matchTable.id),
       );
 
-  $$GameTableTableProcessedTableManager get gameId {
-    final $_column = $_itemColumn<String>('game_id')!;
+  $$MatchTableTableProcessedTableManager get matchId {
+    final $_column = $_itemColumn<String>('match_id')!;
 
-    final manager = $$GameTableTableTableManager(
+    final manager = $$MatchTableTableTableManager(
       $_db,
-      $_db.gameTable,
+      $_db.matchTable,
     ).filter((f) => f.id.sqlEquals($_column));
-    final item = $_typedResult.readTableOrNull(_gameIdTable($_db));
+    final item = $_typedResult.readTableOrNull(_matchIdTable($_db));
     if (item == null) return manager;
     return ProcessedTableManager(
       manager.$state.copyWith(prefetchedData: [item]),
@@ -3507,9 +3525,9 @@ final class $$GroupGameTableTableReferences
   }
 }
 
-class $$GroupGameTableTableFilterComposer
-    extends Composer<_$AppDatabase, $GroupGameTableTable> {
-  $$GroupGameTableTableFilterComposer({
+class $$GroupMatchTableTableFilterComposer
+    extends Composer<_$AppDatabase, $GroupMatchTableTable> {
+  $$GroupMatchTableTableFilterComposer({
     required super.$db,
     required super.$table,
     super.joinBuilder,
@@ -3539,20 +3557,20 @@ class $$GroupGameTableTableFilterComposer
     return composer;
   }
 
-  $$GameTableTableFilterComposer get gameId {
-    final $$GameTableTableFilterComposer composer = $composerBuilder(
+  $$MatchTableTableFilterComposer get matchId {
+    final $$MatchTableTableFilterComposer composer = $composerBuilder(
       composer: this,
-      getCurrentColumn: (t) => t.gameId,
-      referencedTable: $db.gameTable,
+      getCurrentColumn: (t) => t.matchId,
+      referencedTable: $db.matchTable,
       getReferencedColumn: (t) => t.id,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$GameTableTableFilterComposer(
+          }) => $$MatchTableTableFilterComposer(
             $db: $db,
-            $table: $db.gameTable,
+            $table: $db.matchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -3563,9 +3581,9 @@ class $$GroupGameTableTableFilterComposer
   }
 }
 
-class $$GroupGameTableTableOrderingComposer
-    extends Composer<_$AppDatabase, $GroupGameTableTable> {
-  $$GroupGameTableTableOrderingComposer({
+class $$GroupMatchTableTableOrderingComposer
+    extends Composer<_$AppDatabase, $GroupMatchTableTable> {
+  $$GroupMatchTableTableOrderingComposer({
     required super.$db,
     required super.$table,
     super.joinBuilder,
@@ -3595,20 +3613,20 @@ class $$GroupGameTableTableOrderingComposer
     return composer;
   }
 
-  $$GameTableTableOrderingComposer get gameId {
-    final $$GameTableTableOrderingComposer composer = $composerBuilder(
+  $$MatchTableTableOrderingComposer get matchId {
+    final $$MatchTableTableOrderingComposer composer = $composerBuilder(
       composer: this,
-      getCurrentColumn: (t) => t.gameId,
-      referencedTable: $db.gameTable,
+      getCurrentColumn: (t) => t.matchId,
+      referencedTable: $db.matchTable,
       getReferencedColumn: (t) => t.id,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$GameTableTableOrderingComposer(
+          }) => $$MatchTableTableOrderingComposer(
             $db: $db,
-            $table: $db.gameTable,
+            $table: $db.matchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -3619,9 +3637,9 @@ class $$GroupGameTableTableOrderingComposer
   }
 }
 
-class $$GroupGameTableTableAnnotationComposer
-    extends Composer<_$AppDatabase, $GroupGameTableTable> {
-  $$GroupGameTableTableAnnotationComposer({
+class $$GroupMatchTableTableAnnotationComposer
+    extends Composer<_$AppDatabase, $GroupMatchTableTable> {
+  $$GroupMatchTableTableAnnotationComposer({
     required super.$db,
     required super.$table,
     super.joinBuilder,
@@ -3651,20 +3669,20 @@ class $$GroupGameTableTableAnnotationComposer
     return composer;
   }
 
-  $$GameTableTableAnnotationComposer get gameId {
-    final $$GameTableTableAnnotationComposer composer = $composerBuilder(
+  $$MatchTableTableAnnotationComposer get matchId {
+    final $$MatchTableTableAnnotationComposer composer = $composerBuilder(
       composer: this,
-      getCurrentColumn: (t) => t.gameId,
-      referencedTable: $db.gameTable,
+      getCurrentColumn: (t) => t.matchId,
+      referencedTable: $db.matchTable,
       getReferencedColumn: (t) => t.id,
       builder:
           (
             joinBuilder, {
             $addJoinBuilderToRootComposer,
             $removeJoinBuilderFromRootComposer,
-          }) => $$GameTableTableAnnotationComposer(
+          }) => $$MatchTableTableAnnotationComposer(
             $db: $db,
-            $table: $db.gameTable,
+            $table: $db.matchTable,
             $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
             joinBuilder: joinBuilder,
             $removeJoinBuilderFromRootComposer:
@@ -3675,63 +3693,63 @@ class $$GroupGameTableTableAnnotationComposer
   }
 }
 
-class $$GroupGameTableTableTableManager
+class $$GroupMatchTableTableTableManager
     extends
         RootTableManager<
           _$AppDatabase,
-          $GroupGameTableTable,
-          GroupGameTableData,
-          $$GroupGameTableTableFilterComposer,
-          $$GroupGameTableTableOrderingComposer,
-          $$GroupGameTableTableAnnotationComposer,
-          $$GroupGameTableTableCreateCompanionBuilder,
-          $$GroupGameTableTableUpdateCompanionBuilder,
-          (GroupGameTableData, $$GroupGameTableTableReferences),
-          GroupGameTableData,
-          PrefetchHooks Function({bool groupId, bool gameId})
+          $GroupMatchTableTable,
+          GroupMatchTableData,
+          $$GroupMatchTableTableFilterComposer,
+          $$GroupMatchTableTableOrderingComposer,
+          $$GroupMatchTableTableAnnotationComposer,
+          $$GroupMatchTableTableCreateCompanionBuilder,
+          $$GroupMatchTableTableUpdateCompanionBuilder,
+          (GroupMatchTableData, $$GroupMatchTableTableReferences),
+          GroupMatchTableData,
+          PrefetchHooks Function({bool groupId, bool matchId})
         > {
-  $$GroupGameTableTableTableManager(
+  $$GroupMatchTableTableTableManager(
     _$AppDatabase db,
-    $GroupGameTableTable table,
+    $GroupMatchTableTable table,
   ) : super(
         TableManagerState(
           db: db,
           table: table,
           createFilteringComposer: () =>
-              $$GroupGameTableTableFilterComposer($db: db, $table: table),
+              $$GroupMatchTableTableFilterComposer($db: db, $table: table),
           createOrderingComposer: () =>
-              $$GroupGameTableTableOrderingComposer($db: db, $table: table),
+              $$GroupMatchTableTableOrderingComposer($db: db, $table: table),
           createComputedFieldComposer: () =>
-              $$GroupGameTableTableAnnotationComposer($db: db, $table: table),
+              $$GroupMatchTableTableAnnotationComposer($db: db, $table: table),
           updateCompanionCallback:
               ({
                 Value<String> groupId = const Value.absent(),
-                Value<String> gameId = const Value.absent(),
+                Value<String> matchId = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
-              }) => GroupGameTableCompanion(
+              }) => GroupMatchTableCompanion(
                 groupId: groupId,
-                gameId: gameId,
+                matchId: matchId,
                 rowid: rowid,
               ),
           createCompanionCallback:
               ({
                 required String groupId,
-                required String gameId,
+                required String matchId,
                 Value<int> rowid = const Value.absent(),
-              }) => GroupGameTableCompanion.insert(
+              }) => GroupMatchTableCompanion.insert(
                 groupId: groupId,
-                gameId: gameId,
+                matchId: matchId,
                 rowid: rowid,
               ),
           withReferenceMapper: (p0) => p0
               .map(
                 (e) => (
                   e.readTable(table),
-                  $$GroupGameTableTableReferences(db, table, e),
+                  $$GroupMatchTableTableReferences(db, table, e),
                 ),
               )
               .toList(),
-          prefetchHooksCallback: ({groupId = false, gameId = false}) {
+          prefetchHooksCallback: ({groupId = false, matchId = false}) {
             return PrefetchHooks(
               db: db,
               explicitlyWatchedTables: [],
@@ -3756,25 +3774,27 @@ class $$GroupGameTableTableTableManager
                           state.withJoin(
                                 currentTable: table,
                                 currentColumn: table.groupId,
-                                referencedTable: $$GroupGameTableTableReferences
-                                    ._groupIdTable(db),
+                                referencedTable:
+                                    $$GroupMatchTableTableReferences
+                                        ._groupIdTable(db),
                                 referencedColumn:
-                                    $$GroupGameTableTableReferences
+                                    $$GroupMatchTableTableReferences
                                         ._groupIdTable(db)
                                         .id,
                               )
                               as T;
                     }
-                    if (gameId) {
+                    if (matchId) {
                       state =
                           state.withJoin(
                                 currentTable: table,
-                                currentColumn: table.gameId,
-                                referencedTable: $$GroupGameTableTableReferences
-                                    ._gameIdTable(db),
+                                currentColumn: table.matchId,
+                                referencedTable:
+                                    $$GroupMatchTableTableReferences
+                                        ._matchIdTable(db),
                                 referencedColumn:
-                                    $$GroupGameTableTableReferences
-                                        ._gameIdTable(db)
+                                    $$GroupMatchTableTableReferences
+                                        ._matchIdTable(db)
                                         .id,
                               )
                               as T;
@@ -3791,19 +3811,19 @@ class $$GroupGameTableTableTableManager
       );
 }
 
-typedef $$GroupGameTableTableProcessedTableManager =
+typedef $$GroupMatchTableTableProcessedTableManager =
     ProcessedTableManager<
       _$AppDatabase,
-      $GroupGameTableTable,
-      GroupGameTableData,
-      $$GroupGameTableTableFilterComposer,
-      $$GroupGameTableTableOrderingComposer,
-      $$GroupGameTableTableAnnotationComposer,
-      $$GroupGameTableTableCreateCompanionBuilder,
-      $$GroupGameTableTableUpdateCompanionBuilder,
-      (GroupGameTableData, $$GroupGameTableTableReferences),
-      GroupGameTableData,
-      PrefetchHooks Function({bool groupId, bool gameId})
+      $GroupMatchTableTable,
+      GroupMatchTableData,
+      $$GroupMatchTableTableFilterComposer,
+      $$GroupMatchTableTableOrderingComposer,
+      $$GroupMatchTableTableAnnotationComposer,
+      $$GroupMatchTableTableCreateCompanionBuilder,
+      $$GroupMatchTableTableUpdateCompanionBuilder,
+      (GroupMatchTableData, $$GroupMatchTableTableReferences),
+      GroupMatchTableData,
+      PrefetchHooks Function({bool groupId, bool matchId})
     >;
 
 class $AppDatabaseManager {
@@ -3813,12 +3833,12 @@ class $AppDatabaseManager {
       $$PlayerTableTableTableManager(_db, _db.playerTable);
   $$GroupTableTableTableManager get groupTable =>
       $$GroupTableTableTableManager(_db, _db.groupTable);
-  $$GameTableTableTableManager get gameTable =>
-      $$GameTableTableTableManager(_db, _db.gameTable);
+  $$MatchTableTableTableManager get matchTable =>
+      $$MatchTableTableTableManager(_db, _db.matchTable);
   $$PlayerGroupTableTableTableManager get playerGroupTable =>
       $$PlayerGroupTableTableTableManager(_db, _db.playerGroupTable);
-  $$PlayerGameTableTableTableManager get playerGameTable =>
-      $$PlayerGameTableTableTableManager(_db, _db.playerGameTable);
-  $$GroupGameTableTableTableManager get groupGameTable =>
-      $$GroupGameTableTableTableManager(_db, _db.groupGameTable);
+  $$PlayerMatchTableTableTableManager get playerMatchTable =>
+      $$PlayerMatchTableTableTableManager(_db, _db.playerMatchTable);
+  $$GroupMatchTableTableTableManager get groupMatchTable =>
+      $$GroupMatchTableTableTableManager(_db, _db.groupMatchTable);
 }
diff --git a/lib/data/db/tables/group_game_table.dart b/lib/data/db/tables/group_game_table.dart
deleted file mode 100644
index a16672e..0000000
--- a/lib/data/db/tables/group_game_table.dart
+++ /dev/null
@@ -1,13 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:game_tracker/data/db/tables/game_table.dart';
-import 'package:game_tracker/data/db/tables/group_table.dart';
-
-class GroupGameTable extends Table {
-  TextColumn get groupId =>
-      text().references(GroupTable, #id, onDelete: KeyAction.cascade)();
-  TextColumn get gameId =>
-      text().references(GameTable, #id, onDelete: KeyAction.cascade)();
-
-  @override
-  Set<Column<Object>> get primaryKey => {groupId, gameId};
-}
diff --git a/lib/data/db/tables/group_match_table.dart b/lib/data/db/tables/group_match_table.dart
new file mode 100644
index 0000000..3f77dcb
--- /dev/null
+++ b/lib/data/db/tables/group_match_table.dart
@@ -0,0 +1,13 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/tables/group_table.dart';
+import 'package:game_tracker/data/db/tables/match_table.dart';
+
+class GroupMatchTable extends Table {
+  TextColumn get groupId =>
+      text().references(GroupTable, #id, onDelete: KeyAction.cascade)();
+  TextColumn get matchId =>
+      text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
+
+  @override
+  Set<Column<Object>> get primaryKey => {groupId, matchId};
+}
diff --git a/lib/data/db/tables/game_table.dart b/lib/data/db/tables/match_table.dart
similarity index 88%
rename from lib/data/db/tables/game_table.dart
rename to lib/data/db/tables/match_table.dart
index 1a37a73..96aff2a 100644
--- a/lib/data/db/tables/game_table.dart
+++ b/lib/data/db/tables/match_table.dart
@@ -1,6 +1,6 @@
 import 'package:drift/drift.dart';
 
-class GameTable extends Table {
+class MatchTable extends Table {
   TextColumn get id => text()();
   TextColumn get name => text()();
   late final winnerId = text().nullable()();
diff --git a/lib/data/db/tables/player_game_table.dart b/lib/data/db/tables/player_game_table.dart
deleted file mode 100644
index 74c36fe..0000000
--- a/lib/data/db/tables/player_game_table.dart
+++ /dev/null
@@ -1,13 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:game_tracker/data/db/tables/game_table.dart';
-import 'package:game_tracker/data/db/tables/player_table.dart';
-
-class PlayerGameTable extends Table {
-  TextColumn get playerId =>
-      text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
-  TextColumn get gameId =>
-      text().references(GameTable, #id, onDelete: KeyAction.cascade)();
-
-  @override
-  Set<Column<Object>> get primaryKey => {playerId, gameId};
-}
diff --git a/lib/data/db/tables/player_match_table.dart b/lib/data/db/tables/player_match_table.dart
new file mode 100644
index 0000000..e155cd5
--- /dev/null
+++ b/lib/data/db/tables/player_match_table.dart
@@ -0,0 +1,13 @@
+import 'package:drift/drift.dart';
+import 'package:game_tracker/data/db/tables/match_table.dart';
+import 'package:game_tracker/data/db/tables/player_table.dart';
+
+class PlayerMatchTable extends Table {
+  TextColumn get playerId =>
+      text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
+  TextColumn get matchId =>
+      text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
+
+  @override
+  Set<Column<Object>> get primaryKey => {playerId, matchId};
+}
diff --git a/lib/data/dto/game.dart b/lib/data/dto/match.dart
similarity index 81%
rename from lib/data/dto/game.dart
rename to lib/data/dto/match.dart
index 48ef902..fcb4dae 100644
--- a/lib/data/dto/game.dart
+++ b/lib/data/dto/match.dart
@@ -3,7 +3,7 @@ import 'package:game_tracker/data/dto/group.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:uuid/uuid.dart';
 
-class Game {
+class Match {
   final String id;
   final DateTime createdAt;
   final String name;
@@ -11,7 +11,7 @@ class Game {
   final Group? group;
   final Player? winner;
 
-  Game({
+  Match({
     String? id,
     DateTime? createdAt,
     required this.name,
@@ -23,11 +23,11 @@ class Game {
 
   @override
   String toString() {
-    return 'Game{\n\tid: $id,\n\tname: $name,\n\tplayers: $players,\n\tgroup: $group,\n\twinner: $winner\n}';
+    return 'Match{\n\tid: $id,\n\tname: $name,\n\tplayers: $players,\n\tgroup: $group,\n\twinner: $winner\n}';
   }
 
-  /// Creates a Game instance from a JSON object.
-  Game.fromJson(Map<String, dynamic> json)
+  /// Creates a Match instance from a JSON object.
+  Match.fromJson(Map<String, dynamic> json)
     : id = json['id'],
       name = json['name'],
       createdAt = DateTime.parse(json['createdAt']),
@@ -39,7 +39,7 @@ class Game {
       group = json['group'] != null ? Group.fromJson(json['group']) : null,
       winner = json['winner'] != null ? Player.fromJson(json['winner']) : null;
 
-  /// Converts the Game instance to a JSON object.
+  /// Converts the Match instance to a JSON object.
   Map<String, dynamic> toJson() => {
     'id': id,
     'createdAt': createdAt.toIso8601String(),
diff --git a/lib/presentation/views/main_menu/custom_navigation_bar.dart b/lib/presentation/views/main_menu/custom_navigation_bar.dart
index 71a072e..2ec28fa 100644
--- a/lib/presentation/views/main_menu/custom_navigation_bar.dart
+++ b/lib/presentation/views/main_menu/custom_navigation_bar.dart
@@ -1,8 +1,8 @@
 import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/presentation/views/main_menu/game_history_view.dart';
-import 'package:game_tracker/presentation/views/main_menu/groups_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/group_view/groups_view.dart';
 import 'package:game_tracker/presentation/views/main_menu/home_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/match_view.dart';
 import 'package:game_tracker/presentation/views/main_menu/settings_view.dart';
 import 'package:game_tracker/presentation/views/main_menu/statistics_view.dart';
 import 'package:game_tracker/presentation/widgets/navbar_item.dart';
@@ -30,8 +30,8 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
     final List<Widget> tabs = [
       KeyedSubtree(key: ValueKey('home_$tabKeyCount'), child: const HomeView()),
       KeyedSubtree(
-        key: ValueKey('games_$tabKeyCount'),
-        child: const GameHistoryView(),
+        key: ValueKey('matches_$tabKeyCount'),
+        child: const MatchView(),
       ),
       KeyedSubtree(
         key: ValueKey('groups_$tabKeyCount'),
@@ -96,7 +96,7 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
                     index: 1,
                     isSelected: currentIndex == 1,
                     icon: Icons.gamepad_rounded,
-                    label: 'Games',
+                    label: 'Matches',
                     onTabTapped: onTabTapped,
                   ),
                   NavbarItem(
@@ -133,7 +133,7 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
       case 0:
         return 'Home';
       case 1:
-        return 'Game History';
+        return 'Matches';
       case 2:
         return 'Groups';
       case 3:
diff --git a/lib/presentation/views/main_menu/create_group_view.dart b/lib/presentation/views/main_menu/group_view/create_group_view.dart
similarity index 100%
rename from lib/presentation/views/main_menu/create_group_view.dart
rename to lib/presentation/views/main_menu/group_view/create_group_view.dart
diff --git a/lib/presentation/views/main_menu/groups_view.dart b/lib/presentation/views/main_menu/group_view/groups_view.dart
similarity index 97%
rename from lib/presentation/views/main_menu/groups_view.dart
rename to lib/presentation/views/main_menu/group_view/groups_view.dart
index ce47f90..5fd5e4b 100644
--- a/lib/presentation/views/main_menu/groups_view.dart
+++ b/lib/presentation/views/main_menu/group_view/groups_view.dart
@@ -3,7 +3,7 @@ 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/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';
@@ -25,7 +25,7 @@ class _GroupsViewState extends State<GroupsView> {
   late final List<Group> skeletonData = List.filled(
     7,
     Group(
-      name: 'Skeleton Game',
+      name: 'Skeleton Match',
       members: [player, player, player, player, player, player],
     ),
   );
diff --git a/lib/presentation/views/main_menu/home_view.dart b/lib/presentation/views/main_menu/home_view.dart
index 1667f2b..c6322d8 100644
--- a/lib/presentation/views/main_menu/home_view.dart
+++ b/lib/presentation/views/main_menu/home_view.dart
@@ -1,7 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:game_tracker/presentation/widgets/app_skeleton.dart';
 import 'package:game_tracker/presentation/widgets/buttons/quick_create_button.dart';
@@ -18,15 +18,15 @@ class HomeView extends StatefulWidget {
 }
 
 class _HomeViewState extends State<HomeView> {
-  late Future<int> _gameCountFuture;
+  late Future<int> _matchCountFuture;
   late Future<int> _groupCountFuture;
-  late Future<List<Game>> _recentGamesFuture;
+  late Future<List<Match>> _recentMatchesFuture;
   bool isLoading = true;
 
-  late final List<Game> skeletonData = List.filled(
+  late final List<Match> skeletonData = List.filled(
     2,
-    Game(
-      name: 'Skeleton Game',
+    Match(
+      name: 'Skeleton Match',
       group: Group(
         name: 'Skeleton Group',
         members: [
@@ -42,20 +42,22 @@ class _HomeViewState extends State<HomeView> {
   initState() {
     super.initState();
     final db = Provider.of<AppDatabase>(context, listen: false);
-    _gameCountFuture = db.gameDao.getGameCount();
+    _matchCountFuture = db.matchDao.getMatchCount();
     _groupCountFuture = db.groupDao.getGroupCount();
-    _recentGamesFuture = db.gameDao.getAllGames();
+    _recentMatchesFuture = db.matchDao.getAllMatches();
 
-    Future.wait([_gameCountFuture, _groupCountFuture, _recentGamesFuture]).then(
-      (_) async {
-        await Future.delayed(const Duration(milliseconds: 250));
-        if (mounted) {
-          setState(() {
-            isLoading = false;
-          });
-        }
-      },
-    );
+    Future.wait([
+      _matchCountFuture,
+      _groupCountFuture,
+      _recentMatchesFuture,
+    ]).then((_) async {
+      await Future.delayed(const Duration(milliseconds: 250));
+      if (mounted) {
+        setState(() {
+          isLoading = false;
+        });
+      }
+    });
   }
 
   @override
@@ -72,7 +74,7 @@ class _HomeViewState extends State<HomeView> {
                   mainAxisAlignment: MainAxisAlignment.center,
                   children: [
                     FutureBuilder<int>(
-                      future: _gameCountFuture,
+                      future: _matchCountFuture,
                       builder: (context, snapshot) {
                         final int count = (snapshot.hasData)
                             ? snapshot.data!
@@ -115,11 +117,11 @@ class _HomeViewState extends State<HomeView> {
                     content: Padding(
                       padding: const EdgeInsets.symmetric(horizontal: 40.0),
                       child: FutureBuilder(
-                        future: _recentGamesFuture,
+                        future: _recentMatchesFuture,
                         builder:
                             (
                               BuildContext context,
-                              AsyncSnapshot<List<Game>> snapshot,
+                              AsyncSnapshot<List<Match>> snapshot,
                             ) {
                               if (snapshot.hasError) {
                                 return const Center(
@@ -129,7 +131,7 @@ class _HomeViewState extends State<HomeView> {
                                   ),
                                 );
                               }
-                              final List<Game> games =
+                              final List<Match> matches =
                                   (isLoading
                                             ? skeletonData
                                             : (snapshot.data ?? [])
@@ -140,19 +142,19 @@ class _HomeViewState extends State<HomeView> {
                                         ))
                                       .take(2)
                                       .toList();
-                              if (games.isNotEmpty) {
+                              if (matches.isNotEmpty) {
                                 return Column(
                                   mainAxisAlignment: MainAxisAlignment.start,
                                   crossAxisAlignment: CrossAxisAlignment.start,
                                   children: [
-                                    GameTile(
-                                      gameTitle: games[0].name,
-                                      gameType: 'Winner',
+                                    MatchTile(
+                                      matchTitle: matches[0].name,
+                                      game: 'Winner',
                                       ruleset: 'Ruleset',
-                                      players: _getPlayerText(games[0]),
-                                      winner: games[0].winner == null
+                                      players: _getPlayerText(matches[0]),
+                                      winner: matches[0].winner == null
                                           ? 'Game in progress...'
-                                          : games[0].winner!.name,
+                                          : matches[0].winner!.name,
                                     ),
                                     const Padding(
                                       padding: EdgeInsets.symmetric(
@@ -160,15 +162,15 @@ class _HomeViewState extends State<HomeView> {
                                       ),
                                       child: Divider(),
                                     ),
-                                    if (games.length > 1) ...[
-                                      GameTile(
-                                        gameTitle: games[1].name,
-                                        gameType: 'Winner',
+                                    if (matches.length > 1) ...[
+                                      MatchTile(
+                                        matchTitle: matches[1].name,
+                                        game: 'Winner',
                                         ruleset: 'Ruleset',
-                                        players: _getPlayerText(games[1]),
-                                        winner: games[1].winner == null
+                                        players: _getPlayerText(matches[1]),
+                                        winner: matches[1].winner == null
                                             ? 'Game in progress...'
-                                            : games[1].winner!.name,
+                                            : matches[1].winner!.name,
                                       ),
                                       const SizedBox(height: 8),
                                     ] else ...[
@@ -249,7 +251,7 @@ class _HomeViewState extends State<HomeView> {
     );
   }
 
-  String _getPlayerText(Game game) {
+  String _getPlayerText(Match game) {
     if (game.group == null) {
       final playerCount = game.players?.length ?? 0;
       return '$playerCount Players';
diff --git a/lib/presentation/views/main_menu/create_game/choose_game_view.dart b/lib/presentation/views/main_menu/match_view/create_match/choose_game_view.dart
similarity index 100%
rename from lib/presentation/views/main_menu/create_game/choose_game_view.dart
rename to lib/presentation/views/main_menu/match_view/create_match/choose_game_view.dart
diff --git a/lib/presentation/views/main_menu/create_game/choose_group_view.dart b/lib/presentation/views/main_menu/match_view/create_match/choose_group_view.dart
similarity index 100%
rename from lib/presentation/views/main_menu/create_game/choose_group_view.dart
rename to lib/presentation/views/main_menu/match_view/create_match/choose_group_view.dart
diff --git a/lib/presentation/views/main_menu/create_game/choose_ruleset_view.dart b/lib/presentation/views/main_menu/match_view/create_match/choose_ruleset_view.dart
similarity index 100%
rename from lib/presentation/views/main_menu/create_game/choose_ruleset_view.dart
rename to lib/presentation/views/main_menu/match_view/create_match/choose_ruleset_view.dart
diff --git a/lib/presentation/views/main_menu/create_game/create_game_view.dart b/lib/presentation/views/main_menu/match_view/create_match/create_match_view.dart
similarity index 91%
rename from lib/presentation/views/main_menu/create_game/create_game_view.dart
rename to lib/presentation/views/main_menu/match_view/create_match/create_match_view.dart
index eef2de6..03c081c 100644
--- a/lib/presentation/views/main_menu/create_game/create_game_view.dart
+++ b/lib/presentation/views/main_menu/match_view/create_match/create_match_view.dart
@@ -3,28 +3,28 @@ import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/core/enums.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
-import 'package:game_tracker/presentation/views/main_menu/create_game/choose_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/create_game/choose_ruleset_view.dart';
-import 'package:game_tracker/presentation/views/main_menu/game_result_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/choose_game_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/choose_group_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/create_match/choose_ruleset_view.dart';
+import 'package:game_tracker/presentation/views/main_menu/match_view/match_result_view.dart';
 import 'package:game_tracker/presentation/widgets/buttons/custom_width_button.dart';
 import 'package:game_tracker/presentation/widgets/player_selection.dart';
 import 'package:game_tracker/presentation/widgets/text_input/text_input_field.dart';
 import 'package:game_tracker/presentation/widgets/tiles/choose_tile.dart';
 import 'package:provider/provider.dart';
 
-class CreateGameView extends StatefulWidget {
+class CreateMatchView extends StatefulWidget {
   final VoidCallback? onWinnerChanged;
-  const CreateGameView({super.key, this.onWinnerChanged});
+  const CreateMatchView({super.key, this.onWinnerChanged});
 
   @override
-  State<CreateGameView> createState() => _CreateGameViewState();
+  State<CreateMatchView> createState() => _CreateMatchViewState();
 }
 
-class _CreateGameViewState extends State<CreateGameView> {
+class _CreateMatchViewState extends State<CreateMatchView> {
   /// Reference to the app database
   late final AppDatabase db;
 
@@ -234,20 +234,20 @@ class _CreateGameViewState extends State<CreateGameView> {
               buttonType: ButtonType.primary,
               onPressed: _enableCreateGameButton()
                   ? () async {
-                      Game game = Game(
+                      Match match = Match(
                         name: _gameNameController.text.trim(),
                         createdAt: DateTime.now(),
                         group: selectedGroup,
                         players: selectedPlayers,
                       );
-                      await db.gameDao.addGame(game: game);
+                      await db.matchDao.addMatch(match: match);
                       if (context.mounted) {
                         Navigator.pushReplacement(
                           context,
                           CupertinoPageRoute(
                             fullscreenDialog: true,
                             builder: (context) => GameResultView(
-                              game: game,
+                              match: match,
                               onWinnerChanged: widget.onWinnerChanged,
                             ),
                           ),
diff --git a/lib/presentation/views/main_menu/game_result_view.dart b/lib/presentation/views/main_menu/match_view/match_result_view.dart
similarity index 90%
rename from lib/presentation/views/main_menu/game_result_view.dart
rename to lib/presentation/views/main_menu/match_view/match_result_view.dart
index 6e60410..58ff9ce 100644
--- a/lib/presentation/views/main_menu/game_result_view.dart
+++ b/lib/presentation/views/main_menu/match_view/match_result_view.dart
@@ -1,17 +1,17 @@
 import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:game_tracker/presentation/widgets/tiles/custom_radio_list_tile.dart';
 import 'package:provider/provider.dart';
 
 class GameResultView extends StatefulWidget {
-  final Game game;
+  final Match match;
 
   final VoidCallback? onWinnerChanged;
 
-  const GameResultView({super.key, required this.game, this.onWinnerChanged});
+  const GameResultView({super.key, required this.match, this.onWinnerChanged});
   @override
   State<GameResultView> createState() => _GameResultViewState();
 }
@@ -24,10 +24,10 @@ class _GameResultViewState extends State<GameResultView> {
   @override
   void initState() {
     db = Provider.of<AppDatabase>(context, listen: false);
-    allPlayers = getAllPlayers(widget.game);
-    if (widget.game.winner != null) {
+    allPlayers = getAllPlayers(widget.match);
+    if (widget.match.winner != null) {
       _selectedPlayer = allPlayers.firstWhere(
-        (p) => p.id == widget.game.winner!.id,
+        (p) => p.id == widget.match.winner!.id,
       );
     }
     super.initState();
@@ -41,7 +41,7 @@ class _GameResultViewState extends State<GameResultView> {
         backgroundColor: CustomTheme.backgroundColor,
         scrolledUnderElevation: 0,
         title: Text(
-          widget.game.name,
+          widget.match.name,
           style: const TextStyle(
             fontSize: 20,
             fontWeight: FontWeight.bold,
@@ -125,17 +125,17 @@ class _GameResultViewState extends State<GameResultView> {
 
   Future<void> _handleWinnerSaving() async {
     if (_selectedPlayer == null) {
-      await db.gameDao.removeWinner(gameId: widget.game.id);
+      await db.matchDao.removeWinner(matchId: widget.match.id);
     } else {
-      await db.gameDao.setWinner(
-        gameId: widget.game.id,
+      await db.matchDao.setWinner(
+        matchId: widget.match.id,
         winnerId: _selectedPlayer!.id,
       );
     }
     widget.onWinnerChanged?.call();
   }
 
-  List<Player> getAllPlayers(Game game) {
+  List<Player> getAllPlayers(Match game) {
     if (game.group == null && game.players != null) {
       return [...game.players!];
     } else if (game.group != null && game.players != null) {
diff --git a/lib/presentation/views/main_menu/game_history_view.dart b/lib/presentation/views/main_menu/match_view/match_view.dart
similarity index 79%
rename from lib/presentation/views/main_menu/game_history_view.dart
rename to lib/presentation/views/main_menu/match_view/match_view.dart
index 46cb1db..92fd268 100644
--- a/lib/presentation/views/main_menu/game_history_view.dart
+++ b/lib/presentation/views/main_menu/match_view/match_view.dart
@@ -1,32 +1,34 @@
+import 'dart:core' hide Match;
+
 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/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
-import 'package:game_tracker/presentation/views/main_menu/create_game/create_game_view.dart';
-import 'package:game_tracker/presentation/views/main_menu/game_result_view.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 GameHistoryView extends StatefulWidget {
-  const GameHistoryView({super.key});
+class MatchView extends StatefulWidget {
+  const MatchView({super.key});
 
   @override
-  State<GameHistoryView> createState() => _GameHistoryViewState();
+  State<MatchView> createState() => _MatchViewState();
 }
 
-class _GameHistoryViewState extends State<GameHistoryView> {
-  late Future<List<Game>> _gameListFuture;
+class _MatchViewState extends State<MatchView> {
+  late Future<List<Match>> _gameListFuture;
   late final AppDatabase db;
 
-  late final List<Game> skeletonData = List.filled(
+  late final List<Match> skeletonData = List.filled(
     4,
-    Game(
+    Match(
       name: 'Skeleton Gamename',
       group: Group(
         name: 'Groupname',
@@ -43,7 +45,7 @@ class _GameHistoryViewState extends State<GameHistoryView> {
     db = Provider.of<AppDatabase>(context, listen: false);
     _gameListFuture = Future.delayed(
       const Duration(milliseconds: 250),
-      () => db.gameDao.getAllGames(),
+      () => db.matchDao.getAllMatches(),
     );
   }
 
@@ -54,10 +56,10 @@ class _GameHistoryViewState extends State<GameHistoryView> {
       body: Stack(
         alignment: Alignment.center,
         children: [
-          FutureBuilder<List<Game>>(
+          FutureBuilder<List<Match>>(
             future: _gameListFuture,
             builder:
-                (BuildContext context, AsyncSnapshot<List<Game>> snapshot) {
+                (BuildContext context, AsyncSnapshot<List<Match>> snapshot) {
                   if (snapshot.hasError) {
                     return const Center(
                       child: TopCenteredMessage(
@@ -79,7 +81,7 @@ class _GameHistoryViewState extends State<GameHistoryView> {
                   }
                   final bool isLoading =
                       snapshot.connectionState == ConnectionState.waiting;
-                  final List<Game> games =
+                  final List<Match> matches =
                       (isLoading ? skeletonData : (snapshot.data ?? [])
                             ..sort(
                               (a, b) => b.createdAt.compareTo(a.createdAt),
@@ -89,9 +91,9 @@ class _GameHistoryViewState extends State<GameHistoryView> {
                     enabled: isLoading,
                     child: ListView.builder(
                       padding: const EdgeInsets.only(bottom: 85),
-                      itemCount: games.length + 1,
+                      itemCount: matches.length + 1,
                       itemBuilder: (BuildContext context, int index) {
-                        if (index == games.length) {
+                        if (index == matches.length) {
                           return SizedBox(
                             height: MediaQuery.paddingOf(context).bottom - 80,
                           );
@@ -103,13 +105,13 @@ class _GameHistoryViewState extends State<GameHistoryView> {
                               CupertinoPageRoute(
                                 fullscreenDialog: true,
                                 builder: (context) => GameResultView(
-                                  game: games[index],
+                                  match: matches[index],
                                   onWinnerChanged: refreshGameList,
                                 ),
                               ),
                             );
                           },
-                          game: games[index],
+                          match: matches[index],
                         );
                       },
                     ),
@@ -126,7 +128,7 @@ class _GameHistoryViewState extends State<GameHistoryView> {
                   context,
                   MaterialPageRoute(
                     builder: (context) =>
-                        CreateGameView(onWinnerChanged: refreshGameList),
+                        CreateMatchView(onWinnerChanged: refreshGameList),
                   ),
                 );
               },
@@ -139,7 +141,7 @@ class _GameHistoryViewState extends State<GameHistoryView> {
 
   void refreshGameList() {
     setState(() {
-      _gameListFuture = db.gameDao.getAllGames();
+      _gameListFuture = db.matchDao.getAllMatches();
     });
   }
 }
diff --git a/lib/presentation/views/main_menu/statistics_view.dart b/lib/presentation/views/main_menu/statistics_view.dart
index 564d0d5..17376b2 100644
--- a/lib/presentation/views/main_menu/statistics_view.dart
+++ b/lib/presentation/views/main_menu/statistics_view.dart
@@ -1,6 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:game_tracker/presentation/widgets/app_skeleton.dart';
 import 'package:game_tracker/presentation/widgets/tiles/statistics_tile.dart';
@@ -14,10 +14,10 @@ class StatisticsView extends StatefulWidget {
 }
 
 class _StatisticsViewState extends State<StatisticsView> {
-  late Future<List<Game>> _gamesFuture;
+  late Future<List<Match>> _matchesFuture;
   late Future<List<Player>> _playersFuture;
   List<(String, int)> winCounts = List.filled(6, ('Skeleton Player', 1));
-  List<(String, int)> gameCounts = List.filled(6, ('Skeleton Player', 1));
+  List<(String, int)> matchCounts = List.filled(6, ('Skeleton Player', 1));
   List<(String, double)> winRates = List.filled(6, ('Skeleton Player', 1));
   bool isLoading = true;
 
@@ -25,16 +25,16 @@ class _StatisticsViewState extends State<StatisticsView> {
   void initState() {
     super.initState();
     final db = Provider.of<AppDatabase>(context, listen: false);
-    _gamesFuture = db.gameDao.getAllGames();
+    _matchesFuture = db.matchDao.getAllMatches();
     _playersFuture = db.playerDao.getAllPlayers();
 
-    Future.wait([_gamesFuture, _playersFuture]).then((results) async {
+    Future.wait([_matchesFuture, _playersFuture]).then((results) async {
       await Future.delayed(const Duration(milliseconds: 250));
-      final games = results[0] as List<Game>;
+      final matches = results[0] as List<Match>;
       final players = results[1] as List<Player>;
-      winCounts = _calculateWinsForAllPlayers(games, players);
-      gameCounts = _calculateGameAmountsForAllPlayers(games, players);
-      winRates = computeWinRatePercent(wins: winCounts, games: gameCounts);
+      winCounts = _calculateWinsForAllPlayers(matches, players);
+      matchCounts = _calculateGameAmountsForAllPlayers(matches, players);
+      winRates = computeWinRatePercent(wins: winCounts, matches: matchCounts);
       if (mounted) {
         setState(() {
           isLoading = false;
@@ -78,9 +78,9 @@ class _StatisticsViewState extends State<StatisticsView> {
                   SizedBox(height: constraints.maxHeight * 0.02),
                   StatisticsTile(
                     icon: Icons.casino,
-                    title: 'Games per Player',
+                    title: 'Match per Player',
                     width: constraints.maxWidth * 0.95,
-                    values: gameCounts,
+                    values: matchCounts,
                     itemCount: 10,
                     barColor: Colors.green,
                   ),
@@ -97,7 +97,7 @@ class _StatisticsViewState extends State<StatisticsView> {
   /// Calculates the number of wins for each player
   /// and returns a sorted list of tuples (playerName, winCount)
   List<(String, int)> _calculateWinsForAllPlayers(
-    List<Game> games,
+    List<Match> games,
     List<Player> players,
   ) {
     List<(String, int)> winCounts = [];
@@ -141,39 +141,39 @@ class _StatisticsViewState extends State<StatisticsView> {
     return winCounts;
   }
 
-  /// Calculates the number of games played for each player
-  /// and returns a sorted list of tuples (playerName, gameCount)
+  /// Calculates the number of matches played for each player
+  /// and returns a sorted list of tuples (playerName, matchCount)
   List<(String, int)> _calculateGameAmountsForAllPlayers(
-    List<Game> games,
+    List<Match> matches,
     List<Player> players,
   ) {
-    List<(String, int)> gameCounts = [];
+    List<(String, int)> matchCounts = [];
 
-    // Counting games for each player
-    for (var game in games) {
-      if (game.group != null) {
-        final members = game.group!.members.map((p) => p.id).toList();
+    // Counting matches for each player
+    for (var match in matches) {
+      if (match.group != null) {
+        final members = match.group!.members.map((p) => p.id).toList();
         for (var playerId in members) {
-          final index = gameCounts.indexWhere((entry) => entry.$1 == playerId);
+          final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
           // -1 means player not found in gameCounts
           if (index != -1) {
-            final current = gameCounts[index].$2;
-            gameCounts[index] = (playerId, current + 1);
+            final current = matchCounts[index].$2;
+            matchCounts[index] = (playerId, current + 1);
           } else {
-            gameCounts.add((playerId, 1));
+            matchCounts.add((playerId, 1));
           }
         }
       }
-      if (game.players != null) {
-        final members = game.players!.map((p) => p.id).toList();
+      if (match.players != null) {
+        final members = match.players!.map((p) => p.id).toList();
         for (var playerId in members) {
-          final index = gameCounts.indexWhere((entry) => entry.$1 == playerId);
+          final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
           // -1 means player not found in gameCounts
           if (index != -1) {
-            final current = gameCounts[index].$2;
-            gameCounts[index] = (playerId, current + 1);
+            final current = matchCounts[index].$2;
+            matchCounts[index] = (playerId, current + 1);
           } else {
-            gameCounts.add((playerId, 1));
+            matchCounts.add((playerId, 1));
           }
         }
       }
@@ -181,35 +181,35 @@ class _StatisticsViewState extends State<StatisticsView> {
 
     // Adding all players with zero games
     for (var player in players) {
-      final index = gameCounts.indexWhere((entry) => entry.$1 == player.id);
+      final index = matchCounts.indexWhere((entry) => entry.$1 == player.id);
       // -1 means player not found in gameCounts
       if (index == -1) {
-        gameCounts.add((player.id, 0));
+        matchCounts.add((player.id, 0));
       }
     }
 
     // Replace player IDs with names
-    for (int i = 0; i < gameCounts.length; i++) {
-      final playerId = gameCounts[i].$1;
+    for (int i = 0; i < matchCounts.length; i++) {
+      final playerId = matchCounts[i].$1;
       final player = players.firstWhere(
         (p) => p.id == playerId,
         orElse: () => Player(id: playerId, name: 'N.a.'),
       );
-      gameCounts[i] = (player.name, gameCounts[i].$2);
+      matchCounts[i] = (player.name, matchCounts[i].$2);
     }
 
-    gameCounts.sort((a, b) => b.$2.compareTo(a.$2));
+    matchCounts.sort((a, b) => b.$2.compareTo(a.$2));
 
-    return gameCounts;
+    return matchCounts;
   }
 
   // dart
   List<(String, double)> computeWinRatePercent({
     required List<(String, int)> wins,
-    required List<(String, int)> games,
+    required List<(String, int)> matches,
   }) {
     final Map<String, int> winsMap = {for (var e in wins) e.$1: e.$2};
-    final Map<String, int> gamesMap = {for (var e in games) e.$1: e.$2};
+    final Map<String, int> gamesMap = {for (var e in matches) e.$1: e.$2};
 
     // Get all unique player names
     final names = {...winsMap.keys, ...gamesMap.keys};
diff --git a/lib/presentation/widgets/tiles/game_history_tile.dart b/lib/presentation/widgets/tiles/game_history_tile.dart
index 83da859..f79edc3 100644
--- a/lib/presentation/widgets/tiles/game_history_tile.dart
+++ b/lib/presentation/widgets/tiles/game_history_tile.dart
@@ -1,14 +1,14 @@
 import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
-import 'package:game_tracker/data/dto/game.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/presentation/widgets/tiles/text_icon_tile.dart';
 import 'package:intl/intl.dart';
 
 class GameHistoryTile extends StatefulWidget {
-  final Game game;
+  final Match match;
   final VoidCallback onTap;
 
-  const GameHistoryTile({super.key, required this.game, required this.onTap});
+  const GameHistoryTile({super.key, required this.match, required this.onTap});
 
   @override
   State<GameHistoryTile> createState() => _GameHistoryTileState();
@@ -17,8 +17,8 @@ class GameHistoryTile extends StatefulWidget {
 class _GameHistoryTileState extends State<GameHistoryTile> {
   @override
   Widget build(BuildContext context) {
-    final group = widget.game.group;
-    final winner = widget.game.winner;
+    final group = widget.match.group;
+    final winner = widget.match.winner;
     final allPlayers = _getAllPlayers();
 
     return GestureDetector(
@@ -39,7 +39,7 @@ class _GameHistoryTileState extends State<GameHistoryTile> {
               children: [
                 Expanded(
                   child: Text(
-                    widget.game.name,
+                    widget.match.name,
                     style: const TextStyle(
                       fontSize: 18,
                       fontWeight: FontWeight.bold,
@@ -48,7 +48,7 @@ class _GameHistoryTileState extends State<GameHistoryTile> {
                   ),
                 ),
                 Text(
-                  _formatDate(widget.game.createdAt),
+                  _formatDate(widget.match.createdAt),
                   style: const TextStyle(fontSize: 12, color: Colors.grey),
                 ),
               ],
@@ -156,8 +156,8 @@ class _GameHistoryTileState extends State<GameHistoryTile> {
     final playerIds = <String>{};
 
     // Add players from game.players
-    if (widget.game.players != null) {
-      for (var player in widget.game.players!) {
+    if (widget.match.players != null) {
+      for (var player in widget.match.players!) {
         if (!playerIds.contains(player.id)) {
           allPlayers.add(player);
           playerIds.add(player.id);
@@ -166,8 +166,8 @@ class _GameHistoryTileState extends State<GameHistoryTile> {
     }
 
     // Add players from game.group.players
-    if (widget.game.group?.members != null) {
-      for (var player in widget.game.group!.members) {
+    if (widget.match.group?.members != null) {
+      for (var player in widget.match.group!.members) {
         if (!playerIds.contains(player.id)) {
           allPlayers.add(player);
           playerIds.add(player.id);
diff --git a/lib/presentation/widgets/tiles/game_tile.dart b/lib/presentation/widgets/tiles/game_tile.dart
index fcd2f65..f98f425 100644
--- a/lib/presentation/widgets/tiles/game_tile.dart
+++ b/lib/presentation/widgets/tiles/game_tile.dart
@@ -2,27 +2,27 @@ import 'package:flutter/material.dart';
 import 'package:game_tracker/core/custom_theme.dart';
 import 'package:skeletonizer/skeletonizer.dart';
 
-class GameTile extends StatefulWidget {
-  final String gameTitle;
-  final String gameType;
+class MatchTile extends StatefulWidget {
+  final String matchTitle;
+  final String game;
   final String ruleset;
   final String players;
   final String winner;
 
-  const GameTile({
+  const MatchTile({
     super.key,
-    required this.gameTitle,
-    required this.gameType,
+    required this.matchTitle,
+    required this.game,
     required this.ruleset,
     required this.players,
     required this.winner,
   });
 
   @override
-  State<GameTile> createState() => _GameTileState();
+  State<MatchTile> createState() => _MatchTileState();
 }
 
-class _GameTileState extends State<GameTile> {
+class _MatchTileState extends State<MatchTile> {
   @override
   Widget build(BuildContext context) {
     return Column(
@@ -31,12 +31,12 @@ class _GameTileState extends State<GameTile> {
         Row(
           children: [
             Text(
-              widget.gameTitle,
+              widget.matchTitle,
               style: const TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
             ),
             const SizedBox(width: 5),
             Text(
-              widget.gameType,
+              widget.game,
               style: const TextStyle(fontSize: 14, color: Colors.grey),
             ),
           ],
diff --git a/lib/presentation/widgets/tiles/statistics_tile.dart b/lib/presentation/widgets/tiles/statistics_tile.dart
index 6e3b9b2..582cf66 100644
--- a/lib/presentation/widgets/tiles/statistics_tile.dart
+++ b/lib/presentation/widgets/tiles/statistics_tile.dart
@@ -40,11 +40,11 @@ class StatisticsTile extends StatelessWidget {
           child: Column(
             children: List.generate(min(values.length, itemCount), (index) {
               /// The maximum wins among all players
-              final maxGames = values.isNotEmpty ? values[0].$2 : 0;
+              final maxMatches = values.isNotEmpty ? values[0].$2 : 0;
 
               /// Fraction of wins
-              final double fraction = (maxGames > 0)
-                  ? (values[index].$2 / maxGames)
+              final double fraction = (maxMatches > 0)
+                  ? (values[index].$2 / maxMatches)
                   : 0.0;
 
               /// Calculated width for current the bar
diff --git a/lib/services/data_transfer_service.dart b/lib/services/data_transfer_service.dart
index f040b0a..957d8fd 100644
--- a/lib/services/data_transfer_service.dart
+++ b/lib/services/data_transfer_service.dart
@@ -6,8 +6,8 @@ import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:game_tracker/core/enums.dart';
 import 'package:game_tracker/data/db/database.dart';
-import 'package:game_tracker/data/dto/game.dart';
 import 'package:game_tracker/data/dto/group.dart';
+import 'package:game_tracker/data/dto/match.dart';
 import 'package:game_tracker/data/dto/player.dart';
 import 'package:json_schema/json_schema.dart';
 import 'package:provider/provider.dart';
@@ -16,7 +16,7 @@ class DataTransferService {
   /// Deletes all data from the database.
   static Future<void> deleteAllData(BuildContext context) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
-    await db.gameDao.deleteAllGames();
+    await db.matchDao.deleteAllMatches();
     await db.groupDao.deleteAllGroups();
     await db.playerDao.deleteAllPlayers();
   }
@@ -25,13 +25,13 @@ class DataTransferService {
   /// Returns the JSON string representation of the data.
   static Future<String> getAppDataAsJson(BuildContext context) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
-    final games = await db.gameDao.getAllGames();
+    final matches = await db.matchDao.getAllMatches();
     final groups = await db.groupDao.getAllGroups();
     final players = await db.playerDao.getAllPlayers();
 
     // Construct a JSON representation of the data
     final Map<String, dynamic> jsonMap = {
-      'games': games.map((game) => game.toJson()).toList(),
+      'matches': matches.map((match) => match.toJson()).toList(),
       'groups': groups.map((group) => group.toJson()).toList(),
       'players': players.map((player) => player.toJson()).toList(),
     };
@@ -89,14 +89,15 @@ class DataTransferService {
         final Map<String, dynamic> jsonData =
             json.decode(jsonString) as Map<String, dynamic>;
 
-        final List<dynamic>? gamesJson = jsonData['games'] as List<dynamic>?;
+        final List<dynamic>? matchesJson =
+            jsonData['matches'] as List<dynamic>?;
         final List<dynamic>? groupsJson = jsonData['groups'] as List<dynamic>?;
         final List<dynamic>? playersJson =
             jsonData['players'] as List<dynamic>?;
 
-        final List<Game> importedGames =
-            gamesJson
-                ?.map((g) => Game.fromJson(g as Map<String, dynamic>))
+        final List<Match> importedMatches =
+            matchesJson
+                ?.map((g) => Match.fromJson(g as Map<String, dynamic>))
                 .toList() ??
             [];
         final List<Group> importedGroups =
@@ -112,7 +113,7 @@ class DataTransferService {
 
         await db.playerDao.addPlayersAsList(players: importedPlayers);
         await db.groupDao.addGroupsAsList(groups: importedGroups);
-        await db.gameDao.addGamesAsList(games: importedGames);
+        await db.matchDao.addMatchAsList(matches: importedMatches);
       } else {
         return ImportResult.invalidSchema;
       }
diff --git a/test/db_tests/game_test.dart b/test/db_tests/game_test.dart
index 4a5cc32..ca86a60 100644
--- a/test/db_tests/game_test.dart
+++ b/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 Game testGame1;
-  late Game testGame2;
-  late Game testGameOnlyPlayers;
-  late Game testGameOnlyGroup;
+  late Match testMatch1;
+  late Match testMatch2;
+  late Match testMatchOnlyPlayers;
+  late Match testMatchOnlyGroup;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
@@ -46,46 +46,51 @@ void main() {
         name: 'Test Group 2',
         members: [testPlayer4, testPlayer5],
       );
-      testGame1 = Game(
-        name: 'First Test Game',
+      testMatch1 = Match(
+        name: 'First Test Match',
         group: testGroup1,
         players: [testPlayer4, testPlayer5],
         winner: testPlayer4,
       );
-      testGame2 = Game(
-        name: 'Second Test Game',
+      testMatch2 = Match(
+        name: 'Second Test Match',
         group: testGroup2,
         players: [testPlayer1, testPlayer2, testPlayer3],
         winner: testPlayer2,
       );
-      testGameOnlyPlayers = Game(
-        name: 'Test Game with Players',
+      testMatchOnlyPlayers = Match(
+        name: 'Test Match with Players',
         players: [testPlayer1, testPlayer2, testPlayer3],
         winner: testPlayer3,
       );
-      testGameOnlyGroup = Game(name: 'Test Game with Group', group: testGroup2);
+      testMatchOnlyGroup = Match(
+        name: 'Test Match with Group',
+        group: testGroup2,
+      );
     });
   });
   tearDown(() async {
     await database.close();
   });
 
-  group('Game Tests', () {
-    test('Adding and fetching single game works correctly', () async {
-      await database.gameDao.addGame(game: testGame1);
+  group('Match Tests', () {
+    test('Adding and fetching single match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatch1);
 
-      final result = await database.gameDao.getGameById(gameId: testGame1.id);
+      final result = await database.matchDao.getMatchById(
+        matchId: testMatch1.id,
+      );
 
-      expect(result.id, testGame1.id);
-      expect(result.name, testGame1.name);
-      expect(result.createdAt, testGame1.createdAt);
+      expect(result.id, testMatch1.id);
+      expect(result.name, testMatch1.name);
+      expect(result.createdAt, testMatch1.createdAt);
 
-      if (result.winner != null && testGame1.winner != null) {
-        expect(result.winner!.id, testGame1.winner!.id);
-        expect(result.winner!.name, testGame1.winner!.name);
-        expect(result.winner!.createdAt, testGame1.winner!.createdAt);
+      if (result.winner != null && testMatch1.winner != null) {
+        expect(result.winner!.id, testMatch1.winner!.id);
+        expect(result.winner!.name, testMatch1.winner!.name);
+        expect(result.winner!.createdAt, testMatch1.winner!.createdAt);
       } else {
-        expect(result.winner, testGame1.winner);
+        expect(result.winner, testMatch1.winner);
       }
 
       if (result.group != null) {
@@ -99,188 +104,203 @@ void main() {
         fail('Group is null');
       }
       if (result.players != null) {
-        expect(result.players!.length, testGame1.players!.length);
+        expect(result.players!.length, testMatch1.players!.length);
 
-        for (int i = 0; i < testGame1.players!.length; i++) {
-          expect(result.players![i].id, testGame1.players![i].id);
-          expect(result.players![i].name, testGame1.players![i].name);
-          expect(result.players![i].createdAt, testGame1.players![i].createdAt);
+        for (int i = 0; i < testMatch1.players!.length; i++) {
+          expect(result.players![i].id, testMatch1.players![i].id);
+          expect(result.players![i].name, testMatch1.players![i].name);
+          expect(
+            result.players![i].createdAt,
+            testMatch1.players![i].createdAt,
+          );
         }
       } else {
         fail('Players is null');
       }
     });
 
-    test('Adding and fetching multiple games works correctly', () async {
-      await database.gameDao.addGamesAsList(
-        games: [testGame1, testGame2, testGameOnlyGroup, testGameOnlyPlayers],
+    test('Adding and fetching multiple matches works correctly', () async {
+      await database.matchDao.addMatchAsList(
+        matches: [
+          testMatch1,
+          testMatch2,
+          testMatchOnlyGroup,
+          testMatchOnlyPlayers,
+        ],
       );
 
-      final allGames = await database.gameDao.getAllGames();
-      expect(allGames.length, 4);
+      final allMatches = await database.matchDao.getAllMatches();
+      expect(allMatches.length, 4);
 
-      final testGames = {
-        testGame1.id: testGame1,
-        testGame2.id: testGame2,
-        testGameOnlyGroup.id: testGameOnlyGroup,
-        testGameOnlyPlayers.id: testGameOnlyPlayers,
+      final testMatches = {
+        testMatch1.id: testMatch1,
+        testMatch2.id: testMatch2,
+        testMatchOnlyGroup.id: testMatchOnlyGroup,
+        testMatchOnlyPlayers.id: testMatchOnlyPlayers,
       };
 
-      for (final game in allGames) {
-        final testGame = testGames[game.id]!;
+      for (final match in allMatches) {
+        final testMatch = testMatches[match.id]!;
 
-        // Game-Checks
-        expect(game.id, testGame.id);
-        expect(game.name, testGame.name);
-        expect(game.createdAt, testGame.createdAt);
-        if (game.winner != null && testGame.winner != null) {
-          expect(game.winner!.id, testGame.winner!.id);
-          expect(game.winner!.name, testGame.winner!.name);
-          expect(game.winner!.createdAt, testGame.winner!.createdAt);
+        // Match-Checks
+        expect(match.id, testMatch.id);
+        expect(match.name, testMatch.name);
+        expect(match.createdAt, testMatch.createdAt);
+        if (match.winner != null && testMatch.winner != null) {
+          expect(match.winner!.id, testMatch.winner!.id);
+          expect(match.winner!.name, testMatch.winner!.name);
+          expect(match.winner!.createdAt, testMatch.winner!.createdAt);
         } else {
-          expect(game.winner, testGame.winner);
+          expect(match.winner, testMatch.winner);
         }
 
         // Group-Checks
-        if (testGame.group != null) {
-          expect(game.group!.id, testGame.group!.id);
-          expect(game.group!.name, testGame.group!.name);
-          expect(game.group!.createdAt, testGame.group!.createdAt);
+        if (testMatch.group != null) {
+          expect(match.group!.id, testMatch.group!.id);
+          expect(match.group!.name, testMatch.group!.name);
+          expect(match.group!.createdAt, testMatch.group!.createdAt);
 
           // Group Members-Checks
-          expect(game.group!.members.length, testGame.group!.members.length);
-          for (int i = 0; i < testGame.group!.members.length; i++) {
-            expect(game.group!.members[i].id, testGame.group!.members[i].id);
+          expect(match.group!.members.length, testMatch.group!.members.length);
+          for (int i = 0; i < testMatch.group!.members.length; i++) {
+            expect(match.group!.members[i].id, testMatch.group!.members[i].id);
             expect(
-              game.group!.members[i].name,
-              testGame.group!.members[i].name,
+              match.group!.members[i].name,
+              testMatch.group!.members[i].name,
             );
             expect(
-              game.group!.members[i].createdAt,
-              testGame.group!.members[i].createdAt,
+              match.group!.members[i].createdAt,
+              testMatch.group!.members[i].createdAt,
             );
           }
         } else {
-          expect(game.group, null);
+          expect(match.group, null);
         }
 
         // Players-Checks
-        if (testGame.players != null) {
-          expect(game.players!.length, testGame.players!.length);
-          for (int i = 0; i < testGame.players!.length; i++) {
-            expect(game.players![i].id, testGame.players![i].id);
-            expect(game.players![i].name, testGame.players![i].name);
-            expect(game.players![i].createdAt, testGame.players![i].createdAt);
+        if (testMatch.players != null) {
+          expect(match.players!.length, testMatch.players!.length);
+          for (int i = 0; i < testMatch.players!.length; i++) {
+            expect(match.players![i].id, testMatch.players![i].id);
+            expect(match.players![i].name, testMatch.players![i].name);
+            expect(
+              match.players![i].createdAt,
+              testMatch.players![i].createdAt,
+            );
           }
         } else {
-          expect(game.players, null);
+          expect(match.players, null);
         }
       }
     });
 
-    test('Adding the same game twice does not create duplicates', () async {
-      await database.gameDao.addGame(game: testGame1);
-      await database.gameDao.addGame(game: testGame1);
+    test('Adding the same match twice does not create duplicates', () async {
+      await database.matchDao.addMatch(match: testMatch1);
+      await database.matchDao.addMatch(match: testMatch1);
 
-      final gameCount = await database.gameDao.getGameCount();
-      expect(gameCount, 1);
+      final matchCount = await database.matchDao.getMatchCount();
+      expect(matchCount, 1);
     });
 
-    test('Game existence check works correctly', () async {
-      var gameExists = await database.gameDao.gameExists(gameId: testGame1.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,
+    test('Match existence check works correctly', () async {
+      var matchExists = await database.matchDao.matchExists(
+        matchId: testMatch1.id,
       );
-      expect(gameDeleted, true);
+      expect(matchExists, false);
 
-      final gameExists = await database.gameDao.gameExists(
-        gameId: testGame1.id,
+      await database.matchDao.addMatch(match: testMatch1);
+
+      matchExists = await database.matchDao.matchExists(matchId: testMatch1.id);
+      expect(matchExists, true);
+    });
+
+    test('Deleting a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatch1);
+
+      final matchDeleted = await database.matchDao.deleteMatch(
+        matchId: testMatch1.id,
       );
-      expect(gameExists, false);
+      expect(matchDeleted, true);
+
+      final matchExists = await database.matchDao.matchExists(
+        matchId: testMatch1.id,
+      );
+      expect(matchExists, false);
     });
 
-    test('Getting the game count works correctly', () async {
-      var gameCount = await database.gameDao.getGameCount();
-      expect(gameCount, 0);
+    test('Getting the match count works correctly', () async {
+      var matchCount = await database.matchDao.getMatchCount();
+      expect(matchCount, 0);
 
-      await database.gameDao.addGame(game: testGame1);
+      await database.matchDao.addMatch(match: testMatch1);
 
-      gameCount = await database.gameDao.getGameCount();
-      expect(gameCount, 1);
+      matchCount = await database.matchDao.getMatchCount();
+      expect(matchCount, 1);
 
-      await database.gameDao.addGame(game: testGame2);
+      await database.matchDao.addMatch(match: testMatch2);
 
-      gameCount = await database.gameDao.getGameCount();
-      expect(gameCount, 2);
+      matchCount = await database.matchDao.getMatchCount();
+      expect(matchCount, 2);
 
-      await database.gameDao.deleteGame(gameId: testGame1.id);
+      await database.matchDao.deleteMatch(matchId: testMatch1.id);
 
-      gameCount = await database.gameDao.getGameCount();
-      expect(gameCount, 1);
+      matchCount = await database.matchDao.getMatchCount();
+      expect(matchCount, 1);
 
-      await database.gameDao.deleteGame(gameId: testGame2.id);
+      await database.matchDao.deleteMatch(matchId: testMatch2.id);
 
-      gameCount = await database.gameDao.getGameCount();
-      expect(gameCount, 0);
+      matchCount = await database.matchDao.getMatchCount();
+      expect(matchCount, 0);
     });
 
-    test('Checking if game has winner works correclty', () async {
-      await database.gameDao.addGame(game: testGame1);
-      await database.gameDao.addGame(game: testGameOnlyGroup);
+    test('Checking if match has winner works correclty', () async {
+      await database.matchDao.addMatch(match: testMatch1);
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
 
-      var hasWinner = await database.gameDao.hasWinner(gameId: testGame1.id);
+      var hasWinner = await database.matchDao.hasWinner(matchId: testMatch1.id);
       expect(hasWinner, true);
 
-      hasWinner = await database.gameDao.hasWinner(
-        gameId: testGameOnlyGroup.id,
+      hasWinner = await database.matchDao.hasWinner(
+        matchId: testMatchOnlyGroup.id,
       );
       expect(hasWinner, false);
     });
 
-    test('Fetching the winner of a game works correctly', () async {
-      await database.gameDao.addGame(game: testGame1);
+    test('Fetching the winner of a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatch1);
 
-      final winner = await database.gameDao.getWinner(gameId: testGame1.id);
+      final winner = await database.matchDao.getWinner(matchId: testMatch1.id);
       if (winner == null) {
         fail('Winner is null');
       } else {
-        expect(winner.id, testGame1.winner!.id);
-        expect(winner.name, testGame1.winner!.name);
-        expect(winner.createdAt, testGame1.winner!.createdAt);
+        expect(winner.id, testMatch1.winner!.id);
+        expect(winner.name, testMatch1.winner!.name);
+        expect(winner.createdAt, testMatch1.winner!.createdAt);
       }
     });
 
-    test('Updating the winner of a game works correctly', () async {
-      await database.gameDao.addGame(game: testGame1);
+    test('Updating the winner of a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatch1);
 
-      final winner = await database.gameDao.getWinner(gameId: testGame1.id);
+      final winner = await database.matchDao.getWinner(matchId: testMatch1.id);
       if (winner == null) {
         fail('Winner is null');
       } else {
-        expect(winner.id, testGame1.winner!.id);
-        expect(winner.name, testGame1.winner!.name);
-        expect(winner.createdAt, testGame1.winner!.createdAt);
+        expect(winner.id, testMatch1.winner!.id);
+        expect(winner.name, testMatch1.winner!.name);
+        expect(winner.createdAt, testMatch1.winner!.createdAt);
         expect(winner.id, testPlayer4.id);
         expect(winner.id != testPlayer5.id, true);
       }
 
-      await database.gameDao.setWinner(
-        gameId: testGame1.id,
+      await database.matchDao.setWinner(
+        matchId: testMatch1.id,
         winnerId: testPlayer5.id,
       );
 
-      final newWinner = await database.gameDao.getWinner(gameId: testGame1.id);
+      final newWinner = await database.matchDao.getWinner(
+        matchId: testMatch1.id,
+      );
 
       if (newWinner == null) {
         fail('New winner is null');
@@ -292,39 +312,41 @@ void main() {
     });
 
     test('Removing a winner works correctly', () async {
-      await database.gameDao.addGame(game: testGame2);
+      await database.matchDao.addMatch(match: testMatch2);
 
-      var hasWinner = await database.gameDao.hasWinner(gameId: testGame2.id);
+      var hasWinner = await database.matchDao.hasWinner(matchId: testMatch2.id);
       expect(hasWinner, true);
 
-      await database.gameDao.removeWinner(gameId: testGame2.id);
+      await database.matchDao.removeWinner(matchId: testMatch2.id);
 
-      hasWinner = await database.gameDao.hasWinner(gameId: testGame2.id);
+      hasWinner = await database.matchDao.hasWinner(matchId: testMatch2.id);
       expect(hasWinner, false);
 
-      final removedWinner = await database.gameDao.getWinner(
-        gameId: testGame2.id,
+      final removedWinner = await database.matchDao.getWinner(
+        matchId: testMatch2.id,
       );
 
       expect(removedWinner, null);
     });
 
-    test('Renaming a game works correctly', () async {
-      await database.gameDao.addGame(game: testGame1);
+    test('Renaming a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatch1);
 
-      var fetchedGame = await database.gameDao.getGameById(
-        gameId: testGame1.id,
+      var fetchedMatch = await database.matchDao.getMatchById(
+        matchId: testMatch1.id,
       );
-      expect(fetchedGame.name, testGame1.name);
+      expect(fetchedMatch.name, testMatch1.name);
 
-      const newName = 'Updated Game Name';
-      await database.gameDao.updateGameName(
-        gameId: testGame1.id,
+      const newName = 'Updated Match Name';
+      await database.matchDao.updateMatchName(
+        matchId: testMatch1.id,
         newName: newName,
       );
 
-      fetchedGame = await database.gameDao.getGameById(gameId: testGame1.id);
-      expect(fetchedGame.name, newName);
+      fetchedMatch = await database.matchDao.getMatchById(
+        matchId: testMatch1.id,
+      );
+      expect(fetchedMatch.name, newName);
     });
   });
 }
diff --git a/test/db_tests/group_game_test.dart b/test/db_tests/group_game_test.dart
index 1e9b8fc..a4fa146 100644
--- a/test/db_tests/group_game_test.dart
+++ b/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 Game testgameWithGroup;
-  late Game testgameWithPlayers;
+  late Match testMatchWithGroup;
+  late Match testMatchWithPlayers;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
@@ -44,81 +44,84 @@ void main() {
         name: 'Test Group',
         members: [testPlayer3, testPlayer2],
       );
-      testgameWithPlayers = Game(
-        name: 'Test Game with Players',
+      testMatchWithPlayers = Match(
+        name: 'Test Match with Players',
         players: [testPlayer4, testPlayer5],
       );
-      testgameWithGroup = Game(name: 'Test Game with Group', group: testGroup1);
+      testMatchWithGroup = Match(
+        name: 'Test Match with Group',
+        group: testGroup1,
+      );
     });
   });
   tearDown(() async {
     await database.close();
   });
-  group('Group-Game Tests', () {
-    test('Game has group works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithPlayers);
+  group('Group-Match Tests', () {
+    test('matchHasGroup() has group works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchWithPlayers);
       await database.groupDao.addGroup(group: testGroup1);
 
-      var gameHasGroup = await database.groupGameDao.gameHasGroup(
-        gameId: testgameWithPlayers.id,
+      var matchHasGroup = await database.groupMatchDao.matchHasGroup(
+        matchId: testMatchWithPlayers.id,
       );
 
-      expect(gameHasGroup, false);
+      expect(matchHasGroup, false);
 
-      await database.groupGameDao.addGroupToGame(
-        gameId: testgameWithPlayers.id,
+      await database.groupMatchDao.addGroupToMatch(
+        matchId: testMatchWithPlayers.id,
         groupId: testGroup1.id,
       );
 
-      gameHasGroup = await database.groupGameDao.gameHasGroup(
-        gameId: testgameWithPlayers.id,
+      matchHasGroup = await database.groupMatchDao.matchHasGroup(
+        matchId: testMatchWithPlayers.id,
       );
 
-      expect(gameHasGroup, true);
+      expect(matchHasGroup, true);
     });
 
-    test('Adding a group to a game works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithPlayers);
+    test('Adding a group to a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchWithPlayers);
       await database.groupDao.addGroup(group: testGroup1);
-      await database.groupGameDao.addGroupToGame(
-        gameId: testgameWithPlayers.id,
+      await database.groupMatchDao.addGroupToMatch(
+        matchId: testMatchWithPlayers.id,
         groupId: testGroup1.id,
       );
 
-      var groupAdded = await database.groupGameDao.isGroupInGame(
-        gameId: testgameWithPlayers.id,
+      var groupAdded = await database.groupMatchDao.isGroupInMatch(
+        matchId: testMatchWithPlayers.id,
         groupId: testGroup1.id,
       );
       expect(groupAdded, true);
 
-      groupAdded = await database.groupGameDao.isGroupInGame(
-        gameId: testgameWithPlayers.id,
+      groupAdded = await database.groupMatchDao.isGroupInMatch(
+        matchId: testMatchWithPlayers.id,
         groupId: '',
       );
       expect(groupAdded, false);
     });
 
-    test('Removing group from game works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithGroup);
+    test('Removing group from match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchWithGroup);
 
-      final groupToRemove = testgameWithGroup.group!;
+      final groupToRemove = testMatchWithGroup.group!;
 
-      final removed = await database.groupGameDao.removeGroupFromGame(
+      final removed = await database.groupMatchDao.removeGroupFromMatch(
         groupId: groupToRemove.id,
-        gameId: testgameWithGroup.id,
+        matchId: testMatchWithGroup.id,
       );
       expect(removed, true);
 
-      final result = await database.gameDao.getGameById(
-        gameId: testgameWithGroup.id,
+      final result = await database.matchDao.getMatchById(
+        matchId: testMatchWithGroup.id,
       );
       expect(result.group, null);
     });
 
-    test('Retrieving group of a game works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithGroup);
-      final group = await database.groupGameDao.getGroupOfGame(
-        gameId: testgameWithGroup.id,
+    test('Retrieving group of a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchWithGroup);
+      final group = await database.groupMatchDao.getGroupOfMatch(
+        matchId: testMatchWithGroup.id,
       );
 
       if (group == null) {
@@ -136,11 +139,11 @@ void main() {
       }
     });
 
-    test('Updating the group of a game works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithGroup);
+    test('Updating the group of a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchWithGroup);
 
-      var group = await database.groupGameDao.getGroupOfGame(
-        gameId: testgameWithGroup.id,
+      var group = await database.groupMatchDao.getGroupOfMatch(
+        matchId: testMatchWithGroup.id,
       );
 
       if (group == null) {
@@ -153,13 +156,13 @@ void main() {
       }
 
       await database.groupDao.addGroup(group: testGroup2);
-      await database.groupGameDao.updateGroupOfGame(
-        gameId: testgameWithGroup.id,
+      await database.groupMatchDao.updateGroupOfMatch(
+        matchId: testMatchWithGroup.id,
         newGroupId: testGroup2.id,
       );
 
-      group = await database.groupGameDao.getGroupOfGame(
-        gameId: testgameWithGroup.id,
+      group = await database.groupMatchDao.getGroupOfMatch(
+        matchId: testMatchWithGroup.id,
       );
 
       if (group == null) {
diff --git a/test/db_tests/player_game_test.dart b/test/db_tests/player_game_test.dart
index 4e2616e..e2501eb 100644
--- a/test/db_tests/player_game_test.dart
+++ b/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 Game testGameOnlyGroup;
-  late Game testGameOnlyPlayers;
+  late Match testMatchOnlyGroup;
+  late Match testMatchOnlyPlayers;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
@@ -41,9 +41,12 @@ void main() {
         name: 'Test Group',
         members: [testPlayer1, testPlayer2, testPlayer3],
       );
-      testGameOnlyGroup = Game(name: 'Test Game with Group', group: testgroup);
-      testGameOnlyPlayers = Game(
-        name: 'Test Game with Players',
+      testMatchOnlyGroup = Match(
+        name: 'Test Match with Group',
+        group: testgroup,
+      );
+      testMatchOnlyPlayers = Match(
+        name: 'Test Match with Players',
         players: [testPlayer4, testPlayer5, testPlayer6],
       );
     });
@@ -52,67 +55,67 @@ void main() {
     await database.close();
   });
 
-  group('Player-Game Tests', () {
-    test('Game has player works correctly', () async {
-      await database.gameDao.addGame(game: testGameOnlyGroup);
+  group('Player-Match Tests', () {
+    test('Match has player works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.playerDao.addPlayer(player: testPlayer1);
 
-      var gameHasPlayers = await database.playerGameDao.gameHasPlayers(
-        gameId: testGameOnlyGroup.id,
+      var matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
+        matchId: testMatchOnlyGroup.id,
       );
 
-      expect(gameHasPlayers, false);
+      expect(matchHasPlayers, false);
 
-      await database.playerGameDao.addPlayerToGame(
-        gameId: testGameOnlyGroup.id,
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
         playerId: testPlayer1.id,
       );
 
-      gameHasPlayers = await database.playerGameDao.gameHasPlayers(
-        gameId: testGameOnlyGroup.id,
+      matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
+        matchId: testMatchOnlyGroup.id,
       );
 
-      expect(gameHasPlayers, true);
+      expect(matchHasPlayers, true);
     });
 
-    test('Adding a player to a game works correctly', () async {
-      await database.gameDao.addGame(game: testGameOnlyGroup);
+    test('Adding a player to a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.playerDao.addPlayer(player: testPlayer5);
-      await database.playerGameDao.addPlayerToGame(
-        gameId: testGameOnlyGroup.id,
+      await database.playerMatchDao.addPlayerToMatch(
+        matchId: testMatchOnlyGroup.id,
         playerId: testPlayer5.id,
       );
 
-      var playerAdded = await database.playerGameDao.isPlayerInGame(
-        gameId: testGameOnlyGroup.id,
+      var playerAdded = await database.playerMatchDao.isPlayerInMatch(
+        matchId: testMatchOnlyGroup.id,
         playerId: testPlayer5.id,
       );
 
       expect(playerAdded, true);
 
-      playerAdded = await database.playerGameDao.isPlayerInGame(
-        gameId: testGameOnlyGroup.id,
+      playerAdded = await database.playerMatchDao.isPlayerInMatch(
+        matchId: testMatchOnlyGroup.id,
         playerId: '',
       );
 
       expect(playerAdded, false);
     });
 
-    test('Removing player from game works correctly', () async {
-      await database.gameDao.addGame(game: testGameOnlyPlayers);
+    test('Removing player from match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
 
-      final playerToRemove = testGameOnlyPlayers.players![0];
+      final playerToRemove = testMatchOnlyPlayers.players![0];
 
-      final removed = await database.playerGameDao.removePlayerFromGame(
+      final removed = await database.playerMatchDao.removePlayerFromMatch(
         playerId: playerToRemove.id,
-        gameId: testGameOnlyPlayers.id,
+        matchId: testMatchOnlyPlayers.id,
       );
       expect(removed, true);
 
-      final result = await database.gameDao.getGameById(
-        gameId: testGameOnlyPlayers.id,
+      final result = await database.matchDao.getMatchById(
+        matchId: testMatchOnlyPlayers.id,
       );
-      expect(result.players!.length, testGameOnlyPlayers.players!.length - 1);
+      expect(result.players!.length, testMatchOnlyPlayers.players!.length - 1);
 
       final playerExists = result.players!.any(
         (p) => p.id == playerToRemove.id,
@@ -120,10 +123,10 @@ void main() {
       expect(playerExists, false);
     });
 
-    test('Retrieving players of a game works correctly', () async {
-      await database.gameDao.addGame(game: testGameOnlyPlayers);
-      final players = await database.playerGameDao.getPlayersOfGame(
-        gameId: testGameOnlyPlayers.id,
+    test('Retrieving players of a match works correctly', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+      final players = await database.playerMatchDao.getPlayersOfMatch(
+        matchId: testMatchOnlyPlayers.id,
       );
 
       if (players == null) {
@@ -131,34 +134,37 @@ void main() {
       }
 
       for (int i = 0; i < players.length; i++) {
-        expect(players[i].id, testGameOnlyPlayers.players![i].id);
-        expect(players[i].name, testGameOnlyPlayers.players![i].name);
-        expect(players[i].createdAt, testGameOnlyPlayers.players![i].createdAt);
+        expect(players[i].id, testMatchOnlyPlayers.players![i].id);
+        expect(players[i].name, testMatchOnlyPlayers.players![i].name);
+        expect(
+          players[i].createdAt,
+          testMatchOnlyPlayers.players![i].createdAt,
+        );
       }
     });
 
-    test('Updating the games players works coreclty', () async {
-      await database.gameDao.addGame(game: testGameOnlyPlayers);
+    test('Updating the match players works coreclty', () async {
+      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
 
       final newPlayers = [testPlayer1, testPlayer2, testPlayer4];
       await database.playerDao.addPlayersAsList(players: newPlayers);
 
       // First, remove all existing players
-      final existingPlayers = await database.playerGameDao.getPlayersOfGame(
-        gameId: testGameOnlyPlayers.id,
+      final existingPlayers = await database.playerMatchDao.getPlayersOfMatch(
+        matchId: testMatchOnlyPlayers.id,
       );
 
       if (existingPlayers == null || existingPlayers.isEmpty) {
         fail('Existing players should not be null or empty');
       }
 
-      await database.playerGameDao.updatePlayersFromGame(
-        gameId: testGameOnlyPlayers.id,
+      await database.playerMatchDao.updatePlayersFromMatch(
+        matchId: testMatchOnlyPlayers.id,
         newPlayer: newPlayers,
       );
 
-      final updatedPlayers = await database.playerGameDao.getPlayersOfGame(
-        gameId: testGameOnlyPlayers.id,
+      final updatedPlayers = await database.playerMatchDao.getPlayersOfMatch(
+        matchId: testMatchOnlyPlayers.id,
       );
 
       if (updatedPlayers == null) {