[SOLVED] INFO1110 Assignment 4-Acorn Runner: An escape to survive

INFO1110

Acorn Runner: An escape to survive

You are an acorn, heir to the Honourable Furious Forest Throne. Your beauty shines like no other, reflecting the colourful solar rays into the eyes of all spectators. But instead of your usual coat of beautiful acorn shell, you find yourself covered in ash. Not only that, but you’ve fallen great depths from the heights of the towering trees of the Honourable Furious Forest that once cared for you.

You shed a tear of loss. The horrid memories of the Fire Nation’s invasion flash before you as you relive the moments your hometown, the Honourable Furious Forest, was burnt to ashes. Your friends, the koalas and kangaroos, your family, the Honourable Furious Forest members, all burnt to a crisp.

Mustering up your motivation for revenge, you, the acorn, heir to the Honourable Furious Forest Throne, stumble forward and find yourself in a maze. You observe walls of fire, helicopter search lights and teleporting pads within.

You cry out and slam your little acorn fist on the greyed Honourable Furious Forest floor of dried up leaves. You swear upon your Father’s name, Lord Scarlet Oak of the Honourable Furious Forest, that you will conquer this maze and restore the Honourable Furious Forest back to its former glory of rainbow and sunshine.

🔥 💧 ➖ 🏴 🌰

Cells

Cell character

Meaning

A Player cell (stands for Acorn)

” Air cell (space bar)

24. X  Starting cell
25. Y  Ending/Goal cell

* Wall cells

W

A water bucket cell. On stepping onto the cell, the player gains a water bucket.

F A fire obstacle that you cannot pass unless you have a water bucket.

Configuration

There will be one txt file which contains an ASCII representation of the maze. The maze may have more than one viable solution. The symbols correspond to the cell characters outlined above. All letters shall be in upper case.

Example configuration file:

Commands

Command Meaning

w Move up

a Move left

s Move down

4. d  Move right
5. e  Wait a turn

q Quit the game

If the user enters an invalid move, print Please enter a valid move (w, a, s, d, e, q). . The game should then continue to ask for the next move.

These commands are case-insensitive! See the sample outputs below for usage!

Implementation details

Your program will be written in Python 3. The only in-built module methods and attributes you are allowed to use are:

sys.argv
sys.exit()
os.system(“clear”) <— (More on this later)

You may not import any other modules.

To help you, a scaffold of a suggested implementation structure is provided. Some test cases require certain features of your code and cannot be modified.

Things you CANNOT modify (these are tested):

cells.py display

player.py num_water_buckets

The your

The
to test your

attribute will be used to test function.

attribute will be used function.

display

grid_to_string()

player.py display Same as above.

num_water_buckets

player.py

player.py

row Specifies their row in the grid.

col Specifies their col in the grid.

You may modify any other files to your liking. The rest of the scaffold is to help you with some basic structure! You may, of course, import your own modules…! You are also encouraged to write helper functions appropriately.

Note: No file other than run.py and solver.py should print to the screen! Only run.py should print to the screen while playing the game. This is good programming practice, so get used to it early! If needed, you may use it sparingly to debug your program!

game.py

It is recommended you write your game engine here. By writing a Game class, you can easily run and delete game instances for your solver. The game engine should hold all the relevant data regarding the game’s state. This includes the moves made, the player’s position, the cells, etc.

You should call which uses the parse() function to parse the lines in the file. Your function should return the grid as well. If you decide to do this differently however, that is also ok!

cells.py

It is recommended that you write your cells here. All cells must have a display attribute. We recommend your cells also have a step() method. The step() method should take in a Game object (defined above) and make modifications to the game depending on the cell.

If you are a strong programmer and know how to use inheritance, you may use it. Using inheritance will not advantage you much however, and the assignment is completely doable without it! We will not teach it in this course, so it is up to you if you want to use it!

Notable cells:

read_lines()

grid_to_string()

read_lines()

Cell

If a user steps onto a Wall cell, the user should be pushed back to their original cell and the message You walked into a wall. Oof! should be returned. The game should not record illegal user moves onto walls or out of bounds!

Water Cell
If a user steps onto a cell, it should increment the player’s water bucket count and return

Wall

Water

the message
should then behave like an Air block.

Fire Cell

If a user steps onto a Fire cell, two things can happen:
If the user has at least one water bucket, it should return the message

. It

Thank the Honourable Furious Forest, you've found a bucket of water!

acorn arms, you throw a water bucket at the fire. You acorn roll your way

With your strong

through the extinguished flames!

You step into the

Teleport

Teleport

Whoosh! The magical gates break Physics as we know it and opens a wormhole

.
If a user waits (by inputting ‘e’ ) on a teleport cell after stepping on one, they will be teleported

again.

If the Acorn is currently on a teleport pad and walk into a wall, when the Acorn is pushed back, it does not re-trigger the teleport pad.

player.py

It is recommend that you write your Player class here. It must contain the attribute num_water_buckets . The Player class should also contain a method called move(…) which

will receive a move command and move the player.

The class must have a row and col attribute which represents their location on the grid. The function must use these attributes when drawing the player.

If a Player tries to leave the grid (say there was a hole in the perimeter), it should act as if the player walked into a wall.

game_parser.py

It is recommended that you write your parser functions here. A parser is a module which reads an input and processes it into something useful.

through space and time.

Player

grid_to_string()

and reduce the player’s water bucket count by one. The fire block should then behave like an Air block.

If the user does not have a water bucket, it should return the message

and end the game.

Cell

If a user steps onto a cell, it should teleport the user to the destination and return the message

You may assume that the input grid given in the configuration file is a rectangle (i.e. each row has the same number of entries). You may also assume that the border of the maze given in the configuration file will be surrounded with wall cells (except the starting and ending cells)!

Your parse() function will be tested. It should receive a list of strings. The parse() function must be able to handle \n characters at the end of each string in the input list. There are certain error cases it must be able to handle. In this specific order:

If the configuration file contains an unknown letter (including teleport pad ‘0’), raise a ValueError with message Bad letter in configuration file: <letter>. . If there

are multiple unknown letters, you only need to output a single unknown letter in the message. You do not need to find them all and concatenate the output!

If the configuration file does not contain exactly one X , raise a ValueError with message Expected 1 starting position, got <number>. , where number is the occurrence of X .

If the configuration file does not contain exactly one Y , raise a ValueError with message Expected 1 ending position, got <number>. , where number is the occurrence of Y .

If the teleport pads do not come in exact pairs, raise a with message
, where

number is the number of the teleport pad. If there are multiple pairs of non-matching pads, you only need to output a single pad number in the message. You do not need to find them all and concatenate the output!

The function will not be tested. You will need to use this to prepare your data to pass into the function. If the file doesn’t exist, print <filename> does not exist! and exit gracefully.

The order of function calls in this file should look like:

Call read_lines()
Call parse(lines)

Return grid Return grid

grid.py

It is recommended that you write helper functions for the grid here.

The grid_to_string() function must be implemented in this file as it is tested. It should take in a grid (list of lists of Cells ) and a Player . It should return the grid and the number of water buckets the player has as a single string.

Note: Your returned string should include \n characters. Example contents of the string:

ValueError

Teleport pad <number> does not have an exclusively matching pad.

read_lines()

parse()

solver.py – Solver

This file is the entry-point to your solver program. Your solver should have two modes, Depth First Search (DFS) and Breadth First Search (BFS). These are two maze solving algorithms and the pseudocode will be provided in the corresponding lab sheet. Your solver should take in two command line arguments that represents the filename of the configuration file and the mode (DFS or BFS).

If no command line argument is provided, print and exit gracefully.

It should print out the number of moves made as well as the path. There may be more than one path at the shortest path length. These are all accepted solutions. You only need to find and output one such path. The output shall follow the format:

If there are no solutions:

Some tips:

You should only need to change one line to move between DFS and BFS modes! Truly understand how these algorithms work. Their advantages, shortcomings,

appropriateness, etc.

Avoid recursion as it is not very efficient and your solves may time out!

You may want to prohibit your solver from “waiting” more than three turns consecutively.

You may ask your tutor for assistance in the solver component regarding your algorithm design. Not your code!

Ed test cases will test both DFS and BFS modes. While the test cases will be as lenient as possible in terms of run-time, If your solver times out, you need to rethink how you approach the problem!

The DFS and BFS modes will be given different configuration files as they shine in different scenarios.

Your BFS solver must produce an optimal path. There may be multiple optimal paths and these will all be considered correct! (what do you think ‘optimal’ here means?)

Your DFS solver only needs to produce a valid path since there are many paths it can take.

A summary of the file relationships are as follows:

Game Finish

When the player finishes the game successfully by reaching the ending/goal cell, print:

When the player finishes the game unsuccessfully, print:

Submission

You will submit your code on two separate assessment pages on Ed, a milestone submission assessment page and a final submission assessment page. There will be some public and hidden test cases to guide you, however, be aware that there is a portion of marks allocated to writing your own test cases!

Here is a brief checklist of the things you will be required to submit:

Item

Game code Milestone

Solver code

Report (no more than 500 words as specified above)

Milestone:

Where

Ed Milestone submission page

Ed Final submission page

Ed Final submission page and

Canvas TurnItIn

Time

Milestone Deadline

Final deadline

Final deadline

Game code Ed Final submission page

Final deadline

Test code (unit tests and E2E tests) Ed Final submission page

Final deadline

The following will be tested against automated test cases. There is no manual marking component.

game_parser.py:

parse()
Please only use the cell’s display attribute to pass the test cases in parse() .

grid.py:

         grid_to_string()

player.py:
num_water_buckets attribute (int) row attribute (int)
col attribute (int)

Further breakdown:

Self documenting code – 2.5%

The code should largely talk for itself.
Avoid complex one liners that others may not understand. Ensure variable names are meaningful.

Good comments – 2.5%
Not too many, not too few.
Should compliment code, not act as a band-aid for nonsensical code!

Layout – 2.5%
Code should be spaced out vertically.
Code should be spaced out horizontally ( i = 0 is better than i=0 ).

import s are at the top of the file. Structure – 2.5%

Modularity: should this be in its own function/method?
Program flow is well thought out and makes sense.
Code and state are stored in relevant places.
Code should not be overly complex if there is a clearly easier way to do it. Side effects should be kept to a minimum.

Hint: You may directly ask your tutor during the lab sessions what they like, and what they don’t like to see! They will be the ones manually marking your assignment.

Report – 10%

Please attach your report as a pdf file into the same workspace as your final submission titled Report.pdf . There will be a strict word limit of 500 words. Your answers do not need to be long.

You may use dot points to list your responses where appropriate. We want content in your answers, not word fluff!

Please also submit your report to TurnItIn via Canvas.

Section 1 – Testing (3% total, 1% each question):

1. List 3 reasons why it is good to write test cases.
2. We have not discussed mocks. Research and briefly explain the use of mocks in testing. List two advantages and two disadvantages of mocking. Where should mocks generally be used? (unit tests or E2E tests?)
3. Give a real life example of where insufficient code testing led to problems. Cite your resource appropriately. If you are unsure how to cite appropriately, use the Harvard referencing standard.

Section 2 – Solver (7%):

You may assume that the starting cell is on the top row and the ending cell is on the bottom row of the map. Qualitatively consider run-time and correctness.

1. What are the strengths and weaknesses of the BFS algorithm? When would you want to use BFS? (2%)

2. What are the strengths and weaknesses of the DFS algorithm? When would you want to use DFS? (2%)
3. What happens if the ending cell is very close to the starting cell? Is DFS guaranteed to be faster than BFS? (1%)
4. In normal BFS and DFS algorithms, there is usually a list of visited cells that help the algorithm perform faster by not re-visiting a cell. However, this game setup has a certain feature in it that does not allow you to use this. What feature of the game stops you from using a list of visited cells to improve run-time? Justify briefly by giving a simple example. (Hint: Think scenarios where you have to re-visit a cell to complete the game. What about you changed since the previous time you were there?) (2%)

FAQ
Where do I start!?

After reading through this sheet, you are recommended to start by tackling the milestone components!

I need help!

You are strongly encouraged to ask questions about the assignment to your tutors and on the discussion board, Ed. Tutors will be able to support you through the difficult sections of this assignment. Please read this assignment description carefully before you ask questions though!

DO NOT POST YOUR CODE (including small snippets) PUBLICLY. You will be penalised. You can post some code if it is made private and only view-able by tutors. However, limited help will be offered for the implementation of this assignment.

The solver looks too difficult! How can we do this as first years!?

You can easily achieve a distinction this assignment if you completely ignore the solver component. If you want an HD, you have to earn it!

The solver component was designed to be do-able for first year students who thoroughly understand procedural programming. Believe in yourself! You can do it!

Advice?

Start early. You can complete 90% of this assignment once you take the week 9 lab. Develop on your own local environment. It’s much faster and efficient to do so! Write tests as you write your modules (or even before)!

Can I use for and in in the assignment? Yes!

Sample outputs