Free forests software for linux

HLA Adventure is an adventure game that was written in Randy Hydes HLA language.
It features Mippy, a cute dragon that lives happily in the forests and caves and often comes out during the later part of the day to eat leaves, smoulder decaying trees, and generally romp around like every good dragon should.
Enhancements:
- Bugfixes were made to a couple of rooms, including the cave under the forest and near the mansion.

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

Deathchase 3D project is a remake of the Spectrum arcade game of the same name.

Deathchase 3D is a remake of the Spectrum game of the same name, which is itself based on the sequence in "Return of the Jedi" chasing Stormtroopers through the forests of Endor on light-speeders.

Its a fake perspective 3D game: avoid the trees and shoot the bad guys ahead of you. It uses the SDL library.

It is written for Linux but should run on anything SDL supports.

Vallheru is a turn-based, fantasy MMORPG written in PHP and MySQL (but may work with many other databases) with Smarty Template Engine, ADOdb, and PHP Mailer.
It is based on Gamers-Fusion 2.5 with many modifications in security, speed, and features. Vallheru is currently available only in Polish.
Whats New in 1.3 Beta Development Release:
- This version contains many changes in the game interface making it simpler to mine and explore forests and mountains.
- Some new features were added, such as the ability for players to add their own links to the menu and to report bugs while in the game.
- Additionally, this release has a new quest, a few changes in game mechanics (especially alchemy and mage items and spells).
- For administrators, some security and normal bugs were fixed, some code optimization was done, and new versions of third-party software are used.
Whats New in 1.0.9 Stable Release:
- BUG,train.php: fixed bug with train condition
- BUG,languages/pl/checkexp.php: fixed bug in text
- BUG,landfill.php, bank.php, outposts.php, tribes.php, house.php, tribearmor.php, tribeware.php, includes/head.php: fixed possible integer overflow

Bifrost is a firewall management interface to iptables (iptables GUI). The system is inspired by Checkpoint and Watchguard firewall management. We looked at the way Checkpoint works with source, destination, action and logging. At the same time, we are managing incoming and outgoing traffic in a similar way as Watchguard and PIX Firewalls.

B::Graph is a Perl compiler backend to produce graphs of OP trees.

SYNOPSIS

perl -MO=Graph,-text prog.pl >graph.txt

perl -MO=Graph,-vcg prog.pl >graph.vcg
xvcg graph.vcg

perl -MO=Graph,-dot prog.pl | dot -Tps >graph.ps

