Articles are a great way to expand your knowledge as a programmer, by learning from the experiences of others. A good article is also interesting to read. Here is a collection of articles I recommend reading.
When implementing controller support in a game, it’s desirable for gamepads to just work without a lot of user configuration. Platform APIs are pretty useless for this, the solution is an API like SDL_GameController that allows you to target a large number of gamepads without much effort.
Each operating system has its own API for gamepad input. Windows has XInput, and Linux has the joystick and evdev APIs. When a gamepad button is pressed, applications will receive a button id. This is a number, there’s no OS way to know which button id corresponds with which button. The ids for a button are not the same on different gamepads and platforms, making it super hard to support more than a couple of devices.
if (SDL_JoystickGetButton(joystick, 8)) {
std::cerr << "no idea what button 8 is" << std::endl;
}
One thing platforms do give you is the name, model, and manufacturer of the game controller. If you test with a large number of gamepads, you can create a database from gamepad name to layout. Luckily, SDL_GameController has already done this for you. Instead of a random number, you can use a named button that will work no matter the gamepad and platform:
if (SDL_GameControllerGetButton(controller, SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_X)) {
std::cerr << "X was pressed!" << std::endl;
}
I’m a huge fan of RimWorld, a base building game where you manage a group of colonists. Rather than directly controlling the colonists, you place blueprints for buildings, mark trees for cutting, and animals for hunting. NPCs will then decide what to do automatically, based on their skills and priorities.
I’ve made two games recently with similar mechanics. The first was Ruben’s Virtual World Project (RVWP), a hybrid basebuilder/topdown shooter. The second was Tin Mining, a mining sim created as an entry to Ludum Dare 48. Both of these games allowed placing building plans that NPC workers would then build out.
In this article, I will explain how I implemented the NPC AIs, and the problems I faced.
In April 2021, I participated in my first game jam, Ludum Dare 48. Ludum Dare is a popular online game jam; this event received over 3800 submissions. The theme was “Deeper and Deeper,” and I created a game where you manage a tin mine.
The year is 1790, and the Cornish tin industry is booming. You are a businessperson who has just secured investment to build a mine. The area is known to be rich in tin, which is in high demand.
Rather than controlling your workers directly, you drag out plans for tiles to be mined and built. The workers will mine tunnels and build where ordered. They will carry mined resources to the surface to be sold.
Sandboxes can protect the user’s computer from malicious or buggy scripts. But sandboxes are difficult to get right; you need to be very careful with what you expose, and make sure you test for vulnerabilities. The Sandboxes on the Lua wiki is required reading, as it contains very helpful advice.
Many APIs in my game push Vector3s to and from Lua. It’s such a common operation,
that most of my functions used to look like this:
sol::table add(sol::table tPos) {
Vector3f pos = TableToPos(tPos);
// do something
return PosToTable(pos);
}
One of the benefits of sol is that it is able to bind Lua arguments to C++ function arguments, converting types implicitly. Having to convert from a table to a vector ourselves is quite annoying. It would be much nicer to have sol do it for us. Luckily, sol allows you to customise how types are retrieved and pushed to Lua using Customisation Points.
When trying to convert a type from Lua to C++, sol will call certain templated functions.
We will be customisating sol’s behaviour using a technique called template specialization,
which allows us to specialise a specific instance of the templated functions and structs.
By the end of this article, we’ll be able to use Vector3 directly when using sol,
allowing the above code to be turned into this:
Vector3f add(Vector3f pos) {
// do something
return pos;
}
Drop shadows are created using a Gaussian blur drawn underneath the original element. You can do this using either a fixed texture or a post-processing fragment shader.
SFML is an excellent library that can be used to create 2D games in C++. It’s an abstraction over OpenGL and various system APIs, presenting a consistent and nice interface.
There are many different approaches and use-cases to creating GUIs which a standard approach embedded in SFML would not be able to cover, which is why SFML leaves it to other libraries. Additionally, whilst the S in SFML stands for Simple, GUI code rarely is.
There are many different options to choose from when attempting to implement GUIs, some of these will be detailed below.
Ruben’s Virtual World Project is a game I’ve been working on for almost 4 years now. Recently I rewrote the rendering code to support voxel lighting and multiple z-level - heights of the map.
I wrote a raytracer and a rasteriser as part of my university course. The raytracer supported features such as indirect lighting, reflection, refraction, and a photon mapper capable of simulating the final positions of 60,000,000 photons in a few minutes (and quite a few GBs of RAM).
For the last two years, I have been working on a very ambitious game. The game is a top-down sandbox with multiplayer support. I’m aiming towards a city-based game, where players can wander around a procedurally generated city. One of the main reasons I started creating this game is to learn about multiplayer networking at a low level - client-side prediction, server-side reconcilliation, cheat preventation, and reducing the visual effect of latency.
Usecase: shells dropping in sync with firing, fake bullets, etc
You must use a particle emitter to create particles, however this doesn’t mean it’s impossible to create single particles on command. You can create a particle emitter which simply adds particles from a queue to the system
Simply get the SFGUI window size using GetAllocation, the sfml window size using getSize, then do this arithmetic:
auto window = sfg::Window::Create();
auto win_rect = window->GetAllocation();
sf::Vector2f size(win_rect.width, win_rect.height);
window->SetPosition(((sf::Vector2f)rwindow->getSize() - size) / 2.0f);
Today I’ve been doing some work on a flying simulator I’m calling “Flying Pro II”.
Five or six years ago, I created my first ever 3D video game. It was called “Flying Pro”, and it was part of a set of simple 3D video games I called “Pro Series”, for some reason. The games were made using a demo version of a propietary 3D game engine.
Hello 2015! Recently I have created an implementation of the 3D projection algorithm. It is just wireframe models. It works pretty well, except it doesn’t do frustum culling. You still see things that are behind you, but upside down.
The source code of this implementation is available under the WTFPL or CC0 licenses - you can choose which one you want to use. Use WASD to move, arrow keys to rotate, space to ascend and shift to descend.
Hi all! I’m back again for another post. This time I am going to show off a project I have had for quite a while - it is a cellular automaton which simulates the Lotka Volterra equations.