Gaming Integration

Integrate Loyalteez rewards into game servers, Unity, Unreal Engine, and custom game engines.

Overview

Reward players for:

• Achievements and milestones
• Daily logins
• Tournament participation
• In-game purchases
• Social interactions
• Content creation
• Community contributions

Platform Support

• ✅ Unity (C#)
• ✅ Unreal Engine (C++/Blueprints)
• ✅ Custom game servers (Any language with HTTP)
• ✅ Web-based games (JavaScript)
• ✅ Mobile games (React Native, native iOS/Android)

Unity Integration

HTTP Request Script

using UnityEngine;
using UnityEngine.Networking;
using System.Collections;
using System.Text;

public class LoyalteezRewards : MonoBehaviour
{
    private const string API_URL = "https://api.loyalteez.app/loyalteez-api/manual-event";
    private const string BRAND_ID = "YOUR_BRAND_ID";

    [System.Serializable]
    public class RewardRequest
    {
        public string brandId;
        public string eventType;
        public string userEmail;
        public string domain;
        public Metadata metadata;
    }

    [System.Serializable]
    public class Metadata
    {
        public string platform = "unity";
        public string game;
        public string achievement;
        public int level;
        public float playtime;
    }

    public void RewardPlayer(string playerEmail, string achievement, int level)
    {
        StartCoroutine(TrackAchievement(playerEmail, achievement, level));
    }

    IEnumerator TrackAchievement(string email, string achievement, int level)
    {
        var request = new RewardRequest
        {
            brandId = BRAND_ID,
            eventType = "achievement_unlocked",
            userEmail = email,
            domain = "yourgame.com",
            metadata = new Metadata
            {
                game = Application.productName,
                achievement = achievement,
                level = level,
                playtime = Time.realtimeSinceStartup
            }
        };

        string json = JsonUtility.ToJson(request);
        byte[] bodyRaw = Encoding.UTF8.GetBytes(json);

        using (UnityWebRequest www = UnityWebRequest.Post(API_URL, json, "application/json"))
        {
            www.uploadHandler = new UploadHandlerRaw(bodyRaw);
            www.SetRequestHeader("Content-Type", "application/json");

            yield return www.SendWebRequest();

            if (www.result == UnityWebRequest.Result.Success)
            {
                Debug.Log($"Player rewarded for {achievement}!");
                ShowRewardNotification($"You earned LTZ for {achievement}!");
            }
            else
            {
                Debug.LogError($"Reward failed: {www.error}");
            }
        }
    }

    void ShowRewardNotification(string message)
    {
        // Your UI notification logic
        Debug.Log(message);
    }
}

Usage in Unity

// Attach to GameManager
public class GameManager : MonoBehaviour
{
    private LoyalteezRewards rewards;

    void Start()
    {
        rewards = GetComponent<LoyalteezRewards>();
    }

    void OnPlayerAchievement(string achievement)
    {
        string playerEmail = PlayerPrefs.GetString("player_email");
        int playerLevel = PlayerPrefs.GetInt("player_level");
        
        rewards.RewardPlayer(playerEmail, achievement, playerLevel);
    }
}

// Trigger from anywhere
FindObjectOfType<GameManager>().OnPlayerAchievement("First Win");

Unreal Engine Integration

C++ HTTP Request

// LoyalteezRewardsSubsystem.h
#pragma once

#include "CoreMinimal.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "Http.h"
#include "LoyalteezRewardsSubsystem.generated.h"

UCLASS()
class YOURGAME_API ULoyalteezRewardsSubsystem : public UGameInstanceSubsystem
{
    GENERATED_BODY()

public:
    UFUNCTION(BlueprintCallable, Category = "Loyalteez")
    void RewardPlayer(const FString& PlayerEmail, const FString& EventType, const TMap<FString, FString>& Metadata);

private:
    void OnRewardResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful);

    const FString ApiUrl = TEXT("https://api.loyalteez.app/loyalteez-api/manual-event");
    const FString BrandId = TEXT("YOUR_BRAND_ID");
};

// LoyalteezRewardsSubsystem.cpp
#include "LoyalteezRewardsSubsystem.h"
#include "HttpModule.h"
#include "Json.h"
#include "JsonUtilities.h"

