2024-05-21 21:56:36 +00:00
9 changed files with 201 additions and 190 deletions
--- a/lib/api/game_info.dart
+++ b/lib/api/game_info.dart
@ -3,43 +3,33 @@ import 'package:uuid/uuid.dart';

 class GameInfo {
  final UuidValue? playerID;
-  final UuidValue? lobbyID;
  final String? passphrase;

  const GameInfo({
    required this.playerID,
-    required this.lobbyID,
    required this.passphrase,
  });

  factory GameInfo.empty() {
-    return const GameInfo(playerID: null, lobbyID: null, passphrase: null);
+    return const GameInfo(playerID: null, passphrase: null);
  }

  factory GameInfo.fromJson(Map<String, dynamic> json) {
    final playerid = UuidValue.fromString(json['playerID']);
-    final lobbyid = UuidValue.fromString(json['lobbyID']);
    final passphrase = json['passphrase'];

-    return GameInfo(
-        playerID: playerid, lobbyID: lobbyid, passphrase: passphrase);
+    return GameInfo(playerID: playerid, passphrase: passphrase);
  }

  Map<String, dynamic> toJson() {
    String? pid;
-    String? lid;

    if (playerID != null) {
      pid = playerID.toString();
    }

-    if (lobbyID != null) {
-      lid = lobbyID.toString();
-    }
-
    return {
      'playerID': pid,
-      'lobbyID': lid,
      'passphrase': passphrase,
    };
  }
@ -47,51 +37,29 @@ class GameInfo {
  void store() async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();

-    await prefs.setBool("contains", true);
-    await prefs.setString("playerID", playerID.toString());
-    await prefs.setString("lobbyID", lobbyID.toString());
-    await prefs.setString("passphrase", passphrase.toString());
+    await prefs.setString(passphrase!, playerID.toString());
  }

-  void delete() async {
+  static Future<GameInfo?> get(String phrase) async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    var playerID = prefs.getString(phrase);

-    await prefs.setBool("contains", false);
-  }
-
-  static Future<GameInfo?> get() async {
-    final SharedPreferences prefs = await SharedPreferences.getInstance();
-    var contains = prefs.getBool("contains");
-    var playerID = prefs.getString("playerID");
-    var lobbyID = prefs.getString("lobbyID");
-    var passphrase = prefs.getString("passphrase");
-
-    if (contains == null ||
-        !contains ||
-        playerID == null ||
-        lobbyID == null ||
-        passphrase == null) {
-      return null;
-    }
+    if (playerID == null) return null;

    return GameInfo(
-        playerID: UuidValue.fromString(playerID),
-        lobbyID: UuidValue.fromString(lobbyID),
-        passphrase: passphrase);
+        playerID: UuidValue.fromString(playerID), passphrase: phrase);
  }
 }

 class WebsocketMessageIdentifyPlayer {
  final String playerID;
-  final String lobbyID;
  final String? passphrase;

  const WebsocketMessageIdentifyPlayer({
    required this.playerID,
-    required this.lobbyID,
    required this.passphrase,
  });

  Map<String, dynamic> toJson() =>
-      {'lobbyID': lobbyID, 'playerID': playerID, 'passphrase': passphrase};
+      {'playerID': playerID, 'passphrase': passphrase};
 }
--- a/lib/chess/chess_app.dart
+++ b/lib/chess/chess_app.dart
@ -31,7 +31,7 @@ class ChessApp extends StatelessWidget {
          useMaterial3: true,
        ),
        routerConfig: ChessAppRouter.getInstance().router,
-        title: 'mChess 1.0.6',
+        title: 'mChess 1.0.7',
      ),
    );
  }
--- a/lib/connection/ws_connection.dart
+++ b/lib/connection/ws_connection.dart
@ -40,15 +40,16 @@ class ServerConnection {
    channel!.sink.add(message);
  }

