def get_target_point(self): if(self.a == 0.0 and self.b == 0.0): print("Uh oh...Line not defined") return if(self.a == 0.0): # Line is horizontal normal_distance_to_wall = 1.0 * self.c / self.b v_parallel = Vector2D(x=0.0, y=normal_distance_to_wall) v_normal = v_parallel.normal() elif(self.b == 0.0): # Line if vertical normal_distance_to_wall = 1.0 * self.c v_parallel = Vector2D(x=normal_distance_to_wall, y=0.0) v_normal = v_parallel.normal() else: # Get the angle of the normal to the line v_parallel = Vector2D(x=1, y=1.0 * self.a / self.b) v_normal = v_parallel.normal().hat() normal_distance_to_wall = 1.0 * self.c / self.b * cos(radians(90) - v_normal.angle) v_normal = v_normal * normal_distance_to_wall v_forward = v_parallel.hat() * self.f + v_normal.hat() * (v_normal.magnitude - self.distance_to_maintain) v_backward = v_parallel.hat() * -1.0 * self.f + v_normal.hat() * (v_normal.magnitude - self.distance_to_maintain) print("Forward = {}\n Backward = {}".format(v_forward, v_backward)) # self.target_point = v_parallel.hat() * -1.0 * self.f self.target_point_parallel = v_parallel.hat() * self.f self.target_point_normal = v_normal.hat() * (v_normal.magnitude - self.distance_to_maintain) # if(self.prev_angle - v_forward.angle < self.prev_angle - v_backward.angle): self.target_point = self.target_point_parallel + self.target_point_normal print("CHOSE FORWARD") # else: # self.target_point = self.target_point_parallel - self.target_point_normal # print("CHOSE BACKWARD") self.prev_angle = self.target_point.angle
def fireBallAtk(self, delta, player_pos, world, screen): if not self.fireBallActive: self.fireBallActive = True self.fireBallSprite.pos.x = self.boss_hitBox.pos.x + 200 self.fireBallSprite.pos.y = self.boss_hitBox.pos.y + 50 self.fireBallSprite.vel = player_pos.subtract(self.fireBallSprite.pos) self.fireBallSprite.colliDetect(world) if self.fireBallSprite.detectedHit or self.fireBallSprite.pos.x > 1024 or self.fireBallSprite.pos.y > 768: if self.enraged: self.fireScatterActive = True for o in self.fireScatter: o.pos = self.fireBallSprite.pos self.fireScatter[0].vel = Vector2D((-1,0)) self.fireScatter[1].vel = Vector2D((0, -1)) self.fireScatter[2].vel = Vector2D((1,0)) self.fireScatter[3].vel = Vector2D((0,1)) self.fireBallScatter(delta) else: self.fireBallActive = False self.fireBallSprite.pos.x = -300 self.fireBallSprite.pos.y = -300 self.fireBallSprite.vel = Vector2D((0,0)) self.fireBallSprite.detectedHit = False self.fireBallAgain = 600 self.fireBallSprite.accel = .1 else: if self.fireBallSprite.accel < .75: self.fireBallSprite.accel = self.fireBallSprite.accel + .01 self.fireBallSprite.update(delta)
def move(self, direction): move_by_x = 0 move_by_y = 0 if direction == 'up': move_by_y = -1 if direction == 'down': move_by_y = 1 if direction == 'left': move_by_x = -1 if direction == 'right': move_by_x = 1 old_head = self.body[0] new_head = SnakeHead( Vector2D(old_head.get_x() + move_by_x, old_head.get_y() + move_by_y)) self.body.appendleft(new_head) self.body[1] = SnakeBody(old_head.position) curr_cell = self.game.matrix[self.body[0].get_y()]\ [self.body[0].get_x()] if not GameWorld.check_for_collision(self.body[0], curr_cell): last_cell = self.body.pop() reset_cell = EmptyCell( Vector2D(last_cell.get_x(), last_cell.get_y())) self.game.set_cell(reset_cell) else: self.game.set_cell(Flower(Vector2D(randint(0, 14), randint(0, 14)))) self.refresh_snake()
def updateDirection(self): """ Updates the direction that the object faces. """ # Find the velocity vector (self to target) orig = Vector2D(0, 1) # Must be facing down target = Vector2D(pygame.mouse.get_pos()[0] - self.trueX, pygame.mouse.get_pos()[1] - self.trueY) # Calculate the dot product of the vectors dotx = orig.getX() * target.getX() doty = orig.getY() * target.getY() # Calculate the angle between the spawn vector and the target vector. # Formula: cos(@) = (Ax.Bx + Ay.By) / (|Avec| * |Bvec|) angle = (dotx + doty) / (orig.magnitude() * target.magnitude()) angle = math.acos(angle) # Rotate and assign the image. if (target.getX() > orig.getX()): self.image = pygame.transform.rotate(self.imageMaster, math.degrees(angle)) else: self.image = pygame.transform.rotate(self.imageMaster, -math.degrees(angle)) self.rect = self.image.get_rect() self.image.set_colorkey(self.tranColor)
def pointInRegion(self, point, regionInflateAmount): testMin = Vector2D(self.minExtent.x - regionInflateAmount, self.minExtent.y - regionInflateAmount) testMax = Vector2D(self.maxExtent.x + regionInflateAmount, self.maxExtent.y + regionInflateAmount) return (testMin.x <= point.x <= testMax.x and testMin.y <= point.y <= testMax.y)
def main(): game = GameWorld(15) snake = Python(game, start_pos=Vector2D(2, 2), direction="left") Wall(game, position=Vector2D(4, 4), size=3, orientation='x') Wall(game, position=Vector2D(10, 10), size=4, orientation='y') game.set_cell(Flower(position=Vector2D(randint(0, 14), randint(0, 14)))) score = 0 moves = 0 start_time = datetime.now().isoformat() filename = generate_filenmame() try: while True: game.print_game() print('Score:', score) print('Moves:', moves) score = len(snake.body) - 2 moves += 1 direction = getch() snake.move(MOVEMENT[direction]) os.system('clear') except IndexError: with open(filename, 'w') as f: f.write(generate_log_msg(start_time, score, moves)) f.close() print("You've hit the edge of the map!") print("You can check your result at {0}".format(filename)) except DeathError: with open(filename, 'w') as f: f.write(generate_log_msg(start_time, score, moves)) f.close() print("You've hit a wall or fell into black hole!") print("You can check your result at {0}".format(filename))
def testHighLevel(self): basis0 = Vector2D(5.0, 0) basis1 = Vector2D(0, .5) v = Vector2D(10, 1) self.assert_(v.convert_to_basis(basis0, basis1) == [2, 2]) self.assert_(v.projection(basis0) == (10, 0)) self.assert_(basis0.dot(basis1) == 0)
def vectorSpeedTest(): t0 = getCurrentTime() a = Vector2D(0, 0) for x in range(loops): a = a + Vector2D(rndValue(), rndValue()) return getCurrentTime() - t0
def __init__(self, position, velocity, radius, elasticity, wallboundaries): # Initialize all variables self.pos = Vector2D(position) self.velocity = Vector2D(velocity) self.elasticity = elasticity self.radius = radius self.mass = 1 self.wallboundary = wallboundaries
def testReverseMath(self): v = Vector2D(111, 222) self.assert_(1 + v == Vector2D(112, 223)) self.assert_(2 - v == [-109, -220]) self.assert_(3 * v == (333, 666)) self.assert_([222, 888] / v == [2, 4]) self.assert_([111, 222]**Vector2D(2, 3) == [12321, 10941048]) self.assert_([-11, 78] + v == Vector2D(100, 300))
def fireBreathAtk(self, delta, floor, screen): if not self.fireBreathActive: self.fireBreathActive = True self.fireBallChain[0].pos = Vector2D(((self.boss_hitBox.pos.x + self.boss_hitBox.w) - 50, self.boss_hitBox.pos.y + 50)) self.fireBallChain[1].pos = Vector2D((self.fireBallChain[0].pos.x, self.fireBallChain[0].pos.y + 40)) self.fireBallChain[2].pos = Vector2D((self.fireBallChain[0].pos.x, self.fireBallChain[0].pos.y - 40)) for o in self.fireBallChain: o.vel.x = 1 self.fireBallChain[0].accel = .1 self.fireBallChain[1].accel = .1 self.fireBallChain[2].accel = .1 elif self.fireBallChain[0].pos.x > 1024: if self.enraged and not self.pass2: self.pass1 = True for o in self.fireBallChain: o.vel.x = -1 o.accel = .15 o.pos.x = 1024 - o.w o.update(delta) else: self.pass2 = False for o in self.fireBallChain: o.pos = Vector2D((-1000,-1000)) o.vel = Vector2D((0,0)) o.accel = 0 self.fireBreathActive = False self.idle = True elif self.fireBallChain[0].pos.x < floor.x and self.pass1: self.pass1 = False self.pass2 = True for o in self.fireBallChain: o.vel.x = 1 o.accel = .15 o.update(delta) elif self.fireBallChain[1].pos.y + self.fireBallChain[1].h < floor.y: for o in self.fireBallChain: o.vel.y = 1 for o in self.fireBallChain: o.update(delta) if self.fireBallChain[1].pos.y + self.fireBallChain[1].h > floor.pos.y: for o in self.fireBallChain: o.vel.y = 0 self.fireBallChain[1].pos.y = floor.pos.y - self.fireBallChain[1].h self.fireBallChain[0].pos.y = self.fireBallChain[1].pos.y - 40 self.fireBallChain[2].pos.y = self.fireBallChain[0].pos.y - 40 else: for o in self.fireBallChain: if o.accel < .9: o.accel = o.accel + .01 o.update(delta)
def Main(): vec1 = Vector2D(5,6) vec2 = Vector2D(1,1) print(vec1.x) print(vec1.y) print(vec2.x) print(vec2.y)
def __init__(self): super().__init__() self.add_component('renderer', Renderer()) self.add_component( 'physics', Physics(CIRCLE_MASS, CIRCLE_S_FRICTION, CIRCLE_K_FRICTION, Vector2D(0, 0))) self.add_component('body', Body.Circle(0, Vector2D(300, 300), 50, 30)) self.add_component('controller', Controller.CircleController())
def testLength(self): v = Vector2D(3, 4) self.assert_(v.length == 5) self.assert_(v.get_length_sqrd() == 25) self.assert_(v.normalize_return_length() == 5) self.assert_(v.length == 1) v.length = 5 self.assert_(v == Vector2D(3, 4)) v2 = Vector2D(10, -2) self.assert_(v.get_distance(v2) == (v - v2).get_length())
def testMath(self): v = Vector2D(111, 222) self.assertEqual(v + 1, Vector2D(112, 223)) self.assert_(v - 2 == [109, 220]) self.assert_(v * 3 == (333, 666)) self.assert_(v / 2.0 == Vector2D(55.5, 111)) self.assert_(v / 2 == (55, 111)) self.assert_(v**Vector2D(2, 3) == [12321, 10941048]) self.assert_(v + [-11, 78] == Vector2D(100, 300)) self.assert_(v / [11, 2] == [10, 111])
def __init__(self): super().__init__() self.add_component('controller', Controller.PlayerController()) self.add_component('renderer', Renderer()) self.add_component( 'body', Body.Polygon(0, Vector2D(100, 100), 30, PLAYER_SHAPE_VECTOR)) self.add_component( 'physics', Physics(PLAYER_MASS, PLAYER_STATIC_FRICTION, PLAYER_KINETIC_FRICTION, Vector2D(0, 0)))
def take_input(self, keys, mouse_input, physics): force_vector = Vector2D(0, 0) if keys[pygame.K_UP]: force_vector += Vector2D(0, -1) if keys[pygame.K_DOWN]: force_vector += Vector2D(0, 1) if keys[pygame.K_LEFT]: force_vector += Vector2D(-1, 0) if keys[pygame.K_RIGHT]: force_vector += Vector2D(1, 0) physics.add_force(force_vector)
def take_input(self, keys, mouse_input, physics): force_vector = Vector2D(0, 0) if keys[pygame.K_w]: force_vector += Vector2D(0, -1) if keys[pygame.K_s]: force_vector += Vector2D(0, 1) if keys[pygame.K_a]: force_vector += Vector2D(-1, 0) if keys[pygame.K_d]: force_vector += Vector2D(1, 0) physics.add_force(force_vector)
def fireBallScatter(self, delta): for o in self.fireScatter: o.update(delta) self.fireScatterTime = self.fireScatterTime - 1 if self.fireScatterTime <= 0: self.fireScatterActive = False self.fireBallActive = False for o in self.fireScatter: self.fireScatterTime = 500 o.vel = Vector2D((0,0)) o.pos = Vector2D((-1000,-1000))
def testInplace(self): inplace_vec = Vector2D(5, 13) inplace_ref = inplace_vec inplace_src = Vector2D(inplace_vec) inplace_vec *= .5 inplace_vec += .5 inplace_vec /= (3, 6) inplace_vec += Vector2D(-1, -1) alternate = (inplace_src * 0.5 + 0.5) / Vector2D(3, 6) + [-1, -1] self.assertEquals(inplace_vec, inplace_ref) self.assertEquals(inplace_vec, alternate)
def buildRectangeFromLine(self, a, b, width): angle = a.angleHeadingTo(b) left_perp = Vector2D.generateHeadingFromAngle(angle + 90.0) right_perp = Vector2D.generateHeadingFromAngle(angle - 90.0) v1 = a+left_perp*width v2 = a+right_perp*width v3 = b+left_perp*width v4 = b+right_perp*width vertices = [v1.toTuple(), v2.toTuple(), v4.toTuple(), v3.toTuple()] return vertices
def testComparison(self): int_vec = Vector2D(3, -2) flt_vec = Vector2D(3.0, -2.0) zero_vec = Vector2D(0, 0) self.assert_(int_vec == flt_vec) self.assert_(int_vec != zero_vec) self.assert_((flt_vec == zero_vec) == False) self.assert_((flt_vec != int_vec) == False) self.assert_(int_vec == (3, -2)) self.assert_(int_vec != [0, 0]) self.assert_(int_vec != 5) self.assert_(int_vec != [3, -2, -5])
def add_bullet(bullets, game_controller, player_id): bullets.append( game_controller.add_entity( Bullet( Vector2D( game_controller.components['body'][player_id].position.x, game_controller.components['body'][player_id].position.y), Vector2D( game_controller.components['physics'] [player_id].velocity.x, game_controller.components['physics'] [player_id].velocity.y))))
def __init__(self, game_manager, position=Vector2D(0, 0), world_size=Vector2D(0, 0)): self.game_manager = game_manager # type: GameManager.GameManager self.position = position.copy() self.real_position = Vector2D(0, 0) self.__target = None # type: Vector2D self.move_time = 2 self.position_to_real() self.world_size = world_size
def sort(player): if player['pos_x'] == State.INVALID_DATA: return State.INVALID_DATA center = Vector2D(relative_pos['pos_x'], relative_pos['pos_y']) player_pos = Vector2D(player['pos_x'], player['pos_y']) diff = (player_pos - center).th().degree() - relative_angle # TODO ABS...? if diff > 180: diff = -(360 - diff) if diff < -180: diff = 360 + diff return diff
def find_function(self, state, type): kicker_pos = Vector2D(state.kicker['pos_x'], state.kicker['pos_y']) if type == SortType.ANGLE_KICKER_GOAL: return sort_by_angle_kicker( state.kicker, (Vector2D(+52.5, 0) - kicker_pos).th().degree()) elif type == SortType.ANGLE_KICKER: return sort_by_angle_kicker(state.kicker) elif type == SortType.ANGLE_FIELD_CENTER: return sort_by_angle_field_center() elif type == SortType.X: return sort_by_x elif type == SortType.UNUM: return sort_by_unum
def __init__(self, game, start_pos, direction): self.game = game if direction == 'left': cell_pos = Vector2D(start_pos.get_x() + 1, start_pos.get_y()) elif direction == 'right': cell_pos = Vector2D(start_pos.get_x() - 1, start_pos.get_y()) elif direction == 'up': cell_pos = Vector2D(start_pos.get_x(), start_pos.get_y() - 1) elif direction == 'down': cell_pos = Vector2D(start_pos.get_x(), start_pos.get_y() + 1) self.body = deque([SnakeHead(start_pos), SnakeBody(cell_pos)]) self.refresh_snake()
def injectPoints(coords): #Controls spacing between each injectd point spacing = 6 newPoints = [] for i in range(len(coords) - 1): vector = coords[i + 1].sub(coords[i]) num_points_that_fit = math.ceil(vector.mag() / spacing) vector = vector.div(Vector2D(vector.mag(), vector.mag())).mult( Vector2D(spacing, spacing)) for j in range(num_points_that_fit): newPoints.append(coords[i].add(vector.mult(Vector2D(j, j)))) newPoints.append(coords[len(coords) - 1]) return newPoints
def getTargetVec(self): """ Calculate the object's movement vector. """ vec = Vector2D(pygame.mouse.get_pos()[0] - self.trueX, pygame.mouse.get_pos()[1] - self.trueY) if vec.magnitude() > self.accuracy: vec = Vector2D( pygame.mouse.get_pos()[0] + random.randint(-self.spread, self.spread) - self.trueX, pygame.mouse.get_pos()[1] + random.randint(-self.spread, self.spread) - self.trueY) return vec.normalized()
def smoothPath(path, a, b, tol): newPath = path.copy() change = tol while change >= tol: change = 0.0 for i in range(1, len(path) - 1): aux = newPath[i] p1 = path[i].sub(newPath[i]).mult(Vector2D(a, a)) p2 = Vector2D(b, b).mult(newPath[i - 1].add(newPath[i + 1]).sub( newPath[i].mult(Vector2D(2, 2)))) newPath[i] = newPath[i].add(p1.add(p2)) change += abs(aux.sub(newPath[i]).x) change += abs(aux.sub(newPath[i]).y) return newPath
def __init__(self, name, *size): self.name = name self.size = check_size_number(list(size)) self.center = Vector2D(0, 0) self.border_color = 'black' self.background_color = 'white' self.angle = 0 # when it comes to the circle, now angle doesn't make sense, but if it "in future" had sth
def grow(self): # Check if the dendrite segment has resources left for growth if self.resources<self.step_size: # No resources left, you should die. self.is_growing = False return self.is_growing, [] # Calculate the headings to which you can travel allowable_range = self.buildAllowableHeadingRange(self.heading, self.heading_deviation) # If you can't travel anywhere, die. if allowable_range == []: self.is_growing = False return self.is_growing, [] children = self.attemptToSpawnChildren() if children != []: self.children = children self.is_growing = False return self.is_growing, children # Okay, you didn't die or procreate, so you can grow. self.heading = generateRandomInAllowableRanges(allowable_range) vector_direction = Vector2D.generateHeadingFromAngle(self.heading) old_location = self.locations[-1] new_location = old_location + vector_direction * self.step_size distance = self.step_size # Update your internals self.resources -= distance self.length += distance self.locations.append(new_location) # Find your circle bounding box radius = distance/2.0 center = (old_location+new_location)/2.0 self.circle_bounds.append([radius, center]) return self.is_growing, []
grid_size = 10 import random heading = 0.0 heading_deviation = 65.0 step_size = 50 steps = 5 locations = [Vector2D(500,500)] grid_locations = [locations[0]/grid_size] for i in range(steps): last_location = locations[-1] angle = heading + random.uniform(-heading_deviation, heading_deviation) vector_direction = Vector2D.generateHeadingFromAngle(angle) new_location = last_location + vector_direction * step_size locations.append(new_location) grid_locations.append(new_location/grid_size) gridded_locations = snapToNearestGrid(grid_locations, grid_size, step_size, .1) locations2 = [locations[-1]] grid_locations = [locations2[0]/grid_size] for i in range(steps): last_location = locations2[-1] angle = heading + random.uniform(-heading_deviation, heading_deviation) vector_direction = Vector2D.generateHeadingFromAngle(angle) new_location = last_location + vector_direction * step_size locations2.append(new_location) grid_locations.append(new_location/grid_size)
# -*- coding: utf-8 -*- """ Created on Fri Apr 12 21:48:43 2013 @author: mikewesthad """ from math import atan2, pi from numpy import arctan2, arange from Vector2D import Vector2D angles = arange(0.0, 360.0, 45.0) headings = [] py_atan2_angles = [] np_atan2_angles = [] for angle in angles: heading = Vector2D.generateHeadingFromAngle(angle) headings.append(heading) py_angle = atan2(heading.y, heading.x) * 180.0/pi np_angle = arctan2(heading.y, heading.x) * 180.0/pi py_atan2_angles.append(py_angle) np_atan2_angles.append(np_angle) for i in range(len(angles)): print angles[i], headings[i], py_atan2_angles[i], np_atan2_angles[i]