Subversion Repositories Kolibri OS

;

;    MARIO for MENUET

;

;    Compile with fasm

;

use32

           org     0x0

           db     'MENUET01'             ; header

           dd     1                      ; version

           dd     START                  ; program start

           dd     I_END                  ; image size

           dd     MEM                    ; size memory program

           dd     STACKTOP               ; pointer to begin stack pos

           dd     0

           dd     0

res_base        = loadp + 0x36 ; offset on array pixel in BMP file

res_width_px    = 150

res_height_px   = 35

res_line_size   = (res_width_px*3 + 11b) and not 11b ; 150*3 + 2

block_width     = 40

block_height    = 40

block_line_size = block_width * 3

block_img_size  = block_width * block_height * 3

block_draw_size = (block_width shl 16) + block_height ; for sysfn 7

block_count_pixel = block_width * block_height

mario_width     = 50

mario_height    = 70

mario_line_size = mario_width * 3

mario_img_size  = mario_width * mario_height * 3

mario_draw_size = (mario_width shl 16) + mario_height

mario_count_pixel = mario_width * mario_height

wnd_pos_x       = 80

wnd_pos_y       = 20

wnd_header_size = 0x16

wnd_height      = 9*block_height + wnd_header_size

wnd_width       = 12*block_width + 1

START:

    call load_graph

    mov  [marioxy],   dword 300*65536+270

    mov  [leftright], dword 1

    mov  [velocity],  dword 0xff

    call draw_window

sta:

    mov  eax,field

    mov  dword[xxyy], 1*65536 + wnd_header_size

  stl:

    cmp  byte[eax], ' '

    jnz  @f

    mov  ebx,empty

  @@:

    cmp  byte[eax], '1'

    jnz  @f

    mov  ebx,build_1

  @@:

    cmp  byte[eax], '2'

    jnz  @f

    mov  ebx,build_2

  @@:

    cmp  byte[eax], '3'

    jnz  @f

    mov  ebx,build_3

  @@:

    pusha

    mov  edx,[xxyy]

    mov  eax,7           ; display image

    mov  ecx, block_draw_size

    int  0x40

    popa

    add  word [xxyy+2], block_width

    cmp  word [xxyy+2], block_width*12+1

    jnz  .nonewline

    mov  word [xxyy+2], 1

    add  word [xxyy+0], block_height

  .nonewline:

    add  eax,1

    cmp  eax, field.end

    jnz   stl

;  ********* MAIN LOOP ***********

wait_for_event:

    call draw_mario

    mov  eax,11              ; check for event

    int  0x40

    cmp  eax,1

    jz   red

    cmp  eax,2

    jz   key

    cmp  eax,3   ; check pressed button

    jnz  wait_for_event

    mov  eax, -1 ; close this program

    int  0x40

  red:

    mov  [mariomem],dword 0x0

    call draw_window

    jmp  sta

  key:

    mov  [mariomem],dword 0x0

    mov  eax,2   ; ah <- key

    int  0x40

    cmp  ah,176   ; 'left'

    jnz  key1

    mov  byte [leftright],byte 1

  key1:

    cmp  ah,179   ; 'right'

    jnz  key2

    mov  byte [leftright],byte 4

  key2:

    cmp  ah,177   ; 'down'

    jnz  key3

    mov  al,byte [leftright]

    mov  bl,al

    cmp  al,1

    jnz  key31

    mov  bl,2

  key31:

    cmp  al,4

    jnz  key32

    mov  bl,3

  key32:

    mov  byte [leftright],bl

  key3:

    cmp  ah,178   ; 'up'

    jnz  key4

    cmp  [velocity],dword 0xff

    jnz  key4

    mov  [velocity],dword 0x110

  key4:

        ; this code using for fix defects drawing(draw in caption area)

        mov eax,71                                  ;draw caption

        mov ebx,1

        mov ecx,title

        int 0x40

    jmp sta                                         ;draw field

    ;jmp  wait_for_event

load_graph:

    pusha

    ; empty block init  - set in 0x00500f color

    mov  edi,empty

    mov  ecx, block_count_pixel

    mov  eax,0x00500f

    cld

  @@:

    mov  [edi],eax

    add  edi, 3

    loop @b

    mov  [width], block_line_size

    mov  [width_move], block_width/2

    mov  [height_move], block_height/2

    mov  [imul_esi],20*3

    mov  [base], res_base + 3*res_width_px * 34 +3*98-1

    mov  esi,0

    mov  edi,build_1

    call convert

    mov  esi,1

    mov  edi,build_2

    call convert

    ; build_3

    mov  edi,build_3

    mov  esi, res_base + 230*3+3*300*69

    mov  ecx, block_height

  build_3l:

    pusha

    mov  ecx, block_line_size

    cld

    rep  movsb

    popa

    sub  esi,300*3

    add  edi, block_line_size

    loop build_3l

    mov  [width], mario_line_size

    mov  [width_move], mario_width/2

    mov  [height_move], mario_height/2

    mov  [imul_esi],25*3

    mov  [base], res_base + 3*res_width_px*34 + 68

    mov  esi,0

    mov  edi,mario_1

    call convert

    mov  esi,1

    mov  edi,mario_2

    call convert

    mov  esi,2

    mov  edi,mario_3

    call convert

    jmp  mario_mirror

