Game Development

Select suitable Godot node types by interpreting their responsibilities and inheritance.

Reference child nodes safely from a script using unique node names or exported references.

Expose typed configuration values in the Inspector with exported variables.

Create a reusable PackedScene and instantiate it from another scene.

Connect a built-in signal to a method that responds to an event.

Define and emit a custom signal carrying game-state data.

Choose between _process and _physics_process and use delta for frame-rate-independent behavior.

Locate and correct common GDScript errors with the Output panel and debugger.

Interpret Vector3 values and distinguish local coordinates from global coordinates in Godot.

Construct a simple 3D test arena with meshes, static collision, and lighting.

Configure named movement, jump, primary-attack, weapon-switch, and pause actions in the Input Map.

Convert directional input actions into a normalized 3D movement vector.

Move a CharacterBody3D with collision-aware velocity in _physics_process.

Apply gravity and jumping while using floor detection to control airborne movement.

Implement first-person mouse look with body yaw and clamped camera pitch.

Capture and release the mouse while switching correctly between gameplay and pause input.

Attach a simple first-person melee weapon view to the player camera.

Trigger melee attacks from mapped input while enforcing an attack cooldown.

Animate a melee swing with AnimationPlayer without moving the player camera.

Use collision layers and masks to prevent weapons, perception rays, and bodies from detecting unintended objects.

Detect an in-range target with a short forward ShapeCast3D.

Implement a reusable Health component whose take_damage(amount, source) method clamps health and emits damaged, health_changed, and a one-time died(source) signal.

Apply melee damage once per attack to a target dummy with the Health component, passing the player as the damage source.

Add clear hit confirmation using simple visual and audio feedback.

Create a reusable enemy scene with collision, navigation, a Health component, and exported configuration values.

Build and bake navigation data for a small 3D arena.

Move an enemy toward a target with NavigationAgent3D while avoiding direct wall traversal.

Measure whether the player is inside an enemy's detection distance.

Use a dot product to test whether the player lies inside an enemy's field of view.

Use a physics ray query to confirm unobstructed line of sight to the player.

Implement idle, chase, and attack states with explicit transitions based on perception and range.

Rotate an enemy toward a visible player without tilting the enemy body.

Implement a timed enemy firing cycle that only runs in the attack state.

Perform an enemy hitscan shot with a physics ray query and collision filtering.

Equip the player with the reusable Health component and apply gunshot damage while passing the shooting enemy as the damage source.

Add configurable inaccuracy to enemy shots without allowing impossible backward shots.

Stop enemy firing when line of sight is blocked or the player leaves attack range.

Transition the player to a dead state that disables movement and combat when health reaches zero.

Handle enemy death by stopping its AI, disabling its collision, playing any death feedback, and safely removing it.

Relay the Health component's died(source) signal as an enemy_defeated(killer) event exactly once before removal.

Track pistol ammunition as integer player state that cannot become negative.

Connect enemy-defeat events to award exactly one pistol bullet only when the killer is the player.

Switch explicitly between the melee weapon and pistol while preserving each weapon's state.

Fire a pistol hitscan shot that consumes exactly one bullet, damages the first valid target hit, and passes the player as the damage source.

Prevent pistol firing at zero ammunition and communicate the empty state to the player.

Enforce a pistol fire-rate limit using a GDScript cooldown timer.

Apply brief visual recoil to the first-person weapon model when firing the pistol.

Instantiate visual impact feedback at the pistol's hitscan collision point.

Display player health and update the HUD through a health-change event.

Display the pistol ammunition count and update it whenever ammunition changes.

Create a crosshair that provides distinct feedback for hits and confirmed kills.

Indicate the direction of incoming enemy damage by using the attacker's position from the damaged signal.

Implement an encounter controller that declares victory when all required enemies are defeated and defeat when the player dies.

Implement a restartable encounter flow that resets enemies, player health, weapons, and ammunition.

Design an original compact arena layout that supports melee approaches, cover, and enemy sightlines.

Place enemy starting positions that create readable threats without unavoidable opening damage.

Configure navigation and collision so enemies can pursue the player through every intended route.

Tune player movement, melee range, pistol power, and enemy accuracy using exported values.

Create a difficulty progression by varying enemy placement and configuration rather than duplicating scripts.

Playtest the kill-to-bullet reward loop and adjust values so both melee and pistol remain useful.

Execute a repeatable end-to-end gameplay QA checklist.

Diagnose and fix edge cases involving rapid input, simultaneous deaths, and repeated kill rewards.

Connect player-damage screen feedback to the existing damaged signal without modifying combat logic.

Configure project settings and export a playable Linux build of the completed prototype.