编程宝库 - 技术改变世界

编程宝库

Search

Python编程技术

剖析Python CSV文件的读取与写入

python扩展库numpy教程

Python还原超级玛丽游戏的代码

导语🎁

哈喽！哈喽！我是木木子😎，今日游戏更新――超级玛丽华丽上线🎊啦！

“超级玛丽”有多少人还记得这款经典游戏？对于90、00后应该不大熟悉，但多多少少印象中见过

那个戴帽子的大胡子穿着背带裤的马里奥🤣！

🎞这款游戏1985年发售，因上手简单、情节有趣等因素迅速走红！

陪伴70后、80后走过了青涩难忘的童年超级玛丽成了大家心目中的经典！

如果你的童年也曾被魔性的灯~灯灯~灯~灯灯~灯洗脑那就接着来怀旧一番吧~

今天木木子就带着大家自制一款超级玛丽游戏，还原度超高哦~还在等什么动动手就能拥有属于自

己的”超级玛丽“游戏呢，赶快学起来吧👩🏻‍🤝‍👩🏻~

正文🎁

嗯呐~写游戏Python还是用的Pygame模块啦

1）准备中🛒

1.1环境安装🎑

Python3、Pycharm、Pygame模块很多自带的模块等。

模块安装统一用的豆瓣镜像源：

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

1.2图片素材+背景音乐+字体（可修改）🎑

2）开始敲代码🛒

2.1 运行程序：mario_level_1.py。🎑

#!/usr/bin/env python
__author__ = '超级玛丽-源码基地'

"""
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()

2.2 配置音乐文字等setup.py。🎑

__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"))

2.3游戏音乐设置game_sound.py。🎑

__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()

2.4取得的分数🎑

__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)