DEV Community: Godot

Online Visual Novel in Godot: Case Study on Sentou Gakuen

Godot — Thu, 10 Oct 2024 19:52:26 +0000

When you talk about visual novel games, you'd normally think of a static story-driven experience, often with branching paths and multiple endings. You may have hundreds of routes but ultimately designed for solo play. It is why some people consider that visual novel as a genre isn't a game, but more of an interactive storybook.

However, what if you could take the concept of a visual novel and turn it into an online interactive experience?

In this short case study, we will focus on how Sentou Gakuen, an online visual novel developed in Godot Engine, attempts to redefine the genre. We'll explore some of the challenges involved and why this approach was chosen for the project. Let's dive in!

Traditional Visual Novels

Visual novels are well-established in game development—often comprising rich narratives, multiple routes, and player choices that influence outcomes. There are various engine options for creating visual novels, such as Ren'Py, TyranoBuilder, Unity, and Godot Engine is no different. With Godot Engine, numerous developers have created compelling and visually stunning visual novels that allow players to dive deep into story-driven experiences. However, when we introduce the concept of online interactivity into a visual novel, a whole new set of challenges emerges.

Gameplay: Dynamic vs. Static

Traditional visual novels are primarily static, designed around branching paths and predefined outcomes. They typically consist of:

Linear Narratives: While choices may lead to different routes, all possibilities are predetermined. Time, place, and location depends on how are you progressing through the story.
Single-Player Focus: The game is designed for one person to play at their own pace, with no impact from other players. Players are limited to the choices provided by the game, with no real-time interactions or shared experiences.

In contrast, Sentou Gakuen introduces dynamic mechanics:

Shared World: Player actions influence not just their experience, but the experience of others, similar to a multiplayer RPG. The world has day and night cycles, when it's morning for one player, it's morning for everyone.
Community Interaction: Players can communicate through an in-game chat system, post on community boards, and engage in shared events.

This kind of shared experience requires a different design approach. The narrative isn't purely about routes but rather a fluid storyline influenced by the cumulative actions of many players.

Interactive Visual Novels

This paradigm shift from a static, single-player experience to a dynamic, shared world introduces a host of technical and design challenges such as, but not limited to:

A Persistent World: In a multiplayer setting, ensuring that all players experience the same world state at the same time is crucial, preventing discrepancies that could disrupt immersion.
Keeping the World Alive: Creating a lively and dynamic environment, ensuring the game world feels active and interconnected, even when players are exploring alone.
Communication: Effectively managing player communication in a way that aligns with the visual novel's narrative style while accommodating simultaneous interactions.
Player versus Player (PvP): Integrating competitive elements into a visual novel in a way that complements the narrative-driven experience rather than overshadowing it.

Let’s delve into how the game tackles these obstacles to redefine the genre.

Key Challenge: A Persistent World

In traditional offline visual novels, time and location are tightly controlled by the player’s individual progression through the story. The world revolves around the player, and events occur based solely on where they are in the narrative. However, Sentou Gakuen presents a dynamic world where multiple players interact in real time. This shift from static storytelling to a shared world creates a unique challenge: making sure that all players experience the same world state at the same time.

The Problem: Synchronization in a Dynamic World

In Sentou Gakuen, the world needs to be consistent for everyone. For example, if it’s morning for one player, it should be morning for everyone else in the game. Similarly, if a bank is open for business, it has to be open for every player, not just those at a particular point in the story. Having players exist in different “times” would break immersion and create confusion. This required a solution to keep everyone on the same page regarding the state of the game world.

The Solution: Real-Time Synchronization Using Unix Timestamps

To address this challenge, a simple yet effective solution was implemented: Shared Timestamps. By using a common time reference, the game ensures that all players experience the same time of day, the same events, and the same world state. This simple mechanism keeps the world persistent and coherent, even as multiple players interact with it simultaneously.

Key Challenge: Keeping the World Alive

What makes a game world feel alive? It’s the sense that things are happening, even when you’re not around. This is not a concern in single-player games, where the world revolves around the player. But in a shared online environment, that's not the case.

The Problem: Making it Feel Lively

In a multiplayer game, one of the challenges is ensuring the world feels alive and dynamic. Players need to feel like they are part of an active, bustling world, even if there are no other players around at the same time. A static world can quickly become boring, leaving players feeling disconnected from the community.

The Solution: The World Full of Happenings

To make Sentou Gakuen feel lively, each zone in the game features an interface that logs recent events and activities that other players have completed. While not updated in real time, these logs show what players have done in that zone, such as someone being defeated in a brawl or completing a particular event. By displaying these “happenings,” the game creates a sense of a constantly evolving world, making players feel part of a larger, active community. This feature not only adds immersion but also encourages players to engage with the world, knowing their actions contribute to its evolving story.

Furthermore, the faction system enhances the dynamism of the game world. Players can join one of two factions: Hikari or Yami. Zones in the game have a "controlling faction," determined by which faction has the most presence in that zone. By simply being online in a particular zone, players contribute to their faction’s influence. For example, if a player from Yami is in the School Gate zone, they increase Yami's influence there.

The dominant faction in a zone rewards its members with buff, encouraging faction members to compete for control of different zones. This ongoing power struggle ensures the game world remains dynamic, with faction control shifting based on player participation, creating an evolving landscape for players to interact with.

Key Challenge: Chat System Integration

One of the biggest challenges in creating an online visual novel is handling player communication in a way that fits the traditional visual novel style. In a normal visual novel, character dialogues are presented with neatly formatted text boxes that pop up one at a time, allowing players to fully absorb the conversation at their own pace. Initially, The project aimed for a similar experience, where player chat messages would appear as dialogues, just like when a character speaks in the game. However, this approach quickly ran into significant issues.

The Problem: Managing Concurrent Chats

In Sentou Gakuen, multiple players are interacting with each other simultaneously, and when there's a lot of chatter happening at once, it can be challenging to keep up with the conversation. The traditional visual novel dialogue box system, while great for presenting character dialogues, wasn't well-suited for handling real-time player interactions. Players could easily miss messages or get lost in the conversation, leading to a disjointed experience.

The Solution: Transition to a "Chat Box"

To solve this problem, a decision to add seamless transition from visual novel-style dialogue boxes to a more conventional MMO chat box system was made. This allowed players to keep up with ongoing conversations more naturally, while still being able to engage with the story and interact with other players. The chat box will replace the dialogue box automatically when there's too much chatter happening in the game, and players can switch between the two as needed.

This compromise maintained the essence of a visual novel while accommodating the realities of multiplayer communication. Players could enjoy the rich story elements without losing track of real-time conversations happening within the game.

Key Challenge: Player versus Player

How do you introduce competitive elements into a visual novel without compromising the experience? PvP mechanics can add depth and excitement to a game, but in a genre focused on storytelling, it’s essential to find a balance that keeps the narrative at the forefront while still providing engaging gameplay.

The Problem: Can this be done?

Integrating Player versus Player (PvP) mechanics into a visual novel is a concept that has rarely, if ever, been explored. Most visual novels focus on narrative-driven experiences, often limiting player interactions to choices and branching paths. Adding competitive elements introduces a challenge: how can we incorporate PvP in a way that feels natural and maintains the essence of a visual novel, rather than turning it into a traditional combat game?

The Solution: Asynchronous PvP

While Sentou Gakuen doesn't feature direct real-time PvP, it introduces indirect, asynchronous PvP that still fosters competition in two key ways:

Players can create their own loadout and participate as challengers. Once enrolled, other students can challenge these pre-set loadouts in turn-based combat. This system allows for strategic battles without the need for both players to be online simultaneously.
In school zones, players have a chance to "appear" as a mob in another player’s instance during a fight. This simulates PvP encounters in a controlled environment and adds a personal touch to otherwise AI-controlled battles. If preferred, this feature can be turned off for those who want to avoid appearing in others' instances.

Key Challenge: What Engine to Choose?

Godot Engine was chosen for Sentou Gakuen for several reasons:

Flexibility: The engine’s open-source nature and robust feature set made it possible to implement complex systems and mechanics that would have been challenging in other engines.
Networking with GodotSteam: The game utilizes GodotSteam, leveraging the Steamworks API to handle networking functionalities. This integration simplifies the implementation of multiplayer mechanics and ensures a seamless online experience.
Ease of Use: Godot’s GDScript made it easy to prototype and iterate on game systems, allowing for rapid development and testing of new features.
Cross-Platform Compatibility: Godot’s support for multiple platforms ensures that the project can reach a wide audience, regardless of the system they’re running.

And while Godot Engine was the choice for the project, it’s essential to evaluate the engine based on the specific needs of your project. Each engine has its strengths and weaknesses, and choosing the right one can significantly impact the development process and the final product.

Wrappping Up

Creating Sentou Gakuen in Godot was a journey of pushing the boundaries of what a visual novel can be. While traditional visual novels focus on static routes and single-player experiences, Sentou Gakuen aimed to create a shared, interactive story space where every player’s actions could influence the wider game world. Godot’s flexibility allowed the project to achieve that vision, even though it came with challenges.

This case study highlights possibilities for future visual novel projects, showing that the genre can evolve beyond its traditional roots to create engaging, dynamic experiences that bring players together in new and exciting ways. Visual novels can become more than just interactive storybooks!

Sentou Gakuen: Revival on Steam

You are one of the students of Sentou Gakuen, a random school in Japan, filled with delinquents, rascals, and of course some good students. How will you spend your days in Sentou Gakuen? Forge your own path in this online interactive Visual Novel, make friends or foes, the choice is yours.

store.steampowered.com

If you’re interested in exploring the world of Sentou Gakuen, you can check out the game on Steam here or join the Discord, while the final release date is yet to be announced, in the meantime you can try the demo to get a taste of what’s to come.

Godot 4.2.1 Maintenance Release Overview

Godot — Tue, 12 Dec 2023 12:57:10 +0000

Godot 4.2.1, the latest maintenance release, is now available, focusing on resolving platform compatibility issues introduced in Godot 4.2. The update aims to facilitate smoother upgrades from version 4.1 and supports new projects across all platforms.

Key Fixes:

GL Compatibility Renderer on macOS:
- Reverted the default backend from ANGLE's Metal back to native OpenGL drivers due to issues introduced by ANGLE's Metal backend.
macOS One-Click Deploy:
- Addressed freezing issues caused by the Xcode install dialog during iOS one-click deploy by switching to mdfind for Xcode presence checks.
Vulkan Renderer on Android:
- Resolved crashes and mesh corruption issues in Vulkan renderers on Android, potentially fixing problems with tilemap rendering on specific Android devices.
Godot Jolt Addon Compatibility:
- Introduced a workaround for compatibility issues with Godot Jolt addon, preventing crashes during project upgrades. Users are advised to update Godot Jolt to the latest version (0.11.0).
TileMap Occluders:
- Fixed a regression related to TileMap occluders, addressing issues present in the handling of these elements.
Emscripten Web Export:
- Adjusted linker flags to address issues introduced by recent Emscripten releases, ensuring successful compilation and execution.

Additional Changes:

A total of 42 contributors made approximately 74 improvements for this release.
The comprehensive list of changes is available in the interactive changelog.

Download:
Be sure to check out the original page for more details and to download the latest version of the engine.

Known Incompatibilities:
No known incompatibilities exist with previous Godot 4.2.x releases. Users are encouraged to upgrade to 4.2.1. Report any unexpected behavior on GitHub.

Support:
Godot is a non-profit, open-source project sustained by contributions from developers and donations from the community. Financial support can be provided through the Godot Development Fund, managed by the Godot Foundation. Appreciation is extended to all contributors and supporters.

Godot 4.2 Stable is Here!

Godot — Thu, 30 Nov 2023 13:12:24 +0000

Godot 4.2 is finally here, packed with exciting features and improvements for game developers. With over 1800 improvements submitted by 359 contributors, this release is a testament to the dedication and passion of the Godot community.

New Features and Improvements

Let's dive into some of the most significant highlights of this release:

Code Regions in the Code Editor

One of my personal favorites in this release is the addition of Code Regions for GDScript in the code editor. This feature allows you to break up your scripts into named, foldable blocks for better organization and navigation.

Critical and Breaking Changes

While the Godot team strives for seamless compatibility between releases, some breaking changes are inevitable. To help with the migration process, they've provided a migration guide for 4.2.

Core and Systems

This release focuses on stability, addressing design limitations, and fixing bugs related to renaming and moving files. Memory usage has also been optimized for projects using many plain Godot objects.

2D and 3D Features

New features for 2D games include integer scaling for pixel-perfect graphics and closed lines support for Line2D nodes.
In 3D, precise normals can now be calculated from raycast contact points using barycentric coordinates.

Animation Improvements

AnimationPlayer and AnimationTree have been unified under the new AnimationMixer node, addressing various issues and inconsistencies. Onion skinning has also made a return, allowing for better animation previews.

Navigation

The navigation system now supports 2D navigation mesh baking and multi-threaded baking for both 2D and 3D navigation meshes.

Tilemaps

Tilemaps receive a plethora of improvements, including new tools for flipping and rotating tiles, performance optimizations, and usability enhancements.

Editor and Usability

The editor has seen many improvements, such as better focus management, native file dialogs for desktop platforms, and an updated project manager.

GDExtension

GDExtension sees a host of new features, including in-editor hot reloading, Web platform support, and new API functionalities.

GUI and Theming

Focus management has been improved, and new features have been added to the GraphEdit node. Other improvements include seamless video looping and better image handling in RichTextLabel.

Import and Asset Pipeline

Changes to the asset importing process include better handling of import type changes, new import options, and improved GLTF support.

Input

Improvements to input handling include better mouse and focus event handling across multiple viewports and windows, as well as gamepad-related bug fixes.

Multiplayer and Networking

The high-level multiplayer system has been enhanced with better synchronization options and streamlined scene replication.

Porting and Platforms

New features for porting include one-click deployment for iOS, native file dialogs for desktop platforms, and a new architecture for Android that unlocks new features like multiple window support and quicker startup times.

Godot 4.2 is a significant release that brings a wealth of new features and improvements for game developers. There's too much to list here so be sure to check out the original page for more details and to download the latest version of the engine.

As always, if you'd like to support the Godot project financially, consider making a recurring monthly donation to help ensure its sustainability and continued development. Your contributions go a long way in making Godot better for everyone.

Godot 3 or Godot 4: Which Version Should You Choose?

Godot — Fri, 15 Sep 2023 19:19:57 +0000

Godot 3 and Godot 4, two major versions of the engine that offer different features and capabilities. The goal is to help you make an informed decision on which version to choose for your game development projects. So let's dive in and explore the world of Godot!

Comparison of Godot 3 and Godot 4

In this post, we'll be comparing the features, performance, and other aspects of Godot 3 and Godot 4. We'll also discuss the factors you should consider when choosing between these two versions for your game development projects.

By the end of this post (hopefully), you'll have a clear understanding of the key differences between Godot 3 and Godot 4, along with recommendations on which version to choose based on your project needs and preferences.

Godot 3

Overview and release date

Godot 3 was released in January 2018, and it brought a plethora of new features and improvements over the previous version. Some of the most notable additions include:

A new rendering engine with support for physically based rendering (PBR)
Visual scripting, which allows users to create game logic without writing code
Support for the C# programming language

Key features

Here are some of the key features of Godot 3:

GLES2 and GLES3 rendering backends: Godot 3 supports both OpenGL ES 2.0 and OpenGL ES 3.0 rendering backends, providing flexibility and compatibility with a wide range of hardware.
Visual scripting: This feature allows users to create game logic using a node-based visual interface, without writing any code.
C# support: Godot 3 introduced support for the C# programming language, allowing developers to write game logic and scripts using a familiar and powerful language.
3D improvements: The engine received a significant update to its 3D capabilities, including support for PBR materials, global illumination, and improved shadows.
Extensive documentation and community support: Godot 3 has a rich documentation and an active community that can help you with any issues or questions you might have.

Pros and cons of Godot 3

Pros:

Stable and mature
Extensive documentation and community support
Compatibility with older hardware
Visual scripting and C# support

Cons:

Limitations in performance and visual quality compared to Godot 4
Lacks some of the cutting-edge features found in Godot 4

Stability and maturity

Godot 3 is the current long-time support (LTS) version of the engine; it is stable and mature with years of development and testing behind it. This makes it a reliable choice for game development projects, especially if you're looking for a tried-and-tested solution that has been proven to work well.

Compatibility with older hardware

One of the key advantages of Godot 3 is its compatibility with older hardware. The engine supports both GLES2 and GLES3 rendering backends, making it suitable for a wide range of devices, including older smartphones and tablets.

Limitations in performance and visual quality

While Godot 3 offers a solid set of features and capabilities, it does have some limitations in terms of performance and visual quality compared to Godot 4. The newer version of the engine includes a more advanced rendering backend and various other improvements that can result in better performance and higher-quality visuals.

Godot 4

Overview and expected release date

Godot 4 is the current major release of the engine, and it introduced a host of new features and improvements over Godot 3. Some of the most notable changes include:

Visual Scripting is dead
A new Vulkan rendering backend
GDExtension, the successor of GDNative
Improved 3D capabilities
Enhanced UI and UX

Godot 4 initially released in March 2023. As for now, Godot 4.2 is currently in development.

Key features

Here are some of the key features of Godot 4:

Visual Scripting is Dead: In the latest iteration of Godot 4, the once-popular Visual Scripting feature has been entirely discontinued. This decision was made after extensive evaluation and feedback from the devs, which highlighted the need for a more streamlined and efficient approach to game development.
Vulkan rendering backend: Godot 4 introduces a new Vulkan rendering backend, which promises better performance and visual quality compared to the GLES2 and GLES3 backends used in Godot 3.
GDExtension and C++ support: The engine offers improved support for GDExtension, the successor of GDNative, making it easier for developers to write high-performance game code natively.
Improved 3D capabilities: Godot 4 features a host of improvements to its 3D capabilities, including support for real-time global illumination, volumetric fog, and improved shadows.
Enhanced UI and UX: The user interface and user experience in Godot 4 received a major overhaul, making it more intuitive and user-friendly. Godot 4 also adds multiple windows support which wasn't possible in the previous version (Godot 3 only supports single window mode).

Pros and cons of Godot 4

Pros:

Cutting-edge technology and performance
Improved visual quality
New Vulkan rendering backend
Enhanced UI and UX

Cons:

The Death of Visual Scripting
Potential compatibility issues with older hardware
Limited resources

Cutting-edge technology and performance

Godot 4 brings cutting-edge technology and performance improvements to the engine, making it an exciting choice for game developers who want to push the boundaries of what's possible with their projects.

Improved visual quality

Thanks to the new Vulkan rendering backend and various other enhancements, Godot 4 promises to deliver improved visual quality compared to Godot 3. This can be a significant advantage for developers who prioritize high-quality graphics in their games.

Potential compatibility issues

One potential drawback of Godot 4 is that the new Vulkan rendering backend may not be compatible with older hardware. This could be an issue for developers targeting a wide range of devices, especially older smartphones and tablets.

Limited resources

As Godot 4 is still new, the documentation, tutorials, and resources for the engine are currently limited, ie. undocumented changes, etc. This could pose challenges for developers who rely on these resources to learn and troubleshoot issues during development.

Factors to consider when choosing a version

When deciding between Godot 3 and Godot 4, there are several factors to consider:

Project requirements: Consider the specific needs of your project, such as performance, visual quality, and compatibility with target platforms.
Compatibility with target platforms: If you need to support older hardware, Godot 3's GLES2 and GLES3 rendering backends may be more suitable.
Development timeline: If you're working on a project with a tight schedule, you might prefer the stability and maturity of Godot 3.
Stability and maturity of the engine: Godot 3 is a stable and mature version of the engine, while Godot 4 is still in development and may have some bugs and issues.
Availability of documentation and resources: Godot 3 has extensive documentation and resources, while Godot 4's resources are currently limited.

As Godot 4 is steadily progressing towards its next significant milestone with the upcoming release of Version 4.2, it is becoming increasingly viable for developers to consider making the transition. When determining the best choice for your project, it is essential to weigh your specific requirements and preferences carefully. If you place a high value on stability, maturity, and compatibility with older hardware, then Godot 3 might be a more suitable option for your needs. However, if you are willing to embrace the cutting-edge, then making the jump to the latest version could be a strategic decision for your project's future success.

Ultimately, we encourage you to explore both versions and make an informed decision based on your project requirements and personal preferences. Happy game development!

Unity New Pricing in 2024 is Absurd

Godot — Tue, 12 Sep 2023 15:27:58 +0000

Unity’s new pricing update sparks controversy among developers

Unity, one of the most popular game engines in the world, has announced a new pricing and packaging update that will affect games that exceed certain revenue and install thresholds, according to the official blog post. It seems that this update aims to "align Unity's success with the success of our customers" and to "ensure Unity remains a sustainable platform for all developers".

The update introduces a runtime fee for games that generate more than $200,000 in revenue and have more than 200,000 installs in a month. The fee varies depending on the game's install count, ranging from $0.01 to $0.20 per install. Only games that meet the following thresholds qualify for the Unity Runtime Fee:

Unity Personal and Unity Plus: Those that have made $200,000 USD or more in the last 12 months AND have at least 200,000 lifetime game installs.
Unity Pro and Unity Enterprise: Those that have made $1,000,000 USD or more in the last 12 months AND have at least 1,000,000 lifetime game installs.

The update has generated a lot of discussion and criticism from the developer community, especially from indie developers who fear that the fee will hurt their profitability and creativity. Many users have expressed their opinions and concerns on Reddit, where the post has received hundreds of upvotes and hundred of comments.

This announcement has also unexpectedly sparked concerns among /r/gachagaming subreddit dwellers, as rerolling (effectively, reinstalling the game, over and over for a better account) is a very common practice in the community. The post has garnered hundreds of upvotes and comments combined.

Some of the common questions and issues raised by the users are:

How will Unity track and enforce the fee? What if users install games offline or on multiple devices?
How will the fee affect games that are sold at low prices or have large install bases? What if users uninstall and reinstall games frequently?
How will the fee impact Unity’s reputation and competitiveness? Will developers switch to other engines, such as Unreal Engine or Godot?
How will the fee affect the quality and diversity of games made with Unity? Will developers avoid making innovative or experimental games that might attract a large audience?
With the removal of Unity Plus, would that mean if developers want to remove Unity splash screen branding logo, they need to subscribe for Unity Pro ($2040/year)?

The update is expected to take effect in January 2024, giving developers some time to adjust their plans and expectations. However, many developers are already unhappy and worried about the future of Unity and their games.

TL;DR Keypoints:

The change doesn't really affect you if you are below threshold.
Will this fee apply to games using Unity Runtime that are already on the market on January 1, 2024? Yes, the fee applies to eligible games currently in market that continue to distribute the runtime. They will look at a game's lifetime installs to determine eligibility for the runtime fee and bill the runtime fee based on all new installs that occur after January 1, 2024.
Unity Runtime Fee: Starting from January 1, 2024, Unity will charge a small flat fee for each game install after the game has passed a minimum revenue and lifetime install threshold. The fee varies by region and subscription plan.
Unity Subscription Plans Update: In November 2023, Unity will add new tools and services to its subscription plans at no extra cost. These include Unity DevOps, Unity Asset Manager, Unity Sentis, and Team Administration.
Unity Plus Retirement: Unity Plus is no longer available for new subscribers as of September 12, 2023. Existing subscribers will receive an offer to upgrade to Unity Pro for one year at the same price.

So, are you using Unity3D right now?
What do you think about these upcoming changes?
Any plans on looking into different Game Engine?
Would you consider joining the Godot Community?

Update!: Marc Whitten wrote a blog post in September 22, 2023 as an open letter to the Unity community.

Here are the main points from Marc Whitten's statement:

Runtime fee is here to stay, with extra caveats, self-reported, or you can switch to 2.5% revshare instead.
Marc apologized for not speaking with more users before announcing the new Runtime Fee policy. The goal of the policy was to support users today and invest in the Unity engine.
Unity Personal will remain free with no Runtime Fee for games built on it. The revenue cap is increasing from $100k to $200k and the Made with Unity splash screen will be removed.
No game with less than $1 million in trailing 12-month revenue will be subject to the fee.
The Runtime Fee policy will only apply to the next LTS Unity version shipping in 2024. Games currently shipped and in development will not be included unless upgraded to the new version.
For games subject to the fee, users can choose either a 2.5% revenue share or an amount based on new monthly active users. Both numbers are self-reported. Users will be billed the lesser amount.
Marc invited users to join a fireside chat at 4:00 pm ET to answer questions and provide more details.

Please refer to the official blog post for more detail.

GDScript Cheatsheet

Godot — Sun, 10 Sep 2023 21:01:43 +0000

This cheatsheet is meant to be a handy reference for both beginners and experienced GDScript users. So, whether you're just starting out or looking to review up on your GDScript knowledge, this cheatsheet will be your go-to resource. We'll cover all the essential topics you need to know about GDScript, from basic syntax to advanced concepts, complete with code snippets and examples. So, let's get started!

Brief overview of GDScript

GDScript is a high-level, both static and dynamically typed programming language specifically designed for the Godot game engine. It's easy to learn, especially if you're familiar with Python, as its syntax and structure are quite similar. GDScript is powerful and versatile, allowing you to create complex game logic with minimal effort.

Some key benefits of using GDScript include:

Tight integration with Godot's engine and editor
Clear and concise syntax, allows you to focus on game development
Designed for rapid prototyping and iteration

Basic Syntax

Let's begin by going over the basic syntax of GDScript. Here are the topics we'll cover:

Comments

Single-line comments: # This is a single-line comment
Multi-line comments: For multi-line comments you need to prefix every line with # hash, sadly in GDScript there's no easier way. Be careful with """ three quotes """ while it looks like multi-line comments, it's actually a multi-line strings and will be silently executed by the interpreter!

"""
This is a multiline string, not a comment!
And thus it will be parsed by interpreter...
"""

# Now this
# is a multiline comments
# Interpreter will not read this

Basic Output

To print output in GDScript, use the print() function:

print("Hello, Godot!")

Indentation

GDScript uses indentation to define code blocks, just like Python:

func _init():
    pass

Variables

In GDScript, variables can be declared using the var keyword. You can also specify the type of the variable using a colon (:) followed by the type name.

Declare a variable: var my_variable = 10
Change the value of a variable: my_variable = 20
Declare a variable with a specific type: var my_int: int = 5

Here are some common data types in GDScript:

int: Integer numbers
float: Floating-point numbers
bool: Boolean values (true or false)
String: Text strings

var x: int = 42
var y: float = 3.14
var is_active: bool = true
var name: String = "https://godot.community"

Arrays and Dictionaries

GDScript also provides built-in data structures like arrays and dictionaries:

Array: Ordered list of elements
Dictionary: Key-value pairs

var my_array: Array = [1, 2, 3, 4, 5]
var my_dict: Dictionary = {"key1": "value1", "key2": "value2"}

Static Variables

Static variables belong to a class rather than an instance of the class. To define a static variables, use the static keyword:

Declare a static variable: static var my_static_variable = 30
Change the value of a static variable: my_static_variable = 40
Since statics belong to the class, you can also use MyClass.my_static_variable = 40

Constants

Declare a constant: const MY_CONSTANT = 100

Operators

Arithmetic

Addition: a + b
Subtraction: a - b
Multiplication: a * b
Division: a / b
Modulus: a % b
Power: a ** b

Comparison

Equal: a == b
Not equal: a != b
Less than: a < b
Less than or equal: a <= b
Greater than: a > b
Greater than or equal: a >= b

Logical

And: a and b or a && b
Or: a or b or a || b
Not: not a or !a

Bitwise

Bitwise AND: a & b
Bitwise OR: a | b
Bitwise XOR: a ^ b
Bitwise NOT: ~a
Left shift: a << b
Right shift: a >> b

Assignment

Assign: a = b
Add and assign: a += b
Subtract and assign: a -= b
Multiply and assign: a *= b
Divide and assign: a /= b
Modulus and assign: a %= b
Power and assign: a **= b
Left shift and assign: a <<= b
Right shift and assign: a >>= b
Bitwise AND and assign: a &= b
Bitwise OR and assign: a |= b
Bitwise XOR and assign: a ^= b

Variable Typing

Dynamic Typing

In GDScript, variables are dynamically typed by default, meaning their type is interchangeable at runtime. For example:

var my_variable = 10
my_variable = "Hello, GDScript!" # This is allowed

Static Typing

Static typing can be used to explicitly specify the type of a variable, meaning their type is not interchangeable at runtime. This can help catch potential bugs and improve code readability:

var my_int: int = 5
my_int = "Hello, GDScript!" # This will cause an error

Static type can also be inferred by using := followed by value. Be careful when using this though, sometimes verbosity is better.

var my_int := 5
my_int = "Hello World" # Error, because my_int has been statically inferred as int

Control Structures

Control structures are the building blocks of your GDScript code, allowing you to create complex logic and control the flow of your program. Let's learn about the different types of control structures in GDScript:

Conditional statements

If

The if statement is used to execute a block of code if a certain condition is true:

if x > 0:
    print("x is positive")

Else

The else statement is used to execute a block of code if the condition in the if statement is false:

if x > 0:
    print("x is positive")
else:
    print("x is not positive")

Elif

The elif (short for "else if") statement is used to test multiple conditions in a single if statement:

if x > 0:
    print("x is positive")
elif x < 0:
    print("x is negative")
else:
    print("x is zero")

Loops

For

The for loop is used to iterate over a sequence, such as an array or a range of numbers:

for i in range(5):
    print(i) # Prints 0, 1, 2, 3, 4

for item in my_array:
    print(item) # Prints each item in my_array

While

The while loop is used to repeatedly execute a block of code as long as a certain condition is true:

var i = 0
while i < 5:
    print(i) # Prints 0, 1, 2, 3, 4
    i += 1

Break and Continue

The break statement is used to exit a loop prematurely:

for i in range(10):
    if i == 5:
        break
    print(i) # Prints 0, 1, 2, 3, 4

The continue statement is used to skip the rest of the current iteration and proceed to the next one:

for i in range(5):
    if i == 2:
        continue
    print(i) # Prints 0, 1, 3, 4

Functions

Functions are blocks of code that can be defined and called by name. They can take input, perform some action, and return a result. Let's learn how to work with functions in GDScript:

Defining functions

To define a function, use the func keyword followed by the function name and a pair of parentheses:

func my_function():
    print("Hello, GDScript!")

Built-in functions

GDScript comes with a variety of built-in functions that you can use in your code. Some examples include:

print(): Prints a message to the console
randi(): Returns a random integer
len(): Returns the length of a sequence (e.g., an array or a string)

Function arguments

Functions can take input in the form of arguments. To define a function with arguments, include the argument names inside the parentheses:

func add(a, b):
    return a + b

You can also define the types of the arguments, it will spit out an error if you try to pass different types to the arguments.

func add(a: int, b: int):
    return a + b

Return values

Functions can return a result using the return keyword:

func add(a, b):
    return a + b

var result = add(2, 3) # result is 5

You can also define the type of the returned value by appending -> ReturnType to the function declaration, it will spit out an error if you try to return something that isn't the correct type.

# Returns integer
func add(a: int, b: int) -> int:
    return a + b

# This won't work
func add(a, b) -> int:
    return "Hello"

Optional argument values

Functions can have optional argument as value by assigning it at the definition:

func multiply(a: int, b: int = 2) -> int:
    return a * b

var result = multiply(2, 3) # result is 6
var result = multiply(4) # result is 8

Note: Optional arguments can only be positioned after you've defined all mandatory arguments.

# Valid, optional placed last
func sum(a: int, b: int, c: int = 0) -> int:
    return a + b + c

# Invalid, can't have optional before mandatory
func sum(a: int, b: int = 0, c: int) -> int:
    return a + b + c

Static Functions

Static functions are functions that belong to a class rather than an instance of the class. To define a static function, use the static keyword:

class_name  MyClass extends Node

static func my_static_function():
    print("This is a static function.")

func _init() -> void:
    my_static_function()
    MyClass.my_static_function()

Since statics belong to the class, you can use MyClass.my_static_function() to invoke it.

Classes and Objects

In GDScript, a script file represents a class and objects are instances of classes. You can create instances of a class using the new() method.

Defining Classes

To define a class, simply create a new script file (e.g., my_class.gd). The name of the file should represents the name of the class. Create a new file called player.gd with the following content:

class_name Player

var health: int = 100
var name: String = "Unnamed"

func take_damage(amount: int):
    health -= amount
    if health <= 0:
        print("Player", name, "has died!")

Creating Object

var player = Player.new()
player.name = "John Doe"
player.take_damage(50)

Properties

Properties are variables that belong to a class or an object. They can be used to store data or state:

class MyClass:
    var my_property = 0

Methods

Methods are functions that belong to a class or an object. They can be used to perform actions or manipulate data:

class MyClass:
    func my_method():
        print("Hello, GDScript!")

Inheritance

Inheritance is a way for one class to inherit the properties and methods of another class. To inherit from another class, use the extends keyword:

# Derived class
class_name DerivedClass extends MyBaseClass

func my_method():
    print("Hello from the derived class!")

Constructors

Constructors are special methods that are called when an object is initialized. In GDScript, the constructor is named _init:

class MyClass:
    func _init():
        print("Object initialized!")

Signals and Events

Signals are a way for objects to communicate with each other without relying on direct references. They can be used to decouple your code and make it more modular. Let's learn how to work with signals and events in GDScript:

Defining signals

To define a signal, use the signal keyword followed by the signal name:

signal my_signal

Emitting signals

To emit a signal, you can use the emit_signal method:

emit_signal("my_signal")

However, it's better to ditch those strings, by simply calling emit method inside the signal directly:

my_signal.emit()

Connecting signals to functions

Signals are a way to communicate between objects in Godot. They allow you to decouple your code and create more modular systems.

To connect a signal to a function, use the connect method:

my_object.my_signal.connect(on_my_signal)

func on_my_signal():
    print("Signal received!")

There are actually four ways to connect signals, however, this is the recommended approach, instead of the other one (That might more error prone).

Error Handling

Error handling is an important aspect of programming, as it allows you to gracefully handle errors and exceptions that may occur at runtime. In GDScript, you can use the following constructs to handle errors:

Assert

The assert statement is used to check if a condition is true, and if not, raise an error:

assert(x > 0, "x must be positive")

Note: assert is a utility function meant for unit tests. Code inside assert is only executed in debug builds or when running the project from the editor.

Try, Catch, and Throw

GDScript does not have built-in support for try-catch blocks. There are many godot-proposals from people asking for it, however, It has already been stated that try-catch will never come into gdscript.

Quoting from Juan in his post:

Exceptions won't happen. Godot is designed for things to keep working even if state is inconsistent, while at the same time reporting errors

File I/O

Working with files is a common task in many applications. In GDScript, you can use the File class to read from and write to files:

Writing a file

To write to a file, use the store_string, store_line or other store_* methods:

var player_name = "Septian"
var file = FileAccess.open("user://save_game.dat", FileAccess.WRITE)
file.store_string(player_name)

Reading and writing

To read from a file, use the get_as_text or other get_* method:

var file = FileAccess.open("user://save_game.dat", FileAccess.READ)
var player_name = file.get_as_text()
print(player_name)

Closing files

To close a file, use the close method:

file.close()

FileAccess will automatically closes the file when it goes out of scope or set to null. However it's better to be explicit when handling with I/O.

Useful Tips and Tricks

Here are some handy tips and tricks to help you write better GDScript:

Use clear and descriptive variable and function names
Keep your functions short and focused
Use comments to explain complex or important code
Follow the GDScript style guide
Follow the GDScript code ordering

String manipulation

String interpolation:

var result = "The %s has defeated the %s in %s" % ["Player", "Boss", "Combat"]
print(result)
# Will prints:
# The Player has defeated the Boss in Combat

Concatenate strings: var result = "Hello, " + "GDScript!"
Format strings: var result = "Hello, %s!" % "GDScript"
Split strings: var words = "Hello, GDScript!".split(", ")

Array and Dictionary operations

Add an item to an array: my_array.append(item)
Remove an item from an array: my_array.erase(item)
Get the length of an array: var length = my_array.size()
Check if a key exists in a dictionary: if my_dict.has(key):

Type casting

Cast a value to a specific type: var my_int = int("42")

Debugging

Print a message to the console: print("Hello, GDScript!")
Set a breakpoint: breakpoint

Resources

To learn more about GDScript and the Godot game engine, check out these great resources:

That's it for this GDScript Cheatsheet! I hope you found it useful and informative. Feel free to bookmark this post and refer back to it whenever you need a quick reference for GDScript. Happy coding!

This cheatsheet is updated for Godot 4.2, GDScript is an evolving language, if you find outdated information, please let me know so I can fix it!

Learn C++: An Introduction for Beginners

Godot — Sat, 09 Sep 2023 08:32:02 +0000

C++ is a powerful, versatile, and widely-used programming language that has remained relevant in the world of software development for over three decades. In this short post, we'll introduce you to the basics of C++ and help you build a strong foundation to embark on your programming journey.

Brief history of C++

C++ was created by Bjarne Stroustrup in 1985 as an extension of the C programming language. Stroustrup wanted to add object-oriented features to C, which led to the birth of C++. Since then, C++ has undergone several revisions and updates, with the most recent version being C++20.

Importance of C++ in modern programming

C++ is an essential language in today's programming landscape for several reasons:

It is highly efficient and provides fine-grained control over system resources.
It supports both procedural and object-oriented programming paradigms.
It has a vast standard library (STL) that simplifies complex tasks.
It is widely used in industries such as game development, embedded systems, and high-performance computing.

Overview of the post

This post is divided into several sections, each focusing on key aspects of C++ programming:

Setting up the environment
Basic C++ syntax
Functions
Object-oriented programming
Standard Template Library (STL)
Input and output
Error handling
Advanced topics
Best practices and debugging

By the end of this post, you'll have a solid understanding of C++ fundamentals and be ready to tackle more advanced topics.

Setting up the environment

Before we start coding, let's set up our development environment.

Choosing an IDE

An Integrated Development Environment (IDE) is a software application that provides a comprehensive set of tools for coding, debugging, and building software. Some popular C++ IDEs include:

Visual Studio: A powerful and feature-rich IDE from Microsoft.
Code::Blocks: A free, open-source, and cross-platform IDE.
CLion: A commercial IDE from JetBrains with advanced features and excellent support.

Choose the IDE that best fits your needs and preferences.

Installing the compiler

A compiler is a program that translates your C++ code into machine code, which can then be executed by a computer. Some common C++ compilers are:

GCC: The GNU Compiler Collection is a widely-used, open-source compiler that supports multiple platforms.
Clang: A compiler based on LLVM, known for its fast compilation times and helpful error messages.
Microsoft Visual C++: A compiler included with Visual Studio, optimized for Windows development.

Install the compiler that is compatible with your chosen IDE and operating system.

Creating your first C++ project

Once you have your IDE and compiler set up, it's time to create your first C++ project. Follow these general steps:

Open your chosen IDE and create a new project.
Select "C++" as the project type.
Choose a name and location for your project.
Add a new C++ source file to your project (usually with a .cpp extension).

Basic C++ syntax

Now that we have our environment set up, let's dive into the basics of C++ syntax.

Structure of a C++ program

A typical C++ program consists of the following elements:

Preprocessor directives: These are commands that instruct the compiler to perform specific tasks before compiling the code. For example, #include is used to include header files.
Function declarations and definitions: These are used to declare and define functions, which are blocks of code that perform specific tasks.
Variables and data types: These are used to store and manipulate data in your program.
Control structures: These are used to control the flow of your program, such as if, else, and switch statements.
Loops: These are used to repeatedly execute blocks of code, such as for, while, and do-while loops.

Here's a simple example of a C++ program:

#include <iostream>

int main() {
  std::cout << "Hello, World!" << std::endl;
  return 0;
}

Variables and data types

In C++, we use variables to store and manipulate data. Each variable has a specific data type that determines the kind of data it can hold. Some common C++ data types are:

int: Integer values (e.g., -2, 0, 42)
float: Single-precision floating-point values (e.g., 3.14f, -0.001f)
double: Double-precision floating-point values (e.g., 3.141592653589793, -0.000001)
char: Single characters (e.g., 'a', 'Z', '9')
bool: Boolean values (true or false)

Here's an example of declaring and initializing variables in C++:

int age = 30;
float weight = 65.5f;
double pi = 3.141592653589793;
char initial = 'A';
bool is_adult = true;

Operators and expressions

Operators are special symbols that perform operations on operands (variables or values). Some common C++ operators are:

Arithmetic operators: +, -, *, /, %
Relational operators: <, >, <=, >=, ==, !=
Logical operators: &&, ||, !

Expressions are combinations of variables, values, and operators that result in a single value. Here's an example of using operators and expressions in C++:

int a = 10;
int b = 20;
int sum = a + b;
bool is_greater = a > b;

Control structures (if, else, switch)

Control structures are used to control the flow of your program based on certain conditions. Some common C++ control structures are:

if: Executes a block of code if a specified condition is true.
else: Executes a block of code if the condition in the preceding if statement is false.
switch: Executes a block of code based on the value of a specified expression.

Here's an example of using control structures in C++:

int x = 42;

if (x > 0) {
  std::cout << "x is positive" << std::endl;
} else {
  std::cout << "x is non-positive" << std::endl;
}

switch (x % 2) {
  case 0:
    std::cout << "x is even" << std::endl;
    break;
  case 1:
    std::cout << "x is odd" << std::endl;
    break;
}

Loops (for, while, do-while)

Loops are used to repeatedly execute blocks of code based on certain conditions. Some common C++ loops are:

for: Executes a block of code a specified number of times.
while: Executes a block of code as long as a specified condition is true.
do-while: Executes a block of code at least once and then repeatedly as long as a specified condition is true.

Here's an example of using loops in C++:

// for loop
for (int i = 0; i < 10; ++i) {
  std::cout << i << std::endl;
}

// while loop
int count = 0;
while (count < 10) {
  std::cout << count << std::endl;
  ++count;
}

// do-while loop
int num;
do {
  std::cout << "Enter a positive number: ";
  std::cin >> num;
} while (num <= 0);

Functions

Functions are blocks of code that perform specific tasks and can be called by name. They can accept input (parameters) and return output (return values).

Defining and declaring functions

Functions are defined using the following syntax:

return_type function_name(parameter_list) {
  // function body
}

For example, here's a simple function that adds two numbers and returns the result:

int add(int a, int b) {
  return a + b;
}

Function declarations (also called prototypes) are used to inform the compiler about a function's existence before it is defined. They have the following syntax:

return_type function_name(parameter_list);

For example, here's the declaration for the add function:

int add(int a, int b);

Function parameters and return values

Function parameters are variables that hold the input values passed to the function. They are specified in the function definition and declaration.

Return values are the output values produced by the function. They are specified using the return statement followed by an expression or value.

Here's an example of a function that calculates the area of a rectangle:

double area(double length, double width) {
  return length * width;
}

Function overloading

Function overloading is the ability to define multiple functions with the same name but different parameter lists. The compiler chooses the appropriate function to call based on the number and types of arguments passed.

Here's an example of function overloading:

int add(int a, int b) {
  return a + b;
}

double add(double a, double b) {
  return a + b;
}

Recursion

Recursion is the process of a function calling itself, either directly or indirectly. It is often used to solve problems that can be broken down into smaller, similar problems.

Here's an example of a recursive function that calculates the factorial of a number:

int factorial(int n) {
  if (n <= 1) {
    return 1;
  }
  return n * factorial(n - 1);
}

Object-oriented programming

Object-oriented programming (OOP) is a programming paradigm that focuses on organizing code into "objects" that represent real-world entities. It is built on the concepts of classes, objects, inheritance, and polymorphism.

Introduction to OOP concepts

The main concepts in OOP are:

Classes: Templates for creating objects, consisting of data members and member functions.
Objects: Instances of classes, representing real-world entities.
Inheritance: The process of creating new classes that inherit the properties and methods of existing classes.
Polymorphism: The ability of a function or method to operate on multiple types of data or objects.

Classes and objects

Classes are defined using the class keyword, followed by the class name and a set of braces containing the class's data members and member functions.

Objects are instances of classes, created using the class's constructor.

Here's an example of a class definition and object creation:

class Dog {
public:
  std::string name;
  int age;

  void bark() {
    std::cout << "Woof!" << std::endl;
  }
};

int main() {
  Dog my_dog;
  my_dog.name = "Buddy";
  my_dog.age = 3;
  my_dog.bark();
}

Constructors and destructors

Constructors are special member functions that are called when an object is created. They are used to initialize the object's data members. Destructors are special member functions that are called when an object is destroyed. They are used to perform any necessary cleanup.

Here's an example of a class with constructors and a destructor:

class Dog {
public:
  std::string name;
  int age;

  // Default constructor
  Dog() : name("Unnamed"), age(0) {}

  // Parameterized constructor
  Dog(std::string n, int a) : name(n), age(a) {}

  // Destructor
  ~Dog() {
    std::cout << "Dog destroyed" << std::endl;
  }

  void bark() {
    std::cout << "Woof!" << std::endl;
  }
};

Inheritance

Inheritance is the process of creating new classes that inherit the properties and methods of existing classes. It allows for code reuse and modular design.

Here's an example of inheritance in C++:

class Animal {
public:
  std::string name;
  int age;

  void make_sound() {
    std::cout << "Generic animal sound" << std::endl;
  }
};

class Dog : public Animal {
public:
  void make_sound() {
    std::cout << "Woof!" << std::endl;
  }
};

Polymorphism

Polymorphism is the ability of a function or method to operate on multiple types of data or objects. It allows for more flexible and modular code.

Here's an example of polymorphism in C++:

class Animal {
public:
  virtual void make_sound() {
    std::cout << "Generic animal sound" << std::endl;
  }
};

class Dog : public Animal {
public:
  void make_sound() {
    std::cout << "Woof!" << std::endl;
  }
};

class Cat : public Animal {
public:
  void make_sound() {
    std::cout << "Meow!" << std::endl;
  }
};

int main() {
  Animal *animals[] = {new Dog(), new Cat()};
  for (Animal *animal : animals) {
    animal->make_sound();
  }
}

Standard Template Library (STL)

The Standard Template Library (STL) is a collection of template classes and functions that provide common data structures and algorithms for C++ programming.

Overview of STL

The main components of the STL are:

Containers: Data structures that store and organize data (e.g., vector, list, map).
Iterators: Objects that provide a way to access and traverse container elements.
Algorithms: Functions that perform operations on containers (e.g., sorting, searching).

Containers (vector, list, map, etc.)

Containers are data structures that store and organize data. Some common STL containers are:

vector: A dynamic array that can grow or shrink in size.
list: A doubly-linked list that allows for efficient insertions and deletions.
map: An associative container that stores key-value pairs, with unique keys.

Here's an example of using a vector container in C++:

#include <vector>

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5};

  numbers.push_back(6); // Add an element to the end
  numbers.pop_back(); // Remove the last element
  int first = numbers.front(); // Get the first element
  int last = numbers.back(); // Get the last element
}

Iterators

Iterators are objects that provide a way to access and traverse container elements. They are similar to pointers but are more flexible and can work with different container types.

Here's an example of using iterators with a vector container:

#include <vector>

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5};
  std::vector<int>::iterator it;

  for (it = numbers.begin(); it != numbers.end(); ++it) {
    std::cout << *it << std::endl;
  }
}

Algorithms

Algorithms are functions that perform operations on containers, such as sorting, searching, and transforming data.

Here's an example of using the sort algorithm with a vector container:

#include <vector>
#include <algorithm>

int main() {
  std::vector<int> numbers = {5, 3, 1, 4, 2};
  std::sort(numbers.begin(), numbers.end()); // Sort the vector in ascending order
}

Input and output

C++ provides several ways to handle input and output, including console input/output, file input/output, and string manipulation.

Console input and output

Console input and output are performed using the cin and cout objects, which are part of the iostream library. They allow you to read and write data to and from the console.

Here's an example of using console input and output:

#include <iostream>

int main() {
  int age;
  std::cout << "Enter your age: ";
  std::cin >> age;
  std::cout << "You are " << age << " years old" << std::endl;
}

File input and output

File input and output are performed using the ifstream and ofstream classes, which are part of the fstream library. They allow you to read and write data to and from files.

Here's an example of using file input and output:

#include <fstream>
#include <iostream>

int main() {
  std::ofstream outfile("output.txt");
  outfile << "Hello, file!" << std::endl;
  outfile.close();

  std::ifstream infile("output.txt");
  std::string line;
  getline(infile, line);
  std::cout << line << std::endl;
  infile.close();
}

String manipulation

String manipulation is performed using the string class, which is part of the string library. It provides various functions and operators for working with strings.

Here's an example of using string manipulation:

#include <string>
#include <iostream>

int main() {
  std::string greeting = "Hello, World!";
  std::string name = "John";
  std::string personalized_greeting = greeting + " " + name;
  std::cout << personalized_greeting << std::endl;
}

Error handling

Error handling is an essential aspect of programming that helps you deal with unexpected situations and prevent your program from crashing. In C++, error handling is primarily done using exceptions.

Exceptions

Exceptions are events that occur during the execution of a program when an error is encountered. They are thrown using the throw keyword and caught using try and catch blocks.

Here's an example of using exceptions for error handling:

#include <iostream>

double divide(double a, double b) {
  if (b == 0) {
    throw "Division by zero";
  }
  return a / b;
}

int main() {
  try {
    double result = divide(10, 0);
    std::cout << "Result: " << result << std::endl;
  } catch (const char *error) {
    std::cout << "Error: " << error << std::endl;
  }
}

Try, catch, and throw

The try, catch, and throw keywords are used to handle exceptions in C++.

try: Encloses a block of code that might throw an exception.
catch: Defines a block of code that handles a specific type of exception.
throw: Throws an exception when an error is encountered.

Custom exception classes

You can create custom exception classes by inheriting from the std::exception class and overriding its what() method.

Here's an example of creating a custom exception class:

#include <iostream>
#include <stdexcept>

class DivisionByZeroException : public std::exception {
public:
  const char *what() const noexcept override {
    return "Division by zero";
  }
};

double divide(double a, double b) {
  if (b == 0) {
    throw DivisionByZeroException();
  }
  return a / b;
}

int main() {
  try {
    double result = divide(10, 0);
    std::cout << "Result: " << result << std::endl;
  } catch (const DivisionByZeroException &ex) {
    std::cout << "Error: " << ex.what() << std::endl;
  }
}

Advanced topics

Now that we've covered the fundamentals, let's dive into some advanced C++ topics.

Pointers and memory management

Pointers are variables that store the memory address of another variable. They are used to access and manipulate memory directly, providing greater flexibility and control over your program's resources.

Here's an example of using pointers in C++:

int x = 42;
int *p = &x; // p points to the memory address of x
*p = 10; // Change the value of x through the pointer

Memory management is the process of allocating and deallocating memory as needed by your program. In C++, you can use the new and delete operators to allocate and deallocate memory dynamically.

Here's an example of memory management in C++:

int *p = new int; // Allocate memory for an int
*p = 42; // Assign a value to the memory
delete p; // Deallocate the memory

Templates

Templates are a powerful feature of C++ that allows you to write generic code that can work with different data types. They are used to create reusable classes and functions that can operate on any data type.

Here's an example of using templates in C++:

template<typename T>
T add(T a, T b) {
  return a + b;
}

int main() {
  int x = add<int>(1, 2);
  double y = add<double>(3.14, 2.71);
}

Lambda expressions

Lambda expressions are a concise way to create anonymous functions (functions without a name). They are useful for creating short, one-time-use functions that can be passed as arguments to other functions.

Here's an example of using a lambda expression in C++:

#include <algorithm>
#include <vector>

int main() {
  std::vector<int> numbers = {5, 3, 1, 4, 2};
  std::sort(numbers.begin(), numbers.end(),
    [](int a, int b) { return a > b; }); // Sort in descending order using a lambda
}

Multithreading

Multithreading is the process of executing multiple threads concurrently, allowing your program to perform multiple tasks simultaneously. C++ provides the <thread> library to work with threads.

Here's an example of using multithreading in C++:

#include <iostream>
#include <thread>

void print_hello() {
  std::cout << "Hello from thread!" << std::endl;
}

int main() {
  std::thread t(print_hello);
  t.join(); // Wait for the thread to finish
}

Best practices and debugging

Writing clean, efficient, and maintainable code is essential for any programmer. In this section, we'll discuss best practices and debugging techniques for C++ programming.

Code organization

Organizing your code into separate functions, classes, and files makes it easier to read, understand, and maintain.

Functions: Break your code into small, reusable functions that perform specific tasks.
Classes: Organize related data and functions into classes to model real-world entities.
Files: Separate your code into different files based on their functionality, and use header files for declarations.

Naming conventions

Using consistent naming conventions for variables, functions, and classes makes your code easier to read and understand.

Variables: Use lowercase letters and underscores (e.g., my_variable).
Functions: Use lowercase letters and underscores (e.g., my_function).
Classes: Use PascalCase (e.g., MyClass).

Debugging techniques

Debugging is the process of finding and fixing errors in your code. Some common debugging techniques include:

Code review: Review your code for syntax errors, logic errors, and other issues.
Print statements: Add print statements to your code to display variable values and track the program's execution.
Breakpoints: Use breakpoints in your IDE to pause the execution of your program and inspect its state.
Step-through debugging: Use step-through debugging in your IDE to execute your program one line at a time and observe its behavior.

Performance optimization

Optimizing your code for performance can help your program run faster and use fewer resources. Some general performance optimization tips include:

Use efficient algorithms: Choose algorithms with lower time complexity to reduce the execution time of your program.
Minimize memory usage: Use appropriate data structures and memory allocation techniques to minimize memory usage.
Profile your code: Use profiling tools to identify performance bottlenecks in your code and optimize them.

Conclusion

Congratulations! You've now learned the fundamentals of C++ programming, including setting up your development environment, understanding basic syntax, working with functions and classes, using the Standard Template Library, handling input and output, and more.

Review of key concepts

Here's a quick review of some key concepts we covered:

C++ is a powerful, versatile, and widely-used programming language.
It supports both procedural and object-oriented programming paradigms.
The Standard Template Library (STL) provides a collection of template classes and functions for common data structures and algorithms.
Error handling in C++ is primarily done using exceptions.
Advanced topics in C++ include pointers, memory management, templates, lambda expressions, and multithreading.

Resources for further learning

To continue learning and expanding your C++ knowledge, consider the following resources:

C++ reference websites, such as cplusplus.com and cppreference.com.
Online programming courses and tutorials, such as Learn C++ and C++ for Programmers.
Books on C++, such as "C++ Primer" by Stanley B. Lippman, Josée Lajoie, and Barbara E. Moo, and "Effective C++" by Scott Meyers.

Next steps in your C++ journey

Now that you have a solid foundation in C++, you can start exploring more advanced topics, such as:

Graphical user interface (GUI) programming with libraries like Qt or GTK.
Game development with engines like Godot Engine, Unreal Engine or Unity (with C++ scripting).
Networking and web development with libraries like Boost.Asio or Poco.
Embedded systems and IoT programming with platforms like Arduino and Raspberry Pi.

Keep practicing and building projects, and you'll become a proficient C++ programmer in no time!

GodotCon 2023

Godot — Sun, 03 Sep 2023 21:35:04 +0000

Announcing GodotCon 2023: A Two-Day Event in Munich, Germany

Get ready for an exciting two-day event, as GodotCon 2023 is set to take place in Munich, Germany on November 4th and 5th. The event will be packed with talks, Godot games, workshops, and opportunities to network with fellow Godot contributors. Whether you're a beginner or an experienced Godot user, there's something for everyone at this conference.

Event: GodotCon 2023
When: November 4th and 5th, 2023.
Location: Walter-Gropius-Str. 5, 80807 München, Germany.
More Info: Join us at the Godot Conference 2023! Godot Conference 2023: Call for Participations

Call for Proposals: Share Your Ideas

The organizers are eager to hear from the Godot community and are soon launching a Call for Proposals. This is your chance to propose a talk, workshop, or any other activity you think would be a great addition to the event. As the largest Godot event to date, the organizers want to ensure that everyone can participate in some way.

Can't attend the event in person? Don't worry! The organizers plan to record the talks and workshops and make them available online. They'll also try to stream the event live, but they can't make any promises yet.

The Venue: Microsoft Germany

A dedicated team of Munich locals has been working hard to bring this event to life. They have secured a fantastic venue: Microsoft Germany. Located at Walter-Gropius-Str. 5, 80807 München, Germany, Microsoft's generous offer of their space allows GodotCon 2023 to become a reality.

Tickets: Limited Availability

Tickets for the event will be available soon, but keep in mind that they'll be limited. To stay informed about the ticket sale and receive any future communication regarding the conference, make sure to subscribe to the event's mailing list.

Event Highlights

Call for Speakers & Workshops

The organizers are looking for a diverse range of presentations and are inviting interested parties to propose talks or workshops. If you have a project or experience that would be of interest to Godot users, submit your proposal through the dedicated platform.

There will be two tracks available:

Main track
Workshops

Please note that due to the number of proposals and available slots, some proposals may be rejected. If your proposal isn't accepted, don't feel discouraged—you can always try again next year.

Main Track

The main track is open to talks on various topics. Presentations can be directly related to Godot or relevant to game or engine developers. The main track will run for the entire duration of the event, and talks can be either 30 or 60 minutes long (including 5-10 minutes for Q&A). If you require a different duration, you can specify your needs in your proposal.

Some examples from last year's online GodotCon event include:

WebXR in Godot
(Almost) A Year of Fam Jams
Teaching Godot Engine: Learning Experience Design
Wwise Godot Integration: integrating audio middleware into Godot
The Garden Path
The new rendering of Godot 4.0
Extending the 2D Renderer: Adding 3D-Like Shadowing

Workshops

This year, there will be a dedicated room for workshops on both mornings of the event. Depending on the duration, two to four workshop slots will be available. Ideally, workshops should last between one and two hours. However, if your proposal requires more time, please indicate the required duration and explain why.

Call for Volunteers

An event like GodotCon 2023 can't happen without a dedicated team of volunteers. The organizers are looking for individuals to help with various tasks during the event, including:

Steward Lead
Stewards/General Volunteers
Hosts (for speakers/sponsors)
IT Lead
IT Technicians
Streaming Lead
Streaming Operators & Moderators
Ticketing & Accreditation Lead
Ticketing & Accreditation
Meet 2 Match Host

If you're interested in volunteering, send an email to godotcon@proton.me or join the GodotCon 2023 Discord server.

Sponsorship Opportunities

Sponsors are essential for making an event like GodotCon 2023 possible. The organizers are looking for sponsors to help cover costs related to the venue, security, catering, documentation, swag, speaker support, and more. Sponsoring the event offers a unique marketing opportunity with relatively low investment.

If you're interested in sponsoring GodotCon 2023, send an email to contact@godotengine.org and provide details on how or what you'd like to sponsor. For more information, visit the Sponsorship Page.

A special thank you goes out to the current sponsors, Microsoft and DU&I, for their invaluable support.

Mark Your Calendars: GodotCon 2023 Awaits

With an incredible lineup of talks, workshops, and networking opportunities, GodotCon 2023 is an event you won't want to miss. Mark your calendars for November 4th and 5th, and get ready for an unforgettable experience in Munich, Germany. See you there!

Using Progression Systems to Keep Players Engaged

Godot — Mon, 28 Aug 2023 09:55:52 +0000

Introduction

Progression systems are a crucial aspect of game design, playing a significant role in maintaining player engagement and ensuring a fulfilling gaming experience. In this post, we'll explore the different types of progression systems, their importance, and how they can be effectively implemented in various game genres.

Definition of progression systems

Progression systems are mechanisms within games that allow players to advance, improve, and unlock new abilities, items, or content. These systems are designed to provide a sense of achievement and reward as players invest time and effort into the game.

Importance of player engagement

Player engagement is essential for the success of a game. An engaged player is more likely to continue playing, recommend the game to others, and potentially spend money on in-game purchases. Progression systems contribute to engagement by providing players with a sense of purpose and a clear path for improvement and growth.

Role of progression systems in maintaining engagement

Progression systems help maintain player engagement by:

Encouraging players to invest time and effort into the game.
Providing a sense of accomplishment and reward.
Offering meaningful choices and customization.
Integrating with gameplay to create a cohesive experience.

Types of progression systems

There are several types of progression systems commonly used in games, including:

Experience Points (XP) and leveling

Players earn XP through completing tasks, defeating enemies, or discovering new areas.
Accumulated XP contributes to leveling up, unlocking new abilities or stat increases.
Example GDScript code snippet for increasing XP:

func gain_experience(amount):
    xp += amount
    if xp >= next_level_xp:
        level_up()

Skill trees and abilities

Players can unlock and upgrade various skills or abilities, often branching into different specialties.
Skill trees provide customization and meaningful choices for players.
Example GDScript code snippet for unlocking a skill:

func unlock_skill(skill_name):
    if skill_points >= skill_cost[skill_name]:
        skill_points -= skill_cost[skill_name]
        unlocked_skills.append(skill_name)

Gear and equipment upgrades

Players can find, purchase, or craft new gear and equipment to improve their character's stats.
Upgrading gear encourages exploration, resource gathering, and in-game economy engagement.
Example GDScript code snippet for equipping an item:

func equip_item(item):
    if item.type in equipment_slots:
        unequip_item(equipment_slots[item.type])
        equipment_slots[item.type] = item
        apply_item_stats(item)

In-game currency and economy

Players earn in-game currency through various activities, such as completing quests or selling items.
Currency can be used to purchase new gear, abilities, or other in-game content.
Example GDScript code snippet for adding currency:

func add_currency(amount):
    currency += amount

Achievements and milestones

Players can earn achievements or reach milestones by accomplishing specific tasks or goals.
Achievements provide additional incentives for players to explore and challenge themselves.
Example GDScript code snippet for unlocking an achievement:

func unlock_achievement(achievement_name):
    if not achievements.has(achievement_name):
        achievements[achievement_name] = true

Designing effective progression systems

To design an effective progression system, consider the following aspects:

Balancing challenge and reward

Ensure that the difficulty of challenges scales appropriately with the rewards provided.
Avoid making progression too easy or too difficult to maintain engagement.

In order to create an engaging and satisfying progression system, it is crucial to strike a balance between the level of challenge and the rewards offered to the players. This can be achieved by ensuring that the difficulty of challenges scales appropriately with the rewards provided. As players progress through the game, they should encounter increasingly difficult tasks that test their skills and abilities, while simultaneously being rewarded with more valuable and meaningful incentives.

To avoid making the progression system too easy or too difficult, it is important to carefully analyze the player's skill level and adjust the challenges accordingly. This will help maintain player engagement and prevent them from losing interest due to a lack of challenge or becoming frustrated by insurmountable obstacles.

Ensuring a sense of accomplishment

In order to create a highly effective progression system, it is crucial to take into account several key aspects that contribute to a satisfying and engaging player experience:

Striking a balance between challenge and reward: To maintain player interest and motivation, it is essential to find the right balance between the level of difficulty presented in challenges and the rewards offered for overcoming them. This balance ensures that players feel adequately challenged without becoming overwhelmed or frustrated.
Scaling difficulty and rewards proportionately: As players progress through the game, the difficulty of challenges should increase in tandem with the rewards provided. This ensures that players continue to feel motivated to tackle more difficult tasks, while also feeling that their efforts are being justly rewarded.
Avoiding extremes in progression: To keep players engaged and prevent them from losing interest, it is important to avoid making the progression system either too easy or too difficult. A well-designed progression system should offer a steady increase in challenge that keeps players invested in the game without causing undue frustration.
Fostering a sense of accomplishment: An effective progression system should instill a strong sense of achievement in players as they overcome challenges and reach new milestones. This can be achieved by providing players with tangible rewards and recognition for their efforts, such as in-game items, abilities, or other bonuses that enhance their gameplay experience.
Utilizing visual and audio cues to celebrate achievements: To further emphasize the sense of accomplishment, incorporate visual and audio cues that celebrate players' achievements and milestones. These cues can include animations, sound effects, or other in-game elements that signal to the player that they have reached a significant point in their progression. By doing so, you create a more immersive and rewarding experience that encourages players to continue striving for success.

Providing meaningful choices

Offer players multiple paths for progression, allowing them to customize their experience.
Ensure that choices have distinct and noticeable impacts on gameplay.

Offer players a variety of progression paths, enabling them to tailor their gaming experience according to their preferences and playstyles. By presenting diverse options, players can explore different strategies and approaches, making their journey through the game more engaging and personalized.

To maintain player interest and investment, it is crucial to ensure that the choices they make have distinct and significant consequences on gameplay. This can be achieved by designing each choice to lead to unique outcomes, challenges, and rewards, ultimately affecting the overall game narrative and environment. By doing so, players will feel that their decisions matter, fostering a deeper connection to the game and enhancing their sense of agency and immersion.

Integrating progression systems with gameplay

Progression systems should complement and enhance the core gameplay loop, not detract from it.
Consider how progression elements can be woven into the game world, narrative, and mechanics.

In order to create a truly immersive gaming experience, it is essential that progression systems are carefully designed to complement and augment the core gameplay loop, rather than detracting from it or feeling like an afterthought. By seamlessly integrating progression elements into the game world, narrative, and mechanics, developers can create a more engaging and rewarding experience for players.

To achieve this, developers should consider how progression systems can be intricately woven into the game world, making them feel like a natural part of the environment. This can be accomplished by incorporating visual cues, environmental storytelling, and world-building elements that reflect the player's progress and growth. For example, as players advance through the game, they may notice changes in the landscape, the behavior of NPCs, or the availability of new areas to explore, all of which serve to reinforce their sense of progression.

Furthermore, it is important to ensure that progression systems are deeply intertwined with the game's narrative. This can be achieved by having the player's choices and actions directly impact the story, leading to unique outcomes, challenges, and rewards. By doing so, players will feel that their decisions genuinely matter, fostering a deeper connection to the game and enhancing their sense of agency and immersion. This can be achieved through branching storylines, dynamic dialogue, and a variety of narrative consequences that reflect the player's progress and choices.

Lastly, developers should strive to integrate progression systems with the game's mechanics in a way that feels organic and rewarding. This can be done by designing progression systems that enhance the player's abilities, unlock new gameplay options, and encourage experimentation with different strategies and playstyles. For example, as players progress, they may gain access to new skills, equipment, or abilities that allow them to overcome previously insurmountable challenges or explore new aspects of the game world. By doing so, players will feel a sense of accomplishment and satisfaction as they witness their growth and mastery over the game's mechanics.

In summary, by thoughtfully integrating progression systems with the game world, narrative, and mechanics, developers can create a more engaging, immersive, and satisfying gaming experience for players. By ensuring that progression feels like a natural and meaningful aspect of the game, players will be more likely to form a deep connection to the game and feel a greater sense of agency and immersion.

Encouraging exploration and experimentation

Reward players for discovering hidden secrets or trying new strategies.
Create a sense of mystery and curiosity to drive exploration.

Incorporating progression systems seamlessly with gameplay dynamics
To create a truly engaging gaming experience, progression systems must be designed to complement and amplify the core gameplay loop, rather than detracting from it or feeling like an afterthought. This can be achieved by carefully considering how various progression elements can be intricately woven into the game world, its narrative, and the mechanics that govern player interactions.

Fostering exploration and experimentation through incentives
One effective way to encourage players to explore the game world and experiment with different strategies is by offering them tangible rewards for uncovering hidden secrets or successfully employing novel tactics. These incentives can take the form of in-game currency, unique items, or even access to new areas or abilities that further enrich the gaming experience.

Cultivating a sense of mystery and curiosity to propel exploration
To truly captivate players and motivate them to delve deeper into the game world, it's essential to create an atmosphere of mystery and curiosity. This can be achieved by incorporating intriguing storylines, enigmatic characters, and cryptic clues that hint at the existence of undiscovered secrets. By fostering a sense of wonder and intrigue, players will be more inclined to venture off the beaten path and immerse themselves in the rich tapestry of the game world.

Implementing progression systems in different game genres

Progression systems can be tailored to fit various game genres, such as:

Role-playing games (RPGs)

Focus on character development, including leveling, skill trees, and gear upgrades.
Incorporate story-driven progression elements, such as unlocking new areas or abilities through narrative events.

Action-adventure games

Emphasize exploration and discovery, with progression elements tied to uncovering new locations or abilities.
Balance combat and puzzle-solving challenges with appropriate rewards.

Puzzle games

Use progression systems to introduce new mechanics or increase difficulty over time.
Reward players with new levels or modes upon completing certain milestones.

Strategy games

Implement progression systems that allow players to unlock new units, buildings, or technologies.
Balance short-term and long-term progression goals to maintain player interest.

Sports and racing games

Progression systems can include unlocking new vehicles, tracks, or customization options.
Use skill-based progression elements, such as improving player stats or abilities.

Player feedback and analytics

Gathering player feedback and analyzing data can help refine and improve progression systems:

Gathering player feedback

Use surveys, forums, or social media to collect player opinions on progression systems.
Pay attention to common issues or suggestions for improvement.

Analyzing player behavior and data

Monitor player behavior, such as time spent playing, progression speed, and areas of difficulty.
Use data to identify areas where progression systems may need adjustment.

Adjusting progression systems based on feedback and analytics

Make adjustments to progression systems based on player feedback and data analysis.
Iterate on design and implementation to continuously improve the player experience.

Conclusion

Well-designed progression systems are essential for maintaining player engagement and creating a satisfying gaming experience. By tailoring progression systems to specific game genres and continuously refining and improving them based on player feedback and analytics, developers can ensure that their games remain engaging and enjoyable for players.

Godot at Gamescom 2023

Godot — Thu, 17 Aug 2023 19:09:08 +0000

Just want to make a quick shoutout that Godot will be having their first booth at Gamescom 2023, thanks to Ramatak & W4Games donations for the booth.

// Detect dark theme var iframe = document.getElementById('tweet-1692215009974104221-424'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1692215009974104221&theme=dark" }

Where

Koelnmesse, Messepl. 1, 50679 Köln, Germany (map)

When?

August 23rd, 2023. Wednesday 13:00 - 19:00
August 24th, 2023. Thursday 10:00 - 20:00
August 25th, 2023. Friday 10:00 - 20:00

Which Location?

Godot booth in the Business Area, Hall 2.2, Stand C-042. Check the map below:

For those who don't know about Gamescom, it is a trade fair for video games held annually at the Koelnmesse in Cologne, North Rhine-Westphalia. It is the world’s largest gaming event (measured by exhibition space and number of visitors), with 370,000 visitors and 1037 exhibitors from 56 countries attending the show in 2018.

For more details, please check the official announcement page.

GDScript Code Ordering

Godot — Wed, 16 Aug 2023 08:07:37 +0000

GDScript Code Ordering: Best Practices for Arranging Your Code Elements

When it comes to writing clean and organized GDScript code, the ordering of code elements plays an essential role in enhancing readability and maintainability. In this post, we'll explore best practices for ordering different code elements within your GDScript files.

Introduction to Code Ordering

Code ordering refers to the systematic arrangement of different code elements within your GDScript files. Having a consistent and logical order makes it easier for developers to quickly grasp the structure of your code and find specific elements. While there is no strict rule for code ordering, following some common conventions will lead to well-organized and easily maintainable code.

Recommended Code Element Ordering

Below, we present a recommended order for organizing code elements within your GDScript files. Remember that these conventions are guidelines, and you can adjust them to suit your project's needs and team preferences.

Declaration

Begin by listing all necessary class declaration statements at the top of your GDScript file. These statements help you access external classes and modules within your script.

class_name Player extends CharacterBody2D

If your script is a tool (ie running in the Editor), make sure you put the annotation at the very top of the code

@tool
class_name Player extends CharacterBody2D

You might need to save and reopen the scenes/script for it to take effect.

Signals

After that, define the signals that your script emits. Signals are custom events that allow communication between nodes, therefore it is beneficial to have it right up above.

class_name Player extends CharacterBody2D

signal health_depleted
signal player_moved(Vector2)

Enums

If your script uses enums, you can do so after the signals. Enums are user-defined sets of named constants and are often used to represent different states or options.

enum GameState { MENU, PLAY, PAUSE }
enum Direction { UP, DOWN, LEFT, RIGHT }

Constants

Next, define any constants that your script requires. Constants are values that do not change during runtime and are better suited for this early section of your script.

const MAX_SCORE: int = 100
const PLAYER_SPEED: float = 200.0

Class Variables

Now, organize your class variables. Group them into different subsections based on their purposes.

Export Variables

Export variables come first, as they allow you to expose certain variables in the Inspector. This makes them easily accessible and configurable from the Godot editor.

# Good export variables ordering example
class_name Player extends CharacterBody2D
...
...
@export var player_name: String = "Player"
@export var player_health: int = 100

Regular Variables

Then, list your regular class variables, public and private. You can mark a variable as a private by prefixing them with _ underscore. Doing so will hide your variable from showing inside the built in IDE Documentation.

class_name Player extends CharacterBody2D

var score: int = 0
var _is_gameover: bool = false #private, will not appear on docs

Onready Variables

Onready variables come last after every other variables. They represent references to nodes that you need early on right after initialization.

class_name Player extends CharacterBody2D
...
...
@onready var player_sprite: Sprite = $PlayerSprite
@onready var enemy_spawner: EnemySpawner = $EnemySpawner

