用python写一个魂斗罗

已于 2022-11-16 16:10:10 修改
阅读量2.9k 收藏 24
点赞数 6
分类专栏： Python 文章标签： pygame 游戏 python
于 2021-02-22 11:59:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44619675/article/details/113933439
版权

嗨！多一嘴： 童年玩过的经典游戏中，魂斗罗当属经典啊，最近用python写出来，赶一波回忆杀哈哈哈哈哈哈哈~

tips: 600多行代码，耐心耐心耐心！（ 偷看*-|||

1、代码实现

(1)子弹类（bullet.py）

import pygame
from pygame.sprite import Sprite 

class Bullet(Sprite):

	def __init__(self,game_settings,screen,player):
		super().__init__()
		self.game_settings = game_settings
		self.player = player
		self.screen = screen
		self.image = pygame.image.load('图片/bullet1.png')
		self.rect = self.image.get_rect()
		self.rect.left = player.rect.right-20#开始子弹默认往右射击
		if self.player.player_direction == -1:
			self.rect.right = player.rect.left+20
		self.rect.centery = player.rect.centery-15
		if self.player.player_down:
			self.rect.centery = player.rect.centery#调整子弹位置
		if self.player.player_up:
			self.rect.bottom = player.rect.top+20
		self.x = float(self.rect.x)
		self.y = float(self.rect.y)
		self.mx = self.x#mx为保存初始x的坐标
		self.my = self.y
		self.speed_factor = game_settings.bullet_speed_factor

	def update(self):
		if self.y<self.my or self.y == self.my and self.x == self.mx and self.player.player_up:
			self.y -= self.speed_factor
			self.rect.y = self.y
		elif self.x < self.mx or self.x == self.mx and self.player.player_direction == -1:
			self.x -= self.speed_factor
			self.rect.x = self.x
		elif self.x>self.mx or self.x == self.mx:#默认为右方向
			self.x += self.speed_factor
			self.rect.x = self.x

	def blit_bullet(self):
	
		self.screen.blit(self.image,self.rect)

(2)敌人类(enemy.py)

import pygame
from pygame.sprite import Sprite

class Enemy(Sprite):
	def __init__(self,game_settings,screen):
		super().__init__()
		self.pos_j = 0.0
		self.pos_i = 0.0

		self.game_settings = game_settings
		self.screen = screen
		self.image = pygame.image.load('图片/enemy/EL/bag1.png')
		#self.image = pygame.image.load('图片/enemy/EL/bz1.png')
		self.rect = self.image.get_rect()
		self.rect.x = self.game_settings.screen_width+self.rect.width*2
		self.rect.bottom = 367
		self.x = float(self.rect.x)#敌人的位置
		self.speed_factor = self.game_settings.enemy_speed_factor

	def blitme(self):
		self.screen.blit(self.image,self.rect)

	def update(self):
		if self.game_settings.enemy_is_alive:
			if self.game_settings.screen_rolling:
				self.x -= self.speed_factor+1 #屏幕滚动速度减去敌人移动速度
				self.rect.x = self.x
			self.x -= self.speed_factor
			self.rect.x = self.x
			self.update_run_direction('EL')
		else:
			if self.game_settings.screen_rolling:
				self.x -= self.speed_factor+1 #屏幕滚动速度减去敌人移动速度
				self.rect.x = self.x
			self.boom()
		
	def boom(self):
		self.names1 = locals()
		self.players1 = []
		for self.j in range(1,3):
			self.names1['player_image%s' %self.j] = pygame.image.load('图片/enemy/boom%s.png' %self.j)
			self.players1.append(self.names1['player_image%s' %self.j])
		self.image = self.players1[int(self.pos_i)]
		self.pos_i += 0.1
		if self.pos_i > 2.0:
			self.game_settings.boom_end = True
			
	def update_run_direction(self,direction):#循环图片
		self.names1 = locals()
		self.players1 = []
		for self.j in range(1,5):
			self.names1['player_image%s' %self.j] = pygame.image.load('图片/enemy/'+direction+'/bag%s.png' %self.j)
			self.players1.append(self.names1['player_image%s' %self.j])
		self.image = self.players1[int(self.pos_j)]
		self.pos_j += 0.1#图片变化速率
		if self.pos_j > 4.0:#敌人bag有4个动作
			self.pos_j = 0.0

(3)按钮类(button.py)

