Free who needs action when you got words software for linux

Themis Action Editor is a small application for the KDE Desktop which allows you to edit context menu entries in a simple way.
For running Themis the following libraries and programs are needed:
Ruby Interpreter, tested with version 1.8
Korundum KDE/Ruby bindings
Enhancements:
- Fixed search bug introduced in beta 2.
- Fixed naming collision of class Config with ruby gems package.

Pluto Request Action Library allows you to create a client/server application, where client sends requests, server replies with responses and optional actions. Very object oriented, and takes only minutes to get going. Same library used for both server & client side.

How does it work?

The client creates "Requests" which it sends to the server. The server will process the request, set some return variables, and can optionally add "Actions" it wants the client to execute in response. An example is a cashiers computer (the client) sends the central credit card processing server a request to "process a credit card", the server responds with the authorization code and also includes an action "give customer a message" which causes a message to appear on the cashiers computer.
Both the client and server use the same library. Both create an instance of RA_Processor.

The only difference is the server calls "ReceiveRequest" and the client creates the actual requests, and calls RA_Processors "SendRequest".
To create a request, just create a class derived from RA_Request. Add some member variables for the request and variables for the response. Your request must be derived from SerializeClass--a base class that facilitates taking an object (a request in this case), serializing the variables into a binary block, and then on the other end reconstructing the class with all the data. The framework handles everything. You just add the data members.

In the above example, the request variables would probably be the credit card information and maybe the customer ID, and the response variables would be the authorization code. RA_Request has a pure virtual function "ProcessRequest" which will be called on the server to handle the request. Both the client and the server have the same Request/Action classes. When the client side passes a request to the RequestProcessor, the framework handles serializing all the request member variables, making the socket connection to the server and sending the request to the server.

On the server, the framework will create an instance of the request class and deserialize all the data and call the "ProcessRequest" member function. That is the only function the server needs to implement. From within ProcessRequest, the server needs to set the response variables. When ProcessRequest returns, the framework will serialize the response variables, send them back to the client, update the clients original request with the response, and execution will continue. Less than 10 lines of code are required to make it work, and the project includes a sample client/server application you can extend.

Solving word problems is an area where elementary students overwhelmingly display difficulties. Master Math Word Problems program can help sharpen skills through practice. Third through fifth graders learn to watch for key words and translate those into mathematical operations.

Students can learn new math skills, practice logic, get extended practice with word problems, but most of all they learn that they must read the problem. With regular practice your students may become master math word problem solvers.

Download and try out Master Math Word Problems.

Windstille project is a classic jump and shoot action game.
Windstille is an old-school 2D site-scrolling shootem up game, similar to Turrican or Metroid with some influence from Another World and Flashback.
In Windstille the player will be placed in a foreign alien world and has to find its way back into safety. Special focus will be on getting the foreign world and the players character itself believable.
Exploration will be more needed than plain shoot action, even so the players-character will be equipped with a multifunctional war-suit, so he will be far from defenseless.
The game will have slow placed explore and seak sequences as well as more rough section that will feature fast shoot and jump action. The game world should be presented in a consistent state, enemies once destroyed should not respawn automatically.
The player is free to go forward and backward in the world as long as the level design allows it.
Enhancements:
- 3D sprites, giving fluent animation and the ability to zoom in without pixelation in the characters
- multi color light effects for added athmospheric effect as well as new gameplay posibilities
- flexible particle systems for fire, water smoke and such
- dynamic 2D water
- Squirrel based scripting
- console to enter script commands
- simple dialog system
- cutscene support
- menu system for easy access to all the parts and features of the game

OpenInteract2::Manual::Tutorial is a Perl module that will teach learn you how to create and modify a package.

SYNOPSIS

This tutorial will show you the different methods for creating a package and how to maintain them.

CREATING THE PACKAGE

A word on the example

For our example were going to create a book package. This will keep track of all our books and allow us to search our library, add new books, update existing ones and remove old ones. It wont be the backbone for a massive e-commerce website to make you lots of money. It does not attempt to best model the relationships for all the data about a book.

Looking for shortcuts?

If you want to get something running in the fastest manner possible we can generate a simple CRUDS application for you. (CRUDS: CReate Update Delete Search) Just run something like the following:

