def main():
skull = Body.GravBody(5, 6.371 * 10**6, 8000.)
solver = Solver.RK2(0.001)
def stop_condition(skull):
return skull.velocity > 0
sim1 = Simulation.TrajectorySim(stop_condition, solver, skull)
x, y = sim1.get_results()
skull2 = Body.GravBody(5, 6.371 * 10**6, 8000.)
sim2 = Simulation.InverseTrajectorySim(stop_condition, solver, skull2)
a, b = sim2.get_results()
plt.plot(x, y)
plt.plot(a, b)
plt.title("Skull Tosses")
plt.xlabel("Time [s]")
plt.ylabel("Height [m]")
plt.legend(["Uniform Gravity", "Inverse Square Gravity"])
plt.figure()
varray = np.arange(0, 100, 0.5)
harray = []
for v in varray:
skull3 = Body.GravBody(5, 6.371 * 10**6, v)
sim3 = Simulation.InverseTrajectorySim(stop_condition, solver, skull3)
result = sim3.get_results()
harray.append(skull3.position)
plt.plot(varray, harray)
plt.title("Maximum Height vs. Initial Velocity")
plt.xlabel("Initial Velocity [m/s]")
plt.ylabel("Maximum Height [m]")
def main():
coffee = Body.ThermalBody(500)
solver = Solver.Euler(0.5)
def stop_condition(coffee):
return coffee.temperature > sim.Ta * 1.1
sim = Simulation.CoolingSim(stop_condition, solver, 293, 0.05, coffee)
t, T = sim.get_results()
plt.plot(t, T)
coffee = Body.ThermalBody(500)
solver = Solver.RK2(0.5)
def stop_condition(coffee):
return coffee.temperature > sim.Ta * 1.1
sim = Simulation.CoolingSim(stop_condition, solver, 293, 0.05, coffee)
t, T = sim.get_results()
plt.plot(t, T)
plt.title("OOP Cooling Curves")
plt.xlabel("Time [s]")
plt.ylabel("Temperature[K]")
plt.legend(["Euler Curve", "RK2 Cooling Curve"])
def setup():
width=2400
height=1800
for i in range(0,startBodyCount-1):
#stars[i] = Body(id=i,r=1,mass=random.uniform(startBodyMass[0],startBodyMass[1]),pos=[random.uniform(100,1500),random.uniform(100,800)],vel=[random.uniform(0,startBodySpeed),random.uniform(0,startBodySpeed)],col=[random.randint(0,255),random.randint(0,255),random.randint(0,255)])
stars.append(Body(id=i,r=1,mass=random.uniform(startBodyMass[0],startBodyMass[1]),pos=[random.uniform(100,1500),random.uniform(100,800)],vel=[random.uniform(0,startBodySpeed),random.uniform(0,startBodySpeed)],col=[random.randint(0,255),random.randint(0,255),random.randint(0,255)]))
stars.append(Body(id=startBodyCount-1,r=1,mass=5000,pos=[2400/2,1800/2],vel=[0,0],col=[255,255,255]))
def sim_1(self):
Earth = Body.GravBody(1,self.rEarth,self.vEarth)
Mars = Body.GravBody(1,self.rMars,self.vMars)
Planets = [Earth,Mars]
sim = Simulation.OrbitSim(self.stop_1,self.physics,Planets)
sim.advance()
time, bodies = sim.get_results()
return bodies[-1][1].position.theta
def __init__(self, mx, my):
self.map = [[define.elem["case"]] * my for _ in range(mx)]
self.mx = mx
self.my = my
self.head = [self.mx / 2, self.my / 2]
self.body = Body()
self.apple = Apple(self.mx, self.my)
self.cherry = Cherry(self.mx, self.my)
def __init__(self,solver,stopCondition,physics,Ms,Mp,Rs,Rp,ap,e,omega,i):
self.Rs=Rs
self.Rp=Rp
self.omega=omega
self.i=i
self.Ms=Ms
self.Mp=Mp
self.ap=ap
self.e=e
self.physics=physics
self.desiredOrbitRadius=None
self.numberOrbits=0
self.G=6.67408*10**-11
self.vp=math.sqrt(self.G*Ms**3*(1+e)/(ap*(Mp+Ms)**2*(1-e)))
self.vs=-(Mp/Ms)*self.vp
self.rp=ap-ap*e
self.rs=-(Mp/Ms)*self.rp
M=1.989*10**30
body1x=self.rp
body1y=0
body1z=0
body1pos=Vector.Vector(x=body1x,y=body1y,z=body1z)
body1pos.rotZ(omega)
body1pos.rotX(i)
body2x=self.rs
body2y=0
body2z=0
body2pos=Vector.Vector(x=body2x,y=body2y,z=body2z)
body2pos.rotZ(omega)
body2pos.rotX(i)
body1vx=0
body1vy=self.vp
body1vz=0
body1vel=Vector.Vector(x=body1vx,y=body1vy,z=body1vz)
body1vel.rotZ(omega)
body1vel.rotX(i)
body2vx=0
body2vy=self.vs
body2vz=0
body2vel=Vector.Vector(x=body2vx,y=body2vy,z=body2vz)
body2vel.rotZ(omega)
body2vel.rotX(i)
self.body1=Body.GravBody(body1vel,body1pos,Mp)
self.body2=Body.GravBody(body2vel,body2pos,Ms)
bodies=[self.body1,self.body2]
super(ExoSim,self).__init__(solver,bodies,stopCondition,M)
def update(self):
self.imagerectR.centerx = int(self.x) + int(79 / 2)
self.imagerectR.centery = int(self.y) + int(157 / 2)
self.imagerectL.centerx = int(self.x) + int(79 / 2)
self.imagerectL.centery = int(self.y) + int(157 / 2)
if self.facing == 'left':
self.hit_box = Hitbox(self.win, self.x + 27, self.y + 25, 25)
self.body = Body(self.x + 24, self.y + 50, 40, 100)
elif self.facing == 'right':
self.hit_box = Hitbox(self.win, self.x + 52, self.y + 25, 25)
self.body = Body(self.x + 15, self.y + 50, 40, 100)
def sim_3(self):
r1 = vector.Vector(1., 0, 0)
v1 = vector.Vector(0, 1.1 * math.pi, 0)
r2 = vector.Vector(-1., 0, 0)
v2 = vector.Vector(0, -1.1 * math.pi, 0)
One = Body.GravBody(1., r1, v1)
Two = Body.GravBody(1., r2, v2)
Objects = [One, Two]
sim = Simulation.OrbitSim(physics=self.physics, body=Objects)
sim.advance(time=10.)
time, bodies = sim.get_results()
self.plorbits(bodies)
def __init__(self, scene, pos):
Entity.__init__(self, scene)
self.body_handler = Body(scene)
self.scene = scene
self.immunities = []
self.current_path = 0
self.current_tile = ()
self.current_order = 0
self.lifetime = 0
self.vision_range = 0
self.max_health = 0
self.health = 0
self.alive = True
self.target = 0
self.types += ["unit"]
def importBodiesFile(name, combo):
global gBodies
buffer = []
import_file = open(name, 'r')
for line in import_file:
current_data = ""
data_list = list()
for ch in line:
# Caracteres de separacion
if ch != '|' and ch != ',':
if ch != " " and ch != '(' and ch != ')': # Ignorando los espacios
current_data += str(ch)
else:
data_list.append(current_data)
current_data = ""
# Acabada de leer una linea, se carga el objeto con sus datos
temp_body = Body(data_list[0], float(data_list[1]),
float(data_list[2]), float(data_list[3]),
float(data_list[4]), float(data_list[5]),
float(data_list[6]), float(data_list[7]),
(float(data_list[8]), float(
data_list[9]), float(data_list[10])),
bool(int(data_list[11])))
buffer.append(temp_body)
# Acabado el anexo de los cuerpos, se actualiza el combo
gBodies[:] = buffer[:]
FileUtilities.refreshBodiesCombo(combo)
import_file.close()
def canvas_onleftclick(self, event):
check = self.clickOnObject(event)
if self.selectedBody == None:
if check == None:
body = Body(self.canvas,
np.array([event.x, event.y], dtype="float64"),
np.zeros(2), 1e10, 10, len(self.bodies), "white",
0, "collider", self)
if self.selectedBody != None:
self.selectedBody = None
self.bodies.append(body)
else:
self.selectedBody = check
self.selectedBody.selected = True
self.canvas.itemconfig(self.selectedBody.id,
outline="deep sky blue")
else:
if self.selectedBody == check:
self.canvas.itemconfig(self.selectedBody.id, outline="")
self.selectedBody.selected = False
self.selectedBody = None
else:
dx, dy = (event.x - self.selectedBody.position[0]), (
event.y - self.selectedBody.position[1])
self.selectedBody.mom = [dx * 5e9, dy * 5e9]
self.selectedBody.updateVector()
def on_draw(self):
arcade.start_render()
self.side_bar.draw()
for button in self.button_list:
button.draw()
if self.is_menu:
self.menu.draw()
else:
arcade.draw_text("Points", Const.RIGHT - Const.SIDE_BAR / 2, Const.GAME_HEIGHT - 50, arcade.color.WHITE, 30,
align="center", anchor_x="center")
y = Const.GAME_HEIGHT - 100
for a in self.body:
Body.Component(Const.RIGHT - Const.SIDE_BAR + 15, y + 20, a.size, a.color, a.kind).draw()
arcade.draw_text(str(a.points), Const.RIGHT - Const.SIDE_BAR + 30, y, arcade.color.WHITE, 30,
align="center", anchor_x="left")
y -= 40
for a in self.body:
a.draw()
if Const.GHOST_WALK:
self.ghost_walk_effect.draw()
self.food.draw()
def vError(self, v):
'''The error function used in a Search method for finding an initial
velocity that gives a trajectory that reaches the desired height.
Parameters
-----
v : float
The velocity whose error is being calculated.
Returns
-----
float
The difference between the calculated height and the desired height.
'''
step=0.01
skull = Body.GravBody(Vector.Vector(x=0,y=0,z=v),Vector.Vector(x=0,y=0,z=self.startHeight))
solver = Solver.RK2(step,Physics.UniformGravity.diffEq)
skullFlight = TrajectorySim(solver,Vector.Vector(x=0,y=0,z=self.g),skull,Physics.stopCondition)
t,bodies = skullFlight.simulate()
hGuess = bodies[-1].position.z
return hGuess-self.desiredHeight
def angleError(self, phi):
'''The error function used in a Search method for finding an angle that
gives an equal max height and distance.
Parameters
-----
phi : float
The angle whose error is being calculated.
Returns
-----
float
The difference between the max height and the distance traveled for
the given phi.
'''
rock = Body.GravBody(Vector.Vector(r=100.,theta=0,phi=phi),Vector.Vector(x=0,y=0,z=0))
rockTrajectory = TrajectorySim(self.solver,rock,Physics.stopCondition,c=self.c)
t,bodies = rockTrajectory.simulate()
z=[b.position.z for b in bodies]
# y=[b.position.y for b in bodies]
x=[b.position.x for b in bodies]
# print max(z)
# print x[-1]
#
# plt.plot(x,z)
dist=x[-1]
return max(z)-dist
def __init__(self, cam_resolution=(80,80), action_interval=1):
self.body = Body.Body()
self.camera = picamera.PiCamera()
self.camera.resolution = cam_resolution
time.sleep(2) # camera initialization
self.stream = picamera.array.PiRGBArray(self.camera)
self.time = 0
self.action_interval = action_interval
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 closed2BodyAutoBuilder(omega, i, mBig, mSmall, ap, e):
"""
"""
G = 1 #6.67408*10**(-11)
vp = np.sqrt(G * mBig**3 * (1 + e) / (ap * (mSmall + mBig)**2 *
(1 - e)))
vs = -(mSmall / mBig) * vp
rp = ap - ap * e
rs = -(mSmall / mBig) * rp
body1x = rp
body1y = 0
body1z = 0
body1pos = Vector.Vector(x=body1x, y=body1y, z=body1z)
body1pos.rotZ(omega)
body1pos.rotX(i)
body2x = rs
body2y = 0
body2z = 0
body2pos = Vector.Vector(x=body2x, y=body2y, z=body2z)
body2pos.rotZ(omega)
body2pos.rotX(i)
body1vx = 0
body1vy = vp
body1vz = 0
body1vel = Vector.Vector(x=body1vx, y=body1vy, z=body1vz)
body1vel.rotZ(omega)
body1vel.rotX(i)
body2vx = 0
body2vy = vs
body2vz = 0
body2vel = Vector.Vector(x=body2vx, y=body2vy, z=body2vz)
body2vel.rotZ(omega)
body2vel.rotX(i)
body1 = Body.GravBody(body1vel, body1pos, mSmall)
body2 = Body.GravBody(body2vel, body2pos, mBig)
bodies = [body1, body2]
return bodies
def error_3(self,launch_time):
vShip = vector.Vector(0,2*math.pi,0)
rShip = vector.Vector(1,0,0)
Ship = Body.GravBody(1,rShip,vShip)
rMars = vector.Vector(1.5,0,0)
vMars = vector.Vector(0,2*math.pi/math.sqrt(1.5),0)
Mars = Body.GravBody(1,rMars,vMars)
Objects = [Ship,Mars]
sim = Simulation.OrbitSim(physics=self.physics,body=Objects)
sim.advance(time=launch_time)
sim.body[0].velocity.r = self.vL
p = ((2.5/2.)**(3./2.))/2.
sim.advance(time=p+launch_time)
t2list,blist = sim.get_results()
sep = sim.body[1].position - sim.body[0].position
error = sep.r
if error <= 0.01:
self.plorbits(blist)
return error
def __init__(self,
Ms=None,
Mp=None,
ap=None,
e=0,
Rs=None,
Rp=None,
omega=None,
i=None,
apnd=True):
'''Save Values'''
self.apnd = apnd
self.Rs = Rs
self.Rp = Rp
self.G = 4 * math.pi**2.
self.period = np.sqrt(((ap**3.) * ((Ms + Mp)**2.)) / Ms**3.)
'''Set up Vectors'''
rpp = ap - e * ap
rsp = -(Mp / Ms) * rpp
vpp = math.sqrt(
((self.G * Ms**3.) / (ap * (Ms + Mp)**2.)) * ((1. + e) / (1. - e)))
vsp = -(Mp / Ms) * vpp
'''Rotate Vectors into Viewer frame'''
rs = vector.Vector(rsp, 0., 0.)
rs.rot_z(omega)
rs.rot_x(i)
rp = vector.Vector(rpp, 0., 0.)
rp.rot_z(omega)
rp.rot_x(i)
vs = vector.Vector(0., vsp, 0.)
vs.rot_z(omega)
vs.rot_x(i)
vp = vector.Vector(0., vpp, 0.)
vp.rot_z(omega)
vp.rot_x(i)
'''Set Up Sim'''
star = Body.GravBody(Ms, rs, vs)
planet = Body.GravBody(Mp, rp, vp)
self.body = [star, planet]
solver = Solver.RK2(0.01)
self.physics = Physics.NBody(solver, self.G)
self.bodies = [cp.deepcopy(self.body)]
self.t = [0]
def __init__(self, file):
i = 0
self.bodies = list()
for line in file:
i = i + 1
i = i / 30
for j in range(0, int(i)):
b1 = b.Body(file, j)
self.bodies.append(b1)
def findV(self,tolerance):
'''Finds the velocity given a desired height within a given tolerance
for a body on Earth.
Parameters
-----
tolerance : float
How close you want to be to the theoretically ideal value.
Returns
-----
The estimated velocity.
'''
desiredHeight=self.desiredHeight
vGuess=self.vGuess
hGuess=self.hGuess
g = -9.81
step = 0.1
lastvGuess = vGuess
up = False
down = False
while abs(hGuess-desiredHeight)>tolerance:
skull = Body.GravBody(vGuess,self.startHeight)
solver = Solver.RK2(step,Physics.UniformGravity.diffEq)
skullFlight = TrajectorySim(solver,g,skull,Physics.stopCondition)
t,vAndh = skullFlight.simulate()
hGuess = vAndh[1][-1]
if hGuess-desiredHeight < 0:
up = True
if down == False:
lastvGuess = vGuess
vGuess = vGuess*2
else:
lvgHold = vGuess
vGuess = vGuess + abs(lastvGuess-vGuess)*0.5
lastvGuess = lvgHold
elif hGuess-desiredHeight > 0:
down = True
if up == False:
lastvGuess = vGuess
vGuess = vGuess/2.
else:
lvgHold = vGuess
vGuess = vGuess - abs(vGuess-lastvGuess)*0.5
lastvGuess = lvgHold
else: print('Error?')
return vGuess
def __init__(self,solver,stopCondition,physics,M1,M2,a1,e):
self.M1=M1
self.M2=M2
self.a1=a1
self.e=e
self.physics=physics
self.desiredOrbitRadius=None
self.numberOrbits=0
self.G=6.67408*10**-11
self.v1=math.sqrt(self.G*M2**3*(1+e)/(a1*(M1+M2)**2*(1-e)))
self.v2=-(M1/M2)*self.v1
self.r1=a1-a1*e
self.r2=-(M1/M2)*self.r1
M=1.989*10**30
body1x=self.r1
body1y=0
body1z=0
body1pos=Vector.Vector(x=body1x,y=body1y,z=body1z)
body2x=self.r2
body2y=0
body2z=0
body2pos=Vector.Vector(x=body2x,y=body2y,z=body2z)
body1vx=0
body1vy=self.v1
body1vz=0
body1vel=Vector.Vector(x=body1vx,y=body1vy,z=body1vz)
body2vx=0
body2vy=self.v2
body2vz=0
body2vel=Vector.Vector(x=body2vx,y=body2vy,z=body2vz)
self.body1=Body.GravBody(body1vel,body1pos,M1)
self.body2=Body.GravBody(body2vel,body2pos,M2)
bodies=[self.body1,self.body2]
super(BinarySim,self).__init__(solver,bodies,stopCondition,M)
class Board():
def __init__(self, mx, my):
self.map = [[define.elem["case"]] * my for _ in range(mx)]
self.mx = mx
self.my = my
self.head = [self.mx / 2, self.my / 2]
self.body = Body()
self.apple = Apple(self.mx, self.my)
self.cherry = Cherry(self.mx, self.my)
def init_board(self):
self.body.init_body(self.head)
self.apple.set_apple(self.map)
self.cherry.set_cherry(self.map)
self.update_board()
def update_board(self):
for x in range(self.mx):
for y in range(self.my):
self.map[x][y] = define.elem["head"] if [x, y] == self.head \
else define.elem["body"] if self.body.is_body([x, y]) \
else define.elem["apple"] if self.apple.is_apple([x, y]) \
else define.elem["cherry"] if self.cherry.is_cherry_const([x, y]) \
else define.elem["case"]
def get_map(self):
return self.map
def get_head(self):
return self.head
def set_head(self, x, y):
self.head = [x, y]
def is_wall(self, p):
return p[0] < 0 or p[0] > self.mx or p[1] < 0 or p[1] > self.my
def deb(self):
for x in range(self.mx):
for y in range(self.my):
print('{} '.format(self.map[x][y]), end="")
print()
def preset2(self):
self.canvas.delete("all")
self.bodies = []
with open("data/preset2.txt", "r") as preset2File:
for line in preset2File.read().splitlines():
data = line.split(",")
pos = np.array([float(data[1]), 0])
vel = np.array([0, float(data[2])])
planet = Body(self.canvas, pos, vel, float(data[0]), 10,
len(self.bodies), data[3], 1, data[4], self)
self.bodies.append(planet)
def error_2(self,v0):
vShip = vector.Vector(0,v0,0)
rShip = vector.Vector(1,0,0)
Ship = Body.GravBody(1,rShip,vShip)
sim = Simulation.OrbitSim(self.stop_1,self.physics,Ship)
sim.advance()
time, Ships = sim.get_results()
r = [[s.position.r for s in ship] for ship in Ships]
max_r = max(r)
error = max_r[0] - 1.5 #since r becomes another stupid list of lists
return error
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 error(theta):
htarg = 0
r = vector.Vector(0,0,0)
v = vector.Vector(r=100,theta=theta,phi=(math.pi/2))
particle = Body.GravBody(5,r,v)
solver =Solver.RK4(0.1)
physics = Physics.UniformGravity(solver,c=0.1)
sim = Simulation.TrajectorySim(stop_maker(htarg),physics,particle)
a,b = sim.get_results()
y = [p.position.y for p in b]
E = particle.position.x - max(y)
return E
def submit():
mass = float(mass_field.get())
pos = (float(px_field.get()), float(py_field.get()))
vect = (float(vx_field.get()), float(vy_field.get()))
color = (int(r_field.get()), int(g_field.get()), int(b_field.get()))
if autorad:
rad = -1
else:
rad = float(radius_field.get())
collisionbool = collision.get()
body.destroy()
bodies.append(Body(mass, pos, vect, color, rad, collisionbool))
def __init__(self, M1=None, M2=None, a1=1, e=0, apnd=True):
'''Build GravBodies'''
self.G = 4 * math.pi**2.
r1p = a1 - e * a1
r2p = -(M1 / M2) * r1p
v1p = math.sqrt(
((self.G * M2**3.) / (a1 * (M1 + M2)**2.)) * ((1. + e) / (1. - e)))
v2p = -(M1 / M2) * v1p
r1 = vector.Vector(r1p, 0., 0.)
r2 = vector.Vector(r2p, 0., 0.)
v1 = vector.Vector(0., v1p, 0.)
v2 = vector.Vector(0., v2p, 0.)
body1 = Body.GravBody(M1, r1, v1)
body2 = Body.GravBody(M2, r2, v2)
'''Set up Sim'''
self.body = [body1, body2]
solver = Solver.RK2(0.01)
self.physics = Physics.NBody(solver, self.G)
self.bodies = [cp.deepcopy(self.body)]
self.t = [0]
self.apnd = apnd
def set_players(self, number_of_players):
if number_of_players < 1:
number_of_players = 1
center_x = int(Const.GRID_NR_W / 2) * Const.BODY_SIZE + Const.BODY_SIZE / 2 + 2 * Const.BODY_SIZE
center_y = int(Const.GRID_NR_H / 2) * Const.BODY_SIZE + Const.BODY_SIZE / 2
p = 0
self.body = []
for i in range(number_of_players):
player = Body.Body(i)
player.set_position(center_x - p, center_y)
player.setup()
self.body.append(player)
p += 4 * Const.BODY_SIZE
def __init__( self, scene, pos ) :
Entity.__init__( self, scene )
self.body_handler = Body( scene )
self.scene = scene
self.immunities = []
self.current_path = 0
self.current_tile = ()
self.current_order = 0
self.lifetime = 0
self.vision_range = 0
self.max_health = 0
self.health = 0
self.alive = True
self.target = 0
self.types += [ "unit" ]
class Unit( Entity ) :
def __init__( self, scene, pos ) :
Entity.__init__( self, scene )
self.body_handler = Body( scene )
self.scene = scene
self.immunities = []
self.current_path = 0
self.current_tile = ()
self.current_order = 0
self.lifetime = 0
self.vision_range = 0
self.max_health = 0
self.health = 0
self.alive = True
self.target = 0
self.types += [ "unit" ]
def set_body_images( self ) :
pass
def set_health( self, health ) :
self.max_health = health
self.health = health
def set_target( self, target ) :
self.target = target
def handle_collision( self, my_fixture, colliding_fixture ) :
pass
#self.scene.world.DestroyBody( colliding_fixture.body )
def set_order( self, order ) :
if self.current_order == 0 :
self.current_order = order
return True
if self.current_order.remove_unit( self ) == True :
self.current_order = order
return True
return False
def update( self, update ) :
self.last_update = update
self.handle_lifetime( update )
self.body_handler.update( update )
if self.current_order != 0 :
if self.current_order.Step() == False :
return False
def has_vision_of_point( self, pos ) :
if self.vision_range > 0 :
if self.scene.map.fov.is_pos_visible( self.body.transform.position, pos, self.vision_range ) :
return True
return False
def handle_lifetime( self, update ) :
if self.lifetime > 0 :
self.lifetime -= 1
if self.lifetime == 0 :
self.scene.remove_entity( self )
def move( self, new_pos ) :
if self.body == 0 :
self.pos = new_pos
return True
if self.has_vision_of_point( new_pos ) == False :
self.move_along_path( new_pos )
return True
self.move_towards_target( new_pos, 1 )
return True
def stop( self ) :
if self.body == 0 :
return False
self.current_path = 0
self.body.linearVelocity = (0,0)
#self.move_towards_target( self.scene.target_unit, 1 )
def move_towards_target( self, target, final_distance ) :
my_pos = self.body.transform.position
self.current_path = 0
if get_distance_between_points( my_pos, target ) > final_distance :
radians_to_target = get_radians_between_points( my_pos, target )
movement_vector = get_movement_vector( radians_to_target, self.speed )
self.body.linearVelocity = movement_vector
return False
self.body.linearVelocity = (0,0)
return True
def move_along_path( self, new_pos ) :
if self.current_path != 0 :
if len( self.current_path ) != 0 :
next_tile_distance = get_distance_between_points( self.body.transform.position, self.current_tile )
if next_tile_distance < ( 0.3 * self.speed ) :
self.current_tile = self.current_path.pop( 0 )
self.move_to_tile( self.current_tile )
#self.scene.map.get_visible_tiles( self.body.transform.position )
if len( self.current_path ) == 0 :
self.current_path = 0
self.body.linearVelocity = ( 0, 0 )
return False
return True
self.move_to_tile( self.current_tile )
return True
return True
self.current_path = self.scene.map.find_path( self.body.transform.position, new_pos )
if self.current_path == 0 :
self.stop()
return False
self.current_tile = self.current_path.pop( 0 )
self.move_to_tile( self.current_tile )
def move_to_tile( self, tile ) :
radians_to_tile = get_radians_between_points( self.body.transform.position, tile )
self.body_handler.turn( radians_to_tile )
movement_vector = get_movement_vector( radians_to_tile, self.speed )
self.body.linearVelocity = movement_vector
def take_damage( self, origin, damage ) :
if self.immunities.__contains__( damage.type ) :
return True
if self.health > 0 :
self.health -= damage.value
if self.body_handler != 0 :
self.body_handler.blink()
if self.health <= 0 :
self.die( origin )
return True
return False
def die( self, origin ) :
if self.alive == False :
return False
self.scene.remove_entity( self )
if "projectile" not in self.types :
self.scene.game.sound_handler.play_sound("death")
self.alive = False
return True
def pickup( self, item, slot, key, body ) :
if slot.item != 0 :
if slot.item.body == body :
return 0
self.scene.game.sound_handler.play_sound("pick_up")
if item.picked( self, slot ) == True :
return True
self.body_handler.attach_item( key, item )
self.set_current_item( 'weapon' )
return True