def avoid_light_old(self, player_diff, player_distance):
#Get the brightness at a few points and go in the direction that it's
#Use green light for some reason
elapsed = globals.time - self.last_random
if elapsed < self.random_segments:
return
self.last_random = globals.time
self.fleeing = True
sp = self.screen_pos
self.pixel_data = glReadPixels(sp.x - self.width * 2,
sp.y - self.width * 2, self.width * 4,
self.height * 4, GL_RGB, GL_FLOAT)[:, :,
1:3]
max_index = numpy.argmax(self.pixel_data[:, :, 1:2])
min_index = numpy.argmin(self.pixel_data[:, :, 1:2])
indices = numpy.unravel_index((max_index, min_index),
self.pixel_data.shape)
max_index = indices[0][0], indices[1][0], indices[2][0]
min_index = indices[0][1], indices[1][1], indices[2][1]
#print 'max=',max_index,self.pixel_data[max_index]
#print 'test',self.pixel_data[indices]
d = Point(indices[0][0] - indices[0][1],
indices[1][0] - indices[1][1]).unit_vector()
if d.length() == 0:
self.seek_player(player_diff, player_distance)
self.move_direction *= -1
self.move_direction = d.unit_vector() * self.speed
def avoid_light_old(self, player_diff, player_distance):
#Get the brightness at a few points and go in the direction that it's
#Use green light for some reason
elapsed = globals.time - self.last_random
if elapsed < self.random_segments:
return
self.last_random = globals.time
self.fleeing = True
sp = self.screen_pos
self.pixel_data = glReadPixels(sp.x-self.width*2,sp.y-self.width*2,self.width*4,self.height*4,GL_RGB,GL_FLOAT)[:,:,1:3]
max_index = numpy.argmax(self.pixel_data[:,:,1:2])
min_index = numpy.argmin(self.pixel_data[:,:,1:2])
indices = numpy.unravel_index((max_index,min_index),self.pixel_data.shape)
max_index = indices[0][0],indices[1][0],indices[2][0]
min_index = indices[0][1],indices[1][1],indices[2][1]
#print 'max=',max_index,self.pixel_data[max_index]
#print 'test',self.pixel_data[indices]
d = Point(indices[0][0]-indices[0][1],indices[1][0]-indices[1][1]).unit_vector()
if d.length() == 0:
self.seek_player(player_diff, player_distance)
self.move_direction *= -1
self.move_direction = d.unit_vector()*self.speed
class Actor(object):
texture = None
width = None
height = None
threshold = 0.01
initial_health = 100
max_speed = 0.25
max_square_speed = max_speed**2
def __init__(self, map, pos):
self.map = map
self.tc = globals.atlas.TextureSpriteCoords('%s.png' % self.texture)
self.quad = drawing.Quad(globals.quad_buffer, tc=self.tc)
self.size = Point(float(self.width) / 16, float(self.height) / 16)
self.corners = self.size, Point(-self.size.x, self.size.y), Point(
-self.size.x, -self.size.y), Point(self.size.x, -self.size.y)
self.corners = [p * 0.5 for p in self.corners]
self.corners_polar = [(p.length(), ((1 + i * 2) * math.pi) / 4)
for i, p in enumerate(self.corners)]
self.radius_square = (self.size.x / 2)**2 + (self.size.y / 2)**2
self.radius = math.sqrt(self.radius_square)
self.corners_euclid = [p for p in self.corners]
self.current_sound = None
self.last_update = None
self.dead = False
self.move_speed = Point(0, 0)
self.move_direction = Point(0, 0)
self.pos = None
self.last_damage = 0
self.health = self.initial_health
self.interacting = None
self.SetPos(pos)
self.set_angle(3 * math.pi / 2)
def RemoveFromMap(self):
if self.pos != None:
bl = self.pos.to_int()
tr = (self.pos + self.size).to_int()
for x in xrange(bl.x, tr.x + 1):
for y in xrange(bl.y, tr.y + 1):
self.map.RemoveActor(Point(x, y), self)
def AdjustHealth(self, amount):
self.health += amount
if self.health > self.initial_health:
self.health = self.initial_health
if self.health < 0:
#if self.dead_sound:
# self.dead_sound.play()
self.health = 0
self.dead = True
self.Death()
def damage(self, amount):
if globals.time < self.last_damage + self.immune_duration:
#woop we get to skip
return
self.last_damage = globals.time
self.AdjustHealth(-amount)
def SetPos(self, pos):
self.RemoveFromMap()
self.pos = pos
self.vertices = [((pos + corner) * globals.tile_dimensions).to_int()
for corner in self.corners_euclid]
bl = pos
tr = bl + self.size
bl = bl.to_int()
tr = tr.to_int()
#self.quad.SetVertices(bl,tr,4)
self.quad.SetAllVertices(self.vertices, 4)
for x in xrange(bl.x, tr.x + 1):
for y in xrange(bl.y, tr.y + 1):
self.map.AddActor(Point(x, y), self)
def TriggerCollide(self, other):
pass
def set_angle(self, angle):
self.angle = angle
self.corners_polar = [(p.length(),
self.angle + ((1 + i * 2) * math.pi) / 4)
for i, p in enumerate(self.corners)]
cnums = [cmath.rect(r, a) for (r, a) in self.corners_polar]
self.corners_euclid = [Point(c.real, c.imag) for c in cnums]
def Update(self, t):
self.Move(t)
def Move(self, t):
if self.last_update == None:
self.last_update = globals.time
return
elapsed = (globals.time - self.last_update) * globals.time_step
self.last_update = globals.time
self.move_speed += self.move_direction * elapsed
if self.move_speed.SquareLength() > self.max_square_speed:
self.move_speed = self.move_speed.unit_vector() * self.max_speed
friction = self.move_speed.unit_vector() * 0.03 * elapsed
if friction.SquareLength() < self.move_speed.SquareLength():
#self.move_speed *= 0.7*(1-(elapsed/1000.0))
self.move_speed -= friction
else:
self.move_speed = Point(0, 0)
if self.interacting:
self.move_speed = Point(0, 0)
amount = self.move_speed * elapsed
bl = self.pos.to_int()
tr = (self.pos + self.size).to_int()
for x in xrange(bl.x, tr.x + 1):
for y in xrange(bl.y, tr.y + 1):
try:
for actor in self.map.data[x][y].actors:
if actor is self:
continue
distance = actor.pos - self.pos
if distance.SquareLength(
) < self.radius_square + actor.radius_square:
overlap = self.radius + actor.radius - distance.length(
)
adjust = distance.unit_vector() * -overlap
#print type(self),self.radius,actor.radius,distance.length(),overlap,adjust
amount += adjust * 0.1
self.TriggerCollide(actor)
#We've hit, so move us away from it's centre by the overlap
except IndexError:
pass
#check each of our four corners
for corner in self.corners:
pos = self.pos + corner
target_x = pos.x + amount.x
if target_x >= self.map.size.x:
amount.x = 0
target_x = pos.x
elif target_x < 0:
amount.x = -pos.x
target_x = 0
target_tile_x = self.map.data[int(target_x)][int(pos.y)]
if target_tile_x.type in game_view.TileTypes.Impassable:
amount.x = 0
elif (int(target_x), int(pos.y)) in self.map.object_cache:
obj = self.map.object_cache[int(target_x), int(pos.y)]
if obj.Contains(Point(target_x, pos.y)):
amount.x = 0
target_y = pos.y + amount.y
if target_y >= self.map.size.y:
amount.y = 0
target_y = pos.y
elif target_y < 0:
amount.y = -pos.y
target_y = 0
target_tile_y = self.map.data[int(pos.x)][int(target_y)]
if target_tile_y.type in game_view.TileTypes.Impassable:
amount.y = 0
elif (int(pos.x), int(target_y)) in self.map.object_cache:
obj = self.map.object_cache[int(pos.x), int(target_y)]
if obj.Contains(Point(pos.x, target_y)):
amount.y = 0
self.SetPos(self.pos + amount)
if self.interacting:
diff = self.interacting.pos + (self.interacting.size *
0.5) - self.pos
distance = diff.length()
if distance > 2.5:
self.deactivate()
def GetPos(self):
return self.pos
def GetPosCentre(self):
return self.pos
def click(self, pos, button):
pass
def unclick(self, pos, button):
pass
@property
def screen_pos(self):
p = (self.pos * globals.tile_dimensions -
globals.game_view.viewpos._pos) * globals.scale
return p
class Actor(object):
texture = None
width = None
height = None
threshold = 0.01
initial_health = 100
max_speed = 0.25
max_square_speed = max_speed**2
def __init__(self,map,pos):
self.map = map
self.tc = globals.atlas.TextureSpriteCoords('%s.png' % self.texture)
self.quad = drawing.Quad(globals.quad_buffer,tc = self.tc)
self.size = Point(float(self.width)/16,float(self.height)/16)
self.corners = self.size, Point(-self.size.x,self.size.y), Point(-self.size.x,-self.size.y), Point(self.size.x,-self.size.y)
self.corners = [p*0.5 for p in self.corners]
self.corners_polar = [(p.length(),((1+i*2)*math.pi)/4) for i,p in enumerate(self.corners)]
self.radius_square = (self.size.x/2)**2 + (self.size.y/2)**2
self.radius = math.sqrt(self.radius_square)
self.corners_euclid = [p for p in self.corners]
self.current_sound = None
self.last_update = None
self.dead = False
self.move_speed = Point(0,0)
self.move_direction = Point(0,0)
self.pos = None
self.last_damage = 0
self.health = self.initial_health
self.interacting = None
self.SetPos(pos)
self.set_angle(3*math.pi/2)
def RemoveFromMap(self):
if self.pos != None:
bl = self.pos.to_int()
tr = (self.pos+self.size).to_int()
for x in xrange(bl.x,tr.x+1):
for y in xrange(bl.y,tr.y+1):
self.map.RemoveActor(Point(x,y),self)
def AdjustHealth(self,amount):
self.health += amount
if self.health > self.initial_health:
self.health = self.initial_health
if self.health < 0:
#if self.dead_sound:
# self.dead_sound.play()
self.health = 0
self.dead = True
self.Death()
def damage(self, amount):
if globals.time < self.last_damage + self.immune_duration:
#woop we get to skip
return
self.last_damage = globals.time
self.AdjustHealth(-amount)
def SetPos(self,pos):
self.RemoveFromMap()
self.pos = pos
self.vertices = [((pos + corner)*globals.tile_dimensions).to_int() for corner in self.corners_euclid]
bl = pos
tr = bl + self.size
bl = bl.to_int()
tr = tr.to_int()
#self.quad.SetVertices(bl,tr,4)
self.quad.SetAllVertices(self.vertices, 4)
for x in xrange(bl.x,tr.x+1):
for y in xrange(bl.y,tr.y+1):
self.map.AddActor(Point(x,y),self)
def TriggerCollide(self,other):
pass
def set_angle(self, angle):
self.angle = angle
self.corners_polar = [(p.length(),self.angle + ((1+i*2)*math.pi)/4) for i,p in enumerate(self.corners)]
cnums = [cmath.rect(r,a) for (r,a) in self.corners_polar]
self.corners_euclid = [Point(c.real,c.imag) for c in cnums]
def Update(self,t):
self.Move(t)
def Move(self,t):
if self.last_update == None:
self.last_update = globals.time
return
elapsed = (globals.time - self.last_update)*globals.time_step
self.last_update = globals.time
self.move_speed += self.move_direction*elapsed
if self.move_speed.SquareLength() > self.max_square_speed:
self.move_speed = self.move_speed.unit_vector() * self.max_speed
friction = self.move_speed.unit_vector()*0.03*elapsed
if friction.SquareLength() < self.move_speed.SquareLength():
#self.move_speed *= 0.7*(1-(elapsed/1000.0))
self.move_speed -= friction
else:
self.move_speed = Point(0,0)
if self.interacting:
self.move_speed = Point(0,0)
amount = self.move_speed * elapsed
bl = self.pos.to_int()
tr = (self.pos+self.size).to_int()
for x in xrange(bl.x,tr.x+1):
for y in xrange(bl.y,tr.y+1):
try:
for actor in self.map.data[x][y].actors:
if actor is self:
continue
distance = actor.pos - self.pos
if distance.SquareLength() < self.radius_square + actor.radius_square:
overlap = self.radius + actor.radius - distance.length()
adjust = distance.unit_vector()*-overlap
#print type(self),self.radius,actor.radius,distance.length(),overlap,adjust
amount += adjust*0.1
self.TriggerCollide(actor)
#We've hit, so move us away from it's centre by the overlap
except IndexError:
pass
#check each of our four corners
for corner in self.corners:
pos = self.pos + corner
target_x = pos.x + amount.x
if target_x >= self.map.size.x:
amount.x = 0
target_x = pos.x
elif target_x < 0:
amount.x = -pos.x
target_x = 0
target_tile_x = self.map.data[int(target_x)][int(pos.y)]
if target_tile_x.type in game_view.TileTypes.Impassable:
amount.x = 0
elif (int(target_x),int(pos.y)) in self.map.object_cache:
obj = self.map.object_cache[int(target_x),int(pos.y)]
if obj.Contains(Point(target_x,pos.y)):
amount.x = 0
target_y = pos.y + amount.y
if target_y >= self.map.size.y:
amount.y = 0
target_y = pos.y
elif target_y < 0:
amount.y = -pos.y
target_y = 0
target_tile_y = self.map.data[int(pos.x)][int(target_y)]
if target_tile_y.type in game_view.TileTypes.Impassable:
amount.y = 0
elif (int(pos.x),int(target_y)) in self.map.object_cache:
obj = self.map.object_cache[int(pos.x),int(target_y)]
if obj.Contains(Point(pos.x,target_y)):
amount.y = 0
self.SetPos(self.pos + amount)
if self.interacting:
diff = self.interacting.pos + (self.interacting.size*0.5) - self.pos
distance = diff.length()
if distance > 2.5:
self.deactivate()
def GetPos(self):
return self.pos
def GetPosCentre(self):
return self.pos
def click(self, pos, button):
pass
def unclick(self, pos, button):
pass
@property
def screen_pos(self):
p = (self.pos*globals.tile_dimensions - globals.game_view.viewpos._pos)*globals.scale
return p
