Python開發一個滑雪小游戲

大家好，我是Lex 喜歡欺負超人那個Lex

擅長領域：Python開發一個小游戲

今日重點：一步步分析and越過亞馬遜的反爬蟲機制

不一會，游戲寫好了

效果是這樣的

一、如何搭建開發環境環境

一起來學pygame吧 游戲開發30例（開篇詞）——環境搭建+游戲效果展示

windows系統，python3.6+ pip21+

安裝游戲依賴模塊

pip install pygame

二、完整開發流程

1、代碼結構

首先，先整理一下專案的主結構，其實看一下主結構，基本就清晰了

modules：自己定義的模塊
——game.py:主程式

res：存放參考到的圖片和音頻等等
——music: 音頻 資源
——imgs: 圖片 資源
——fonts： 字體

cfg.py：為主組態檔

skiing.py：主程式檔案

requirements.txt：需要引入的python依賴包

2、詳細配置

cfg.py

組態檔中，需要引入os模塊，并且配置打開游戲的螢屏大小，將我們需要用到的圖片、音頻和字體檔案全部引入到專案中，

'''組態檔'''
import os


'''FPS'''
FPS = 40
'''游戲螢屏大小'''
SCREENSIZE = (640, 640)
'''圖片路徑'''
SKIER_IMAGE_PATHS = [
    os.path.join(os.getcwd(), 'res/imgs/game_forward.png'),
    os.path.join(os.getcwd(), 'res/imgs/game_right1.png'),
    os.path.join(os.getcwd(), 'res/imgs/game_right2.png'),
    os.path.join(os.getcwd(), 'res/imgs/game_left2.png'),
    os.path.join(os.getcwd(), 'res/imgs/game_left1.png'),
    os.path.join(os.getcwd(), 'res/imgs/game_fall.png')
]
OBSTACLE_PATHS = {
    'tree': os.path.join(os.getcwd(), 'res/imgs/tree.png'),
    'flag': os.path.join(os.getcwd(), 'res/imgs/flag.png')
}
'''背景音樂路徑'''
BGMPATH = os.path.join(os.getcwd(), 'res/music/bgm.mp3')
'''字體路徑'''
FONTPATH = os.path.join(os.getcwd(), 'res/font/FZSTK.TTF')

3、影片中參考到的圖片

4、資源檔案

包括游戲背景音頻、圖片和字體設計

res

music：游戲背景音樂

fonts：記分牌呀、顯示呀的 相關字體

imgs：游戲影片里的靜態圖片，所謂影片都是圖片

5、主程式

skiing.py

在主程式中，通過讀取組態檔，引入專案資源：包括圖片、音頻等，并從我們的modules里引入所有我們的模塊，

