--- a/skaapsteker/physics.py	Sat May 07 14:40:04 2011 +0200
+++ b/skaapsteker/physics.py	Sat May 07 15:39:38 2011 +0200
@@ -50,20 +50,27 @@
         self._mask_cache = {} # image id -> collision bit mask
 
     def init_pos(self):
-        self._float_pos = self.rect.center
-
+        self._float_pos = cadd(self.rect.center, 0.0) # To make it a float
 
     def deltav(self, dv):
         self.velocity = cadd(self.velocity, dv)
 
-    def deltap(self, dt):
+    def get_vectors(self):
         self.velocity = cclamp(self.velocity, self.terminal_velocity)
+        return (self.velocity, self._float_pos)
+
+    def update_position(self, float_pos):
+        self._float_pos = float_pos
         old_pos = self.rect.center
-        self._float_pos = cadd(self._float_pos, cmul(self.velocity, dt))
-        self.rect.center = cint(self._float_pos)
-        delta_pos = csub(self.rect.center, old_pos)
-        self.collide_rect.move_ip(delta_pos)
-        self.floor_rect.move_ip(delta_pos)
+        self.rect.center = cint(float_pos)
+        displacement = csub(self.rect.center, old_pos)
+        self.collide_rect.move_ip(displacement)
+        self.floor_rect.move_ip(displacement)
+
+    def apply_velocity(self, dt):
+        velocity, pos = self.get_vectors()
+        new_pos = cadd(pos, cmul(velocity, dt))
+        self.update_position(new_pos)
 
     def _check_mask(self):
         mask = self._mask_cache.get(id(self.image))
@@ -216,46 +223,49 @@
 
                 if idx is not None:
                     # We can see no solide collisions now
-                    sprite.deltap(max(-1.1 * frac, -dt))
+                    sprite.apply_velocity(max(-1.1 * frac, -dt))
                     sprite.bounce(others[idx], normal)
 
         for other in others:
             sprite.collided(other)
 
 
-    def do_gravity(self, dt):
+    def apply_gravity(self, dt):
         dv = cmul(self.GRAVITY, dt)
         for sprite in self._gravitators:
-            if sprite.on_solid:
-                sprite.deltav((dv[0], 0.0))
-            else:
+            if not sprite.on_solid:
                 sprite.deltav(dv)
 
+    def apply_friction(self):
+        for sprite in self._mobiles:
+            sprite.apply_friction()
+
+    def handle_escaped_sprites(self):
+        inbound = self._bounds.colliderect
+        for sprite in self._mobiles:
+            if not inbound(sprite):
+                sprite.fix_bounds(self._bounds)
+
+    def get_dt(self):
+        now = time.time()
+        dt = now - self._last_time
+        self._last_time = now
+        return dt
 
     def update(self):
         if self._last_time is None:
             self._last_time = time.time()
             return
 
-        # find dt
-        now = time.time()
-        self._last_time, dt = now, now - self._last_time
-
-        self.do_gravity(dt)
+        dt = self.get_dt()
 
-        # friction
-        for sprite in self._mobiles:
-            sprite.apply_friction()
-
-        # kill sprites outside the world
-        inbound = self._bounds.colliderect
-        for sprite in self._mobiles:
-            if not inbound(sprite):
-                sprite.fix_bounds(self._bounds)
+        self.apply_gravity(dt)
+        self.apply_friction()
+        self.handle_escaped_sprites()
 
         # position update and collision check (do last)
         for sprite in self._mobiles:
-            sprite.deltap(dt)
+            sprite.apply_velocity(dt)
             sprite_collides = sprite.collide_rect.colliderect
             collisions = []
             for other in self._collision_groups[sprite.collision_layer]:
@@ -287,9 +297,9 @@
 
         # call update methods
         self._updaters.update()
+        self.handle_actions()
 
-        # Action stuff.
-        # Happens after updates, because we only want it for the next frame.
+    def handle_actions(self):
         for sprite in self._actors:
             actor_collide_rect = sprite.collide_rect.inflate((4, 4))
             for other in self._actionables: