So, minimalism turned out to be a great theme for me. I’d already been thinking about the idea of just doing a simple, fun game to relax after all of the hard work I’d been doing on my other game, so everything worked out. But not before a sidetrip through the insanity of development that was just a little bit more insane than usual.

I decided to take a well-known genre and pare it down to the core experience. Hence, a bullet-hell shooter with no shooting. The player doesn’t even have to click on anything–the click at the start is just to make sure your web browser is focused. While the art style references De Stijl, I felt that for a game the essence was in the mechanics, not the visuals, so I avoided the visual minimalism of horizontal and vertical lines in favor of an interactive minimalism of a handful of actors and the tightly defined but emergent relationship between them.

Despite everything in the game being a square, you can pretty much instantly tell how they relate to each other just but how they move and interact. I like how that turned out.

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

What Went Wrong

Time

Technically this didn’t go wrong so much as I knew going in that this was going to be an issue. I had a major paper due the week of Ludum Dare, so there was no way I would be able to devote the full time to the game, or even very much of it. I actually wasn’t sure if I was going to participate at all until a late evening conversation on Saturday made me realize that I had to get this idea out of my head. I always make a point of sleeping properly and not disrupting my usual routines, so even though I had deadlines about to steamroll me I ended up putting in about three hours on the game Saturday night and picking development back up at about ten or so on Sunday. In total, I probably spent about twelve to fifteen hours on the game.

Audio

I knew I wanted to get audio into the game, but a bug earlier in the day had put me behind, so I ended up with three hours to go, no audio–and no idea how to add it, because Processing.js doesn’t natively do audio. I had to learn HTML5 audio and make the sounds in three hours or less. Preferably less, because I like to leave some extra time at the end of Ludum Dare for breathing room. It worked in the end, but I’d have liked to have a bit more attention to the audio–but not to add much, because the minimalistic effects that are currently a part of the game do fit the theme. Just be glad my screeching temp sounds got replaced.

Testing

The procedural generator I wrote is fairly clever, given the time constraints. It divides the different possible features a wave can have into buckets and then uses Perlin noise to select a subset of those features to use. But it needs a bit more tuning than it has. I was the only one testing it, so I knew the ins and outs of the generator, but other people take a bit of time to figure it out and mostly die when the difficulty curve ramps up really sharply at the fifth level.

If I had been able to watch other people play the game I probably would have been able to avoid the other big problem, which is that there’s no “Game Over” screen. I didn’t need it while I was testing, and I didn’t care what my score was, so I didn’t notice that it was missing. But having one turns out to be really important for the game. Adding it in was a simple 26-line change, and the post-comp version has it, but I feel that if I had other people test it during primary development the game would have ended up even better than it is now.

What Went Right

Processing

Processing was a great platform to work with. I had to implement my own collisions, but that wasn’t a problem since I already knew how. I was able to use a lot of programming tricks that are technically feasible anywhere, like adding easing to most of the movement, but Processing’s immediate feedback let me fine-tune to get the exact feel that I wanted. And feel is a huge part of a game like this. Processing.js was easy to get working once I figured out which PVector functions weren’t implemented yet–in fact, it was so easy that I switched to make the web version of the game the primary one for the competition release.

Scope

I gave myself permission to not do everything. That is, the game wasn’t going to be the best graphics, the best sound, the most innovative concept–I was going to focus on making a game, not starting a revolution. Minimalism turned out to help with that, since it let me make a game that is deliberately about the most basic expression of a core idea.

No Feature Creep

Speaking of which, minimalism gave me an excuse for avoiding feature creep. Every time I had an awesome idea for something that would be an awesome addition to the game, I could just say, “Nope. Minimalism,” and go on my way.

Source Code Control

I took a few minutes on Sunday to set up a git repository for the game. I never ended up needing it, but it let me experiment, knowing that there was always going to be a mostly-working version of the game that I could go back to. I can, right now, jump back to the compo-version or forward to the post-comp changes with no trouble at all. If you aren’t using source code control, take a few minutes to learn how. You won’t regret it.

Conclusions

Keeping yourself healthy is important, even during a crazy crunch situation like this. I made a point to sleep and eat–and that really helped when I needed the energy and concentration to learn a completely new thing three hours before the deadline.

Finally, the community is a big part of why I participate. I make a point of rating a bunch of games–nowhere near all of them, but as many as I can find the time to do. I’ve already incorporated some of the suggestions I’ve received into the post-comp version I’m working on. I try to leave feedback that will help make the games better and I encourage you to do the same.

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

It’s still clunky. oh well.

At least it works!

I’m using it to create the levels in the game right now.

I have some bezier curve thing and a WORKING EDITOR! Woop.

Collision works too.

Hoping to add, you know… gameplay. Have an idea though

I’m silent lately but ofcourse I’m IN! Also this will be April’s #1GAM entry.

When I find some time you will get the missing works on YouTube, Twitter and my site. Stay tuned!
Until then check out my works. You missed 8 games and the tutorials with them not to mention free code…  Enjoy!

Gear for this LD is Processing & Gimp as mostly was – still not promising sounds. No need for desktop photo as it’s about the same as last time and there is only an – irrelevant –  console development corner has been added.

See you in the compo!

I’m getting to grips with game development and lately jams like this have helped me to actually get stuff done.

I’m not yet sure what tools I’m going to use. I like Unity but it’s hard and I’m very slow with it. Construct 2 comes recommended so it is likely that I will take advantage of the ludum deal discount on that if the theme suits. For some themes I might find that I’d rather make something with Twine, or if I’m going to go super abstract and geometric then I’ll use Processing.

I’ve been following the theme voting with bated breath. Some of the leading themes I love and I’m really hoping I can make one of the game ideas I have for them!

I…guess I’m in. I’m not sure if I’ll have any time, but I’ve been wanting to do this since the day I heard it. First dare, first jam, first game. Yay milestones

… i hope. Oh well. Already have an idea slowly piecing itself together, hope I can pull it off. I have nothing better to do with it I suppose…

• code+ide: processing. booyeah!
• gfx: primitives like rect(), line(), and box(). gimp for emergencies.
• musics: assuming minim will work i’ll try b/sfxr for sfx and maybe CAUSTIC 2 for music. yay android apps!
• timelapse: maybe, just maybe a glapse. say please.
• os: #! linux. or without all the funny characters it’s crunchbang linux. lightweight & perfect for my
• computer: who knows how old? i get 100% cpu from a 500×500 window (but a nice frame rate )
• food: sandwiches, preferably peanut butter + cinnamon
• cats: two + laser pointer. are extremley cute & may be distraction.
• pickle: bermuda

what am i listing again? oh, compo stuff.

right. This is all very iffy now. I don’t even know if I’ll have a free weekend and I’ll probably forget the dare anyway. but IF I can remember it’s gonna be grrrrreat!

Hi LD25!

This time I don’t have any new hardware to learn and I’m not really interested in HTML5 games – right now – and I don’t want to mess with Angie – it would produce a lot of bugs and code mess. However in the last weeks I used Processing a lot so that will be my tool for sure.

code: Processing
gfx: Gimp2
sound: sfxr, musagi – never done any sound before though…

I’ll reuse code from my previous game GotEL if needed – not likely though. You can find it at StaticVoidGames.com.

I’ll certainly try to use my NES Framework  - for Processing – made during the CharityGameJam. Sadly no game was made based on it then but it developed more since so if you want then feel free to download the latest version here: YouTube video of it. Read the description for updates!

I wish lots of fun and plentygood experiences for the weekend!

p.s: My internet connection having problems in the past weeks and my PC does wierd things so I’ll may not be overly social during this jam.

My entry Darwin Award is mostly an infectious disease simulation with some population genetics thrown in.

If that description doesn’t sell a game, I don’t know what will.

A gameplay video perhaps?

Darwin Award gameplay video

Seems like the simulation part of my LD#24 entry is going ok.

LD#24 work in progress screenshot, darwin_award

Next up is working on the interaction part.  And sprite animations.  And background.  And music.

&c.

I heard twa thousand corbies making a game.

I began this compo with several hours of sleeping and thinking. But now I’ve reached my first milestone! There is not much to see here – I’m using placeholder graphics for today – but I pretty much got the player-character’s movement working.
In this game, mankind has screwed up their own evolution. The player controls a raven, feasting on the dying humans.

Oh, and by the way: I’m in too.

flap flap flap

Hi!

So this is the 4th time for me. I am excited but not like in previous attempts. I don’t have a new platform to learn during the LD so maybe I’ll concentrate on making a game this time…

I think I’ll go with Processing and use Gimp and sfxr as before. Today and tomorrow afternoon I’ll refresh my Processing knowledge maybe sleep an hour or two and jump in!

Good luck everyone, make lots of good ideas come to life!

Hello everyone,

I made a mini-game called “Switch”. It was meant to be for the MiniLD 36 with the theme Contrasts, but I was busy then and could not get to work on the game. I still wanted to make the game though and I finished it today in Processing (I love Processing; almost no “housekeeping” code).

How to play: Move the mouse so that the green ball only travels on the white areas. Click to swap black for white and vice versa. Press ‘r’ to reset the game. Try to finish the track!

Here is a link: http://switch.netai.net/

Nat —||—

My entry tr-3012 is primarily a musical instrument, a drum machine with five independent looping triggers identified by robots.

This time around I did a lot better at removing code that wasn’t necessary and dropping ideas I wouldn’t have time for. I had all of these digitized robot voices recorded that my five year old loved but which didn’t really make the game any better.

One thing I regret not having time to implement was an introductory zoom from outer space into the playing grid, to make it look like the robots were isolated and adrift in space. That would have helped fit the theme better.

The tools I used:

Processing
Piccolo2D
Piccolo2D library for Processing
Beads library for Processing
Garage Band
Animoog
Audacity
TAL-Dub-2 audio unit plugin
GIMP

I plan to add a few new features to tr-3012 later, to make it more useful as a musical instrument

– allow user-provided samples
– external MIDI sync, or at least set a tempo in BPM internally
– send MIDI and OSC events in place of/in addition to playing samples

The second day of the jam has been worse than I hoped, but better than I feared. I managed to tackle the performance issues we were having earlier by switching to the OpenGL renderer in Processing, which incidentally also fixed the huge memory leak.

So, here’s the first thing you’ll see when you load up the game:

Daniel created some really dope art today and I was happy to get it into the build along with some graphical effects like animated sprites and a scrolling background image.

Daniel’s friend Optomon also is writing us an awesome chiptune soundtrack. Here is the first part he sent over.

Here are some screenshots to show off what the game looks like now:

I ran into a ton of technical issues today but wound up working through them all. I finally finished defining all of the level geometry as arc segments, so you can run around the level and collide with the walls and ceiling too. I got basic bullets working, and they travel along an arc. The animation system was a doozie but it’s all working really nicely now. I learned more about OpenGL and it seems less daunting than before, and now I’m wishing I had more direct access to the OpenGL API from Processing!

Some things seem much easier and more efficient to implement in low-level OpenGL, such as my scrolling background. If I could have just accessed the texture directly and set GL_TEXTURE_WRAP_S to GL_REPEAT, it would have saved me a lot of trouble since I could have just animated the uv coordinates of the texture instead of having to move two images around. I spent nearly 3 hours trying to figure out how to set GL_REPEAT from within Processing before throwing my hands up.

It wasn’t a waste of time though, as I was able to apply what I learned to the animation system to flip a sprite horizontally by inverting the u coordinates and drawing them to a texture I defined manually in Processing. This saves on memory and disk footprint since I only need to load sprite assets facing one direction, and hopefully helps with performance as well.

Daniel and I both have work tomorrow, so we are going to have to submit the game as-is before the jam deadline. Right now there are no enemies and no win condition, but we plan to keep working on the game after Ludum Dare is over since the hard part (at least for me) is done. Now, on to the fun part, making it into an actual game!

We plan to submit this build before the jam deadline tomorrow evening, once we have some new music.

We’re currently 35 hours in and have some decent progress to show. I got a full player movement and collision system working using arcs to define platforms and walls. You can now run and jump around the level, and the ‘camera’ follows you.

Here’s a screenshot of what the game looks like now, complete with debugging info on collision arcs and background tiles:

I figured out a workaround to the issue I posted about earlier thanks to the help of some twitter buddies. Thank you also to everyone in the LD community who chimed in. I am splitting arcs that cross the polar axis into two arcs, and everything works fine so far. You can see the seam of the axis, i.e. 0 degrees, and the arcs that cross it have been split in twain.

I thought you all might be interested to see how we made this level and translated it into code, so here is a screenshot of that process in action:

Daniel designed a level on paper using a compass, and scanned it in so he could paint it in Photoshop. He then sent me the image, which I measured using a handy screen protractor (which doesn’t have a setting to measure angles clockwise, WTF!) and entered into the giant blob of setup code that is our one and only level. I worked out a function that adds a ring segment based on its start and stop angles and ‘valence’, i.e. what level it’s on. It figures out the maximum and minimum radius of each arc segment based on the even spacing that Daniel set up in his design. So that has sped up the process quite a bit. You could say that without it, the process of making levels would be too protracted. Ba-dum psshhhh.

Now, for some technical rambling…

I’ve been having some pretty disheartening performance issues in Processing.  It’s a prototyping tool that excels at real-time procedural graphics – it doesn’t do so well when you expect it to be blitting bitmaps to the screen at 30 FPS. As soon as I threw in some background art, the framerate dropped significantly. I tried reducing the size of the art and scaling it up in-engine but the exact same issue persisted. In a hail-mary attempt, I rolled back from the Processing 2 beta to Processing 1.5.1 so I could try the now-deprecated P2D renderer. And what do you know, it performed way better than the Processing 2 2D renderer, Java2D!

Unfortunately, since the level is laid out in polar coordinates, it’s a pain in the ass to line up raster graphics since they are all rectangles. Also, my jam partner Daniel requested that we use raster graphics so he can paint them in Photoshop.

What this amounts to, for a 1024 x 768 game like ours, is a level that is 6144 x 6144. And we can’t build platforms out of standard square tiles since the entire level is curved. So we split the image up into 1024 x 1024 slices and tiled them in-engine in the hopes that we might save on performance somewhat, since I can cull tiles if they are out of the camera’s view. This doesn’t seem to be helping a ton.

Also, the image loading needs some tuning. I was loading everything at runtime but the load time for the game was awful that way. So I switched to asynchronous loading on an as-needed basis, but now I’ve created a thundering herd, each thread requesting a 1024×1024 image from disk at once! And there are 18 of these during launch to load the images at and around the player. I think I’ll need to throw these image load requests into some sort of prioritized queue so I can throttle them. I also need to make the game update steps independent of framerate.

So overall, perf is in pretty bad shape now, and I’m apprehensive about what things will be like once we start adding animated sprites for the player and enemies. Also, it appears as if the P2D renderer may have a really bad memory leak, my swap file grew to 8 GB when I was testing the game! Bleaahhh…

I’d like to learn openFrameworks for my next game, maybe I can optimize the rendering better. There remains the option of me trying to implement my own renderer on top of Processing’s P3D (OpenGL) renderer but god knows if that will help at all.

There’s a ton of stuff to do tomorrow. i.e. turn this movement/art prototype into a game!

Good luck, and rest well, fellow jammers!

I’d appreciate some advice on whether my collison system can be salvaged or if I need to rewrite it.
My game is using polar coordinates and I am defining sections of arcs like so for the level geometry:

Right now I wrote checks to see if a point at polar coordinate (r, theta) is inside the region between the greater and lesser arc that makes up a solid object, like so:

class Arc {
  //Not a true arc, more of a segment of one or a "Block Arc", but it's much easier to type.
  float startAngle;
  float stopAngle;
  float maxRadius;
  float minRadius;
  //...
  boolean collidesWith(PolarCoord point) {
    return !( startAngle > point.t ||
              stopAngle < point.t ||
              minRadius > point.r ||
              maxRadius < point.r );
  }
  //...
}

(Full class is here.)

It appears my math doesn’t work out for arcs on certain intervals. Previously I had encountered issues with this code not working when a radian was less than 0 or greater than 2*pi, so I wrapped my radians between 0 and 2*pi which fixed it. But I need to define some arcs that start around, say, the radian equivalent of ~270 degrees and end at ~45 degrees, making the shape of the letter C and crossing the 0 degrees mark. This kind of arc breaks my collision check above.

