Free dominions 3 the awakening software for linux

Dominion is a multi-playerworld simulation and role-playing game. Each user controls a nation, making economic, political and military decisions for it.

This is a world simulation game developed initially by students at SUNY at Stony Brook, and then by students at Stony Brook and other universities. The intention is to write a game which offers the role playing potential and complexity of relations found in conquer (written by Ed Barlow, then picked up by Adam Bryant). The plan is to
extend the game by offering general descriptions of many features (such as races, magic spells, armies, spirits and technology powers). For example, the races of the world are not limited to 4 hard-coded races, but are described in a file which can be modified at any point in the game by the Game Master. The same goes for army and spirit types.

Dominion is *not* another version of conquer; things work quite differently, and we have *never* looked at the conquer source. Still, we acknowledge this most creative game which gave us our inspiration. In September 1990, the author of conquer version 5 has heard of many of the features of dominion, and has included them in conquer version 5. He has acknowledged that these ideas come from Dominion.

The Game Master is given a nation, but this nation is sort of "fragile", since it has no sectors, and such stuff. We should make it more solid, but meanwhile it is to be used mostly for its [E] command, which allows the Game Master (who logs into the game as "Gamemaster") to change the properties of a sector or of a nation.

Dominion development started in the spring of 1990, when Mark Galassi was running a game of conquer for graduate and undergraduate students at at Stony Brook. After the data file kept crashing, and a whole lot of inconsistencies were discovered, and we found that the source was too complex to be fixed, we decided to write our own replacement. Ed Barlow did a great job with conquer, and it is a great game, but it
was his first C program, and people who added to it kept the endless case statements, and the special cases, and worked on new features rather than re-writing. The original name of Dominion was Stony Brook World (sbw), but it has been named Dominion since version 1.02.

In many ways Dominion was a teaching project intended to teach many Stony Brook undergraduate CS majors to work on a large software development project. Once the project reached a certain size, people from other universities joined in the development.

One goal of dominion is that the ruler of a nation should always have many choices available on how to invest resources, each one presenting strong but distinct advantages. Conquer contains both a good and a bad example of this: you can invest metal in cities, ships or armies. Either way you get advantages, and you have to choose. On the other hand, jewels are really not used for much else than getting magic powers. You can also use them to support monsters, but that is a different order of magnitude, and few players get the monsters. In dominion, there should be several decisions you can make to invest all your resources.

Kevin Hart has been working on the CN code which allows the computer to play various nations. Starting with version 1.05, the computer-played CNs have begun posing a real challenge in the game.

The Data Mine is a search engine designed to give users an unusually powerful interface. It is designed around human-computer intelligent interaction (making the computer a tool so humans can use their intelligence).

The project divides the screen into two halves: one lets you find all the instances of your querys keywords, and the other lets you look through a highlighted version of the results you choose.

Installation:

Basics

To install, run "./install" and answer the questions provided. This will run a Unix-flavor install-style script and should create a working, out-of-the-box installation when supplied appropriate values.

See USAGE below if are curions about how to use the Data Mine.

Setup and Customization

The Configure link at the bottom of the Data Mine search page provides a menu you can use to customize the data mine.

The main engine is intended for anyone to be able to use; the setup pages are written for techies. If you arent sure what a regular expression is, for instance, ask someone whos more technical.

Security

The present release of the Data Mine has not been closely scrutinized for security, and should be treated as such by security-conscious administrators. If you discover a vulnerability, please contact the author.

You are strongly encouraged to change the password in /usr/share/datamine/password.

The default installation sets /usr/share/datamine and contents to a relatively permissive mode. Administrators are encouraged to set directory and contents to mode 700, owned by the effective user ID that CGI scripts will be running under. This is usually apache or nobody.

Usage:

The Data Mine is designed to be run as a straightforward web application, with much administrative activity performed on-web.

Once it is set up via the Configure link, just explore.

http://[your hostname]/cgi-bin/datamine

(That is the location provided by RPM installation and the default for the provided installer. The provided installer allows you to specify another location; if you specified another location, substitute that for "/cgi-bin/furball".)

The Wurld 3D Engine is yet another 3D gaming engine. It is light, fast, has minimal external requirements, and is still very immature. The project is Python scriptable, including support for generating models using 3D turtle graphics.

The streak plug-in is a Gimp plug-in that makes simulation of a streak camera.

A streak camera images an object through a slit - thus getting a kind of "one dimensional image". This image is propagated along the second dimension of the image plane at a constant speed. The result is a picture of the time dependency of the object.

The plug-in takes a film (multilayer image), cuts a slice of selectable width and position out of each layer and puts the slices together to the streak image.

The Glasgow Haskell Compiler is a state-of-the-art, open source, compiler and interactive environment for the functional language Haskell.
Main features:
- GHC supports the entire Haskell 98 language plus a wide variety of extensions.
- GHC works on several platforms including Windows and most varieties of Unix, and several different processor architectures. There are detailed instructions for porting GHC to a new platform.
- GHC has extensive optimisation capabilities, including inter-module optimisation.
- GHC compiles Haskell code either by using an intermediate C compiler (GCC), or by generating native code on some platforms. The interactive environment compiles Haskell to bytecode, and supports execution of mixed bytecode/compiled programs.
- Profiling is supported, both by time/allocation and various kinds of heap profiling.
- GHC comes with a wide range of libraries.
GHC is heavily dependent on its users and contributors. Please come and join the mailing lists and send us your comments, suggestions, bug reports and contributions!
Enhancements:
- SMP support and impredicative polymorphism were added.
- The libraries were split into core and extra.
- Many more changes were made.

