Hiro Unreal Reference #

This page provides samples for working with Hiro game systems in Unreal Engine.

Inventory #

List items #

List all inventory items defined in the codex, optionally filtered by category.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroInventoryListRequest Request;
Request.ItemCategory = TEXT("weapons");

FHiroOnInventoryList OnInventoryList;
OnInventoryList.AddDynamic(this, &AMyActor::OnInventoryList)
FOnError OnError;

HiroClient->InventoryList(Session, Request, OnInventoryList, OnError)

void AMyActor::OnInventoryList(const FHiroInventoryList& InventoryList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *InventoryList.ToJson());
}

List user inventory items #

List all inventory items owned by the player, optionally filtered by category.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroInventoryListRequest Request;
Request.ItemCategory = TEXT("weapons");

FHiroOnInventoryListInventory OnInventoryListInventory;
OnInventoryListInventory.AddDynamic(this, &AMyActor::OnInventoryListInventory)
FOnError OnError;

HiroClient->InventoryListInventory(Session, Request, OnInventoryListInventory, OnError)

void AMyActor::OnInventoryList(const FHiroInventoryList& InventoryList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *InventoryList.ToJson());
}

Consume inventory items #

Consume one or more inventory items owned by the player.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroInventoryConsumeRequest Request;
Request.Items.Add(TEXT("health_potion"), 1);

FHiroOnInventoryConsume OnInventoryConsume;
OnInventoryConsume.AddDynamic(this, &AMyActor::OnInventoryConsume)
FOnError OnError;

HiroClient->InventoryConsume(Session, Request, OnInventoryConsume, OnError)

void AMyActor::OnInventoryConsume(const FHiroInventoryConsumeRewards& InventoryConsumeRewards)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *InventoryConsumeRewards.ToJson());
}

Grant inventory items #

Grant one or more inventory items to the player.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroInventoryGrantRequest Request;
Request.Items.Add(TEXT("bronze_sword"), 1);

FHiroOnInventoryGrant OnInventoryGrant;
OnInventoryGrant.AddDynamic(this, &AMyActor::OnInventoryGrant)
FOnError OnError;

HiroClient->InventoryGrant(Session, Request, OnInventoryGrant, OnError)

void AMyActor::OnInventoryConsume(const FHiroInventoryUpdateAck& InventoryUpdateAck)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *InventoryUpdateAck.ToJson());
}

Update inventory items #

Update the properties on one or more inventory items owned by the player.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

FHiroInventoryUpdateItemsRequest Request;

FHiroInventoryUpdateItemProperties ItemProperties;
ItemProperties.StringProperties.Add(TEXT("example_property"), TEXT("example_value"))
ItemProperties.NumericProperties.Add(TEXT("numeric_property"), 10)

Request.ItemUpdates.Add(TEXT("bronze_sword"), ItemProperties);

FHiroOnInventoryUpdate OnInventoryUpdate;
OnInventoryUpdate.AddDynamic(this, &AMyActor::OnInventoryUpdate)
FOnError OnError;

HiroClient->InventoryUpdate(Session, Request, OnInventoryUpdate, OnError)

void AMyActor::OnInventoryConsume(const FHiroInventoryUpdateAck& InventoryUpdateAck)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *InventoryUpdateAck.ToJson());
}

Economy #

Donation claim #

Claim one or more rewards which are partially or full donated by other players.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroEconomyDonationClaimRequest Request;
Request.Items = {TEXT("donation_1"), TEXT("donation_2")}

FHiroOnEconomyDonationClaim OnEconomyDonationClaim;
OnEconomyDonationClaim.AddDynamic(this, &AMyActor::OnEconomyDonationClaim)
FOnError OnError;

HiroClient->EconomyDonationCLaim(Session, Request, OnEconomyDonationClaim, OnError)

void AMyActor::OnEconomyDonationClaim(const FHiroEconomyDonationClaimRewards& EconomyDonationClaimRewards)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EconomyDonationClaimRewards.ToJson());
}

Donate some resource (currencies, items, etc.) to a user by donation ID.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

FHiroEconomyDonationGiveRequest Request;
Request.UserId = TEXT("user_1");
Request.DonationId = TEXT("donation_1")

