Added some vector operations

dot product, projection, and right/left normal

renamed CartesianMath to MathUtils

a little refactoring in Screenshot
Changes to save system and image rendering

The save system isn't ready for use yet, and won't be until the future
large overhauls of the entity and image system. I just changed some
stuff around so that the code compiles and isn't quite as confusing (I
hope).

The image rendering system is being redesigned to be more efficient.
There is a SpriteSheet that is supposed to hold all the images, while
entities hold onto what are essentially pointers with extra data like
position and a visibility flag.
Rendering redesign

I am redesigning/refactoring the render process so that it makes more
sense. The actual drawing happens on Screen, which only ever uses
screen-space coordinates. But  I don't want ingame objects to have to
figure out how to draw themselves, so I have Render, which takes
world-space coords and converts them to screen-space coords using
information from the camera. This way, objects never have to know
anything about screen-space, and only exist in world-space. All
conversion between coordinate systems happens in the Render class.
Objects are still free to access the Screen directly, though, to allow
easy addition of things like UI elements.
Rendering redesign - rotation support

Adds support for image and camera rotation using the new rendering
pipeline. This update uses a Transform to represent the camera, so
future updates could allow for any Transform to function as a camera.
The only thing that will make it a camera is my say-so, along with any
camera-specific motion scripting. Scaling is next on the list, and then
I can move on to some physics.

Also updated the Keyboard class to be able to support the entire
keyboard. The keys array now holds as many values as there are keys.
Adding Behaviors

A behavior is a specific action that occurs over many entities at once.
Instead of putting the action in tick methods among all the other things
that get stuck in there, I used a Behavior class. This allows Components
to be free of action-related parts, and allows an action to happen over
every entity without fear of being interrupted by other actions changing
variables around. A prime example is for physics. First the gravity
Behavior will analyze the entities and apply gravity to them, then any
other similar forces will act, and then at the end of the tick cycle the
collision Behavior will analyze all the entities and deal with
collisions.

If multiple Behaviors do not affect entities in the same way, this could
even allow for multithreading.

Also, I might want to rename Behaviors to Systems.
Big Physics Update (and some other stuff)

New Features:
- Entity-Component-System framework
- Circle-circle collision detection
- Universal gravity
- A render method for devmode
- Each Entity has a unique ID
- Game says it's paused when it is paused with devmode enabled
- FreeBody shows dev info with devmode enabled
- You can get the momentum from a FreeBody
- Removed test code from PlayerMovement
- Render has an alignGraphicsToCamera() method

Changes:
- Added some more render methods to Screen
- Gravity is calculated by a System instead of by individual FreeBody
objects
- the utils package was moved from hellomisterme to artillery_engine
- Entity uses a Hashtable to store Components instead of a List
- Game has some basic updates to do with window size and rendering
- World makes circles instead of a spaceship
- World makes random circles when ADDBADDIE is pressed
- Speeded up the camera movement
- put back globalTransform() for easy future changes
- Keyboard now uses BitSet instead of boolean[]
- Screenshot doesn't copy the image it's given, its owner needs to do
that
- Render has an AffineTransform to transform Graphics objects to
worldspace
- Renamed Behavior to System
Entity/Component/Behavior System Update

Behaviors are now designed to keep track of the entities they are to
use. They are no longer passed a list of all entities in the game.
Instead entities are added to them the way they are added to the World.
The most efficient way for a Behavior to keep track of an entity is for
it to store references to the individual components instead of the
Entity, avoiding thousands of component lookups per tick.

I renamed Systems to Behaviors again, because I didn't want namespace
conflicts.

Entity now stores a List of Components because looking them up based on
their hash won't work if the Component type stored is a subclass of what
you're looking for. It also uses Iterators.

World stores Entities and Components in Sets for faster lookup times and
to prevent duplicates.

The isMutualllyExclusive() method in Component is no longer static
because static methods cannot be overridden.

Used Generics for the Entity's getComponent() method, because now I know
how!!!

Collision uses a data structure modeled after LinkedLists, so that it
can efficiently test each pair of entities against each other.
Changes to Vector

All methods modifying a Vector now return the same Vector. This helps to
work with Vectors because I can chain the method calls as explained in
the added documentation.

All methods returning new Vectors have been removed to avoid confusion
as to whether a new vector is being made. New Vectors will always be
created by the code using them. Other classes have been changed since
this change has broken some code.

Fixed the normalize() method, which was not actually doing its job
correctly. Hopefully I can find a more efficient way to normalize in the
future, but I doubt it.
FreeBody Acceleration Vector

Instead of directly modifying its velocity vector every time a force
acts on it, FreeBody now keeps track of acceleration per vector and adds
it to the velocity once per turn. That way every object that uses the
velocity for calculations uses the same values.
Merge branch 'master' of https://github.com/ChemicalRocketeer/ArtilleryEngine