Active Engagement Time

Overview

AET turns engagement into a single number you can compare across any playable — tap, swipe, drag, gyro, hold. It counts active seconds (time the player is genuinely driving the game) and fires one event per second.

AET (report) = count(AET) ÷ impressions  =  average active seconds per user.

One file (aet.js, ~150 lines, no deps). You write one line of game-specific code — telling AET when the player is engaged. Everything else (per-second clock, AFK + tab-hidden gating, first-input signal, cumulative across PLAY AGAIN, live event firing, debug HUD) is built in.

▶ Try it live — the interaction playground runs a mock playable for every control (drag, gyro, hold, swipe, tap) with the live AET HUD. Great for onboarding.

Install

1. Get the file. Download it directly (no GitHub access needed):

copycurl -O https://aet-sdk.vercel.app/aet.js

…or open aet-sdk.vercel.app/aet.js and Save As aet.js, or clone creativehubiion/aet-sdk and copy aet.js in.

2. Drop it into your playable and import it — your bundler inlines it into the creative. It is not loaded from a URL at runtime (creatives must be self-contained). ES module; for non-bundled creatives load via <script type="module">.

copyimport { AET } from "./aet.js";

Quick start

copyconst aet = new AET({
  send: (name) => fetch(window.trackingType + name),  // your DMP call
});

aet.start();                       // run starts (PLAY tapped) → fires "StartPlayable" once

// tell AET when the player is engaged — pick ONE per control:
onTap(() => aet.markInput());                  // discrete (tap / swipe)
gameLoop((dt) => aet.setActive(isSteering));   // continuous (drag / gyro / hold)

aet.pause();                       // run ends → AET kept; PLAY AGAIN → start() resumes adding

That's it. AET fires once per active second; idle / AFK / backgrounded time never counts; replays accumulate within the impression.

How it works

AET measures active seconds — not a count of inputs (a held drag is "1 input", a gyro stream is hundreds; those aren't comparable). Every frame it asks one question — "is the player engaged right now?" — and sums the time the answer is yes.

• 1 AET event = 1 active second.
• The clock starts at the first real interaction (which also fires control_active) — not on load.
• Active time is gated on three things, all required: run live · ad foregrounded (Page Visibility) · player engaged.
• It accumulates across PLAY AGAIN within one impression (resets on a fresh page load).
• Events fire live — you never lose data if the user closes the ad.

Models & idleMs

Every control reduces to one of two models — that's the whole game-specific decision:

What idleMs is

One knob: how long one input keeps you "active" before AET assumes you stopped. If another input lands within idleMs, active runs unbroken; if idleMs passes with no input, it flips to idle. (Only used by discrete controls; continuous ignores it.)

Choosing the cap (idleMs)

Set it to roughly the time between inputs when the player is actively playing, plus a little headroom — so in-rhythm play reads as continuous but real pauses read as idle. Three ways, best to worst:

1. From data. Log gaps between inputs in a playtest; the histogram splits into in-rhythm gaps and pauses — set the cap in the valley (~85th percentile of in-play gaps).
2. From the game's cadence (heuristic below).
3. Fallback default: 2000 ms — a sane middle for casual discrete games.

API

Options

Control recipes

copy// TAP (discrete)
input.on("pointerdown", () => aet.markInput());

// SWIPE / flick (discrete)
onSwipeDetected(() => aet.markInput());

// DRAG — track the finger (continuous), each frame:
const dx = pointer.isDown ? pointer.x - player.x : 0;
aet.setActive(pointer.isDown && Math.abs(dx) > DEADZONE_PX);

// GYRO / tilt (continuous), each frame:
aet.setActive(gyroActive && Math.abs(gamma) > GYRO_DEADZONE);

// HOLD (continuous):
zone.on("pointerdown", () => held = true);
zone.on("pointerup",   () => held = false);
aet.setActive(held);   // each frame

Rule of thumb: “active” should mean the player is causing something to happen (character moving, charging, aiming) — not merely touching the screen.

Engine adapters

Phaser

copycreate() {
  this.aet = new AET({ send: (n) => fetch(window.trackingType + n), autoLoop: false });
}
startRun() { this.aet.start(); }
update() {
  this.aet.setActive(this._isSteering());   // continuous
  this.aet.update(this.game.loop.delta);
}
onGameOver() { this.aet.pause(); }           // PLAY AGAIN → startRun() again

Plain canvas / requestAnimationFrame

copyconst aet = new AET({ send: (n) => fetch(TRACKER + n) }); // autoLoop on
playBtn.onclick = () => aet.start();
canvas.addEventListener("pointerdown", () => aet.markInput());
function onGameOver() { aet.pause(); }

PixiJS / Three.js: same as Phaser — autoLoop:false, then in your ticker call setActive(...) (continuous) and update(deltaMs).

Events & DMP

Fire to the same tracker via window.trackingType + eventName (PLL/GAM macros fill campaign_id at serve time).

Fire your own CTAClick / milestones / PlayAgain with the same send call.

QA & debug HUD

Open any playable with ?debug=1 — a HUD shows AET 0.0s · ticks 0 · ○ idle. Verify in 30s:

1. Do your control → HUD flips to ● ACTIVE and ticks climb.
2. Stop (lift finger / level the phone / pause tapping) → returns to ○ idle and freezes.
3. Background the tab → counting stops; foreground → resumes.

If it ticks while you're not engaged, your setActive/markInput predicate is too loose. If it never ticks while engaged, you're not calling it (or start() wasn't called). Try the interaction playground to see every model side by side.

Pitfalls

• Don't count raw inputs as the metric — gyro and tap aren't comparable. Time is.
• Don't fire only at game-over — users close ads mid-run. AET fires live per second.
• Don't reset per replay — let it accumulate across PLAY AGAIN (the SDK does this).
• Don't make “active” = “finger on screen” — make it “player is causing motion”.
• When A/B testing two versions, match the control difficulty so AET reflects real engagement — not one control simply being easier.