IEnumerator CheckServer()
{
clientNetwork = gameObject.AddComponent <TestPlayerClient> ();
Debug.Log("Checking for server");
yield return(new WaitForSeconds(1f));
hostDiscovered = clientNetwork.hostDiscovered;
if (clientNetwork != null && !hostDiscovered)
{
Debug.Log("AWWW! Tragedy! Starting as Host");
clientNetwork.StopBroadcast();
Destroy(clientNetwork);
yield return(null);
}
Debug.Log("The Server is " + serverStarted);
if (!hostDiscovered && !serverStarted)
{
Debug.Log("No Server found. Starting as Host");
NetworkServer.Reset();
NetworkManager.singleton.StartHost();
serverNetwork = gameObject.AddComponent <NetworkDiscovery> ();
serverNetwork.useNetworkManager = true;
serverNetwork.GetComponent <NetworkDiscovery> ().showGUI = false;
serverNetwork.Initialize();
serverNetwork.StartAsServer();
serverStarted = true;
}
}
public void StartGame()
{
isServer = true;
StartHost();
MyNetDiscovery.Initialize();
MyNetDiscovery.StartAsServer();
}
void StartServer()
{
if (!NetworkServer.active)
{
NetworkServer.RegisterHandler((short)PTEvent.Connect, Handler_OnConnected);
NetworkServer.RegisterHandler(MsgType.Disconnect, Handler_OnDisconnect);
NetworkServer.RegisterHandler((short)PTEvent.Data, Handler_OnData);
NetworkServer.RegisterHandler((short)PTEvent.Ready, Handler_OnReadyReceived);
NetworkServer.RegisterHandler((short)PTEvent.ConfirmReadyReceived, Handler_OnConfirmReady);
NetworkServer.Listen(PTNetwork.DEFAULT_SERVER_PORT);
}
PTSession newSession = new PTSession();
newSession.senderName = playerName;
newSession.gameName = gameName;
newSession.port = NetworkServer.listenPort;
newSession.data = Encoding.Unicode.GetBytes(PTNetwork.DEFAULT_BROADCAST_DATA);
if (nd.running)
{
nd.StopBroadcast();
}
nd.broadcastData = newSession.ToString();
nd.Initialize();
nd.StartAsServer();
}
private void offlineBroadcast(string gameName)
{
networkDisc.broadcastData = gameName;
networkDisc.Initialize();
networkDisc.broadcastData = gameName;
networkDisc.StartAsServer();
}
void Start()
{
discovery.Initialize();
discovery.StartAsServer();
StartCoroutine("Initialise");
}
public override void OnStartHost()
{
//string ipAdd = Network.player.ipAddress;
//Debug.Log(ipAdd);
discovery.Initialize();
discovery.StartAsServer();
}
public void StartBroadcasting()
{
if (!discovery.running)
{
discovery.Initialize();
discovery.StartAsServer();
}
}
public void StartServerAndClient()
{
NetworkManager.singleton.StartHost();
_networkDiscovery.Initialize();
_networkDiscovery.StartAsServer();
CheckCanvasControllers();
}
/// <summary>
/// Es llamado cuando se pulsa el botón de iniciar Server.
/// Inicializa el Broadcast y crea el Server.
/// Muestra la IP del servidor
/// </summary>
public void StartServer()
{
NetworkDiscovery.Initialize();
NetworkDiscovery.StartAsServer();
NetworkManager.singleton.StartServer();
IPText.text = "Address=" + LocalIPAddress();
}
public override void OnStartHost()
{
Debug.Log("OnPlayerConnected" + numPlayers);
waiting = false;
GameSceneManager.choice = 0;
waiting = false;
discovery.StartAsServer();
}
void Update()
{
if (netDiscovery.isClient)
{
if (netDiscovery.broadcastsReceived.Count == 0)
{
elapsedTime += Time.deltaTime;
if (elapsedTime > waitSecondsForServer)
{
netDiscovery.StopBroadcast();
netDiscovery.StartAsServer();
netManager.StartHost();
Debug.Log("No hosts were found, setting up as a host.");
if (connectingWindow != null)
{
connectingWindow.SetActive(false);
}
}
}
else if (!isConnected)
{
var brdReceived = netDiscovery.broadcastsReceived;
var brdKeys = brdReceived.Keys.ToArray();
NetworkBroadcastResult invitation = brdReceived[brdKeys[0]];
string msg = NetworkDiscovery.BytesToString(invitation.broadcastData);
Debug.Log("Broadcast from host at " + invitation.serverAddress + " was received: " + msg);
Debug.Log("Port: " + msg.Split(':')[2]);
netManager.networkPort = int.Parse(msg.Split(':').Last()); //NetworkManager:address:port
netManager.networkAddress = invitation.serverAddress;
netManager.StartClient();
isConnected = true;
netDiscovery.StopBroadcast();
if (connectingWindow != null)
{
connectingWindow.SetActive(false);
}
NetworkManager.singleton.client.RegisterHandler(MsgType.Disconnect, OnNetworkDisconnect);
}
}
if (isConnected && !NetworkManager.singleton.client.handlers.ContainsValue(OnNetworkDisconnect))
{
NetworkManager.singleton.client.RegisterHandler(MsgType.Disconnect, OnNetworkDisconnect);
}
}
public override void OnStartServer()
{
base.OnStartServer();
if (!networkDiscovery.StartAsServer())
{
Debug.Log("Couldn't start listening");
}
}
public void Host()
{
RestartDiscovery();
if (discoveryInit)
{
discovery.StartAsServer();
}
NetworkManager.singleton.StartHost();
}
public override void OnStartServer()
{
discovery.StopBroadcast();
Debug.Log("Start Server Broadcast....");
discovery.broadcastData = networkPort.ToString();
discovery.StartAsServer();
base.OnStartServer();
connected = true;
}
public void callback_broadcast()
{
NetworkDiscovery discovery = GameObject.FindObjectOfType <NetworkDiscovery>();
discovery.Initialize();
//discovery.broadcastData = "spam!"; // This is NetworkManager:localhost:7777 by default
discovery.StartAsServer();
this.broadcastButton.interactable = false;
}
public void StartGame()
{
isServer = true;
StartHost();
GameObject gamemng = Instantiate(GameManagerPrefab, new Vector3(0, 0, 0), Quaternion.identity);
NetworkServer.Spawn(gamemng);
Discovery.Initialize();
Discovery.StartAsServer();
}
// Use this for initialization
void Start()
{
//m_HVAxis = new CrossPlatformInputManager.VirtualAxis(horizontalAxisName);
//CrossPlatformInputManager.RegisterVirtualAxis(m_HVAxis);
//m_VVAxis = new CrossPlatformInputManager.VirtualAxis(verticalAxisName);
//CrossPlatformInputManager.RegisterVirtualAxis(m_VVAxis);
broadcast = GetComponent <NetworkDiscovery>();
NetworkServer.Listen(25000);
NetworkServer.RegisterHandler(888, ServerReceiveJoystick);
broadcast.StartAsServer();
}
private void SetGameVisibility(bool visible)
{
if (visible)
{
networkDiscovery.Initialize();
networkDiscovery.StartAsServer();
}
else
{
networkDiscovery.StopBroadcast();
}
}
private IEnumerator InitServer()
{
StartHost();
//Wait a frame to initialize broadcasting
yield return(null);
_discovery.StartAsServer();
//Initialize UWP networking
GenericNetworkTransmitter.instance.ConfigureAsServer();
}
void StartLANHost()
{
NetworkServer.Reset();
manager.StartHost();
if (NetworkServer.active)
{
Debug.Log("Server: Port = " + manager.networkPort);
discovery.Initialize();
discovery.StartAsServer();
canvas.SetActive(false);
preGamePlayer.SetActive(false);
}
}
public void Start()
{
(host.IP.placeholder as Text).text = Format.localIPAddress();
localDiscoveryClient = Instantiate(host.localDiscoveryPrefab).GetComponent <NetworkDiscovery>();
localDiscoveryServer = Instantiate(host.localDiscoveryPrefab).GetComponent <NetworkDiscovery>();
localDiscoveryClient.Initialize();
localDiscoveryClient.StartAsClient();
localDiscoveryClient.Subscribe <LocalNetworkDiscoveryMessage>(this);
localDiscoveryServer.Initialize();
localDiscoveryServer.StartAsServer();
}
IEnumerator Broadcast()
{
yield return(new WaitUntil(() => networkFinder));
if (networkFinder.running)
{
networkFinder.StopBroadcast();
}
yield return(new WaitUntil(() => networkFinder.Initialize()));
networkFinder.broadcastData = SystemInfo.deviceName;
networkFinder.StartAsServer();
}
IEnumerator EstablishConnection()
{
Debug.Log("Establishing connection: Searching for host");
discovery.StartAsClient();
yield return(new WaitForSeconds(2));
if (State.DISCONNECTED != state)
{
yield break;
}
Debug.Log("Establishing connection: No host found, will become host");
discovery.StopBroadcast();
StartHost();
discovery.StartAsServer();
}
public void StartAsServer(int port)
{
PortNumber = port;
if (!networkDiscovery.isServer)
{
if (networkDiscovery.running)
{
networkDiscovery.StopBroadcast();
}
networkDiscovery.Initialize();
networkDiscovery.StartAsServer();
MPLobbyManager.Instance.CreateServer();
GameManager.playerType = GameManager.PlayerType.Master;
}
}
public void StartServer()
{
if (!netDisc.Initialize())
{
SwitchToUI(0);
return;
}
SwitchToUI(1);
netDisc.StartAsServer();
netManager.StartHost();
SwitchToUI(3);
clientIndicators.SetActive(true);
localClientIndicator.SetActive(false);
isHost = true;
}
// Update is called once per frame
void Update()
{
locationTimer += Time.deltaTime;
if (locationTimer > 0.1f)
{
locationTimer = 0;
SendLocation();
print("Sending Location");
}
if (NetworkServer.connections.Count <= 0 && !broadcast.isServer)
{
broadcast.StartAsServer();
}
}
public void StartupHost()
{
StartHost();
GameObject gamemng = Instantiate(GameManagerPrefab, new Vector3(0, 0, 0), Quaternion.identity);
NetworkServer.Spawn(gamemng);
isServer = true;
Discovery.Initialize();
Discovery.StartAsServer();
/*
* broadcast.StartServerBroadcast();
* if (listen.listenStarted)
* {
* listen.StopListenning();
* AutoConnectButton.GetComponentInChildren<Text>().text = TextManager.Instance.Search;
* }*/
}
/// <summary>
/// Es llamado cuando se pulsa el botón de iniciar Server.
/// Inicializa el Broadcast y crea el Server.
/// Muestra la IP del servidor.
/// Construye las fichas del partido y muestra información del partido en el Server
/// </summary>
/// <param name="matchName"></param>
public void StartServer()
{
//Inicializa broadcast
NetworkDiscovery.Initialize();
NetworkDiscovery.StartAsServer();
//Crea servidor
NetworkManager.singleton.StartServer();
//Registra al servidor para escuchar cuando un cliente se desconecta
NetworkServer.RegisterHandler(MsgType.Disconnect, ConnectionError);
//TODO: THIS IS FOR DEBUG
//Muestra IP del servidor
IPText.text = "Match name=" + NetworkDiscovery.broadcastData + '\n' + "Address=" + LocalIPAddress();
ServerGameManager.Instance.OnStartServer(NetworkDiscovery.broadcastData);
}
public void StartHostingServer()
{
// Try starting the network discovery sequence. If the port is taken, go back to the menu.
if (!networkDiscovery.Initialize())
{
ReturnToMainMenu();
Debug.Log("Can't start the network discovery sequence.... The port is taken??");
return;
}
nState = NetworkState.Host;
SwitchToUI(1);
networkDiscovery.StartAsServer();
networkManager.StartHost();
AssignIPText();
SwitchToUI(3);
}
private void StartMatch(MatchingMode mode)
{
StopMatch();
switch (mode)
{
case MatchingMode.Host:
_networkDiscovery.Initialize();
_networkDiscovery.StartAsServer();
NetworkManager.singleton.StartHost();
break;
case MatchingMode.Client:
_networkDiscovery.Initialize();
_networkDiscovery.StartAsClient();
NetworkManager.singleton.StartClient();
break;
}
_matchingMode = mode;
}
