fork download

copy

;Game of NIM -- Pooya
;******Some defs******
prnt_msg equ 09h
cr equ 0dh
nl equ 0ah
_in equ 01h
_out equ 0eh
spc equ 2 dup (' ')
str equ 0b1h, 0b2h    
 
;*****Color Table*****
black equ 00h
blue equ 01h
green equ 02h
cyan equ 03h
red equ 04h
magenta equ 05h
brown equ 06h
light_gray equ 07h
dark_gray equ 08h
light_blue equ 09h
light_green equ 0ah
light_cyan equ 0bh
light_red equ 0ch
light_magenta equ 0dh
yellow equ 0eh
white equ 0fh
;*********************
 
.MODEL SMALL
 
;******Stack Segment******
.STACK
 
    dw   128  dup (?)
;*************************
 
;******Data Segement******
.DATA
 
    star db cr, nl, spc, str, '$'
    star2 db cr, nl, spc, str, 32 dup (' '), str, '$'
    space db spc, '$'  
    nim_desc db spc, spc, spc, spc
             db 'THE GAME OF NIM'
             db cr, nl, nl, '$'
 
    pilesAsk db spc 
             db 'How many piles? (No more than 5)'
             db cr, nl, '$'
 
    wrong db cr, nl, nl
          db spc
          db 'Your input is wrong'
          db cr, nl, '$'
 
    sticks  db cr, nl, nl
            db spc
            db , 'How many sticks in ', '$'
    sticks2 db ' pile? (no more than 9)'
            db cr, nl, '$' 
 
    pile_num1 db cr, spc, str, '$'
 
    pile_num2 db nl, cr
              db spc, str, spc
              db 'Pile #', '$'
 
    who_first db cr, nl, nl
              db spc
              db 'Who plays first?'
              db cr, nl
              db spc
              db '0 = Computer, 1 = Player'
              db cr, nl, nl, '$'
 
    computer_think db cr, nl, nl
                   db 'Hmm... What should I pick now...?'
                   db cr, nl, '$'
 
    computer_pick  db cr, nl
                   db 'I picked ', '$'
    computer_pick2 db ' sticks from pile #', '$'                       
 
    first db -1
    piles dw 0
    pile1 db 5 dup (?)
 
    shape db 0f4h, 0f5h, '$'
    new db cr, nl, '$'
 
    pick_pile db cr, nl, nl
              db spc
              db 'Please pick one pile.'
              db cr, nl, nl, '$'
 
    pick_stick_ db cr, nl, nl
                db spc
                db 'How many sticks to remove? '
                db '(Zero, or numbers greater than ', '$'
 
    pick_stick__ db ' are illegal.)'
                 db cr, nl, '$'
 
    iwin db cr, nl
         db spc
         db 'I WON!!'
         db cr, nl, '$'
 
    uwin db cr, nl
         db spc
         db 'YOU WON!!'
         db cr, nl, '$'
 
 
    top db cr, nl
        db spc
        db 17 dup (str), 0b1h, 0b2h, nl, '$'
 
    again_ul db cr, nl, spc
             db 'Do you want to play again?'
             db cr, nl, spc
             db 'Maybe this time you could beat me? (Y/n)'
             db cr, nl, '$'
 
    again_cl db cr, nl, spc
             db 'Do you want to play again?'
             db cr, nl, spc
             db 'This time I will win for sure! (Y/n)'
             db cr, nl, '$'
 
    win_flag db -1
 
    gState db 0
    computer_move db 0
    rand dw 0
    pile_choice dw 0
    sum db 1
    err db cr, spc
        db 'You need to have at least two piles'
        db cr, nl, '$'
 
    temp dw 0
    temp2 db 24h
;*************************
 
;******Code Segemnt*******      
.CODE
.STARTUP
;**********Macro**********
set_color macro par ;macro to set a color for printing
       pusha
       mov bl, par  
       mov ah, 9 
       mov al, 0 
       int 10h
       popa 
endm
;************************
 
start:
;set video mode
    mov ah, 0h
    mov al, 03h
    int 10h
;====================== 
 
set_color light_gray ; change color for second run (if i don't add this line,
					 ; in second run (after play_again proc) some of character
					 ; are colored in a random manner
 
;print description
    lea dx, nim_desc
    call print_msg
;======================
 
;ask for the number of piles
    lea dx, pilesAsk
    call print_msg 
;===========================
 
 
;get piles:
    jmp get_pile
    wrong_pile:
    lea dx, wrong
    call print_msg
 
    jmp get_pile
    wrong_pile2:
    lea dx, wrong
    call print_msg
    lea dx, err
    call print_msg
 
    get_pile:
    call get_ch
    sub al, 30h
    cmp al, 5
    jg wrong_pile
    cmp al, 0
    jz wrong_pile
    cmp al, 1
    jz wrong_pile2 
    mov b. piles, al 
 ;===========================   
 
    mov cl, '1'
    mov si, 0
 
 
    jmp input
    wrong_stick:
    lea dx, wrong
    call print_msg
    dec cl
 
input:
 
;ask for number of sticks each pile contains:
    lea dx, sticks
    call print_msg
 
    mov al, cl
    call print_ch
 
    mov dx, offset sticks2
    call print_msg
    inc cl
;==========================
 
;get sticks:    
    xor al, al
    call get_ch   
    sub al, 30h
    cmp al, 0
    jz wrong_stick
    mov pile1[si], al
    inc si          
    cmp si, piles 
    jb input
;==========================
 
;print pile
    call print_pile
;==========================
 
;prompt user to choose who plays first (machine or user):
    call who_turn
;==========================
 
turn:
    cmp first, 0 ;compare to know who played first
    jnz computer_next
 
    player_next:
    call print_pile
    call user_turn
    cmp win_flag, 0
    jz closing
    call print_pile
    call computer_turn
    cmp win_flag, 1
    je closing
    jmp player_next
 
    jmp closing
 
    computer_next:
    call print_pile
    call computer_turn
    cmp win_flag, 1
    je closing
    call print_pile
    call user_turn
    cmp win_flag, 0
    jz closing
    jmp computer_next
 
 
    closing:
    call play_again
    jmp exit
 
 
who_turn proc
 
    lea dx, who_first
    call print_msg
 
    call get_ch
    sub al,30h
    cmp al, 0
    mov first, al
    jnz label3
 
    call computer_turn
 
    jmp fin
 
    label3:
    call user_turn
 
    fin:
    ret
who_turn endp    
 
user_turn proc
 
    jmp pick_
    wrong_:
    lea dx, wrong
    call print_msg
 
    pick_:    
    lea dx, pick_pile
    call print_msg
 
    call get_ch
    dec al
    sub al, 30h
    mov b. pile_choice, al
 
    xor di, di
    mov di, pile_choice
    cmp pile1[di], 0
    jz wrong_
    cmp al, b. piles
    jg wrong_
 
 
    mov dx, offset pick_stick_
    call print_msg
 
    mov si, pile_choice
    mov al, pile1[si]
    add al, 30h
    call print_ch
 
 
    lea dx, pick_stick__
    call print_msg
 
    jmp label2
    wrong_choice2:
    lea dx, wrong
    call print_msg
 
    label2:
    call get_ch
    sub al, 30h
    cmp al, pile1[si]
    jg wrong_choice2
    cmp al, 0
    jz wrong_choice2
 
    sub pile1[si], al
    call get_sum
    cmp sum, 0
    jz u_win
 
    jmp label5
    u_win:
    mov win_flag, 0
    lea dx, uwin
    call print_msg    
 
    label5:
    ret
user_turn endp    
 
computer_turn proc
    lea dx, computer_think
    call print_msg    
    call is_kernel
    cmp gState, 0
    jz pick  
 
    call make_kernel
    call print_move
    call get_sum
    cmp sum, 0
    jz i_win
 
    jmp label1
 
    pick:
    call pick_stick
    call print_move
    call get_sum
    cmp sum, 0
    jz i_win
 
    jmp label1 
 
    i_win:
    call print_pile
    mov win_flag, 1
    lea dx, iwin
    call print_msg
 
    label1: 
 
    ret
computer_turn endp     
 
print_move proc ;prints computer's move
    pusha
    lea dx, computer_pick
    call print_msg
    mov al, computer_move
    add al, 30h
    call print_ch
    lea dx, computer_pick2
    call print_msg
    mov al, b. rand
    inc al
    add al, 30h
    call print_ch
    popa
    ret
print_move endp
 
get_sum proc ; get sum of sticks. if there is not more sticks,
			 ; player who's made the last move is the winner
    pusha
    mov cx, piles
    xor si, si
    xor al, al
 
    label4:
    add al, pile1[si]
    inc si
    loop label4
    mov sum, al
    popa
    ret
get_sum endp
 
is_empty proc ; check if a pile is empty so user can't choose that one
    pusha
    mov al, pile1[si]
    or al, al
    popa
    ret 
is_empty endp
 
pick_stick proc ;pick one stick from a random pile when status is kernel
    pusha
    label:
    call rand_gen
    mov si, rand
    call is_empty
    jz label
    sub pile1[si], 1
    mov computer_move, 1
    popa
    ret
pick_stick endp    
 
rand_gen proc ;generates a random number -- not a good one, but does the job
    pusha
    mov ah, 0h
    int 1ah
    mov  ax, dx
    xor  dx, dx
    mov  cx, piles    
    div  cx
    mov rand, dx
 
    popa
    ret
rand_gen endp
 
is_kernel proc ;check if game status is kernel
    pusha
    mov cx, piles          
    mov al, 0
    xor si, si
 
    _xor:
    xor al, pile1[si]
    inc si
    loop _xor
 
    mov gState, al
    popa
    ret
is_kernel endp
 
make_kernel proc ; make game status kernel. (computer's move)
 
    jmp xor_
    wrong_choice: 
    xchg bl, pile1[di]
 
    xor_:
    call rand_gen
    mov di, rand
 
    cmp pile1[di], 0
    jz xor_
 
    mov bl, gState
    xor bl, pile1[di]
    xchg bl, pile1[di]
 
    cmp pile1[di], bl
    jge wrong_choice
 
    sub bl, pile1[di]
    mov computer_move, bl
 
    ret
make_kernel endp
 
 
print_pile  proc ;print the piles. this is where my problem lies.
    pusha
 
    mov al, nl ; print a new line
    call print_ch
    lea dx, top ;print top of border
    call print_msg 
    xor si, si
    mov cx, piles
    xor bl, bl
 
    pile_loop: ;print pile number
    lea dx, pile_num1
    call print_msg
    call set_cursor
    lea dx, pile_num2
    call print_msg
    mov temp, si
    mov al, b. temp
    inc al
    add al, 30h
    call print_ch
 
    mov al, ' ' ;print sticks in each pile in numbers
    call print_ch
    mov al, '('
    call print_ch
    mov al, pile1[si]
    add al, 30h
    call print_ch
    mov al, ')'
    call print_ch
    mov al, ' '
    call print_ch
 
    lea dx, shape 
    mov bl, pile1[si]
    cmp bl, 0
    jz no_print
        print_loop: ;prints sticks in each pile using an ascii character
        set_color light_red ; here i want to print abovesaid shapes in a color
        call print_msg
        dec bl
        cmp bl, 0
 
        jnz print_loop
 
    no_print:
 
    call set_cursor
 
    inc si    
    dec cx
    or cx, cx
    jnz pile_loop
    lea dx, star2
    call print_msg
    lea dx, top
    call print_msg
    popa
    ret
print_pile endp
 
; get and set cursor position in order to print a border
; around piles
get_cursor proc
    mov ah, 03h
    int 10h
    ret
get_cursor endp
 
set_cursor proc
    pusha
    call get_cursor
    mov temp2, 24h
    sub temp2, dl 
    add dl, temp2
    mov ah, 02h
    int 10h
    mov al, 0b1h
    call print_ch
    mov al, 0b2h
    call print_ch
    popa
    ret
set_cursor endp
;==========================
 
print_msg proc
    pusha
    mov ah, prnt_msg
    int 21h
    popa
    ret
print_msg endp
 
 
print_ch proc
    pusha
    mov ah, _out
    int 10h
    popa
    ret
print_ch endp
 
 
get_ch proc
    lea dx, space
    call print_msg
    mov ah, _in
    int 21h
    ret
get_ch endp        
 
 
play_again proc ; here i prompt user for a second play
    cmp win_flag, 0
    jz computer_lost
 
    lea dx, again_ul
 
    jmp fin2
 
    computer_lost:
    lea dx, again_cl
 
    fin2:
    call print_msg
 
    call get_ch
    cmp al, 'y'
    je start_again
    cmp al, 'Y'
    je start_again
    cmp al, 'N'
    je exit
    cmp al, 'n'
    je exit
 
    start_again:
    mov win_flag, -1
    jmp start
 
    ret    
play_again endp
 
exit:
    mov ax, 4c00h
    int 21h
 
.EXIT
END
 

prog.asm:8: error: comma, colon, decorator or end of line expected after operand
prog.asm:9: error: comma, colon, decorator or end of line expected after operand
prog.asm:30: error: attempt to define a local label before any non-local labels
prog.asm:30: error: parser: instruction expected
prog.asm:33: error: attempt to define a local label before any non-local labels
prog.asm:35: error: comma expected after operand 1
prog.asm:39: error: attempt to define a local label before any non-local labels
prog.asm:42: error: comma expected after operand 5
prog.asm:59: error: expression syntax error
prog.asm:87: error: comma expected after operand 1
prog.asm:118: error: comma expected after operand 1
prog.asm:151: error: parser: instruction expected
prog.asm:168: error: symbol `set_color' redefined
prog.asm:168: error: parser: instruction expected
prog.asm:205: error: comma, colon, decorator or end of line expected after operand
prog.asm:227: error: comma, colon, decorator or end of line expected after operand
prog.asm:238: error: comma, colon, decorator or end of line expected after operand
prog.asm:286: error: parser: instruction expected
prog.asm:306: error: symbol `who_turn' redefined
prog.asm:306: error: parser: instruction expected
prog.asm:308: error: parser: instruction expected
prog.asm:322: error: comma, colon, decorator or end of line expected after operand
prog.asm:326: error: comma, colon, decorator or end of line expected after operand
prog.asm:328: error: comma, colon, decorator or end of line expected after operand
prog.asm:332: error: comma, colon, decorator or end of line expected after operand
prog.asm:336: error: comma, colon, decorator or end of line expected after operand
prog.asm:352: error: comma, colon, decorator or end of line expected after operand
prog.asm:357: error: comma, colon, decorator or end of line expected after operand
prog.asm:370: error: symbol `user_turn' redefined
prog.asm:370: error: parser: instruction expected
prog.asm:372: error: parser: instruction expected
prog.asm:405: error: symbol `computer_turn' redefined
prog.asm:405: error: parser: instruction expected
prog.asm:407: error: parser: instruction expected
prog.asm:416: error: comma, colon, decorator or end of line expected after operand
prog.asm:422: error: symbol `print_move' redefined
prog.asm:422: error: parser: instruction expected
prog.asm:424: error: parser: instruction expected
prog.asm:432: error: comma, colon, decorator or end of line expected after operand
prog.asm:438: error: symbol `get_sum' redefined
prog.asm:438: error: parser: instruction expected
prog.asm:440: error: parser: instruction expected
prog.asm:442: error: comma, colon, decorator or end of line expected after operand
prog.asm:446: error: symbol `is_empty' redefined
prog.asm:446: error: parser: instruction expected
prog.asm:448: error: parser: instruction expected
prog.asm:455: error: comma, colon, decorator or end of line expected after operand
prog.asm:459: error: symbol `pick_stick' redefined
prog.asm:459: error: parser: instruction expected
prog.asm:461: error: parser: instruction expected
prog.asm:473: error: symbol `rand_gen' redefined
prog.asm:473: error: parser: instruction expected
prog.asm:475: error: parser: instruction expected
prog.asm:482: error: comma, colon, decorator or end of line expected after operand
prog.asm:489: error: symbol `is_kernel' redefined
prog.asm:489: error: parser: instruction expected
prog.asm:491: error: parser: instruction expected
prog.asm:495: error: comma, colon, decorator or end of line expected after operand
prog.asm:501: error: comma, colon, decorator or end of line expected after operand
prog.asm:505: error: comma, colon, decorator or end of line expected after operand
prog.asm:506: error: comma, colon, decorator or end of line expected after operand
prog.asm:508: error: comma, colon, decorator or end of line expected after operand
prog.asm:511: error: comma, colon, decorator or end of line expected after operand
prog.asm:515: error: symbol `make_kernel' redefined
prog.asm:515: error: parser: instruction expected
prog.asm:518: error: parser: instruction expected
prog.asm:536: error: comma, colon, decorator or end of line expected after operand
prog.asm:545: error: comma, colon, decorator or end of line expected after operand
prog.asm:554: error: comma, colon, decorator or end of line expected after operand
prog.asm:558: error: symbol `set_color' redefined
prog.asm:558: error: parser: instruction expected
prog.asm:579: error: symbol `print_pile' redefined
prog.asm:579: error: parser: instruction expected
prog.asm:583: error: parser: instruction expected
prog.asm:587: error: symbol `get_cursor' redefined
prog.asm:587: error: parser: instruction expected
prog.asm:589: error: parser: instruction expected
prog.asm:603: error: symbol `set_cursor' redefined
prog.asm:603: error: parser: instruction expected
prog.asm:606: error: parser: instruction expected
prog.asm:612: error: symbol `print_msg' redefined
prog.asm:612: error: parser: instruction expected
prog.asm:615: error: parser: instruction expected
prog.asm:621: error: symbol `print_ch' redefined
prog.asm:621: error: parser: instruction expected
prog.asm:624: error: parser: instruction expected
prog.asm:630: error: symbol `get_ch' redefined
prog.asm:630: error: parser: instruction expected
prog.asm:633: error: parser: instruction expected
prog.asm:662: error: symbol `play_again' redefined
prog.asm:662: error: parser: instruction expected
ld: cannot find prog.o: No such file or directory

Standard output is empty