Free water features garden software for linux

Packet Garden is a project that allows you to grow a world from network traffic.

Packet Garden captures information about how you use the internet and uses this stored information to grow a private world you can later explore.

To do this, Packet Garden takes note of all the servers you visit, their geographical location and the kinds of data you access.

Uploads make hills and downloads valleys, their location determined by numbers taken from internet address itself.

The size of each hill or valley is based on how much data is sent or received.

Plants are also grown for each protocol detected by the software; if you visit a website, an HTTP plant is grown. If you share some files via eMule, a Peer to Peer plant is grown, and so on.

zengarden is a tool that watches over the installation and building of source archives. It is a fork of installwatch that has been heavily updated with modern features.
It can prevent build tools from interfering with files outside the build directory and create a virtual chroot to perform installations in or backup the files the install overwrites.
Installation
Installwatch has been tested on Linux only.
Before compiling, you can edit the Makefile and change the PREFIX variable. Common values are `/usr and `/usr/local.
To compile it, a simple `make followed by `make install should do the magic.
You need an ELF system, but I dont think its a problem today...
If you want to try installwatch on itself for the first time, do the following instead of `make install.
Bash family:
LD_PRELOAD=./installwatch.so make install
Tcsh family:
setenv LD_PRELOAD ./installwatch.so ; make install
Of course, you must be root in the installwatch source directory.
Remember, if you belong to the tcsh family, LD_PRELOAD will remain set after `make install, so be sure to clear the variable.
Enhancements:
- autoolized - at least for the most part
- minor bug fixes
- viewcvs (not really a feature in the tarball) - thx to sofar

Gimp::Feature is a Perl module that can check for specific features to be present before registering the script.

SYNOPSIS

use Gimp::Feature;
or
use Gimp::Feature qw(feature1 feature2 ...);

This module can be used to check for specific features to be present. This can be used to deny running the script when neccessary features are not present. While some features can be checked for at any time, the Gimp::Fu module offers a nicer way to check for them.

gtk

checks for the presence of the gtk interface module.

gtk-1.1, gtk-1.2

checks for the presence of gtk-1.1 (1.2) or higher.

perl-5.005

checks for perl version 5.005 or higher.

pdl

checks for the presence of a suitable version of PDL (>=1.9906).

gnome

checks for the presence of the Gnome-Perl module.

gtkxmhtl

checks for the presence of the Gtk::XmHTML module.

unix

checks wether the script runs on a unix-like operating system. At the moment, this is every system except windows, macos, os2 and vms.

persistency

checks wether the Gimp::Data module (Gimp::Data) can handle complex persistent data structures, i.e. perl references in addition to plain strings.

The following features can only be checked after Gimp-main> has been called (usually found in the form exit main). See Gimp::Fu on how to check for these.
gimp-1.1, gimp-1.2

checks for the presense of gimp in at least version 1.1 (1.2).

FUNCTIONS

present(feature)

Checks for the presense of the single feature given as the argument. Returns true if the feature is present, false otherwise.

need(feature,[function-name])

Require a specific feature. If the required feature is not present the program will exit gracefully, logging an appropriate message. You can optionally supply a function name to further specify the place where this feature was missing.

This is the function used when importing symbols from the module.

missing(feature-description,[function-name])

Indicates that a generic feature (described by the first argument) is missing. A function name can further be specified. This function will log the given message and exit gracefully.

describe(feature)

Returns a string describing the given feature in more detail, or undef if there is no description for this feature.

list()

Returns a list of features that can be checked for. This list might not be complete.

Habitat from System Garden is a performance monitor of applications and operating system with the ability to track availability and service level. System Garden Habitats design goals are to be of modest size, flexible and ubiquitous.

The core of habitat provides a mechanism for collecting, storing and distributing data. Out of the box are many useful system collectors, known as probes.

Additionally, there is an API available to extend the collector (known as clockwork) with plug-ins, which allows data to be pulled from applications. Another API and a command line interface lets applications and scripts of all types push information into the collection system.

Lingua::Phonology::Features is a module to handle a set of hierarchical features.

SYNOPSIS

use Lingua::Phonology;

my $phono = new Lingua::Phonology;
my $features = $phono->features;

# Add features programmatically
$features->add_feature(
Node => { type => privative, children => [Scalar, Binary, Privative] },
Scalar => { type => scalar },
Binary => { type => binary },
Privative => { type => privative }
);

# Drop features
$features->drop_feature(Privative);

