In-game store offers for studios

Offer the small bundle of what the player just ran out of

A player has run out of gems two rooms from the end of a level, and the store opens on the standard bundle because that is what was configured before the session began. The bundle is sized for a planned purchase. What this player wants is enough gems to finish the room they are standing in, and by the time the catalog is retuned the level is over. The small gem bundle, offered where they ran out, is the purchase that fits.

What Signals knows

last_currency_depleted: The premium currency they most recently ran out of
depleted_at: The level they were in when it ran out
minutes_since_depleted: Minutes since it happened

What your game server does

Opens the store on the small bundle of the currency that just ran out, placed at the point in the level where it happened, when the depletion is a few minutes old. Which bundle counts as small, and its price, come from your monetization team's rules.

game-server.ts · 14 lines

from snowplow_signals import Attribute, Event, EventProperty, StreamAttributeGroup, user_id

currency_depleted = Event(name="currency_depleted", vendor="com.example", version="1-0-0")

last_currency_depleted = Attribute(
    name="last_currency_depleted",
    type="string",
    events=[currency_depleted],
    aggregation="last",
    property=EventProperty(vendor="com.example", name="currency_depleted", major_version=1, path="currency"),
)

depleted_at = Attribute(
    name="depleted_at",
    type="string",
    events=[currency_depleted],
    aggregation="last",
    property=EventProperty(vendor="com.example", name="currency_depleted", major_version=1, path="level_id"),
)

minutes_since_depleted = Attribute(
    name="minutes_since_depleted",
    type="double",
    events=[currency_depleted],
    aggregation="time_since_last",
    time_unit="min",
)

# Players are signed in, so the game server asks by player id.
game_store_depleted = StreamAttributeGroup(
    name="game_store_depleted",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[last_currency_depleted, depleted_at, minutes_since_depleted],
)

// In the game server, when the client asks for the store
const player = await signals.getServiceAttributes({
  name: "game_store_depleted",
  attribute_key: "user_id",
  identifier: playerId,
});
// { last_currency_depleted: "gems", depleted_at: "w3_l7", minutes_since_depleted: 1.4 }

if (player.minutes_since_depleted < 10) {
  store.open({
    lead: bundles.small(player.last_currency_depleted),
    placement: { level: player.depleted_at },
  });
}

Show the starter offer when the store keeps getting closed

A player has opened the store three times in this session and closed it each time without buying. The catalog is the same on the third open as on the first, and the starter offer the monetization team set aside for players like this sits behind a segment that gets rebuilt later, after the session has ended. Three opens and no purchase is the moment that offer was made for, and the player is in the store right now.

What Signals knows

store_opens_session: Times they opened the store in the last hour
purchases_session: Purchases in the last hour

What your game server does

Shows the starter offer your rules allow once per player when the store has been opened three times this session without a purchase, and records on your side that this player has had it, so the fourth open goes back to the catalog.

game-server.ts · 14 lines

from datetime import timedelta
from snowplow_signals import Attribute, Event, StreamAttributeGroup, user_id

store_opened = Event(name="store_opened", vendor="com.example", version="1-0-0")
purchase = Event(name="purchase", vendor="com.example", version="1-0-0")

# A session on this title runs well under an hour, so an hour-long window stands in for it.
store_opens_session = Attribute(
    name="store_opens_session",
    type="int32",
    events=[store_opened],
    aggregation="counter",
    period=timedelta(hours=1),
    default_value=0,
)

purchases_session = Attribute(
    name="purchases_session",
    type="int32",
    events=[purchase],
    aggregation="counter",
    period=timedelta(hours=1),
    default_value=0,
)

game_store_browsing = StreamAttributeGroup(
    name="game_store_browsing",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[store_opens_session, purchases_session],
)

// In the game server, when the client asks for the store
const player = await signals.getServiceAttributes({
  name: "game_store_browsing",
  attribute_key: "user_id",
  identifier: playerId,
});
// { store_opens_session: 3, purchases_session: 0 }

const eligible = await offers.notYetShown(playerId, "starter");

if (player.store_opens_session >= 3 && player.purchases_session === 0 && eligible) {
  store.open({ lead: offers.starter });
  offers.markShown(playerId, "starter");
}

Lead the store with what this player buys

