Free person software for linux

Nexuiz is a fast-paced, chaotic, and intense multiplayer first-person shooter game, focused on providing basic, old style deathmatch.

Nexuiz is extremely modder-friendly. Nexuiz is built on the power of the Darkplaces engine, which is a heavily modified version of the original Quake.

Darkplaces features realtime lighting and stencil shadows, bumpmapping, gloss, bloom, and totally rewritten network code that supports up to 64 players on a single server.

Enemy lines 7 is a single player first person 3d shooter game.

Shoot down enemy bombers threatening your city.

Tilda project is a Linux terminal taking after the likeness of many classic terminals from first person shooter games, Quake, Doom and Half-Life to name a few, where the terminal has no border and is hidden from the desktop till a key or keys is hit.

Sparklet is a multiplayer networking game. Sparklet is multiplatform, real-time, 2D, top-down view, 3rd person space shooting game. It is released under GPL license.

At the moment there are no known bugs, but the game has not been deeply tested yet.

Data::Stag is a Perl module with structured tags datastructures.

SYNOPSIS

# PROCEDURAL USAGE
use Data::Stag qw(:all);
$doc = stag_parse($file);
@persons = stag_find($doc, "person");
foreach $p (@persons) {
printf "%s, %s phone: %sn",
stag_sget($p, "family_name"),
stag_sget($p, "given_name"),
stag_sget($p, "phone_no"),
;
}

# OBJECT-ORIENTED USAGE
use Data::Stag;
$doc = Data::Stag->parse($file);
@persons = $doc->find("person");
foreach $p (@person) {
printf "%s, %s phone:%sn",
$p->sget("family_name"),
$p->sget("given_name"),
$p->sget("phone_no"),
;
}

This module is for manipulating data as hierarchical tag/value pairs (Structured TAGs or Simple Tree AGgreggates).

KBoxes! project is a little mind game.
You can play against another human or the computer. The object is to wipe out boxes from a set of 1, 3, 5, and 7 boxes. The person who wipes the last one loses the game.
Enhancements:
- Now kboxes! can be compiled with the latest QT

Nazghul project is a computer role-playing game (CRPG) engine.

Obviously, the emphasis is not on graphics or first-person squad-based stealth action.

If you like roguelikes or the top-down, 2d, turn-based CRPGs that disappeared in the early 90s then this is for you.

Rose::HTML::Form is a HTML form base class.

SYNOPSIS

package PersonForm;

use Rose::HTML::Form;
our @ISA = qw(Rose::HTML::Form);

use Person;

sub build_form
{
my($self) = shift;

$self->add_fields
(
name => { type => text, size => 25, required => 1 },
email => { type => email, size => 50, required => 1 },
phone => { type => phone },
);
}

sub validate
{
my($self) = shift;

# Base class will validate individual fields in isolation,
# confirming that all required fields are filled in, and that
# the email address and phone number are formatted correctly.
my $ok = $self->SUPER::validate(@_);
return $ok unless($ok);

# Inter-field validation goes here
if($self->field(name)->internal_value ne John Doe &&
$self->field(phone)->internal_value =~ /^555/)
{
$self->error(Only John Doe can have a 555 phone number.);
return 0;
}

return 1;
}

sub init_with_person # give a friendlier name to a base-class method
{
my($self, $person) = @_;
$self->init_with_object($person);
}

sub person_from_form
{
my($self) = shift;

# Base class method does most of the work
my $person = $self->object_from_form(class => Person);

# Now fill in the non-obvious details...
# e.g., set alt phone to be the same as the regular phone
$person->alt_phone($self->field(phone)->internal_value);

return $person;
}

...

#
# Sample usage in a hypothetical web application
#

$form = PersonForm->new;

if(...)
{
# Get query parameters in a hash ref and pass to the form
my $params = MyWebServer->get_query_params();
$form->params($params);

# ...or initialize form params from a CGI object
# $form->params_from_cgi($cgi); # $cgi "isa" CGI

# ...or initialize params from an Apache request object
# (mod_perl 1 and 2 both supported)
# $form->params_from_apache($r);

# Initialize the fields based on params
$form->init_fields();

unless($form->validate)
{
return error_page(error => $form->error);
}

$person = $form->person_from_form; # $person is a Person object

do_something_with($person);
...
}
else
{
$person = ...; # Get or create a Person object somehow

# Initialize the form with the Person object
$form->init_with_person($person);

# Pass the initialized form object to the template
display_page(form => $form);
}
...

Rose::HTML::Form is more than just an object representation of the HTML tag. It is meant to be a base class for custom form classes that can be initialized with and return "rich" values such as objects, or collections of objects.

Building up a reusable library of form classes is extremely helpful when building large web applications with forms that may appear in many different places. Similar forms can inherit from a common subclass, and forms may be nested.

This class inherits from, and follows the conventions of, Rose::HTML::Object. Inherited methods that are not overridden will not be documented a second time here. See the Rose::HTML::Object documentation for more information.