import pygame.font

class Button():

	def __init__(self,game_settings,screen,msg):
		self.screen = screen
		self.screen_rect = self.screen.get_rect()

		self.width,self.height = 300,150
		self.button_color=(0,255,0)
		self.text_color = (255,255,255)
		self.font = pygame.font.SysFont(None,48)

		self.rect = pygame.Rect(0,0,self.width,self.height)
		self.rect.center = self.screen_rect.center

		self.prep_msg(msg)

	def	prep_msg(self,msg):
		self.msg_image = self.font.render(msg,True,self.text_color,self.button_color)
		self.msg_image_rect = self.msg_image.get_rect()
		self.msg_image_rect.center = self.rect.center

	def draw_button(self):
		self.screen.fill(self.button_color,self.rect)
		self.screen.blit(self.msg_image,self.msg_image_rect)

(4)游戏大boss类(game_boss.py)

import pygame
import random
from pygame.sprite import Sprite
import datetime

class Game_Boss(Sprite):
	def __init__(self,game_settings,screen,player):
		super().__init__()
		self.pos_i = 0.0
		self.pos_j = 0.0
		self.pos_k = 0.0
		self.game_settings = game_settings
		self.screen = screen
		self.image = pygame.image.load('图片/boss/left/move/bz1.png')
		self.rect = self.image.get_rect()
		self.rect.x = self.game_settings.screen_width-self.rect.width
		self.rect.bottom = 370
		self.x = float(self.rect.x)#敌人的位置
		self.speed_factor = self.game_settings.enemy_speed_factor
		self.boss_start_Y = 370#开始boss人物的高度
		self.boss_Y = self.boss_start_Y
		self.attack1_order = 0
		self.player = player
		self.mx = self.x

	def blitme(self):
		self.screen.blit(self.image,self.rect)

	def update(self):
		if self.game_settings.boss_alive:
			self.direction()
			self.rand_att()
			if  self.game_settings.attack_1:
				if self.game_settings.boss_direction == 1:
					self.attack_1('left')
				else:
					self.attack_1('right')

			elif self.game_settings.attack_2:
				if self.game_settings.boss_direction == 1:
					self.attack_2('left')
				else:
					self.attack_2('right')

			elif self.game_settings.boss_jump:
				self.jump()

			elif self.game_settings.boss_run:
				if self.game_settings.boss_direction == 1:
					self.run('left')
				else:
					self.run('right')
					
			elif self.player.rect.centerx > self.rect.x:
				self.x += self.speed_factor
				self.rect.x = self.x
				self.move('right')
			elif self.player.rect.centerx < self.rect.x:
				self.x -= self.speed_factor
				self.rect.x = self.x
				self.move('left')
		else:
			self.boom()
			self.game_settings.game_win = True

	def rand_att(self):
		random.seed(datetime.datetime.now())
		if self.game_settings.attack_1 == False and self.game_settings.attack_2 == False and self.game_settings.boss_jump == False and self.game_settings.boss_run == False:
			self.rand_num = random.randint(1,70)
			if self.rand_num == 1:
				self.game_settings.attack_1 = True
			elif self.rand_num == 2:
				self.game_settings.attack_2 = True
			elif self.rand_num == 3:
				self.game_settings.boss_jump =True
			elif self.rand_num == 4:
				self.game_settings.boss_run = True


	def attack_1(self,direction):
		self.rect.bottom = 410#做此动作时人物的位置
		self.names1 = locals()
		self.players1 = []
		for self.j in range(0,34):
			self.names1['player_image%s' %self.j] = pygame.image.load('图片/boss/'+direction+'/attack_1/%s.png' %self.j)
			self.players1.append(self.names1['player_image%s' %self.j])
		self.image = self.players1[int(self.pos_i)]
		self.pos_i += 0.5
		if self.pos_i >= 34.0 :#循环完成后:
			self.pos_i = 0.0
			self.game_settings.attack_1 = False

	def attack_2(self,direction):
		self.rect.bottom = 355
		self.names1 = locals()
		self.players1 = []
		for self.j in range(0,30):
			self.names1['player_image%s' %self.j] = pygame.image.load('图片/boss/'+direction+'/attack_2/%s.png' %self.j)
			self.players1.append(self.names1['player_image%s' %self.j])
		self.image = self.players1[int(self.pos_i)]
		self.pos_i += 0.5
		if self.pos_i >= 30:
			self.pos_i = 0.0
			self.game_settings.attack_2 = False

	def move(self,direction):#循环图片
		self.rect.bottom = 370
		self.names1 = locals()
		self.players1 = []
		for self.j in range(1,7):
			self.names1['player_image%s' %self.j] = pygame.image.load('图片/boss/'+direction+'/move/bz%s.png' %self.j)
			self.players1.append(self.names1['player_image%s' %self.j])
		self.image = self.players1[int(self.pos_i)]
		self.pos_i += 0.1#图片变化速率
		if self.pos_i > 6.0:#敌人bag有4个动作
			self.pos_i = 0.0

	def run(self,direction):
		self.rect.bottom = 400
		self.names1 = locals()
		self.players1 = []
		for self.j in range(0,6):
			self.names1['player_image%s' %self.j] = pygame.image.load('图片/boss/'+direction+'/run/%s.png' %self.j)
			self.players1.append(self.names1['player_image%s' %self.j])
		self.image = self.players1[int(self.pos_i)]
		self.pos_i += 0.3
		if self.pos_i >= 6:
			self.pos_i = 0.0
			self.game_settings.boss_run = False

		if self.player.rect.centerx > self.rect.x :#or self.x < self.mx:
			self.x += 6
			self.rect.x = self.x
		elif self.player.rect.centerx < self.rect.x :#or self.x > self.mx:
			self.x -= 6
			self.rect.x = self.x
			
	def jump(self):			
		self.rect.bottom = self.boss_Y
		if self.game_settings.boss_jump_vel < 0:
			self.game_settings.boss_jump_vel += 0.6#跳跃上升的增加的速率
		elif self.game_settings.boss_jump_vel > 0:
			self.game_settings.boss_jump_vel += 0.8#跳跃下降增加的速率
		self.boss_Y += self.game_settings.boss_jump_vel
		if self.boss_Y > self.boss_start_Y:
			self.game_settings.boss_jump = False#结束跳跃
			self.boss_Y = self.boss_start_Y
			self.game_settings.boss_jump_vel = -12.0#恢复跳跃开始的速度

		if self.player.rect.centerx > self.rect.x :#or self.x < self.mx:
			self.x += self.speed_factor
			self.rect.x = self.x
		elif self.player.rect.centerx < self.rect.x :#or self.x > self.mx:
			self.x -= self.speed_factor
			self.rect.x = self.x

		self.names1 = locals()
		self.players1 = []
		for self.j in range(3,10):
			self.names1['player_image%s' %self.j] = pygame.image.load('图片/boss/left/jump/%s.png' %self.j)
			self.players1.append(self.names1['player_image%s' %self.j])
		self.image = self.players1[int(self.pos_j)]
		self.pos_j += 0.4#跳跃旋转速率
		if self.pos_j >= 7:#跳跃有7个动作
			self.pos_j = 0.0

	def direction(self):
		if self.player.rect.centerx > self.rect.x:
			self.game_settings.boss_direction = -1
		else:
			self.game_settings.boss_direction = 1


	def boom(self):
		self.names1 = locals()
		self.players1 = []
		for self.j in range(1,4):
			self.names1['player_image%s' %self.j] = pygame.image.load('图片/boss/boom%s.png' %self.j)
			self.players1.append(self.names1['player_image%s' %self.j])
		self.image = self.players1[int(self.pos_k)]
		self.pos_k += 0.05
		if self.pos_k >= 3.0:
			#self.game_settings.boom_end = True
			self.game_settings.boss_boom_end = True

