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]
