topdownengine.mobile_object Reference¶

def __init__(
    self, 
    controller: Any,
    animation_paths: dict[str,str]|None=None, 
    frame_size: tuple[int]|None=None, 
    directional_anims: bool=False
) -> None:
    """Initialize the MobileObject.

    Args:
        controller (BaseController): The controller the MobileObject should use.
        animation_paths (dict[str,str], optional): The animation paths to load animations from. Defaults to None.
        frame_size (tuple[int]|None, optional): The frame size to use to load/generate animations. Defaults to None.
        directional_anims (bool, optional): Whether or not to load and use directional animations. Defaults to False.
    """
    # Set animation paths dict and frame size before calling super().__init__()
    # This make it automatically load in the animations without
    # having to call it a second time.
    self.animation_paths = animation_paths
    if frame_size is not None:
        self.frame_size = frame_size
    self.directional_anims = directional_anims
    if self.directional_anims:
        self.current_dir = "d"

    super().__init__()
    self.controller = controller
    self.jump_vel = 0.75

def add_to(self, *groups: GameObjectGroup):
    """Adds this GameObject instance to these groups.

    Args:
        *groups (GameObjectGroup): The groups to add to.
    """
    for group in groups:
        group.add(self)

def generate_colliders(self) -> list[pg.Rect|pg.FRect]:
    "Default list of Rect objects for collisions."
    elev_pos = self.position - pg.Vector2(0, self.elevation)
    if self.SUBPIXEL:
        r = self.current_frame.get_frect(
            topleft=elev_pos * self.SCALE
        )
    else:
        elev_pos.x = int(elev_pos.x)
        elev_pos.y = int(elev_pos.y)
        r = self.current_frame.get_rect(
            topleft=elev_pos * self.SCALE
        )

    r.height -= r.height / 2 if self.SUBPIXEL else r.height // 2

    return [tde_math.scale_rect(r, 1/self.SCALE)]

def jump(self) -> None:
    """This method sets the MobileObject's z velocity to the jump velocity
    if the MobileObject is grounded (MobileObject.elevation == MobileObject.z).
    """
    if self.elevation == self.z:
        self.z_vel = self.jump_vel

def load_animations(self) -> None:
    "Load unscaled animations."
    self.animations = dict()

    if getattr(self, "animation_paths", None) is None:
        # When there is no animation path data, add red
        # square idle animation with changing colors.
        self.animations["idle"] = []
        for i in range(4):
            image = pg.Surface(getattr(self, "frame_size", (16, 16)))
            image.fill((255/(i+1), 0, 0))
            self.animations["idle"].append(image.convert_alpha())
    else:
        for k, v in self.animation_paths.items():
            if getattr(self, "directional_anims", False):
                dirs = ["d", "r", "u", "l"]
                all_anims = VisualUtils.load_animations(v, *self.frame_size)
                all_anims.append(VisualUtils.flip_animation(all_anims[1], True, False))
                for i, anim in enumerate(all_anims):
                    self.animations[f"{k}_{dirs[i]}"] = anim

            else:
                self.animations[k] = VisualUtils.load_animation(v, *self.frame_size)

def remove_from(self, *groups: GameObjectGroup):
    """Removes this GameObject instance from these groups.

    Args:
        *groups (GameObjectGroup): The groups to remove from.
    """
    for group in groups:
        group.remove(self)

def scale_animations(self) -> None:
    "Scale animations."
    for _, anim in self.animations.items():
        for i, frame in enumerate(anim):
            anim[i] = pg.transform.scale(
                frame,
                (frame.width * self.SCALE, frame.height * self.SCALE)
            )

@classmethod
def set_scale(cls, new_scale: int, game: Game|None) -> None:
    """This method sets the target scale of all GameObjects.

    Args:
        new_scale (int): The new target scale being set to.
        game (Game|None): The Game object being used. While you may pass in None, you MUST pass in a Game instance if you have already defined GameObjects.
    """
    if game is not None:
        new_scale = game.set_target_scale(new_scale)
    cls.SCALE = new_scale
    cls.load_and_scale_shadows()
    if game is None: 
        return
    for go in game.game_object_group.game_objects:
        go.load_animations()
        go.scale_animations()

def update(self, dt: float, game: Game) -> None:
    """This method updates the MobileObject instance.

    Args:
        dt (float): The deltatime.
        game (Game): The Game object.
    """
    self.controller.update(self, dt)
    super().update(dt, game)
    if self.velocity.length():
        self.current_animation = "walk"
        angle = self.velocity.as_polar()[1]
        if -67.5 <= angle <= 67.5: # Right
            self.current_dir = "r"

        elif (-180 <= angle <= -112.5) or (112.5 <= angle <= 180): # Left 
            self.current_dir = "l"

        elif 67.5 <= angle <= 112.5: # Down
            self.current_dir = "d"

        elif -112.5 <= angle <= -67.5: # Up
            self.current_dir = "u"
    else:
        self.current_animation = "idle"

