Discovering Godot

Plan and build a Looney Lips word game in Godot to learn core programming fundamentals using GDScript, including functions, variables, arrays, dictionaries, nodes, and JSON files.

Discover how arrays make scalable stories by storing plug-in words in an array, merging with a story using format strings like %s, and avoiding off-by-one errors.

Learn to display text to the player in Godot by importing assets, creating a background texture, and using a label node updated by script to show dynamic prompts.

Learn to capture player input with a line edit in Godot and display it using signals. Refactor into a clear update display text function for cleaner code.

Learn to add a texture button in Godot, assign a label, align with containers, and pass text from the line edit to the display via the pressed signal.

In this Godot lecture, learn to capture player input, store words in an array, and drive a narrative with if/elif/else logic, array append, and size checks.

Learn to fix a Godot game bug by using queue_free to free memory and reload the current scene with get_tree, improving endgame flow.

Discover how to build a story template in Godot using dictionaries and arrays, organize prompts and stories, and select a random story with randomise.

Learn how to create story objects in Godot by separating data from script, using a shared script with export variables and a pull string array to manage multiple stories.

Learn to use json files in Godot to store stories as arrays of dictionaries and read, parse, and randomly select a story for the game.

export a Godot project with presets for Android, iOS, HTML, macOS, Windows, and Linux, and reinforce core concepts like variables, functions, dictionaries, and GUI elements.

Reflect on Loony Lips progress, using signals, child nodes, and exported variables like arrays, dictionaries, and constants to store and manipulate game data, then preview a two dimensional bunny game.

Design an old-school platformer where a cute bunny uses speed and agility to navigate a world. Avoid enemies and edges, and collect coins to gain lives via boost platforms.

Download the Happy Days assets, create a new Godot project, and import fonts, graphics, and sound effects to set up parallax backgrounds and a purple bunny player.

Create a 2d player's kinematic body with a collision shape and sprite in Godot. Move left or right with input, multiply by delta, and use move and slide for collisions.

Learn to make bunny jump in Godot by instancing scenes and building a level, defining gravity and jump speed, and applying move_and_slide with is_on_floor.

Discover how to set up an animated sprite in Godot, create multiple animations (idle, walk, jump) from sprite frames, and control playback with script, including facing direction using flip_h.

Learn reformatting and elegance in coding by applying the single responsibility principle, avoiding spaghetti code, and decoupling components with signals and separate scenes.

Build a level in Godot with a tile map in a 2D scene, convert tiles to a tile set, and paint collision polygons. Tune camera and collision layers for players.

Learn to use is_on_ceiling in Godot to stop hovering, bounce off ceilings, and integrate gravity with move_and_slide for a 2D platformer.

Learn to create immersive parallax backgrounds in Godot by using parallax layers and canvas layers, texturing with texture rects, mirroring repeated images, and adjusting scales to simulate depth and speed.

Implement a game over screen in Godot by detecting when bunny's y position exceeds a world limit, displaying game over with try again, and using get_tree to switch scenes.

Discover Area2D detection and spike hazards in Godot, using body entered signals, collision layers and masks, and simple scripts to hurt the Bunny.

Learn to use audio stream players in Godot to play sound effects and background music, control looping, volume, and pitch, and assign jump and hurt sounds.

Learn to add jump pads in Godot by using an area with collision shapes and signals to trigger a boost animation via the animation player, increasing the player's jump height.

Discover how to apply the single responsibility principle in Godot by moving end game logic to a dedicated game state script and using groups and signals to manage lives.

Create a Godot graphical user interface using a canvas layer, texture rectangles, and box containers to display coin and life icons, updated via game state and a gui group.

Learn to add coins in a Godot level with an AnimationPlayer spin, shrink and vanish on collection, and update coin count, lives, and the game state.

Fix the is_on_floor bug in a Godot project by refining the on floor logic to prevent zero motion when on the ground and ensure proper jump speed is applied.

Add spike man as a moving hazard in a 2d area using animated sprite, collision shape, and animation player; configure left-right movement and body_entered signal to detect the player.

Learn to build a cloud NPC that drifts left and right, detects the bunny with recast 2D, and fires cooldown-regulated lightning that vanishes on terrain, on bunny hit, or off-screen.

Design and animate a portal that emits particles, add a victory end screen, implement area 2D interactions, and hook the portal to trigger a win state in a Godot game.

Design a top-down stealth game in Godot featuring an expert thief sneaking through dark locations to steal valuables and escape undetected, balancing risk and reward with night-vision penalties, avoiding violence.

Install Kenney's assets for a Godot project, import tiles, sprite sheets, UI packs, and sounds, and preview how the assets shape the game's look and sound.

Create a character template in Godot using inheritable scenes to reduce repetition and enable variations. Implement a base script with speed and friction constants and a collision shape.

In Godot, build a player by inheriting from a character template, instantiate the scene, and implement top-down movement with keyboard input for four directions and look at the mouse.

Explore autotiles in Godot by using bitmasks to auto determine tile configurations, set up 2x2 or 3x3 masks, and create efficient tile maps with walls, floors, collision, occlusion, and navigation.

Learn to add collisions to auto tiles, choosing full or partial collisions, adjust snap options, and test with a centered camera and player in a template level.

Learn to create atmosphere with light 2d nodes in Godot by using light maps, occlusion, and shadows, offsetting textures, and toggling a torch via input mapping.

Build a basic security camera NPC in a Godot 2D scene by attaching a sprite to a camera body and animating rotation left and right, preparing for future player detection.

Discover how to implement player detection in Godot by calculating a guard's field of view and checking if the player lies within a 40-degree cone, with torch color feedback.

Set up line of sight with a max detection range using 2D direct space state. Draw a ray from the NPC to the player, then test obstruction and distance.

Add guards as NPCs in Godot by instantiating a character, inheriting from the template level, and equipping torches to reveal interactive guard behavior.

Learn to move guards in Godot using navigation options, choosing between a navigation polygon instance or a tile map, and use get simple path to drive a random destination sequence.

Move guards using get_simple_path to generate a path to random destinations, update the path as entries are reached, and use a timer to pause before selecting a new waypoint.

Add furniture in Godot to make the level more believable and visually varied, using tile maps, collision, and occlusion to create hiding spots and gameplay depth.

Learn to implement a not purely cosmetic night vision mode in Godot, switching between dark and night vision with canvas modulate, group interfaces, and a cooldown balancing risk and reward.

Develop simple doors in Godot by detecting mouse clicks within a clickable area. Manage interactions with players and NPCs via collision layers, animations, audio, z-index, and automatic closing.

Explore building a keypad UI in Godot to unlock doors, using popups, themes, and a grid of buttons laid out with nine-patch textures for a clean, scalable interface.

Explore extending scripts in Godot by inheriting scenes to build a locked door that shows a number pad pop-up on interaction and hides when the player exits the detection area.

Discover how to implement a number pad puzzle in Godot using arrays and signals. Wire all buttons with a loop, display input, and open the door when the code matches.

Create a singleton autoload that generates random numeric combinations of configurable length for every door, expose it to doors and computers, and print the eight-digit result for verification.

Learn to build a simple in-game computer in Godot using a sprite, an interaction area, and a pop-up monitor, then wire input events and collisions for player interaction.

Learn to build a Godot computer that generates and displays a combination, transmits it to locked doors via signals, and shows lock group IDs on labels.

Discover how night vision mode reveals map information by toggling labels on doors and computers while hiding torches, using Godot groups 'Lights' and 'Labels' with get_tree group calls.

Learn to build a texture progress meter for a suspicion meter in Godot, using a canvas layer, nine patch, and texture progress node that moves with the camera.

Learn to implement stealth in Godot by hiding in a box, using collision layers, line-of-sight, field of view, and range checks; toggle disguise with a key, swap textures, align occlusion.

Highlight the player in a dark level by adding a light that uses the player texture as a glow and toggle to a box light, adjusting its intensity for visibility.

In Discovering Godot, this lecture adds risk to disguises by slowing player movement and capping disguises. It implements a timed disguise with a visible timer and adjustable duration.

Learn to display disguises in a Godot inventory using an item list that shows icons, and update the user interface with group and signal calls.

Implement an object oriented inventory in Godot by turning loot into a briefcase node, using area collision and signals to collect items.

Design a bottom-left loot gui that remains invisible until the player picks up loot and then reveals the loot as an icon in a seven-column item list with a label.

Add an exit that activates only when the player has the briefcase, using a collision area and has_node to detect it, then end the level and show a victory screen.

Discover how to polish a Godot game by adding looping background music across scenes, and building a lobby with start and quit options plus a victory screen.

Design a Godot tutorial level that teaches players to move and interact in a dark map, use night vision, collect loot, and exit after securing the briefcase.

Learn to add objective markers in Godot, using a visual indicator that moves between objectives via signals, tweens, and position 2D nodes to guide the player.

Create on-screen objective text in Godot by building a bottom-anchored gooey interface with a nine-patch panel, multi-line string messages, and a reusable template for dynamic, labeled objectives.

Finish the tutorial and the game by animating text changes with an animation player, resizing and revealing the patch rectangle, and switching vision mode to night vision for the objective.

Explore planning a fast, competitive two-player 3D game in Godot with Cube Dude kickabout, focusing on local multiplayer and a clear, essential experience to score the most goals.

Create a new Godot project, download and paste the cube dude kick about assets, then explore 3D models, animations, materials, and sounds for gameplay.

Discover how to shift from 2D to 3D in Godot, build a pitch scene using a plane mesh, collision shapes, and basic spatial materials.

Explore how 3D physics work in Godot by examining static, rigid, and kinematic bodies, translation versus impulse, and how mass, gravity, friction, bounce, and sleep shape their behavior.

Discovering Godot teaches how to import a cube dude from Blender, configure a kinematic player with capsule collision, and use templates with material overrides for multiple characters.

Create a single Godot movement script that supports two players via keyboard and controller inputs. Bind four directions, use get_action_strength for analog input, and move with move_and_slide on normalized vector.

Finish the pitch in Godot by adding goals and boundary walls, configure static bodies with mesh collisions, and test ball and player interactions with posts and the net.

Improve cube movement by linking run animations to actual movement, looping only while moving, and updating the cube’s facing direction using the motion vector length and a face forward function.

Use area detectors with collision shapes to detect crossing the goal line, wire signals from detectors 1 and 2 to the game, and print which player scored to the console.

Resetting the game after a goal freezes the ball and players for five seconds, then moves them to their start positions via a game pieces group and spawn points.

Explore adding a 2D GUI in a 3D Godot scene by using a canvas layer, nine-patch banners, dynamic fonts, and a live score UI.

Implement end-of-game logic in Godot by setting a target score, stopping the timer, showing a centered game over pop up, updating the winner label, and offering a restart.

Enhance player experience through set dressing in Godot by adding background details, textures, materials, and scaled assets to create a playful, polished scene.

Add background music and scoring feedback to your Godot game by using audio stream players, looping background music, and non-positional sounds like an air horn triggered on goals.

Add visual effects to celebrate goals with 3D particle bursts, a spotlight on the scorer, and a dimmed directional light; preview with the camera to heighten the moment.

Plan a fast, frantic 3d food fight in Godot, where players throw food and dodge hits, with robots challenging them; customize characters with two messages and calfskin color options.

Set up a new Godot project, import food fight assets zip, organize fonts, graphics, materials, models, scenes, and SFX, then build a 3D scene and scale animated characters to 0.01.

Set up a 3d play space by adding a floor, camera, environment, and lighting, enable physics with rigid bodies and collisions, and fix center of gravity by aligning origins.

Explore character and player scenes in Godot by building a base class from which PCs and NPCs derive, set up moves with move and slide, collision shapes, and animation integration.

Learn to build a Godot animation tree with an animation player as root, blending idle and run, then add punch and pick up via blend nodes controlled by a script.

Learn to implement a mouse look system that rotates the camera and the player with mouse movement, capture and clamp the cursor, and adjust horizontal and vertical rotation with sensitivity.

Learn to implement camera-driven 2D movement in a 3D Godot project by separating horizontal movement, calculating a movement direction from input, and aligning it with the camera orientation.

We compare grid maps and manual level design in Godot, explaining why grid maps aren’t the right fit for our game, and show building with walls, doors, and windows.

fire projectiles in three-dimensional space using a rigid body template, spawn from a forward position, apply an impulse in the facing direction, and respond to a left mouse button input.

Create new food ammunition in Godot by inheriting the projectile, load random food models from a directory with a file grabber singleton, and add collisions and doppler audio.

In this Godot lecture, you finish the food by adding a 0.5 second cooldown timer, a can_fire flag, and a try_fire function to limit firing to twice per second.

Spawn unanimated bystander obstacles in Godot from a pool of figures via file grabber, using a semi random timer and spawner, with rigid bodies, collision shapes, and a dying animation.

Create robots in Godot, turning NPCs into moving shooting adversaries with forward ray cast firing, animation-driven motion, and collision-layer setups while wiring crossing-line logic.

Learn to pause a Godot game by building a canvas-layer pause menu with a popup, wiring full-screen, quit, and customize buttons, and toggling pause with the Escape key.

Learn to decorate a Godot level with static bodies, adding kitchen furniture such as cabinets, fridge, and sink using collision shapes and physics materials to shape player interactions and boundaries.

Decorate the level with rigid and static furniture in Godot, adjusting mass and TriMet collision shapes while aligning the origin to the center of gravity for dynamic, interactive objects.

Discover how to create a refill zone in Godot that limits ammo, detects the player with an area node, and refills ammunition over time as you stand in the zone.

Explore combat animations in Godot by wiring fire and reload sequences through an animation tree, action state management, and blend parameters to create responsive firing effects.