Free eat software for linux

Eat The Whistle is an opensource soccer game originally developed by Hurricane Studios as commercial product for the Amiga platform. It has a lot of features never seen in other soccer games.
The original Amiga version has been made portable with the help of the SDL library, now ETW runs on a wide range of machines, the site will keep precompiled binaries for Win32, Linux, MacOSX, AmigaOS, but its possible to adapt it to run on every platform supported by SDL.
Main features:
- System friendly. Run in a window or fullscreen, can be played also on old machines (runs pefectly on a P200).
- World cup, leagues, cups with real teams (with slightly modified names).
- Time synchronized, faster CPU get faster framerate but not faster gameplay.
- Can be played through keyboard or joypad/joysticks (USB or Gameport).
- Network playing through TCP/IP (not yet finished).
- Very intuitive control method with acceleration/deceleration.
- More than 550 frames of animations for the players, 300 for the goalkeeper, 100 for the refree and a lot of other graphics.
- 30 different fields, including muddy, frozen and wet (actually only one included in the demo version to contain the archive size).
- Fouls, corners, throw-in with an intuitive control system.
- Role playing. (You can play a match as the whole team or only as a player).
- About every thing in the game is configurable via intuitive menus.
- Game Tactics and tactic editor.
- Heading and other special shots with intuitive controls.
- Team players (with individual stats) and team editor (the editor is actually available only for AmigaOS).
- Import SWOS teams.
- Arcade-like actions for "arcade mode" (powerups, bonuses... something like speedball II).
- Replays (with load/save option).
- Spoken comment (actually broken).

Fat Fish is an attractive and funny arcade game.

Are you prepared to meet the most hungry fish of the ocean?... Fat Fish is a game where you take the control of a fish who has a insatiable stomach and must to eat his victims who falls infinitely into the ocean.

The game has 4 different objectives, or rather, 4 short-games where you will entertain trying to complete them. During the game and according to how much you eat, you will start to find out that the fish will lose his agility little by little... here is the part where the toilet that is in the right-bottom of the ocean takes part of the game letting you to "shit" to recover your agility and to continue with your food.

Fat Fish has a simple and funny graphic design, it also has funny music and powerful sound effects that give the game a extra points of fun and adiction.
You will be able to setup your controls, the video mode, sound, music, graphic effects and all the necesary to setup de game according to the needs of your computer or according to your preferences.

MouseTrap is a challenging old-style puzzle game, involving you collecting fruit and avoiding the enemy red dots.
The aim of the game is to eat as many of the white fruit pieces as you can possibly manage before dying. Your reaction times will tested to the limit!
The enemy (red) balls are limitted in their movements - they are constrained to either move horizontally, vertically, or diagonally but they will not change their direction.
Dodging the enemy balls becomes very challenging once there are a lot on the screen at the same time. It requires as much thought as reaction speed.
Use the arrow keys to move your avatar around, eating the white "fruit" and avoiding the red "enemies". If you eat a blue "fruit" you will gain a shield which will allow you to kill any of the enemies you bump into instead of dying yourself.
Apart from using the arrow keys to control your avatar you can use the following keys:
- n == New game
- q == Quit & Exit.
- Space toggles pause.
Enhancements:
- Fixed scoring bugs.
- Made the game-over animation less annoying.

Mathfun.py project s a rather small Python library that contains some of the more obscure (others would say less useful 8^) mathematical formula/functions that I have always found interesting/amusing.

These include primality tests, fibonacci sequences and turning characters into numbers, among other things. The next paragraph includes a little story about my strange habits as a teenager. The paragraph after that contains some ramblings about primes and formulas.

The paragraph after that hasnt been decided on yet, but you can be assured that it will be more stream-of- consciousness rambling about something mathematic by yours truly.

One of the reasons that this library exists is that, as a junior programmer in high school, I spent an insane amount of time writing BASIC programs on our IIgs that would calculate the first 100 primes or some other such nonsense. I would write it one way, get out a stop watch, run it, record the time it took, rewrite it, rerun it, retime it and calculate the difference as percentage decrease in time. Repeat the previous until you get BASIC that looked like an explosion in a type factory. All in some sort of quest to... well, I dont really know what I was shooting for. I just enjoyed it. Calculating if a number was prime, calculating the prime factorization, calculating the first N prime numbers... Yeah, I was a strange one.

