richard.asm

课程设计,俄罗斯方块,源码用汇编语言编写,在DOS运行,用MASM2.0编译.

printstring macro x,y,mess  ;less bl,cx
	push bp
	mov dh,y
	mov dl,x
	mov bh,0
	lea bp,mess
	mov al,1
	mov ah,13h
	int 10h
	pop bp
	endm

string macro ch,len
	mov bh,0
	mov al,ch
	mov cx,len
	mov ah,9
	int 10h
	endm

clrscr macro
	mov ah,6
	mov bh,7
	mov cx,0
	mov dh,24
	mov dl,79
	int 10h
     endm

closecur macro
	mov ah,1
	mov ch,20h
	int 10h
	endm

opencur macro
	mov ah,1
	mov ch,12
	mov cl,13
	int 10h
	endm

gotoxy macro x,y
	mov dh,y
	mov dl,x
	mov bh,0
	mov ah,2
	int 10h
	endm

clrkey macro
	mov ah,0ch
	int 21h
	endm

pushall macro
	push ax
	push bx
	push cx
	push dx
	endm

popall macro
	pop dx
	pop cx
	pop bx
	pop ax
	endm

block macro attr
	push cx
	mov ah,9
	mov al,0dbh
	mov bl,attr
	mov cx,2
	int 10h
	pop cx
	endm

cprintf macro ch
	mov ah,9
	mov al,ch
	mov cx,1
	int 10h
	endm

random macro
	mov ah,0
	int 1ah
	mov al,dl
	mov cl,7
	div cl
	mov al,ah
	cbw
	endm

printscore macro x,y,scro
	push bx
	gotoxy x,y
	pop bx
	mov bx,scro
	mov cx,10000d
	call dec_div

	push bx
	gotoxy x+1,y
	pop bx
	mov cx,1000
	call dec_div

	push bx
	gotoxy x+2,y
	pop bx
	mov cx,100
	call dec_div

	push bx
	gotoxy x+3,y
	pop bx
	mov cx,10
	call dec_div

	push bx
	gotoxy x+4,y
	pop bx
	mov cx,1
	call dec_div
	endm

ENTER EQU 1C0DH
ESCA  EQU 011BH
LEFT  EQU 4B00H
RIGHT EQU 4D00H
UP    EQU 4800H
DOWN  EQU 5000H
HOME  EQU 4700H
ENDA  EQU 4F00H

EMPTY EQU 0
BRICK EQU 1
WALL  EQU 2

MOVE_DOWN EQU 0
MOVE_LEFT EQU 1
MOVE_RIGHT EQU 2
REVOLVE  EQU 3

YES  EQU 1
NO   EQU 0

GET  EQU 0
PUT  EQU 1
CAL  EQU 2

BACKGROUND EQU 19
SHADE_ATTR EQU 8
BAR_ATTR   EQU 6EH

BOARD_WIDTH  EQU 12;10
BOARD_HEIGHT EQU 18
BOARD_LEFT   EQU 16
BOARD_TOP    EQU 3
BOARD_ATTR   EQU 7eH
BOARD_BACK   EQU 7

SCORE_LEFT   EQU 49
SCORE_TOP    EQU 14
SCORE_WIDTH  EQU 14
SCORE_HEIGHT EQU 6
SCORE_ATTR   EQU 46
SCORE1       EQU 1
SCORE2       EQU 100

NEXT_LEFT    EQU 49
NEXT_TOP     EQU 4
NEXT_WIDTH   EQU 14
NEXT_HEIGHT  EQU 6
NEXT_ATTR    EQU 7EH

TIME         EQU 1CH

data segment
brick_set db 1,1,1,1,0,0
	  db 1,1,1,0,1,0
	  db 1,1,1,0,0,1
	  db 1,1,0,0,1,1
	  db 0,1,1,1,1,0
	  db 1,1,0,1,1,0
array db (BOARD_HEIGHT+2)*(BOARD_WIDTH+2) dup(0)
row_down_offset db BOARD_HEIGHT dup(?)
xp db ?
yp db ?
brick_no dw ?
down_speed dw ?
ticket dw ?
time_set dw ?
down_offset db ?
gover db ?
over dw ?
next_brick_no dw ?
next_set dw 2
reach_bottom dw NO
key dw ?
current_score dw 0
high_score dw 0
level dw 200
i db 0
j db 0
t dw 0
x1 db 0
x2 db 0
x3 db 0
x4 db 0
y db 0
mable dw ?
mess1 db 0b3h,' Russian Brick Game ',0b3h
mess2 db ' HELP ',0b3h,' ESC: Exit Game  HOME: New Game  END: Pause  UP: Rotate'
mess3 db 0b2h,0b1h,0b0h
mess4 db 0b1h,0b0h
mess5 db 0b2h,0b1h,0b0h
mess6 db 0b0h,0b1h,0b0h
mess7 db 'High Score:'
mess8 db 'Speed:'
mess9 db 'Score:'
mess10 db 'Next Brick:'
mess11 db 'Try again?(Y/N)'
mess12 db 0
data ends

stack segment
	dw 100 dup(?)
   tos  label word
stack ends


code segment
main proc far
	assume cs:code,ds:data,es:data,ss:stack
start:
	mov ax,data
	mov ds,ax
	mov es,ax
	mov ax,stack
	mov ss,ax
	mov sp,offset tos

	clrscr
	closecur

	mov al,1ch
	mov ah,35h
	int 21h
	push es
	push bx

	push ds
	mov dx,offset new_int
	mov ax,seg new_int
	mov ds,ax
	mov al,1ch
	mov ah,25h
	int 21h
	pop ds
while1:
	call game_screen
	call new_game
	call score
do:
	call generate
	mov over,1
	mov reach_bottom,NO
while2:
	cmp over,1
	jne rb0
	cmp reach_bottom,YES
	je rb0
	jmp rb1
rb0:    jmp rb
rb1:
	mov ah,1
	int 16h
	jz key0
	mov ah,0
	int 16h
	mov key,ax
	jmp clk
key0:
	mov key,0
clk:
	clrkey
switch:
	mov ax,key
	cmp ax,ESCA
	je exit50
	cmp ax,HOME
	je hom
	cmp key,ENDA
	je en
	cmp key,3b00h
	je MI
	cmp ax,LEFT
	je movleft
	cmp ax,RIGHT
	je movr
	cmp ax,DOWN
	je movd
	cmp ax,UP
	je revo

	mov ax,MOVE_DOWN
	push ax
	call moveable
	mov ax,1
	sub ax,mable
	mov reach_bottom,ax
	jmp tm
exit50: jmp exit5
revo:   jmp movrevolve
movr:   jmp movright
movd:   jmp movdown
MI:
	mov mess12,1
	jmp while2
HOM:
	mov cx,mess12-mess11
	mov bl,74h
	printstring BOARD_LEFT+6,BOARD_TOP+3,mess11
	mov ah,0
	int 16h
	cmp al,'n'
	je exit50
	call new_game
	mov reach_bottom,YES
	mov current_score,0
	jmp while2
EN:
	mov ah,0
	int 16h
	mov time_set,8
while20:
	jmp while2

movleft:
	mov ax,move_left
	push ax
	call moveable
	cmp mable,YES
	jne while20
	mov ax,move_left
	push ax
	call move
	jmp while2
movright:
	mov ax,move_right
	push ax
	call moveable
	cmp mable,YES
	jne while20
	mov ax,move_right
	push ax
	call move
	jmp while2
movdown:
	mov ax,move_down
	push ax
	call moveable
	cmp mable,YES
	jne rb
	mov ax,move_down
	push ax
	call move
	jmp while2
movrevolve:
	mov ax,revolve
	push ax
	call moveable
	cmp mable,YES
	jne while20
	mov ax,revolve
	push ax
	call move
	jmp while2
tm:
	cmp reach_bottom,1
	je rb;f2
f1:
	mov ah,1
	int 16h
	jnz f2
	mov ax,10
	sub ax,down_speed
	cmp time_set,ax
	ja f2
	cmp time_set,ax
	jb f1
	mov ax,MOVE_DOWN
	push ax
	call move
	mov time_set,0
	jmp while2;f1