''' 類'''
class lexGame():
    def __init__(self, screen, sounds, font, lex_imgs, cfg, **kwargs):
        self.info = 'Gemlex —— hacklex'
        self.screen = screen
        self.sounds = sounds
        self.font = font
        self.lex_imgs = lex_imgs
        self.cfg = cfg
        self.reset()
    '''開始 '''
    def start(self):
        clock = gamepy.time.Clock()
        # 遍歷整個 界面更新位置
        overall_moving = True
        # 指定某些物件個體更新位置
        individual_moving = False
        # 定義一些必要的變數
        lex_selected_xy = None
        lex_selected_xy2 = None
        swap_again = False
        add_score = 0
        add_score_showtimes = 10
        time_pre = int(time.time())
        #  主回圈
        while True:
            for event in gamepy.event.get():
                if event.type == gamepy.QUIT or (event.type == gamepy.KEYUP and event.key == gamepy.K_ESCAPE):
                    gamepy.quit()
                    sys.exit()
                elif event.type == gamepy.MOUSEBUTTONUP:
                    if (not overall_moving) and (not individual_moving) and (not add_score):
                        position = gamepy.mouse.get_pos()
                        if lex_selected_xy is None:
                            lex_selected_xy = self.checkSelected(position)
                        else:
                            lex_selected_xy2 = self.checkSelected(position)
                            if lex_selected_xy2:
                                if self.swapGem(lex_selected_xy, lex_selected_xy2):
                                    individual_moving = True
                                    swap_again = False
                                else:
                                    lex_selected_xy = None
            if overall_moving:
                overall_moving = not self.dropGems(0, 0)
                # 移動一次可能可以拼出多個3連塊
                if not overall_moving:
                    res_match = self.isMatch()
                    add_score = self.removeMatched(res_match)
                    if add_score > 0:
                        overall_moving = True
            if individual_moving:
                lex1 = self.getGemByPos(*lex_selected_xy)
                lex2 = self.getGemByPos(*lex_selected_xy2)
                lex1.move()
                lex2.move()
                if lex1.fixed and lex2.fixed:
                    res_match = self.isMatch()
                    if res_match[0] == 0 and not swap_again:
                        swap_again = True
                        self.swapGem(lex_selected_xy, lex_selected_xy2)
                        self.sounds['mismatch'].play()
                    else:
                        add_score = self.removeMatched(res_match)
                        overall_moving = True
                        individual_moving = False
                        lex_selected_xy = None
                        lex_selected_xy2 = None
            self.screen.fill((154, 206, 235))
            self.drawGrids()
            self.lexs_group.draw(self.screen)
            if lex_selected_xy:
                self.drawBlock(self.getGemByPos(*lex_selected_xy).rect)
            if add_score:
                if add_score_showtimes == 10:
                    random.choice(self.sounds['match']).play()
                self.drawAddScore(add_score)
                add_score_showtimes -= 1
                if add_score_showtimes < 1:
                    add_score_showtimes = 10
                    add_score = 0
            self.remaining_time -= (int(time.time()) - time_pre)
            time_pre = int(time.time())
            self.showRemainingTime()
            self.drawScore()
            if self.remaining_time <= 0:
                return self.score
            gamepy.display.update()
            clock.tick(self.cfg.FPS)
			
    '''初始化'''
    def reset(self):
        # 隨機生成各個塊
        while True:
            self.all_lexs = []
            self.lexs_group = gamepy.sprite.Group()
            for x in range(self.cfg.NUMGRID):
                self.all_lexs.append([])
                for y in range(self.cfg.NUMGRID):
                    lex = lexSprite(img_path=random.choice(self.lex_imgs), size=(self.cfg.GRIDSIZE, self.cfg.GRIDSIZE), position=[self.cfg.XMARGIN+x*self.cfg.GRIDSIZE, self.cfg.YMARGIN+y*self.cfg.GRIDSIZE-self.cfg.NUMGRID*self.cfg.GRIDSIZE], downlen=self.cfg.NUMGRID*self.cfg.GRIDSIZE)
                    self.all_lexs[x].append(lex)
                    self.lexs_group.add(lex)
            if self.isMatch()[0] == 0:
                break
        # 得分
        self.score = 0
        # 拼出一個的獎勵
        self.reward = 10
        # 時間
        self.remaining_time = 300
    '''顯示剩余時間'''
    def showRemainingTime(self):
        remaining_time_render = self.font.render('CountDown: %ss' % str(self.remaining_time), 1, (85, 65, 0))
        rect = remaining_time_render.get_rect()
        rect.left, rect.top = (self.cfg.SCREENSIZE[0]-201, 6)
        self.screen.blit(remaining_time_render, rect)
    '''顯示得分'''
    def drawScore(self):
        score_render = self.font.render('SCORE:'+str(self.score), 1, (85, 65, 0))
        rect = score_render.get_rect()
        rect.left, rect.top = (10, 6)
        self.screen.blit(score_render, rect)
    '''顯示加分'''
    def drawAddScore(self, add_score):
        score_render = self.font.render('+'+str(add_score), 1, (255, 99, 99))
        rect = score_render.get_rect()
        rect.left, rect.top = (250, 250)
        self.screen.blit(score_render, rect)
    '''生成新的 塊'''
    def generateNewGems(self, res_match):
        if res_match[0] == 1:
            start = res_match[2]
            while start > -2:
                for each in [res_match[1], res_match[1]+1, res_match[1]+2]:
                    lex = self.getGemByPos(*[each, start])
                    if start == res_match[2]:
                        self.lexs_group.remove(lex)
                        self.all_lexs[each][start] = None
                    elif start >= 0:
                        lex.target_y += self.cfg.GRIDSIZE
                        lex.fixed = False
                        lex.direction = 'down'
                        self.all_lexs[each][start+1] = lex
                    else:
                        lex = lexSprite(img_path=random.choice(self.lex_imgs), size=(self.cfg.GRIDSIZE, self.cfg.GRIDSIZE), position=[self.cfg.XMARGIN+each*self.cfg.GRIDSIZE, self.cfg.YMARGIN-self.cfg.GRIDSIZE], downlen=self.cfg.GRIDSIZE)
                        self.lexs_group.add(lex)
                        self.all_lexs[each][start+1] = lex
                start -= 1
        elif res_match[0] == 2:
            start = res_match[2]
            while start > -4:
                if start == res_match[2]:
                    for each in range(0, 3):
                        lex = self.getGemByPos(*[res_match[1], start+each])
                        self.lexs_group.remove(lex)
                        self.all_lexs[res_match[1]][start+each] = None
                elif start >= 0:
                    lex = self.getGemByPos(*[res_match[1], start])
                    lex.target_y += self.cfg.GRIDSIZE * 3
                    lex.fixed = False
                    lex.direction = 'down'
                    self.all_lexs[res_match[1]][start+3] = lex
                else:
                    lex = lexSprite(img_path=random.choice(self.lex_imgs), size=(self.cfg.GRIDSIZE, self.cfg.GRIDSIZE), position=[self.cfg.XMARGIN+res_match[1]*self.cfg.GRIDSIZE, self.cfg.YMARGIN+start*self.cfg.GRIDSIZE], downlen=self.cfg.GRIDSIZE*3)
                    self.lexs_group.add(lex)
                    self.all_lexs[res_match[1]][start+3] = lex
                start -= 1
    '''移除匹配的lex'''
    def removeMatched(self, res_match):
        if res_match[0] > 0:
            self.generateNewGems(res_match)
            self.score += self.reward
            return self.reward
        return 0
    ''' 界面的網格繪制'''
    def drawGrids(self):
        for x in range(self.cfg.NUMGRID):
            for y in range(self.cfg.NUMGRID):
                rect = gamepy.Rect((self.cfg.XMARGIN+x*self.cfg.GRIDSIZE, self.cfg.YMARGIN+y*self.cfg.GRIDSIZE, self.cfg.GRIDSIZE, self.cfg.GRIDSIZE))
                self.drawBlock(rect, color=(0, 0, 255), size=1)
    '''畫矩形block框'''
    def drawBlock(self, block, color=(255, 0, 255), size=4):
        gamepy.draw.rect(self.screen, color, block, size)
    '''下落特效'''
    def dropGems(self, x, y):
        if not self.getGemByPos(x, y).fixed:
            self.getGemByPos(x, y).move()
        if x < self.cfg.NUMGRID - 1:
            x += 1
            return self.dropGems(x, y)
        elif y < self.cfg.NUMGRID - 1:
            x = 0
            y += 1
            return self.dropGems(x, y)
        else:
            return self.isFull()
    '''是否每個位置都有 塊了'''
    def isFull(self):
        for x in range(self.cfg.NUMGRID):
            for y in range(self.cfg.NUMGRID):
                if not self.getGemByPos(x, y).fixed:
                    return False
        return True
    '''檢查有無 塊被選中'''
    def checkSelected(self, position):
        for x in range(self.cfg.NUMGRID):
            for y in range(self.cfg.NUMGRID):
                if self.getGemByPos(x, y).rect.collidepoint(*position):
                    return [x, y]
        return None
    '''是否有連續一樣的三個塊(無--回傳0/水平--回傳1/豎直--回傳2)'''
    def isMatch(self):
        for x in range(self.cfg.NUMGRID):
            for y in range(self.cfg.NUMGRID):
                if x + 2 < self.cfg.NUMGRID:
                    if self.getGemByPos(x, y).type == self.getGemByPos(x+1, y).type == self.getGemByPos(x+2, y).type:
                        return [1, x, y]
                if y + 2 < self.cfg.NUMGRID:
                    if self.getGemByPos(x, y).type == self.getGemByPos(x, y+1).type == self.getGemByPos(x, y+2).type:
                        return [2, x, y]
        return [0, x, y]
    '''根據坐標獲取對應位置的 物件'''
    def getGemByPos(self, x, y):
        return self.all_lexs[x][y]
    '''交換 '''
    def swapGem(self, lex1_pos, lex2_pos):
        margin = lex1_pos[0] - lex2_pos[0] + lex1_pos[1] - lex2_pos[1]
        if abs(margin) != 1:
            return False
        lex1 = self.getGemByPos(*lex1_pos)
        lex2 = self.getGemByPos(*lex2_pos)
        if lex1_pos[0] - lex2_pos[0] == 1:
            lex1.direction = 'left'
            lex2.direction = 'right'
        elif lex1_pos[0] - lex2_pos[0] == -1:
            lex2.direction = 'left'
            lex1.direction = 'right'
        elif lex1_pos[1] - lex2_pos[1] == 1:
            lex1.direction = 'up'
            lex2.direction = 'down'
        elif lex1_pos[1] - lex2_pos[1] == -1:
            lex2.direction = 'up'
            lex1.direction = 'down'
        lex1.target_x = lex2.rect.left
        lex1.target_y = lex2.rect.top
        lex1.fixed = False
        lex2.target_x = lex1.rect.left
        lex2.target_y = lex1.rect.top
        lex2.fixed = False
        self.all_lexs[lex2_pos[0]][lex2_pos[1]] = lex1
        self.all_lexs[lex1_pos[0]][lex1_pos[1]] = lex2
        return True
    '''info'''
    def __repr__(self):
        return self.info