But, in retrospect, all that solitary math kinda helped. While I reinvented many a prime wheel, I did it on my own, which was something of a personal fulfillment once I had learned more of a history of mathematics. And I never forgot most of those formulas that I worked out on that Apple. For instance, mathfun.isprime(number) utilizes most of what I learned back in high school. It iterates through the odd numbers, up to the integer value of the square root of the number in question. I still remember the epiphany that I had that I only needed to calculate through the square root of the number. 8^)

Theres a minor paradox with the calculation of a prime. The quickest way to generate primes would be to only attempt modular arithmetic with prime numbers. However, to do it that way means that you have to generate a list of prime numbers first, which involves a primality test on every odd number up to the square root of the number in question. This would be sloooooow for the primality test for any single number. (For instance, isprime(10000) would involved roughly 50 full primality tests to generate the list needed to be a maximally efficient test on it.) So, we accept that even if were not going to get any results doing (N mod 9), its much quicker to eat those wasted cycles than to determine if 9 is prime first.

However, if youre doing nothing more than simply cranking out prime after prime, it becomes much more efficient to only do the primality test with a list of primes, since (if you start from 2) youve already determined the ealier ones before. (Theres probably a break-even time first (machine dependent) before "determine all primes with primes" becomes more efficient than "crank through the odd numbers".) Its easy to see however, that for very large numbers its much better to only work with primes.

Theres also a minor question of the speed of the data structures used to store the prime list versus the very fast next odd number test. However, Ill leave that one up to the True Computer Scientists.

foundation Perl module to inheritance without objects.

SYNOPSIS

package Foo;

sub fooble { 42 }

package Bar;

sub mooble { 23 }
sub hooble { 13 }

package FooBar;
use foundation;
foundation(qw(Foo Bar));

sub hooble { 31 }

print fooble(); # prints 42
print moodle(); # prints 23
print hooble(); # prints 31 (FooBar overrides hooble() from Bar)
print SUPER(hooble); # prints 13 (Bars hooble())

Havent drunk the OO Kool-Aid yet? Think object-oriented has something to do with Ayn Rand? Do you eat Java programmers for breakfast?

If the answer to any of those is yes, than this is the module for you! foundation adds the power of inheritance without getting into a class-war!

Simply use foundation and list which libraries symbols you wish to "inherit". It then sucks in all the symbols from those libraries into the current one.

Functions

foundation

foundation(@libraries);

Declares what libraries you are founded on. Similar to use base.

SUPER

my @results = SUPER($function, @args);

Calls the named $function of the current packages foundation with the given @args.

Similar to $obj-SUPER::meth();>

Genuts Snake project is a remake of the popular classic snake game.
Eat as many mice as possible, Dont hit the walls, and dont bite your tail. Genuts Snake uses the Genuts Framework.
How to play?
- Eat as many mouses as possible.
- Dont hit the walls.
- Dont bite your tail.
The snake is moving all time, you can not stop it. Use the keyboards arrows to control it.
The more you eat mouses, the longer the snakes tail grows and the higher your score will be.

DeadlyCobra project is a game similar to the classic Nibbles or snake game.
Basically the point of the game is to eat as many pebbles (in this case "Men") as possible without eating yourself or hitting a wall.
Features include both single and multiplayer modes, cool 2-D graphics and energizing music for each level.
It was originally designed to compete in No Starch Presss game cometition, but has continued to evolve and grow beyond the December 1st, 2001 deadline.
Main features:
- 2 Single player modes:
- Adventure & Longest Snake
- 2 Head to Head multiplayer modes:
- Standard & Instant Respawn
- Simple design, keeping the program small
- 4 targets w/ individual movement patterns
- 9 difficulty increments
- 3 different levels
- Music for each level
- Sound effects
- High score save