Live event invites for studios

Show the invite in the lobby before they log off

A player has just finished their third match of the session and has not entered the event that opened this week. The invite goes out on a schedule, as a push or an email, and it tends to reach them after they have logged off for the night. The lobby they are about to see is the better place for it, with the event one tap away and the player still in the mood for another match.

What Signals knows

matches_session: Matches they have finished this session
event_entries: Times they have entered the event since it opened

What your game and messaging tool do

Shows the event invite on the lobby screen when a player has finished a match this session and has no entry to the event, and tells your messaging tool the invite was shown so the scheduled push skips them.

game-server.ts · 12 lines

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

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

# Keyed on the player, so a rolling two hours stands in for the session.
matches_session = Attribute(
    name="matches_session",
    type="int32",
    events=[match_ended],
    aggregation="counter",
    period=timedelta(hours=2),
    default_value=0,
)

# The event runs for two weeks, so the window is the event window.
event_entries = Attribute(
    name="event_entries",
    type="int32",
    events=[event_entered],
    aggregation="counter",
    period=timedelta(days=14),
    default_value=0,
)

game_events_lobby = StreamAttributeGroup(
    name="game_events_lobby",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[matches_session, event_entries],
)

// In the server code that builds the lobby after a match
const player = await signals.getServiceAttributes({
  name: "game_events_lobby",
  attribute_key: "user_id",
  identifier: playerId,
});
// { matches_session: 3, event_entries: 0 }

if (player.matches_session >= 1 && player.event_entries === 0) {
  lobby.show({ card: "event_invite", event: "spring_cup" });
  messaging.suppress({ campaign: "event_invite_push", playerId });
}

Remind them where they stand, not that the event exists

A player entered the event the day it opened, played one event match and has queued for ranked ever since. The reminder they get is the same invite everyone gets, so it tells them about an event they entered a week ago. What would bring them back is their standing, their place in the table and the matches left to climb it, shown in the lobby when they come back from a ranked match.

What Signals knows

event_entries: Times they have entered the event since it opened
event_matches: Event matches they have played since it opened
days_since_event_match: Days since their last event match

What your game and messaging tool do

Swaps the general invite for a standing card when a player has an entry and no event match in the last three days, filling in the rank from your own leaderboard, and keeps the general invite for the player with no entry at all.

game-server.ts · 12 lines

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

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

event_entries = Attribute(
    name="event_entries",
    type="int32",
    events=[event_entered],
    aggregation="counter",
    period=timedelta(days=14),
    default_value=0,
)

event_matches = Attribute(
    name="event_matches",
    type="int32",
    events=[event_match_played],
    aggregation="counter",
    period=timedelta(days=14),
    default_value=0,
)

days_since_event_match = Attribute(
    name="days_since_event_match",
    type="double",
    events=[event_match_played],
    aggregation="time_since_last",
    time_unit="d",
)

game_events_standing = StreamAttributeGroup(
    name="game_events_standing",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[event_entries, event_matches, days_since_event_match],
)

// In the server code that builds the lobby after a match
const player = await signals.getServiceAttributes({
  name: "game_events_standing",
  attribute_key: "user_id",
  identifier: playerId,
});
// { event_entries: 1, event_matches: 1, days_since_event_match: 6.4 }

if (player.event_entries > 0 && player.days_since_event_match >= 3) {
  const rank = await leaderboard.rankFor(playerId, "spring_cup");
  lobby.show({ card: "event_standing", rank, matchesPlayed: player.event_matches });
}

Send one push at the hour they usually play

A player who plays most evenings has not opened the game since the event opened four days ago. The event push goes out at launch time to everyone, and for this player that is the middle of a workday, so it is swiped away with the rest of the morning's notifications. One push, on a day they are missing and at the hour they usually pick the game up, is a different message, and one is enough.

What Signals knows

usual_hour_30d: The hour of day they have played most in the last 30 days
days_since_session: Days since their last session, counted from the last match they finished
event_entries: Times they have entered the event since it opened

What your game and messaging tool do

Schedules a single push in your messaging tool for the player's usual hour once a regular has been away since the event opened and has no entry, and sends nothing to the player who has been in the game since it opened.

push-scheduler.ts · 15 lines

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

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

# The hour is taken from each match's timestamp before the count, so the
# value is the hour they play most, not the time of any one match.
usual_hour_30d = Attribute(
    name="usual_hour_30d",
    type="int32",
    events=[match_ended],
    aggregation="most_frequent",
    property=AtomicProperty(name="derived_tstamp", date_part="hour_of_day"),
    period=timedelta(days=30),
)

days_since_session = Attribute(
    name="days_since_session",
    type="double",
    events=[match_ended],
    aggregation="time_since_last",
    time_unit="d",
)

event_entries = Attribute(
    name="event_entries",
    type="int32",
    events=[event_entered],
    aggregation="counter",
    period=timedelta(days=14),
    default_value=0,
)

game_events_usual_hour = StreamAttributeGroup(
    name="game_events_usual_hour",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[usual_hour_30d, days_since_session, event_entries],
)

// In the job that schedules event pushes in your messaging tool
const player = await signals.getServiceAttributes({
  name: "game_events_usual_hour",
  attribute_key: "user_id",
  identifier: playerId,
});
// { usual_hour_30d: 20, days_since_session: 4.2, event_entries: 0 }

if (player.days_since_session >= eventOpenedDaysAgo && player.event_entries === 0) {
  messaging.scheduleOnce({
    campaign: "event_invite_push",
    playerId,
    sendAtHour: player.usual_hour_30d,
  });
}

Tell them how close the reward is while they are in the lobby

A player has played eight event matches and the reward unlocks at ten. The progress bar is on the event screen, two taps away, and from the lobby the player heads back to ranked without seeing it. The two matches that finish the reward are the easiest ones to ask for, and the ask belongs on the lobby screen between matches, where the event queue is one tap away.

What Signals knows

event_matches: Event matches they have played since it opened
matches_session: Matches they have finished this session

What your game and messaging tool do

Shows a two-matches-to-go line on the lobby card when a player's event matches are within two of the reward threshold your live ops team set, and points the play button at the event queue for the next match.

game-server.ts · 13 lines

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

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

event_matches = Attribute(
    name="event_matches",
    type="int32",
    events=[event_match_played],
    aggregation="counter",
    period=timedelta(days=14),
    default_value=0,
)

matches_session = Attribute(
    name="matches_session",
    type="int32",
    events=[match_ended],
    aggregation="counter",
    period=timedelta(hours=2),
    default_value=0,
)

game_events_reward = StreamAttributeGroup(
    name="game_events_reward",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[event_matches, matches_session],
)

// In the server code that builds the lobby after a match
const player = await signals.getServiceAttributes({
  name: "game_events_reward",
  attribute_key: "user_id",
  identifier: playerId,
});
// { event_matches: 8, matches_session: 2 }

const remaining = REWARD_THRESHOLD - player.event_matches;
if (remaining > 0 && remaining <= 2 && player.matches_session >= 1) {
  lobby.show({ card: "event_reward_progress", remaining });
  lobby.setPlayQueue("spring_cup");
}

Invite the player while they are still in the lobby.

Get more players into the event by inviting them while they are still playing.

Show the invite in the lobby before they log off

Remind them where they stand, not that the event exists

Send one push at the hour they usually play

Tell them how close the reward is while they are in the lobby

Try it on your own site.