From bba8a3e99e88f5cac84e1df9e377d71bfe541eab Mon Sep 17 00:00:00 2001 From: ll <396463537@qq.com> Date: Sun, 15 Mar 2026 23:52:54 +0800 Subject: [PATCH] =?UTF-8?q?=E5=90=88=E5=B9=B62048=E5=92=8C=E8=B4=AA?= =?UTF-8?q?=E5=90=83=E8=9B=87=E5=B0=8F=E6=B8=B8=E6=88=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../__pycache__/game_2048.cpython-314.pyc | Bin 0 -> 14470 bytes .../__pycache__/main.cpython-314.pyc | Bin 0 -> 9237 bytes .../__pycache__/snake_game.cpython-314.pyc | Bin 0 -> 12945 bytes GameCollection/game_2048.py | 271 ++++++++++++++++++ GameCollection/main.py | 181 ++++++++++++ GameCollection/out.npy | Bin 0 -> 136 bytes GameCollection/snake_game.py | 210 ++++++++++++++ 7 files changed, 662 insertions(+) create mode 100644 GameCollection/__pycache__/game_2048.cpython-314.pyc create mode 100644 GameCollection/__pycache__/main.cpython-314.pyc create mode 100644 GameCollection/__pycache__/snake_game.cpython-314.pyc create mode 100644 GameCollection/game_2048.py create mode 100644 GameCollection/main.py create mode 100644 GameCollection/out.npy create mode 100644 GameCollection/snake_game.py diff --git a/GameCollection/__pycache__/game_2048.cpython-314.pyc b/GameCollection/__pycache__/game_2048.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7376eb3a4979952906d0c693eedcdfe43cb7aba8 GIT binary patch literal 14470 zcmdTre^49OnY+^J2a*5*0t5&U1``Ar#|GONyNMkGw!sFx#^59bMMeV4mL+*5;+S+| zdNbF`ximn28FI-Wx6T;1$%I_p#%Xhxw3oYcdcBK?gi$ukG&k3o4xPCh+expT`{R1w z_g1?rVG+CS{d3ROw{PG3-rM)S_x*a`d(>rR>L^IlpZv)E%}R>;cYG0(Ig$C|OUR5< zgA_~er-H(h4l2mIGN>d^Cdj~3v0t@CQH~h;K?Q3VWZ29>Et@rHWU~jYtZ{G`n=?4h z=CVpQk7ZaBt77w6HCwRJ5L5$xA>bDRz8Ub%fNutTGvJ#6-wgO>z&8WFd80n4VT*!V z_+_w~pe~=Ppjd4o#bz`qgfR#8j~Q59^HGX&7E_dkdQ4wIH6^AK%zP}fr!?`B^bqUI zVV;%bXDeR8`Ys#I)3qxUO;K(NKH#Ppidvzx6g8&tjRqUM{wP^>nnETDW8%v@1OdFUX+DhsKgie&(*SrtGHs|KiLH2^bkPC*@;0Z`BC02)|5 zz)aQvFpJFun9XJZ1o{HZVT}ND*&Kj*Y%V|(n-|RQqk;uEBU?VN-Rn5z+I)XgbJvhE zF-Ux<;Ro;9FK)olaiRMtuT)LmVCq8Zqk2?gUVe(CgLYECfSDm?dXX#yc^4MDiq6vCLqZD5@|H zX^oS{aqm6VfLc&*OYj}^Ci6%_j0y8=I26mS_OT4)e=7n9spEd6n?cd3+A1UBFRu!c!LrI=oJY$LDqN>c9}^a(Q`X z*yj!M89}$lWhdFJ5%`|n_k@eH4|^OVe8!N=#_10DJ&v=yHsA`{Px+iKUXQsUhd=1{d3nv@vw?Q_qD{#&0hec(%Y~_OIRFAk zmg?$iesg=vfY){AgzwnEN%txDfd6dpxX-&`0O_#D=kd6Pu%`hsOe9c)AHHU{6B5|@ z97H3uT58m|g;;Lt} z;{_JTnaog-5icr*M^?P7GQ`BRCGjE)c`Yo0hap~EGVPr8&UhD#>*r3-H@&m-?VXDo zA6zVc5Nfl3tpyk>v^&!G z@M7!3kzhtgkFxSoPooA!wX29IP zTv|E%=**)_rS~tC-alV>ZQTb=k<$C4rTapy&vo6>Qzf?ZEnff$s3A!`!V3x&P+j}Q zzd~l58UQGy0nsi{J⁡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 literal 0 HcmV?d00001 diff --git a/GameCollection/__pycache__/main.cpython-314.pyc b/GameCollection/__pycache__/main.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..61670321baada7b755756faee1fb026a3d9f2103 GIT binary patch literal 9237 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 b;#sqJ=Z_ckrca0dc<4`upTR3HmEb=C{bW;1 literal 0 HcmV?d00001 diff --git a/GameCollection/__pycache__/snake_game.cpython-314.pyc b/GameCollection/__pycache__/snake_game.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..475204adb5220aa5bb37598355f665bde503aa8e GIT binary patch literal 12945 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 j+BkMOsjB$OVEv0dS3A= 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() diff --git a/GameCollection/main.py b/GameCollection/main.py new file mode 100644 index 0000000..f26e4f4 --- /dev/null +++ b/GameCollection/main.py @@ -0,0 +1,181 @@ +import pygame +from pygame.locals import * +from game_2048 import Game2048 +from snake_game import SnakeGame + +# Screen dimensions +SCREEN_WIDTH = 960 +SCREEN_HEIGHT = 600 + +# Colors +BG_COLOR = (50, 50, 50) +MENU_BG_COLOR = (30, 30, 30) +TEXT_COLOR = (255, 255, 255) +HIGHLIGHT_COLOR = (0, 200, 255) + + +class GameCollection: + def __init__(self): + pygame.init() + self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) + pygame.display.set_caption('Game Collection - Press TAB to switch games') + self.clock = pygame.time.Clock() + self.font = pygame.font.SysFont('Arial', 30) + self.small_font = pygame.font.SysFont('Arial', 20) + self.title_font = pygame.font.SysFont('Arial', 40, bold=True) + + # Game states: 'menu', '2048', 'snake' + self.current_state = 'menu' + self.selected_game = 0 # 0 for 2048, 1 for snake + + # Initialize games + self.game_2048 = None + self.snake_game = None + + def draw_menu(self): + self.screen.fill(MENU_BG_COLOR) + + # Draw title + title = self.title_font.render('Game Collection', True, HIGHLIGHT_COLOR) + title_rect = title.get_rect(center=(SCREEN_WIDTH // 2, 100)) + self.screen.blit(title, title_rect) + + # Draw game options + games = ['1. 2048 Game', '2. Snake Game'] + y_start = 250 + for i, game in enumerate(games): + color = HIGHLIGHT_COLOR if i == self.selected_game else TEXT_COLOR + text = self.font.render(game, True, color) + text_rect = text.get_rect(center=(SCREEN_WIDTH // 2, y_start + i * 80)) + self.screen.blit(text, text_rect) + + # Draw instructions + instructions = [ + 'Controls:', + 'UP/DOWN - Select game', + 'ENTER - Start game', + 'TAB - Switch games while playing', + 'ESC - Return to menu / Quit' + ] + y = 450 + for instruction in instructions: + text = self.small_font.render(instruction, True, (150, 150, 150)) + self.screen.blit(text, (50, y)) + y += 25 + + pygame.display.update() + + def init_game_2048(self): + self.game_2048 = Game2048(screen=self.screen, standalone=False) + self.game_2048.font = pygame.font.SysFont('Arial', 30) + self.game_2048.tile_font = pygame.font.SysFont('Arial', 40, bold=True) + # Adjust cell size for the collection screen + self.game_2048.cell_size = 100 + self.game_2048.padding = 10 + self.game_2048.board_size = 4 * self.game_2048.cell_size + 5 * self.game_2048.padding + + def init_snake_game(self): + self.snake_game = SnakeGame(screen=self.screen, standalone=False) + self.snake_game.font = pygame.font.SysFont('Arial', 20) + + def draw_switch_notification(self): + # Draw a small notification at the top + notification = self.small_font.render('Press TAB to switch games | ESC for menu', True, (255, 255, 0)) + self.screen.blit(notification, (10, 5)) + + def run_game_2048(self): + if self.game_2048 is None: + self.init_game_2048() + + for event in pygame.event.get(): + if event.type == QUIT: + return 'quit' + elif event.type == KEYDOWN: + if event.key == K_TAB: + self.current_state = 'snake' + if self.snake_game is None: + self.init_snake_game() + return + elif event.key == K_ESCAPE: + self.current_state = 'menu' + return + else: + result = self.game_2048.handle_event(event) + if result == 'quit': + return 'quit' + + self.game_2048.draw_board() + self.draw_switch_notification() + pygame.display.update() + + def run_snake_game(self): + if self.snake_game is None: + self.init_snake_game() + + for event in pygame.event.get(): + if event.type == QUIT: + return 'quit' + elif event.type == KEYDOWN: + if event.key == K_TAB: + self.current_state = '2048' + if self.game_2048 is None: + self.init_game_2048() + return + elif event.key == K_ESCAPE: + self.current_state = 'menu' + return + else: + self.snake_game.handle_event(event) + + self.snake_game.update() + self.draw_switch_notification() + + def run(self): + running = True + + while running: + if self.current_state == 'menu': + for event in pygame.event.get(): + if event.type == QUIT: + running = False + elif event.type == KEYDOWN: + if event.key == K_ESCAPE: + running = False + elif event.key == K_UP: + self.selected_game = (self.selected_game - 1) % 2 + elif event.key == K_DOWN: + self.selected_game = (self.selected_game + 1) % 2 + elif event.key == K_RETURN: + if self.selected_game == 0: + self.current_state = '2048' + if self.game_2048 is None: + self.init_game_2048() + else: + self.current_state = 'snake' + if self.snake_game is None: + self.init_snake_game() + + self.draw_menu() + + elif self.current_state == '2048': + result = self.run_game_2048() + if result == 'quit': + running = False + + elif self.current_state == 'snake': + result = self.run_snake_game() + if result == 'quit': + running = False + + self.clock.tick(30) + + # Save scores before quitting + if self.game_2048: + self.game_2048.save_score() + + pygame.quit() + + +if __name__ == '__main__': + app = GameCollection() + app.run() diff --git a/GameCollection/out.npy b/GameCollection/out.npy new file mode 100644 index 0000000000000000000000000000000000000000..748264ceb0b53269008d554ef6a275872720a3d3 GIT binary patch literal 136 zcmbR27wQ`j$;eQ~P_3SlTAW;@Zl$1ZlWC!@qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= YXCxM+0{I%6ItsN46ag*=c?K{504s$Xp#T5? literal 0 HcmV?d00001 diff --git a/GameCollection/snake_game.py b/GameCollection/snake_game.py new file mode 100644 index 0000000..f719a33 --- /dev/null +++ b/GameCollection/snake_game.py @@ -0,0 +1,210 @@ +import pygame +import time +import numpy as np +from pygame.locals import * + +# Board dimensions +BOARDWIDTH = 48 +BOARDHEIGHT = 28 + + +class Food: + def __init__(self): + self.item = (4, 5) + + def _draw(self, screen, i, j): + color = 255, 0, 255 + radius = 10 + width = 10 + position = 10 + 20 * i, 10 + 20 * j + pygame.draw.circle(screen, color, position, radius, width) + + def update(self, screen, enlarge, snack): + if enlarge: + self.item = np.random.randint(1, BOARDWIDTH - 2), np.random.randint(1, BOARDHEIGHT - 2) + while self.item in snack.item: + self.item = np.random.randint(1, BOARDWIDTH - 2), np.random.randint(1, BOARDHEIGHT - 2) + self._draw(screen, self.item[0], self.item[1]) + + +class Snake: + def __init__(self): + self.item = [(3, 25), (2, 25), (1, 25), (1, 24)] + self.x = 0 + self.y = -1 + self.score = 0 + + def move(self, enlarge): + if not enlarge: + self.item.pop() + head = (self.item[0][0] + self.x, self.item[0][1] + self.y) + self.item.insert(0, head) + + def eat_food(self, food): + snake_x, snake_y = self.item[0] + food_x, food_y = food.item + if (food_x == snake_x) and (food_y == snake_y): + self.score += 100 + return 1 + else: + return 0 + + def toward(self, x, y): + if self.x * x >= 0 and self.y * y >= 0: + self.x = x + self.y = y + + def get_head(self): + return self.item[0] + + def draw(self, screen): + radius = 15 + width = 15 + color = 255, 0, 0 + position = 10 + 20 * self.item[0][0], 10 + 20 * self.item[0][1] + pygame.draw.circle(screen, color, position, radius, width) + radius = 10 + width = 10 + color = 255, 255, 0 + for i, j in self.item[1:]: + position = 10 + 20 * i, 10 + 20 * j + pygame.draw.circle(screen, color, position, radius, width) + + +class SnakeGame: + def __init__(self, screen=None, standalone=True): + self.snake = None + self.food = None + self.is_fail = False + self.standalone = standalone + self.screen = screen + self.font = None + self.clock = pygame.time.Clock() + self.last_update = 0 + + if standalone and screen is None: + pygame.init() + self.screen = pygame.display.set_mode((BOARDWIDTH * 20, BOARDHEIGHT * 20)) + pygame.display.set_caption('Snake Game') + self.font = pygame.font.SysFont('SimHei', 20) + + self.reset_game() + + def reset_game(self): + self.snake = Snake() + self.food = Food() + self.is_fail = False + + def init_board(self, screen): + board_width = BOARDWIDTH + board_height = BOARDHEIGHT + color = 10, 255, 255 + width = 0 + for i in range(board_width): + pos = i * 20, 0, 20, 20 + pygame.draw.rect(screen, color, pos, width) + pos = i * 20, (board_height - 1) * 20, 20, 20 + pygame.draw.rect(screen, color, pos, width) + for i in range(board_height - 1): + pos = 0, 20 + i * 20, 20, 20 + pygame.draw.rect(screen, color, pos, width) + pos = (board_width - 1) * 20, 20 + i * 20, 20, 20 + pygame.draw.rect(screen, color, pos, width) + + def game_over(self): + broad_x, broad_y = self.snake.get_head() + flag = 0 + old = len(self.snake.item) + new = len(set(self.snake.item)) + if new < old: + flag = 1 + if broad_x == 0 or broad_x == BOARDWIDTH - 1: + flag = 1 + if broad_y == 0 or broad_y == BOARDHEIGHT - 1: + flag = 1 + return flag == 1 + + def print_text(self, screen, font, x, y, text, color=(255, 0, 0)): + imgText = font.render(text, True, color) + screen.blit(imgText, (x, y)) + + def handle_key(self, keys): + if keys[K_w] or keys[K_UP]: + self.snake.toward(0, -1) + elif keys[K_s] or keys[K_DOWN]: + self.snake.toward(0, 1) + elif keys[K_a] or keys[K_LEFT]: + self.snake.toward(-1, 0) + elif keys[K_d] or keys[K_RIGHT]: + self.snake.toward(1, 0) + elif keys[K_r]: + self.reset_game() + + def handle_event(self, event): + if event.type == KEYDOWN: + if event.key == K_r: + self.reset_game() + + def update(self): + current_time = time.time() + if current_time - self.last_update < 0.1: + return + self.last_update = current_time + + if self.screen is None: + return + + self.screen.fill((0, 0, 100)) + self.init_board(self.screen) + + keys = pygame.key.get_pressed() + self.handle_key(keys) + + if self.is_fail: + if self.font: + font2 = pygame.font.Font(None, 40) + self.print_text(self.screen, self.font, 0, 0, f"Score: {self.snake.score}") + self.print_text(self.screen, font2, 400, 200, "GAME OVER") + else: + font = pygame.font.SysFont('Arial', 40) + text = font.render("GAME OVER - Press R to restart", True, (255, 0, 0)) + text_rect = text.get_rect(center=(BOARDWIDTH * 10, BOARDHEIGHT * 10)) + self.screen.blit(text, text_rect) + else: + enlarge = self.snake.eat_food(self.food) + if self.font: + text = f"Score: {self.snake.score}" + self.print_text(self.screen, self.font, 0, 0, text) + else: + font = pygame.font.SysFont('Arial', 20) + text = font.render(f"Score: {self.snake.score}", True, (255, 255, 255)) + self.screen.blit(text, (10, 10)) + + self.food.update(self.screen, enlarge, self.snake) + self.snake.move(enlarge) + self.is_fail = self.game_over() + self.snake.draw(self.screen) + + pygame.display.update() + + def run(self): + if not self.standalone: + return + + running = True + while running: + for event in pygame.event.get(): + if event.type == QUIT: + running = False + else: + self.handle_event(event) + + self.update() + self.clock.tick(30) + + pygame.quit() + + +if __name__ == '__main__': + game = SnakeGame() + game.run()