(5)方法封装类(game_function.py)

import sys
import pygame
from bullet import Bullet
from enemy import Enemy 
from game_boss import Game_Boss

def check_keydown_events(event,game_settings,screen,player,bullets):
	if event.key == pygame.K_k:#跳跃
		player.player_jump = True

	if event.key == pygame.K_d:#向右
		game_settings.bullet_direction = 'right' 
		if player.player_down or player.player_up:
			player.moving_right = False
		else:
			player.moving_right = True
		player.player_direction = 1	

	if event.key == pygame.K_a:#向左
		game_settings.bullet_direction = 'left'
		if player.player_down or player.player_up:
			player.moving_left = False
		else:
			player.moving_left = True
		player.player_direction = -1

	elif event.key == pygame.K_s:#向下
		player.player_down = True
		player.player_moving = False
		player.moving_left = False
		player.moving_right = False

	elif event.key == pygame.K_w:#向上
		player.player_up = True
		player.player_moving = False
		player.moving_left = False
		player.moving_right = False

	elif event.key == pygame.K_j:#射击
		new_bullet = Bullet(game_settings,screen,player)
		bullets.add(new_bullet)
		player.player_shooting = True

	elif event.key == pygame.K_p:
		sys.exit()

def check_keyup_events(event,player):
	if event.key == pygame.K_d:#右
		player.image = pygame.image.load('图片/PR/player.png')
		player.moving_right = False
		player.player_moving = False
	elif event.key == pygame.K_a:#左
		player.image = pygame.image.load('图片/PL/player.png')
		player.player_moving = False
		player.moving_left = False
	elif event.key == pygame.K_s:#下
		player.player_down = False
		if player.player_direction == 1:
			player.image = pygame.image.load('图片/PR/player.png')
		if player.player_direction == -1:
			player.image = pygame.image.load('图片/PL/player.png')
	elif event.key == pygame.K_w:#上
		player.player_up = False
		if player.player_direction == 1:
			player.image = pygame.image.load('图片/PR/player.png')
		if player.player_direction == -1:
			player.image = pygame.image.load('图片/PL/player.png')
	
