summaryrefslogtreecommitdiff
path: root/chapter31/docs
diff options
context:
space:
mode:
Diffstat (limited to 'chapter31/docs')
-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
-rw-r--r--chapter31/docs/intrinsics.md53
8 files changed, 483 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);
diff --git a/chapter31/docs/intrinsics.md b/chapter31/docs/intrinsics.md
new file mode 100644
index 00000000..3aae39bd
--- /dev/null
+++ b/chapter31/docs/intrinsics.md
@@ -0,0 +1,53 @@
+# Fixed-semantics C intrinsics
+
+An intrinsic is an ordinary C binding with a reserved external symbol and a
+fixed signature and meaning. The compiler may replace a known call with ideal
+IR nodes; it does not match the spelling of the caller's local variable or a
+Simple function with the same name. No new expression syntax is involved.
+
+The first intrinsics preserve IEEE binary64 representations:
+
+| External C symbol | Signature | Public alias |
+| --- | --- | --- |
+| `simple_f64_bits` | `{ f64 -> i64 }` | `sys.math.f64Bits` |
+| `simple_f64_from_bits` | `{ i64 -> f64 }` | `sys.math.f64FromBits` |
+
+```simple
+i64 bits = sys.math.f64Bits(1.0); // 0x3ff0000000000000
+f64 value = sys.math.f64FromBits(bits); // 1.0
+int numeric = value; // Numeric conversion, still 1.
+```
+
+Both operations preserve signed zero, infinities, subnormals, and NaN signs and
+payloads, including the signaling bit. They perform no arithmetic and have no
+memory effects. An `i64` holds the bit pattern; its sign is irrelevant to the
+conversion. Applying either operation followed by the other is an identity.
+Floating-point arithmetic between conversions retains its usual semantics and
+may change a NaN representation.
+
+`Intrinsic.java` owns the reserved-symbol table, signatures, effect queries,
+inlining, and ideal nodes. Call/CallEnd delegate to it. The cheap inliner checks
+intrinsics before requiring a Simple body or Return edge. It validates the
+signature and actual arguments, then replaces the complete control/memory/value
+state. For these pure operations, control and memory pass through unchanged.
+Aliases and imported bindings use the existing external-function identity map.
+
+Unknown indirect targets keep ordinary calls. `simple_crt.c` supplies real C
+definitions, using `memcpy` to preserve representations without aliasing tricks.
+These symbols have fixed semantics: a replacement implementation must honor the
+same contract. Ordinary C functions remain opaque to the optimizer.
+
+The ideal nodes support constant folding, inverse cancellation, evaluation, and
+serialization. Floating-point constant interning and serialization retain raw
+NaN bits. x86 emits `MOVQ` between XMM and integer registers; ARM emits `FMOV`,
+and RISC-V emits `FMV.X.D` / `FMV.D.X`. Register allocation may add copies or
+spills, and normal module-initialization checks still apply.
+
+Future intrinsics such as compare-and-swap or fences must define their memory
+and escape effects explicitly and expand to nodes with appropriate ordering
+dependencies. They must not inherit the pure conversions' passthrough memory
+behavior. Atomic operations and hardware square root are not introduced here.
+
+`make test CLASS=IntrinsicTest CTAGS=` checks folding, representation preservation,
+type errors, side effects, indirect C fallback, binary imports, and instruction
+selection on all three backends, plus ARM/RISC-V emulation and native x86 execution.