Free matches bomb software for linux

Bomb is a visual-musical instrument. It uses alife, and is alife. It runs on your PC and produces animated organic graphics in response to the keyboard, audio music, or on its own. You can download it from this web site, and run it on your PC.
I encourage you to make your own "music" to work with Bomb, or just use it as a screensaver. I am always thrilled to hear about what people do with it, so please keep me informed if you make something of it. Collaboration is also a possibility. Mail me, or talk to other users in the discussion forum.
Enhancements:
- automatically failover from ESD to nosound.
- add quicktime output (on control-v).

Net::ACL::Match::IP is a class matching IP addresses against an IP or network.

SYNOPSIS

use Net::ACL::Match::IP;
# Constructor
$match = new Net::ACL::Match::IP(1,10.0.0.0/8);
# Accessor Methods
$netmaskobj = $match->net($netmaskobj);
$netmaskobj = $match->net($net);
$index = $match->index($index);
$rc = $match->match($ip);
__top

This module is just a wrapper of the Net::Netmask module to allow it to operate automatically with Net::ACL::Rule.

X-bomber project is a multiplayer game for Unix systems.
"X-Bomber" is multi-player maze-style game where players collect and drop bombs, in an attempt to blow each other up. Last player standing wins!
X-Bomber is vaguely based on "Atomic Bomberman" by InterPlay and "Bomberman" by Hudsonsof. It is played on a grid, rather than with smooth movement.
Main features:
- 4 players on screen, up to 3 may be computer-controlled
- Pairs of players can share the same keyboard (so only two PCs are needed for a 4-human match)
- 2 types of bombs - normal, and remote-controlled
- Randomly-placed boxes with random power-ups inside!
- Occasionally, random boxes of explosive TNT
- 100 level maps!
- A nasty "death" character who appears if the players take too long. He ruthlessly homes in one a character until he catches him... then he picks a new victim!

Regexp::MatchContext is Perl module to replace (and improve) $MATCH, $PREMATCH, and $POSTMATCH

SYNOPSIS

use Regexp::MatchContext -vars;

$str = m/(?p) d+ /;

print "Before: $PREMATCHn";
print "Matched: $MATCHn";
print "After: $POSTMATCHn";

$MATCH = 2 * $MATCH; # substitute into original $str

The English.pm module provides named aliases for Perls built-in $`, $& and $ variables: $PREMATCH, $MATCH, and $POSTMATCH. Unfortunately, those aliases suffer the same problems as their originals: they degrade the performance of every single regex in your program, even if youre only using them to get information about a single match.

This module also provides $PREMATCH, $MATCH, and $POSTMATCH, but in a way that only impacts the performance of matches that you specify. That is, these three variables are only set if the most recently matched regex contained the special (non-standard) meta- flag: (?p).

That is:

use Regexp::MatchContext -vars;

$str = foobarbaz;

$str =~ /(?p) foo /x;

# $PREMATCH contains foo
# $MATCH contains bar
# $POSTMATCH contains baz

$str =~ / foo /x;

# $PREMATCH, $MATCH, and $POSTMATCH all undef

The (?p) marker can be placed anywhere within the regex and, except for setting the three context variables on a successful match, is otherwise totally ignored.

Test::Cmd is a Perl module for portable testing of commands and scripts.

SYNOPSIS

use Test::Cmd;

$test = Test::Cmd->new(prog => program_or_script_to_test,
interpreter => script_interpreter,
string => identifier_string,
workdir => ,
subdir => dir,
match_sub => $code_ref,
verbose => 1);

$test->verbose(1);

$test->prog(program_or_script_to_test);

$test->basename(@suffixlist);

$test->interpreter(script_interpreter);

$test->string(identifier string);

$test->workdir(prefix);

$test->workpath(subdir, file);

$test->subdir(subdir, ...);
$test->subdir([sub, dir], ...);

$test->write(file, read($contents, [subdir, file]);
$test->read(@lines, [subdir, file]);

$test->writable(dir);
$test->writable(dir, $rwflag);
$test->writable(dir, $rwflag, %errors);

$test->preserve(condition, ...);

$test->cleanup(condition);

$test->run(prog => program_or_script_to_test,
interpreter => script_interpreter,
chdir => dir, args => arguments, stdin => pass(condition, &func);

$test->fail(condition);
$test->fail(condition, &func);
$test->fail(condition, &func, $caller);

$test->no_result(condition);
$test->no_result(condition, &func);
$test->no_result(condition, &func, $caller);

$test->stdout;
$test->stdout($run_number);

$test->stderr;
$test->stderr($run_number);

$test->match(@lines, @matches);
$test->match($lines, $matches);

$test->match_exact(@lines, @matches);
$test->match_exact($lines, $matches);

$test->match_regex(@lines, @regexes);
$test->match_regex($lines, $regexes);

$test->diff_exact(@lines, @matches, @output);
$test->diff_exact($lines, $matches, @output);

$test->diff_regex(@lines, @regexes, @output);
$test->diff_regex($lines, $regexes, @output);

sub func {
my ($self, $lines, $matches) = @_;
# code to match $lines and $matches
}
$test->match_sub(&func);
$test->match_sub(sub { code to match $_[1] and $_[2] });

$test->here;

The Test::Cmd module provides a low-level framework for portable automated testing of executable commands and scripts (in any language, not just Perl), especially commands and scripts that interact with the file system.

The Test::Cmd module makes no assumptions about what constitutes a successful or failed test. Attempting to read a file that doesnt exist, for example, may or may not be an error, depending on the software being tested.

Consequently, no Test::Cmd methods (including the new() method) exit, die or throw any other sorts of exceptions (but they all do return useful error indications). Exceptions or other error status should be handled by a higher layer: a subclass of Test::Cmd, or another testing framework such as the Test or Test::Simple Perl modules, or by the test itself.
(That said, see the Test::Cmd::Common module if you want a similar module that provides exception handling, either to use directly in your own tests, or as an example of how to use Test::Cmd.)

In addition to running tests and evaluating conditions, the Test::Cmd module manages and cleans up one or more temporary workspace directories, and provides methods for creating files and directories in those workspace directories from in-line data (that is, here-documents), allowing tests to be completely self-contained. When used in conjunction with another testing framework, the Test::Cmd module can function as a fixture (common startup code for multiple tests) for simple management of command execution and temporary workspaces.

The Test::Cmd module inherits File::Spec methods (file_name_is_absolute(), catfile(), etc.) to support writing tests portably across a variety of operating and file systems.

A Test::Cmd environment object is created via the usual invocation:

$test = Test::Cmd->new();

Arguments to the Test::Cmd::new method are keyword-value pairs that may be used to initialize the object, typically by invoking the same-named method as the keyword.

BomberMaze project is a bomberman clone.
It is a multiplayer action game in which players run around a square-grid maze while dropping bombs and collecting power-ups.
The bombs explode after a short time delay, taking out any nearby bricks and players.
Main features:
- Support for 2 to 4 players
- 5 different power-ups: Extra Bomb, Extra Blast Radius, Trigger Bomb, Kick Bomb, and Extra Speed
- Configurable mazes and randomizable mazes
- Configurable key controls
- Theme support (ie., configurable tiles and sprites)
Enhancements:
- New translations: Danish, German, Spanish, Italian, Norwegian, Russian, and Ukrainian (da, de, es, it, no, ru, uk).

TRE is a robust, lightweight, and efficient POSIX compliant regexp matching library with some exciting features such as approximate (fuzzy) matching.
At the core of TRE is a new algorithm for regular expression matching with submatch addressing. The algorithm uses linear worst-case time in the length of the text being searched, and quadratic worst-case time in the length of the used regular expression.
In other words, the time complexity of the algorithm is O(M2N), where M is the length of the regular expression and N is the length of the text. The used space is also quadratic on the length of the regex, but does not depend on the searched string. This quadratic behaviour occurs only on pathological cases which are probably very rare in practice.
Main features:
- TRE is not just yet another regexp matcher. TRE has some features which are not there in most free POSIX compatible implementations. Most of these features are not present in non-free implementations either, for that matter.
Approximate matching
Approximate pattern matching allows matches to be approximate, that is, allows the matches to be close to the searched pattern under some measure of closeness. TRE uses the edit-distance measure (also known as the Levenshtein distance) where characters can be inserted, deleted, or substituted in the searched text in order to get an exact match. Each insertion, deletion, or substitution adds the distance, or cost, of the match. TRE can report the matches which have a cost lower than some given threshold value. TRE can also be used to search for matches with the lowest cost.
TRE includes a version of the agrep (approximate grep) command line tool for approximate regexp matching in the style of grep. Unlike other agrep implementations (like the one by Sun Wu and Udi Manber from University of Arizona available here) TRE agrep allows full regexps of any length, any number of errors, and non-uniform costs for insertion, deletion and substitution.
Enhancements:
- A Swedish translation has been added.
- Documentation has been updated.
- The -q command line option has been added.
- A number of bugs have been fixed.