game_2048.py

import pygame
import numpy as np
import copy
import os
from pygame.locals import *

# Colors for different tile values
COLORS = {
    0: (205, 193, 180),
    2: (238, 228, 218),
    4: (237, 224, 200),
    8: (242, 177, 121),
    16: (245, 149, 99),
    32: (246, 124, 95),
    64: (246, 94, 59),
    128: (237, 207, 114),
    256: (237, 204, 97),
    512: (237, 200, 80),
    1024: (237, 197, 63),
    2048: (237, 194, 46),
}

TEXT_COLORS = {
    2: (119, 110, 101),
    4: (119, 110, 101),
    8: (255, 255, 255),
    16: (255, 255, 255),
    32: (255, 255, 255),
    64: (255, 255, 255),
    128: (255, 255, 255),
    256: (255, 255, 255),
    512: (255, 255, 255),
    1024: (255, 255, 255),
    2048: (255, 255, 255),
}

BG_COLOR = (187, 173, 160)
GRID_COLOR = (187, 173, 160)
FILENAME = 'out.npy'


class Game2048:
    def __init__(self, screen=None, standalone=True):
        self.score = 0
        self.win = 0
        self.board = self.init_board()
        self.rscore = self.load_score()
        self.standalone = standalone
        self.screen = screen
        self.font = None
        self.tile_font = None
        self.game_over_flag = False
        self.cell_size = 100
        self.padding = 10
        self.board_size = 4 * self.cell_size + 5 * self.padding
        
        if standalone and screen is None:
            pygame.init()
            self.screen = pygame.display.set_mode((self.board_size, self.board_size + 100))
            pygame.display.set_caption('2048 Game')
            self.font = pygame.font.SysFont('Arial', 30)
            self.tile_font = pygame.font.SysFont('Arial', 40, bold=True)
    
    def init_board(self):
        if FILENAME not in os.listdir():
            np.save(FILENAME, 0)
        board = self.choice(np.zeros((4, 4), dtype=int))
        return board
    
    def choice(self, board):
        udict = {}
        count = 0
        for i in range(4):
            for j in range(4):
                if not board[i, j]:
                    udict[count] = (i, j)
                    count += 1
        if count == 0:
            return board
        random_number = np.random.randint(0, count)
        two_or_four = np.random.choice([2, 2, 2, 4])
        board[udict[random_number]] = two_or_four
        return board
    
    def basic(self, board):
        for i in range(4):
            flag = 1
            while flag:
                flag = 0
                j = 2
                while j >= 0:
                    if board[i, j] != 0:
                        if board[i, j + 1] == board[i, j]:
                            board[i, j + 1] = 2 * board[i, j]
                            if board[i, j + 1] == 2048:
                                self.win = 1
                            board[i, j] = 0
                            self.score += 100
                            flag = 1
                        elif board[i, j + 1] == 0:
                            temp = board[i, j]
                            board[i, j] = board[i, j + 1]
                            board[i, j + 1] = temp
                            flag = 1
                    j -= 1
        return board
    
    def move_right(self, board):
        return self.basic(board)
    
    def move_up(self, board):
        board = board[::-1, ::-1].T
        board = self.basic(board)
        board = board[::-1, ::-1].T
        return board
    
    def move_left(self, board):
        board = board[::-1, ::-1]
        board = self.basic(board)
        board = board[::-1, ::-1]
        return board
    
    def move_down(self, board):
        board = board.T
        board = self.basic(board)
        board = board.T
        return board
    
    def move(self, order):
        change = 1
        tempboard = copy.deepcopy(self.board)
        
        if order == ord('r') or order == K_r:
            self.reset_game()
            return
        elif order == ord('q') or order == K_q:
            self.save_score()
            return 'quit'
        elif self.win and (order in [ord('w'), ord('a'), ord('s'), ord('d'), K_UP, K_LEFT, K_DOWN, K_RIGHT]):
            change = 0
            return
        elif order == ord('w') or order == K_UP or order == K_w:
            self.board = self.move_up(self.board)
        elif order == ord('s') or order == K_DOWN or order == K_s:
            self.board = self.move_down(self.board)
        elif order == ord('a') or order == K_LEFT or order == K_a:
            self.board = self.move_left(self.board)
        elif order == ord('d') or order == K_RIGHT or order == K_d:
            self.board = self.move_right(self.board)
        else:
            newboard = self.board
        
        if (self.board == tempboard).all():
            change = 0
        
        if change:
            self.board = self.choice(self.board)
        
        self.check_fail()
        self.rscore = max(self.rscore, self.score)
    
    def check_fail(self):
        if (self.board != 0).all():
            diff1 = self.board[:, 1:] - self.board[:, :-1]
            diff2 = self.board[1:, :] - self.board[:-1, :]
            inter = (diff1 != 0).all() and (diff2 != 0).all()
            if inter:
                self.game_over_flag = True
                self.save_score()
    
    def load_score(self):
        try:
            rank_score = np.load(FILENAME)
            return int(rank_score)
        except:
            return 0
    
    def save_score(self):
        if self.score > self.rscore:
            np.save(FILENAME, self.score)
    
    def reset_game(self):
        self.save_score()
        self.score = 0
        self.win = 0
        self.game_over_flag = False
        self.board = self.init_board()
        self.rscore = self.load_score()
    
    def draw_board(self):
        if self.screen is None:
            return
        
        self.screen.fill(BG_COLOR)
        
        # Draw score
        if self.font:
            score_text = self.font.render(f'Score: {self.score}', True, (255, 255, 255))
            self.screen.blit(score_text, (10, 10))
            high_score_text = self.font.render(f'Best: {max(self.rscore, self.score)}', True, (255, 255, 255))
            self.screen.blit(high_score_text, (self.board_size - 150, 10))
        
        # Draw grid
        for i in range(4):
            for j in range(4):
                value = self.board[i, j]
                x = self.padding + j * (self.cell_size + self.padding)
                y = 60 + self.padding + i * (self.cell_size + self.padding)
                
                color = COLORS.get(int(value), (60, 58, 50))
                pygame.draw.rect(self.screen, color, (x, y, self.cell_size, self.cell_size), border_radius=8)
                
                if value != 0:
                    text_color = TEXT_COLORS.get(int(value), (255, 255, 255))
                    if self.tile_font:
                        text = self.tile_font.render(str(int(value)), True, text_color)
                        text_rect = text.get_rect(center=(x + self.cell_size // 2, y + self.cell_size // 2))
                        self.screen.blit(text, text_rect)
        
        # Draw win message
        if self.win:
            if self.font:
                win_text = self.font.render('You Win! Press R to restart', True, (0, 255, 0))
                text_rect = win_text.get_rect(center=(self.board_size // 2, self.board_size // 2 + 30))
                self.screen.blit(win_text, text_rect)
        
        # Draw game over message
        if self.game_over_flag:
            if self.font:
                over_text = self.font.render('Game Over! Press R to restart', True, (255, 0, 0))
                text_rect = over_text.get_rect(center=(self.board_size // 2, self.board_size // 2 + 30))
                self.screen.blit(over_text, text_rect)
    
    def handle_event(self, event):
        if event.type == KEYDOWN:
            if event.key in [K_UP, K_DOWN, K_LEFT, K_RIGHT, K_w, K_s, K_a, K_d, K_r, K_q]:
                result = self.move(event.key)
                if result == 'quit':
                    return 'quit'
        return None
    
    def update(self):
        self.draw_board()
        pygame.display.update()
    
    def run(self):
        if not self.standalone:
            return
        
        clock = pygame.time.Clock()
        running = True
        
        while running:
            for event in pygame.event.get():
                if event.type == QUIT:
                    running = False
                else:
                    result = self.handle_event(event)
                    if result == 'quit':
                        running = False
            
            self.update()
            clock.tick(30)
        
        self.save_score()
        pygame.quit()


if __name__ == '__main__':
    game = Game2048()
    game.run()