python游戏实战项目之智能五子棋

目录
  • 导语
  • 正文
  • 总结

导语

今日游戏更新,大家好,我是木木子,每天都给大家更新最好玩的游戏!关注我,从此你再也不用去费力找游戏了!

最热门最好玩的Python游戏点击即玩!

今天推荐的游戏是五子棋小游戏——人机对战、联机对战皆可!

你是否还记得?中学时代和同桌下过的五子棋?

这样下棋只怕是会被打!​!!!我怀疑他开挂了,并且找到了证据。

正文

首先准备好需要的图片等素材部分如下:

​​

好了!直接上代码吧——设置游戏开始界面:

class gameStartUI(QWidget):
    def __init__(self, parent=None, **kwargs):
        super(gameStartUI, self).__init__(parent)
        self.setFixedSize(760, 650)
        self.setWindowTitle('五子棋游戏对战')
        self.setWindowIcon(QIcon(cfg.ICON_FILEPATH))
        # 背景图片
        palette = QPalette()
        palette.setBrush(self.backgroundRole(), QBrush(QPixmap(cfg.BACKGROUND_IMAGEPATHS.get('bg_start'))))
        self.setPalette(palette)
        # 按钮
        # --人机对战
        self.ai_button = PushButton(cfg.BUTTON_IMAGEPATHS.get('ai'), self)
        self.ai_button.move(250, 200)
        self.ai_button.show()
        self.ai_button.click_signal.connect(self.playWithAI)
        # --联机对战
        self.online_button = PushButton(cfg.BUTTON_IMAGEPATHS.get('online'), self)
        self.online_button.move(250, 350)
        self.online_button.show()
        self.online_button.click_signal.connect(self.playOnline)
    '''人机对战'''
    def playWithAI(self):
        self.close()
        self.gaming_ui = playWithAIUI(cfg)
        self.gaming_ui.exit_signal.connect(lambda: sys.exit())
        self.gaming_ui.back_signal.connect(self.show)
        self.gaming_ui.show()
    '''联机对战'''
    def playOnline(self):
        self.close()
        self.gaming_ui = playOnlineUI(cfg, self)
        self.gaming_ui.show()

'''run'''
if __name__ == '__main__':
    app = QApplication(sys.argv)
    handle = gameStartUI()
    font = QFont()
    font.setPointSize(12)
    handle.setFont(font)
    handle.show()
    sys.exit(app.exec_())

效果如下:

​​

一个是五子棋规则设置的人机对战:

import pygame
from ..misc import *
from PyQt5 import QtCore
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
from itertools import product
from .aiGobang import aiGobang

