WebSVN – Kolibri OS – Diff – /programs/games/freecell/freecell.ASM


; <--- description --->
; compiler:     FASM 1.50
; name:         FreeCell for MeOS
; version:      1.00
; last update:  21/07/2004
; written by:   Alexandr Gorbovets
; e-mail:       gorsash@mail.ru
 
 
include "macros.inc"
include "lang.inc"
meos_app_start
 
code
   call    randomize
   call    draw_window
 
  wait_event:
    mov     eax, 10
    mcall
 
    cmp     eax, 1           ;   if event == 1
    je      redraw           ;     jump to redraw handler
    cmp     eax, 2           ;   else if event == 2
    je      key              ;     jump to key handler
    cmp     eax, 3           ;   else if event == 3
    je      button           ;     jump to button handler
 
 
    jmp     wait_event  ;else return to the start of main cycle
 
 
  redraw:                    ; redraw event handler
    call    draw_window
    jmp     wait_event
 
 
  key:                       ; key event handler
    mov     eax, 2           ;   get key code
    mcall
 
    jmp     wait_event
 
  button:                    ; button event handler
    mov     eax, 17          ;   get button identifier
    mcall
 
    cmp     ah, 1
    je      exit_app         ;   return if button id != 1
 
    cmp     ah, 1 + 8
    jbe     common_card      ;   if 1 < ah <= 9
 
    cmp     ah, 1 + 8 + 4    ;   if 9 < ah <= 13
    jbe     temp_cell
 
    cmp     ah, 1 + 8 + 8
    jbe     home_cell
 
    cmp     ah, 1 + 8 + 4 + 4 + 1
    je      new_game_button
 
    cmp     ah, 1 + 8 + 4 + 4 + 2
    je      exit_app
 
 
    jmp     wait_event
 
 
  exit_app:
    mov     eax, -1          ;   exit application
    mcall
 
  common_card:
    sub     ah, 2            ;going from number of card to number of column
    mov     [columnclicked], 0
    mov     byte [columnclicked], ah
    call    common_card_click
    jmp     wait_event
 
  temp_cell:
    sub     ah, 2 + 8
    mov     [columnclicked], 0
    mov     byte [columnclicked], ah
    call    temp_cell_click
    jmp     wait_event
 
 
  home_cell:
    sub    ah, 2 + 8 + 4
    mov    [columnclicked], 0
    mov    byte [columnclicked], ah
    call   home_cell_click
    jmp    wait_event
 
  new_game_button:
    call   new_game_click
    jmp    wait_event
 
 
;******************************************************************************
;                            common_card_click(columnclicked)
  common_card_click:
 
                             ; counting code of card, that has been clicked
    mov    eax, [columnclicked]
    mov    [ncolumn], eax
    call   get_row_of_top_card_in_column
    mov    eax, [topcardrow]  ; eax = topcardrow * 8 + columnofselcard
    mov    bl, 8
    mul    bl
    add    eax, [columnclicked]
    add    eax, cards
 
    mov    ebx, 0
    mov    bl, byte [eax]
    mov    [cardclicked], ebx
 
 
    call   get_sel_card_code_and_addr
 
    cmp    [selcardcode], 52
    jb      .something_selected
 
 
    cmp    [cardclicked], 52
    je      .end
 
    mov    [whereisselcard], scCommonCells
    mov    eax, [columnclicked]
    mov    [columnofselcard], eax
    call   draw_window
    jmp    .end
 
 
    .something_selected:
 
 
             ; checking if selected and clicked cards are equivalent
      mov     eax, [selcardcode]
      cmp     [cardclicked], eax
      jne     .not_same_card
 
      mov     [whereisselcard], scNotSelected
      call    draw_window
      jmp     .end
 
    .not_same_card:
 
      cmp     [cardclicked], 52
      jae     .put_in_blank_cell
 
 
      mov     eax, [selcardcode]
      mov     bl, 4
      div     bl
 
      mov     ebx, 0
      mov     bl, ah
      mov     [cardfamily], ebx
 
      mov     ecx, 0
      mov     cl, al
      mov     [cardrange], ecx
 
 
      mov     eax, [cardclicked]
      mov     bl, 4
      div     bl                     ; reminder in ah, quotient in al
 
      mov     ebx, 0
      mov     bl, ah
      mov     [clickedcardfamily], ebx
 
      mov     ecx, 0
      mov     cl, al
      mov     [clickedcardrange], ecx
 
                             ; clickedcardrange must be = cardrange + 1
      mov     eax, [cardrange]
      inc     eax
 
      cmp     [clickedcardrange], eax ; eax is such as needed
      jne     .end
 
 
      cmp     [cardfamily], 1
      ja             .black_card
 
                             ; if selected red card
      cmp     [clickedcardfamily], 1
      jbe     .end             ; if clicked red card (range <= 1) then exit
 
      jmp     .valid_cards
 
    .black_card:
                             ; if selected black card
      cmp     [clickedcardfamily], 1
      ja      .end             ; if clicked black card then exit
 
      jmp     .valid_cards
 
    .valid_cards:
                      ; moving card from its place on clicked card
 
      mov     eax, [columnclicked]
      mov     [ncolumn], eax
      call    get_row_of_top_card_in_column
      mov     eax, [topcardrow]
      inc     eax
 
      mov     bl, 8
      mul     bl
 
      and     eax, $0000FFFF
      add     eax, [columnclicked]
      add     eax, cards
 
      mov     bl, byte [selcardcode]
      mov     byte [eax], bl
 
      mov     eax, [selcardaddr]
      mov     byte [eax], 52
 
      mov     [whereisselcard], scNotSelected
 
      call    draw_window
 
      jmp     .end
 
      .put_in_blank_cell:
 
      mov     eax, cards
      add     eax, [columnclicked]
      mov     bl,  byte [selcardcode]
      mov     byte [eax], bl
 
      mov     eax, [selcardaddr]
      mov     byte [eax], 52
 
      mov     [whereisselcard], scNotSelected
 
      call    draw_window
 
    .end:
 
  ret
 
 
;******************************************************************************
;                            temp_cell_click(columnclicked)
  temp_cell_click:
    call   get_sel_card_code_and_addr
    cmp    [selcardcode], 52
    jb     .something_selected
 
 
    mov    [whereisselcard], scTempCells
    mov    eax, [columnclicked]
    mov    [columnofselcard], eax
    call   draw_window
    jmp    .end
 
    .something_selected:
                             ; checking if selected and clicked cards equivalent
    mov     eax, [columnclicked]
    add     eax, tempcells
 
    mov     ebx, 0
    mov     bl, byte [eax]
    mov     [cardclicked], ebx
 
    mov     eax, [selcardcode]
    cmp     [cardclicked], eax
    jne     .not_same_card
 
    mov     [whereisselcard], scNotSelected
    call    draw_window
 
    .not_same_card:
 
                             ;putting cards in temp cells
 
    mov     eax, [columnclicked]
    add     eax, tempcells
 
    mov     ebx, 0
    mov     bl, byte [eax]
    mov     [cardclicked], ebx
 
 
    cmp     [cardclicked], 52
    jb     .end
                             ; if nothing lay in this cell
                             ; move selected card to temp cell
    mov     eax, [columnclicked]
    add     eax, tempcells
    mov     bl, byte [selcardcode]
    mov     byte [eax], bl
 
    mov     eax, [selcardaddr]
    mov     byte [eax], 52
 
    mov     [whereisselcard], scNotSelected
 
    call    draw_window
 
 
    jmp     .end
 
 
    .end:
 
  ret
 
;******************************************************************************
;                            home_cell_click(column_clicked)
  home_cell_click:
    call    get_sel_card_code_and_addr
 
    mov     eax, [columnclicked]
    add     eax, homecells
 
 
    mov     ebx, 0
    mov     bl, byte [eax]
    mov     [cardclicked], ebx
 
    mov     eax, [selcardcode]
    mov     bl, 4
    div     bl               ; reminder in ah, quotient in al
 
    mov     ebx, 0
    mov     bl, ah
    mov     [cardfamily], ebx
 
    mov     ecx, 0
    mov     cl, al
    mov     [cardrange], ecx
 
 
    cmp     [cardclicked], 52
    jb     .not_blank
                             ; if nothing lay in this cell
    cmp     [cardrange], 0
    jne     .end
                             ; move ace to home
    mov     eax, [columnclicked]
    add     eax, homecells
    mov     bl, byte [selcardcode]
    mov     byte [eax], bl
 
    mov     eax, [selcardaddr]
    mov     byte [eax], 52
 
    mov     [whereisselcard], scNotSelected
 
    call    draw_window
 
 
    jmp     .end
 
    .not_blank:
 
    mov     eax, [cardclicked]
    mov     bl, 4
    div     bl               ; reminder in ah, quotient in al
 
    mov     ebx, 0
    mov     bl, ah
    mov     [clickedcardfamily], ebx
 
    mov     ecx, 0
    mov     cl, al
    mov     [clickedcardrange], ecx
 
    cmp     [cardfamily], ebx
    jne     .end
 
    inc     ecx
    cmp     [cardrange], ecx
    jne     .end
 
                      ; moving card from its place to home with replacing
                      ; of old card in home
    mov     eax, [columnclicked]
    add     eax, homecells
    mov     bl, byte [selcardcode]
    mov     byte [eax], bl
 
    mov     eax, [selcardaddr]
    mov     byte [eax], 52
 
    mov     [whereisselcard], scNotSelected
 
    call    draw_window
 
 
 
    .end:
 
  ret
 
 
