Python实例浅谈之八2048游戏(字符界面)

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/taiyang1987912/article/details/45392791

一、简介

        使用python完成2048的代码编写。
        2048游戏规则:简单的移动方向键让数字叠加,并且获得这些数字每次叠加后的得分,当出现2048这个数字时游戏胜利。同时每次移动方向键时,都会在这个4*4的方格矩阵的空白区域随机产生一个数字2或者4,如果方格被数字填满了,那么就GameOver了。
         实现思路:2048游戏的全部操作都是围绕着一个4*4的矩阵进行,每次从用户界面获取用户的操作(即移动方向),然后重新计算这个4*4矩阵的状态,最后刷新用户界面显示4*4矩阵的最新状态,不断的循环这个过程,直到出现2048或没有空白方块了,如下是一个处理流程示意图:

二、运行图

      
       Python控制台程序,用字符(W/S/A/D)代表方向键的输入,以数字0代表空白方格。计算部分:以向左移动为例,4*4矩阵在接收到向左移动的指令后,应该将每行的数字向左叠加, 将一行的叠加操作定义为函数 handle(list, direction),其第一个参数用来存储4*4矩阵中的某一行(列),第二个参数表示移动的方向(上下左右)。 这样当左右移动方向键时,可以这样来计算矩阵:遍历矩阵的每行,并将每行的数字沿左或右进行叠加操作,for row in matrix:handle(row, direction)。对于上下移动方向键时,由于矩阵是按行存储的,不能直接处理矩阵中的列,可以通过变通采用上面的函数handle()。对于矩阵中每一列,先将其拷贝到一个列表中,然后调用handle()函数对该列表进行叠加处理,最后再将叠加后的新列表拷贝回原始矩阵中其所在的列,其逻辑上等同于下面的代码操作。

for col in matrix:handle(col, direction)。
       handle(row, direction)函数的作用是沿指定方向叠加一行中的数字,请看下面几个例子:

        实现handle函数是关键。仔细观察叠加的过程,其都是由两个子过程组成的:
(1) align(row, direction)沿direction方向对齐列表row中的数字,例如:
x = [0, 4, 0, 2]
align(x, 'left')  后 x = [4, 2, 0, 0]
在 align(x, 'right') 后 x = [0, 0, 4, 2]
(2) addSame(row, direction) 查找相同且相邻的数字。如果找到,将其中一个翻倍,另一个置0(如果direction是'left'将左侧翻倍,右侧置0,如果direction为'right',将右侧翻倍,左侧置0),并返回True;否则,返回False。例如:
x = [2, 2, 2, 2]
addSame(x, 'left') 后 x = [4, 0, 2, 2]      返回 True
再 addSame(x, 'left') 后 x = [4, 0, 4, 0]   返回 True
再 addSame(x, 'left') 后 x = [4, 0, 4, 0]   返回 False 
       有了上面两个子函数,应该不难实现。有了这两个子函数,函数handle()就很好实现了,如下:
handle(row, direction):
          align(row, direction)
          result = addSame(row, direction)
          while result == True:
                    align(row, direction)
                    result = addSame(row, direction)
     下面结合一个实际例子再来看看handle函数的处理过程:
x = [2, 4, 2, 2]
调用 handle(x, 'right'),变量 x 变化过程:
align(x, 'right')          ->     [2, 4, 2, 2]
addSame(x, 'right')   ->     [2, 4, 0, 4]     ->     return True
align(x, 'right')          ->     [0, 2, 4, 4]    
addSame(x, 'right')   ->     [0, 2, 0, 8]     ->     return True
align(x, 'right')          ->     [0, 0, 2, 8]    
addSame(x, 'right')   ->     [0, 0, 2, 8]     ->     return False
最终得到的 x = [0, 0, 2, 8]

三、详解

(1)文件2048.py,运行:python 2048.py,运行环境linux python2.6.6。
# -*- coding:UTF-8 -*-
#! /usr/bin/python

import random
import sys

v = [[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0] ]

def display(v, score):
	'''显示界面
	'''
	print '{0:4} {1:4} {2:4} {3:4}'.format(v[0][0], v[0][1], v[0][2], v[0][3])
	print '{0:4} {1:4} {2:4} {3:4}'.format(v[1][0], v[1][1], v[1][2], v[1][3])
	print '{0:4} {1:4} {2:4} {3:4}'.format(v[2][0], v[2][1], v[2][2], v[2][3])
	print '{0:4} {1:4} {2:4} {3:4}'.format(v[3][0], v[3][1], v[3][2], v[3][3]), '    Total score: ', score


def init(v):
	'''随机分布网格值
	'''
	for i in range(4):
		v[i] = [random.choice([0, 0, 0, 2, 2, 4]) for x in v[i]]

def align(vList, direction):
	'''对齐非零的数字
        direction == 'left':向左对齐,例如[8,0,0,2]左对齐后[8,2,0,0]
        direction == 'right':向右对齐,例如[8,0,0,2]右对齐后[0,0,8,2]
        '''

	# 移除列表中的0
	for i in range(vList.count(0)):
		vList.remove(0)
	# 被移除的0
	zeros = [0 for x in range(4 - len(vList))]
        # 在非0数字的一侧补充0
	if direction == 'left':
		vList.extend(zeros)
	else:
		vList[:0] = zeros
        
def addSame(vList, direction):
        '''在列表查找相同且相邻的数字相加, 找到符合条件的返回True,否则返回False,同时还返回增加的分数
        direction == 'left':从右向左查找,找到相同且相邻的两个数字,左侧数字翻倍,右侧数字置0
        direction == 'right':从左向右查找,找到相同且相邻的两个数字,右侧数字翻倍,左侧数字置0
	'''
	score = 0
	if direction == 'left':
		for i in [0, 1, 2]:
			if vList[i] == vList[i+1] != 0: 
				vList[i] *= 2
				vList[i+1] = 0
				score += vList[i]
				return {'bool':True, 'score':score}
	else:
		for i in [3, 2, 1]:
			if vList[i] == vList[i-1] != 0:
				vList[i-1] *= 2
				vList[i] = 0
				score += vList[i-1]
				return {'bool':True, 'score':score}
	return {'bool':False, 'score':score}  

def handle(vList, direction):
	'''处理一行(列)中的数据,得到最终的该行(列)的数字状态值, 返回得分
        vList: 列表结构,存储了一行(列)中的数据
        direction: 移动方向,向上和向左都使用方向'left',向右和向下都使用'right'
        '''
	totalScore = 0
	align(vList, direction)
	result = addSame(vList, direction)
	while result['bool'] == True:
		totalScore += result['score']
		align(vList, direction)
		result = addSame(vList, direction)
	return totalScore
        

def operation(v):
	'''根据移动方向重新计算矩阵状态值,并记录得分
        '''
	totalScore = 0
	gameOver = False
	direction = 'left'
	op = raw_input('operator:')
	if op in ['a', 'A']:    # 向左移动
                direction = 'left'
                for row in range(4):
				totalScore += handle(v[row], direction)
	elif op in ['d', 'D']:  # 向右移动
                direction = 'right'
                for row in range(4):
                        totalScore += handle(v[row], direction)
	elif op in ['w', 'W']:  # 向上移动
                direction = 'left'
                for col in range(4):
                        # 将矩阵中一列复制到一个列表中然后处理
                        vList = [v[row][col] for row in range(4)]
                        totalScore += handle(vList, direction)
                        # 从处理后的列表中的数字覆盖原来矩阵中的值
                        for row in range(4):
                                v[row][col] = vList[row]
	elif op in ['s', 'S']:  # 向下移动
                direction = 'right'
                for col in range(4):
                        # 同上
                        vList = [v[row][col] for row in range(4)]
                        totalScore += handle(vList, direction)
                        for row in range(4):
                                v[row][col] = vList[row]
	else:
                print('Invalid input, please enter a charactor in [W, S, A, D] or the lower')
                return {'gameOver':gameOver, 'score':totalScore}

        # 统计空白区域数目 N
	N = 0
	for q in v:
            N += q.count(0)
        # 不存在剩余的空白区域时,游戏结束
	if N == 0:
                gameOver = True
                return {'gameOver':gameOver, 'score':totalScore}

        # 按2和4出现的几率为3/1来产生随机数2和4
	num = random.choice([2, 2, 2, 4]) 
        # 产生随机数k,上一步产生的2或4将被填到第k个空白区域
	k = random.randrange(1, N+1)
	n = 0
	for i in range(4):
                for j in range(4):
                        if v[i][j] == 0:
                                n += 1
                                if n == k:
                                        v[i][j] = num
                                        break

	return {'gameOver':gameOver, 'score':totalScore}

init(v)
score = 0
print 'Input:W(Up) S(Down) A(Left) D(Right), press <CR>.'
while True:
    display(v, score)
    result = operation(v)
    if result['gameOver'] == True:
        print 'Game Over, You failed!'
        print 'Your total score:', score
        sys.exit(1)
    else:
        score += result['score']
        if score >= 2048:
            print 'Game Over, You Win!!!'
            print 'Your total score:', score
            sys.exit(0)
(2)修改出现例如(4,4,8,0)这样的情况,得分不合理的情况
# -*- coding:UTF-8 -*-
#!/usr/bin/python2
 
import random
import os, sys

 
v = [[0, 0, 0, 0],
     [0, 0, 0, 0],
     [0, 0, 0, 0],
     [0, 0, 0, 0]]
 
def display(v, score):
	print "%4d	%4d	%4d	%4d"	%	(v[0][0], v[0][1], v[0][2], v[0][3])
	print "%4d	%4d	%4d	%4d"	%	(v[1][0], v[1][1], v[1][2], v[1][3])
	print "%4d	%4d	%4d	%4d"	%	(v[2][0], v[2][1], v[2][2], v[2][3])
	print "%4d	%4d	%4d	%4d"	%	(v[3][0], v[3][1], v[3][2], v[3][3])
	print "Total score: %d" % score
 
def init(v):
	for i in range(4):
		v[i] = [random.choice([0, 0, 0, 2, 2, 4]) for x in range(4)]

def align(vList, direction):
	for i in range(vList.count(0)):
		vList.remove(0)
	zeros = [0 for x in range(4 - len(vList))]
	if direction == 'left':
		vList.extend(zeros)
	else:
		vList[:0] = zeros

def addSame(vList, direction):
	score = 0
	if direction == 'left':
		for i in [0, 1, 2]:
			align(vList, direction)
			if vList[i] == vList[i+1] != 0:
				vList[i] *= 2
				vList[i+1] = 0
				score += vList[i]
				return {'bool':True, 'score':score}
	else:
		for i in [3, 2, 1]:
			align(vList, direction)
			if vList[i] == vList[i-1] != 0:
				vList[i] *= 2
				vList[i-1] = 0
				score += vList[i]
				return {'bool':True, 'score':score}
	return {'bool':False, 'score':score}

def handle(vList, direction):
	totalScore = 0
	align(vList, direction)
	result = addSame(vList, direction)
	while result['bool'] == True:
		totalScore += result['score']
		align(vList, direction)
		result = addSame(vList, direction)
	return totalScore
	 
def operation(v):
	totalScore = 0
	gameOver = False
	direction = 'left'
	op = raw_input('operator:')
	if op in ['a','A']:
		direction = 'left'
		for row in range(4):
			totalScore += handle(v[row], direction)
	elif op in ['d','D']:
		direction = 'right'
		for row in range(4):
			totalScore += handle(v[row], direction)
	elif op in ['w', 'W']:
		direction = 'left'
		for col in range(4):
			vList = [v[row][col] for row in range(4)]
			totalScore += handle(vList, direction)
			for row in range(4):
				v[row][col] = vList[row]
	elif op in ['s', 'S']:
		direction = 'right'
		for col in range(4):
			vList = [v[row][col] for row in range(4)]
			totalScore += handle(vList, direction)
			for row in range(4):
				v[row][col] = vList[row]
	else:
		print "Invalid input,please enter a charactor in [W,S,A,D] or the lower"
		gameOver = True
		return {'gameOver':gameOver,'score':totalScore}

	N = 0
	for q in v:
		N += q.count(0)

	if N == 0:
		gameOver = True
		return {'gameover':gameOver,'score':totalScore}
	
	num = random.choice([2,2,2,4])
	k = random.randrange(1, N+1)
	n = 0

	for i in range(4):
		for j in range(4):
			if v[i][j] == 0:
				n += 1
				if n == k:
					v[i][j] = num
					break			

	return {'gameOver':gameOver, 'score':totalScore}
	

init(v)
score = 0
print "Input:W(Up) S(Down) A(Left) D(Right), press <CR>."
while True:
	os.system("clear")
	display(v, score)
	result = operation(v)
	print result
	if result['gameOver'] == True:
		print "Game Over, You failed!"
		print "Your total score %d" % (score)
		sys.exit(1)
	else:
		score += result['score']
		if score >= 2048:
			print "Game Over, You Win!!!"
			print "Your total score: %d" % (score)
			sys.exit(0)
(3)linux使用ncurses库实现的2048 ai
/***********************************
*makefile:
*CC=gcc  
*CFLAGS=-g -O3 -lncurses  
*
*.PHONY : all  
*all: 2048.c   
*    $(CC) 2048.c -o 2048 $(CFLAGS) 
************************************
*---Play----  
* make  
* ./2048     <-- Normal mode  
* ./2048 -s  <-- Play with AI suggestion  
* ./2048 -a  <-- Watch AI plays it. Good luck!  
************************************/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <ncurses.h>
#include <sys/time.h>
#include <time.h>

#define AUTO

#define SIZE (4)
typedef int board_t[SIZE][SIZE];
struct hash_elem {
    int hash;
    int depth;
    double value;
};

enum input {
    LEFT = 0,
    RIGHT = 1,
    UP = 2,
    DOWN = 3,
    QUIT = 4
};

/* Static mappings & initialzation ***********************************/

/* Weight of each value */
int value_weight[16];
/* Mapping from value to power of 2 form */
int value_real[16];
/* Default search depth for each #zero-blocks */
int depth_map[] = {6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4};

/* Weight map of cells */
static const board_t cell_weight = {
    {17, 13, 11, 10},
    {13, 10,  9,  9},
    {11,  9,  8,  8},
    {10,  9,  8,  8}
};

/* Used for hash table */
static const board_t primes = {
    {22189, 28813, 37633, 43201}, 
    {47629, 60493, 63949, 65713}, 
    {69313, 73009, 76801, 84673}, 
    {106033, 108301, 112909, 115249}
};
    
void init() {
    int i;
    int cur_weight = 1;
    int cur_real = 2;
    for (i = 1; i < 16; i++) {
        value_weight[i] = cur_weight;
        value_real[i] = cur_real;
        cur_weight *= 3;
        cur_real *= 2;
    }
}

/* Util Functions *****************************************************/
long gettime() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec * 1000 * 1000 + tv.tv_usec;
}

void draw_grid(int y, int x) {
    mvprintw(y++, x,    "#####################################");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#-----------------------------------#");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#-----------------------------------#");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#-----------------------------------#");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#        |        |        |        #");
    mvprintw(y++, x,    "#####################################");
    mvprintw(y+2, x,    "Control: wasd  Exit: q");
}


void board_dump(board_t b, int y, int x) { 
    int i, j;
    draw_grid(y, x);
    for (i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            if (b[i][j])
                mvprintw(i * 4 + 2 + y, j * 9 + 3 + x, "%d", value_real[b[i][j]]);
        }
    }
}

int board_count_zero(board_t b) {
    int cnt = 0;
    int i, j;
    for (i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            if (b[i][j] == 0)
                cnt++;
        }
    }
    return cnt;
}

void board_clear(board_t b) {
    int i, j;
    for (i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            b[i][j] = 0;
        }
    }
}

int board_hash(board_t b) {
    int i, j;
    int hash = 0;
    for (i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            hash += b[i][j] * primes[i][j];
        }
    }
    return hash;
}

void board_rnd_gen_cell(board_t b) {
    int i, j;
    int cnt = board_count_zero(b);
    int gen = random() % cnt;
    int n = (random() % 10) == 0 ? 2 : 1;

    cnt = 0;    

    for (i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            if (b[i][j] == 0) {
                if (cnt == gen) {
                    b[i][j] = n;
                    return;
                }
                cnt++;
            }
        }
    }
}

void delay() {
    struct timespec t;
    t.tv_sec = 0;
    t.tv_nsec = 10000000;
    nanosleep(&t, NULL);
}

/* Performance statistic */
long stat_time[16];
long stat_count[16]; 
void stat(int depth, long time) {
    stat_count[depth]++;
    stat_time[depth] += time;
}

void stat_dump() {
    int i;
    int line = 0;
    mvprintw(25 + line++, 8, "Performance Stat");
    for (i = 0; i < 16; i++) {
        if (!stat_count[i])
            continue;
        mvprintw(25 + line++, 8, "[Depth %d] %ld us * %d times",
            i, stat_time[i] / stat_count[i], stat_count[i]);
    }   
}

/* Game logic: Move to a direction **************************************************/

/* Return score earned, return 1 if moved with zero score */
#define movefunc(src_cell, combine_cell, nocombine_cell)\
{\
    int i, j = 0;\
    int moved = 0;\
    int score = 0;\
    for (i = 0; i < SIZE; i++) {\
        int last = 0;\
        int j2 = 0;\
        for (j = 0; j < SIZE; j++) {\
            int v = src_cell;\
            if (v == 0) {\
                continue;\
            }\
            if (v == last) {\
                last = 0;\
                combine_cell = v + 1;\
                score += value_real[v + 1];\
            } else {\
                if (j2 < j)\
                    moved = 1;\
                last = v;\
                nocombine_cell = v;\
                j2++;\
            }\
        }\
    }\
    return score ? score : moved;\
}

#define REVERSE(i) (SIZE - 1 - (i))



int move_left(board_t src, board_t dst) {
    movefunc(src[i][j], dst[i][j2 - 1], dst[i][j2]);
}

int move_right(board_t src, board_t dst) {
    movefunc(src[i][REVERSE(j)], dst[i][REVERSE(j2 - 1)], dst[i][REVERSE(j2)]);
}

int move_up(board_t src, board_t dst) {
    movefunc(src[j][i], dst[j2 - 1][i], dst[j2][i]);
}

int move_down(board_t src, board_t dst) {
    movefunc(src[REVERSE(j)][i], dst[REVERSE(j2 - 1)][i], dst[REVERSE(j2)][i]);
}


/* AI-related functions **************************************************/
double value(board_t b, int depth, int *choice, double max);

/* Immediate value score estimation for a board */
int imm_value(board_t b) {
    int i, j;
    int result = 0;

    for (i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            result += value_weight[b[i][j]] * cell_weight[i][j];
        }
    }
    return result;
}

#define HASH_SIZE (35317) 
struct hash_elem vcache[HASH_SIZE];
void cache_board_value(board_t b, int depth, double value) {
    int hash = board_hash(b);
    int index = hash % HASH_SIZE;
    vcache[index].hash = hash;
    vcache[index].value = value;
    vcache[index].depth = depth;
}

int qcnt;
int qmiss;
double query_board_value(board_t b, int depth) {
    int hash = board_hash(b);
    int index = hash % HASH_SIZE;
    qcnt++;
    if (vcache[index].hash == hash && vcache[index].depth >= depth) {
        return vcache[index].value;
    }
    qmiss++;
    return -1;
}

/* Generate 2/4 at every posible position, return the average value score 
 * b        : the board
 * depth    : depth of the recursive search
 * max      : current maximum value score
 * sampled  : sample rate, 0 means no sample
 */
double rnd_value(board_t b, int depth, double max, int sampled) {
    int i, j;
    int cnt = 0;
    double sum = 0;
    static int scnt = 0;

    for (i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            /* Check zero */
            if (b[i][j])
                continue;

            /* Do sampling to reduce computation if needed */
            if (sampled) {
                scnt++;
                if(scnt % sampled)
                    continue;
            }
            cnt += 9;
            b[i][j] = 1;
            sum += 9 * value(b, depth, NULL, max);
            /* We do not take random 4 into consideration as it is rare */
            if (depth >= 5) {
                cnt += 1;
                b[i][j] = 2;
                sum += value(b, depth, NULL, max);
            }
            /**/
            b[i][j] = 0;
        }
    }
    return sum / cnt;
}

/* Return the value score for given board, zero score means died 
 * b        : the board
 * depth    : depth of the recursive search
 * choice   : used to return the final choise of movement
 * max      : current maximum value score
 */
