Hiro Module¶

using IntelliVerseX.Backend;
using IntelliVerseX.Hiro;
using Nakama;

public class GameBootstrap : MonoBehaviour
{
    [SerializeField] private MyGameNakamaManager _nakamaManager;

    private async void Start()
    {
        bool connected = await _nakamaManager.InitializeAsync();
        if (!connected) return;

        var coordinator = IVXHiroCoordinator.Instance;
        coordinator.OnInitialized += OnHiroReady;
        coordinator.InitializeSystems(
            _nakamaManager.Client,
            _nakamaManager.Session);
    }

    private void OnHiroReady(bool success)
    {
        if (success)
            Debug.Log("All Hiro systems ready.");
    }
}

IVXHiroCoordinator.Instance.RefreshSession(newSession);

public class IVXSpinWheelConfig
{
    public string wheelId;
    public string name;
    public List<IVXSpinWheelSegment> segments;
    public int freeSpinsRemaining;
    public int maxFreeSpinsPerDay;
    public long nextFreeSpinAt;
    public int adSpinsRemaining;
    public int maxAdSpinsPerDay;
    public IVXReward spinCost;
}

public class IVXSpinWheelSegment
{
    public string segmentId;
    public string label;
    public IVXReward reward;
    public float weight;
    public string color;
    public bool isJackpot;
}

public class IVXSpinWheelResult
{
    public string wheelId;
    public IVXSpinWheelSegment winningSegment;
    public IVXReward reward;
    public string spinType;
    public int freeSpinsRemaining;
    public int adSpinsRemaining;
}

var wheel = IVXHiroCoordinator.Instance.SpinWheel;

// Load the wheel configuration
var config = await wheel.GetAsync();
Debug.Log($"Free spins left: {config.freeSpinsRemaining}");

// Render segments in the UI
foreach (var seg in config.segments)
{
    AddWheelSegment(seg.label, seg.color, seg.isJackpot);
}

// Execute a free spin
if (config.freeSpinsRemaining > 0)
{
    var result = await wheel.SpinAsync("free");
    if (result != null)
    {
        AnimateWheelTo(result.winningSegment.segmentId);
        ShowRewardPopup(result.reward);
    }
}

public class IVXStreak
{
    public string streakId;
    public string name;
    public int currentCount;
    public int bestCount;
    public long lastUpdateSec;
    public long resetAt;
    public List<int> claimedMilestones;
}

public class IVXRetentionState
{
    public string userId;
    public long firstSessionAt;
    public long lastSessionAt;
    public int totalSessions;
    public int currentSessionDepth;
    public int daysSinceLastSession;
    public string churnRisk;           // "low", "medium", "high"
    public bool onboardingComplete;
    public int onboardingStep;
    public bool comebackBonusAvailable;
    public IVXReward comebackBonusReward;
}

var hiro = IVXHiroCoordinator.Instance;

// Session start: send heartbeat
var heartbeat = await hiro.Retention.HeartbeatAsync();
if (heartbeat?.reward != null)
{
    ShowRewardPopup(heartbeat.reward);
}

// Check comeback bonus
var state = await hiro.Retention.GetAsync();
if (state.comebackBonusAvailable)
{
    var bonus = await hiro.Retention.ClaimComebackBonusAsync();
    ShowWelcomeBackDialog(state.daysSinceLastSession, bonus?.reward);
}

// Update daily streak
var streak = await hiro.Streaks.UpdateAsync("daily_login");
if (streak != null && streak.currentCount == 7)
{
    var claimed = await hiro.Streaks.ClaimMilestoneAsync("daily_login", 7);
    ShowMilestoneReward(claimed?.reward);
}

// Protect the streak with a shield
var shield = await hiro.StreakShield.GetAsync();
if (!shield.shieldActive && shield.shieldsRemaining > 0)
{
    await hiro.StreakShield.ActivateAsync();
}

public class IVXOfferwallState
{
    public List<IVXOfferwallOffer> offers;
    public float totalEarned;
    public float pendingRewards;
}

public class IVXOfferwallOffer
{
    public string offerId;
    public string provider;
    public string title;
    public string description;
    public float rewardAmount;
    public string rewardCurrency;
    public bool completed;
    public long expiresAt;
}

var offerwall = IVXHiroCoordinator.Instance.Offerwall;

// Display offerwall state
var state = await offerwall.GetAsync();
foreach (var offer in state.offers)
{
    if (!offer.completed)
        AddOfferCard(offer.title, offer.rewardAmount, offer.rewardCurrency);
}

