Subversion Repositories Kolibri OS

Rev

Rev 677 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. ; <--- description --->
  2. ; compiler:     FASM 1.50
  3. ; name:         FreeCell for MeOS
  4. ; version:      1.00
  5. ; last update:  21/07/2004
  6. ; written by:   Alexandr Gorbovets
  7. ; e-mail:       gorsash@mail.ru
  8.  
  9.  
  10. include "macros.inc"
  11. include "lang.inc"
  12. meos_app_start
  13.  
  14. code
  15.    call    randomize
  16.    call    draw_window
  17.  
  18.   wait_event:
  19.     mov     eax, 10
  20.     mcall
  21.  
  22.     cmp     eax, 1           ;   if event == 1
  23.     je      redraw           ;     jump to redraw handler
  24.     cmp     eax, 2           ;   else if event == 2
  25.     je      key              ;     jump to key handler
  26.     cmp     eax, 3           ;   else if event == 3
  27.     je      button           ;     jump to button handler
  28.  
  29.  
  30.     jmp     wait_event  ;else return to the start of main cycle
  31.  
  32.  
  33.   redraw:                    ; redraw event handler
  34.     call    draw_window
  35.     jmp     wait_event
  36.  
  37.  
  38.   key:                       ; key event handler
  39.     mov     eax, 2           ;   get key code
  40.     mcall
  41.  
  42.     jmp     wait_event
  43.  
  44.   button:                    ; button event handler
  45.     mov     eax, 17          ;   get button identifier
  46.     mcall
  47.  
  48.     cmp     ah, 1
  49.     je      exit_app         ;   return if button id != 1
  50.  
  51.     cmp     ah, 1 + 8
  52.     jbe     common_card      ;   if 1 < ah <= 9
  53.  
  54.     cmp     ah, 1 + 8 + 4    ;   if 9 < ah <= 13
  55.     jbe     temp_cell
  56.  
  57.     cmp     ah, 1 + 8 + 8
  58.     jbe     home_cell
  59.  
  60.     cmp     ah, 1 + 8 + 4 + 4 + 1
  61.     je      new_game_button
  62.  
  63.     cmp     ah, 1 + 8 + 4 + 4 + 2
  64.     je      exit_app
  65.  
  66.  
  67.     jmp     wait_event
  68.  
  69.  
  70.   exit_app:
  71.     mov     eax, -1          ;   exit application
  72.     mcall
  73.  
  74.   common_card:
  75.     sub     ah, 2            ;going from number of card to number of column
  76.     mov     [columnclicked], 0
  77.     mov     byte [columnclicked], ah
  78.     call    common_card_click
  79.     jmp     wait_event
  80.  
  81.   temp_cell:
  82.     sub     ah, 2 + 8
  83.     mov     [columnclicked], 0
  84.     mov     byte [columnclicked], ah
  85.     call    temp_cell_click
  86.     jmp     wait_event
  87.  
  88.  
  89.   home_cell:
  90.     sub    ah, 2 + 8 + 4
  91.     mov    [columnclicked], 0
  92.     mov    byte [columnclicked], ah
  93.     call   home_cell_click
  94.     jmp    wait_event
  95.  
  96.   new_game_button:
  97.     call   new_game_click
  98.     jmp    wait_event
  99.  
  100.  
  101. ;******************************************************************************
  102. ;                            common_card_click(columnclicked)
  103.   common_card_click:
  104.  
  105.                              ; counting code of card, that has been clicked
  106.     mov    eax, [columnclicked]
  107.     mov    [ncolumn], eax
  108.     call   get_row_of_top_card_in_column
  109.     mov    eax, [topcardrow]  ; eax = topcardrow * 8 + columnofselcard
  110.     mov    bl, 8
  111.     mul    bl
  112.     add    eax, [columnclicked]
  113.     add    eax, cards
  114.  
  115.     mov    ebx, 0
  116.     mov    bl, byte [eax]
  117.     mov    [cardclicked], ebx
  118.  
  119.  
  120.     call   get_sel_card_code_and_addr
  121.  
  122.     cmp    [selcardcode], 52
  123.     jb      .something_selected
  124.  
  125.  
  126.     cmp    [cardclicked], 52
  127.     je      .end
  128.  
  129.     mov    [whereisselcard], scCommonCells
  130.     mov    eax, [columnclicked]
  131.     mov    [columnofselcard], eax
  132.     call   draw_window
  133.     jmp    .end
  134.  
  135.  
  136.     .something_selected:
  137.  
  138.  
  139.              ; checking if selected and clicked cards are equivalent
  140.       mov     eax, [selcardcode]
  141.       cmp     [cardclicked], eax
  142.       jne     .not_same_card
  143.  
  144.       mov     [whereisselcard], scNotSelected
  145.       call    draw_window
  146.       jmp     .end
  147.  
  148.     .not_same_card:
  149.  
  150.       cmp     [cardclicked], 52
  151.       jae     .put_in_blank_cell
  152.  
  153.  
  154.       mov     eax, [selcardcode]
  155.       mov     bl, 4
  156.       div     bl
  157.  
  158.       mov     ebx, 0
  159.       mov     bl, ah
  160.       mov     [cardfamily], ebx
  161.  
  162.       mov     ecx, 0
  163.       mov     cl, al
  164.       mov     [cardrange], ecx
  165.  
  166.  
  167.       mov     eax, [cardclicked]
  168.       mov     bl, 4
  169.       div     bl                     ; reminder in ah, quotient in al
  170.  
  171.       mov     ebx, 0
  172.       mov     bl, ah
  173.       mov     [clickedcardfamily], ebx
  174.  
  175.       mov     ecx, 0
  176.       mov     cl, al
  177.       mov     [clickedcardrange], ecx
  178.  
  179.                              ; clickedcardrange must be = cardrange + 1
  180.       mov     eax, [cardrange]
  181.       inc     eax
  182.  
  183.       cmp     [clickedcardrange], eax ; eax is such as needed
  184.       jne     .end
  185.  
  186.  
  187.       cmp     [cardfamily], 1
  188.       ja             .black_card
  189.  
  190.                              ; if selected red card
  191.       cmp     [clickedcardfamily], 1
  192.       jbe     .end             ; if clicked red card (range <= 1) then exit
  193.  
  194.       jmp     .valid_cards
  195.  
  196.     .black_card:
  197.                              ; if selected black card
  198.       cmp     [clickedcardfamily], 1
  199.       ja      .end             ; if clicked black card then exit
  200.  
  201.       jmp     .valid_cards
  202.  
  203.     .valid_cards:
  204.                       ; moving card from its place on clicked card
  205.  
  206.       mov     eax, [columnclicked]
  207.       mov     [ncolumn], eax
  208.       call    get_row_of_top_card_in_column
  209.       mov     eax, [topcardrow]
  210.       inc     eax
  211.  
  212.       mov     bl, 8
  213.       mul     bl
  214.  
  215.       and     eax, $0000FFFF
  216.       add     eax, [columnclicked]
  217.       add     eax, cards
  218.  
  219.       mov     bl, byte [selcardcode]
  220.       mov     byte [eax], bl
  221.  
  222.       mov     eax, [selcardaddr]
  223.       mov     byte [eax], 52
  224.  
  225.       mov     [whereisselcard], scNotSelected
  226.  
  227.       call    draw_window
  228.  
  229.       jmp     .end
  230.  
  231.       .put_in_blank_cell:
  232.  
  233.       mov     eax, cards
  234.       add     eax, [columnclicked]
  235.       mov     bl,  byte [selcardcode]
  236.       mov     byte [eax], bl
  237.  
  238.       mov     eax, [selcardaddr]
  239.       mov     byte [eax], 52
  240.  
  241.       mov     [whereisselcard], scNotSelected
  242.  
  243.       call    draw_window
  244.  
  245.     .end:
  246.  
  247.   ret
  248.  
  249.  
  250. ;******************************************************************************
  251. ;                            temp_cell_click(columnclicked)
  252.   temp_cell_click:
  253.     call   get_sel_card_code_and_addr
  254.     cmp    [selcardcode], 52
  255.     jb     .something_selected
  256.  
  257.  
  258.     mov    [whereisselcard], scTempCells
  259.     mov    eax, [columnclicked]
  260.     mov    [columnofselcard], eax
  261.     call   draw_window
  262.     jmp    .end
  263.  
  264.     .something_selected:
  265.                              ; checking if selected and clicked cards equivalent
  266.     mov     eax, [columnclicked]
  267.     add     eax, tempcells
  268.  
  269.     mov     ebx, 0
  270.     mov     bl, byte [eax]
  271.     mov     [cardclicked], ebx
  272.  
  273.     mov     eax, [selcardcode]
  274.     cmp     [cardclicked], eax
  275.     jne     .not_same_card
  276.  
  277.     mov     [whereisselcard], scNotSelected
  278.     call    draw_window
  279.  
  280.     .not_same_card:
  281.  
  282.                              ;putting cards in temp cells
  283.  
  284.     mov     eax, [columnclicked]
  285.     add     eax, tempcells
  286.  
  287.     mov     ebx, 0
  288.     mov     bl, byte [eax]
  289.     mov     [cardclicked], ebx
  290.  
  291.  
  292.     cmp     [cardclicked], 52
  293.     jb     .end
  294.                              ; if nothing lay in this cell
  295.                              ; move selected card to temp cell
  296.     mov     eax, [columnclicked]
  297.     add     eax, tempcells
  298.     mov     bl, byte [selcardcode]
  299.     mov     byte [eax], bl
  300.  
  301.     mov     eax, [selcardaddr]
  302.     mov     byte [eax], 52
  303.  
  304.     mov     [whereisselcard], scNotSelected
  305.  
  306.     call    draw_window
  307.  
  308.  
  309.     jmp     .end
  310.  
  311.  
  312.     .end:
  313.  
  314.   ret
  315.  
  316. ;******************************************************************************
  317. ;                            home_cell_click(column_clicked)
  318.   home_cell_click:
  319.     call    get_sel_card_code_and_addr
  320.  
  321.     mov     eax, [columnclicked]
  322.     add     eax, homecells
  323.  
  324.  
  325.     mov     ebx, 0
  326.     mov     bl, byte [eax]
  327.     mov     [cardclicked], ebx
  328.  
  329.     mov     eax, [selcardcode]
  330.     mov     bl, 4
  331.     div     bl               ; reminder in ah, quotient in al
  332.  
  333.     mov     ebx, 0
  334.     mov     bl, ah
  335.     mov     [cardfamily], ebx
  336.  
  337.     mov     ecx, 0
  338.     mov     cl, al
  339.     mov     [cardrange], ecx
  340.  
  341.  
  342.     cmp     [cardclicked], 52
  343.     jb     .not_blank
  344.                              ; if nothing lay in this cell
  345.     cmp     [cardrange], 0
  346.     jne     .end
  347.                              ; move ace to home
  348.     mov     eax, [columnclicked]
  349.     add     eax, homecells
  350.     mov     bl, byte [selcardcode]
  351.     mov     byte [eax], bl
  352.  
  353.     mov     eax, [selcardaddr]
  354.     mov     byte [eax], 52
  355.  
  356.     mov     [whereisselcard], scNotSelected
  357.  
  358.     call    draw_window
  359.  
  360.  
  361.     jmp     .end
  362.  
  363.     .not_blank:
  364.  
  365.     mov     eax, [cardclicked]
  366.     mov     bl, 4
  367.     div     bl               ; reminder in ah, quotient in al
  368.  
  369.     mov     ebx, 0
  370.     mov     bl, ah
  371.     mov     [clickedcardfamily], ebx
  372.  
  373.     mov     ecx, 0
  374.     mov     cl, al
  375.     mov     [clickedcardrange], ecx
  376.  
  377.     cmp     [cardfamily], ebx
  378.     jne     .end
  379.  
  380.     inc     ecx
  381.     cmp     [cardrange], ecx
  382.     jne     .end
  383.  
  384.                       ; moving card from its place to home with replacing
  385.                       ; of old card in home
  386.     mov     eax, [columnclicked]
  387.     add     eax, homecells
  388.     mov     bl, byte [selcardcode]
  389.     mov     byte [eax], bl
  390.  
  391.     mov     eax, [selcardaddr]
  392.     mov     byte [eax], 52
  393.  
  394.     mov     [whereisselcard], scNotSelected
  395.  
  396.     call    draw_window
  397.  
  398.  
  399.  
  400.     .end:
  401.  
  402.   ret
  403.  
  404.  
  405. ;******************************************************************************
  406.   new_game_click:
  407.  
  408.       mov   [i], 0
  409.     .deleting_cards_from_common_cells:
  410.       mov   eax, cards
  411.       add   eax, [i]
  412.       mov   byte [eax], 52
  413.  
  414.  
  415.       inc   [i]
  416.       cmp   [i], 19*8
  417.       jb    .deleting_cards_from_common_cells
  418.  
  419.  
  420.     mov     [i], 0
  421.     .filling_pack:
  422.       mov   eax, pack
  423.       add   eax, [i]
  424.       mov   bl, byte [i]
  425.       mov   byte [eax], bl
  426.  
  427.       inc   [i]
  428.       cmp   [i], 52
  429.       jb    .filling_pack
  430.  
  431.       mov     [i], 0
  432.  
  433.     .putting_cards:
  434.  
  435.       mov   [range], 52
  436.       call  random
  437.       mov   eax, [random_value]
  438.       add   eax, pack
  439.  
  440.       mov   ebx, 0
  441.       mov   bl, byte [eax]
  442.       mov   [randomcard], ebx
  443.  
  444.       mov   eax, [random_value]
  445.       mov   [j], eax
  446.  
  447.       cmp   [randomcard], 52
  448.       jb    .found_card
  449.  
  450.  
  451.       mov   [range], 52
  452.       call  random
  453.       cmp   [random_value], 26
  454.       jae    .decreasing_j
  455.  
  456.     .increasing_j:
  457.       inc   [j]
  458.                              ; j mod 52
  459.       mov   eax, [j]
  460.       mov   edx, 0
  461.       mov   ebx, 52
  462.       div   ebx
  463.       mov   [j], edx
  464.  
  465.  
  466.       mov   eax, [j]
  467.       add   eax, pack
  468.       mov   ebx, 0
  469.       mov   bl, byte [eax]
  470.       mov   [randomcard], ebx
  471.       cmp   [randomcard], 52
  472.       jb    .found_card
  473.  
  474.       jmp  .increasing_j
  475.  
  476.  
  477.     .decreasing_j:
  478.       dec   [j]
  479.                              ; i mod 32
  480.       mov   eax, [j]
  481.       mov   edx, 0
  482.       mov   ebx, 52
  483.       div   ebx
  484.       mov   [j], edx
  485.  
  486.       mov   eax, [j]
  487.       add   eax, pack
  488.       mov   ebx, 0
  489.       mov   bl, byte [eax]
  490.       mov   [randomcard], ebx
  491.       cmp   [randomcard], 52
  492.       jb    .found_card
  493.  
  494.       jmp  .decreasing_j
  495.  
  496.     .found_card:
  497.                              ; putting card from pack
  498.       mov   eax, cards
  499.       add   eax, [i]
  500.       mov   bl, byte [randomcard]
  501.       mov   byte [eax], bl
  502.                              ; deleting card from pack
  503.       mov   eax, pack
  504.       add   eax, [j]
  505.       mov   byte [eax], 52
  506.  
  507.  
  508.       inc   [i]
  509.       cmp   [i], 52
  510.       jb    .putting_cards
  511.  
  512.  
  513.  
  514.  
  515.       mov   [i], 0
  516.     .deleting_cards_from_temp_cells:
  517.       mov   eax, tempcells
  518.       add   eax, [i]
  519.       mov   byte [eax], 52
  520.  
  521.  
  522.       inc   [i]
  523.       cmp   [i], 4
  524.       jb    .deleting_cards_from_temp_cells
  525.  
  526.       mov   [i], 0
  527.     .deleting_cards_from_home_cells:
  528.       mov   eax, homecells
  529.       add   eax, [i]
  530.       mov   byte [eax], 52
  531.  
  532.  
  533.       inc   [i]
  534.       cmp   [i], 4
  535.       jb    .deleting_cards_from_home_cells
  536.  
  537.  
  538.     mov     [whereisselcard], scNotSelected
  539.     call    draw_window
  540.  
  541.  
  542.   ret
  543.  
  544.  
  545. ;******************************************************************************
  546. ;                       get_sel_card_code_and_addr(): selcardcode, selcardaddr
  547. ;                       if nothing selected, then selcardcode is 52
  548.   get_sel_card_code_and_addr:
  549.     cmp     [whereisselcard], scNotSelected
  550.     jne     .something_selected
  551.  
  552.     mov     [selcardcode], 52
  553.     jmp     .end
  554.  
  555.     .something_selected:
  556.     cmp     [whereisselcard], scTempCells
  557.     je      .temp_cells_selected
  558.  
  559.                              ; common cells selected
  560.     mov     eax, [columnofselcard]
  561.     mov     [ncolumn], eax
  562.     call    get_row_of_top_card_in_column
  563.  
  564.  
  565.     mov     eax, [topcardrow]; eax = topcardrow * 8  + columnofselcard
  566.     mov     bl, 8
  567.     mul     bl                       ; result of multiplication in ax
  568.     add     eax, [columnofselcard]
  569.     add     eax, cards
  570.  
  571.  
  572.     mov     [selcardaddr], eax
  573.     xor     ebx, ebx
  574.     mov     bl, byte [eax]
  575.     mov     [selcardcode], ebx
  576.  
  577.     jmp     .end
  578.  
  579.     .temp_cells_selected:
  580.  
  581.     mov     eax, tempcells
  582.     add     eax, [columnofselcard]
  583.     mov     [selcardaddr], eax
  584.     mov     ebx, 0
  585.     mov     bl, byte [eax]
  586.     mov     [selcardcode], ebx
  587.  
  588.     .end:
  589.  
  590.   ret
  591.  
  592. ;******************************************************************************
  593. ;                            draw_window()
  594.  
  595.   draw_window:
  596.     mov  eax,48  ; get system colors
  597.     mov  ebx,3
  598.     mov  ecx,syscolors
  599.     mov  edx,sizeof.system_colors
  600.     mcall
  601.  
  602.  
  603.     mov     eax, 12          ; start drawing
  604.     mov     ebx, 1
  605.     mcall
  606.  
  607.     mov     eax, 0           ; create and draw the window
  608.     mov     ebx, 100 * 65536 + 8 * cardwidth + 10 + 7 * columnspace
  609.     mov     ecx, 100 * 65536 + 500
  610.     mov     edx, 0x13008000
  611.     mov     edi, title
  612.     mcall
  613.  
  614.     mov     eax, 9           ; getting window info
  615.     mov     ebx, process_info
  616.     mov     ecx, -1          ; we want to know info of our window
  617.     mcall
  618.  
  619.  
  620.     mov     eax, [process_info.box.height]
  621.     mov     [WindowHeight], ax
  622.  
  623.     mov     eax, [process_info.box.width]
  624.     mov     [WindowWidth], ax
  625.  
  626. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  627.         ; draw top panel
  628.  
  629.     mov     eax, 13
  630.     mov     ebx, 5
  631.     shl     ebx, 16
  632.     add     bx, word [process_info.box.width]
  633.     sub     bx, 9
  634.     mov     ecx, 22 shl 16 + topbuttonsbarheight - 1
  635.     mov     edx, [syscolors.work_graph]
  636.     mcall
  637.  
  638.                              ; draw button "new game"
  639.  
  640.     mov     eax, 8
  641.     mov     ebx, 5 shl 16 + 80
  642.     mov     ecx, 22 shl 16 + topbuttonsbarheight - 2
  643.     mov     edx, 1 + 8 + 4 + 4 + 1 ;button id
  644.     mov     esi, [syscolors.work_button]
  645.     mcall
  646.  
  647.     mov     eax, 4
  648.     mov     ebx, 20 shl 16 + 22 + topbuttonsbarheight/2 - 4
  649.     mov     ecx, [syscolors.work_button_text]
  650.     mov     edx, new_game
  651.     mov     esi, new_game_len
  652.     mcall
  653.  
  654.  
  655.        ; draw button "exit"
  656.     mov     eax, 8
  657.     mov     ebx, (5 + 85) shl 16 + 80 + 5
  658.     mov     ecx, 22 shl 16 + topbuttonsbarheight - 2
  659.     mov     edx, 1 + 8 + 4 + 4 + 2 ;button id
  660.     mov     esi, [syscolors.work_button]
  661.     mcall
  662.  
  663.     mov     eax, 4
  664.     mov     ebx, (40 + 80) shl 16 + 22 + topbuttonsbarheight/2 - 4
  665.     mov     ecx, [syscolors.work_button_text]
  666.     mov     edx, exit
  667.     mov     esi, exit_len
  668.     mcall
  669. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  670. ;                        draw separators between home, temp and common cells
  671.     mov     eax, 13
  672.                    ; horizontal line
  673.     mov     ebx, 5
  674.     shl     ebx, 16
  675.     add     bx,  word [process_info.box.width]
  676.     sub     bx,  9
  677.     mov     ecx, (21 + topbuttonsbarheight + cardheight + columnspace) shl 16+1
  678.  
  679.     mov     edx, [syscolors.work_graph]
  680.     mcall
  681.                   ; verical line
  682.     mov     eax, [process_info.box.width]
  683.     mov     edx, 0
  684.     mov     ecx, 2
  685.     div     ecx
  686.  
  687.     mov     ebx, eax
  688.  
  689.     ;
  690.     shl     ebx, 16
  691.     add     bx,  1
  692.     mov     ecx, (21 + topbuttonsbarheight) shl 16 + cardheight + columnspace
  693.     mov     edx, [syscolors.work_graph]
  694.     mov     eax, 13
  695.     mcall
  696.  
  697. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  698. ;                            draw temp buttons
  699.  
  700.     mov     [j], 0           ;counter that loops from 0 to 51
  701.  
  702.     draw_a_temp_card:
  703.  
  704.                              ; code of card must be in ecx
  705.     mov     eax, tempcells
  706.     add     eax, [j]
  707.     xor     ecx, ecx
  708.     mov     cl, byte [eax]   ; placing in cl value from memory
  709.                              ;  with address [tempcells + j] or
  710.                              ;  j-th element of array "tempcells"
  711.  
  712.     mov     [cardcode], ecx
  713.  
  714.     mov     eax, [j]
  715.     xor     edx, edx
  716.     mov     ebx, 8
  717.     div     ebx              ; divsion by 8 (8 columns),
  718.                              ;   so in eax quotient - number of row
  719.                              ;   and in edx remainder -
  720.                              ;   number of column where lay card
  721.  
  722.     mov     [row], eax
  723.     mov     [column], edx
  724.  
  725.     mov     eax, [process_info.box.width]       ; width of window
  726.     sub     eax, 10
  727.     sub     eax, cardwidth
  728.     mov     ebx, 7
  729.     mov     edx, 0
  730.     div     ebx
  731.     mov     ebx, [column]
  732.     mul     ebx
  733.     add     eax, 5
  734.  
  735.     mov     [xpos], eax
  736.  
  737.  
  738.     mov     eax, [row]
  739.     mov     bl, rowsize
  740.     mul     bl
  741.     add     eax, 24 + topbuttonsbarheight
  742.     mov     [ypos], eax
  743.  
  744.                              ; checking, if this card selected
  745.  
  746.     mov     [negativedraw], 0
  747.  
  748.     cmp     [whereisselcard], scTempCells
  749.     jne     .this_temp_cell_isnt_selected
  750.  
  751.     mov     eax, [column]
  752.     cmp     [columnofselcard], eax
  753.     jne     .this_temp_cell_isnt_selected
  754.  
  755.     mov     [negativedraw], 1
  756.  
  757.     .this_temp_cell_isnt_selected:
  758.  
  759.     call    draw_card
  760.  
  761.                              ; define button on place of card
  762.     mov     eax, 8
  763.     mov     ebx, [xpos]
  764.     shl     ebx, 16
  765.     add     bx, cardwidth - 1
  766.     mov     ecx, [ypos]
  767.     shl     ecx, 16
  768.     add     cx, cardheight - 1
  769.     mov     edx, [column]
  770.     add     edx, 01000000000000000000000000000000b + 2 + 8;  button id = column
  771.                                            ; id = 1 reserved as close button
  772.     mcall
  773.  
  774.  
  775.     inc     [j]
  776.     cmp     [j], 4
  777.     jb      draw_a_temp_card
  778.  
  779.  
  780. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  781. ;                            draw home buttons
  782.  mov     [j], 0              ;counter that loops from 0 to 51
  783.  
  784.     draw_a_home_card:
  785.  
  786.  
  787.                              ; code of card must be in ecx
  788.     mov     eax, homecells
  789.     add     eax, [j]
  790.     xor     ecx, ecx
  791.     mov     cl, byte [eax]   ; placing in cl value from memory
  792.                              ;  with address [tempcells + j] or
  793.                              ;  j-th element of array "tempcells"
  794.  
  795.     mov     [cardcode], ecx
  796.  
  797.     mov     eax, [j]
  798.     xor     edx, edx
  799.     mov     ebx, 8
  800.     div     ebx              ; divsion by 8 (8 columns),
  801.                              ;  so in eax quotient - number of row
  802.                              ;  and in edx remainder -
  803.                              ;  number of column where lay card
  804.  
  805.     mov     [row], eax
  806.     mov     [column], edx
  807.  
  808.     mov     eax, [process_info.box.width]       ; width of window
  809.     sub     eax, 10
  810.     sub     eax, cardwidth
  811.     mov     ebx, 7
  812.     mov     edx, 0
  813.     div     ebx
  814.     mov     ebx, [column]
  815.     add     ebx, 4
  816.     mul     ebx
  817.     add     eax, 5
  818.  
  819.     mov     [xpos], eax
  820.  
  821.     mov     eax, [row]
  822.     mov     bl, rowsize
  823.     mul     bl
  824.     add     eax, 24 + topbuttonsbarheight
  825.     mov     [ypos], eax
  826.  
  827.     mov     [negativedraw], 0
  828.  
  829.     call    draw_card
  830.  
  831.                              ; define button on place of card
  832.  
  833.     mov     eax, 8
  834.     mov     ebx, [xpos]
  835.     shl     ebx, 16
  836.     add     bx, cardwidth - 1
  837.     mov     ecx, [ypos]
  838.     shl     ecx, 16
  839.     add     cx, cardheight - 1
  840.     mov     edx, [column]
  841.     add     edx, 01000000000000000000000000000000b + 2 + 8 + 4 ; button id
  842.  
  843.                              ; id = 1 reserved as close button
  844.     mcall
  845.  
  846.  
  847.     inc     [j]
  848.     cmp     [j], 4
  849.     jb       draw_a_home_card
  850.  
  851.  
  852. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  853. ;                            draw common cards
  854.  
  855.     mov     [j], 0           ;counter that loops from 0 to 8 * 19
  856.  
  857.     draw_a_card:
  858.  
  859.  
  860.                              ; code of card must be in ecx
  861.     mov     eax, cards
  862.     add     eax, [j]
  863.     xor     ecx, ecx
  864.     mov     cl, byte [eax]   ; placing in cl value from memory
  865.                              ;  with address [cards + j] or
  866.                              ;  j-th element of array "cards"
  867. ;    cmp     ecx, 52          ; if code of card >= 52 then there is no card
  868. ;    jae     no_draw
  869. ;
  870. ;    cmp     ecx, 0           ; if code of card  < 0 then there is no card
  871. ;    jb      no_draw
  872.  
  873.     mov     [cardcode], ecx
  874.  
  875.  
  876.  
  877.     mov     eax, [j]
  878.     xor     edx, edx
  879.     mov     ebx, 8
  880.     div     ebx             ; divsion by 8 (8 columns),
  881.                             ;  so in eax quotient - number of row
  882.                             ;  and in edx remainder -
  883.                             ;  number of column where lay card
  884.  
  885.     mov     [row], eax
  886.     mov     [column], edx
  887.  
  888.     mov     eax, [process_info.box.width]       ; width of window
  889.     sub     eax, 10
  890.     sub     eax, cardwidth
  891.     mov     ebx, 7
  892.     mov     edx, 0
  893.     div     ebx
  894.     mov     ebx, [column]
  895.     mul     ebx
  896.     add     eax, 5
  897.  
  898.     mov     [xpos], eax
  899.  
  900.     mov     eax, [row]
  901.     mov     bl, rowsize
  902.     mul     bl
  903.     add     eax, cardheight + 24 + topbuttonsbarheight + columnspace
  904.     mov     [ypos], eax
  905.  
  906.  
  907.     mov     [negativedraw], 0 ;checking, if this is selected card
  908.  
  909.     cmp     [whereisselcard], scCommonCells
  910.     jne     .this_card_isnt_selected
  911.  
  912.     mov     eax, [column]
  913.     cmp     [columnofselcard], eax
  914.     jne     .this_card_isnt_selected
  915.  
  916.  
  917.     mov     eax, [column]
  918.     mov     [ncolumn], eax
  919.     call    get_row_of_top_card_in_column
  920.     mov     eax, [row]
  921.     cmp     [topcardrow], eax
  922.     jne     .this_card_isnt_selected
  923.  
  924.     mov     [negativedraw], 1
  925.  
  926.     .this_card_isnt_selected:
  927.  
  928.     call    draw_card
  929.  
  930.  
  931.  
  932.                              ; now checking if it is top card in its column
  933.                              ; if it does, we'll define button on its place
  934.     mov     eax, [column]
  935.     mov     [ncolumn], eax
  936.     call    get_row_of_top_card_in_column
  937.     mov     eax, [row]
  938.     cmp     [topcardrow], eax
  939.     je       .define_button
  940.  
  941.     cmp     [topcardrow], 0
  942.     jne     .no_define_button
  943.  
  944.     cmp     [row], 0
  945.     jne     .no_define_button
  946.  
  947.  
  948.     .define_button:
  949.     mov     eax, 8
  950.     mov     ebx, [xpos]
  951.     shl     ebx, 16
  952.     add     bx, cardwidth - 1
  953.     mov     ecx, [ypos]
  954.     shl     ecx, 16
  955.     add     cx, cardheight - 1
  956.     mov     edx, [column]
  957.     add     edx, 01000000000000000000000000000000b + 2; button id = column + 2,
  958.                              ; id = 1 reserved as close button
  959.     mcall
  960.  
  961.  
  962.     .no_define_button:
  963.  
  964.     inc     [j]
  965.     cmp     [j], 8 * 19
  966.     jb       draw_a_card
  967.  
  968.  
  969.  
  970.  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  971.  
  972.  
  973.     mov     eax, 12          ; finish drawing
  974.     mov     ebx, 2
  975.     mcall
  976.  
  977.   ret
  978.  
  979.  
  980. ;******************************************************************************
  981. ;            get_row_of_top_card_in_column(ncolumn): topcardrow
  982.  
  983.   get_row_of_top_card_in_column:
  984.                              ; number of column in ncolumn
  985.                              ; returns in topcardrow
  986.  
  987.     mov [i], 0               ; i loops from 0 to 1, ... while card i * 8 + ncolumn
  988.                              ; is valid card (0 <= its code < 52)
  989.  
  990.     .cycle:
  991.        xor  eax, eax
  992.        mov  al, 8
  993.        mov  ebx, [i]
  994.        mul  bl
  995.        add  eax, [ncolumn]
  996.        add  eax, cards
  997.        xor  ecx, ecx
  998.        mov  cl, byte [eax]
  999.  
  1000.        cmp  ecx, 52
  1001.        jae  .endcycle
  1002.  
  1003.  
  1004.        cmp  [i], 18
  1005.        ja   .endcycle
  1006.  
  1007.  
  1008.        inc  [i]
  1009.  
  1010.        jmp  .cycle
  1011.  
  1012.     .endcycle:
  1013.  
  1014.       cmp   [i], 0
  1015.       je    .dont_dec
  1016.  
  1017.       dec   [i]
  1018.  
  1019.     .dont_dec:
  1020.  
  1021.       mov   eax, [i]
  1022.       mov   [topcardrow], eax
  1023.   ret
  1024.  
  1025.  
  1026. ;******************************************************************************
  1027. ;                      invert_image_colors(imagetoinvert, sizeofimagetoinvert)
  1028.   invert_image_colors:
  1029.     mov     [i], 0
  1030.  
  1031.     .inverting:
  1032.     mov     eax, [imagetoinvert]
  1033.     add     eax, [i]
  1034.  
  1035.     mov     bl, byte [eax]
  1036.     ;xor     ebx, ebx
  1037.     ;add     ebx, 10
  1038.     not     ebx
  1039.  
  1040.     mov     byte [eax], bl
  1041.  
  1042.  
  1043.     inc     [i]
  1044.  
  1045.     mov     ecx, [sizeofimagetoinvert]
  1046.     cmp     [i], ecx
  1047.     jb      .inverting
  1048.  
  1049.     jmp   .later
  1050.  
  1051.  
  1052.     .exit:
  1053.       mov  eax, -1
  1054.       mcall
  1055.  
  1056.     .later:
  1057.  
  1058.  
  1059.   ret
  1060.  
  1061.  
  1062.  
  1063. ;******************************************************************************
  1064. ;            draw_card(xpos, ypos, cardcode, negativedraw)
  1065. ; if negativedraw = 1 then card drawn in inverted colors
  1066.  
  1067.   draw_card: ; draws card with left top corner
  1068.                     ; in point ([xpos],[ypos]),
  1069.                     ; type of card in [cardcode]
  1070.  
  1071.     cmp     [cardcode], 52   ; if code of card >= 52 then there is no card
  1072.     jae     .no_draw_card
  1073.  
  1074.  
  1075.     cmp     [negativedraw], 1
  1076.     jne     .no_invert1
  1077.                              ;doing if negativedraw
  1078.     mov     [bgcolor], $00000000
  1079.     mov     [blackcolor], $00FFFFFF
  1080.     mov     [redcolor], $0000FFFF
  1081.  
  1082.              ;inverting all images
  1083.     call invert_all_images
  1084.  
  1085.     jmp     .colors_selection_done
  1086.  
  1087.     .no_invert1:
  1088.                              ;doing if not negativedraw
  1089.     mov     [bgcolor], $00FFFFFF
  1090.     mov     [blackcolor], $00000000
  1091.     mov     [redcolor], $00FF0000
  1092.  
  1093.  
  1094.     .colors_selection_done:
  1095.  
  1096.     mov     eax, 13
  1097.  
  1098.     mov     ebx, [xpos]      ; filling card with bgcolor
  1099.                              ; (big background rectangle)
  1100.     mov     edx, [bgcolor]
  1101.     add     ebx, 2
  1102.     shl     ebx, 16
  1103.     mov     bx, cardwidth - 4
  1104.  
  1105.     mov     ecx, [ypos]
  1106.     add     ecx, 2
  1107.     shl     ecx, 16
  1108.     mov     cx, cardheight - 4
  1109.     mcall
  1110.  
  1111. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1112.  
  1113.     mov     ebx, [xpos]      ; left black line
  1114.     shl     ebx, 16
  1115.     mov     bx, 1
  1116.  
  1117.     mov     ecx, [ypos]
  1118.     add     ecx, 5
  1119.     shl     ecx, 16
  1120.     xor     cx, cx
  1121.     mov     cx, cardheight - 2 * radius - 2
  1122.     mov     edx, [blackcolor]
  1123.     mcall
  1124.  
  1125.     mov     ebx, [xpos]      ; left white line
  1126.     inc     ebx
  1127.     shl     ebx, 16
  1128.     mov     bx, 1
  1129.     mov     edx, [bgcolor]
  1130.     mcall
  1131.  
  1132.     mov     ebx, [xpos]      ; right black line
  1133.     add     ebx, cardwidth - 1
  1134.     shl     ebx, 16
  1135.     mov     bx,  1
  1136.     mov     edx, [blackcolor]
  1137.     mcall
  1138.  
  1139.     mov     ebx, [xpos]      ; right white line
  1140.     add     ebx, cardwidth - 2
  1141.     shl     ebx, 16
  1142.     mov     bx, 1
  1143.     mov     edx, [bgcolor]
  1144.     mcall
  1145.  
  1146. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1147.  
  1148.     mov     ecx, [ypos]      ; top black line
  1149.     shl     ecx, 16
  1150.     mov     cx, 1
  1151.  
  1152.     mov     ebx, [xpos]
  1153.     add     ebx, 5
  1154.     shl     ebx, 16
  1155.     mov     bx, cardwidth - 2 * radius - 2
  1156.     mov     edx, [blackcolor]
  1157.     mcall
  1158.  
  1159.     mov     ecx, [ypos]      ; top white line
  1160.     inc     ecx
  1161.     shl     ecx, 16
  1162.     mov     cx, 1
  1163.     mov     edx, [bgcolor]
  1164.     mcall
  1165.  
  1166.     mov     ecx, [ypos]      ; bottom black line
  1167.     add     ecx, cardheight - 1
  1168.     shl     ecx, 16
  1169.     mov     cx,  1
  1170.     mov     edx, [blackcolor]
  1171.     mcall
  1172.  
  1173.     mov     ecx, [ypos]      ; bottom white line
  1174.     add     ecx, cardheight - 2
  1175.     shl     ecx, 16
  1176.     mov     cx, 1
  1177.     mov     edx, [bgcolor]
  1178.     mcall
  1179.  
  1180. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1181.  
  1182.     mov    eax, 1            ; drawing points
  1183.     mov    edx, [blackcolor] ; black color for all pixels
  1184.  
  1185.     mov    ebx, [xpos]       ; draw top left corner
  1186.     mov    ecx, [ypos]
  1187.     inc    ebx
  1188.     add    ecx, 4
  1189.     mcall
  1190.  
  1191.     dec    ecx
  1192.     mcall
  1193.  
  1194.     dec    ecx
  1195.     inc    ebx
  1196.     mcall
  1197.  
  1198.     dec    ecx
  1199.     inc    ebx
  1200.     mcall
  1201.  
  1202.     inc    ebx
  1203.     mcall
  1204.  
  1205.     mov    ebx, [xpos]       ;drawing top right corner
  1206.     mov    ecx, [ypos]
  1207.     add    ebx, cardwidth - 2
  1208.     add    ecx, 4
  1209.     mcall
  1210.  
  1211.     dec    ecx
  1212.     mcall
  1213.  
  1214.     dec    ebx
  1215.     dec    ecx
  1216.     mcall
  1217.  
  1218.     dec    ebx
  1219.     dec    ecx
  1220.     mcall
  1221.  
  1222.     dec    ebx
  1223.     mcall
  1224.                              ;drawing bottom left corner
  1225.     mov    ebx, [xpos]
  1226.     mov    ecx, [ypos]
  1227.     inc    ebx
  1228.     add    ecx, cardheight - 5
  1229.     mcall
  1230.  
  1231.     inc    ecx
  1232.     mcall
  1233.  
  1234.     inc    ebx
  1235.     inc    ecx
  1236.     mcall
  1237.  
  1238.     inc    ebx
  1239.     inc    ecx
  1240.     mcall
  1241.  
  1242.     inc    ebx
  1243.     mcall
  1244.                              ;drawing bottom right corner
  1245.     mov    ebx, [xpos]
  1246.     mov    ecx, [ypos]
  1247.     add    ebx, cardwidth - 2
  1248.     add    ecx, cardheight - 5
  1249.     mcall
  1250.  
  1251.     inc    ecx
  1252.     mcall
  1253.  
  1254.     dec    ebx
  1255.     inc    ecx
  1256.     mcall
  1257.  
  1258.     dec    ebx
  1259.     inc    ecx
  1260.     mcall
  1261.  
  1262.     dec    ebx
  1263.     mcall
  1264.  
  1265.  
  1266. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1267. ;   drawing text and images
  1268.  
  1269.     mov    eax, [cardcode]
  1270.     mov    edx, 0
  1271.     mov    ebx, 4
  1272.     div    ebx
  1273.  
  1274.     mov    [cardfamily], edx
  1275.     mov    [cardrange], eax
  1276.  
  1277.                      ; counting position of small card image
  1278.     mov eax, 7
  1279.     mov ecx, 8*65536+8
  1280.     mov edx, [xpos]
  1281.     add edx, radius
  1282.     shl edx, 16
  1283.     mov dx, word [ypos]
  1284.     add dx, radius + 8
  1285.  
  1286.  
  1287.  
  1288.     cmp    [cardfamily], 0
  1289.     je     .heart
  1290.  
  1291.     cmp    [cardfamily], 1
  1292.     je     .diamond
  1293.  
  1294.     cmp    [cardfamily], 2
  1295.     je     .club
  1296.  
  1297.     cmp    [cardfamily], 3
  1298.     je     .spade
  1299.  
  1300.     .heart:
  1301.        mov esi, [redcolor]
  1302.        mov [color], esi
  1303.        mov [imageaddr], heart
  1304.        mov [imageflipaddr], heart_updown
  1305.  
  1306.        mov ebx, heart_small
  1307.        mcall
  1308.  
  1309.        jmp .selnumber
  1310.  
  1311.     .diamond:
  1312.        mov esi, [redcolor]
  1313.        mov [color], esi
  1314.        mov [imageaddr], diamond
  1315.        mov [imageflipaddr], diamond_updown
  1316.  
  1317.        mov ebx, diamond_small
  1318.        mcall
  1319.  
  1320.        jmp .selnumber
  1321.  
  1322.     .club:
  1323.       mov  esi, [blackcolor]
  1324.       mov  [color], esi
  1325.       mov  [imageaddr], club
  1326.       mov  [imageflipaddr], club_updown
  1327.  
  1328.       mov ebx, club_small
  1329.       mcall
  1330.  
  1331.       jmp  .selnumber
  1332.  
  1333.     .spade:
  1334.       mov  esi, [blackcolor]
  1335.       mov  [color], esi
  1336.       mov  [imageaddr], spade
  1337.       mov  [imageflipaddr], spade_updown
  1338.  
  1339.       mov ebx, spade_small
  1340.       mcall
  1341.  
  1342.  
  1343.  
  1344.     .selnumber:
  1345.  
  1346.     mov    ebx, [xpos]       ; counting position of text
  1347.                              ; in ebx, same for all cards
  1348.     add    ebx, radius
  1349.     shl    ebx, 16
  1350.     mov    bx,  word [ypos]
  1351.     add    bx,  radius
  1352.  
  1353.  
  1354.     mov    ecx, [color]
  1355.  
  1356.  
  1357.     cmp    [cardrange], 0
  1358.     je     .ace
  1359.  
  1360.     cmp    [cardrange], 1
  1361.     je     .two
  1362.  
  1363.     cmp    [cardrange], 2
  1364.     je     .three
  1365.  
  1366.     cmp    [cardrange], 3
  1367.     je     .four
  1368.  
  1369.     cmp    [cardrange], 4
  1370.     je     .five
  1371.  
  1372.     cmp    [cardrange], 5
  1373.     je     .six
  1374.  
  1375.     cmp    [cardrange], 6
  1376.     je     .seven
  1377.  
  1378.     cmp    [cardrange], 7
  1379.     je     .eight
  1380.  
  1381.     cmp    [cardrange], 8
  1382.     je     .nine
  1383.  
  1384.     cmp    [cardrange], 9
  1385.     je     .ten
  1386.  
  1387.     cmp    [cardrange], 10
  1388.     je     .jack
  1389.  
  1390.     cmp    [cardrange], 11
  1391.     je     .queen
  1392.  
  1393.     cmp    [cardrange], 12
  1394.     je     .king
  1395.  
  1396.     ;      +-------+-------+-------+
  1397.     ;      |   3   |   2   |   3   |   ace   = 1
  1398.     ;      +-------+-------+-------+   two   = 2
  1399.     ;      |       |       |       |   three = 2 + 1
  1400.     ;      +-------+-------+-------+   four  = 3
  1401.     ;      |       |   6   |       |   five  = 3 + 1
  1402.     ;      +-------+-------+-------+   six   = 3 + 4
  1403.     ;      |   5   |       |   5   |   seven = 3 + 4 + 6
  1404.     ;      +-------+-------+-------+   eight = 3 + 5
  1405.     ;      |   4   |   1   |   4   |   nine  = 3 + 5
  1406.     ;      +-------+-------+-------+   ten   = 3 + 5 + 6 + 7
  1407.     ;      |   5   |       |   5   |
  1408.     ;      +-------+-------+-------+
  1409.     ;      |       |   7   |       |   1 means draw_1
  1410.     ;      +-------+-------+-------+
  1411.     ;      |       |       |       |
  1412.     ;      +-------+-------+-------+
  1413.     ;      |   3   |   2   |   3   |
  1414.     ;      +-------+-------+-------+
  1415.  
  1416.  
  1417.  
  1418.     .ace:
  1419.       mov  eax, 4
  1420.       mov  [s], byte 'A'
  1421.       mov  edx, s
  1422.       mov  esi, 1
  1423.       mcall
  1424.  
  1425.       call draw_1
  1426.       jmp .end
  1427.  
  1428.     .two:
  1429.       mov  eax, 4
  1430.       mov  [s], byte '2'
  1431.       mov  edx, s
  1432.       mov  esi, 1
  1433.       mcall
  1434.  
  1435.       call draw_2
  1436.       jmp .end
  1437.  
  1438.  
  1439.     .three:
  1440.       mov  eax, 4
  1441.       mov  [s], byte '3'
  1442.       mov  edx, s
  1443.       mov  esi, 1
  1444.       mcall
  1445.  
  1446.       call draw_1
  1447.       call draw_2
  1448.  
  1449.       jmp  .end
  1450.  
  1451.     .four:
  1452.       mov  eax, 4
  1453.       mov  [s], byte '4'
  1454.       mov  edx, s
  1455.       mov  esi, 1
  1456.       mcall
  1457.  
  1458.       call draw_3
  1459.       jmp  .end
  1460.  
  1461.     .five:
  1462.       mov  eax, 4
  1463.       mov  [s], byte '5'
  1464.       mov  edx, s
  1465.       mov  esi, 1
  1466.       mcall
  1467.  
  1468.       call draw_1
  1469.       call draw_3
  1470.  
  1471.       jmp  .end
  1472.  
  1473.     .six:
  1474.       mov  eax, 4
  1475.       mov  [s], byte '6'
  1476.       mov  edx, s
  1477.       mov  esi, 1
  1478.       mcall
  1479.  
  1480.       call draw_3
  1481.       call draw_4
  1482.  
  1483.       jmp  .end
  1484.  
  1485.     .seven:
  1486.       mov  eax, 4
  1487.       mov  [s], byte '7'
  1488.       mov  edx, s
  1489.       mov  esi, 1
  1490.       mcall
  1491.  
  1492.       call draw_3
  1493.       call draw_4
  1494.       call draw_6
  1495.  
  1496.       jmp  .end
  1497.  
  1498.     .eight:
  1499.       mov  eax, 4
  1500.       mov  [s], byte '8'
  1501.       mov  edx, s
  1502.       mov  esi, 1
  1503.       mcall
  1504.  
  1505.       call draw_3
  1506.       call draw_5
  1507.  
  1508.       jmp  .end
  1509.  
  1510.     .nine:
  1511.       mov  eax, 4
  1512.       mov  [s], byte '9'
  1513.       mov  edx, s
  1514.       mov  esi, 1
  1515.       mcall
  1516.  
  1517.       call draw_3
  1518.       call draw_5
  1519.       call draw_1
  1520.  
  1521.       jmp  .end
  1522.  
  1523.     .ten:
  1524.       mov  eax, 4
  1525.       mov  [s], word '10'
  1526.       mov  edx, s
  1527.       mov  esi, 2
  1528.       mcall
  1529.  
  1530.       call draw_3
  1531.       call draw_5
  1532.       call draw_6
  1533.       call draw_7
  1534.  
  1535.       jmp  .end
  1536.  
  1537.     .jack:
  1538.       mov  eax, 4
  1539.       mov  [s], byte 'J'
  1540.       mov  edx, s
  1541.       mov  esi, 1
  1542.       mcall
  1543.  
  1544.       jmp  .end
  1545.  
  1546.     .queen:
  1547.       mov  eax, 4
  1548.       mov  [s], byte 'Q'
  1549.       mov  edx, s
  1550.       mov  esi, 1
  1551.       mcall
  1552.  
  1553.       jmp  .end
  1554.  
  1555.     .king:
  1556.       mov  eax, 4
  1557.       mov  [s], byte 'K'
  1558.       mov  edx,s
  1559.       mov  esi, 1
  1560.       mcall
  1561.  
  1562.     .end:
  1563.  
  1564.  
  1565.     cmp  [negativedraw], 1
  1566.     jne  .no_invert2
  1567.  
  1568.     call invert_all_images
  1569.  
  1570.  
  1571.     .no_invert2:
  1572.     .no_draw_card:
  1573.  
  1574.   ret
  1575.  
  1576. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1577. ;                            invert_all_images()
  1578.   invert_all_images:
  1579.     mov  [sizeofimagetoinvert], 16 * 16 * 3
  1580.     mov  [imagetoinvert], heart
  1581.     call invert_image_colors
  1582.  
  1583.     mov  [sizeofimagetoinvert], 16 * 16 * 3
  1584.     mov  [imagetoinvert], diamond
  1585.     call invert_image_colors
  1586.  
  1587.     mov  [sizeofimagetoinvert], 16 * 16 * 3
  1588.     mov  [imagetoinvert], spade
  1589.     call invert_image_colors
  1590.  
  1591.     mov  [sizeofimagetoinvert], 16 * 16 * 3
  1592.     mov  [imagetoinvert], club
  1593.     call invert_image_colors
  1594.  
  1595.  
  1596.     mov  [sizeofimagetoinvert], 16 * 16 * 3
  1597.     mov  [imagetoinvert], heart_updown
  1598.     call invert_image_colors
  1599.  
  1600.     mov  [sizeofimagetoinvert], 16 * 16 * 3
  1601.     mov  [imagetoinvert], diamond_updown
  1602.     call invert_image_colors
  1603.  
  1604.     mov  [sizeofimagetoinvert], 16 * 16 * 3
  1605.     mov  [imagetoinvert], spade_updown
  1606.     call invert_image_colors
  1607.  
  1608.     mov  [sizeofimagetoinvert], 16 * 16 * 3
  1609.     mov  [imagetoinvert], club_updown
  1610.     call invert_image_colors
  1611.  
  1612.  
  1613.     mov  [sizeofimagetoinvert], 8 * 8 * 3
  1614.     mov  [imagetoinvert], heart_small
  1615.     call invert_image_colors
  1616.  
  1617.     mov  [sizeofimagetoinvert], 8 * 8 * 3
  1618.     mov  [imagetoinvert], diamond_small
  1619.     call invert_image_colors
  1620.  
  1621.     mov  [sizeofimagetoinvert], 8 * 8 * 3
  1622.     mov  [imagetoinvert], spade_small
  1623.     call invert_image_colors
  1624.  
  1625.     mov  [sizeofimagetoinvert], 8 * 8 * 3
  1626.     mov  [imagetoinvert], club_small
  1627.     call invert_image_colors
  1628.  
  1629.  
  1630.  
  1631.   ret
  1632.  
  1633.  
  1634. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1635.  
  1636.   draw_1:
  1637.                              ;draw center image
  1638.       mov     ebx, [imageaddr]
  1639.       mov     ecx, 16 * 65536 + 16
  1640.       mov     edx, [xpos]
  1641.       add     edx, cardwidth/2 - 8
  1642.       shl     edx, 16
  1643.       mov     dx, word [ypos]
  1644.       add     dx, cardheight/2 - 8
  1645.       mov      eax, 7
  1646.       mcall
  1647.   ret
  1648.  
  1649. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1650.  
  1651.  
  1652.   draw_2:
  1653.                              ;draw top image
  1654.       mov     ebx, [imageaddr]
  1655.       mov     ecx, 16 * 65536 + 16
  1656.       mov     edx, [xpos]
  1657.       add     edx, 40 - 8
  1658.       shl     edx, 16
  1659.       mov     dx, word [ypos]
  1660.       add     dx, margin
  1661.       mov     eax, 7
  1662.       mcall
  1663.                              ;draw bottom image
  1664.       mov     ebx, [imageflipaddr]
  1665.       mov     edx, [xpos]
  1666.       add     edx, cardwidth/2 - 8
  1667.       shl     edx, 16
  1668.       mov     dx, word [ypos]
  1669.       add     dx, cardheight - 16 - margin
  1670.       mov     eax, 7
  1671.       mcall
  1672.   ret
  1673.  
  1674. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1675.  
  1676.   draw_3:
  1677.                              ;draw top left image
  1678.       mov     ebx, [imageaddr]
  1679.       mov     ecx, 16 * 65536 + 16
  1680.       mov     edx, [xpos]
  1681.       add     edx, margin
  1682.       shl     edx, 16
  1683.       mov     dx, word [ypos]
  1684.       add     dx, margin
  1685.       mov     eax, 7
  1686.       mcall
  1687.                              ;draw bottom left image
  1688.       mov     ebx, [imageflipaddr]
  1689.       mov     edx, [xpos]
  1690.       add     edx, margin
  1691.       shl     edx, 16
  1692.       mov     dx, word [ypos]
  1693.       add     dx, cardheight - margin - 16
  1694.       mov     eax, 7
  1695.       mcall
  1696.                              ;draw top right image
  1697.       mov     ebx, [imageaddr]
  1698.       mov     edx, [xpos]
  1699.       add     edx, cardwidth - margin - 16
  1700.       shl     edx, 16
  1701.       mov     dx, word [ypos]
  1702.       add     dx, margin
  1703.       mov     eax, 7
  1704.       mcall
  1705.                              ;draw bottom right image
  1706.       mov     ebx, [imageflipaddr]
  1707.       mov     edx, [xpos]
  1708.       add     edx, cardwidth - margin - 16
  1709.       shl     edx, 16
  1710.       mov     dx, word [ypos]
  1711.       add     dx, cardheight - margin - 16
  1712.       mov     eax, 7
  1713.       mcall
  1714.   ret
  1715.  
  1716. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1717.  
  1718.   draw_4:
  1719.                              ;draw center left image
  1720.       mov     ebx, [imageaddr]
  1721.       mov     ecx, 16 * 65536 + 16
  1722.       mov     edx, [xpos]
  1723.       add     edx, margin
  1724.       shl     edx, 16
  1725.       mov     dx, word [ypos]
  1726.       add     dx, cardheight/2 - 8
  1727.       mov     eax, 7
  1728.       mcall
  1729.                              ;draw center right image
  1730.       mov     edx, [xpos]
  1731.       add     edx, cardwidth - margin - 16
  1732.       shl     edx, 16
  1733.       mov     dx, word [ypos]
  1734.       add     dx, cardheight/2 - 8
  1735.       mov     eax, 7
  1736.       mcall
  1737.   ret
  1738.  
  1739. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1740.  
  1741.   draw_5:
  1742.                              ;draw top left image
  1743.       mov     ebx, [imageaddr]
  1744.       mov     ecx, 16 * 65536 + 16
  1745.       mov     edx, [xpos]
  1746.       add     edx, margin
  1747.       shl     edx, 16
  1748.       mov     dx, word [ypos]
  1749.       add     dx, cardheight * 3 / 9
  1750.       mov     eax, 7
  1751.       mcall
  1752.                              ;draw bottom left image
  1753.       mov     ebx, [imageflipaddr]
  1754.       mov     edx, [xpos]
  1755.       add     edx, 16
  1756.       shl     edx, 16
  1757.       mov     dx, word [ypos]
  1758.       add     dx, cardheight * 5 / 9
  1759.       mov     eax, 7
  1760.       mcall
  1761.                              ;draw top right image
  1762.       mov     ebx, [imageaddr]
  1763.       mov     edx, [xpos]
  1764.       add     edx, cardwidth - margin - 16
  1765.       shl     edx, 16
  1766.       mov     dx, word [ypos]
  1767.       add     dx, cardheight * 3 / 9
  1768.       mov     eax, 7
  1769.       mcall
  1770.                              ;draw bottom right image
  1771.       mov     ebx, [imageflipaddr]
  1772.       mov     edx, [xpos]
  1773.       add     edx, cardwidth - margin - 16
  1774.       shl     edx, 16
  1775.       mov     dx, word [ypos]
  1776.       add     dx, cardheight * 5 / 9
  1777.       mov     eax, 7
  1778.       mcall
  1779.   ret
  1780.  
  1781. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1782.  
  1783.   draw_6:
  1784.       mov     ebx, [imageaddr]
  1785.       mov     ecx, 16 * 65536 + 16
  1786.       mov     edx, [xpos]
  1787.       add     edx, cardwidth/2 - 8
  1788.       shl     edx, 16
  1789.       mov     dx, word [ypos]
  1790.       add     dx, cardheight * 2 / 9
  1791.       mov     eax, 7
  1792.       mcall
  1793.   ret
  1794.  
  1795.  
  1796. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1797.   draw_7:
  1798.       mov     ebx, [imageflipaddr]
  1799.       mov     ecx, 16 * 65536 + 16
  1800.       mov     edx, [xpos]
  1801.       add     edx, cardwidth/2 - 8
  1802.       shl     edx, 16
  1803.       mov     dx, word [ypos]
  1804.       add     dx, cardheight * 6 / 9
  1805.       mov     eax, 7
  1806.       mcall
  1807.   ret
  1808.  
  1809.  
  1810. ;******************************************************************************
  1811.   randomize:
  1812.     push eax
  1813.  
  1814.     mov  eax, 3
  1815.     mcall
  1816.  
  1817.     mov  ebx, $A59E3F1C
  1818.     mul  ebx
  1819.     mov  dword [randseed], eax
  1820.     pop  eax
  1821.   ret
  1822.  
  1823.  
  1824.  
  1825. ;******************************************************************************
  1826. ;          function Random(Range): RandomValue
  1827.   random:
  1828.     push ebx
  1829.  
  1830.     mov  eax, [randseed]
  1831.     mov  edx, 0
  1832.     mov  ebx, 7
  1833.     div  ebx
  1834.  
  1835.     cmp  edx, 0
  1836.     je   _0
  1837.  
  1838.     cmp  edx, 1
  1839.     je   _1
  1840.  
  1841.     cmp  edx, 2
  1842.     je   _2
  1843.  
  1844.     cmp  edx, 3
  1845.     je   _3
  1846.  
  1847.     cmp  edx, 4
  1848.     je   _4
  1849.  
  1850.     cmp  edx, 5
  1851.     je   _5
  1852.  
  1853.     cmp  edx, 6
  1854.     je   _6
  1855.  
  1856.     jmp  _end
  1857.  
  1858.  
  1859.     _0:
  1860.       ;base := base + 58 + a[8];
  1861.       mov  eax, [randseed]
  1862.       add  eax, 58
  1863.       add  eax, dword [a + 8 * 4]
  1864.       mov  [randseed], eax
  1865.       jmp  _end;
  1866.  
  1867.     _1:
  1868.       ;base := base + 1 + a[9];
  1869.       mov  eax, [randseed]
  1870.       add  eax, 1
  1871.       add  eax, dword [a + 9 * 4]
  1872.       mov  [randseed], eax
  1873.       jmp _end;
  1874.  
  1875.     _2:
  1876.       ;base := base + 4 + a[88];
  1877.       mov  eax, [randseed]
  1878.       add  eax, 4
  1879.       add  eax, dword [a + 88 * 4]
  1880.       mov  [randseed], eax
  1881.       jmp _end;
  1882.  
  1883.     _3:
  1884.       ;randseed := randseed + 79 + a[43];
  1885.       mov  eax, [randseed]
  1886.       add  eax, 79
  1887.       add  eax, dword [a + 43 * 4]
  1888.       mov  [randseed], eax
  1889.       jmp _end;
  1890.  
  1891.     _4:
  1892.       ;randseed := randseed + 3 + a[12];
  1893.       mov  eax, [randseed]
  1894.       add  eax, 3
  1895.       add  eax, dword [a + 12 * 4]
  1896.       mov  [randseed], eax
  1897.       jmp _end;
  1898.  
  1899.     _5:
  1900.       ;randseed := randseed + 2 + a[63];
  1901.       mov  eax, [randseed]
  1902.       add  eax, 2
  1903.       add  eax, dword [a + 63 * 4]
  1904.       mov  [randseed], eax
  1905.       jmp _end;
  1906.  
  1907.     _6:
  1908.       ;randseed := randseed + 151 + a[24];
  1909.       mov  eax, [randseed]
  1910.       add  eax, 151
  1911.       add  eax, dword [a + 24 * 4]
  1912.       mov  [randseed], eax
  1913.  
  1914.       _end:
  1915.  
  1916.     mov  eax, [randseed]
  1917.     mov  edx, eax
  1918.     shl  edx, 16
  1919.     mov  bx, 100
  1920.     div  bx                   ; dx = randseed mod 100
  1921.  
  1922.     mov  ax, dx               ; ax = randseed mod 100
  1923.     mov  bx, 4
  1924.     mul  bx                   ; dx:ax = (randseed mod 100) * 4
  1925.     and  eax, $0000FFFF
  1926.     shr  edx, 16
  1927.     and  edx, $FFFF0000
  1928.     or   eax, edx
  1929.  
  1930.     mov  eax, dword [a + eax] ; eax = dword[a + (randseed mod 100) * 4]
  1931.                             ; ~ a[randseed mod 100]
  1932.     mov  ebx, dword [a + 47 * 4]
  1933.     mul  ebx                  ; eax = low(a[randseed mod 100] * a[47])
  1934.  
  1935.     add  eax, [randseed]
  1936.     add  eax, $4AE783A
  1937.     mov  [randseed], eax
  1938.  
  1939.     mov  eax, dword [a + 6 * 4]
  1940.     mov  edx, 0
  1941.     mov  ebx,  100
  1942.     div  ebx
  1943.     mov  eax, edx
  1944.     mov  ebx, 4
  1945.     mul  ebx                  ; eax = (dword [a + 6 * 4] mod 100) * 4 ~ a[6] mod 100
  1946.  
  1947.  
  1948.     mov  eax, dword [a + eax] ; eax = dword [a + (dword [a + 6 * 4] mod 100) * 4
  1949.  
  1950.                             ; ~ a[a[6] mod 100]
  1951.     add  eax, [randseed]
  1952.     mov  [random_value], eax
  1953.  
  1954.     mov  edx, 0
  1955.  
  1956.     mov  ebx, [range]
  1957.     div  ebx
  1958.     mov  [random_value], edx
  1959.  
  1960.     mov  al, [TimesCalled]
  1961.     xor  ah, ah
  1962.     inc  al
  1963.     mov  bl, 100
  1964.     div  bl
  1965.     mov  [TimesCalled], ah   ; TimesCalled = (TimesCalled + 1 ) mod 100
  1966.  
  1967.     mov  al, ah
  1968.     mov  bl, 4
  1969.     mul  bl
  1970.     and  eax, $0000FFFF
  1971.  
  1972.     mov  ebx, [randseed]
  1973.     mov  dword [a + eax], ebx ; a[TimesCalled] = randseed
  1974.  
  1975.     pop  ebx
  1976.   ret
  1977.  
  1978. ;******************************************************************************
  1979.  
  1980. ; <--- initialised data --->
  1981. if lang eq ru
  1982.   title db '‘®«¨â¥à',0
  1983.  
  1984.   new_game: db "®¢ ï ¨£à "
  1985.   new_game_len = $ - new_game
  1986.  
  1987.   exit: db "‚ë室"
  1988.   exit_len = $ - exit
  1989.  
  1990.   s: db "10"
  1991.  
  1992. else
  1993.   title db 'Freecell',0
  1994.  
  1995.   new_game: db "New game"
  1996.   new_game_len = $ - new_game
  1997.  
  1998.   exit: db "Exit"
  1999.   exit_len = $ - exit
  2000.  
  2001.   s: db "10"
  2002. end if
  2003.  
  2004.   negativedraw db 0          ; for procedure draw_card
  2005.  
  2006.  
  2007.   spade          file 'Spade.bmp': 54
  2008.   spade_updown   file 'SpadeUD.bmp': 54
  2009.   spade_small    file 'SpadeSml.bmp': 54
  2010.  
  2011.   club           file 'Club.bmp': 54
  2012.   club_updown    file 'ClubUD.bmp': 54
  2013.   club_small     file 'ClubSml.bmp': 54
  2014.  
  2015.   diamond        file 'Diam.bmp': 54
  2016.   diamond_updown file 'DiamUD.bmp': 54
  2017.   diamond_small  file 'DiamSml.bmp': 54
  2018.  
  2019.   heart          file 'Heart.bmp': 54
  2020.   heart_updown   file 'HeartUD.bmp': 54
  2021.   heart_small    file 'HeartSml.bmp': 54
  2022.  
  2023.  
  2024.   scNotSelected = 0
  2025.   scCommonCells = 1
  2026.   scTempCells = 2
  2027.  
  2028.  
  2029.   whereisselcard  dd scNotSelected
  2030.   columnofselcard dd 0       ; if WhereIsSelCard = scGeneralCells
  2031.                              ;    then this can be 0 .. 7,
  2032.                              ; if scTempCells then - 0 .. 3
  2033.                              ; if scNotSelected - no matter
  2034.  
  2035.   tempcells: times 4 db 52;
  2036.   homecells: times 4 db 52 ; maximal card code is 51
  2037.   cards:     times 8 * 19 db 52; - %
  2038.   pack:      times 52 db ?
  2039.  
  2040.  
  2041.  
  2042. udata
  2043.   process_info process_information
  2044.   syscolors system_colors
  2045.  
  2046.   WindowHeight rw 1
  2047.   WindowWidth rw 1
  2048.  
  2049.   xpos rd 1
  2050.   ypos rd 1
  2051.   bgcolor rd 1
  2052.   blackcolor rd 1
  2053.   redcolor rd 1
  2054.  
  2055.  
  2056.   lastparam rd 1                  ;
  2057.  
  2058.   randomcard rd 1                ; for new_game_click
  2059.  
  2060.   columnclicked rd 1             ; used in common_card_click, temp_cell_click,
  2061.   cardclicked rd 1               ;    home_cell_click
  2062.   clickedcardrange rd 1          ;
  2063.   clickedcardfamily rd 1         ;
  2064.  
  2065.  
  2066.   selcardcode rd 1               ; for procedure get_sel_card_code_and_addr
  2067.   selcardaddr rd 1               ;
  2068.  
  2069.   column rd 1                    ; for procedure draw_window
  2070.   row rd 1                          ;
  2071.  
  2072.   imagetoinvert rd 1             ; for procedure invert_image_colors
  2073.   sizeofimagetoinvert rd 1       ;
  2074.  
  2075.   ncolumn rd 1                   ; for procedure get_row_of_top_card_in_column
  2076.   topcardrow rd 1                ;
  2077.  
  2078.  
  2079.   color rd 1                     ; for procedue draw_card
  2080.   imageaddr rd 1                 ;
  2081.   imageflipaddr rd 1             ;
  2082.  
  2083.   cardcode rd 1                  ; used in differrent procedures
  2084.   cardrange rd 1                 ; cardcode = cardrange * 4 + cardfamily
  2085.   cardfamily rd 1                ;
  2086.  
  2087.   a: times 100 rd 1              ; for function Random
  2088.   range rd 1                     ;
  2089.   random_value rd 1              ;
  2090.   randseed rd 1                  ;
  2091.   TimesCalled rb 1               ;
  2092.  
  2093.   j rd 1                         ; number of card (in array cards) drawn now
  2094.   i rd 1                         ; used in many procedures of 1-st level
  2095.   k rd 1
  2096.  
  2097.   cardwidth = 80
  2098.   cardheight = 120
  2099.   radius = 4                     ; not recommended to change
  2100.   rowsize = 30                   ; distance between top poins
  2101.                                  ;of cards in neighboring rows
  2102.   columnspace = 5                ; minimal space between cards
  2103.   margin = 14                       ; margin of every card
  2104.  
  2105.   topbuttonsbarheight = 20
  2106.  
  2107.  
  2108. meos_app_end