private void offlineBroadcast(string gameName)
{
networkDisc.broadcastData = gameName;
networkDisc.Initialize();
networkDisc.broadcastData = gameName;
networkDisc.StartAsServer();
}
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();
}
public void StartServerAndClient()
{
NetworkManager.singleton.StartHost();
_networkDiscovery.Initialize();
_networkDiscovery.StartAsServer();
CheckCanvasControllers();
}
public void StartGame()
{
isServer = true;
StartHost();
GameObject gamemng = Instantiate(GameManagerPrefab, new Vector3(0, 0, 0), Quaternion.identity);
NetworkServer.Spawn(gamemng);
Discovery.Initialize();
Discovery.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();
}
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 StartServer()
{
if (!netDisc.Initialize())
{
SwitchToUI(0);
return;
}
SwitchToUI(1);
netDisc.StartAsServer();
netManager.StartHost();
SwitchToUI(3);
clientIndicators.SetActive(true);
localClientIndicator.SetActive(false);
isHost = true;
}
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;
}
}
private void Start()
{
netDiscovery.Initialize();
netDiscovery.StartAsClient();
connectIP.text = PlayerPrefs.GetString(IPPrefName);
newWorldToggle.onValueChanged.AddListener(SetNewWorldToggle);
}
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;
}
}
void Start()
{
discovery.Initialize();
discovery.StartAsServer();
StartCoroutine("Initialise");
}
void Init()
{
networkDiscovery = gameObject.GetComponent <NetworkDiscovery> ();
networkDiscovery.Initialize();
networkDiscovery.useNetworkManager = true;
InvokeRepeating("RefreshServer", 0, 5);
}
// Use this for initialization
void Start()
{
GameSceneManager.JoinSuccess = false;
GameSceneManager.choice = 1;
discovery.Initialize();
discovery.StartAsClient();
}
// Use this for initialization
void Start()
{
state = State.DISCONNECTED;
discovery.Initialize();
StartCoroutine(EstablishConnection());
}
/// <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 void StartBroadcasting()
{
if (!discovery.running)
{
discovery.Initialize();
discovery.StartAsServer();
}
}
public void RestartDiscovery()
{
if (discovery.running)
{
discovery.StopBroadcast();
}
discoveryInit = discovery.Initialize();
}
public override void Toggle()
{
nd.Initialize();
nd.StartAsClient();
Debug.Log("Is running as client?: " + nd.isClient);
Debug.Log("Listenning on port: " + nd.broadcastPort);
closeMenu();
}
public void StartDiscoveringServer()
{
// 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.Client;
SwitchToUI(2);
networkDiscovery.StartAsClient();
Debug.Log("Attempting To connect...");
}
public override void OnStartHost()
{
//string ipAdd = Network.player.ipAddress;
//Debug.Log(ipAdd);
discovery.Initialize();
discovery.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;
* }*/
}
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;
}
private void OnNetworkDisconnect(NetworkMessage msg)
{
if (isConnected)
{
netManager.StopClient();
isConnected = false;
elapsedTime = 0;
netDiscovery.Initialize();
netDiscovery.StartAsClient();
if (connectingWindow != null)
{
connectingWindow.SetActive(true);
}
if (netDiscovery.broadcastsReceived.Count > 0)
{
netDiscovery.broadcastsReceived.Clear();
}
}
}
void Start()
{
#if !UNITY_EDITOR
discovery.Initialize();
discovery.StartAsClient();
StartCoroutine("SetServerIP");
#else
Connect();
#endif
}
//public Text mapText;
void Start()
{
netDisc = GetComponent <NetworkDiscovery> ();
netDisc.Initialize();
if (lobbymanagerSingleton == null)
{
lobbymanagerSingleton = this;
}
//mapText.text = this.playScene;
}
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;
}
// Starts a lan game with the client also being a server
// This is what we want in most cases
public void Lan_Host()
{
if (networkDiscovery.running)
{
networkDiscovery.StopBroadcast();
}
if (!networkDiscovery.Initialize())
{
print("Failed to start network discovery");
return;
}
// Check if the discovery is running is client or server mode
// if it is, stop this and start again
if (!networkDiscovery.isServer)
{
networkDiscovery.StartAsServer();
StartHost();
}
}
private void SetGameVisibility(bool visible)
{
if (visible)
{
networkDiscovery.Initialize();
networkDiscovery.StartAsServer();
}
else
{
networkDiscovery.StopBroadcast();
}
}
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();
}
void Awake()
{
manager = GetComponent<NetworkManager>();
discovery = GetComponent<NetworkDiscovery>();
discovery.Initialize();
}
void Awake()
{
networkMatch = gameObject.AddComponent<NetworkMatch>();
networkDiscovery = gameObject.AddComponent<OverriddenNetworkDiscovery>();
networkDiscovery.showGUI = false;
//networkDiscovery.useNetworkManager = false;
networkDiscovery.Initialize();
}
