俄罗斯方块(三):”流动”的方块

图片 17

 

编程语言:python(3.6.4)

 

主要应用的模块:pygame

 问题的提出:

 

俄罗斯方块允许90度的坡,是不是有点不够科学#(滑稽)

首先列出我的核心思路:

想办法加一种会“滑坡”的方块

1,图像由“核心变量”完全控制,图像变化的本质是 变量的改变

本文两大部分:

2,自上而下式的思考,图像变化的问题将一步步转为 一系列具体的变量修改

详细的描绘是怎样的“流动”

3,“核心变量”在思考过程中并非不可变更,为了写函数方便,可以适当让步

写代码,并整合进游戏

 

 

正文开始:

 本文基于我写的

核心变量到图像

首先看成品图预览图

图片 1

从上图和游戏玩法可以得出以下两点:

1,方块位置十分有规律

2,两类方块(上面移动的,下方固定的 都比较有特点)

方块的大小都是固定的,只需要操心位置的问题,下面建坐标系

图片 2

下一步,坐标的储存方式

记录方式有两种:

1,横纵坐标做一个二元元组,再用一个列表装着一堆二元元组

例如:[(20,1),(20,2),(20,3),(20,4)]代表第20行的1~4列的四个方块

2,二维数组,一行是一个列表,用两个索引代表横纵坐标,值为1就代表有方块,0就是没有方块

例如:block[20][1] 值为1就表示20行第1列有方块,block[20][5]
为0表示20行第5列有没有方块

 

讲道理,两种记录方式没什么大区别,而且第一种似乎更好用

但后面会有这样的问题

 

怎么判断一行是否被填满,填满后怎么消除,消除后怎么使上方的方块下落。

两种记录方式对应的解法:

1,假如判断第2行 只要依次判断(2, 0), (2, 1)···· (2, 8), (2, 9)
是否都存在于列表就可以,消除、下落就有点麻烦,以第2行为例 遍历列表
2行以下的不修改,2行的全部清除,2行以上的 行数-1

2,被填满 等价于 全是1  等价于 没有0 ,一个not in
就可以啦,pop就可以清除一行,而且后面列表的索引会向前补(实现下落),然后在最后补充一个空列表就完事啦(防止被删光)

所以

充当背景的方块 就使用2号记录方式

下一步 对接pygame绘制函数

核心变量的声明

background = [[0 for i in range(10)]for j in range(21)]
active = []

绘制函数

# 第一版
def new_draw():
    screen.fill(white)

    for i in range(1, 21):
        for j in range(10):
            bolck = background[i][j]
            if bolck:
                pygame.draw.rect(screen, blue, (j * 25 + 1, 500 - i * 25 + 1, 23, 23))

    for i, j in active:
        pygame.draw.rect(screen, blue, (j * 25+1, 500 - i * 25 + 1, 23, 23))

    pygame.display.update()

补充:坐标转换

图片 3

俄罗斯方块(一):简版 

键盘到图像(本质:键盘到核心变量)

下面简略列出需要的函数

名称 内容 发生时机
左右移动 修改y轴坐标 键盘事件
旋转 复杂的坐标转化 键盘事件
下落 修改x轴坐标 键盘事件,计时器
下落检查 检查是否可以继续下落 下落  前后
检查方块 逐行检查是否可以消除, 下落检查 后
消除方块 检查方块 后
生成方块 产生下一个方块 消除方块 后
检查存活

生成的方块无法放置<=>

堆到顶端<=>game over

生成方块 后

首先,方块移动的难点在“旋转”上

Q:为什么不先考虑左右移动
A:旋转的问题的有些复杂,需要变更“核心变量”
  核心变量一但变更 其它相关函数都得改写
  所以为了省心,优先考虑可能涉及“核心变量”的事情

解决思路:

1,为每个形状建立一个“状态库”,手写出每个姿态,旋转时再读取

2,旋转前后存在明确的数学关系

图片 4

选那个没有悬念

追加一个变量,记录旋转中心坐标

旋转时依照方程转换坐标

公式很简单吧

如果旋转在原点,将会更简单

图片 5

 PS:注意坐标系,公式不能直接抄

 所以,从记录“绝对坐标”变更为“中心坐标+相对坐标”

PS:绘制函数需要做相应的调整

图片 6

旋转过程 ( x , y ) –> (-y , x)

重要的细节:移动是有限制的

方块在边界处,就得限制向外的移动,如果移动后与已有的方块重叠,也得限制移动

事先上两个动图, 说明下我想做什么

代码时间

左右移动

def move_LR(n):
    """n=-1代表向左,n=1代表向右"""
    x, y = centre
    y += n
    for i, j in active:
        i += x
        j += y
        if j < 0 or j > 9 or background[i][j]:
            break
    else:
        centre.clear()
        centre.extend([x, y])

PS:centre是列表

Q:clear + extend 是什么骚操作?不可以直接赋值吗?
A:函数内部可以读取 但不能修改全局变量
    但是可以调用全局变量的方法
    所以clear+extend修改centra
    这样就不用将centra传入传出啦
    (危险操作,谨慎使用)

