Comparison of free software shooters

There have been many free software first-person shooters (FPS) projects over the years, from modded Doom and Quake engines to enhance the existing games (ezQuake, EGL, ZDoom), to free art packs such as OpenQuartz or OpenArena. In 2002, along came Cube, a single and multiplayer FPS based on its own engine, including artwork, maps, models and an ingame map editor. In the freeware (and Linux compatible!) world a little-known game called Legends, a Tribes-inspired game, appeared yet remained closed-source. Filling the FPS gap in the open-source world has usually been left up to commercial companies who release their games with Linux support (i.e. Doom3, Unreal Tournament 2004, Loki Software's work) or freeware games produced by commercial studios(i.e. America's Army, Wolfenstein: Enemy Territory) or simply running Windows games run via wine. In the last few years a few built-from-scratch community-based FPS projects, most built on the GPLed Quake engines, have popped up, among them are Tremulous, Alien Arena, Nexuiz, and War§ow. Some have kept their art assets under a closed license (War§ow), while others have also released their art under an OSS license (Nexuiz).
For this comparison, we'll take a look at active, robust and community-developed free software shooters. Most released free software shooters are designed for multiplayer, a logical step for a game developed in an online community, however most also feature a bot-based single-player mode.This feature seeks to be a little more thorough and go a step further, ranking the following seven games: Alien Arena, Nexuiz, OpenArena, Sauerbraten, Tremulous, War§ow, and World of Padman. In ranking these games, gameplay, design, innovation and presentation (in that order) will be held as primary criteria.

1. War§ow

War§ow is a deathmatch shooter with a focus on freedom of movement, attracting new players and fostering a competitive scene. It is built on Qfusion, a heavy modification of the GPL Quake 2 engine. From the user interface, to the gameplay, to even the netcode the game feels more like an improvement on Quake 3 than anything, stretching far beyond the original Quake 2 engine. Along with World of Padman, wSw stands out in this comparison by actually using colorful and clean graphics as opposed to Quake-inspired dark visuals. Warsow manages set itself even further by using cel-shading to create very clean, yet stunning visuals which regrettably can strain slower systems. In addition, the maps all feature a unique visual style that varies between maps yet retains the clean and cyberpunk visual themes.While sticking to basic deathmatch gamemodes, wSw manages to refine them and remain fun and enjoyable. Weapons are generally the same as Quake 3 and 4, although with a more polished feel. wSw however, implements a dual tier system for ammos. Weapons have weak and strong ammos which add more functionality to the gameplay while still keeping the basics simple. War§ow’s main change on top of basic Quake 3 gameplay is an expansion of movement options, featuring strafejumping and bunnyhopping from Quake along with dash, walljumping and aircontrol. Polish and high quality standards are what make War§ow the free software FPS to beat. All aspects, from movement to maps to the gamemodes, seem refined and balanced. It was not until the mid-2007 release of the 0.3x version (currently 0.32) that wSw became refined enough to set itself apart from the others mentioned here. While many of the previously mentioned games have good original ideas and interesting features, they do not present games that match the quality of commercial offerings. In terms of multiplayer features and customizability, War§ow matches and outclasses any released commercial deathmatch game. Many of the other games seem to fall into the common trend in free software projects: lots of great ideas without friendly and useful implementation, while War§ow is in the style of Firefox, polished and accessible. Maps seem to have serious consideration for item placement and flow, voice-overs seem clean and crisp, lag-compensating network code keeps online play smooth. While many games seem to concentrate in only one area, Warsow seems to do well in almost every area. teamplay, 1v1, new players and experienced players all have been considered in design. Out of the previously mentioned games War§ow also has the largest community with over 250 servers. Competitive gaming is a key part of wSw and there exists a very large competitive community, for example, an international LAN competition was hosted in 2007. Competition drives many of the design decisions behind the game, and always leaves players with something to do and strive for. This also leads to the game's largest flaw, a steep learning curve that pushes wSw beyond the scope of many casual gamers; although the newly added Clan Arena mode lets new players have a simple gamemode where they can stand a bit more of a chance. wSw thrives on bunnyhopping and strafing skills which take time to develop, tutorial videos exist but lack of an ingame tutorial seriously limits adoption. The high quality art direction, the implementation of some simple yet effective original ideas, combined with the refined Quake gameplay leaves War§ow the champion of the pack for free software shooters. Warsow was able to do what many free software projects strive for, take an established concept, clearly implement additional original ideas, refine the core of the project, and then present it in a very professional way.

