Difficulty tuning for studios

Ease the level on the third failure, before the quit

A player who installed this morning has failed level four three times in a row, and the game is loading it a fourth time unchanged. Difficulty is set per level in the balance sheet, so a level that is too hard for new players shows up in the funnel review and changes in the next patch. By then this player has gone. The fourth attempt is where the level needs to give a little, with a slower wave, an extra life or a boost dropped into the inventory.

What Signals knows

level_failures_session: How many times they failed each level this session
level_attempts_session: How many times they started each level this session
levels_cleared_lifetime: Levels they have ever completed

What your game server does

Loads the fourth attempt with the easing your designers set for that level, a slower wave or an extra life, once this player's failures on it reach three this session and they are still in their first few levels, and leaves the level as designed for everyone else.

game-server.ts · 13 lines

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

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

# Counted per level id, so the server looks up the level it is about to load.
level_failures_session = Attribute(
    name="level_failures_session",
    type="dict",
    events=[level_failed],
    aggregation="category_count",
    property=EventProperty(vendor="com.example", name="level_failed", major_version=1, path="level_id"),
    period=timedelta(hours=1),
)

level_attempts_session = Attribute(
    name="level_attempts_session",
    type="dict",
    events=[level_started],
    aggregation="category_count",
    property=EventProperty(vendor="com.example", name="level_started", major_version=1, path="level_id"),
    period=timedelta(hours=1),
)

levels_cleared_lifetime = Attribute(
    name="levels_cleared_lifetime",
    type="int32",
    events=[level_completed],
    aggregation="counter",
    ttl=timedelta(days=365),
    default_value=0,
)

# Players are logged in, so the group keys on the player's user id.
game_difficulty_retry = StreamAttributeGroup(
    name="game_difficulty_retry",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[level_failures_session, level_attempts_session, levels_cleared_lifetime],
)

// In the game server, when it builds the next level load
const player = await signals.getServiceAttributes({
  name: "game_difficulty_retry",
  attribute_key: "user_id",
  identifier: playerId,
});
// { level_failures_session: { "4": 3, "3": 1 }, level_attempts_session: { "4": 4, "3": 2 }, levels_cleared_lifetime: 3 }

const failures = player.level_failures_session[levelId] ?? 0;

if (failures >= 3 && player.levels_cleared_lifetime < 10) {
  level.load({ id: levelId, tuning: "eased", grant: "extra_life" });
}

Show the hint before the dry spell becomes a quit

A player has been in the game for half an hour and has not cleared anything in twenty minutes. They are not stuck on one level, they are moving between two levels and the daily puzzle without a win. Lowering difficulty here would feel like the game noticing them struggle. The quieter fix is a hint on the next load for the mechanic they keep missing, and the usual hint system waits for them to tap the question mark.

What Signals knows

minutes_since_last_win: Minutes since they last completed a level
wins_1h: Levels completed in the last hour
failures_1h: Levels failed in the last hour

What your game server does

Shows the hint for the level's core mechanic on the next load once this player has gone twenty minutes without a win and has failed at least twice in that time, and leaves difficulty where the designers set it.

game-server.ts · 11 lines

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

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

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

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

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

game_difficulty_drought = StreamAttributeGroup(
    name="game_difficulty_drought",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[minutes_since_last_win, wins_1h, failures_1h],
)

// In the game server, when it builds the next level load
const player = await signals.getServiceAttributes({
  name: "game_difficulty_drought",
  attribute_key: "user_id",
  identifier: playerId,
});
// { minutes_since_last_win: 22.4, wins_1h: 1, failures_1h: 3 }

if (player.minutes_since_last_win >= 20 && player.failures_1h >= 2) {
  level.load({ id: levelId, hint: level.coreMechanic });
}

Raise the challenge for the player who is coasting

A player has cleared six levels tonight, every one on the first attempt. The curve was tuned for the average player, and this one is well ahead of it. A game with no resistance gets put down as readily as one with too much, and the drop-off shows up a week later as a D7 dip with no obvious cause. The next level is the place for a harder wave or a time target, while they are still enjoying themselves.

What Signals knows

first_try_clears_session: Levels completed on the first attempt this session
failures_session: Levels failed this session

What your game server does

Loads the next level in the harder variant your designers built once this player has cleared five in a row on the first attempt without a failure this session, and steps back to the standard version after their first failure.

game-server.ts · 11 lines

from datetime import timedelta
from snowplow_signals import (
    Attribute, Criteria, Criterion, Event, EventProperty, StreamAttributeGroup, user_id,
)

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

# level_completed carries the attempt number, so a first-try clear is attempt 1.
first_try_clears_session = Attribute(
    name="first_try_clears_session",
    type="int32",
    events=[level_completed],
    aggregation="counter",
    criteria=Criteria(all=[
        Criterion.eq(EventProperty(vendor="com.example", name="level_completed", major_version=1, path="attempt"), 1),
    ]),
    period=timedelta(hours=1),
    default_value=0,
)

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

game_difficulty_streak = StreamAttributeGroup(
    name="game_difficulty_streak",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[first_try_clears_session, failures_session],
)

// In the game server, when it builds the next level load
const player = await signals.getServiceAttributes({
  name: "game_difficulty_streak",
  attribute_key: "user_id",
  identifier: playerId,
});
// { first_try_clears_session: 6, failures_session: 0 }

if (player.first_try_clears_session >= 5 && player.failures_session === 0) {
  level.load({ id: levelId, tuning: "hard", timeTarget: true });
}

Open with a warm-up when the player has been away

A player comes back after eight days, and the game drops them into the level they left on, which was the hardest one they had reached. The controls are rusty and the mechanic they learned last week has faded. The message that brought them back has done its job, and the first minute decides whether it was worth sending. The first load should be a warm-up level or a reminder of the controls, and the game can only choose that if it knows how long they have been gone.

What Signals knows

days_since_last_session: Days since they last opened the game
sessions_30d: Sessions in the last 30 days
last_level_cleared: The last level they completed

What your game server does

Loads a warm-up variant of the level they left on, with the controls reminder, when this player has been away more than seven days, and goes straight to the level when they played yesterday.

game-server.ts · 11 lines

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

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

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

sessions_30d = Attribute(
    name="sessions_30d",
    type="int32",
    events=[session_start],
    aggregation="counter",
    period=timedelta(days=30),
    default_value=0,
)

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

game_difficulty_return = StreamAttributeGroup(
    name="game_difficulty_return",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[days_since_last_session, sessions_30d, last_level_cleared],
)

// In the game server, when it builds the first level load of a session
const player = await signals.getServiceAttributes({
  name: "game_difficulty_return",
  attribute_key: "user_id",
  identifier: playerId,
});
// { days_since_last_session: 8.3, sessions_30d: 4, last_level_cleared: "11" }

if (player.days_since_last_session > 7) {
  level.load({ id: player.last_level_cleared, tuning: "warm_up", controlsReminder: true });
}

Difficulty that adjusts before the player quits.

Keep more players past the first day and the first week by tuning the level while they are still playing.

Ease the level on the third failure, before the quit

Show the hint before the dry spell becomes a quit

Raise the challenge for the player who is coasting

Open with a warm-up when the player has been away

Try it on your own site.