Menu

© 2025 ういやまラボ

BLOGTOOLSPRODUCTNOTES

    Godot Technical Notes

    Technical notes for Godot game engine

    Controlling Pause Functionality with Process Mode

    Basics2025-06-20

    Learn Godot Engine's pause functionality and Node Process Mode. From basic usage to creating non-paused UIs, cutscene and dialogue applications, and performance considerations.

    A Thorough Guide to Scenes and Nodes

    Basics2025-12-06

    Learn the fundamental concepts of 'Scenes' and 'Nodes' that form the core of Godot Engine, explained at a practical level. Includes performance tips and best practices.

    Debugging Techniques and print_debug - Efficient Bug Fixing in Godot Engine

    Basics2025-12-08

    Learn how to strategically use Godot Engine's debugging tools and print_debug function to efficiently fix bugs, aimed at beginners to intermediate developers.

    How to Configure VSCode / Cursor as an External Editor

    Basics2025-08-13

    Learn how to set up VSCode or Cursor as an external editor in Godot, improving your development workflow with AI completion, advanced debugging, and LSP integration.

    Complete Guide to Static Typing in GDScript: Performance Optimization and Bug Prevention

    Basics2025-12-08

    Master GDScript's static typing to prevent bugs proactively and maximize performance. Learn practical techniques with code examples.

    Node Communication with Signals

    GDScript2025-12-06

    Learn Godot's signal feature from basics to practical applications and best practices, enabling loosely coupled component design while avoiding direct references.

    Managing AI and Player States with State Machines

    GDScript2025-12-06

    Learn how to organize complex character behavior, from simple state machines using enum and match statements to advanced design patterns with state classes.

    Managing Cross-Scene Data with Autoload

    GDScript2025-06-20

    A comprehensive guide to Godot Engine's Autoload (Singleton) feature, from basic usage to common mistakes, best practices, and comparisons with alternative patterns.

    Dependency Management in Godot: Design Patterns to Avoid Cyclic References

    GDScript2025-12-10

    Design patterns to prevent memory leaks from cyclic references. Learn how to use WeakRef, signals, and Autoload.

    Proper Usage of _process and _physics_process

    GDScript2025-12-10

    Explains the difference between _process and _physics_process. Fundamentals of variable/fixed timesteps and best practices for proper usage.

    Understanding await and Coroutines in Godot Engine: Async Processing Fundamentals (Including yield Migration)

    GDScript2025-12-08

    Learn how to use the await keyword and coroutines in Godot 4's GDScript, from basic signal waiting to practical UI control and performance considerations. Includes migration guide from Godot 3's yield.

    Managing Key Bindings with InputMap

    Input2025-06-20

    Learn Godot Engine's InputMap feature. From basic usage to dynamic key configuration, saving settings, and best practices for building a flexible input system.

    Understanding Input Detection Methods: just_pressed, pressed, and released

    Input2025-06-20

    Learn the differences between Godot Engine's input methods is_action_just_pressed, is_action_pressed, and is_action_just_released. Includes practical code examples for jumping, movement, charge attacks, and variable-height jumps.

    CharacterBody2D Motion Mode: Choosing Between Top-Down and Side-Scroller

    Physics2025-06-20

    Learn the differences between CharacterBody2D's Grounded and Floating modes. Discover optimal usage for top-down vs side-scrolling games, with code examples, common mistakes, and best practices.

    Organizing Collision Detection with Layers and Masks

    Physics2025-06-20

    Learn how Godot Engine's Collision Layers and Masks work. Covers efficient setup methods, dynamic code control, and performance optimization.

    Understanding move_and_slide vs move_toward: Implementing Knockback

    Physics2025-06-20

    Learn the differences between move_and_slide used with CharacterBody and the versatile move_toward function in Godot Engine. Includes practical code examples for knockback, enemy tracking, and UI animation.

    CharacterBody2D vs RigidBody2D vs StaticBody2D - Choosing the Right 2D Physics Body in Godot Engine

    Physics2025-12-08

    Learn the features, characteristics, performance, and practical use cases of Godot Engine's main 2D physics bodies—CharacterBody2D, RigidBody2D, and StaticBody2D—with code examples.

    Complete Guide to Area2D in Godot Engine: Range Detection and Trigger Implementation

    Physics2025-12-08

    Learn the fundamentals of range detection and trigger implementation using Godot Engine's Area2D node, from practical implementations like enemy detection ranges and continuous damage zones to performance optimization.

    AnimatedSprite2D vs AnimationPlayer: When to Use Each

    Animation2025-06-20

    A comprehensive guide to Godot Engine's 2D animation systems, comparing AnimatedSprite2D and AnimationPlayer features, with practical code examples and integration techniques.

    White Flash Damage Effect Using the Modulate Property

    Animation2025-06-20

    Learn how to implement a white flash effect when characters take damage in Godot Engine using the modulate property and Tween. Includes performance considerations and advanced examples.

    Smooth Animations with Tween

    Animation2025-12-06

    Learn how to easily implement time-based value changes for UI effects, visual effects, and moving platforms using create_tween(), with practical code examples.

    Advanced AnimationPlayer - Mastering Tracks, Keyframes, and Callbacks

    Animation2025-12-08

    Master the advanced features of Godot Engine's AnimationPlayer—tracks, keyframes, and callbacks—to synchronize complex animations with game logic.

    Complex Animation Management with AnimationTree and State Machines

    Animation2025-12-08

    Learn how to efficiently manage complex character animations using Godot Engine's AnimationTree and state machines, with practical code examples.

    Control Node Fundamentals and Layout Containers - Building Responsive UI in Godot Engine

    UI2025-12-08

    Learn how to build responsive UI that adapts to various screen sizes using Godot Engine's Control nodes and layout containers.

    Building a Simple Dialogue System (Text, Choices, and Branching)

    UI2025-12-08

    Learn how to build an extensible dialogue system in Godot Engine featuring text display, typewriter effects, choices, branching, and data-driven design.

    Unified UI Design with the Theme System - Implementing Consistent Design

    UI2025-12-08

    Learn Godot Engine's Theme system. From basic concepts to StyleBox, dynamic changes, and best practices—dramatically improve UI design consistency and maintainability.

    Inventory System Design Fundamentals: Item Management with Resources and Signals

    UI2025-12-08

    Learn how to design an extensible and maintainable inventory system in Godot Engine using Resources and signals, with clear separation of data, logic, and UI.

    Godot Engine Camera2D Practical Techniques: Mastering Smooth Follow, Screen Shake, and Dynamic Zoom

    Rendering2025-12-08

    Practical techniques for mastering Godot Engine's Camera2D. Covers smooth follow, screen shake, dynamic zoom, and performance optimization with concrete code examples.

    Fragment Shader Fundamentals and First Steps - Color Changes and Effects

    Rendering2025-12-08

    From the basic role of Fragment Shaders in Godot Engine to dynamic effects using UV coordinates, time, and noise, with concrete code examples and performance optimization techniques.

    Creating Explosion, Smoke, and Magic Effects with GPUParticles2D

    Rendering2025-12-08

    Learn how to implement visual effects like explosions, smoke, and magic using Godot Engine's GPUParticles2D, from basic setup to performance optimization.

    Godot 2D Lighting Guide: Deep Expression with PointLight2D and Shadows

    Rendering2025-12-10

    Learn how to implement 2D lighting and shadows using PointLight2D and LightOccluder2D. From basic setup to common problem solutions and performance optimization.

    SubViewport Techniques - Minimaps, 3D in 2D, and Render Textures to Enhance Godot's Expressiveness

    Rendering2025-12-08

    Learn SubViewport in Godot Engine. Covers practical techniques from minimap and 2D/3D hybrid UI implementation to dynamic render textures and performance optimization.

    Learning Godot's 3D Space Fundamentals with Node3D and MeshInstance3D

    Rendering2025-12-08

    Learn the essential concepts of Node3D and MeshInstance3D for starting 3D game development in Godot Engine, including 3D coordinate systems, Transform3D, and parent-child relationships with practical code examples.

    Godot Audio Management Basics: Mastering AudioStreamPlayer and Audio Bus

    Audio2025-12-10

    Learn how to use AudioStreamPlayer and Audio Bus. Best practices for BGM/SFX management and volume control.

    Smart Obstacle Avoidance with NavigationRegion2D and Navigation Meshes

    Navigation2025-12-08

    Learn how NavigationRegion2D and navigation meshes work in Godot Engine, and how to build systems where AI smoothly navigates around obstacles—from bake settings to RVO avoidance.

    Pathfinding with NavigationAgent2D - Enemy AI Pursuit and Patrol

    Navigation2025-12-08

    Learn how to implement enemy AI pursuit and patrol behavior while avoiding obstacles using Godot Engine's NavigationAgent2D, with practical code examples and performance optimization tips.

    Implementing Save/Load Systems - A Complete Comparison of JSON, ConfigFile, and Custom Resources

    Data2025-12-08

    Compare the three main methods for persisting game data in Godot Engine (JSON, ConfigFile, Custom Resources) from error handling, performance, and security perspectives with concrete implementation examples.

    Setting Up Auto-Tile with the Terrains Feature

    Data2025-06-20

    Learn how to configure Godot 4's Terrains (auto-tile) feature, from setup to common mistakes, performance optimization, and GDScript integration.

    Creating and Using Custom Resources - Data-Driven Design in Godot Engine

    Data2025-12-08

    Practical methods for data-driven design using Godot Engine's custom resources. Covers performance optimization, common mistakes, and best practices.

    Using Marker2D as a Management Node

    Scene2025-06-20

    Learn how to use Marker2D for GameManagers, spawn points, and weapon muzzle management. Covers differences from Position2D, performance considerations, common mistakes, and best practices.

    Flexible Object Detection with Groups

    Scene2025-06-20

    Godot's group feature is a system for tagging and flexibly managing nodes. Learn basic usage through practical performance-conscious applications, and comparison with alternative approaches.

    Mass-Producing NPCs with Editable Children and Scene Inheritance

    Scene2025-06-20

    Learn how to efficiently create and manage large numbers of NPCs and enemy character variations in Godot. Covers scene inheritance vs Editable Children usage with code examples and performance considerations.

    Complete Guide to Object Pooling for Dramatically Improving Godot Performance

    Performance2025-12-10

    Learn the mechanism and implementation of Object Pooling. Eliminate instantiation spikes and stabilize FPS.

    Stabilizing FPS in Godot Engine: Frame Rate Management and Optimization Techniques

    Performance2025-12-10

    Learn the fundamentals of frame rate management to stabilize FPS, along with optimization techniques like physics interpolation and Object Pooling.

    Building Godot Projects for Various Platforms

    Build2025-12-10

    Complete guide to reliably export Godot projects to Windows/macOS/Android/Web. Covers build size optimization, common error solutions, and best practices.