double value(board_t b, int depth, int *choice, double max) {
    /* Estimate the value score */
    int estimate = imm_value(b);

    /* Decrease depth if estimation is too low */
    if (estimate < max * 0.7)
        depth--;

    /* Return estimation at level 0 */
    if (depth <= 0)
        return estimate;

    /* Adjust next depth according to depth_map */ 
    int next_depth = depth - 1;    
    if (depth > 3) {
        int zeros = board_count_zero(b);
        if (next_depth > depth_map[zeros])
            next_depth--; 
    } 
    
    int i;
    int moved[4];
    double maxv = 0;
    board_t tmp[4] = {0};
    int my_choice = QUIT; /* Default choice */

    if (!choice) {
        double v = query_board_value(b, depth);
        if (v >= 0)
            return v;
    }
    
    moved[LEFT] = move_left(b, tmp[LEFT]);
    moved[RIGHT] = move_right(b, tmp[RIGHT]);
    moved[UP] = move_up(b, tmp[UP]);
    moved[DOWN] = move_down(b, tmp[DOWN]);

    /* Estimate the maximum value score */
    if (depth > 2)
    for (i = 0; i < 4; i++) {
        int v = imm_value(tmp[0]);
        max = v > max ? v : max;
    }   
    
    /* Try all the four direction */ 
    for (i = 0; i < 4; i++) {
        int c;
        if (!moved[i])
            continue;
        int sample = 0; //depth < 3 ? 3 : 1;
        double v = rnd_value(tmp[i], next_depth, max, sample);
        if (v > maxv) {
            my_choice = i;
            maxv = v;
            max = maxv;
        }
    }

    if (choice)
        *choice = my_choice;
   
    cache_board_value(b, depth, maxv); 
    return maxv;
}

/* Game logic: Control and Interface *************************************/
static int get_AI_input(board_t b) {
    int choice;
    int zeros = board_count_zero(b);

    long start = gettime();
    double v = value(b, depth_map[zeros], &choice, 0);
    long timeval = gettime() - start;
    stat(depth_map[zeros], timeval);

    return choice;
}

static int get_keyboard_input() {
    char c;
    while(1) {
        //c = getchar();
        c = getch();
        switch(c) {
            case 'w': return UP;
            case 'a': return LEFT;
            case 's': return DOWN;
            case 'd': return RIGHT;
            case 'q': return QUIT;
        }
    }
}

int auto_play = 0;
int suggestion = 0;

void game_loop() {

    board_t a = {0};
    board_t b = {0};
    board_t *cur;
    board_t *next;

    int input;
    int AI_input;
    int score = 0;
    
    cur = &a;
    next = &b;

    board_rnd_gen_cell(*cur);
    
    while (1) {
        clear();
        
        /* Draw the board */
        board_dump(*cur, 4, 8);
        // stat_dump(); 
        
        /* AI computation */
        if (auto_play || suggestion) {
            AI_input = get_AI_input(*cur);
            const char *move_text[] = {"Left", "Right", "Up", "Down", "Game Over"};
            mvprintw(1, 8, "Suggest: %s", move_text[AI_input]);
        }
        mvprintw(2, 8, "Score: %d", score);
        
        /* Update screen */
        refresh();
        
        /* Get input */
        if (auto_play) {
            input = AI_input;
        } else {
            input = get_keyboard_input();
        }

        int moved = 0;
        switch(input) {
            case UP:
                moved = move_up(*cur, *next); break;
            case LEFT:
                moved = move_left(*cur, *next); break;
            case DOWN:
                moved = move_down(*cur, *next); break;
            case RIGHT:
                moved = move_right(*cur, *next); break;
            case QUIT:
                return;
            default:
                continue;
        }

        if (!moved)
            continue;
       
        if (moved != 1)
            score += moved;
 
        /* Generate new cell */
        board_rnd_gen_cell(*next);

        /* Switch cur and next */ 
        board_t *temp = cur;
        cur = next;
        next = temp; 
        board_clear(*next);
    }

}

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "as")) != -1) {
        switch (opt) {
            case 'a':
                auto_play = 1;
                break;
            case 's':
                suggestion = 1;
                break;
            default: /* '?' */
                fprintf(stderr, "Usage: %s [-a] [-s]\r\n", argv[0]);
                fprintf(stderr, "-a:  Let AI play the game\r\n");
                fprintf(stderr, "-s:  Display AI suggestion\r\n");
                exit(EXIT_FAILURE);
        }

    }


    init();
    srandom(time(NULL)); 
    initscr();
    noecho();
    
    game_loop();
    
    refresh();
    endwin();
    return 0;
}
编译:gcc -g -O3 -o 2048 2048.c -lncurses
运行:(第一图是正常模式,第二图是提示模式,第三张图是人工智能模式)

三、总结

(1)代码皆是总结而至,具体细节还待以后深入研究。
(2)代码中有比较多的问题,有待完善的地方还很多。

展开阅读全文

没有更多推荐了,返回首页