## Entries

 Alone (Except for some Snakes)Ludum Dare 22 Mirror's SecretLudum Dare 21

## So, I have an idea now.

Posted by
Saturday, August 25th, 2012 9:03 am

Which is excellent since I was afraid I wouldn’t be participating!

Before the competition started, I decided that if I wasn’t going to be able to make a real-time game with graphics, that I would simply make on in an HTML document which entirely utilizes text and links and stuff. So that’s what I’m doing.

Specifically, a general sort of adventure game, where you are presented with something like twenty different choices for what to do that season–then you’ll go out and do it, and you’ll be asked again what to do, but, of course, it’s been 3 months–things have changed. Now to implement. The graphics will be nonexistent, and I’m not sure what about music. So let’s focus on everything else. 😀

## Musings

Posted by
Friday, August 24th, 2012 6:46 pm

I, like apparently a lot of people, are lost as to what to do. My goal in the Ludum Dare is always to do as well as I possibly can in the ‘Fun’ category, which is why I want to stay away from casual type games–they aren’t grabbing enough. Currently my only real finished idea would be navigating through simple puzzlish type things using pseudochemistry. But as I said, it might be entertaining, but not ‘fun’.

An idea has sprung into my head! I will have to plan out how to make it work.

## Smooth Noise Function [java]

Posted by
Sunday, August 19th, 2012 9:59 am

It’s a fairly slow function, but it’s better than the one built into Processing.org. The functions which I don’t define are mostly in the Math library (they’re redefined like that by Processing). ‘dist’ is Euclidean distance.

`int seed; //Seed for the noise. It seems that very similar seeds have very similar results.`
`float rr(int x,int y,int b) {`
`Random k = new Random(x + y*13337 + seed);`
`int a = 0;`
`while (a < b+2){`
`k.nextFloat(); a++;`
`}`
`return k.nextFloat();`
`}`
`int noiq = 4;//Quality of noise. Higher is slower and shouldn't have rips.`
`float noi(float a,float b) { //x,y positions of noise. Returns a number between 0 and 1,symmetric about 0.5.`
`int u = (int)floor(a-noiq);`
`int ut = u + noiq*2;`
`float s = 0;`
`float w = 0;`
`while (u < ut) {`
`int v = (int)floor(b-noiq);`
`int vt = v + noiq*2;`
`while (v < vt) {`
`float m = dist(a,b,(float)u + rr(u,v,1),(float)v + rr(u,v,2));`
`float j = pow(0.2,m*2);`
`w = w + j;`
`s = s + j * rr(u,v,0);`
`v++;`
`}`
`u++;`
`}`
`return s/w;`
`}`

## Probably Entering

Posted by
Thursday, August 16th, 2012 5:32 pm

Yep, probably. It’s possible like last time I will just not get enough done in the 48 hours. My tools will be Processing’s IDE & Library, Paint.net, & Notepad++. I’m not certain if I want to opt for an all web game or a java applet, obviously dependent on what sort of game I want to create, so maybe I won’t use Processing at all. Who knows?

For Processing libraries, probably Minim, SoundCipher, and SFXR/BFXR, Audacity and Anvil Studio for music/sound? All of which are free.

## Update

Posted by
Saturday, April 21st, 2012 12:23 pm

I have for now decided to keep it on one scale rather than multiple… Although I may change back depending on how easy it is to interface with the world at this scale.

Anyways, here’s a picture.

## What am I doing?

Posted by
Friday, April 20th, 2012 7:14 pm

Well, I want to make a very simple fractal-level RPG, with you able to zoom in on a tile to get a much closer view.

I’ll be making it in Processing.org and probably incorporate procedural generation of the world because of time constraints.

Posted by
Sunday, December 18th, 2011 5:12 pm

I’m pretty sure my game is fun, which is what I’m happy about, because last time my game wasn’t nearly fun enough.

Fun is good. It’s the entire purpose of making a game. No greater beauty or artistic or realistic value qualifies something as a good game. Games are art, but I don’t think art is a game. This time, I’m pretty sure my game is a bit of both (although highly lacking in art, it does make up for it in back death/snake related jokes).

I’m glad I finished two hours early. Sort of. Oh well, it doesn’t make much of a difference.

I guess I’ll have more to talk about

## Throwing it all together

Posted by
Sunday, December 18th, 2011 3:48 pm

I added more witty jokes for the end of the game (heh heh) and did some tweaking.

I am putting ‘music’ into it right now.

Then I need to upload…  Processing.org > Applications > Web as far speed goes, so that’s the order I’ll suggest people to try…

## Finishing Up

Posted by
Saturday, December 17th, 2011 8:11 pm

I still need to add music…

I made Big snakes. They can eat through walls (stone and wooden).

I made it compensate for lag (somewhat).

But I added treasure, which makes the game quite more purposeful.

The snakes tend to guard the treasure. It’s still dangerous at day, which is new.

## “Finished”.

Posted by
Saturday, December 17th, 2011 5:46 pm

But not enough… I suppose it’s fun. But there’s no particular reason to keep playing because the middle game is entirely consistent for eternity.

So now what? I need suggestions!!!!! D:

Very slow demo at  themage.x10.mx/LD22

## Level Gen

Posted by
Saturday, December 17th, 2011 11:07 am

I have a basic level gen working (I need to tweak it.).

It basically layers boxes to clear / add outlines, and ends up working pretty well with the snakes and all.

Now I need to make day and night do something, namely, affect the snakes’ behavior. I also need to make fruit-bearing palm trees to provide the sustenance of the game, and also possible for building walls / buildings and stoof.

## Next update…

Posted by
Saturday, December 17th, 2011 8:05 am

Well, I’ve been sleeping… But now I’m up and working.

I’ve added snakes, which are going to be the general enemy. I’m not sure how you’re going to actually fight them, but you’ll fend them off with fire.

You can also see the rudimentary clock at the top of the screen; right now it’s night.

## Basically wrapping up for tonight

Posted by
Friday, December 16th, 2011 9:17 pm

Well… Revising from my original more abstract idea, I want to make this a more peaceful, ambient game.

So I took the rough looking walls I had coded and made them look stony; then I added grass, and, tada, you’re on an island.

This game is going to play pretty straight forward. Basically, you’re surviving on an island where largely the elements as opposed to enemies are the danger. Most of the game will consist of searching for food.

Preliminary screenshot attached. I should post more updates throughout the compo, so you’ll see it evolving. That is, if I finish.

Which this looks fun enough that I will.

I plan on having the world be constantly regenerating, so the island won’t be very similar after a few days.

## Putting ideas down

Posted by
Friday, December 16th, 2011 7:33 pm

What I have so far as my idea is a basic topdown shooter.

I’m thinking of procedurally generated levels, because I can make it considerably more complex that way and focus on the feel and art of the game. Also because I was expecting randomly generated to win and I’m ignoring the fact it didn’t. 20 votes is very close. 😮

So in my first half hour of coding I’ve drawn a scalable gear… I’m not sure if this is relevant. We’ll see.

## I should be doing this LD…

Posted by
Friday, December 16th, 2011 3:02 pm

I don’t think any of the themes should catch me totally off guard…

I’m sort of happy with my game from last LD, but not nearly enough. I hope to do a lot better in executing a FUN game. To do that I’m going to abolish plans of storyline unless it’s really excellent and I can turn it into mechanics as well, and add it in after I have a fun game.

## Hallo.

Posted by
Tuesday, December 6th, 2011 2:39 pm

Last compo I wrote a platformer.

This took an unusually long amount of time.

This worries me for the next one coming up, so I’ve decided I might commit myself to simply using old code (as allowed by ‘base code’, although I’m going to try to confirm this specifically with as many LD’ers as I can before the compo).

Code:

player_x and player_y are float values, of the center of the player (which is a 16×16 box).

player_vspeed and player_hspeed correspond to the vertical and horizontal speed of the player (in pixels/frame).

current_map is a two dimensional boolean array, where true corresponds to a block and false not.

(Written with Processing.org in mind; any math functions such as min / max can be referenced through the Math java library, or really any programming language’s math library).

Up/down/left/right are booleans corresponding to the pressed-state of the cardinal keys, used for movement.

``` int LX = int((player_x-5)/16);
int LY = int((player_y+12)/16);
int RX = int((player_x+5)/16);
int RY = int((player_y+12)/16);
int MY = int((player_y+5)/16);
int TY = int((player_y-8)/16);
if ( (current_map[RX][RY] || current_map[LX][LY]) && player_vspeed > 0 )
{
player_vspeed = 0;
player_y = RY*16-12;
}
if (current_map[RX][RY] || current_map[LX][LY] )
{
//On ground.
if (up)
{
up = false;
player_vspeed = -5; //Jump speed.
}
if (!left && !right)
{
player_hspeed = player_hspeed * 0.8; //Horizontal velocity damping.
}
if (left)
{
player_hspeed = max(-3,player_hspeed - 0.3); //Accelerate to the left, with a maximum speed.
}
if (right)
{
player_hspeed = min(3,player_hspeed + 0.3); //Accelerate to the right, with a maximum speed.
}
}
else
{
player_vspeed = player_vspeed + 0.3; //Gravity. Accelerate down.
//In air.
if (left)
{
player_hspeed = max(-3,player_hspeed - 0.1); //For, in the air, horizontal acceleration from arrow keys.
}
if (right)
{
player_hspeed = min(3,player_hspeed + 0.1);
}
}
if (current_map[RX][TY] || current_map[LX][TY] )
{
player_vspeed = 0;
player_y = player_y + 2; //Hit the floor.
}
if (current_map[int((player_x+8.1)/16)][MY] && player_hspeed >= 0)
{
player_x = int((player_x+8.1)/16)*16-8.2;
player_hspeed = 0; //Hit a wall.
}
if (current_map[int((player_x-8.1)/16)][MY] && player_hspeed <= 0)
{
player_x = int((player_x-8.1)/16)*16 + 24.2;
player_hspeed = 0; //Hit a wall.
}
player_y = player_y + player_vspeed; //Accelerate the player.
player_x = player_x + player_hspeed;
player_vspeed = min(player_vspeed,5);```

[cache: storing page]