def acceleration(self, pos, d):
A = -G * (pos + np.array([d, 0.0, 0.0])) * (self.mass / 2) / (
v.length(pos + np.array([d, 0.0, 0.0]))**3
) # first mass contibution
B = -G * (pos + np.array([-d, 0.0, 0.0])) * (self.mass / 2) / (
v.length(pos + np.array([-d, 0.0, 0.0]))**3
) # second mass contibution
return A + B # full acceleration
def acceleration_rotational(self, pos, d, angle):
x_r = d * math.cos(angle)
y_r = d * math.sin(angle)
A = -G * (pos + np.array([x_r, y_r, 0.0])) * (self.mass / 2) / (
v.length(pos + np.array([x_r, y_r, 0.0]))**3
) # first mass contibution
B = -G * (pos + np.array([-x_r, -y_r, 0.0])) * (self.mass / 2) / (
v.length(pos + np.array([-x_r, -y_r, 0.0]))**3
) # second mass contibution
return A + B # full acceleration
def _localVertices(self):
w, h = self.size[0], self.size[1]
rot = self.rot
radius = vectors.length((0, 0), (w, h)) / 2
# top right corner
# ______
# | /|
# | / |
# | /__|
# |a |
# | |
# |______|
a = math.asin(h/(2 * radius))
#c = (radius * round(cos(rot + a), 2), radius * round(sin(rot + a), 2))
c = vectors.component(radius, rot + a)
v = [(c[0], c[1])]
# top left corner
#c = (radius * round(cos(rot + pi - a), 2), radius * round(sin(rot + pi - a), 2))
c = vectors.component(radius, rot + (math.pi - a))
v.append((c[0], c[1]))
# bottom left corner
#c = (radius * round(cos(rot + pi + a), 2), radius * round(sin(rot + pi + a), 2))
c = vectors.component(radius, rot + (math.pi + a))
v.append((c[0], c[1]))
# bottom right corner
#c = (radius * round(cos(rot - a), 2), radius * round(sin(rot - a), 2))
c = vectors.component(radius, rot - a)
v.append((c[0], c[1]))
return (list(map(lambda t: (round(t[0], 2), round(t[1], 2)), v)))
def _localVertices(self):
w, h = self.size[0], self.size[1]
rot = self.rot
radius = vectors.length((0, 0), (w, h)) / 2
# top right corner
# ______
# | /|
# | / |
# | /__|
# |a |
# | |
# |______|
a = math.asin(h / (2 * radius))
#c = (radius * round(cos(rot + a), 2), radius * round(sin(rot + a), 2))
c = vectors.component(radius, rot + a)
v = [(c[0], c[1])]
# top left corner
#c = (radius * round(cos(rot + pi - a), 2), radius * round(sin(rot + pi - a), 2))
c = vectors.component(radius, rot + (math.pi - a))
v.append((c[0], c[1]))
# bottom left corner
#c = (radius * round(cos(rot + pi + a), 2), radius * round(sin(rot + pi + a), 2))
c = vectors.component(radius, rot + (math.pi + a))
v.append((c[0], c[1]))
# bottom right corner
#c = (radius * round(cos(rot - a), 2), radius * round(sin(rot - a), 2))
c = vectors.component(radius, rot - a)
v.append((c[0], c[1]))
return (list(map(lambda t: (round(t[0], 2), round(t[1], 2)), v)))
def execute(self, obj):
pos = V.vector(obj.rect.center)
targpos = obj.target.rect.center
traveltime = V.length(pos-targpos)/obj.maxspeed
targvel = obj.target.velocity
futurepos = targpos + targvel*traveltime
desired_velocity = obj.maxspeed*V.normalize(futurepos - pos)
obj.steering = desired_velocity - obj.velocity
V.truncate(obj.steering, obj.maxforce)
def execute(self, obj):
pos = V.vector(obj.rect.center)
targpos = obj.target.rect.center
traveltime = V.length(pos - targpos) / obj.maxspeed
targvel = obj.target.velocity
futurepos = targpos + targvel * traveltime
desired_velocity = obj.maxspeed * V.normalize(pos - futurepos)
obj.steering = desired_velocity - obj.velocity
V.truncate(obj.steering, obj.maxforce)
def update(self):
self.prevpos = V.vector(self.rect.center).copy()
self.state.execute(self)
## Add a tiny force toward the center of the field
if False: #self.state != S.Wait():
center = V.vector(pygame.display.get_surface().get_rect().center)
towardcenter = center - self.rect.center
V.normalize_ip(towardcenter)
self.steering += 0.5 * towardcenter
self.velocity += FORCE_PER_TICK * self.steering / (self.mass)
V.truncate(self.velocity, self.maxspeed)
speed = V.length(self.velocity)
if speed > 0.001:
self.heading = V.normalize(self.velocity)
self.rect.center += self.velocity
self.depth = -self.rect.centery
#determine which image direction to use, based on heading and velocity:
if speed >= 0.001:
small = 0.382 # sin(22.5 degrees)
big = 0.923 # cos(22.5 degrees)
x, y = self.heading
if y >= big: self.dir = 's'
elif small <= y:
if x > 0: self.dir = 'se'
else: self.dir = 'sw'
elif -small <= y:
if x > 0: self.dir = 'e'
else: self.dir = 'w'
elif -big <= y:
if x > 0: self.dir = 'ne'
else: self.dir = 'nw'
else: self.dir = 'n'
else:
self.velocity[0] = self.velocity[1] = 0.0
#image action: stopped or moving?
if speed < 0.001:
self.aspeed = 0.5
action = 'looking'
else:
self.aspeed = 0.2 * speed
action = 'walking'
self.images = Images.get(self.name)[self.dir][action]
self.nframes = len(self.images)
#advance animation frame
self.frame = self.aspeed + self.frame
while self.frame >= self.nframes:
self.frame -= self.nframes
self.image = self.images[int(self.frame)]
def update(self):
self.prevpos = V.vector(self.rect.center).copy()
self.state.execute(self)
## Add a tiny force toward the center of the field
if False:#self.state != S.Wait():
center = V.vector(pygame.display.get_surface().get_rect().center)
towardcenter = center - self.rect.center
V.normalize_ip(towardcenter)
self.steering += 0.5*towardcenter
self.velocity += FORCE_PER_TICK*self.steering/(self.mass)
V.truncate(self.velocity, self.maxspeed)
speed = V.length(self.velocity)
if speed > 0.001:
self.heading = V.normalize(self.velocity)
self.rect.center += self.velocity
self.depth = -self.rect.centery
#determine which image direction to use, based on heading and velocity:
if speed >= 0.001:
small = 0.382 # sin(22.5 degrees)
big = 0.923 # cos(22.5 degrees)
x,y = self.heading
if y >= big: self.dir = 's'
elif small <= y:
if x > 0: self.dir = 'se'
else: self.dir = 'sw'
elif -small <= y:
if x > 0: self.dir = 'e'
else: self.dir = 'w'
elif -big <= y:
if x > 0: self.dir = 'ne'
else: self.dir = 'nw'
else: self.dir = 'n'
else:
self.velocity[0] = self.velocity[1] = 0.0
#image action: stopped or moving?
if speed < 0.001:
self.aspeed = 0.5
action = 'looking'
else:
self.aspeed = 0.2*speed
action = 'walking'
self.images = Images.get(self.name)[self.dir][action]
self.nframes = len(self.images)
#advance animation frame
self.frame = self.aspeed+self.frame
while self.frame >= self.nframes: self.frame -= self.nframes
self.image = self.images[int(self.frame)]
def shoot(self, weapon):
if weapon is "WEAP_BULLET":
entity.entBullet(self.ent.projloc("WEAP_BULLET"),
vec.component(
SPD_BULLET + vec.length(self.ent.vel),
self.ent.rot),
owner=self.ent)
print "bullet shot. travelling at %s units per frame %s, at an angle of %s radians" % (
SPD_BULLET, vec.component(SPD_BULLET,
self.ent.rot), self.ent.rot)
pass
def __init__(self,
pos,
rot=0,
vel=(0, 0),
player=False,
sprite=None,
size=None,
expiry=-1,
interact=True,
health=HEALTH_PLANE,
owner=None):
self.age = 0
self.expiry = expiry
self.health = health
self.owner = owner
self.pos = pos
# if rotation and velocity is given, use only the magnitude of the velocity
if rot:
self.rot = ROT_PLANE_INT * round(rot / ROT_PLANE_INT)
else:
self.rot = ROT_PLANE_INT * round(
vectors.anglex(vel) / ROT_PLANE_INT)
self.vel = vectors.component(vectors.length(vel), self.rot)
self.ctlfunc = control.ctlPlane(self)
self.player = player
if self.player:
Entity.players.append(self)
self.interact = interact
#if not Texture.textures.has_key("OBJ_PLANE"):
# Texture("OBJ_PLANE", IMGDIR + "OBJ_PLANE" + IMGEXT)
#self.texture = Texture.textures["OBJ_PLANE"]
#self.size = (40, 40)#(self.image.w, self.image.h)
if not sprite:
self.sprite = sprclass.plane
else:
self.sprite = sprite
if not size:
self.size = len(self.sprite[0]), len(self.sprite)
else:
self.size = size
self.cells = []
if self.interact:
cell.add(self)
Entity.entities.append(self)
def gradient_descent2(f, xstart, ystart, tolerance=1e-6):
i = 0
x = xstart
y = ystart
grad = approx_gradient2(f, x, y)
while length(grad) > tolerance:
i = i + 1
x -= 0.01 * grad[0]
y -= 0.01 * grad[1]
grad = approx_gradient2(f, x, y)
print(f'gradient_descent2: converged after {i} iterations')
return x, y
def gradient_descent(f, vstart, dx=1e-6, max_steps=1000):
v = vstart
grad = approx_gradient(f, v, dx)
steps = 0
while length(grad) > dx and steps < max_steps:
v = [(vi - 0.01 * dvi) for vi, dvi in zip(v, grad)]
grad = approx_gradient(f, v, dx)
steps += 1
print(f'gradient_descent: max_steps = {max_steps}')
print(
f'gradient_descent: converged or reached max_steps after {steps} steps'
)
return v
def pnt2line(pnt, start, end):
line_vec = vec.vector(start, end)
pnt_vec = vec.vector(start, pnt)
line_len = vec.length(line_vec)
line_unitvec = vec.unit(line_vec)
pnt_vec_scaled = vec.scale(pnt_vec, 1.0 / line_len)
t = vec.dot(line_unitvec, pnt_vec_scaled)
if t < 0.0:
t = 0.0
elif t > 1.0:
t = 1.0
nearest = vec.scale(line_vec, t)
dist = vec.distance(nearest, pnt_vec)
nearest = vec.add(nearest, start)
return (dist, nearest)
def __init__(self, pos, rot = 0, vel = (0, 0), player = False, sprite = None, size = None, expiry = -1, interact = True, health = HEALTH_PLANE, owner =
None):
self.age = 0
self.expiry = expiry
self.health = health
self.owner = owner
self.pos = pos
# if rotation and velocity is given, use only the magnitude of the velocity
if rot:
self.rot = ROT_PLANE_INT * round(rot / ROT_PLANE_INT)
else:
self.rot = ROT_PLANE_INT * round(vectors.anglex(vel) / ROT_PLANE_INT)
self.vel = vectors.component(vectors.length(vel), self.rot)
self.ctlfunc = control.ctlPlane(self)
self.player = player
if self.player:
Entity.players.append(self)
self.interact = interact
#if not Texture.textures.has_key("OBJ_PLANE"):
# Texture("OBJ_PLANE", IMGDIR + "OBJ_PLANE" + IMGEXT)
#self.texture = Texture.textures["OBJ_PLANE"]
#self.size = (40, 40)#(self.image.w, self.image.h)
if not sprite:
self.sprite = sprclass.plane
else:
self.sprite = sprite
if not size:
self.size = len(self.sprite[0]), len(self.sprite)
else:
self.size = size
self.cells = []
if self.interact:
cell.add(self)
Entity.entities.append(self)
def move(self, env):
#physics of forces on sail here
#src:https://en.wikipedia.org/wiki/Forces_on_sails#Effect_of_coefficients_of_lift_and_drag_on_forces
#f: (angle between wind and sail) -> (total force on sail)
# function returns matrix: Matrix * Wind = Total Force
def force_on_sails_matrix(wind, sail):
#1. get angle between wind and sail
orientation = np.sign(np.cross(wind, sail))
angle = v.angle(wind, sail)
if np.pi/2 < angle <= np.pi:
angle = abs(np.pi - angle)
orientation *= -1
#2. get forces on sail (for 0 <= angle <= pi/2)
#every ship has different parameters
#so this is just game model boat
#to test control self-education ability
drag = np.exp(abs(angle)/2) - 1
lift = -orientation * np.exp(-20*(angle - 0.6)**2)
return np.array([[drag, -lift], [lift, drag]])
#1. rotation
k_rotate = 0.05 * v.length(self.speed) #wheel -> rotate coefficient
self.speed = v.rotate(self.speed, (-1) * self.wheel * k_rotate)
#2. friction
k_friction = 0.05
self.speed = self.speed * (1 - k_friction)
#3. acceleration = forces on sails -> projection on boat direction
k_acceleration = 0.1
wind_apparent = env.wind - self.speed
total_force_matrix = force_on_sails_matrix(wind_apparent, v.rotate(self.speed, self.sail))
total_force = np.dot(total_force_matrix, wind_apparent)
self.speed += k_acceleration * v.projection(total_force, self.speed)
#4. move
self.location += self.speed
def gradient_descent3(f,
xstart,
ystart,
zstart,
tolerance=1e-6,
max_steps=1000):
x = xstart
y = ystart
z = zstart
grad = approx_gradient3(f, x, y, z)
steps = 0
while length(grad) > tolerance and steps < max_steps:
x -= 0.01 * grad[0]
y -= 0.01 * grad[1]
z -= 0.01 * grad[2]
grad = approx_gradient3(f, x, y, z)
steps += 1
print(f'gradient_descent3: max_steps = {max_steps}')
print(
f'gradient_descent3: converged or reached max_steps after {steps} steps'
)
return x, y, z
def getKinectEnergy(self):
return self.mass*((v.length(self.vel))**2)/2
from vectors import length, scale
def normalize(v):
l = length(v)
return scale(1/l, v)
# return tuple(coord / l for coord in v)
norm = normalize((-1, -1, 2))
print(norm, length(norm))
def main():
ip= CamImageProvider(0, "../resources/testdata.avi")
#ip = MovieImageProvider("../resources/testdata.avi",0,0)
sq = Square(0)
img,imgtime = ip.getImage(1)
m_d = SquareDetector(img, imgtime, 2, 0)
m_d.add_marker(sq)
angle_min = math.pi
angle_max = 0
angle_diff_min = 100
angle_diff_max = 0
prop_min = 40
prop_max = 0
rot_max = 0
debug.start_at(ip, 0)
while cv.WaitKey(1)<>27:
img,imgtime = ip.getImage(1)
if img is None:
return
# tmpimg = cv.CloneImage(draw_img)
# tmpimg2 = cv.CloneImage(draw_img)
# gray2 = cv.CloneImage(gray)
# gray3 = cv.CloneImage(gray)
# tmp = cv.CloneImage(gray)
# mask = cv.CloneImage(gray)
# mask2=cv.CloneImage(gray)
# cv.Set(mask2,1)
# cv.CvtColor(draw_img, gray, cv.CV_BGR2GRAY)
# cv.CvtColor(draw_img, tmpimg, cv.CV_BGR2HSV)
# cv.SetImageCOI(tmpimg, 1)
# cv.Copy(tmpimg, gray)
# print cv.MinMaxLoc(gray)
# cv.ShowImage("gray", gray)
if debug.is_time():
pass
m_d.find_markers(img,imgtime,True)
mar = m_d.markers[0]
points = mar.points
m_d.draw_markers(m_d.draw_img)
debug.show([m_d.draw_img],"main",1,1)
#debug.show_images()
if len(points)<>4 or cv.WaitKey(50)<>32:
continue
a = length(vector(points[0],points[1]))
b = length(vector(points[1],points[2]))
c = length(vector(points[2],points[3]))
d = length(vector(points[3],points[0]))
if a>c:
a,c = c,a
if b>d:
b,d = d,b
if c == 0.0:
print mar
else:
print "sides a/c:", a/c
if a/c > prop_max: prop_max = a/c
if a/c < prop_min: prop_min = a/c
if d==0.0:
print mar
else:
print "sides b/d", b/d
if b/d > prop_max: prop_max = b/d
if b/d < prop_min: prop_min = b/d
for cor in mar.corners:
if cor.angle < angle_min:angle_min = cor.angle
if cor.angle > angle_max:angle_max = cor.angle
if cor.rotation > rot_max: rot_max = cor.rotation
a,b,c,d = [c.angle for c in mar.corners]
if a>c:
a,c=c,a
if b>d:
b,d=d,b
if a/c > angle_diff_max: angle_diff_max=a/c
if a/c< angle_diff_min: angle_diff_min = a/c
print "angle diff a/c", a/c
if b/d > angle_diff_max: angle_diff_max=b/d
if b/d< angle_diff_min: angle_diff_min = b/d
print "angle diff b/d", b/d
print "angle_min", angle_min
print "angle_max", angle_max
print "prop_min", prop_min
print "prop_max", prop_max
print "rot_max",rot_max
print "angle_diff_min", angle_diff_min
print "angle_diff_max",angle_diff_max
def normalize(v):
l = length(v)
return scale(1/l, v)
def process(self):
actions = [] # immediate actions
# increase
for k in self.inter:
if self.inter[k] > 0:
self.inter[k] -= 1
if self.ent.player: # human input
# rotate. all this shit is so you can go like tapTAP to go up or down a slight level. roll on the arrows right?
if k_clockwise in Control.keyevents:
actions.append("ROT_CLOCK")
elif k_counterclockwise in Control.keyevents:
actions.append("ROT_COUNTER")
elif Control.keys[k_clockwise] and Control.keys[
k_counterclockwise]: # if both are pressed, going by key events will be unsynched
pass
elif Control.keys[
k_clockwise]: #or k_clockwise in Control.keyevents:
# self.ent.rot += ROT_PLANE_INT
actions.append("ROT_CLOCK")
elif Control.keys[
k_counterclockwise]: #or k_counterclockwise in Control.keyevents:
# self.ent.rot -= ROT_PLANE_INT
actions.append("ROT_COUNTER")
# accelerate
if Control.keys[k_accel] and Control.keys[k_decel]:
pass
elif Control.keys[k_accel] or k_accel in Control.keyevents:
# self.ent.vel = vectors.component(vectors.length(self.ent.vel) + 1, self.ent.rot)
actions.append("ACCEL")
elif Control.keys[k_decel] or k_decel in Control.keyevents:
# self.ent.vel = vectors.component(vectors.length(self.ent.vel) - 1, self.ent.rot)
actions.append("DECEL")
# shoot
if Control.keys[k_gun] or k_gun in Control.keyevents:
# self.shoot()
actions.append("SHOOT_BULLET")
else: # AI
# will have to adapt this to teammates / opponents, not just players
if not entity.Entity.players:
return
# calculate closest player
nearplayer = entity.Entity.players[0]
neardist = math.fabs(self.ent.pos[0] - nearplayer.pos[0])
for p in entity.Entity.players:
if math.fabs(self.ent.pos[0] - p.pos[0]) < neardist:
nearplayer = p
# set course
realangle = vec.anglex((nearplayer.pos[0] - self.ent.pos[0],
nearplayer.pos[1] - self.ent.pos[1]))
if realangle < 0:
realangle = 2 * math.pi + realangle
rotangle = ROT_PLANE_INT * int(realangle / ROT_PLANE_INT)
xdist = math.fabs(nearplayer.pos[0] - self.ent.pos[0])
ydist = math.fabs(nearplayer.pos[1] - self.ent.pos[1])
#pys = [y for _, y in nearplayer.vertices()]
#ptop = max(pys)
#pbottom = min(pys)
pvs = nearplayer.vertices()
pxs = [x for x, _ in pvs]
pys = [y for _, y in pvs]
left, right = min(pxs), max(pxs)
bottom, top = min(pys), max(pys)
#print self.ent, self.ent.rot, rotangle
# set course. if far away, take your turns easy, otherwise, sharp is ok
#if xdist > AI_PLANE_ACT_DIST: # far, easy
cmpangle = rotangle
#else: # close, hard
# cmpangle = realangle
# latter conditions checks for alignment
if self.ent.rot < cmpangle:
if cmpangle - self.ent.rot > math.pi:
actions.append("ROT_COUNTER")
else:
actions.append("ROT_CLOCK")
elif self.ent.rot > cmpangle:
if self.ent.rot - cmpangle > math.pi:
actions.append("ROT_CLOCK")
else:
actions.append("ROT_COUNTER")
# speed up
if xdist <= AI_PLANE_SLOW_DIST:
actions.append("DECEL")
else:
actions.append("ACCEL")
# woah, cool
def supercmp(f):
if not f and f == self.ent.vel[0]:
return cmp(nearplayer.pos[0] - self.ent.pos[0], 0)
elif not f and f == self.ent.vel[1]:
return cmp(nearplayer.pos[1] - self.ent.pos[1], 0)
return cmp(f, 0)
# blaze
if xdist <= AI_PLANE_ACT_DIST:
# facing the bastard
if ((supercmp(self.ent.vel[0]) == cmp(nearplayer.pos[0] - self.ent.pos[0], 0)) and \
(supercmp(self.ent.vel[1]) == cmp(nearplayer.pos[1] - self.ent.pos[1], 0))):
# ^ test is failing on vel[0] == 0 or vel[1] == 0
# b = y - mx. we take the linear equation of our ai's velocity,
# and compare its offset (b = 0) with the offset computed by
# substituting the y and x values of each vertex of the player.
# if these vertices lie both above (b > 0) and below (b < 0)
# the line of velocity, then a bullet might intersect, so shoot, shoot
#if not self.ent.vel[0]:
if not self.ent.vel[0]: # up/down
if self.ent.pos[0] > left and self.ent.pos[0] < right:
actions.append("SHOOT_BULLET")
else:
slope = self.ent.vel[1] / self.ent.vel[0]
b = self.ent.pos[1] - slope * self.ent.pos[0]
above = below = False
for v in pvs:
if (v[1] - slope * v[0]) > b:
above = True
else:
below = True
if above and below:
break
if above and below:
actions.append("SHOOT_BULLET")
# perform actions
for a in actions:
if a == "ROT_CLOCK" and not self.inter["ROT"]:
self.ent.rot += ROT_PLANE_INT
if self.ent.rot >= 2 * math.pi:
self.ent.rot = 0
self.ent.vel = vec.component(vec.length(self.ent.vel),
self.ent.rot)
self.inter["ROT"] = INT_ROT_PLANE
elif a == "ROT_COUNTER" and not self.inter["ROT"]:
self.ent.rot -= ROT_PLANE_INT
if self.ent.rot < 0:
self.ent.rot = 2 * math.pi - ROT_PLANE_INT
self.ent.vel = vec.component(vec.length(self.ent.vel),
self.ent.rot)
self.inter["ROT"] = INT_ROT_PLANE
elif a == "ACCEL" and not self.inter["ACCEL"] and vec.length(
self.ent.vel) < SPD_PLANE_MAX:
self.ent.vel = vec.component(
vec.length(self.ent.vel) + 1, self.ent.rot)
self.inter["ACCEL"] = INT_ACCEL_PLANE
elif a == "DECEL" and not self.inter["DECEL"] and vec.length(
self.ent.vel) > SPD_PLANE_MIN:
self.ent.vel = vec.component(
vec.length(self.ent.vel) - 1, self.ent.rot)
self.inter["DECEL"] = INT_DECEL_PLANE
elif a == "SHOOT_BULLET" and not self.inter["SHOOT_BULLET"]:
self.shoot("WEAP_BULLET")
self.inter["SHOOT_BULLET"] = INT_BULLET_PLANE
def shoot(self, weapon):
if weapon is "WEAP_BULLET":
entity.entBullet(self.ent.projloc("WEAP_BULLET"), vec.component(SPD_BULLET + vec.length(self.ent.vel), self.ent.rot), owner = self.ent)
print "bullet shot. travelling at %s units per frame %s, at an angle of %s radians" % (SPD_BULLET, vec.component(SPD_BULLET, self.ent.rot), self.ent.rot)
pass
def process(self):
actions = [] # immediate actions
# increase
for k in self.inter:
if self.inter[k] > 0:
self.inter[k] -= 1
if self.ent.player: # human input
# rotate. all this shit is so you can go like tapTAP to go up or down a slight level. roll on the arrows right?
if k_clockwise in Control.keyevents:
actions.append("ROT_CLOCK")
elif k_counterclockwise in Control.keyevents:
actions.append("ROT_COUNTER")
elif Control.keys[k_clockwise] and Control.keys[k_counterclockwise]: # if both are pressed, going by key events will be unsynched
pass
elif Control.keys[k_clockwise]: #or k_clockwise in Control.keyevents:
# self.ent.rot += ROT_PLANE_INT
actions.append("ROT_CLOCK")
elif Control.keys[k_counterclockwise]: #or k_counterclockwise in Control.keyevents:
# self.ent.rot -= ROT_PLANE_INT
actions.append("ROT_COUNTER")
# accelerate
if Control.keys[k_accel] and Control.keys[k_decel]:
pass
elif Control.keys[k_accel] or k_accel in Control.keyevents:
# self.ent.vel = vectors.component(vectors.length(self.ent.vel) + 1, self.ent.rot)
actions.append("ACCEL")
elif Control.keys[k_decel] or k_decel in Control.keyevents:
# self.ent.vel = vectors.component(vectors.length(self.ent.vel) - 1, self.ent.rot)
actions.append("DECEL")
# shoot
if Control.keys[k_gun] or k_gun in Control.keyevents:
# self.shoot()
actions.append("SHOOT_BULLET")
else: # AI
# will have to adapt this to teammates / opponents, not just players
if not entity.Entity.players:
return
# calculate closest player
nearplayer = entity.Entity.players[0]
neardist = math.fabs(self.ent.pos[0] - nearplayer.pos[0])
for p in entity.Entity.players:
if math.fabs(self.ent.pos[0] - p.pos[0]) < neardist:
nearplayer = p
# set course
realangle = vec.anglex((nearplayer.pos[0] - self.ent.pos[0], nearplayer.pos[1] - self.ent.pos[1]))
if realangle < 0:
realangle = 2 * math.pi + realangle
rotangle = ROT_PLANE_INT * int(realangle / ROT_PLANE_INT)
xdist = math.fabs(nearplayer.pos[0] - self.ent.pos[0])
ydist = math.fabs(nearplayer.pos[1] - self.ent.pos[1])
#pys = [y for _, y in nearplayer.vertices()]
#ptop = max(pys)
#pbottom = min(pys)
pvs = nearplayer.vertices()
pxs = [x for x, _ in pvs]
pys = [y for _, y in pvs]
left, right = min(pxs), max(pxs)
bottom, top = min(pys), max(pys)
#print self.ent, self.ent.rot, rotangle
# set course. if far away, take your turns easy, otherwise, sharp is ok
#if xdist > AI_PLANE_ACT_DIST: # far, easy
cmpangle = rotangle
#else: # close, hard
# cmpangle = realangle
# latter conditions checks for alignment
if self.ent.rot < cmpangle:
if cmpangle - self.ent.rot > math.pi:
actions.append("ROT_COUNTER")
else:
actions.append("ROT_CLOCK")
elif self.ent.rot > cmpangle:
if self.ent.rot - cmpangle > math.pi:
actions.append("ROT_CLOCK")
else:
actions.append("ROT_COUNTER")
# speed up
if xdist <= AI_PLANE_SLOW_DIST:
actions.append("DECEL")
else:
actions.append("ACCEL")
# woah, cool
def supercmp(f):
if not f and f == self.ent.vel[0]:
return cmp(nearplayer.pos[0] - self.ent.pos[0], 0)
elif not f and f == self.ent.vel[1]:
return cmp(nearplayer.pos[1] - self.ent.pos[1], 0)
return cmp(f, 0)
# blaze
if xdist <= AI_PLANE_ACT_DIST:
# facing the bastard
if ((supercmp(self.ent.vel[0]) == cmp(nearplayer.pos[0] - self.ent.pos[0], 0)) and \
(supercmp(self.ent.vel[1]) == cmp(nearplayer.pos[1] - self.ent.pos[1], 0))):
# ^ test is failing on vel[0] == 0 or vel[1] == 0
# b = y - mx. we take the linear equation of our ai's velocity,
# and compare its offset (b = 0) with the offset computed by
# substituting the y and x values of each vertex of the player.
# if these vertices lie both above (b > 0) and below (b < 0)
# the line of velocity, then a bullet might intersect, so shoot, shoot
#if not self.ent.vel[0]:
if not self.ent.vel[0]: # up/down
if self.ent.pos[0] > left and self.ent.pos[0] < right:
actions.append("SHOOT_BULLET")
else:
slope = self.ent.vel[1] / self.ent.vel[0]
b = self.ent.pos[1] - slope * self.ent.pos[0]
above = below = False
for v in pvs:
if (v[1] - slope * v[0]) > b:
above = True
else:
below = True
if above and below:
break
if above and below:
actions.append("SHOOT_BULLET")
# perform actions
for a in actions:
if a == "ROT_CLOCK" and not self.inter["ROT"]:
self.ent.rot += ROT_PLANE_INT
if self.ent.rot >= 2 * math.pi:
self.ent.rot = 0
self.ent.vel = vec.component(vec.length(self.ent.vel), self.ent.rot)
self.inter["ROT"] = INT_ROT_PLANE
elif a == "ROT_COUNTER" and not self.inter["ROT"]:
self.ent.rot -= ROT_PLANE_INT
if self.ent.rot < 0:
self.ent.rot = 2 * math.pi - ROT_PLANE_INT
self.ent.vel = vec.component(vec.length(self.ent.vel), self.ent.rot)
self.inter["ROT"] = INT_ROT_PLANE
elif a == "ACCEL" and not self.inter["ACCEL"] and vec.length(self.ent.vel) < SPD_PLANE_MAX:
self.ent.vel = vec.component(vec.length(self.ent.vel) + 1, self.ent.rot)
self.inter["ACCEL"] = INT_ACCEL_PLANE
elif a == "DECEL" and not self.inter["DECEL"] and vec.length(self.ent.vel) > SPD_PLANE_MIN:
self.ent.vel = vec.component(vec.length(self.ent.vel) - 1, self.ent.rot)
self.inter["DECEL"] = INT_DECEL_PLANE
elif a == "SHOOT_BULLET" and not self.inter["SHOOT_BULLET"]:
self.shoot("WEAP_BULLET")
self.inter["SHOOT_BULLET"] = INT_BULLET_PLANE
def main():
ip = CamImageProvider(0, "../resources/testdata.avi")
#ip = MovieImageProvider("../resources/testdata.avi",0,0)
sq = Square(0)
img, imgtime = ip.getImage(1)
m_d = SquareDetector(img, imgtime, 2, 0)
m_d.add_marker(sq)
angle_min = math.pi
angle_max = 0
angle_diff_min = 100
angle_diff_max = 0
prop_min = 40
prop_max = 0
rot_max = 0
debug.start_at(ip, 0)
while cv.WaitKey(1) <> 27:
img, imgtime = ip.getImage(1)
if img is None:
return
# tmpimg = cv.CloneImage(draw_img)
# tmpimg2 = cv.CloneImage(draw_img)
# gray2 = cv.CloneImage(gray)
# gray3 = cv.CloneImage(gray)
# tmp = cv.CloneImage(gray)
# mask = cv.CloneImage(gray)
# mask2=cv.CloneImage(gray)
# cv.Set(mask2,1)
# cv.CvtColor(draw_img, gray, cv.CV_BGR2GRAY)
# cv.CvtColor(draw_img, tmpimg, cv.CV_BGR2HSV)
# cv.SetImageCOI(tmpimg, 1)
# cv.Copy(tmpimg, gray)
# print cv.MinMaxLoc(gray)
# cv.ShowImage("gray", gray)
if debug.is_time():
pass
m_d.find_markers(img, imgtime, True)
mar = m_d.markers[0]
points = mar.points
m_d.draw_markers(m_d.draw_img)
debug.show([m_d.draw_img], "main", 1, 1)
#debug.show_images()
if len(points) <> 4 or cv.WaitKey(50) <> 32:
continue
a = length(vector(points[0], points[1]))
b = length(vector(points[1], points[2]))
c = length(vector(points[2], points[3]))
d = length(vector(points[3], points[0]))
if a > c:
a, c = c, a
if b > d:
b, d = d, b
if c == 0.0:
print mar
else:
print "sides a/c:", a / c
if a / c > prop_max: prop_max = a / c
if a / c < prop_min: prop_min = a / c
if d == 0.0:
print mar
else:
print "sides b/d", b / d
if b / d > prop_max: prop_max = b / d
if b / d < prop_min: prop_min = b / d
for cor in mar.corners:
if cor.angle < angle_min: angle_min = cor.angle
if cor.angle > angle_max: angle_max = cor.angle
if cor.rotation > rot_max: rot_max = cor.rotation
a, b, c, d = [c.angle for c in mar.corners]
if a > c:
a, c = c, a
if b > d:
b, d = d, b
if a / c > angle_diff_max: angle_diff_max = a / c
if a / c < angle_diff_min: angle_diff_min = a / c
print "angle diff a/c", a / c
if b / d > angle_diff_max: angle_diff_max = b / d
if b / d < angle_diff_min: angle_diff_min = b / d
print "angle diff b/d", b / d
print "angle_min", angle_min
print "angle_max", angle_max
print "prop_min", prop_min
print "prop_max", prop_max
print "rot_max", rot_max
print "angle_diff_min", angle_diff_min
print "angle_diff_max", angle_diff_max
def length(self):
return vectors.length(self.coords)
def getEnergy(self, M):
return self.mass*((v.length(self.vel))**2)/2 - G*M*self.mass/v.length(self.pos)
def vectorLenc(self, M):
return np.cross(np.cross(self.vel,self.pos),self.vel)*self.mass*self.mass - self.pos*self.mass*G*M/v.length(self.pos)
def getPotentialEnergy(self, M):
return G*M*self.mass/v.length(self.pos)