Zelda OoT Actor List

The Bg_Bombwall actor represents a simple bombable wall used throughout the game world, such as in fields and caves. This wall starts intact and has triangle-based collision that can detect hits from player bombs. When struck by an explosion, it plays a crumble effect using randomized dust puffs and visual debris placements, then switches its model to a broken wall variant. A switch flag is set to ensure the destruction persists across reloads. The actor can optionally trigger a success chime if configured to do so via parameters. After breaking, its collision and damage detection are disabled, and it becomes static, leaving only the visual of the broken wall behind. This actor provides an efficient and reusable way to hide secrets or block paths, encouraging exploration and puzzle-solving using bombs.

The En_River_Sound actor serves as an invisible controller for environmental audio, background music, and sound effects across various regions in the game. Despite its name, it manages much more than just river sounds—it plays ambient effects like rushing water, lava bubbling, fairy fountain music, and even Saria’s Song in the Lost Woods or Goron City. Depending on its parameters, the actor can trigger background music changes, ambient nature sounds, or positional sound effects based on the player’s location. When linked to a path, it calculates the closest point to the player and adjusts river sound frequency depending on nearby surface properties like conveyor speed. It also includes logic for gradually increasing the volume of Ganon’s Tower BGM as the player ascends. The draw function, rather than rendering visuals, is used each frame to trigger the appropriate sound at the correct location and volume, making this actor a core part of the game’s immersive sound design.

En_Arow_Trap is an unused trap actor designed to periodically fire arrows at the player. When initialized, it sets a timer (attackTimer) to 80 frames and scales down to a small, nearly invisible object. During gameplay, if the player comes within a 400-unit radius, the timer begins to count down. Once the timer reaches zero, the trap spawns an En_Arrow actor—specifically a silent normal arrow—fired in the trap’s facing direction. After each shot, the timer resets to 80 frames. Despite being functional, this trap is never used in the final game, making it a hidden leftover with potential for creative use in ROM hacks or custom maps.

The Obj_Bean actor represents a magic bean plant spot that progresses through several life stages based on player interaction and game state. Initially, as a child, Link can plant a Magic Bean in the soft soil spot by interacting with it while holding one. Once planted, the bean grows visibly through an animated sequence and enters a dormant state. When revisited as an adult, if water has been sprinkled on the bean or the relevant switch flag is active, the plant will emerge, rapidly grow through a series of phases, and then become a flying platform that follows a preset path. The platform lifts the player through the air, often used to reach otherwise inaccessible areas.

Throughout its lifecycle, the bean plant transitions through complex visual and physical states—sprouting leaves, growing a stalk, flattening to create a platform, and rotating while in motion. Leaf and stalk animations are handled using sinusoidal transformations to simulate natural swaying and growth. Once activated, the platform loops its path indefinitely unless the player dismounts, at which point it resets to its starting position. The actor can also be trampled by Epona, triggering a destruction sequence with fragments and disabling its collision.

The Bg_Spot18_Basket actor represents a rotating pot minigame basket found in Goron City. It begins stationary with a lid and starts rotating once a switch is activated, triggering a short cutscene. As it spins in a circular path with increasing speed and wobble, the player can attempt to throw a bomb into the basket. If successful, the pot reacts by spinning rapidly and dispensing a reward, which varies depending on its final rotation angle. The basket then resets or enters a new state depending on the reward logic and game progression.

The Bg_Haka_Zou actor represents destructible and movable environmental objects in the Shadow Temple, including the giant bird statue, bombable skull walls, piles of rubble, and miscellaneous falling debris. Each variation is defined by the actor’s parameters and reacts to specific triggers such as bombs, switches, or collisions with the player.

When initialized, the actor determines its type (e.g., bird statue, skull wall, rubble) and sets up its collider and scale appropriately. If the object is already destroyed (based on the switch flag), it won't spawn. Otherwise, it sets up collision, loads the correct model from the required object set (either haka_objects or hakach_objects), and waits for interaction.

For example, the giant bird statue responds to a switch being activated—triggering a dramatic cutscene where it explodes in sections, shifts position with shaking effects, and then topples over using calculated step-to logic in both the Z and Y axes, enhanced by visual effects like dust clouds and explosion bursts. Similarly, the bombable wall and rubble fragments can be destroyed when hit, causing debris to fly, smoke to rise, and actors to spawn or despawn accordingly.

Some rubble actors (when assigned the STA_UNKNOWN type) serve as small falling pieces spawned dynamically. They rotate and bounce on the ground briefly before disappearing. These add realism to the destruction sequences, like when a wall collapses and throws fragments outward.

The actor leverages shared explosion and debris effect functions such as EffectSsHahen_SpawnBurst and func_800286CC, combined with random position offsets and timers, to create varied and dynamic visuals. Its update function handles both physical motion (like falling due to gravity) and state changes based on timers.

The Blue Fire actor (En_Ice_Hono) plays a key role in melting Red Ice and unlocking key areas. This versatile actor has multiple forms: the capturable flame in bottles, dropped flames that fall and spread, and smaller ambient flames that animate and fade out. Each type has its own behavior, collider setup, and light effect logic. When active, Blue Fire emits a glowing light, plays a unique sound, and animates a scrolling flame texture. Capturable flames offer interaction with Link's bottle system, while dropped and spread flames have collision-based logic for Red Ice melting.

The actor file z_en_bom.c defines the En_Bom actor — the standard bomb in The Legend of Zelda: Ocarina of Time that has been dropped or thrown and is actively lit (fuse burning). It is fully physical, has a countdown timer, can bounce off surfaces, interact with enemies and the environment, and explodes after a set time or on contact.

The Bg_Jya_Bombiwa actor represents a bombable wall in the Spirit Temple’s upper room. It's a destructible barrier that disappears when hit by a bomb, triggering an effect and updating a switch flag.

The Bg_Mizu_Bwall actor represents the bombable walls found within the Water Temple. These destructible walls are part of the temple’s puzzle mechanics and are visually distinct yet designed to blend with their surroundings, challenging players to spot and destroy them using bombs. Each wall instance uses dynamic collision and triangle-based hit detection (ColliderTris) to register when it's been hit by a damaging effect. Upon receiving a hit, it disables its collision, hides its display list (making it visually disappear), and plays debris and sound effects to simulate destruction. The actor uses switch flags to ensure destroyed walls stay gone permanently after being blown up. It supports multiple configurations depending on its param value, such as floor segments, vertical walls, and special areas like Ruto's room. Notably, several bugs in the setup result in incorrect collision meshes for some wall types, as indicated in the comments. The actor also includes special rendering logic with dynamic alpha blending, allowing parts of the wall to appear semi-transparent or fully visible depending on the current water level in the temple, enhancing immersion and signaling progress.

The Bg_Breakwall actor represents bombable walls and destructible floors in Ocarina of Time, including special cases like the lava cover in King Dodongo’s chamber. Depending on the wall type, it loads the appropriate display list and collision data from either the object_bwall or object_kingdodongo object files. The wall checks for damage using a quad collider and responds to explosion collisions by spawning fragment debris (En_A_Obj), playing destruction sound effects, triggering cutscenes (such as the Dodongo’s Cavern opening), and setting switches or event flags. Some variants, like the lava cover, move slowly to a designated position post-boss defeat, while others disappear instantly. The system ensures that the correct object is loaded before setting up rendering or collision. The actor supports multiple destruction geometries, scales visual effects accordingly, and uses actor parameters to determine wall type and switch flag logic.

The Bg_Hidan_Kowarerukabe actor represents the breakable bombable walls and cracked floors in the Fire Temple. This actor is initialized based on its type—either a cracked floor, standard bombable wall, or a larger version of the wall—and is defined with appropriate collision data and a spherical collider that detects explosive hits. When the player places a bomb near the object and it detonates within the collider’s range, the actor triggers a destruction sequence: particle fragments (called kakera) burst outward in randomized directions, creating a dramatic visual effect. Each type has its own unique debris spread pattern and sound effect. After breaking, a switch flag is set to ensure the wall or floor doesn’t reappear when the player re-enters the room. This actor uses dynamic collision to interact properly with the environment, and it self-terminates after being destroyed. Through this setup, the actor provides a reusable, modular mechanic for puzzle-solving and progression, relying entirely on in-game physics and effects to communicate its breakability.

The En_Bom_Chu actor is the Bombchu — a small, autonomous bomb used in Ocarina of Time. Unlike regular bombs, Bombchus travel along surfaces (walls, floors, ceilings) in the direction they are released, making them ideal for puzzles and reaching otherwise inaccessible targets.

Upon activation, the Bombchu orients itself based on the player's direction, calculates its movement vectors, and navigates dynamically by detecting surface normals and adjusting rotation accordingly using EnBomChu_UpdateFloorPoly. It travels forward while sticking to the surface, creating a realistic "crawling" effect across terrain geometry.

Visual effects include dual motion blur trails using EffectBlure_AddVertex, blinking red light based on a countdown timer, and ripple or bubble effects if underwater. If the timer expires, it contacts another actor, or it can no longer find a path forward, the Bombchu self-destructs by spawning a regular bomb (En_Bom actor) which immediately explodes. It also plays unique sliding and explosion sound effects.

The Bombchu's code demonstrates complex surface-following logic, model-space to world-space transformations for effects, and a blend of visual/audio feedback to bring this explosive gadget to life.

The En_Bombf actor represents Bomb Flowers in Ocarina of Time. These special plants grow explosive bombs that can be picked up by Link or detonated in place through various triggers, including attacks, proximity to burning sticks, or direct player interaction. Bomb Flowers go through a lifecycle: they grow to full size, wait to be picked or struck, spawn a live bomb (BOMBFLOWER_BODY), and eventually explode. When active, the bombs behave like standard thrown explosives—bouncing, sparking, and flashing as the timer counts down. If submerged in deep water, the bomb is extinguished and removed. The explosion triggers a blast effect, shockwave, sound, and temporary lighting changes, and damages nearby actors. Bomb Flowers can regrow over time, and the system includes logic to prevent multiple grabs or glitches with player carrying states. Their visuals are dynamically scaled and colored based on fuse status, and they include a segmented, billboarded spark effect to simulate ignition. Note: To display a proper Bomb Flower in-engine, the Type parameter must be set to Default. In Fast64, this is incorrectly set to "Bomb" by default, which instead spawns a detached, live bomb actor—BOMBFLOWER_BODY.

The Bg_Sst_Floor actor represents the bouncy drum floor used during the Bongo Bongo boss fight. It’s a dynamic actor that detects when the player or items land on it, and responds by compressing and bouncing them upward. This actor uses vertex manipulation and camera logic to simulate the effect of a flexible, percussive surface. When the player falls onto the drum from a significant height, the drum "plays a beat" by oscillating up and down and launching the player (and nearby collectibles) back into the air. This bounce height depends on the distance from the center of the drum—closer to the rim results in a higher launch. The drum's movement is visually animated by updating multiple vertices in the collision mesh in real time, creating a squash and stretch effect. The camera perspective also shifts dynamically depending on whether the player is on the drum, enhancing the boss fight's cinematic quality.

The En_Kakasi3 actor represents Bonooru the Scarecrow, a friendly and musical NPC in The Legend of Zelda: Ocarina of Time. Found at Lake Hylia during both the child and adult timelines, Bonooru plays a key role in the Scarecrow Song side quest. As a child, Link can approach Bonooru to teach him a custom 8-note melody, which is saved in the game as the Scarecrow’s Song. Later, as an adult, this same scarecrow can recall and recognize the song, enabling Link to use it to summon Pierre (another scarecrow) in specific areas for hookshot access to otherwise unreachable locations.

Bonooru’s implementation features rich interaction systems. He uses a friendly dialog flow based on Link’s age and quest progress, offers a custom ocarina interface, and even uses a cinematic camera cutscene system for teaching and recalling the song. His behavior includes quirky animations such as spinning, hopping, or swaying in response to player input during the ocarina sequence. Internally, the actor uses skeletal animations and has a cylindrical collider flagged as hookshot-compatible.

Bonooru's logic also manages multiple game states: recording a new song, verifying the player's previous song, or rejecting attempts if certain conditions aren’t met. Debug messages suggest heavy developer testing of these sequences. Bonooru’s joyful energy and his role in enabling creative traversal give him a memorable and functional place in the game’s world, rewarding players who engage with him by unlocking unique shortcuts and secret locations.

The Bg_Haka_Water actor is responsible for dynamically changing the water level in Bottom of the Well. Controlled by a switch flag, it raises or lowers the water level in real time, affecting the entire area’s water box configuration. Upon initialization, it checks whether the switch is active to determine if the water should start in a raised or lowered state. When the player toggles the corresponding switch, the actor triggers a gradual transition to the new water height, updating all water boxes in the area accordingly. Visually, the actor renders a translucent water ring and animated waterfall effect while the water level is changing, and these are hidden when the water is fully lowered. It also plays appropriate sound effects during movement. This actor allows for puzzle mechanics involving altering water heights to access new areas or items.

The Obj_Tsubo actor represents breakable pots found throughout dungeons and overworld areas. When placed in a scene, this actor spawns as a static pot that the player can interact with—either by attacking it, throwing it, or lifting it. If struck or thrown against a surface, the pot shatters into fragments using the EffectSsKakera visual effect and may drop a collectible item like a rupee, heart, or magic jar depending on parameters encoded in its params. The pot can also break in water, generating a splash effect. It uses a cylinder collider for detecting interactions and relies on nearby proximity to the player before activating collision to save performance. The actor's state machine transitions between waiting for required object data (for different pot models), idle, lifted, and thrown states. Upon being picked up, it sets itself to follow the player and later transitions to a thrown state with randomized spin applied to its rotation. If the thrown pot hits the ground or a wall, it breaks and disappears, completing its lifecycle.

The Bg_Spot00_Break actor represents destructible scenery in Hyrule Field, specifically the broken drawbridge near the castle and, in some cases, a fence. This actor only appears when Link is an adult; if he's still a child, the actor deletes itself immediately upon initialization. Depending on the value of the actor's parameters, it either loads collision and a model for the ruined drawbridge or the fence barrier. While the actor has no update behavior—it’s static once placed—it contributes to the game's storytelling by visually showing the aftermath of Hyrule’s fall during the seven-year timeskip. The draw function selects and renders the appropriate display list based on its type, helping to reflect the changed and more dangerous state of the world in the adult timeline.

The Obj_Bombiwa actor is a round, brown boulder that can be destroyed by explosions or heavy impact, such as from the Megaton Hammer. It serves as a destructible environmental obstacle and typically hides a passage, treasure, or pathway when broken. While idle, the boulder passively waits for specific damage input. When it is hit by a bomb, bombchu, or hammer, it shatters into multiple fragments with particle effects and sound, and may also trigger a chime if a specific bit in its params is set.

The boulder’s behavior is straightforward: it uses a cylinder collider to detect damage and triggers its destruction sequence upon valid impact. It cannot be moved or interacted with in any other way. The params field determines which switch flag will be set upon destruction and whether a success sound (correct chime) will play. Its transformation is randomized slightly at runtime to vary its appearance. Once destroyed, it removes itself from the scene and never returns unless the switch flag is cleared or the area is reloaded without persistent flags.

The En_Kusa actor represents a bush that can be cut with a sword or picked up and thrown by the player. It comes in three types that define how it behaves when interacted with: Type 0 bushes are destroyed upon being cut and do not return; Type 1 bushes can be picked up and thrown, and after landing they will regrow over time; Type 2 bushes can only be cut but will also regrow after a short delay. When destroyed—either by cutting or impact—they break into fragments using particle effects and may drop a random collectible, such as rupees, hearts, or seeds. Some variants can also spawn insects when slashed, depending on their params settings. The bush transitions between various states, including idle, picked up, falling, broken, and regrowing, using internal timers and state functions. When regrowing, the bush smoothly scales back to full size and reactivates its collider for reuse. The actor also handles its physics and collisions during the fall state and makes splashes if it lands in water. Additionally, it has custom draw logic that changes the model based on its destroyed state.

The Door_Gerudo actor is a metal sliding grate door used primarily in the Gerudo Fortress area. It functions as a locked cell door that can be opened by using a small key, typically acquired by freeing carpenters or completing certain objectives. When approached with the correct conditions met, the door animates by sliding upward, accompanied by appropriate sound effects. If the player lacks the required key or collectible, Navi will provide a corresponding message, and the door will remain shut.

The Bg_Gnd_Darkmeiro actor handles multiple environmental elements used in the Shadow Trial of Ganon's Castle, including invisible paths, clear blocks, and block timers. Invisible paths are only visible through the Lens of Truth and serve as hidden walkways over pits. Clear blocks can either remain static or appear temporarily when a nearby switch is activated—these dynamic ones fade out based on a countdown timer, with their collision toggled on or off accordingly. There's also a timer-based controller actor that monitors multiple switches and ensures blocks are only active for a limited duration. Through clever use of draw functions and switch flags, this actor group creates the trial’s signature illusion and timing-based platforming challenges.

The Bg_Jya_Kanaami actor is a dynamic, climbable wire mesh platform that plays a key role in certain puzzle sequences—particularly in the Spirit Temple. It begins in a vertical orientation, acting as a wall the player can climb. When a specific switch is activated, the actor transitions into a new animation state, rotating forward 90 degrees to become a horizontal bridge. This transformation is accompanied by a short cutscene and sound effects to emphasize the movement. The transition is not instant: the actor gradually tilts forward over several frames, simulating weight and realism. Once the transformation completes, the actor becomes static again, permanently staying in its bridge orientation for the rest of the scene.

The Bg_Spot16_Doughnut actor renders the iconic donut-shaped cloud circling Death Mountain in Ocarina of Time. It appears in various scenes such as Kakariko Village and the Temple of Time exterior, with its size adjusting depending on the viewpoint. The cloud can either remain static or enter a special "expanding" state, gradually growing in size and fading out to simulate atmospheric changes. When the fire temple event hasn't been completed, the cloud displays a fiery texture to reflect the mountain’s volcanic unrest. Once the player progresses the story, the fiery effect fades away, leaving a calm white ring of mist. This subtle visual actor adds both ambiance and environmental storytelling, helping signal major plot changes in a visually memorable way.

The Item_Etcetera actor in Ocarina of Time is a highly adaptable collectible item handler used to spawn various static items in the game world. Upon initialization, it reads an 8-bit value from its params to determine what type of item it represents—ranging from bottles and shields to cutscene items like Ruto’s Letter or the Fire Arrow. It first loads the appropriate object file (e.g., gi_bottle, gi_arrow_fire) into memory using the dynamic object system and waits until it is fully loaded before activating. Once ready, the actor either displays the item normally or conditionally—such as only through the Lens of Truth for chest game items. Some items automatically disappear if corresponding event or treasure flags are already set, while others offer the item to the player if approached. Special effects like floating, sparkle particles, or falling with gravity are also handled based on the item type. Drawing is done using the GetItem_Draw() system, which shows a 3D model of the item from a defined list of draw IDs. This makes Item_Etcetera a versatile and reusable system for rendering world items that aren’t tied to treasure chests or immediate pickups.

En_Item00 actor defines the behavior of collectible items in Ocarina of Time, such as rupees, hearts, arrows, bombs, seeds, magic jars, keys, and special pickups like heart containers or shields. When these items are spawned—either from enemies, environmental triggers, or item drop tables—they are initialized with properties like scale, rotation, shadow, collision, and movement behavior. The file handles item interactions with the player, including automatic pickups or triggering a “Get Item” animation for major items. Items react to physics like gravity and ground collisions, often bouncing or sparkling while idle. Drawing functions render the appropriate item models and textures, while helper functions manage conditional replacements, spawning, and quantity control from predefined enemy drop tables. Overall, the file is a comprehensive system for spawning, animating, and collecting in-game item drops based on player state and context.

The core logic also includes a dynamic drop system, particularly for the ITEM00_FLEXIBLE type, which adjusts what item is spawned based on Link’s current needs. The flexible drop system determines item spawns based on Link’s current status. If Link has 1 or fewer hearts, a Healing Fairy is spawned. If he has 2 to 3 hearts, the game spawns 3 Recovery Hearts, or 3 Green Rupees if he’s at full health. For 4 to 5 hearts, it drops 1 Recovery Heart, or 1 Green Rupee if Link is already at full health. If Link has no magic, a large Magic Jar is dropped—unless magic hasn’t been unlocked yet, in which case nothing is spawned. If Link is a child with 5 or fewer Deku Seeds, he receives 5 more, but only if he owns a Slingshot. If he’s an adult with 5 or fewer Arrows, he gets 10 Arrows—assuming he has a Bow. Similarly, if he has 5 or fewer Bombs, he gets 5 Bombs, but only if he has a Bomb Bag. If none of these apply but Link has 10 or fewer Rupees, a Red Rupee is dropped. If none of the above conditions are met, no item is spawned.

The En_Cow actor represents the cows found throughout The Legend of Zelda: Ocarina of Time, functioning both as ambient characters and interactive NPCs. These cows are uniquely responsive to the player playing Epona's Song nearby. If Link plays the song and is close enough, the cow will offer a bottle of Lon Lon Milk—assuming the player has an empty bottle. The cow actor handles dialog interactions, item giving, animation control, and attention targeting.

Each cow is composed of two actor instances: a main body and a tail. The body actor manages interactions, sound effects, head tracking, and animations like chewing or breathing. The tail actor is spawned as a child and plays idle and swishing animations independently. Both parts use skeletal animation (SkelAnime) and are drawn with flexible limb transformations. For example, the cow’s head rotates to follow the player if they’re nearby.

The cow has a dual collision system using two cylinders—front and rear—to simulate its body. When Epona’s Song is played, all cows attempt to give milk, but only one will succeed based on distance and orientation to Link. This is managed through shared global flags (R_EPONAS_SONG_PLAYED and internal cowFlags), ensuring only one milk is given per song play.

Cows are also context-sensitive: some only appear if certain conditions are met, such as being an adult or having unlocked a specific event. For instance, the cow in Link’s house only appears if the player has completed the Epona-related mini-game.

Overall, the En_Cow actor is a well-crafted, immersive NPC system with subtle personality and useful functionality, showcasing thoughtful interaction design in the game world.

The En_Niw actor is the Cucco (chicken) in Ocarina of Time. It controls everything from idle movement and flight mechanics to the infamous swarm attack when Link repeatedly hits a Cucco. This actor can either be passive, following a patrol or idle behavior, or enter an aggressive mode that spawns flying attack Cuccos after taking enough damage. The file also manages feather particle effects for realism during flapping or fleeing. It includes distinct logic for special Cuccos in areas like Zora’s River or mini-games, checking event flags to determine whether the actor should be spawned. The behavior changes based on parameters and player interactions, like being picked up, thrown, or attacked. Animations are handled via skeleton-based animation logic (SkelAnime), and collision is managed using cylinder colliders. Cuccos also respond to the environment—floating when in water, reacting to walls, and resetting if they fall out of bounds. Overall, the file defines the Cucco as a complex, reactive NPC with multiple states and a notorious defense mechanism that players love (or fear).

The En_Attack_Niw actor represents one of the attacking Cuccos that swarm the player after repeated abuse of a regular Cucco. These flying, non-solid actors home in on the player using randomized vectors relative to the camera. They are spawned and controlled by the parent Cucco (En_Niw) and can knock back the player upon contact. Each attacker has its own animation, randomized rotation, and sound effects like crowing and flapping. Once off-screen or after some time, they despawn. Their behavior is primarily aesthetic and meant to overwhelm rather than cause significant damage.

The En_Ssh actor represents the cursed members of the Fabulously Rich Family in Kakariko Village—also known as the Cursed Skulltula people. These NPCs were transformed into spider-like creatures due to their greed and are found inside the House of Skulltula. As the player collects Gold Skulltula Tokens throughout the game, each token helps break the curse on one family member. The actor tracks how many tokens the player has collected and updates its state accordingly. When a family member is freed, they return to human form, thank the player, and offer a unique reward. Their animations and dialog vary based on how many members have been saved and whether they have already given their reward.

The DemoKankyo actor in Ocarina of Time is a powerful background visual and cutscene effect controller used in some of the game's most iconic moments, such as warp song sequences, the Door of Time opening, magical sparkles, falling rocks, rain, and moving clouds. Depending on its params, it loads specific visual effects like blue rain in the Temple of Time, warp sparkles tied to different songs, or large floating rocks in cutscenes. These effects are often synchronized with cutscene camera paths, sound effects, and player animations using internal timers and logic. The actor dynamically changes its behavior based on the scene and Link's age (child/adult), playing different animations or triggering different events (e.g., opening the Door of Time or starting a warp cutscene). It uses helper functions for vector math, randomized movement patterns, alpha blending, scaling, and sound triggers to create immersive transitions and mystical moments. DemoKankyo is essential for creating cinematic atmosphere and enhancing emotional beats in the game’s storytelling.

The En_Po_Relay actor (z_en_po_relay.c) is Dampé's ghost from Ocarina of Time, central to the iconic graveyard racing minigame in the adult timeline. This NPC starts idle and interacts with the player through dialog, initiating a race through the graveyard's winding crypt passages. During the race, Dampé floats along a set of predefined waypoints (D_80AD8C30) while dynamically adjusting his speed and occasionally spawning flame traps (En_Honotrap) to hinder the player. His AI considers the player’s distance, alternative paths, and whether the player possesses the Hookshot to maintain a competitive challenge.

The actor has multiple phases: idle, initiating the race, navigating through the course, concluding the race, engaging in post-race dialogue, and finally disappearing in a particle effect while dropping a reward (a Piece of Heart or rupees depending on the result). The system also updates the high score if the player finishes under a set time. The rendering includes animated eye textures, a glowing lantern light with dynamic color flickering, and a halo, enhancing the ghostly aesthetic.

This actor skillfully combines AI path-following, dynamic difficulty scaling, environmental interaction, and visual feedback to deliver one of the game’s most memorable and atmospheric side quests.

The z_item_shield.c file defines the behavior of the Deku Shield as a dropped or burning item. This actor appears in two primary contexts: Dropped Item (params = 0) – When the Deku Shield is found as a pickup in the world. Burning Shield (params = 1) – When Link’s equipped Deku Shield catches fire and is destroyed. In the dropped state, the shield remains idle until it is collected or damaged by an attack, at which point it gains physics and can bounce. After a countdown, it disappears if not collected. In the burning state, the shield detaches from Link's hand and creates a fiery effect trail using the EffectSsFireTail_SpawnFlame function, simulating it burning up mid-air. Both states utilize custom rotation logic, collision detection, and graphical effects. The rendering function conditionally draws the shield depending on internal flags, allowing it to vanish visually while still being active logically (e.g., when it's burning). This file elegantly blends item collection, physics, and visual effects into a seamless game mechanic.

The Bg_Ydan_Hasi actor handles several puzzle elements within the Deku Tree dungeon. It includes three distinct object types: the animated water plane on B1, the floating platform that rides above it, and the set of three blocks that rise and fall on 2F when triggered by a switch. The floating block gently oscillates in position and height, synchronized with sine wave functions for smooth movement. The water plane itself moves up and down depending on switch activation, altering the water level in the room and affecting platform behavior. The three rising blocks activate during a cutscene and elevate to a set height before returning after a timer ends. These coordinated elements contribute to a multi-step environmental puzzle, enhancing the dungeon’s interactivity and depth.

The Deku Tree Sprout (Obj_Dekujr) actor represents the small tree that emerges in Kokiri Forest after completing the Forest Temple. This friendly NPC only appears when Link is an adult and has obtained the Forest Medallion, serving as a narrative milestone that acknowledges Link's progress and reveals important story details about his origins. During a specific cutscene, the sprout rises from the ground using scripted motion defined by the cutscene data, with its position and rotation animated frame by frame. If the game is not currently running a relevant cutscene, or if the player is still a child or hasn't cleared the temple, the actor automatically despawns. It uses a cylindrical collider for interaction, allowing the player to speak with it outside of cutscenes. Visually, the sprout combines solid and semi-transparent display lists to create a glowing, magical effect, further enhancing its significance as a symbol of renewal in the forest.

The Bg_Spot17_Bakudankabe actor represents a bombable wall located in the Death Mountain Crater area of Ocarina of Time. When initialized, it checks a switch flag to determine whether the wall has already been destroyed and, if so, removes itself from the game world. Otherwise, it registers dynamic collision using a pre-defined collision header. During gameplay, if the player approaches and uses a triggering method like a bomb, the actor detects the hit and activates a destruction sequence. This sequence includes spawning debris shards using EffectSsKakera, playing an explosion and chime sound effect, and displaying layered draw calls to show cracks and wall fragments. After the destruction, it sets the corresponding switch flag to ensure the change is saved and despawns the actor. This destructible wall adds an element of exploration and progression within the fiery environment of the crater.

The Bg_Spot11_Bakudankabe actor represents a destructible wall in the Desert Colossus area of Ocarina of Time. This actor is designed to respond to bomb damage and simulates a crumbling wall effect when destroyed. Upon initialization, it sets up collision using a cylindrical collider and loads the appropriate collision data and display list for the wall. If the corresponding switch flag has already been triggered—indicating the wall was destroyed in a previous visit—the actor deletes itself. During gameplay, if the wall is hit (typically by a bomb), it triggers a sequence of visual effects by spawning debris (EffectSsKakera) and dust clouds to simulate an explosion. It also plays sound effects for the wall breaking and the item chime, sets a switch flag so the destruction is remembered in future visits, and removes itself from the game world. This kind of destructible environment adds both interactivity and a sense of progression to the game’s world.

The Bg_Spot08_Bakudankabe actor represents a destructible wall found in Zora’s Fountain in Ocarina of Time. This wall can be blown up with bombs, revealing a hidden passage. Upon initialization, the actor checks if the wall has already been destroyed in a previous session by checking a switch flag—if so, it removes itself from the game world. Otherwise, it sets up its joint-sphere collider and registers dynamic collision for interaction. If the player hits it with a bomb or another triggering method, it spawns debris effects using EffectSsKakera to simulate the wall shattering and generates dust clouds to enhance the impact. It also plays the appropriate breaking and chime sound effects before setting the switch flag and despawning itself. This destructible object adds a secret-revealing mechanic and a sense of discovery to the environment.

The Bg_Spot16_Bombstone actor represents the destructible bomb boulder seen in Death Mountain Crater. When first loaded, the actor checks whether it should appear as an intact boulder or as one of the flying debris fragments resulting from its destruction. The intact boulder sets up spherical and cylindrical colliders to detect player interaction and damage from explosives. When hit by a bomb, it triggers a dramatic breaking sequence: a brief camera cutscene plays, dust effects are spawned, and several smaller debris actors are launched outward with randomized spin and velocity. These debris pieces are separate actors that fall with gravity and disappear after hitting the ground or walls, sometimes creating more particles on impact. The boulder also sets a switch flag once destroyed, ensuring it doesn't reappear on reload. This actor handles the entire lifecycle of the destructible rock—from solid form to scattered fragments—using custom rotation, collision detection, and environmental feedback to make the event feel dynamic and responsive within the game world.

The En_Door actor handles all standard doors with handles, including both single and double doors across various dungeons and overworld locations. It supports multiple visual styles depending on the scene (such as Fire Temple or Shadow Temple doors) and switches between them by dynamically loading associated objects and display lists. Upon initialization, the actor checks the current scene and sets its door type (standard, locked, ajar, checkable, or timed) based on parameters and game state. It processes player interaction by checking proximity, orientation, and item availability (like small keys for locked doors). When the player approaches and interacts, the door plays a context-sensitive animation, sound effect, and in some cases, visual effects like magic bubbles. For double doors, it automatically spawns a mirrored child door and synchronizes their behavior. The actor also accommodates special cases like Talon’s door at Lon Lon Ranch or doors that behave differently at certain times of day. Animations, lock visuals, and draw behavior are managed with a flexible skeletal system, and the drawing function intelligently determines which side of the door to render based on camera angle and room configuration. This makes En_Door one of the most versatile and essential world-interaction actors in the game.

The Bg_Spot00_Hanebasi actor represents the iconic drawbridge and torches at the entrance of Hyrule Castle in Ocarina of Time. It consists of a central bridge platform and two chain objects, which are spawned as child actors. The bridge's behavior dynamically changes based on time of day, story progression, and Link's age. During the day, the drawbridge lowers for child Link to enter the castle, and at night it raises unless specific quest items are collected, in which case a cutscene may be triggered. The raising and lowering of the bridge is smoothly animated, with accompanying sound effects and synchronized chain rotation. The chains include dynamic torch lights with randomized flame flickering and texture scrolling to simulate animated fire. The flames scale based on bridge position and camera context, providing visual feedback on the bridge’s state. If all three Spiritual Stones are collected, a cutscene transition is triggered upon approaching the bridge as child Link. Additionally, the actor manages light context insertion and removal for the torches, as well as subtle camera interactions to enhance immersion during bridge movement or fire effects.

The Bg_Mori_Elevator actor in Ocarina of Time controls the iconic elevator platform in the Forest Temple. This dynamic platform connects two main areas of the dungeon—Room 2 and Room 17—via vertical movement based on the player's interaction and switch flags. When first initialized, the elevator checks if it has already been spawned to prevent duplication. If not, it sets up collision, draws the platform, and waits for the required texture bank to load. Once ready, it either remains idle, waits for the player to step on it, or moves based on room conditions and switch states.

The elevator's movement is smooth and physics-based, gradually accelerating and decelerating using custom interpolation logic (func_808A1800) to simulate realistic motion. Sound effects accompany the motion to reinforce feedback. Depending on which room the player is in and whether the player steps onto the elevator, the platform either rises to the upper floor, lowers to the basement, or aligns itself to a central resting point at 73.0f. The logic ensures a seamless and immersive experience, enhancing the dungeon’s spatial design and puzzle-solving flow.

The ObjectKankyo actor in The Legend of Zelda: Ocarina of Time is responsible for rendering and managing environmental effects that enhance the atmosphere and storytelling across various parts of the game. Depending on the actor.params value, it can control a range of visual phenomena, such as floating fairies in Kokiri Forest, falling snow in cold regions, flickering lightning bolts during dramatic cutscenes, radiant sparkles triggered by sunlight hitting a gravestone, or the six colored energy beams that seal Ganon’s Castle. Each effect is handled through a shared system of state-based "effect slots" that store properties like position, scale, alpha, movement patterns, and animation frames. For example, the fairy effect dynamically spawns fluttering motes that trail the player when idle, using sinusoidal motion and screen wrapping for a magical feel. The snow effect generates randomized flakes in front of the camera that drift downward and wrap around when out of view, maintaining consistent visual density. Lightning effects are cutscene-driven and display animated textures with scaling and sound synced to the scene. The sunbeam sparkle and castle barrier beams are also linked to cutscene cues and game progress flags, respectively, with logic to load external object files as needed. Internally, the system leverages transformation matrices for precise positioning and orientation, as well as custom color blending for a vivid, layered look. By modularizing these effects and tying them to scene logic and player movement, ObjectKankyo plays a subtle but vital role in shaping the game’s mood and pacing, adding richness to the world of Hyrule without overburdening the core engine.

The Bg_Menkuri_Eye actor represents the rotating red "eye switches" found in the Gerudo Training Grounds. These switches activate when shot from a specific direction (not head-on), and only after all four have been triggered does the switch flag set, unlocking the corresponding mechanism (like opening a door or stopping a trap).

Upon initialization, each eye sets up a spherical collision area. If the eye detects a hit from a valid angle, it temporarily activates, playing a sound and increasing the global counter sNumEyesShot. If this counter reaches four, it triggers the switch flag and plays a success chime. Visually, the eye glows red when active, fades when idle, and uses transparency to indicate its state.

This actor plays a key role in timing-based or accuracy challenges in puzzle rooms, adding interactivity and requiring players to approach from strategic angles.

The En_Fire_Rock actor is responsible for simulating the falling fire rocks and rock hazards seen during events like the eruptions on Death Mountain and the collapse of Ganon's Tower. Depending on its parameters, this actor can take several forms: it may appear as a static hazard on the ground, a ceiling spawner that drops rocks when the player approaches, or a large flaming rock that falls from above. Upon impact, these rocks often shatter into smaller fragments that scatter and disappear shortly after.

When initialized, the actor uses the params value to determine its behavior. For example, FIRE_ROCK_CEILING_SPOT_SPAWNER is an invisible entity that waits for the player to get close before dropping a rock. It doesn't render any graphics itself but triggers a dramatic moment by spawning a falling hazard. On the other hand, FIRE_ROCK_ON_FLOOR is a stationary object that emits flames and can damage the player upon contact. The most common variant, however, is the falling rock — either type 1 or 2 — which drops from the sky, rotates as it falls, and leaves behind a trail of fire. Type 1 can slightly track the player's position, while type 2 falls straight down with random variation.

When a fire rock hits the ground, it triggers visual and sound effects such as screen rumble, explosion sounds, and dust rings. Larger rocks often break into smaller fragments (piece 1 and piece 2 types), which scatter with upward momentum and gradually fade out. These pieces serve no further gameplay function but enhance the realism of the impact. The actor also checks for collisions — either with the ground or with the player’s shield — and may shatter early if deflected. In combat zones, the rocks can actively damage Link if they collide.

Visually, each rock uses a spinning model with randomized rotation and scaling. Flame particle effects are continuously spawned from its center as it falls. The entire actor is carefully tuned to contribute both gameplay tension and visual drama, reinforcing the sense of danger in volcanic and crumbling environments.

The Bg_Mori_Rakkatenjo actor controls the falling ceiling trap in the Forest Temple. It begins suspended above the ground and becomes active once the Forest Temple textures are loaded. Initially, the actor waits for Link to approach. Once Link enters a defined proximity area (a rectangular region under or near the trap), a countdown timer begins. If Link remains within the zone for long enough—or if he walks directly underneath—it triggers the ceiling to drop.

As the trap falls, it uses gravity and simulates a realistic bounce effect with decreasing rebound velocity. Each impact plays a heavy sound effect and initiates a camera shake (quake) to emphasize the ceiling's weight and danger. After hitting the ground and finishing its bounce sequence, the trap rests briefly, then slowly rises back to its original position using smooth upward motion.

During the sequence, the camera switches to a special birds-eye view when Link is underneath, providing a better perspective of the danger. Once Link exits the area, the camera returns to its default dungeon setting.

This system combines positional checks, camera transitions, physics simulation, and audio-visual feedback to create one of the temple’s most tense moments—a trap that feels both intimidating and cinematic.

The EnEncount2 actor is a dynamic environmental hazard system responsible for creating falling rocks and visual effects during intense sequences, such as Death Mountain eruptions or the collapse of Ganon’s Tower.

When placed in Death Mountain Trail, the system checks if Link is within a specific coordinate range and whether certain game flags are unset (like whether the Fire Temple has been cleared). If these conditions are met, the system activates and begins periodically spawning falling rocks (via the En_Fire_Rock actor) and lava spark-like visual effects. These rocks can fall near the player or further away based on their speed and random factors, and their spawns are synchronized with camera quake effects and sound cues like rumbling and volcanic eruptions.

In the Ganon’s Tower collapse scenes, the same system activates when Link is close enough and a switch flag is set. The system spawns similar effects but with different timing and a slightly altered visual presentation. Only one rock is spawned at a time in this sequence, and effects are more spaced out to match the escape sequence pacing.

The system includes a pool of visual particle effects that are managed through the EnEncount2_UpdateEffects function. These effects have randomized rotations and drift downward, getting culled once they fall below a threshold. Their movement gives the illusion of debris or sparks falling from above.

In addition, the actor manipulates the environment colors and fog during active sequences in Death Mountain to simulate a visual sense of danger. The ambient light, primary light, and fog settings shift dynamically based on an internal timer that gradually ramps up and down.

The modular design allows the same actor to behave differently in each scene depending on scene ID and parameters, demonstrating its flexible and context-sensitive behavior within the game’s environmental storytelling.

The Bg_Menkuri_Nisekabe actor represents the false stone walls and ceilings in the Gerudo Training Grounds. These deceptive barriers appear solid at first glance but are actually illusions, designed to test the player’s perception and puzzle-solving skills. By default, the actor draws either a fake wall or ceiling depending on its params value, using display lists from the Gerudo Training Grounds object set. However, the illusion only persists until the Lens of Truth is activated. When the player uses the lens, the game sets a special flag (ACTOR_FLAG_REACT_TO_LENS), causing the actor to render with transparency (Xlu) instead of opacity, visually revealing the wall’s false nature. This mechanic cleverly integrates into dungeon design, challenging players to use their items thoughtfully. Despite its simple behavior, the actor adds depth to gameplay by blending environmental deception with item-based discovery.

The Arrow_Fire actor handles the visual and functional effects of a Fire Arrow in The Legend of Zelda: Ocarina of Time. It is spawned as a child of a normal arrow (En_Arrow) when the player uses the Fire Arrow magic. This actor is responsible for: Charging phase: Glowing effect while aiming. Flight phase: Trails fire particles behind the arrow. Hit phase: Creates an explosion effect and brief red screen tint on impact. Visual effects: Includes animated texture scrolling for the fire flame and dynamic scaling depending on arrow distance. Damage behavior: The actual damage and collision is handled by the parent arrow; this actor focuses on aesthetics and feedback.

The Obj_Mure actor in Ocarina of Time is a dynamic group spawner responsible for populating the environment with small ambient creatures like fish, bugs, and butterflies. It uses distance-based culling to manage performance, only spawning these child actors when the player is nearby. Depending on its parameters, it can spawn different types and numbers of creatures, and assign behaviors that simulate natural group movement—such as fish following each other or a butterfly occasionally trailing the player. The actor continuously monitors the state of its children, removing them when out of range or destroyed, and respawning them when conditions are met again. This system creates a believable and efficient way to bring the game's natural environments to life.

The z_en_light.c actor file defines the En_Light actor, which represents flame effects such as torch flames and small candle flames in The Legend of Zelda: Ocarina of Time. This actor is primarily used for visual ambiance and lighting, attaching dynamic light sources to static world objects or other actors (like torches or held items). It handles lighting, flame animations, sound effects, and optional logic for appearing or disappearing based on switch states.

Use shrinking Mode: Switch-controlled shrink/grow behavior. When this bit is set, the flame will smoothly scale up or down depending on the state of a specified switch.

Is Lit: If set the flame appears (grows) when the switch is on, and disappears (shrinks) when off.

Is Candle: Small Candle Flame

Switch Shrink: Specifies which switch flag this flame listens to when shrinking mode is active.

The Bg_Hidan_Curtain actor controls the circular flame barriers in the Fire Temple, which act as environmental hazards that can block or damage the player. Depending on its type, the curtain can appear in different sizes and behaviors—some rise and fall when triggered by switches, others disappear after clearing a room or opening a chest. Its logic includes waiting for specific flags (like switches or clear events), playing cutscenes, and cycling its alpha transparency and collider height to simulate the flame rising or lowering. Visually, the fire uses texture scrolling and glowing colors to create a dynamic flame ring effect, and it emits sound and knockback when touched.

Flobbery Muscle Blocks are strange, organic obstacles found inside Jabu-Jabu’s Belly. These squishy, pulsating blocks resemble chunks of flesh and serve as environmental puzzles rather than enemies. They can made non hostile and climbable by hitting it with the boomerang allowing Link to alter the layout of the dungeon and access new areas. Their unsettling, living texture adds to the surreal and biological feel of the dungeon.

The Bg_Mori_Hashira4 actor in Ocarina of Time is responsible for two major interactive elements in the Forest Temple: the rotating central pillars and the large metal gate that opens after solving a puzzle. When configured as the rotating platform, the actor continuously spins the four massive stone pillars in the temple’s main room, using dynamic collision to let Link walk across the moving surface. As a gate, it waits for a switch to be activated—triggering a short delay, a dramatic cutscene, and the gate rising smoothly out of view. Both versions of the actor rely on shared Forest Temple textures and are accompanied by immersive sound effects that enhance the feeling of mystery and ancient machinery. This actor is a great example of how Zelda’s environmental design blends gameplay, atmosphere, and subtle storytelling through motion and interaction.

The En_A_Obj actor is a versatile environmental object used for various static and interactive scene decorations in The Legend of Zelda: Ocarina of Time. This actor handles many types of objects including stone blocks, small grass, a stump, and signs. It extends from DynaPolyActor, meaning it can participate in dynamic collision and physics simulations. The actor supports rotation behaviors, timed actions, and text interaction (primarily for signposts). It features a cylindrical collider for physical interactions and uses an action function pointer to define custom logic per object type. Although only oblong and arrow signposts are placed in rooms by default, the system supports a wide range of types for flexibility in world design.

The Bg_Gnd_Nisekabe actor represents illusionary walls found in Ganon's Castle during the trials. These walls appear solid at first but are revealed to be fake when viewed through the Lens of Truth. Depending on the specific parameter value set for each instance, the actor displays one of several different wall designs, such as those used in the Light Trial or near the Deku Scrubs. While the wall seems real under normal conditions, activating the Lens of Truth dynamically changes its rendering from opaque to semi-transparent, visually exposing the deception. The actor manages this by toggling its internal rendering flags during each update cycle based on whether the Lens of Truth is active.

The En_Ganon_Organ actor represents the dramatic organ setup Ganondorf plays during the cutscene just before the final battle. This static, non-interactive prop includes the organ, its platform, decorative statues, and part of the throne room floor. Its primary function is visual, helping to build tension and atmosphere. The actor reacts to the cutscene state and Ganondorf’s transparency by adjusting its environment color and render mode, allowing it to fade out smoothly when no longer needed. The organ setup self-terminates after its role in the cutscene ends.

The En_Horse_Ganon actor represents Ganondorf’s black steed during his cinematic appearances in Ocarina of Time, particularly in key cutscenes like his dramatic exit from Hyrule Castle after kidnapping Zelda. This actor is built on the flexible skeletal animation system (Skin), using a set of animations including idle, walking, galloping, and rearing. It follows a predefined path of 14 waypoints, adjusting its speed dynamically based on player proximity or scene context. Equipped with both cylindrical and joint-sphere colliders, En_Horse_Ganon supports accurate collision for cinematic realism and interaction detection. Though not ridable by the player, it’s designed to react to the environment and maintain animation transitions that enhance Ganondorf’s imposing presence. Its combination of pathing logic, skeletal animation, and collision behavior makes it one of the more cinematic and atmospheric non-interactive actors in the game.

The Bg_Gate_Shutter actor controls the large metal gate found between Kakariko Village and Death Mountain Trail in Ocarina of Time. This gate opens or closes based on the player’s progress in the story, particularly after triggering certain flags like talking to characters or completing events. When open, the gate slides open along the X and Z axes accompanied by sound effects. It uses a dynamic polygon (DynaPoly) collision and plays an animation of sliding horizontally to either block or allow passage through the path. Internally, the actor maintains a state machine (actionFunc) to handle transitions between idle, opening, and resetting.

The Bg_Spot12_Saku actor controls the spiked metal gate inside the Gerudo Fortress that leads to the Gerudo Training Ground. Initially, the gate remains closed and scaled to its full blocking size. When the appropriate switch flag is triggered, a short cutscene begins and the gate smoothly retracts sideways by shrinking its horizontal scale and adjusting its position using trigonometric functions based on its rotation. As the gate slides away, a metallic opening sound effect plays, and once fully retracted, it remains in the open position, allowing Link to access the area beyond. If the switch has already been activated before entering the scene, the gate starts already open and out of the way.

The Bg_Spot12_Gate actor represents the large metal gate leading from Gerudo Fortress into the Haunted Wasteland. Initially closed, the gate is programmed to open vertically when a specific switch flag is triggered—typically after the player gains approval from the Gerudo guards. Once activated, a short cutscene plays, and the gate begins to rise smoothly using gradual velocity changes. During this motion, appropriate metallic gate-opening sound effects are played, and a brief camera quake effect adds dramatic tension. If the switch flag has already been set before the area loads, the gate appears fully open from the start. After reaching its open position, the gate remains permanently raised, allowing the player to pass freely into the desert beyond.

The Bg_Haka_Tubo actor represents the giant flaming skull jars found in the Shadow Temple. These interactive objects are both environmental hazards and collectible sources. Each jar consists of two components: the visible skull model and an animated ring of blue fire that spins around its top. The actor includes two collision zones: one inside the jar (to detect attacks or projectiles that may break it) and another surrounding the flame circle (which harms the player upon contact).

At initialization, the actor sets up its dynamic collision and two cylindrical colliders — one for the pot itself and another for the damaging flame. It also begins with a small randomized offset for the animated fire texture to give a more natural visual variation. If the actor is placed in room 12 (the infamous spinning pot room), the jar rotates in a circular path around a central point, creating a moving hazard that the player must chase down or avoid.

If the player's attack hits the jar's internal collider within a specified range, the jar "breaks," triggering an explosion effect, a burst of fragments, and a sound effect. At this point, the jar becomes invisible, and after a short delay, drops a collectible. The drop behavior depends on the room and game state. In room 12, the pot may spawn random rewards, nothing (and a Keese), or — if it’s the last of the three jars — a big rupee reward and a chime. In other rooms, the pot usually drops a small key unless that key has already been collected, in which case it defaults to a recovery heart.

The blue flame around the pot is animated with scrolling textures and uses transparency effects to create a magical look. This flame is both aesthetic and functional, damaging the player if they make contact. Overall, this actor combines visual effects, collision logic, and collectible mechanics to provide a dynamic temple obstacle that rewards the player for careful timing and exploration.

The BgHeavyBlock actor controls the large blocks in the game that can only be lifted using the Golden Gauntlets. Depending on its type, the block may be breakable, unbreakable, or a falling piece created after destruction. Breakable blocks shatter into pieces when thrown, triggering a cutscene, rumble, sound effects, and spawning debris with randomized velocity and rotation. Unbreakable blocks can be moved but remain intact, sometimes triggering switches or unlocking progress (e.g., outside Ganon’s Castle). This actor uses DynaPoly collision for interaction and transitions through states such as waiting to be lifted, flying through the air, or landing. When broken, it spawns smaller debris actors, each with their own physics and timers before despawning. Dust and quake effects add realism during lifting, impact, and crumbling, enhancing the dramatic weight and power associated with these legendary-strength puzzles.

The Bg_Po_Syokudai actor represents the golden torch stands used during the Poe Sisters puzzle in the Forest Temple of The Legend of Zelda: Ocarina of Time. These torches light up when a specific Poe Sister is defeated and help manage the puzzle’s state. There are four variations, each with a unique flame color representing one of the Poe Sisters: Meg (purple), Joelle (red), Beth (blue), and Amy (green). The torches emit glowing dynamic light, play fire sound effects when lit, and spawn flame visual effects. The final purple torch also has conditional logic to spawn Meg once the others have been defeated and the corresponding switches are set.

The Bg_Spot18_Futa actor represents the lid of the spinning Goron vase found in Goron City in The Legend of Zelda: Ocarina of Time. This lid is a dynamic actor with collision, meaning it physically blocks the player and interacts with other elements in the game world. It’s typically positioned over the large pot that spins in the middle of the room, part of a mini-game or puzzle event. When certain conditions are met—such as the player lighting the torches and causing the pot to spin—the lid can be removed. In the code, this is represented by the lid checking whether it has a parent actor (likely the spinning pot). If it does not, it begins to shrink uniformly in all dimensions until it vanishes entirely, at which point it removes itself from the game with Actor_Kill(). Its rendering is handled through a simple display list (gGoronCityVaseLidDL), and its collision uses dynamic polygon collision (DynaPoly) tied to a static mesh (gGoronCityVaseLidCol). Overall, the lid acts as a temporary, destructible environmental prop that visually and physically seals the spinning pot until gameplay logic determines it should be removed.

The Gossip Stone actor (En_Gs) in The Legend of Zelda: Ocarina of Time is a unique, interactive object that serves both as a mysterious environmental element and a player utility. These stones respond to various player actions, including being struck, bombed, or having songs played near them. They often provide cryptic hints or lore when spoken to, particularly when the player wears the Mask of Truth. The code handles several interactive responses: playing certain ocarina songs causes fairies to spawn, hitting the stone with different weapons or effects (like a bomb or hammer) triggers animations such as bouncing, rotating, stretching, glowing, or even launching upward and exploding. Each effect is managed through a combination of state flags, smooth mathematical transformations (for visual squashing/stretching), and sound cues to enhance player feedback. The Gossip Stone uses a ColliderCylinder to detect interactions and supports attention targeting, meaning Navi may point it out to players. Though it appears inert, the actor is a rich showcase of responsive design in the game’s world, incorporating text display, visual deformation, sound effects, collision handling, and even limited physics-based movement.

The gravestone actor is a dynamic background object used in various scenes, such as the graveyard and Lake Hylia. It can be interacted with by the player, specifically by pulling it backward to reveal hidden content. During initialization, the actor loads its collision data and sets itself up as a dynamic polygon actor. In its default closed state, it checks whether the player is standing on the dirt patch in front of it and, under certain conditions, allows the player to pull the gravestone. When the player pulls it, the stone slides backward up to a maximum distance while playing a sliding sound effect. If the stone reaches its maximum distance and the correct conditions are met—like being in the graveyard at night—a Poe may spawn. Alternatively, if it's the correct gravestone in Lake Hylia, a success chime plays. The stone also has a locked variant, used during the day in the graveyard, where it becomes unmovable and displays a warning message from the Graveyard Boy if the player attempts to pull it. Visually, the actor draws both the stone and a patch of disturbed earth that slides back depending on how far the stone has been pulled, giving it a dynamic appearance.

The Bg_Treemouth actor represents the mouth of the Great Deku Tree. It plays a critical role during the early part of Link's journey by controlling access to the dungeon inside the tree. This actor handles the cutscene where the tree opens its mouth, responds to player interaction, and animates the movement of the mouth. Based on the player's progress and certain flags like whether they’ve spoken to the tree or accepted the quest, the mouth either stays closed, opens during a cutscene, or remains open. The actor uses a float value (unk_168) to interpolate the mouth’s position over time, simulating it opening or closing gradually. It is also tied to specific cutscenes (gDekuTreeMeetingCs, gDekuTreeChoiceCs, etc.) and uses sound effects to emphasize key moments, such as the tree groaning or the mouth creaking open. Collision is managed via dynamic collision setup so the player can't walk into the tree until it opens. The actor also spawns debris effects during certain scenes to enhance the animation, and it includes special logic to reposition Link based on his choices. Overall, Bg_Treemouth is a cinematic and gameplay-critical background actor that helps bring the Deku Tree to life.

The actor in z_door_ana.c represents hidden grotto entrances scattered throughout Hyrule in Ocarina of Time. These grottos are small, often secretive areas that the player can enter to find fairies, enemies, treasure, or mini-puzzles. The actor supports two main states: closed (hidden) and open (accessible). Hidden grottos require specific triggers to reveal them — either a bomb, a hammer, or playing the Song of Storms. The actor uses a collider to detect player interactions or environmental triggers. Once revealed, the grotto slowly scales into visibility and waits for the player to approach. Upon contact, it initiates a warp to a corresponding grotto interior using the sGrottoEntrances table. The entrance angle dynamically adjusts based on the camera’s yaw to ensure proper alignment. This actor plays a key role in encouraging exploration and rewarding curiosity throughout the game world.

The Item_B_Heart actor represents the Heart Container in Ocarina of Time, a collectible item that permanently increases the player’s maximum health by one heart. Upon initialization, it checks if the Heart Container has already been collected using a predefined flag (0x1F) and self-destructs if so. Visually, it slowly floats up and down while rotating, using sinusoidal movement and smooth scaling to create a gentle animation. When the player approaches within range, the game prompts the item for collection using Actor_OfferGetItem. Once picked up, the flag is set to prevent future respawns. Rendering switches between opaque and translucent display lists depending on whether another warp actor is in front of the item on screen, preserving visual depth and presentation fidelity during cutscenes or transitions.

The Bg_Hidan_Fslift actor represents the Hookshot Elevator in the Fire Temple. This dynamic platform initially waits near its home position until Link stands on it, triggering it to rise to a higher level. After reaching the top, or if Link steps off early, the elevator waits briefly and then descends back to its original position. The actor handles both the movement and the positioning of a separate Hookshot target actor (a child actor) that moves with it. It also interacts with the camera system, switching to an elevator camera view while Link is on the platform. Sounds are played during movement and when the platform hits its bounds, enhancing player feedback.

The En_Horse_Normal actor represents non-rideable horses found in specific scenes like Lon Lon Ranch, the Stable, and Gerudo Fortress. These horses are mostly decorative and contribute to the realism and ambiance of the world. Unlike Epona, they can't be mounted by the player. These horses exhibit lifelike behaviors such as wandering, idling, and playing random animations like neighing or rearing. Their animations and movements vary based on time of day, scene, and in-game flags. They use a custom skinning system (Skin) for animations, multiple colliders (including for body and head), and can even display "clone" visuals for aesthetic mirroring in the stable. Some horses follow a set path if configured to do so via parameters. Overall, En_Horse_Normal helps breathe life into the environment without serving a direct gameplay function.

The En_Yabusame_Mark actor represents invisible hitboxes for horseback archery targets in Gerudo Fortress's mini-game. Each target is categorized as small, medium, or large, with invisible quad colliders positioned in the world. When Link hits a target with an arrow while riding Epona, the actor calculates the distance from the hit location to the target’s center and assigns a score tier—100, 60, or 30 points—based on accuracy. A corresponding sound and particle effect plays based on the score. This logic enables fine-grained scoring by evaluating impact precision, allowing the game to reward better aim. The actor also self-deletes unless the player is in the correct mini-game layer.

The Obj_Elevator actor represents a stone platform elevator commonly used in Ocarina of Time dungeons, such as the Fire Temple. It activates when Link steps on top and moves smoothly between two vertical positions—its home Y position and a raised or lowered position defined by a parameter. Upon activation, the elevator detects whether it is currently at its original height or already elevated and then moves in the opposite direction. The movement is handled using smooth step interpolation to create a gradual lift or descent effect, and corresponding sound effects are played during motion and upon reaching the destination. Once it reaches the target position, the elevator becomes idle again, waiting for the next player interaction. The elevator uses dynamic collision to allow Link to stand and move on it as it travels.

The Bg_Hidan_Hrock actor represents the large stone spike platforms found in the Fire Temple, playing a crucial role in environmental puzzles and player progression. These dynamic actors can be triggered to drop into position by striking them with a weapon, typically the Megaton Hammer. Upon activation, the platform shakes dramatically, simulating a heavy stone shifting loose, complete with rumble feedback and sound effects. The platform then descends to a lower position, where it becomes permanent and solid for navigation. Depending on its parameter value, the actor renders one of three models and drops to a unique height. It also updates its collision and hit detection to allow the player to stand on it or interact with it further. By integrating collision geometry updates, dynamic movement, switch flag logic, and animation feedback, Bg_Hidan_Hrock provides a satisfying and impactful interaction in the temple’s vertical design.

The Bg_Spot15_Saku actor represents the metal gate at the entrance of Hyrule Castle. This gate serves as a dynamic obstacle that can be lowered when certain story events occur. Upon initialization, it loads collision data and sets its position; if the player has already triggered the associated story flag (INFTABLE_71), the gate is positioned as open by default. Otherwise, it starts closed. When a specific condition is met in the game (such as the player advancing the story or interacting with a certain trigger), the gate’s internal flag unk_168 is set, which transitions the actor to a state where it begins to animate the gate lowering. This is done by decrementing the z position gradually while playing sound effects to simulate the gate moving. Once it reaches the target position (2660.0f on the z-axis), the movement stops, and a cooldown timer is set before returning the gate to an idle state. The actor also handles cleanup of dynamic collision and renders a translucent display list of the gate model. It’s a simple but effective puzzle gate actor controlling access to the castle area based on progression.

The Arrow_Ice actor controls the visual and reactive effects of the Ice Arrow. It is automatically spawned as a child of the normal arrow (En_Arrow) when the Ice Arrow is used, and manages three core stages: Charging Phase: While aiming the arrow, a blue icy glow charges up. Flight Phase: A shimmering frost trail follows the arrow mid-air. Hit Phase: On impact, the screen flashes blue, and the actor simulates a freezing explosion with animated visuals. While the actual damage and freezing mechanics are handled by the parent arrow (En_Arrow), Arrow_Ice provides the visual and audio feedback, including the swirling frost animations and translucent effects.

The Bg_Spot08_Iceblock actor represents the floating ice platforms found in Zora’s Fountain. These platforms are dynamic, interactable objects that bob up and down, react to Link's weight, and in some configurations, rotate or orbit around a central point. The actor can behave in several ways based on its params settings: remaining stationary, slowly rotating, or forming a twin pair that orbits each other. When Link steps on an ice block, it sinks slightly to simulate weight and shifts its orientation with a rolling effect determined by Link's position, momentum, and the block’s size and damping settings. This realistic floating behavior is calculated each frame using surface normals, rotation matrices, and vector math to smoothly animate the ice’s tilt. Additionally, the actor dynamically spawns its twin when configured for orbiting mode. Only available to adult Link, these platforms are used for traversal across the frozen lake and to hidden areas, adding both a puzzle and platforming challenge.

The Bg_Ice_Turara actor represents the icicles (stalactites and stalagmites) found in ice-themed areas such as the Ice Cavern. These hazards come in two main types: static stalagmites that can be destroyed and dynamic stalactites that fall when the player gets close. Some stalactites can also regrow after shattering, creating an ongoing environmental hazard.

The actor starts by checking its params to determine its type. Stalagmites simply wait to be struck—usually by the player’s sword or other attacks—and break apart into ice shard particles when hit. Stalactites, on the other hand, use a state machine to handle player proximity: they begin in a waiting state, transition to a shivering animation with slight positional jitter and sound effects when the player is near, and then drop after a brief delay. If they hit the player or the ground, they shatter with a sound and particle effect.

Some stalactites are set to regrow. In these cases, after falling and breaking, they reposition themselves above and slowly descend back to their original position to reset the trap. The breaking effect uses ice particles with randomized position, velocity, and scale, adding visual variety.

Collision is handled via a ColliderCylinder, which is dynamically updated as the icicle moves. Collision with the player or environment determines when the icicle should shatter. The actor uses DynaPoly for environmental interaction and basic physics, including gravity, to simulate falling.

The Bg_Ingate actor controls the wooden gates at Lon Lon Ranch used during the Ingo horse-racing events. These gates act as dynamic actors with collision, capable of rotating open during a cutscene. Upon initialization, the actor verifies that the scene is Lon Lon Ranch and the player is adult Link. It then checks specific game progress flags—such as whether Epona has been obtained—to determine whether it should be active. If the conditions are met, the gate either stays idle or begins a scripted rotation animation based on cutscene frames, simulating the gates opening outward. This animation uses smooth sinusoidal rotation and then locks into place once the gate fully opens. The actor includes collision, draws a gate model, and is used to visually and physically control player access during Ingo’s events.

The Bg_Bdan_Objects actor is responsible for managing several interactive and animated environmental elements within the Lord Jabu-Jabu dungeon, including elevators, falling platforms, rotating spike platforms, and the dramatic Big Octo boss platform. This actor’s design is modular, supporting various types of behavior through different parameter values, and it uses a state machine (actionFunc) pattern to transition between phases of interaction based on player behavior and game flags.

When initialized, it loads different collision models depending on its type. For instance, the Big Octo boss platform has special logic that handles Ruto-triggered cutscenes and boss battle progression. The platform begins lowered, raises when the cutscene starts, and then drops again once Big Octo appears. It uses smooth interpolation for movement and audio-visual effects like rumble, sound effects, and screen shake (via the quake system) to enhance immersion. Additionally, once Big Octo is defeated and the room is cleared, the platform rotates to align with the new path forward and becomes a player-controlled elevator.

Its update and draw functions maintain a consistent loop of behavior execution and render appropriate display lists depending on the object type. For instance, water platforms are rendered translucently, while others use opaque geometry.

The En_Wonder_Item actor is a versatile and invisible trigger-based entity used in Ocarina of Time to spawn collectibles, activate switches, or initiate events under specific conditions—without any visible model. It operates in multiple “wonder modes,” each enabling unique behaviors such as proximity-based item drops, damage-triggered interactions (e.g. hit by arrow or boomerang), sequence-based tag puzzles, and “cow switch” replacements in Master Quest. The actor uses the params and rot.z fields to define its mode, number of required interactions, item drop type, and switch flag. In some modes, it tracks the player’s proximity or input, while in others it checks collisions (like from specific weapons) or coordinates with invisible tag point markers to solve puzzles. When the conditions are met, the actor may spawn a drop (like rupees or hearts), activate a switch, or even spawn another actor like a soldier. After fulfilling its task, it destroys itself.

Bg_Jya_Ironobj represents destructible environmental props found in Iron Knuckle rooms — specifically large stone pillars and thrones. These objects are dynamic actors that can be broken by Iron Knuckle’s heavy axe attacks. When struck successfully, the object disintegrates into flying debris using custom particle effects and spawns three Recovery Hearts at its base. This adds both a cinematic flair and functional reward to boss encounters. The actor uses a collision cylinder to detect when it's hit, checks that the attacker is specifically an En_Ik (Iron Knuckle), and then triggers a custom destruction animation depending on whether it’s a pillar or a throne. The explosion effect includes individually animated fragments and dust clouds, enhancing the environmental storytelling and making Iron Knuckle feel more powerful. Once destroyed, the actor cleans itself up, removing its collision and visuals from the scene.

The Bg_Mori_Hashigo actor is an unused object in Ocarina of Time designed to simulate a falling ladder mechanism, including both the ladder itself and a clasp that holds it in place. This setup appears to be intended for the Forest Temple or a similar dungeon environment but ultimately wasn’t utilized in the final game. When loaded, the clasp spawns the ladder as a child actor. Upon player interaction (e.g., a strike), the clasp's hit flag triggers the ladder’s state machine to simulate gravity and bounce three times before settling into a climbable position. The ladder uses DynaPolyActor for collision so Link can climb it like any standard ladder in the game.

The Lake Hylia Objects (Bg_Spot06_Objects) actor handles a group of interactive environmental objects that reflect the player’s progression through the Water Temple in Ocarina of Time. This multifaceted actor includes the large metal gate that seals the temple entrance, the fish-shaped hookshot lock used to trigger its opening, the dynamic water plane that represents the surface of Lake Hylia, and an ice block that provides shortcut access to Zora’s Domain. Each type behaves differently depending on the game’s state: the gate remains shut until the player activates a switch; the lock responds to the hookshot by floating to the surface with elaborate motion and effects; the water plane rises during a cutscene after the temple is completed; and the ice block only appears when Link is an adult. The code carefully manages each object’s visual representation, collisions, cutscene behaviors, and sound effects, all contributing to a smooth, reactive environment. Through this system, Lake Hylia becomes a living location that changes as Link’s journey progresses.

The Bg_Jya_Bigmirror actor represents the massive ceiling mirror used in the Spirit Temple's light-based puzzle. It dynamically manages the spawning and removal of related Cobra mirrors and light beams depending on the player’s current room and puzzle progress. The mirror is visually responsive to the height of the elevator platform below it, creating the illusion of reflected light. The actor checks Cobra mirror orientations to determine puzzle completion and, once solved, spawns light beams (Mir_Ray) that visually represent light being redirected through the temple. This actor is responsible for orchestrating one of the major progression-based puzzles in the adult portion of the dungeon.

The BgHidanFwbig actor controls the large animated fire walls in the Fire Temple — including the vertical wall that blocks a bombable door and the horizontal one that chases the player across the lava room. These fire walls are initialized with directional parameters and scale based on whether they move or remain stationary. For moving variants, the actor tracks the player’s position and shifts along a defined path, triggering cutscenes and sound effects. The actor has built-in logic to rise and lower the wall, detect switch triggers, and damage players via a cylindrical collider. It includes smooth animation transitions, player knockback interactions, and visual effects using animated textures and scrolling flames. Overall, this actor dynamically enhances the temple's danger through movement, sound, and visual intimidation.

The En_Lightbox actor in Ocarina of Time is a dynamic, interactable object with multiple scale variations, defined by its params value. Though the header lacks a description, the code reveals its functionality as a carryable and bouncy box-like prop, potentially used in puzzles or room decoration. It uses a collision mesh (object_lightbox_Col_001F10) and is registered with the dynamic collision system, making it responsive to the environment. When thrown or moved, it reacts to ground and wall collisions by bouncing with sound effects and reduced momentum, using configurable bounce behavior via IREG values. It can be picked up when idle on the ground and maintains an updated collision and focus position. The draw function renders a display list (object_lightbox_DL_000B70), completing its simple visual representation. Though not explicitly tied to puzzles in this snippet, its physical behavior and interaction flags suggest it may serve as a physics object or visual element within dungeons or scripted cutscenes.

The Bg_Mori_Bigst actor in Ocarina of Time controls a key gameplay sequence in the Forest Temple involving a falling platform and multiple Stalfos encounters. Initially, the platform is suspended above the arena, and the actor waits for a texture bank to load before proceeding. If the player has not yet triggered the switch that anchors the platform, the actor initiates a sequence where the platform drops dramatically when the player approaches a certain height, starting with a single Stalfos fight. Upon defeating it, the platform falls into place with a cutscene and rumble effect, followed by a second fight featuring two Stalfos. If all enemies are defeated, a switch flag is set to ensure the platform remains grounded in future visits. This actor combines dynamic environmental movement, conditional cutscenes, and enemy spawning to create a memorable mid-dungeon battle encounter.

The Arrow_Light actor handles the visual, audio, and reactive effects of the Light Arrow in The Legend of Zelda: Ocarina of Time. It is dynamically created as a child of a normal arrow (En_Arrow) when the Light Arrow is used and progresses through three main states: Charge State: A golden glow builds around the arrow while aiming. Flight State: A bright, radiant trail follows the arrow mid-flight. Hit State: Upon collision, a blinding flash of light overlays the screen to emphasize its magical impact. This actor primarily manages visual presentation, leaving damage mechanics and collision handling to its parent (En_Arrow).

The Bg_Jya_Bombchuiwa actor represents a destructible rock in the Spirit Temple that reacts specifically to bomb or explosive-based damage. Initially, it waits in place with collision detection active, ready to trigger a short cutscene once struck. After being hit or if a certain timer elapses, it plays a breaking animation by spawning debris (via EffectSsKakera) and sound effects, then disables itself visually. As the rock breaks, a beam of light effect gradually fades in at its location, increasing in intensity until it reaches full brightness. Eventually, it spawns a Mir_Ray actor to direct a beam of light through the temple for the mirror puzzle sequence.

