def update(self):
        super().update()

        if self.state == state.ON_MOVE:

            if abs(self.from_x - self.center_x) >= GRID_SIZE or abs(
                    self.from_y - self.center_y) >= GRID_SIZE:
                self.change_x = 0
                self.change_y = 0
                self.x += self.dx
                self.y += self.dy
                # self.fighter.wait += self.fighter.speed
                self.dx, self.dy = 0, 0

                self.from_x, self.from_y = self.center_x, self.center_y
                self.state = state.TURN_END
                self.form = form.NORMAL
        if self.state == state.TURN_END:
            self.change_x = 0
            self.change_y = 0
            self.center_x, self.center_y = grid_to_pixel(self.x, self.y)
        elif self.state == state.READY:
            self.change_x = 0
            self.change_y = 0
            self.center_x, self.center_y = grid_to_pixel(self.x, self.y)
def apply_damage(skill, engine, x, y, results):
    position = grid_to_pixel(x, y)
    # print(f"{pixel_x}{pixel_y} apply pixel_x_y")
    sprites = arcade.get_sprites_at_point(
        position, engine.cur_level.actor_sprites)

    for sprite in sprites:
        if sprite.fighter and not sprite.is_dead:
            result = sprite.fighter.skill_process(skill)
            if result:
                results.extend(result)
    def draw_select_mouse_location(self):
        """ マウス操作時のグリッド表示"""

        mouse_x, mouse_y = self.mouse_position
        grid_x, grid_y = pixel_to_grid(mouse_x, mouse_y)
        center_x, center_y = grid_to_pixel(grid_x, grid_y)

        arcade.draw_rectangle_outline(center_x=center_x,
                                      center_y=center_y,
                                      width=SPRITE_SIZE * SPRITE_SCALE,
                                      height=SPRITE_SIZE * SPRITE_SCALE,
                                      color=arcade.color.RAJAH,
                                      border_width=2)
Exemple #4
0
    def items_set(self):
        """itemをgame_mapタイル番号から設定する
        """
        item_sprites = arcade.SpriteList(use_spatial_hash=True,
                                         spatial_hash_cell_size=32)
        for x in range(self.width):
            for y in range(self.height):
                if type(self.item_tiles[x][y]) is int:
                    item = get_random_items_by_challenge(self.item_tiles[x][y])

                    item.x = x
                    item.y = y
                    cx, cy = grid_to_pixel(x, y)
                    item.center_x = cx
                    item.center_y = cy

                    item_sprites.append(item)

        return item_sprites
Exemple #5
0
    def actor_set(self):
        """actorをgame_mapタイル番号から設定する
        """
        actor_sprites = arcade.SpriteList(use_spatial_hash=True,
                                          spatial_hash_cell_size=32)
        for x in range(self.width):
            for y in range(self.height):
                if type(self.actor_tiles[x][y]) == int:
                    monster = get_random_monster_by_challenge(
                        self.actor_tiles[x][y])
                    # monster = make_monster_sprite(monster_tile_number)
                    monster.x = x
                    monster.y = y
                    cx, cy = grid_to_pixel(x, y)
                    monster.center_x = cx
                    monster.center_y = cy

                    actor_sprites.append(monster)  # ここをコメントアウトすると敵無しに

        return actor_sprites
    def update(self):

        self.d_time -= 2
        if 40 > self.d_time:
            self.d_time = 170

            #############

        try:
            if self.engine.skill_shape:
                for line in Bresenham(
                    (self.engine.player.x, self.engine.player.y),
                    (self.dx, self.dy)):
                    line = grid_to_pixel(*line)
                    arcade.draw_rectangle_filled(line[0], line[1], GRID_SIZE,
                                                 GRID_SIZE, [
                                                     255,
                                                     251,
                                                     160,
                                                     100,
                                                 ])
        except:
            pass
