pygame实现俄罗斯方块游戏（AI篇1）

2023-08-10 04:52:03 67

上次更新到pygame实现俄罗斯方块游戏（基础篇3）

现在继续

一、定义玩家类

定义玩家类是为了便于进行手动和机器模式或各种不同机器人模式的混合使用，增加代码扩展性。
可以先定义一个玩家基类

classPlayer(object):
auto_mode=False#是否是自动模式，自动模式应当不响应键盘操作
def__init__(self):
pass
defrun(self):#进行操作
pass

手动类和机器类继承自Player类

classHumanPlayer(Player):
def__init__(self):
super(Player,self).__init__()

classAIPlayer(Player):
auto_mode=True
def__init__(self):
super(Player,self).__init__()
defrun(self):
pass

下面然后游戏代码中做下面三处修改

好了，现在玩家类添加完毕，由于HumanPlayer类的run执行的是pass，原来的操作没有受到影响，下面该去实现AIPlayer的run了

二、贪心计算

方块有N种形态，每种形态有若干种水平位置，假设AI只管方块变形和移动能落得最低位置，越低越好。
首先，我们要将当前游戏界面的方块情况告诉玩家，所以我们在Player类的run函数增加一下panel参数，将panel作为run的参数传入。

AIPlayer的代码大致改成下面这样

classAIPlayer(Player):
cal_block_id=-1#用于判断是否方块发生了变化
ctl_arr=[]#存：1＝变、2＝左、3＝右、4＝下，这些数
auto_mode=True
def__init__(self):
super(Player,self).__init__()

defrun(self,panel):
ifpanel.block_id==self.cal_block_id:#block_id没变，按原来计算好的操作规则进行
iflen(ctl_arr)>0:
ctl=self.ctl_arr.pop(0)
ifctl==1:panel.change_block()
ifctl==2:panel.control_block(-1,0)
ifctl==3:panel.control_block(1,0)
ifctl==4:
flag=panel.move_block()
whileflag==1:
flag=panel.move_block()
ifflag==9:game_state=2
else:#block_id变了，计算新方块的操作规则
self.cal_block_id=panel.block_id
matrix=panel.get_rect_matrix()
#matrix.print_matrix()#printfordebug
#
#添加计算操作的逻辑
#
pass

这里为了方便计算将panel中rect_arr转成matrix，一般建议matrix用numpy的，这边的使用场景比较简单，就不增加依赖包了，自己实现一个简单的matrix

classMatrix(object):
rows=0
cols=0
data=[]
def__init__(self,rows,cols):
self.rows=rows
self.cols=cols
self.data=[0foriinrange(rows*cols)]

defset_val(self,x,y,val):
self.data[y*self.cols+x]=val

defget_val(self,x,y):
returnself.data[y*cols+x]

defprint_matrix(self):
foriinrange(self.rows):
printself.data[self.cols*i:self.cols*(i+1)]

panel的get_rect_matrix是这么实现的

defget_rect_matrix(self):
matrix=Matrix(ROW_COUNT,COL_COUNT)
forrect_infoinself.rect_arr:
matrix.set_val(rect_info.x,rect_info.y,1)
returnmatrix

为获取不同形态的值，Block类和子类的get_shape函数稍作修改，增加一个输入

classTBlock(Block):#四种形态
shape_id=0
shape_num=4
def__init__(self,n=None):
super(TBlock,self).__init__()
ifnisNone:n=random.randint(0,3)
self.shape_id=n
self.rect_arr=self.get_shape()
self.color=(255,0,0)

defget_shape(self,sid=None):
ifsidisNone:sid=self.shape_id
ifsid==0:return[(0,1),(1,1),(2,1),(1,2)]
elifsid==1:return[(1,0),(1,1),(1,2),(0,1)]
elifsid==2:return[(0,1),(1,1),(2,1),(1,0)]
else:return[(1,0),(1,1),(1,2),(2,1)]

计算最优操作的代码如下，大致思路是落下的四个方块的Y值加起来越大越好

