代写159.172留学生编程、代做Python编程、Python程序设计调试

日期：2020-10-26 10:47

159.172 Computational Thinking

Programming Assignment 1:

Snake Game

This assignment is worth 15% of your final mark. It will be marked out of a total of 25

marks. You are expected to work on this assignment individually and all work that you hand

in is expected to be your own work.

In this assignment you will develop an animated application that uses several of the concepts

that we have studied so far in 159172.

Go to Stream and download the file

snake.py snake.py

Set up a new project and add this file to it.

snake.py is a program that implements the beginnings of a simple animation for the classic

"Snake Game". When you run this program, you will see a screen with a (very rudimentary)

moving snake. The direction of movement of the snake is controlled by the UP, DOWN,

LEFT and RIGHT keys. At the moment the snake just stops when it hits the edge of the

screen, until the user presses a suitable key to move it in another direction. It is currently

able to double back over the top of itself. In the finished game, either of these scenarios

would cause the snake to meet its demise.

The Snake class has two attributes:

1. self.segments - an (ordered) list of the body segments that make up the snake, each of

these is a Sprite object, defined in the pygame.sprite module.

2. self.spriteslist - a pygame.sprite.Group object, which is an (unordered) container to hold

and manage multiple Sprite objects, this allows for drawing or collision detection

methods to be applied on the whole group.

The Segment class is a subclass of pygame.sprite.Sprite. When a new segment object is created

we first call the parent constructor to create a new Sprite instance, then assign image and rect

attributes. The rect attribute is the bounding box for the image, we update the position of the

Sprite by setting values for rect.x and rect.y.

The move method in the Snake class moves the snake one step, in the direction determined

by the key pressed (UP, DOWN, LEFT or RIGHT.) It uses values assigned to the global

variables x_change and y_change to decide where the new "head" of the snake should be,

Computational Thinking 18/08/19, 6)30 PM

file:///Users/cmmccart/Documents/Teaching/159172/Assignment1_2019.html Page 2 of 5

variables x_change and y_change to decide where the new "head" of the snake should be,

relative to the old head. It creates a new segment at this position and inserts it at the front of

the segments list, then pops the last segment from the list. It also updates the spriteslist

attribute, using add and remove methods. This gives the effect of moving the whole body,

since every segment except the head should end up in the position of its predecessor at each

step.

The main game loop updates the x_change and y_change variables, depending on the key

pressed, then calls the move method on the snake object my_snake and draws the

my_snake.spriteslist Group object.

The aim of the "Snake Game" is to have the player control the snake, using the direction

keys, so that it "eats" food items by running over them with its head. Each item eaten makes

the snake longer, so control becomes progressively more difficult, since the player loses when

the snake runs into the screen border, obstacles other than food, or itself.

Your tasks

Before you start, go to Paul Craven's text "Program Arcade Games with Python and Pygame"

using this link http://programarcadegames.com, and read Chapter 13 "Introduction to

Sprites". See also https://www.pygame.org/docs/ref/sprite.html#pygame.sprite.Sprite for

documentation on the pygame module pygame.sprite.

1. Add some food for the snake to eat - create two new classes

class Food(): class Food():

...

class Food_item(pygame.sprite.Sprite): class Food_item(pygame.sprite.Sprite):

...

that mimic the Snake and Segment classes. Food_item objects should be Sprites, a Food

object should be a Group of randomly-placed food items (doesn't need to maintain an

ordering.) The number of food items provided at each point in the game is up to you.

Create a new Food object and update the main game loop so that it displays both the

snake and the food.

2. Update the main game loop to detect collisions between the head of the snake and any

food items. Food items that have been eaten should be removed. You can use the

method pygame.sprite.spritecollide() to find sprites in a group that collide with another

sprite. The return value for this method is a list containing all sprites in a group that

intersect with another Sprite. Usage example -

hit_list = pygame.sprite.spritecollide(one_sprite, hit_list = pygame.sprite.spritecollide(one_sprite,

sprite_Group, True) sprite_Group, True)

Computational Thinking 18/08/19, 6)30 PM

file:///Users/cmmccart/Documents/Teaching/159172/Assignment1_2019.html Page 3 of 5

The True flag will remove each sprite from sprite_Group that collides with one_sprite.

3. Add a grow() method to the Snake class that grows the snake by one segment each time

it eats a piece of food. Note that you will need to compare rect.x and rect.y positions of

the last and second-to-last segments of the snake in order to determine the direction in

which the snake's tail should grow. Create a new segment in the correct position and

add it to the snake.

4. Add a replenish() method to the Food class, to replace food that has been eaten with

new randomly-placed food items. Each time the snake eats a piece of food the Food

object needs to be replenished. The pattern that this takes is up to you, one for one

(recommended, to begin with), or increasing/decreasing amounts, or a new batch

provided when the last has completely run out. Make sure that new food items do not

land on the snake itself (we didn't worry about this to begin with.) To do this, you can

use the method pygame.sprite.spritecollide() again, but using a False flag. Usage example -

hit_list = pygame.sprite.spritecollide(one_sprite, hit_list = pygame.sprite.spritecollide(one_sprite,

sprite_Group, False) sprite_Group, False)

The False flag will ensure that each sprite from sprite_Group that collides with

one_sprite is not removed from the Group. If the hit_list is not empty, you can

recursively call the replenish() method to try again.

5. Add some obstacles for the snake to avoid - create a new class

class Obstacle(): class Obstacle():

...

whose instances are randomly sized and placed Sprites that the snake must avoid.

Create a new pygame.sprite.Group() object and add some obstacles to it. Make sure that

obstacles don't collide with the snake in its initial position. Update the main game loop

so that it displays the snake, the food and the obstacles.

6. Add code to implement a score for the game. Each time the snake eats a piece of food,

increment the score. You can make this a bit more interesting by adding type and points

attributes to the Food_item class. Not all food has to be created equal! (or displayed

identically.) Extend the screen so that there is a banner along the bottom (separate from

the main game environment) where you display the score.

Computational Thinking 18/08/19, 6)30 PM

file:///Users/cmmccart/Documents/Teaching/159172/Assignment1_2019.html Page 4 of 5

Displaying text in pygame is a bit tricky, you can do it using these five steps (change

the font/message to your liking):

# create a Font object from the system fonts create a Font object from the system fonts

font = pygame.font.SysFont("comicsansms", 48) font = pygame.font.SysFont("comicsansms", 48)

# create an image (Surface) of the text create an image (Surface) of the text

text = font.render('Score = ' + str(score), True, text = font.render('Score = ' + str(score), True,

(255, 0, 0)) (255, 0, 0))

# get the bounding box for the image get the bounding box for the image

textrect = text.get_rect() textrect = text.get_rect()

# set the position set the position

textrect.centerx = 200 textrect.centerx = 200

textrect.centery = 700 textrect.centery = 700

# blit (copy) the image onto the screen blit (copy) the image onto the screen

screen.blit(text, textrect) screen.blit(text, textrect)

Update the main game loop so that it displays the snake, the food, the obstacles and

the current score.

7. Add code to end the game. The player loses when the snake runs into the screen

border, obstacles other than food, or itself. If any of these things happen, clear the

screen and display a "Game Over" message in the bottom banner area. Note that

adding a game_ended Boolean flag, and setting it to True here, rather than setting done =

True, will allow for the display to stay live until the player decides to Quit.

8. Challenge Exercise: Add an "enemy" snake. This second snake should be controlled by

the program, independently of the player. It should start off at a location somewhat

away from the original snake and should move one step on each iteration of the main

game loop. You will need to create a new method in the Snake class - ai_move() - to

control the movement of the enemy snake. You need to make sure that the enemy

snake doesn't double back on itself and that it doesn't change direction too often. You

can make this snake as smart as you like. For example, before making a move, it can

check if this will make it hit the screen border or an obstacle, and if so it can make a

different move. The enemy snake doesn't need to eat food, it just obstructs or chases the

original snake. If the original snake collides with the enemy snake, the player loses.

Computational Thinking 18/08/19, 6)30 PM

file:///Users/cmmccart/Documents/Teaching/159172/Assignment1_2019.html Page 5 of 5

Extensions (not marked):

1. Add code to implement a "high score" ladder, that is initialised and then retained

from one play to the next. This will require you to store information in a text file,

separate from the game program. When the game begins, ask the player for a

name. When the game ends, display the information from your file - high scores

along with player names. If the current player has beaten one of these, store the

name and the score achieved in your text file.

2. To make everything look nicer, use graphical sprites rather than filled blocks. For

a very simple introduction, see http://kidscancode.org/blog/2016/08/pygame_1-

3_more-about-sprites/

Submission

Submit the assignment in Stream as a single zipped file containing:

1. Your completed code, contained in the file snake.py.

2. A word document containing annotated screen shots demonstrating the behaviour of

your program.

3. If you have completed any extensions to the program, submit your extended code as a

separate module, or modules, and include a separate word document demonstrating the

extended program behavior.

Marking Scheme:

Completion of each of the first seven tasks: 3 marks each

Annotated screenshots demonstrating the behaviour of your program - 2 marks

Implementation of the Challenge Exercise - 2 marks

Total – 25 marks

Late submission:

Late assignments will be penalised 10% for each weekday past the deadline, for up to five (5)

days; after this no marks will be gained. In special circumstances an extension may be

obtained from the paper co-ordinator, and these penalties will not apply. Workload will not

be considered a special circumstance – you must budget your time.