Loveapplegames are in again! Ludum Dare hasn't even started, and we made 3 games already... Can't stop us this time!
Check out our warmup games: Reflections, The Gnome, Ludum Dare: the game.
Our weapons of choice:
The WebGL library jgame.js
Possibly Wool for storyline and dialogues.
tinyspriteeditor for spriting
The Gimp, Inkscape, Evolvotron for graphics
jfxr, audacity for sounds
LMMS or Bosca Ceoil for music
Good luck and have fun everyone!
[EDIT] Thanks for all the well meaning comments on how to give feedback, but my point is that I would like to have known that this change was made.
I've rated 18 games, but noticed hardly anyone was rating my games back. Apparently my "Smart balance" score is not increased by rating games, but only by comment karma? Does anyone know what's going on? Is this a bug?
[EDIT] I am not on Twitter. Thanks the the commenters pointing it out, I just found the following on Twitter. Please Mike, put this in a sticky post on the LD site. Not everyone is on Twitter!
Remember Ludum Dare Rescue Rangers? I'm trying to bring it back!
Getting over 20 comments has been tough this time round, due to the need to have the game developers "like" your comments to get ranking score. The basic idea is good: have people try and write meaningful comments, instead of spending 30 seconds on a game and keying in some ratings. In practice, however, there are some problems.
First of all, the developers of the game have to like your comments. This is not going to work if the developers are out on vacation because they finished the rating process already. Since we're near the end of the rating period, a lot of developers are not checking their comments every day!
Please note: Occasionally, others will also like your comments. However, there is a quirk in the scoring calculation that will penalize the game that is rated when there are third party likes. A like on a comment is counted much like a comment, which means the game's score will go down dramatically if you like a bunch of its comments. Check the Github issue here. So please don't do it!
So, how do we find those games with active developers? The answer is, use my new search engine! You get a list of only the "active" games, sorted by score. Additionally you can also search by platform or keyword.
The search engine scrapes the data every hour. However, scraping comments takes 40 minutes, so to offload the system a bit, it scrapes only 1/4 of the games at a time, so refresh time for comments is 4 hours.
The search engine: http://tmtg.nl/ld46/
Here is a follow-up announcement for my own version of the good old Ludum Dare Rescue Rangers.
Getting over 20 comments has been tough this time round, due to the need to have the game developers "like" your comments to get ranking (smart balance) score. The basic idea is good: have people try and write meaningful comments, instead of spending 30 seconds on a game and putting in some ratings. As it is now, however, the quality of your comments is the least of your worries.
The developers of the game have to like your comments. This is not going to work if the developers are out on vacation because they finished the rating process already. Since we're near the end of the rating period, a lot of developers are not checking their comments every day! Only about 12% of the developers show "like" activity in the last 48 hours.
Please note: Occasionally, others will also like your comments. However, there is a quirk in the smart balance calculation that will penalize the game that is rated when there are third party likes. A like on a comment is counted much like a comment, which means the game's score will go down dramatically if you like a bunch of its comments. Check the Github issue here. So please don't do it!
So, how do we find those games with active developers? The answer is, use my new search engine! You get a list of only the "active" games (games that show "like" activity in the past 48 hours), sorted by smart balance. Additionally you can also search by platform or keyword.
The search engine scrapes scores and comments every hour. However, since scraping comments takes 40 minutes, it scrapes only 1/4 of the comments at a time, so refresh time for comments is 4 hours.
If you do not get new comments, but want your game to appear in this list, just un-like, then re-like an old comment. Your game should appear in the "active games" list within 4 hours.
The search engine: http://tmtg.nl/ld46/
Val and Boris from Loveapple Games present our latest game: Cyto Killer: Save our Cells! It is a realtime strategy game. We tried to base the game on actual cell biology, and each unit has a background story!
This was a very productive Ludum Dare for us. Beside the game, we did a Ludum Dare rating search engine and 3 warmup games: Reflections, The Gnome, and Ludum Dare: The Game.
This was the first time we did a realtime strategy / tower defense game, and we found it tough to actually turn it into a game with interesting strategic gameplay. But, as time progresses, and the game started taking shape, we became quite excited about the behaviour and dynamics of the different units and enemies, and we ended up creating 7 unit types and 4 enemy types. The game isn't quite balanced, in particular, player doesn't really get a lot of time time to learn how the different elements of the game work. All the levels are winnable though! We did put in a lot of interesting behaviours, and it seems a lot of people enjoyed the game, and some showed they completed it. Thanks everyone for your great feedback!
Our VIRUS is inspired by INFLUENZA 1918 (A/H1N1) aka SPANISH FLU, which killed up to 40 M people, outperforming WWI in deadliness. Some claim the death toll was even higher, some think the then recommended (over)dose of aspirin (newly off-patent in USA) as a treatment may have caused some deaths. We also considered Polio, Marburg and Influenza A Hong Kong viruses, but they are a bit complex for 14x14 sprites.
The tiny freshwater SNAIL represents the tropical disease SCHISTOSOMIAIS, aka BILHARZIA or SNAIL FEVER. The snail is not the pathogen but plays host to it (a parasitic flatworm SCHISTOSOMA, aka blood fluke - YUK!) for part of its lifecycle.
Our BACTERIUM started life (in LD46!) as a tapeworm-like intestinal parasite, but ended up as a bacterium that seems to be a crossover between bacillus (rod) and spririllum (spiral) forms. Let see what that mutates into....
SUPERBUGS (Level 5 upwards) are two rare new strains which are proving difficult to eradicate. SUPERBUG1 is a mutation of the distinctive orange rod baccillus salmonella typhi which has developed long yellow flaggelli. SUPERBUG2 is a novel parasitic form of P1V1 resembling Avian flu. Both are difficult to pin down directly but much has been learnt from examining the trails of destruction they leave in various channels.
MACROPHAGES attack invading bacteria by swallowing them up and killing them in an acid bath. Our MACROPHAGES look a bit like monocytes.
The MAC (Membrane Attack Complex) goes after invading bacteria and kills them by penetrating the bacterium's outer and inner membranes (it pops it like a balloon).
Our BACTERIOPHAGE is inspired by Enterobacteria phage Lambda (λ), a bacterial virus which infects the bacterial species Escherichia coli. E-coli - your fave kind of food poisoning!
APOPTOSIS (programmed cell death) is one of the immune system's mechanisms for zapping defective cells (eg pre-cancerous cells) and virus-infected cells. Kill your own cells to survive...
MARKER ANTIBODIES detect and point to pathogens such as bacteria, so that immune system destroyer cells can home in on them and go in for the kill. Marker antibodies grass up other cells - the body's very own snitches :)
https://www.youtube.com/watch?v=KzmW64nVnOk
Our tools of choice:
Evolvotron, Gimp, Inkscape for graphics
jfxr, Audacity for sound
Bosca Ceoil, Neural Composer, lmms for music
To start with, here are two warmup games:
The Labyrinth, made with Wool. This is a little warmup game we did within the LD47 time frame, so it actually has the "stuck in a loop" theme.
A second warmup game is Binary Squirrel, which was inspired by the Tree theme of One Hour Game Jam 282.
The Labyrinth was made with the Wool platform in about an hour. Wool includes a language and toolkit for creating interactive fiction and dialogue-based games. A game is subdivided into "nodes" which can be rooms or steps in a dialogue. The most basic Wool game offers a multiple choice style interface where each choice leads to a new node. Variables and other types of inputs are also supported.
The editor looks like this:
Small games can be exported directly with an URL that includes the encoded source code.
Source code for this game is supplied below!
``` title: Start tags: speaker: Narrator colorID: 2
LD47 warmup game made with Wool
Try to escape the labyrinth!
<> <>
title: Room11 tags: speaker: Narrator colorID: 0
You are in a labyrinth.
<> There is a hollow tree stump here, with a ladder going down. <> There is a dead tree here. <>
<>
[[Climb ladder|UnderTree]]
<>
<>
[[Cut down tree|Room11|<>]]
<>
<>
[[North|Room31]]
title: Room12 tags: speaker: Narrator colorID: 0
You are in a labyrinth.
There is a sign here. It says: "One P, Two O, Three L".
[[North|Room32]]
title: Room13 tags: speaker: Narrator colorID: 0
You are in a labyrinth.
[[North|Room33]]
title: Room21 tags: speaker: Narrator colorID: 0
You are in a labyrinth.
[[North|Room11]] [[South|Room31]] [[East|Room22]]
title: Room22 tags: speaker: Narrator colorID: 0
You are in a labyrinth.
[[East|Room23]] [[West|Room21]]
title: Room23 tags: speaker: Narrator colorID: 0
You are in a labyrinth.
There is a sign here. It says: "LOOP".
[[East|Room21]]
title: Room31 tags: speaker: Narrator colorID: 0
You are in a labyrinth.
[[North|Room21]]
title: Room32 tags: speaker: Narrator colorID: 0
You are in a labyrinth.
[[North|Room22]]
title: Room33 tags: speaker: Narrator colorID: 0
You are in a labyrinth.
<> There is an axe here.
[[Pick up axe|Room33|<>]] <>
title: UnderTree tags: speaker: Guard colorID: 1
You found the exit under the tree! But you are not finished yet. Tell me the pass code to continue!
[[I don't have the pass code|Room11]]
[[The code is: <>|UnderTreePasscode]]
=== title: UnderTreePasscode tags: speaker: Guard colorID: 1
<> That is correct! You may pass. [[Pass|Finished]] <> Wrong code! [[Try again|UnderTree]]
title: Finished tags: speaker: Narrator colorID: 2
```
Our entry: Bioluminescence. In the deep ocean, the only light source is bioluminescence. Chase the bioluminescent jellyfish around the screen to uncover the hidden fish!
This time round, I worked on another project, but I managed to create this game in the last 4 hours before the deadline.
The game uses a kind of flocking / Boids algorithm. The jellyfish move away from the mouse, but they also keep a minimum distance from each other, and move towards a certain point. The result is something quite pretty and organic looking!
Tools I may use:
LMMS
Gimp
Inkscape
As a warming up exercise, I created a "wizard" style dialogue that guides you through game development, if you are a beginner. It explains in a fun way how I develop games. It contains links to some of the tools I use myself, so it's sort of an alternative "I'm in" post as well.
It's made with the Wool system, a system for creating dialogues, interactive fiction, serious games, etc. which allows you to quickly whip up a game prototype.
Start the game development wizard!
Will be participating in the 48 hour compo this time.
Oh, the theme... I did "10 seconds" back in 2013. Maybe I should make a game themed "every 9 years ... history repeats itself". But I feel like doing 10 second minigames right now.
Tools: - jgame.js (https://github.com/borisvanschooten/jgame.js) - tinyspriteeditor (https://github.com/borisvanschooten/tinyspriteeditor) - gimp - audacity - jsfxr (https://sfxr.me/) - LMMS (if I get round to music)
Good luck everyone!
I've participated in many LDs, but this time round I made it really hard for myself! My goal was to create an AI and put it in a browser game. I decided on a generative AI that generates pixel art, because I am really interested in image generation. Being a total noob to Python and Pytorch, I had an insane weekend, and barely managed to publish something functional.
But is was a start. After another week of hard work, I actually managed to get a good result! I now have a neural network that reliably creates potion sprites.
I had to fix a lot of things before it worked well. I changed the approach, from GAN to denoising autoencoder, to denoising in latent space; I had to work around bugs and issues in Torch model export and ONNX; I spent a lot of time digging deeper into Pytorch and trying different things.
I started with a messy 16x16 pixel art dataset, created on day 1, which I cleaned and reduced to 8x8 to make it more tractable. When I finally got it to reproduce the sprites reliably, I realised that the sprites are not similar enough for generalization or creative variations. So I needed a dataset with a lot of similar sprites. I ended up using a hand-coded sprite generator to generate a dataset of 1024 12x12 potion sprites. The neural network managed to replicate these potions quite reliably, demonstrating that it can replicate the algorithm from just examples.
The original generation algorithm
After two weeks of hard work... finally, a nice result! This Ludum Dare, my ambition was to create a browser game with my own embedded AI based pixel art generation. Being a total noob in Python, Pytorch and deep learning, I did not manage to create an actual game, but I was proud of myself that I did produce a half-functional tech demo running my homemade AI in the browser.
After a lot of experimentation in Pytorch with different datasets, I managed to create a useful tool for generating animated game characters. It's based on a 5-layer denoising autoencoder with noise added to the latent space, a sort of poor man's variational encoder. I started with 376 8x8 pixel art characters, obtained from freely available internet sources. It was hard to find a large enough dataset. Some images were distorted with jpeg noise. I wrote a segmenter that cuts sprites out of sprite sheets and scale them to 1x1, reconstructing the original colours as well as possible.
Pixel art is prone to overfitting, and I could get the neural net to perfectly recall all items in the data set. However, the goal is not to literally reproduce, but to interpolate. I removed a lot of oddball characters to arrive at a dataset with 166 humanoids, all with two eyes, hands, legs, etc. I shrunk the latent space to 3 values. The resulting neural net actually interpolates meaningfully between data points.
The result: http://tmtg.nl/ludumdare/ld53-charactergen/
Check out my other experiments on my game page:
https://ldjam.com/events/ludum-dare/53/i-dream-of-pixel-art-ai-game
Does anyone remember the animated sprite generator I wrote almost 10 years ago?
http://tmtg.nl/ludumdare/spritegen/
It's based on mirrored random pixels, and used the same animation technique as my AI sprite generator. The Java code is a bit outdated now, so I thought I might as well re-implement it in my new tool. I improved a lot on the original, with nicer colour schemes and more animations. I also fixed a bug in the animation code, so the walking characters should also look better. So now you can create both walking characters and other kinds of sprites in 8x8. There is also a 10x10 version, like the original Java generator. However I think at 10x10 the sprites look a little too random.
Use the selection dropdown at the top right to select the type of sprite to generate.
http://tmtg.nl/ludumdare/ld53-charactergen/
Last time I wanted to do something with AI. After three weeks I came up with an animated pixel art character generator. Remember that one?
This time I want to try and include a trainable AI in the browser!
A shoutout: anyone else going to use AI in their project? Tell me in the comments :smiley:
Tools: - jgame.js (https://github.com/borisvanschooten/jgame.js) - tinyspriteeditor (https://github.com/borisvanschooten/tinyspriteeditor) - animated character generator (http://tmtg.nl/ludumdare/ld53-charactergen/) - gimp - audacity - jsfxr (https://sfxr.me/) - LMMS (if I get round to music) - Pytorch and tensorflow.js
Good luck everyone!
Only 12 hours left in the rating period! For anyone interested in AI and neural networks, I present Brainspace, a game where you design a neural network with drag & drop to solve particular classification problems. Just so you get an idea what it looks like, below is a neural network design that solves the first problem:
I managed to make a reasonable looking game in 48 hours, with help of existing libraries, in particular Tensorflow.js and Baklava.js. I am impressed with how easy to use the libraries are. I didn't get much time to balance the game though. At first I thought, this must be one of the hardest gamest to balance! But while playing it, I myself learned a thing or two about neural network design, and in spite of the limited variation of classification problems, it was a great learning experience.
I plan to make this into a tool for education and experimentation, and want to include visualisation features: what the tensors look like, and visualisation of the neural weights and intermediate data.
Play the game here: https://ldjam.com/events/ludum-dare/54/brainspace
Below is a solution that solves all problems. It's a bit overcomplicated, showing off branching and merging. It can be done with a simpler network.
Like last time, I want to do something with deep learning. Not sure what though. Maybe learning enemies, or something generated by a homemade AI (like last time ...). Given the theme, maybe the game should involve creating and training AI minions, or perhaps summoning should be based on AI prompts. Tools I might use:
Last night I got my new AI rig up and running, just in time for LD. It's an 7 year old PC with an RTX4060 16G. It seems to perform surprisingly well. It can run sdxl at about 2.5 iterations per second. It may come in handy this weekend!
Houston, we have a problem! We have sighted yet another astronaut on a horse!
In this game, your goal is to train a neural net to copy your gameplay behaviour. The game is a simple pick up the coins and avoid the enemies game, to keep things simple. The neural net determines which move to do by looking at a 9x9 area around the player. Its output is what move to make: up, down, left, or right. Every time you make a move, a datapoint is added to the training set. Once you think you have enough data, you can summon a replica and see how well it plays.
I wasn't sure this was going to work at all, so I concentrated on making the neural net work. With a few major bugfixes and tweaks, it ran reasonably well. It isn't too difficult to create a replica that completes most levels. The biggest problem is when it keep running around in circles. Usually this can be remedied with more data, sometimes it's best to clear the dataset and start again. You can also try making the replica misbehave, for example by deliberately ramming enemies.
Context area around the player is shown in red.
This is definitely an experimental game. It's rather simple and could use some polish. Sometimes it generates levels where you have to ram enemies to get all the coins. Movement can be a little odd, because you always move from one tile to another. The neural net is limited, because it has to be simple enough train in the browser without long wait times. Nevertheless, I definitely consider this a success, because the replica works well with so little data. The result could be used to create all sorts of interesting variations. For example (and this includes suggestions made by raters, thank you so much for the feedback):
In again! Tools I might use:
A little plug for my animated character generator: here are some sprites generated with it.
Cellspace is a cellular automata based rule system that can be used to create games. I developed it some time ago. My goal for LD56 is to start on a graphical user interface for Cellspace. I tried to "gamify" it by defining some levels you can play around with by defining rules. There are no clear goals, though some levels suggest concrete goals.
I want to develop this into a full fledged graphical IDE in which you can make your own games. This would require at least a level editor and win/lose conditions. Note that it is already possible to control rules using the W,S,A,D keys, using the "playerdir" option.
Cellspace is based on the classical 3x3 cellular automata, but is more complicated, because the output of a cell rule is not just the center cell, but can be any of the cells in the 3x3 grid. This extra complexity makes it possible to specify various games, including a full implementation of Boulderdash. The system handles complex cases meaningfully, such as blocking rules that have output that overlaps with a rule that is already applied, handling competing rules, and randomizing rule execution order to avoid bias. Also, it tries to animate moving sprites smoothly.
Here are some examples of nice looking rule systems.
Example 1: different animated cells
At the bottom left are moving cell colonies (cyan) that propagate and die with random probability. This can be described with two rules:
rule5 indicates propagating the colony to a neighbouring spot with probability 0.33, while rule6 indicates dieoff with probability 0.2 when a colony already has a neighbouring cell. With the rot4 option, the rules are rotated in all directions, creating four competing rules that are randomly selected, resulting in random propagation in all directions.
At the bottom right are "pacman" (red) cells that move around and propagate randomly. This can be described with two rules:
rule_0 indicates that the "@" (pacman) should move right when there is an empty spot there. Again the rot4 option rotates the rule in all directions. Note there is also an outdir "R" defined, which sets the direction of the new "@" to the right. This means the sprite will face right.
rule_1 again indicates that the "@" should propagate with low probability, that is, create a new "@" in an empty spot without removing the old one.
At the top left are moving cells (blue) that leave trails behind (green). They prefer open space over already laid trails, so that they try to explore new areas. This can be described with 3 rules:
rule_2 indicates that an "o" (the blue circle) should move left when there's an empty space ("-"), and should leave a trail behind (":"). With the rot4 option, rule is rotated in all directions, resulting in four competing rules that are randomly selected, resulting in random movement.
rule_3 indicates the "o" moving across an already laid trail, but this rule has lower priority (1 instead of 2).
rule_4 indicates that the "o" should spawn (create a new "o" without removing the old one), when there is an empty spot, again with low (1 in 10) probability.
The self-generating maze (yellow Xes) in the middle can be specified with a single rule, given in the next example.
Example 2: Harvey Wallbangers in a self generating maze
Harvey Wallbanger is a robot that can find the exit of any labyrinth (= maze without loops) by just following the leftmost wall.
The Harveys (cyan) are controlled by the following rules:
Rule_3 generates the maze, the other rules govern the Harvey Wallbanger movements. Note it keeps track of the center cell direction via conddir, which specifies that the center cell should face in that direction.
Example 3: self eating maze
The following rules specify the self-eating walls:
