Made mapmod able to read multiple entries on the same line.
Made loot events accept repeating entries
Finished up the remaining repeating event components.
whitespace
Refactor: Powers

Rather than passing around an int power_id that references a certain
power, just use a const Power &reference.  This also adds an int id data
member to the Power class.
Tweak: Change resale value of gems to 50%

Change resale value of gems from 25% to 50%, making them actually useful
as items sold from a vendor as a sort of life insurance mechanism
(although, certainly with a cost), which basically limits the death
penalty (for that amount of money) to a single death.
Refactor: replace Point with generic vector

Remove Point struct and add a generic 2d vector class template Vec2 and
then add typedef Vec2d<int> Point, so that Point name may still be used.

Added new functions & altered existing ones for conversions and
transformations between Point and SDL_Rect.
Refactor: replace bubble sort with std::sort

std::sort is a tried and true sorting algo, but the main reason for this
was breakage of the existing sort function in a previous patch
Refactor: Uncopyable

class Uncopyable was added in the same patch that added the Vec2
template class.  Uncopyable is a simple mechanism to cause a class to
become uncopyable, eliminating the risk of un-intended copy or
assignment using the compiler-generated copy constructor or assignment
operator.  Generally, any class that has a pointer data member should be
Uncopyable (there are exceptions of course).  While doing other
refactoring, I actually ended up with a problem because I accidentally
copied the map object when I meant to store a reference to it.
Employing Uncopyable solves this problem
Refactor: pass objects by const ref instead of value
Refactor: constructors and pointers.

Many classes are given pointers to other objects when they are created
or shortly thereafter.  These pointers never change throughout the
lifetime of the objects and are never NULL.  Therefore, this patch
transforms these pointer data members into references, which cannot
accidentally be changed and have no default constructor, so cannot
accidentally be uninitialized.

Further, most constructors in this project allow their members to use
their default constructor and later re-assign them to the desired value,
resulting in double initialization.  This patch also employs member
initializers to prevent this and other problems.
Refactor: CombatText

This patch transforms struct CombatTextItem into a full class with
private members and a public constructor (although it is friends with
class CombatText).  This greatly cleans up sources for the construction
of new CombatTextItem objects.

Double creation of CombatTextItems has been factored out and the
CombatText's vector replaced with a list.  Finally, the entire display
mechanism is changed to handle messages with varying display times,
which may be desirable at some point in the future.
Tweak: Knights interrupted less in melee combat.

This patch affects game play.  When a PC is hit (Avatar::takeHit()) and
are engaged in the AVATAR_MELEE stance (action/skill) while wielding a
shield, they are granted a chance to not be interrupted.  The chance of
avoiding interruption is 20% plus an additional 20% per point of
absorption with a maxiumum chance of 90%.  When a shield as an
absorption range, the average value is used.
Refactor: Items

This patch is similar to the Powers refactoring.  An int id data member
is added to the Item class and Items are now referenced by a const Item
*pointer rather than an item id.  This simplifies many things -- for
one, when you need item data, you don't have to refer to the ItemManager
anymore.  When "no item" needs to be specified, the const Item *pointer
is simply set to NULL and this condition is now checked for.

ItemStorage's operator[] is now inline and exists in two forms: a const
and non-const, to reduce the need for a non-const ItemManager reference.

This patch intruduces a bug that still needs to be fixed: somewhere,
picking up loot (off of the floor) can get screwed up and you pick up,
picking up the wrong item and even duplicating items -- oops.
Refactor: GameStates and MenuManager

Pointers to gui objects that are constructed via a call to new by the
object and destroyed with a delete in the destructor have been
refactored.  Now, these classes will simply use composition and allow
these UI components to be naturally created and destroyed as data
members.  This is far cleaner, eliminates the possibility of memory
leaks and other pointer and memory errors and is much less code.

I have changed visibility of some members, making the private and adding
getters & setters as needed, which improves encapsulation.
equipment
explicit initialization for global object pointers
WidgetLabel
better encapsulation in QuestLog
trailing whitespace