四、如何啟動游戲

1、開發工具

如果你有配置了工具的環境VScode、sublimeText、notepad+、pycharm什么的，可以直接在工具中，運行游戲，

如果沒配置，可以使用命令啟動，

2、命令列

推薦閱讀

python實戰

【python實戰】前女友婚禮，python破解婚禮現場的WIFI，把名稱改成了

【python實戰】前女友發來加密的 “520快樂.pdf“，我用python破解開之后，卻發現

【python實戰】昨晚，我用python幫隔壁小姐姐P證件照 自拍，然后發現...

【python實戰】女友半夜加班發自拍 python男友用30行代碼發現驚天秘密

【python實戰】python你TM太皮了——區區30行代碼就能記錄鍵盤的一舉一動

【python實戰】女神相冊密碼忘記了，我只用Python寫了20行代碼~~~

pygame系列文章【訂閱專欄，獲取完整原始碼】

一起來學pygame吧 游戲開發30例（二）——塔防游戲

一起來學pygame吧 游戲開發30例（四）——俄羅斯方塊小游戲

滲透測驗實戰專欄

Windows AD/Exchange管理專欄

Linux高性能服務器搭建

PowerShell自動化專欄

CSDN官方學習推薦 ↓ ↓ ↓

CSDN出的Python全堆疊知識圖譜，太強了，推薦給大家！

?