def check_events(game_settings,screen,player,bullets):
	for event in pygame.event.get():
		if event.type == pygame.QUIT:
			sys.exit()
		elif event.type == pygame.KEYDOWN:
			player.player_moving = True
			check_keydown_events(event,game_settings,screen,player,bullets)		
		elif event.type == pygame.KEYUP:
			check_keyup_events(event,player)

def update_screen(game_settings,bg,pos_x,screen,player,bullets,enemys,boss,win_button):
	screen.blit(bg,(pos_x,0))
	for bullet in bullets.sprites():
		bullet.blit_bullet()
	"""if game_settings.boom_end:#击中敌人爆炸
		enemys.empty()
		game_settings.boom_end = False"""
	player.blitme()
	if game_settings.boss_appear:
		boss.draw(screen)
	enemys.draw(screen)

	if game_settings.game_win:
		win_button.draw_button()
	pygame.display.flip()

def update_bullet(game_settings,bullets,screen,enemys,boss):
	bullets.update()
	for bullet in bullets.copy():
		if bullet.rect.centerx<0 or bullet.rect.centery<0 or bullet.rect.centerx > game_settings.screen_width:
			bullets.remove(bullet)
	check_bullet_enemy_collisions(game_settings,bullets,screen,enemys)
	check_bullet_boss_collisions(game_settings,bullets,boss)
	

def check_bullet_enemy_collisions(game_settings,bullets,screen,enemys):
	if game_settings.enemy_is_alive:
		collisions = pygame.sprite.groupcollide(bullets,enemys,True,False)
	else:
		collisions = pygame.sprite.groupcollide(bullets,enemys,True,True)
	if collisions != {}:
		game_settings.enemy_is_alive = False
	if len(enemys) == 0:
		create_legion(game_settings,screen,enemys)

def check_bullet_boss_collisions(game_settings,bullets,boss):
	if game_settings.boss_alive:
		collisions = pygame.sprite.groupcollide(boss,bullets,False,True)
	else:
		collisions = pygame.sprite.groupcollide(boss,bullets,True,True)

	if collisions != {}:
		game_settings.boss_lift -= 1
	if game_settings.boss_lift == 0:
		game_settings.boss_alive = False

def create_legion(game_settings,screen,enemys):
	for enemy_number in range(1):
		game_settings.enemy_is_alive = True
		enemy = Enemy(game_settings,screen)
		enemys.add(enemy)

def update_enemys(game_settings,enemys):
	if game_settings.boss_appear == False:#判断boss是否出现，出现则不出现小兵
		enemys.update()

		for enemy in enemys.copy():
			if enemy.rect.centerx<0:
				enemys.remove(enemy)
			if game_settings.boom_end:#击中敌人爆炸
				enemys.remove(enemy)
				game_settings.boom_end = False
				game_settings.boss_appear = True

def update_player(game_settings,stats,player,enemys):
	player.update()
	if pygame.sprite.spritecollideany(player,enemys):
		player_hit(game_settings,stats,player)
	if game_settings.player_die_end == True:
		player.revive_player()
		game_settings.player_die_end = False

def player_hit(game_settings,stats,player):
	stats.players_left -= 1
	game_settings.player_is_alive = False
	
def update_boss(game_settings,boss):
	if game_settings.boss_appear:
		boss.update()
	if game_settings.boss_boom_end:
		boss.empty()

def create_boss(game_settings,screen,player,boss):
	bo = Game_Boss(game_settings,screen,player)
	boss.add(bo)

(6)游戏玩家类(game_player.py)

import pygame

class Game_Player():
	def __init__(self,game_settings,screen):

		self.screen = screen
		self.game_settings = game_settings
		self.image = pygame.image.load('图片/PR/player.png')
		self.rect = self.image.get_rect()
		self.screen_rect = self.screen.get_rect()
		self.screen_center_pos = self.screen_rect.centerx
		self.rect.centerx = self.screen_rect.centerx
		self.rect.bottom = 380
		self.center = float(self.rect.centerx)
		self.moving_right = False
		self.moving_left = False
		self.player_moving = False
		self.pos_i = 0.0#跑步画面改变速度
		self.pos_j = 0.0#跳跃的改变初始速度
		self.pos_n = 0.0#射击
		self.pos_d = 0.0
		self.player_direction = 1#1为右，-1为左
		self.player_down = False
		self.player_up = False
		self.player_jump = False
		self.player_start_Y = 380#开始人物的高度
		self.player_Y = self.player_start_Y
		self.player_shooting = False

	def update(self):
		if self.game_settings.player_is_alive:
			if self.moving_right and self.rect.right < self.screen_rect.right:
				if self.game_settings.boss_appear:
					self.center += self.game_settings.player_speed
				elif self.center > self.screen_center_pos:
					self.center += 0
				else:
					self.center += self.game_settings.player_speed
			if self.moving_left and self.rect.left > 0:
				self.center -= self.game_settings.player_speed
			self.rect.centerx = self.center

			self.update_image_moving()
		else:
			self.update_die()

	def update_die(self):
		self.names = locals()
		self.players = []
		for self.i in range(1,3):
			self.names['player_image%s' %self.i] = pygame.image.load('图片/PR/death%s.png' %self.i)
			self.players.append(self.names['player_image%s' %self.i])
		self.image = self.players[int(self.pos_d)]
		self.pos_d += 0.1
		if self.pos_d > 2.0:
			self.pos_d = 0.0
			self.game_settings.player_die_end = True


	def update_image_moving_direction(self,direction):#循环图片
		if self.player_shooting == True:
			self.names = locals()
			self.players = []
			for self.i in range(1,4):
				self.names['player_image%s' %self.i] = pygame.image.load('图片/'+direction+'/shooting%s.png' %self.i)
				self.players.append(self.names['player_image%s' %self.i])
			self.image = self.players[int(self.pos_n)]
			self.pos_n += 0.1#射击时跑步速率
			if self.pos_n > 3.0:#射击时跑步有3个动作
				self.pos_n = 0.0
		else:
			self.names = locals()
			self.players = []
			for self.i in range(1,6):
				self.names['player_image%s' %self.i] = pygame.image.load('图片/'+direction+'/player%s.png' %self.i)
				self.players.append(self.names['player_image%s' %self.i])
			self.image = self.players[int(self.pos_i)]
			self.pos_i += 0.1#跑步速率
			if self.pos_i > 5.0:#跑步有5个动作
				self.pos_i = 0.0

	def update_image_jump(self,direction):#循环图片
		if self.game_settings.player_is_alive:
			if self.player_jump == True:
				self.names1 = locals()
				self.players1 = []
				for self.j in range(1,5):
					self.names1['player_image%s' %self.j] = pygame.image.load('图片/'+direction+'/jump%s.png' %self.j)
					self.players1.append(self.names1['player_image%s' %self.j])
				self.image = self.players1[int(self.pos_j)]
				self.pos_j += 0.3#跳跃旋转速率
				if self.pos_j > 4.0:#跳跃有4个动作
					self.pos_j = 0.0
		else:
			self.update_die()


	def update_image_moving(self):
		if self.player_moving:
			if self.moving_right:
				self.update_image_moving_direction('PR')#PR是向右的图片
			elif self.moving_left:
				self.update_image_moving_direction('PL')

	def get_player_state(self,player_state):#检测player的状态是否为趴下，向上，跳跃等
		if self.player_direction == 1:
			self.image = pygame.image.load('图片/PR/'+player_state+'.png')
		if self.player_direction == -1:
			self.image = pygame.image.load('图片/PL/'+player_state+'.png')
		self.rect = self.image.get_rect()
		self.rect.centerx = self.center

	def get_player_down(self):
		self.get_player_state('down')
		self.rect.bottom = self.player_start_Y
		self.screen.blit(self.image,self.rect)

	def get_player_up(self):
		self.get_player_state('up')
		self.rect.bottom = self.player_start_Y
		self.screen.blit(self.image,self.rect)

	def get_player_jump(self):
		self.get_player_state('jump1')
		self.rect.bottom = self.player_Y
		if self.game_settings.jump_vel < 0:
			self.game_settings.jump_vel += 0.6#跳跃上升的增加的速率
		elif self.game_settings.jump_vel > 0:
			self.game_settings.jump_vel += 0.8#跳跃下降增加的速率
		self.player_Y += self.game_settings.jump_vel
		if self.player_Y > self.player_start_Y:
			self.player_jump = False
			self.player_Y = self.player_start_Y
			self.game_settings.jump_vel = -14.0#恢复跳跃开始的速度
			if self.player_direction == 1:
				self.image = pygame.image.load('图片/PR/player.png')
				self.reset_player()
			if self.player_direction == -1:
				self.image = pygame.image.load('图片/PL/player.png')
				self.reset_player()
		if self.player_jump == True:#判断是否处于跳跃状态来决定是否旋转跳跃的图像
			if self.player_direction == 1:
				self.update_image_jump('PR')
			if self.player_direction == -1:
				self.update_image_jump('PL')
		self.screen.blit(self.image,self.rect)

	def reset_player(self):
		self.rect = self.image.get_rect()
		self.rect.centerx = self.center
		self.rect.bottom = self.player_start_Y
		self.screen.blit(self.image,self.rect)

	def blitme(self):
		if self.player_jump:
			self.get_player_jump()
		elif self.player_down:
			self.get_player_down()
		elif self.player_up:
			self.get_player_up()
		else:
			self.reset_player()

	def revive_player(self):
		self.center = self.screen_rect.centerx
		self.game_settings.player_is_alive = True

