CSC $256$ Final Project

An ancient robot game

For this project, you are given a program that implements a game where a human user

tries to escape from four robots. The user and four robots are on an x$-$y grid. On every

step, you enter a move for the human. The robots will attempt to get closer to the human.

When a robot has the same x$-$y coordinates as the human, the game is over. You will

translate this program faithfully, following all function call guidelines and MIPS register

use conventions.

Two arrays x$[4]$ and y$[4]$ keep track of the x$-$ and y$-$coordinates of four robots. The

positions of the human and the four robots are initialized in the program. On each step,

the user enters a move; the positions of the human and the robots are updated. This

continues until the human dies. This figure gives an idea of the game; we$$ll work with a

text$-$only version, sorry.

In the main loop, the user is prompted to enter a move. The position of the user is

updated. Then the program calls a function moveRobots$()$ to update the position of

the robots as they try to catch the human. The new positions of the human and the robots

are then displayed.

The function moveRobots$()$ has prototype

int moveRobots$($int $*$arg$0,$ int $*$arg$1,$ int arg$2,$ int arg$3)$

arg$0$ is the base address of array that contains the x$-$coordinates of the four robots, arg$1$ is

the base address of array that contains the y$-$coordinates of the four robots, arg$2$ is the x$-$

coordinate of the human, arg$3$ is the y$-$coordinate of the human. moveRobots$()$updates the positions of the four robots, and returns a $1$ if the human is alive, and a $0$ if the human

is dead $($i$.$e$.,$ the human has the same coordinates as a robot$).$ Each coordinate of a robot

is updated by calling the function getNew$(),$ which returns the new coordinate based

on the current coordinate of the robot and the current coordinate of the human.

When you translate moveRobots$()$ to MIPS assembly language, arg$0$ through arg$3$

are in $a$0$ through $a$3$; the return value is in $v$0.$

The function getNew$()$ uses simple rules to move a robot closer to the human. If the

difference in the coordinates is $>=10,$ the robot's coordinate will move $10$ units closer to

the human. If the difference in the coordinates is $<10,$ the robot's coordinate will

move one unit closer to the human. $($See program listings.$)$ getNew$()$ has prototype

int getNew$($int arg$0,$ int arg$1)$

arg$0$ is the coordinate $($x or y$)$ of a robot, arg$1$ is the coordinate $($x or y$)$ of the human.

getNew$()$ returns the new coordinate of the robot, based on the position of the human.

The function getNew$()$ is already translated to MIPS assembly language, arg$0$ and arg$1$

are in $a$0$ and $a$1$ respectively, and the return value is in $v$0.$

A copy of the C$++$ program robots.cpp can be found on Canvas. The file robots.asm

contains the main program and getnew$(),$ already translated into MIPS assembly

language. Your functions will follows the main program in the same file.

Write the functions exactly as described in this handout. Do not implement the

program using other algorithms or tricks. Do not even switch the order of the arguments

in function calls; you must follow the order specified in the C$++$ code. The purpose of

this program is to test whether you understand nested functions. If you wish to make

changes to the algorithm, you must first check with the instructor.

Your functions should be properly commented. Each function must have its own header

block, including the prototype of the function, the locations of all arguments and return

values, descriptions of the arguments and how they are passed, and a description of what

the function does. Paste in the C$++$ code as inline comments for your MIPS assembly

code. Refer to the Programming Style handout from Chapter $2$ slides from Canvas for

guidelines on how to comment your code.

You should try to make your code efficient. For example, your loops should follow the

efficient form presented in class. Points will be deducted for obvious inefficiencies.

Submission: submit your code via Canvas. All your code should be in a single plain text

file.

$80\%$ of your grade is for correctness. $20\%$ is for clarity$/$documentation$.$

Output$\%$

Your coordinates: $2525$

Enter move $(1$ for $+$x$,-1$ for $-$x$,2$ for $+$ y$,-2$ for $-$y$)$:$2$

Your coordinates: $2526$

Robot at $1010$

Robot at $1040$

Robot at $4010$

Robot at $4040$

Enter move $(1$ for $+$x$,-1$ for $-$x$,2$ for $+$ y$,-2$ for $-$y$)$:$1$

Your coordinates: $2626$

Robot at $2020$

Robot at $2030$

Robot at $3020$

Robot at $3030$

Enter move $(1$ for $+$x$,-1$ for $-$x$,2$ for $+$ y$,-2$ for $-$y$)$:$2$

Your coordinates: $2627$

Robot at $2121$

Robot at $2129$

Robot at $2921$

Robot at $2929$

Enter move $(1$ for $+$x$,-1$ for $-$x$,2$ for $+$ y$,-2$ for $-$y$)$:$1$

Your coordinates: $2727$

Robot at $2222$

Robot at $2228$

Robot at $2822$

Robot at $2828$

Enter move $(1$ for $+$x$,-1$ for $-$x$,2$ for $+$ y$,-2$ for $-$y$)$:$2$

Your coordinates: $2728$

Robot at $2323$

Robot at $2328$

Robot at $2723$

Robot at $2728$

AAAARRRRGHHHHH... Game over

libra$\%$