Runners v0.0.1

You’re probably wondering why after the previous posts about the runners game we’ve landed at version 0.0.1, well there wasn’t any sort of versioning before and it’s being remade to a degree. The way the original version was put together made it very difficult to implement zooming on the map. Because of this, zooming was one of the first things to be put together in the new version.

It was also made with my own implementation of OpenGL which was still pretty buggy so I’ve decided to switch it over to use libGdx. Now the new map is working the way I want it to I can start merging code over from the previous version.

Runes v0.0.2

The main noticeable change this week is the introduction of animation for both the creatures and the background. Previously the creatures would instantly move to the selected location but now they follow the path changing direction and displaying an animated walk cycle. A test area of water has been added to the centre of the battlefield as a testing ground for both an animated background and to act as a blocked area for pathfinding.

Another visual change is the selected creature details box has been styled (slightly) and also works as a quick link to centre the camera on the selected creature.

Behind the scenes a major change has been made to the creature movement and action point system. Previously creatures had one movement point per round and the action point accumulated, now it’s completely custom for each creature and non creature cards now have mana and/or stamina requirements. Creature movement is his based off stamina but based off movement stamina, meaning big slow creatures with high movement stamina won’t be able to move far but can do some devastating high damage stamina based attacks.

Runes v0.0.1

Learning libGdx is something I’ve been meaning to do for some time now and I’ve finally gotten round to doing it. I decided to convert an existing project instead of creating something from scratch and spent the last week or two working on it. The previous game was purely for Android but using Gdx allows the project to also be built for desktop and iOS.

The initial idea for the game was to create something which was essentially a TCG with an additional layer of strategy by having a playfield to move characters around. Each character would have their own deck and characters of different types would have decks containing different cards.

The first version was created as just portrait for mobile but being the main structure was being remade I made the decision to cater for both portrait and landscape, especially with the option for building for desktop. Originally the battlefield was going to just be a five by eight grid with just the card icons as movable tokens but while working on the Gdx implementation I thought it would be better to use separate battlefield sprites and create an actual level with obstacles to maneuver around. In its current state the creatures gain one action point per turn and can move one space each turn but they cast as many spells they have action points for. After thinking about how this plays out I think it’s going to change in a future update

Another visible change is that I’ve decided to give a ‘demake’ effect to the card images by changing the graphics to a 16bit type appearance. They all still need to be tweaked and I need create a proper palette for them.

Currently there’s only a few different cards which were used for testing. This mainly consisted of spawning creatures and affecting them with effects. Once everything is working correctly with Gdx and I make a few changes to some of the game mechanics, I can continue to add new cards.

Runners – 2020-01-16

There’s just a couple of new things to showcase after all this time which are the inventory UI and scrolling support. A fair amount of work was put into the tutorial but has been put on hold for the time being.

A bit more map work has also been done to start planning the position of additional locations.

Runners – 2019-11-11

The bulk of the progress made this week is with the UI. I’ve completely remade it all to use a base display to keep it consistent for each view. I’m not too happy with the buttons and there’s a little bit of a stretching issue but the new changes will make updating this in the future much easier.

Other updates include creating a dialogue handling system for displaying multiple strips of text which will be used for the tutorial and quest information. Hopefully this will be finished next week

Runners – (2019-11-03)

Over the last month I’ve been revisiting the Runners game and quite a lot has changed since the last post a couple of years ago!

Visually

The first big change you’ll notice is the tile set has been swapped out for a brand new one. The new tiles blend together better than the old ones and will allow more interesting environments, they generally look a bit better than the last as well.

Under the hood

Now this is where the majority of the recent changes are so I’m gonna break it down a bit:

OpenGL

The graphics are now being rendered with OpenGL which will help with general performance and allow some advanced graphical techniques

UI

The UI originally was a mash up of Android components layered on top of the map canvas which was a pretty nasty way to do it. It’s now been completely redone within OpenGL to make it more fluid.

Quests

The quest system has been completely rewritten to allow different types of objectives to be part of a quest and to give prerequisites to each objective if required

Exitus – Reactive pathfinding & FOV

The last week has been mostly spent working on two core mechanics. Although both could still do with some tidying up, they’re both functional.

Reactive Pathfinding

The idea behind reactive pathfinding is that the character will keep checking their path as they progress down it to see if the route can be optimized. The result will therefore be a shorter path and hopefully one which looks more natural.

Field of View

Field of view is a key mechanic so the characters can see enemies and know how to remain hidden. The method was completely changed from the original. Instead of doing a periodic check along an angle like what was originally used, it now uses a line intersection check to see where the ray hits a wall. This will give a smoother line next to walls.


Original FOV


New FOV

What’s next?

Well now the field of view is in place the next step is to add in the mechanics of what to do once something is seen. This will be the beginnings of adding in some sort of simple behaviour to the characters.

Exitus – 2019

It’s been a while since working on Exitus but it started playing on my mind over Christmas as to why it was abandoned. The main reason was due to the time to take fixing bugs and not progressing, these bugs were mainly due to trying to build something too quickly and the structure becoming difficult to maintain.

It was therefore decided to reign back some of the features for now and rework them. It also allowed me to familiarize myself with something I had been interested in for a while, WebGL.

After building up the core groundwork for WebGL I began incorporating previous pieces back into the new version.

So far the city generation is in place but limited to just one block, there’s also no internal structure which was one of the pieces which needed the most fixing. The path finding is also in place but being worked on again to give it some well needed improvements, the main being implementing reactive path finding to make it look more natural.

Exitus (2018-05-29)

After spending a fair amount of time on the perimeter buildings and not getting it to work nicely I’ve stashed it for now to work on other pieces.

I’ve added some basic characters, enemy and player. Currently they’re just coloured circles with a code showing their field of vision. If a player goes into an enemy’s FOV then the player will turn white. Just so we know they’ve been seen, in the future they’ll start chasing the player.

Players are black and can be selected, once selected they can have a path created by clicking on the map. Enemies will just move randomly around the map.

character FOV

Exitus (2018-05-22)

I’ve spent a little time working on a project to learn ECMA6 and the process of transpiling it down to ECMA6. The project is essentially rewriting a collection of code I’ve previously written in other languages and merging them together to play nicely. I’m now considering developing it further into a survival game.

So far I’ve put together the bulk of the city generation and the polygon path finding. The polygon mesh currently consists of the roads and a very basic algorithm for building layout. In the image the polygons are only visible for the current city block you’re currently in. This is only temporary so you can see the room layout as there’s no building textures yet.

Screen Shot 2018-05-22 at 17.00.29

I had originally thought that having procedurally generated building layouts would be good but I’m now thinking that having preset layouts would be a better idea.

There’s some lag while moving around the world which I’ve got to address and I’ve still to combine the perimeter buildings as they’re currently split by the city block edges. I’m also eager to get some sort of gameplay added in.

A working example can be viewed here and the code is available on github