Hello! This weekend was my first LD and it was a lot of fun, I’ll definitely join next time too! 😀

Anyway I was wondering about something…

How are the entries scored from the judging? Are the results purely based on the average rating? Wouldn’t that result in the possibility of some game that only one person voted 5 stars on being able to win even though it might be worse than say a game that has 4.78 stars and is rated by hundreds of people? Looking at past entries that seems unlikely.. all the winners are of exceptional quality! Is that because there is like a minimum of votes a game needs to taken into consideration for the final score?

There was nothing about this in the rules.. sorry if it’s been asked before, but I couldn’t find anything about it!:o

Thanks!

Linus

I am so excited to announce that my game-jam-gone-official game Rocket Boy is now available for Alpha testing!

For more info on Rocket Boy, or to join in on the Alpha testing fun please visit my website: http://seacreaturesandwich.com/index.php/rocket-boy/

Thanks fellow Ludum Darers, and have a great judging period!

People were reporting crashes, but I couldn’t reproduce them. Finally I found it. It was a memory leak in a line drawing function (I have enough VRAM that I never enountered this problem). It is fixed now. If you started playing my game before and it crashed, you could hypothetically try it again and see it work this time. If you wanted.

http://www.ludumdare.com/compo/ludum-dare-26/?action=preview&uid=22819

PaperCoaster is our group Ludum Dare jam entry for LD  #26 made by 10 people with CraftStudio!

A game about drawing rollercoasters on paper… how minimalist is that? 😀

You can play & rate it here:
http://www.ludumdare.com/compo/ludum-dare-26/?action=preview&uid=6780

There were at least 8 other games made with CraftStudio for this Ludum Dare edition, which is awesome! I’m trying to gather them all over at the CraftStudio forums.

Tags: craftstudio

Just a re-post from earlier to remind Unity/Dropbox users to please use HTTP not HTTPS (which Dropbox uses by default). It can in some instances result in people not being able to play your game in their browser even though they have Unity Webplayer properly installed. ;___;

someone (surely a crazy person) made a speed run of my game

Congrats somonflex at beating me on my own game!

As predicted, I didn’t end up making a game for Ludum Dare this past weekend.

But I just realized that one of my old ideas actually fits the theme perfectly. It’s called Freetrace. Basically a game where you erase drawings.

So maybe I’ll make it. I just contacted some of my artist friends about it. It would be cool to use some drawings like these:

A little bit of background information first, I’ve been working on an RPG on my own for over a year now. It’s going well but it’s taking a really long time to finish (obviously.) I guess my dream this Ludum Dare was to make a simple, solid, polished game that I could port to touchscreen devices without too much effort, just to get a taste of the whole commercial thing.

Well, that didn’t happen, but I think the game I ended up making is still a great portfolio piece. Especially in combination with the timelapse.

What went wrong

It’s the same story, again. Every Ludum Dare I tell myself I should make something simple and solid, so I have time to test and polish. And I NEVER do. I always end up making something big and ambitious. I got so close this time too! The night before I had this dream the theme was going to be “afterlife” and I made this beautiful game where you played charon who had to take the dead to the afterlife in a beautiful greek vase art style.

But the theme wasn’t afterlife, it was minimalism. I did try to somehow connect charon and greek vases to the theme, as you can see in the timelapse. But I couldn’t.

I also had some problems with the theme. I do think it’s a good theme, but in my mind there was a difference between what I thought were good ways to make use of the theme and what the majority would think. I thought that if I didn’t make something super low-res or something with primary colors and basic shapes, it would get downvoted in the theme category. I thought the best minimalist games wouldn’t even get recognised as such, because they arn’t the games with the low res graphics and barely-enough gameplay elements, it’s the games with exactly the right amount of gameplay elements that make a real minimalist game. It’s about getting to the essence, not to anything less than that.

So in a way it was the perfect theme to make that simple, solid, polished game I wanted to make. But I let possible public opinion hold me back. It would have had comment after comment with “I don’t see how you used the theme.”

I discarded a first Idea because it was too complex mathematically (I wanted to make a game that created minimalist music through playing, with everything that happened in the game having a corresponding instrument/ tone.)

Then the theme made me think of a game I once made that started as a text adventure that was seemingly solved by just typing “go door” but turned into a visual adventure when you typed “look room” and kept introducing new elements from there (Its called secrets) But that game focussed on the fact that there was more than there seemed to be, which felt like the opposite of the theme.

