From 3d0f3f38d9d8345b6508b3289dc94b0500c53d9e Mon Sep 17 00:00:00 2001 From: Cliff Click Date: Sat, 14 Nov 2026 12:41:16 -0800 Subject: 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 --- chapter31/docs/examples/Breakout.smp | 293 +++++++++++++++++++++++++ chapter31/docs/examples/Clock.smp | 74 +++---- chapter31/docs/examples/Dijkstra.smp | 12 +- chapter31/docs/examples/Graphics.smp | 4 +- chapter31/docs/examples/README.md | 24 ++ chapter31/docs/examples/TicTacToe.smp | 54 ++--- chapter31/docs/examples/TicTacToeGraphical.smp | 82 +++---- chapter31/docs/intrinsics.md | 53 +++++ 8 files changed, 483 insertions(+), 113 deletions(-) create mode 100644 chapter31/docs/examples/Breakout.smp create mode 100644 chapter31/docs/intrinsics.md (limited to 'chapter31/docs') 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< _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 else { if( nearest == dst ) return best; visited.set(nearest); - for( int node=0; node 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 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 - for( int i=0; i 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 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. -- cgit v1.2.3