Free 2d game software for linux

JGame is a small high-level 2D game engine for producing games on Java platforms. It does a lot of the stuff you need for a game automatically, and "classic" type arcade games can be developed with a minimum of effort.
It is based on sprites with automatic collision detection, and a tile-based background with easy sprite-tile interaction facilities. JGame games can easily be run as stand-alone applications or as applets, and can be scaled to any resolution.
Main features:
- Tested on various platforms; can easily be run as applet as well.
- Ensures optimised and accelerated graphics for a variety of displays; even works well on remote X11 displays.
- The game is programmed at one resolution, but can be scaled to any desired resolution when run.
- Built-in animated "sprite" engine, with easy animation definition.
- Tile-based background handling, with decorative backdrop.
- Automatic collision detection with sprites and background tiles, and easy background tile interaction.
- Load sprites, tiles, and colour fonts directly from sprite sheets.
- Define images and animations in a text file.
Enhancements:
- New platform-independent versions of Point, Rectangle, Color, Font.
- Changes in package structure. Base classes are now in jgame, platform independent implementation details in jgame.impl, platform dependent classes in jgame.platform.
- Major changes in JGEngine/JGCanvas. A platform independent interface JGEngineInterface has been defined. The platform-independent code has been moved to jgame.impl.*, and for each platform there is a platform-dependent version of JGEngine, delegating functionality to jgame.impl.EngineLogic where possible.
- ImageUtil has been split into a platform-independent interface JGImage, and platform implementations JREImage and MIDPImage.
- StdGame now has two versions, the original for JRE and a somewhat simplified version for MIDP.
- The package tree has been changed. The sources are now in src-*, classes are compiled into classes-*. Compilation of the JGame classes and the examples and applications has been split.
- The code has been optimised: object creations in the most important tight loops have been reduced to near zero, repaintBG has been optimised by a factor 2, isOnPF/isInView were optimised.
- a small bug in background copying where the area bounds would exceed the size of the source image was fixed.
- A few methods were added specifically for use the Midlet platform, such as isMidlet(), displayWidth/Height(), setScalingPreferences().
- setCursor has been renamed to SetMouseCursor.
- there is a new engine getTiles method that copies the data into an existing object. Semantics of the getTiles methods in JGObject have been changed to return a local variable with the information copied into it, rather than create an object every time. Semantics of some other methods such as getImage is changed so as not to create a new object every time.
- fixed bug in exitEngine which did not set the JGObject default_engine to null
- fixed access exception occurring in unsigned webstart.
- improved frame skip logic so that game runs smoothly even if the machine is way too slow

Epiphany project is a multiplatform clone of the game Boulderdash.

It is written entirely in C++, using Clanlib as its graphic library.

The player must collect all valuable minerals scattered in levels, while avoiding being hit by a falling boulder or a bomb.

Advanced game library project is a library designed to ease game development.
It uses the SDL library and provides 2D graphical functions, sound streaming and events functions, video streaming, AI engines, and map generator.
This software is primarily designed for LINUX.
This SDK uses the SDL library for the bitmap, sound and events system. SDL provides accelerated and portable interfaces for the video and sound hardware.
The abstraction of the low level layer makes possible the extension of adgali to other low level libraries like Allegro or GGI.
This library tends to provide useful functions for bitmap and sprite display, game GUI, game sound events and music stream , network management and video streaming.
Well, only a subset of these features are implemented for now.
Main features:
- underlying library:
- SDL
- General features:
- The library is thread safe and reentrant
- Error management system: adgali provides a system to trace the origin of an error
- Unified data streaming system: memory, files, network or archives are simple to manage and can provide the game datas
- A modular conception for the loaders (streaming system, images, fonts ...)
- A memory leak detection system
- A postmortem backtracing system
- A general parser for a general treatment of the configuration files and scripts (in the spirit of the GTK+ description files).
- All major features are designed as modules integrated with a general engine
- a dynamic loading system of modules or third part libraries (work in progress)
- A cache system is designed for all objects to accelarate object loading
- 2D graphics features are:
- 32 bits pictures management: 24 bits of colour, 8 bits of alpha
- image loading: support BMP, PCX, GIF, TGA, JPG, PNG, PPM, PNM, PGM, TIFF, XCF, XPM image formats
- unified fonts management: true type fonts (TTF using freetype 2) and bitmap fonts ( an image file and a text description file)
- Color separation, modification and combination for an image (RGB, green level, CMY and HSV)
- zone filling, copying, tiling, clipping with optionnal rotation and mirror
- color filling, mask-ing, key color alpha channel treatment
- lines drawing with clipping functions
- Graphical user interface:
- a tree organized bitmap hierarchy with an automatic refresh system to the viewport
- basic string printing

