Added inheritance from Object->Player

This is the very first step in the first
goal of this new branch: to greater
modularize the engine and all of its
components. This will primarily center
around taking adavantage of the OO provided
by C++. Something I've never fully dived into
More refactoring of the build method

Now run make commands from the build
directory. Added some sym links: link
to /build/test exe into src and linked
sprites into the build directory. This
allows one to run test from either build
or from the source directories.
Initial inheritance relation of Object/Player done

This commit is the first step in making the Object
class the base class for all future in game entities
that have movement (velocity,accel) and even mass.
Objects do not have sprites. In order to create an
object with a sprite, derive a class from object and
compose the new class with the new Sprite class. The
new sprite class handles everything from rotation
creation to rotational animation and much more in
the future (auto collison box creation, deformation,
 etc.).This allows easy creation of new on screen
objects/entities and their behaviors. Also, with
the movement and physics effects now separated from
the animation, Objects can be used to create
interesting effects. NOTE: This commit does not
introduce any new demos or behvaior that takes advantage
of the new back end refactoring. Everything operates as
before (except a minore bug fix with the "w" key).
Fixed broken makefile

Somehow a line was deleted,
didnt compile the RuPPAT.o.
Added background support!

No more plain black backgrounds.
This is the first implementation of
backgrounds with alpha layers (PNG).
Nex step will be to create a layered
background that makes use of Alpha
channel to give the first sense of
depth that this engine has seen. Later
add support for animated backgrounds.
This also introduces a problem that I've
been aware of for some time. The pixel
dimming technique in that past has simply
been to slowly darken the pixels to black.
This will no longer work nicely (look good)
now that backgrounds dont have to be
black.
Multilayer background proof of concept

The background now consists of 3 different
PNGs layerd ontop of each other. Further
work will be needed to make this more
dynamic.
Planet demo looks nicer

Moved the planet to match the backgroun.
Also, altered the pixel spawn to spawn
pixels closer to planet. This works best
if you run at 1920x1080. Use the -width
and -height options to set the resolution.
Cleaning up some old unused code

Made some things more easily readable.
Updated Art and fixed a few bugs

Added some better layering with the
background provided. Fixed a bug that
would cause lockups under odd key
combonations. This isue seems to stem
from odd, undefined, behavior that
I've been seeing when using object
fields and pthreads. A possible long
term solution could be to use C11
threads, SDL_threads (though these
are apparently pthreads anyway), or
to find a method that actually works
with pthreads. The current fix is to
make the field a global variable rather
than a public or private field.
Made some changes to object

Planet in the primary demo now
rotates. Art for the red planet
was also updated to fit the
current art style.
Update Object class its use

Now Objects gravity effect other
objects. To demonstrate, the
default orbit demo now has an
asteroid added.
Formatting abd commenting

Small changes also made to
accel player, should be a
bit more efficient.
Formatting and cleaning
Cleanup
Removing legacy "Mass_desc" code

Replacing with the generic Entity_desc
based code.
Removed legacy code, better formatted

Removed old descriptors and the code
leftover that still needed them.
A tiny bit more formating
Disabled Object orbit. Collisions!

I had to disable gravitational effects
between objects as it was causing major
stability issues. The behavior is odd,
considerably undefined. Sometimes things
work, sometimes they dont. This issue will
have to be fixed as it is a wanted and
expected feature. Additionally, collision
detections has made its first, very rough,
appearance in the form of hit circles. It
looks like this method could work pretty
well, but some major overhauls will be
needed in the way the physics is
implemented. Should be fun.
Renabled Object Grav and NAN checks

The object grav bug is very hard to
define but it is stemming from NaNs
in the physics calculation. I added
some checks, and so far i haven't seen
any NaNs detected. This bug might
require valgrind/helgrind and a serious
rewrite of the backend and threading
implementation.
More advanced CL options

By adding an additional constructor
that uses a struct full of options,
more runtime options are easily
configurable and maintained.