CODE    SEGMENT
    ASSUME  CS:CODE, DS:DATA, SS:STK
    
START:        
    MOV AX, DATA
    MOV DS, AX     
           
    ; PRINT WELCOME MESSAGE       
    MOV DX, OFFSET MSG
    MOV AH, 09H
    INT 21H                
    
    ;WAIT FOR ANY KEY;
    MOV AH, 00H
    INT 16H
    
GAME_LOOP:
    PUSH AX
    PUSH BX
    PUSH CX
    PUSH DX
   
    MOV BX, 00H
    MOV AH, 00H
    INT 1AH
    ADD BX, DX
   
    TLOOP:
    MOV AH, 00H
    INT 1AH
    CMP DX, BX
    JG  TLOOP2
    JMP TLOOP

    TLOOP2:
    POP DX
    POP CX
    POP BX
    POP AX   


    MOV DX, SNAKE[0]
    
    ;SET CURSOR AT DH(Y), DL(X)
    MOV AH, 02H
    INT 10H    
    
    MOV AL, "*"
    MOV AH, 09H
    MOV BL, 0EH
    MOV CX, 1
    INT 10H

    MOV AX, SNAKE[SNAKE_SIZE * 2 - 2]
    MOV SNAKE_TAIL, AX
    
    CALL SNAKE_MOVE

    MOV DX, SNAKE_TAIL

    MOV AH, 02H
    INT 10H

    MOV AL, " "
    MOV AH, 09H
    MOV BL, 0EH
    MOV CX, 1
    INT 10H


    MOV AH, 01H
    INT 16H
    JZ GAME_LOOP

    MOV AH, 00H
    INT 16H
                
                
    CMP AL, 1BH
    JE GAME_STOP
    
    MOV SNAKE_DIR, AH



    JMP GAME_LOOP
    
GAME_STOP:
    MOV AH, 4CH
    INT 21H
    
SNAKE_MOVE    PROC
    MOV DI, SNAKE_SIZE * 2 - 2
    MOV CX, SNAKE_SIZE - 1
    
    SHIFT_SNAKE:
    MOV AX, SNAKE[DI-2]
    MOV SNAKE[DI], AX
    SUB DI, 2
    LOOP SHIFT_SNAKE
    
    CMP SNAKE_DIR, UP
    JE  CALL_UP
    CMP SNAKE_DIR, DOWN
    JE  CALL_DOWN
    CMP SNAKE_DIR, RIGHT
    JE  CALL_RIGHT
    CMP SNAKE_DIR, LEFT
    JE  CALL_LEFT
    
    JMP RETURN
              
CALL_UP:
    CALL SNAKE_MOVE_UP
    JMP RETURN
CALL_DOWN:    
    CALL SNAKE_MOVE_DOWN
    JMP RETURN
CALL_RIGHT:   
    CALL SNAKE_MOVE_RIGHT
    JMP RETURN
CALL_LEFT:    
    CALL SNAKE_MOVE_LEFT
    JMP RETURN

RETURN:    
    RET
SNAKE_MOVE    ENDP

SNAKE_MOVE_UP    PROC
    MOV AX, SNAKE[1]
    DEC AL
    MOV SNAKE[1], AX
    CMP AL, -1
    JNZ UP_RE      
    MOV AL, 1AH
    MOV SNAKE[1], AX
    
    UP_RE:    
    RET
SNAKE_MOVE_UP    ENDP

SNAKE_MOVE_DOWN    PROC
    MOV AX, SNAKE[1]
    INC AL
    MOV SNAKE[1], AX
    CMP AL, 1AH
    JNE DOWN_RE   
    MOV AL, 0
    MOV SNAKE[1], AX
    
    DOWN_RE:    
    RET    
SNAKE_MOVE_DOWN    ENDP

SNAKE_MOVE_LEFT    PROC
    MOV AX, SNAKE[0]
    DEC AL
    MOV SNAKE[0], AX
    CMP AL, 0        
    JNE LEFT_RE    
    MOV AL, 4FH
    MOV SNAKE[0], AX
    
    LEFT_RE:
    RET
SNAKE_MOVE_LEFT    ENDP

SNAKE_MOVE_RIGHT  PROC
    MOV AX, SNAKE[0]
    INC AL
    MOV SNAKE[0], AX
    CMP AL, 50H
    JNE RIGHT_RE   
    MOV AL, 0H
    MOV SNAKE[0], AX

    RIGHT_RE:
    RET
SNAKE_MOVE_RIGHT  ENDP

PRINT_MSG    PROC
    MOV AH, 09H
    INT 21H
    RET
PRINT_MSG    ENDP

DATA    SEGMENT            
MSG         DB  "=====================", 0DH, 0AH
            DB  "=   ARE YOU READY   =", 0DH, 0AH
            DB  "=                   =", 0DH, 0AH
            DB  "=   PRESS ANY KEY   =", 0DH, 0AH
            DB  "=      TO START     =", 0DH, 0AH
            DB  "=====================$"     

UP      EQU     48H
DOWN    EQU     50H
LEFT    EQU     4BH
RIGHT   EQU     4DH       

SNAKE_DIR   DB  RIGHT

SNAKE_SIZE  EQU     20H
SNAKE       DW      SNAKE_SIZE  DUP(0)
SNAKE_TAIL  DW      ?

WAIT_TIME   DW    0
    

;FOR DEBUG
MSG_UP        DB    "  GO UP ", 0DH, 0AH, "$"
MSG_DOWN    DB    "  GO DOWN ", 0DH, 0AH, "$"
MSG_LEFT    DB    "  GO LEFT ", 0DH, 0AH, "$"
MSG_RIGHT    DB    "  GO RIGHT ", 0DH, 0AH, "$"

DATA    ENDS

STK     SEGMENT STACK
    DB    1000H    DUP(?)
STK     ENDS

CODE ENDS
END