This is my third Ludum Dare, and I’m going to make it the first where I actually finished my game. This LD starts few hours after my last exam, talk about good timing :). As usual, I will be using FlashDevelop + Flashpunk + stuffs from the tools page.

So… good luck to all other participants!

PS. I’m sad that we don’t have silly themes anymore

My first Ludum dare. I will use libgdx and hopefully get something to work for all desktops platforms + android.

I’m looking forward to watching everyone make amazing games this weekend. I have a request: please connect with me so we can encourage each other to do amazing things! Be sure to post tons of screenshots on twitter using the #screenshotsaturday and #LD48 hashtags.

I’d be grateful if you followed (I’ll follow you back!):

Twitter: http://twitter.com/mcfunkypants

Google+: http://mcfunkypants.com/+

Tags: Google, ld48, screenshotsaturday, twitter

I’m in!

This will be my second LD. My first entry’s scope was simply far too big, and it never saw the light of day. This time I’ve come back with a graphics/control toolkit of my own design, JLayer to help out with music playback, and a promise-to-self to spend more time in design and be ruthless in cutting out the fat. This year the whole shebang will also be in jnlp/Java Web Start, so you can launch it directly from the site.

A couple notes on tools: Sfxr/bfxr is absolutely invaluable for sound effects. Gimp is no replacement for Adobe Photoshop, no matter what open source evangelists say. Renoise and Reason/Rebirth are extremely powerful all-in-one music studios.

Finally, I have had my brain filled with cool ideas all year. I’m dying to use steganography to embed the levels into something else. There are UDP tricks I’ve been meaning to implement. Story ideas that haven’t seen prime time… yet. And they may not in the next couple days either. I have to be ruthless about these things. When the theme is revealed, I’ll start designing all kinds of crazy stuff. (seriously, people have asked me what I’m smoking. I’m not!) Then I’m going to kill my baby, crossing off more than half the things I want to put in until I have something I can implement in 24 hours, even though the compo is 48. If all goes well, for half of the compo I’ll be ‘done’ with my entry and adding pure gravy. If not, well, good thing I crossed those things off.

Good luck to everyone! Many of my favorite flash games came from Prior LD’s (yes, that was a pun), so I can’t wait to play what you’re writing! This is not an easy challenge, but keep plodding on – I believe in you.

–Falkreon

So it turns out I’ll have to work this weekend. I’ve figured out if I subtract work, sleep, driving, eating, and the inevitable stress-diarrhea, I have about 8 hours to make a game. That should be enough time, right?

Oh, and since I already went to the trouble to make this:

See you in 1 day, 12 hours, 48 minutes, and 53 seconds!

My first ludumdare weekend and looking forward to it!!

I’ll use game maker and all I wanted is to make circles in my painting pad but can’t use a spirograph on the wacom.

I have a weekend of packing and cleaning house ready to leave for christmas holidays from Berlin to Vigo (spain). So in the relax time at home, I will enjoy nice tea cups with the game making!

yeay!

Yep, I’m in. This time I’ll try to use the following setup:

Code: Java and libGDX (uses LWJGL)

Graphics: Paint.Net, GraphicsGale and Inkscape

SoundFX: bfxr/sfxr or my mic if I need some fancy sounds.

Music: Sunvox or Ableton

We’ll meet in IRC, if you happen to be there.

First time, thought I would try my hand at this. There is a small chance I will get waylaid (ie. drink too much) at a christmas party and not be in any state to submit anything, but I will at least start on it

I will be using C++, SFML, GIMP, audacity + microphone. I have only spent a few hours with SFML so far but it looks good – this will be an opportunity to get some more experience with it.

Also will most likely use Box2D, Angelscript, and my editor for Box2D scenes.

I made a small project to use as my basecode, available here. It opens an SFML window and moves some dots around using Angelscript.

This will be my first Ludum-Dare.  I’m going to use XNA, paint.net/gimp/picroma (haven’t decided yet) and sfxr (of course).

I haven’t decided yet how am I going to broadcast my work.. maybe justin.tv

I understood I don’t have the full 48 hours maybe only a half of them, but still I’ll do the best I can.

Have a great Ludum Dare everyone!

I am going to give it a try. This will be my first LD so i dont know if i can finish anything. I will try though.

I will be using java for code, paint.net for graphics and sfxr, lmms and audacity for sound/music.

I might also use the ogmo editor, if it fits the theme and if i can get it to work with java.

Some of you may remember me from last Ludum Dare jam, where I did Reveal with my friend.  This time, I’m going it alone in the competish.  Unity3d and Blender are tools of choice, and I’ll be streaming development w/chat a la http://www.justin.tv/offwhitefox.

P.S. no overtly nihilistic themes in my game this time.  Though on second thought…

This will be my first Ludum-Dare. I’m founder of Islandworks, a “serious game” gamestudio.

Language: C++

OS of choice: Windows 7

Graphics Library of choice: Irrlicht

Audio library of choice: Irrklang.

3D Graphics: 3dsMax

2D Graphics: Photoshop/Illustrator

Have a great Ludum Dare everyone!

Tags: strong99

I’m in, for the jam only though. First Ludum Dare comp I’ve been in, should be fun. Although currently I have no idea what I’ll be using.

I’m planning to use my 2D framework (built on xna 4.0) for my LD22 entry, so here it is: http://www.dynamicarcade.co.uk/downloads/xna/Dynamic2D/Dynamic2D.zip
It’s very bare bones, but it basically works like this:
Derive from Game for your game, which is just like xna’s Game but with a few more features. The only real difference is game logic should go in UpdateGame() instead of Update(), and try to Draw using GameObjects instead of overriding Draw().
Derive from GameObject for all of your game objects.
Derive from GameObjectBase for object templates. Set GameObjectType and use ConstructInstance() on the template to create an instance of a game object from that template. Then set the object’s initial properties (like position) then call AddToGame().

Okay, too many years of being on the fence.  I’ll be in the jam this time ’round.  Gonna be using Java/LWJGL, and a personal engine/library I’ve been rolling over the last couple of years.

I’ll be using:

VS 2010

Unity3D with SpriteManager2, iTween

Photoshop

3dsmax 2010

TimelineFX

Audacity

sfxr

not sure how I’m gonna make music… maybe on the ipad app Rhythm Studio

dont know if it will be 3d or 2d but those tools should cover both

I mentioned in my “Im in” post that I will be using the code I made in the last LD as a base for this one, im not sure if using, or even looking, at that code again is a good idea, but I’m hoping it will give me the chance to focus more on the game and particularly on audio this time.

Anyway, the code repo is here https://github.com/callidus/Callidus-Ludum-Dare-Framework so there you  go. This also holds the code for my online tile map editor tool available at http://www.callidusrex.com/mapper

Good luck all.

In the past I’ve tried building “frameworks.” They never did what I expected them to do. But this past week I’ve worked on another one and it’s actually shaped up reasonably well. Calling it “TriadNME” – it is a haXe/NME/Flash10 2d platforming engine with applicability to other 2d games. Some notes on interesting elements of the design and things I discovered in the process:

• Mostly based on stealing existing good code from old projects. Proven code is golden, and possibly worth more than the architecture itself. I would actually consider Triad a second generation framework(the first being some bits of code for timing, the entity system, build system, etc.)
• Very centered around the haXe dynamic/static typing mix. Entities are anonymous objects, with a component system based on “conventions” of data layout(field names, an array of component destructors, etc.) attached to them. I’ve used this for about a year on many projects – it feels like the right mix most of the time.
• Lax approach to performance to favor reusable functionality. Essentially, I give myself room to use a layer or two of  indirection(callbacks, lookups, etc.), but try not to go much deeper. So, e.g., instead of a hardcoded timer I now use an Alarm class with callbacks. Character controllers, camera movements, etc. are similarly based on callbacks, thus it’s easy to go from (e.g.) flipscreen camera to scrolling and centered around the player. If I want to regain performance from those things – I can usually rewrite the specific functionality.
• Minimal contextual instancing. By this I mean – at the start I prepare all the core structures(whether as singleton instances or as static classes) and never destroy or replace them. Instead I call reset methods and toggle visiblility on the Flash displaylist. As a result, I never have to litter tests in the code for whether a certain kind of data is available, because it always is. To change contexts, I disable some functionality. As a result, there’s a whole body of code that simply doesn’t exist, since disabling is (in general) easier than destruction. This goes hand-in-hand with the approach to performance.
• My approach to algorithms has generally improved. I’ve started making my own “xxxTools” static classes for common algorithms – so I have some for math/trig/probability now,  some bits for strings and hashes, some bits specific to my AABB/tile collision system. Conversions between measurements (degrees/radians, pixels/tiles) and alignments (centered, left, right, above, below) are a major part of the toolbox and my core data structures tend to include a lot of conversion methods. Similarly, more structural algorithms like “array of objects with name fields” to “string hash of objects” are starting to come into play. In the past I had a horrible tendency to rewrite simple algorithms and inline stuff that didn’t warrant the customization, but hopefully I’ve come around on that.
• [haXe-specific] – I use many more anonymous structures. HaXe is structurally typed and lets me add a bit of extra type checking just by wrapping everything in a little structure – e.g. most of my points are {x:Int,y:Int} or {x:Float,y:Float], instead of being a class. This adds a bit more flexibility in writing the data because I can just inline the structure into a function call instead of going through writing a class, a new() method, etc. Doing this lowers performance for the Flash target somewhat, but adds a ton of code clarity.
• While heaping on engine-level features with sprites, rendering, physics, I specifically tried to engineer them so that they’re easy to rip out if I don’t want to use them for LD. This had the effect of making them modular without an explicitly “modular/pluggable” system design – a field on the main class, one call to initialize, one call to reset, one call to update. Take those out and the system is essentially gone, although other things might reference them – but that’s more of an “integration” problem and usually just requires more things to be deleted.
• The in-game console is increasingly central to the workflow. I try to cram as many in-game tools as I can because – besides the obvious iteration improvements – it has a knock-on effect on the architecture where I need to keep data in both editable and playable forms, thus it starts decomposing towards the “real” constraints.  The console works as a way to quickly expose editing functionality. This is something I could continue to refine considerably with tool-specific namespaces, unix-esque pipes, etc.
• I opted for a tilesheet format that uses a “smallest size” of tile and rebuilds larger ones from that, similar to the character-mapped graphics of older consoles(NES, SMS, etc.). This has some interesting effects on editability – with an in-game editor the downsides are mostly covered, but the benefits in internal architecture are surprising: the structure of graphics access is greatly clarified when you have three ways to inspect a tile sheet – by set name, by set index, by tile index. It works particularly well with the autotiling algorithms I’ve made(one of the main reasons I started down this path). It also means that the framework should port more easily to a 3D-accelerated setting since only the rendering methods have to change – the original data for sprites and tiles is already a nice NPOT-sized thing.

This is my framework, there are many like it, but this one is mine.

It’s basically bits of code that i’ve written for game jams over the ages, use them at your own risk.

I’ll upload the level editor that i’ll be using aswell, i just need to fix a few things first.

Src