Software Design Patterns

class GameObject
{
    readonly IVisible _v;
    readonly IUpdatable _u;
    readonly ICollidable _c;

    public GameObject(IVisible v, IUpdatable u, ICollidable c)
    {
        _v = v;
        _u = u;
        _c = c;
    }
 
    public void Update()
    {
        _u.Update();
    }
 
    public void Draw()
    {
        _v.Draw();
    }
 
    public void Collide()
    {
        _c.Collide();
    }
}
interface IVisible
{
    void Draw();
}
class Invisible : IVisible
{
    public void Draw()
    {
    }
}
class Visible : IVisible
{
    public void Draw()
    {
        /* draw model */
    }
}
interface ICollidable
{
    void Collide();
} 
class Solid : ICollidable
{
    public void Collide()
    {
        /* check collisions with object and react */
    }
}
class NotSolid : ICollidable
{
    public void Collide()
    {
    }
}
interface IUpdatable
{
    void Update();
}
class Movable : IUpdatable
{
    public void Update()
    {
        /* move object */
    }
}
class NotMovable : IUpdatable
{
    public void Update()
    {
    }
}
class Player : GameObject
{
    public Player() : base(new Visible(), new Movable(), new Solid())
    {

    }
}
class Smoke : GameObject
{
    public Smoke() : base(new Visible(), new Movable(), new NotSolid())
    {

    }
}

class GameObject {
private:
    VisibilityDelegate* _v;
    UpdateDelegate* _u;
    CollisionDelegate* _c;

public:
    GameObject(VisibilityDelegate* v, UpdateDelegate* u, CollisionDelegate* c) : _v(v), _u(u), _c(c) {
    }

    void Update() { 
        _u->Update(); 
    }

    void Draw() { 
        _v->Draw(); 
    }

    void Collide(GameObject objects[]) { 
        _c->Collide(objects); 
    }
};
class VisibilityDelegate {
public:
    virtual void Draw() = 0;
};
class Invisible : public VisibilityDelegate {
public:
    virtual void Draw() {
    }
};
class Visible: public VisibilityDelegate {
public:
    virtual void Draw() { 
        /* draw model */ 
    }
};
class CollisionDelegate {
public:
    virtual void Collide(GameObject objects[]) = 0;
};
class Solid : public CollisionDelegate {
public:
    virtual void Collide(GameObject objects[]) {
        /* check collisions with object and react */ 
    }
};
class NotSolid : public CollisionDelegate {
public:
    virtual void Collide(GameObject objects[]) {
    }
};
class UpdateDelegate {
public:
    virtual void Update() = 0;
};
class Movable : public UpdateDelegate {
public:
    virtual void Update() { 
        /* move object */ 
    }
};
class NotMovable : public UpdateDelegate {
public:
    virtual void Update() { 
    }
};
class Player : public GameObject {
public:
    Player() : GameObject(new Visible(), new Movable(), new Solid()) {
    }
};
class Smoke : public GameObject {
public:
    Smoke() : GameObject(new Visible(), new Movable(), new NotSolid()) {
    }
};