So I’m thinking, I can either fix my math for the check somehow, or abandon this method completely. Unfortunately I can’t find many resources on how to do this type of collision check properly. I couldn’t even find what these arc segment shapes are actually called.

In addition, I’m seeing occasional tunneling issues and would like to switch to doing an arc segment + line segment test for continuous collision instead of just an arc/point test.

The alternative I thought of was to define my arcs based on a vector at the center and an angle, and use the dot product to the player to do my collison checks, similar to the FOV check described here.

But it will take time to do that and I’d rather salvage this code if possible. If anyone has any advice, please let me know.

My first Ludum Dare Compo was the previous one, LD #22. I had a good time and I learned a ton, and have used what I learned to make several physics-based games in Processing for various jams afterwards. However, I felt that my LD22 game suffered due to my poor art skills, so I decided I wanted to team up for the jam this time with a talented artist, for maximum awesome.

I’m working on a jam entry for LD #23 with my friend Daniel. He had an idea for a metroidvania where you traverse a rather small planetoid, where the curvature is actually visible.

We’re cutting the metroidvania part and trying to make a 2d action platformer set on a very small planet. The idea is that everything conforms to the planet’s curves, even your shots.

Here are some concept sketches of the planet and possible level designs that Daniel drew, along with some of my own drawings explaining how I will set up the collision volumes (using 2D arcs) and orient sprites.

I was pleased with how much progress I made on coding tonight, especially since I have never written anything like this before. I am using a generic template I made for writing games in Processing that I am calling QEngine. I will be publishing this game on the TinyWorld branch of the QEngine git repo.

As you can see from this screenshot, I have set up a class to define an arc section in code, and draw it for debugging purposes. These will be used as collision volumes, and I will draw a sprite in the same location. I couldn’t find what the real name of this sort of shape is, it’s a sort of wide arc, or arc with a circle segment removed from it. Microsoft calls them “block arcs” in their software but I couldn’t find any references to that being a widely used term.

I vaguely remembered reading about polar coordinates, and after looking them up again concluded that they would be a perfect way to store the position of objects in this game. It should be simple to move the player around and test for collision with arc segments if everything is stored in polar coordinates. And I even found some easy trig to convert to cartesian coordinates when needed (i.e. for drawing.) Here’s a screenshot of collision in action – the player (the white dot) is inside the upper left arc segment, which is why it’s red:

To move the player, I just add or subtract from his radial coordinate (vertical position) or angular coordinate (horizontal position). I love that math is providing such an elegant solution to what I thought might be  a pretty hairy problem! It’s times like this I’m glad I’m writing the game mostly from scratch in Processing since I have the flexibility to do stuff like this with ease.

There is one bug that I know of currently, I’m not accounting for the fact that there are multiple representations of a single angle in radians, so if you rotate the player past 360 degrees, the collision basically stops working. But I think this should be fixable if I can find a function to normalize the angle or whatever, if not I can always force it to wrap around with some custom logic.

Yay math! Yay game jams!

Here’s a hopeful sign-off for a productive day tomorrow. Good luck everyone!

I made this fairly simple game to familiarize myself with the new environment I’m using. It is a more constructive interpretation of classic Breakout: instead of destroying blocks, you create them. See how many blocks you can make before losing your ball or getting it stuck.
But there’s an alternative way of playing this: try to get the ball stuck deliberately, using as few blocks as possible.

It’s not doodle-based in any way, bit I’m submiting anyways. Maybe, on a more abstract level, you could consider the game itself a doodle… ah, nevermind.

Controls: mouse or arrow keys. Space or mousebutton resets.

Play it in your browser (source included)

Having been away and sick I didn’t get a chance to write this, but I’ll do so now(with a little over 24 hours to spare)

Let’s get started then. Not with the beginning, that’s what is expected, let’s go for a random order.

“A form of monotheism” a silly name, thought of in the last 30 minutes as a better-than-nothing name. It surprisingly works and fits the mechanics of the game. You’re an exterior force with equal control over everything in the game world. You can chose sides, be impartial, have some work for the benefit of others and so on.

The original idea was to have the player be some fellow that clones himself amd tweaks said clones to accomplish some end (repopulate the planet, fight off aliens/ zombies/ in-laws) but someone already  had that idea. Can’t remember who.

The second idea was to make a platformer and beat the theme into it with a stick. Since I forgot to make a platformer framework before the compo, I decided that’d take too long so I dropped it.

Back to square 1.

I wanted the player to start with one individual, and have the ability to spawn more and breed a populaton.  That took too long, so I ended up spawning a whole bunch right from the start.

Species and similarity

What you’ll notice is that creatures are divided into specias: humins, cats, rats, and llamas (the llamas were supposed to be centaurs but I gave up on that) . Each individual also has an empathy-o-meter/ similarity-rating, the color under them. The more you interact with an individual the more that changes. New creatures get one based on their parents.

Breeding and killing

Creatures of different genders and the same species will produce an offspring if they are similar enough AND one or both of them are assigned as breeders. This is mostly to avoid population floods encountered in early testing.

You might wonder why breeding and killing are in the same subcategory. Because they both depend on similarity. If two creatures are too dissimilar they’ll want each other dead(regardless of species). If you keep a similar population confined and breeding you’ll notice that eventually they’ll start killing each other to keep ‘strange’ ones away. Much like history isn’t it?

Social commentary much?

Yes. The only time when you can be sure things won’t be killing each other is when there is only one left. Hence alone. After I finished the game I was left disgusted. I unwillingly made a game about racist intolerant cartoony critters that strip the land of resources and kill eachother because the color under their feet is different. You know: like real people. The relative accuracy of my ‘simulation’ was even confirmed by someone who actually bothered studying these things.

Anyway

The good is working with processing and making html5. A lot easier than I thought.

The bad was not getting to add sound effects, which I knew how to do, and making a cheap hack to loop music. Uneven distribution of resources and a lot of other gameplay and balance tweaks.

The achievements: The end game, when you have a single individual left, a single species left, or one individual of each species. A total of 7. I don’t think anybody got any.

Want to give it a try? knock yourself out:

http://www.ludumdare.com/compo/ludum-dare-22/?action=rate&uid=5432

Hi!

In the middle of the bad things I’ve been through the weekend. I decided to keep my game simple and tought that I could make a game out of my work. I’m alone at the night every thay and keep telling Windows that he should work becouse he used to. But I have leaved out the programming and stuff like that and added the fun parts and some problems to solve and watch out for.

Basically you sit in front of the monitor and try to find a way out of randomly generated 2D mazes to get score. But you have 4 stats – awakeness, stress, hydatation and bladder – as well to watch out for. If they reach their limit than you loose – fall a sleep, going mad, get dehydratated or be in shame at work place. These stats can be easily controlled with a mouse click. You can make coffee to drink to stay awake or water to get hydrated and you can go to the toilet.

The problem is their effect on eachother. Becouse if stress go high, then you are getting tired quicker and start to see hallucinations that couse more stress. Bladder goes up from water and coffee too, but you need to drink to reduce stress and to avoid dehydratation. And while you can make more coffe, you can’t replenish the water resource.

Hallucinations are coming when you are doing your job, but gets more intensive when you go alone to the toilet or the make coffee. So watch out. The ghosts are building up your stress…

The game made entirely in Processing becouse I needed to learn it. So This was my first time I’ve wrote a line of code in it. Sadly other things have gotten in my way, so the game is about half finished. It need some features and some graphics. There isn’t even support in the code for sound – I’ll add it tough. But the main engine is working pretty well.

This concludes to myself that I’m f***ing awesome and have to work hard on things like game making. Instead of the DAQ programs for foundries and the likes…

Anyway have fun with it. The source is up with the release. Feel free to use it. To play the game, click on the first screen, use wasd to move in the mazes and try to go out at the bottom as many of then as you can. Click on the coffee or the water to drink. If you run out of coffee, then click on it once more to get another one. (This minigame isn’t working yet!) To go to the toilet, click on the Bladder stat. (This is a similar minigame and it’s in the state like the other with the coffee…) There are no scores, but I wanted to do it like “how many mazes in wath amount of time, but maybe there are more possibilities than this. I’ll consider them too.

Here is the entry: http://www.ludumdare.com/compo/ludum-dare-22/?action=preview&uid=5167 Try it out!