Constructor and Initialization

After the class variables, you can include the constructor (also known as the _init method) if you need to initialize any variables. Note that overriding the _init, _ready, _enter_tree or other built-in virtual function is optional.

# Good constructor and initialization ordering example
class_name Player extends CharacterBody2D

# Constructor
func _init() -> void:
    player_additem(Item.SWORD)
    player_additem(Item.SHIELD)

func _enter_tree() -> void:
    var parent_name = get_parent().name
    print("Parented to: " + parent_name)

func _ready() -> void:
    _sync_textures()
    _sync_animations()

Public Methods

Finally, place your class public methods. Group them based on their purposes or relevance to specific aspects of your script.

# Good class methods ordering example
class_name Player extends CharacterBody2D

# Initialization methods
func _ready() -> void:
    pass

# Player movement related methods
func move_player() -> void:
    pass

# Player combat related methods
func damage_player() -> void:
    pass

Private Methods

Methods of your class can be marked as private by prefixing them with _ underscore. Private variables and private methods that are prefixed by _ will not appear when you open Search Help (F1) of this particular class.

func _internal_check(): # _internal_check will not appear in IDE Help
    pass

Code Organization in Functions

Within your class methods, aim for consistent code organization to maintain readability.

Arguments

List function arguments in a logical order, with required arguments first and optional arguments last.

# Good function arguments ordering example
func move_player(direction: Vector2, speed: float = 200.0):
    pass

Local Variables

Declare local variables at the beginning of the function before using them.

# Good local variables ordering example
func calculate_score(score_value: int) -> int:
    var bonus_score: int = 10
    return score_value * 2 + bonus_score

Function Logic

Organize the logic of your functions in a way that is clear and easy to follow. Consider using comments to explain complex sections. Best code is the one that doesn't require comments and innately self explanatory.

func is_game_over() -> bool:
    if player_health <= 0 and player_lives <= 0:
        return true
    else:
        return false

Example

Now with all that said and done, here is the final snippet to sum it all up. See it in action.

Note: The examples and conventions provided in this post are intended as guidelines. Feel free to tailor them to your specific needs and preferences. Consistency is key!

@tool
## This is the Player class, representing the player character in the game.
class_name Player extends CharacterBody2D

# Signals
signal player_hit
signal player_jump

# Enums
enum PlayerState { IDLE, RUNNING, JUMPING, FALLING }

# Constants
const MAX_HEALTH: int = 100
const MAX_SPEED: float = 150.0

# @export variables
@export var player_name: String = "Player"
@export var player_health: int = MAX_HEALTH

# Public variables
var player_state: PlayerState = PlayerState.IDLE

# Private variables
var _is_invincible: bool = false
var _jump_power: float = 400.0

# @onready variables
@onready var player_sprite: Sprite2D = $Sprite2D
@onready var collision_shape: CollisionShape2D = $CollisionShape2D

# Optional built-in virtual _init method
func _init():
        player_health = MAX_HEALTH
        _is_invincible = false

# Optional built-in virtual _enter_tree() method
func _enter_tree():
        # Code here will be executed when the node enters the scene tree.
        pass

# Built-in virtual _ready method
func _ready():
        # Code here will be executed once when the node is added to the scene and ready.
        pass

# Remaining built-in virtual methods
func _process(delta: float):
        # Code here will be executed every frame (if the node is added to the scene and ready).
        pass

# Public methods
func take_damage(damage_amount: int):
        if not _is_invincible:
                player_health -= damage_amount
                if player_health <= 0:
                        emit_signal("player_hit")

func jump():
        if is_on_floor():
                player_state = PlayerState.JUMPING
                apply_impulse(Vector2.UP * _jump_power)
                emit_signal("player_jump")

# Private methods
func _on_invincibility_timer_timeout():
        _is_invincible = false

# Subclasses
# Add any subclasses here, if applicable.

Summary

Following an organized code ordering is crucial for creating clean, maintainable, and readable GDScript code. By adopting a consistent approach to arranging your code elements, you can improve collaboration within your development team and make it easier for other developers to understand and contribute to your projects.

Remember that the conventions provided in this post are recommendations, not strict rules. Feel free to adapt them to your project's needs and your team's preferences. The key is to maintain consistency throughout your codebase, making it easier for everyone to work together efficiently.

Happy coding, and may your GDScript projects shine with well-organized and easily understandable code! 🚀🎮

GDScript Coding Conventions

Godot — Mon, 14 Aug 2023 10:10:27 +0000

Hello fellow DEV community!

Today, I want to dive into an essential topic that often gets overlooked but plays a crucial role in creating clean, readable, and maintainable GDScript code: coding conventions. Consistent coding conventions not only make your code more organized but also contribute to the overall productivity and collaboration within your development team. So, let's explore some best practices for writing GDScript code, including naming conventions for assets, scenes, and nodes.

Introduction to GDScript Coding Conventions

Coding conventions are a set of guidelines and rules that developers follow to maintain consistency in their codebase. They help create a standardized format, making it easier for developers to understand each other's code and contribute effectively. GDScript, as a flexible and Python-like scripting language, allows developers to write code in various ways. However, sticking to a common set of conventions enhances code quality and makes your projects more robust.

In this post, we'll cover some general coding conventions and delve into naming conventions for variables, functions, classes, and more. Additionally, we'll explore how to apply these conventions to assets, scenes, and nodes in your Godot projects.

General Coding Conventions

Indentation

Consistent indentation is vital for code readability. GDScript generally uses tabs for indentation. Avoid using spaces, as different editors might interpret them differently.

# Bad indentation example
func calculate_score(score_value: int) -> int:
    if score_value > 100:
        return score_value * 2
    else:
        return score_value

# Good indentation example (using tabs)
func calculate_score(score_value: int) -> int:
    if score_value > 100:
        return score_value * 2
    else:
        return score_value

Line Length

To enhance code readability, aim to keep your lines of code within a reasonable length. A common practice is to limit lines to around 80 characters. If a line becomes too long, consider breaking it into multiple lines or using parentheses for better formatting.

# Good line length example
func _ready():
    var message = "Hello, Godot developers! Welcome to our community."
    print(message)

# Bad line length example
func _ready(): var message = "Hello, Godot developers! Welcome to our community."; print(message)

Whitespace

Use whitespace judiciously to separate different parts of your code and improve readability. Add spaces after commas, around operators, and between function arguments.

# Good use of whitespace example
func calculate_total_score(score1: int, score2: int) -> int:
    return score1 + score2

# Bad use of whitespace example
func calculate_total_score(score1:int,score2:int)->int:
    return score1+score2

Comments

Add comments to explain your code and its purpose. Well-commented code helps other developers, including your future self, understand the logic and functionality of your code.

# Good use of comments example
# This function calculates the total score by adding two individual scores.
func calc_total(s1: int, s2: int) -> int:
    return s1 + s2

# Bad use of comments example
func calc_total(s1: int, s2: int) -> int:
    return s1 + s2

Nevertheless, the best code is the code that doesn't require comments as it is innately self explanatory.

func calculate_total_score(score1: int, score2: int) -> int:
    return score1 + score2

Naming Conventions

Variables and Constants

Use descriptive names for variables and constants that indicate their purpose. Names should be in lowercase, with words separated by underscores.

# Good variable naming example
var player_health: int = 100
const MAX_ENEMIES: int = 10

# Bad variable naming example
var p: int = 100
const max: int = 10

Functions and Methods

Function and method names should also be descriptive and use lowercase letters with underscores to separate words.

# Good function naming example
func calculate_score(score_value: int) -> int:
    return score_value * 2

# Bad function naming example
func clc(score: int) -> int:
    return score * 2

Classes and Enums

Use PascalCase for class and enum names. Class names should be nouns, while enum names should be singular nouns.

# Good class and enum naming example
class Player:
    enum Direction { UP, DOWN, LEFT, RIGHT }

# Bad class and enum naming example
class playeR:
    enum direction { UP, DOWN, LEFT, RIGHT }

Naming Conventions for Assets and Scenes

Assets

When naming assets, camel_case, use lowercase letters and separate words with underscores. Be descriptive and use meaningful names that indicate the asset's purpose. The reason why we use all lowercase letters is that each platforms have different ways in treating uppercase and lowercase in file names.

# Good asset naming example
main_room.tscn
main_room.gd
background_image.png
enemy_sprite.png
jump_sound.wav

# Bad asset naming example
mainRoom.tscn
mainRoom.gd
bg.png
spr1.png
sound1.wav

Nodes

Nodes in scenes should follow PascalCase conventions. Choose descriptive names that represent the node's functionality.

# Good node naming example
PlayerCharacter
EnemySpawner
ScoreLabel

# Bad node naming example
Player
Node2D
Label

Coding Style

Consistency is key when it comes to coding style. Ensure that you and your team members follow the same conventions throughout your project. Adopting a consistent coding style improves readability and makes your code look professional.

In addition to the conventions mentioned above, consider adopting the following practices:

Use Meaningful Names: Always choose meaningful names for variables, functions, classes, and nodes. Avoid single-letter or vague names that might confuse other developers.
Be Mindful of Abbreviations: While abbreviations can save typing, be cautious with them. Avoid using obscure or ambiguous abbreviations that might not be immediately understandable.
Avoid Magic Numbers: Instead of using literal values in your code, assign them to constants with descriptive names. This improves code readability and makes it easier to maintain.
Limit Function Length: Aim to keep your functions short and focused. Long functions can become difficult to manage and understand.
Organize Code Logically: Structure your code in a logical manner, breaking it into meaningful sections or using comments to group related code together.

Code Reusability

An essential benefit of following coding conventions is that it promotes code reusability. When your code is well-organized and follows consistent conventions, you can easily reuse functions, methods, and classes across different projects.

By applying the same conventions to your assets, scenes, and nodes, you can also streamline your workflow when working with Godot Engine. Consistent naming and organization help you find and manage resources more efficiently, resulting in a smoother development process.

Summary

Coding conventions are an invaluable tool for any Godot developer seeking to create clean, readable, and maintainable code. In this post, we explored some general coding conventions, including indentation, line length, whitespace, and commenting. We also discussed naming conventions for variables, functions, classes, enums, assets, scenes, and nodes.

Adopting coding conventions in your projects enhances code quality, increases collaboration within your team, and facilitates code reuse. Consistent naming and organization make it easier for you and other developers to understand and contribute to the codebase effectively.

Remember that while coding conventions offer a set of guidelines, they are not set in stone. You can adapt them to suit your team's preferences and requirements. What matters most is that you and your team members follow the same conventions consistently throughout your projects.

Happy coding, and may your Godot projects thrive with clean and maintainable code! 🚀🎮