;******************************************************************************
  new_game_click:
 
      mov   [i], 0
    .deleting_cards_from_common_cells:
      mov   eax, cards
      add   eax, [i]
      mov   byte [eax], 52
 
 
      inc   [i]
      cmp   [i], 19*8
      jb    .deleting_cards_from_common_cells
 
 
    mov     [i], 0
    .filling_pack:
      mov   eax, pack
      add   eax, [i]
      mov   bl, byte [i]
      mov   byte [eax], bl
 
      inc   [i]
      cmp   [i], 52
      jb    .filling_pack
 
      mov     [i], 0
 
    .putting_cards:
 
      mov   [range], 52
      call  random
      mov   eax, [random_value]
      add   eax, pack
 
      mov   ebx, 0
      mov   bl, byte [eax]
      mov   [randomcard], ebx
 
      mov   eax, [random_value]
      mov   [j], eax
 
      cmp   [randomcard], 52
      jb    .found_card
 
 
      mov   [range], 52
      call  random
      cmp   [random_value], 26
      jae    .decreasing_j
 
    .increasing_j:
      inc   [j]
                             ; j mod 52
      mov   eax, [j]
      mov   edx, 0
      mov   ebx, 52
      div   ebx
      mov   [j], edx
 
 
      mov   eax, [j]
      add   eax, pack
      mov   ebx, 0
      mov   bl, byte [eax]
      mov   [randomcard], ebx
      cmp   [randomcard], 52
      jb    .found_card
 
      jmp  .increasing_j
 
 
    .decreasing_j:
      dec   [j]
                             ; i mod 32
      mov   eax, [j]
      mov   edx, 0
      mov   ebx, 52
      div   ebx
      mov   [j], edx
 
      mov   eax, [j]
      add   eax, pack
      mov   ebx, 0
      mov   bl, byte [eax]
      mov   [randomcard], ebx
      cmp   [randomcard], 52
      jb    .found_card
 
      jmp  .decreasing_j
 
    .found_card:
                             ; putting card from pack
      mov   eax, cards
      add   eax, [i]
      mov   bl, byte [randomcard]
      mov   byte [eax], bl
                             ; deleting card from pack
      mov   eax, pack
      add   eax, [j]
      mov   byte [eax], 52
 
 
      inc   [i]
      cmp   [i], 52
      jb    .putting_cards
 
 
 
 
      mov   [i], 0
    .deleting_cards_from_temp_cells:
      mov   eax, tempcells
      add   eax, [i]
      mov   byte [eax], 52
 
 
      inc   [i]
      cmp   [i], 4
      jb    .deleting_cards_from_temp_cells
 
      mov   [i], 0
    .deleting_cards_from_home_cells:
      mov   eax, homecells
      add   eax, [i]
      mov   byte [eax], 52
 
 
      inc   [i]
      cmp   [i], 4
      jb    .deleting_cards_from_home_cells
 
 
    mov     [whereisselcard], scNotSelected
    call    draw_window
 
 
  ret
 
 
;******************************************************************************
;                       get_sel_card_code_and_addr(): selcardcode, selcardaddr
;                       if nothing selected, then selcardcode is 52
  get_sel_card_code_and_addr:
    cmp     [whereisselcard], scNotSelected
    jne     .something_selected
 
    mov     [selcardcode], 52
    jmp     .end
 
    .something_selected:
    cmp     [whereisselcard], scTempCells
    je      .temp_cells_selected
 
                             ; common cells selected
    mov     eax, [columnofselcard]
    mov     [ncolumn], eax
    call    get_row_of_top_card_in_column
 
 
    mov     eax, [topcardrow]; eax = topcardrow * 8  + columnofselcard
    mov     bl, 8
    mul     bl                       ; result of multiplication in ax
    add     eax, [columnofselcard]
    add     eax, cards
 
 
    mov     [selcardaddr], eax
    xor     ebx, ebx
    mov     bl, byte [eax]
    mov     [selcardcode], ebx
 
    jmp     .end
 
    .temp_cells_selected:
 
    mov     eax, tempcells
    add     eax, [columnofselcard]
    mov     [selcardaddr], eax
    mov     ebx, 0
    mov     bl, byte [eax]
    mov     [selcardcode], ebx
 
    .end:
 
  ret
 
;******************************************************************************
;                            draw_window()
 
  draw_window:
    mov  eax,48  ; get system colors
    mov  ebx,3
    mov  ecx,syscolors
    mov  edx,sizeof.system_colors
    mcall
 
 
    mov     eax, 12          ; start drawing
    mov     ebx, 1
    mcall
 
    mov     eax, 0           ; create and draw the window
    mov     ebx, 100 * 65536 + 8 * cardwidth + 10 + 7 * columnspace
    mov     ecx, 100 * 65536 + 500
    mov     edx, 0x13008000
    mov     edi, title
    mcall
 
    mov     eax, 9           ; getting window info
    mov     ebx, process_info
    mov     ecx, -1          ; we want to know info of our window
    mcall
 
 
    mov     eax, [process_info.box.height]
    mov     [WindowHeight], ax
 
    mov     eax, [process_info.box.width]
    mov     [WindowWidth], ax
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
        ; draw top panel
 
    mov     eax, 13
    mov     ebx, 5
    shl     ebx, 16
    add     bx, word [process_info.box.width]
    sub     bx, 9
    mov     ecx, 22 shl 16 + topbuttonsbarheight - 1
    mov     edx, [syscolors.work_graph]
    mcall
 
                             ; draw button "new game"
 
    mov     eax, 8
    mov     ebx, 5 shl 16 + 80
    mov     ecx, 22 shl 16 + topbuttonsbarheight - 2
    mov     edx, 1 + 8 + 4 + 4 + 1 ;button id
    mov     esi, [syscolors.work_button]
    mcall
 
    mov     eax, 4
    mov     ebx, 20 shl 16 + 22 + topbuttonsbarheight/2 - 4
    mov     ecx, [syscolors.work_button_text]
    mov     edx, new_game
    mov     esi, new_game_len
    mcall
 
 
       ; draw button "exit"
    mov     eax, 8
    mov     ebx, (5 + 85) shl 16 + 80 + 5
    mov     ecx, 22 shl 16 + topbuttonsbarheight - 2
    mov     edx, 1 + 8 + 4 + 4 + 2 ;button id
    mov     esi, [syscolors.work_button]
    mcall
 
    mov     eax, 4
    mov     ebx, (40 + 80) shl 16 + 22 + topbuttonsbarheight/2 - 4
    mov     ecx, [syscolors.work_button_text]
    mov     edx, exit
    mov     esi, exit_len
    mcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                        draw separators between home, temp and common cells
    mov     eax, 13
                   ; horizontal line
    mov     ebx, 5
    shl     ebx, 16
    add     bx,  word [process_info.box.width]
    sub     bx,  9
    mov     ecx, (21 + topbuttonsbarheight + cardheight + columnspace) shl 16+1
 
    mov     edx, [syscolors.work_graph]
    mcall
                  ; verical line
    mov     eax, [process_info.box.width]
    mov     edx, 0
    mov     ecx, 2
    div     ecx
 
    mov     ebx, eax
 
    ;
    shl     ebx, 16
    add     bx,  1
    mov     ecx, (21 + topbuttonsbarheight) shl 16 + cardheight + columnspace
    mov     edx, [syscolors.work_graph]
    mov     eax, 13
    mcall
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                            draw temp buttons
 
    mov     [j], 0           ;counter that loops from 0 to 51
 
    draw_a_temp_card:
 
                             ; code of card must be in ecx
    mov     eax, tempcells
    add     eax, [j]
    xor     ecx, ecx
    mov     cl, byte [eax]   ; placing in cl value from memory
                             ;  with address [tempcells + j] or
                             ;  j-th element of array "tempcells"
 
    mov     [cardcode], ecx
 
    mov     eax, [j]
    xor     edx, edx
    mov     ebx, 8
    div     ebx              ; divsion by 8 (8 columns),
                             ;   so in eax quotient - number of row
                             ;   and in edx remainder -
                             ;   number of column where lay card
 
    mov     [row], eax
    mov     [column], edx
 
    mov     eax, [process_info.box.width]       ; width of window
    sub     eax, 10
    sub     eax, cardwidth
    mov     ebx, 7
    mov     edx, 0
    div     ebx
    mov     ebx, [column]
    mul     ebx
    add     eax, 5
 
    mov     [xpos], eax
 
 
    mov     eax, [row]
    mov     bl, rowsize
    mul     bl
    add     eax, 24 + topbuttonsbarheight
    mov     [ypos], eax
 
                             ; checking, if this card selected
 
    mov     [negativedraw], 0
 
    cmp     [whereisselcard], scTempCells
    jne     .this_temp_cell_isnt_selected
 
    mov     eax, [column]
    cmp     [columnofselcard], eax
    jne     .this_temp_cell_isnt_selected
 
    mov     [negativedraw], 1
 
    .this_temp_cell_isnt_selected:
 
    call    draw_card
 
                             ; define button on place of card
    mov     eax, 8
    mov     ebx, [xpos]
    shl     ebx, 16
    add     bx, cardwidth - 1
    mov     ecx, [ypos]
    shl     ecx, 16
    add     cx, cardheight - 1
    mov     edx, [column]
    add     edx, 01000000000000000000000000000000b + 2 + 8;  button id = column
                                           ; id = 1 reserved as close button
    mcall
 
 
    inc     [j]
    cmp     [j], 4
    jb      draw_a_temp_card
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                            draw home buttons
 mov     [j], 0              ;counter that loops from 0 to 51
 
    draw_a_home_card:
 
 
                             ; code of card must be in ecx
    mov     eax, homecells
    add     eax, [j]
    xor     ecx, ecx
    mov     cl, byte [eax]   ; placing in cl value from memory
                             ;  with address [tempcells + j] or
                             ;  j-th element of array "tempcells"
 
    mov     [cardcode], ecx
 
    mov     eax, [j]
    xor     edx, edx
    mov     ebx, 8
    div     ebx              ; divsion by 8 (8 columns),
                             ;  so in eax quotient - number of row
                             ;  and in edx remainder -
                             ;  number of column where lay card
 
    mov     [row], eax
    mov     [column], edx
 
    mov     eax, [process_info.box.width]       ; width of window
    sub     eax, 10
    sub     eax, cardwidth
    mov     ebx, 7
    mov     edx, 0
    div     ebx
    mov     ebx, [column]
    add     ebx, 4
    mul     ebx
    add     eax, 5
 
    mov     [xpos], eax
 
    mov     eax, [row]
    mov     bl, rowsize
    mul     bl
    add     eax, 24 + topbuttonsbarheight
    mov     [ypos], eax
 
    mov     [negativedraw], 0
 
    call    draw_card
 
                             ; define button on place of card
 
    mov     eax, 8
    mov     ebx, [xpos]
    shl     ebx, 16
    add     bx, cardwidth - 1
    mov     ecx, [ypos]
    shl     ecx, 16
    add     cx, cardheight - 1
    mov     edx, [column]
    add     edx, 01000000000000000000000000000000b + 2 + 8 + 4 ; button id
 
                             ; id = 1 reserved as close button
    mcall
 
 
    inc     [j]
    cmp     [j], 4
    jb       draw_a_home_card
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                            draw common cards
 
    mov     [j], 0           ;counter that loops from 0 to 8 * 19
 
    draw_a_card:
 
 
                             ; code of card must be in ecx
    mov     eax, cards
    add     eax, [j]
    xor     ecx, ecx
    mov     cl, byte [eax]   ; placing in cl value from memory
                             ;  with address [cards + j] or
                             ;  j-th element of array "cards"
;    cmp     ecx, 52          ; if code of card >= 52 then there is no card
;    jae     no_draw
;
;    cmp     ecx, 0           ; if code of card  < 0 then there is no card
;    jb      no_draw
 
    mov     [cardcode], ecx
 
 
 
    mov     eax, [j]
    xor     edx, edx
    mov     ebx, 8
    div     ebx             ; divsion by 8 (8 columns),
                            ;  so in eax quotient - number of row
                            ;  and in edx remainder -
                            ;  number of column where lay card
 
    mov     [row], eax
    mov     [column], edx
 
    mov     eax, [process_info.box.width]       ; width of window
    sub     eax, 10
    sub     eax, cardwidth
    mov     ebx, 7
    mov     edx, 0
    div     ebx
    mov     ebx, [column]
    mul     ebx
    add     eax, 5
 
    mov     [xpos], eax
 
    mov     eax, [row]
    mov     bl, rowsize
    mul     bl
    add     eax, cardheight + 24 + topbuttonsbarheight + columnspace
    mov     [ypos], eax
 
 
    mov     [negativedraw], 0 ;checking, if this is selected card
 
    cmp     [whereisselcard], scCommonCells
    jne     .this_card_isnt_selected
 
    mov     eax, [column]
    cmp     [columnofselcard], eax
    jne     .this_card_isnt_selected
 
 
    mov     eax, [column]
    mov     [ncolumn], eax
    call    get_row_of_top_card_in_column
    mov     eax, [row]
    cmp     [topcardrow], eax
    jne     .this_card_isnt_selected
 
    mov     [negativedraw], 1
 
    .this_card_isnt_selected:
 
    call    draw_card
 
 
 
                             ; now checking if it is top card in its column
                             ; if it does, we'll define button on its place
    mov     eax, [column]
    mov     [ncolumn], eax
    call    get_row_of_top_card_in_column
    mov     eax, [row]
    cmp     [topcardrow], eax
    je       .define_button
 
    cmp     [topcardrow], 0
    jne     .no_define_button
 
    cmp     [row], 0
    jne     .no_define_button
 
 
    .define_button:
    mov     eax, 8
    mov     ebx, [xpos]
    shl     ebx, 16
    add     bx, cardwidth - 1
    mov     ecx, [ypos]
    shl     ecx, 16
    add     cx, cardheight - 1
    mov     edx, [column]
    add     edx, 01000000000000000000000000000000b + 2; button id = column + 2,
                             ; id = 1 reserved as close button
    mcall
 
 
    .no_define_button:
 
    inc     [j]
    cmp     [j], 8 * 19
    jb       draw_a_card
 
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
    mov     eax, 12          ; finish drawing
    mov     ebx, 2
    mcall
 
  ret
 
 
;******************************************************************************
;            get_row_of_top_card_in_column(ncolumn): topcardrow
 
  get_row_of_top_card_in_column:
                             ; number of column in ncolumn
                             ; returns in topcardrow
 
    mov [i], 0               ; i loops from 0 to 1, ... while card i * 8 + ncolumn
                             ; is valid card (0 <= its code < 52)
 
    .cycle:
       xor  eax, eax
       mov  al, 8
       mov  ebx, [i]
       mul  bl
       add  eax, [ncolumn]
       add  eax, cards
       xor  ecx, ecx
       mov  cl, byte [eax]
 
       cmp  ecx, 52
       jae  .endcycle
 
 
       cmp  [i], 18
       ja   .endcycle
 
 
       inc  [i]
 
       jmp  .cycle
 
    .endcycle:
 
      cmp   [i], 0
      je    .dont_dec
 
      dec   [i]
 
    .dont_dec:
 
      mov   eax, [i]
      mov   [topcardrow], eax
  ret
 
 
;******************************************************************************
;                      invert_image_colors(imagetoinvert, sizeofimagetoinvert)
  invert_image_colors:
    mov     [i], 0
 
    .inverting:
    mov     eax, [imagetoinvert]
    add     eax, [i]
 
    mov     bl, byte [eax]
    ;xor     ebx, ebx
    ;add     ebx, 10
    not     ebx
 
    mov     byte [eax], bl
 
 
    inc     [i]
 
    mov     ecx, [sizeofimagetoinvert]
    cmp     [i], ecx
    jb      .inverting
 
    jmp   .later
 
 
    .exit:
      mov  eax, -1
      mcall
 
    .later:
 
 
  ret
 
 
 