2. Tremulous

Tremulous sets itself aside from all of the previous games in that it isn’t a FFA deathmatch game. Instead Tremulous is a team-based game with aliens vs. humans where each team constructs a base and players are given the ability to obtain individual upgrades. With a kill-based point system, Tremulous rewards combat, allowing players to get better equipment so they can better attack the opponents. The two teams are unique and the concept and style of the game is rather original. If anything, Tremulous can be related to the Half-Life mod Natural Selection, although without the RTS commander mode. Tremulous has had a very constant release cycle with the latest 1.1 being released about a year ago and the community and development remaining active. The game is based on the Quake 3 engine, and although there are only 8 maps, they’re all varied, unique and high-quality. The only notable flaw was that the options menu didn’t show up until the player joined a game. Tremulous has rich gameplay but still very accessible to new players, featuring onscreen help and tips while you play. To further the point, Tremulous comes with a descriptive and friendly manual for those who want to learn the details of the gameplay. The game is simply fun; there is just action for those who want a simple game and tons of features and detail for those that want a bit more. The graphic design is consistent, dark and sci-fi futuristic with a bit of variance but a lot of consistency. The game has a large following as far as free software goes with a about 200 servers and at least a couple games any time of day. The performance is clean and consistent and it looks as good as Quake 3 generation mods. Tremulous is one of the few free software projects to combine an original idea with a polished implementation and good direction. The few maps and one gamemode really keep the style focused and clean. Tremulous could use more maps, more variety, more content and perhaps more robust gameplay, but 1.1 is a great release and future versions are definitely something to watch out for.



3. World of Padman

World of Padman originated as a modification on top of Quake 3 in 2004. With the release of GPL licensed Quake3 code, World of Padman was released as a stand-alone game on top of ioquake3. From that perspective, World of Padman was designed more in the style of the mod community (art-driven projects) than that of the free software community (code-driven projects) but nonetheless, its free software now. The game is based on a comic book and has unique colorful graphics with clear comic inspiration. World of Padman gameplay is very similar to that of Quake3, a little bit different, a little refreshing, but nothing too strikingly new. Killing other players is satisfying and just silly fun. If anything, World of Padman is proof that deathmatch gaming doesn’t need to be blood-covered, violent and serious; it can be silly, cutesy and fun. World of Padman features several maps, each quite unique and but fitting with a common style. For example, players are characters about 3cm high and fight in real rooms like a bedroom, library, kitchen, etc. It’s not a new approach for maps, but it definitely is fun and interesting; combined with World of Padman’s art direction, this leaves for rather refreshing arenas. And while maps like this sure are great free-for-all fun, they aren’t really designed for competitive play, limiting potential for a hardcore community (the driving force of many shooter games). Gameplay is similar to Quake3 with slower rockets and a very satisfying machine gun being the most notable differences. It has a small community at about 26 servers but the large installer above 500MB might be slowing adoption. The game is very polished , it has several gamemodes (including a unique “Spray your Color” mode) but gameplay still boils down the basic Quake-like fragging. While World of Padman is not, by any stretch of the imagination, a bad game, it lacks the innovative gameplay design goals of several of the games features here, it feels like Quake with polish and restructured objectives. While the game has great style rivaling the stylistic nature of any commercial game, it lacks advanced graphical features of Nexuiz & Sauerbraten or unique gameplay features of Nexuiz & Alien Arena. If you want to see what the gothic Quake 3 would look like if it were designed by color-loving comic artists with a sense of humor and a sense of fun style, World of Padman is exactly what you’re looking for but regrettably that’s about as far is it goes at the moment.

4. Nexuiz