'''人机对战'''
class playWithAIUI(QWidget):
    back_signal = pyqtSignal()
    exit_signal = pyqtSignal()
    send_back_signal = False
    def __init__(self, cfg, parent=None, **kwargs):
        super(playWithAIUI, self).__init__(parent)
        self.cfg = cfg
        self.setFixedSize(760, 650)
        self.setWindowTitle('五子棋人机对战')
        self.setWindowIcon(QIcon(cfg.ICON_FILEPATH))
        # 背景图片
        palette = QPalette()
        palette.setBrush(self.backgroundRole(), QBrush(QPixmap(cfg.BACKGROUND_IMAGEPATHS.get('bg_game'))))
        self.setPalette(palette)
        # 按钮
        self.home_button = PushButton(cfg.BUTTON_IMAGEPATHS.get('home'), self)
        self.home_button.click_signal.connect(self.goHome)
        self.home_button.move(680, 10)
        self.startgame_button = PushButton(cfg.BUTTON_IMAGEPATHS.get('startgame'), self)
        self.startgame_button.click_signal.connect(self.startgame)
        self.startgame_button.move(640, 240)
        self.regret_button = PushButton(cfg.BUTTON_IMAGEPATHS.get('regret'), self)
        self.regret_button.click_signal.connect(self.regret)
        self.regret_button.move(640, 310)
        self.givein_button = PushButton(cfg.BUTTON_IMAGEPATHS.get('givein'), self)
        self.givein_button.click_signal.connect(self.givein)
        self.givein_button.move(640, 380)
        # 落子标志
        self.chessman_sign = QLabel(self)
        sign = QPixmap(cfg.CHESSMAN_IMAGEPATHS.get('sign'))
        self.chessman_sign.setPixmap(sign)
        self.chessman_sign.setFixedSize(sign.size())
        self.chessman_sign.show()
        self.chessman_sign.hide()
        # 棋盘(19*19矩阵)
        self.chessboard = [[None for i in range(19)] for _ in range(19)]
        # 历史记录(悔棋用)
        self.history_record = []
        # 是否在游戏中
        self.is_gaming = True
        # 胜利方
        self.winner = None
        self.winner_info_label = None
        # 颜色分配and目前轮到谁落子
        self.player_color = 'white'
        self.ai_color = 'black'
        self.whoseround = self.player_color
        # 实例化ai
        self.ai_player = aiGobang(self.ai_color, self.player_color)
        # 落子声音加载
        pygame.mixer.init()
        self.drop_sound = pygame.mixer.Sound(cfg.SOUNDS_PATHS.get('drop'))
    '''鼠标左键点击事件-玩家回合'''
    def mousePressEvent(self, event):
        if (event.buttons() != QtCore.Qt.LeftButton) or (self.winner is not None) or (self.whoseround != self.player_color) or (not self.is_gaming):
            return
        # 保证只在棋盘范围内响应
        if event.x() >= 50 and event.x() <= 50 + 30 * 18 + 14 and event.y() >= 50 and event.y() <= 50 + 30 * 18 + 14:
            pos = Pixel2Chesspos(event)
            # 保证落子的地方本来没有人落子
            if self.chessboard[pos[0]][pos[1]]:
                return
            # 实例化一个棋子并显示
            c = Chessman(self.cfg.CHESSMAN_IMAGEPATHS.get(self.whoseround), self)
            c.move(event.pos())
            c.show()
            self.chessboard[pos[0]][pos[1]] = c
            # 落子声音响起
            self.drop_sound.play()
            # 最后落子位置标志对落子位置进行跟随
            self.chessman_sign.show()
            self.chessman_sign.move(c.pos())
            self.chessman_sign.raise_()
            # 记录这次落子
            self.history_record.append([*pos, self.whoseround])
            # 是否胜利了
            self.winner = checkWin(self.chessboard)
            if self.winner:
                self.showGameEndInfo()
                return
            # 切换回合方(其实就是改颜色)
            self.nextRound()
    '''鼠标左键释放操作-调用电脑回合'''
    def mouseReleaseEvent(self, event):
        if (self.winner is not None) or (self.whoseround != self.ai_color) or (not self.is_gaming):
            return
        self.aiAct()
    '''电脑自动下-AI回合'''
    def aiAct(self):
        if (self.winner is not None) or (self.whoseround == self.player_color) or (not self.is_gaming):
            return
        next_pos = self.ai_player.act(self.history_record)
        # 实例化一个棋子并显示
        c = Chessman(self.cfg.CHESSMAN_IMAGEPATHS.get(self.whoseround), self)
        c.move(QPoint(*Chesspos2Pixel(next_pos)))
        c.show()
        self.chessboard[next_pos[0]][next_pos[1]] = c
        # 落子声音响起
        self.drop_sound.play()
        # 最后落子位置标志对落子位置进行跟随
        self.chessman_sign.show()
        self.chessman_sign.move(c.pos())
        self.chessman_sign.raise_()
        # 记录这次落子
        self.history_record.append([*next_pos, self.whoseround])
        # 是否胜利了
        self.winner = checkWin(self.chessboard)
        if self.winner:
            self.showGameEndInfo()
            return
        # 切换回合方(其实就是改颜色)
        self.nextRound()
    '''改变落子方'''
    def nextRound(self):
        self.whoseround = self.player_color if self.whoseround == self.ai_color else self.ai_color
    '''显示游戏结束结果'''
    def showGameEndInfo(self):
        self.is_gaming = False
        info_img = QPixmap(self.cfg.WIN_IMAGEPATHS.get(self.winner))
        self.winner_info_label = QLabel(self)
        self.winner_info_label.setPixmap(info_img)
        self.winner_info_label.resize(info_img.size())
        self.winner_info_label.move(50, 50)
        self.winner_info_label.show()
    '''认输'''
    def givein(self):
        if self.is_gaming and (self.winner is None) and (self.whoseround == self.player_color):
            self.winner = self.ai_color
            self.showGameEndInfo()
    '''悔棋-只有我方回合的时候可以悔棋'''
    def regret(self):
        if (self.winner is not None) or (len(self.history_record) == 0) or (not self.is_gaming) and (self.whoseround != self.player_color):
            return
        for _ in range(2):
            pre_round = self.history_record.pop(-1)
            self.chessboard[pre_round[0]][pre_round[1]].close()
            self.chessboard[pre_round[0]][pre_round[1]] = None
        self.chessman_sign.hide()
    '''开始游戏-之前的对弈必须已经结束才行'''
    def startgame(self):
        if self.is_gaming:
            return
        self.is_gaming = True
        self.whoseround = self.player_color
        for i, j in product(range(19), range(19)):
            if self.chessboard[i][j]:
                self.chessboard[i][j].close()
                self.chessboard[i][j] = None
        self.winner = None
        self.winner_info_label.close()
        self.winner_info_label = None
        self.history_record.clear()
        self.chessman_sign.hide()
    '''关闭窗口事件'''
    def closeEvent(self, event):
        if not self.send_back_signal:
            self.exit_signal.emit()
    '''返回游戏主页面'''
    def goHome(self):
        self.send_back_signal = True
        self.close()
        self.back_signal.emit()

