Free changeling true story software for linux

madlibs engine project is a MadLibs clone.

The madlibs engine is a tiny engine for MadLibs-like interactive stories. Basically, you enter different words of a certain part of speech.

The program pastes them into a story text, creating weird, funny, or stupid results.

It runs on anything from a line printer to an xterm.

Chess::Game::MoveList is a specialized list class for recording the moves of a Chess::Game.

SYNOPSIS

$movelist = Chess::Game::MoveList->new("white", "black");
$wpawn = Chess::Game::Pawn->new("e2", "white");
$entry = $movelist->add_move($wpawn, "e2", "e4");
$true = $entry->get_piece() eq $entry;
$bpawn = Chess::Game::Pawn->new("e7", "black");
$entry = $movelist->add_move($bpawn, "e7", "e6");
$entry = $movelist->add_move($wpawn, "e4", "e5");
@del_entries = $movelist->delete_move(1, "white"); # delete the list
$true = $entries[0]->get_piece() eq $wpawn;
$true = $entries[0]->get_dest_square() eq "e4";
$true = $entries[1]->get_piece() eq $bpawn;
$true = $entries[1]->get_dest_square() eq "e6";

The Chess module provides a framework for writing chess programs with Perl. This class forms part of that framework, recording a log of all moves during a Chess::Game in such a fashion that the list can be used to undo moves that have been made.

Olive is a totally sweet console mode RSS aggregator and newsreader written in Perl with Curses::UI as its toolkit.
The big difference between Olive and other newsreaders is that it takes a time-centric as opposed to site-centric view of newsfeeds.
Olive also tries to stay out of your way as much as possible by eating a minimum of screen real estate and streamlining operations to keep neccessary human interaction to a minimum.
Enhancements:
- A problem with starred story (un)selection was fixed.
- Standard --help and --version command-line arguments have been implemented.
- Licensing has been unified under the Perl license.

Elixir is a declarative layer on top of SQLAlchemy. The project is a fairly thin wrapper, which provides the ability to define model objects following the Active Record design pattern, and using a DSL syntax similar to that of the Ruby on Rails ActiveRecord system.

Elixir does not intend to replace SQLAlchemys core features, but instead focuses on providing a simpler syntax for defining model objects when you do not need the full expressiveness of SQLAlchemys manual mapper definitions.

Examples:

The Elixir source distribution includes a sample web application that uses the TurboGears web application framework. The application builds upon the tutorials Movie model to create a simple store for buying movies.

The Video Store sample application also includes an example of how to use Elixir with the TurboGears "identity" framework for security and authorization. If you are planning to use Elixir with your TurboGears application, and need to support authorization using identity, you can use this model as a basis:

from turbogears.database import metadata, session
from elixir import Unicode, DateTime, String, Integer
from elixir import Entity, has_field, using_options
from elixir import has_many, belongs_to, has_and_belongs_to_many
from sqlalchemy import ForeignKey
from datetime import datetime

class Visit(Entity):
has_field(visit_key, String(40), primary_key=True)
has_field(created, DateTime, nullable=False, default=datetime.now)
has_field(expiry, DateTime)
using_options(tablename=visit)

@classmethod
def lookup_visit(cls, visit_key):
return Visit.get(visit_key)

class VisitIdentity(Entity):
has_field(visit_key, String(40), primary_key=True)
has_field(user_id, Integer, ForeignKey(tg_user.user_id, name=user_id_fk, use_alter=True), index=True)
using_options(tablename=visit_identity)

class Group(Entity):
has_field(group_id, Integer, primary_key=True)
has_field(group_name, Unicode(16), unique=True)
has_field(display_name, Unicode(255)),
has_field(created, DateTime, default=datetime.now)
has_and_belongs_to_many(users, of_kind=User, inverse=groups)
has_and_belongs_to_many(permissions, of_kind=Permission, inverse=groups)
using_options(tablename=tg_group)

class User(Entity):
has_field(user_id, Integer, primary_key=True)
has_field(user_name, Unicode(16), unique=True)
has_field(email_address, Unicode(255), unique=True)
has_field(display_name, Unicode(255))
has_field(password, Unicode(40))
has_field(created, DateTime, default=datetime.now)
has_and_belongs_to_many(groups, of_kind=Group, inverse=users)
using_options(tablename=tg_user)

@property
def permissions(self):
perms = set()
for g in self.groups:
perms = perms | set(g.permissions)
return perms

class Permission(Entity):
has_field(permission_id, Integer, primary_key=True)
has_field(permission_name, Unicode(16), unique=True)
has_field(description, Unicode(255))
has_and_belongs_to_many(groups, of_kind=Group, inverse=permissions)
using_options(tablename=permission)

More Elixir examples are coming soon, and we would appreciate any additional sample applications that you could provide to illustrate more complex mappings.

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.

List::MoreUtils is a Perl module that can provide the stuff missing in List::Util.

SYNOPSIS

use List::MoreUtils qw(any all none notall true false firstidx first_index
lastidx last_index insert_after insert_after_string
apply after after_incl before before_incl indexes
firstval first_value lastval last_value each_array
each_arrayref pairwise natatime mesh zip uniq minmax);

List::MoreUtils provides some trivial but commonly needed functionality on lists which is not going to go into List::Util.

All of the below functions are implementable in only a couple of lines of Perl code. Using the functions from this module however should give slightly better performance as everything is implemented in C. The pure-Perl implementation of these functions only serves as a fallback in case the C portions of this module couldnt be compiled on this machine.

any BLOCK LIST

Returns a true value if any item in LIST meets the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "At least one value undefined"
if any { !defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

all BLOCK LIST

Returns a true value if all items in LIST meet the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "All items defined"
if all { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

none BLOCK LIST

Logically the negation of any. Returns a true value if no item in LIST meets the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "No value defined"
if none { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

notall BLOCK LIST

Logically the negation of all. Returns a true value if not all items in LIST meet the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "Not all values defined"
if notall { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

true BLOCK LIST

Counts the number of elements in LIST for which the criterion in BLOCK is true. Sets $_ for each item in LIST in turn:

printf "%i item(s) are defined", true { defined($_) } @list;

false BLOCK LIST

Counts the number of elements in LIST for which the criterion in BLOCK is false. Sets $_ for each item in LIST in turn:

printf "%i item(s) are not defined", false { defined($_) } @list;

firstidx BLOCK LIST

first_index BLOCK LIST

Returns the index of the first element in LIST for which the criterion in BLOCK is true. Sets $_ for each item in LIST in turn:

my @list = (1, 4, 3, 2, 4, 6);
printf "item with index %i in list is 4", firstidx { $_ == 4 } @list;
__END__
item with index 1 in list is 4

Returns -1 if no such item could be found.

first_index is an alias for firstidx.

FreeOrion is an open-source game inspired by Master of Orion, is a turn-based game of epic space strategy that builds on the classic 4X model by incorporating the nation-building elements of games such as Europa Universalis 2 and a versatile tactical combat engine.

While its modular, open-source design allows for a significant degree of customization of the game engine and the story elements by the community, the FreeOrion team is dedicated to the construction of a living, breathing universe in a grand campaign model.