Life

IDEAL
MODEL small
STACK 100h
DATASEG
    Index dw 0
    neighborsCounter db 0
    GameArray db 70 dup (3)
    Picture    db'oooooo                          ooooooo           o                       '
                 db'o         oo   o    o oooooo    o     o oooooo    o       o oooooo oooooo   '
                 db'o        o  o  oo  oo o         o     o o         o       o o      o        '
               db'o  oooo o    o o oo o ooooo     o     o ooooo     o       o ooooo  ooooo  '
                 db'o     o oooooo o    o o         o     o o         o       o o      o        '
                 db'o     o o    o o    o o         o     o o         o       o o      o        '
                 db'ooooo o o    o o    o oooooo    ooooooo o         ooooooo o o      oooooo   ',10,13
                 db '                                                                           ', 10,13
                 db 'Welcome to the game "life". Here are the rules:$',10,13

                 SelectedEnter db 'Press any key to continue...$',10,13
                  Rules db '- The universe of Game of Life is an infinite,two-dimensional' ,10,13
                 db ' consists of square cells.',10,13
                   db '- Each cell can be either alive or dead',10,13
                 db '- Every cell interacts with its eight neighbours',10,13
                   db '- Which are the cells that are horizontally,vertically,or ',10,13
                 db ' diagonally adjacent. At each step in time, the following transitions occur:',10,13
                   db '- Any live cell with fewer than two live neighbours dies',10,13
                 db ' as if by underpopulation.',10,13
                   db '- Any live cell with two or three live neighbours lives',10,13
                 db '- On to the next turn.',10,13
                   db '- Any live cell with more than three live neighbours dies',10,13
                 db '- As if by overpopulation.',10,13
                   db '- Any dead cell with exactly three live neighbours becomes a live cell',10,13
                 db '- As if by reproduction.$'

    x dw ?
    y dw ?

    color db ?

    startX dw ?
    endX dw ?

    startY dw ?
    endY dw ?

    CounterLines db 0
    CounterColumns db 0


    IndexX dw ?
    IndexY dw ?

    RectLength db 20

    ArrayNum dw ?


;-------

CODESEG

proc PrintPicture
push ax
push dx
    mov dx, offset Picture
    mov ah, 9h
    int 21h
pop dx
pop ax
    call PrintRules
    ret
endp PrintPicture


proc PrintRules ;prints the rules of the game
push ax
push dx
    mov ah,2h
    mov dl, 10
    int 21h
    mov dl, 13
    int 21h
    mov dx, offset Rules
    mov ah, 9h
    int 21h
    mov dx, offset SelectedEnter
    mov ah, 9h
    int 21h
    mov ah, 01h
    int 21h
    cmp al, 13 ;enter
    call SwitchToGraphicsMode


pop dx
pop ax
    ret
endp PrintRules

proc CheckInput ;checks if you press r or enter
push ax
OneMoreInput:
    mov ah, 7
    int 21h
    cmp al, 114 ;r
    je PrintRules
    cmp al, 13 ;enter
    jne OneMoreInput
    call SwitchToGraphicsMode
pop ax
    ret
endp CheckInput


proc SwitchToGraphicsMode ;switches to graphics mode
push ax
    mov ax, 13h
    int 10h
pop ax
    ret
endp SwitchToGraphicsMode


proc SwitchToTextMode ;switches totext mode
push ax
    mov ax, 2
    int 10h
pop ax
    ret
endp SwitchToTextMode


proc DisplayDot
push ax
push bx
push cx
push dx
    mov al, [color] ;color
    mov bl, 0 ;page number - always 0

    mov cx, [x] ;x value
    mov dx, [y] ;y value

    mov ah, 0Ch
    int 10h
pop dx
pop cx
pop bx
pop ax
    ret
endp DisplayDot


proc DisplayLine
push cx
    mov cx, [startX] ;x position
    mov [x], cx

DisplayDotLoop:
    call DisplayDot
    inc [x]

    mov cx, [endX]
    inc cx
    cmp [x], cx

    jne DisplayDotLoop
pop cx
    ret
endp DisplayLine


proc DisplayLine2 ;horizontal line
push cx
    mov cx, [startY] ;y position
    mov [y], cx

DisplayDotLoop2:
    call DisplayDot
    inc [y]

    mov cx, [endY]
    inc cx
    cmp [y], cx

    jne DisplayDotLoop2
pop cx
    ret
endp DisplayLine2


proc DisplayRect
push dx
    mov dx, [startY]
    mov [y], dx

DisplayLineLoop:
    call DisplayLine
    inc [y]

    mov dx, [endY]
    inc dx
    cmp [y], dx
    jne DisplayLineLoop
pop dx
    ret
endp DisplayRect


proc AliveRectGraphics ;White color as parameter
push [endY]
push [startY]
push [endX]
push [startX]
    add [endY], 4
    sub [startY], 4
    add [endX], 4
    sub [startX], 4
    call DisplayRect
pop [startX]
pop [endX]
pop [startY]
pop [endY]
    ret
endp AliveRectGraphics


proc NewRectGraphics ;Yellow color as parameter
push [endY]
push [startY]
push [endX]
push [startX]
    add [endY], 4
    sub [startY], 4
    add [endX], 4
    sub [startX], 4
    call DisplayRect
pop [startX]
pop [endX]
pop [startY]
pop [endY]
    ret
endp NewRectGraphics


proc DeadRectGraphics ;Red color as parameter
push [endY]
push [startY]
push [endX]
push [startX]
    add [endY], 4
    sub [startY], 4
    add [endX], 4
    sub [startX], 4
    call DisplayRect
pop [startX]
pop [endX]
pop [startY]
pop [endY]
    ret
endp DeadRectGraphics


proc DisplayBoard ;creates the board of the game
    mov [y], 20
DisplayLines:
    mov [color], 1Eh
    mov [startX], 60
    mov [endX], 260
    call DisplayLine
    add [Y], 20
    inc [CounterLines]
    cmp [CounterLines],8
    jne DisplayLines
    mov [x], 60

DisplayColumns:
    mov [color], 1Eh
    mov [startY], 20
    mov [endY], 160
    call DisplayLine2
    add [X], 20
    inc [CounterColumns]
    cmp [CounterColumns],11
    jne DisplayColumns
    ret
endp DisplayBoard

proc WaitForKey
push ax
    mov ah, 0
    int 16h
pop ax
    ret
endp WaitForKey


proc MoveToken ;moves the gray token in all directions

push ax
    xor ax,ax
    mov [Index],ax
    mov [color], 7h
    mov [startX], 65
    mov [endX], 75
    mov [startY], 25
    mov [endY], 35
    call DisplayRect
ReadKeyboardLoop:
    mov ah, 0
    int 16h

    cmp ah, 4Dh ;right arrow
    jne Left
    call MoveRight
    jmp ReadKeyboardLoop
Left:
    cmp ah, 4Bh ;left arrow
    jne Up
    call MoveLeft
    jmp ReadKeyboardLoop
Up:
    cmp ah, 48h ;up arrow
    jne Down
    call MoveUp
    jmp ReadKeyboardLoop
Down:
    cmp ah, 50h ;down arrow
    jne Space
    call MoveDown
    jmp ReadKeyboardLoop
Space:
    cmp ah, 39h ;space
    jne EnterCheck
    call ColorSlot
    mov [color], 7h
    call DisplayRect
    jmp ReadKeyboardLoop
EnterCheck:
    cmp al, 13 ;enter
    jne Eraser
    jmp EndMoveToken
Eraser: ;erase the slot
    cmp ah,0Eh
    jne EscCheck
    call EraseSlot
    mov [color], 7h
    call DisplayRect
    jmp ReadKeyboardLoop
EscCheck:;Press esc to exit
    cmp ah,1b ;esc
    jne ReadKeyboardLoop
EndMoveToken:
pop ax
    ret
endp MoveToken

proc MoveRight
push bx
    cmp [startX], 240 ;board limit
    jae EndMoveRight
    mov [color], 0
    mov bx,offset GameArray
    add bx,[index]
    cmp [byte ptr bx],1
    jne SquareR
    mov [color],1Eh
SquareR:
    call DisplayRect ;draw a black or white square

    add [startX], 20
    add [endX], 20
    mov [color], 7h
    call DisplayRect ;draw a small gray square
    inc [index]
EndMoveRight:
pop bx
    ret
endp MoveRight

proc MoveLeft
push bx
    cmp [startX], 80
    jbe EndMoveLeft
    mov [color], 0
    mov bx,offset GameArray
    add bx,[Index]
    cmp [byte ptr bx],1
    jne SquareL
    mov [color],1Eh
SquareL:
    call DisplayRect

    sub [startX], 20
    sub [endX], 20
    mov [color], 7h
    call DisplayRect
    dec [Index]
EndMoveLeft:
pop bx
    ret
endp MoveLeft

proc MoveUp
push bx
    cmp [startY], 40
    jbe EndMoveUp
    mov [color], 0h
    mov bx,offset GameArray
    add bx,[Index]
    cmp [byte ptr bx],1
    jne SquareU
    mov [color],1Eh
SquareU:
    call DisplayRect

    sub [startY], 20
    sub [endY], 20
    mov [color], 7h
    call DisplayRect
    sub [Index],10
EndMoveUp:
pop bx
    ret
endp MoveUp


proc MoveDown
push bx
    cmp [startY], 140
    jae EndMoveDown
    mov [color], 0h
    mov bx,offset GameArray
    add bx,[index]
    cmp [byte ptr bx],1
    jne SquareD
    mov [color],1Eh
SquareD:
    call DisplayRect

    add [startY], 20
    add [endY], 20
    mov [color], 7h
    call DisplayRect
    add [Index],10
EndMoveDown:
pop bx
    ret
endp MoveDown


proc EraseSlot
push bx
    mov [color], 0
    call AliveRectGraphics
    mov bx,offset GameArray
    add bx,[index]
    mov [byte ptr bx],0
pop bx
    ret
endp EraseSlot


proc ColorSlot
push bx
    mov [color], 1Eh
    call AliveRectGraphics
    mov bx, offset GameArray
    add bx, [Index]
    mov [byte ptr bx], 1
pop bx
    ret
endp ColorSlot


proc CheckIfColored
    mov [Index],0
    mov bx,offset GameArray

    mov [startX], 65
    mov [endX], 75
    mov [startY], 25
    mov [endY], 35

StartCheck:
    mov [neighborsCounter],0
    mov bx,offset GameArray
    add bx,[Index]
    cmp [byte ptr bx],3
    jne AfterCheck
    cmp [Index],10
    jb AfterUpCheck
    call UpCheck
AfterUpCheck:
    cmp [Index],59
    ja AfterDownCheck
    call DownCheck
AfterDownCheck:
    xor ax,ax
    mov ax,[index]
    inc ax
    mov dl,10
    div dl
    cmp ah,0
    je AfterRightCheck
    push 1
    call CheckNeighbors
AfterRightCheck:
    xor ax,ax
    mov ax,[Index]
    mov dl,10
    div dl
    cmp ah,0
    je AfterLeftCheck
    push -1
    call CheckNeighbors
AfterLeftCheck:
    cmp [neighborsCounter],3
    jne AfterCheck
    mov [color],44
    call AliveRectGraphics
AfterCheck:
    inc [Index]
    cmp [Index],80
    je EndCheckNeighbors
    mov dl,10
    mov ax,[Index]
    div dl
    cmp ah,0
    je DownLine
    add [startX], 20
    add [endX], 20
    jmp StartCheck
DownLine:
    mov [startX], 65
    mov [endX], 75
    add [startY], 20
    add [endY], 20
    jmp StartCheck
EndCheckNeighbors:
    ret
endp CheckIfColored

proc ColorSign
    mov [color],0
    cmp [neighborsCounter],3
    jne EndColorSign
    mov [color],0Eh
EndColorSign:
    ret
endp ColorSign

proc UpCheck
    push -10
    call CheckNeighbors
    mov ax,[index]
    mov dl,10
    div dl
    cmp ah,0
    je AfterLeftUpCheck
    push -11
    call CheckNeighbors
AfterLeftUpCheck:
    xor ax,ax
    mov ax,[Index]
    inc ax
    mov dl,10
    div dl
    cmp ah,0
    je AfterRightUpCheck
    push -9
    call CheckNeighbors
AfterRightUpCheck:
    ret
endp UpCheck

proc DownCheck
    push 10
    call CheckNeighbors
    mov ax,[Index]
    mov dl,10
    div dl
    cmp ah,0
    je AfterLeftDownCheck
    push 9
    call CheckNeighbors
AfterLeftDownCheck:
    xor ax,ax
    mov ax,[Index]
    inc ax
    mov dl,10
    div dl
    cmp ah,0
    je AfterRightDownCheck
    push 11
    call CheckNeighbors
AfterRightDownCheck:
    ret
endp DownCheck


Proc CheckNeighbors
push bp
    mov bp,sp
push ax
push bx
    mov ax,[bp+4]
    mov bx,offset GameArray
    add bx,[Index]
    add bx,ax
    cmp [byte ptr bx],1
    jne EndCheck
    inc [neighborsCounter]
EndCheck:
pop bx
pop ax
pop bp
    ret 2
endp CheckNeighbors


start:
    mov ax,@data
    mov ds,ax

Preview:
    call SwitchToTextMode
    call PrintPicture
    call DisplayBoard


Game:
    call MoveToken
    call CheckIfColored
    ;jmp Game


Exit:
    mov ax, 4c00h
    int 21h
END start