Adds an end screen.

Throot.py

@@ -11,11 +11,9 @@ from Games.Throot.artrepository import OBSTACLES
 from Games.Throot.player import Player
 from Games.Throot.map import ObstacleSlice, OBSTACLE_SLICES
 from Games.Throot.sprites import Obstacle, update_entities
-from Games.Throot.constants import CONST_FPS
+from Games.Throot.constants import *
 
 class GameManager:
-    EVENT_ROOM_CHANGE = {'start': 0, 'main': 1, 'end': 2, 'next': -1}
-    
     def __init__(self, *rooms):
          self.rooms = rooms
          self.room_index = 0
@@ -24,13 +22,14 @@ class GameManager:
         # Set the FPS (without this call, the default fps is 30)
         thumby.display.setFPS(CONST_FPS)
 
-    def room_goto(self, index):
+    def room_goto(self, event):
+        index = event['room']
         if index < 0:
             self.room_index = min(self.room_index + 1, len(self.rooms))
         else:
             self.room_index = index
             
-        self.rooms[self.room_index].start()
+        self.rooms[self.room_index].start(event)
 
     def restart(self):
         self.room_index = 0
@@ -41,11 +40,11 @@ class GameManager:
         thumby.display.update()
         
         if event:
-            self.room_goto(self.EVENT_ROOM_CHANGE[event])
+            self.room_goto(event)
         
 
 class Room:
-    def start(self):
+    def start(self, event):
         t0 = time.ticks_ms()   # Get time (ms)
         thumby.display.fill(0) # Fill canvas to black
     
@@ -58,7 +57,9 @@ class RoomTitle(Room):
         super().update(tpf)
         
         if thumby.inputPressed():
-            return 'main'
+            return {
+                'room': ROOM_MAIN
+            }
         
         # draw title sprite
         title_text = 'press a to start'
@@ -85,6 +86,13 @@ class GameLoop(Room):
         
         self.score = 0
     
+    def start(self, event):
+        self.current_depth = 0
+        self.entities.clear()
+        self.current_obstacle_slice = OBSTACLE_SLICES[0]
+        self.player = Player()
+        self.score = 0
+
     def get_obstacle_slice(self):
         return OBSTACLE_SLICES[randrange(0, len(OBSTACLE_SLICES))]
 
@@ -109,7 +117,7 @@ class GameLoop(Room):
         self.player.update_phys(self.current_depth, prev_depth)
 
         # Generate new entities as needed
-        self.entities |= update_entities(self.current_obstacle_slice, self.current_depth, prev_depth)
+        self.entities |= update_entities(self.entities, 5, self.current_depth, prev_depth)
 
         # Updates the entities
         to_remove = set()
@@ -118,7 +126,10 @@ class GameLoop(Room):
                 to_remove.add(entity)
             elif entity.intersects_pixel(self.player.xsub, self.player.ysub):
                 if isinstance(entity, Obstacle):
-                    print("Hit!")
+                    return {
+                        'room': ROOM_END,
+                        'score': self.score
+                    }
         self.entities -= to_remove
         
         self.score = int(self.current_depth * 10)
@@ -130,10 +141,29 @@ class GameLoop(Room):
         self.player.update_draw(self.player.y)
 
         thumby.display.drawText(str(self.score), thumby.display.width - (len(str(self.score)) + 2) * 5, 1, 1)
-        thumby.display.update()
+        
+class EndRoom(Room):
+    def __init__(self):
+        self.score = 0
+    
+    def start(self, event):
+        self.score = event['score']
+        # Used to make sure that we aren't triggering from input mean't for the game.
+        self.still_pressed = thumby.inputPressed()
+    
+    def update(self, tpf):
+        if not thumby.inputPressed():
+            self.still_pressed = False
+        elif not self.still_pressed and thumby.inputPressed():
+            return {
+                'room': ROOM_START
+            }
+        thumby.display.fill(0)
+        thumby.display.drawText("Final Score:", (thumby.display.width - 60) // 2, 1, 1)
+        thumby.display.drawText(str(self.score), (thumby.display.width - (len(str(self.score)) * 5)) // 2, 9, 1)
 
 def main():    
-    game = GameManager(RoomTitle(), GameLoop())
+    game = GameManager(RoomTitle(), GameLoop(), EndRoom())
     game.start()
 
     prev_time = 0

sprites.py

@@ -1,4 +1,5 @@
-from random import randint
+import math
+from random import randrange, random
 
 import thumby
 
@@ -101,7 +102,7 @@ class Obstacle(Entity):
         return self.can_render(current_depth)
 
 
-def update_entities(current_slice: ObstacleSlice, current_depth: int, prev_depth: int):
+def update_entities(entities, difficulty: int, current_depth: int, prev_depth: int):
     """
     Checks the current game state and generates new sprites based on said state.
 
@@ -118,24 +119,28 @@ def update_entities(current_slice: ObstacleSlice, current_depth: int, prev_depth
     :return:
         A list of entities to generate this tick.
     """
+    
+    OBSTACLE_BUFFER = 10
+    
     if current_depth == prev_depth:
         # If we haven't moved, we don't need to spawn anything
         return set()
-    # Local y relative to the top of the slice
-    slice_y = (current_depth) % ObstacleSlice.height
-    slice_prev_y = (prev_depth) % ObstacleSlice.height
-    if prev_depth < current_depth and slice_prev_y > slice_y:
-        slice_prev_y -= ObstacleSlice.height
-    elif current_depth < prev_depth and slice_y > slice_prev_y:
-        slice_prev_y += ObstacleSlice.height
-    min_y = min(slice_prev_y, slice_y)
-    max_y = max(slice_prev_y, slice_y)
+        
     spawned = set()
-    for entity in current_slice.obstacle_map:
-        # The position the entity should spawn at, relative to the slice top
-        entity_y = entity[1]
-        if entity_y >= min_y and entity_y < max_y:
-            sprite_image = OBSTACLES[entity[2]]
-            sprite = thumby.Sprite(sprite_image.width, sprite_image.height, sprite_image.image, 0, 0, 0, entity[3], entity[4])
-            spawned.add(Obstacle(entity[0], entity_y + current_depth // ObstacleSlice.height * ObstacleSlice.height, sprite_image.width, sprite_image.height, sprite_image.collision or sprite_image.image, sprite))
+    max_spawned = 1#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:
+        sprite_image = OBSTACLES[randrange(0, min((difficulty + 1) * 3, len(OBSTACLES)))]
+        if sprite_image.width >= thumby.display.width:
+            x = 0
+        else:
+            x = randrange(0, thumby.display.width - sprite_image.width)
+        y = current_depth
+        error = False
+        for entity in entities | spawned:
+            if x > (entity.x - OBSTACLE_BUFFER) and x <= (entity.x + entity.width + OBSTACLE_BUFFER) and y > (entity.y - OBSTACLE_BUFFER) and y <= (entity.y + entity.height + OBSTACLE_BUFFER):
+                error = True
+                break
+        if not error:
+            sprite = thumby.Sprite(sprite_image.width, sprite_image.height, sprite_image.image, 0, 0, 0, False, False)
+            spawned.add(Obstacle(x, y, sprite_image.width, sprite_image.height, sprite_image.collision or sprite_image.image, sprite))
     return spawned