2022年 11月 5日

Python基础-Pygame游戏框架之飞机大战

                                      Pygame游戏框架

Pygame

Pygame是一套跨平台的Python模块，专为编写游戏而设计。

它包括计算机图形和声音库，旨在与Python编程语言一起使用。

展示窗体

引入pygame模块

import pygame

初始化游戏

pygame.init()

设置窗体大小

pygame.display.set_mode((400, 400))

展示窗体-程序执行流程

展示窗体

图形化界面程序都是阻塞式的

通常阻塞的实现策略就是死循环

事件捕获之窗体关闭

窗体关闭

pygame.event.get()提供事件的清单

event.type指明了事件的类型

pygame.locals模块提供了常量

QUIT就是窗体关闭事件

01.pygame窗口创建.py

  1. # 导入游戏引擎
  2. import pygame
  3.  
  4. # 初始化pygame
  5. pygame.init()
  6.  
  7. # 创建窗口
  8. # size 窗口大小 宽度和高度
  9. pygame.display.set_mode(size=(800,800))

02.pygame窗口一直展示.py

  1. # 导入游戏引擎
  2. import pygame
  3.  
  4. # 初始化pygame
  5. pygame.init()
  6.  
  7. # 创建窗口
  8. # size 窗口大小 宽度和高度
  9. pygame.display.set_mode(size=(800,800))
  10. # 避免程序结束
  11. while True:
  12.     pass

03.游戏停止.py

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5.  
  6. # 初始化pygame
  7. pygame.init()
  8.  
  9. # 创建窗口
  10. # size 窗口大小 宽度和高度
  11. window = pygame.display.set_mode(size=(800,800))
  12. # 避免程序结束
  13. while True:
  14.     # 处理事件
  15.     eventList = pygame.event.get()
  16.     # if len(eventList)>0:
  17.     # 有事件发生
  18.     # 判断是否是退出事件
  19.     # if len(eventList)>0:
  20.     #     print(eventList)
  21.     for event in eventList:
  22.         # 退出事件类型
  23.         if event.type==QUIT:
  24.             # 退出界面
  25.             pygame.display.quit()
  26.             # sys退出
  27.             sys.exit()

04.窗口标题和图标.py

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5.  
  6. # 初始化pygame
  7. pygame.init()
  8.  
  9. # 创建窗口
  10. # size 窗口大小 宽度和高度
  11. window = pygame.display.set_mode(size=(800,800))
  12. # 设置窗口标题
  13. pygame.display.set_caption('飞机大战')
  14.  
  15. # 加载图标
  16. icon = pygame.image.load('img/app.ico')
  17. # 设置图标
  18. pygame.display.set_icon(icon)
  19.  
  20. # 避免程序结束
  21. while True:
  22.     # 处理事件
  23.     eventList = pygame.event.get()
  24.     for event in eventList:
  25.         # 退出事件类型
  26.         if event.type==QUIT:
  27.             # 退出界面
  28.             pygame.display.quit()
  29.             # sys退出
  30.             sys.exit()

05.展示图片到窗口.py

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5.  
  6. # 初始化pygame
  7. pygame.init()
  8.  
  9. # 创建窗口
  10. # size 窗口大小 宽度和高度
  11. window = pygame.display.set_mode(size=(800,800))
  12. # 设置窗口标题
  13. pygame.display.set_caption('飞机大战')
  14.  
  15. # 加载图标
  16. icon = pygame.image.load('img/app.ico')
  17. # 设置图标
  18. pygame.display.set_icon(icon)
  19.  
  20. # 加载飞机图片
  21. heroImg = pygame.image.load('img/hero2.png')
  22.  
  23. # 避免程序结束
  24. while True:
  25.     # 展示飞机图片
  26.     window.blit(heroImg,(40,40))
  27.     # 刷新
  28.     pygame.display.flip()
  29.  
  30.     # 处理事件
  31.     eventList = pygame.event.get()
  32.     for event in eventList:
  33.         # 退出事件类型
  34.         if event.type==QUIT:
  35.             # 退出界面
  36.             pygame.display.quit()
  37.             # sys退出
  38.             sys.exit()

06.键盘事件处理.py

06.1 键盘按压一次触发一次

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5.  
  6. # 初始化pygame
  7. pygame.init()
  8.  
  9. # 创建窗口
  10. # size 窗口大小 宽度和高度
  11. window = pygame.display.set_mode(size=(800,800))
  12.  
  13.  
  14. # 避免程序结束
  15. while True:
  16.     # 处理事件
  17.     eventList = pygame.event.get()
  18.     for event in eventList:
  19.         # 退出事件类型
  20.         if event.type==QUIT:# 退出事件类型
  21.             # 退出界面
  22.             pygame.display.quit()
  23.             # sys退出
  24.             sys.exit()
  25.         elif event.type==KEYDOWN:# 键盘按下的事件
  26.             # 判断按下的是哪个键
  27.             if event.key==K_a:
  28.                 print('向左')
  29.             elif event.key==K_d:
  30.                 print('向右')
  31.             elif event.key==K_w:
  32.                 print('向前')
  33.             elif event.key==K_s:
  34.                 print('向后')
  35.             elif event.key==K_RETURN:
  36.                 print('点击了enter键')
  37.  
  38.

06.2 键盘一直按压,就一直触发

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5.  
  6. # 初始化pygame
  7. pygame.init()
  8.  
  9. # 创建窗口
  10. # size 窗口大小 宽度和高度
  11. window = pygame.display.set_mode(size=(800,800))
  12.  
  13.  
  14. # 避免程序结束
  15. while True:
  16.     # 处理事件
  17.     eventList = pygame.event.get()
  18.     for event in eventList:
  19.         # 退出事件类型
  20.         if event.type==QUIT:# 退出事件类型
  21.             # 退出界面
  22.             pygame.display.quit()
  23.             # sys退出
  24.             sys.exit()
  25.  
  26.  
  27.       # 返回所有键对应的状态 0:没有按压  1:有按压
  28.         states = pygame.key.get_pressed() # 键盘一直按压,就一直触发
  29.         # 有按压事件
  30.         if 1 in states:
  31.             # 是否是关心的a d s w键
  32.             if states[K_a]:  # 0 1
  33.                 plane.moveLeft()
  34.             elif states[K_d]:
  35.                 plane.moveRight()
  36.             elif states[K_w]:
  37.                 plane.moveUp()
  38.             elif states[K_s]:
  39.                 plane.moveDown()

07.展示图片到窗口.py

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5.  
  6. # 初始化pygame
  7. pygame.init()
  8.  
  9. # 创建窗口
  10. # size 窗口大小 宽度和高度
  11. window = pygame.display.set_mode(size=(800,800))
  12. # 设置窗口标题
  13. pygame.display.set_caption('飞机大战')
  14.  
  15. # 加载图标
  16. icon = pygame.image.load('img/app.ico')
  17. # 设置图标
  18. pygame.display.set_icon(icon)
  19.  
  20. # 加载飞机图片
  21. heroImg = pygame.image.load('img/hero2.png')
  22.  
  23. heroX = 200
  24. heroY = 200
  25.  
  26. # 避免程序结束
  27. while True:
  28.     # 清空窗口,通过背景颜色覆盖
  29.     # R G B
  30.     window.fill((0,0,0))
  31.  
  32.     # 展示飞机图片
  33.     window.blit(heroImg,(heroX,heroY))
  34.     # 刷新
  35.     pygame.display.flip()
  36.  
  37.     # 处理事件
  38.     eventList = pygame.event.get()
  39.     for event in eventList:
  40.         # 退出事件类型
  41.         if event.type==QUIT:
  42.             # 退出界面
  43.             pygame.display.quit()
  44.             # sys退出
  45.             sys.exit()
  46.         elif event.type==KEYDOWN:# 键盘按下的事件
  47.             # 判断按下的是哪个键
  48.             if event.key==K_a:
  49.                 heroX-=10
  50.             elif event.key==K_d:
  51.                 heroX+=10
  52.             elif event.key==K_w:
  53.                 heroY-=10
  54.             elif event.key==K_s:
  55.                 heroY+=10

08.文字展示.py

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5.  
  6. # 初始化pygame
  7. pygame.init()
  8.  
  9. # 创建窗口
  10. # size 窗口大小 宽度和高度
  11. window = pygame.display.set_mode(size=(800,800))
  12. # 加载字体
  13. font = pygame.font.Font('font/happy.ttf',50)
  14. # 渲染字体
  15. fontSurface = font.render('游戏开始',True,(255,255,255))
  16.  
  17. # 避免程序结束
  18. while True:
  19.     # 显示字体控件
  20.     window.blit(fontSurface,(200,200))
  21.     # 刷新(只需要执行一次)
  22.     pygame.display.flip()
  23.  
  24.     # 处理事件
  25.     eventList = pygame.event.get()
  26.     for event in eventList:
  27.         # 退出事件类型
  28.         if event.type==QUIT:
  29.             # 退出界面
  30.             pygame.display.quit()
  31.             # sys退出
  32.             sys.exit()

09.背景音效播放.py

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5.  
  6. # 初始化pygame
  7. pygame.init()
  8.  
  9. # 创建窗口
  10. # size 窗口大小 宽度和高度
  11. window = pygame.display.set_mode(size=(800,800))
  12. # 加载背景音效
  13. pygame.mixer.music.load('snd/bomb.wav')
  14.  
  15. # 避免程序结束
  16. while True:
  17.     # 处理事件
  18.     eventList = pygame.event.get()
  19.     for event in eventList:
  20.         # 退出事件类型
  21.         if event.type==QUIT:# 退出事件类型
  22.             # 退出界面
  23.             pygame.display.quit()
  24.             # sys退出
  25.             sys.exit()
  26.         elif event.type==KEYDOWN:# 键盘按下的事件
  27.             # 判断按下的是哪个键
  28.             if event.key==K_a:
  29.                 # 播放背景音效
  30.                 pygame.mixer.music.play(loops=-1)

10.特殊音效处理.py

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5.  
  6. # 初始化pygame
  7. pygame.init()
  8.  
  9. # 创建窗口
  10. # size 窗口大小 宽度和高度
  11. window = pygame.display.set_mode(size=(800,800))
  12.  
  13. # 加载特殊音效
  14. sn = pygame.mixer.Sound('snd/bomb.wav')
  15.  
  16. # 避免程序结束
  17. while True:
  18.     # 处理事件
  19.     eventList = pygame.event.get()
  20.     for event in eventList:
  21.         # 退出事件类型
  22.         if event.type==QUIT:# 退出事件类型
  23.             # 退出界面
  24.             pygame.display.quit()
  25.             # sys退出
  26.             sys.exit()
  27.         elif event.type==KEYDOWN:# 键盘按下的事件
  28.             # 判断按下的是哪个键
  29.             if event.key==K_a:
  30.                 sn.stop()
  31.             elif event.key==K_s:
  32.                 sn.play(loops=0)
  33.

11.FPS计算.py

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5. import time
  6.  
  7. # 初始化pygame
  8. pygame.init()
  9.  
  10. # 创建窗口
  11. # size 窗口大小 宽度和高度
  12. window = pygame.display.set_mode(size=(800,800))
  13. # 设置窗口标题
  14. pygame.display.set_caption('飞机大战')
  15.  
  16. # 加载图标
  17. icon = pygame.image.load('img/app.ico')
  18. # 设置图标
  19. pygame.display.set_icon(icon)
  20.  
  21. # 加载飞机图片
  22. heroImg = pygame.image.load('img/hero2.png')
  23.  
  24. heroX = 200
  25. heroY = 200
  26.  
  27. # 避免程序结束
  28. while True:
  29.     # 开始时间
  30.     startTime = time.time()
  31.  
  32.     # 清空窗口,通过背景颜色覆盖
  33.     # R G B
  34.     window.fill((0,0,0))
  35.  
  36.     # 展示飞机图片
  37.     window.blit(heroImg,(heroX,heroY))
  38.     # 刷新
  39.     pygame.display.flip()
  40.  
  41.     # 处理事件
  42.     eventList = pygame.event.get()
  43.     for event in eventList:
  44.         # 退出事件类型
  45.         if event.type==QUIT:
  46.             # 退出界面
  47.             pygame.display.quit()
  48.             # sys退出
  49.             sys.exit()
  50.         elif event.type==KEYDOWN:# 键盘按下的事件
  51.             # 判断按下的是哪个键
  52.             if event.key==K_a:
  53.                 heroX-=10
  54.             elif event.key==K_d:
  55.                 heroX+=10
  56.             elif event.key==K_w:
  57.                 heroY-=10
  58.             elif event.key==K_s:
  59.                 heroY+=10
  60.     # 降低fps
  61.     time.sleep(0.008)
  62.     # 结束时间
  63.     endTime = time.time()
  64.     # 这一次渲染时间
  65.     renderTime = endTime-startTime
  66.     try:
  67.         # 求FPS
  68.         fps = int(1/renderTime)
  69.         print(fps)
  70.     except:
  71.         pass

12.Surface.py

  1. # 导入游戏引擎
  2. import pygame
  3. from pygame.locals import *
  4. import sys
  5.  
  6. # 初始化pygame
  7. pygame.init()
  8.  
  9. # 创建窗口
  10. # size 窗口大小 宽度和高度
  11. window = pygame.display.set_mode(size=(800,800))
  12.  
  13. print(window.get_width(),window.get_height())
  14. # 设置窗口标题
  15. pygame.display.set_caption('飞机大战')
  16.  
  17. # 加载图标
  18. icon = pygame.image.load('img/app.ico')
  19. # 设置图标
  20. pygame.display.set_icon(icon)
  21.  
  22. # 加载飞机图片
  23. heroImg = pygame.image.load('img/hero2.png')
  24.  
  25. # 获取图片大小
  26. # print(heroImg.get_width(),heroImg.get_height())
  27. print(heroImg.get_rect())
  28.  
  29. heroX = 200
  30. heroY = 200
  31.  
  32. # 避免程序结束
  33. while True:
  34.     # 清空窗口,通过背景颜色覆盖
  35.     # R G B
  36.     window.fill((0,0,0))
  37.  
  38.     # 展示飞机图片
  39.     window.blit(heroImg,(heroX,heroY))
  40.     # 刷新
  41.     pygame.display.flip()
  42.  
  43.     # 处理事件
  44.     eventList = pygame.event.get()
  45.     for event in eventList:
  46.         # 退出事件类型
  47.         if event.type==QUIT:
  48.             # 退出界面
  49.             pygame.display.quit()
  50.             # sys退出
  51.             sys.exit()
  52.         elif event.type==KEYDOWN:# 键盘按下的事件
  53.             # 判断按下的是哪个键
  54.             if event.key==K_a:
  55.                 heroX-=10
  56.             elif event.key==K_d:
  57.                 heroX+=10
  58.             elif event.key==K_w:
  59.                 heroY-=10
  60.             elif event.key==K_s:
  61.                 heroY+=10

飞机大战

01.创建飞机大战窗口

  1. import pygame
  2.  
  3. # 初始化
  4. pygame.init()
  5.  
  6. # 创建游戏窗口
  7. window = pygame.display.set_mode(size=(600,800))
  8.  
  9. # 保证窗口不关闭
  10. while True:
  11.     pass

