def get_angle():
vgx = math.cos(goal.angle)
vgy = math.sin(goal.angle)
vsx = goal.x - me.x
vsy = goal.y - me.y
angle = geometry.get_angle(vgx, vgy, vsx, vsy)
return angle if angle < math.pi / 2. else math.pi - angle
def shell_damage(shell, tank):
'''return health damage'''
pessimistic_tank = copy(tank)
pessimistic_tank.width *= 1.1
pessimistic_tank.height *= 1.1
front, right, back, left = utils.get_borders(pessimistic_tank)
# front, right, back, left = utils.get_borders(tank)
next_shell_x = shell.x + shell.speedX * 1000.
next_shell_y = shell.y + shell.speedY * 1000.
borders_with_intersections = [(b,
geometry.intervals_intersection(
b[0], b[1], b[2], b[3], shell.x, shell.y, next_shell_x, next_shell_y)) for
b in front, right, back, left]
borders_with_intersections = filter(lambda bi: bi[1] is not None, borders_with_intersections)
if not borders_with_intersections:
return 0.
border, intersection_point = min(borders_with_intersections,
key=lambda b: math.hypot(b[1][0] - shell.x, b[1][1] - shell.y))
angle = geometry.get_angle(border[0] - border[2], border[1] - border[3], shell.speedX, shell.speedY)
if angle > math.pi / 2:
angle = math.pi - angle
angle = math.pi / 2. - angle
r1 = math.hypot(border[0] - intersection_point[0], border[1] - intersection_point[1])
r2 = math.hypot(border[2] - intersection_point[0], border[3] - intersection_point[1])
r = r1 + r2
dist_factor = (r - 2. * min(r1, r2)) / r
return coeff_by_angle(shell, geometry.rad_to_degree(angle)) * coeff_by_dist_factor(dist_factor)
def do_stop(env):
speed_abs = geometry.vector_abs(env.me.speed_x, env.me.speed_y)
angle = geometry.get_angle(
math.cos(env.me.angle), math.sin(env.me.angle),
env.me.speed_x, env.me.speed_y)
if abs(geometry.rad_to_degree(angle)) < 90:
env.move.turn = angle
env.move.speed_up = -min(1., speed_abs / env.game.hockeyist_speed_down_factor)
else:
env.move.turn = -angle
env.move.speed_up = min(1., speed_abs / env.game.hockeyist_speed_up_factor)
def count_damage(goal, enemy):
if abs(geometry.get_angle(
enemy.x - me.x, enemy.y - me.y, enemy.x - goal.x, enemy.y - goal.y)) < math.pi / 2:
x, y = goal.x, goal.y
else:
# FIXME more correct here cause me and goal is not equivalent here
x, y = geometry.get_nearest_point(me.x, me.y, goal.x, goal.y, enemy.x, enemy.y)
goal_damage = damage_probability(enemy.x, enemy.y, x, y)
for e in enemies + teammates:
if utils.is_teammate(e, enemy):
continue
if damage_probability(enemy.x, enemy.y, e.x, e.y) > goal_damage:
return 0.
return goal_damage
def bulge_coords(self, x0, y0, x1, y1, bulge, tol_deg=20):
# global Zero
bcoords = []
if bulge < 0.0:
sign = 1
bulge = abs(bulge)
# bcoords.append([x0,y0,x1,y1])
# return bcoords
else:
sign = -1
dx = x1 - x0
dy = y1 - y0
c = sqrt(dx**2 + dy**2)
alpha = 2.0 * (atan(bulge))
R = c / (2 * sin(alpha))
L = R * cos(alpha)
steps = ceil(2 * alpha / radians(tol_deg))
if abs(c) < Zero:
phi = 0
bcoords.append([x0, y0, x1, y1])
return bcoords
seg_sin = dy / c
seg_cos = dx / c
phi = get_angle(seg_sin, seg_cos)
d_theta = 2 * alpha / steps
theta = alpha - d_theta
xa = x0
ya = y0
for i in range(1, int(steps)):
xp = c / 2 - R * sin(theta)
yp = R * cos(theta) - L
xb, yb = transform(xp, yp * sign, radians(phi))
xb = xb + x0
yb = yb + y0
bcoords.append([xa, ya, xb, yb])
xa = xb
ya = yb
theta = theta - d_theta
bcoords.append([xa, ya, x1, y1])
return bcoords
def bulge_coords(self, x0, y0, x1, y1, bulge, tol_deg=20):
# global Zero
bcoords = []
if bulge < 0.0:
sign = 1
bulge = abs(bulge)
# bcoords.append([x0,y0,x1,y1])
# return bcoords
else:
sign = -1
dx = x1 - x0
dy = y1 - y0
c = sqrt(dx ** 2 + dy ** 2)
alpha = 2.0 * (atan(bulge))
R = c / (2 * sin(alpha))
L = R * cos(alpha)
steps = ceil(2 * alpha / radians(tol_deg))
if abs(c) < Zero:
phi = 0
bcoords.append([x0, y0, x1, y1])
return bcoords
seg_sin = dy / c
seg_cos = dx / c
phi = get_angle(seg_sin, seg_cos)
d_theta = 2 * alpha / steps
theta = alpha - d_theta
xa = x0
ya = y0
for i in range(1, int(steps)):
xp = c / 2 - R * sin(theta)
yp = R * cos(theta) - L
xb, yb = transform(xp, yp * sign, radians(phi))
xb = xb + x0
yb = yb + y0
bcoords.append([xa, ya, xb, yb])
xa = xb
ya = yb
theta = theta - d_theta
bcoords.append([xa, ya, x1, y1])
return bcoords
def get_attract_field(self, mytank, obj, r, s, a):
d = get_center_distance(mytank, obj)
theta = get_angle(mytank, obj)
dx = 0
dy = 0
if d > (s + r):
dx = a * s * cos(theta)
dy = a * s * sin(theta)
elif d >= r: #and d<=s+r
dx = a * (d - r) * cos(theta)
dy = a * (d - r) * sin(theta)
#else dx = 0 dy = 0
vector = Vector()
vector.set_x_and_y(dx, dy)
return vector
def get_attract_field(self, mytank, obj, r, s, a): d = get_center_distance(mytank, obj) theta = get_angle(mytank, obj) dx = 0; dy = 0 if d > (s+r): dx = a * s * cos(theta) dy = a * s * sin(theta) elif d >= r: #and d<=s+r dx = a * (d-r) * cos(theta) dy = a * (d-r) * sin(theta) #else dx = 0 dy = 0 vector = Vector() vector.set_x_and_y(dx, dy) return vector
def get_repulse_field(self, mytank, obj, r, s, b):
d = get_center_distance(mytank, obj)
theta = get_angle(mytank, obj)
dx = 0
dy = 0
if d < r:
dx = -sign(cos(theta)) * float('inf')
dy = -sign(sin(theta)) * float('inf')
elif d >= r and d <= s + r:
dx = -b * (s + r - d) * cos(theta)
dy = -b * (s + r - d) * sin(theta)
#else dx, dy = 0
vector = Vector()
vector.set_x_and_y(dx, dy)
return vector
def get_repulse_field(self, mytank, obj, r, s, b):
d = get_center_distance(mytank, obj)
theta = get_angle(mytank, obj)
dx = 0
dy = 0
if d < r:
dx = -sign(cos(theta))*float('inf')
dy = -sign(sin(theta))*float('inf')
elif d >= r and d <= s+r:
dx = -b * (s + r - d) * cos(theta)
dy = -b * (s + r - d) * sin(theta)
#else dx, dy = 0
vector = Vector()
vector.set_x_and_y(dx, dy)
return vector
def do(self, env):
speed_abs = geometry.vector_abs(env.me.speed_x, env.me.speed_y)
if speed_abs < 0.0001:
self.done = True
print (
'tick = ', env.world.tick,
'Stop done',
'x = ', env.me.x,
'y = ', env.me.y,
'speed abs = ', speed_abs
)
return
angle = geometry.get_angle(
math.cos(env.me.angle), math.sin(env.me.angle),
env.me.speed_x, env.me.speed_y)
if abs(geometry.rad_to_degree(angle)) < 90:
env.move.turn = angle
env.move.speed_up = -min(1., speed_abs / env.game.hockeyist_speed_down_factor)
else:
env.move.turn = -angle
env.move.speed_up = min(1., speed_abs / env.game.hockeyist_speed_up_factor)
def line_arc_fit(lastx, lasty, lastz, x1, y1, z1, nextx, nexty, nextz,
FLAG_arc, code, R_last, x_center_last, y_center_last,
FLAG_line, accuracy, seg_arc):
"""
Line fit and arc fit (curve fit)
"""
# print lastx, lasty, lastz, x1, y1, z1, nextx, nexty, nextz
# print FLAG_arc, code, R_last, x_center_last, y_center_last, FLAG_line, accuracy
dx_a = x1 - lastx
dy_a = y1 - lasty
dz_a = z1 - lastz
dx_c = nextx - lastx
dy_c = nexty - lasty
dz_c = nextz - lastz
if abs(dx_a) > Zero:
line_t = dx_c / dx_a
elif abs(dy_a) > Zero:
line_t = dy_c / dy_a
elif abs(dz_a) > Zero:
line_t = dz_c / dz_a
else:
line_t = 0
ex = dx_c - dx_a * line_t
ey = dy_c - dy_a * line_t
ez = dz_c - dz_a * line_t
et = sqrt(ex * ex + ey * ey + ez * ez)
L_a = dx_a * dx_a + dy_a * dy_a + dz_a * dz_a
L_c = dx_c * dx_c + dy_c * dy_c + dz_c * dz_c
FLAG_arc_last = FLAG_arc
FLAG_arc = 0
FLAG_line_last = FLAG_line
if et > accuracy or (L_a >= L_c) or FLAG_arc_last == 1:
FLAG_line = 0
else:
FLAG_line = 1
code = "G1"
###############
# Arc Fitting #
###############
arc_fit = 1
if (FLAG_line != 1 and FLAG_line_last != 1 and line_t != 0 and arc_fit):
dx_b = nextx - x1
dy_b = nexty - y1
dz_b = nextz - z1
L_b = dx_b * dx_b + dy_b * dy_b + dz_b * dz_b
if abs(dx_a) > Zero and abs(dx_b) > Zero:
ma = dy_a / dx_a
mb = dy_b / dx_b
if abs(mb - ma) > Zero and (abs(ma) > Zero or abs(mb) > Zero):
x_center = (ma * mb * (lasty - nexty) + mb *
(lastx + x1) - ma * (x1 + nextx)) / (2 * (mb - ma))
if abs(ma) > Zero:
y_center = -1 / ma * (x_center -
(lastx + x1) / 2) + (lasty + y1) / 2
elif abs(mb) > Zero:
y_center = -1 / mb * (x_center -
(x1 + nextx) / 2) + (y1 + nexty) / 2
R_arc = hypot(x1 - x_center, y1 - y_center)
cord_a = hypot(dx_a, dy_a)
cord_b = hypot(dx_b, dy_b)
cord_limit = 2 * R_arc * sin(radians(seg_arc))
try:
sagitta_a = R_arc - sqrt(R_arc**2 - cord_a**2)
sagitta_b = R_arc - sqrt(R_arc**2 - cord_b**2)
sagitta_min = min(sagitta_a, sagitta_b)
except:
sagitta_min = 0.0
SKIP = 0
if FLAG_arc_last == 1:
if (abs(R_last - R_arc) > Zero
or abs(x_center_last - x_center) > Zero
or abs(y_center_last - y_center) > Zero):
SKIP = 1
if (max(cord_a, cord_b) <= cord_limit and abs(ez) <= Zero
and L_a**2 + L_b**2 < L_c**2
and cord_a / cord_b >= 1.0 / 1.5
and cord_a / cord_b <= 1.5 and sagitta_min > Zero
and SKIP == 0):
seg_sin_test = (y1 - lasty) / cord_a
seg_cos_test = -(x1 - lastx) / cord_a
phi_test = get_angle(seg_sin_test, seg_cos_test)
X_test, Y_test = transform(x_center - lastx,
y_center - lasty,
radians(phi_test))
code = 'G2' if Y_test > 0.0 else 'G3'
x_center_last = x_center
y_center_last = y_center
R_last = R_arc
FLAG_arc = 1
WRITE = 0
if FLAG_line == 0 and FLAG_arc == 0:
WRITE = 1
return code, FLAG_arc, R_last, x_center_last, y_center_last, WRITE, FLAG_line
def line_arc_fit(lastx, lasty, lastz, x1, y1, z1, nextx, nexty, nextz, FLAG_arc, code,
R_last, x_center_last, y_center_last, FLAG_line, accuracy, seg_arc):
"""
Line fit and arc fit (curve fit)
"""
# print lastx, lasty, lastz, x1, y1, z1, nextx, nexty, nextz
# print FLAG_arc, code, R_last, x_center_last, y_center_last, FLAG_line, accuracy
dx_a = x1 - lastx
dy_a = y1 - lasty
dz_a = z1 - lastz
dx_c = nextx - lastx
dy_c = nexty - lasty
dz_c = nextz - lastz
if abs(dx_a) > Zero:
line_t = dx_c / dx_a
elif abs(dy_a) > Zero:
line_t = dy_c / dy_a
elif abs(dz_a) > Zero:
line_t = dz_c / dz_a
else:
line_t = 0
ex = dx_c - dx_a * line_t
ey = dy_c - dy_a * line_t
ez = dz_c - dz_a * line_t
et = sqrt(ex * ex + ey * ey + ez * ez)
L_a = dx_a * dx_a + dy_a * dy_a + dz_a * dz_a
L_c = dx_c * dx_c + dy_c * dy_c + dz_c * dz_c
FLAG_arc_last = FLAG_arc
FLAG_arc = 0
FLAG_line_last = FLAG_line
if et > accuracy or (L_a >= L_c) or FLAG_arc_last == 1:
FLAG_line = 0
else:
FLAG_line = 1
code = "G1"
###############
# Arc Fitting #
###############
arc_fit = 1
if (FLAG_line != 1 and FLAG_line_last != 1 and line_t != 0 and arc_fit):
dx_b = nextx - x1
dy_b = nexty - y1
dz_b = nextz - z1
L_b = dx_b * dx_b + dy_b * dy_b + dz_b * dz_b
if abs(dx_a) > Zero and abs(dx_b) > Zero:
ma = dy_a / dx_a
mb = dy_b / dx_b
if abs(mb - ma) > Zero and (abs(ma) > Zero or abs(mb) > Zero):
x_center = (ma * mb * (lasty - nexty) + mb * (lastx + x1) - ma * (x1 + nextx)) / (2 * (mb - ma))
if abs(ma) > Zero:
y_center = -1 / ma * (x_center - (lastx + x1) / 2) + (lasty + y1) / 2
elif abs(mb) > Zero:
y_center = -1 / mb * (x_center - (x1 + nextx) / 2) + (y1 + nexty) / 2
R_arc = hypot(x1 - x_center, y1 - y_center)
cord_a = hypot(dx_a, dy_a)
cord_b = hypot(dx_b, dy_b)
cord_limit = 2 * R_arc * sin(radians(seg_arc))
try:
sagitta_a = R_arc - sqrt(R_arc ** 2 - cord_a ** 2)
sagitta_b = R_arc - sqrt(R_arc ** 2 - cord_b ** 2)
sagitta_min = min(sagitta_a, sagitta_b)
except:
sagitta_min = 0.0
SKIP = 0
if FLAG_arc_last == 1:
if (
abs(R_last - R_arc) > Zero or
abs(x_center_last - x_center) > Zero or
abs(y_center_last - y_center) > Zero):
SKIP = 1
if (max(cord_a, cord_b) <= cord_limit and
abs(ez) <= Zero and L_a ** 2 + L_b ** 2 < L_c ** 2 and
cord_a / cord_b >= 1.0 / 1.5 and cord_a / cord_b <= 1.5 and
sagitta_min > Zero and SKIP == 0):
seg_sin_test = (y1 - lasty) / cord_a
seg_cos_test = -(x1 - lastx) / cord_a
phi_test = get_angle(seg_sin_test, seg_cos_test)
X_test, Y_test = transform(x_center - lastx, y_center - lasty, radians(phi_test))
code = 'G2' if Y_test > 0.0 else 'G3'
x_center_last = x_center
y_center_last = y_center
R_last = R_arc
FLAG_arc = 1
WRITE = 0
if FLAG_line == 0 and FLAG_arc == 0:
WRITE = 1
return code, FLAG_arc, R_last, x_center_last, y_center_last, WRITE, FLAG_line
