The core difference between OOP and DOD lies in the separation of data and behavior. In OOP, data and behavior are coupled together in objects, while in DOD, data and behavior are decoupled. In OOP, if we want to perform an action, we ask an object to do something via its methods. In DOD, we don't ask the data to do something, instead we have systems that perform actions on the data.
In DOD, specifically within the Entity-Component-System (ECS) architecture used by Unity DOTS, entities are simple identifiers, components are containers for data, and systems contain the behavior/logic that operates on entities with specific components.
Let's take the example of moving a character in a game. OOP Approach: We might create a Character class that has a position attribute and a move() method. We create a Character object and call the move() method when we want the character to move.
class Character
{
Vector3 position;
void move(Vector3 direction, float speed)
{
position += direction * speed * Time.deltaTime;
}
}
Character myCharacter = new Character();
myCharacter.move(Vector3.right, 5);
DOD Approach: In DOD, we instead create a Position and Velocity component. We create a system that iterates over all entities with these components and updates their position.
struct Position
{
public float3 Value;
}
struct Velocity
{
public float3 Value;
}
class MovementSystem : SystemBase
{
protected override void OnUpdate()
{
Entities.ForEach((ref Position pos, in Velocity vel) =>
{
pos.Value += vel.Value * Time.DeltaTime;
}).ScheduleParallel();
}
}A crucial part of DOD is to focus on the data, not the conceptual objects. Instead of thinking about a character who can move, think about position and velocity data that can be processed. Systems don't "know" what they're moving, they're just performing operations on data.
In DOD, systems perform behavior globally. A MovementSystem doesn't belong to a single entity. Instead, it operates on all entities that have the necessary components. In the movement example, any entity with a Position and Velocity component will be moved by the MovementSystem.
The transition from OOP to DOD is as much about practice as it is about understanding. Try taking simple examples, like the one above, and translating them from OOP to DOD. Over time, this process will become more intuitive. Remember, it's not about forgetting OOP, but rather about learning a new way to structure and think about your code. Both paradigms have their own strengths and suitable use cases. The goal is to expand your toolkit and flexibility as a programmer.