FHiroOnEconomyDonationGive OnEconomyDonationGive;
OnEconomyDonationGive.AddDynamic(this, &AMyActor::OnEconomyDonationGive)
FOnError OnError;

HiroClient->EconomyDonationGive(Session, Request, OnEconomyDonationGive, OnError)

void AMyActor::OnEconomyDonationGive(const FHiroEconomyUpdateAck& EconomyUpdateAck)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EconomyUpdateAck.ToJson());
}

Get donation progress #

Get progress on one or more donations for a set of players by their IDs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroEconomyDonationGetRequest Request;
Request.Ids = {TEXT("donation_1"), TEXT("donation_2")};

FHiroOnEconomyDonationGet OnEconomyDonationGet;
OnEconomyDonationGet.AddDynamic(this, &AMyActor::OnEconomyDonationGet)
FOnError OnError;

HiroClient->EconomyDonationGet(Session, Request, OnEconomyDonationGet, OnError)

void AMyActor::OnEconomyDonationGet(const FHiroEconomyDonationsByUserList& EconomyDonationsByUserList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EconomyDonationsByUserList.ToJson());
}

Request a donation #

Request a donation which other players can contribute into.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroEconomyDonationRequest Request;
Request.DonationId = TEXT("donation_1");

FHiroOnEconomyDonationRequest OnEconomyDonationRequest;
OnEconomyDonationRequest.AddDynamic(this, &AMyActor::OnEconomyDonationRequest)
FOnError OnError;

HiroClient->EconomyDonationRequest(Session, Request, OnEconomyDonationRequest, OnError)

void AMyActor::OnEconomyDonationRequest(const FHiroEconomyDonationAck& EconomyDonationAck)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EconomyDonationAck.ToJson());
}

Get store items #

Get all store items defined in the Virtual Store.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroEconomyListRequest Request;
Request.StoreType = EHiroEconomyStoreType::ECONOMY_STORE_TYPE_APPLE_APPSTORE;

FHiroOnEconomyStoreGet OnEconomyStoreGet;
OnEconomyStoreGet.AddDynamic(this, &AMyActor::OnEconomyStoreGet)
FOnError OnError;

HiroClient->EconomyStoreGet(Session, Request, OnEconomyStoreGet, OnError)

void AMyActor::OnEconomyStoreGet(const FHiroEconomyList& EconomyList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EconomyList.ToJson());
}

Grant currencies or reward modifiers #

Grant one or more currencies or reward modifiers to te player.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroEconomyGrantRequest Request;
Request.Currencies.Add(TEXT("coins"), 100);

FHiroOnEconomyGrant OnEconomyGrant;
OnEconomyGrant.AddDynamic(this, &AMyActor::OnEconomyGrant)
FOnError OnError;

HiroClient->EconomyGrant(Session, Request, OnEconomyGrant, OnError)

void AMyActor::OnEconomyGrant(const FHiroEconomyUpdateAck& EconomyUpdateAck)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EconomyUpdateAck.ToJson());
}

Send a purchase intent #

Send a marker of intent to purchase by the player.

1
2
3
4
5
6
7
8

FHiroEconomyPurchaseIntentRequest Request;
Request.ItemId = TEXT("item_1")
Request.StoreType = EHiroEconomyStoreType::ECONOMY_STORE_TYPE_APPLE_APPSTORE;
Request.Sku = TEXT("sku_1");

FOnError OnError;

HiroClient->EconomyPurchaseIntent(Session, Request, OnError)

Purchase a store item #

Purchase a store item by the player.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

FHiroEconomyPurchaseRequest Request;
Request.ItemId = TEXT("item_1")
Request.StoreType = EHiroEconomyStoreType::ECONOMY_STORE_TYPE_APPLE_APPSTORE;
Request.Receipt = TEXT("<receipt>");

FHiroOnEconomyPurchaseItem OnEconomyPurchaseItem;
OnEconomyPurchaseItem.AddDynamic(this, &AMyActor::OnEconomyPurchaseItem)
FOnError OnError;

HiroClient->EconomyPurchaseItem(Session, Request, OnEconomyPurchaseItem, OnError)

