About this Video

• Video Title: Your First 2D GAME From Zero in Godot 4 Vampire Survivor Style
• Channel: GDQuest
• Speakers: Nathan
• Duration: 02:13:16

Introduction

This tutorial teaches viewers how to create a 2D roguelite shoot-em-up game similar to Vampire Survivors using Godot 4. The video covers coding player movement, implementing weapons, creating and animating enemies, managing health, and more. It also includes hidden coupons for a discount on the GDQuest Godot 4 Starter Kit.

Key Takeaways

• Roguelite shoot-em-up games are relatively easy to develop in Godot.
• Godot is a free and open-source game engine, making it accessible for game development.
• The tutorial covers fundamental Godot features, including player movement, weapon implementation, enemy AI, health management, and animation.
• The video uses Godot's built-in features and functions to simplify the development process.
• Hidden coupons are scattered throughout the video, offering discounts on GDQuest's Godot 4 Starter Kit.

The video tutorial covers a vast number of steps to create the game. Providing every single detail would be extremely lengthy. However, I can summarize the key phases and significant steps within each. Remember, this is based solely on the provided transcript and omits many of the fine-tuning details shown visually in the video.

Phase 1: Project Setup and Basic Character Creation:

1. Download and Setup: Download Godot 4 and the provided project files. Import the project into the Godot editor.
2. Editor Tour: Familiarize yourself with the Godot editor's interface (Scene Dock, File System Dock, Inspector).
3. Character Creation: Create a CharacterBody2D node for the player. Add a CollisionShape2D (circle shape) as a child to define the collision area.
4. Visuals: Import the pre-made animated character ("happyboo.tscn") and add it as a child of the CharacterBody2D.
5. Scripting Movement: Attach a GDScript to the CharacterBody2D node. Within the _physics_process(delta) function, use Input.get_vector() to get input directions, calculate velocity, and use move_and_slide() to move the character. Animations are triggered based on velocity.

Phase 2: Game Scene and Environment:

1. Game Scene Creation: Create a new scene (Node2D) named "game" to serve as the main game scene.
2. Adding Player: Add the player character scene ("player.tscn") to the "game" scene.
3. Background: Add a ColorRect node for the background color and adjust its size to fill the screen. Layer ordering ensures the background is behind the player.
4. Trees (Static Obstacles): Create a new scene for a tree, using a StaticBody2D with a CollisionShape2D (circle) and a sprite. Adjust the collision shape size. Add a shadow sprite. Use Y-sorting to control drawing order based on Y-position. Add multiple trees to the game scene.
5. Setting Main Scene: Set the "game" scene as the main scene for the project.

Phase 3: Enemy (Mob) Creation and AI:

1. Mob Scene: Create a new scene with a CharacterBody2D, a sprite for the slime enemy ("slime.tscn"), and a CollisionShape2D. Add scripting for movement.
2. Enemy AI: In the mob's GDScript, use _physics_process(delta) to calculate the direction towards the player using global_position.direction_to(). Apply velocity and use move_and_slide().
3. Adding Mobs: Add multiple instances of the mob scene to the game scene. Use @onready to get a reference to the player node when the scene loads. Physics layers and masks manage collisions between mobs, player, and trees.

Phase 4: Weapon and Projectile System:

1. Weapon Scene: Create a new scene for the player's weapon using an Area2D (for detection) with a CollisionShape2D (circle) representing the weapon's range. Add a sprite for the pistol. Add a child Marker2D ("weapon pivot") to control rotation. Add another child Marker2D ("shooting point") for bullet spawning.
2. Aiming: Attach a script to the Area2D. Use get_overlapping_bodies() to detect nearby enemies and use look_at() to aim the weapon at the closest enemy. Physics layers and masks ensure the weapon only detects enemies.
3. Bullet Scene: Create a new scene for bullets using an Area2D with a CollisionShape2D (circle) and a sprite for the projectile.
4. Bullet Movement: Attach a script to the bullet. Use _physics_process(delta) to move the bullet based on its rotation, using position += direction.rotated(rotation) * speed * delta. Implement a maximum travel distance to destroy the bullet after it travels far enough.
5. Damage: Connect the body_entered signal of the bullet's Area2D to a function in the bullet's script. In this function, check if the hit body has a take_damage method and call it if it exists.
6. Shooting Mechanics: Attach a Timer node to the gun. Connect the timeout signal to a function in the gun's script that instantiates and fires a bullet using the techniques from step 4. Set the timer's wait_time to control the fire rate. The top_level property on the bullet makes it independent of parent rotation.

Phase 5: Health, Animations, and Game Over:

1. Player Health: Add a health variable to the player's script. Use the player's Area2D ("hurtbox") to detect overlapping enemies. Reduce player health based on the number of overlapping enemies and delta. Emit a health_depleted signal when health reaches zero.
2. Health Bar: Add a ProgressBar node to the player scene. Use themes to customize the appearance. In the player's script, update the progress bar's value to match the player's health.
3. Enemy Animations: Implement animations for enemy hit and walking states within the enemy's script. Use the take_damage function to trigger the appropriate animations.
4. Death Effect: Add a smoke explosion effect using a pre-made scene ("smoke_explosion.tscn") to be spawned at the enemy's position upon death.
5. Game Over Screen: Create a CanvasLayer with a ColorRect (to darken the screen) and a Label (for "Game Over" text). Use layout options to center the text. Connect the player's health_depleted signal to a function that shows the game over screen and pauses the game using get_tree().paused = true.

Phase 6: Random Mob Spawning:

1. Spawn Area: Use a Path2D node to define an area outside the camera view where mobs will spawn.
2. Path Following: Add a PathFollow2D node as a child of the Path2D. Use randf() to generate a random progress_ratio and get a random point along the path.
3. Spawning Function: Create a function in the game scene's script to spawn a mob at a random point from the PathFollow2D node.
4. Timer for Spawning: Add a timer node to the game scene to call the spawning function repeatedly at intervals, resulting in continuous mob spawning. Make the Path2D a child of the player node so that the spawning area follows the player.

This detailed breakdown should help you understand the process. However, the actual implementation within Godot involves a significant amount of visual manipulation and code writing not fully described in the transcript. Consult the video itself for the most comprehensive guide.