俄罗斯方块引导程序：

; TetrOS version 1.04   改写版
; by Tomasz Grysztar

; Requires VGA and 80386 CPU or higher.
; Version 1.01 was submitted in 2004 for a 512-byte OS contest.

; For your playing pleasure, it's a boot-sector Tetris game.
; Keys:
;   Left - move left
;   Right - move right
;   Up - rotate
;   Down - drop
;   Esc - new game at any time

format binary as 'img'
org 7C00h

ROWS = 23
COLUMNS = 12
BACKGROUND = 0 ; background color, 0 for randomized

virtual at 46Ch
  clock dw ?
end virtual

virtual at bp
  current dw ?
  current_column db ?
  current_row dw ?
  next dw ?
  score dw ?
  last_tick dw ?
  random dw ?
end virtual

label well at 9000h
label pics at well-2*64

        xor     ax,ax
        mov     sp,8000h
        mov     ss,ax
        mov     ds,ax
        mov     es,ax
        push    ax
        push    start
        retf

start:
        mov     bp,sp

        mov     al,13h
        int     10h

        mov     di,3*4
        mov     ax,int_3
        stosw
        xor     ax,ax
        stosw
        lea     di,[next]
        stosw   ; [next]
        stosw   ; [score]
        mov     ax,[clock]
        stosw   ; [last_tick]
        stosw   ; [random]

        mov     di,pics
        mov     cx,64
if BACKGROUND
        mov     ax,0F00h + BACKGROUND
else
        mov     ah,15
end if
        rep     stosb
        mov     dx,7
      @@:
        mov     al,15
        stosb
        mov     al,ah
        mov     cl,6
        rep     stosb
        mov     ax,0708h
        stosb
        dec     dx
        jnz     @b
        mov     cl,8
        rep     stosb

        or      ax,-1
        stosw
        stosw
        stosw
        mov     cl,ROWS+4
        mov     ax,not ( (1 shl COLUMNS - 1) shl ((16-COLUMNS)/2) )
        rep     stosw
new_piece:
        mov     bx,[random]
        mov     ax,257
        mul     bx
        inc     ax
        mov     cx,43243
        div     cx
        mov     [random],dx
        and     bx,7
        jz      new_piece
;        shl     bx,1
        movzx   ax,byte[pieces+bx-1]
        ;shl     ax,4
        xchg    ax,[next]
        or      ax,ax
        jz      new_piece
        lea     di,[current]
        stosw   ; [current]
        mov     al,6
        stosb   ; [current_column]
        mov     ax,well+(3+ROWS-4)*2
        stosw   ; [current_row]
        mov     si,no_move
        call    first_move
        jz      update_screen
        inc     bp      ; game over  

process_key:
        xor     ah,ah
        int     16h
        mov     al,ah
        dec     ah
        jz      start
        test    bp,bp
        jnp     process_key
        mov     si,rotate
        cmp     al,48h
        je      action
        mov     si,left
        cmp     al,4Bh
        je      action
        mov     si,right
        cmp     al,4Dh
        je      action
        cmp     al,50h
        jne     main_loop

drop_down:
        call    do_move_down
        jz      drop_down

action:
        call    do_move

update_screen:
        mov     bx,7
        mov     dx,12h
        mov     ah,2
        int     10h
        mov     cl,12
      print_score:
        mov     ax,[score]
        shr     ax,cl
        and     al,0Fh
        cmp     al,10
        sbb     al,69h
        das
        mov     ah,0Eh
        int     10h
        sub     cl,4
        jnc     print_score
        push    es
        push    0A000h
        pop     es
        mov     si,well+3*2
        mov     di,320*184+160-(COLUMNS*8)/2
      draw_well:
        lodsw
        push    si
        mov     dl,COLUMNS
        xchg    bx,ax
        shr     bx,(16-COLUMNS)/2
        call    draw_row
        pop     si
        cmp     si,well+(3+ROWS)*2
        jb      draw_well
        mov     di,320*100+250
        mov     bx,[next]
      draw_preview:
        mov     dl,4
        call    draw_row
        cmp     di,320*68
        ja      draw_preview
        pop     es

