lab2

Assets/Code/Lab2.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 030a0473af3b411db8cf3a5eecfa4f00
+timeCreated: 1770375687

Assets/Code/Lab2/Arrive.cs

@@ -0,0 +1,39 @@
+using Code.Base;
+
+namespace Code.Lab2
+{
+    public class Arrive : AgentBehaviour
+    {
+        public float targetRadius;
+        public float slowRadius;
+        public float timeToTarget = 0.1f;
+
+        public override Steering GetSteering()
+        {
+            var steering = new Steering();
+            var direction = target.transform.position - transform.position;
+            var distance = direction.magnitude;
+            float targetSpeed;
+            
+            if (distance < targetRadius)
+                return steering;
+            if (distance > slowRadius)
+                targetSpeed = Agent.maxSpeed;
+            else
+                targetSpeed = Agent.maxSpeed * distance / slowRadius;
+
+            var desiredVelocity = direction;
+            desiredVelocity.Normalize();
+            desiredVelocity *= targetSpeed;
+            steering.Linear = desiredVelocity - Agent.velocity;
+            steering.Linear /= timeToTarget;
+
+            if (!(steering.Linear.magnitude > Agent.maxAcceleration)) return steering;
+            
+            steering.Linear.Normalize();
+            steering.Linear *= Agent.maxAcceleration;
+
+            return steering;
+        }
+    }
+}

Assets/Code/Lab2/Arrive.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a971b0661663493c886aaf7cb1b7c1a1
+timeCreated: 1770375702

Assets/Code/Lab2/Leave.cs

@@ -0,0 +1,42 @@
+using Code.Base;
+
+namespace Code.Lab2
+{
+    public class Leave : AgentBehaviour
+    {
+        public float escapeRadius;
+        public float dangerRadius;
+        public float timeToTarget = 0.1f;
+
+        public override Steering GetSteering()
+        {
+            var steering = new Steering();
+            var direction = transform.position - target.transform.position;
+            var distance = direction.magnitude;
+            
+            if (distance > dangerRadius) return steering;
+            
+            float reduce;
+
+            if (distance < escapeRadius)
+                reduce = 0f;
+            else 
+                reduce = distance / dangerRadius * Agent.maxSpeed;
+            
+            var targetSpeed = Agent.maxSpeed - reduce;
+            
+            var desiredVelocity = direction;
+            desiredVelocity.Normalize();
+            desiredVelocity *= targetSpeed;
+            steering.Linear = desiredVelocity - Agent.velocity;
+            steering.Linear /= timeToTarget;
+
+            if (!(steering.Linear.magnitude > Agent.maxAcceleration)) return steering;
+            
+            steering.Linear.Normalize();
+            steering.Linear *= Agent.maxAcceleration;
+
+            return steering;
+        }
+    }
+}

Assets/Code/Lab2/Leave.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 99c7dd3de75b4888b84e02afda7dcb8d
+timeCreated: 1770375985

Assets/Code/UI/Lab2Controller.cs

