Free ai. software for linux

Created by accident, all who find you would destroy you. Can you escape?
Endgame: Singularity project is a simulation of a true AI. Go from computer to computer, pursued by the entire world. Keep hidden, and you might have a chance.
Originally created for the Pyweek compo, this version features many bugfixes and enhancements over the compo version. Thanks to Phil Bordelon for many of these fixes.
Enhancements:
- Very Easy mode is actually playable.

Othello Game is a classic strategy game, also known as Reversi. Its objective is to finish the game with the greater amount of pieces (circles) of the same color.
This version of the Othello game supports the writing of AI plugins in C++ or Python, network games, and interface themes.
Enhancements:
- pkgconfig support was added.
- It is now easier to write AI plugins.
- An installation guide, and a tutorial for writing plugins were incuded.
- It is now possible to disable Python support from the configuration.
- New icons were provided.

Pioneers project is an emulation of the Settlers of Catan board game which can be played over the internet.

Pioneers follows the rules of the award winning game by Klaus Teuber as closely as possible.

You can play with up to 8 players over the internet, and an AI is included too. It includes the default boards, and SeaFarers too.

Alizarin Tetris is a Tetris-like game with a twist for Unix, Win32 and BeOS systems. It includes multi-player support, user-extensible color, shape and sound styles, can use TCP/IP networking and features a few different AI opponents. This game was written using the SDL Library.

Cyphesis is a WorldForge server suitable running small games. Cyphesis is also designed by be used as an AI subsystem in a network of distributed servers.
It includes a terrain engine based on the Mercator library, a persistence system based on PostgreSQL, and an AI engine using goal trees implemented in Python. It is the server used in most current WorldForge games.
Current releases of cyphesis use the re-written C++ core, based on the design of the original python core.
Enhancements:
- The way rules data is handled is now much simpler to make it easier for game designers to create what they want.
- A lot of hard-coded functionality has been removed from the compiled core program.
- Core functionality is now associated with properties, and so can be applied to any entity.
- Most of Mason has been reimplemented as task scripts, which are cleaner and more flexible.
- There are more helpful messages when inconsistencies are detected in rule data.
- This release works more reliably as an autopackage.

AI::Menu is a Perl object that generates Tree::Nary objects from directed graphs or a description of the function set.

The algorithm is not very efficient (approximately O(F^6), F being the number of functions). It is also not quite as intelligent as it should be. You should cache the results instead of repeatedly calculating them.

As the algorithm is optimized or more efficient algorithms are found, they will be incorporated. The interface for generating the trees should not change too much. The resulting object might become a Tree::Nary object encased in an AI::Menu object.

SYNOPSIS

use AI::Menu;

my $factory = new AI::Menu::Factory;

my $menu = $factory->generate($hash_of_functions);
my $menu = $factory->generate($hash_of_functions, $hash_of_categories);
my $menu = $factory->generate($graph);

METHODS

All of the following methods (except generate) are available in the new function when creating the AI::Menu::Factory object.

generate

This function does some housekeeping before calling a configurable module to generate the tree.

If called with a single hash reference, the hash is assumed to be a list of functions mapping to array references containing a list of categories. It is further assumed that the sets of function names and category names are disjoint. A closure is created for the leaf_q function which returns true if its argument is a key in the hash reference. The complete graph is created from this single hash reference: if a category can reach another category through a function, then an edge is inserted between the two categories. This edge is bidirectional.

If called with two hash references, the first hash is treated as before, but the second hash reference is considered a mapping of categories to categories. This second hash is used instead of automatically generating the information from the first hash.

If called with a single object that is not a hash reference, then the argument is considered a graph object (usually of Graph::Directed). The leaf_q function will need to be defined.

leaf_q

This function returns true if the argument represents a function (leaf in the graph). It returns false if the argument represents a category. This may be set either when the AI::Menu::Factory object is created or through a method call. The method call with no argument returns the current function.

maker

This is the package used to create the menu from the graph. The following call is made:

my $menu = $self -> {maker} -> new(
width => $self->{width},
weight_f => $self -> {weight_f},
leaf_q => $leafq,
);

return $menu -> generate_tree($g, $optscore);

The $optscore value is the score for the optimum tree. Once a tree is found with this score, searching should stop.

new

Creates an AI::Menu::Factory object. Optional arguments are key/value pairs taken from this list of methods except for generate and new.

weight_f

This function is used to calculate the edge weights in the graph. It is called with four arguments: the object generating the tree, the graph object, the originating vertex, the destination vertex. The function should return undef for an infinite weight.

width

This is the desired number of children per node. The optimal number (and default) is three.

AI::Prolog::Introduction Perl module contains the what and the why of logic programming.

You can skip this if you already know logic programming.

Note that most of this was pulled from my write-up about logic programming in Perl at http://www.perlmonks.org/?node_id=424075.

In Perl, generally you can append one list to another with this:

my @Z = (@X, @Y);

However, thats telling the language what to do. As sentient beings, we can look at that and infer more information. Given @Z and @X, we could infer @Y. Given just @Z, we could infer all combinations of @X and @Y that can be combined to form @Z.

Perl cannot do that. In logic programming, however, by defining what append() looks like, we get all of that other information.

In Prolog, it looks like this:

append([], X, X).
append([W|X],Y,[W|Z]) :- append(X,Y,Z).

(Theres actually often something called a "cut" after the first definition, but well keep this simple.)

What the above code says is "appending an empty list to a non-empty list yields the non-empty list." This is a boundary condition. Logic programs frequently require a careful analysis of boundary conditions to avoid infinite loops (similar to how recursive functions in Perl generally should have a terminating condition defined in them.)

The second line is where the bulk of the work gets done. In Prolog, to identify the head (first element) of a list and its tail (all elements except the first), we use the syntax [head|tail]. Since ":-" is read as "if" in Prolog, what this says if we want to concatenate (a,b,c) and (d,e,f):

Given a list with a head of W and a tail of X:

@list1 = qw/a b c/; (qw/a/ is W, the head, and qw/b c/ is X, the tail)

If its appended to list Y:

@Y = qw/d e f/;

We get a list with a head of W and a tail of Z:

@list2 = qw/a b c d e f/;

Only if X appended to Y forms Z:

X is qw/b c/. Y is qw/d e f/. Z is qw/b c d e f/.

AI::NNFlex::Reinforce is a very simple experimental NN module.

SYNOPSIS

use AI::NNFlex::Reinforce;

my $network = AI::NNFlex::Reinforce->new(config parameter=>value);

$network->add_layer(nodes=>x,activationfunction=>function);

$network->init();



use AI::NNFlex::Dataset;

my $dataset = AI::NNFlex::Dataset->new([
[INPUTARRAY],[TARGETOUTPUT],
[INPUTARRAY],[TARGETOUTPUT]]);

my $sqrError = 10;

for (1..100)

{

$dataset->learn($network);

}

$network->lesion({nodes=>PROBABILITY,connections=>PROBABILITY});

$network->dump_state(filename=>badgers.wts);

$network->load_state(filename=>badgers.wts);

my $outputsRef = $dataset->run($network);

my $outputsRef = $network->output(layer=>2,round=>1);

Reinforce is a very simple NN module. Its mainly included in this distribution to provide an example of how to subclass AI::NNFlex to write your own NN modules. The training method strengthens any connections that are active during the run pass.