Behavioural Patterns: Strategy Pattern

EliteSalad — Sun, 28 Nov 2021 23:46:39 +0000

Strategy pattern defines a family of algorithms Defines each one of them and makes them interchangeable. Strategy lets the algorithm vary independently from the clients that use it.

Inheritance is a pretty basic object-oriented technique that allows subclasses created from already existing classes to use functions and variables from their parent class. This easily allows behaviors to be similar and means code can be reused. There are however circumstances where an inheritance will in fact create more duplicate code than can easily be managed to bring with it all the folly of having copy-paste code from one section to another. This can occur because when inherited functions can be inherited down easily but they cannot be inherited across. Here is an example of when code would be duplicated under inheritance.

In the above UML 2 subclasses are using the same Fight function and two are also utilizing the same Eat function. Despite that, on implementation, those repeat functions will have to be written out in full twice or even more if another class shares that functionality. There is no way for the one function to be used by one of its sister classes, but strategy patterns can circumnavigate this dilemma.

A strategy pattern takes functionality away from the function within the class instead of requiring an interface class for that function to be created which can then act as a directory to select a class for them. Now that the interface class exists it can assign completely different classes even ones unrelated to the base class with the exact same functionality if required. This is the logic applied to the first UML diagram

It is possible to take this one step further completely foregoing inheritance itself and instead establishing all parts of the base class as interfaces. This would then mean the subclass would instead be a collection of the correct interfaces instead of one that inherited the correct functionality and had overridden other parts.

This complete lack of inheritance means no class in this model 'is a' form of another class and instead it is a group of classes that 'has a' bunch of other classes creating a spider web of links as opposed to a tree of inheritance. This method probably shouldn't be the default with simple projects or small use cases but it definitely has earned the right o be as prolific as inheritance in my opinion. Sandi Metz argues the benefits of composition over inheritance in her Nothing is something talk on the null object pattern.

Moving Objects in Unity The Right Way

EliteSalad — Sun, 28 Nov 2021 23:05:40 +0000

Physics based

Rigidbody SetVelocity

rb.velocity = transform.forward;
Once velocity is set provided there is no drag object will maintain pace until collision.
Great for launching an object with a speed independent of its mass

Rigidbody MovePosition

rb.MovePosition(transform.position + (transform.forward * Time.deltaTime));
Only physics based way to move a kinematic object
Stable Way to move a rigidbody object without manipulating the physics of the object just the position.

Rigidbody AddForce

rb.AddForce(transform.foward * Time.deltaTime );
Every frame force will be added leading to acceleration up to infinity provided drag is 0.
Allows for specific force modes to be inserted such as Start, Impulse, Acceleration, Force, and Velocity Change. These can all change the behavior of how that particular force is applied to the object.

Position Based

Transform Translate

transform.Translate(Vector3.foward * Time.deltaTime);
Gives an amount of space to move each frame
Great for animating
Can move kinematic objects

Transform Set Position

transform.position += transform.forward * Time.deltaTime;
Giving new position to move every frame
Great for animating
Can move kinematic objects

Because movement operations through transform happen asynchronously when moving through or next to an object with a collider on the object may bounce or stutter as it tries to continue in the desired direction. This is because it successfully moves before being rejected back out by the physics of the collider. Because of this using these functions on an object that is meant to touch another object in some way is not recommended.

DEV Community: EliteSalad