Added task stations rendering

.gitignore

@@ -186,7 +186,6 @@ StyleCopReport.xml
 *_p.c
 *_h.h
 *.ilk
-*.meta
 *.obj
 *.iobj
 *.pch
@@ -304,10 +303,6 @@ PublishScripts/
 *.nupkg
 # NuGet Symbol Packages
 *.snupkg
-# The packages folder can be ignored because of Package Restore
-**/[Pp]ackages/*
-# except build/, which is used as an MSBuild target.
-!**/[Pp]ackages/build/
 # Uncomment if necessary however generally it will be regenerated when needed
 #!**/[Pp]ackages/repositories.config
 # NuGet v3's project.json files produces more ignorable files

Assets/ClientSDK.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 799f52449ae21404c9a7593f6dc28c60
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ClientSDK/Encryption.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: bc06bb57786c7e142b06ec231e5cf709

Assets/ClientSDK/EventDispatcher.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1d2251b279edb0147bd274a884ac878b

Assets/ClientSDK/GameClient.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 91e0f647c37b0b94b83f53bb854db28c

Assets/ClientSDK/Protocol.cs

@@ -39,8 +39,9 @@ public struct Position
 
             return R * c;
         }
+        public static bool operator ==(Position left, Position right) { if (left.Lat == right.Lat && left.Lon == right.Lon) { return true; } else { return false; } }
+        public static bool operator !=(Position left, Position right) { return !(left == right); }
     }
-
 [JsonConverter(typeof(StringEnumConverter))]
 public enum PlayerRole { Crew, Impostor }
 

Assets/ClientSDK/Protocol.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 14463228dfea2264ebfc36c3a7dc4b99

Assets/ClientSDK/SimulatorClient.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 80ef0979df5d1fe489225f3e5edadc5c

Assets/ClientSDK/bin.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3a4035bdb812fee4f96cb1aa1b24c999
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ClientSDK/obj.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 131d9de257c8edc49991d792c6e702f6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameManager.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5fd2bf33031fe9d4ea3439b41d7f4b97
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameManager/AreaMat.mat

@@ -0,0 +1,92 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: AreaMat
+  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AlphaTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - PixelSnap: 0
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _EnableExternalAlpha: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.0813297, g: 1, b: 0, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _Flip: {r: 1, g: 1, b: 1, a: 1}
+    - _RendererColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1

Assets/GameManager/AreaMat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5a46533bdf4003449bc9146ccef44e27
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameManager/GameManager.cs

@@ -1,11 +1,10 @@
 using UnityEngine;
 using GeoSus.Client;
 using Subsystems;
-using System.Threading;
-using System.Threading.Tasks;
 using System.Collections;
-using System.Collections.Generic;
+using System;
 using TMPro;
+using System.Collections.Generic;
 /*
     GameManager - hlavní tøida pro správu hry
     GameManager_Network - subsystém pro správu komunikace se serverem
@@ -20,26 +19,65 @@ public class GameManager : MonoBehaviour
     [Header("Subsystems")]
     protected GameManager_Network networkSubsystem;
     protected GameManager_UI uiSubsystem;
-
+    protected GameManager_Map mapSubsystem;
+    protected GameManager_Input inputSubsystem;
+    protected GameManager_Game gameSubsystem;
 
     protected GameClient gameClient;
+
     [Header("Player Info")]
     public string displayName;
 
     [Header("UI Elements")]
     public Canvas JoinCreateLobby;
     public Canvas InLobby;
+    public Canvas LoadingScreen;
+    public Canvas GameScreen;
+
+
+    [Header("Map")]
+    public GameObject MapCenterPoint;
+    public BuildingSettings buildingSettings;
+    public PathwaySettings pathwaySettings;
+    public AreaSettings areaSettings;
+
+    [Header("GPS")]
+    public GameObject Player;
+
+    [Header("Debug")]
+    public bool testMode = false;
+    private GameClient _secondClient;
+    private GameClient _thirdClient;
+    private GameManager_Network _secondNetwork;
+    private GameManager_Network _thirdNetwork;
+
+    [Header("Tasks")]
+    public List<TaskData> AvailableTasks = new List<TaskData>();
+    public StationSettings settings = new StationSettings();
 
     void Start()
     {
         DontDestroyOnLoad(this);
         if (displayName == null || displayName == "")
         {
-            displayName = "Player_" + Random.Range(1000, 9999).ToString();
+            displayName = GenerateUsername();
         }
-        gameClient = new GameClient(GenerateUUID(), /*displayName*/ GenerateUsername());
+        if (testMode)
-        uiSubsystem = new GameManager_UI(gameClient, JoinCreateLobby, InLobby);
+        {
+            _secondClient = new GameClient(GenerateUUID(), GenerateUsername());
+            _secondNetwork = new GameManager_Network(_secondClient);
+            _thirdClient = new GameClient(GenerateUUID(), GenerateUsername());
+            _thirdNetwork = new GameManager_Network(_thirdClient);
+
+            _secondNetwork.OpenConection();
+            _thirdNetwork.OpenConection();
+        }
+        gameClient = new GameClient(GenerateUUID(), displayName);
+        uiSubsystem = new GameManager_UI(gameClient, JoinCreateLobby, InLobby, LoadingScreen, GameScreen);
         networkSubsystem = new GameManager_Network(gameClient);
+        mapSubsystem = new GameManager_Map(gameClient, MapCenterPoint, buildingSettings, pathwaySettings, areaSettings);
+        inputSubsystem = new GameManager_Input(gameClient, Player, testMode);
+        gameSubsystem = new GameManager_Game(gameClient, Player, MapCenterPoint, AvailableTasks);
         networkSubsystem.OpenConection();
     }
     private void Update()
@@ -47,8 +85,17 @@ public class GameManager : MonoBehaviour
         if (gameClient.CurrentLobbyState != null)
         {
             uiSubsystem.UpdateLobbyUI();
-
         }
+        try
+        {
+            if (gameClient.CurrentLobbyState.MapDataReady)
+            {
+                mapSubsystem.BuildMap();
+                gameClient.CurrentLobbyState.MapDataReady = false;
+            }
+        }
+        catch (NullReferenceException ex) { }
+        inputSubsystem.positionCheck();
     }
 
 
@@ -60,13 +107,17 @@ public class GameManager : MonoBehaviour
     }
     protected string GenerateUsername()
     {
-        string Username = Random.Range(0,10).ToString() + Random.Range(0, 10).ToString() + Random.Range(0, 10).ToString() + Random.Range(0, 10).ToString();
+        string Username = UnityEngine.Random.Range(0,10).ToString() + UnityEngine.Random.Range(0, 10).ToString() + UnityEngine.Random.Range(0, 10).ToString() + UnityEngine.Random.Range(0, 10).ToString();
         Debug.Log(Username);
         return Username;
     }
     public void CreateLobbyButton()
     {
-        networkSubsystem.CrateLobby(50.0755, 14.4378);
+        networkSubsystem.CrateLobby(50.7727264, 15.0719876);
+        if (testMode)
+        {
+            StartCoroutine(ConnectTestClients());
+        }
     }
     public void JoinLobbyButton()
     {
@@ -84,8 +135,24 @@ public class GameManager : MonoBehaviour
     {
         networkSubsystem.LeaveLobby();
     }
+    public void StartGameButton()
+    {
+        networkSubsystem.StartGame();
+    }
+    public void Interact()
+    {
+        //TODO: Interakce s úkoly
+    }
     void OnApplicationQuit()
     {
         gameClient.Disconnect();
+        _secondClient?.Disconnect();
+        _thirdClient?.Disconnect();
+    }
+    IEnumerator ConnectTestClients()
+    {
+        yield return new WaitForSeconds(2f);
+        _secondNetwork.JoinLobby(gameClient.CurrentLobbyState.JoinCode);
+        _thirdNetwork.JoinLobby(gameClient.CurrentLobbyState.JoinCode);
     }
 }