// After provider S2S callback completes an offer
await offerwall.CompleteOfferAsync(
    offerId: "offer_123",
    provider: "tapjoy",
    transactionId: "txn_abc");

// Claim all pending rewards
if (state.pendingRewards > 0)
{
    var claimed = await offerwall.ClaimPendingAsync();
    ShowRewardPopup(claimed?.reward);
}

public class IVXFriendQuest
{
    public string questId;
    public string title;
    public string description;
    public int targetValue;
    public int currentValue;
    public string partnerId;
    public string partnerName;
    public int partnerProgress;
    public IVXReward reward;
    public string status;       // "available", "active", "completed"
    public long expiresAt;
}

public class IVXFriendStreak
{
    public string streakId;
    public string friendId;
    public string friendName;
    public int currentStreak;
    public int longestStreak;
    public long lastInteractionAt;
    public bool myContributionToday;
    public bool friendContributionToday;
    public long expiresAt;
    public List<IVXFriendStreakMilestone> milestoneRewards;
}

public class IVXFriendBattleChallenge
{
    public string challengeId;
    public string challengerId;
    public string challengerName;
    public int challengerScore;
    public string opponentId;
    public string opponentName;
    public int opponentScore;
    public string gameMode;
    public string status;       // "pending", "active", "completed"
    public IVXReward wager;
    public IVXReward winnerReward;
    public long expiresAt;
    public string winnerId;
}

var hiro = IVXHiroCoordinator.Instance;

// Accept a friend quest
var questState = await hiro.FriendQuests.GetAsync();
var available = questState.availableQuests[0];
await hiro.FriendQuests.AcceptAsync(available.questId, friendUserId);

// Report quest progress after a game
var progress = await hiro.FriendQuests.ReportProgressAsync(
    available.questId, amount: 1);
if (progress is { completed: true })
{
    ShowCoopReward(progress.reward);
}

// Maintain a friend streak
var interact = await hiro.FriendStreaks.InteractAsync(friendUserId);
if (interact is { streak.currentStreak: 7 })
{
    var milestone = await hiro.FriendStreaks.ClaimMilestoneAsync(
        interact.streak.streakId, day: 7);
    ShowMilestoneReward(milestone?.milestoneReward);
}

// Send a friend battle challenge
var challenge = await hiro.FriendBattles.SendChallengeAsync(
    friendUserId, gameMode: "trivia_blitz", score: 850);

public class IVXIAPTrigger
{
    public string triggerId;
    public string offerSku;
    public string triggerType;
    public string displayTitle;
    public string displayMessage;
    public long expiresAt;
    public int priority;
    public Dictionary<string, string> metadata;
}

public class IVXSmartAdTimerState
{
    public int interstitialCooldownSec;
    public long nextInterstitialAt;
    public int rewardedAdsToday;
    public int maxRewardedAdsPerDay;
    public bool bannerEnabled;
    public int sessionAdCount;
}

public class IVXAdRevenueConfig
{
    public List<IVXAdPlacement> placements;
    public int globalFrequencyCapSec;
    public int sessionCap;
}

public class IVXAdPlacement
{
    public string placementId;
    public string adType;
    public int priority;
    public int cooldownSec;
    public float rewardMultiplier;
    public bool enabled;
}

var hiro = IVXHiroCoordinator.Instance;

// After a game round, evaluate IAP triggers
var eval = await hiro.IAPTriggers.EvaluateAsync("post_game", contextValue: 5);
if (eval.triggers.Count > 0)
{
    var offer = eval.triggers[0];
    ShowOfferPopup(offer.displayTitle, offer.displayMessage, offer.offerSku);
}

// Check if an interstitial is allowed
var timer = await hiro.SmartAdTimer.CanShowAsync("interstitial");
if (timer != null && DateTimeOffset.UtcNow.ToUnixTimeSeconds() >= timer.nextInterstitialAt)
{
    ShowInterstitialAd();
    await hiro.SmartAdTimer.RecordImpressionAsync("interstitial", "post_game_interstitial");
}

// Check rewarded ad eligibility
var adState = await hiro.SmartAdTimer.GetAsync();
if (adState.rewardedAdsToday < adState.maxRewardedAdsPerDay)
{
    ShowRewardedAdButton();
}

// Record rewarded ad impression
var adResult = await hiro.SmartAdTimer.RecordImpressionAsync("rewarded", "double_coins");
if (adResult?.reward != null)
{
    CreditReward(adResult.reward);
}

