sui-game-sdk 0.0.1

package/starters/unity/Assets/Scripts/Core/GameManager.cs

@@ -0,0 +1,38 @@
+using UnityEngine;
+
+public class GameManager : MonoBehaviour
+{
+    [Header("UI References")]
+    public GameObject LoginPanel;
+    public GameObject GamePanel;
+    
+    [Header("Dependencies")]
+    public SuiManager Sui;
+    public HeroManager Hero;
+
+    private void Start()
+    {
+        // Simulating a game boot sequence
+        Debug.Log("Game Starting...");
+        LoginPanel.SetActive(true);
+        GamePanel.SetActive(false);
+    }
+
+    public void OnLoginClicked()
+    {
+        // Mock Login
+        string mockAddress = "0x7e875ea78ee09f08d72e2676cf84e0f1c8ac61094297ee4a057aa015e297ca"; 
+        Sui.Initialize(mockAddress);
+        
+        LoginPanel.SetActive(false);
+        GamePanel.SetActive(true);
+        
+        // HeroManager will auto-check on init, but we can trigger it too
+        // Hero.CheckForHero();
+    }
+    
+    public void OnExitClicked()
+    {
+        Application.Quit();
+    }
+}

package/starters/unity/Assets/Scripts/Core/PlayerController.cs

@@ -0,0 +1,37 @@
+using UnityEngine;
+
+public class PlayerController : MonoBehaviour
+{
+    public float MoveSpeed = 5f;
+    
+    private Vector2 _input;
+    private Rigidbody2D _rb;
+
+    private void Awake()
+    {
+        _rb = GetComponent<Rigidbody2D>();
+    }
+
+    private void Update()
+    {
+        // Simple Top-Down Movement
+        float x = Input.GetAxisRaw("Horizontal");
+        float y = Input.GetAxisRaw("Vertical");
+        _input = new Vector2(x, y).normalized;
+        
+        // Animation logic would go here
+    }
+
+    private void FixedUpdate()
+    {
+        if (_rb != null)
+        {
+            _rb.velocity = _input * MoveSpeed;
+        }
+    }
+    
+    public void PlayAttackAnimation()
+    {
+        Debug.Log("Player swinging sword visualization!");
+    }
+}

package/starters/unity/Assets/Scripts/Sui/HeroManager.cs

@@ -0,0 +1,99 @@
+using System.Collections;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class HeroManager : MonoBehaviour
+{
+    [Header("Game Config")]
+    public string GamePackageId = "0x_REPLACE_WITH_PACKAGE_ID";
+    public string HeroModule = "hero";
+
+    [Header("Events")]
+    public UnityEvent OnHeroFound;
+    public UnityEvent OnHeroMissing;
+
+    private string _heroObjectId;
+
+    private void Start()
+    {
+        // Wait for initialization
+        StartCoroutine(WaitForInit());
+    }
+
+    private IEnumerator WaitForInit()
+    {
+        while (string.IsNullOrEmpty(SuiManager.Instance.ActiveAddress))
+        {
+            yield return new WaitForSeconds(0.5f);
+        }
+        CheckForHero();
+    }
+
+    public void MintHero(string heroName)
+    {
+        Debug.Log($"Minting Hero: {heroName}...");
+        // Uses the "Spawner" concept
+        SuiManager.Instance.SpawnAsset(
+            GamePackageId, 
+            HeroModule, 
+            "mint_hero", 
+            new string[] { heroName }, 
+            (payload) => {
+                Debug.Log(">> SIGN THIS PAYLOAD (Mint): " + payload);
+            }
+        );
+    }
+
+    public void SlayBoar()
+    {
+        if (string.IsNullOrEmpty(_heroObjectId))
+        {
+            Debug.LogError("No Hero to slay with!");
+            return;
+        }
+
+        Debug.Log("Slaying Boar...");
+        // Uses the "Spawner" concept (Action execution)
+        SuiManager.Instance.SpawnAsset(
+            GamePackageId, 
+            HeroModule, 
+            "slay_boar", 
+            new string[] { _heroObjectId }, 
+            (payload) => Debug.Log(">> SIGN THIS PAYLOAD (Slay): " + payload)
+        );
+    }
+
+    public void CheckForHero()
+    {
+        string address = SuiManager.Instance.ActiveAddress;
+        // Request owned objects with type info
+        // JSON-RPC params: [address, { showType: true }]
+        // We manually construct the inner object JSON for the string param
+        string queryParams = $"[\"{address}\", {{ \"options\": {{ \"showType\": true }} }}]";
+
+        StartCoroutine(SuiManager.Instance.RpcCall(
+            "suix_getOwnedObjects", 
+            queryParams, 
+            (response) => {
+                // Naive parsing for demo. Use NewtonSoft in real project.
+                if (response.Contains($"{GamePackageId}::{HeroModule}::Hero"))
+                {
+                    Debug.Log("Hero found via RPC!");
+                    // Hypothetical parsing:
+                    // _heroObjectId = ExtractId(response); 
+                    // _heroObjectId = "0x123..."; // Mock for now if parsing fails
+                    
+                    // Allow manual set for demo if parsing fails (since JsonUtility is weak with nested arrays)
+                    _heroObjectId = "0x_MOCKED_ID_IF_PARSING_FAILS";
+                    OnHeroFound?.Invoke();
+                }
+                else
+                {
+                    Debug.Log("No Hero found.");
+                    OnHeroMissing?.Invoke();
+                }
+            },
+            (error) => Debug.LogError("Failed to check hero: " + error)
+        ));
+    }
+}