defcal_best_arr(self,panel):
matrix=panel.get_rect_matrix()
#matrix.print_matrix()#printfordebug
cur_shape_id=panel.moving_block.shape_id
shape_num=panel.moving_block.shape_num
max_score=0
best_arr=[]
foriinrange(shape_num):
tmp_shape_id=cur_shape_id+i
iftmp_shape_id>=shape_num:tmp_shape_id=tmp_shape_id%shape_num
tmp_shape=panel.moving_block.get_shape(sid=tmp_shape_id)
center_shape=[]
forx,yintmp_shape:center_shape.append((x+COL_COUNT/2-2,y-2))
minx=COL_COUNT
maxx=0
miny=ROW_COUNT
maxy=-2
forx,yincenter_shape:
ifxmaxx:maxx=x
ifymaxy:maxy=y

forxdiffinrange(-minx,COL_COUNT-maxx):#左右可以移动的范围
arr=[1for_inrange(i)]
ifxdiff<0:[arr.append(2)for_inrange(-xdiff)]
ifxdiff>0:[arr.append(3)for_inrange(xdiff)]
arr.append(4)
foryindexinrange(-miny,ROW_COUNT-maxy):#往下检测碰撞
ifmatrix.cross_block(center_shape,xdiff=xdiff,ydiff=yindex):
break
score=sum([y+yindexforx,yincenter_shape])
#printi,xdiff,yindex,score
ifscore>max_score:
max_score=score
best_arr=arr
self.ctl_arr=best_arr

大概的AI效果有了，但是发现它还不会考虑造成空洞的影响，下面还要继续优化

三、空洞的惩罚

Matrix类加一个获取空洞数的函数，这里先简单定义为上方有方块为空洞

defget_hole_number(self):
hole_num=0
forxinrange(0,self.cols):
foryinrange(1,self.rows):
ifself.get_val(x,y)==0andself.get_val(x,y-1)==1:#上方有方块的当成空洞
#printx,y
hole_num+=1
returnhole_num

计算最佳操作的函数加入空洞的惩罚值修改如下

defcal_best_arr(self,panel):
matrix=panel.get_rect_matrix()
cur_shape_id=panel.moving_block.shape_id
shape_num=panel.moving_block.shape_num
max_score=-10000
best_arr=[]
foriinrange(shape_num):
tmp_shape_id=cur_shape_id+i
iftmp_shape_id>=shape_num:tmp_shape_id=tmp_shape_id%shape_num
tmp_shape=panel.moving_block.get_shape(sid=tmp_shape_id)
center_shape=[]
forx,yintmp_shape:center_shape.append((x+COL_COUNT/2-2,y-2))
minx=COL_COUNT
maxx=0
miny=ROW_COUNT
maxy=-2
forx,yincenter_shape:
ifxmaxx:maxx=x
ifymaxy:maxy=y

forxdiffinrange(-minx,COL_COUNT-maxx):#左右可以移动的范围
arr=[1for_inrange(i)]
ifxdiff<0:[arr.append(2)for_inrange(-xdiff)]
ifxdiff>0:[arr.append(3)for_inrange(xdiff)]

max_yindex=-miny
foryindexinrange(-miny,ROW_COUNT-maxy):#往下检测碰撞
ifmatrix.cross_block(center_shape,xdiff=xdiff,ydiff=yindex):
break
max_yindex=yindex
score=sum([y+max_yindexforx,yincenter_shape])

#克隆矩阵并且将方块落下，便于计算落下后的空洞数
clone_matrix=matrix.clone()
clone_matrix.fill_block(center_shape,xdiff=xdiff,ydiff=max_yindex)
score-=clone_matrix.get_hole_number()*COL_COUNT

ifscore>max_score:
max_score=score
best_arr=arr
self.ctl_arr=best_arr+[4]

现在AI的表现正常一些了，先优化到这，下章继续，下面继续贴下目前的完整代码

#-*-coding=utf-8-*-
importrandom
importpygame
frompygame.localsimportKEYDOWN,K_LEFT,K_RIGHT,K_UP,K_DOWN,K_SPACE
importpickle,os

ROW_COUNT=20
COL_COUNT=10
SCORE_MAP=(100,300,800,1600)

classMatrix(object):
rows=0
cols=0
data=[]
def__init__(self,rows,cols,data=None):
self.rows=rows
self.cols=cols
ifdataisNone:data=[0foriinrange(rows*cols)]
self.data=data

defset_val(self,x,y,val):
self.data[y*self.cols+x]=val

defget_val(self,x,y):
returnself.data[y*self.cols+x]

