Free destiny 0.31 software for linux

Wars of Destiny project is a real-time strategy game with network support.

Wars of Destiny is a real-time strategy game. It is currently in a major building stage, but looks very promising. If you are interested in helping, then your assistance would be greatly appreciated. It uses SDL 1.2.0 and SDL_mixer, and it includes fully integrated network support for playing with other people over the Internet. It also includes a map creator and an easy-to-use interface for configuring WOD.

Scriptix has but several goals for its existance. First, it must be easy to program in. I originally decided that, for this purpose, a BASIC-like syntax would be best. However, it appears that people find familiarity to be more important - so versions of Scriptix from 0.19 onward will have a C/C++-like syntax. Scriptix parser can be quite easily re-written to handle almost any syntax desired, however.
Second, Scriptix must be threadable, allowing semi-syncronous execution of threads within a single OS process. Both pre-emptive and cooperative multi-tasking should be available. Both have their advantages and disadvantages, and the embedding application should be able to decide on the best method for the task. While pre-emptive multi-tasking is currently supported, it is still rudimentary, and basic thread control types (mutexes, etc.) are not yet implemented.
Third, it must support a decent subset of high-level language features, such as arrays, classes, and user-definable data types. The language itself does not provide for a large amount of definable functionality - the user scripts are somewhat limited in the scope of effect they can have on the language (in regards to defining functions/classes, etc.) This limits the negative effects a poorly written or malicious script can have on the host application.
Fourth, Scriptix must be of decent speed. As Scriptix is designed for interactive entertainment software (a.k.a. games), speed is very important. Ive no benchmarks yet to display hard-data on Scriptix speed - simple tests have shown it to easily outperform more popular scripting languages, however.
Scriptix makes use of a garbage collection scheme for memory management. Lots of people think this means it will be very slow. On the contrary, a clever garbage management system can result in a more responsive application, since memory deallocation can be controlled to a large degree. However, Scriptix does not (yet) have a clever scheme. It is planned to be greatly improved before 1.0, however.
Enhancements:
- Minor API and languages changes.
- Last independent release of Scriptix.
- Future releases will be part of the AweMUD package.

Sizzle project ios an mebeddable Scheme interpret
Sizzle is a Scheme interpreter for embedding into C applications and for standalone scripting.
It implements a nearly complete subset of R5RS Scheme, adding a lot of primitives for U*ix scripting, regular expression searching, a simple module system, dynamic library linking, powerful string processing procedures, and much more.
It includes a users guide and an embedding manual in texinfo format, some examples, the embedding library, and a standalone interpreter for interactive use and scripting.
Main features:
- Supports most library procedures from R5RS
- Sizzle aims to be compatible to Guile, whereever possible
- Sizzle is easy to embed
- Sizzle is easy to extend
- Sizzle provides bindings for most Posix functions
- Bindings for regular expression matching

VideoDog software was a kind of video /bin/cat, to grab a single frame of a video4linux device or set some pictures default.

Now it evolved into a complete image capture/processing environment, with a simple and clean API, and using almost no external libs.

It works with linuxs v4l subsystem, has a lot of algorithms for image processing and storage, including motion detection, alpha blending logos, image formats, edge detection, and so on. Also, it includes examples on how to deal with jpeglib, gtk, SDL and XLib, regarding image capture and processing.

You can use a simple config file, suited for the most common needs, or use the command line options.

To change the path, just edit the makefile. The default path is /etc/vd.conf.
In the folder called "extra" you will find the gtkpnm, xputjpeg, gtk_cam and a small swap asm function, bgr2rgb.

There is a man page. Just check it with man ./videodog.man or move to a proper location. Its not complete yet, so, I didn`t put it in the Makefile.

*In a short:*

Just grabs a frame from v4l device or set its picture defaults. Useful for scripts, webcam scripts. No dependencies of any external libs.

This code is GPLed, feel free to use it and send me tips, patches,etc, etc.

Please, send me bug reports, feedbacks, ideas, patches and stuffs.

Possible outputs:

RAW frame (RGB)
PNM frame
JPEG frame
TARGA24 (tga) frame.
Double buffer loop capture or single frame with any format.

Tested with:

CPiA driver (webcam II parport)
Bttv driver ( bt 848 & 878 )
ov511 ( webcam III usb )
DLINK cam

Devel::RingBuffer is a Perl module with shared memory ring buffers for Perl scripts diagnosis/debug.

SYNOPSIS

#
# create ringbuffer
#
use Devel::RingBuffer;
use Devel::RingBuffer::TieInt;

my $ringbuf = Devel::RingBuffer->new(
File => somefile.trace,
Rings => 20,
Slots => 20,
SlotSize => 300,
MessageSize => 256,
GlobalSize => 24 * 1024,
StopOnCreate => 0,
TraceOnCreate => 1) || die "Cant create a ring buffer.";

my $ring = $ringbuf->allocate();

Provides shared memory structures (using memory mapped files via IPC::Mmap) to be used by diagnostic and debugger applications for Perl scripts (see Devel::STrace). Using XS/C code to maximize performance, creates a set of ringbuffers with a configurable number of slots.

Each slot includes a field for a linenumber, a timestamp, and a fully qualified subroutine name. Each ring buffer also includes additional headers and fields to support diagnostic interfaces, e.g., watched expressions, command/reponse interfaces to the monitored applications, etc.

Tabble is a small alternative X shell which presents your programs in tabs for easy launch. Tabble is not meant to replace a window manager, just complement it. Light window managers benefit the most from tabble.

The idea is that tabble is always on top so multiple launches can be made without re-navigating a menu hierarchy or clearing the desktop.

The above window, customized to your choices, can appear at a fixed position on your screen so you can spawn a few things quickly. Hit the hide button and its out of your way, and the next switch to tabble will be faster.

One of the reasons for tabble is that it can be started from within a chroot (32 bit inside 64 say). Other programs within the chroot can be easily spawned from this tabble.

KDE/GNOME could use this concept but there is still a case for a standalone program for those who switch between window managers - because only one configuration file needs maintaining and it can be shared.

WebService::ISBNDB Perl module provides an object-oriented interface to the data API at http://isbndb.com. Books, authors, publishers, categories, and subjects are all represented in separate classes. The module uses the REST interface to communicate with isbndb.com.

Devel::STrace::Monitor is a monitor interface component for Devel::STrace.

SYNOPSIS

#
# open the mmaped file
#
use Devel::STrace::Monitor;

my $view = Devel::STrace::Monitor->open(somefile.map);

my $cycles = 0;
while (1) {
print "n**************************************n";
#
# refresh the internal ringbuffer map
#
$view->refresh();
#
# dump the current traces
#
$view->trace(&dump_trace);

sleep 10;
}
#
# method to display the traces
#
sub dump_trace {
my ($key, $slot, $depth, $line, $time, $entry) = @_;

$lastkey = $key,
print "n**************************************n"
unless ($lastkey eq $key);

if ($time) {
#
# trim the weekday and year from timestamp
#
my $frac = ($time - int($time)) * 1000000;
$frac=~s/..*$//;
my @parts = split(/s+/, scalar localtime($time));
pop @parts; # get rid of year
print "$key($depth) : $slot : $entry:$line at ",
join( , @parts), ., $frac, "n";
}
else {
print "$key($depth) : $slot : $entry:$line (No timestamp)n";
}
}

Provides methods to attach to and read the memory mapped file generated by Devel::STrace (or future full featured debuggers) using Devel::RingBuffer.

set or clear any of the $DB::single, $DB::trace, or $DB::signal control variables of the AUT (via their tied interfaces in the AUT).

inspect the current execution call stack of the AUT

The interfaces provide a simple framework for building an external application that can attach to a running Perl application, monitor its current execution, and eventually detach, all while permitting the application continue to run uninterrupted.

A more complete debugger module is planned to exploit the various command/control structures available via Devel::RingBuffer. Note that this module will be fully compatible with the resulting debugger so that, e.g., an application can first be monitored to detect troublespots, and then the debugger can be attached to fully debug the problem.