The z_player.c file is one of the most essential components in the decompiled codebase of The Legend of Zelda: Ocarina of Time, as it defines the behavior of the main character, Link. This actor file manages everything related to the player, including movement, animations, combat, equipment usage, and interactions with the environment and other actors. It processes controller input to drive actions like walking, jumping, attacking, and item usage, while also switching between different states such as idle, swimming, climbing, or aiming with a bow. The file is closely integrated with others like z_player_lib.c for helper functions, and header files like z64player.h and z64item.h that define data structures, item IDs, and state flags. Through this system, the game can dynamically adjust Link’s behavior based on his age, equipment, and surroundings. For instance, using the ocarina, equipping different swords and shields, or triggering context-sensitive actions all depend on logic defined in z_player.c. This makes it a cornerstone of the game’s functionality, enabling the seamless and responsive control that the series is known for.

The En_Jj actor represents Lord Jabu-Jabu, the massive fish deity found in Zora’s Fountain. This complex actor consists of three parts: the animated main body (JABUJABU_MAIN), a static collision actor (JABUJABU_COLLISION), and an unused collision variant. Lord Jabu-Jabu interacts with the player in multiple ways—he blinks dynamically, breathes audibly, and responds to specific triggers such as being fed a fish, which initiates a cutscene where he opens his mouth and inhales Link. His eye state cycles through open, half-closed, and closed using a blink timer with optional multi-blink behavior. The actor coordinates with child actors for collision and visual effects like dust. During cutscenes, his behavior is guided by cue points, including playing sounds, removing the dust actor, and animating his mouth open angle. The En_Jj system also disables ceiling collision and handles dynamic collision setup for the interior dungeon entrance.

The En_Jsjutan actor is the flying magic carpet that supports the Magic Carpet Salesman in the Haunted Wasteland. This dynamic actor handles not only visuals but physics-based wave simulation, creating a believable flying and wobbling surface in mid-air. The carpet reacts to nearby characters (including Link, the salesman, bombs, or even NPCs during credits), generating localized ripples based on proximity and position. The carpet’s surface is animated using sinusoidal wave patterns with vertex displacement. It alternates between two vertex buffers (odd and even) each frame for smooth animation and lighting.

The Bg_Hidan_Dalm actor is a dynamic, destructible object used in the Fire Temple to represent hammerable totem pieces. When initialized, it checks a switch flag to determine if it should already be removed from the scene—if not, it remains idle in a wait state. In this state, it listens for an attack from the player using the Megaton Hammer. Upon being struck, it triggers a short animation where the totem rotates, moves slightly, and then begins to shrink while emitting sparkle effects. Once fully shrunken, it disappears from the scene, sets the corresponding switch flag, and plays appropriate sound effects. The actor uses a four-element triangular collider to detect hits from the player, and dynamically updates its collision vertices each frame to match its current transformation. Depending on its parameters, it will render either a totem head or body model, making it a flexible modular component used to gate progress in the Fire Temple.

The Bg_Zg actor represents the large vertical metal bars found in Ganon’s Castle. These bars are dynamic background elements that can be raised and removed from the scene when specific conditions are met—namely, when a switch flag is set. Upon initialization, the actor checks if a relevant switch is already activated and removes itself if so. Otherwise, it loads its collision data and sets its position and scale based on actor parameters. The actor responds to game logic in two main states: waiting for the switch flag to trigger the bar's movement, and animating the upward motion as the bars rise. Once they have risen past a certain height, the actor deletes itself. A special anti-piracy check is also embedded in the code for the N64 version to prevent the bars from opening if the system’s memory state is invalid, an intentional deterrent against using unauthorized copies of the game. The visual representation uses a specific display list and scales appropriately depending on which instance of the bars is being rendered. This actor contributes to key dramatic moments in Ganon’s Castle, reinforcing progression by gating access until certain in-game events have occurred.

The Bg_Mizu_Shutter actor controls the metal shutter gates found in the Water Temple. These gates operate based on switch triggers and timed logic, playing a key role in the temple’s dynamic, puzzle-based progression. Each shutter can be in either a small or large variant and is defined by parameters such as open/closed positions, a switch flag, and an optional timer. When the designated switch is activated, the shutter initiates a cutscene if appropriate, plays a metal door opening sound, and then smoothly moves from its closed to open position. If a timer is set (less than the default max of 0x3F * 20 frames), the door remains open for that duration before automatically closing again. During movement, the actor uses smooth interpolation for position changes, accompanied by fitting sound effects and even controller rumble feedback. Visually, it renders one of two display lists depending on its size type, and it makes use of dynamic collision through the DynaPoly system to block or allow player passage. The logic ensures the shutter is persistent, responsive to switch states, and blends well into the puzzle design of the Water Temple.

En_Trap is a hostile mechanical spike trap found in dungeons such as the Shadow Temple and Bottom of the Well. It moves using one of three configurable behaviors based on its parameters: linear (sliding back and forth), circular (orbiting a central point), or four-directional (lunging at the player when nearby). It actively damages and knocks back Link upon contact and uses a cylindrical collision detector to manage interactions. If struck by an ice-based attack, it temporarily freezes, halting its motion and displaying icy visual effects. The trap makes mechanical sounds while moving and reacts to collisions with walls or actors, reversing or stopping when necessary. Its behavior is driven by internal logic that calculates directions, distances, and actor proximity each frame, making it a dynamic obstacle that adds pressure and timing challenges to dungeon traversal.

The Bg_Spot15_Rrbox actor is the pushable wooden milk crate found at Lon Lon Ranch. It functions similarly to push blocks in dungeons but with scene-specific logic and constraints. The crate can be pushed by Link in the direction he is facing, will slide forward on a grid, and checks if it is placed correctly (e.g., on a designated ground spot). If misaligned, the crate falls and resets its position. Some crates are permanently moved once a switch flag is set. Sound effects play during sliding, collision, or falling. The actor tracks player interaction and precise movement for puzzle solving and scene scripting.

The Elf_Msg2 actor is a targetable Navi hint point used throughout Ocarina of Time to trigger contextual dialogue when Link is nearby and uses the C-Up command to interact. Upon initialization, it checks various flags to determine if it should be removed from the scene immediately—for example, if a specific switch flag is already set or if the room has been cleared. If not, it sets up an internal action function that either waits for a specific switch flag to become active (delaying its interactivity) or allows immediate interaction. The actor's parameters control which message will be displayed, whether it should destroy itself after use, and what switch flag, if any, should be activated once the message is read. In most cases, once the Navi message is delivered and the player closes the textbox, the actor sets its designated switch flag and then removes itself, unless configured to persist via a special rotation value. This makes Elf_Msg2 especially useful for puzzle hints, optional guidance, and scene-based progress triggers. In debug mode, the actor even renders a faint blue cube to help developers visualize its location and range.

The Elf_Msg actor (z_elf_msg.c) in Ocarina of Time represents invisible Navi call spots—locations where Navi flies to prompt the player with context-sensitive advice or messages. These actors use either a cuboid or cylindrical detection zone to determine if the player is within range, triggering Navi to offer dialogue based on pre-set parameters. They can conditionally appear or self-destruct depending on switch flags or room clear status, allowing designers to tailor when advice becomes available. The actor can also set new switch flags once the player accepts the interaction, enabling progression or event tracking. While normally invisible in gameplay, a debug draw function reveals their shapes for testing. This system forms a key part of the game's guidance mechanic, quietly supporting storytelling and tutorial delivery without intrusive UI elements.

The Magic_Dark actor handles the visual and functional aspects of Nayru’s Love, a magical shield ability that makes Link temporarily invincible. When activated, it initially spawns as an orb of light forming between Link’s hands, accompanied by gradually intensifying light and sound effects. After a short buildup, it transitions into a diamond-shaped protective barrier that surrounds Link. The diamond continuously follows Link’s waist position and rotates to maintain visual appeal. While active, it disables collision damage by repeatedly setting Link’s invincibilityTimer to a negative value. The actor also gradually adjusts the fog and lighting in the environment to create a more mystical and protective atmosphere. It is removed automatically after a fixed duration or if certain cutscenes are triggered, such as playing warp songs. The shader effects, sound cues, and visual transitions are tightly controlled by frame-based timers, ensuring a smooth and cinematic transformation from orb to shield.

The Bg_Umajump actor is a hoppable wooden fence used in areas where Link can ride Epona. This object allows Epona to jump over it, commonly seen in ranches, fields, or horse-riding courses. It features dynamic collision so the player and horse can interact with it, and optionally hides itself if the player has not obtained Epona yet. The fence is visually static but serves as a gameplay mechanic to test or require horse jumping skill.

The En_Okarina_Tag actor represents invisible trigger points where the player can play specific Ocarina songs to cause events in the game world. These actors are scattered throughout the world and facilitate puzzles, environmental changes, and story progression through song recognition. When the player approaches one of these spots and plays the correct tune—such as Zelda's Lullaby, the Song of Time, or the Song of Storms—the game responds with a visual, audio, or scripted effect, such as opening a tomb, triggering a cutscene, or starting rain. The actor can also be used for teaching songs or advancing story milestones and supports customizable interaction range and multiple internal behavior modes based on parameter configuration.

The Item_Ocarina actor, represents the musical instrument known as the Ocarina of Time. This actor is used in key cutscenes and scripted events, such as when Link throws the Ocarina into the moat or retrieves it afterward. The actor supports multiple behaviors defined by its parameters: it can be thrown and animated mid-air, land in water triggering ripples and splashes, or wait submerged for the player to pick it up. Specific cutscene frames control when the Ocarina appears, moves, and triggers effects. This detailed scripting gives the item a cinematic presence in the story.

En_Vase is an unused decorative actor in Ocarina of Time modeled after an orange pot seen in A Link to the Past. It lacks interactivity or collision, serving purely as a visual element. When initialized, it scales down to 1% of its original model size and sets its focus position for camera interactions. Although it casts a circular shadow, it cannot be broken, picked up, or interacted with in any way. The actor renders using the gUnusedVaseDL display list and is never placed in the original game maps, making it another unused asset that could be repurposed in custom mods or restored content.

The En_fHG actor represents Phantom Ganon’s spectral horse, playing a central role in the cinematic boss fight in the Forest Temple. It appears during the dramatic cutscene sequence before the battle and serves as the vehicle Phantom Ganon rides in and out of enchanted paintings. The actor handles complex camera transitions, fog effects, timed animations, and interactions with Boss Ganondorf (En_Boss_Ganondrof), dynamically adjusting its behavior based on battle phase and player position. Depending on its parameters, it can play through the full intro cutscene or spawn mid-battle to initiate approach or retreat behaviors. It supports rendering tricks like fog color blending and morphing scale to simulate teleportation into paintings, while also coordinating sound, animation, and environmental changes to enhance the boss’s haunting presentation.

The En_Kakasi actor represents Pierre the Scarecrow, a memorable NPC in Ocarina of Time who plays a special role in Link’s musical journey. This actor allows players to create and later summon a custom Scarecrow's Song, enabling strategic hookshot points in certain areas. Upon initialization, Pierre sets up his animation and hookshot interaction flags, and determines dialogue options depending on whether the player is child or adult Link and whether a custom song has been saved. The actor's behavior is governed by a state machine that transitions through idle, dialogue, and cutscene states. When interacted with, Pierre initiates a One-Point Cutscene and listens for ocarina inputs. If the player plays a valid sequence, Pierre animates and reacts to each button press with playful movements and sound effects, including spins and bounces. Once the song is recorded, a cutscene concludes and the song is saved to the game state. The code handles both recording and playback modes and uses animation blending, camera transitions, and actor state flags to maintain immersion. Pierre also includes collider logic for player interaction and updates animation frames each tick. This actor contributes both to gameplay utility and the quirky charm that defines many of Ocarina of Time’s NPCs.

The En_Kakasi2 actor represents Pierre the Scarecrow's spawn point in The Legend of Zelda: Ocarina of Time. This actor enables one of the most iconic optional mechanics in the game—custom Scarecrow Song hookshot points. After the player teaches a custom song to Bonooru (the scarecrow by Lake Hylia), Pierre can be summoned at specific locations by playing that song on the Ocarina, allowing the player to hookshot to areas otherwise unreachable.

When initialized, En_Kakasi2 checks a variety of parameters:
It determines whether a certain switch flag has been set, which controls whether Pierre should appear persistently.
It also configures custom spawn range values for XZ and Y axes, defining how close the player must be for Pierre to activate.

If the conditions are met—either the custom Scarecrow Song is played or debug flags are used—Pierre rises from the ground in a cinematic cutscene, accompanied by sound effects and an idle animation. He becomes hookshot-able thanks to a cylindrical collider flagged with HOOKABLE, and he draws attention using ACTOR_FLAG_ATTENTION_ENABLED. Once spawned, his state changes and persists if tied to a switch flag.

The scarecrow uses skeletal animation with a looping idle pose and rotating movement to simulate liveliness. Debugging printouts throughout the code show how developers fine-tuned spawn behavior using the actor's distance to the player and debug registers (BREG), including visual debug aids in development builds.

Overall, En_Kakasi2 is a highly interactive and conditional actor, allowing players to creatively use their custom song for traversal, and offering a satisfying reward for engaging with a quirky side quest mechanic.

The z_bg_po_event.c actor manages the Poe torch puzzle events in the Forest Temple, where Link must solve a series of tasks involving four Poe Sisters. This actor controls the torches that light up or extinguish as the player progresses, reflecting the status of each Poe Sister. It visually updates flames, handles animations, and syncs with game flags to determine which Poes have been defeated. The actor also contributes to the central elevator room puzzle by unlocking the rotating block mechanism once all torches are lit. Through clever state tracking and visual effects, this actor reinforces the eerie, haunted atmosphere of the dungeon while tying together its multi-room puzzle progression.

Proximity Activated Fire Wall actor, is a triggered wall of flames used in the Fire Temple of The Legend of Zelda: Ocarina of Time. This actor remains invisible and inactive until the player approaches it, at which point it erupts into a damaging flame wall. The firewall uses visual effects, sound, and collision detection to simulate a hazardous barrier blocks or creates pressure in puzzle or combat scenarios. The firewall begins in an idle state and constantly checks if the player enters a rectangular activation zone (100 units x-axis, 120 units z-axis). Once triggered, it transitions through a brief countdown before becoming fully active. The flame animation cycles through 8 textures (gFireTempleFireball0Tex to gFireTempleFireball7Tex) every frame via unk_150, simulating a flickering effect. This is rendered using a translucent display list.

The En_Weather_Tag actor is responsible for dynamically triggering weather changes—such as rain, clouds, snow, thunderstorms, and sandstorms—when the player enters a designated proximity radius. Each weather tag is initialized with a specific mode based on its params, such as cloudy weather for Hyrule Market or rain and thunder for Lake Hylia. Once the player enters the tag’s detection range, the actor smoothly transitions the environment settings, including skybox, lighting, precipitation, ambient sounds, and fog values to simulate the desired weather. If the player exits the area, the tag gradually restores the previous weather conditions. Some weather tags also include logic to prevent activation if certain event flags or story progress milestones have been met, making them context-sensitive and ensuring they only appear during the appropriate points in the game.

The Obj_Makeoshihiki actor is a hardcoded puzzle setup used to spawn and control push blocks in predefined configurations. Instead of relying on dynamic object placement, this actor spawns a child Obj_Oshihiki block at one of three preset positions determined by the current puzzle state and in-game flags. During initialization, it checks various switch flags to determine which block position to use, then spawns the corresponding block with specific attributes such as size, color, and behavior (like immovability). The actor also contains logic in its draw function to monitor the position of the child block—when the block is aligned with a designated target spot, it updates associated switches and can play a chime sound to indicate success. The configuration includes logic for enabling or disabling specific switches based on bitwise conditions, providing feedback through sound effects, and locking the block in place once it reaches the correct location.

The Obj_Oshihiki actor represents the classic pushable blocks used in many dungeon puzzles throughout The Legend of Zelda: Ocarina of Time. These blocks can be pushed or pulled by the player under certain conditions and are commonly used to press switches, create platforms, or open paths. The actor handles detailed logic such as determining if Link is strong enough to move it (based on strength upgrades), falling behavior if unsupported, syncing movement when stacked on top of another block, and adapting its behavior depending on the scene and block type. The block's appearance, size, and function (e.g., initially present or hidden based on a switch flag) are all configurable via its parameters.

The Pushable Ice Block (Bg_Ice_Objects) actor represents the sliding puzzle blocks found in the Ice Cavern. These blocks are dynamic background actors that interact with the player’s pushing input and slide across a grid-based floor until they hit a wall or fall into a pit. The actor determines its direction from the player's push and calculates its next stopping point based on predefined wall coordinates. As it slides, it builds momentum, plays ice-sliding sound effects, and emits icy particle effects when moving fast. If the block falls into a pit, it smoothly resets to its original position. Once placed in a specific target location, it becomes "stuck" and unmovable, often as part of a puzzle solution. The logic is crafted to provide both responsive control and visual feedback, creating a satisfying mechanic central to the Ice Cavern’s environmental challenges.

The Bg_Gnd_Iceblock actor represents the sliding ice blocks used in Ganon's Castle's Water Trial puzzle. These blocks can be pushed by the player and slide across the floor until they collide with an obstacle, fall into a pit, or land in a specific hole. Internally, the actor tracks each block's current grid position within a predefined map and determines legal movement paths based on direction and collision checks. Depending on where the block ends up, it either resets, falls into a pit, or "solves" part of the puzzle by settling into a hole. The actor also handles visual feedback such as slipping effects and ice particle generation while sliding. This logic is deeply tied to scripted cutscenes and player states to ensure that the puzzle interacts cleanly with the game's flow and camera events.

The Bg_Gjyo_Bridge actor represents the iconic Rainbow Bridge that forms outside Ganon’s Castle, allowing Link to access the final dungeon. At runtime, the actor checks if the event flag for the bridge has been set. If not, it hides the bridge and disables its collision. When Link enters the correct area with both the Shadow and Spirit Medallions and the Light Arrows, it triggers a special cutscene that spawns the bridge. Once the cutscene reaches a specific point, the bridge becomes visible, collision is enabled, and the event flag is set to prevent it from despawning in the future. The bridge uses dynamic scrolling textures for a magical effect and has animated visuals drawn via translucent display lists.

I'm working on documenting and organizing all the level item actors in Zelda: Ocarina of Time, and right now I'm focusing on the Red Ice actor (Bg_Ice_Shelter). This actor is used throughout the Ice Cavern and near King Zora, representing magical ice that can only be melted with Blue Fire. There are several different versions—large blocks, small chunks, platforms, walls, and the special case covering King Zora. Each version has its own scale, collision setup, and melting behavior. When hit with Blue Fire, the red ice starts to fade and shrink, releasing steam particles and eventually disappearing. I'm cataloging the specific parameters, display lists, collider configurations, and how the animation and particle effects are triggered, so that I can better understand and repurpose these elements for custom map design.

En_Horse actor in Zelda handles the behavior, animation, collision, and interaction logic for Epona, Link’s horse, as well as other generic horses seen in places like Lon Lon. This is a very long file with almost 4000 lines of code and supports free movement, pathing, player riding, and interactive gameplay mechanics. It’s tightly integrated with both player state and cutscene systems, making it one of the most complex and feature-rich actors in the game.

Common States & Events
Spawned at Lon Lon Ranch or Hyrule Field.
Racing Events: Used during Ingo races.
Escape Scene: Jumping the fence when escaping Ingo.
Call-and-ride Mechanic: Responds to Epona's Song.

Other Related Files
z_en_horse_game_check.c: Handles horse-racing minigame logic.
z_en_horse_link_child.c: Defines the child Link’s horse (used in Lon Lon Ranch).
z_en_horse_ganon.c: Horse used by Ganondorf in final battle.
z_en_horse_normal.c: Handles horses without special behavior (e.g., background props).

The Bg_Ddan_Jd actor is a rising stone platform used in Dodongo’s Cavern. It moves between the dungeon's lower levels, a middle resting point, and the top level, creating a timed elevator cycle that players must use to progress or backtrack. Its movement is controlled by a finite state machine and a delay timer (idleTimer) that determines when it starts moving. The platform creates dust effects and plays movement sound effects while rising or descending. Crucially, if a specific switch is activated (typically through dungeon progression), the platform becomes a shortcut elevator that skips the middle point and ascends directly to the top. This shortcut behavior is triggered only when params < 0x40, which is assumed to represent valid switch flag usage; if this condition isn’t met, the shortcut will not initialize properly. This implementation uses a faster Y-axis movement speed (SHORTCUT_Y_SPEED) and also triggers a cutscene camera effect when the shortcut is activated.

The Bg_Haka_Ship actor controls the iconic Shadow Temple Ship sequence. This dynamic background actor has two variants: the main rideable ship and a smaller attached child actor that follows its position. Initially stationary, the ship waits for the player to activate a specific switch using Zelda's Lullaby. Once triggered, it enters a cutscene state and begins rocking before slowly moving forward, simulating a ghostly journey through the depths of the temple. During this ride, it plays ambient bell sounds and gradually accelerates until it reaches a scripted crash point. At that moment, the ship violently shakes and collapses, killing both itself and its child actor. If the player is still on board during the fall, they are voided out to prevent breaking the sequence. The actor uses DynaPoly for collision, timed counters for animation syncing, and SFX cues to enhance immersion. Overall, Bg_Haka_Ship serves as both a storytelling and gameplay mechanic that enhances the eerie atmosphere of the Shadow Temple.

Obj_Mure2 is a dynamic spawner actor used to create groups of objects like bushes (En_Kusa) or rocks (En_Ishi) in either circular or scattered formations. When the player comes within range, the actor spawns its child actors in predetermined positions relative to its own, giving the illusion of environmental clutter. The child actors persist until they are interacted with or collected, after which they are removed from memory. The actor can also detect when a spawned child has been destroyed or picked up, updating its internal state to avoid respawning it. This system allows for flexible environmental population without permanently keeping every object loaded, optimizing performance.

The Bg_Jya_Goroiwa actor is a rolling boulder used primarily in the Shadow Temple and Spirit Temple, designed to move along a preset horizontal path while dealing damage to the player upon contact. It starts by initializing a joint sphere collider for collision detection and setting its shape, shadow, and rotation parameters. Its movement speed is dynamically calculated based on its Y position, simulating a slope effect, and the actor adjusts its rotation to match the movement. When it hits the player, it triggers a knockback and temporarily slows down while bouncing slightly with a vertical offset before resetting. The boulder reverses direction when reaching specific X boundaries and emits a rumbling sound during motion. After hitting the player or reaching a wait state, it pauses for a short duration before resuming movement. The actor handles its own collision updates and floor detection, and visually renders using a display list of the large rock model. Its behavior loop balances predictable movement with reactive physics for engaging obstacle design.

The En_Goroiwa actor represents rolling boulders commonly found in areas like Goron City, Death Mountain Trail, and the Fire Temple. These boulders either follow a looping path along predetermined splines or fall from above to crush the player. The actor calculates gravity, collision response, and rolling direction based on its type and current state. Rolling boulders continuously follow a set course, respawning when destroyed or offscreen, while falling rocks wait in place until triggered (often by proximity or timer), then fall, bounce, and eventually reset. The actor features dynamic physics including rotation, bounce scaling, and visual effects like dust clouds on impact, making it a versatile environmental hazard.

The Obj_Roomtimer actor is responsible for starting Timer 1 in a room, commonly used in time-based puzzles or challenges. When the actor initializes, it reads a timer duration from its parameters and clamps it to a maximum of 600 seconds if not set to the special value 0x3FF (which disables the timer). Once active, it sets the countdown and monitors room progress. If the player clears the room before time runs out, the actor stops the timer, sets a temporary clear flag, activates a switch, plays a success chime, and removes itself. If the timer reaches zero without the room being cleared, it triggers the void-out sequence, simulating a failure condition such as falling or running out of time.

The Bg_Jya_Cobra actor is an animated environmental object representing a large snake-head statue, commonly used in temple settings to enhance atmosphere or signal puzzle mechanics. It operates by rotating or sweeping in a programmed motion, often tied to a predefined path or internal animation loop. The cobra head does not interact directly with the player through collisions or damage but is designed to visually convey the operation of ancient machinery or magical influence. Its smooth, repetitive motion is driven by trigonometric functions and internal timers, and it may include sound effects to reinforce its heavy, mechanical feel. The actor adds cinematic or thematic weight to temple scenes, often placed in areas where it draws attention or accentuates a key part of a puzzle or room layout.

The Bg_Mori_Kaitenkabe actor handles the rotating wall in the basement of the Forest Temple. This mechanic is used during a puzzle sequence where Link must push a wall to reveal different rooms. The wall is represented as a dynamic actor that rotates 45 degrees when Link interacts with it.

Upon initialization, the actor sets up its collision and waits for the required texture to load. Once loaded, it transitions to a waiting state where it checks for player interaction. If Link pushes the wall for more than 28 frames and isn’t in a cutscene, the wall begins to rotate. The direction of rotation is determined by calculating the cross product between the push direction and the lever arm (from wall center to Link). This allows the wall to rotate in the correct direction relative to Link's push.

The rotation smoothly interpolates using Math_StepToF, gradually increasing rotation speed and angle until the wall reaches 45 degrees, at which point it stops and resets its state. During this process, sound effects for wall sliding and stopping play to enhance the experience, and Link’s position is locked to prevent clipping. This entire system adds depth to dungeon navigation and creates a memorable moment in the Forest Temple’s design.

The Bg_Ydan_Maruta actor represents two trap-related elements in the Deku Tree dungeon: the rolling spike log and the falling ladder. When placed with parameter 0, it becomes the rotating log that swings back and forth and can knock Link back upon collision. It uses a triangle collider to detect hits and plays a wooden rolling sound effect as it spins. When parameter 1 is set, the actor becomes the falling ladder that drops down after being hit by a slingshot or similar attack. The ladder only falls once per save file, tied to a switch flag, and includes cutscene and camera behavior for dramatic effect. It also slides forward slightly before falling, mimicking a physical release.

The Bg_Menkuri_Kaiten actor is a large, rotating stone ring platform used in areas like the Gerudo Training Grounds and Forest Temple in Ocarina of Time. This platform rotates when the player stands on it—unless a corresponding switch flag has been triggered. It initializes with collision data and is registered as a dynamic background actor that transforms around the Y-axis. In its Update function, the platform continuously rotates by 0x80 (about 1.4 degrees) per frame while the player is detected above it and the rotation switch is off, accompanied by a mechanical sound effect. The draw function renders the ring using a display list, ensuring it appears as a solid, animated structure in the game world.

The Obj_Mure3 actor is a background object responsible for spawning a "tower of rupees" — an arrangement of collectible rupees that appear in different patterns depending on its parameters. Upon initialization, the actor checks a specific switch flag to determine whether its rupees have already been collected. If the flag is set, it removes itself. Otherwise, it remains dormant until the player gets close enough. Once within range, the actor becomes active and spawns rupees in one of several formations: a vertical tower, a curved line, or a circular layout. Each rupee is tracked individually, and if collected or despawned, it’s flagged internally to prevent reappearance. When all rupees have been collected, the actor sets a switch flag to mark completion and returns to its dormant state until the player moves away, at which point it cleans up and resets for future encounters. This actor is used to reward players for exploration or puzzle-solving with a burst of colorful, satisfying loot.

The Bg_Spot05_Soko actor manages special movable or conditional geometry in the Sacred Forest Meadow, including stone blocks that are tied to specific story progression or puzzles. It exists in two variants depending on its parameters: one is present only when Link is a child and represents a static piece of collision, while the other responds to switch flags and represents a metal gate that sinks into the ground when triggered. This actor supports dynamic collision, plays a metal-closing sound effect when activated, and smoothly animates downward over time to simulate a mechanical door lowering. It's also capable of triggering a one-point cutscene to draw the player's attention during the action.

The Bg_Haka_Trap actor manages a wide variety of traps and mechanical hazards within the Shadow Temple and related areas. This highly modular actor supports multiple trap types, including the swinging guillotines, spiked walls, crushing boxes, and the large wind propeller. Each variant uses different models, collider setups, and behavior logic, but they all share the goal of creating environmental threats to challenge the player.

When initialized, the actor reads its type from its parameters and configures itself accordingly. For example, the guillotine traps use vertical motion and a timed loop to fall and rise, dealing damage to the player if they’re hit by the blade. These traps utilize a cylindrical collider that tracks the player’s position and moves to match it horizontally, ensuring that contact is accurately registered during their downward motion.

Spiked walls behave like moving barriers that advance towards the player. They’re equipped with both a cylinder and a triangle mesh collider to detect impact on different parts of the wall. When triggered, they create a crushing effect that can pin the player, complete with visual effects like debris bursts and sound cues for added drama. If both spiked walls close in at once, the game forcibly ends the player’s movement to simulate a trap sequence.

Spiked boxes act as crushing ceilings. They alternate between rising and slamming down, creating a timing-based hazard. The actor checks for floor collision to determine when it should stop descending and switch to rising again. If the player is beneath the box during a drop, they risk taking damage or being crushed.

The propeller trap spins in place, using its rotation to generate wind-like force that pushes the player backwards unless they wear Iron Boots. This mechanic adds a movement puzzle where the player must either time their progress or use specific equipment to move forward safely.

The Bg_Haka_Trap actor is a masterclass in reusing code logic for diverse mechanical behaviors. It leverages physics, timers, collision detection, sound, and particle systems to bring each trap to life, ensuring the Shadow Temple maintains its reputation for eerie, trap-filled challenges.

The En_Tana actor represents the decorative shop shelves found in shop interiors throughout Ocarina of Time. While this actor has no interactivity or behavior logic, it serves an important visual role by displaying either wooden or stone shelves to match the shop’s aesthetic. The actor uses its params value to determine which type of shelf to render — wooden (type 0) or one of two stone variants (types 1 and 2). Each shelf type has its own display list and, in the case of the stone shelves, a specific texture is applied using the segment register. The actor’s Init function assigns the appropriate draw function based on the params, disables the attention flag, and sets the model scale to 1.0. Notably, there is a debug print for the shelf type name, though an array bounds bug exists if params is set to an invalid value. As a static prop, En_Tana is a clean and efficient implementation of a purely visual environment actor.

The z_door_shutter.c actor controls various types of shutter-style doors, which are designed to block or unlock player progression based on in-game events or triggers. These include doors that close behind Link when entering a room, doors that require all enemies to be defeated before opening, or doors that unlock upon triggering a switch. The actor reads bitwise-encoded parameters to determine its behavior, such as whether it lifts, slides, or remains locked from one side. Some variations include Phantom Ganon bars, Boss doors, and puzzle doors linked to switch flags or room-clear conditions. Upon initialization, the actor checks the relevant scene and game flags to determine if it should appear, stay locked, or be removed. It also includes collision and animation handling for smooth door transitions and integrates sound effects for added feedback. Overall, Door_Shutter plays a key role in dungeon flow control and puzzle mechanics, often signaling challenge, progress, or reward.

The Bg_Jya_Block actor represents the Silver Push Block found in the Spirit Temple, specifically designed for Child Link. This block is a part of the dungeon’s puzzle mechanics, requiring the player to push or pull it to progress or trigger certain switches. The actor only initializes and appears if the player is currently Child Link and a specific switch flag is set — otherwise, it immediately removes itself from the scene. The block includes a collision header, allowing it to interact with the game world and respond to player actions like movement or pressure plate triggers. Visually, it uses a silver-gray texture and custom display list, with subtle environment coloring for a distinct aesthetic. Though its update function is minimal, it still clears a specific player state flag each frame, likely related to pushing behavior. This actor is a classic example of dungeon interaction, providing environmental depth and requiring critical thinking and strength-based mechanics unique to Child Link’s dungeon experience.

The En_G_Switch actor (z_en_g_switch.c) handles a variety of collectible and interactive gameplay elements, including Silver Rupees, moving or stationary rupee targets for shooting galleries, and destructible pots used in horseback archery minigames. Each variant of the actor responds to different types of interactions: Silver Rupees contribute to puzzle completion by tracking the number collected, gallery rupees move or respond to hits during timed shooting events, and archery pots break with satisfying effects when struck by arrows. The actor uses multiple states and subfunctions to manage its behaviors, including collision detection, custom effects on collection or destruction, and conditional spawning based on game progress. It also integrates custom audio cues and dynamic visual feedback like particle effects, broken pot fragments, and animated rupee textures. With modular draw functions and structured initialization based on parameter types, this actor is a multifunctional system that enhances collectible, skill-based, and visual gameplay throughout various mini-challenges and rooms in the game.

The Bg_Gnd_Firemeiro actor is a dynamic sinking platform used during the Fire Trial in Ganon’s Castle. When Link steps on it, the platform begins to shake violently, simulating instability with randomized movement, sound effects, and a brief delay. After shaking for a short period, the platform slowly sinks into the lava, forcing the player to move quickly or risk falling. Once Link jumps off or the timer expires, the platform begins to rise back to its original height, resetting the cycle. This actor creates a tense environmental hazard, adding urgency and danger to the trial through interactive motion and timed response.

The Obj_Makekinsuta actor is responsible for spawning a Gold Skulltula from a bean patch after it has fully grown. This actor monitors the environment and waits for the right conditions to trigger the appearance of the Skulltula enemy. Specifically, it checks a hidden flag (unk_152) to determine if the bean plant has been interacted with, and then starts a countdown timer. If at least 60 frames pass and the player is not currently interacting with anything (func_8002DEEC), the actor spawns a Gold Skulltula (ACTOR_EN_SW) at its location. After spawning the enemy, it switches to a no-op function to prevent repeated activations. This actor has no visual model or collision and simply serves as a logic controller to time and conditionally trigger enemy appearances, adding surprise and reward elements to exploration and gardening mechanics.

The Bg_Hidan_Sima actor is a stone platform used in the Fire Temple, with two variations depending on its params value. When params is 0, it acts as a reactive platform that shakes and drops slightly when the player steps on it. The platform briefly wobbles from side to side, accompanied by sound and rumble effects, before lowering a short distance. Once the player steps off, it resets to its original height and awaits another interaction. When params is 1, the platform serves as a rotating fire trap. It periodically turns 180 degrees and emits a stream of animated fireballs along its path, dealing damage to anything in their way. The fireballs are rendered using scaling animated textures and follow the platform’s rotation using trigonometric calculations. Collision spheres are updated in real-time to match the movement of the flames, allowing the platform to damage the player during its active phase. This variation emphasizes timing and hazard avoidance, adding a layer of difficulty and visual flair to the Fire Temple's environment.

The Bg_Jya_Amishutter actor represents a circular metal grate in the Spirit Temple. When the player approaches within a short distance, the grate lifts vertically to allow passage. After the player moves far enough away, the grate automatically lowers back into its original position. The movement is accompanied by metallic sliding sound effects for added realism. The actor is implemented as a dynamic polygon object that interacts with the player and the collision system.

The Bg_Spot18_Shutter actor controls the stone doors and shutters in Goron City. These heavy doors block access to key areas like Darunia’s room or the back of the city and are controlled by in-game events such as switches or story progression flags. The actor can be one of two types: a vertically moving shutter (param 0) or a sliding stone door (param 1), with behavior differing for child and adult Link.

On initialization, the actor checks the player's age and relevant game flags (INFTABLE_109 or switch flags) to determine if the door should already be open. If not, it waits for a trigger. When triggered, it plays a cutscene (or sets camera focus), then begins its smooth motion: vertical shutters rise by 180 units, while sliding doors shift 125 units along their facing direction. Motion is interpolated using Math_StepToF() to create a gradual, smooth animation. Sound effects for stone grinding and stopping enhance the realism of the movement. Once the movement completes, the door becomes static again.

Collision is managed via DynaPoly, allowing the door to physically block the player and be dynamically disabled when the door moves. Visually, the actor draws the gGoronCityDoorDL model. Overall, this actor creates a dynamic and context-sensitive gating mechanic, contributing to the layered puzzles and age-dependent progression within Goron City.

The Bg_Hidan_Kousi actor represents the heavy metal grates found in the Fire Temple, which slide open when triggered by switches. It supports three distinct models—standard, reinforced, and slanted—based on the actor's parameters. On initialization, it sets its rotation and collision based on configuration and checks for a switch flag that may cause it to spawn in an already-open state. When the linked switch is activated, the grate enters a multi-phase animation: it triggers a cutscene attention focus, begins to slide, and stops when reaching a predefined distance. The movement is directional, calculated using trigonometric functions based on the actor's rotation. Sound effects for sliding and halting metal reinforce the animation, creating an atmospheric dungeon element that reacts dynamically to player progression.

The Bg_Jya_Zurerukabe actor represents a sliding, climbable brick wall that moves back and forth in a fixed pattern, commonly seen in dungeon puzzles. Upon initialization, it determines which of the four preset movement tracks it belongs to by comparing its Y position to predefined values. Once matched, it sets up a direction and range for horizontal sliding motion. Its movement alternates between waiting and sliding phases, stepping through a sequence of positions based on its current index and movement direction. The actor also contains logic to knock the player off if they are climbing the wall and the wall shifts significantly while they are attached. The knockback behavior only applies to certain vertical zones on the wall and only if movement between adjacent sections is fast enough. A dynamic collider is used so the player can climb and interact with it physically as it moves, and the wall makes an elevator-like sound as it slides.

The Obj_Kibako actor represents a small wooden box, which players can pick up, throw, or break to reveal hidden items. When initialized, it sets up a cylindrical collider for interaction and applies gravity so it can fall naturally in the game world. The box can enter different states: idle on the ground, being carried, or flying through the air after being thrown. If the player attacks the box, throws it against a wall, or drops it in deep enough water, the box breaks into fragments using the EffectSsKakera system. Upon breaking, it may spawn a collectible item (like rupees or hearts), determined by parameters encoded in the actor's params. The actor includes logic to prevent interactions until the player is close enough, and it can only be picked up when within a short distance. Special care is taken to trigger different breaking effects based on whether the box is destroyed in air or underwater. This actor showcases a modular and responsive design for destructible environment objects in Zelda 64.

The Bg_Spot17_Funen actor represents the cone-shaped volcanic smoke plume that continuously rises from the crater of Death Mountain. It’s a purely visual environmental effect with no physical interaction or gameplay functionality but plays a crucial role in enhancing the atmosphere of the area by simulating volcanic activity.

Upon initialization, the actor sets its scale using a predefined chain and logs its creation with a debug message identifying it as “噴煙” (volcanic smoke). The actor's update function sets its custom draw and update routines (func_808B7478 and func_808B746C, respectively). Interestingly, func_808B746C does nothing — this indicates the actor doesn’t have dynamic logic beyond being drawn each frame.

The draw function, func_808B7478, sets up translucent rendering with a dual texture scroll effect to simulate moving smoke. It rotates the smoke cone to always face the camera (a billboard effect), making the illusion more convincing from any angle. The cone itself is rendered using the gCraterSmokeConeDL display list from the object_spot17_obj asset file.

The Obj_Timeblock actor controls the Song of Time blocks in The Legend of Zelda: Ocarina of Time, which appear or disappear when Link plays the Song of Time. These magical blocks serve as dynamic platforms or barriers and are often used in puzzles and navigation challenges. The actor initializes with collision detection and appearance parameters based on its size and specific flags stored in its params field. It constantly checks if the player is in range and prompts for ocarina interaction. When the correct song is played, it toggles visibility and collision based on internal logic and the current game state, sometimes tied to switch flags or Link’s age (child or adult). The block can behave in two major modes: normal (basic toggle) and alternate (with visibility tied to switches). When changing states, the block triggers sound effects and visual demo effects to signify its magical transformation. This actor ensures the Song of Time mechanic is integrated seamlessly into gameplay with flexible configurations for different dungeons and challenges.

The Spinning Scythe Trap is a rotating hazard found in areas like the Shadow Temple and Ice Cavern. Upon initialization, the actor sets up collision detection using a cylindrical collider at its center and two triangle-based colliders to represent the blades. It also initializes two blur trail effects, one for each spinning scythe blade, using color parameters that give a ghostly white-to-gray fade.

There are three visual variants based on the scene: a visible version for the Shadow Temple, an invisible version revealed only by the Lens of Truth, and a smaller variant used in the Ice Cavern. Depending on its variant, the actor loads the corresponding object (either object_haka_objects or object_ice_objects) and uses different display lists for drawing.

Once initialized, the trap enters its spinning behavior. The scythe rotates in place, modulating its speed slightly with a sine wave function for a more natural acceleration-deceleration pattern. During each frame, the positions of the rotating scythe’s blade tips are recalculated and used both for collision detection and for generating a visual blur effect using the preconfigured blur trails. If Link comes into contact with the triangle colliders representing the blades, it triggers damage as expected. Meanwhile, the center cylinder collider allows the player to bump into the trap’s body.

The actor uses different logic depending on whether it’s visible or invisible, and only draws the blur and geometry if it is either inherently visible or revealed via the Lens of Truth. It emits a mechanical spinning sound effect (NA_SE_EV_ROLLCUTTER_MOTOR) as it rotates, contributing to the eerie atmosphere of the dungeons where it's placed.

The `Bg_Hidan_Rsekizou` actor defines the spinning stone flamethrower found in the Fire Temple. This rotating hazard continuously emits fireballs in a radial pattern, dealing damage through a ring of six collider spheres that are positioned dynamically each frame based on rotation. The actor animates fireball textures from a sequence and emits alternating streams of translucent fire effects using matrix transformations for realistic movement. In addition to visual and collision updates, it emits a looping flame sound. With precise timing and damage zones, it challenges the player to navigate moving platforms or puzzles while avoiding continuous fire arcs.

The Obj_Lift actor is a square, collapsible platform found in dungeons. When Link steps on it, the platform waits for a short countdown based on its parameters. If Link remains on the platform, it begins shaking violently to signal impending collapse. After the shaking sequence, the platform detaches and falls down using gravity simulation. Upon hitting the ground or reaching its maximum fall distance, the platform shatters into fragments and plays a crumbling sound. The actor then sets a switch flag to mark its destruction and deletes itself from the game world. This interactive destruction effect is enhanced by screen quake, dynamic rotation, and randomized fragment debris.

The En_Kanban actor represents the wooden signposts scattered across Hyrule that players can read and break. When approached, the sign displays a message box with text depending on its params index. If struck by a sword or similar attack, the sign breaks into falling wooden fragments using a cut system that divides the sign into parts. The actor tracks interactions with the player for displaying messages and ensures it can only be cut once. After being cut, the broken pieces fall realistically and eventually despawn.

The Bg_Hidan_Sekizou actor represents a stationary flamethrower statue found in the Fire Temple. It comes in two forms: a short version that constantly shoots twin flames to the sides and a tall version that detects the player's alignment and blasts fire directly in their direction. The actor utilizes six joint-sphere colliders to simulate the flame's damaging hitboxes and periodically updates their world positions for accuracy. The flame visuals animate dynamically with layered textures, and the direction of the flame adapts based on player proximity and facing angle. Sound effects and camera feedback reinforce the hazard’s presence, making it a classic environmental trap.

Bg_Jya_Megami represents the stone face of the Goddess Statue in the Spirit Temple, featured prominently in the mirrored room puzzle. Initially, the statue’s face is intact and reacts to sustained light from the Mirror Shield. As light hits the statue, it begins to crack and crumble over time, displaying visual degradation. After enough exposure, a dramatic explosion sequence is triggered: the statue's face breaks into multiple pieces with sound effects and particle effects to enhance the destruction. This action also triggers a switch flag and causes the actor to despawn after the sequence completes. The breaking sequence is animated with rotating debris and physical motion for each piece, all driven by pre-defined vectors and velocities.

The Bg_Spot01_Idosoko actor represents the large stone that blocks the entrance to the Bottom of the Well in Kakariko Village. This is a static background object that uses a collision mesh and draw function to appear as a solid rock slab. It is part of the world geometry and doesn't have interactive behavior beyond its presence. Its primary role is to visually and physically block access to the dungeon. The actor initializes and loads its collision model, but self-deletes if the player is a child, ensuring it's only present during the adult portion of the game.

The Bg_Hidan_Rock actor controls the large stone blocks found in the Fire Temple, which serve as both moving platforms and environmental hazards. There are two block types: one that slides along the floor when pushed, eventually locking into place and activating a switch (type == 0), and another that reacts to player interaction by vibrating and rising temporarily before dropping. The actor uses a variety of functions to handle player-induced motion, timed platform behavior, sound effects (like rumbling and impact), and dynamic camera transitions. It also draws animated vertical flames using translucent display lists when the block is active. With logic for physics updates, collision checking, and interactive behavior, Bg_Hidan_Rock is essential to Fire Temple puzzles requiring spatial reasoning and timed movement.

En_Pu_Box is an unused actor representing a movable stone block that behaves like a physics-enabled cube. Although not placed in the final game, it was likely intended for use as a pushable or gravity-affected object, similar to other stone blocks found in dungeons. It supports variable sizes through its parameters, applies gravity, and responds to sliding motion with appropriate sound effects. The cube is collision-enabled via DynaPoly, and its position and rotation are updated using standard physics movement functions. Its presence in the game code hints at either cut dungeon mechanics or general-purpose block puzzles that were later discarded or replaced.

The Bg_Hidan_Syoku actor is the stone elevator platform located in the Fire Temple, notably used during the Flare Dancer mini-boss encounter. It starts raised and lowers once the room is cleared and the player steps onto it. The elevator smoothly animates up and down using a cosine function over 140 frames and includes sound effects during movement (NA_SE_EV_ELEVATOR_MOVE3) and at rest (NA_SE_EV_BLOCK_BOUND). Between cycles, it pauses for 60 frames before reversing direction. Additionally, the camera dynamically switches to an elevator view (CAM_SET_ELEVATOR_PLATFORM) while the player is on the platform.

The Bg_Jya_1flift actor controls the shortcut elevator located in the Spirit Temple. This dynamic platform begins in one of two fixed vertical positions and moves up or down when a specific switch is activated. It smoothly accelerates and decelerates between levels, pausing briefly before reversing direction. The actor uses collision detection to register if the player is standing on it and will temporarily change the camera setting to better follow the elevator’s movement. It only exists in the first and sixth rooms of the temple to ensure it's only active when needed.

The En_Honotrap actor (z_en_honotrap.c) in Ocarina of Time is a trap system used to create two deceptive or dangerous environmental elements: fake eye switches and ghostly flame projectiles like those seen in Dampe’s grave. The fake eye switches lure players into shooting them, only to retaliate by launching a tracking fireball. These switches animate through a sequence of eye states (closed, opening, attacking, shutting) and spawn a moving flame actor when the player gets close. The flame actors can behave in several ways: dropping straight down, homing toward Link, bouncing off shields, or vanishing on collision. The actor uses different collider setups—triangular for the fake eye switch and cylindrical for flames—and employs complex logic for movement, targeting, collision response, and rendering effects like texture scrolling and environmental color modulation. Through a combination of visual deception and dynamic threat, En_Honotrap enhances dungeon and graveyard encounters with traps that require awareness, timing, and spatial reasoning to overcome.

The Obj_Hsblock actor is a stone platform designed to serve as a Hookshot target in dungeons and other areas. Depending on its type, it can either remain static or dynamically rise into place when a switch is activated. It uses different models and collision data to represent hookshot posts or targets. Upon initialization, the actor checks its parameters to determine its visual model and interaction type. If set to rise, the block starts hidden below the floor and waits for its associated switch flag to be triggered. When activated, it ascends smoothly to its designated position and locks in place. It can optionally spawn an ice overlay effect when configured to do so.

The Bg_Ddan_Kd actor represents the falling staircase mechanism in Dodongo’s Cavern. This environmental object responds to bomb explosions by checking for explosive collisions using a cylindrical collider. When a valid explosive is detected and confirmed to be different from the previous one, the actor triggers a one-point cutscene and begins to lower the staircase using smooth vertical motion and incremental speed. The descent includes synchronized effects like rumble feedback, camera quakes, dust generation, and falling debris to simulate the heavy stone impact. Once the stairs reach their final position, a switch flag is set to indicate the puzzle is solved. On subsequent visits, if the switch flag is active, the stairs are already lowered and the actor enters an idle state. This setup prevents the sequence from repeating and ensures consistent dungeon state tracking.

The Bg_Hidan_Hamstep actor handles the dynamic stone platforms that rise in sequence when hit with the Megaton Hammer. These actors represent both the initial hammer switch and the subsequent stepping stones that rise progressively higher when triggered. When the player strikes the initial stone platform, a chain reaction begins: camera cutscenes, rumble feedback, and quake effects simulate the platforms forcefully rising from lava. Each step responds with a bounce animation before locking into place. The actor includes collision management, impact response, particle effect spawning, and parent-child coordination between each platform to ensure they animate in proper order and maintain consistent vertical spacing. This dramatic sequence is crucial for traversing a lava pit, symbolizing player progress and strength in the Fire Temple.

The Obj_Lightswitch actor is a dynamic switch used primarily in the Spirit Temple that responds to light-based interactions. It features a rotating flame ring and expressive face textures that visually change as the switch activates. When triggered, it can play sound effects, change appearance, activate a switch flag, and in some cases, self-destruct. The switch supports multiple behavior types, including permanent activation, toggling, holding state while targeted, or disappearing once activated. One variant also spawns on top of a push/pull block and tracks its position. These features make it suitable for puzzles requiring timed or light-based solutions.

The Obj_Switch actor is a versatile trigger object used throughout the game to control puzzles, doors, and timed events. This actor comes in multiple types, including floor switches, eye switches, crystal switches, and rusted switches, with behavior determined by the lower bits of the params field. Each type responds to specific actions: floor switches are activated by standing or placing weight on them, eye switches by arrows or hookshots, crystal switches by sword strikes or explosions, and rusted switches by the Megaton Hammer. Once activated, the switch can toggle a switch flag on or off, remain pressed, or return to its original state after a delay. Some switches can be stepped on repeatedly, while others require being struck from a distance.

Visually, the actor uses animated materials and effects to show its activation state, including glowing textures, pulsing overlays, or changing shapes. Sound effects accompany both activation and deactivation. In the case of floor or rusted switches, the actor uses collision detection to sense the player, objects, or enemies applying pressure. Eye and crystal switches, on the other hand, rely on hit detection against damage types. Some switches can be configured to play a success chime or activate cutscenes when triggered. Switch state can persist across reloads if tied to a permanent switch flag.

The Bg_Bdan_Switch actor controls the organic-looking switches found inside Lord Jabu-Jabu in Ocarina of Time. These switches come in different types—blue, yellow, heavy yellow, and tall yellow—and each has unique behavior depending on player interaction. Blue and yellow switches respond to pressure: some toggle on and off when stepped on, while others require objects like boxes or Ruto to activate. Tall switches can also be triggered by projectiles or physical hits. The actor manages collision, animation, switch flags, and visual scaling for the pulsating organic design. It also handles SFX cues and camera cutscenes when activated, enhancing the dungeon’s interactive and biological theme.

The Obj_Syokudai actor in Ocarina of Time represents torches that can be lit or extinguished depending on in-game events and interactions. There are three types—permanent, timed, and puzzle-related—determined by parameters that control behavior like whether the flame stays lit indefinitely or needs to be relit under a time limit. The actor uses two colliders: one for the torch stand and another for detecting flame-based interactions (e.g., contact with a lit Deku Stick or a Fire Arrow). Lighting a torch can trigger switches or progress puzzle sequences, with multi-torch setups tracking the total number of lit torches. The actor handles dynamic lighting, environmental effects, and visual flame rendering using a textured animated flame and dynamic light nodes. It also plays appropriate sound effects and adjusts light intensity based on the flame's state. This makes Obj_Syokudai a key environmental and puzzle element that enhances both gameplay mechanics and atmospheric immersion.

The z_en_box.c file defines the En_Box actor, which handles treasure chests in The Legend of Zelda: Ocarina of Time. This versatile actor supports a wide range of chest behaviors, from always-visible small chests to large, dramatic ones that fall from the ceiling or appear after puzzle completion. The chest’s behavior is controlled primarily through actor parameters, allowing map designers to control when and how a chest appears, opens, and what it contains.

Type: Defines how and when the chest appears or behaves.

Switch Flag: Determines the chest’s interaction with in-game switches. For “appear on switch” or “fall on switch” types, this value tells the chest which switch ID it listens to before becoming active.

Chest Flag: Links the chest to a flag in save data. Once the chest is opened, this flag is set so it doesn’t respawn the next time the player enters the room. It's also used to decide whether to auto-open the chest on scene load.

Chest Content: Determines the item inside the chest. This maps to the item-giving system, using a negative value passed to Actor_OfferGetItemNearby() to spawn the correct prize (e.g., rupees, key, heart piece, etc.).

This actor represents the magical glowing effect that rises from treasure chests when they are opened in certain cutscenes. It uses skeletal curve animation (SkelCurve) to animate a transparent, swirling effect that moves upward as the chest lid opens. Upon initialization, the actor loads the appropriate animation depending on whether the player is child or adult, and sets its transparency values (unk_170 and unk_174) to fully opaque. It remains in a waiting state until it detects the treasure chest lid has reached frame 10 of its opening animation, at which point it starts animating. The animation gradually fades out different parts of the glow by interpolating the alpha values based on the animation's progress. Around frame 30, a flashing sound effect is played to coincide with the visual burst. Once the animation completes, the actor destroys itself. Visually, the draw function renders the animated limbs with a shimmering scroll texture and dynamic colors that fade over time, giving the illusion of magical energy escaping the chest.

En_Wood02 is a versatile actor responsible for rendering and managing trees, bushes, and falling leaves across Hyrule. It supports dynamic spawning logic to populate large outdoor areas like Hyrule Field without overwhelming system memory. Trees and bushes can appear in clusters, with spawners activating nearby vegetation based on the player’s proximity and camera frustum. This actor also manages collision with trees and rustling bushes, allowing randomized item drops and visual effects such as wobble animations and falling leaves. The leaf subtypes behave as lightweight visual actors that drift and fade after a set lifespan, enhancing environmental immersion.

The Bg_Haka_Gate actor is a multi-functional puzzle component used in the Shadow Temple’s "Skull of Truth" spinner puzzle. Depending on its params value, it controls different objects: the rotating statue, the floor trap, the gate, and the flaming skulls. The central mechanic involves rotating a statue to face one of several skull torches—only one of which is the real "Skull of Truth." If the statue is correctly rotated and the player steps away, the puzzle checks if the skull aligns with the predetermined solution. A correct match opens the gate and ends the puzzle, while a wrong guess triggers a trapdoor beneath the player. The skull flames include a visual lens of truth interaction, with the real skull distinguished only by using the Lens of Truth. The actor manages dynamic interactions, switch flags, cutscenes, and visual effects like spinning flames and animated gates, using shared static variables to ensure puzzle consistency. This actor showcases complex interactivity, conditional logic, and integrated cutscene handling within the dungeon environment.

The Bg_Mori_Hineri actor controls the iconic twisting hallway and adjacent room in the Forest Temple. It dynamically swaps geometry and collision to simulate the hallway twisting based on switch flags, providing a dramatic visual and gameplay effect. The actor manages multiple versions of the hallway (straight or twisted) and coordinates between object sets for each variant. It integrates with camera cutscenes to enhance the transition, spawns a special boss key chest when untwisting occurs, and even renders a rotating door and chest lid if appropriate object data is loaded. The twisting animation is simulated by rotating the hallway’s geometry as the player approaches, creating one of the most memorable moments in the dungeon.

The Obj_Hana actor represents a variety of small environmental decorations found primarily in graveyard or field areas, such as a grave flower, a rock fragment, and a bush. These objects are visually simple but use scalable geometry and, in some cases, cylindrical collision to interact with the player. Each object type is determined by parameters passed on spawn, which select different models, sizes, and behaviors. For example, the bush type includes collision and despawns if a specific story event has occurred. The actor updates its collider only when the player is within range to optimize performance.

The Bg_Ice_Shutter actor represents the vertical sliding ice bar doors found in the Ice Cavern in The Legend of Zelda: Ocarina of Time. These translucent gates block progression until certain conditions are met, functioning as room-based or switch-based barriers. Depending on the parameters passed at initialization, an ice shutter can either block access until a room is cleared of enemies (room-clear shutter) or until a specific switch is activated (switch-triggered shutter).

When initialized, the actor determines its behavior by decoding parameters that specify its type and switch ID. If it's a room-clear shutter and the room has already been marked clear, it deletes itself immediately. Otherwise, it waits until the temporary room clear flag is set—usually after defeating all enemies—before triggering its opening sequence. For switch-based shutters, it monitors the linked switch and begins to open once it is triggered.

The opening animation is handled with trigonometric calculations that simulate the bars sliding up or rotating away based on the shutter's orientation. During the transition, a sliding sound effect is played to enhance immersion. Once the shutter has moved a certain distance, it is removed from the scene.

This actor uses the DynaPoly system for collision handling and environmental interaction, and it is registered with a static collision model. The shutter can rotate and move in three-dimensional space, allowing it to accommodate varied architectural placements in the Ice Cavern.

The DoorWarp1 actor handles all major warp portals and warp crystal events that occur after dungeon completions and during key cutscenes. It controls the behavior of blue and purple warp crystals, child and adult dungeon warps, and various color-coded destination warps used in temple scenes. The actor uses a modular state machine to manage different actions such as appearing, warping in or out, playing cutscenes, and deactivating after use. It integrates closely with the cutscene system, triggering specific sequences, item rewards, and transitions between locations. Visually, it creates dynamic effects like glowing light rays, animated warp portals, and crystal opacity changes using skeletal animations, matrix scaling, and segment-based coloring. It also manipulates environmental elements like fog and lighting and controls player movement, gravity, and positioning to ensure a smooth cinematic experience. With support for multiple variants and transition types, DoorWarp1 plays a critical role in storytelling and progression, guiding players through pivotal moments in the game.

The Bg_Mjin actor represents warp pads used for teleportation throughout the game, such as elemental warp pads and the Ocarina pedestal in the Temple of Time. It dynamically loads one of several object sets depending on its params value (e.g., fire, ice, shadow), ensuring the correct graphics and collision data are used. When initialized, it sets up its object dependency, applies the correct collision header, and registers itself with the dynamic polygon system. While the warp pad doesn't include active behavior itself, it serves as a visually distinct and interactable location, often used in cutscenes or warping mechanics. Its visual appearance and rendering setup are determined by the loaded object segment and draw function.

The Bg_Mizu_Water actor manages the dynamic water level throughout the Water Temple, responding to specific switch flags (0x1C, 0x1D, and 0x1E) to raise or lower the water surface across multiple rooms. Upon initialization, it sets the water height based on active switches or defaults, and updates relevant water boxes in the collision context. The actor handles smooth transitions using Math_StepToF, triggers cutscenes and sound effects during level changes, and integrates with draw parameters to simulate visual fog effects at different depths. Variants of the actor also support localized water height changes in special rooms. As a key mechanism of dungeon progression, Bg_Mizu_Water ensures that puzzles and access routes change dynamically with each adjustment to the temple's water level.

The En_Siofuki actor represents dynamic water spouts that rise and fall in certain areas, primarily serving as timed environmental hazards or platforms. These water jets oscillate in height and apply physical force to the player when approached, potentially lifting or pushing them depending on proximity and direction. The actor uses sine wave movement for realistic animation, handles sound effects based on its current state, and can respond to in-game switches and treasure flags to change behavior or deactivate permanently. Its movement logic is defined by parameters that dictate whether it should raise, lower, or cycle between both actions.

The Bg_Mizu_Movebg actor is responsible for handling the Water Temple’s moving platforms and statues, including floating platforms that adjust with the water level, dragon statues that move vertically based on switch flags, and the rotating hookshot target platform. Depending on its params, it loads different display lists and collision headers and may optionally follow a path if it’s the hookshot platform variant. The actor checks switch flags to determine its position or movement behavior, uses Math_StepToF to move smoothly, and optionally spawns child actors like Obj_Hsblock for dragon statues. It includes dynamic texture scrolling and water-themed alpha blending to simulate the temple’s aquatic atmosphere. The platform also plays elevator or rolling sounds while in motion and includes custom segment setup for visual effects.

The En_Stream actor creates a water vortex that detects when the player is within a cylindrical region above it and then exerts suction forces that draw the player toward its center. Once caught in the vortex, the player is gradually pulled inward on the XZ-plane while also being pushed downward on the Y-axis. The vortex continues to influence the player’s movement until they escape or are fully drawn into the center, potentially triggering drowning or other scripted events. The visual effect of the vortex is animated through texture scrolling, and it plays a looping sound effect to reinforce its presence.

The Bg_Gnd_Soulmeiro actor is used in Ganon's Castle to manage several spiritual trial objects, including the web-blocked ceiling, the light beam source, and the illuminated floor. Its primary role is to handle the web covering the ceiling hole, which the player must destroy using light-based attacks. When the correct conditions are met—such as shining light into the room or triggering a switch—the actor initiates a sequence that plays an effect of the web burning away and then spawns a Mir_Ray actor to represent the beam of light. In its web-covered state, the actor uses a cylindrical collider to detect hits and only becomes destructible when the appropriate trial switch hasn't been activated. Additionally, other variants of this actor represent the light source and light floor, which are conditionally drawn based on the current state of the switches. The destruction animation includes randomized particle effects that mimic the web disintegrating into ash, enhancing the cinematic feel of the puzzle being solved.

The Bg_Ydan_Sp actor, which represents burnable spider webs found in the Deku Tree dungeon of The Legend of Zelda: Ocarina of Time. These webs serve as environmental obstacles and can be destroyed through specific player actions like burning with a Deku Stick or falling from a height. This actor enhances gameplay by creating interactive, destructible environmental puzzles that respond to fire and player movement.

Switch Flag (Set When Destroyed)
This value determines which switch flag is set after the web has been successfully destroyed. It ensures the web stays removed if the player re-enters the room.

Switch Flag (Burn Trigger)
This value defines the burn trigger switch that, if set elsewhere in the dungeon (e.g., via torches or other mechanics), causes the web to ignite automatically.

Web Type:
Web-Covered Hole – A horizontal web on the ground. Can be burned or broken by falling onto it from high up. When destroyed, it animates a tear and possibly reveals a pit or passage.
Vertical Web Wall – A web stretched across a vertical surface, usually over a door. Can be burned by touching it with a lit stick.
Special Floor Web – Like the basic floor web, but when burned, it displays a dramatic vertical flame column effect as it dissolves in reverse cone-like motion.

The Bg_Spot01_Idohashira actor represents the wooden beam structure above the well in Kakariko Village. This beam plays a key role in a story cutscene that explains how the well was sealed. During that cutscene, the beam spins and crashes into the well, triggering dust and spark effects. The actor is responsible for controlling this animation, handling timed effects, rotating the beam, and despawning itself at appropriate times depending on the player's progress. It uses a dynamic collision object and has multiple modes depending on whether it is in the main game or a cutscene layer.

The Bg_Spot01_Idomizu actor represents the animated water surface inside the well in Kakariko Village. This actor dynamically adjusts the water level based on the player’s progress in the story. If the well has been drained (via the Song of Storms event), the water level drops to a hidden position below the well. Otherwise, it stays at its normal height. The water also animates with a scrolling texture to simulate movement. This actor uses translucency and updates the waterbox’s surface height in the collision context so Link can swim in it if it's active.

The Bg_Relay_Objects actor in Ocarina of Time manages two key environmental setpieces: the rotating gear inside the Kakariko Village windmill and the stone slab doors in Dampé's grave-digging race. When functioning as the windmill gear, the actor causes the wooden mechanism to rotate continuously, with its speed determined by the game’s event flags—spinning faster after the “Song of Storms” sequence has been completed. It emits a creaking wood sound that varies with its speed and uses a static flag to prevent multiple instances from running simultaneously. In its other role, the actor handles the large stone doors that open and close throughout Dampé’s race. Each door responds to a corresponding switch flag and will rise when triggered, remain open for a brief timer duration, then slam shut with a rumble effect and stone impact sound. If the player isn’t in the correct room when the door closes, the game plays a ghostly laugh and forcibly respawns them at the beginning of the course. One specific door (the fifth) is open by default based on story progress. This dual-purpose actor is a strong example of how Ocarina of Time uses shared logic and switch flags to manage dynamic environmental storytelling and gameplay flow.

The Bg_Spot01_Fusya actor represents the rotating windmill sails in Kakariko Village in The Legend of Zelda: Ocarina of Time. It is a simple background actor that continuously spins its vertical blades on the Z-axis and plays the iconic windmill music as it rotates. The sail's rotation speed gradually increases over time, especially after a key story event involving the Song of Storms. The actor uses a minimal state machine with one primary update function to handle animation and sound, and it renders the windmill sails using a display list from object_spot01_objects.

The Bg_Toki_Hikari actor handles the light beam effects in the Temple of Time’s stained glass windows. It uses animated textures and additive blending to create shimmering light rays when Link is a child. A second mode triggers a dramatic energy pulse and light shaft animation during the Door of Time opening cutscene. This visual effect is tied to the game's story progression flags and fades out once the event completes, after which the actor removes itself. It’s a simple but iconic atmospheric element that enhances the magic of the Temple.

The En_Hata actor is a decorative wooden flagpole with a red cloth that waves dynamically in the wind. It uses skeletal animation and a flexible cloth system to simulate realistic wind behavior, reacting to both wind speed and direction set in the game’s environment context. The animation speed, joint rotations, and cloth sway are updated every frame based on randomized wind fluctuation values, making the flag appear to ripple naturally. The actor also includes dynamic collision using DynaPoly, allowing it to be part of the environment’s collision map. While it has collision data and limb override logic, it doesn’t interact with the player or other entities and serves purely as an environmental visual element.

The En_Horse_Link_Child actor represents Young Epona, the foal version of Epona featured during Link’s childhood. This actor is mainly used in scenes set at Lon Lon Ranch and during scripted cutscenes, particularly those involving Malon and the learning of Epona’s Song. Young Epona’s behavior is defined through several action states that dictate how she moves, reacts to the player, and interacts with events or music.

Upon initialization, the actor sets its skeleton, collision data, animation, and other parameters like gravity and scale. The animations are selected from a set of five: idle, whinny, walk, trot, and gallop. Depending on the context—such as whether a cutscene is active, if Malon has returned to the ranch, or if Epona’s Song has been played—the actor enters different action states. For example, in action state 3, she exhibits autonomous behavior that changes depending on Link’s proximity, moving toward him or idling if he gets too close. If Epona’s Song is played (or a corresponding cutscene flag is triggered), she transitions to action state 4, in which she gallops toward Link or returns to her home position, complete with turn logic and speed control based on distance.

The actor uses sound effects like neighing, galloping, or whinnying to enhance realism and convey emotion. Sound triggers are integrated with animation keyframes and frame counters. The actor also includes eye-blinking behavior through a series of indexed eye textures that cycle randomly, giving Epona a lifelike appearance. Collision handling is split between her body and head, using a cylinder and joint sphere respectively, both managed by the game’s collision system for player interaction and movement realism.

The En_Horse_Zelda actor represents Zelda’s white horse, seen galloping across Hyrule Field in Ocarina of Time’s opening and ending cutscenes. This actor uses skeletal animation and follows a pre-defined looping path composed of coordinates and target speeds (sHorseFieldPositions). As it moves, the horse dynamically adjusts its yaw to face the next waypoint and modulates its speed based on proximity to the player or waypoint target. Its movement state toggles between idle (Stop) and animated galloping (Gallop) with synchronized sound effects. The actor includes two colliders: a cylindrical body collider and a joint-sphere collider for limb-based detection. Rendering uses a Skin system for dynamic limb animation, and a post-draw callback ensures accurate collision sphere placement. Its shape rotation is adjusted based on ground slope to simulate natural galloping posture.

The En_Diving_Game actor manages the Zora's Domain diving minigame. Upon initialization, it checks if another instance already exists and removes itself if so. When active, the actor offers dialogue interactions to start the minigame, which costs 20 rupees. If accepted, the game sets up a scripted cutscene where the Zora throws special rupees (En_Ex_Ruppy) into the water, then initiates a timed challenge where Link must collect them. The actor uses sub-cameras for cinematic angles during rupee throws and tracks the number of rupees collected to determine success. Winning grants the player a reward like the Silver Scale, while losing prompts a failure message. The actor handles animations, transitions, state tracking, and message flow, cycling through phases like idle, preparing the game, playing, and awarding prizes. It also manages a simple idle animation with head and torso tracking for realism, eye blinking, and ripple effects in water for visual polish.

The `Bg_Spot07_Taki` actor (`z_bg_spot07_taki.c`) represents the animated waterfall and frozen surfaces in Zora’s Domain, dynamically changing based on Link’s age and story progression. When Link is a child, the area displays flowing water effects with layered scrolling textures, creating a vibrant, animated waterfall scene. As an adult, the domain becomes frozen, and this actor conditionally loads collision data and geometry for either solid ice formations or the frozen waterfall, based on parameters. The actor handles both visual rendering and physical collision using the dyna system but performs no behavior updates beyond initialization—its primary purpose is environmental storytelling through conditional rendering. The draw function adapts dynamically to game state, rendering different display lists and applying custom scrolling effects or semi-transparent textures depending on context. This actor contributes significantly to the atmospheric transformation of Zora’s Domain between timelines, reinforcing the consequences of the world’s altered state.

The Bg_Spot03_Taki actor controls the animated waterfall in Zora’s River, a key environmental element in Ocarina of Time. This dynamic actor represents the curtain of water that hides the entrance to Zora’s Domain. Initially solid and opaque, the waterfall responds to a specific switch flag to begin an animated opening sequence. As the animation progresses, its alpha transparency gradually decreases, making the waterfall fade away visually and disabling its collision to allow the player to pass through. After a set duration, the waterfall automatically restores itself by reversing the transparency and re-enabling collision, effectively closing the passage again. The draw function uses scrolling textures to simulate the flowing water effect, and special audio cues adjust the waterfall sound based on its state. By linking visual, physical, and audio elements with game progression logic, this actor creates an immersive and interactive environmental barrier that feels both natural and meaningful within the world.