def agent_update(): temp_agent_array = [] for i in range(len(shared.agent_array)): agent = shared.agent_array[i] temp_vel = (0, 0) cohesion_v = compute_cohesion(agent, i % 2) alignment_v = compute_alignment(agent, i % 2) seperation_v = compute_seperation(agent, i % 2) obstacle_dodge_v = compute_obstacle_dodge(agent) v_array = [ agent.vel, v_mul(cohesion_v, COHESION_WEIGHT[i % 2]), v_mul(alignment_v, ALIGNMENT_WEIGHT[i % 2]), v_mul(seperation_v, SEPERATION_WEIGHT[i % 2]), v_mul(obstacle_dodge_v, OBSTACLE_DOGDGE_WEIGHT) ] temp_vel = v_array_sum(v_array) temp_vel = v_mul(temp_vel, shared.FPS) a = Agent(agent.pos, temp_vel) if i % 2: a.vel = limit(temp_vel, DEFAULT_SPEED + 6 + shared.speed_adjustment) else: a.vel = limit(temp_vel, DEFAULT_SPEED + shared.speed_adjustment) # change_vel_if_zero(a) a.update_pos() temp_agent_array.append(a) shared.agent_array = temp_agent_array
def agent_update(): global agent_array temp_agent_array = [] if freeze: return for i in xrange(0, len(agent_array)): agent = agent_array[i] temp_vel = (0, 0) cohesion_v = computeCohesion(agent, i % 2) alignment_v = computeAlignment(agent, i % 2) seperation_v = computeSeperation(agent, i % 2) obstacle_dodge_v = computeObscatleDodge(agent) v_array = [ agent.vel, utils.v_mul(cohesion_v, COHESION_WEIGHT[i % 2]), utils.v_mul(alignment_v, ALIGNMENT_WEIGHT[i % 2]), utils.v_mul(seperation_v, SEPERATION_WEIGHT[i % 2]), utils.v_mul(obstacle_dodge_v, OBSTACLE_DOGDGE_WEIGHT) ] temp_vel = utils.v_array_sum(v_array) a = Agent(agent.pos, temp_vel) if i % 2: a.vel = utils.limit(temp_vel, DEFAULT_SPEED + 6 + speed_adjustment) else: a.vel = utils.limit(temp_vel, DEFAULT_SPEED + speed_adjustment) # utils.change_vel_if_zero(a) a.updatePos() temp_agent_array.append(a) agent_array = temp_agent_array
async def run_spaceship( canvas, start_row, start_column, gun_activation_year=2020): row, column = start_row, start_column row_speed = column_speed = 0 canvas_height, canvas_width = canvas.getmaxyx() while True: current_frame = spaceship_frame rows_direction, columns_direction, space_pressed = read_controls( canvas=canvas, ) row_speed, column_speed = update_speed( row_speed=row_speed, column_speed=column_speed, rows_direction=rows_direction, columns_direction=columns_direction, ) row += row_speed column += column_speed frame_height, frame_width = get_frame_size(current_frame) row = limit( value=row, min_value=1, max_value=canvas_height - frame_height - 1, ) column = limit( value=column, min_value=1, max_value=canvas_width - frame_width - 1, ) draw_frame(canvas, row, column, current_frame) if space_pressed and row > 1 and year >= gun_activation_year: coroutines.append( animate_gun_shot( canvas=canvas, start_row=row - 1, start_column=column + 2, ) ) await sleep() draw_frame(canvas, row, column, current_frame, negative=True) for obstacle in obstacles: if obstacle.has_collision( obj_corner_row=row, obj_corner_column=column): coroutines.append( show_gameover(canvas=canvas), ) return
def arrive(self, target): """ Arrive Steering Behavior """ # Calculates vector desired self.desired = (target - self.location) # get the distance to the target d = self.desired.magnitude() try: dist = copy.deepcopy(self.desired.normalize()) # obtem direção except: # If the magnitude of desired is zero it cant be normalized dist = copy.deepcopy(self.desired) r = RADIUS_TARGET # Modulates the force if d < r: # close to target it will reduce velocty till stops # interpolation dist *= self.max_speed * (1 + 1 / r * (d - r)) else: dist *= self.max_speed # Steering force steer = dist - self.velocity #Limit the magnitude of the steering force. steer = limit(steer, self.max_force) # apply force to the vehicle self.applyForce(steer) # Simulates Wind - random Noise wind = vec2(random.uniform(-0.15, 0.15), random.uniform(-0.15, 0.15)) self.applyForce(wind) # Draws current target as a point pg.draw.circle(self.window, self.color_target, target, 5, 0)
def col_bullet_walls(self, bullet): # Set of tiles that are passable by bullets. # TODO: If you want your Hazard to leave Bullets through # insert Hazard.YourNewHazard can_pass = {Hazard.Empty} position = bullet.position tile_x = int(position[0] / TILE_SIZE) tile_x = utils.limit(tile_x, 0, Board.TILE_COUNT - 1) tile_y = int(position[1] / TILE_SIZE) tile_y = utils.limit(tile_y, 0, Board.TILE_COUNT - 1) if self.obstacleArray[tile_x][tile_y] not in can_pass: self.bullets.remove(bullet) return True return False
def generate_rss(): html_file = os.path.join(defs.STATIC_HTML_DIR, 'special', 'rss.xml') articles = utils.limit(fetch_articles_sorted(), defs.MAX_ARTICLES_RSS) last_updated = articles[0].published_date template_variables = { 'articles': articles, 'defs': defs, 'last_updated': last_updated, } html = render_template('rss-articles.xml', template_variables) utils.write_file(html_file, html) return html_file
def calculate_robot(self, poll, robot): """Uses current position data of robot robot and acceleration values polled from the robot to calculate new position values. """ # robot won't move while dead if robot.dead: return # unpack robot output a, a_alpha = poll # checks if acceleration is valid a = utils.limit(a, -robot.a_max, robot.a_max) # checks if angle acceleration is valid a_alpha = utils.limit(a_alpha, -robot.a_alpha_max, robot.a_alpha_max) # calculates velocities new_v = utils.limit(robot.v + a, -1 * robot.v_max, robot.v_max) new_v_alpha = utils.limit(robot.v_alpha + a_alpha, -1 * robot.v_alpha_max, robot.v_alpha_max) # calculate alpha and x and y component of v alpha = robot.alpha + new_v_alpha alpha = alpha % 360 radian = ((alpha - 90) / 180 * math.pi) dx = new_v * math.cos(radian) dy = new_v * math.sin(radian) # calculates the new position - factors in collisions col_data = self.col_robots_walls(robot, dx, dy, new_v, new_v_alpha) dx_col, dy_col, v_col, v_alpha_col = col_data new_position_col = (robot.x + dx_col, robot.y + dy_col, alpha, v_col, new_v_alpha) # finally, re-place the robot on the board Board.place_robot(robot, *new_position_col)
def collision_avoidance(self, all_positions, index): """ Not working yet """ aux = 0 for p in all_positions: if ((self.location - p.location).length() < AVOID_DISTANCE) and (aux != index): desired = vec2(self.max_speed, self.velocity.y) steer = desired - self.velocity steer = limit(steer, self.max_force) self.applyForce(steer) print(f'Alerta de colisão drone {index} com drone {aux}') break aux += 1
def compute_cohesion(myAgent, t): compute_vel = (0, 0) neighbors_cnt = 0 for i in range(len(shared.agent_array)): agent = shared.agent_array[i] if agent != myAgent and myAgent.distance_from( agent) < COHESION_RADIUS and t == i % 2: compute_vel = v_sub(agent.pos, myAgent.pos) neighbors_cnt += 1 if neighbors_cnt == 0: return compute_vel compute_vel = v_div(compute_vel, neighbors_cnt) return limit(compute_vel, 0.05)
def computeAlignment(myAgent, t): compute_vel = (0, 0) neighbors_cnt = 0 for i in xrange(0, len(agent_array)): agent = agent_array[i] if agent != myAgent and myAgent.distanceFrom( agent) < ALIGNMENT_RADIUS and t == i % 2: compute_vel = v_add(compute_vel, agent.vel) neighbors_cnt += 1 if neighbors_cnt == 0: return compute_vel compute_vel = v_div(compute_vel, neighbors_cnt) return utils.limit(compute_vel, 0.05)
def computeCohesion(myAgent, t): compute_vel = (0, 0) neighbors_cnt = 0 for i in xrange(0, len(agent_array)): agent = agent_array[i] if agent != myAgent and myAgent.distanceFrom( agent) < COHESION_RADIUS and t == i % 2: compute_vel = v_sub(agent.pos, myAgent.pos) neighbors_cnt += 1 if neighbors_cnt == 0: return compute_vel compute_vel = v_div(compute_vel, neighbors_cnt) return utils.limit(compute_vel, 0.05)
def compute_alignment(myAgent, t): compute_vel = (0, 0) neighbors_cnt = 0 for i in range(len(shared.agent_array)): agent = shared.agent_array[i] if agent != myAgent and myAgent.distance_from( agent) < ALIGNMENT_RADIUS and t == i % 2: compute_vel = v_add(compute_vel, agent.vel) neighbors_cnt += 1 if neighbors_cnt == 0: return compute_vel compute_vel = v_div(compute_vel, neighbors_cnt) return limit(compute_vel, 0.05)
def seek(self, target): """ Seek Steering force Algorithm """ try: self.desired = (target - self.location).normalize() * self.max_speed except: # if you try to normalize a null vector it will catch self.desired = (target - self.location) * self.max_speed # Calculates steering force steer = self.desired - self.velocity # Limit the magnitude of the steering force. steer = limit(steer, self.max_force) # Applies steering force to drone self.applyForce(steer) # Draws current target being seeked pg.draw.circle(self.window, self.color_target, target, 5, 0)
async def animate_flying_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start. """ canvas_height, canvas_width = canvas.getmaxyx() frame_height, frame_width = get_frame_size(garbage_frame) column = limit( value=column, min_value=1, max_value=canvas_width - frame_width - 1, ) row = 1 while row < canvas_height - frame_height - 1: obstacle = Obstacle( row=row, column=column, rows_size=frame_height, columns_size=frame_width, ) obstacles.append(obstacle) draw_frame(canvas, row, column, garbage_frame) await sleep() draw_frame(canvas, row, column, garbage_frame, negative=True) obstacles.remove(obstacle) if obstacle in obstacles_in_last_collisions: obstacles_in_last_collisions.remove(obstacle) await animate_explosion( canvas=canvas, center_row=row + 2 + frame_height // 2, center_column=column + frame_width // 2, ) return row += speed
def update(self): """ Standart Euler integration Updates bahavior tree """ # updates behavior in machine state self.behavior.update(self) # Updates velocity at every step and limits it to max_speed self.velocity += self.acceleration * 1 self.velocity = limit(self.velocity, self.max_speed) # updates position self.location += self.velocity # Prevents it from crazy spinning due to very low noise speeds if self.velocity.length() > 0.5: self.rotation = atan2(self.velocity.y, self.velocity.x) # Constrains position to limits of screen self.location = constrain(self.location, SCREEN_WIDTH, SCREEN_HEIGHT) self.acceleration *= 0 # Memory of positions to draw Track self.memory_location.append((self.location.x, self.location.y)) # size of track if len(self.memory_location) > SIZE_TRACK: self.memory_location.pop(0)
def _apply_acceleration(speed, speed_limit, forward=True): """Change speed — accelerate or brake — according to force direction.""" speed_limit = abs(speed_limit) speed_fraction = speed / speed_limit # if the spaceship is standing still, then we accelerate quickly # if the spaceship is already flying fast, then we accelerate slowly delta = math.cos(speed_fraction) * 0.75 result_speed = speed + delta if forward else speed - delta result_speed = limit( value=result_speed, min_value=-speed_limit, max_value=speed_limit, ) # if the speed of the spaceship is close to zero, then we stop it if abs(result_speed) < 0.1: result_speed = 0 return result_speed
def move(self, di, dj): i, j = self.position i = limit(i + di, 0, self._table.height - 1) j = limit(j + dj, 0, len(self._table.table[i]) - 1) self.position = (i, j)
def true_score(score): return utils.limit(score,OUTPUT_FACTOR)/OUTPUT_FACTOR*REDUCE_ONE
import utils def fibo(n): if n < 2: return n else: return fibo(n - 1) + fibo(n - 2) @utils.bench def run(n): return fibo(n) n = 37 s = utils.limit("{}".format(run(n)), 10) print('n={} fib={}'.format(n, s))