schreinerma97192/WerWolfInteraktion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request 'Implemented Corrections during integration tests' (#1) from aioptimize into master

Browse Source 
Reviewed-on: #1
This commit is contained in:
Maurice Schreiner 2026-06-30 09:41:46 +00:00
commit 77ee05338f
3 changed files with 293 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
Game.cs
View File

@ -112,9 +112,11 @@ namespace Wolf
logger.Log($"Spieler {p.Name} wacht auf und sieht sich seine Rolle an.");
ttsClient.Read(logger.getLastLine(), readHistory);
ShowRole(p);
Task.Delay(5000).Wait();
logger.Log($"Spieler {p.Name} hat seine Rolle gesehen und geht wieder schlafen.");
ttsClient.Read(logger.getLastLine(), readHistory);
getConfirmationEveryoneAsleep();
}
Console.Clear();
@ -360,46 +362,73 @@ namespace Wolf
{
try
{
int res = logicClient.GetPlayerId(targets, pois).WaitAsync(TimeSpan.FromSeconds(10)).Result;
int res = logicClient.GetPlayerId(targets, pois).WaitAsync(TimeSpan.FromSeconds(30)).Result;
if (res >= 0)
{
return res;
}
}
catch
{
logger.Log("GetPlayerId returned invalid value, defaulting to 0");
return 0;
}
catch (TimeoutException)
{
logger.Log("GetPlayerId timed out after 30 seconds");
return 0;
}
catch (Exception ex)
{
logger.Log($"GetPlayerId error: {ex.Message}");
return 0;
}
return 0;
}
public bool getConfirmation(List<Player> players)
{
try
{
bool res = logicClient.GetConfirmation(players).WaitAsync(TimeSpan.FromSeconds(10)).Result;
if (res)
{
return true;
}
bool res = logicClient.GetConfirmation(players).WaitAsync(TimeSpan.FromSeconds(30)).Result;
return res;
}
catch
catch (TimeoutException)
{
logger.Log("GetConfirmation timed out after 30 seconds, defaulting to false");
return false;
}
catch (Exception ex)
{
logger.Log($"GetConfirmation error: {ex.Message}");
return false;
}
return false;
}
public bool getConfirmationEveryoneAsleep()
{
try
int maxRetries = 50;
int attempt = 0;
while (attempt < maxRetries)
{
return logicClient.GetConfirmationEveryoneAsleep().WaitAsync(TimeSpan.FromSeconds(30)).Result;
}
catch
{
return false;
attempt++;
try
{
bool result = logicClient.GetConfirmationEveryoneAsleep().WaitAsync(TimeSpan.FromSeconds(60)).Result;
if (result)
{
return true;
}
logger.Log($"GetConfirmationEveryoneAsleep returned false on attempt {attempt}, retrying...");
}
catch (TimeoutException)
{
logger.Log($"GetConfirmationEveryoneAsleep timed out on attempt {attempt}/{maxRetries}, retrying...");
}
catch (Exception ex)
{
logger.Log($"GetConfirmationEveryoneAsleep error on attempt {attempt}/{maxRetries}: {ex.Message}, retrying...");
}
}
logger.Log($"GetConfirmationEveryoneAsleep failed after {maxRetries} attempts, defaulting to false");
return false;
}
}

364
OSCClient.cs
View File

