dabai 1.0.0__tar.gz
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- dabai-1.0.0/API.py +900 -0
- dabai-1.0.0/LICENSE +21 -0
- dabai-1.0.0/PKG-INFO +929 -0
- dabai-1.0.0/README.md +903 -0
- dabai-1.0.0/__init__.py +22 -0
- dabai-1.0.0/android.py +351 -0
- dabai-1.0.0/buildozer.spec +37 -0
- dabai-1.0.0/camera.py +68 -0
- dabai-1.0.0/config.py +87 -0
- dabai-1.0.0/constraints.py +30 -0
- dabai-1.0.0/dabai.egg-info/PKG-INFO +929 -0
- dabai-1.0.0/dabai.egg-info/SOURCES.txt +57 -0
- dabai-1.0.0/dabai.egg-info/dependency_links.txt +1 -0
- dabai-1.0.0/dabai.egg-info/requires.txt +7 -0
- dabai-1.0.0/dabai.egg-info/top_level.txt +1 -0
- dabai-1.0.0/draw.py +7 -0
- dabai-1.0.0/draw_options.py +94 -0
- dabai-1.0.0/events.py +147 -0
- dabai-1.0.0/game_object.py +110 -0
- dabai-1.0.0/music.py +72 -0
- dabai-1.0.0/physics.py +329 -0
- dabai-1.0.0/pyproject.toml +49 -0
- dabai-1.0.0/screen.py +91 -0
- dabai-1.0.0/settings.py +1 -0
- dabai-1.0.0/setup.cfg +4 -0
- dabai-1.0.0/sprite.py +411 -0
- dabai-1.0.0/static/DialogBox.png +0 -0
- dabai-1.0.0/static/NotoSansSC-Regular.otf +0 -0
- dabai-1.0.0/static/OFL.txt +94 -0
- dabai-1.0.0/tests/__init__.py +0 -0
- dabai-1.0.0/tests/bugfix_verification.py +238 -0
- dabai-1.0.0/tests/expected_sweep.txt +120 -0
- dabai-1.0.0/tests/golden_parity.txt +76 -0
- dabai-1.0.0/tests/parity_script.py +120 -0
- dabai-1.0.0/tests/run_all.py +220 -0
- dabai-1.0.0/tests/run_lesson_capped.py +84 -0
- dabai-1.0.0/textbox.py +202 -0
- dabai-1.0.0/tiledmap.py +71 -0
dabai-1.0.0/API.py
ADDED
|
@@ -0,0 +1,900 @@
|
|
|
1
|
+
from .game_object import *
|
|
2
|
+
from .screen import *
|
|
3
|
+
from .sprite import *
|
|
4
|
+
from .physics import *
|
|
5
|
+
from .events import *
|
|
6
|
+
from .tiledmap import TiledMap
|
|
7
|
+
from .textbox import *
|
|
8
|
+
from .music import *
|
|
9
|
+
from .draw import *
|
|
10
|
+
from .constraints import *
|
|
11
|
+
from .android import IS_ANDROID, virtualpad, scan_layout, DEFAULT_PAD_LAYOUT
|
|
12
|
+
import random
|
|
13
|
+
import time
|
|
14
|
+
import sys
|
|
15
|
+
import math
|
|
16
|
+
|
|
17
|
+
IS_UPDATED = 0
|
|
18
|
+
SPEED = 1
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
def tracer(f):
|
|
22
|
+
global IS_UPDATED
|
|
23
|
+
IS_UPDATED = f
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
def speed(s):
|
|
27
|
+
global SPEED
|
|
28
|
+
SPEED = s
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
def random_pos():
|
|
32
|
+
return (
|
|
33
|
+
random.randint(-global_var.WIDTH // 2, global_var.WIDTH // 2),
|
|
34
|
+
random.randint(-global_var.HEIGHT // 2, global_var.HEIGHT // 2),
|
|
35
|
+
)
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
def debug():
|
|
39
|
+
global_var.DEBUG_DRAW = True
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def set_gravity(x, *y):
|
|
43
|
+
if y:
|
|
44
|
+
global_var.SPACE.gravity = (x, *y)
|
|
45
|
+
else:
|
|
46
|
+
# pymunk 6.11 不接受 pygame Vector2,需要转成 tuple
|
|
47
|
+
global_var.SPACE.gravity = (
|
|
48
|
+
(x.x, x.y) if hasattr(x, "x") and hasattr(x, "y") else tuple(x)
|
|
49
|
+
)
|
|
50
|
+
|
|
51
|
+
|
|
52
|
+
def set_mouse_visible(v):
|
|
53
|
+
pygame.mouse.set_visible(v)
|
|
54
|
+
|
|
55
|
+
|
|
56
|
+
def enable_pad(layout=None, source=None):
|
|
57
|
+
"""打开虚拟按键。
|
|
58
|
+
|
|
59
|
+
- 不带参数: 自动扫描课程源码里用到的 K_* 键生成按钮,
|
|
60
|
+
课程改按键后按钮自动跟着变(安卓上 setup() 已自动调用)
|
|
61
|
+
- 传列表: 完全按列表来, 如 enable_pad([(K_1, "1", 0.9, 0.5), ...])
|
|
62
|
+
- 传 source 字符串: 用这段文本代替课程文件做扫描(测试用)
|
|
63
|
+
"""
|
|
64
|
+
if layout is None and source is not None:
|
|
65
|
+
layout = scan_layout(source) or DEFAULT_PAD_LAYOUT
|
|
66
|
+
virtualpad.enable(layout)
|
|
67
|
+
|
|
68
|
+
|
|
69
|
+
def disable_pad():
|
|
70
|
+
virtualpad.disable()
|
|
71
|
+
|
|
72
|
+
|
|
73
|
+
def sign(n):
|
|
74
|
+
if n > 0:
|
|
75
|
+
return 1
|
|
76
|
+
elif n < 0:
|
|
77
|
+
return -1
|
|
78
|
+
else:
|
|
79
|
+
return 0
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
class NewGameObject:
|
|
83
|
+
def __init__(
|
|
84
|
+
self, imgs=None, size=None, body_type=pymunk.Body.KINEMATIC, sensor=False
|
|
85
|
+
):
|
|
86
|
+
self.DialogBox_img = os.path.join(cwd, "static", "DialogBox.png")
|
|
87
|
+
self.DialogBox_font = os.path.join(cwd, "static", "NotoSansSC-Regular.otf")
|
|
88
|
+
self._gameObject = GameObject()
|
|
89
|
+
if imgs:
|
|
90
|
+
self._gameObject.set_sprite(Sprite(imgs))
|
|
91
|
+
|
|
92
|
+
if size:
|
|
93
|
+
if isinstance(size, int):
|
|
94
|
+
self._gameObject.set_body(
|
|
95
|
+
Body(body_type, "CIRCLE", size=size, sensor=sensor)
|
|
96
|
+
)
|
|
97
|
+
self.radius = self._gameObject.body.shape.radius
|
|
98
|
+
elif isinstance(size, tuple):
|
|
99
|
+
self._gameObject.set_body(
|
|
100
|
+
Body(body_type, "BOX", size=size, sensor=sensor)
|
|
101
|
+
)
|
|
102
|
+
self.vertices = self._gameObject.body.shape.get_vertices()
|
|
103
|
+
elif isinstance(size, list):
|
|
104
|
+
if isinstance(size[0], list):
|
|
105
|
+
self._gameObject.set_body(
|
|
106
|
+
Body(body_type, "POLY", size=size, sensor=sensor)
|
|
107
|
+
)
|
|
108
|
+
self.vertices = self._gameObject.body.shape.get_vertices()
|
|
109
|
+
else:
|
|
110
|
+
objs = size
|
|
111
|
+
tiledmap_objects = TiledMapBodies(body_type, objs, sensor)
|
|
112
|
+
self._gameObject.set_tiledmap_bodies(tiledmap_objects)
|
|
113
|
+
|
|
114
|
+
self._direction = vec(1, 0)
|
|
115
|
+
self._dialogBox = None
|
|
116
|
+
self._get_clicked = False
|
|
117
|
+
|
|
118
|
+
global_var.GROUP.add(self)
|
|
119
|
+
self._just_released = False
|
|
120
|
+
self.collision_dict = {}
|
|
121
|
+
self.sounds = []
|
|
122
|
+
self.volume = 1
|
|
123
|
+
self.rememberClick = ""
|
|
124
|
+
if self._gameObject.sprite:
|
|
125
|
+
self._gameObject.sprite.update()
|
|
126
|
+
|
|
127
|
+
def __len__(self):
|
|
128
|
+
raise NotImplementedError
|
|
129
|
+
|
|
130
|
+
def __getitem__(self):
|
|
131
|
+
raise NotImplementedError
|
|
132
|
+
|
|
133
|
+
def __setitem__(self):
|
|
134
|
+
raise NotImplementedError
|
|
135
|
+
|
|
136
|
+
def __bool__(self):
|
|
137
|
+
return True
|
|
138
|
+
|
|
139
|
+
def __del__(self):
|
|
140
|
+
pass
|
|
141
|
+
|
|
142
|
+
"""
|
|
143
|
+
运动命令
|
|
144
|
+
"""
|
|
145
|
+
|
|
146
|
+
def forward(self, d):
|
|
147
|
+
n = 0
|
|
148
|
+
while n < abs(d):
|
|
149
|
+
# 每步不超过剩余距离: SPEED 大于剩余量时走剩余量, 总位移精确等于 d
|
|
150
|
+
# (SPEED 为 0 时剩余距离一步走完, 避免死循环)
|
|
151
|
+
step = min(SPEED, abs(d) - n) if SPEED > 0 else abs(d) - n
|
|
152
|
+
self._gameObject.pos += self._direction * step * sign(d)
|
|
153
|
+
n += step
|
|
154
|
+
if IS_UPDATED:
|
|
155
|
+
update()
|
|
156
|
+
|
|
157
|
+
def backward(self, d):
|
|
158
|
+
n = 0
|
|
159
|
+
while n < abs(d):
|
|
160
|
+
step = min(SPEED, abs(d) - n) if SPEED > 0 else abs(d) - n
|
|
161
|
+
self._gameObject.pos -= self._direction * step * sign(d)
|
|
162
|
+
n += step
|
|
163
|
+
if IS_UPDATED:
|
|
164
|
+
update()
|
|
165
|
+
|
|
166
|
+
def _rotate(self, rot):
|
|
167
|
+
self.rotate_image(rot)
|
|
168
|
+
self.rotate_direction(rot)
|
|
169
|
+
|
|
170
|
+
def rotate_direction(self, rot):
|
|
171
|
+
self.dir = self.dir.rotate(rot)
|
|
172
|
+
|
|
173
|
+
def rotate_image(self, rot):
|
|
174
|
+
self.rot += rot
|
|
175
|
+
|
|
176
|
+
@property
|
|
177
|
+
def rot(self):
|
|
178
|
+
return self._gameObject.rot
|
|
179
|
+
|
|
180
|
+
@rot.setter
|
|
181
|
+
def rot(self, r):
|
|
182
|
+
# 角度没变就不动它(物理引擎每帧回写角度, 拦住可以省掉
|
|
183
|
+
# 每帧一次的旋转变换和空间索引重建); 数值仍写回保持类型一致
|
|
184
|
+
if abs(r - self._gameObject.rot) < 1e-6:
|
|
185
|
+
self._gameObject.rot = r
|
|
186
|
+
return
|
|
187
|
+
self._gameObject.rot = r
|
|
188
|
+
if self._gameObject.sprite:
|
|
189
|
+
self._gameObject.sprite.rotated = True
|
|
190
|
+
if self._gameObject.body:
|
|
191
|
+
self._gameObject.body.set_rot(r)
|
|
192
|
+
if self._gameObject.tiledmap_bodies:
|
|
193
|
+
self._gameObject.tiledmap_bodies.set_rot(r)
|
|
194
|
+
|
|
195
|
+
@property
|
|
196
|
+
def dir(self):
|
|
197
|
+
return self._direction
|
|
198
|
+
|
|
199
|
+
@dir.setter
|
|
200
|
+
def dir(self, d):
|
|
201
|
+
self._direction = d
|
|
202
|
+
|
|
203
|
+
@property
|
|
204
|
+
def get_angle(self):
|
|
205
|
+
angle = math.atan2(self._direction[0], self._direction[1])
|
|
206
|
+
degrees = math.degrees(angle)
|
|
207
|
+
return round(degrees, 1)
|
|
208
|
+
|
|
209
|
+
def set_angle(self, angle):
|
|
210
|
+
radians = math.radians(angle)
|
|
211
|
+
x = math.sin(radians)
|
|
212
|
+
y = math.cos(radians)
|
|
213
|
+
self.dir = [x, y]
|
|
214
|
+
|
|
215
|
+
def left(self, a):
|
|
216
|
+
n = 0
|
|
217
|
+
while n < abs(a):
|
|
218
|
+
step = min(SPEED, abs(a) - n) if SPEED > 0 else abs(a) - n
|
|
219
|
+
self._rotate(step * sign(a))
|
|
220
|
+
n += step
|
|
221
|
+
if IS_UPDATED:
|
|
222
|
+
update()
|
|
223
|
+
|
|
224
|
+
def right(self, a):
|
|
225
|
+
n = 0
|
|
226
|
+
while n < abs(a):
|
|
227
|
+
step = min(SPEED, abs(a) - n) if SPEED > 0 else abs(a) - n
|
|
228
|
+
self._rotate(-step * sign(a))
|
|
229
|
+
n += step
|
|
230
|
+
if IS_UPDATED:
|
|
231
|
+
update()
|
|
232
|
+
|
|
233
|
+
def slide_to(self, pos, v=1):
|
|
234
|
+
distance = vec(pos) - self._gameObject.pos
|
|
235
|
+
if distance.length() < v:
|
|
236
|
+
self._gameObject.pos = vec(pos)
|
|
237
|
+
return True
|
|
238
|
+
self._gameObject.pos += distance.normalize() * v
|
|
239
|
+
return False
|
|
240
|
+
|
|
241
|
+
def goto(self, x, *y):
|
|
242
|
+
if y:
|
|
243
|
+
self._gameObject.pos = vec(x, *y)
|
|
244
|
+
else:
|
|
245
|
+
self._gameObject.pos = vec(x)
|
|
246
|
+
if self._gameObject.body:
|
|
247
|
+
self._gameObject.body.velocity = vec(0, 0)
|
|
248
|
+
# update()
|
|
249
|
+
|
|
250
|
+
def face_to(self, x, *y, VEC=False):
|
|
251
|
+
if not VEC:
|
|
252
|
+
if y:
|
|
253
|
+
self.rot = -(vec(x, *y) - self._gameObject.pos).angle_to(vec(1, 0))
|
|
254
|
+
self.dir = (vec(x, *y) - self._gameObject.pos).normalize()
|
|
255
|
+
else:
|
|
256
|
+
self.rot = -(vec(x) - self._gameObject.pos).angle_to(vec(1, 0))
|
|
257
|
+
if (vec(x) - self._gameObject.pos).length() != 0:
|
|
258
|
+
self.dir = (vec(x) - self._gameObject.pos).normalize()
|
|
259
|
+
else:
|
|
260
|
+
if y:
|
|
261
|
+
self.rot = -vec(x, *y).angle_to(vec(1, 0))
|
|
262
|
+
self.dir = vec(x, *y).normalize()
|
|
263
|
+
else:
|
|
264
|
+
self.rot = -vec(x).angle_to(vec(1, 0))
|
|
265
|
+
if vec(x).length() != 0:
|
|
266
|
+
self.dir = vec(x).normalize()
|
|
267
|
+
|
|
268
|
+
@property
|
|
269
|
+
def pos(self):
|
|
270
|
+
return self._gameObject.pos
|
|
271
|
+
|
|
272
|
+
@property
|
|
273
|
+
def x(self):
|
|
274
|
+
return self._gameObject.pos[0]
|
|
275
|
+
|
|
276
|
+
@property
|
|
277
|
+
def y(self):
|
|
278
|
+
return self._gameObject.pos[1]
|
|
279
|
+
|
|
280
|
+
@pos.setter
|
|
281
|
+
def pos(self, p):
|
|
282
|
+
self._gameObject.pos = p
|
|
283
|
+
if self._gameObject.body:
|
|
284
|
+
self._gameObject.body.velocity = vec(0, 0)
|
|
285
|
+
if self._gameObject.tiledmap_bodies:
|
|
286
|
+
self._gameObject.tiledmap_bodies.velocity = vec(0, 0)
|
|
287
|
+
|
|
288
|
+
@dir.setter
|
|
289
|
+
def dir(self, dir):
|
|
290
|
+
self._direction = dir
|
|
291
|
+
|
|
292
|
+
@x.setter
|
|
293
|
+
def x(self, x):
|
|
294
|
+
if self._gameObject.body:
|
|
295
|
+
self._gameObject.body.velocity = vec(0, 0)
|
|
296
|
+
if self._gameObject.tiledmap_bodies:
|
|
297
|
+
self._gameObject.tiledmap_bodies.velocity = vec(0, 0)
|
|
298
|
+
self._gameObject.x = x
|
|
299
|
+
|
|
300
|
+
@y.setter
|
|
301
|
+
def y(self, y):
|
|
302
|
+
if self._gameObject.body:
|
|
303
|
+
self._gameObject.body.velocity = vec(0, 0)
|
|
304
|
+
if self._gameObject.tiledmap_bodies:
|
|
305
|
+
self._gameObject.tiledmap_bodies.velocity = vec(0, 0)
|
|
306
|
+
self._gameObject.y = y
|
|
307
|
+
|
|
308
|
+
@property
|
|
309
|
+
def velocity(self):
|
|
310
|
+
if self._gameObject.body:
|
|
311
|
+
return self._gameObject.body.velocity
|
|
312
|
+
elif self._gameObject.tiledmap_bodies:
|
|
313
|
+
return self._gameObject.tiledmap_bodies.velocity
|
|
314
|
+
|
|
315
|
+
@velocity.setter
|
|
316
|
+
def velocity(self, v):
|
|
317
|
+
if self._gameObject.body:
|
|
318
|
+
self._gameObject.body.velocity = v
|
|
319
|
+
elif self._gameObject.tiledmap_bodies:
|
|
320
|
+
self._gameObject.tiledmap_bodies.velocity = v
|
|
321
|
+
|
|
322
|
+
@property
|
|
323
|
+
def angular_velocity(self):
|
|
324
|
+
if self._gameObject.body:
|
|
325
|
+
return self._gameObject.body.angular_velocity
|
|
326
|
+
elif self._gameObject.tiledmap_bodies:
|
|
327
|
+
return self._gameObject.tiledmap_bodies.angular_velocity
|
|
328
|
+
|
|
329
|
+
@angular_velocity.setter
|
|
330
|
+
def angular_velocity(self, v):
|
|
331
|
+
if self._gameObject.body:
|
|
332
|
+
self._gameObject.body.angular_velocity = v
|
|
333
|
+
elif self._gameObject.tiledmap_bodies:
|
|
334
|
+
self._gameObject.tiledmap_bodies.angular_velocity = v
|
|
335
|
+
|
|
336
|
+
"""
|
|
337
|
+
图片命令
|
|
338
|
+
"""
|
|
339
|
+
|
|
340
|
+
def scale(self, scalex, scaley=None):
|
|
341
|
+
if scaley == None:
|
|
342
|
+
if self._gameObject.sprite:
|
|
343
|
+
self._gameObject.sprite.scaled = True
|
|
344
|
+
self._gameObject.scl = scalex
|
|
345
|
+
if self._gameObject.body:
|
|
346
|
+
self.body_scale(scalex, scaley)
|
|
347
|
+
if self._gameObject.tiledmap_bodies:
|
|
348
|
+
self.body_scale(scalex, scaley)
|
|
349
|
+
else:
|
|
350
|
+
if self._gameObject.sprite:
|
|
351
|
+
self._gameObject.sprite.scaled = True
|
|
352
|
+
self._gameObject.scl = (scalex, scaley)
|
|
353
|
+
if self._gameObject.body:
|
|
354
|
+
self.body_scale(scalex, scaley)
|
|
355
|
+
if self._gameObject.tiledmap_bodies:
|
|
356
|
+
self.body_scale(scalex, scaley)
|
|
357
|
+
|
|
358
|
+
def flipx(self, h):
|
|
359
|
+
self._gameObject.sprite.fliped = True
|
|
360
|
+
self._gameObject.sprite.is_flip_h = h
|
|
361
|
+
|
|
362
|
+
def flipy(self, v):
|
|
363
|
+
self._gameObject.sprite.fliped = True
|
|
364
|
+
self._gameObject.sprite.is_flip_v = v
|
|
365
|
+
|
|
366
|
+
@property
|
|
367
|
+
def red(self):
|
|
368
|
+
return self._gameObject.sprite.red
|
|
369
|
+
|
|
370
|
+
@red.setter
|
|
371
|
+
def red(self, red):
|
|
372
|
+
self._gameObject.sprite.modified = True
|
|
373
|
+
self._gameObject.sprite.red = red
|
|
374
|
+
|
|
375
|
+
@property
|
|
376
|
+
def green(self):
|
|
377
|
+
return self._gameObject.sprite.green
|
|
378
|
+
|
|
379
|
+
@green.setter
|
|
380
|
+
def green(self, green):
|
|
381
|
+
self._gameObject.sprite.modified = True
|
|
382
|
+
self._gameObject.sprite.green = green
|
|
383
|
+
|
|
384
|
+
@property
|
|
385
|
+
def blue(self):
|
|
386
|
+
return self._gameObject.sprite.blue
|
|
387
|
+
|
|
388
|
+
@blue.setter
|
|
389
|
+
def blue(self, blue):
|
|
390
|
+
self._gameObject.sprite.modified = True
|
|
391
|
+
self._gameObject.sprite.blue = blue
|
|
392
|
+
|
|
393
|
+
@property
|
|
394
|
+
def alpha(self):
|
|
395
|
+
return self._gameObject.sprite.alpha
|
|
396
|
+
|
|
397
|
+
@alpha.setter
|
|
398
|
+
def alpha(self, alpha):
|
|
399
|
+
self._gameObject.sprite.modified = True
|
|
400
|
+
self._gameObject.sprite.alpha = alpha
|
|
401
|
+
|
|
402
|
+
@property
|
|
403
|
+
def color(self):
|
|
404
|
+
return (
|
|
405
|
+
self._gameObject.sprite.red,
|
|
406
|
+
self._gameObject.sprite.green,
|
|
407
|
+
self._gameObject.sprite.blue,
|
|
408
|
+
self._gameObject.sprite.alpha,
|
|
409
|
+
)
|
|
410
|
+
|
|
411
|
+
@color.setter
|
|
412
|
+
def color(self, color):
|
|
413
|
+
# 不建议对过大的地图进行此操作,会导致动画变慢
|
|
414
|
+
self._gameObject.sprite.modified = True
|
|
415
|
+
self._gameObject.sprite.red = color[0]
|
|
416
|
+
self._gameObject.sprite.green = color[1]
|
|
417
|
+
self._gameObject.sprite.blue = color[2]
|
|
418
|
+
self._gameObject.sprite.alpha = color[3]
|
|
419
|
+
|
|
420
|
+
def show(self):
|
|
421
|
+
self._gameObject.sprite.modified = True
|
|
422
|
+
self._gameObject.sprite.visible = True
|
|
423
|
+
|
|
424
|
+
def hide(self):
|
|
425
|
+
self._gameObject.sprite.modified = True
|
|
426
|
+
self._gameObject.sprite.visible = False
|
|
427
|
+
|
|
428
|
+
@property
|
|
429
|
+
def visible(self):
|
|
430
|
+
return self._gameObject.sprite.visible
|
|
431
|
+
|
|
432
|
+
@property
|
|
433
|
+
def width(self):
|
|
434
|
+
return self._gameObject.sprite.width
|
|
435
|
+
|
|
436
|
+
@property
|
|
437
|
+
def height(self):
|
|
438
|
+
return self._gameObject.sprite.height
|
|
439
|
+
|
|
440
|
+
# 动画命令
|
|
441
|
+
@property
|
|
442
|
+
def frame(self):
|
|
443
|
+
return self._gameObject.sprite.sprite_strategy.frame
|
|
444
|
+
|
|
445
|
+
@frame.setter
|
|
446
|
+
def frame(self, f):
|
|
447
|
+
self._gameObject.sprite.sprite_strategy.frame = f
|
|
448
|
+
|
|
449
|
+
def play_anim(self):
|
|
450
|
+
self._gameObject.sprite.sprite_strategy.playing = True
|
|
451
|
+
|
|
452
|
+
def stop_anim(self):
|
|
453
|
+
self._gameObject.sprite.sprite_strategy.playing = False
|
|
454
|
+
|
|
455
|
+
@property
|
|
456
|
+
def state(self):
|
|
457
|
+
return self._gameObject.sprite.sprite_strategy.state
|
|
458
|
+
|
|
459
|
+
@state.setter
|
|
460
|
+
def state(self, state):
|
|
461
|
+
self._gameObject.sprite.sprite_strategy.state = state
|
|
462
|
+
|
|
463
|
+
def set_dt(self, *args):
|
|
464
|
+
self._gameObject.sprite.sprite_strategy.set_dt(*args)
|
|
465
|
+
|
|
466
|
+
@property
|
|
467
|
+
def dt(self):
|
|
468
|
+
if isinstance(self._gameObject.sprite.sprite_strategy, ListSpriteStrategy):
|
|
469
|
+
return self._gameObject.sprite.sprite_strategy.dt
|
|
470
|
+
else:
|
|
471
|
+
raise NotImplementedError
|
|
472
|
+
|
|
473
|
+
@dt.setter
|
|
474
|
+
def dt(self, dt):
|
|
475
|
+
if isinstance(self._gameObject.sprite.sprite_strategy, ListSpriteStrategy):
|
|
476
|
+
self.set_dt(dt)
|
|
477
|
+
else:
|
|
478
|
+
raise NotImplementedError
|
|
479
|
+
|
|
480
|
+
def set_next_state(self, state, next_state):
|
|
481
|
+
self._gameObject.sprite.sprite_strategy.set_next_state(state, next_state)
|
|
482
|
+
|
|
483
|
+
def set_start_func(self, state, func):
|
|
484
|
+
self._gameObject.sprite.sprite_strategy.set_start_func(state, func)
|
|
485
|
+
|
|
486
|
+
def set_end_func(self, state, func):
|
|
487
|
+
self._gameObject.sprite.sprite_strategy.set_end_func(state, func)
|
|
488
|
+
|
|
489
|
+
# 图层
|
|
490
|
+
@property
|
|
491
|
+
def layer(self):
|
|
492
|
+
return global_var.ALL_SPRITES.get_layer_of_sprite(self._gameObject.sprite)
|
|
493
|
+
|
|
494
|
+
@layer.setter
|
|
495
|
+
def layer(self, layer):
|
|
496
|
+
global_var.ALL_SPRITES.change_layer(self._gameObject.sprite, layer)
|
|
497
|
+
|
|
498
|
+
def move_to_front(self):
|
|
499
|
+
global_var.ALL_SPRITES.move_to_front(self._gameObject.sprite)
|
|
500
|
+
|
|
501
|
+
def move_to_back(self):
|
|
502
|
+
global_var.ALL_SPRITES.move_to_back(self._gameObject.sprite)
|
|
503
|
+
|
|
504
|
+
# 音效
|
|
505
|
+
def play_snd(self, snd=None, volume=None):
|
|
506
|
+
if snd:
|
|
507
|
+
s = pygame.mixer.Sound(snd)
|
|
508
|
+
if not volume:
|
|
509
|
+
volume = self.volume
|
|
510
|
+
s.set_volume(volume)
|
|
511
|
+
if len(self.sounds) == 20:
|
|
512
|
+
pre_s = self.sounds.pop(0)
|
|
513
|
+
pre_s.stop()
|
|
514
|
+
s.play()
|
|
515
|
+
|
|
516
|
+
def set_volume(self, volume):
|
|
517
|
+
self.volume = volume
|
|
518
|
+
|
|
519
|
+
# 交互
|
|
520
|
+
|
|
521
|
+
def get_mouse_clicked(self, b="all"):
|
|
522
|
+
# 检测鼠标左键是否在按下的状态下
|
|
523
|
+
for event in global_var.EVENTS:
|
|
524
|
+
if (
|
|
525
|
+
event
|
|
526
|
+
and event.type == MOUSEBUTTONDOWN
|
|
527
|
+
and self.get_mouse_upon()
|
|
528
|
+
and (event.button == b or b == "all")
|
|
529
|
+
):
|
|
530
|
+
self._get_clicked = True
|
|
531
|
+
self.rememberClick = str(b)
|
|
532
|
+
self.get_mouse_just_released(b)
|
|
533
|
+
if self._get_clicked and self.rememberClick == str(b):
|
|
534
|
+
return True
|
|
535
|
+
else:
|
|
536
|
+
return False
|
|
537
|
+
|
|
538
|
+
def get_mouse_just_clicked(self, b="all"):
|
|
539
|
+
# 检测鼠标是否刚刚被按下
|
|
540
|
+
for event in global_var.EVENTS:
|
|
541
|
+
if (
|
|
542
|
+
event
|
|
543
|
+
and event.type == MOUSEBUTTONDOWN
|
|
544
|
+
and self.get_mouse_upon()
|
|
545
|
+
and (event.button == b or b == "all")
|
|
546
|
+
):
|
|
547
|
+
self._get_clicked = True
|
|
548
|
+
return True
|
|
549
|
+
else:
|
|
550
|
+
return False
|
|
551
|
+
|
|
552
|
+
def get_mouse_just_released(self, b="all"):
|
|
553
|
+
# 检测鼠标是否刚刚被松开
|
|
554
|
+
if self._just_released:
|
|
555
|
+
self.rememberClick = ""
|
|
556
|
+
return True
|
|
557
|
+
self.get_mouse_just_clicked(b)
|
|
558
|
+
if self._get_clicked:
|
|
559
|
+
for event in global_var.EVENTS:
|
|
560
|
+
if event and event.type == MOUSEBUTTONUP:
|
|
561
|
+
self._get_clicked = False
|
|
562
|
+
self._just_released = True
|
|
563
|
+
if self._get_clicked:
|
|
564
|
+
return False
|
|
565
|
+
else:
|
|
566
|
+
return True
|
|
567
|
+
else:
|
|
568
|
+
return False
|
|
569
|
+
|
|
570
|
+
def get_mouse_upon(self):
|
|
571
|
+
# 检测鼠标是否在图片上
|
|
572
|
+
if self.collide(get_mouse_pos()):
|
|
573
|
+
return True
|
|
574
|
+
else:
|
|
575
|
+
return False
|
|
576
|
+
|
|
577
|
+
# 其他
|
|
578
|
+
def collide(self, other):
|
|
579
|
+
|
|
580
|
+
if self._gameObject.sprite and self._gameObject.sprite.visible:
|
|
581
|
+
|
|
582
|
+
if isinstance(other, tuple) or isinstance(other, vec):
|
|
583
|
+
|
|
584
|
+
if self._gameObject.body:
|
|
585
|
+
|
|
586
|
+
return self._gameObject.body.point_query(other)
|
|
587
|
+
elif self._gameObject.tiledmap_bodies:
|
|
588
|
+
|
|
589
|
+
return self._gameObject.tiledmap_bodies.point_query(other)
|
|
590
|
+
else:
|
|
591
|
+
|
|
592
|
+
mask = pygame.mask.from_surface(
|
|
593
|
+
self._gameObject.sprite.image, threshold=0
|
|
594
|
+
)
|
|
595
|
+
offset = (
|
|
596
|
+
self._gameObject.pos
|
|
597
|
+
- other
|
|
598
|
+
+ vec(
|
|
599
|
+
self._gameObject.sprite.width // 2,
|
|
600
|
+
self._gameObject.sprite.height // 2,
|
|
601
|
+
)
|
|
602
|
+
)
|
|
603
|
+
# 对offset进行了重新处理,防止mask左右颠倒
|
|
604
|
+
offset = [int(i) for i in offset]
|
|
605
|
+
offset[0] = self._gameObject.sprite.width - offset[0]
|
|
606
|
+
try:
|
|
607
|
+
|
|
608
|
+
return bool(mask.get_at(offset))
|
|
609
|
+
|
|
610
|
+
except IndexError:
|
|
611
|
+
|
|
612
|
+
return False
|
|
613
|
+
else:
|
|
614
|
+
if self._gameObject.body:
|
|
615
|
+
if other._gameObject.body:
|
|
616
|
+
return self._gameObject.body.collide(other._gameObject.body)
|
|
617
|
+
elif other._gameObject.tiledmap_bodies:
|
|
618
|
+
return other._gameObject.tiledmap_bodies.collide(
|
|
619
|
+
self._gameObject.body
|
|
620
|
+
)
|
|
621
|
+
|
|
622
|
+
elif self._gameObject.tiledmap_bodies:
|
|
623
|
+
if other._gameObject.body:
|
|
624
|
+
return self._gameObject.tiledmap_bodies.collide(
|
|
625
|
+
other._gameObject.body
|
|
626
|
+
)
|
|
627
|
+
elif other._gameObject.tiledmap_bodies:
|
|
628
|
+
return self._gameObject.tiledmap_bodies.collide(
|
|
629
|
+
other._gameObject.tiledmap_bodies
|
|
630
|
+
)
|
|
631
|
+
else:
|
|
632
|
+
mask1 = pygame.mask.from_surface(self._gameObject.sprite.image)
|
|
633
|
+
mask2 = pygame.mask.from_surface(other._gameObject.sprite.image)
|
|
634
|
+
offset = (
|
|
635
|
+
self._gameObject.pos
|
|
636
|
+
- other._gameObject.pos
|
|
637
|
+
+ vec(
|
|
638
|
+
self._gameObject.sprite.width // 2,
|
|
639
|
+
self._gameObject.sprite.height // 2,
|
|
640
|
+
)
|
|
641
|
+
- vec(
|
|
642
|
+
other._gameObject.sprite.width // 2,
|
|
643
|
+
other._gameObject.sprite.height // 2,
|
|
644
|
+
)
|
|
645
|
+
)
|
|
646
|
+
# 对offset进行了重新处理,防止mask左右颠倒
|
|
647
|
+
offset = [int(i) for i in offset]
|
|
648
|
+
offset[0] = (
|
|
649
|
+
self._gameObject.sprite.width
|
|
650
|
+
- other._gameObject.sprite.width
|
|
651
|
+
- offset[0]
|
|
652
|
+
)
|
|
653
|
+
|
|
654
|
+
return bool(mask1.overlap(mask2, offset))
|
|
655
|
+
elif not self._gameObject.sprite:
|
|
656
|
+
if isinstance(other, tuple) or isinstance(other, vec):
|
|
657
|
+
if self._gameObject.body:
|
|
658
|
+
return self._gameObject.body.point_query(other)
|
|
659
|
+
elif self._gameObject.tiledmap_bodies:
|
|
660
|
+
return self._gameObject.tiledmap_bodies.point_query(other)
|
|
661
|
+
else:
|
|
662
|
+
return False
|
|
663
|
+
else:
|
|
664
|
+
if self._gameObject.body:
|
|
665
|
+
if other._gameObject.body:
|
|
666
|
+
return self._gameObject.body.collide(other._gameObject.body)
|
|
667
|
+
elif other._gameObject.tiledmap_bodies:
|
|
668
|
+
return other._gameObject.tiledmap_bodies.collide(
|
|
669
|
+
self._gameObject.body
|
|
670
|
+
)
|
|
671
|
+
else:
|
|
672
|
+
return False
|
|
673
|
+
elif self._gameObject.tiledmap_bodies:
|
|
674
|
+
if other._gameObject.body:
|
|
675
|
+
return self._gameObject.tiledmap_bodies.collide(
|
|
676
|
+
other._gameObject.body
|
|
677
|
+
)
|
|
678
|
+
elif other._gameObject.tiledmap_bodies:
|
|
679
|
+
return self._gameObject.tiledmap_bodies.collide(
|
|
680
|
+
other._gameObject.tiledmap_bodies
|
|
681
|
+
)
|
|
682
|
+
else:
|
|
683
|
+
return False
|
|
684
|
+
else:
|
|
685
|
+
return False
|
|
686
|
+
|
|
687
|
+
else:
|
|
688
|
+
return False
|
|
689
|
+
|
|
690
|
+
def separate(self, other):
|
|
691
|
+
# 不要检测是否与get_mouse_pos()函数的分离,因为只能检测和固定点之间的分离
|
|
692
|
+
if other not in self.collision_dict:
|
|
693
|
+
self.collision_dict[other] = False
|
|
694
|
+
if not self.collide(other) and self.collision_dict[other]:
|
|
695
|
+
self.collision_dict[other] = False
|
|
696
|
+
return True
|
|
697
|
+
else:
|
|
698
|
+
if self.collide(other):
|
|
699
|
+
self.collision_dict[other] = True
|
|
700
|
+
else:
|
|
701
|
+
self.collision_dict[other] = False
|
|
702
|
+
return False
|
|
703
|
+
|
|
704
|
+
def distance(self, other):
|
|
705
|
+
if isinstance(other, tuple):
|
|
706
|
+
return self._gameObject.pos.distance_to(other)
|
|
707
|
+
else:
|
|
708
|
+
return self._gameObject.pos.distance_to(other._gameObject.pos)
|
|
709
|
+
|
|
710
|
+
def say(self, text=None, textColor=(0, 0, 0)):
|
|
711
|
+
if not self._dialogBox:
|
|
712
|
+
self._dialogBox = DialogBox(self, self.DialogBox_img, self.DialogBox_font)
|
|
713
|
+
if text:
|
|
714
|
+
self._dialogBox.show()
|
|
715
|
+
self._dialogBox.say(text, textColor)
|
|
716
|
+
else:
|
|
717
|
+
self._dialogBox.hide()
|
|
718
|
+
if IS_UPDATED:
|
|
719
|
+
update()
|
|
720
|
+
|
|
721
|
+
def kill(self):
|
|
722
|
+
self._gameObject.kill()
|
|
723
|
+
if self._dialogBox:
|
|
724
|
+
self._dialogBox.kill()
|
|
725
|
+
|
|
726
|
+
def apply_force(self, x, *y):
|
|
727
|
+
if self._gameObject.body:
|
|
728
|
+
if y:
|
|
729
|
+
self._gameObject.body.apply_impulse_at_local_point((x, *y))
|
|
730
|
+
else:
|
|
731
|
+
self._gameObject.body.apply_impulse_at_local_point(x)
|
|
732
|
+
elif self._gameObject.tiledmap_bodies:
|
|
733
|
+
if y:
|
|
734
|
+
self._gameObject.tiledmap_bodies.apply_impulse_at_local_point((x, *y))
|
|
735
|
+
else:
|
|
736
|
+
self._gameObject.tiledmap_bodies.apply_impulse_at_local_point(x)
|
|
737
|
+
|
|
738
|
+
@property
|
|
739
|
+
def elasticity(self):
|
|
740
|
+
if self._gameObject.body:
|
|
741
|
+
return self._gameObject.body.elasticity
|
|
742
|
+
elif self._gameObject.tiledmap_bodies:
|
|
743
|
+
return self._gameObject.tiledmap_bodies.elasticity
|
|
744
|
+
|
|
745
|
+
@elasticity.setter
|
|
746
|
+
def elasticity(self, e):
|
|
747
|
+
if self._gameObject.body:
|
|
748
|
+
self._gameObject.body.elasticity = e
|
|
749
|
+
elif self._gameObject.tiledmap_bodies:
|
|
750
|
+
self._gameObject.tiledmap_bodies.elasticity = e
|
|
751
|
+
|
|
752
|
+
@property
|
|
753
|
+
def friction(self):
|
|
754
|
+
if self._gameObject.body:
|
|
755
|
+
return self._gameObject.body.friction
|
|
756
|
+
elif self._gameObject.tiledmap_bodies:
|
|
757
|
+
return self._gameObject.tiledmap_bodies.friction
|
|
758
|
+
|
|
759
|
+
@friction.setter
|
|
760
|
+
def friction(self, f):
|
|
761
|
+
if self._gameObject.body:
|
|
762
|
+
self._gameObject.body.friction = f
|
|
763
|
+
elif self._gameObject.tiledmap_bodies:
|
|
764
|
+
self._gameObject.tiledmap_bodies.friction = f
|
|
765
|
+
|
|
766
|
+
@property
|
|
767
|
+
def mass(self):
|
|
768
|
+
if self._gameObject.body:
|
|
769
|
+
return self._gameObject.body.mass
|
|
770
|
+
elif self._gameObject.tiledmap_bodies:
|
|
771
|
+
return self._gameObject.tiledmap_bodies.mass
|
|
772
|
+
|
|
773
|
+
@mass.setter
|
|
774
|
+
def mass(self, m):
|
|
775
|
+
if self._gameObject.body:
|
|
776
|
+
self._gameObject.body.mass = m
|
|
777
|
+
elif self._gameObject.tiledmap_bodies:
|
|
778
|
+
self._gameObject.tiledmap_bodies.mass = m
|
|
779
|
+
|
|
780
|
+
def body_scale(self, scalex, scaley):
|
|
781
|
+
if "radius" in self.__dict__:
|
|
782
|
+
if scaley:
|
|
783
|
+
print("圆形无法进行不同方向的拉伸")
|
|
784
|
+
self._gameObject.body.shape.unsafe_set_radius(int(self.radius * scalex))
|
|
785
|
+
elif "vertices" in self.__dict__:
|
|
786
|
+
if scaley:
|
|
787
|
+
self._gameObject.body.set_vertices(
|
|
788
|
+
self.vertices, transform=pymunk.Transform(a=scalex, d=scaley)
|
|
789
|
+
)
|
|
790
|
+
else:
|
|
791
|
+
self._gameObject.body.set_vertices(
|
|
792
|
+
self.vertices, transform=pymunk.Transform(a=scalex, d=scalex)
|
|
793
|
+
)
|
|
794
|
+
elif self._gameObject.tiledmap_bodies:
|
|
795
|
+
if scaley:
|
|
796
|
+
self._gameObject.tiledmap_bodies.set_vertices(scalex, scaley)
|
|
797
|
+
else:
|
|
798
|
+
self._gameObject.tiledmap_bodies.set_vertices(scalex, scalex)
|
|
799
|
+
else:
|
|
800
|
+
raise NotImplementedError
|
|
801
|
+
|
|
802
|
+
def _update(self):
|
|
803
|
+
# 私有方法, 不要重载!!
|
|
804
|
+
self._just_released = False
|
|
805
|
+
if self.angular_velocity:
|
|
806
|
+
self.dir = self.dir.rotate(self.angular_velocity)
|
|
807
|
+
|
|
808
|
+
def update(self):
|
|
809
|
+
# 允许重载的方法
|
|
810
|
+
pass
|
|
811
|
+
|
|
812
|
+
|
|
813
|
+
class Character(NewGameObject):
|
|
814
|
+
"""
|
|
815
|
+
允许通过代码控制其运动的类
|
|
816
|
+
"""
|
|
817
|
+
|
|
818
|
+
def __init__(self, imgs=None, size=None):
|
|
819
|
+
# 可以通过给出一张图片或图片列表或来实现人物创建
|
|
820
|
+
NewGameObject.__init__(
|
|
821
|
+
self, imgs=imgs, size=size, body_type="DYNAMIC", sensor=False
|
|
822
|
+
)
|
|
823
|
+
|
|
824
|
+
|
|
825
|
+
class Sensor(NewGameObject):
|
|
826
|
+
def __init__(self, imgs=None, size=None):
|
|
827
|
+
# 可以通过给出一张图片或图片列表或来实现人物创建
|
|
828
|
+
NewGameObject.__init__(
|
|
829
|
+
self, imgs=imgs, size=size, body_type="KINEMATIC", sensor=True
|
|
830
|
+
)
|
|
831
|
+
|
|
832
|
+
|
|
833
|
+
class Wall(NewGameObject):
|
|
834
|
+
"""
|
|
835
|
+
墙壁,无法运动的物体
|
|
836
|
+
"""
|
|
837
|
+
|
|
838
|
+
def __init__(self, imgs=None, size=None):
|
|
839
|
+
# 可以通过给出一张图片或图片列表或来实现人物创建
|
|
840
|
+
NewGameObject.__init__(
|
|
841
|
+
self, imgs=imgs, size=size, body_type="STATIC", sensor=False
|
|
842
|
+
)
|
|
843
|
+
self._velocity = vec(0, 0)
|
|
844
|
+
|
|
845
|
+
@property
|
|
846
|
+
def velocity(self):
|
|
847
|
+
return self._velocity
|
|
848
|
+
|
|
849
|
+
@velocity.setter
|
|
850
|
+
def velocity(self, v):
|
|
851
|
+
self._velocity = v
|
|
852
|
+
|
|
853
|
+
def _update(self):
|
|
854
|
+
super()._update()
|
|
855
|
+
self.pos += self._velocity
|
|
856
|
+
|
|
857
|
+
|
|
858
|
+
class Mouse(Character):
|
|
859
|
+
def __init__(self, imgs=None):
|
|
860
|
+
Character.__init__(self, imgs)
|
|
861
|
+
if imgs:
|
|
862
|
+
set_mouse_visible(False)
|
|
863
|
+
|
|
864
|
+
def body_scale(self, scalex, scaley=None):
|
|
865
|
+
pass
|
|
866
|
+
|
|
867
|
+
def get_pos(self):
|
|
868
|
+
return get_mouse_pos()
|
|
869
|
+
|
|
870
|
+
def get_rel(self):
|
|
871
|
+
return get_mouse_rel()
|
|
872
|
+
|
|
873
|
+
def get_clicked(self):
|
|
874
|
+
return get_mouse_clicked()
|
|
875
|
+
|
|
876
|
+
def get_just_clicked(self):
|
|
877
|
+
return get_mouse_just_clicked()
|
|
878
|
+
|
|
879
|
+
def get_just_released(self):
|
|
880
|
+
return get_mouse_just_released()
|
|
881
|
+
|
|
882
|
+
def update(self):
|
|
883
|
+
self.goto(get_mouse_pos())
|
|
884
|
+
|
|
885
|
+
|
|
886
|
+
def load_image(img):
|
|
887
|
+
return pygame.image.load(img)
|
|
888
|
+
|
|
889
|
+
|
|
890
|
+
def bgpic(img):
|
|
891
|
+
if isinstance(img, str):
|
|
892
|
+
bg = Character(img)
|
|
893
|
+
else:
|
|
894
|
+
bg = img
|
|
895
|
+
if isinstance(bg, TiledMap):
|
|
896
|
+
global_var.CAMERA = Camera((bg.width, bg.height))
|
|
897
|
+
else:
|
|
898
|
+
global_var.CAMERA = Camera(
|
|
899
|
+
(bg._gameObject.sprite.width, bg._gameObject.sprite.height)
|
|
900
|
+
)
|