Here’s a preliminary picture of my game. I think I will name it “Split em Up”:

The progress is going very slowly, and the game is still far from playable… I will probably not be able to include stuff like a decent title screen or sound. But well, who knows.

A few 70s kids arrived at your doorstep. What can you do to make them go away?

Hello again! This weekend I’ll be taking part of Ludum Dare for the second time.

I’ll be participating from my friend heloheu‘s house and we’ll probably order some delicious broccoli pizza while we work in our games.

These are the tools I plan on using:

• Processing for programming
• iNudge and Audacity for BGM
• bfxr for sound effects
• Photoshop or Illustrator for graphics
• Tiled for level design, if any.

It’s pretty much the same thing from last time, though I hope this time I’ll make something playable in a browser

Depending on the game genre, I might use this code for tilemap collision (based on this tutorial by Emanuele Feronato. Sorry for the messy code, some variable/function names are in Portuguese =P)

class Objeto { //class for sidescroller objects
float x, y;
float xspeed, yspeed, vm, g;
boolean caindo = true, walkanim=true;
boolean sobreAlgo;
int sizex, sizey;
float jHeight;
int top, bottom, left, right, centerH, centerV, top_left, top_right, center_left, center_right, bottom_left, bottom_right, center_center, prev_bottom;
boolean climbing;
void fall() {
y+=yspeed;
yspeed+=g;
if (yspeed>vm) yspeed=vm;
}
void start() {
}
void jump(float H) {
caindo = true;
yspeed=-pow(2*g*H, 0.5);
if (hero.direita==true) poeira.cria(hero.x, hero.y-5);
else poeira.cria(hero.x+hero.sizex, hero.y-5);
y–;
}
void update() {
}
void draw() {
}

void getBounds() {
top=floor((y-sizey)/tsize);
centerV=floor((y-sizey/2)/tsize);
bottom=floor(y/tsize);
left=floor(x/tsize);
centerH=floor((x+sizex/2)/tsize);
right=floor((x+sizex)/tsize);

if (left<0)left=0;
if (left>w-1)left=w-1;

if (centerH<0)centerH=0;
if (centerH>w-1)centerH=w-1;

if (right<0)right=0;
if (right>w-1)right=w-1;

if (top<0) top=0;
if (top>h-1) top=h-1;

if (centerV<0) centerV=0;
if (centerV>h-1) centerV=h-1;

if (bottom<0) bottom=0;
if (bottom>h-1) bottom=h-1;
top_left=left+w*top;
top_right=right+w*top;
center_left=left+w*centerV;
center_right=right+w*centerV;
bottom_left=left+w*bottom;
bottom_right=right+w*bottom;
center_center=centerH+w*centerV;
}

void colide() {
getBounds();
//pes
if (yspeed>0) {
if (solido(bottom_left)==true || solido(bottom_right)==true) {
caindo = false;
yspeed = 0;
y = bottom*tsize-1;
}

else if (prev_bottom<bottom && (solidoTransponivel(bottom_left)==true || solidoTransponivel(bottom_right)==true)) {
caindo = false;
yspeed = 0;
y = bottom*tsize-1;
}
}
//cabeca
else if (yspeed<0) {
if (solido(top_right)==true || solido(top_left)==true) {
yspeed = -yspeed*0.1;
y = (top+1)*tsize+sizey;
}
}

x+=xspeed;
getBounds();

//esq
if (xspeed<0) {
if (solido(top_left)==true || solido(center_left)==true || solido(bottom_left)==true) {
x = (left+1)*tsize;
xspeed=0;
}
}
//dir
else if (xspeed>0) {
if (solido(top_right)==true || solido(center_right)==true || solido(bottom_right)==true) {
x = (right)*tsize-sizex-1;
xspeed=0;
}
}
prev_bottom=bottom;
}

void sobreAlgo() {
sobreAlgo=false;
for (int i =0;i<=(sizex/16);i++) {
if (solido(floor((x+i)/tsize)+w*floor((y+1)/tsize))==true || solidoTransponivel(floor((x+i)/tsize)+w*floor((y+1)/tsize))==true) {
sobreAlgo=true;
}
}
if (solido(floor((x+sizex)/tsize)+w*floor((y+1)/tsize))==true || solidoTransponivel(floor((x+sizex)/tsize)+w*floor((y+1)/tsize))==true) {
sobreAlgo=true;
}
if (sobreAlgo==false && climbing==false) caindo=true;
}

boolean solido(int A) {
boolean solido=false;
if (tile[A]%tsw>sol) solido=true;
return(solido);
}

boolean dentro() {
boolean D = false;
if (x<w*tsize && y<h*tsize) D= true;
return (D);
}
}