Assets/GameManager/GameManager.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9e2c3e4ba4e36ea40a686e58feca4d2b

Assets/GameManager/GameManager_Game.cs

@@ -0,0 +1,141 @@
+using GeoSus.Client;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using UnityEngine;
+using static UnityEngine.Rendering.RayTracingAccelerationStructure;
+
+namespace Subsystems
+{
+    [System.Serializable]
+    public class StationSettings
+    {
+        public GameObject TaskStationPrefab;
+        public GameObject SabotageStationPrefab;
+        public GameObject MeetingStationPrefab;
+        public GameObject BodyStationPrefab;
+
+    }
+    public class GameManager_Game
+    {
+        private GameClient _gameClient;
+        private GameObject _player;
+        private GameObject _map;
+        private float _range;
+        private List<TaskData> _availableTasks;
+        public List<GameObject> Stations { get; private set; }
+        public List<GameObject> TaskStations { get; private set; } = new List<GameObject>();
+        private StationSettings _stationSettings;
+        public GameManager_Game(GameClient client, GameObject player, GameObject map, List<TaskData> availableTasks,  float range = 20f, StationSettings stationSettings = null)
+        {
+            _gameClient = client;
+            _player = player;
+            _map = map;
+            _availableTasks = availableTasks;
+            _range = range;
+            _stationSettings = stationSettings;
+        }
+        public bool CheckSightLine(Vector3 target)
+        {
+            RaycastHit hit;
+            Vector3 direction = target - _player.transform.position;
+            Ray ray = new Ray(new Vector3(_player.transform.position.x, 0.1f, _player.transform.position.z), direction);
+            Physics.Raycast(ray, out hit, _range);
+            if (hit.collider.tag == "Player")
+            {
+                Debug.Log("Target is visible");
+                return true;
+            }
+            else
+            {
+                Debug.Log("Target is not visible");
+                return false;
+            }
+
+        }
+        public void InitializeTaskStations()
+        {
+            for(int i = 0; i < _gameClient.MyTasks.Count; i++)
+            {
+                System.Random rnd = new System.Random();
+                var task = _availableTasks[rnd.Next(0,_availableTasks.Count)];
+                CreateStation(_gameClient.MyTasks[i].Location, StationType.Task, _gameClient.MyTasks[i]);
+            }
+        }
+        private void CreateStation(Position pos, StationType type)
+        {
+            GameObject stationPrefab = null;
+            PlayerRole? reqRole = null;
+            switch (type)
+            {
+                case StationType.Task:
+                    stationPrefab = _stationSettings.TaskStationPrefab;
+                    reqRole = PlayerRole.Crew;
+                    Debug.LogError("Task station creation not fully implemented, using task station prefab as placeholder");
+                    break;
+                case StationType.Sabotage:
+                    stationPrefab = _stationSettings.SabotageStationPrefab;
+                    break;
+                case StationType.Meeting:
+                    stationPrefab = _stationSettings.MeetingStationPrefab;
+                    break;
+                case StationType.Body:
+                    stationPrefab = _stationSettings.BodyStationPrefab;
+                    break;
+                default:
+                    Debug.LogError("Invalid station type");
+                    break;
+            }
+            var station = UnityEngine.Object.Instantiate(stationPrefab);
+            station.transform.position = pos.ToLocalVector3(_gameClient.CurrentLobbyState.MapData.Center);
+            Stations.Add(station);
+            IInteractable interactable = station.GetComponent<IInteractable>();
+            interactable.Location = pos;
+            interactable.InteractionRange = _range;
+            /*Stations = new List<GameObject>();
+            foreach (var task in _gameClient.MyTasks)
+            {
+                System.Random rnd = new System.Random();
+                int index = rnd.Next(0, _availableTasks.Count);
+                var station = UnityEngine.Object.Instantiate(_stationPrefab);
+                ITask TaskSettings = station.GetComponent<ITask>();
+                TaskSettings.TaskID = task.TaskId;
+                TaskSettings.TaskLocation = task.Location;
+                station.transform.position = TaskSettings.TaskLocation.ToLocalVector3(_gameClient.CurrentLobbyState.MapData.Center);
+                station.SetActive(false);
+
+                Stations.Add(station);
+            }*/
+
+        }
+        private void CreateStation(Position pos, StationType type, GameTask taskInfo)
+        {
+            GameObject stationPrefab = _stationSettings.TaskStationPrefab;
+            var station = UnityEngine.Object.Instantiate(stationPrefab);
+            station.transform.position = pos.ToLocalVector3(_gameClient.CurrentLobbyState.MapData.Center);
+            Stations.Add(station);
+            TaskStation interactable = station.GetComponent<TaskStation>();
+            interactable.Location = pos;
+            interactable.InteractionRange = _range;
+            interactable.TaskID = taskInfo.TaskId;
+
+        }
+
+        void CheckForPlayers()
+        {
+            foreach (var player in _gameClient.PlayerPositions.Where(p => p.Value.State == PlayerState.Alive))
+            {
+                if (CheckSightLine(player.Value.Position.ToLocalVector3(_gameClient.CurrentLobbyState.MapData.Center)))
+                {
+                    Debug.Log($"Player {player.Key} is visible");
+                    //TODO: Render player on map
+                }
+                else
+                {
+                    Debug.Log($"Player {player.Key} is not visible");
+                }
+            }
+        }
+    }
+}

Assets/GameManager/GameManager_Game.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: aba57c59fb2a19141a4868fa6a5c924c

Assets/GameManager/GameManager_Input.cs

