What is cool about Web3 Gaming and why am I writing about it on a coding website?

There are many things that are cool about web3 gaming. Here are a few of the most notable:

Ownership: In web3 games, players own their in-game assets. This means that they can trade or sell them to other players, or use them in other games. This gives players more control over their gaming experience and allows them to earn money from playing games. If you have ever wondered about the game world and got a thrill from collecting all the gold, money, crafting resources, etc. then Web3 games multiply this adrenalin hit 100 fold.

Transparency: Web3 games are built on blockchain technology, which is a transparent and secure ledger. This means that all transactions in web3 games are public and can be verified by anyone. This gives players peace of mind knowing that their in-game assets are safe and secure. Want to trade, swap, or give away that new shield or cool outfit, you can.

Interoperability: Web3 games are designed to be interoperable, which means that in-game assets can be used in other games. This creates a more open and connected gaming ecosystem where players can take their assets with them wherever they go.

But actually, there is an even bigger, more urgent reason than any of these and it is less to do with gaming specifically and more to do with society, culture, and, unfortunately, global politics. I won’t bother you with it until the end of the article.

The problem with Web3 gaming

Actually, there are quite a few. First, there is not a single game that fully realizes the vision I outlined above. Second, the games which are closest to the vision like some of the Gala Games titles, Illuvium, or The Sandbox are all, without exception, overpriced. My best prediction for a web3 game that can go mainstream and please everybody – but still isn’t done yet – is Off the Grid from Gunzilla.

Third, I think Web3 is a stupid name. Web3 doesn’t just refer to games, it refers to the wider crypto economy. As, currently, most of the applications of this economy are interacted with through websites, the name has stuck. I think that a truly decentralized crypto economy including games will be better when we are downloading native to the OS apps from decentralized storage. I am working on such a game myself but I am not ready to share the details.

Fourth, even if the cost of entry is not a barrier to you, it is a significant learning curve to understand all the bits of crypto infrastructure like wallets, exchanges, tokens, and NFTs required to get started.

Finally, there has been no end of scams and just downright crappy games that have given the haters more ammunition.

You might be thinking that web3 gaming is doomed. I actually believe that the use case is so compelling that all these problems can be overcome but it would take a whole book to explain why. If you are keen to find out more, check out my crypto tutorials for beginners. If not, just sit back and wait for the revolution or, better, learn to code web3 games with my new Solidity tutorials. On to the haters.

Why do existing game developers and game media not like Web3 Gaming?

There are a few reasons why existing game developers and game media may not like web3 gaming. Here are a few of the most notable:

Competition: Web3 gaming is a new and disruptive technology that could pose a threat to the existing gaming industry. This is because web3 games offer a more immersive and rewarding experience for players, which could lead to players abandoning traditional games in favor of web3 games.

Complexity: Web3 gaming is a complex technology that can be difficult to understand for both developers and players. This could make it difficult for developers to create web3 games, and for players to understand how to play them.

Regulation: Web3 gaming is a new and emerging industry, which means that there is a lack of regulation. This could make it difficult for developers and players to know what is and is not allowed in web3 games.

Web3 gaming is a new and exciting technology that has the potential to revolutionize the gaming industry. However, there are still a number of challenges that need to be addressed before web3 gaming can become mainstream. These challenges include the need for more developers to understand and adopt web3 technology, the need for more players to understand how to play web3 games, and the need for more regulation in the web3 gaming industry. Despite these challenges, the potential of web3 gaming is undeniable. With its focus on ownership, transparency, and interoperability, web3 gaming has the potential to create a more immersive, rewarding, and open gaming ecosystem for players.

why has web3 gaming been slow to take off

There are a number of reasons why web3 gaming has been slow to take off. Here are a few of the most notable:

High entry barrier: Web3 games require players to have a cryptocurrency wallet and to understand how to use it. This can be a barrier to entry for many players, especially those who are not familiar with cryptocurrency.

Lack of high-quality games: There are a number of web3 games available, but many of them are not very good. This has made it difficult for web3 gaming to attract a large number of players.
Concerns about security and scams: There have been a number of scams and security issues associated with web3 gaming. This has made some players hesitant to participate in web3 gaming.

Regulation: The web3 gaming industry is still in its early stages, and there is a lack of regulation. This has made it difficult for developers and investors to know what is and is not allowed in web3 gaming.

Despite these challenges, the potential of web3 gaming is undeniable. With its focus on ownership, transparency, and interoperability, web3 gaming has the potential to create a more immersive, rewarding, and open gaming ecosystem for players. As the web3 gaming industry matures and these challenges are addressed, web3 gaming is poised to take off.

Here are some of the things that can be done to help web3 gaming take off

More developers need to create high-quality web3 games: There are a number of web3 games available, but many of them are not very good. This has made it difficult for web3 gaming to attract a large number of players. More developers need to create high-quality web3 games that are fun to play and that offer players a compelling experience.

The web3 gaming industry needs to address concerns about security and scams: There have been a number of scams and security issues associated with web3 gaming. This has made some players hesitant to participate in web3 gaming. The web3 gaming industry needs to address these concerns and take steps to ensure that players’ assets are safe.

The web3 gaming industry needs to be regulated: The web3 gaming industry is still in its early stages, and there is a lack of regulation. This has made it difficult for developers and investors to know what is and is not allowed in web3 gaming. The web3 gaming industry needs to be regulated in a way that is fair to both developers and players.

If these things can be done, web3 gaming is poised to take off. With its focus on ownership, transparency, and interoperability, web3 gaming has the potential to create a more immersive, rewarding, and open gaming ecosystem for players.

Examples and short descriptions of web3 games and platforms

Axie Infinity: Axie Infinity is a Pokemon-inspired game where players can collect, breed, and battle Axies, which are digital pets. Axies are non-fungible tokens (NFTs), which means that they are unique and can be traded or sold. Players can earn rewards in the form of Axie Infinity Shards (AXS) and Smooth Love Potions (SLP) by playing the game.

The Sandbox: The Sandbox is a virtual world where players can create, own, and monetize their own gaming experiences. The Sandbox uses the Ethereum blockchain to power its economy, which means that players can buy, sell, and trade in-game assets using cryptocurrency.

Decentraland: Decentraland is another virtual world that uses the Ethereum blockchain. Decentraland is a 3D world where players can explore, build, and interact with each other. Players can buy land in Decentraland, which they can then use to create their own games, experiences, and businesses.

Gods Unchained: Gods Unchained is a collectible card game where players can collect, trade, and battle cards. Gods Unchained uses the Immutable X blockchain, which is a layer-2 scaling solution for Ethereum. This means that players can trade battle cards without having to pay high gas fees.

Alien Worlds: Alien Worlds is a play-to-earn game where players can mine Trilium (TLM), the native token of the game. TLM can be used to buy land, upgrade tools, and participate in governance. Alien Worlds is one of the most popular web3 games, with over 1 million registered players.

These are just a few examples of the many web3 games and platforms that are available. Most of them are mediocre in their current sate but some of them are evolving rapidly. As the web3 gaming industry continues to grow, we can expect to see even more innovative and exciting games being developed.

Summary

The WEF is coming for gaming make no mistake! They want to sanitize player interactions by promoting victimhood amongst certain demographics of gamers and once gamers have been pacified the advertisers will move in and a rental/advertising model for all consoles and eventually PCs through Windows 11 will ensue. You will own nothing and be happy. Web3 or whatever we end up calling it is the best chance we have of beating this dystopian future.

What SFML isn’t

