Sets collectibles for ascending.

Update player.py

Throot.py

@@ -100,6 +100,7 @@ class RoomTitle(Room):
         thumby.display.drawSprite(spr_b)
 
 class GameLoop(Room):
+
     def __init__(self):
         self.diving_velocity = 10
         self.diving_accel = 0
@@ -125,13 +126,17 @@ class GameLoop(Room):
         )
         self.current_obstacle_slice = OBSTACLE_SLICES[0]
         self.player = Player()
-        self.player.yspeed = 10
+        self.player.speed_y = 16
+        self.player.isdecend = 1
         self.score = 'score' in event and event['score'] or 0
         self.level = 'level' in event and event['level'] or 0
 
         self.finish_depth = 100 + 5 * self.level ** 2
+        self.finish_height = -self.finish_depth
         self.camera = Camera(self.player)
 
+        self.stage = DESCEND_STAGE
+
     def get_obstacle_slice(self):
         return OBSTACLE_SLICES[randrange(0, len(OBSTACLE_SLICES))]
 
@@ -201,7 +206,7 @@ class GameLoop(Room):
         """
         super().update(tpf)
 
-        self.player.update_phys(tpf, self.camera)
+        self.player.update_phys(tpf, self.stage in (DESCEND_STAGE, ASCEND_STAGE) and self.camera or None)
 
         self.camera.update_phys()
 
@@ -231,15 +236,23 @@ class GameLoop(Room):
         self.score += int(abs(self.player.ysub - self.player.prev_y) * 10)
 
         # finish level
-        if self.player.y > self.finish_depth + int(thumby.display.height * 1.5):
-            self.score += 20
-            self.level += 1
-            self.start({
-                'score': self.score,
-                'level': self.level
-            })
+        if self.stage == DESCEND_STAGE:
+            if self.player.y > self.finish_depth + int(thumby.display.height * 1.5):
+                self.stage = ASCEND_STAGE
+                self.player.ysub = 0
+                self.player.prev_y = 0
+                self.player.speed_y *= -1
+                self.player.isdecend = 0
+        elif self.stage == ASCEND_STAGE:
+            if self.player.y < self.finish_height - int(thumby.display.height * 1.5):
+                self.score += 20
+                self.level += 1
+                self.start({
+                    'score': self.score,
+                    'level': self.level
+                })
 
-        thumby.display.fill(0)
+        thumby.display.fill(int(self.player.y < 0))
         self.draw_sky()
         # Draw the entities
         for entity in self.entities:
@@ -248,7 +261,7 @@ class GameLoop(Room):
 
         self.draw_water()
 
-        thumby.display.drawText(str(self.score), thumby.display.width - (len(str(self.score)) + 2) * 5, 1, 1)
+        thumby.display.drawText(str(self.score), thumby.display.width - (len(str(self.score)) + 2) * 5, 1, int(self.player.y > 0))
 
 
 class EndRoom(Room):

constants.py

@@ -5,3 +5,13 @@ ROOM_MAIN = 1
 ROOM_END = 2
 ROOM_NEXT = -1
 
+
+# The first part of the level, where we are reaching the water
+DESCEND_STAGE = 0
+# The transition to the second part of the level, where the camera travels
+# back to the surface
+WATER_STAGE = 1
+# The second part of the level, where we are growing into the sky
+ASCEND_STAGE = 2
+# The "level complete" animation
+BLOOM_STAGE = 3

player.py

@@ -2,19 +2,26 @@ import time
 import thumby
 import math
 import random
+from collections import namedtuple
 
 from Games.Throot.constants import CONST_FPS
 
 # didplay width 72
 # display height 40
 
-# constants
-CONST_PL_SCREEN_Y =  int((0.5) * thumby.display.height)
+class Input:
+    def move_right(self):
+        return (
+            thumby.buttonA.pressed() or
+            thumby.buttonR.pressed()
+        )
 
-CONST_INP_MOVE_LEFT = thumby.buttonL
-CONST_INP_MOVE_RIGHT = thumby.buttonA
+    def move_left(self):
+        return thumby.buttonL.pressed()
 
-# classes
+inp = Input()
+
+### classes
 class Player:
     def __init__(self):
         self.prev_x = 0
@@ -24,61 +31,74 @@ class Player:
         self.x = int(self.xsub)
         self.y = int(self.ysub)
 
-        self.movespeed = 32 / CONST_FPS
         self.isdecend = 1
 
-        self.xspeed = 32 / CONST_FPS
-        self.yspeed = 32
-        self.accx = 1 / (CONST_FPS * 4)
-        self.accaccx = self.accx
+        self.input_x = float(0)
+
+        # constants
+        self.speed_x_start = 32
+        self.speed_x_max = 200
+        self.acc_x_start = 64
+        self.jerk_x = 128
+
+        self.speed_x = self.speed_x_start
+        self.acc_x = self.acc_x_start
+
+        # y speed is constant
+        self.speed_y = 16
+
+        self.anim = PlayerAnimation(self)
 
-        self.anim = PlayerAnimation(self.x, self.y)
-        self.debugvisible = False
 
     def update_phys(self, tpf, camera: Camera):
+        # prevoius sub pixel position
         self.prev_x = self.xsub
         self.prev_y = self.ysub
-        inp = int(0)
-        if CONST_INP_MOVE_LEFT.pressed():
-            inp -= 1
-        if CONST_INP_MOVE_RIGHT.pressed():
-            inp += 1
-        
-        # debug visible
-        if thumby.buttonU.pressed():
-            self.debugvisible = not self.debugvisible
 
         ### x movement
-        self.xspeed += self.accx
-        self.accx += self.accaccx
 
-        if (inp == 0) and (self.xspeed > self.movespeed):
-            self.xspeed = self.movespeed
-            self.accx = self.accaccx
+        # x input
+        if inp.move_left() and (not inp.move_right()):
+            self.input_x = -1
 
-        xx = self.xsub + inp * self.xspeed
+        if inp.move_right() and (not inp.move_left()):
+            self.input_x = 1
 
-        # clamp to screen
-        self.xsub = max(min(xx, thumby.display.width - 1), 0)
+        if (not inp.move_left()) and (not inp.move_right()):
+            self.input_x = 0
+
+        # acceleration and jerk
+        self.speed_x += self.acc_x * tpf
+        self.acc_x += self.jerk_x * tpf
+
+        # limit speed
+        self.speed_x = min(self.speed_x_max, self.speed_x)
+
+        # reset speed and acceleration if no input
+        if (self.input_x == 0) and (self.speed_x != self.speed_x_start):
+            self.speed_x = self.speed_x_start
+            self.acc_x = self.acc_x_start
+
+        # set x sub pixel position
+        self.xsub += self.speed_x * tpf * self.input_x
 
         ### y movement
 
-        self.ysub += self.yspeed * tpf
+        # set y sub pixel position
+        self.ysub += self.speed_y * tpf
+
+        ### stay in world bounds
+        self.xsub = max(min(self.xsub, thumby.display.width - 1), 0)
 
         ### pixel positions
         self.x = int(self.xsub)
         self.y = int(self.ysub)
 
-        # animation
-        self.anim.update_phys(self.x, self.y, camera)
+        ### animation physics
+        self.anim.update_phys(camera)
 
     def update_draw(self, camera):
-        # debug draw
-        if self.debugvisible:
-            pix_x, pix_y = camera.relative_to_camera(self.x, self.y)
-            thumby.display.setPixel(int(pix_x), int(pix_y), self.isdecend)
-        
-        # animation
+        ### animation render
         self.anim.update_draw(camera, self.isdecend)
 
 
@@ -101,46 +121,92 @@ class Camera:
         # position player
         self.y = self.target.y + self.offset
 
-
 class PlayerAnimation:
-    # width and height of range bounding box must be odd
-    RANDOM_RANGE = int(5)
-    POS_RANGE = int(3)
-    POS_X = int(0)
-    POS_Y = int(1)
+    MAX_ROOT_OFFSET = int(4)
 
-    def __init__(self, plworldx, plworldy):
-        self.poslist = [(plworldx, plworldy)]
-        self.debugrandomrange = self.RANDOM_RANGE
-        self.debugposrange = self.POS_RANGE
+    MAX_GROW_DISTANCE = int(6)#int(3)
+    MIN_GROW_DISTANCE = int(2)
 
-    def update_phys(self, plworldx, plworldy, camera):
+    Point = namedtuple("Point", ["x", "y"])
 
-        if plworldy < self.poslist[-1][self.POS_Y] + self.POS_RANGE:
-            return
+    def __init__(self, player):
+        self.player = player
 
-        ### get new position
-        rad = self.RANDOM_RANGE // 2
+        self.root_offset = self.MAX_ROOT_OFFSET
+        self.grow_distance = self.MAX_GROW_DISTANCE
 
-        # move last pos
-        self.poslist[-1] = (
-            plworldx + random.randrange(-rad, rad), 
-            plworldy + random.randrange(-rad, rad)
+        self.points = []
+        self.add_point()
+
+        self.debug_visible = False
+        self.debug_exact = True
+
+    def add_point(self):
+        self.points.append(self.Point(self.player.x, self.player.y))
+
+    def update_phys(self, camera):
+        # debug visible
+        if thumby.buttonB.justPressed():
+            self.debug_visible = not self.debug_visible
+
+        # debug exact
+        if thumby.buttonU.justPressed():
+            self.debug_exact = not self.debug_exact
+
+        # exit if distance from player to last root point is less than gorw distance
+        dist_sqr = (
+            (self.player.x - self.points[-1].x) ** 2 +
+            (self.player.y - self.points[-1].y) ** 2
         )
 
-        # new pos is perfectly on player
-        self.poslist.append((plworldx, plworldy))
+        if dist_sqr < self.grow_distance ** 2:
+            return
 
-        ### remove the fist item in the list if its full line is off screen
-        if not camera.entity_in_camera(self.poslist[1][self.POS_X], self.poslist[1][self.POS_Y]):
-            self.poslist.pop(0)
+        # set new grow distance
+        self.grow_distance = random.randint(self.MIN_GROW_DISTANCE, self.MAX_GROW_DISTANCE)
+
+        # offset last root point to look random
+        self.points[-1] = self.Point(
+            self.points[-1].x + random.randrange(-self.root_offset, self.root_offset),
+            self.points[-1].y + random.randrange(-self.root_offset, self.root_offset)
+        )
+
+        # new root point created exactly on player
+        self.add_point()
+
+        # remove points in list that would make lines off the camera
+        for point in self.points[1:]:
+            if camera.entity_in_camera(point.x, point.y):
+                break
+
+            self.points.pop(0)
 
     def update_draw(self, camera, isdecend=1):
-        ### draw line from first position to next
+        # debug render
+        if self.debug_visible:
+            pix_x, pix_y = camera.relative_to_camera(self.player.x, self.player.y)
+            thumby.display.setPixel(int(pix_x), int(pix_y), isdecend)
+            return
+
+        # root always reaches player position
+        if self.debug_exact:
+            x1, y1 = camera.relative_to_camera(self.player.x, self.player.y)
+            x2, y2 = camera.relative_to_camera(self.points[-1].x, self.points[-1].y)
+            thumby.display.drawLine(
+                int(x1),
+                int(y1),
+                int(x2),
+                int(y2),
+                isdecend
+            )
+
+        # draw line from first position to next
+        point_prev = self.points[-1]
+        for point in self.points[-2::-1]:
+            x1, y1 = camera.relative_to_camera(point_prev.x, point_prev.y)
+            x2, y2 = camera.relative_to_camera(point.x, point.y)
+            point_prev = point
 
-        for i in range(len(self.poslist) - 1):
-            x1, y1 = camera.relative_to_camera(self.poslist[i][self.POS_X], self.poslist[i][self.POS_Y])
-            x2, y2 = camera.relative_to_camera(self.poslist[i + 1][self.POS_X], self.poslist[i + 1][self.POS_Y])
             thumby.display.drawLine(
                 int(x1),
                 int(y1),

sprites.py

@@ -131,17 +131,25 @@ def update_entities(entities, difficulty: int, current_depth: int, prev_depth: i
         return set()
 
     spawned = set()
-    max_spawned = randrange(0, difficulty + 1)
-    while len(spawned) < max_spawned and random() < (2 * math.pow(difficulty + 0.01, 2)) / (3 * math.pow(difficulty + 0.01, 2) + 20 * (difficulty + 0.01)) + 0.05:
-        if random() < 0.2:
-            Clazz = Collectible
-            if current_depth >= 0:
-                sprite_image = collectibleunder
-            else:
-                sprite_image = collectibleover
-        else:
+    if current_depth > 0:
+        max_spawned = randrange(0, difficulty + 1)
+    else:
+        max_spawned = randrange(0, int(5 / (0.3 * difficulty + 0.7)))
+    print(f"Spawning {max_spawned} entities this tick")
+    while len(spawned) < max_spawned:
+        if current_depth > 0:
+            if random() >= (2 * math.pow(difficulty + 0.01, 2)) / (3 * math.pow(difficulty + 0.01, 2) + 20 * (difficulty + 0.01)) + 0.05:
+                print(f"Cancelling obstacles after {len(spawned)} entities")
+                break
             Clazz = Obstacle
             sprite_image = OBSTACLES[randrange(0, min((difficulty + 1) * 3, len(OBSTACLES)))]
+        else:
+            if random() >= 1 / (math.pow(difficulty, 2) + 3):
+                print(f"Cancelling obstacles after {len(spawned)} entities")
+                break
+            Clazz = Collectible
+            sprite_image = collectibleover
+
         if sprite_image.width >= thumby.display.width:
             x = 0
         else:
@@ -157,6 +165,6 @@ def update_entities(entities, difficulty: int, current_depth: int, prev_depth: i
                 error = True
                 break
         if not error:
-            sprite = thumby.Sprite(sprite_image.width, sprite_image.height, sprite_image.image, 0, 0, 0, False, False)
+            sprite = thumby.Sprite(sprite_image.width, sprite_image.height, sprite_image.image, 0, 0, int(y < 0), False, False)
             spawned.add(Clazz(x, y, sprite_image.width, sprite_image.height, sprite_image.collision or sprite_image.image, sprite))
     return spawned