Exemple #7
0
    def items_point_set(self):
        items_point_sprites = arcade.SpriteList(use_spatial_hash=False,
                                                spatial_hash_cell_size=32)
        for x in range(self.width):
            for y in range(self.height):
                if type(self.item_tiles[x][y]) is int:

                    item = Actor(image=IMAGE_ID["items_point"],
                                 scale=1.2,
                                 x=x,
                                 y=y,
                                 color=COLORS["black"],
                                 visible_color=COLORS["light_ground"],
                                 not_visible_color=COLORS["light_ground"])
                    item.x = x
                    item.y = y
                    cx, cy = grid_to_pixel(x, y)
                    item.center_x = cx
                    item.center_y = cy

                    items_point_sprites.append(item)

        return items_point_sprites
    def grid_cursor(self):
        self.sprites = [
            self.engine.cur_level.actor_sprites,
            self.engine.cur_level.item_sprites
        ]

        self.dx += self.grid_select[0]
        self.dy += self.grid_select[1]

        self.x, self.y = grid_to_pixel(self.dx, self.dy)
        if self.x < self.viewport_left:
            print(f"{self.x=} {self.viewport_left=}")

        # グリッド囲い線の描写
        arcade.draw_rectangle_outline(center_x=self.x,
                                      center_y=self.y,
                                      width=SPRITE_SIZE * SPRITE_SCALE,
                                      height=SPRITE_SIZE * SPRITE_SCALE,
                                      color=arcade.color.LIGHT_BLUE,
                                      border_width=3)
        # 点滅するグリッド内部
        arcade.draw_rectangle_filled(center_x=self.x,
                                     center_y=self.y,
                                     width=SPRITE_SIZE * SPRITE_SCALE - 2,
                                     height=SPRITE_SIZE * SPRITE_SCALE - 2,
                                     color=[255, 255, 255, self.d_time])
        if self.engine.skill_shape:
            for x, y in self.engine.skill_shape:
                arcade.draw_rectangle_filled(
                    center_x=self.x + (x * 64),
                    center_y=self.y + (y * 64),
                    width=SPRITE_SIZE * SPRITE_SCALE,
                    height=SPRITE_SIZE * SPRITE_SCALE,
                    color=[200, 115, 155, self.d_time])

        try:

            # グリッド囲い線の中にあるオブジェクトの情報の表示
            actor_at_point = arcade.get_sprites_at_exact_point(
                (self.x, self.y), self.sprites[0])
            item_at_point = arcade.get_sprites_at_exact_point((self.x, self.y),
                                                              self.sprites[1])
            if actor_at_point or item_at_point:
                y = 20
                for actor in chain(actor_at_point, item_at_point):
                    if actor.ai:
                        arcade.draw_text(
                            text=
                            f"{actor.name.capitalize()}\n{actor.fighter.hp}/{actor.fighter.max_hp}",
                            start_x=self.viewport_left + SCREEN_WIDTH -
                            STATES_PANEL_WIDTH + 10,
                            start_y=self.viewport_bottom + SCREEN_HEIGHT -
                            400 - y,
                            color=arcade.color.RED_PURPLE,
                            font_size=20,
                        )
                        y += 20

                    y += 10

                    if not actor.ai:
                        arcade.draw_text(
                            text=f"{actor.__class__.__name__}",
                            start_x=self.viewport_left + SCREEN_WIDTH -
                            STATES_PANEL_WIDTH + 10,
                            start_y=self.viewport_bottom + SCREEN_HEIGHT -
                            400 - y,
                            color=arcade.color.GREEN_YELLOW,
                            font_size=20,
                        )
                        y += 30

                    if actor.explanatory_text:
                        arcade.draw_text(
                            text=f"{actor.explanatory_text}",
                            start_x=self.viewport_left + SCREEN_WIDTH -
                            STATES_PANEL_WIDTH + 10,
                            start_y=self.viewport_bottom + SCREEN_HEIGHT -
                            400 - y,
                            color=arcade.color.WHITE,
                            font_size=14,
                        )
                        y += 20
        except:
            pass
    def on_draw(self):
        """全画像の表示"""

        arcade.start_render()

        # minimap start ------------------------------------------------------------------------------------------------------------
        """minimap draw"""
        if self.engine.game_state == GAME_STATE.NORMAL:
            self.offscreen.use()
            # self.offscreen.clear(arcade.color.BLACK)

            arcade.set_viewport(0, GAME_GROUND_WIDTH, 0,
                                GAME_GROUND_HEIGHT+GRID_SIZE*2)

            self.engine.cur_level.map_point_sprites.draw()
            arcade.draw_rectangle_filled(center_x=self.engine.player.center_x,
                                         center_y=self.engine.player.center_y, width=45, height=45, color=arcade.color.BLUE)

            self.engine.cur_level.item_point_sprites.draw()

        self.use()
        self.color_attachment.use(0)
        self.quad_fs.render(self.program)
        # minimap end -------------------------------------------------------------------------------------------------------------




            
        # アタック時はビューポート固定する
        if self.engine.game_state == GAME_STATE.NORMAL:
            if self.engine.player.state == state.ON_MOVE:
                viewport(self.engine.player.center_x, self.engine.player.center_y)
                # viewport(self.engine.player.from_x, self.engine.player.from_y)
            else:
                x, y = (grid_to_pixel(self.engine.player.x, self.engine.player.y))
                viewport(x,y)

        # ビューポート情報取得(この位置で取得しないとバグる)
        self.viewports = arcade.get_viewport()

        # arcadeの光源効果
        with self.engine.light_layer:
            self.draw_sprites()
            self.engine.light_layer.draw(ambient_color=(1,1,1))


        # ノーマルステート時の画面表示
        if self.engine.game_state == GAME_STATE.NORMAL or self.engine.game_state == GAME_STATE.DELAY_WINDOW:
            self.normal_UI.draw_in_normal_state(self.viewports)
            # damage表示
            for i in self.engine.damage_pop:
                if i.dist > 40:
                    self.engine.damage_pop.remove(i)
                elif i.dist < 30:
                    i.draw()


        # Character_Screen表示
        elif self.engine.game_state == GAME_STATE.CHARACTER_SCREEN:
            self.character_UI.draw_character_screen(arcade.get_viewport(), self.engine.selected_item)
            
        # inventory表示
        elif self.engine.game_state == GAME_STATE.INVENTORY:
            draw_inventory(self.engine, self.engine.selected_item, self.viewports)

        # level_up画面表示
        elif self.engine.game_state == GAME_STATE.LEVEL_UP_WINDOW:
            self.level_up_window.window_pop(self.viewports, self.engine)
        elif self.engine.game_state == GAME_STATE.LEVEL_UP_FLOWER:
            self.level_up_flower.window_pop(self.viewports)

        # LOOKシステム
        elif self.engine.game_state == GAME_STATE.SELECT_LOCATION or self.engine.game_state == GAME_STATE.LOOK:
            # lookカーソルにviewportを渡す
            x, y = grid_to_pixel(self.select_UI.grid_select[0]+self.engine.player.x, self.select_UI.grid_select[1]+self.engine.player.y)
            viewport(x, y)
            # Lookメイン関数
            self.select_UI.draw_in_select_ui(self.viewports, self.engine)


        # draw the mini_map(この位置に置かないとバグる)
        if self.engine.game_state == GAME_STATE.NORMAL:
            self.color_attachment.use(0)
            self.mini_map_quad.render(self.program)