void AMyActor::OnEconomyPurchaseItem(const FHiroEconomyPurchaseAck& EconomyPurchaseAck)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EconomyPurchaseAck.ToJson());
}

Get ad placement status #

Get the current status on an Ad placement which may have been rewarded.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

FHiroEconomyPlacementStatusRequest Request;
Request.RewardId = TEXT("reward_1");
Request.PlacementId = TEXT("placement_1");
Request.Count = 0;

FHiroOnEconomyPlacementStatus OnEconomyPlacementStatus;
OnEconomyPlacementStatus.AddDynamic(this, &AMyActor::OnEconomyPlacementStatus)
FOnError OnError;

HiroClient->EconomyPlacementStatus(Session, Request, OnEconomyPlacementStatus, OnError)

void AMyActor::OnEconomyPlacementStatus(const FHiroEconomyPlacementStatus& EconomyPlacementStatus)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EconomyPlacementStatus.ToJson());
}

Start a new ad placement #

Start a new Ad placement by placement ID.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroEconomyPlacementStartRequest Request;
Request.PlacementId = TEXT("placement_1");

FHiroOnEconomyPlacementStart OnEconomyPlacementStart;
OnEconomyPlacementStart.AddDynamic(this, &AMyActor::OnEconomyPlacementStart)
FOnError OnError;

HiroClient->EconomyPlacementStart(Session, Request, OnEconomyPlacementStart, OnError)

void AMyActor::OnEconomyPlacementStart(const FHiroEconomyPlacementStatus& EconomyPlacementStatus)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EconomyPlacementStatus.ToJson());
}

Placement success #

Webhook RPC to handle Rewarded Video Ad placement success callbacks.

1
2
3

FOnError OnError;

HiroClient->EconomyPlacementSuccess(Session, OnError);

Placement fail #

Webhook RPC to handle Rewarded Video Ad placement failure callbacks.

1
2
3

FOnError OnError;

HiroClient->EconomyPlacementFail(Session, OnError);

Achievements #

Get all achievements #

Get all achievements with progress accumulated by the player.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FHiroOnAchievementsGet OnAchievementsGet;
OnAchievementsGet.AddDynamic(this, &AMyActor::OnAchievementsGet);
FOnError OnError;

HiroClient->AchievementsGet(Session, OnAchievementsGet, OnError);

void AMyActor::OnAchievementsGet(const FHiroAchievementList& AchievementList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *AchievementList.ToJson());
}

Claim achievements #

Claim one or more achievements which have completed their progress.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

FHiroAchievementsClaimRequest Request;
Request.Ids = {TEXT("achievement_1"), TEXT("achievement_2")};
Request.ClaimTotalReward = true;

FHiroOnAchievementsClaim OnAchievementsClaim;
OnAchievementsClaim.AddDynamic(this, &AMyActor::OnAchievementsClaim);
FOnError OnError;

HiroClient->AchievementsClaim(Session, OnAchievementsClaim, OnError);

void AMyActor::OnAchievementsClaim(const FHiroAchievementsUpdateAck& AchievementsUpdateAck)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *AchievementsUpdateAck.ToJson());
}

Update achievement progress #

Update one or more achievements with the same progress amount.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

FHiroAchievementsUpdateRequest Request;
Request.Ids = {TEXT("achievement_1"), TEXT("achievement_2")};
Request.Amount = 1;

FHiroOnAchievementsUpdate OnAchievementsUpdate;
OnAchievementsUpdate.AddDynamic(this, &AMyActor::OnAchievementsUpdate);
FOnError OnError;

HiroClient->AchievementsUpdate(Session, Request, OnAchievementsUpdate, OnError);

void AMyActor::OnAchievementsUpdate(const FHiroAchievementsUpdateAck& AchievementsAck)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *AchievementsAck.ToJson());
}

Energy #

Get all energies #

Get the energies and their current timers for the player.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FHiroOnEnergyGet OnEnergyGet;
OnEnergyGet.AddDynamic(this, &AMyActor::OnEnergyGet);
FOnError OnError;

HiroClient->EnergyGet(Session, OnEnergyGet, OnError);

