0,0 → 1,2111 |
; <--- 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 |