02.窗口处理:

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4. """
  5. 1.标题和图标
  6. 2.退出事件
  7. """
  8.  
  9. # 初始化
  10. pygame.init()
  11.  
  12. # 创建游戏窗口
  13. window = pygame.display.set_mode(size=(600,800))
  14. # 窗口标题
  15. pygame.display.set_caption('飞机大战')
  16.  
  17. # 加载图标图片
  18. iconSurface = pygame.image.load('img/app.ico')
  19. # 设置图标
  20. pygame.display.set_icon(iconSurface)
  21.  
  22.  
  23. # 保证窗口不关闭
  24. while True:
  25.     # 处理窗口关闭
  26.     eventList = pygame.event.get()
  27.     for event in eventList:
  28.         # 判断是否是退出类型
  29.         if event.type==QUIT:
  30.             # 退出游戏
  31.             pygame.quit()
  32.             # 退出程序
  33.             sys.exit()

03.展示背景

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4. """
  5. 1.标题和图标
  6. 2.退出事件
  7. """
  8.  
  9. # 初始化
  10. pygame.init()
  11.  
  12. # 加载背景图片
  13. bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  14. # 获取背景图片的大小
  15. bgWidth = bgSurface.get_width()
  16. bgHeight = bgSurface.get_height()
  17.  
  18. # 创建游戏窗口
  19. window = pygame.display.set_mode(size=(bgWidth,bgHeight))
  20. # 窗口标题
  21. pygame.display.set_caption('飞机大战')
  22.  
  23. # 加载图标图片
  24. iconSurface = pygame.image.load('img/app.ico')
  25. # 设置图标
  26. pygame.display.set_icon(iconSurface)
  27.  
  28.  
  29. # 保证窗口不关闭
  30. while True:
  31.     # 展示背景
  32.     window.blit(bgSurface,(0,0))
  33.     # 刷新
  34.     pygame.display.flip()
  35.  
  36.     # 处理窗口关闭
  37.     eventList = pygame.event.get()
  38.     for event in eventList:
  39.         # 判断是否是退出类型
  40.         if event.type==QUIT:
  41.             # 退出游戏
  42.             pygame.quit()
  43.             # 退出程序
  44.             sys.exit()

04.入口函数处理

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4. """
  5. 1.标题和图标
  6. 2.退出事件
  7. """
  8.  
  9. def start():
  10.     # 初始化
  11.     pygame.init()
  12.  
  13.     # 加载背景图片
  14.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  15.     # 获取背景图片的大小
  16.     bgWidth = bgSurface.get_width()
  17.     bgHeight = bgSurface.get_height()
  18.  
  19.     # 创建游戏窗口
  20.     window = pygame.display.set_mode(size=(bgWidth,bgHeight))
  21.     # 窗口标题
  22.     pygame.display.set_caption('飞机大战')
  23.  
  24.     # 加载图标图片
  25.     iconSurface = pygame.image.load('img/app.ico')
  26.     # 设置图标
  27.     pygame.display.set_icon(iconSurface)
  28.  
  29.  
  30.     # 保证窗口不关闭
  31.     while True:
  32.         # 展示背景
  33.         window.blit(bgSurface,(0,0))
  34.         # 刷新
  35.         pygame.display.flip()
  36.  
  37.         # 处理窗口关闭
  38.         eventList = pygame.event.get()
  39.         for event in eventList:
  40.             # 判断是否是退出类型
  41.             if event.type==QUIT:
  42.                 # 退出游戏
  43.                 pygame.quit()
  44.                 # 退出程序
  45.                 sys.exit()
  46.  
  47. if __name__ == '__main__':
  48.     start()

05.添加我方飞机

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4. """
  5. 1.标题和图标
  6. 2.退出事件
  7. """
  8.  
  9. def start():
  10.     # 初始化
  11.     pygame.init()
  12.  
  13.     # 加载背景图片
  14.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  15.     # 获取背景图片的大小
  16.     bgWidth = bgSurface.get_width()
  17.     bgHeight = bgSurface.get_height()
  18.  
  19.     # 创建游戏窗口
  20.     window = pygame.display.set_mode(size=(bgWidth,bgHeight))
  21.     # 窗口标题
  22.     pygame.display.set_caption('飞机大战')
  23.  
  24.     # 加载图标图片
  25.     iconSurface = pygame.image.load('img/app.ico')
  26.     # 设置图标
  27.     pygame.display.set_icon(iconSurface)
  28.  
  29.     # 加载我方飞机图片
  30.     heroSurface = pygame.image.load('img/hero2.png')
  31.  
  32.     # 保证窗口不关闭
  33.     while True:
  34.         # 展示背景
  35.         window.blit(bgSurface,(0,0))
  36.         # 展示我方飞机
  37.         window.blit(heroSurface,(200,600))
  38.         # 刷新
  39.         pygame.display.flip()
  40.  
  41.         # 处理窗口关闭
  42.         eventList = pygame.event.get()
  43.         for event in eventList:
  44.             # 判断是否是退出类型
  45.             if event.type==QUIT:
  46.                 # 退出游戏
  47.                 pygame.quit()
  48.                 # 退出程序
  49.                 sys.exit()
  50.  
  51. if __name__ == '__main__':
  52.     start()

06.飞机类抽取

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4. """
  5. 1.标题和图标
  6. 2.退出事件
  7. """
  8. """
  9. 飞机属性: x,y window
  10. 飞机行为:被展示行为display
  11. """
  12.  
  13. """------------------ 我方飞机类 ------------------"""
  14. class Plane:
  15.     def __init__(self,x,y,window):
  16.         # 坐标
  17.         self.x = x
  18.         self.y = y
  19.         # 被展示到的窗口
  20.         self.window = window
  21.         # 飞机展示的Surface
  22.         self.surface = pygame.image.load('img/hero2.png')
  23.  
  24.     def display(self):
  25.         '''
  26.         被展示
  27.         :return:
  28.         '''
  29.         # 展示我方飞机
  30.         self.window.blit(self.surface, (self.x, self.y))
  31.  
  32.  
  33. def start():
  34.     # 初始化
  35.     pygame.init()
  36.  
  37.     # 加载背景图片
  38.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  39.     # 获取背景图片的大小
  40.     bgWidth = bgSurface.get_width()
  41.     bgHeight = bgSurface.get_height()
  42.  
  43.     # 创建游戏窗口
  44.     window = pygame.display.set_mode(size=(bgWidth,bgHeight))
  45.     # 窗口标题
  46.     pygame.display.set_caption('飞机大战')
  47.  
  48.     # 加载图标图片
  49.     iconSurface = pygame.image.load('img/app.ico')
  50.     # 设置图标
  51.     pygame.display.set_icon(iconSurface)
  52.  
  53.     # 创建飞机类
  54.     plane = Plane(200,600,window)
  55.  
  56.     # 保证窗口不关闭
  57.     while True:
  58.         # 展示背景
  59.         window.blit(bgSurface,(0,0))
  60.         # 展示飞机
  61.         plane.display()
  62.         # 刷新
  63.         pygame.display.flip()
  64.  
  65.         # 处理窗口关闭
  66.         eventList = pygame.event.get()
  67.         for event in eventList:
  68.             # 判断是否是退出类型
  69.             if event.type==QUIT:
  70.                 # 退出游戏
  71.                 pygame.quit()
  72.                 # 退出程序
  73.                 sys.exit()
  74.  
  75. if __name__ == '__main__':
  76.     start()

07.飞机的移动

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13.  
  14. """------------------ 我方飞机类 ------------------"""
  15.  
  16.  
  17. class Plane:
  18.     def __init__(self, x, y, window):
  19.         # 坐标
  20.         self.__x = x
  21.         self.__y = y
  22.         # 被展示到的窗口
  23.         self.__window = window
  24.         # 飞机展示的Surface
  25.         self.__surface = pygame.image.load('img/hero2.png')
  26.  
  27.     def display(self):
  28.         '''
  29.         被展示
  30.         :return:
  31.         '''
  32.         # 展示我方飞机
  33.         self.__window.blit(self.__surface, (self.__x, self.__y))
  34.  
  35.     def moveLeft(self):
  36.         '''
  37.         向左移动
  38.         :return:
  39.         '''
  40.         self.__x -= 1
  41.  
  42.     def moveRight(self):
  43.         '''
  44.         向右移动
  45.         :return:
  46.         '''
  47.         self.__x += 1
  48.  
  49.     def moveUp(self):
  50.         '''
  51.         向上移动
  52.         :return:
  53.         '''
  54.         self.__y -= 1
  55.  
  56.     def moveDown(self):
  57.         '''
  58.         向下移动
  59.         :return:
  60.         '''
  61.         self.__y += 1
  62.  
  63.  
  64. def start():
  65.     # 初始化
  66.     pygame.init()
  67.  
  68.     # 加载背景图片
  69.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  70.     # 获取背景图片的大小
  71.     bgWidth = bgSurface.get_width()
  72.     bgHeight = bgSurface.get_height()
  73.  
  74.     # 创建游戏窗口
  75.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  76.     # 窗口标题
  77.     pygame.display.set_caption('飞机大战')
  78.  
  79.     # 加载图标图片
  80.     iconSurface = pygame.image.load('img/app.ico')
  81.     # 设置图标
  82.     pygame.display.set_icon(iconSurface)
  83.  
  84.     # 创建飞机类
  85.     plane = Plane(200, 600, window)
  86.  
  87.     # 保证窗口不关闭
  88.     while True:
  89.         # 展示背景
  90.         window.blit(bgSurface, (0, 0))
  91.         # 展示飞机
  92.         plane.display()
  93.         # 刷新
  94.         pygame.display.flip()
  95.  
  96.         # 处理窗口关闭
  97.         eventList = pygame.event.get()
  98.         for event in eventList:
  99.             # 判断是否是退出类型
  100.             if event.type == QUIT:
  101.                 # 退出游戏
  102.                 pygame.quit()
  103.                 # 退出程序
  104.                 sys.exit()
  105.             elif event.type == KEYDOWN:  # 按下事件
  106.                 if event.key == K_a:
  107.                     plane.moveLeft()
  108.                 elif event.key == K_d:
  109.                     plane.moveRight()
  110.                 elif event.key == K_w:
  111.                     plane.moveUp()
  112.                 elif event.key == K_s:
  113.                     plane.moveDown()
  114.  
  115.  
  116. if __name__ == '__main__':
  117.     start()

08.飞机的移动细节处理

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13.  
  14. """------------------ 我方飞机类 ------------------"""
  15.  
  16.  
  17. class Plane:
  18.     def __init__(self, x, y, window):
  19.         # 坐标
  20.         self.__x = x
  21.         self.__y = y
  22.         # 被展示到的窗口
  23.         self.__window = window
  24.         # 飞机展示的Surface
  25.         self.__surface = pygame.image.load('img/hero2.png')
  26.         # 运动速度
  27.         self.speed = 1
  28.  
  29.     def display(self):
  30.         '''
  31.         被展示
  32.         :return:
  33.         '''
  34.         # 展示我方飞机
  35.         self.__window.blit(self.__surface, (self.__x, self.__y))
  36.  
  37.     def moveLeft(self):
  38.         '''
  39.         向左移动
  40.         :return:
  41.         '''
  42.         self.__x -= self.speed
  43.  
  44.     def moveRight(self):
  45.         '''
  46.         向右移动
  47.         :return:
  48.         '''
  49.         self.__x += self.speed
  50.  
  51.     def moveUp(self):
  52.         '''
  53.         向上移动
  54.         :return:
  55.         '''
  56.         self.__y -= self.speed
  57.  
  58.     def moveDown(self):
  59.         '''
  60.         向下移动
  61.         :return:
  62.         '''
  63.         self.__y += self.speed
  64.  
  65.  
  66. def start():
  67.     # 初始化
  68.     pygame.init()
  69.  
  70.     # 加载背景图片
  71.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  72.     # 获取背景图片的大小
  73.     bgWidth = bgSurface.get_width()
  74.     bgHeight = bgSurface.get_height()
  75.  
  76.     # 创建游戏窗口
  77.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  78.     # 窗口标题
  79.     pygame.display.set_caption('飞机大战')
  80.  
  81.     # 加载图标图片
  82.     iconSurface = pygame.image.load('img/app.ico')
  83.     # 设置图标
  84.     pygame.display.set_icon(iconSurface)
  85.  
  86.     # 创建飞机类
  87.     plane = Plane(200, 600, window)
  88.  
  89.     # 保证窗口不关闭
  90.     while True:
  91.         # 展示背景
  92.         window.blit(bgSurface, (0, 0))
  93.         # 展示飞机
  94.         plane.display()
  95.         # 刷新
  96.         pygame.display.flip()
  97.  
  98.         # 处理窗口关闭
  99.         eventList = pygame.event.get()
  100.         for event in eventList:
  101.             # 判断是否是退出类型
  102.             if event.type == QUIT:
  103.                 # 退出游戏
  104.                 pygame.quit()
  105.                 # 退出程序
  106.                 sys.exit()
  107.         # 处理按压事件
  108.         # 返回所有键对应的状态 0:没有按压  1:有按压
  109.         states = pygame.key.get_pressed()
  110.         # 有按压事件
  111.         if 1 in states:
  112.             # 是否是关心的a d s w键
  113.             if states[K_a]:# 0 1
  114.                 plane.moveLeft()
  115.             elif states[K_d]:
  116.                 plane.moveRight()
  117.             elif states[K_w]:
  118.                 plane.moveUp()
  119.             elif states[K_s]:
  120.                 plane.moveDown()
  121.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  122.             #     if event.key == K_a:
  123.             #         plane.moveLeft()
  124.             #     elif event.key == K_d:
  125.             #         plane.moveRight()
  126.             #     elif event.key == K_w:
  127.             #         plane.moveUp()
  128.             #     elif event.key == K_s:
  129.             #         plane.moveDown()
  130.  
  131.  
  132. if __name__ == '__main__':
  133.     start()

09.子弹类的创建

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. """------------------ 子弹类 ------------------"""
  14. class Bullet:
  15.     def __init__(self,x,y,window):
  16.         # 展示的坐标
  17.         self.x = x
  18.         self.y = y
  19.         # 需要展示的窗口
  20.         self.window = window
  21.         # 展示的控件
  22.         self.surface = pygame.image.load('img/bullet_10.png')
  23.  
  24.     def display(self):
  25.         '''
  26.         展示控件
  27.         :return:
  28.         '''
  29.         self.window.blit(self.surface,(self.x,self.y))
  30.  
  31.  
  32. """------------------ 我方飞机类 ------------------"""
  33.  
  34. class Plane:
  35.     def __init__(self, x, y, window):
  36.         # 坐标
  37.         self.__x = x
  38.         self.__y = y
  39.         # 被展示到的窗口
  40.         self.__window = window
  41.         # 飞机展示的Surface
  42.         self.__surface = pygame.image.load('img/hero2.png')
  43.         # 运动速度
  44.         self.speed = 1
  45.  
  46.     def display(self):
  47.         '''
  48.         被展示
  49.         :return:
  50.         '''
  51.         # 展示我方飞机
  52.         self.__window.blit(self.__surface, (self.__x, self.__y))
  53.  
  54.     def moveLeft(self):
  55.         '''
  56.         向左移动
  57.         :return:
  58.         '''
  59.         self.__x -= self.speed
  60.  
  61.     def moveRight(self):
  62.         '''
  63.         向右移动
  64.         :return:
  65.         '''
  66.         self.__x += self.speed
  67.  
  68.     def moveUp(self):
  69.         '''
  70.         向上移动
  71.         :return:
  72.         '''
  73.         self.__y -= self.speed
  74.  
  75.     def moveDown(self):
  76.         '''
  77.         向下移动
  78.         :return:
  79.         '''
  80.         self.__y += self.speed
  81.  
  82.  
  83. def start():
  84.     # 初始化
  85.     pygame.init()
  86.  
  87.     # 加载背景图片
  88.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  89.     # 获取背景图片的大小
  90.     bgWidth = bgSurface.get_width()
  91.     bgHeight = bgSurface.get_height()
  92.  
  93.     # 创建游戏窗口
  94.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  95.     # 窗口标题
  96.     pygame.display.set_caption('飞机大战')
  97.  
  98.     # 加载图标图片
  99.     iconSurface = pygame.image.load('img/app.ico')
  100.     # 设置图标
  101.     pygame.display.set_icon(iconSurface)
  102.  
  103.     # 创建飞机类
  104.     plane = Plane(200, 600, window)
  105.  
  106.     # 保证窗口不关闭
  107.     while True:
  108.         # 展示背景
  109.         window.blit(bgSurface, (0, 0))
  110.         # 展示飞机
  111.         plane.display()
  112.         # 刷新
  113.         pygame.display.flip()
  114.  
  115.         # 处理窗口关闭
  116.         eventList = pygame.event.get()
  117.         for event in eventList:
  118.             # 判断是否是退出类型
  119.             if event.type == QUIT:
  120.                 # 退出游戏
  121.                 pygame.quit()
  122.                 # 退出程序
  123.                 sys.exit()
  124.         # 处理按压事件
  125.         # 返回所有键对应的状态 0:没有按压  1:有按压
  126.         states = pygame.key.get_pressed()
  127.         # 有按压事件
  128.         if 1 in states:
  129.             # 是否是关心的a d s w键
  130.             if states[K_a]:# 0 1
  131.                 plane.moveLeft()
  132.             elif states[K_d]:
  133.                 plane.moveRight()
  134.             elif states[K_w]:
  135.                 plane.moveUp()
  136.             elif states[K_s]:
  137.                 plane.moveDown()
  138.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  139.             #     if event.key == K_a:
  140.             #         plane.moveLeft()
  141.             #     elif event.key == K_d:
  142.             #         plane.moveRight()
  143.             #     elif event.key == K_w:
  144.             #         plane.moveUp()
  145.             #     elif event.key == K_s:
  146.             #         plane.moveDown()
  147.  
  148.  
  149. if __name__ == '__main__':
  150.     start()

10.发射子弹

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. """------------------ 子弹类 ------------------"""
  14. class Bullet:
  15.     def __init__(self,x,y,window):
  16.         # 展示的坐标
  17.         self.x = x
  18.         self.y = y
  19.         # 需要展示的窗口
  20.         self.window = window
  21.         # 展示的控件
  22.         self.surface = pygame.image.load('img/bullet_10.png')
  23.  
  24.     def display(self):
  25.         '''
  26.         展示控件
  27.         :return:
  28.         '''
  29.         self.window.blit(self.surface,(self.x,self.y))
  30.  
  31.  
  32. """------------------ 我方飞机类 ------------------"""
  33. class Plane:
  34.     def __init__(self, x, y, window):
  35.         # 坐标
  36.         self.__x = x
  37.         self.__y = y
  38.         # 被展示到的窗口
  39.         self.__window = window
  40.         # 飞机展示的Surface
  41.         self.__surface = pygame.image.load('img/hero2.png')
  42.         # 运动速度
  43.         self.speed = 1
  44.         # 发射的子弹容器
  45.         self.__bullets = []
  46.  
  47.     def display(self):
  48.         '''
  49.         被展示
  50.         :return:
  51.         '''
  52.         # 展示我方飞机
  53.         self.__window.blit(self.__surface, (self.__x, self.__y))
  54.         # 把所有发射的子弹渲染出来
  55.         for bullet in self.__bullets:
  56.             # 把子弹展示出来
  57.             bullet.display()
  58.  
  59.     def fire(self):
  60.         '''
  61.         发射子弹
  62.         :return:
  63.         '''
  64.         # 创建子弹对象
  65.         bullet = Bullet(self.__x,self.__y,self.__window)
  66.         # 子弹对象添加到子弹列表中
  67.         self.__bullets.append(bullet)
  68.  
  69.     def moveLeft(self):
  70.         '''
  71.         向左移动
  72.         :return:
  73.         '''
  74.         self.__x -= self.speed
  75.  
  76.     def moveRight(self):
  77.         '''
  78.         向右移动
  79.         :return:
  80.         '''
  81.         self.__x += self.speed
  82.  
  83.     def moveUp(self):
  84.         '''
  85.         向上移动
  86.         :return:
  87.         '''
  88.         self.__y -= self.speed
  89.  
  90.     def moveDown(self):
  91.         '''
  92.         向下移动
  93.         :return:
  94.         '''
  95.         self.__y += self.speed
  96.  
  97.  
  98. def start():
  99.     # 初始化
  100.     pygame.init()
  101.  
  102.     # 加载背景图片
  103.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  104.     # 获取背景图片的大小
  105.     bgWidth = bgSurface.get_width()
  106.     bgHeight = bgSurface.get_height()
  107.  
  108.     # 创建游戏窗口
  109.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  110.     # 窗口标题
  111.     pygame.display.set_caption('飞机大战')
  112.  
  113.     # 加载图标图片
  114.     iconSurface = pygame.image.load('img/app.ico')
  115.     # 设置图标
  116.     pygame.display.set_icon(iconSurface)
  117.  
  118.     # 创建飞机类
  119.     plane = Plane(200, 600, window)
  120.  
  121.     # 保证窗口不关闭
  122.     while True:
  123.         # 展示背景
  124.         window.blit(bgSurface, (0, 0))
  125.         # 展示飞机
  126.         plane.display()
  127.         # 刷新
  128.         pygame.display.flip()
  129.  
  130.         # 处理窗口关闭
  131.         eventList = pygame.event.get()
  132.         for event in eventList:
  133.             # 判断是否是退出类型
  134.             if event.type == QUIT:
  135.                 # 退出游戏
  136.                 pygame.quit()
  137.                 # 退出程序
  138.                 sys.exit()
  139.             elif event.type==KEYDOWN:
  140.                 if event.key==K_RETURN:
  141.                     # 发射子弹
  142.                     plane.fire()
  143.  
  144.         # 处理按压事件
  145.         # 返回所有键对应的状态 0:没有按压  1:有按压
  146.         states = pygame.key.get_pressed()
  147.         # 有按压事件
  148.         if 1 in states:
  149.             # 是否是关心的a d s w键
  150.             if states[K_a]:# 0 1
  151.                 plane.moveLeft()
  152.             elif states[K_d]:
  153.                 plane.moveRight()
  154.             elif states[K_w]:
  155.                 plane.moveUp()
  156.             elif states[K_s]:
  157.                 plane.moveDown()
  158.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  159.             #     if event.key == K_a:
  160.             #         plane.moveLeft()
  161.             #     elif event.key == K_d:
  162.             #         plane.moveRight()
  163.             #     elif event.key == K_w:
  164.             #         plane.moveUp()
  165.             #     elif event.key == K_s:
  166.             #         plane.moveDown()
  167.  
  168.  
  169. if __name__ == '__main__':
  170.     start()

11.子弹位置确定

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. """------------------ 子弹类 ------------------"""
  14. class Bullet:
  15.     def __init__(self,px,py,pw,window):
  16.         # 需要展示的窗口
  17.         self.__window = window
  18.         # 展示的控件
  19.         self.__surface = pygame.image.load('img/bullet_10.png')
  20.         # 控件宽度和高度
  21.         self.width = self.__surface.get_width()
  22.         self.height = self.__surface.get_height()
  23.  
  24.         # bx = px + (pw - bw) / 2
  25.         # by = py - bh / 2
  26.         self.__x = px+(pw-self.width)/2
  27.         self.__y = py-self.height/2
  28.  
  29.  
  30.     def display(self):
  31.         '''
  32.         展示控件
  33.         :return:
  34.         '''
  35.         self.__window.blit(self.__surface,(self.__x,self.__y))
  36.  
  37.  
  38. """------------------ 我方飞机类 ------------------"""
  39. class Plane:
  40.     def __init__(self, x, y, window):
  41.         # 坐标
  42.         self.__x = x
  43.         self.__y = y
  44.         # 被展示到的窗口
  45.         self.__window = window
  46.         # 飞机展示的Surface
  47.         self.__surface = pygame.image.load('img/hero2.png')
  48.         # 控件宽度和高度
  49.         self.width = self.__surface.get_width()
  50.         self.height = self.__surface.get_height()
  51.         # 运动速度
  52.         self.speed = 1
  53.         # 发射的子弹容器
  54.         self.__bullets = []
  55.  
  56.     def display(self):
  57.         '''
  58.         被展示
  59.         :return:
  60.         '''
  61.         # 展示我方飞机
  62.         self.__window.blit(self.__surface, (self.__x, self.__y))
  63.         # 把所有发射的子弹渲染出来
  64.         for bullet in self.__bullets:
  65.             # 把子弹展示出来
  66.             bullet.display()
  67.  
  68.     def fire(self):
  69.         '''
  70.         发射子弹
  71.         :return:
  72.         '''
  73.         # 子弹的x和y
  74.         # bx = px + (pw - bw) / 2
  75.         # by = py - bh / 2
  76.         # 创建子弹对象
  77.         bullet = Bullet(self.__x,self.__y,self.width,self.__window)
  78.         # 子弹对象添加到子弹列表中
  79.         self.__bullets.append(bullet)
  80.  
  81.     def moveLeft(self):
  82.         '''
  83.         向左移动
  84.         :return:
  85.         '''
  86.         self.__x -= self.speed
  87.  
  88.     def moveRight(self):
  89.         '''
  90.         向右移动
  91.         :return:
  92.         '''
  93.         self.__x += self.speed
  94.  
  95.     def moveUp(self):
  96.         '''
  97.         向上移动
  98.         :return:
  99.         '''
  100.         self.__y -= self.speed
  101.  
  102.     def moveDown(self):
  103.         '''
  104.         向下移动
  105.         :return:
  106.         '''
  107.         self.__y += self.speed
  108.  
  109.  
  110. def start():
  111.     # 初始化
  112.     pygame.init()
  113.  
  114.     # 加载背景图片
  115.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  116.     # 获取背景图片的大小
  117.     bgWidth = bgSurface.get_width()
  118.     bgHeight = bgSurface.get_height()
  119.  
  120.     # 创建游戏窗口
  121.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  122.     # 窗口标题
  123.     pygame.display.set_caption('飞机大战')
  124.  
  125.     # 加载图标图片
  126.     iconSurface = pygame.image.load('img/app.ico')
  127.     # 设置图标
  128.     pygame.display.set_icon(iconSurface)
  129.  
  130.     # 创建飞机类
  131.     plane = Plane(200, 600, window)
  132.  
  133.     # 保证窗口不关闭
  134.     while True:
  135.         # 展示背景
  136.         window.blit(bgSurface, (0, 0))
  137.         # 展示飞机
  138.         plane.display()
  139.         # 刷新
  140.         pygame.display.flip()
  141.  
  142.         # 处理窗口关闭
  143.         eventList = pygame.event.get()
  144.         for event in eventList:
  145.             # 判断是否是退出类型
  146.             if event.type == QUIT:
  147.                 # 退出游戏
  148.                 pygame.quit()
  149.                 # 退出程序
  150.                 sys.exit()
  151.             elif event.type==KEYDOWN:
  152.                 if event.key==K_RETURN:
  153.                     # 发射子弹
  154.                     plane.fire()
  155.  
  156.         # 处理按压事件
  157.         # 返回所有键对应的状态 0:没有按压  1:有按压
  158.         states = pygame.key.get_pressed()
  159.         # 有按压事件
  160.         if 1 in states:
  161.             # 是否是关心的a d s w键
  162.             if states[K_a]:# 0 1
  163.                 plane.moveLeft()
  164.             elif states[K_d]:
  165.                 plane.moveRight()
  166.             elif states[K_w]:
  167.                 plane.moveUp()
  168.             elif states[K_s]:
  169.                 plane.moveDown()
  170.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  171.             #     if event.key == K_a:
  172.             #         plane.moveLeft()
  173.             #     elif event.key == K_d:
  174.             #         plane.moveRight()
  175.             #     elif event.key == K_w:
  176.             #         plane.moveUp()
  177.             #     elif event.key == K_s:
  178.             #         plane.moveDown()
  179.  
  180.  
  181. if __name__ == '__main__':
  182.     start()

12.子弹的移动

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. """------------------ 子弹类 ------------------"""
  14. class Bullet:
  15.     def __init__(self,px,py,pw,window):
  16.         # 需要展示的窗口
  17.         self.__window = window
  18.         # 展示的控件
  19.         self.__surface = pygame.image.load('img/bullet_10.png')
  20.         # 控件宽度和高度
  21.         self.width = self.__surface.get_width()
  22.         self.height = self.__surface.get_height()
  23.  
  24.         # bx = px + (pw - bw) / 2
  25.         # by = py - bh / 2
  26.         self.__x = px+(pw-self.width)/2
  27.         self.__y = py-self.height/2
  28.         # 自动运行速度
  29.         self.__speed = 2
  30.  
  31.  
  32.     def display(self):
  33.         '''
  34.         展示控件
  35.         :return:
  36.         '''
  37.         self.__window.blit(self.__surface,(self.__x,self.__y))
  38.         # 自动移动
  39.         self.autoMove()
  40.  
  41.     def autoMove(self):
  42.         '''
  43.         自动移动
  44.         :return:
  45.         '''
  46.         self.__y-=self.__speed
  47.  
  48.  
  49. """------------------ 我方飞机类 ------------------"""
  50. class Plane:
  51.     def __init__(self, x, y, window):
  52.         # 坐标
  53.         self.__x = x
  54.         self.__y = y
  55.         # 被展示到的窗口
  56.         self.__window = window
  57.         # 飞机展示的Surface
  58.         self.__surface = pygame.image.load('img/hero2.png')
  59.         # 控件宽度和高度
  60.         self.width = self.__surface.get_width()
  61.         self.height = self.__surface.get_height()
  62.         # 运动速度
  63.         self.speed = 1
  64.         # 发射的子弹容器
  65.         self.__bullets = []
  66.  
  67.     def display(self):
  68.         '''
  69.         被展示
  70.         :return:
  71.         '''
  72.         # 展示我方飞机
  73.         self.__window.blit(self.__surface, (self.__x, self.__y))
  74.         # 把所有发射的子弹渲染出来
  75.         for bullet in self.__bullets:
  76.             # 把子弹展示出来
  77.             bullet.display()
  78.  
  79.     def fire(self):
  80.         '''
  81.         发射子弹
  82.         :return:
  83.         '''
  84.         # 子弹的x和y
  85.         # bx = px + (pw - bw) / 2
  86.         # by = py - bh / 2
  87.         # 创建子弹对象
  88.         bullet = Bullet(self.__x,self.__y,self.width,self.__window)
  89.         # 子弹对象添加到子弹列表中
  90.         self.__bullets.append(bullet)
  91.  
  92.     def moveLeft(self):
  93.         '''
  94.         向左移动
  95.         :return:
  96.         '''
  97.         self.__x -= self.speed
  98.  
  99.     def moveRight(self):
  100.         '''
  101.         向右移动
  102.         :return:
  103.         '''
  104.         self.__x += self.speed
  105.  
  106.     def moveUp(self):
  107.         '''
  108.         向上移动
  109.         :return:
  110.         '''
  111.         self.__y -= self.speed
  112.  
  113.     def moveDown(self):
  114.         '''
  115.         向下移动
  116.         :return:
  117.         '''
  118.         self.__y += self.speed
  119.  
  120.  
  121. def start():
  122.     # 初始化
  123.     pygame.init()
  124.  
  125.     # 加载背景图片
  126.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  127.     # 获取背景图片的大小
  128.     bgWidth = bgSurface.get_width()
  129.     bgHeight = bgSurface.get_height()
  130.  
  131.     # 创建游戏窗口
  132.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  133.     # 窗口标题
  134.     pygame.display.set_caption('飞机大战')
  135.  
  136.     # 加载图标图片
  137.     iconSurface = pygame.image.load('img/app.ico')
  138.     # 设置图标
  139.     pygame.display.set_icon(iconSurface)
  140.  
  141.     # 创建飞机类
  142.     plane = Plane(200, 600, window)
  143.  
  144.     # 保证窗口不关闭
  145.     while True:
  146.         # 展示背景
  147.         window.blit(bgSurface, (0, 0))
  148.         # 展示飞机
  149.         plane.display()
  150.         # 刷新
  151.         pygame.display.flip()
  152.  
  153.         # 处理窗口关闭
  154.         eventList = pygame.event.get()
  155.         for event in eventList:
  156.             # 判断是否是退出类型
  157.             if event.type == QUIT:
  158.                 # 退出游戏
  159.                 pygame.quit()
  160.                 # 退出程序
  161.                 sys.exit()
  162.             elif event.type==KEYDOWN:
  163.                 if event.key==K_RETURN:
  164.                     # 发射子弹
  165.                     plane.fire()
  166.  
  167.         # 处理按压事件
  168.         # 返回所有键对应的状态 0:没有按压  1:有按压
  169.         states = pygame.key.get_pressed()
  170.         # 有按压事件
  171.         if 1 in states:
  172.             # 是否是关心的a d s w键
  173.             if states[K_a]:# 0 1
  174.                 plane.moveLeft()
  175.             elif states[K_d]:
  176.                 plane.moveRight()
  177.             elif states[K_w]:
  178.                 plane.moveUp()
  179.             elif states[K_s]:
  180.                 plane.moveDown()
  181.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  182.             #     if event.key == K_a:
  183.             #         plane.moveLeft()
  184.             #     elif event.key == K_d:
  185.             #         plane.moveRight()
  186.             #     elif event.key == K_w:
  187.             #         plane.moveUp()
  188.             #     elif event.key == K_s:
  189.             #         plane.moveDown()
  190.  
  191.  
  192. if __name__ == '__main__':
  193.     start()

13.子弹的越界处理

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. """------------------ 子弹类 ------------------"""
  14. class Bullet:
  15.     def __init__(self,px,py,pw,window):
  16.         # 需要展示的窗口
  17.         self.__window = window
  18.         # 展示的控件
  19.         self.__surface = pygame.image.load('img/bullet_10.png')
  20.         # 控件宽度和高度
  21.         self.width = self.__surface.get_width()
  22.         self.height = self.__surface.get_height()
  23.  
  24.         # bx = px + (pw - bw) / 2
  25.         # by = py - bh / 2
  26.         self.__x = px+(pw-self.width)/2
  27.         self.__y = py-self.height/2
  28.         # 自动运行速度
  29.         self.__speed = 2
  30.  
  31.  
  32.     def display(self):
  33.         '''
  34.         展示控件
  35.         :return:
  36.         '''
  37.         self.__window.blit(self.__surface,(self.__x,self.__y))
  38.         # 自动移动
  39.         self.autoMove()
  40.  
  41.     def autoMove(self):
  42.         '''
  43.         自动移动
  44.         :return:
  45.         '''
  46.         self.__y-=self.__speed
  47.  
  48.     def needDestroy(self):
  49.         '''
  50.         是否需要被销毁
  51.         :return:
  52.         '''
  53.         return self.__y<=-self.height
  54.  
  55.  
  56. """------------------ 我方飞机类 ------------------"""
  57. class Plane:
  58.     def __init__(self, x, y, window):
  59.         # 坐标
  60.         self.__x = x
  61.         self.__y = y
  62.         # 被展示到的窗口
  63.         self.__window = window
  64.         # 飞机展示的Surface
  65.         self.__surface = pygame.image.load('img/hero2.png')
  66.         # 控件宽度和高度
  67.         self.width = self.__surface.get_width()
  68.         self.height = self.__surface.get_height()
  69.         # 运动速度
  70.         self.speed = 1
  71.         # 发射的子弹容器
  72.         self.__bullets = []
  73.  
  74.     def display(self):
  75.         '''
  76.         被展示
  77.         :return:
  78.         '''
  79.         print(len(self.__bullets))
  80.         # 展示我方飞机
  81.         self.__window.blit(self.__surface, (self.__x, self.__y))
  82.         # 先销毁越界子弹
  83.         for bullet in self.__bullets:
  84.             # 如果子弹需要销毁
  85.             if bullet.needDestroy():
  86.                 # 移除子弹对象
  87.                 self.__bullets.remove(bullet)
  88.                 # 内存销毁对象
  89.                 del bullet
  90.  
  91.         # 把所有发射的子弹渲染出来
  92.         for bullet in self.__bullets:
  93.             # 把子弹展示出来
  94.             bullet.display()
  95.  
  96.     def fire(self):
  97.         '''
  98.         发射子弹
  99.         :return:
  100.         '''
  101.         # 子弹的x和y
  102.         # bx = px + (pw - bw) / 2
  103.         # by = py - bh / 2
  104.         # 创建子弹对象
  105.         bullet = Bullet(self.__x,self.__y,self.width,self.__window)
  106.         # 子弹对象添加到子弹列表中
  107.         self.__bullets.append(bullet)
  108.  
  109.     def moveLeft(self):
  110.         '''
  111.         向左移动
  112.         :return:
  113.         '''
  114.         self.__x -= self.speed
  115.  
  116.     def moveRight(self):
  117.         '''
  118.         向右移动
  119.         :return:
  120.         '''
  121.         self.__x += self.speed
  122.  
  123.     def moveUp(self):
  124.         '''
  125.         向上移动
  126.         :return:
  127.         '''
  128.         self.__y -= self.speed
  129.  
  130.     def moveDown(self):
  131.         '''
  132.         向下移动
  133.         :return:
  134.         '''
  135.         self.__y += self.speed
  136.  
  137.  
  138. def start():
  139.     # 初始化
  140.     pygame.init()
  141.  
  142.     # 加载背景图片
  143.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  144.     # 获取背景图片的大小
  145.     bgWidth = bgSurface.get_width()
  146.     bgHeight = bgSurface.get_height()
  147.  
  148.     # 创建游戏窗口
  149.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  150.     # 窗口标题
  151.     pygame.display.set_caption('飞机大战')
  152.  
  153.     # 加载图标图片
  154.     iconSurface = pygame.image.load('img/app.ico')
  155.     # 设置图标
  156.     pygame.display.set_icon(iconSurface)
  157.  
  158.     # 创建飞机类
  159.     plane = Plane(200, 600, window)
  160.  
  161.     # 保证窗口不关闭
  162.     while True:
  163.         # 展示背景
  164.         window.blit(bgSurface, (0, 0))
  165.         # 展示飞机
  166.         plane.display()
  167.         # 刷新
  168.         pygame.display.flip()
  169.  
  170.         # 处理窗口关闭
  171.         eventList = pygame.event.get()
  172.         for event in eventList:
  173.             # 判断是否是退出类型
  174.             if event.type == QUIT:
  175.                 # 退出游戏
  176.                 pygame.quit()
  177.                 # 退出程序
  178.                 sys.exit()
  179.             elif event.type==KEYDOWN:
  180.                 if event.key==K_RETURN:
  181.                     # 发射子弹
  182.                     plane.fire()
  183.  
  184.         # 处理按压事件
  185.         # 返回所有键对应的状态 0:没有按压  1:有按压
  186.         states = pygame.key.get_pressed()
  187.         # 有按压事件
  188.         if 1 in states:
  189.             # 是否是关心的a d s w键
  190.             if states[K_a]:# 0 1
  191.                 plane.moveLeft()
  192.             elif states[K_d]:
  193.                 plane.moveRight()
  194.             elif states[K_w]:
  195.                 plane.moveUp()
  196.             elif states[K_s]:
  197.                 plane.moveDown()
  198.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  199.             #     if event.key == K_a:
  200.             #         plane.moveLeft()
  201.             #     elif event.key == K_d:
  202.             #         plane.moveRight()
  203.             #     elif event.key == K_w:
  204.             #         plane.moveUp()
  205.             #     elif event.key == K_s:
  206.             #         plane.moveDown()
  207.  
  208.  
  209. if __name__ == '__main__':
  210.     start()

14.子弹的越界处理错误解决

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. """------------------ 子弹类 ------------------"""
  14.  
  15.  
  16. class Bullet:
  17.     def __init__(self, px, py, pw, window):
  18.         # 需要展示的窗口
  19.         self.__window = window
  20.         # 展示的控件
  21.         self.__surface = pygame.image.load('img/bullet_10.png')
  22.         # 控件宽度和高度
  23.         self.width = self.__surface.get_width()
  24.         self.height = self.__surface.get_height()
  25.  
  26.         # bx = px + (pw - bw) / 2
  27.         # by = py - bh / 2
  28.         self.__x = px + (pw - self.width) / 2
  29.         self.__y = py - self.height / 2
  30.         # 自动运行速度
  31.         self.__speed = 2
  32.  
  33.     def display(self):
  34.         '''
  35.         展示控件
  36.         :return:
  37.         '''
  38.         self.__window.blit(self.__surface, (self.__x, self.__y))
  39.         # 自动移动
  40.         self.autoMove()
  41.  
  42.     def autoMove(self):
  43.         '''
  44.         自动移动
  45.         :return:
  46.         '''
  47.         self.__y -= self.__speed
  48.  
  49.     def needDestroy(self):
  50.         '''
  51.         是否需要被销毁
  52.         :return:
  53.         '''
  54.         return self.__y <= -self.height
  55.  
  56.  
  57. """------------------ 我方飞机类 ------------------"""
  58.  
  59.  
  60. class Plane:
  61.     def __init__(self, x, y, window):
  62.         # 坐标
  63.         self.__x = x
  64.         self.__y = y
  65.         # 被展示到的窗口
  66.         self.__window = window
  67.         # 飞机展示的Surface
  68.         self.__surface = pygame.image.load('img/hero2.png')
  69.         # 控件宽度和高度
  70.         self.width = self.__surface.get_width()
  71.         self.height = self.__surface.get_height()
  72.         # 运动速度
  73.         self.speed = 1
  74.         # 发射的子弹容器
  75.         self.__bullets = []
  76.  
  77.     def display(self):
  78.         '''
  79.         被展示
  80.         :return:
  81.         '''
  82.         print(len(self.__bullets))
  83.         # 展示我方飞机
  84.         self.__window.blit(self.__surface, (self.__x, self.__y))
  85.  
  86.         # 在循环遍历的时候做了移除元素的操作
  87.         # 先销毁越界子弹
  88.         # for bullet in self.__bullets:
  89.         #     # 如果子弹需要销毁
  90.         #     if bullet.needDestroy():
  91.         #         # 移除子弹对象
  92.         #         self.__bullets.remove(bullet)
  93.         #         # 内存销毁对象
  94.         #         del bullet
  95.  
  96.         for index in range(len(self.__bullets) - 1, -1, -1):
  97.             bullet = self.__bullets[index]
  98.             if bullet.needDestroy():
  99.                 # 移除子弹对象
  100.                 self.__bullets.remove(bullet)
  101.                 # 内存销毁对象
  102.                 del bullet
  103.             else:
  104.                 # 把子弹展示出来
  105.                 bullet.display()
  106.  
  107.         # # 把所有发射的子弹渲染出来
  108.         # for bullet in self.__bullets:
  109.         #     # 把子弹展示出来
  110.         #     bullet.display()
  111.  
  112.     def fire(self):
  113.         '''
  114.         发射子弹
  115.         :return:
  116.         '''
  117.         # 子弹的x和y
  118.         # bx = px + (pw - bw) / 2
  119.         # by = py - bh / 2
  120.         # 创建子弹对象
  121.         bullet = Bullet(self.__x, self.__y, self.width, self.__window)
  122.         # 子弹对象添加到子弹列表中
  123.         self.__bullets.append(bullet)
  124.  
  125.     def moveLeft(self):
  126.         '''
  127.         向左移动
  128.         :return:
  129.         '''
  130.         self.__x -= self.speed
  131.         # 越界处理
  132.         if self.__x < 0:
  133.             self.__x = 0
  134.  
  135.     def moveRight(self):
  136.         '''
  137.         向右移动
  138.         :return:
  139.         '''
  140.         self.__x += self.speed
  141.         # 越界处理
  142.         if self.__x > bgWidth - self.width:
  143.             self.__x = bgWidth - self.width
  144.  
  145.     def moveUp(self):
  146.         '''
  147.         向上移动
  148.         :return:
  149.         '''
  150.         self.__y -= self.speed
  151.         # 越界处理
  152.         if self.__y < 0:
  153.             self.__y = 0
  154.  
  155.     def moveDown(self):
  156.         '''
  157.         向下移动
  158.         :return:
  159.         '''
  160.         self.__y += self.speed
  161.         # 越界处理
  162.         if self.__y > bgHeight - self.height:
  163.             self.__y = bgHeight - self.height
  164.  
  165.  
  166. # 全局变量
  167. bgWidth = 0
  168. bgHeight = 0
  169.  
  170.  
  171. def start():
  172.     global bgWidth, bgHeight
  173.     # 初始化
  174.     pygame.init()
  175.  
  176.     # 加载背景图片
  177.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  178.     # 获取背景图片的大小
  179.     bgWidth = bgSurface.get_width()
  180.     bgHeight = bgSurface.get_height()
  181.  
  182.     # 创建游戏窗口
  183.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  184.     # 窗口标题
  185.     pygame.display.set_caption('飞机大战')
  186.  
  187.     # 加载图标图片
  188.     iconSurface = pygame.image.load('img/app.ico')
  189.     # 设置图标
  190.     pygame.display.set_icon(iconSurface)
  191.  
  192.     # 创建飞机类
  193.     plane = Plane(200, 600, window)
  194.  
  195.     # 保证窗口不关闭
  196.     while True:
  197.         # 展示背景
  198.         window.blit(bgSurface, (0, 0))
  199.         # 展示飞机
  200.         plane.display()
  201.         # 刷新
  202.         pygame.display.flip()
  203.  
  204.         # 处理窗口关闭
  205.         eventList = pygame.event.get()
  206.         for event in eventList:
  207.             # 判断是否是退出类型
  208.             if event.type == QUIT:
  209.                 # 退出游戏
  210.                 pygame.quit()
  211.                 # 退出程序
  212.                 sys.exit()
  213.             elif event.type == KEYDOWN:
  214.                 if event.key == K_RETURN:
  215.                     # 发射子弹
  216.                     plane.fire()
  217.  
  218.         # 处理按压事件
  219.         # 返回所有键对应的状态 0:没有按压  1:有按压
  220.         states = pygame.key.get_pressed()
  221.         # 有按压事件
  222.         if 1 in states:
  223.             # 是否是关心的a d s w键
  224.             if states[K_a]:  # 0 1
  225.                 plane.moveLeft()
  226.             elif states[K_d]:
  227.                 plane.moveRight()
  228.             elif states[K_w]:
  229.                 plane.moveUp()
  230.             elif states[K_s]:
  231.                 plane.moveDown()
  232.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  233.             #     if event.key == K_a:
  234.             #         plane.moveLeft()
  235.             #     elif event.key == K_d:
  236.             #         plane.moveRight()
  237.             #     elif event.key == K_w:
  238.             #         plane.moveUp()
  239.             #     elif event.key == K_s:
  240.             #         plane.moveDown()
  241.  
  242.  
  243. if __name__ == '__main__':
  244.     start()

15.提取敌方飞机类

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. """------------------ 敌方飞机类 ------------------"""
  14. class EnemyPlane:
  15.     def __init__(self, x, y, window):
  16.         # 坐标
  17.         self.__x = x
  18.         self.__y = y
  19.         # 被展示到的窗口
  20.         self.__window = window
  21.         # 飞机展示的Surface
  22.         self.__surface = pygame.image.load('img/img-plane_1.png')
  23.         # 控件宽度和高度
  24.         self.width = self.__surface.get_width()
  25.         self.height = self.__surface.get_height()
  26.  
  27.  
  28.     def display(self):
  29.         '''
  30.         被展示
  31.         :return:
  32.         '''
  33.         # 展示我方飞机
  34.         self.__window.blit(self.__surface, (self.__x, self.__y))
  35.  
  36.  
  37. """------------------ 子弹类 ------------------"""
  38. class Bullet:
  39.     def __init__(self, px, py, pw, window):
  40.         # 需要展示的窗口
  41.         self.__window = window
  42.         # 展示的控件
  43.         self.__surface = pygame.image.load('img/bullet_10.png')
  44.         # 控件宽度和高度
  45.         self.width = self.__surface.get_width()
  46.         self.height = self.__surface.get_height()
  47.  
  48.         # bx = px + (pw - bw) / 2
  49.         # by = py - bh / 2
  50.         self.__x = px + (pw - self.width) / 2
  51.         self.__y = py - self.height / 2
  52.         # 自动运行速度
  53.         self.__speed = 2
  54.  
  55.     def display(self):
  56.         '''
  57.         展示控件
  58.         :return:
  59.         '''
  60.         self.__window.blit(self.__surface, (self.__x, self.__y))
  61.         # 自动移动
  62.         self.autoMove()
  63.  
  64.     def autoMove(self):
  65.         '''
  66.         自动移动
  67.         :return:
  68.         '''
  69.         self.__y -= self.__speed
  70.  
  71.     def needDestroy(self):
  72.         '''
  73.         是否需要被销毁
  74.         :return:
  75.         '''
  76.         return self.__y <= -self.height
  77.  
  78.  
  79. """------------------ 我方飞机类 ------------------"""
  80.  
  81.  
  82. class Plane:
  83.     def __init__(self, x, y, window):
  84.         # 坐标
  85.         self.__x = x
  86.         self.__y = y
  87.         # 被展示到的窗口
  88.         self.__window = window
  89.         # 飞机展示的Surface
  90.         self.__surface = pygame.image.load('img/hero2.png')
  91.         # 控件宽度和高度
  92.         self.width = self.__surface.get_width()
  93.         self.height = self.__surface.get_height()
  94.         # 运动速度
  95.         self.speed = 1
  96.         # 发射的子弹容器
  97.         self.__bullets = []
  98.  
  99.     def display(self):
  100.         '''
  101.         被展示
  102.         :return:
  103.         '''
  104.         print(len(self.__bullets))
  105.         # 展示我方飞机
  106.         self.__window.blit(self.__surface, (self.__x, self.__y))
  107.  
  108.         # 在循环遍历的时候做了移除元素的操作
  109.         # 先销毁越界子弹
  110.         # for bullet in self.__bullets:
  111.         #     # 如果子弹需要销毁
  112.         #     if bullet.needDestroy():
  113.         #         # 移除子弹对象
  114.         #         self.__bullets.remove(bullet)
  115.         #         # 内存销毁对象
  116.         #         del bullet
  117.  
  118.         for index in range(len(self.__bullets) - 1, -1, -1):
  119.             bullet = self.__bullets[index]
  120.             if bullet.needDestroy():
  121.                 # 移除子弹对象
  122.                 self.__bullets.remove(bullet)
  123.                 # 内存销毁对象
  124.                 del bullet
  125.             else:
  126.                 # 把子弹展示出来
  127.                 bullet.display()
  128.  
  129.         # # 把所有发射的子弹渲染出来
  130.         # for bullet in self.__bullets:
  131.         #     # 把子弹展示出来
  132.         #     bullet.display()
  133.  
  134.     def fire(self):
  135.         '''
  136.         发射子弹
  137.         :return:
  138.         '''
  139.         # 子弹的x和y
  140.         # bx = px + (pw - bw) / 2
  141.         # by = py - bh / 2
  142.         # 创建子弹对象
  143.         bullet = Bullet(self.__x, self.__y, self.width, self.__window)
  144.         # 子弹对象添加到子弹列表中
  145.         self.__bullets.append(bullet)
  146.  
  147.     def moveLeft(self):
  148.         '''
  149.         向左移动
  150.         :return:
  151.         '''
  152.         self.__x -= self.speed
  153.         # 越界处理
  154.         if self.__x < 0:
  155.             self.__x = 0
  156.  
  157.     def moveRight(self):
  158.         '''
  159.         向右移动
  160.         :return:
  161.         '''
  162.         self.__x += self.speed
  163.         # 越界处理
  164.         if self.__x > bgWidth - self.width:
  165.             self.__x = bgWidth - self.width
  166.  
  167.     def moveUp(self):
  168.         '''
  169.         向上移动
  170.         :return:
  171.         '''
  172.         self.__y -= self.speed
  173.         # 越界处理
  174.         if self.__y < 0:
  175.             self.__y = 0
  176.  
  177.     def moveDown(self):
  178.         '''
  179.         向下移动
  180.         :return:
  181.         '''
  182.         self.__y += self.speed
  183.         # 越界处理
  184.         if self.__y > bgHeight - self.height:
  185.             self.__y = bgHeight - self.height
  186.  
  187.  
  188. # 全局变量
  189. bgWidth = 0
  190. bgHeight = 0
  191.  
  192.  
  193. def start():
  194.     global bgWidth, bgHeight
  195.     # 初始化
  196.     pygame.init()
  197.  
  198.     # 加载背景图片
  199.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  200.     # 获取背景图片的大小
  201.     bgWidth = bgSurface.get_width()
  202.     bgHeight = bgSurface.get_height()
  203.  
  204.     # 创建游戏窗口
  205.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  206.     # 窗口标题
  207.     pygame.display.set_caption('飞机大战')
  208.  
  209.     # 加载图标图片
  210.     iconSurface = pygame.image.load('img/app.ico')
  211.     # 设置图标
  212.     pygame.display.set_icon(iconSurface)
  213.  
  214.     # 创建飞机类
  215.     plane = Plane(200, 600, window)
  216.  
  217.     # 保证窗口不关闭
  218.     while True:
  219.         # 展示背景
  220.         window.blit(bgSurface, (0, 0))
  221.         # 展示飞机
  222.         plane.display()
  223.         # 刷新
  224.         pygame.display.flip()
  225.  
  226.         # 处理窗口关闭
  227.         eventList = pygame.event.get()
  228.         for event in eventList:
  229.             # 判断是否是退出类型
  230.             if event.type == QUIT:
  231.                 # 退出游戏
  232.                 pygame.quit()
  233.                 # 退出程序
  234.                 sys.exit()
  235.             elif event.type == KEYDOWN:
  236.                 if event.key == K_RETURN:
  237.                     # 发射子弹
  238.                     plane.fire()
  239.  
  240.         # 处理按压事件
  241.         # 返回所有键对应的状态 0:没有按压  1:有按压
  242.         states = pygame.key.get_pressed()
  243.         # 有按压事件
  244.         if 1 in states:
  245.             # 是否是关心的a d s w键
  246.             if states[K_a]:  # 0 1
  247.                 plane.moveLeft()
  248.             elif states[K_d]:
  249.                 plane.moveRight()
  250.             elif states[K_w]:
  251.                 plane.moveUp()
  252.             elif states[K_s]:
  253.                 plane.moveDown()
  254.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  255.             #     if event.key == K_a:
  256.             #         plane.moveLeft()
  257.             #     elif event.key == K_d:
  258.             #         plane.moveRight()
  259.             #     elif event.key == K_w:
  260.             #         plane.moveUp()
  261.             #     elif event.key == K_s:
  262.             #         plane.moveDown()
  263.  
  264.  
  265. if __name__ == '__main__':
  266.     start()

16.展示敌方飞机以及敌方飞机自动移动

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. """------------------ 敌方飞机类 ------------------"""
  14. class EnemyPlane:
  15.     def __init__(self, x, y, window):
  16.         # 坐标
  17.         self.__x = x
  18.         self.__y = y
  19.         # 被展示到的窗口
  20.         self.__window = window
  21.         # 飞机展示的Surface
  22.         self.__surface = pygame.image.load('img/img-plane_1.png')
  23.         # 控件宽度和高度
  24.         self.width = self.__surface.get_width()
  25.         self.height = self.__surface.get_height()
  26.         # 自动移动
  27.         self.__speed = 1
  28.  
  29.  
  30.     def display(self):
  31.         '''
  32.         被展示
  33.         :return:
  34.         '''
  35.         # 展示我方飞机
  36.         self.__window.blit(self.__surface, (self.__x, self.__y))
  37.         # 自动移动
  38.         self.autoMove()
  39.  
  40.     def autoMove(self):
  41.         '''
  42.         自动移动
  43.         :return:
  44.         '''
  45.         self.__y += self.__speed
  46.  
  47.  
  48. """------------------ 子弹类 ------------------"""
  49. class Bullet:
  50.     def __init__(self, px, py, pw, window):
  51.         # 需要展示的窗口
  52.         self.__window = window
  53.         # 展示的控件
  54.         self.__surface = pygame.image.load('img/bullet_10.png')
  55.         # 控件宽度和高度
  56.         self.width = self.__surface.get_width()
  57.         self.height = self.__surface.get_height()
  58.  
  59.         # bx = px + (pw - bw) / 2
  60.         # by = py - bh / 2
  61.         self.__x = px + (pw - self.width) / 2
  62.         self.__y = py - self.height / 2
  63.         # 自动运行速度
  64.         self.__speed = 2
  65.  
  66.     def display(self):
  67.         '''
  68.         展示控件
  69.         :return:
  70.         '''
  71.         self.__window.blit(self.__surface, (self.__x, self.__y))
  72.         # 自动移动
  73.         self.autoMove()
  74.  
  75.     def autoMove(self):
  76.         '''
  77.         自动移动
  78.         :return:
  79.         '''
  80.         self.__y -= self.__speed
  81.  
  82.     def needDestroy(self):
  83.         '''
  84.         是否需要被销毁
  85.         :return:
  86.         '''
  87.         return self.__y <= -self.height
  88.  
  89.  
  90. """------------------ 我方飞机类 ------------------"""
  91.  
  92.  
  93. class Plane:
  94.     def __init__(self, x, y, window):
  95.         # 坐标
  96.         self.__x = x
  97.         self.__y = y
  98.         # 被展示到的窗口
  99.         self.__window = window
  100.         # 飞机展示的Surface
  101.         self.__surface = pygame.image.load('img/hero2.png')
  102.         # 控件宽度和高度
  103.         self.width = self.__surface.get_width()
  104.         self.height = self.__surface.get_height()
  105.         # 运动速度
  106.         self.speed = 1
  107.         # 发射的子弹容器
  108.         self.__bullets = []
  109.  
  110.     def display(self):
  111.         '''
  112.         被展示
  113.         :return:
  114.         '''
  115.         print(len(self.__bullets))
  116.         # 展示我方飞机
  117.         self.__window.blit(self.__surface, (self.__x, self.__y))
  118.  
  119.         # 在循环遍历的时候做了移除元素的操作
  120.         # 先销毁越界子弹
  121.         # for bullet in self.__bullets:
  122.         #     # 如果子弹需要销毁
  123.         #     if bullet.needDestroy():
  124.         #         # 移除子弹对象
  125.         #         self.__bullets.remove(bullet)
  126.         #         # 内存销毁对象
  127.         #         del bullet
  128.         # 是否和敌方飞机发生了碰撞
  129.         # TODO 是否发生碰撞
  130.  
  131.         # 展示
  132.         for index in range(len(self.__bullets) - 1, -1, -1):
  133.             bullet = self.__bullets[index]
  134.             if bullet.needDestroy():
  135.                 # 移除子弹对象
  136.                 self.__bullets.remove(bullet)
  137.                 # 内存销毁对象
  138.                 del bullet
  139.             else:
  140.                 # 把子弹展示出来
  141.                 bullet.display()
  142.  
  143.         # # 把所有发射的子弹渲染出来
  144.         # for bullet in self.__bullets:
  145.         #     # 把子弹展示出来
  146.         #     bullet.display()
  147.  
  148.     def fire(self):
  149.         '''
  150.         发射子弹
  151.         :return:
  152.         '''
  153.         # 子弹的x和y
  154.         # bx = px + (pw - bw) / 2
  155.         # by = py - bh / 2
  156.         # 创建子弹对象
  157.         bullet = Bullet(self.__x, self.__y, self.width, self.__window)
  158.         # 子弹对象添加到子弹列表中
  159.         self.__bullets.append(bullet)
  160.  
  161.     def moveLeft(self):
  162.         '''
  163.         向左移动
  164.         :return:
  165.         '''
  166.         self.__x -= self.speed
  167.         # 越界处理
  168.         if self.__x < 0:
  169.             self.__x = 0
  170.  
  171.     def moveRight(self):
  172.         '''
  173.         向右移动
  174.         :return:
  175.         '''
  176.         self.__x += self.speed
  177.         # 越界处理
  178.         if self.__x > bgWidth - self.width:
  179.             self.__x = bgWidth - self.width
  180.  
  181.     def moveUp(self):
  182.         '''
  183.         向上移动
  184.         :return:
  185.         '''
  186.         self.__y -= self.speed
  187.         # 越界处理
  188.         if self.__y < 0:
  189.             self.__y = 0
  190.  
  191.     def moveDown(self):
  192.         '''
  193.         向下移动
  194.         :return:
  195.         '''
  196.         self.__y += self.speed
  197.         # 越界处理
  198.         if self.__y > bgHeight - self.height:
  199.             self.__y = bgHeight - self.height
  200.  
  201.  
  202. # 全局变量
  203. bgWidth = 0
  204. bgHeight = 0
  205.  
  206.  
  207. def start():
  208.     global bgWidth, bgHeight
  209.     # 初始化
  210.     pygame.init()
  211.  
  212.     # 加载背景图片
  213.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  214.     # 获取背景图片的大小
  215.     bgWidth = bgSurface.get_width()
  216.     bgHeight = bgSurface.get_height()
  217.  
  218.     # 创建游戏窗口
  219.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  220.     # 窗口标题
  221.     pygame.display.set_caption('飞机大战')
  222.  
  223.     # 加载图标图片
  224.     iconSurface = pygame.image.load('img/app.ico')
  225.     # 设置图标
  226.     pygame.display.set_icon(iconSurface)
  227.  
  228.     # 创建飞机类
  229.     plane = Plane(200, 600, window)
  230.  
  231.     # 创建敌方飞机类
  232.     enemyPlane = EnemyPlane(100,0,window)
  233.  
  234.     # 保证窗口不关闭
  235.     while True:
  236.         # 展示背景
  237.         window.blit(bgSurface, (0, 0))
  238.         # 展示我方飞机
  239.         plane.display()
  240.         # 展示敌方飞机
  241.         enemyPlane.display()
  242.         # 刷新
  243.         pygame.display.flip()
  244.  
  245.         # 处理窗口关闭
  246.         eventList = pygame.event.get()
  247.         for event in eventList:
  248.             # 判断是否是退出类型
  249.             if event.type == QUIT:
  250.                 # 退出游戏
  251.                 pygame.quit()
  252.                 # 退出程序
  253.                 sys.exit()
  254.             elif event.type == KEYDOWN:
  255.                 if event.key == K_RETURN:
  256.                     # 发射子弹
  257.                     plane.fire()
  258.  
  259.         # 处理按压事件
  260.         # 返回所有键对应的状态 0:没有按压  1:有按压
  261.         states = pygame.key.get_pressed()
  262.         # 有按压事件
  263.         if 1 in states:
  264.             # 是否是关心的a d s w键
  265.             if states[K_a]:  # 0 1
  266.                 plane.moveLeft()
  267.             elif states[K_d]:
  268.                 plane.moveRight()
  269.             elif states[K_w]:
  270.                 plane.moveUp()
  271.             elif states[K_s]:
  272.                 plane.moveDown()
  273.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  274.             #     if event.key == K_a:
  275.             #         plane.moveLeft()
  276.             #     elif event.key == K_d:
  277.             #         plane.moveRight()
  278.             #     elif event.key == K_w:
  279.             #         plane.moveUp()
  280.             #     elif event.key == K_s:
  281.             #         plane.moveDown()
  282.  
  283.  
  284. if __name__ == '__main__':
  285.     start()

17.子弹和敌方飞机碰撞检测

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. """------------------ 敌方飞机类 ------------------"""
  14. class EnemyPlane:
  15.     def __init__(self, x, y, window):
  16.         # 坐标
  17.         self.__x = x
  18.         self.__y = y
  19.         # 被展示到的窗口
  20.         self.__window = window
  21.         # 飞机展示的Surface
  22.         self.__surface = pygame.image.load('img/img-plane_1.png')
  23.         # 控件宽度和高度
  24.         self.width = self.__surface.get_width()
  25.         self.height = self.__surface.get_height()
  26.         # 自动移动
  27.         self.__speed = 1
  28.  
  29.     def getX(self):
  30.         return self.__x
  31.  
  32.     def getY(self):
  33.         return self.__y
  34.  
  35.     def display(self):
  36.         '''
  37.         被展示
  38.         :return:
  39.         '''
  40.         # 展示我方飞机
  41.         self.__window.blit(self.__surface, (self.__x, self.__y))
  42.         # 自动移动
  43.         self.autoMove()
  44.  
  45.     def autoMove(self):
  46.         '''
  47.         自动移动
  48.         :return:
  49.         '''
  50.         self.__y += self.__speed
  51.  
  52.  
  53. """------------------ 子弹类 ------------------"""
  54. class Bullet:
  55.     def __init__(self, px, py, pw, window):
  56.         # 需要展示的窗口
  57.         self.__window = window
  58.         # 展示的控件
  59.         self.__surface = pygame.image.load('img/bullet_10.png')
  60.         # 控件宽度和高度
  61.         self.width = self.__surface.get_width()
  62.         self.height = self.__surface.get_height()
  63.  
  64.         # bx = px + (pw - bw) / 2
  65.         # by = py - bh / 2
  66.         self.__x = px + (pw - self.width) / 2
  67.         self.__y = py - self.height / 2
  68.         # 自动运行速度
  69.         self.__speed = 2
  70.  
  71.     def display(self):
  72.         '''
  73.         展示控件
  74.         :return:
  75.         '''
  76.         self.__window.blit(self.__surface, (self.__x, self.__y))
  77.         # 自动移动
  78.         self.autoMove()
  79.  
  80.     def autoMove(self):
  81.         '''
  82.         自动移动
  83.         :return:
  84.         '''
  85.         self.__y -= self.__speed
  86.  
  87.     def needDestroy(self):
  88.         '''
  89.         是否需要被销毁
  90.         :return:
  91.         '''
  92.         return self.__y <= -self.height
  93.  
  94.     def hasShootEnemey(self,enemy):
  95.         '''
  96.         是否已经射击到敌方飞机
  97.         :param enemy: EnemyPlane
  98.         :return:
  99.         '''
  100.         # 子弹矩形
  101.         bulletRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
  102.         # 敌方飞机矩形
  103.         enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
  104.  
  105.         return bulletRect.colliderect(enemyRect)
  106.  
  107.  
  108.  
  109. """------------------ 我方飞机类 ------------------"""
  110.  
  111.  
  112. class Plane:
  113.     def __init__(self, x, y, window):
  114.         # 坐标
  115.         self.__x = x
  116.         self.__y = y
  117.         # 被展示到的窗口
  118.         self.__window = window
  119.         # 飞机展示的Surface
  120.         self.__surface = pygame.image.load('img/hero2.png')
  121.         # 控件宽度和高度
  122.         self.width = self.__surface.get_width()
  123.         self.height = self.__surface.get_height()
  124.         # 运动速度
  125.         self.speed = 1
  126.         # 发射的子弹容器
  127.         self.__bullets = []
  128.  
  129.     def display(self):
  130.         '''
  131.         被展示
  132.         :return:
  133.         '''
  134.         print(len(self.__bullets))
  135.         # 展示我方飞机
  136.         self.__window.blit(self.__surface, (self.__x, self.__y))
  137.  
  138.         # 在循环遍历的时候做了移除元素的操作
  139.         # 先销毁越界子弹
  140.         # for bullet in self.__bullets:
  141.         #     # 如果子弹需要销毁
  142.         #     if bullet.needDestroy():
  143.         #         # 移除子弹对象
  144.         #         self.__bullets.remove(bullet)
  145.         #         # 内存销毁对象
  146.         #         del bullet
  147.         # 是否和敌方飞机发生了碰撞
  148.         for index in range(len(self.__bullets) - 1, -1, -1):
  149.             bullet = self.__bullets[index]
  150.             # bullet和enemy是否发生了碰撞
  151.             if bullet.hasShootEnemey(enemyPlane):
  152.                 # 子弹销毁
  153.                 self.__bullets.remove(bullet)
  154.                 del bullet
  155.                 # 敌方飞机打掉
  156.                 # 敌方飞机复用
  157.  
  158.  
  159.         # 展示
  160.         for index in range(len(self.__bullets) - 1, -1, -1):
  161.             bullet = self.__bullets[index]
  162.             if bullet.needDestroy():
  163.                 # 移除子弹对象
  164.                 self.__bullets.remove(bullet)
  165.                 # 内存销毁对象
  166.                 del bullet
  167.             else:
  168.                 # 把子弹展示出来
  169.                 bullet.display()
  170.  
  171.         # # 把所有发射的子弹渲染出来
  172.         # for bullet in self.__bullets:
  173.         #     # 把子弹展示出来
  174.         #     bullet.display()
  175.  
  176.     def fire(self):
  177.         '''
  178.         发射子弹
  179.         :return:
  180.         '''
  181.         # 子弹的x和y
  182.         # bx = px + (pw - bw) / 2
  183.         # by = py - bh / 2
  184.         # 创建子弹对象
  185.         bullet = Bullet(self.__x, self.__y, self.width, self.__window)
  186.         # 子弹对象添加到子弹列表中
  187.         self.__bullets.append(bullet)
  188.  
  189.     def moveLeft(self):
  190.         '''
  191.         向左移动
  192.         :return:
  193.         '''
  194.         self.__x -= self.speed
  195.         # 越界处理
  196.         if self.__x < 0:
  197.             self.__x = 0
  198.  
  199.     def moveRight(self):
  200.         '''
  201.         向右移动
  202.         :return:
  203.         '''
  204.         self.__x += self.speed
  205.         # 越界处理
  206.         if self.__x > bgWidth - self.width:
  207.             self.__x = bgWidth - self.width
  208.  
  209.     def moveUp(self):
  210.         '''
  211.         向上移动
  212.         :return:
  213.         '''
  214.         self.__y -= self.speed
  215.         # 越界处理
  216.         if self.__y < 0:
  217.             self.__y = 0
  218.  
  219.     def moveDown(self):
  220.         '''
  221.         向下移动
  222.         :return:
  223.         '''
  224.         self.__y += self.speed
  225.         # 越界处理
  226.         if self.__y > bgHeight - self.height:
  227.             self.__y = bgHeight - self.height
  228.  
  229.  
  230. # 全局变量
  231. bgWidth = 0
  232. bgHeight = 0
  233.  
  234. # 敌方飞机
  235. enemyPlane = None
  236.  
  237. def start():
  238.     global bgWidth, bgHeight,enemyPlane
  239.     # 初始化
  240.     pygame.init()
  241.  
  242.     # 加载背景图片
  243.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  244.     # 获取背景图片的大小
  245.     bgWidth = bgSurface.get_width()
  246.     bgHeight = bgSurface.get_height()
  247.  
  248.     # 创建游戏窗口
  249.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  250.     # 窗口标题
  251.     pygame.display.set_caption('飞机大战')
  252.  
  253.     # 加载图标图片
  254.     iconSurface = pygame.image.load('img/app.ico')
  255.     # 设置图标
  256.     pygame.display.set_icon(iconSurface)
  257.  
  258.     # 创建飞机类
  259.     plane = Plane(200, 600, window)
  260.  
  261.     # 创建敌方飞机类
  262.     enemyPlane = EnemyPlane(100,0,window)
  263.  
  264.     # 保证窗口不关闭
  265.     while True:
  266.         # 展示背景
  267.         window.blit(bgSurface, (0, 0))
  268.         # 展示我方飞机
  269.         plane.display()
  270.         # 展示敌方飞机
  271.         enemyPlane.display()
  272.         # 刷新
  273.         pygame.display.flip()
  274.  
  275.         # 处理窗口关闭
  276.         eventList = pygame.event.get()
  277.         for event in eventList:
  278.             # 判断是否是退出类型
  279.             if event.type == QUIT:
  280.                 # 退出游戏
  281.                 pygame.quit()
  282.                 # 退出程序
  283.                 sys.exit()
  284.             elif event.type == KEYDOWN:
  285.                 if event.key == K_RETURN:
  286.                     # 发射子弹
  287.                     plane.fire()
  288.  
  289.         # 处理按压事件
  290.         # 返回所有键对应的状态 0:没有按压  1:有按压
  291.         states = pygame.key.get_pressed()
  292.         # 有按压事件
  293.         if 1 in states:
  294.             # 是否是关心的a d s w键
  295.             if states[K_a]:  # 0 1
  296.                 plane.moveLeft()
  297.             elif states[K_d]:
  298.                 plane.moveRight()
  299.             elif states[K_w]:
  300.                 plane.moveUp()
  301.             elif states[K_s]:
  302.                 plane.moveDown()
  303.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  304.             #     if event.key == K_a:
  305.             #         plane.moveLeft()
  306.             #     elif event.key == K_d:
  307.             #         plane.moveRight()
  308.             #     elif event.key == K_w:
  309.             #         plane.moveUp()
  310.             #     elif event.key == K_s:
  311.             #         plane.moveDown()
  312.  
  313.  
  314. if __name__ == '__main__':
  315.     start()

18.敌方飞机复用

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. import random
  14. """------------------ 敌方飞机类 ------------------"""
  15. class EnemyPlane:
  16.     def __init__(self, window):
  17.         # 被展示到的窗口
  18.         self.__window = window
  19.         # 自动移动
  20.         self.__speed = 1
  21.         # 重置
  22.         self.__reset()
  23.  
  24.     def getX(self):
  25.         return self.__x
  26.  
  27.     def getY(self):
  28.         return self.__y
  29.  
  30.     def display(self):
  31.         '''
  32.         被展示
  33.         :return:
  34.         '''
  35.         # 展示我方飞机
  36.         self.__window.blit(self.__surface, (self.__x, self.__y))
  37.         # 自动移动
  38.         self.autoMove()
  39.  
  40.     def autoMove(self):
  41.         '''
  42.         自动移动
  43.         :return:
  44.         '''
  45.         self.__y += self.__speed
  46.         # 如果越界 需要重置
  47.         if self.__y>bgHeight-self.height:
  48.             self.__reset()
  49.  
  50.     def reUse(self):
  51.         '''
  52.         飞机被打死后者飞机越界 需要重新复用飞机
  53.         :return:
  54.         '''
  55.         self.__reset()
  56.  
  57.     def __reset(self):
  58.         '''
  59.         重置
  60.         :return:
  61.         '''
  62.         # 飞机展示的Surface
  63.         self.__surface = pygame.image.load('img/img-plane_{}.png'.format(random.randint(1,7)))
  64.         # 控件宽度和高度
  65.         self.width = self.__surface.get_width()
  66.         self.height = self.__surface.get_height()
  67.         # 坐标
  68.         self.__x = random.randint(0,bgWidth-self.width)
  69.         self.__y = -self.height
  70.  
  71.  
  72. """------------------ 子弹类 ------------------"""
  73. class Bullet:
  74.     def __init__(self, px, py, pw, window):
  75.         # 需要展示的窗口
  76.         self.__window = window
  77.         # 展示的控件
  78.         self.__surface = pygame.image.load('img/bullet_10.png')
  79.         # 控件宽度和高度
  80.         self.width = self.__surface.get_width()
  81.         self.height = self.__surface.get_height()
  82.  
  83.         # bx = px + (pw - bw) / 2
  84.         # by = py - bh / 2
  85.         self.__x = px + (pw - self.width) / 2
  86.         self.__y = py - self.height / 2
  87.         # 自动运行速度
  88.         self.__speed = 2
  89.  
  90.     def display(self):
  91.         '''
  92.         展示控件
  93.         :return:
  94.         '''
  95.         self.__window.blit(self.__surface, (self.__x, self.__y))
  96.         # 自动移动
  97.         self.autoMove()
  98.  
  99.     def autoMove(self):
  100.         '''
  101.         自动移动
  102.         :return:
  103.         '''
  104.         self.__y -= self.__speed
  105.  
  106.     def needDestroy(self):
  107.         '''
  108.         是否需要被销毁
  109.         :return:
  110.         '''
  111.         return self.__y <= -self.height
  112.  
  113.     def hasShootEnemey(self,enemy):
  114.         '''
  115.         是否已经射击到敌方飞机
  116.         :param enemy: EnemyPlane
  117.         :return:
  118.         '''
  119.         # 子弹矩形
  120.         bulletRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
  121.         # 敌方飞机矩形
  122.         enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
  123.  
  124.         return bulletRect.colliderect(enemyRect)
  125.  
  126.  
  127.  
  128. """------------------ 我方飞机类 ------------------"""
  129.  
  130.  
  131. class Plane:
  132.     def __init__(self, x, y, window):
  133.         # 坐标
  134.         self.__x = x
  135.         self.__y = y
  136.         # 被展示到的窗口
  137.         self.__window = window
  138.         # 飞机展示的Surface
  139.         self.__surface = pygame.image.load('img/hero2.png')
  140.         # 控件宽度和高度
  141.         self.width = self.__surface.get_width()
  142.         self.height = self.__surface.get_height()
  143.         # 运动速度
  144.         self.speed = 1
  145.         # 发射的子弹容器
  146.         self.__bullets = []
  147.  
  148.     def display(self):
  149.         '''
  150.         被展示
  151.         :return:
  152.         '''
  153.         print(len(self.__bullets))
  154.         # 展示我方飞机
  155.         self.__window.blit(self.__surface, (self.__x, self.__y))
  156.  
  157.         # 在循环遍历的时候做了移除元素的操作
  158.         # 先销毁越界子弹
  159.         # for bullet in self.__bullets:
  160.         #     # 如果子弹需要销毁
  161.         #     if bullet.needDestroy():
  162.         #         # 移除子弹对象
  163.         #         self.__bullets.remove(bullet)
  164.         #         # 内存销毁对象
  165.         #         del bullet
  166.         # 是否和敌方飞机发生了碰撞
  167.         for index in range(len(self.__bullets) - 1, -1, -1):
  168.             bullet = self.__bullets[index]
  169.             # bullet和enemy是否发生了碰撞
  170.             if bullet.hasShootEnemey(enemyPlane):
  171.                 # 子弹销毁
  172.                 self.__bullets.remove(bullet)
  173.                 del bullet
  174.                 # 敌方飞机打掉
  175.                 # 敌方飞机复用
  176.                 enemyPlane.reUse()
  177.  
  178.  
  179.         # 展示
  180.         for index in range(len(self.__bullets) - 1, -1, -1):
  181.             bullet = self.__bullets[index]
  182.             if bullet.needDestroy():
  183.                 # 移除子弹对象
  184.                 self.__bullets.remove(bullet)
  185.                 # 内存销毁对象
  186.                 del bullet
  187.             else:
  188.                 # 把子弹展示出来
  189.                 bullet.display()
  190.  
  191.         # # 把所有发射的子弹渲染出来
  192.         # for bullet in self.__bullets:
  193.         #     # 把子弹展示出来
  194.         #     bullet.display()
  195.  
  196.     def fire(self):
  197.         '''
  198.         发射子弹
  199.         :return:
  200.         '''
  201.         # 子弹的x和y
  202.         # bx = px + (pw - bw) / 2
  203.         # by = py - bh / 2
  204.         # 创建子弹对象
  205.         bullet = Bullet(self.__x, self.__y, self.width, self.__window)
  206.         # 子弹对象添加到子弹列表中
  207.         self.__bullets.append(bullet)
  208.  
  209.     def moveLeft(self):
  210.         '''
  211.         向左移动
  212.         :return:
  213.         '''
  214.         self.__x -= self.speed
  215.         # 越界处理
  216.         if self.__x < 0:
  217.             self.__x = 0
  218.  
  219.     def moveRight(self):
  220.         '''
  221.         向右移动
  222.         :return:
  223.         '''
  224.         self.__x += self.speed
  225.         # 越界处理
  226.         if self.__x > bgWidth - self.width:
  227.             self.__x = bgWidth - self.width
  228.  
  229.     def moveUp(self):
  230.         '''
  231.         向上移动
  232.         :return:
  233.         '''
  234.         self.__y -= self.speed
  235.         # 越界处理
  236.         if self.__y < 0:
  237.             self.__y = 0
  238.  
  239.     def moveDown(self):
  240.         '''
  241.         向下移动
  242.         :return:
  243.         '''
  244.         self.__y += self.speed
  245.         # 越界处理
  246.         if self.__y > bgHeight - self.height:
  247.             self.__y = bgHeight - self.height
  248.  
  249.  
  250. # 全局变量
  251. bgWidth = 0
  252. bgHeight = 0
  253.  
  254. # 敌方飞机
  255. enemyPlane = None
  256.  
  257. def start():
  258.     global bgWidth, bgHeight,enemyPlane
  259.     # 初始化
  260.     pygame.init()
  261.  
  262.     # 加载背景图片
  263.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  264.     # 获取背景图片的大小
  265.     bgWidth = bgSurface.get_width()
  266.     bgHeight = bgSurface.get_height()
  267.  
  268.     # 创建游戏窗口
  269.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  270.     # 窗口标题
  271.     pygame.display.set_caption('飞机大战')
  272.  
  273.     # 加载图标图片
  274.     iconSurface = pygame.image.load('img/app.ico')
  275.     # 设置图标
  276.     pygame.display.set_icon(iconSurface)
  277.  
  278.     # 创建飞机类
  279.     plane = Plane(200, 600, window)
  280.  
  281.     # 创建敌方飞机类
  282.     enemyPlane = EnemyPlane(window)
  283.  
  284.     # 保证窗口不关闭
  285.     while True:
  286.         # 展示背景
  287.         window.blit(bgSurface, (0, 0))
  288.         # 展示我方飞机
  289.         plane.display()
  290.         # 展示敌方飞机
  291.         enemyPlane.display()
  292.         # 刷新
  293.         pygame.display.flip()
  294.  
  295.         # 处理窗口关闭
  296.         eventList = pygame.event.get()
  297.         for event in eventList:
  298.             # 判断是否是退出类型
  299.             if event.type == QUIT:
  300.                 # 退出游戏
  301.                 pygame.quit()
  302.                 # 退出程序
  303.                 sys.exit()
  304.             elif event.type == KEYDOWN:
  305.                 if event.key == K_RETURN:
  306.                     # 发射子弹
  307.                     plane.fire()
  308.  
  309.         # 处理按压事件
  310.         # 返回所有键对应的状态 0:没有按压  1:有按压
  311.         states = pygame.key.get_pressed()
  312.         # 有按压事件
  313.         if 1 in states:
  314.             # 是否是关心的a d s w键
  315.             if states[K_a]:  # 0 1
  316.                 plane.moveLeft()
  317.             elif states[K_d]:
  318.                 plane.moveRight()
  319.             elif states[K_w]:
  320.                 plane.moveUp()
  321.             elif states[K_s]:
  322.                 plane.moveDown()
  323.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  324.             #     if event.key == K_a:
  325.             #         plane.moveLeft()
  326.             #     elif event.key == K_d:
  327.             #         plane.moveRight()
  328.             #     elif event.key == K_w:
  329.             #         plane.moveUp()
  330.             #     elif event.key == K_s:
  331.             #         plane.moveDown()
  332.  
  333.  
  334. if __name__ == '__main__':
  335.     start()

批量产生敌方飞机:

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. import random
  14. """------------------ 敌方飞机类 ------------------"""
  15. class EnemyPlane:
  16.     def __init__(self, window):
  17.         # 被展示到的窗口
  18.         self.__window = window
  19.         # 自动移动
  20.         self.__speed = 1
  21.         # 重置
  22.         self.__reset()
  23.  
  24.     def getX(self):
  25.         return self.__x
  26.  
  27.     def getY(self):
  28.         return self.__y
  29.  
  30.     def display(self):
  31.         '''
  32.         被展示
  33.         :return:
  34.         '''
  35.         # 展示我方飞机
  36.         self.__window.blit(self.__surface, (self.__x, self.__y))
  37.         # 自动移动
  38.         self.autoMove()
  39.  
  40.     def autoMove(self):
  41.         '''
  42.         自动移动
  43.         :return:
  44.         '''
  45.         self.__y += self.__speed
  46.         # 如果越界 需要重置
  47.         if self.__y>bgHeight-self.height:
  48.             self.__reset()
  49.  
  50.     def reUse(self):
  51.         '''
  52.         飞机被打死后者飞机越界 需要重新复用飞机
  53.         :return:
  54.         '''
  55.         self.__reset()
  56.  
  57.     def __reset(self):
  58.         '''
  59.         重置
  60.         :return:
  61.         '''
  62.         # 飞机展示的Surface
  63.         self.__surface = pygame.image.load('img/img-plane_{}.png'.format(random.randint(1,7)))
  64.         # 控件宽度和高度
  65.         self.width = self.__surface.get_width()
  66.         self.height = self.__surface.get_height()
  67.         # 坐标
  68.         self.__x = random.randint(0,bgWidth-self.width)
  69.         self.__y = -random.randint(3*self.height,10*self.height)
  70.  
  71.  
  72. """------------------ 子弹类 ------------------"""
  73. class Bullet:
  74.     def __init__(self, px, py, pw, window):
  75.         # 需要展示的窗口
  76.         self.__window = window
  77.         # 展示的控件
  78.         self.__surface = pygame.image.load('img/bullet_10.png')
  79.         # 控件宽度和高度
  80.         self.width = self.__surface.get_width()
  81.         self.height = self.__surface.get_height()
  82.  
  83.         # bx = px + (pw - bw) / 2
  84.         # by = py - bh / 2
  85.         self.__x = px + (pw - self.width) / 2
  86.         self.__y = py - self.height / 2
  87.         # 自动运行速度
  88.         self.__speed = 2
  89.  
  90.     def display(self):
  91.         '''
  92.         展示控件
  93.         :return:
  94.         '''
  95.         self.__window.blit(self.__surface, (self.__x, self.__y))
  96.         # 自动移动
  97.         self.autoMove()
  98.  
  99.     def autoMove(self):
  100.         '''
  101.         自动移动
  102.         :return:
  103.         '''
  104.         self.__y -= self.__speed
  105.  
  106.     def needDestroy(self):
  107.         '''
  108.         是否需要被销毁
  109.         :return:
  110.         '''
  111.         return self.__y <= -self.height
  112.  
  113.     def hasShootEnemey(self,enemy):
  114.         '''
  115.         是否已经射击到敌方飞机
  116.         :param enemy: EnemyPlane
  117.         :return:
  118.         '''
  119.         # 子弹矩形
  120.         bulletRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
  121.         # 敌方飞机矩形
  122.         enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
  123.  
  124.         return bulletRect.colliderect(enemyRect)
  125.  
  126.  
  127.  
  128. """------------------ 我方飞机类 ------------------"""
  129.  
  130.  
  131. class Plane:
  132.     def __init__(self, x, y, window):
  133.         # 坐标
  134.         self.__x = x
  135.         self.__y = y
  136.         # 被展示到的窗口
  137.         self.__window = window
  138.         # 飞机展示的Surface
  139.         self.__surface = pygame.image.load('img/hero2.png')
  140.         # 控件宽度和高度
  141.         self.width = self.__surface.get_width()
  142.         self.height = self.__surface.get_height()
  143.         # 运动速度
  144.         self.speed = 1
  145.         # 发射的子弹容器
  146.         self.__bullets = []
  147.         # 血量值
  148.         self.blood = 5
  149.  
  150.     def hasCollision(self,enemy):
  151.         '''
  152.         是否和敌方飞机发生了碰撞
  153.         :param enemy:
  154.         :return:
  155.         '''
  156.         # 我方飞机矩形
  157.         myRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
  158.         # 敌方飞机矩形
  159.         enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
  160.         return myRect.colliderect(enemyRect)
  161.  
  162.     def display(self):
  163.         '''
  164.         被展示
  165.         :return:
  166.         '''
  167.         # 展示我方飞机
  168.         self.__window.blit(self.__surface, (self.__x, self.__y))
  169.  
  170.         # 在循环遍历的时候做了移除元素的操作
  171.         # 先销毁越界子弹
  172.         # for bullet in self.__bullets:
  173.         #     # 如果子弹需要销毁
  174.         #     if bullet.needDestroy():
  175.         #         # 移除子弹对象
  176.         #         self.__bullets.remove(bullet)
  177.         #         # 内存销毁对象
  178.         #         del bullet
  179.  
  180.         # 检测我方飞机和敌方飞机是否发生了碰撞
  181.         for enemy in enemyList:
  182.             # 判断是否发生了碰撞
  183.             if self.hasCollision(enemy):
  184.                 # 我方飞机掉血
  185.                 self.blood -= 1
  186.                 print('血量',self.blood)
  187.                 # 敌方飞机重复使用
  188.                 enemy.reUse()
  189.  
  190.         # 子弹是否和敌方飞机发生了碰撞
  191.         for index in range(len(self.__bullets) - 1, -1, -1):
  192.             bullet = self.__bullets[index]
  193.             for enemy in enemyList:
  194.                 # bullet和enemy是否发生了碰撞
  195.                 if bullet.hasShootEnemey(enemy):
  196.                     # 子弹销毁
  197.                     self.__bullets.remove(bullet)
  198.                     del bullet
  199.                     # 敌方飞机打掉
  200.                     # 敌方飞机复用
  201.                     enemy.reUse()
  202.                     # 退出里层循环
  203.                     break
  204.  
  205.  
  206.  
  207.  
  208.         # 展示
  209.         for index in range(len(self.__bullets) - 1, -1, -1):
  210.             bullet = self.__bullets[index]
  211.             if bullet.needDestroy():
  212.                 # 移除子弹对象
  213.                 self.__bullets.remove(bullet)
  214.                 # 内存销毁对象
  215.                 del bullet
  216.             else:
  217.                 # 把子弹展示出来
  218.                 bullet.display()
  219.  
  220.         # # 把所有发射的子弹渲染出来
  221.         # for bullet in self.__bullets:
  222.         #     # 把子弹展示出来
  223.         #     bullet.display()
  224.  
  225.     def fire(self):
  226.         '''
  227.         发射子弹
  228.         :return:
  229.         '''
  230.         # 子弹的x和y
  231.         # bx = px + (pw - bw) / 2
  232.         # by = py - bh / 2
  233.         # 创建子弹对象
  234.         bullet = Bullet(self.__x, self.__y, self.width, self.__window)
  235.         # 子弹对象添加到子弹列表中
  236.         self.__bullets.append(bullet)
  237.  
  238.     def moveLeft(self):
  239.         '''
  240.         向左移动
  241.         :return:
  242.         '''
  243.         self.__x -= self.speed
  244.         # 越界处理
  245.         if self.__x < 0:
  246.             self.__x = 0
  247.  
  248.     def moveRight(self):
  249.         '''
  250.         向右移动
  251.         :return:
  252.         '''
  253.         self.__x += self.speed
  254.         # 越界处理
  255.         if self.__x > bgWidth - self.width:
  256.             self.__x = bgWidth - self.width
  257.  
  258.     def moveUp(self):
  259.         '''
  260.         向上移动
  261.         :return:
  262.         '''
  263.         self.__y -= self.speed
  264.         # 越界处理
  265.         if self.__y < 0:
  266.             self.__y = 0
  267.  
  268.     def moveDown(self):
  269.         '''
  270.         向下移动
  271.         :return:
  272.         '''
  273.         self.__y += self.speed
  274.         # 越界处理
  275.         if self.__y > bgHeight - self.height:
  276.             self.__y = bgHeight - self.height
  277.  
  278.  
  279. # 全局变量
  280. bgWidth = 0
  281. bgHeight = 0
  282.  
  283. # 敌方飞机
  284. enemyList = []
  285.  
  286. def start():
  287.     global bgWidth, bgHeight,enemyPlane
  288.     # 初始化
  289.     pygame.init()
  290.  
  291.     # 加载背景图片
  292.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  293.     # 获取背景图片的大小
  294.     bgWidth = bgSurface.get_width()
  295.     bgHeight = bgSurface.get_height()
  296.  
  297.     # 创建游戏窗口
  298.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  299.     # 窗口标题
  300.     pygame.display.set_caption('飞机大战')
  301.  
  302.     # 加载图标图片
  303.     iconSurface = pygame.image.load('img/app.ico')
  304.     # 设置图标
  305.     pygame.display.set_icon(iconSurface)
  306.  
  307.     # 创建飞机类
  308.     plane = Plane(200, 600, window)
  309.  
  310.     # 创建5个敌方飞机对象
  311.     for index in range(0,5):
  312.         enemyList.append(EnemyPlane(window))
  313.  
  314.     # 保证窗口不关闭
  315.     while True:
  316.         # 展示背景
  317.         window.blit(bgSurface, (0, 0))
  318.         # 展示我方飞机
  319.         plane.display()
  320.         # 展示敌方飞机
  321.         for enemy in enemyList:
  322.             enemy.display()
  323.  
  324.         # 刷新
  325.         pygame.display.flip()
  326.  
  327.         # 处理窗口关闭
  328.         eventList = pygame.event.get()
  329.         for event in eventList:
  330.             # 判断是否是退出类型
  331.             if event.type == QUIT:
  332.                 # 退出游戏
  333.                 pygame.quit()
  334.                 # 退出程序
  335.                 sys.exit()
  336.             elif event.type == KEYDOWN:
  337.                 if event.key == K_RETURN:
  338.                     # 发射子弹
  339.                     plane.fire()
  340.  
  341.         # 处理按压事件
  342.         # 返回所有键对应的状态 0:没有按压  1:有按压
  343.         states = pygame.key.get_pressed()
  344.         # 有按压事件
  345.         if 1 in states:
  346.             # 是否是关心的a d s w键
  347.             if states[K_a]:  # 0 1
  348.                 plane.moveLeft()
  349.             elif states[K_d]:
  350.                 plane.moveRight()
  351.             elif states[K_w]:
  352.                 plane.moveUp()
  353.             elif states[K_s]:
  354.                 plane.moveDown()
  355.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  356.             #     if event.key == K_a:
  357.             #         plane.moveLeft()
  358.             #     elif event.key == K_d:
  359.             #         plane.moveRight()
  360.             #     elif event.key == K_w:
  361.             #         plane.moveUp()
  362.             #     elif event.key == K_s:
  363.             #         plane.moveDown()
  364.  
  365.  
  366. if __name__ == '__main__':
  367.     start()

