def validate_entity_location(self, entity):
"""Entities should call when they change their own location.
Has a side effect of correcting entity locations at the boundaries,
something entities shouldn't have to know about, as well as updating
spatial indexes (something entities also shouldn't have to know about).
This is experimental. This makes me want to rethink how objects are
managed in the world and how movement occurs.
entity {Entity} An entity with a location.
"""
# Operate to speed up the writing.
entity.location[0] = mmval(self.width, entity.location[0])
entity.location[1] = mmval(self.height, entity.location[1])
self.spatial_index.update(entity)
def zoom_level(self, value):
"""{int}
"""
# Boundary check.
self._zoom_level = mmval(len(self.zoom_level_dims)-1, value, 0)
# Resize the viewable area.
self.rect.width = self.zoom_area_width
self.rect.height = self.zoom_area_height
# Correct the center point.
self.move(*self.rect.center)
def move(self, x=None, y=None):
"""Moves the viewport and adjusts the dimensions of the bounding
rectangle.
(x, y) make up the new center coordinate for the viewport.
Needs to be called to to after zoom level changes, too.
"""
max_width = self.maximim_zoom_dims[0]
max_height = self.maximim_zoom_dims[1]
# Default to the center of the largest view.
x = x if x != None else max_width/2
y = y if y != None else max_height/2
# Test to see if viewport center is out of range after the the zoom,
# if so, fix'um up. This can happen if you're at the edge of the
# screen and then zoom out - the center will be close to the edge.
x = mmval(max_width - self.zoom_area_width/2, x, self.zoom_area_width/2)
y = mmval(max_height - self.zoom_area_height/2, y, self.zoom_area_height/2)
# Update the visible area.
self.rect.center = (x, y)
def process(self, time_passed):
"""Manage velocity.
"""
if self.target_speed != None and self.target_speed != self.speed:
direction = 1 if self.target_speed > self.speed else -1
delta = time_passed * self.acceleration
speed = self.speed + math.copysign(delta, direction)
self.speed = mmval(self.target_speed, speed)
if self.target_course != None and self.target_course != self.course:
angleto = self.course.angleto(self.target_course)
direction = -1 if angleto <= 0 else 1
delta = direction * time_passed * self.rotation_speed
if abs(delta) <= abs(angleto):
self.course += delta
else:
self.course = self.target_course
loc = self.entity.location
dx, dy = self.deltaxy
self.entity.location = loc[0]+dx*time_passed, loc[1]+dy*time_passed
def target_speed(self, value):
self._target_speed = mmval(self.max_speed, float(value)) if value is not None else None
def val(self, value):
self._val = mmval(self.max, value, self.min)
