void SelectShip()
{
loading.transform.localScale = Vector3.one;
ClientListener.SendDataTCP($"selectship?idx={ship}");
ClientListener.SendDataTCP("reqmyshipdata?");
StartCoroutine(AwaitShipData());
}
/// <summary>
/// Removes a listener from the LightstreamerClient instance so that it will not receive events anymore.
///
/// <b>Lifecycle:</b> a listener can be removed at any time.
/// </summary>
/// <param name="listener"> The listener to be removed.
/// </param>
/// <seealso cref="addListener" />
public virtual void removeListener(ClientListener listener)
{
lock (this)
{
this.dispatcher.removeListener(listener, new ClientListenerEndEvent(this));
}
}
public MqttClient(DBInterface _interface, DnsEndPoint address, Boolean isWS, String username, String password, String clientID, Boolean isClean, int keepalive, Will will, Boolean isSecured, String certificate, String certificatePassword, ClientListener listener)
{
this._dbInterface = _interface;
this._address = address;
this._isWs = isWS;
this._username = username;
this._password = password;
this._clientID = clientID;
this._isClean = isClean;
this._keepalive = keepalive;
this._will = will;
this.isSecured = isSecured;
this.certificate = certificate;
this.certificatePassword = certificatePassword;
this._listener = listener;
if (this._isWs)
{
_client = new WSClient(address, isSecured, certificate, certificatePassword, WORKER_THREADS);
}
else
{
_client = new TCPClient(address, isSecured, certificate, certificatePassword, WORKER_THREADS);
}
}
private void Form1_Load(object sender, EventArgs e)
{
packetProcessor.Build();
ClientListener l = new ClientListener(9000);
l.Listen(100);
}
public ClientThread()
{
ConfigManager = new Config.Manager();
ClientListener = new ClientListener();
Manager = new ClientManager(ClientListener, "teamscreen");
ClientListener.SetManager(Manager);
}
public void setClientListener(ClientListener listener)
{
this.clientListener = listener;
int indexOfThisClient = Array.IndexOf(connectedPlayerIps, this.ipAddress);
this.clientListener.connectedPlayerIpsDidChange(this.connectedPlayerIps, indexOfThisClient);
}
static void Main(string[] args)
{
// Set working directory to application directory.
// Otherwise Windows/System32 is used.
Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
try
{
XmlConfigurator.Configure();
Console.WriteLine("Loaded app.config");
}
catch (Exception)
{
Console.WriteLine("Error: configuration file not found.");
throw;
}
try
{
MessageDispatcher md = new MessageDispatcher();
md.RegisterHandlers(new Program());
ClientListener server = new ClientListener(3333, new SocketListener(), md);
server.Start();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void OnJoinGameResult(object sender, ClientListener <JoinGameMessage> .TArg e)
{
//Получение позиции игрока в игре
uint?myPlayerPosition = e.Arg.MyPosition;
//Проверка позиции игрока
if (myPlayerPosition == null)
{
//Если присоединение не удалось, то разрываем соединение
OnJoin?.Invoke(null);
tcpClient.Dispose();
return;
}
//Если присоединение успешно
OnJoin?.Invoke(e.Arg);
//Если есть противник, то начинаем игру
if (e.Arg.EnemyName != null)
{
joinGameListener.Stop();
OnStart?.Invoke();
playGameListener.Start();
}
}
public void RemoveClientListener(ClientListener <K, V> cl)
{
stopAndRemoveTask(cl.listenerId);
VectorByte vb = new VectorByte(cl.listenerId);
cache.removeClientListener(vb);
}
/// <summary>
/// Adds a listener that will receive events from the LightstreamerClient instance.
/// The same listener can be added to several different LightstreamerClient instances.<br/>
///
/// <b>Lifecycle:</b> A listener can be added at any time. A call to add a listener already
/// present will be ignored.
/// </summary>
/// <param name="listener"> An object that will receive the events as documented in the
/// ClientListener interface.
/// </param>
/// <seealso cref="removeListener" />
public virtual void addListener(ClientListener listener)
{
lock (this)
{
this.dispatcher.AddListener(listener, new ClientListenerStartEvent(this));
}
}
public async Task <T> ShowQrForAJsonResult <T>(string prefix, Task <string> qrUserContentJson) where T : class
{
using (var pcKey = CngKey.Create(CngAlgorithm.ECDiffieHellmanP384))
{
using (var comm = NewClientListener())
{
var qrBody = QrBuilder.BuildQrBody(comm, EncryptionUtils.EccPublicToPem(pcKey));
await _qrDisplayer.ShowQr(prefix, qrBody.ToArray());
using (var commStream = await comm.GetStream())
{
await _qrDisplayer.HideQr();
var aes256Key = ClientListener.CompleteEcdhFromStream(pcKey, commStream);
qrUserContentJson.Start();
var content = await qrUserContentJson;
if (content == null)
{
return(null);
}
ClientListener.SendEncrypted(Encoding.UTF8.GetBytes(content), aes256Key, commStream);
return(JsonConvert.DeserializeObject <T>(ClientListener.DecryptMessage(aes256Key, commStream)));
}
}
}
}
private void ListenClient()
{
client_listener = new ClientListener(this, ServerSettings.BindAddr, ServerSettings.BindPort, _logger);
client_listener.OnClientsChange += Client_listener_OnClientsChange;
client_listener.Start();
_logger.LogDebug($"监听客户端 -> {ServerSettings.BindAddr}:{ServerSettings.BindPort}");
}
public Server(ClientListener clientListener)
{
m_tcpListener = new TcpListener(IPAddress.Any, 3000);
var listenThread = new Thread(ListenForClients);
listenThread.Start();
m_clientListener = clientListener;
}
public InternalConnectionOptions(EventDispatcher <ClientListener> eventDispatcher, ClientListener internalListener)
{
this.eventDispatcher = eventDispatcher;
this.internalListener = internalListener;
if (TransportFactory <HttpProvider> .DefaultHttpFactory.ResponseBuffered)
{
this.contentLength = 4_000_000;
}
}
void SendDataToServer()
{
times = 150;
ClientListener.SendDataUDP($"usp?i={transform.name}" +
$"&p={Message.ParseVector3(transform.position)}" +
$"&r={Message.ParseVector3(transform.eulerAngles)}" +
$"&v={Message.ParseVector3(_rigidbody.velocity)}" +
$"&av={Message.ParseVector3(_rigidbody.angularVelocity)}");
}
public LoginServerApp()
{
this.eventAggregator = new EventAggregator();
this.clientListener = new ClientListener(IPAddress.Any, 8112);
this.clientListener.ClientConnected += OnClientConnected;
logger.Info("Server created on {0}:{1}.", this.clientListener.EndPoint.Address, this.clientListener.EndPoint.Port);
}
private void buttonStart_Click(object sender, EventArgs e)
{
ClientListener listener;
listener = new ClientListener(new IPEndPoint(GetLocalInternalIP(), UInt16.Parse(textBoxLocalPort.Text)), new IPEndPoint(IPAddress.Parse(textBoxRemoteIp.Text), UInt16.Parse(textBoxPort.Text)), ProxyMode);
Listener.OnGotResultsCbk onGotRes = new Listener.OnGotResultsCbk(OnGotResults);
listener.SetOnGotResults(onGotRes);
listenerList.Add(listener);
listener.Start();
}
public LightstreamerEngine(InternalConnectionOptions options, SessionThread sessionThread, EventsThread eventsThread, ClientListener listener, SessionManager manager)
{
this.connectionOptions = options;
this.sessionThread = sessionThread;
this.clientListener = listener;
this.eventsThread = eventsThread;
this.sessionManager = manager;
manager.SessionsListener = new SessionsListenerImpl(this);
}
public void CreateClientPort(string listenAddress, int listenPort, string connectAddress, int connectPort)
{
var listenIndex = ++ConnectionCount;
ForwardedPort forwardedPort = null;
var listener = new ClientListener
{
ListenResponse = response =>
{
forwardedPort = new ForwardedPort
{
Direction = ForwardDirection.Local,
ListenEndPoint = listenAddress + ":" + listenPort,
ConnectEndPoint = connectAddress + ":" + connectPort,
Remove = () =>
{
Log("Cancelling local port " + listenAddress + ":" + listenPort + " forwarding to " + connectAddress + ":" + connectPort + " requested");
WriteMessage(new StreamError(listenIndex, new EndOfStreamException()));
},
};
Log("Local port forwarding from " + listenAddress + ":" + listenPort + " enabled");
OnForwardedPortAdded(forwardedPort);
},
StreamError = error =>
{
if (forwardedPort == null)
{
Log("Local port forwarding from " + listenAddress + ":" + listenPort + " failed: " + error.Message);
lock (clientListeners)
{
if (clientListeners.ContainsKey(listenIndex))
{
clientListeners.Remove(listenIndex);
}
}
}
else
{
Log("Cancelled local port " + listenAddress + ":" + listenPort + " forwarding to " + connectAddress + ":" + connectPort);
OnForwardedPortRemoved(forwardedPort);
}
},
AcceptRequest = request =>
{
Log("Opening forwarded connection " + request.RemoteEndPoint + " to " + connectAddress + ":" + connectPort);
new ConnectRequest(request.StreamIndex, request.RemoteEndPoint, connectAddress, connectPort).Process(this);
},
};
lock (clientListeners)
{
clientListeners[listenIndex] = listener;
}
Log("Requesting local port " + listenAddress + ":" + listenPort + " forward to " + connectAddress + ":" + connectPort);
WriteMessage(new ListenRequest(listenIndex, listenAddress, listenPort));
}
void HUDEvent(string[] info)
{
Transform element = GameObject.Find(info[0]).transform;
string myEvent = info[1];
if (element.name == "Button_Quit" && myEvent == "mouseDown")
{
ClientListener.SendDataTCP("disconnect?");
Application.Quit();
}
}
public void Run()
{
TestPerformance();
//Server
_serverListener = new ServerListener();
NetManager server = new NetManager(_serverListener, 2, "myapp1");
if (!server.Start(9050))
{
Console.WriteLine("Server start failed");
Console.ReadKey();
return;
}
_serverListener.Server = server;
//Client
_clientListener = new ClientListener();
NetManager client = new NetManager(_clientListener, "myapp1");
client.MergeEnabled = true;
if (!client.Start())
{
Console.WriteLine("Client1 start failed");
return;
}
client.Connect("127.0.0.1", 9050);
while (!Console.KeyAvailable)
{
client.PollEvents();
server.PollEvents();
Thread.Sleep(15);
}
client.Stop();
server.Stop();
Console.ReadKey();
Console.WriteLine("ServStats:\n BytesReceived: {0}\n PacketsReceived: {1}\n BytesSent: {2}\n PacketsSent: {3}",
server.BytesReceived,
server.PacketsReceived,
server.BytesSent,
server.PacketsSent);
Console.WriteLine("ClientStats:\n BytesReceived: {0}\n PacketsReceived: {1}\n BytesSent: {2}\n PacketsSent: {3}",
client.BytesReceived,
client.PacketsReceived,
client.BytesSent,
client.PacketsSent);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
public void Run()
{
//Server
_serverListener = new ServerListener();
NetServer server = new NetServer(_serverListener, 2, "myapp1");
if (!server.Start(9050))
{
Console.WriteLine("Server start failed");
Console.ReadKey();
return;
}
_serverListener.Server = server;
//Client
_clientListener = new ClientListener();
NetClient client1 = new NetClient(_clientListener, "myapp1");
client1.SimulateLatency = true;
client1.SimulationMaxLatency = 1500;
if (!client1.Start())
{
Console.WriteLine("Client1 start failed");
return;
}
client1.Connect("127.0.0.1", 9050);
NetClient client2 = new NetClient(_clientListener, "myapp1");
client2.SimulateLatency = true;
client2.SimulationMaxLatency = 1500;
client2.Start();
client2.Connect("::1", 9050);
while (!Console.KeyAvailable)
{
client1.PollEvents();
client2.PollEvents();
server.PollEvents();
Thread.Sleep(15);
}
client1.Stop();
client2.Stop();
server.Stop();
Console.ReadKey();
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
internal void Connect(string playerName)
{
//Если уже подключен
if (tcpClient != null && tcpClient.Connected)
{
var args = new ResponseTypeArg
{
Type = ResponseType.ALREADY_CONNECTED
};
OnConnect?.Invoke(this, args);
return;
}
TcpClient client = new TcpClient();
tcpClient = client;
//Инициализация клиента - присоединение к игре:
joinGameListener = new ClientListener <JoinGameMessage>(client);
joinGameListener.OnMessageReceived += OnJoinGameResult;
//Инициализация клиента - игровой процесс:
playGameListener = new ClientListener <PlayGameMessage>(client);
playGameListener.OnMessageReceived += OnUpdateGameResult;
try
{
tcpClient.Connect(IPAddress.Loopback, 8080);
//Успешное подключение
if (tcpClient.Connected)
{
var args = new ResponseTypeArg
{
Type = ResponseType.SUCCESS
};
OnConnect?.Invoke(this, args);
//Присоединение к игре
JoinGame(playerName);
}
}
catch (SocketException)
{
var args = new ResponseTypeArg
{
Type = ResponseType.NO_CONNECTION
};
OnConnect?.Invoke(this, args);
}
}
public override void Initialize()
{
InitHandler();
var listener = new ClientListener(this);
mClient = new NetManager(listener);
//client.SimulateLatency = true;
mClient.UpdateTime = 15;
if (!mClient.Start())
{
Console.WriteLine("Client start failed");
}
isOnUpdate = true;
}
public PropertyBag(MineWorldClient gamein, GameStateManager gameManagerin)
{
Game = gamein;
GameManager = gameManagerin;
NetPeerConfiguration netconfig = new NetPeerConfiguration("MineWorld");
netconfig.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
Client = new NetClient(netconfig);
Client.Start();
Player = new Player(this);
WorldManager = new WorldManager(GameManager, Player);
ClientListener = new ClientListener(Client, this);
ClientSender = new ClientSender(Client, this);
Debugger = new Debug(this);
}
/// <summary>
/// Called when the ClientListener has quit.
/// </summary>
/// <param name="sender">The client listener that quit.</param>
private void ClientDisconnectedCallback(ClientListener sender)
{
clientsLock.AcquireWriterLock(Timeout.Infinite);
try
{
// Lib.Disco this connection just to be safe
//Lib.Disco(sender.UserSocket);
// Remove this client listener from the collection
connectedClients.Remove(sender);
}
finally
{
clientsLock.ReleaseLock();
}
}
public void TestCase()
{
// create a new client manager and register for
// its new-client event. we will check if we actually get
// the new client later on.
// finally start the manager.
var manager = new ClientListener(IPAddress.Any, 9999);
manager.ClientConnected += this.OnClientConnected;
manager.Listen();
TestGeneral();
TestKick();
}
public ClientManagerImpl(ClientManagerConfig config, ClientListener listener, Manager wrapper)
{
this.config = config;
this.listener = listener;
this.wrapper = wrapper;
this.dispatcher = config.getDispatcher();
Exception e = dispatcher.run(() => this.listener.onManagerInitialized(this, config));
if (e != null)
{
throw e;
}
this.autoReconnect = config.isAutoReconnect();
state = State.INIT;
doConnect();
}
/// <summary>
/// constructor
/// </summary>
ClientGateway()
{
throw new NotImplementedException();
//init listener
_webserviceListener = new ClientListener();
_webserviceListener.initialize(8999);
ClientDefinition.ErrorMessageEvent += ClientDefinition_ErrorMessageEvent;
ClientDefinition.OnConfigRequestEvent += ClientDefinition_OnConfigRequestEvent;
ClientDefinition.OnPingEvent += ClientDefinition_OnPingEvent;
ClientDefinition.OnScanRequestEvent += ClientDefinition_OnScanRequestEvent;
ClientDefinition.OnShutdownRequestEvent += ClientDefinition_OnShutdownRequestEvent;
//init sender
_webserviceSender = new ServerSender();
}
/// <summary>
/// Осуществляет подключение к командному обработчику и выполняет действия
/// необходимые при первом подключении клиента к серверу.
/// </summary>
protected async Task ConnectToCommandHandlerAsync(IPEndPoint endPoint)
{
mainConnection = new Connection(endPoint);
ConnectionCallback callback = new NewConnectionCallback(mainConnection);
await mainConnection.OpenAsync(callback).ConfigureAwait(false);
Guid[] ids = (Guid[])callback.Result;
mainConnection.InitializationOnClient(ids[0], ids[1]);
ID = ids[0];
clientListener = new ClientListener(mainConnection, cSource.Token);
}
public override void Initialize()
{
InitHandler();
var listener = new ClientListener(this);
mClient = new NetManager(listener);
mClient.UnconnectedMessagesEnabled = true;
mClient.UpdateTime = 15;
mClient.DisconnectTimeout = 30 * 1000;
if (!mClient.Start())
{
Debug.LogError("Client start failed");
return;
}
isOnUpdate = true;
}
public void Run()
{
//Server
_serverListener = new ServerListener();
NetServer server = new NetServer(_serverListener, 2, "myapp1");
if (!server.Start(9050))
{
Console.WriteLine("Server start failed");
Console.ReadKey();
return;
}
_serverListener.Server = server;
//Client
_clientListener = new ClientListener();
NetClient client1 = new NetClient(_clientListener, "myapp1");
//client1.SimulateLatency = true;
client1.SimulationMaxLatency = 1500;
client1.MergeEnabled = true;
if (!client1.Start())
{
Console.WriteLine("Client1 start failed");
return;
}
client1.Connect("127.0.0.1", 9050);
NetClient client2 = new NetClient(_clientListener, "myapp1");
//client2.SimulateLatency = true;
client2.SimulationMaxLatency = 1500;
client2.Start();
client2.Connect("::1", 9050);
while (!Console.KeyAvailable)
{
client1.PollEvents();
client2.PollEvents();
server.PollEvents();
Thread.Sleep(15);
}
client1.Stop();
client2.Stop();
server.Stop();
Console.ReadKey();
Console.WriteLine("ServStats:\n BytesReceived: {0}\n PacketsReceived: {1}\n BytesSent: {2}\n PacketsSent: {3}",
server.BytesReceived,
server.PacketsReceived,
server.BytesSent,
server.PacketsSent);
Console.WriteLine("Client1Stats:\n BytesReceived: {0}\n PacketsReceived: {1}\n BytesSent: {2}\n PacketsSent: {3}",
client1.BytesReceived,
client1.PacketsReceived,
client1.BytesSent,
client1.PacketsSent);
Console.WriteLine("Client2Stats:\n BytesReceived: {0}\n PacketsReceived: {1}\n BytesSent: {2}\n PacketsSent: {3}",
client2.BytesReceived,
client2.PacketsReceived,
client2.BytesSent,
client2.PacketsSent);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
private void buttonStart_Click(object sender, EventArgs e)
{
ClientListener listener;
listener = new ClientListener(new IPEndPoint(GetLocalInternalIP(), UInt16.Parse(textBoxLocalPort.Text)), new IPEndPoint(IPAddress.Parse(textBoxRemoteIp.Text), UInt16.Parse(textBoxPort.Text)), ProxyMode);
Listener.OnGotResultsCbk onGotRes = new Listener.OnGotResultsCbk(OnGotResults);
listener.SetOnGotResults(onGotRes);
listenerList.Add(listener);
listener.Start();
}
public void Run()
{
//Server
_serverListener = new ServerListener();
NetServer server = new NetServer(_serverListener, 2, "myapp1");
server.DiscoveryEnabled = true;
if (!server.Start(9050))
{
Console.WriteLine("Server start failed");
Console.ReadKey();
return;
}
_serverListener.Server = server;
//Client
_clientListener1 = new ClientListener();
NetClient client1 = new NetClient(_clientListener1, "myapp1");
_clientListener1.Client = client1;
client1.SimulateLatency = true;
client1.SimulationMaxLatency = 1500;
if (!client1.Start())
{
Console.WriteLine("Client1 start failed");
return;
}
_clientListener2 = new ClientListener();
NetClient client2 = new NetClient(_clientListener2, "myapp1");
_clientListener2.Client = client2;
client2.SimulateLatency = true;
client2.SimulationMaxLatency = 1500;
client2.Start();
//Send broadcast
NetDataWriter writer = new NetDataWriter();
writer.Put("CLIENT 1 DISCOVERY REQUEST");
client1.SendDiscoveryRequest(writer, 9050);
writer.Reset();
writer.Put("CLIENT 2 DISCOVERY REQUEST");
client2.SendDiscoveryRequest(writer, 9050);
while (!Console.KeyAvailable)
{
client1.PollEvents();
client2.PollEvents();
server.PollEvents();
Thread.Sleep(15);
}
client1.Stop();
client2.Stop();
server.Stop();
Console.ReadKey();
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
