DEV Community: JDBC

Making Games With Raylib Library As Senior Developer

JDBC — Sat, 09 Dec 2023 17:30:33 +0000

Imagine you are an experienced Senior Developer, so you have decided to give you the chance to build your first indie video game.

Obviously, the natural and first option seems to start learning a Game Engine like Unity or Godot with some visual tools that help you in developing your first indie game.

As I explained in my last article Is it worth to use Unity Game Engine for Indie Game Developers?, Unity engine is not a choice for different reasons.

Also, learning How to use a new visual tool and specific Game Engine workflow is not the path you really want to follow.

You have the expertise of developing software for many years and do not want to begin learning from scratch. And the truth is, you really do not need it.

Maybe you really want to keep using your favorite text editor like vim or Visual Studio Code. You would rather develop your indie video game following the old-school way, just coding it, just you and your programming expertise. You do not want more visual tools, one text editor and your knowledge should be enough.

You only want to learn how to use a game library and to write your indie game using a simple text editor running on multiple platforms.

Looking for simple Game library

In this context, three requirements are set up:

Choose an open-source and free Game library without any visual tool I must learn from scratch. The control of source code of your game has to be full.
The game library does not need any extra dependencies. Choose a text editor and start building.
The game library should be cross-platform, just one single codebase to run on multiple platforms.

At this point, you are digging into multiple game frameworks or libraries which fit into those previous requirements.

So Raylib library could be your best option. Let's code, just open your text editor like vim or VSCodium in your Windows, Linux or Mac computer and let's build our indie game with Raylib library, no extra dependencies are needed.

The best part is Raylib also supports multiple target platforms in any platform that supports C language and OpenGL: Windows, Linux, MacOS, Android, HTML, Raspberry PI...

Write once, running multiple platforms is really cool feature.

Raylib and its own history

Raylib is a simple and open-source library that was built by Ramon Santamaria starting in August 2013 to support a game development course.

Inspired by Windows XNA framework, the first stable version of Raylib 1.0 was published on November 2013 as an open-source library.

Now in December 2023, ten years later, Raylib 5.0 has been released and, along the way, it has been ported to more than 50 programming languages, known as Raylib bindings.

In words of the creator of Raylib: A simple and easy-to-use library to enjoy videogames programming.

Raylib formed by modules

Raylib architecture is defined by a set of modules named accordingly to its primary functionality.

The following image is the current Raylib 5 architecture:

Every Raylib module defines a set of functions which provides a feature to make a game easy.

For instance, rcore module defines the functions to manage windows, file system and game input.

Even some of those modules can be used in standalone mode, independently of Raylib library.

Learning Raylib

Raylib cheatsheet provides you with a quick reference for Raylib API API (functions and datatypes) in HTML and PDF format.

The Raylib cheatshee is listed and colored by its modules and datatypes: rcore, rshapes, rtextures, rtext, rmodels, and raudio,

For example, the Raylib rcore module defines these basic functions to init and close windows:

// Window-related functions
    void InitWindow(int width, int height, const char *title);  // Initialize window and OpenGL context
    void CloseWindow(void);                                     // Close window and unload OpenGL context

and functions to clear background and begin / end drawing on the screen:

 // Drawing-related functions
    void ClearBackground(Color color);                          // Set background color (framebuffer clear color)

    void BeginDrawing(void);                                    // Setup canvas (framebuffer) to start drawing
    void EndDrawing(void);                                      // End canvas drawing and swap buffers (double buffering)

Take a look at these Raylib cheatsheet to know more about Raylib features provided.

Let's code

In addition, the Huge examples collection is available to acquire how to use Raylib library in a proper form.

Choose your favourite programming language and begin to use the Rayblib binding for that language.

There are Raylib binding for +60 bindings, no excuses if you really know one programming language to begin developing your next indie game.

For example, if you are a C# expertise developer then you will use the Raylib C# binding to begin developing your video game.

Linux is also the favorite operating system for senior developers, but no problem at all, C# also works in Linux through .Net free, open-source and cross-platform framework.

Let's install DotNet for starting your first indie video game.

.Net in Linux

First step is to read the Raylib Wiki for installing Raylib library on your Linux operating.

user@linux:~$ sudo apt-get install build-essential git cmake libasound2-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev libglu1-mesa-dev libxcursor-dev libxinerama-dev

Download latest version of Raylib from github repository and build the shared version of Raylib library using make command:

user@linuxmint:~/raylib/raylib/src$ git clone https://github.com/raysan5/raylib.git raylib
cd raylib/src/
make PLATFORM=PLATFORM_DESKTOP RAYLIB_LIBTYPE=SHARED # To make the dynamic shared version.

Install the library to the standard usr/local/lib directory:

user@linuxmint:~/raylib/raylib/src$ sudo make install RAYLIB_LIBTYPE=SHARED # Dynamic shared version.

sudo make install RAYLIB_LIBTYPE=SHARED # Dynamic shared version.

Follow the Manual installation for DotNet: use wget command to download dotnet-install.sh and execute it to complete the installation process.

user@linux:~$ wget https://dot.net/v1/dotnet-install.sh -O dotnet-install.sh

That's all jolks, Raylib C# binding is installed in your Linux.

Use dotnet new command to create a new console C# project where your indie videogame single codebase will stand.

user@linux:~/raylib/first_game$ dotnet new console -n first_game

Add Raylib C# binding library using nuget:

user@linux:~/raylib/first_game$ dotnet add package Raylib-cs
user@linux:~/raylib/first_game$ ls -ltr
total 12
-rw-rw-r-- 1 jdbc jdbc  105 dic  9 12:54 Program.cs
-rw-rw-r-- 1 jdbc jdbc  342 dic  9 12:54 first_game.csproj
drwxrwxr-x 2 jdbc jdbc 4096 dic  9 12:54 obj

Editing your video game

It's time to write some C# code and execute some commands in the Linux terminal:

You could use any text editor, but we will use vim text editor to edit C# code.

Execute the following command if you do need to install it in your Linux operating system.

user@linux:~$ sudo apt-get install vim

Open up Program.cs file with vim text editor and replace everything with the following Raylib C# template for opening a window and drawing some text on the screen:

user@linux:~/raylib/first_game$ vim Program.cs
using Raylib_cs;
using System.Numerics;
using System;
using System.Text;

namespace Company.FirstGame;

public class MyFirstGame
{
    public static int Main()
    {
        const int screenWidth = 800;
        const int screenHeight = 450;

        Raylib.InitWindow(screenWidth, screenHeight, "My First Game");

        // Main loop
        while (!Raylib.WindowShouldClose())
        {
            Raylib.BeginDrawing();
            Raylib.ClearBackground(Color.RAYWHITE);

            Raylib.DrawText("Let's make an indie videogame!", 190, 200, 20, Color.BLACK);

            Raylib.EndDrawing();
        }

        Raylib.CloseWindow();

        return 0;
    }
}

Build and run your first video game using dotnet build && dotnet run commands

user@linux:~/raylib/first_game$ dotnet build && dotnet run

That's it, your first game window appears.

Is it worth to use Unity Game Engine for Indie Game Developers?

JDBC — Sun, 17 Sep 2023 12:20:14 +0000

The rules of Unity Engine have changed.

On September 12, Unity announced a new Runtime Fee based on above certain thresholds, annual revenue and game installs, starting January 1, 2024.

For instance, if indie developers used the free Unity Personal plan, getting $200k in revenue and 200k downloads in the last 12 months, then Unity company would charge $0.20 for every install above the threshold.

In fact with this announcement, Unity has becomes the enemy of indie game developers for many reasons.

Unity forum thread

The official Unity Forum tries to explain common questions / answers as the following:

If a user reinstalls/redownloads a game / changes their hardware, will that count as multiple installs?
A: Yes. The creator will need to pay for all future installs. The reason is that Unity doesn’t receive end-player information, just aggregate data.

Really?

Let's suppose the following scenario: a game is installed / uninstalled 10 times for every device of one single user, and will be counted as 10 installed games.

In this case, Unity will charge 10 times for running the game but player has only paid once for it.

Do we agree this scenario is not a good deal for you as an indie developer?

It is clear you should consider another game engine instead of Unity.

Developers reactions to Unity Runtime fee

Game developers are angry and fuming for this new pricing model. It is insane, unfair and the worst, most devs do not trust Unity ever again.

So many question are in the air:

What about pirated installs?

How Unity will track game installs?

I have spent some time analyzing which game engine is best for making indie games. In my opinion Unity Game Engine is not a good choice to make indie video games regardless this new Runtime fee.

Some reasons to avoid to choose Unity for making indie games:

Unity Engine is not open source, so you might wait for bug fixes until Unity decides in the best case.
Unity pricing model can be changed at any moment... just what they have done!. This is not a fair deal.
Unity provides a pretty good visual editor but experienced developers will prefer to write code.

From my point of view, you should use Unity Engine for two reasons:

Quick demos or testing a game design idea.
You are planning to release the game the no-paid one.

Looking for Game Engine Alternatives

This comment from official Unity Forum summarizes the lack of trust in Unity:

Question to the team: How are installs tracked on devices, I'm Not collecting any data from my players / clients and I don't plan to do so in the future. no data packages going out - Unity can't verify the numbers. Will the game be FORCED to do it? In that case I'll probably look at Godot for future projects, that's a big No for me.

Most indie developers disagree with this new Runtime fee, with many unclear arguments for updating the Unity pricing model.

How game installs will be tracked? It is an unclear question that should be answered by Unity company.

The way installs are counted is also outside of game developers' control. Is it enough to switch to another Game Engine?

Let's take a look at Game Engine based on C# programming language.

Godot Game Engine

I guess many Indie developers will switch from Unity to Godot, as the following comment extracted from the previous Unity Forum.

This is because Godot is absolutely free.

Godot provides a visual editor that is working on Windows, MacOS and Linux. The officially supported programming languages for Godot are C#, C++ and GDScript.

Just visit the following Godot's FAQ to get answers to the following three questions:

What can I do with Godot?
How much does it cost?
What are the license terms?

The short answer is you could develop exactly the same type of game using both engines Godot and Unity.

Download Godot 4.1 if you want to give it a try.

RayLib Library

Actually, Raylib is not a game engine but that's an open-source, cross-platform, minimalistic, simple and easy-to-use library to build video games without visual helpers or specific editor, just coding with your favorite text editor.

Raylib has received some awards from Google and Epic Games in the last years.

RayLib C# binding provides you the way to use C# with RayLib library, which is appropiated for senior experienced developers.

MonoGame

MonoGame is also a open-source C# Game Framework that currently supports Windows, macOS, Linux, iOS, Android, PlayStation 4, PlayStation 5, Xbox and Nintendo Switch.

It is a very interesting alternative to switch from Unity.

MonoGame also distributes tools to build content for your game.

Too many another Game Engines is out there to switch from Unity.

Let’s take a look at my story Becoming an Indie Developer with Gideros Studio if you want to develop games with a Lua based and totally free game framework.

Happy switching!

Gideros Project Template for your Indie Games

JDBC — Sun, 14 Nov 2021 17:01:03 +0000

Gideros Project Template for your Indie games

This article will explain how to create a common Gideros Project Template for all your Indie games developed using the amazing Gideros Studio.

Game configuration

The first step is to configure the game in the Gideros Studio editor.

Click on the right button of the mouse to open Gideros project properties window where you will choose your game name:

Additionally the following properties can be set from this window:

Settings tab: current version of the game, build version, retina display and autorotation.
Window tab: scale mode (recommended letterbox), logical dimensions, window size, orientation (Portrait or Landscape) and FPS (30 or 60).
Input tab: behaviour of mouse and touch events.

Starting point file

The main.lua file is the entry point for your game. The following lines have been added to the beginning:

application:setKeepAwake(true)
application:setOrientation(Application.PORTRAIT)
application:setBackgroundColor(0xffffff)

Why these lines were added?

You will check from Gideros documentation for Application Class to answer to the previous question:

Application:setKeepAwake keeps runnning your game when there is no touches for some period of time.
Application:setOrientation sets the orientation of your game: PORTRAIT or LANDSCAPE.
Application:setBackgroundColor sets the background color of your game in hexadecimal, by default 0xffffff is the white color. You could change it for another you want.

Game assets

In this point you will need to store your game assets (images, music, sounds, fonts) in some specific folder.

For this purpose the following folders within Files are created:

The images folder where all your game graphics are placed.
The sounds folder where music and sounds of your game are set.
The fonts folder where all your game fonts are localized.

Gideros Studio supports Bitmap and TrueType Fonts, I recommend to use TrueType Fonts (TTFonts).

For example download the First Fun Font which is Free for commercial use and put into fonts folder.

Loading game

Define one draw_loading local function in the main.lua file which will show the Loading text message when your game begins.

-- Loading function
local function draw_loading()
    loading = Sprite.new()

    local font =  TTFont.new("fonts/firstfun.ttf", 50)
    local text = TextField.new(font, "Loading")
    local posX = (application:getLogicalWidth() - text:getWidth()) * 0.5
    text:setPosition(posX, 280)
    text:setTextColor(0x00ff11)
    loading.text = text
    loading:addChild(text)

    stage:addChild(loading)
end

Gideros Studio uses a nodes hierarchy graph to draw something in the game screen and the stage variable is the root node in the graph.

This local function will use the Sprite and TTFont Gideros classes to do the following:

Creates a loading Sprite object which must contain the Loading text message.
Defines a local font variable which uses the TTFont Gideros class to load firstfun TrueType font with size 50.
Creates a local text variable which is a TextField object with Loading string text.
Sets the X position and the text color of the text variable.
Adds the text variable to the loading Sprite object
We wish to render loading text in screen, so adds the loading Sprite object to stage.

Detecting Platform

Define two local variables iOS and android in the main.lua file to know which is the native platform when game is running.

local iOS = application:getDeviceInfo() == "iOS"
local android = application:getDeviceInfo() == "Android"

Both variables gives you the value true when your game is running on iOS or Android device, so you can use them to write custom Lua code depending on the target device.

Scene Manager plugin

The SceneManager plugin allows you to manage all your game scenes.

Go to Plugins folder, click on right button to Add Plugin and the list with all plugins will be shown:

Select Scene Manager and Easing plugins and click on OK button to add both to your Gideros project.

Go back to the beginning of the main.lua file and use require sentence to import these plugins:

require "scenemanager"
require "easing"

Game scenes

Once you have added Scene Manager and Easing plugins, then Menu and Game scenes will be created in the Gideros project template.

Gideros provides the Sprite Class as the base class for your game scenes. A sprite object describes Scene Graph containing child nodes.

Every game scene will extends Sprite class following the oriented object programming approach.

Menu Scene

The Menu scene should be the first scene shown in your game, this is where you show the different options of your game.

First a scenes folder is created within Files, this folder is where all game scenes are placed.
Second the menu.lua file is created within scenes folder with the following Lua code:

MenuScene = Core.class(Sprite)

-- Static setup
function MenuScene.setup()

end

-- Constructor
function MenuScene:init()

end

The static setup() function allows to load all MenuScene assets (images, music, sounds, fonts,...).

The init function is the constructor for MenuScene Sprite which is called for sceneManager for creating the Menu scene.

Game Scene

The Game scene is the core game loop of your game, where the magic happens.

Just create a game file within scenes folder with the following Lua code:

GameScene = Core.class(Sprite)

-- Static setup
function GameScene.setup()

end

-- Constructor
function GameScene:init()

end

The static setup() function allows to load all GameScene assets.

The init function is the constructor for GameScene Sprite which is called for sceneManager to create the Game scene.

For instance this is how it looks menu scene in Gideros Studio editor:

Using scenes

Go back to main.lua file and write some Lua code at the end of this file:

draw_loading()
stage:addEventListener(Event.ENTER_FRAME, preloader)

The above Lua code will do the following two things:

Invoke the local draw_loading function.
Add ENTER_FRAME event listener to call the preloader function the first time screen must be rendered. Click on ENTER_FRAME event for specific info about this event.

So we need to create the local preloader function with the following Lua code:

local function preloader()
    stage:removeEventListener(Event.ENTER_FRAME, preloader)

    -- Load all your assets here
    MenuScene.setup()
    GameScene.setup()

    -- List of scenes
    scenes = {"menu", "game"}

    sceneManager = SceneManager.new({
        ["menu"] = MenuScene,
        ["game"] = GameScene
        })
    stage:addChild(sceneManager)

    -- MenuScene is the first scene to show
    local currentScene = scenes[1]

    local timer = Timer.new(2000, 1)
    timer:addEventListener(Event.TIMER, 
                function()
                    -- Remove loading scene
                    stage:removeChild(loading)
                    loading = nil
                    sceneManager:changeScene(currentScene)
                end)
    timer:start()
end

The preloader function must do the following:

Remove the ENTER_FRAME event listener. We only need to call the preloader function once.
Invoke MenuScene.setup and GameScene.setup functions to load the scenes assets.
Define the game scene list that will be used by sceneManager variable.
The variable currentScene defines the MenuScene as the default game scene.
Use Gideros Timer class to wait 2000 miliseconds until the Menu scene is shown by sceneManager variable.

