521 lines
11 KiB
C#
521 lines
11 KiB
C#
using Godot;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
|
|
public partial class Connection : Node
|
|
{
|
|
public const string WS_DEFAULT_ADDRESS = "wss://connect4.abunchofknowitalls.com";
|
|
|
|
public static Connection Instance { get; private set; }
|
|
|
|
private WebSocketPeer _webSocket = new ();
|
|
private Thread _gameListThread;
|
|
private bool _gameListThreadRunning;
|
|
|
|
public event Action OnConnected;
|
|
public event Action OnReadyAcknowledged;
|
|
public event Action<bool> OnGameStart;
|
|
public event Action OnGameWin;
|
|
public event Action OnGameLoss;
|
|
public event Action OnGameDraw;
|
|
public event Action OnGameTerminated;
|
|
public event Action<int> OnOpponentMove;
|
|
|
|
public event Action OnWatchGameAck;
|
|
public event Action<string> OnObserveWin;
|
|
public event Action OnObserveDraw;
|
|
public event Action OnObserveTerminated;
|
|
public event Action<string, int> OnObserveMove;
|
|
public event Action<List<MatchData>> OnUpdatedMatches;
|
|
public event Action<List<PlayerData>> OnUpdatedPlayers;
|
|
public event Action OnStartTournamentAck;
|
|
public event Action<List<(string, int)>> OnTournamentEnd;
|
|
public event Action OnBecomeAdmin;
|
|
|
|
public event Action OnWsConnectionSuccess;
|
|
public event Action OnWsConnectionFailed;
|
|
public event Action OnWsDisconnect;
|
|
|
|
// Already prints to console
|
|
public event Action<string> OnError;
|
|
|
|
public bool IsAdmin { get; private set; }
|
|
public bool IsPlayer { get; private set; }
|
|
public bool ActiveTournament { get; private set; }
|
|
public List<(string, int)> PreviousMoves { get; private set; } = [];
|
|
public double CurrentWaitTimeout { get; private set; } = 5.0;
|
|
|
|
|
|
public MatchData CurrentObservingMatch { get; private set; }
|
|
|
|
private bool IsSocketOpen => _webSocket.GetReadyState() == WebSocketPeer.State.Open;
|
|
|
|
private bool _connecting = false;
|
|
private bool _connected = false;
|
|
|
|
public String LastError = "";
|
|
|
|
public override void _Ready()
|
|
{
|
|
Instance = this;
|
|
_webSocket.SetHeartbeatInterval(5.0);
|
|
_webSocket.HeartbeatInterval = 5.0;
|
|
Instance.OnWsDisconnect += () => GetTree().ChangeSceneToFile("res://scenes/main_menu.tscn");
|
|
}
|
|
|
|
public void Connect(string address)
|
|
{
|
|
_connecting = true;
|
|
if (_connected)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Error error = _webSocket.ConnectToUrl(address);
|
|
if (error != Error.Ok)
|
|
{
|
|
LastError = error.ToString();
|
|
}
|
|
}
|
|
|
|
public override void _ExitTree()
|
|
{
|
|
StopGameListRefreshLoop();
|
|
}
|
|
|
|
public override void _Process(double delta)
|
|
{
|
|
_webSocket.Poll();
|
|
WebSocketPeer.State state = _webSocket.GetReadyState();
|
|
if (state == WebSocketPeer.State.Open)
|
|
{
|
|
if (_connecting)
|
|
{
|
|
_connecting = false;
|
|
_connected = true;
|
|
OnWsConnectionSuccess?.Invoke();
|
|
StartGameListRefreshLoop();
|
|
}
|
|
|
|
while (_webSocket.GetAvailablePacketCount() > 0)
|
|
{
|
|
string message = _webSocket.GetPacket().GetStringFromUtf8();
|
|
HandleServerMessage(message);
|
|
}
|
|
}
|
|
else if (state == WebSocketPeer.State.Connecting)
|
|
{
|
|
// Do nothing
|
|
}
|
|
else if (state == WebSocketPeer.State.Closing)
|
|
{
|
|
// Do nothing
|
|
}
|
|
else if (state == WebSocketPeer.State.Closed)
|
|
{
|
|
if (_connecting)
|
|
{
|
|
_connecting = false;
|
|
OnWsConnectionFailed?.Invoke();
|
|
}
|
|
else if (_connected)
|
|
{
|
|
_connected = false;
|
|
StopGameListRefreshLoop();
|
|
var code = _webSocket.GetCloseCode();
|
|
var reason = _webSocket.GetCloseReason();
|
|
GD.PrintErr("WebSocket closed with code: " + code + ", reason " + reason + ". Clean: " + (code != -1));
|
|
OnWsDisconnect?.Invoke();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Player commands
|
|
public void SendConnect(string clientId)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(clientId))
|
|
{
|
|
GD.PrintErr("Client ID is required to CONNECT.");
|
|
return;
|
|
}
|
|
|
|
clientId = clientId.Trim();
|
|
|
|
if (clientId.Contains(":"))
|
|
{
|
|
GD.PrintErr("Client ID cannot contain ':' characters.");
|
|
return;
|
|
}
|
|
|
|
SendCommand("CONNECT", clientId);
|
|
}
|
|
|
|
public void SendReady()
|
|
{
|
|
SendCommand("READY");
|
|
}
|
|
|
|
public void SendPlay(int column)
|
|
{
|
|
SendCommand("PLAY", column.ToString());
|
|
}
|
|
|
|
// Observer commands
|
|
public void UpdateGameList()
|
|
{
|
|
SendCommand("GAME", "LIST");
|
|
}
|
|
|
|
private void StartGameListRefreshLoop()
|
|
{
|
|
if (_gameListThreadRunning)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_gameListThreadRunning = true;
|
|
_gameListThread = new Thread(() =>
|
|
{
|
|
while (_gameListThreadRunning)
|
|
{
|
|
if (IsSocketOpen)
|
|
{
|
|
UpdateGameList();
|
|
UpdatePlayerList();
|
|
}
|
|
|
|
Thread.Sleep(TimeSpan.FromSeconds(5));
|
|
}
|
|
})
|
|
{
|
|
IsBackground = true
|
|
};
|
|
_gameListThread.Start();
|
|
}
|
|
|
|
private void StopGameListRefreshLoop()
|
|
{
|
|
if (!_gameListThreadRunning)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_gameListThreadRunning = false;
|
|
_gameListThread?.Join();
|
|
_gameListThread = null;
|
|
}
|
|
|
|
public void UpdatePlayerList()
|
|
{
|
|
SendCommand("PLAYER", "LIST");
|
|
}
|
|
|
|
public void SendWatchGame(int matchID)
|
|
{
|
|
SendCommand("GAME", "WATCH:" + matchID);
|
|
}
|
|
|
|
public void AdminAuth(string password)
|
|
{
|
|
if (IsAdmin) return;
|
|
SendCommand("ADMIN", "AUTH:" + password);
|
|
}
|
|
|
|
|
|
// Admin commands
|
|
public void KickPlayer(string playerId)
|
|
{
|
|
if (!IsAdmin) return;
|
|
SendCommand("ADMIN", "KICK:" + playerId);
|
|
}
|
|
|
|
public void StartTournament()
|
|
{
|
|
if (!IsAdmin) return;
|
|
SendCommand("TOURNAMENT", "START");
|
|
}
|
|
|
|
public void CancelTournament()
|
|
{
|
|
if (!IsAdmin) return;
|
|
SendCommand("TOURNAMENT", "CANCEL");
|
|
}
|
|
|
|
public void TerminateGame(int matchID)
|
|
{
|
|
if (!IsAdmin) return;
|
|
SendCommand("GAME", "TERMINATE:" + matchID);
|
|
}
|
|
|
|
public void SetTournamentWait(float waitTime)
|
|
{
|
|
if (!IsAdmin) return;
|
|
CurrentWaitTimeout = waitTime;
|
|
SendCommand("TOURNAMENT", "WAIT:" + waitTime);
|
|
}
|
|
|
|
private void SendCommand(string header, string body = "")
|
|
{
|
|
if (!IsSocketOpen)
|
|
{
|
|
GD.PrintErr($"Cannot send {header}, socket is not open.");
|
|
return;
|
|
}
|
|
|
|
string payload = string.IsNullOrEmpty(body) ? header : $"{header}:{body}";
|
|
_webSocket.SendText(payload);
|
|
}
|
|
|
|
private void HandleServerMessage(string message)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(message))
|
|
{
|
|
return;
|
|
}
|
|
|
|
message = message.Trim();
|
|
|
|
string header;
|
|
string body;
|
|
int separatorIndex = message.IndexOf(':');
|
|
if (separatorIndex >= 0)
|
|
{
|
|
header = message.Substring(0, separatorIndex).Trim();
|
|
body = message.Substring(separatorIndex + 1).Trim();
|
|
}
|
|
else
|
|
{
|
|
header = message.Trim();
|
|
body = string.Empty;
|
|
}
|
|
|
|
header = header.ToUpperInvariant();
|
|
|
|
switch (header)
|
|
{
|
|
case "CONNECT":
|
|
if (body.Equals("ACK", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
IsPlayer = true;
|
|
OnConnected?.Invoke();
|
|
}
|
|
|
|
break;
|
|
case "READY":
|
|
if (body.Equals("ACK", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
OnReadyAcknowledged?.Invoke();
|
|
}
|
|
|
|
break;
|
|
case "GAME":
|
|
HandleGameMessage(body);
|
|
break;
|
|
case "PLAYER":
|
|
HandlePlayerList(body);
|
|
break;
|
|
case "OPPONENT":
|
|
if (int.TryParse(body, out int column))
|
|
{
|
|
OnOpponentMove?.Invoke(column);
|
|
}
|
|
else
|
|
{
|
|
GD.PrintErr($"Invalid opponent column: {body}");
|
|
}
|
|
|
|
break;
|
|
case "ADMIN":
|
|
if (body == "AUTH:ACK")
|
|
{
|
|
IsAdmin = true;
|
|
SetTournamentWait(5.0f);
|
|
OnBecomeAdmin?.Invoke();
|
|
}
|
|
|
|
break;
|
|
case "TOURNAMENT":
|
|
HandleTournamentMessage(body);
|
|
break;
|
|
case "ERROR":
|
|
GD.PrintErr(message);
|
|
OnError?.Invoke(message);
|
|
break;
|
|
default:
|
|
GD.Print($"Unhandled server message: {message}");
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void HandleTournamentMessage(string body)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(body))
|
|
{
|
|
return;
|
|
}
|
|
|
|
string[] segments = body.Split(':');
|
|
string command = segments[0].Trim().ToUpperInvariant();
|
|
string argument = segments.Length > 1 ? segments[1].Trim() : string.Empty;
|
|
|
|
switch (command)
|
|
{
|
|
case "END":
|
|
{
|
|
ActiveTournament = false;
|
|
List<(string, int)> playerScoreboard = new List<(string, int)>();
|
|
string[] entries = segments[1].Split("|");
|
|
foreach (string entry in entries)
|
|
{
|
|
string[] data = entry.Split(',');
|
|
playerScoreboard.Add((data[0], int.Parse(data[1])));
|
|
}
|
|
|
|
OnTournamentEnd?.Invoke(playerScoreboard);
|
|
break;
|
|
}
|
|
case "START":
|
|
{
|
|
OnStartTournamentAck?.Invoke();
|
|
ActiveTournament = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void HandlePlayerList(string body)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(body))
|
|
{
|
|
return;
|
|
}
|
|
|
|
string[] segments = body.Split(':');
|
|
string command = segments[0].Trim().ToUpperInvariant();
|
|
string argument = segments.Length > 1 ? segments[1].Trim() : string.Empty;
|
|
|
|
switch (command)
|
|
{
|
|
case "LIST":
|
|
{
|
|
List<PlayerData> players = new List<PlayerData>();
|
|
|
|
if (segments.Length < 2)
|
|
{
|
|
OnUpdatedPlayers?.Invoke(players);
|
|
break;
|
|
}
|
|
|
|
string[] entries = segments[1].Split("|");
|
|
foreach (string entry in entries)
|
|
{
|
|
string[] data = entry.Split(',');
|
|
players.Add(new PlayerData(data[0], bool.Parse(data[1]), bool.Parse(data[2])));
|
|
}
|
|
|
|
OnUpdatedPlayers?.Invoke(players);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void HandleGameMessage(string body)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(body))
|
|
{
|
|
return;
|
|
}
|
|
|
|
string[] segments = body.Split(':');
|
|
string command = segments[0].Trim().ToUpperInvariant();
|
|
string argument = segments.Length > 1 ? segments[1].Trim() : string.Empty;
|
|
|
|
if (IsPlayer)
|
|
{
|
|
switch (command)
|
|
{
|
|
case "START":
|
|
bool isFirst = argument == "1" || argument.Equals("TRUE", StringComparison.OrdinalIgnoreCase);
|
|
OnGameStart?.Invoke(isFirst);
|
|
break;
|
|
case "WINS":
|
|
OnGameWin?.Invoke();
|
|
break;
|
|
case "LOSS":
|
|
OnGameLoss?.Invoke();
|
|
break;
|
|
case "DRAW":
|
|
OnGameDraw?.Invoke();
|
|
break;
|
|
case "TERMINATED":
|
|
OnGameTerminated?.Invoke();
|
|
break;
|
|
default:
|
|
GD.Print($"Unhandled GAME message: {body}");
|
|
break;
|
|
}
|
|
}
|
|
else // Regular observer/admin
|
|
{
|
|
switch (command)
|
|
{
|
|
case "WIN":
|
|
OnObserveWin?.Invoke(segments[1]);
|
|
break;
|
|
case "MOVE":
|
|
OnObserveMove?.Invoke(segments[1], int.Parse(segments[2]));
|
|
break;
|
|
case "DRAW":
|
|
OnObserveDraw?.Invoke();
|
|
break;
|
|
case "TERMINATED":
|
|
OnObserveTerminated?.Invoke();
|
|
break;
|
|
case "LIST":
|
|
List<MatchData> matches = new List<MatchData>();
|
|
|
|
if (segments.Length < 2)
|
|
{
|
|
OnUpdatedMatches?.Invoke(matches);
|
|
break;
|
|
}
|
|
|
|
string[] entries = segments[1].Split("|");
|
|
foreach (string entry in entries)
|
|
{
|
|
string[] data = entry.Split(',');
|
|
matches.Add(new MatchData(int.Parse(data[0]), data[1], data[2]));
|
|
}
|
|
|
|
OnUpdatedMatches?.Invoke(matches);
|
|
break;
|
|
case "WATCH":
|
|
CurrentObservingMatch = null;
|
|
PreviousMoves.Clear();
|
|
string[] activeMatchData = segments[2].Split("|");
|
|
if (activeMatchData.IsEmpty())
|
|
{
|
|
string[] matchData = segments[2].Split(',');
|
|
CurrentObservingMatch = new MatchData(int.Parse(matchData[0]), matchData[1], matchData[2]);
|
|
}
|
|
else
|
|
{
|
|
string[] matchData = activeMatchData[0].Split(',');
|
|
CurrentObservingMatch = new MatchData(int.Parse(matchData[0]), matchData[1], matchData[2]);
|
|
for (int i = 1; i < activeMatchData.Length; i++)
|
|
{
|
|
string[] moveData = activeMatchData[i].Split(',');
|
|
PreviousMoves.Add((moveData[0], int.Parse(moveData[1])));
|
|
}
|
|
}
|
|
OnWatchGameAck?.Invoke();
|
|
break;
|
|
default:
|
|
GD.Print($"Unhandled GAME message: {body}");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|