Introduction to Panda3d

Well, hello good people. Let’s get into Parnda3d, the module to create 3d games or 3d visuals with Python.

Understanding Panda3D and the Panda Controller Script

What is Panda3D?

Panda3D is a powerful, open-source 3D game engine used for creating games, simulations, and other 3D applications. It is written in C++ but is primarily used with Python, making it easy to learn and use for developers of all levels.

How the `pandas.py` Script Works

This script creates a simple 3D world with a controllable panda. Here is a breakdown of the key components:

ShowBase: This is the main class for any Panda3D application. It sets up the main window, rendering pipeline, and other essential components.
Actor: The Actor class is used to load and control animated models. In this script, it loads the panda model and its walking animation.
Movement Control: The script uses the accept method to listen for keyboard events. When the arrow keys are pressed, the corresponding methods (move_forward, rotate_left, etc.) are called to update the panda’s position and orientation.
Camera Control: A task named camera_follow is added to the task manager. This task runs every frame and updates the camera’s position to follow the panda, creating a third-person view.

How to Run the Script

To run the script, you will need to have Python and Panda3D installed. You can then execute the script from your terminal:

python pandas.py

The Animation logic

Animation Start/Stop:
- Now, when you press the “up arrow” key, the code checks if the “walk” animation is already playing.
  If not, it starts the walk animation loop.
- When you release the “up arrow” key, the else block is triggered, which immediately stops the current
  animation, making the panda stand still.

from direct.showbase.ShowBase import ShowBase
from direct.actor.Actor import Actor
from panda3d.core import Vec3

class ActorControlExample(ShowBase):
    def __init__(self):
        super().__init__()
        # Load the environment model.
        self.scene = self.loader.loadModel("models/environment")
        # Reparent the model to render.
        self.scene.reparentTo(self.render)
        # Apply scale and position transforms on the model.
        self.scene.setScale(0.25, 0.25, 0.25)
        self.scene.setPos(-8, 42, 0)

        # Load the Actor with animations
        self.panda = Actor(
            "models/panda-model",  # Model file
            {"walk": "models/panda-walk4"}  # Animasi file
        )
        self.panda.reparentTo(self.render)
        self.panda.setScale(0.005)
        self.panda.setPos(0, 0, 0)

        # Initial Animation
        # self.panda.loop("walk")  # Start walking animation in a loop

        # To store the state of the keys
        self.keyMap = {"forward": False, "left": False, "right": False}

        # Key bindings for movement controls
        self.accept("arrow_up", self.set_key, ["forward", True])
        self.accept("arrow_up-up", self.set_key, ["forward", False])
        self.accept("arrow_left", self.set_key, ["left", True])
        self.accept("arrow_left-up", self.set_key, ["left", False])
        self.accept("arrow_right", self.set_key, ["right", True])
        self.accept("arrow_right-up", self.set_key, ["right", False])

        # Add a task to update the camera and panda movement
        self.taskMgr.add(self.update, "updateTask")

    def set_key(self, key, value):
        """Stores the state of the key."""
        self.keyMap[key] = value

    def update(self, task):
        """Updates the panda's position and rotation based on key states."""
        dt = globalClock.getDt()

        if self.keyMap["forward"]:
            self.panda.setY(self.panda, -1000 * dt)
            if self.panda.getCurrentAnim() != "walk":
                self.panda.loop("walk")
        else:
            if self.panda.getCurrentAnim() == "walk":
                self.panda.stop()

        if self.keyMap["left"]:
            self.panda.setH(self.panda.getH() + 300 * dt)

        if self.keyMap["right"]:
            self.panda.setH(self.panda.getH() - 300 * dt)

        # Camera follows the panda
        self.camera.setPos(self.panda.getPos() + Vec3(0, 20, 5))
        self.camera.lookAt(self.panda)

        return task.cont
# Run the application
app = ActorControlExample()
app.run()