Every purchase this player has made in the last three months has been a skin. The store front leads with the currency bundles and the season pass, because the front page is laid out for the average player and changes on the content schedule. This player scrolls past the top row every time. Leading with skins puts the thing they buy where they look first.

What Signals knows

purchases_by_type_90d: How many items of each type they bought in the last ninety days
last_item_type: The type of the last item they bought

What your game server does

Moves the item type this player keeps buying to the top row of the store when it makes up most of their purchases this quarter, and keeps the rest of the layout as the content team set it.

game-server.ts · 15 lines

from datetime import timedelta
from snowplow_signals import Attribute, Event, EventProperty, StreamAttributeGroup, user_id

purchase = Event(name="purchase", vendor="com.example", version="1-0-0")
item_type = EventProperty(vendor="com.example", name="purchase", major_version=1, path="item_type")

purchases_by_type_90d = Attribute(
    name="purchases_by_type_90d",
    type="dict",
    events=[purchase],
    aggregation="category_count",
    property=item_type,
    period=timedelta(days=90),
)

last_item_type = Attribute(
    name="last_item_type",
    type="string",
    events=[purchase],
    aggregation="last",
    property=item_type,
)

game_store_cosmetics = StreamAttributeGroup(
    name="game_store_cosmetics",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[purchases_by_type_90d, last_item_type],
)

// In the game server, when it lays out the store front
const player = await signals.getServiceAttributes({
  name: "game_store_cosmetics",
  attribute_key: "user_id",
  identifier: playerId,
});
// { purchases_by_type_90d: { skin: 6, emote: 1 }, last_item_type: "skin" }

const counts = Object.entries(player.purchases_by_type_90d);
const total = counts.reduce((sum, [, n]) => sum + n, 0);
const [topType, topCount] = counts.sort((a, b) => b[1] - a[1])[0];

if (topCount / total > 0.6) {
  store.lead({ row: topType });
}

Make the first-purchase offer to a daily player on a level clear

A player has cleared levels on twelve of the last fourteen days and has never bought anything. The first-purchase offer is in the catalog, and it reaches players on a schedule that does not know how long their streak is or what they just did. A daily player who has just cleared a level is the one most open to it, and the level-clear screen is where it belongs, before they go back to the map.

What Signals knows

active_days_14d: Days with a level cleared in the last fourteen
lifetime_purchases: Purchases since the account was created

What your game server does

Puts the first-purchase offer on the level-clear screen when a player with no purchases has cleared a level on most of the last fourteen days, and leaves the screen alone for anyone who has bought before or plays now and then.

game-server.ts · 11 lines

from datetime import timedelta
from snowplow_signals import Attribute, AtomicProperty, Event, StreamAttributeGroup, user_id

level_completed = Event(name="level_completed", vendor="com.example", version="1-0-0")
purchase = Event(name="purchase", vendor="com.example", version="1-0-0")

active_days_14d = Attribute(
    name="active_days_14d",
    type="int32",
    events=[level_completed],
    aggregation="approx_count_distinct",
    property=AtomicProperty(name="derived_tstamp", date_part="active_day"),
    period=timedelta(days=14),
)

# No period, so the count runs over the whole account; the ttl expires it for a player who stops playing.
lifetime_purchases = Attribute(
    name="lifetime_purchases",
    type="int32",
    events=[purchase],
    aggregation="counter",
    ttl=timedelta(days=365),
    default_value=0,
)

game_store_first_purchase = StreamAttributeGroup(
    name="game_store_first_purchase",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[active_days_14d, lifetime_purchases],
)

// In the game server, when it builds the level-clear screen
const player = await signals.getServiceAttributes({
  name: "game_store_first_purchase",
  attribute_key: "user_id",
  identifier: playerId,
});
// { active_days_14d: 12, lifetime_purchases: 0 }

if (player.lifetime_purchases === 0 && player.active_days_14d >= 12) {
  levelClear.show({ offer: offers.firstPurchase });
}

A store offer that fits what the player ran out of.

Earn more per player per day by building the offer for the session they are in.

Offer the small bundle of what the player just ran out of

Show the starter offer when the store keeps getting closed

Lead the store with what this player buys

Make the first-purchase offer to a daily player on a level clear

Try it on your own site.