python面向對象編程實例：飛機大戰

說明：此則博客只是自己學習python編程的學習記錄，其中完成的程序設計只是飛機大戰的小小小demo，只爲自己熟悉python語言和pygame，所以程序並不完善，只當練手和記錄，當然可基於次程序進行後續的完善開發。最後感謝一下hm的python教程。至於程序中的圖片素材，如果大家有需要可在本文下方留言，可私發。

開頭 祭出程序開發文檔：

#01. 使用pygame創建圖形窗口


#1.1 遊戲的初始化和退出
# 方法：           說明：
#   pygame.init()   導入並初始化所有pygame模塊
#   pygame.quit()   卸載所有pygame模塊，在遊戲結束之前調用


#1.2 理解遊戲中的座標系
# ·座標系：
#      1. 原點在左上角(0,0)
#      2. x軸水平方法向右，逐漸增加
#      3. y軸垂直方向向下，逐漸增加


# ·在遊戲中，所有的可見元素都是以矩形區域來描述位置的
#      1.要描述一個矩形區域有四個元素：(x, y) (width, heigth)


# ·pygame專門提供了一個類pygame.Rect用於描述矩形區域
#      Rect(x, y, width, heigth) -> Rect


#1.3 創建遊戲的主窗口
# ·pygame專門提供了一個模塊pygame.display用於創建，管理遊戲窗口
#     方法：                         說明：
#       pygame.display.set_mode()     初始化遊戲顯示窗口
#       pygame.display.update()       刷新屏幕內容顯示，稍後使用
#     使用：
#       set_mode(resolution=(0,0), flags=0, depth=0) -> Surface
# ·參數
#     1.resolution指定屏幕的寬和高，默認創建的窗口大小和屏幕大小一致
#     2.flags參數指定屏幕的附加選項，例如是否全屏等等，默認不需要傳遞
#     3.depth參數表示顏色的位數，默認自動匹配
# ·注意
#     必須使用變量記錄set_mode方法的返回結果！因爲：後續所有的圖像繪製都基於這個返回結果




#02. 理解圖像並實現圖像繪製
# ·在屏幕上看到某一個圖像的內容，需要三個步驟：
#     1.使用pygame.image.load()加載圖像的數據
#     2.使用遊戲屏幕對象，調用blit方法將圖像繪製到指定的位置
#     3.調用pygame.display.update()方法更新整個屏幕的顯示




#03. 理解遊戲循環和遊戲時鐘
#3.1 遊戲中的動畫實現原理
#    一秒60幀的高質量視頻


#3.2 遊戲循環
#    1.設置刷新幀率
#    2.檢測用戶交互
#    3.更新所有的圖像位置
#    4.更新屏幕顯示


#3.3 遊戲時鐘
# ·pygame專門提供了一個類pygame.time.Clock可以非常方便的設置屏幕繪製速度--刷新幀率
# ·使用時鐘步驟：
#            1.在遊戲初始化創建一個時鐘對象
#            2.在遊戲循環中讓時鐘對象調用tick（幀率）方法
# ·tick方法會根據上次被調用的時間，自動設置遊戲循環中的延時


#3.4 英雄的簡單動畫實現
# ·提示：
#      1.每一次調用update()方法之前，需要把所有的遊戲圖像都重新繪製一遍
#      2.而且應該最先重新繪製背景圖像


#3.5 在遊戲循環中監聽事件
# ·事件 event
#       ·就是遊戲啓動後，用戶針對遊戲所做的操作
#       ·例如：點擊關閉按鈕，點擊鼠標，按下鍵盤
# ·監聽
#       ·在遊戲循環中，判斷用戶具體的操作（只有捕獲到用戶具體的操作，纔能有針對性的做出相應）
# ·實現
#       ·pygame中通過pygame.event.get()可以獲得用戶當前所做動作的事件列表




#04. 理解精靈和精靈組
#4.1 精靈和精靈組
# ·爲了簡化開發步驟，pygame提供了兩個類
#       1.pygame.sprite.Sprite -- 存儲圖像數據image和位置rect的對象
#       2.pygame.sprite.Group
# ·精靈
#       image    記錄圖像數據
#       rect     記錄在屏幕上的位置
#       update(*args): 更新精靈位置
#       kill():        從所有組中刪除
# ·精靈組
#       __init__(self, *精靈):
#       add(*sprites):    向組中增加精靈
#       sprites():        返回所有精靈列表
#       upadte(*args):    讓組中所有精靈調用update方法
#       draw(Surface):    將組中所有精靈的image，繪製到Surface的rect位置


#4.2 派生精靈子類
# ·定義如下GameSprite繼承自pygame.sprite.Sprite
# ·GameSprite
#       image       精靈圖像，使用image_name加載
#       rect        精靈大小，默認使用圖像大小
#       speed       精靈移動速度，默認爲1
#       __init————(self, image_name, speed=1):
#       update(self):       每次更新屏幕時在遊戲循環內調用，讓精靈的self.rect.y += self.speed
# ·注意
#       ·在重寫初始化方法時，一定要先super()一下父類的__int__方法
#       ·進而保證父類中實現的__init__代碼能夠被正常執行
# ·提示
#       ·image的get_rect()方法，可以返回pygame.Rect(0, 0, 圖像寬， 圖像高）的對象


#4.3 使用遊戲精靈和精靈組創建敵機
# ·精靈
#       ·封裝image，rect，speed
#       ·提供update()方法，根據遊戲需求，更新位置rect
# ·精靈組
#       ·包含多個精靈組
#       ·update方法，讓精靈組中的所有精靈調用update方法更新位置
#       ·draw(screen)方法，在screen上繪製精靈組中的所有精靈




# 遊戲框架搭建
#01. 明確主程序職責
# ·遊戲主程序主要負責：
#       1.遊戲的初始化
#       2.遊戲循環


# ·設計PlaneGame類
#       screen
#       clock
#       精靈或精靈組
# --------------------------
#       __init__(self):
#       __create_sprites(self):
#       start_game(self):
#       __event_handle(self):
#       __check_collide(self):
#       __update_sprites(self):
#       __game_over():


#02. 實現飛機大戰主遊戲類
# ·plane_main
#       1.封裝主遊戲類
#       2.創建遊戲對象
#       3.啓動遊戲
# ·plane_sprites
#       1.封裝遊戲中所有需要使用的精靈類
#       2.提供遊戲的相關工具
# ·常量
#       常量的命名應該所有字母都使用大寫，單詞和單詞之間使用下劃線連接


# 背景圖像
#01. 背景交替滾動的思路確定
#02. 設計背景類
# ·由GameSprite繼承而來
#       Background
#           __init__(self, is_alt):
#           update(self):
# ·初始化方法
#       1.直接指定背景圖片
#       2.is_alt判斷是否是另一張圖
# ·update()方法
#       ·判斷是否移動出屏幕，如果是，將圖像設置到屏幕的正上方，從而實現交替滾動




# 敵機出場
#01. 使用定時器添加敵機
# ·定時器
#       pygame.time.set_timer(eventid, milliseconds) -> None
#       ·set_timer可以創建一個事件
# ·定時器事件的監聽
#       通過pygame.event.get()可以獲得當前時刻所有的時間列表
#       遍歷判斷event.type是否等於eventid


#1.1 定義並監聽創建敵機的定時器事件
# ·步驟
#       1.定義定時器常量 -- eventid
#       2.在初始化方法中，調用set_timer方法設置定時器時間
#       3.在遊戲循環中，監聽定時器事件


#02. 設計敵機類
# ·Enemy(GameSprite)
#       __init__(self):
#       update(self):
# ·初始化方法
#       ·指定敵機圖片
#       ·隨機敵機的初始位置和初始速度
# ·重寫update方法
#       ·判斷是否飛出屏幕，如果是，從精靈組刪除


#2.1 創建敵機
# ·在__create_sprites中創建敵機精靈組
# ·在__event_handler中創建敵機，並且添加到精靈組
# ·在__update_sprites中調用update和draw


#2.2 隨機敵機位置和速度
# ·import random


#2.3 移出屏幕銷燬敵機
# ·從敵機組刪除




# 英雄登場
#01. 設計英雄和子彈類
# ·Hero -- 英雄
#   ·初始化方法
#       ·指定英雄圖片
#       ·初始速度 = 0 -- 英雄默認靜止不動
#       ·定義bullets子彈精靈組保存子彈精靈
#   ·重寫update()方法
#       ·英雄需要水平移動
#       ·並且需要保證不能移出屏幕
#   ·增加bullets屬性，記錄所有子彈精靈
#   ·增加fire方法，用於發射子彈
#---------------------------------
#   Hero(GameSprite)
#       bulltes
#       __init__(self):
#       update(self):
#       fire(self):
#---------------------------------
#   Bullet(GameSprite)
#       __init__(self):
#       update(self):
#---------------------------------


#02. 繪製英雄
#03. 移動英雄位置（鍵盤按鍵的捕獲）
# ·方式一(單次按鍵)
#       if event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
# ·方式二(支持連按)
#       keys_pressed = pygame.key.get_pressed()
#       if keys_pressed[pygame.K_RIGHT]:
#           print("向右移動...")


#04. 發射子彈
#4.1 添加發射子彈事件
# ·使用定時器完成子彈事件


#4.2 定義子彈類
# ·Bullet -- 子彈
#   ·初始化方法
#       ·指定子彈圖片
#       ·初始速度 = -2 -- 子彈需要向上飛行
#   ·重寫update方法
#       ·判斷是否飛出屏幕，如果是，從精靈組刪除


#4.3 發射子彈
# ·步驟
#       1.在hero的初始化方法中創建子彈精靈組屬性
#       2.修改plane_main.pyde __update_sprites方法，讓子彈精靈組調用update和draw方法
#       3.實現fire方法
#           ·創建子彈精靈
#           ·設置初始位置 -- 在英雄的正上方
#           ·將子彈添加到精靈組




#碰撞檢測
#01. 碰撞檢測方法
#-----------------------------------------------------------------------
# ·pygame.sprite.groupcollide()
#       ·兩個精靈組中的所有精靈的碰撞檢測
#       groupcollide(group1, group2, dokill1, dokill2, collided = None) -> Sprite_dict
#       ·如果將dokill設置爲True，則發生碰撞的精靈將被自動移除
#       ·collided參數是用於計算碰撞的回調函數
#           ·如果沒有指定，則每一個精靈必須有一個rect屬性
#-----------------------------------------------------------------------
# ·pygame.sprite.spritecollide()
#       ·判斷某個精靈和指定精靈組中的精靈的碰撞
#       spritecollide(sprite, group, dokill, collided = None) -> Sprite_list
#-----------------------------------------------------------------------

然後祭出兩個py文件：

文件1. plane_sprites.py

作用： 完成精靈類的編寫

#plane_sprites.py
import random
import pygame

# 屏幕大小的常量
SCREEN_RECT = pygame.Rect(0, 0, 480, 852)
# 刷新的幀率
FRAME_PER_SEC = 60
# 創建敵機的定時器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
# 英雄發射子彈事件
HERO_FIRE_EVENT = pygame.USEREVENT + 1


class GameSprite(pygame.sprite.Sprite):
    """飛機大戰遊戲精靈"""

    def __init__(self, image_name, speed=1):

        # 調用父類的初始化方法
        super(GameSprite, self).__init__()

        # 定義對象的屬性
        self.image = pygame.image.load(image_name)
        self.rect = self.image.get_rect()
        self.speed = speed

    def update(self):

        # 在屏幕的垂直方向上移動
        self.rect.y += self.speed


class Background(GameSprite):
    """遊戲背景精靈"""

    def __init__(self, is_alt=False):

        # 1. 調用父類方法實現精靈的創建（image，rect，speed）
        super().__init__(r".\Image\background.png")

        # 2. 判斷是否是交替圖像，如果是，需要設置初始位置
        if is_alt:
            self.rect.y = -SCREEN_RECT.height

    def update(self):

        #1. 調用父類的方法實現
        super().update()

        #2. 判斷是否移動出屏幕，如果移動出，將圖像設置到屏幕的上方
        if self.rect.y >= SCREEN_RECT.height:
            self.rect.y = -self.rect.height


class Enemy(GameSprite):
    """敵機精靈"""

    def __init__(self):

        #1. 調用父類方法，創建敵機精靈，同時指定敵機圖片
        super().__init__(r".\Image\small_enemy.png")

        #2. 指定敵機的初始隨機速度 1 ~ 3
        self.speed = random.randint(1, 3)

        #3. 指定敵機的初始隨機位置
        self.rect.x = random.randint(0, SCREEN_RECT.width - self.rect.width)
        #self.rect.y = -self.rect.height
        self.rect.bottom = 0

    def update(self):

        #1. 調用父類方法，保持垂直方向的飛行
        super().update()

        #2. 判斷是否飛出屏幕，如果是，需要從精靈組刪除敵機
        if self.rect.y >= SCREEN_RECT.height:
            #print("飛出屏幕，需要從精靈組刪除")
            self.kill()

    def __del__(self):
        #print("敵機掛了 %s" % self.rect)
        pass


class Hero(GameSprite):
    """英雄精靈"""

    def __init__(self):

        #1. 調用父類方法，設置image和speed
        super().__init__(r".\Image\hero1.png", 0)

        #2. 設置英雄的初始位置
        self.rect.centerx = SCREEN_RECT.centerx
        self.rect.bottom = SCREEN_RECT.bottom - 120

        #3. 創建子彈的精靈組
        self.bullets = pygame.sprite.Group()

    def update(self):

        # 用速度和英雄的x進行疊加
        self.rect.x += self.speed

        # 控制英雄不能離開屏幕
        if self.rect.x < 0:
            self.rect.x = 0

        if self.rect.right > SCREEN_RECT.right:
            self.rect.right = SCREEN_RECT.right

    def fire(self):

        # 英雄發射子彈
        print("突突突...")

        # 一次發射三顆子彈
        for i in (0, 1, 2):

            #1. 創建子彈精靈
            bullet = Bullet()

            #2. 設置精靈的位置
            bullet.rect.bottom = self.rect.y - 20 * i
            bullet.rect.centerx = self.rect.centerx

            #3. 將精靈添加到精靈組
            self.bullets.add(bullet)


class Bullet(GameSprite):
    """子彈精靈"""

    def __init__(self):

        # 調用父類方法，設置子彈圖片，設置初始速度
        super().__init__(r".\Image\normal_bullet.png", -2)

    def update(self):

        # 調用父類方法，讓子彈沿垂直方向飛行
        super().update()

        # 判斷子彈是否飛出屏幕
        if self.rect.bottom < 0:
            self.kill()

    def __del__(self):
        print("子彈被銷燬...")

文件2. plane_main.py

作用： 主程序（構建起程序框架）

#plane_main.py
import pygame
from plane_sprites import *


class PlaneGame(object):
    """飛機大戰主遊戲"""

    def __init__(self):
        print("遊戲初始化")

        #1. 創建遊戲窗口
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        #2. 創建遊戲的時鐘
        self.clock = pygame.time.Clock()
        #3. 調用私有方法，精靈和精靈組的創建
        self.__create_sprites()

        #4. 設置定時器事件 -- 創建敵機 1s
        pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)

        #5. 設置發射子彈事件
        pygame.time.set_timer(HERO_FIRE_EVENT, 500)

    def __create_sprites(self):

        # 創建背景精靈和精靈組
        bg1 = Background(False)
        bg2 = Background(True)

        self.back_group = pygame.sprite.Group(bg1, bg2)

        # 創建敵機的精靈組
        self.enemy_group = pygame.sprite.Group()

        # 創建英雄的精和精靈組
        self.hero = Hero()
        self.hero_group = pygame.sprite.Group(self.hero)

    def start_game(self):
        print("遊戲開始...")

        while True:
            #1. 設置刷新幀率
            self.clock.tick(FRAME_PER_SEC)
            #2. 事件監聽
            self.__event_handler()
            #3. 碰撞檢測
            self.__check_collide()
            #4. 更新/繪製精靈組
            self.__update_sprites()
            #5. 更新顯示
            pygame.display.update()


    def __event_handler(self):

        for event in pygame.event.get():

            # 判斷是否退出遊戲
            if event.type == pygame.QUIT:
                PlaneGame.__game_over()
            elif event.type == CREATE_ENEMY_EVENT:
                #print("敵機出場...")
                # 創建敵機精靈
                enemy = Enemy()

                # 將敵機精靈添加到敵機精靈組
                self.enemy_group.add(enemy)
            elif event.type == HERO_FIRE_EVENT:
                self.hero.fire()

            #elif event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
            #    print("向右移動...")

        # 使用鍵盤提供的方法獲取鍵盤按鍵 - 按鍵元組
        keys_pressed = pygame.key.get_pressed()
        # 判斷元組中對應的按鍵索引值
        if keys_pressed[pygame.K_RIGHT]:
            print("向右移動...")
            self.hero.speed = 2
        elif keys_pressed[pygame.K_LEFT]:
            print("向左移動...")
            self.hero.speed = -2
        else:
            self.hero.speed = 0


    def __check_collide(self):

        #1. 子彈摧毀敵機
        pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)

        #2. 敵機撞毀英雄
        enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)

        # 判斷列表enemies是否有內容
        if len(enemies) > 0:

            #讓英雄犧牲
            self.hero.kill()

            #結束遊戲
            PlaneGame.__game_over()


    def __update_sprites(self):

        self.back_group.update()
        self.back_group.draw(self.screen)

        self.enemy_group.update()
        self.enemy_group.draw(self.screen)

        self.hero_group.update()
        self.hero_group.draw(self.screen)

        self.hero.bullets.update()
        self.hero.bullets.draw(self.screen)

    @staticmethod
    def __game_over():
        print("遊戲結束")
        pygame.quit()
        exit()


if __name__ == '__main__':

    # 創建遊戲對象
    game = PlaneGame()

    # 啓動遊戲
    game.start_game()

小小小demo編程實現效果：