Free freespace intro software for linux

XML::SAX::Intro is an Introduction to SAX Parsing with Perl.

XML::SAX is a new way to work with XML Parsers in Perl. In this article well discuss why you should be using SAX, why you should be using XML::SAX, and well see some of the finer implementation details. The text below assumes some familiarity with callback, or push based parsing, but if you are unfamiliar with these techniques then a good place to start is Kip Hamptons excellent series of articles on XML.com.

Replacing XML::Parser

The de-facto way of parsing XML under perl is to use Larry Wall and Clark Coopers XML::Parser. This module is a Perl and XS wrapper around the expat XML parser library by James Clark. It has been a hugely successful project, but suffers from a couple of rather major flaws. Firstly it is a proprietary API, designed before the SAX API was conceived, which means that it is not easily replaceable by other streaming parsers. Secondly its callbacks are subrefs. This doesnt sound like much of an issue, but unfortunately leads to code like:

sub handle_start {
my ($e, $el, %attrs) = @_;
if ($el eq foo) {
$e->{inside_foo}++; # BAD! $e is an XML::Parser::Expat object.
}
}

As you can see, were using the $e object to hold our state information, which is a bad idea because we dont own that object - we didnt create it. Its an internal object of XML::Parser, that happens to be a hashref. We could all too easily overwrite XML::Parser internal state variables by using this, or Clark could change it to an array ref (not that he would, because it would break so much code, but he could).

The only way currently with XML::Parser to safely maintain state is to use a closure:

my $state = MyState->new();
$parser->setHandlers(Start => sub { handle_start($state, @_) });

This closure traps the $state variable, which now gets passed as the first parameter to your callback. Unfortunately very few people use this technique, as it is not documented in the XML::Parser POD files.

Another reason you might not want to use XML::Parser is because you need some feature that it doesnt provide (such as validation), or you might need to use a library that doesnt use expat, due to it not being installed on your system, or due to having a restrictive ISP. Using SAX allows you to work around these restrictions.

OpenOffice::OODoc::Intro is a Perl module for an introduction to the Open OpenDocument Connector.

The main goal of the Open OpenDocument Connector (OODoc) is to allow quick application development in 2 areas:

- replacement of old-style, proprietary, client-based macros for intensive and non-interactive document processing;
- direct read/write operations by enterprise software on office documents, and/or document-driven applications.

OODoc provides an abstraction of the document objects and isolates the programmer from low level XML navigation, UTF8 encoding and file compression details. For example:

use OpenOffice::OODoc;
my $document = ooDocument(file => filename.odt);
$document->appendParagraph
(
text => Some new text,
style => Text body
);
$document->appendTable("My Table", 6, 4);
$document->cellValue("My Table", 2, 1, "New value");
$document->save;

The script above appends a new paragraph, with given text and style, and a table with 6 lines and 4 columns, to an existing document, then inserts a value at a given position in the table. It takes much less time than the opening of the document with your favourite text processor, and can be executed without any desktop software connection. A program using this library can run without any OpenOffice.org installation (and, practically, OODoc has been tested on platforms where OpenOffice.org is not available yet).

More generally, OpenOffice::OODoc provides a lot of methods (probably most of them are not useful for you) allowing create/search/update/delete operations with document elements such as:

- ordinary text containers (paragraphs, headings, item lists); - tables and cells; - sections; - images; - styles; - page layout; - metadata (i.e. title, subject, and other general properties).

YES Linux is an idea started by Arthur Copeland, CEO of Saphari.com. The idea was to build a low cost suite of products and services that could enable a Mom and Pop Store (MaPs) to quickly and easily build an internet presence.
The project was understood that not all MaPs need to have an internet presence, thus the suite would also have to work while not being connected to the internet. To the MaPs, it should be transparent.
Thus, YourESale was born... and the rest is history. MaPs - MaPs are defined as companies that have between 1 and 20 employees or total gross revenue of less than $200,000.00 per year.
YES Linux is a server appliance for small and medium size networks to quickly and easily build an Internet presence. It completely installs in under 10 minutes and 2 screens.
It features a secure Web server, a secure email server with Web-based email, a firewall, spam filtering, WebDAV support, an FTP server, an SSH server, a PostgreSQL database, the Resin J2EE server, Java, Apache Ant, PHP 5, Autonomous Backups, and complete Web-based administration.
Enhancements:
- addition:
- added mod_auth_msfix
- added xmlstarlet
- removal:
- removed mondo
- removed mindi
- removed dvdrecord
- removed lzop
- removed lzo
- removed star
- removed afio
- removed buffer
- updates:
- updated gnupg
- updated rsync
- updated phppgadmin
- updated findutils
- updated java
- updated yes-java
- updated yes-backup - removed mondo and mindi and added simple multi volume homegrown
- updated yes-website - added ms auth client fix, fixed default website formatting, Changed to YES Technology Association, added new group to webdav
- updated yes-admin - added ms auth client fix, Changed to YES Technology Association, added new group to webdav
- updated yes-configuration - added default httpd configuration area to change ip, increased the max heap size
- updated yes-rebrand - Changed to YES Technology Association
- updated yes-boot - Changed to YES Technology Association
- updated yes-dns - Changed to YES Technology Association
- updated yes-intro - Changed to YES Technology Association
- updated yes-mail - Changed to YES Technology Association
- updated yes-stats - Changed to YES Technology Association
- updated yes-authentication - added user management
- updated yes-security - added user management
- updated yes-dbadmin - spec file added reporting for phppgadmin

Beyond the Red Line project is a stand-alone total conversion for the award-winning Freespace 2 released by Volition and Interplay for the PC. It is based on the popular new tv-show Battlestar Galactica. No, not the one from the 70s.
Will I need Freespace 2 to play it?
No, Beyond the Red Line is a stand-alone conversion and will not require Freespace 2. All you need for playing will be included in the download.
Is it free?
Absolutely. The game is made by fans for the fans, no profit is being made from any part of the project. Although we could use some pizzas and coke to keep our mortal bodies running.
That about covers it... a BSG total conversion of FS2 that has just released a demo version. it plays really well and looks amazing. a must for any BSG fan.
Enhancements:
- This demo contains spoilers for the second season of BSG, so if you havent seen that season yet you should pass on this game for now.

Embperl::TOC is a Perl module for Embperl Documenation: Table of Contents.

Embperl can be used in many ways and its documentation doesnt fit in one man pages. The following documentation is available within the distribution and the installed system using perldoc(1) or man(1):

CONTENT:

Installation Documentation
Embperl::Features
Embperl::Intro
Embperl::IntroEmbperl2
Embperl::Config
Embperl
Embperl::Object
Embperl::Form
Embperl::Form::Validate
Embperl::Mail
Embperl::Inline
Embperl::Recipe
Embperl::Syntax
Embperl::Syntax::ASP
Embperl::Syntax::Embperl
Embperl::Syntax::EmbperlBlocks
Embperl::Syntax::HTML
Embperl::Syntax::EmbperlHTML
Embperl::Syntax::Mail
Embperl::Syntax::MsgIdExtract
Embperl::Syntax::Perl
Embperl::Syntax::POD
Embperl::Syntax::RTF
Embperl::Syntax::SSI
Embperl::Syntax::Text
Embperl::TipsAndTricks
Sourcecode encryption
Changes

PDL::Internals is a Perl module that contains a description of some aspects of the current internals.

Intro

This document explains various aspects of the current implementation of PDL. If you just want to use PDL for something, you definitely do not need to read this. Even if you want to interface your C routines to PDL or create new PDL::PP functions, you do not need to read this man page (though it may be informative). This document is primarily intended for people interested in debugging or changing the internals of PDL. To read this, a good understanding of the C language and programming and data structures in general is required, as well as some Perl understanding. If you read through this document and understand all of it and are able to point what any part of this document refers to in the PDL core sources and additionally struggle to understand PDL::PP, you will be awarded the title "PDL Guru" (of course, the current version of this document is so incomplete that this is next to impossible from just these notes).

Warning: If it seems that this document has gotten out of date, please inform the PDL porters email list (pdl-porters@jach.hawaii.edu). This may well happen.

Piddles

The pdl data object is generally an opaque scalar reference into a pdl structure in memory. Alternatively, it may be a hash reference with the PDL field containing the scalar reference (this makes overloading piddles easy, see PDL::Objects). You can easily find out at the Perl level which type of piddle you are dealing with. The example code below demonstrates how to do it:

# check if this a piddle
die "not a piddle" unless UNIVERSAL::isa($pdl, PDL);
# is it a scalar ref or a hash ref?
if (UNIVERSAL::isa($pdl, "HASH")) {
die "not a valid PDL" unless exists $pdl->{PDL} &&
UNIVERSAL::isa($pdl->{PDL},PDL);
print "This is a hash reference,",
" the PDL field contains the scalar refn";
} else {
print "This is a scalar ref that points to address $$pdl in memoryn";
}

The scalar reference points to the numeric address of a C structure of type pdl which is defined in pdl.h. The mapping between the object at the Perl level and the C structure containing the actual data and structural that makes up a piddle is done by the PDL typemap. The functions used in the PDL typemap are defined pretty much at the top of the file pdlcore.h. So what does the structure look like:

struct pdl {
unsigned long magicno; /* Always stores PDL_MAGICNO as a sanity check */
/* This is first so most pointer accesses to wrong type are caught */
int state; /* Whats in this pdl */

pdl_trans *trans; /* Opaque pointer to internals of transformation from
parent */

pdl_vaffine *vafftrans;

void* sv; /* (optional) pointer back to original sv.
ALWAYS check for non-null before use.
We cannot inc refcnt on this one or wed
never get destroyed */

void *datasv; /* Pointer to SV containing data. Refcnt inced */
void *data; /* Null: no data alloced for this one */
int nvals; /* How many values allocated */
int datatype;
PDL_Long *dims; /* Array of data dimensions */
PDL_Long *dimincs; /* Array of data default increments */
short ndims; /* Number of data dimensions */

unsigned char *threadids; /* Starting index of the thread index set n */
unsigned char nthreadids;

pdl *progenitor; /* Im in a mutated family. make_physical_now must
copy me to the new generation. */
pdl *future_me; /* Im the "then" pdl and this is my "now" (or more modern
version, anyway */

pdl_children children;

short living_for; /* perl side not referenced; delete me when */

PDL_Long def_dims[PDL_NDIMS]; /* Preallocated space for efficiency */
PDL_Long def_dimincs[PDL_NDIMS]; /* Preallocated space for efficiency */
unsigned char def_threadids[PDL_NTHREADIDS];

struct pdl_magic *magic;

void *hdrsv; /* "header", settable from outside */
};

This is quite a structure for just storing some data in - what is going on?

WESTBANG is a western FPS style game for Linux.

Comics

Files: DATA/COMIX/*.CMX

Comics are simple animations with given images made by a script file.
Comics are used for intro and outro animation and for interlevel shots.
There are these reserved comics:

intro.cmx played after the start of the program
gameover.cmx played, when a player loose his last life
goodbye.cmx played after the quit

You can modify these files as you wish, but you have to keep these names,
because they are called directly from the program. Other comics, their
names or number, is random.

Any of the *.cmx file can contain these commands:

delay < ticks >

Specifies the time the computer will wait before he does the next
command.

image < index > < name >

Image loads the specified bitmap and gives it an index number. In the
< name > can be just the name of the bitmap (the *.bmp file) or the path
and the name. The path starts in ../WESTBANG/DATA/COMIX, so all your
bitmaps and dirs have to be in the COMIX directory.

Note: The color 255,0,255 is transparent.

destroy < index >

Removes the image from the memory. Dont forget to destroy images,
or you can glut the memory.

virtual < v_index > < index > < pos_X > < pos_Y > < width > < height >

Virtual is the quad shaped object taken out of the image you can work
with by the commands of the comics. You can define more than one virtual
in one image.
< v_index > is the index given to the new virtual.
< index > is the index of the source bitmap.
< pox_X > < pos_Y > are the coords of the upper left corner of the virtual
in the image.
< width > < height > set the size of the virtual.

anime < v_inde x> < frames > < delay >

Makes the specified virtual the animated one. < Frames > is the number of
the frames and < delay > sets the pause between the two frames (speed of
animation).
Animated virtuals are made of bitmaps with all the frames placed in the
row. So the height of the bitmap is the same as the frames height and
width equals to times width of the frame.

anime_type < v_index > < type >

Sets the type of the animation of the specified virtual.
1: from first to last (1->2->3->...)
2: zig zag (1->2->3->2->1->...)
3: random

Example: These three commands make a short animated virtual.
virtual 3 1 0 0 10 10 //defines the first frame (size 10x10)
//taken from the image 1 (size 40x10)
anime 3 4 18 //makes 4-frames animation
anime_type 3 1 //sets the type of the animation to normal

setxy < v_index > < x > < y >

Puts the specified virtual on the given coords.

vis_on < v_index >

Shows the specified virtual. New created virtuals are hiden. You have to
use vis_on, if you want to see them on the screen.

vis_off < v_index >

Hides the specified virtual.

move < v_index > < tx > < ty > < sx > < sy > < tempo >

Sets the virtual as "the moving" one. Moving virtual goes automaticaly
from actual coords to target coords < tx >,< ty >. The speed of the motion
can be controled by the length of the single step (< sx >: step along the
x-axis, < sy >: step along the y-axis in pixels), or by the < tempo > - the
delay between the two steps.

resize < v_index> < sw> < sh> < speed_x> < speed_y>

Sets the virtual as "the resizing" one. < Sw> and < sh> are starting
height and witdth. Resizing can go by the very small steps, thats why
you have to set sw=100000 and sh=100000 if you want the starting size
of the virtual to be 100% x 100%.

sound < index> < name>

This is the same as the image command for the bitmaps.

play_sound < index> < volume> < panning>

Plays the sound once.

repeat_sound < index> < volume> < panning>

Repeats the sound, until you stop it by the command:

stop_sound < index>

destroy_sound < index>

Removes the sound from the memory.

pause

Waits for input. The script wont continue, until the user presses any key.

include < file_name>

Plays the < file_name> comics file. You can make the hierarchy in the files by this command. Its usefull for the good control of the long comics to create one "main" cmx file, that calls the single scenes as you can see in the "intro.cmx".

If you want to learn more, how to create the script look in our *.cmx files. Note: Max number of images is 50. Max number of virtuals is 50. Max number of samples is 20.