// Record ad revenue for optimization
var adConfig = await hiro.AdRevenueOptimizer.GetConfigAsync();
foreach (var placement in adConfig.placements)
{
    if (placement.enabled)
        RegisterPlacement(placement.placementId, placement.rewardMultiplier);
}

IVXHiroCoordinator.Instance.OnInitialized += success =>
{
    if (success)
        LoadMainMenu();
    else
        ShowConnectionError();
};

public class HiroRpcResponse<T>
{
    public bool success;
    public T data;
    public string error;
}

IVXHiroRpcClient.EnableDebugLogs = false;

using IntelliVerseX.Backend;
using IntelliVerseX.Hiro;
using UnityEngine;

public class HiroSessionManager : MonoBehaviour
{
    [SerializeField] private MyGameNakamaManager _nakama;

    private async void Start()
    {
        bool connected = await _nakama.InitializeAsync();
        if (!connected) return;

        var hiro = IVXHiroCoordinator.Instance;
        hiro.InitializeSystems(_nakama.Client, _nakama.Session);

        // 1. Session heartbeat
        var heartbeat = await hiro.Retention.HeartbeatAsync();

        // 2. Comeback bonus
        var retention = await hiro.Retention.GetAsync();
        if (retention.comebackBonusAvailable)
        {
            var bonus = await hiro.Retention.ClaimComebackBonusAsync();
            ShowWelcomeBack(bonus?.reward);
        }

        // 3. Daily streak
        var streak = await hiro.Streaks.UpdateAsync("daily_login");

        // 4. Check daily content
        var daily = await hiro.DailyContent.GetAsync();
        ShowDailyContentGrid(daily.slots);

        // 5. Load spin wheel
        var wheel = await hiro.SpinWheel.GetAsync();
        if (wheel.freeSpinsRemaining > 0)
            ShowFreeSpinBadge();

        // 6. Load social pressure
        var social = await hiro.SocialPressure.GetAsync();
        ShowFriendsOnline(social.friendsOnline);

        // 7. Evaluate monetization triggers
        var triggers = await hiro.IAPTriggers.EvaluateAsync("session_start");
        if (triggers.triggers.Count > 0)
            ShowSpecialOffer(triggers.triggers[0]);

        // 8. Check appointments
        var appts = await hiro.Appointments.GetAsync();
        foreach (var appt in appts.appointments)
        {
            if (!appt.claimed && !appt.expired)
                ShowAppointmentNotification(appt);
        }
    }
}

var battles = IVXHiroCoordinator.Instance.FriendBattles;

// List pending challenges
var state = await battles.GetAsync();
foreach (var pending in state.pendingChallenges)
{
    ShowChallengeInvite(pending.challengerName, pending.gameMode);
}

// Accept a challenge
var accepted = await battles.AcceptChallengeAsync(challengeId);

// After playing, submit score
var result = await battles.SubmitScoreAsync(challengeId, score: 920);
if (result is { challenge.winnerId: var winnerId } && winnerId == myUserId)
{
    ShowVictoryScreen(result.reward);
}

var adOptimizer = IVXHiroCoordinator.Instance.AdRevenueOptimizer;
var smartAd = IVXHiroCoordinator.Instance.SmartAdTimer;

// Fetch personalized ad config on session start
var config = await adOptimizer.GetConfigAsync();

// Before showing any ad, check eligibility
var canShow = await smartAd.CanShowAsync("rewarded");
bool eligible = canShow != null
    && canShow.rewardedAdsToday < canShow.maxRewardedAdsPerDay;

if (eligible)
{
    ShowRewardedAd(onComplete: async (network, revenue) =>
    {
        // Record impression for timer tracking
        await smartAd.RecordImpressionAsync("rewarded", "level_complete_reward");

        // Record impression for revenue optimization
        await adOptimizer.RecordImpressionAsync(
            placementId: "level_complete_reward",
            adNetwork: network,
            revenue: revenue);
    });
}

public class IVXReward
{
    public Dictionary<string, float> currencies;  // e.g. { "coins": 500, "gems": 10 }
    public Dictionary<string, int> items;          // e.g. { "shield_token": 1 }
}

var result = await hiro.SpinWheel.SpinAsync("free");
if (result == null)
{
    Debug.LogWarning("Spin failed -- check network or session state.");
    ShowRetryDialog();
    return;
}
ShowSpinResult(result);

var response = await hiro.RpcClient.CallAsync<IVXSpinWheelResult>(
    "hiro_spin_wheel_spin", new { spinType = "free" });

if (!response.success)
    Debug.LogError($"RPC failed: {response.error}");