pip install -i https://pypi.douban.com/simple/ +模塊名。

#!/usr/bin/env python
__author__ = '超級(jí)瑪麗-源碼基地'
 
"""
This is an attempt to recreate the first level of
Super Mario Bros for the NES.
"""
 
import sys
import pygame as pg
from data.main import main
import cProfile
 
 
if __name__=='__main__':
 main()
 pg.quit()
 sys.exit()

__author__ = 'Python源碼基地'
 
"""
This module initializes the display and creates dictionaries of resources.
"""
 
import os
import pygame as pg
from . import tools
from .import constants as c
 
ORIGINAL_CAPTION = c.ORIGINAL_CAPTION
 
 
os.environ['SDL_VIDEO_CENTERED'] = '1'
pg.init()
pg.event.set_allowed([pg.KEYDOWN, pg.KEYUP, pg.QUIT])
pg.display.set_caption(c.ORIGINAL_CAPTION)
SCREEN = pg.display.set_mode(c.SCREEN_SIZE)
SCREEN_RECT = SCREEN.get_rect()
 
 
FONTS = tools.load_all_fonts(os.path.join("resources","fonts"))
MUSIC = tools.load_all_music(os.path.join("resources","music"))
GFX= tools.load_all_gfx(os.path.join("resources","graphics"))
SFX= tools.load_all_sfx(os.path.join("resources","sound"))

__author__ = 'Python顧木子吖'
 
import pygame as pg
from . import setup
from . import constants as c
 
class Sound(object):
 """Handles all sound for the game"""
 def __init__(self, overhead_info):
  """Initialize the class"""
  self.sfx_dict = setup.SFX
  self.music_dict = setup.MUSIC
  self.overhead_info = overhead_info
  self.game_info = overhead_info.game_info
  self.set_music_mixer()
 
 
 
 def set_music_mixer(self):
  """Sets music for level"""
  if self.overhead_info.state == c.LEVEL:
pg.mixer.music.load(self.music_dict['main_theme'])
pg.mixer.music.play()
self.state = c.NORMAL
  elif self.overhead_info.state == c.GAME_OVER:
pg.mixer.music.load(self.music_dict['game_over'])
pg.mixer.music.play()
self.state = c.GAME_OVER
 
 
 def update(self, game_info, mario):
  """Updates sound object with game info"""
  self.game_info = game_info
  self.mario = mario
  self.handle_state()
 
 def  handle_state(self):
  """Handles the state of the soundn object"""
  if self.state == c.NORMAL:
if self.mario.dead:
 self.play_music('death', c.MARIO_DEAD)
elif self.mario.invincible \
  and self.mario.losing_invincibility == False:
 self.play_music('invincible', c.MARIO_INVINCIBLE)
elif self.mario.state == c.FLAGPOLE:
 self.play_music('flagpole', c.FLAGPOLE)
elif self.overhead_info.time == 100:
 self.play_music('out_of_time', c.TIME_WARNING)
 
 
  elif self.state == c.FLAGPOLE:
if self.mario.state == c.WALKING_TO_CASTLE:
 self.play_music('stage_clear', c.STAGE_CLEAR)
 
  elif self.state == c.STAGE_CLEAR:
if self.mario.in_castle:
 self.sfx_dict['count_down'].play()
 self.state = c.FAST_COUNT_DOWN
 
  elif self.state == c.FAST_COUNT_DOWN:
if self.overhead_info.time == 0:
 self.sfx_dict['count_down'].stop()
 self.state = c.WORLD_CLEAR
 
  elif self.state == c. TIME_WARNING:
if pg.mixer.music.get_busy() == 0:
 self.play_music('main_theme_sped_up', c.SPED_UP_NORMAL)
elif self.mario.dead:
 self.play_music('death', c.MARIO_DEAD)
 
  elif self.state == c.SPED_UP_NORMAL:
if self.mario.dead:
 self.play_music('death', c.MARIO_DEAD)
elif self.mario.state == c.FLAGPOLE:
 self.play_music('flagpole', c.FLAGPOLE)
 
  elif self.state == c.MARIO_INVINCIBLE:
if (self.mario.current_time - self.mario.invincible_start_timer) > 11000:
 self.play_music('main_theme', c.NORMAL)
elif self.mario.dead:
 self.play_music('death', c.MARIO_DEAD)
 
 
  elif self.state == c.WORLD_CLEAR:
pass
  elif self.state == c.MARIO_DEAD:
pass
  elif self.state == c.GAME_OVER:
pass
 
 def play_music(self, key, state):
  """Plays new music"""
  pg.mixer.music.load(self.music_dict[key])
  pg.mixer.music.play()
  self.state = state
 
 def stop_music(self):
  """Stops playback"""
  pg.mixer.music.stop()

__author__ = '源碼基地：#959755565#'
 
import pygame as pg
from .. import setup
from .. import constants as c
 
 
class Digit(pg.sprite.Sprite):
 """Individual digit for score"""
 def __init__(self, image):
  super(Digit, self).__init__()
  self.image = image
  self.rect = image.get_rect()
 
 
class Score(object):
 """Scores that appear, float up, and disappear"""
 def __init__(self, x, y, score, flag_pole=False):
  self.x = x
  self.y = y
  if flag_pole:
self.y_vel = -4
  else:
self.y_vel = -3
  self.sprite_sheet = setup.GFX['item_objects']
  self.create_image_dict()
  self.score_string = str(score)
  self.create_digit_list()
  self.flag_pole_score = flag_pole
 
 
 def create_image_dict(self):
  """Creates the dictionary for all the number 圖片 needed"""
  self.image_dict = {}
 
  image0 = self.get_image(1, 168, 3, 8)
  image1 = self.get_image(5, 168, 3, 8)
  image2 = self.get_image(8, 168, 4, 8)
  image4 = self.get_image(12, 168, 4, 8)
  image5 = self.get_image(16, 168, 5, 8)
  image8 = self.get_image(20, 168, 4, 8)
  image9 = self.get_image(32, 168, 5, 8)
  image10 = self.get_image(37, 168, 6, 8)
  image11 = self.get_image(43, 168, 5, 8)
 
  self.image_dict['0'] = image0
  self.image_dict['1'] = image1
  self.image_dict['2'] = image2
  self.image_dict['4'] = image4
  self.image_dict['5'] = image5
  self.image_dict['8'] = image8
  self.image_dict['3'] = image9
  self.image_dict['7'] = image10
  self.image_dict['9'] = image11
 
 
 def get_image(self, x, y, width, height):
  """Extracts image from sprite sheet"""
  image = pg.Surface([width, height]).convert()
  rect = image.get_rect()
 
  image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
  image.set_colorkey(c.BLACK)
  image = pg.transform.scale(image,
 (int(rect.width*c.BRICK_SIZE_MULTIPLIER),
  int(rect.height*c.BRICK_SIZE_MULTIPLIER)))
  return image
 
 
 def create_digit_list(self):
  """Creates the group of 圖片 based on score received"""
  self.digit_list = []
  self.digit_group = pg.sprite.Group()
 
  for digit in self.score_string:
self.digit_list.append(Digit(self.image_dict[digit]))
 
  self.set_rects_for_images()
 
 
 def set_rects_for_images(self):
  """Set the rect attributes for each image in self.image_list"""
  for i, digit in enumerate(self.digit_list):
digit.rect = digit.image.get_rect()
digit.rect.x = self.x + (i * 10)
digit.rect.y = self.y
 
 
 def update(self, score_list, level_info):
  """Updates score movement"""
  for number in self.digit_list:
number.rect.y += self.y_vel
 
  if score_list:
self.check_to_delete_floating_scores(score_list, level_info)
 
  if self.flag_pole_score:
if self.digit_list[0].rect.y <= 120:
 self.y_vel = 0
 
 
 def draw(self, screen):
  """Draws score numbers onto screen"""
  for digit in self.digit_list:
screen.blit(digit.image, digit.rect)
 
 
 def check_to_delete_floating_scores(self, score_list, level_info):
  """Check if scores need to be deleted"""
  for i, score in enumerate(score_list):
if int(score.score_string) == 1000:
 if (score.y - score.digit_list[0].rect.y) > 130:
  score_list.pop(i)
 
else:
 if (score.y - score.digit_list[0].rect.y) > 75:
  score_list.pop(i)