private void Start()
{
_listenning = false;
_newConnections = new Queue <NewConnection>();
_clients = new Dictionary <int, ORTCPClient>();
StartListening();
Observable
.EveryUpdate()
.Where(_ => _newConnections.Count > 0)
.Subscribe(_ =>
{
//Debug.Log(Thread.CurrentThread.ManagedThreadId);
NewConnection newConnection = _newConnections.Dequeue();
ORTCPClient client = ORTCPClient.CreateInstance("ORMultiServerClient", newConnection.tcpClient, this);
int clientID = SaveClient(client);
ORTCPEventParams eventParams = new ORTCPEventParams();
eventParams.eventType = ORTCPEventType.Connected;
eventParams.client = client;
eventParams.clientID = clientID;
eventParams.socket = newConnection.tcpClient;
if (verbose)
{
print("[TCPServer] New client connected");
}
});
}
private void OnTestInputAllowed()
{
FadeManager.EnableCanvasGroup(_testElements, true);
_joinButtons.ForEach(jb =>
{
jb.Button.gameObject.SetActive(false);
jb.Slider
.OnValueChangedAsObservable()
.Subscribe(val =>
{
var b = jb.Slider.value != -1;
jb.Text.text = ((TeamType)jb.Slider.value).ToString();
jb.Button.gameObject.SetActive(b);
}).AddTo(jb.Slider.gameObject);
jb.Button
.OnClickAsObservable()
.Where(_ => jb.Slider.value != -1)
.Subscribe(_ =>
{
var msg = new ORTCPEventParams();
msg.message = "{\"state\":10,\"station_id\":" + jb.Lane + ",\"team\":" + jb.Slider.value + "}";
_appStateBroker.ComReceivingStream.OnNext(msg);
jb.Slider.gameObject.SetActive(false);
jb.Button.gameObject.SetActive(false);
})
.AddTo(jb.Button.gameObject);
});
}
public void Start(int port = 0)
{
_listenning = false;
_newConnections = new Queue <NewConnection>();
_clients = new Dictionary <int, ORTCPClient>();
if (port != 0)
{
StartListening(port);
}
else
{
StartListening();
}
Observable
.Interval(TimeSpan.FromSeconds(1))
.Where(_ => _newConnections.Count > 0)
.Subscribe(_ =>
{
//Debug.Log(Thread.CurrentThread.ManagedThreadId);
NewConnection newConnection = _newConnections.Dequeue();
ORTCPClient client = ORTCPClient.CreateInstance("ORMultiServerClient", newConnection.tcpClient, this, port);
int clientID = SaveClient(client);
ORTCPEventParams eventParams = new ORTCPEventParams();
eventParams.eventType = ORTCPEventType.Connected;
eventParams.client = client;
eventParams.clientID = clientID;
eventParams.socket = newConnection.tcpClient;
Console.BackgroundColor = ConsoleColor.Cyan;
Console.ForegroundColor = ConsoleColor.Black;
Console.WriteLine("[TCPServer] New client connected");
});
}
private void OnTCPMessage(ORTCPEventParams e)
{
print("===========================================");
print("message recived from client: " + e.message);
output.text += e.message + "\n";
// just as a reminder, this will be a JSON in format of {hand:"right", number:"22", team_id:"0", path:"F/..."}.
//let me know if I left something out or you want a different format.
}
public void OnClientDisconnect(ORTCPEventParams eventParams)
{
Console.BackgroundColor = ConsoleColor.Red;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("[TCPServer] OnClientDisconnect");
eventParams.clientID = GetClientID(eventParams.client);
RemoveClient(eventParams.client);
}
public void OnClientDisconnect(ORTCPEventParams eventParams)
{
if (verbose)
{
print("[TCPServer] OnClientDisconnect");
}
eventParams.clientID = GetClientID(eventParams.client);
RemoveClient(eventParams.client);
}
private void Update()
{
while (_events.Count > 0)
{
ORTCPEventType eventType = _events.Dequeue();
ORTCPEventParams eventParams = new ORTCPEventParams();
eventParams.eventType = eventType;
eventParams.server = this;
eventParams.socket = _client;
if (eventType == ORTCPEventType.Connected)
{
print("[TCPServer] New client connected");
foreach (GameObject listener in listeners)
{
listener.SendMessage(onConnectMessage, eventParams, SendMessageOptions.DontRequireReceiver);
}
}
else if (eventType == ORTCPEventType.Disconnected)
{
_reader.Close();
_writer.Close();
_client.Close();
print("[TCPServer] Server Disconnected");
foreach (GameObject listener in listeners)
{
listener.SendMessage(onDisconnectMessage, eventParams, SendMessageOptions.DontRequireReceiver);
}
if (autoListenOnDisconnect)
{
StartListening();
}
}
else if (eventType == ORTCPEventType.DataReceived)
{
if (socketType == ORTCPSocketType.Text)
{
eventParams.message = _messages.Dequeue();
print("[TCPServer] Server DataReceived: " + eventParams.message);
}
else
{
eventParams.packet = _packets.Dequeue();
}
foreach (GameObject listener in listeners)
{
listener.SendMessage(onDataReceivedMessage, eventParams, SendMessageOptions.DontRequireReceiver);
}
}
}
}
public void OnDataReceived(ORTCPEventParams eventParams)
{
if (verbose)
{
print("[TCPServer] OnDataReceived: " + eventParams.message);
}
eventParams.clientID = GetClientID(eventParams.client);
if (OnTCPMessageRecived != null)
{
OnTCPMessageRecived(eventParams);
}
}
public void OnDataReceived(ORTCPEventParams eventParams)
{
Console.BackgroundColor = ConsoleColor.DarkYellow;
Console.ForegroundColor = ConsoleColor.Black;
//Console.Clear();
Console.WriteLine("[TCPServer] OnDataReceived: " + eventParams.message);
eventParams.clientID = GetClientID(eventParams.client);
if (OnTCPMessageRecived != null)
{
OnTCPMessageRecived(eventParams);
}
}
private UniRx.IObservable <string> OnTCPMessage(ORTCPEventParams e)
{
var msg = e.message;
myComandList.Add(msg);
Debug.Log(msg);
if (msg.Contains("[TCPServer]"))
{
Servermsg.text = msg + " [" + DateTime.Now + "] " + "\n" + Servermsg.text;
}
else
{
Output.text = msg + " [" + DateTime.Now + "] " + "\n" + Output.text;
}
return(myComandList.ToObservable());
}
private void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(this.gameObject);
}
else
{
_instance = this;
}
//debug binding
Observable.EveryUpdate()
.Select(_ => GameManager.TargetObject_External)
.DistinctUntilChanged()
.Subscribe(_ => verbose = (GameManager.TargetObject_External & TargetObject.TCP) == TargetObject.TCP)
.AddTo(gameObject);
_listenning = false;
_newConnections = new Queue <NewConnection>();
_clients = new Dictionary <int, ORTCPClient>();
StartListening();
Observable
.EveryUpdate()
.Where(_ => _newConnections.Count > 0)
.Subscribe(_ =>
{
//Debug.Log(Thread.CurrentThread.ManagedThreadId);
NewConnection newConnection = _newConnections.Dequeue();
ORTCPClient client = ORTCPClient.CreateInstance("ORMultiServerClient", newConnection.tcpClient, this);
int clientID = SaveClient(client);
ORTCPEventParams eventParams = new ORTCPEventParams();
eventParams.eventType = ORTCPEventType.Connected;
eventParams.client = client;
eventParams.clientID = clientID;
eventParams.socket = newConnection.tcpClient;
if (verbose)
{
print("[TCPServer] New client connected");
}
});
}
public void Start()
{
Connect();
Observable
.Interval(TimeSpan.FromSeconds(1))
.Where(x => _events.Count > 0)
.Subscribe(x =>
{
ORTCPEventType eventType = _events.Dequeue();
ORTCPEventParams eventParams = new ORTCPEventParams();
eventParams.eventType = eventType;
eventParams.client = this;
eventParams.socket = _client;
if (eventType == ORTCPEventType.Connected)
{
//Console.WriteLine("[TCPClient] Connnected to server");
if (serverDelegate != null)
{
serverDelegate.OnServerConnect(eventParams);
}
}
else if (eventType == ORTCPEventType.Disconnected)
{
//Console.WriteLine("[TCPClient] Disconnnected from server");
if (serverDelegate != null)
{
serverDelegate.OnClientDisconnect(eventParams);
}
_reader.Close();
_writer.Close();
_client.Close();
}
else if (eventType == ORTCPEventType.DataReceived)
{
if (socketType == ORTCPSocketType.Text)
{
eventParams.message = _messages.Dequeue();
// Console.WriteLine("[TCPClient] DataReceived: "+ eventParams.message);
if (OnTCPMessageRecived != null)
{
OnTCPMessageRecived(eventParams);
}
}
else
{
eventParams.packet = _packets.Dequeue();
}
if (serverDelegate != null)
{
serverDelegate.OnDataReceived(eventParams);
}
}
else if (eventType == ORTCPEventType.ConnectionRefused)
{
//Console.WriteLine("[TCPClient] ConnectionRefused... will try again...");
}
});
}
private void OnMessageRecived(ORTCPEventParams e)
{
_appStateBroker.ComReceivingStream.OnNext(e);
}
//Delegation methods. The clients call these
public void OnServerConnect(ORTCPEventParams eventParams)
{
//if(verbose)print("[TCPServer] OnServerConnect");
}
private void Update()
{
while (_events.Count > 0)
{
ORTCPEventType eventType = _events.Dequeue();
ORTCPEventParams eventParams = new ORTCPEventParams();
eventParams.eventType = eventType;
eventParams.client = this;
eventParams.socket = _client;
if (eventType == ORTCPEventType.Connected)
{
if (verbose)
{
print("[{name}] Connnected to server");
}
if (serverDelegate != null)
{
serverDelegate.OnServerConnect(eventParams);
}
Send(isShowControl?"100":GameManager.StatusMsgBackup);
}
else if (eventType == ORTCPEventType.Disconnected)
{
if (verbose)
{
print("[{name}] Disconnnected from server");
}
if (serverDelegate != null)
{
serverDelegate.OnClientDisconnect(eventParams);
}
_reader.Close();
_writer.Close();
_client.Close();
if (autoConnectOnDisconnect)
{
ORTimer.Execute(gameObject, disconnectTryInterval, "OnDisconnectTimer");
}
}
else if (eventType == ORTCPEventType.DataReceived)
{
if (socketType == ORTCPSocketType.Text)
{
eventParams.message = _messages.Dequeue();
if (verbose)
{
print("[{name}] DataReceived: " + eventParams.message);
}
if (OnTCPMessageRecived != null)
{
OnTCPMessageRecived(eventParams);
}
}
else
{
eventParams.packet = _packets.Dequeue();
}
if (serverDelegate != null)
{
serverDelegate.OnDataReceived(eventParams);
}
}
else if (eventType == ORTCPEventType.ConnectionRefused)
{
if (verbose)
{
print("[{name}] ConnectionRefused... will try again...");
}
if (autoConnectOnConnectionRefused)
{
ORTimer.Execute(gameObject, connectionRefusedTryInterval, "OnConnectionRefusedTimer");
}
}
}
}
static void DoCommnad(ORTCPEventParams e)
{
var cmd = e.message;
switch (cmd)
{
case "100":
Console.BackgroundColor = ConsoleColor.Blue;
Console.ForegroundColor = ConsoleColor.White;
APP = e.client;
var str = "[TCPServer] Sending Message to all Clients: TargetApp Connected";
Console.WriteLine(str);
ORTCPMultiServer.Instance.SendAllClientsMessage(str);
APP?.Send("Ready to receive cmds");
break;
case "200":
Console.BackgroundColor = ConsoleColor.DarkGray;
Console.ForegroundColor = ConsoleColor.White;
SC = e.client;
var str1 = "[TCPServer] Sending Message to all Clients: ShowControl Connected";
Console.WriteLine(str1);
ORTCPMultiServer.Instance.SendAllClientsMessage(str1);
APP?.Send("Show Control Connected");
break;
case "shutdown-machine":
{
Console.ForegroundColor = ConsoleColor.Green;
var str2 = "[TCPServer] Sending Message to all Clients: Shutting down in 3s";
Console.WriteLine(str2);
ORTCPMultiServer.Instance.SendAllClientsMessage(str2);
APP?.Send("Shutting down in 3s..");
Observable.Timer(TimeSpan.FromSeconds(3))
.Take(1)
.Subscribe(_ =>
{
ProcessStartInfo proc = new ProcessStartInfo();
proc.WindowStyle = ProcessWindowStyle.Hidden;
proc.FileName = "cmd";
proc.Arguments = "/C shutdown /s /t 0";
Process.Start(proc);
});
}
break;
case "restart-machine":
{
Console.ForegroundColor = ConsoleColor.Green;
var str3 = "[TCPServer] Sending Message to all Clients: Restarting in 3s";
Console.WriteLine(str3);
ORTCPMultiServer.Instance.SendAllClientsMessage(str3);
APP?.Send("Shutting down in 3s...");
Observable.Timer(TimeSpan.FromSeconds(3))
.Take(1)
.Subscribe(_ =>
{
ProcessStartInfo proc = new ProcessStartInfo();
proc.WindowStyle = ProcessWindowStyle.Hidden;
proc.FileName = "cmd";
proc.Arguments = "/C shutdown /f /r /t 0";
Process.Start(proc);
});
}
break;
case "restart-application":
{
Console.BackgroundColor = ConsoleColor.Blue;
Console.ForegroundColor = ConsoleColor.White;
APP?.Send("Restarting the app..");
Observable.Timer(TimeSpan.FromSeconds(2))
.Take(1)
.Subscribe(_ => TargetApp.CloseMainWindow(),
() =>
{
Observable.Timer(TimeSpan.FromSeconds(2))
.Take(1)
.Subscribe(_ => TargetApp.Start());
});
}
break;
case "reset-application":
{
Console.BackgroundColor = ConsoleColor.Blue;
Console.ForegroundColor = ConsoleColor.White;
var str3 = "reset-application";
Console.WriteLine("[TCPServer] Sending Message to all Clients: " + str3);
ORTCPMultiServer.Instance.SendAllClientsMessage(str3);
}
break;
case "shutdown-application":
{
Console.BackgroundColor = ConsoleColor.Blue;
Console.ForegroundColor = ConsoleColor.White;
APP?.Send("Shutting down the app...");
Observable.Timer(TimeSpan.FromSeconds(2))
.Take(1)
.Subscribe(_ => TargetApp.CloseMainWindow());
}
break;
case "status-application":
{
Console.BackgroundColor = ConsoleColor.Blue;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("[TCPServer] Sending Message to App client: status-application");
APP?.Send(e.message);
}
break;
default:
{
if (SC != null)
{
SC.Send(e.message);
}
else
{
Console.Write("Unknown command. Show Control is null.");
}
}
break;
}
}
private void Awake()
{
_appStateBroker = AppStateBroker.Instance;
AutoTest = AutoTest_External;
#if !UNITY_EDITOR
DevMode = false;
#endif
//Debug msg binding
Observable
.EveryUpdate()
.Select(_ => TargetLane)
.DistinctUntilChanged()
.Subscribe(_ =>
{
TargetLane_External = _;
}).AddTo(gameObject);
Observable
.EveryUpdate()
.Select(_ => TargetObject)
.DistinctUntilChanged()
.Subscribe(_ =>
{
TargetObject_External = _;
}).AddTo(gameObject);
//to reset
ResetApp
.Where(b => b)
.Take(1)
.Subscribe(x =>
{
ResetApp.Value = false;
AppStateBroker.Instance.ComOutGoingStream.OnNext("{state:30}");
Observable.Timer(TimeSpan.FromSeconds(1f))
.Subscribe(_ => SceneManager.LoadScene(SceneManager.GetActiveScene().name))
.AddTo(gameObject);
})
.AddTo(gameObject);
//to clibration
CalibrationMode
.Where(b => b)
.Take(1)
.Subscribe(x =>
{
CalibrationMode.Value = false;
AppStateBroker.Instance.ComOutGoingStream.OnNext("{state:30}");
Observable.Timer(TimeSpan.FromSeconds(1f))
.Subscribe(_ => SceneManager.LoadScene(Open4thLane?"MainScene_4Lane_Cal":"MainScene_3Lane_Cal"))
.AddTo(gameObject);
})
.AddTo(gameObject);
//to main game
GameMode
.Where(b => b)
.Take(1)
.Subscribe(x =>
{
GameMode.Value = false;
AppStateBroker.Instance.ComOutGoingStream.OnNext("{state:30}");
Observable.Timer(TimeSpan.FromSeconds(1f))
.Subscribe(_ =>
{
SceneManager.LoadScene(Open4thLane ? "MainScene_4Lane" : "MainScene_3Lane");
})
.AddTo(gameObject);
})
.AddTo(gameObject);
//auto test
if (AutoTest)
{
DebugOutputObjects.SetActive(true);
ManualTeamSelectAllowed = ManualTeamSelectAllowedExternal = false;
Observable.EveryUpdate().Select(_ => TestCount).Subscribe(x =>
{
DubugOutput.text = x.ToString();
ThrowAllowed.gameObject.SetActive(TestCount % 2 != 0);
}).AddTo(gameObject);
_appStateBroker
.CurrentRound
.Subscribe(round =>
{
switch (round)
{
case Rounds.Idle:
Observable.Timer(TimeSpan.FromSeconds(2f))
.Take(1)
.Subscribe(_ =>
{
var len = Open4thLane ? 4 : 3;
for (int i = 0; i < len; i++)
{
var client = new ORTCPEventParams();
var team = AutoTestIndexProvider.GetTeamIndex();
client.message = "{\"state\":10,\"station_id\":" + i + ",\"team\":" + team + "}";
_appStateBroker.ComReceivingStream.OnNext(client);
}
DelayedSanp();
}).AddTo(gameObject);
break;
case Rounds.R1:
case Rounds.R2:
case Rounds.R3:
DelayedSanp();
break;
case Rounds.Finish:
DelayedSanp();
TestCount++;
Debug.LogFormat("[{0}] Testing Count : {1}", name, TestCount);
break;
}
})
.AddTo(gameObject);
}
else
{
DebugOutputObjects.SetActive(false);
}
}
