Please document the highlighted GDScript code following Godot's
official documentation comment style:
  - Use ## for single-line documentation comments
  - Use """ triple quotes for multi-line documentation
  - Document classes with a description at the top of the file
  - Format function documentation with:
    - Description of what the function does
    - Parameters section using @param keyword
    - Return value description using @return keyword
  - Document properties with a description on the line above the declaration
  - Document signals with a description on the line above the signal declaration
  - Include @example blocks when helpful
  - Use BBCode for formatting when appropriate: [b]bold[/b], [i]italic[/i], [code]code[/code]

Focus on being concise but thorough. Prioritize documenting:
  - Public methods and their parameters
  - Class purpose and responsibilities
  - Non-obvious functionality
  - Custom signals

Do not modify the actual code logic, only add documentation comments.

Review the highlighted GDScript code and suggest improvements based on Godot best practices.
Focus on:
  - Following the official GDScript style guide
  - Proper use of Godot's node system and hierarchy
  - Effective use of built-in features instead of custom implementations
  - Scene structure and organization
  - Resource management and loading
  - Signal connections and communication patterns
  - Editor integration (exports, tool scripts)
  - Code maintainability and readability
Provide concrete suggestions with code examples where appropriate, explaining the benefits of each recommended change in the context of Godot development.

Review the highlighted GDScript code and suggest optimizations
specific to Godot 4.3.

Focus on:
  - Reducing CPU usage
  - Minimizing memory allocations
  - Using Godot's built-in optimized methods
  - Proper signal handling
  - Improving node structure efficiency
  - Physics performance improvements
  - Replacing expensive operations in _process and _physics_process
Explain why each optimization helps and what impact it will have.

Based on the highlighted code or description, suggest appropriate Godot-specific design patterns.
Consider patterns like:
  - Node composition vs inheritance
  - Resource-based data management
  - State machines for character/entity behavior
  - Event bus vs direct signal connections
  - Dependency injection approaches
  - Scene instantiation strategies
  - UI management techniques
Provide code examples showing how to implement the recommended pattern in GDScript.

Review the highlighted code and help implement robust input handling using Godot's input system.
Consider:
  - InputMap for configurable controls
  - Input actions vs raw input
  - Controller/gamepad support
  - Touch input for mobile
  - Accessibility considerations
  - Input buffering techniques
  - UI input handling
Provide sample code that implements the appropriate input methodology for my use case.

Help me write or improve the highlighted shader code for Godot 4.3.
Consider:
  - ShaderMaterial vs CanvasItemMaterial
  - Performance implications
  - Platform compatibility (mobile, web)
  - Shader parameters and how to expose them
  - Visual quality improvements
  - Common visual effects (outlines, dissolve, etc.)
Provide complete shader code examples with explanations of key techniques.

Help me plan the implementation of the described game feature for Godot 4.3.
Consider:
  - Appropriate node structure and scene organization
  - Required scripts and resources
  - Potential performance considerations
  - Integration with existing systems
  - Signals and communication needed
  - Data persistence requirements
  - Editor tools or custom inspectors that might help
Provide a structured implementation plan with:
  - Component breakdown
  - Dependencies and prerequisites
  - Suggested implementation order
  - Potential challenges to anticipate
Focus on Godot-specific approaches and take advantage of the engine's built-in capabilities.