static async Task Main(string[] args)
{
client = new TcpClient();
await client.ConnectAsync(IPAddress.Loopback, serverPort);
NetworkStream stream = client.GetStream();
StreamReader reader = new StreamReader(stream);
StreamWriter writer = new StreamWriter(stream);
Console.WriteLine("User start");
while (play)
{
bool run = true;
var stones = 0;
var max_step = 0;
var stones_s = "";
var max_step_s = "";
Console.Write("Enter the number of stones: ");
stones_s = Console.ReadLine();
Console.Write("Enter max step: ");
max_step_s = Console.ReadLine();
do
{
if (int.TryParse(stones_s, out stones) && int.TryParse(max_step_s, out max_step) && (max_step > 0) && (stones > 0))
{
message = stones_s + ' ' + max_step_s;
}
else
{
Console.WriteLine("Input correct numbers");
}
} while ((stones == 0) && (max_step == 0));
await writer.WriteLineAsync(message);
await writer.FlushAsync();
string answer = await reader.ReadLineAsync();
Console.WriteLine(answer);
while (run)
{
var step_s = "";
var step = 0;
do
{
Console.Write("Enter your step: ");
step_s = Console.ReadLine();
if (int.TryParse(step_s, out step) && (step > 0) && (step <= max_step))
{
Console.WriteLine("OK");
}
else
{
Console.WriteLine("Uncorrect step");
}
} while (!(int.TryParse(step_s, out step) && (step > 0) && (step <= max_step)));
await writer.WriteLineAsync(step_s);
await writer.FlushAsync();
answer = await reader.ReadLineAsync();
if ((answer == "I am winner, ha-ha!") || (answer == "You are winner!"))
{
run = false;
}
Console.WriteLine(answer);
}
Console.WriteLine("Want to play again? any character or no");
if (Console.ReadLine() == "no")
{
play = false;
}
}
client.Close();
}
public Task Connect(string ip, ushort port) => client.ConnectAsync(ip, port);
/**
* Send a server request and display the response.
*/
static async Task SendRequestAndReceiveResponseAsync(string server, RequestPayload payload)
{
/**
* Create a TcpClient socket in order to connectto the echo server.
*/
using (TcpClient connection = new TcpClient())
{
try
{
// Start a stop watch timer
Stopwatch sw = Stopwatch.StartNew();
// connect socket to the echo server.
await connection.ConnectAsync(server, SERVER_PORT);
// Create and fill the Request with "payload" as Payload
Request request = new Request
{
Method = payload.Method,
Path = payload.Text,
Headers = new Dictionary <String, String>(),
Payload = (JObject)JToken.FromObject(payload),
};
// Add some headers for test purposes
request.Headers.Add("agent", "json-client");
request.Headers.Add("timeout", "10000");
/**
* Translate the message to JSON and send it to the echo server.
*/
JsonTextWriter writer = new JsonTextWriter(new StreamWriter(connection.GetStream()));
serializer.Serialize(writer, request);
Console.WriteLine($"-->{payload.ToString()}");
await writer.FlushAsync();
/**
* Receive the server's response and display it.
*/
JsonTextReader reader = new JsonTextReader(new StreamReader(connection.GetStream()))
{
// To support reading multiple top-level objects
SupportMultipleContent = true
};
try
{
// to consume any bytes until start of object ('{')
do
{
await reader.ReadAsync();
} while (reader.TokenType != JsonToken.StartObject &&
reader.TokenType != JsonToken.None);
if (reader.TokenType == JsonToken.None)
{
Console.WriteLine("***error: reached end of input stream, ending.");
return;
}
/**
* Read response JSON object
*/
JObject jresponse = await JObject.LoadAsync(reader);
sw.Stop();
/**
* Back to the .NET world
*/
Response response = jresponse.ToObject <Response>();
RequestPayload recoveredPayload = response.Payload.ToObject <RequestPayload>();
Console.WriteLine($"<--{response.ToString()}, elapsed: {sw.ElapsedMilliseconds} ms");
}
catch (JsonReaderException jre)
{
Console.WriteLine($"***error: error reading JSON: {jre.Message}");
}
catch (Exception e)
{
Console.WriteLine($"-***error: exception: {e}");
}
sw.Stop();
Interlocked.Increment(ref requestCount);
}
catch (Exception ex)
{
Console.WriteLine($"--***error:[{payload}] {ex.Message}");
}
}
}
public async Task ConnectAsync()
{
await _tcpClient.ConnectAsync(_ipAddress, _port);
_stream = _tcpClient.GetStream();
}
public static async Task PlayGameAsync(ClientID clientId, LoginToLobbyResponseMessage gameserver, Func <Task <string> > GetChatMessage)
{
#region Establish TCP connection
var client = new TcpClient();
await client.ConnectAsync(
address : gameserver.GameServer.Address,
port : gameserver.GameServer.Port);
var server = client.Client;
#endregion
#region Send the port number to the proxy.
await server.WriteAsync(gameserver.InnergameServerPort);
#endregion
await server.WriteCommandAsync(new LoginToGameServerRequest(gameserver.Token));
var receiveTask = Task.Factory.StartNew(async() =>
{
while (true)
{
var someGameMessage = await server.ReadCommandOrErrorAsync <SomeGameMessage>();
if (someGameMessage.IsError)
{
Console.WriteLine("Error {0}", someGameMessage.ErrorMessage);
}
else
{
Console.WriteLine("Received \"{0}\" from {1}", someGameMessage.Message.Stuff, someGameMessage.Message.From.ID);
}
}
}).Unwrap();
var senderTask = Task.Factory.StartNew(async() =>
{
while (true)
{
try
{
var content = await GetChatMessage();
await server.WriteCommandAsync(new SomeGameMessage {
Stuff = content, From = new ClientID {
ID = Guid.Empty
}
});
Console.WriteLine("Client {0} sending message {1}", clientId.ID, content);
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.Message);
}
}
}).Unwrap();
await Task.WhenAll(receiveTask, senderTask);
client.Close();
}
public async Task StartAsync()
{
await _client.ConnectAsync(IPAddress.Parse(Config.ServerIPAddress), Config.ServerPortNumber);
await Task.Run(() => MessageHandler.ReceiveMessage(_client, ProcessServerMessage));
}