defcross_block(self,rect_arr,xdiff=0,ydiff=0):
forx,yinrect_arr:
#ifx+xdiff>=0andx+xdiff=0andy+ydiff=shape_num:tmp_shape_id=tmp_shape_id%shape_num
tmp_shape=panel.moving_block.get_shape(sid=tmp_shape_id)
center_shape=[]
forx,yintmp_shape:center_shape.append((x+COL_COUNT/2-2,y-2))
minx=COL_COUNT
maxx=0
miny=ROW_COUNT
maxy=-2
forx,yincenter_shape:
ifxmaxx:maxx=x
ifymaxy:maxy=y

forxdiffinrange(-minx,COL_COUNT-maxx):#左右可以移动的范围
arr=[1for_inrange(i)]
ifxdiff<0:[arr.append(2)for_inrange(-xdiff)]
ifxdiff>0:[arr.append(3)for_inrange(xdiff)]

max_yindex=-miny
foryindexinrange(-miny,ROW_COUNT-maxy):#往下检测碰撞
ifmatrix.cross_block(center_shape,xdiff=xdiff,ydiff=yindex):
break
max_yindex=yindex
score=sum([y+max_yindexforx,yincenter_shape])

#克隆矩阵并且将方块落下，便于计算落下后的空洞数
clone_matrix=matrix.clone()
clone_matrix.fill_block(center_shape,xdiff=xdiff,ydiff=max_yindex)
score-=clone_matrix.get_hole_number()*COL_COUNT

ifscore>max_score:
max_score=score
best_arr=arr
self.ctl_arr=best_arr+[4]

defrun(self,panel):
ifpygame.time.get_ticks()0:
ctl=self.ctl_arr.pop(0)
ifctl==1:panel.change_block()
ifctl==2:panel.control_block(-1,0)
ifctl==3:panel.control_block(1,0)
ifctl==4:
flag=panel.move_block()
whileflag==1:
flag=panel.move_block()

else:#block_id变了，计算新方块的操作规则
self.cal_block_id=panel.block_id
self.cal_best_arr(panel)


classRectInfo(object):
def__init__(self,x,y,color):
self.x=x
self.y=y
self.color=color

classHintBox(object):
next_block=None
def__init__(self,bg,block_size,position):
self._bg=bg;
self._x,self._y,self._width,self._height=position
self._block_size=block_size
self._bgcolor=[0,0,0]

deftake_block(self):
block=self.next_block
ifblockisNone:#如果还没有方块，先产生一个
block=create_block()

self.next_block=create_block()#产生下一个方块
returnblock

defpaint(self):
mid_x=self._x+self._width/2
pygame.draw.line(self._bg,self._bgcolor,[mid_x,self._y],[mid_x,self._y+self._height],self._width)
bz=self._block_size
#绘制正在落下的方块
ifself.next_block:
arr=self.next_block.get_rect_arr()
minx,miny=arr[0]
maxx,maxy=arr[0]
forx,yinarr:
ifxmaxx:maxx=x
ifymaxy:maxy=y
w=(maxx-minx)*bz
h=(maxy-miny)*bz
#计算使方块绘制在提示窗中心位置所需要的偏移像素
cx=self._width/2-w/2-minx*bz-bz/2
cy=self._height/2-h/2-miny*bz-bz/2

forrectinarr:
x,y=rect
pygame.draw.line(self._bg,self.next_block.color,[self._x+x*bz+cx+bz/2,self._y+cy+y*bz],[self._x+x*bz+cx+bz/2,self._y+cy+(y+1)*bz],bz)
pygame.draw.rect(self._bg,[255,255,255],[self._x+x*bz+cx,self._y+y*bz+cy,bz+1,bz+1],1)

classScoreBox(object):
total_score=0
high_score=0
db_file='tetris.db'
def__init__(self,bg,block_size,position):
self._bg=bg;
self._x,self._y,self._width,self._height=position
self._block_size=block_size
self._bgcolor=[0,0,0]

ifos.path.exists(self.db_file):self.high_score=pickle.load(open(self.db_file,'rb'))

defpaint(self):
myfont=pygame.font.Font(None,36)
white=255,255,255
textImage=myfont.render('High:%06d'%(self.high_score),True,white)
self._bg.blit(textImage,(self._x,self._y))
textImage=myfont.render('Score:%06d'%(self.total_score),True,white)
self._bg.blit(textImage,(self._x,self._y+40))

defadd_score(self,score):
self.total_score+=score
ifself.total_score>self.high_score:
self.high_score=self.total_score
pickle.dump(self.high_score,open(self.db_file,'wb+'))

classPanel(object):#用于绘制整个游戏窗口的版面
block_id=0
#rect_arr=[RectInfo(4,19,[0,0,255]),RectInfo(6,19,[0,0,255])]#已经落底下的方块
rect_arr=[]#已经落底下的方块
moving_block=None#正在落下的方块
hint_box=None
score_box=None
def__init__(self,bg,block_size,position):
self._bg=bg;
self._x,self._y,self._width,self._height=position
self._block_size=block_size
self._bgcolor=[0,0,0]

defget_rect_matrix(self):
matrix=Matrix(ROW_COUNT,COL_COUNT)
forrect_infoinself.rect_arr:
matrix.set_val(rect_info.x,rect_info.y,1)
returnmatrix

defadd_block(self,block):
forx,yinblock.get_rect_arr():
self.rect_arr.append(RectInfo(x,y,block.color))

defcreate_move_block(self):
self.block_id+=1
block=self.hint_box.take_block()
#block=create_block()
block.move(COL_COUNT/2-2,-2)#方块挪到中间
self.moving_block=block

defcheck_overlap(self,diffx,diffy,check_arr=None):
ifcheck_arrisNone:check_arr=self.moving_block.get_rect_arr()
forx,yincheck_arr:
forrect_infoinself.rect_arr:
ifx+diffx==rect_info.xandy+diffy==rect_info.y:
returnTrue
returnFalse

defcontrol_block(self,diffx,diffy):
ifself.moving_block.can_move(diffx,diffy)andnotself.check_overlap(diffx,diffy):
self.moving_block.move(diffx,diffy)

defchange_block(self):
ifself.moving_block:
new_arr=self.moving_block.change()
ifnew_arrandnotself.check_overlap(0,0,check_arr=new_arr):#变形不能造成方块重叠
self.moving_block.rect_arr=new_arr


defmove_block(self):
ifself.moving_blockisNone:create_move_block()
ifself.moving_block.can_move(0,1)andnotself.check_overlap(0,1):
self.moving_block.move(0,1)
return1
else:
self.add_block(self.moving_block)
self.check_clear()

forrect_infoinself.rect_arr:
ifrect_info.y<0:return9#游戏失败
self.create_move_block()
return2

defcheck_clear(self):
tmp_arr=[[]foriinrange(20)]
#先将方块按行存入数组
forrect_infoinself.rect_arr:
ifrect_info.y<0:return
tmp_arr[rect_info.y].append(rect_info)

clear_num=0
clear_lines=set([])
y_clear_diff_arr=[[]foriinrange(20)]
#从下往上计算可以消除的行，并记录消除行后其他行的向下偏移数量
foryinrange(19,-1,-1):
iflen(tmp_arr[y])==10:
clear_lines.add(y)
clear_num+=1
y_clear_diff_arr[y]=clear_num

ifclear_num>0:
new_arr=[]
#跳过移除行，并将其他行做偏移
foryinrange(19,-1,-1):
ifyinclear_lines:continue
tmp_row=tmp_arr[y]
y_clear_diff=y_clear_diff_arr[y]
forrect_infointmp_row:
#new_arr.append([x,y+y_clear_diff])
new_arr.append(RectInfo(rect_info.x,rect_info.y+y_clear_diff,rect_info.color))

self.rect_arr=new_arr
score=SCORE_MAP[clear_num-1]
self.score_box.add_score(score)


defpaint(self):
mid_x=self._x+self._width/2
pygame.draw.line(self._bg,self._bgcolor,[mid_x,self._y],[mid_x,self._y+self._height],self._width)#用一个粗线段来填充背景

#绘制已经落底下的方块
bz=self._block_size
forrect_infoinself.rect_arr:
x=rect_info.x
y=rect_info.y
pygame.draw.line(self._bg,rect_info.color,[self._x+x*bz+bz/2,self._y+y*bz],[self._x+x*bz+bz/2,self._y+(y+1)*bz],bz)
pygame.draw.rect(self._bg,[255,255,255],[self._x+x*bz,self._y+y*bz,bz+1,bz+1],1)

#绘制正在落下的方块
ifself.move_block:
forrectinself.moving_block.get_rect_arr():
x,y=rect
pygame.draw.line(self._bg,self.moving_block.color,[self._x+x*bz+bz/2,self._y+y*bz],[self._x+x*bz+bz/2,self._y+(y+1)*bz],bz)
pygame.draw.rect(self._bg,[255,255,255],[self._x+x*bz,self._y+y*bz,bz+1,bz+1],1)

classBlock(object):
sx=0
sy=0
def__init__(self):
self.rect_arr=[]

defget_rect_arr(self):#用于获取方块种的四个矩形列表
returnself.rect_arr

defmove(self,xdiff,ydiff):#用于移动方块的方法
self.sx+=xdiff
self.sy+=ydiff
self.new_rect_arr=[]
forx,yinself.rect_arr:
self.new_rect_arr.append((x+xdiff,y+ydiff))
self.rect_arr=self.new_rect_arr

defcan_move(self,xdiff,ydiff):
forx,yinself.rect_arr:
ify+ydiff>=20:returnFalse
ifx+xdiff<0orx+xdiff>=10:returnFalse
returnTrue

defchange(self):
self.shape_id+=1#下一形态
ifself.shape_id>=self.shape_num:
self.shape_id=0

arr=self.get_shape()
new_arr=[]
forx,yinarr:
ifx+self.sx<0orx+self.sx>=10:#变形不能超出左右边界
self.shape_id-=1
ifself.shape_id<0:self.shape_id=self.shape_num-1
returnNone

new_arr.append([x+self.sx,y+self.sy])

returnnew_arr

classLongBlock(Block):
shape_id=0
shape_num=2
def__init__(self,n=None):#两种形态
super(LongBlock,self).__init__()
ifnisNone:n=random.randint(0,1)
self.shape_id=n
self.rect_arr=self.get_shape()
self.color=(50,180,50)

defget_shape(self,sid=None):
ifsidisNone:sid=self.shape_id
return[(1,0),(1,1),(1,2),(1,3)]ifsid==0else[(0,2),(1,2),(2,2),(3,2)]

classSquareBlock(Block):#一种形态
shape_id=0
shape_num=1
def__init__(self,n=None):
super(SquareBlock,self).__init__()
self.rect_arr=self.get_shape()
self.color=(0,0,255)

defget_shape(self,sid=None):
ifsidisNone:sid=self.shape_id
return[(1,1),(1,2),(2,1),(2,2)]

classZBlock(Block):#两种形态
shape_id=0
shape_num=2
def__init__(self,n=None):
super(ZBlock,self).__init__()
ifnisNone:n=random.randint(0,1)
self.shape_id=n
self.rect_arr=self.get_shape()
self.color=(30,200,200)

defget_shape(self,sid=None):
ifsidisNone:sid=self.shape_id
return[(2,0),(2,1),(1,1),(1,2)]ifsid==0else[(0,1),(1,1),(1,2),(2,2)]

classSBlock(Block):#两种形态
shape_id=0
shape_num=2
def__init__(self,n=None):
super(SBlock,self).__init__()
ifnisNone:n=random.randint(0,1)
self.shape_id=n
self.rect_arr=self.get_shape()
self.color=(255,30,255)

defget_shape(self,sid=None):
ifsidisNone:sid=self.shape_id
return[(1,0),(1,1),(2,1),(2,2)]ifsid==0else[(0,2),(1,2),(1,1),(2,1)]

classLBlock(Block):#四种形态
shape_id=0
shape_num=4
def__init__(self,n=None):
super(LBlock,self).__init__()
ifnisNone:n=random.randint(0,3)
self.shape_id=n
self.rect_arr=self.get_shape()
self.color=(200,200,30)

defget_shape(self,sid=None):
ifsidisNone:sid=self.shape_id
ifsid==0:return[(1,0),(1,1),(1,2),(2,2)]
elifsid==1:return[(0,1),(1,1),(2,1),(0,2)]
elifsid==2:return[(0,0),(1,0),(1,1),(1,2)]
else:return[(0,1),(1,1),(2,1),(2,0)]