$ oi2_manage easy_app --package=book --table=book
--dsn=DBI:Pg:dbname=mylibrary --username=foo --password=bar

This will create a simple application built off a table book with templates and objects for searching, creating, updating and removing objects. (More at OpenInteract2::Manage::Package::CreatePackageFromTable.)
Since this is a tutorial well assume you want to read to learn, so on we go.

Generating the skeleton

OpenInteract comes with tools to create a skeleton package -- we dont want to do all this from scratch! The skeleton package has the directory structure, metadata and a number of files to get you going on your new package. Heres how to create one -- be sure to first go to the directory under which the package will be created:

$ oi2_manage create_package --package=book

And heres what youll see:

PROGRESS: Starting task
PROGRESS: Task complete
ACTION: Create package book
OK: Package book created ok in /path/to/my/book

And now lets see what it created:

$ find book/
book/
book/conf
book/conf/spops.ini
book/conf/action.ini
book/data
book/doc
book/doc/book.pod
book/struct
book/template
book/template/sample.tmpl
book/script
book/html
book/html/images
book/OpenInteract2
book/OpenInteract2/Action
book/OpenInteract2/Action/Book.pm
book/OpenInteract2/SQLInstall
book/OpenInteract2/SQLInstall/Book.pm
book/package.ini
book/MANIFEST.SKIP
book/Changes
book/MANIFEST

These files and directories are explained in OpenInteract2::Manual::Packages.

You will normally need to edit/add the following:

book/package.ini # Add name, version, author information
book/MANIFEST # Add names of distribution files
book/conf/spops.ini # Describe the objects your package uses
book/conf/action.ini # Map URLs to handlers in your package
book/data # Specify the initial data and security
book/struct # Describe the tables used to store your objects
book/template # HTML to display and manipulate your objects
book/OpenInteract2 # Optional Perl modules defining object behavior
book/OpenInteract2/Action # Manipulate objects for desired functionality
book/OpenInteract2/SQLInstall # Tell the installer about your tables, data, security
book/doc/book.pod # Last but not least, tell the world about it

Short sidebar: Creating a MANIFEST

Notice that we create a MANIFEST file for you when the package is created. As you add more files to your package youll need to add them to your book/MANIFEST. Fortunately, it can be created automatically:

$ cd /path/to/mypackage
$ perl -MExtUtils::Manifest -e ExtUtils::Manifest::mkmanifest()

Thats it! If you have an old MANIFEST file in the directory it will be copied to MANIFEST.bak. Also note that files matching patterns in the book/MANIFEST.SKIP file will not be included.

Alien Flux is an arcade game where cute little Fluffies need YOUR help! Have you got what it takes to save them?
Defend the cutest, fluffiest little creatures in the Galaxy from a horde of evil aliens from the fifth dimension! With only fast reactions, animal cunning and a very big laser cannon to help you, you must rescue the Fluffies as malevolent Bubbles attempt to turn them into lime jelly.
Main features:
- 16 unique evil aliens from the 5th dimension
- 4 massive and fiendish bosses
- 8 cute fluffy friends that need your help
- 12 powerups to help you in your mission
- 100 levels of blistering arcade action in which to battle
- online hiscore table - be the best in the world and compete against your friends!

Leter Hunt is a Seven Day Roguelike game. The original idea came from a discussion at the end of the 2005 7DRL challenge with Antoine, the author of Guild.
Main features:
- Spell words by capturing your foes in the correct order to earn points and powerups.
- Fifty-two letters to capture, many with their own personalities or unique abilities.
- Power-up based character advancement. Rather than gaining experience or levels, you just gain powerups that can wear off. Advancement is not permament.
- Open-ended game - there is no final boss or win condition. Your goal is to get as many points as possible before attrition or increasingly difficult enemies take you down.
- Extremely tactical combat. There is no randomness in combat. You always hit and always do full damage. This means that careful placement is the difference between success and failure.
- Turn based action, as is normal for a roguelike.
- User editable wordlist: The list of valid words is a plain text file that can be added to or replaced. Creature frequency is calculated from letter frequency in the wordlist file.
Enhancements:
- Various niggly bugs fixed, including the crash on walk.