Super Bobby Workd - part 5

Note: we’re just getting started - everything is supposed to look like shit at this point :-D

Huge progress today!

• Player physics (iteration 1) implemented
  • Running, sliding, jumping, falling
  • If falling too far, he screams “FAAAAAAAAAN”
• Implemented quick IMGUI-framework + auto layout
• Implemented in-game debug menu
  • Toggle player physics
  • Pause/unpause the game
  • Debug mode to not die (not implemented yet)
  • Toggle languages
• Also properly implemented “toggle sound”

This is amazing progress for about 5 days work! Almost all the major pieces are in place to run around now. What’s missing is the ability to die, which I’ll handle tomorrow (work in progress).

It puts me in a great spot - timewise. I’ve got a full 9 more days before my deadline of a playable demo, and I have one more, really big feature left: a Level editor. But 9 days for a level editor and put together some levels seems absolutely doable.

Of course, the game also lacks a ton of content. Enemies, interactables and such. Adding more stuff will also be part of those 9 days. But I need a level editor before I can properly place them (because my random layout is just a quick way for me to test basic functionality and not meant for prime time).

Super Bobby World - Part 4

Note: we’re just getting started - everything is supposed to look like shit at this point :-D

Progress

• Render ground chunks with variation (see below)
• Implemented first interactable object
• Objects can now “talk back”, so my interactable can tell that it whish to give the player score
• Objects can mark themselves ready for destruction
• Bug fixes in platforming physics, so we now can detect if you are grounded or not
• Player animations adjusted, walk on ground, jump in air, and so on…
• Started implementing player physics (work in progress)

Ground chunks with variation

In order to avoid repeating patterns, I implemented a variant that will take a bunch of ground tiles, and randomly place them based on spatial mapping (i.e. to get a psuedo-random number based on x and y position). In my sample I used 6 different dirt tiles, this is how it looks:

Pressing shift will render in debug mode, where you can see the distribution of the dirt tiles more clearly

And at the end, I put a grass tile on top

Interactable

Also did basic implementation of an Interactable object to battle test the system. You can now collect these pickups, they will play a sound and increase your score.

Very good progress today!

Super Bobby World - Part 3

Note: we’re just getting started - everything is supposed to look like shit at this point :-D

Progress today

• All visible objects now belong to a screen struct
• You can define multiple screens
• Implemented screen transitions
• Bobby run animation (temporary)
• Bottom UI (temporary)
• Crude localization - switch between Swedish and English

Super Bobby World - Part 2

Note: we’re just getting started - everything is supposed to look like shit at this point :-D

Progress

• Re-structure of code (as always)
• Decided on scale and window size (more on this below)
• Implemented a menu screen (pretty low on priority, but I was blocked for a few hours)
• Generate a level usding std::rand(), super naive, and a bunch of things break. Still funny
• Started getting animations in there

Ola (who implemented all the platform physics) is now working on a system for player and enemy behaviours.

Scale and Size

We have very limited time, so we’re gonna take the easy way out.

• Baseline size will be 1024x768, with scaling of multiples of two (or there’ll be a ton of blurry artifacts)

Take it easy =D

Super Bobby World - 22 years later

Me and my brother has decided to - for the first time - try to collaborate and see if we can make a game together. We will attempt to make a sequel to my first “real” game, Super Bobby World, originally released in 2003 (i.e. 22 years ago). The image above is from that game.

This time we’ll do it in c++ instead, and with a very limited time scope… so we’ll see how it goes. Let’s keep a short dev log about it here to keep track.

Done so far

Mostly the boring boiler plate and setup-stuff:

• Creating a window, handle input, game loop (using SDL)
• Load and draw bitmaps and colored rectangles
• First pass of custom platform physics (collision detection and response)

• Drawing text
• Playing music and SFX
• Very simple screen management

Not much to look at yet, but still managed to get a lot of the nessecary stuff out of the way.

And remember that you can play the original game here, free and in your browser:

https://games.salomonsson.se/bobby/

Separating Axis Theorem - for idiots