旋转的

def rotate():
    x, y = centre
    l = [(-j, i) for i, j in active]
    for i, j in l:
        i += x
        j += y
        if j < 0 or j > 9 or background[i][j]:
            break
    else:
        active.clear()
        active.extend(l)

PS:因为旋转的机制很简陋,会有田字形方块的也能旋转的奇怪现象发生。

讲道理下落并不难,关键是下落结束后会有很多后事要处理

1,检查是否落到底部,是:继续,否:跳出

2,active的信息转到background,

3,检查background是否有“行”被填满 是:继续,否:跳至5

4,清掉满行,补上空行,计分

5,生成新的active,检查其位置是否被占(被占<=>方块被堆至顶部<=>game
over)

那就开始撸代码

def move_down():
    x, y = centre
    x -= 1
    for i, j in active:
        i += x
        j += y
        if background[i][j]:
            break
    else:
        centre.clear()
        centre.extend([x, y])
        return
    # 如果新位置未被占用 通过return结束
    # 如果新位置被占用则继续向下执行
    x, y = centre
    for i, j in active:
        background[x + i][y + j] = 1

    l = []
    for i in range(1, 20):
        if 0 not in background[i]:
            l.append(i)
    # l装 行号,鉴于删去后,部分索引变化,对其降序排列,倒着删除
    l.sort(reverse=True)

    for i in l:
        background.pop(i)
        background.append([0 for j in range(10)])
        # 随删随补

    score[0] += len(l)
    pygame.display.set_caption("分数:%d" % (score[0]))

    active.clear()
    active.extend(list(random.choice(all_block)))
    # all_block保存7种形状的信息,手打出来的
    centre.clear()
    centre.extend([20, 4])

    x, y = centre
    for i, j in active:
        i += x
        j += y
        if background[i][j]:
            break
    else:
        return
    alive.append(1)

图片 7图片 8

控制结构

下一步组装

因为核心变量发生变化,new_draw重写

def new_draw():
    screen.fill(white)

    for i in range(1, 21):
        for j in range(10):
            bolck = background[i][j]
            if bolck:
                pygame.draw.rect(screen, blue, (j * 25 + 1, 500 - i * 25 + 1, 23, 23))

    x, y = centre
    for i, j in active:
        i += x
        j += y
        pygame.draw.rect(screen, blue, (j * 25 + 1, 500 - i * 25 + 1, 23, 23))

    pygame.display.update()

核心变量定义

all_block = (((0, 0), (0, -1), (0, 1), (0, 2)),
             ((0, 0), (0, 1), (-1, 0), (-1, 1)),
             ((0, 0), (0, -1), (-1, 0), (-1, 1)),
             ((0, 0), (0, 1), (-1, -1), (-1, 0)),
             ((0, 0), (0, 1), (1, 0), (0, -1)),
             ((0, 0), (1, 0), (-1, 0), (1, -1)),
             ((0, 0), (1, 0), (-1, 0), (1, 1)))
background = [[0 for i in range(10)] for j in range(24)]
background[0] = [1 for i in range(10)]
active = list(random.choice(all_block))
centre = [20, 4]
score = [0]

标红处的说明:

1,生成方块的时的中心为[20,4]

可能会有方块伸展到 21 层,然后引发 越界错误   ̄へ ̄

所以一口气 将上限设为 24

2,因为测试时发现,方块直接从底部漏了出去(⊙﹏⊙)

 所以,在第零行加一层地板φ(>ω<*) 

 注意尽管第0行 满足 “没有0″的条件,但是

    l = []
    for i in range(1, 20):
        if 0 not in background[i]:
            l.append(i)

这个部分是从第1行才开始检查的(~ ̄▽ ̄)~ 

3,我懒,不想传参,所以 老套路

pygame固定结构,控制结构,控制变量,龙套变量

pygame.init()
screen = pygame.display.set_mode((250, 500))
pygame.display.set_caption("俄罗斯方块")
fclock = pygame.time.Clock()

black = 0, 0, 0
white = 255, 255, 255
blue = 0, 0, 255

times = 0
alive = []
press = False
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                move_LR(-1)
            elif event.key == pygame.K_RIGHT:
                move_LR(1)
            elif event.key == pygame.K_UP:
                rotate()
            elif event.key == pygame.K_DOWN:
                press = True
        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_DOWN:
                press = False
    if press:
        times += 10

    if times >= 50:
        move_down()
        times = 0
    else:
        times += 1

    if alive:
        pygame.display.set_caption("over分数:%d" % (score[0]))
        time.sleep(3)
        break
    new_draw()
    fclock.tick(100)

说明:

1,原来按一次“下”,方块只会移动一格。。。。

所以修正了一下,支持 长按,为此加了一个变量press

2,times用于计时

3,游戏结束的有点突兀,直接就brake啦

最后发现漏了一行没拷上来

