Added rendered world part to EmailPlayer notification

Added actual center-of-mass calculation for territories.

Also:
* Added CCW check in Region._generate_outline.
* Added attribute control (e.g. opacity) for continent color templates.
* Added army outline color control to templates.
* Removed unnecessary label_offset attribute from Region.

Added player colors

Add titles to regions (Firefox, and possibly others) use them for tooltips.

Use world.name as template.name and SVG <title>.

Remove the upper-left and lower right bounding box marks

Added template control over line colors (and presence).

Distinguish between line (boder) and route color

Added continent colors to template system

Configurable line color

Added traditional template for Earth

Added virtual routes to template system to allow related islands

Add preliminary graphics library with world generation

Added fortification to the basic Player AI.

This will excercise the fortification code during random_game()s.

Also moved Player.border_territories functionality into a combo of
Player.territories and a new Territory.border.  This makes it easy to
iterate through non-border territories looking for out-of-the-way
armies for fortification.

Finally, limit the players to one fortification per turn ;).

Added Engine.fortify (previously fortification would break Engine)

Also moved adjacency check from Engine.attack_and_fortify to
Engine.attack and Engine.fortify.  This will make it easier for
subclasses to change the rules (e.g. non-adjacent fortifications).

Also reordered attack / conquer log messages:
  'attacked X from Y' -> 'X attacks Y'
which is shorter and makes the A:B ratios more clear.

Added Event classes to pyrisk.log

This should make logging easier to configure.  For example, a
Player.report function now has access to the raw data used to compose
the string.  Well, if the mutables haven't changed ;).  If that's an
issue for you, stick some copy.deepcopy calls into the Event subclass
__init__ definitions.

Remove EmailPlayers from pyrisk.random_game

Now that I'm pretty happy with the email interface, we don't need an
easy way to test it anymore.  It was probably never a good idea to
hard-code dummy emails anyway ;).  The code is still in README so
people setting up EmailPlayers will know what to do.

Add reference to "The Red Balloon" ;)

Added error handling for (?most?) invalid Player responses

Fixed up IncomingEmailDispatcher to work in real life ;).

Replaced README procmail rule with one I've actually tested :p

Also updated the README example code for new email setup.

Update OutgoingEmailDispatcher execute calls -> self._execute

Fix missing dispatchers in base.random_game EmailPlayer init.

Fix excute -> execute typo in OutgoingEmailDispatcher

Correct "Re:" portion of procmail regexp in README

Added .gitignore to mask *.pyc files

Preliminary handling of actual emails.

Added setup.py and moved VERSION to pyrisk/__init__.py

Added README and renamed risk/ -> pyrisk/

Added GPLv2 boilerplate.

Added risk.player.email with EmailPlayer.

Currently only a text-mode interface (no actual email), but it
supports all the necessary methods.

Player.select_territory returns territory name rather than instance.

To keep the Player interface as simple (and tamper-resistant :) as
possible, Player methods should return names instead of instances
of risk-specific classes.

Also fixed a deck -> self.deck typo in Engine.

Broke Engine.end_of_turn_cards out of Engine.play_turn

For easier modification if you decide to change the rules in a
subclass.

Added adjacency checking to Engine.attack_and_fortify.

Fixed bug in active_player calculation + other cleanups.

Also
* Added docstrings to many classes and methods.
* Added NameMixin, breaking off .name portion of ID_CmpMixin.
* Removed unused contains_territory methods.
* _check_short_names comparison now case insensitive to match
  territory_by_name.
* Deck gains options num_wilds and type_names.
* Deck gains method shuffle.
* Deck and Hand scoring and production generalized.
* Many Player methods renamed (losing "phase_").
* Many Player methods gain log option, since the player might want to
  know what's been going on.
* Player methods phase_attack and phase fortify combined to form
  attack_and_fortify.  The idea is to let the player make as many
  decisions as they would like to in one fell swoop, and attacking
  and fortifying are very similar.
* Engine gains game_over method for easier subclassing.
* Engine deal method more flexible, now single player.  Also takes
  over player hand manipulation from Player.draw (formerly
  phase_draw).  The idea is to have Engine do all possible Player
  manipulation; Player methods are just for making decisions and
  notification.
* test function adjusted to work with
  python -c 'import risk.base as b; b.test()'

Only call Player.report (prev. Player.phase_report) as final contact

Added player-specific log reporting

Began versioning (v0.1), engine and basic AI.