Games::Console Perl module provide a 2D quake style in-game console.

SYNOPSIS

use Games::Console;

my $console = Games::Console->new(
font => $font_object,
background_color => [ 1,1,0],
background_alpha => 0.4,
text_color => [ 1,1,1 ],
text_alpha => 1,
speed => 50, # in percent per second
height => 50, # fully opened, in percent of screen
width => 100, # fully opened, in percent of screen
backbuffer_size => 100, # keep so many messages
prompt => >,
cursor => _,
);

$console->screen_width($width);
$console->screen_height($height);
$console->toggle($current_time);
$console->message(Hello there!);
$console->input(a);

This package provides you with a quake-style console for your games. The console gathers messages and lets you scroll trough them. It also can display a command line.

This package is just a base class setting up everything, but doesnt actually render anything.

See Games::Console::SDL and Games::Console::OpenGL for subclasses that implement the actual rendering to the screen via SDL and OpenGL, respectively.

JGachine project is a Java game machine/engine/browser.
JGachine is a networked game engine for 2D multi-player (networked) games.
It is written in Java and C++.
The games themselves are written in pure Java and can be loaded via the network.
Main features:
- easy game programing for beginners
- a game machine/engine/browser
- one client for multiple games
- you only write the game server (though the server may send bytecode to the client)
- secure client (though executing bytecode from the server
- writing multiplayer networked games within 2 hours
- portable
- try to allow output device independent games
- device independent coordinates
- help with different/changing aspect ratios

Crate Game Engine is a game engine that is designed to make the process of creating games trivial.
The rendering engine and scripting engine are removed from the game engine to make the specialization of games as easy as possible.
An XML game loader will be implemented to make creating games require no recompiling.
Extremely easy to use game engine with modular Scripting and Rendering engines.
Milestones:
Milestone 1: Basic framework compilable (completed Oct 9, 2005)
Milestone 2: C++ proof of concept demo using framework & text based RenderingEngine
Milestone 3: XML based game loader with Milestone 2 game ported to it
Milestone 4: Scripting support with Milestone 3 game ported to it
Milestone 5: 2D Rendering Engine with Milestone 4 game ported to it
Enhancements:
- This release includes minor API and documentation updates, as well as a logging system.

Games::OpenGL::Font::2D module can load/render 2D colored bitmap fonts via OpenGL.

SYNOPSIS

use Games::OpenGL::Font::2D;

my $font = Games::OpenGL::Font::2D->new(
file => font.bmp );

use SDL::App::FPS;

my $app = SDL::App::FPS->new( ... );

# dont forget to change these on resize events!
$font->screen_width( $app->width() );
$font->screen_height( $app->width() );

$font->pre_output(); # setup rendering for font

$font->color( [ 0,1,0] ); # yellow as array ref
$font->color( 1,0,0 ); # or red
$font->alpha( 0.8 ); # nearly opaque

# half-transparent, red
$font->output (100,100, Hello OpenGL!, [ 1,0,0], 0.5 );
# using the $fonts color and alpha
$font->output (100,200, Hello OpenGL! );

$font->transparent( 1 ); # render font background transparent

$font->spacing_y( 16 ); # render vertical (costly rebuild!)
$font->spacing_x( 0 ); # (costly rebuild!)
$font->output (100,200, Hello OpenGL! );

$font->post_output(); # if wanted, you can reset OpenGL

EXPORTS

Exports nothing on default. Can export on demand the following:

FONT_ALIGN_LEFT
FONT_ALIGN_RIGHT
FONT_ALIGN_CENTER
FONT_ALIGN_TOP
FONT_ALIGN_BOTTOM