f2:
	mov ax,10
	sub ax,down_speed
	cmp time_set,ax
	jb wh
	mov over,0
wh:
	jmp while2
rb:
	call brick_reach_bottom
	call score
	call game_over
	cmp gover,1
	je renew
	jmp do
renew:
	jmp hom
exit5:
	
	pop dx
	pop ds
	mov al,1ch
	mov ah,25h
	int 21h

	clrscr
	opencur
	mov ah,4ch
	int 21h
main endp

show_next proc near
	push bp
	mov bp,sp
	push ax
	push bx
	push cx
	push dx


	cmp word ptr [bp+6],6
	jae stick
	mov ch,0
cl0:
	mov cl,0
judge:
	mov al,3
	mul ch
	add al,cl
	cbw
	mov bx,[bp+6]
	xchg ax,bx
	mov dl,6
	mul dl
	add bx,ax
	cmp brick_set[bx],0
	je cl1
	mov al,cl
	shl al,1
	add al,NEXT_LEFT+5
	mov ah,ch
	add ah,NEXT_TOP
	add ah,4
	gotoxy al,ah
	mov bx,[bp+4]
	block bl
cl1:
	inc cl
	cmp cl,3
	jb judge
	inc ch
	cmp ch,2
	jb cl0
	jmp exit
stick:
	mov cl,0
cir:
	mov al,cl
	shl al,1
	add al,NEXT_LEFT+4
	gotoxy al,NEXT_TOP+4
	mov bx,[bp+4]
	block bl
	inc cl
	cmp cl,4
	jb cir
exit:
	pop dx
	pop cx
	pop bx
	pop ax
	pop bp
	ret 4
show_next endp

disp_ground proc near
	push ax
	push bx
	push cx
	push dx

	gotoxy 0,0
	mov ah,09h
	mov bh,0
	mov bl,BAR_ATTR
	mov al,' '
	mov cx,80
	int 10h

	mov ah,13h
	mov dh,0
	mov dl,24
	mov cx,mess2-mess1
	mov bh,0
	mov al,0
	mov bl,BAR_ATTR
	lea bp,mess1
	int 10h

	mov dl,0dh
	mov ah,2
	int 21h
	mov dl,0ah
	int 21h

	mov i,1
j0:
	mov j,0
three:
	mov dh,i
	mov al,3
	mul j
	mov dl,al
	mov cx,mess4-mess3
	mov bh,0
	mov al,1
	mov bl,BACKGROUND
	lea bp,mess3
	mov ah,13h
	int 10h
	inc j
	cmp j,27
	jb three
	inc i
	cmp i,24
	jb j0

	gotoxy 0,24
	mov ah,9
	mov bh,0
	mov bl,BAR_ATTR
	mov al,' '
	mov cx,80
	int 10h

	mov ah,13h
	mov dh,24
	mov dl,1
	mov cx,mess3-mess2
	mov bh,0
	mov al,0
	mov bl,BAR_ATTR
	lea bp,mess2
	int 10h

	pop dx
	pop cx
	pop bx
	pop ax
	ret
disp_ground endp

disp_box proc near
	push bp
	mov bp,sp
	pushall

	mov bx,[bp+4]

	mov dx,[bp+12]
	mov ax,[bp+10]
	mov dh,al
	mov x1,dl
	push dx
	inc dl
	mov x2,dl
	mov ax,[bp+8]
	mov t,ax
	add dl,al
	mov x3,dl
	inc dl
	mov x4,dl
	mov y,dh

	pop dx
	mov bh,0
	mov ah,2
	int 10h

	cprintf 0c9h
	gotoxy x2,y
	string 0cdh,t
	gotoxy x3,y
	cprintf 0bbh

	mov cx,[bp+6]
body:
	push cx
	inc y
	gotoxy x1,y
	mov bx,[bp+4]
	cprintf 0bah
	gotoxy x2,y
	string ' ',t
	gotoxy x3,y
	cprintf 0bah
	mov bl,SHADE_ATTR
	mov cx,mess5-mess4
	printstring x4,y,mess4
	pop cx
	loop body

	inc y
	mov bx,[bp+4]
	gotoxy x1,y
	cprintf 0c8h
	gotoxy x2,y
	string 0cdh,t
	gotoxy x3,y
	cprintf 0bch
	mov bl,SHADE_ATTR
	mov cx,mess5-mess4
	printstring x4,y,mess4

	mov ax,t
	add al,2
	mov cl,3
	div cl
	push ax
	mov cl,al
	mov ch,0

	mov dh,y
	inc dh
	mov dl,x1
	add dl,2
sha:
	push cx
	mov cx,mess6-mess5
	push bp
	mov bh,0
	lea bp,mess5
	mov al,1
	mov ah,13h
	int 10h
	add dl,3
	pop bp
	pop cx
	loop sha
	pop ax

	mov cx,mess5-mess4
	inc y
	printstring x4,y,mess4
exit0:
	popall
	pop bp
	ret 10
disp_box endp

game_screen proc near
	pushall

	mov ax,data
	mov ds,ax
	mov es,ax
	call disp_ground

	mov ax,BOARD_LEFT
	push ax
	mov ax,BOARD_TOP
	push ax
	mov ax,BOARD_WIDTH*2
	push ax
	mov ax,BOARD_HEIGHT
	push ax
	mov ax,7eh;BOARD_ATTR
	push ax
	call disp_box

	mov ax,SCORE_LEFT
	push ax
	mov ax,SCORE_TOP
	push ax
	mov ax,SCORE_WIDTH
	push ax
	mov ax,SCORE_HEIGHT
	push ax
	mov ax,SCORE_ATTR
	push ax
	call disp_box

	mov ax,NEXT_LEFT
	push ax
	mov ax,NEXT_TOP
	push ax
	mov ax,NEXT_WIDTH
	push ax
	mov ax,NEXT_HEIGHT
	push ax
	mov ax,NEXT_ATTR
	push ax
	call disp_box

	mov bl,SCORE_ATTR

	mov cx,mess8-mess7
	printstring SCORE_LEFT+2,SCORE_TOP+1,mess7
	mov cx,mess9-mess8
	printstring SCORE_LEFT+2,SCORE_TOP+3,mess8
	mov cx,mess10-mess9
	printstring SCORE_LEFT+2,SCORE_TOP+5,mess9

	mov bl,NEXT_ATTR

	mov cx,mess11-mess10
	printstring NEXT_LEFT+2,NEXT_TOP+1,mess10

	popall
	ret
game_screen endp

draw proc near
	push bp
	mov bp,sp
	pushall

	mov bx,[bp+4]
	mov al,BOARD_ATTR
	and al,0f0h
	or bl,al
	mov si,bx
	cmp word ptr [bp+6],WALL
	je drawwall
	cmp word ptr [bp+6],BRICK
	je drawbrick

drawwall:
	mov i,0
jsd:
	mov j,0
g0:
	mov ax,0
	mov al,2
	mul j
	add al,BOARD_LEFT+1
	mov cl,i
	add cl,BOARD_TOP+1
	gotoxy al,cl

	mov ax,BOARD_WIDTH+2
	mul i
	add al,j
	mov bx,ax
	mov di,bx
	mov cx,[bp+6]
	cmp array[bx],WALL; cl
	jb next
	block array[bx]
	mov bx,di
next:
	cmp array[bx],EMPTY
	jne j1
	mov bx,si
	string ' ',2
j1:
	inc j
	cmp j,BOARD_WIDTH
	jb g0
	inc i
	cmp i,BOARD_HEIGHT
	jb jsd
	jmp exit1

drawbrick:
	cmp word ptr [bp+4],BOARD_BACK
	jz c
	mov bx,brick_no
	add bl,8
c:
	mov i,-1
d:
	mov j,-1
e:
	mov al,yp
	add al,i
	cmp al,0
	jl j2
	mov al,xp
	add al,j
	cmp al,0