【Python游戏】Python各大游戏合集：超级玛丽、天天酷跑、我的世界、魔塔、雷霆战机 | 附带源码
相关文件
关注小编，私信小编领取哟！
当然别忘了一件三连哟~~
公众号：Python日志
可以关注小编公众号，会不定时的发布一下Python小技巧，还有很多资源可以免费领取哟！！
源码领取：加Python学习交流群：773162165 可以领取哟
开发工具
Python版本：3.7.8
相关模块：
pytorch模块；
pyqt5模块；
numpy模块；
pyttsx3模块；
以及一些python自带的模块。
环境搭建
安装Python并添加到环境变量，pip安装需要的相关模块即可。
一：超级玛丽
效果展示
部分源码
class Box(pg.sprite.Sprite):
def __init__(self, x, y, type, group=None, name=c.MAP_BOX):
pg.sprite.Sprite.__init__(self)
self.frames = []
self.frame_index = 0
self.load_frames()
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.rest_height = y
self.animation_timer = 0
self.first_half = True # First half of animation cycle
self.state = c.RESTING
self.y_vel = 0
self.gravity = 1.2
self.type = type
self.group = group
self.name = name
def load_frames(self):
sheet = setup.GFX['tile_set']
frame_rect_list = [(384, 0, 16, 16), (400, 0, 16, 16),
(416, 0, 16, 16), (400, 0, 16, 16), (432, 0, 16, 16)]
for frame_rect in frame_rect_list:
self.frames.append(tools.get_image(sheet, *frame_rect,
c.BLACK, c.BRICK_SIZE_MULTIPLIER))
def update(self, game_info):
self.current_time = game_info[c.CURRENT_TIME]
if self.state == c.RESTING:
self.resting()
elif self.state == c.BUMPED:
self.bumped()
def resting(self):
time_list = [375, 125, 125, 125]
if (self.current_time - self.animation_timer) > time_list[self.frame_index]:
self.frame_index += 1
if self.frame_index == 4:
self.frame_index = 0
self.animation_timer = self.current_time
self.image = self.frames[self.frame_index]
def bumped(self):
self.rect.y += self.y_vel
self.y_vel += self.gravity
if self.rect.y > self.rest_height + 5:
self.rect.y = self.rest_height
self.state = c.OPENED
if self.type == c.TYPE_MUSHROOM:
self.group.add(powerup.Mushroom(self.rect.centerx, self.rect.y))
elif self.type == c.TYPE_FIREFLOWER:
self.group.add(powerup.FireFlower(self.rect.centerx, self.rect.y))
elif self.type == c.TYPE_LIFEMUSHROOM:
self.group.add(powerup.LifeMushroom(self.rect.centerx, self.rect.y))
self.frame_index = 4
self.image = self.frames[self.frame_index]
def start_bump(self, score_group):
self.y_vel = -6
self.state = c.BUMPED
if self.type == c.TYPE_COIN:
self.group.add(coin.Coin(self.rect.centerx, self.rect.y, score_group))
class Coin(pg.sprite.Sprite):
def __init__(self, x, y, score_group):
pg.sprite.Sprite.__init__(self)
self.frames = []
self.frame_index = 0
self.load_frames()
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.centerx = x
self.rect.bottom = y - 5
self.gravity = 1
self.y_vel = -15
self.animation_timer = 0
self.initial_height = self.rect.bottom - 5
self.score_group = score_group
def load_frames(self):
sheet = setup.GFX[c.ITEM_SHEET]
frame_rect_list = [(52, 113, 8, 14), (4, 113, 8, 14),
(20, 113, 8, 14), (36, 113, 8, 14)]
for frame_rect in frame_rect_list:
self.frames.append(tools.get_image(sheet, *frame_rect,
c.BLACK, c.BRICK_SIZE_MULTIPLIER))
def update(self, game_info):
self.current_time = game_info[c.CURRENT_TIME]
self.spinning()
def spinning(self):
self.image = self.frames[self.frame_index]
self.rect.y += self.y_vel
self.y_vel += self.gravity
if (self.current_time - self.animation_timer) > 80:
if self.frame_index < 3:
self.frame_index += 1
else:
self.frame_index = 0
self.animation_timer = self.current_time
if self.rect.bottom > self.initial_height:
self.kill()
class FlashCoin(pg.sprite.Sprite):
def __init__(self, x, y):
pg.sprite.Sprite.__init__(self)
self.frame_index = 0
self.frames = []
self.load_frames()
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.animation_timer = 0
def load_frames(self):
sheet = setup.GFX[c.ITEM_SHEET]
frame_rect_list = [(1, 160, 5, 8), (9, 160, 5, 8),
(17, 160, 5, 8), (9, 160, 5, 8)]
for frame_rect in frame_rect_list:
self.frames.append(tools.get_image(sheet, *frame_rect,
c.BLACK, c.BRICK_SIZE_MULTIPLIER))
def update(self, current_time):
time_list = [375, 125, 125, 125]
if self.animation_timer == 0:
self.animation_timer = current_time
elif (current_time - self.animation_timer) > time_list[self.frame_index]:
self.frame_index += 1
if self.frame_index == 4:
self.frame_index = 0
self.animation_timer = current_time
self.image = self.frames[self.frame_index]
class StaticCoin(pg.sprite.Sprite):
def __init__(self, x, y):
pg.sprite.Sprite.__init__(self)
self.frame_index = 0
self.frames = []
self.load_frames()
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.animation_timer = 0
def load_frames(self):
sheet = setup.GFX[c.ITEM_SHEET]
frame_rect_list = [(3, 98, 9, 13), (19, 98, 9, 13),
(35, 98, 9, 13), (51, 98, 9, 13)]
for frame_rect in frame_rect_list:
self.frames.append(tools.get_image(sheet, *frame_rect,
c.BLACK, c.BRICK_SIZE_MULTIPLIER))
def update(self, game_info):
self.current_time = game_info[c.CURRENT_TIME]
time_list = [375, 125, 125, 125]
if self.animation_timer == 0:
self.animation_timer = self.current_time
elif (self.current_time - self.animation_timer) > time_list[self.frame_index]:
self.frame_index += 1
if self.frame_index == 4:
self.frame_index = 0
self.animation_timer = self.current_time
self.image = self.frames[self.frame_index]
二：天天酷跑
效果展示
部分源码
class Role: #人物
def __init__(self,surface=None,y=None):
self.surface=surface
self.y=y
self.w=(surface.get_width())/12
self.h=surface.get_height()/2
self.currentFrame=-1
self.state=0 #0代表跑步状态，1代表跳跃状态,2代表连续跳跃
self.g=1 #重力加速度
self.vy=0 #y轴速度
self.vy_start=-20 #起跳开始速度
def getRect(self):
return (0,self.y+12,self.w,self.h)
class Object: #障碍物
def __init__(self,surface,x=0,y=0):
self.surface=surface
self.x=x
self.y=y
self.w=surface.get_width()
self.h=surface.get_height()
self.currentFrame=random.randint(0,6)
self.w = 100
self.h = 100
def getRect(self):
return (self.x,self.y,self.w,self.h)
def collision(self,rect1,rect2):
#碰撞检测
if (rect2[0]>=rect1[2]-20) or (rect1[0]+40>=rect2[2])or (rect1[1]+rect1[3]<rect2[1]+20) or (rect2[1]+rect2[3]<rect1[1]+20):
return False
return True
class Bg: #背景
def __init__(self,surface):
self.surface=surface
self.dx=-10
self.w=surface.get_width()
self.rect=surface.get_rect()
def initGame():
global bg,role,clock,gameState,surObject,surGameOver,score,myFont,myFont1,objectList
#分数初始化
score=0
#初始化
objectList=[]
#加载字体
myFont=pygame.font.Font("./freesansbold.ttf",32)
myFont1=pygame.font.Font("./freesansbold.ttf",64)
# 创建时钟对象 (可以控制游戏循环频率)
clock = pygame.time.Clock()
#初始化游戏状态
gameState=0
#游戏背景
surBg=pygame.image.load("image/bg.bmp").convert_alpha()
bg=Bg(surBg)
#结束画面
surGameOver=pygame.image.load("image/gameover.bmp").convert_alpha()
#人物图片
surRole=pygame.image.load("image/role.png").convert_alpha()
role=Role(surRole,508-85)
#障碍物图片
surObject=pygame.image.load("image/object.png").convert_alpha()
def addObject():
global surObject,object,objectList,object
rate=4
#是否生成障碍物
if not random.randint(0,300)<rate:
return
y=random.choice([height-100,height-200,height-300,height-400])
object=Object(surObject,width+40,y)
objectList.append(object)
def updateLogic():
global gameState,score
#键盘事件处理
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type==pygame.KEYDOWN:
#空格键跳跃
if gameState==0:
if event.key==pygame.K_SPACE:
if role.state==0:
role.state=1
role.vy=role.vy_start
elif role.state==1:
role.state=2
role.vy=role.vy_start
elif gameState==1:
if event.key==pygame.K_SPACE:
#重新开始游戏
initGame()
if gameState==0:
#背景的移动
bg.dx+=10
if bg.dx==1200:
bg.dx=0
#人物的移动
if role.state==0:
role.currentFrame+=1
if role.currentFrame==12:
role.currentFrame=0
else:
role.y+=role.vy
role.vy+=role.g
if role.y>=508-85:
role.y=508-85
role.state=0
#障碍物的移动
addObject()
for object in objectList:
object.x-=10 #障碍物移动
# 障碍物超出屏幕，移除障碍物
if object.x+object.w<=0:
objectList.remove(object)
score+=10 #避开障碍物，加10分
print("移除了一个目标")
#碰撞检测
if object.collision(role.getRect(),object.getRect()):
if(object.currentFrame==6):
objectList.remove(object)
score+=100 #吃金币加100分
print(score)
print("吃了一个金币")
else:
gameState=1 #游戏失败
print("发生了碰撞！")
三：我的世界
效果展示
部分代码展示
class Model(object):
def __init__(self):
# A Batch is a collection of vertex lists for batched rendering.
self.batch = pyglet.graphics.Batch()
# A TextureGroup manages an OpenGL texture.
self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture())
# A mapping from position to the texture of the block at that position.
# This defines all the blocks that are currently in the world.
self.world = {}
# Same mapping as `world` but only contains blocks that are shown.
self.shown = {}
# Mapping from position to a pyglet `VertextList` for all shown blocks.
self._shown = {}
# Mapping from sector to a list of positions inside that sector.
self.sectors = {}
# Simple function queue implementation. The queue is populated with
# _show_block() and _hide_block() calls
self.queue = deque()
self._initialize()
def _initialize(self):
""" Initialize the world by placing all the blocks.
"""
n = 80 # 1/2 width and height of world
s = 1 # step size
y = 0 # initial y height
for x in xrange(-n, n + 1, s):
for z in xrange(-n, n + 1, s):
# create a layer stone an grass everywhere.
self.add_block((x, y - 2, z), GRASS, immediate=False)
self.add_block((x, y - 3, z), STONE, immediate=False)
if x in (-n, n) or z in (-n, n):
# create outer walls.
for dy in xrange(-2, 3):
self.add_block((x, y + dy, z), STONE, immediate=False)
# generate the hills randomly
o = n - 10
for _ in xrange(120):
a = random.randint(-o, o) # x position of the hill
b = random.randint(-o, o) # z position of the hill
c = -1 # base of the hill
h = random.randint(1, 6) # height of the hill
s = random.randint(4, 8) # 2 * s is the side length of the hill
d = 1 # how quickly to taper off the hills
t = random.choice([GRASS, SAND, BRICK])
for y in xrange(c, c + h):
for x in xrange(a - s, a + s + 1):
for z in xrange(b - s, b + s + 1):
if (x - a) ** 2 + (z - b) ** 2 > (s + 1) ** 2:
continue
if (x - 0) ** 2 + (z - 0) ** 2 < 5 ** 2:
continue
self.add_block((x, y, z), t, immediate=False)
s -= d # decrement side length so hills taper off
def hit_test(self, position, vector, max_distance=8):
""" Line of sight search from current position. If a block is
intersected it is returned, along with the block previously in the line
of sight. If no block is found, return None, None.
Parameters
----------
position : tuple of len 3
The (x, y, z) position to check visibility from.
vector : tuple of len 3
The line of sight vector.
max_distance : int
How many blocks away to search for a hit.
"""
m = 8
x, y, z = position
dx, dy, dz = vector
previous = None
for _ in xrange(max_distance * m):
key = normalize((x, y, z))
if key != previous and key in self.world:
return key, previous
previous = key
x, y, z = x + dx / m, y + dy / m, z + dz / m
return None, None
def exposed(self, position):
""" Returns False is given `position` is surrounded on all 6 sides by
blocks, True otherwise.
"""
x, y, z = position
for dx, dy, dz in FACES:
if (x + dx, y + dy, z + dz) not in self.world:
return True
return False
def add_block(self, position, texture, immediate=True):
""" Add a block with the given `texture` and `position` to the world.
Parameters
----------
position : tuple of len 3
The (x, y, z) position of the block to add.
texture : list of len 3
The coordinates of the texture squares. Use `tex_coords()` to
generate.
immediate : bool
Whether or not to draw the block immediately.
"""
if position in self.world:
self.remove_block(position, immediate)
self.world[position] = texture
self.sectors.setdefault(sectorize(position), []).append(position)
if immediate:
if self.exposed(position):
self.show_block(position)
self.check_neighbors(position)
def remove_block(self, position, immediate=True):
""" Remove the block at the given `position`.
Parameters
----------
position : tuple of len 3
The (x, y, z) position of the block to remove.
immediate : bool
Whether or not to immediately remove block from canvas.
"""
del self.world[position]
self.sectors[sectorize(position)].remove(position)
if immediate:
if position in self.shown:
self.hide_block(position)
self.check_neighbors(position)
四：魔塔游戏
效果展示
部分代码展示
ef init_actions():
# QUIT:
def quit(e):
global running
running = False
return True
# 注册事件
action_control.register_action('QUIT', pygame.QUIT, quit)
action_control.register_action('BOOK', pygame.KEYUP, global_var.get_value('BOOK').action)
action_control.register_action('STARTMENU', pygame.KEYUP, global_var.get_value('STARTMENU').action)
action_control.register_action('BACKPACK', pygame.KEYUP, global_var.get_value('BACKPACK').action)
action_control.register_action('SAVE', pygame.KEYUP, global_var.get_value('SAVE').action)
action_control.register_action('LOAD', pygame.KEYUP, global_var.get_value('LOAD').action)
action_control.register_action('FLY', pygame.KEYUP, global_var.get_value('FLY').action)
action_control.register_action('HELP', pygame.KEYUP, global_var.get_value('HELP').action)
action_control.register_action('Shop1', pygame.KEYUP, global_var.get_value('Shop1').action)
action_control.register_action('Shop2', pygame.KEYUP, global_var.get_value('Shop2').action)
action_control.register_action('TEXTBOX', pygame.KEYUP, global_var.get_value('TEXTBOX').action)
action_control.register_action('CHOICEBOX', pygame.KEYUP, global_var.get_value('CHOICEBOX').action)
action_control.register_action('SHOWDAMAGE', pygame.KEYUP, global_var.get_value('SHOWDAMAGE').action)
action_control.register_action('STATUSBAR', pygame.KEYUP, global_var.get_value('STATUSBAR').action)
action_control.register_action('CURTAIN', pygame.KEYUP, global_var.get_value('CURTAIN').action)
WriteLog.info(__name__, "事件全部注册完成")
def init_sound():
Music = music.MusicWrapper()
global_var.set_value("Music", Music)
WriteLog.info(__name__, "初始化音效完成")
def init_event_flow():
EVENTFLOW = EventFlow()
global_var.set_value("EVENTFLOW", EVENTFLOW)
EVENT = Event()
global_var.set_value("EVENT", EVENT)
EVENT.get_event_flow_module()
EVENTFLOW.get_event_module()
WriteLog.info(__name__, "初始化事件流完成")
def init_function():
FUNCTION = global_var.get_value("FUNCTION")
FUNCTION.init_var()
WriteLog.info(__name__, "初始化function完成")
# DEBUG（开关在sysconf.py，如果开启将会启动控制台）
if DEBUG:
import threading
def console():
while running:
r = input()
try:
print(eval(r))
except:
try:
exec(r)
except Exception as e:
print("error:", str(e))
t = threading.Thread(target=console)
t.start()
init()
init_actions()
init_sound()
init_event_flow()
init_function()
clock = pygame.time.Clock()
STARTMENU = global_var.get_value("STARTMENU")
# 主程序
while running:
# a = pygame.time.get_ticks()
# 展示开始菜单
if STARTMENU.new_game == True:
STARTMENU.open()
STARTMENU.new_game = False
# 默认开启显伤
show_damage = global_var.get_value("SHOWDAMAGE")
show_damage.open()
# 默认开启状态栏
status_bar = global_var.get_value("STATUSBAR")
status_bar.open()
# 地图确保为active状态
CurrentMap.active = True
# 载入初始事件
EVENTFLOW = global_var.get_value("EVENTFLOW")
with open(os.path.join(os.getcwd(),"project", "start_text.json")) as f:
start_text = json.load(f)
EVENTFLOW.insert_action(start_text["startText"])
pygame.display.update()
# 背景
RootScreen.flush(screen) # 显示刷新到屏幕
action_control.action_render() # 检查动作消息
# b = pygame.time.get_ticks()
# print(b - a)
五：雷霆战机
效果展示
部分代码展示
class Menu(object):
"""每个页面的父类"""
def __init__(self, image, music):
#设置背景音乐
pygame.mixer.music.load(music)
pygame.mixer.music.set_volume(0.4)
pygame.mixer.music.play(-1)
#设置屏幕大小
self.screen = pygame.display.set_mode(SCREEN_RECT.size)
#设置标题
pygame.display.set_caption("雷霆战机 公众号：Python日志 学习交流群：685237705")
#加载传入的图片并获取位置大小
self.image = pygame.image.load(image)
self.rect = self.image.get_rect()
def event(self):
#遍历所有事件
for event in pygame.event.get():
#点击游戏右上角的×关闭游戏
if event.type == pygame.QUIT:
pygame.quit()
exit()
#按下Esc键关闭游戏
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.quit()
exit()
#获取鼠标是否点击和位置
self.mouse_press = pygame.mouse.get_pressed()
self.mouse_pos = pygame.mouse.get_pos()
@staticmethod
def clicks():
#点击按钮时播放声音
pygame.mixer.music.load("./music/mouse.mp3")
#设置声音大小
pygame.mixer.music.set_volume(0.5)
#0为不循环播放，start为从音频的什么时候开始。
pygame.mixer.music.play(loops=0, start=0.5)
#500毫秒的时间慢慢退出
pygame.mixer.music.fadeout(500)
class MainMenu(Menu):
"""游戏主菜单"""
def __init__(self):
#加载背景音乐和图片
music = "./music/menu1.mp3"
image = "./images/background2.png"
super().__init__(image, music)
def update_menu(self):
while True:
#调用父类的事件方法
super().event()
#加载按钮并获取位置
start = pygame.image.load("./images/start1.png")
start_rect = start.get_rect()
rule = pygame.image.load("./images/rule1.png")
rule_rect = rule.get_rect()
# 开始键和查看键位置定位
start_rect.centerx = SCREEN_RECT.centerx
start_rect.y = SCREEN_RECT.height * 0.3
rule_rect.centerx = SCREEN_RECT.centerx
rule_rect.y = SCREEN_RECT.height * 0.45
#判断鼠标的横纵坐标是否在按钮图片范围内
if (start_rect.left < self.mouse_pos[0] < start_rect.right) and (
start_rect.top < self.mouse_pos[1] < start_rect.bottom):
#在图片范围内则更换图片
start = pygame.image.load("./images/start2.png")
#按下鼠标左键，触发父类的私有方法发出鼠标声，并跳转页面
if self.mouse_press[0]:
Menu.clicks()
GameType().update_menu()
if (rule_rect.left < self.mouse_pos[0] < rule_rect.right) and (
rule_rect.top < self.mouse_pos[1] < rule_rect.bottom):
rule = pygame.image.load("./images/rule2.png")
if self.mouse_press[0]:
Menu.clicks()
RuleMenu().update_menu()
#更新背景、开始按钮、规则按钮
self.screen.blit(self.image, self.rect)
self.screen.blit(start, start_rect)
self.screen.blit(rule, rule_rect)
pygame.display.update()
class GameType(Menu):
"""游戏模式选择"""
def __init__(self):
music = "./music/type1.mp3"
image = "./images/background4.png"
super().__init__(image, music)
def update_menu(self):
while True:
super().event()
type1 = pygame.image.load("./images/first1.png")
type1_rect = type1.get_rect()
type2 = pygame.image.load("./images/second1.png")
type2_rect = type2.get_rect()
type3 = pygame.image.load("./images/third1.png")
type3_rect = type3.get_rect()
return_picture = pygame.image.load("./images/return5.png")
return_rect = return_picture.get_rect()
type1_rect.centerx = SCREEN_RECT.centerx
type1_rect.y = SCREEN_RECT.height * 0.15
type2_rect.centerx = type1_rect.centerx
type2_rect.y = SCREEN_RECT.height * 0.3
type3_rect.centerx = SCREEN_RECT.centerx
type3_rect.y = SCREEN_RECT.height * 0.45
return_rect.x = 10
return_rect.y = 10
#调用自己的静态私有方法获取记录
record1 = self.__record(str(1))
record2 = self.__record(str(2))
# 开始模式一
if (type1_rect.left < self.mouse_pos[0] < type1_rect.right) and (
type1_rect.top < self.mouse_pos[1] < type1_rect.bottom):
type1 = pygame.image.load("./images/first2.png")
if self.mouse_press[0]:
Menu.clicks()
plane_main_1.Game().start_game()
#开始模式二
if (type2_rect.left < self.mouse_pos[0] < type2_rect.right) and (
type2_rect.top < self.mouse_pos[1] < type2_rect.bottom):
type2 = pygame.image.load("./images/second2.png")
if self.mouse_press[0]:
Menu.clicks()
#用获取的记录判断能否开启游戏关卡
if 0 <= int(record1) <= 3:
plane_main_2.Game().start_game()
else:
#不可以则调用禁止类的，显示禁止页面
ProhibitMenu().update_menu()
#开始模式三
if (type3_rect.left < self.mouse_pos[0] < type3_rect.right) and (
type3_rect.top < self.mouse_pos[1] < type3_rect.bottom):
type3 = pygame.image.load("./images/third2.png")
if self.mouse_press[0]:
Menu.clicks()
if 0 <= int(record2) <= 3:
plane_main_3.Game().start_game()
else:
ProhibitMenu().update_menu()
if return_rect.left < self.mouse_pos[0] < return_rect.right and (
return_rect.top < self.mouse_pos[1] < return_rect.bottom):
return_picture = pygame.image.load("./images/return6.png")
if self.mouse_press[0]:
Menu.clicks()
MainMenu().update_menu()
self.screen.blit(self.image, self.rect)
self.screen.blit(type1, type1_rect)
self.screen.blit(type2, type2_rect)
self.screen.blit(type3, type3_rect)
self.screen.blit(return_picture, return_rect)
pygame.display.update()