Free moon trailer software for linux

FreevoLive is a live cd, running Mandriva Linux, with Freevo preinstalled. It is meant to show people why Freevo is the way to go for your Home Theater PC!
The CD was build with the mklivecd scripts from MCNLive, which is a live cd created by members of the Dutch MandrivaClub.
Enhancements:
- Updated Freevo to version 1.7.3
- Re-enabled the apple-trailers plugin
- Enabled the new lyrics plugin
- Removed Xine and TVTime (They are not needed by Freevo, and thus dont need to be on the cd, if you want them, you can manually install them).

PDL::Transform::Cartography Perl module contains useful cartographic projections.

SYNOPSIS

# make a Mercator map of Earth
use PDL::Transform::Cartography;
$a = earth_coast();
$a = graticule(10,2)->glue(1,$a);
$t = t_mercator;
$w = pgwin(xs);
$w->lines($t->apply($a)->clean_lines());

PDL::Transform::Cartography includes a variety of useful cartographic and observing projections (mappings of the surface of a sphere), including reprojected observer coordinates. See PDL::Transform for more information about image transforms in general.

Cartographic transformations are used for projecting not just terrestrial maps, but also any nearly spherical surface including the Sun, the Celestial sphere, various moons and planets, distant stars, etc. They also are useful for interpreting scientific images, which are themselves generally projections of a sphere onto a flat focal plane (e.g. the t_gnomonic projection).

Unless otherwise noted, all the transformations in this file convert from (theta,phi) coordinates on the unit sphere (e.g. (lon,lat) on a planet or (RA,dec) on the celestial sphere) into some sort of projected coordinates, and have inverse transformations that convert back to (theta,phi). This is equivalent to working from the equidistant cylindrical (or "plate caree") projection, if you are a cartography wonk.

The projected coordinates are generally in units of body radii (radians), so that multiplying the output by the scale of the map yields physical units that are correct wherever the scale is correct for that projection. For example, areas should be correct everywhere in the authalic projections; and linear scales are correct along meridians in the equidistant projections and along the standard parallels in all the projections.

The transformations that are authalic (equal-area), conformal (equal-angle), azimuthal (circularly symmetric), or perspective (true perspective on a focal plane from some viewpoint) are marked. The first two categories are mutually exclusive for all but the "unit sphere" 3-D projection.

Extra dimensions tacked on to each point to be transformed are, in general, ignored. That is so that you can add on an extra index to keep track of pen color. For example, earth_coast returns a 3x< n > piddle containing (lon, lat, pen) at each list location. Transforming the vector list retains the pen value as the first index after the dimensional directions.

Planets is a simple interactive program for playing with simulations of planetary systems, released under the GPL. The project runs on Linux and Windows, and could doubtless be ported to your favorite flavor of Unix.
Planets was originally designed for kids, in particular, for my then 4-year old nephew who is fascinated by astronomy. The user interface is aimed at being simple enough that a fairly young kid can get some joy out of it. But the adults who have used it have found it to be pretty fun as well.
The code is not bug-free, and Planets is missing some significant features. But its pretty stable and is a fun toy to play with. If you do download it, please drop me an email and tell me about your experience with it.
Main features:
- Saving and loading of universes
- Infinite undo (erase last action) and goback (return to point in time just after last action). This allows for undoing mistakes and replaying interesting configurations.
- Traces of planet trajectories
- Two ways of dealing with planet collisions:
- merges, where the colliding planets are merged into one planet, and
- bounces, where the colliding planets are bounced off each other elastically. This itself comes in two varieties:
- force bouncing, where the force between planets is made repulsive at close quarters.
- true bouncing, where simple pool-table physics calculations are made to determine when planets collide, and compute the appropriate bounce from said collision.
- kidmode, a mode where the focus is (mostly) locked on the application, and interesting changes are initiated by merely banging on the keyboard. This mode is aimed at 1-5 year olds.
- Center-of-mass following: it is possible to follow the center of mass of a subset of the planets. Thus, if you have a sun-moon-planet system, you can have the view automatically track the moon-planet pair.
- Can display kinetic, potential and total energy of the system.
- Both the gravitational constant and the gravitational exponent can be changed.
- There is a simple control panel that makes it possible to see and change the simulation options.
- Zooming, panning, and centering on the center of mass.

Trailerfetcher is video conversion application.

As an owner of a small home-cinema system I got an idea: Wouldnt it be neat if before every film you play, mythtv would automatically show you a few trailers of other cool films too come (or already there)?

Trailers would also allow you to "ease into" actually watching the film and cover the whole "lets get the popcorn"-phase, etc.

But I already knew what a hassle it is to download _one_ trailer from sites like yahoo or apple.com. So I decided to make it easy:

This application provides an easy to use interface for downloading trailers. It fetches a list from a trailerpage (currently only yahoo.com) and lists all avalible trailers.

It then summarize the found trailers and displays info about the title, the genre and a short describtion of the plot. All this is fetched and extracted automatically.

You can than mark the trailers you want to download and simply press "Download" to save them to your harddrive.

Ok this was the marketing talk. I wrote this software because I needed it (probably the reason for most open-source-projects), but it is far from feature-complete. It is usable though (it loaded all 73 currently avalible trailers from yahoo.com last night).

AFAIK it is perfectly legal to download these trailers. If anyone thinks it isnt: please feel free to delete the project.

Usage notes: Set the settings before retrieving the list! Some settings (e.g. the resolution) will not take effect if you dont.

Barbie Seahorse Adventures Deluxe game allows you to help barbie the seahorse float on bubbles to the moon. This is a retro-side scroller game. It won the teams category in pyweek 4. Includes original soundtrack, graphics, and 15 levels!

fbdump is a simple tool that captures the contents of the visible portion of the Linux framebuffer device and writes it to the standard output as a PPM file.
In other words, it takes a screenshot of anything running on the framebuffer. The project currently has fairly complete support for packed-pixel framebuffer types and also works with the VGA16 framebuffer driver.
fbdump was inspired by an even simpler program I came across ages ago called fbsnap, which I believe was written by Gerd Knorr (although no author is mentioned in the source code of that program, so I could be wrong). fbdump bears little relationship to fbsnap, however, and is generally much more useful. It supports framebuffers employing a greater variety of pixel and colour models, works (should work?) on big- and little-endian architectures, and is reasonably quick (although reading from video memory is never going to be super fast).
I first wrote fbdump many moons ago when I needed a quick and simple way to grab lots of images from the framebuffer. As most of you will probably know, although its possible to do a raw framebuffer dump by performing a simple cat /dev/fb0 command or similar - depending on what pixel format and colour model your framebuffer uses - the results are not always particularly useful. With fbdump, on the other hand, you always get a nice, portable, 24-bit, true-colour image - since it takes care of any pixel format or colour-space conversion required (at least for formats it supports).
Why does fbdump save the image as a PPM - rather than, for instance, a PNG - you might ask? Well, a PPM is cheap to write out and doesnt require linking against any external libraries to do so. On the x86 architecture, fbdump currently compiles down to a miniscule 8K executable once stripped - and has no dependencies other than the standard C library. Having said that, I may get around to adding support for PNG at some point. Its not strictly necessary, though, because with the NetPBM package its easy to convert PPMs into something more useful. For example, you can do something like
fbdump | pnmtopng > grab.png
to output the framebuffer as a PNG. PPMs can also be read directly by most open source image processing packages, such as the Gimp and ImageMagick.
Usage
fbdump currently supports the following command-line options:
-fb < string > Specifies the framebuffer device to grab from is < string >
-vt < num > Bring virtual terminal number to the foreground before grabbing (and return to the current terminal afterwards)
-delay < num > Delay seconds after switching, but before grabbing.
If the -fb option is not provided, fbdump defaults to grabbing from the device /dev/fb0. You can also specify the framebuffer via the environment variable FRAMEBUFFER (a value supplied with the -fb switch on the command line will override this). For example:
FRAMEBUFFER=/dev/fb1 fbdump >out.ppm
Enhancements:
- A fix for a long-standing bug in handling of colour maps, support for 64-bit architectures and a lot of cleaning up.

Qonk project is a game I wrote to learn some SDL basics. The game is a small build-and-conquer strategy game with very simple rules. A complete game only lasts for a few minutes and can be a fun break away from work or whatever youre doing.
The setting of the game is a solar system of planets. Your goal is to conquer all of the planets in the game by sending ships there. Planets that are under your control generate new ships. Simple AI players are playing against you. As you gain more experience throughout the game, more AI players have to be kicked out of bigger solar systems.
The game is currently very much in beta. I published it however in order to see whether it compiles on other machines, and to see what reactions people had on its gameplay. The game engine itself is fully functional. A lot of things have to be added to make this a mature game (like menus and stuff), but since the engine itself works, Qonk is already very playable.
How to run
In order to change between levels, Qonk exits and parameters for the game and its level have to be entered from the command line. After a game, Qonk will tell you how to start Qonk again when exited. This is because Im too lazy to write a decent menu system (everyone who is interested, may add a menu system to the source), and only interested in hacking and tuning he game engine, its graphics and obviously, game play.
Rodolfo Borges provided a small shell script that helps starting the game, saving your current level, and moving to new levels automagically. You have to edit the file to change the path where you have installed Qonk before running it.
Qonk can be given two numeric parameters, the first denoting the number of planets in the solar system, the second gives the number of enemy AI players. Successive levels of the game are defined by two such parameters.
The first levels in the game are given by parameters (6 1), (7 2), (8 3), (9 4), (10 5), (10 6), (10 7), (10 8), (10 9), (11 10), (12 11), ... I managed to get to about (35 34) before I got bored with it and started over again. I have also managed to win a (100 99) game once. That was pretty hectic.
Although the game engine is prepared to run under different modes, the game always defaults to 1024x768 resolution, and goes into fullscreen modus to run qonk. (because of beta status)
How to play
You select ships and send them out to planets, to attack or fortify them. A ship that arrives at an enemy planet dies and kills an enemy ship, residing on that planet, along with it. If no enemy ships are based on the planet, you take over the planet. Planets under your control grow new ships for you to send around.
You control white planets and white ships. Colored planets belong to the opponent players. Gray planets are not controled by a player and can easily be conquered, once its resident neutral ships are destroyed (about 2-4 of them on each neutral planet).
There are two types of planets in the solar system. There are planets orbiting around the "sun" and moons orbiting around the planets. There are as many moons as planets in each solar system. Some planets may have more moons than others. A planet is expected to generate twice as many ships as a moon in the same amount of time. Some planets/moons build ships more quickly than others. Each ship also has a random speed.
Select ships by dragging your left mouse button. A ship can only be selected for an action if it resides on a planet. Use the right mouse button to send selected ships to the nearest planet to the mouse pointer. If you want to select all of the available ships, press A.
As you conquer more planets, more ships are built in parallel. Try to conquer as many planets as possible, so that many new ships are constructed and you can reign over the solar system.
There are some extra keys that can be used:
- While pressing E, the ships of enemy players are shown, so this is kind of a cheat button
- Press P to pause and unpause the game
- Press S to save a screenshot (screenshot.bmp) of the game