Nexuiz is another game that follows the fast, dark, and intense free-for-all deathmatch style first set down by Quake 1 in 1996. Nexuiz curiously enough is built on the Darkplaces engine, an expanded version of the GPL released Quake 1 source. While the basic graphics are seem to be up to Quake 3 standards, expanded lighting options allow the graphical features to be brought up to just below Quake 4 standards. Although the newest version still follows that simple deathmatch style, the fast, varied maps and lots of explosive action with interesting two fire-mode weapons leads to gameplay that is about as intense as it gets for shooters. Good sound combined with varied and unique weapons attests to the polish that has gone into bringing Nexuiz up to version 2.3. Nexuiz has lots of maps which seem to be slightly varied in style, but still are predominantly covered with dark overtones. While most of the game is cleaned up far beyond its Quake 1 roots, it is still lacking in presentation with the menu being very circa 1990s. The community is strong and with about 80 servers, and finding a game is fairly easy. Nexuiz has lots of content, style and features and is very well done for a FFA game but some areas could use some more work and showcasing of its unique features and modes.

5. Alien Arena

Alien Arena is a Quake 2 based deathmatch game that tries to draw on a conflict between humans and aliens. However this distinction between two player types rarely stretches beyond player models. The latest release, Alien Arena 2007 6.10, still has many visual characteristics that appear outdated and reminiscent of Quake 2. Although there are game modes such as deathball, CTF, and assult, with a dark artistic style, fast gameplay with strong weapons, Alien Arena is predominantly a deathmatch game. The original game modes aren’t very well presented and seem to be underutilized, which is a shame because they seem to be fairly innovative. For example, Alien Arena includes vehicles in certain game modes, but the feature is hidden away on a few rarely-played and rarely-promoted maps. Although the external server browser and main menu are very nice, much of Alien Arena seems to be muddled and lacking polished design. The HUD lacks many critical features like a weaponlist or a clock, and the icons and graphics are not clear. Alien Arena lacks many obvious gameplay features that have become standard in modern games, like removing the quad powerup for the duel gamemode. While many of the weapons seem to be recreations of weapons in Unreal and Quake, the two fire modes for each weapon adds interesting diversity on top of Quake-inspired gameplay rules. But overpowered nature of the weapons, especially the chaingun, leaves much to be desired from the gameplay. The community isn’t very large at about 60 servers, but the game seems to be a bit lacking in clean presentation so it may not be as attractive to new players. Alien Arena seems to be working with lots of new and interesting original concepts but still needs work to match the artistic and gameplay quality of the other games covered here. If the project were to shift gears and focus a bit more on polish, design and presentation instead of creating tons of content (which it already has lots of), it has the potential to move beyond "dark FFA deathmatch action" and really be something quite original and remarkable.

6. OpenArena

OpenArena is a project to create GPL-licensed art assets on top of the open-sourced Quake 3 engine. It uses the latest snapshot of the ioquake3 engine and a mix of GPL assets ranging from original work to resources from Nexuiz, Cube and others. OpenArena 0.71 is a fairly large release at over 200MB. Most of the space is spent on many maps and models, some of which are regrettably lacking in quality. Some are straight recompiles of the GPL released Quake 1 maps (oa_dm1-7), which fail to use many of the advanced lighting and detail offered in the new engine. OpenArena seems to generally lack coherent art direction or design; most the maps, models and artwork seems like a half-done mix of Quake 3’s gothic architecture and anime. The gameplay stays true to what was included in Quake3, so it can be rather enjoyable. On the other hand, much of Quake 3 Arena's popularity came from being done in such a simple, directed, and polished manner and OpenArena lacks much of the polish that made Quake3 so enjoyable. However, the project is still in its early stages and the task at hand is a rather large one. The goal of recreating GPL Q3A artwork on top of the GPL code is both noble and a great contribution to the community. OpenArena games still seem limited to FFA and with about 70 servers, the community is rather small. While Q3A gained popularity as a competitive game, the developers of OA don’t see that as a target market so the depth of gameplay is unlikely to expand. At the moment, most the games on this list display far better art direction and design, which is regrettable as OpenArena is the most art-driven and least code-driven game in the group. At the end of the day though, OpenArena is about making a free game that has lots of simple & fun deathmatch action a la Quake3, and that is where it succeeds.

7. Sauerbraten

Sauerbraten is basically Cube 2, the sequel to one of the most influential free software shooters released to date. The engine is completely reworked with brand new graphics rendering features rivaling that of Quake4. Like Cube, Sauerbraten has a built-in map editor that allows player to edit maps from within the game, making this one of the friendliest games for content-creation. The latest version of Sauerbraten, 2007-09-04, is little more than a subversion snapshot packaged and stabilized for wider distribution; the game is still in heavy development. Sauerbraten gameplay drastically differ from anything Cube offered, with simple Quake-style weapons, game effects, and the same Quake3-like FFA action. It is worth noting that Cube (and Sauerbraten) give you a weapon when you pick up the appropriate ammobox; there is no separation between ammo and weapons.While it has some cool features, the game still feels like more of a concept demo than an actual game, and with only 20-30 servers, half running instagib, there isn’t much of a community following. Single player is reminiscent of Quake1, with enemy monsters in a variety of maps. The menu is actually one of the coolest I’ve seen implemented in a game, it spawns as an object ingame and faces you, however the lack of a main menu upon load adds to the tech-demo feel. Despite the tech-demo nature of the game, Sauerbraten has a good soundtrack, lots of maps, good quality models, well-done artwork and textures. The gameplay isn’t anything astounding but with pretty decent maps and gameplay reminiscent of Quake3, Sauerbraten definitely offers something for people who just want some simple mindless action with some eye candy. Sauerbraten is a really cool project, but right now it remains that, a project of what can be done, more than a game.

source:
http://www.linux-gamers.net/smartsection.item.81/comparison-of-free-softwareshooters.html

"Shut Not Your Doors

Shut not your doors to me proud libraries,
For that which was lacking on all your well-fill'd shelves, yet
needed most, I bring,
Forth from the war emerging, a book I have made,
The words of my book nothing, the drift of it every thing,
A book separate, not link'd with the rest nor felt by the intellect,
But you ye untold latencies will thrill to every page."

LEAVES OF GRASS By Walt Whitman :)

A Quick Insight

It's not a filter at all, it's a recursive estimator which is very convenient to implement as a computer algorithm ; i.e. for each instance, you use the previous output as an input.

To grasp the meaning of Kalman Filter by starting from definitions and complicated equations is nearly impossible.The equation below, is much easier to start with.

The k's on the subscript are states. Here we can treat it as discrete time intervals, such as k=1 means 1ms, k=2 means 2ms.

Our purpose is to find , the estimate of the signal x. And we wish to find it for each consequent k's.

Also here, is the measurement value. Keep in mind that, we are not perfectly sure of these values. Otherwise, we won't be needing to do all these. And is called "Kalman Gain" (which is the key point of all these), and is the estimate of the signal on the previous state.

The only unknown component in this equation is the Kalman Gain . Because, we have the measurement values, and we already have the previous estimated signal. You should calculate this Kalman Gain for each consequent state.

On the other hand, let's assume to be 0.5, what do we get? It's a simple averaging! In other words, we should find smarter coefficients at each state. The bottom line is :

"Kalman filter finds the most optimum averaging factor for each consequent state;& somehow remembers a little bit about the past states."

Build a Model

First of all, we must be sure that, Kalman filtering conditions fit to our problem.

The two equations of KLF are:

It means that each x_k (our signal values) may be evaluated by using a linear stochastic equation (the first one). Any x_k is a linear combination of its previous value plus a control signal u_k and a process noise (which may be hard to conceptualize). Remember that, most of the time, there's no control signal u_k.

The second equation tells that any measurement value (which we are not sure its accuracy) is a linear combination of the signal value and the measurement noise. They are both considered to be Gaussian.

The process noise and measurement noise are *statisticlly independent. [*(of events or values) having the probability of their joint occurrence equal to the product of their individual probabilities.] The entities A, B and H are in general form matrices. But in most of our signal processing problems, we use models such that these entities are just numeric values. Also as an additional ease, while these values may change between states, most of the time, we can assume that they're constant. If we are pretty sure that our system fits into this model , the only thing left is to estimate the mean and standard deviation of the noise functions Wk-1 and vk. We know that, in real life, no signal is pure Gaussian, but we may assume it with some approximation. This is not a big problem, because we'll see that the Kalman Filtering Algorithm tries to converge into correct estimations, even if the Gaussian noise parameters are poorly estimated. The only thing to keep in mind is : "The better you estimate the noise parameters, the better estimates you get."

Starting the Process

When you fit your problem(model) into the KLF, the next step is to determine the parameters and the initial values.

We have two distinct set of equations :

*Time Update (prediction) and *Measurement Update (correction). Both equation sets are applied at each k^th state.

[*Can be derived from the linear stochastic difference equation (2 equations of KLF), by taking the partial derivative and setting them to zero ]

Time Update (prediction)

Measurement Update (correction)

When we make the modeling , we know the matrices A, B and H. Most probably, they will be numerical constants.(And even most probably, they'll be equal to 1.)

R is rather simple to find out, because, in general, we're quite sure about the noise in the environment. But finding out Q is not so obvious.

To start the process, we need to know the estimate of x₀, and P₀.

Iterate

Since we gathered all the information we need and started the process, now we can iterate through the estimates. Previous estimates will be the input for the current state.

Here, is the "prior estimate" which in a way, means the rough estimate before the measurement update correction. And also is the "prior error covariance". We use these "prior" values in our Measurement Update equations. In Measurement Update equations, we really find which is the estimate of x at time k (the very thing we wish to find). Also, we find which is necessary for the k 1 (future) estimate, together with . The Kalman Gain ( ) we evaluate is not needed for the next iteration step, it's a hidden, mysterious and the most important part of this set of equations. The values we evaluate at Measurement Update stage are also called "posterior" values. Which also makes sense.

source: http://bilgin.esme.org

********************************************************

A Simple Example

Now let's try to estimate a scalar random constant, such as a "voltage reading" from a source. So let's assume that it has a constant value of aV (volts) , but of of course these are noisy readings above and below a volts. And we assume that the standard deviation of the measurement noise is 0.1 V.

Now let's build our model:

We have reduced the equations to a very simple form.

• Above all, we have a 1 dimensional signal problem, so every entity in our model is a numerical value, not a matrix.

• We have no such control signal u_k, and it's out of the game

• As the signal is a constant value, the constant A is just 1, because we already know that the next value will be same as the previous one. We are lucky that we have a constant value in this example, but even if it were any other linear nature, again we could easily assume that the value A will be 1.

• The value H = 1, because we know that the measurement is composed of the state value and some noise. You'll rarely encounter real life cases that H is different from 1.

Let's as

TIME (ms)	1	2	3	4	5	6	7	8	9	10
VALUE (V)	0.39	0.50	0.48	0.29	0.25	0.32	0.34	0.48	0.41	0.45

We should start from somewhere, such as k=0. We should find or assume some initial state. Here, we throw out some initial values. Let's assume estimate of X₀ = 0, and P₀ = 1. Then why didn't we choose P₀ = 0 for example? It's simple. If we chose that way, this would mean that there's no noise in the environment, and this assumption would lead all the consequent to be zero (remaining as the initial state). So we choose P₀ something other that zero.

Let's write the Time Update and Measurement Update equations.



Now, let's calculate the values for each iteration.

Here, I displayed the first 2 state iterations in detail, the others follow the same pattern. I've completed the other numerical values via a computer algorithm, which is the appropriate solution.

The chart here (right) shows that the Kalman Filter algorithm converges to the true voltage value. Here, I displayed the first 10 iterations and we clearly see the signs of convergence. In 50 or so iterations, it'll converge even better.

To enable the convergence in fewer steps, you should

• Model the system more elegantly
• Estimate the noise more precisely

Applications of KLF (Research Papers)

1.An Extended Kalman Filtering Approach to Modeling Nonlinear Dynamic Gene Regulatory Networks via Short Gene Expression Time Series

In this paper, the extended Kalman filter (EKF) algorithm is applied to model the gene regulatory network from gene time series data. The gene regulatory network is considered as a nonlinear dynamic stochastic model that consists of the gene measurement equation and the gene regulation equation. After specifying the model structure, the EKF algorithm is applied for identifying both the model parameters and the actual value of gene expression levels. It is shown that the EKF algorithm is an online estimation algorithm that can identify a large number of parameters (including parameters of nonlinear functions) through iterative procedure by using a small number of observations. Four real-world gene expression data sets are employed to demonstrate the effectiveness of the EKF algorithm, and the obtained models are evaluated from the viewpoint of bioinformatics.

2.Relaxed parametric design with probabilistic constraints

Parametric design is an important modelling paradigm in computer-aided design. Relationships (constraints) are specified between the degrees of freedom (DOFs) of the model, instead of the DOFs themselves, resulting in efficient design modifications and variations. Current parametric modellers require an exact specification of all the constraints involved, which causes overwork for the designer during design iterations. The relaxed-parametric-design modelling paradigm is described, in which decisions which needlessly limit the freedom of design in later stages are avoided. The designer usesb soft constraints, and specifies the level of exactness with which they are to be met. As a specific scheme for implementing relaxed parametric design, probabilistic constraints are presented, where a parametric model is viewed as a stochastic process. The softness of a constraint is represented as the covariance of a suitably distributed random variable. A novel method is described of expressing the DOFs and the model as a system of probabilistic equations, which is then solved using the Kalman filter, a powerful estimation tool for stochastic systems. An a priori covariance matrix associated with a DOF can be used as a guideline for the solver to select a particular solution from multiple solutions.

3.An alternative Kalman innovation filter approach for receiver position estimation based on GPS measurements

This article presents an alternative Kalman innovation filter approach for receiver position estimation, based on pseudorange measurements of the global positioning system. First, a dynamic pseudorange model is represented as an ARMAX model and a pseudorange state-space innovation model suitable for both parameter identification and state estimation. The Kalman gain in the pseudorange coordinates is directly calculated from the identified parameters without prior knowledge of the noise properties and the receiver parameters. Then, the pseudorange state-space innovation model is transformed into the receiver state-space innovation model for optimal estimation of the receiver position. Hence, the proposed approach overcomes the drawbacks of the classical Kalman filter approach since it does not require prior knowledge of the noise properties, and the receiver's dynamic model to calculate the Kalman gain. In addition, due to its simplicity, it can be easily implemented in any receiver. To demonstrate the effectiveness of the approach, it is utilized to estimate the position of a stationary receiver and its performance is compared against two versions of the classical Kalman filter approach. The results show that the proposed approach yields consistently good estimation of the receiver position and outperforms the other methods.

4 Parallel computation of the modified extended kalman filter

In this paper, certain techniques for mapping the modified extended Kalman filter (MEKF) onto systolic array processors are described. First, a square-root algorithm based on the singular value decomposition (SVD) for the Kalman filteris introduced. Then, VLSI architecture of the systolic array type for its implementation is developed. Compared with other existing square-root Kalman filtering algorithms, this new design is numerically more stable and has nicer parallel and pipelining characteristics when it is applied to the MEKF. Moreover, it achieves higher efficiency. For n-dimensional state vector estimations, the proposed architecture consists of O(3/2n²) processing elements and completes an iteration in time O((s + 8)n), in contrast to the time complexity of O((s + 3)n³) for a sequential implementation, where s ≈ log n.

When you are at a cross road...

To see a world in a grain of sand
Or a heaven in a wild flower,
Hold infinity in the palm of your hand
And eternity in an hour.
WILLIAM BLAKE (1757-1827)

Some good links about research : Thanks to (http://damithakumarage.wordpress.com/)

[1] http://www.cse.iitk.ac.in/users/jalote/GenArticles/ET23-06-03.htm
[2] http://www-2.cs.cmu.edu/~mblum/research/pdf/grad.html
[3] http://www-2.cs.cmu.edu/~harchol/gradschooltalk.pdf