rfg/nsi-rpg
3
2
Fork 0
Code Issues 13 Pull requests Actions Packages Projects Releases Wiki Activity

Merge pull request 'delta_time' (#34) from delta_time into main

Browse source 
Reviewed-on: #34
Reviewed-by: Adastram <adastram@noreply.tipragot.fr>
This commit is contained in:
Yannis 2024-01-13 20:05:55 +00:00
parent 561934e4ef 6cd2591659
commit ee17be37e2
8 changed files with 64 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/custom_AI.py
View file

@ -32,23 +32,23 @@ class WolfAI(MobAI):
# On vérifie que le loup peut voir le joueur
if player_distance <= self.ATTACK_DISTANCE:
# On rétablit la vitesse du loup à 1
self.entity.max_speed = 1.
# On rétablit la vitesse du loup à 60
self.entity.max_speed = 60.
# Si le loup touche le joueur, il lui inflige des dégats
if player.get_collisions_with_entity(self.entity):
player.take_damages(1)
# Si le loup n'est pas déja sur le joueur, on le fait s'en raprocher
if player_distance > self.entity.max_speed:
if player_distance > 1.:
self.entity.move(x_distance / player_distance*self.entity.max_speed,
y_distance / player_distance*self.entity.max_speed, self.map_manager)
y_distance / player_distance*self.entity.max_speed, self.map_manager, delta)
else:
# Comportement d'attente
# On diminue la vitesse
self.entity.max_speed = 0.5
self.entity.max_speed = 30.
self.timer -= delta
# Si le timer est fini et que le loup était en train d'attendre, il commence à marcher
@ -66,4 +66,4 @@ class WolfAI(MobAI):
# On fait avancer le loup quand il le doit
if self.comportment == 1:
self.entity.move(self.walk_x, self.walk_y, self.map_manager)
self.entity.move(self.walk_x, self.walk_y, self.map_manager, delta)

10
src/engine/camera.py
View file

@ -15,11 +15,11 @@ class Camera:
self.target_y = self.y
self.target_zoom = self.zoom
self.smoothness = 20.
self.smoothness = 0.5
self.followed_entity: Entity | None = None
def update(self):
def update(self, delta: float):
"""Met à jour la caméra. Permet, par exemple, de faire le scrolling."""
# Si on suit une entité, on met à jour les coordonnées de suivi
@ -29,9 +29,9 @@ class Camera:
self.target_y = (self.followed_entity.y + self.followed_entity.mouvements[1] *
self.player_moving_offset / self.zoom)
self.x += (self.target_x - self.x) / self.smoothness
self.y += (self.target_y - self.y) / self.smoothness
self.zoom += (self.target_zoom - self.zoom) / self.smoothness
self.x += (self.target_x - self.x)*delta / self.smoothness
self.y += (self.target_y - self.y)*delta / self.smoothness
self.zoom += (self.target_zoom - self.zoom)*delta / self.smoothness
def follow_entity(self, entity: Entity | None):
"""Active le suivit de l'entité donnée. Mettre `None` pour retirer le suivit."""

30
src/engine/engine.py
View file

@ -1,3 +1,5 @@
import time
from src.engine.boss_fight_manager import BossFightManager
from src.engine.camera import Camera
from src.engine.dialogs_manager import DialogsManager
@ -24,8 +26,6 @@ class Engine:
# Etat courant du jeu
self.game_state = GameState.NORMAL
self.clock = pygame.time.Clock()
self.running = False
# Composants du moteur de jeu
@ -44,20 +44,26 @@ class Engine:
"""Fonction à lancer au début du programme et qui va lancer les updates dans une boucle.
Attend jusqu'à la fin du jeu."""
self.running = True
while self.running:
self.update()
self.clock.tick(60.)
def update(self):
delta = 1. # Le delta est le temps depuis la dernière image
last_time = time.time_ns()/10E8
while self.running:
self.update(delta)
new_time = time.time_ns()/10E8
delta = new_time-last_time
last_time = new_time
def update(self, delta: float):
"""Fonction qui regroupe toutes les updates des composants. Elle permet de mettre à jour le jeu quand on
l'appelle."""
self.camera.update()
self.entity_manager.update(0.016666666)
self.renderer.update(0.016666666)
self.event_handler.update()
self.camera.update(delta)
self.entity_manager.update(delta)
self.renderer.update(delta)
self.event_handler.update(delta)
self.event_sheduler.update()
self.dialogs_manager.update(0.016666666)
self.sound_manager.update(1/60)
self.dialogs_manager.update(delta)
self.sound_manager.update(delta)
def stop(self):
"""Arrête le programme."""

27
src/engine/entity.py
View file

