// Create a client and connect to the server port
public void SetupClient()
{
myClient = new NetworkClient();
myClient.RegisterHandler(MsgType.Connect, OnConnected);
myClient.RegisterHandler(MyMsgType.Info, OnInfo);
myClient.Connect("10.250.235.162", 3000);
}
public void connect(string server, NetworkMessageDelegate onConnect)
{
client = new NetworkClient ();
if(onConnect != null)
client.RegisterHandler (MsgType.Connect, onConnect);
client.Connect (server, PORT);
}
public override void InitializeScene(ICanvas canvas)
{
// Connect with simulator
connection = new NetworkClient();
if (!connection.Connect("ganberg2", 9999))
{
throw new ApplicationException("Unable to establish connection with host.");
}
else
{
connection.Subscribe("TimeTick");
connection.Subscribe("ViewProUpdate");
}
// Create and initialize Gameboard.
background = new Obj_Sprite(texture_file, SpriteFlags.SortTexture | SpriteFlags.AlphaBlend);
background.Initialize(canvas);
background.Position = new Vector3(0, 0, 0);
background.Rotation = new Vector3(0, 0, 0);
background.Scaling = new Vector3(1, 1, 1);
background.Texture(canvas);
// Initialize and create Font;
this._myFont = canvas.CreateFont(new System.Drawing.Font("Arial", 10));
message = string.Empty;
//f16 = new Obj_Sprite("f16.png", SpriteFlags.AlphaBlend);
//f16.Initialize(canvas);
//f16.Texture(canvas);
//f16.Position = new Vector3(0, 0, 0);
//f16.Rotation = new Vector3(0, 0, 0);
//f16.Scaling = new Vector3(1, 1, 1);
}
public void SetupClient()
{
myClient = new NetworkClient();
myClient.RegisterHandler(MsgType.Connect, OnConnected);
myClient.Connect("192.16.7.21", 8888);
isAtStartup = false;
}
private void SetupClient()
{
if (client == null)
{
client = new NetworkClient();
client.Connect("127.0.0.1", serverPort);
}
}
void Awake()
{
myClient = new NetworkClient ();
ConnectionConfig config = new ConnectionConfig ();
config.AddChannel (QosType.ReliableFragmented);
myClient.Configure (config, 1);
myClient.Connect (IP, 7777);
myClient.RegisterHandler (MyMsgType.Info, OnInfoMessage);
}
void setupClient()
{
//registerPrefabs ();
//Spawn ();
myClient = new NetworkClient();
myClient.RegisterHandler(MsgType.Connect, OnConnectedRemotePlayer);
myClient.RegisterHandler (MsgType.Error, OnErrorRemotePlayer);
myClient.Connect(gameIP, gamePort);
}
public void Start()
{
ClientScene.RegisterPrefab(Player);
ClientScene.RegisterPrefab (Bolt);
myClient = new NetworkClient();
Debug.Log("oollolo");
//myClient.RegisterHandler(MsgType.Connect, OnConnected);
myClient.Connect("127.0.0.1", 7777);
}
public void SetupClient()
{
StartClient();
Debug.Log("SetupClient()");
discovery.Initialize();
discovery.StartAsClient();
myClient = new NetworkClient();
myClient.Connect("127.0.0.1", 4444);
}
// Use this for initialization
void Start () {
nc = new NetworkClient ();
nc.Connect("192.168.1.19", 5678);
Debug.Log ("Client : " + nc);
Debug.Log (nc.isConnected);
if (nc.isConnected) {
int score = snake.score;
Debug.Log ("Derp " + score);
scoreText.text = "Score: " + score;
} else {
scoreText.text = "Score: ERROR";
}
}
// Create a client and connect to the server port
public void SetupClient()
{
Debug.Log ("SetupClient.");
foreach (GameObject prefab in prefabs) {
if (prefab != null)
ClientScene.RegisterPrefab (prefab);
}
myClient = new NetworkClient ();
myClient.RegisterHandler (MsgType.Connect, OnConnected);
myClient.Connect (base.networkAddress, base.networkPort);
}
void Start()
{
//on client, this isn't required but is nice for testing.
Application.runInBackground = true;
var globals = FindObjectOfType<GlobalAssets>();
_networkStateEntityProtoType = globals.NetworkEntityStatePrototype.GetComponent<NetworkIdentity>();
ClientScene.RegisterSpawnHandler(_networkStateEntityProtoType.assetId, OnSpawnEntity, OnDespawnEntity);
_client = new NetworkClient();
_client.Connect("localhost", 7777);
_client.RegisterHandler(MsgType.Connect, OnClientConnected);
}
public void joinGame()
{
// Check if there is a room
// Has the game Started?
// If no, send the player to the Waiting For Players page
// If yes, give error message.
Debug.Log (string.Format ("join button clicked"));
client = new NetworkClient();
client.Connect ("192.168.1.103", 4444);
client.RegisterHandler(MsgType.Connect, OnConnected);
client.RegisterHandler(MsgType.Error, OnError);
client.RegisterHandler (Message.GET_HAS_ROOM, OnGetRoom);
}
static void Main(string[] args)
{
string scenarioFile = args[0];
new ScenarioToQueues(scenarioFile);
// string hostname = "dgeller";
string hostname=args[1];
// int port = 9999;
int port = int.Parse(args[2]);
// string simModelName = "SimulationModel.xml";
string simModelName = args[3];
NetworkClient c = new NetworkClient();
c.Connect(hostname, port);
EventCommunicator eventCommunicator = new EventCommunicator(c);
SimulationModelReader smr = new SimulationModelReader();
SimulationModelInfo simModelInfo = smr.readModel(simModelName);
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
sink = new Watcher(400);
ThreadStart stub = new ThreadStart(sink.WatcherThread);
Thread stubThread = new Thread(stub);
stubThread.Start();
for (int i = 0; i < 5; i++) // in test the move happens at time 2
{
TimerTicker.NextTick();
}
IncomingList.Add(new MoveComplete_Event("UNIT0"));
for (int i = 0; i < 2; i++)
{
TimerTicker.NextTick();
}
Console.WriteLine("The end");
}
public void OnMatchJoined(JoinMatchResponse matchJoin)
{
if (matchJoin.success)
{
Debug.Log("Join match succeeded");
if (matchCreated)
{
Debug.LogWarning("Match already set up, aborting...");
return;
}
Utility.SetAccessTokenForNetwork(matchJoin.networkId, new NetworkAccessToken(matchJoin.accessTokenString));
NetworkClient myClient = new NetworkClient();
myClient.RegisterHandler(MsgType.Connect, OnConnected);
myClient.Connect(new MatchInfo(matchJoin));
}
else
{
Debug.LogError("Join match failed");
}
}
void Start()
{
manager = GetComponent<NetworkManager>();
manager.StartMatchMaker();
matcher = manager.matchMaker;
matcher.ListMatches(0, ListSize, "", (matches) => {
if (matches.success) {
if (matches.matches.Count > 0 && !OnlyHost) {
matcher.JoinMatch(matches.matches[0].networkId, "", (join) => {
if (join.success) {
Utility.SetAccessTokenForNetwork(join.networkId, new NetworkAccessToken(join.accessTokenString));
NetworkClient client = new NetworkClient();
client.RegisterHandler(MsgType.Connect, (connected) => {
Debug.Log("Connected");
});
client.Connect(new MatchInfo(join));
manager.StartClient();
} else {
Debug.LogError("Could not join match");
}
});
} else {
matcher.CreateMatch(URandom.value.ToString(), PlayerCountPerRoom, Advertise, "", (created) => {
if (created.success) {
Debug.Log("Create match succeeded");
Utility.SetAccessTokenForNetwork(created.networkId, new NetworkAccessToken(created.accessTokenString));
NetworkServer.Listen(new MatchInfo(created), 9000);
manager.StartHost();
isHost = true;
} else {
Debug.LogError("Could not create match");
}
});
}
} else {
Debug.LogError("Could not recieve list of matchces");
}
});
}
public void InitializeClient()
{
if (client != null)
{
Debug.LogError("Already connected");
return;
}
client = new NetworkClient();
client.Connect(MasterServerIpAddress, MasterServerPort);
// system msgs
client.RegisterHandler(MsgType.Connect, OnClientConnect);
client.RegisterHandler(MsgType.Disconnect, OnClientDisconnect);
client.RegisterHandler(MsgType.Error, OnClientError);
// application msgs
client.RegisterHandler(MasterMsgTypes.RegisteredHostId, OnRegisteredHost);
client.RegisterHandler(MasterMsgTypes.UnregisteredHostId, OnUnregisteredHost);
client.RegisterHandler(MasterMsgTypes.ListOfHostsId, OnListOfHosts);
//DontDestroyOnLoad(gameObject);
}
public void OnStartServerInHostModeSetsIsClientTrue()
{
CreateNetworked(out GameObject _, out NetworkIdentity identity);
// call client connect so that internals are set up
// (it won't actually successfully connect)
NetworkClient.Connect("localhost");
// manually invoke transport.OnConnected so that NetworkClient.active is set to true
Transport.activeTransport.OnClientConnected.Invoke();
Assert.That(NetworkClient.active, Is.True);
// isClient needs to be true in OnStartServer if in host mode.
// this is a test for a bug that we fixed, where isClient was false
// in OnStartServer if in host mode because in host mode, we only
// connect the client after starting the server, hence isClient would
// be false in OnStartServer until way later.
// -> we have the workaround in OnStartServer, so let's also test to
// make sure that nobody ever breaks it again
Assert.That(identity.isClient, Is.False);
identity.OnStartServer();
Assert.That(identity.isClient, Is.True);
}
public void Join()
{
client = new NetworkClient();
client.RegisterHandler(MsgType.Connect, OnConnected);
client.RegisterHandler(MsgType.Disconnect, OnDisconnected);
// custom msgs
client.RegisterHandler(CustomNetMsg.Ready, GotReady);
client.RegisterHandler(CustomNetMsg.Name, GotName);
client.RegisterHandler(CustomNetMsg.Role, GotRole);
client.RegisterHandler(CustomNetMsg.Id, GotId);
client.RegisterHandler(CustomNetMsg.PlayerDisconnected, GotPlayerDisconnected);
client.RegisterHandler(CustomNetMsg.Player, GotPlayer);
client.RegisterHandler(CustomNetMsg.StartGame, GotStartGame);
client.RegisterHandler(CustomNetMsg.Spawn, GotSpawnLocation);
client.RegisterHandler(CustomNetMsg.Move, GotMove);
client.RegisterHandler(CustomNetMsg.DissonanceId, GotDissonanceId);
client.RegisterHandler(CustomNetMsg.Tile, GotTile);
client.RegisterHandler(CustomNetMsg.Attack, GotAttack);
client.Connect(ip, 45555);
}
public void Connect()
{
loadingText.text = Language.GetText(8);
panel_Loading.Open();
nc = new NetworkClient();
nc.Connect(string.IsNullOrEmpty(debugIp.text) ? settings.targetIp : debugIp.text, settings.port);
nc.RegisterHandler(MsgType.Connect, OnConnected);
nc.RegisterHandler(MsgType.Disconnect, OnDisconnect);
nc.RegisterHandler(MTypes.SessionUpdate, OnSessionUpdate);
nc.RegisterHandler(MTypes.AgentInfo, OnAgentInfo);
nc.RegisterHandler(MTypes.SyncPosition, OnSyncPosition);
nc.RegisterHandler(MTypes.AgentMove, OnAgentMove);
nc.RegisterHandler(MTypes.AgentStop, OnAgentStop);
nc.RegisterHandler(MTypes.AgentDestroy, OnAgentDestroy);
nc.RegisterHandler(MTypes.StartSkill, OnStartSkill);
nc.RegisterHandler(MTypes.EndSkill, OnEndSkill);
nc.RegisterHandler(MTypes.AgentHealth, OnAgentHealth);
nc.RegisterHandler(MTypes.SkillDestroy, OnSkillDestroy);
nc.RegisterHandler(MTypes.SkillSpawn, OnSkillSpawn);
nc.RegisterHandler(MTypes.AgentAim, OnAgentAim);
nc.RegisterHandler(MTypes.SkillEffect, OnSkillEffect);
nc.RegisterHandler(MTypes.HeroInfo, OnHeroInfo);
nc.RegisterHandler(MTypes.Cooldown, OnCooldown);
nc.RegisterHandler(MTypes.KillInfo, OnKillInfo);
nc.RegisterHandler(MTypes.ScoreInfo, OnScoreInfo);
nc.RegisterHandler(MTypes.SessionEnd, OnSessionEnd);
nc.RegisterHandler(MTypes.RoundComplete, OnRoundComplete);
nc.RegisterHandler(MTypes.SkillInfo, OnSkillInfo);
nc.RegisterHandler(MTypes.AgentLevel, OnAgentLevel);
nc.RegisterHandler(MTypes.LevelInfo, OnLevelInfo);
nc.RegisterHandler(MTypes.MapInfo, OnMapInfo);
nc.RegisterHandler(MTypes.AgentBuff, OnAgentBuff);
nc.RegisterHandler(MTypes.Teleport, OnTeleport);
nc.RegisterHandler(MTypes.Hook, OnHook);
}
public IEnumerator _ConnectionId()
{
using (NetworkServer server = new NetworkServer())
{
server.Start(localPort);
using (NetworkClient client = new NetworkClient())
{
client.Connect(localAddress, localPort);
foreach (var o in Wait())
{
yield return(null);
}
Assert.AreEqual(server.Connections.Count(), 1);
int connectionId = server.Connections.First().ConnectionId;
Assert.IsTrue(connectionId > 0, connectionId.ToString());
Assert.IsTrue(client.Connection.IsConnected);
Assert.AreEqual(client.Connection.ConnectionId, connectionId);
Assert.AreEqual(client.Connection, server.Connections.First());
}
}
}
public void SetupNetwork()
{
netManagerObj = new GameObject();
networkManager = netManagerObj.AddComponent <NetworkManager>();
networkManager.playerPrefab = Resources.Load("PlayerGameObject", typeof(GameObject)) as GameObject;
Assert.IsNotNull(networkManager.playerPrefab);
networkManager.customConfig = true;
networkManager.networkAddress = _ip;
networkManager.networkPort = _port;
networkManager.autoCreatePlayer = false;
networkMigrManager = netManagerObj.AddComponent <NetworkMigrationManager>();
Assert.IsTrue(networkManager.StartServer(), "Server was not started!");
networkManager.SetupMigrationManager(networkMigrManager);
client = networkManager.StartClient();
client.Connect(_ip, _port);
Assert.IsNull(client.connection, "Client is not connected");
networkMigrManager.Initialize(client, networkManager.matchInfo);
networkMigrManager.SendPeerInfo();
}
public void SetupClient(string ip)
{
string conIP;
if (ip == "")
{
if (ipAdress.text != "")
{
conIP = ipAdress.text;
}
else
{
conIP = "127.0.0.1";
}
}
else
{
conIP = ip;
}
myClient = new NetworkClient();
myClient.RegisterHandler(MsgType.Connect, OnConnected);
myClient.Connect(conIP, 7777);
isAtStartup = false;
}
//check that Server/Client can be started
public IEnumerator NetworkServerClientCanBeStartedWithConfig()
{
string netAddress = "127.0.0.1";
int netPort = 8887;
netManager.networkAddress = netAddress;
netManager.networkPort = netPort;
netManager.StartServer();
NetworkClient netClient = netManager.StartClient();
netClient.Connect(netAddress, netPort);
if (!netClient.isConnected)
{
yield return(null);
}
Assert.IsTrue(netClient.isConnected,
"Client did not connect to server");
netManager.StopServer();
}
public void InitializeClient()
{
if (client != null)
{
Debug.LogError("Already connected");
return;
}
client = new NetworkClient();
RegisterHandlers();
//Parse address
Uri url;
int port = GameServer.port;
if (Uri.TryCreate("http://" + hostAddress, UriKind.Absolute, out url))
{
if (url.Port != 80)
{
port = url.Port;
}
Debug.Log("IP: " + url.Host + " Port: " + port);
}
else
{
Debug.LogError("Error parsing IP Address");
client.Shutdown();
client = null;
return;
}
client.Connect(url.Host, port);
DontDestroyOnLoad(this.gameObject);
}
public void Connect(string ip, int port)
{
ConnectionConfig cc = new ConnectionConfig();
cc.AddChannel(QosType.Reliable);
cc.AddChannel(QosType.ReliableFragmented);
networkClient = new NetworkClient();
networkClient.Configure(cc, 1);
networkClient.RegisterHandler(MsgType.Connect, x =>
{
isConnected = true;
if (OnConnected != null)
{
OnConnected();
}
});
networkClient.RegisterHandler(MsgType.Disconnect, x =>
{
if (isConnected)
{
isConnected = false;
if (OnDisconnected != null)
{
OnDisconnected();
}
}
else //connection failure
{
if (OnFailedToConnect != null)
{
OnFailedToConnect();
}
}
});
networkClient.Connect(ip, port);
}
IEnumerator <CustomYieldInstruction> ConnectCoroutine(PTSession session)
{
if (!myClient.isConnected && session != null)
{
//
ResetClient();
//Check the player's name is valid (no duplica)
//bool isClientNameValid = true;
if (isClientNameValid())
{
//Actuall connect happens here
myClient.Connect(session.ip, session.port);
//wait until the connection is established
yield return(new WaitUntil(() => myClient.isConnected));
//Send the connected event msg to server
PTMessage msg = new PTMessage();
msg.senderName = playerName;
myClient.Send((short)PTEvent.Connect, msg);
}
}
}
public void SetupClient(bool simulatedLatency)
{
ConnectionConfig config = new ConnectionConfig();
//config.por
//MyNetworkManager.singleton.StartServer();
config.NetworkDropThreshold = 90;
config.ReducedPingTimeout = 1000;
config.PingTimeout = 1000;
config.AddChannel(QosType.ReliableSequenced);
config.AddChannel(QosType.AllCostDelivery);
myClient = new NetworkClient();
myClient.Configure(config, 10);
myClient.RegisterHandler(MsgType.Connect, OnConnected);
if (simulatedLatency)
{
myClient.ConnectWithSimulator(m_ipText.text, m_gameServerPort, 150, 0);
}
else
{
myClient.Connect(m_ipText.text, m_gameServerPort);
}
}
public void StartClient()
{
if (networkClient == null)
{
Debug.Log("StartClient");
networkClient = new NetworkClient();
networkClient.Connect(ipv4, portTCP); // port server的端口，用于建立链接
networkClient.RegisterHandler(MsgType.Connect, OnConnect);
networkClient.RegisterHandler(MsgType.Disconnect, reconnectHandler.OnDisconnect);
networkClient.RegisterHandler(CustomMsgType.RoleState, roleChooseHandler.OnReceiveRoleState);
networkClient.RegisterHandler(CustomMsgType.ClientChange, panelChanger.ChangePanel);
networkClient.RegisterHandler(CustomMsgType.GroupState, joystickHandler.OnClientReciveMessage);
networkClient.RegisterHandler(CustomMsgType.AdvanceControl, advanceControlHandler.OnReceiveAdvanceControl);
networkClient.RegisterHandler(CustomMsgType.Session, reconnectHandler.OnReceiveSession);
networkClient.RegisterHandler(CustomMsgType.Stage, panelChanger.ChangeStage);
}
else
{
if (!networkClient.isConnected)
{
networkClient.Connect(ipv4, portTCP);
}
}
}
public void Send()
{
// register server handler
int called = 0;
NetworkServer.RegisterHandler <AddPlayerMessage>((conn, msg) => { ++called; }, false);
// connect a regular connection. not host, because host would use
// connId=0 but memorytransport uses connId=1
NetworkClient.Connect("localhost");
// update transport so connect event is processed
((MemoryTransport)Transport.activeTransport).LateUpdate();
// send it
AddPlayerMessage message = new AddPlayerMessage();
NetworkClient.Send(message);
// update transport so data event is processed
((MemoryTransport)Transport.activeTransport).LateUpdate();
// received it on server?
Assert.That(called, Is.EqualTo(1));
}
// Use this for initialization
void Start () {
nc = new NetworkClient ();
nc.Connect("192.168.1.19", 5678);
nc.RegisterHandler (Networking.CustomMsgType.SpreadMiniGameMessage, getInputFromServer );
}
//=====================================================
//Кнопки
//=====================================================
//подключение по введеному в поле ip адресу и вывод сообщения на
//экран с результатом подлкючения
public void ConnectClick()
{
ip = InputServerIP.text;
MessageLog.text = "Connecting to " + ip;
client.Connect(ip, port);
}
private static async Task Connect()
{
client = new NetworkClient();
await client.Connect(NetworkConstants.ServerUrl, NetworkConstants.MainHubName);
}
/// <summary>
/// Connect client to a NetworkServer instance.
/// </summary>
/// <param name="address"></param>
public void Connect(string address)
{
NetworkClient.Connect(address);
}
// Create a client and connect to the server port
public void SetupClient2()
{
myClient2 = new NetworkClient(); //Instantiate the client
myClient2.Connect(SERVER_ADDRESS, SERVER_PORT2); //Attempt to connect, this will send a connect request which is good if the OnConnected fires
}
public void OnReceivedBroadcast(string fromAddress, string data)
{
foreach (GameObject but in joinGameButtons)
{
if (but.name == fromAddress)
{
return;
}
}
GameObject newButton = GameObject.Instantiate(joinButtonPrefab);
newButton.name = fromAddress;
newButton.transform.parent = joinGameUI.transform;
newButton.transform.localPosition = new Vector2(newButton.transform.position.x, joinListY);
newButton.GetComponentInChildren<Text>().text = data;
newButton.GetComponent<Button>().onClick.AddListener(() => {
SceneManager.LoadScene("main");
GameObject.Find("Global").GetComponent<Game>().Networked = true;
NetworkClient myClient = new NetworkClient();
myClient.Connect(fromAddress, net.LOCAL_PORT);
});
joinListY -= 50;
joinGameButtons.Add(newButton);
}
public void ConnectToServer()
{
// Connect to the server
client.Connect(inputIP.text, port);
}
public void SetupClient()
{
myClient = new NetworkClient();
myClient.RegisterHandler(MsgType.Connect, OnConnected);
myClient.Connect("192.168.1.83", 80);
}
void SetupClient()
{
ClientScene.RegisterPrefab (this.pointObject.gameObject);
ClientScene.RegisterPrefab (this.baseObject.gameObject);
mode = false;
Debug.Log("Verbinde mit Server...");
client = new NetworkClient ();
client.RegisterHandler (MsgType.Connect, OnConnected);
client.Connect (adress, System.Convert.ToInt16 (port));
client.RegisterHandler (MyMsgType.IDComponentUpdateMessage, OnUpdateDistributionRequestMsg);
ClientScene.AddPlayer (0);
}
public static void Connect(string serverIp, int serverPort)
{
_client.Connect(serverIp, serverPort);
}
/// <summary>
/// Reconnects to a CityServer.
/// </summary>
public void Reconnect(ref NetworkClient Client, CityInfo SelectedCity, LoginArgsContainer LoginArgs)
{
Client.Disconnect();
if (LoginArgs.Enc == null)
{
Debug.WriteLine("LoginArgs.Enc was null!");
LoginArgs.Enc = new GonzoNet.Encryption.AESEncryptor(Convert.ToBase64String(PlayerAccount.Hash));
}
else if (LoginArgs.Username == null || LoginArgs.Password == null)
{
Debug.WriteLine("LoginArgs.Username or LoginArgs.Password was null!");
LoginArgs.Username = PlayerAccount.Username;
LoginArgs.Password = Convert.ToBase64String(PlayerAccount.Hash);
}
Client.Connect(LoginArgs);
}
/// <summary>
/// Reconnects to a CityServer.
/// </summary>
public void Reconnect(ref NetworkClient Client, CityInfo SelectedCity, LoginArgsContainer LoginArgs)
{
Client.Disconnect();
Client.Connect(LoginArgs);
}
public void StartConnect()
{
client = new NetworkClient();
client.RegisterHandler(MyMsgType.Message, ReceiveMessage);
client.Connect(serverIP, port);
}
public void OnSBMatchJoined(JoinMatchResponse matchJoin)
{
if (matchJoin.success)
{
Debug.Log("Join match succeeded");
Utility.SetAccessTokenForNetwork(matchJoin.networkId, new NetworkAccessToken(matchJoin.accessTokenString));
SceneManager.LoadScene("main");
GameObject.Find("Global").GetComponent<Game>().Networked = true;
NetworkClient myClient = new NetworkClient();
//myClient.RegisterHandler(MsgType.Connect, OnConnected);
myClient.Connect(new MatchInfo(matchJoin));
}
else
{
Debug.LogError("Join match failed");
}
}
//[STAThread]
static void Main(string[] args)
{
string hostname = args[0];
int port = Int32.Parse(args[1]);
string simModelName = args[2];
SimulationModelReader smr = new SimulationModelReader();
SimulationModelInfo simModelInfo = smr.readModel(simModelName);
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
cc.Subscribe("ALL");
ScenarioReader scenarioReader = new ScenarioReader();
QueueManager queueManager = QueueManager.UniqueInstance();
c = new NetworkClient();
c.Connect(hostname, port);
EventListener myEL = EventListener.UniqueInstance(c);
int t = 0;
int dt = simModelInfo.simulationExecutionModel.updateFrequency;
SimulationEvent tick = SimulationEventFactory.BuildEvent(ref simModelInfo, "TimeTick");
((IntegerValue)tick["Time"]).value = t;
ConsoleKeyInfo cki;
//Console.TreatControlCAsInput = false; //This explodes my code for some reason, but is in Gabe's client code and works fine, what does it do?
Console.CancelKeyPress += new ConsoleCancelEventHandler(MyExitHandler);
List<SimulationEvent> events = null;
while (c.IsConnected() && queueManager.count() > 0)
{
//Read incoming events queue
//if any events deal with a conditional event, remove the conditional
//event from the conditional list, and place it onto the event queue
//if a unit dies, remove them from the event queue and condition list
while (c.IsConnected() && !(queueManager.eventsAtTime(t)))
{
events = c.GetEvents();
foreach (SimulationEvent e in events)
{
if (e.eventType == "MoveDone")
c.PutEvent(myEL.MoveDoneReceived(e, simModelInfo, tick));
System.Console.WriteLine(SimulationEventFactory.XMLSerialize(e));
}
((IntegerValue)tick["Time"]).value = t;
c.PutEvent(tick);
//Console.WriteLine("Sending...");
//Console.WriteLine(SimulationEventFactory.XMLSerialize(tick));
Thread.Sleep(dt);
t += dt;
}
if (c.IsConnected())
{
QueueManager.sendEventsAtTime(t, c);
((IntegerValue)tick["Time"]).value = t;
c.PutEvent(tick);
//Console.WriteLine("Sending...");
//Console.WriteLine(SimulationEventFactory.XMLSerialize(e));
t += dt;
}
}
while (c.IsConnected())
{
((IntegerValue)tick["Time"]).value = t;
c.PutEvent(tick);
//Console.WriteLine("Sending...");
//Console.WriteLine(SimulationEventFactory.XMLSerialize(tick));
Thread.Sleep(dt);
t += dt;
}
}
public void Connect(NetworkClient ConnectDev, String ConnDevIP, int ConnPort)
{
ConnectDev.Connect(ConnDevIP, ConnPort);
}
public virtual void Connect(string host, int port)
{
client.Connect(host, port);
}
//Creamos un cliente y nos conectamos al ip y puerto del sv
public void SetupClient()
{
myClient = new NetworkClient();
RegisterClientMsgs();
myClient.Connect("127.0.0.1", 8080);
}
public void Connect()
{
serverIp = FindObjectOfType <InputField>().text;
client.Connect(serverIp, port);
}
public TestGameClient(int port)
{
m_Transport = new TestTransport("127.0.0.1", port);
m_NetworkClient = new NetworkClient(m_Transport);
m_NetworkClient.Connect("127.0.0.1:1");
}
public void ClientConnect()
{
ClientScene.RegisterPrefab(moneyBagPrefab);
NetworkClient.RegisterHandler <ConnectMessage>(OnClientConnect);
NetworkClient.Connect("localhost");
}
/// <summary>
/// Connect client to a NetworkServer instance.
/// </summary>
/// <param name="uri">Address of the server to connect to</param>
public void Connect(Uri uri)
{
NetworkClient.Connect(uri);
}
public void Init()
{
ScanForHandlers();
client = new NetworkClient(managerAddress, connector);
client.Connect();
OnInit();
}
private void ConnectNetworkClient(string host = "localhost", int port = 7777)
{
//Basic Unity Networking Client, note there are other ways to do this
//Referr to the unity documentation on Unity Networking for more info.
_network = new NetworkClient();
_network.RegisterHandler(MsgType.Connect, OnConnected);
_network.RegisterHandler(GameServerMsgTypes.OnAuthenticated, OnAuthenticated);
_network.RegisterHandler(GameServerMsgTypes.MsgRecieverExampleResponse, OnMsgRecieverExampleResponse);
_network.RegisterHandler(MsgType.Error, OnClientNetworkingError);
_network.RegisterHandler(MsgType.Disconnect, OnClientDisconnect);
_network.RegisterHandler(GameServerMsgTypes.OnPlayStreamEventReceived, OnReceivedPlayStreamEvent);
_network.RegisterHandler(GameServerMsgTypes.OnSendFriendsList, OnReceivedFriendList);
_network.RegisterHandler(GameServerMsgTypes.OnTitleNewsUpdate, OnTitleNewsUpdate);
//If this fails, it will automatically disconnect from the server.
if (IsLocalNetwork)
{
host = this.host;
port = this.port;
}
_network.Connect(host, port);
Debug.LogFormat("Network Client Created, waiting for connection on ServerHost:{0} Port:{1}", host, port);
/* I wanted to expand on the statement above, Unity Networking has a NetworkingManager that is a
* monobehaviour that you can instantiate into the scene and it also has a HUD for debugging,
* Some like to use that over the direct client. So instead of creating a NetworkingClient
* You could just instantiate a NetworkManager Game Object Prefab, and get a refrence to it's Client
* property. This would allow you to virtually do the same code above, but on that game object.
* For this example, I'm taking the most simple and direct path.
*/
}
private void ClientSetup()
{
NetworkClient client = new NetworkClient();
client.RegisterHandler(MsgType.Connect, OnConnected);
client.Connect(server, port);
}
public void Commands_TickJumpBack()
{
TestTransport.Reset();
var random = new Random(9904);
var serverTransport = new TestTransport("127.0.0.1", 1);
var clientTransport = new TestTransport("127.0.0.1", 2);
var snapshotConsumer = new NullSnapshotConsumer();
var server = new NetworkServer(serverTransport);
var client = new NetworkClient(clientTransport);
client.Connect("127.0.0.1:1");
server.InitializeMap((ref NetworkWriter data) => { data.WriteString("name", "TestMap"); });
server.Update(this);
var sentCommands = new Dictionary <int, MyCommand>();
m_ReceivedCommands.Clear();
var RUNS = 100;
var serverTick = 0;
var clientTick = 10;
bool jumped = false;
while (serverTick < RUNS)
{
server.Update(this);
server.HandleClientCommands(serverTick, this);
++serverTick;
server.SendData();
client.Update(this, snapshotConsumer);
if (clientTick < RUNS)
{
if (!jumped && clientTick == 50)
{
jumped = true;
clientTick = 45;
for (int i = serverTick; i < 50; ++i)
{
sentCommands.Remove(i);
}
}
client.QueueCommand(clientTick, (ref NetworkWriter writer) =>
{
var sent = new MyCommand();
sent.intValue = random.Next(-1000, 1000);
sent.boolValue = random.Next(0, 1) == 1;
sent.floatValue = (float)random.NextDouble();
sentCommands.Add(clientTick, sent);
sent.Serialize(ref writer);
});
}
++clientTick;
client.SendData();
}
foreach (var sent in sentCommands)
{
sent.Value.AssertReplicatedCorrectly(m_ReceivedCommands[sent.Key], false);
}
}
public void OnMatchJoined(JoinMatchResponse matchJoin) {
if (matchJoin.success) {
connectionStatus = "Joined Match. Connecting...";
joiningPanel.gameObject.SetActive(false);
if (matchCreated) {
connectionStatus = "Error. Cannot connect.";
return;
}
Utility.SetAccessTokenForNetwork(matchJoin.networkId, new NetworkAccessToken(matchJoin.accessTokenString));
NetworkClient myClient = new NetworkClient();
myClient.RegisterHandler(MsgType.Connect, OnConnected);
matchInfo = new MatchInfo(matchJoin);
myClient.Connect(matchInfo);
} else {
connectionStatus = "Join match failed";
}
}