void ULoyalteezRewardsSubsystem::RewardPlayer(
    const FString& PlayerEmail,
    const FString& EventType,
    const TMap<FString, FString>& Metadata)
{
    TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
    HttpRequest->SetVerb(TEXT("POST"));
    HttpRequest->SetURL(ApiUrl);
    HttpRequest->SetHeader(TEXT("Content-Type"), TEXT("application/json"));

    // Build JSON
    TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject());
    JsonObject->SetStringField(TEXT("brandId"), BrandId);
    JsonObject->SetStringField(TEXT("eventType"), EventType);
    JsonObject->SetStringField(TEXT("userEmail"), PlayerEmail);
    JsonObject->SetStringField(TEXT("domain"), TEXT("yourgame.com"));

    // Add metadata
    TSharedPtr<FJsonObject> MetadataObj = MakeShareable(new FJsonObject());
    for (const auto& Pair : Metadata)
    {
        MetadataObj->SetStringField(Pair.Key, Pair.Value);
    }
    JsonObject->SetObjectField(TEXT("metadata"), MetadataObj);

    // Convert to string
    FString OutputString;
    TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&OutputString);
    FJsonSerializer::Serialize(JsonObject.ToSharedRef(), Writer);

    HttpRequest->SetContentAsString(OutputString);
    HttpRequest->OnProcessRequestComplete().BindUObject(
        this, &ULoyalteezRewardsSubsystem::OnRewardResponseReceived);
    
    HttpRequest->ProcessRequest();
}

void ULoyalteezRewardsSubsystem::OnRewardResponseReceived(
    FHttpRequestPtr Request,
    FHttpResponsePtr Response,
    bool bWasSuccessful)
{
    if (bWasSuccessful && Response.IsValid())
    {
        UE_LOG(LogTemp, Log, TEXT("Player rewarded successfully!"));
        // Show in-game notification
    }
    else
    {
        UE_LOG(LogTemp, Error, TEXT("Failed to reward player"));
    }
}

Blueprint Usage

1. Get Loyalteez Subsystem
2. Call "Reward Player"
3. Pass: Email, Event Type, Metadata Map

Node.js Game Server

// gameServer.js
const express = require('express');
const axios = require('axios');

const app = express();
const LOYALTEEZ_API = 'https://api.loyalteez.app/loyalteez-api/manual-event';
const BRAND_ID = process.env.LOYALTEEZ_BRAND_ID;

// Reward player for achievement
async function rewardPlayer(playerEmail, achievement, metadata = {}) {
  try {
    const response = await axios.post(LOYALTEEZ_API, {
      brandId: BRAND_ID,
      eventType: 'achievement_unlocked',
      userEmail: playerEmail,
      domain: 'yourgame.com',
      metadata: {
        platform: 'game_server',
        achievement: achievement,
        ...metadata
      }
    });

    console.log(`Rewarded ${playerEmail} for ${achievement}`);
    return response.data;
  } catch (error) {
    console.error('Reward failed:', error.message);
    throw error;
  }
}

// Example: Player wins match
app.post('/match/complete', async (req, res) => {
  const { playerEmail, matchId, won } = req.body;

  if (won) {
    await rewardPlayer(playerEmail, 'match_won', {
      matchId: matchId,
      timestamp: Date.now()
    });
  }

  res.json({ success: true });
});

app.listen(3000, () => console.log('Game server running'));

Common Integration Patterns

Daily Login Rewards

// Unity
public void CheckDailyLogin(string playerEmail)
{
    string lastLogin = PlayerPrefs.GetString("last_login_date");
    string today = System.DateTime.Now.ToString("yyyy-MM-dd");

    if (lastLogin != today)
    {
        rewards.RewardPlayer(playerEmail, "daily_login", 1);
        PlayerPrefs.SetString("last_login_date", today);
    }
}

Achievement Milestones

// Node.js
const ACHIEVEMENTS = {
  'first_kill': { ltz: 10, name: 'First Blood' },
  'ten_kills': { ltz: 50, name: 'Killing Spree' },
  'hundred_kills': { ltz: 500, name: 'Legendary' }
};

async function checkAchievement(playerEmail, kills) {
  const achievements = Object.entries(ACHIEVEMENTS);
  
  for (const [key, data] of achievements) {
    const threshold = parseInt(key.split('_')[0]);
    
    if (kills === threshold) {
      await rewardPlayer(playerEmail, key, {
        achievement_name: data.name,
        reward_amount: data.ltz
      });
    }
  }
}

Tournament Participation

# Python game server
import requests

def reward_tournament_participant(player_email, placement):
    rewards = {
        1: 1000,  # 1st place
        2: 500,   # 2nd place
        3: 250    # 3rd place
    }
    
    if placement in rewards:
        requests.post('https://api.loyalteez.app/loyalteez-api/manual-event', json={
            'brandId': BRAND_ID,
            'eventType': 'tournament_placement',
            'userEmail': player_email,
            'domain': 'yourgame.com',
            'metadata': {
                'placement': placement,
                'reward_ltz': rewards[placement],
                'tournament_id': tournament_id
            }
        })

Web-Based Games (JavaScript)

// Phaser / Babylon.js / Three.js
class LoyalteezIntegration {
  constructor(brandId) {
    this.brandId = brandId;
    this.apiUrl = 'https://api.loyalteez.app/loyalteez-api/manual-event';
  }

  async rewardPlayer(playerEmail, eventType, metadata = {}) {
    try {
      const response = await fetch(this.apiUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          brandId: this.brandId,
          eventType: eventType,
          userEmail: playerEmail,
          domain: window.location.hostname,
          metadata: {
            platform: 'web_game',
            game: 'MyGame',
            ...metadata
          }
        })
      });

      const data = await response.json();
      this.showRewardNotification(data.rewardAmount);
      return data;
    } catch (error) {
      console.error('Reward failed:', error);
    }
  }

  showRewardNotification(amount) {
    // Show in-game UI notification
    alert(`You earned ${amount} LTZ!`);
  }
}

// Usage in game
const loyalteez = new LoyalteezIntegration('YOUR_BRAND_ID');

// On level complete
scene.events.on('levelComplete', () => {
  loyalteez.rewardPlayer(playerEmail, 'level_complete', {
    level: currentLevel,
    time: completionTime,
    score: finalScore
  });
});

Reward Strategies

Progression-Based

const LEVEL_REWARDS = {
  5: 50,
  10: 100,
  25: 250,
  50: 500,
  100: 1000
};

function checkLevelReward(level) {
  if (LEVEL_REWARDS[level]) {
    rewardPlayer(playerEmail, 'level_milestone', {
      level: level,
      reward: LEVEL_REWARDS[level]
    });
  }
}

Time-Based

// Reward for play time
function trackPlaytime() {
  const hoursPlayed = getPlaytimeHours();
  
  if (hoursPlayed % 10 === 0) { // Every 10 hours
    rewardPlayer(playerEmail, 'playtime_milestone', {
      hours: hoursPlayed,
      reward: 100
    });
  }
}

Social-Based

// Reward for referrals
function rewardReferral(referrerEmail, newPlayerEmail) {
  rewardPlayer(referrerEmail, 'referral', {
    referred_player: newPlayerEmail,
    reward: 200
  });
}

Best Practices

1. Validate on Server

// Never trust client-side achievement data
// Validate on your game server before rewarding

app.post('/achievement/validate', async (req, res) => {
  const { playerEmail, achievement } = req.body;

  // Verify achievement is legitimate
  const isValid = await validateAchievement(playerEmail, achievement);

  if (isValid) {
    await rewardPlayer(playerEmail, achievement);
    res.json({ success: true });
  } else {
    res.status(400).json({ error: 'Invalid achievement' });
  }
});

2. Prevent Duplicate Rewards

// Track rewarded achievements
const rewardedAchievements = new Set();

function rewardOnce(playerEmail, achievement) {
  const key = `${playerEmail}_${achievement}`;
  
  if (!rewardedAchievements.has(key)) {
    rewardPlayer(playerEmail, achievement);
    rewardedAchievements.add(key);
  }
}

3. Handle Offline Players

// Queue rewards for offline processing
const rewardQueue = [];

function queueReward(playerEmail, achievement) {
  rewardQueue.push({ playerEmail, achievement, timestamp: Date.now() });
  processQueue();
}

async function processQueue() {
  while (rewardQueue.length > 0) {
    const reward = rewardQueue.shift();
    try {
      await rewardPlayer(reward.playerEmail, reward.achievement);
    } catch (error) {
      rewardQueue.unshift(reward); // Re-queue on failure
      break;
    }
  }
}

Example Use Cases

Battle Royale Game

• Match win: 100 LTZ
• Top 10 finish: 25 LTZ
• First kill: 10 LTZ
• Daily login: 50 LTZ

RPG Game

• Level milestone: 50-500 LTZ (scaling)
• Quest completion: 25 LTZ
• Rare item drop: 100 LTZ
• Guild contribution: 10-100 LTZ

Puzzle Game

• Level complete: 5 LTZ
• Perfect score: 25 LTZ
• Daily challenge: 50 LTZ
• Share achievement: 10 LTZ

Testing

// Use test environment
const TEST_API = 'https://api-test.loyalteez.app/loyalteez-api/manual-event';
const TEST_EMAIL = '[email protected]';

async function testRewardSystem() {
  const result = await rewardPlayer(TEST_EMAIL, 'test_achievement', {
    test_mode: true
  });
  
  console.log('Test result:', result);
}

Support

• Unity Package: [Coming Soon]
• Unreal Plugin: [Coming Soon]
• GitHub Examples: github.com/Alpha4-Labs/loyalteez-gaming
• Email: [email protected]