@ -65,8 +65,23 @@ class Entity:
# Si les coordonnées ont changé, l'entité a bougé
self.mouvements[0] = (self.x - self.last_x) / self.max_speed
self.mouvements[1] = (self.y - self.last_y) / self.max_speed
x_motion = (self.x - self.last_x)
if x_motion > 0:
self.mouvements[0] = 1
elif x_motion < 0:
self.mouvements[0] = -1
else:
self.mouvements[0] = 0
y_motion = (self.y - self.last_y)
if y_motion > 0:
self.mouvements[1] = 1
elif y_motion < 0:
self.mouvements[1] = -1
else:
self.mouvements[1] = 0
self.last_x = self.x
self.last_y = self.y
@ -116,10 +131,10 @@ class Entity:
return collision
def move(self, x: float, y: float, map_manager: MapManager):
def move(self, x: float, y: float, map_manager: MapManager, delta: float):
"""Fait bouger l'entité en tenant compte des collisions."""
if not self.locked: # Si l'entité n'est pas verrouillée on calcul le mouvement
if not self.locked: # Si l'entité n'est pas verrouillée on calcul le mouvement
# On vérifie le sens du mouvement pour changer self.direction
if x > 0:
@ -131,8 +146,8 @@ class Entity:
# On normalise la vitesse
initial_speed = math.sqrt(x**2+y**2)
x = x/initial_speed*self.max_speed
y = y/initial_speed*self.max_speed
x = x*delta/initial_speed*self.max_speed
y = y*delta/initial_speed*self.max_speed
# On simule le mouvement. Si on ne rencontre pas de collision, on applique le mouvement

7
src/engine/entity_manager.py
View file

@ -21,10 +21,10 @@ class EntityManager:
"""Définit l'entité donnée comme le joueur. Elle peut donc être controlée."""
self.player_entity_name = name
def move_player_controls(self, x: float, y: float):
def move_player_controls(self, x: float, y: float, delta: float):
"""Bouge le joueur. X et y doivent être compris entre 0 et 1"""
player: Entity = self.get_by_name(self.player_entity_name)
player.move(x, y, self.map_manager)
player.move(x, y, self.map_manager, delta)
def update(self, delta: float):
"""Met à jour toutes les entités enregistrées."""
@ -61,7 +61,6 @@ class EntityManager:
e.lock()
self.paused = True
def resume(self):
"""Reprend les mouvement de toutes les entitées qui n'étaient pas lock avant l'appel de .pause()"""
for e in self.get_all_entities():
@ -69,4 +68,4 @@ class EntityManager:
e.unlock()
self.paused = False
self.locked_before_pause = []
self.locked_before_pause = []

12
src/engine/event_handler.py
View file

@ -98,7 +98,7 @@ class EventHandler:
return x_value, y_value
def update(self):
def update(self, delta: float):
"""Vérifie s'il y a de nouvelles interactions et les traites."""
window_size = display.get_window_size()
@ -203,13 +203,13 @@ class EventHandler:
if self.engine.entity_manager.player_entity_name:
if K_RIGHT in self.key_pressed:
self.engine.entity_manager.move_player_controls(1, 0)
self.engine.entity_manager.move_player_controls(1, 0, delta)
if K_LEFT in self.key_pressed:
self.engine.entity_manager.move_player_controls(-1, 0)
self.engine.entity_manager.move_player_controls(-1, 0, delta)
if K_UP in self.key_pressed:
self.engine.entity_manager.move_player_controls(0, -1)
self.engine.entity_manager.move_player_controls(0, -1, delta)
if K_DOWN in self.key_pressed:
self.engine.entity_manager.move_player_controls(0, 1)
self.engine.entity_manager.move_player_controls(0, 1, delta)
if K_SPACE in self.key_pressed:
self.engine.dialogs_manager.next_signal()
@ -221,7 +221,7 @@ class EventHandler:
if K_p in self.key_pressed:
self.engine.renderer.emit_particles(math.floor(self.engine.entity_manager.get_by_name("player").x),
math.floor(self.engine.entity_manager.get_by_name("player").y),
16, 16, 16, 1, 8, 0, 1, 0.2, 1., (0, 200, 200))
16, 16, 16, 1, 8, 0, 60., 0.2, 1., (0, 200, 200))
if K_o in self.key_pressed:
print(f"Player pos: X = {self.engine.entity_manager.get_by_name('player').x} "
f"Y = {self.engine.entity_manager.get_by_name('player').y}")

6
src/engine/renderer.py
View file

@ -172,7 +172,7 @@ class Renderer:
# Conteur de FPS en mode DEBUG
if self.engine.DEBUG_MODE:
self.window.blit(font.SysFont("Arial", 20).render(f"FPS: {round(self.engine.clock.get_fps())}, Game Status: {'Paused' if self.engine.entity_manager.paused else 'Playing'}", True, (255, 0, 0)),
self.window.blit(font.SysFont("Arial", 20).render(f"FPS: {round(1/delta if delta else 1)}, Game Status: {'Paused' if self.engine.entity_manager.paused else 'Playing'}", True, (255, 0, 0)),
(0, 0))
player = self.engine.entity_manager.get_by_name('player')
self.window.blit(font.SysFont("Arial", 20).render(f"X: {round(player.x, 2)} Y:{round(player.y, 2)}",
@ -480,8 +480,8 @@ class Renderer:
draw.rect(rendered_surface, part[7], part_dest + (part[2], part[2]))
part[5] += delta
part[0] += part[3]
part[1] += part[4]
part[0] += part[3]*delta
part[1] += part[4]*delta
if part[5] > part[6]:
self.particles.remove(part)

4
src/main.py
View file

@ -72,7 +72,7 @@ class Game(Engine):
player.collision_rect = [-6, -7, 6, 16]
player.set_default_life(15)
player.max_speed = 1.1
player.max_speed = 64.0
self.entity_manager.set_player_entity("player")
@ -95,7 +95,7 @@ class Game(Engine):
mob.collision_rect = [-15, -7, 12, 7]
mob.set_default_life(5)
mob.max_speed = 1.
mob.max_speed = 60.
mob.x, mob.y = 1600, 16