; copy in [edi], image x2

convert:

    imul esi,[imul_esi]

    add  esi,[base] ; loadp+18*3+3*150*34+68

    mov  eax, [width]

    shl  eax, 1 ; *2

    mov  ecx, [height_move]      ;?

  .new_line:

    pusha

    mov  ecx,[width_move]

  .putpix: ; set 4 pixel: edi, edi+3, edi+width, edi+width+3

    mov  eax,[esi]

    mov  [edi+00],ax

    mov  [edi+03],ax

    mov  ebx,[width]

    mov  [edi+ebx],ax

    add  ebx,3

    mov  [edi+ebx],ax

    shr  eax,16

    mov  [edi+02],al

    dec  ebx

    mov  [edi+ebx],al

    mov  [edi+05],al

    add  ebx,3

    mov  [edi+ebx],al

    add  esi,3

    add  edi,6

    loop .putpix

    popa

    sub  esi,res_line_size

    add  edi, eax

    loop .new_line

    ret

imul_esi        dd 0

base            dd 0

width           dd 0

width_move      dd 0

height_move     dd 0

mario_mirror:

    ; mario_green

    mov  edi,mario_green

    mov  ecx, mario_count_pixel

  @@:

    mov  [edi],dword 0x00500f

    add  edi, 3

    loop @b

    ; mario_4 - reverse mario_1

    mov  edi, mario_4

    mov  esi, mario_1 + (mario_width - 1)*3

    mov  ecx, mario_height

  m4l1:

    pusha

    mov  ecx, mario_width

  m4l2:

    mov  eax,[esi]

    mov  [edi],ax

    shr  eax,16

    mov  [edi+2],al

    add  edi,3

    sub  esi,3

    loop m4l2

    popa

    add  esi, mario_width*3

    add  edi, mario_width*3

    loop m4l1

    ; mario_5 - reverse mario_2

    mov  edi, mario_5

    mov  esi, mario_2 + (mario_width - 1)*3

    mov  ecx, mario_height

  m5l1:

    pusha

    mov  ecx, mario_width

  m5l2:

    mov  eax,[esi]

    mov  [edi],ax

    shr  eax,16

    mov  [edi+2],al

    add  edi,3

    sub  esi,3

    loop m5l2

    popa

    add  esi, mario_width*3

    add  edi, mario_width*3

    loop m5l1

    ; mario_6 - reverse mario_3

    mov  edi, mario_6

    mov  esi, mario_3 + (mario_width - 1)*3

    mov  ecx, mario_height

  m6l1:

    pusha

    mov  ecx, mario_width

  m6l2:

    mov  eax,[esi]

    mov  [edi],ax

    shr  eax,16

    mov  [edi+2],al

    add  edi,3

    sub  esi,3

    loop m6l2

    popa

    add  esi, mario_width*3

    add  edi, mario_width*3

    loop m6l1

    popa

    ret

advance_mario:

    pusha

    mov  eax,[marioxy]      ; wherey ?

    and  eax,65535

    add  eax,40+21

    xor  edx,edx

    mov  ebx,40

    div  ebx

    mov  [marioy],eax

    mov  eax,[marioxy]      ; wherex ?

    shr  eax,16

    add  eax,20

    xor  edx,edx

    mov  ebx,40

    div  ebx

    mov  [mariox],eax

    cmp  byte [leftright],byte 1    ; go left

    jnz  noleft

    mov  eax,[marioxy]

    xor  edx,edx

    shr  eax,16

    sub  eax,7

    mov  ebx,40

    div  ebx

    add  eax,field+7*12

    cmp  [eax],byte ' '

    jz   mgoleft

    mov  byte [leftright],byte 2

    jmp  noleft

  mgoleft:

    mov  eax,[marioxy]

    sub  eax,6*65536

    mov  [marioxy],eax

  noleft:

    cmp  byte [leftright],byte 4    ; go right

    jnz  noright

    mov  eax,[marioxy]

    xor  edx,edx

    shr  eax,16

    add  eax,54

    mov  ebx,40

    div  ebx

    add  eax,field+7*12

    cmp  byte [eax],byte ' '

    jz   mgoright

    mov  byte [leftright],byte 3

    jmp  noright

  mgoright:

    mov  eax,[marioxy]

    add  eax,6*65536

    mov  [marioxy],eax

  noright:

    cmp  [velocity],dword 0x100    ; jump up ?

    jbe  nojumpup

    mov  ebx,[velocity]

    sub  ebx,1

    cmp  ebx,0x100

    jnz  no0x100

    mov  [velocity],dword 0xff

    jmp  nojumpup

  no0x100:

    mov  [velocity],ebx

    sub  ebx,0x100-1

    mov  eax,[marioxy]

    sub  ax,bx

    mov  [marioxy],eax

  nojumpup:

    call mario_environment

    cmp  [velocity],dword 0x100    ; jump -> down ?

    jge  nojumpdown

    mov  eax,[marioy]

    cmp  eax,[mario_below]

    jb   yesgd

    mov  [velocity],dword 0xff

    mov  eax,[marioxy]

    mov  eax,[mario_below]

    sub  eax,1

    mov  ebx,40

     mul  ebx

     sub  eax,10

    mov  word [marioxy],ax

    jmp  nojumpdown

  yesgd:

    mov  ebx,[velocity]

    sub  ebx,1

    mov  [velocity],ebx

    mov  eax,[marioxy]

    add  ax,0xff

    sub  ax,bx

    mov  [marioxy],eax

  nojumpdown:

    popa

    ret

