Tiny Dungeons – WIP

I’ve started working on a game again. Haven’t done one in ages, hope i have the stamina to pull it off. It’s going to be a light-weight Diablo kinda thingy. Kinda sorta, with a twist. I’ll try to release it on the desktop, Android and iOS eventually.

Here’s a screenshot. I’m happy to announce that Pascal from OrangePixels is doing the amazing pixel art.

I’m actually taking timelapse videos for all the time i spent on the game. It’s gonna be a glorious 2 weeks timelapse once i’m done with this ๐Ÿ™‚

The game is “data-driven”, in the sense that there are no real entity types in the code. Pretty much everything is specified in a bunch of JSON files. I keep things very simple by using conventions-over-configuration where possible. E.g. all sprite sheets for monsters/heroes etc. have the same layout. Adding a new “entity” boils down to dropping a PNG file with the animation frames into a folder, and adding a JSON descriptor for it in a file. I have not started implementing behaviour for entities, but the plan is to provide a couple of pre-build Java classes that i can reference by name from within an entities JSON descriptor. It’s not exactly a full-blown entity system, but it sure smells like one.

I guess what i want to get across is that i keep things as small and simple as possible, while making it very easy to add new content on the fly. I try to limit flexibility where i think i won’t need it, short-cutting my way through things ๐Ÿ™‚

12 thoughts on “Tiny Dungeons – WIP

  1. Looks great, love the pixel style combinated with the lightning system. The approach you’re taking sounds simple but flexible enough to pull a thing of this scope off. Go go go and don’t get disencouraged!

  2. Same genre as what I am working on ๐Ÿ™‚

    Good luck on it, the old going through rooms in a top down semi 3D killing stuff Diablo style still has some steam left in it, or at least I hope so.

  3. Can’t wait to see timelapse, final effect and eventually dive into source code.
    I’m crossing my fingers!

  4. great.
    will it be some kind of open source?
    that would be great. just for learning purposes….


  5. Any hints on how you will go from xsd > xml > java classes? I’m trying to find the best solution for this and still support the most platforms possible. Jaxb isn’t on android, simplexml doesn’t allow generation of xsd to java class files, any hints or good examples you could recommend? Thanks.

  6. I was able to run and compile the Game that I previously used the library jbullet.jar for the physics. Some comments here.

    1.) Big decresase in time loading the physics library when I use the gdx-bullet and so libraries from the nightly download. This is the best news so far.
    2.) Java name convention, for the classes I believe should be changed from the C++ convention. For example, the physics imports and instances looked like the following :

    import com.badlogic.gdx.files.FileHandle;
    import com.bulletphysics.collision.broadphase.AxisSweep3;
    import com.bulletphysics.collision.broadphase.BroadphaseInterface;
    import com.bulletphysics.collision.broadphase.DbvtBroadphase;
    import com.bulletphysics.collision.dispatch.CollisionDispatcher;
    import com.bulletphysics.collision.dispatch.CollisionObject;
    import com.bulletphysics.collision.dispatch.DefaultCollisionConfiguration;
    import com.bulletphysics.collision.shapes.CollisionShape;
    import com.bulletphysics.collision.shapes.CompoundShape;
    import com.bulletphysics.collision.shapes.ConvexHullShape;
    import com.bulletphysics.collision.shapes.StaticPlaneShape;
    import com.bulletphysics.dynamics.DiscreteDynamicsWorld;
    import com.bulletphysics.dynamics.DynamicsWorld;
    import com.bulletphysics.dynamics.RigidBody;
    import com.bulletphysics.dynamics.RigidBodyConstructionInfo;
    import com.bulletphysics.dynamics.constraintsolver.SequentialImpulseConstraintSolver;
    import com.bulletphysics.linearmath.DefaultMotionState;
    import com.bulletphysics.linearmath.Transform;
    import com.bulletphysics.util.ObjectArrayList;

    public class FrogzillaPhysics {
    private DiscreteDynamicsWorld world;

    * Creates a new physics object to simulate world physics for the game.
    * @param gravity
    public FrogzillaPhysics(float gravity)
    BroadphaseInterface broadphase = new DbvtBroadphase();
    DefaultCollisionConfiguration collisionConfiguration = new DefaultCollisionConfiguration();
    CollisionDispatcher dispatcher = new CollisionDispatcher(collisionConfiguration);
    SequentialImpulseConstraintSolver solver = new SequentialImpulseConstraintSolver();

    When I used your libraries, I had to go to thousands of line of code and prefix everything with the bt extension as follows :

    import com.badlogic.gdx.physics.*;
    import com.badlogic.gdx.physics.bullet.btBroadphaseInterface;
    import com.badlogic.gdx.physics.bullet.btCollisionDispatcher;
    import com.badlogic.gdx.physics.bullet.btCollisionObject;
    import com.badlogic.gdx.physics.bullet.btCollisionShape;
    import com.badlogic.gdx.physics.bullet.btCompoundShape;
    import com.badlogic.gdx.physics.bullet.btConstraintSolver;
    import com.badlogic.gdx.physics.bullet.btConvexHullShape;
    import com.badlogic.gdx.physics.bullet.btDbvtBroadphase;
    import com.badlogic.gdx.physics.bullet.btDefaultCollisionConfiguration;
    import com.badlogic.gdx.physics.bullet.btDefaultMotionState;
    import com.badlogic.gdx.physics.bullet.btDiscreteDynamicsWorld;
    import com.badlogic.gdx.physics.bullet.btDynamicsWorld;
    import com.badlogic.gdx.physics.bullet.btRigidBody;
    import com.badlogic.gdx.physics.bullet.btRigidBodyConstructionInfo;
    import com.badlogic.gdx.physics.bullet.btSequentialImpulseConstraintSolver;
    import com.badlogic.gdx.physics.bullet.btStaticPlaneShape;
    import com.badlogic.gdx.physics.bullet.btTransform;
    import com.badlogic.gdx.math.*;
    import com.bulletphysics.util.ObjectArrayList;

    public class FrogzillaPhysics {
    private btDiscreteDynamicsWorld world;
    //private DiscreteDynamicsWorld dynamicsWorld;
    private static List collisionShapes = new ArrayList();
    private btBroadphaseInterface overlappingPairCache;
    private btConstraintSolver constraintSolver;
    private float localTime = 0f;
    private Vector3f worldMin;
    private Vector3f worldMax;

    * Creates a new physics object to simulate world physics for the game.
    * @param gravity
    public FrogzillaPhysics(float gravity)
    btBroadphaseInterface broadphase = new btDbvtBroadphase();
    btDefaultCollisionConfiguration collisionConfiguration = new btDefaultCollisionConfiguration();
    btCollisionDispatcher dispatcher = new btCollisionDispatcher(collisionConfiguration);
    btSequentialImpulseConstraintSolver solver = new btSequentialImpulseConstraintSolver();

    3.) I think is important to mention, that in the ApplicationListener class, the physics library should be loaded before the create method that fires the instantiation of the physics objects. As in the following example :

    public class FrogzillaGame implements ApplicationListener {

    static {
    new SharedLibraryLoader().load(“gdx-bullet”);

    I spent a lot of time trying to figure this out.

    I need to point out that the physics enhances greatly, I am looking at testing your physics library and benchmarked against the jbullet.jar and give you some input regarding to collisions objects, mesh interfaces and such


Leave a Reply

Your email address will not be published.