How to Make a Survival Game in Godot

Building a Godot survival game? You have come to the right place. In this tutorial, we will be guiding you through the process of setting up a realistic needs system for players using Godot, a robust gaming engine. This interactive player needs system will consist of key elements like a health bar, hunger bar, thirst bar, and sleep bar – each integrated to deliver a lifelike gaming experience. These bars will indicate the player’s state by depleting or regenerating over time, providing a clear understanding of the player’s needs in the game.

You’ll learn how to create, manage, and delete UI bars that display these needs, and how to perform Checks & Balances on these Godot survival stats. To make the most of this tutorial, you should have a basic understanding of Godot, game development, and coding.

Project Files

The project files include code snippets used in this tutorial to set up the needs system. Understanding this codebase will prove beneficial in realizing the functionality of your Godot survival game.

Download Project Files Here

CTA Small Image




Player Needs – Part 1

In this tutorial, we will show you how to set up a foundational needs system for a Godot survival game. The needs system will consist of a health, hunger, thirst, and sleep bar, which will deplete or regenerate over time.

Creating the UI

To begin, we need to set up our actual UI bars to track needs in our Godot survival game. Here’s how you can go about creating these:

  1. Create a new node as a child of the player node. This node will be of type Node3D and will hold all our different needs and the UI nodes as well. Rename this new node to ‘Player Needs’.
  2. Add a ‘Control’ node as a child of the ‘Player Needs’ node. The ‘Control’ node is a UI node in Godot. We’re using it because we want to modify UI elements.
  3. Next, we add two elements to the ‘Control’ node. One is a progress bar, which will display how much of a certain need we have left. The other is text, to provide more information about the need.
  4. Resize the progress bar to fit your needs and change its size by setting the X to 300 and the Y to 45 and height under Transform in the Inspector.

Godot Progress Bar UI in Godot survival game

Setting up The Progress Bar

Now that we have our progress bar setup, there are a few tweaks we need to make to ensure it behaves and is displayed as expected within our Godot survival game:

  1. Begin by disabling the ‘Show Percentage’ option, as we don’t want to display the percentage.
  2. Modify the Background and Fill styles. For the background style, create a new ‘Style Box Flat’ and give it a dark color. Repeat the process for the Fill style, but this time give it a reddish color or any color that suits your needs.
  3. Add text to the progress bar using a ‘Label’ node, which is essentially just text. Resize the label node to fit the bounds of the progress bar, and give it an example text.
  4. Center align the text horizontally and vertically. Increase the font size for better visibility and give it a dark outline to contrast against the background.

Need bar with the Health progress displayed

Coding the need UI Bar

With the progress bar properly setup, we now need to code our Need UI Bar to control the UI in our Godot survival game:

// The Need UI Bar script:
var need_name: String
export(var) var text: Label = get_node("Need Text")

func update_value(new_value: int, max_value: int):
    max_value = max
    value = new_value
    text.text = str(need_name, ": ", value, "/", max_value)

The script begins by creating two variables: a `need_name` string and a label text for displaying current and maximum values. It then includes the `update_value()` function which updates the UI every time it’s called.

Lastly, save the ‘Need Bar’ as a scene in the file system to make it reusable for health, hunger, thirst, and sleep bars.

In the next tutorial, we’ll show you how to create all the different bars and set up a script for managing the values and regenerating and decaying over them over time.

This demonstrates the creation of a basic needs system in Godot. Remember, Godot allows ample customization, so feel free to tweak this design to meet the exact needs of your game.

Player Needs – Part 2

In this Godot survival game tutorial, we will continue setting up our UI bars. This tutorial will guide you on how to create, delete, and manage bars that display player needs such as health, hunger, thirst, and sleep. Moreover, it will illustrate how to create a script that manages each need, updates the UI, and modifies their attributes.

Setting Up UI Bars

  • Start by cleaning up your scene, getting rid of nodes you may not need.
  • Drag your UI bar node into the scene and make it a child of the player needs node. You can adjust its position as needed.
  • Create a basic node that acts as a container for data. This node will not have a positional or rotational scale attributed to it. This basic node will be named according to the need it represents such as ‘health’.
  • Next, make the need bar a child of the newly created basic node.
  • For each need (health, hunger, thirst, sleep), duplicate the health node and adjust their names and positions accordingly.
  • Label each of these bars as per their corresponding need.

Multiple needs bars for Godot survival game

At this point, you can test your settings by running the UI. The bars should render on the screen displaying their respective needs.

Creating a Need Management Script

Our next step for our Godot survival game needs system is to create a script that constantly manages the value of each need, how the value changes over time, and updates the UI accordingly.

class_name Need

var value : float
var max_value : float
var start_value : float
var regen_rate : float
var decay_rate : float
var UI_bar : Node
  • value: This variable represents the current value of the need.
  • max_value: This variable represents the maximum value that the need can reach.
  • start_value: This variable is set to an initial value at the start of the game.
  • regen_rate: This variable helps in increasing the value of a need over time. Useful for needs like ‘sleep’ where the value has to increase over time.
  • decay_rate: This variable helps in decreasing the value of a need over time. Useful for necessities such as ‘hunger’ and ‘thirst’ that decay over time.
  • UI_bar: This variable references the UI bar being managed, which is a child of the needs node.

The script also includes functions to add, subtract and update UI bars.

function add(amount : float) -> void:
    value += amount
    if value > max_value:
        value = max_value

function subtract(amount : float) -> void:
    value -= amount
    if value < 0:
        value = 0

function update_UI_bar() -> void:
    UI_bar.update_value(value, max_value)

Modifying Need Attributes

As the next step in our Godot survival game tutorial, we need to turn back to the engine itself and adjust some settings in the Inspector.

  • Select the node corresponding to each need and fill in their attributes in the inspector as per requirements.
  • Configure the max value, start value, regen rate, and decay rate for each need.
  • To link the UI bar to each need, drag the corresponding UI bar into the UI_bar field in the inspector.
  • To customize the look of each need bar, change the color in the ‘theme overrides’ section in the inspector accordingly.

Health bars with customizations in Godot 4 survival game

Once these steps are complete, your UI bars for player needs are all set up and on screen. In the next section, we will learn how to increase and decrease these values and make sure the visual representation corresponds to these changes.

Player Needs – Part 3

We’re now ready to finish the needs system for our Godot survival game with some additional functionality to actually decay the needs.

Step 1: Start with the Baselines

Firstly, we will initiate the process by selecting the ‘Player Needs’ node we’ve created. In the inspector, we will create a new script named ‘Player Needs’.

Step 2: Set up Variables

Inside the ‘Player Needs’ script, create variables corresponding to each need. For instance:

var health: Need
var hunger: Need
var thirst: Need
var sleep: Need

We also require additional variables to handle the health decay over time, once hunger and thirst hit zero. These variables could look something like:

var no_hunger_decay: float
var no_thirst_decay: float

Step 3: Scripting Initial Values

In the ‘ready function’, we would get and store each ‘Need’ node inside the variables and set their initial values. The code could look like:

health = get_node "health"
health.value = health.start_value

Step 4: Implement Time-Based Modifications

In the ‘Process function,’ we establish modifications to our needs over time:

hunger.subtract(hunger.decay_rate * delta)
thirst.subtract(thirst.decay_rate * delta)
sleep.add(sleep.regeneration_rate * delta)

Step 5: Regulate Health Decay

If the hunger or thirst hit zero, we’d initiate health depletion. You can use conditions:

if hunger.value == 0:
    health.subtract(no_hunger_decay * delta)
if thirst.value == 0:
    health.subtract(no_thirst_decay * delta)
if health.value == 0:

Step 6: Adding Functionality

To further develop the needs system, you can add functionality such as eating food or sleeping. For instance:

func eat(amount: int):

This basic player needs system serves as a robust foundation for any Godot survival game. You can expand and customize it to fit your specific needs. Keep in mind that this system is intended to be used in conjunction with other systems like a damage system.

In conclusion, a player needs system is an integral part of any survival game, and building one with Godot can be quite intuitive and straightforward. Following the outlined steps can help create an immersive gaming experience that keeps players engaged.


And with that, we conclude this tutorial. We hope it was useful in helping you understand how to set up and implement an interactive player needs system using the Godot game engine. Now that you have constructed a basic needs system, you can use it as a blueprint to further tailor the attributes and behaviors of each need to precisely fit your game’s requirements.

Never forget, the horizon of customization in Godot is extremely broad, and you can tweak the system to the exact detail for your Godot survival game. Additionally, you can build on this foundation to integrate more complex elements like a damage system or an energy system.

We’re excited about what you’ll create, and we hope to see your Godot survival game in action soon. Good luck with your gaming project, and remember – the game-making journey is just as fun as playing the game!

Want to learn more? Try our complete EXPLORE MICRO-SURVIVAL GAMES WITH GODOT 4 course.


Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Unreal, Python, Godot and more.