home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / SLOGRO.ZIP / FRAC.ASM next >
Encoding:
Assembly Source File  |  1988-11-26  |  7.0 KB  |  214 lines
  1.             PAGE        60,132
  2. ;****************************************************************
  3. ;*                 FRAC.ASM - SLO-GRO FRACTAL Routines          *
  4. ;*                 Devin Cook        10/24/88                   *
  5. ;*                 Mutalation Software Design                   *
  6. ;****************************************************************
  7.  
  8.             TITLE       FRAC.ASM    SLO-GRO Fractal Routines
  9.  
  10. CODE        SEGMENT     BYTE        PUBLIC
  11.             ASSUME      CS:CODE,DS:DSEG;
  12.  
  13.             PUBLIC      INIT_ARRAY,FRAC;
  14.  
  15. INIT_ARRAY  PROC        NEAR
  16.             LEA         BX,ARRAY    ; Point to the array
  17.             MOV         CX,5199     ; Its a big boy!
  18. LOOP1:      MOV         BYTE PTR [BX],0         ; Clear it!
  19.             INC         BX
  20.             LOOP        LOOP1
  21.             SUB         AX,AX       ; Set Pixel 0,0
  22.             MOV         X,AX
  23.             MOV         Y,AX
  24.             CALL        SET_PIX
  25.             RET
  26. INIT_ARRAY  ENDP
  27.                        
  28. FRAC        PROC        NEAR
  29.             PUSH        BP          ; Save BP
  30.             MOV         BP,SP       ; Set up stack frame
  31.  
  32.             SUB         AX,AX
  33.             MOV         LOOPS,AX    ; Save loop count
  34.  
  35. ; Ok, the BS is out of the way, now to pull X & Y off stack.
  36.  
  37. DO_RAND:    CALL        RANDOM      ; Get 0-3 in AL
  38.             MOV         BX,X
  39.             MOV         CX,Y
  40.  
  41.             CMP         AL,0        ; Random 0
  42.             JNZ         NOT_0
  43.             INC         BX          ; X := X + 1
  44.             MOV         X,BX
  45.             JMP         CHK_SZ
  46.  
  47. NOT_0:      CMP         AL,1        ; Random 1
  48.             JNZ         NOT_1
  49.             DEC         BX          ; X := X - 1
  50.             MOV         X,BX
  51.             JMP         CHK_SZ
  52.  
  53. NOT_1:      CMP         AL,2        ; Random 2
  54.             JNZ         NOT_2
  55.             INC         CX          ; Y := Y + 1
  56.             MOV         Y,CX
  57.             JMP         CHK_SZ
  58.  
  59. NOT_2:      DEC         CX          ; Y := Y - 1
  60.             MOV         Y,CX
  61.  
  62. CHK_SZ:     MOV         AX,CX
  63.             MUL         CX
  64.             MOV         CX,AX
  65.             MOV         AX,BX
  66.             MUL         BX
  67.             ADD         AX,CX
  68.             CMP         AX,10000
  69.             JLE         UNDR_10G
  70.             SUB         AX,AX       ; Report its off the map!
  71.             JMP         EXIT
  72.  
  73. UNDR_10G:   MOV         AX,X        ; Check ( X-1 , Y-1 )
  74.             DEC         AX          ;
  75.             MOV         TEMPX,AX    ;
  76.             MOV         AX,Y        ;
  77.             DEC         AX          ;
  78.             MOV         TEMPY,AX    ;
  79.             CALL        CHECK_PIX   ;
  80.             JB          WINNER      ; Bit SET!!
  81.  
  82.             INC         TEMPX       ; Check ( X , Y - 1 );
  83.             CALL        CHECK_PIX   ;
  84.             JB          WINNER      ;
  85.  
  86.             INC         TEMPX       ; Check ( X + 1 , Y - 1 );
  87.             CALL        CHECK_PIX   ;
  88.             JB          WINNER      ;
  89.  
  90.             INC         TEMPY       ; Check ( X + 1 , Y  );
  91.             CALL        CHECK_PIX   ;
  92.             JB          WINNER      ;
  93.  
  94.             DEC         TEMPX       ; Check ( X-1 , Y  );
  95.             DEC         TEMPX       ;
  96.             CALL        CHECK_PIX   ;
  97.             JB          WINNER      ;
  98.  
  99.             INC         TEMPY       ; Check ( X-1 , Y + 1 );
  100.             CALL        CHECK_PIX   ;
  101.             JB          WINNER      ;
  102.  
  103.             INC         TEMPX       ; Check ( X , Y + 1 );
  104.             CALL        CHECK_PIX   ;
  105.             JB          WINNER      ;
  106.  
  107.             INC         TEMPX       ; Check ( X+1 , Y + 1 );
  108.             CALL        CHECK_PIX   ;
  109.             JB          WINNER      ;
  110.  
  111.             INC         LOOPS       ;
  112.             MOV         AX,LOOPS
  113.             CMP         AX,10000    ; Must have trouble!
  114.             MOV         AX,0        ;
  115.             JZ          EXIT
  116.  
  117.             JMP         DO_RAND     ; Loop again!
  118.  
  119. ; Report a hit!
  120. WINNER:
  121.             CALL        SET_PIX     ; Give it a home!
  122.             MOV         AX,1        ; Boolean TRUE
  123.  
  124. EXIT:
  125.             POP         BP
  126.             RET                     ; Remove 2 words from stack
  127.  
  128. FRAC        ENDP
  129.  
  130. ; Check X-Y from TEMPX/TEMPY , sets CARRY flag
  131. CHECK_PIX   PROC        NEAR
  132.  
  133.             MOV         AX,TEMPY    ; Get Y pos
  134.             ADD         AX,101      ; Make it ( 0 - 201 )
  135.             MOV         BL,25       ; # of bytes per line
  136.             MUL         BL          ; ( Y + 101 ) * 25
  137.             ADD         AX,OFFSET ARRAY    ; Add to base address
  138.             MOV         [ADDRS],AX  ; Save the byte addr for later
  139.  
  140.             MOV         AX,TEMPX    ; Get X Pos
  141.             ADD         AX,104      ;
  142.             MOV         DL,8        ;
  143.             DIV         DL          ; ( X + 104 ) / 8
  144.             MOV         CL,AH       ; remainder
  145.             INC         CL          ; + 1  ( Number of shifts to do )
  146.  
  147.             SUB         AH,AH       ;
  148.             MOV         BX,AX       ; Bytes
  149.             ADD         BX,[ADDRS]  ;   + Byte Addr
  150.             MOV         AL,[BX]     ; Get that damn byte finally
  151.  
  152.             ROR          AL,CL      ; Do it finally!
  153.             RET
  154. CHECK_PIX   ENDP
  155.  
  156. ; Set Pixel data at X,Y
  157. SET_PIX     PROC        NEAR
  158.  
  159.             MOV         AX,Y        ; Get Y pos
  160.             ADD         AX,101      ; Make it ( 0 - 201 )
  161.             MOV         BL,25       ; # of bytes per line
  162.             MUL         BL          ; ( Y + 101 ) * 25
  163.             ADD         AX,OFFSET ARRAY    ; Add to base address
  164.             MOV         [ADDRS],AX  ; Save the byte addr for later
  165.  
  166.             MOV         AX,X        ; Get X Pos
  167.             ADD         AX,104      ;
  168.             MOV         DL,8        ;
  169.             DIV         DL          ; ( X + 104 ) / 8
  170.             MOV         CL,AH       ; remainder  ( bit to set! )
  171.  
  172.             SUB         AH,AH       ;
  173.             MOV         BX,AX       ; Bytes
  174.             ADD         BX,[ADDRS]  ;   + Byte Addr
  175.             MOV         AL,[BX]     ; Get that damn byte finally
  176.  
  177.             MOV         DL,1        ;
  178.             SHL         DL,CL       ; Sheft bit to proper position
  179.             OR          AL,DL       ; Set Bit
  180.             MOV         [BX],AL     ; Save Byte
  181.             RET
  182. SET_PIX     ENDP
  183.             
  184.  
  185.  
  186.  
  187.  
  188. ; Return random 0-3 in AX
  189. RANDOM      PROC        NEAR
  190.             MOV         AX,SEED
  191.             MOV         BX,31421
  192.             MUL         BX
  193.             ADD         AX,6927
  194.             MOV         SEED,AX
  195.             MOV         BX,4
  196.             MUL         BX
  197.             MOV         AX,DX
  198.             AND         AX,3        ; Just making sure!!!!
  199.             RET
  200. RANDOM      ENDP
  201.  
  202. CODE        ENDS
  203.  
  204.  
  205. DSEG        SEGMENT     WORD  PUBLIC
  206.             EXTRN       X:WORD,Y:WORD,LOOPS:WORD,SEED:WORD;
  207.             EXTRN       TEMPX:WORD,TEMPY:WORD;
  208. ADDRS       DW          ?
  209. ARRAY       DW          2600 dup (?) ; Array for pixel like data
  210. DSEG        ENDS
  211.  
  212. END
  213.  
  214.