* Things To Do

** DONE Game loop
   Provide a game loop structure that responds to input events,
   updates the game state, renders the scene. Use a fixed update
   timestep and cap the maximum FPS.

** DONE Input
   Provide hooks to respond to keyboard, mouse, and joystick events.
   Wrap SDL keycode, mouse button, etc. constants in our own
   enumeration.

   - [X] Keyboard
   - [X] Mouse
   - [X] Window (active, resize, quit)
   - [X] Joystick

** DONE Sprites
   Encapsulates an image and all of its transformations: position,
   rotation, scale, color, etc.

   - [X] Use FreeImage
   - [X] Add support for texture regions
   - [X] Add support for animations
   - [X] Use a sprite batch when drawing if one is currently bound

** TODO Sprite batches
   Efficiently render a large number of sprites. Only change OpenGL
   context when necessary. For example, don't change texture when
   rendering several sprites in a row that use the same one.

** DONE Tilesets
   Break an image up into many small pieces. Useful for creating maps.

   - [X] Algorithm to split texture into tiles
   - [X] <tileset> type

** DONE Animations
   Create a data type to represent an animated sequence of textures
   and/or texture regions.

** TODO Tile maps
   - [ ] Create a generic tilemap module
   - [ ] Create a loader for Tiled .tmx map files.

** TODO Scene graph
   A tree structure that is traversed when rendering a game scene.
   The graph is composed of groups and nodes. Transformations are
   accumulated as the tree is walked.

** DONE Scripting
   Provide a way for users to easily script 2D games using coroutines
   and a scheduler.

   - [X] Coroutines
   - [X] Agenda

** TODO Vectors and matrices
   Vectors and matrices are needed constantly for games. Provide an
   easy-to-use module that provides procedures for common
   vector/matrix math operations

   - [X] Vectors
   - [ ] Matrices

** DONE Fonts
   - [X] Write wrappers for needed FTGL functions
   - [X] Write font rendering procedures

** DONE Sound
   Provide helpful wrappers around SDL sound procedures?

** TODO A* pathfinding
   A* is a commonly used pathfinding algorithm for games. Pathfinding
   is such a common task that it would be nice to provide users with
   a generic implementation.

** TODO Bounding box collision detection
   Most games need simple bounding box collision detection. Provide an
   efficient implementation that uses quad trees.

   - [X] Rect module
   - [ ] Quadtree module

** TODO Particle systems
   Provide a highly configurible particle simulation system.

   - [ ] Investigate ways to make it fast.  Use guile-compost for
     performance reasons.

** TODO Asset Management
   Provide a generic system for loading assets (images, sounds, fonts,
   etc.) and storing them in a cache. Explore using weak keys so that
   assets are removed from the cache when they are no longer
   referenced.

   - [ ] Create asset cache
   - [ ] Live asset reloading

** TODO Keymaps
   Provide an Emacs-like way of defining key combinations so that
   multi-button input is easy for users.

   - [ ] Abstract away input methods
     Controls can be bound to keys, mouse, whatever
   - [ ] Basic sequences
     Press A then B
   - [ ] Simultaneous key presses
     Press A and B at the same time
   - [ ] Composing sequences
     Press A then B + C
   - [ ] Timeouts
     Press A then B then C within 15 frames time
   - [ ] Sequences with actions along the way
     Press A to kick, then forward + B to uppercut, within 30 frames
     time.

** TODO GUI widgets
   Provide a set of common graphical widgets such as buttons, scroll
   bars, and sliders.

** DONE REPL
   Provide a REPL that plays nice with the game loop. Easier said than
   done.

   - [X] Modify Guile's REPL to work with the game loop
     - Short-term solution that *mostly* works
   - [X] Write a new REPL that runs in the current thread
     - Use coroutines
     - Read user input from a separate thread so as to not block the
       main thread
     - Will be available in Guile 2.0.10!

** TODO Scene Graph
   Provide a reactive scene graph for representing the renderable
   objects in a game.

** TODO Shaders
   - [ ] Scheme -> GLSL compiler
     Port http://wiki.call-cc.org/eggref/4/glls to guile?

** TODO Upgrade to SDL2
   Guile bindings needed.

** TODO Rename (sly helpers) to (sly utils)

** TODO Rename (sly transform) to (sly math transform)

** TODO Rename (sly quaternion) to (sly math quaternion)

** TODO Rename (sly shader) to (sly render shader)

** TODO 0.1 Release
   A 0.1 release was made under the project's old name, guile-2d.  Now
   that things have changed so drastically and the name has been
   changed, a new 0.1 release will be made.

   - [X] New REPL server
     Use the (system repl coop-server) module in Guile 2.0.11.
   - [ ] Screencast
   - [ ] Relatively complete documentation
   - [X] Clean up font module
   - [X] Add GLSL shaders
   - [X] Finish FRP module
   - [X] Make basic webpage with HTML docs
   - [ ] Basic scene graph (must support sprites and text)