So in the game I ended op making, it is obvious from the start that there is more. Collectables in unreachable places tell the player “There is stuff to collect! There are new powers to gain!” But you are stuck with a character that wants to do no more than is absolutely necessary (minimalism). Too bad for the character, because the player is in control of the game.

I thought – and still do – that that was a pretty interesting premise, so that’s when all my previous plans to make somethin simple, solid and polished went out of the window.

…Somewhere I also decided that I should hand draw everything… Do you get me? I don’t.

What went right

In the end I’m happy I made those choices, I don’t have a perfectly polished game now, but I don’t think that’s what Ludum Dare is about.

The fun of Ludum Dare lies in trying to do the impossible. And hand painting an entire game in under 48 hours? I am not supposed to be able to do that. Yet that’s exactly what I did.

I could talk some more about the fact that composing went great, sound design went right, programming went okay and it’s unfortunate you can get stuck in walls, but that’s not what I take away this time. What I take away is that I love to challenge myself, I need that every four months while I’m working on that RPG that seems to take forever to finish, and it’s unlikely that I’ll ever make a simple, solid, polished game for any ludum dare yet to come, even though I may try to do so again.

Play my game here

Game: Exploding Cubes of Cleanliness

Exploding Cubes of Cleanliness (ECC from now on) is a puzzle game where you try to unravel a mess to reveal a pristine white grid.

What Went Right

• It’s… fun! This became a negative (read what went wrong) but it was actually fun by the end of day one.
• The removal animation gives it some flavor.
• I added in very basic logging so I can tell when players are finding things difficult. I can’t tweak the difficulty for purposes of the competition, but I will as I turn this into production-quality game.
• libGDX. It brought with it one minor negative (performance/quality of HTML port) but brought an incredible amount of positives. And I’m not even sure what other engine I could have used that would have made better html5 output without me giving up a lot of things in return.
• I created a YouTube video of my playing it shortly after the deadline and put it on the page. People do seem to get it a little better once they see it being done.
• Put the flower mode in the main menu. It originally swapped modes at level 14. According to my stats, the highest level anyone has played is 10. It would have literally been wasted if I hadn’t made this change.

What Went Wrong

• People don’t get it. My internal stats say that more than 50% of clicks in level 1 are wrong. Level 1 literally takes a single click to beat, no matter what difficulty you choose. It needs a tutorial badly. I knew this, but didn’t make the time for it.
• The HTML port is especially ugly, slow, and error-prone (if you block flash it doesn’t load at all, even though it only uses flash for audio).
• It’s ugly. It got to fun (for those who know how to play) quickly, and I spent too much of my time “play testing” or polishing mechanics instead of polishing visuals.
• I suck at marketing. I spammed Twitter and the IRC room, but have mostly failed to drum up much attention.

Early screenshot: Exploding Cubes of Cleanliness

Video of me playing it: Exploding Cubes of Cleanliness

So I made my first LD game!

It turned out alright in the end I suppose, it works as intended even if it doesn’t have all the features I would have liked. And sorry to any colorblind players! If I ever make an updated version with more of everything I’ll be sure to include a colorblind mode. But I blame the painters I ripped off for the graphics style 😛

The only major thing missing from my original idea is for the game to showcase the individual “suprema” the player collects, the whole point was to show how some of these minimal shapes look better when paired according to the game rules. Oh well. I’ll definitely see if I can’t give it a touch up and turn it into something that’s fun for more than a few moments. Perhaps more shapes and game modes.

I’ll be back for LD27

After reading through the contest rules again, I realized that my use of some prerecorded sound effects is a violation of the rules. Oops!

This was an oversight on my part, since I rarely do anything with audio, but I regret giving false impressions about the quality of my work. I’ve removed the offending sounds from my main entry and moved them to a ‘non-compo’ version, but since I’ve already received a fair number of ratings, I’m afraid this disqualifies me from the competition proper.

Apologies to anyone I may have unwittingly deceived, but I hope you enjoyed my game anyway! Next time I’ll go out and record some bird sounds myself, somehow…

This is a time-lapse video of my development of Amish Brothers for Ludum Dare 26.  The video footage was taken from my Twitch.tv stream.

Generating a time-lapse video from a Twitch.tv stream is not a trivial task.  I will describe the process that I used to create this video.  This is only a suggested method, and I do not suggest, promote, or advocate any of the software packages described below.  Use all software at your own risk.

First, you will need all of your Twitch.Tv video clips.  These can be downloaded from http://bashtech.net/twitch/download.php .  You will need to connect your twitch.tv account with your username and password.  I believe the authentication is through Twitch.tv, so it should be safe, but don’t hold me to that.  To be on the safe side, make sure your Twitch.Tv password is unique from any other passwords that you use.

Then start pressing the Next button until you get to the videos that you want to use for your time lapse.  If you’re like me, you named these videos something like Ludum Dare.  Now for the monotonous part, start downloading each of the video streams into a folder of your choosing.  These videos will be saved in FLV format.  Unfortunately, this site provides your videos in 30 minute chunks, so there may be numerous video files to download.  If you are clever, you can probably script a process to speed up the download process using a web file grabber like wget or curl.

Download and install the VLC video player from http://www.videolan.org/vlc/ .

VLC can be used to generate snapshots of an FLV video as specified frame intervals using  a command like the one below from a Windows command prompt.

> vlc C:\ludumdare\myvideo.flv --rate=1 --video-filter=scene --vout=dummy --start-time=1 
--stop-time=1800 --scene-format=png --scene-ratio=24 --scene-prefix=snap 
--scene-path=C:\ludumdare\screens vlc://quit

This tells VLC to generate a snapshot every 24 frames for the first 1800 seconds (30 minutes).  This works okay, but the stream has to completely play through the entire 30 minutes to take the snapshots.  Therefore, it will take the total amount of casting time to grab all of the snapshots for the time-lapse video.  This method could take hours for to grab all the snapshots out of the stream videos.

Note: The path to VLC must be in your PATH environment variable.  This can be done in a command prompt using a command such as the one below.  Change the value accordingly for your VLC installation.

set PATH=%PATH%;C:\Program Files (x86)\VideoLAN\VLC

To make this process more efficient, we only want to play the video at the points where we will capture a snapshot.  This can be accomplished by changing the start-time and stop-time values.  When specifying those values, VLC will start generating snapshots at that number of seconds into the clip.  However, there is an apparent bug which makes VLC also generate a snapshot at the beginning of the video as well.

Now to generate all of the snapshots, we will need to execute VLC setting the start-time parameter to the value of the position where the snapshot should be taken.  Repeat this process by incrementing the start-time parameter by the interval between frames in seconds.  I set the stop-time to the start-time + 1, since we only want to capture one frame at that time.  Be careful to make scene-ratio the value of the frames per second for the cast, so that only one snapshot is taken for the one second interval.  In most cases, that value will probably be 24 frames per second for Twitch.tv.

I chose to take one frame every 30 seconds for my Amish Brothers time lapse video.  I scripted this process in Ruby, so that it automatically calls VLC with the correct time parameters.  This made the total time to generate the snapshots for a 30 minute video 60 seconds (2 snapshots generated for each minute of footage at one second each), but maybe a little longer due to some overhead of starting and stopping VLC.

That is good, but I had 37 videos to process, which is still tedious.  With a little more scripting, I was able to loop through all of the FLV files that I had downloaded into my video directory.  After the script is complete, it puts all of the PNG image files in the “screens” directory.  However, there is that bug in VLC that generates an image at the start of the video, so with a simple DOS delete command I removed all of the “*00001.png” files, leaving only the correct snapshots remaining in the directory.

Below is the Ruby code for generating the snapshots with VLC.

USE AT YOUR OWN RISK AND ONLY IF YOU KNOW WHAT YOU ARE DOING!

iFramesPerSecond = 25
iSecondInterval = 30
iFrameCounter = 1

Dir.foreach('.') do | strFile |
  if (strFile =~ /\.flv/)

    iStartTime = 1
    while (iStartTime < 30 * 60)

      strFrame = "%05d" % iFrameCounter

      strCommand = "vlc #{strFile} --rate=1 --video-filter=scene --start-time=#{iStartTime} 
--stop-time=#{iStartTime + 1} --vout=dummy --aout=dummy --scene-format=png 
--scene-ratio=#{iFramesPerSecond - 1} --scene-prefix=#{strFrame}f 
--scene-path=.\\screens vlc://quit"
      puts "Running #{strCommand}"
      system(strCommand)

      iFrameCounter += 1
      iStartTime += iSecondInterval

    end
   end
 end

Next, I went through my snapshot directory and removed unneeded images, such as when I was eating or away on a bathroom break.

Now I needed to put the snapshots back together in a video file.  Some people have recommended Chronolapse, but I tried it and the video quality was really poor and there were no options to increase the quality.  Therefore, I used VirtualDub (http://virtualdub.org/), which can also make a video out of image files.

The only problem with VirtualDub is that it expects the filenames to be in sequential order (0001.png, 0002.png, 0003.png, etc), and the filenames generated by VLC can only be specified by a prefix, and it gives each file an unchangeable ending, which is based on the frame number.  To resolve this, I wrote another Ruby script which looped through all my snapshot images and renamed them to sequential file names.  I’m not sure if the files are looped through by lexicographical order or timestamp order by default, but it worked so I’m not complaining.

USE AT YOUR OWN RISK AND ONLY IF YOU KNOW WHAT YOU ARE DOING!

iFile = 1

Dir.foreach('.') do | strFile |

  if (strFile =~ /\.png/)

    strNewName =  "%05d" % iFile
    strNewName += ".png"

    puts "Old: #{strFile} New: #{strNewName}"
    File.rename(strFile, strNewName)

    iFile += 1

  end

end

Now all of my images are in the directory in sequential order by file name.  The images can be imported into VirtualDub by selecting File > Open Video File and selecting the first image.  It will automatically add all of the other images in the directory.  I also added an audio track using some of the music from my game, by selecting Audio > Audio from other file.  It is important to note that VirtualDub will not loop your audio, so I had to manually loop the audio myself by extending the audio track in Audacity.

Finally, I added a credits screen at the end, which seemed to be more trouble than it was worth.  There is no way to slow down or copy frames in Virtual Dub, so I had to make another video file containing my credits, and then used File > Append AVI segment to add it to the end.

Now I just needed to encode the video, but it turned out to be about 5 Gigs in size, which I believe is too big for YouTube.  This was fixed by selecting Video > Compression from the VirtualDub menu.  It gives a few different compression methods.  I didn’t really have a clue as to which one is best, so I just selected Microsoft Video 1.  It reduced the size to around 400 Megs, so it did the job.

Finally, I previewed the video and uploaded to YouTube.  It seemed to a be a lot of trouble just to make a time-lapse video, but this was my method since I didn’t not use a screen capture program and I didn’t want to spend a lot of money on a professional video package.

References:

http://wiki.videolan.org/How_to_create_thumbnails

http://code.google.com/p/chronolapse/

http://support.twitch.tv/discussion/2391/frequently-asked-questions

http://www.ludumdare.com/compo/2012/09/09/how-to-make-a-good-timelapse/

https://wiki.videolan.org/VLC_command-line_help

Tags: timelapse

Hey ! We improved swimming fool, it no longer sticks you in crazy froglish dialogs and control is ‘mush’  better  !

If we can we’ll make a post mortem tomorrow relating our experience with haxe and starling and other super uber meaningful details such as how much tavrox slept !

XOXO, BM

Thanks for playing !

What went right?

Animation works! I integrated an animation system which uses image references based on an animation state.

Mostly consistent style! I used less colours and also added a slight orange tint to the final scene. I used a lot of real pictures such as the background. I also made the levels (replaced pngs doodled in a tray of salt). The wall graphic works really well as a texture (minus the tiling), though the garden itself was a bit of a hassle, and I spent a few hours finding an appropriate texture for that before resorting to basics (the salt has a slight grey tint). Building a concept image really helped this.

Basic gameplay: The shooing mechanism wasn’t what I first intended, the original idea was that the cat and dog were messing up the level and you were sorting it out (cough, Fix it felix, cough).

Ideas: I generated a few then picked what I considered to be a rare idea. My first ideas were all like mondrial crazy painter, so I wanted to get away from that. It was good coming back to my ideas later to appraise them critically, rather than being swept up near the start.

What went wrong?

Timing: I had a few ideas for themes at about 5am, but I started at about 3pm on Saturday, 12 hours after the start. I then lost some supplies so didn’t really do much on Saturday apart from draw some resources and build the concept image.

Art: My import process was sloppy as I was taking photographs of faint coloured pencil drawings. I should have been using my scanner from the start. Also, I decided to learn animation on the fly, and didn’t have a workflow to help me do that. It would have been handy to have my multiple layers within a single frame object in Gimp, rather than having layers everywhere.

Swing: I had an issue with my double buffering. Turns out I was using 2 backbuffers so when i flipped from the backbuffer for the first frame, that was blank and nothing showed. Similarly, I had problems with only certain objects using double buffering too, which all meant it took me a while to get anything of note on the screen. Even with referencing my working projects.

Perfectionism: Although I could have probably submitted for the 48 hours on Sunday, I was sleepy after a late lunch and it just wasn’t polished enough to submit.. I’ve done 72 successfully.. The 48 hours is the next goal to break!

Things of note:

I put poop into the game at 5 hours to because my sister mentioned it. The code is awesome:

if (“TURDING”.equals(animationSequence)){

Long currentPoopStart = GameState.getAsLong(key, GameState.POOPOFFSET);

long poopDuration = startTime-currentPoopStart.longValue();

//                            System.out.println(poopDuration);

MyBoolean pooped = GameState.getAsMyBoolean(key, GameState.POOPED);

if (poopDuration > 2000 && pooped == null){

// thats a long enough poop.

int turd = GameState.add(“turd”, new MyXY(location.x, location.y+3));

GameState.addField(key, GameState.POOPED, new MyBoolean(true));

}

if (poopDuration > 3200){

// figure out where to go

int returnX = -150;

if (!rand.nextBoolean()){

returnX = 1150;

}

// run along now

MyXY targetDestination = new MyXY(returnX, location.y);

GameState.addField(key, GameState.TARGET, targetDestination);

}

else {

// keep doing what you’re doing, kitty!

continue;

}

}

I also made this really weird data structure to save any parameter to any integer key. It isn’t normal, but it meant that instead of adding a hundred parameters to every object, I could add new parameters whenever I needed and not have really unwieldy objects with a hundred unused getters and setters. I’m not sure if it is a side effect, but I didn’t notice any garbage collection or slowdown either. It’s quite bizarre, as I was really lazy and left my objects in the hash rather than removing anything.

public static HashMap<Integer, HashMap<Integer, Object>> objects = new HashMap<Integer, HashMap<Integer,Object>>();

public static int add(String type, MyXY location){

int newKey = objectsPresent++;

objects.put(newKey, new HashMap<Integer, Object>());

addField(newKey, TYPE, type);

addField(newKey, LOCATION, location);

return newKey;

}

To finish, I think this was a very successful Jam, and while the game looks and acts like a real game.. It doesn’t really have the fun factor (and its a matter of time until catmoggeddon). I would typically start from a basic programming concept, make it work, make it interesting, and then try to fit some art into that and make it challenging afterwards. Though if I had done that, I would have likely built a completely different game and focused on the cleaning up mechanic rather than chasing cats.

As it says on the tin: Broke Down is a Twinestory about tearing shit up and getting off on it.

Twine is easy to use, but it takes a little persistence to coax out the possibilities. Fortunately, there are resources everywhere (Porpentine has collected many). I relied heavily on the collective knowledge shared by the Twine community.

1 Design
I wanted to design the layout first, because I knew that there would be a temptation to use the default CSS styling if there was a time crunch. The hardest part was figuring out which elements affected what, especially for the sidebar (the hyperlink in the byline bedeviled me). When I got stuck, I was able to look at Leon and Porpentine’s stylesheets to figure out which elements to reference in my own CSS. Dan Cox’s Twine tutorial provided information about using Google Web Fonts.

2 Mechanic
Implementing the story layers was easily done using Twine’s built-in if macro and jumping to “more” and “less” passages that changed the level variable. The hard part was resetting the variable each time the reader advanced, and I felt this was critical. I couldn’t find a way to combine the set macro with internal links. I thought I found a workaround using Leon’s timedreplace macro, but an hour before the deadline I realized it didn’t work. As a last-minute MacGuyver move I created duplicate passages that reset the variable and automatically jumped to the prose passage using Leon’s goto macro. It doubles the number of passages but it works.

I used a number of Leon’s excellent macros and fixes:

• Timedgoto macro
• Timedreplace and timedinsert macros
• Display macro fix (allows variable passage names)
• Inline CSS fix

3 Writing
I got a late start Saturday morning. I wasn’t sure about the story, I just knew I wanted 3 levels of prose. I spent most of the day freewriting stuff and reading erotic fanfiction (sorry, it’s true), and I thought about people in rollover crashes and what it might be like to roll downhill in a metal cage and maybe hit a tree or water. I don’t know what that says exactly, it’s just where my head was at. Sometime Sunday morning the story clicked and I wrote the bulk of the prose from then until deadline. I was writing up until the last ten minutes and ended up condensing routes to make it in on time. What you’re seeing is relatively raw.

4 Post-competition
I will release a post-competition version before voting ends. I mainly want to expand the routes and add more diversity, but I had an idea for color scheme changes that I want to try implementing. Li’l, my jam partner for LD25, has expressed interest in creating music.

As far as what worked/didn’t work, I got lucky and had access to awesome macros that let me set up the story experience I wanted. It was a much more organic process than my previous entries, but it worked out.

I thought I would take a break from playing entries to write a quick post mortem on my game Rokhopr. If you haven’t played it yet, it’s a simple 1 button game for 1 or two players. It can be played on desktop browsers with the keyboard or on touch enabled devices.

Play it here!

Here are a few points regarding the development:

The good
I decided to make the game from scratch using the HTML5 canvas tag and JavaScript. I wanted to make sure the game could easily be played on desktop browsers as well as touch enabled phones and tablets and I think I achieved that (though I’m sure there are some devices and/or browsers that don’t work, but haven’t encountered any yet).

I think the 2 player mode was a nice addition that I decided on quite late on. Though it took a while to implement, I think it worked out pretty well.

I was pretty happy with how the minimal 4 colour Gameboy-style aesthetic turned out in the end (although I probably spent too much time trying out different colours/designs).

The not so good
I ran out of time before I had done any game balancing (tweaking the rock spawning rate, speed up rate, player rotation and movement speed etc), and I feel the game really needs this to make it fairer and try to eliminate situations that are impossible for the player to deal with.

Also, the game is completely silent. I knew that getting consistent audio behavior across devices/browsers might be tricky, so I decided to not even try quite early on. Obviously the game could have been improved with some sound effects and music, so this was a shame.

Well, that’s all from me – back to playing my way through the entries!

Hello guys,

Did you already save enough animals with your extraordinary space ship?  No ???  You really are failing.

You can now discover all possibilities of our game on

https://dl.dropboxusercontent.com/u/69483216/Site%20spaceship/index.html

with a tutorial and explanations.

With all this, you don’t have any excuse to fail your missions !!

You can find the game here : http://www.ludumdare.com/compo/ludum-dare-26/?action=preview&uid=20579

Intro

IceBreaker is a minimalist free-pause RTS-ish thing (probably better described as an FTL-like, though bearing little similarity) set in a Cyberspace similar to the one portrayed in William Gibson’s Neuromancer (a book which changed my adolescent life and is at least partially responsible for my getting into programming).

I didn’t get much (okay, any) journal-writing done during the weekend, though there’s a vague run-down of events in the project’s github page.

So consider this (rather large) postmortem post-hoc overcompensation. (and apologies in advance for the spam)

Blender was extremely helpful for rapidly producing the future-retro look very quickly, even the sprites were tiny renderings with wireframes

You can’t quite tell, but it’s a stripped-down RTS:

• no resources or buildings (instead you have gestation periods for replication)
• since you can’t build unit factories, you instead have to replicate (and be vulnerable), but if you’re standing still you will heal
• there /are/ classes, but they are restricted to *strength* (hit amount) and *vitality* (health)
• it’s meant to be broken down into very short levels, generally with you collecting/destroying something which is being protected.

Statistics

• Four litres of coffee consumed
• A whole forest of tobacco
• 3,617 lines of code
  • That’s 60 A4 pages if printed out
  • According to Wolfram Alpha that’s:
    • about 17.8 metres ( 58 ft ) tall
    • 6.6 storeys high
    • and about half the diameter of the Hindenberg
  • Very sore wrists (hush, you!)
• somewhere between 3 and 6 hours of sleep

What went wrong

1. strong underlying system
   • unlike my last two LudumDare attempts, I knew what I wanted to do very quickly, I wrote about three pages of ideas and then stopped when I realised I’d already made my mind up to do the first one.
     However I didn’t flesh out the details as much as usual and so started building the basic framework while pondering, knowing I could change the details later on.  This resulted in a lot of code ( ~60ft worth! ) that, whilst extremely useful was probably not necessary to get the basics of the game done.
     I remain convinced that it was doable within the alotted time period (the post compo version is only an extra 4 hours work, with the last 3 mostly being unnecesary tweaking)
2. not enough testing of environment
   • I did more preparation than previously, but I wasted time on a few things which could have been sorted out before the compo:
     • setting up the live stream stole about 1-2 hours, admittedly I was feeling a bit braindead/overwhelmed/uninspired so this was a better utilisation of time than say, nothing.  But this should have “Just Worked”
     • Final builds (I’ll get to that)
3. using an unfamiliar framework and language (again)
   • In my first LD, I used AS3/FlashPunk which I’d picked up a couple of hours before the compo.  In the second, I used Java/LibGDX and didn’t complete – whilst I had familiarity with Java I was very very new to LibGDX and as a result spent wayy too much time googling.  This time was a fair bit better (Haxe is quite similar to Java/AS3) but I still had little to now experience with either it, or HaxePunk
   • HaxePunk is quite nice, but unfortunately not quite “there” yet for me, I wrote a disproportionately large amount of patches to the library in order to get basic features to work normally.  This stole quite a bit of time, but it was far too late in the project to change ships.  I look forward to using it more though.
4. refactoring at the halfway point
   • despite having most of the system quite well designed in my head, I had to stop and write a vast swathe of code on day 2, partially to undo the odd choices of my sleep-deprived self the night before
5. sleep (braindead 6+6 hours)
   • I should have done it sooner, and more.  I’m quite good without sleep, but I ran rampant on the code-base when I  started getting exhausted.  Much time was spent rectifying this spaghetti.  I’m not sure how long I actually slept (somewhere between 4 and 6 hours), but I easily lost 12 hours to silly choices and then the bleary-headedness upon waking.

     

     an early screenshot complete with pointless UI and ugly tiles

6. didn’t demonstrate theme clearly enough (despite following it)
   • I had basic gameplay down very early in the project this time, but the sleep-spaghetti resulted in about 10-12 hours of programming which left me (effectively) where I started
7. planning
   • I actually planned quite well in a lot of ways, but some very fundamental (and rudimentary) aspects were overlooked initially, resulting in much confusion and wasted time
8. submission process panic!
   • I tested my environment this time to avoid this exact thing.  However I discovered (at submission time) that whilst my project ran perfectly in the Flash standalone player, it would silently fail completely in-browser.  It turns out all I had to do was add “-web” to the build command, but it took me far too long to discover this!
9. no end-game detection or automatic level progression
   • despite “shipping” with a few levels, the submission process issues resulted in my missing the 20 minutes that I needed to finalise this important factor of a “short-level based game” and the gameplay suffers for it.

What went right

1. strong underlying system
   1. Yes, it’s a dirty trick having this in both sections.  But I maintain that the approach was a good one, early efforts resulted in the tutorial system being a mere 45 minutes to implement, and most new features were added extremely quickly
   2. I used JSON for most of the configuration of the game, allowing rapid prototyping of enemy AI, character attributes, menus and the tutorial system)