void AMyActor::OnEnergyGet(const FHiroEnergyList& EnergyList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EnergyList.ToJson());
}

Spend one or more energies #

Spend one or more energies for the player.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

FHiroEnergySpendRequest Request;
Request.Amounts.Add(TEXT("power"), 10);
Request.Amouns.Add(TEXT("tickets"), 1);

FHiroOnEnergySpend OnEnergySpend;
OnEnergySpend.AddDynamic(this, &AMyActor::OnEnergySpend);
FOnError OnError;

HiroClient->EnergySpend(Session, Request, OnEnergySpend, OnError);

void AMyActor::OnEnergySpend(const FHiroEnergySpendReward& EnergySpendReward)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EnergySpendReward.ToJson());
}

Tutorials #

Get all tutorials #

Get the tutorials and current progress step for the player.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FHiroOnTutorialsGet OnTutorialsGet;
OnTutorialsGet.AddDynamic(this, &AMyActor::OnTutorialsGet);
FOnError OnError;

HiroClient->TutorialsGet(Session, OnTutorialsGet, OnError);

void AMyActor::OnTutorialsGet(const FHiroTutorialList& TutorialList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *TutorialList.ToJson());
}

Accept a tutorial #

Accept an offer to step through a tutorial.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroTutorialAcceptRequest Request;
Request.Id = TEXT("tutorial_1");

FHiroOnTutorialsAccept OnTutorialsAccept;
OnTutorialsAccept.AddDynamic(this, &AMyActor::OnTutorialsAccept);
FOnError OnError;

HiroClient->TutorialsAccept(Session, Request, OnTutorialsAccept, OnError);

void AMyActor::OnTutorialsAccept(const FHiroTutorial& Tutorial)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *Tutorial.ToJson());
}

Decline a tutorial #

Decline an offer to start a tutorial.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroTutorialDeclineRequest Request;
Request.Id = TEXT("tutorial_1");

FHiroOnTutorialsDecline OnTutorialsDecline;
OnTutorialsDecline.AddDynamic(this, &AMyActor::OnTutorialsDecline);
FOnError OnError;

HiroClient->TutorialsDecline(Session, Request, OnTutorialsDecline, OnError);

void AMyActor::OnTutorialsDecline(const FHiroTutorial& Tutorial)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *Tutorial.ToJson());
}

Abandon a tutorial #

Abandon progress on a tutorial.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroTutorialAbandonRequest Request;
Request.Id = TEXT("tutorial_1");

FHiroOnTutorialsAbandon OnTutorialsAbandon;
OnTutorialsAbandon.AddDynamic(this, &AMyActor::OnTutorialsAbandon);
FOnError OnError;

HiroClient->TutorialsAbandon(Session, Request, OnTutorialsAbandon, OnError);

void AMyActor::OnTutorialsAbandon(const FHiroTutorial& Tutorial)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *Tutorial.ToJson());
}

Update progress of a tutorial #

Update the current progress step in the tutorial by ID.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

FHiroTutorialUpdateRequest Request;
Request.Id = TEXT("tutorial_1");
Request.Step = 1;

FHiroOnTutorialsUpdate OnTutorialsUpdate;
OnTutorialsUpdate.AddDynamic(this, &AMyActor::OnTutorialsUpdate);
FOnError OnError;

HiroClient->TutorialsUpdate(Session, Request, OnTutorialsUpdate, OnError);

void AMyActor::OnTutorialsUpdate(const FHiroTutorialList& TutorialList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *TutorialList.ToJson());
}

Teams #

Create a team #

Create a team which other players can join.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

FHiroTeamCreateRequest Request;
Request.Name = TEXT("Example team");
Request.Desc = TEXT("Example description");
Request.Open = true;
Request.Icon = TEXT("icon.png");
Request.LangTag = TEXT("en");
Request.SetupMetadata = TEXT("");

FHiroOnTeamsCreate OnTeamsCreate;
OnTeamsCreate.AddDynamic(this, &AMyActor::OnTeamsCreate);
FOnError OnError;

HiroClient->TeamsCreate(Session, Request, OnTeamsCreate, OnError);

void AMyActor::OnTeamsCreate(const FHiroTeam& Team)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *Team.ToJson());
}

List one or more teams #

List one or more teams which the player can join.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

FHiroTeamListRequest Request;
Request.Cursor = TEXT("");
Request.Location = TEXT("UK");
Request.Limit = 100;

FHiroOnTeamsList OnTeamsList;
OnTeamsList.AddDynamic(this, &AMyActor::OnTeamsList);
FOnError OnError;

HiroClient->TeamsList(Session, Request, OnTeamsList, OnError);

void AMyActor::OnTeamsList(const FHiroTeamList& TeamList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *TeamList.ToJson());
}

Search for a team #

Search for a team by name or optional short code.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

FHiroTeamSearchRequest Request;
Request.Input = TEXT("heroes");
Request.Limit = 100;

FHiroOnTeamsSearch OnTeamsSearch;
OnTeamsSearch.AddDynamic(this, &AMyActor::OnTeamsSearch);
FOnError OnError;

HiroClient->TeamsSearch(Session, Request, OnTeamsSearch, OnError);

void AMyActor::OnTeamsSearch(const FHiroTeamList& TeamList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *TeamList.ToJson());
}

Send team chat message #

Write a chat message to the Team’s chat channel.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

FHiroTeamWriteChatMessageRequest Request;
Request.Id = TEXT("team_1");
Request.Content = TEXT("{\"message\":\"Hey everyone!\"}");

FHiroOnTeamsWriteChatMessage OnTeamsWriteChatMessage;
OnTeamsWriteChatMessage.AddDynamic(this, &AMyActor::OnTeamsWriteChatMessage);
FOnError OnError;

HiroClient->TeamsWriteChatmessage(Session, Request, OnTeamsWriteChatMessage, OnError);

void AMyActor::OnTeamsWriteChatMessage(const FHiroChannelMessageAck& ChannelMessageAck)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *ChannelMessageAck.ToJson());
}

Unlockables #

Create a random unlockable #

Create a random unlockable to assign to a slot (or overflow) unless there are no slots.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FHiroOnUnlockablesCreate OnUnlockablesCreate;
OnUnlockablesCreate.AddDynamic(this, &AMyActor::OnUnlockablesCreate);
FOnError OnError;

HiroClient->UnlockablesCreate(Session, OnUnlockablesCreate, OnError);

void AMyActor::OnUnlockablesCreate(const FHiroUnlockablesList& UnlockablesList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *UnlockablesList.ToJson());
}

Get in progress unlockables #

Get the unlockables which are currently in progress for the player.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FHiroOnUnlockablesCreate OnUnlockablesCreate;
OnUnlockablesCreate.AddDynamic(this, &AMyActor::OnUnlockablesCreate);
FOnError OnError;

HiroClient->UnlockablesGet(Session, OnUnlockablesCreate, OnError);

void AMyActor::OnUnlockablesCreate(const FHiroUnlockablesList& UnlockablesList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *UnlockablesList.ToJson());
}

Start an unlock #

Start the unlock timer for an unlockable in the specified slot.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroUnlockablesRequest Request;
Request.InstanceId = TEXT("unlockable_instance_1");

FHiroOnUnlockablesUnlockStart OnUnlockablesUnlockStart;
OnUnlockablesUnlockStart.AddDynamic(this, &AMyActor::OnUnlockablesUnlockStart);
FOnError OnError;

HiroClient->UnlockablesUnlockStart(Session, Request, OnUnlockablesUnlockStart, OnError);

void AMyActor::OnUnlockablesUnlockStart(const FHiroUnlockablesList& UnlockablesList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *UnlockablesList.ToJson());
}

Purchase an unlockable #

Purchase an unlockable with soft currency based on the remainder cost calculated by the offset left to wait.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroOnUnlockablesPurchaseUnlock Request;
Request.InstanceId = TEXT("unlockable_instance_1");

FHiroOnUnlockablesPurchaseUnlock OnUnlockablesPurchaseUnlock;
OnUnlockablesPurchaseUnlock.AddDynamic(this, &AMyActor::OnUnlockablesPurchaseUnlock);
FOnError OnError;

HiroClient->UnlockablesPurchaseUnlock(Session, Request, OnUnlockablesPurchaseUnlock, OnError);

void AMyActor::OnUnlockablesPurchaseUnlock(const FHiroUnlockablesList& UnlockablesList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *UnlockablesList.ToJson());
}

Purchase a new unlockable slot #

Purchase a new slot to be used to store unlockables.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FHiroOnUnlockablesPurchaseSlot OnUnlockablesPurchaseSlot;
OnUnlockablesPurchaseSlot.AddDynamic(this, &AMyActor::OnUnlockablesPurchaseSlot);
FOnError OnError;

HiroClient->UnlockablesPurchaseSlot(Session, Request, OnUnlockablesPurchaseSlot, OnError);

void AMyActor::OnUnlockablesPurchaseSlot(const FHiroUnlockablesList& UnlockablesList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *UnlockablesList.ToJson());
}

Claim an unlockable #

Claim an unlockable whose start timer has completed or completion was fast tracked with a purchase.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroUnlockablesRequest Request;
Request.InstanceId = TEXT("unlockable_instance_1");

FHiroOnUnlockablesClaim OnUnlockablesClaim;
OnUnlockablesClaim.AddDynamic(this, &AMyActor::OnUnlockablesClaim);
FOnError OnError;

HiroClient->UnlockablesClaim(Session, Request, OnUnlockablesClaim, OnError);

void AMyActor::OnUnlockablesClaim(const FHiroUnlockablesReward& UnlockablesReward)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *UnlockablesReward.ToJson());
}

Base #

Rate app #

Send feedback to the game’s developers over email.

1
2
3
4
5
6
7

FHiroRateAppRequest Request;
Request.Score = 5;
Request.Message = TEXT("I loved it!");

FOnError OnError;

HiroClient->BaseRateApp(Session, Request, OnError);

Set device prefs #

Update or create the mobile push device tokens and preferences for the player.

1
2
3
4
5
6
7
8
9

FHiroDevicePrefsRequest Request;
Request.DeviceId = TEXT("device_id");
Request.PushTokenAndroid = TEXT("android_push_token");
Request.PushTokenIos = TEXT("ios_push_token");
Request.Preferences.Add(TEXT("dark_mode"), true)

FOnError OnError;

HiroClient->BaseRateApp(Session, Request, OnError);

Leaderboards #

Get all leaderboards #

Get the leaderboards defined for the game.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FHiroOnLeaderboardsConfigGet OnLeaderboardsConfigGet;
OnLeaderboardsConfigGet.AddDynamic(this, &AMyActor::OnLeaderboardsConfigGet);
FOnError OnError;

HiroClient->LeaderboardsConfigGet(Session, OnLeaderboardsConfigGet, OnError);

void AMyActor::OnLeaderboardsConfigGet(const FHiroLeaderboardConfigList& LeaderboardConfigList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *LeaderboardConfigList.ToJson());
}

Event Leaderboards #

Get an event leaderboard #

Get a specified event leaderboard defined for the game.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroEventLeaderboardGet Request;
Request.Id = TEXT("leaderboard_1");

FHiroOnEventLeaderboardGet OnEventLeaderboardGet;
OnEventLeaderboardGet.AddDynamic(this, &AMyActor::OnEventLeaderboardGet);
FOnError OnError;

HiroClient->EventLeaderboardGet(Session, Request, OnEventLeaderboardGet, OnError);

void AMyActor::OnEventLeaderboardGet(const FHiroEventLeaderboard& EventLeaderboard)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EventLeaderboard.ToJson());
}

Update event leaderboard record #

Update an event leaderboard record for a user.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

FHiroEventLeaderboardUpdate Request;
Request.Id = TEXT("leaderboard_1");
Request.Score = 100;
Request.Subscore = 10;

FHiroOnEventLeaderboardUpdate OnEventLeaderboardUpdate;
OnEventLeaderboardUpdate.AddDynamic(this, &AMyActor::OnEventLeaderboardUpdate);
FOnError OnError;

HiroClient->EventLeaderboardUpdate(Session, Request, OnEventLeaderboardUpdate, OnError);

