Jump to content

  • Log In with Google      Sign In   
  • Create Account

Banner advertising on our site currently available from just $5!

1. Learn about the promo. 2. Sign up for GDNet+. 3. Set up your advert!


Member Since 29 Sep 2012
Offline Last Active Today, 04:15 PM

Topics I've Started

Scene editor

18 June 2014 - 01:03 PM

So, I am creating a tile based scene editor (Yep, I hate myself).


I may be overthinking this, but I wanted to know some good features to implement in it, but I have run out of ideas. So far I have:

- Object copy (up, down, left right).

- Align to the grid.

- Movement with drag and drop.

- Increase/Decrease scale.

- Flip (horizontal and vertically).

- Delete object.

- Toggle grid.


The editor supports multiple selection and also implements an undo/redo feature.


I currently gave the scene editor as done and am working on a visual collision editor for the objects. still I am thinking I may be missing something. If you were to use a 2D tile editor, what features would you like to see on it?

Pirate RPG class design

08 April 2014 - 11:15 PM

Hi there, lately I have been thinking a lot of a pirate class design for a RPG system, but haven't really got much success.


Most of pirate classes you find around are designed as a swashbuckler fighting style, mostly using movement with ropes. Most also focus on using light and fast weapons or double guns, also they always focus on using light armor (since falling into the sea in a full plate would kill the wearer). In the end it tends to be mix of a rogue and a warrior, with no focus on stealth and heavy focus on high mobility and balance fighting style.


My problem with it is: assuming the world has magic all around, wouldn't it make sense that they have magic abilities to survive on the sea? Fighting with heavier armor would be a huge advantage (a great example of this are the iron born of the Song of Ice and Fire book series*), specially considering that heavy armored classes wouldn't be able to use it in the sea.


So far my concept would be:

- Medium armor wearing.

- Water and Wind magic (maybe ghost also? ghost ship spell would be nice).

- Ability to find treasures.


But that is it, while I see they using a spell to produce fresh water or change the course of the winds, I couldn't think of an interesting way to bring those spells to combat. So, I would love to hear other people opinion on this. How do you see pirates in a fantasy medieval world?


* In the book they use heavy armor, but they don't use any magic. They are just not afraid to die drowning, as they see it as a glorious death and believe that their afterlife will be in under the sea.

IndieDia competition

28 March 2014 - 07:58 AM

This was published in another community I am part of, so I am spreading the word in case anyone is interested, it is kind of a game jam (but with one month duration):


You can check the details here:




I am not an organizer or involved with it in any way, just posting here in case some indies may be interested, the prizes are quite cool for indie devs.


That is it, good luck and have fun =)


PS: We could have a forum for that kind of competitions, I saw kivy (ui framework) is going to have a contest, last one was a gaming contest, there are probably many more around the web.

Good pratices to publish code on github?

07 March 2014 - 12:37 PM

Hi there guys, I have two projects that I want to share on github and I was wondering what would be a good way to organize the project. Both projects are in C.


In the last days I have:

- Hidden the implementations that should be hidden.

- Improved the Makefile (for instance, it adds the -g flag when compiling).

- Created a .gitignore file.


I am still thinking if that is enough. What do you guys expect when you clone a github repository? Should I add some samples or the tests?


Binary heap vs list A* - my humble performance comparison [updated with JPS]

06 January 2014 - 03:32 PM

*** UPDATED ***

Added JPS information, I added some information about the implementation in another post, be sure to check it.


Quite some time ago I released a C implementation of the A* algorithm using grids as the graph and a LinkedList for the OpenList, the topic can be found here:




After that I got really busy with a lot of different work and couldn't really touch the code for quite some time.
Recently I managed to put some work on it and implement a version using a binary heap for the open list, as well as a version that uses memory pooling. The pool would increase its size by 4096 * struct size each time it run out of elements.


My objective with this post is to show the performance gain you can expect to achieve by optimizing an A* implementation, so that people can decide if they should optimize their own. I won't release the code as of now because it is still a bit ugly and it depends on a container library that I use (it has no package yet, so people would need to compile themselves).


Tests Info:


The tests were run on a core 2 duo 8400 3.00GHz, the code runs on a single thread.

The OS used was Ubuntu 12.04 32 bits.

All the times are in microseconds (10^6 = 1s).


Test on a random generated 64x64 map.

List implementation: 235.
Heap implementation: 161.
Pool + Heap implementation: (first path) 124 | (following paths) 105.

JPS + Pool + Heap: (first path) 118 | (following paths) 117.


Test on a random generated 640 x 640 map:
List implementation: 322823.
Heap implementation: 2006.
Pool + Heap implementation: (first path) 1823 | (following paths) 1652.
JPS + Pool + Heap: (first path) 1724 | (following paths) 1542.
Test on a random generated 3600 x 1800 map:
List implementation: 8075664
Heap implementation: 131072.
Pool + Heap implementation: (first path) 126942 | (following paths) 124395.
JPS + Pool + Heap: (first path) 7218 | (following paths) 6321.

The results are pretty much what I would expect them to be, as the path size increases the heap implementation will get a lot faster than a list implementation. The pooling advantage isn't really that big as the path size increases, but it does increase your performance.

My conclusion would be that optimization would be important only if your paths can get big. I used the list based version on a prototype dungeon game (something like a gauntlet), the monsters would only aggro players up to 20 squares distance, and the performance was not a issue at all.


Comments, questions and suggestions are always welcome.