BOTW: LÖVE for Lua Game Programming

This week I read ‘LÖVE for Lua Game Programming’ by author Darmie Akinlaja. This review is by request of Packt Publishing, and in these situations I like to offer full disclosure. I am not being paid for this review and I do not personally know the author or anyone at Packt Publishing. However, Packt was kind enough to give me a free copy of the text for review and I want to thank them for even wanting to hear my opinion in the first place. They have been nothing but polite and professional in our conversations.

So with that out of the way, let’s get to the review.

The Dangers of the Premise

As the title indicates, the book is about creating games using the LÖVE engine where developers do their work via the Lua programming language. The first paragraph of the preface makes a great argument in favor in LÖVE:

LÖVE is a popular open source 2D video game framework that allows you to leverage the simplicity of the Lua scripting language in developing game prototypes quickly and easily. LÖVE’s robustness and active community support make it a viable framework for game development. It has empowered a lot of indie developers of various ages around the world, giving them an edge in tapping into the lucrative video game market.

This nicely summarizes the selling points of LÖVE. In particular, one cannot overstate the quality of support you will find in the LÖVE community. It is one of the best online communities I’ve had the pleasure of being a part of.

However, there is an inherent danger behind this book: it discusses a technology which is still under development. LÖVE 0.9.0 looms on the horizon as I write this, bringing with it major changes such as a switch to LuaJIT, which brings with it a terrific foreign-function interface, a library of bitwise operations, and more. Writing and release the book before LÖVE reaches version 1.0 unfortunately means that some of its content will become out-dated, deprecated, and it will not have the chance to explain future features that may become part of the 1.0 release, e.g. improved shader support.

Because the book is published digitally it will be easier for the author to update the material to fit future versions of LÖVE. Nonetheless, I am of the opinion a book about an unfinished game engine has too high of a chance to become antiquated.

On Teaching LÖVE

The author does a great job of beginning each chapter with a bullet list of the key points of discussion, and then he drills through them with efficient, concise but effective language. I have read too many programming books that either over-repeat themselves or derail into tangents at every turn. ‘LÖVE for Lua Game Programming’ is not that type of book.

In the past I have criticized game programming books for presenting large chunks of code and then assuring the reader he or she will, “understand it eventually.” Darmie Akinlaja avoids this poor teaching structure. Informative explanations come before example code. This goes a long way towards helping the reader understand and learn.

And on the subject of code, I want to say that the examples in this book are better than what I am accustomed to seeing in programming books. I would disagree with the author on some stylistic issues, e.g. I would more strongly advocate the use of local, but the overall quality of the example code is above average.

I was happy to see the author show seemingly no hesitation in directing the reader towards popular tools and libraries in the LÖVE community, e.g. Tiled and anim8. (The book refers to the author of anim8 as Kikito, his name in the LÖVE community, instead of Enrique García. I am curious if anyone contacted him about that or which name he would prefer used.) The book also points the reader in the directory of free-to-use art assets, an immensely useful resource for budding game developers who, like myself, cannot create tolerable graphics if their lives depended on it.

Faults and Errors

The cover and opening page say:

Master the Lua programming language and build exciting strategy-based games in 2D using the LÖVE framework.

Yet the book uses a platformer as its running example throughout. However, the entire third chapter is a more egregious problem. Titled ‘Before You Build a Game’, the chapter aims to discuss the preparation and planning necessary for designing a game. Obviously this is an important and relevant topic. But here the book fails to deliver in some of the worst ways. First, the chapter is a mere two pages in length; I applaud the author for his concise style elsewhere, but attempting to discuss 2D game design in two pages—it is nowhere near long enough to offer meaningful content. Second, I take issue with the chapter’s classification of games into only five genres:

  1. Strategy
  2. Role-Playing Games
  3. Adventure
  4. Action
  5. Simulation

If I wanted to be unnecessarily pedantic I guess I could argue that all games do fit into one of those five categories. But to present them as if they were the only five and then to follow that with minimal descriptions of each—again the book would be better without the chapter. Game design is a subject of such complexity that it deserves and has books of its own. I would not expect a book about a specific game engine to teach the general principles of game design. And on top of that, I think it is fair to assume anyone reading the book knows what a role-playing game is.

Chapter three is the worst and since it is only two pages the rest of the book would benefit from its deletion.

The book contains no discussion about the file-system and physics modules in LÖVE. Not every game needs the latter, but I cannot imagine a non-trivial game which does not require the former. And so I consider that to be a major omission. LÖVE places certain restrictions on how you interact with files that differs from the Lua standard library, which the book ought to explain in my opinion.

Conclusion

In less than one-hundred pages ‘LÖVE for Lua Game Programming’ takes the reader through the creation of a basic 2D platformer, starting from scratch and ending with an explanation on packaging and releasing the game (and all LÖVE projects) for Windows, OSX, and Linux—LÖVE has terrific cross-platform support. In that time-span the author does a good job of introducing the fundamentals of LÖVE, particularly as they relate to rendering graphics. The other aspects of LÖVE receive much less treatment.

I like author Darmie Akinlaja’s style of writing and organization. But at the end of the day I cannot recommend ‘LÖVE for Lua Game Programming’ due to the fact that it discusses a technology still in-development, which will at best break the book’s example code, and because the book omits some important aspects of LÖVE such as its file-system and physics library, and its shader support. However, because the book is only published digitally I would like to believe that the author can address these issues, certainly more easily than if the book were physically on store shelves.

‘LÖVE for Lua Game Programming’ teaches a lot, but not enough. It has a solid foundation but needs more content and the removal of the superfluous third chapter. If the book receives updates in parallel with LÖVE’s development then it could be an excellent resource by the time LÖVE 1.0 is available. But until then the book is just slightly too much of a paltry discussion of a moving target, and so I would not recommend it.

Advertisements

2 thoughts on “BOTW: LÖVE for Lua Game Programming

  1. This is a great article, thank you for the write up!

    I would like to mention that while LÖVE may not be tagged as 1.0, it is in constant development. Between the 0.5.0, 0.6.0, 0.7.2, 0.8.0 and the upcoming 0.9.0 tags, each release has been ~1 year (https://bitbucket.org/rude/love/src/e55d966e3c23103a4a57ad062de726854b23d294/changes.txt?at=default). As it is a shame that this book is based on 0.8.0, I don’t believe that releasing a book on the framework that releases a new version every year is premature. The framework is rather solid and I have been using it to make all of my games (http://missingsentinelsoftware.com).

    It’s a shame that shaders (GLSL-like), the file system (love.filesystem) and the box2d (love.physics) extension aren’t covered, but it’s good to hear that the rest of the book provides a solid foundation!

    1. Thanks, and great point about the releases. I definitely agree LÖVE is a solid engine. When the team makes changes to the API I have not had to change much of my code. But unfortunately that will still break the example code in the book at some point or another.

Add Your Thoughts

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s