snake snake snake snake snake snake snake

Less than a week ago, I was busy developing a game called “Ghost Town” (see relevant post). This has been, by far, my most productive and successful Ludum Dare for quite a while, perhaps since April 2010. That’s not to say I haven’t gained anything from these other Ludum Dare competitions, but I’ve usually gone into them half-heartedly or with too grandiose a concept. The main reason is probably because I was trying to juggle my Physics degree and work at the same time.

However, I would like to save the motivational analysis for a future post (I have much to say in this regard!), and let’s get down to the technical/artistic breakdown of what happened.

The theme

I’m going to let you in on a secret: I didn’t do any voting for the theme! Not a single round. I think SoS Sosowski and the other Ludum Dare organizers did a fantastic job of weeding out the “weak” themes before the voting even began. Each round, I found myself looking at the list with indifference, because any one of the themes could work as an inspiration for games. I’m happy to say I didn’t build any expectations, nor did I feel any disappointment when I woke up on Saturday morning to find the theme announced as “Alone”. That said, I didn’t feel much in the way of identification with the theme either. (Though I will say that it was a crushing blow to see “Kittens” pushed to the end of the list. That was undeserved cruelty.)

When I awoke that morning, I didn’t get up immediately. I kind of went back to sleep. During this quasi-sleep, or maybe when I woke the second time, the idea of having a snake jump out and bite the player in a surprise cut-scene came to me. I put it aside in my gigantic brain, in the hopes that I’d come up with something better.

As per tradition, I left the house almost immediately, carrying my trusty camera. Instead of standing around waiting for an idea or forcing one into existence, I try to clear my head and frame photos around the theme. You can see these photos here, on my G+ photo album. I think they captured the feeling of “Alone” pretty well.

When I got back, I stared at the whiteboard for a while, trying to build some free associations. This didn’t lead me too far, and I just kind of ended up starting to code and draw things without really having a clear idea of where it was going.

I don’t believe that this thoughtlessness did much harm to my project. I knew something had to happen with ghosts, and something had to have a dangerous, filthy atmosphere to it. I knew there was a snake in it, and the snake was meant to surprise the player. This would be introduced by a cut scene, in which the player has a near-death experience by a hit-and-run snake.

With these things in mind, I set to work.

Coding

I used my boilerplate Flixel code to put together this platformer. On the one hand, I’m quite pleased with Flixel and I’m very comfortable with it as middleware for my Ludum Dare games. It is extremely fast and easy for me to get up and running, because if I forget how to do something, I have tons of in-house reference code I can look at. On the other hand, it means my games usually look and feel the same, and not just because Flixel lends its own look-and-feel. It has to do with how I build them, always in the same kind of general way. If I ever want to branch out and try something new, it will probably be difficult if I use the same Flixel basecode I am used to. But like I said, the learning curve was absolutely flat, and my game was up and running in no time at all.

But this smooth flow of coding was not to last. Following up on my “surprise snake” cutscene, I decided I needed a generic[ish] scripting method…. Things started to slow down here. I implemented a generic scene that would receive an embedded XML with a list of triggers and actions. The triggers would be read from each scene’s maps built in Tiled. It was daring and risky, because once you start building such a system, there really is no end to it. You can keep adding features and trigger options until coding each script takes longer than it would to simply add a huge “switch” statement with special cases.

It ended well, because it did work. But I think things would have been smoother if I had either already built such a thing (elegantly, unlike how it came out during the competition), or if I had just added special cases (ugly, but much faster to get working, and justified because of the small scope of the project). So this goes on the list of things to practice or wrap in an Eli Basecode library for the next time.

The artwork

Artwork for this game splits itself into two neat categories: spriting and backgrounds. Spriting was a huge challenge for me, because I really suck at animating. I think I did better than usually, because the walk cycle for the main character has more than two frames in it.

But the sprites did come out ok. Especially the ghosts, which I made using Photoshop, not GraphicsGale.

The backgrounds are a whole different story. For over a month, I’ve been attending “intuitive” drawing classes, and drawing something on my own nearly every day. While the idea was not to make “intuitive” style backdrops, I decided I would use the painterly style. These backgrounds were very easy to make, and I blitzed through ten of them in a really short time on Saturday night (direct link to portion of video with “background blitz”). Doing these backgrounds (and the tiles that went with them) are surely the high points of my Ludum Dare entry. Feeling at home with a tool is the greatest. In this case, it was Photoshop.

