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

Subversion Repositories Kolibri OS

(root)/programs/games/freecell/freecell.asm – Rev 1728 → 2067