Free one tree hill software for linux

King of the Hill project is a full client/server multiplayer artillery game in the scorched earth tradition.
King of the Hill (KOTH) is an artillery game in the grand old tradition of little tanks with ridiculously powerful weapons trying to blow each other up while trying to avoid getting blown up themselves.
Koth features LibGGI for fast portable graphics, full client/server multiplayer, a few cool weapons, in-game chat, and nice terrain generation algorithm.
Open source in the hopes that others will help out and make this a really great game.
Main features:
- Supports up to ten players at once, with unlimited observers (ten only because beyond that the game would get unwieldy, not an architectural limitation)
- Players can join and leave at any time without disrupting the game
- Pregame and In-game color-coded chat
- Buy and sell various types of neat weapons to use against your enemies
- Fractal-tessalation terrain generating algorithm produces endless variations of interesting terrain (before you start blowing massing craters into it that is
- Falling dirt and falling damage to tanks
- Lightweight, asynchronous networking protocol - perfectly playable on a modem over the Internet even with high pingtime
- LibGGI for portable graphics. Currently supports 8/15/16/24/32 bits per pixel in any resolution
- Free software so anyone can and is encouraged to add in their own favorite weapons, equipment, and other features.
Enhancements:
- kick (through server console)
- new weapons: black hole, laser, dirt curtain, dirt vaporizer and depth charge
- infinite number of observers
- new status area in battle window (nickname/armor/shield)
- readiness indication in pregame
- new "who already fired" ingame bar
- bugfixes and other misc changes (weapons price, power, behavior etc)
- weapons name in death messages
- New explosions
- Koth is now playable on fast computers (sleep in animations)

mod_domaintree is a hostname to filesystem mapper for Apache2. It maps host names like www.example.com to a filesystem tree like $prefix/com/example/www/$suffix.
mod_domaintree module can optionally strip the www prefix of host names.
Enhancements:
- The suexec hook and DomainTreeSuexec directory configuration directive were added.
- "make clean" was fixed.

Bio::Tree::Tree is an implementation of TreeI interface.

SYNOPSIS

# like from a TreeIO
my $treeio = new Bio::TreeIO(-format => newick, -file => treefile.dnd);
my $tree = $treeio->next_tree;
my @nodes = $tree->get_nodes;
my $root = $tree->get_root_node;

This object holds handles to Nodes which make up a tree.

AJAX Tree Control is a modified version of SilverStripes tree control. It adds dynamic loading of child nodes via AJAX.

The default implementation uses the prototype library to make dynamic requests, but this behavior can be overridden by setting functions on the global Tree object.

There are a few demo Ruby on Rails applications included in the distribution that show how to use and customize the tree.

GGTL is a library designed to make it easier to program games in C. Generic Game-Tree Library provides an AI that is able to play most 2 player strategic games.
Nim, Tic-Tac-Toe, Reversi (aka Othello), Connect-4 and Chess are all examples of games that can all be implemented using GGTL.
GGTL comes with game-specific extensions that enables it to play Nim and Reversi almost out of the box. Please see the documentation for details.
Enhancements:
- "clock()" is used as a fallback for sub-second timing if "gettimeofday()" is not found.
- An internal typedef was dropped, and a header declaration for a function that didnt exist was removed.
- Some build system refactoring was done.

B::Tree is a simplified version of B::Graph for demonstration.

SYNOPSIS

perl -MO=Tree program | dot -Tps > tree.ps

This is a very cut-down version of B::Graph; it generates minimalist tree graphs of the op tree of a Perl program, merely connecting the op nodes and labelling each node with the type of op.

It was written as an example of how to write compiler modules for "Professional Perl", but Ive found it extremely useful for creating simple op tree graphs for use in presentations on Perl internals.

It requires the CPAN GraphViz module and the GraphViz package from http://www.research.att.com/sw/tools/graphviz/. It takes no options.

Bio::NEXUS::TreesBlock is a Perl module that represents TREES block of a NEXUS file.

SYNOPSIS

if ( $type =~ /trees/i ) {
$block_object = new Bio::NEXUS::TreesBlock( $block_type, $block, $verbose );
}

If a NEXUS block is a Trees Block, this module parses the block and stores the tree data.

METHODS

new

Title : new
Usage : block_object = new Bio::NEXUS::TreesBlock($block_type, $commands, $verbose );
Function: Creates a new Bio::NEXUS::TreesBlock object and automatically reads the file
Returns : Bio::NEXUS::TreesBlock object
Args : type (string), the commands/comments to parse (array ref), and a verbose flag (0 or 1; optional)

clone

Title : clone
Usage : my $newblock = $block->clone();
Function: clone a block object (shallow)
Returns : Block object
Args : none

set_trees

Title : set_trees
Usage : $block->set_trees($trees);
Function: Sets the list of trees (Bio::NEXUS::Tree objects)
Returns : none
Args : ref to array of Bio::NEXUS::Tree objects

add_tree

Title : add_tree
Usage : $block->add_tree($tree);
Function: Add trees (Bio::NEXUS::Tree object)
Returns : none
Args : a Bio::NEXUS::Tree object

add_tree_from_newick

Title : add_tree_from_newick
Usage : $block->add_tree_from_newick($newick_tree, $tree_name);
Function: Add a tree (Bio::NEXUS::Tree object)
Returns : none
Args : a tree string in newick format and a name for the tree (scalars)

get_trees

Title : get_trees
Usage : $block->get_trees();
Function: Gets the list of trees (Bio::NEXUS::Tree objects) and returns it
Returns : ref to array of Bio::NEXUS::Tree objects
Args : none

get_tree

Title : get_tree
Usage : $block->get_tree($treename);
Function: Gets the first tree (Bio::NEXUS::Tree object) that matches the name given or the first tree if $treename is not specified. If no tree matches, returns undef.
Returns : a Bio::NEXUS::Tree object
Args : tree name or none

set_translate

Title : set_translate
Usage : $block->set_translate($translate);
Function: Sets the hash of translates for nodes names
Returns : none
Args : hash of translates

translate

Title : translate
Usage : $self->translate($num);
Function: Translates a number with its associated name.
Returns : integer or string
Args : integer
Method : Returns the name associated with that numbers translated name.
If it cant find an association, returns the number.

reroot_tree

Title : reroot_tree
Usage : $block->reroot_tree($outgroup,$root_position, $treename);
Function: Reroot a tree using an OTU as new outgroup.
Returns : none
Args : outgroup name, the distance before the root position and tree name

reroot_all_trees

Title : reroot_all_trees
Usage : $block->reroot_all_trees($outgroup, $root_position);
Function: Reroot all the trees in the treesblock tree. use an OTU as new outgroup
Returns : none
Args : outgroup name and root position

rename_otus

Title : rename_otus
Usage : $block->rename_otus(%translation);
Function: Renames nodes based on a translation hash
Returns : none
Args : hash containing translation (e.g., { old_name => new_name} )
Comments: nodes not included in translation hash are unaffected

select_otus

Name : select_otus
Usage : $nexus->select_otus(@otunames);
Function: select a subset of OTUs
Returns : a new nexus object
Args : a ref to array of OTU names

select_tree

Name : select_tree
Usage : $nexus->select_tree($treename);
Function: select a tree
Returns : a new nexus object
Args : a tree name

select_subtree

Name : select_subtree
Usage : $nexus->select_subtree($inodename);
Function: select a subtree
Returns : a new nexus object
Args : an internal node name for subtree to be selected

exclude_subtree

Name : exclude_subtree
Usage : $nexus->exclude_subtree($inodename);
Function: remove a subtree
Returns : a new nexus object
Args : an internal node for subtree to be removed

equals

Name : equals
Usage : $nexus->equals($another);
Function: compare if two NEXUS objects are equal
Returns : boolean
Args : a NEXUS object