The Original Problem: I need to know if two rectangles are overlapping. Rectangle is the only shape I need to check The rectangles are NOT rotated The rectangles can be of different sizes There are several possible ways to solve this. Check if any of the corner points is inside the other, since point-vs-rectangle-test is so easy to write. But doesn’t work if rectangles has different sizes. Clip them and check if the area is empty or negative Use the Separating Axis Theorem The last option is what we want to do in this case. READ MORE >>

Banish and Polish

Been playing around with this project quite a bit this summer. Here are a few highlights!

Banish Ability

I implemented a new ability, Banish. It targets an entity and teleports it to a random part of the map that is out of the casters vision. This means you can send away dangerous opponents, but you can’t control where they’ll end up. Maybe just behind a pillar right next to you…

Also, since the code don’t deal with “players” or “enemies” or “monsters”, but entities, it means you can banish anything. Like a chest, yourself, or a door.

Just to test it out, I created an enemy that would use the banish against you. Turned out too frustrating as it is potentially very deadly, and almost completely out of control, so needs tweaking.

Sequences re-write - C-style

The back bones of this game is how I can create and chain Sequences together. It was one of the very earliest features I implemented, but some aspects of the implementation has annoyed me for some time now:

• Object oriented C++ with inheritance, not very nice to work with: lots of boiler plate and lots of copy-paste for every new sequence
• Heavy use of new and delete, even though the rest of the game uses my own, custom memory arena allocator
• Lots of copy-paste nonsense between header and cpp-files (even though I thought I managed to keep it fairly simple with a factory)

So I took the bold decision to do a full re-write. No more classes. No more new/delete.

Now we’re using old-school C-style structs, void * for custom data (yeah baby), and function pointers for custom execution. My project, my rules.

Turns out I could simplify things a lot. Better overview of existing sequence-implementation, and fixing a few bugs along the way.

Slot machine polish

One sequence that was very old, and very hacky was the slot machine implementation. While at it, I got to do a re-write, getting rid of some really crazy hax, and adding lots of polish to it too!

• Each real slows down before stopping
• As a reel stops, the result is highlighted by a quick white flash
• Added a bit of shading to the “curves” of the reels
• Reel can support other that plain damage numbers (implemented fire damage as a test)

And here is a video of the new slot machine in motion.

Working on some other, really cool features too. But those’ll get their own post!

Happy ascii!

Holes in the level, and ability hints

Been mostly playing with levels, but have two new things to show.

First, I added descriptions to each ability which is displayed when hovering in your inventory.

And secondly I added “holes” in the level. You can’t walk over a hole (unless you can fly), but you can see over it and ranged attacks work. If you can teleport, then you can also teleport straight to the exit.

That’s all for today.

Asciibrain - Strategic Gameplay!

Sometimes it’s the small things that really stir things up. I decided to spend some time on making a static dungeon, and making it really fun. And the result was fantastic!

Step 1: Add a third character

Only two characters made the game hard. A turn would end too fast. So I quickly added the Thief. This new character has the following interesting characteristics:

1. Weak! Low on hp and don’t hit very hard
2. Has a much shorter walk range, BUT has 3 actions per turn (instead of 2) so the total movement is much greater
3. Has a new default ability Sneak that makes enemies ignore him (or her?) for one round
4. Also starts with the One more thing ability by default, which means she can make up to 4 potential actions!

Step 2: Players can act in any order

The Thief turned out fantastically, but turn order really limited everything. So I quickly re-wrote it to allow you to change to any player controlled character with actions left….

And wow! Now it’s a completly new game!

Where before it was just mindlessly “walk and attack”. Now you can start taking strategic decisions! A simple example:

1. One of your characters is in deep trouble, cut off and surrounded by enemies and low on health.
2. Switch to another character. Loot a nearby chest (chest will give every character a ability-card) and
3. …pray it contains something that will save the day. Maybe your character got a sneak? Change back and apply it to yourself. You’ve just delayed your imminent doom one turn…

Here’s a short video showing heroes and abilities playing together…

Step 3: Adjust health on doors

Another really small, but impactful change, was to lower the health of my doors to match the damage of a Fireball. Now, any door that gets collateral damage from a fireball will be removed and reveal the enemies behind it… now you need to be a bit more careful…

Step 4: Adjust health on chests too…

Even more critical! Chests also gets destroyed from Fireball damage! This might be even more critical!

How to handle it? Change to the Thief character, sneak in and grab the loot, get out of the way and have the Wizard fry the eneimes and the now empty chest…

Asciibrain - Memory Issues

How a simple feature, developed in one afternoon, turned into a memory corruption bug hunt that lasted almost a month… I’ve been so proud of how simple, and easy to use, my custom memory allocator has worked. Then suddenly the memory issues started happening and I had to deep dive into all kind of memory related debugging. And what started as one bug, soon turned out to be three different ones. READ MORE >>

Playing around with opengl

Spent a few hours reading up on OpenGL this winter holliday. Haven’t messed around with it for 11 years.

What’s was most interesting was optimizing compile times. Using VIM and a bat-script for compilation made it pretty much instant.

Well. I realized that even if it’s nice to have basic knowledge, I find it boring. And also realized that OpenGL is considered more or less ‘deprecated’ now as a cross platform graphics api (since Mac no longer supports it). I wasn’t aware of that as a more or less established status before. If you are interested in graphics programming, then you should look into webgpu instead, it seems.

But this will be it for now. Time to go back to my beloved AsciiBrain project again.

KTHXBAI

Status of AsciiBrain - end of 2023

Haven’t posted in a while, so let’s do something about it! Big time!

Here’s a summary of all that’s happened to asciibrain (that I haven’t yet posted about) during at least the past 1,5 years. Quite a lot, this is still very much a live passion project for me.

READ MORE >>

Practical Git

You know all the basic stuff of git: pull, add, commit, push, log, branch, diff. But want to be able to practically use it. To get actual overview of what’s going on. Here are a few really neat commands with options that might be good candidates for you to add as git aliases.

Interactive add

Ever find yourself doing

1. git status
2. git diff path/to/file1
3. git add path/to/file1
4. repeat for every file?

You can review each change much faster by using the patch option inside

git add -i

Log like a boss

Logging is these things thats important, but also super important if you want to get an overview. Most of these commands can be combined!

Tip number 1:

git log --graph --all

Show log as a graph, and how its relationship with other branches/remotes

---

Tip number 2 (can be combined with 1)

git log --oneline

Shows a condensed list with only hashes and messages

---

Tip number 3 (this I don’t see enough of, use it often! Can also be combined with 1):

git log --stat

Shows which files were affected, with a brief addition/deletion summary

I cannot stress how often I find the need to see which files were actually touched by a specific commit.

---

So you found a suspicious commit and a file you want to inspect

git show hash:file

Quickly show the file at the specific commit

---

But git diff hash -- file will compare it to the version in your working directory, and you want to see what changes were introduced in that specific commit! That means you need to compare that version of the file with the version of the file as it looked before that commit. This is actually not as easy as one would wish, but here it comes:

git log -p -1 [-m] [--follow] [hash] file

Let’s break this one down.

• Weird enough we use log -p where one would assume git diff
• -p will log only changes to that specific file
• -1 (optional) will limit to only one entry, in our case we do
• -m (optional) will allow us to diff with merge-commits, most likely we do
• -follow (optional) will follow commit history of file even if it was renamed
• hash if we omit this it will show the latest introduced change, we might want to inspect an older one
• file yeah, no dashes… I do find git syntax to be quite inconsistent

---

Asciibrain running on Linux

Migrated the project to CMake and tried compiling it on my ancient linux netbook. Had to shrink the window, other than that it worked fine!

Here you’ll also see a glimpse of my ascii smoke and text layout code…

White laptop to the left is running Lubuntu and the laptop to the right is running Windows 11.

Ripple Dot Zero

Lets cut it short! Ripple Dot Zero is my Magnum Opus! For five years me and my childhood friend, Simon Stålenhag, worked on this in our spare times. It’s an action platformer, heavily inspired by our favourite childhood Sega Genesis game titles such as Sonic the hedgehog, Strider, Wonderboy in Monster World…

READ MORE >>