Shell forms around the atom based on Charge.

Added a Basic class that is inherited by Circles and Hexagons.  Takes care of a get_points() function that returns lines (list(a,b)), shapes (list(points)), and circles (list(position, radius))
Started to work on Views interface to make better use of PyGame.Surface class.

View base class is built out quite a bit.  Considering making MainView handle opening up the PyGame.display.set_mode(): Surface instead of the Interface.  Interface will still be responsible for the PyGame.clock to keep track of time.  CameraView is in progress.  This will enable better scrolling than the garbage I have (presumably), as well as zooming.  GameView is going to be a big one and is currently jumbled.

I'm finally tired.
More in progress work on Views interface.

Decided I probably will move the pygame.clock to the MainView, and let the Interface use time.time() and eventually retire itself as the "Interface", and be more like the Core... thing - Yeah I'll just rename it to Core in a future update.  Though it does handle a lot of input stuff...  That might have to get moved- Ahhh!!
More work on creating Views and trying to progress with a system that I feel will be the most efficient.

All calls to a View.update() can include an optional Area rect which only updates the subviews in that region and blits that segment of the surface.  Even now if we have a huge surface for a game level, we should never need to write to all of it and then lose most of it when it gets cropped to the size of the screen.  Basically, I'm trying to avoid redrawing the entire map on every frame, only to crop out the tiny pieces that are used for the Main View.
Trying to focus on the GameView as that is the first piece I think I should test.

From there I will try to build up the CameraView so that I can scroll and zoom.  After that I can try plugging it all into the MainView.

GameView is going to contain the settings for how everything in the game should be seen.  So that means it is now going to handle Player/energy color, atom border color, atom border opacity, atom border width, etc.  Moving all of that stuff over should be quick.  I just have to step it up.
GameView - Still working on copying over display functions and configurations over to GameView.  Ran into an issue when trying to figure out how to display the Shell with the Charge Lines.  There is some question as to whether the GameView should be responsible for holding onto these objects that are only display related, or whether the Shell object should also reference it for some reason.  I'm leaning towards keeping the display and the game elements independent of one another.
GameView - Added func args in the object settings dictionaries.
SpaceTime & Levels - Started building out basic classes to handle level data and creating of random levels.  These will then get loaded into the SpaceTime element, which is meant to eventually replace the Plane, which in turn could become a Basic object as it interfaces with pymunk and be loaded by SpaceTime.  Oh the confusion...
PhysicalWorld - So made the Plane be replaced by the PhysicalWorld.  Also, all of the calls to pymunk were moved to the PhysicalWorld library.

SpaceTime - This will be more responsible for the ability to go back and forth between events in the timeline.  I will make it responsible for tracking all the world events.  Essentially, I should always be able to paint an exact picture of what is going now by building up from the last checkpoint with the events list.  It will also be responsible for creating the atoms and energy in the world that the Game will load from the Level Data.

Player - Will now have unique hashes to compare and control energies.
GameView - Added a surface_dict of PyGame Surfaces that will be used by categories of objects to allow the best flexibility in display while optimizing for speed.  So atoms display on 4+ different surfaces for their 2 borders (white + black), shell (player color), and charge (player color).  The surfaces_dict will be what gets blitted to the GameView's Surface.  The GameView will be one of the lowest level Views, so it will not emulate the behavior of attempting to display more Views below it, like the View class.  Instead, it shows the actual Game Objects as they appear in SpaceTime.

SpaceTime - Added functions to support GameView.

Really trying to focus on this thing as I need to see results of the work I've been doing soon.  I keep finding myself getting side tracked on how Levels will be loaded and ElementData passed around.
GameView - More work to get GameView to be responsible for displaying everything.

Made it hold a dict of display_objects that will handle more fluid displays of data than the game world often can provide.  One example is its current use, the Shell, which slowly fades in and fades out after every 1/6 mark rather than always accurately representing the exact charge of the Shell.

Element - Will also generate a unique hash and store it.  This id is used in dicts like the display_objects in GameView.

Walls - Added displaying of Walls to GameView and changed the name of the prior Wall class to just Line.  Then added a Wall to the elements that will create lines, and that is about it for now.
ChargeLines - Had to make a few minor changes to get the engine to run correctly with the current parameters for ChargeLines.

Working on changing Game next, so everything is going to break anyway.
Game - I started switching stuff ov-- I broke everything.  I'm not sorry.

Started writing level loading into Game.  Also began phasing out the use of ElementData for a dict for now.  I'll leave ElementData around a bit to see if it ever fills a role.

ToDo:
Game - Fix everything.
Basics - Need to remove all references to a Plane and replace them with PhysicalWorld probably.
Game - Attempting to fix everything.  It's going alright.
Game - Almost fixed.  It runs, more or less.  Commands don't work yet.  WAY slower, too.  May need to conserve with this multiple surfaces idea as per pixel transparency is expensive.
Game - Still fixing stuff.  Still slow.
Game - So I made the generation of multiple surfaces easier but still came to the conclusion that having this many surfaces is just way too horribly slow.

ToDo:
I think I'll fix this by emulating the effect of layers in GameView.  Instead of printing each object directly to a specific surface as they are looped through, they are instead appended into a specific list.  Then at the end of the display function, it'll go through the lists in a specified order, so all atoms get blitted before all energy, onto a single per pixel alpha surface.

This also means that I really have to conserve on Views and CameraViews as each additional one will slow down the game considerably.  Not very scalable.  Probably... should... have... seen that one coming.
Game - Used just one surface for which I iterate over function callbacks.  Introducing SixX: Waaaayyy faster.  Whole new bugs!  This will all soon be worth it.

ToDo:
Fix new problems.

Zooming with CameraView!
GameView - Last commit should have been titled GameView as well.  Just minor changes of method names and an include.
GameView - Corrected the Charge not displaying.

Wall, Line - Fixed the collision detection.