;******************************************************************************
;            draw_card(xpos, ypos, cardcode, negativedraw)
; if negativedraw = 1 then card drawn in inverted colors
 
  draw_card: ; draws card with left top corner
                    ; in point ([xpos],[ypos]),
                    ; type of card in [cardcode]
 
    cmp     [cardcode], 52   ; if code of card >= 52 then there is no card
    jae     .no_draw_card
 
 
    cmp     [negativedraw], 1
    jne     .no_invert1
                             ;doing if negativedraw
    mov     [bgcolor], $00000000
    mov     [blackcolor], $00FFFFFF
    mov     [redcolor], $0000FFFF
 
             ;inverting all images
    call invert_all_images
 
    jmp     .colors_selection_done
 
    .no_invert1:
                             ;doing if not negativedraw
    mov     [bgcolor], $00FFFFFF
    mov     [blackcolor], $00000000
    mov     [redcolor], $00FF0000
 
 
    .colors_selection_done:
 
    mov     eax, 13
 
    mov     ebx, [xpos]      ; filling card with bgcolor
                             ; (big background rectangle)
    mov     edx, [bgcolor]
    add     ebx, 2
    shl     ebx, 16
    mov     bx, cardwidth - 4
 
    mov     ecx, [ypos]
    add     ecx, 2
    shl     ecx, 16
    mov     cx, cardheight - 4
    mcall
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
    mov     ebx, [xpos]      ; left black line
    shl     ebx, 16
    mov     bx, 1
 
    mov     ecx, [ypos]
    add     ecx, 5
    shl     ecx, 16
    xor     cx, cx
    mov     cx, cardheight - 2 * radius - 2
    mov     edx, [blackcolor]
    mcall
 
    mov     ebx, [xpos]      ; left white line
    inc     ebx
    shl     ebx, 16
    mov     bx, 1
    mov     edx, [bgcolor]
    mcall
 
    mov     ebx, [xpos]      ; right black line
    add     ebx, cardwidth - 1
    shl     ebx, 16
    mov     bx,  1
    mov     edx, [blackcolor]
    mcall
 
    mov     ebx, [xpos]      ; right white line
    add     ebx, cardwidth - 2
    shl     ebx, 16
    mov     bx, 1
    mov     edx, [bgcolor]
    mcall
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
    mov     ecx, [ypos]      ; top black line
    shl     ecx, 16
    mov     cx, 1
 
    mov     ebx, [xpos]
    add     ebx, 5
    shl     ebx, 16
    mov     bx, cardwidth - 2 * radius - 2
    mov     edx, [blackcolor]
    mcall
 
    mov     ecx, [ypos]      ; top white line
    inc     ecx
    shl     ecx, 16
    mov     cx, 1
    mov     edx, [bgcolor]
    mcall
 
    mov     ecx, [ypos]      ; bottom black line
    add     ecx, cardheight - 1
    shl     ecx, 16
    mov     cx,  1
    mov     edx, [blackcolor]
    mcall
 
    mov     ecx, [ypos]      ; bottom white line
    add     ecx, cardheight - 2
    shl     ecx, 16
    mov     cx, 1
    mov     edx, [bgcolor]
    mcall
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
    mov    eax, 1            ; drawing points
    mov    edx, [blackcolor] ; black color for all pixels
 
    mov    ebx, [xpos]       ; draw top left corner
    mov    ecx, [ypos]
    inc    ebx
    add    ecx, 4
    mcall
 
    dec    ecx
    mcall
 
    dec    ecx
    inc    ebx
    mcall
 
    dec    ecx
    inc    ebx
    mcall
 
    inc    ebx
    mcall
 
    mov    ebx, [xpos]       ;drawing top right corner
    mov    ecx, [ypos]
    add    ebx, cardwidth - 2
    add    ecx, 4
    mcall
 
    dec    ecx
    mcall
 
    dec    ebx
    dec    ecx
    mcall
 
    dec    ebx
    dec    ecx
    mcall
 
    dec    ebx
    mcall
                             ;drawing bottom left corner
    mov    ebx, [xpos]
    mov    ecx, [ypos]
    inc    ebx
    add    ecx, cardheight - 5
    mcall
 
    inc    ecx
    mcall
 
    inc    ebx
    inc    ecx
    mcall
 
    inc    ebx
    inc    ecx
    mcall
 
    inc    ebx
    mcall
                             ;drawing bottom right corner
    mov    ebx, [xpos]
    mov    ecx, [ypos]
    add    ebx, cardwidth - 2
    add    ecx, cardheight - 5
    mcall
 
    inc    ecx
    mcall
 
    dec    ebx
    inc    ecx
    mcall
 
    dec    ebx
    inc    ecx
    mcall
 
    dec    ebx
    mcall
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;   drawing text and images
 
    mov    eax, [cardcode]
    mov    edx, 0
    mov    ebx, 4
    div    ebx
 
    mov    [cardfamily], edx
    mov    [cardrange], eax
 
                     ; counting position of small card image
    mov eax, 7
    mov ecx, 8*65536+8
    mov edx, [xpos]
    add edx, radius
    shl edx, 16
    mov dx, word [ypos]
    add dx, radius + 8
 
 
 
    cmp    [cardfamily], 0
    je     .heart
 
    cmp    [cardfamily], 1
    je     .diamond
 
    cmp    [cardfamily], 2
    je     .club
 
    cmp    [cardfamily], 3
    je     .spade
 
    .heart:
       mov esi, [redcolor]
       mov [color], esi
       mov [imageaddr], heart
       mov [imageflipaddr], heart_updown
 
       mov ebx, heart_small
       mcall
 
       jmp .selnumber
 
    .diamond:
       mov esi, [redcolor]
       mov [color], esi
       mov [imageaddr], diamond
       mov [imageflipaddr], diamond_updown
 
       mov ebx, diamond_small
       mcall
 
       jmp .selnumber
 
    .club:
      mov  esi, [blackcolor]
      mov  [color], esi
      mov  [imageaddr], club
      mov  [imageflipaddr], club_updown
 
      mov ebx, club_small
      mcall
 
      jmp  .selnumber
 
    .spade:
      mov  esi, [blackcolor]
      mov  [color], esi
      mov  [imageaddr], spade
      mov  [imageflipaddr], spade_updown
 
      mov ebx, spade_small
      mcall
 
 
 
    .selnumber:
 
    mov    ebx, [xpos]       ; counting position of text
                             ; in ebx, same for all cards
    add    ebx, radius
    shl    ebx, 16
    mov    bx,  word [ypos]
    add    bx,  radius
 
 
    mov    ecx, [color]
 
 
    cmp    [cardrange], 0
    je     .ace
 
    cmp    [cardrange], 1
    je     .two
 
    cmp    [cardrange], 2
    je     .three
 
    cmp    [cardrange], 3
    je     .four
 
    cmp    [cardrange], 4
    je     .five
 
    cmp    [cardrange], 5
    je     .six
 
    cmp    [cardrange], 6
    je     .seven
 
    cmp    [cardrange], 7
    je     .eight
 
    cmp    [cardrange], 8
    je     .nine
 
    cmp    [cardrange], 9
    je     .ten
 
    cmp    [cardrange], 10
    je     .jack
 
    cmp    [cardrange], 11
    je     .queen
 
    cmp    [cardrange], 12
    je     .king
 
    ;      +-------+-------+-------+
    ;      |   3   |   2   |   3   |   ace   = 1
    ;      +-------+-------+-------+   two   = 2
    ;      |       |       |       |   three = 2 + 1
    ;      +-------+-------+-------+   four  = 3
    ;      |       |   6   |       |   five  = 3 + 1
    ;      +-------+-------+-------+   six   = 3 + 4
    ;      |   5   |       |   5   |   seven = 3 + 4 + 6
    ;      +-------+-------+-------+   eight = 3 + 5
    ;      |   4   |   1   |   4   |   nine  = 3 + 5
    ;      +-------+-------+-------+   ten   = 3 + 5 + 6 + 7
    ;      |   5   |       |   5   |
    ;      +-------+-------+-------+
    ;      |       |   7   |       |   1 means draw_1
    ;      +-------+-------+-------+
    ;      |       |       |       |
    ;      +-------+-------+-------+
    ;      |   3   |   2   |   3   |
    ;      +-------+-------+-------+
 
 
 
    .ace:
      mov  eax, 4
      mov  [s], byte 'A'
      mov  edx, s
      mov  esi, 1
      mcall
 
      call draw_1
      jmp .end
 
    .two:
      mov  eax, 4
      mov  [s], byte '2'
      mov  edx, s
      mov  esi, 1
      mcall
 
      call draw_2
      jmp .end
 
 
    .three:
      mov  eax, 4
      mov  [s], byte '3'
      mov  edx, s
      mov  esi, 1
      mcall
 
      call draw_1
      call draw_2
 
      jmp  .end
 
    .four:
      mov  eax, 4
      mov  [s], byte '4'
      mov  edx, s
      mov  esi, 1
      mcall
 
      call draw_3
      jmp  .end
 
    .five:
      mov  eax, 4
      mov  [s], byte '5'
      mov  edx, s
      mov  esi, 1
      mcall
 
      call draw_1
      call draw_3
 
      jmp  .end
 
    .six:
      mov  eax, 4
      mov  [s], byte '6'
      mov  edx, s
      mov  esi, 1
      mcall
 
      call draw_3
      call draw_4
 
      jmp  .end
 
    .seven:
      mov  eax, 4
      mov  [s], byte '7'
      mov  edx, s
      mov  esi, 1
      mcall
 
      call draw_3
      call draw_4
      call draw_6
 
      jmp  .end
 
    .eight:
      mov  eax, 4
      mov  [s], byte '8'
      mov  edx, s
      mov  esi, 1
      mcall
 
      call draw_3
      call draw_5
 
      jmp  .end
 
    .nine:
      mov  eax, 4
      mov  [s], byte '9'
      mov  edx, s
      mov  esi, 1
      mcall
 
      call draw_3
      call draw_5
      call draw_1
 
      jmp  .end
 
    .ten:
      mov  eax, 4
      mov  [s], word '10'
      mov  edx, s
      mov  esi, 2
      mcall
 
      call draw_3
      call draw_5
      call draw_6
      call draw_7
 
      jmp  .end
 
    .jack:
      mov  eax, 4
      mov  [s], byte 'J'
      mov  edx, s
      mov  esi, 1
      mcall
 
      jmp  .end
 
    .queen:
      mov  eax, 4
      mov  [s], byte 'Q'
      mov  edx, s
      mov  esi, 1
      mcall
 
      jmp  .end
 
    .king:
      mov  eax, 4
      mov  [s], byte 'K'
      mov  edx,s
      mov  esi, 1
      mcall
 
    .end:
 
 
    cmp  [negativedraw], 1
    jne  .no_invert2
 
    call invert_all_images
 
 
    .no_invert2:
    .no_draw_card:
 
  ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                            invert_all_images()
  invert_all_images:
    mov  [sizeofimagetoinvert], 16 * 16 * 3
    mov  [imagetoinvert], heart
    call invert_image_colors
 
    mov  [sizeofimagetoinvert], 16 * 16 * 3
    mov  [imagetoinvert], diamond
    call invert_image_colors
 
    mov  [sizeofimagetoinvert], 16 * 16 * 3
    mov  [imagetoinvert], spade
    call invert_image_colors
 
    mov  [sizeofimagetoinvert], 16 * 16 * 3
    mov  [imagetoinvert], club
    call invert_image_colors
 
 
    mov  [sizeofimagetoinvert], 16 * 16 * 3
    mov  [imagetoinvert], heart_updown
    call invert_image_colors
 
    mov  [sizeofimagetoinvert], 16 * 16 * 3
    mov  [imagetoinvert], diamond_updown
    call invert_image_colors
 
    mov  [sizeofimagetoinvert], 16 * 16 * 3
    mov  [imagetoinvert], spade_updown
    call invert_image_colors
 
    mov  [sizeofimagetoinvert], 16 * 16 * 3
    mov  [imagetoinvert], club_updown
    call invert_image_colors
 
 
    mov  [sizeofimagetoinvert], 8 * 8 * 3
    mov  [imagetoinvert], heart_small
    call invert_image_colors
 
    mov  [sizeofimagetoinvert], 8 * 8 * 3
    mov  [imagetoinvert], diamond_small
    call invert_image_colors
 
    mov  [sizeofimagetoinvert], 8 * 8 * 3
    mov  [imagetoinvert], spade_small
    call invert_image_colors
 
    mov  [sizeofimagetoinvert], 8 * 8 * 3
    mov  [imagetoinvert], club_small
    call invert_image_colors
 
 
 
  ret
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  draw_1:
                             ;draw center image
      mov     ebx, [imageaddr]
      mov     ecx, 16 * 65536 + 16
      mov     edx, [xpos]
      add     edx, cardwidth/2 - 8
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight/2 - 8
      mov      eax, 7
      mcall
  ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
  draw_2:
                             ;draw top image
      mov     ebx, [imageaddr]
      mov     ecx, 16 * 65536 + 16
      mov     edx, [xpos]
      add     edx, 40 - 8
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, margin
      mov     eax, 7
      mcall
                             ;draw bottom image
      mov     ebx, [imageflipaddr]
      mov     edx, [xpos]
      add     edx, cardwidth/2 - 8
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight - 16 - margin
      mov     eax, 7
      mcall
  ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  draw_3:
                             ;draw top left image
      mov     ebx, [imageaddr]
      mov     ecx, 16 * 65536 + 16
      mov     edx, [xpos]
      add     edx, margin
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, margin
      mov     eax, 7
      mcall
                             ;draw bottom left image
      mov     ebx, [imageflipaddr]
      mov     edx, [xpos]
      add     edx, margin
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight - margin - 16
      mov     eax, 7
      mcall
                             ;draw top right image
      mov     ebx, [imageaddr]
      mov     edx, [xpos]
      add     edx, cardwidth - margin - 16
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, margin
      mov     eax, 7
      mcall
                             ;draw bottom right image
      mov     ebx, [imageflipaddr]
      mov     edx, [xpos]
      add     edx, cardwidth - margin - 16
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight - margin - 16
      mov     eax, 7
      mcall
  ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  draw_4:
                             ;draw center left image
      mov     ebx, [imageaddr]
      mov     ecx, 16 * 65536 + 16
      mov     edx, [xpos]
      add     edx, margin
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight/2 - 8
      mov     eax, 7
      mcall
                             ;draw center right image
      mov     edx, [xpos]
      add     edx, cardwidth - margin - 16
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight/2 - 8
      mov     eax, 7
      mcall
  ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  draw_5:
                             ;draw top left image
      mov     ebx, [imageaddr]
      mov     ecx, 16 * 65536 + 16
      mov     edx, [xpos]
      add     edx, margin
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight * 3 / 9
      mov     eax, 7
      mcall
                             ;draw bottom left image
      mov     ebx, [imageflipaddr]
      mov     edx, [xpos]
      add     edx, 16
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight * 5 / 9
      mov     eax, 7
      mcall
                             ;draw top right image
      mov     ebx, [imageaddr]
      mov     edx, [xpos]
      add     edx, cardwidth - margin - 16
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight * 3 / 9
      mov     eax, 7
      mcall
                             ;draw bottom right image
      mov     ebx, [imageflipaddr]
      mov     edx, [xpos]
      add     edx, cardwidth - margin - 16
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight * 5 / 9
      mov     eax, 7
      mcall
  ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  draw_6:
      mov     ebx, [imageaddr]
      mov     ecx, 16 * 65536 + 16
      mov     edx, [xpos]
      add     edx, cardwidth/2 - 8
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight * 2 / 9
      mov     eax, 7
      mcall
  ret
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  draw_7:
      mov     ebx, [imageflipaddr]
      mov     ecx, 16 * 65536 + 16
      mov     edx, [xpos]
      add     edx, cardwidth/2 - 8
      shl     edx, 16
      mov     dx, word [ypos]
      add     dx, cardheight * 6 / 9
      mov     eax, 7
      mcall
  ret
 
 
