• entries
33
37
• views
39187

# [Structure] Stop The Catch All's!

836 views

How do you write your classes? Are they neatly divided into different member functions, each one handling a small responsibility that plays into the larger responsibility of the class? If they are, good for you! You're following one of the main Principles of clean code, the single responsibility principle. However you're taking it a step further. Instead of only applying it to your class, you're applying it to your functions too.

Wait, do you have the common Update() function? Or how about the Logic() function? You might have your classes neatly divided up, however this will ruin your whole class. The point of the single responsibility principle is to make your code easy to read and to make it easy to understand why you're doing what you're doing. Calling Collision.Physics().CheckCollision(Collision.GetNextTile(), Collision.GetNextTile()) would be almost impossible to understand, that's why you divide you Tile Manager, Physics Manager, and Collision Manager into separate classes. So calling Collision.Logic() or Collision.Update() ruins the harmony. What does Logic() do, what does Update() do? Wouldn't it be far easier to read if your code was calling if it was structured like this:
for (int CurrentTile = 0; CurrentTile < Collision.NumberOfTiles(); ++CurrentTile){ Collision.CheckTile(CurrentTile);}if (Collision.ThereWasCollision()){ Physics.AcceptCollisionPoints(Collision.GetCollisionPoints);}
It would be. That's why calling an Update() or Logic() function is bad. No-one will have any idea the sum of what that function does. Imagine going back to your code in a month (Wait, do I still have to give my Physics object the collision points, no Update() does that, what about testing Collision on slopes?....). You'll have no idea what functions you need to call, and it would probably result in you searching through your Physics and Collision classes trying to figure out what's doing what.

This often becomes and issue of coding the right way or going the lazy path. A lot of times you just want to write the "catch-all" Logic() or Update() function because you're lazy or don't want to write down the extra code. Now, if you're going to be doing what I did in the code above many times, then it would make sense to create a function that does it for you. You just need to give it a proper name (Collision.CheckCollisionandSendPoints(Physics)). Now, there is probably a better name for it, however I just couldn't think of one (Stupid Me !).

Even if it's more code, coding the right way will pay out in the long run. Resulting in adding features extremely easy. For example, when I made breakout my code was filled with these functions, all kinds of extremely specific properties, and a code-base that resulted in needing fifty classes passing to each other, making adding power-ups a futile attempt. You often need to strike a balance. My code-base would have been more expansive and readable had I been more lenient on the principles I was using. You can never "always" apply a principle, however when it applies, it applies (When using it strictly makes sense, it really helps your code).

I hope you enjoyed this article, and please comment below with how you handle your functions. If you disagreed with it or have a correction, feel free to criticize me and mock how amateur I am !

There are no comments to display.

## Create an account

Register a new account