Sounds and music

And after that bout of self-congratulation, we arrive at the hardest part of the post-mortem. This part went all wrong! There are no sounds, and only one tiny musical riff played when the player finishes a screen. (I have been told that it does more harm than good, and I should probably have just left it out.)

So what happened here? I’m no stranger to music and sound in games, especially Ludum Dare. In retrospect, I think there was a certain kind of pressure I fabricated for myself, demanding too high a level of quality for the game. I could have made something simple and had a more complete entry, but the “visionary” Eli decided this was not good enough. I had great ideas for atmospheric sounds (windy building interiors, ghostly ambience, etc.), and five minutes with bfxr just weren’t enough to make it happen for me. I gave up on sound.

Music had a similar failure. I wanted some kind of moody music. The original idea even had more than one tune: Quiet ambience from the start of the game, followed by tense action sounds after the snake cut-scene, and finishing up with a wistful melancholy song for the ghosts. Obviously this was too much.

I think there are two ways to deal with this in the future. Either I should practice throwing together simple songs on a theme, or I should lower the demand on myself when it comes to the compo. Perhaps a mixture of the two will do it. Either way, being paralyzed because “it probably won’t come out good enough” is against the spirit of Ludum Dare and my own recent mindset about creation.

Overall

Overall, it was an excellent Ludum Dare weekend. I had a terrific time. Stress levels were high, and I had a very hard time getting to sleep, even after submitting the finished entry. But I did eat properly (mostly thanks to having a caring wifes — highly recommended), and I don’t feel I neglected myself.

Another difference this time was the recording of the timelapse. I found this to be a great productivity tool. I did take breaks, and I did find myself staring at Gmail or Google+, but every time I did so, I remembered the timelapse photos being taken and these breaks sort of ended themselves. Trying to make a good impression for the camera is an excellent motivational tool, (as long as it is voluntary!). Of course, when it’s all said and done, the timelapse looks pretty much the same. A blur of code and pixels flying by, and it inevitably looks like the subject is some kind of magician. So who knows if this productivity “trick” will work next time….

All in all, it was a fantastic weekend, and I look forward to the next one: Ludum Dare’s April 2012 edition will mark its 10th anniversary, and it will surely be a compo to remember.

Here is my entry for the 22nd Ludum Dare 48-hour game development competition.

All in all, it was a terrific experience (again). Very stressful, but extremely fun at the same time.

Links:

• Play the game (web-based Flash)
• See the Ludum Dare entry page

There were tons of features I wanted to add, notably the huge sub-plot where the character is actually a mental patient “escaping” their reality by inventing a punching hero. The game was meant to switch back and forth between these two realities.

Visit the Ludum Dare entry page here.

I made everything, but the Wifes donated some voices for the evil nurse.

Thanks for playing, and thanks to all who cheered me on!

Special thanks to Daniel Zoran moral support, and also for really powering through this competition. His entry is most impressive!!!!

It might be said that NPCs fit into specific typecast roles because that is how they are most useful for the game designer. In a world built out of limited content, there is little room for more than a token representation of “real” individuals, making the generic NPC rather shallow.

NPC - an experiment from January, 2010

Or are they? About a year ago, I made a sketch of a game called “NPC” (you can play it here, if you like – it even has music by Chen and graphics by Daniel!). Taking control of an ordinary peasant child, various adventurers may approach you and ask for a quest in order to gain experience and items. The quest is invariably to find a lost cat.

In this experiment, the twist that I found most intriguing was the multiplicity of “parallel worlds”, such as it were. Multiple adventurers are tasked with finding a lost cat, and each of them supply an identical-looking cat at the end of their quest. At the end of the game, a summary screen proudly displays your feline collection, as provided by adventuring heroes, the “player characters”.

Legend of Zelda, 1986

One of the most famous NPCs is the Old Man from Legend of Zelda (1986). In the midst of a grassy field, surround by mountains, a small one-room cave is situated. The Old Man, accompanied by his long white beard, red habit and sword have been waiting patiently for you, the player. Framed by eternally-glowing fires, the ritual begins. The magic words are uttered: “It’s dangerous to go alone! Take this.” The Item is offered (sword). Newly armed, the player can continue the quest.

Old Man is in quite a bind!

