python-pygame實現飛機大戰-6-完結,增加游戲結束界面,歷史記錄、游戲得分、重新開始與結束游戲按鈕


本次添加的功能就是對項目的收尾工作了:增加游戲結束界面,歷史記錄、游戲得分、重新開始與結束游戲按鈕。(當玩家三條命都用完后觸發)
同樣的,先上圖:

 

 本次步驟所需的資源其實就兩個按鈕的圖片了,(文字的font我無法放上來,可以直接下一個font)

 

 

或者直接下載整個項目的包,包括源碼以及資源,都很詳細:https://download.csdn.net/download/weixin_38778769/19126067

本次變動的地方還是在main.py里面,其實就是最后的一些小功能的完善,當你已經寫到這一步的時候,這些功能其實自己都可以添加了,方法都是一樣的,所以項目做到這里就算小小的完結了。
其實教程里面還有添加中型、大型飛機來着,還有游戲難度遞增,但其實跟原有寫法沒太大差別,我就沒有繼續寫了,都是上面那個包還是都包含了。

最后:我自己有些寫的邏輯以及方法跟教程不一樣,也建議大家自己看個大致的邏輯就行,然后以自己的方式去實現,這樣學到的東西會更多。
然后便是代碼模塊了,這回的代碼我會把我寫的全部放上來。

main.py:渲染各個組件,運行邏輯等等
bullet.py:主要是子彈的控制,包括子彈各種屬性、以及子彈的重置
enemy.py:敵機類,包含敵機的屬性、運行、重置等
myplane.py:主要是玩家飛機的控制,包括玩家飛機各種屬性、飛機的上下左右移動,以及飛機的重生
supply.py:主要是補給的控制,包括補給的移動以及重置,其實寫法都差不多
record.txt:保存玩家最高記錄

main.py

import pygame
import sys
import traceback
from pygame.locals import *
from random import *
import myplane
import enemy
import bullet
import supply


# 初始化
pygame.init()
# 設置窗口大小
bg_size = width, height = 400, 700  # 實際上是元組
screen = pygame.display.set_mode(bg_size)  # 設置窗口
pygame.display.set_caption("飛機大戰")  # 窗口標題
# 加載背景圖片,對於普通圖像的顯示效果有沒有convert都是一樣的,但是 使用 convert 可以轉換格式,提高 blit 的速度
background = pygame.image.load("images/background.png").convert()

# 設置黑、綠、紅、百幾種顏色對應值,后面會用到
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
WHITE = (255, 255, 255)

# 生成敵方小型飛機
def add_small_enemy(small_enemies, enemiesGroup, num):
    for i in range(num):
        smallenemy = enemy.SmallEnemy(bg_size)
        # 精靈組來實現多個圖像,很適合處理精靈列表,有添加,移除,繪制,更新等方法
        # Group.sprites 精靈組
        # Group.copy 復制
        # Group.add 添加
        # Group.remove 移除
        # Group.has 判斷精靈組成員
        # Group.update 更新
        # Group.draw 位塊顯示
        # Group.clear - 繪制背景
        # Group.empty 清空
        # 將這一組敵機都添加上小型飛機屬性,相當於統一處理,統一賦值
        small_enemies.add(smallenemy)
        enemiesGroup.add(smallenemy)