And also my .tmx loader, for Tiled files:

class Stage {
PApplet p;
XMLElement xml;
Stage (PApplet parent, int N) {
p = parent;
xml = new XMLElement(p, “stage/”+N+”.tmx”);
}
void load() {
XMLElement mapa;
mapa=xml.getChild(“layer”).getChild(“data”);
int n = mapa.getChildCount();
for (int i = 0; i < n; i++) {
XMLElement kid = mapa.getChild(i);
tile[i] = byte(kid.getInt(“gid”)-1);
}
w = int(xml.getInt(“width”));
h = int(xml.getInt(“height”));
}

void loadObjects () {
//for (int i = 0; i<objeto.length; i++) objeto[i]=new Enemy1(-10000, -10000);
XMLElement obj;
obj=xml.getChild(“objectgroup”);
if (obj!=null) {
int n = obj.getChildCount();
String objectType;
for (int i = 0; i < n; i++) {
XMLElement kid = obj.getChild(i);
objectType =kid.getString(“type”);
//if (objectType.equals(“Enemy1″)) objeto[i]=new Enemy1(kid.getInt(“x”)/tsize, kid.getInt(“y”)/tsize);
}
}
}
}

Well, good luck everyone!

The game I made for LD23, Recluse, got a prize at last weekend’s SBGames (Brazilian Symposium on Computer Games and Digital Entertainment) 2012! I believe it’s currently the biggest national prize for indie game developers, so it’s kind of big deal and I felt I should share this information with the LD community.

These were the results of the Indie Games Festival of SBGames 2012:

Best game developed by student:

• 1st – Recluse
• 2nd – Save the King
• 3rd – Kane

Best use of technology:

PC/Web

• 1st – Qasir al-Wasat: A Night in-Between
• 2nd –  Jelly Escape
• 3rd – Recluse

Game Design:

PC/Web

• 1st – Save the King
• 2nd – Mr. Bree – Returning Home
• 3rd – Recluse

Congrats for the winners of other categories, too!

I was certainly not expecting such an awesome result, but it’s good to know people are enjoying the game – Though I really need to put some work on other projects! >_>I’ll probably take part of LD25, I hope something nice will come out of it.

For those who still haven’t played Recluse (or haven’t played the enhanced version) check out the entry page!

It’s been a while! Back in the judging period of LD23, I promised I would make a post-compo version of Recluse – one with sound and bug fixes – but I was too busy with college back then. Well, I finally manged to work on the game, and here it is!

You can download the new version in the entry page – in the same links as usual. (I’ve included the original compo versions inside the RAR files, so that shouldn’t be a problem)

To make up for the long time without any update, I also decided to include a whole new game mode for those who are bad enough dudes to find all secret collectibles in the game. This should be enough reason for people who have already played Recluse to download it again, and in case you still haven’t, this is also a great opportunity to try it out for the first time.

Changes in the new game:

• Sound.
• A new game mode, activated when you collect all secrets and finish the game.
• Adjustments on the difficulty and controls.
• Some new animations where it was needed.
• 4 hidden collectibles instead or 3.
• Bug fixes.

Unfortunately, the screen flashing (which is not intentional) was the only bug that couldn’t be solved. On the other hand, I managed to change the color of those flashes from white to purple, which made them less intense.

Well, I hope you enjoy it!

(Thanks Lumi Mae for the picture!)

I couldn’t believe my eyes when I saw it, but Recluse got 8th place in the competition alongside with Astro Break and also 1st place in the innovation category!

I already wrote everything I could want to say right now in my “thank you” post, so if you still haven’t, please read it. (copying and pasting everything here would be too cheap, even cheaper than pasting a link to the original post =P)

I also can’t stress enough how much I am grateful to my friends in Brazil who gave me support. I hope they are reading this!

I wasn’t expecting getting such high rankings, especially in overall… So once again,

• Thanks a lot for playing and rating Recluse.
• Congratulations for everyone.
• I hope you all had fun!

