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

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

@@ -0,0 +1,110 @@
+using System.Collections.Generic;
+using Hyper;
+using UnityEngine;
+
+namespace HyperSamples.LaneRunner
+{
+    public sealed class LaneRunnerSpawner : MonoBehaviour
+    {
+        [SerializeField] private GameObject obstaclePrefab;
+        [SerializeField] private GameObject doubleScorePrefab;
+        [SerializeField] private Transform itemRoot;
+        [SerializeField] private float spawnX = 38f;
+        [SerializeField] private float despawnX = -8f;
+        [SerializeField] private float laneWidth = 2.4f;
+        [SerializeField] private float rowSpacing = 10f;
+
+        private readonly List<LaneRunnerTrackItem> activeItems = new List<LaneRunnerTrackItem>();
+        private HyperRandomStream random;
+        private LaneRunnerGame game;
+        private float distanceToNextRow;
+        private int rowIndex;
+
+        public void Begin(LaneRunnerGame owner)
+        {
+            game = owner;
+            random = HyperRandom.GetContext();
+            distanceToNextRow = 8f;
+            rowIndex = 0;
+            Clear();
+
+            for (float x = 14f; x <= spawnX; x += rowSpacing)
+                SpawnRow(x);
+        }
+
+        public void Tick(float speed, float fixedDeltaTime)
+        {
+            float distance = speed * fixedDeltaTime;
+            distanceToNextRow -= distance;
+
+            for (int i = activeItems.Count - 1; i >= 0; i--)
+            {
+                LaneRunnerTrackItem item = activeItems[i];
+                if (item == null || item.IsCollected || !item.gameObject.activeSelf)
+                {
+                    RemoveItemAt(i);
+                    continue;
+                }
+
+                item.Advance(distance);
+                if (item.transform.position.x < despawnX)
+                    RemoveItemAt(i);
+            }
+
+            if (distanceToNextRow > 0f) return;
+
+            SpawnRow(spawnX);
+            distanceToNextRow += rowSpacing;
+        }
+
+        public void Clear()
+        {
+            for (int i = activeItems.Count - 1; i >= 0; i--)
+            {
+                if (activeItems[i] != null) Destroy(activeItems[i].gameObject);
+            }
+            activeItems.Clear();
+        }
+
+        private void SpawnRow(float x)
+        {
+            int safeLane = random.Range(-1, 2);
+            int obstacleCount = random.Range(1, 3);
+
+            for (int lane = -1; lane <= 1; lane++)
+            {
+                if (lane == safeLane) continue;
+                if (obstacleCount == 1 && lane != ((safeLane + 2) % 3) - 1) continue;
+                Spawn(obstaclePrefab, x, lane, 0.75f);
+            }
+
+            if (rowIndex > 0 && rowIndex % 5 == 0)
+                Spawn(doubleScorePrefab, x + 2f, safeLane, 1.15f);
+
+            rowIndex++;
+        }
+
+        private void Spawn(GameObject prefab, float x, int lane, float y)
+        {
+            if (prefab == null) return;
+            GameObject instance = Instantiate(prefab, itemRoot == null ? transform : itemRoot);
+            LaneRunnerTrackItem item = instance.GetComponent<LaneRunnerTrackItem>();
+            if (item == null)
+            {
+                Debug.LogWarning($"Lane Runner track prefab '{prefab.name}' is missing LaneRunnerTrackItem.");
+                Destroy(instance);
+                return;
+            }
+            item.transform.position = new Vector3(x, y, lane * laneWidth);
+            item.Initialize(game);
+            activeItems.Add(item);
+        }
+
+        private void RemoveItemAt(int index)
+        {
+            LaneRunnerTrackItem item = activeItems[index];
+            activeItems.RemoveAt(index);
+            if (item != null) Destroy(item.gameObject);
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4f207f8c064231944bdb73e8f1bf6298

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

@@ -0,0 +1,41 @@
+using UnityEngine;
+
+namespace HyperSamples.LaneRunner
+{
+    [RequireComponent(typeof(Collider))]
+    public sealed class LaneRunnerTrackItem : MonoBehaviour
+    {
+        [SerializeField] private bool doubleScorePickup;
+
+        public bool IsCollected { get; private set; }
+
+        private LaneRunnerGame game;
+
+        public void Initialize(LaneRunnerGame owner)
+        {
+            game = owner;
+            IsCollected = false;
+        }
+
+        public void Advance(float distance)
+        {
+            transform.position += Vector3.left * distance;
+        }
+
+        private void OnTriggerEnter(Collider other)
+        {
+            if (IsCollected || other.GetComponent<LaneRunnerPlayer>() == null) return;
+
+            IsCollected = true;
+            if (doubleScorePickup)
+            {
+                game?.CollectDoubleScore();
+                gameObject.SetActive(false);
+            }
+            else
+            {
+                game?.HitObstacle();
+            }
+        }
+    }
+}

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

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

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

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

package/Samples~/LaneRunner/Scripts/Hyper/LaneRunnerReplayAdapter.cs

@@ -0,0 +1,62 @@
+using Hyper;
+using UnityEngine;
+
+namespace HyperSamples.LaneRunner
+{
+    /// <summary>
+    /// Maps the game's three commands to compact replay actions. The SDK owns
+    /// recording eligibility, timestamps, loading, scheduling and completion.
+    /// </summary>
+    public sealed class LaneRunnerReplayAdapter : MonoBehaviour
+    {
+        private const string LeftAction = "Left";
+        private const string RightAction = "Right";
+        private const string JumpAction = "Jump";
+
+        [SerializeField] private LaneRunnerPlayer player;
+
+        private void OnEnable()
+        {
+            player.CommandApplied += HandleCommandApplied;
+            HyperSDK.Replay.OnAction += HandleReplayAction;
+        }
+
+        private void OnDisable()
+        {
+            player.CommandApplied -= HandleCommandApplied;
+            HyperSDK.Replay.OnAction -= HandleReplayAction;
+        }
+
+        private static void HandleCommandApplied(LaneRunnerCommand command)
+        {
+            switch (command)
+            {
+                case LaneRunnerCommand.MoveLeft:
+                    HyperSDK.Data.RecordActivity(LeftAction);
+                    break;
+                case LaneRunnerCommand.MoveRight:
+                    HyperSDK.Data.RecordActivity(RightAction);
+                    break;
+                case LaneRunnerCommand.Jump:
+                    HyperSDK.Data.RecordActivity(JumpAction);
+                    break;
+            }
+        }
+
+        private void HandleReplayAction(string action)
+        {
+            switch (action)
+            {
+                case LeftAction:
+                    player.QueueCommand(LaneRunnerCommand.MoveLeft);
+                    break;
+                case RightAction:
+                    player.QueueCommand(LaneRunnerCommand.MoveRight);
+                    break;
+                case JumpAction:
+                    player.QueueCommand(LaneRunnerCommand.Jump);
+                    break;
+            }
+        }
+    }
+}

package/Samples~/LaneRunner/Scripts/Hyper/LaneRunnerReplayAdapter.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 992c0965393c18c48b51eb8465bda2ff

package/Samples~/LaneRunner/Scripts/Hyper/LaneRunnerTournamentAdapter.cs

@@ -0,0 +1,64 @@
+using Hyper;
+using UnityEngine;
+
+namespace HyperSamples.LaneRunner
+{
+    /// <summary>
+    /// Keeps Hyper tournament concerns outside the core game scripts.
+    /// </summary>
+    public sealed class LaneRunnerTournamentAdapter : MonoBehaviour
+    {
+        private const string DoubleScorePowerup = "DoubleScore";
+
+        [SerializeField] private LaneRunnerGame game;
+
+        private void OnEnable()
+        {
+            HyperSDK.Event.OnGameStart += HandleGameStart;
+            HyperSDK.Event.OnGameEnded += HandleGameEnded;
+            game.ScoreChanged += HandleScoreChanged;
+            game.DoubleScoreChanged += HandleDoubleScoreChanged;
+            game.GameOverRequested += HandleGameOverRequested;
+        }
+
+        private void OnDisable()
+        {
+            HyperSDK.Event.OnGameStart -= HandleGameStart;
+            HyperSDK.Event.OnGameEnded -= HandleGameEnded;
+            game.ScoreChanged -= HandleScoreChanged;
+            game.DoubleScoreChanged -= HandleDoubleScoreChanged;
+            game.GameOverRequested -= HandleGameOverRequested;
+        }
+
+        private void HandleGameStart()
+        {
+            game.Begin(!HyperSDK.Game.IsReplayMode);
+        }
+
+        private void HandleGameEnded()
+        {
+            game.Stop();
+            HyperSDK.Data.SetGlobalMultiplier(1f);
+            HyperSDK.Data.RemovePowerup(DoubleScorePowerup);
+        }
+
+        private static void HandleScoreChanged(int score)
+        {
+            HyperSDK.Data.UpdateScore(score);
+        }
+
+        private static void HandleDoubleScoreChanged(bool active)
+        {
+            HyperSDK.Data.SetGlobalMultiplier(active ? 2f : 1f);
+            if (active)
+                HyperSDK.Data.AddPowerup(DoubleScorePowerup);
+            else
+                HyperSDK.Data.RemovePowerup(DoubleScorePowerup);
+        }
+
+        private static void HandleGameOverRequested()
+        {
+            HyperSDK.Game.EndGame();
+        }
+    }
+}

package/Samples~/LaneRunner/Scripts/Hyper/LaneRunnerTournamentAdapter.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4e31803cf44f24943bc2b44151847e33

package/Samples~/LaneRunner/Scripts/Hyper.meta

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

package/Samples~/LaneRunner/Scripts.meta

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

package/Tests.meta

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "app.hypergames.hypersdk",
-  "version": "1.10.0",
+  "version": "1.11.0-beta.2",
   "displayName": "HyperSDK",
   "description": "Official Unity SDK for Hyper: multiplayer battles, leaderboards, deterministic RNG, session management, tutorials, and WebGL optimizations for production-ready games.",
   "unity": "6000.0",
@@ -31,6 +31,13 @@
     "type": "git",
     "url": "https://github.com/mvmhyper/hyper-sdk.git"
   },
+  "samples": [
+    {
+      "displayName": "Lane Runner",
+      "description": "A scene-authored three-lane runner demonstrating score reporting, power-ups, deterministic spawning, and replay integration.",
+      "path": "Samples~/LaneRunner"
+    }
+  ],
   "dependencies": {
     "com.unity.nuget.newtonsoft-json": "3.2.1"
   }