markil3/Throot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #9 from Markil3/negative-scroll

Browse Source 
Cleans up the scrolling code
This commit is contained in:
Neal Finger
2023-02-05 14:12:45 -07:00
committed by GitHub
parent e03d74be36 8d90129dbd
commit 05d5734c66
3 changed files with 64 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
Throot.py
View File

@@ -8,7 +8,7 @@ import Games.Throot.sprites
from random import randrange from random import randrange
from Games.Throot.artrepository import OBSTACLES from Games.Throot.artrepository import OBSTACLES
from Games.Throot.player import Player from Games.Throot.player import Player, Camera
from Games.Throot.map import ObstacleSlice, OBSTACLE_SLICES from Games.Throot.map import ObstacleSlice, OBSTACLE_SLICES
from Games.Throot.sprites import Obstacle, update_entities from Games.Throot.sprites import Obstacle, update_entities
from Games.Throot.constants import * from Games.Throot.constants import *
@@ -82,7 +82,8 @@ class GameLoop(Room):
self.current_obstacle_slice = OBSTACLE_SLICES[0] self.current_obstacle_slice = OBSTACLE_SLICES[0]
self.entities = set() self.entities = set()
self.player = Player() self.player = None
self.camera = None
self.score = 0 self.score = 0
@@ -91,7 +92,9 @@ class GameLoop(Room):
self.entities.clear() self.entities.clear()
self.current_obstacle_slice = OBSTACLE_SLICES[0] self.current_obstacle_slice = OBSTACLE_SLICES[0]
self.player = Player() self.player = Player()
self.player.yspeed = 10
self.score = 0 self.score = 0
self.camera = Camera(self.player)
def get_obstacle_slice(self): def get_obstacle_slice(self):
return OBSTACLE_SLICES[randrange(0, len(OBSTACLE_SLICES))] return OBSTACLE_SLICES[randrange(0, len(OBSTACLE_SLICES))]
@@ -101,28 +104,18 @@ class GameLoop(Room):
Executes one tick of the game Executes one tick of the game
""" """
super().update(tpf) super().update(tpf)
prev_depth = self.current_depth
self.diving_velocity += self.diving_accel * tpf self.player.update_phys(tpf, self.camera)
self.current_depth += self.diving_velocity * tpf
#print("%f (%f)" % (self.current_depth, self.current_depth % ObstacleSlice.height)) self.camera.update_phys()
#print("%f -> %f: %f -> %f" % (prev_depth, self.current_depth, prev_depth % ObstacleSlice.height, self.current_depth % ObstacleSlice.height))
if (
self.current_depth > prev_depth and self.current_depth % ObstacleSlice.height < prev_depth % ObstacleSlice.height
or self.current_depth < prev_depth and self.current_depth % ObstacleSlice.height > prev_depth % ObstacleSlice.height
):
self.current_obstacle_slice = self.get_obstacle_slice()
self.player.update_phys(self.current_depth, prev_depth)
# Generate new entities as needed # Generate new entities as needed
self.entities |= update_entities(self.entities, 5, self.current_depth, prev_depth) self.entities |= update_entities(self.entities, 5, self.player.ysub, self.player.prev_y)
# Updates the entities # Updates the entities
to_remove = set() to_remove = set()
for entity in self.entities: for entity in self.entities:
if not entity.update(tpf, self.current_depth, prev_depth): if not entity.update(tpf, self.player, self.camera) or abs(entity.y - self.player.y) > self.camera.height * 1.5:
to_remove.add(entity) to_remove.add(entity)
elif entity.intersects_pixel(self.player.xsub, self.player.ysub): elif entity.intersects_pixel(self.player.xsub, self.player.ysub):
if isinstance(entity, Obstacle): if isinstance(entity, Obstacle):
@@ -132,13 +125,13 @@ class GameLoop(Room):
} }
self.entities -= to_remove self.entities -= to_remove
self.score = int(self.current_depth * 10) self.score = self.player.x#int(abs(self.player.y) * 10)
thumby.display.fill(0) thumby.display.fill(0)
# Draw the entities # Draw the entities
for entity in self.entities: for entity in self.entities:
entity.render(tpf, self.current_depth, prev_depth) entity.render(tpf, self.camera)
self.player.update_draw(self.player.y) self.player.update_draw(self.camera)
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, 1)

51
player.py
View File

@@ -17,6 +17,8 @@ CONST_INP_MOVE_RIGHT = thumby.buttonA
# classes # classes
class Player: class Player:
def __init__(self): def __init__(self):
self.prev_x = 0
self.prev_y = 0
self.xsub = float(thumby.display.width / 2) self.xsub = float(thumby.display.width / 2)
self.ysub = float(0) self.ysub = float(0)
self.x = int(self.xsub) self.x = int(self.xsub)
@@ -26,14 +28,16 @@ class Player:
self.isdecend = 1 self.isdecend = 1
self.xspeed = 32 / CONST_FPS self.xspeed = 32 / CONST_FPS
self.yspeed = 32 / CONST_FPS self.yspeed = 32
self.accx = 1 / (CONST_FPS * 4) self.accx = 1 / (CONST_FPS * 4)
self.accaccx = self.accx self.accaccx = self.accx
self.anim = PlayerAnimation(self.x, self.y) self.anim = PlayerAnimation(self.x, self.y)
self.debugvisible = True self.debugvisible = True
def update_phys(self, current_depth, prev_depth): def update_phys(self, tpf, camera: Camera):
self.prev_x = self.xsub
self.prev_y = self.ysub
inp = int(0) inp = int(0)
if CONST_INP_MOVE_LEFT.pressed(): if CONST_INP_MOVE_LEFT.pressed():
inp -= 1 inp -= 1
@@ -58,35 +62,44 @@ class Player:
self.xsub = max(min(xx, thumby.display.width - 1), 0) self.xsub = max(min(xx, thumby.display.width - 1), 0)
### y movement ### y movement
self.ysub = current_depth - (thumby.display.height / 2)
self.ysub += self.yspeed * tpf
### pixel positions ### pixel positions
self.x = int(self.xsub) self.x = int(self.xsub)
self.y = int(self.ysub) self.y = int(self.ysub)
# animation # animation
self.anim.update_phys(self.x, self.y, CONST_PL_SCREEN_Y, current_depth) self.anim.update_phys(self.x, self.y, camera)
def update_draw(self, plworldy): def update_draw(self, camera):
# debug draw # debug draw
if self.debugvisible: if self.debugvisible:
pix_x = self.x pix_x, pix_y = camera.relative_to_camera(self.x, self.y)
pix_y = int(self.y - plworldy + 20) thumby.display.setPixel(int(pix_x), int(pix_y), self.isdecend)
thumby.display.setPixel(pix_x, pix_y, self.isdecend)
# animation # animation
self.anim.update_draw(plworldy - 20, self.isdecend) self.anim.update_draw(camera, self.isdecend)
class Camera: class Camera:
def __init__(self, target): def __init__(self, target):
self.x = int(0) self.x = int(0)
self.y = int(0) self.y = int(0)
self.width = thumby.display.width
self.height = thumby.display.height
self.offset = -self.height / 2
self.target = target self.target = target
def update_phys(self, plscreeny): def entity_in_camera(self, ent_x, ent_y, ent_width = 0, ent_height = 0) -> bool:
return ent_x + ent_width >= self.x and ent_y + ent_height >= self.y and ent_x < self.x + self.width and ent_y < self.y + self.height
def relative_to_camera(self, global_x, global_y):
return (global_x - self.x, global_y - self.y)
def update_phys(self):
# position player # position player
self.y = self.target.y - plscreeny self.y = self.target.y + self.offset
class PlayerAnimation: class PlayerAnimation:
@@ -101,7 +114,7 @@ class PlayerAnimation:
self.debugrandomrange = self.RANDOM_RANGE self.debugrandomrange = self.RANDOM_RANGE
self.debugposrange = self.POS_RANGE self.debugposrange = self.POS_RANGE
def update_phys(self, plworldx, plworldy, plscreeny, current_depth): def update_phys(self, plworldx, plworldy, camera):
#print(plworldx, plworldy, plscreeny, current_depth) #print(plworldx, plworldy, plscreeny, current_depth)
@@ -159,21 +172,23 @@ class PlayerAnimation:
# self.poslist.append((plworldx, plworldy)) # self.poslist.append((plworldx, plworldy))
### remove the fist item in the list if its full line is off screen ### remove the fist item in the list if its full line is off screen
if self.poslist[1][self.POS_Y] < plworldy - plscreeny: if not camera.entity_in_camera(self.poslist[1][self.POS_X], self.poslist[1][self.POS_Y]):
self.poslist.pop(0) self.poslist.pop(0)
#print(len(self.poslist)) #print(len(self.poslist))
def update_draw(self, topleft, prev_depth, isdecend=1): def update_draw(self, camera, isdecend=1):
### draw line from first position to next ### draw line from first position to next
#print(topleft) #print(topleft)
for i in range(len(self.poslist) - 1): 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( thumby.display.drawLine(
int(self.poslist[i][self.POS_X]), int(x1),
int(self.poslist[i][self.POS_Y] - topleft), int(y1),
int(self.poslist[i + 1][self.POS_X]), int(x2),
int(self.poslist[i + 1][self.POS_Y] - topleft), int(y2),
isdecend isdecend
) )

