ui a main menu a join a host lobby

2026-02-21 10:50:37 +01:00
526 changed files with 13432 additions and 192165 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -186,6 +186,7 @@ StyleCopReport.xml
 *_p.c
 *_h.h
 *.ilk
+*.meta
 *.obj
 *.iobj
 *.pch
@@ -303,6 +304,8 @@ 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
--- a/Performance.meta
+++ b/Performance.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 7eaf47040f6a6ba4bb9df4eab675de30
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Performance/Settings.meta
+++ b/Performance/Settings.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: a369fde97a303eb4ebfe7de3af10fac4
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/AntoineCherel/RoundedRectMask2D/Demo/Demo.unity
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Demo/Demo.unity
--- a/Assets/AntoineCherel/RoundedRectMask2D/Demo/Mask
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Demo/Mask
@@ -7,11 +7,10 @@ Material:
  m_CorrespondingSourceObject: {fileID: 0}
  m_PrefabInstance: {fileID: 0}
  m_PrefabAsset: {fileID: 0}
-  m_Name: textik
-  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
+  m_Name: Mask 3 Default UI
+  m_Shader: {fileID: 4800000, guid: 2fa3c67be732d4f38be87103967c4b10, type: 3}
+  m_ValidKeywords:
+  - UNITY_UI_ALPHACLIP
  m_InvalidKeywords: []
  m_LightmapFlags: 4
  m_EnableInstancingVariants: 0
@@ -19,7 +18,6 @@ Material:
  m_CustomRenderQueue: -1
  stringTagMap: {}
  disabledShaderPasses: []
-  m_LockedProperties: 
  m_SavedProperties:
    serializedVersion: 3
    m_TexEnvs:
@@ -62,11 +60,12 @@ Material:
    m_Ints: []
    m_Floats:
    - _BumpScale: 1
+    - _ColorMask: 15
    - _Cutoff: 0.5
    - _DetailNormalMapScale: 1
    - _DstBlend: 0
    - _GlossMapScale: 1
-    - _Glossiness: 0.583
+    - _Glossiness: 0.5
    - _GlossyReflections: 1
    - _Metallic: 0
    - _Mode: 0
@@ -75,10 +74,17 @@ Material:
    - _SmoothnessTextureChannel: 0
    - _SpecularHighlights: 1
    - _SrcBlend: 1
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
    - _UVSec: 0
+    - _UseUIAlphaClip: 1
    - _ZWrite: 1
    m_Colors:
+    - _ClipRect: {r: -32767, g: -32767, b: 32767, a: 32767}
+    - _ClipRectRadii: {r: 50, g: 20, b: 20, a: 50}
    - _Color: {r: 1, g: 1, b: 1, a: 1}
    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/AntoineCherel/RoundedRectMask2D/Documentation/Resources/RRM2D_Banner.png
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Documentation/Resources/RRM2D_Banner.png
--- a/Assets/AntoineCherel/RoundedRectMask2D/Documentation/Resources/RRM2D_ScreenshotScene.png
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Documentation/Resources/RRM2D_ScreenshotScene.png
--- a/Assets/AntoineCherel/RoundedRectMask2D/Documentation/documentation.html
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Documentation/documentation.html
@@ -0,0 +1,226 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <title>Rounded Rect Mask 2D</title>
+    <link href="https://fonts.cdnfonts.com/css/inter" rel="stylesheet">
+    <style>
+        * {
+    /* outline: 1px solid red; */
+    box-sizing: border-box;
+}
+
+/* THESE ENSURE THE WEBVIEW WILL BE OF CORRECT HEIGHT
+  * =======================================================================
+  */
+
+html {
+    margin: 0px;
+    padding: 0px;
+    font-family: 'Inter';
+    background-color: #F7F5EB;
+}
+
+body {
+    margin: 0px;
+    padding: 0px;
+}
+
+body :first-child {
+    margin-top: 0px;
+}
+
+body :last-child {
+    margin-bottom: 0px;
+}
+
+/* FIXES SCROLLING 
+ * =======================================================================
+ */
+
+html,
+body {
+    overflow-x: hidden;
+}
+
+/* MAIN STYLING
+ * =======================================================================
+ */
+
+:root {
+    --default-text-color: #333333;
+    --muted-text-color: #666666;
+    --link-color: #f05675;
+
+    --muted-border-color: #dddddd;
+    --muted-background-color: #eeeeee;
+
+    --codeblock-background-color: #222222;
+    --codeblock-text-color: #ffffff;
+}
+
+body {
+    padding: 16px;
+
+    line-height: 1.5rem;
+    color: var(--default-text-color);
+
+    word-wrap: break-word;
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+    margin-top: 2rem;
+    margin-bottom: 1rem;
+}
+
+h1 {
+    font-size: 1.6rem;
+}
+
+h2 {
+    font-size: 1.45rem;
+}
+
+h3 {
+    font-size: 1.3rem;
+}
+
+h4 {
+    font-size: 1.2rem;
+}
+
+h5 {
+    font-size: 1.1rem;
+}
+
+h6 {
+    font-size: 1.05rem;
+}
+
+h1,
+h2 {
+    padding-bottom: 0.4rem;
+    border-bottom: 1px solid var(--muted-border-color);
+}
+
+ul,
+ol {
+    padding-inline-start: 1.8rem;
+}
+
+a {
+    text-decoration-thickness: 1px;
+    text-underline-offset: 2px;
+    color: var(--link-color);
+}
+
+del {
+    color: var(--muted-text-color);
+}
+
+pre {
+    padding: 1rem;
+    border-radius: 4px;
+
+    color: var(--codeblock-text-color);
+    background-color: var(--codeblock-background-color);
+
+    overflow-x: auto;
+}
+
+:not(pre)>code {
+    background-color: var(--muted-background-color);
+    padding: 0.1rem 0.4rem;
+    border-radius: 3px;
+}
+
+blockquote {
+    margin-inline: 0px;
+    padding-block: 12px;
+    padding-left: 16px;
+
+    color: var(--muted-text-color);
+    border-left: 2px solid var(--muted-border-color);
+    font-style: italic;
+}
+
+blockquote :last-child {
+    margin-bottom: 0px;
+}
+
+
+table {
+    display: block;
+    overflow-x: auto;
+
+    border-collapse: collapse;
+}
+
+th,
+td {
+    padding: 0.6rem 1rem;
+}
+
+th,
+td {
+    border: 1px solid var(--muted-border-color)
+}
+
+th {
+    font-size: 1rem;
+    background-color: var(--muted-background-color);
+    border-bottom-width: 2px;
+}
+
+img {
+    max-width: 100%;
+}
+    </style>
+  </head>
+  <body>
+    <h1 id="rounded-rect-mask-2d">Rounded Rect Mask 2D</h1>
+<p><img src="./Resources/RRM2D_Banner.png" alt="screenshot" /><br />
+available on the <a href="https://assetstore.unity.com/packages/slug/326028" rel="noopener noreferrer" target="_blank">Asset Store</a></p>
+<h2 id="documentation">Documentation</h2>
+<p><img src="./Resources/RRM2D_ScreenshotScene.png" alt="screenshot" /></p>
+<h3 id="basics">Basics</h3>
+<ul>
+<li>All Graphics (<a href="https://docs.unity3d.com/Packages/com.unity.ugui@1.0/manual/comp-UIVisual.html" rel="noopener noreferrer" target="_blank">Visuals</a> &amp; <a href="https://docs.unity3d.com/Packages/com.unity.ugui@1.0/manual/comp-UIInteraction.html" rel="noopener noreferrer" target="_blank">Interactions</a>) components child of the Rounded Mask need the <em>Default UI (Rounded Mask)</em> material to work.</li>
+<li>All TextMeshPro texts need the <em>TMP SDF-Mobile (Rounded Mask)</em> material inside the TMP_FontAsset that needs to work with the rounded corners. If your text is only clipped on the straight edges of the mask, they don't need to be changed.</li>
+<li>You will need one <em>Default UI (Rounded Mask)</em> material per RoundedRectMask2D radius configuration. If you always use the same corners throughout your project, you can use the Material provided in the package. Same for the TMP_FontAssets.</li>
+<li>If you have different radii in your project, either <strong>duplicate the materials</strong>, or tick the checkbox <strong>Clone maskable materials on Start</strong> to automatically create new instances of the materials (for both Default UI &amp; TMP_FontAsset's material).</li>
+</ul>
+<h3 id="limitations">Limitations</h3>
+<ul>
+<li>As Rounded RectMask2D uses a special UI shader to work, it can only be used with normal UI (ie: Images with no special material). If you have custom UI shaders for your UI you will need to tweak them to support the RoundedRectMask2D component (otherwise the corners will not be correctly clipped).</li>
+<li>Moreover, you will need one Material per corners configuration. If you always use the same values, you can use one Material for all of your UI, but otherwise, RoundedRectMask2D can auto instantiate your materials at runtime, allowing you to have any mask values.</li>
+<li>Softness doesn't work with RoundedRectMask2D. If you need softness in your mask, you will have to use both RoundedRectMask2D &amp; a regular RectMask2D nested into each other.</li>
+</ul>
+<h3 id="custom-shaders">Custom Shaders</h3>
+<p>If you have custom UI shaders and would like them to work with the RoundedRectMask2D component, you will need to edit them, to support the feature. You can check how it's done in the custom Shaders (UI Default &amp; TMP_SDF Mobile). <br />
+Here is what you need to do:</p>
+<ol>
+<li>Either move your shaders to the AntoineCherel/RoundedRectMask2D/Shaders folder, or copy &amp; paste the <em>RoundedMaskCommon.hlsl</em> library to your custom shader's folder</li>
+<li>in the <em>Pass</em>, include the library <br />
+<code>#include "RoundedMaskCommon.hlsl"</code></li>
+<li>in the Vertex to Fragment or Vertext to Pixel struct, add <br />
+<code>float3 posLocal : TEXCOORD8;</code></li>
+<li>fill it in the V2F or V2P function <br />
+<code>OUT.posLocal = v.vertex.xyz;</code></li>
+<li>in the frag or pixel return function, replace the existing clipping method by<br />
+<code>clip( RMUnityUIClipRect(IN.posLocal.xy, _ClipRect, _ClipRectRadii) - 0.5);</code><br />
+all of these added lines should be encapsulated inside <code>#ifdef UNITY_UI_CLIP_RECT</code> statements.</li>
+</ol>
+<p>If something goes wrong double check with the implemented shaders inside the Shaders folder.<br />
+You can also reach out to me contact (at) antoinecherel.dev</p>
+<h2 id="credits">Credits</h2>
+<p>Unity Plugin, developped by <a href="https://www.antoinecherel.dev/" target="_blank">Antoine Cherel</a></p>  
+  </body>
+</html>
--- a/Assets/AntoineCherel/RoundedRectMask2D/Editor/RoundedRectMask2D
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Editor/RoundedRectMask2D
--- a/Assets/AntoineCherel/RoundedRectMask2D/Editor/RoundedRectMask2DEditor.cs
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Editor/RoundedRectMask2DEditor.cs
@@ -0,0 +1,124 @@
+using UnityEditor;
+using UnityEditor.UI;
+using UnityEngine;
+
+namespace ACRoundedRectMask
+{
+    /// <summary>
+    /// Custom editor for the RoundedRectMask2D component.
+    /// </summary>
+    [CustomEditor(typeof(RoundedRectMask2D), true)]
+    [CanEditMultipleObjects]
+    public class RoundedRectMask2DInspector : RectMask2DEditor
+    {
+        private static GUIContent radiusContent = new GUIContent("Corner Radius", "Determines the radius of the rect mask's corners.");
+        private static GUIContent radiiContent = new GUIContent("Corner Radii", "Determines the radius of each corner of the rect mask.");
+        private static GUIContent topLeftContent = new GUIContent("Top Left", "Local -X, +Y corner.");
+        private static GUIContent topRightContent = new GUIContent("Top Right", "Local +X, +Y corner.");
+        private static GUIContent bottomLeftContent = new GUIContent("Bottom Left", "Local -X, -Y corner.");
+        private static GUIContent bottomRightContent = new GUIContent("Bottom Right", "Local +X, -Y corner.");
+        private static bool showRadii = false;
+
+        private static GUIContent paddingContent = new GUIContent("Padding");
+        private static GUIContent leftContent = new GUIContent("Left");
+        private static GUIContent rightContent = new GUIContent("Right");
+        private static GUIContent topContent = new GUIContent("Top");
+        private static GUIContent bottomContent = new GUIContent("Bottom");
+        private static bool showOffsets = false;
+
+        private SerializedProperty independentRadii;
+        private SerializedProperty radii;
+        private SerializedProperty padding;
+        private SerializedProperty cloneMaterials;
+
+
+        /// <inheritdoc/>
+        protected override void OnEnable()
+        {
+            independentRadii = serializedObject.FindProperty("independantRadii");
+            radii = serializedObject.FindProperty("radii");
+            padding = serializedObject.FindProperty("m_Padding");
+            cloneMaterials = serializedObject.FindProperty("cloneMaskableMaterialsOnStart");
+
+            base.OnEnable();
+        }
+
+        /// <summary>
+        /// Renders a custom inspector GUI that displays radius options and hides softness properties.
+        /// </summary>
+        public override void OnInspectorGUI()
+        {   
+            EditorGUILayout.PropertyField(independentRadii);
+
+            if (independentRadii.boolValue)
+            {
+                showRadii = EditorGUILayout.Foldout(showRadii, radiiContent, true);
+
+
+                if (showRadii)
+                {
+                    using (var check = new EditorGUI.ChangeCheckScope())
+                    {
+                        EditorGUI.indentLevel++;
+                        Vector4 newRadii = radii.vector4Value;
+
+                        newRadii.x = Mathf.Max(0.0f, EditorGUILayout.FloatField(topLeftContent, newRadii.x));
+                        newRadii.y = Mathf.Max(0.0f, EditorGUILayout.FloatField(topRightContent, newRadii.y));
+                        newRadii.z = Mathf.Max(0.0f, EditorGUILayout.FloatField(bottomLeftContent, newRadii.z));
+                        newRadii.w = Mathf.Max(0.0f, EditorGUILayout.FloatField(bottomRightContent, newRadii.w));
+
+                        if (check.changed)
+                        {
+                            radii.vector4Value = newRadii;
+                        }
+
+                        EditorGUI.indentLevel--;
+                    }
+                }
+            }
+            else
+            {
+                using (var check = new EditorGUI.ChangeCheckScope())
+                {
+                    float newRadius = radii.vector4Value.x;
+
+                    newRadius = Mathf.Max(0.0f, EditorGUILayout.FloatField(radiusContent, newRadius));
+
+                    if (check.changed)
+                    {
+                        Vector4 newRadii = radii.vector4Value;
+                        newRadii = Vector4.one * newRadius;
+                        radii.vector4Value = newRadii;
+                    }
+                }
+            }
+
+            // Rather than call base.OnInspectorGUI() manually showing padding so that softness can be hidden since it is not supported by rounded rect masks.
+            showOffsets = EditorGUILayout.Foldout(showOffsets, paddingContent, true);
+
+            if (showOffsets)
+            {
+                using (var check = new EditorGUI.ChangeCheckScope())
+                {
+                    EditorGUI.indentLevel++;
+                    Vector4 newPadding = padding.vector4Value;
+
+                    newPadding.x = EditorGUILayout.FloatField(leftContent, newPadding.x);
+                    newPadding.z = EditorGUILayout.FloatField(rightContent, newPadding.z);
+                    newPadding.w = EditorGUILayout.FloatField(topContent, newPadding.w);
+                    newPadding.y = EditorGUILayout.FloatField(bottomContent, newPadding.y);
+
+                    if (check.changed)
+                    {
+                        padding.vector4Value = newPadding;
+                    }
+                    EditorGUI.indentLevel--;
+                }
+            }
+
+            EditorGUILayout.PropertyField(cloneMaterials);
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
--- a/Assets/AntoineCherel/RoundedRectMask2D/Materials/Default
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Materials/Default
@@ -7,11 +7,10 @@ Material:
  m_CorrespondingSourceObject: {fileID: 0}
  m_PrefabInstance: {fileID: 0}
  m_PrefabAsset: {fileID: 0}
-  m_Name: New Material
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
+  m_Name: Default UI (RoundedMask)
+  m_Shader: {fileID: 4800000, guid: 2fa3c67be732d4f38be87103967c4b10, type: 3}
+  m_ValidKeywords:
+  - UNITY_UI_ALPHACLIP
  m_InvalidKeywords: []
  m_LightmapFlags: 4
  m_EnableInstancingVariants: 0
@@ -19,14 +18,9 @@ Material:
  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}
@@ -65,14 +59,11 @@ Material:
        m_Offset: {x: 0, y: 0}
    m_Ints: []
    m_Floats:
-    - PixelSnap: 0
    - _BumpScale: 1
    - _ColorMask: 15
-    - _CullMode: 0
    - _Cutoff: 0.5
    - _DetailNormalMapScale: 1
    - _DstBlend: 0
-    - _EnableExternalAlpha: 0
    - _GlossMapScale: 1
    - _Glossiness: 0.5
    - _GlossyReflections: 1
@@ -89,13 +80,11 @@ Material:
    - _StencilReadMask: 255
    - _StencilWriteMask: 255
    - _UVSec: 0
-    - _UseUIAlphaClip: 0
+    - _UseUIAlphaClip: 1
    - _ZWrite: 1
    m_Colors:
    - _ClipRect: {r: -32767, g: -32767, b: 32767, a: 32767}
+    - _ClipRectRadii: {r: 20, g: 20, b: 20, a: 20}
    - _Color: {r: 1, g: 1, b: 1, 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
--- a/Assets/AntoineCherel/RoundedRectMask2D/Materials/LiberationSans
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Materials/LiberationSans
--- a/Assets/AntoineCherel/RoundedRectMask2D/Scripts/RoundedRectMask2D.cs
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Scripts/RoundedRectMask2D.cs
@@ -0,0 +1,359 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using System.Reflection;
+using TMPro;
+
+
+#if UNITY_2021_1_OR_NEWER
+using UnityEngine.Pool;
+#endif
+
+namespace ACRoundedRectMask
+{
+    /// <summary>
+    /// Overrides the RectMask2D.PerformClipping method to add extra checks before doing exhaustive culling on 
+    /// each maskable target.
+    /// </summary>
+    public class RoundedRectMask2D : RectMask2D
+    {
+        public static readonly string RadiiPropertyName = "_ClipRectRadii";
+
+
+        [SerializeField]
+        private bool independantRadii;
+        [Tooltip("The four corner radii of the rounded rect. (x: top left, y: top right, z: bottom left, w: bottom right)")]
+        [SerializeField]
+        private Vector4 radii = Vector4.one * 10.0f;
+        public Vector4 Radii
+        {
+            get => radii;
+            set
+            {
+                radii = value;
+                MaskUtilities.Notify2DMaskStateChanged(this);
+                ForceClip = true;
+            }
+        }
+
+        [Tooltip("If not set to true, you will need to handle that all masked UI elements have their own material instances")]
+        [SerializeField]
+        private bool cloneMaskableMaterialsOnStart = true;
+
+        private static int clipRectRadiiID = 0;
+
+
+        private HashSet<IClippable> clipTargets = null;
+        private HashSet<MaskableGraphic> maskableTargets = null;
+        private int lastclipTargetsCount = 0;
+        private int lastmaskableTargetsCount = 0;
+        private bool shouldRecalculateClipRects = false;
+
+        private Canvas cachedCanvas = null;
+        private Vector3[] cachedCorners = new Vector3[4];
+        private Rect lastClipRectCanvasSpace = new Rect();
+        private Vector2Int lastSoftness = new Vector2Int();
+        private List<RectMask2D> clippers = new List<RectMask2D>();
+
+        #region MonoBehaviour Implementation
+        /// <inheritdoc />
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            shouldRecalculateClipRects = true;
+            ForceClip = true;
+        }
+
+#if UNITY_EDITOR
+        /// <inheritdoc />
+        protected override void OnValidate()
+        {
+            base.OnValidate();
+            shouldRecalculateClipRects = true;
+            ForceClip = true;
+        }
+#endif
+        /// <inheritdoc />
+        protected override void OnDidApplyAnimationProperties()
+        {
+            base.OnDidApplyAnimationProperties();
+
+            shouldRecalculateClipRects = true;
+            ForceClip = true;
+        }
+
+        #endregion MonoBehaviour Implementation
+
+        #region RectMask2D Implementation
+
+        /// <inheritdoc />
+        protected override void OnTransformParentChanged()
+        {
+            base.OnTransformParentChanged();
+            shouldRecalculateClipRects = true;
+        }
+
+        /// <inheritdoc />
+        protected override void OnCanvasHierarchyChanged()
+        {
+            cachedCanvas = null;
+            base.OnCanvasHierarchyChanged();
+            shouldRecalculateClipRects = true;
+        }
+
+
+        protected override void Start()
+        {
+            base.Start();
+
+            shouldRecalculateClipRects = true;
+            PerformClipping();
+
+            if (cloneMaskableMaterialsOnStart && maskableTargets != null)
+            {
+                foreach (MaskableGraphic mg in maskableTargets)
+                {
+                    if (mg.materialForRendering.Equals(mg.material))
+                    {
+                        Material m = new Material(mg.material);
+                        mg.material = m;
+                    }
+                    else if (mg is TMP_Text tmpText)
+                    {
+                        Material m = new Material(tmpText.fontMaterial);
+                        tmpText.fontMaterial = m;
+                    }
+                    else
+                    {
+                        Debug.Log("[RoundedRectMask2d] Can't clone material for " + mg.name + ". This will result in same rounded corners for all assets sharing its materiel " + mg.materialForRendering);
+                        continue;
+                    }
+                    
+                    OnSetClipRect(mg);
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Improves the base class method by:
+        /// - Checks if the canvas renderer has moved before exhaustive culling.
+        /// - Interleaves UpdateClipSoftness so objects are not iterated over twice.
+        /// - Adds a OnSetClipRect callback for derived classes to use.
+        /// </summary>
+        public override void PerformClipping()
+        {
+            // Not calling the base class method intentionally to provide a more optimal version.
+            //base.PerformClipping();
+
+            if (clipRectRadiiID == 0)
+            {
+                clipRectRadiiID = Shader.PropertyToID(RadiiPropertyName);
+            }
+
+
+            Initialize();
+
+            if (ReferenceEquals(Canvas, null))
+            {
+                return;
+            }
+
+            //TODO See if an IsActive() test would work well here or whether it might cause unexpected side effects (re case 776771)
+
+            // if the parents are changed
+            // or something similar we
+            // do a recalculate here
+            if (shouldRecalculateClipRects || ForceClip)
+            {
+                MaskUtilities.GetRectMasksForClip(this, clippers);
+                shouldRecalculateClipRects = false;
+            }
+
+            // get the compound rects from
+            // the clippers that are valid
+            bool validRect = true;
+            Rect clipRect = Clipping.FindCullAndClipWorldRect(clippers, out validRect);
+
+            // If the mask is in ScreenSpaceOverlay/Camera render mode, its content is only rendered when its rect
+            // overlaps that of the root canvas.
+            RenderMode renderMode = Canvas.rootCanvas.renderMode;
+            bool maskIsCulled =
+                (renderMode == RenderMode.ScreenSpaceCamera || renderMode == RenderMode.ScreenSpaceOverlay) &&
+                !clipRect.Overlaps(RootCanvasRect, true);
+
+            if (maskIsCulled)
+            {
+                // Children are only displayed when inside the mask. If the mask is culled, then the children
+                // inside the mask are also culled. In that situation, we pass an invalid rect to allow callees
+                // to avoid some processing.
+                clipRect = Rect.zero;
+                validRect = false;
+            }
+
+            if (clipRect != lastClipRectCanvasSpace || softness != lastSoftness)
+            {
+                foreach (IClippable clipTarget in clipTargets)
+                {
+                    clipTarget.SetClipRect(clipRect, validRect);
+                    clipTarget.SetClipSoftness(softness);
+                }
+
+                foreach (MaskableGraphic maskableTarget in maskableTargets)
+                {
+                    maskableTarget.SetClipRect(clipRect, validRect);
+                    maskableTarget.SetClipSoftness(softness);
+                    OnSetClipRect(maskableTarget);
+
+                    maskableTarget.Cull(clipRect, validRect);
+                }
+            }
+            else if (ForceClip)
+            {
+                foreach (IClippable clipTarget in clipTargets)
+                {
+                    clipTarget.SetClipRect(clipRect, validRect);
+                    clipTarget.SetClipSoftness(softness);
+                }
+
+                foreach (MaskableGraphic maskableTarget in maskableTargets)
+                {
+                    maskableTarget.SetClipRect(clipRect, validRect);
+                    maskableTarget.SetClipSoftness(softness);
+                    OnSetClipRect(maskableTarget);
+
+                    if (maskableTarget.canvasRenderer.hasMoved)
+                    {
+                        maskableTarget.Cull(clipRect, validRect);
+                    }
+                }
+            }
+            else
+            {
+                foreach (MaskableGraphic maskableTarget in maskableTargets)
+                {
+                    if (!maskableTarget.canvasRenderer.hasMoved)
+                    {
+                        continue;
+                    }
+
+                    maskableTarget.Cull(clipRect, validRect);
+                }
+            }
+
+            ForceClip = false;
+            lastClipRectCanvasSpace = clipRect;
+            lastSoftness = softness;
+        }
+
+        #endregion RectMask2D Implementation
+
+        public bool ForceClip
+        {
+            get
+            {
+                // This is an imprecise check if a clip or mask target gets added then removed on the same frame.
+                // But... the alternative is we reflect into m_ForceClip base member which would be a per frame allocation due to it being a value type.
+                // If this check is return false negatives in your scenario, then set ForceClip to true.
+                return clipTargets.Count != lastclipTargetsCount ||
+                       maskableTargets.Count != lastmaskableTargetsCount;
+            }
+            set
+            {
+                if (value == true)
+                {
+                    lastclipTargetsCount = 0;
+                    lastmaskableTargetsCount = 0;
+                }
+                else
+                {
+                    Initialize();
+
+                    lastclipTargetsCount = clipTargets.Count;
+                    lastmaskableTargetsCount = maskableTargets.Count;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Callback whenever the clip rect is mutated.
+        /// </summary>
+        protected virtual void OnSetClipRect(IClippable clippable)
+        { 
+            
+        }
+
+        /// <summary>
+        /// Callback whenever the clip rect is mutated.
+        /// </summary>
+        protected virtual void OnSetClipRect(MaskableGraphic maskableTarget)
+        {
+            Material targetMaterial = maskableTarget.materialForRendering;
+
+            if (targetMaterial != null)
+            {
+                targetMaterial.SetVector(clipRectRadiiID, Radii);
+            }
+
+            Debug.Log("Setting clip rect for " + maskableTarget.name);
+        }
+
+        private void Initialize()
+        {
+            // Check if we have already initialized.
+            if (clipTargets != null)
+            {
+                return;
+            }
+
+            // Many of the properties we need access to for clipping are not exposed. So, we have to do reflection to get access to them.
+            BindingFlags bindFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
+            clipTargets = (HashSet<IClippable>)typeof(RectMask2D).GetField("m_ClipTargets", bindFlags).GetValue(this);
+            maskableTargets = (HashSet<MaskableGraphic>)typeof(RectMask2D).GetField("m_MaskableTargets", bindFlags).GetValue(this);
+        }
+
+        private Canvas Canvas
+        {
+            get
+            {
+                if (cachedCanvas == null)
+                {
+#if UNITY_2021_1_OR_NEWER
+                    var list = ListPool<Canvas>.Get();
+                    gameObject.GetComponentsInParent(false, list);
+                    if (list.Count > 0)
+                        cachedCanvas = list[list.Count - 1];
+                    else
+                        cachedCanvas = null;
+                    ListPool<Canvas>.Release(list);
+#else
+                    var list = gameObject.GetComponentsInParent<Canvas>(false);
+                    if (list.Length > 0)
+                        cachedCanvas = list[list.Length - 1];
+                    else
+                        cachedCanvas = null;
+#endif
+                }
+
+                return cachedCanvas;
+            }
+        }
+
+        private Rect RootCanvasRect
+        {
+            get
+            {
+                rectTransform.GetWorldCorners(cachedCorners);
+
+                if (!ReferenceEquals(Canvas, null))
+                {
+                    Canvas rootCanvas = Canvas.rootCanvas;
+                    for (int i = 0; i < 4; ++i)
+                        cachedCorners[i] = rootCanvas.transform.InverseTransformPoint(cachedCorners[i]);
+                }
+
+                return new Rect(cachedCorners[0].x, cachedCorners[0].y, cachedCorners[2].x - cachedCorners[0].x, cachedCorners[2].y - cachedCorners[0].y);
+            }
+        }
+    }
+}
--- a/Assets/AntoineCherel/RoundedRectMask2D/Shaders/RoundedMaskCommon.hlsl
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Shaders/RoundedMaskCommon.hlsl
@@ -0,0 +1,112 @@
+#ifndef RM_COMMON
+#define RM_COMMON
+
+/// <summary>
+/// Constants
+/// </summary>
+
+#define RM_PI                    3.14159265359
+#define RM_DEGREES_TO_RADIANS    (RM_PI / 180.0)
+
+#define RM_HALF_MIN              6.103515625e-5  // 2^-14, the same value for 10, 11 and 16-bit: https://www.khronos.org/opengl/wiki/Small_Float_Formats
+
+#define RM_MIN_CORNER_VALUE      1e-3
+#define RM_MIN_CORNER_VALUE_RECT 1e-3
+
+/// <summary>
+/// SDF methods.
+/// </summary>
+
+inline float RMPointVsRoundedBox(in float2 position, in float2 cornerCircleDistance, in float cornerCircleRadius)
+{
+    return length(max(abs(position) - cornerCircleDistance, 0.0)) - cornerCircleRadius;
+}
+
+inline float FilterDistance(in float distance)
+{
+    float pixelDistance = distance / fwidth(distance);
+
+#if defined(_INDEPENDENT_CORNERS) || defined(_UI_CLIP_RECT_ROUNDED_INDEPENDENT)
+    // To avoid artifacts at discontinuities in the SDF distance increase the pixel width.
+    return saturate(1.0 - pixelDistance);
+#else
+    return saturate(0.5 - pixelDistance);
+#endif
+}
+
+inline float RMRoundCornersSmooth(in float2 position, in float2 cornerCircleDistance, in float cornerCircleRadius, in float smoothingValue)
+{
+    float distance = RMPointVsRoundedBox(position, cornerCircleDistance, cornerCircleRadius);
+#if defined(_EDGE_SMOOTHING_AUTOMATIC)
+    return FilterDistance(distance);
+#else
+    return smoothstep(1.0, 0.0, distance / smoothingValue);
+#endif
+}
+
+inline float RMRoundCorners(in float2 position, in float2 cornerCircleDistance, in float cornerCircleRadius, in float smoothingValue)
+{
+#if defined(_TRANSPARENT)
+    return RMRoundCornersSmooth(position, cornerCircleDistance, cornerCircleRadius, smoothingValue);
+#else
+    return (RMPointVsRoundedBox(position, cornerCircleDistance, cornerCircleRadius) < 0.0);
+#endif
+}
+
+inline float RMFindCornerRadius(in float2 uv, in float4 radii)
+{
+    if (uv.x < 0.5)
+    {
+        if (uv.y > 0.5) { return radii.x; } // Top left.
+        else { return radii.z; } // Bottom left.
+    }
+    else
+    {
+        if (uv.y > 0.5) { return radii.y; } // Top right.
+        else { return radii.w; } // Bottom right.
+    }
+}
+
+/// <summary>
+/// UnityUI methods.
+/// </summary>
+
+inline float RMGet2DClippingRounded(in float2 position, in float4 clipRect, in float radius)
+{
+    float2 halfSize = (clipRect.zw - clipRect.xy) * 0.5;
+    float2 center = clipRect.xy + halfSize;
+    float2 offset = position - center;
+
+    return RMPointVsRoundedBox(offset, halfSize - radius, radius);
+}
+
+inline float RMGet2DClippingRoundedSoft(in float2 position, in float4 clipRect, in float radius)
+{
+    return saturate(FilterDistance(RMGet2DClippingRounded(position, clipRect, radius)));
+}
+
+inline float RMGet2DClippingRoundedIndependent(in float2 position, in float4 clipRect, in float4 radii)
+{
+    float2 halfSize = (clipRect.zw - clipRect.xy) * 0.5;
+    float2 center = clipRect.xy + halfSize;
+    float2 offset = position - center;
+    float radius = RMFindCornerRadius(offset, radii);
+
+    return RMPointVsRoundedBox(offset, halfSize - radius, radius);
+}
+
+inline float RMGet2DClippingRoundedIndependentSoft(in float2 position, in float4 clipRect, in float4 radii)
+{
+    return saturate(FilterDistance(RMGet2DClippingRoundedIndependent(position, clipRect, radii)));
+}
+
+inline float RMUnityUIClipRect(in float2 position, in float4 clipRect, in float4 radii)
+{
+    radii = max(radii, RM_MIN_CORNER_VALUE_RECT);
+#if defined(UNITY_UI_ALPHACLIP)
+    return RMGet2DClippingRoundedIndependent(position, clipRect, radii) <= 0.0;
+#else
+    return RMGet2DClippingRoundedIndependentSoft(position, clipRect, radii);
+#endif
+}
+#endif // RM_COMMON
--- a/Assets/AntoineCherel/RoundedRectMask2D/Shaders/RoundedMaskDefault.shader
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Shaders/RoundedMaskDefault.shader
@@ -0,0 +1,126 @@
+// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
+
+Shader "RoundedMask/UI/Default (RoundedMask)"
+{
+    Properties
+    {
+        [PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+        _Color ("Tint", Color) = (1,1,1,1)
+
+        _StencilComp ("Stencil Comparison", Float) = 8
+        _Stencil ("Stencil ID", Float) = 0
+        _StencilOp ("Stencil Operation", Float) = 0
+        _StencilWriteMask ("Stencil Write Mask", Float) = 255
+        _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+        _ColorMask ("Color Mask", Float) = 15
+
+        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+        [HideInInspector] _ClipRect("Clip Rect", Vector) = (-32767.0, -32767.0, 32767.0, 32767.0)
+        [HideInInspector] _ClipRectRadii("Clip Rect Radii", Vector) = (10.0, 10.0, 10.0, 10.0)
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "Queue"="Transparent"
+            "IgnoreProjector"="True"
+            "RenderType"="Transparent"
+            "PreviewType"="Plane"
+            "CanUseSpriteAtlas"="True"
+        }
+
+        Stencil
+        {
+            Ref [_Stencil]
+            Comp [_StencilComp]
+            Pass [_StencilOp]
+            ReadMask [_StencilReadMask]
+            WriteMask [_StencilWriteMask]
+        }
+
+        Cull Off
+        Lighting Off
+        ZWrite Off
+        ZTest [unity_GUIZTestMode]
+        Blend SrcAlpha OneMinusSrcAlpha
+        ColorMask [_ColorMask]
+
+        Pass
+        {
+            Name "Default"
+        CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma target 2.0
+
+            #include "UnityCG.cginc"
+            #include "UnityUI.cginc"
+            #include "RoundedMaskCommon.hlsl"
+
+            #pragma multi_compile_local _ UNITY_UI_CLIP_RECT
+            #pragma multi_compile_local _ UNITY_UI_ALPHACLIP
+
+            struct appdata_t
+            {
+                float4 vertex   : POSITION;
+                float4 color    : COLOR;
+                float2 texcoord : TEXCOORD0;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct v2f
+            {
+                float4 vertex   : SV_POSITION;
+                fixed4 color    : COLOR;
+                float2 texcoord  : TEXCOORD0;
+                float4 worldPosition : TEXCOORD1;
+#ifdef UNITY_UI_CLIP_RECT
+                float3 posLocal : TEXCOORD8;
+#endif
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            sampler2D _MainTex;
+            fixed4 _Color;
+            fixed4 _TextureSampleAdd;
+            float4 _ClipRect;
+            float4 _ClipRectRadii;
+            float4 _MainTex_ST;
+
+            v2f vert(appdata_t v)
+            {
+                v2f OUT;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
+                OUT.worldPosition = v.vertex;
+                OUT.vertex = UnityObjectToClipPos(OUT.worldPosition);
+
+                OUT.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);
+#ifdef UNITY_UI_CLIP_RECT
+                OUT.posLocal = v.vertex.xyz;
+#endif
+                OUT.color = v.color * _Color;
+                return OUT;
+            }
+
+            fixed4 frag(v2f IN) : SV_Target
+            {
+                
+                #ifdef UNITY_UI_CLIP_RECT
+                clip( RMUnityUIClipRect(IN.posLocal.xy, _ClipRect, _ClipRectRadii) - 0.5);
+                #endif
+                
+                half4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color;
+
+                #ifdef UNITY_UI_ALPHACLIP
+                clip (color.a - 0.001);
+                #endif
+
+                return color;
+            }
+        ENDCG
+        }
+    }
+}
--- a/Assets/AntoineCherel/RoundedRectMask2D/Shaders/RoundedMaskTMP_SDF-Mobile.shader
+++ b/Assets/AntoineCherel/RoundedRectMask2D/Shaders/RoundedMaskTMP_SDF-Mobile.shader
@@ -0,0 +1,249 @@
+// Simplified SDF shader:
+// - No Shading Option (bevel / bump / env map)
+// - No Glow Option
+// - Softness is applied on both side of the outline
+
+Shader "RoundedMask/TextMeshPro/Mobile/Distance Field (RoundedMask)" {
+
+Properties {
+	[HDR]_FaceColor     ("Face Color", Color) = (1,1,1,1)
+	_FaceDilate			("Face Dilate", Range(-1,1)) = 0
+
+	[HDR]_OutlineColor	("Outline Color", Color) = (0,0,0,1)
+	_OutlineWidth		("Outline Thickness", Range(0,1)) = 0
+	_OutlineSoftness	("Outline Softness", Range(0,1)) = 0
+
+	[HDR]_UnderlayColor	("Border Color", Color) = (0,0,0,.5)
+	_UnderlayOffsetX 	("Border OffsetX", Range(-1,1)) = 0
+	_UnderlayOffsetY 	("Border OffsetY", Range(-1,1)) = 0
+	_UnderlayDilate		("Border Dilate", Range(-1,1)) = 0
+	_UnderlaySoftness 	("Border Softness", Range(0,1)) = 0
+
+	_WeightNormal		("Weight Normal", float) = 0
+	_WeightBold			("Weight Bold", float) = .5
+
+	_ShaderFlags		("Flags", float) = 0
+	_ScaleRatioA		("Scale RatioA", float) = 1
+	_ScaleRatioB		("Scale RatioB", float) = 1
+	_ScaleRatioC		("Scale RatioC", float) = 1
+
+	_MainTex			("Font Atlas", 2D) = "white" {}
+	_TextureWidth		("Texture Width", float) = 512
+	_TextureHeight		("Texture Height", float) = 512
+	_GradientScale		("Gradient Scale", float) = 5
+	_ScaleX				("Scale X", float) = 1
+	_ScaleY				("Scale Y", float) = 1
+	_PerspectiveFilter	("Perspective Correction", Range(0, 1)) = 0.875
+	_Sharpness			("Sharpness", Range(-1,1)) = 0
+
+	_VertexOffsetX		("Vertex OffsetX", float) = 0
+	_VertexOffsetY		("Vertex OffsetY", float) = 0
+
+	_ClipRect			("Clip Rect", vector) = (-32767, -32767, 32767, 32767)
+    [HideInInspector] 
+    _ClipRectRadii      ("Clip Rect Radii", vector) = (10.0, 10.0, 10.0, 10.0)
+	_MaskSoftnessX		("Mask SoftnessX", float) = 0
+	_MaskSoftnessY		("Mask SoftnessY", float) = 0
+
+	_StencilComp		("Stencil Comparison", Float) = 8
+	_Stencil			("Stencil ID", Float) = 0
+	_StencilOp			("Stencil Operation", Float) = 0
+	_StencilWriteMask	("Stencil Write Mask", Float) = 255
+	_StencilReadMask	("Stencil Read Mask", Float) = 255
+
+	_CullMode			("Cull Mode", Float) = 0
+	_ColorMask			("Color Mask", Float) = 15
+}
+
+SubShader {
+	Tags
+	{
+		"Queue"="Transparent"
+		"IgnoreProjector"="True"
+		"RenderType"="Transparent"
+	}
+
+
+	Stencil
+	{
+		Ref [_Stencil]
+		Comp [_StencilComp]
+		Pass [_StencilOp]
+		ReadMask [_StencilReadMask]
+		WriteMask [_StencilWriteMask]
+	}
+
+	Cull [_CullMode]
+	ZWrite Off
+	Lighting Off
+	Fog { Mode Off }
+	ZTest [unity_GUIZTestMode]
+	Blend One OneMinusSrcAlpha
+	ColorMask [_ColorMask]
+
+	Pass {
+		CGPROGRAM
+		#pragma vertex VertShader
+		#pragma fragment PixShader
+		#pragma shader_feature __ OUTLINE_ON
+		#pragma shader_feature __ UNDERLAY_ON UNDERLAY_INNER
+
+		#pragma multi_compile __ UNITY_UI_CLIP_RECT
+		#pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+		#include "UnityCG.cginc"
+		#include "UnityUI.cginc"
+        #include "RoundedMaskCommon.hlsl"
+		#include "Assets/TextMesh Pro/Shaders/TMPro_Properties.cginc"
+
+		struct vertex_t {
+			UNITY_VERTEX_INPUT_INSTANCE_ID
+			float4	vertex			: POSITION;
+			float3	normal			: NORMAL;
+			fixed4	color			: COLOR;
+			float2	texcoord0		: TEXCOORD0;
+			float2	texcoord1		: TEXCOORD1;
+		};
+
+		struct pixel_t {
+			UNITY_VERTEX_INPUT_INSTANCE_ID
+			UNITY_VERTEX_OUTPUT_STEREO
+			float4	vertex			: SV_POSITION;
+			fixed4	faceColor		: COLOR;
+			fixed4	outlineColor	: COLOR1;
+			float4	texcoord0		: TEXCOORD0;			// Texture UV, Mask UV
+			half4	param			: TEXCOORD1;			// Scale(x), BiasIn(y), BiasOut(z), Bias(w)
+			half4	mask			: TEXCOORD2;			// Position in clip space(xy), Softness(zw)
+			#if (UNDERLAY_ON | UNDERLAY_INNER)
+			float4	texcoord1		: TEXCOORD3;			// Texture UV, alpha, reserved
+			half2	underlayParam	: TEXCOORD4;			// Scale(x), Bias(y)
+			#endif
+            #ifdef UNITY_UI_CLIP_RECT
+            float3 posLocal : TEXCOORD8;
+            #endif
+		};
+
+        float4 _ClipRectRadii;
+
+		pixel_t VertShader(vertex_t input)
+		{
+			pixel_t output;
+
+			UNITY_INITIALIZE_OUTPUT(pixel_t, output);
+			UNITY_SETUP_INSTANCE_ID(input);
+			UNITY_TRANSFER_INSTANCE_ID(input, output);
+			UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
+
+			float bold = step(input.texcoord1.y, 0);
+
+			float4 vert = input.vertex;
+			vert.x += _VertexOffsetX;
+			vert.y += _VertexOffsetY;
+			float4 vPosition = UnityObjectToClipPos(vert);
+
+			float2 pixelSize = vPosition.w;
+			pixelSize /= float2(_ScaleX, _ScaleY) * abs(mul((float2x2)UNITY_MATRIX_P, _ScreenParams.xy));
+
+			float scale = rsqrt(dot(pixelSize, pixelSize));
+			scale *= abs(input.texcoord1.y) * _GradientScale * (_Sharpness + 1);
+			if(UNITY_MATRIX_P[3][3] == 0) scale = lerp(abs(scale) * (1 - _PerspectiveFilter), scale, abs(dot(UnityObjectToWorldNormal(input.normal.xyz), normalize(WorldSpaceViewDir(vert)))));
+
+			float weight = lerp(_WeightNormal, _WeightBold, bold) / 4.0;
+			weight = (weight + _FaceDilate) * _ScaleRatioA * 0.5;
+
+			float layerScale = scale;
+
+			scale /= 1 + (_OutlineSoftness * _ScaleRatioA * scale);
+			float bias = (0.5 - weight) * scale - 0.5;
+			float outline = _OutlineWidth * _ScaleRatioA * 0.5 * scale;
+
+			float opacity = input.color.a;
+			#if (UNDERLAY_ON | UNDERLAY_INNER)
+			opacity = 1.0;
+			#endif
+
+			fixed4 faceColor = fixed4(input.color.rgb, opacity) * _FaceColor;
+			faceColor.rgb *= faceColor.a;
+
+			fixed4 outlineColor = _OutlineColor;
+			outlineColor.a *= opacity;
+			outlineColor.rgb *= outlineColor.a;
+			outlineColor = lerp(faceColor, outlineColor, sqrt(min(1.0, (outline * 2))));
+
+			#if (UNDERLAY_ON | UNDERLAY_INNER)
+			layerScale /= 1 + ((_UnderlaySoftness * _ScaleRatioC) * layerScale);
+			float layerBias = (.5 - weight) * layerScale - .5 - ((_UnderlayDilate * _ScaleRatioC) * .5 * layerScale);
+
+			float x = -(_UnderlayOffsetX * _ScaleRatioC) * _GradientScale / _TextureWidth;
+			float y = -(_UnderlayOffsetY * _ScaleRatioC) * _GradientScale / _TextureHeight;
+			float2 layerOffset = float2(x, y);
+			#endif
+
+			// Generate UV for the Masking Texture
+			float4 clampedRect = clamp(_ClipRect, -2e10, 2e10);
+			float2 maskUV = (vert.xy - clampedRect.xy) / (clampedRect.zw - clampedRect.xy);
+
+			// Populate structure for pixel shader
+			output.vertex = vPosition;
+			output.faceColor = faceColor;
+			output.outlineColor = outlineColor;
+			output.texcoord0 = float4(input.texcoord0.x, input.texcoord0.y, maskUV.x, maskUV.y);
+			output.param = half4(scale, bias - outline, bias + outline, bias);
+			output.mask = half4(vert.xy * 2 - clampedRect.xy - clampedRect.zw, 0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) + pixelSize.xy));
+			#if (UNDERLAY_ON || UNDERLAY_INNER)
+			output.texcoord1 = float4(input.texcoord0 + layerOffset, input.color.a, 0);
+			output.underlayParam = half2(layerScale, layerBias);
+			#endif
+            #ifdef UNITY_UI_CLIP_RECT
+            output.posLocal = vert.xyz;
+            #endif
+
+			return output;
+		}
+
+
+		// PIXEL SHADER
+		fixed4 PixShader(pixel_t input) : SV_Target
+		{
+			UNITY_SETUP_INSTANCE_ID(input);
+
+			half d = tex2D(_MainTex, input.texcoord0.xy).a * input.param.x;
+			half4 c = input.faceColor * saturate(d - input.param.w);
+
+			#ifdef OUTLINE_ON
+			c = lerp(input.outlineColor, input.faceColor, saturate(d - input.param.z));
+			c *= saturate(d - input.param.y);
+			#endif
+
+			#if UNDERLAY_ON
+			d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x;
+			c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * saturate(d - input.underlayParam.y) * (1 - c.a);
+			#endif
+
+			#if UNDERLAY_INNER
+			half sd = saturate(d - input.param.z);
+			d = tex2D(_MainTex, input.texcoord1.xy).a * input.underlayParam.x;
+			c += float4(_UnderlayColor.rgb * _UnderlayColor.a, _UnderlayColor.a) * (1 - saturate(d - input.underlayParam.y)) * sd * (1 - c.a);
+			#endif
+
+			// Alternative implementation to UnityGet2DClipping with support for softness.
+			#if UNITY_UI_CLIP_RECT
+			clip( RMUnityUIClipRect(input.posLocal.xy, _ClipRect, _ClipRectRadii) - 0.5);
+			#endif
+
+			#if (UNDERLAY_ON | UNDERLAY_INNER)
+			c *= input.texcoord1.z;
+			#endif
+
+			#if UNITY_UI_ALPHACLIP
+			clip(c.a - 0.001);
+			#endif
+
+			return c;
+		}
+		ENDCG
+	}
+}
+
+CustomEditor "TMPro.EditorUtilities.TMP_SDFShaderGUI"
+}
--- a/Assets/ClientSDK.meta
+++ b/Assets/ClientSDK.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 799f52449ae21404c9a7593f6dc28c60
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/ClientSDK/Encryption.cs.meta
+++ b/Assets/ClientSDK/Encryption.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: bc06bb57786c7e142b06ec231e5cf709
--- a/Assets/ClientSDK/EventDispatcher.cs.meta
+++ b/Assets/ClientSDK/EventDispatcher.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 1d2251b279edb0147bd274a884ac878b
--- a/Assets/ClientSDK/GameClient.cs.meta
+++ b/Assets/ClientSDK/GameClient.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 91e0f647c37b0b94b83f53bb854db28c
--- a/Assets/ClientSDK/Protocol.cs
+++ b/Assets/ClientSDK/Protocol.cs
@@ -9,39 +9,38 @@ namespace GeoSus.Client
 {
    #region Základní typy

-    public struct Position
+public struct Position
+{
+    [JsonProperty("lat")]
+    public double Lat { get; set; }
+    
+    [JsonProperty("lon")]
+    public double Lon { get; set; }
+    
+    public Position(double lat, double lon)
    {
-        [JsonProperty("lat")]
-        public double Lat { get; set; }
-
-        [JsonProperty("lon")]
-        public double Lon { get; set; }
-
-        public Position(double lat, double lon)
-        {
-            Lat = lat;
-            Lon = lon;
-        }
-
-        // Haversine vzdálenost v metrech
-        public double DistanceTo(Position other)
-        {
-            const double R = 6371000;
-            var lat1 = Lat * Math.PI / 180;
-            var lat2 = other.Lat * Math.PI / 180;
-            var dLat = (other.Lat - Lat) * Math.PI / 180;
-            var dLon = (other.Lon - Lon) * Math.PI / 180;
-
-            var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
-                    Math.Cos(lat1) * Math.Cos(lat2) *
-                    Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
-            var c = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
-
-            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); }
+        Lat = lat;
+        Lon = lon;
    }
+    
+    // Haversine vzdálenost v metrech
+    public double DistanceTo(Position other)
+    {
+        const double R = 6371000;
+        var lat1 = Lat * Math.PI / 180;
+        var lat2 = other.Lat * Math.PI / 180;
+        var dLat = (other.Lat - Lat) * Math.PI / 180;
+        var dLon = (other.Lon - Lon) * Math.PI / 180;
+        
+        var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
+                Math.Cos(lat1) * Math.Cos(lat2) *
+                Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
+        var c = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
+        
+        return R * c;
+    }
+}
+
 [JsonConverter(typeof(StringEnumConverter))]
 public enum PlayerRole { Crew, Impostor }

--- a/Assets/ClientSDK/Protocol.cs.meta
+++ b/Assets/ClientSDK/Protocol.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 14463228dfea2264ebfc36c3a7dc4b99
--- a/Assets/ClientSDK/SimulatorClient.cs.meta
+++ b/Assets/ClientSDK/SimulatorClient.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 80ef0979df5d1fe489225f3e5edadc5c
--- a/Assets/ClientSDK/bin.meta
+++ b/Assets/ClientSDK/bin.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 3a4035bdb812fee4f96cb1aa1b24c999
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/ClientSDK/obj.meta
+++ b/Assets/ClientSDK/obj.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 131d9de257c8edc49991d792c6e702f6
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Editor.meta
+++ b/Assets/Editor.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 8fa0d9c695119af49bd1693054cf3174
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Editor/com.unity.mobile.notifications.meta
+++ b/Assets/Editor/com.unity.mobile.notifications.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 70729d202603eef42955f52bd64f7c69
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/GameManager.meta
+++ b/Assets/GameManager.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 5fd2bf33031fe9d4ea3439b41d7f4b97
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/GameManager/AreaMat.mat
+++ b/Assets/GameManager/AreaMat.mat
@@ -1,92 +0,0 @@
-%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
--- a/Assets/GameManager/AreaMat.mat.meta
+++ b/Assets/GameManager/AreaMat.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 5a46533bdf4003449bc9146ccef44e27
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/GameManager/GameManager.cs
+++ b/Assets/GameManager/GameManager.cs
@@ -1,8 +1,10 @@
 using UnityEngine;
 using GeoSus.Client;
 using Subsystems;
+using System.Threading;
+using System.Threading.Tasks;
 using System.Collections;
-using System;
+using System.Collections.Generic;
 using TMPro;
 /*
    GameManager - hlavní tøida pro správu hry
@@ -11,67 +13,33 @@ using TMPro;
    GameManager_Map - subsystém pro správu mapy a prostøedí
    GameManager_Input - subsystém pro správu vstupu od hráèe
    GameManager_UI - subsystém pro správu uživatelského rozhraní
-    GamaManager_Stats - subsystém pro správu statistik pro server 
+    GamaManager_Stats - subsystém pro správu statistik pro server
 */
 public class GameManager : MonoBehaviour
 {
    [Header("Subsystems")]
    protected GameManager_Network networkSubsystem;
    protected GameManager_UI uiSubsystem;
-    protected GameManager_Map mapSubsystem;
-    protected GameManager_Input inputSubsystem;
+

    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;
-

    void Start()
    {
        DontDestroyOnLoad(this);
        if (displayName == null || displayName == "")
        {
-            displayName = GenerateUsername();
+            displayName = "Player_" + Random.Range(1000, 9999).ToString();
        }
-        if (testMode)
-        {
-            _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);
+        gameClient = new GameClient(GenerateUUID(), /*displayName*/ GenerateUsername());
+        uiSubsystem = new GameManager_UI(gameClient, JoinCreateLobby, InLobby);
        networkSubsystem = new GameManager_Network(gameClient);
-        mapSubsystem = new GameManager_Map(gameClient, MapCenterPoint, buildingSettings, pathwaySettings, areaSettings);
-        inputSubsystem = new GameManager_Input(gameClient, Player, testMode);
        networkSubsystem.OpenConection();
    }
    private void Update()
@@ -79,17 +47,8 @@ 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();
    }


@@ -101,17 +60,13 @@ public class GameManager : MonoBehaviour
    }
    protected string GenerateUsername()
    {
-        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();
+        string Username = Random.Range(0,10).ToString() + Random.Range(0, 10).ToString() + Random.Range(0, 10).ToString() + Random.Range(0, 10).ToString();
        Debug.Log(Username);
        return Username;
    }
    public void CreateLobbyButton()
    {
-        networkSubsystem.CrateLobby(50.7727264, 15.0719876);
-        if (testMode)
-        {
-            StartCoroutine(ConnectTestClients());
-        }
+        networkSubsystem.CrateLobby(50.0755, 14.4378);
    }
    public void JoinLobbyButton()
    {
@@ -129,20 +84,8 @@ public class GameManager : MonoBehaviour
    {
        networkSubsystem.LeaveLobby();
    }
-    public void StartGameButton()
-    {
-        networkSubsystem.StartGame();
-    }
    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);
    }
 }
--- a/Assets/GameManager/GameManager.cs.meta
+++ b/Assets/GameManager/GameManager.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 22bf82e679cf6e1419440d236360ba3b
--- a/Assets/GameManager/GameManager_Input.cs
+++ b/Assets/GameManager/GameManager_Input.cs
@@ -1,926 +0,0 @@
-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
-    }
-
-    /// <summary>
-    /// Position source backend. Selectable at runtime via the GPS overlay
-    /// "Source" button so the user can recover when one path misbehaves on
-    /// their phone:
-    ///   Auto         - JNI: subscribe to gps + network, pick most recent fix.
-    ///   GpsOnly      - JNI: subscribe to gps only (network's frequent indoor
-    ///                  fixes don't drown out the slower-but-precise gps fix).
-    ///   NetworkOnly  - JNI: subscribe to network only (cell tower / WiFi).
-    ///                  Useful indoors when no satellite lock is possible.
-    ///   UnityInput   - Unity's Input.location wrapper. Verified to hang on
-    ///                  Mi 9T / A20e (which is why JNI exists), but works on
-    ///                  newer Android where the JNI streaming-callbacks path
-    ///                  silently doesn't fire (MIUI/HyperOS battery saver,
-    ///                  approximate-vs-precise permission split, minDistance
-    ///                  gating on stationary phones).
-    ///   EditorWasd   - WASD-driven simulated position. Available regardless
-    ///                  of testMode flag so desktop builds and editor sessions
-    ///                  can navigate the map without real GPS.
-    /// </summary>
-    public enum PositionSource
-    {
-        Auto,
-        GpsOnly,
-        NetworkOnly,
-        UnityInput,
-        EditorWasd,
-    }
-
-#if UNITY_ANDROID && !UNITY_EDITOR
-    /// <summary>
-    /// Bridges android.location.LocationListener to managed code. The method
-    /// names here must match Java's LocationListener interface exactly so
-    /// AndroidJavaProxy's reflection dispatcher can find them.
-    /// </summary>
-    internal class AndroidLocationProxy : AndroidJavaProxy
-    {
-        public AndroidLocationProvider Owner { get; set; }
-        public AndroidLocationProxy() : base("android.location.LocationListener") { }
-
-        // Called by Android each time a new fix arrives from the registered provider.
-        public void onLocationChanged(AndroidJavaObject location)
-        {
-            try
-            {
-                if (location == null) return;
-                double lat = location.Call<double>("getLatitude");
-                double lon = location.Call<double>("getLongitude");
-                long t = location.Call<long>("getTime");
-                string provider = "";
-                try { provider = location.Call<string>("getProvider"); } catch { }
-                // Streaming callbacks are LIVE (never cached). The cached path
-                // calls UpdateLocation directly with isCached=true.
-                Owner?.UpdateLocation(lat, lon, t, provider, isCached: false);
-            }
-            catch (Exception ex)
-            {
-                Debug.LogWarning("[GPS-JNI] onLocationChanged failed: " + ex.Message);
-            }
-        }
-
-        // Required by the LocationListener interface even if we don't use them.
-        // Missing methods cause java.lang.AbstractMethodError at runtime.
-        public void onStatusChanged(string provider, int status, AndroidJavaObject extras) { }
-        public void onProviderEnabled(string provider) { }
-        public void onProviderDisabled(string provider) { }
-    }
-
-    /// <summary>
-    /// Direct wrapper around android.location.LocationManager via JNI, used as
-    /// a replacement for Unity's Input.location on Android when the user picks
-    /// Auto/GpsOnly/NetworkOnly. Subscribed providers are configurable so the
-    /// position-source picker can rewire live without restart.
-    /// </summary>
-    internal class AndroidLocationProvider
-    {
-        private AndroidJavaObject _activity;
-        private AndroidJavaObject _locationManager;
-        private AndroidLocationProxy _gpsListener;
-        private AndroidLocationProxy _networkListener;
-        private double _lat, _lon;
-        private long _lastTimeMillis;
-        private long _lastLiveTimeMillis;   // Time of most recent NON-cached fix.
-        private bool _hasFix;
-        private bool _hasLiveFix;           // True once any streaming callback fired.
-        private string _activeProvider = "";
-
-        // Captured at Initialize() so the diagnostic can report
-        // "GPS provider DISABLED, only network enabled" etc.
-        private bool _gpsProviderEnabled;
-        private bool _networkProviderEnabled;
-        private bool _gpsLastKnownExists;
-        private bool _networkLastKnownExists;
-        private string _enabledProvidersList = "";
-
-        // Subscription scope - set in Initialize, used in Shutdown to know
-        // which listeners we registered.
-        private bool _subscribedGps;
-        private bool _subscribedNetwork;
-
-        public bool HasFix => _hasFix;
-        public bool HasLiveFix => _hasLiveFix;
-        public long LastLiveTimeMillis => _lastLiveTimeMillis;
-        public long LastTimeMillis => _lastTimeMillis;
-        public double Lat => _lat;
-        public double Lon => _lon;
-        public string ActiveProvider => _activeProvider;
-        public bool GpsProviderEnabled => _gpsProviderEnabled;
-        public bool NetworkProviderEnabled => _networkProviderEnabled;
-        public bool GpsLastKnownExists => _gpsLastKnownExists;
-        public bool NetworkLastKnownExists => _networkLastKnownExists;
-        public string EnabledProvidersList => _enabledProvidersList;
-        public bool SubscribedGps => _subscribedGps;
-        public bool SubscribedNetwork => _subscribedNetwork;
-
-        public bool Initialize(out string error, bool useGps, bool useNetwork)
-        {
-            error = "";
-            try
-            {
-                using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
-                {
-                    _activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
-                }
-                if (_activity == null) { error = "no current activity"; return false; }
-
-                _locationManager = _activity.Call<AndroidJavaObject>("getSystemService", "location");
-                if (_locationManager == null) { error = "getSystemService(\"location\") returned null"; return false; }
-
-                // Capture provider enable state up front so the diagnostic
-                // can distinguish "provider disabled at OS level" from
-                // "provider enabled but produced no fix yet".
-                _gpsProviderEnabled = SafeIsProviderEnabled("gps");
-                _networkProviderEnabled = SafeIsProviderEnabled("network");
-                _enabledProvidersList = SafeGetEnabledProviders();
-
-                Debug.Log($"[GPS-JNI] init useGps={useGps} useNetwork={useNetwork} gps enabled={_gpsProviderEnabled} network enabled={_networkProviderEnabled} all enabled=[{_enabledProvidersList}]");
-
-                // Try cached last-known fixes from the providers we're about
-                // to subscribe to. If the OS already knows where we are
-                // (e.g. from another app that recently used GPS), we get a
-                // fix at zero cost and zero wait time. Tagged isCached so
-                // the diagnostic can mark them and we know we still need
-                // to wait for a streaming callback.
-                if (useNetwork) TryLastKnown("network", out _networkLastKnownExists);
-                if (useGps)     TryLastKnown("gps",     out _gpsLastKnownExists);
-
-                _subscribedGps = useGps;
-                _subscribedNetwork = useNetwork;
-
-                if (useGps)     _gpsListener     = new AndroidLocationProxy { Owner = this };
-                if (useNetwork) _networkListener = new AndroidLocationProxy { Owner = this };
-
-                // requestLocationUpdates must be called on a thread with a
-                // Looper. Use the Activity's UI thread, which always has one.
-                // minTime=1000ms, minDistance=0f - we want updates on every
-                // fix the OS produces. Previously this was 1f which gated
-                // out updates from a stationary phone (MIUI/newer Android
-                // are stricter about this and that's the suspected cause of
-                // "via gps (cached)" sticking forever).
-                _activity.Call("runOnUiThread", new AndroidJavaRunnable(() =>
-                {
-                    if (useGps)
-                    {
-                        try { _locationManager.Call("requestLocationUpdates", "gps", 1000L, 0f, _gpsListener); }
-                        catch (Exception ex) { Debug.LogWarning("[GPS-JNI] gps subscribe failed: " + ex.Message); }
-                    }
-                    if (useNetwork)
-                    {
-                        try { _locationManager.Call("requestLocationUpdates", "network", 1000L, 0f, _networkListener); }
-                        catch (Exception ex) { Debug.LogWarning("[GPS-JNI] network subscribe failed: " + ex.Message); }
-                    }
-                }));
-
-                return true;
-            }
-            catch (Exception ex)
-            {
-                error = "JNI init exception: " + ex.Message;
-                return false;
-            }
-        }
-
-        void TryLastKnown(string provider, out bool nonNullReturned)
-        {
-            nonNullReturned = false;
-            try
-            {
-                var loc = _locationManager.Call<AndroidJavaObject>("getLastKnownLocation", provider);
-                if (loc != null)
-                {
-                    nonNullReturned = true;
-                    double lat = loc.Call<double>("getLatitude");
-                    double lon = loc.Call<double>("getLongitude");
-                    long t = loc.Call<long>("getTime");
-                    UpdateLocation(lat, lon, t, provider, isCached: true);
-                }
-            }
-            catch (Exception ex)
-            {
-                Debug.LogWarning($"[GPS-JNI] getLastKnownLocation({provider}) failed: " + ex.Message);
-            }
-        }
-
-        bool SafeIsProviderEnabled(string provider)
-        {
-            try
-            {
-                return _locationManager.Call<bool>("isProviderEnabled", provider);
-            }
-            catch (Exception ex)
-            {
-                Debug.LogWarning($"[GPS-JNI] isProviderEnabled({provider}) failed: " + ex.Message);
-                return false;
-            }
-        }
-
-        // Build a comma-separated list of currently-enabled providers via
-        // LocationManager.getProviders(true). We iterate the returned
-        // java.util.List by index because AndroidJavaObject does not
-        // implement IEnumerable.
-        string SafeGetEnabledProviders()
-        {
-            try
-            {
-                var list = _locationManager.Call<AndroidJavaObject>("getProviders", true);
-                if (list == null) return "";
-                int size = list.Call<int>("size");
-                var parts = new System.Text.StringBuilder();
-                for (int i = 0; i < size; i++)
-                {
-                    var name = list.Call<string>("get", i);
-                    if (i > 0) parts.Append(",");
-                    parts.Append(name);
-                }
-                return parts.ToString();
-            }
-            catch (Exception ex)
-            {
-                Debug.LogWarning("[GPS-JNI] getProviders failed: " + ex.Message);
-                return "";
-            }
-        }
-
-        public void UpdateLocation(double lat, double lon, long timeMillis, string provider, bool isCached)
-        {
-            // Ignore older fixes if a newer one is already in hand. This lets
-            // both gps + network listeners feed us without ping-ponging
-            // between stale and fresh data.
-            if (timeMillis < _lastTimeMillis) return;
-            _lat = lat;
-            _lon = lon;
-            _lastTimeMillis = timeMillis;
-            // Active-provider name carries cached/live state in the diagnostic
-            // banner so the user can see at a glance whether streaming has
-            // kicked in or we're still on the initial cached snapshot.
-            _activeProvider = (provider ?? "") + (isCached ? " (cached)" : "");
-            _hasFix = true;
-            if (!isCached)
-            {
-                _hasLiveFix = true;
-                _lastLiveTimeMillis = timeMillis;
-            }
-        }
-
-        public void Shutdown()
-        {
-            try
-            {
-                if (_locationManager != null)
-                {
-                    if (_gpsListener != null) _locationManager.Call("removeUpdates", _gpsListener);
-                    if (_networkListener != null) _locationManager.Call("removeUpdates", _networkListener);
-                }
-            }
-            catch (Exception ex)
-            {
-                Debug.LogWarning("[GPS-JNI] Shutdown failed: " + ex.Message);
-            }
-            _gpsListener = null;
-            _networkListener = null;
-            _locationManager = null;
-            _activity = null;
-        }
-    }
-#endif
-    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;
-
-        // PlayerPrefs key for the user's chosen position source. Persists
-        // across app restarts so a user who flipped to UnityInput because
-        // their phone hated the JNI path doesn't have to flip again every
-        // launch.
-        private const string PrefsSourceKey = "PositionSource_v1";
-        private PositionSource _currentSource = PositionSource.Auto;
-
-        // When the multi-client editor test mode picks a non-host bot as
-        // active, we need the host's WASD path to NOT also move. Set true
-        // by GameManager when active slot != 0.
-        public bool SuppressWasd = false;
-
-        private GPSState _GPSState = GPSState.Uninitialized;
-        private float _speed = 0.00001f;
-        private Position _mapCenter;
-        private CoroutineHost _coroutineHost;
-
-        private int _gpsRetryCount = 0;
-        private const int _maxGpsRetries = 5;
-        private float _lastPositionSendTime;
-        private const float _positionKeepAliveSeconds = 1.0f;
-
-        // Diagnostic state. We capture *why* GPS init failed so the UI can
-        // surface it to the user without requiring logcat. Older Android
-        // phones (Mi 9T, A20e) hit silent failure modes that are impossible
-        // to distinguish from "still warming up" without this.
-        private string _lastGpsError = "";
-        private float _gpsInitStartTime = -1f;
-        // Bump from the original 20s. Cold-start GPS on older Android can
-        // easily exceed 20s indoors or under cloud cover - by the time the
-        // user notices nothing is happening, we've already given up.
-        private const int _gpsInitTimeoutSeconds = 60;
-
-#if UNITY_ANDROID && !UNITY_EDITOR
-        // JNI-backed location provider, used for Auto/GpsOnly/NetworkOnly.
-        // UnityInput uses Input.location instead and leaves this null.
-        private AndroidLocationProvider _androidProvider;
-#endif
-
-        /// <summary>Last known GPS position (for CreateLobby centre point)</summary>
-        public Position? LastKnownPosition => _currentPosition.Lat != 0 || _currentPosition.Lon != 0 ? _currentPosition : (Position?)null;
-
-        /// <summary>Current GPS state machine value (debug/diagnostic).</summary>
-        public string GpsStateName => _GPSState.ToString();
-
-        /// <summary>Last GPS error reason captured during init (empty if none).</summary>
-        public string LastGpsError => _lastGpsError ?? "";
-
-        /// <summary>Retry count out of max (debug/diagnostic).</summary>
-        public string GpsRetryProgress => $"{_gpsRetryCount}/{_maxGpsRetries}";
-
-        /// <summary>Currently selected position source (for UI cycle button).</summary>
-        public PositionSource CurrentSource => _currentSource;
-
-        /// <summary>Display name for the current source (for UI label).</summary>
-        public string CurrentSourceName
-        {
-            get
-            {
-                switch (_currentSource)
-                {
-                    case PositionSource.Auto:        return "Auto (GPS+Net)";
-                    case PositionSource.GpsOnly:     return "GPS only";
-                    case PositionSource.NetworkOnly: return "Network only";
-                    case PositionSource.UnityInput:  return "Unity Input";
-                    case PositionSource.EditorWasd:  return "WASD";
-                    default: return _currentSource.ToString();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Human-readable one-line GPS status for on-screen overlay. Designed
-        /// to be visible without ADB so users can self-diagnose permission
-        /// vs. timeout vs. device-disabled vs. running-but-no-fix-yet.
-        /// </summary>
-        public string GpsDiagnostic
-        {
-            get
-            {
-                if (_currentSource == PositionSource.EditorWasd)
-                {
-                    if (_currentPosition.Lat == 0 && _currentPosition.Lon == 0)
-                        return "WASD: waiting for map center";
-                    return $"WASD lat={_currentPosition.Lat:F5} lon={_currentPosition.Lon:F5}";
-                }
-
-                switch (_GPSState)
-                {
-                    case GPSState.Uninitialized:
-                        return "Uninitialized (will start on first lobby action)";
-                    case GPSState.Initializing:
-                    {
-                        float elapsed = _gpsInitStartTime >= 0 ? Time.time - _gpsInitStartTime : 0;
-                        string providers = "";
-#if UNITY_ANDROID && !UNITY_EDITOR
-                        if (_androidProvider != null && !string.IsNullOrEmpty(_androidProvider.EnabledProvidersList))
-                            providers = $" providers=[{_androidProvider.EnabledProvidersList}]";
-#endif
-                        return $"Initializing ({elapsed:F1}s / max {_gpsInitTimeoutSeconds}s){providers}";
-                    }
-                    case GPSState.Running:
-                    {
-                        string suffix = "";
-#if UNITY_ANDROID && !UNITY_EDITOR
-                        if (_androidProvider != null)
-                        {
-                            string p = _androidProvider.ActiveProvider;
-                            if (!string.IsNullOrEmpty(p)) suffix = " via " + p;
-                            // Show how stale the most recent fix is (ms-level
-                            // resolution) so "stuck on cached" is obvious at
-                            // a glance: "via gps (cached) [no live, 47s old]".
-                            if (!_androidProvider.HasLiveFix)
-                            {
-                                long now = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
-                                long ageMs = now - _androidProvider.LastTimeMillis;
-                                if (_androidProvider.LastTimeMillis > 0 && ageMs > 0)
-                                    suffix += $" [no live, {ageMs / 1000}s old]";
-                                else
-                                    suffix += " [no live]";
-                            }
-                            else
-                            {
-                                long now = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
-                                long ageMs = now - _androidProvider.LastLiveTimeMillis;
-                                if (ageMs > 5000) suffix += $" [live {ageMs / 1000}s old]";
-                            }
-                        }
-#endif
-                        if (_currentPosition.Lat == 0 && _currentPosition.Lon == 0)
-                            return "Running but no fix yet (waiting for satellites)" + suffix;
-                        return $"Running lat={_currentPosition.Lat:F5} lon={_currentPosition.Lon:F5}" + suffix;
-                    }
-                    case GPSState.Failed:
-                        return $"Failed: {(_lastGpsError ?? "unknown")} (retries {GpsRetryProgress})";
-                    default:
-                        return "?";
-                }
-            }
-        }
-
-        public GameManager_Input(GameClient gameClient, GameObject player, bool testMode)
-        {
-            _gameClient = gameClient;
-            _player = player;
-            _testMode = testMode;
-            // CoroutineHost needs a MonoBehaviour on a real GameObject
-            var hostGO = new UnityEngine.GameObject("_CoroutineHost");
-            UnityEngine.Object.DontDestroyOnLoad(hostGO);
-            _coroutineHost = hostGO.AddComponent<CoroutineHost>();
-
-            // Restore the user's last picked source. Default depends on
-            // platform: editor defaults to EditorWasd (no GPS hardware in
-            // editor anyway); device defaults to Auto.
-            string saved = PlayerPrefs.GetString(PrefsSourceKey, "");
-            if (!string.IsNullOrEmpty(saved) && Enum.TryParse(saved, out PositionSource parsed))
-            {
-                _currentSource = parsed;
-            }
-            else
-            {
-#if UNITY_EDITOR
-                _currentSource = PositionSource.EditorWasd;
-#else
-                _currentSource = PositionSource.Auto;
-#endif
-            }
-
-            // Legacy testMode flag forces EditorWasd. New code paths should
-            // use SwitchPositionSource(EditorWasd) instead, but we keep the
-            // old behavior for backward compatibility with the inspector flag.
-            if (_testMode) _currentSource = PositionSource.EditorWasd;
-        }
-
-        /// <summary>Called from OnSceneLoaded when Client.unity loads so the
-        /// Player capsule (which lives in Client.unity) can be wired at runtime.</summary>
-        public void SetPlayerObject(GameObject player) { _player = player; }
-
-        /// <summary>
-        /// Switch the active position source backend live. Tears down the
-        /// current backend's listeners (JNI proxies, Input.location), resets
-        /// the state machine, and kicks off init for the new source. Persists
-        /// the choice to PlayerPrefs.
-        /// </summary>
-        public void SwitchPositionSource(PositionSource newSource)
-        {
-            if (_currentSource == newSource) return;
-            Debug.Log($"[GPS] SwitchPositionSource {_currentSource} -> {newSource}");
-
-            // Tear down whatever's running.
-            ShutdownCurrentBackend();
-
-            _currentSource = newSource;
-            PlayerPrefs.SetString(PrefsSourceKey, newSource.ToString());
-            PlayerPrefs.Save();
-
-            _GPSState = GPSState.Uninitialized;
-            _gpsRetryCount = 0;
-            _lastGpsError = "";
-            _gpsInitStartTime = -1f;
-            // Don't clear _currentPosition - the user has presumably been
-            // playing somewhere. Map markers/avatar position can stay until
-            // the next fix arrives from the new source.
-
-            EnsureGPSStarted();
-        }
-
-        /// <summary>Cycle through the available sources for tap-to-cycle UI.</summary>
-        public void CycleNextPositionSource()
-        {
-            var values = (PositionSource[])Enum.GetValues(typeof(PositionSource));
-            int idx = Array.IndexOf(values, _currentSource);
-            var next = values[(idx + 1) % values.Length];
-            SwitchPositionSource(next);
-        }
-
-        private void ShutdownCurrentBackend()
-        {
-#if UNITY_ANDROID && !UNITY_EDITOR
-            if (_androidProvider != null)
-            {
-                _androidProvider.Shutdown();
-                _androidProvider = null;
-            }
-#endif
-            // Stop Unity Input.location too, in case it was running.
-            try { Input.location.Stop(); } catch { }
-        }
-
-        /// <summary>
-        /// Kick off GPS initialization if it hasn't started yet. Safe to call
-        /// repeatedly. Hosts must call this from the lobby setup screen so
-        /// that by the time they click "Create Lobby" we have a real GPS
-        /// fix to use as the play-area center, instead of falling back to
-        /// the hardcoded coordinates.
-        /// </summary>
-        public void EnsureGPSStarted()
-        {
-            if (_currentSource == PositionSource.EditorWasd) return;
-            if (_coroutineHost == null) return;
-            // Allow tapping "Create Lobby" again (or any caller of this
-            // method) to retry from Failed up to _maxGpsRetries times.
-            if (_GPSState == GPSState.Uninitialized)
-            {
-                _coroutineHost.StartCoroutine(InitiallizeGPS());
-            }
-            else if (_GPSState == GPSState.Failed && _gpsRetryCount < _maxGpsRetries)
-            {
-                _gpsRetryCount++;
-                _coroutineHost.StartCoroutine(InitiallizeGPS());
-            }
-        }
-        public void positionCheck()
-        {
-            var state = _gameClient?.CurrentLobbyState;
-            if (state == null || state.Phase != GamePhase.Playing)
-                return;
-
-            try
-            {
-                if (_currentSource == PositionSource.EditorWasd)
-                {
-                    if (_currentPosition == new Position(0, 0))
-                    {
-                        if (state.MapData == null)
-                            return;
-
-                        //Init blok
-                        _currentPosition = state.MapData.Center;
-                        _mapCenter = state.MapData.Center;
-                        _lastSentPosition = _currentPosition;
-                    }
-
-                    if (!SuppressWasd)
-                        TestPlayerPosition();
-                    else
-                        TrySendCurrentPosition(); // keep-alive only
-                }
-                else
-                {
-                    if (_GPSState == GPSState.Uninitialized)
-                    {
-                        _coroutineHost.StartCoroutine(InitiallizeGPS());
-                        return;
-                    }
-                    else if (_GPSState == GPSState.Initializing)
-                    {
-                        return;
-                    }
-                    else if (_GPSState == GPSState.Running)
-                    {
-                        EnsureMapCenter();
-                        TrySendCurrentPosition();
-                    }
-                    else
-                    {
-                        Debug.Log("GPS failed, trying again...");
-                        if (_gpsRetryCount < _maxGpsRetries)
-                        {
-                            _gpsRetryCount++;
-                            _GPSState = GPSState.Uninitialized;
-                        }
-                        else
-                        {
-                            Debug.LogWarning("GPS unavailable after max retries. Using last known position.");
-                            // Keep _GPSState = Failed so we stop retrying
-                        }
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                Debug.LogWarning($"[Input] positionCheck failed: {ex.Message}");
-            }
-        }
-
-        private void EnsureMapCenter()
-        {
-            if (_mapCenter.Lat != 0 || _mapCenter.Lon != 0)
-                return;
-
-            var md = _gameClient?.CurrentLobbyState?.MapData;
-            if (md != null)
-                _mapCenter = md.Center;
-        }
-
-        private void TrySendCurrentPosition()
-        {
-            bool moved = _currentPosition != _lastSentPosition;
-            bool keepAliveDue = (Time.time - _lastPositionSendTime) >= _positionKeepAliveSeconds;
-            if (!moved && !keepAliveDue)
-                return;
-
-            var previous = _lastSentPosition;
-            _gameClient.UpdatePosition(_currentPosition);
-            _lastSentPosition = _currentPosition;
-            _lastPositionSendTime = Time.time;
-
-            if (_player == null || (_mapCenter.Lat == 0 && _mapCenter.Lon == 0))
-                return;
-
-            var localCurrent = _currentPosition.ToLocalVector3(_mapCenter);
-            _player.transform.position = localCurrent;
-
-            if (previous.Lat == 0 && previous.Lon == 0)
-                return;
-
-            var heading = CalculateHeading(previous.ToLocalVector3(_mapCenter), localCurrent);
-            if (heading.HasValue)
-                _player.transform.rotation = Quaternion.Euler(0, (float)heading.Value, 0);
-        }
-
-        private void TestPlayerPosition()
-        {
-            double x = Input.GetAxis("Horizontal");
-            double y = Input.GetAxis("Vertical");
-            _currentPosition = new Position( _lastSentPosition.Lat + y * _speed, _lastSentPosition.Lon + x * _speed);
-            var localCurrent = _currentPosition.ToLocalVector3(_mapCenter);
-            var heading = CalculateHeading(_lastSentPosition.ToLocalVector3(_mapCenter), localCurrent);
-            if (heading != null)
-            {
-                if (_player != null)
-                    _player.transform.rotation = Quaternion.Euler(0, (float)heading, 0);
-            }
-            if (_player != null)
-                _player.transform.position = localCurrent;
-            try
-            {
-                TrySendCurrentPosition();
-            }
-            catch
-            {
-                _gameClient.UpdatePosition(_currentPosition);
-                _lastSentPosition = _currentPosition;
-            }
-        }
-        private double? CalculateHeading(Vector3 first, Vector3 second)
-        {
-            if ((first - second).magnitude < 0.0001f) return null;
-            float dx = second.x - first.x;
-            float dz = second.z - first.z;
-            float heading = Mathf.Atan2(dx, dz) * Mathf.Rad2Deg;
-            if (heading < 0) heading += 360f;
-            return heading;
-        }
-        IEnumerator InitiallizeGPS()
-        {
-            _GPSState = GPSState.Initializing;
-            _gpsInitStartTime = Time.time;
-            _lastGpsError = "";
-
-#if UNITY_ANDROID
-            // Request fine location permission if not already granted.
-            // On Android 12+ a "precise" toggle exists separately from coarse,
-            // but Unity's FineLocation request covers both for our purposes.
-            if (!UnityEngine.Android.Permission.HasUserAuthorizedPermission(UnityEngine.Android.Permission.FineLocation))
-            {
-                UnityEngine.Android.Permission.RequestUserPermission(UnityEngine.Android.Permission.FineLocation);
-                // Wait up to 10 seconds for user to respond to the permission dialog
-                float waited = 0f;
-                while (!UnityEngine.Android.Permission.HasUserAuthorizedPermission(UnityEngine.Android.Permission.FineLocation) && waited < 10f)
-                {
-                    yield return new WaitForSeconds(0.5f);
-                    waited += 0.5f;
-                }
-                if (!UnityEngine.Android.Permission.HasUserAuthorizedPermission(UnityEngine.Android.Permission.FineLocation))
-                {
-                    _lastGpsError = "Permission denied (fine location)";
-                    Debug.LogError("[GPS] " + _lastGpsError);
-                    _GPSState = GPSState.Failed;
-                    yield break;
-                }
-            }
-#endif
-
-#if UNITY_ANDROID && !UNITY_EDITOR
-            // Choose subscription scope based on selected source. UnityInput
-            // skips JNI entirely and falls through to the Input.location path
-            // below (the same path iOS / editor use).
-            if (_currentSource == PositionSource.Auto ||
-                _currentSource == PositionSource.GpsOnly ||
-                _currentSource == PositionSource.NetworkOnly)
-            {
-                bool useGps     = (_currentSource != PositionSource.NetworkOnly);
-                bool useNetwork = (_currentSource != PositionSource.GpsOnly);
-
-                if (_androidProvider != null)
-                {
-                    _androidProvider.Shutdown();
-                    _androidProvider = null;
-                }
-                _androidProvider = new AndroidLocationProvider();
-                if (!_androidProvider.Initialize(out var initError, useGps, useNetwork))
-                {
-                    _lastGpsError = "Native LocationManager failed: " + initError;
-                    Debug.LogError("[GPS] " + _lastGpsError);
-                    _androidProvider = null;
-                    _GPSState = GPSState.Failed;
-                    yield break;
-                }
-
-                // Fast-fail if neither subscribed provider is enabled at OS
-                // level. Waiting 60s for fixes from disabled providers is
-                // pointless - tell the user immediately what's wrong.
-                bool anyUsableEnabled =
-                    (useGps && _androidProvider.GpsProviderEnabled) ||
-                    (useNetwork && _androidProvider.NetworkProviderEnabled);
-                if (!anyUsableEnabled)
-                {
-                    string which = useGps && useNetwork ? "gps + network"
-                                 : useGps ? "gps"
-                                 : "network";
-                    _lastGpsError = $"{which} provider DISABLED at OS level. Open Settings > Location and switch it ON. Or tap [Source] to try a different backend.";
-                    Debug.LogError("[GPS] " + _lastGpsError);
-                    _androidProvider.Shutdown();
-                    _androidProvider = null;
-                    _GPSState = GPSState.Failed;
-                    yield break;
-                }
-
-                // Wait for the first fix (cached or live).
-                int maxWaitJni = _gpsInitTimeoutSeconds;
-                while (!_androidProvider.HasFix && maxWaitJni > 0)
-                {
-                    yield return new WaitForSeconds(1);
-                    maxWaitJni--;
-                }
-
-                if (!_androidProvider.HasFix)
-                {
-                    string enabled = _androidProvider.EnabledProvidersList ?? "";
-                    string gpsState = _androidProvider.GpsProviderEnabled ? "ON" : "OFF";
-                    string netState = _androidProvider.NetworkProviderEnabled ? "ON" : "OFF";
-                    string lastKnown = $"lastKnown[gps={(_androidProvider.GpsLastKnownExists ? "yes" : "no")}, net={(_androidProvider.NetworkLastKnownExists ? "yes" : "no")}]";
-
-                    _lastGpsError = $"Timeout {_gpsInitTimeoutSeconds}s on {_currentSource}. enabled=[{enabled}] gps={gpsState} net={netState} {lastKnown}. Try [Source] cycle to switch backends.";
-                    Debug.LogError("[GPS] " + _lastGpsError);
-                    _androidProvider.Shutdown();
-                    _androidProvider = null;
-                    _GPSState = GPSState.Failed;
-                    yield break;
-                }
-
-                _currentPosition = new Position(_androidProvider.Lat, _androidProvider.Lon);
-                _GPSState = GPSState.Running;
-                _gpsRetryCount = 0;
-                _coroutineHost.StartCoroutine(AndroidGPSService());
-                yield break;
-            }
-
-            // _currentSource == UnityInput on Android: fall through to the
-            // Input.location path below. This is the recovery path for
-            // newer Android phones where JNI's streaming-callbacks don't
-            // fire (MIUI/HyperOS background restrictions, approximate-vs-
-            // precise permission, minDistance gating on stationary phones).
-#endif
-
-            // iOS / editor / non-Android / Android-with-UnityInput-source:
-            // use Unity's Input.location.
-            if (!Input.location.isEnabledByUser)
-            {
-                _lastGpsError = "Location services not enabled by user";
-                Debug.LogError("[GPS] " + _lastGpsError);
-                _GPSState = GPSState.Failed;
-                yield break;
-            }
-
-            float desiredAccuracyInMeters = 5f;
-            float updateDistanceInMeters = 1f;
-
-            Input.location.Start(desiredAccuracyInMeters, updateDistanceInMeters);
-
-            int maxWait = _gpsInitTimeoutSeconds;
-            while (Input.location.status == LocationServiceStatus.Initializing && maxWait > 0)
-            {
-                yield return new WaitForSeconds(1);
-                maxWait--;
-            }
-
-            if (maxWait < 1)
-            {
-                _lastGpsError = $"Timed out after {_gpsInitTimeoutSeconds}s waiting for first fix (try moving outdoors, or tap [Source] to try a different backend)";
-                Debug.LogError("[GPS] " + _lastGpsError);
-                _GPSState = GPSState.Failed;
-                yield break;
-            }
-
-            if (Input.location.status == LocationServiceStatus.Failed)
-            {
-                _lastGpsError = "Unity Input.location reported Failed status";
-                Debug.LogError("[GPS] " + _lastGpsError);
-                _GPSState = GPSState.Failed;
-                yield break;
-            }
-
-            _GPSState = GPSState.Running;
-            _gpsRetryCount = 0;
-            _coroutineHost.StartCoroutine(GPSService());
-        }
-
-#if UNITY_ANDROID && !UNITY_EDITOR
-        /// <summary>
-        /// Mirrors the JNI provider's most recent fix into _currentPosition
-        /// every 0.5s so the rest of the game (which polls _currentPosition
-        /// indirectly via LastKnownPosition / TrySendCurrentPosition) keeps
-        /// working unchanged. Replaces GPSService on Android.
-        /// </summary>
-        IEnumerator AndroidGPSService()
-        {
-            while (_GPSState == GPSState.Running && _androidProvider != null)
-            {
-                if (_androidProvider.HasFix)
-                {
-                    _currentPosition = new Position(_androidProvider.Lat, _androidProvider.Lon);
-                }
-                yield return new WaitForSeconds(0.5f);
-            }
-
-            // Loop ended (state != Running or provider disposed). Clean up
-            // listeners so we don't leak across retries.
-            if (_androidProvider != null)
-            {
-                _androidProvider.Shutdown();
-                _androidProvider = null;
-            }
-        }
-#endif
-        IEnumerator GPSService()
-        {
-            while (_GPSState == GPSState.Running)
-            {
-                if (Input.location.status == LocationServiceStatus.Failed)
-                {
-                    _lastGpsError = "Location service died after init (provider stopped)";
-                    Debug.LogError("[GPS] " + _lastGpsError);
-                    _GPSState = GPSState.Failed;
-                    yield break;
-                }
-
-                // Keep current GPS position fresh; sending is throttled in positionCheck().
-                var data = Input.location.lastData;
-                _currentPosition = new Position(data.latitude, data.longitude);
-                yield return new WaitForSeconds(0.5f);
-            }
-        }
-    }
-}
--- a/Assets/GameManager/GameManager_Input.cs.meta
+++ b/Assets/GameManager/GameManager_Input.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 2ef1abfb1e85a7943925f9dc3cfea742
--- a/Assets/GameManager/GameManager_Map.cs
+++ b/Assets/GameManager/GameManager_Map.cs
@@ -1,808 +0,0 @@
-using GeoSus.Client;
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Globalization;
-using TMPro;
-using UnityEngine;
-using UnityEngine.UI;
-
-
-namespace Subsystems{
-    [System.Serializable]
-    public class BuildingSettings
-    {
-        public Material ResidentialBuildingsMat;
-        public float ResidentialBuildingHeight;
-        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;
-
-        // ── Layer Y separation (single source of truth for vertical stacking) ───
-        // Areas at the bottom, paths above areas, buildings extruded upward from
-        // their own base, POIs floating well above everything else. Z-fighting
-        // happens when adjacent geometry shares a Y; these constants keep each
-        // logical layer at a distinct elevation.
-        private const float kAreaBaseY     = 0.10f;
-        private const float kPathY         = 0.30f;
-        private const float kBuildingBaseY = 0.50f;
-        private const float kPoiY          = 2.00f;
-
-        // Render-queue forcing was tried in P3 to disambiguate same-Y geometry
-        // but turned out to be the cause of the "blank map in mobile game view,
-        // fine in scene view" regression: forcing transparent-class shaders
-        // (default queue 3000+) into the Geometry range (2000-2150) breaks
-        // their depth-write/blend assumptions on mobile shader paths. The
-        // editor's scene view masks it because it uses different render paths
-        // and post-process is off there. Queue forcing removed in P8;
-        // disambiguation is now via Y-layering + per-area Y-stagger alone,
-        // which the depth buffer resolves correctly even on weak mobile GPUs.
-
-        // ── Marker sizing (top-down camera, units = meters) ─────────────────
-        // The camera's orthographic size pushes "1 meter" to a small fraction
-        // of the screen. Markers need to be visibly larger than buildings'
-        // footprints for instant recognition.
-        private const float kMarkerHeight  = 8f;     // pillar height
-        private const float kMarkerRadius  = 3f;     // pillar radius (cylinder X/Z)
-        private const float kMarkerY       = 4f;     // base Y so pillar centers ~mid-height
-        private const float kLabelY        = 9f;     // text label sits above pillar top
-        private const float kLabelFontSize = 14f;    // 3D text size in world units
-
-        // Runtime marker collections
-        private Dictionary<string, GameObject> _taskMarkers   = new Dictionary<string, GameObject>();
-        private Dictionary<string, GameObject> _bodyMarkers   = new Dictionary<string, GameObject>();
-        private Dictionary<string, GameObject> _playerAvatars = new Dictionary<string, GameObject>();
-        private List<GameObject> _sabotageMarkers             = new List<GameObject>();
-
-        public GameManager_Map(GameClient gameClient, GameObject mapCenterPoint, BuildingSettings buildingSettings, PathwaySettings pathwaySettings, AreaSettings areaSettings)
-        {
-            _gameClient = gameClient;
-            _mapCenterPoint = mapCenterPoint;
-            _buildingSettings = buildingSettings;
-            _pathwaySettings = pathwaySettings;
-            _areaSettings = areaSettings;
-        }
-
-        public bool IsSceneReady => _mapCenterPoint != null;
-
-        /// <summary>Called from OnSceneLoaded when Client.unity is loaded so the
-        /// MapCenterPoint (which lives in Client.unity) can be wired at runtime.</summary>
-        public void SetMapCenterPoint(GameObject go) { _mapCenterPoint = go; }
-        public void BuildMap()
-        {
-            if (_mapCenterPoint == null)
-            {
-                Debug.LogWarning("[Map] BuildMap skipped: MapCenterPoint is not yet bound.");
-                return;
-            }
-            if (_gameClient?.CurrentLobbyState?.MapData == null)
-            {
-                Debug.LogWarning("[Map] BuildMap skipped: no MapData in CurrentLobbyState.");
-                return;
-            }
-
-            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;
-            }
-
-            GameObject poiRoot = new GameObject("POIs");
-            poiRoot.transform.parent = _mapCenterPoint.transform;
-            int poiCount = 0;
-            foreach (var poi in _gameClient.CurrentLobbyState.MapData.GetPOIs())
-            {
-                GameObject p = BuildPOIMarker(poi);
-                if (p != null) { p.transform.parent = poiRoot.transform; poiCount++; }
-            }
-
-            // Diagnostic - if the user reports "map missing in game view" but
-            // the counts here are non-zero, the bug is camera/culling related,
-            // not a build issue.
-            int buildings = _gameClient.CurrentLobbyState.MapData.GetBuildings()?.Count ?? 0;
-            int paths     = _gameClient.CurrentLobbyState.MapData.GetPathways()?.Count ?? 0;
-            int areas     = _gameClient.CurrentLobbyState.MapData.GetAreas()?.Count ?? 0;
-            Debug.Log($"[Map] BuildMap done: {buildings} buildings, {paths} paths, " +
-                      $"{areas} areas, {poiCount} POIs. MapCenterPoint={_mapCenterPoint.name} " +
-                      $"layer={_mapCenterPoint.layer} pos={_mapCenterPoint.transform.position} " +
-                      $"scale={_mapCenterPoint.transform.localScale}");
-        }
-
-        /// <summary>
-        /// Build a tall, brightly-colored pillar for a Point of Interest with
-        /// a 3D text label above it (e.g. "FOOD", "SHOP"). The label is laid
-        /// flat on the XZ plane facing UP so it reads correctly under the
-        /// orthogonal top-down camera.
-        /// </summary>
-        private GameObject BuildPOIMarker(MapPOI poi)
-        {
-            if (poi == null) return null;
-            var color = ColorForPOI(poi.POIType);
-            string label = LabelForPOI(poi.POIType);
-            var pos = poi.Location.ToLocalVector3(_centerPosition);
-            return CreateMarkerWithLabel($"POI_{poi.POIType}_{poi.Id}", pos, color, label);
-        }
-
-        /// <summary>
-        /// Shared marker builder: tall colored cylinder pillar + 3D text label
-        /// above it. Used by POIs, tasks, bodies, and sabotage stations so
-        /// they all share a visual language ("colored pillar with a name").
-        /// </summary>
-        private GameObject CreateMarkerWithLabel(string name, Vector3 worldPos, Color color, string label)
-        {
-            var go = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
-            go.name = name;
-
-            // Strip the auto-added collider - markers are visual only.
-            var col = go.GetComponent<Collider>();
-            if (col != null) UnityEngine.Object.Destroy(col);
-
-            go.transform.position = worldPos + Vector3.up * kMarkerY;
-            // Cylinder's default unit is 2 tall, 1 wide. Scale Y by half of
-            // kMarkerHeight (built-in is 2 units), X/Z by kMarkerRadius.
-            go.transform.localScale = new Vector3(kMarkerRadius, kMarkerHeight * 0.5f, kMarkerRadius);
-
-            var mr = go.GetComponent<MeshRenderer>();
-            if (mr != null)
-            {
-                // One .material access -> single clone of the primitive's
-                // default mat. Don't touch renderQueue (P3 regression cause).
-                var inst = mr.material;
-                if (inst != null) inst.color = color;
-            }
-
-            // 3D text label - lays flat on top of the pillar facing up.
-            // Parented to the marker so it follows position changes.
-            var labelGO = new GameObject("Label");
-            labelGO.transform.SetParent(go.transform, worldPositionStays: false);
-            // Local Y offset: pillar's local scale Y is kMarkerHeight/2, but
-            // the cylinder primitive is 2 units tall in local space, so its
-            // top is at local +1. Label sits a hair above that.
-            labelGO.transform.localPosition = new Vector3(0, 1.05f, 0);
-            // Rotate 90 around X so the text quad's normal points +Y (toward
-            // the top-down camera). The default TMP forward is +Z.
-            labelGO.transform.localRotation = Quaternion.Euler(90f, 0f, 0f);
-            // Compensate for the cylinder's non-uniform parent scale so the
-            // text size in world units matches kLabelFontSize regardless of
-            // how the pillar was scaled.
-            labelGO.transform.localScale = new Vector3(
-                1f / kMarkerRadius,
-                1f / (kMarkerHeight * 0.5f),
-                1f / kMarkerRadius);
-
-            var tmp = labelGO.AddComponent<TextMeshPro>();
-            tmp.text = label;
-            tmp.fontSize = kLabelFontSize;
-            tmp.color = Color.white;
-            tmp.fontStyle = FontStyles.Bold;
-            tmp.alignment = TextAlignmentOptions.Center;
-            tmp.outlineColor = Color.black;
-            tmp.outlineWidth = 0.25f;
-            // Reasonable bounds so the text mesh isn't auto-clipped.
-            var rt = tmp.rectTransform;
-            rt.sizeDelta = new Vector2(20, 4);
-
-            return go;
-        }
-
-        private static Color ColorForPOI(MapPOIType type)
-        {
-            switch (type)
-            {
-                case MapPOIType.FoodDrink:  return new Color(1.00f, 0.55f, 0.00f); // orange
-                case MapPOIType.Shop:       return new Color(0.20f, 0.60f, 1.00f); // blue
-                case MapPOIType.Health:     return new Color(0.96f, 0.27f, 0.27f); // red
-                case MapPOIType.Transport:  return new Color(0.85f, 0.85f, 0.20f); // yellow
-                case MapPOIType.Culture:    return new Color(0.65f, 0.30f, 0.95f); // purple
-                case MapPOIType.Landmark:   return new Color(0.95f, 0.85f, 0.40f); // gold
-                case MapPOIType.Recreation: return new Color(0.30f, 0.85f, 0.30f); // green
-                default:                    return new Color(0.75f, 0.75f, 0.80f); // muted grey
-            }
-        }
-
-        private static string LabelForPOI(MapPOIType type)
-        {
-            switch (type)
-            {
-                case MapPOIType.FoodDrink:  return "FOOD";
-                case MapPOIType.Shop:       return "SHOP";
-                case MapPOIType.Health:     return "HEALTH";
-                case MapPOIType.Transport:  return "TRANSIT";
-                case MapPOIType.Culture:    return "CULTURE";
-                case MapPOIType.Landmark:   return "LANDMARK";
-                case MapPOIType.Recreation: return "PARK";
-                default:                    return "POI";
-            }
-        }
-        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. Lift the base above kPathY so building
-            // walls visibly extrude *upward* from above the road/area layer
-            // instead of starting at ground (which made them clip into paved
-            // areas that share their footprint).
-            Vector3 center = CalculatePolygonCenter(b.Outline);
-            building.transform.position = center + Vector3.up * kBuildingBaseY;
-
-            // Vytvoření mesh pro budovu
-            MeshFilter meshFilter = building.AddComponent<MeshFilter>();
-            MeshRenderer meshRenderer = building.AddComponent<MeshRenderer>();
-
-            float height;
-            Material mat;
-            switch (b.BuildingType.ToLower())
-            {
-                case "residential":
-                    mat = _buildingSettings.ResidentialBuildingsMat;
-                    height = _buildingSettings.ResidentialBuildingHeight;
-                    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;
-
-            //TODO: material by type
-            // Použijeme barvu podle typu budovy. Use sharedMaterial to keep
-            // the project's Material asset reference - no clone, no leak.
-            // Y-position alone disambiguates building geometry from area/path
-            // layers; we don't need renderQueue overrides (which broke mobile
-            // rendering for transparent-class shaders in P3).
-            meshRenderer.sharedMaterial = mat;
-
-            // Přidání collideru pro interakci
-            building.AddComponent<MeshCollider>();
-            return building;
-        }
-        GameObject BuildPathwayMesh(MapPathway w)
-        {
-            var path = new GameObject($"Path_{w.Name ?? "Unknown"}");
-
-            // 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;
-            }
-
-            // sharedMaterial avoids the LineRenderer cloning the project's
-            // shared path Material on every BuildMap call. Queue overrides
-            // dropped (P3 mobile-render regression cause).
-            line.sharedMaterial = mat;
-            line.widthMultiplier = width;
-
-            // Nastavení bodů cesty - kPathY sits above all area polygons but
-            // below building bases, so paths visibly run on top of areas.
-            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 = kPathY;
-                line.SetPosition(i, pos);
-            }
-            return path;
-        }
-        GameObject BuildAreaMesh(MapArea a)
-        {
-            var area = new GameObject($"Area_{a.Name ?? "Unknown"}");
-
-            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;
-            }
-            
-            // sharedMaterial: no per-area material clone. Render-queue forcing
-            // dropped in P8 (caused mobile-render regression). The Y-stagger
-            // below alone now drives "smaller polygon on top of larger one"
-            // depth ordering - which is what the depth buffer was always
-            // designed to do, and works on mobile GPUs with weak precision
-            // because the stagger spread (0.04 units) is well above any
-            // reasonable depth-buffer epsilon.
-            meshRenderer.sharedMaterial = mat;
-
-            // Y stagger: smaller polygons sit a hair higher than larger ones,
-            // so depth-test draws them on top of bigger area polygons they sit
-            // inside (e.g. a playground inside a park). Total spread is 0.04
-            // units - visually invisible but plenty for the depth buffer.
-            float yStagger = ComputeAreaYStagger(a.Outline);
-            area.transform.position = new Vector3(0, kAreaBaseY + yStagger, 0);
-
-            return area;
-        }
-
-        /// <summary>
-        /// Returns a non-negative size proxy used to bucket areas by footprint.
-        /// Larger polygons return higher numbers; used inversely for queue/Y.
-        /// </summary>
-        private float AreaSizeBucket(List<Position> outline)
-        {
-            if (outline == null || outline.Count < 3) return 1f;
-            // Cheap bbox area in lat-lon space scaled by 1e6 - we only need a
-            // monotonic ordering, not a real geographic area.
-            double minLat = outline[0].Lat, maxLat = outline[0].Lat;
-            double minLon = outline[0].Lon, maxLon = outline[0].Lon;
-            for (int i = 1; i < outline.Count; i++)
-            {
-                if (outline[i].Lat < minLat) minLat = outline[i].Lat;
-                if (outline[i].Lat > maxLat) maxLat = outline[i].Lat;
-                if (outline[i].Lon < minLon) minLon = outline[i].Lon;
-                if (outline[i].Lon > maxLon) maxLon = outline[i].Lon;
-            }
-            double bbox = (maxLat - minLat) * (maxLon - minLon) * 1e6;
-            return (float)System.Math.Max(0.001, bbox);
-        }
-
-        /// <summary>
-        /// Smaller areas get a higher Y so they render on top of any larger
-        /// area they overlap. Returns a value in [0, 0.04] units.
-        /// </summary>
-        private float ComputeAreaYStagger(List<Position> outline)
-        {
-            float bucket = AreaSizeBucket(outline);
-            // Inverse mapping: huge area -> 0, tiny area -> 0.04.
-            float t = Mathf.Clamp01(1f - bucket / (bucket + 50f));
-            return t * 0.04f;
-        }
-        #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;
-        }
-
-        /// <summary>
-        /// Signed XZ shoelace area for a polygon expressed in local Vector3.
-        /// Positive = CCW (Unity left-handed Y-up: upward-facing normal),
-        /// negative = CW (downward-facing normal -> top face invisible from
-        /// above unless we reverse the winding before triangulating).
-        /// </summary>
-        private static float PolygonSignedAreaXZ(List<Vector3> verts)
-        {
-            float area = 0f;
-            int n = verts.Count;
-            for (int i = 0; i < n; i++)
-            {
-                var a = verts[i];
-                var b = verts[(i + 1) % n];
-                area += (b.x - a.x) * (a.z + b.z);
-            }
-            return area * 0.5f;
-        }
-        private Mesh CreateExtrudedPolygonMesh(List<Position> outline, float height)
-        {
-            Mesh mesh = new Mesh();
-
-            // Reject degenerates - Recast/Overpass can hand back 1-2 vertex
-            // outlines on broken ways. Empty mesh -> renderer draws nothing,
-            // safer than a malformed triangle list.
-            if (outline == null || outline.Count < 3) return mesh;
-
-            // Convert to local space first so we can run a winding check, then
-            // reverse if needed. Without this, CW outlines from Overpass yield
-            // downward-facing top normals and the building roof is invisible
-            // from the top-down map camera.
-            int vertexCount = outline.Count;
-            var localVerts = new List<Vector3>(vertexCount);
-            Vector3 center = CalculatePolygonCenter(outline);
-            for (int i = 0; i < vertexCount; i++)
-                localVerts.Add(outline[i].ToLocalVector3(_gameClient.CurrentLobbyState.MapData.Center) - center);
-
-            if (PolygonSignedAreaXZ(localVerts) < 0f)
-                localVerts.Reverse();
-
-            // Vertices - spodní a horní podstava
-            Vector3[] vertices = new Vector3[vertexCount * 2];
-            for (int i = 0; i < vertexCount; i++)
-            {
-                Vector3 pos = localVerts[i];
-                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();
-
-            // Reject degenerates (matches CreateExtrudedPolygonMesh).
-            if (outline == null || outline.Count < 3) return mesh;
-
-            int vertexCount = outline.Count;
-            var localVerts = new List<Vector3>(vertexCount);
-            Vector3 center = CalculatePolygonCenter(outline);
-            for (int i = 0; i < vertexCount; i++)
-                localVerts.Add(outline[i].ToLocalVector3(_gameClient.CurrentLobbyState.MapData.Center) - center);
-
-            // Force CCW so RecalculateNormals produces an upward-facing normal.
-            // CW polygons from Overpass would otherwise render as black voids
-            // when the top-down camera looks at their back face.
-            if (PolygonSignedAreaXZ(localVerts) < 0f)
-                localVerts.Reverse();
-
-            Vector3[] vertices = localVerts.ToArray();
-
-            // Triangulace - fan pattern
-            List<int> triangles = new List<int>();
-            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
-        #region Markers
-
-        public void CreateTaskMarkers(List<GeoSus.Client.GameTask> tasks)
-        {
-            if (_mapCenterPoint == null) return;
-            if (_centerPosition.Lat == 0 && _centerPosition.Lon == 0)
-            {
-                var md = _gameClient?.CurrentLobbyState?.MapData;
-                if (md != null) _centerPosition = md.Center;
-            }
-            if (_centerPosition.Lat == 0 && _centerPosition.Lon == 0) return;
-            var taskColor = new Color(0.20f, 0.95f, 0.55f); // bright green - "GO HERE"
-            foreach (var task in tasks)
-            {
-                if (_taskMarkers.ContainsKey(task.TaskId)) continue;
-                var pos = task.Location.ToLocalVector3(_centerPosition);
-                var go = CreateMarkerWithLabel($"Task_{task.TaskId}", pos, taskColor, "TASK");
-                go.transform.parent = _mapCenterPoint.transform;
-
-                // Pulsing point light so the task literally glows on the map.
-                var light = go.AddComponent<Light>();
-                light.color = taskColor;
-                light.intensity = 3f;
-                light.range = 25f;
-                _taskMarkers[task.TaskId] = go;
-            }
-        }
-
-        public void RemoveTaskMarker(string taskId)
-        {
-            if (_taskMarkers.TryGetValue(taskId, out var go))
-            {
-                UnityEngine.Object.Destroy(go);
-                _taskMarkers.Remove(taskId);
-            }
-        }
-
-        public void CreateBodyMarker(string bodyId, Position location)
-        {
-            if (_mapCenterPoint == null) return;
-            if (_bodyMarkers.ContainsKey(bodyId)) return;
-            var pos = location.ToLocalVector3(_centerPosition);
-            // Bright red pillar with "BODY" label - players need to see this
-            // from across the map to call it in.
-            var go = CreateMarkerWithLabel($"Body_{bodyId}", pos,
-                new Color(0.96f, 0.18f, 0.18f), "BODY");
-            go.transform.parent = _mapCenterPoint?.transform;
-            _bodyMarkers[bodyId] = go;
-        }
-
-        public void ClearBodyMarkers()
-        {
-            foreach (var go in _bodyMarkers.Values)
-                if (go) UnityEngine.Object.Destroy(go);
-            _bodyMarkers.Clear();
-        }
-
-        // ── Player avatar sizing ────────────────────────────────────────────
-        // The default Unity capsule primitive is 2m tall in local space. The
-        // map camera defaults to 150m orthographic-ish height (see
-        // MapCameraController), so anything smaller than ~3m world-size is a
-        // pixel on screen. Original code used scale=0.4 (~0.8m capsule) which
-        // was invisible. Markers (POIs/tasks/bodies) are 8m pillars; players
-        // need to be visibly distinct from those AND from each other. The
-        // local player gets a halo light + larger scale so the user can find
-        // themselves on the map at a glance.
-        private const float kLocalPlayerScale  = 4f;   // ~8m capsule (matches marker height)
-        private const float kRemotePlayerScale = 2f;   // ~4m capsule (smaller than markers)
-        private const float kLocalPlayerHaloRange = 18f;
-        private const float kLocalPlayerHaloIntensity = 2.5f;
-
-        public void UpdatePlayerAvatars(Dictionary<string, PlayerPositionInfo> positions, string myUuid)
-        {
-            if (_mapCenterPoint == null) return;
-            if (_centerPosition.Lat == 0 && _centerPosition.Lon == 0)
-            {
-                var md = _gameClient?.CurrentLobbyState?.MapData;
-                if (md != null) _centerPosition = md.Center;
-            }
-            if (_centerPosition.Lat == 0 && _centerPosition.Lon == 0) return;
-            foreach (var kvp in positions)
-            {
-                string uuid = kvp.Key;
-                var info = kvp.Value;
-                bool isLocal = uuid == myUuid;
-                if (!_playerAvatars.TryGetValue(uuid, out var go) || go == null)
-                {
-                    go = GameObject.CreatePrimitive(PrimitiveType.Capsule);
-                    go.name = $"Player_{uuid.Substring(0, Mathf.Min(8, uuid.Length))}";
-                    go.transform.parent = _mapCenterPoint?.transform;
-                    // Strip the auto-collider - avatars are visual only and the
-                    // collider would interact with the map's MeshColliders.
-                    var col = go.GetComponent<Collider>();
-                    if (col != null) UnityEngine.Object.Destroy(col);
-
-                    float scale = isLocal ? kLocalPlayerScale : kRemotePlayerScale;
-                    go.transform.localScale = Vector3.one * scale;
-
-                    if (isLocal)
-                    {
-                        // Halo light around the local player so the user can
-                        // find themselves at a glance even at the widest zoom.
-                        // Range/intensity tuned so it reads as "this is me"
-                        // without bleeding far enough to drown POI markers.
-                        var halo = go.AddComponent<Light>();
-                        halo.color = new Color(0.30f, 1.00f, 0.55f); // matches green capsule color
-                        halo.intensity = kLocalPlayerHaloIntensity;
-                        halo.range = kLocalPlayerHaloRange;
-                    }
-
-                    _playerAvatars[uuid] = go;
-                }
-
-                // Lift the avatar so the bottom of the capsule sits roughly at
-                // ground level despite the larger scale. Capsule's local pivot
-                // is at center, height = 2 * localScale.y world units, so we
-                // raise by half the local height.
-                float halfHeight = (isLocal ? kLocalPlayerScale : kRemotePlayerScale);
-                go.transform.position = info.Position.ToLocalVector3(_centerPosition)
-                                      + Vector3.up * halfHeight;
-
-                var mr = go.GetComponent<MeshRenderer>();
-                if (mr)
-                {
-                    if (isLocal) mr.material.color = new Color(0.30f, 1.00f, 0.55f);
-                    else if (info.State == GeoSus.Client.PlayerState.Dead) mr.material.color = Color.grey;
-                    else mr.material.color = Color.white;
-                }
-            }
-        }
-
-        public void CreateSabotageMarkers(List<RepairStationInfo> stations)
-        {
-            var color = new Color(1.0f, 0.55f, 0.0f); // strong orange = repair urgency
-            foreach (var station in stations)
-            {
-                var pos = station.Location.ToLocalVector3(_centerPosition);
-                var go = CreateMarkerWithLabel($"Sabotage_{station.StationId}", pos,
-                    color, "REPAIR");
-                go.transform.parent = _mapCenterPoint?.transform;
-
-                // Repair stations also pulse light so impostors and crew see
-                // the urgency from across the map.
-                var light = go.AddComponent<Light>();
-                light.color = color;
-                light.intensity = 4f;
-                light.range = 30f;
-                _sabotageMarkers.Add(go);
-            }
-        }
-
-        public void ClearSabotageMarkers()
-        {
-            foreach (var go in _sabotageMarkers)
-                if (go) UnityEngine.Object.Destroy(go);
-            _sabotageMarkers.Clear();
-        }
-
-        #endregion
-    }
-}
--- a/Assets/GameManager/GameManager_Map.cs.meta
+++ b/Assets/GameManager/GameManager_Map.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 71870ee18b89dd7438e5362ff9e02a3b
--- a/Assets/GameManager/GameManager_Network.cs
+++ b/Assets/GameManager/GameManager_Network.cs
@@ -2,9 +2,6 @@ using GeoSus.Client;
 using System.Collections;
 using System.Threading.Tasks;
 using UnityEngine;
-using System.Collections.Generic;
-using Subsystems;
-using System.Linq;

 namespace Subsystems
 {
@@ -13,7 +10,6 @@ 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)
@@ -82,31 +78,14 @@ namespace Subsystems
        }
        private void OnGameEvent(GameEvent gameEvent)
        {
-            switch (gameEvent.EventType)
+            switch (gameEvent.Type)
            {
                case "PlayerJoined":
                    Debug.Log($"Player {gameEvent.GetPayload<PlayerJoinedPayload>().DisplayName} joined");
-                    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");
+                    HandlePlayerJoined(gameEvent);
                    break;
                default:
-                    Debug.Log("Received GameEvent of type: " + gameEvent.EventType);
+                    Debug.Log("Received GameEvent of type: " + gameEvent.Type);
                    break;
            }
        }
@@ -132,9 +111,23 @@ 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));
+            _gameClient.CreateLobby(new Position(lat, lon)); 
        }
        public void JoinLobby(string joinCode)
        {
@@ -152,11 +145,8 @@ namespace Subsystems
            _gameClient.Disconnect();
            Application.Quit();
        }
-        public void StartGame()
-        {
-            _gameClient.StartGame();

-        }
+
    }
 }

--- a/Assets/GameManager/GameManager_Network.cs.meta
+++ b/Assets/GameManager/GameManager_Network.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 989e9292fe24c2a4ba95ceae191dd330
--- a/Assets/GameManager/GameManager_UI.cs
+++ b/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,61 +11,25 @@ namespace Subsystems
        private GameClient _gameClient;
        private Canvas _CreateJoinLobby;
        private Canvas _InLobby;
-        private Canvas _LoadingScreen;
-        private Canvas _GameScreen;
-        public GameManager_UI(GameClient gameClient, Canvas CreateJoinLobby, Canvas InLobby, Canvas LoadingScreen, Canvas GameScreen)
+        public GameManager_UI(GameClient gameClient, Canvas CreateJoinLobby, Canvas InLobby)
        {
            _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)
+            _InLobby.enabled = true;
+            _CreateJoinLobby.enabled = false;
+            var playerList = _InLobby.transform.Find("PlayerList").GetComponent<TMPro.TMP_Text>();
+            playerList.text = "";
+            foreach (var player in _gameClient.CurrentLobbyState.Players)
            {
-                _CreateJoinLobby.enabled = true;
-                _InLobby.enabled = false;
-                _GameScreen.enabled = false;
-                _LoadingScreen.enabled = false;
-                return;
+                playerList.text += player.DisplayName + "\n";
            }
-            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;
-                var playerList = _InLobby.transform.Find("PlayerList").GetComponent<TMPro.TMP_Text>();
-                playerList.text = "";
-                foreach (var player in _gameClient.CurrentLobbyState.Players)
-                {
-                    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;
-            }
-            
+            _InLobby.transform.Find("JoinCode").GetComponent<TMPro.TMP_Text>().text = _gameClient.CurrentLobbyState.JoinCode;
        }
    }
 }
--- a/Assets/GameManager/GameManager_UI.cs.meta
+++ b/Assets/GameManager/GameManager_UI.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: cbe0afd6cfb57b44781533cfa4ce4196
--- a/Assets/GameManager/ITask.cs
+++ b/Assets/GameManager/ITask.cs
@@ -2,10 +2,10 @@ using GeoSus.Client;
 using System;
 using UnityEngine;

-/*public enum TaskType
+public enum TaskType
 {
    Task //TODO: Typy úkolù
-}*/
+}



@@ -14,7 +14,7 @@ public interface ITask
    public string TaskID { get; } // Unikátní ID úkolu pro server
    public TaskType TaskType { get; } // Typ úkolu
    public string TaskName { get; } // Viditelný název úkolu
-    public Position TaskLocation { get; } // Polohy na mapì
+    public (double, double) TaskLocation { get; } // Polohy na mapì
    public bool IsCompleted { get; } // Stav dokonèení úkolu

    void Initialize(Action<ITask> onCompleted); // Vytvoøení tasku + naètení postupu
@@ -27,7 +27,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 Position TaskLocation { get; set; } // Poloha na mapì
+    public (double, double) TaskLocation { get; set; } // Poloha na mapì
    public bool IsCompleted { get; private set; } // Stav dokonèení úkolu
    private Action<ITask> _onCompleted; 

--- a/Assets/GameManager/ITask.cs.meta
+++ b/Assets/GameManager/ITask.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: feb806f8c9bbde347862d714c4e96c61
--- a/Assets/GameManager/New
+++ b/Assets/GameManager/New
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: dac0a6a54861f2c438fc5fd58864473d
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/GameManager/TestMaterial.mat
+++ b/Assets/GameManager/TestMaterial.mat
@@ -1,92 +0,0 @@
-%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
--- a/Assets/GameManager/TestMaterial.mat.meta
+++ b/Assets/GameManager/TestMaterial.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 6744524496c8e1549882277283c132cc
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/InputSystem_Actions.inputactions.meta
+++ b/Assets/InputSystem_Actions.inputactions.meta
@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 832a89cb6f62a5240a99d84d09f0a0eb
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/MainScreenUI.meta
+++ b/Assets/MainScreenUI.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 1bc3c07f160332843b2a60af3513f7f6
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/MainScreenUI/Materials.meta
+++ b/Assets/MainScreenUI/Materials.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 624830e44386e5d45a391630cd88151d
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/MainScreenUI/Materials/Zeme_Textura.mat.meta
+++ b/Assets/MainScreenUI/Materials/Zeme_Textura.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 299795d658d037841b1552f783d462c3
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/MainScreenUI/RotaceZeme.cs
+++ b/Assets/MainScreenUI/RotaceZeme.cs
@@ -1,17 +0,0 @@
-using UnityEngine;
-//clankr
-public class RotaceZeme : MonoBehaviour
-{
-    public float rychlost = 20f;
-    // Start is called once before the first execution of Update after the MonoBehaviour is created
-    void Start()
-    {
-
-    }
-
-    // Update is called once per frame
-    void Update()
-    {
-        transform.Rotate(Vector3.up, rychlost * Time.deltaTime);
-    }
-}
--- a/Assets/MainScreenUI/RotaceZeme.cs.meta
+++ b/Assets/MainScreenUI/RotaceZeme.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 2167308ece2e6664fa472e3dff700350
--- a/Assets/MainScreenUI/Zeme_Material.mat
+++ b/Assets/MainScreenUI/Zeme_Material.mat
@@ -1,84 +0,0 @@
-%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: Zeme_Material
-  m_Shader: {fileID: 46, 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:
-    - _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: 2800000, guid: d1443c0777d81e24caecc3991b8bf225, type: 3}
-        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:
-    - _BumpScale: 1
-    - _Cutoff: 0.5
-    - _DetailNormalMapScale: 1
-    - _DstBlend: 0
-    - _GlossMapScale: 1
-    - _Glossiness: 0.414
-    - _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: 1, g: 1, b: 1, a: 1}
-    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/MainScreenUI/Zeme_Material.mat.meta
+++ b/Assets/MainScreenUI/Zeme_Material.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 4cf6d1d65bc4af24fa762f6801fcc7c4
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/MainScreenUI/Zeme_Textura.png
+++ b/Assets/MainScreenUI/Zeme_Textura.png
--- a/Assets/MainScreenUI/Zeme_Textura.png.meta
+++ b/Assets/MainScreenUI/Zeme_Textura.png.meta
@@ -1,143 +0,0 @@
-fileFormatVersion: 2
-guid: d1443c0777d81e24caecc3991b8bf225
-TextureImporter:
-  internalIDToNameTable: []
-  externalObjects: {}
-  serializedVersion: 13
-  mipmaps:
-    mipMapMode: 0
-    enableMipMap: 1
-    sRGBTexture: 1
-    linearTexture: 0
-    fadeOut: 0
-    borderMipMap: 0
-    mipMapsPreserveCoverage: 0
-    alphaTestReferenceValue: 0.5
-    mipMapFadeDistanceStart: 1
-    mipMapFadeDistanceEnd: 3
-  bumpmap:
-    convertToNormalMap: 0
-    externalNormalMap: 0
-    heightScale: 0.25
-    normalMapFilter: 0
-    flipGreenChannel: 0
-  isReadable: 0
-  streamingMipmaps: 0
-  streamingMipmapsPriority: 0
-  vTOnly: 0
-  ignoreMipmapLimit: 0
-  grayScaleToAlpha: 0
-  generateCubemap: 6
-  cubemapConvolution: 0
-  seamlessCubemap: 0
-  textureFormat: 1
-  maxTextureSize: 2048
-  textureSettings:
-    serializedVersion: 2
-    filterMode: 1
-    aniso: 1
-    mipBias: 0
-    wrapU: 0
-    wrapV: 0
-    wrapW: 0
-  nPOTScale: 1
-  lightmap: 0
-  compressionQuality: 50
-  spriteMode: 0
-  spriteExtrude: 1
-  spriteMeshType: 1
-  alignment: 0
-  spritePivot: {x: 0.5, y: 0.5}
-  spritePixelsToUnits: 100
-  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
-  spriteGenerateFallbackPhysicsShape: 1
-  alphaUsage: 1
-  alphaIsTransparency: 0
-  spriteTessellationDetail: -1
-  textureType: 0
-  textureShape: 1
-  singleChannelComponent: 0
-  flipbookRows: 1
-  flipbookColumns: 1
-  maxTextureSizeSet: 0
-  compressionQualitySet: 0
-  textureFormatSet: 0
-  ignorePngGamma: 0
-  applyGammaDecoding: 0
-  swizzle: 50462976
-  cookieLightType: 0
-  platformSettings:
-  - serializedVersion: 4
-    buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 2
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: Standalone
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: Android
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: iOS
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  spriteSheet:
-    serializedVersion: 2
-    sprites: []
-    outline: []
-    customData: 
-    physicsShape: []
-    bones: []
-    spriteID: 
-    internalID: 0
-    vertices: []
-    indices: 
-    edges: []
-    weights: []
-    secondaryTextures: []
-    spriteCustomMetadata:
-      entries: []
-    nameFileIdTable: {}
-  mipmapLimitGroupName: 
-  pSDRemoveMatte: 0
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/MainScreenUI/Zeme_vystup.renderTexture
+++ b/Assets/MainScreenUI/Zeme_vystup.renderTexture
@@ -1,39 +0,0 @@
-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
--- !u!84 &8400000
-RenderTexture:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_Name: Zeme_vystup
-  m_ImageContentsHash:
-    serializedVersion: 2
-    Hash: 00000000000000000000000000000000
-  m_IsAlphaChannelOptional: 0
-  serializedVersion: 6
-  m_Width: 1048
-  m_Height: 1048
-  m_AntiAliasing: 1
-  m_MipCount: -1
-  m_DepthStencilFormat: 94
-  m_ColorFormat: 8
-  m_MipMap: 0
-  m_GenerateMips: 1
-  m_SRGB: 0
-  m_UseDynamicScale: 0
-  m_UseDynamicScaleExplicit: 0
-  m_BindMS: 0
-  m_EnableCompatibleFormat: 1
-  m_EnableRandomWrite: 0
-  m_TextureSettings:
-    serializedVersion: 2
-    m_FilterMode: 1
-    m_Aniso: 0
-    m_MipBias: 0
-    m_WrapU: 1
-    m_WrapV: 1
-    m_WrapW: 1
-  m_Dimension: 2
-  m_VolumeDepth: 1
-  m_ShadowSamplingMode: 2
--- a/Assets/MainScreenUI/Zeme_vystup.renderTexture.meta
+++ b/Assets/MainScreenUI/Zeme_vystup.renderTexture.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 4d595312cdcdd094cbe411227603ceea
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 8400000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/MainScreenUI/Zmekole_geosusv2.fbx
+++ b/Assets/MainScreenUI/Zmekole_geosusv2.fbx
--- a/Assets/MainScreenUI/Zmekole_geosusv2.fbx.meta
+++ b/Assets/MainScreenUI/Zmekole_geosusv2.fbx.meta
@@ -1,110 +0,0 @@
-fileFormatVersion: 2
-guid: 0e125acbe6e192344a3f1c6d4a54f131
-ModelImporter:
-  serializedVersion: 24200
-  internalIDToNameTable: []
-  externalObjects: {}
-  materials:
-    materialImportMode: 2
-    materialName: 0
-    materialSearch: 1
-    materialLocation: 1
-  animations:
-    legacyGenerateAnimations: 4
-    bakeSimulation: 0
-    resampleCurves: 1
-    optimizeGameObjects: 0
-    removeConstantScaleCurves: 0
-    motionNodeName: 
-    animationImportErrors: 
-    animationImportWarnings: 
-    animationRetargetingWarnings: 
-    animationDoRetargetingWarnings: 0
-    importAnimatedCustomProperties: 0
-    importConstraints: 0
-    animationCompression: 1
-    animationRotationError: 0.5
-    animationPositionError: 0.5
-    animationScaleError: 0.5
-    animationWrapMode: 0
-    extraExposedTransformPaths: []
-    extraUserProperties: []
-    clipAnimations: []
-    isReadable: 0
-  meshes:
-    lODScreenPercentages: []
-    globalScale: 1
-    meshCompression: 0
-    addColliders: 0
-    useSRGBMaterialColor: 1
-    sortHierarchyByName: 1
-    importPhysicalCameras: 1
-    importVisibility: 1
-    importBlendShapes: 1
-    importCameras: 1
-    importLights: 1
-    nodeNameCollisionStrategy: 1
-    fileIdsGeneration: 2
-    swapUVChannels: 0
-    generateSecondaryUV: 0
-    useFileUnits: 1
-    keepQuads: 0
-    weldVertices: 1
-    bakeAxisConversion: 0
-    preserveHierarchy: 0
-    skinWeightsMode: 0
-    maxBonesPerVertex: 4
-    minBoneWeight: 0.001
-    optimizeBones: 1
-    generateMeshLods: 0
-    meshLodGenerationFlags: 0
-    maximumMeshLod: -1
-    meshOptimizationFlags: -1
-    indexFormat: 0
-    secondaryUVAngleDistortion: 8
-    secondaryUVAreaDistortion: 15.000001
-    secondaryUVHardAngle: 88
-    secondaryUVMarginMethod: 1
-    secondaryUVMinLightmapResolution: 40
-    secondaryUVMinObjectScale: 1
-    secondaryUVPackMargin: 4
-    useFileScale: 1
-    strictVertexDataChecks: 0
-  tangentSpace:
-    normalSmoothAngle: 60
-    normalImportMode: 0
-    tangentImportMode: 3
-    normalCalculationMode: 4
-    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
-    blendShapeNormalImportMode: 1
-    normalSmoothingSource: 0
-  referencedClips: []
-  importAnimation: 1
-  humanDescription:
-    serializedVersion: 3
-    human: []
-    skeleton: []
-    armTwist: 0.5
-    foreArmTwist: 0.5
-    upperLegTwist: 0.5
-    legTwist: 0.5
-    armStretch: 0.05
-    legStretch: 0.05
-    feetSpacing: 0
-    globalScale: 1
-    rootMotionBoneName: 
-    hasTranslationDoF: 0
-    hasExtraRoot: 0
-    skeletonHasParents: 1
-  lastHumanDescriptionAvatarSource: {instanceID: 0}
-  autoGenerateAvatarMappingIfUnspecified: 1
-  animationType: 2
-  humanoidOversampling: 1
-  avatarSetup: 0
-  addHumanoidExtraRootOnlyWhenUsingAvatar: 1
-  importBlendShapeDeformPercent: 1
-  remapMaterialsIfMaterialImportModeIsNone: 0
-  additionalBone: 0
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/MainScreenUI/textik.mat.meta
+++ b/Assets/MainScreenUI/textik.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: e00f6447ca0dc7646b73cb387d282a47
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials.meta
+++ b/Assets/Materials.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 2230bf768ecb84610af77bea6cdd7074
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/DOMEKBARVA.mat
+++ b/Assets/Materials/DOMEKBARVA.mat
@@ -1,297 +0,0 @@
-%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: DOMEKBARVA
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _EMISSION
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  - _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-  m_LightmapFlags: 1
-  m_EnableInstancingVariants: 0
-  m_DoubleSidedGI: 1
-  m_CustomRenderQueue: -1
-  stringTagMap: {}
-  disabledShaderPasses:
-  - MOTIONVECTORS
-  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}
-    - _BackTex:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _BaseMap:
-        m_Texture: {fileID: 2800000, guid: c72a02e6a4cda274ba055c14119e8b9c, type: 3}
-        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}
-    - _Control:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DecalTex:
-        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}
-    - _DownTex:
-        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}
-    - _FrontTex:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Illum:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _LeftTex:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _LightMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _MainTex:
-        m_Texture: {fileID: 2800000, guid: c72a02e6a4cda274ba055c14119e8b9c, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Mask0:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Mask1:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Mask2:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Mask3:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _MaskTex:
-        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}
-    - _Normal0:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Normal1:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Normal2:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Normal3:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _NormalMap:
-        m_Texture: {fileID: 2800000, guid: c72a02e6a4cda274ba055c14119e8b9c, type: 3}
-        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}
-    - _RightTex:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _SpecGlossMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Splat0:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Splat1:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Splat2:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Splat3:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _TerrainHolesTexture:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _Tex:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _UpTex:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - unity_Lightmaps:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - unity_LightmapsInd:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - unity_ShadowMasks:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    m_Ints: []
-    m_Floats:
-    - PixelSnap: 0
-    - _AddPrecomputedVelocity: 0
-    - _AlphaClip: 0
-    - _AlphaToMask: 0
-    - _AtmosphereThickness: 1
-    - _Blend: 0
-    - _BlendModePreserveSpecular: 1
-    - _BlendOp: 0
-    - _BumpScale: 1
-    - _CameraFadingEnabled: 0
-    - _CameraFarFadeDistance: 2
-    - _CameraNearFadeDistance: 1
-    - _ClearCoatMask: 0
-    - _ClearCoatSmoothness: 0
-    - _ColorMask: 15
-    - _Cull: 0
-    - _CullMode: 18.7
-    - _Cutoff: 0.5
-    - _DetailAlbedoMapScale: 1
-    - _DetailNormalMapScale: 1
-    - _DistortionBlend: 0.5
-    - _DistortionEnabled: 0
-    - _DistortionStrength: 1
-    - _DistortionStrengthScaled: 0
-    - _DstBlend: 0
-    - _DstBlendAlpha: 0
-    - _Emission: 1
-    - _EmissionEnabled: 0
-    - _EnableExternalAlpha: 0
-    - _EnableHeightBlend: 0
-    - _EnableInstancedPerPixelNormal: 1
-    - _EnvironmentReflections: 1
-    - _Exposure: 1.03
-    - _FlipbookMode: 0
-    - _GlossMapScale: 1
-    - _Glossiness: 0
-    - _GlossinessSource: 0
-    - _GlossyReflections: 1
-    - _HeightTransition: 0
-    - _ImageType: 0
-    - _Layout: 2
-    - _LightingEnabled: 1
-    - _Mapping: 1
-    - _Metallic: 0
-    - _Metallic0: 0
-    - _Metallic1: 0
-    - _Metallic2: 0
-    - _Metallic3: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _NumLayersCount: 1
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _QueueOffset: 50
-    - _ReceiveShadows: 1
-    - _Rotation: 0
-    - _SampleGI: 0
-    - _Shininess: 0.7
-    - _Smoothness: 0.5
-    - _Smoothness0: 0.5
-    - _Smoothness1: 0.5
-    - _Smoothness2: 0.5
-    - _Smoothness3: 0.5
-    - _SmoothnessSource: 0
-    - _SmoothnessTextureChannel: 1
-    - _SoftParticlesEnabled: 0
-    - _SoftParticlesFarFadeDistance: 1
-    - _SoftParticlesNearFadeDistance: 0
-    - _SpecSource: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _SrcBlendAlpha: 1
-    - _Stencil: 0
-    - _StencilComp: 8
-    - _StencilOp: 0
-    - _StencilReadMask: 255
-    - _StencilWriteMask: 255
-    - _SunDisk: 2
-    - _SunSize: 0.04
-    - _SunSizeConvergence: 5
-    - _Surface: 0
-    - _UVSec: 0
-    - _UseUIAlphaClip: 0
-    - _WorkflowMode: 1
-    - _XRMotionVectorsPass: 1
-    - _ZWrite: 1
-    m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
-    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
-    - _ClipRect: {r: -11275, g: -32767, b: 32767, a: 32767}
-    - _Color: {r: 0, g: 0.83456206, b: 1, a: 1}
-    - _Emission: {r: 0, g: 0, b: 0, a: 0}
-    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
-    - _Flip: {r: 1, g: 1, b: 1, a: 1}
-    - _GroundColor: {r: 0.36899996, g: 0.34899998, b: 0.34099993, a: 1}
-    - _RendererColor: {r: 1, g: 1, b: 1, a: 1}
-    - _SkyTint: {r: 0.5, g: 0.5, b: 0.5, a: 1}
-    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
-    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/DOMEKBARVA.mat.meta
+++ b/Assets/Materials/DOMEKBARVA.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 43a59ce0be297c44a94d4266bc86174d
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/HDR_multi_nebulae_1.mat
+++ b/Assets/Materials/HDR_multi_nebulae_1.mat
@@ -1,37 +0,0 @@
-%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: HDR_multi_nebulae_1
-  m_Shader: {fileID: 103, 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:
-    - _Tex:
-        m_Texture: {fileID: 8900000, guid: bbe6dc8ab03108a488246bb64d4078ff, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    m_Ints: []
-    m_Floats:
-    - _Exposure: 1
-    - _Rotation: 0
-    m_Colors:
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/HDR_multi_nebulae_1.mat.meta
+++ b/Assets/Materials/HDR_multi_nebulae_1.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: b8ea26def9472484b87d08513faa2756
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/KOMRECNIBARVA.mat
+++ b/Assets/Materials/KOMRECNIBARVA.mat
@@ -1,100 +0,0 @@
-%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: KOMRECNIBARVA
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  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: 2800000, guid: b2aafd5c840033f44a31e8557fc1aee9, type: 3}
-        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
-    - _Exposure: 1
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 1, g: 1, b: 1, 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}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/KOMRECNIBARVA.mat.meta
+++ b/Assets/Materials/KOMRECNIBARVA.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: d7a2ebf8eb383bc43a5203bcaf1b63e2
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/barvamapa1.mat
+++ b/Assets/Materials/barvamapa1.mat
@@ -1,100 +0,0 @@
-%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: barvamapa1
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  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: 2800000, guid: 38ab53fd7c012934f80d87d827371c70, type: 3}
-        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
-    - _Exposure: 1
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 0.11974901, g: 0.3358179, b: 0.5518868, 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}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/barvamapa1.mat.meta
+++ b/Assets/Materials/barvamapa1.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: fbe49e8a4c50f024989408f62bfdcb33
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/barvamapa11.mat
+++ b/Assets/Materials/barvamapa11.mat
@@ -1,100 +0,0 @@
-%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: barvamapa11
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  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: 2800000, guid: 38ab53fd7c012934f80d87d827371c70, type: 3}
-        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
-    - _Exposure: 1
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 0.64017385, g: 0.5382698, b: 0.9056604, 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}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/barvamapa11.mat.meta
+++ b/Assets/Materials/barvamapa11.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 8be50db4bd8c0aa4e884602af1bdccbc
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/barvamapa2.mat
+++ b/Assets/Materials/barvamapa2.mat
@@ -1,100 +0,0 @@
-%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: barvamapa2
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  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: 2800000, guid: 38ab53fd7c012934f80d87d827371c70, type: 3}
-        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
-    - _Exposure: 1
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 0.5707547, g: 0.58085465, b: 1, 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}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/barvamapa2.mat.meta
+++ b/Assets/Materials/barvamapa2.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: f745f6d4b3e89844aadf9e01fcf41cf3
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/barvamapa3.mat
+++ b/Assets/Materials/barvamapa3.mat
@@ -1,100 +0,0 @@
-%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: barvamapa3
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  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: 2800000, guid: 38ab53fd7c012934f80d87d827371c70, type: 3}
-        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
-    - _Exposure: 1
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 0.4009434, g: 0.4009434, b: 0.4009434, 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}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/barvamapa3.mat.meta
+++ b/Assets/Materials/barvamapa3.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: e5e090726056f374dbbd3a626772822f
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/barvamapa4.mat
+++ b/Assets/Materials/barvamapa4.mat
@@ -1,100 +0,0 @@
-%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: barvamapa4
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  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: 2800000, guid: 38ab53fd7c012934f80d87d827371c70, type: 3}
-        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
-    - _Exposure: 1
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 0.5754717, g: 0.5754717, b: 0.5754717, 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}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/barvamapa4.mat.meta
+++ b/Assets/Materials/barvamapa4.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: a83875b5ebf7d7b42a074d07e791fee7
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/barvamapa5.mat
+++ b/Assets/Materials/barvamapa5.mat
@@ -1,100 +0,0 @@
-%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: barvamapa5
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  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: 2800000, guid: 38ab53fd7c012934f80d87d827371c70, type: 3}
-        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
-    - _Exposure: 1
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 0.5566038, g: 0.9338248, b: 1, 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}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/barvamapa5.mat.meta
+++ b/Assets/Materials/barvamapa5.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: c4c816c88b520f649a38ab2b4e1716f4
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/barvamapa6.mat
+++ b/Assets/Materials/barvamapa6.mat
@@ -1,32 +0,0 @@
-%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: barvamapa6
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 2100000, guid: c4c816c88b520f649a38ab2b4e1716f4, type: 2}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  m_LightmapFlags: 4
-  m_EnableInstancingVariants: 0
-  m_DoubleSidedGI: 0
-  m_CustomRenderQueue: -1
-  stringTagMap: {}
-  disabledShaderPasses: []
-  m_LockedProperties: 
-  m_SavedProperties:
-    serializedVersion: 3
-    m_TexEnvs: []
-    m_Ints: []
-    m_Floats: []
-    m_Colors:
-    - _Color: {r: 0.9800406, g: 0.6084906, b: 1, a: 1}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/barvamapa6.mat.meta
+++ b/Assets/Materials/barvamapa6.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 616bfa229ebc56548ae11df790a4cf12
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/barvamapa7.mat
+++ b/Assets/Materials/barvamapa7.mat
@@ -1,100 +0,0 @@
-%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: barvamapa7
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  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: 2800000, guid: 38ab53fd7c012934f80d87d827371c70, type: 3}
-        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
-    - _Exposure: 1
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 0.5754717, g: 0.5754717, b: 0.5754717, 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}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/barvamapa7.mat.meta
+++ b/Assets/Materials/barvamapa7.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 2faa8c507cbdf4e44bda99e39e5ee03d
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/barvamapa8.mat
+++ b/Assets/Materials/barvamapa8.mat
@@ -1,100 +0,0 @@
-%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: barvamapa8
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  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: 2800000, guid: 38ab53fd7c012934f80d87d827371c70, type: 3}
-        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
-    - _Exposure: 1
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 0.63918453, g: 0.8113208, b: 0.36739054, 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}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/barvamapa8.mat.meta
+++ b/Assets/Materials/barvamapa8.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 1848627499bdc424fa11b913e3aa2c1d
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/barvamapa9.mat
+++ b/Assets/Materials/barvamapa9.mat
@@ -1,32 +0,0 @@
-%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: barvamapa9
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 2100000, guid: 8be50db4bd8c0aa4e884602af1bdccbc, type: 2}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  m_LightmapFlags: 4
-  m_EnableInstancingVariants: 0
-  m_DoubleSidedGI: 0
-  m_CustomRenderQueue: -1
-  stringTagMap: {}
-  disabledShaderPasses: []
-  m_LockedProperties: 
-  m_SavedProperties:
-    serializedVersion: 3
-    m_TexEnvs: []
-    m_Ints: []
-    m_Floats: []
-    m_Colors:
-    - _Color: {r: 0.754717, g: 0.40583837, b: 0.40583837, a: 1}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/barvamapa9.mat.meta
+++ b/Assets/Materials/barvamapa9.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 33108960a53974744ae1f1f329275c9d
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/bilabarva.mat
+++ b/Assets/Materials/bilabarva.mat
@@ -1,101 +0,0 @@
-%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: bilabarva
-  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}
-    - _DecalTex:
-        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}
-    - _SpecGlossMap:
-        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: 1, g: 1, b: 1, 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}
-    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/bilabarva.mat.meta
+++ b/Assets/Materials/bilabarva.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 3e5ab1daf40a3b54995d5f1453f1d199
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/industrybarva.mat
+++ b/Assets/Materials/industrybarva.mat
@@ -1,100 +0,0 @@
-%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: industrybarva
-  m_Shader: {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  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: 2800000, guid: 38ab53fd7c012934f80d87d827371c70, type: 3}
-        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
-    - _Exposure: 1
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 1, g: 1, b: 1, 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}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/industrybarva.mat.meta
+++ b/Assets/Materials/industrybarva.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 30078b48eb864694dbcb63ce7a222fc4
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/mapamaterial1.mat
+++ b/Assets/Materials/mapamaterial1.mat
@@ -1,92 +0,0 @@
-%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: mapamaterial1
-  m_Shader: {fileID: 108, guid: 0000000000000000f000000000000000, type: 0}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords: []
-  m_InvalidKeywords:
-  - _MAPPING_LATITUDE_LONGITUDE_LAYOUT
-  m_LightmapFlags: 4
-  m_EnableInstancingVariants: 0
-  m_DoubleSidedGI: 0
-  m_CustomRenderQueue: -1
-  stringTagMap: {}
-  disabledShaderPasses: []
-  m_LockedProperties: 
-  m_SavedProperties:
-    serializedVersion: 3
-    m_TexEnvs:
-    - _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: 2800000, guid: c72a02e6a4cda274ba055c14119e8b9c, type: 3}
-        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:
-    - _BumpScale: 1
-    - _Cutoff: 0.5
-    - _DetailNormalMapScale: 1
-    - _DstBlend: 0
-    - _Exposure: 0.64
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _ImageType: 0
-    - _Layout: 0
-    - _Mapping: 1
-    - _Metallic: 0
-    - _MirrorOnBack: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _Rotation: 0
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 1, g: 1, b: 1, a: 1}
-    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
-    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
--- a/Assets/Materials/mapamaterial1.mat.meta
+++ b/Assets/Materials/mapamaterial1.mat.meta
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 746910162b3ccfe469ca492e61529149
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/mapasketch1.png
+++ b/Assets/Materials/mapasketch1.png
--- a/Assets/Materials/mapasketch1.png.meta
+++ b/Assets/Materials/mapasketch1.png.meta
@@ -1,143 +0,0 @@
-fileFormatVersion: 2
-guid: c72a02e6a4cda274ba055c14119e8b9c
-TextureImporter:
-  internalIDToNameTable: []
-  externalObjects: {}
-  serializedVersion: 13
-  mipmaps:
-    mipMapMode: 0
-    enableMipMap: 1
-    sRGBTexture: 1
-    linearTexture: 0
-    fadeOut: 0
-    borderMipMap: 0
-    mipMapsPreserveCoverage: 0
-    alphaTestReferenceValue: 0.5
-    mipMapFadeDistanceStart: 1
-    mipMapFadeDistanceEnd: 3
-  bumpmap:
-    convertToNormalMap: 0
-    externalNormalMap: 0
-    heightScale: 0.25
-    normalMapFilter: 0
-    flipGreenChannel: 0
-  isReadable: 0
-  streamingMipmaps: 0
-  streamingMipmapsPriority: 0
-  vTOnly: 0
-  ignoreMipmapLimit: 0
-  grayScaleToAlpha: 0
-  generateCubemap: 6
-  cubemapConvolution: 0
-  seamlessCubemap: 0
-  textureFormat: 1
-  maxTextureSize: 2048
-  textureSettings:
-    serializedVersion: 2
-    filterMode: 1
-    aniso: 1
-    mipBias: 0
-    wrapU: 0
-    wrapV: 0
-    wrapW: 0
-  nPOTScale: 1
-  lightmap: 0
-  compressionQuality: 50
-  spriteMode: 2
-  spriteExtrude: 1
-  spriteMeshType: 1
-  alignment: 0
-  spritePivot: {x: 0.5, y: 0.5}
-  spritePixelsToUnits: 100
-  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
-  spriteGenerateFallbackPhysicsShape: 1
-  alphaUsage: 1
-  alphaIsTransparency: 0
-  spriteTessellationDetail: -1
-  textureType: 0
-  textureShape: 1
-  singleChannelComponent: 0
-  flipbookRows: 1
-  flipbookColumns: 1
-  maxTextureSizeSet: 0
-  compressionQualitySet: 0
-  textureFormatSet: 0
-  ignorePngGamma: 0
-  applyGammaDecoding: 0
-  swizzle: 50462976
-  cookieLightType: 0
-  platformSettings:
-  - serializedVersion: 4
-    buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: Standalone
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: Android
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: iOS
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  spriteSheet:
-    serializedVersion: 2
-    sprites: []
-    outline: []
-    customData: 
-    physicsShape: []
-    bones: []
-    spriteID: 
-    internalID: 0
-    vertices: []
-    indices: 
-    edges: []
-    weights: []
-    secondaryTextures: []
-    spriteCustomMetadata:
-      entries: []
-    nameFileIdTable: {}
-  mipmapLimitGroupName: 
-  pSDRemoveMatte: 0
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/mapasketch2.png
+++ b/Assets/Materials/mapasketch2.png
--- a/Assets/Materials/mapasketch2.png.meta
+++ b/Assets/Materials/mapasketch2.png.meta
@@ -1,143 +0,0 @@
-fileFormatVersion: 2
-guid: 38ab53fd7c012934f80d87d827371c70
-TextureImporter:
-  internalIDToNameTable: []
-  externalObjects: {}
-  serializedVersion: 13
-  mipmaps:
-    mipMapMode: 0
-    enableMipMap: 1
-    sRGBTexture: 1
-    linearTexture: 0
-    fadeOut: 0
-    borderMipMap: 0
-    mipMapsPreserveCoverage: 0
-    alphaTestReferenceValue: 0.5
-    mipMapFadeDistanceStart: 1
-    mipMapFadeDistanceEnd: 3
-  bumpmap:
-    convertToNormalMap: 0
-    externalNormalMap: 0
-    heightScale: 0.25
-    normalMapFilter: 0
-    flipGreenChannel: 0
-  isReadable: 0
-  streamingMipmaps: 0
-  streamingMipmapsPriority: 0
-  vTOnly: 0
-  ignoreMipmapLimit: 0
-  grayScaleToAlpha: 0
-  generateCubemap: 6
-  cubemapConvolution: 0
-  seamlessCubemap: 0
-  textureFormat: 1
-  maxTextureSize: 2048
-  textureSettings:
-    serializedVersion: 2
-    filterMode: 1
-    aniso: 1
-    mipBias: 0
-    wrapU: 0
-    wrapV: 0
-    wrapW: 0
-  nPOTScale: 1
-  lightmap: 0
-  compressionQuality: 50
-  spriteMode: 0
-  spriteExtrude: 1
-  spriteMeshType: 1
-  alignment: 0
-  spritePivot: {x: 0.5, y: 0.5}
-  spritePixelsToUnits: 100
-  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
-  spriteGenerateFallbackPhysicsShape: 1
-  alphaUsage: 1
-  alphaIsTransparency: 0
-  spriteTessellationDetail: -1
-  textureType: 0
-  textureShape: 1
-  singleChannelComponent: 0
-  flipbookRows: 1
-  flipbookColumns: 1
-  maxTextureSizeSet: 0
-  compressionQualitySet: 0
-  textureFormatSet: 0
-  ignorePngGamma: 0
-  applyGammaDecoding: 0
-  swizzle: 50462976
-  cookieLightType: 0
-  platformSettings:
-  - serializedVersion: 4
-    buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: Standalone
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: Android
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: iOS
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  spriteSheet:
-    serializedVersion: 2
-    sprites: []
-    outline: []
-    customData: 
-    physicsShape: []
-    bones: []
-    spriteID: 
-    internalID: 0
-    vertices: []
-    indices: 
-    edges: []
-    weights: []
-    secondaryTextures: []
-    spriteCustomMetadata:
-      entries: []
-    nameFileIdTable: {}
-  mipmapLimitGroupName: 
-  pSDRemoveMatte: 0
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/mapasketch3.png
+++ b/Assets/Materials/mapasketch3.png
--- a/Assets/Materials/mapasketch3.png.meta
+++ b/Assets/Materials/mapasketch3.png.meta
@@ -1,143 +0,0 @@
-fileFormatVersion: 2
-guid: b2aafd5c840033f44a31e8557fc1aee9
-TextureImporter:
-  internalIDToNameTable: []
-  externalObjects: {}
-  serializedVersion: 13
-  mipmaps:
-    mipMapMode: 0
-    enableMipMap: 1
-    sRGBTexture: 1
-    linearTexture: 0
-    fadeOut: 0
-    borderMipMap: 0
-    mipMapsPreserveCoverage: 0
-    alphaTestReferenceValue: 0.5
-    mipMapFadeDistanceStart: 1
-    mipMapFadeDistanceEnd: 3
-  bumpmap:
-    convertToNormalMap: 0
-    externalNormalMap: 0
-    heightScale: 0.25
-    normalMapFilter: 0
-    flipGreenChannel: 0
-  isReadable: 0
-  streamingMipmaps: 0
-  streamingMipmapsPriority: 0
-  vTOnly: 0
-  ignoreMipmapLimit: 0
-  grayScaleToAlpha: 0
-  generateCubemap: 6
-  cubemapConvolution: 0
-  seamlessCubemap: 0
-  textureFormat: 1
-  maxTextureSize: 2048
-  textureSettings:
-    serializedVersion: 2
-    filterMode: 1
-    aniso: 1
-    mipBias: 0
-    wrapU: 0
-    wrapV: 0
-    wrapW: 0
-  nPOTScale: 1
-  lightmap: 0
-  compressionQuality: 50
-  spriteMode: 0
-  spriteExtrude: 1
-  spriteMeshType: 1
-  alignment: 0
-  spritePivot: {x: 0.5, y: 0.5}
-  spritePixelsToUnits: 100
-  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
-  spriteGenerateFallbackPhysicsShape: 1
-  alphaUsage: 1
-  alphaIsTransparency: 0
-  spriteTessellationDetail: -1
-  textureType: 0
-  textureShape: 1
-  singleChannelComponent: 0
-  flipbookRows: 1
-  flipbookColumns: 1
-  maxTextureSizeSet: 0
-  compressionQualitySet: 0
-  textureFormatSet: 0
-  ignorePngGamma: 0
-  applyGammaDecoding: 0
-  swizzle: 50462976
-  cookieLightType: 0
-  platformSettings:
-  - serializedVersion: 4
-    buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: Standalone
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: Android
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  - serializedVersion: 4
-    buildTarget: iOS
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    ignorePlatformSupport: 0
-    androidETC2FallbackOverride: 0
-    forceMaximumCompressionQuality_BC6H_BC7: 0
-  spriteSheet:
-    serializedVersion: 2
-    sprites: []
-    outline: []
-    customData: 
-    physicsShape: []
-    bones: []
-    spriteID: 
-    internalID: 0
-    vertices: []
-    indices: 
-    edges: []
-    weights: []
-    secondaryTextures: []
-    spriteCustomMetadata:
-      entries: []
-    nameFileIdTable: {}
-  mipmapLimitGroupName: 
-  pSDRemoveMatte: 0
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/Materials/mapasketch4.png
+++ b/Assets/Materials/mapasketch4.png
--- a/Show More
+++ b/Show More