.data
    gameOver:       .asciiz     "Game Over.\n"
    playTime1:      .asciiz     "The playing time was "
    playTime2:      .asciiz     " ms.\n"
    score1:         .asciiz     "The game score was "
    score2:         .asciiz     " frogs.\n"
    headX:          .word       7   # head X position
    headY:          .word       31  # head Y position
    tailX:          .word       0   # tail X position
    tailY:          .word       31  # tail Y position
    startTime:      .word       0
    dir:            .asciiz     "000000000000000000000000000000000000000000"
                            # 0 = right, 1 = left, 2 = up, 3 = down
                            # 42 characters (32 frogs + 8 original + 2 for overflow protection)
                            # starts all 0's (right) since snake is facing right
    #REGISTER USES
    #t0 TRASH TEMP
    #t1 TRASH TEMP
    #t2 TRASH TEMP
    #t3 TRASH TEMP
    #t4 TRASH TEMP: frog randX
    #t5 TRASH TEMP: frog randY
    #t6 TRASH TEMP: frogs generated
    #t7 FULL TEMP: Score
    #t8 FULL TEMP: Last Pressed Direction (0,1,2,3)
    #t9 FULL TEMP: Tail Size
    #a0 setLED/getLED X
    #a1 setLED/getLED Y
    #a2 setLED color
    #a3 dir .asciiz tracker
.text
Initialize:             # initialize program (sets walls, starter colors, values, then frogs)
    jal randinit            # initialize random
    li $t6, 0           # set wall counter
wall_loop:              # do frogs first, they will be overwritten by snake or walls (eliminates checking)
    la $a0, 64          # sets upper bound for random generator as 64 (width)
    jal getRandomNumber     # generate random number (1-64)
    la $t4, ($t1)           # random X
    la $a0, 64          # sets upper bound for random generator as 64 (height)
    jal getRandomNumber     # generate random number (1-64)
    la $t5, ($t1)           # random Y
    la $a0, ($t4)           # prepare random X for setLED
    la $a1, ($t5)           # prepare random Y for setLED
    li $a2, 1           # set red
    jal setLED          # make wall
    addi $t6, $t6, 1        # add one to wall counter
    beq $t6, 32, wall_end       # branch if all walls generated (64)
    j wall_loop         # loop to generate another frog
    wall_end:
    li $a0, 0xFFFF0008      # load LED address
    li $a1, 0x0000AAAA      # load yellow starters
    addi $a0, $a0, 496      # jump ahead in LED display to start location
    sw  $a1, 0($a0)         # store yellow starters at proper LED location

    li $t7, 0           # set score to 0 (score = frogs found)
    li $t8, 4           # load last pressed direction as 4 (nothing) to start (makes pause at start)
    li $t9, 8           # load TailSize as 8 to start

    li $t6 0            # set frog counter
frog_loop:              # do frogs first, they will be overwritten by snake or walls (eliminates checking)
    la $a0, 64          # sets upper bound for random generator as 64 (width)
    jal getRandomNumber     # generate random number (1-64)
    la $t4, ($t1)           # random X
    la $a0, 64          # sets upper bound for random generator as 64 (height)
    jal getRandomNumber     # generate random number (1-64)
    la $t5, ($t1)           # random Y
    la $a0, ($t4)           # prepare random X for setLED
    la $a1, ($t5)           # prepare random Y for setLED
    jal getLED          # get LED at randomXY
    bne $v0, 0, not_frog        # if LED at randomXY is not blank, skip making frog
    li $a2, 3           # set green
    jal setLED          # make frog
    addi $t6, $t6, 1        # add one to frog counter
    beq $t6, 32, frog_end       # branch if all frogs generated (32)
    not_frog:
    j frog_loop         # loop to generate another frog
frog_end:

_poll:
    jal sleep           # sleep for 200ms

    la $a0, 15          # sets upper bound for random generator as 15
    jal getRandomNumber     # generate random number
    bne $t1, 10, frog_move_done2    # if not 10 (which would be a 1/15 chance that it is, aka on average once every 3 seconds since 15*200ms=3s), then skip
frog_move:              # generates randomXY until frog is found
    la $a0, 64          # sets upper bound for random generator as 64 (width)
    jal getRandomNumber     # generate random number (1-64)
    la $t4, ($t1)           # random X
    la $a0, 64          # sets upper bound for random generator as 64 (height)
    jal getRandomNumber     # generate random number (1-64)
    la $t5, ($t1)           # random Y
    la $a0, ($t4)           # prepare random X for setLED
    la $a1, ($t5)           # prepare random Y for setLED
    jal getLED          # get LED at randomXY
    bne $v0, 3, frog_move       # if LED at randomXY is not green, go back and generate another randomXY
    li $a2, 0           # set blank
    jal setLED          # make blank
    la $a0, 8           # set upper bound for random generator to 4
    jal getRandomNumber     # generate random number (1-8)
    subi $t1, $t1, 1        # subtract random number by one so its 0-7 (for consistency) this determines direction (4-7 are diagonals)
    la $a0, ($t4)           # prepare random X for setLED
    la $a1, ($t5)           # prepare random Y for setLED
    beq $t1, 0, frog_right      # if right
    beq $t1, 1, frog_left       # if left
    beq $t1, 2, frog_up     # if up
    beq $t1, 3, frog_down       # if down
    beq $t1, 4, frog_rightUp    # if right-up
    beq $t1, 5, frog_leftUp     # if left-up
    beq $t1, 6, frog_rightDown  # if right-down
    beq $t1, 7, frog_leftDown   # if left-down
    j frog_right            # catch

frog_right:
    addi $a0, $a0, 1        # move right 1
    bge $a0, 64, frog_RIGHT_SIDE    # check if we go beyond the edge
    j frog_move_done        # move done
    frog_RIGHT_SIDE:
    li $a0, 0           # set x location to left side
    j frog_move_done        # move done

frog_left:
    subi $a0, $a0, 1        # move left 1
    blt $a0, $0, frog_LEFT_SIDE # check if we go beyond the edge
    j frog_move_done        # move done
    frog_LEFT_SIDE:
    li $a0, 63          # set x location to right side
    j frog_move_done        # move done

frog_up:
    subi $a1, $a1, 1        # move up 1
    blt $a1, $0, frog_DOWN_SIDE # check if we go beyond the top
    j frog_move_done        # move done
    frog_DOWN_SIDE:
    li $a1, 63          # set y location to bottom row
    j frog_move_done        # move done

frog_down:
    addi $a1, $a1, 1        # move down 1
    bge $a1, 64, frog_UP_SIDE   # check if we go beyond the bottom
    j frog_move_done        # move done
    frog_UP_SIDE:
    li $a1, 0           # set y location to top row
    j frog_move_done        # move done

frog_rightUp:
    addi $a0, $a0, 1        # move right 1
    bge $a0, 64, frog_RIGHT_SIDE1   # check if we go beyond the edge
    j skip1             # skip
    frog_RIGHT_SIDE1:
    li $a0, 0           # set x location to left side
    skip1:
    subi $a1, $a1, 1        # move up 1
    blt $a1, $0, frog_DOWN_SIDE1    # check if we go beyond the top
    j frog_move_done        # move done
    frog_DOWN_SIDE1:
    li $a1, 63          # set y location to bottom row
    j frog_move_done        # move done

frog_leftUp:
    subi $a0, $a0, 1        # move left 1
    blt $a0, $0, frog_LEFT_SIDE2    # check if we go beyond the edge
    j skip2             # skip
    frog_LEFT_SIDE2:
    li $a0, 63          # set x location to right side
    skip2:
    subi $a1, $a1, 1        # move up 1
    blt $a1, $0, frog_DOWN_SIDE2    # check if we go beyond the top
    j frog_move_done        # move done
    frog_DOWN_SIDE2:
    li $a1, 63          # set y location to bottom row
    j frog_move_done        # move done

frog_rightDown:
    addi $a0, $a0, 1        # move right 1
    bge $a0, 64, frog_RIGHT_SIDE3   # check if we go beyond the edge
    j skip3             # skip
    frog_RIGHT_SIDE3:
    li $a0, 0           # set x location to left side
    skip3:
    addi $a1, $a1, 1        # move down 1
    bge $a1, 64, frog_UP_SIDE3  # check if we go beyond the bottom
    j frog_move_done        # move done
    frog_UP_SIDE3:
    li $a1, 0           # set y location to top row
    j frog_move_done        # move done

frog_leftDown:
    addi $a0, $a0, 1        # move right 1
    bge $a0, 64, frog_RIGHT_SIDE4   # check if we go beyond the edge
    j skip4             # skip
    frog_RIGHT_SIDE4:
    li $a0, 0           # set x location to left side
    skip4:
    addi $a1, $a1, 1        # move down 1
    bge $a1, 64, frog_UP_SIDE4  # check if we go beyond the bottom
    j frog_move_done        # move done
    frog_UP_SIDE4:
    li $a1, 0           # set y location to top row
    j frog_move_done        # move done

frog_move_done:         # frog position has been moved
    li $a2, 3           # prepare green
    jal setLED          # set new frog location to green
rog_move_done2:         # used as the skip from earlier

    skip:               # if a direction is already being travelled, skip it and the pause (pause has already been done)
    la $t0, 0xFFFF0000      # address of key press signifier
    lw $t0, 0($t0)          # load key press signifier
    andi $t0, $t0, 1        # check if there was a keypress
    bne $t0, $0, _keypress      # branch if there was a keypress
    la $a3, dir         # load dir
    beq $t8, 0, right_pressed   # branch if right was last pressed
    beq $t8, 1, left_pressed    # branch if left was last pressed
    beq $t8, 2, up_pressed      # branch if up was last pressed
    beq $t8, 3, down_pressed    # branch if down was last pressed
    j _poll             # loop poll

_keypress:
    lw $t0, startTime       # load startTime
    beq $t0, 0, get_start_time  # if startTime is 0 (hasn't been set yet) branch to get_start_time
    j skip_start_time       # if it skips the branch, then skip get_start_time
    get_start_time:
    li $v0, 30          # prepare to get start time
    syscall
    sw $a0, startTime       # store start time
    skip_start_time:

    la $t0, 0xFFFF0004      # address of which key was pressed
    lw $t0, 0($t0)          # load the word that was stored
    la $a3, dir         # load dir

    subi $t1, $t0, 66       # center?
    beq $t1, $0, center_pressed # branch if center key pressed

    subi $t1, $t0, 227      # right?
    beq $t1, $0, right_pressed  # branch if right was pressed

    subi $t1, $t0, 226      # left?
    beq $t1, $0, left_pressed   # branch if left was pressed

    subi $t1, $t0, 224      # up?
    beq $t1, $0, up_pressed     # branch if up was pressed

    subi $t1, $t0, 225      # down?
    beq $t1, $0, down_pressed   # branch if down was pressed

    j _poll             # start the polling loop again


right_pressed:
    beq $t8, 1, skip        # if travelling left, skip right

    lw $a0, headX           # load headX
    lw $a1, headY           # load headY
    addi $a0, $a0, 1        # move right 1
    bge $a0, 64, RIGHT_SIDE_wall    # check if we go beyond the edge
    j RIGHT_SIDE_wall_skip      # skip side exception
    RIGHT_SIDE_wall:
    li $a0, 0           # set x location to left side
    RIGHT_SIDE_wall_skip:
    jal getLED
    beq $v0, 1, down_pressed    # if LED is red, branch to go down

    li $t8, 0           # set last pressed key to right
    li $t4, 0           # character counter (for backtrace)
    li $t3, 0           # load "right" into temp3
right_loop:
    addi $a3, $a3, 1        # increment to next character
    addi $t4, $t4, 1        # increment counter
    lb $t2, ($a3)           # load character into temp2
    sb $t3,($a3)            # load temp3 into character location
    la $t3, ($t2)           # load temp2 into temp3
    beq $t4, 42, right_end      # if end of character line is reached, goto end
    j right_loop            # loop
right_end:
    sub $a3,$a3,42          # backtrace
    lw $a0, headX           # load headX
    lw $a1, headY           # load headY
    addi $a0, $a0, 1        # move right 1
    bge $a0, 64, RIGHT_SIDE     # check if we go beyond the edge
    j head_move_done        # move done

    RIGHT_SIDE:
    li $a0, 0           # set x location to left side
    j head_move_done        # move done

left_pressed:
    beq $t8, 0, skip        # if travelling right, skip left
    beq $t8, 4, skip        # if just started (facing right), skip left

    lw $a0, headX           # load headX
    lw $a1, headY           # load headY
    subi $a0, $a0, 1        # move right 1
    blt $a0, $0, LEFT_SIDE_wall # check if we go beyond the edge
    j LEFT_SIDE_wall_skip       # skip side exception
    LEFT_SIDE_wall:
    li $a0, 63          # set x location to right side
    LEFT_SIDE_wall_skip:
    jal getLED
    beq $v0, 1, up_pressed      # if LED is red, branch to go up

    li $t8, 1           # set last pressed key to left
    li $t4, 0           # character counter (for backtrace)
    li $t3, 1           # load "left" into temp3
left_loop:
    addi $a3, $a3, 1        # increment to next character
    addi $t4, $t4, 1        # increment counter
    lb $t2, ($a3)           # load character into temp2
    sb $t3,($a3)            # load temp3 into character location
    la $t3, ($t2)           # load temp2 into temp3
    beq $t4, 42, left_end       # if end of character line is reached, goto end
    j left_loop         # loop
left_end:
    sub $a3,$a3,42          # backtrace
    lw $a0, headX           # load headX
    lw $a1, headY           # load headY
    subi $a0, $a0, 1        # move left 1
    blt $a0, $0, LEFT_SIDE      # check if we go beyond the edge
    j head_move_done        # move done

    LEFT_SIDE:
    li $a0, 63          # set x location to right side
    j head_move_done        # move done

up_pressed:
    beq $t8, 3, skip        # if travelling down, skip up

    lw $a0, headX           # load headX
    lw $a1, headY           # load headY
    subi $a1, $a1, 1        # move up 1
    blt $a1, $0, DOWN_SIDE_wall # check if we go beyond the top
    j DOWN_SIDE_wall_skip       # skip side exception
    DOWN_SIDE_wall:
    li $a1, 63          # set y location to bottom row
    DOWN_SIDE_wall_skip:
    jal getLED
    beq $v0, 1, right_pressed   # if LED is red, branch to go right

    li $t8, 2           # set last pressed key to up
    li $t4, 0           # character counter (for backtrace)
    li $t3, 2           # load "up" into temp3
up_loop:
    addi $a3, $a3, 1        # increment to next character
    addi $t4, $t4, 1        # increment counter
    lb $t2, ($a3)           # load character into temp2
    sb $t3,($a3)            # load temp3 into character location
    la $t3, ($t2)           # load temp2 into temp3
    beq $t4, 42, up_end     # if end of character line is reached, goto end
    j up_loop           # loop
up_end:
    sub $a3,$a3,42          # backtrace
    lw $a0, headX           # load headX
    lw $a1, headY           # load head Y
    subi $a1, $a1, 1        # move up 1
    blt $a1, $0, DOWN_SIDE      # check if we go beyond the top
    j head_move_done        # move done

    DOWN_SIDE:
    li $a1, 63          # set y location to bottom row
    j head_move_done        # move done

down_pressed:
    beq $t8, 2, skip        # if travelling up, skip down

    lw $a0, headX           # load headX
    lw $a1, headY           # load headY
    addi $a1, $a1, 1        # move down 1
    bge $a1, 64, UP_SIDE_wall   # check if we go beyond the bottom
    j UP_SIDE_wall_skip     # skip side exception
    UP_SIDE_wall:
    li $a1, 0           # goto top
    UP_SIDE_wall_skip:
    jal getLED
    beq $v0, 1, left_pressed    # if LED is red, branch to go left

    li $t8, 3           # set last pressed key to down
    li $t4, 0           # character counter (for backtrace)
    li $t3, 3           # load "down" into temp3
down_loop:
    addi $a3, $a3, 1        # increment to next character
    addi $t4, $t4, 1        # increment counter
    lb $t2, ($a3)           # load character into temp2
    sb $t3,($a3)            # load temp3 into character location
    la $t3, ($t2)           # load temp2 into temp3
    beq $t4, 42, down_end       # if end of character line is reached, goto end
    j down_loop         # loop
down_end:
    sub $a3,$a3,42          # backtrace
    lw $a0, headX           # get headX
    lw $a1, headY           # get headY
    addi $a1, $a1, 1        # move down 1
    bge $a1, 64, UP_SIDE        # check if we go beyond the bottom
    j head_move_done        # move done

    UP_SIDE:
    li $a1, 0           # goto top
    j head_move_done        # move done

center_pressed:
    j skip

head_move_done:
    sw $a0, headX           # store new headX
    sw $a1, headY           # store new headY
    jal getLED
    beq $v0, 2, game_over       # if color is yellow (snake), branch to game_over
    beq $v0, 3, hit_frog        # if color is green (frog), branch to hit_frog
    beq $v0, 0, hit_nothing     # if color is blank, branch hit_nothing
    j hit_nothing           # catches in case of exceptions

hit_frog:
    lw $a0, headX           # get headX
    lw $a1, headY           # get headY
    li $a2, 2           # get yellow
    jal setLED          # set new head LED
    addi $t7, $t7, 1        # add one to score
    beq $t7, 32, game_over      # if score = 32 (all 32 frogs found) branch to game_over
    addi $t9, $t9, 1        # add one to tail length and do not move tail
    j _poll             # go back to poll

hit_nothing:
    lw $a0, headX           # load headX
    lw $a1, headY           # load headY
    li $a2, 2           # get yellow
    jal setLED          # set new head LED
    lw $a0, tailX           # load tailX
    lw $a1, tailY           # load tailY
    li $a2, 0           # get blank
    jal setLED          # remove tail LED
    la $a3, dir         # reload
    la $t1, 0($t9)          # get tailSize
    add $a3, $a3, $t1       # increment to number at tailSize to find direction
    lb $t0, ($a3)           # get number
    beq $t0, 0, tail_right_pressed  # if right
    beq $t0, 1, tail_left_pressed   # if left
    beq $t0, 2, tail_up_pressed # if up
    beq $t0, 3, tail_down_pressed   # if down
    j tail_right_pressed        # catches it from somehow running the j _poll in hit_frog



tail_right_pressed:
    lw $a0, tailX           # load tailX
    lw $a1, tailY           # load tailY
    addi $a0, $a0, 1        # move right 1
    bge $a0, 64, TAIL_RIGHT_SIDE    # check if we go beyond the edge
    j tail_move_done        # move done

    TAIL_RIGHT_SIDE:
    li $a0, 0           # set x location to left side
    j tail_move_done        # move done

tail_left_pressed:
    lw $a0, tailX           # load tailX
    lw $a1, tailY           # load tailY
    subi $a0, $a0, 1        # move left 1
    blt $a0, $0, TAIL_LEFT_SIDE # check if we go beyond the edge
    j tail_move_done        # move done

    TAIL_LEFT_SIDE:
    li $a0, 63          # set x location to right side
    j tail_move_done        # move done

tail_up_pressed:
    lw $a0, tailX           # load tailX
    lw $a1, tailY           # load tailY
    subi $a1, $a1, 1        # move up 1
    blt $a1, $0, TAIL_DOWN_SIDE # check if we go beyond the top
    j tail_move_done        # move done

    TAIL_DOWN_SIDE:
    li $a1, 63          # set y location to bottom row
    j tail_move_done        # move done

tail_down_pressed:
    lw $a0, tailX           # load tailX
    lw $a1, tailY           # load tailY
    addi $a1, $a1, 1        # move down 1
    bge $a1, 64, TAIL_UP_SIDE   # check if we go beyond the bottom
    j tail_move_done        # move done

    TAIL_UP_SIDE:
    li $a1, 0           # set y location to top row
    j tail_move_done        # move done

tail_move_done:
    sub $a3, $a3, $t1       # backtrace
    sw $a0, tailX           # store new tailX
    sw $a1, tailY           # store new tailY
    j _poll             # go back to poll

game_over:
    li $v0, 4
    la $a0, gameOver        # "Game Over" text
    syscall
    la $a0, playTime1       # first part of "Play Time" text
    syscall
    li $v0, 30          # prepare to get system time
    syscall
    lw $a1, startTime           # load start time
    sub $a0, $a0, $a1       # subtract start time from end time
    li $v0, 1
    syscall             # call end time
    li $v0, 4
    la $a0, playTime2       # second part of "Play Time" text
    syscall
    la $a0, score1          # first part of score text
    syscall
    li $v0, 1
    la $a0, ($t7)           # score
    syscall
    li $v0, 4
    la $a0, score2          # second part of score text
    syscall
    li $v0, 10
    syscall

setLED: # USED GIVEN CODE
    # void _setLED(int x, int y, int color)
    # 03/11/2012: this version is for the 64x64 LED
    # sets the LED at (x,y) to color
    # color: 0=off, 1=red, 2=orange, 3=green
    # warning:   x, y and color are assumed to be legal values (0-63,0-63,0-3)
    # arguments: $a0 is x, $a1 is y, $a2 is color
    # trashes:   $t0-$t3
    # returns:   none

    # byte offset into display = y * 16 bytes + (x / 4)
    sll $t0,$a1,4           # y * 16 bytes
    srl $t1,$a0,2           # x / 4
    add $t0,$t0,$t1         # byte offset into display
    li  $t2,0xffff0008      # base address of LED display
    add $t0,$t2,$t0         # address of byte with the LED
    # now, compute led position in the byte and the mask for it
    andi    $t1,$a0,0x3         # remainder is led position in byte
    neg $t1,$t1             # negate position for subtraction
    addi    $t1,$t1,3           # bit positions in reverse order
    sll $t1,$t1,1           # led is 2 bits
    # compute two masks: one to clear field, one to set new color
    li  $t2,3
    sllv    $t2,$t2,$t1
    not $t2,$t2             # bit mask for clearing current color
    sllv    $t1,$a2,$t1         # bit mask for setting color
    # get current LED value, set the new field, store it back to LED
    lbu $t3,0($t0)          # read current LED value
    and $t3,$t3,$t2         # clear the field for the color
    or  $t3,$t3,$t1         # set color field
    sb  $t3,0($t0)          # update display
    jr  $ra


getLED: # USED GIVEN CODE
    # int _getLED(int x, int y)
    # 03/11/2012: this version is for the 64x64 LED
    # returns the value of the LED at position (x,y)
    # warning:   x and y are assumed to be legal values (0-63,0-63)
    # arguments: $a0 holds x, $a1 holds y
    # trashes:   $t0-$t2
    # returns:   $v0 holds the value of the LED (0, 1, 2, 3)

    # byte offset into display = y * 16 bytes + (x / 4)
    sll  $t0,$a1,4              # y * 16 bytes
    srl  $t1,$a0,2              # x / 4
    add  $t0,$t0,$t1            # byte offset into display
    la   $t2,0xffff0008
    add  $t0,$t2,$t0            # address of byte with the LED
    # now, compute bit position in the byte and the mask for it
    andi $t1,$a0,0x3            # remainder is bit position in byte
    neg  $t1,$t1                # negate position for subtraction
    addi $t1,$t1,3              # bit positions in reverse order
        sll  $t1,$t1,1              # led is 2 bits
    # load LED value, get the desired bit in the loaded byte
    lbu  $t2,0($t0)
    srlv $t2,$t2,$t1            # shift LED value to lsb position
    andi $v0,$t2,0x3            # mask off any remaining upper bits
    jr   $ra

sleep:
    li $v0, 32          # Prepare syscall sleep
    li $a0, 200         # For this many milliseconds
    syscall
    jr $ra

randinit:               # initialize random
    subi $sp, $sp, 8
    sw $ra, 0($sp)
    sw $s0, 4($sp)
    li $v0, 30
    syscall
    move $s0, $a0
    move $a1, $s0
    li $a0, 1
    li $v0, 40
    syscall
    lw $ra, 0($sp)
    lw $s0, 4($sp)
    addi $sp, $sp, 8
    jr $ra
getRandomNumber:            # get random (I:$a0, O: $t1)
    subi $sp, $sp, 4
    sw $ra, 0($sp)
    move $a1, $a0
    li $a0, 1
    li $v0, 42
    syscall
    move $t1, $a0
    lw $ra, 0($sp)
    addi $sp, $sp, 4
    jr $ra