marioy dd 0x0

mariox dd 0x0

mario_below dd 5

mario_environment:

     pusha

     mov  eax,[marioy]

     mov  ebx,12

     mul  ebx

     add  eax,[mariox]

     add  eax,field

     cmp  [eax],byte ' '

     jz   me_ok

     mov  eax,[marioy]

     mov  [mario_below],eax

     popa

     ret

   me_ok:

     mov  [mario_below],dword 100

     popa

     ret

mario_delay:

    pusha

    mov  eax,5          ;pause

    mov  ebx,2

    int  0x40

    popa

    ret

draw_mario:

    pusha

    mov  eax,[mariomem]

    cmp  eax,[marioxy]

    jnz  @f

    call mario_delay

    popa

    ret

@@:

    mov  eax,[marioxy]

    mov  [mariomem],eax

    cmp  byte [leftright], 1   ; go left

    jz   m_left

    cmp  byte [leftright], 4   ; go right

    jz   m_right

    cmp  byte [leftright], 2   ; stand left

    jnz  no_r_still

    mov  eax,7

    mov  ebx,mario_green

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call advance_mario

    mov  eax,7

    mov  ebx,mario_1

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call mario_delay

    popa

    ret

  no_r_still:

    cmp  byte [leftright],byte 3   ; stand right

    jnz  no_l_still

    mov  eax,7

    mov  ebx,mario_green

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call advance_mario

    mov  eax,7

    mov  ebx,mario_4

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call mario_delay

  no_l_still:

    popa

    ret

  m_left:

    mov  eax,7

    mov  ebx,mario_green

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call advance_mario

    mov  eax,7

    mov  ebx,mario_1

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call mario_delay

    mov  eax,7

    mov  ebx,mario_green

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call advance_mario

    mov  eax,7

    mov  ebx,mario_2

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call mario_delay

    mov  eax,7

    mov  ebx,mario_green

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call advance_mario

    mov  eax,7

    mov  ebx,mario_3

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call mario_delay

    mov  eax,7

    mov  ebx,mario_green

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call advance_mario

    mov  eax,7

    mov  ebx,mario_2

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call mario_delay

    popa

    ret

  m_right:

    mov  eax,7

    mov  ebx,mario_green

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call advance_mario

    mov  eax,7

    mov  ebx,mario_4

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call mario_delay

    mov  eax,7

    mov  ebx,mario_green

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call advance_mario

    mov  eax,7

    mov  ebx,mario_5

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call mario_delay

    mov  eax,7

    mov  ebx,mario_green

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call advance_mario

    mov  eax,7

    mov  ebx,mario_6

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call mario_delay

    mov  eax,7

    mov  ebx,mario_green

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call advance_mario

    mov  eax,7

    mov  ebx,mario_5

    mov  ecx, mario_draw_size

    mov  edx,[marioxy]

    int  0x40

    call mario_delay

    popa

    ret

draw_window:

    pusha

    mov       eax,12                    ; tell os about redraw

    mov       ebx,1

    int       0x40

    mov       eax,0                     ; define and draw window

    mov       ebx, (wnd_pos_x shl 16) + wnd_width ;80*65536+480+1

    mov       ecx, (wnd_pos_y shl 16) + wnd_height ;20*65536+382

    mov       edx,0x5466AA88   ; 4 type window + title + no draw work space

    mov       edi,title

    int       0x40

    mov       eax,12                    ; tell os about redraw end

    mov       ebx,2

    int       0x40

    popa

    ret

; DATA SECTION

title:

    db 'SUPER MARIO - USE ARROW KEYS', 0

field:

    db  '1          1'

    db  '1          1'

    db  '111      111'

    db  '1          1'

    db  '1          1'

    db  '1  111111  1'

    db  '1          1'

    db  '1          1'

    db  '222222222222'

.end:

xxyy        dd 0x0

marioxy     dd 0x0

mariomem    dd 0x0

leftright   dd 0x0

velocity    dd 0x0

align 16

loadp:

        file 'MARIOALL.BMP'

I_END:

align 0x1000

empty:          rb block_img_size

build_1:        rb block_img_size

build_2:        rb block_img_size

build_3:        rb block_img_size

align 0x1000

mario_1:        rb mario_img_size

mario_2:        rb mario_img_size

mario_3:        rb mario_img_size

mario_4:        rb mario_img_size

mario_5:        rb mario_img_size

mario_6:        rb mario_img_size

mario_green:    rb mario_img_size

        rb 4096

STACKTOP:

MEM: