def calculate_start(sprite, mouse_location): mouse_x, mouse_y = mouse_location sprite_center = [sprite.rect.centerx, sprite.rect.centery] move_vector = [ mouse_x - sprite.rect.centerx, mouse_y - sprite.rect.centery ] # normalize the move vector unit_move_vector = [ move_vector[0] / vector.length(move_vector), move_vector[1] / vector.length(move_vector) ] # calculate distance between the center of the player and the potential bullet start point distance = vector.distance(sprite_center, [ sprite_center[0] + unit_move_vector[0], sprite_center[1] + unit_move_vector[1] ]) # One number above the radius of the circle circumscribing the player sprite radius = hitbox_radius = math.ceil( (sprite.image.get_width() / 2) * math.sqrt(2)) # ensure that the bullet starts outside of the player hitbox while distance < hitbox_radius: move_vector = vector.multiply_scalar(unit_move_vector, radius) distance = vector.distance(sprite_center, [ sprite_center[0] + move_vector[0], sprite_center[1] + move_vector[1] ]) radius += 1 # raise me to lower iterations but possibly increase start distance return sprite_center[0] + move_vector[0], sprite_center[ 1] + move_vector[1]
def check_collision(): global colli_point vecd0 = vector.sub(colli_point[0],[ball.x, ball.y]) vecd1 = vector.sub(colli_point[1],[ball.x, ball.y]) if vector.distance(colli_point[0], [ball.x,ball.y]) <= 60: return colli_point[0] elif vector.distance(colli_point[1], [ball.x,ball.y]) <= 60: return colli_point[1] else: return None
def test_distance(self): vec1 = Vector2f(1.0, 0.0) vec2 = Vector2f(0.0, 1.0) self.assertEqual(distance(vec1, vec2), sqrt(2), "Dist1 failed") vec1 = Vector2f(0.0, 0.0) vec2 = Vector2f(0.0, 0.0) self.assertEqual(distance(vec1, vec2), 0.0, "Dist2 failed") vec1 = Vector2f(0.2314320, 0.3242123) vec2 = Vector2f(-0.2342343, 0.0324121) self.assertEqual(round(distance(vec1, vec2), 5), 0.54954, "Dist3 failed")
def detectLines(frame): gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) edges = cv2.Canny(gray, 10, 100, apertureSize=3) linesTemp = cv2.HoughLinesP(edges, 2, np.pi / 180, 100, maxLineGap=20, minLineLength=150) lines = [] middlePoints = [] for i in range(0, len(linesTemp)): x1, y1, x2, y2 = linesTemp[i][0] lines.insert(len(lines), linesTemp[i][0]) middlePoints.insert(len(middlePoints), ((x2 + x1) / 2, (y2 + y1) / 2, i)) ## Trazimo dve linije cija je udaljenost sredisnjih tacaka najveca longestDist = 0 firstLine = 0 secondLine = 0 for i in range(0, len(middlePoints)): for j in range(i, len(middlePoints)): x1, y1, pointNum1 = middlePoints[i] x2, y2, pointNum2 = middlePoints[j] longDistTemp = ((x2 - x1)**2 + (y2 - y2)**2)**(1 / 2.0) if longDistTemp > longestDist: firstLine = pointNum1 secondLine = pointNum2 longestDist = longDistTemp linesFinal = {} x1, y1, x2, y2 = lines[firstLine] firstMidPoint = ((x2 + x1) / 2, (y2 + y1) / 2) linesFinal['add'] = ((x1, y1), (x2, y2)) x1, y1, x2, y2 = lines[secondLine] secondMidPoint = ((x2 + x1) / 2, (y2 + y1) / 2) linesFinal['sub'] = ((x1, y1), (x2, y2)) if distance((20, 450), firstMidPoint) < distance( (20, 450), secondMidPoint): linesFinal['add'], linesFinal['sub'] = linesFinal['sub'], linesFinal[ 'add'] return linesFinal
def data_mean(): for d, vectors in g_dataSet.items(): for g in range (35): s = sample(g_dataSet_modify[d],3) v = vector_mean(s) g_dataSet_modify[d].append(v) g_dataSet[d].append(v) g_dataSet_modify[d] = g_dataSet_modify[d][-35:] g_dataSet[d] = g_dataSet[d][-35:] for i in range(2, len(g_dataSet[d])): distance_1 = distance(g_dataSet[d][i], g_dataSet[d][i - 1]) distance_2 = distance(g_dataSet[d][i], g_dataSet[d][i - 2]) if distance_1 > 8 and distance_2 > 8: g_dataSet_modify[d].remove(g_dataSet[d][i]) return g_dataSet_modify
def da_li_le_u_Rasponu(self, item): retVal = [] for obj in self.elements: distanca = distance(item['center'], obj['center']) if (distanca < 21): retVal.append(obj) return retVal
def inRange(r, item, items): # print item retVal = [] for obj in items: if (distance(item['center'], obj['center']) < r): retVal.append(obj) return retVal
def update_ball(dt): global t, v_init, can_play, Vx, Vy, has_colli, score_point, has_scored t += dt if has_colli is False: y = START_POS[1] + v_init[1]*t + 1/2*G*t*t if y < 0: y = 0 x = START_POS[0] + v_init[0]*t ball.y = y ball.x = x if v_init[1] > 0: Vy = (v_init[1] + G*t)/4 Vx = (v_init[0])/4 update_order(Vx,Vy,dt) if t > 2*v_init[1]/abs(G) and v_init[1] > 0: reset_ball() reset_time() else: y = START_POS[1] + v_init[1]*t + 1/2*G*t*t if y < 0: y = 0 x = START_POS[0] + v_init[0]*t ball.y = y ball.x = x if vector.distance([ball.x,ball.y],score_point) <= 50: has_scored = True if ball.y < 20 or t > 1.5: reset_ball() reset_time() has_colli = False
def move(self): # Get target from behind the leader target = self.leader.getPos() - normalize( self.leader.getV()) * self.params.followDist # Calculate desired direction steer = trunc(target - self.pos, self.params.maxF) # Truncate final steering vector and convert to acceleration steer = trunc(steer + self.repulsionF, self.params.maxF) acc = steer / self.params.mass * self.gParams.speed # Truncate final speed, slow down if necessary self.v = trunc(self.v + acc, self.params.maxV) dist = distance(self.pos, target) if dist < self.params.slowingD: self.v *= dist / self.params.slowingD # Calculate new position self.pos += self.v * self.gParams.speed # Update grid if necessary newLoc = Vector2f( floor(self.pos.x / 32) + 1, floor(self.pos.y / 32) + 1) if newLoc.x != self.loc.x or newLoc.y != self.loc.y: self.grid.remove(self, self.loc.x, self.loc.y) self.loc = newLoc self.grid.insert(self, self.loc.x, self.loc.y) # Set current angle for drawing self.orientation = self.v.angle() * 180 / pi
def inRange(r, item, items): retVal = [] for obj in items: mdist = distance(item['center'], obj['center']) if (mdist < r): retVal.append(obj) return retVal
def setView(self, bbox, side="front"): """Sets the camera looking at one of the sides of the bbox""" self.makeCurrent() center = (bbox[0] + bbox[1]) / 2 self.camera.setCenter(*center) size = bbox[1] - bbox[0] # print "size=",size if side == "front": hsize, vsize, depth = size[0], size[1], size[2] long, lat = 0.0, 0.0 elif side == "back": hsize, vsize, depth = size[0], size[1], size[2] long, lat = 180.0, 0.0 elif side == "right": hsize, vsize, depth = size[2], size[1], size[0] long, lat = 90.0, 0.0 elif side == "left": hsize, vsize, depth = size[2], size[1], size[0] long, lat = 270.0, 0.0 elif side == "top": hsize, vsize, depth = size[0], size[2], size[1] long, lat = 0.0, 90.0 elif side == "bottom": hsize, vsize, depth = size[0], size[2], size[1] long, lat = 0.0, -90.0 elif side == "iso": hsize = vsize = depth = vector.distance(bbox[1], bbox[0]) long, lat = 45.0, 45.0 # go to a distance to have a good view with a 45 degree angle lens dist = max(0.6 * depth, 1.5 * max(hsize / self.aspect, vsize)) self.camera.setEye(long, lat, dist) self.camera.setLens(45.0, self.aspect) self.camera.setClip(0.1 * dist, 10 * dist) self.camera.loadProjection()
def update_order(Vx,Vy,dt): global t, v_init, has_scored, colli_point, START_POS, has_colli, score_point if v_init[1] > 0: if t > v_init[1]/abs(G): # is falling ball.group = mid # change gourp basket[1].group = front #if check_collision() != None: # if collide #reset_time() #reset_ball() #time.sleep(0.2) if check_collision() == colli_point[0]: has_colli = True reset_time() vec1 = vector.sub([ball.x, ball.y],colli_point[0]) vec1 = vector.vec_x_float(vec1,2) v_init = vector.add(vec1,[Vx,Vy]) v_init = vector.vec_x_float(v_init,5) START_POS[0] = ball.x START_POS[1] = ball.y elif check_collision() == colli_point[1]: has_colli = True reset_time() vec1 = vector.sub([ball.x, ball.y],colli_point[1]) vec1 = vector.vec_x_float(vec1,2) v_init = vector.add(vec1,[Vx,Vy]) v_init = vector.vec_x_float(v_init,5) START_POS[0] = ball.x START_POS[1] = ball.y if vector.distance([ball.x,ball.y],score_point) <= 50: has_scored = True else: ball.group = front basket[1].group = mid
def knn_classify(k: int, labeled_points: List[LabeledPoint], new_point: Vector) -> str: by_distance = sorted(labeled_points, key=lambda lp: distance(lp.point, new_point)) k_nearest_labels = [lp.label for lp in by_distance[:k]] return majority_vote(k_nearest_labels)
def predict_by_knn_dist(p_v1, p_k=7): near = [] for digit in g_data_set: for v2 in g_data_set[digit]: dist = distance(p_v1, v2) near.append((dist, digit)) near.sort() return knn_by_majority(near[:p_k])
def __init__(self, terrain): pos = terrain.start.origin tiles = terrain.surrounding_tiles(terrain.start, multiplier=2) for tile in tiles: if tile.color == colors['road']: direction = vector.unit( vector.distance(tile.pos, terrain.start.pos)) super().__init__(pos, 1, direction, 10, 20, colors['blue'])
def enemies_on_range(self): on_range = [] for enemy in self.terrain.enemy_group: distance_vector = vector.distance(enemy.origin, self.origin) mag = vector.mag(distance_vector) if mag < self.range + enemy.radius: on_range.append(enemy) return on_range
def calculate_start(sprite, mouse_location): mouse_x, mouse_y = mouse_location sprite_center = [sprite.rect.centerx, sprite.rect.centery] move_vector = [mouse_x - sprite.rect.centerx, mouse_y - sprite.rect.centery] # normalize the move vector unit_move_vector = [move_vector[0] / vector.length(move_vector), move_vector[1] / vector.length(move_vector)] # calculate distance between the center of the player and the potential bullet start point distance = vector.distance(sprite_center, [sprite_center[0] + unit_move_vector[0], sprite_center[1] + unit_move_vector[1]]) # One number above the radius of the circle circumscribing the player sprite radius = hitbox_radius = math.ceil((sprite.image.get_width()/2) * math.sqrt(2)) # ensure that the bullet starts outside of the player hitbox while distance < hitbox_radius: move_vector = vector.multiply_scalar(unit_move_vector, radius) distance = vector.distance(sprite_center, [sprite_center[0] + move_vector[0], sprite_center[1] + move_vector[1]]) radius += 1 # raise me to lower iterations but possibly increase start distance return sprite_center[0] + move_vector[0], sprite_center[1] + move_vector[1]
def inRange( r, item, items ): # inRange fja proverava da li ima brojeva u okolini trenutnog broja retVal = [] for obj in items: mdist = distance(item['center'], obj['center']) if (mdist < r): retVal.append(obj) return retVal
def predict_by_knn_or(p_v1, k=1): global g_new_data_set all_dist = [] g_new_data_set = data_by_or() for digit in g_new_data_set: dist = distance(p_v1, g_new_data_set[digit][0]) all_dist.append((dist, digit)) all_dist.sort() return all_dist[0][1]
def rotate_cannon(self, enemy): distance_vector = vector.distance(enemy.origin, self.origin) angle = vector.angle(self.barrel_axis, distance_vector) if distance_vector[0] > 0: angle *= -1 rot_image = pygame.transform.rotate(self.original_cannon_image, angle) rot_rect = self.original_cannon_image_rect.copy() rot_rect.center = rot_image.get_rect().center rot_image = rot_image.subsurface(rot_rect).copy() self.rotated_cannon = rot_image
def radar(self, object): """ Returns all objects within a certain radius of a position @param position: Position of the object to get radar @param range: Range of the radar """ pings = [] for x in self.objects.itervalues(): if hasattr(x, 'owner'): if x.owner != object.owner: if distance(object.position, x.position) <= \ Constants.scan_range: pings.append(x) else: if distance(object.position, x.position) <= \ Constants.scan_range: pings.append(x) return pings
def inRange(r, item): retVal = [] for obj in global_contours: x1, y1, w1, h1 = cv2.boundingRect(item) x2, y2, w2, h2 = cv2.boundingRect(obj) mdist = distance((x1, y1), (x2, y2)) if (mdist < r): return True global_contours.append(item) return False
def shouldFireProjectile(window): '''Returns true on mouse click (which is > 10px away from last click)''' mousePoint = window.checkMouse() if mousePoint != None: x1 = shouldFireProjectile.oldPos.x x2 = mousePoint.x y1 = shouldFireProjectile.oldPos.y y2 = mousePoint.y if vector.distance(x1, y1, x2, y2) > 10: shouldFireProjectile.oldPos = mousePoint return True, mousePoint return False, shouldFireProjectile.oldPos
def find_eigenvector(A, tolerance=0.00001): guess = [1 for __ in A] while True: result = matrix_operate(A, guess) length = magnitude(result) next_guess = scalar_multiply(1 / length, result) if distance(guess, next_guess) < tolerance: return next_guess, length # eigenvector, eigenvalue guess = next_guess
def compare_square_normals(self, square, dim): """ Increments the score of two squares based on how parallel their normal vectors are. :param square: :param dim: the dimensions of the image :return: nothing """ # Using 1-cross product due to larger change of sin when parallel temp_cross = cross(self.normal, square.normal) edge = False for point in square.corners: if point[0][0] < 1 or point[0][0] > dim[1] - 2 or point[0][1] < 1 \ or point[0][1] > dim[0] - 2: # Contours on the edge don't improve scores edge = True if not edge: # Increment the score self.score += 1 - abs(distance(temp_cross) / (distance(square.normal)*distance(self.normal)))
def move(self): if self.controlled: self.v = normalize(self.v) * self.params.maxV elif self.seeking: self.seek() else: self.wander() # New position is simply last position plus velocity (times simulation speed) self.pos += self.v * self.gParams.speed if self.seeking and distance(self.pos, self.target) < 10.0: self.seeking = False # Set current angle for drawing self.orientation = self.v.angle() * 180 / pi
def calcRepulsion(self, followers): self.repulsionF = Vector2f(0.0, 0.0) collisionChecks = 0 # Calculate evasion from neighbours that are too close for i in self.grid.getNeighbours(self.loc.x, self.loc.y): d = distance(self.pos, i.pos) collisionChecks += 1 if d < self.params.separationD and d != 0.0: self.repulsionF += (self.pos - i.getPos()) * self.params.separationD / d # Evade leader if necessary fLeader = self.leader.getPos() + normalize( self.leader.getV()) * self.params.followDist d = distance(self.pos, fLeader) if d < self.params.followDist and d != 0.0: self.repulsionF += (self.pos - fLeader) * self.params.followDist / d d = distance(self.pos, self.leader.getPos()) if d < self.params.followDist and d != 0.0: self.repulsionF += (self.pos - self.leader.getPos() ) * 2 * self.params.followDist / d return collisionChecks
def repair_ship(self, ship_id): """ Repair a ship, adding repair_percent ship health per turn used. @type ship: Ship object @param ship: A ship object to add health to """ from game_instance import game ship = game.game_map.ships[ship_id] if distance(self.position, ship.position) < Constants.base_repair_radius: ship.health += Constants.repair_percent * Constants.ship_health if ship.health > Constants.ship_health: ship.health = Constants.ship_health
def line_of_sight(self,level,playerPos): #check all nodes between the player and the enemy to see if there #is a wall in the way rel = vector.normalized(vector.add([playerPos[1],playerPos[0]],vector.negative(self.pos))) checkPos = self.pos for i in 10 * range(int(math.floor(vector.distance([playerPos[1],playerPos[0]],self.pos))) - 1): checkPos = vector.add(checkPos,[rel[0] * 0.1,rel[1] * 0.1]) if not level.map[int(math.floor(checkPos[1]))][int(math.floor(checkPos[0]))] == 0: return False return True
def create_ship(self, position): """ Construct a ship. @type: tuple @param position: location the player wants the object at """ # if outside build radius, move position in if distance(self.planet.position, position) > Constants.build_radius: mag = hypot(*position) position = (position[0]*(Constants.build_radius/mag), position[1]*(Constants.build_radius/mag)) new_ship = Ship(position, self.owner) self.owner.resources -= Constants.ship_price return new_ship
def compare_square_normals(self, square, dim): """ Increments the score of two squares based on how parallel their normal vectors are. :param square: :param dim: the dimensions of the image :return: nothing """ # Using 1-cross product due to larger change of sin when parallel temp_cross = cross(self.normal, square.normal) edge = False for point in square.corners: if point[0][0] < 1 or point[0][0] > dim[1] - 2 or point[0][1] < 1 \ or point[0][1] > dim[0] - 2: # Contours on the edge don't improve scores edge = True if not edge: # Increment the score self.score += 1 - abs( distance(temp_cross) / (distance(square.normal) * distance(self.normal)))
def nadjiNajblizi2(broj, odgovarajuciBrojevi): minDistance = math.hypot( broj['center'][0] - odgovarajuciBrojevi[0]['center'][0], broj['center'][1] - odgovarajuciBrojevi[0]['center'][1]) najblizi = odgovarajuciBrojevi[0] for br in odgovarajuciBrojevi: dist = math.hypot(br['center'][0] - broj['center'][0], br['center'][1] - broj['center'][1]) if dist < minDistance: najblizi = br minDistance = distance(br['center'], broj['center']) return najblizi
def collides(self, other): """Checks if this shape collides with another Args: other: the shape to test collision against Returns: True if the two shapes collide, False if they do not """ # Start with a bounding circle test, using the effective # lengths as radii for the circles. If we don't at least # pass this, then the shapes don't collide, and we skip # doing the more computationally expensive collision test if distance(self.pos, other.pos) > (self.effective_length + other.effective_length): return False # We passed the bounding circle test, so we now need to do the # more accurate test for collision, using the separating axis # theorem # First grab the transformed (world-space) vertices of each # shape. Then, grab the axes, which are normalized vectors # perpendicular to each side verts1 = self._get_transformed_verts() verts2 = other._get_transformed_verts() axes1 = generate_axes(verts1) axes2 = generate_axes(verts2) # Loop over each set of axes, and project both shapes onto # each axis. If they don't overlap on the axis, the shapes do # not collide for axis in axes1: proj1 = project(verts1, axis) proj2 = project(verts2, axis) if not proj1.overlaps(proj2): return False for axis in axes2: proj1 = project(verts1, axis) proj2 = project(verts2, axis) if not proj1.overlaps(proj2): return False # If we got this far, the shapes overlap on each axis, # and the shapes collide return True
def update(self, targetLocation, targetAim, targetMomentum, shooting): for index, effect in enumerate(self.statusEffects): effect.update(self, targetLocation, targetAim, targetMomentum, shooting, effectIndex=index) self.weapon.cool() d = distance(targetLocation, self.position) if d < FORMATION_LOCK_DISTANCE: self.lock() else: self.unlock() def easeMomentum(targetMomentum, c): goalmomentum = self.momentum.mult(1-c) + targetMomentum.mult(c) diff = goalmomentum - self.momentum diff.crop_ip(self.thrust) self.propel(diff) def easePosition(target, c): newpos = self.position.mult(1-c) + target.mult(c) self.position = newpos if not self.islocked: #when not already locked into formation, move toward the assigned position goal = targetLocation - self.position timeestimate = sqrt(d/max(self.momentum.magnitude,self.maxSpeed/2)) goal += (targetMomentum - self.momentum).mult(timeestimate) easeMomentum(goal, 0.2) if d > (4 * FORMATION_LOCK_DISTANCE): #when close to locking into formation, aim in the assigned direction goalaimvector = goal.unit self.aim = goalaimvector.direction else: #otherwise aim toward destination self.aim = targetAim if self.islocked: self.momentum = targetMomentum self.aim = targetAim easePosition(targetLocation,0.5) if shooting: self.shoot() #update image based on new aim self.image = pygame.transform.flip(pygame.transform.rotate(self.originalimage,degrees(float(self.aim))),False,True) self.rect = self.image.get_rect() self.position += self.momentum
def update(self, dt, level, playerPos): if self.timer > 0: self.timer -= 1 * dt if self.timer < 0: self.timer = 0 relplayer = vector.add([playerPos[1], playerPos[0]], vector.negative(self.pos)) if self.line_of_sight(level, playerPos): #move directly at the player if they can be seen if vector.length(relplayer) > 0.2: reldir = vector.normalized(relplayer) self.pos = vector.add( self.pos, [reldir[0] * self.speed * dt, reldir[1] * self.speed * dt]) else: #update the target position if the player moves to far away #from the original target position if len(self.nodes) == 0 or vector.distance( self.pos, self.nodes[len(self.nodes) - 1]) > 2: self.find_path(level, playerPos) else: #get the direction to move in rel = vector.add(self.nodes[len(self.nodes) - 1], vector.negative(self.pos)) #set the position to the vector if moving one step will cause #the enemy to move over the node if vector.length(rel) < self.speed * dt: self.pos = self.nodes[len(self.nodes) - 1] #return subset of original that doesn't include the first entry self.nodes.remove(self.nodes[len(self.nodes) - 1]) else: #move towards the node rel = vector.normalized(rel) self.pos = vector.add( self.pos, [rel[0] * self.speed * dt, rel[1] * self.speed * dt])
def line_of_sight(self, level, playerPos): #check all nodes between the player and the enemy to see if there #is a wall in the way rel = vector.normalized( vector.add([playerPos[1], playerPos[0]], vector.negative(self.pos))) checkPos = self.pos for i in 10 * range( int( math.floor( vector.distance([playerPos[1], playerPos[0]], self.pos))) - 1): checkPos = vector.add(checkPos, [rel[0] * 0.1, rel[1] * 0.1]) if not level.map[int(math.floor(checkPos[1]))][int( math.floor(checkPos[0]))] == 0: return False return True
def predict(p_vec): knn=[] for d,vectors in g_dataSet_modify.items(): cnt = 0 for v in vectors: dist = distance(v, p_vec) if dist > 15: cnt = cnt + 1 if cnt > 2: break knn.append((dist, d)) knn.sort() nearest = knn[:9] nearest_data = [] for i in nearest: nearest_data.append(i[1]) c = Counter(nearest_data) for i in c.most_common(1): nearest_number = i[0] return nearest_number
def K_NN(p_dataset, test_vector, n, flag): data_list = sorted(list(p_dataset.items())) judge_list = [] for i in data_list: for j in i[1]: vec_dis = distance(j, test_vector) judge_list.append((vec_dis, i[0])) judge_list.sort() # For testing # print(len(judge_list)) if flag == 'f': answer_list = [] for m in range(n): answer_list.append(judge_list[m][1]) return answer_list[0] elif flag == 'm': answer_list = [] for m in range(n): answer_list.append(judge_list[m][1]) con_list = Counter(answer_list) return con_list.most_common()[0][0] elif flag == 'a': answer_list = [] answer_dict = {} for m in range(n): answer_list.append(judge_list[m]) for a in answer_list: if answer_dict.get(a[1], 0) == 0: answer_dict[a[1]] = [a[0]] else: answer_dict[a[1]].append(a[0]) answer_list = [(sum(answer_dict[k]) / len(answer_dict[k]), k) for k in sorted(answer_dict.keys())] answer_list.sort() return answer_list[0][1]
def update(self,dt,level,playerPos): if self.timer > 0: self.timer -= 1 * dt if self.timer < 0: self.timer = 0 relplayer = vector.add([playerPos[1],playerPos[0]],vector.negative(self.pos)) if self.line_of_sight(level,playerPos): #move directly at the player if they can be seen if vector.length(relplayer) > 0.2: reldir = vector.normalized(relplayer) self.pos = vector.add(self.pos,[reldir[0] * self.speed * dt, reldir[1] * self.speed * dt]) else: #update the target position if the player moves to far away #from the original target position if len(self.nodes) == 0 or vector.distance(self.pos,self.nodes[len(self.nodes) - 1]) > 2: self.find_path(level,playerPos) else: #get the direction to move in rel = vector.add(self.nodes[len(self.nodes) - 1],vector.negative(self.pos)) #set the position to the vector if moving one step will cause #the enemy to move over the node if vector.length(rel) < self.speed * dt: self.pos = self.nodes[len(self.nodes) - 1] #return subset of original that doesn't include the first entry self.nodes.remove(self.nodes[len(self.nodes) - 1]) else: #move towards the node rel = vector.normalized(rel) self.pos = vector.add(self.pos,[rel[0] * self.speed * dt,rel[1] * self.speed * dt])
def validate_base_action(action, player, turn, resource_counter): """ Validate an action performed by a base @param action: Action to validate @param player: The player that requested the action """ # make sure a base action h as all required keys attrs = ["command", "obj_id", "args"] for attr in attrs: if attr not in action.keys(): return {"success": False, "message": "base action requires a %s attribute" % attr} # attempt to coerce the obj_id to int try: obj_id = action["obj_id"] except: return {"success": False, "message": "invalid base id"} # check if base exists base = None for planet in game.game_map.planets.itervalues(): if obj_id == id(planet.base): base = planet.base if base == None: return {"success": False, "message": "base does not exist"} # make sure the player owns the base if base.owner != player: return {"success": False, "message": "not authenticated for that base"} # check to see if base is active if base.built > 0: return {"success": False, "message": "base is under construction"} # check if the base is busy if base.busy != 0: return {"success": False, "message": "base is busy"} # make sure args is a dict if not isinstance(action["args"], dict): return {"success": False, "message": "args must be a object"} if action["command"] == "create_ship": if "position" not in action["args"].keys(): return {"success": False, "message": "create_ship requires position arg"} elif not isinstance(action["args"]["position"], list): return {"success": False, "message": "position must be list"} elif resource_counter - Constants.ship_price < 0: return {"success": False, "message": "not enough resources"} position = action["args"]["position"] if distance(position, base.position) > Constants.base_build_radius: return {"success": False, "message": "too far away to build ship"} else: position = action["args"]["position"] try: (a, b) = (position[0], position[1]) except: return {"success": False, "message": "invalid position values"} result = {"object": base, "method": action["command"], "params": extract(["position"], action["args"])} with game.action_list_lock: game.actions[turn][player.auth].append(result) base.busy = Constants.base_build_busy resource_counter -= Constants.ship_price return {"success": True, "message": "success"} elif action["command"] == "salvage_ship": if "ship_id" not in action["args"].keys(): return {"success": False, "message": "salvage_ship requires ship_id arg"} else: ship_id = action["args"]["ship_id"] if not isinstance(ship_id, int): return {"success": False, "message": "ship must be int"} ship = game.game_map.ships[ship_id] if distance(ship.position, base.position) > Constants.base_salvage_radius: return {"success": False, "message": "too far away to salvage ship"} result = {"object": base, "method": action["command"], "params": extract(["ship_id"], action["args"])} with game.action_list_lock: game.actions[turn][player.auth].append(result) base.busy = Constants.base_salvage_busy return {"success": True, "message": "success"} elif action["command"] == "repair_ship": if "ship_id" not in action["args"].keys(): return {"success": False, "message": "repair_ship requires ship_id arg"} else: ship_id = action["args"]["ship_id"] if not isinstance(ship_id, int): return {"success": False, "message": "ship must be int"} ship = game.game_map.ships[ship_id] if distance(ship.position, base.position) > Constants.base_repair_radius: return {"success": False, "message": "too far away to repair ship"} elif ship.health == Constants.base_health: return {"success": False, "message": "ship already at full health"} result = {"object": base, "method": action["command"], "params": extract(["ship_id"], action["args"])} with game.action_list_lock: game.actions[turn][player.auth].append(result) base.busy = Constants.base_repair_busy return {"success": True, "message": "success"} elif action["command"] == "destroy": result = {"object": base, "method": action["command"], "params": {}} with game.action_list_lock: game.actions[turn][player.auth].append(result) return {"success": True, "message": "success"} else: return {"success": False, "message": "invalid base command"}
def intersection(self, segment): closest_point = segment.closest_point(self.center) if distance(closest_point, self.center) <= self.radius: return closest_point else: return None
#rotate the direction and the plane so that it stays perpendicular to the direction player.dir = vector.rotate(player.dir,turnSpeed * dt) player.plane = vector.rotate(player.plane,turnSpeed * dt) if keys_pressed[K_RIGHT]: #rotate the direction and the plane so that it stays perpendicular to the direction player.dir = vector.rotate(player.dir,-turnSpeed * dt) player.plane = vector.rotate(player.plane,-turnSpeed * dt) for entity in level.entities: #enter the shop if the player goes close enough to the object that represents it if health > 0 and wave_num < len(waves): if not entity.__class__.__name__ == "Explosion" and entity.type == 3: #allow the player to move away from the shop once they exit the shop gameState if vector.distance(entity.pos, [player.pos[1],player.pos[0]]) < 0.5: if shop == False: shop = True gameState = 'shop' else: shop = False if entity.__class__.__name__ == "Explosion" and entity.life == 0 and entity.timer == 0: #the first frame that the explosion is updated #damage the player if they are too close to te explosion if vector.distance(entity.pos, [player.pos[1],player.pos[0]]) < 1.5: if health >= 8 / (defense_multiplyer * (1.05 ** defense_upgrades)): health -= 8 / (defense_multiplyer * (1.05 ** defense_upgrades)) else: health = 0 dmg_timer = 0.35
#rotate the direction and the plane so that it stays perpendicular to the direction player.dir = vector.rotate(player.dir, turnSpeed * dt) player.plane = vector.rotate(player.plane, turnSpeed * dt) if keys_pressed[K_RIGHT]: #rotate the direction and the plane so that it stays perpendicular to the direction player.dir = vector.rotate(player.dir, -turnSpeed * dt) player.plane = vector.rotate(player.plane, -turnSpeed * dt) for entity in level.entities: #enter the shop if the player goes close enough to the object that represents it if health > 0 and wave_num < len(waves): if not entity.__class__.__name__ == "Explosion" and entity.type == 3: #allow the player to move away from the shop once they exit the shop gameState if vector.distance(entity.pos, [player.pos[1], player.pos[0]]) < 0.5: if shop == False: shop = True gameState = 'shop' else: shop = False if entity.__class__.__name__ == "Explosion" and entity.life == 0 and entity.timer == 0: #the first frame that the explosion is updated #damage the player if they are too close to te explosion if vector.distance(entity.pos, [player.pos[1], player.pos[0]]) < 1.5: if health >= 8 / (defense_multiplyer * (1.05**defense_upgrades)): health -= 8 / (defense_multiplyer * (1.05**defense_upgrades))
def fire(self, direction): from game_instance import game """Fire at angle relative to the ship's direction. The laser is instant and is a rectangle with a width of 10 and a length of self.weapon_strength. Any object that intersects that rectatngle takes damage. @param direction: vector to fire at """ from asteroid import Asteroid from planet import Planet from ship import Ship width = Constants.weapon_width length = self.weapon_range mag = hypot(*direction) if mag != 0: normalized = (direction[0]*(length/mag),direction[1]*(length/mag)) else: normalized = (0,0) angle = atan2(*direction) w = width/2 # Four points, counter clockwise p_0 = (self.position[0] + w * cos(angle), self.position[1] + w * -sin(angle)) p_3 = (self.position[0] + w * -cos(angle), self.position[1] + w * sin(angle)) p_1 = (p_0[0] + length * sin(angle), p_0[1] + length * cos(angle)) p_2 = (p_3[0] + length * sin(angle), p_3[1] + length * cos(angle)) # rectangle of laser beam beam = (p_0, p_1, p_2, p_3) within_beam = [] # list for objects in beam for obj in game.game_map.objects.itervalues(): hit = circle_in_rect((obj.position, obj.size), beam) if hit and obj != self: within_beam.append(obj) if len(within_beam) == 0: # No object hit self.events.append({'type':'shot','hit': None}) else: cmp_dist = lambda a: distance(self.position, a.position) within_beam.sort(key=cmp_dist) for o in within_beam: if isinstance(o, Planet) or isinstance(o, Asteroid): if hasattr(o,'base') and o.base != None: if o.base.owner == self.owner: within_beam.remove(o) if hasattr(o, 'refinery') and o.refinery != None: if o.refinery.owner == self.owner: within_beam.remove(o) if len(within_beam) == 0: # No object hit self.events.append({'type':'shot','hit': None}) else: # Hit first in line, record id hit = within_beam[0] for o in within_beam: for i in within_beam: if isinstance(o, Ship) and o != i: if circle_collision((o.position, o.size),(i.position, i.size)): hit = o if hasattr(hit, 'base') and hit.base != None: hit = hit.base if hasattr(hit, 'refinery') and hit.refinery != None: hit = hit.refinery self.events.append({'type':'shot', 'hit': id(hit),'obj_type':hit.__class__.__name__}) # register damage with hit object diagonal = distance(self.position, p_2) dist = distance(self.position, hit.position) damage_amt = Constants.weapon_strength hit.events.append({'type':'damage', 'amount':damage_amt, 'hit_by':id(self)}) with game.lasers_shot_lock: game.lasers_shot[game.turn].append({'start': self.position, 'direction':normalized})
def validate_ship_action(action, player, turn, resource_counter): """Valide an action performed by a ship @param action: Action to validate @param player: The player that requested the action """ # make sure a ship action has all required keys attrs = ["command", "obj_id", "args"] for attr in attrs: if attr not in action.keys(): return {"success": False, "message": "ship action requires a %s attribute" % attr} # attempt to coerce the obj_id to int try: obj_id = action["obj_id"] except: return {"success": False, "message": "invalid ship id"} # check if ship exiss if obj_id in game.game_map.ships.keys(): ship = game.game_map.ships[obj_id] else: return {"success": False, "message": "ship does not exist"} # make sure the player owns the ship if ship.owner != player: return {"success": False, "message": "not authenticated for that ship"} # make sure args is a dict if not isinstance(action["args"], dict): return {"success": False, "message": "args must be a object"} # validate commands if action["command"] == "thrust": if ship.methods_used["thrust"]: return {"success": False, "message": "thrust action already used"} elif "direction" not in action["args"].keys(): return {"success": False, "message": "thrust requires direction arg"} elif not isinstance(action["args"]["direction"], list): return {"success": False, "message": "direction must be list"} elif "speed" not in action["args"].keys(): return {"success": False, "message": "thrust requires speed arg"} elif not isinstance(action["args"]["speed"], Number): return {"success": False, "message": "speed must be Number"} else: accel = action["args"]["direction"] try: (a, b) = (accel[0], accel[1]) except: return {"success": False, "message": "invalid direction values"} result = { "object": ship, "method": action["command"], "params": extract(["direction", "speed"], action["args"]), } with game.action_list_lock: game.actions[turn][player.auth].append(result) ship.methods_used["thrust"] = True return {"success": True, "message": "success"} elif action["command"] == "fire": if ship.methods_used["fire"]: return {"success": False, "message": "fire action already used"} elif "direction" not in action["args"].keys(): return {"success": False, "message": "fire requires direction arg"} else: direction = action["args"]["direction"] if not isinstance(direction, list): return {"success": False, "message": "direction must be a list"} result = {"object": ship, "method": action["command"], "params": extract(["direction"], action["args"])} with game.action_list_lock: game.actions[turn][player.auth].append(result) ship.methods_used["fire"] = True return {"success": True, "message": "success"} elif action["command"] == "create_refinery": if ship.methods_used["create_refinery"]: return {"success": False, "message": "create_refinery action already used"} elif resource_counter - Constants.refinery_price < 0: return {"success": False, "message": "not enough resources"} elif "asteroid_id" not in action["args"].keys(): return {"success": False, "message": "create_refinery requires asteroid_id arg"} elif player.resources < Constants.refinery_price: return {"success": False, "message": "not enough resources!"} else: asteroid_id = action["args"]["asteroid_id"] if not isinstance(asteroid_id, int): return {"success": False, "message": "asteroid_id must be int"} asteroid = game.game_map.asteroids[asteroid_id] if distance(ship.position, asteroid.position) > Constants.ship_build_radius: return {"success": False, "message": "too far away from asteroid"} if asteroid.refinery != None: return {"success": False, "message": "asteroid already has a refinery"} result = {"object": ship, "method": action["command"], "params": extract(["asteroid_id"], action["args"])} # TODO Check if another ship has built a base/refinery with game.action_list_lock: game.actions[turn][player.auth].append(result) ship.methods_used["create_refinery"] = True resource_counter -= Constants.refinery_price return {"success": True, "message": "success"} elif action["command"] == "create_base": if ship.methods_used["create_base"]: return {"success": False, "message": "create_base action already used"} elif turn == 0: return {"success": False, "message": "create_base action can't be used first turn"} elif resource_counter - Constants.base_price < 0: return {"success": False, "message": "not enough resources"} elif "planet_id" not in action["args"].keys(): return {"success": False, "message": "create_base requires planet_id arg"} else: planet_id = action["args"]["planet_id"] if not isinstance(planet_id, int): return {"success": False, "message": "planet must be int"} planet = game.game_map.planets[planet_id] if distance(ship.position, planet.position) > Constants.ship_build_radius: return {"success": False, "message": "too far away from planet"} if planet.base != None: return {"success": False, "message": "planet already has a base"} result = {"object": ship, "method": action["command"], "params": extract(["planet_id"], action["args"])} with game.action_list_lock: game.actions[turn][player.auth].append(result) ship.methods_used["create_base"] = True resource_counter -= Constants.base_price return {"success": True, "message": "success"} else: return {"success": False, "message": "invalid ship command"}