(7)游戏统计类(game_stats.py)

class GameStats():
	def __init__(self,game_settings):
		self.game_settings = game_settings
		self.reset_stats()

	def reset_stats(self):
		self.players_left = self.game_settings.players_limit

(8)设置类(settings.py)

class Settings():
	def __init__(self):
		self.screen_width = 1200
		self.screen_height = 750
		self.player_speed = 5
		self.jump_vel = -14.0#跳跃开始的速度,这里改动，game_player那里也要改动
		self.bullet_speed_factor = 17
		self.enemy_speed_factor = 1#屏幕滚动速度减去敌人移动速度为1（屏幕为5，敌人为4）移动时候才平滑。这里改动，enemy的update那里也要改
		self.screen_rolling = False
		self.enemy_is_alive = True
		self.boom_end = False
		self.players_limit = 3
		self.player_is_alive = True
		self.player_die_end = False
		self.boss_jump_vel = -12.0
		self.attack_1 = False
		self.attack_2 = False
		self.boss_jump = False
		self.boss_run = False
		self.boss_appear = False
		self.boss_direction = 1#1位向左，-1为向右
		self.boss_lift = 15
		self.boss_alive = True
		self.game_win = False
		self.boss_boom_end = False

(9)主程序类（Contra.py）

import pygame
import sys
from pygame.locals import *
from settings import Settings
from game_player import Game_Player 
import game_functions as gf
from pygame.sprite import Group
from game_stats import GameStats
from game_boss import Game_Boss
from button import Button

