About

Thousand Parsec is a framework for turn based space empire building games.

It is important to understand that Thousand Parsec is not a game by itself, it is a frame work for creating a similar group of games. Some of the games, such as our first demo game MiniSec, are developed by the Thousand Parsec developers themselves. In the near future we hope that other developers will create their own games using Thousand Parsec.

Some examples of games which Thousand Parsec draws ideas from are, Stars!, VGA Planets, Master of Orion and Galactic Civilizations. These games are often called 4 X's from the main phases found in the games, eXplore, eXpand, eXploit and eXterminate. If you haven't heard of them, other games which are a bit similar include, Civilisation, Hero's of Might and Magic and Starcraft.

Thousand Parsec includes everything you need for

play any of the currently running games,
set up your own game using already designed games, and
building your own space empire building game.

As Thousand Parsec is a rather large project it is easy to get confused when first starting out. This page has instructions on how to get started with Thousand Parsec.

Getting Started!

Before we can give you instructions on what to do, we need to figure out which part of Thousand Parsec you are interested in. Click the Link below which best describes you.

I want to actually play a game!
I want to run a game!
I want to develop a game!

Most races don't survive finding out what lizard men eat.

I want to actually play a game!

To actually play a game which uses Thousand Parsec you need a client. Any Thousand Parsec client can connect to any Thousand Parsec server.

At the moment you most probably want tpclient-pywx as it's the only client in active development. You should always get the latest version of the client because older versions tend to lack important features and have more bugs. Below are instructions on how to install tpclient-pywx.

If you are a console junkie you can also use tpclient-pytext, however this client is far from polished. You can find instructions for installing this client in the developer section.

After you have installed a client you should then head over to the metaserver which lists all the currently running public servers.

Installing tpclient-pywx on Windows

Just download the setup/exe version from the download page and run it!

Installing tpclient-pywx on Mac OS X

Just download the Mac DMG version from the download page, drag the folder into your Applications directory and then double click on the icon.

Note: If you get an error about the application being "corrupted or incomplete" please eject the DMG file and double click on it again.

Installing tpclient-pywx on Debian or Ubuntu

First you need to install the prerequisites for tpclient-pywx not developed by the Thousand Parsec project.

Experimental packages are available from the packages server. You can find instructions on how to use the packages

Firstly you need to install Python package.
```
	apt-get install python
		
```

You also need to install Numpy

	apt-get install python-numpy python-numpy-ext

Next you need to install wxPython
```
	apt-get install python-wxgtk2.8
		
```
For best performance and the most functionality it is recommended you install the following.
```
	apt-get install python-psyco
	apt-get install python-pyopenssl
	apt-get install python-imaging
		
```
If you are running a Gnome or gtk system (which you are if you are running Ubuntu) it is also recommended you installed the following.
- On Debian:
```
	apt-get install python-gconf
			
```
- On Ubuntu:
```
	apt-get install python-gconf
			
```

Next you need to install tpclient-pywx.

Now all you need to do is get tpclient-pywx
1. Download the "inplace" version tar.gz from here
2. Extract the tar.gz
3. Enter the newly created directory
4. Run
```
./tpclient-pywx
```

I want to run a game!

There are two servers that can be used, tpserver-py and tpserver-cpp.

Tpserver-py

Real Instructions coming soon.

git-clone git://git.thousandparsec.net/git/scratchpad
git-clone git://git.thousandparsec.net/git/libtpproto-py
git-clone git://git.thousandparsec.net/git/tpserver-py

cd scratchpad
sh setup.sh
cd ..
cd tpclient-pywx

cp config.py-template config.py
./tpserver-py-tool --addgame tp minisec [admin email] "A test game"
./tpserver-py-tool --populate tp 0 10 10 2 2
./tpserver-py-tool --adduser tp [username] [password]

# Run the following to generate a turn
./tpserver-py-tool --turn tp

Tpserver-cpp

The tpserver-cpp is written in C++. It should compile and run under most unix-like operating systems (Linux, MacOS X, *BSD). No binaries are currently supplied.

To build from source, follow these steps:

Install the dependencies: autotools (autoconf, autoheader, automake, aclocal), libtprl, and MzScheme or guile. Don't forget to install dev packages for libraries.
Optionally, install the optional dependencies.
- libmysql-client (and dev package) if you want to use a MySQL server for the persistence backend. You might want a server too.
- libgnutls (and dev package) if you want secure sockets.
Download, build and install libtprl. This requires readline5 (and dev packages).
Download the sources from Thousand Parsec Download page.
Extract the tar.gz file.
Enter the created directory.
Run
```
./configure
```
To see what build options are available run
```
./configure --help
```
Build with make.
```
make
```
As root (or administrator user) run
```
make install
```
. The executable, static data and man page are installed. They can be uninstalled with
```
make uninstall
```
To start server, run
```
tpserver-cpp
```

tpserver-cpp has a number of command line arguments and config files. A man page is provided and a sample config file is in the source package. quickstart config files for the available games are also provided in the tarbal. The console when the server starts has a number of commands, and has help and tab completion.

I want to develop a game!

tpserver-cpp

There are a number of small tasks in the TP bugs tracker on Sourceforge that a new programmer could start on.

Rulesets

The tpserver-cpp game server supports plug-in rulesets that define new games. A book which talks about how to develop new rulesets can be found here.

The latest version of the document can be found in git here.

Thousand Parsec: Getting Started