如下:害!我这下了很久呢,有几次都没下赢人机!2333游戏废材

​​

另一个定义联机对战:

import sys
import random
from .server import *
from .client import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *

'''联机对战'''
class playOnlineUI(QWidget):
    def __init__(self, cfg, home_ui, parent=None, **kwargs):
        super(playOnlineUI, self).__init__(parent)
        self.cfg = cfg
        self.home_ui = home_ui
        self.setWindowTitle('联机对战')
        self.setWindowIcon(QIcon(cfg.ICON_FILEPATH))
        self.setFixedSize(300, 200)
        # 昵称
        self.nickname = random.choice(['杰尼龟', '皮卡丘', '小火龙', '小锯鳄', '妙蛙种子', '菊草叶'])
        self.layout0 = QHBoxLayout()
        self.nickname_label = QLabel('游戏昵称:', self)
        self.nickname_edit = QLineEdit(self)
        self.nickname_edit.setText(self.nickname)
        self.layout0.addWidget(self.nickname_label, 1)
        self.layout0.addWidget(self.nickname_edit, 3)
        # IP
        self.target_ip = '127.0.0.1'
        self.layout1 = QHBoxLayout()
        self.ip_label = QLabel('对方IP:', self)
        self.ip_edit = QLineEdit(self)
        self.ip_edit.setText(self.target_ip)
        self.layout1.addWidget(self.ip_label, 1)
        self.layout1.addWidget(self.ip_edit, 3)
        # 按钮
        self.layout2 = QHBoxLayout()
        self.connect_button = QPushButton('作为客户端', self)
        self.connect_button.clicked.connect(self.becomeClient)
        self.ashost_button = QPushButton('作为服务器', self)
        self.ashost_button.clicked.connect(self.becomeHost)
        self.layout2.addWidget(self.connect_button)
        self.layout2.addWidget(self.ashost_button)
        # 布局
        self.layout = QVBoxLayout()
        self.layout.addLayout(self.layout0)
        self.layout.addLayout(self.layout1)
        self.layout.addLayout(self.layout2)
        self.setLayout(self.layout)
    '''作为客户端'''
    def becomeClient(self):
        self.close()
        self.nickname = self.nickname_edit.text()
        self.target_ip = self.ip_edit.text()
        self.client_ui = gobangClient(cfg=self.cfg, nickname=self.nickname, server_ip=self.target_ip)
        self.client_ui.exit_signal.connect(lambda: sys.exit())
        self.client_ui.back_signal.connect(self.home_ui.show)
        self.client_ui.show()
    '''作为服务器'''
    def becomeHost(self):
        self.close()
        self.nickname = self.nickname_edit.text()
        self.server_ui = gobangSever(cfg=self.cfg, nickname=self.nickname)
        self.server_ui.exit_signal.connect(lambda: sys.exit())
        self.server_ui.back_signal.connect(self.home_ui.show)
        self.server_ui.show()