Finally this Gideros Template Project should be used as starting point to develop your upcoming hit Indie game.

All my Android games published to Google Store has been developed using these template.

Enjoy it and do not hesitate to leave some comment.

Becoming an Indie Game Developer with Gideros Studio

JDBC — Sun, 18 Jul 2021 09:51:50 +0000

If you are planning to becoming an indie game developer then you should give a try to Gideros Studio Studio.

Why Choose Gideros Studio to build games?

These are the main reasons to start using Gideros for your next game:

Gideros Studio is free and open-source.
Cross-platform to publish your game to multiple platforms.
Fully IDE to develop, test and publish your game.
Easy and fast game development, ideal for prototyping.
Object oriented programming is supported.
Your game runs at Native speed in every published platform.
Gideros Studio provides a Plugins system to extend it.
Active Forum to resolve any question.

Gideros Studio is free and open source

Gideros Studio is Free

Gideros Studio is a free and open-source development environment to make cross-platform 2D games in a easy and quick way.

Gideros Studio needs OpenGL 3.0 or better and at least 1Ghz and 1Gb RAM and runs on:

Windows XP, Vista, 7, 8, 10
Mac OS X Lion or later.
Linux with Wine Emulator or compile from source code.
Raspberry Pi 2 or 3, compiling compile from source code.

You can download the Last release of Gideros Studio without cost. Anyway you can also Download and colaborate with this project to help to keep working on this project.

Gideros Studio is Open source

The Gideros Studio is also open source and available in the Github repositories, so you can study how it works.

Cross-platform

Cross-platform feature allows you to develop your game with only one code base, and publish it to multiple platforms.

The following is the list of supported platforms:

Android
iOS
HTML
MacOSX
Windows

Native speed

Gideros Studio is developed on top of C/C++ and OpenGL, so your game runs at native speed on every supported platform.

Additionally Gideros allows to develop native code for one specific platform with the provided Plugins system.

Lua programming language

Gideros Studio uses Lua programming language to help you to build your next 2D indie game.

Lua is simple and powerful programming language, if you already know another programming language as Java, C# or Javascript then do not worry, you will learn Lua in just a few days or a week.

In my opinion Lua is one of the easiest and powerfull programming language. Take a look to the official Lua web

For instance the following source code displays a PNG image at the position (100, 100)

local bmp = Bitmap.new(Texture.new("ball.png", true))
bmp:setPosition(100, 100)
stage:addChild(bmp)

Quite simple, isn't it?

Furthermore you can read the Gideros LUA API reference to know Lua modules and Enhancements provided by Gideros Studio.

Object Oriented Programming

Gideros Studio provides a Set of classes to follow a clean Object Oriented Programming approach when you build your games with Lua programming language.

The above example uses two classes, Bitmap and Texture to display image to screen.

The Texture class loads PNG image to memory and Bitmap displays the PNG to screen,write only 3 lines of code to display image to screen.

Gideros Studio IDE

Gideros Studio provides a complete Integrated Development Environment (IDE) for quick developing and testing your indie games.

Gideros Studio includes a code editor with project files manager, Lua syntax checking and find/replace tools to build your game without another external editor.

Create main.lua file as the starting point of your next indie game.

When finally you were ready to publish then Gideros Studio also allows you to export it to several platforms with no additional effort.

I've just developed my own Arkamania Brick Breaker game in just one month, published for Android and iOS.

Gideros Player

For testing purposes you will use Gideros Player with Hot Reloading feature which speeds up game development.

Change your Lua code in Gideros Studio, save and test your game instantly in Gideros Player. Repeat, repeat and repeat this process and finish your game without realizing it.

This is how looks my Flappy Creature game in Gideros Player:

Extending with Plugins

Gideros Studio Plugins is a feature which enable to develop a C/C++/Swift/Java/Kotlin library and call functions of this library from Lua code.

This is really useful when you need to integrate third-party libraries (Google Play Services, Facebook, In-app billing, Ads…) to your game.

Many plugins are already developed and available from Gideros Labs, but you can develop your own in case you need it. Usually Plugins are developed in C/C++ for all platforms, Java/Kotlin for Android and Swift/Objective-C for iOS.

You can read Creating Plugins for Android article for more information.

Awesome Gideros Resources

¿Are you still reading this article?

Let's check Awesome Gideros to know what Gideros Studio provides you to becoming an indie developer in record time and less effort you think.