Free newerth sep software for linux

Savage: The Battle for Newerth SEP 2 for Linux is a patch for Savage game.
Serverside Demos, with the possibility of multiple players watching the same replay on the same replay server at the same time!
Fixed ALL known bugs and exploits, including tons of non-public ones. Even more so than in the original SEP-2 release.
Improved clientside performance and loading speed, up to 25-50% each, depending on your configuration.
Lower pings, especially so on SEP-2 servers (only when on the field, to minimize bandwidth costs)
Enhancements:
- highly optimized rewritten network code
- two new Healer class units
- two new structures
- all new weapons effects
- new items
- new maps
- engine enhancements which increase frame rate by up to 40% on many computer systems
- numerous bug/exploit fixes
- new gameplay and balance tweaks
- introduces Demo Recording

Term::TUI is a simple tool for building text-based user interfaces.

SYNOPSIS

If TUI_Run is the only routine being used:
use Term::TUI;
$flag=&TUI_Run($command,%desc);

$version=&Term::TUI::TUI_Version;
If other TUI subroutines are used:
use Term::TUI qw(:all);
$flag=&TUI_Run($command,%desc);

&TUI_Out($message);

$flag=&TUI_Script(%desc,$script,$sep);

Many times, Ive wanted to quickly write a nice text-based user interface around a set of perl routines only to end up writing the full (though simple) parser and interface to make it nice enough, and friendly enough, to be usable.

This module creates a simple but powerful text based user interface around perl routines, adding such features as command line history, command line editing, and online help (command completion will also be implemented), while hiding all details of the interface from the programmer.

The interface is described in a simple hash which is passed to the TUI_Run command. This routine exits only when the user has exited the program (returning a flag signalling any special exit conditions).

This program reads symbolic 65816 or 65c816 machine code and compiles (assembles) it into a relocatable object file.
The produced object file is binary-compatible with those made with XA65.
This program was born when Bisqwit needed a relocatable object -producing snes assembler and XA65 had too many bugs in it.
He was unable to fix the XA65 source so he started his own project, aiming for enough compatibility to be able to use the assembly files already written in the XAxa65 syntax.
Since that, this program has been growing to meet the needs in SNES game and patch development.
The following mnemonics are supported:
adc, and, asl, bcc, bcs, beq, bit, bmi, bne, bpl, bra, brk, brl, bvc, bvs, clc, cld, cli, clv, cmp, cop, cpx, cpy, db , dec, dex, dey, eor, inc, inx, iny, jml, jmp, jsl, jsr, lda, ldx, ldy, lsr, mvn, mvp, nop, ora, pea, pei, per, pha, phb, phd, phk, php, phx, phy, pla, plb, pld, plp, plx, ply, rep, rol, ror, rti, rtl, rts, sbc, sec, sed, sei, sep, sta, stp, stx, sty, stz, tax, tay, tcd, tcs, tdc, trb, tsb, tsc, tsx, txa, txs, txy, tya, tyx, wai, xba, xce
All the standard addressing modes of the 65816 cpu are supported.
Syntax:
- Implied: nop; clc
- Immediate: lda #value; rep #value etc (size may depend on an operand size setting)
- Short relative: bra end
- Long relative: brl end; per end+2
- Direct: lda $12
- Direct indexed: lda $12,x; lda $12,y
- Direct indirect: lda ($12); pei ($12)
- Direct indexed indirect: lda ($12,x)
- Direct indirect indexed: lda ($12),y
- Direct indirect long: lda [$12]
- Direct indirect indexed long: lda [$12],y
- Absolute: lda $1234
- Absolute indexed: lda $1234,x; lda $1234,y
- Absolute long: lda $123456
- Absolute indexed long: lda $123456,x
- Stack-relative: lda $12,s
- Stack-relative indirect indexed: lda ($12,s),y
- Absolute indirect: lda ($1234)
- Absolute indirect long: lda [$1234]
- Absolute indexed indirect: lda ($1234,x)
- MVN/MVP: mvn $7E,$7F
For reference, in Intel syntax it would be something like this (not supported by snescom):
- Implied: nop; clc
- Immediate: lda value; rep value etc (size may depend on an operand size setting)
- Short relative: bra end
- Long relative: brl end; per end+2
- Direct: lda [$00:d+$12]
- Direct indexed: lda [$00:d+$12+x]; lda [$00:d+$12+y]
- Direct indirect: lda [db:[$00:d+$12]]; pei [db:[$00:d+$12]]
- Direct indexed indirect: lda [db:[$00:d+$12+x]]
- Direct indirect indexed: lda [db:[$00:d+$12]+y]
- Direct indirect long: lda [long[$00:d+$12]]
- Direct indirect indexed long: lda [long[$00:d+$12]+y]
- Absolute: lda [db:$1234]
- Absolute indexed: lda [db:$1234+x]; lda [db:$1234+y]
- Absolute long: lda [$12:$3456]
- Absolute indexed long: lda [$12:$3456+x]
- Stack-relative: lda [$00:$12+s]
- Stack-relative indirect indexed: lda [db:[$00:$12+s]+y]
- Absolute indirect: lda [db:[$1234]]
- Absolute indirect long: lda [long[db:$1234]]
- Absolute indexed indirect: lda [db:[db:$1234+x]]
- MVN/MVP: mvn $7E,$7F
Enhancements:
- This release updates the linker program, adding a feature to output raw files, or even ROM files directly in the SMC format, with proper checksums.
- The error handling of the assembler was improved somewhat.

PShutter lets you firewall off ports such as ssh, and selectively enable access with a one-time password.
For example, if you want to log into the server from a friends house, you pull out a list of one-time passwords and point the web browser at a URL that contains one password. That tells the server to allow ssh connections from your friends IP address for five minutes. Connections made in that period will stay up indefinitely.
IPShutter is written in Perl language. It requires ipchains - on 2.4 kernels, ipchains can be loaded as module. IPShutter must run as root.
You may need to modify the first line of IPShutter to point to where Perl5 is located on your system.
Enhancements:
- Version 0.2 - Sat Sep 28 14:55:03 CDT 2002 - Moved configuration options to /etc/ipshutterrc and fixed daemonization.

Algorithm::Diff is a Perl module to compute `intelligent differences between two files / lists.

SYNOPSIS

require Algorithm::Diff;

# This example produces traditional diff output:

my $diff = Algorithm::Diff->new( @seq1, @seq2 );

$diff->Base( 1 ); # Return line numbers, not indices
while( $diff->Next() ) {
next if $diff->Same();
my $sep = ;
if( ! $diff->Items(2) ) {
printf "%d,%dd%dn",
$diff->Get(qw( Min1 Max1 Max2 ));
} elsif( ! $diff->Items(1) ) {
printf "%da%d,%dn",
$diff->Get(qw( Max1 Min2 Max2 ));
} else {
$sep = "---n";
printf "%d,%dc%d,%dn",
$diff->Get(qw( Min1 Max1 Min2 Max2 ));
}
print "< $_" for $diff->Items(1);
print $sep;
print "> $_" for $diff->Items(2);
}


# Alternate interfaces:

use Algorithm::Diff qw(
LCS LCS_length LCSidx
diff sdiff compact_diff
traverse_sequences traverse_balanced );

@lcs = LCS( @seq1, @seq2 );
$lcsref = LCS( @seq1, @seq2 );
$count = LCS_length( @seq1, @seq2 );

( $seq1idxref, $seq2idxref ) = LCSidx( @seq1, @seq2 );


# Complicated interfaces:

@diffs = diff( @seq1, @seq2 );

@sdiffs = sdiff( @seq1, @seq2 );

@cdiffs = compact_diff( @seq1, @seq2 );

traverse_sequences(
@seq1,
@seq2,
{ MATCH => &callback1,
DISCARD_A => &callback2,
DISCARD_B => &callback3,
},
&key_generator,
@extra_args,
);

traverse_balanced(
@seq1,
@seq2,
{ MATCH => &callback1,
DISCARD_A => &callback2,
DISCARD_B => &callback3,
CHANGE => &callback4,
},
&key_generator,
@extra_args,
);

Math::String::Charset is a simple charset for Math::String objects.

SYNOPSIS

use Math::String::Charset;

$a = new Math::String::Charset; # default a-z
$b = new Math::String::Charset [a..z]; # same
$c = new Math::String::Charset
{ start => [a..z], sep => }; # with between chars

print $b->length(); # a-z => 26

# construct a charset from bigram table, and an initial set (containing
# valid start-characters)
# Note: After an a, either an b, c or a can follow, in this order
# After an d only an a can follow
$bi = new Math::String::Charset ( {
start => a..d,
bi => {
a => [ b, c, a ],
b => [ c, b ],
c => [ a, c ],
d => [ a, ],
q => [ ], # q will be automatically in end
}
end => [ a, b, ],
} );
print $bi->length(); # a,b => 2 (cross of end and start)
print scalar $bi->class(2); # count of combinations with 2 letters
# will be 3+2+2+1 => 8

$d = new Math::String::Charset ( { start => [a..z],
minlen => 2, maxlen => 4, } );

print $d->first(0),"n"; # undef, too short
print $d->first(1),"n"; # undef, to short
print $d->first(2),"n"; # aa

$d = new Math::String::Charset ( { start => [a..z] } );

print $d->first(0),"n"; #
print $d->first(1),"n"; # a
print $d->last(1),"n"; # z
print $d->first(2),"n"; # aa

This module lets you create an charset object, which is used to contruct Math::String objects. This object knows how to handle simple charsets as well as complex onex consisting of bi-grams (later tri and more).

In case of more complex charsets, a reference to a Math::String::Charset::Nested or Math::String::Charset::grouped will be returned.

The default charset is the set containing "abcdefghijklmnopqrstuvwxyz" (thus producing always lower case output).

DNS Domain Expiration Check is a utility for checking DNS domain expiration dates.

domain-check queries WHOIS data in realtime, and can be integrated with cron to provide e-mail notifications prior to a domain expiring.

The first example will print the expiration date and registrar for daemons.net:

$ domain-check.sh -d daemons.net

Domain Registrar Status Expires Days Left
----------------------------------- ----------------- -------- ----------- ---------
daemons.net INTERCOSMOS MEDIA Valid 13-feb-2006 64


The second example prints the expiration date and registrar for the domains listed in the file "domains":

$ domain-check.sh -f domains

Domain Registrar Status Expires Days Left
----------------------------------- ----------------- -------- ----------- ---------
sun.com NETWORK SOLUTIONS Valid 20-mar-2010 1560
google.com EMARKMONITOR INC. Valid 14-sep-2011 2103
daemons.net INTERCOSMOS MEDIA Valid 13-feb-2006 64
spotch.com GANDI Valid 03-dec-2006 357


The third example will e-mail the address admin@daemons.net with the domains that will expire in 60-days or less:

$ domain-check -a -f domains -q -x 60 -e admin@daemons.net

JoeDog::Config provides a perl extension for parsing data/configuration file.

It reads columns, key-value pairs, and INI style config files into arrays, hashes and hashes of hashes. It can take characters or regexes for separators.

ABSTRACT:
This is a autoloadable module which allows the programmer
to read data from an configuration file into various perl
data types, arrays, multi-dimentional arrays and hashes.

INSTALLATION
JoeDog::Config.pm was built using perl Make::Maker utility
If you are familiar with that utility you should have no
problem with this installation as it will be familiar:

$ perl Makefile.PL
$ make
$ make test
$ su
$ make install

USAGE
use JoeDog::Config;
my $cnf = new JoeDog::Config(filename);
my @array = $cnf->get_column();
my @arrays = $cnf->get_columns(sep);
my @aoa = $cnf->get_table(sep,num);
my @aoa = $cnf->get_table(sep,[num1, num2, etc...]);
my %hash = $cnf->get_hash(sep);
my %hashes = $cnf->get_hashes(sep);