This module is a backend to the perl compiler (B::*) which, instead of outputting bytecode or C based on perls compiled version of a program, writes descriptions in graph-description languages specifying graphs that show the programs structure. It currently generates descriptions for the VCG tool (http://www.cs.uni-sb.de/RW/users/sander/html/gsvcg1.html) and Dot (part of the graph visualization toolkit from AT&T: http://www.research.att.com/sw/tools/graphviz/). It also can produce plain text output (which is more useful for debugging the module itself than anything else, though you might be able to make cut the nodes out and make a mobile or something similar).

OPTIONS

Like any other compiler backend, this module needs to be invoked using the O module to run correctly:

perl -MO=Graph,-opt,-opt,-opt program.pl
OR
perl -MO=Graph,-opt,obj -e BEGIN {$obj = ["hi"]}; print $obj
OR EVEN
perl -e use O qw(Graph -opt obj obj); print "hi!n";

Obj is the name of a perl variable whose contents will be examined. It cant be a my() variable, and it shouldnt have a prefix symbol ($@^*), though you can specify a package -- the name will be used to look up a GV, whose various fields will lead to the scalar, array, and other values that correspond to the named variable. If no object is specified, the whole main program, including the CV that points to its pad, will be displayed.

Each of the the opts can come from one of the following (each set is mutually exclusive; case and underscores are insignificant):

-text, -vcg, -dot

Produce output of the appropriate type. The default is -text, which isnt useful for much of anything (it does draw some nice ASCII boxes, though).

-addrs, -no_addrs

Each of the nodes on the graph produced corresponds to a C structure that has an address and includes pointers to other structures. The module uses these addresses to decide how to draw edges, but it makes the graph more compact if they arent printed. The default is -no_addrs.

-compile_order, -run_order

The collection of OPs that perl compiles a script into has two different layers of structure. It has a tree structure which corresponds roughly to the synactic nesting of constructs in the source text, and a roughly linked-list representation, essentially a postorder traversal of this tree, which is used at runtime to decide what to do next. The graph can be drawn to emphasize one structure or the other. The former, compile_order, is the default, as it tends to lead to graphs with aspect ratios close to those of standard paper.

-SVs, -no_SVs

If OPs represent a programs compiled code, SVs represent its data. This includes literal numbers and strings (IVs, NVs, PVs, PVIVs, and PVNVs), regular arrays, hashes, and references (AVs, HVs, and RVs), but also the structures that correspond to individual variables (special HVs for symbol tables and GVs to represent values within them, and special AVs that hold my() variables (as well as compiler temporaries)), structures that keep track of code (CVs), and a variety of others. The default is to display all these too, to give a complete picture, but if you arent in a holistic mood, you can make them disappear.

-ellipses, -rhombs

The module tries to give the nodes representing SVs a different shape from those of OPs. OPs are usually rectangular, so two obvious shapes for SVs are ellipses and rhombuses (stretched diamonds). This option currently only makes a difference for VCG (ellipse is the default).

-stashes, -no_stashes

The hashes that perl uses to represent symbol tables are called stashes. Since every GV has a pointer back to its stash, its virtually inevitable for the links in a graph to lead to the main stash. Unfortunately stashes, especially the main one, can be quite big, and lead to forests of other structures -- theres one GV and another SV for each magic variable, plus all of @INC and %ENV, and so on. To prevent information overload, then, the display of stashes is disabled by default.

-fileGVs, -no_fileGVs

Another kind graph element that can be annoying are the pointers from every GV and COP (a kind of OP that occurs for every statement) to the GV that represents the file from which that code came (used for error messages). By default, these links arent shown, to keep them from cluttering the graph. Also, perls internal interfaces changed in a recent version, so in perl 5.005_63 or later you cant see the fileGVs at all.

-SEQs, -no_SEQs

As it is visited in the peephole optimization phase, each OP gets a sequence number, which is currently used by anything (except the peephole optimizer, to avoid visiting OPs twice). If you want to see these, ask for them. (COPs have their own sequence numbers too, but theyre more interesting to look at -- for instance, theyre used to bound the lifetimes of lexicals).

-types, -no_types

B::Graph always gives the type of each OP symbolically (entersub), but it can also print the numeric value of the type field, if you want. The default is no_types.

-float, -no_float

Almost every OP has an op_next and an op_sibling pointer, and B::Graph colors them distinctively (pink and light blue, respectively). Because of this, it isnt strictly necessary to anchor the arrow on a line in the OPs box saying op_next. The float option lets the graph layout engine start these arrows wherever it wants, which can sometimes lead to a more pleasing layout, at the expense of being less obvious. The default is not to float.

-targlinks, -no_targlinks

Lexical (my()) variables and temporary values used by individual OPs are stored in pads, per-code arrays linked to the CV. OPs store indexes into these arrays in the op_targ field, but B::Graph can often also draw links directly from the OP to the SV that stores the name of the variable. These links dont correspond to any real pointers, however, and they can make the graph more complicated, so they are disabled by default.

Bio::Phylo::IO Perl module contains input and output of phylogenetic data.

SYNOPSIS

use Bio::Phylo::IO;

# parsing a tree from a newick string
my $tree_string = (((A,B),C),D);;
my $tree = Bio::Phylo::IO->parse(
-string => $tree_string,

# old parser, always adds node labels
-format => newick,
)->first;

# note: newick parsers return
# Bio::Phylo::Forest! Call
# ->first to retrieve the first
# tree of the forest.

# prints Bio::Phylo::Forest::Tree
print ref $tree, "n";

# parsing a table
my $table_string = qq(A,1,2|B,1,2|C,2,2|D,2,1);
my $matrix = Bio::Phylo::IO->parse(
-string => $table_string,
-format => table,

# Data type, see Bio::Phylo::Parsers::Table
-type => STANDARD,

# field separator
-fieldsep => ,,

# line separator
-linesep => |
);

# prints Bio::Phylo::Matrices::Matrix
print ref $matrix, "n";

# parsing a list of taxa
my $taxa_string = A:B:C:D;
my $taxa = Bio::Phylo::IO->parse(
-string => $taxa_string,
-format => taxlist,
-fieldsep => :
);

# prints Bio::Phylo::Taxa
print ref $taxa, "n";

# matches taxon names in tree to $taxa object
$tree->cross_reference($taxa);

# likewise for matrix
$matrix->cross_reference($taxa);

print Bio::Phylo::IO->unparse(

# pass the tree object,
# crossreferenced to taxa, which
# are crossreferenced to the matrix
-phylo => $tree,
-format => pagel
);

# prints a pagel data file:
#4 2
#A,n1,0.000000,1,2
#B,n1,0.000000,1,2
#n1,n2,0.000000
#C,n2,0.000000,2,2
#n2,n3,0.000000
#D,n3,0.000000,2,1

JPSEEK and JPHIDE are 2 programs that allows you to hide a file in a jpeg visual image. There are lots of versions of similar programs available on the internet but JPHIDE and JPSEEK are rather special.

The design objective was not simply to hide a file but rather to do this in such a way that it is impossible to prove that the host file contains a hidden file. Given a typical visual image, a low insertion rate (under 5%) and the absence of the original file, it is not possible to conclude with any worthwhile certainty that the host file contains inserted data.

As the insertion percentage increases the statistical nature of the jpeg coefficients differs from "normal" to the extent that it raises suspicion. Above 15% the effects begin to become visible to the naked eye. Of course some images are much better than others when used a host file - plenty of fine detail is good. A cloudless blue sky over a snow covered ski paradise is bad. A waterfall in a forest is probably ideal.

Instructions:

jphide input-jpeg-file output-jpeg-file file-to-be-hidden

jpseek input-jpeg-file output-hidden-file

Building the programs:

Get the sources for the jpeg library jpeg-6a.
I got mine from a RedHat cd.

Compile them following the instructions that came with them.

Check them out - there is a "make test".

Use tar to put the new programs into the directory containing
the standard jpeg-6a sources:

tar -xzf jphs.tgz

Patch the makefile:

patch<<less