Unit 5: Gameplay components - Subjective Questions

3D game creation is the process of designing and implementing an interactive game in which objects, characters, and environments are represented using three-dimensional coordinates.

The major stages are:

• Concept and planning: Define the game idea, objectives, target audience, mechanics, and story.
• Environment creation: Build the terrain, rooms, buildings, lighting, and other level elements.
• Asset integration: Import 3D models, textures, materials, animations, sounds, and visual effects.
• Gameplay programming: Implement player movement, interaction, scoring, combat, and game rules.
• Camera setup: Configure a first-person, third-person, or other suitable camera system.
• Physics and collision: Add colliders, rigid bodies, gravity, and collision responses.
• Testing and optimization: Detect errors, balance gameplay, and improve performance.
• Build and deployment: Package the completed game for the intended platform.

A 3D game scene is generally organized as a hierarchy of game objects. Each object represents an entity such as a player, enemy, camera, light, weapon, or environmental prop.

• Game objects: Act as containers for the elements present in the scene.
• Transform component: Stores the position, rotation, and scale of an object in 3D space.
• Rendering components: Display meshes, materials, textures, particles, and animations.
• Physics components: Provide colliders, rigid bodies, gravity, and physical reactions.
• Scripts: Define object-specific logic such as movement, attacks, health, and interaction.
• Assets: Include reusable models, sounds, textures, animations, and prefabricated objects.
• Parent-child hierarchy: Allows related objects to be grouped so that child objects inherit transformations from their parents.

This component-based organization improves modularity, reuse, debugging, and maintainability.

A controllable 3D player character can be implemented through the following steps:

1. Create or import the character: Add a suitable 3D model to the scene.
2. Configure collisions: Attach a capsule collider or character controller to prevent the player from passing through objects.
3. Read player input: Capture keyboard, mouse, controller, or touch input.
4. Calculate movement: Convert input into forward, backward, and sideways movement relative to the character or camera.
5. Apply movement: Move the character using a character controller, rigid body, or movement component.
6. Add gravity and jumping: Apply vertical velocity and ground checks.
7. Control rotation: Rotate the player toward the movement or aiming direction.
8. Integrate animations: Use an animation state machine for idle, walk, run, jump, and attack states.
9. Attach a camera: Configure the camera to follow the character smoothly.

The implementation should use frame-rate-independent movement and reliable collision detection.

• Collider: Defines the physical shape used to detect contact or overlap. It does not necessarily make an object move. Box, sphere, capsule, and mesh colliders are common examples.
• Rigid body: Makes an object participate in physics simulation. It can respond to gravity, forces, impulses, mass, friction, and collisions.
• Character controller: Provides controlled movement for player or non-player characters without relying completely on rigid-body physics. It commonly supports slope limits, step handling, and grounded movement.

Key distinction:

• A collider defines the collision boundary.
• A rigid body gives an object physics-based motion.
• A character controller gives a character predictable, script-controlled movement.

For example, a falling crate usually uses a collider and rigid body, while a player character commonly uses a capsule-shaped character controller.

Adding an enemy involves both visual setup and gameplay programming:

• Import or create the enemy model and place it in the game scene.
• Configure the transform so that its position, rotation, and scale match the environment.
• Add collision and navigation components to support movement and obstacle avoidance.
• Create enemy attributes such as health, movement speed, attack power, detection range, and attack range.
• Add animations for idle, patrol, chase, attack, damage, and death.
• Implement perception using distance checks, trigger volumes, vision cones, or raycasts.
• Create decision logic with a finite-state machine or behavior tree.
• Implement combat behavior so that the enemy can attack and receive damage.
• Handle death and rewards by disabling the enemy, playing effects, and updating the score or inventory.
• Test and balance the enemy's speed, accuracy, damage, and reaction time.

Enemy perception can combine three checks:

• Detection radius: The enemy first checks whether the player is within a specified distance. This is an efficient way to reject distant targets.
• Field of view: The angle between the enemy's forward direction and the direction toward the player is calculated. The player is visible only when this angle is within the enemy's viewing cone.
• Raycasting: A ray is cast from the enemy's eye position toward the player. If a wall or obstacle is hit first, the player is not considered visible.

A typical detection sequence is:

1. Find targets inside the detection radius.
2. Test whether each target is inside the viewing angle.
3. Cast a ray to verify a clear line of sight.
4. Store the detected target and activate chase or attack behavior.

This layered approach produces more believable perception while avoiding unnecessary raycasts.

• Patrol behavior: The enemy moves between predefined waypoints or randomly selected locations when no threat is detected.
• Chase behavior: The enemy follows a detected player using navigation and pathfinding until the player is reached or lost.
• Attack behavior: The enemy stops or adjusts its movement and performs melee, ranged, or special attacks when the player enters attack range.
• Retreat behavior: The enemy moves away from the player when health is low, ammunition is unavailable, or tactical conditions are unfavorable.

These behaviors differ in their activation conditions, movement goals, and actions. A common transition sequence is patrol to chase to attack. Retreat may interrupt chase or attack when a survival condition becomes true. Coordinating these behaviors creates an enemy that reacts meaningfully to gameplay conditions.

A navigation mesh, often called a NavMesh, represents the parts of a 3D level on which an AI-controlled character can walk.

Its use involves:

• Baking or generating walkable surfaces from level geometry.
• Excluding walls, steep slopes, holes, and inaccessible regions.
• Attaching a navigation agent to the enemy.
• Assigning a destination such as a patrol point or the player's location.
• Calculating a path through connected walkable regions.
• Steering the enemy around obstacles while following that path.

Pathfinding algorithms, commonly based on A*, search for a low-cost route between the current position and destination. Dynamic obstacle avoidance helps multiple agents move without colliding. Off-mesh links may represent jumps, doors, ladders, or gaps. Navigation meshes provide more reliable movement than directly moving an enemy in a straight line toward its target.

An AI behavior tree is a hierarchical decision-making structure used to control the actions of an autonomous game character. The tree is evaluated from its root, and each node usually returns success, failure, or running.

Principal components include:

• Root node: The entry point of the behavior tree.
• Composite nodes: Control the execution of child nodes. Common composites include selectors and sequences.
• Selector node: Executes children until one succeeds or remains running.
• Sequence node: Executes children in order until one fails or remains running.
• Decorator node: Modifies or restricts a child's execution using conditions, repetition, inversion, or cooldowns.
• Condition node: Checks a fact, such as whether the player is visible.
• Action node: Performs an operation, such as moving, attacking, or waiting.
• Blackboard: Stores shared data such as target position, health, and alert state.

Behavior trees are modular and are well suited to complex, reusable AI logic.

Selector node:

• Represents alternative choices.
• Evaluates child nodes from left to right.
• Returns success when any child succeeds.
• Returns failure only when every child fails.
• Example: An enemy may try to attack; if that fails, it may chase; if chasing fails, it may patrol.

Sequence node:

• Represents a series of required steps.
• Evaluates child nodes from left to right.
• Continues only while each child succeeds.
• Returns failure as soon as one child fails.
• Example: To attack, an enemy may first check that the player is visible, confirm that the player is in range, face the player, and then perform the attack.

Thus, a selector behaves like an OR decision, whereas a sequence behaves like an AND process.

A suitable behavior tree can use a root selector with three major branches:

• Attack sequence:

  • Check whether the player is visible.
  • Check whether the player is within attack range.
  • Face the player.
  • Perform the attack.

• Chase sequence:

  • Check whether the player is visible or has a known last position.
  • Set the navigation destination.
  • Move toward the player.
  • Update the last known position while the player remains visible.

• Patrol sequence:

  • Select a patrol waypoint.
  • Move to the waypoint.
  • Wait for a short duration.
  • Select the next waypoint.

The root selector prioritizes attacking over chasing and chasing over patrolling. When the player enters attack range, the attack branch succeeds. If the player is visible but too far away, the chase branch runs. If the player is lost, the enemy can investigate the last known position and then return to patrol. Blackboard values store the target, last known position, and current waypoint.

Finite-state machine:

• Organizes behavior into explicit states such as patrol, chase, and attack.
• Uses transitions to move between states.
• Is simple and efficient for a small number of behaviors.
• Can become difficult to maintain when many states and transitions are added.

Behavior tree:

• Organizes decisions as a hierarchy of conditions, composites, decorators, and actions.
• Naturally represents priorities and reusable behavior branches.
• Supports complex behavior without requiring direct transitions between every possible state.
• May require careful debugging because evaluation occurs across many nodes.

A finite-state machine is appropriate for simple, clearly separated behaviors. A behavior tree is generally more scalable for enemies that need many conditions, priorities, and reusable actions. Hybrid systems may use a state machine for broad modes and behavior trees for detailed decisions.

• Blackboard: A shared memory structure that stores values used by behavior-tree nodes. Examples include the current target, last known player position, remaining health, ammunition, and alert level.
• Decorator: A node that controls whether or how another node executes. It may test a condition, repeat an action, impose a cooldown, invert a result, or abort a running branch when a value changes.
• Service: A periodically executed operation that updates information while a branch is active. For example, a service may scan for the player or update the distance to the current target.

Together, these components separate decision logic from data gathering. The blackboard centralizes AI knowledge, decorators express conditions and execution rules, and services keep relevant information current. This makes complex behavior trees easier to reuse and modify.

A timeline-based cutscene is a cinematic sequence created by arranging events and media clips along a time-based editor. The timeline controls when each event starts, how long it lasts, and how it blends with nearby events.

Common timeline elements include:

• Camera tracks for camera position, rotation, cuts, and blending.
• Animation tracks for character movement, gestures, and facial expressions.
• Audio tracks for dialogue, music, and sound effects.
• Activation tracks for showing or hiding game objects.
• Event or signal tracks for triggering scripts, effects, or gameplay changes.
• Lighting and post-processing tracks for mood and visual transitions.
• Subtitle or dialogue tracks for presenting spoken content.

The timeline allows designers to synchronize these elements precisely without programming every event manually.

The procedure is as follows:

1. Create a timeline controller: Add a timeline or sequence component to a scene object.
2. Define the duration: Decide the start time, end time, and pacing of the cutscene.
3. Add cinematic cameras: Position cameras for wide shots, close-ups, and character viewpoints.
4. Create camera tracks: Arrange camera shots and configure smooth blends or direct cuts.
5. Add animation tracks: Bind characters and place movement, gesture, and facial animation clips.
6. Add dialogue and audio: Synchronize voice recordings, music, and sound effects with the animations.
7. Add subtitles: Display timed text that matches spoken dialogue and remains readable.
8. Trigger events: Use signals to open doors, spawn objects, change lighting, or update game state.
9. Control player input: Disable or restrict gameplay controls when necessary.
10. Restore gameplay: Return control, camera state, and AI behavior after the cutscene.

The sequence must be tested for synchronization, continuity, camera clipping, and correct state restoration.

A smooth transition requires coordinated control of the camera, player, AI, user interface, and game state.

• Trigger the cutscene using a collision volume, interaction, mission event, or script.
• Save relevant gameplay state before the sequence begins.
• Temporarily disable or limit player movement and combat input.
• Pause, reposition, or constrain AI characters when required.
• Blend from the gameplay camera to the cinematic camera.
• Hide unnecessary interface elements while keeping essential prompts or subtitles visible.
• Play the timeline and process its scripted events.
• At completion, restore the player, AI, interface, and gameplay camera.
• Place the player and characters in positions consistent with the final cutscene frame.
• Prevent the same cutscene from replaying unintentionally by recording its completion state.

Smooth camera blending and consistent character positions prevent abrupt visual or logical discontinuities.

Advantages:

• Provide precise synchronization of animation, camera, dialogue, sound, and effects.
• Allow designers to edit cinematic sequences visually.
• Support camera cuts, blends, and layered tracks.
• Reduce the amount of custom sequencing code required.
• Make it easier to preview and revise narrative scenes.

Limitations:

• Fixed sequences may reduce player agency.
• Changes to level geometry or character positions can break staging.
• Long cutscenes may interrupt gameplay flow.
• Branching narratives can make timelines complex to manage.
• Real-time performance problems may affect timing and visual quality.
• Skipping a sequence can leave the game in an incorrect state unless events are handled properly.

Timeline-based cutscenes are most effective when they are concise, integrated with gameplay, and designed to handle interruption or skipping reliably.

Immersive storytelling presents narrative information in a way that makes players feel present in the game world and personally involved in its events.

Environmental storytelling communicates narrative through the design and condition of the world rather than relying only on direct exposition. It may use:

• Object placement and visual clues.
• Architecture and level layout.
• Lighting, color, weather, and atmosphere.
• Abandoned equipment, damaged structures, or character belongings.
• Written notes, recordings, signs, and symbols.
• Non-player character routines and reactions.
• Changes in the environment caused by player decisions.

For example, a deserted room containing barricaded doors, broken furniture, and unfinished messages can suggest a past conflict without a narrator explaining it. This encourages observation and interpretation, strengthening player engagement.

• Player agency gives players meaningful control over actions and narrative outcomes.
• Branching choices allow conversations, missions, relationships, or events to follow different paths.
• Consequences make decisions affect characters, environments, resources, future missions, or endings.

An effective choice should:

• Be understandable within the story context.
• Represent genuinely different intentions or trade-offs.
• Produce visible short-term or long-term consequences.
• Remain consistent with established characters and world rules.
• Avoid presenting false choices that always produce the same result.

The game can store decisions using variables or flags and use them to alter dialogue, AI attitudes, available areas, cutscenes, and mission outcomes. When the world remembers and reacts to player actions, the player becomes an active participant in the narrative rather than a passive observer.

Consider a sequence in which the player enters an abandoned research facility:

1. Environmental setup: Damaged equipment, warning messages, and audio logs reveal that an experiment escaped.
2. Gameplay trigger: Crossing a doorway activates a short timeline-based cutscene.
3. Cutscene presentation: The camera shows a security door closing while an enemy appears behind glass. Lighting, animation, and sound establish the threat.
4. Gameplay restoration: Control returns to the player, and the enemy's behavior tree becomes active.
5. AI behavior: The enemy patrols nearby rooms, uses sight and sound to detect the player, chases when the player is found, and attacks at close range.
6. Adaptive response: If the player hides, the enemy searches the last known position before returning to patrol.
7. Narrative choice: The player may destroy the enemy, trap it, or restore the facility's containment system.
8. Consequences: Later dialogue, level conditions, and mission outcomes change according to the player's choice.

This sequence integrates story and mechanics because the enemy is both a gameplay challenge and evidence of the facility's past events.