def recalculate_fov(engine, radius):
    """ Fovの計算を行う
    """
    player = engine.player
    char_x, char_y = player.position_xy
    sprite_lists = [
        engine.cur_level.wall_sprites, engine.cur_level.floor_sprites,
        engine.cur_level.actor_sprites, engine.cur_level.item_sprites,
        engine.cur_level.map_obj_sprites, engine.cur_level.map_point_sprites,
        engine.cur_level.item_point_sprites
    ]

    # 最初に渡された全てのスプライトリストをループし、is_visible等をFalseにして画面から隠す
    for sprite_list in sprite_lists:
        for sprite in sprite_list:
            if sprite.is_visible:
                sprite.is_visible = False
                sprite.color = sprite.not_visible_color
                if Tag.npc in sprite.tag:
                    sprite.alpha = 0

    resolution = 12
    circumference = 2 * math.pi * radius

    radians_per_point = 2 * math.pi / (circumference * resolution)
    point_count = int(round(circumference)) * resolution
    for i in range(point_count):
        radians = i * radians_per_point

        x = math.sin(radians) * radius + char_x
        y = math.cos(radians) * radius + char_y

        ray_checks = radius
        for j in range(ray_checks):
            v1 = char_x, char_y
            v2 = x, y
            x2, y2 = arcade.lerp_vec(v1, v2, j / ray_checks)
            x2 = round(x2)
            y2 = round(y2)

            pixel_point = grid_to_pixel(x2, y2)

            blocks = False
            for sprite_list in sprite_lists:
                sprites_at_point = arcade.get_sprites_at_exact_point(
                    pixel_point, sprite_list)

                # 探索済みならis_visibleをTrueにする
                for sprite in sprites_at_point:
                    sprite.is_visible = True
                    if sprite.block_sight:
                        blocks = True
                    if hasattr(sprite.ai, "visible_check"):
                        if sprite.ai.visible_check == False:
                            engine.damage_pop.append(
                                DamagePop("!", (250, 240, 0),
                                          sprite,
                                          15,
                                          size=30))
                            engine.move_switch = False
                            sprite.ai.visible_check = True

            if blocks:
                break

    # 全てのスプライトを再度ループし、is_visibleがTrueなら画面に表示する
    for sprite_list in sprite_lists:
        for sprite in sprite_list:
            if sprite.is_visible:
                sprite.color = sprite.visible_color
                sprite.alpha = 255
 def position_xy(self, value):
     self._x, self._y = value
     self.center_x, self.center_y = grid_to_pixel(self._x, self._y)
 def y(self, value):
     self._y = value
     self.center_x, self.center_y = grid_to_pixel(self._x, self._y)