As I’m trying to still come to grips with coding in C++ (I’m a Java developer, so it’s similar, but not quite the same), I immersed myself in a few basic C++ principles these past few days. This will eventually mean a game with smarter code.

Open sesame

But all the boring programming theory was becoming kind of… well… boring, so I decided to set up the mechanics behind the player interaction with the button. And, more importantly, the button now also opens the doorway. At least… until the player steps off the button again. Here’s a short test clip:

The next update will be a lot meatier and expand even more on the player interactions with his environment. So until next time!

For this test, I’ve used the Caged Wave logo as a simple game test room, divided into two zones (thanks to a colleague for the idea). The total resolution of the game screen is 432 by 240 pixels, which is a ratio of 16:9 and should look good on most modern displays.

I’ve added five basic test sprites to the background. The first sprite is a floating head to represent the player, followed by some gold that the player has to collect by solving a basic puzzle, two states of a button that will open a (not so secret) door and a box that the player has to push on top of the button to hold the door open.

These sprites were saved as .PNG files and imported as SDL2-textures in the C++ program that will run this test.

I like to move it, move it

Then, I added some basic code to check for different inputs. Right now, the program checks if the player presses any of the W, A, S, or D keys on the keyboard and moves the sprite up (W), down (S), left (A) or right (D) accordingly.

At this point, there is not yet any collision detection in the code, so the player sprite can move wherever it likes. These limits to player movement will of course be added in a future update.

Sizing up the screen

To get to grips with window scaling options in SDL2, I also added a few zoom states to the test. The game window can be shown in the original (tiny) 432 x 240 pixel resolution, or two zoomed in modes (2x and 3x) that will perform perfect integer scales of the entire game window and all movement within. These zoom modes can be selected by pressing either the 1, 2, or 3 key on the keyboard. Pressing the F-key will toggle a full screen mode.

Below, you can see a video of all the movement and screen options working in this test. In the next blogpost, I aim to have collision detection working and some simple player interaction.

Until next time, take care!

Please leave this field empty

DON’T MISS A BLOGPOST

Be the first to know when a new Caged Wave blogpost appears!

Thank you for subscribing! Check your inbox or spam folder to confirm your subscription.

Well, since I’m not making a text adventure here (although that would be a nice genre to make a comeback), I have to know how to draw stuff onto the screen. So I’ve been figuring out how SDL2 wants me to handle things when it comes to graphics. Here’s a moving test I came up with:

The most basic test would have been just to move a box or circle around I guess, but I also wanted to test two more things: alpha transparency and changing said transparency over time, so the image would appear to pulsate.

The pulsation that’s rocking the nation

The trick to this pulsating image is first to create a hexadecimal number between 0 and 255 (my starting value is 0x33, also known as the decimal number 51), which will determine how transparent the image will appear: 0 is fully transparent, 255 is fully opaque.

Uint8 alphaValue = 0x33;

After setting this default value, I assign this variable to the native SDL2-function SDL_SetTextureAlphaMod(), that takes two arguments: the name of the image you want to apply the alpha value to, and the alpha value itself.

SDL_SetTextureAlphaMod(floatingImage, alphaValue);

When applying this alpha-blended image over the background, the image appears semi-transparent, like so:

The rest is just a simple matter of changing the alpha value over time, and voila, the moving image pulsates.

Where to go from here?

I have some ideas that will use the image blending principles in this simple test to great effect, but you’ll have to wait for a future post for more info on that. In the next post, I’ll be showing a basic gameplay interaction that will be central to the game I’m planning. See you then!

Please leave this field empty

DON’T MISS A BLOGPOST

Be the first to know when a new Caged Wave blogpost appears!

Thank you for subscribing! Check your inbox or spam folder to confirm your subscription.

I’ve written about how one of my main reasons for choosing SDL2 was it’s excellent cross-platform support. So I realized that, before I could continue coding some moving elements, I first had to create a setup that would allow me to build this project quickly for multiple systems.

The big three

So naturally I picked the big three operating systems (Windows, Linux and macOS) as my target platforms to try this on. My first test was already running on Linux, so I decided to tackle macOS next, since its Unix underpinnings make it relatively similar to Linux.

This turned out to be the case, as getting the same code up and running on macOS requires more or less the same steps as in the Ubuntu installation I had done my first test in. And before long, the same code was compiling and running on the Mac.

Windows

Then along came Windows and mucked up all my plans. The less rigid structure of this system means lots more time (and curse words) had to be spent tweaking settings and environment variables, just to make sure everything pointed at the right libraries.

So after a lot more time was spent than I’d like, the code was running on Windows as well. I wish this step had been a little more painless.

The good thing is, that the whole Windows experience made me rethink my strategy for building a bit. Instead of trying to juggle different hand-written Makefiles for different systems, I’ve concluded that it’s much smarter to use something like CMake and have that do a lot of the dirty work.

So the next step will be to get CMake doing its brave thing on all three platforms and then I’ll finally be ready to jump into some basic movement stuff.

Please leave this field empty

DON’T MISS A BLOGPOST

Be the first to know when a new Caged Wave blogpost appears!

Thank you for subscribing! Check your inbox or spam folder to confirm your subscription.

First off, the basic approach is to learn as much about how things work under the hood as possible. So the biggest limitation I’m setting myself is: no pre-existing game engines! So no Game Maker Studio, Unity, Godot, etc… just a programming language and a multimedia library, that’s it.

The language: C++

Well, it’s an industry-leading language used in game programming everywhere. And since I have some prior experience in other c-family programming languages, it’s just a good personal choice as well and will ensure I won’t have to learn a totally alien syntax. So C++ it is!

The library: SDL2

Also a deliberate choice. Mainly because SDL runs on a lot of different platforms, which will make porting of games to different devices easier. But SDL also handles a lot of the stuff that is either extremely hard, or extremely tedious to code myself. Things like handling of video, audio, input devices, etc… SDL does it all.

First blood

So that’s about where I’m at. I’m currently following some C++ and SDL2 tutorials online to get to grips with the basics. Today I managed to get a static image of the Caged Wave logo to display in a game window, which is not very spectacular, but always a good start.

Next steps are to get some sprites moving on a static background image and I’ll see where that takes me. For now, I’m signing off, ciao!

Please leave this field empty

DON’T MISS A BLOGPOST

Be the first to know when a new Caged Wave blogpost appears!

Thank you for subscribing! Check your inbox or spam folder to confirm your subscription.