def __limit_length(self):
length = glm.distance(self.start, self.end)
if length > ARROW_MAX_LENGTH:
self.end = vec3((self.end.x - self.start.x) / length * ARROW_MAX_LENGTH + self.start.x,
(self.end.y - self.start.y) / length * ARROW_MAX_LENGTH + self.start.y,
0)
self.length = glm.distance(self.start, self.end)
def distance(self, other:"Transformation") -> float:
td = glm.distance(self.translation, other.translation)
sd = glm.distance(self.scale, other.scale)
qn : glm.Quat = glm.inverse(self.quaternion) # type: ignore
qn = qn * other.quaternion
if qn.w<0: qn = -qn
qd = glm.length(qn - glm.quat())
return td+sd+qd
def find_nearest_ball(self, nodes):
closest_node = ball.ball(50, glm.vec3(5000,5000,5000))
nearest = glm.distance(self.pos.center_pos , closest_node.pos.center_pos)
for n in nodes:
distance = glm.distance(self.pos.center_pos, n.pos.center_pos)
if (distance < nearest):
nearest = distance
closest_node = n
return closest_node
def drive(self):
if self.state is not character.DIE:
if self.state is character.DRIVING:
self.collider.pos = self.vehicle.get_seat_pos(
self.seat_index, 2)
# self.collider.pos = self.graphics.pos
self.engine.physics.dynamic.append(self.collider)
self.collider.vel = glm.vec3(*self.vehicle.collider.vel)
if self.seat_index is 0:
self.vehicle.accel = 0
self.vehicle.turn = 0
self.vehicle.turn_off()
self.vehicle.occupied_seats.remove(self.seat_index)
self.vehicle = None
self.set_state(character.JUMPING)
else:
for vehicle in self.engine.game_manager.vehicles:
if glm.distance(self.graphics.pos,
vehicle.collider.pos) < 7:
self.seat_index = vehicle.get_open_seat()
if self.seat_index >= 0:
self.vehicle = vehicle
self.set_state(character.DRIVING)
break
def __get_force(self, obj) -> vec3:
'''
Return the force between self and obj.
'''
vect = vec3(obj.pos.x - self.pos.x, obj.pos.y - self.pos.y, 0)
dist = glm.distance(self.pos, obj.pos)
factor = self.mass * obj.mass / dist**3 #Power of 3 because the directional vector is not normalized
return vec3(vect.x * factor, vect.y * factor, 0)
def __new_object_stage1_cont(self):
"""
Private function to update celestial body radius
"""
if self.curr_celestial:
center = self.curr_celestial.rect.center
center_v = vec3(center[0], center[1], 0)
curpos = pygame.mouse.get_pos()
curpos_v = vec3(curpos[0], curpos[1], 0)
self.curr_celestial.radius = math.floor(glm.distance(center_v, curpos_v))
def getFarthestTileOfType(self, type, worldPosition):
tiles = self.graph.getTilesOfType(type)
farthestTile = None
for tile in tiles:
if farthestTile == None:
farthestTile = tile
continue
farthestTileWorldPosition = self.map.getWorldPosition(farthestTile)
farthestTileDistance = glm.distance(
glm.vec2(farthestTileWorldPosition[0],
farthestTileWorldPosition[1]),
glm.vec2(worldPosition[0], worldPosition[1]))
tileWorldPosition = self.map.getWorldPosition(tile)
tileDistance = glm.distance(
glm.vec2(tileWorldPosition[0], tileWorldPosition[1]),
glm.vec2(worldPosition[0], worldPosition[1]))
if tileDistance > farthestTileDistance:
farthestTile = tile
return farthestTile
def calcNeighborAcc(self, neighbor):
#Distancia entre G e g
distance = glm.distance(self.posicao, neighbor.posicao)
#calculo da forca escalar Fg = G (M1 * M2 / d **2)
escalarForce = 6.67e-11 * ((self.massa * neighbor.massa) /
(distance**2))
#proporcao (Regra de 3), da forca em cada eixo
self.accForce += (
(neighbor.posicao - self.posicao) * escalarForce) / distance
def getClosestTileOfType(self, type, worldPosition):
tiles = self.graph.getTilesOfType(type)
closestTile = None
for tile in tiles:
if closestTile == None:
closestTile = tile
continue
closestTileWorldPosition = self.map.getWorldPosition(closestTile)
closestTileDistance = glm.distance(
glm.vec2(closestTileWorldPosition[0],
closestTileWorldPosition[1]),
glm.vec2(worldPosition[0], worldPosition[1]))
tileWorldPosition = self.map.getWorldPosition(tile)
tileDistance = glm.distance(
glm.vec2(tileWorldPosition[0], tileWorldPosition[1]),
glm.vec2(worldPosition[0], worldPosition[1]))
if tileDistance < closestTileDistance:
closestTile = tile
return closestTile
def getClosestWalkable(self, mapPosition):
if self.graph.isWalkable(mapPosition) == True:
return mapPosition
tiles = self.graph.getWalkableTiles()
closestTile = None
for tile in tiles:
if closestTile == None:
closestTile = tile
continue
closestTileDistance = glm.distance(
glm.vec2(closestTile[0], closestTile[1]),
glm.vec2(mapPosition[0], mapPosition[1]))
tileDistance = glm.distance(
glm.vec2(tile[0], tile[1]),
glm.vec2(mapPosition[0], mapPosition[1]))
if tileDistance < closestTileDistance:
closestTile = tile
return closestTile
def update(self, time: float, dt: float):
location = self.location
if self._last_location is None:
speed = 0.
else:
speed = glm.distance(location.xy, self._last_location.xy) / dt
if speed:
self.direction_of_movement = glm.normalize(location.xy - self._last_location.xy)
self._last_location = self._location.__copy__()
self.average_speed += min(1., 8. * dt) * (speed - self.average_speed)
def getFarthestCover(self, coverWorldPosition, farWorldPosition):
tiles = self.graph.getWalkableTiles()
closestTile = None
for tile in tiles:
tileWorldPosition = self.map.getWorldPosition(tile)
if self.map.isVisible(coverWorldPosition,
tileWorldPosition) == True:
continue
if closestTile == None:
closestTile = tile
continue
closestTileWorldPosition = self.map.getWorldPosition(closestTile)
closestTileDistance = glm.distance(
glm.vec2(closestTileWorldPosition[0],
closestTileWorldPosition[1]),
glm.vec2(farWorldPosition[0], farWorldPosition[1]))
tileDistance = glm.distance(
glm.vec2(tileWorldPosition[0], tileWorldPosition[1]),
glm.vec2(farWorldPosition[0], farWorldPosition[1]))
if tileDistance > closestTileDistance:
closestTile = tile
return closestTile
def update(self, dt):
if self.state is IDLE:
self.angle += 30 * dt
p_col = self.engine.game_manager.player.collider
if glm.distance(self.pos.xz, p_col.pos.xz) < 2:
if p_col.pos.y <= self.pos.y < p_col.pos.y + p_col.height:
self.set_state(DIE)
elif self.state is DIE:
self.timer -= dt
if self.timer > 0:
self.scale = self.timer
else:
self.despawn()
self.engine.game_manager.powerups.remove(self)
self.on_collect()
def __init__(self, name, position=None, up=None, center=None):
self._name = name
self._position = position if position else glm.vec3()
self._up = up if up else glm.vec3(0.0, 1.0, 0.0)
self._center = center if center else glm.vec3()
self._input = {"move": False, "x": 0.0, "y": 0.0}
self.state = {
"moving": False,
"looking": False,
"target_position": None,
"target_center": None,
"move_speed": 0,
"look_speed": 0
}
self.distance = glm.distance(self._position, self._center)
self.view_matrix = glm.mat4()
def __new_object_stage2(self):
"""
Private function to complete creating a new celestial object
"""
if self.curr_celestial:
# Replace functions for next stage
self.__dynamic_input_funcs["temp"] = self.app.inputs.inputs["update"].always(self.__new_object_stage2_cont)
self.__dynamic_input_funcs["temp2"] = self.app.inputs.inputs["new_object"].on_press(self.__new_object_stage3)
center = self.curr_celestial.rect.center
center_v = vec3(center[0], center[1], 0)
curpos = pygame.mouse.get_pos()
curpos_v = vec3(curpos[0], curpos[1], 0)
self.curr_celestial.radius = math.floor(glm.distance(center_v, curpos_v))
self.setting_velocity = True
center = self.curr_celestial.rect.center
self.curr_velo_arrow = VelocityArrow(center)
def __init__(self, start: vec3, end: vec3, radius: float):
super().__init__()
self.start: vec3 = vec3(start)
self.end: vec3 = vec3(end)
self.radius: float = radius
self.height: float = glm.distance(self.start, self.end)
self.normal: vec3 = glm.normalize(self.end - self.start)
self.b1: vec3
self.b2: vec3
self.b1, self.b2 = orthonormal_basis_of(self.normal)
# calculate rotation matrix for cylinder
self.trans_matrix: mat4 = glm.orientation(vec3(0.0, 0.0, 1.0), self.normal)
# add translation to matrix
self.trans_matrix[0][3] = start.x
self.trans_matrix[1][3] = start.y
self.trans_matrix[2][3] = start.z
# get corners of OBB
points = glm.array(
vec3(self.radius, self.radius, 0.0),
vec3(-self.radius, self.radius, 0.0),
vec3(self.radius, -self.radius, 0.0),
vec3(-self.radius, -self.radius, 0.0),
vec3(self.radius, self.radius, self.height),
vec3(-self.radius, self.radius, self.height),
vec3(self.radius, -self.radius, self.height),
vec3(-self.radius, -self.radius, self.height))
# inflate OBB into AABB
# TODO:
# BoundingBox _should_ have default values - we shouldn't have to
# initialize with inf and -inf manually. but if we do that,
# it seems to initialize with other BoundingBox's values.
# Something weird is going on with (I presume) glm pointers?
self._bbox = BoundingBox(vec3(inf), vec3(-inf))
for v in points:
self._bbox.vec3_extend(vec3(vec4(v, 1.0) * self.trans_matrix))
def update(self, dt):
if self.cur_index + 1 >= len(self.path):
return False
this_pos = self.waypoints.id_to_pos[self.path[
self.cur_index]] + glm.vec3(.5, .5, 0)
next_node = self.path[self.cur_index + 1]
next_pos = self.waypoints.id_to_pos[next_node] + glm.vec3(.5, .5, 0)
#print(self.path, self.cur_index, next_node, self.agent.sposition, next_pos)
dist = glm.distance(self.agent.sposition, next_pos)
dir = (next_pos - self.agent.sposition) / dist
self.agent.move(dir)
#if self.agent.name == "player":
# print(this_pos.y, next_pos.y, self.agent.sposition.y)
if next_pos.z > this_pos.z + .3 and next_pos.z > self.agent.sposition.z:
self.agent.jump()
if dist <= self.min_dist:
self.cur_index += 1
def process(self):
if self.world.state == res.STATE_PAUSED:
return
for hero_id, (hero_transformation,
hero_velocity,
hero_bounding_box,
hero_collision) in \
self.world.get_components(com.Transformation,
com.Velocity,
com.BoundingBox,
com.CollisionComponent):
hero_rotation = hero_transformation.rotation.x
target_velocity = hero_velocity.value * self.world.delta
hero_comfort_zone = hero_bounding_box.radius
hero_rectangle = hero_bounding_box.shape
hero_target_pos = hero_transformation.position + target_velocity
hero_rectangle_width = (
hero_rectangle.width * abs(math.cos(hero_rotation)) +
hero_rectangle.depth * abs(math.sin(hero_rotation)))
hero_rectangle_depth = (
hero_rectangle.width * abs(math.sin(hero_rotation)) +
hero_rectangle.depth * abs(math.cos(hero_rotation)))
hero_rectangle_height = hero_rectangle.height
hero_collision.is_colliding_x = False
hero_collision.is_colliding_y = False
hero_collision.is_colliding_z = False
for villain_id, (
villain_transformation,
villain_bounding_box) in self.world.get_components(
com.Transformation, com.BoundingBox):
villain_rectangle = villain_bounding_box.shape
# Don't hit your self
if villain_id == hero_id: continue
# Are they in each others comfort zones?
if (glm.distance(villain_transformation.position,
villain_transformation.position) >
(hero_comfort_zone + villain_bounding_box.radius)):
continue
diff = glm.vec3(
villain_transformation.position.x - hero_target_pos.x,
villain_transformation.position.y - hero_target_pos.y,
villain_transformation.position.z - hero_target_pos.z)
gap = glm.vec3(
(hero_rectangle_width + villain_rectangle.width) -
abs(diff.x),
(hero_rectangle_depth + villain_rectangle.depth) -
abs(diff.y),
(hero_rectangle_height + villain_rectangle.height) -
abs(diff.z))
old_gap_x = ((hero_rectangle_width + villain_rectangle.width) -
abs(villain_transformation.position.x -
hero_transformation.position.x))
# One side is outside
if gap.x < 0.0 or gap.y < 0.0 or gap.z < 0.0: continue
# Has collided and append
if self.world.has_components(villain_id, com.CollisionReport):
self.world.component_for_entity(
villain_id, com.CollisionReport).failed.append(hero_id)
old_diff = hero_transformation.position - villain_transformation.position
if gap.x <= gap.y and gap.x <= gap.z:
offset = max(
hero_rectangle_width + villain_rectangle.width, 0)
hero_target_pos.x = villain_transformation.position.x + math.copysign(
offset, old_diff.x)
hero_collision.is_colliding_x = True
elif gap.y <= gap.z:
if old_gap_x <= 0:
continue
offset = max(
hero_rectangle_depth + villain_rectangle.depth, 0)
hero_target_pos.y = villain_transformation.position.y + math.copysign(
offset, old_diff.y)
hero_collision.is_colliding_y = True
else:
offset = hero_rectangle_height + villain_rectangle.height
hero_target_pos.z = villain_transformation.position.z + math.copysign(
offset, old_diff.z)
hero_collision.is_colliding_z = True
hero_velocity.value = (
hero_target_pos -
hero_transformation.position) / self.world.delta
def finished(self):
if self.cur_index >= len(self.path):
return True
return glm.distance(self.agent.sposition,
glm.vec3(*self.goal_pos)) <= self.min_dist
def near(self, neighbor, minDistance):
distance = glm.distance(self.posicao, neighbor.posicao)
if distance < minDistance:
return True
return False
def circle_collision(center, point, radius):
if glm.distance(point, center) < radius:
return center, glm.normalize(point - center), radius
def think(self):
if self.lastSeenBotEntity != None and self.timer.read(
) >= self.seeDelay:
seenBotInfo = self.sight.getSeenBotInfo(self.lastSeenBotEntity)
distance = glm.distance(
glm.vec2(seenBotInfo.transform.position[0],
seenBotInfo.transform.position[1]),
glm.vec2(self.transform.position[0],
self.transform.position[1]))
colliderRange = self.collider.size[
0] / 2.0 + seenBotInfo.collider.size[0] / 2.0
# Take cover
if self.fsm.isCurrentState("TakeCover") == True:
if self.agent.finishedMove == True:
if self.fsm.isCurrentState("Idle") == False:
self.fsm.changeCurrentState(decisionMaking.Idle())
elif self.fsm.isCurrentState("TakeHealthCover") == True:
if self.agent.finishedMove == True:
if self.fsm.isCurrentState("Heal") == False:
self.fsm.changeCurrentState(decisionMaking.Heal())
elif self.fsm.isCurrentState("TakeWeaponCover") == True:
if self.agent.finishedMove == True:
if self.fsm.isCurrentState("Reload") == False:
self.fsm.changeCurrentState(decisionMaking.Reload())
# Heal or retreat
elif self.health.currentHP < seenBotInfo.health.currentHP * 0.9:
if self.health.firstAidBoxHP > 0:
if self.canTakeCover == True:
if self.fsm.isCurrentState("TakeHealthCover") == False:
closestCover = self.getClosestCover(
seenBotInfo.transform.position,
self.transform.position)
worldDestinationPosition = self.map.getWorldPosition(
closestCover)
self.fsm.changeCurrentState(
decisionMaking.TakeHealthCover(
self.transform.position,
worldDestinationPosition))
else:
if self.fsm.isCurrentState("Heal") == False:
self.fsm.changeCurrentState(decisionMaking.Heal())
else:
if self.fsm.isCurrentState("TakeCover") == False:
farthestCover = self.getFarthestCover(
seenBotInfo.transform.position,
self.transform.position)
worldDestinationPosition = self.map.getWorldPosition(
farthestCover)
self.fsm.changeCurrentState(
decisionMaking.TakeCover(self.transform.position,
worldDestinationPosition))
# Shoot
elif self.weapon.currentAmmo > 0:
if distance <= self.weapon.primaryWeaponRange:
if distance >= colliderRange:
if self.fsm.isCurrentState(
"ShootPrimaryWeapon") == False:
self.fsm.changeCurrentState(
decisionMaking.ShootPrimaryWeapon(
self.lastSeenBotEntity))
else:
if self.fsm.isCurrentState("MoveAwayFromBot") == False:
self.fsm.changeCurrentState(
decisionMaking.MoveAwayFromBot(
self.lastSeenBotEntity))
else:
if self.fsm.isCurrentState("MoveTowardsBot") == False:
self.fsm.changeCurrentState(
decisionMaking.MoveTowardsBot(
self.lastSeenBotEntity))
# Shoot
elif seenBotInfo.health.currentHP - self.weapon.secondaryWeaponDamage * 3 <= 0:
if distance <= self.weapon.secondaryWeaponRange:
if distance >= colliderRange:
if self.fsm.isCurrentState(
"ShootSecondaryWeapon") == False:
self.fsm.changeCurrentState(
decisionMaking.ShootSecondaryWeapon(
self.lastSeenBotEntity))
else:
if self.fsm.isCurrentState("MoveAwayFromBot") == False:
self.fsm.changeCurrentState(
decisionMaking.MoveAwayFromBot(
self.lastSeenBotEntity))
else:
if self.fsm.isCurrentState("MoveTowardsBot") == False:
self.fsm.changeCurrentState(
decisionMaking.MoveTowardsBot(
self.lastSeenBotEntity))
# Reload
elif self.weapon.ammoBoxAmmo > 0:
if self.canTakeCover == True:
if self.fsm.isCurrentState("TakeWeaponCover") == False:
closestCover = self.getClosestCover(
seenBotInfo.transform.position,
self.transform.position)
worldDestinationPosition = self.map.getWorldPosition(
closestCover)
self.fsm.changeCurrentState(
decisionMaking.TakeWeaponCover(
self.transform.position,
worldDestinationPosition))
else:
if self.fsm.isCurrentState("Reload") == False:
self.fsm.changeCurrentState(decisionMaking.Reload())
# Shoot
else:
if distance <= self.weapon.secondaryWeaponRange:
if distance >= colliderRange:
if self.fsm.isCurrentState(
"ShootSecondaryWeapon") == False:
self.fsm.changeCurrentState(
decisionMaking.ShootSecondaryWeapon(
self.lastSeenBotEntity))
else:
if self.fsm.isCurrentState("MoveAwayFromBot") == False:
self.fsm.changeCurrentState(
decisionMaking.MoveAwayFromBot(
self.lastSeenBotEntity))
else:
if self.fsm.isCurrentState("MoveTowardsBot") == False:
self.fsm.changeCurrentState(
decisionMaking.MoveTowardsBot(
self.lastSeenBotEntity))
else:
# Take cover
if self.fsm.isCurrentState("TakeCover") == True:
if self.agent.finishedMove == True:
if self.fsm.isCurrentState("Idle") == False:
self.fsm.changeCurrentState(decisionMaking.Idle())
elif self.fsm.isCurrentState("TakeHealthCover") == True:
if self.agent.finishedMove == True:
if self.fsm.isCurrentState("Heal") == False:
self.fsm.changeCurrentState(decisionMaking.Heal())
elif self.fsm.isCurrentState("TakeWeaponCover") == True:
if self.agent.finishedMove == True:
if self.fsm.isCurrentState("Reload") == False:
self.fsm.changeCurrentState(decisionMaking.Reload())
# Heal
elif self.health.currentHP < self.health.maxHP * 0.5 and self.health.firstAidBoxHP > 0:
if self.fsm.isCurrentState("Heal") == False:
self.fsm.changeCurrentState(decisionMaking.Heal())
elif self.health.currentHP < self.health.maxHP * 0.5 and self.canPickUpObjects:
if self.fsm.isCurrentState("GoToHealthSpawner") == False:
closestHealthSpawner = self.getClosestHealthSpawner(
self.transform.position)
worldDestinationPosition = self.map.getWorldPosition(
closestHealthSpawner)
self.fsm.changeCurrentState(
decisionMaking.GoToHealthSpawner(
self.transform.position, worldDestinationPosition))
# Reload
elif self.weapon.currentAmmo < self.weapon.maxAmmo * 0.5 and self.weapon.ammoBoxAmmo > 0:
if self.fsm.isCurrentState("Reload") == False:
self.fsm.changeCurrentState(decisionMaking.Reload())
elif self.weapon.currentAmmo < self.weapon.maxAmmo * 0.5 and self.canPickUpObjects:
if self.fsm.isCurrentState("GoToWeaponSpawner") == False:
closestWeaponSpawner = self.getClosestWeaponSpawner(
self.transform.position)
worldDestinationPosition = self.map.getWorldPosition(
closestWeaponSpawner)
self.fsm.changeCurrentState(
decisionMaking.GoToWeaponSpawner(
self.transform.position, worldDestinationPosition))
# Search
elif self.lastKnownDirection != None:
if self.fsm.isCurrentState("LookAtBullet") == True:
if self.agent.finishedRotate == True:
self.lastKnownDirection = None
else:
self.fsm.changeCurrentState(
decisionMaking.LookAtBullet(self.lastKnownDirection))
elif self.lastKnownPosition != None:
if self.fsm.isCurrentState("GoToLastKnownPosition") == True:
if self.agent.finishedMove == True:
self.lastKnownPosition = None
else:
self.fsm.changeCurrentState(
decisionMaking.GoToLastKnownPosition(
self.transform.position, self.lastKnownPosition))
# Reload
elif self.weapon.ammoBoxAmmo == 0 and self.canPickUpObjects:
if self.fsm.isCurrentState("GoToWeaponSpawner") == False:
closestWeaponSpawner = self.getClosestWeaponSpawner(
self.transform.position)
worldDestinationPosition = self.map.getWorldPosition(
closestWeaponSpawner)
self.fsm.changeCurrentState(
decisionMaking.GoToWeaponSpawner(
self.transform.position, worldDestinationPosition))
# Heal
elif self.health.firstAidBoxHP == 0 and self.canPickUpObjects:
if self.fsm.isCurrentState("GoToHealthSpawner") == False:
closestHealthSpawner = self.getClosestHealthSpawner(
self.transform.position)
worldDestinationPosition = self.map.getWorldPosition(
closestHealthSpawner)
self.fsm.changeCurrentState(
decisionMaking.GoToHealthSpawner(
self.transform.position, worldDestinationPosition))
# Search
else:
if self.agent.finishedMove == True:
randomTile = self.getRandomTile()
worldDestinationPosition = self.map.getWorldPosition(
randomTile)
self.fsm.changeCurrentState(
decisionMaking.GoToRandomPosition(
self.transform.position, worldDestinationPosition))
def plan_move(self, field):
if (self.state == state.IDLE):
if (len(field.power_cells) > 0):
self.state = state.COLLECT
elif (self.state == state.COLLECT):
# pick the target
if ((self.balls_held < self.ball_capacity) and (len(field.power_cells) > 0)):
nearest= self.find_nearest_ball(field.power_cells)
# get the heading (destination - current)
direction = glm.vec3(nearest.pos.center_pos - self.pos.center_pos);
self.pos.target = direction
#see if we're going to collide with another robot
draw_ray=[]
draw_ray.append(glm.vec3(0,-20,0)*self.pos.velocity)
angle_heading = draw.angleBetween(glm.vec3(0,-1,0), self.pos.heading)
ray_collisions = draw.collide_rays(field, draw_ray, self.pos.center_pos, angle_heading)
# if ray_collisions is not empty, we had a hit
# depending on where the hit was, we should turn left, right or decrease speed
# take a hard right, JIC
if (len(ray_collisions) > 0):
self.pos.heading = draw.rotate_vector(self.pos.heading, 1)
print ("Collision")
col_count = len(ray_collisions)
col=0
while (col < col_count):
print(ray_collisions[col].x, ray_collisions[col].y, ray_collisions[col].z)
col += 1
# get the distance (TODO: scale accel by distance)
distance = glm.distance(nearest.pos.center_pos, self.pos.center_pos);
if (distance > self.width/2):
print ("nearest %d %d %d %d %d %d %d %d" %(nearest.id, nearest.pos.center_pos.x, nearest.pos.center_pos.y, distance, self.pos.target.x, self.pos.target.y, direction.x, direction.y))
# TODO: set accel rate based on distance to target
self.pos.accelleration += self.max_accel/20
if (self.pos.accelleration > self.max_accel):
self.pos.accelleration = self.max_accel
# adjust the velocity to velocity += (accelrate/30)
self.pos.velocity += self.pos.accelleration
# limit velocity to top speed
if (self.pos.velocity > self.top_speed):
self.pos.velocity = self.top_speed
if (self.pos.velocity < 0):
self.pos.velocity = 0
print ("velocity now %d %d"%(self.pos.velocity, self.top_speed))
else:
print ("Caught %d"%(nearest.id))
self.pos.velocity = 0
self.pos.accelleration = 0;
self.balls_held += 1
field.remove_ball(nearest.id)
else:
self.state = state.FIRE
elif (self.state == state.FIRE):
# get the heading (destination - current)
direction = glm.vec3(self.firing_target - self.pos.center_pos);
# convert it to a scale of 1
#direction = glm.normalize(direction);
self.pos.target = direction
# get the distance (TODO: scale accel by distance)
distance = glm.distance(self.firing_target, self.pos.center_pos);
if (distance > self.firing_range):
# TODO: set accel rate based on distance to target
self.pos.accelleration = self.max_accel
# adjust the velocity to velocity += (accelrate/30)
self.pos.velocity += (self.pos.accelleration*(1/20))
# limit velocity to top speed
if (self.pos.velocity > self.top_speed):
self.pos.velocity = self.top_speed
if (self.pos.velocity < 0):
self.pos.velocity = 0
else:
# in firing range
if (self.firing_timer == 0):
self.firing_timer = (time.time()*1000)+self.firing_rate
if (self.firing_timer <= (time.time()*1000)):
self.pos.velocity = 0
self.pos.accelleration = 0
self.balls_held -= 1
self.firing_timer = 0
shot_val = random.random();
if (shot_val < self.firing_accuracy):
# handle scoring
# ball goes to queue for re-introduction
print("Hit")
else:
# ball goes back to field
# angle of deflection and 1/2 launching speed
print("Miss")
if (self.balls_held == 0):
self.state = state.IDLE
