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

2023-08-10 04:58:04 169

上篇更新到pygame实现俄罗斯方块游戏（AI篇2），原本应该继续做优化，不过考虑到完成游戏完整性，这张就先把对战做好。

一、对战的方块管理

定义一个BlockManage管理对战的方块

classBlockManage(object):
pnum=1
blocks=[]
def__init__(self,pnum):
self.pnum=pnum
self.blocks=[[]foriinrange(self.pnum)]

defget_block(self,pid=0):
iflen(self.blocks[pid])==0:
block=create_block()
forarrinself.blocks:
arr.append(pickle.loads(pickle.dumps(block)))
returnself.blocks[pid].pop(0)

根据BlockManage根据传入的玩家id返回方块，保证每个玩家拿到的方块序列十一致的，所以在每次创建方块时存放了玩家数量相同的拷贝，拷贝是避免对象的引用造成对同一个方块对象操作混乱。

然后HintBox里加入block_manage的引用并且在take_block函数里将创建Block改为使用block_manage去取方块

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

deftake_block(self):
block=self.next_block
ifblockisNone:#makefirstblock
block=self.block_manage.get_block()

self.next_block=self.block_manage.get_block()
returnblock

分别定义一个VirtualHintBox和一个VirtualScoreBox，用于给右下角面板上的

classVirtualHintBox(object):
pid=0
block_manage=None
next_block=None
def__init__(self,pid,block_manage):
printpid
self.pid=pid
self.block_manage=block_manage

deftake_block(self):
block=self.next_block
ifblockisNone:#makefirstblock
block=block_manage.get_block(self.pid)

self.next_block=block_manage.get_block(self.pid)
returnblock

classVirtualScoreBox(object):
total_score=0
def__init__(self):
pass

defadd_score(self,score):
self.total_score+=score

使用block_manage并分别传递给主面板的hint_box和右下角面板的VirtualHintBox,右下角面板的定义和初使设置完了以后，将下面的player改为player1和player2两个玩家。

在游戏主循环增加完相应的设置和操作，现在就可以玩人机对战了。

当然如果你把

player1=HumanPlayer()
player2=AIPlayer(ai_diff_ticks=350)

改成

player1=AIPlayer(ai_diff_ticks=150)
player2=AIPlayer(ai_diff_ticks=350)

当然就是一场机器人对机器人的战斗

二、记分和增加对抗性

增加记分显示比较容易，给VirtualScoreBox实现下paint就行。

classVirtualScoreBox(object):
total_score=0
def__init__(self,bg,position):
self._bg=bg;
self._x,self._y,self._width,self._height=position
self._bgcolor=[0,0,0]

defpaint(self):
myfont=pygame.font.Font(None,22)
white=255,255,255
textImage=myfont.render('Player2Score:%06d'%(self.total_score),True,white)
self._bg.blit(textImage,(self._x,self._y))

defadd_score(self,score):
self.total_score+=score

增加对抗性的话先设置个规则，谁的分数满1000，就可以给另一方增加两层方块作为攻击，为便于计算，我们在Panel里增加一个数字，用于标记对对方攻击的次数。

Panel里增加一个添加障碍物的函数

defadd_hinder(self):
hinder_lines=2
fortmpinself.rect_arr:
tmp.y-=hinder_lines
foryinrange(hinder_lines):
arr=range(10)
foriinrange(5):
n=random.randint(0,len(arr)-1)
arr.pop(n)
forxinarr:
self.rect_arr.append(RectInfo(x,19-y,[0,0,255]))

Panel里再添加一个获取是否有攻击触发的函数

defget_attach_num(self):
ifself.score_box.total_score/1000>self.attack_num:
self.attack_num+=1
return1
else:
return0

主循环里再增加攻击的处理

好了，现在对战效果也完成了。

最后再给AIPlayer一个level属性，将level映射为时间间隔

以现在的机器人水平，试了下大概能战胜5级的AIPlayer。

最后附下目前的代码。

#-*-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+ydiff2:empty_arr.append((self.cols,miny_arr[1]-miny_arr[0]))
ifminy_arr[self.cols-2]-miny_arr[self.cols-1]>2:empty_arr.append((miny_arr[self.cols-2]-miny_arr[self.cols-1],self.cols))
forxinrange(1,self.cols-1):
ifminy_arr[x-1]-miny_arr[x]>2orminy_arr[x+1]-miny_arr[x]>2:empty_arr.append((miny_arr[x-1]-miny_arr[x],miny_arr[x+1]-miny_arr[x]))
returnempty_arr

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

classPlayer(object):
auto_mode=False
def__init__(self):
pass
defrun(self,panel):
pass

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

classAIPlayer(Player):
cal_block_id=-1
ctl_arr=[]#controlarr,1＝change、2＝left、3＝right、4＝down
auto_mode=True
ai_diff_ticks=100#timespanbetweentwocontrols
level=None

def__init__(self,level=None,ai_diff_ticks=100):
super(Player,self).__init__()
self.ai_diff_ticks=ai_diff_ticks
self.level=level
iflevelisnotNone:
level=int(level)
iflevel<1:level=1
iflevel>10:level=10
self.ai_diff_ticks=1000/level

self.ctl_ticks=pygame.time.get_ticks()+self.ai_diff_ticks

defget_cost_of_emptycol(self,empty_arr):
cost=0
forl,rinempty_arr:
ifl>2andr>2:cost+=(l+r)*2
elifl>2:cost+=l
else:cost+=r
returncost

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])

#clonematrixandfillnewblocktocalculateholes
clone_matrix=matrix.clone()
clone_matrix.fill_block(center_shape,xdiff=xdiff,ydiff=max_yindex)
clear_num=clone_matrix.do_clear()
score-=clone_matrix.get_block_above_hole()
empty_arr=clone_matrix.get_empty_col()
score-=self.get_cost_of_emptycol(empty_arr)
score+=clear_num*5
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_idisnew
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

classBlockManage(object):
pnum=1
blocks=[]
def__init__(self,pnum):
self.pnum=pnum
self.blocks=[[]foriinrange(self.pnum)]

defget_block(self,pid=0):
iflen(self.blocks[pid])==0:
block=create_block()
forarrinself.blocks:
arr.append(pickle.loads(pickle.dumps(block)))
returnself.blocks[pid].pop(0)

classVirtualHintBox(object):
pid=0
block_manage=None
next_block=None
def__init__(self,pid,block_manage):
printpid
self.pid=pid
self.block_manage=block_manage

deftake_block(self):
block=self.next_block
ifblockisNone:#makefirstblock
block=block_manage.get_block(self.pid)

self.next_block=block_manage.get_block(self.pid)
returnblock

defpaint(self):
pass

classHintBox(VirtualHintBox):
def__init__(self,bg,block_size,position,block_manage):
super(VirtualHintBox,self).__init__()
self._bg=bg;
self._x,self._y,self._width,self._height=position
self._block_size=block_size
self._bgcolor=[0,0,0]

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-10))
textImage=myfont.render('Score:%06d'%(self.total_score),True,white)
self._bg.blit(textImage,(self._x,self._y+20))

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+'))

classVirtualScoreBox(object):
total_score=0
def__init__(self,bg,position):
self._bg=bg;
self._x,self._y,self._width,self._height=position
self._bgcolor=[0,0,0]

defpaint(self):
myfont=pygame.font.Font(None,22)
white=255,255,255
textImage=myfont.render('Player2Score:%06d'%(self.total_score),True,white)
self._bg.blit(textImage,(self._x,self._y))

defadd_score(self,score):
self.total_score+=score

classPanel(object):
attack_num=0
block_id=0
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]
self.block_id=0
self.rect_arr=[]
self.moving_block=None

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):
printblock.get_rect_arr()
forx,yinblock.get_rect_arr():
self.rect_arr.append(RectInfo(x,y,block.color))
printlen(self.rect_arr)

defcreate_move_block(self):
self.block_id+=1
block=self.hint_box.take_block()
#block=create_block()
block.move(COL_COUNT/2-2,-2)#moveblocktotopcenter
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#gameover
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)

defget_attach_num(self):
ifself.score_box.total_score/1000>self.attack_num:
self.attack_num+=1
return1
else:
return0

defadd_hinder(self):
hinder_lines=2
fortmpinself.rect_arr:
tmp.y-=hinder_lines
foryinrange(hinder_lines):
arr=range(10)
foriinrange(5):
n=random.randint(0,len(arr)-1)
arr.pop(n)
forxinarr:
self.rect_arr.append(RectInfo(x,19-y,[0,0,255]))

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.moving_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)


self.score_box.paint()
self.hint_box.paint()

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)

block_manage=BlockManage(2)#twoplayers
defrun():
pygame.init()
addition_width=160
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+addition_width+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,addition_width,addition_width],block_manage)
score_box=ScoreBox(screen,main_block_size,[main_panel_width+space+space,addition_width+space*2,addition_width,addition_width])

main_panel.hint_box=hint_box
main_panel.score_box=score_box

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

battle_panel_width=160
battle_block_width=battle_panel_width/COL_COUNT
battle_panel_height=battle_block_width*ROW_COUNT
battle_panel_x=main_panel_width+space+space+(addition_width-battle_panel_width)
battle_panel_y=main_panel_height+space-battle_panel_height
battle_panel=Panel(screen,battle_block_width,[battle_panel_x,battle_panel_y,battle_panel_width,battle_panel_height])
battle_panel.hint_box=VirtualHintBox(1,block_manage)
battle_panel.score_box=VirtualScoreBox(screen,[battle_panel_x,battle_panel_y-16,addition_width,16])
battle_panel.create_move_block()


diff_ticks=300
ticks=pygame.time.get_ticks()+diff_ticks

player1=HumanPlayer()
#player1=AIPlayer(ai_diff_ticks=100)
player2=AIPlayer(level=5)

pause=0
game_state=1#gamestatus1.normal2.gameover
whileTrue:
foreventinpygame.event.get():
ifevent.type==pygame.QUIT:
pygame.quit()
exit()
ifevent.type==KEYDOWN:
ifevent.key==97:pause=1-pause#pressatopause
ifevent.key==112:#fordebugwherepressp
main_panel.get_rect_matrix().print_matrix()
ifplayer1.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
ifmain_panel.get_attach_num()>0:battle_panel.add_hinder()

screen.fill((100,100,100))#makebackgroundgray
main_panel.paint()
battle_panel.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))
ifgame_state==3:
myfont=pygame.font.Font(None,30)
white=255,255,255
textImage=myfont.render("Player1win",True,white)
screen.blit(textImage,(160,190))

pygame.display.update()

ifpause==1:continue
ifgame_state==1:
player1.run(main_panel)
player2.run(battle_panel)
ifgame_state==1andpygame.time.get_ticks()>=ticks:
ticks+=diff_ticks
ifmain_panel.move_block()==9:game_state=2#gameover
ifmain_panel.get_attach_num()>0:battle_panel.add_hinder()
ifbattle_panel.move_block()==9:game_state=3#gameover
ifbattle_panel.get_attach_num()>0:main_panel.add_hinder()

run()

更多关于俄罗斯方块的文章，请点击查看专题：《俄罗斯方块》

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

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

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

热门推荐

随机推荐