The Examiner is an application that utilizes the objdump command to disassemble and comment foreign executable binaries. This app was designed to analyze static compiled binaries but works ok with others. The intention is for forensic research but could also be used in general reverse engineering.
This program can only handle basic dissassembly. If the binary has been modified to resist debugging then the Examinier probably will not be able to analyze the code. Also the Examiner will not analyze live running code. This can be a good thing but if you need to look at code when it runs or deal with complicated disassembly you should probably use Fenris.
Main features:
- Automates objdump usage
- Can generate cross-reference files of functions, interrupts and other useful things
- Locates functions within the binary
- Understands the stack and comments on its state
- Can parse and understand the contents of the .rodata section
- Cross references .rodata calls and comments on them
- Locates .data pointer references to .rodata
- Provides an easy to read CALL syntax for comments
- Understands and looks up interrupts calls
- Utilizes Linux source headers to determine function names based on what interrupt is called
- Can differentiate all of the socketcall functions
- Can comment on some C like constants for function calls
- Separates functions based on ret calls
- Can recognize and attempts to decode UPX compressed binaries
- Works with TCT and Fenris dress utility
- Can detect crippled ELF executables and burneye executables
- Recognizes symbols and will cross-reference dynamic libraries
Enhancements:
- Has rudementary detection of burneye via 7350 sig.
- Can detect crippled ELF header files (optionally uncripple)
- Added a TUTORIAL file
- Modified default working dir to $HOMEexaminer-data
- Can cross-reference .data pointers to .rodata sections
- Now records pushl calls
- Fixed -H to dump headers instead of -R
- Added -o to specify an output file or STDOUT with -
- Added -c to specify a comment character
- Added a new util xhierarchy to print function call hierarchy

Danger from the deep (aka dangerdeep) is a Free / Open Source World War II german submarine simulation.
It is currently available for Linux/i386 and Windows, but since it uses SDL/OpenGL it should be portable to other operating systems or platforms. (If anyone whishes to port it, please contact us.)
This game is planned as tactical simulation and will be as realistic as our time and knowledge of physics allows. Its current state is ALPHA, but it is playable.
If anyone wants to contribute in development, youre welcome, just email the dangerdeep-devel mailing list. Contributing binary packages for various Linux distributions would also be much appreciated.
To get help with the game you should visit our public forum.
The game has support for multiple languages but currently only English, Italian and German are implemented. It is written in C++ with the use of the STL.
Danger from the Deep is released under the GNU General Public License. The project is hosted on SourceForge, a great supporter of the Open Source community.
Main features:
- simple main menu
- user interface (some items missing)
- basic world simulation, night and day
- realistic water and cloud simulation
- one type of destroyer, one battleship, one aircraft carrier, three subs, eight civilian ship types
- steering, firing, diving, periscope use
- free look engine for testing, periscope, UZO (aiming binoculars), bridge view
- console for logging purposes
- basic physics (acceleration, steering, firing)
- basic destroyer AI (follow, throw depth charges)
- simple vehicle preview
- mission parsing via text files, you can create your own custom missions
- tonnage recording
- log book

The Java Exorcist projects aim is to create a small and easy to use tool, that can be used to extend the Java language syntactically. Why would you do that? There are basically two reasons:
First, you just might want to fix your pet-peeve in the language itself. For example, create new keywords like unless, foreach, new operators, or generate setter getters automatically for a bean property.

Secondly, you might tune the language itself for a specific project, so the project code may look more clean and thought out. For example: specific logger keyword, which automatically checks (if statement) whether the logger should be invoked or not, or even ommits the whole logging compile-time, when its disabled! Or create a method modifier transaction to enclose the whole method in a project specific transaction.

How it works on the outside

Exorcist is a compiler of extended Java code. The compiler can be used in command-line mode, or through Ant. Basically, with no extensions configured, Exorcist only compiles the standard java code. To extend the language, you can plug in classes, which extend a single interface of the exorcist framework, and implement a single (and simple) method. Thats it.

How it works inside

Exorcist works like a pre-processor. It translates the extended language into plain Java code, and then compiles it using the standard Java compiler (javac).

To analyze a language, there are two steps involved. The first is a Lexical analysis, the second is the Parsing of the lexical tokens. Lexical tokens are strings, numbers, operators, dots, semicolons, etc. These are also called terminal symbols, because they can not be analyzed further. During parsing, lexical tokens are read, and non-terminal symbols may be produced.

These include things like: expression, method body, declaration, if-statement, etc. The Exorcists tranformation engine works basically with lexical token lists. Each extension first matches itself to the start of the received token list, using terminal and non-terminal symbols freely. If the match is detected, the extension is free to modify the input token list as it pleases, and with it modify the output clean Java source code.