@@ -0,0 +1,254 @@
+using UnityEngine;
+using GeoSus.Client;
+using System;
+using System.Collections;
+
+namespace Subsystems
+{
+    internal class CoroutineHost : MonoBehaviour
+    {
+        public CoroutineHost() { }
+    }
+    internal enum GPSState
+    {
+        Uninitialized,
+        Initializing,
+        Running,
+        Failed
+    }
+    public static class PositonExtensions
+    {
+        public static Position ToLocal(this Position position, Position center)
+        {
+            double latDiff = position.Lat - center.Lat;
+            double lonDiff = position.Lon - center.Lon;
+            double metersPerDegreeLat = 111320.0;
+            double metersPerDegreeLon = 111320.0 * Math.Cos(center.Lat * Math.PI / 180.0);
+            float x = (float)(lonDiff * metersPerDegreeLon);
+            float z = (float)(latDiff * metersPerDegreeLat);
+            return new Position(z, x); 
+        }
+        public static Vector3 ToLocalVector3(this Position position, Position center)
+        {
+            return position.ToLocal(center).ToVector3(); //TODO: Implementace v subsystemech
+        }
+        public static Vector3 ToVector3(this Position position)
+        {
+            return new Vector3((float)position.Lon, 0, (float)position.Lat); //TODO: Implementace v subsystemech
+        }
+        public static double DistanceTo(this Vector3 pos, Vector3 other)
+        {
+            return Math.Sqrt((other.x - pos.x) * (other.x - pos.x) + (other.z - pos.z) * (other.z - pos.z));
+        }
+
+    }
+
+    public class GameManager_Input
+    {
+        private GameClient _gameClient;
+        private Position _currentPosition;
+        private Position _lastSentPosition;
+        private GameObject _player;
+        private bool _testMode;
+        
+        private GPSState _GPSState = GPSState.Uninitialized;
+        private float _speed = 0.00001f;
+        private Position _mapCenter;
+        private CoroutineHost _coroutineHost = new CoroutineHost();
+        public GameManager_Input(GameClient gameClient, GameObject player, bool testMode)
+        {
+            _gameClient = gameClient;
+            _player = player;
+            _testMode = testMode;
+        }
+        public void positionCheck()
+        {
+            try
+            {
+                if (_gameClient.CurrentLobbyState.Phase == GamePhase.Playing)
+                {
+                    if (_testMode)
+                    {
+
+                        if (_currentPosition == null || _currentPosition == new Position(0, 0))
+                        {
+                            //Init blok
+                            _currentPosition = _gameClient.CurrentLobbyState.MapData.Center;
+                            _mapCenter = _gameClient.CurrentLobbyState.MapData.Center;
+                            _lastSentPosition = _currentPosition;
+                        }
+
+                        TestPlayerPosition();
+                    }
+                    else
+                    {
+                        if (_GPSState == GPSState.Uninitialized)
+                        {
+                            _coroutineHost.StartCoroutine(InitiallizeGPS());
+                            return;
+                        }
+                        else if (_GPSState == GPSState.Initializing)
+                        {
+                            return;
+                        }
+                        else if (_GPSState == GPSState.Running)
+                        {
+                            try
+                            {
+                                if (_currentPosition != _lastSentPosition)
+                                {
+                                    _gameClient.UpdatePosition(_currentPosition);
+                                    _lastSentPosition = _currentPosition;
+                                    _player.transform.position = _currentPosition.ToLocalVector3(_mapCenter);
+                                    _player.transform.rotation = Quaternion.Euler(0, (float)CalculateHeading(_lastSentPosition.ToLocalVector3(_mapCenter), _currentPosition.ToLocalVector3(_mapCenter)), 0);
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                Debug.Log(ex);
+                            }
+                        }
+                        else
+                        {
+                            Debug.Log("GPS failed, trying again...");
+                            _GPSState = GPSState.Uninitialized;
+                        }
+                    }
+                }
+            }
+            catch (NullReferenceException ex) { Debug.Log(ex); }
+        }
+        private void TestPlayerPosition()
+        {
+            double x = Input.GetAxis("Horizontal");
+            double y = Input.GetAxis("Vertical");
+            Debug.Log($"Input: {x}, {y}");
+            _currentPosition = new Position( _lastSentPosition.Lat + y * _speed, _lastSentPosition.Lon + x * _speed);
+            Debug.Log($"Current Position: {_currentPosition.Lat}, {_currentPosition.Lon}");
+            var localCurrent = _currentPosition.ToLocalVector3(_mapCenter);
+            Debug.Log($"Local Current Position: {localCurrent}");
+            var heading = CalculateHeading(_lastSentPosition.ToLocalVector3(_mapCenter), localCurrent);
+            if (heading != null)
+            {
+                Debug.Log($"Heading: {heading}");
+                _player.transform.rotation = Quaternion.Euler(0, (float)heading, 0);
+            }
+            _player.transform.position = localCurrent;
+            try
+            {
+                if (_currentPosition != _lastSentPosition)
+                {
+                    _gameClient.UpdatePosition(_currentPosition);
+                    _lastSentPosition = _currentPosition;
+                }
+            }
+            catch
+            {
+                _gameClient.UpdatePosition(_currentPosition);
+                _lastSentPosition = _currentPosition;
+            }
+        }
+        private double? CalculateHeading(Vector3 first, Vector3 second)
+        {
+            double? heading = null;
+            if ((first - second).magnitude == 0)
+            {
+                return null;
+            }
+            else if (first.x == second.x && first.z < second.z)
+            {
+                return 0;
+            }
+            else if (first.x == second.x && first.z > second.z)
+            {
+                return 180;
+            }
+            else if (first.x > second.x && first.z == second.z)
+            {
+                return 270;
+            }
+            else if (first.x < second.x && first.z == second.z)
+            {
+                return 90;
+            }
+            else if (first.x < second.x && first.z < second.z)
+            {
+                heading = Math.Asin((second.z - first.z) / first.DistanceTo(second));
+                return (heading * 180) / Math.PI;
+            }
+            else if (first.x < second.x && first.z > second.z)
+            {
+                heading = Math.Asin((second.z - first.z) / first.DistanceTo(second));
+                return (heading * 180) / Math.PI + 180;
+            }
+            else if (first.x > second.x && first.z < second.z)
+            {
+                heading = Math.Asin((second.z - first.z) / first.DistanceTo(second));
+                return (heading * 180) / Math.PI - 90;
+            }
+            else if (first.x > second.x && first.z > second.z)
+            {
+                heading = Math.Asin((second.z - first.z) / first.DistanceTo(second));
+                return (heading * 180) / Math.PI - 90;
+            }
+            else
+            {
+                return heading;
+            }
+        }
+        IEnumerator InitiallizeGPS()
+        {
+            _GPSState = GPSState.Initializing;
+            if (!Input.location.isEnabledByUser)
+            {
+                Debug.LogError("Location not enabled on device or app does not have permission to access location");
+            }
+            // Starts the location service.
+
+            float desiredAccuracyInMeters = 10f;
+            float updateDistanceInMeters = 10f;
+
+            Input.location.Start(desiredAccuracyInMeters, updateDistanceInMeters);
+
+            // Waits until the location service initializes
+            int maxWait = 20;
+            while (Input.location.status == LocationServiceStatus.Initializing && maxWait > 0)
+            {
+                yield return new WaitForSeconds(1);
+                maxWait--;
+            }
+
+            // If the service didn't initialize in 20 seconds this cancels location service use.
+            if (maxWait < 1)
+            {
+                _GPSState = GPSState.Failed;
+                Debug.LogError("Timed out");
+                yield break;
+            }
+            _GPSState = GPSState.Running;
+            yield return _coroutineHost.StartCoroutine(GPSService());
+        }
+        IEnumerator GPSService()
+        {
+            // Check if the user has location service enabled.
+
+
+            // If the connection failed this cancels location service use.
+            if (Input.location.status == LocationServiceStatus.Failed)
+            {
+                Debug.LogError("Unable to determine device location");
+                yield break;
+            }
+            else
+            {
+                // If the connection succeeded, this retrieves the device's current location and displays it in the Console window.
+                _currentPosition = new Position(Input.location.lastData.latitude, Input.location.lastData.longitude);
+                Debug.Log("Location: " + Input.location.lastData.latitude + " " + Input.location.lastData.longitude + " " + Input.location.lastData.altitude + " " + Input.location.lastData.horizontalAccuracy + " " + Input.location.lastData.timestamp);
+                yield return new WaitForSeconds(5f);
+            }
+
+            // Stops the location service if there is no need to query location updates continuously.
+            yield return _coroutineHost.StartCoroutine(GPSService());
+        }
+    }
+}

Assets/GameManager/GameManager_Input.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2ef1abfb1e85a7943925f9dc3cfea742

Assets/GameManager/GameManager_Map.cs

@@ -0,0 +1,381 @@
+using GeoSus.Client;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Localization.Pseudo;
+using UnityEngine.UI;
+
+
+namespace Subsystems{
+    [System.Serializable]
+    public class BuildingSettings
+    {
+        public Material ResidentalBuildingsMat;
+        public float ResidentalBuildingHeight;
+        public Material CommercialBuildingsMat;
+        public float CommercialBuildingHeight;
+        public Material IndustrialBuildingsMat;
+        public float IndustrialBuildingHeight;
+        public Material DefaultBuildingMat;
+        public float DefaultBuildingHeight;
+    }
+    [System.Serializable]
+    public class PathwaySettings
+    {
+        public Material FootwayMat;
+        public float FootwayWidth;
+        public Material PathMat;
+        public float PathWidth;
+        public Material StepsMat;
+        public float StepsWidth;
+        public Material CyclewayMat;
+        public float CyclewayWidth;
+        public Material PedestrianMat;
+        public float PedestrianWidth;
+        public Material RoadMat;
+        public float RoadWidth;
+        public Material ServiceMat;
+        public float ServiceWidth;
+        public Material ResidentialMat;
+        public float ResidentialWidth;
+        public Material TrackMat;
+        public float TrackWidth;
+        public Material DefaultMat;
+        public float DefaultWidth;
+    }
+    [System.Serializable]
+    public class AreaSettings
+    {
+        public Material ParkMat;
+        public Material GardenMat;
+        public Material PlaygroundMat;
+        public Material ForestMat;
+        public Material GrassMat;
+        public Material WaterMat;
+        public Material DefaultMat;
+    }
+    public class GameManager_Map
+    {
+        private GameClient _gameClient;
+        private GameObject _mapCenterPoint;
+        private Position _centerPosition;
+        private BuildingSettings _buildingSettings;
+        private PathwaySettings _pathwaySettings;
+        private AreaSettings _areaSettings;
+        private const float _metersPerUnit = 1f; 
+        public GameManager_Map(GameClient gameClient, GameObject mapCenterPoint, BuildingSettings buildingSettings, PathwaySettings pathwaySettings, AreaSettings areaSettings)
+        {
+            _gameClient = gameClient;
+            _mapCenterPoint = mapCenterPoint;
+            _buildingSettings = buildingSettings;
+            _pathwaySettings = pathwaySettings;
+            _areaSettings = areaSettings;
+        }
+        public void BuildMap()
+        {
+            ClearChildren();
+            _centerPosition = _gameClient.CurrentLobbyState.MapData.Center;
+            GameObject buildingsRoot = new GameObject("Buildings");
+            buildingsRoot.transform.parent = _mapCenterPoint.transform;
+
+            GameObject pathRoot = new GameObject("Pathways");
+            pathRoot.transform.parent = _mapCenterPoint.transform;
+
+            GameObject areaRoot = new GameObject("Areas");
+            areaRoot.transform.parent = _mapCenterPoint.transform;
+
+            foreach (var building in _gameClient.CurrentLobbyState.MapData.GetBuildings())
+            {
+                string buildingType = "Unknown";
+                try
+                {
+                    buildingType = _gameClient.CurrentLobbyState.MapData.BuildingTypes[_gameClient.CurrentLobbyState.MapData.GetBuildings().IndexOf(building)];
+                }
+                catch (Exception ex) { Debug.Log($"Error: {ex.Message}"); }
+                building.Name = buildingType;
+                GameObject b = BuildBuildingMesh(building);
+                b.transform.parent = buildingsRoot.transform;
+            }
+            foreach (var path in _gameClient.CurrentLobbyState.MapData.GetPathways())
+            {
+                GameObject p = BuildPathwayMesh(path);
+                p.transform.parent = pathRoot.transform;
+            }
+            foreach (var area in _gameClient.CurrentLobbyState.MapData.GetAreas())
+            {
+                GameObject a = BuildAreaMesh(area);
+                a.transform.parent = areaRoot.transform;
+            }
+            //TODO: POIs
+        }
+        void ClearChildren()
+        {
+            List<GameObject> toDestroy = new List<GameObject>();
+            foreach (Transform t in _mapCenterPoint.transform)
+                toDestroy.Add(t.gameObject);
+            foreach (var g in toDestroy)
+            {
+                UnityEngine.Object.DestroyImmediate(g);
+            }
+        }
+        #region Mesh Building
+        GameObject BuildBuildingMesh(MapBuilding b)
+        {
+            var building = new GameObject($"Building_{b.Name ?? "Unknown"}");
+
+            // Výpočet středu budovy
+            Vector3 center = CalculatePolygonCenter(b.Outline);
+            building.transform.position = center;
+
+            // Vytvoření mesh pro budovu
+            MeshFilter meshFilter = building.AddComponent<MeshFilter>();
+            MeshRenderer meshRenderer = building.AddComponent<MeshRenderer>();
+            MeshCollider meshCollider = building.AddComponent<MeshCollider>();
+            building.tag = "Map";
+
+            float height;
+            Material mat;
+            switch (b.BuildingType.ToLower())
+            {
+                case "residential":
+                    mat = _buildingSettings.ResidentalBuildingsMat;
+                    height = _buildingSettings.ResidentalBuildingHeight;
+                    break;
+                case "commercial":
+                    mat = _buildingSettings.CommercialBuildingsMat;
+                    height = _buildingSettings.CommercialBuildingHeight;
+                    break;
+                case "industrial":
+                    mat = _buildingSettings.IndustrialBuildingsMat;
+                    height = _buildingSettings.IndustrialBuildingHeight;
+                    break;
+                default:
+                    mat = _buildingSettings.DefaultBuildingMat;
+                    height = _buildingSettings.DefaultBuildingHeight;
+                    break;
+            }
+            Mesh mesh = CreateExtrudedPolygonMesh(b.Outline, height);
+            meshFilter.mesh = mesh;
+            meshCollider.sharedMesh = mesh;
+
+            //TODO: material by type
+            // Použijeme barvu podle typu budovy
+            meshRenderer.material = mat;
+
+            // Přidání collideru pro interakci
+            building.AddComponent<MeshCollider>();
+            return building;
+        }
+        GameObject BuildPathwayMesh(MapPathway w)
+        {
+            var path = new GameObject($"Path_{w.Name ?? "Unknown"}");
+            path.tag = "Map";
+
+            // Použijeme LineRenderer pro jednoduchost
+            LineRenderer line = path.AddComponent<LineRenderer>();
+            float width;
+            Material mat;
+            
+            switch (w.PathType)
+            {
+                case PathType.Footway:
+                    mat = _pathwaySettings.FootwayMat;
+                    width = _pathwaySettings.FootwayWidth;
+                    break;
+                case PathType.Path:
+                    mat = _pathwaySettings.PathMat;
+                    width = _pathwaySettings.PathWidth;
+                    break;
+                case PathType.Steps:
+                    mat = _pathwaySettings.StepsMat;
+                    width = _pathwaySettings.PathWidth;
+                    break;
+                case PathType.Cycleway:
+                    mat = _pathwaySettings.CyclewayMat;
+                    width = _pathwaySettings.CyclewayWidth;
+                    break;
+                case PathType.Pedestrian:
+                    mat = _pathwaySettings.PedestrianMat;
+                    width = _pathwaySettings.PedestrianWidth;
+                    break;
+                case PathType.Road:
+                    mat = _pathwaySettings.RoadMat;
+                    width = _pathwaySettings.RoadWidth;
+                    break;
+                case PathType.Service:
+                    mat = _pathwaySettings.ServiceMat;
+                    width = _pathwaySettings.ServiceWidth;
+                    break;
+                case PathType.Residential:
+                    mat = _pathwaySettings.ResidentialMat;
+                    width = _pathwaySettings.ResidentialWidth;
+                    break;
+                case PathType.Track:
+                    mat = _pathwaySettings.TrackMat;
+                    width = _pathwaySettings.TrackWidth;
+                    break;
+                default:
+                    mat = _pathwaySettings.DefaultMat;
+                    width = _pathwaySettings.DefaultWidth;
+                    break;
+            }
+
+            line.material = mat;
+            line.widthMultiplier = width;
+
+            // Nastavení bodů cesty
+            line.positionCount = w.Points.Count;
+            for (int i = 0; i < w.Points.Count; i++)
+            {
+                Vector3 pos = w.Points[i].ToLocalVector3(_gameClient.CurrentLobbyState.MapData.Center);
+                pos.y = 0.1f; // Mírně nad zemí
+                line.SetPosition(i, pos);
+            }
+            return path;
+        }
+        GameObject BuildAreaMesh(MapArea a)
+        {
+            var area = new GameObject($"Area_{a.Name ?? "Unknown"}");
+            area.tag = "Map";
+
+            MeshFilter meshFilter = area.AddComponent<MeshFilter>();
+            MeshRenderer meshRenderer = area.AddComponent<MeshRenderer>();
+
+            // Vytvoření plochého mesh
+            Mesh mesh = CreateFlatPolygonMesh(a.Outline);
+            meshFilter.mesh = mesh;
+
+            
+            Material mat;
+            switch (a.AreaType)
+            {
+                case MapAreaType.Park:
+                    mat = _areaSettings.ParkMat;
+                    break;
+                case MapAreaType.Garden:
+                    mat = _areaSettings.GardenMat;
+                    break;
+                case MapAreaType.Playground:
+                    mat = _areaSettings.PlaygroundMat;
+                    break;
+                case MapAreaType.Forest:
+                    mat = _areaSettings.ForestMat;
+                    break;
+                case MapAreaType.Grass:
+                    mat = _areaSettings.GrassMat;
+                    break;
+                case MapAreaType.Water:
+                    mat = _areaSettings.WaterMat;
+                    break;
+                default:
+                    mat = _areaSettings.DefaultMat;
+                    break;
+            }
+            
+            meshRenderer.material = mat;
+
+            area.transform.position = new Vector3(0, 0.05f, 0); // Těsně nad zemí
+
+            return area;
+        }
+        //TODO: POIs
+        #endregion
+        #region Polygon Utils
+        private Vector3 CalculatePolygonCenter(List<Position> points)
+        {
+            Vector3 center = Vector3.zero;
+            foreach (var point in points)
+            {
+                center += point.ToLocalVector3(_gameClient.CurrentLobbyState.MapData.Center);
+            }
+            return center / points.Count;
+        }
+        private Mesh CreateExtrudedPolygonMesh(List<Position> outline, float height)
+        {
+            Mesh mesh = new Mesh();
+
+            int vertexCount = outline.Count;
+
+            // Vertices - spodní a horní podstava
+            Vector3[] vertices = new Vector3[vertexCount * 2];
+            Vector3 center = CalculatePolygonCenter(outline);
+
+            for (int i = 0; i < vertexCount; i++)
+            {
+                Vector3 pos = outline[i].ToLocalVector3(_gameClient.CurrentLobbyState.MapData.Center) - center;
+                vertices[i] = pos; // Spodní
+                vertices[i + vertexCount] = pos + Vector3.up * height; // Horní
+            }
+
+            // Triangles - jen boční stěny pro jednoduchost
+            List<int> triangles = new List<int>();
+
+            for (int i = 0; i < vertexCount; i++)
+            {
+                int next = (i + 1) % vertexCount;
+
+                // Boční stěna - dva trojúhelníky
+                triangles.Add(i);
+                triangles.Add(i + vertexCount);
+                triangles.Add(next);
+
+                triangles.Add(next);
+                triangles.Add(i + vertexCount);
+                triangles.Add(next + vertexCount);
+            }
+
+            // Horní podstava - zjednodušená triangulace (fan)
+            if (vertexCount >= 3)
+            {
+                for (int i = 1; i < vertexCount - 1; i++)
+                {
+                    triangles.Add(vertexCount); // Střed (první bod horní)
+                    triangles.Add(vertexCount + i);
+                    triangles.Add(vertexCount + i + 1);
+                }
+            }
+
+            mesh.vertices = vertices;
+            mesh.triangles = triangles.ToArray();
+            mesh.RecalculateNormals();
+            mesh.RecalculateBounds();
+
+            return mesh;
+        }
+        private Mesh CreateFlatPolygonMesh(List<Position> outline)
+        {
+            Mesh mesh = new Mesh();
+
+            int vertexCount = outline.Count;
+            Vector3[] vertices = new Vector3[vertexCount];
+            Vector3 center = CalculatePolygonCenter(outline);
+
+            for (int i = 0; i < vertexCount; i++)
+            {
+                vertices[i] = outline[i].ToLocalVector3(_gameClient.CurrentLobbyState.MapData.Center) - center;
+            }
+
+            // Triangulace - fan pattern
+            List<int> triangles = new List<int>();
+            if (vertexCount >= 3)
+            {
+                for (int i = 1; i < vertexCount - 1; i++)
+                {
+                    triangles.Add(0);
+                    triangles.Add(i);
+                    triangles.Add(i + 1);
+                }
+            }
+
+            mesh.vertices = vertices;
+            mesh.triangles = triangles.ToArray();
+            mesh.RecalculateNormals();
+
+            return mesh;
+        }
+        #endregion
+    }
+}

Assets/GameManager/GameManager_Map.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 71870ee18b89dd7438e5362ff9e02a3b

Assets/GameManager/GameManager_Network.cs

@@ -2,6 +2,9 @@ using GeoSus.Client;
 using System.Collections;
 using System.Threading.Tasks;
 using UnityEngine;
+using System.Collections.Generic;
+using Subsystems;
+using System.Linq;
 
 namespace Subsystems
 {
@@ -10,6 +13,7 @@ namespace Subsystems
         private const string _serverAddress = "geosus.honzuvkod.dev";
         private const int _serverPort = 7777;
         private GameClient _gameClient;
+        private GameManager_Map _mapSubsystem;
         public async void OpenConection()
         {
             while (true)
@@ -78,14 +82,35 @@ namespace Subsystems
         }
         private void OnGameEvent(GameEvent gameEvent)
         {
-            switch (gameEvent.Type)
+            switch (gameEvent.EventType)
             {
                 case "PlayerJoined":
                     Debug.Log($"Player {gameEvent.GetPayload<PlayerJoinedPayload>().DisplayName} joined");
-                    HandlePlayerJoined(gameEvent);
+                    break;
+                case "PlayerLeft":
+                    Debug.Log($"Player {gameEvent.GetPayload<PlayerLeftPayload>()} left");
+                    break;
+                case "GameStarting":
+                    Debug.Log("Game is starting!");
+                    break;
+                case "GameStarted":
+                    Debug.Log("Game started");
+                    break;
+                case "MapDataReady":
+                    Debug.Log("Map data ready");
+                    break;
+                case "PlayerMapDataReceived":
+                    Debug.Log("Player map data recieved");
+                    break;
+                case "MapDataError":
+                    Debug.Log("Received MapData server error");
+                    break;
+                case "SabotageStarted":
+                    Debug.Log("Sabotage started");
+                    HandleSabotageStarted(gameEvent);
                     break;
                 default:
-                    Debug.Log("Received GameEvent of type: " + gameEvent.Type);
+                    Debug.Log("Received GameEvent of type: " + gameEvent.EventType);
                     break;
             }
         }
@@ -111,20 +136,6 @@ namespace Subsystems
                 Debug.LogError("Failed to create lobby: " + message.Error);
             }
         }
