Godot Development

func _ready():
    if PlaycademySdk:
        PlaycademySdk.sdk_ready.connect(_on_sdk_ready)
        PlaycademySdk.sdk_initialization_failed.connect(_on_sdk_init_failed)

        # Connect to API signals
        PlaycademySdk.users.profile_received.connect(_on_profile_received)

func _on_sdk_ready():
    print("SDK Ready!")
    PlaycademySdk.users.me()

func _on_sdk_init_failed(error: String):
    printerr("SDK failed:", error)

func _on_sdk_ready():
    match PlaycademySdk.mode:
        "platform":
            # Authenticated user, full SDK surface
            PlaycademySdk.users.me()
        "demo":
            # Anonymous user, landing-page demo shell
            start_demo_flow()
        "standalone":
            # Running outside any iframe — mock token, no real user
            start_offline_flow()

func _ready():
    if PlaycademySdk.mode != "demo":
        return

    # Profile reads/writes resolve asynchronously via signals.
    PlaycademySdk.demo.profile_get_succeeded.connect(_on_demo_profile)
    PlaycademySdk.demo.profile_update_succeeded.connect(_on_demo_profile)
    PlaycademySdk.demo.profile_get()

func _on_demo_profile(profile: Dictionary):
    # profile → { "displayName": String, "isDefault": bool }
    # `isDefault` means the player is still on the server-generated
    # placeholder handle — prompt them before the next run.
    if profile.get("isDefault", true):
        PlaycademySdk.demo.profile_update({ "displayName": "linus-torvalds" })

func _on_round_finished(final_score: int, duration_ms: int):
    PlaycademySdk.demo.end(final_score, {
        "durationMs": duration_ms,
        "metadata": { "level": current_level },
    })

func try_submit_score(score: int):
    if not PlaycademySdk.assert_platform_mode("scores.submit"):
        return
    PlaycademySdk.scores.submit(score, { "level": current_level })

# Get current user
PlaycademySdk.users.me()

func _on_profile_received(user_data: Dictionary):
    print("User:", user_data.name)
    print("ID:", user_data.id)

# Submit a score
PlaycademySdk.scores.submit(1500, { "level": 5, "difficulty": "hard" })

func _on_submit_succeeded(score_data: Dictionary):
    print("Score submitted!")

# Signal ready
PlaycademySdk.runtime.ready()

# Exit
PlaycademySdk.runtime.exit()

# Start tracking an activity
var activity_metadata = {
    "activityId": "math-quiz-1",
    "grade": 3,
    "subject": "Math"
}

PlaycademySdk.timeback.start_activity(activity_metadata)

# ... student completes the activity ...

# End activity and submit results (XP calculated automatically)
var score_data = {
    "correctQuestions": 8,
    "totalQuestions": 10
}

PlaycademySdk.timeback.end_activity(score_data)

# Access user properties
var user = PlaycademySdk.timeback.user
var id = user.id                     # TimeBack user ID
var role = user.role                 # "student", "parent", "teacher", etc.
var enrollments = user.enrollments   # Array of { id, subject, grade, courseId }
var orgs = user.organizations        # Array of { id, name, type }

# Fetch fresh Timeback user data
PlaycademySdk.timeback.user.fetch()

# Fetch XP data
PlaycademySdk.timeback.user.xp.fetch({"include": ["today"]})

# Fetch highest grade mastered for a subject
PlaycademySdk.timeback.user.highest_grade_mastered.fetch({"subject": "Math"})

var id = PlaycademySdk.timeback.user.id
# "abc123-def456-..."

var role = PlaycademySdk.timeback.user.role
# "student", "parent", "teacher", "administrator", or "guardian"

var enrollments = PlaycademySdk.timeback.user.enrollments
# [{ "subject": "Math", "grade": 3, "courseId": "..." }, ...]

var orgs = PlaycademySdk.timeback.user.organizations
# [{ "id": "...", "name": "Playcademy Studios", "type": "school" }, ...]

PlaycademySdk.timeback.user.fetch()

# Fetch XP data
PlaycademySdk.timeback.user.xp.fetch({
    "include": ["today"],  # Include today's XP breakdown
    "force": false         # Use cached data if available
})

# Basic fetch (uses 5-second cache)
PlaycademySdk.timeback.user.xp.fetch()

# Include today's XP in response
PlaycademySdk.timeback.user.xp.fetch({
    "include": ["today"]
})

# Filter by grade and subject (must provide both)
PlaycademySdk.timeback.user.xp.fetch({
    "grade": 3,
    "subject": "Math",
    "include": ["today", "perCourse"]
})

# Bypass cache for fresh data
PlaycademySdk.timeback.user.xp.fetch({
    "force": true
})

PlaycademySdk.timeback.user.highest_grade_mastered.fetch({
    "subject": "Math",
    "force": false
})

# Basic fetch (uses 5-second cache)
PlaycademySdk.timeback.user.highest_grade_mastered.fetch({
    "subject": "Math"
})

# Bypass cache for fresh data
PlaycademySdk.timeback.user.highest_grade_mastered.fetch({
    "subject": "Math",
    "force": true
})

# Minimal (most common)
var activity_metadata = {
    "activityId": "math-quiz-1",
    "grade": 3,
    "subject": "Math"
}
# Activity name auto-derived: "Math Quiz 1"

PlaycademySdk.timeback.start_activity(activity_metadata)

# With custom name override
var custom_activity = {
    "activityId": "multiplication-drill",
    "activityName": "Advanced Multiplication Drill",
    "grade": 4,
    "subject": "Math"
}

var result = PlaycademySdk.timeback.start_activity(custom_activity)
var run_id = result.get("runId", "")

# Resumable activity - pass a stable UUID across sessions so the
# dashboard correlates related runs (persist it however you like)
PlaycademySdk.timeback.start_activity(
    { "activityId": "level-1-quiz" },
    { "runId": "123e4567-e89b-42d3-a456-426614174000" }
)

# Disable the periodic heartbeat interval (final flushes still run)
PlaycademySdk.timeback.start_activity(
    activity_metadata,
    { "heartbeatIntervalMs": 2147483647 }
)

# Stop paused heartbeats after 5 minutes of hidden/idle auto-pause
PlaycademySdk.timeback.start_activity(
    activity_metadata,
    { "pausedHeartbeatTimeoutMs": 300000 }
)

# Auto-calculate XP based on score
var score_data = {
    "correctQuestions": 8,
    "totalQuestions": 10
}

PlaycademySdk.timeback.end_activity(score_data)

# Report mastery (e.g., unit completed)
var score_with_mastery = {
    "correctQuestions": 8,
    "totalQuestions": 10,
    "masteredUnits": 1  # Student mastered 1 unit
}

PlaycademySdk.timeback.end_activity(score_with_mastery)

# Override XP calculation
var score_with_custom_xp = {
    "correctQuestions": 8,
    "totalQuestions": 10,
    "xpAwarded": 15  # Award exactly 15 XP
}

PlaycademySdk.timeback.end_activity(score_with_custom_xp)

PlaycademySdk.timeback.start_activity({
    "activityId": "speed-math-1",
    "grade": 4,
    "subject": "Math"
})

# Student attempts a problem...

func _on_answer_submitted(is_correct: bool):
    if not is_correct:
        # Pause timer during feedback
        PlaycademySdk.timeback.pause_activity()

        # Show correct answer or explanation
        show_correct_answer()
        await get_tree().create_timer(3.0).timeout

        # Resume timer when they continue
        PlaycademySdk.timeback.resume_activity()

# End activity (only active time counted)
PlaycademySdk.timeback.end_activity({
    "correctQuestions": 40,
    "totalQuestions": 50
})

# After pausing
PlaycademySdk.timeback.pause_activity()

# ... show feedback ...

# Resume when ready
PlaycademySdk.timeback.resume_activity()

func _ready():
    # Activity signals
    PlaycademySdk.timeback.end_activity_succeeded.connect(_on_end_activity_succeeded)
    PlaycademySdk.timeback.end_activity_failed.connect(_on_end_activity_failed)
    PlaycademySdk.timeback.pause_activity_failed.connect(_on_pause_activity_failed)
    PlaycademySdk.timeback.resume_activity_failed.connect(_on_resume_activity_failed)

    # User fetch signals
    PlaycademySdk.timeback.user_fetch_succeeded.connect(_on_user_fetch_succeeded)
    PlaycademySdk.timeback.user_fetch_failed.connect(_on_user_fetch_failed)

    # XP fetch signals
    PlaycademySdk.timeback.xp_fetch_succeeded.connect(_on_xp_fetch_succeeded)
    PlaycademySdk.timeback.xp_fetch_failed.connect(_on_xp_fetch_failed)

    # Highest grade mastered fetch signals
    PlaycademySdk.timeback.highest_grade_mastered_fetch_succeeded.connect(_on_hgm_fetch_succeeded)
    PlaycademySdk.timeback.highest_grade_mastered_fetch_failed.connect(_on_hgm_fetch_failed)

# Handle activity success
func _on_end_activity_succeeded(response):
    print("Activity ended! XP awarded:", response.xpAwarded)

# Handle activity failures
func _on_end_activity_failed(error: String):
    printerr("Failed to end activity:", error)

func _on_pause_activity_failed(error: String):
    printerr("Failed to pause activity:", error)

func _on_resume_activity_failed(error: String):
    printerr("Failed to resume activity:", error)

# Handle user fetch
func _on_user_fetch_succeeded(user_data: Dictionary):
    print("User data refreshed:", user_data)

func _on_user_fetch_failed(error: String):
    printerr("Failed to fetch user data:", error)

# Handle XP fetch
func _on_xp_fetch_succeeded(xp_data: Dictionary):
    print("Total XP:", xp_data.get("totalXp", 0))
    if xp_data.has("todayXp"):
        print("Today's XP:", xp_data.todayXp)

func _on_xp_fetch_failed(error: String):
    printerr("Failed to fetch XP data:", error)

# Handle highest grade mastered fetch
func _on_hgm_fetch_succeeded(data: Dictionary):
    var highest_grade_mastered = data.get("highestGradeMastered", null)
    if highest_grade_mastered == null:
        print("No mastered grade yet for ", data.get("subject", ""))
    else:
        print("Highest grade mastered:", highest_grade_mastered)

func _on_hgm_fetch_failed(error: String):
    printerr("Failed to fetch highest grade mastered:", error)

func _ready():
    PlaycademySdk.backend.request_succeeded.connect(_on_backend_succeeded)
    PlaycademySdk.backend.request_failed.connect(_on_backend_failed)

func _on_backend_succeeded(response: Dictionary):
    print("Backend response:", response)

    # Access response data
    if response.has("message"):
        print("Message:", response.message)

func _on_backend_failed(error: String):
    printerr("Backend request failed:", error)