def main():
    # 創建時鍾對象(可以控制游戲循環頻率)
    clock = pygame.time.Clock()

    # 生成玩家飛機
    me = myplane.MyPlane(bg_size)

    # 存放所有敵方飛機,這個飛機組包含了小型飛機、中型飛機、大型飛機的各種屬性,只要用於處理碰撞
    # 當程序中有大量的實體的時候,操作這些實體將會是一件相當麻煩的事
    # 使用pygame.sprite.Group()函數可以創建一個精靈組,從而統一管理,這里創建了一個敵機組
    enemiesGroup = pygame.sprite.Group()

    # 生成地方小型飛機,敵方小型飛機也是一個組,進行統一處理
    small_enemies = pygame.sprite.Group()
    add_small_enemy(small_enemies, enemiesGroup, 15)

    # 生成普通子彈,這里是四顆子彈循環
    bullet1s = []
    # 標記發生的哪顆子彈
    bullet1s_index = 0
    # 子彈數目
    bullet1_num = 4
    for i in range(bullet1_num):
        # 把玩家飛機的位置發給子彈類
        bullet1s.append(bullet.Bullet1(me.rect.midtop))

    # 生成加強子彈,這里是八顆子彈循環,左右各四顆
    bulletspro = []
    # 標記發生的哪顆子彈
    bulletspro_index = 0
    # 子彈數目
    bulletspro_num = 8
    # 左右各壓入四顆子彈,//2表示的整除,其實用/2也一樣
    for i in range(bulletspro_num // 2):
        # 這里(me.rect.centerx - 33, me.rect.centery)是指元組位置,centerx代表x軸,centery代表y軸
        bulletspro.append(bullet.Bullet2((me.rect.centerx - 33, me.rect.centery)))
        bulletspro.append(bullet.Bullet2((me.rect.centerx + 33, me.rect.centery)))

    # 初始化加強子彈補給,超級炸彈補給
    bullet_supply = supply.Bullet_Supply(bg_size)
    bomb_supply = supply.Bomb_Supply(bg_size)
    # 設置無敵時間事件,pygame.USEREVENT代表事件1,pygame.USEREVENT+1代表事件2,以此類推,這里相當於定義了一個事件
    invincible_event = pygame.USEREVENT
    # 設置補給時間事件
    bullet_time_supply = pygame.USEREVENT + 1
    # 設置加強子彈定時器事件,即加強子彈buff持續事件
    bulletpro_time = pygame.USEREVENT + 2
    # 設置定時器,8秒鍾發放一次補給
    pygame.time.set_timer(bullet_time_supply, 8 * 1000)

    # 標記是否使用超級子彈
    is_double_bullet = False

    # 玩家三條命
    life_num = 3
    life_image = pygame.image.load('images/life.png').convert_alpha()
    life_rect = life_image.get_rect()
    # 玩家帶有超級炸彈數量
    bomb_num = 3
    # 繪制超級炸彈
    bomb_image = pygame.image.load('images/bomb.png').convert_alpha()
    # 超級炸彈圖片位置
    bomb_rect = bomb_image.get_rect()
    # 超級炸彈數量字體
    bomb_font = pygame.font.Font('font/font.ttf', 48)


    # 游戲暫停,默認為非暫停狀態
    paused = False
    # 暫停圖片
    pause_nor_image = pygame.image.load('images/pause_nor.png').convert_alpha()
    pause_pressed_image = pygame.image.load('images/pause_pressed.png').convert_alpha()
    # 繼續圖片
    resume_nor_image = pygame.image.load('images/resume_nor.png').convert_alpha()
    resume_pressed_image = pygame.image.load('images/resume_pressed.png').convert_alpha()
    # 設置默認圖片
    paused_image = pause_nor_image
    # 暫停按鈕位置
    paused_rect = pause_nor_image.get_rect()
    paused_rect.left, paused_rect.top = width - paused_rect.width - 10, 10


    # 控制玩家飛機圖片切換,展示突突突的效果
    switch_image = True
    # 切換延時
    delay = 100

    # 游戲分數
    score = 0
    # 設定玩家分數字體樣式,從一個字體文件創建一個 Font 對象
    score_font = pygame.font.Font('font/font.ttf', 36)
    # 游戲結束界面
    gameover_font = pygame.font.Font('font/font.TTF', 48)
    # 重新開始按鈕圖片
    again_image = pygame.image.load('images/again.png').convert_alpha()
    again_rect = again_image.get_rect()
    # 游戲結束按鈕圖片
    gameover_image = pygame.image.load('images/gameover.png').convert_alpha()
    gameover_rect = gameover_image.get_rect()

    # 飛機爆炸的圖片下標,依次為小型敵機,中型敵機,大型敵機,玩家飛機的爆炸的圖片的下標,切換下標來改變爆炸圖片
    e1_destory_index = 0
    e2_destory_index = 0
    e3_destory_index = 0
    me_destory_index = 0

    running = True
    while running:
        # 獲取事件
        for event in pygame.event.get():
            # 結束事件觸發結束操作
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
            # 在觸發碰撞的時候,寫了pygame.time.set_timer(invincible_event, 3*1000)
            # 意思就是3秒后將會執行invincible_event事件,這里捕獲了invincible_event事件,執行后,將取消這個計時器,防止循環重復執行,等待下一次觸發
            elif event.type == invincible_event:
                # 解除無敵狀態
                me.invincible = False
                pygame.time.set_timer(invincible_event, 0)
            # 觸發補給事件
            elif event.type == bullet_time_supply:
                # 隨機進行一次判斷,如果是True,就發放強化子彈補給
                if choice([True, False]):
                    # 發放強化子彈補給
                    bullet_supply.reset()
                else:
                    # 發放超級炸彈補給
                    bomb_supply.reset()
            # 加強子彈buff到時事件
            elif event.type == bulletpro_time:
                # 子彈切換為普通子彈
                is_double_bullet = False
                # 事件停止循環,等待下一次觸發
                pygame.time.set_timer(bulletpro_time, 0)
            # 捕獲按鍵操作
            elif event.type == KEYDOWN:
                # 如果按下的是空格,觸發大招,超級炸彈清空屏幕內的飛機
                if event.key == K_SPACE:
                    if bomb_num > 0:
                        bomb_num -= 1
                        # 判斷所有在場的敵機,是否在游戲屏幕內
                        for ei in enemiesGroup:
                            if ei.rect.bottom > 0:
                                ei.active = False
            # 鼠標移動事件
            elif event.type == MOUSEMOTION:
                # 鼠標移入到暫停的矩形框內,檢測鼠標是否在矩形里,是則返回True,否則返回False ; pos – 就是鼠標位置
                if paused_rect.collidepoint(event.pos):
                    # 如果是暫停狀態
                    if paused:
                        paused_image = resume_pressed_image
                    else:
                        paused_image = pause_pressed_image
                else:
                    if paused:
                        paused_image = resume_nor_image
                    else:
                        paused_image = pause_nor_image
            # 鼠標左鍵點擊暫停按鈕
            elif event.type == MOUSEBUTTONDOWN:
                # 如果是左鍵而且鼠標點擊位置在暫停框內
                if event.button == 1 and paused_rect.collidepoint(event.pos):
                    # 切換暫停狀態
                    paused = not paused
                # 如果點擊暫停按鈕后,游戲是暫停狀態
                if paused:
                    # 繪制暫停按鈕圖片
                    paused_image = resume_pressed_image
                    # 暫停補給定時器
                    pygame.time.set_timer(bullet_time_supply, 0)
                # 如果點擊暫停按鈕后,游戲是繼續狀態
                else:
                    # 繪制繼續按鈕圖片
                    paused_image = pause_pressed_image
                    # 繼續補給定時器
                    pygame.time.set_timer(bullet_time_supply, 8 * 1000)


        # 檢測用戶鍵盤操作,分別為上下左右
        key_pressed = pygame.key.get_pressed()
        if key_pressed[K_w] or key_pressed[K_UP]:
            me.moveUp()
        if key_pressed[K_s] or key_pressed[K_DOWN]:
            me.moveDown()
        if key_pressed[K_a] or key_pressed[K_LEFT]:
            me.moveLeft()
        if key_pressed[K_d] or key_pressed[K_RIGHT]:
            me.moveRight()


        # 在屏幕上面繪制背景圖像,並指定位置
        screen.blit(background, (0, 0))

        # 繪制子彈補給、炸彈補給、敵機、玩家飛機等等各種元素
        # 未暫停且生命大於0
        if paused == False and life_num > 0:
            # 繪制子彈補給,如果子彈補給狀態為真,即觸發子彈補給操作
            if bullet_supply.active:
                # 子彈開始運動,並且渲染子彈子彈補給圖片
                bullet_supply.move()
                screen.blit(bullet_supply.image, bullet_supply.rect)
                # 下落過程中如果跟玩家飛機碰撞,說明玩家飛機拾取到子彈補給
                # pygame.sprite.collide_mask:兩個精靈之間的像素遮罩檢測,接收兩個精靈作為參數,返回值是一個bool變量
                if pygame.sprite.collide_mask(bullet_supply, me):
                    # 改變子彈補給狀態,包括隱藏以及不能再拾取了
                    bullet_supply.active = False
                    # 飛機子彈變為加強子彈
                    is_double_bullet = True
                    # 設置加強子彈buff持續事件,這里持續4s
                    pygame.time.set_timer(bulletpro_time, 4 * 1000)

            # 繪制超級炸彈補給,如果超級炸彈狀態為真,即觸發超級炸彈補給操作
            if bomb_supply.active:
                # 超級炸彈補給開始運動,並且渲染補給圖片
                bomb_supply.move()
                screen.blit(bomb_supply.image, bomb_supply.rect)
                # 玩家飛機拾取到補給
                if pygame.sprite.collide_mask(bomb_supply, me):
                    # 改變補給狀態,包括隱藏以及不能再拾取了
                    bomb_supply.active = False
                    # 判斷超級炸彈數量,不能大於3
                    if bomb_num < 3:
                        bomb_num += 1



            # 繪制小型敵機,這里是由於上面定義了小型飛機組,飛機組add了小型飛機屬性(速度、位置等),這時候地圖上就生成了飛機
            # 如果這些飛機屬於小型敵機類,即一起處理
            for ei in small_enemies:
                # 敵機是活的,未被擊毀
                if ei.active == True:
                    # 繪制小型敵機,並且敵機開始運動
                    screen.blit(ei.image, ei.rect)
                    ei.samll_enemy_move()
                # 小型敵機被摧毀(被玩家擊毀或者與玩家碰撞)
                else:
                    # 這里設置delay % 4是指爆炸畫面為4幀(個人猜測),理解為爆炸停留時間,可自行設置
                    if not (delay % 4):
                        # 用於播放爆炸聲音,每一架敵機只有一次
                        if e1_destory_index == 0:
                            print("播放敵機爆炸聲音")
                        # 繪制敵機撞擊爆炸畫面
                        screen.blit(ei.destory_images[e1_destory_index], ei.rect)
                        # 切換爆炸圖片下標,從而切換爆炸圖片
                        e1_destory_index = (e1_destory_index + 1) % 4
                        # 經歷完一輪爆炸的敵機,可以將其銷毀,也可以重生,都是不能不處理,不然會一直爆炸、爆炸
                        # 這里選擇將其重生
                        if e1_destory_index == 0:
                            ei.reset()
                            score += 100

            # 做碰撞檢測,pygame.sprite.spritecollide(sprite,sprite_group,bool):一個組中的所有精靈都會逐個地對另外一個單個精靈進行沖突檢測,發生沖突的精靈會作為一個列表返回。
            # 第一個參數就是單個精靈,第二個參數是精靈組,第三個參數是一個bool值,最后這個參數起了很大的作用。當為True的時候,會刪除組中所有沖突的精靈,False的時候不會刪除沖突的精靈
            # 第四個參數是:兩個精靈之間的像素遮罩檢測
            enemy_collide = pygame.sprite.spritecollide(me, enemiesGroup, False, pygame.sprite.collide_mask)
            # 碰撞處理,如果不是無敵狀態下發生碰撞
            if enemy_collide and not me.invincible:
                # 玩家飛機觸發摧毀狀態
                me.active = False
                # enemy_collide是一個列表,存儲所有跟玩家飛機發生碰撞的敵機,然后把碰撞的敵機狀態置為摧毀狀態
                for ei in enemy_collide:
                    ei.active = False

            # 繪制玩家飛機,如果飛機為激活狀態
            if me.active:
                # 在屏幕上繪制玩家飛機,switch_image為是否切換圖片
                if switch_image:
                    screen.blit(me.image1, me.rect)
                # 切換一下飛行圖片
                else:
                    screen.blit(me.image2, me.rect)
            # 代表飛機遭到碰撞,激活爆炸事件
            else:
                if not (delay % 4):
                    # 用於播放爆炸聲音,每一架敵機只有一次
                    if me_destory_index == 0:
                        print("玩家飛機爆炸聲音")
                    # 繪制玩家撞擊爆炸畫面
                    screen.blit(me.destory_image[me_destory_index], me.rect)
                    # 切換爆炸圖片下標,從而切換爆炸圖片
                    me_destory_index = (me_destory_index + 1) % 4
                    # 爆炸畫面播放完之后飛機重生
                    if me_destory_index == 0:
                        # 生命減一條,如果見到0,會自動跳過上一級循環
                        life_num -= 1
                        # 重置狀態
                        me.reset()
                        # 無敵時間設置為3秒,3秒后,觸發無敵時間事件,pygame.time.set_timer:就是每隔一段時間(這里是3毫秒 * 1000 = 3s),去執行一些動作
                        pygame.time.set_timer(invincible_event, 3 * 1000)

            # 每10個單位時間發射一顆子彈
            if not(delay % 10):
                # 如果是普通子彈
                if is_double_bullet == False:
                    bullets = bullet1s
                    # 先定子彈0的位置
                    bullets[bullet1s_index].reset(me.rect.midtop)
                    # 切換到下一顆子彈
                    bullet1s_index = (bullet1s_index + 1) % bullet1_num
                # 如果是超級子彈
                else:
                    # 則子彈切換為加強子彈
                    bullets = bulletspro
                    # 左右加強子彈重置位置,邏輯其實跟普通子彈一樣的,只是位置變了
                    bullets[bulletspro_index].reset((me.rect.centerx - 33, me.rect.centery))
                    bullets[bulletspro_index + 1].reset((me.rect.centerx + 33, me.rect.centery))
                    # 切換到下一組子彈
                    bulletspro_index = (bulletspro_index + 2) % bulletspro_num


            # 繪制子彈
            for bul in bullets:
                if bul.active:
                    # 子彈如果是激活狀態的話,就可以移動加繪制了
                    bul.move()
                    screen.blit(bul.image, bul.rect)
                    # 子彈與敵機的碰撞,子彈與敵機組之間的碰撞,正常情況下其實就是1對1的碰撞
                    enemy_hit = pygame.sprite.spritecollide(bul, enemiesGroup, False, pygame.sprite.collide_mask)
                    # 如果存在被子彈擊中的敵機
                    if enemy_hit:
                        # 擊中敵機的子彈先標為未激活狀態,下一次循環到這個子彈的時候其實會重置的,又會顯示出來
                        bul.active = False
                        for ei in enemy_hit:
                            ei.active = False

            # 繪制分數文字,pygame.font.Font.render():在一個新 Surface 對象上繪制文本
            # pygame.font.Font.render(text, antialias, color, background=None)
            # text:要顯示的文字  antialias: 為True時文本圖像顯示更光滑,為False時文本圖像顯示有鋸齒狀
            # color:字體顏色 background:背景顏色(可選參數),默認為小黑屏
            score_text = score_font.render('Score : %s' % str(score), True, WHITE)
            screen.blit(score_text, (10, 5))

            # 繪制超級炸彈圖片以及數量顯示
            bomb_text = bomb_font.render('* %d' % bomb_num, True, WHITE)
            bomb_text_rect = bomb_text.get_rect()
            screen.blit(bomb_image, (10, height - 10 - bomb_rect.height))
            screen.blit(bomb_text, (bomb_rect.width + 20, height - 5 - bomb_text_rect.height))

            # 繪制玩家剩余生命數
            if life_num > 0:
                for i in range(life_num):
                    screen.blit(life_image, (width - 10 - (i+1)*life_rect.width, height - 10 - life_rect.height))


            delay -= 1
            if delay == 0:
                delay = 100
            # 每5幀切換一下飛行圖片樣式
            if delay % 5 == 0:
                switch_image = not switch_image

        # 生命小於0,代表游戲結束,啟動游戲結束事件處理
        elif life_num == 0:
            # 停止產生補給
            pygame.time.set_timer(bullet_time_supply, 0)
            # 打開歷史記錄文件,讀取歷史最高分
            with open('record.txt', 'r') as f:
                record_score = int(f.read())
            # 如果玩家分數大於歷史最高分,則寫入
            if score > record_score:
                with open('record.txt', 'w') as f:
                    f.write(str(score))

            # 繪制結束界面
            # 繪制歷史最高分數
            record_text_score = score_font.render('Best : %d' % int(record_score), True, WHITE)
            screen.blit(record_text_score, (100, 50))

            # 本次游戲所得分數標題
            gameover_text1 = gameover_font.render('Your Score', True, WHITE)
            gameover_text1_rect = gameover_text1.get_rect()
            # 讓橫坐標居中
            screen.blit(gameover_text1, ((width - gameover_text1_rect.width) // 2, (height // 2 - 100)))

            # 本次游戲所得分數
            gameover_text2 = gameover_font.render(str(score), True, WHITE)
            gameover_text2_rect = gameover_text2.get_rect()
            # 讓橫坐標居中
            screen.blit(gameover_text2, ((width - gameover_text2_rect.width) // 2, (height // 2 - 30)))

            # 繪制重新開始
            again_rect.left, again_rect.top = (width - again_rect.width) // 2, \
                                              (height // 2 + 90)
            screen.blit(again_image, again_rect)

            # 繪制結束游戲
            gameover_rect.left, gameover_rect.top = (width - gameover_rect.width) // 2, \
                                                    (height // 2 + 150)
            screen.blit(gameover_image, gameover_rect)

            # 檢測用戶的鼠標操作
            # 如果用戶按下鼠標左鍵
            if pygame.mouse.get_pressed()[0]:
                # 獲取鼠標坐標
                pos = pygame.mouse.get_pos()
                # 如果用戶點擊重新開始
                if again_rect.left < pos[0] < again_rect.right and \
                        again_rect.top < pos[1] < again_rect.bottom:
                    # 重新開始游戲
                    main()
                # 如果用戶點擊結束游戲
                elif gameover_rect.left < pos[0] < gameover_rect.right and \
                        gameover_rect.top < pos[1] < gameover_rect.bottom:
                    # 結束游戲
                    pygame.quit()
                    sys.exit()

        # 繪制暫停按鈕圖片
        screen.blit(paused_image, paused_rect)
        # 更新整個待顯示的  Surface 對象到屏幕上,將內存中的內容顯示到屏幕上
        pygame.display.flip()
        # 通過時鍾對象指定循環頻率,每秒循環60次
        # 幀速率是指程序每秒在屏幕山繪制圖
        clock.tick(60)

if __name__ == "__main__":
    try:
        main()
    # 服務正常退出
    except SystemExit:
        print("游戲正常退出!")
        # pass忽略錯誤並繼續往下運行,其實這里以及退出了
        pass
    # 服務出現其他的異常
    except:
        # 直接將錯誤打印出來
        traceback.print_exc()
        pygame.quit()

bullet.py

import pygame


# 子彈1
class Bullet1(pygame.sprite.Sprite):
    # 這里的position其實是玩家飛機的位置,因為飛機的位置是變化的,所有子彈也是變化的
    def __init__(self, position):
        # 這里還是一樣,”基類的初始化“,具體看enemy.py里面有介紹
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.image.load('images/bullet1.png').convert_alpha()
        # get_rect()是一個處理矩形圖像的方法,返回值包含矩形的各屬性,這里返回子彈的位置,可以獲取圖片的寬高等屬性
        self.rect = self.image.get_rect()
        # 定義子彈的位置
        self.rect.left = position[0]
        self.rect.top = position[1]
        # 判斷子彈是否激活狀態
        self.active = True
        # 子彈速度
        self.bulletSpeed = 12
        # 碰撞檢測,會忽略掉圖片中白色的背景部分
        self.mask = pygame.mask.from_surface(self.image)

    # 子彈移動
    def move(self):
        self.rect.top -= self.bulletSpeed
        # 超出屏幕以外,定義為未激活狀態,同時kill掉,不然消耗資源
        if self.rect.top < 0:
            self.active = False

    # 子彈重置
    def reset(self, position):
        self.active = True
        self.rect.left = position[0]
        self.rect.top = position[1]

# 子彈2,即加強子彈
class Bullet2(pygame.sprite.Sprite):
    # 這里的position其實是玩家飛機的位置,因為飛機的位置是變化的,所有加強子彈也是變化的
    def __init__(self, position):
        pygame.sprite.Sprite.__init__(self)
        # 加強子彈圖片
        self.image = pygame.image.load('images/bullet2.png').convert_alpha()
        # get_rect()是一個處理矩形圖像的方法,返回值包含矩形的各屬性,這里返回子彈的位置,可以獲取圖片的寬高等屬性
        self.rect = self.image.get_rect()
        # 定義子彈的位置
        self.rect.left = position[0]
        self.rect.top = position[1]
        # 判斷子彈是否激活狀態
        self.active = True
        # 加強子彈速度
        self.bulletSpeed = 14
        # 碰撞檢測,會忽略掉圖片中白色的背景部分
        self.mask = pygame.mask.from_surface(self.image)

    # 加強子彈移動
    def move(self):
        self.rect.top -= self.bulletSpeed
        # 超出屏幕以外,定義為未激活狀態
        if self.rect.top < 0:
            self.active = False

    # 子彈重置
    def reset(self, position):
        self.active = True
        self.rect.left = position[0]
        self.rect.top = position[1]

enemy.py

import pygame
from random import *


# 小型飛機類
# pygame.sprite.Sprite就是Pygame里面用來實現精靈的一個類,使用時,並不需要對它實例化,只需要繼承他,然后按需寫出自己的類就好了,因此非常簡單實用
# 所有精靈在建立時都是從pygame.sprite.Sprite中繼承的
class SmallEnemy(pygame.sprite.Sprite):
    def __init__(self, bg_size):
        # 這里涉及到”基類的初始化“建用百度好好理解一下。
        # 通俗來說,SmallEnemy類繼承了父類pygame.sprite.Sprite,子類父類都有__init__()這個函數,如果子類不實現這個init()函數,
        # 那么初始化時直接調用父類的初始化函數,如果子類實現這個init()函數,就覆蓋了父類的這個函數,既然繼承父類,就要在這個函數里顯式調用一下父類的__init__()
        pygame.sprite.Sprite.__init__(self)
        # 敵機圖片
        self.image = pygame.image.load('images/enemy1.png').convert_alpha()
        # 敵機摧毀圖片
        self.destory_images = []
        self.destory_images.extend([
            pygame.image.load('images/enemy1_down1.png').convert_alpha(),
            pygame.image.load('images/enemy1_down2.png').convert_alpha(),
            pygame.image.load('images/enemy1_down3.png').convert_alpha(),
            pygame.image.load('images/enemy1_down4.png').convert_alpha()
        ])
        # 定義屏幕寬高
        self.width = bg_size[0]
        self.height = bg_size[1]

        # get_rect()是一個處理矩形圖像的方法,返回值包含矩形的各屬性,這里返回飛機圖片1的位置,可以獲取圖片的寬高等屬性
        self.rect = self.image.get_rect()

        # 隨機生成飛機的位置,randint(a,b)即生成a<=n<=b,即在屏幕寬度,以及負5倍的高度下隨機生成
        self.rect.left = randint(0, self.width - self.rect.width)
        self.rect.top = randint(-5 * self.height, 0)

        # 小型敵機速度
        self.speed = 2
        # 敵機是否存活狀態
        self.active = True
        # 飛機碰撞檢測,會忽略掉圖片中白色的背景部分
        self.mask = pygame.mask.from_surface(self.image)

    # 小型敵機向下移動
    def samll_enemy_move(self):
        # 飛機還未飛出屏幕外,就向下運動(這里可以自己修改飛機的飛行軌跡,比如x軸的隨機左右飛行等,怎么浪怎么來)
        if self.rect.top < self.height:
            self.rect.top += self.speed
        else:
            self.reset()

    # 飛機飛出屏幕外后,別浪費,重置其位置(或者摧毀也行,反正得處理,不然內存會炸)
    def reset(self):
        # 這里寫不寫這個感覺都行,因為都是存活狀態,寫了更保險
        self.active = True
        # 隨機重置飛機的位置,跟上面生成得一樣
        self.rect.left = randint(0, self.width - self.rect.width)
        self.rect.top = randint(-5 * self.height, 0)

supply.py

import pygame
from random import *

# 子彈補給
class Bullet_Supply(pygame.sprite.Sprite):
    def __init__(self, bg_size):
        pygame.sprite.Sprite.__init__(self)
        # 子彈補給的圖片
        self.image = pygame.image.load('images/bullet_supply.png').convert_alpha()
        # 定義屏幕寬高
        self.width = bg_size[0]
        self.height = bg_size[1]
        # get_rect()是一個處理矩形圖像的方法,返回值包含矩形的各屬性,這里返回飛機圖片1的位置,可以獲取圖片的寬高等屬性
        self.rect = self.image.get_rect()
        # 隨機子彈補給的位置,randint(a,b)即生成a<=n<=b,即在屏幕寬度,以及2倍的高度下隨機生成
        self.rect.left = randint(0, self.width - self.rect.width)
        self.rect.top = randint(-2 * self.height, 0)
        # 補給的存活狀態,即是否顯示以及能否觸碰
        self.active = False
        # 補給下降狀態
        self.speed = 5

    # 子彈補給運動
    def move(self):
        # 還未下降到最底部
        if self.rect.top < self.height:
            # 則繼續向下運動
            self.rect.top += self.speed
        else:
            # 下降到最底部后,狀態變為未激活狀態
            self.active = False

    # 子彈補給重置
    def reset(self):
        # 狀態重置
        self.active = True
        # 隨機子彈補給的位置,randint(a,b)即生成a<=n<=b,即在屏幕寬度,以及2倍的高度下隨機生成
        self.rect.left = randint(0, self.width - self.rect.width)
        self.rect.top = randint(-2 * self.height, 0)

# 超級炸彈補給
class Bomb_Supply(pygame.sprite.Sprite):
    def __init__(self, bg_size):
        pygame.sprite.Sprite.__init__(self)
        # 超級炸彈圖片
        self.image = pygame.image.load('images/bomb_supply.png').convert_alpha()
        # 定義屏幕寬高
        self.width = bg_size[0]
        self.height = bg_size[1]
        # get_rect()是一個處理矩形圖像的方法,返回值包含矩形的各屬性,這里返回飛機圖片1的位置,可以獲取圖片的寬高等屬性
        self.rect = self.image.get_rect()
        # 超級炸彈補給的位置,randint(a,b)即生成a<=n<=b,即在屏幕寬度,以及2倍的高度下隨機生成
        self.rect.left = randint(0, self.width - self.rect.width)
        self.rect.top = randint(-2 * self.height, 0)
        # 補給的存活狀態,即是否顯示以及能否觸碰
        self.active = False
        # 補給下降狀態
        self.speed = 5

    # 超級炸彈移動
    def move(self):
        # 還未下降到最底部
        if self.rect.top < self.height:
            # 則繼續向下運動
            self.rect.top += self.speed
        else:
            # 下降到最底部后,狀態變為未激活狀態
            self.active = False

# 子彈補給重置
    def reset(self):
        # 狀態重置
        self.active = True
        # 超級炸彈補給的位置,randint(a,b)即生成a<=n<=b,即在屏幕寬度,以及2倍的高度下隨機生成
        self.rect.left = randint(0, self.width - self.rect.width)
        self.rect.top = randint(-2 * self.height, 0)

myplane.py

import pygame

# 玩家飛機類,pygame.sprite模塊里面包含了一個名為Sprite類,他是pygame本身自帶的一個精靈。
class MyPlane(pygame.sprite.Sprite):
    def __init__(self, bg_size):
        # convert_alpha()更改圖像的像素格式,包括每個像素的alpha,相當於圖片背景變為透明
        self.image1 = pygame.image.load('images/me1.png').convert_alpha()
        self.image2 = pygame.image.load('images/me2.png').convert_alpha()
        # 飛機摧毀圖片,以數字形式保存
        self.destory_image = []
        self.destory_image.extend([
            pygame.image.load('images/me_destroy_1.png').convert_alpha(),
            pygame.image.load('images/me_destroy_2.png').convert_alpha(),
            pygame.image.load('images/me_destroy_3.png').convert_alpha(),
            pygame.image.load('images/me_destroy_4.png').convert_alpha()
        ])
        # 定義屏幕寬高
        self.width = bg_size[0]
        self.height = bg_size[1]

        # get_rect()是一個處理矩形圖像的方法,返回值包含矩形的各屬性,這里返回飛機圖片1的位置,可以獲取圖片的寬高等屬性
        self.rect = self.image1.get_rect()

        # 飛機的初始化位置,//是整除,位置居中以及高度為圖片下框離屏幕最下方60
        self.rect.left = (self.width - self.rect.width)//2
        self.rect.top = self.height - self.rect.height - 60

        # 設置飛機的速度
        self.myPlaneSpeed = 10
        self.active = True

        # 設置飛機是否是無敵狀態(重生3秒內無敵)
        self.invincible = False

        # 飛機碰撞檢測,會忽略掉圖片中白色的背景部分,從指定 Surface 對象中返回一個 Mask
        # 用於快速實現完美的碰撞檢測,Mask 可以精確到 1 個像素級別的判斷。
        # Surface 對象中透明的部分設置為 1,不透明部分設置為 0。
        self.mask = pygame.mask.from_surface(self.image1)

    # 玩家飛機向上移動
    def moveUp(self):
        # 說明還沒定格,即還未到達游戲界面上邊界
        if self.rect.top > 0:
            self.rect.top -= self.myPlaneSpeed
        # 說明移動到達上邊界了
        else:
            self.rect.top = 0

    # 玩家飛機向下移動
    def moveDown(self):
        # 底部需要划出60的高度用來展示其他數據(炸彈數,生命數等)
        if self.rect.bottom < self.height - 60:
            # self.rect.bottom指的是飛機圖片下邊界
            self.rect.bottom += self.myPlaneSpeed
        else:
            self.rect.bottom = self.height - 60

    # 玩家飛機向左移動
    def moveLeft(self):
        if self.rect.left > 0:
            self.rect.left -= self.myPlaneSpeed
        else:
            self.rect.left = 0

    # 玩家飛機向右移動
    def moveRight(self):
        if self.rect.right < self.width:
            self.rect.right += self.myPlaneSpeed
        else:
            self.rect.right = self.width

    # 玩家飛機重生
    def reset(self):
        self.active = True
        # 重生時處於無敵狀態
        self.invincible = True
        # 重生飛機的初始化位置,//是整除,位置居中以及高度為圖片下框離屏幕最下方60
        self.rect.left = (self.width - self.rect.width) // 2
        self.rect.top = self.height - self.rect.height - 60

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM