app.hypergames.hypersdk 1.10.0 → 1.11.0-beta.2

package/Samples~/LaneRunner/Prefabs/DoubleScorePickup.prefab

@@ -0,0 +1,152 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &4122494009787179883
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 6433609908091535661}
+  - component: {fileID: 7121910225939348887}
+  - component: {fileID: 7832153223912747726}
+  - component: {fileID: 245166456015105769}
+  - component: {fileID: 2803258236501787411}
+  - component: {fileID: 3724547471223867592}
+  m_Layer: 0
+  m_Name: DoubleScorePickup
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &6433609908091535661
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4122494009787179883}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1.05, y: 1.05, z: 1.05}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &7121910225939348887
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4122494009787179883}
+  m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!135 &7832153223912747726
+SphereCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4122494009787179883}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 1
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Radius: 0.5
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &245166456015105769
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4122494009787179883}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 5477d0aea0bf80a48be0dbf9edbae95a, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!54 &2803258236501787411
+Rigidbody:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4122494009787179883}
+  serializedVersion: 4
+  m_Mass: 1
+  m_Drag: 0
+  m_AngularDrag: 0.05
+  m_CenterOfMass: {x: 0, y: 0, z: 0}
+  m_InertiaTensor: {x: 1, y: 1, z: 1}
+  m_InertiaRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ImplicitCom: 1
+  m_ImplicitTensor: 1
+  m_UseGravity: 0
+  m_IsKinematic: 1
+  m_Interpolate: 0
+  m_Constraints: 0
+  m_CollisionDetection: 0
+--- !u!114 &3724547471223867592
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4122494009787179883}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d30ecc4be65668940a5990199de8c899, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  doubleScorePickup: 1

package/Samples~/LaneRunner/Prefabs/DoubleScorePickup.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 65f7b19e5cea1f94fb69dba009f042a0
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Samples~/LaneRunner/Prefabs/Obstacle.prefab

@@ -0,0 +1,152 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &6430252537693784949
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2742232547165175125}
+  - component: {fileID: 4471148443040927750}
+  - component: {fileID: 705868622986271356}
+  - component: {fileID: 597113936367337497}
+  - component: {fileID: 8610291193526034833}
+  - component: {fileID: 6935381596637914183}
+  m_Layer: 0
+  m_Name: Obstacle
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2742232547165175125
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6430252537693784949}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1.35, y: 1.5, z: 1.55}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &4471148443040927750
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6430252537693784949}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!65 &705868622986271356
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6430252537693784949}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 1
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &597113936367337497
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6430252537693784949}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 0d5a2abe57852794ca0154f6270b5e8e, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!54 &8610291193526034833
+Rigidbody:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6430252537693784949}
+  serializedVersion: 4
+  m_Mass: 1
+  m_Drag: 0
+  m_AngularDrag: 0.05
+  m_CenterOfMass: {x: 0, y: 0, z: 0}
+  m_InertiaTensor: {x: 1, y: 1, z: 1}
+  m_InertiaRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ImplicitCom: 1
+  m_ImplicitTensor: 1
+  m_UseGravity: 0
+  m_IsKinematic: 1
+  m_Interpolate: 0
+  m_Constraints: 0
+  m_CollisionDetection: 0
+--- !u!114 &6935381596637914183
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6430252537693784949}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d30ecc4be65668940a5990199de8c899, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  doubleScorePickup: 0

package/Samples~/LaneRunner/Prefabs/Obstacle.prefab.meta

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

package/Samples~/LaneRunner/Prefabs.meta

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

package/Samples~/LaneRunner/README.md

@@ -0,0 +1,35 @@
+# Lane Runner Sample
+
+Lane Runner is a small, scene-authored Hyper game showing score reporting,
+deterministic spawning, a timed score multiplier, and replay integration.
+
+## Play
+
+- Use `A` / `D` or the arrow keys to change lanes.
+- Press `Space` or swipe up to jump.
+- Avoid red obstacles.
+- Collect the yellow pickup for five seconds of double score.
+
+Assign `LaneRunnerSample` as the Game and Practice scene in Hyper Game Content
+Config, then use Hyper's Editor game-mode menu to run Practice, Battle, or Replay.
+Battle sessions record to `hyper-replay.ndjson` in `Application.persistentDataPath`.
+
+## Integration structure
+
+- `LaneRunnerGame` owns rules, score, speed, and power-up state.
+- `LaneRunnerPlayer` owns physical input and applies commands in `FixedUpdate`.
+- `LaneRunnerSpawner` creates deterministic rows using `HyperRandom`.
+- `LaneRunnerTournamentAdapter` connects score, power-ups, and lifecycle to HyperSDK.
+- `LaneRunnerReplayAdapter` records accepted commands and injects replay commands
+  through the same player path.
+
+The replay adapter does not move or jump the player directly. It records commands
+after the player accepts them and routes playback back through `QueueCommand`:
+
+```csharp
+HyperSDK.Data.RecordActivity("Jump");
+HyperSDK.Replay.OnAction += HandleReplayAction;
+```
+
+`RecordActivity` records only during active Battle gameplay. The SDK owns replay
+timestamps, file loading, scheduling, pause handling, progress, and completion.

package/Samples~/LaneRunner/README.md.meta

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

package/Samples~/LaneRunner/Scripts/Gameplay/LaneRunnerCommand.cs

@@ -0,0 +1,9 @@
+namespace HyperSamples.LaneRunner
+{
+    public enum LaneRunnerCommand
+    {
+        MoveLeft,
+        MoveRight,
+        Jump
+    }
+}

package/Samples~/LaneRunner/Scripts/Gameplay/LaneRunnerCommand.cs.meta

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

package/Samples~/LaneRunner/Scripts/Gameplay/LaneRunnerGame.cs

@@ -0,0 +1,93 @@
+using System;
+using UnityEngine;
+
+namespace HyperSamples.LaneRunner
+{
+    public sealed class LaneRunnerGame : MonoBehaviour
+    {
+        [SerializeField] private LaneRunnerPlayer player;
+        [SerializeField] private LaneRunnerSpawner spawner;
+        [SerializeField] private float startingSpeed = 7f;
+        [SerializeField] private float maximumSpeed = 15f;
+        [SerializeField] private float accelerationPerSecond = 0.12f;
+        [SerializeField] private float scorePerMeter = 10f;
+        [SerializeField] private float doubleScoreDuration = 5f;
+
+        public event Action<int> ScoreChanged;
+        public event Action<bool> DoubleScoreChanged;
+        public event Action GameOverRequested;
+
+        public bool IsRunning { get; private set; }
+        public int Score { get; private set; }
+        public float CurrentSpeed { get; private set; }
+
+        private float elapsed;
+        private float preciseScore;
+        private float doubleScoreRemaining;
+
+        private void FixedUpdate()
+        {
+            if (!IsRunning) return;
+
+            elapsed += Time.fixedDeltaTime;
+            CurrentSpeed = Mathf.Min(maximumSpeed,
+                startingSpeed + accelerationPerSecond * elapsed);
+
+            float multiplier = doubleScoreRemaining > 0f ? 2f : 1f;
+            preciseScore += CurrentSpeed * Time.fixedDeltaTime * scorePerMeter * multiplier;
+            int nextScore = Mathf.FloorToInt(preciseScore);
+            if (nextScore != Score)
+            {
+                Score = nextScore;
+                ScoreChanged?.Invoke(Score);
+            }
+
+            if (doubleScoreRemaining > 0f)
+            {
+                doubleScoreRemaining -= Time.fixedDeltaTime;
+                if (doubleScoreRemaining <= 0f)
+                    DoubleScoreChanged?.Invoke(false);
+            }
+
+            spawner.Tick(CurrentSpeed, Time.fixedDeltaTime);
+        }
+
+        public void Begin(bool allowPhysicalInput)
+        {
+            elapsed = 0f;
+            preciseScore = 0f;
+            doubleScoreRemaining = 0f;
+            Score = 0;
+            CurrentSpeed = startingSpeed;
+            IsRunning = true;
+
+            player.Begin(allowPhysicalInput);
+            spawner.Begin(this);
+            ScoreChanged?.Invoke(0);
+            DoubleScoreChanged?.Invoke(false);
+        }
+
+        public void Stop()
+        {
+            IsRunning = false;
+            player.Stop();
+            spawner.Clear();
+        }
+
+        public void HitObstacle()
+        {
+            if (!IsRunning) return;
+            IsRunning = false;
+            player.Stop();
+            GameOverRequested?.Invoke();
+        }
+
+        public void CollectDoubleScore()
+        {
+            if (!IsRunning) return;
+            bool wasInactive = doubleScoreRemaining <= 0f;
+            doubleScoreRemaining = doubleScoreDuration;
+            if (wasInactive) DoubleScoreChanged?.Invoke(true);
+        }
+    }
+}

package/Samples~/LaneRunner/Scripts/Gameplay/LaneRunnerGame.cs.meta

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

package/Samples~/LaneRunner/Scripts/Gameplay/LaneRunnerPlayer.cs

