final.asm

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

; the files that stores the boards/screens
%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 '~'
%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 and missus starting positions for every level.
; 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 MII_STARTX 24                   ;level 1
%define MII_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 MII_STARTIIX 30					;level 2
%define MII_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 MII_STARTIIIX 30				;level 3
%define MII_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
%define MII_STARTIVX 30					;level 4
%define MII_STARTIVY 11					;level 4

; teleport to positions for each board
%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 player positions
%define WIN_X 24
%define WIN_Y 6
%define LOSE_X 22
%define LOSE_Y 14

; these keys do things/actions the player can take
%define EXITCHAR 'x'
%define UPCHAR 'w'
%define LEFTCHAR 'a'
%define DOWNCHAR 's'
%define RIGHTCHAR 'd'
%define BOMBCHAR 'b'
%define	ONECHAR	'1'		;yellow player character
%define TWOCHAR '2'		;green player character
%define THREECHAR '3'	;lavender player character

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

; dot counts per board, used to track when level over
%define DOTS 248
%define DOTSII 256
%define DOTSIII 300
%define DOTSIV 262

segment .data

        ; used to fopen() the board files 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			;current board level
        caught db 0			;keeps track of if player has been caught by missus (0=no,1=yes)

        ;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				;keeps track of how many bombs player has currently
        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				;keeps track of player lives
        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 / ", \
														BOMBCHAR,"=BOMB / ", \
                                                        EXITCHAR,"=EXIT", \
                                                        13,10,0

		;player color options
		color_opt						db 13,10,"Characters: ", \
											ONECHAR, "=YELLOW / ", \
											TWOCHAR, "=GREEN / ", \
											THREECHAR, "=PURPLE", \
											13,10,10,0

		;player color
		pcolor db 1			;keeps track of which color player chooses to play as

        ; 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				;keeps track of if the player has won or not
        losevar db 0				;keeps track of if the player has lost or not
        loading db 0				;keeps track of if the player is between levels
        missus_first_move dd 1		;keeps track of if the missus needs to execute her first move to escape home
        missusII_first_move dd 1	;same for missusII

        ;colors used in printing
        yellow_code db 27,"[38;2;255;255;0m",0  	; 1.player character
        orange_code db 27,"[38;2;255;165;0m",0  	; 1.safe player
		green_code db 27,"[32m",0					; 2.player character
		lightgreen_code db 27,"[38;2;142;194;21m",0 ; 2.safe player
		lavender_code db 27,"[38;2;115;79;150m",0	; 3.player character
		violet_code db 27,"[35m",0					; 3.safe player
        blue_code db 27,"[38;2;33;33;222m",0		; the walls
        cyan_code db 27,"[38;2;0;255;255m",0		; the teleport tunnels
        gray_code db 27,"[38;2;211;211;211m",0		; the gate for missus's home
        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						; plus sign in wedding image
        light_blue_code db 27,"[38;5;74m",0 		; bombs
		blue_background_code db 27,"[44m",0			; water
        reset_code db 27,"[0m",0					; used to stop printing in color

        board_pointers:				;used to keep track of which board array to use for calculations
                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	; missus x-coordinate
        m_ypos    resd  1	; missus y-coordinate
        	; second missus
            mII_xpos resd 1		;second missus x-coordinate
            mII_ypos resd 1		;second missus y-coordinate
            missusII_right_streak resd 1	;stroes if missusII is moving
            missusII_last_move resd 1		;stores missusII laster direction: 1=left, 2=down, 3=right 4=up

        curheight resd  1		;used to keep track of board height for current level
        curwidth  resd  1		;board width for current level
        dots_req  resd  1		;dots needed to end the current level
        dots_eaten resd 1		;how many have been collected by player for current level

segment .text

        global  asm_main
        global  raw_mode_on
        global  raw_mode_off
        global  init_board
        global  render
        global  explode_space	;used for bomb logic

        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 to load proper level variables (board dimensions, dots required, player/missus starting positions)
                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:			;the two missus's starting x & y positions 4
                        mov     DWORD [m_xpos], M_STARTIVX
                        mov     DWORD [m_ypos], M_STARTIVY
                           	mov DWORD [mII_xpos], MII_STARTIVX
                            mov DWORD [mII_ypos], MII_STARTIVY
                        jmp end_lvlchk
                start_pos:
                ;board1 has extra checks because it's dimensions are used for other screens (Marriage, Lose, Loading Screens)
                        mov     DWORD [curheight], HEIGHT
                        mov     DWORD [curwidth],  WIDTH
                        call init_board
                        ;check if win
                        cmp     BYTE [winvar], 1
                        je      win_step2			;used to return to win code if coming from there
                        ;check if loading screen
                        cmp     BYTE [loading], 1
                        je      loading_step2		;used to return to load code
                        ;check if lose
                        cmp     BYTE [losevar], 1
                        je      lose_step2			;used to ret to los code
                        mov     DWORD [dots_req],   DOTS
                        reset_positions:
                        mov     DWORD [xpos], STARTX
                        mov     DWORD [ypos], STARTY
                        ;missus code
                        just_mpos:			;the two missus's starting x & y positions 1
                        mov DWORD [m_xpos], M_STARTX
                        mov DWORD [m_ypos], M_STARTY
                           	mov DWORD [mII_xpos], MII_STARTX
                            mov DWORD [mII_ypos], MII_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:			;the two missus's starting x & y positions 2
                        mov     DWORD [m_xpos], M_STARTIIX
                        mov     DWORD [m_ypos], M_STARTIIY
                           	mov DWORD [mII_xpos], MII_STARTIIX
                            mov DWORD [mII_ypos], MII_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:			;the two missus's starting x & y positions 3
                        mov             DWORD [m_xpos], M_STARTIIIX
                        mov             DWORD [m_ypos], M_STARTIIIY
                           	mov DWORD [mII_xpos], MII_STARTIIIX
                            mov DWORD [mII_ypos], MII_STARTIIIY
                        jmp end_lvlchk
                end_lvlchk:

                cmp     BYTE [caught], 1
                jmp     post_losechk		;used to return to lose_chk code

        ; 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
				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, ONECHAR
				je				pcolor_one
				cmp				eax, TWOCHAR
				je				pcolor_two
				cmp				eax, THREECHAR
				je				pcolor_three
                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/or change player color
				pcolor_one:
					mov		BYTE [pcolor], 1
					jmp 	game_loop
				pcolor_two:
					mov		BYTE [pcolor], 2
					jmp		game_loop
				pcolor_three:
					mov 	BYTE [pcolor], 3
					jmp		game_loop
                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 to use lea on a board array
                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		;check if player is teleporting
                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 to use lea on a board array
                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
                after_orb:
                cmp     BYTE [eax], SPECIALORB_CHAR		;are used for sending the missus home, activates safeguard if eaten
                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:
				;check if player ate all dots on the board
                mov             edx, [dots_eaten]
                cmp             edx, DWORD [dots_req]
                jz              screen_change			;level over

				;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			;if not first move use normal logic

            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 logic ******************
            normal_missus_move:
                        ; compare Missus x to players x
            mov eax, [m_xpos]		;missus x coordinate in eax
            mov ebx, [m_ypos]		;missus y coordinate in ebx

			; Try to move horizontally first, to align x-coordinate with the player
            mov ecx, [xpos]		; load player x
            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              ; try to move right by 2
                jmp missus_check_wall   ; see if moving right allowed

            missus_left:
                sub eax, 2              ; try to move left by 2
                jmp missus_check_wall   ; see if moving left is allowed

            ;****** if x-cordinate of player and missus is equal try to move to same y cordinate *****
            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					; move down 1
                jmp missus_check_wall

            missus_up:
                dec ebx					; moves up 1

            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 to use lea with board array
                                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:				;restore original missus position
                    mov eax, [m_xpos]
                    mov ebx, [m_ypos]

               ; check player y ; defaults left or right based on midline
                mov ecx, [ypos]
                cmp ecx, 15		; compare to horisonal mid line
                jg try_down
                jl try_up
                je mx_check		; if on midline check x position

                ; horizontal midline to establish defaults
                mx_check:
                    mov ecx, [xpos]
                    cmp ecx, 22					; check if player left or right of mid line
                    jg confused_move_right		; if right of midline 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				; if blocked dont go there
                    mov [m_xpos], eax           ; else save new x position
                    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 to use lea with board array
                                        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           ; saves new x-cordinate
                    jmp missus_done

					; alternativly try moving up
                    try_up:
                    mov edx, ebx
                   	dec edx                     ; move up by 1

                    mov esi, [curwidth]
                    imul esi, edx
                    add esi, eax
                    ;lea esi, [board + esi]     ;was an issue, fixed
                                        ;check board level to use lea with board array
                                        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     ; save new y position
                    jmp missus_done

                    try_down:
                    mov edx, ebx
                    inc edx               ; move down by 1

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

                    cmp BYTE [esi], WALL_CHAR
                    je missus_done
						cmp BYTE [esi], GATE_CHAR	;new (needed to keep off of gate)
						je missus_done
                    mov [m_ypos], edx           ; save new y-coordiante
                    jmp missus_done

                                ;saves the valid move
                missus_set_pos:
                    mov [m_xpos], eax           ; updates missus x-cordinate
                    mov [m_ypos], ebx           ; updates missus y-cordiante

                    jmp missus_done

                missus_done:

                ; second missus priorizes following the left wall
                missusII_movement:
                	mov eax, [score]
                    cmp eax, 50         ; missusII leaves spawn after player has 50 points
                    jl missusII_done

                    cmp dword [missusII_first_move], 1
                    jne normal_missusII_move            ; if not first move, normal pathing

                    ;else exit spawn by moving left and up
                    mov eax, [mII_xpos]
                    mov ebx, [mII_ypos]
                    sub eax, 2       ; moves left
                    sub ebx, 2       ; moves up

                    mov [mII_xpos], eax    					; save new x-cordinate
                    mov [mII_ypos], ebx    					; save new y-cordinate
                    mov dword [missusII_first_move], 0  	; first move complete
                    mov dword [missusII_right_streak], 0	; not on right streak
                    mov dword [missusII_last_move], 0   	; reset last move
                    jmp missusII_done

                 normal_missusII_move:
					;check if on player char
				    mov ebx, [xpos]
                	cmp ebx, [mII_xpos]
             		jne post_mIIcaughtchk
                    mov ebx, [ypos]
                    cmp ebx, [mII_ypos]
                    jne post_mIIcaughtchk
					jmp missusII_done

					post_mIIcaughtchk:

					; check if last move was right
                    cmp dword [missusII_right_streak], 1
                    je missusII_continue_right ; if last move was right, next move is right

                    ; check every direction to see if valid
                    ; store which directions are valid on the stack
                    push 0          ; left valid (ebp-4)
                    push 0          ; down valid (ebp-8)
                    push 0          ; right valid (ebp-12)
                    push 0          ; up valid (ebp-16)


                    ; check left
                    mov eax, [mII_xpos] 		;current missusII position
                    mov ebx, [mII_ypos]
                    sub eax, 2          		; try moving left
                    mov edx, [curwidth]
                    imul edx, ebx
                    add edx, eax
                    movzx ecx, BYTE [level]     ; check which board
                    dec ecx
                    mov ecx, [board_pointers + ecx*4]
                    lea esi, [ecx + edx]
                    cmp BYTE [esi], WALL_CHAR   ; wall check
                    je check_down_valid
                    cmp BYTE [esi], GATE_CHAR   ; gate check
                    je check_down_valid
                    cmp BYTE [esi], TELEPORT_CHAR       ; teleport check
                    je check_down_valid
                    mov dword [esp + 12], 1 	;left is valid

                 check_down_valid:
                    mov eax, [mII_xpos]
                    mov ebx, [mII_ypos]
                    inc ebx                     ; try moving down
                    mov edx, [curwidth]
                    imul edx, ebx
                    add edx, eax
                    movzx ecx, BYTE [level]
                    dec ecx
                    mov ecx, [board_pointers + ecx*4]
                    lea esi, [ecx + edx]
                    cmp BYTE [esi], GATE_CHAR   ; gate check
                    je check_right_valid
                    mov dword [esp + 8], 1 		;down is valid

                 check_right_valid:
                    mov eax, [mII_xpos]
                    mov ebx, [mII_ypos]
                    add eax, 2                  ; try moving right
                    mov edx, [curwidth]
                    imul edx, ebx
                    add edx, eax
                    movzx ecx, BYTE [level]
                    dec ecx
                    mov ecx, [board_pointers + ecx*4]
                    lea esi, [ecx + edx]
                    cmp BYTE [esi], WALL_CHAR
                    je check_up_valid
                    cmp BYTE [esi], GATE_CHAR
                    je check_up_valid
                    cmp BYTE [esi], TELEPORT_CHAR
                    je check_up_valid
                    mov dword [esp + 4], 1 		;right is valid

                 check_up_valid:
                    mov eax, [mII_xpos]
                    mov ebx, [mII_ypos]
                    dec ebx                     ; try moving up
                    mov edx, [curwidth]
                    imul edx, ebx
                    add edx, eax
                    movzx ecx, BYTE [level]
                    dec ecx
                    mov ecx, [board_pointers + ecx*4]
                    lea esi, [ecx + edx]
                    cmp BYTE [esi], WALL_CHAR
                    je check_if_intersection
                    cmp BYTE [esi], GATE_CHAR
                    je check_if_intersection
                    mov dword [esp], 1 			; up is valid

                  ; if 4 valid directions, then is intersection
                  check_if_intersection:
                    mov ecx, 0
                    add ecx, [esp + 12]         ; add left
                    add ecx, [esp + 8]          ; add down
                    add ecx, [esp + 4]          ; add right
                    add ecx, [esp]              ; add up

                    cmp ecx, 4                  ; are 4 directions valid?
                    je at_intersection

                    ;not at intersection
                    add esp, 16
                    jmp missusII_normal_priority

                  at_intersection:
                    add esp, 16         ; clean up stack

                    mov eax, [mII_xpos]         ; check x-cordinate
                    cmp BYTE [level], 1         ; check x-cordinate
                    je use_startx
                    cmp BYTE [level], 2
                    je use_startiix
                    cmp BYTE [level], 3
                    je use_startiiix

                    ; level 4 midline
                    cmp eax, STARTIVX
                    jl go_right_intersection    ; if left of mid, go right
                    jmp go_left_intersection    ; if right of mid, go left

                  ; level 1 midline
                  use_startx:
                    cmp eax, STARTX
                    jl go_right_intersection
                    jmp go_left_intersection

                 ; level 2 midling
                  use_startiix:
                    cmp eax, STARTIIX
                    jl go_right_intersection
                    jmp go_left_intersection

                 ; level 3 midline
                  use_startiiix:
                    cmp eax, STARTIIIX
                    jl go_right_intersection
                    jmp go_left_intersection
                  go_left_intersection:
                    mov eax, [mII_xpos]
                    sub eax, 2                  ; move left
                    mov [mII_xpos], eax
                    mov dword [missusII_last_move], 1   ; record last move
                    mov dword [missusII_right_streak],0 ; not on streak
                    jmp missusII_done

                  go_right_intersection:
                    mov eax, [mII_xpos]
                    add eax, 2                  ; move right
                    mov [mII_xpos], eax
                    mov dword [missusII_last_move], 3   ; record last move
                    mov dword [missusII_right_streak], 1 ; not on streak
                    jmp missusII_done

                 ; normal priority is try left, down, right, then up
                 ; missusII doesnt try the opposite of her last move
                 missusII_normal_priority:


                 missusII_try_left:
                    cmp dword [missusII_last_move], 3 ; was last move right
                    je missusII_try_down       ; prevent left if so

                    mov eax, [mII_xpos]
                    mov ebx, [mII_ypos]
                    sub eax, 2                  ; try left

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

                    cmp BYTE [esi], WALL_CHAR
                    je missusII_try_down
                    cmp BYTE [esi], GATE_CHAR
                    je missusII_try_down
                    cmp BYTE [esi], TELEPORT_CHAR
                    je missusII_try_down

                   ;if it is valid to move left
                   mov [mII_xpos], eax
                   mov dword [missusII_last_move], 1
                   mov dword [missusII_right_streak], 0
                   jmp missusII_done

                 missusII_try_down:
                   cmp dword [missusII_last_move], 4  ; if last was up
                   je missusII_try_right        ; skip down

                   mov eax, [mII_xpos]
                   mov ebx, [mII_ypos]
                   inc ebx                      ; try down

                   mov edx, [curwidth]
                   imul edx, ebx
                   add edx, eax
                   movzx ecx, BYTE [level]
                   dec ecx
                   mov ecx, [board_pointers + ecx*4]
                   lea esi, [ecx + edx]

                   cmp BYTE [esi], WALL_CHAR
                   je missusII_try_right
                   cmp BYTE [esi], GATE_CHAR
                   je missusII_try_right

                   ; valid
                   mov [mII_ypos], ebx
                   mov dword [missusII_last_move], 2
                   mov dword [missusII_right_streak],0
                   jmp missusII_done

                 missusII_try_right:
                   cmp dword [missusII_last_move],1     ; if last move was left
                   je missusII_try_up                   ; then skip right

                   mov eax, [mII_xpos]
                   mov ebx, [mII_ypos]
                   add eax, 2                   ; else try right

                   mov edx, [curwidth]
                   imul edx, ebx
                   add edx, eax
                   movzx ecx, BYTE [level]
                   dec ecx
                   mov ecx, [board_pointers + ecx*4]
                   lea esi, [ecx + edx]

                   cmp BYTE [esi], WALL_CHAR
                   je missusII_try_up
                   cmp BYTE [esi], GATE_CHAR
                   je missusII_try_up
                   cmp BYTE [esi], TELEPORT_CHAR
                   je missusII_try_up

                   mov [mII_xpos], eax
                   mov dword [missusII_last_move], 3
                   mov dword [missusII_right_streak], 1  ; starts right streak
                   jmp missusII_done

                 missusII_try_up:
                   cmp dword [missusII_last_move], 2 ; if just moved down
                   je missusII_done                ; skip up

                   mov eax, [mII_xpos]
                   mov ebx, [mII_ypos]
                   dec ebx                      ; try up

                   mov edx, [curwidth]
                   imul edx, ebx
                   add edx, eax
                   movzx ecx, BYTE [level]
                   dec ecx
                   mov ecx, [board_pointers + ecx*4]
                   lea esi, [ecx + edx]

                   cmp BYTE [esi], WALL_CHAR
                   je missusII_done
                   cmp BYTE [esi], GATE_CHAR
                   je missusII_done

                   mov [mII_ypos], ebx              ;valid to move up
                   mov dword [missusII_last_move], 4
                   mov dword [missusII_right_streak],0
                   jmp missusII_done

                ;when on a right streak keep moving right
                 missusII_continue_right:
                   mov eax, [mII_xpos]
                   mov ebx, [mII_ypos]
                   add eax, 2            ; move right

                   mov edx, [curwidth]
                   imul edx, ebx
                   add edx, eax
                   movzx ecx, BYTE [level]
                   dec ecx
                   mov ecx, [board_pointers + ecx*4]
                   lea esi, [ecx + edx]

                   cmp BYTE [esi], WALL_CHAR
                   je missusII_right_blocked
                   cmp BYTE [esi], GATE_CHAR
                   je missusII_right_blocked
                   cmp BYTE [esi], TELEPORT_CHAR
                   je missusII_right_blocked

                   ; continue moving right
                   mov [mII_xpos], eax
                   mov dword [missusII_last_move], 3
                   jmp missusII_done

                ;if right is blocked during streak, try up
                 missusII_right_blocked:
                   mov eax, [mII_xpos]
                   mov ebx, [mII_ypos]
                   dec ebx                      ; try up

                   mov edx, [curwidth]
                   imul edx, ebx
                   add edx, eax
                   movzx ecx, BYTE [level]
                   dec ecx
                   mov ecx, [board_pointers + ecx*4]
                   lea esi, [ecx + edx]

                   cmp BYTE [esi], WALL_CHAR
                   je missusII_try_down_streak
                   cmp BYTE [esi], GATE_CHAR
                   je missusII_try_down_streak

                   ; moving up, ends the streak
                   mov [mII_ypos], ebx
                   mov dword [missusII_last_move],4
                   mov dword [missusII_right_streak],0
                   jmp missusII_done

                 missusII_try_down_streak:
                   mov eax, [mII_xpos]
                   mov ebx, [mII_ypos]
                   inc ebx                      ; try down

                   mov edx, [curwidth]
                   imul edx, ebx
                   add edx, eax
                   movzx ecx, BYTE [level]
                   dec ecx
                   mov ecx, [board_pointers + ecx*4]
                   lea esi, [ecx + edx]

                   cmp BYTE [esi], WALL_CHAR
                   je missusII_streak_stuck
                   cmp BYTE [esi], GATE_CHAR
                   je missusII_streak_stuck

                   ; move down, end streak
                   mov [mII_ypos], ebx
                   mov dword [missusII_last_move], 2
                   mov dword [missusII_right_streak],0
                   jmp missusII_done

                ; if MissusII stuck
                 missusII_streak_stuck:
                   mov dword [missusII_right_streak], 0    ;for when she cant move up or down
                   mov dword [missusII_last_move],0
                   jmp missusII_done

                 missusII_done:

                ; check if player loses to first missus
                   mov ebx, [xpos]
                   cmp ebx, [m_xpos]            ; compare player x with missus x
                   jne missusII_losechk    		;if diffrent check missusII
                   mov ebx, [ypos]              ; compare player y with missus y
                   cmp ebx, [m_ypos]
                   jne missusII_losechk         ; if diffrent check missusII

                missusII_caught:
                   ;check if points for catching missus
                   cmp DWORD [safeguard],0
                   jle past_ghost_points        ; if no safeguard, lose a life
                   ;if safeguard active player eats missus
                   mov ebx, [score]
                   add ebx, 200
                   mov [score], ebx
                   inc DWORD [lives]

                past_ghost_points:
                  ; reset both missus characters to first move state
                  mov DWORD [missus_first_move], 1
                  mov DWORD [missusII_first_move], 1
                  mov DWORD [missusII_right_streak], 0
                  mov DWORD [missusII_last_move], 0

                        ; lose a life
                        dec             DWORD [lives]
                        cmp             DWORD [lives], 0
                je                      lose

                ; reset player position based on current level
                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

                ;if safeguard is active only reset missus postion
                lose1:
                        cmp                     DWORD [safeguard],0
						jg						just_mpos
						jmp						reset_positions
                lose2:
                        cmp                     DWORD [safeguard],0
                        jg                      just_mpos2
						jmp						reset_positions2
                lose3:
                        cmp                     DWORD [safeguard],0
                        jg                      just_mpos3
                        jmp                     reset_positions3
                lose4:
                        cmp                     DWORD [safeguard],0
                        jg                      just_mpos4
                        jmp                     reset_positions4

				; check collision with second missus
				missusII_losechk:
                	mov ebx, [xpos]
                    cmp ebx, [mII_xpos]     	; compare playerx with missusI
                    jne post_losechk
                    mov ebx, [ypos]
                    cmp ebx, [mII_ypos]         ; compare player y with missusII y
                    jne post_losechk            ; if diffrent, no collision

                    jmp missusII_caught         ; missusII eats player

                post_losechk:
                mov     BYTE [caught], 0        ;character positions were reset, player no longer caught

        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 [missusII_first_move], 1
            mov 	DWORD [missusII_right_streak], 0
            mov 	DWORD [missusII_last_move], 0
        	mov     DWORD [lives], 3
        	mov     [bombs], DWORD 0
        	call    render
        ;get c input to continue to next level
        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:										;char losing position
                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 needed
                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 to use lea with board array
                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]
                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

		; check if bomb prints not needed
        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
                mov ebx, 7FFFFFFFh              ;byte mask for ebx
                and eax, ebx                    ;makes the number non-negative
                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
                mov ebx, 7FFFFFFFh              ;byte mask for ebx
                and eax, ebx                    ;makes the number non-negative
                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
		push	color_opt
		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
								; check which player color is in use
								cmp		BYTE [pcolor], 1
								je		print_player1
								cmp		BYTE [pcolor], 2
								je		print_player2
								cmp		BYTE [pcolor], 3
								je		print_player3
								print_player1:
                                	cmp     DWORD [safeguard], 0
                                	je      player1_default
                                	push    orange_code
                                	jmp     print_player
                                player1_default:
                                	push    yellow_code
									jmp		print_player
								print_player2:
                                	cmp     DWORD [safeguard], 0
                                	je      player2_default
                                	push    lightgreen_code
                                	jmp     print_player
                                player2_default:
                                	push    green_code
									jmp		print_player
								print_player3:
                                	cmp     DWORD [safeguard], 0
                                	je      player3_default
                                	push    violet_code
                                	jmp     print_player
                                player3_default:
                                	push    lavender_code
									jmp		print_player
                                print_player:
                                call    printf
                                add     esp,4
                                push    PLAYER_CHAR
                                call    putchar
                                jmp     print_end

                        ;render missus character
                        check_m:
							;check if skip missus character print
	                        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 check_mII
             			    mov eax, DWORD [m_ypos]
               				cmp eax, DWORD [ebp - 4]
                			jne check_mII

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

                        check_mII:
                        	mov eax, DWORD [mII_xpos]
                            cmp eax, DWORD [ebp - 8]
                            jne print_board
                            mov eax, DWORD [mII_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]
                                mul             ebx
                                add             eax, DWORD [ebp - 8]
                                mov             ebx, 0
                        ;check board level to use board array
                        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
                                je              missus_print
                                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

						; pushes colors to use on screen
                        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    peach_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 to use board array
                        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