小学生python游戏编程arcade----基本知识5 自动行走的敌人

前言

接上篇文章小学生python游戏编程arcade----基本知识1、2，连接如下：小学生python游戏编程arcade----基本知识，小学生python游戏编程arcade----基本知识2,小学生python游戏编程arcade----基本知识3

自动行走的敌人

1、敌人的类定义

1.1 不同的敌人，不同的生命值

通过对Enemy类的继承，调用不同的图片，显示不同的敌人与生命值

1.2 动画更新在在父类中实现

def update_animation(self, delta_time: float = 1 / 60):

1.3 代码实现

class Enemy(DongSprite):
    def __init__(self, name_folder, name_file):

        # 通过父类设置，文件夹及文件名
        super().__init__(name_folder, name_file)

        self.should_update_walk = 0
        self.health = 0

    def update_animation(self, delta_time: float = 1 / 60):

        # 面向参数
        if self.change_x < 0 and self.facing_direction == R_facing:
            self.facing_direction = L_facing
        elif self.change_x > 0 and self.facing_direction == L_facing:
            self.facing_direction = R_facing

        # 站立动画
        if self.change_x == 0:
            self.texture = self.idle_texture_pair[self.facing_direction]
            return

        # 行走动画
        if self.should_update_walk == 3:
            self.cur_texture += 1
            if self.cur_texture > 7:
                self.cur_texture = 0
            self.texture = self.walk_textures[self.cur_texture][self.facing_direction]
            self.should_update_walk = 0
            return

        self.should_update_walk += 1



class RobotEnemy(Enemy):
    def __init__(self):

        # 通过父类设置，文件夹及文件名
        super().__init__("robot", "robot")
        self.health = 100

class ZombieEnemy(Enemy):
    def __init__(self):

        # 通过父类设置，文件夹及文件名
        super().__init__("zombie", "zombie")
        self.health = 50
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

2、Enemy类的使用

2.1 在setup中初始敌人

enemies_layer = self.tile_map.object_lists[‘Enemies’]

2.2 通过对所有地图 上敌人插入点进行调用类的初始方法加载图片

    for my_object in enemies_layer:
        cartesian = self.tile_map.get_cartesian(
            my_object.shape[0], my_object.shape[1]
        )

        enemy_type = my_object.properties["type"]
        if enemy_type == "robot":
            enemy = RobotEnemy()
        elif enemy_type == "zombie":
            enemy = ZombieEnemy()
        else:
            raise Exception(f"Unknown enemy type {enemy_type}.")
1
2
3
4
5
6
7
8
9
10
11
12

2.3 通过在地图中设置敌人可行走的x值范围及enemy.change_x属性，实现自动行走

        if "boundary_left" in my_object.properties:
            enemy.boundary_left = my_object.properties["boundary_left"]
        if "boundary_right" in my_object.properties:
            enemy.boundary_right = my_object.properties["boundary_right"]
        if "change_x" in my_object.properties:
            enemy.change_x = my_object.properties["change_x"]
1
2
3
4
5
6

2.4 代码实现

        # -- 敌人 Enemies
        enemies_layer = self.tile_map.object_lists['Enemies']

        for my_object in enemies_layer:
            print(my_object.shape)
            # print(my_object.shape[0],'shap',my_object.shape[1])
            # 因我的地图enemies层中有点及距形,点删除了，同一层中不好区分
            # if my_object.p
            cartesian = self.tile_map.get_cartesian(
                my_object.shape[0], my_object.shape[1]
            )

            enemy_type = my_object.properties["type"]
            if enemy_type == "robot":
                enemy = RobotEnemy()
            elif enemy_type == "zombie":
                enemy = ZombieEnemy()
            else:
                raise Exception(f"Unknown enemy type {enemy_type}.")
            enemy.center_x = math.floor(
                cartesian[0] * TILE_Scaling * self.tile_map.tile_width
            )
            enemy.center_y = math.floor(
                (cartesian[1] + 1) * (self.tile_map.tile_height * TILE_Scaling)
            )
            self.scene.add_sprite(LAYER_enemies, enemy)

            if "boundary_left" in my_object.properties:
                enemy.boundary_left = my_object.properties["boundary_left"]
            if "boundary_right" in my_object.properties:
                enemy.boundary_right = my_object.properties["boundary_right"]
            if "change_x" in my_object.properties:
                enemy.change_x = my_object.properties["change_x"]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

3、碰撞检测

3.1 敌人与玩家的碰撞

碰撞检测
player_collision_list = arcade.check_for_collision_with_lists(
self.wanjia,
[
# self.scene[LAYER_tree],
self.scene[LAYER_enemies],
],
)

3.2 检测磁到的是硬币还是敌人

    for collision in player_collision_list:
        if self.scene[LAYER_enemies] in collision.sprite_lists:
            arcade.play_sound(self.game_over)
            self.setup()
            return
        else:
            # 算出这枚硬币值多少分
            if "Points" not in collision.properties:
                print("警告，收集的硬币没有点数属性.")
            else:
                points = int(collision.properties["Points"])
                self.score += points

            # Remove the coin
            collision.remove_from_sprite_lists()
            arcade.play_sound(self.collect_coin_sound)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

总的效果及源代码

# _*_ coding: UTF-8 _*_
# 开发人员： Administrator
# 开发时间：2022/11/5 16:59


from arcadegame.mysprite import *
import math
import os


class MyGame(arcade.Window):
    def __init__(self):
        # 初始化窗体
        super().__init__(SCREEN_width, SCREEN_height, SCREEN_title)
        self.scene = None
        self.player_sprite = None

        file_path = os.path.dirname(os.path.abspath(__file__))
        os.chdir(file_path)
        # 上下左右按键状态
        self.left_pressed = False
        self.right_pressed = False
        self.up_pressed = False
        self.down_pressed = False
        self.jump_needs_reset = False

        arcade.set_background_color(arcade.csscolor.BLUE)

        self.physics_engine = None
        self.camera = None  # 摄象机
        self.gui_camera = None  # 第二摄象机
        self.score = 0
        # 加载声音
        self.collect_coin_sound = arcade.load_sound("sounds/coin2.wav")
        self.jump_sound = arcade.load_sound("sounds/s3.wav")
        self.game_over = arcade.load_sound(":resources:sounds/gameover1.wav")

        # 设置地图
        self.tile_map = None
        # 是否重新设置分数
        self.reset_score = True
        # 地图的最右边
        self.end_of_map = 0
        # 关卡级别
        self.level = 1

    def setup(self):
        # 摄象机
        self.camera = arcade.Camera(self.width, self.height)
        self.gui_camera = arcade.Camera(self.width, self.height)

        # 初始化场景
        map_name = f"地图\家2.json"  # jia{self.level}.json"
        # 层属性
        layer_options = {
            LAYER_platforms: {
                "use_spatial_hash": True,
            },
            LAYER_tree: {
                "use_spatial_hash": False,
            },
            'fz': {
                "use_spatial_hash": True,
            },
            # 'tizi': {
            #     "use_spatial_hash": True,
            # },
            'Enemies': {
                "use_spatial_hash": True,
            },
        }

        # 读地图文件
        self.tile_map = arcade.load_tilemap(map_name, TILE_Scaling, layer_options)
         # 使用我们的TileMap初始化场景，这将自动添加所有层，以正确的顺序在场景中显示为SpriteList。
        self.scene = arcade.Scene.from_tilemap(self.tile_map)
        print('精灵列表', self.scene['fz'])

        if self.reset_score:
            self.score = 0
        self.reset_score = True

        self.end_of_map = self.tile_map.width * GRID_pixel_size


        # 添加角色.
        self.wanjia = PlayerCharacter()
        self.wanjia.center_x = PLAYER_start_x
        self.wanjia.center_y = PLAYER_start_y
        self.scene.add_sprite_list_after("wj", LAYER_platforms)  # 添加精灵列表，把玩家放在哪一层，前后层在此关健
        self.scene.add_sprite("wj",self.wanjia)
        # self.physics_engine = arcade.PhysicsEnginePlatformer(
        #     self.wanjia, gravity_constant=GRAVITY, walls=self.scene[LAYER_tree]
        # )  # 此处的walls=指定支撑图层
        self.physics_engine = arcade.PhysicsEngineSimple(
            self.wanjia,
            walls=self.scene['fz'])
        # -- 敌人 Enemies
        enemies_layer = self.tile_map.object_lists['Enemies']

        for my_object in enemies_layer:
            print(my_object.shape)
            # print(my_object.shape[0],'shap',my_object.shape[1])
            # 因我的地图enemies层中有点及距形,点删除了，同一层中不好区分
            # if my_object.p
            cartesian = self.tile_map.get_cartesian(
                my_object.shape[0], my_object.shape[1]
            )

            enemy_type = my_object.properties["type"]
            if enemy_type == "robot":
                enemy = RobotEnemy()
            elif enemy_type == "zombie":
                enemy = ZombieEnemy()
            else:
                raise Exception(f"Unknown enemy type {enemy_type}.")
            enemy.center_x = math.floor(
                cartesian[0] * TILE_Scaling * self.tile_map.tile_width
            )
            enemy.center_y = math.floor(
                (cartesian[1] + 1) * (self.tile_map.tile_height * TILE_Scaling)
            )
            self.scene.add_sprite(LAYER_enemies, enemy)

            if "boundary_left" in my_object.properties:
                enemy.boundary_left = my_object.properties["boundary_left"]
            if "boundary_right" in my_object.properties:
                enemy.boundary_right = my_object.properties["boundary_right"]
            if "change_x" in my_object.properties:
                enemy.change_x = my_object.properties["change_x"]
        # # 设置背景色
        # if self.tile_map.background_color:
        #     arcade.set_background_color(self.tile_map.background_color)

    def on_draw(self):
        self.clear()
        self.camera.use()  # 摄象机
        self.scene.draw()  # 摄相机与scence的顺序不能放错，否则不会移动
        self.gui_camera.use()
        # 在屏幕上绘制分数，用屏幕滚动
        score_text = f"得分: {self.score}"
        arcade.draw_text(score_text, 10, 500, arcade.csscolor.RED, 18, )

    def process_keychange(self):
        """ 当我们向上/向下改变键或上/下梯子时调用.     """
        if not self.up_pressed and not self.down_pressed:
            self.wanjia.change_y = 0
        elif self.down_pressed:
            self.wanjia.change_y = -PLAYER_movement_speed
        elif self.up_pressed:
            self.wanjia.change_y = PLAYER_movement_speed

        # 左右
        if self.right_pressed and not self.left_pressed:
            self.wanjia.change_x = PLAYER_movement_speed
        elif self.left_pressed and not self.right_pressed:
            self.wanjia.change_x = -PLAYER_movement_speed
        else:
            self.wanjia.change_x = 0

    def on_key_press(self, key, modifiers):
        """每当按下键时调用."""
        if key == arcade.key.UP or key == arcade.key.W:
            self.up_pressed = True
        elif key == arcade.key.DOWN or key == arcade.key.S:
            self.down_pressed = True
        elif key == arcade.key.LEFT or key == arcade.key.A:
            self.left_pressed = True
        elif key == arcade.key.RIGHT or key == arcade.key.D:
            self.right_pressed = True

        self.process_keychange()

    def on_key_release(self, key, modifiers):
        """键盘释放时"""
        if key == arcade.key.UP or key == arcade.key.W:
            self.up_pressed = False
            self.jump_needs_reset = False
        elif key == arcade.key.DOWN or key == arcade.key.S:
            self.down_pressed = False
        elif key == arcade.key.LEFT or key == arcade.key.A:
            self.left_pressed = False
        elif key == arcade.key.RIGHT or key == arcade.key.D:
            self.right_pressed = False

        self.process_keychange()

    def center_camera_to_player(self):
        """摄相机随角色移动"""
        screen_center_x = self.wanjia.center_x - (self.camera.viewport_width / 2)
        screen_center_y = self.wanjia.center_y - (self.camera.viewport_height / 2)

        # 防止相机出界
        if screen_center_x < 0:
            screen_center_x = 0
        if screen_center_y < 0:
            screen_center_y = 0
        player_centered = screen_center_x, screen_center_y
        # print(player_centered)
        self.camera.move_to(player_centered)
        # print(self.wanjia.center_x)

    def on_update(self, delta_time):
        """运动和游戏逻辑"""
        self.physics_engine.update()  # 运用引擎移动角色
        # 掉下或level达到最后一关时，游戏结束，或重新开始
        if self.wanjia.center_y < -100 or self.level==3:
            self.wanjia.center_x = PLAYER_start_x
            self.wanjia.center_y = PLAYER_start_y
            arcade.play_sound(self.game_over)

        self.process_keychange()
        # 更新动画
        self.scene.update_animation(delta_time, ['wj', LAYER_enemies])
        # Update moving platforms and enemies
        self.scene.update([LAYER_enemies])

        # 看看敌人是否达到了边界，需要改变方向.
        for enemy in self.scene[LAYER_enemies]:
            # enemy.left += enemy.change_x 此句通过读sprite中的update（）方法已实现
            # print(enemy.left,enemy.right,enemy.change_x)
            # print(enemy.boundary_left,enemy.boundary_right)
            if (
                    enemy.boundary_right
                    and enemy.right > enemy.boundary_right
                    and enemy.change_x > 0
            ):
                enemy.change_x *= -1

            if (
                    enemy.boundary_left
                    and enemy.left < enemy.boundary_left
                    and enemy.change_x < 0
            ):
                enemy.change_x *= -1

        # 碰撞检测
        player_collision_list = arcade.check_for_collision_with_lists(
            self.wanjia,
            [
                # self.scene[LAYER_tree],
                self.scene[LAYER_enemies],
            ],
        )

        # 检测磁到的是硬币还是敌人
        for collision in player_collision_list:
            if self.scene[LAYER_enemies] in collision.sprite_lists:
                arcade.play_sound(self.game_over)
                self.setup()
                return
            else:
                # 算出这枚硬币值多少分
                if "Points" not in collision.properties:
                    print("警告，收集的硬币没有点数属性.")
                else:
                    points = int(collision.properties["Points"])
                    self.score += points

                # Remove the coin
                collision.remove_from_sprite_lists()
                arcade.play_sound(self.collect_coin_sound)


        # 是否走到地图尽头
        if self.wanjia.center_x >= self.end_of_map:
            # 关卡升级
            self.level += 1
            # 不需重新积分
            self.reset_score = False
            # 加载下个场景
            self.setup()

        self.center_camera_to_player()   # 摄象机


def main():
    """主程序"""
    window = MyGame()
    window.setup()
    arcade.run()


if __name__ == "__main__":
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286

源码获取

可关注博主后，私聊博主免费获取
需要技术指导，育娃新思考，企业软件合作等更多服务请联系博主

今天是以此模板持续更新此育儿专栏的第 15/50次。
可以关注我，点赞我、评论我、收藏我啦。