def updateMoveButton(self):
if self.moveButton1:
moveDir = Vector(self.moveButton1.targetPos) - Vector(
self.moveButton1.pos)
moveDist = moveDir.length()
moveVel = self.vMoveVel * self.fFrameTime
if moveVel > moveDist:
self.moveButton1.pos = self.moveButton1.targetPos
self.moveButton1 = None
else:
moveDir = moveDir.normalize()
moveDir *= moveVel
self.moveButton1.pos = (self.moveButton1.pos[0] + moveDir[0],
self.moveButton1.pos[1] + moveDir[1])
if self.moveButton2:
moveDir = Vector(self.moveButton2.targetPos) - Vector(
self.moveButton2.pos)
moveDist = moveDir.length()
moveVel = self.vMoveVel * self.fFrameTime
if moveVel > moveDist:
self.moveButton2.pos = self.moveButton2.targetPos
self.moveButton2 = None
else:
moveDir = moveDir.normalize()
moveDir *= moveVel
self.moveButton2.pos = (self.moveButton2.pos[0] + moveDir[0],
self.moveButton2.pos[1] + moveDir[1])
def avoid_obstacles_vector(self, entity_id, position):
entities = self.gameworld.entities
ship_system = entities[entity_id].ship_system
obstacles_to_avoid = ship_system.in_view
sum_avoidance = Vector(0, 0)
ob_count = 0
for obstacle in obstacles_to_avoid:
if obstacle != entity_id:
obstacle = entities[obstacle]
if not hasattr(obstacle, 'cymunk_physics') or hasattr(
obstacle, 'boundary_system'):
continue
ob_location = obstacle.position
dist = Vector((ob_location.x, ob_location.y)).distance(
(position.x, position.y))
scale_factor = (150. - dist) / 150.
avoidance_vector = Vector((position.x, position.y)) - Vector(
(ob_location.x, ob_location.y))
avoidance_vector = avoidance_vector.normalize()
avoidance_vector *= scale_factor
sum_avoidance += avoidance_vector
ob_count += 1
if ob_count > 0:
sum_avoidance /= float(ob_count)
sum_avoidance *= ship_system.max_speed
return sum_avoidance
def circleToCircle(a, b): v = Vector(a.pos) - Vector(b.pos) if v.length() < a.r+b.r: return (True, None, v.normalize()) return (False, None, None)
def avoid_obstacles_vector(self, entity_id, position):
entities = self.gameworld.entities
ship_system = entities[entity_id].ship_system
obstacles_to_avoid = ship_system.in_view
sum_avoidance = Vector(0, 0)
ob_count = 0
for obstacle in obstacles_to_avoid:
if obstacle != entity_id:
obstacle = entities[obstacle]
if not hasattr(obstacle, 'cymunk_physics') or hasattr(
obstacle, 'boundary_system'):
continue
ob_location = obstacle.position
dist = Vector((ob_location.x, ob_location.y)).distance(
(position.x, position.y))
scale_factor = (150.-dist)/150.
avoidance_vector = Vector(
(position.x, position.y)) - Vector(
(ob_location.x, ob_location.y))
avoidance_vector = avoidance_vector.normalize()
avoidance_vector *= scale_factor
sum_avoidance += avoidance_vector
ob_count += 1
if ob_count > 0:
sum_avoidance /= float(ob_count)
sum_avoidance *= ship_system.max_speed
return sum_avoidance
class Ball(Widget): r = 30 / 2 r2 = r**2 trail_pts = [] g_trail = "trail" def setup(self): self.pos = (cx, cy+cy/2) self.velocity = Vector(0,5) def move(self, dt): self.canvas.remove_group(self.g_trail) with self.canvas: Color(1, 1, 1, 0.5, mode='rgba', group=self.g_trail) Line(points=sum(self.trail_pts, []), group=self.g_trail) to_center = (Vector(cx, cy) - Vector(self.pos)) l = self.velocity.length() cen_d = to_center.length() self.velocity = self.velocity * 0.99 + to_center.normalize() * sqrt(cen_d) * 0.04 if l > 25: self.velocity = self.velocity.normalize() * 20 self.pos = Vector(self.pos) + self.velocity * dt * 30 if len(self.trail_pts) == 0: self.trail_pts = [self.pos] else: self.trail_pts.insert(0, self.pos) while len(self.trail_pts) > 30: self.trail_pts.pop()
def update(self, dt):
"""Updates the position and the velocity of the shell.
Moves the shell based on it's current velocity and the time passed (`dt`).
Updates the velocity based on `self.gravity`, `self.wind`, `self.drag_coef` and the time passed.
Args:
dt: Delta t, the change of time the shell should be updated by.
"""
# move the shell based on the current velocity and change of time
self.center = Vector(*self.center) + Vector(*self.velocity) * dt
# apply gravitational acceleration
self.velocity_y -= self.gravity * dt
air_vel = Vector(self.velocity_x - self.wind, self.velocity_y)
# based on https://en.wikipedia.org/wiki/Drag_equation
# hides the density, area and other constants for the shell into the drag coefficient
drag = air_vel.normalize() * self.drag_coef * air_vel.length2()
vel_vec = Vector(*self.velocity) - (drag / self.mass)
self.velocity = (vel_vec.x, vel_vec.y)
# bounce off the walls
if (self.x < 0) or (self.right > self.parent.width):
self.velocity_x *= -1
self.right = clamp(self.right, 0, self.parent.width)
self.x = clamp(self.x, 0, self.parent.width)
if self.top > self.parent.height:
self.velocity_y *= -1
self.top = clamp(self.top, 0, self.parent.height)
def circleToCircle(a, b):
v = Vector(a.pos) - Vector(b.pos)
if v.length() < a.r + b.r:
return (True, None, v.normalize())
return (False, None, None)
class Ball(Widget):
r = 30 / 2
r2 = r**2
trail_pts = []
g_trail = "trail"
def setup(self):
self.pos = (cx, cy + cy / 2)
self.velocity = Vector(0, 5)
def move(self, dt):
self.canvas.remove_group(self.g_trail)
with self.canvas:
Color(1, 1, 1, 0.5, mode='rgba', group=self.g_trail)
Line(points=sum(self.trail_pts, []), group=self.g_trail)
to_center = (Vector(cx, cy) - Vector(self.pos))
l = self.velocity.length()
cen_d = to_center.length()
self.velocity = self.velocity * 0.99 + to_center.normalize() * sqrt(
cen_d) * 0.04
if l > 25:
self.velocity = self.velocity.normalize() * 20
self.pos = Vector(self.pos) + self.velocity * dt * 30
if len(self.trail_pts) == 0:
self.trail_pts = [self.pos]
else:
self.trail_pts.insert(0, self.pos)
while len(self.trail_pts) > 30:
self.trail_pts.pop()
def update(self, dt):
self.ball.move(dt)
col = self.paddle.collide_widget(self.ball)
if col[0]:
#print dt,"bam"
self.sounds["hit_2"].play()
d = self.ball.r + self.paddle.r - (
Vector(self.ball.pos) - Vector(self.paddle.pos)).length()
#print d
self.ball.pos = Vector(self.ball.pos) + col[2] * d
v = self.ball.velocity
v_n = v.normalize()
normal = col[2]
m = max((280 - v.length2()) / 100, 1)
v = v - normal * 2 * (normal.dot(v)) * m
self.ball.velocity = v
killspace_col_paddle = self.killspace.collide_widget(self.ball)
# WE DIED!
if killspace_col_paddle[0]:
self.sounds["die"].play()
self.start()
for w in self.blocks:
col = w.collide_widget(self.ball)
if col[0]:
self.sounds["hit"].play()
closest = col[1]
circle = self.ball
mtd = Vector(circle.pos[0], circle.pos[1]) - closest
mtd = mtd.normalize()
pos = closest + mtd * 1.05 * self.ball.size[0] / 2
self.ball.pos = pos
v = self.ball.velocity
normal = col[2]
v = v - normal * 2 * (normal.dot(v))
self.ball.velocity = v
self.remove_widget(w)
self.blocks.remove(w)
self.score += 5 + 2 * self.level_num
self.best_score = max(self.score, self.best_score)
if len(self.blocks) == 0:
self.n_rings += 1
self.level_num += 1
self.ball.setup()
self.generate_level()
break
def update(self, dt): self.ball.move(dt) col = self.paddle.collide_widget(self.ball) if col[0]: #print dt,"bam" self.sounds["hit_2"].play() d = self.ball.r + self.paddle.r - (Vector(self.ball.pos) - Vector(self.paddle.pos)).length() #print d self.ball.pos = Vector(self.ball.pos) + col[2] * d v = self.ball.velocity v_n = v.normalize() normal = col[2] m = max((280-v.length2())/100,1) v = v - normal * 2 * (normal.dot(v)) * m self.ball.velocity = v killspace_col_paddle = self.killspace.collide_widget (self.ball) # WE DIED! if killspace_col_paddle[0]: self.sounds["die"].play() self.start() for w in self.blocks: col = w.collide_widget(self.ball) if col[0]: self.sounds["hit"].play() closest = col[1] circle = self.ball mtd = Vector(circle.pos[0], circle.pos[1]) - closest mtd = mtd.normalize() pos = closest + mtd * 1.05 * self.ball.size[0]/2 self.ball.pos = pos v = self.ball.velocity normal = col[2] v = v - normal * 2 * (normal.dot(v)) self.ball.velocity = v self.remove_widget (w) self.blocks.remove(w) self.score += 5 + 2 * self.level_num self.best_score = max(self.score, self.best_score) if len(self.blocks) == 0: self.n_rings += 1 self.level_num += 1 self.ball.setup() self.generate_level() break
def update_last_touch(self, touch):
tx, ty = self.last_touches[touch.uid]
v = Vector(touch.x - tx, touch.y - ty)
v1 = v
if 0 < v.length() < self.stroke_error_margin:
v = Vector(0, 0)
if v.length() > 0:
self.stroke_list[touch.uid][-1] = self.round_vector(v.normalize())
def update_line(self, startPt, endPt, loop):
startPt = Vector(startPt)
endPt = Vector(endPt)
if not loop:
line_vec = Vector(endPt) - Vector(startPt)
line_vec_unit = line_vec.normalize()
orth_unit_vec = Vector(-line_vec[1], line_vec[0]).normalize()
arrow_pt = Vector(endPt)
other_pt = -line_vec_unit * 12 + Vector(endPt)
self.mainLine.bezier = (startPt[0], startPt[1], endPt[0], endPt[1])
self.arrowColor.r = 1
self.arrowColor.g = 1
self.arrowColor.b = 0
self.arrow.points = (other_pt[0] - orth_unit_vec[0] * 10,
other_pt[1] - orth_unit_vec[1] * 10,
arrow_pt[0], arrow_pt[1],
other_pt[0] + orth_unit_vec[0] * 10,
other_pt[1] + orth_unit_vec[1] * 10)
else:
angle = (180 / math.pi) * math.atan2(endPt[1] - startPt[1],
endPt[0] - startPt[0]) - 90
loop_width = Vector(40, 0).rotate(angle)
width_orth_unit_vec = Vector(-loop_width[1],
loop_width[0]).normalize()
loop_start_pt = startPt - loop_width / 2
loop_end_pt = startPt + loop_width / 2
self.loop_ctrl_pt = startPt + width_orth_unit_vec * 125
self.mainLine.bezier = (loop_start_pt[0], loop_start_pt[1],
self.loop_ctrl_pt[0], self.loop_ctrl_pt[1],
loop_end_pt[0], loop_end_pt[1])
loop_width_unit = loop_width.normalize()
arrow_pt = self.get_bezier_mid(loop_start_pt, self.loop_ctrl_pt,
loop_end_pt) + loop_width_unit * 5
arrow_left = arrow_pt + width_orth_unit_vec * 10 - loop_width_unit * 10
arrow_right = arrow_pt - width_orth_unit_vec * 10 - loop_width_unit * 10
self.arrowColor.r = .9
self.arrowColor.g = .9
self.arrowColor.b = .9
self.arrow.points = (arrow_left[0], arrow_left[1], arrow_pt[0],
arrow_pt[1], arrow_right[0], arrow_right[1])
def on_touch_up(self, touch):
v = Vector(touch.pos) - Vector(touch.opos)
if v.length < 20:
return
if abs(v.x) > abs(v.y):
v.y = 0
else:
v.x = 0
self.move(*v.normalize())
def on_touch_up(self, touch):
v = Vector(touch.pos) - Vector(touch.opos)
if v.length() < self.columns:
return
if abs(v.x) > abs(v.y):
v.y = 0
else:
v.x = 0
if not self.game_over:
self.move(*v.normalize())
def on_touch_up(self, touch):
v = Vector(touch.pos) - Vector(touch.opos)
if v.length() < 20:
return
if abs(v.x) > abs(v.y):
v.y = 0
else:
v.x = 0
self.move(*v.normalize())
def updateMoveButton(self): if self.moveButton1: moveDir = Vector(self.moveButton1.targetPos) - Vector(self.moveButton1.pos) moveDist = moveDir.length() moveVel = self.vMoveVel * self.fFrameTime if moveVel > moveDist: self.moveButton1.pos = self.moveButton1.targetPos self.moveButton1 = None else: moveDir = moveDir.normalize() moveDir *= moveVel self.moveButton1.pos = (self.moveButton1.pos[0] + moveDir[0], self.moveButton1.pos[1] + moveDir[1]) if self.moveButton2: moveDir = Vector(self.moveButton2.targetPos) - Vector(self.moveButton2.pos) moveDist = moveDir.length() moveVel = self.vMoveVel * self.fFrameTime if moveVel > moveDist: self.moveButton2.pos = self.moveButton2.targetPos self.moveButton2 = None else: moveDir = moveDir.normalize() moveDir *= moveVel self.moveButton2.pos = (self.moveButton2.pos[0] + moveDir[0], self.moveButton2.pos[1] + moveDir[1])
def _calculate_resistance_vector(self, affection_zone):
"""Calculate vector from self to widget
:param affection_zone: bitmap of collission sector
:type affection_zone: numpy.ones
:returns: vector from self to widget
:rtype: kivy.vector.Vector
"""
resistance_vector = Vector(0, 0)
for x in range(affection_zone.shape[0]):
for y in range(affection_zone.shape[1]):
if not affection_zone[x, y]:
resistance_vector += Vector(
x - (affection_zone.shape[0] - 1) / 2,
y - (affection_zone.shape[1] - 1) / 2).normalize()
return resistance_vector.normalize()
def move(self, previousPart, magnitude):
#moves an individual part
#first calculates the previous part's position and vectorizes it
previousPos = (previousPart.absolutePos[0],previousPart.absolutePos[1])
destination = Vector(previousPos[0], previousPos[1])
current = (self.absolutePos[0], self.absolutePos[1])
velocity = Vector(destination.x-current[0],destination.y-current[1])
#determines velocity based on destination and current position
if destination.distance(current) < self.width:
#realigns the part velocity so that parts don't outrun the head
#when the head turns
magnitude *= velocity.length() / self.width
velocity = velocity.normalize() * magnitude
self.absolutePos[0] += velocity.x
self.absolutePos[1] += velocity.y
self.wrapAround()
def on_touch_move(self, *args):
# print("on_touch_down", args)
touch = args[0]
# print(touch.pos, self.center)
# self.stick.center = touch.pos
center2touch = Vector(*touch.pos) - Vector(*self.center)
# print("center2touch", center2touch)
dist = center2touch.length()
# print("dist", dist)
self.angle = -Vector(1, 0).angle(center2touch)
# print("angle", self.angle)
pos2center = Vector(*self.center) - Vector(*self.pos)
if dist > self.max_dist:
dist = self.max_dist
center2touch = center2touch.normalize() * self.max_dist
self.stick.center = center2touch + pos2center
self.magnitude = dist / self.max_dist
def move(self, previousPart, magnitude):
#moves an individual part
#first calculates the previous part's position and vectorizes it
previousPos = (previousPart.absolutePos[0],
previousPart.absolutePos[1])
destination = Vector(previousPos[0], previousPos[1])
current = (self.absolutePos[0], self.absolutePos[1])
velocity = Vector(destination.x - current[0],
destination.y - current[1])
#determines velocity based on destination and current position
if destination.distance(current) < self.width:
#realigns the part velocity so that parts don't outrun the head
#when the head turns
magnitude *= velocity.length() / self.width
velocity = velocity.normalize() * magnitude
self.absolutePos[0] += velocity.x
self.absolutePos[1] += velocity.y
self.wrapAround()
def calculate_desired_vector(self, target, location, ship_data, ship_ai_data):
g_map = self.gameworld.systems['default_map']
map_size_x = g_map.map_size[0]/1.9
map_size_y = g_map.map_size[1]/1.9
dist_x = math.fabs(target[0] - location[0])
dist_y = math.fabs(target[1] - location[1])
ship_ai_data['distance_to_target'] = Vector(target).distance2(location)
max_speed = ship_data['max_speed']
v = Vector(target) - Vector(location)
v = v.normalize()
v *= max_speed
if ship_ai_data['ai_state'] == 'flee':
v *= -1
if dist_x > map_size_x:
v[0] *=-1
if dist_y > map_size_y:
v[1] *=-1
return v
def calculate_desired_vector(self, target, location, system_data):
# g_map = self.gameworld.systems['default_map']
# map_size_x = g_map.map_size[0]/1.9
# map_size_y = g_map.map_size[1]/1.9
dist_x = math.fabs(target[0] - location[0])
dist_y = math.fabs(target[1] - location[1])
system_data["distance_to_target"] = Vector(target).distance2(location)
max_speed = system_data["max_speed"]
v = Vector(target) - Vector(location)
v = v.normalize()
v *= max_speed
if system_data["ai_state"] == "flee":
v *= -1
# if dist_x > map_size_x:
# v[0] *=-1
# if dist_y > map_size_y:
# v[1] *=-1
return v
def update_points(self):
v = Vector(self.start_point[0] - self.end_point[0], self.start_point[1] - self.end_point[1])
# orthogonal vector
o_v = v.normalize().rotate(90) * self.thickness / 2.0
self.quad_points = [
self.start_point[0] + o_v[0],
self.start_point[1] + o_v[1],
self.start_point[0] - o_v[0],
self.start_point[1] - o_v[1],
self.end_point[0] - o_v[0],
self.end_point[1] - o_v[1],
self.end_point[0] + o_v[0],
self.end_point[1] + o_v[1],
]
self.x = min(self.quad_points[::2]) - self.thickness
self.y = min(self.quad_points[1::2]) - self.thickness
self.width = max(self.quad_points[::2]) - min(self.quad_points[::2]) + 2 * self.thickness
self.height = max(self.quad_points[1::2]) - min(self.quad_points[1::2]) + 2 * self.thickness
def calculate_desired_vector(self, target, location, ship_data, ship_ai_data, is_player):
g_map = self.gameworld.systems["default_map"]
map_size_x = g_map.map_size[0] / 1.9
map_size_y = g_map.map_size[1] / 1.9
dist_x = math.fabs(target[0] - location[0])
dist_y = math.fabs(target[1] - location[1])
ship_ai_data["distance_to_target"] = Vector(target).distance2(location)
max_speed = ship_data["max_speed"]
v = Vector(target) - Vector(location)
v = v.normalize()
v *= max_speed
if not is_player:
if ship_ai_data["ai_state"] == "flee":
v *= -1
if dist_x > map_size_x:
v[0] *= -1
if dist_y > map_size_y:
v[1] *= -1
return v
def calculate_desired_vector(self, target, location, ship_data,
ship_ai_data):
g_map = self.gameworld.systems['default_map']
map_size_x = g_map.map_size[0] / 1.9
map_size_y = g_map.map_size[1] / 1.9
dist_x = math.fabs(target[0] - location[0])
dist_y = math.fabs(target[1] - location[1])
ship_ai_data['distance_to_target'] = Vector(target).distance2(location)
max_speed = ship_data['max_speed']
v = Vector(target) - Vector(location)
v = v.normalize()
v *= max_speed
if ship_ai_data['ai_state'] == 'flee':
v *= -1
if dist_x > map_size_x:
v[0] *= -1
if dist_y > map_size_y:
v[1] *= -1
return v
def _update(self, dt):
self.vel_x += self.acc_x * dt
self.vel_y += self.acc_y * dt
move_x = self.vel_x * dt
move_y = self.vel_y * dt
self.x += move_x
self.y += move_y
# reset force
self.force_x.clear()
self.force_y.clear()
for other in self.parent.children:
if other is not self and self.collide_widget(other):
move_vector = Vector(move_x, move_y)
move_normal = move_vector.normalize()
move_x_normal, move_y_normal = move_normal
# gradually move back to position where it is not collided with other
while self.collide_widget(other):
self.x -= move_x_normal
self.y -= move_y_normal
# recalculate velocity upon collision
direction = self.direction_widget(other)
if direction in HORIZONTAL:
self.vel_x = -self.vel_x * self.bounce
self.vel_y = self.vel_y * (1 - self.friction)
elif direction in VERTICAL:
self.vel_x = self.vel_x * (1 - self.friction)
self.vel_y = -self.vel_y * self.bounce
if direction is DOWN:
if "normal" not in self.force_y:
self.force_y["normal"] = -self.force_y.get(
"gravity", 0)
# prevent glitch when a block is stuck between multiple blocks
break # todo: a better solution for minor trembling
def avoid_obstacles_vector(self, entity_id, position):
entities = self.gameworld.entities
obstacles_to_avoid = self.query_physics_bb(position, 100)
sum_avoidance = Vector(0, 0)
ob_count = 0
for obstacle in obstacles_to_avoid:
if obstacle != entity_id:
obstacle = entities[obstacle]
ob_location = obstacle['cymunk-physics']['position']
dist = Vector(ob_location).distance(position)
scale_factor = (150. - dist) / 150.
avoidance_vector = Vector(position) - Vector(ob_location)
avoidance_vector = avoidance_vector.normalize()
avoidance_vector *= scale_factor
sum_avoidance += avoidance_vector
ob_count += 1
if ob_count > 0:
sum_avoidance /= float(ob_count)
sum_avoidance *= entities[entity_id]['ship_system']['max_speed']
return sum_avoidance
def on_touch_up(self, touch):
# Debug section
self.touch_console_pos = self.con.get_console_pos((touch.x, touch.y))
self.touch_info['pos'] = touch.pos
self.touch_info['time_start'] = touch.time_start
self.touch_info['time_update'] = touch.time_update
self.touch_info['time_end'] = touch.time_end
self.touch_info['triple_tap_time'] = touch.triple_tap_time
self.touch_info['double_tap_time'] = touch.double_tap_time
# Start of move code
vec = Vector(touch.pos) - Vector(touch.opos)
# If travel distance is short then it's probably a tap or click.
if vec.length() < 50:
return
dx, dy = vec.normalize()
self.player.move(round(dx), round(dy))
self.update()
class OVector:
def __init__(self, p: Vector, v: Vector, color=Color(1, 1, 1, 1)):
self.p = p
self.v = v
self.color = color
def end(self):
return self.p + self.v
def len(self):
return self.v.length()
def normalize(self, unit):
if self.is_inf():
self.v = Vector(0, 0)
else:
self.v = self.v.normalize() * unit
def is_inf(self):
return self.v.x == inf or self.v.y == inf
def avoid_obstacles_vector(self, entity_id, position):
entities = self.gameworld.entities
obstacles_to_avoid = self.query_physics_bb(position, 100)
sum_avoidance = Vector(0, 0)
ob_count = 0
for obstacle in obstacles_to_avoid:
if obstacle != entity_id:
obstacle = entities[obstacle]
ob_location = obstacle['cymunk-physics']['position']
dist = Vector(ob_location).distance(position)
scale_factor = (150.-dist)/150.
avoidance_vector = Vector(position) - Vector(ob_location)
avoidance_vector = avoidance_vector.normalize()
avoidance_vector *= scale_factor
sum_avoidance += avoidance_vector
ob_count += 1
if ob_count > 0:
sum_avoidance /= float(ob_count)
sum_avoidance *= entities[entity_id]['ship_system']['max_speed']
return sum_avoidance
def circleToPolygon(circle, quad):
cpos = Vector(circle.pos[0], circle.pos[1])
x = cpos[0]
y = cpos[1]
r = circle.r
r2 = circle.r2
w = quad
if (x + r > w.lowerx) and (x - r < w.upperx) and (y + r > w.lowery) and (
y - r < w.uppery):
quad = quad.pts
#print random.randint(0,1000000)
# for each edge
best_closest = None
normal = None
best_d = None
for i in range(4):
edge_pt1 = Vector(float(quad[i * 2]), float(quad[(i * 2 + 1)]))
edge_pt2 = Vector(float(quad[((i + 1) * 2) % 8]),
float(quad[((i + 1) * 2 + 1) % 8]))
pt = closestPointOnEdge(cpos, edge_pt1, edge_pt2)
d = pt.distance2(cpos)
if d < r2 and (best_d is None or d < best_d):
closest = pt
normal = edge_pt2 - edge_pt1
normal = Vector(-normal.y, normal.x).normalize()
best_d = d
#return (True, closest, normal)
if best_d is not None:
return (True, closest, normal)
# if we still haven't gotten anything, try this test..
if polygonContainsPoint(cpos, quad):
#print "GRRRRRRR"
return (True, cpos, cpos.normalize())
return (False, None, None)
def on_touch_move(self, touch):
if "vjtouch" not in touch.ud:
return
vec = Vector(touch.pos) - Vector(self.center)
vlen = vec.length()
if vlen > self.radius:
vec = vec.normalize() * self.radius
stripsize = 0.2
try:
if vlen < self.radius * stripsize or \
self.radius * (1.0 + stripsize) > vlen > self.radius:
vibrator.vibrate(0.005)
except NotImplementedError:
pass
self.touch = Vector(self.center) + vec
self.vec = vec / self.radius
def avoid_obstacles_vector(self, entity_id, position):
entities = self.gameworld.entities
obstacles_to_avoid = entities[entity_id]["ship_system"]["in_view"]
sum_avoidance = Vector(0, 0)
ob_count = 0
for obstacle in obstacles_to_avoid:
if obstacle != entity_id:
obstacle = entities[obstacle]
if "cymunk-physics" not in obstacle or "boundary_system" in obstacle:
continue
ob_location = obstacle["cymunk-physics"]["position"]
dist = Vector(ob_location).distance(position)
scale_factor = (150.0 - dist) / 150.0
avoidance_vector = Vector(position) - Vector(ob_location)
avoidance_vector = avoidance_vector.normalize()
avoidance_vector *= scale_factor
sum_avoidance += avoidance_vector
ob_count += 1
if ob_count > 0:
sum_avoidance /= float(ob_count)
sum_avoidance *= entities[entity_id]["ship_system"]["max_speed"]
return sum_avoidance
def retreat(self):
"""Move the enemy to the beetle den.
This method moves the enemy to the beetle den if it is dead.
The enemy is set to not dead upon reaching the beetle den.
This method should be called every frame in place of move if
the enemy is dead.
"""
beetle_den_center = self.game.level.beetle_den['center']
beetle_den_center_coords = beetle_den_center.center
direction_vector = Vector(beetle_den_center_coords) - Vector(self.center)
direction_vector = direction_vector.normalize()
if not self.collide_point(*beetle_den_center_coords):
self.pos = (direction_vector * self.speed) + Vector(self.pos)
else:
self.center = beetle_den_center_coords
# Reset here as rare bug sometimes happens where grid coordinates not set before move
self.grid_position = beetle_den_center.coordinates
self.dead = False
self.frightened = False
def circleToPolygon(circle, quad): cpos = Vector(circle.pos[0], circle.pos[1]) x = cpos[0] y = cpos[1] r = circle.r r2 = circle.r2 w = quad if (x+r > w.lowerx) and (x-r < w.upperx) and (y+r > w.lowery) and (y-r < w.uppery): quad = quad.pts #print random.randint(0,1000000) # for each edge best_closest = None normal = None best_d = None for i in range(4): edge_pt1 = Vector(float(quad[i*2]), float(quad[(i*2+1)])) edge_pt2 = Vector(float(quad[((i+1)*2)%8]), float(quad[((i+1)*2+1)%8])) pt = closestPointOnEdge(cpos, edge_pt1, edge_pt2) d = pt.distance2(cpos) if d < r2 and (best_d is None or d < best_d): closest = pt normal = edge_pt2 - edge_pt1 normal = Vector(-normal.y, normal.x).normalize() best_d = d #return (True, closest, normal) if best_d is not None: return (True, closest, normal) # if we still haven't gotten anything, try this test.. if polygonContainsPoint(cpos, quad): #print "GRRRRRRR" return (True, cpos, cpos.normalize()) return (False, None, None)
def update_points(self):
v = Vector(self.start_point[0] - self.end_point[0],
self.start_point[1] - self.end_point[1])
# orthogonal vector
o_v = v.normalize().rotate(90) * self.thickness / 2.
self.quad_points = [
self.start_point[0] + o_v[0],
self.start_point[1] + o_v[1],
self.start_point[0] - o_v[0],
self.start_point[1] - o_v[1],
self.end_point[0] - o_v[0],
self.end_point[1] - o_v[1],
self.end_point[0] + o_v[0],
self.end_point[1] + o_v[1],
]
self.x = min(self.quad_points[::2]) - self.thickness
self.y = min(self.quad_points[1::2]) - self.thickness
self.width = max(self.quad_points[::2]) - min(
self.quad_points[::2]) + 2 * self.thickness
self.height = max(self.quad_points[1::2]) - min(
self.quad_points[1::2]) + 2 * self.thickness
def update(self, dt):
""" 게임업데이트 """
if not self.is_start:
self.txupdate(dt)
# tip label
if self.tip_label.opacity <= 1.0:
self.tip_label.opacity += 0.005
return
self.txupdate(dt)
self.is_ycoll = False
# Character's Move
for brick in self.bricks:
# meet Block
if self.character.collide_widget(brick):
z = Vector(self.character.center) - Vector(brick.center)
if -0.70 < z.normalize()[0] < 0.70:
# down
if self.character_y_collision(brick):
self.is_jumping = False
self.is_ycoll = True
else:
self.character_x_collision(brick)
self.character.move()
# y 충돌이면 떨어지지 않는다. // 표면보다 같거나 낮으면 떨어지지 않는다.
if not self.is_ycoll and not self.character.y <= self.y:
self.character.y -= 5.0
# floor
if self.character.y <= self.y and self.is_jumping:
self.is_jumping = False
self.character.y = self.y
# next stage
if self.character.center_x > self.width or self.character.center_x < 0:
self.clear_stage()
# monster
for monster in self.monsters:
if self.character.collide_widget(monster):
if monster.status == 1: # Food
anim = Animation(
size=[self.character.player_image.width * 1.2, self.character.player_image.height * 1.2], duration=.2)
if anim:
anim.stop(self.character.player_image)
anim.start(self.character.player_image)
# remove monster
self.remove_widget(monster)
self.monsters.remove(monster)
self.score += 1
elif monster.status == 2: # Enemy
monster.source_dir = "data/mouse_dead.png"
monster.status = 3
left = Animation(
center_x=monster.center_x + 10, duration=.2)
right = Animation(center_x=monster.center_x, duration=.2)
anim = left + right
if anim:
anim.stop(self)
anim.start(monster)
self.score += 2
elif monster.status == 9: # Boss
monster.source_dir = "data/spider_dead.png"
monster.status = 3
self.score += 3
elif monster.status == 10: # Girl
self.character.velocity = [0, 0]
self.character.y += 6
monster.y += 1
if self.center[1] < self.character.y:
self.clear_stage()
# Letter
elif monster.status in [12, 13, 14, 15, 16, 17, 18, 19, 20, 21]:
left = Animation(
center_y=monster.center_y + 400, duration=.2)
right = Animation(center_y=monster.center_y, duration=.2)
anim = left + right
if anim:
anim.stop(self)
anim.start(monster)
monster.status = 3
self.score += 1
# Hurt
elif monster.status in [30, 31, 32, 33, 34]:
left = Animation(
center_y=monster.center_y + 400, duration=.2)
right = Animation(center_y=monster.center_y, duration=.2)
anim = left + right
if anim:
anim.stop(self)
anim.start(monster)
monster.source_dir = monster.source_dir.replace(
"_hurt", "")
monster.status = 3
self.score += 2
# 3. MESSAGE
elif monster.status == 3:
pass
# 4. JUMP - SONIC
elif monster.status == 4:
self.character_jump(2) # jump time x 2
# 5. Gold Ring - SONIC
elif monster.status == 5:
self.remove_widget(monster)
self.monsters.remove(monster)
self.score += 1
# 6. speed up
elif monster.status == 23:
self.remove_widget(monster)
self.monsters.remove(monster)
self.score += 1
self.character.velocity = [
self.character.velocity[0] * 2, 0]
# 6,7. FLAGS - MARIO
elif monster.status == 6:
self.character.velocity = [0, 0]
self.score += 1
monster.status = 3
elif monster.status == 22:
self.character.velocity = [
self.block_size / self.speed_ratio, 0]
# 8. Gold coin - MARIO
elif monster.status in [8, 24]:
self.remove_widget(monster)
self.monsters.remove(monster)
self.score += 1
self.is_jumping = False
# trap
for trap in self.traps:
if self.character.collide_widget(trap):
self.failed_stage()
def set_new_target(self, x, y):
self.target = x, y
v = Vector(self.target) - Vector(self.center)
self.velocity = v.normalize() * self.speed
