Free aged software for linux

bridged is a user-space alternative to the in-kernel bridge code in Linux. It uses AVL trees to speed lookups. Currently it only offers basic functionality, but if theres interest, I plan to add some more advanced features like access-lists (filtering), SNMP management, telnet console etc.
Bridged doesnt use autoconf/automake yet. If you want to change paths it installs itself to you need to edit Makefile directly. To compile bridged you need flex and GNU avl library (you can download it from http://www.msu.edu/user/pfaffben/avl/) Perfom make and then make install.
By default, bridged looks for its configuration in /etc/bridged.conf, but you can override this by -c argument on command-line. Typical configuration file for making a bridge between two interfaces looks like this:
bridge-group 0
interface eth0
interface eth1
Youll need GNU avl library. For compiling from source RPM, you also need the devel RPM.
Enhancements:
- Aging MAC address table entries implemented.
- Purging MAC address table implemented.
- mac-address-table "aging ", "entries " and "purge-batch " recognized in config file, but no functionality implemented yet.

FAangband is a first age Tolkien-based variant of Angband.
A roguelike game set in the wilderness and dungeons of Middle Earth in the first age. Fight your way through plains, mountains, forests, swamps, deserts and dungeons to face Morgoth, Lord of Darkness. Not a short game.
Here are the big changes:
- Races have been significantly changed. Half-Orcs, Half-Trolls, Half-elves and Shadow Fairies have gone; there are new varieties of Elves, Dwarves and Men. Dwarves as a whole tend to have better Intelligence than Wisdom; the reverse is true for (most) Elves and Hobbits. Different races also have significantly different starting conditions.
- There is wilderness. Wilderness is like and unlike dungeon. On the similar side, it is randomly generated in rectangular pieces; the "level" still only goes up or down by one in going from one piece to the next; there is a structured way of advancing through the wilderness. On the other hand, it looks different (no rooms); there are sometimes choices as to how to advance (north or west, maybe, rather than just down); and tactics become quite different. There are five basic types of wilderness - open plains, dense forests, rocky mountains, harsh deserts and pathless swamps. It also has day and night, which affects light-hating monsters and the players need for light.
- There are multiple towns, small and large, spread throughout the wilderness. Each race starts in its natural town. This means that the starting towns for some races are in the middle of quite dangerous wilderness. In order to reduce extreme effects of this (instant death, or instant growth of 15 levels), some races have improved starting equipment, and several races start with some experience already (advancing them in character level up to a maximum of level 5). High elves are no longer the easy option, at least at first. You can move your house to a different town, but only once you have walked there.
- There are multiple dungeons (five, to be precise). At the bottom of each is a guardian, who can only appear there or in special circumstances (which you may be able to guess...) be summoned. The first specialist ability (and second as well for warriors) is still learned at the beginning, but the two others each become available on killing a dungeon guardian. It is possible to ignore the other dungeons and head straight for Angband, but theres a heavy price to pay.
- Word of Recall works differently. Read away from your home town, it still takes you back there. Read in your home town, you are given a list of up to four points to recall to. When you recall back to town, you get the choice of which of your recall points you wish to update.
- Anything from later than the First Age has been removed. No more Rings of Power, Grishnakh, Anduril, Saruman, Witch-King, etc. There are some new uniques, artifacts and ego-items (and some just renamed). There are also new item sets, and some reworked artifacts.
- There is no savefile compatibility with Oangband or Angband. Savefiles had to change at least to accommodate changes to data structures (particularly the player data), and the big changes to races meant that any translation would be rather artificial. Anyone with an Oangband savefile should keep playing it in Oangband; anyone with an Oangband compatible Angband savefile (version 2.9.1 or older) should be congratulated and, well, upgrade.
Enhancements:
- large reduction in wilderness monsters
- better handling of savefile paths
- increase in wilderness vaults
- some extra dungeon vaults
- several bugfixes

yaDMS provides a PHP-based document management system.
yaDMS (yet another Document Management System) is a PHP-based document management system, with many features like a clipboard, conversion of mail to DMS, conversion from DMS to mail, zip & download, copy, move, multiuser, and full-text searching with support for various document formats.
Main features:
- Multiuser: manage as many users as you want with different "document roots" and read only access
- Create/Delete Folders+Files
- Download whole Folders as a zip archiv
- Copy and Move Files or Folders between the different Folders
- Put files into the clipboard and send them by mail or download them as a zip file
- Receive Mails (each user can define his own pop3 Account) and use filters to put the attached files directly into the right folder
- Search files by age/filesize/location/mime Type
- Change to the "thumbnail-view" to see images in preview

Data::Inherited is a Perl module with hierarchy-wide accumulation of list and hash results.

SYNOPSIS

package Foo;
use base Data::Inherited;
use constant PROPERTIES => (qw/name address/);

package Bar;
use base Foo;
use constant PROPERTIES => (qw/age/);

package main;
my $bar = Bar->new;
print "$_n" for $bar->every_list(PROPERTIES);
prints
name
address
age

This is a mixin class. By inheriting from it you get two methods that are able to accumulate hierarchy-wide list and hash results.

every_list(String $method_name, Bool ?$override_cache = 0)

Takes as arguments a method name (mandatory) and a boolean indicating whether to override the cache (optional, off by default)

Causes every method in the objects hierarchy with the given name to be invoked. The resulting list is the combined set of results from all the methods, pushed together in top-to-bottom order (hierarchy-wise).

every_list() returns a list in list context and an array reference in scalar context.
The result is cached (per calling package) and the next time the method is called from the same package with the same method argument, the cached result is returned.

This is to speed up method calls, because internally this module uses NEXT, which is quite slow. It is expected that every_list() is used for methods returning static lists (object defaults, static class definitions and such). If you want to override the caching mechanism, you can provide the optional second argument. The result is cached in any case.

Tie::Hash::Sorted Perl module presents hashes in sorted order.

SYNOPSIS

use Tie::Hash::Sorted;

my %ages = (
John => 33,
Jacob => 29,
Jingle => 15,
Heimer => 48,
Smitz => 12,
);

my $sort_by_numeric_value = sub {
my $hash = shift;
[ sort {$hash->{$b} $hash->{$a}} keys %$hash ];
};

tie my %sorted_ages, Tie::Hash::Sorted,
Hash => %ages,
Sort_Routine => $sort_by_numeric_value;

for my $name ( keys %sorted_ages ) {
print "$name is $sorted_ages{$name} years old.n";
}

### OUTPUT ###
Heimer is 48 ears old.
John is 33 ears old.
Jacob is 29 ears old.
Jingle is 15 ears old.
Smitz is 12 ears old.

Greenfoot is an integrated development environment that makes it easy to write games and simulations in Java.
It comes with a broad range of demo scenarios and documentation that gets newcomers started very quickly. Greenfoot may be used to learn or teach programming, or just to write a cool game and maybe put it up on a Web site. (it can export the game to a Web page).
The project was originally developed for school age learners, but is now used by all age groups.

Class::Meta is a Perl class automation, introspection, and data validation.

SYNOPSIS

Generate a class:
package MyApp::Thingy;
use strict;
use Class::Meta;
use Class::Meta::Types::String;
use Class::Meta::Types::Numeric;

BEGIN {

# Create a Class::Meta object for this class.
my $cm = Class::Meta->new( key => thingy );

# Add a constructor.
$cm->add_constructor(
name => new,
create => 1,
);

# Add a couple of attributes with generated methods.
$cm->add_attribute(
name => uuid,
authz => Class::Meta::READ,
type => string,
required => 1,
default => sub { Data::UUID->new->create_str },
);
$cm->add_attribute(
name => name,
is => string,
required => 1,
default => undef,
);
$cm->add_attribute(
name => age,
is => integer,
default => undef,
);

# Add a custom method.
$cm->add_method(
name => chk_pass,
view => Class::Meta::PUBLIC,
);
$cm->build;
}
Then use the class:
use MyApp::Thingy;

my $thingy = MyApp::Thingy->new;
print "ID: ", $thingy->id, $/;
$thingy->name(Larry);
print "Name: ", $thingy->name, $/;
$thingy->age(42);
print "Age: ", $thingy->age, $/;
Or make use of the introspection API:
use MyApp::Thingy;

my $class = MyApp::Thingy->my_class;
my $thingy;

print "Examining object of class ", $class->package, $/;

print "nConstructors:n";
for my $ctor ($class->constructors) {
print " o ", $ctor->name, $/;
$thingy = $ctor->call($class->package);
}

print "nAttributes:n";
for my $attr ($class->attributes) {
print " o ", $attr->name, " => ", $attr->get($thingy), $/;
if ($attr->authz >= Class::Meta::SET && $attr->type eq string) {
$attr->get($thingy, hey there!);
print " Changed to: ", $attr->get($thingy), $/;
}
}

print "nMethods:n";
for my $meth ($class->methods) {
print " o ", $meth->name, $/;
$meth->call($thingy);
}

Class::Meta provides an interface for automating the creation of Perl classes with attribute data type validation. It differs from other such modules in that it includes an introspection API that can be used as a unified interface for all Class::Meta-generated classes. In this sense, it is an implementation of the "Facade" design pattern.

Class::Prototyped::Mixin Perl module contains Mixin Support for Class::Prototyped.

SYNOPSIS

Usage one: whip up a class and toss it in a scalar
package HelloWorld;

sub hello {
my ($self, $age) = @_;
return "Hello World! I am $age years old"
}


package HelloWorld::Uppercase;
use base qw(Class::Prototyped);

__PACKAGE__->reflect->addSlot(
[qw(hello superable)] => sub {
my $self = shift;
my $ret = $self->reflect->super(hello, @_);
uc $ret
}
);


package HelloWorld::Bold;
use base qw(Class::Prototyped);

__PACKAGE__->reflect->addSlot(
[qw(hello superable)] => sub {
my $self = shift;
my $ret = $self->reflect->super(hello, @_);
"< b >$ret< /b >";
}
);


package HelloWorld::Italic;
use base qw(Class::Prototyped);

__PACKAGE__->reflect->addSlot(
[qw(hello superable)] => sub {
my $self = shift;
my $ret = $self->reflect->super(hello, @_);
"< i >$ret< /i >";
}
);

# script.pl - now the whipping begins
use Class::Prototyped::Mixin qw(mixin);
my $runtime = mixin(
HelloWorld => HelloWorld::Uppercase, HelloWorld::Italic
);

print $runtime->hello(74);
< i >HELLO WORLD! I AM 74 YEARS OLD< /i >
Usage two: create hierarchy and install in a Class::Prototyped package
package CompileTime;
use Class::Prototyped::Mixin qw(mixin);

my $uclass = mixin(
HelloWorld => HelloWorld::Uppercase, HelloWorld::Bold
);

__PACKAGE__->reflect->addSlot(
* => $uclass
);


# script.pl
use CompileTime;

print CompileTime->hello(88);
< b >HELLO WORLD! I AM 88 YEARS OLD< /b >