代码分析

状态机：

共分为四个状态：init,game, not game(win, gameover), exit(退出程序)

  • Init:
  1. game_field.reset()
  2. 返回game状态
  • Game:
  1. game_field.draw(stdscr)
  2. action = get_user_action(stdscr) 获取输入
  3. 根据action选择返回对应的状态
  4. 如果是restart就返回init
  5. exit则返回exit
  6. 根据action移动，再判断是赢是输返回对应状态
  7. 都不是，则返回game状态
  • Notgame:
  1. game_field.draw(stdscr)
  2. action = get_user_action(stdscr)
  3. 根据action选择返回对应的状态

主要操作：

主要操作为draw，move，get_user_action，is_win，is_gameover，主要都集成在game_field类里面

game_field：
  • init：height, width, win_value, high_score, score, reset()(生成初始的field)
  • Reset:
  1. 保留了最高分
  2. 将分数重置为0
  3. field数组重置为0
  4. 随机生成了2个位置的2或4
  • Draw:
  1. 清屏&输出当前分数&（如果最高分不为0，输出最高分)
  2. 根据field数组画图(draw_hor_separator(), draw_row(row))
  3. 判断是赢还是输，输出对应语句(is_win(),is_gameover())
  • Move:
  1. 定义了一个move[direction]的函数字典(move_row_left(row))
  2. Move_row_left(row): 定义了两个函数tighten()和merge()。tighten将非零元素删除，merge将相同元素相加。最后返回tighten(merge(tighten(row)))
  3. 判断是否可以移动，可以的话就移动，修改field并且返回True，否则返回False。(is_move_possible())
  • is_win&is_gameover:判断是否达到win_value|任意方向都不可移动
  • Spawn():在0的位置随机生成2或4
  1. 随机生成2或4
  2. 遍历field找到0的位置
  3. 随机选择0位置赋值随机数
Get_user_action()：

获取用户输入，转换成right、left、up、down、quit和restart操作。


自己代码与原始代码的对比：

  • 两个对数组做转秩操作的函数其中的左右倒序：
def reverse(array):
    return [list(reversed(row)) for row in array] # reversed(row)返回迭代器list_reverseiterator object 
    # return [row[::-1] for row in array]

利用reversed函数返回的是迭代器类型，后续对转秩数组操作如果采用下标索引会出错。并且迭代器在使用一次list(reversed(row))后会消耗掉，在第二次使用的时候会重新创建一个新的迭代器，再次调用为空。感觉在除一次遍历之外尽量避免使用。

  • 移动数组将两个相邻且相等的元素合并：
#原始代码：
def merge(row):
    pair = False
    new_row = []
    for i in range(len(row)):
        if pair:
            new_row.append(2 * row[i])
            self.score += 2 * row[i]
            pair = False
            else:
                if i + 1 < len(row) and row[i] == row[i + 1]:
                    pair = True
                    new_row.append(0)
                    else:
                        new_row.append(row[i])
                        assert len(new_row) == len(row)
                        return new_row

用了两层if判断，一是与前一个元素相同，新数组写进两者之和，计分；二是与前一元素不同，再判断。如果与下一元素相同，新数组写0，修改标签；否则新数组写入当前元素。

#我的代码：
def merge(row): 
    flag=False
    new_row=[]
    for i in range(len(row)):
        try:
            if flag:
                new_row[i-1]=0
                new_row.append(row[i]*2)
                self.score+=row[i]*2
                flag=False
                else:
                    flag=True if row[i]==row[i+1] else False
                    new_row.append(row[i])
                    except:
                        new_row.append(row[i])
                        return new_row

一层if判断，区别在于与不考虑是否与后一元素是否相等，先写入原始元素并且判断，等到遍历到下一元素时再修改前一元素。

  • 判断赢了没：
def is_win(self):
    return any([self.field[i][j]>= self.win_value for i in range(self.height) for j in range(self.width)])
	# return any(any(i >= self.win_value for i in row) for row in self.field)

要习惯用迭代值来遍历list

  • 画分隔符():
def draw_hor_separator():
    line = '+' + ('+------' * self.width + '+')[1:]
    separator = defaultdict(lambda: line)
    if not hasattr(draw_hor_separator, "counter"):
        draw_hor_separator.counter = 0
        cast(separator[draw_hor_separator.counter])
        draw_hor_separator.counter += 1

这里使用了一种[函数名].[变量名]的格式声明并引用变量counter，这种格式它意味着函数本身也是对象，也可以像其他对象一样拥有属性；在这种情况下，可能的目的是拥有一些其他语言所称的"静态"变量——一个对函数本身存在全局性的变量，而不是一个单独的调用。可以在外部调用。

def example():
    pass
example.foo ="hello"
print(example.foo)

作者的意思大概是生成一个默认字典defauldict，每次修改counter值作为默认字典的输入，然后输出一行分隔符。但是好像没啥必要？反正最后都是要在循环中调用n次，为什么不直接输出一行分隔符呢？我的代码直接输出目前没发现什么问题。

  • 判断当前方向是否可移动中的某一行是否可移动：
#原始代码
def row_is_left_movable(row):
    def change(i):  # true if there'll be change in i-th tile
        if row[i] == 0 and row[i + 1] != 0:  # Move
            return True
        if row[i] != 0 and row[i + 1] == row[i]:  # Merge
            return True
        return False
    return any(change(i) for i in range(len(row) - 1))

判别单个元素是否具备可移动的特征，但是其实可以写成某一行是否具备可移动特征。

#我的代码
def is_row_movable(row):
    if 0 in row:
        return True
    for i in range(self.width-1):
        if row[i]==row[i+1]:
            return True
        return False

不用反复调用我觉得还挺简单的23333

  • 原始代码中move操作有一个返回值，是否移动成功。加了这个返回值就可以省略主程序中调用is_move_possible函数进行判断。
  • 原始代码中not_game在判断是win还是gameover时使用了默认字典。默认是当前状态，如果没有行为就会一直在当前界面循环。我是用if…elif…else实现的。感觉默认字典看起来要厉害一些233333

学到的知识点：

  • Python_函数做字典的值 ：当需要用到3个及以上的if…elif…else时就要考虑该方法进行简化，通过将函数名称当做字典的值，利用字典的关键字查询，可以快速定位函数，然后执行
  • 默认字典：
    访问字典中某个‘键’时，若键不存在则会报错。解决方法有两种：字典自带的setdefault函数和collections模块的defaultdict函数。
  • 其中setdefault能为某一个键设置默认值，再次赋值可以被修改。
  • defaultdict可以为所有不存在的key设置一个默认值。
    defaultdict的构造函数接受一个工厂函数作为参数。一个类型名可以作为一个工厂函数，例如collections.defaultdict(int)默认返回0；collections.defaultdict(tuple)默认返回(); collections.defaultdict(str)默认返回空字符串。
    该函数在生成默认值时进行无参调用。因此如果使用类型名作为工厂函数，该类型名一定要具有无参构造函数。
class Test:
    def __init__(self): #无参构造函数
        print("testing")
dd = collections.defaultdict(Test) #使用自定义类型Test作为工厂函数
print(dd['a']) #运行到这里输出testing