temp.asm

%include "/usr/local/share/csc314/asm_io.inc"

; the file that stores the initial state
%define BOARD_FILE 'board.txt'
%define BOARDII_FILE 'level2.txt'
%define BOARDIII_FILE 'level3.txt'
%define BOARDIV_FILE 'level4.txt'
%define MARRIAGE_FILE 'Marriage.txt'
%define LOADING_FILE 'loading.txt'
%define LOSE_FILE 'lose.txt'

; how to represent everything
%define WALL_CHAR '#'
%define GATE_CHAR '_'
%define PLAYER_CHAR 'O'
%define THE_MISSUS 'M'                  ;get caught and get Married
%define TELEPORT_CHAR '='
%define NULL_CHAR ' '
%define ORB_CHAR '.'
%define SPECIALORB_CHAR '@'             ;make it to end of game and get a Divorce
%define BOMB_CHAR '*'
%define WATER_CHAR '~'					;visually replaced in render, but used to distinguish in the stack
%define WET_ORB_CHAR ','

; the size of the game screen in characters
%define HEIGHT 23       ;also used for marriage file
%define WIDTH 45        ; mfile
%define HEIGHTII 21
%define WIDTHII 57
%define HEIGHTIII 23
%define WIDTHIII 55
%define HEIGHTIV 23
%define WIDTHIV 49

; the player starting position.
; top left is considered (0,0)
%define STARTX 22                       ;level 1
%define STARTY 15                       ;level 1
%define M_STARTX 22                     ;level 1
%define M_STARTY 11                     ;level 1
%define STARTIIX 28                             ;level 2
%define STARTIIY 14                             ;level 2
%define M_STARTIIX 28                   ;level 2
%define M_STARTIIY 9                    ;level 2
%define STARTIIIX 28                    ;level 3
%define STARTIIIY 13                    ;level 3
%define M_STARTIIIX 28                  ;level 3
%define M_STARTIIIY     11                      ;level 3
%define STARTIVX 26                             ;level 4
%define STARTIVY 15                             ;level 4
%define M_STARTIVX 28                   ;level 4
%define M_STARTIVY 11                   ;level 4

; teleport to positions
%define TEL_ONEX 2                      ;level 1,2,3
%define TEL_ONEY 11                     ;level 1,2,3
%define TEL_ONEIVY 5            ;level 4

%define TEL_TWOX 42             ;for level 1
%define TEL_TWOIIX 54           ;for level 2
%define TEL_TWOIIIX 52          ;level 3
%define TEL_TWOIVX 46           ;level 4
%define TEL_TWOY 11                     ;for level 1,2,3,4

; ending positions
%define WIN_X 24
%define WIN_Y 6
%define LOSE_X 22
%define LOSE_Y 14

; these keys do things
%define EXITCHAR 'x'
%define UPCHAR 'w'
%define LEFTCHAR 'a'
%define DOWNCHAR 's'
%define RIGHTCHAR 'd'
%define BOMBCHAR 'b'

; how many orbs to replace with bombs
%define NUM_BOMBS 3

; dot counts
%define DOTS 248
%define DOTSII 256
%define DOTSIII 300
%define DOTSIV 262

segment .data

        ; used to fopen() the board file defined above
        board_file                      db BOARD_FILE,0
        level2_file                     db BOARDII_FILE,0
        level3_file             db BOARDIII_FILE,0
        level4_file                     db BOARDIV_FILE,0
        win_file                        db MARRIAGE_FILE,0
        loading_file            db LOADING_FILE,0
        lose_file                       db LOSE_FILE,0

        ;helper vars
        score dq 0
        level db 1
        caught db 0

        ;special orbs
        safeguard dq 0          ;allows you to send the missus back to her start
        safetxt db 27, "[38;2;255;165;0m", " Safeguard: ", 27, "[0m",0

        ;bomb vars
        bombs dd 0
        bombtxt db 27, "[38;5;74m", " Bombs: ", 27, "[0m",0
        explode db 0

        spacetxt db " - ",0

		;water label to check if water was added
		water_increased db 0

        ;lives
        lives dd 3
        livestxt db 27,"[31m"," Lives: ",27,"[0m",0

        ; used to change the terminal mode
        mode_r                          db "r",0
        raw_mode_on_cmd         db "stty raw -echo",0
        raw_mode_off_cmd        db "stty -raw echo",0

        ; ANSI escape sequence to clear/refresh the screen
        clear_screen_code       db      27,"[2J",27,"[H",0

        ; things the program will print
        help_str                        db 13,10,"Controls: ", \
                                                        UPCHAR,"=UP / ", \
                                                        LEFTCHAR,"=LEFT / ", \
                                                        DOWNCHAR,"=DOWN / ", \
                                                        RIGHTCHAR,"=RIGHT / ", \
                                                        EXITCHAR,"=EXIT / ", \
                                                        BOMBCHAR,"=BOMB", \
                                                        13,10,10,0

        ; helper text
        scoretxt db "Score: ",0

        ; won the game
        congrats_txt db 13,10,"YOU WIN: ",\
                                         "Congrats on your marriage to The Missus!",\
                                        13,10,10,0
        winvar  db 0
        losevar db 0
        loading db 0
        missus_first_move dd 1

        ;colors
        blue_code db 27,"[38;2;33;33;222m",0
        cyan_code db 27,"[38;2;0;255;255m",0
        gray_code db 27,"[38;2;211;211;211m",0
        yellow_code db 27,"[38;2;255;255;0m",0  ;player character
        orange_code db 27,"[38;2;255;165;0m",0  ;safe player
        pink_code db 27,"[38;2;247;83;148m",0   ;Missus character
        peach_code db 27,"[38;2;255;211;172m",0 ;orbs
        red_code db 27,"[31m",0
        light_blue_code db 27,"[38;5;74m",0		;bombs
		blue_background_code db 27,"[44m",0		;water
        reset_code db 27,"[0m",0

        board_pointers:
                dd board
                dd board2
                dd board3
                dd board4

segment .bss

        ; this array stores the current rendered gameboard (HxW)
        board   resb    (HEIGHT * WIDTH)
        board2  resb    (HEIGHTII * WIDTHII)
        board3  resb    (HEIGHTIII * WIDTHIII)
        board4  resb    (HEIGHTIV * WIDTHIV)

        ; these variables store the current player position
        xpos    resd    1
        ypos    resd    1

        ; random number seed variable
        seed    resd    1

        ;bomb location variable (for replacing orbs)
        bomb_x  resd    1

        ; missus position vars
        m_xpos    resd  1
        m_ypos    resd  1

        curheight resd  1
        curwidth  resd  1
        dots_req  resd  1
        dots_eaten resd 1

segment .text

        global  asm_main
        global  raw_mode_on
        global  raw_mode_off
        global  init_board
        global  render
        global  explode_space

        extern  system
        extern  putchar
        extern  getchar
        extern  printf
        extern  fopen
        extern  fread
        extern  fgetc
        extern  fclose

asm_main:
        push    ebp
        mov             ebp, esp

        ; put the terminal in raw mode so the game works nicely
        call    raw_mode_on

initial_levelchk:
        ; read the game board file into the global variable
                ; check level
                cmp     BYTE [level], 1
                je              start_pos
                cmp     BYTE [level],2
                je start2_pos
                cmp     BYTE [level],3
                je start3_pos
                ;else level 4
                        mov             DWORD [curheight], HEIGHTIV
                        mov     DWORD [curwidth],  WIDTHIV
                        mov             DWORD [dots_req],   DOTSIV
                        call init_board         ;init a dif board
                        reset_positions4:
                        mov     DWORD [xpos], STARTIVX
                        mov     DWORD [ypos], STARTIVY
                        ;missus code
                        just_mpos4:
                        mov     DWORD [m_xpos], M_STARTIVX
                        mov     DWORD [m_ypos], M_STARTIVY
                        jmp end_lvlchk
                start_pos:
                        mov     DWORD [curheight], HEIGHT
                        mov     DWORD [curwidth],  WIDTH
                        call init_board
                        ;check if win
                        cmp     BYTE [winvar], 1
                        je              win_step2
                        ;check if loading screen
                        cmp             BYTE [loading], 1
                        je              loading_step2
                        ;check if lose
                        cmp             BYTE [losevar], 1
                        je              lose_step2
                        mov     DWORD [dots_req],   DOTS
                        reset_positions:
                        mov             DWORD [xpos], STARTX
                        mov             DWORD [ypos], STARTY
                        ;missus code
                        just_mpos:
                        mov DWORD [m_xpos], M_STARTX
                        mov DWORD [m_ypos], M_STARTY
                        jmp end_lvlchk
                start2_pos:
                        mov     DWORD [curheight], HEIGHTII
                        mov     DWORD [curwidth],  WIDTHII
                        mov             DWORD [dots_req],   DOTSII
                        call init_board         ;init a dif board
                        reset_positions2:
                        mov     DWORD [xpos], STARTIIX
                        mov     DWORD [ypos], STARTIIY
                        ;missus code
                        just_mpos2:
                        mov     DWORD [m_xpos], M_STARTIIX
                        mov     DWORD [m_ypos], M_STARTIIY
                        jmp end_lvlchk
                start3_pos:
                        mov     DWORD [curheight], HEIGHTIII
                        mov     DWORD [curwidth],  WIDTHIII
                        mov             DWORD [dots_req],   DOTSIII
                        call init_board         ;init a dif board
                        reset_positions3:
                        mov     DWORD [xpos], STARTIIIX
                        mov     DWORD [ypos], STARTIIIY
                        ;missus code
                        just_mpos3:
                        mov             DWORD [m_xpos], M_STARTIIIX
                        mov             DWORD [m_ypos], M_STARTIIIY
                        jmp end_lvlchk
                end_lvlchk:

                cmp     BYTE [caught], 1
                jmp             post_losechk

        ; set the player at the proper start position

        ; the game happens in this loop
        ; the steps are...
        ;   1. render (draw) the current board
        ;   2. get a character from the user
        ;       3. store current xpos,ypos in esi,edi
        ;       4. update xpos,ypos based on character from user
        ;       5. check what's in the buffer (board) at new xpos,ypos
        ;       6. if it's a wall, reset xpos,ypos to saved esi,edi
        ;       7. otherwise, just continue! (xpos,ypos are ok)
        game_loop:
                ; draw the game board
                call    render

				;checks if water increased and the screen needs a refresh
				cmp		[water_increased], BYTE 2
				jne		do_not_refresh_water
				call	render

				do_not_refresh_water:

                ;temporary print of score
                mov eax, scoretxt
                call print_string
                mov eax, [score]
                call print_int

                ;temporary print of bombs
                mov eax, bombtxt
                call print_string
                mov eax, [bombs]
                call print_int

                ;print of lives
                mov eax, livestxt
                call print_string
                mov eax, [lives]
                call print_int

                ;print safeguard
                mov eax, safetxt
                call print_string
                mov eax, [safeguard]
                call print_int
                call print_nl

                ; get an action from the user
                call    getchar

                ; store the current position
                ; we will test if the new position is legal
                ; if not, we will restore these
                mov             esi, DWORD [xpos]
                mov             edi, DWORD [ypos]

                ; choose what to do
                cmp             eax, EXITCHAR
                je              game_loop_end
                cmp             eax, UPCHAR
                je              move_up
                cmp             eax, LEFTCHAR
                je              move_left
                cmp             eax, DOWNCHAR
                je              move_down
                cmp             eax, RIGHTCHAR
                je              move_right
                cmp     eax, BOMBCHAR
                je              move_bomb
                jmp             input_end                       ; or just do nothing

                ; move the player according to the input character
                move_up:
                        dec             DWORD [ypos]
                        jmp             input_end
                move_left:
                        sub             DWORD [xpos],2
                        jmp             input_end
                move_down:
                        inc             DWORD [ypos]
                        jmp             input_end
                move_right:
                        add             DWORD [xpos],2
                        jmp             input_end
                move_bomb:
                        cmp     [bombs], DWORD 1
                        jl              input_end
                        mov     [explode], DWORD 1              ;1 used to signal on
                input_end:

                ; (W * y) + x = pos

                ; compare the current position to the wall character
                mov             eax, [curwidth]
                mul             DWORD [ypos]
                add             eax, DWORD [xpos]

                ;check board level
                movzx ecx, BYTE [level]
                dec ecx
                mov edx, [board_pointers + ecx*4]
                lea eax, [edx + eax]

                cmp             BYTE [eax], WALL_CHAR
                je              invalid_move
                cmp     BYTE [eax], GATE_CHAR
                jne             valid_move

                invalid_move:
                        ; opps, that was an invalid move, reset
                        mov             DWORD [xpos], esi
                        mov             DWORD [ypos], edi
                valid_move:
                cmp BYTE[eax], TELEPORT_CHAR
                jne normal_mov
                        ; teleportation, spooky
                        ;teleport level check
                        cmp     BYTE [level], 1
                        je              telb1
                        cmp     BYTE [level], 2
                        je              telb2
                        cmp     BYTE [level], 3
                        je              telb3
                        cmp     BYTE [level], 4
                        je              telb4
                telb1:
                        cmp DWORD [xpos], 0
                        jz telb1right
                        ;else left
                left1:
                        mov DWORD [xpos], TEL_ONEX
                        mov DWORD [ypos], TEL_ONEY
                        jmp new_pos
                telb1right:
                        mov DWORD [xpos], TEL_TWOX
                        mov DWORD [ypos], TEL_TWOY
                        jmp new_pos
                telb2:
                        cmp DWORD [xpos], 0
                        jz telb2right
                        ;else left
                        jmp left1
                telb2right:
                        mov DWORD [xpos], TEL_TWOIIX
                        mov DWORD [ypos], TEL_TWOY
                        jmp new_pos
                telb3:
                        cmp DWORD [xpos], 0
                        jz telb3right
                        ;else left
                        jmp left1
                telb3right:
                        mov DWORD [xpos], TEL_TWOIIIX
                        mov DWORD [ypos], TEL_TWOY
                        jmp new_pos
                telb4:
                        cmp DWORD [xpos], 0
                        jz telb4right
                        ;else left
                        mov DWORD [xpos], TEL_ONEX
                        mov DWORD [ypos], TEL_ONEIVY
                        jmp new_pos
                telb4right:
                        mov DWORD [xpos], TEL_TWOIVX
                        mov DWORD [ypos], TEL_TWOY
                        jmp new_pos
                new_pos:
                        ;recalculate position
                        mov             eax, [curwidth]
                        mul             DWORD [ypos]
                        add             eax, DWORD [xpos]

                ;check board level
                movzx ecx, BYTE [level]
                dec ecx
                mov edx, [board_pointers + ecx*4]
                lea eax, [edx + eax]

                        jmp normal_mov

                normal_mov:
                ;check if safeguard needs to dec
                cmp             DWORD [safeguard], 0
                jle             skip_safechk
                dec             DWORD [safeguard]
                skip_safechk:
                ;check if need to inc the score
                cmp             BYTE [eax], ORB_CHAR
				je		check_orb
				cmp				BYTE [eax], WET_ORB_CHAR
                jne     after_orb
				check_orb:
                        mov             ebx, [score]
                        add             ebx, 10
                        mov     [score], ebx
                        inc             DWORD [dots_eaten]
                        ;replaces the orb character with empty space
                        mov     BYTE [eax], NULL_CHAR
                ; extra points will need to modify to give ability to eat ghosts once we get there
                after_orb:
                cmp     BYTE [eax], SPECIALORB_CHAR
                jne     after_specialorb
                        mov     ebx, [score]
                        add     ebx, 50
                        inc     DWORD [dots_eaten]
                        mov     [score], ebx
                        mov             BYTE [safeguard], 15

                        ;replace with empty space
                        mov     BYTE [eax], NULL_CHAR
                after_specialorb:
                mov             edx, [dots_eaten]
                cmp             edx, DWORD [dots_req]
                jz              screen_change

                ;check if need to increase the bombs
                cmp             BYTE [eax], BOMB_CHAR
                jne             after_bomb_collect
                                mov             ebx, [bombs]
                                inc             ebx
                                mov             [bombs], ebx
                                ;replaces the bomb character with empty space
                                mov             BYTE [eax], NULL_CHAR
                after_bomb_collect:

                ;checks if it should explode (this can be moved to after missus movement if wanted)
                cmp             [explode], DWORD 1
                jne             no_explode

				pusha		;save registers
                ;does explosion via for loop
                mov             ecx, 0  ;ecx is the x loop counter
                mov             edx, 0  ;edx is the y loop counter
                mov             eax, DWORD [xpos]
                mov             ebx, DWORD [ypos]
                sub             eax, 2
                sub             ebx, 1

                explode_loop_x:

                        explode_loop_y:
                                pusha                                   ;save current registers
                                push    eax                             ;pass xpos
                                push    ebx                             ;pass ypos
                                call    explode_space
                                add             esp, 8
                                popa                                    ;restore registers

                                inc ebx                                 ;go to next ypos
                                inc edx                                 ;up y loop counter
                                cmp edx, 2
                                jle explode_loop_y

                        inc eax                                         ;go to next xpos
                        mov ebx, DWORD [ypos]           ;set ypos to original
                        sub ebx, 1
                        ;makes ypos 1 less
                        mov edx, 0                                      ;resets inner loop counter
                        inc ecx                                         ;up x loop counter
                        cmp ecx, 4
                        jle explode_loop_x

                        ;turns off the explosion and use a bomb
                        mov eax, 0
                        mov [explode], eax
                        sub [bombs], DWORD 1
					popa	;retrieve registers
                no_explode:

				;check if moving into water
				cmp BYTE [eax], WATER_CHAR
				je water_penalty
				cmp BYTE [eax], WET_ORB_CHAR
				jne no_water_penalty

				water_penalty:
					mov ebx, [score]
					sub ebx, 5
					mov [score], ebx

				no_water_penalty:

                ;missus movement code
                        ; check if missus first move
            cmp dword[missus_first_move], 1
            jne normal_missus_move

                        mov eax, [m_xpos]       ; missus current x position
            mov ebx, [m_ypos]   ; missus current y position
            sub ebx, 2          ; up 2

            mov [m_xpos], eax
            mov [m_ypos], ebx
            mov dword [missus_first_move],0             ;first move has happened
            jmp missus_done

            normal_missus_move:
                        ; compare Missus x to players x
            mov eax, [m_xpos]
            mov ebx, [m_ypos]

            mov ecx, [xpos]
            cmp eax, ecx        ; missus x cordinate and player x corrdiante
                je missus_try_y

            jl missus_right
            jg missus_left

                        missus_right:
                add eax, 2
                jmp missus_check_wall

            missus_left:
                sub eax, 2
                jmp missus_check_wall

            missus_try_y:
                mov ecx, [ypos]         ;load player y
                cmp ebx, ecx        ; missus y cordinate and player y cordinate
                je missus_done
                                jl missus_down
                                jg missus_up

                        missus_down:
                inc ebx
                jmp missus_check_wall

            missus_up:
                dec ebx

            missus_check_wall:
                mov edx, [curwidth]   ;current board width
                imul edx, ebx         ; linear index because 2d board
                add edx, eax
                ;lea esi, [board + edx]         ;was an issue, fixed
                                ;check board level
                                movzx ecx, BYTE [level]
                                dec ecx
                                mov ecx, [board_pointers + ecx*4]
                                lea esi, [ecx + edx]

                                cmp BYTE[esi], WALL_CHAR    ;is there a wall there
                je missus_blocked

                cmp BYTE[esi], GATE_CHAR        ;is there a gate there
                je missus_blocked

                jmp missus_set_pos          ;valid move

                missus_blocked:
                        mov eax, [m_xpos]
                    mov ebx, [m_ypos]

                                ; check player y ; defaults left or right based on midline
                mov ecx, [ypos]
                cmp ecx, 15
                jg try_down
                jl try_up
                je mx_check

                ; horizontal midline to establish defaults
                mx_check:
                        mov ecx, [xpos]
                    cmp ecx, 22
                    jg confused_move_right

                    ;;left
                    sub eax, 2
                    mov esi, [curwidth]
                    imul esi, ebx
                    add esi, eax
                    ;lea esi, [board + esi]     ;was an issue, fixed
                                        ;check board level
                                        movzx edx, BYTE [level]
                                        dec edx
                                        mov edx, [board_pointers + edx*4]
                                        lea esi, [edx + esi]

                    cmp BYTE [esi], WALL_CHAR
                    je missus_done
                    mov [m_xpos], eax
                    jmp missus_done

                confused_move_right:
                                        add eax, 2
                    mov esi, [curwidth]
                    imul esi, ebx
                    add esi, eax
                    ;lea esi, [board + esi]             ;was an issue, fixed
                                        ;check board level
                                        movzx ecx, BYTE [level]
                                        dec ecx
                                        mov ecx, [board_pointers + ecx*4]
                                        lea esi, [ecx + esi]

                    cmp BYTE [esi], WALL_CHAR
                    je missus_done
                    mov [m_xpos], eax
                    jmp missus_done


                                try_up:
                        mov edx, ebx
                    dec edx

                    mov esi, [curwidth]
                    imul esi, edx
                    add esi, eax
                    ;lea esi, [board + esi]     ;was an issue, fixed
                                        ;check board level
                                        movzx ecx, BYTE [level]
                                        dec ecx
                                        mov ecx, [board_pointers + ecx*4]
                                        lea esi, [ecx + esi]

                    cmp BYTE[esi], WALL_CHAR
                    je missus_done
                    mov [m_ypos], edx
                    jmp missus_done

                                try_down:
                        mov edx, ebx
                    inc edx

                    mov esi, [curwidth]
                    imul esi, edx
                    add esi, eax
                    ;lea esi, [board + esi]     ;ISSUE HERE
                                        ;check board level
                                        movzx ecx, BYTE [level]
                                        dec ecx
                                        mov ecx, [board_pointers + ecx*4]
                                        lea esi, [ecx + esi]

                    cmp BYTE [esi], WALL_CHAR
                    je missus_done
                    mov [m_ypos], edx
                    jmp missus_done

                                ;saves the valid move
                missus_set_pos:
                        mov [m_xpos], eax
                    mov [m_ypos], ebx
                    jmp missus_done

                missus_done:
                ; check if player loses
                ;cmp            BYTE [eax], THE_MISSUS  ;doesn't work, compare positions instead?
                mov                     ebx, [xpos]
                cmp                     ebx, [m_xpos]
                jne                     post_losechk
                mov                     ebx, [ypos]
                cmp                     ebx, [m_ypos]
                jne                     post_losechk
                ;check if points for catching missus
                cmp                     DWORD [safeguard],0
                jle                     past_ghost_points
                mov                     ebx, [score]
                add                     ebx, 200
                mov                     [score], ebx
                inc             DWORD [lives]
                past_ghost_points:
                mov             DWORD [missus_first_move], 1
                        dec             DWORD [lives]
                        cmp             DWORD [lives], 0
                je                      lose
                mov             BYTE [caught], 1
                ;check level to reset positions
                cmp                     BYTE [level], 1
                je                      lose1
                cmp                     BYTE [level], 2
                je                      lose2
                cmp                     BYTE [level], 3
                je                      lose3
                cmp                     BYTE [level], 4
                je                      lose4
                lose1:
                        cmp                     DWORD [safeguard],0
                        jle                     all_pos
                        jmp                     just_mpos
                        all_pos:
                        jmp                     reset_positions
                lose2:
                        cmp                     DWORD [safeguard],0
                        jle                     all_pos2
                        jmp                     just_mpos2
                        all_pos2:
                        jmp                     reset_positions2
                lose3:
                        cmp                     DWORD [safeguard],0
                        jle                     all_pos
                        jmp                     just_mpos3
                        all_pos3:
                        jmp                     reset_positions3
                lose4:
                        cmp                     DWORD [safeguard],0
                        jle                     all_pos4
                        jmp                     just_mpos4
                        all_pos4:
                        jmp                     reset_positions4
                post_losechk:
                mov     BYTE [caught], 0

        jmp             game_loop
        screen_change:
        cmp     BYTE [level], 4
        je              win
        mov             BYTE [loading], 1               ;loading screen in between levels
        jmp     start_pos
        loading_step2:
        mov     BYTE  [loading], 0
        mov             DWORD [dots_eaten], 0
        mov     DWORD [missus_first_move], 1
        mov             DWORD [lives], 3
        mov             [bombs], DWORD 0
        call    render
        ;get c input to move on
        waiting_loop:                                   ;wait for signal to continue
                call    getchar
                cmp             eax, 120                        ;in case player wants to quit
                je              game_loop_end
                cmp             eax, 99                         ;ascii for c or C
                je              end_wait
                cmp     eax, 67
                je              end_wait
                jmp             waiting_loop
        end_wait:
                inc             BYTE [level]
                jmp             initial_levelchk                ;start new level
        win:
                mov     BYTE [winvar], 1
                jmp             start_pos                       ;need board to be size 1
        ;mov player char position here
        win_step2:
                mov     DWORD [xpos], WIN_X
                mov     DWORD [ypos], WIN_Y
                call    render                  ;print out the new file
                jmp             game_loop_end
        lose:
                mov             BYTE [losevar], 1
                jmp             start_pos
        lose_step2:
                mov             DWORD [xpos], LOSE_X
                mov             DWORD [ypos], LOSE_Y
                call    render
        game_loop_end:

        ; restore old terminal functionality
        call raw_mode_off

        mov             eax, 0
        mov             esp, ebp
        pop             ebp
        ret

raw_mode_on:

        push    ebp
        mov             ebp, esp

        push    raw_mode_on_cmd
        call    system
        add             esp, 4

        mov             esp, ebp
        pop             ebp
        ret

raw_mode_off:

        push    ebp
        mov             ebp, esp

        push    raw_mode_off_cmd
        call    system
        add             esp, 4

        mov             esp, ebp
        pop             ebp
        ret

init_board:

        push    ebp
        mov             ebp, esp

        ; FILE* and loop counter
        ; ebp-4, ebp-8
        sub             esp, 8

        ; open the file
        push    mode_r
                ;check the board/screen
                cmp             BYTE [winvar],  1
                je              initwin
                cmp             BYTE [losevar], 1
                je              initlose
                cmp             BYTE [loading], 1
                je              initloading
                cmp     BYTE [level], 1
                je              initb1
                cmp     BYTE [level], 2
                je              initb2
                cmp     BYTE [level], 3
                je      initb3
                cmp     BYTE [level], 4
                je              initb4
                initwin:
                        push    win_file
                        jmp             end_filechk
                initlose:
                        push    lose_file
                        jmp             end_filechk
                initloading:
                        push    loading_file
                        jmp             end_filechk
                initb1:
                        push    board_file
                        jmp     end_filechk
                initb2:
                        push    level2_file
                        jmp     end_filechk
                initb3:
                        push    level3_file
                        jmp             end_filechk
                initb4:
                        push    level4_file
        end_filechk:
        call    fopen
        add             esp, 8
        mov             DWORD [ebp - 4], eax
        ; read the file data into the global buffer
        ; line-by-line so we can ignore the newline characters
        mov             DWORD [ebp - 8], 0
        read_loop:
                xor edx, edx
                mov edx, [curheight]
                cmp             DWORD [ebp - 8], edx
        je              read_loop_end

                ; find the offset (WIDTH * counter)
                mov             eax, [curwidth]
                mul             DWORD [ebp - 8]
                ;check board level
                movzx ecx, BYTE [level]
                dec ecx
                mov ecx, [board_pointers + ecx*4]
                lea ebx, [ecx + eax]

                ; read the bytes into the buffer
                push    DWORD [ebp - 4]
                ;use a register instead of a level check
                xor edx, edx
                mov edx, [curwidth]
                push    edx
                push    1
                push    ebx
                call    fread
                add             esp, 16

                ; slurp up the newline
                push    DWORD [ebp - 4]
                call    fgetc
                add             esp, 4

        inc             DWORD [ebp - 8]
        jmp             read_loop
        read_loop_end:

        ; close the open file handle
        push    DWORD [ebp - 4]
        call    fclose
        add             esp, 4

        cmp             BYTE [winvar],  1
        je              skip_otb
        cmp             BYTE [loading], 1
        je              skip_otb
        cmp             BYTE [losevar], 1
        je              skip_otb

        ; replace orbs with bombs
        mov ecx, 0              ;ecx is the loop counter
        orb_to_bomb:
                push ecx        ;store ecx

                ;get random x
                call random_num
                cdq
                mov ebx, [curwidth]
                idiv ebx                                ;remainder stored in edx
                mov [bomb_x], edx               ;temporarily storing the remainder in bomb_x

                ;get random y
                call random_num
                cdq
                mov ebx, [curheight]
                idiv ebx                                ;remainder stored in edx
                mov             eax, [curwidth]
                mul             edx
                add             eax, [bomb_x]
                ;lea    eax, [board + eax]              ;will cause an error
                ;check board level
                movzx edi, BYTE [level]
                dec edi
                mov edi, [board_pointers + edi*4]
                lea eax, [edi + eax]

                cmp BYTE [eax], ORB_CHAR
                jne orb_to_bomb                 ;if not replaceable, get new cords

                ;if it can be replaced, replace it and increase valid bombs placed
                mov BYTE [eax], BOMB_CHAR

                pop ecx         ;retrieve ecx
                inc ecx

                cmp ecx, NUM_BOMBS      ;if there are not enough vaild bombs, go to loop start
                jl orb_to_bomb
        skip_otb:

        mov             esp, ebp
        pop             ebp
        ret

render:

        push    ebp
        mov             ebp, esp

        ; two ints, for two loop counters
        ; ebp-4, ebp-8
        sub             esp, 8

        ; clear the screen
        push    clear_screen_code
        call    printf
        add             esp, 4

        cmp             BYTE [winvar], 1
        jne             lose_chk
        ;print the congrats message
        push    congrats_txt
        call    printf
        add             esp, 4
        jmp post_help
        lose_chk:
        cmp             BYTE [losevar],1
        je              post_help
        help_info:
        ; print the help information
        push    help_str
        call    printf
        add             esp, 4
        post_help:

        ; outside loop by height
        ; i.e. for(c=0; c<height; c++)
        mov             DWORD [ebp - 4], 0
        y_loop_start:
                xor edx, edx
                mov edx, [curheight]
                cmp             DWORD [ebp - 4], edx
        je              y_loop_end

                ; inside loop by width
                ; i.e. for(c=0; c<width; c++)
                mov             DWORD [ebp - 8], 0
                x_loop_start:
                        xor edx, edx
                        mov edx, [curwidth]
                        cmp             DWORD [ebp - 8], edx
                je              x_loop_end

                        ; check if (xpos,ypos)=(x,y)
                        mov             eax, DWORD [xpos]
                        cmp             eax, DWORD [ebp - 8]
                        jne             check_m
                        mov             eax, DWORD [ypos]
                        cmp             eax, DWORD [ebp - 4]
                        jne             check_m
                                ; if both were equal, print the player
                                cmp     DWORD [safeguard], 0
                                je              normal_player
                                push    orange_code
                                jmp             skip_normal_player
                                normal_player:
                                push    yellow_code
                                skip_normal_player:
                                call    printf
                                add     esp,4
                                push    PLAYER_CHAR
                                call    putchar
                                jmp             print_end

                        ;render missus character
                        check_m:
                        cmp             BYTE [winvar],  1
                        je              print_board
                        cmp             BYTE [loading], 1
                        je              print_board
                        cmp             BYTE [losevar], 1
                        je              print_board
                                mov eax, DWORD [m_xpos]
                cmp eax, DWORD [ebp - 8]
                jne print_board
                mov eax, DWORD [m_ypos]
                cmp eax, DWORD [ebp - 4]
                jne print_board

                push pink_code
                call printf
                add esp, 4
                push THE_MISSUS
                call putchar
                jmp print_end

                        print_board:
                                ; otherwise print whatever's in the buffer
                                mov             eax, DWORD [ebp - 4]
                                mov             ebx, [curwidth]
								xor				edx, edx		;clear edx
                                mul             ebx
                                add             eax, DWORD [ebp - 8]
                                mov             ebx, 0
                        ;check board level
                        movzx edi, BYTE [level]
                        dec edi
                        mov edi, [board_pointers + edi*4]
                        mov bl, [edi + eax]

                        ;special character are a different color
                                cmp     ebx, THE_MISSUS         ;this will need to be changed similar to player char
                                je              missus_print            ; once movement is added
                                cmp             ebx, ORB_CHAR
                                je              orb_print
                                cmp     ebx, SPECIALORB_CHAR
                                je              specialorb_print
                                cmp             ebx, GATE_CHAR
                                je              gate_print
                                cmp     ebx, TELEPORT_CHAR
                                je              teleport_print
                                cmp     ebx, WALL_CHAR
                                je              wall_print
                                cmp     ebx, BOMB_CHAR
                                je              bomb_print
                                cmp             ebx, '+'
                                je              plus_print
								cmp		ebx, WATER_CHAR
								je				water_print
								cmp		ebx, WET_ORB_CHAR
								je				wet_orb_print
                                jmp     normal_print

                        missus_print:
                                push    pink_code
                                jmp     special_print
                        plus_print:
                                push    red_code
                                jmp     special_print
                        orb_print:
                                push    peach_code
                                jmp             special_print
                        specialorb_print:
                                push    orange_code
                                jmp             special_print
                        teleport_print:
                                push    cyan_code
                                jmp             special_print
                        wall_print:
                                push    blue_code
                                jmp     special_print
                        gate_print:
                                push    gray_code
                                jmp             special_print
                        bomb_print:
                                push    light_blue_code
                                jmp             special_print
						water_print:
								cmp		[water_increased], BYTE 2
								je 	no_more_water
								push	DWORD [ebp-8]		;xpos
								push	DWORD [ebp-4]		;ypos
								call	water_calc			;tries to add water
								add		esp, 8
								no_more_water:
								push	blue_background_code
								mov 	ebx, NULL_CHAR			;gives it more of a water appearance
								jmp				special_print
						wet_orb_print:
								cmp		[water_increased], BYTE 2
								je 	no_more_water2
								push	DWORD [ebp-8]		;xpos
								push	DWORD [ebp-4]		;ypos
								call	water_calc			;tries to add water
								add		esp, 8
								no_more_water2:
								push	blue_background_code
								mov 	ebx, ORB_CHAR			;gives it more of a water appearance
								jmp				special_print
                        special_print:
                                call    printf
                                add     esp, 4

                        normal_print:
                                push    ebx
                                call    putchar
                                add             esp, 4
                        print_end:
                                ;reset color
                                push    reset_code
                                call    printf
                                add     esp, 4

                inc             DWORD [ebp - 8]
                jmp             x_loop_start
                x_loop_end:

                ; write a carriage return (necessary when in raw mode)
                push    0x0d
                call    putchar
                add             esp, 4

                ; write a newline
                push    0x0a
                call    putchar
                add             esp, 4

        inc             DWORD [ebp - 4]
        jmp             y_loop_start
        y_loop_end:

		;checks if it needs to refresh water on the screen
		cmp				[water_increased], BYTE 1
		jne 			water_not_increased
		mov				[water_increased], BYTE 2
		jmp 			water_increased_check_end

		water_not_increased:
		mov				[water_increased], BYTE 0

		water_increased_check_end:

        mov             esp, ebp
        pop             ebp
        ret

explode_space:
        push    ebp
        mov             ebp, esp

        mov             eax, [curwidth]
		xor				edx, edx			;clear edx
        mul             DWORD [ebp + 8]
        add             eax, DWORD [ebp + 12]
        ;lea    eax, [board + eax]      ;ISSUE
                        ;check board level
                        movzx edi, BYTE [level]
                        dec edi
                        mov edi, [board_pointers + edi*4]
                        lea     eax, [edi + eax]

        ;checks to make sure it is not the border wall
        cmp [ebp + 8], DWORD 0
        je do_not_explode
        mov ebx, [curheight]
        dec ebx
        cmp [ebp + 8], ebx
        je do_not_explode
        cmp [ebp + 12], DWORD 0
        je do_not_explode
        mov ebx, [curwidth]
        dec ebx
        cmp [ebp + 12], ebx
        je do_not_explode

        ;checks if it is something that can explode
        cmp             BYTE [eax], WALL_CHAR
        je do_explode
        cmp             BYTE [eax], GATE_CHAR
        je do_explode
        jmp do_not_explode

        do_explode:
				pusha				;temporarily registers
				call random_num
				cdq
				mov ebx, 100		;used to find mod 100
				idiv ebx
				cmp edx, 1
				popa				;retrieving registers
				jge do_not_place_water

                mov BYTE [eax], WATER_CHAR
				jmp end_water_place

				do_not_place_water:
                mov BYTE [eax], NULL_CHAR

				end_water_place:
                mov eax, [score]
                add eax, 10
                mov [score], eax

        do_not_explode:

        mov             esp, ebp
        pop             ebp
        ret

water_calc:
        push    ebp
        mov             ebp, esp

				pusha
                ;does water via for loop
                mov             ecx, 0  ;ecx is the x loop counter
                mov             edx, 0  ;edx is the y loop counter
                mov             eax, [ebp + 12]
                mov             ebx, [ebp + 8]
                sub             eax, 1
                sub             ebx, 1

                water_loop_x:

                        water_loop_y:
                                pusha                                   ;save current registers
                                push    ebx                             ;pass xpos
                                push    eax                             ;pass ypos
                                call    water_place
                                add             esp, 8
                                popa                                    ;restore registers

                                inc ebx                                 ;go to next ypos
                                inc edx                                 ;up y loop counter
                                cmp edx, 2
                                jle water_loop_y

                        inc eax                                         ;go to next xpos
                        mov ebx, [ebp + 8]           ;set ypos to original
                        sub ebx, 1
                        ;makes ypos 1 less
                        mov edx, 0                                      ;resets inner loop counter
                        inc ecx                                         ;up x loop counter
                        cmp ecx, 2
                        jle water_loop_x
		popa

        mov             esp, ebp
        pop             ebp
        ret

water_place:
        push    ebp
        mov             ebp, esp

        mov             eax, [curwidth]
		xor				edx, edx		;clear edx
        mul             DWORD [ebp + 12]
        add             eax, DWORD [ebp + 8]
        ;lea    eax, [board + eax]      ;ISSUE
                        ;check board level
                        movzx edi, BYTE [level]
                        dec edi
                        mov edi, [board_pointers + edi*4]
                        lea     eax, [edi + eax]

		;checks to make sure it is not the player's position
		;mov ecx, [xpos]
        ;cmp [ebp + 12], ecx
		;jne water_not_player_pos
		;mov ecx, [ypos]
		;cmp [ebp + 8], ecx
		;jne water_not_player_pos

		;jmp cannot_place_water

		water_not_player_pos:

        ;checks if it is something that can be turned into water
        cmp             BYTE [eax], NULL_CHAR
        je place_water
		cmp				BYTE [eax], ORB_CHAR
		je place_water
        jmp cannot_place_water

        place_water:
				pusha		;temporarily storing registers
				call random_num
				xor edx, edx
				mov ebx, 100		;used to find mod 100
				div ebx
				cmp edx, 5
				popa		;retrieving registers
				jge do_not_place_water2

				cmp BYTE [eax], ORB_CHAR
				jne	not_wet_orb
				mov BYTE [eax], WET_ORB_CHAR
				jmp end_water_place2

				not_wet_orb:
                mov BYTE [eax], WATER_CHAR
				jmp end_water_place2

				do_not_place_water2:
				cmp BYTE [eax], ORB_CHAR
				jne replace_with_null
				mov BYTE [eax], ORB_CHAR
				jmp end_water_place2

				replace_with_null
                mov BYTE [eax], NULL_CHAR

				end_water_place2:
                ;mov eax, [score]
                ;add eax, 5
                ;mov [score], eax
				;At the moment does not increase score, but does set the need to refresh render
				mov [water_increased], BYTE 1

        cannot_place_water:

        mov             esp, ebp
        pop             ebp
        ret

random_num:
        push ebp
        mov ebp, esp

        RDTSC                           ;gets the CPU time stamp counter

        imul eax, 123           ;multiplies eax by an arbitrary number
        add eax, 456            ;adds to eax by an arbitrary number
		add eax, [seed]			;further adds to eax with a pseudo random arbitrary number
        mov [seed], eax         ;stores the lower 32-bits of time into eax

		push ebx
        mov ebx, 7FFFFFFFh              ;byte mask for ebx
        and eax, ebx                    ;makes the number non-negative
		pop ebx

        mov esp, ebp
        pop ebp
        ret