Lisp Game Jam Log #2

Screenshot showing several 2D player images, grassy terrain, and water arranged in a simple scene. I am making progress on my game jam entry. Last night I was able to make the code to load a spritesheet from Kenney Game Assets, using spritesheet code I previously wrote for my eggsweeper example game. To test that the sprites were defined correctly, I arranged a simple scene, shown here in the screenshot.

I then started working on the data structures for representing a game level. So far I have a level type, which holds many individual tiles, each of which has a tiletype that defines the appearance and default properties of a tile. A level is not responsible for managing entities such as players or items; those things be managed by a scene type, which will also hold a reference to the level.

As I was drifting off to sleep last night (or rather, tossing and turning with my head full of ideas), I pondered different approaches to defining a level format. I want the level format to be pretty simple and text-based, so that levels can be created in a text editor, without the need for a dedicated level editor program.

One easy-to-implement format would be to simply have s-expression based list of all the tiles in the map. But that would be pretty hard to visualize and modify in the text editor. I also considered having two parts to each level: a s-expression file describing metadata and logic, and an PNG image file where each pixel color represents a different tiletype. This might be easier for people to visualize and edit, but harder to implement.

Right now I am leaning towards a simple s-expression format with tiles of three characters, separated by spaces, like so:

(prop title "My First Level")
(prop author "John Croisant")
(prop num-players 2)
(row --- --- --- --- ---)
(ids ~~~ ~~~ C1~ ~~~ ~~~)
(row --- --- PLT --- ---)
(ids P1~ ~~~ ~~~ ~~~ P2~)
(row GL- GM- GR- WT- GL-)

Here, each row expression defines a row of tiles. --- means empty space, and other three-character strings describe tile types: PLT (Prop/Ladder/Top), GL- (Grass/Left), GM- (Grass/Middle), GR- (Grass/Right), and WT- (Water/Top).

Each ids expression assigns three-character IDs to the tiles above it. The IDs can be used to assign special gameplay behavior to that tile. The ~~~ means the above tile has no ID, so the tile doesn’t have any special behavior. This level has tiles with IDs C1~ (Coin 1), P1~ (Player 1), and P2~ (Player 2). Probably there will be many pre-defined special IDs for gameplay, plus the ability to define custom IDs. The custom IDs could be used to connect a button tile to a trap tile, for example.

This level also has a few prop expressions to define extra level properties. The title and author properties are metadata about the level. The num-players property indicates how many players the level is designed for.

I think this format will strike a good balance between ease of implementation, ease of visualization, and ease of editing.

Lisp Game Jam Log #1

The January 2016 Lisp Game Jam officially started earlier tonight. I haven’t participated in a game jam for several years, and I’m excited. Game jams are exciting (and stressful) in general, but I’m also excited because this is my first jam using a Lisp dialect, plus it is an opportunity to use the CHICKEN Scheme bindings to SDL2 and related libraries, which I have been working on for the past several months. (I’m also excited because at least two other people are planning on using my bindings for the jam, which is a nice feeling.)

This game jam does not have a prescribed theme, so I’m free to make any game. I’ve been pondering for weeks about what kind of game I might make for the jam. My goal is to produce another example game for the bindings, so I want the result to be clearly organized, well documented, and to demonstrate the capabilities of the bindings. In particular, I want to try to push the boundaries of performance. My previous game library project, Rubygame, struggled with raw performance, partly because of the performance limitations of Ruby in those days, and partly because I didn’t put much effort into optimization. So, I’m keen to see what I can achieve with CHICKEN Scheme and these bindings.

Thinking about what type of game I’d like to make for the jam, I had two main ideas: a scrolling space shooter à la Tyrian, or a platformer à la Mario Bros. I also briefly considered a Harvest Moon-like RPG, but decided I wouldn’t be able to make it fun in 7 days, and the laid-back gameplay style wouldn’t push any performance boundaries.

Between the space shooter and the platformer, the space shooter would be a more interesting example, because I could try to achieve solid performance while having hundreds of bullets and ships on screen at the same time, and it could use the function bindings I recently added for 2D accelerated rendering. But, those bindings aren’t actually released yet (they are scheduled for version 0.2), so it wouldn’t be as easy for people to install the bindings and play the game. So, I am going to make the platformer game for this jam, and then make the space shooter at some later date.

This game jam allows us to use preexisting free assets (images, sound, music), so to make things easy for myself I am going to use a lot of assets from the Kenney Game Assets pack. (You have to donate money to get the assets from the official store, but they are licensed CC0 public domain, so no doubt they are available somewhere for free.)

In terms of gameplay, I’m thinking the game will be a rowdy local multiplayer game, where players compete to collect the most treasure, like the old Super Mario Bros. Battle Mode. At the most basic level, it could just be treasure periodically appearing at random places on the level, and the players scrambling to reach it first, with no real interaction between players. If I have time, I could add various ways for the players to interact and interfere with each other: bouncing and bumping into each other, triggering traps, throwing items, etc.

This game design is simple and flexible enough that I’m confident I’ll be able to complete something fun during the game, especially since we have 7 days. I will probably try to include 2 or 3 built-in levels, and have a simple text-based file format so that people could create their own levels.

chicken-sdl2-ttf 0.1 Released

Screenshot of the chicken-sdl2-ttf demo program, displaying the text "Hello, World!" three times. Last week I released version 0.1 of chicken-sdl2-ttf (aka the sdl2-ttf egg). This provides bindings to SDL_ttf 2, the font rendering library for SDL. This library is compatible with chicken-sdl2, which I released a couple weeks ago.

SDL_ttf is thankfully a fairly small library, so I was able to create and document complete bindings to it in less than a week, in advance of the January 2016 Lisp Game Jam, which has just started a half hour ago.

My plans now are:

  1. Create a game for the game jam!
  2. Release chicken-sdl2 0.2 (the main new feature is 2D accelerated rendering).
  3. Create bindings for SDL_mixer, and possibly SDL_gfx.