@@ -0,0 +1,155 @@
+using System;
+using UnityEngine;
+
+namespace HyperSamples.LaneRunner
+{
+    [RequireComponent(typeof(Rigidbody), typeof(BoxCollider))]
+    public sealed class LaneRunnerPlayer : MonoBehaviour
+    {
+        [SerializeField] private Rigidbody body;
+        [SerializeField] private float laneWidth = 2.4f;
+        [SerializeField] private float laneChangeSpeed = 14f;
+        [SerializeField] private float jumpVelocity = 7.5f;
+        [SerializeField] private float swipeThreshold = 45f;
+        [SerializeField] private Vector3 startPosition = new Vector3(0f, 0.68f, 0f);
+
+        public event Action<LaneRunnerCommand> CommandApplied;
+
+        private int targetLane;
+        private int pendingLaneDelta;
+        private bool jumpPending;
+        private bool inputEnabled;
+        private Vector2 touchStart;
+        private bool trackingTouch;
+
+        private void Reset()
+        {
+            body = GetComponent<Rigidbody>();
+        }
+
+        private void Awake()
+        {
+            if (body == null) body = GetComponent<Rigidbody>();
+        }
+
+        private void Update()
+        {
+            if (!inputEnabled) return;
+
+            if (Input.GetKeyDown(KeyCode.LeftArrow) || Input.GetKeyDown(KeyCode.A))
+                QueueCommand(LaneRunnerCommand.MoveLeft);
+            if (Input.GetKeyDown(KeyCode.RightArrow) || Input.GetKeyDown(KeyCode.D))
+                QueueCommand(LaneRunnerCommand.MoveRight);
+            if (Input.GetKeyDown(KeyCode.Space) || Input.GetKeyDown(KeyCode.UpArrow))
+                QueueCommand(LaneRunnerCommand.Jump);
+
+            ReadTouchInput();
+        }
+
+        private void FixedUpdate()
+        {
+            if (pendingLaneDelta != 0)
+            {
+                int nextLane = Mathf.Clamp(targetLane + pendingLaneDelta, -1, 1);
+                pendingLaneDelta = 0;
+                Debug.Log($"LaneRunnerPlayer: Moving from lane {targetLane} to {nextLane}");
+                if (nextLane != targetLane)
+                {
+                    LaneRunnerCommand applied = nextLane < targetLane
+                        ? LaneRunnerCommand.MoveLeft
+                        : LaneRunnerCommand.MoveRight;
+                    targetLane = nextLane;
+                    Debug.Log($"targetLane updated to {targetLane}");
+                    CommandApplied?.Invoke(applied);
+                }
+            }
+
+            if (jumpPending)
+            {
+                jumpPending = false;
+                if (IsGrounded())
+                {
+                    Vector3 velocity = body.linearVelocity;
+                    velocity.y = jumpVelocity;
+                    body.linearVelocity = velocity;
+                    CommandApplied?.Invoke(LaneRunnerCommand.Jump);
+                }
+            }
+
+            Vector3 position = body.position;
+            position.z = Mathf.MoveTowards(position.z, targetLane * -laneWidth,
+                laneChangeSpeed * Time.fixedDeltaTime);
+            body.MovePosition(position);
+        }
+
+        public void QueueCommand(LaneRunnerCommand command)
+        {
+            switch (command)
+            {
+                case LaneRunnerCommand.MoveLeft:
+                    pendingLaneDelta = -1;
+                    break;
+                case LaneRunnerCommand.MoveRight:
+                    pendingLaneDelta = 1;
+                    break;
+                case LaneRunnerCommand.Jump:
+                    jumpPending = true;
+                    break;
+            }
+        }
+
+        public void Begin(bool allowPhysicalInput)
+        {
+            targetLane = 0;
+            pendingLaneDelta = 0;
+            jumpPending = false;
+            inputEnabled = allowPhysicalInput;
+            trackingTouch = false;
+            body.position = startPosition;
+            body.rotation = Quaternion.identity;
+            body.linearVelocity = Vector3.zero;
+            body.angularVelocity = Vector3.zero;
+        }
+
+        public void Stop()
+        {
+            inputEnabled = false;
+            pendingLaneDelta = 0;
+            jumpPending = false;
+        }
+
+        private bool IsGrounded()
+        {
+            return body.position.y <= 0.68f && body.linearVelocity.y <= 0.05f;
+        }
+
+        private void ReadTouchInput()
+        {
+            if (Input.touchCount == 0)
+            {
+                trackingTouch = false;
+                return;
+            }
+
+            Touch touch = Input.GetTouch(0);
+            if (touch.phase == TouchPhase.Began)
+            {
+                touchStart = touch.position;
+                trackingTouch = true;
+                return;
+            }
+
+            if (!trackingTouch || (touch.phase != TouchPhase.Ended && touch.phase != TouchPhase.Canceled))
+                return;
+
+            trackingTouch = false;
+            Vector2 swipe = touch.position - touchStart;
+            if (swipe.magnitude < swipeThreshold) return;
+
+            if (Mathf.Abs(swipe.x) > Mathf.Abs(swipe.y))
+                QueueCommand(swipe.x < 0f ? LaneRunnerCommand.MoveLeft : LaneRunnerCommand.MoveRight);
+            else if (swipe.y > 0f)
+                QueueCommand(LaneRunnerCommand.Jump);
+        }
+    }
+}

package/Samples~/LaneRunner/Scripts/Gameplay/LaneRunnerPlayer.cs.meta

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