;******************************************************************************
  randomize:
    push eax
 
    mov  eax, 3
    mcall
 
    mov  ebx, $A59E3F1C
    mul  ebx
    mov  dword [randseed], eax
    pop  eax
  ret
 
 
 
;******************************************************************************
;          function Random(Range): RandomValue
  random:
    push ebx
 
    mov  eax, [randseed]
    mov  edx, 0
    mov  ebx, 7
    div  ebx
 
    cmp  edx, 0
    je   _0
 
    cmp  edx, 1
    je   _1
 
    cmp  edx, 2
    je   _2
 
    cmp  edx, 3
    je   _3
 
    cmp  edx, 4
    je   _4
 
    cmp  edx, 5
    je   _5
 
    cmp  edx, 6
    je   _6
 
    jmp  _end
 
 
    _0:
      ;base := base + 58 + a[8];
      mov  eax, [randseed]
      add  eax, 58
      add  eax, dword [a + 8 * 4]
      mov  [randseed], eax
      jmp  _end;
 
    _1:
      ;base := base + 1 + a[9];
      mov  eax, [randseed]
      add  eax, 1
      add  eax, dword [a + 9 * 4]
      mov  [randseed], eax
      jmp _end;
 
    _2:
      ;base := base + 4 + a[88];
      mov  eax, [randseed]
      add  eax, 4
      add  eax, dword [a + 88 * 4]
      mov  [randseed], eax
      jmp _end;
 
    _3:
      ;randseed := randseed + 79 + a[43];
      mov  eax, [randseed]
      add  eax, 79
      add  eax, dword [a + 43 * 4]
      mov  [randseed], eax
      jmp _end;
 
    _4:
      ;randseed := randseed + 3 + a[12];
      mov  eax, [randseed]
      add  eax, 3
      add  eax, dword [a + 12 * 4]
      mov  [randseed], eax
      jmp _end;
 
    _5:
      ;randseed := randseed + 2 + a[63];
      mov  eax, [randseed]
      add  eax, 2
      add  eax, dword [a + 63 * 4]
      mov  [randseed], eax
      jmp _end;
 
    _6:
      ;randseed := randseed + 151 + a[24];
      mov  eax, [randseed]
      add  eax, 151
      add  eax, dword [a + 24 * 4]
      mov  [randseed], eax
 
      _end:
 
    mov  eax, [randseed]
    mov  edx, eax
    shl  edx, 16
    mov  bx, 100
    div  bx                   ; dx = randseed mod 100
 
    mov  ax, dx               ; ax = randseed mod 100
    mov  bx, 4
    mul  bx                   ; dx:ax = (randseed mod 100) * 4
    and  eax, $0000FFFF
    shr  edx, 16
    and  edx, $FFFF0000
    or   eax, edx
 
    mov  eax, dword [a + eax] ; eax = dword[a + (randseed mod 100) * 4]
                            ; ~ a[randseed mod 100]
    mov  ebx, dword [a + 47 * 4]
    mul  ebx                  ; eax = low(a[randseed mod 100] * a[47])
 
    add  eax, [randseed]
    add  eax, $4AE783A
    mov  [randseed], eax
 
    mov  eax, dword [a + 6 * 4]
    mov  edx, 0
    mov  ebx,  100
    div  ebx
    mov  eax, edx
    mov  ebx, 4
    mul  ebx                  ; eax = (dword [a + 6 * 4] mod 100) * 4 ~ a[6] mod 100
 
 
    mov  eax, dword [a + eax] ; eax = dword [a + (dword [a + 6 * 4] mod 100) * 4
 
                            ; ~ a[a[6] mod 100]
    add  eax, [randseed]
    mov  [random_value], eax
 
    mov  edx, 0
 
    mov  ebx, [range]
    div  ebx
    mov  [random_value], edx
 
    mov  al, [TimesCalled]
    xor  ah, ah
    inc  al
    mov  bl, 100
    div  bl
    mov  [TimesCalled], ah   ; TimesCalled = (TimesCalled + 1 ) mod 100
 
    mov  al, ah
    mov  bl, 4
    mul  bl
    and  eax, $0000FFFF
 
    mov  ebx, [randseed]
    mov  dword [a + eax], ebx ; a[TimesCalled] = randseed
 
    pop  ebx
  ret
 
;******************************************************************************
 
; <--- initialised data --->
if lang eq ru
  title db '®«¨â¥à',0
 
  new_game: db "®¢ ï ¨£à "
  new_game_len = $ - new_game
 
  exit: db "ëå®¤"
  exit_len = $ - exit
 
  s: db "10"
 
else
  title db 'Freecell',0
 
  new_game: db "New game"
  new_game_len = $ - new_game
 
  exit: db "Exit"
  exit_len = $ - exit
 
  s: db "10"
end if
 
  negativedraw db 0          ; for procedure draw_card
 
 
  spade          file 'SPADE.BMP': 54
  spade_updown   file 'SPADEUD.BMP': 54
  spade_small    file 'SPADESML.BMP': 54
 
  club           file 'CLUB.BMP': 54
  club_updown    file 'CLUBUD.BMP': 54
  club_small     file 'CLUBSML.BMP': 54
 
  diamond        file 'DIAM.BMP': 54
  diamond_updown file 'DIAMUD.BMP': 54
  diamond_small  file 'DIAMSML.BMP': 54
 
  heart          file 'HEART.BMP': 54
  heart_updown   file 'HEARTUD.BMP': 54
  heart_small    file 'HEARTSML.BMP': 54
 
 
  scNotSelected = 0
  scCommonCells = 1
  scTempCells = 2
 
 
  whereisselcard  dd scNotSelected
  columnofselcard dd 0       ; if WhereIsSelCard = scGeneralCells
                             ;    then this can be 0 .. 7,
                             ; if scTempCells then - 0 .. 3
                             ; if scNotSelected - no matter
 
  tempcells: times 4 db 52;
  homecells: times 4 db 52 ; maximal card code is 51
  cards:     times 8 * 19 db 52; - %
  pack:      times 52 db ?
 
 
 
udata
  process_info process_information
  syscolors system_colors
 
  WindowHeight rw 1
  WindowWidth rw 1
 
  xpos rd 1
  ypos rd 1
  bgcolor rd 1
  blackcolor rd 1
  redcolor rd 1
 
 
  lastparam rd 1                  ;
 
  randomcard rd 1                ; for new_game_click
 
  columnclicked rd 1             ; used in common_card_click, temp_cell_click,
  cardclicked rd 1               ;    home_cell_click
  clickedcardrange rd 1          ;
  clickedcardfamily rd 1         ;
 
 
  selcardcode rd 1               ; for procedure get_sel_card_code_and_addr
  selcardaddr rd 1               ;
 
  column rd 1                    ; for procedure draw_window
  row rd 1                          ;
 
  imagetoinvert rd 1             ; for procedure invert_image_colors
  sizeofimagetoinvert rd 1       ;
 
  ncolumn rd 1                   ; for procedure get_row_of_top_card_in_column
  topcardrow rd 1                ;
 
 
  color rd 1                     ; for procedue draw_card
  imageaddr rd 1                 ;
  imageflipaddr rd 1             ;
 
  cardcode rd 1                  ; used in differrent procedures
  cardrange rd 1                 ; cardcode = cardrange * 4 + cardfamily
  cardfamily rd 1                ;
 
  a: times 100 rd 1              ; for function Random
  range rd 1                     ;
  random_value rd 1              ;
  randseed rd 1                  ;
  TimesCalled rb 1               ;
 
  j rd 1                         ; number of card (in array cards) drawn now
  i rd 1                         ; used in many procedures of 1-st level
  k rd 1
 
  cardwidth = 80
  cardheight = 120
  radius = 4                     ; not recommended to change
  rowsize = 30                   ; distance between top poins
                                 ;of cards in neighboring rows
  columnspace = 5                ; minimal space between cards
  margin = 14                       ; margin of every card
 
  topbuttonsbarheight = 20
 
 
meos_app_end

Rev 485	Rev 677
1	; <--- description --->	1	; <--- description --->
2	; compiler: FASM 1.50	2	; compiler: FASM 1.50
3	; name: FreeCell for MeOS	3	; name: FreeCell for MeOS
4	; version: 1.00	4	; version: 1.00
5	; last update: 21/07/2004	5	; last update: 21/07/2004
6	; written by: Alexandr Gorbovets	6	; written by: Alexandr Gorbovets
7	; e-mail: gorsash@mail.ru	7	; e-mail: gorsash@mail.ru
8		8
9		9
-		10	include "macros.inc"
10	include "..\..\macros.inc"	11	include "lang.inc"
11	meos_app_start	12	meos_app_start
12		13
13	code	14	code
14	call randomize	15	call randomize
15	call draw_window	16	call draw_window
16		17
17	wait_event:	18	wait_event:
18	mov eax, 10	19	mov eax, 10
19	mcall	20	mcall
20		21
21	cmp eax, 1 ; if event == 1	22	cmp eax, 1 ; if event == 1
22	je redraw ; jump to redraw handler	23	je redraw ; jump to redraw handler
23	cmp eax, 2 ; else if event == 2	24	cmp eax, 2 ; else if event == 2
24	je key ; jump to key handler	25	je key ; jump to key handler
25	cmp eax, 3 ; else if event == 3	26	cmp eax, 3 ; else if event == 3
26	je button ; jump to button handler	27	je button ; jump to button handler
27		28
28		29
29	jmp wait_event ;else return to the start of main cycle	30	jmp wait_event ;else return to the start of main cycle
30		31
31		32
32	redraw: ; redraw event handler	33	redraw: ; redraw event handler
33	call draw_window	34	call draw_window
34	jmp wait_event	35	jmp wait_event
35		36
36		37
37	key: ; key event handler	38	key: ; key event handler
38	mov eax, 2 ; get key code	39	mov eax, 2 ; get key code
39	mcall	40	mcall
40		41
41	jmp wait_event	42	jmp wait_event
42		43
43	button: ; button event handler	44	button: ; button event handler
44	mov eax, 17 ; get button identifier	45	mov eax, 17 ; get button identifier
45	mcall	46	mcall
46		47
47	cmp ah, 1	48	cmp ah, 1
48	je exit_app ; return if button id != 1	49	je exit_app ; return if button id != 1
49		50
50	cmp ah, 1 + 8	51	cmp ah, 1 + 8
51	jbe common_card ; if 1 < ah <= 9	52	jbe common_card ; if 1 < ah <= 9
52		53
53	cmp ah, 1 + 8 + 4 ; if 9 < ah <= 13	54	cmp ah, 1 + 8 + 4 ; if 9 < ah <= 13
54	jbe temp_cell	55	jbe temp_cell
55		56
56	cmp ah, 1 + 8 + 8	57	cmp ah, 1 + 8 + 8
57	jbe home_cell	58	jbe home_cell
58		59
59	cmp ah, 1 + 8 + 4 + 4 + 1	60	cmp ah, 1 + 8 + 4 + 4 + 1
60	je new_game_button	61	je new_game_button
61		62
62	cmp ah, 1 + 8 + 4 + 4 + 2	63	cmp ah, 1 + 8 + 4 + 4 + 2
63	je exit_app	64	je exit_app
64		65
65		66
66	jmp wait_event	67	jmp wait_event
67		68
68		69
69	exit_app:	70	exit_app:
70	mov eax, -1 ; exit application	71	mov eax, -1 ; exit application
71	mcall	72	mcall
72		73
73	common_card:	74	common_card:
74	sub ah, 2 ;going from number of card to number of column	75	sub ah, 2 ;going from number of card to number of column
75	mov [columnclicked], 0	76	mov [columnclicked], 0
76	mov byte [columnclicked], ah	77	mov byte [columnclicked], ah
77	call common_card_click	78	call common_card_click
78	jmp wait_event	79	jmp wait_event
79		80
80	temp_cell:	81	temp_cell:
81	sub ah, 2 + 8	82	sub ah, 2 + 8
82	mov [columnclicked], 0	83	mov [columnclicked], 0
83	mov byte [columnclicked], ah	84	mov byte [columnclicked], ah
84	call temp_cell_click	85	call temp_cell_click
85	jmp wait_event	86	jmp wait_event
86		87
87		88
88	home_cell:	89	home_cell:
89	sub ah, 2 + 8 + 4	90	sub ah, 2 + 8 + 4
90	mov [columnclicked], 0	91	mov [columnclicked], 0
91	mov byte [columnclicked], ah	92	mov byte [columnclicked], ah
92	call home_cell_click	93	call home_cell_click
93	jmp wait_event	94	jmp wait_event
94		95
95	new_game_button:	96	new_game_button:
96	call new_game_click	97	call new_game_click
97	jmp wait_event	98	jmp wait_event
98		99
99		100
100	;******************************************************************************	101	;******************************************************************************
101	; common_card_click(columnclicked)	102	; common_card_click(columnclicked)
102	common_card_click:	103	common_card_click:
103		104
104	; counting code of card, that has been clicked	105	; counting code of card, that has been clicked
105	mov eax, [columnclicked]	106	mov eax, [columnclicked]
106	mov [ncolumn], eax	107	mov [ncolumn], eax
107	call get_row_of_top_card_in_column	108	call get_row_of_top_card_in_column
108	mov eax, [topcardrow] ; eax = topcardrow * 8 + columnofselcard	109	mov eax, [topcardrow] ; eax = topcardrow * 8 + columnofselcard
109	mov bl, 8	110	mov bl, 8
110	mul bl	111	mul bl
111	add eax, [columnclicked]	112	add eax, [columnclicked]
112	add eax, cards	113	add eax, cards
113		114
114	mov ebx, 0	115	mov ebx, 0
115	mov bl, byte [eax]	116	mov bl, byte [eax]
116	mov [cardclicked], ebx	117	mov [cardclicked], ebx
117		118
118		119
119	call get_sel_card_code_and_addr	120	call get_sel_card_code_and_addr
120		121
121	cmp [selcardcode], 52	122	cmp [selcardcode], 52
122	jb .something_selected	123	jb .something_selected
123		124
124		125
125	cmp [cardclicked], 52	126	cmp [cardclicked], 52
126	je .end	127	je .end
127		128
128	mov [whereisselcard], scCommonCells	129	mov [whereisselcard], scCommonCells
129	mov eax, [columnclicked]	130	mov eax, [columnclicked]
130	mov [columnofselcard], eax	131	mov [columnofselcard], eax
131	call draw_window	132	call draw_window
132	jmp .end	133	jmp .end
133		134
134		135
135	.something_selected:	136	.something_selected:
136		137
137		138
138	; checking if selected and clicked cards are equivalent	139	; checking if selected and clicked cards are equivalent
139	mov eax, [selcardcode]	140	mov eax, [selcardcode]
140	cmp [cardclicked], eax	141	cmp [cardclicked], eax
141	jne .not_same_card	142	jne .not_same_card
142		143
143	mov [whereisselcard], scNotSelected	144	mov [whereisselcard], scNotSelected
144	call draw_window	145	call draw_window
145	jmp .end	146	jmp .end
146		147
147	.not_same_card:	148	.not_same_card:
148		149
149	cmp [cardclicked], 52	150	cmp [cardclicked], 52
150	jae .put_in_blank_cell	151	jae .put_in_blank_cell
151		152
152		153
153	mov eax, [selcardcode]	154	mov eax, [selcardcode]
154	mov bl, 4	155	mov bl, 4
155	div bl	156	div bl
156		157
157	mov ebx, 0	158	mov ebx, 0
158	mov bl, ah	159	mov bl, ah
159	mov [cardfamily], ebx	160	mov [cardfamily], ebx
160		161
161	mov ecx, 0	162	mov ecx, 0
162	mov cl, al	163	mov cl, al
163	mov [cardrange], ecx	164	mov [cardrange], ecx
164		165
165		166
166	mov eax, [cardclicked]	167	mov eax, [cardclicked]
167	mov bl, 4	168	mov bl, 4
168	div bl ; reminder in ah, quotient in al	169	div bl ; reminder in ah, quotient in al
169		170
170	mov ebx, 0	171	mov ebx, 0
171	mov bl, ah	172	mov bl, ah
172	mov [clickedcardfamily], ebx	173	mov [clickedcardfamily], ebx
173		174
174	mov ecx, 0	175	mov ecx, 0
175	mov cl, al	176	mov cl, al
176	mov [clickedcardrange], ecx	177	mov [clickedcardrange], ecx
177		178
178	; clickedcardrange must be = cardrange + 1	179	; clickedcardrange must be = cardrange + 1
179	mov eax, [cardrange]	180	mov eax, [cardrange]
180	inc eax	181	inc eax
181		182
182	cmp [clickedcardrange], eax ; eax is such as needed	183	cmp [clickedcardrange], eax ; eax is such as needed
183	jne .end	184	jne .end
184		185
185		186
186	cmp [cardfamily], 1	187	cmp [cardfamily], 1
187	ja .black_card	188	ja .black_card
188		189
189	; if selected red card	190	; if selected red card
190	cmp [clickedcardfamily], 1	191	cmp [clickedcardfamily], 1
191	jbe .end ; if clicked red card (range <= 1) then exit	192	jbe .end ; if clicked red card (range <= 1) then exit
192		193
193	jmp .valid_cards	194	jmp .valid_cards
194		195
195	.black_card:	196	.black_card:
196	; if selected black card	197	; if selected black card
197	cmp [clickedcardfamily], 1	198	cmp [clickedcardfamily], 1
198	ja .end ; if clicked black card then exit	199	ja .end ; if clicked black card then exit
199		200
200	jmp .valid_cards	201	jmp .valid_cards
201		202
202	.valid_cards:	203	.valid_cards:
203	; moving card from its place on clicked card	204	; moving card from its place on clicked card
204		205
205	mov eax, [columnclicked]	206	mov eax, [columnclicked]
206	mov [ncolumn], eax	207	mov [ncolumn], eax
207	call get_row_of_top_card_in_column	208	call get_row_of_top_card_in_column
208	mov eax, [topcardrow]	209	mov eax, [topcardrow]
209	inc eax	210	inc eax
210		211
211	mov bl, 8	212	mov bl, 8
212	mul bl	213	mul bl
213		214
214	and eax, $0000FFFF	215	and eax, $0000FFFF
215	add eax, [columnclicked]	216	add eax, [columnclicked]
216	add eax, cards	217	add eax, cards
217		218
218	mov bl, byte [selcardcode]	219	mov bl, byte [selcardcode]
219	mov byte [eax], bl	220	mov byte [eax], bl
220		221
221	mov eax, [selcardaddr]	222	mov eax, [selcardaddr]
222	mov byte [eax], 52	223	mov byte [eax], 52
223		224
224	mov [whereisselcard], scNotSelected	225	mov [whereisselcard], scNotSelected
225		226
226	call draw_window	227	call draw_window
227		228
228	jmp .end	229	jmp .end
229		230
230	.put_in_blank_cell:	231	.put_in_blank_cell:
231		232
232	mov eax, cards	233	mov eax, cards
233	add eax, [columnclicked]	234	add eax, [columnclicked]
234	mov bl, byte [selcardcode]	235	mov bl, byte [selcardcode]
235	mov byte [eax], bl	236	mov byte [eax], bl
236		237
237	mov eax, [selcardaddr]	238	mov eax, [selcardaddr]
238	mov byte [eax], 52	239	mov byte [eax], 52
239		240
240	mov [whereisselcard], scNotSelected	241	mov [whereisselcard], scNotSelected
241		242
242	call draw_window	243	call draw_window
243		244
244	.end:	245	.end:
245		246
246	ret	247	ret
247		248
248		249
249	;******************************************************************************	250	;******************************************************************************
250	; temp_cell_click(columnclicked)	251	; temp_cell_click(columnclicked)
251	temp_cell_click:	252	temp_cell_click:
252	call get_sel_card_code_and_addr	253	call get_sel_card_code_and_addr
253	cmp [selcardcode], 52	254	cmp [selcardcode], 52
254	jb .something_selected	255	jb .something_selected
255		256
256		257
257	mov [whereisselcard], scTempCells	258	mov [whereisselcard], scTempCells
258	mov eax, [columnclicked]	259	mov eax, [columnclicked]
259	mov [columnofselcard], eax	260	mov [columnofselcard], eax
260	call draw_window	261	call draw_window
261	jmp .end	262	jmp .end
262		263
263	.something_selected:	264	.something_selected:
264	; checking if selected and clicked cards equivalent	265	; checking if selected and clicked cards equivalent
265	mov eax, [columnclicked]	266	mov eax, [columnclicked]
266	add eax, tempcells	267	add eax, tempcells
267		268
268	mov ebx, 0	269	mov ebx, 0
269	mov bl, byte [eax]	270	mov bl, byte [eax]
270	mov [cardclicked], ebx	271	mov [cardclicked], ebx
271		272
272	mov eax, [selcardcode]	273	mov eax, [selcardcode]
273	cmp [cardclicked], eax	274	cmp [cardclicked], eax
274	jne .not_same_card	275	jne .not_same_card
275		276
276	mov [whereisselcard], scNotSelected	277	mov [whereisselcard], scNotSelected
277	call draw_window	278	call draw_window
278		279
279	.not_same_card:	280	.not_same_card:
280		281
281	;putting cards in temp cells	282	;putting cards in temp cells
282		283
283	mov eax, [columnclicked]	284	mov eax, [columnclicked]
284	add eax, tempcells	285	add eax, tempcells
285		286
286	mov ebx, 0	287	mov ebx, 0
287	mov bl, byte [eax]	288	mov bl, byte [eax]
288	mov [cardclicked], ebx	289	mov [cardclicked], ebx
289		290
290		291
291	cmp [cardclicked], 52	292	cmp [cardclicked], 52
292	jb .end	293	jb .end
293	; if nothing lay in this cell	294	; if nothing lay in this cell
294	; move selected card to temp cell	295	; move selected card to temp cell
295	mov eax, [columnclicked]	296	mov eax, [columnclicked]
296	add eax, tempcells	297	add eax, tempcells
297	mov bl, byte [selcardcode]	298	mov bl, byte [selcardcode]
298	mov byte [eax], bl	299	mov byte [eax], bl
299		300
300	mov eax, [selcardaddr]	301	mov eax, [selcardaddr]
301	mov byte [eax], 52	302	mov byte [eax], 52
302		303
303	mov [whereisselcard], scNotSelected	304	mov [whereisselcard], scNotSelected
304		305
305	call draw_window	306	call draw_window
306		307
307		308
308	jmp .end	309	jmp .end
309		310
310		311
311	.end:	312	.end:
312		313
313	ret	314	ret
314		315
315	;******************************************************************************	316	;******************************************************************************
316	; home_cell_click(column_clicked)	317	; home_cell_click(column_clicked)
317	home_cell_click:	318	home_cell_click:
318	call get_sel_card_code_and_addr	319	call get_sel_card_code_and_addr
319		320
320	mov eax, [columnclicked]	321	mov eax, [columnclicked]
321	add eax, homecells	322	add eax, homecells
322		323
323		324
324	mov ebx, 0	325	mov ebx, 0
325	mov bl, byte [eax]	326	mov bl, byte [eax]
326	mov [cardclicked], ebx	327	mov [cardclicked], ebx
327		328
328	mov eax, [selcardcode]	329	mov eax, [selcardcode]
329	mov bl, 4	330	mov bl, 4
330	div bl ; reminder in ah, quotient in al	331	div bl ; reminder in ah, quotient in al
331		332
332	mov ebx, 0	333	mov ebx, 0
333	mov bl, ah	334	mov bl, ah
334	mov [cardfamily], ebx	335	mov [cardfamily], ebx
335		336
336	mov ecx, 0	337	mov ecx, 0
337	mov cl, al	338	mov cl, al
338	mov [cardrange], ecx	339	mov [cardrange], ecx
339		340
340		341
341	cmp [cardclicked], 52	342	cmp [cardclicked], 52
342	jb .not_blank	343	jb .not_blank
343	; if nothing lay in this cell	344	; if nothing lay in this cell
344	cmp [cardrange], 0	345	cmp [cardrange], 0
345	jne .end	346	jne .end
346	; move ace to home	347	; move ace to home
347	mov eax, [columnclicked]	348	mov eax, [columnclicked]
348	add eax, homecells	349	add eax, homecells
349	mov bl, byte [selcardcode]	350	mov bl, byte [selcardcode]
350	mov byte [eax], bl	351	mov byte [eax], bl
351		352
352	mov eax, [selcardaddr]	353	mov eax, [selcardaddr]
353	mov byte [eax], 52	354	mov byte [eax], 52
354		355
355	mov [whereisselcard], scNotSelected	356	mov [whereisselcard], scNotSelected
356		357
357	call draw_window	358	call draw_window
358		359
359		360
360	jmp .end	361	jmp .end
361		362
362	.not_blank:	363	.not_blank:
363		364
364	mov eax, [cardclicked]	365	mov eax, [cardclicked]
365	mov bl, 4	366	mov bl, 4
366	div bl ; reminder in ah, quotient in al	367	div bl ; reminder in ah, quotient in al
367		368
368	mov ebx, 0	369	mov ebx, 0
369	mov bl, ah	370	mov bl, ah
370	mov [clickedcardfamily], ebx	371	mov [clickedcardfamily], ebx
371		372
372	mov ecx, 0	373	mov ecx, 0
373	mov cl, al	374	mov cl, al
374	mov [clickedcardrange], ecx	375	mov [clickedcardrange], ecx
375		376
376	cmp [cardfamily], ebx	377	cmp [cardfamily], ebx
377	jne .end	378	jne .end
378		379
379	inc ecx	380	inc ecx
380	cmp [cardrange], ecx	381	cmp [cardrange], ecx
381	jne .end	382	jne .end
382		383
383	; moving card from its place to home with replacing	384	; moving card from its place to home with replacing
384	; of old card in home	385	; of old card in home
385	mov eax, [columnclicked]	386	mov eax, [columnclicked]
386	add eax, homecells	387	add eax, homecells
387	mov bl, byte [selcardcode]	388	mov bl, byte [selcardcode]
388	mov byte [eax], bl	389	mov byte [eax], bl
389		390
390	mov eax, [selcardaddr]	391	mov eax, [selcardaddr]
391	mov byte [eax], 52	392	mov byte [eax], 52
392		393
393	mov [whereisselcard], scNotSelected	394	mov [whereisselcard], scNotSelected
394		395
395	call draw_window	396	call draw_window
396		397
397		398
398		399
399	.end:	400	.end:
400		401
401	ret	402	ret
402		403
403		404
404	;******************************************************************************	405	;******************************************************************************
405	new_game_click:	406	new_game_click:
406		407
407	mov [i], 0	408	mov [i], 0
408	.deleting_cards_from_common_cells:	409	.deleting_cards_from_common_cells:
409	mov eax, cards	410	mov eax, cards
410	add eax, [i]	411	add eax, [i]
411	mov byte [eax], 52	412	mov byte [eax], 52
412		413
413		414
414	inc [i]	415	inc [i]
415	cmp [i], 19*8	416	cmp [i], 19*8
416	jb .deleting_cards_from_common_cells	417	jb .deleting_cards_from_common_cells
417		418
418		419
419	mov [i], 0	420	mov [i], 0
420	.filling_pack:	421	.filling_pack:
421	mov eax, pack	422	mov eax, pack
422	add eax, [i]	423	add eax, [i]
423	mov bl, byte [i]	424	mov bl, byte [i]
424	mov byte [eax], bl	425	mov byte [eax], bl
425		426
426	inc [i]	427	inc [i]
427	cmp [i], 52	428	cmp [i], 52
428	jb .filling_pack	429	jb .filling_pack
429		430
430	mov [i], 0	431	mov [i], 0
431		432
432	.putting_cards:	433	.putting_cards:
433		434
434	mov [range], 52	435	mov [range], 52
435	call random	436	call random
436	mov eax, [random_value]	437	mov eax, [random_value]
437	add eax, pack	438	add eax, pack
438		439
439	mov ebx, 0	440	mov ebx, 0
440	mov bl, byte [eax]	441	mov bl, byte [eax]
441	mov [randomcard], ebx	442	mov [randomcard], ebx
442		443
443	mov eax, [random_value]	444	mov eax, [random_value]
444	mov [j], eax	445	mov [j], eax
445		446
446	cmp [randomcard], 52	447	cmp [randomcard], 52
447	jb .found_card	448	jb .found_card
448		449
449		450
450	mov [range], 52	451	mov [range], 52
451	call random	452	call random
452	cmp [random_value], 26	453	cmp [random_value], 26
453	jae .decreasing_j	454	jae .decreasing_j
454		455
455	.increasing_j:	456	.increasing_j:
456	inc [j]	457	inc [j]
457	; j mod 52	458	; j mod 52
458	mov eax, [j]	459	mov eax, [j]
459	mov edx, 0	460	mov edx, 0
460	mov ebx, 52	461	mov ebx, 52
461	div ebx	462	div ebx
462	mov [j], edx	463	mov [j], edx
463		464
464		465
465	mov eax, [j]	466	mov eax, [j]
466	add eax, pack	467	add eax, pack
467	mov ebx, 0	468	mov ebx, 0
468	mov bl, byte [eax]	469	mov bl, byte [eax]
469	mov [randomcard], ebx	470	mov [randomcard], ebx
470	cmp [randomcard], 52	471	cmp [randomcard], 52
471	jb .found_card	472	jb .found_card
472		473
473	jmp .increasing_j	474	jmp .increasing_j
474		475
475		476
476	.decreasing_j:	477	.decreasing_j:
477	dec [j]	478	dec [j]
478	; i mod 32	479	; i mod 32
479	mov eax, [j]	480	mov eax, [j]
480	mov edx, 0	481	mov edx, 0
481	mov ebx, 52	482	mov ebx, 52
482	div ebx	483	div ebx
483	mov [j], edx	484	mov [j], edx
484		485
485	mov eax, [j]	486	mov eax, [j]
486	add eax, pack	487	add eax, pack
487	mov ebx, 0	488	mov ebx, 0
488	mov bl, byte [eax]	489	mov bl, byte [eax]
489	mov [randomcard], ebx	490	mov [randomcard], ebx
490	cmp [randomcard], 52	491	cmp [randomcard], 52
491	jb .found_card	492	jb .found_card
492		493
493	jmp .decreasing_j	494	jmp .decreasing_j
494		495
495	.found_card:	496	.found_card:
496	; putting card from pack	497	; putting card from pack
497	mov eax, cards	498	mov eax, cards
498	add eax, [i]	499	add eax, [i]
499	mov bl, byte [randomcard]	500	mov bl, byte [randomcard]

Subversion Repositories Kolibri OS

(root)/programs/games/freecell/freecell.ASM @ 1728 – Rev 485 → 677