I am an amateur (indie, if you prefer) game developer from Poland. I blog at http://dabroz.scythe.pl/. Recently I'm busy with my OpenGL engine and FPS game called LvxTechdemo. My main area of interest is of course 3D graphics, but I don't mind coding other fun stuff as well. You can also track me on Twitter: @dabrozPL
Posts by Tomasz Dąbrowski
  1. Simplicity Oriented Programming ( Counting comments... )
  2. Keep data close, part 1 ( Counting comments... )
  3. Binary shaders -- not that big of a deal ( Counting comments... )
  4. At the right time! ( Counting comments... )
  5. Vicious circle of generalization ( Counting comments... )
  6. Simple continous integration ( Counting comments... )
  7. Yet Another C++ Rant ( Counting comments... )
  8. Just-in-time Data Transformations ( Counting comments... )
Technology/ Code /

After few years on Warsztat (a Polish gamedev site) I've noticed an interesting phenomenon. Every now and then there are Compos (programming competitions) organized in two different flavours. Some compos are single-run events that last only few hours, others are long-term (several days/weeks). And as an extra catch, the former are usually restricted to basic APIs (SDL, OpenGL etc) while the latter are free-for-all (all sorts of engines, UDK/Unity allowed).

Now, results are somewhat shocking. Much more people participate in short compos than the long ones. But the best part is that quality of games created is just the same, no matter if the games was made in 2 hours or 4 weeks. Why?

  1. Well, creating game in 4 weeks doesn't usually mean neither 672 nor 224 working hours. In extreme cases 4 week compo is just a 2-hours compo, with 2 hours located at the very end of 4 weeks.
  2. A lot of game value is an idea. Fact: you won't come up with better idea in 4 weeks than in 10 minutes.
  3. Development process for 2-hours game is very dense. And most of the time is spent on improving core features (because there are no others).
  4. On the other hand, in long-term projects people start to focus on insignificant features. The moment you start improving abstract communication between task pools, adding GUI widgets so that you can make a built-in MP3 player or making splash screen data-oriented, your project is screwed to hell.

And this is probably the most important lesson to remember. If you need to do something very quick, code will be horrific, but also short, simple and fixable. With no time constraints, code will get new levels of complication, features and bugs. Time spent on maintaining won't justify the result.

In 4 weeks, you can make several iterations of speed-coding, each time improving core features of the game. If you start with future proofness in mind, writing code and fixing bugs will consume most of the time. Sure, in 4 weeks you can make a ton of assets/levels, but how good are they is core gameplay is not good enough?

Finally, one solid C(++) tip: when adding new features, start with the smallest of available guns:

  1. Global function -- if you need to display score, don't hesitate to add void DisplayScore() somewhere.  If your game is single-player, store score as a global variable. See? You have just saved 10 minutes of writing getters, setters and designing communication between modules. If your game is multi-player then you will need to store and display scores per-player. But there is no reason to be able to display arbitrary score of arbitrary player if your game is not yet multiplayer. Believe me, you'll have bigger problems than displaying score with that.
  2. If your functions share common code or require helper functions, group them somewhere, possibly in separate file. Remember about static functions and variables -- contrary to "OO" static, file static is about visibility. But it's cool, because you can have a file for all font-related operations and store internal data in static global variable. Helper functions can be static, and public ones go to one shared header (if you write simple code, compilation time is never your enemy).
  3. Promote functions to classes only when it's relevant and useful. Remember, classes means objects, objects mean relations and relations means complexity. Is your gameplay so cool that you have time for code complexity?
  4. Any design patterns or other exotic stuff is the last resort if none of above is good enough. Personally? Never got there.