Free first person plural software for linux

FIRST DiskImager is an advanced, full-featured GUI disk image acquisition tool.

It was designed for forensic disk image inspection. Developed using C++ and QT. This is our 1st attempt to create an acquisition software to meet the NIST standards.

******** WARNING !!! USE THIS SOFTWARE AT YOUR OWN RISK!!! **************

Ive tested and used the software and it works for me, but there is no guarantee that it will work for you. You can very easily DESTROY DATA IRRECOVERABLY by using this software. Do not even attempt using this software unless you are VERY FAMILIAR with the process of imaging hard drives and other media. While this program is intended to make the imaging
process more convenient, it cannot THINK for you. If you mix up the source and destination targets and accidentally overwrite the original evidence, there is nothing I (or anyone else) can do for you.

DO NOT USE THIS SOFTWARE FOR ACTUAL PRODUCTION OR CASE WORK UNTIL YOU HAVE THOUROUGHLY TESTED IT AND HAVE SATISFIED YOURSELF THAT IT DOES WHAT YOU WANT IT TO DO. I WILL NOT BE RESPONSIBLE FOR UNEXPECTED RESULTS OBTAINED FROM THE USE OF THIS SOFTWARE WHETHER THEY ARE THE RESULT OF PROGRAM BUGS, USER ERROR, HARDWARE FAILURES, OR ACTS OF GOD. AGAIN, IF YOU USE THIS SOFTWARE YOU DO SO AT YOUR OWN RISK AND ASSUME ALL RESPONSIBILITY FOR THE RESULTS.
***************************************************************************

Space Plumber is a first-person 3d game, not much different to Doom and Quake. The main goal of Space Plumber is to reach the extraction pumps before the water level increases swamping everything.
Each of the 30 levels that conform the game have progressive difficulty by adding more pumps and consoles that you must deactivate first, and by making the map bigger. There are no enemies, you fight against time and misorientation, and you only have your skills to move inside the maze.
The 1.1.x series are a port to use the QDGDF library, making it easier to compile in a variety of systems. Its included in the package, so you dont have to download it separately.
Enhancements:
- Space Plumber has been ported to use the QDGDF library, so its compilable in a wider variety of platforms and has some new features.
- The most important new feature is sound support under Linux.
- The game itself is exactly the same.

Persistent::LDAP is a persistent class implemented using a LDAP directory.

SYNOPSIS

use Persistent::LDAP;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $person =
new Persistent::LDAP(localhost, 389,
cn=Directory Manager, test1234,
ou=Engineering,o=Big Snow Org,c=US);

### declare attributes of the object ###
$person->add_attribute(uid, ID, String);
$person->add_attribute(userpassword, Persistent, String);
$person->add_attribute(objectclass, Persistent, String);
$person->add_attribute(givenname, Persistent, String);
$person->add_attribute(sn, Persistent, String);
$person->add_attribute(cn, Persistent, String);
$person->add_attribute(mail, Persistent, String);
$person->add_attribute(telephonenumber, Persistent, String);

### query the datastore for some objects ###
$person->restore_where(& (objectclass=person)(mail=*bigsnow.org),
sn, givenname);
while ($person->restore_next()) {
printf("name = %s, email = %sn",
$person->givenname . . $person->sn,
$person->mail);
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses a LDAP directory to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.

Tactical Operations: Crossfire is a tactical shooter based on Unreal Tournament 2004.

Tactical Operations: Crossfire is a fast paced first person online shooter in which two teams, terrorists and special forces, duke it out in a wide variety of environments with various objectives to accomplish. From rescuing hostages kept in a small desert town in Saudi-Arabia to preventing the bombing of an oil refinery on the Caspian sea shore. There are no less than fourteen official maps to choose from!

Each map is played for a certain amount of time and the team having won the most rounds when the time runs out is declared the winner. A round can be won either by completing the objective set for that team, such as rescueing the hostages, or by simply eliminating all players on the opposite team.

A large number of weapons is avaialable for both teams, which can be purchased by each player at the start of the round. Out of the thirty weapons currently available, theres bound to be a weapon to suit your style of playing, be it either up close and personal with the Benelli Nova tactical shotgun or sneaky sniper work with the Dragunov SVD.

Tactical Operations: Crossfire continues where the popular Tactical Ops: Assault on Terror left off, with many classic weapons returning and remakes of some of the original maps. To play TO:C, you will need Unreal Tournament 2004 installed and patched to the latest version (3369). Tactical Ops: Crossfire can be played on Windows, Linux and Mac systems.

Asteroids3D is a 3D FPS game of blowing up asteroids.
The object of the game is to stay alive and destroy all the asteroids in the asteroid field.
To view the available command line options type:
asteroids3D -help
Installation:
Unfortunately theres no configure script for this program yet. If you have installed mesa3d in some place other than /usr/local/opengl, you should edit the INC and LIB lines of the make file and change them appropratly. Other than that, A3D should compile without a problem. Type make.
If you want to install the program somewhere else, copy the asteroids3D binary, *.ppm, and *.ub to a directory of your choice.
Enhancements:
- This release fixes compilation when -DDATADIR or the enhanced LDFLAGS line are used.
- An extended debugging grid and spherical/tetrahedronal bounding boxes for asteroids have been added.
- The view depth has been increased.

Template::Simple is a simple and fast template module.

SYNOPSIS

use Template::Simple;

my $tmpl = Template::Simple->new();

my $template = Jan 1, 2008,
author => Me, myself and I,
},
row => [
{
first => row 1 value 1,
second => row 1 value 2,
},
{
first => row 2 value 1,
second => row 2 value 2,
},
],
footer_data => {
modified => Aug 31, 2006,
},
} ;

my $rendered = $tmpl->render( $template, $data ) ;

Template::Simple has these goals:

Support most common template operations

It can recursively include other templates, replace tokens (scalars), recursively render nested chunks of text and render lists. By using simple idioms you can get conditional renderings.
Complete isolation of template from program code

This is very important as template design can be done by different people than the program logic. It is rare that one person is well skilled in both template design and also programming.
Very simple template markup (only 4 markups)

The only markups are INCLUDE, START, END and token. See MARKUP for more.

Easy to follow rendering rules

Rendering of templates and chunks is driven from a data tree. The type of the data element used in an rendering controls how the rendering happens. The data element can be a scalar or scalar reference or an array, hash or code reference.

Efficient template rendering

Rendering is very simple and uses Perls regular expressions efficiently. Because the markup is so simple less processing is needed than many other templaters. Precompiling templates is not supported yet but that optimization is on the TODO list.

Easy user extensions

User code can be called during an rendering so you can do custom renderings and plugins. Closures can be used so the code can have its own private data for use in rendering its template chunk.

Trepidation is a first-person person shooter based on the IOQ3 engine.

Trepidation is a first person shooter set in the future based on the GPL IOQ3 Quake Engine. Trepidation features all new weapons, maps and vehicles.. Currently planned game types are Deathmatch, Team Deathmatch, Capture The Flag, Last Man Standing, Arsenal, Instagib and a few others to be announced.

Trepidation intends to be a 100% free GPL multiplayer first person shooter based on the IOQ3 Quake 3 Engine. The game media will also be GPL/Open Source so that others can improve and expand upon. Trepidation will include many standard gametypes such as DM, TDM, and CTF with instagib options, as well as the introduction 2-4 new gametypes. Each game mode will have additional attributes that can be activated via the configuration such as wall jumping, double/multijumping, instagib,multiflag and return the flag (for flag based games).

Trepidation will introduce new aspects to the physics of the Q3 engine, The new physics are geared towards trick jumping with weapons and high speed jumping. Trepidation also introduces air and land vehicles, something that hasnt been seen in similar projects. Trepidation will also include an improved unlagged network code based on unlagged 2.0 but more finely tuned to the new physics present.

The project will utilize a modified version of the GPL dpmaster for the master server code base.

The game will have ports for *nix, *BSD, Win32 and possibly an OSX port. OpenAL will be used for sound. Surround sound supported. AVI video capture of demos, Ogg Vorbis & MP3 support. Much improved QVM tools and a well documented SDK for mod authors. MinGW compilation support on Windows and cross-compilation on Linux, which is already included in the IOQ3 Project.