2. using Haxe and SublimeText 2
   1. This was a pretty awesome combination, I look forward to being able to justify the $70 license for SublimeText2 (this was my first real experience with it, and it was wonderful).  I have been using (shudder) Eclipse for a while despite my lack of appreciation for IDEs in general so it was nice to have a “real” development environment again.  However I’ve gotten rather dependent on Eclipse’s easy mass-refactoring, and you can really tell (names of things changed through the course of the project and thus there are some things named Agents which are actually Actors and so forth)
3. the game idea
   1. I think this concept is pretty sound, and I enjoyed playtesting it.  Definitely building some more levels and a little more “Juice” and thrusting it in the face of anyone who walks by
4. music and art
   1. There were a few times when my brain completely went on strike, so it was good to change gears and work in Blender or Renoise to build some of the feel, having these elements in game was also fantastic for morale.
   2. The music was made in about 5-15 minutes for each of the two tracks
   3. Art was quite quick too, despite a few false starts
5. tutorial system
   1. I’m really happy with the tutorial system, which could also double as a mission introduction system.  It hooks into game events and each dialog of the tutorial can have a number of events required before it appears, or disappears making it very easy to make a clear (and importantly, responsive) tutorial.

The in-game tutorial system is quite smart, if a little overenthusiastic

Last words

Thanks to everyone for an awesome experience yet again!

Project source (github) | Project page | Live stream (twitch)

I strongly encourage you to try out the Jam/Post-compo version after you’ve rated, as it’ll be a lot more clear what I was trying to achieve

Tags: 2D, blender, compo, flash, flashpunk, haXe, jam, LD#26, post-mortem, postmortem, sublimetext2

My Entry – The Time Saver

Tags: console, terminal, timelapse