-        private void HandlePlayerJoined(GameEvent gameEvent)
-        {
-            var payload = gameEvent.GetPayload<PlayerJoinedPayload>();
-            _gameClient.CurrentLobbyState.Players.Add(new PlayerInfo
-            {
-                ClientUuid = payload.ClientUuid,
-                DisplayName = payload.DisplayName,
-                IsOwner = false,
-                IsReady = false,
-                State = PlayerState.Alive
-            });
-        }
-
-
         public void CrateLobby(double lat, double lon)
         {
             _gameClient.CreateLobby(new Position(lat, lon));
@@ -145,8 +156,41 @@ namespace Subsystems
             _gameClient.Disconnect();
             Application.Quit();
         }
+        public void StartGame()
+        {
+            _gameClient.StartGame();
 
+        }
+        #region GameEvent Handlers
+        private void HandleSabotageStarted(GameEvent gameEvent)
+        {
+            SabotageStartedPayload payload = gameEvent.GetPayload<SabotageStartedPayload>();
+            switch (payload.Type)
+            {
+                case SabotageType.CommsBlackout:
+                    for(int i  = 0;i < payload.RequiredSimultaneousRepairs; i++)
+                    {
+                        //create stations
+                    }
+                    //Ui.alert
+                    //DisableComms
+                    return;
+                case SabotageType.CriticalMeltdown:
+                    for (int i = 0; i < payload.RequiredSimultaneousRepairs; i++)
+                    {
+                        //create stations
+                    }
+                    //UI.alert
+                    //UI Time remain
+                    return;
+
+                default:
+                    Debug.Log($"Sabotage of unknown type: {payload.Type}");
+                    return;
 
             }
         }
