Free cruz azul vs tecos software for linux

Block Attack - Raise of the Blocks is another block fall game based on Tetris Attack.

Block Attack - Raise of the Blocks is a block fall game. Like Tetris Attack and Crack Attack, block are raising from the floor and the player must clear them before they touch the roof.

Blocks are cleared by making a line of three blocks in the same color horizontally or vertically, and blocks can only be changed horizontally.

The goal is to either get as much points as possible, get as much point in two minutes, clear all blocks in limited moves and clear a number of lines.

Two player slit screen is available. Two players can compete in Time Trial (who gets most points in two minutes) or Vs. mode where clearing more than 3 blocks trows blocks at the opponent.

Brim is an application suite that allows you to manage all your personal items online. No need to syncronize your bookmarks and favorites and contacts, you can now keep them well-secured online in one single place.
Additionally, Brim provides a calendar, a task manager, notes, a password manager etc. all behind a single logon.
Brim is an opensource Webbased Information Manager, formerly known as Booby, with support for bookmarks, calendar, contacts, notes, news, passwords and tasks and more.
Brim is written in PHP, has an underlying Model-View-Controller (MVC - Model II) framework based on items with a hierarchical relationship, has support for internationlization (i18n) with over 15 translations available, has multiple themes and is database independant. In short; a multi-thingy something.
Main features:
- Support for unlimited users
- Tested on IE5, IE6, Opera 7.5, Firefox 1.0, Netscape/Mozilla and more
- Plugin support (bookmarks, calendar events, news items, notes, tasks and a webtools plugin)
- Support for unlimited items per plugin
- Support for multiple languages:
English
Czech
German
Esperanto
Spanish
French
Hebrew
Italian
Dutch
Norwegian
Polish
Portuguese Brazilian
Portuguese
Russian
Swedish
Tradition Chinese
- Support for multiple themes (check the demo site!)
- Support to publish items (public vs. private items)
Enhancements:
- This release features a totally reworked user-interface with lots of ajax features.

Microracers is a fun 2D top-view racing game.

Microracers aims to be a fun 2D top-view racing game. It is inspired on the old Micromachines game, but it isnt meant to be a clone of it.

For now, it only has a racing gameplay where you have to beat computer vehicles (or other 3 humans on the same seat) by completing 2 laps the first.

The game is under the GPL. Everyone is free to contribute! Contact us.

CHEOPS Chess project is a C++ chess engine.

CHEOPS (CHEss OPponent Simulator), or Χεοψ, is a fully-functional AI chess program capable of human vs. human, human vs. computer, and computer vs. computer play. It uses a 64-square linear array board representation.

The game tree search is alpha-beta, and the static evaluation function considers material, mobility, and motif features.

CHEOPS comes with extensive documentation on the program internals, aimed at students or programmers wishing to understand or extend the system.

Scalar::Util is a selection of general-utility scalar subroutines.

SYNOPSIS

use Scalar::Util qw(blessed dualvar isweak readonly refaddr reftype tainted
weaken isvstring looks_like_number set_prototype);

Scalar::Util contains a selection of subroutines that people have expressed would be nice to have in the perl core, but the usage would not really be high enough to warrant the use of a keyword, and the size so small such that being individual extensions would be wasteful.

By default Scalar::Util does not export any subroutines. The subroutines defined are

blessed EXPR

If EXPR evaluates to a blessed reference the name of the package that it is blessed into is returned. Otherwise undef is returned.

$scalar = "foo";
$class = blessed $scalar; # undef

$ref = [];
$class = blessed $ref; # undef

$obj = bless [], "Foo";
$class = blessed $obj; # "Foo"

dualvar NUM, STRING

Returns a scalar that has the value NUM in a numeric context and the value STRING in a string context.

$foo = dualvar 10, "Hello";
$num = $foo + 2; # 12
$str = $foo . " world"; # Hello world

isvstring EXPR

If EXPR is a scalar which was coded as a vstring the result is true.

$vs = v49.46.48;
$fmt = isvstring($vs) ? "%vd" : "%s"; #true
printf($fmt,$vs);

isweak EXPR

If EXPR is a scalar which is a weak reference the result is true.

$ref = $foo;
$weak = isweak($ref); # false
weaken($ref);
$weak = isweak($ref); # true

NOTE: Copying a weak reference creates a normal, strong, reference.

$copy = $ref;
$weak = isweak($ref); # false

looks_like_number EXPR

Returns true if perl thinks EXPR is a number. See "looks_like_number" in perlapi.

