Writing an Extensible Application - Part 1

Hi All,


In the next posts I will try to examine some simple ways to make your application extensible. Most of the applications we use in our daily life have some form of extensibility. For example the Visual Studio has add ins, extensions, packages and other forms of extensibility which allow you integrate your own functionality to an existing application. For the purpose of our discussion I will define extensibility of an application simply as adding new application functionality without having to recompile any part of the application.

I will demonstrate briefly several simple ways to make your application extensible. To this end I have prepared a demo project (in fact, this post will discuss only this demo project).

The Balls Simulation

The demo project might be familiar to some of my readers since I take it from the new employee training program of my previous job. The application contains a rectangular area called "field". The user adds entities to that field called "balls" and they move inside the field. The balls may collide with each other during the movement within the field and they have to react accordingly. The balls may also collide with the walls and react accordingly.

A screenshot from my demo application

The most important part of writing an extensible application is to decide how the user will be able to extend it. In the case of my application the user will be able to extend the ball behavior using three aspects:

• Movement - Determines how the ball is going to move around the field.
• Drawing - Determines how the ball is going to be drawn on the filed.
• Collision - Determines how the ball will react to a collision with another ball.

Now that I decided that these three items are my extensibility points I need to decide on the design of the application. I chose to implement it using the strategy design pattern. Each of the three elements mentioned above will have a strategy object which will be assigned to a ball. (The ball will be composed of the three element.) Now that this is decided I can define a dll that will be given to the extension writers, clients, which will contain the required interfaces. You don't want to give your clients a bulky dll that will contain all the classes and the logic but a thin layer which will not confuse them but will allow to write a complete extension set.

The interfaces I defined are:

5. public interface IMover
6. {
7.   void Tick(IBall ball);
8.   void Initialize(IBall ball);
9.   void AtWalls(IBall ball, HashSet<WallType> wallTypes);
10. }

 

4. public interface IColider
5. {
6.   void AfterCollision(IBall ball, IBall other);
7.   void BeforeCollision(IBall ball, IBall other);
8.   void Collision(IBall ball, IBall other);
9. }

 

4. public interface IDrawer
5. {
6.   void Tick(IBall ball);
7.   void Initialize(IBall ball);
8. }

 

At this point I want to dedicate a short passage on coding games. The basic design of a game contains a game timer that paces the game. The game timer activates as fast as possible but sometimes it is limited to a specific frame rate - FPS (Frames Per Second). Each time the timer activates is called a game "tick". In each tick the game manager iterates on all the entities within the game (called "sprites") and calls a method that updates their inner parameters. Then the game manager iterates on all the sprites again and draws them on the screen.

As you can see I am using a 3 method collision handling. This method will not cover all the collision cases but it is good enough for many basic games including this demo application. The rules are simple: When two balls collide then the three collision methods are called one by one on each ball with an alternating order (see the code snippet next). On the BeforeCollision method the current ball can gather and data it needs from the other ball but it is not allowed to change its own data. On the Collision method the ball may change any of its parameters based on the data collected in the BeforeCollision method. On the AfterCollision method each ball may set any parameters on the other ball but not on itself.

Putting every thing mention above into code, results in the following Tick method of the timer:

65. #region Handle Movement
    
66. foreach (Ball ball in _balls)
    
67. {
    
68.   ball.Move();
    
69.  
70.   HashSet<WallType> hitWalls = new HashSet<WallType>();
    
71.  
72.   if (ball.Left <= 0)
    
73.     hitWalls.Add(WallType.Left);
    
74.  
75.   if (ball.Top <= 0)
    
76.     hitWalls.Add(WallType.Top);
    
77.  
78.   if (ball.Right >= MainCanvas.ActualWidth)
    
79.     hitWalls.Add(WallType.Right);
    
80.  
81.   if (ball.Bottom >= MainCanvas.ActualHeight)
    
82.     hitWalls.Add(WallType.Bottom);
    
83.  
84.   if (hitWalls.Count > 0)
    
85.     ball.AtWalls(hitWalls);
    
86. }
    
87.  
88. #endregion
    
89.  
90. #region Handle Collision
    
91. for (int i = 0; i < _balls.Count; i++)
    
92. {
    
93.   for (int j = i + 1; j < _balls.Count; j++)
    
94.   {
    
95.     if (IsColliding(_balls[i], _balls[j]))
    
96.     {
    
97.       _balls[i].BeforeCollision(_balls[j]);
    
98.       _balls[j].BeforeCollision(_balls[i]);
    
99.       _balls[i].Collision(_balls[j]);
    
100.       _balls[j].Collision(_balls[i]);
     
101.       _balls[i].AfterCollision(_balls[j]);
     
102.       _balls[j].AfterCollision(_balls[i]);
     
103.     }
     
104.   }
     
105. }
     
106. #endregion

(Note that in this first version the Drawer is not used but you will see it in play in the next post)

The main object of the game is the Ball class. It is exposed to the client as an interface and the client may interact with this class through the interface. All the Ball logic is managed within the class itself, feel free to browse the code there after downloading the demo application.

The application UI is quite simple. The field is on the left side. On the right side there are three combo boxes which will allow you to select the relevant strategy objects and a create button that generates a ball with the selected strategy objects. Both the Mover and the Drawer have Initialize methods that are called once the ball is created to allow the client position and draw the ball for the first time. Note that for this initial stage of the application the combo boxes are not used (since there is no extensibility yet) and the create button creates a small blue ball that just moves around and bounces off walls and other balls.

I encourage you to try out the code to get the feel of it before diving into the extensibility part in the next posts.

You can download the code from my SkyDrive here:

 

Thank you for reading,

Boris.

 

P.S.

Thanks to David Elentok you can see that the formatting is improved a little. I hope to improve it even more in future posts.