Hey y’all! It’s already been almost 3 weeks since we all finished working on our games… And even though the 48-hour marathon, which was the reason why I took part of this, was immensely fun and satisfying, I can’t help but say I these 21 days have been even more enjoyable than the competition itself. Waking up to see new comments on my page made me smile every day. I was already happy enough to make a playable game all by myself in 48 hours, but this was my first LD and I had no expectations that the community would be so nice and had no idea that so many people actively rated and commented on each others games. So reading everyone’s nice comments and finding my game in other people’s recommendation lists made me feel it was all more than worth it.

Even though Ludum Dare is a competition, I can’t think of a better prize than knowing that other people enjoyed the experience your game created. I believe the real “winning” here is feeling satisfied with your final product, and of course, knowing that your game achieved what it intended to. My game has a lot flaws and there’s always improvement to be done, but I can say with confidence that, in the end, the overall experience from these 23 days was very fulfilling. So congratulations for everyone who achieved this, and in case there are people who haven’t, I hope it becomes motivation for taking part of more and more LDs!

Something that also made this 3-week experience incredible was getting to play other people’s games, which I enjoyed a lot. There are a lot of delightful surprises and a huge variety of good ideas around. It doesn’t matter how many times I look, I always find some new pearls, and knowing that there are so many people with creative ideas out there is always good and inspiring. Even though I already wrote a review post, a few games that I played very recently instantly became some of my favorites, such as SubAtomic (which was funny as hell), Planet ZOOB (highly addictive) and Tinytanic (whose humor and shifting mood I loved).

Anyway, I’d like to thank once again everyone who played my game and left a comment on my page, and to tell everyone from the LD community that you are awesome. Seriously. I’m still amazed at how friendly everyone is and how genuinely helpful and caring the participants are toward each other. Some competitors have helped me out and I also feel like I’ve helped a few people.

I will also take this occasion to let you know I decided to start using twitter (@BiggerBoo) so if I’ll post there any updates on Recluse and other games I’m working on, so keep tuned. To take a look at other projects, check out the indie group I’m part of, Catavento. (@catavento_games). Like many other participants here, I’m from a country with a relatively underdeveloped game industry and having your support means a lot to us.

Also, if you still haven’t played and rated my game, Recluse, please check it out – there’s still time! The post-compo version should be released soon, so please stick around!

Thanks for reading and good luck, everyone!

I don’t think I’ll be able to play many more games until the judging period ends, so I guess I can already post a few of my favorite ones, since I know that posting this kind of list helps some people (like me) a lot.

I decided to divide them into categories in case people are looking for something specific, but most of these games could easily win at other categories as well, other than the ones in which I’ve included them. Some of them received quite a lot of attention already, and some still haven’t, but certainly deserve yours. You should definitely check them all out.

Innovation

T in Y World by Tom 7 – I can’t really describe this without making it sound like a very confusing game. Perhaps it’s because it is one, indeed. But it’s also a very unique concept. Be sure to play it!

Fracuum by TylerGlaiel – A very simple and short game but with an amazing core mechanic. One of the best entries I’ve played so far.

Soul Searchin’ by MaximSchoemaker – It’s a different take on the same mechanic as Fracuum, with some narrative involved. I personally prefer this one because of the overall mood and humor, but the graphics are not polished like the above game.

Atom Planet by NMcCoy – Very fun concept, though it would be better if it wasn’t so hard to find out what you have to do.

Stellar Nurse by Bleck’s team – Feels like a completed game because it’s very well-polished, but it still needs some balancing on the pace. The game’s name is awesome too.

Fun

Planet 161 by Saint11 – Lots of well-thought puzzles, will leave you wanting more. Not to mention it’s also amazingly well-polished.

Astro Break by hulahulahest – This could have easily been a real Golden Age arcade game.

This Precious Land - Ishisoft – Even though it’s very similar to Triple Town, it has some unique mechanics which make it almost as addictive as Spry Fox’s hit.

Tiny Shards by Gabriel’s team – Best story I’ve seen in a jam/compo entry. The game itself is very hard but feels like a completed work.

MakHappy by JosephGribbin – Very simple and short but enjoyable. The dialogues made me laugh a lot.

Predicament by Orangepascal – Short adventure that takes place in a single room. Finding out what to do is fun and satisfying.

Graphics

Planet Trot by Logan – Best graphics in the competition! Too bad the gameplay needs more work…

Nook by PoV’s team – A lovely short platformer with very professional-looking graphics.

Apocalypse Inc. by mooosh – Creative, memorable art style. The game is quite fun too, if you like pressure =P

Inside my Radio by TurboDindon – A lot of polish in this one. It’s also a fun synesthesic experience, though frustrating at some times.

Little Biyubi by edbadiux’s team – Makes me want to make a game with those looks. Reminds me of the 3D Link’s Awakening project by MithosKuu.

Hamster Bowling by tfendall – Very well-done visuals for a jam game. Play it until the end!

Mood

There is a Picture by MortisGhost’s team – Although I didn’t quite get the ending, the Earthbound-like mood and the abstract graphics made this game one of my favorites.

Obsolescence by quickfingers – Probably the most meaningful game I’ve seen so far, the message is very strong and the graphics are beautiful. Too bad it gets boring quite soon, though.

Memento XII by deepnight – One of the most well-finished games I’ve seen so far, the plot is quite interesting for a short game.

Asylum by Orni – A very involving short narrative, which amazingly has a very strong mood despite the fact that it has no sound.

Hey guys!

After reading demonpants’ post, I worked overnight to make mac and linux-compatible versions of my game! Fortunately it wasn’t so hard to find out what bug was crashing the game in those systems and now it should run with no problems. Sorry to keep you waiting!

These versions also try to correct the white flash bug, but I still found no solution for that. The game now flashes purple instead of white, which is less hard on the eyes, but still is an undesirable effect.

Thanks for reading and have fun!

In this post, I will share with you guys some details about the game’s development and my final thoughts on the project. It ended up becoming quite a long text, but at least it’s good to have the process documented before I forget how it went. Please skip to the final parts if you want to see a summarized list of what went right and what went wrong. There is also a timelapse video featuring everything I mention here, in case you’re interested.

First of all, I need to say this was my first Ludum Dare and the experience was very enjoyable. I had already taken part of 2 game jams in the past, so I had a slight idea of what 48 hours meant in terms of development, and had already worked on game projects of my own, though I hardly ever finish them. I am a designer and I don’t know any programming language besides Processing, which I feel very comfortable to use (the reason why I chose to work with it instead of Scirra Construct, which was also an option). Since I knew there was a chance I’d make a platformer game, I decided to announce before the competition started that I would probably use some classes from one of my old games.

Second, I live in Brazil, so the competition started on Friday, at 10:00PM for me. Take that in mind when reading the time marks!

And last, I strongly suggest that you play the game before reading this, because I’d like everyone who plays it to have the experience of finding out what they have to do on their own. In other words, this post will contain SPOILERS.

Tools used

Language: Processing (java)
Map editor: Tiled
Graphics: Photoshop
Sound: Intended to use Bfxr and Famitracker, but ended up not having time to implement.

Development summary

Brainstorming and research (Fri, 10:10PM to Fri, 11:00PM)

I admit I was really lucky that the game idea came so quickly and naturally, unlike my other experiences in jams (according to my timelapse video, which I will post here later, I had the window resizing idea in the first 4 minutes of competition). For those who haven’t played it, my game’s core mechanic is that the character can expand the game world by literally pushing the limits of the application window. At first I was kind of disappointed by the unveiling of the theme, since “Tiny World” wasn’t one of my favorite finalists, but went straight to brainstorming right away. I basically first thought of the theme “tiny world” as a person’s private world, and then thought about social reclusion, which led me to the hikikomori (social recluse) cases in Japan. A long time ago, in a “Peter Molydeux”-like vibe, I had already imagined how cool it would be if the game window position was part of the mechanics, but never really thought of how would a game like that be. When I started imagining a game set inside a hikikomori bedroom, the idea of finding a way out in the least likely way came to my mind, and pushing the limits of the screen was one of the first things I thought of.

The first thing I did then was transforming the time limit I had stablished for the brainstorm (2 hours) in a time limit for a research phase in which I would check on the internet if it was possible to make window resizing using Processing or not. And if not, go back to brainstorming. After a successful test of window resizing, I decided to stick with the idea.

Still during this research phase, I found an interesting chart for web developers showing the most common screen resolutions, and decided that in the game window shouldn’t pass 1024×600 pixels (which is the window size at the final moments of the final game). Though the game wouldn’t be accessible by netbook users, it was guaranteed that more than 80% of users would be able to play, and this number should be even bigger if you only consider only the gaming community. The good thing is that, due to that screen size limit, I had no option but to make a short game. In other words, what was fortunate about the window size mechanic choice was that it solved two problems at the same time: It was not just a charming core-mechanic, but also a way of restraining me from taking too much time to make an unnecessarily long level design. When I had all the information I needed, which happened way earlier than I had planned, I started development properly speaking.

Early Development (Fri, 11:00PM to Sat, 12:40PM)

Throughout the 48 hours I kept an open all-purpose txt file that somehow served as a game design document. This text file was not very well-organized, but I don’t think they need to be when we’re talking about quick one-man projects. It contained:

• Important notes and numbers (like the starting and final screen sizes);
• A checklist of what I had to do, in order of importance (THIS WAS VERY IMPORTANT);
• All ideas for gameplay and story that came to my mind;
• Urgent matters (either big concept flaws that I couldn’t forget that existed, like “how does the player find out that he has to push the window limits?” or things I had to ask friends, like “can this bug be even fixed?”);
• Ideas for the game’s name.

At the start of the development, I could only make the window grow to the right or down, because of how java’s frame.resize() method worked. This led me to start drafting a stage where the starting room was located on the top-left corner of the map instead of the center, so I could try to visualize the gameplay and imagine what mechanics would have been neat. Due to the expanding and continuous nature of the map, I thought metroidvania-style elements like non-linear exploration and gradual acquirement of new actions would fit well, so I also starting writing down a few a actions that could help unveiling new parts of the map (ground pound, double jump, jet pack, etc).

First draft for the game world, with the starting room in the corner

Back then, I had already started working on an preliminary sketches for the main character’s sprite, and for technical reasons, I decided to turn the neckbearded human hikikomori into a snail, which would be easier to draw and animate, and fit the “recluse” and “tiny world” themes. As a result, I found it would be cool if the game world was actually the inside that snail’s shell. The problem was that, with the first room located on the top-left corner, I found it was a huge loss for the game’s concept that I wouldn’t be able to make a helix-based level design starting from the center. At this moment, I started losing my interest in the project, because in my head, the game experience would be way better if I could make the game area grow towards all 4 directions. On top of that, the constant window resizing would result on the player constantly having to move the window around using the mouse, which didn’t sound much desirable to me.

After insisting a little bit more on finding a solution for that, I finally found a way of forcing a window to be positioned always in the center of the screen, and that also made it possible for the window to expand to the left and upwards. On the other hand, by this time I realized there would be a huge chance that the mechanic wouldn’t work on other OS’s besides Windows, due how different OS’s might deal with window sizes. Either way, I decided to take the risk.

Up until this moment I had only worked on programming the basic mechanics and was kind of frustrated that it had taken so much time, after all, 1/4 of the competition had already passed and I still had no idea of what the map would look like and had hardly any piece of artwork. But I sent the first working prototype for a few friends to test, and their reaction to the window-resizing mechanic was so positive that from this point I started feeling motivated again, and worked more seriously on the project from this point.

Development: Game design (Sat, 12:41 PM, Sat, 8:30 PM)

With the level design back to being a spiraling maze of reclusion (wow, I liked the sound of that!), I decided for a while removing the metroidvania influences and making a 100% linear gameplay centered on simple platform jumping and enemy avoiding. Something like a snail-speed super meat boy with checkpoints and a good variety of hazards. That’s because I thought that it wouldn’t make sense to make a short, single screen game with metroidvania characteristics, since there would be not enough space to do backtracking, and the experience would be too short for the player to acquire items and new significant actions that changed gameplay.

The ideas I had for the game so far were the following:

• Starts off in a room with videogames, stacked pizza boxes and a computer.
• The character would ocasionally say things like “let’s see what’s on TV”, “I feel like playing videogames” or “I wonder what’s for dinner”, through a speech bubble.
• The player can interact with all those objects using the “down” key, which makes the snail use them or talk about the object.
• This misguides the player, who thinks he’s playing an adventure game. But this game is quite boring since it feels pointless.
• Only when the player tries leaving the room through pushing the window border away, the game suddenly transforms into an action platformer.
• From this point on, there would be 2 or more enemy types and other environmental hazards, like spikes and springs.

Thus reinforcing the concept of escaping from a monotonous recluse life.

After talking to a friend, though, I got the feedback that the window-resizing mechanic was neat but not enough to make the game fun. I somehow got convinced back that a metroidvania-style level design with a little backtracking could enrich the game more than a regular platformer and would fit well with the “expanding” mechanic. Since I’ve been in a really big vibe for this genre lately, I decided to give it a shot. After all, I found the “ground pound” ability a good solution for the downwards window expansion, and I didn’t find it a good idea for the player to start off with it right in the first room, so the idea of gradually acquiring more actions suddenly seemed very adequate for the game.