+        #endregion
+    }
+}
 

Assets/GameManager/GameManager_Network.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9c2032ed1184ad7418cc415edf97b69e

Assets/GameManager/GameManager_UI.cs

@@ -2,7 +2,7 @@ using UnityEngine;
 using Subsystems;
 using GeoSus.Client;
 using System.ComponentModel;
-
+using System.Threading;
 
 namespace Subsystems
 {
@@ -11,15 +11,39 @@ namespace Subsystems
         private GameClient _gameClient;
         private Canvas _CreateJoinLobby;
         private Canvas _InLobby;
-        public GameManager_UI(GameClient gameClient, Canvas CreateJoinLobby, Canvas InLobby)
+        private Canvas _LoadingScreen;
+        private Canvas _GameScreen;
+        public GameManager_UI(GameClient gameClient, Canvas CreateJoinLobby, Canvas InLobby, Canvas LoadingScreen, Canvas GameScreen)
         {
             _gameClient = gameClient;
             _CreateJoinLobby = CreateJoinLobby;
+            _LoadingScreen = LoadingScreen;
+            _GameScreen = GameScreen;
             _InLobby = InLobby;
             _CreateJoinLobby.enabled = true;
             _InLobby.enabled = false;
+            _GameScreen.enabled = false;
+            _LoadingScreen.enabled = false;
         }
         public void UpdateLobbyUI()
+        {
+            if (_gameClient.CurrentLobbyState == null)
+            {
+                _CreateJoinLobby.enabled = true;
+                _InLobby.enabled = false;
+                _GameScreen.enabled = false;
+                _LoadingScreen.enabled = false;
+                return;
+            }
+            else if (_gameClient.CurrentLobbyState.Phase == GamePhase.Loading)
+            {
+                _CreateJoinLobby.enabled = false;
+                _InLobby.enabled = false;
+                _GameScreen.enabled = false;
+                _LoadingScreen.enabled = true;
+                return;
+            }
+            else if (_gameClient.CurrentLobbyState.Phase == GamePhase.Lobby)
             {
                 _InLobby.enabled = true;
                 _CreateJoinLobby.enabled = false;
@@ -30,6 +54,18 @@ namespace Subsystems
                     playerList.text += player.DisplayName + "\n";
                 }
                 _InLobby.transform.Find("JoinCode").GetComponent<TMPro.TMP_Text>().text = _gameClient.CurrentLobbyState.JoinCode;
+                return;
+            }
+            else if (_gameClient.CurrentLobbyState.Phase == GamePhase.Playing)
+            {
+                _CreateJoinLobby.enabled = false;
+                _InLobby.enabled = false;
+                _GameScreen.enabled = true;
+                _LoadingScreen.enabled = false;
+                _GameScreen.transform.Find("Role").GetComponent<TMPro.TMP_Text>().text = _gameClient.MyRole.ToString() ;
+                return;
+            }
+            
         }
     }
 }

Assets/GameManager/GameManager_UI.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f575016e02384774d88b46ed7f09579f

Assets/GameManager/Interfaces.cs

@@ -2,20 +2,24 @@ using GeoSus.Client;
 using System;
 using UnityEngine;
 
-public enum TaskType
+/*public enum TaskType
 {
     Task //TODO: Typy úkolù
+}*/
+[System.Serializable]
+public class TaskData
+{
+    //TaskType
+    public GameObject TaskPrefab;
 }
-
-
-
 public interface ITask
 {
-    public string TaskID { get; } // Unikátní ID úkolu pro server
+    public string TaskID { get; set; } // Unikátní ID úkolu pro server
-    public TaskType TaskType { get; } // Typ úkolu
+    public TaskType TaskType { get; set; } // Typ úkolu
-    public string TaskName { get; } // Viditelný název úkolu
+    public string TaskName { get; set; } // Viditelný název úkolu
-    public (double, double) TaskLocation { get; } // Polohy na mapì
+    public Position TaskLocation { get; set; } // Polohy na mapì
-    public bool IsCompleted { get; } // Stav dokonèení úkolu
+    public bool IsCompleted { get; } // Stav dokončení úkolu
+
 
     void Initialize(Action<ITask> onCompleted); // Vytvoøení tasku + naètení postupu
     void ExitTask(Action<ITask> onExit); // Pøi opuštìní úkolu poslat hotovo / uložit postup / reset
@@ -27,7 +31,7 @@ public class Wires : ITask{
     public string TaskID { get; set; } // Unikátní ID úkolu pro server
     public TaskType TaskType { get; set; } // Typ úkolu
     public string TaskName { get; set; } // Viditelný název úkolu
-    public (double, double) TaskLocation { get; set; } // Poloha na mapì
+    public Position TaskLocation { get; set; } // Poloha na mapì
     public bool IsCompleted { get; private set; } // Stav dokonèení úkolu
     private Action<ITask> _onCompleted; 
 
@@ -35,6 +39,7 @@ public class Wires : ITask{
     {
         IsCompleted = false;
         _onCompleted = onCompleted;
+
     }
     public void ExitTask(Action<ITask> onExit) //Zavøení tasku
     {
@@ -51,3 +56,18 @@ public class Wires : ITask{
 
 }
 */
+public enum StationType
+{
+    Sabotage,
+    Task,
+    Meeting,
+    Body
+}
+public interface IInteractable
+{
+    public StationType Type { get; set; } // Typ stanice
+    public Position Location { get; set; } // Pozice na mapě
+    public PlayerRole? ReqRole { get; set; } // Požadovaná role hráče Impostor / Crewmate / Any = null
+    public float InteractionRange { get; set; } // Dosah interakce
+    void Interact(PlayerRole role); // Spuštění interakce
+}

Assets/GameManager/Interfaces.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8e926b313c00d4f48ad68750c88817bf

Assets/GameManager/Stations.cs

@@ -0,0 +1,83 @@
+using GeoSus.Client;
+using System;
+using UnityEngine;
+using System.Linq;  
+
+public class Station : IInteractable
+{
+    public StationType Type { get; set; }
+    public Position Location { get; set; }
+    public PlayerRole? ReqRole { get; set; }
+    public float InteractionRange { get; set; }
+    protected GameObject interfaceInstance;
+    public GameObject Interface { get; set; } // Prefab pro interakci (napø. UI pro úkol nebo sabotáže)
+
+    public virtual void Interact(PlayerRole role)
+    {
+        if (ReqRole.HasValue && role != ReqRole.Value)
+        {
+            Debug.Log("You do not have the required role to interact with this station.");
+            return;
+        }
+        else
+        {
+            interfaceInstance = UnityEngine.Object.Instantiate(Interface); // Zobrazí interakèní UI
+        }
+
+
+    }
+    public Station(Position location, float interactionRange)
+    {
+        Location = location;
+        InteractionRange = interactionRange;
+    }
+}
+public class TaskStation : Station
+{
+    public string TaskID { get; set; } // Unikátní ID úkolu pro server
+    private GameClient _gameClient;
+    public TaskStation(Position pos, float interactionRange, GameClient gameClient, string taskID) : base(pos, interactionRange)
+    {
+        Type = StationType.Task;
+        ReqRole = PlayerRole.Crew;
+        _gameClient = gameClient;
+    }
+    public ITask Task { get; set; }
+    public override void Interact(PlayerRole role)
+    {
+        if(interfaceInstance != null)
+        {
+            ResumeTask();
+            return;
+        }
+        base.Interact(role);
+        Task = interfaceInstance.GetComponent<ITask>();
+        Task.TaskID = TaskID;
+        Task.Initialize(OnTaskCompleted);
+    }
+    private void ResumeTask()
+    {
+        interfaceInstance.SetActive(true); // Zobrazí interakèní UI
+    }
+    private void OnTaskCompleted(ITask task)
+    {
+        _gameClient.CompleteTask(task.TaskID);
+        task.ExitTask(OnTaskExit);
+        Debug.Log($"Task {task.TaskName} completed and sent to server.");
+    }
+    private void OnTaskExit(ITask task)
+    {   
+        if (task.IsCompleted)
+        {
+            UnityEngine.Object.Destroy(interfaceInstance); // Znièí interakèní UI
+            Debug.Log($"Task {task.TaskName} completed and sent to server.");
+        }
+        else
+        {
+            interfaceInstance.SetActive(false); // Skryje interakèní UI
+            Debug.Log($"Task {task.TaskName} was not completed, but exited.");
+        }
+
+    }
+
+}

Assets/GameManager/Stations.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 0ca1825585bf9bc42bd3b11985048465

Assets/GameManager/TestMaterial.mat

@@ -0,0 +1,92 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: TestMaterial
+  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AlphaTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - PixelSnap: 0
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _EnableExternalAlpha: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _Flip: {r: 1, g: 1, b: 1, a: 1}
+    - _RendererColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1

Assets/GameManager/TestMaterial.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6744524496c8e1549882277283c132cc
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/InputSystem_Actions.inputactions.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 832a89cb6f62a5240a99d84d09f0a0eb
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scenes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fa2dc9f32b7ad7c419b06e4ad6866e09
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scenes/Client.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8f736798e2d13f14f903b26a2df0eed8
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scenes/SampleScene.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3e95f16d8e50b3341925e51e50768027
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scenes/scene.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: facb9eb5d6c7d484097d6167562da786
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 59d02e797bf2bf54e8b2aa0c7e0d4c87
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/GPSManager.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2d992ef55bc28784f81e79dd5cca414b

Assets/Scripts/IMapDataCollector.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8cf96fedb0da0ff4f947cad1c84e352b

Assets/Scripts/MapRenderer.cs

@@ -34,7 +34,7 @@ public class MapRenderer : MonoBehaviour
 
 
     [Header("Misc")]
-    public float metersPerUnit = 1f; // scale: 1 unit = 1 meter
+    public float _metersPerUnit = 1f; // scale: 1 unit = 1 meter
 
 
     [Header("Storage")]
@@ -172,7 +172,7 @@ public class MapRenderer : MonoBehaviour
         double R = 6378137.0; // Earth radius in meters
         double x = R * dLon * Math.Cos(lat0 * Mathf.Deg2Rad);
         double y = R * dLat;
-        return new Vector3((float)x / metersPerUnit, 0f, (float)y / metersPerUnit);
+        return new Vector3((float)x / _metersPerUnit, 0f, (float)y / _metersPerUnit);
     }
     Vector3 NodeIdToLocal(long nodeId)
     {
@@ -258,9 +258,9 @@ public class MapRenderer : MonoBehaviour
             Vector2 p2 = poly2D[idx2];
 
             int baseIdx = verts.Count;
-            verts.Add(new Vector3(p0.x, height / metersPerUnit, p0.y));
+            verts.Add(new Vector3(p0.x, height / _metersPerUnit, p0.y));
-            verts.Add(new Vector3(p1.x, height / metersPerUnit, p1.y));
+            verts.Add(new Vector3(p1.x, height / _metersPerUnit, p1.y));
-            verts.Add(new Vector3(p2.x, height / metersPerUnit, p2.y));
+            verts.Add(new Vector3(p2.x, height / _metersPerUnit, p2.y));
 
             triangles.Add(baseIdx);
             triangles.Add(baseIdx + 1);
@@ -279,10 +279,10 @@ public class MapRenderer : MonoBehaviour
             Vector2 p1 = poly2D[iNext];
 
             int baseIdx = verts.Count;
-            verts.Add(new Vector3(p0.x, height / metersPerUnit, p0.y)); // top left
+            verts.Add(new Vector3(p0.x, height / _metersPerUnit, p0.y)); // top left
             verts.Add(new Vector3(p0.x, 0, p0.y)); // bottom left
             verts.Add(new Vector3(p1.x, 0, p1.y)); // bottom right
-            verts.Add(new Vector3(p1.x, height / metersPerUnit, p1.y)); // top right
+            verts.Add(new Vector3(p1.x, height / _metersPerUnit, p1.y)); // top right
 
             triangles.Add(baseIdx);
             triangles.Add(baseIdx + 1);
@@ -369,8 +369,8 @@ public class MapRenderer : MonoBehaviour
             else dir = (pts[i + 1] - pts[i - 1]).normalized;
 
             Vector3 normal = Vector3.Cross(dir, Vector3.up).normalized;
-            Vector3 left = p + normal * (width * 0.5f / metersPerUnit);
+            Vector3 left = p + normal * (width * 0.5f / _metersPerUnit);
-            Vector3 right = p - normal * (width * 0.5f / metersPerUnit);
+            Vector3 right = p - normal * (width * 0.5f / _metersPerUnit);
             verts.Add(left);
             verts.Add(right);
             uvs.Add(new Vector2(0, i));

Assets/Scripts/MapRenderer.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 648d9484af013c346bd5ae603a8c7185

Assets/Scripts/TestMaterial.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 950ad2ddcd752c84a92eec2603508248
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Settings.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5a64c672ea90b0f47aa9765ef8cd36bf
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Settings/Build Profiles.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9fd22110cecc9764db443475c88fb5f8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Settings/Build Profiles/Android™.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1a0d4317fa56b6f4ca3cc36db322f632
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Settings/DefaultVolumeProfile.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8dda0318c5f0774428ff048cf1cc7903
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Settings/Mobile_RPAsset.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1b1d1c584534f0943bd7782382ca724d
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Settings/Mobile_Renderer.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 16789ecfba5bb8b4f9ffe2a76899c9a0
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Settings/PC_RPAsset.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 32964dc92131b7640be075f3a6fba255
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Settings/PC_Renderer.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9c16494a2393df0429ba240dbfde961b
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Settings/SampleSceneProfile.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: abb54dd1945d1f747981a246f46dfdb4
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Settings/UniversalRenderPipelineGlobalSettings.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 01963b65aa570034185cb6e241239ba7
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f54d1bd14bd3ca042bd867b519fee8cc
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ce51c8e33b734b4db6086586558c53a3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b63e0053080646b9819789bf3bf9fa17
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Anton OFL.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 73a79399807f4e8388c2cbb5494681ca
+timeCreated: 1484172033
+licenseType: Pro
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Anton.ttf.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 997a43b767814dd0a7642ec9b78cba41
+timeCreated: 1484172033
+licenseType: Pro
+TrueTypeFontImporter:
+  serializedVersion: 2
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 1
+  characterPadding: 0
+  includeFontData: 1
+  use2xBehaviour: 0
+  fontNames: []
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Bangers - OFL.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: efe0bf4ac872451e91612d1ae593f480
+timeCreated: 1484171296
+licenseType: Pro
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Bangers.ttf.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 5dd49b3eacc540408c98eee0de38e0f1
+timeCreated: 1484171297
+licenseType: Pro
+TrueTypeFontImporter:
+  serializedVersion: 2
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 1
+  characterPadding: 0
+  includeFontData: 1
+  use2xBehaviour: 0
+  fontNames: []
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Electronic Highway Sign.TTF.meta

@@ -0,0 +1,22 @@
+fileFormatVersion: 2
+guid: 8a2b9e2a607dd2143b58c44bc32410b4
+TrueTypeFontImporter:
+  externalObjects: {}
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontName: Electronic Highway Sign
+  fontNames:
+  - Electronic Highway Sign
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  useLegacyBoundsCalculation: 0
+  shouldRoundAdvanceValue: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Oswald-Bold - OFL.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d2cf87a8a7a94aa8b80dff1c807c1178
+timeCreated: 1484171296
+licenseType: Pro
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Oswald-Bold.ttf.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: c9f6d0e7bc8541498c9a4799ba184ede
+timeCreated: 1484171297
+licenseType: Pro
+TrueTypeFontImporter:
+  serializedVersion: 2
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 1
+  characterPadding: 0
+  includeFontData: 1
+  use2xBehaviour: 0
+  fontNames: []
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Roboto-Bold - AFL.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f28c334d44214474d9702d3ad79ecb0a
+timeCreated: 1484171296
+licenseType: Pro
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Roboto-Bold - License.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f0303f887b8fa7243a51432c478ff2f3
+timeCreated: 1484171296
+licenseType: Pro
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Roboto-Bold.ttf.meta

@@ -0,0 +1,22 @@
+fileFormatVersion: 2
+guid: 4beb055f07aaff244873dec698d0363e
+TrueTypeFontImporter:
+  externalObjects: {}
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontName: Roboto
+  fontNames:
+  - Roboto
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  useLegacyBoundsCalculation: 0
+  shouldRoundAdvanceValue: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Unity - OFL.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0251f66ebc602a944b35bccd13be2738
+timeCreated: 1484171296
+licenseType: Pro
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Fonts/Unity.ttf.meta

@@ -0,0 +1,21 @@
+fileFormatVersion: 2
+guid: f4eec857a4fdf2f43be0e9f3d1a984e7
+TrueTypeFontImporter:
+  externalObjects: {}
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontNames:
+  - Unity
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  useLegacyBoundsCalculation: 0
+  shouldRoundAdvanceValue: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Materials.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 5808953df7a24274a851aa6dee52d30e
+folderAsset: yes
+timeCreated: 1436068007
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Materials/Crate - Surface Shader Scene.mat.meta

@@ -0,0 +1,6 @@
+fileFormatVersion: 2
+guid: e6b9b44320f4448d9d5e0ee634259966
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Materials/Crate - URP.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3b5cc91c3bf8cf74391252247f52fb59
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Materials/Ground - Logo Scene.mat.meta

@@ -0,0 +1,6 @@
+fileFormatVersion: 2
+guid: c719e38f25a9480abd2480ab621a2949
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Materials/Ground - Surface Shader Scene.mat.meta

@@ -0,0 +1,6 @@
+fileFormatVersion: 2
+guid: aadd5a709a48466c887296bb5b1b8110
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Materials/Ground - URP.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 71529b88994c1a341b22bc57c038674a
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Materials/Small Crate_diffuse.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 22262639920f43d6be32430e4e58350d
+timeCreated: 1473643741
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Prefabs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 5bff2544887143f5807c7d5059d07f79
+folderAsset: yes
+timeCreated: 1436068007
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Prefabs/Text Popup.prefab.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b06f0e6c1dfa4356ac918da1bb32c603
+timeCreated: 1435130987
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Prefabs/TextMeshPro - Prefab 1.prefab.meta

@@ -0,0 +1,6 @@
+fileFormatVersion: 2
+guid: a6e39ced0ea046bcb636c3f0b2e2a745
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Prefabs/TextMeshPro - Prefab 2.prefab.meta

@@ -0,0 +1,6 @@
+fileFormatVersion: 2
+guid: fdad9d952ae84cafb74c63f2e694d042
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: d6d3a169ad794942a21da6a552d62f6f
+folderAsset: yes
+timeCreated: 1436068007
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Color Gradient Presets.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7f422cd1388b01047a58cd07c7a23d9d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Color Gradient Presets/Blue to Purple - Vertical.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 479a66fa4b094512a62b0a8e553ad95a
+timeCreated: 1468189245
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Color Gradient Presets/Dark to Light Green - Vertical.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4c86a3366cd840348ebe8dc438570ee4
+timeCreated: 1468443381
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Color Gradient Presets/Light to Dark Green - Vertical.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5cf8ae092ca54931b443bec5148f3c59
+timeCreated: 1468443381
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Color Gradient Presets/Yellow to Orange - Vertical.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 69a525efa7e6472eab268f6ea605f06e
+timeCreated: 1468213165
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4f1e85c79acf49968737939ce8b445c7
+folderAsset: yes
+timeCreated: 1436068007
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Anton SDF - Drop Shadow.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 749b9069dc4742c5bfa5c74644049926
+timeCreated: 1484173523
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Anton SDF - Outline.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a00013af81304728b2be1f4309ee2433
+timeCreated: 1484173536
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Anton SDF - Sunny Days.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6522f30e342599e4e9dd4cc2cc03c830
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Anton SDF.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8a89fa14b10d46a99122fd4f73fca9a2
+timeCreated: 1484172732
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Bangers SDF - Drop Shadow - 2 Pass.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 947a44964e53bf0448ff698b2a2219c0
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Bangers SDF - Drop Shadow.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f2dcf029949142e28b974630369c8b4e
+timeCreated: 1444812175
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Bangers SDF - Outline.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f629c6e43dba4bf38cb74d8860150664
+timeCreated: 1455497618
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Bangers SDF Glow.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d75b8f41e959450c84ac6e967084d3e1
+timeCreated: 1426033972
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Bangers SDF Logo - URP.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6751ce1a4611b3940812c13a6847d94f
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Bangers SDF Logo.mat.meta

@@ -0,0 +1,6 @@
+fileFormatVersion: 2
+guid: f4e195ac1e204eff960149d1cb34e18c
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Bangers SDF.asset.meta

@@ -0,0 +1,6 @@
+fileFormatVersion: 2
+guid: 125cb55b44b24c4393181402bc6200e6
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/Electronic Highway Sign SDF.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: dc36b3fdc14f47ebb36fd484a67e268a
+timeCreated: 1487729771
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/LiberationSans SDF - Metalic Green.mat

@@ -2,20 +2,28 @@
 %TAG !u! tag:unity3d.com,2011:
 --- !u!21 &2100000
 Material:
-  serializedVersion: 6
+  serializedVersion: 8
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
   m_Name: LiberationSans SDF - Metalic Green
   m_Shader: {fileID: 4800000, guid: 68e6db2ebdc24f95958faec2be5558d6, type: 3}
-  m_ShaderKeywords: BEVEL_ON GLOW_ON OUTLINE_ON UNDERLAY_ON
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - BEVEL_ON
+  - GLOW_ON
+  - OUTLINE_ON
+  - UNDERLAY_ON
+  m_InvalidKeywords: []
   m_LightmapFlags: 5
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []
+  m_LockedProperties: 
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
@@ -32,14 +40,14 @@ Material:
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _MainTex:
-        m_Texture: {fileID: 28684132378477856, guid: 8f586378b4e144a9851e7b34d9b748ee,
+        m_Texture: {fileID: 28684132378477856, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
-          type: 2}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _OutlineTex:
         m_Texture: {fileID: 2800000, guid: f88677df267a41d6be1e7a6133e7d227, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    m_Ints: []
     m_Floats:
     - _Ambient: 0
     - _Bevel: 1
@@ -50,6 +58,7 @@ Material:
     - _BumpFace: 0
     - _BumpOutline: 0
     - _ColorMask: 15
+    - _CullMode: 0
     - _Diffuse: 0
     - _FaceDilate: 0.15
     - _FaceUVSpeedX: 0
@@ -69,8 +78,8 @@ Material:
     - _PerspectiveFilter: 0
     - _Reflectivity: 12.76
     - _ScaleRatioA: 0.9
-    - _ScaleRatioB: 0.6525
+    - _ScaleRatioB: 0.59624994
-    - _ScaleRatioC: 0.6525
+    - _ScaleRatioC: 0.59624994
     - _ScaleX: 1
     - _ScaleY: 1
     - _ShaderFlags: 0
@@ -102,3 +111,5 @@ Material:
     - _ReflectOutlineColor: {r: 0, g: 0, b: 0, a: 1}
     - _SpecularColor: {r: 0.7689687, g: 1, b: 0.75000346, a: 1}
     - _UnderlayColor: {r: 0, g: 0, b: 0, a: 0.5}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1

Assets/TextMesh Pro/Examples & Extras/Resources/Fonts & Materials/LiberationSans SDF - Metalic Green.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8b29aaa3eec7468097ff07adfcf29ac9
+timeCreated: 1484213182
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: