Question: #-----Task Description-----------------------------------------------# # # TREASURE MAP # # This assignment tests your skills at processing data stored in # lists, creating reusable code and following

#-----Task Description-----------------------------------------------#

#

# TREASURE MAP

#

# This assignment tests your skills at processing data stored in

# lists, creating reusable code and following instructions to display

# a complex visual image. The incomplete Python program below is

# missing a crucial function, "follow_path". You are required to

# complete this function so that when the program is run it traces

# a path on the screen, drawing "tokens" to indicate discoveries made

# along the way, while using data stored in a list to determine the

# steps to be taken. See the instruction sheet accompanying this

# file for full details.

#

# Note that this assignment is in two parts, the second of which

# will be released only just before the final deadline. This

# template file will be used for both parts and you will submit

# your final solution as a single Python 3 file, whether or not you

# complete both parts of the assignment.

#

#--------------------------------------------------------------------#

#-----Preamble-------------------------------------------------------#

#

# This section imports necessary functions and defines constant

# values used for creating the drawing canvas. You should not change

# any of the code in this section.

#

# Import the functions needed to complete this assignment. You

# should not need to use any other modules for your solution. In

# particular, your solution must not rely on any non-standard Python

# modules t hat need to be downloaded and installed separately,

# because the markers will not have access to such modules.

from turtle import *

from math import *

from random import *

# Define constant values used in the main program that sets up

# the drawing canvas. Do not change any of these values.

grid_size = 100 # pixels

num_squares = 7 # to create a 7x7 map grid

margin = 50 # pixels, the size of the margin around the grid

legend_space = 400 # pixels, the space to leave for the legend

window_height = grid_size * num_squares + margin * 2

window_width = grid_size * num_squares + margin + legend_space

font_size = 18 # size of characters for the coords

starting_points = ['Top left', 'Top right', 'Centre',

'Bottom left', 'Bottom right']

#

#--------------------------------------------------------------------#

#-----Functions for Creating the Drawing Canvas----------------------#

#

# The functions in this section are called by the main program to

# manage the drawing canvas for your image. You should not change

# any of the code in this section. (Very keen students are welcome

# to draw their own background, provided they do not change the map's

# grid or affect the ability to see it.)

#

# Set up the canvas and draw the background for the overall image

def create_drawing_canvas():

# Set up the drawing window with enough space for the grid and

# legend

setup(window_width, window_height)

setworldcoordinates(-margin, -margin, window_width - margin,

window_height - margin)

# Draw as quickly as possible

tracer(False)

# Choose a neutral background colour (if you want to draw your

# own background put the code here, but do not change any of the

# following code that draws the grid)

bgcolor('light grey')

# Get ready to draw the grid

penup()

color('slate grey')

width(2)

# Draw the horizontal grid lines

setheading(0) # face east

for y_coord in range(0, (num_squares + 1) * grid_size, grid_size):

penup()

goto(0, y_coord)

pendown()

forward(num_squares * grid_size)

# Draw the vertical grid lines

setheading(90) # face north

for x_coord in range(0, (num_squares + 1) * grid_size, grid_size):

penup()

goto(x_coord, 0)

pendown()

forward(num_squares * grid_size)

# Draw each of the labels on the x axis

penup()

y_offset = -27 # pixels

for x_coord in range(0, (num_squares + 1) * grid_size, grid_size):

goto(x_coord, y_offset)

write(str(x_coord), align = 'center',

font=('Arial', font_size, 'normal'))

# Draw each of the labels on the y axis

penup()

x_offset, y_offset = -5, -10 # pixels

for y_coord in range(0, (num_squares + 1) * grid_size, grid_size):

goto(x_offset, y_coord + y_offset)

write(str(y_coord), align = 'right',

font=('Arial', font_size, 'normal'))

# Mark the space for drawing the legend

goto((num_squares * grid_size) + margin, (num_squares * grid_size) // 2)

write(' Put your legend here', align = 'left',

font=('Arial', 24, 'normal'))

# Reset everything ready for the student's solution

pencolor('black')

width(1)

penup()

home()

tracer(True)

# End the program and release the drawing canvas to the operating

# system. By default the cursor (turtle) is hidden when the

# program ends - call the function with False as the argument to

# prevent this.

def release_drawing_canvas(hide_cursor = False):

tracer(True) # ensure any drawing still in progress is displayed

if hide_cursor:

hideturtle()

done()

#

#--------------------------------------------------------------------#

#-----Test Data for Use During Code Development----------------------#

#

# The "fixed" data sets in this section are provided to help you

# develop and test your code. You can use them as the argument to

# the follow_path function while perfecting your solution. However,

# they will NOT be used to assess your program. Your solution will

# be assessed using the random_path function appearing below. Your

# program must work correctly for any data set that can be generated

# by the random_path function.

#

# Each of the data sets is a list of instructions expressed as

# triples. The instructions have two different forms. The first

# instruction in the data set is always of the form

#

# ['Start', location, token_number]

#

# where the location may be 'Top left', 'Top right', 'Centre',

# 'Bottom left' or 'Bottom right', and the token_number is an

# integer from 0 to 4, inclusive. This instruction tells us where

# to begin our treasure hunt and the token that we find there.

# (Every square we visit will yield a token, including the first.)

#

# The remaining instructions, if any, are all of the form

#

# [direction, number_of_squares, token_number]

#

# where the direction may be 'North', 'South', 'East' or 'West',

# the number_of_squares is a positive integer, and the token_number

# is an integer from 0 to 4, inclusive. This instruction tells

# us where to go from our current location in the grid and the

# token that we will find in the target square. See the instructions

# accompanying this file for examples.

#

# Some starting points - the following fixed paths just start a path

# with each of the five tokens in a different location

fixed_path_0 = [['Start', 'Top left', 0]]

fixed_path_1 = [['Start', 'Top right', 1]]

fixed_path_2 = [['Start', 'Centre', 2]]

fixed_path_3 = [['Start', 'Bottom left', 3]]

fixed_path_4 = [['Start', 'Bottom right', 4]]

# Some miscellaneous paths which encounter all five tokens once

fixed_path_5 = [['Start', 'Top left', 0], ['East', 1, 1], ['East', 1, 2],

['East', 1, 3], ['East', 1, 4]]

fixed_path_6 = [['Start', 'Bottom right', 0], ['West', 1, 1], ['West', 1, 2],

['West', 1, 3], ['West', 1, 4]]

fixed_path_7 = [['Start', 'Centre', 4], ['North', 2, 3], ['East', 2, 2],

['South', 4, 1], ['West', 2, 0]]

# A path which finds each token twice

fixed_path_8 = [['Start', 'Bottom left', 1], ['East', 5, 2],

['North', 2, 3], ['North', 4, 0], ['South', 3, 2],

['West', 4, 0], ['West', 1, 4],

['East', 3, 1], ['South', 3, 4], ['East', 1, 3]]

# Some short paths

fixed_path_9 = [['Start', 'Centre', 0], ['East', 3, 2],

['North', 2, 1], ['West', 2, 3],

['South', 3, 4], ['West', 4, 1]]

fixed_path_10 = [['Start', 'Top left', 2], ['East', 6, 3], ['South', 1, 0],

['South', 1, 0], ['West', 6, 2], ['South', 4, 3]]

fixed_path_11 = [['Start', 'Top left', 2], ['South', 1, 0], ['East', 2, 4],

['South', 1, 1], ['East', 3, 4], ['West', 1, 3],

['South', 2, 0]]

# Some long paths

fixed_path_12 = [['Start', 'Top right', 2], ['South', 4, 0],

['South', 1, 1], ['North', 3, 4], ['West', 4, 0],

['West', 2, 0], ['South', 3, 4], ['East', 2, 3],

['East', 1, 1], ['North', 3, 2], ['South', 1, 3],

['North', 3, 2], ['West', 1, 2], ['South', 3, 4],

['East', 3, 0], ['South', 1, 1]]

fixed_path_13 = [['Start', 'Top left', 1], ['East', 5, 3], ['West', 4, 2],

['East', 1, 3], ['East', 2, 2], ['South', 5, 1],

['North', 2, 0], ['East', 2, 0], ['West', 1, 1],

['West', 5, 0], ['South', 1, 3], ['East', 3, 0],

['East', 1, 4], ['North', 3, 0], ['West', 1, 4],

['West', 3, 1], ['South', 4, 1], ['East', 5, 1],

['West', 4, 0]]

# "I've been everywhere, man!" - this path visits every square in

# the grid, with randomised choices of tokens

fixed_path_99 = [['Start', 'Top left', randint(0, 4)]] + \

[['East', 1, randint(0, 4)] for step in range(6)] + \

[['South', 1, randint(0, 4)]] + \

[['West', 1, randint(0, 4)] for step in range(6)] + \

[['South', 1, randint(0, 4)]] + \

[['East', 1, randint(0, 4)] for step in range(6)] + \

[['South', 1, randint(0, 4)]] + \

[['West', 1, randint(0, 4)] for step in range(6)] + \

[['South', 1, randint(0, 4)]] + \

[['East', 1, randint(0, 4)] for step in range(6)] + \

[['South', 1, randint(0, 4)]] + \

[['West', 1, randint(0, 4)] for step in range(6)] + \

[['South', 1, randint(0, 4)]] + \

[['East', 1, randint(0, 4)] for step in range(6)]

# If you want to create your own test data sets put them here

#

#--------------------------------------------------------------------#

#-----Function for Assessing Your Solution---------------------------#

#

# The function in this section will be used to assess your solution.

# Do not change any of the code in this section.

#

# The following function creates a random data set specifying a path

# to follow. Your program must work for any data set that can be

# returned by this function. The results returned by calling this

# function will be used as the argument to your follow_path function

# during marking. For convenience during code development and

# marking this function also prints the path to be followed to the

# shell window.

#

# Note: For brevity this function uses some Python features not taught

# in IFB104 (dictionaries and list generators). You do not need to

# understand this code to complete the assignment.

#

def random_path(print_path = True):

# Select one of the five starting points, with a random token

path = [['Start', choice(starting_points), randint(0, 4)]]

# Determine our location in grid coords (assuming num_squares is odd)

start_coords = {'Top left': [0, num_squares - 1],

'Bottom left': [0, 0],

'Top right': [num_squares - 1, num_squares - 1],

'Centre': [num_squares // 2, num_squares // 2],

'Bottom right': [num_squares - 1, 0]}

location = start_coords[path[0][1]]

# Keep track of squares visited

been_there = [location]

# Create a path up to 19 steps long (so at most there will be 20 tokens)

for step in range(randint(0, 19)):

# Find places to go in each possible direction, calculating both

# the new grid square and the instruction required to take

# us there

go_north = [[[location[0], new_square],

['North', new_square - location[1], token]]

for new_square in range(location[1] + 1, num_squares)

for token in [0, 1, 2, 3, 4]

if not ([location[0], new_square] in been_there)]

go_south = [[[location[0], new_square],

['South', location[1] - new_square, token]]

for new_square in range(0, location[1])

for token in [0, 1, 2, 3, 4]

if not ([location[0], new_square] in been_there)]

go_west = [[[new_square, location[1]],

['West', location[0] - new_square, token]]

for new_square in range(0, location[0])

for token in [0, 1, 2, 3, 4]

if not ([new_square, location[1]] in been_there)]

go_east = [[[new_square, location[1]],

['East', new_square - location[0], token]]

for new_square in range(location[0] + 1, num_squares)

for token in [0, 1, 2, 3, 4]

if not ([new_square, location[1]] in been_there)]

# Choose a free square to go to, if any exist

options = go_north + go_south + go_east + go_west

if options == []: # nowhere left to go, so stop!

break

target_coord, instruction = choice(options)

# Remember being there

been_there.append(target_coord)

location = target_coord

# Add the move to the list of instructions

path.append(instruction)

# To assist with debugging and marking, print the list of

# instructions to be followed to the shell window

print('Welcome to the Treasure Hunt!')

print('Here are the steps you must follow...')

for instruction in path:

print(instruction)

# Return the random path

return path

I have this so far but i need drawings for the token but don't know what to draw any help with some would be great and need to put them on the blank box need all 5 token put on there as well as add how many are used during the random drawings

#-----Student's Solution---------------------------------------------#

#

# Complete the assignment by replacing the dummy function below with

# your own "follow_path" function.

# Defining the Legend box.

def legend_box():

goto(750,600)

width(6)

pencolor('black')

fillcolor('grey')

begin_fill()

pendown()

setheading(270)

forward(500)

setheading(0)

forward(345)

setheading(90)

forward(500)

setheading(180)

forward(345)

end_fill()

penup()

# Defining all of the tokens being Drawn.

def token_drawn(path):

if path[2] == 0:

Bundaberg_rum()

if path[2] == 1:

Jim_beam()

if path[2] == 2:

Black_douglas()

if path[2] == 3:

Ozzo()

if path[2] == 4:

Sambucca()

# Defining the Starting position.

def starting_position(path):

if path[1] == 'Bottom right':

goto(650,50)

if path[1] == 'Top right':

goto(650,650)

if path[1] == 'Center':

goto(350,350)

if path[1] == 'Top left':

goto(50,650)

if path[1] == 'Bottom left':

goto(50,50)

# Defining the route of the map.

def location(path):

if path[0] == 'North':

setheading(90)

if path[0] == 'East':

setheading(0)

if path[0] == 'South':

setheading(270)

if path[0] == 'West':

setheading(180)

forward( path[1] * 100)

token_drawn(path)

# Drawing token 1.

def Bundaberg_rum():

center = position()

penup()

width(2)

begin_fill()

pencolor('black')

fillcolor('orange')

setheading(180)

forward(20)

setheading(270)

pendown()

forward(50)

setheading(0)

forward(25)

setheading(90)

forward(50)

setheading(180)

forward(8)

setheading(90)

forward(50)

setheading(180)

forward(10)

setheading(270)

forward(50)

setheading(180)

forward(6)

setheading(270)

forward(10)

end_fill()

penup()

goto(center)

# Drawing token 2.

def Jim_beam():

center = position()

width(2)

begin_fill()

pencolor('white')

fillcolor('goldenrod')

setheading(180)

forward(20)

setheading(270)

pendown()

forward(50)

setheading(0)

forward(25)

setheading(90)

forward(50)

setheading(180)

forward(8)

setheading(90)

forward(50)

setheading(180)

forward(10)

setheading(270)

forward(50)

setheading(180)

forward(6)

setheading(270)

forward(10)

end_fill()

penup()

goto(center)

# Drawing token 3.

def Black_douglas():

center = position()

width(2)

begin_fill()

pencolor('black')

fillcolor('dark goldenrod')

setheading(180)

forward(20)

setheading(270)

pendown()

forward(50)

setheading(0)

forward(25)

setheading(90)

forward(50)

setheading(180)

forward(8)

setheading(90)

forward(50)

setheading(180)

forward(10)

setheading(270)

forward(50)

setheading(180)

forward(6)

setheading(270)

forward(10)

end_fill()

penup()

goto(center)

# Drawing token 4.

def Ozzo():

center = position()

width(2)

begin_fill()

pencolor('white')

fillcolor('light sea green')

setheading(180)

forward(20)

setheading(270)

pendown()

forward(50)

setheading(0)

forward(25)

setheading(90)

forward(50)

setheading(180)

forward(8)

setheading(90)

forward(50)

setheading(180)

forward(10)

setheading(270)

forward(50)

setheading(180)

forward(6)

setheading(270)

forward(10)

end_fill()

penup()

goto(center)

# Drawing token 5.

def Sambucca():

center = position()

width(2)

begin_fill()

pencolor('white')

fillcolor('sea green')

setheading(180)

forward(20)

setheading(270)

pendown()

forward(50)

setheading(0)

forward(25)

setheading(90)

forward(50)

setheading(180)

forward(8)

setheading(90)

forward(50)

setheading(180)

forward(10)

setheading(270)

forward(50)

setheading(180)

forward(6)

setheading(270)

forward(10)

end_fill()

penup()

goto(center)

# Follow the path as per the provided dataset.

def follow_path(path):

legend_box()

for direction in path:

if direction[0] == 'Start':

starting_position(direction)

if direction[0] != 'Start':

location(direction)

Step by Step Solution

There are 3 Steps involved in it

1 Expert Approved Answer
Step: 1 Unlock blur-text-image
Question Has Been Solved by an Expert!

Get step-by-step solutions from verified subject matter experts

Step: 2 Unlock
Step: 3 Unlock

Students Have Also Explored These Related Databases Questions!

Q:

#-----Task Description-----------------------------------------------# # # TREASURE MAP # # This assignment tests your skills at processing data stored in # lists, creating reusable code and...

Q:

#-----Task Description-----------------------------------------------# # # TREASURE MAP # # This assignment tests your skills at processing data stored in # lists, creating reusable code and...

Q:

There are two problems due this week (each worth 35 points) as follows. Problem 1.6 (page 20) In comprehensive paragraphs, answerrequirements a to e. You will have 5 paragraphs total of four to five...

Q:

I have to create a program in C and I can't figure it out. The program has to read a source file. Please help. /******************************************************************** PROJECT: Glossary...

Q:

Note: we are not concerned with rounding at the calculation level, however, please take note of the decimal precision represented in the output below Output Once you have calculated the necessary...

Q:

haa23684_PlugInT6CD.qxd 9/6/06 5:38 PM Page 2 CONFIRMING PAGES P L U G - I N T6 Basic Skills and Tools Using Access LEARNING OUTCOMES 1. Describe the primary functions using Microsoft Access. 2....

Q:

Module 9 Assignment: TOC Answer all the questions and submit your answer report to Module 9 Assignment in Dropbox by the deadline . The report should be typed, single spaced, in one MS Word file. You...

Q:

Predictive text entry systems are familiar on touch screens and mobile phones. This question asks you to consider how the same principles might be used in a programming editor for creating Java code....

Q:

Introduction Note: Circular Buffers are described in Section 5.2.4 of our textbook (p. 211). Please read that section before proceeding. An interesting, relatively straightforward data structure is...

Q:

answer the following questions: What are your moral obligations as professionals to prevent such things from happening? What guidance do the professional codes provide (cite specific code sections in...

Q:

What are the major differences between internal and external auditing? Why is the scope of activities much different for internal auditing than for the external audit?

Q:

Sunlight Pty Ltd is a business that manufactures and sells solar panels. The business was established in 2014 and has grown to a large proprietary company with four owners: Rachel, Fiona, John, and...

Q:

Jorge Rojo, CMA, has been working in a primary care practice for several years. He applies for a position with the specialty clinic closer to his home and offers better hours and more pay. This...

Q:

Assume that markets are perfect in the sense of being free from transactions costs and short selling impediments, that the only carrying cost is the cost of financing, that borrowing and lending can...

Q:

C What aspects of the public speaking situation do you think a VRT simulation could effectively simulate?

Q:

A What type of accent do you have? How do you feel it is perceived by others from different regions in the United States or even abroad?

Q:

Many of us feel awkward when we hear our voices on a recording, but rather than feel uncomfortable, you should learn to embrace your speaking voice. What aspects of your vocal delivery are unique to...