​如下联机对战界面第一步:

​​

​​

定义五子棋AI算法:

import random
from itertools import product

'''五子棋AI算法'''
class aiGobang():
    def __init__(self, ai_color, player_color, search_depth=1, **kwargs):
        assert search_depth % 2, 'search_depth must be odd number'
        self.ai_color = ai_color
        self.player_color = player_color
        self.search_depth = search_depth
        self.score_model = [(50, (0, 1, 1, 0, 0)), (50, (0, 0, 1, 1, 0)), (200, (1, 1, 0, 1, 0)),
                            (500, (0, 0, 1, 1, 1)), (500, (1, 1, 1, 0, 0)), (5000, (0, 1, 1, 1, 0)),
                            (5000, (0, 1, 0, 1, 1, 0)), (5000, (0, 1, 1, 0, 1, 0)), (5000, (1, 1, 1, 0, 1)),
                            (5000, (1, 1, 0, 1, 1)), (5000, (1, 0, 1, 1, 1)), (5000, (1, 1, 1, 1, 0)),
                            (5000, (0, 1, 1, 1, 1)), (50000, (0, 1, 1, 1, 1, 0)), (99999999, (1, 1, 1, 1, 1))]
        self.alpha = -99999999
        self.beta = 99999999
        self.all_list = [(i, j) for i, j in product(range(19), range(19))]
    '''外部调用'''
    def act(self, history_record):
        self.ai_list = []
        self.player_list = []
        self.aiplayer_list = []
        for item in history_record:
            self.aiplayer_list.append((item[0], item[1]))
            if item[-1] == self.ai_color:
                self.ai_list.append((item[0], item[1]))
            elif item[-1] == self.player_color:
                self.player_list.append((item[0], item[1]))
        while True:
            self.next_point = random.choice(range(19)), random.choice(range(19))
            if self.next_point not in self.aiplayer_list:
                break
        self.__doSearch(True, self.search_depth, self.alpha, self.beta)
        return self.next_point
    '''负极大值搜索, alpha+beta剪枝'''
    def __doSearch(self, is_ai_round, depth, alpha, beta):
        if self.__isgameover(self.ai_list) or self.__isgameover(self.player_list) or depth == 0:
            return self.__evaluation(is_ai_round)
        blank_list = list(set(self.all_list).difference(set(self.aiplayer_list)))
        blank_list = self.__rearrange(blank_list)
        for next_step in blank_list:
            if not self.__hasNeighbor(next_step):
                continue
            if is_ai_round:
                self.ai_list.append(next_step)
            else:
                self.player_list.append(next_step)
            self.aiplayer_list.append(next_step)
            value = -self.__doSearch(not is_ai_round, depth-1, -beta, -alpha)
            if is_ai_round:
                self.ai_list.remove(next_step)
            else:
                self.player_list.remove(next_step)
            self.aiplayer_list.remove(next_step)
            if value > alpha:
                if depth == self.search_depth:
                    self.next_point = next_step
                if value >= beta:
                    return beta
                alpha = value
        return alpha
    '''游戏是否结束了'''
    def __isgameover(self, oneslist):
        for i, j in product(range(19), range(19)):
            if i < 15 and (i, j) in oneslist and (i+1, j) in oneslist and (i+2, j) in oneslist and (i+3, j) in oneslist and (i+4, j) in oneslist:
                return True
            elif j < 15 and (i, j) in oneslist and (i, j+1) in oneslist and (i, j+2) in oneslist and (i, j+3) in oneslist and (i, j+4) in oneslist:
                return True
            elif i < 15 and j < 15 and (i, j) in oneslist and (i+1, j+1) in oneslist and (i+2, j+2) in oneslist and (i+3, j+3) in oneslist and (i+4, j+4) in oneslist:
                return True
            elif i > 3 and j < 15 and (i, j) in oneslist and (i-1, j+1) in oneslist and (i-2, j+2) in oneslist and (i-3, j+3) in oneslist and (i-4, j+4) in oneslist:
                return True
        return False
    '''重新排列未落子位置'''
    def __rearrange(self, blank_list):
        last_step = self.aiplayer_list[-1]
        for item in blank_list:
            for i, j in product(range(-1, 2), range(-1, 2)):
                if i == 0 and j == 0:
                    continue
                next_step = (last_step[0]+i, last_step[1]+j)
                if next_step in blank_list:
                    blank_list.remove(next_step)
                    blank_list.insert(0, next_step)
        return blank_list
    '''是否存在近邻'''
    def __hasNeighbor(self, next_step):
        for i, j in product(range(-1, 2), range(-1, 2)):
            if i == 0 and j == 0:
                continue
            if (next_step[0]+i, next_step[1]+j) in self.aiplayer_list:
                return True
        return False
    '''计算得分'''
    def __calcScore(self, i, j, x_direction, y_direction, list1, list2, all_scores):
        add_score = 0
        max_score = (0, None)
        for each in all_scores:
            for item in each[1]:
                if i == item[0] and j == item[1] and x_direction == each[2][0] and y_direction == each[2][1]:
                    return 0, all_scores
        for noffset in range(-5, 1):
            position = []
            for poffset in range(6):
                x, y = i + (poffset + noffset) * x_direction, j + (poffset + noffset) * y_direction
                if (x, y) in list2:
                    position.append(2)
                elif (x, y) in list1:
                    position.append(1)
                else:
                    position.append(0)
            shape_len5 = tuple(position[0: -1])
            shape_len6 = tuple(position)
            for score, shape in self.score_model:
                if shape_len5 == shape or shape_len6 == shape:
                    if score > max_score[0]:
                        max_score = (score, ((i + (0 + noffset) * x_direction, j + (0 + noffset) * y_direction),
                                             (i + (1 + noffset) * x_direction, j + (1 + noffset) * y_direction),
                                             (i + (2 + noffset) * x_direction, j + (2 + noffset) * y_direction),
                                             (i + (3 + noffset) * x_direction, j + (3 + noffset) * y_direction),
                                             (i + (4 + noffset) * x_direction, j + (4 + noffset) * y_direction)), (x_direction, y_direction))
        if max_score[1] is not None:
            for each in all_scores:
                for p1 in each[1]:
                    for p2 in max_score[1]:
                        if p1 == p2 and max_score[0] > 10 and each[0] > 10:
                            add_score += max_score[0] + each[0]
            all_scores.append(max_score)
        return add_score+max_score[0], all_scores
    '''评估函数'''
    def __evaluation(self, is_ai_round):
        if is_ai_round:
            list1 = self.ai_list
            list2 = self.player_list
        else:
            list2 = self.ai_list
            list1 = self.player_list
        active_all_scores = []
        active_score = 0
        for item in list1:
            score, active_all_scores = self.__calcScore(item[0], item[1], 0, 1, list1, list2, active_all_scores)
            active_score += score
            score, active_all_scores = self.__calcScore(item[0], item[1], 1, 0, list1, list2, active_all_scores)
            active_score += score
            score, active_all_scores = self.__calcScore(item[0], item[1], 1, 1, list1, list2, active_all_scores)
            active_score += score
            score, active_all_scores = self.__calcScore(item[0], item[1], -1, 1, list1, list2, active_all_scores)
            active_score += score
        passive_all_scores = []
        passive_score = 0
        for item in list2:
            score, passive_all_scores = self.__calcScore(item[0], item[1], 0, 1, list2, list1, passive_all_scores)
            passive_score += score
            score, passive_all_scores = self.__calcScore(item[0], item[1], 1, 0, list2, list1, passive_all_scores)
            passive_score += score
            score, passive_all_scores = self.__calcScore(item[0], item[1], 1, 1, list2, list1, passive_all_scores)
            passive_score += score
            score, passive_all_scores = self.__calcScore(item[0], item[1], -1, 1, list2, list1, passive_all_scores)
            passive_score += score
        total_score = active_score - passive_score * 0.1
        return total_score