In the most recent Ludum Dare 48-hour game development competition, this “ritual” was the chosen theme: “It’s dangerous to go alone! Take this.” Many of the competition entries dealt with this famous Old Man scene, from all sorts of different angles. My take on the concept was to assume control of the Old Man himself, rushing from cave to cave and dispensing both crucial advice and Item against a ticking clock.

From this viewpoint, each cave corresponds to a different player, perhaps even a different game universe. This is because the Old Man, much like other NPCs, can exist in an plane orthogonal to the player. As we have become accustomed, the player can explore a single slice of the multiverse, whereas the Old Man and his various counterparts exist simultaneously in all these different worlds and zones. Furthermore – some NPCs exist in all parallel universe and at all time. Old Man will wait for you, the player, for hundreds of thousands of years, if you make him wait that long.

In fact, he is waiting for you right now.

Even though we take the part of a Non-Player Character, the player is playing, so should they be known as Player Non-Player Characters (PNPCs)?

One of the comments on my Ludum Dare entry (written by DrPetter) was this:

… Would be a lot of fun to see more of these “behind the scenes” games based on NPCs from famous titles. That could be a compo theme in itself, so many silly possibilities :)

Undoubtedly, peeking behind the curtain would provide much fun and entertainment, especially to those who are familiar with the old classic games. However, there are many issues to explore here. Instead of revealing the vacuum behind the façade-like characters populating games, I propose we embrace the mythology of cross-dimensional entities, and perhaps try and enrich their existence instead of empty it. (Does this help us understand the Many-worlds interpretation of quantum mechanics?)

Or, taken a step in the other direction: a single mind (the player) exploring a world of mindless automatons is reminiscent of solipsism. What can we learn from this game model that we can apply here on Earth?

How do these in-game entities change as we add other player characters (multi user games)? How do they change as artificial intelligence is improved?

What are your thoughts?

Play The Legend of Old Man after the jump.

Play using the arrow keys (you can also jump with X or the spacebar). Type when prompted, and please excuse the terrible dictionary – it’s the best I could do during the short competition.

Here is the game – you might need to click on it to give it focus.

See original entry page for voting and more details.

Also available: complete source to this project.

The Legend of Old Man was built in Flixel, using the FlashDevelop IDE. Photoshop and GraphicsGale provided drawing tools, and Tiled was the map editor. I used a short Ruby script (included in source) in order to help compile the word list. FL Studio was used for the “music”, and I used Audacity and Increpare’s lovely bfxr for the sound effects.

Trying to make something bad seems to relieve one’s self from the stress of making a great game on your first try. The competition is still open (for a few days at least), and I recommend giving it a shot.

Play Chompre here.

edit: BONUS!! Concept artwork!

The theme of this competition was “Enemies as Weapons”.

The physics are quite wonky, but it is “broken in a good/funny way” as one commenter says. I like that, and yes, I feel it was broken properly.

Links to download on the official submission page.

Also notable were Yoni’s first ever LD entry, and Daniel’s second.

It is called “You are me now”. You may need to click on the game to give it focus before playing. Hopefully, all instructions are given in-game.

If you get stuck, you may need to backtrack a bit.

(original LD entry) | (source) | (post-competition auto-analysis)

(intro/extro music) | (island theme music)

Review by ZOMGIndie!

Download

Get the competition version here:

• Leaving Satisfactoria – exe and source.zip (10,142 KB – Windows .exe and full source)
  • alternative download
• Leaving Satisfactoria.zip (328 KB – full source, needs pygame [see below])

Background

I wanted to break the normal “exploration” mold, where the goal is to uncover every single square on a map. The following elements were under focus:

• A conscious decision to depart from a comfortable space (leaving home)
• The one-way journey, leading your exploration far from the comfort zone
• Accepting the danger before you

The actual “exploration” probably occurs after the end of the game. You will most likely have to play a few times before reaching all points on the field, this is by design.

Tools

The entire game was built with the Pygame Python-based engine. You can get that here. Graphics were done entirely in MSpaint. Sound effects courtesy of sfxr.

However, the idea has been around for years now, and it will reincarnate better than ever. Maybe next time a less lofty goal will be chosen, and the project may attain a feeling of completeness. I believe I may have reached too high in this current cycle, and constantly straining my neck looking at the goals is frustrating and discouraging.

For now, there are some other projects that demand pursuing. Rest assured that the Megastructure will return; because the truth is, it never ceased existing to begin with.

This blog will continue to exist as a development log, as well as @megastrata. I am participating in Ludum Dare #16 this weekend, under the name eli.