CS代考计算机代写 python “””

=== Module Description ===
This module contains the Game class and the main game application.

from typing import Any, Type, Tuple, List, Sequence, Optional
import pygame
from settings import *
from stack import Stack
import actor

class Game:
Class representing the game.
size: Tuple[int, int]
width: int
height: int
screen: Optional[pygame.Surface]
x_tiles: int
y_tiles: int
tiles_number: Tuple[int, int]
background: Optional[pygame.Surface]

_actors: List[actor.Actor]
_is: List[actor.Is]
_running: bool
_rules: List[str]
_history: Stack

player: Optional[actor.Actor]
map_data: List[str]
keys_pressed: Optional[Sequence[bool]]

def __init__(self) -> None:
Initialize variables for this Class.
self.width, self.height = 0, 0
self.size = (self.width, self.height)
self.screen = None
self.x_tiles, self.y_tiles = (0, 0)
self.tiles_number = (self.x_tiles, self.y_tiles)
self.background = None

# TODO Task 1: complete the initializer of the Game class

def load_map(self, path: str) -> None:
Reads a .txt file representing the map
with open(path, ‘rt’) as f:
for line in f:

self.width = (len(self.map_data[0])) * TILESIZE
self.height = len(self.map_data) * TILESIZE
self.size = (self.width, self.height)
self.x_tiles, self.y_tiles = len(self.map_data[0]), len(self.map_data)

# center the window on the screen
os.environ[‘SDL_VIDEO_CENTERED’] = ‘1’

def new(self) -> None:
Initialize variables to be object on screen.
self.screen = pygame.display.set_mode(self.size)
self.background = pygame.image.load(
for col, tiles in enumerate(self.map_data):
for row, tile in enumerate(tiles):
if tile.isnumeric():
Game.get_character(CHARACTERS[tile])(row, col))
elif tile in SUBJECTS:
actor.Subject(row, col, SUBJECTS[tile]))
elif tile in ATTRIBUTES:
actor.Attribute(row, col, ATTRIBUTES[tile]))
elif tile == ‘I’:
is_tile = actor.Is(row, col)

def get_actors(self) -> List[actor.Actor]:
Getter for the list of actors
return self._actors

def get_running(self) -> bool:
Getter for _running
return self._running

def get_rules(self) -> List[str]:
Getter for _rules
return self._rules

def _draw(self) -> None:
Draws the screen, grid, and objects/players on the screen
(((0.5 * self.width) – (0.5 * 1920),
(0.5 * self.height) – (0.5 * 1080))))
for actor_ in self._actors:
rect = pygame.Rect(actor_.x * TILESIZE,
self.screen.blit(actor_.image, rect)

# Blit the player at the end to make it above all other objects
if self.player:
rect = pygame.Rect(self.player.x * TILESIZE,
self.screen.blit(self.player.image, rect)


def _events(self) -> None:
Event handling of the game window
for event in pygame.event.get():
if event.type == pygame.QUIT:
self._running = False
# Allows us to make each press count as 1 movement.
elif event.type == pygame.KEYDOWN:
self.keys_pressed = pygame.key.get_pressed()
ctrl_held = self.keys_pressed[pygame.K_LCTRL]

# handle undo button and player movement here
if event.key == pygame.K_z and ctrl_held: # Ctrl-Z
if self.player is not None:
assert isinstance(self.player, actor.Character)
save = self._copy()
if self.player.player_move(self)
and not self.win_or_lose():

def win_or_lose(self) -> bool:
Check if the game has won or lost
Returns True if the game is won or lost; otherwise return False
assert isinstance(self.player, actor.Character)
for ac in self._actors:
if isinstance(ac, actor.Character)
and ac.x == self.player.x and ac.y == self.player.y:
if ac.is_win():
return True
elif ac.is_lose():
return True
return False

def run(self) -> None:
Run the Game until it ends or player quits.
while self._running:
pygame.time.wait(1000 // FPS)

def set_player(self, actor_: Optional[actor.Actor]) -> None:
Takes an actor and sets that actor to be the player
self.player = actor_

def remove_player(self, actor_: actor.Actor) -> None:
Remove the given from the game’s list of actors.
self.player = None

def _update(self) -> None:
Check each “Is” tile to find what rules are added and which are removed
if any, and handle them accordingly.

# TODO Task 3: Add code here to complete this method
# What you need to do in this method:
# – Get the lists of rules that need to be added to and remove from the
# current list of rules. Hint: use the update() method of the Is
# class.
# – Apply the additional and removal of the rules. When applying the
# rules of a type of character, make sure all characters of that type
# have their flags correctly updated. Hint: take a look at the
# get_character() method — it can be useful.
# – The player may change if the “isYou” rule is updated. Make sure set
# self.player correctly after you update the rules. Note that
# self.player could be None in some cases.
# – Update self._rules to the new list of rules.


def get_character(subject: str) -> Optional[Type[Any]]:
Takes a string, returns appropriate class representing that string
if subject == “Meepo”:
return actor.Meepo
elif subject == “Wall”:
return actor.Wall
elif subject == “Rock”:
return actor.Rock
elif subject == “Flag”:
return actor.Flag
elif subject == “Bush”:
return actor.Bush
return None

def _undo(self) -> None:
Returns the game to a previous state based on what is at the top of the
_history stack.
# TODO Task 4: Implement this undo method.
# You’ll need to restore the previous state the game using the
# self._history stack
# Find the code that pushed onto the stack to understand better what
# is in the stack.

def _copy(self) -> ‘Game’:
Copies relevant attributes of the game onto a new instance of Game.
Return new instance of game
game_copy = Game()
# TODO Task 4: Complete this method to create a proper copy of the
# current state of the game
return game_copy

def get_actor(self, x: int, y: int) -> Optional[actor.Actor]:
Return the actor at the position x,y. If the slot is empty, Return None
for ac in self._actors:
if ac.x == x and ac.y == y:
return ac
return None

def win(self) -> None:
End the game and print win message.
self._running = False
print(“Congratulations, you won!”)

def lose(self, char: actor.Character) -> None:
Lose the game and print lose message
print(“You lost! But you can have it undone if undo is done :)”)

if __name__ == “__main__”:

game = Game()
# load_map public function

# import python_ta
# python_ta.check_all(config={
# ‘extra-imports’: [‘settings’, ‘stack’, ‘actor’, ‘pygame’]
# })

Leave a Reply

Your email address will not be published. Required fields are marked *