Scrolling Game Development Kit 2 (SGDK2) is designed to simplify and speed
the development of 2D scrolling games for beginning game developers and
experts. Although this program can be used for other types of games, it's
primary design is to assist in the creation of scrolling games, especially
side-scrollers. This is the second major release of this program, and is a
total rewrite from the ground up. If you are a new user you may want to focus
on the Main Features section
below. If you are familiar with the old version, you might be more interested
in the What's New section.
The design of SGDK2 attempts to maximize both flexibility and
user-friendly design. Here are some of the high level features that make
SGDK2 a powerful and interesting environment for new and experienced game
- User friendly interface: Rather than requiring the user to become
familiar with coding, the environment provides many wizards, selection
lists and templates to make it possible to create complete games without
requiring the writing of any code.
- Extensive customizability: The vast majority of the generated game's
source code is exposed in the IDE's "Source Code" folder and can be
customized beyond recognition. This is theoretically flexible enough to
allow you to go as far as creating a project whose source code generates a
3D game instead of a 2D game, or compiles to a web component instead of a
Windows application. Furthermore a saved project file is nothing more than
XML, so you can conceivably write your own programs to process, edit or
re-use project data.
- Embedded Graphics Editor: Although you can import images from external
sources, it's not necessary to flip back and forth between programs as you
create or edit images. SGDK2 has a powerful graphics editor built in with
tools sophisticated enough to handle alpha translucency, rotation,
anti-aliasing and color re-mapping, among many other tasks. You can even
add your own tools.
- Integrated Map Editor: The main foundation of a 2D game is the data
contained in its maps. The map editor in SGDK2 includes abilities to select
and place tiles, copy blocks of tiles, easily add and edit sprites and
groups of sprites, and add/edit "plans" which define areas or coordinates
where events happen on the map.
- Sprite Editor: The sprite editing system is very flexible, allowing you
to define any number of states and frames that compose a sprite, and define
rules that determine how the sprite behaves and transitions between its
states. All these rules are based on C# source code which you can edit or
extend by adding new functions of your own design. Samples are included so
you're free to use pre-defined sprite types, customize the rules for
sprites, or get down to the lowest levels by editing the source code on
which the rules are based. All this can be done within the IDE and saved
with your individual project... no re-compiling SGDK2 code is
- High performace graphics: In version 2.0, the games generated by this
program were based on DirectX by default (though a project can theoretically
be customized to use other technologies). The main update with version 2.1
is a switch to using OpenGL as the graphics library of choice. This also
improved performance even more. As such, you get crisp, smooth graphics
performance on systems with adequate hardware support, whether you're
playing in a window of full-screen.
- Real-time transforms: Rather than pre-rendering your sprite with 8
different color schemes at 72 rotations, you can draw the image once and
then adjust the color (to a limited extent) and rotation in a Frameset.
Then if you decide to change your sprite's appearance, you only have to
change the graphic on which it's based, and all variations will be
- Collision Detection: Collisions between sprites and tiles are based on
an optimized algorithm that allows the game to efficiently make a sprite
respond to slopes and walls. Collisions between sprites can either be based
on a user-defined rectangular area within the sprite, or on a collision
mask that is in turn based on a certain level of opacity in the sprite's
graphic. Again this is optimized for reasonable performance with larger
numbers of sprites.
- Animated Tiles: Not only can your sprites be animated, but so can your
backgrounds. You can define a series of frames for each tile value that you
want to animate, and link the tile to a global counter object that defines
how fast the tile is animating (which frame it's displaying). Each
animation can be linked to its own counter, or you can have many or all
tile animations share a common counter.
- Multi-layered Maps: you can create multi-layered parallax-scrolling
maps by adding layers that scroll at different rates horizontally and
- Compiled output: The games generated in this environment are internally
transformed into .NET applications and then compiled to binary executables.
That means they don't rely on runtime processing of script/code, but are
compiled to a form optimized for performance. Furthermore, it's possible to
create entirely self-contained games that generate a single EXE file with
all the data embedded.
- Sound/Music support: The environment includes support for playing OGG,
MP3, MOD and other formats of music and sounds (provided by the third-party
- Scalability: Maps created in SGDK2 can opt to use 1, 2 or 4 bytes per
tile depending on how many types of tiles you intend to support, and
because you can have as little as 1-byte per tile, you can create some very
large maps with very low memory requirements. A map representing more than
a billon pixels of viewable space could be created in under a megabyte
using 32x32-pixel tiles.
For details about what's new in the current release, see the
What's New page. The section below
is mainly an introduction to SGDK2 for users of version 1.x.
Many features have been greatly improved during the total rewrite in .NET
that was done for version 2.0. Here are a few of the more interesting
differences since the last 1.x version.
- Shared Sprite Definitions: Sprite templates no longer have to be
re-defined from scratch for each map. Sprite Definitions, which are the
replacement for most of the features formerly found in a sprite template,
are shared accross the whole project.
- Run Windowed or Full-Screen: The graphics and map editors run in a
window with a much more friendly interface than that found in version 1.x.
But more importantly, the games created in this environment can run either
in full screen or windowed mode.
- Run-time customizable controls: The default project template includes
an options menu that allows the player to customize the controls instead of
requiring the designer to pre-set them.
- Multi-player Support: It's much easier to create multi-player
- Customizable scrolling: Scrolling is no longer hard-linked to the
player sprite. You can design a game that forces the map to automatically
scroll by following an invisible non-player sprite.
- Easier Sprite Placement: You no longer have to create a path for every
sprite, and you no longer have to exit the map editor to add sprites. Now
you can simply select a sprite in the map editor and place it on the map
with a single click like you would a tile.
- Integrated Customization: No more editing VBScript in a separate window
in a separate file. To customize game behavior in SGDK2, use the integrated
code editor, and see your customizations (in C# code) saved as part of the
project. Furthermore, you can not only add your own code now (as you had to
do before), but also edit almost all of the pre-existing code that goes
into generating a running game, giving you much more control over the
overall behavior of a game.
- Build Your Own Sprite Types: You no longer have a limited selection of
sprite types such as "left/right" or "8-direction" sprites to choose from
when creating a new sprite definition. You can import, customize or create
your own sprite types by creating any number of states, and define your own
rules for how they behave. You can do this without even writing any
- PNG support: PNG is now the native graphics format of SGDK2 internally.
This also means that you can have translucent graphics. Instead of only
having transparent or opaque pixels, you can have 255 levels of
- Simplified File Management: Project data is now all embedded into a
single SGDK2 file instead of having a GDP file that references all sorts of
external files. No more confusion when moving projects around or backing
- Sound Support: You now have the ability to play OGG and MOD files. MOD
will be good for compact representations of long pieces of music without
relying on the quality of the sound card's sound table.
- Overlapping Graphics: Your tiles are no longer confined the space they
occupy on the map. You can have graphics of one tile overlapping those of
- Composite Graphics: Your tiles and sprite frames can be composed of
multiple graphics without having to pre-render all the possible
combinations as their own graphics.
- Offsetting Layers: You can now create layers that have a position not
"anchored" to the top left corner of the map. A layer does not have to
cover the entire map, so you can have a layer that just represents some
tiles for a small part of the map.
- Overlay Map: The player's inventory and other features can now be
represented on an "Overlay" map, a map that is drawn in front of the main
map, and generally does not scroll.
- Counters: Instead of "Inventory" a more general-purpose concept of
"Counters" have been introduced as global numeric variables.
- Independent Tile Animation: Tile animation is now linked to a
particular counter instead of an internal global counter, so not all your
animations need to be based on the same value. You can, for example, have a
counter that only switches to a particular value when the player
accomplishes a task, which in turn changes all of tile X to tile Y via the
- New Tile Solidity: You are no longer confined to 6 tile solidity
shapes. 11 shapes are provided by default, (including a new shape that
allows the player to jump upward through a tile and then land on it) and
you can write your own by customizing the code that defines the tile
- Save to Memory: When saving a game to a slot, you no longer have to
write it to a file. The saved game can be stored to a "memory" slot which
only exists for the duration of the game. This is handy for resetting the
game to an initial state without requiring a file.
- Partial Save: You now have some choice about which data you want to
save. You can save just data for the current map or just the counter values
- Collision Detection: In order to give the user more control over the
collision detection process, tests for colliding sprites are now performed
more explicitly. Test for collisions between a specific sprite and all
sprites in a specific category. Also, the collision test can be a simple
rectangular collision test or the fancier pixel/mask-based test.
- Global Tile Categories: You can now include tiles from multiple
tilesets in a single tile category. This allows, for example, a single
sprite definition to treat ladders from different kinds of layers the same
way. A "winter" map might use a "winter" tileset that looks completely
different from the "summer" tileset, yet the player could have rules to
treat them both as ladders.
- Sprite Categories: Sprites can also be categorized now for the purposes
of testing collisions or creating instances of sprites of a particular
- No Tile Matching or Maze Generator Yet: In the interest of getting
SGDK2 into the hands of users as soon as possible, some of the less
critical features are left to a later release.