next »

[bitbulldotcom]

Jetboard Joust can now be wishlisted on Steam here. Your support is much appreciated, even if you don’t end up buying it each wishlist helps - as does tagging!

I’m getting rather behind on this devlog again and wanted to write something about the process of getting the Steam page up. Even if it’s not strictly ‘development’ per se, it’s an important part of the process and took me some time.

I started off by reading this excellent Reddit post on how to create a kick-ass Steam page. Lots of useful info there and I kept referring back to this throughout the process. I also spent quite some time looking at the pages of other games, especially those that are also in the same general genre (fast-paced pixelart SHMUP) such as Nuclear Throne and Enter The Gungeon.

The bulk of the work, of course, is creating image assets. I decided to do this using the in-game art rather than trying to illustrate the game in some other fashion. This was a decision largely borne out of necessity (it would have taken me ages to produce quality vector illustrations), but I also felt a pixel art approach would more accurately convey the spirit of the game. If I couldn’t get it to work with pixel art I’d try another method, maybe even commission someone else.

I started off working on rough layouts using art cut-and-pasted from the trailer just to see if what I wanted to do was going to be achievable. I knew I’d need to use at least one of the boss sprites as they were the only ones likely to have the necessary impact without being blown up a ridiculous amount. I settled on the ‘stinger’ boss as it seemed to work well within the proportions of the various steam ‘capsules’, the other bosses actually proved to be too large and complex.

When I had a layout I was happy with I built a much cleaner final version using art taken from the original sprite sheets.

A huge part of the game’s personality though is the particle and shader effects and without these my capsule images were looking rather static and boring. As these are all semi-transparent in-game and overlap other elements it was impossible to cut-and-paste them from gameplay footage and would have been extremely laborious to recreate them ‘manually’ in Photoshop. Consequently I was a bit stuck as to how to convey these in a static context.

After much head-scratching I came up with the idea of doing a pure black-and white palette for the game. I could then make only the particle and shader fx visible, capture these as gameplay footage, import them in to Photoshop as an alpha channel, position where I saw fit and apply colors and blending. This method, with a bit of post-editing, worked really well and, I think, enabled me to communicate the feel of the game pretty well in a static context without a lot of laborious Photoshop work. It was also extremely useful when it came to mocking up / embellishing screenshots.



For the screenshots I also used a ‘green-screening’ technique whereby everything but key sprites are rendered in green making cut-and-paste from gameplay footage extremely easy.



Annoyingly the ‘angled’ logo I use in-game just didn’t work within the proportions of the Steam Capsule images, particularly the smaller ones, and its proportions meant it was either too big or too small when blown up in the exact multiples necessary to maintain the pixel integrity. Consequently I had to recreate a purely horizontal version of the logo which I did in illustrator and pasted into Photoshop as vectors. I think a ‘pure’ pixelart version would possibly have looked better but I’m not sure it would have justified the amount of time needed to do it, particularly given the differing size requirements.



Then there was also the text to write, a myriad of forms to fill in, emails to write to try and generate some publicity, tags to add and a press page to create. I was pretty much losing the will to live by the end of it (not the first time I’ve said that on this project) but it’s done now. Check out the final result here.

Dev Time: 6 days (including other marketing)
Total Dev Time: approx 306 days

[bitbulldotcom]

The final major thing I wanted to do before releasing the beta (other than going back to the PC port) was implement multiple save ‘slots’ per game. It’s surprising how few games bother with this now but for me, it’s essential. Not only does it provide a loving nod back to the days of 8bit consoles, it allows the player to mess around with different upgrade paths and/or multiple members of the same family to maintain their own save state.

It’s not really a technical challenge either. What’s time consuming, as with most functionality of this nature, is designing and implementing the UI.

Fortunately I was able to cheat by recycling 90% of the UI for the upgrades screen (which I’d implemented in a pretty flexible manner to allow for different numbers of stats per weapon). This saved me a ton of time and allowed me to romp through this task pretty quickly.

The only real change I made from a UI perspective was the positioning of the ‘jetsuit’ and ‘jetboard’ icons. I also though the jetsuit looked a little static without any kind of animation so I implemented a few simple idle anims to bring things to life a bit.



On MacOS I have shifted location of the save files to ~/Library/Application Support rather than the default C# IsolatedStorage directory. This makes more sense and, crucially, means save files are preserved between builds (I wouldn’t be able to test it otherwise). As I’m using JSON for the save data I’ve also implemented a very simple encryption algorithm to obfuscate the files, it’s now now longer a trivial business for users to edit the file to change upgrade levels etc!

The game saves at the end of every level and at other key points, such as losing a life and upgrading a weapon – not every time the user picks up a coin or something. Consequently progress will be lost if the user quits in the middle of a level but I don’t think this matters – the end of the level is effectively the ‘save point’.

Testing seems to have gone relatively smoothly so far but I’m continuing to test as I do my final round of pre-beta playtesting.



Wishlist Jetboard Joust here, and view the trailer

, sign up for the beta here.

Dev Time: 2 days
Total Dev Time: approx 308 days

[bitbulldotcom]

The last couple of weeks have been taken up with what seems like an endless round of playtesting, bugfixing, and making minor improvements. It’s the first time I’ve really played the game through from scratch, gradually upgrading a character and progressing through the various worlds in an attempt to see how much time, and how difficult it is, to complete the game.

I made it to just before the second-to-last boss before realising I had to implement major changes to the cost/benefit ratio of the weapon upgrade system in order to get things to scale properly across the game. So now it’s back to square one for another go (groan). It took me around 11.5hrs of gameplay to get this far so I reckon there’s at least 15hrs worth in the game in total.

Every time I come across a bug (no matter how minor), or something that I just find frustrating in the overall experience, I log it in Trello to fix later. There’s been too many minor improvements to list here so I’ll just go over some of the key ones…

Abduction Warnings
There is now an indicator to show where the closest abduction is relative to the player. What became clear to me during playtesting is how vital it is to unlock teleports at the end of each level in order to enable free travel throughout the various worlds. As you unlock teleports by completing a level without having had any of your babies abducted, warnings as to when and where abductions are occurring are key. I may also add some kind of audio indicator as well, like a siren or something.



Map Improvements
Rather than show every upgradeable item with the same icon the map now differentiates between new weapons, weapon upgrades and (valuable) jetboard/jetsuit upgrades. This make it less likely that the player will get frustrated chasing items that are less important. The map now also shows the location of the jetsuit (akin to the bloodstain in Dark Souls) which makes it easier for them to retrieve any cash they may have lost on their previous game.



Weapon Warnings
It was too annoying when enemies armed with powerful weapons such as the RPG or grenade launcher ‘one shotted’ the player pretty much as soon as they appeared onscreen so I’ve implemented a configurable delay for certain weapon types. The first time an enemy appear on screen there’s a delay set before they can fire so the player has adequate warning that that weapon is ‘in play’. A separate (shorter) delay time can also be set for each subsequent time the same weapon appears on screen.

Explosive Weapon Limits
I have limited the player to one explosive weapon per level, some levels offered up multiple explosive weapons which pretty much made the player invincible. The was fun, but didn’t really do much for the gameplay.

Rocket Recharge Limits
I have stopped the meter that indicates when a new rocket will be awarded (for the jetboard attack) from filling up if the player’s rockets are maxxed out. It seemed a bit too easy that a new rocket pickup would get dropped almost as soon as the player used the jetboard attack.

Combo Restrictions
I have limited the cash ‘combo’ multiplier at x5 as it was ratcheting up massive combos which could dish out a huge amount of cash and throw off the upgrades system.

Upgrade Tweaks
I have implemented an algorithmic system for allocating weapon upgrade costs that takes into account the maximum amount of cash that can be earned on the level when the weapon is unlocked, and the estimated amount of levels before the weapon is maxxed out. For weapons that are unlocked earlier on in the game I have allocated more upgrade levels so that they can be upgraded regularly early on but also continue to be upgraded throughout the game and dish out enough to damage to be effective in the later levels. This is proving to be one of the hardest things to balance.

Restrict Level Exit
It was too annoying to accidentally teleport out of a level when you were in the middle of a boss fight. Consequently I’ve made it so that, once a treasure chamber has been activated, you can’t exit the level until either the boss(es) have been defeated and the treasure retrieved, or you’ve lost a life.

There have been numerous bugfixes as well, and other minor improvements. I’ve also made some very significant improvements to the way I calculate explosive damage but that’s going to be the subject of a post in its own right…

Added some recoil to the antimatter gun as it was too overpowered...



Improved the way 'sticky' explosives stick to rotating targets...



Dev Time: 8 days
Total Dev Time: approx 316 days

Wishlist on Steam here | View the trailer here | Sign up for the beta here

[bitbulldotcom]

Check out Jetboard Joust on Steam here.

During my recent intensive playtesting sessions playtesting I’ve become a bit concerned that there’s not enough variety in the earlier levels of Jetboard Joust.

Originally I’d paced things so that either a new weapon or a new enemy is introduced at least every other level. This is fine once you’ve made a bit of progress through the game (as it has all the weapons/enemies from the previous levels to draw on for variety) but earlier on it just felt like I was facing the same old enemies too much, even if they were armed with new weapons.

So I’ve decided to bite the bullet and create a new enemy per level for at least every level until you meet the first boss. As these enemies appear early on in the game they don’t need to be too elaborate, but as engagement in the first stages is key I thought it was worth the extra effort.

This means a total of five new enemies, I’ll cover the three simplest ones in this post as the two slightly more complex ones in the next devlog.

The first two are both jetboarding enemies. Jetboarding enemies are the easiest to add as they all work from basically the same AI, I just have to tweak certain values and maybe add a couple of specialist behaviours for variety. I wanted these ones to have a ‘gang’ type behaviour so I designate one enemy from each group as a ‘leader’ and have the others position themselves around the leader until they get within a certain distance of the player (in which case it’s pretty much every man for himself). Both enemies follow this pattern, though one type will abduct/mutate whereas the other attacks more aggressively.



The enemy on the left is supposed to be wearing a kind of gas mask / backpack type arrangement. This was bloody hard to get right in so few pixels and I’m still not convinced to be honest. Someone on r/pixelart said it looked like a racoon and now I can’t unsee that! It looks better in some palettes.

The other enemy I’ve christened the ‘swarmer’. As you can guess from the name, it attacks in large batches! For the attack pattern I generate a virtual circle around the player and set an ideal position for each enemy on a point on that circle. The enemy tracks to this ideal position rather than directly onto the player, as I rotate each ideal position this means that the enemies circle the player when they get close enough.



The swarmer also has a more aggressive ‘ram attack’ where it propels itself towards the player at high velocity. To make sure that not too many swarmers are doing this at once I maintain a virtual ‘baton’ which is passed from one enemy to another, only the enemy that possesses this ‘baton’ can carry out the attack. I can vary the amount of batons per group to increase difficulty.

Whilst testing on large groups of this enemy I found that gameplay tended to get a bit unbalanced, with all enemies lumped on one side of the player. To avoid this I’ve implemented a ‘split’ AI whereby, if things do get too ‘one sided’, a bunch of enemies will split off in the ‘wrong’ direction to wrap round the game world and attack the player from the other side in a pincer movement! You can see this in action in the video. This mechanic seems to work well so I’ve applied it to a few of the other ‘swarm’ type enemies as well.



Dev Time: 4 days
Total Dev Time: approx 320 days

[bitbulldotcom]

…and on and on it goes. Please wishlist Jetboard Joust on Steam here.

In the last devlog entry I talked about how I felt there wasn’t enough variety in the earlier levels of Jetboard Joust and that more enemies were needed. The two covered in this post are the more elaborate additions to the pack, in fact they kind of morphed into three – or two and a half at least!

1. The Watcher
I’d always wanted to add an enemy based on a giant floating eyeball. That and a brain in a jar, but I haven’t got to the brain in the jar (yet).

My fascination with giant eyeballs comes from two things. Firstly, the art of Rick Griffin. Rick Griffin was an American counter-culture psychedelic comic/poster artist who helped define the look of the period. Giant, often winged, eyeballs feature throughout his work alongside all sorts of other weird shit. I love it.

Secondly – The Residents. The Residents are an avant-garde rock band formed in the early 1970s who have released a mountain of weird and wonderful work over the past 50 odd years. Their ‘Duck Stab/Buster and Glen’ set is one of my favourite LPs of all time – it sounds like it’s landed from another planet. They were one of the first bands to experiment with multimedia and (weirdly) appeared in Apple’s original demos for Quicktime. The Residents famously used giant eyeballs and top hats to mask their identity throughout their career.



Designing the eyeball itself wasn’t too difficult with such great inspiration to work from. It didn’t really work just as a floating eyeball though, and I thought adding Rick Griffin style ‘wings’ would be too time consuming and complex to animate, so I decided to add some slightly Lovecraftian tentacles which are in fact part tentacles and part severed optic nerve (nice)!

Of course I had to make the eyeball track the player! I also added a laser attack (with recoil) and a background shader effect which is also a nod to Rick Griffin psychedelics. The enemy’s movement is based on the ‘swarmer’ logic from the previous post in that there’s a ‘controller’ for each group of eyeballs so they attempt to circle the player rather than attack the player directly. I also use a ‘baton’ approach for the firing so that only a certain number of the group can ever be firing at one time. In the end I was really pleased with the way this enemy worked out.



2. The Swimmer
The next enemy actually started with an idea for its movement before I had any idea what it would look like. I wanted something that would rotate and attack in short ninety degree ‘bursts’ as there aren’t really many enemies in the game that follow this type of strictly horizontal/vertical movement pattern. Coding the movement was pretty easy but I became a bit stuck as to what the enemy should actually look like. I didn’t want to have anything abstract like a rocket or missile (everything has to have personality) and anything I thought of would have looked weird rotating in this way.

Then, whilst emptying the week’s food waste into my compost heap, I happened to see a bunch of woodlice crawling around. It occurred to me (as it has many times before) that these creatures look very similar to prehistoric trilobites and I though – bingo! That would work! A trilobite enemy would work with that movement pattern and fit within the aquatic/Lovecraftian feel of much of the art. I was amazed when looking at reference material just how many types of trilobite existed, and just how creepy some of them were!



So I got to work on animating a trilobite. This wasn’t as hard as I thought it might be, luckily just using a chequered pattern to infer some kind of skeletal structure worked rather than literally attempting to draw every single bone (which would have been impossible in so few pixels). The hardest thing to get right was the head which I found difficult to make look like something that was seen top-down and facing forward rather than some kind of face looking at you straight on. It actually looked better when seen in the context of the enemy’s movement rather than when worked on in isolation.



I felt that these guys should have more of an attack than just ramrodding the player so I blessed them with the ability to shoot exploding egg sacks out of their arse (aren’t they lucky)! Also, these are the only enemy that interact with each other in that they bounce off each other as well as off the environment. I felt this made the movement patterns more interesting.

I was pleased with this enemy but when I tested it in-game their size meant they were much too hard for the level at which they needed to appear. Being such a large enemy it looked silly if I reduced their health so much that the player could just one-shot them with a weak weapon. They’d have to appear later in the game, which left yet another gap earlier on!

So, I decided to work on a ‘baby’ version. I edited down the graphics, removed the exploding egg sacks, and slowed down the movement. This made for a much more appropriate enemy for the earlier levels – almost two enemies for the price of one!



Here's a hastily cut together video showing all the new enemies in action...



Dev Time: 5 days
Total Dev Time: approx 325 days

[bitbulldotcom]

One of the things I’ve been doing recently is improving the algorithm I use to calculate explosive damage in Jetboard Joust. I’ve mentioned this in passing before but, as I’ve spent quite some time on it throughout the course of the project, I felt it warranted a devlog entry all to itself. So here you go...

Take 1: The Range Check
The simplest way of calculating explosive damage in a game is to use a basic range check, i.e. calculate the distance of each target from the centrepoint of the explosion and if this is less than the radius of the explosion register a ‘hit’. For slightly more realism you can reduce the amount of damage done the further a target is from the centre using the inverse square law.

This method is fine in some circumstances and basically what I originally implemented in Jetboard Joust (only complicate things when necessary is pretty much the mantra I live by when it comes to coding). I didn’t feel it really cut the mustard when it came to playtesting though for a number of reasons.

1. Size Matters. As this method only uses the centrepoint of each target as reference it would distribute the same damage to a very large enemy as to a very small one, even though the large enemy had a much greater surface area exposed to the explosion. Similarly it would be possible for a large enemy to be exposed to a considerable amount of the explosion whilst its centre point was outside the damage radius and therefore not take any damage at all. As enemies vary in size tremendously in Jetboard Joust this was an issue.

2. No Protection. It did not make sense to me within the context of the game that a target on the other side of a building would not be shielded in some way from the force of the explosion, and similarly that small targets would not be shielded by larger targets. I wanted the player to have to think (to an extent) about the placing of an explosive weapon when fired into a group of targets as part of the gameplay and with this method of calculating damage the placing of explosives made very little difference.

Take 2: Mass Raycasting
My next approach was my first attempt at using raycasting to calculate explosive damage. The technique used was as follows:

Allocate a maximum damage and range to the weapon.

1. Cast a bunch of rays out from the centrepoint of the explosion. Allocate an amount of damage per ray proportional to the weapon’s overall damage.

2. For each ray, iterate through each edge of every potential target and work out the closest target to intersect (if any). Obstructions are included here.

3. If an intersection occurs, work out the ‘strength’ of the damage based on the distance of the point of intersection from the centrepoint of the explosion as a proportion of the weapon’s overall range.

4. Apply the ray damage multiplied by the strength value to the enemy

This GIF shows an example of the above method, note that the frame-rate drop is only because of the debug rendering.



On the whole this method worked pretty well. Damage done was now (roughly) proportional to the size of the target’s surface area that came into contact with the blast and targets could be shielded from the blast by obstructions and each other, making the whole system feel much more interactive dynamic. There were a couple of issues, however.

1. Fanning As rays spread out from the centre it could be possible for very small enemies to be missed entirely be explosions that had a very large blast radius. This could be remedied by simply casting more rays, but that brings me on to point 2…

2. CPU Expense I never really noticed any slowdown with this method but the amount of needless rays cast, and the fact that to improve the accuracy of the system I would have to cast yet more rays, worried me. It seemed especially wasteful on explosives fired by enemies as these really only needed to be checked against the player and obstructions.

3. Too Much Shielding Whilst having obstructions like buildings shield targets from the blast radius worked well in-game, having targets absorb 100% of blast energy was too much. With smaller enemies particularly, it seemed there needed to be some kind of ‘bleed through’ otherwise a small enemy near the centre of an explosion could absorb almost all its damage.

(2) could have been partially resolved by doing a basic range check to collect potential targets before performing the raycasting and (3) could have been resolved by ordering targets per-ray before applying damage but, with some considerable help from r/gamedev, I was able to come up with a much better solution.

Take 3: Selective Raycasting
This technique builds upon ideas that are discussed here and here. A very ‘broad brush’ description of the process is as follows:

1. Perform a basic range check to get a list of potential targets.

2. Cast a ray to each vertex of each potential target.

3. For each ray, iterate through each edge of every potential target and maintain an ordered list of those that intersect.

4. For each ray, apply damage to each intersecting target in order.

Of course, it’s a bit more complex than that in practice, particularly when it comes to calculating the damage. This is best explained with a diagram.



I’ll refer to each point that a ray intersects the edge of a target as a hitpoint. Each hitpoint is allocated an energy value. Energy starts out at 1.0 but is reduced by each target the ray intersects along the way. The amount of reduction can be set per target, so certain targets can absorb more energy than others. Remember that we are only registering the closest hitpoint on each target so each ray will only have one hitpoint per target.

I maintain a list of all hitpoints per target. Once I have iterated through all rays, so all hitpoints and their energy values have been calculated, I then iterate through each target.

For each target I sort the hitpoints by their angle from the centrepoint of the explosion, so I’m iterating through each hitpoint in a clockwise direction (could be anti-clockwise, doesn’t matter).

I calculate the angle between each hitpoint and the next one from the centrepoint of the explosion. This angle / 360˚ gives me the proportion of blast damage that should be allocated to this ‘slice’. I then take the sum of the energy value for said hitpoints and divide by two – this gives me the ‘energy’ of the blast damage for this slice. The actual damage done per slice is the blast damage value multiplied by the energy value.

Note that I don’t have to apply the inverse square law here as calculating damage done based on the angle between hitpoints means that blast damage will already decay as the target is moved further from the centrepoint of the explosion.

So, in the example diagram, the energy value for hitpoint (2) will be less than 1.0 as the ray has already passed through hitpoint (1) and absorbed some energy. Assuming for the sake of argument that the angle from the centrepoint of the explosion between points (2) and (3) is 10˚, the damage done for the ‘slice’ between hitpoints (2) and (3) will be max_damage * (10/360) * (energy(2)+energy(3))/2.0.

This method largely works but there is an issue. Consider this example image...



If the smaller target absorbed 100% of the blast’s energy then the energy value at hitpoints (2),(3),(4) and (5) would be zero which in turn means that the energy allocated to the ‘slice’ between points (1) and (2) would only be half of what it should be. The solution to this (or at least the best one I can come up with) is to also cast rays slightly to either side of each vertex, which is what I ended up doing. A similar solution is presented here. Unfortunately this triples the CPU expense but it doesn’t seem to impact performance in-game, even with lots of enemies. If performance did become an issue I could probably get away with only casting rays slightly to either side of each vertex and ignoring the ‘direct’ one.

Another key point in optimising performance is that all objects used in these calculations are recycled as described here, so there is no object allocation or garbage collection involved. I’ve found that recycling objects, particularly in memory-managed languages like Java and C#, pays off in spades when it comes to performance.

Another special case I should mention is what happens if the explosive projectile directly collides with an enemy. In this instance I found the best approach from a gameplay perspective was to allocate maximum damage at the point of impact. If the target is destroyed by the impact I remove it from the list of valid targets (so it doesn’t block the blast from anything else), whereas if it is not destroyed by the impact I leave it to absorb blast energy in the normal way.

The end result is a process that minimises CPU expense whilst also providing a rich, dynamic and pseudo-realistic gameplay experience. I can set energy absorption levels for different types of enemy, plus energy penetration levels for different types of weapon. It’s been a fairly rough road getting here (maths is not my strong point by a long chalk) but I’m pleased with the result.

The video below has a few examples of debug output showing rays cast and hitpoints followed by a few non-debug examples of explosive collisions with multiple complex colliders just to demonstrate the lack of any noticeable impact on performance.





Dev Time: 3 days
Total Dev Time: approx 329 days

[bitbulldotcom]

Mainly been working on my Steam page this week, adding animations and stuff. Here's a GIF to demonstrate the powerful jetboard attack...

[bitbulldotcom]

...and another GIF for the Steam page. This one giving a glimpse of some of the enemies you'll face. There's knocking-on fifty in all!

[bitbulldotcom]

OK, it's been... a while!

But I've been working hard on this. So hard in fact that I've just not had the energy to keep updating the devlog and do all the stuff I'm supposed to be doing. I will be updating with more info later.

The good news though - I'm going to be partnering with Freedom! Games for a release of Jetboard Joust on Steam on October 23rd. The 'meta-gameplay' has swung to being much more roguelite-esque and there's a ton of new weapons (over thirty in all) including this bad boy...

Wishlist here

[bitbulldotcom]

Not long to the release now! I've been in full-on crunch mode for the past two weeks and there's still loads to do. I'm exhausted! Feel like I've been flattened by this guy.

[bitbulldotcom]

Jetboard Joust is now available on Steam here!

It's taken five years to get to this point and I'm exhausted. I hope to be posting some DevLog updates about the last few months but for now I hope some of you will download and enjoy the game - and if you do enjoy it, please leave a review! 





Join the Discord server

[bitbulldotcom]

Several months later and still no DevLog updates but I'm stoked to announce that Jetboard Joust has just launched on Nintendo Switch and Atari VCS! There's also been a significant update to the PC version that includes Linux support amongst other things. I'm still exhausted!

Here's a nice video showing Chris from Cane And Rinse playing and talking about the game. I'll be interviewed about it on the Sausage Factory podcast in the not-too-distant future as well.