import arcade import json import math import random import pyglet from pyglet.display.base import Screen, ScreenMode from fill_level import filler SCREEN_WIDTH = 1280 SCREEN_HEIGHT = 720 # def calculate_coeff(self, degr): # return math.cos(math.radians(degr)) + math.sin(math.radians(degr)) # def convert_rot_to_body(self, deg0, deg1 ): # # deg1 - угол ближайшей к голове части # # deg0 - угол переходной части (он особый) # deg0 = deg0 % 360 # deg1 = deg1 % 360 # if (deg0 == 180 and deg1 == 270) or (deg0 == 270 and deg1 == 90): # return 180 # if (deg0 == 90 and deg1 == 270) or (deg0 == 0 and deg1 == 90): # return 0 # if ((deg0 == 90) and deg1 == 180) or (deg0 == 180 and deg1 == 0): # return 90 # if (deg0 == 0 and deg1 == 180) or (deg0 == 270 and deg1 == 0): # return 270 # return 0 class food(): def __init__(self, x, y, healf = 1): self.x = x self.y = y self.healf = healf class body(): def __init__(self, x, y, rotate, type, health = 3): self.x = x self.y = y self.rotate = rotate self.type = type self.health = health class SNAKE(): def __init__(self, star_point_x, star_point_y, start_rotate = 0): self.tail_rot = 0 self.body = [ body(star_point_x, star_point_y, start_rotate, "head"), body(star_point_x - 1, star_point_y, start_rotate, "tail") ] def check_contact(self,x,y): cont = 0 for body in self.body: if body.x == x and body.y == y: cont = 1 return cont def get_damage(self, index): self.body[index].health -= 1 if self.body[index].health == 0: del self.body[index:len(self.body)] def calculate_rot(self, degr1, degr2): # deg1 - угол ближайшей к голове части # deg2 - угол дальней от голове части degr1 = degr1 % 360 degr2 = degr2 % 360 if (degr1 == 180 and degr2 == 270) or (degr1 == 90 and degr2 == 0): return 180 if (degr1 == 0 and degr2 == 90) or (degr1 == 270 and degr2 == 180): return 0 if ((degr1 == 90) and degr2 == 180) or (degr1 == 0 and degr2 == 270): return 90 if (degr1 == 270 and degr2 == 0) or (degr1 == 180 and degr2 == 90): return 270 return 90 def calc_tail_rotate(self): tail = self.body[len(self.body)-1] pre_last = self.body[len(self.body)-2] grad = 0 pos_x = tail.x pos_y = tail.y while not((pre_last.x == pos_x) and (pre_last.y == pos_y)): pos_x = tail.x + int(math.cos(math.radians(grad))) pos_y = tail.y + int(math.sin(math.radians(grad))) grad += 90 return grad - 90 def player_move(self, vector): i = len(self.body)-1 self.tail_rot = self.body[i].rotate while i > 0: self.body[i].x = self.body[i-1].x self.body[i].y = self.body[i-1].y self.body[i].rotate = self.body[i-1].rotate self.body[i].type = self.body[i-1].type i -= 1 self.body[0].rotate = vector * 90 self.body[0].x = int(math.cos(math.radians(self.body[0].rotate))) + self.body[0].x self.body[0].y = int(math.sin(math.radians(self.body[0].rotate))) + self.body[0].y self.body[0].rotate = 360 - self.body[0].rotate if self.body[0].rotate != self.body[1].rotate: self.body[1].type = "body-rotate" self.body[1].rotate = 360 - self.calculate_rot(360 - self.body[0].rotate, 360 - self.body[1].rotate) else: self.body[1].type = "body" self.body[ len(self.body) - 1 ].type = "tail" self.body[ len(self.body) - 1 ].rotate = 360 - self.calc_tail_rotate() def add_body(self): last_body = self.body[len(self.body)-1] new_body = body(last_body.x, last_body.y, self.tail_rot, "tail") v_x = int(math.cos(math.radians(360 - self.tail_rot))) v_y = int(math.sin(math.radians(360 - self.tail_rot))) new_body.x = last_body.x - v_x new_body.y = last_body.y - v_y l = len(self.body) - 1 if 360 - self.body[l].rotate != 360 - self.tail_rot: self.body[l].type = "body-rotate" self.body[l].rotate = 360 - self.calculate_rot(360 - self.body[l].rotate, 360 - self.tail_rot) else: self.body[l].type = "body" self.body.append(new_body) class Level_data(): def __init__(self, level_data_json = []): if level_data_json: self.fill_grid(level_data_json) def fill_grid(self, level_data_json): self.name = level_data_json["name"] self.floor = level_data_json["floor"] self.size = level_data_json["size"] self.enemy_types = level_data_json["enemy_types"] self.enemy_spawns = level_data_json["enemy_spawns"] self.start_point = level_data_json["start_point"] class MYGAME(arcade.Window): def __init__( self, width: int = 1280, height: int = 720, title: str | None = "Snake", fullscreen: bool = False, resizable: bool = False, update_rate: float = 1 / 60, antialiasing: bool = True, gl_version: tuple[int, int] = (3, 3), screen: Screen | None = None, style: str | None = pyglet.window.Window.WINDOW_STYLE_DEFAULT, visible: bool = True, vsync: bool = False, gc_mode: str = "context_gc", center_window: bool = True, samples: int = 4, enable_polling: bool = True, gl_api: str = "gl", draw_rate: float = 1 / 60, fixed_rate: float = 1.0 / 60.0, fixed_frame_cap: int | None = None, ): super().__init__(width, height) arcade.set_background_color(arcade.color.AMAZON) def setup(self, level_name): print(f"Upload level: {level_name}") with open(f'./DATA/Levels/{level_name}/data.json', 'r') as file: self.Lvl_data = Level_data(json.load(file)) if self.Lvl_data.name : print(f"{self.Lvl_data.name} loaded") else: print("Error to load level") self.enemies_list = arcade.SpriteList() self.enemy_spawn = arcade.SpriteList() self.tecnical_list = arcade.SpriteList() # Сетка уровня self.floor_list = arcade.SpriteList() grid = fill_empty_grid() self.floor_grid = self.arr2grid(self.Lvl_data.floor, grid) self.print_grid(self.floor_grid) # Загрузка текстур self.texture_list = { "snake": { "head": arcade.load_texture( "./DATA/Sprites/Snake/head.png" ), "body": arcade.load_texture( "./DATA/Sprites/Snake/body.png" ), "body-rotate": arcade.load_texture( "./DATA/Sprites/Snake/body-rotate.png" ), "tail": arcade.load_texture( "./DATA/Sprites/Snake/tail.png" ) }, "food": { "healthy-food": arcade.load_texture( "./DATA/Sprites/Enemies/Tier 0/healthy_food.png" ) }, "floor": { "floor-gray": arcade.load_texture( "./DATA/Sprites/Floor/floor_grey.png" ) } } # food self.food_list = arcade.SpriteList() self.food_sleep = 200 self.delay = 200 self.food = [] # Счет self.score = 0 self.scale_ = 1.4 screen_center = [SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2] self.level_start = [screen_center[0] - self.Lvl_data.size[0] * 16 * self.scale_, screen_center[1] - self.Lvl_data.size[1] * 16 * self.scale_] # Загрузка змеи self.snake_sprite_list = arcade.SpriteList() self.snake = SNAKE(self.Lvl_data.start_point["x"], self.Lvl_data.start_point["y"]) # Загрузка пола for floor in self.Lvl_data.floor: floor_sprite = arcade.Sprite(self.texture_list["floor"]["floor-gray"], self.scale_) floor_sprite.center_x = self.level_start[0] - 16 + ( floor["x"] ) * 32 * self.scale_ floor_sprite.center_y = self.level_start[1] - 16 + ( floor["y"] ) * 32 * self.scale_ self.floor_list.append(floor_sprite) def update_snake_sprites(self): # Обновляем положениям спрайтов if (len(self.snake.body) == len(self.snake_sprite_list)): for i, body_part in enumerate(self.snake.body): self.snake_sprite_list[i].texture = self.texture_list[ "snake" ][ body_part.type ] self.snake_sprite_list[i].angle = body_part.rotate self.snake_sprite_list[i].center_x = self.level_start[0] - 16 + ( body_part.x ) * 32 * self.scale_ self.snake_sprite_list[i].center_y = self.level_start[1] - 16 + ( body_part.y ) * 32 * self.scale_ elif (len(self.snake.body) - len(self.snake_sprite_list) > 0): # Обновляем список спрайтов delta = len(self.snake.body) - len(self.snake_sprite_list) i = len(self.snake.body) - delta while i <= len(self.snake.body) - 1: snake_new_sprite = arcade.Sprite(self.texture_list[ "snake" ][ self.snake.body[i].type ], self.scale_) snake_new_sprite.angle = self.snake.body[i].rotate snake_new_sprite.center_x = self.level_start[0] - 16 + ( self.snake.body[i].x ) * 32 * self.scale_ snake_new_sprite.center_y = self.level_start[1] - 16 + ( self.snake.body[i].y ) * 32 * self.scale_ self.snake_sprite_list.append( snake_new_sprite ) i += 1 else: # Обновляем список спрайтов delta = len(self.snake_sprite_list) - len(self.snake.body) i = len(self.snake.body) - delta + 1 while i <= len(self.snake_sprite_list) - 1: self.snake_sprite_list[i].kill() i += 1 def spawn_food(self): spawn = False while spawn == False: x = random.randint(0, 14) y = random.randint(0, 14) if self.floor_grid[y][x] == 1: food_sprite = arcade.Sprite(self.texture_list[ "food" ][ "healthy-food" ], self.scale_) food_sprite.center_x = self.level_start[0] - 16 + ( x ) * 32 * self.scale_ food_sprite.center_y = self.level_start[1] - 16 + ( y ) * 32 * self.scale_ if arcade.check_for_collision_with_list(food_sprite, self.floor_list) != [] and arcade.check_for_collision_with_list(food_sprite, self.snake_sprite_list) == []: self.food_list.append(food_sprite) spawn = True else: food_sprite.kill() def find_way(self, enemy): if enemy.detect == 0: vector = 0 while vector != 360 and self.check_floor(vector, enemy) == 0: vector += 90 if vector == 360: enemy.angle = random.randint(0, 3) * 90 else: enemy.angle = 360 - vector def enemy_move(self, enemy): if self.check_floor(360 - enemy.angle, enemy): enemy.center_x = int(math.cos(math.radians(360 - enemy.angle))) * 32 * self.scale_ + enemy.center_x enemy.center_y = int(math.sin(math.radians(360 - enemy.angle))) * 32 * self.scale_ + enemy.center_y def check_detect(self, enemy): pass def on_update(self, delta_time: float): self.update_snake_sprites() # Food self.food_sleep -= 1 if self.food_sleep <= 0: self.spawn_food() self.food_sleep = self.delay list = arcade.check_for_collision_with_list(self.snake_sprite_list[0], self.food_list) if list != []: self.food_list.remove(list[0]) self.score += 1 for body_part in self.snake.body: body_part.health = 3 self.snake.body self.snake.add_body() self.spawn_food() # Enemy # for enemy in self.enemies_list: # enemy.sleep -= 1 # self.check_detect(enemy) # if (enemy.sleep == enemy.delay / 2 ): # self.find_way(enemy) # elif (enemy.sleep == 0 ): # self.enemy_move(enemy) # enemy.sleep = enemy.delay # Enemy_spawn # for spawn in self.Lvl_data.enemy_spawns[0]: # spawn["sleep"] -= 1 # if spawn["sleep"] <= 0: # spawn["sleep"] = spawn["delay"] # self.spawn_enemy(spawn["y"], spawn["x"], spawn["tier"]) def spawn_enemy(self, y, x, tier): type = random.randint(0, len(self.Lvl_data.enemy_types[tier-1])) if (type == 0): enemy_sprite = arcade.Sprite("./DATA/Sprites/Enemies/Tier 1/little-spider.png", self.scale_) posible = arcade.check_for_collision_with_list(enemy_sprite, self.snake_sprite_list) == [] posible = posible and arcade.check_for_collision_with_list(enemy_sprite, self.enemies_list) == [] if posible: enemy_sprite.damage = 1 enemy_sprite.healf = 1 enemy_sprite.toxic = 0 enemy_sprite.detect = 0 enemy_sprite.sleep = 200 enemy_sprite.delay = 200 enemy_sprite.hear_radius = 1 * 32 * self.scale_ enemy_sprite.angle = 90 enemy_sprite.center_x = self.level_start[0] - 16 + ( x ) * 32 * self.scale_ enemy_sprite.center_y = self.level_start[1] - 16 + ( y ) * 32 * self.scale_ self.enemies_list.append(enemy_sprite) else: enemy_sprite.kill() # print_spawn("tier: " + str(type), x, y) def print_grid(self, grid): x = 0 y = 14 print_ = '' while y >= 0: while x < 15: print_ += " " if grid[y][x] == 0 else "1 " x += 1 print(print_) print_ = '' y -= 1 x = 0 def arr2grid(self, arr, grid): for point in arr: grid[point["y"]][point["x"]] = 1 return grid # Обработка нажатий def check_floor(self, vector, sprite): rotate = 90 * vector v_x = int(math.cos(math.radians(rotate))) * 32 * self.scale_ v_y = int(math.sin(math.radians(rotate))) * 32 * self.scale_ new_pos = arcade.Sprite( self.texture_list["floor"]["floor-gray"], self.scale_, sprite.center_x + v_x, sprite.center_y + v_y ) posible = arcade.check_for_collision_with_list(new_pos, self.floor_list) != [] body_part = arcade.check_for_collision_with_list(new_pos, self.snake_sprite_list) if ( body_part != [] and body_part[0] != self.snake_sprite_list[0]): self.snake.get_damage(self.snake_sprite_list.index(body_part[0])) posible = False # posible = posible and arcade.check_for_collision_with_list(new_pos, self.enemies_list) == [] new_pos.kill() return posible def on_key_press(self, key, modifiers): """Вызывается при нажатии пользователем клавиши""" # Get the first sprite (head) from the player list if len(self.snake_sprite_list) == 0: return if key in (arcade.key.UP, arcade.key.W): if self.snake_sprite_list[0].angle != 90: if self.check_floor(1, self.snake_sprite_list[0]): self.snake.player_move(1) self.update_snake_sprites() elif key in (arcade.key.DOWN, arcade.key.S): if self.snake_sprite_list[0].angle != 270: if self.check_floor(3, self.snake_sprite_list[0]): self.snake.player_move(3) self.update_snake_sprites() elif key in (arcade.key.LEFT, arcade.key.A): if (self.snake_sprite_list[0].angle != 360 and self.snake_sprite_list[0].angle != 0): if self.check_floor(2, self.snake_sprite_list[0]): self.snake.player_move(2) self.update_snake_sprites() elif key in (arcade.key.RIGHT, arcade.key.D): if self.snake_sprite_list[0].angle != 180: if self.check_floor(0, self.snake_sprite_list[0]): self.snake.player_move(0) self.update_snake_sprites() def on_draw(self): # Очищаем экран перед каждой отрисовкой self.clear() # Отрисовываем все спрайты self.floor_list.draw() # self.tecnical_list.draw() self.food_list.draw() # self.enemies_list.draw() self.snake_sprite_list.draw() arcade.draw_text(f"Score: {self.score}", self.level_start[0], self.level_start[1], arcade.color.BLACK, 24) def print_spawn(who, x, y): print(f"Spawn: {who}\nx: {x}\ny: {y}") def fill_empty_grid(): grid = [] y = 0 x = 0 while y < 15: grid.append([]) while x < 15: grid[y].append([x]) grid[y][x] = 0 x = x + 1 y = y + 1 x = 0 return grid def main(): filler_ = filler("Default") filler_.fill_level(filler_.floor_code) filler_.export2json() game = MYGAME(SCREEN_WIDTH, SCREEN_HEIGHT) game.setup( "Default" ) arcade.run() if __name__ == "__main__": main()