总结

好啦!五子棋现在人机对战也可,真人局域网联机也可!文章就到这里​

到此这篇关于python游戏实战项目之智能五子棋的文章就介绍到这了,更多相关python 五子棋内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 一篇文章带你了解谷歌这些大厂是怎么写 python 代码的

    目录 谷歌内部的 python 代码规范 1.导入模块和包,不导入单独的类.函数或者变量. 2.从根目录导入,不假定任意的 sys.path,也不使用相对导入. 3.谨慎使用异常 4.不要使用可变类型作为函数默认值,如果修改了这个变量,默认值也会跟着发生变化. 5.注意条件表达式的隐式布尔值 6.谨慎使用装饰器 7.建议使用类型声明,类型声明的好处非常明显: 总结 谷歌内部的 python 代码规范 熟悉 python 一般都会努力遵循 pep8 规范,也会有一些公司制定内部的代码规范.大公司制

  • python游戏实战项目之智能五子棋简易版

    目录 导语 正文 总结 导语 前段时间不是制作了一款升级版本五子棋的嘛! 但是居然有粉丝私信我说: "准备拿到代码玩一下ok过去了!太难了准备放收藏夹落灰q@q~" 所噶,今天先放一个简易版本的五子棋给大家看看!学习嘛~从简单到难 还是慢慢来撒~ 学玩这篇可以学下一篇难一点的撒: Pygame实战:下五子棋吗?信不信我让你几步你也赢不了?​​​​​​​ 正文 嘿嘿!这五子棋只有人机对战了哈!不要看人机对战感觉很简单,其实代码量也超多滴. 主要代码:都有注释的撒!就不一步一步介绍了. i

  • Python中is与==的使用区别详解

    目录 一.== 是比较两个对象的内容是否相等 二.is 比较的是两个实例对象是不是完全相同 三.使用is注意python对于小整数使用对象池存储问题 四.使用is注意python关于字符串的intern机制存储 5.python中对于None值的比较:使用is 一.== 是比较两个对象的内容是否相等 即两个对象的"值""是否相等,不管两者在内存中的引用地址是否一样. //地址一样,值也一样.所以==成立. st1 ='aaaaa' st2 = 'bbbbb' st3 = 'b

  • 利用 Python 实现随机相对强弱指数 StochRSI

    目录 一.StochRSI如何运作? 二.如何使用StochRSI? 三.基于均值回归的StochRSI 策略 四.StochRSI 和动量策略 随机相对强弱指数简称为StochRSI,是一种技术分析指标,用于确定资产是否处于超买或超卖状态,也用于确定当前市场的态势.顾名思义,StochRSI是标准相对强弱指数(RSI)的衍生,因此被视为是一种能够衡量指数的指数.它是一种振荡器,在中心线的上方和下方波动. StochRSI最初是在1994年由Stanley Kroll和Tushar Chande

  • 关于python变量的引用以及在底层存储原理

    目录 1.变量的引用的底层原理 2.变量的分类 Python的变量,简单来说有数值型,布尔型,字符串类型,列表,元组,字典等6大类.那么不同变量类型在底层是如何存储的,关系到变量的引用,能否正确的掌握变量的相关操作 下面v1,v2的值分别是多少?为什么? v1 =3 v2=v1 print("v2:",v2) v1 += 2 print("v1:",v1) print("v2:",v2) #下面l2的值又是多少?为什么? l1 = [1,2,3]

  • 中秋将至利用python画一些月饼从天而降不用买了

    目录 ​​导语 正文 ​​总结 ​ ​​导语 好消息!下一个假期已经在路上了,正在向我们招手呢! 大家只要再坚持5天 就能迎来中秋小长假啦~ ​"海上生明月,天涯共此时" 又是一年中秋至!快跟着小编来看看怎么寓教于乐吧-- 今天带大家编写一款应时应景的中秋小游戏! 天上掉月饼啦~天上掉月饼啦~天上掉月饼啦~ 正文 ​准备好相应的素材如下: ​ 环境安装: Python3.6.pycharm2021.游戏模块Pygame. 安装:pip install pygame ​初始化游戏加载素材

  • Python中with...as...的使用方法

    目录 一.With...as语句的基本语法格式: 二.With...as语法的执行流程 三.实例验证 四.程序运行结果 五.代码解析 简介: with是从Python2.5引入的一个新的语法,它是一种上下文管理协议,目的在于从流程图中把 try,except 和finally 关键字和资源分配释放相关代码统统去掉,简化try-.except-.finlally的处理流程 with通过__enter__方法初始化,然后在__exit__中做善后以及处理异常.所以使用with处理的对象必须有__en

  • python游戏实战项目之童年经典超级玛丽

    导语 "超级玛丽"--有多少人还记得这款经典游戏?那个戴帽子的大胡子穿着背带裤的马里奥! 带您重温经典的回忆,超级马里奥拯救不开心!炫酷来袭. 如果您的童年,也曾被魔性的 灯~灯灯~灯~灯灯~灯洗脑~那就来怀旧一番吧! 我是华丽的分割线------------------------------ 往期写过游戏实战已经积累到30几篇了哦~嘿嘿,推一波之前的,狗头保命.jpg. 欢迎大家来领免费的游戏,开玩啦~源码可以直接找我拿滴! 在座的各位大佬,你们都玩过这里面的几个游戏吖? ​ 往期

  • python游戏实战项目之智能五子棋

    目录 导语 正文 总结 导语 ​ 今日游戏更新,大家好,我是木木子,每天都给大家更新最好玩的游戏!关注我,从此你再也不用去费力找游戏了! 最热门最好玩的Python游戏点击即玩! 今天推荐的游戏是五子棋小游戏--人机对战.联机对战皆可! 你是否还记得?中学时代和同桌下过的五子棋? ​ 这样下棋只怕是会被打!​!!!我怀疑他开挂了,并且找到了证据. ​ 正文 首先准备好需要的图片等素材部分如下: ​​​ 好了!直接上代码吧--设置游戏开始界面: class gameStartUI(QWidget)

  • python游戏实战项目之俄罗斯方块的魅力

    目录 导语 正文 效果图: ​总结 导语 ​ 为什么有这么一个简单的游戏?这个游戏如此受欢迎? 仅仅是因为它在游戏行业异常匮乏的年代出现,从而成为了一代人的记忆吗?恐怕并不是. 玩过俄罗斯方块的人都明白,它给人的感觉就像是嗑瓜子一样,一旦开始就会像上瘾一样难以停下来,绞尽脑汁只想填满空缺的地方. ​ 哈哈哈!小编每周的话基本上都会整理一些游戏代码的哈! 这一期文章就带大家来开发一款俄罗斯方块小游戏! 正文 游戏规则:由小方块组成的不同形状的板块陆续从屏幕上方落下来,玩家通过调整板块的位置和方向,

  • Python爬虫实战项目掌握酷狗音乐的加密过程

    1.前言 小编在这里讲一下,下面的内容仅供学习参考,切莫用于商业活动,一经被相关人员发现,本小编概不负责!读者切记切记. 2.获取音乐播放列表 其实,这就是小编要讲的重点,因为就是这部分用到了加密. 我们在搜索栏上输入我们想听的音乐,小编输入:刺客 是不是看到了一系列音乐,怎样得到这些音乐的一些信息呢?(这里指的音乐信息是指音乐的hash值和音乐的album_id值[这两个参数在获取音乐的下载链接那里会用到],当然还包括音乐的名称[不然怎么区别呢?]). 由于这一系列音乐是动态加载出来的,也就是

  • Python PyQt5实战项目之文件拷贝器的具体实现详解

    目录 简介 UI设置 主要逻辑 信号与槽 成果展示 简介 写了一个简单的文件夹内容下所有文件复制到另一个文件夹内,主要逻辑代码是来自<2小时玩转python多线程编程>中的一个章节. UI设置 def ui_init(self): ''' 界面的函数 ''' self.setWindowTitle('拷贝器') self.resize(600,400) self.setMinimumSize(600,400) # 设置窗口的最小值 '''控件''' self.root_btn = QPushB

  • Python PyQt5实战项目之查询器的实现流程详解

    目录 简介 主界面 添加数据的界面 删除数据的界面 修改数据的界面 全部代码 展示 简介 这是一个操作数据库(sqlite3)的项目,用PyQt5进行界面封装. 此次项目最主要的是,主界面与子界面的交互,一个主界面与三个子界面交互 可以添加数据,修改数据,删除数据 主界面 class MainWidget(QMainWindow): def __init__(self): super(MainWidget,self).__init__() self.ui_init() self.connect_

  • Python PyQt5实战项目之网速监控器的实现

    目录 简介 psutil模块使用 主界面 网速线程 全部代码 成果展示 简介 看到了一个能够轻松实现获取系统运行的进程和系统利用率(包括CPU.内存.磁盘.网络等)信息的模块–psutil模块.这次利用psutil.net_io_counters()这个方法. psutil模块使用 >>> psutil.net_io_counters() # 获取网络读写字节/包的个数 snetio(bytes_sent=16775953, bytes_recv=712657945, packets_s

  • python爬虫实战项目之爬取pixiv图片

    自从接触python以后就想着爬pixiv,之前因为梯子有点问题就一直搁置,最近换了个梯子就迫不及待试了下. 爬虫无非request获取html页面然后用正则表达式或者beautifulsoup之类现成工具截取我们想要的页面,pixiv也不例外. 首先我们来实现模拟登陆,虽然大多数情况不需要我们实现模拟登录,但如果你是会员之类的,登录和不登录网页就有区别.思路是登录时抓包抓到post请求,看pixiv构建的post的数据表格是什么格式,我们根据这个格式构建form,然后调用post方法去请求,再

  • Python 游戏大作炫酷机甲闯关游戏爆肝数千行代码实现案例进阶

    目录 导语 正文 一.小编有话说 ​二.游戏规则 2.1闯关模式 2.2技能提示 三.游戏素材 3.1像素画风-- 3.2机甲模型-- 3.3冒险闯关 四.环境安装 五.项目代码 5.1加载动画以及音效 5.2初始化地图 5.3关卡动画 5.4玩家角色 5.5敌人死亡删除 5.6 敌方大BOSS 5.7敌方BOSS章鱼怪 5.8敌方BOSS 绿坦克 5.9掉落的血瓶 5.10捡血包 5.11结束类 六.效果展示 总结 导语 大家早上好哈!--有没有想我啊? 木木子来啦,今日上线放一波大招给大家!

随机推荐