def get_standart(cls, w: float, h: float, n: int, m: int):
obs = [
PolyLine(
[Vec2(0, 0), Vec2(w, 0),
Vec2(w, h), Vec2(0, h)],
enclosed=True),
PolyLine([
Vec2(-10, -10),
Vec2(w + 10, -10),
Vec2(10 + w, 10 + h),
Vec2(-10, 10 + h)
],
enclosed=True)
]
w1, h1 = w / n, h / m
r = min(w1, h1) * 0.3
for i in range(n):
for j in range(m):
x = w1 / 2 + w1 * i + np.random.uniform(-0.1, 0.1) * w1
y = h1 / 2 + h1 * j + np.random.uniform(-0.1, 0.1) * h1
if (i == 0 and j == 0):
pos_1 = Vec2(x, y)
continue
if (i == (n - 1) and j == (m - 1)):
pos_2 = Vec2(x, y)
continue
ri = r * np.random.uniform(0.9, 1.1)
nn = np.random.randint(3, 6)
dx = w1 * np.random.uniform(0.02, 0.1)
dy = h1 * np.random.uniform(0.02, 0.1)
obs.append(rnd_polygon(x, y, ri, nn, dx, dy))
return cls(obs, pos_1, pos_2)
def test_constructor6():
m = Mat2([Vec2(1, 2), Vec2(3, 4)])
assert m is not None
assert m.m11 == approx(1)
assert m.m12 == approx(2)
assert m.m21 == approx(3)
assert m.m22 == approx(4)
def get_vis_polygon(self, pos: Vec2, r: float, alpha: float,
thetta: float) -> PolyLine:
n_rays = 10
angles = np.linspace(-thetta + alpha, thetta + alpha, n_rays)
p2s = [
Vec2(r, 0).rotate(angle, degrees=True).add(pos) for angle in angles
]
ps = [pos.copy()]
for p2 in p2s:
p1, pi = self.intersected_segment(pos, p2)
ps.append(pi)
return PolyLine(ps)
def test_polyline_get_Iz():
pl = PolyLine([(0, 3), (10, 3), (10, 0), (0, 0)], copy_data=True)
for angle in np.random.uniform(-180, 180, 1000):
pl1 = pl.add_vec(Vec2(10, 20))
plt = pl1.transform(Mat2.from_angle(angle, True))
cm = plt.get_center_mass()
assert plt.get_Iz(cm) == approx((10**2 + 3**2) / 12)
def rnd_polygon(x, y, r, n, dx, dy, angle0=None):
v = Vec2(r, 0)
v.rotate_(angle0 if angle0 else np.random.uniform(0, 360), degrees=True)
vs = [
v.rotate(i * (360 / n), degrees=True) + rnd_vec(x, y, dx, dy)
for i in range(n)
]
return PolyLine(vs, enclosed=True)
def __init__(self,
name,
pos,
alpha,
brain_foo,
theta,
r_vis,
v_max,
d_alpha_max,
n_rays,
dmg,
round_vel,
hp,
shot_delta,
d_theta_max,
color,
draw_stuff=True):
self.name = name
self.pos = _convert(pos)
self.alpha = alpha
self.brain_foo = brain_foo
self.theta = theta
self.d_theta_max = d_theta_max
self.r_vis = r_vis
self.v_max = v_max
self.d_alpha_max = d_alpha_max
self.n_rays = n_rays
self.s_vis = pi * r_vis**2 / 2
self.polygon_local = PolyLine(
[Vec2(2, 0), Vec2(-1, -1), Vec2(-1, 1)], enclosed=True)
self.dmg = dmg
self.round_vel = round_vel
self.hp = hp
self.hp0 = hp
self.time = 0
self.time_last_shot = -shot_delta
self.shot_delta = shot_delta
self.vis_polygon = None
self.vis_line = None
self.intersected = None
self.set_alpha(alpha)
self.set_theta(theta)
self.color = color
self.draw_stuff = draw_stuff
def shoot(self):
if not self.can_shoot:
return None
angle = np.random.normal(self.alpha, self.theta / 3)
vel = Vec2(self.round_vel, 0).rotate(angle, degrees=True)
self.time_last_shot = self.time
v = 3 * vel.norm() + self.pos
return Round(v, vel, self.dmg)
def set_theta(self, theta):
self.theta = theta
self.r_vis = sqrt(self.s_vis / theta * 180 / pi)
self.angles = np.linspace(-self.theta, self.theta, self.n_rays)
self.rays = [
Vec2(self.r_vis, 0).rotate(angle, degrees=True)
for angle in self.angles
]
def test_mul2():
for angle, x, y in np.random.uniform(-180, 180, (1000, 3)):
m = Mat2.from_angle(angle, 1)
v = Vec2(x, y).norm()
v1 = m * v
assert v.angle_to(v1, 1) == approx(-angle)
v2 = m._1 * v1
assert v2 == v
v3 = m._1 * v
assert v.angle_to(v3, 1) == approx(angle)
def get_move_segment(self, vel_portion: float, dalpha_portion: float,
dt: float):
if abs(vel_portion) < 1e-8:
return None
vel_portion = 1 if vel_portion > 1 else -1 if vel_portion < -1 else vel_portion
dalpha_portion = 1 if dalpha_portion > 1 else -1 if dalpha_portion < -1 else dalpha_portion
vel = Vec2(self.v_max * vel_portion * dt, 0).rotate(
self.alpha + dalpha_portion * self.d_alpha_max * dt / 2,
degrees=True)
return (self.pos.copy(), self.pos + vel)
def add_vis_signals(self, unit: Unit, signals: dict):
unit.vis_polygon = self.scene.get_vis_polygon(unit.pos, unit.r_vis,
unit.alpha, unit.theta)
signals['enemies'] = []
signals['rounds'] = []
for u in self.units:
if u is not unit:
upos = u.pos
if unit.vis_polygon.is_in(upos):
unit.vis_line = upos - unit.pos
unit_ox = unit.to_world(Vec2(1, 0), is_dir_vector=True)
angle = unit_ox.angle_to(unit.vis_line, degrees=True)
signals['enemies'].append((angle, unit.vis_line.len()))
else:
unit.vis_line = None
for u in self.rounds:
upos = u.pos
if unit.vis_polygon.is_in(upos):
vis_line = upos - unit.pos
unit_ox = unit.to_world(Vec2(1, 0), is_dir_vector=True)
angle = unit_ox.angle_to(vis_line, degrees=True)
signals['rounds'].append((angle, vis_line.len()))
def to_vec(self, x, y):
"""Метод перевода пиксельных координат в координаты имитационной модели
Arguments:
x {int} -- пиксельная координата по оси абсцисс
y {int} -- пиксельная координата по оси ординат
Returns:
Vec2d -- соответствующая координата имитационной модели
"""
masht_x = self.display_width / (self.v1.x - self.v0.x)
masht_y = self.display_height / (self.v1.y - self.v0.y)
res = Vec2(self.v0.x + x / masht_x, self.v1.y - y / masht_y)
return res
def test_is_in_polygon():
assert is_in_polygon(Vec2(0.1, 0.1), [Vec2(0, 0), Vec2(1, 0), Vec2(0, 1)])
def test_polyline_area4():
pl = PolyLine([(1, 2), (11, 2), (10, 0), (0, 0)], copy_data=True)
for angle in np.random.uniform(-180, 180, 1000):
pl1 = pl.add_vec(Vec2(10, 20))
plt = pl1.transform(Mat2.from_angle(angle, True))
assert plt.get_area() == approx(20)
def vp(x, y):
return Vec2(x, y) if np.random.random() < 0.5 else (x, y)
def test_add2():
assert Vec2(2,3) + (3,2) == Vec2(5,5)
def test_Rect_union3():
r1 = Rect(0, 0, 3, 3)
assert r1 + Vec2(-1, -3) == Rect(-1, -3, 3, 3)
def test_add7():
assert (3,2) + Vec2(2,3) == Vec2(5,5)
def test_PolyLine_is_in2():
pl = PolyLine([(-10, 1), (1, 0), (-10, -1)], copy_data=True)
assert pl.is_in(Vec2(0, 0))
def test_add4():
import numpy as np
assert Vec2(2,3) + np.array([3,2]) == Vec2(5,5)
def test_unpack4():
def foo(x, y):
return x, y
x,y = foo(**Vec2(-7,8))
assert x == -7
assert y == 8
def test_unpack1():
x, y = Vec2(-7,8)
assert x == -7
assert y == 8
def test_add5():
assert Vec2(2,3) + 3 == Vec2(5,6)
def test_add9():
assert 3 + Vec2(2,3) == Vec2(5,6)
def test_add8():
import numpy as np
assert Vec2(5,5) == np.array([3,2]) + Vec2(2,3).as_np()
def test_rect_is_in():
r = Rect(0, 0, 3, 2)
assert r.is_in(Vec2(1, 1))
def test_PolyLine_is_in():
pl = PolyLine([(0, 0), (1, 0), (0, 1)], copy_data=True)
assert pl.is_in(Vec2(0.5, 0.1))
def test_add3():
assert Vec2(2,3) + [3,2] == Vec2(5,5)
def test_add10():
assert [33,22] + Vec2(2,3) == Vec2(35,25)
def test_add6():
import numpy as np
assert [33,22] + Vec2(2,3) == Vec2(35,25)