openhandle FH

Returns FH if FH may be used as a filehandle and is open, or FH is a tied handle. Otherwise undef is returned.

$fh = openhandle(*STDIN); # *STDIN
$fh = openhandle(*STDIN); # *STDIN
$fh = openhandle(*NOTOPEN); # undef
$fh = openhandle("scalar"); # undef

readonly SCALAR

Returns true if SCALAR is readonly.

sub foo { readonly($_[0]) }

$readonly = foo($bar); # false
$readonly = foo(0); # true

refaddr EXPR

If EXPR evaluates to a reference the internal memory address of the referenced value is returned. Otherwise undef is returned.

$addr = refaddr "string"; # undef
$addr = refaddr $var; # eg 12345678
$addr = refaddr []; # eg 23456784

$obj = bless {}, "Foo";
$addr = refaddr $obj; # eg 88123488

reftype EXPR

If EXPR evaluates to a reference the type of the variable referenced is returned. Otherwise undef is returned.

$type = reftype "string"; # undef
$type = reftype $var; # SCALAR
$type = reftype []; # ARRAY

$obj = bless {}, "Foo";
$type = reftype $obj; # HASH

set_prototype CODEREF, PROTOTYPE

Sets the prototype of the given function, or deletes it if PROTOTYPE is undef. Returns the CODEREF.

set_prototype &foo, $$;

tainted EXPR

Return true if the result of EXPR is tainted

$taint = tainted("constant"); # false
$taint = tainted($ENV{PWD}); # true if running under -T

weaken REF

REF will be turned into a weak reference. This means that it will not hold a reference count on the object it references. Also when the reference count on that object reaches zero, REF will be set to undef.

This is useful for keeping copies of references , but you dont want to prevent the object being DESTROY-ed at its usual time.

{
my $var;
$ref = $var;
weaken($ref); # Make $ref a weak reference
}
# $ref is now undef

Note that if you take a copy of a scalar with a weakened reference, the copy will be a strong reference.

my $var;
my $foo = $var;
weaken($foo); # Make $foo a weak reference
my $bar = $foo; # $bar is now a strong reference

This may be less obvious in other situations, such as grep(), for instance when grepping through a list of weakened references to objects that may have been destroyed already:

@object = grep { defined } @object;

This will indeed remove all references to destroyed objects, but the remaining references to objects will be strong, causing the remaining objects to never be destroyed because there is now always a strong reference to them in the @object array.

xquarto project is a two-player board game based on logic.

Xquarto is a board game designed for the X windows environment. The game is a two-player game, although for the moment,it is only possible to play against the computer. The board is composed of 4x4 squares and 16 pieces. Each piece has four
properties: black or brown, horizontal or vertical, solid or hollow, round or square. This makes up 16 possible combinations and there is exactly one piece for each possibility.

Initially, the board is empty and it is successively filled with pieces. The game is over when a row, a column or a diagonal has four pieces carrying a common property in it, e.g. four black (brown) pieces, four square (round) pieces, four filled
(hollow) pieces, four horizontal (vertical) pieces. In the original quarto rules, the player who is the first to complete a row, column or diagonal as described above wins. This is the implicit mode under which xquarto runs. A variant of the game (tic rules) consists rather of avoiding alignments, i.e. the player who is forced to complete
an alignment loses.

The game is a two-player game. Player 1 chooses one of the 16 pieces. Player 2 then places this piece on one of the 16 squares of the board and chooses a piece out of the remaining 15 pieces which he gives to player 1, who places this piece on one of the remaining 15 squares on the board, etc...

Xquarto supports three different player combinations: human vs computer, computer vs human and human vs human (possibly through the local network in the latter case). The default combination is human vs computer, i.e. the human player starts the game against the computer. This can be changed by clicking on the "Actions" menu (see below for more details).

The rules are really very simple - believe me!

Basset::Object is a Perl module used to create objects.

This is my ultimate object creation toolset to date. It has roots in Mail::Bulkmail, Text::Flowchart, and the unreleased abstract object constructors that Ive tooled around with in the past.

If you want an object to be compatible with anything else Ive written, then subclass it off of here.

Of course, you dont have to use this to create subclasses, but youll run the risk of making something with an inconsistent interface vs. the rest of the system. Thatll confuse people and make them unhappy. So I recommend subclassing off of here to be consistent. Of course, you may not like these objects, but they do work well and are consistent. Consistency is very important in interface design, IMHO.