Let’s quickly state was SFML is not. It is not an all-in-one solution for all your game development needs like Unreal Engine, CryEngine or Unity. It will not let you design huge realistic 3d worlds, build 3d models or create movie-like cut-scenes. Although if you are quite expert you can make 3d games with it, that is not it’s strength. It does not offer point and click tools for even 2d games like Game Maker Studio although you can build amazing 2d games far better than anything that can be done in GameMaker Studio*.

What it is

SFML is perfect for writing 2d games of any size or complexity at all. If you want to learn game coding and your favourite device is your PC, Mac or Linux; SFML is the best choice providing the above limitations are not an issue for you. If you dream of publishing 2d games for any of the desktop platforms, perhaps you want to get your cool idea onto Steam? If this describes you then SFML is for you.

SFML stands for simple fast media library and for once the acronym is entirely accurate. Let’s deal with the simple bit first.

Simple

Take a look at this next code sample. Don’t try and understand it just scan your eyes over it and then continue with the article.

// Win32Project4.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "Win32Project4.h"

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE hInst;                                // current instance
WCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
WCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name

// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: Place code here.

    // Initialize global strings
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_WIN32PROJECT4, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WIN32PROJECT4));

    MSG msg;

    // Main message loop:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}

//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WIN32PROJECT4));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_WIN32PROJECT4);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Store instance handle in our global variable

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // Parse the menu selections:
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);
            // TODO: Add any drawing code that uses hdc here...
            EndPaint(hWnd, &ps);
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

That was pretty scary!

The previous code is what you need to do in Windows to get a completely empty window- that does absolutely nothing!

If you have read any game development tutorials in the past you will know that there are components that all games need. A place/interface to draw your graphics, like-wise to control the logic of the game and handle input from the player. Furthermore the above code does not include a controlled loop known as the game loop to repeatedly process and draw all the frames of the game. Add all that into the code above and you will at least quadruple the code and it will be spread over multiple complex files.

Now consider if you want your game to run on Mac, PC and Windows then all of this code will be different for each of the desktop operating systems.

In the next code sample all the lines of code that start with // are comments to explain what is happening. Now look at this SFML code:

// Include some code from the SFML library
#include <SFML/Graphics.hpp>

// This is where our game starts
int main()
{
	// Make a window that is 1920 by 1080 pixels in size
    sf::RenderWindow window(sf::VideoMode(1920, 1080), "My Cool Game");

    while (window.isOpen())
    {// Game loop starts here

        //Handle input from the keyboard, mouse and controller

		// Process movement, AI and other logic here

		// Rub out the last frame
        window.clear();

		// Draw the current scene here

		// Show the current scene
        window.display();

    }// Do all of the above over and over again

// User has quit- go back to the operating system
    return 0;
}

The previous code not only does everything that the rather frightening Windows code did but it also provides a place to draw, process logic and handle player input. Oh yes, and the curly brace { next to the // Game loop starts here comment, down to the closing curly brace } by the comment that says // Do all of the above over and over again is the game loop. The same code can also be made(compiled) to run on all three of the major desktop operating systems.

We can then draw things to the screen with simple code like this.

// Draw a previously defined shape in the main game loop
window.draw(shape);

We can play soundFX with code like this:

// Play a previously prepared sound
sound.play();

We could even send packets of data over the Internet to build multi-player games with code as simple as this:

// Send a previously prepared message across the Internet to another computer
tcpSocket.send(message, msgSize);

It is true that as our projects grow into complete games they will become complex eventually but the point is that SFML is perfect, through it’s simplicity, for a beginner and yet because of it’s depth and speed is something we won’t grow out of if we have the dedication to become a professional. And we can steadily build up the complexity so it doesn’t overwhelm us.

What about the F for fast then?

Fast

C++ is a language which is turned (compiled) into native executable programs by the software (compiler) that we use to write our code. This means that it is super-fast because it works directly with the software subsystems of our computer without any layers to slow it down. I mentioned in the previous section that the simple SFML code we looked at previously included the game loop. On my ageing laptop that game loop runs at around 2000 frames per second. Of course as we add more logic and drawing into our games this will reduce but the point is SFML makes it simple to write very fast code.

Media Library

SFML is a library, a library of C++ code organized into 5 modules that handle all the fundamentals of game programming. We use the library by writing our own C++ code (like in the previous examples) to call the code from the SFML library. We don’t need to see this SFML library code, we don’t even really need to know how it works internally.

SFML conclusion

SFML IS NOT for you if:

• You want to build amazing 3d worlds or characters especially if you want user friendly GUI tools
• You want to build any type of game by pointing, clicking, dragging and dropping
• You want your game done by tea time
• You want to avoid learning and writing real code

SFML IS for you if :

• You want the fastest possible language and library
• You want to learn to actually code games from scratch
• You are looking for a fun way to learn C++
• You want to make 2d games for desktop (Mac, Windows, Linux) that can go way beyond more friendly environments like GameMaker Studio
• You aspire to be a professional/indie developer who has a career making 2d games for desktop**

If you want to begin to learn C++ then take a look at the growing range of c++ game coding beginner tutorials and if you want to dive in to SFML straight away here is my click by click guide to getting started with SFML and Microsoft Visual Studio.

*I am not knocking GameMaker Studio it is a great tool but there are differences. It is true that you could have a simple working game in GameMaker Studio much faster than with SFML and if that is your goal then I highly recommend it.

**SFML can actually make games for Android and iOS. At the time of writing I am not considering any tutorials because it is complex, relatively untested and there are arguably better and simpler ways to make cross platform games between mobile and desktop. This could change of course and if it does, by learning SFML now you will be well placed to learn the extra steps to make games for mobile devices.

So, you know you’re serious about building games but what should you do next?

The 3 getting started questions of doom

There are a lot of different ways to make games. Loads in fact. And a surprisingly high number of these options are suitable for complete beginners as well as the seasoned professionals. This is good because it gives us choice, but is awkward because this choice can cause confusion as to what is the best way. Are you going over and over the same 3 unanswered questions? I call them the “getting started questions of doom!”

1. Which is the best language (C++, C#, Java, insert half dozen more possibilities here) to use/learn?
2. Which platform should I build for(PC, Android, iOS, something else, all of them)?
3. Which game engine or gaming library (if any) should I use/learn?

If you feel confident that you already know the answer to these questions and just want to get game building then click the button below.

Trying to answer these questions is like trying to choose who to vote for before you have heard the policies. It’s stupid and leads to a very bad place.

Yet at the same time, the answer to these questions is vital if you are to be able to get started with confidence. Furthermore, trying to answer these questions directly will likely lead to no answers or even worse the wrong answers. Kind of like just listening to the political policies rather than considering if they are genuinely held beliefs and achievable. “I will make your life better”. You would be wise to ask, “how exactly”? Yet you must answer these questions and answer them correctly.

If you ever get that sinking feeling knowing you have just lost a day of your life on social media or watching daytime TV; trust me, that is nothing compared to months of learning a programming language, game engine or platform specific library when it turns out it can never deliver what you want. (No more political analogies).

The truth is there is no “best” platform, game engine or programming language! Anyone who tells you there is, without discussing it with you personally and in great depth first, is just plain wrong.

To help you arrive at the correct answers for you and get you started as quickly as possible, let’s start by answering three, much more useful(and easier to answer) questions.

The 3 getting started questions of enlightenment

Here are a small selection of possible answers:

• You want to be the head programmer at Bethesda, Valve or ID etc.
• Maybe you want to find fortune and fame as an indie dev’
• Perhaps you just want the fastest, simplest route to getting something, nay anything published
• You just want to have fun
• Do you have a story inside your mind that absolutely must be told – sometime before you die
• Something else entirely?

Think about the first question a little before moving on to the second.

Yes, there is always a price. If you go for a half hour run the price is half an hour lost on either work, family life or something else you might have done. You need to first accept that building a game is going to take a while. Should personal/family financial considerations take preference over any of these other goals and how much time are you prepared to put into this game programming thing? A weekend, a year, as long as it takes?

There are so many different types of game and which one you want to make will certainly steer you towards different learning pathways, engines, and languages. Be sure to decide on the genre, 3D, 2D, First person shooter, RPG, survival, retro, something totally new, etc. Will your game work best on a particular device type or platform? Do you specifically want to target a particular platform or is it the more the merrier?

Notice that the above questions might be challenging and deep to answer but unlike the “getting started questions of doom”, the “getting started questions of enlightenment” don’t need Google, an expert or even me to help you answer them. The previous three questions can be consolidated as follows.

Where do you want to go, what price are you prepared to pay and what game are you going to make next/first?

Think about them for a bit, they will help you make the right decisions.

I have answered the questions – Tell me the answers to the questions of doom already!

By now you should know your personal game building goals, determination, and game specifics or at least be formulating them. Certainly, your goals might change along the way and you can always make changes in direction but at least you will be starting out based on what you want to achieve rather than the latest trend that sounded good at the time.

Choosing a language, platform, and engine

The platform might already be a part of your plans at this stage. The language and engine, however, still need to be chosen. In the table that follows you can easily target your language and engine options based on your genre and target platforms (if they are decided already).

Take a look over the following table. Use the priorities from your goals to target the appropriate game building solution (engine/library/tool) and then study the row (which represents the attributes of a specific game building solution) to see if it also matches your other priorities or requirements. There will always be a match! But, there will always be compromises to be made too. These are YOUR compromises based on YOUR goals. There are no universal right or wrong answers.

* Separate developer license required from each console manufacturer.

Disclaimer: There are even more ways of building games.

Hopefully building a clear view of exactly what it is you want to achieve will make the table of options super-useful in identifying the best path for you. Having started to nail down or at least tentatively Blu-tac your answers to the getting started questions of doom you will need to know where to go next.

Matching your choices to learning pathways – Game programming courses

I have started putting together some “learning pathways” in the form of game programming courses. Each course comprises multiple modules. They are designed to take you from complete beginner to developer. Some of the modules are completely free, some are paid and others are a bit of both.

Once you have chosen a pathway/course the only other question that needs answering is what knowledge if any do you already have with your chosen language/platform(s)/engine etc? Compare the Knowledge Checklist section of each module of your chosen pathway/course to see which ones you can skip and when required click the Module Content tab to see the specific tutorials, projects, books and videos required to gain the knowledge.

As you can see below, all the courses are not available yet. They will be soon I promise. Eventually, I will have a pathway/course for every viable option but it takes quite a significant amount of time to put each one together. Where the full detailed course and its modules are not available but I have started on tutorials, I point you instead to the appropriate beginner programming language tutorials and engine/library example projects. These tutorials and projects start from zero knowledge just like the courses.

It is now that you might get this funny feeling in your stomach. A feeling of anticipation, excitement and urgency. You will absolutely know- without any doubt that not only have you got a game inside of you but you can get it out too.

ANDROID GAME PROGRAMMING COURSE

Beginner to developer

Build more than a dozen playable games, in excess of 50 working apps and a bit of theory too!

UNITY 2D GAME PROGRAMMING COURSE

Beginner to developer

Coming Soon!

If you are new to game programming with Unity then while you are waiting for the full course, take a look at these beginners C# tutorials and these beginner Unity game projects.

ANDROID APPLICATION PROGRAMMING COURSE

Beginner to developer

Coming Soon!

While you’re waiting for the full course to be available take a look at my book Android Programming for Beginners.

C++ GAME PROGRAMMING COURSE

Beginner to developer

Coming Soon!

While you are waiting for the full C++ game programming course to be available take a look at these beginners C++ tutorials and these SFML game programming projects.