def move(self, mobile_object: MobileObject, dt: float, dir: pg.Vector2) -> None:
    """Change a MobileObject's velocity using a given dir Vector.

    Args:
        mobile_object (MobileObject): The MobileObject to move.
        dt (float): The deltatime.
        dir (pg.Vector2): Vector to move by.
    """
    if dir.length() != 0: 
        dir.normalize_ip()
        dir *= self.speed

    dt_seconds = dt / 1000.0
    weight = 1.0 - math.exp(-self.snapping_speed * dt_seconds)
    mobile_object.velocity = tde_math.lerp(mobile_object.velocity, dir, weight)

def update(self, mobile_object: MobileObject, dt: float) -> None:
    """Update function for MobileObject controllers.

    Args:
        mobile_object (MobileObject): The MobileObject to update.
        dt (float): The deltatime.
    """
    pass

def __init__(self) -> None:
    "Initializes the input manager."
    self.input_mgr = KeyboardInputManager()
    self.speed = 2
    self.snapping_speed = 10.0

def move(self, mobile_object: MobileObject, dt: float, dir: pg.Vector2) -> None:
    """Change a MobileObject's velocity using a given dir Vector.

    Args:
        mobile_object (MobileObject): The MobileObject to move.
        dt (float): The deltatime.
        dir (pg.Vector2): Vector to move by.
    """
    if dir.length() != 0: 
        dir.normalize_ip()
        dir *= self.speed

    dt_seconds = dt / 1000.0
    weight = 1.0 - math.exp(-self.snapping_speed * dt_seconds)
    mobile_object.velocity = tde_math.lerp(mobile_object.velocity, dir, weight)

def update(self, mobile_object: MobileObject, dt: float) -> None:
    """Moves the MobileObject based on keyboard input.

    Args:
        mobile_object (MobileObject): The MobileObject to update.
        dt (float): The deltatime.
    """
    input = self.input_mgr.get_input()

    if "Jump" in input:
        mobile_object.jump()

    dir = pg.Vector2(
        int("Move Right" in input) - int("Move Left" in input),
        int("Move Down" in input) - int("Move Up" in input)
    )
    self.move(mobile_object, dt, dir)

def __init__(self, target_mobile_object: MobileObject) -> None:
    """Initialize the MovementAIController.

    Args:
        target_mobile_object (MobileObject): The MobileObject to move toward.
    """
    self.target_mobile_object = target_mobile_object
    self.speed = 1.5
    self.snapping_speed = 10.0

def move(self, mobile_object: MobileObject, dt: float, dir: pg.Vector2) -> None:
    """Change a MobileObject's velocity using a given dir Vector.

    Args:
        mobile_object (MobileObject): The MobileObject to move.
        dt (float): The deltatime.
        dir (pg.Vector2): Vector to move by.
    """
    if dir.length() != 0: 
        dir.normalize_ip()
        dir *= self.speed

    dt_seconds = dt / 1000.0
    weight = 1.0 - math.exp(-self.snapping_speed * dt_seconds)
    mobile_object.velocity = tde_math.lerp(mobile_object.velocity, dir, weight)

def update(self, mobile_object: MobileObject, dt: float) -> None:
    """Move the MobileObject towards the target.

    Args:
        mobile_object (MobileObject): The MobileObject to update.
        dt (float): The deltatime.
    """
    dir = self.target_mobile_object.position - mobile_object.position
    self.move(mobile_object, dt, dir)

def move(self, mobile_object: MobileObject, dt: float, dir: pg.Vector2) -> None:
    """Change a MobileObject's velocity using a given dir Vector.

    Args:
        mobile_object (MobileObject): The MobileObject to move.
        dt (float): The deltatime.
        dir (pg.Vector2): Vector to move by.
    """
    if dir.length() != 0: 
        dir.normalize_ip()
        dir *= self.speed

    dt_seconds = dt / 1000.0
    weight = 1.0 - math.exp(-self.snapping_speed * dt_seconds)
    mobile_object.velocity = tde_math.lerp(mobile_object.velocity, dir, weight)

def update(self, mobile_object: MobileObject, dt: float) -> None:
    """Sets the MobileObject's velocity to (0, 0).

    Args:
        mobile_object (MobileObject): The MobileObject to update.
        dt (float): The deltatime.
    """
    mobile_object.velocity = pg.Vector2()