;bounce.asm

.model small
.386
.stack

e       equ     65536
esh     equ     16
n       equ     150


BALL    struc
x       dd      160*e
y       dd      50*e
xf      dd      e*2
yf      dd      e/2
lx      dd      160*e
ly      dd      50*e
c       db      32
pad     db      0,0,0
BALL    ends

.data

r1      dw      0                       ;lower limit           random
r2      dw      99                      ;upper limit           vars
r3      dd      0                       ;seed 1
r4      dd      0                       ;seed 2

b       BALL    n dup (<>)


g       dd      e/8


.code


main    proc

        mov     ax,@data                ;standard segs
        mov     ds,ax
        mov     ax,0A000h
        mov     es,ax

        mov     ah,0
        int     1ah

        shl     ecx,16
        mov     cx,dx
        mov     r3,ecx
        rol     ecx,17
        mov     r4,ecx


        mov     ax,0013h                ;320x200x256
        int     10h

        call    init

m0:
        mov     bx,0
        mov     cx,n
m1:
        push    cx

        mov     eax,b.x[bx]
        mov     b.lx[bx],eax
        mov     eax,b.y[bx]
        mov     b.ly[bx],eax

        mov     eax,b.x[bx]
        add     eax,b.xf[bx]

        cmp     eax,319*e
        jg      m1a
        cmp     eax,0
        jl      m1a
        jmp     m2
m1a:
        neg     b.xf[bx]
        add     eax,b.xf[bx]
m2:
        mov     b.x[bx],eax


        mov     eax,b.yf[bx]
        add     eax,g
        mov     b.yf[bx],eax

        mov     eax,b.y[bx]
        add     eax,b.yf[bx]
        cmp     eax,199*e
        jg      m2a
        cmp     eax,0
        jl      m2a
        jmp     m3
m2a:
        neg     b.yf[bx]
        add     eax,b.yf[bx]
m3:
        mov     b.y[bx],eax






        mov     eax,b.lx[bx]               ;erase last
        sar     eax,esh
        mov     si,ax

        mov     eax,b.ly[bx]
        sar     eax,esh
        mov     di,ax

        mov     dl,0

        call    pset


        mov     eax,b.x[bx]                   ;draw current
        sar     eax,esh
        mov     si,ax

        mov     eax,b.y[bx]
        sar     eax,esh
        mov     di,ax

        mov     dl,b.c[bx]

        call    pset

        add     bx,28
        pop     cx
        loop    m1_bridge
        jmp     m100

m1_bridge:
        jmp     m1

m100:
        mov     dx,3dah                 ;vert wait
VRT:
        in      al,dx
        test    al,8
        jnz     VRT

;        mov     dx,3dah
NoVRT:
        in      al,dx
        test    al,8
        jz      NoVRT


        mov     ah,01h                  ;key waiting?
        int     16h
        jnz     keytest                 ;yeah, xit

        jmp     m0                      ;no, go on


keytest:
        xor     ah,ah                   ;get key
        int     16h


        cmp     al,32
        jne     xit

        call    init
        call    cls
        jmp     m0

xit:
        mov     ax,0003h                ;text mode
        int     10h


        mov     ax,4C00h                ;to DOS
        int     21h
main    endp

cls     proc
        xor     di,di
        xor     eax,eax
        mov     cx,16000
        rep     stosd
        ret
cls     endp

init    proc
        mov     bx,0
        mov     cx,n
init1:
        push    cx

        mov     dword ptr b.y[bx],160*e ;x

        mov     r2,100                  ;y
        call    rnd
        and     ecx,0FFFFh
        shl     ecx,esh
        ;sub     ecx,50*e
        mov     b.y[bx],ecx

        mov     r2,65535
        call    rnd                     ;xf
        xor     ecx,0FFFFh
        shl     ecx,3
        sub     ecx,e*4
        mov     b.xf[bx],ecx

        call    rnd                     ;yf
        xor     ecx,0FFFFh
        shl     ecx,1
        sub     ecx,e
        mov     b.yf[bx],ecx

        mov     dword ptr b.lx[bx],0    ;last x

        mov     dword ptr b.ly[bx],0    ;last y

        mov     r2,32                   ;color
        call    rnd
        add     cl,32
        mov     b.c[bx],cl



        add     bx,28

        pop     cx
        loop    init1_bridge

        ret

init1_bridge:
        jmp     init1
init    endp

pset    proc                            ;call with si=x di=y dl=color
        push    bx
        mov     ax,di
        ;add     ax,yo
        shl     ax,6
        mov     bx,ax
        shl     ax,2
        add     bx,ax
        add     bx,si
        ;add     bx,xo
        ;mov     al,color
        mov     es:[bx],dl
        pop     bx
        ret
pset    endp

rnd     proc    near            ;call w/ r1 = lower limit  r2 = upper limit
        push    ax              ;        r3 = dword seed
        push    dx
        mov     ecx,r4
        xchg    ecx,r3
        mov     r4,ecx
        mov     ecx,r3          ;seed
        add     ecx,r4   ;249d62e4h   ;12345678h   ;249D62E4h   ;
        ror     ecx,9           ;
        mov     r3,ecx          ;new seed

        mov     ax,r2           ;upper
        sub     ax,r1           ; - lower
        mul     cx              ; * seed
        mov     cx,dx           ;whole part
        add     cx,r1           ; + lower

        and     ecx,0FFFFh
        pop     dx
        pop     ax
        ret                     ;return w/ cx = rnd number r1 - r2
rnd     endp


        end     main