kriss/garmin-padel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
48f7d5c7dc1697896bb49b14a9cd7cdaa5f92bfb
garmin-padel/docs/superpowers/plans/2026-07-02-padel-scoring.md
Christophe Vila cad84029fd chore: initial padel scaffold + design docs 
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-04 09:58:02 +02:00

1017 lines
33 KiB
Markdown
Raw Blame History

# Padel Scoring App Implementation Plan
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
**Goal:** Turn the Connect IQ scaffold into a padel score tracker: a top-down court with a yellow serve ball, sets/games on the left, points on the right, heart rate on top, time on bottom, driven by swipe/tap gestures.
**Architecture:** A UI-free scoring engine (`PadelMatch`) holds all match state and rules and is fully unit-tested. UI classes (`CourtRenderer`, `HeartRateProvider`, the `View`, the `Delegate`) read from the engine and are verified in the simulator. Rules live in a `RulesConfig` object so a future settings screen can drive them.
**Tech Stack:** Monkey C, Connect IQ SDK 9.2.0, product `venu445mm` (Venu 4, 45mm), Toybox `WatchUi`/`Graphics`/`Sensor`/`UserProfile`/`Test`.
---
## Reference: full spec
Design spec lives at `docs/superpowers/specs/2026-07-02-padel-scoring-design.md`. Read it before starting.
## File structure
- `source/RulesConfig.mc` — rules struct + v1 defaults (golden point, best-of-3, tiebreak at 6-6).
- `source/PadelMatch.mc` — the scoring engine (no UI imports). Module-level `US`/`THEM` and quadrant enum live here.
- `source/PadelMatchTest.mc` — unit tests + plain helper functions for the engine.
- `source/CourtRenderer.mc` — draws the court + yellow serve ball against a `Dc`.
- `source/HeartRateProvider.mc` — wraps the HR sensor + zone lookup.
- `source/garmin-padelView.mc` — draws the whole screen in `onUpdate`; 1s timer for the clock.
- `source/garmin-padelDelegate.mc` — maps swipes/taps to the engine.
- `source/garmin-padelApp.mc` — owns the engine/rules/HR, wires view+delegate, enables sensors.
- `source/garmin-padelMenuDelegate.mc` — **deleted** (scaffold menu not used).
- `resources/strings/strings.xml` — team labels + match-end text.
- `manifest.xml` — regenerated to add `Sensor` + `UserProfile` permissions.
## Conventions used throughout
- Teams: module constants `US = 0`, `THEM = 1`.
- Quadrants: module enum `QUAD_BOTTOM_RIGHT, QUAD_BOTTOM_LEFT, QUAD_UPPER_LEFT, QUAD_UPPER_RIGHT` (values 0..3).
- Your team is the bottom half of the court; opponents the top.
---
## Task 0: Prerequisites — env vars, git, gitignore
**Files:**
- Create: `.gitignore`
- [ ] **Step 1: Set SDK env vars (run in every shell you use for this plan)**
```bash
export SDK="$HOME/Library/Application Support/Garmin/ConnectIQ/Sdks/connectiq-sdk-mac-9.2.0-2026-06-09-92a1605b2"
export KEY="$HOME/Downloads/developer_key"
export DEVICE=venu445mm
```
Verify: `"$SDK/bin/monkeyc" --version` prints a version string.
- [ ] **Step 2: Create `.gitignore`**
```
bin/
*.prg
```
- [ ] **Step 3: Initialize git and commit the current scaffold**
```bash
cd /Users/kriss/Dev/scm/scm.vilanet.fr/kriss/garmin-padel
git init
git add -A
git commit -m "chore: initial padel scaffold + design docs"
```
Expected: a commit is created (the `bin/` output is excluded).
---
## Task 1: RulesConfig
**Files:**
- Create: `source/RulesConfig.mc`
- [ ] **Step 1: Write `RulesConfig.mc`**
```monkeyc
import Toybox.Lang;
// Configurable padel rules. v1 uses the defaults below; a future settings
// screen will mutate an instance of this class — the engine reads it as-is.
class RulesConfig {
public var goldenPoint as Boolean; // true = sudden death at 40-40
public var gamesPerSet as Number; // games needed to take a set (before win-by-2)
public var setsToWin as Number; // sets needed to win the match
public var tiebreakEnabled as Boolean; // play a tiebreak at gamesPerSet-all
public var tiebreakTarget as Number; // points needed to win a tiebreak (before win-by-2)
public function initialize() {
goldenPoint = true;
gamesPerSet = 6;
setsToWin = 2;
tiebreakEnabled = true;
tiebreakTarget = 7;
}
}
```
- [ ] **Step 2: Commit**
```bash
git add source/RulesConfig.mc
git commit -m "feat: add RulesConfig with v1 defaults"
```
---
## Task 2: Engine test suite (test-first)
Write the complete unit-test suite for `PadelMatch` before the engine exists. It will fail to compile (no `PadelMatch`) — that is the expected failing state.
**Files:**
- Create: `source/PadelMatchTest.mc`
- [ ] **Step 1: Write `PadelMatchTest.mc`**
```monkeyc
import Toybox.Lang;
import Toybox.Test;
// ---- plain helpers (not annotated :test, so not run as cases) ----
function newMatch() as PadelMatch {
return new PadelMatch(new RulesConfig());
}
function newAdvantageMatch() as PadelMatch {
var r = new RulesConfig();
r.goldenPoint = false;
return new PadelMatch(r);
}
// Win one game for `team` under golden-point rules (4 straight points).
function winGameFor(m as PadelMatch, team as Number) as Void {
for (var i = 0; i < 4; i += 1) { m.pointTo(team); }
}
// ---- test cases ----
(:test) function testInitialState(logger as Logger) as Boolean {
var m = newMatch();
Test.assertEqualMessage(m.sets(US), 0, "sets US");
Test.assertEqualMessage(m.games(US), 0, "games US");
Test.assertEqualMessage(m.pointLabel(US), "0", "points US");
Test.assertEqualMessage(m.isMatchOver(), false, "not over");
Test.assertEqualMessage(m.servingQuadrant(), QUAD_BOTTOM_RIGHT, "US serves deuce");
return true;
}
(:test) function testPointLabelsProgress(logger as Logger) as Boolean {
var m = newMatch();
m.pointTo(US);
Test.assertEqualMessage(m.pointLabel(US), "15", "15");
m.pointTo(US);
Test.assertEqualMessage(m.pointLabel(US), "30", "30");
m.pointTo(US);
Test.assertEqualMessage(m.pointLabel(US), "40", "40");
return true;
}
(:test) function testGoldenGameWin(logger as Logger) as Boolean {
var m = newMatch();
winGameFor(m, US);
Test.assertEqualMessage(m.games(US), 1, "US won a game");
Test.assertEqualMessage(m.pointLabel(US), "0", "points reset");
return true;
}
(:test) function testAdvantageDeuceCycle(logger as Logger) as Boolean {
var m = newAdvantageMatch();
// 3-3 deuce
for (var i = 0; i < 3; i += 1) { m.pointTo(US); m.pointTo(THEM); }
Test.assertEqualMessage(m.pointLabel(US), "40", "deuce US 40");
m.pointTo(US);
Test.assertEqualMessage(m.pointLabel(US), "AD", "US advantage");
m.pointTo(THEM);
Test.assertEqualMessage(m.pointLabel(US), "40", "back to deuce");
m.pointTo(US); m.pointTo(US);
Test.assertEqualMessage(m.games(US), 1, "US won from advantage");
return true;
}
(:test) function testWinSetSixLove(logger as Logger) as Boolean {
var m = newMatch();
for (var g = 0; g < 6; g += 1) { winGameFor(m, US); }
Test.assertEqualMessage(m.sets(US), 1, "US won the set");
Test.assertEqualMessage(m.games(US), 0, "games reset");
return true;
}
(:test) function testTiebreakEntryAndWin(logger as Logger) as Boolean {
var m = newMatch();
for (var i = 0; i < 6; i += 1) { winGameFor(m, US); winGameFor(m, THEM); }
Test.assertEqualMessage(m.isInTiebreak(), true, "6-6 tiebreak");
Test.assertEqualMessage(m.games(US), 6, "games 6-6");
for (var p = 0; p < 7; p += 1) { m.pointTo(US); }
Test.assertEqualMessage(m.isInTiebreak(), false, "tiebreak done");
Test.assertEqualMessage(m.sets(US), 1, "US won the set via tiebreak");
return true;
}
(:test) function testServeSideParity(logger as Logger) as Boolean {
var m = newMatch(); // US serving
Test.assertEqualMessage(m.servingQuadrant(), QUAD_BOTTOM_RIGHT, "0 pts deuce");
m.pointTo(THEM); // 1 point played
Test.assertEqualMessage(m.servingQuadrant(), QUAD_BOTTOM_LEFT, "1 pt ad");
m.pointTo(US); // 2 points played
Test.assertEqualMessage(m.servingQuadrant(), QUAD_BOTTOM_RIGHT, "2 pts deuce");
return true;
}
(:test) function testServerAlternation(logger as Logger) as Boolean {
var m = newMatch();
winGameFor(m, US); // serve passes to THEM
Test.assertEqualMessage(m.servingQuadrant(), QUAD_UPPER_LEFT, "THEM serves deuce");
return true;
}
(:test) function testTiebreakServing(logger as Logger) as Boolean {
var m = newMatch();
for (var i = 0; i < 6; i += 1) { winGameFor(m, US); winGameFor(m, THEM); }
// 12 games played, start server US -> US serves first in tiebreak
Test.assertEqualMessage(m.servingQuadrant(), QUAD_BOTTOM_RIGHT, "P0 US deuce");
m.pointTo(US);
Test.assertEqualMessage(m.servingQuadrant(), QUAD_UPPER_RIGHT, "P1 THEM ad");
m.pointTo(US);
Test.assertEqualMessage(m.servingQuadrant(), QUAD_UPPER_LEFT, "P2 THEM deuce");
m.pointTo(US);
Test.assertEqualMessage(m.servingQuadrant(), QUAD_BOTTOM_LEFT, "P3 US ad");
return true;
}
(:test) function testUndoAcrossGame(logger as Logger) as Boolean {
var m = newMatch();
winGameFor(m, US); // US 1 game, points 0-0, THEM to serve
m.pointTo(THEM); // THEM has 15
m.undo(); // back to just-after-game
Test.assertEqualMessage(m.pointLabel(THEM), "0", "point undone");
m.undo(); // undo the game-winning point
Test.assertEqualMessage(m.games(US), 0, "game undone");
Test.assertEqualMessage(m.pointLabel(US), "40", "back to 40");
return true;
}
(:test) function testUndoAtStartIsNoop(logger as Logger) as Boolean {
var m = newMatch();
m.undo();
Test.assertEqualMessage(m.games(US), 0, "still zero");
return true;
}
(:test) function testStartingServerToggle(logger as Logger) as Boolean {
var m = newMatch();
m.toggleStartingServer();
Test.assertEqualMessage(m.servingQuadrant(), QUAD_UPPER_LEFT, "THEM serves first");
m.pointTo(US); // match started; toggle now locked
m.toggleStartingServer();
Test.assertEqualMessage(m.canSetServer(), false, "server locked after first point");
return true;
}
(:test) function testMatchOver(logger as Logger) as Boolean {
var m = newMatch();
for (var s = 0; s < 2; s += 1) {
for (var g = 0; g < 6; g += 1) { winGameFor(m, US); }
}
Test.assertEqualMessage(m.isMatchOver(), true, "match over");
Test.assertEqualMessage(m.winner(), US, "US wins");
var setsBefore = m.sets(US);
m.pointTo(US); // ignored after match over
Test.assertEqualMessage(m.sets(US), setsBefore, "no scoring after match");
return true;
}
```
- [ ] **Step 2: Build the test binary and confirm it FAILS to compile**
```bash
"$SDK/bin/monkeyc" -f monkey.jungle -o bin/test.prg -y "$KEY" -d "$DEVICE" --unit-test
```
Expected: FAIL — errors like `Undefined symbol :PadelMatch` / `US` / `QUAD_BOTTOM_RIGHT`. This confirms the tests reference the not-yet-written engine.
- [ ] **Step 3: Commit the tests**
```bash
git add source/PadelMatchTest.mc
git commit -m "test: add PadelMatch engine test suite (failing)"
```
---
## Task 3: PadelMatch engine
Implement the engine so every test in Task 2 passes.
**Files:**
- Create: `source/PadelMatch.mc`
- [ ] **Step 1: Write `PadelMatch.mc`**
```monkeyc
import Toybox.Lang;
// Teams
const US = 0;
const THEM = 1;
// Court quadrants (your team = bottom half)
enum {
QUAD_BOTTOM_RIGHT, // US, deuce (right)
QUAD_BOTTOM_LEFT, // US, ad (left)
QUAD_UPPER_LEFT, // THEM, deuce (their right -> screen left)
QUAD_UPPER_RIGHT // THEM, ad (their left -> screen right)
}
class PadelMatch {
private var _rules as RulesConfig;
private var _points as Array<Number>; // raw point count per team in the current game
private var _games as Array<Number>; // games won in the current set
private var _sets as Array<Number>; // sets won in the match
private var _server as Number; // team serving the current game
private var _inTiebreak as Boolean;
private var _tbPoints as Array<Number>;
private var _tbFirstServer as Number; // team that served the tiebreak's first point
private var _matchOver as Boolean;
private var _winner as Number; // US / THEM / -1
private var _history as Array<Dictionary>;
private const POINT_LABELS = ["0", "15", "30", "40"];
public function initialize(rules as RulesConfig) {
_rules = rules;
_points = [0, 0];
_games = [0, 0];
_sets = [0, 0];
_server = US;
_inTiebreak = false;
_tbPoints = [0, 0];
_tbFirstServer = US;
_matchOver = false;
_winner = -1;
_history = [];
}
// ---- public API ----
public function pointTo(team as Number) as Void {
if (_matchOver) { return; }
_pushHistory();
if (_inTiebreak) {
_tbPoints[team] += 1;
_resolveTiebreak(team);
} else {
_points[team] += 1;
_resolveGame(team);
}
}
public function undo() as Void {
var n = _history.size();
if (n == 0) { return; }
var s = _history[n - 1];
_history = _history.slice(0, n - 1);
_points = s["points"] as Array<Number>;
_games = s["games"] as Array<Number>;
_sets = s["sets"] as Array<Number>;
_server = s["server"] as Number;
_inTiebreak = s["inTiebreak"] as Boolean;
_tbPoints = s["tbPoints"] as Array<Number>;
_tbFirstServer = s["tbFirstServer"] as Number;
_matchOver = s["matchOver"] as Boolean;
_winner = s["winner"] as Number;
}
public function canSetServer() as Boolean {
return _history.size() == 0 && !_matchOver;
}
public function toggleStartingServer() as Void {
if (canSetServer()) { _server = 1 - _server; }
}
public function servingQuadrant() as Number {
var team;
var pointsPlayed;
if (_inTiebreak) {
pointsPlayed = _tbPoints[0] + _tbPoints[1];
team = _tiebreakServer(pointsPlayed);
} else {
pointsPlayed = _points[0] + _points[1];
team = _server;
}
var isDeuce = (pointsPlayed % 2) == 0;
return _quadrantFor(team, isDeuce);
}
public function pointLabel(team as Number) as String {
if (_inTiebreak) { return _tbPoints[team].toString(); }
var a = _points[team];
var b = _points[1 - team];
if (!_rules.goldenPoint && a == 4 && b == 3) { return "AD"; }
if (a >= 4) { return "40"; } // safety; game normally ends before display
return POINT_LABELS[a];
}
public function games(team as Number) as Number { return _games[team]; }
public function sets(team as Number) as Number { return _sets[team]; }
public function server() as Number { return _server; }
public function isInTiebreak() as Boolean { return _inTiebreak; }
public function isMatchOver() as Boolean { return _matchOver; }
public function winner() as Number { return _winner; }
public function tiebreakPoints(team as Number) as Number { return _tbPoints[team]; }
// ---- internals ----
private function _resolveGame(team as Number) as Void {
var other = 1 - team;
var a = _points[team];
var b = _points[other];
if (_rules.goldenPoint) {
if (a >= 4) { _winGame(team); }
} else {
if (a >= 4 && (a - b) >= 2) { _winGame(team); }
else if (a >= 4 && b >= 4) { _points[team] = 3; _points[other] = 3; } // both past 40 -> deuce
}
}
private function _winGame(team as Number) as Void {
_games[team] += 1;
_points = [0, 0];
_server = 1 - _server;
_resolveSet(team);
}
private function _resolveSet(team as Number) as Void {
var other = 1 - team;
var a = _games[team];
var b = _games[other];
if (a >= _rules.gamesPerSet && (a - b) >= 2) {
_winSet(team);
} else if (_rules.tiebreakEnabled && a == _rules.gamesPerSet && b == _rules.gamesPerSet) {
_inTiebreak = true;
_tbPoints = [0, 0];
_tbFirstServer = _server; // team due to serve after the 12th game
}
}
private function _resolveTiebreak(team as Number) as Void {
var other = 1 - team;
var a = _tbPoints[team];
var b = _tbPoints[other];
if (a >= _rules.tiebreakTarget && (a - b) >= 2) {
_games[team] += 1; // e.g. 7-6
_winSet(team);
}
}
private function _winSet(team as Number) as Void {
_sets[team] += 1;
_games = [0, 0];
if (_inTiebreak) {
_inTiebreak = false;
_server = 1 - _tbFirstServer; // tiebreak receiver serves first next set
}
_resolveMatch(team);
}
private function _resolveMatch(team as Number) as Void {
if (_sets[team] >= _rules.setsToWin) {
_matchOver = true;
_winner = team;
}
}
private function _tiebreakServer(pointsPlayed as Number) as Number {
var offset = ((pointsPlayed + 1) / 2) % 2; // integer division
return (offset == 0) ? _tbFirstServer : (1 - _tbFirstServer);
}
private function _quadrantFor(team as Number, isDeuce as Boolean) as Number {
if (team == US) {
return isDeuce ? QUAD_BOTTOM_RIGHT : QUAD_BOTTOM_LEFT;
}
return isDeuce ? QUAD_UPPER_LEFT : QUAD_UPPER_RIGHT;
}
private function _pushHistory() as Void {
_history.add({
"points" => [_points[0], _points[1]],
"games" => [_games[0], _games[1]],
"sets" => [_sets[0], _sets[1]],
"server" => _server,
"inTiebreak" => _inTiebreak,
"tbPoints" => [_tbPoints[0], _tbPoints[1]],
"tbFirstServer" => _tbFirstServer,
"matchOver" => _matchOver,
"winner" => _winner
});
}
}
```
- [ ] **Step 2: Build the test binary (should now compile)**
```bash
"$SDK/bin/monkeyc" -f monkey.jungle -o bin/test.prg -y "$KEY" -d "$DEVICE" --unit-test
```
Expected: `BUILD SUCCESSFUL`.
- [ ] **Step 3: Run the unit tests in the simulator**
```bash
"$SDK/bin/connectiq" &
"$SDK/bin/monkeydo" bin/test.prg "$DEVICE" -t
```
Expected: the console lists each `test...` case as `PASSED` and ends with a summary reporting `PASSED` for all cases and `FAILED` count 0. If any case fails, fix the engine (not the tests) and re-run.
- [ ] **Step 4: Commit**
```bash
git add source/PadelMatch.mc
git commit -m "feat: implement PadelMatch scoring engine (tests pass)"
```
---
## Task 4: CourtRenderer
Pure drawing. Verified in the simulator (Task 8), but written and compiled now.
**Files:**
- Create: `source/CourtRenderer.mc`
- [ ] **Step 1: Write `CourtRenderer.mc`**
```monkeyc
import Toybox.Lang;
import Toybox.Graphics;
// Draws a top-down padel court centered at (cx, cy) and a yellow serve ball
// in the given quadrant. Half-width HW and half-height HH keep it inside the
// central band of the round screen.
class CourtRenderer {
private const HW = 60; // half court width (px)
private const HH = 78; // half court height (px)
private const BALL_R = 6;
public function draw(dc as Graphics.Dc, cx as Number, cy as Number,
quadrant as Number, showBall as Boolean) as Void {
var left = cx - HW;
var top = cy - HH;
dc.setColor(Graphics.COLOR_WHITE, Graphics.COLOR_TRANSPARENT);
dc.setPenWidth(2);
dc.drawRectangle(left, top, 2 * HW, 2 * HH); // outer court
dc.drawLine(cx, top, cx, cy + HH); // center service line
dc.setPenWidth(1);
dc.drawLine(left, cy - HH / 2, left + 2 * HW, cy - HH / 2); // upper service line
dc.drawLine(left, cy + HH / 2, left + 2 * HW, cy + HH / 2); // lower service line
dc.setPenWidth(3);
dc.drawLine(left, cy, left + 2 * HW, cy); // net
if (showBall) {
var pos = _ballPos(quadrant, cx, cy);
dc.setColor(Graphics.COLOR_YELLOW, Graphics.COLOR_TRANSPARENT);
dc.fillCircle(pos[0], pos[1], BALL_R);
}
}
private function _ballPos(quadrant as Number, cx as Number, cy as Number) as Array<Number> {
var dx = HW / 2;
var dy = HH / 2;
if (quadrant == QUAD_BOTTOM_RIGHT) { return [cx + dx, cy + dy]; }
if (quadrant == QUAD_BOTTOM_LEFT) { return [cx - dx, cy + dy]; }
if (quadrant == QUAD_UPPER_LEFT) { return [cx - dx, cy - dy]; }
return [cx + dx, cy - dy]; // QUAD_UPPER_RIGHT
}
}
```
- [ ] **Step 2: Commit**
```bash
git add source/CourtRenderer.mc
git commit -m "feat: add CourtRenderer (court + yellow serve ball)"
```
---
## Task 5: HeartRateProvider
**Files:**
- Create: `source/HeartRateProvider.mc`
- [ ] **Step 1: Write `HeartRateProvider.mc`**
```monkeyc
import Toybox.Lang;
import Toybox.Sensor;
import Toybox.UserProfile;
// Wraps the heart-rate sensor and maps the current bpm to a zone (1..5).
// Returns null bpm when no reading is available (e.g. simulator without data
// simulation), so the view can show a placeholder.
class HeartRateProvider {
private var _hr as Number?;
private var _zones as Array<Number>?;
public function initialize() {
_hr = null;
_zones = null;
}
public function onStart() as Void {
Sensor.setEnabledSensors([Sensor.SENSOR_HEARTRATE]);
Sensor.enableSensorEvents(method(:onSensor));
_zones = UserProfile.getHeartRateZones(UserProfile.HR_ZONE_SPORT_GENERIC);
}
public function onStop() as Void {
Sensor.enableSensorEvents(null);
}
public function onSensor(info as Sensor.Info) as Void {
_hr = info.heartRate;
}
public function getHeartRate() as Number? {
return _hr;
}
// Returns 1..5, or 0 if HR/zones unavailable.
public function getZone() as Number {
if (_hr == null || _zones == null) { return 0; }
var z = _zones as Array<Number>;
var hr = _hr as Number;
// _zones holds 6 boundaries: [z1lo, z2lo, z3lo, z4lo, z5lo, max]
for (var i = z.size() - 2; i >= 0; i -= 1) {
if (hr >= z[i]) { return i + 1 > 5 ? 5 : i + 1; }
}
return 1;
}
}
```
- [ ] **Step 2: Build a normal (non-test) binary to typecheck the new file**
```bash
"$SDK/bin/monkeyc" -f monkey.jungle -o bin/garmin-padel.prg -y "$KEY" -d "$DEVICE"
```
Expected: `BUILD SUCCESSFUL` (the app still uses the old scaffold view/delegate at this point; those are replaced next). If the build complains about `HR_ZONE_SPORT_GENERIC`, confirm the constant name against the API docs for SDK 9.2.0 and adjust.
- [ ] **Step 3: Commit**
```bash
git add source/HeartRateProvider.mc
git commit -m "feat: add HeartRateProvider (bpm + HR zone)"
```
---
## Task 6: App wiring — own the engine, rules, HR
Replace the scaffold app so it owns shared state and exposes it to the view/delegate.
**Files:**
- Modify: `source/garmin-padelApp.mc`
- [ ] **Step 1: Rewrite `garmin-padelApp.mc`**
```monkeyc
import Toybox.Application;
import Toybox.Lang;
import Toybox.WatchUi;
class garmin_padelApp extends Application.AppBase {
private var _rules as RulesConfig;
private var _match as PadelMatch;
private var _hr as HeartRateProvider;
public function initialize() {
AppBase.initialize();
_rules = new RulesConfig();
_match = new PadelMatch(_rules);
_hr = new HeartRateProvider();
}
public function onStart(state as Dictionary?) as Void {
_hr.onStart();
}
public function onStop(state as Dictionary?) as Void {
_hr.onStop();
}
public function getMatch() as PadelMatch { return _match; }
public function getHeartRate() as HeartRateProvider { return _hr; }
public function resetMatch() as Void {
_match = new PadelMatch(_rules);
}
public function getInitialView() as [Views] or [Views, InputDelegates] {
return [ new garmin_padelView(), new garmin_padelDelegate() ];
}
}
function getApp() as garmin_padelApp {
return Application.getApp() as garmin_padelApp;
}
```
- [ ] **Step 2: Commit**
```bash
git add source/garmin-padelApp.mc
git commit -m "feat: app owns match/rules/HR and exposes accessors"
```
---
## Task 7: The View — draw the whole screen
**Files:**
- Modify: `source/garmin-padelView.mc`
- [ ] **Step 1: Rewrite `garmin-padelView.mc`**
```monkeyc
import Toybox.Lang;
import Toybox.Graphics;
import Toybox.WatchUi;
import Toybox.System;
import Toybox.Timer;
class garmin_padelView extends WatchUi.View {
private const ACCENT = 0x00E0A0; // padel green (sets/games)
private const LABEL_COLOR = 0x808080; // muted grey (S/G/pts labels)
private var _court as CourtRenderer;
private var _timer as Timer.Timer;
public function initialize() {
View.initialize();
_court = new CourtRenderer();
_timer = new Timer.Timer();
}
public function onShow() as Void {
_timer.start(method(:onTick), 1000, true); // refresh clock + HR every second
}
public function onHide() as Void {
_timer.stop();
}
public function onTick() as Void {
WatchUi.requestUpdate();
}
public function onUpdate(dc as Graphics.Dc) as Void {
var m = getApp().getMatch();
var w = dc.getWidth();
var h = dc.getHeight();
var cx = w / 2;
var cy = h / 2;
dc.setColor(Graphics.COLOR_WHITE, Graphics.COLOR_BLACK);
dc.clear();
_court.draw(dc, cx, cy, m.servingQuadrant(), !m.isMatchOver());
_drawLeftColumn(dc, m);
_drawRightColumn(dc, m, w);
_drawHeartRate(dc, cx, 40);
_drawTime(dc, cx, h - 44);
if (m.isMatchOver()) {
_drawWinner(dc, cx, cy, m);
}
}
// Left: S and G mini-columns, your team on top, opponents below.
private function _drawLeftColumn(dc as Graphics.Dc, m as PadelMatch) as Void {
var sX = 24;
var gX = 60;
var labelY = 150;
var usY = 178;
var themY = 206;
dc.setColor(LABEL_COLOR, Graphics.COLOR_TRANSPARENT);
dc.drawText(sX, labelY, Graphics.FONT_XTINY, "S", Graphics.TEXT_JUSTIFY_CENTER);
dc.drawText(gX, labelY, Graphics.FONT_XTINY, "G", Graphics.TEXT_JUSTIFY_CENTER);
dc.setColor(ACCENT, Graphics.COLOR_TRANSPARENT);
dc.drawText(sX, usY, Graphics.FONT_TINY, m.sets(US).toString(), Graphics.TEXT_JUSTIFY_CENTER);
dc.drawText(sX, themY, Graphics.FONT_TINY, m.sets(THEM).toString(), Graphics.TEXT_JUSTIFY_CENTER);
dc.drawText(gX, usY, Graphics.FONT_TINY, m.games(US).toString(), Graphics.TEXT_JUSTIFY_CENTER);
dc.drawText(gX, themY, Graphics.FONT_TINY, m.games(THEM).toString(), Graphics.TEXT_JUSTIFY_CENTER);
}
// Right: pts column, your team on top, opponents below.
private function _drawRightColumn(dc as Graphics.Dc, m as PadelMatch, w as Number) as Void {
var pX = w - 42;
var labelY = 150;
var usY = 178;
var themY = 206;
dc.setColor(LABEL_COLOR, Graphics.COLOR_TRANSPARENT);
dc.drawText(pX, labelY, Graphics.FONT_XTINY, "pts", Graphics.TEXT_JUSTIFY_CENTER);
dc.setColor(Graphics.COLOR_WHITE, Graphics.COLOR_TRANSPARENT);
dc.drawText(pX, usY, Graphics.FONT_TINY, m.pointLabel(US), Graphics.TEXT_JUSTIFY_CENTER);
dc.drawText(pX, themY, Graphics.FONT_TINY, m.pointLabel(THEM), Graphics.TEXT_JUSTIFY_CENTER);
}
private function _drawHeartRate(dc as Graphics.Dc, cx as Number, y as Number) as Void {
var hr = getApp().getHeartRate();
var bpm = hr.getHeartRate();
var text = (bpm == null) ? "-- bpm" : bpm.toString() + " bpm";
dc.setColor(Graphics.COLOR_RED, Graphics.COLOR_TRANSPARENT);
dc.drawText(cx, y, Graphics.FONT_TINY, text, Graphics.TEXT_JUSTIFY_CENTER);
_drawZoneBar(dc, cx, y + 26, hr.getZone());
}
// 5-segment bar; segments up to the current zone are filled.
private function _drawZoneBar(dc as Graphics.Dc, cx as Number, y as Number, zone as Number) as Void {
var segW = 12;
var segH = 6;
var gap = 3;
var totalW = 5 * segW + 4 * gap;
var x = cx - totalW / 2;
for (var i = 1; i <= 5; i += 1) {
if (i <= zone) {
dc.setColor(ACCENT, Graphics.COLOR_TRANSPARENT);
dc.fillRectangle(x, y, segW, segH);
} else {
dc.setColor(LABEL_COLOR, Graphics.COLOR_TRANSPARENT);
dc.drawRectangle(x, y, segW, segH);
}
x += segW + gap;
}
}
private function _drawTime(dc as Graphics.Dc, cx as Number, y as Number) as Void {
var now = System.getClockTime();
var text = now.hour.format("%02d") + ":" + now.min.format("%02d");
dc.setColor(Graphics.COLOR_WHITE, Graphics.COLOR_TRANSPARENT);
dc.drawText(cx, y, Graphics.FONT_SMALL, text, Graphics.TEXT_JUSTIFY_CENTER);
}
private function _drawWinner(dc as Graphics.Dc, cx as Number, cy as Number, m as PadelMatch) as Void {
var text = (m.winner() == US) ? "You win!" : "They win";
dc.setColor(ACCENT, Graphics.COLOR_BLACK);
dc.fillRectangle(cx - 70, cy - 18, 140, 36);
dc.setColor(Graphics.COLOR_BLACK, Graphics.COLOR_TRANSPARENT);
dc.drawText(cx, cy - 14, Graphics.FONT_SMALL, text, Graphics.TEXT_JUSTIFY_CENTER);
}
}
```
- [ ] **Step 2: Commit**
```bash
git add source/garmin-padelView.mc
git commit -m "feat: draw full padel screen (score, court, HR, time)"
```
---
## Task 8: The Delegate — gestures
**Files:**
- Modify: `source/garmin-padelDelegate.mc`
- Delete: `source/garmin-padelMenuDelegate.mc`
- [ ] **Step 1: Rewrite `garmin-padelDelegate.mc`**
```monkeyc
import Toybox.Lang;
import Toybox.WatchUi;
class garmin_padelDelegate extends WatchUi.BehaviorDelegate {
public function initialize() {
BehaviorDelegate.initialize();
}
public function onSwipe(swipeEvent as WatchUi.SwipeEvent) as Boolean {
var m = getApp().getMatch();
var dir = swipeEvent.getDirection();
if (dir == WatchUi.SWIPE_UP) {
m.pointTo(US);
} else if (dir == WatchUi.SWIPE_DOWN) {
m.pointTo(THEM);
} else if (dir == WatchUi.SWIPE_LEFT) {
m.undo();
} else {
return false;
}
WatchUi.requestUpdate();
return true;
}
public function onTap(clickEvent as WatchUi.ClickEvent) as Boolean {
var m = getApp().getMatch();
if (m.isMatchOver()) {
getApp().resetMatch();
} else if (m.canSetServer()) {
m.toggleStartingServer();
} else {
return false;
}
WatchUi.requestUpdate();
return true;
}
}
```
- [ ] **Step 2: Delete the unused menu delegate**
```bash
git rm source/garmin-padelMenuDelegate.mc
```
- [ ] **Step 3: Commit**
```bash
git add source/garmin-padelDelegate.mc
git commit -m "feat: swipe to score/undo, tap to set server / new match"
```
---
## Task 9: Permissions, strings, full build & simulator verification
**Files:**
- Modify: `manifest.xml` (via palette command — do not hand-edit)
- Modify: `resources/strings/strings.xml`
- [ ] **Step 1: Add Sensor + UserProfile permissions**
In VS Code run `Monkey C: Edit Permissions` and enable **Sensor** and **UserProfile**. This regenerates `manifest.xml`.
Verify from the CLI:
```bash
grep -E "Sensor|UserProfile" manifest.xml
```
Expected: two `<iq:uses-permission id="Sensor"/>` / `<iq:uses-permission id="UserProfile"/>` lines.
- [ ] **Step 2: Update strings (remove scaffold menu strings, keep app name)**
```xml
<strings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="https://developer.garmin.com/downloads/connect-iq/resources.xsd">
<string id="AppName">Padel</string>
</strings>
```
(The old `prompt`/`menu_label_*` strings are removed; nothing references them now that the menu is gone.)
- [ ] **Step 3: Build the release binary**
```bash
"$SDK/bin/monkeyc" -f monkey.jungle -o bin/garmin-padel.prg -y "$KEY" -d "$DEVICE"
```
Expected: `BUILD SUCCESSFUL`.
- [ ] **Step 4: Run in the simulator and verify behavior**
```bash
"$SDK/bin/connectiq" &
"$SDK/bin/monkeydo" bin/garmin-padel.prg "$DEVICE"
```
Then in the simulator, verify:
- Court is centered with a yellow ball at **bottom-right** (US serves, deuce).
- **Tap** → ball jumps to **upper-left**; tap again → back to bottom-right.
- **Swipe up** → your `pts` go `0→15→30→40`; after the 4th point (golden) your `G` increments and points reset; the ball moves to the opponents' half.
- **Swipe down** scores for opponents; **swipe left** undoes the last point.
- Top shows `-- bpm` (or a value if HR data simulation is enabled via the simulator's **Settings → data-simulation / sensors**) with the zone bar; bottom shows the current time.
- Win a full match → the winner banner appears; **tap** starts a fresh match at server-positioning.
- [ ] **Step 5: Re-run unit tests to confirm no regressions**
```bash
"$SDK/bin/monkeyc" -f monkey.jungle -o bin/test.prg -y "$KEY" -d "$DEVICE" --unit-test
"$SDK/bin/monkeydo" bin/test.prg "$DEVICE" -t
```
Expected: all cases `PASSED`, 0 failures.
- [ ] **Step 6: Commit**
```bash
git add manifest.xml resources/strings/strings.xml
git commit -m "feat: add Sensor/UserProfile permissions, tidy strings"
```
---
## Done
The scaffold is now a working padel score tracker. Deferred to future iterations (see spec §8): the settings screen (driving `RulesConfig` and the top/bottom info slots), match history, resume-after-close persistence, and recorded Garmin activity.
Reference in New Issue View Git Blame Copy Permalink