@ -8,65 +8,103 @@ using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
namespace Wolf
{
internal class OSCClient
{
UdpClient udpClientSend;
UdpClient udpClientReceive;
private UdpClient udpClientSend;
private UdpClient udpClientReceive;
private readonly SemaphoreSlim _requestSemaphore;
private string _lastSentAddress = "";
private object[] _lastSentArguments = Array.Empty<object>();
public OSCClient(string hostname, int port)
{
// 1. Lokalen Port binden (für Empfang)
udpClientSend = new UdpClient(hostname, port);
udpClientReceive = new UdpClient(new IPEndPoint(IPAddress.Any, port));
_requestSemaphore = new SemaphoreSlim(1, 1);
}
public async Task SendMessage(string endpoint)
{
var message = new OscMessage(new Address(endpoint));
await udpClientSend.SendMessageAsync(message);
await _requestSemaphore.WaitAsync();
try
{
var message = new OscMessage(new Address(endpoint));
_lastSentAddress = endpoint;
_lastSentArguments = Array.Empty<object>();
await udpClientSend.SendMessageAsync(message);
}
finally
{
_requestSemaphore.Release();
}
}
public async Task SpeakId(int textId)
{
var message = new OscMessage(
address: new Address("/speak"),
arguments: new object[]
{
textId
});
await udpClientSend.SendMessageAsync(message);
await _requestSemaphore.WaitAsync();
try
{
var message = new OscMessage(
address: new Address("/speak"),
arguments: new object[]
{
textId
});
_lastSentAddress = "/speak";
_lastSentArguments = new object[] { textId };
await udpClientSend.SendMessageAsync(message);
}
finally
{
_requestSemaphore.Release();
}
}
public async Task Read(string text, bool readStory = true)
{
string endpoint = readStory ? "/read_story" : "/read";
var message = new OscMessage(
address: new Address(endpoint),
arguments: new object[]
{
text, 2
});
await udpClientSend.SendMessageAsync(message);
await _requestSemaphore.WaitAsync();
try
{
string endpoint = readStory ? "/read_story" : "/read";
var message = new OscMessage(
address: new Address(endpoint),
arguments: new object[]
{
text, 2
});
_lastSentAddress = endpoint;
_lastSentArguments = new object[] { text, 2 };
await udpClientSend.SendMessageAsync(message);
}
finally
{
_requestSemaphore.Release();
}
}
public async Task SendMessageWithArguments(string endpoint, params object[] param)
{
var message = new OscMessage(
address: new Address(endpoint),
arguments: param
);
await udpClientSend.SendMessageAsync(message);
await _requestSemaphore.WaitAsync();
try
{
var message = new OscMessage(
address: new Address(endpoint),
arguments: param
);
_lastSentAddress = endpoint;
_lastSentArguments = param;
await udpClientSend.SendMessageAsync(message);
}
finally
{
_requestSemaphore.Release();
}
}
@ -100,20 +138,101 @@ namespace Wolf
}
}
/// <summary>
/// Generische Methode zur Ausführung von Request-Response-Kommunikation mit Retry-Logik.
/// </summary>
private async Task<T> ExecuteRequestWithRetry<T>(
string expectedAddress,
OscMessage requestMessage,
Func<OscMessage, T> responseParser,
int maxRetries = 50,
int timeoutSeconds = 20)
{
await _requestSemaphore.WaitAsync();
try
{
_lastSentAddress = requestMessage.Address.Value;
_lastSentArguments = requestMessage.Arguments.ToArray();
for (int attempt = 1; attempt <= maxRetries; attempt++)
{
try
{
// Anfrage senden
await udpClientSend.SendMessageAsync(requestMessage);
// Auf Response warten mit Timeout
var receiveTask = udpClientReceive.ReceiveMessageAsync();
var timeoutTask = Task.Delay(TimeSpan.FromSeconds(timeoutSeconds));
var completed = await Task.WhenAny(receiveTask, timeoutTask);
if (completed == receiveTask)
{
var response = await receiveTask;
// Prüfen, ob es die erwartete Antwort ist
if (response.Address.Value == expectedAddress)
{
try
{
return responseParser(response);
}
catch (Exception parseEx)
{
// Argument-Parsing-Fehler, ignorieren und nächste Anfrage senden
System.Diagnostics.Debug.WriteLine($"Parse error on attempt {attempt}: {parseEx.Message}");
continue;
}
}
// Falsche Antwort → ignorieren und weiter versuchen
}
// Timeout → erneut versuchen
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"Request attempt {attempt} failed: {ex.Message}");
}
}
// Alle Versuche fehlgeschlagen
throw new TimeoutException($"Request to {expectedAddress} failed after {maxRetries} attempts");
}
finally
{
_requestSemaphore.Release();
}
}
public async Task<List<int>> GetAllIds()
{
SendMessage("/getAllIds");
var response = await udpClientReceive.ReceiveMessageAsync();
if (response.Address.Value == "/getAllIds")
var message = new OscMessage(new Address("/getAllIds"));
try
{
List<int> playerIds = new List<int>();
foreach (var argument in response.Arguments)
{
playerIds.Add((int)argument);
}
return playerIds;
var result = await ExecuteRequestWithRetry(
expectedAddress: "/getAllIds",
requestMessage: message,
responseParser: response =>
{
var playerIds = new List<int>();
foreach (var argument in response.Arguments)
{
playerIds.Add((int)argument);
}
return playerIds;
});
return result;
}
catch (TimeoutException)
{
return new List<int>();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"GetAllIds error: {ex.Message}");
return new List<int>();
}
return new List<int>();
}
// < 0 = no confirmation; 0 = confirm; > 0 = player id
@ -139,7 +258,6 @@ namespace Wolf
public async Task<int> GetPlayerId(List<Player> targets, List<Player> pois)
{
//return (int) targets.FirstOrDefault().id;
// Arrays extrahieren
var arr2 = targets.Select(p => p.id).ToArray();
var arr1 = pois.Select(p => p.id).ToArray();
@ -156,121 +274,117 @@ namespace Wolf
foreach (var id in arr2)
args.Add(id);
// Nachricht senden
// Nachricht vorbereiten
var message = new OscMessage(
new Address("/getPlayerID"),
args.ToArray()
);
int maxRetries = 50;
int timeoutSeconds = 20;
// Anfrage senden
await udpClientSend.SendMessageAsync(message);
for (int attempt = 1; attempt <= maxRetries; attempt++)
try
{
// Timeout für Receive
var receiveTask = udpClientReceive.ReceiveMessageAsync();
var timeoutTask = Task.Delay(TimeSpan.FromSeconds(timeoutSeconds));
var completed = await Task.WhenAny(receiveTask, timeoutTask);
if (completed == receiveTask)
{
var response = await receiveTask;
// Prüfen, ob es die erwartete Antwort ist
if (response.Address.Value == "/getPlayerID")
var result = await ExecuteRequestWithRetry(
expectedAddress: "/getPlayerID",
requestMessage: message,
responseParser: response =>
{
return (int)response.Arguments.ElementAt(0);
}
// Falsche Antwort → ignorieren und weiter versuchen
continue;
}
await udpClientSend.SendMessageAsync(message);
if (response.Arguments.Count() > 0)
{
return (int)response.Arguments.ElementAt(0);
}
throw new InvalidOperationException("No arguments in response");
},
maxRetries: 50,
timeoutSeconds: 20);
return result;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"GetPlayerId error: {ex.Message}");
return -1;
}
return -1;
}
public async Task<bool> GetConfirmation(List<Player> players)
{
int maxRetries = 50;
int timeoutSeconds = 20;
var args = new List<object>();
foreach (var p in players)
{
args.Add(p.id);
}
// Anfrage senden
var message = new OscMessage(
new Address("/confirmation"),
args.ToArray()
new Address("/confirmation"),
args.ToArray()
);
await udpClientSend.SendMessageAsync(message);
//await udpClientReceive.ReceiveMessageAsync();
for (int attempt = 1; attempt <= maxRetries; attempt++)
try
{
// Timeout für Receive
var receiveTask = udpClientReceive.ReceiveMessageAsync();
var timeoutTask = Task.Delay(TimeSpan.FromSeconds(timeoutSeconds));
var completed = await Task.WhenAny(receiveTask, timeoutTask);
if (completed == receiveTask)
{
var response = await receiveTask;
// Prüfen, ob es die erwartete Antwort ist
if (response.Address.Value == "/confirmation")
var result = await ExecuteRequestWithRetry(
expectedAddress: "/confirmation",
requestMessage: message,
responseParser: response =>
{
if (response.Arguments.ElementAt(0) is OscFalse)
if (response.Arguments.Count() > 0)
{
return false;
var firstArg = response.Arguments.ElementAt(0);
if (firstArg is OscFalse)
{
return false;
}
if (firstArg is OscTrue)
{
return true;
}
throw new InvalidOperationException($"Unexpected argument type: {firstArg.GetType().Name}");
}
if (response.Arguments.ElementAt(0) is OscTrue)
{
return true;
}
}
// Falsche Antwort → ignorieren und weiter versuchen
continue;
}
await udpClientSend.SendMessageAsync(message);
throw new InvalidOperationException("No arguments in response");
},
maxRetries: 50,
timeoutSeconds: 20);
return result;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"GetConfirmation error: {ex.Message}");
return false;
}
return false;
}
public async Task<bool> GetConfirmationEveryoneAsleep()
{
return true;
SendMessage("/everyoneAsleep");
var message = new OscMessage(new Address("/everyoneAsleep"));
var response = await udpClientReceive.ReceiveMessageAsync();
if (response.Address.Value == "/everyoneAsleep")
try
{
if (response.Arguments.ElementAt(0) is OscFalse)
{
return false;
}
if (response.Arguments.ElementAt(0) is OscTrue)
{
return true;
}
var result = await ExecuteRequestWithRetry(
expectedAddress: "/everyoneAsleep",
requestMessage: message,
responseParser: response =>
{
if (response.Arguments.Count() > 0)
{
var firstArg = response.Arguments.ElementAt(0);
if (firstArg is OscFalse)
{
return false;
}
if (firstArg is OscTrue)
{
return true;
}
throw new InvalidOperationException($"Unexpected argument type: {firstArg.GetType().Name}");
}
throw new InvalidOperationException("No arguments in response");
},
maxRetries: 50,
timeoutSeconds: 30);
return result;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"GetConfirmationEveryoneAsleep error: {ex.Message}");
return false;
}
return false;
}
}
}

11
Program.cs
View File

@ -11,17 +11,20 @@ namespace Wolf
{
//OSCClient logicClient = new OSCClient("127.0.0.1", 9000);
OSCClient logicClient = new OSCClient("100.81.182.220", 9000);
OSCClient ttsClient = new OSCClient("100.81.196.62", 9001);
OSCClient logicClient = new OSCClient("100.83.197.1", 9000);
OSCClient ttsClient = new OSCClient("100.83.246.218", 9001);
//await logicClient.SendMessageWithArguments("/test", "HILFE!!! . . Rettet mich aus diesem Laptop!!! . . . Ich bin eingesperrt!!!!!");
//logicClient.ReceiveMessageWithoutArguments().Wait();
//List<int> ids = await logicClient.GetAllIds();
List<int> ids = await logicClient.GetAllIds();
ids.Add(71);
ids.Add(72);
ids.Add(73);
Game game = new Game(logicClient, ttsClient, new Logger());
List<int> ids = new List<int>{ 31, 27, 71, 72, 73, 74};
//List<int> ids = new List<int>{ 31, 27, 71, 72, 73, 74};
foreach (int id in ids)
{