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)