def run_game():
	bg = pygame.image.load("图片/map01.jpeg")
	game_settings = Settings()
	pos_x = 0#地图移动
	
	pygame.init()
	screen = pygame.display.set_mode(
		(game_settings.screen_width,game_settings.screen_height))
	pygame.display.set_caption("魂斗罗")
	stats = GameStats(game_settings)
	player = Game_Player(game_settings,screen)
	bullets = Group()
	boss = Group()
	enemys = Group()
	win_button = Button(game_settings,screen,"YOU WIN")
	gf.create_legion(game_settings,screen,enemys)
	gf.create_boss(game_settings,screen,player,boss)

	while True:
		pygame.mouse.set_visible(False)
		gf.check_events(game_settings,screen,player,bullets)
		gf.update_player(game_settings,stats,player,enemys)
		gf.update_bullet(game_settings,bullets,screen,enemys,boss)	
		gf.update_enemys(game_settings,enemys)	
		gf.update_boss(game_settings,boss)
		gf.update_screen(game_settings,bg,pos_x,screen,player,bullets,enemys,boss,win_button)
		
		if player.moving_right and player.center > player.screen_rect.centerx and game_settings.boss_appear == False:
			game_settings.screen_rolling = True
			pos_x -= 5#屏幕滚动速度
		else:
			game_settings.screen_rolling = False
run_game()
2、运行结果

在这里插入图片描述

3、游戏素材

链接：https://pan.baidu.com/s/1M6-eZhHM9rOaFmrSMYOdog
提取码：wi6h

