summaryrefslogtreecommitdiff
path: root/chapter31/docs/examples
diff options
context:
space:
mode:
authorCliff Click <cliffc@acm.org>2026-11-14 12:41:16 -0800
committerCliff Click <cliffc@acm.org>2026-11-14 12:41:16 -0800
commit3d0f3f38d9d8345b6508b3289dc94b0500c53d9e (patch)
tree1b769cdc4e415fad5c1b18afa23ffc6fe56db18a /chapter31/docs/examples
parentafcf96444366fb4b7c83f938763013cbc360aade (diff)
downloadSimple-3d0f3f38d9d8345b6508b3289dc94b0500c53d9e.tar.gz
Simple-3d0f3f38d9d8345b6508b3289dc94b0500c53d9e.zip
Breakout, Clock demos
Math lib with simple constants raw bit converters TypeConAry unified Big Formatting change Debug symbols for constant data IterPeeps was endlessly running asserts with much inlining RegAlloc rounds raised
Diffstat (limited to 'chapter31/docs/examples')
-rw-r--r--chapter31/docs/examples/Breakout.smp293
-rw-r--r--chapter31/docs/examples/Clock.smp74
-rw-r--r--chapter31/docs/examples/Dijkstra.smp12
-rw-r--r--chapter31/docs/examples/Graphics.smp4
-rw-r--r--chapter31/docs/examples/README.md24
-rw-r--r--chapter31/docs/examples/TicTacToe.smp54
-rw-r--r--chapter31/docs/examples/TicTacToeGraphical.smp82
7 files changed, 430 insertions, 113 deletions
diff --git a/chapter31/docs/examples/Breakout.smp b/chapter31/docs/examples/Breakout.smp
new file mode 100644
index 00000000..e5757b45
--- /dev/null
+++ b/chapter31/docs/examples/Breakout.smp
@@ -0,0 +1,293 @@
+// Clear 24 x 8 bricks. Arrows or mouse move; Space/click serves; P pauses;
+// R restarts; Q/Escape exits. Any argument runs ten frames as a smoke test.
+int WIDTH = 1008, HEIGHT = 760, COLS = 24, ROWS = 8;
+int LEFT = 24, RIGHT = 984, TOP = 84, BOTTOM = 718;
+int BRICK_TOP = 152, BRICK_DX = 40, BRICK_DY = 22, BRICK_W = 36, BRICK_H = 18;
+int RADIUS = 5, PADDLE_HALF = 56, PADDLE_Y = 674;
+int READY = 0, PLAY = 1, WON = 2, LOST = 3;
+int KEY_LEFT = 263, KEY_RIGHT = 262; // MiniFB key codes; gfx.LEFT is a mouse button.
+i64 STEP_ms = 8, FRAME_ms = 16;
+u32 BACKGROUND = 0x0b1220, WHITE = 0xeef7ff, MUTED = 0x8aabc4, CYAN = 0x4ce0ef;
+val COLORS = new u32[~]{0xff5268,0xff8050,0xffb548,0xffdb58,
+ 0x9bdd58,0x45d8b0,0x49b9f5,0x8d94ff};
+val DIGITS = new u8[~][~]{"0","1","2","3","4","5","6","7","8","9"};
+
+struct Game {
+ u8[] bricks = new u8[COLS*ROWS]{int i -> 1;};
+ int score = 0, remaining = COLS*ROWS, lives = 3, depth = 1, phase = READY;
+ bool boosted = false, backWall = false, paused = false;
+ f64 x = 504.0, y = 663.0, dx = 0.4, dy = -0.916515138991168;
+ int soundDepth = 1;
+
+ // Serve the ball; give it a nominal direction and speed
+ val _serve = { ->
+ if( phase == READY && !paused ) {
+ phase = PLAY;
+ dx = 0.4;
+ dy = -_sqrt(1.0-dx*dx);
+ }
+ return 0;
+ };
+
+ // Several sound things might happen in this event, pick one
+ int sound = 0; // Increasing priority: wall, paddle, brick, boost, miss, win.
+ val _cue = { int snd -> if( snd > sound ) sound = snd; };
+
+ // Ball speed is a fraction of deepest brick hit, plus backwall boost
+ f64 speed;
+ val _speed = { -> speed = (320.0+35.0*(depth-1))*(boosted ? 1.65 : 1.0); };
+
+ // Clamp paddle to wall sides
+ f64 paddle;
+ val _paddle = { f64 x ->
+ paddle = x < LEFT +PADDLE_HALF ? LEFT +PADDLE_HALF :
+ x > RIGHT-PADDLE_HALF ? RIGHT+PADDLE_HALF :
+ x;
+ };
+
+
+ // Hit the paddle
+ val _rebound = { ->
+ // Where along the paddle did you hit?
+ f64 offset = (x-paddle)/PADDLE_HALF;
+ if( offset < -1.0 ) offset = -1.0;
+ if( offset > 1.0 ) offset = 1.0;
+ dx = 0.88*offset;
+ // A near-center hit still drifts sideways instead of repeating forever.
+ if( -0.12 < dx < 0.12 ) dx = dx < 0.0 ? -0.12 : 0.12;
+ dy = -_sqrt(1.0-dx*dx); // Bounce upwards speed
+ y = PADDLE_Y-RADIUS; // Reset ball hit to top of paddle
+ backWall = false; // Did not hit back wall
+ _cue(2); // Paddle bounce sound
+ };
+
+ // Hit a brick?
+ val _brick = { int index, bool back ->
+ if( bricks[index] == 0 ) return 0; // No brick to hit!
+ bricks[index] = 0; // Clear brick
+ int row = ROWS-index/COLS; // Get brick row
+ score += row; // Score by row
+ remaining--; // Fewer bricks to iwn
+ if( row > depth ) depth = row; // Max depth seen
+ // Brick-hit sound
+ if( sound <= 3 ) { soundDepth = row; _cue(3); }
+ if( back && backWall && !boosted ) { boosted = true; _cue(4); }
+ if( remaining == 0 ) { phase = WON; _cue(6); }
+ _speed();
+ return 0;
+ };
+
+ // Reset for another round
+ val _reset = { ->
+ for( int i = 0; i < bricks#; i++ ) bricks[i] = 1;
+ score = 0;
+ remaining = COLS*ROWS;
+ lives = 3;
+ depth = 1;
+ phase = READY;
+ boosted = false;
+ backWall = false;
+ paused = false;
+ sound = 0;
+ paddle = 504.0;
+ x = paddle;
+ y = PADDLE_Y-RADIUS-6;
+ _speed();
+ };
+};
+
+// Fixed 8 ms simulation, split further to travel at most two pixels per step.
+// Even at maximum boosted speed a ball cannot tunnel through an 18 px brick.
+val _tick = { !Game g, int direction ->
+ if( g.paused || g.phase == WON || g.phase == LOST ) return 0;
+ g._paddle(g.paddle+direction*6.4);
+ if( g.phase == READY ) { g.x = g.paddle; g.y = PADDLE_Y-RADIUS-6; return 0; }
+ f64 seconds = 0.008;
+ while( seconds > 0.000000001 && g.phase == PLAY ) {
+ f64 dt = 2.0/g.speed;
+ if( dt > seconds ) dt = seconds;
+ seconds -= dt;
+ f64 oldX = g.x, oldY = g.y;
+ g.x += g.dx*g.speed*dt;
+ g.y += g.dy*g.speed*dt;
+ if( g.x < LEFT+RADIUS && g.dx < 0.0 ) {
+ g.x = 2.0*(LEFT+RADIUS)-g.x; g.dx = -g.dx; g._cue(1);
+ }
+ if( g.x > RIGHT-RADIUS && g.dx > 0.0 ) {
+ g.x = 2.0*(RIGHT-RADIUS)-g.x; g.dx = -g.dx; g._cue(1);
+ }
+ if( g.y < TOP+RADIUS && g.dy < 0.0 ) {
+ g.y = 2.0*(TOP+RADIUS)-g.y; g.dy = -g.dy;
+ g.backWall = true; g._cue(1);
+ }
+ if( g.dy > 0.0 && oldY <= PADDLE_Y-RADIUS && g.y >= PADDLE_Y-RADIUS &&
+ g.paddle-PADDLE_HALF-RADIUS <= g.x <= g.paddle+PADDLE_HALF+RADIUS ) g._rebound();
+ if( g.y > BOTTOM+RADIUS ) {
+ g.lives--;
+ g.phase = g.lives == 0 ? LOST : READY;
+ g.backWall = false;
+ g.depth = 1;
+ g.boosted = false;
+ g._speed();
+ g.x = g.paddle; g.y = PADDLE_Y-RADIUS-6;
+ g._cue(5);
+ break;
+ }
+ for( int i = 0; i < g.bricks#; i++ ) {
+ if( g.bricks[i] == 0 ) continue;
+ f64 left = LEFT+2+(i-i/COLS*COLS)*BRICK_DX-RADIUS;
+ f64 top = BRICK_TOP+(i/COLS)*BRICK_DY-RADIUS;
+ f64 right = left+BRICK_W+2*RADIUS, bottom = top+BRICK_H+2*RADIUS;
+ if( left < g.x < right && top < g.y < bottom ) {
+ bool back = false;
+ // Resolve the face crossed this step, using the previous center.
+ // Vertical faces win a simultaneous corner contact.
+ if( oldY <= top && g.dy > 0.0 ) {
+ g.y = top; g.dy = -g.dy; back = true;
+ } else if( oldY >= bottom && g.dy < 0.0 ) {
+ g.y = bottom; g.dy = -g.dy;
+ } else if( oldX <= left && g.dx > 0.0 ) {
+ g.x = left; g.dx = -g.dx;
+ } else if( oldX >= right && g.dx < 0.0 ) {
+ g.x = right; g.dx = -g.dx;
+ } else continue;
+ g._brick(i,back);
+ break;
+ }
+ }
+ }
+ return 0;
+};
+
+// Fixed-width decimal labels avoid allocating new strings on every frame.
+val _number = { !sys.draw.Canvas c, i64 x, i64 y, int value, int digits, int scale, u32 color ->
+ for( int i = 0; i < digits; i++ ) {
+ c.text(x+(digits-1-i)*4*scale,y,DIGITS[value-value/10*10],scale,color);
+ value /= 10;
+ }
+};
+val _hud = { !sys.draw.Canvas c, Game g ->
+ c.text(24,22,"BREAKOUT",5,WHITE);
+ c.text(264,20,"SCORE",2,MUTED);
+ _number(c,264,40,g.score,3,4,WHITE);
+ c.text(424,20,"BRICKS",2,MUTED);
+ _number(c,424,40,g.remaining,3,4,WHITE);
+ c.text(584,20,"BALLS",2,MUTED);
+ for( int i = 0; i < g.lives; i++ ) c.fillCircle(590+23*i,50,5,CYAN);
+ c.text(714,20,"SPEED",2,MUTED);
+ int speed = g.speed;
+ _number(c,714,40,speed,3,4,g.boosted ? COLORS[0] : WHITE);
+ c.text(838,40,g.boosted ? "BOOST!" : "NORMAL",3,g.boosted ? COLORS[0] : MUTED);
+};
+val _bricks = { !sys.draw.Canvas c, Game g ->
+ c.fillRect(LEFT-4,TOP-4,RIGHT-LEFT+8,4,MUTED);
+ c.fillRect(LEFT-4,TOP,4,BOTTOM-TOP,0x29435a);
+ c.fillRect(RIGHT,TOP,4,BOTTOM-TOP,0x29435a);
+ c.text(376,108,g.boosted ? "BACK WALL BOOST ACTIVE" : "BREAK THROUGH FOR A BOOST",2,g.boosted ? COLORS[0] : MUTED);
+ for( int i = 0; i < g.bricks#; i++ ) {
+ if( g.bricks[i] == 0 ) continue;
+ int row = i/COLS;
+ i64 x = LEFT+2+(i-row*COLS)*BRICK_DX, y = BRICK_TOP+row*BRICK_DY;
+ c.fillRect(x,y,BRICK_W,BRICK_H,COLORS[row]);
+ c.fillRect(x,y,BRICK_W,2,WHITE);
+ }
+};
+val _overlay = { !sys.draw.Canvas c, Game g ->
+ if( g.phase != PLAY || g.paused ) {
+ c.fillRect(246,422,516,108,0x17263a).rect(246,422,516,108,2,0x29435a);
+ u8[~] title = g.paused ? "PAUSED" : g.phase == WON ? "WALL CLEARED!" : g.phase == LOST ? "GAME OVER" : "READY?";
+ c.text(504-(title#*4-1)*4/2,442,title,4,WHITE);
+ u8[~] help = g.paused ? "P TO CONTINUE" : g.phase == WON || g.phase == LOST ? "R TO PLAY AGAIN" : "SPACE OR CLICK TO SERVE";
+ c.text(504-(help#*4-1)*2/2,490,help,2,CYAN);
+ }
+ return 0;
+};
+val _draw = { !sys.draw.Canvas c, Game g ->
+ c.clear(BACKGROUND);
+ _hud(c,g);
+ _bricks(c,g);
+ i64 paddle = g.paddle, ballX = g.x, ballY = g.y;
+ int glowRadius = RADIUS+3;
+ c.fillRect(paddle-PADDLE_HALF,PADDLE_Y,2*PADDLE_HALF,12,CYAN);
+ c.fillRect(paddle-PADDLE_HALF+4,PADDLE_Y+2,2*PADDLE_HALF-8,2,WHITE);
+ c.fillCircle(ballX,ballY,glowRadius,g.boosted ? 0x672a42 : 0x224b61);
+ c.fillCircle(ballX,ballY,RADIUS,g.boosted ? COLORS[0] : WHITE);
+ _overlay(c,g);
+ c.text(24,738,"ARROWS / MOUSE: MOVE SPACE / CLICK: SERVE P: PAUSE R: RESTART Q / ESC: QUIT",2,MUTED);
+};
+
+// Short, fading triangle waves; the array initializer builds PCM once at startup.
+val _tone = { int period ->
+ val samples = new i16[~2400]{int i ->
+ int phase = i-i/period*period;
+ int triangle = phase < period/2 ? phase : period-phase;
+ return (triangle*4-period)*6000/period*(2400-i)/2400;
+ };
+ int handle = sys.audio.load(samples);
+ return handle < 0 ? sys.audio.BOOP : handle;
+};
+struct Controls {
+ bool serveHeld = false, pauseHeld = false, restartHeld = false;
+ int lastMouse = 504;
+};
+val _input = { !Game g, !Controls keys ->
+ val gfx = sys.gfx;
+ bool serve = gfx.key(' ') || gfx.button(gfx.LEFT);
+ bool pause = gfx.key('P'), restart = gfx.key('R');
+ if( restart && !keys.restartHeld ) { g._reset(); sys.audio.stop(); }
+ if( pause && !keys.pauseHeld && (g.phase == READY || g.phase == PLAY) ) g.paused = !g.paused;
+ int direction = (gfx.key(KEY_RIGHT) ? 1 : 0)-(gfx.key(KEY_LEFT) ? 1 : 0);
+ int mouse = gfx.mouseX();
+ if( mouse != keys.lastMouse && direction == 0 && !g.paused && (g.phase == READY || g.phase == PLAY) ) {
+ g._paddle(mouse*1.0);
+ if( g.phase == READY ) g.x = g.paddle;
+ }
+ keys.lastMouse = mouse;
+ if( serve && !keys.serveHeld ) g._serve();
+ keys.serveHeld = serve; keys.pauseHeld = pause; keys.restartHeld = restart;
+ return direction;
+};
+
+// Fast low accuracy sqrt
+val _sqrt = { f64 n ->
+ f64 r = 1.0;
+ for( int i = 0; i < 8; i++ ) r = (r+n/r)*0.5;
+ return r;
+};
+
+val main = { u8[~][] args ->
+ val gfx = sys.gfx, audio = sys.audio, time = sys.time;
+ val c = new sys.draw.Canvas(WIDTH,HEIGHT);
+ val g = new Game;
+ if( gfx.open("Simple Breakout",c.width,c.height) != gfx.OK ) return 1;
+ audio.open(); // Optional: a missing audio backend leaves play silent.
+ val sounds = new int[~]{0,_tone(120),_tone(80),audio.BOOP,audio.WIN,audio.LOSE,audio.WIN};
+ // Bottom to top: roughly 333..800 Hz, below the old 1000 Hz brick tone.
+ val brickSounds = new int[~ROWS]{int i -> int period = 144-i*12; _tone(period);};
+ val keys = new Controls;
+ keys.lastMouse = gfx.mouseX();
+ int frames = 0, status = gfx.OK;
+ i64 last_ms = time.monotonic(), pending_ms = 0, frame_ms = last_ms;
+ while( status == gfx.OK ) {
+ if( gfx.key('Q') || gfx.key(gfx.ESCAPE) ) break;
+ int direction = _input(g,keys);
+ i64 now_ms = time.monotonic(), elapsed_ms = now_ms-last_ms;
+ last_ms = now_ms;
+ // Drop long stalls instead of teleporting the ball after a window drag.
+ pending_ms += elapsed_ms < 0 ? 0 : elapsed_ms > 64 ? 64 : elapsed_ms;
+ while( pending_ms >= STEP_ms ) { _tick(g,direction); pending_ms -= STEP_ms; }
+ if( g.sound != 0 ) {
+ audio.play(g.sound == 3 ? brickSounds[g.soundDepth-1] : sounds[g.sound]);
+ g.sound = 0;
+ }
+ if( now_ms >= frame_ms ) {
+ _draw(c,g);
+ status = gfx.present(c.pixels);
+ frame_ms = now_ms+FRAME_ms;
+ if( args# > 1 && ++frames == 10 ) break;
+ }
+ if( status == gfx.OK ) status = gfx.wait(STEP_ms-pending_ms);
+ }
+ audio.close(); gfx.close();
+ return status == gfx.ERROR ? 1 : 0;
+};
diff --git a/chapter31/docs/examples/Clock.smp b/chapter31/docs/examples/Clock.smp
index 11449810..ecf0fae1 100644
--- a/chapter31/docs/examples/Clock.smp
+++ b/chapter31/docs/examples/Clock.smp
@@ -1,25 +1,25 @@
// Local clocks; click the button or press Space to switch. Q/Escape exits.
// Any argument runs ten frames, exercising both faces for smoke tests.
-u32 GREEN=0x62ff70, DIM=0x123d20, BACKGROUND=0x020b05;
+u32 GREEN = 0x62ff70, DIM = 0x123d20, BACKGROUND = 0x020b05;
val main = { u8[~][] args ->
val gfx = sys.gfx;
val time = sys.time;
// The main Canvas
val screen = new sys.draw.Canvas(720,540);
- if( gfx.open("Simple digital and analog clocks",screen.width,screen.height)!=gfx.OK ) return 1;
+ if( gfx.open("Simple digital and analog clocks",screen.width,screen.height) != gfx.OK ) return 1;
// Button to flip clock style
val button = new sys.draw.Button(220,454,280,52,"ANALOG CLOCK");
val timers = new sys.time.Timers();
u32 frame_id = timers.every(33);
- if( frame_id==0 ) { gfx.close(); return 1; }
+ if( frame_id == 0 ) { gfx.close(); return 1; }
- bool analog=false, held=false;
- int frames=0, status=gfx.OK;
+ bool analog = false, held = false;
+ int frames = 0, status = gfx.OK;
// Main event loop
- while( status==gfx.OK ) {
+ while( status == gfx.OK ) {
// Did the user press space bar?
bool space = gfx.key(' ');
// Did the left mouse button go down?
@@ -27,31 +27,31 @@ val main = { u8[~][] args ->
// ANd did it go down over this button?
bool click = button.update(gfx.mouseX(),gfx.mouseY(),down);
// If clicked, flip the clock mode
- if( click || (space && !held) ) analog=!analog;
+ if( click || (space && !held) ) analog = !analog;
held = space;
if( gfx.key('Q') ) break;
// Change button label
button.label = analog ? "DIGITAL CLOCK" : "ANALOG CLOCK";
// If the next timer event is the every-33-msec event
- if( timers.poll(time.monotonic())==frame_id ) {
+ if( timers.poll(time.monotonic()) == frame_id ) {
// Draw the clock screen and button
_draw(screen,time.now(),analog);
button.draw(screen,3,GREEN,BACKGROUND,DIM);
// Presne the canvas on screen
status = gfx.present(screen.pixels);
// Testing only: show 5 frames, flip to analog, show 5 more and exit
- if( args#>1 ) {
+ if( args# > 1 ) {
frames++;
- if( frames==5 ) analog=true;
- if( frames==10 ) break;
+ if( frames == 5 ) analog = true;
+ if( frames == 10 ) break;
}
}
- if( status!=gfx.OK ) break;
+ if( status != gfx.OK ) break;
// Stall until next timer event
status = gfx.wait(time.remaining(timers.nextDeadline(),time.monotonic()));
}
gfx.close();
- return status==gfx.ERROR ? 1 : 0;
+ return status == gfx.ERROR ? 1 : 0;
};
val _draw = { !sys.draw.Canvas screen, i64 wall_ms, i64 analog ->
@@ -67,17 +67,17 @@ val _draw = { !sys.draw.Canvas screen, i64 wall_ms, i64 analog ->
// a..g bits: top, upper-right, lower-right, bottom, lower-left, upper-left,
// middle. Faint unlit bars retain the old LED figure-eight silhouette.
val _digit = { !sys.draw.Canvas c, int x, int y, i64 digit ->
- int bits=digit==0 ? 0x3f : digit==1 ? 0x06 : digit==2 ? 0x5b :
- digit==3 ? 0x4f : digit==4 ? 0x66 : digit==5 ? 0x6d :
- digit==6 ? 0x7d : digit==7 ? 0x07 : digit==8 ? 0x7f : digit==9 ? 0x6f : 0;
- for( int i=0; i<7; i++ ) {
- u32 color=(bits&(1<<i))!=0 ? GREEN : DIM;
- if( i==0 || i==3 || i==6 ) {
- int dy=i==0 ? 0 : i==3 ? 144 : 72;
+ int bits = digit == 0 ? 0x3f : digit == 1 ? 0x06 : digit == 2 ? 0x5b :
+ digit == 3 ? 0x4f : digit == 4 ? 0x66 : digit == 5 ? 0x6d :
+ digit == 6 ? 0x7d : digit == 7 ? 0x07 : digit == 8 ? 0x7f : digit == 9 ? 0x6f : 0;
+ for( int i = 0; i < 7; i++ ) {
+ u32 color = (bits&(1<<i)) != 0 ? GREEN : DIM;
+ if( i == 0 || i == 3 || i == 6 ) {
+ int dy = i == 0 ? 0 : i == 3 ? 144 : 72;
c.line(x+14,y+dy,x+58,y+dy,10,color);
} else {
- bool right=i==1 || i==2;
- int dx=right ? 68 : 4, dy=i==1 || i==5 ? 12 : 84;
+ bool right = i == 1 || i == 2;
+ int dx = right ? 68 : 4, dy = i == 1 || i == 5 ? 12 : 84;
c.line(x+dx,y+dy,x+dx,y+dy+48,10,color);
}
}
@@ -87,7 +87,7 @@ val _digital = { !sys.draw.Canvas c, int hour, int minute, int second ->
_digit(c,68,166,hour/10); _digit(c,154,166,hour-hour/10*10);
_digit(c,284,166,minute/10); _digit(c,370,166,minute-minute/10*10);
_digit(c,500,166,second/10); _digit(c,586,166,second-second/10*10);
- for( int i=0; i<2; i++ ) {
+ for( int i = 0; i < 2; i++ ) {
c.fillCircle(254+i*216,214,6,GREEN);
c.fillCircle(254+i*216,262,6,GREEN);
}
@@ -96,31 +96,31 @@ val _digital = { !sys.draw.Canvas c, int hour, int minute, int second ->
// Rational sine approximation, accurate enough for pixel clock geometry.
// Arguments are nonnegative turns; no additional native math dependency.
val _sin = { f64 turn ->
- i64 whole=turn; turn-=whole;
- bool negative=turn>0.5;
- f64 x=(negative ? turn-0.5 : turn)*6.283185307179586;
- f64 product=x*(3.141592653589793-x);
- f64 numerator=negative ? -16.0 : 16.0;
+ i64 whole = turn; turn -= whole;
+ bool negative = turn > 0.5;
+ f64 x = (negative ? turn-0.5 : turn)*6.283185307179586;
+ f64 product = x*(3.141592653589793-x);
+ f64 numerator = negative ? -16.0 : 16.0;
return numerator*product/(49.34802200544679-4*product);
};
val _hand = { !sys.draw.Canvas c, f64 turn, int length, int thickness, u32 color ->
- int x=360+_sin(turn)*length, y=232-_sin(turn+0.25)*length;
+ int x = 360+_sin(turn)*length, y = 232-_sin(turn+0.25)*length;
c.line(360,232,x,y,thickness,color);
};
val _analog = { !sys.draw.Canvas c, int hour, int minute, int second, int millisecond ->
c.circle(360,232,154,3,GREEN);
- for( int i=0; i<60; i++ ) {
- f64 turn=i/60.0;
- bool major=i-i/5*5==0;
- int inner=major ? 133 : 143;
- int x0=360+_sin(turn)*inner, y0=232-_sin(turn+0.25)*inner;
- int x1=360+_sin(turn)*149, y1=232-_sin(turn+0.25)*149;
+ for( int i = 0; i < 60; i++ ) {
+ f64 turn = i/60.0;
+ bool major = i-i/5*5 == 0;
+ int inner = major ? 133 : 143;
+ int x0 = 360+_sin(turn)*inner, y0 = 232-_sin(turn+0.25)*inner;
+ int x1 = 360+_sin(turn)*149, y1 = 232-_sin(turn+0.25)*149;
c.line(x0,y0,x1,y1,major ? 3 : 1,GREEN);
}
c.text(349,100,"12",2,GREEN); c.text(484,227,"3",2,GREEN);
c.text(357,354,"6",2,GREEN); c.text(230,227,"9",2,GREEN);
- f64 seconds=second+millisecond/1000.0;
- f64 minutes=minute+seconds/60.0;
+ f64 seconds = second+millisecond/1000.0;
+ f64 minutes = minute+seconds/60.0;
_hand(c,(hour-hour/12*12+minutes/60.0)/12.0,78,8,GREEN);
_hand(c,minutes/60.0,112,5,GREEN);
_hand(c,seconds/60.0,128,2,0xc3ffcb);
diff --git a/chapter31/docs/examples/Dijkstra.smp b/chapter31/docs/examples/Dijkstra.smp
index a8fcf3da..6591b310 100644
--- a/chapter31/docs/examples/Dijkstra.smp
+++ b/chapter31/docs/examples/Dijkstra.smp
@@ -6,14 +6,14 @@ val shortestPath = { !sys.aryi64 matrix, int nodes, int src, int dst ->
i64 infinity = sys.integer.MAX_I64;
var visited = new sys.adt.bitset();
// All nodes are infinitely far from each other, except the starting point
- var dist = new i64[nodes]{ int i -> i==src ? 0 : infinity; };
+ var dist = new i64[nodes]{ int i -> i == src ? 0 : infinity; };
i64 result = -1;
int count = 0;
while( count < nodes && result < 0 ) {
int nearest = -1;
i64 best = infinity;
- for( int node=0; node<nodes; node++ )
+ for( int node = 0; node < nodes; node++ )
if( !visited.get(node) && dist[node] < best ) {
nearest = node;
best = dist[node];
@@ -22,8 +22,8 @@ val shortestPath = { !sys.aryi64 matrix, int nodes, int src, int dst ->
else {
if( nearest == dst ) return best;
visited.set(nearest);
- for( int node=0; node<nodes; node++ ) {
- u32 index=nearest*nodes + node;
+ for( int node = 0; node < nodes; node++ ) {
+ u32 index = nearest*nodes + node;
i64 weight = matrix.get(index);
if( weight > 0 && !visited.get(node) && best+weight < dist[node] )
dist[node] = best+weight;
@@ -47,7 +47,7 @@ val main = { u8[~][] args ->
if( !matrix ) return usage();
if( !matrix.len ) return usage();
// All numbers are positive
- for( u32 i=0; i<matrix.len; i++ )
+ for( u32 i = 0; i < matrix.len; i++ )
if( matrix.get(i) < 0 ) return usage();
// Matrix is square
int nodes = 0;
@@ -61,7 +61,7 @@ val main = { u8[~][] args ->
if( src < 0 || src >= nodes || dst < 0 || dst >= nodes )
return usage(); // Source and destination land within the graph
- int source=src, destination=dst;
+ int source = src, destination = dst;
i64 cost = shortestPath(matrix,nodes,source,destination);
if( cost >= 0 ) {
new sys.aryu8().num(cost).add('\n').write(1);
diff --git a/chapter31/docs/examples/Graphics.smp b/chapter31/docs/examples/Graphics.smp
index 7ba5c6e7..8b251fa2 100644
--- a/chapter31/docs/examples/Graphics.smp
+++ b/chapter31/docs/examples/Graphics.smp
@@ -3,8 +3,8 @@
val main = { u8[~][] args ->
if( sys.gfx.open("Simple pixels",320,240) != sys.gfx.OK ) return 1;
val pixels = new u32[320*240];
- for( int y=0; y<240; y++ )
- for( int x=0; x<320; x++ )
+ for( int y = 0; y < 240; y++ )
+ for( int x = 0; x < 320; x++ )
pixels[y*320+x] = (x*255/319 << 16) | (y*255/239 << 8) | 64;
int result = sys.gfx.present(pixels);
int frames = 0;
diff --git a/chapter31/docs/examples/README.md b/chapter31/docs/examples/README.md
index 46965ac0..20b644cf 100644
--- a/chapter31/docs/examples/README.md
+++ b/chapter31/docs/examples/README.md
@@ -16,6 +16,30 @@ Run `make run-clock CTAGS=`; click the button or press Space to switch faces,
and Q/Escape to exit. Both faces show system-local time.
`make clock-example CTAGS=` builds it without starting a window.
+The [Breakout game](Breakout.smp) has 24 columns and 8 rows, with colors and
+point values by depth: 1 at the bottom through 8 at the top, 864 points total.
+Clear the wall before losing all three balls. Mouse movement or the arrow keys
+move the paddle; Space/left click serves, P pauses, R restarts, Q/Escape exits.
+Run `make run-breakout CTAGS=` or build only with `make breakout CTAGS=`.
+The familiar paddle, serve, and limited-ball rules follow
+[Atari's Breakout instructions](https://atari.com/pages/breakout).
+
+The deepest row reached with the current ball sets the base speed: 320 pixels/second plus 35 for
+each additional depth. After touching the back wall, hitting the top of a brick
+activates a **one-time 1.65x speed boost**; side/front hits do not. Returning to
+the paddle disarms that trip's back-wall opportunity. Losing a ball resets depth
+and boost, so each new ball starts at 320 pixels/second and can earn its own
+back-wall boost. Edge hits on the paddle give a wider
+rebound than center hits. Clear all bricks to win; no new wall replaces them.
+
+Physics uses fixed 8 ms ticks with movement split into steps of at most two
+pixels, including at boosted speed. Rendering runs roughly every 16 ms. The
+brick and sound tables demonstrate array initializers; the short bounce tones
+use read-only PCM arrays made by index functions. Brick boops rise in pitch with
+row depth, from about 333 Hz at the bottom to 800 Hz at the top. Audio is optional. Native
+tests in `BreakoutTest` exercise collisions, scoring, lives, pause, paddle angles,
+the boost, and clearing the whole wall without a display or audio device.
+
From `chapter31`, build the tic-tac-toe executable (without starting it):
```sh
diff --git a/chapter31/docs/examples/TicTacToe.smp b/chapter31/docs/examples/TicTacToe.smp
index 1e0f3ca0..ee4e3182 100644
--- a/chapter31/docs/examples/TicTacToe.smp
+++ b/chapter31/docs/examples/TicTacToe.smp
@@ -21,7 +21,7 @@ val main = { u8[~][] args ->
// Compute CPU move
int reply = _cpu(board);
// Set CPU choice; print board
- board[reply]='O';
+ board[reply] = 'O';
sys.io.p("CPU plays %(reply+1).\n");
_draw(board);
// A winner?
@@ -61,37 +61,37 @@ val _validMove = { u8[~] board ->
// Return the winning mark, or zero.
val _winner = { u8[~] board ->
- for( int i=0; i<3; i++ ) {
+ for( int i = 0; i < 3; i++ ) {
int row = i*3;
- if( board[row]!=' ' && board[row]==board[row+1] && board[row]==board[row+2] )
+ if( board[row] != ' ' && board[row] == board[row+1] && board[row] == board[row+2] )
return board[row];
- if( board[i]!=' ' && board[i]==board[i+3] && board[i]==board[i+6] )
+ if( board[i] != ' ' && board[i] == board[i+3] && board[i] == board[i+6] )
return board[i];
}
- if( board[4]!=' ' ) {
- if( board[0]==board[4] && board[4]==board[8] ) return board[4];
- if( board[2]==board[4] && board[4]==board[6] ) return board[4];
+ if( board[4] != ' ' ) {
+ if( board[0] == board[4] && board[4] == board[8] ) return board[4];
+ if( board[2] == board[4] && board[4] == board[6] ) return board[4];
}
return 0;
};
val _finished = { u8[~] board ->
int winner = _winner(board);
- if( winner=='X' ) { sys.io.p("You win!\n"); return true; }
- if( winner=='O' ) { sys.io.p("CPU wins!\n"); return true; }
- for( int i=0; i<board#; i++ )
- if( board[i]==' ' ) return false;
+ if( winner == 'X' ) { sys.io.p("You win!\n"); return true; }
+ if( winner == 'O' ) { sys.io.p("CPU wins!\n"); return true; }
+ for( int i = 0; i < board#; i++ )
+ if( board[i] == ' ' ) return false;
sys.io.p("It's a draw!\n");
return true;
};
// Try each empty square, restoring it before returning.
val _threat = { u8[] board, u8 mark ->
- for( int i=0; i<board#; i++ ) {
- if( board[i]==' ' ) {
- board[i]=mark;
- bool wins = _winner(board)==mark;
- board[i]=' '; // Restore board
+ for( int i = 0; i < board#; i++ ) {
+ if( board[i] == ' ' ) {
+ board[i] = mark;
+ bool wins = _winner(board) == mark;
+ board[i] = ' '; // Restore board
if( wins ) return i;
}
}
@@ -103,30 +103,30 @@ val _threat = { u8[] board, u8 mark ->
val _cpu = { u8[] board ->
// If O can win, do so
int win = _threat(board,'O');
- if( win>=0 ) return win;
+ if( win >= 0 ) return win;
// If X will win next move, block
int block = _threat(board,'X');
- if( block>=0 ) return block;
+ if( block >= 0 ) return block;
// If center is open, take it
- if( board[4]==' ' ) return 4;
+ if( board[4] == ' ' ) return 4;
// If a corner is open, take it
- for( int i=0; i<board#; i+=2 )
- if( board[i]==' ' ) return i;
+ for( int i = 0; i < board#; i += 2 )
+ if( board[i] == ' ' ) return i;
// Take whatever is available
- for( int i=0; i<board#; i++ )
- if( board[i]==' ' ) return i;
+ for( int i = 0; i < board#; i++ )
+ if( board[i] == ' ' ) return i;
return -1;
};
val _draw = { u8[~] board ->
val out = new sys.aryu8();
- for( int row=0; row<3; row++ ) {
- for( int col=0; col<3; col++ ) {
+ for( int row = 0; row < 3; row++ ) {
+ for( int col = 0; col < 3; col++ ) {
out.add(' ').add(board[row*3+col]).add(' ');
- if( col<2 ) out.add('|');
+ if( col < 2 ) out.add('|');
}
out.add('\n');
- if( row<2 ) out.addAry("---+---+---\n");
+ if( row < 2 ) out.addAry("---+---+---\n");
}
out.write(sys.libc.STDOUT);
};
diff --git a/chapter31/docs/examples/TicTacToeGraphical.smp b/chapter31/docs/examples/TicTacToeGraphical.smp
index da77e8f6..d3d575a7 100644
--- a/chapter31/docs/examples/TicTacToeGraphical.smp
+++ b/chapter31/docs/examples/TicTacToeGraphical.smp
@@ -13,28 +13,28 @@ val main = { u8[~][] args ->
bool mouseHeld = false, keyHeld = false, replayHeld = false;
int hover = -1, frames = 0;
- while( result==sys.gfx.OK ) {
+ while( result == sys.gfx.OK ) {
result = sys.gfx.wait(17);
- if( result!=sys.gfx.OK ) break;
+ if( result != sys.gfx.OK ) break;
if( sys.gfx.key('Q') ) break;
bool down = sys.gfx.button(sys.gfx.LEFT);
bool replay = sys.gfx.key('R') || sys.gfx.key(' ');
int square = _square(sys.gfx.mouseX(),sys.gfx.mouseY());
- bool dirty = square!=hover;
+ bool dirty = square != hover;
hover = square;
- if( replay && !replayHeld ) { sys.audio.stop(); _reset(board); dirty=true; }
+ if( replay && !replayHeld ) { sys.audio.stop(); _reset(board); dirty = true; }
bool digit = false;
int choice = down && !mouseHeld ? square : -1;
- for( int i=0; i<9; i++ ) {
+ for( int i = 0; i < 9; i++ ) {
int key = '1'+i;
if( sys.gfx.key(key) ) {
digit = true;
- if( !keyHeld ) choice=i;
+ if( !keyHeld ) choice = i;
}
}
if( !(replay && !replayHeld) && _move(board,choice) ) {
sys.audio.play(_sound(board));
- dirty=true;
+ dirty = true;
}
mouseHeld = down;
keyHeld = digit;
@@ -43,68 +43,68 @@ val main = { u8[~][] args ->
_draw(screen,board,hover);
result = sys.gfx.present(screen.pixels);
}
- if( args#>1 && ++frames==5 ) break;
+ if( args# > 1 && ++frames == 5 ) break;
}
sys.audio.close();
sys.gfx.close();
- return result==sys.gfx.ERROR ? 1 : 0;
+ return result == sys.gfx.ERROR ? 1 : 0;
};
// Called only for an accepted move; invalid input never requests a sound.
val _sound = { u8[~] board ->
int winner = _winner(board);
- return winner=='X' ? sys.audio.WIN : winner=='O' ? sys.audio.LOSE : sys.audio.BOOP;
+ return winner == 'X' ? sys.audio.WIN : winner == 'O' ? sys.audio.LOSE : sys.audio.BOOP;
};
val _reset = { u8[] board ->
- for( int i=0; i<9; i++ ) board[i]=' ';
+ for( int i = 0; i < 9; i++ ) board[i] = ' ';
};
val _square = { int x, int y ->
- if( x<48 || x>=552 || y<168 || y>=672 ) return -1;
+ if( x < 48 || x >= 552 || y < 168 || y >= 672 ) return -1;
return (y-168)/168*3+(x-48)/168;
};
// One player turn followed by one CPU turn. Invalid/finished moves do nothing.
val _move = { u8[] board, int square ->
- if( square<0 || square>=9 || board[square]!=' ' || _finished(board) ) return false;
+ if( square < 0 || square >= 9 || board[square] != ' ' || _finished(board) ) return false;
board[square] = 'X';
if( !_finished(board) ) {
int reply = _cpu(board);
- if( reply>=0 ) board[reply]='O';
+ if( reply >= 0 ) board[reply] = 'O';
}
return true;
};
val _finished = { u8[~] board ->
if( _winner(board) ) return true;
- for( int i=0; i<9; i++ ) if( board[i]==' ' ) return false;
+ for( int i = 0; i < 9; i++ ) if( board[i] == ' ' ) return false;
return true;
};
val _winningLine = { u8[~] board ->
- for( int i=0; i<3; i++ ) {
+ for( int i = 0; i < 3; i++ ) {
int row = i*3;
- if( board[row]!=' ' && board[row]==board[row+1] && board[row]==board[row+2] ) return i;
- if( board[i]!=' ' && board[i]==board[i+3] && board[i]==board[i+6] ) return 3+i;
+ if( board[row] != ' ' && board[row] == board[row+1] && board[row] == board[row+2] ) return i;
+ if( board[i] != ' ' && board[i] == board[i+3] && board[i] == board[i+6] ) return 3+i;
}
- if( board[4]!=' ' ) {
- if( board[0]==board[4] && board[4]==board[8] ) return 6;
- if( board[2]==board[4] && board[4]==board[6] ) return 7;
+ if( board[4] != ' ' ) {
+ if( board[0] == board[4] && board[4] == board[8] ) return 6;
+ if( board[2] == board[4] && board[4] == board[6] ) return 7;
}
return -1;
};
// Return the winning mark, or zero.
val _winner = { u8[~] board ->
int line = _winningLine(board);
- return line<0 ? 0 : line<3 ? board[line*3] : line<6 ? board[line-3] : board[4];
+ return line < 0 ? 0 : line < 3 ? board[line*3] : line < 6 ? board[line-3] : board[4];
};
// Try each empty square, restoring it before returning.
val _threat = { u8[] board, u8 mark ->
- for( int i=0; i<9; i++ )
- if( board[i]==' ' ) {
+ for( int i = 0; i < 9; i++ )
+ if( board[i] == ' ' ) {
board[i] = mark;
- bool wins = _winner(board)==mark;
+ bool wins = _winner(board) == mark;
board[i] = ' '; // Restore board
if( wins ) return i;
}
@@ -115,16 +115,16 @@ val _threat = { u8[] board, u8 mark ->
val _cpu = { u8[] board ->
// If O can win, do so
int win = _threat(board,'O');
- if( win>=0 ) return win;
+ if( win >= 0 ) return win;
// If X will win next move, block
int block = _threat(board,'X');
- if( block>=0 ) return block;
+ if( block >= 0 ) return block;
// If center is open, take it
- if( board[4]==' ' ) return 4;
+ if( board[4] == ' ' ) return 4;
// If a corner is open, take it
- for( int i=0; i<9; i+=2 ) if( board[i]==' ' ) return i;
+ for( int i = 0; i < 9; i += 2 ) if( board[i] == ' ' ) return i;
// Take whatever is available
- for( int i=0; i<9; i++ ) if( board[i]==' ' ) return i;
+ for( int i = 0; i < 9; i++ ) if( board[i] == ' ' ) return i;
return -1;
};
@@ -136,30 +136,30 @@ val _draw = { !sys.draw.Canvas screen, u8[~] board, int hover ->
screen.clear(background);
screen.text(48,34,"TIC TAC TOE",6,paper);
screen.fillRect(48,90,504,3,ink);
- screen.text(48,116,finished ? (winner=='X' ? "YOU WIN!" : winner=='O' ? "CPU WINS" : "DRAW") : "YOUR TURN",4,accent);
+ screen.text(48,116,finished ? (winner == 'X' ? "YOU WIN!" : winner == 'O' ? "CPU WINS" : "DRAW") : "YOUR TURN",4,accent);
screen.line(428,112,450,134,5,cross).line(450,112,428,134,5,cross);
screen.circle(496,123,13,5,0x70c9bf);
screen.text(428,145,"YOU",2,0xa2b9b7);
screen.text(484,145,"CPU",2,0xa2b9b7);
screen.fillRect(48,168,504,504,paper);
- if( !finished && hover>=0 && hover<9 && board[hover]==' ' )
+ if( !finished && hover >= 0 && hover < 9 && board[hover] == ' ' )
screen.fillRect(48+(hover-hover/3*3)*168,168+hover/3*168,168,168,0xd9e8de);
- for( int i=1; i<3; i++ ) {
+ for( int i = 1; i < 3; i++ ) {
screen.fillRect(48+i*168-3,168,6,504,ink);
screen.fillRect(48,168+i*168-3,504,6,ink);
}
- for( int i=0; i<9; i++ ) {
+ for( int i = 0; i < 9; i++ ) {
int cx = 132+(i-i/3*3)*168, cy = 252+i/3*168;
- if( board[i]=='X' )
+ if( board[i] == 'X' )
screen.line(cx-38,cy-38,cx+38,cy+38,12,cross).line(cx+38,cy-38,cx-38,cy+38,12,cross);
- else if( board[i]=='O' ) screen.circle(cx,cy,48,11,ring);
- else screen.text(cx-6,cy-10,i==0 ? "1" : i==1 ? "2" : i==2 ? "3" :
- i==3 ? "4" : i==4 ? "5" : i==5 ? "6" : i==6 ? "7" : i==7 ? "8" : "9",4,0x95a59e);
+ else if( board[i] == 'O' ) screen.circle(cx,cy,48,11,ring);
+ else screen.text(cx-6,cy-10,i == 0 ? "1" : i == 1 ? "2" : i == 2 ? "3" :
+ i == 3 ? "4" : i == 4 ? "5" : i == 5 ? "6" : i == 6 ? "7" : i == 7 ? "8" : "9",4,0x95a59e);
}
int line = _winningLine(board);
- if( line>=0 ) {
- int first = line<3 ? line*3 : line<6 ? line-3 : line==6 ? 0 : 2;
- int last = line<3 ? first+2 : line<6 ? first+6 : line==6 ? 8 : 6;
+ if( line >= 0 ) {
+ int first = line < 3 ? line*3 : line < 6 ? line-3 : line == 6 ? 0 : 2;
+ int last = line < 3 ? first+2 : line < 6 ? first+6 : line == 6 ? 8 : 6;
screen.line(132+(first-first/3*3)*168,252+first/3*168,132+(last-last/3*3)*168,252+last/3*168,5,0xeab64e);
}
screen.text(48,704,"CLICK A SQUARE OR PRESS 1-9",3,paper);