2048 для программистов

[SergeyIT]

Подумалось что и такая игра может быть, а почему нет 

Код: [Выделить]


#needs: python-tk
#modified by SergeyIT
#original: from http://blog.hrvoje.org/blog/2014/09/20/a-simple-2048-clone-in-python/

import random,Tkinter
def shift(c): return list([i for i in c if i>0] + [0]*c.count(0))
def sms(l):
    l=shift(l)
    for i in range(len(l)-1):
        if l[i+1]==l[i]: l[i], l[i+1] = 2*l[i], 0
    return shift(l)
class igra(Tkinter.Tk):
    fm = {0: '%d', 1: '0%o', 2: '0x%X'}
    b = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
    def __init__(self,parent):
        Tkinter.Tk.__init__(self,parent)
        self.parent = parent
        self.grid()
        self.bl = [Tkinter.Button(self, height=3, width=6, state=Tkinter.DISABLED, font=("Helvetica", 18)) for i in range(16)]
        for i in range(16): self.bl[i].grid(row=i//4, column=i%4)
        self.dodaj_novu()
        self.bind_all('<Key>', self.key)
        self.mainloop()
    def pr(self, d, f): return str(self.fm[f] % d)
    def rot(self): self.b = list(map(list, zip(*self.b[::-1])))
    def move(self, n):
        diff = self.b[:]
        for i in range(n): self.rot()
        for i in range(4): self.b[i] = sms(self.b[i])
        for i in range(4-n): self.rot()
        return 1 if self.b != diff else 0
    def dodaj_novu(self):
        k = [(i//4, i%4) for i,j in enumerate(sum(self.b, [])) if j == 0][random.randint(0, sum(self.b, []).count(0)-1)]
        self.b[k[0]][k[1]] = random.randint(1,2)*2
        for i in range(16):
            d = self.b[i//4][i%4]
            self.bl[i].config(text=self.pr(d, random.randint(0,2)) if d else ' ', bg='#%06x'% ((2**24-1) - (d*1500) ))
    def key(self, event):
        direction={'Left': 0, 'Down': 1, 'Right': 2, 'Up': 3}
        if self.move(direction[event.keysym]): self.dodaj_novu()
        p = self.b[:]
        for i in range(4):
            self.move(i)
            if self.b != p:
                self.b = p[:]
                return
        for i in range(16): self.bl[i].config(bg='red', text=':(')
a = igra(None)


[Гриб_под_зонтом]

Скачал библиотеку , но почему то ругаеться на import(

[SergeyIT]

Не скажу, у меня и python-tk и python3-tk стоят и все команды работают
python g.py
python3 g.py
python2.7 g.py

хотя где-то читал, что в 2-ке модуль tkinter, а в 3-ке Tkinter

[ivsatel]

хотя где-то читал, что в 2-ке модуль tkinter, а в 3-ке Tkinter

Наоборот.

[SergeyIT]

ivsatel, может быть

[alsoijw]

А что это из себя представляет? Скриншоты там что ли?

[SergeyIT]

alsoijw, игрушка на питоне

[alsoijw]

SergeyIT, какие пакеты надо ставить?

[SergeyIT]

У меня стоят дополнительно python-tk, python3-tk для Tkinter, а может еще что надо. Я не программировал еще, так только, попробовал.
Пользователь решил продолжить мысль 06 Января 2015, 18:40:01:Можно на Си скомпилить (так, баловство)

(Нажмите, чтобы показать/скрыть)

Код: [Выделить]

/* 0x800.c
Original sources ->
  ============================================================================
  Name        : 2048.c
  Author      : Maurits van der Schee
  Description : Console version of the game "2048" for GNU/Linux
 ============================================================================
*/

#define _XOPEN_SOURCE 500
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <termios.h>
#include <stdbool.h>
#include <stdint.h>
#include <time.h>
#include <signal.h>

#define SIZE 4
uint32_t score=0, prevscore=0;
uint16_t prevboard[SIZE][SIZE];
int8_t prevx=0, prevy=0;
uint32_t maxscore=0;
uint8_t scheme=0;

void getColor(uint16_t value, char *color, size_t length) {
uint8_t original[] = {8,255,1,255,2,255,3,255,4,255,5,255,6,255,7,255,9,0,10,0,11,0,12,0,13,0,14,0,255,0,255,0};
uint8_t blackwhite[] = {232,255,234,255,236,255,238,255,240,255,242,255,244,255,246,0,248,0,249,0,250,0,251,0,252,0,253,0,254,0,255,0};
uint8_t bluered[] = {235,255,63,255,57,255,93,255,129,255,165,255,201,255,200,255,199,255,198,255,197,255,196,255,196,255,196,255,196,255,196,255};
uint8_t *schemes[] = {original,blackwhite,bluered};
uint8_t *background = schemes[scheme]+0;
uint8_t *foreground = schemes[scheme]+1;
if (value > 0) while (value >>= 1) {
if (background+2<schemes[scheme]+sizeof(original)) {
background+=2;
foreground+=2;
}
}
snprintf(color,length,"\033[38;5;%d;48;5;%dm",*foreground,*background);
}

void ClearScr() {
int y;
printf("\033[H");
for (y=0;y<3*SIZE+4;y++) {
  printf("                            \n");
}
printf("\033[A"); //Cursor up one line
}

void drawBoard(uint16_t board[SIZE][SIZE]) {
int8_t x,y;
char color[40], reset[] = "\033[m";
printf("\033[H");
char *fmt[3] = {"%u","0x%x","0%o"};
int ifmt=0;
// printf("2048.c %17d pts\n\n",score);
printf("<4096>  %7d /%7d pts\n\n",score, maxscore);

for (y=0;y<SIZE;y++) {
for (x=0;x<SIZE;x++) {
getColor(board[x][y],color,40);
printf("%s",color);
printf("       ");
printf("%s",reset);
}
printf("\n");
for (x=0;x<SIZE;x++) {
getColor(board[x][y],color,40);
printf("%s",color);
if (board[x][y]!=0) {
char s[8];
ifmt = rand()%3;
snprintf(s,8,fmt[ifmt],board[x][y]);
int8_t t = 7-strlen(s);
printf("%*s%s%*s",t-t/2,"",s,t/2,"");
} else {
printf("   ·   ");
}
printf("%s",reset);
}
printf("\n");
for (x=0;x<SIZE;x++) {
getColor(board[x][y],color,40);
printf("%s",color);
printf("       ");
printf("%s",reset);
}
printf("\n");
}
printf("\n");
printf("        ←,↑,→,↓ or q  r     \n");
printf("\033[A"); //Cursor up one line
}

int8_t findTarget(uint16_t array[SIZE],int8_t x,int8_t stop) {
int8_t t;
// if the position is already on the first, don't evaluate
if (x==0) {
return x;
}
for(t=x-1;t>=0;t--) {
if (array[t]!=0) {
if (array[t]!=array[x]) {
// merge is not possible, take next position
return t+1;
}
return t;
} else {
// we should not slide further, return this one
if (t==stop) {
return t;
}
}
}
// we did not find a
return x;
}

bool slideArray(uint16_t array[SIZE]) {
bool success = false;
int8_t x,t,stop=0;

for (x=0;x<SIZE;x++) {
if (array[x]!=0) {
t = findTarget(array,x,stop);
// if target is not original position, then move or merge
if (t!=x) {
// if target is not zero, set stop to avoid double merge
if (array[t]!=0) {
score+=array[t]+array[x];
stop = t+1;
}
array[t]+=array[x];
array[x]=0;
success = true;
}
}
}
return success;
}

void rotateBoard(uint16_t board[SIZE][SIZE]) {
int8_t i,j,n=SIZE;
uint16_t tmp;
for (i=0; i<n/2; i++){
for (j=i; j<n-i-1; j++){
tmp = board[i][j];
board[i][j] = board[j][n-i-1];
board[j][n-i-1] = board[n-i-1][n-j-1];
board[n-i-1][n-j-1] = board[n-j-1][i];
board[n-j-1][i] = tmp;
}
}
}

bool moveUp(uint16_t board[SIZE][SIZE]) {
bool success = false;
int8_t x;
for (x=0;x<SIZE;x++) {
success |= slideArray(board[x]);
}
return success;
}

bool moveLeft(uint16_t board[SIZE][SIZE]) {
bool success;
rotateBoard(board);
success = moveUp(board);
rotateBoard(board);
rotateBoard(board);
rotateBoard(board);
return success;
}

bool moveDown(uint16_t board[SIZE][SIZE]) {
bool success;
rotateBoard(board);
rotateBoard(board);
success = moveUp(board);
rotateBoard(board);
rotateBoard(board);
return success;
}

bool moveRight(uint16_t board[SIZE][SIZE]) {
bool success;
rotateBoard(board);
rotateBoard(board);
rotateBoard(board);
success = moveUp(board);
rotateBoard(board);
return success;
}

bool findPairDown(uint16_t board[SIZE][SIZE]) {
bool success = false;
int8_t x,y;
for (x=0;x<SIZE;x++) {
for (y=0;y<SIZE-1;y++) {
if (board[x][y]==board[x][y+1]) return true;
}
}
return success;
}

int16_t countEmpty(uint16_t board[SIZE][SIZE]) {
int8_t x,y;
int16_t count=0;
for (x=0;x<SIZE;x++) {
for (y=0;y<SIZE;y++) {
if (board[x][y]==0) {
count++;
}
}
}
return count;
}

bool gameEnded(uint16_t board[SIZE][SIZE]) {
bool ended = true;
if (countEmpty(board)>0) return false;
if (findPairDown(board)) return false;
rotateBoard(board);
if (findPairDown(board)) ended = false;
rotateBoard(board);
rotateBoard(board);
rotateBoard(board);
return ended;
}

void addRandom(uint16_t board[SIZE][SIZE]) {
static bool initialized = false;
int8_t x,y;
int16_t r,len=0;
uint16_t n,list[SIZE*SIZE][2];

if (!initialized) {
srand(time(NULL));
initialized = true;
}

for (x=0;x<SIZE;x++) {
for (y=0;y<SIZE;y++) {
if (board[x][y]==0) {
list[len][0]=x;
list[len][1]=y;
len++;
}
}
}

if (len>0) {
r = rand()%len;
x = list[r][0]; prevx = x;
y = list[r][1]; prevy = y;
n = ((rand()%10)/9+1)*2;
board[x][y]=n;
}
}

void setBufferedInput(bool enable) {
static bool enabled = true;
static struct termios old;
struct termios new;

if (enable && !enabled) {
// restore the former settings
tcsetattr(STDIN_FILENO,TCSANOW,&old);
// set the new state
enabled = true;
} else if (!enable && enabled) {
// get the terminal settings for standard input
tcgetattr(STDIN_FILENO,&new);
// we want to keep the old setting to restore them at the end
old = new;
// disable canonical mode (buffered i/o) and local echo
new.c_lflag &=(~ICANON & ~ECHO);
// set the new settings immediately
tcsetattr(STDIN_FILENO,TCSANOW,&new);
// set the new state
enabled = false;
}
}

int test() {
uint16_t array[SIZE];
uint16_t data[] = {
0,0,0,2, 2,0,0,0,
0,0,2,2, 4,0,0,0,
0,2,0,2, 4,0,0,0,
2,0,0,2, 4,0,0,0,
2,0,2,0, 4,0,0,0,
2,2,2,0, 4,2,0,0,
2,0,2,2, 4,2,0,0,
2,2,0,2, 4,2,0,0,
2,2,2,2, 4,4,0,0,
4,4,2,2, 8,4,0,0,
2,2,4,4, 4,8,0,0,
8,0,2,2, 8,4,0,0,
4,0,2,2, 4,4,0,0
};
uint16_t *in,*out;
uint16_t t,tests;
uint8_t i;
bool success = true;

tests = (sizeof(data)/sizeof(data[0]))/(2*SIZE);
for (t=0;t<tests;t++) {
in = data+t*2*SIZE;
out = in + SIZE;
for (i=0;i<SIZE;i++) {
array[i] = in[i];
}
slideArray(array);
for (i=0;i<SIZE;i++) {
if (array[i] != out[i]) {
success = false;
}
}
if (success==false) {
for (i=0;i<SIZE;i++) {
printf("%d ",in[i]);
}
printf("=> ");
for (i=0;i<SIZE;i++) {
printf("%d ",array[i]);
}
printf("expected ");
for (i=0;i<SIZE;i++) {
printf("%d ",in[i]);
}
printf("=> ");
for (i=0;i<SIZE;i++) {
printf("%d ",out[i]);
}
printf("\n");
break;
}
}
if (success) {
printf("All %u tests executed successfully\n",tests);
}
return !success;
}

void signal_callback_handler(int signum) {
ClearScr();
// printf("\033[;H\033[2J");
printf("\033[?25h");
setBufferedInput(true);
printf("\n         TERMINATED         \n");
exit(signum);
}

void rwFile(uint16_t board[SIZE][SIZE], bool bwrite)
{
// Read data & last game from /home/tsi/.config/4096.dat
char sfile[1024]="\0", *sf = "/.config/4096.dat";
char *s = getenv("HOME");
strcat(sfile, s); strcat(sfile, sf); 
FILE *ff = fopen(sfile, bwrite ? "w+" : "r");
if ( ff)
{
if (bwrite)
{
maxscore = score > maxscore ? score : maxscore;
fwrite(&maxscore, 4, 1, ff);
fwrite(&score, 4, 1, ff);
fwrite(board, 2 * SIZE * SIZE, 1, ff);
}
else
{
fread(&maxscore, 4, 1, ff);
fread(&score, 4, 1, ff);
fread(board, 2 * SIZE * SIZE, 1, ff);
}
fclose(ff);
} else
printf ("\n error open %s\n\n", sfile);
//
}

int main(int argc, char *argv[]) {
uint16_t board[SIZE][SIZE];
uint16_t prevboard[SIZE][SIZE];
char c;
bool success;

if (argc == 2 && strcmp(argv[1],"test")==0) {
return test();
}
if (argc == 2 && strcmp(argv[1],"blackwhite")==0) {
scheme = 1;
}
if (argc == 2 && strcmp(argv[1],"bluered")==0) {
scheme = 2;
}

printf("\033[?25l\033[H\033[2J"); //cursor off, Move cursor to upper left corner Erase entire screen

// register signal handler for when ctrl-c is pressed
signal(SIGINT, signal_callback_handler);

memset(board,0,sizeof(board));
memcpy(prevboard,board,sizeof(board));

addRandom(board);
addRandom(board);
rwFile(board, false);
memcpy(prevboard,board,sizeof(board));
prevscore = score;
drawBoard(board);
setBufferedInput(false);
while (true) {
c=getchar();
switch(c) {
case 97: // 'a' key
// case 104: // 'h' key
case 68: // left arrow
memcpy(prevboard,board,sizeof(board));
prevscore = score;
success = moveLeft(board);  break;
case 100: // 'd' key
// case 108: // 'l' key
case 67: // right arrow
memcpy(prevboard,board,sizeof(board));
prevscore = score;
success = moveRight(board); break;
case 119: // 'w' key
// case 107: // 'k' key
case 65: // up arrow
memcpy(prevboard,board,sizeof(board));
prevscore = score;
success = moveUp(board);    break;
case 115: // 's' key
// case 106: // 'j' key
case 66: // down arrow
memcpy(prevboard,board,sizeof(board));
prevscore = score;
success = moveDown(board);  break;
default: success = false;
}
if (success) {
drawBoard(board);
usleep(150000);
addRandom(board);
drawBoard(board);
if (gameEnded(board)) {
printf("\n         GAME OVER          \n");
break;
}
}
if (c=='q') {
ClearScr();
//printf("\033[;H\033[2J");
printf("\033[?25h");
setBufferedInput(true);
rwFile(board, true);
printf("\n       QUIT        \n");
exit(0);
}
if (c=='r') {
maxscore = score > maxscore ? score : maxscore;
score = 0;
memset(board,0,sizeof(board));
addRandom(board);
addRandom(board);
drawBoard(board);
}
if (c=='u') {
memcpy(board,prevboard,sizeof(board));
score = prevscore;
drawBoard(board);
}
}

ClearScr();
// printf("\033[;H\033[2J");
printf("\033[?25h");
setBufferedInput(true);
rwFile(board, true);
return EXIT_SUCCESS;
}