Skip to main content

Rollin Droid

I have been working on prototypes for games for a while now. I tried doing:
  • a game where you rotate a shape and avoid projectiles
  • a game where you race in between planets
  • an isometric-real-time-chess game on an infinitely large board where you move a knight
but there was always something in the gameplay that didn't feel right.

Luckily, after playing Line Runner I finally did a prototype that deserved to be turned into a complete game. Line Runner is incredibly addictive, but there are several things that I would have done differently:
  • the player isn't allowed to make mistakes: one mistake and it's an immediate Game Over.
  • you play on a horizontal line. It would be better if you could move up or down.
Here's what Rollin Droid (my interpretation of Line Runner) currently looks like:


During the development I realized that I could implement wall jumps which allowed players to climb up tunnels and change direction.
Wall jumping unfortunately creates a big problem: if the player mistakenly wall jumps somewhere he's not supposed to, he ends up going in the wrong way and is very frustrated of not being able to change his direction until he finds a place where he can wall jump again. This problem isn't yet entirely solved, but can be mitigated with smart level design.



The main character is a little bugdroid that skates and collects donuts. In the game, he's a ragdoll animated using box2D, so his body/head/arms/accessories correctly reacts to his movements :-)
I doubt Apple would be very happy if I released the game on the App Store with a bugdroid as the main character, so the game on iOS (and the other non-android OS) will probably feature an other character.
Labels:

Comments

  1. HybrisSeptember 9, 2012 at 9:51 AM

    hey, I've been following your game for a while, and I really love it, I just want to start programming games, but I don't know what to do first, can you tell me what programming languages / techniques are the best for programming games like pewpew? thanks in advance! :-)

    ReplyDelete
  2. Jean-François GeyelinSeptember 9, 2012 at 10:10 AM

    Do you already know a programming language? If not, I suggest you start learning python, it helps getting to know the basics.
    Once you know the basics of programming, you can use Unity3D to get your game running relatively quickly.

    ReplyDelete
  3. HybrisSeptember 10, 2012 at 6:25 PM

    yes, I already know programming, most PHP, MVC, front-end and stuff like that, but I don't know where to start on 3d programming, not sure if I need some physics background, and I would like to know if there is a cross mobile platform to 3d programming to target iOS/android :-)

    ReplyDelete
  4. Jean-François GeyelinSeptember 15, 2012 at 9:25 AM

    You definitely don't need a physics background, or at least not right away :-) Vector math on the other hand is very useful.
    One cross platform is Unity3D, and I suggest you look into that. You can target Windows, OS X, iOS, Android, and probably more. It's really the best way to get into 3D. The path I took (C++ and OpenGL) is very very long.

    ReplyDelete
  5. HybrisSeptember 19, 2012 at 10:27 AM

    Hey! I really appreciate your info about this, I'm deciding between Unity3D and Corona SDK to start doing things :)

    Thank You!

    ReplyDelete
  6. AnonymousOctober 21, 2012 at 7:21 AM

    To be grammatically correct it should be titled "Rollin' Droid".

    ReplyDelete
  7. 2noob2banoobNovember 1, 2012 at 1:20 PM

    That game looks quite nice! I think I'd play it.

    ReplyDelete
  8. AnonymousNovember 25, 2012 at 5:47 PM

    Hey ! Any update on your game ? Seems really good (and potentially really addictive to achieve perfect scores aha).

    ReplyDelete
  9. AnonymousAugust 30, 2022 at 7:01 PM

    10 year later lmao

    ReplyDelete

Post a Comment

Popular posts from this blog

PewPew Live's look in a nutshell

Occasionally someone will asked how I obtained the PPL look. In a nutshell: Draw everything with lines, including the text and the various icons. It's a lot of work, but besides looking unique it creates a consistent appearance which is a thing that a lot of indie games struggle with. The lines are screen-space projected lines with miter joins. Draw the lines with additive rendering. This means that if a red and green line overlap, the overlap will be yellow. There are a few things not drawn with additive rendering (like the background of buttons to improve readability), but they are exceptions. Add bloom. There's lots of different bloom implementations. Nowadays I use a bloom that is similarly to the one in  blender's eevee . If you see banding, use dithering. Optional: Add even more post-processing like (very slight) chromatic aberration, lens dirt, scan lines, curved monitor, and vignette. No post-processing, just lines Bloom! Ignore the missing bloom at the top All the...
Post a Comment
Read more

A general state rollback technique for C++

I wanted to write this post for a while. It describes a C++ technique to implement rollback in the context of multiplayer games that I feel is quite interesting and useful. The tl;dr is: don't bother serializing individual objects, just rollback all the memory. Rollback-based multiplayer I've been working on a multiplayer version of PewPew, and for reasons that are outside of the scope of this post, I chose to implement multiplayer with deterministic lockstep and rollback. The basic idea behind rollback-based multiplayer is that the inputs of players are replicated to all the players. Whenever a player receives the inputs of another player, the state of the game is rolled back to the point where the input happened and fast-forwarded back to the present so that the state shown to a player takes into account the inputs of the other players. Because history is being re-computed, some events get undone. For example, it's possible a player saw themselves taking a bonus, but aft...
2 comments
Read more

Ridiculously cheap depth of field effect for lines

I'm working on PewPew's sequel, for which I've revamped the graphics. Instead of drawing lines directly using OpenGL, each individual line segment is made up of two triangles whose vertexes are computed with shaders. Getting lines in 3D space to be properly displayed on a 2D screen is not trivial. In PewPew's sequel I use the screen-space projected lines, a technique very well described in the  Drawing Lines is Hard  post. The upside of drawing the lines yourself is that you are fully in control, which allows you to implement nice things such as joints, perspective, and even simulate depth of field. https://en.wikipedia.org/wiki/Depth_of_field Usually depth of field (DoF) in video games is implemented using a post-processing step that blurs the pixels with an intensity that is a function of the depth of the pixels. When we are rendering lines, we can approximate DoF directly when rendering the lines by having the vertex shader increase the width of lines and r...
1 comment
Read more