main_loop:
        mov     ah,1
        int     16h
        jnz     process_key
        mov     al,-1
        xor     al,byte [score+1]
        and     al,11b
        mov     cx,[clock]
        sub     cx,[last_tick]
        cmp     cl,al
        jbe     main_loop
        add     [last_tick],cx
        call    do_move_down
        jz      update_screen
        movzx   dx,byte [current_row]
        shr     dx,2
        mov     si,well+3*2
        mov     di,si
      check_row:
        lodsw
        inc     ax
        jz      remove_row
        dec     ax
        stosw
        jmp     check_next_row
      remove_row:
        shl     dx,1
      check_next_row:
        cmp     di,well+(3+ROWS)*2
        jb      check_row
        add     [score],dx
        jmp     new_piece

draw_row:
        push    di
      blit_row:
        shr     bx,1
        mov     si,pics
        jnc     blit_block
        add     si,64
      blit_block:
        mov     cx,8
        rep     movsb
        add     di,320-8
        test    si,111111b
        jnz     blit_block
        sub     di,320*8-8
        dec     dx
        jnz     blit_row
        pop     di
        sub     di,320*8
        ret

do_move_down:
        mov     si,down
do_move:
        mov     al,1
        int3
first_move:
        push    dword [current]
        call    si
        xor     ax,ax
        int3
        inc     ax
        pop     edx
        test    ah,ah
        jz      @f
        mov     dword [current],edx
      @@:
        int3
      no_move:
        ret
down:
        sub     byte [current_row],2
        ret
left:
        dec     [current_column]
        ret
right:
        inc     [current_column]
        ret
rotate:
        mov     cx,3
     @@:
        bt      [current],cx
        rcl     dx,1
        add     cl,4
        cmp     cl,16
        jb      @b
        sub     cl,17
        jnc     @b
        mov     [current],dx
        ret

int_3:
        mov     di,[current_row]
        mov     bx,4
      on_piece_row:
        mov     dx,[current]
        mov     cl,bh
        shr     dx,cl
        and     dx,1111b
        mov     cl,[current_column]
        add     cl,4
        shl     edx,cl
        shr     edx,4
        test    al,al
        jz      @f
        xor     [di],dx
      @@:
        test    [di],dx
        jz      @f
        inc     ah
      @@:
        add     bh,4
        scasw
        dec     bl
        jnz     on_piece_row
        iret

pieces:
        db 1111'0000b ;I
        db 1110'0100b ;T
        db 1110'0010b ;J
        db 1110'1000b ;L
        db 0110'0110b ;O
        db 0110'1100b ;S
        db 1100'0110b ;Z

;       dw 0010'0010'0010'0010b
;       dw 0010'0110'0010'0000b
;       dw 0010'0010'0110'0000b
;       dw 0100'0100'0110'0000b
;       dw 0000'0110'0110'0000b
;       dw 0100'0110'0010'0000b
;       dw 0010'0110'0100'0000b

       n = 0
repeat 7C00h+510-$
       display n+30h
       n=n+1
       if n=10
       n=0
       display 13,10
       end if
       db 0
end repeat

dw 0AA55h

这个引导型程序是16位系统的引导程序，一开始的引导程序中最好是16位再32位。这样就可以了。因为计算机的BIOS基本输入输出系统有几个模式，基地址都不同。

后来的资料是32位保护模式，一直存在了很多年，从1990到2023有30年的历史地位了，那64位保护模式很一般，因为只是权限和为了更远的地址还有64位程序大作战。

上一层的管理你不太懂，CPU管理64位是一块一块的，到32位就连续了，你要知道，32位的寻址对64位寻址来说是冰山一角。也有可能，你看到的是别人电脑的内存。这个你还不知道。

你知道当权限被局限成32位的模式之后，有跳过64位的址的吗？最简单的就是利用MMX寄存器，这个寄存器利用得好是没有限制的。跳越地址快得很。这和CPU结构有关。并不复杂，只是巧思。

那些研究计算机指令和破解的人并没有完全看懂intel手册。也都只是局部了解，不过也是一通百通。究真没意义。不过有些指令和实现很吸引人，不用过分的死记硬背。这个技术来得快。

那起步是有难度的，一开始是捉虫，有个抖音视频，BUG!BUG!BUG！也就是两边战士打架，一边的一位战士丢了一个手榴弹，那手榴弹不是弦线，是弦线加垂直线下来打的中间的那几个人。

那几个人不知道是两边哪一边的。可能是两边的人打架的前锋在一起了，一起吃个饭，还是被炸了。焦糊的黑灰脸，一个东北帽，两只大眼睛向上向前，“bug,bug,bug",当然，这是一个笑话。没下文了，一个引导型游戏。截屏不太方便。