void AMyActor::OnEventLeaderboardUpdate(const FHiroEventLeaderboard& EventLeaderboard)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EventLeaderboard.ToJson());
}

Claim event leaderboard reward #

Claim an event leaderboard reward for a user.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroEventLeaderboardClaim Request;
Request.Id = TEXT("leaderboard_1");

FHiroOnEventLeaderboardClaim OnEventLeaderboardClaim;
OnEventLeaderboardClaim.AddDynamic(this, &AMyActor::OnEventLeaderboardClaim);
FOnError OnError;

HiroClient->EventLeaderboardClaim(Session, Request, OnEventLeaderboardClaim, OnError);

void AMyActor::OnEventLeaderboardClaim(const FHiroEventLeaderboard& EventLeaderboard)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EventLeaderboard.ToJson());
}

Roll a new cohort #

Roll a new cohort for the specified event leaderboard.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroEventLeaderboardRoll Request;
Request.Id = TEXT("leaderboard_1");

FHiroOnEventLeaderboardRoll OnEventLeaderboardRoll;
OnEventLeaderboardRoll.AddDynamic(this, &AMyActor::OnEventLeaderboardRoll);
FOnError OnError;

HiroClient->EventLeaderboardRoll(Session, Request, OnEventLeaderboardRoll, OnError);

void AMyActor::OnEventLeaderboardRoll(const FHiroEventLeaderboard& EventLeaderboard)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *EventLeaderboard.ToJson());
}

Stats #

Get all stats #

Get all stats.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FHiroOnStatsGet OnStatsGet;
OnStatsGet.AddDynamic(this, &AMyActor::OnStatsGet);
FOnError OnError;

HiroClient->StatsGet(Session, OnStatsGet, OnError);

void AMyActor::OnStatsGet(const FHiroStatList& StatList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *StatList.ToJson());
}

Update stats for the player #

Update stats.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

FHiroStatUpdateRequest Request;

FHiroStatUpdate StatUpdate1;
StatUpdate1.Name = "public_stat_1";
StatUpdate1.Value = 100;
StatUpdate1.Operator = EHiroStatUpdateOperator::STAT_UPDATE_OPERATOR_SET; // Replace SomeEnumValue with the actual enum value
Request.Public.Add(StatUpdate1);

FHiroStatUpdate StatUpdate2;
StatUpdate2.Name = "private_stat_1";
StatUpdate2.Value = 100;
StatUpdate2.Operator = EHiroStatUpdateOperator::STAT_UPDATE_OPERATOR_SET; // Replace SomeEnumValue with the actual enum value
Request.Private.Add(StatUpdate2);

FHiroOnStatsUpdate OnStatsUpdate;
OnStatsUpdate.AddDynamic(this, &AMyActor::OnStatsUpdate);
FOnError OnError;

HiroClient->StatsUpdate(Session, Request, OnEventLeaderboardRoll, OnError);

void AMyActor::OnStatsUpdate(const FHiroStatList& StatList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *StatList.ToJson());
}

Progression #

Get all progressions #

Get progressions.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FHiroOnProgressionsGet OnProgressionsGet;
OnProgressionsGet.AddDynamic(this, &AMyActor::OnProgressionsGet);
FOnError OnError;

HiroClient->ProgressionsGet(Session, OnProgressionsGet, OnError);

void AMyActor::OnProgressionsGet(const FHiroProgressionList& ProgressionList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *ProgressionList.ToJson());
}

Purchase progression #

Purchase a progression for permanent unlock, if supported.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

FHiroProgressionPurchaseRequest Request;
Request.Id = TEXT("progression_1");

FHiroOnProgressionsPurchase OnProgressionsPurchase;
OnProgressionsPurchase.AddDynamic(this, &AMyActor::OnProgressionsPurchase);
FOnError OnError;

HiroClient->ProgressionsPurchase(Session, Request, OnProgressionsPurchase, OnError);

void AMyActor::OnProgressionsPurchase(const FHiroProgressionList& ProgressionList)
{
    UE_LOG(LogTemp, Log, TEXT("%s"), *ProgressionList.ToJson());
}