# Load feature definitions from a file
$features->loadfile(phono.xml);

# Load default features
$features->loadfile;

Lingua::Phonology::Features allows you to create a hierarchy of features of various types, and includes methods for adding and deleting features and changing the relationships between them.

By "heirarchical features" we mean that some features dominate some other features, as in a tree. By having heirarchical features, it becomes possible to set multiple features at once by assigning to a node, and to indicate conceptually related features that are combined under the same node. This module, however, does not instantiate values of features, but only establishes the relationships between features.

Lingua::Phonology::Features recognizes multiple types of features. Features may be privative (which means that their legal values are either true or undef), binary (which means they may be true, false, or undef), or scalar (which means that their legal value may be anything). You can freely mix different kinds of features into the same set of features.

Finally, while this module provides a full set of methods to add and delete features programmatically, it also provides the option of reading feature definitions from a file. This is usually faster and more convenient. The method to do this is "loadfile". Lingua::Phonology::Features also comes with an extensive default feature set.

Garden is a dependency injection for PHP5.

Inspired by Spring Framework, it uses XML application context with syntax as similar as possible to Spring context definitions.

Kickstarter

Create example.xml file like this (dont forget to put garden-beans.dtd next to it!):

< ?xml version="1.0" encoding="UTF-8"? >
< !DOCTYPE beans PUBLIC "-//GARDEN//DTD BEAN//EN" "garden-beans.dtd" >
< beans default-lazy-init="true" >

< bean id="dog" class="Dog" file="ext/Dog.php" >
< property name="collar" >
< ref local="dogCollar"/ >
< /property >
< /bean >

< bean id="dogCollar" class="Collar" file="ext/Dog/Collar.php" >
< property name="spiked" value="true"/ >
< /bean >

< /beans >

etx/Dog.php contains:
class Dog
{
private $collar;
public function setCollar($collar)
{
$this->collar = $collar;
}
public function getCollar()
{
return $this->collar;
}
}

etx/Dog/Collar.php contains:
class Collar
{
private $spiked;
public function setSpiked($spiked)
{
$this->spiked = $spiked;
}
public function getSpiked()
{
return $this->spiked;
}
}

Bio::DB::GFF::Feature is a relative segment identified by a feature type.

Bio::DB::GFF::Feature is a stretch of sequence that corresponding to a single annotation in a GFF database. It inherits from Bio::DB::GFF::RelSegment, and so has all the support for relative addressing of this class and its ancestors. It also inherits from Bio::SeqFeatureI and so has the familiar start(), stop(), primary_tag() and location() methods (it implements Bio::LocationI too, if needed).

Bio::DB::GFF::Feature adds new methods to retrieve the annotations type, group, and other GFF attributes. Annotation types are represented by Bio::DB::GFF::Typename objects, a simple class that has two methods called method() and source(). These correspond to the method and source fields of a GFF file.

Annotation groups serve the dual purpose of giving the annotation a human-readable name, and providing higher-order groupings of subfeatures into features. The groups returned by this module are objects of the Bio::DB::GFF::Featname class.

Bio::DB::GFF::Feature inherits from and implements the abstract methods of Bio::SeqFeatureI, allowing it to interoperate with other Bioperl modules.
Generally, you will not create or manipulate Bio::DB::GFF::Feature objects directly, but use those that are returned by the Bio::DB::GFF::RelSegment->features() method.
Important note about start() vs end()

If features are derived from segments that use relative addressing (which is the default), then start() will be less than end() if the feature is on the opposite strand from the reference sequence. This breaks Bio::SeqI compliance, but is necessary to avoid having the real genomic locations designated by start() and end() swap places when changing reference points.

To avoid this behavior, call $segment->absolute(1) before fetching features from it. This will force everything into absolute coordinates.

For example:

my $segment = $db->segment(CHROMOSOME_I);
$segment->absolute(1);
my @features = $segment->features(transcript);

Dirty Water project is a custom MUD server.
Dirty Water is an original MUD server/engine written in OCaml.
It is designed to be much more advanced and realistic and to encourage role playing more than Diku-style MUDs.
We are using a higher level language which we feel will yield a code-base that is significantly easier to modify, maintain and understand.
We felt that OCaml would make a good choice for this language, though we have since decided Scheme would be a better choice.
All of our code is licensed under the GNU GPL.
Enhancements:
- can pick up items
- can view inventory
- you can specify 1st, 2nd, etc when refering to items
- cant pick up buildings or yourself
- dont see yourself in room descriptions