35
sprites.py
View File

@@ -4,6 +4,7 @@ from random import randrange, random
import thumby import thumby
from Games.Throot.map import ObstacleSlice from Games.Throot.map import ObstacleSlice
from Games.Throot.player import Player, Camera
from Games.Throot.artrepository import OBSTACLES from Games.Throot.artrepository import OBSTACLES
class Entity: class Entity:
@@ -36,9 +37,9 @@ class Entity:
return False return False
rel_x = int(loc_x - self.x) rel_x = int(loc_x - self.x)
rel_y = int(loc_y - self.y) rel_y = int(loc_y - self.y)
return bool((self.collision[rel_x] >> (self.height - rel_y)) & 1) return bool((self.collision[rel_x] >> (rel_y)) & 1)
def can_render(self, current_depth: int) -> bool: def can_render(self, camera: Camera) -> bool:
""" """
Checks to see if this sprite is within the game screen. Checks to see if this sprite is within the game screen.
@@ -49,15 +50,9 @@ class Entity:
:return: :return:
True if the sprite shows up on screen in any capacity, false otherwise. True if the sprite shows up on screen in any capacity, false otherwise.
""" """
if self.x < -self.width or self.x >= thumby.display.width: return camera.entity_in_camera(self.x, self.y, self.width, self.height)
return False
max = current_depth
min = max - thumby.display.height
if self.y < (min - self.height) or self.y > max:
return False
return True
def update(self, tpf: float, current_depth: int, prev_depth: int) -> bool: def update(self, tpf: float, player: Player, camera: Camera) -> bool:
""" """
Updates the state of the entity based on the game state. Updates the state of the entity based on the game state.
@@ -74,7 +69,7 @@ class Entity:
""" """
return False return False
def render(self, tpf: float, current_depth: int, prev_depth: int) -> bool: def render(self, tpf: float, camera: Camera) -> bool:
""" """
Sets the position of the sprite and draws it. Sets the position of the sprite and draws it.
@@ -90,16 +85,17 @@ class Entity:
should be hidden. should be hidden.
""" """
if self.sprite: if self.sprite:
self.sprite.y = int(self.y - current_depth + thumby.display.height) coordinates = camera.relative_to_camera(self.x, self.y)
self.sprite.x = int(self.x) self.sprite.x = coordinates[0]
if self.can_render(current_depth): self.sprite.y = coordinates[1]
if self.can_render(camera):
thumby.display.drawSprite(self.sprite) thumby.display.drawSprite(self.sprite)
return True return True
return False return False
class Obstacle(Entity): class Obstacle(Entity):
def update(self, tpf: float, current_depth: int, prev_depth: int) -> bool: def update(self, tpf: float, player: Player, camera: Camera) -> bool:
return self.can_render(current_depth) return True
def update_entities(entities, difficulty: int, current_depth: int, prev_depth: int): def update_entities(entities, difficulty: int, current_depth: int, prev_depth: int):
@@ -127,7 +123,7 @@ def update_entities(entities, difficulty: int, current_depth: int, prev_depth: i
return set() return set()
spawned = set() spawned = set()
max_spawned = 1#randrange(0, difficulty + 1) 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: 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)))] sprite_image = OBSTACLES[randrange(0, min((difficulty + 1) * 3, len(OBSTACLES)))]
if sprite_image.width >= thumby.display.width: if sprite_image.width >= thumby.display.width:
@@ -135,6 +131,10 @@ def update_entities(entities, difficulty: int, current_depth: int, prev_depth: i
else: else:
x = randrange(0, thumby.display.width - sprite_image.width) x = randrange(0, thumby.display.width - sprite_image.width)
y = current_depth y = current_depth
if current_depth > prev_depth:
y += thumby.display.height // 2
elif current_depth < prev_depth:
y -= thumby.display.height // 2 + sprite_image.height
error = False error = False
for entity in entities | spawned: 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): 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):
@@ -142,5 +142,6 @@ def update_entities(entities, difficulty: int, current_depth: int, prev_depth: i
break break
if not error: 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, 0, False, False)
print("Adding obstacle of to (%d, %d) of size (%d, %d)" % (x, y, sprite_image.width, sprite_image.height))
spawned.add(Obstacle(x, y, sprite_image.width, sprite_image.height, sprite_image.collision or sprite_image.image, sprite)) spawned.add(Obstacle(x, y, sprite_image.width, sprite_image.height, sprite_image.collision or sprite_image.image, sprite))
return spawned return spawned