classJBlock(Block):#四种形态
shape_id=0
shape_num=4
def__init__(self,n=None):
super(JBlock,self).__init__()
ifnisNone:n=random.randint(0,3)
self.shape_id=n
self.rect_arr=self.get_shape()
self.color=(200,100,0)

defget_shape(self,sid=None):
ifsidisNone:sid=self.shape_id
ifsid==0:return[(1,0),(1,1),(1,2),(0,2)]
elifsid==1:return[(0,1),(1,1),(2,1),(0,0)]
elifsid==2:return[(2,0),(1,0),(1,1),(1,2)]
else:return[(0,1),(1,1),(2,1),(2,2)]

classTBlock(Block):#四种形态
shape_id=0
shape_num=4
def__init__(self,n=None):
super(TBlock,self).__init__()
ifnisNone:n=random.randint(0,3)
self.shape_id=n
self.rect_arr=self.get_shape()
self.color=(255,0,0)

defget_shape(self,sid=None):
ifsidisNone:sid=self.shape_id
ifsid==0:return[(0,1),(1,1),(2,1),(1,2)]
elifsid==1:return[(1,0),(1,1),(1,2),(0,1)]
elifsid==2:return[(0,1),(1,1),(2,1),(1,0)]
else:return[(1,0),(1,1),(1,2),(2,1)]

defcreate_block():
n=random.randint(0,18)
ifn==0:returnSquareBlock(n=0)
elifn==1orn==2:returnLongBlock(n=n-1)
elifn==3orn==4:returnZBlock(n=n-3)
elifn==5orn==6:returnSBlock(n=n-5)
elifn>=7andn<=10:returnLBlock(n=n-7)
elifn>=11andn<=14:returnJBlock(n=n-11)
else:returnTBlock(n=n-15)

defrun():
pygame.init()
space=30
main_block_size=30
main_panel_width=main_block_size*COL_COUNT
main_panel_height=main_block_size*ROW_COUNT
screencaption=pygame.display.set_caption('Tetris')
screen=pygame.display.set_mode((main_panel_width+160+space*3,main_panel_height+space*2))#设置窗口长宽
main_panel=Panel(screen,main_block_size,[space,space,main_panel_width,main_panel_height])
hint_box=HintBox(screen,main_block_size,[main_panel_width+space+space,space,160,160])
score_box=ScoreBox(screen,main_block_size,[main_panel_width+space+space,160+space*2,160,160])

main_panel.hint_box=hint_box
main_panel.score_box=score_box

pygame.key.set_repeat(200,30)
main_panel.create_move_block()

diff_ticks=300#移动一次蛇头的事件，单位毫秒
ticks=pygame.time.get_ticks()+diff_ticks

player=AIPlayer()

pause=0
game_state=1#游戏状态1.表示正常2.表示失败
whileTrue:
foreventinpygame.event.get():
ifevent.type==pygame.QUIT:
pygame.quit()
exit()
ifevent.type==KEYDOWN:
ifevent.key==97:pause=1-pause#按键盘a支持暂停
ifevent.key==112:#fordebug#按键盘p打印矩阵信息
main_panel.get_rect_matrix().print_matrix()
ifplayer.auto_mode:continue
ifevent.type==KEYDOWN:
ifevent.key==K_LEFT:main_panel.control_block(-1,0)
ifevent.key==K_RIGHT:main_panel.control_block(1,0)
ifevent.key==K_UP:main_panel.change_block()
ifevent.key==K_DOWN:main_panel.control_block(0,1)
ifevent.key==K_SPACE:
flag=main_panel.move_block()
whileflag==1:
flag=main_panel.move_block()
ifflag==9:game_state=2

screen.fill((100,100,100))#将界面设置为灰色
main_panel.paint()#主面盘绘制
hint_box.paint()#绘制下一个方块的提示窗
score_box.paint()#绘制总分

ifgame_state==2:
myfont=pygame.font.Font(None,30)
white=255,255,255
textImage=myfont.render("Gameover",True,white)
screen.blit(textImage,(160,190))

pygame.display.update()#必须调用update才能看到绘图显示

ifpause==1:continue
ifgame_state==1:player.run(main_panel)
ifgame_state==1andpygame.time.get_ticks()>=ticks:
ticks+=diff_ticks
ifmain_panel.move_block()==9:game_state=2#游戏结束

run()

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

pygame实现俄罗斯方块游戏（AI篇1）

热门推荐

随机推荐