import pygame, sys, random, time

下面是全部代码

图片 9图片 10

import pygame, sys, random, time


# 第二版
def new_draw():
    screen.fill(white)

    for i in range(1, 21):
        for j in range(10):
            bolck = background[i][j]
            if bolck:
                pygame.draw.rect(screen, blue, (j * 25 + 1, 500 - i * 25 + 1, 23, 23))

    x, y = centre
    for i, j in active:
        i += x
        j += y
        pygame.draw.rect(screen, blue, (j * 25 + 1, 500 - i * 25 + 1, 23, 23))

    pygame.display.update()


def move_LR(n):
    """n=-1代表向左,n=1代表向右"""
    x, y = centre
    y += n
    for i, j in active:
        i += x
        j += y
        if j < 0 or j > 9 or background[i][j]:
            break
    else:
        centre.clear()
        centre.extend([x, y])


def rotate():
    x, y = centre
    l = [(-j, i) for i, j in active]
    for i, j in l:
        i += x
        j += y
        if j < 0 or j > 9 or background[i][j]:
            break
    else:
        active.clear()
        active.extend(l)


def move_down():
    x, y = centre
    x -= 1
    for i, j in active:
        i += x
        j += y
        if background[i][j]:
            break
    else:
        centre.clear()
        centre.extend([x, y])
        return
    # 如果新位置未被占用 通过return结束
    # 如果新位置被占用则继续向下执行
    x, y = centre
    for i, j in active:
        background[x + i][y + j] = 1

    l = []
    for i in range(1, 20):
        if 0 not in background[i]:
            l.append(i)
    # l装 行号,鉴于删去后,部分索引变化,对其降序排列,倒着删除
    l.sort(reverse=True)

    for i in l:
        background.pop(i)
        background.append([0 for j in range(10)])
        # 随删随补

    score[0] += len(l)
    pygame.display.set_caption("分数:%d" % (score[0]))

    active.clear()
    active.extend(list(random.choice(all_block)))
    # all_block保存7种形状的信息,手打出来的
    centre.clear()
    centre.extend([20, 4])

    x, y = centre
    for i, j in active:
        i += x
        j += y
        if background[i][j]:
            break
    else:
        return
    alive.append(1)


pygame.init()
screen = pygame.display.set_mode((250, 500))
pygame.display.set_caption("俄罗斯方块")
fclock = pygame.time.Clock()

all_block = (((0, 0), (0, -1), (0, 1), (0, 2)),
             ((0, 0), (0, 1), (-1, 0), (-1, 1)),
             ((0, 0), (0, -1), (-1, 0), (-1, 1)),
             ((0, 0), (0, 1), (-1, -1), (-1, 0)),
             ((0, 0), (0, 1), (1, 0), (0, -1)),
             ((0, 0), (1, 0), (-1, 0), (1, -1)),
             ((0, 0), (1, 0), (-1, 0), (1, 1)))
background = [[0 for i in range(10)] for j in range(24)]
background[0] = [1 for i in range(10)]
active = list(random.choice(all_block))
centre = [20, 4]
score = [0]


black = 0, 0, 0
white = 255, 255, 255
blue = 0, 0, 255

times = 0
alive = []
press = False
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                move_LR(-1)
            elif event.key == pygame.K_RIGHT:
                move_LR(1)
            elif event.key == pygame.K_UP:
                rotate()
            elif event.key == pygame.K_DOWN:
                press = True
        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_DOWN:
                press = False
    if press:
        times += 10

    if times >= 50:
        move_down()
        times = 0
    else:
        times += 1

    if alive:
        pygame.display.set_caption("over分数:%d" % (score[0]))
        time.sleep(3)
        break
    new_draw()
    fclock.tick(100)

all

 

 

本文就此结束

如果有疏漏或不对的地方,欢迎评论指正

#

 

 

第一部分

首先是假象图

图片 11

这是一个长条逐渐“瘫软”的过程

归纳规律,其实只有两种移动

 图片 12

1下方没有方块时:向下方滑落

2下方有方块时:向左下或者右下滑落

但是这两条是不够的

下面展示一种例外

图片 13

左边的比右边“更科学”

显然,需要再加一条规则“规则三:下方的方块先行动

但是,这个规则还不够,我又找到两个“不科学的”例子

图片 14

左边的比右边“更科学”

不同行之间需要区分次序,同一行的也要区分次序!!!

行内从左向右,和从右向左都无法从根本解决问题,那就只能调整两种移动的优先级

再加一条规则“规则四:同一行的,下落移动的优先

接下来还有一个“不科学”

图片 15

进去了。。。这是最不科学的一个。。

图片 16

添加一条斜向移动的限制“左右有方块不可斜向移动

然后我发现,规则四没用了!!!

图片 17

说明:1号方块的斜向移动被2号阻止了,上面的情况变成“不可能发生”

它们解决的是同一个问题,水平相邻方块之间的次序问题

只是限制斜向移动的方法更为彻底!

规则汇总: