Thanks to Emscripten, you can now play my game in your browser with a bloated 10MB download over HTTP, awful framerate, and NEARLY ONE SECOND of sound lag… on Firefox, and absolutely NO sound on Chrome!

Hell, I don’t even KNOW if it works on Chrome, but here we go:

https://dl.dropboxusercontent.com/u/32094129/em/rebellion/em.html

Let me know how badly it works!

Because I like it. And I’m willing to make it.

Either that or it’s got something to do with the fact that I only rated about 7 games.

But lulzfish_4 rated many more games than I did yet performed bloody awfully. Maybe people are vicious when they see someone’s made a few mistakes. Or maybe they just can’t cope with 8 enemies firing targetted shots at them. I don’t know. (It’s pretty easy to dodge once you know your hit region.)

And he got 1.33 for audio? His game doesn’t even HAVE audio! DO YOU NOT KNOW HOW TO PRESS THE N/A BUTTON (obviously I had better people voting for mine because they knew how to press the N/A button for humour even though there was a bit in the game itself)

His game wasn’t even terrible. It was just a bit incomplete, and a bit rough around the edges. I’ve seen worse games that deserve worse scores, most notably a particular game which involved going around a huge-ass cavern picking up 50 identical things. It was not fun at all. I am neither naming this game nor this author, as everyone does duds every now and then and he doesn’t need to be remembered for such a dud.

Hell, his worst placing was in the theme department. I feel this is complete horseshit. If anything, this needed MORE things.

Come to think of it, if his game were some Unity hackjob, he’d get a much higher score because shitny*. I really don’t like that.

(* typo’d that, corrected that, decided to leave it in. It’s a new word, guys!)

If it’s any compensation, I at least did well in the audio department, and somehow did alright in the fun department.

MiniLD #42 is coming up. Provided my coursework doesn’t suddenly start kicking me in the crotch, I might take this time to learn how to use LÖVE, and then make a bullet hell shooter with it.

Alternatively, if emscripten decides to work, I might be able to make an asm.js port of my LD26 entry, and then I can gut the engine out and use that as base code. Hell, I might even stick in a few #define macros just to save my sanity (getting the texcoords right was somewhat tedious, lots of copy paste, thank you vim for being awesome).

And then I will make a bullet hell shooter.

Because I like bullet hell shooters.

And, to be quite honest, there are other people who do.—Maybe I’ll have enough time to stick in a few difficulty levels. I for one am not particularly good at my own game, but I can get a no-death run every now and then.At least I still find my game challenging.

So here’s the bullet hell shooter I was working on, and it’s DONE.

Look on the page for “Rebellion: Resistance of Complacency”, or click my name and you might see it there.

Sorry about the lack of X.

Yes, this game IS beatable with the 3 lives you have.

Let’s milk that screenshot a 4th time, even though there’s actually a score counter and a lives counter now and has been since the previous alpha:

Download: https://dl.dropboxusercontent.com/u/32094129/ld26/ld26gm-rebellion-20130428221657.zip

Z to shoot, shift to focus, arrows to move.

Enjoy!

This didn’t take long.

Also, you have LIVES now! (and score, because grazing is implemented now)

https://dl.dropboxusercontent.com/u/32094129/ld26/ld26gm-rebellion-20130428203730.zip

Forgot which game this was? Let’s milk this screenshot AGAIN:

Controls are, of course, arrows to move and shift to “focus”.

If you die for good, and you’re using Windows, check stdout.txt for your score.

Let me know if you survive!

I’m just going to type some crap while I wait for it to upload to Dropbox. The .zip is 3.3MB. This might be due to the fact that all my textures are uncompressed BGRA .tga files.

Anyhow, I think I’ve managed to push this level up to the 38  second mark. I’m going to play a round and see how well I go.

…great, I died on one of the radial shots, AND THE DAMN  THINGS AREN’T EVEN THAT FAST. Maybe I should raise them higher for the next build.

Still uploading. At least we’re bringing back the good ol’ days where the graphics used up more space than the music. What the hell, seriously, why is it that by removing the music from most things you shave off 90% of the game.

Oh good, I did leave Dropbox running, so it is uploading.

Ah, done!

https://dl.dropboxusercontent.com/u/32094129/ld26/ld26gm-rebellion-20130428174710.zip

Contains builds for 32-bit Windows and 64-bit Linux, the latter is not intentional, the former is because Windows sucks and doesn’t come with a decent toolchain.

Here’s the screenshot from the last post to jog your memory. Yes, you can DIE in this now (and thankfully it doesn’t abort() anymore).

Have fun!

No collision detection yet, but mobs work and can shoot bullets.

Oh yeah, the player can move and also has a visible hitbox now (not pictured because it’s difficult getting good screenshots… maybe I’ll pull out recordmydesktop at some stage).

So this is typical “Start Of Stage 1 Lunatic” stuff. I think. I might just stick with “if((other->type == T_BULLET || other->type == T_ENEMY) && (other->flags & F_ENEMY)) abort();” until I get a life system working.

Here’s what I have of the boss theme so far, it might need more work in a few places (read: the loop is a bit nasty):

https://dl.dropboxusercontent.com/u/32094129/ld26/gm-ld26b-dem01.it

And just in case you missed it, there’s also the level theme.

Enjoy!

So, now we have a player and a couple of shots. Not pictured: I have libsackit working now and it’s playing the music I made. Also, the title text transitions nicely now.

No, there is no actual collision detection yet, and you can’t even move the player. But the bullets move! Honest!

Next thing (which will have to wait until tomorrow) is to get the player moving around – then we can work on enemy mobs, and eventually making the player shoot stuff. Oh, and making the player die.

Any ideas for what I should call this player? I’m not taking the theme very seriously at all – I’m hoping for a fairly “normal” guy’s name.

Ooh, I wonder what THIS game is going to be?

At the moment the title isn’t properly animated, though, and I’ll need to drop a player in at some stage. (Plus I need to get the timing sorted out and chuck in that music I’ve been working on.)

Don’t worry, I do have SOME code (including a very minimalistic .tga loader which is NOT for my interpretation of the theme dammit!).

So anyways, after spending suprisingly less time in sunvox making samples than in schismtracker making the actual music, here’s some music:

https://dl.dropboxusercontent.com/u/32094129/ld26/gm-ld26a-dem02.it

and while I would like to do a post with a tutorial on how to code in Lua disgustingly, by the time I would be done bashing this into my phone we would have started already, and I have lawns to mow.

function applyargs(f, l)
local function g(k)
if k < #l then return l[k], g(k+1) end
end
return f(g(1))
end

provided i don’t end up jamming with someone else here’s the lowdown

c

sdl, opengl, libsackit

schismtracker

gimp

vim

no fancy asm + weird console crap this time – i’d like to have something a bit better than an exploration game

maybe this time i’ll have a bullet hell shooter ffffffffffffffffffff

also, congrats to the guy at VUW who managed to advertise a meetup by sticking a piece of paper on the roof

EDIT 1: Forgot to finish a certain thing. Also, added one more consideration to group 2, and a consideration to group 1.

For the charity game jam (and apparently there isn’t a blog category here for that, I have no idea why), you will be making a “NES-like” game.

But wait! Before you open up Musagi and turn the reverb up, consider actually doing it properly.

I’m not saying you should quickly download WLA-DX and make a game with it. What I am saying, however, is you should at least make a decent attempt to stick within the limits. There’s no point making it vaguely like a NES and then throwing the palette out altogether and having 256 different colours in a 16×16 area and smooth-as-balls non-dithered gradients, when this is the perfect opportunity to actually stick to at least some of the limits.

So here we go. I’m going to categorise these into groups.

Group 1: The bare minimum

This is what you can easily achieve if you actually try.

• Stick strictly to the NES palette. Really, it’s not hard. You have 56 unique colours to work with, plus you can dither stuff to some extent.
• The tile layer consists of 16×16 tiles (technically a 2×2 group of 8×8 tiles), each consisting of 3 colours + 1 transparency colour. Note, some mappers allow grouping these as 8×8 tiles, although I recommend you go with 16×16.
• The tile layer is scrollable in all 4 directions.
• Sprites are either 8×8 or 8×16 (note, this is a global flag, either all are 8×8 or all are 8×16), and each sprite consists of 3 colours + 1 transparency colour. If you want bigger sprites, or more colours (don’t go overboard with this, please! 2 should be enough), stick a bunch of sprites together.
• Sprites can be flipped horizontally/vertically in hardware, and can be set to either go in front of the tile layer or behind it.
• There is a background colour, which you can set to anything in the NES palette.
• Feel free to consider scanline effects, but don’t go overboard! Something as simple as changing the background colour (or all the colours, typically making everything the same colour) at a few points, or making only the middle of the screen scrollable (although in those cases you shouldn’t scroll vertically!) could work. Take a look at actual 2nd/3rd/4th gen games and see how it’s done.
• Audiowise, you have 2 pulse waves (either 50%, 25%, or 12.5% duty cycle), 1 triangle wave, 1 noise channel (either “periodic noise” or “white noise”, if you’d like to be precise see here), and 1 DPCM sample channel. Please use the crap out of these! Check Group 2 for some stronger restrictions you may wish to consider.
• There are also some audio expansions you might want to consider, for instance the wonderful VRC6 gives you 2 pulse waves (1/16 through 8/16) and 1 sawtooth wave, but if you use them, use the crap out of them!
• NES/Famicom audio doesn’t actually have stereo support, but for Group 1 you can ignore this fact.
• Consider using a 60Hz (or 59.97Hz if you feel like being anal) base clock (divide it how you like, I suggest 30Hz if your game making program isn’t exactly the most efficient). PAL timing is OK but be warned – there are a lot of differences between the PAL and NTSC versions of the NES/Famicom that you might as well just go with NTSC to keep it simple.

Shouldn’t be hard if you actually try, although some of you might get stuck for a few minutes with some of the limitations.

Group 2: The recommended courseload

This is what you will achieve if you actually care.

• Each 16×16 tile can use one of 4 3-colour palettes (editable), and each sprite can use one of 4 3-colour palettes (also editable). Each of these palettes take colours from, you guessed it, the NES palette.
• You can have only 64 sprites on-screen at a time (scanline hackery MAY allow for more but don’t bank on it). Note, this does not need to be a strict limit, but don’t spam over 9000 sprites.
• Consider this, but you don’t need to enforce it: You can only have 8 sprites which have pixels (even transparent ones!) on a single scanline. (The hardware behaviour, if you’re wondering, is to draw the “topmost” 8 for the scanline, and discard the rest.)
• Consider this too, but likewise you don’t need to enforce it: Your tileset consists of 512 8×8 tiles. For each of these, the first or last (globally settable) 256 tiles can be used for the tilemap. A 16×16 “tile” consists of 4 of these tiles in a 2×2 arrangement, which can be any combination of those 256 tiles. For 8×8 sprite mode, either the top or the bottom (also globally settable) 256 tiles can be used. For 8×16, you can use any even-odd pair from the tilemap. Vertically flipping the sprite will flip the whole sprite as a unit, and not just the individual tiles, which is a good thing. (EDIT to clarify: Yes, you can assume CHR-RAM and edit the whole tileset.)
• Consider this also: You can only write so much to the video memory per frame. Try not to replace the whole tileset during vblank!
• Musicwise, you are ONLY going to use the 5 channels indicated, optionally adding whatever expansions you want to squeeze in (USE THE CRAP OUT OF THEM IF YOU USE THEM, I CANNOT STRESS THIS ENOUGH). For this, you will need to stick within the note limits. My advice, just get FamiTracker (or anything that spits out a playable .nsf for that matter, I tend to use s3m2nsf myself, although pcmnsf/supernsf is somewhat cheating here).
• Audiowise, use one (or, if you must, two) of those waveforms for each sound effect. You can layer them over the music instead of replacing what’s playing in the channels, if you like. Please stick within the note limits for this, too.
• The pulse channel note limits are either ~110Hz or ~55Hz (I think there’s a mode that can get you down to ~55Hz but I found that I could only go down to ~110Hz for some reason) for the pulse waves – this is A-2 or A-1. Feel free to assume the latter.
• For the triangle channel, either A-1 or A-0, I’m not sure. Also, the triangle has 2 volumes: “On” and “Off”.
• For the noise channel, there’s 16 discrete frequencies. See here for more info.
• For the sample channel, same deal with the 16 frequencies. See here for more info. Also, like the triangle, there are 2 volumes here, too! Finally, the outputted waveform tends to sound like crap. Sorry, guys!

This is really what you should attempt, unless you speak 6502 assembler.

Group 3: “Head Trauma” all over again

This is a stupid idea and you should just skip to Group 4. I basically did this for my first ever LD (#18, although for the Sega Master System, which is better, so ), and wasted over half the time getting the half-baked emulation right.

• Graphics and audio must be completely accurate ignoring any weird signal degradation / filtering / whatnot, and possibly ignoring some of the finer quirks.

No really, I’d rather code in 6502 asm, thanks.

Group 4: NES-like but without the “-like”

This is what you will achieve if you want to soil your pants at what you’ve managed to achieve in 48 hours. This is much more achievable than it sounds at first.

• Use this and this and this.

I’ve done this 3 times. Twice for the Sega Master System, once for the Sega Mega Drive. I also have some base code for the NES but it’s very minimal.

But yeah, seeing as you’ve been given this opportunity, you might as well make the most of it. I personally recommend Group 2, although if that’s a bit too tough, Group 1 should do.

Remind me and I might release a modified atrk-bu.py or an atrk2nsf thing or something like that.

I’m kinda disappointed at the sheer lack of platform games with slopes in them which aren’t Game Maker / Unity hackjobs. So, I’ll explain how they work in Cave Wanderer and to some extent This Is Totally About Evolution.

As I’ve coded both of these games in assembler (Z80 for CW, 68000 for TITAE), and in neither case have I had a floating point unit, I’ve been slightly cheap wrt slopes, simply not affecting the X coordinate.

Anyhow, the most important detail: tile types.

Each tile type has these two values:

• flags – Flags
• clampy – Maximum in-tile Y clamp value

And of course, flags is a bunch of boolean true/false values typically stored as a bit mask in some byte/doublebyte/quadbyte integer. (Not using the term “word” – that’s CPU-specific.)

So what we end up doing is a chain of functions doing something like this:

void tile_do_step_1(tiletype_t *tt, int *x, int *y)
{
  if(tt->flags & TF_STEP1)
  {
    /* apply step 1 here - f(v) */
    tile_do_step_2(tt, x, y);
    /* mathematically unapply step 1 here - g(v) */
  } else {
    return tile_do_step_2(tt, x, y);
  }
}

Note, x and y are the x,y coordinates relative to the top-left corner of the tile. Or whatever corner you choose for practicality. Anyhow, those are *pointers* to x and y, mostly because you want to screw with them all the way up and then all the way down again.

Heck, if you really wanted to, you could make them global variables “col_x” and “col_y” or whatever sane name you want to give them. Just be very careful if you decide to start multithreading stuff. Or you could just, y’know, pass the entity along instead.

Having a mathematical inverse is absolutely crucial here – in other words, for every vector v, g(f(v)) = v (or at the very least g(f(g(f(v)))) = v if you can’t ensure that). All inverses I’ve used in CW and TITAE are very straightforward. Let’s list them.

• TF_SWAPXY: f(x,y) = <y,x> = g(x,y)
• TF_INVX: f(x,y) = <tile_width-1-x,y> = g(x,y)
• TF_INVY: f(x,y) = <x,tile_width-1-y> = g(x,y)
• TF_SLOPE1: f(x,y) = <x,y+x>; g(x,y) = <x,y-x>
• TF_SLOPE2: f(x,y) = <x,y+x/2); g(x,y) = <x,y-x/2>

Of course, if you want a physically-accurate slope, you’d probably want to then divide the inverses there by some numbers I can’t quite recall the values of, but are basically the lengths of whatever the hell kind of vectors you want to shove in there.

I was experimenting with that in CW but the experiments proved to be a pain in the ass so I just went with what you see above (minus TF_SLOPE1, of course).

Anyhow, the final step is just this:

void tile_do_step_last(tiletype_t *tt, int *x, int *y)
{
  if(*y >= tt->clampy)
    *y = tt->clampy;
}

…that really wasn’t hard, was it?

Of course, you then need to know what to do with these values. Simple: you give an entity and some relative coordinate to a function that goes a little something… like this:

void apply_tile_collision(entity_t *e, int rx, int ry)
{
  int bx = (e->x + rx) % tile_width;
  int by = (e->y + ry) % tile_height;
  int x = bx, y = by;
  tile_do_step_1(get_tile(x/tile_width, y/tile_height), &x, &y);
  e->x += x - bx;
  e->y += y - by;
}

Call that a bunch of times for any point you like, and… that’s it really. Although you can then send across some special flags for each point, like “this is on the bottom therefore I should be counted as on the ground and able to jump”. TITAE uses 8 points for the player: bottom middle, top middle, left middle, right middle, all 4 corners.

Anyhow, the way the tiles are done in CW is something like this:

• There are “top” (TF_INVY) and “bottom” (no flags) tiles. clampy is about half way down the tile.
• There are “left” (TF_SWAPXY) and “right” (TF_SWAPXY,TF_INVY) tiles. clampy is 0.
• There are “clear” (clampy=tile_height*2) and “solid” (clampy=0) tiles.
• Slopes are denoted with TF_SLOPE2, have selected clampy values, and tend to have TF_INVX in one direction and not in the other.

And that’s Slopes 101. Any questions?

Well, this is pretty much what I learnt:

NEVER EVER IMPLEMENT SCROLLING DURING THE COMPO EVER AGAIN.

I basically had 6 hours to make a game. Totally reusing this engine for next time, so I’ll have the whole 48, instead of spending a whole day on the bloody scrolling.

But aside from a few last-minute hacks, it’s a fairly solid engine. It maintains a linked list of all entities, allows for adding and removing said entries, has a roughly O(n^2) collision detection method, scrolls a 128×128-tile (64×64-chunk) virtual playfield in a 64×64-tile VDP playfield (I hope to extend this to double the size in each direction), has slopes (I COULD NOT RELEASE THIS WITHOUT SLOPES THAT WOULD BE WRONG), and that’s pretty much it.

Oh yeah, I pretty much spammed twitter during the compo. I cannot guarantee the whole lot will make sense.

So there we go!

About 4:30 to go. Going to have breakfast ‘n’ get ready ‘n’ stuff.

TODO:

• make the bats kill you
• allow for adding/removing stuff on the fly
• ADD A GUN
• make it upgradeable
• level switching?

Oh yeah, I also have music. PREPARE YOUR EARS FOR THE AWESOME.

And added in slopes and a silly parallax background (mostly because it’s a LOT easier than, um, the scrolling crap I had to do before).

Now it’s time for a shower, then possibly refactoring the entity draw code so it draws more than just the player. Then… sleep!

As usual, there are the bugs.

• Collisions are absolutely fine, actually.
• The level (wrt Y+ scrolling) is drawn with the wrong Y offset, and quite likely the wrong X offset, too
• Uhh, I think that’s pretty much all the actual identifiable bugs.

Let’s see if we can sort this out before dinner. (Not likely, but itmight happen. Anyone into miracles?)