chrz-development / supermariobros.3-pygame Goto Github PK

@dataclass
class ImageData(object):
    type_of_block: TypeOfBlock
    type_of_image: TypeOfImage

    x: int
    y: int
    name: str
    data: Surface

class Fps(object):
    def __init__(self):
        self.prev_time = time.time()
        self.clock = Clock()
        self.font = Font()

        self.benchmark = True

        self.get()

        self.t = 0
        self.dt = self.manage(fps=120)

        fps = round(self.clock.get_fps())
        self.countFps = 1
        self.sumFps = 0
        self.avg = fps//self.countFps
        self.max = fps
        self.min = 1_000_000

    def manage(self, fps):
        """ Manage the delta time (Time between two frame) """
        self.clock.tick(fps)     # Cadence the clock of the game
        self.dt = float(time.time() - self.prev_time)     # The time between old frame and the new frame
        self.prev_time = time.time()     # Previous frame
        return self.dt * 60     # 60 is fps we need to have in game

    def average(self):
        """ 
           Make a average of fps getted
           @return average of fps, max fps, min fps
        """
        fps = round(self.clock.get_fps())
        self.sumFps += fps
        self.countFps += 1
        self.avg = self.sumFps//self.countFps

        if fps > self.max:
            self.max = fps
        if self.min > fps > 0:
            self.min = fps

        return self.avg,self.max,self.min

    def get(self):
        """ get the framerate in game """
        return round(self.clock.get_fps())

    def draw(self,surface):
        """ Display on a surface all informations about the framerate in game """
        msg = [self.font.font.render(f'{self.get()} Fps',0,(255,255,255)),self.font.font.render(f'avg:  {self.avg} Fps',0,(255,255,255)),self.font.font.render(f'max: {self.max} Fps',0,(255,255,255)),self.font.font.render(f'min: {self.min} Fps',0,(255,255,255)),self.font.font.render(f'var: {round(self.dt,3)} ms',0,(255,255,255))]
        self.font.outline(surface,msg[1],(5,5))
        self.font.outline(surface,msg[0],(5,msg[0].get_height() + 7))
        self.font.outline(surface,msg[2],(msg[0].get_width() * 2.5,5))
        self.font.outline(surface,msg[3],(msg[0].get_width() * 2.5,msg[2].get_height() * 1.5))
        self.font.outline(surface,msg[4],(5,msg[1].get_height() * 2.5))
        surface.blit(msg[1],(5,5))
        surface.blit(msg[0],(5,msg[0].get_height() + 7))
        surface.blit(msg[2],(msg[0].get_width() * 2.5,5))
        surface.blit(msg[3],(msg[0].get_width() * 2.5,msg[2].get_height() * 1.5))
        surface.blit(msg[4],(5,msg[1].get_height() * 2.5))

@staticmethod
def position_platform_on_sheet(type_of_block) -> tuple:
    match type_of_block:
        case TypeOfBlock.TOP:
            return 1, 1
        case TypeOfBlock.BOTTOM:
            return 7, 1
        case TypeOfBlock.LEFT:
            return 8, 1
        case TypeOfBlock.RIGHT:
            return 5, 1
        case TypeOfBlock.CORNER_LEFT_TOP:
            return 0, 1
        # ...

class ImAnEntity(Entity):
    game: Game

    def __init__(self, game, ...):
        self.game = game
        # ...

# ...
for sprite in self.sprites:
  if isinstance(sprite, Block):
      sprite.update(maps=self.maps, display=display)
  
  if isinstance(sprite, Floor):
      if all([self.maps.camera.rect.left + 16 >= -sprite.rect.left,
              (TILE_WIDTH - self.maps.camera.rect.left + 390) >= sprite.rect.left]):
          display.blit(sprite.image, self.maps.camera.apply(sprite))
  
  if isinstance(sprite, LootBlock):
      if len(sprite.mushrooms) != 0:
          for mush in sprite.mushrooms:
              if all([self.maps.camera.rect.left + 16 >= -mush.rect.left,
                      (TILE_WIDTH - self.maps.camera.rect.left + 390) >= mush.rect.left]):
                  display.blit(mush.image, self.maps.camera.apply(mush))
      if all([self.maps.camera.rect.left + 16 >= -sprite.rect.left,
              (TILE_WIDTH - self.maps.camera.rect.left + 390) >= sprite.rect.left]):
          display.blit(sprite.image, self.maps.camera.apply(sprite))
  
  if isinstance(sprite, Vegetable) or isinstance(sprite, Coin) or isinstance(sprite, Cloud):
      if all([self.maps.camera.rect.left + 16 >= -sprite.rect.left,
              (TILE_WIDTH - self.maps.camera.rect.left + 390) >= sprite.rect.left]):
          display.blit(sprite.image, self.maps.camera.apply(sprite))
  
  if isinstance(sprite, Goomba) or isinstance(sprite, Koopa) or isinstance(sprite, Coin):
      if sprite.step == 1:
          self.sprites.remove(sprite)
      if all([self.maps.camera.rect.left + 16 >= -sprite.rect.left,
              (TILE_WIDTH - self.maps.camera.rect.left + 390) >= sprite.rect.left]):
          display.blit(sprite.image, self.maps.camera.apply(sprite))
# ...

class MapsGenerator(list):
    def __init__(self, iterable: List[Map]) -> None:
        super().__init__(item for item in iterable)

    def __setitem__(self, index: int, item: Map) -> None:
        super().__setitem__(index, item)

    def insert(self, index: int, item: Map) -> None:
        super().insert(index, str(item))

    def append(self, item: Map) -> None:
        super().append(item)

    def extend(self, other) -> None:
        if isinstance(other, type(self)):
            super().extend(other)
        else:
            super().extend(item for item in other)

class Game(object):
    """ 
        Environment where everything will works together. 
        This class have only one instance (Singleton Patern)
    """
    __instance = None    # Private variable

    def __new__(cls, *args, **kwargs):
        """ 
            Return only one instance of this class.
            @return Game instance into __instance variable
        """
        if cls.__instance is None:
            cls.__instance = super(Game, cls).__new__(cls, *args, **kwargs)
        return cls.__instance
   
    @staticmethod
    def get_instance():
        """ 
            Return only one instance of this class.
            @return Game instance into __instance variable
        """
        if Game.__instance is None:
            Game.__instance = Game()
        return Game.__instance

class Scene0(object):
    """ Scene n°0
            Qu'es-ce qu'il se passe ?
                1. Debut = Fade in sur "intro-bg.png" pendant 1.5s
                2. Reste static pendant Stage1Msc
                3. Fade out sur "intro-bg.png" pendant 1.5s
                4. Fin = Passe à la Scene n°1
    """

    def __init__(self):
        self.step = [True, False]
        self.finish = False
        self.background = pg.image.load("res/sheets/intro-bg.png")
        self.alpha = 0
        self.t = 0

    def getFinish(self) -> bool:
        return self.finish

    def start(self, surface: Surface, dt: float) -> None:
        """ Demarre l'animation.
            (Fade in par default)
                :param dt: DeltaTime """
        surface.fill((0, 0, 0))

        # Timer
        if int(self.t) == 100:
            # Disable fade in and enable fade out
            self.step = [False, True]
        elif int(self.t) == 200:
            # Pass to scene n°1
            self.finish = True

        self.background.set_alpha(self.alpha)
        self.alpha += (5 * dt) if self.step[0] else 0
        self.alpha -= (5 * dt) if self.step[1] else 0
        surface.blit(self.background, (0, 0))
        self.t += (1*dt)