More missing stuff

Assets/MyPlayerController.cs

@@ -0,0 +1,29 @@
+using UnityEngine;
+using System.Collections;
+using Mirror;
+using UnityEngine;
+using System.Collections;
+
+public class MyPlayerController : NetworkBehaviour {
+
+	Rigidbody rb;
+    float speed = 25.0F;
+    float rotationSpeed = 50.0F;
+
+    void Start(){
+        rb = this.GetComponent<Rigidbody>();
+    }
+
+    // Update is called once per frame
+	void Update () {
+        if (!isLocalPlayer) return;
+
+        float translation = Input.GetAxis("Vertical") * speed;
+        float rotation = Input.GetAxis("Horizontal") * rotationSpeed;
+        translation *= Time.deltaTime;
+        rotation *= Time.deltaTime;
+        Quaternion turn = Quaternion.Euler(0f,rotation,0f);
+        rb.MovePosition(rb.position + this.transform.forward * translation);
+        rb.MoveRotation(rb.rotation * turn);
+	}
+}

Assets/MyPlayerTracker.cs

@@ -0,0 +1,86 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+public class MyPlayerTracker : MonoBehaviour
+{
+    public RawImage OnScreenSprite;
+    public Canvas screenCanvas;
+    public Text debugText;
+    public static GameObject trackingObject;
+    public float xoffset;
+    public float yoffset;
+
+    public static void SetTrackingObject(GameObject track)
+    {
+        trackingObject = track;
+    }
+
+    void Start()
+    {
+        GetComponent<Canvas>().worldCamera = Camera.main;
+        OnScreenSprite.enabled = false;
+        debugText.enabled = false;
+    }
+
+    void Update()
+    {
+        if (trackingObject != null)
+        {
+            Vector3 screenMiddle = new Vector3(Screen.width / 2, Screen.height / 2, 0);
+
+            Vector3 screenpos = Camera.main.WorldToScreenPoint(trackingObject.transform.position);
+
+            float tarAngle = (Mathf.Atan2(screenpos.x - screenMiddle.x, Screen.height - screenpos.y - screenMiddle.y) * Mathf.Rad2Deg) + 90;
+            if (tarAngle < 0)
+            {
+                tarAngle += 360;
+            }
+
+            //debugText.text = Mathf.RoundToInt(tarAngle).ToString() + " " + Mathf.RoundToInt(screenpos.x).ToString() + " " + Mathf.RoundToInt(screenpos.y).ToString() + " " + Mathf.RoundToInt(screenpos.z).ToString();
+            debugText.text = "";
+
+            if (/*(screenpos.x > Screen.width) || (screenpos.y > Screen.height) || (screenpos.y < 0) || (screenpos.x < 0) || */ (screenpos.z < 0))
+            {
+                OnScreenSprite.enabled = true;
+
+                OnScreenSprite.material.SetFloat("_Alpha", 0.5f);
+            }
+            else
+            {
+                OnScreenSprite.enabled = false;
+            }
+
+            if (screenpos.z < 0)
+            {
+                screenpos = new Vector3(Screen.width / 2, Screen.height / 2, screenpos.z);
+                tarAngle = tarAngle - 180;
+            }
+
+            if (screenpos.x > Screen.width - Screen.width * xoffset)
+            {
+                screenpos.x = Screen.width - Screen.width * xoffset;
+            }
+            else if (screenpos.x < Screen.width * xoffset)
+            {
+                screenpos.x = Screen.width * xoffset;
+            }
+            if (screenpos.y > Screen.height - Screen.height * yoffset)
+            {
+                screenpos.y = Screen.height - Screen.height * yoffset;
+            }
+            else if (screenpos.y < Screen.height * yoffset)
+            {
+                screenpos.y = Screen.height * yoffset;
+            }
+
+            RectTransformUtility.ScreenPointToWorldPointInRectangle(screenCanvas.GetComponent<RectTransform>(), screenpos, Camera.main, out screenpos);
+
+            OnScreenSprite.rectTransform.position = screenpos;
+            OnScreenSprite.transform.rotation = Camera.main.transform.rotation * Quaternion.Euler(0, 0, tarAngle);
+        }
+        else
+        {
+            OnScreenSprite.enabled = false;
+        }
+    }
+}

