I am starting to refactor the Entity class to remove the drawing of squares as the default behavior. Instead there will be a hierarchy for both shapes and images.
I refactored more the of entity class. Now there will be the Entity parent class. This will have the sub-class Entity2D. The class Entity2D will have two sub classes, EntityImage and EntityShape.

Now, one can declare either an EntityShape or EntityImage for a game entity rather than the Entity class.

Note that additional changes will need to be performed including:

- The class Entity will need to be made abstract
- The class Entity2D will be the main entity class on which the game engine will operate.
- All changes will need to be made in the dependent projects that now use this framework.
- Everything will need to be tested to see if anything is broken.
I added another class that extends the shape class in order to draw a rectangle.
Yet another refactoring. I am getting rid of the new Entity2D class.

Note that the original Entity class will become the Entity2D class.
I removed the class Entity2D class.
I refactored the entity class. Now the base entity class is Entity2D and this class is extended by both the EntityImage and EntityShape.

One thing to note. Consider making the Entity2D class abstract to the developer is forced to create an instance of either the EntityImage or EntityShape classes.
I added two new shapes that extend the EntityShape class. These shapes include EntityOval and EntityLine.

I also added a fill flag to the EntityShape class. Now when a rectangle or oval is drawn, either the g.drawRect or g.fillRect is called depending on the value of the fill flag. The same goes for the oval shape.

I began to add graph support. I added interfaces for both nodes and edges. I also added node and edge entities that implement these interfaces. My reasoning, I want to also use this game engine to test and show different planning approaches. I made them part of the game framework rather than a seperate library. If the game framework gets too bloated i the future, I can alway make this graph portion a different library. Possibly an AI library.
I added additional graph files. Again, I decided to make this a part of the GameFramework project. When I use the graph feature more and more and better understand how it is used, I can then refactor the graph class into another seperate library, possibly GamePlanningFramework.
I refactored the graph class that is part of this game framework.

First I realized that the EntityNode and EntityEdge classes could no longer exist in this library and will need to be moved over to the project that makes use of this graph class. I moved these classes to the respective project that uses the graph component of this library.

Second, since the use of the EntityNode and EntityEdge class was "sprinkled" throughout the graph portion, I had to replace these class references with the respective interfaces INode and IEdge.

After using the interface references, there were a few places where edges and nodes were instantiated. Since interfaces cannot be instantiated, I realized I need to use some type of factory pattern. I added the interfaces IEdgeFactory and INodeFactory and passed objects that inplement these interfaces into the graph classes and utility classes.
I added logic to the AStar algorithm that calls the edge and node update methods to perform any updates as the algoritm makes progress.
I added additional logic to AStar that will call the edge update method so projects that implement the IEdge interface can add custom logic when an edge is part of the nodes added to the open list.

I also updated the graph generator so that it can generate either 4 or 8 neighbor connected graphs.
I added two new custom font classes. The one, Static Text, is a wrapper that contains all of the code required to configure and draw a static string to the screen. The other, StaticTextFade, will either fade in or fade out a static string on the screen.

These classes came about due to the large amount of code needed to layout and draw the may strings for different screens in the various games developed so far. Hopefully these classes will make it easier for one to desing and layout various screens in their games.
I made a few improvments to the StaticText class.
I added a conditon to the draw method of the EntityImage class to throw and exeption if the image is null.
I added additional messages in Game Engine class to display a message when the update and render operation takes too long.