Free cells software for linux

SYNOPSIS

use AFS::Cell qw (configdir expandcell
getcellinfo localcell
whichcell wscell
);

my $conf_dir = configdir;

my $cell = expandcell(mpa);
$cell = localcell;
$cell = whichcell(./);
$cell = wscell;

($cell, my @hosts) = getcellinfo;
print "Cell: $celln";
foreach my $host (@hosts) {
print(" $hostn");
}
NOTE: The following lines are version 1 style: all names are exported by default. This style is deprecated !!!
use AFS; # import all AFS names
use AFS @AFS::CELL; # import just the cell config names
DESCRIPTION ^
This module provides several functions to configure and to maintain an AFS cell. It is used to maintain the configuration directory. Any function required must by explicitly listed by the use statement to be exported into the calling package.
Some of these functions have the optional argument FOLLOW. FOLLOW determines which file should be used should PATH be a symbolic link. If FOLLOW be set to 1, then the symbolic link is followed to its target. If FOLLOW is set to 0, then the function applies to the symbolic link itself. If not specified FOLLOW defaults to 1.

XellPlan is a set of very simple php scripts (by using a Mysql database) to create plans for events and provide a means for people (e.g. volunteers) to enlist for the various positions.
Think of it as a online version of a spreadsheet program, where some cells are editable by users.
NOTE: This is not mature software, rather a quick "hack"- im not very proud of it, but it works quite well.
Main features:
- Unlimited spreadsheet size
- Style cells (bold, italics, font size)
- Track changes (when did who enlist for what kind of job)
- Limit plan modification to a specific date range (e.g. "entry allowed starting dd-mm-yyy 12:00am")
- Password-protected plan entry
- Localizable to different languages (english/german supported out-of-the-box)
- System easy relocatable (just move the installation to another directory)
- Admin login / password protected plans need browser cookie support
Enhancements:
- This release implements the "entry end date" and "plan description" features requested by a user.

Cubulus is an analytic engine and a slice and dice Web interface on top of a relational database (MySQL at the moment).
The project caches calculated cells, and is able to parse basic MDX queries.
Enhancements:
- Rounding has been fixed for MonetDB.
- A bug with keeping the drillpath when dicing has been fixed.
- gen.py generates all tables.

KLines project is a simple logical game.
Klines is a simple logical game, similar to the DOS-based game "Color lines.
You can move the balls by pointing source and destanation cells on the board. You target is to put at least 5 balls of same colors in one line (horisontal, vertical or diagonal) , in case of that they dissapear and you can make one move more, otherwise computer drop randomly another three balls.
Game over then there is no more free cells on the board.
Enhancements:
- Running 3D balls

Clorox is shared memory for AJAX applications. Clorox provides data structures that look exactly like ordinary JavaScript objects but that actually make AJAX RPC calls behind the scenes to fetch data.
Since many web applications can be thought of as viewers over structured data (grids of map cells, arrays of email messages, etc), and RPCs and callback functions are a pain, this abstraction makes writing applications much easier. Additionally, Clorox makes it simple to define data caching and prefetching policies to boost performance.
No new languages: Clorox applications are 100% JavaScript, and they play well with other toolkits.
Clorox is a new way of writing highly-interactive web applications. Its based on a single observation: that many web applications serve as viewers over structured data. Email clients display lists of messages. Mapping applications display grids of map cells. Search auto-complete applications display nodes in a trie containing completion strings. Today, such applications are often written using AJAX. Clorox argues that we can make these applications both higher performance and easier to write by exploiting the underlying logical structure of their data, a structure which is ignored by AJAX. (Note that the logical structure of the data is entirely separate from their physical representation on the server.)
In place of the asynchronous, RPC-based abstraction furnished by AJAX, Clorox provides the illusion of synchronously-accessed data structures shared between the web browser and web server, which is to say, it provides a shared memory abstraction. These data structures look exactly like ordinary JavaScript objects on the client side, allowing programmers to focus on what they do best (writing compelling web applications) without worrying about data locality, message reordering, callback functions, or data prefetching. Additionally, to free programmers from concerns over locking, Clorox allows multiple operations on these data structures to be grouped into atomic actions.
Clorox applications are 100% JavaScript: application programmers write JavaScript code which is processed by the Clorox compiler into more JavaScript. Clorox applications can thus run on any modern web browser without the need for special plugins, and your code will never be locked up in some proprietary format.
We think the best way to learn to use a new piece of software is by playing around with it, so the rest of this document will explain how to build a sample application using the Clorox system.
Enhancements:
- A small bug was fixed to correct a problem with dim() methods.
- The homepage URL was updated.

PyCAGE fairly generic and complete cellular automata simulation engine.
Its written in Python and it supports both 1D and 2D automata, a variety of prepackaged rules, and the concept of "agents" which can move about independently on the map for implementing agent behavior.
It comes with numerous examples of fully-functional CA systems, including Conways Game of Life, Langtons self-reproducing automaton, Langtons "vants," and 1D automata rule explorers.
It also comes with simple displayers (including a curses interface for 2D automata) and a unique implementation of a finite state machine.
Main features:
- time is measured in discrete steps, called time units;
- a network of cells, each of which with a well-defined state at each time unit;
- at each time unit, each cell has a series of other cells which constitutes its neighorhood;
- the state each of cell changes according to a state transition function which depends on the state of that cell and the states of the cells of its neighbors;
- in synchronous automata (the typical usage), all cell transitions take place simultaneously.
Enhancements:
- Minor organizational changes; add stepping stone automaton.

Overflow project is a board game about chain reactions.
Overflow is a board game for two players or one player against the computer. Put pieces on the board until critical mass is reached, and watch a chain reaction go off.
Although the rules are simple, several different tactical considerations are required in order to play the game well.
The name refers to the key principle in the game that each cell on the board can hold a maximum of three units (pieces), and if you add another unit to a filled up cell, the units will be distributed to the four neighbor cells.
Main features:
- Play against the computer or another person
- Advanced hint feature
- Unlimited take backs and redos
- Ugly but scalable graphics
- Selectable colors

A Small MUD project is a minimal MUD implementation.

A Small MUD is a minimal MUD implementation, with some mildly intelligent mobs running around creating rooms.

A few pointers when reading the source code... the World class contains the "cells" in the dungeon - all those are created randomly by the mobs.

The MobFactory class contains and controls all mobs in the world - the class holds a reference to the World class.

Cells are specified by the World::CELL struct and mobs by the MobFactory::MOB struct. The SmallHandler class contains the World, MobFactory, and active sockets list (via SocketHandler).

Finally, the SmallSocket class handles all socket communication and the ListenSocket template class acts as the socket listen server.