20.游戏结束

  1. import pygame
  2. from pygame.locals import *
  3. import sys
  4.  
  5. """
  6. 1.标题和图标
  7. 2.退出事件
  8. """
  9. """
  10. 飞机属性: x,y window
  11. 飞机行为:被展示行为display
  12. """
  13. import random
  14. """------------------ 敌方飞机类 ------------------"""
  15. class EnemyPlane:
  16.     def __init__(self, window):
  17.         # 被展示到的窗口
  18.         self.__window = window
  19.         # 自动移动
  20.         self.__speed = 1
  21.         # 重置
  22.         self.__reset()
  23.  
  24.     def getX(self):
  25.         return self.__x
  26.  
  27.     def getY(self):
  28.         return self.__y
  29.  
  30.     def display(self):
  31.         '''
  32.         被展示
  33.         :return:
  34.         '''
  35.         # 展示我方飞机
  36.         self.__window.blit(self.__surface, (self.__x, self.__y))
  37.  
  38.  
  39.     def autoMove(self):
  40.         '''
  41.         自动移动
  42.         :return:
  43.         '''
  44.         self.__y += self.__speed
  45.         # 如果越界 需要重置
  46.         if self.__y>bgHeight-self.height:
  47.             self.__reset()
  48.  
  49.     def reUse(self):
  50.         '''
  51.         飞机被打死后者飞机越界 需要重新复用飞机
  52.         :return:
  53.         '''
  54.         self.__reset()
  55.  
  56.     def __reset(self):
  57.         '''
  58.         重置
  59.         :return:
  60.         '''
  61.         # 飞机展示的Surface
  62.         self.__surface = pygame.image.load('img/img-plane_{}.png'.format(random.randint(1,7)))
  63.         # 控件宽度和高度
  64.         self.width = self.__surface.get_width()
  65.         self.height = self.__surface.get_height()
  66.         # 坐标
  67.         self.__x = random.randint(0,bgWidth-self.width)
  68.         self.__y = -random.randint(3*self.height,10*self.height)
  69.  
  70.  
  71. """------------------ 子弹类 ------------------"""
  72. class Bullet:
  73.     def __init__(self, px, py, pw, window):
  74.         # 需要展示的窗口
  75.         self.__window = window
  76.         # 展示的控件
  77.         self.__surface = pygame.image.load('img/bullet_10.png')
  78.         # 控件宽度和高度
  79.         self.width = self.__surface.get_width()
  80.         self.height = self.__surface.get_height()
  81.  
  82.         # bx = px + (pw - bw) / 2
  83.         # by = py - bh / 2
  84.         self.__x = px + (pw - self.width) / 2
  85.         self.__y = py - self.height / 2
  86.         # 自动运行速度
  87.         self.__speed = 2
  88.  
  89.     def display(self):
  90.         '''
  91.         展示控件
  92.         :return:
  93.         '''
  94.         self.__window.blit(self.__surface, (self.__x, self.__y))
  95.         # 自动移动
  96.         self.autoMove()
  97.  
  98.     def autoMove(self):
  99.         '''
  100.         自动移动
  101.         :return:
  102.         '''
  103.         self.__y -= self.__speed
  104.  
  105.     def needDestroy(self):
  106.         '''
  107.         是否需要被销毁
  108.         :return:
  109.         '''
  110.         return self.__y <= -self.height
  111.  
  112.     def hasShootEnemey(self,enemy):
  113.         '''
  114.         是否已经射击到敌方飞机
  115.         :param enemy: EnemyPlane
  116.         :return:
  117.         '''
  118.         # 子弹矩形
  119.         bulletRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
  120.         # 敌方飞机矩形
  121.         enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
  122.  
  123.         return bulletRect.colliderect(enemyRect)
  124.  
  125.  
  126.  
  127. """------------------ 我方飞机类 ------------------"""
  128.  
  129.  
  130. class Plane:
  131.     def __init__(self, x, y, window):
  132.         # 坐标
  133.         self.__x = x
  134.         self.__y = y
  135.         # 被展示到的窗口
  136.         self.__window = window
  137.         # 飞机展示的Surface
  138.         self.__surface = pygame.image.load('img/hero2.png')
  139.         # 控件宽度和高度
  140.         self.width = self.__surface.get_width()
  141.         self.height = self.__surface.get_height()
  142.         # 运动速度
  143.         self.speed = 1
  144.         # 发射的子弹容器
  145.         self.__bullets = []
  146.         # 血量值
  147.         self.blood = 5
  148.  
  149.     def hasCollision(self,enemy):
  150.         '''
  151.         是否和敌方飞机发生了碰撞
  152.         :param enemy:
  153.         :return:
  154.         '''
  155.         # 我方飞机矩形
  156.         myRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
  157.         # 敌方飞机矩形
  158.         enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
  159.         return myRect.colliderect(enemyRect)
  160.  
  161.     def display(self):
  162.         '''
  163.         被展示
  164.         :return:
  165.         '''
  166.         # 展示我方飞机
  167.         self.__window.blit(self.__surface, (self.__x, self.__y))
  168.  
  169.         # 在循环遍历的时候做了移除元素的操作
  170.         # 先销毁越界子弹
  171.         # for bullet in self.__bullets:
  172.         #     # 如果子弹需要销毁
  173.         #     if bullet.needDestroy():
  174.         #         # 移除子弹对象
  175.         #         self.__bullets.remove(bullet)
  176.         #         # 内存销毁对象
  177.         #         del bullet
  178.  
  179.         # 检测我方飞机和敌方飞机是否发生了碰撞
  180.         for enemy in enemyList:
  181.             # 判断是否发生了碰撞
  182.             if self.hasCollision(enemy):
  183.                 # 我方飞机掉血
  184.                 self.blood -= 1
  185.                 print('血量',self.blood)
  186.                 # 敌方飞机重复使用
  187.                 enemy.reUse()
  188.  
  189.         # 子弹是否和敌方飞机发生了碰撞
  190.         for index in range(len(self.__bullets) - 1, -1, -1):
  191.             bullet = self.__bullets[index]
  192.             for enemy in enemyList:
  193.                 # bullet和enemy是否发生了碰撞
  194.                 if bullet.hasShootEnemey(enemy):
  195.                     # 子弹销毁
  196.                     self.__bullets.remove(bullet)
  197.                     del bullet
  198.                     # 敌方飞机打掉
  199.                     # 敌方飞机复用
  200.                     enemy.reUse()
  201.                     # 退出里层循环
  202.                     break
  203.  
  204.  
  205.  
  206.  
  207.         # 展示
  208.         for index in range(len(self.__bullets) - 1, -1, -1):
  209.             bullet = self.__bullets[index]
  210.             if bullet.needDestroy():
  211.                 # 移除子弹对象
  212.                 self.__bullets.remove(bullet)
  213.                 # 内存销毁对象
  214.                 del bullet
  215.             else:
  216.                 # 把子弹展示出来
  217.                 bullet.display()
  218.  
  219.         # # 把所有发射的子弹渲染出来
  220.         # for bullet in self.__bullets:
  221.         #     # 把子弹展示出来
  222.         #     bullet.display()
  223.  
  224.     def fire(self):
  225.         '''
  226.         发射子弹
  227.         :return:
  228.         '''
  229.         # 子弹的x和y
  230.         # bx = px + (pw - bw) / 2
  231.         # by = py - bh / 2
  232.         # 创建子弹对象
  233.         bullet = Bullet(self.__x, self.__y, self.width, self.__window)
  234.         # 子弹对象添加到子弹列表中
  235.         self.__bullets.append(bullet)
  236.  
  237.     def moveLeft(self):
  238.         '''
  239.         向左移动
  240.         :return:
  241.         '''
  242.         self.__x -= self.speed
  243.         # 越界处理
  244.         if self.__x < 0:
  245.             self.__x = 0
  246.  
  247.     def moveRight(self):
  248.         '''
  249.         向右移动
  250.         :return:
  251.         '''
  252.         self.__x += self.speed
  253.         # 越界处理
  254.         if self.__x > bgWidth - self.width:
  255.             self.__x = bgWidth - self.width
  256.  
  257.     def moveUp(self):
  258.         '''
  259.         向上移动
  260.         :return:
  261.         '''
  262.         self.__y -= self.speed
  263.         # 越界处理
  264.         if self.__y < 0:
  265.             self.__y = 0
  266.  
  267.     def moveDown(self):
  268.         '''
  269.         向下移动
  270.         :return:
  271.         '''
  272.         self.__y += self.speed
  273.         # 越界处理
  274.         if self.__y > bgHeight - self.height:
  275.             self.__y = bgHeight - self.height
  276.  
  277.  
  278. # 全局变量
  279. bgWidth = 0
  280. bgHeight = 0
  281.  
  282. # 敌方飞机
  283. enemyList = []
  284.  
  285. def start():
  286.     global bgWidth, bgHeight,enemyPlane
  287.     # 初始化
  288.     pygame.init()
  289.  
  290.     # 加载背景图片
  291.     bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
  292.     # 获取背景图片的大小
  293.     bgWidth = bgSurface.get_width()
  294.     bgHeight = bgSurface.get_height()
  295.  
  296.     # 创建游戏窗口
  297.     window = pygame.display.set_mode(size=(bgWidth, bgHeight))
  298.     # 窗口标题
  299.     pygame.display.set_caption('飞机大战')
  300.  
  301.     # 加载图标图片
  302.     iconSurface = pygame.image.load('img/app.ico')
  303.     # 设置图标
  304.     pygame.display.set_icon(iconSurface)
  305.  
  306.     # 创建飞机类
  307.     plane = Plane(200, 600, window)
  308.  
  309.     # 创建5个敌方飞机对象
  310.     for index in range(0,5):
  311.         enemyList.append(EnemyPlane(window))
  312.  
  313.     # 游戏结束文字
  314.     font = pygame.font.Font('font/happy.ttf',50)
  315.     gameOverSurface = font.render('游戏结束',True,(255,255,255))
  316.  
  317.     # 保证窗口不关闭
  318.     while True:
  319.         # 展示背景
  320.         window.blit(bgSurface, (0, 0))
  321.         # 展示我方飞机
  322.         plane.display()
  323.  
  324.         # 展示敌方飞机
  325.         for enemy in enemyList:
  326.             enemy.display()
  327.  
  328.         # 处理窗口关闭
  329.         eventList = pygame.event.get()
  330.         for event in eventList:
  331.             # 判断是否是退出类型
  332.             if event.type == QUIT:
  333.                 # 退出游戏
  334.                 pygame.quit()
  335.                 # 退出程序
  336.                 sys.exit()
  337.             elif event.type == KEYDOWN:
  338.                 if event.key == K_RETURN:
  339.                     # 发射子弹
  340.                     plane.fire()
  341.         # 检测是否停止
  342.         if plane.blood<=0:
  343.             # 游戏停止
  344.             window.blit(gameOverSurface,((bgWidth-gameOverSurface.get_width())/2,(bgHeight-gameOverSurface.get_height())/2))
  345.             # 刷新
  346.             pygame.display.flip()
  347.             continue
  348.  
  349.  
  350.         # 敌方飞机自动移动
  351.         for enemy in enemyList:
  352.             enemy.autoMove()
  353.  
  354.         # 刷新
  355.         pygame.display.flip()
  356.  
  357.         # 处理窗口关闭
  358.         eventList = pygame.event.get()
  359.         for event in eventList:
  360.             # 判断是否是退出类型
  361.             if event.type == QUIT:
  362.                 # 退出游戏
  363.                 pygame.quit()
  364.                 # 退出程序
  365.                 sys.exit()
  366.             elif event.type == KEYDOWN:
  367.                 if event.key == K_RETURN:
  368.                     # 发射子弹
  369.                     plane.fire()
  370.  
  371.         # 处理按压事件
  372.         # 返回所有键对应的状态 0:没有按压  1:有按压
  373.         states = pygame.key.get_pressed()
  374.         # 有按压事件
  375.         if 1 in states:
  376.             # 是否是关心的a d s w键
  377.             if states[K_a]:  # 0 1
  378.                 plane.moveLeft()
  379.             elif states[K_d]:
  380.                 plane.moveRight()
  381.             elif states[K_w]:
  382.                 plane.moveUp()
  383.             elif states[K_s]:
  384.                 plane.moveDown()
  385.             # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
  386.             #     if event.key == K_a:
  387.             #         plane.moveLeft()
  388.             #     elif event.key == K_d:
  389.             #         plane.moveRight()
  390.             #     elif event.key == K_w:
  391.             #         plane.moveUp()
  392.             #     elif event.key == K_s:
  393.             #         plane.moveDown()
  394.  
  395.  
  396. if __name__ == '__main__':
  397.     start()

代码下载:

链接: https://pan.baidu.com/s/1yScaUX3Aumos_iMrI4ZKjw 提取码: xwct 

注意:

打包时把所有的图片和文字路径改成绝对路径:

程序打包

PyInstaller

将Python应用打包成可执行文件

安装和使用

安装:

pip install pyinstaller

打包命令:

pyinstaller-F xx.py -w

最后说下-p这个参数

                -p：添加搜索路径

这个参数是告诉打包工具到哪去搜索依耐性文件，此次我们没有使用-p参数是因为工具默认为到python安装路径下的Lib 以及 Lib文件夹下的site-packages。

Lib文件夹下是python自带的一些库，site-packages为pip安装的库。此次的第三方库我都是通过pip安装的，所以不用加-p参数。如果使用了第三方库并且不再这两个路径下的需要加上：-p 库地址，告诉打包工具你使用的库在哪
 

3.更改exe文件的图标

自定义打包出来的exe文件图标，需要使用-i参数，同时需要准备一个ico格式的图片，贴上一个在线ico制作网站：

ico图片转换

pyinstaller -F --icon=1234.ico run.py

打包好的下载:

链接: https://pan.baidu.com/s/1EFsyTRQ6C6S82c0Tw33OYA 提取码: qkc6

注意: 如果打包后打不开文件,就把代码中用到的资源路径改成绝对路径后在打包