Up til now I’ve just been developing on a testbed 20×20 tile grid. This has been fine for testing but I wasn’t sure how well it’d run with the real map size of 254×212.
Method #1 – one big canvas
The original method was using one big canvas and drawing each tile to it which was fine for the small number of tiles used for testing. For the final number of tiles however resulted in instant failure due to bitmap size restrictions. I had considered using multiple smaller bitmaps but went on to trying the next method
Method #2 – individual tiles
The second method was using a separate sprite for each individual tile instead of one giant one. This had marginal success as in it didn’t fall over instantly. Instead it was just horrifically slow and made the game unusable. I spent quite a bit of time diagnosing bottlenecks and trying to speed things up. The main idea was to stop rendering all the tiles which were off screen but there was still the overhead of the tiles existing in the first place. This led me to come up with the final method
Method #3 – reusable tiles
The final method came from the idea: what if I didn’t need all the tiles created at once, all I need is enough tiles to cover the screen then reuse them when they’re out of sight. So now if a tile moves too far to the left and off the screen, it redraws and repositions itself to be the next tile on the right.
In this example, there’s only ever 80 tiles (8×10) yet I’m able to create a map of all 53,848 tiles with minimal overhead.
Over the last few weeks I’ve made a little more progress on the map but most of the time has been spent on the code base. Map-wise I’ve continued working around the map to get the edges in place and started the rough placing for a mountainous path (the swirly bit).
Code wise I’ve been reworking the tasks to allow building up a task queue so you can set your runner to do multiple tasks without interruption. They still need the option to view active tasks as well as remove or edit them.
I’ve also added in basic Quests. They’re randomly assigned at the moment but I’ll add in some structure later on. They’re automatically assigned upon reaching a location and they have a requirement of delivering one or more of a specific item. You can then assign the task to a runner to deliver an item if the runner have it in their inventory.
It’s all pretty rough but at least progress is being made.
I'd started working on an idea for a game a while back and it faded into the background but now I'm back to working on it. The main concept is a supply / demand style game where you have to obtain specific items and deliver them.
It's going to take place on an island which I had originally intended to be generated but on reflection it wouldn't add anything so I'm rethinking it to be a static map. For this I started out with looking for an island map I liked the look of for a starting point and I went with Lombok in Indonesia.
I've been using Pyxel Edit to create a tile map and tile over the original image.
I've created about thirty tiles to handle the majority of angles of the edges but I'll probably create a few more for variety. Once the outline is done I can start adding some additional features.
Over the years I’ve created quite a few code examples which were pretty much just proof of concept projects. The polymesh navigation was one of these.
Another one was to create a php socket server and html client and yet another was the city generation script. These were all stand alone examples which I think could all work well together in one project.
Therefore I have started piecing together a basic start for an MMO type game. I’ve started with the existing polymesh navigation and have implemented the socket server into it. So far all players can see each other move around the screen using the polymesh.
The next stage is to get enemies on stage and get the city generation put in place.
Like the original polymesh navigation example, this project is going to be open source and is on github
So very simple, there’s a few polygons which are to represent rooms and joining doors. First click sets the starting point, second click defines the destination.
The main idea is to create a simplistic version of how Valve does the bot pathfinding in games like CounterStrike. Currently it simple works out the path from the polygon edges but only uses the centre points, in the future I’d need to make the path more natural and fluid in design.
Not much game development has occurred over the last month or two, this is mainly down to trying to get an ongoing site live.
Introducing Projectily, a project management site which has been in development (on & off) for the last year. It’s still nowhere near finished but has been made live as an alpha release. This means you can create an account but there’s a whole load of features yet to be added and quite possibly some bugs left to squish.
You may be wondering why a site would be made live in such an early stage, it’s because this way there’s reason to prioritize development on it as it’s publically accessible. It also allows people to help shape the future of the site, if there’s any features you’d like to see on the site you can send a suggestion and it will be considered.
It’s typical that as soon as I commit to start doing device captured videos, my phone breaks preventing me from doing them. It’s been replaced but unfortunately the update to lollipop hasn’t been pushed to it yet so the screen recorder doesn’t work.
The device shadow issue on the previous video is due to the shadows overlapping. This is because each shadow is being ray-casted from each shadow object and the semi transparency is building up on the overlapping shadows. Ideally the shadows should build up one mesh to keep all the shadow elements on the same layer.
No more work has been done on the space side of things, mainly planning and coming up with ideas. A few changes have been made to the level parts. Player movement has been added along with direction swapping and the wall tiles have been corrected. There’s are few odd tiles in place but they’re just placeholders for elements still in development.
I thought the game needed a name so came up with ‘Pixelnaut’ (pixel as it’s using 16bit sprites and naut as in astronaut), not completely sold on it but it’ll do for now.
It’s been a busy start to the new year so far, breathing life into the new project. Currently created a very rough space level holder consisting of the player’s ship and a planet. The player can select the planet and the ship will navigate to it. The functionality took longer to implement than planned due to the new scaling but it’s working well now. Once the ship reaches the planet then the dungeon style level is loaded in.
The majority of the dungeon level functionality can be migrated from the previous dungeon game but there’s a few issues which still need resolving. So far only the bare minimum has been migrated across so there’ll be more to come.
Overall it’s been a slow but steady start of getting core chunks of code in place.
On another note, with the recent release of Lollipop for Android, Google have opened up the API for screen recording so now progress recordings can be taken directly from the device.
As you can see there are some rendering issues with the shadows on the device which will need to be looked into but it shows the progress made.
I was fortunate enough to be given a new sprite set of a sci-fi theme. Originally the idea was to use it in a completely different game but it’s since occurred that it could be used to enhance the dungeon crawler game which was already in development.
It’s probably going to be more efficient to start afresh and merge the existing code into the new. This sort of rolls neatly onto the next section.
This blog has been somewhat neglected for a while now so being that the new year is just around the corner, the new year’s resolution is to keep this blog up to date. This will coincide nicely with the game refresh as all game provide will help keep the site current.
It’s been on the cards for a while to allow zooming functionality within the games but it was pushed back to the queue as a future addition.
It’s now been realized that this is also tied in with how scaling will work which is essential for mobile devices. If scaling isn’t implemented then the sprites will be the same pixel size on all devices. The problem with this is that on devices with a high DPI will display a much smaller looking version of the image than on others. This also means that this would allow much more to be seen on screens of a higher resolution than those devices with a lower one.
The solution is pretty simple, we create a scale based on the devices DPI along with a manually adjusted scale and the height of the camera is adjusted based on this value. This means that no matter the device, the camera position will always be positioned to show around the same amount of the display.
This has caused a few issues which needed to be cleaned up. The positioning of elements needed to be shifted so point 0,0 goes from the top left to the centre of the stage. This keeps everything in the correct place no matter the height of the camera. This in turn meant that the hit testing of elements needed to be updated to match the new positions of the sprites as well the scale.