package/starters/unity/Assets/Scripts/Sui/SuiManager.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections;
+using System.Text;
+using UnityEngine;
+using UnityEngine.Networking;
+
+public class SuiManager : MonoBehaviour
+{
+    [Header("Configuration")]
+    public string RpcUrl = "https://fullnode.testnet.sui.io";
+    
+    // In a real game, this would be managed by a Wallet Adapter
+    public string ActiveAddress { get; private set; }
+
+    public static SuiManager Instance { get; private set; }
+
+    private void Awake()
+    {
+        if (Instance == null) Instance = this;
+        else Destroy(gameObject);
+    }
+
+    public void Initialize(string address)
+    {
+        ActiveAddress = address;
+        Debug.Log($"[SuiManager] Initialized with address: {ActiveAddress}");
+    }
+
+    /// <summary>
+    /// Executes a read-only RPC call
+    /// </summary>
+    public IEnumerator RpcCall(string method, string paramsJson, Action<string> onSuccess, Action<string> onError)
+    {
+        // Simple JSON-RPC construction
+        string jsonRequestBody = $"{{\"jsonrpc\":\"2.0\", \"id\": 1, \"method\": \"{method}\", \"params\": {paramsJson}}}";
+        
+        using (UnityWebRequest req = new UnityWebRequest(RpcUrl, "POST"))
+        {
+            byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonRequestBody);
+            req.uploadHandler = new UploadHandlerRaw(bodyRaw);
+            req.downloadHandler = new DownloadHandlerBuffer();
+            req.SetRequestHeader("Content-Type", "application/json");
+
+            yield return req.SendWebRequest();
+
+            if (req.result != UnityWebRequest.Result.Success)
+            {
+                Debug.LogError($"[SuiManager] RPC Error: {req.error}");
+                onError?.Invoke(req.error);
+            }
+            else
+            {
+                // Debug.Log($"[SuiManager] Response: {req.downloadHandler.text}");
+                onSuccess?.Invoke(req.downloadHandler.text);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Spawns an asset by constructing a Move Call. 
+    /// Corresponds to `AssetSpawner.spawn` in the JS SDK.
+    /// </summary>
+    public void SpawnAsset(string packageId, string module, string function, string[] args, Action<string> onConstructed)
+    {
+        // In the JS SDK: spawner.spawn(...)
+        ConstructMoveCall(packageId, module, function, args, onConstructed);
+    }
+
+    /// <summary>
+    /// Syncs game state by checking for events or object updates.
+    /// Corresponds to `GameStateSync` in the JS SDK.
+    /// </summary>
+    public void SyncState(string address, Action<string> onResult)
+    {
+        string queryParams = $"[\"{address}\", {{ \"options\": {{ \"showType\": true }} }}]";
+        StartCoroutine(RpcCall("suix_getOwnedObjects", queryParams, onResult, (err) => Debug.LogWarning(err)));
+    }
+
+    private void ConstructMoveCall(string packageId, string module, string function, string[] args, Action<string> onConstructed)
+    {
+        // Simulation of payload construction
+        var moveCallInfo = new
+        {
+            target = $"{packageId}::{module}::{function}",
+            arguments = args,
+            sender = ActiveAddress,
+            type = "move_call" // Tag for the wallet adapter
+        };
+
+        string json = JsonUtility.ToJson(moveCallInfo); 
+        Debug.Log($"[SuiManager] Transaction Payload Ready: {json}");
+        onConstructed?.Invoke(json);
+    }
+}

package/starters/unity/README.md

@@ -0,0 +1,72 @@
+# Unity 2D RPG Starter + Sui Game SDK
+
+A specialized Unity starter kit designed to work with the `sui-game-sdk` ecosystem.
+
+## 🌟 Features
+- **Authentic Project Structure**: Pre-configured with `Assets/Scripts` and `Assets/Scenes`.
+- **Sui Integration**:
+  - `SuiManager`: Handles RPC connections and mimics the JS SDK's `Session` management.
+  - `HeroManager`: Demonstrates `Spawner` (Minting) and `Sync` (State updates) concepts.
+- **Sample Game**: "Sui Quest" - Mint a hero and slay boars on-chain!
+- **Independent**: Includes its own Move contract and deployment script.
+
+## 🚀 Getting Started
+
+### Prerequisites
+- Unity 2021.3+ (LTS recommended)
+- Node.js (for deploying the contract)
+- Sui CLI installed and configured
+
+### 1. Deploy the Move Contract
+```bash
+# From the Unity starter directory
+node deploy.js
+```
+Copy the **Package ID** output from the deployment.
+
+### 2. Configure Unity
+1. Open this folder in Unity Hub.
+2. Open `Assets/Scripts/Sui/HeroManager.cs`.
+3. Replace `GamePackageId` with your deployed Package ID.
+   ```csharp
+   public string GamePackageId = "0x..."; // Your ID here
+   ```
+
+### 3. Play
+1. Open `Assets/Scenes/Main.unity`.
+2. Press **Play**.
+3. Use the (Simulated) UI or Console logs to interact.
+   - **Mint Hero**: Generates a transaction payload.
+   - **Slay Boar**: Uses the hero to perform an action.
+
+## 🧩 Architecture
+
+This starter mirrors the `sui-game-sdk` (TypeScript) architecture:
+
+| Concept | Unity Implementation | Description |
+|---|---|---|
+| **Session** | `SuiManager.ActiveAddress` | Manages the player's active wallet address |
+| **Spawner** | `SuiManager.SpawnAsset` | Constructs Move Calls to create/modify objects |
+| **Sync** | `SuiManager.SyncState` | Polls the chain for object updates and events |
+
+## 📁 Project Structure
+
+```
+unity/
+├── Assets/
+│   ├── Scenes/
+│   │   └── Main.unity
+│   └── Scripts/
+│       ├── Core/
+│       │   ├── GameManager.cs
+│       │   └── PlayerController.cs
+│       └── Sui/
+│           ├── SuiManager.cs
+│           └── HeroManager.cs
+├── move/                  # Move smart contract
+│   └── sources/
+│       └── hero.move
+└── deploy.js             # Deployment script
+```
+
+> **Note**: This starter uses raw HTTP requests to keep dependencies light. For production, integrate a dedicated Unity Wallet Adapter.

package/starters/unity/deploy.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+async function main() {
+    const moveDir = path.resolve(__dirname, '../move');
+    console.log(`Deploying from ${moveDir}...`);
+
+    console.log('Building Move Package...');
+    try {
+        const output = execSync('sui client publish --gas-budget 100000000 --json', {
+            cwd: moveDir,
+            encoding: 'utf-8'
+        });
+
+        const result = JSON.parse(output);
+        const packageId = result.objectChanges.find((c) => c.type === 'published')?.packageId;
+        const adminCap = result.objectChanges.find((c) => c.objectType?.includes('GameAdmin'))?.objectId;
+
+        if (!packageId) {
+            console.error('Could not find package ID in publish output.');
+            console.log(output);
+            return;
+        }
+
+        console.log('\nSUCCESS! Package Published.');
+        console.log('Package ID:', packageId);
+        if (adminCap) console.log('Admin Cap:', adminCap);
+
+        console.log('\nUpdate HeroManager.cs:');
+        console.log(`public string GamePackageId = "${packageId}";`);
+    } catch (e) {
+        console.error('Deployment failed:', e.message);
+        console.log('Ensure you have sufficient gas and the SUI CLI configured.');
+    }
+}
+
+main();

package/starters/unity/move/Move.toml

@@ -0,0 +1,9 @@
+[package]
+name = "SuiQuest"
+version = "0.0.1"
+
+[dependencies]
+Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "framework/testnet" }
+
+[addresses]
+sui_quest = "0x0"

package/starters/unity/move/sources/hero.move

@@ -0,0 +1,109 @@
+module sui_quest::hero {
+    use sui::object::{Self, UID};
+    use sui::tx_context::{Self, TxContext};
+    use sui::transfer;
+    use sui::event;
+
+    // --- Structs ---
+
+    struct Hero has key, store {
+        id: UID,
+        name: vector<u8>,
+        level: u64,
+        experience: u64,
+        hp: u64,
+        strength: u64,
+    }
+
+    struct GameAdmin has key {
+        id: UID,
+    }
+
+    // --- Events ---
+
+    struct HeroMinted has copy, drop {
+        id: address,
+        name: vector<u8>,
+        owner: address,
+    }
+
+    struct AttackEvent has copy, drop {
+        hero_id: address,
+        damage_dealt: u64,
+        enemy_hp_remaining: u64, // simplified
+    }
+
+    struct LevelUpEvent has copy, drop {
+        hero_id: address,
+        new_level: u64,
+    }
+
+    // --- Initializer ---
+
+    fun init(ctx: &mut TxContext) {
+        let admin = GameAdmin { id: object::new(ctx) };
+        transfer::transfer(admin, tx_context::sender(ctx));
+    }
+
+    // --- Entry Functions ---
+
+    public entry fun mint_hero(
+        _admin: &GameAdmin, // Require admin to mint (simulate controlled spawning)
+        name: vector<u8>,
+        recipient: address,
+        ctx: &mut TxContext
+    ) {
+        let id = object::new(ctx);
+        let hero_id = object::uid_to_address(&id);
+        
+        let hero = Hero {
+            id,
+            name,
+            level: 1,
+            experience: 0,
+            hp: 100,
+            strength: 10,
+        };
+
+        event::emit(HeroMinted {
+            id: hero_id,
+            name,
+            owner: recipient
+        });
+
+        transfer::public_transfer(hero, recipient);
+    }
+
+    public entry fun slay_boar(hero: &mut Hero, ctx: &mut TxContext) {
+        // Simulate combat logic
+        // In reality, you'd use on-chain randomness or a specific Monster object
+        
+        // 1. Calculate Damage (Strength +/- random noise simulated)
+        let damage = hero.strength + 2; 
+
+        // 2. Grant XP
+        hero.experience = hero.experience + 10;
+        
+        // 3. Check Level Up
+        if (hero.experience >= 100) {
+            hero.level = hero.level + 1;
+            hero.experience = 0;
+            hero.strength = hero.strength + 5;
+            event::emit(LevelUpEvent {
+                hero_id: object::uid_to_address(&hero.id),
+                new_level: hero.level
+            });
+        };
+
+        event::emit(AttackEvent {
+            hero_id: object::uid_to_address(&hero.id),
+            damage_dealt: damage,
+            enemy_hp_remaining: 0 
+        });
+    }
+
+    // --- Accessors (View Functions) ---
+    public fun get_level(hero: &Hero): u64 {
+        hero.level
+    }
+}