I then reviewed my list and made a final choice of which actions the player would acquire throughout the gameplay: ground-pounding, double-jumping and sprinting. Except for ground-pounding, none of them would need specific animation frames.

So when I got tired of coding, at around 1:00PM, I started working on the final character sprites. The snail, which was originally yellow and 1 tile (16 pixels) high, became way bigger (which affected level design a lot) and also blue, so details like the glasses and beard could be more easily understood.

From this point on, I spent a long time working on the game mechanics, because I didn’t want to start working on the level design before “feeling” how the game played and knowing all speeds, jumping distances, and enemy behaviour. This only happened by around 6:00PM.

I spent the following period finally working on the level design properly speaking, using as a guideline the following concepts:

• The level is has a spiral pattern-At one or more points, the player would have to go back to a previously visited room so he could reach a place he couldn’t before.
• Make all 3 abilities useful throughout the whole game, and not only in specific situations;
• Leave some spaces for for secret collectibles in case I have time to include some in the game;
• Rising difficulty

In 40 minutes of work I had almost 80% of the map done. Most of it is very similar to what you see in the final version of the game. By 8:30PM I had to stop working, only to return at midnight. At the moment I left, my checklist looked like this, in priority order:

• Damage & knockback (programming)
• Items (programming)
• Game Over & restart (programming)
• Items (art)
• Game Ending (art & programming)
• Title Screen (art & coming up with a name for the game)
• Tileset (art)
• Sound
• Checkpoint (programming)
• Fixing enemy behavior
• Furniture in the starting room.

I also listed a few animations like “adding dust clouds for when the snail is dashing” but realistically thinking I didn’t believe there would have time to implement that sort of polish.

Development – Final day, 22 hours remain (Sun, 0:00AM to Sun, 8:00PM)

I started working on each of the items in the list in the order they appear, and tried to do them quickly (for example, didn’t spend much time thinking on what appearance would be appropriate for each item and sticked with whatever was easiest to draw).

At around 5:30AM, I could say I finally had a fully playable version of the game, though there were still a few bugs here and there. Since I felt more relaxed, I even worked a little bit on a few non-essencial mechanics that were neat but not top-priority, like the checkpoint. At that time, I was already halfway through that checklist and started working on the title screen and ending screen art. I came up with the name “Recluse” because, even though I had more interesting name suggestions, this was the only one that fit the tiny title screen.

The ending screen art took almost 3 hours to make (wow) and I made it using illustrator since I had lost my tablet. After it was done I imported the curves into photoshop and stroked them with the pencil to make it pixelized. I thought the drawing would look way worse, so the final result kind of exceeded my expectations, even though it still looks like some sort of old educational game. But since it was not essencial for the game, I figured I shouldn’t spend any more time in it. It also took a lot of time to program the scripted animation, but both art and programming were done, at 2:20PM, I sent the first fully playable version of the game to friends to test, even though there was still no terrain tileset.

I researched references for the tileset and worked on it for around 3 hours, though I didn’t like the result, which kind of hurt my eyes. Feedback from friends pointed out that the game was too hard and that the dash ability wasn’t very noticeable, so I had to prioritize making a dust animation to indicate more clearly that the sprint was activated.

Comparison between the terrain tiles at this point and in the final version of the game

Even though I was still unhappy with the tileset and there was no sound in the game or furniture in the main character’s room, I decided to upload a fully playable version to the LD website 2 hours before the time limit (actually a friend pressed me into doing it, but I think it was one of the best things I did in the whole project). This was important because I found out what kinds of trouble could happen while exporting the game application and uploading the game.

Development – Final sprint! (Sun, 8:00PM to Sun, 10:00PM)

I had 2 hours to improve whatever I could in the game, so I decided to give up on the sound (the files were all already on the game folder, but I couldn’t find out why they weren’t working – after the competition ended, though, I found out it was just a missing line in the code) and include the bedroom objects, even though there wouldn’t be time to interact with them, I found them extremely important to characterize the snail as a social recluse and justify the game’s theme. When I finished doing that, I worked until the very last moment in a new tileset – which I liked a lot. In other words, I sacrificed sound in order to give the game better graphics, something I didn’t regret.

TL;DR:

What went right:

• Good project dimensioning.
• The game’s “expanding” mechanic implied that the game couldn’t be too long, at least not bigger than most computer screens. This helped me not overworking on the level design.
• Only started working properly on the “true” level design after I could feel all the player’s actions (jumping, double-jumping, sprinting, ground pound) and be sure they would be in the final version of the game.
• Showed the game to trustworthy friends while developing, who gave me good feedback and motivation.
• Had the idea really early, and found out how to implement window-resizing mechanics pretty quickly, too.
• The spiral level design fit the “recluse snail” theme like a glove.
• I really liked the final sprites and the tileset, they look different from my previous works, in a good way.

What went Wrong:

• Didn’t prepare myself beforehand. Found out during the competition I had lost my drawing tablet’s pen, so I had to make all the graphics using the mouse. Also, I spent MANY hours trying to fix bugs from the platforming code I used as a source (it was kind of hard-coded and it took a long time to adapt to a re-usable generic platformer). I could have done that before the competition and saved time.
• Had to cut down the double jump’s height midway through the development due to a bug. This made me have to redesign some parts of the map. Fortunately, though, the game is very short and that wasn’t too much of a hassle. If it was a big game, this mistake could have costed a lot.
• Lost some really cool graphics in a power outage, and part of the game documentation.
• Even though I think the game matched the theme very well, I could have made a better use of the expanding screen as a game mechanic, instead of just an aesthetic gimmick. For example, a friend found out a very interesting way of picking up one of the secrets, which involved not pushing one of the walls to its limit on purpose so you could stand on it later and reach a certain platform; I wish I had thought of that kind of use for the mechanic.
• Some things like the second jump height and the dash speed are lower than I planned because of bugs in my platformer “engine” and level design issues. I think both should be increased to make the mechanics better.
• I should have followed suggestions from friends and made the game easier.
• Enemy placement was kind of random and their movement pattern is weird and not very predictable.
• I didn’t really have a pallete, so I used colors kind of randomly.

Tips for future participants:

• Fall in love with your game idea. A project made enthusiastically is better than a project made by self-imposed obligation.
• Fall in love with an alternative idea before working on your main one. I didn’t do that, but that was risky. If you don’t, you won’t be able to give up on the first idea and still feel motivated, if needed.
• In my personal opinion, it’s better to make a game that’s close to your capabilities and spend the rest of the time polishing it than starting off a great game concept and cutting features that composed what the overall game experience was planned to be.
• Always have a quick way of transfering files from one computer to another beforehand. Even if you don’t plan on using more than one computer.
• Have a priority to-do list.
• Try to find solutions that solve more than one problem.
• If you’re taking part of LD for the first time, upload a preliminary version of the game BEFORE the time limit.

It’s already been a while since the competition ended, but I finally uploaded my timelapse to Youtube. I’ll be posting a post-mortem in the next few days, too.

I’d also like to announce that I’m currently working on an updated version of Recluse, that includes everything I originally planned for the game (like sound), and also taking into consideration the main issues people seemed to be having with the game (like difficulty).

I’m trying to find a way to stop the white flashes that most computers experience while the “expanding” mechanic is at work, but I suspect there’s no easy solution to that =/

What you should expect in the next version:

-Sound
-Corrections in the level design to make the game less frustrating
-Re-written text (I think the current ones are weird, they were made in a hurry)
-Mac compatibility?
-New hidden collectibles (maybe)
-Easier-to-predict enemy behaviour.
-A few improved animations
-Checkpoint animation
-Animation for the cracked block being destroyed.

Well, I think that’s it. If anyone has any opinions or suggestions, feel free to contribute! Also, if you still haven’t, play Recluse!

Hello! This is the first time I’m taking part of Ludum Dare. I feel kinda lazy at the moment but I believe once the competition starts and I get the first game ideas I hope I’ll get more enthusiastic.

I will be using either Construct Classic or Processing to make my game, depending on the project complexity.

In case I use Processing and the game is a platformer, I will use a few objects from one of my platforming sketches (at the end of the post), as well as Tiled as a level editor.

Graphics will be all made on Adobe Photoshop.

I might make sound effects and music using Famitracker and definitely bfxr (thanks to Saint11 for the link!)

Good luck, everyone! I hope this will be an enjoyable experience.

class Objeto2D {
float x, y, v, g;
float vx;
int w=12, h=8;
boolean caindo = true, c;
boolean ativo = true;
boolean sobre[] = new boolean [128*128];
boolean aolado[] = new boolean [128*128];
int sizex=16, sizey=16, vm;
int Jpower;
void fall() {
y=y+v;
if (v<vm)v+=g;
}
void start() {
g=1;
vm=20;
v=0;
sizex=16;
sizey=16;
y=16;
x=11*16;
Jpower = 30;//170
vx=1;
}
void move() {
if (right == true&& ativo==true) {
x+=vx;
if (x>11*16) x =11*16;
}
if (left == true&& ativo==true) {
x-=vx;
if (x<0) x =0;
}
}
void jump() {
caindo = true;
if (v ==0) v=-Jpower*0.1;
y–;
}
void desenha() {
if (preto>=3){
if (lumi>=3) image (bandeirinha[(animacao/16)&1], x, y-sizey);
else image (bandeirinha[0], x, y-sizey);
}
else {
fill(255, 0, 0);
noStroke();
rect(x, y-sizey, sizex, sizey);
}
}
void colide() {
c = true;
for (int i = 0; i < sobre.length; i++) {
sobre[i]=false;
aolado[i] = false;
}

for (int j =0;j<h;j++) {
for (int i =0;i<w;i++) {

//pés

if (x>i*tsize-sizex && x< (i+1)*tsize && y >=j*tsize && y <=j*tsize+vm+1 && tile[i+w*j]>0 && (caindo == false ||v>0)) {
sobre[i+w*j]=true;
}

//cabeça

if (x>i*tsize-sizex+vx && x< (i+1)*tsize-vx &&  y >=j*tsize+tsize+sizey-Jpower*0.1 && y <=j*tsize+tsize+sizey && tile[i+w*j]>0 && v<0) {
sobre[i+w*j]=true;
}

//esq
if (x>=i*tsize+tsize-vx-1 && x<= i*tsize+tsize &&  y >=j*tsize && y <= j*tsize+tsize+sizey && tile[i+w*j]>0 && (sobre[i+w*j]==false || caindo==true)) {
x = i*tsize+tsize;
aolado[i+w*j]=true;
}

//dir

if (x>=i*tsize-sizex && x<= i*tsize-sizex+vx &&  y >=j*tsize && y <= j*tsize+tsize+sizey && tile[i+w*j]>0 && (sobre[i+w*j]==false || caindo==true)) {
x = i*tsize-sizex;
aolado[i+w*j]=true;
}

//pés2

if (x>i*tsize-sizex+1 && x< (i+1)*tsize && y >=j*tsize && y <=j*tsize+vm+1 && tile[i+w*j]>0 && aolado[i+w*j]==false && (caindo == false ||v>0)) {
c = false;
v = 0;
y = j*tsize;
}

if (y>=h*tsize) { //sem buraco
c = false;
v = 0;
y = h*tsize;
}

//cabeça2

if (x>i*tsize-sizex+vx && x< (i+1)*tsize-vx &&  y >=j*tsize+tsize+sizey-Jpower*0.5 && y <=j*tsize+tsize+sizey && tile[i+w*j]>0 && aolado[i+w*j]==false && (v<0)) {
v = -v*0.2;
y = j*tsize+tsize+sizey;
}
}
}
caindo = c;
}
}

==EDIT==

Derp, I forgot to say, but since I’m using Tiled as a level editor I’m also using a stage loader I made with processing. Also, the font I’ll be using in the game is called 04b03, by Yuji Oshimoto. Here’s the stage loader code:

class Stage {
PApplet p;
Stage (PApplet parent) {
p = parent;
}
void load(int A) {
XMLElement xml = new XMLElement(p, “stage/”+bossName+A+”.tmx”);
XMLElement mapa;
mapa=xml.getChild(“layer”).getChild(“data”);
int n = mapa.getChildCount(); //haruna5=1400?
for (int i = 0; i < n; i++) {
XMLElement kid = mapa.getChild(i);
sprite[i] = byte(kid.getInt(“gid”)-1);
}
w = byte(xml.getInt(“width”));
h = byte(xml.getInt(“height”));
}
void loadEnemies (int A) {
for (int i = 0; i<inimigo.length; i++) inimigo[i]=new MiniDragon2(-1000, -1000);
XMLElement xml = new XMLElement(p, “stage/”+bossName+A+”.tmx”);
XMLElement obj;
obj=xml.getChild(“objectgroup”);
if (obj!=null) {
int n = obj.getChildCount();
String enemyType;
for (int i = 0; i < n; i++) {
XMLElement kid = obj.getChild(i);
enemyType =kid.getString(“type”);

if (enemyType.equals(“TShadow”)) inimigo[i]=new TShadow(kid.getInt(“x”)/tsize, kid.getInt(“y”)/tsize);
}
}
}
}