@@ -0,0 +1,271 @@
+using Code.Base;
+using Code.Lab2;
+using TMPro;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using UnityEngine.UI;
+
+namespace Code.UI
+{
+    public class Lab2Controller : MonoBehaviour
+    {
+        [SerializeField] private Agent arriveAgent;
+        [SerializeField] private Agent leaveAgent;
+
+        [SerializeField] private Transform arriveWrapper;
+        [SerializeField] private Transform leaveWrapper;
+
+        [SerializeField] private Transform arriveTarget;
+        [SerializeField] private Transform leaveTarget;
+
+        [SerializeField] private Button toMenuButton;
+        [SerializeField] private Button resetButton;
+
+        private Slider _arriveTargetRadiusSlider;
+        private Slider _arriveSlowRadiusSlider;
+        private Slider _arriveTimeToTargetSlider;
+        private Slider _arriveMaxSpeedSlider;
+        private Slider _arriveMaxAccelerationSlider;
+        private Slider _arriveOrientationSlider;
+
+        private Slider _leaveEscapeRadiusSlider;
+        private Slider _leaveDangerRadiusSlider;
+        private Slider _leaveTimeToTargetSlider;
+        private Slider _leaveMaxSpeedSlider;
+        private Slider _leaveMaxAccelerationSlider;
+        private Slider _leaveOrientationSlider;
+
+        private TMP_Text _arriveRotationVelocityText;
+        private TMP_Text _leaveRotationVelocityText;
+
+        private Transform _targetCircle;
+        private Transform _slowCircle;
+        private Transform _dangerRadius;
+        private Transform _escapeRadius;
+
+        private Arrive _arriveBehaviour;
+        private Leave _leaveBehaviour;
+
+        private void Awake()
+        {
+            _arriveTargetRadiusSlider = GetSlider(arriveWrapper, "TargetRadiusSlider");
+            _arriveSlowRadiusSlider = GetSlider(arriveWrapper, "SlowRadiusSlider");
+            _arriveTimeToTargetSlider = GetSlider(arriveWrapper, "TimeToTargetSlider");
+            _arriveMaxSpeedSlider = GetSlider(arriveWrapper, "MaxSpeedSlider");
+            _arriveMaxAccelerationSlider = GetSlider(arriveWrapper, "MaxAccelerationSlider");
+            _arriveOrientationSlider = GetSlider(arriveWrapper, "OrientationSlider");
+
+            _leaveEscapeRadiusSlider = GetSlider(leaveWrapper, "EscapeRadiusSlider");
+            _leaveDangerRadiusSlider = GetSlider(leaveWrapper, "DangerRadiusSlider");
+            _leaveTimeToTargetSlider = GetSlider(leaveWrapper, "TimeToTargetSlider");
+            _leaveMaxSpeedSlider = GetSlider(leaveWrapper, "MaxSpeedSlider");
+            _leaveMaxAccelerationSlider = GetSlider(leaveWrapper, "MaxAccelerationSlider");
+            _leaveOrientationSlider = GetSlider(leaveWrapper, "OrientationSlider");
+
+            _arriveRotationVelocityText = GetText(arriveWrapper, "RotationVelocityText");
+            _leaveRotationVelocityText = GetText(leaveWrapper, "RotationVelocityText");
+
+            _targetCircle = arriveTarget?.Find("TargetCircle");
+            _slowCircle = arriveTarget?.Find("SlowCircle");
+            _dangerRadius = leaveTarget?.Find("DangerRadius");
+            _escapeRadius = leaveTarget?.Find("EscapeRadius");
+
+            _arriveBehaviour = arriveAgent.GetComponent<Arrive>();
+            _leaveBehaviour = leaveAgent.GetComponent<Leave>();
+
+            if (_arriveBehaviour == null) Debug.LogWarning("ArriveBehaviour not found on ArriveAgent!");
+            if (_leaveBehaviour == null) Debug.LogWarning("LeaveBehaviour not found on LeaveAgent!");
+
+            if (toMenuButton != null)
+                toMenuButton.onClick.AddListener(LoadMainMenu);
+            if (resetButton != null)
+                resetButton.onClick.AddListener(ResetAgents);
+        }
+
+        private void Start()
+        {
+            UpdateArriveSliders();
+            UpdateLeaveSliders();
+
+            if (_arriveTargetRadiusSlider != null) _arriveTargetRadiusSlider.onValueChanged.AddListener(OnArriveTargetRadiusChanged);
+            if (_arriveSlowRadiusSlider != null) _arriveSlowRadiusSlider.onValueChanged.AddListener(OnArriveSlowRadiusChanged);
+            if (_arriveTimeToTargetSlider != null) _arriveTimeToTargetSlider.onValueChanged.AddListener(OnArriveTimeToTargetChanged);
+            if (_arriveMaxSpeedSlider != null) _arriveMaxSpeedSlider.onValueChanged.AddListener(OnArriveMaxSpeedChanged);
+            if (_arriveMaxAccelerationSlider != null) _arriveMaxAccelerationSlider.onValueChanged.AddListener(OnArriveMaxAccelerationChanged);
+            if (_arriveOrientationSlider != null) _arriveOrientationSlider.onValueChanged.AddListener(OnArriveOrientationChanged);
+
+            if (_leaveEscapeRadiusSlider != null) _leaveEscapeRadiusSlider.onValueChanged.AddListener(OnLeaveEscapeRadiusChanged);
+            if (_leaveDangerRadiusSlider != null) _leaveDangerRadiusSlider.onValueChanged.AddListener(OnLeaveDangerRadiusChanged);
+            if (_leaveTimeToTargetSlider != null) _leaveTimeToTargetSlider.onValueChanged.AddListener(OnLeaveTimeToTargetChanged);
+            if (_leaveMaxSpeedSlider != null) _leaveMaxSpeedSlider.onValueChanged.AddListener(OnLeaveMaxSpeedChanged);
+            if (_leaveMaxAccelerationSlider != null) _leaveMaxAccelerationSlider.onValueChanged.AddListener(OnLeaveMaxAccelerationChanged);
+            if (_leaveOrientationSlider != null) _leaveOrientationSlider.onValueChanged.AddListener(OnLeaveOrientationChanged);
+        }
+
+        private void Update()
+        {
+            UpdateArriveSliders();
+            UpdateLeaveSliders();
+        }
+
+        private static Slider GetSlider(Transform parent, string name) =>
+            parent?.Find(name)?.GetComponent<Slider>();
+
+        private static TMP_Text GetText(Transform parent, string name) =>
+            parent?.Find(name)?.GetComponent<TMP_Text>();
+
+        private void UpdateArriveSliders()
+        {
+            if (_arriveBehaviour == null) return;
+
+            if (_arriveTargetRadiusSlider != null) _arriveTargetRadiusSlider.value = _arriveBehaviour.targetRadius;
+            if (_arriveSlowRadiusSlider != null) _arriveSlowRadiusSlider.value = _arriveBehaviour.slowRadius;
+            if (_arriveTimeToTargetSlider != null) _arriveTimeToTargetSlider.value = _arriveBehaviour.timeToTarget;
+            if (_arriveMaxSpeedSlider != null) _arriveMaxSpeedSlider.value = arriveAgent.maxSpeed;
+            if (_arriveMaxAccelerationSlider != null) _arriveMaxAccelerationSlider.value = arriveAgent.maxAcceleration;
+            if (_arriveOrientationSlider != null) _arriveOrientationSlider.value = arriveAgent.orientation;
+
+            if (_targetCircle != null) _targetCircle.localScale = new Vector3(_arriveBehaviour.targetRadius * 2, _arriveBehaviour.targetRadius * 2, 1f);
+            if (_slowCircle != null) _slowCircle.localScale = new Vector3(_arriveBehaviour.slowRadius * 2, _arriveBehaviour.slowRadius * 2, 1f);
+
+            if (_arriveRotationVelocityText == null) return;
+            
+            var rot = arriveAgent.rotation;
+            var vel = arriveAgent.velocity;
+            _arriveRotationVelocityText.text =
+                $"Rotation: {rot:F2}\nVelocity: X {vel.x:F2} Y {vel.y:F2} Z {vel.z:F2}";
+        }
+
+        private void OnArriveTargetRadiusChanged(float value)
+        {
+            if (_arriveBehaviour == null) return;
+            
+            _arriveBehaviour.targetRadius = value;
+            if (_targetCircle != null) _targetCircle.localScale = new Vector3(value, value, value);
+        }
+
+        private void OnArriveSlowRadiusChanged(float value)
+        {
+            if (_arriveBehaviour == null) return;
+            
+            _arriveBehaviour.slowRadius = value;
+            if (_slowCircle != null) _slowCircle.localScale = new Vector3(value, value, value);
+        }
+
+        private void OnArriveTimeToTargetChanged(float value)
+        {
+            if (_arriveBehaviour != null) _arriveBehaviour.timeToTarget = value;
+        }
+
+        private void OnArriveMaxSpeedChanged(float value)
+        {
+            if (arriveAgent != null) arriveAgent.maxSpeed = value;
+        }
+
+        private void OnArriveMaxAccelerationChanged(float value)
+        {
+            if (arriveAgent != null) arriveAgent.maxAcceleration = value;
+        }
+
+        private void OnArriveOrientationChanged(float value)
+        {
+            if (arriveAgent != null) arriveAgent.orientation = value % 360f;
+        }
+
+        private void UpdateLeaveSliders()
+        {
+            if (_leaveBehaviour == null) return;
+
+            if (_leaveEscapeRadiusSlider != null) _leaveEscapeRadiusSlider.value = _leaveBehaviour.escapeRadius;
+            if (_leaveDangerRadiusSlider != null) _leaveDangerRadiusSlider.value = _leaveBehaviour.dangerRadius;
+            if (_leaveTimeToTargetSlider != null) _leaveTimeToTargetSlider.value = _leaveBehaviour.timeToTarget;
+            if (_leaveMaxSpeedSlider != null) _leaveMaxSpeedSlider.value = leaveAgent.maxSpeed;
+            if (_leaveMaxAccelerationSlider != null) _leaveMaxAccelerationSlider.value = leaveAgent.maxAcceleration;
+            if (_leaveOrientationSlider != null) _leaveOrientationSlider.value = leaveAgent.orientation;
+
+            if (_dangerRadius != null) _dangerRadius.localScale = new Vector3(_leaveBehaviour.dangerRadius * 2, _leaveBehaviour.dangerRadius * 2, 1f);
+            if (_escapeRadius != null) _escapeRadius.localScale = new Vector3(_leaveBehaviour.escapeRadius * 2, _leaveBehaviour.escapeRadius * 2, 1f);
+
+            if (_leaveRotationVelocityText == null) return;
+            
+            var rot = leaveAgent.rotation;
+            var vel = leaveAgent.velocity;
+            _leaveRotationVelocityText.text =
+                $"Rotation: {rot:F2}\nVelocity: X {vel.x:F2} Y {vel.y:F2} Z {vel.z:F2}";
+        }
+
+        private void OnLeaveEscapeRadiusChanged(float value)
+        {
+            if (_leaveBehaviour == null) return;
+            
+            _leaveBehaviour.escapeRadius = value;
+            if (_escapeRadius != null) _escapeRadius.localScale = new Vector3(value, value, 1f);
+        }
+
+        private void OnLeaveDangerRadiusChanged(float value)
+        {
+            if (_leaveBehaviour == null) return;
+            
+            _leaveBehaviour.dangerRadius = value;
+            if (_dangerRadius != null) _dangerRadius.localScale = new Vector3(value, value, 1f);
+        }
+
+        private void OnLeaveTimeToTargetChanged(float value)
+        {
+            if (_leaveBehaviour != null) _leaveBehaviour.timeToTarget = value;
+        }
+
+        private void OnLeaveMaxSpeedChanged(float value)
+        {
+            if (leaveAgent != null) leaveAgent.maxSpeed = value;
+        }
+
+        private void OnLeaveMaxAccelerationChanged(float value)
+        {
+            if (leaveAgent != null) leaveAgent.maxAcceleration = value;
+        }
+
+        private void OnLeaveOrientationChanged(float value)
+        {
+            if (leaveAgent != null) leaveAgent.orientation = value % 360f;
+        }
+
+        private void ResetAgents()
+        {
+            if (leaveAgent != null && leaveTarget != null)
+            {
+                var pos = leaveAgent.transform.position;
+                pos.x = leaveTarget.position.x;
+                pos.z = leaveTarget.position.z;
+                leaveAgent.transform.position = pos;
+            }
+
+            if (arriveAgent == null || _arriveBehaviour == null) return;
+            
+            var slowRadius = _arriveBehaviour.slowRadius;
+            arriveAgent.transform.position = new Vector3(-slowRadius, 1f, 0f);
+        }
+
+        private static void LoadMainMenu() => SceneManager.LoadScene("MainMenu");
+
+        private void OnDestroy()
+        {
+            if (_arriveTargetRadiusSlider != null) _arriveTargetRadiusSlider.onValueChanged.RemoveListener(OnArriveTargetRadiusChanged);
+            if (_arriveSlowRadiusSlider != null) _arriveSlowRadiusSlider.onValueChanged.RemoveListener(OnArriveSlowRadiusChanged);
+            if (_arriveTimeToTargetSlider != null) _arriveTimeToTargetSlider.onValueChanged.RemoveListener(OnArriveTimeToTargetChanged);
+            if (_arriveMaxSpeedSlider != null) _arriveMaxSpeedSlider.onValueChanged.RemoveListener(OnArriveMaxSpeedChanged);
+            if (_arriveMaxAccelerationSlider != null) _arriveMaxAccelerationSlider.onValueChanged.RemoveListener(OnArriveMaxAccelerationChanged);
+            if (_arriveOrientationSlider != null) _arriveOrientationSlider.onValueChanged.RemoveListener(OnArriveOrientationChanged);
+
+            if (_leaveEscapeRadiusSlider != null) _leaveEscapeRadiusSlider.onValueChanged.RemoveListener(OnLeaveEscapeRadiusChanged);
+            if (_leaveDangerRadiusSlider != null) _leaveDangerRadiusSlider.onValueChanged.RemoveListener(OnLeaveDangerRadiusChanged);
+            if (_leaveTimeToTargetSlider != null) _leaveTimeToTargetSlider.onValueChanged.RemoveListener(OnLeaveTimeToTargetChanged);
+            if (_leaveMaxSpeedSlider != null) _leaveMaxSpeedSlider.onValueChanged.RemoveListener(OnLeaveMaxSpeedChanged);
+            if (_leaveMaxAccelerationSlider != null) _leaveMaxAccelerationSlider.onValueChanged.RemoveListener(OnLeaveMaxAccelerationChanged);
+            if (_leaveOrientationSlider != null) _leaveOrientationSlider.onValueChanged.RemoveListener(OnLeaveOrientationChanged);
+
+            if (toMenuButton != null) toMenuButton.onClick.RemoveListener(LoadMainMenu);
+            if (resetButton != null) resetButton.onClick.RemoveListener(ResetAgents);
+        }
+    }
+}

Assets/Code/UI/Lab2Controller.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 341aa60b8bff45888899f4cbc8cd60bd
+timeCreated: 1770379327

Assets/Resources/Materials/Target.mat

@@ -0,0 +1,137 @@
+%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: Target
+  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    RenderType: Opaque
+  disabledShaderPasses:
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 10309, guid: 0000000000000000f000000000000000, type: 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: 10309, guid: 0000000000000000f000000000000000, type: 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}
+    - 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:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _ClearCoatMask: 0
+    - _ClearCoatSmoothness: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailAlbedoMapScale: 1
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _EnvironmentReflections: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.005
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _WorkflowMode: 1
+    - _XRMotionVectorsPass: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0.5896226, g: 1, b: 1, a: 1}
+    - _Color: {r: 0.58962256, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &8496668540796800970
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Unity.RenderPipelines.Universal.Editor::UnityEditor.Rendering.Universal.AssetVersion
+  version: 10

Assets/Resources/Materials/Target.mat.meta

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

Assets/Resources/Scenes/Lab2.unity.meta

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