Free online simulation games software for linux

Unlimited Simulator project is a general purpose simulator.
Unlimited Simulator is not a game. Its a basis to create whatever simulations you want, from games to scientific simulations.
You only have to worry about physics, controls and how the world looks like. It can be at the same time a car simulator, a spaceships war game, or a scientific simulation.
While you can do these things on their own, Unlimited Simulator provides the ability to do all three at once. It allows interaction of completely different kinds of clients, thus achieving unprecedent realism and complexity.
Main features:
- multiplayer: many players by internet or two in your computer;
- create your own vehicles, tracks, terrains, sounds, objects;
- vehicles may have their own physical simulation functions, and interact with the game, creating new objects, destroying others. They can fly or float or move underwater; they can be animals, or surrealistic creations. You create.
- track can contain structures as loops, bridges, banked curves, and anything you can do with polygons;
- creating a track can be done DRAWING on the terrain (not implemented yet);
- objects can be animated and intelligent!
- everything is modular: this means almost all the stuff is plugable! No need to recompile the code;
- last, but not least: GPLed!
Enhancements:
- big debugging in ulengine/primitives.c. Several allocation problems solved.
- review of network code: structs separated in a new header, shared/net.h, and other improvements in code itself.
- review of client plugin format (what functions, names, etc).
- wrappers for the not-so-standard standard C variable types in config.h.
- cosmetic changes in some places, specially ulengine.h.
- BIG debugging in ulengine/project.c and ulengine/graphic.c. Only a billion or so bugs left.
- improved ulengine/demo.c; tests now include graphic functions.
- fixed two small bugs in drawHLine due to rounding.
- added a new projection system. Not tested yet.
- graphics test phase started: drawPixel, drawHLine, drawLine, drawFlatTri and drawShadedTri are working.
- modified POLY_UL structure: SCREENP_UL *projected field was deleted. This field is really unecessary, and deleting it saves 2*sizeof(int) bytes for each vertex. Projections are not individually saved anymore (why should they be after all?). See ulengine/project.c:projectP() to see how projected points are handled.
- added ulengine/image.c, to handle image operations.
- added ulengine/effects.c.
- textures support implemented.
- several small optimizations in ulengine/graphic.c.
- work in the server communications system.

Mars Simulation Project is a free software Java project to create a simulation of future human settlement of Mars.
The simulation is a multi-agent artificial society set in a detailed virtual world.
XML configuration files allow the user to modify the simulation properties.
The Mars Simulation Projects main window contains the following components:
- Menu Bar
- Search Tool
- Time Tool
- Mars Navigator
- Monitor Tool
- Rover Info Window
- Settlement Info Window
- Person Info Window
- Unit Bar
The Mars Simulation Project can be configured with a number of XML configuration files located in the "conf/" directory. It is recommended that you save a backup copy of a configuration file before modifying it in case there is an error and the simulation cannot read the modified configuration file.
Here are the configuration files you can modify for the simulation. You will need to start a new simulation for any changes to be loaded in.
- buildings.xml
- crops.xml
- landmarks.xml
- malfunctions.xml
- medical.xml
- people.xml
- settlements.xml
- simulation.xml
- vehicles.xml
Enhancements:
- This release includes the new mission tool for viewing, creating, and editing missions as well as plenty of bugfixes.

breve is a free, open-source software package which makes it easy to build 3D simulations of decentralized systems and artificial life.
Users define the behaviors of agents in a 3D world and observe how they interact. breve includes physical simulation and collision detection so you can simulate realistic creatures, and an OpenGL display engine so you can visualize your simulated worlds.
breve simulations are written in an easy to use language called steve. The language is object-oriented and borrows many features from languages such as C, Perl and Objective C, but even users without previous programming experience will find it easy to jump in. More information on the steve language can be found in the documentation section.
breve features an extensible plugin architecture which allows you to write your own plugins and interact with your own code. Writing plugins is simple and allows you to expand breve to work with existing projects. Plugins have been written in breve to generate MIDI music, download web pages, interact with a Lisp environment and interact with the "push" language.
Enhancements:
- An experimental Python language bridge is now available.
- There were also fixes related to Push language support and fixes for broken demos.

Arithmetic Operations Simulation Librarys aim is to develop an open source library to simulate heavy arithmetic operations efficiently.
Finding different ways to solve a problem has been an interesting way to relax for many people. Not only they derive some kicks out of it, but as a side effect they develop much deeper insight into the problems enabling them to work out solutions under different constraints easily.
Here you will find discussion/hints to solve some common programming problems in efficient ways, supported with code that you can try.
DSP Programming Tricks
Often support for many heavy arithmetic operations goes missing to reduce the chip cost for marketability reasons, or during chip development stages. And we programmers have to make for the lack of these.
Accessing recent N items in history
This problem attracted my attention during DSP guest lectures by Mr. Ganesh Bhokare at PUCSD in later half of 2005. Various programming solutions to this problem would be.
Maintain a circular buffer in an array of N (or N+1) items. This will require support for MOD operation.
In case N is a power of 2, bitwise-anding with (N-1) can be used in place of MOD.
If neither N is a power of 2, nor MOD support is available?
Enhancements:
- This version supports finding the first 1/0 bit from left/right (lsb/msb), 16-bit unsigned numbers multiplication, division and mod operations, and also special cases of division by 3.

Simulation::Sensitivity is a general-purpose sensitivity analysis tool for user-supplied calculations and parameters.

SYNOPSIS

use Simulation::Sensitivity;
$sim = Simulation::Sensitiviy->new(
calculation => sub { my $p = shift; return $p->{alpha} + $p->{beta} }
parameters => { alpha => 1.1, beta => 0.2 },
delta => 0.1 );
$result = $sim->run;
print $sim->text_report($result);

Simulation::Sensitivity is a general-purpose sensitivity analysis tool. Given a user-written calculating function, a "base-case" of parameters, and a requested input sensitivity delta, this module will carry out a sensitivity analysis, capturing the output of the calculating function while varying each parameter positively and negatively by the specified delta. The module also produces a simple text report showing the percentage impact of each parameter upon the output.

The user-written calculating function must follow a standard form, but may make any type of computations so long as the form is satisfied. It must take a single argument -- a hash reference of parameters for use in the calculation. It must return a single, numerical result.

CONSTRUCTORS

new

my $sim = Simulation::Sensitivity->new(
calculation => sub { my $p = shift; return $p->{alpha} + $p->{beta} }
parameters => { alpha => 1.1, beta => 0.2 },
delta => 0.1 );

new takes as its argument a hash with three required parameters. calculation must be a reference to a subroutine and is used for calculation. It must adhere to the usage guidelines above for such functions. parameters must be a reference to a hash that represents the initial starting parameters for the calculation. delta is a percentage that each parameter will be pertubed by during the analysis. Percentages should be expressed as a decimal (0.1 to indicate 10%).

As a constructor, new returns a Simulation::Sensitivity object.