-  void connect(String playerID, lobbyID, String? passphrase) {
-    disconnectExistingConnection();
+  Future? connect(String playerID, String? passphrase) {
+    if (channel != null) return null;
+
    channel = WebSocketChannel.connect(Uri.parse(config.getWebsocketURL()));

+    channel!.ready.then((val) {
      send(
        jsonEncode(
          WebsocketMessageIdentifyPlayer(
            playerID: (playerID),
-          lobbyID: (lobbyID),
            passphrase: (passphrase),
          ),
        ),
@ -57,12 +58,17 @@ class ServerConnection {
      log(channel!.closeCode.toString());
      broadcast = channel!.stream.asBroadcastStream();
      broadcast.listen(handleIncomingData);
+    });
+
+    return channel!.ready;
  }

-  void disconnectExistingConnection() {
+  Future disconnectExistingConnection() async {
    if (channel == null) return;
-    channel!.sink.close();

+    await channel!.sink.close();
+
+    channel = null;
    broadcast = const Stream.empty();
  }

--- a/lib/connection_cubit/connection_cubit.dart
+++ b/lib/connection_cubit/connection_cubit.dart
@ -15,21 +15,64 @@ class ConnectionCubit extends Cubit<ConnectionCubitState> {
    return _instance;
  }

-  void connect(String playerID, lobbyID, String? passphrase) {
-    ServerConnection.getInstance().connect(playerID, lobbyID, passphrase);
+  void connect(String playerID, String? passphrase) {
+    var connectedFuture =
+        ServerConnection.getInstance().connect(playerID, passphrase);
+
+    connectedFuture?.then((val) {
+      emit(ConnectionCubitState(
+          iAmConnected: true,
+          connectedToPhrase: passphrase,
+          opponentConnected: false));
+    });
+  }
+
+  void connectIfNotConnected(String playerID, String? passphrase) {
+    if (state.iAmConnected && state.connectedToPhrase == passphrase) {
+      return;
+    }
+    if (state.iAmConnected && state.connectedToPhrase != passphrase) {
+      disonnect().then((val) {
+        connect(playerID, passphrase);
+      });
+    }
+
+    connect(playerID, passphrase);
+  }
+
+  Future disonnect() async {
+    var disconnectFuture =
+        ServerConnection.getInstance().disconnectExistingConnection();
+
+    disconnectFuture.then(
+      (val) {
+        emit(ConnectionCubitState.init());
+      },
+    );
+
+    return disconnectFuture;
  }

  void opponentConnected() {
-    emit(ConnectionCubitState(true));
+    emit(ConnectionCubitState(
+        iAmConnected: state.iAmConnected,
+        connectedToPhrase: state.connectedToPhrase,
+        opponentConnected: true));
  }
 }

 class ConnectionCubitState {
+  final bool iAmConnected;
+  final String? connectedToPhrase;
  final bool opponentConnected;

-  ConnectionCubitState(this.opponentConnected);
+  ConnectionCubitState(
+      {required this.iAmConnected,
+      required this.connectedToPhrase,
+      required this.opponentConnected});

  factory ConnectionCubitState.init() {
-    return ConnectionCubitState(false);
+    return ConnectionCubitState(
+        iAmConnected: false, connectedToPhrase: null, opponentConnected: false);
  }
 }
--- a/lib/pages/create_game_widget.dart
+++ b/lib/pages/create_game_widget.dart
@ -24,35 +24,22 @@ class CreateGameWidget extends StatefulWidget {

 class _CreateGameWidgetState extends State<CreateGameWidget> {
  late Future<GameInfo?> registerResponse;
+  late Future disconnectFuture;
  late ChessGameArguments chessGameArgs;

  @override
  void initState() {
-    registerResponse = hostPrivateGame();
-
-    registerResponse.then((args) {
-      if (args == null) return;
-
-      chessGameArgs = ChessGameArguments(
-          lobbyID: args.lobbyID!,
-          playerID: args.playerID!,
-          passphrase: args.passphrase);
-    });
-
-    connectToWebsocket(registerResponse);
    super.initState();
-  }
-
-  void connectToWebsocket(Future<GameInfo?> resp) {
-    resp.then((value) {
-      if (value == null) return;
-
-      ConnectionCubit.getInstance().connect(
-        value.playerID!.uuid,
-        value.lobbyID!.uuid,
-        value.passphrase,
+    disconnectFuture = ConnectionCubit().disonnect();
+    disconnectFuture.then((val) {
+      registerResponse = createPrivateGame();
+      registerResponse.then((val) {
+        ConnectionCubit().connectIfNotConnected(
+          val!.playerID.toString(),
+          val.passphrase,
        );
      });
+    });
  }

  @override
@ -72,7 +59,13 @@ class _CreateGameWidgetState extends State<CreateGameWidget> {
    return Scaffold(
      floatingActionButton: fltnBtn,
      body: Center(
-        child: FutureBuilder<GameInfo?>(
+        child: FutureBuilder(
+            future: disconnectFuture,
+            builder: (context, snapshot) {
+              if (snapshot.connectionState != ConnectionState.done) {
+                return Container();
+              } else {
+                return FutureBuilder<GameInfo?>(
                  future: registerResponse,
                  builder: (context, snapshot) {
                    if (snapshot.connectionState != ConnectionState.done) {
@ -82,15 +75,17 @@ class _CreateGameWidgetState extends State<CreateGameWidget> {
                        child: CircularProgressIndicator(),
                      );
                    } else {
-              String passphrase = snapshot.data?.passphrase ?? "no passphrase";
-              return BlocListener<ConnectionCubit, ConnectionCubitState>(
+                      var passphrase =
+                          snapshot.data?.passphrase ?? "no passphrase";
+                      return BlocListener<ConnectionCubit,
+                          ConnectionCubitState>(
                        listener: (context, state) {
                          // We wait for our opponent to connect
                          if (state.opponentConnected) {
                            //TODO: is goNamed the correct way to navigate?
-                    context.goNamed('game',
-                        pathParameters: {'phrase': passphrase.toURL()},
-                        extra: chessGameArgs);
+                            context.goNamed('game', pathParameters: {
+                              'phrase': passphrase.toURL(),
+                            });
                          }
                        },
                        child: Column(
@ -107,7 +102,8 @@ class _CreateGameWidgetState extends State<CreateGameWidget> {
                              children: [
                                SelectableText(
                                  passphrase,
-                          style: const TextStyle(fontWeight: FontWeight.bold),
+                                  style: const TextStyle(
+                                      fontWeight: FontWeight.bold),
                                ),
                                IconButton(
                                  icon: const Icon(Icons.copy),
@ -125,16 +121,18 @@ class _CreateGameWidgetState extends State<CreateGameWidget> {
                      );
                    }
                  },
-        ),
+                );
+              }
+            }),
      ),
    );
  }

-  Future<GameInfo?> hostPrivateGame() async {
+  Future<GameInfo?> createPrivateGame() async {
    Response response;

    try {
-      response = await http.get(Uri.parse(config.getHostURL()),
+      response = await http.get(Uri.parse(config.getCreateGameURL()),
          headers: {"Accept": "application/json"});
    } catch (e) {
      log('Exception: ${e.toString()}');
--- a/lib/pages/join_game_handle_widget.dart
+++ b/lib/pages/join_game_handle_widget.dart
@ -3,7 +3,7 @@ import 'dart:developer';
 import 'dart:io';

 import 'package:flutter/material.dart';
-import 'package:go_router/go_router.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:http/http.dart' as http;
 import 'package:mchess/api/game_info.dart';
 import 'package:mchess/connection_cubit/connection_cubit.dart';
@ -23,65 +23,62 @@ class _JoinGameHandleWidgetState extends State<JoinGameHandleWidget> {

  @override
  void initState() {
-    joinGameFuture = joinPrivateGame(widget.passphrase);
-    joinGameFuture.then(
-      (value) {
-        if (value != null) {
-          switchToGame(value);
-        }
-      },
-    );
    super.initState();
+    joinGameFuture = joinPrivateGame(widget.passphrase);
+    joinGameFuture.then((val) {
+      ConnectionCubit.getInstance().connectIfNotConnected(
+        val!.playerID!.uuid,
+        val.passphrase,
+      );
+    });
  }

  @override
  Widget build(BuildContext context) {
+    var loadingIndicator = const SizedBox(
+      height: 100,
+      width: 100,
+      child: CircularProgressIndicator(),
+    );
+
+    return Scaffold(
+      body: Center(
+        child: FutureBuilder(
+            future: joinGameFuture,
+            builder: (context, snapshot) {
+              if (snapshot.connectionState != ConnectionState.done) {
+                return loadingIndicator;
+              } else {
+                return BlocBuilder<ConnectionCubit, ConnectionCubitState>(
+                    builder: (context, state) {
+                  if (state.iAmConnected) {
                    return const ChessGame();
+                  } else {
+                    return loadingIndicator;
                  }
-
-  void switchToGame(GameInfo info) {
-    var chessGameArgs = ChessGameArguments(
-        lobbyID: info.lobbyID!,
-        playerID: info.playerID!,
-        passphrase: info.passphrase);
-
-    ConnectionCubit.getInstance().connect(
-      info.playerID!.uuid,
-      info.lobbyID!.uuid,
-      info.passphrase,
-    );
-
-    if (!chessGameArgs.isValid()) {
-      context.goNamed('lobbySelector');
-      const snackBar = SnackBar(
-        backgroundColor: Colors.amberAccent,
-        content: Text("Game information is corrupted"),
-      );
-      ScaffoldMessenger.of(context).clearSnackBars();
-      ScaffoldMessenger.of(context).showSnackBar(snackBar);
-
-      return;
+                });
              }
+            }),
+      ),
+    );
  }

  Future<GameInfo?> joinPrivateGame(String phrase) async {
    http.Response response;
-    var existingInfo = await GameInfo.get();
-    log('lobbyID: ${existingInfo?.lobbyID} and playerID: ${existingInfo?.playerID} and passphrase: "${existingInfo?.passphrase}"');
+
+    var existingInfo = await GameInfo.get(phrase);
+    log('playerID: ${existingInfo?.playerID} and passphrase: "${existingInfo?.passphrase}"');

    GameInfo info;
    if (existingInfo?.passphrase == phrase) {
      // We have player info for this exact passphrase
-      info = GameInfo(
-          playerID: existingInfo?.playerID,
-          lobbyID: existingInfo?.lobbyID,
-          passphrase: phrase);
+      info = GameInfo(playerID: existingInfo?.playerID, passphrase: phrase);
    } else {
-      info = GameInfo(playerID: null, lobbyID: null, passphrase: phrase);
+      info = GameInfo(playerID: null, passphrase: phrase);
    }

    try {
-      response = await http.post(Uri.parse(config.getJoinURL()),
+      response = await http.post(Uri.parse(config.getJoinGameURL()),
          body: jsonEncode(info), headers: {"Accept": "application/json"});
    } catch (e) {
      log(e.toString());
@ -114,7 +111,6 @@ class _JoinGameHandleWidgetState extends State<JoinGameHandleWidget> {
      var info = GameInfo.fromJson(jsonDecode(response.body));
      info.store();
      log('Player info received from server: ');
-      log('lobbyID: ${info.lobbyID}');
      log('playerID: ${info.playerID}');
      log('passphrase: ${info.passphrase}');

--- a/lib/pages/lobby_selector.dart
+++ b/lib/pages/lobby_selector.dart
@ -20,7 +20,9 @@ class _LobbySelectorState extends State<LobbySelector> {
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            ElevatedButton(
-              onPressed: () => context.goNamed('createGame'),
+              onPressed: () {
+                context.goNamed('createGame');
+              },
              child: const Row(
                mainAxisSize: MainAxisSize.min,
                children: [
@ -34,7 +36,9 @@ class _LobbySelectorState extends State<LobbySelector> {
            ),
            const SizedBox(height: 20),
            ElevatedButton(
-              onPressed: () => buildEnterPassphraseDialog(context),
+              onPressed: () {
+                buildEnterPassphraseDialog(context);
+              },
              child: const Row(
                mainAxisSize: MainAxisSize.min,
                children: [
--- a/lib/utils/chess_router.dart
+++ b/lib/utils/chess_router.dart
@ -2,7 +2,6 @@ import 'dart:developer';

 import 'package:flutter/widgets.dart';
 import 'package:go_router/go_router.dart';
-import 'package:mchess/connection/ws_connection.dart';
 import 'package:mchess/pages/join_game_handle_widget.dart';
 import 'package:mchess/pages/lobby_selector.dart';
 import 'package:mchess/pages/create_game_widget.dart';
@ -40,8 +39,6 @@ class ChessAppRouter {
            path: 'game/:phrase',
            name: 'game',
            builder: (context, state) {
-              ServerConnection.getInstance().disconnectExistingConnection();
-
              var urlPhrase = state.pathParameters['phrase'];
              if (urlPhrase == null) {
                log('in /game route builder: url phrase null');
@ -49,8 +46,7 @@ class ChessAppRouter {
              }

              return JoinGameHandleWidget(
-                passphrase: urlPhrase.toPhraseWithSpaces(),
-              );
+                  passphrase: urlPhrase.toPhraseWithSpaces());
            },
          )
        ],
--- a/lib/utils/config.dart
+++ b/lib/utils/config.dart
@ -3,7 +3,7 @@ const debugURL = 'localhost:8080';

 const useDbgUrl = false;

-String getHostURL() {
+String getCreateGameURL() {
  var prot = 'https';
  var domain = prodURL;
  if (useDbgUrl) {
@ -13,7 +13,7 @@ String getHostURL() {
  return '$prot://$domain/api/hostPrivate';
 }

-String getJoinURL() {
+String getJoinGameURL() {
  var prot = 'https';
  var domain = prodURL;
  if (useDbgUrl) {