Assets/NetworkDetails.cs

@@ -0,0 +1,17 @@
+using Mirror;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Networking;
+
+public class NetworkDetails : NetworkBehaviour {
+
+	// Use this for initialization
+	void Start () {
+
+	}
+
+	// Update is called once per frame
+	void Update () {
+	}
+}

Assets/NetworkDiscoveryHUDAutoConnect.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mirror.Discovery
+{
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Network/NetworkDiscoveryHUDAutoConnect")]
+    [HelpURL("https://mirror-networking.com/docs/Components/NetworkDiscovery.html")]
+    [RequireComponent(typeof(NetworkDiscovery))]
+    public class NetworkDiscoveryHUDAutoConnect : MonoBehaviour
+    {
+        readonly Dictionary<long, ServerResponse> discoveredServers = new Dictionary<long, ServerResponse>();
+        Vector2 scrollViewPos = Vector2.zero;
+
+        public NetworkDiscovery networkDiscovery;
+
+        void tryConnect()
+        {
+            // try all found servers
+            foreach (ServerResponse info in discoveredServers.Values)
+            {
+                if (!NetworkClient.isConnected && !NetworkServer.active && !NetworkClient.active)
+                {
+                    Connect(info);
+                }
+            }
+
+            // no server connected try hosting instead
+            if (!NetworkClient.isConnected && !NetworkServer.active && !NetworkClient.active)
+            {
+                discoveredServers.Clear();
+                NetworkManager.singleton.StartHost();
+                networkDiscovery.AdvertiseServer();
+            }
+        }
+
+        void Start()
+        {
+            discoveredServers.Clear();
+            networkDiscovery.StartDiscovery();
+            // wait 5 seconds before trying to connect so we find any servers out there already
+            Invoke("tryConnect", 5);
+        }
+
+#if UNITY_EDITOR
+        void OnValidate()
+        {
+            if (networkDiscovery == null)
+            {
+                networkDiscovery = GetComponent<NetworkDiscovery>();
+                UnityEditor.Events.UnityEventTools.AddPersistentListener(networkDiscovery.OnServerFound, OnDiscoveredServer);
+                UnityEditor.Undo.RecordObjects(new UnityEngine.Object[] { this, networkDiscovery }, "Set NetworkDiscovery");
+            }
+        }
+#endif
+
+        void OnGUI()
+        {
+            if (NetworkManager.singleton == null)
+                return;
+
+            if (NetworkServer.active || NetworkClient.active)
+                return;
+
+            if (!NetworkClient.isConnected && !NetworkServer.active && !NetworkClient.active)
+                DrawGUI();
+        }
+
+        void DrawGUI()
+        {
+            GUILayout.BeginHorizontal();
+
+            if (GUILayout.Button("Find Servers"))
+            {
+                discoveredServers.Clear();
+                networkDiscovery.StartDiscovery();
+            }
+
+            // LAN Host
+            if (GUILayout.Button("Start Host"))
+            {
+                discoveredServers.Clear();
+                NetworkManager.singleton.StartHost();
+                networkDiscovery.AdvertiseServer();
+            }
+
+            // Dedicated server
+            if (GUILayout.Button("Start Server"))
+            {
+                discoveredServers.Clear();
+                NetworkManager.singleton.StartServer();
+
+                networkDiscovery.AdvertiseServer();
+            }
+
+            GUILayout.EndHorizontal();
+
+            // show list of found server
+
+            GUILayout.Label($"Discovered Servers [{discoveredServers.Count}]:");
+
+            // servers
+            scrollViewPos = GUILayout.BeginScrollView(scrollViewPos);
+
+            foreach (ServerResponse info in discoveredServers.Values)
+                if (GUILayout.Button(info.EndPoint.Address.ToString()))
+                    Connect(info);
+
+            GUILayout.EndScrollView();
+        }
+
+        void Connect(ServerResponse info)
+        {
+            NetworkManager.singleton.StartClient(info.uri);
+        }
+
+        public void OnDiscoveredServer(ServerResponse info)
+        {
+            // Note that you can check the versioning to decide if you can connect to the server or not using this method
+            discoveredServers[info.serverId] = info;
+        }
+    }
+}