偷完面具就瞎跑
关注
  • 6
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
Python实现魂斗罗游戏：添加音效、增加关卡、道具等源码描述
程序熊的博客
05-03 380
self.image.fill((255, 0, 0)) # 红色方块代表玩家self.image.fill((0, 255, 0)) # 绿色方块代表敌人self.image.fill((255, 255, 0)) # 黄色方块代表子弹通过以上步骤，我们成功实现了一个简化版的魂斗罗游戏，并且添加了音效功能。玩家可以控制一个红色方块移动，并发射黄色方块代表的子弹击败绿色方块的敌人。你可以根据需要进一步扩展游戏内容，增加关卡、道具等元素，让游戏更加丰富和有趣。祝你玩得愉快！
基于python开发的魂斗罗游戏+源码（毕业设计&课程设计&项目开发）
05-02
基于python开发的魂斗罗游戏+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 基于python开发的魂斗罗游戏+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 基于python开发的魂斗罗游戏+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 基于python开发的魂斗罗游戏+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~
【标题】用python写一个魂斗罗
2302_81218205的博客
01-27 148
self.names1['player_image%s' %self.j] = pygame.image.load('图片/boss/'+direction+'/attack_1/%s.png' %self.j)self.names1['player_image%s' %self.j] = pygame.image.load('图片/boss/'+direction+'/attack_2/%s.png' %self.j)这里改动，enemy的update那里也要改。
用 Python 写个魂斗罗
AI科技大本营
06-01 1444
作者 |Python小二来源 | Python小二今天分享一个经典小游戏魂斗罗的 Python 版实现。部分代码实现如下：classGame_Player(): def__init__(self,game_settings,screen): self.screen=screen self.game_settings=game_settings ...
学习 Python 之 Pygame 开发魂斗罗（一）
qq_37354060的博客
02-23 1万+
学习 Python 之 Pygame 开发魂斗罗（一）
用Python写个魂斗罗，另附30个Python小游戏源码
热门推荐
Python小二
04-30 1万+
Python 版魂斗罗
Python魂斗罗代码
最新发布
2401_83470102的博客
05-22 451
这段代码创建了一个简单的灵魂斗罗游戏，玩家通过方向键控制角色移动，角色不能移出屏幕边界。游戏结束时，按下关闭按钮或者窗口的关闭按钮，游戏将结束，并且清理pygame资源。pygame.display.set_caption('灵魂斗罗')# 游戏结束，关闭pygame。# 通过按键状态移动角色。# 初始化pygame。# 保持角色在屏幕内。
学习 Python 之 Pygame 开发魂斗罗（二）
qq_37354060的博客
02-25 4491
学习 Python 之 Pygame 开发魂斗罗（二）
python/pygame 挑战魂斗罗 笔记(一)
2302_76282232的博客
04-15 993
前面完成了飞机和坦克两个经典游戏的基本功能，想挑战一下魂斗罗？这里的难点感觉是玩家的上下左右移动和变换动作，还有跳跃、趴下、射击等，尤其是跳到地面下的各个台阶部分，有点复杂。下面开始我的魂斗罗1.0的挑战，看看能不能实现。
pygame 魂斗罗源码和素材（Python版）完整版
02-18
本项目以"pygame 魂斗罗源码和素材（Python版）完整版"为主题，旨在深入解析如何使用Pygame构建一个经典的魂斗罗风格的游戏。 首先，我们要理解Pygame的基本结构。Pygame的核心是`pygame.display`模块，用于创建和...
基于Python的魂斗罗源码（完整源码可运行）.rar
05-06
【标题】"基于Python的魂斗罗源码（完整源码可运行）.rar" 提供的是一个使用Python编程语言实现的经典游戏魂斗罗的源代码。这个项目旨在展示如何利用Python进行游戏开发，同时也为学习Python编程的人提供了一个有趣...
经典小游戏，Python版魂斗罗完整程序包
12-29
【标题】"经典小游戏，Python版魂斗罗完整程序包"揭示了这是一个使用Python编程语言重制的经典游戏——魂斗罗。在IT领域，用编程语言实现经典游戏是一种常见的学习和实践方法，它能帮助开发者熟悉语言特性和游戏开发...
Python实现魂斗罗游戏源码
07-06
在这个"Python魂斗罗"项目中，开发者可能还使用了其他Python库，如numpy进行数学计算，或者pygame.transform和pygame.time来处理图像变换和时间控制。此外，游戏的难度、关卡设计、敌人的AI（如果有的话）也是项目中...
罗魂斗(第一个自己写的项目)模仿魂斗罗
08-23
【标题】"罗魂斗(第一个自己写的项目)模仿魂斗罗"是一个初学者尝试创建的游戏项目，旨在致敬经典游戏《魂斗罗》。在这个项目中，开发者运用所学的编程知识来构建一个类似的游戏环境，尽管可能还存在一些技术上的不足...
使用python开发“魂斗罗”游戏
Quintin
06-01 4308
使用python开发“魂斗罗”游戏
XPath超详细总结
qq_44619675的博客
02-22 1万+
XPath XPath，全称 XML Path Language，即 XML 路径语⾔，它是⼀⻔在 XML ⽂档中查找信息的语⾔。最初是⽤来搜寻 XML ⽂档的，但同样适⽤于 HTML ⽂档的搜索。所以在做爬⾍时完全可以使⽤ XPath做相应的信息抽取。 1、XPath概览 XPath 的选择功能⼗分强⼤，它提供了⾮常简洁明了的路径选择表达式。另外，它还提供了超过100 个内建函数，⽤于字符串、数值、时间的匹配以及节点、序列的处理等，⼏乎所有想要定位的节点都可以⽤ XPath 来选择。      官⽅⽂档：
用python写一个小鸟管道游戏
qq_44619675的博客
02-22 1379
嗨！多一嘴： 好久没有写博客了，自我罪恶感来袭，赶紧将最近实战的小游戏进行分享，跟上大家学习的步伐！ 1、代码实现(内附详细注释) （1）引入需要的模块 import pygame import sys import random （2）定义一个鸟类 class Bird(object): """定义一个鸟类""" def __init__(self): """定义初始化方法""" self.birdRect = pygame.Rect(65, 50,.
python实现魂斗罗源代码
09-18
Python实现魂斗罗的源代码可以分为游戏初始化、角色控制、游戏循环、碰撞检测、绘制等部分。 首先，在游戏初始化阶段，我们需要导入所需模块，设置游戏窗口大小、标题等，初始化角色、背景音乐等。 其次，在角色控制部分，我们可以定义一个角色类，包括角色的位置、状态、速度等属性，以及相应的移动、射击等方法。这样，在游戏循环中，我们可以根据玩家的操作来调用角色的相应方法，实现角色的控制。 然后，在游戏循环中，我们需要不断监听玩家的操作，例如按键的按下、松开等。根据玩家的操作来更新角色的状态，并刷新游戏的显示。 接着，在碰撞检测部分，我们可以定义一系列碰撞检测函数，例如检测角色与敌人、角色与道具等的碰撞。当检测到碰撞发生时，可以触发相应的事件，如角色受伤、敌人消失等。 最后，在绘制部分，我们可以使用绘图模块来绘制游戏的背景、角色、敌人等。可以根据角色的状态来选择相应的图像进行绘制。 总结起来，Python实现魂斗罗的源代码需要实现游戏的初始化、角色控制、游戏循环、碰撞检测、绘制等功能。通过合理的设计和编码，可以实现一个简单的魂斗罗游戏，让玩家能够在游戏中操作角色，并与敌人战斗。
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值