diff options
Diffstat (limited to 'chapter31/docs')
| -rw-r--r-- | chapter31/docs/examples/Breakout.smp | 293 | ||||
| -rw-r--r-- | chapter31/docs/examples/Clock.smp | 74 | ||||
| -rw-r--r-- | chapter31/docs/examples/Dijkstra.smp | 12 | ||||
| -rw-r--r-- | chapter31/docs/examples/Graphics.smp | 4 | ||||
| -rw-r--r-- | chapter31/docs/examples/README.md | 24 | ||||
| -rw-r--r-- | chapter31/docs/examples/TicTacToe.smp | 54 | ||||
| -rw-r--r-- | chapter31/docs/examples/TicTacToeGraphical.smp | 82 | ||||
| -rw-r--r-- | chapter31/docs/intrinsics.md | 53 |
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. |
