
## How many players are online?

Knowing how many players are currently playing your game is something that almost everyone wants to know. It's always great to see player counts climbing, especially after new updates or announcements.

But how can you track this? You could build your own tracking system, but that's time-consuming and complex - you've got a game to build! That's why we built [Talo](https://trytalo.com), a game backend platform that makes it easy to understand player behaviour and gain oversight over your game's data. In this tutorial, we'll show you how to use Talo to track player counts in your Godot game.

## Online player counts with Talo

Talo makes it easy to segment your players using [player groups](https://trytalo.com/players#groups). You can use player groups to create distinct buckets of players. For example, in this tutorial, you'll use player groups to check for players with a custom "online" property.

When your Godot game starts, you'll identify the player and set the "online" property to `true`. When they exit the game, you'll set it to `false`. Using Talo's new pinned groups feature in the dashoard, you can see the number of players in the "online" group in real-time.

## Setup the Talo Godot plugin

You need to start by setting up the Talo Godot plugin. You can do this by downloading the plugin from the [Godot Asset Library](https://godotengine.org/asset-library/asset/2936) (or by searching "Talo Game Services" in the `AssetLib` tab of the Godot editor). You can also find the latest version of the plugin on [itch.io](https://sleepystudios.itch.io/talo-godot).

![Install Talo from the AssetLib tab](/blog/live-player-counts-godot/install-assetlib.png)

Once you've downloaded the plugin, import it (typically you want to install plugins under the `addons` folder) and enable it in the `Project > Project Settings > Plugins` window.

![Enable the Talo plugin in the project settings](/blog/live-player-counts-godot/install-enable.png)

You can now run your game - this will create a `settings.cfg` asset inside the folder where you installed the plugin - you'll need this later. To learn more about how to configure Talo, including how to configure your self-hosted version, [check out the docs](https://docs.trytalo.com/docs/godot/install#create-and-update-settings).

### Generating an access key

Next you need to generate an access key for your game. Visit the [Talo dashboard](https://dashboard.trytalo.com), login or create an account (and confirm your email address). Once logged in, create a new game (if you need to) and visit the Access Keys page.

Once there, choose the scopes available to your access key. For this tutorial, you'll need the `read:players` and `write:players` scopes. Create your access key and copy it into the `access_key` field of the `settings.cfg`.

## Creating your group

Talo players can have properties ([known as props](https://trytalo.com/players#props)) that persist between sessions. As long as you know who the player is, you can set and get these properties. Player groups are able to read these properties and adjust the group's members accordingly.

To create your group, click the `Services` dropdown and go to `Groups`. Create a new group where you check for the `online` prop being equal to `true`. After creating your group you can pin it to your dashboard so you can see the online player count from the dashboard homepage.

![Creating your player group in the dashboard](/blog/live-player-counts-godot/group-setup.png)

## Setting up the game logic

All you need for this tutorial is a scene with a single root node, for example a `Node2D`. Attach a script to your root node with the following content:

```gdscript
extends Node2D

@export var username: String = "username"

func _ready() -> void:
  # prevent Talo from exiting before our online prop logic runs
  Talo.settings.set_value("", "handle_tree_quit", false)

  Talo.players.identified.connect(_on_identified)

  # identify who the player is
  Talo.players.identify("username", username)

func _on_identified(_player: TaloPlayer) -> void:
  # set the prop now that we know who the player is
  await Talo.current_player.set_prop("online", "true")

func _notification(what: int):
  match what:
    NOTIFICATION_WM_CLOSE_REQUEST:
      # update the prop before quitting
      await Talo.current_player.set_prop("online", "false")
      get_tree().quit()
```

This script does the following:
1. Sets the Talo `handle_tree_quit` property to `false`. By default Talo will listen for the `NOTIFICATION_WM_CLOSE_REQUEST` notification to run cleanup operations and then exit. However in this case, the online property should be updated first before the game exits.
2. Identifies the player using the `username` service. The player's username can be customised using the export variable.
3. Once the player is identified, their `online` property is set to `true`. At this point they should be in the "Online players" group you created earlier.
4. If the player closes the game, their `online` property is set to `false` and the game is exited. They will no longer be part of the "Online players" group.

## Testing the online player count

You can now open your game, go to the dashboard, and see the "Online players" group count is 1. If you close the game, it will reset back down to 0. As mentioned earlier, the group can be pinned to your dashboard so you can always see the online player count when visiting the Talo dashboard.

![Pinned online player count in the Talo dashboard](/blog/live-player-counts-godot/pinned-group-dashboard.png)

## Making oversight easy

Talo is designed to be extremely flexible in the way it provides observability and oversight to you. You don't need to spend hours building your own tools when you can just use Talo and the customisable groups to drill down into specific player behaviours.

If you're building a game and you want more oversight over it, come and join our [Discord community](https://discord.gg/2RWwxXVY3v) or follow us on [GitHub](https://github.com/TaloDev) to keep up to date with how we're improving Talo to make game development fun, easy and observable.


Ever wondered how many players are current playing your game? Talo makes it easy to find out!

How to see live online player counts in your Godot game


## A simple but robust game save system

Building a save system is something most game developers will end up doing. Saving and loading data is a fundamental part of game development and can be used for a variety of things such as saving player progress, storing game settings or even saving the state of the game world. There's hundreds of tutorials and ways of approaching this but that doesn't mean you need to roll your own code.

A good save system is built on 3 main principles:
1. **Flexible**: it should be easy to save and load any type of data from anywhere in your game.
2. **Observable**: you should be able to inspect what's being saved and loaded to better understand the state of your game.
3. **Secure**: players should not be able to tamper with their saves. Typically this means saving data on a server but that may prevent players from playing offline.

Building the system described above can be time consuming and complex. That's why we built [Talo](https://trytalo.com) - a game backend platform that makes it easy to save and load game data. In this tutorial we'll show you how to use Talo to save and load game data in your Godot game.

For more information on Talo's save system, [check out the docs](https://trytalo.com/saves).

## Game saves using Talo

Talo uses all the principles we've outlined above to make it easy to manage saves in your game:

* Talo lets you have direct control over what data you save and how it's subsequently loaded in.
* Talo provides a dashboard where you can see all the data being saved for a player, making it easier to debug save issues.
* Talo is secure: saves can be created, updated and deleted via the [Godot plugin](https://trytalo.com/godot).
* Talo creates encrypted offline saves that are synced up when the player is online.

## What are we building?

In this tutorial you'll build a simple project that shows creating a save, updating a save and loading a save. The project will have some buttons, each of which can be clicked to increase the number they display. We'll save the state of each button and load it when the game is restarted.

![The demo project you'll be building](/blog/game-saves-godot/saves-demo.gif)

## Setup the Talo Godot plugin

To start saving and loading state, you need to set up the Talo Godot plugin. You can do this by downloading the plugin from the [Godot Asset Library](https://godotengine.org/asset-library/asset/2936) (or by searching "Talo Game Services" in the `AssetLib` tab of the Godot editor). You can also find the latest version of the plugin on [itch.io](https://sleepystudios.itch.io/talo-godot).

![Install Talo from the AssetLib tab](/blog/game-saves-godot/install-assetlib.png)

Once you've downloaded the plugin, import it (typically you want to install plugins under the `addons` folder) and enable it in the `Project > Project Settings > Plugins` window.

![Enable the Talo plugin in the project settings](/blog/game-saves-godot/install-enable.png)

You can now run your game - this will create a `settings.cfg` asset inside the folder where you installed the plugin - you'll need this later. To learn more about how to configure Talo, including how to configure your self-hosted version, [check out the docs](https://docs.trytalo.com/docs/godot/install#create-and-update-settings).

### Generating an access key

Next you need to generate an access key for your game. Visit the [Talo dashboard](https://dashboard.trytalo.com), login or create an account (and confirm your email address). Once logged in, create a new game (if you need to) and visit the Access Keys page.

Once there, choose the scopes available to your access key. For this tutorial, you'll need the `read:players`, `write:players`, `read:gameSaves` and `write:gameSaves` scopes. Create your access key and copy it into the `access_key` field of the `settings.cfg`.

![Creating a new access key in the Talo dashboard](/blog/game-saves-godot/access-key.png)

### Setting up the scene

Let's start by creating a new scene with a `Node2D` root and add a `Control` node that has a `Button` node child. Each button will display the number of times the button has been clicked. Here's the structure of the scene:

![Scene structure in Godot](/blog/game-saves-godot/scene-structure.png)

We've used a grid container so we can layout the buttons in a 3x2 grid. You can use any layout you like, but make sure you have a `Button` node nested under a `Control` node.

For reference, here's our `.tscn` [file for this scene](https://gist.github.com/tudddorrr/2a16d1ab9f4382abbd9012a1f1deb3ec).

### Making buttons loadable

You'll only need two scripts for this demo: one for our buttons and one for managing state.

Let's start with the button script. This script will handle the button's state and update the button's text when clicked. Here's the script you should attach to the `Control` node (the parent of your `Button` node):

```gdscript
class_name LoadableButton extends TaloLoadable

var button: Button
var clicks: int = 0

func _ready() -> void:
  super()
  button = get_child(0)

func register_fields() -> void:
  register_field("clicks", clicks)

func on_loaded(data: Dictionary) -> void:
  clicks = data["clicks"]
  button.text = "%s clicks" % clicks

func _on_button_pressed() -> void:
  clicks += 1
  button.text = "%s clicks" % clicks
```

This script extends `TaloLoadable`, a helper class provided by the Talo plugin. `register_fields` tells Talo what fields to save and `on_loaded` is called when the object is loaded.

You'll need to connect up the `pressed()` signal on your `Button` child node to the `_on_button_pressed` method in the script. You'll also need to add a unique identifier for your button so that Talo knows which button it's saving and loading. You can do this by setting the `ID` property in the inspector (you could also do this via the script):

![Setting the ID property in the Godot inspector](/blog/game-saves-godot/loadable-id.png)

At this point you can duplicate your button container as many times as you like (we're going for 6) and set the `ID` property to a unique value for each button.

### Managing the state

Next, you'll need a state manager to handle loading saves, saving the game state and updating the game state. Create a new script and attach it to the root node of your scene. Here's the script:

```gdscript
extends Node2D

@export var username: String = "username"

func _ready() -> void:
  Talo.players.identified.connect(_on_identified)
  Talo.players.identify("username", username)

func _on_identified(_player: TaloPlayer) -> void:
  var saves = await Talo.saves.get_saves()
  if saves.is_empty():
    await Talo.saves.create_save("save", {})

  await Talo.saves.set_chosen_save(Talo.saves.all.front())
```

This simple script identifies the player using the `username` property. It then fetches the player's saves and creates a new save if the player doesn't have any. Finally, it sets the chosen save to the first save in the list.

You'll need to update the `LoadableButton` script before you can fully test this out. Update the `_on_button_pressed` method to update the save when it's clicked:

```gdscript
func _on_button_pressed() -> void:
  clicks += 1
  button.text = "%s clicks" % clicks
  await Talo.saves.update_current_save() # update the save
```

### Checking the finished demo

All of the logic is now ready. You can run your game and start clicking the buttons. You should see the number of clicks persist between runs. If you want to test the offline save feature, you can run the game, disconnect from the internet and click the buttons. When you reconnect to the internet and run the game again, you should see the number of clicks persist.

With Talo, you can easily see the content of your save directly in the dashboard. Simply login to the dashboard, head over to the `Players` service, go to your player's profile and choose `Saves`. You should be able to see a visual representation of the data saved for your player:

![The player's save content in the Talo dashboard](/blog/game-saves-godot/save-content.png)

## Summing things up

How quick was that!? Using just two scripts, we've shown how easy it is to save and load data with Talo. We've covered how to set up the [Talo Godot plugin](https://trytalo.com/godot), create a save, update a save and load saves. You can now extend this script to work with other objects and add more properties. You could even think about automatically setting the `ID` property on your buttons to make it easier to manage.

Saves are just one of the features Talo provides. You can also use Talo to manage player data, leaderboards, achievements and more. If you're building a game that needs persistence or want to make more data-driven decisions, join our [Discord community](https://discord.gg/2RWwxXVY3v) or follow us on [GitHub](https://github.com/TaloDev) to keep up to date with the latest and greatest releases for our open source game backend.


A quick and easy example of how to use Talo to handle online and offline game saves.

How to load and save game state using Godot


## Steamworks authentication is here!

We've added a new way of authenticating Steam users in Talo directly through Steamworks. Talo can now automatically pull in a player's Steam ID and sync it up with their Talo account.

### Talo's Steamworks integration

Previously, Talo's existing integration only allowed you to sync player stats and leaderboards with Steamworks. Now, you can identify players using an auth ticket from Steamworks and sync them up with Talo.

Talo takes care of validating the ticket and even checking the app ownership state for the player - work that you would typically need to do manually in game servers.

Want to learn more? Visit our [Steamworks page](https://trytalo.com/steamworks-integration) for a detailed integration overview and links to our documentation.

### Learn more about your player with props

Talo's [player props feature](https://trytalo.com/players#props) is a great way of persisting player data across sessions. When you authenticate a player with Steamworks, we'll automatically pull in ownership data for your game and store it as props. Ban statuses will also be stored as props.

Using these props, you can easily check if a player owns your game on Steam, whether they own it permanently and even if they're VAC banned.

![Steamworks props in the Talo dashboard](/blog/steamworks-authentication/steamworks-props.png)

## New releases this month

We've been working hard on moving towards a 1.0 "stable" release across our dashboard, backend, Godot plugin and Unity package. Here are some of the things we've worked on in September:

### Feedback exports

You can now export game feedback from the Talo dashboard. This is a great way of keeping track of player feedback and sharing it with your team or community.

### New save content viewer

The Talo dashboard now has an updated save content viewer, allowing you to see the contents of a save file in a human-readable format. This is a great way of debugging save data and understanding what's being stored. The new viewer allows you to search for specific data too!

![Save content viewer in the Talo dashboard](/blog/steamworks-authentication/save-content-viewer.png)


### Deleting Talo auth accounts

Players can now delete their Talo auth accounts in-game, allowing them to be in control of their data. Talo takes care of anonymising the alias while preserving data that belongs at a player-level intact. 

### Leaderboard entry props

[Leaderboard](https://trytalo.com/leaderboards) entries can now have props attached to them. This is a great way of storing additional data about a player's entry, such as the character they used, the level they played or the team they were on. Props act in the same way player props and event props work, allowing you to send arbitrary data that will also be displayed in the Talo dashboard.

![Leaderboard entry props in the Talo dashboard](/blog/steamworks-authentication/leaderboard-entry-props.png)

### Godot plugin updates

This month, we've put a focus on the first time user experience of setting up [the plugin](https://trytalo.com/godot). We've added new helpful log messages to make sure your setup is correct and you're ready to start using Talo in your Godot game.

Concurrent API requests are now better supported and we've made the debugging experience more informative by naming Talo nodes in the remote scene tree.

The leaderboards sample has also been updated to show how to use the new leaderboard entry props feature. In the new demo, a "team" prop is attached to all entries and you can filter leaderboard entries by team.

### Unity package updates

On top of lots of small fixes, [the Unity package](https://trytalo.com/unity) has added support for encrypted offline saves. Saves are now encrypted by default, significantly reducing the likelihood of save file tampering.

Similarly to the Godot plugin, the leaderboards sample has been updated to showcase the new leaderboard entry props feature. We've also made some minor improvements to the demo for easier debugging.

## Join our community

Adding Steam auth was a community suggestion from [Discord](https://discord.gg/2RWwxXVY3v). Come join us to talk about what you're working on, share feedback, and get the latest updates. We're always looking for ways to improve Talo and make it work better for you.


You can now identify Steam players and sync them up with Talo. Plus, an overview of new releases this month.

Steamworks authentication is now available


## Continuity is here!

Talo Continuity is a resilience layer to keep your game and data in sync when Talo can't be reached. Continuity ensures that your game can continue to function even when there are network issues or Talo is temporarily unavailable.

### How does it work?

Continuity is a simple cache that automatically runs in the background. When Talo is available and your player is online, your game will run as normal. When Talo is unavailable or your player is offline, Continuity will store your data locally and sync it with Talo when a network connection is re-established. Your game will be able to run as normal and you won't have to manually catch and handle network errors.

Talo will keep track of when the request was originally made and will ensure timestamps are correctly reflected in your data. This means that your data is always kept accurate and up-to-date.

### Configuring Continuity

We've made Continuity easy to configure: you can enable or disable Continuity based on what makes sense for your game.

It's also really easy to see Continuity in action. You can simulate network connectivity issues by toggling the Offline Mode and Continuity options in the sample scenes available in our [Unity package](https://trytalo.com/unity) and [Godot plugin](https://trytalo.com/godot).

![Continuity logs in the Godot editor](/blog/continuity-announcement/continuity-logs.png)

### Now available in the Talo Godot plugin

Continuity is now available in the Talo Godot plugin (version 0.6.0). You can download the latest version of the plugin from the [Godot Asset Library](https://godotengine.org/asset-library/asset/1016). You can also download the plugin directly from our [itch.io page](https://sleepystudios.itch.io/talo-godot).

We're currently working on adding Continuity to the Talo Unity package and we'll be releasing an update (including some other big improvements) very soon.

## Join our community

Join us on [Discord](https://discord.gg/2RWwxXVY3v) for all the latest Talo updates, to share your feedback or even just to talk about what you're working on.


Continuity is a new resilience layer for keeping your game data in sync.

Introducing Talo Continuity

Highlights from October 2024’s releases

Sign up

Changelog: Player groups API, pinned groups and Godot saves demo

October 2024 overview

Dashboard updates

Backend updates

Godot plugin updates

Unity package updates

Have your say: join the community

Get started

More from the Talo Blog

How to see live online player counts in your Godot game

How to load and save game state using Godot

Steamworks authentication is now available

Introducing Talo Continuity