All language subtitles for 011 Composite Pattern_en

Now, suppose we wanted to take the complexity of our special abilities to the next level, and we want

to have something like a power attack, which is a sort of sequence type.

So this power tank would be composed of other things, such as a particle effect ability, such as a

do damage over time, parallel ability.

And that parallel ability itself would be composed of an instant damage, which might be of a damage

ability type and a delayed damage, which is of the delay decorator type.

And then that delay decorator itself references the instant damage object.

So you end up with these complicated object hierarchies, which reuse a lot of code and allow you or

your designers to easily put together a new special abilities out of component parts a little bit like

Lego bricks.

So if you wanted to be able to do something like this, then you would need the composite pattern,

which looks very similar to the strategy pattern and decorator pattern we've already seen.

So instead of having a decorator say if I want to have a sequence ability instead of having one thing

that we wrap up in the sequence, which would be the decorator pattern, the composite pattern says

instead of having one thing, let's have an array of things.

So the sequence would be an array of children which are all members of the ability interface.

Then my sequence would dictate how do those children get run?

So it makes sense that in a sequence, they would get run one after another, the first one would complete

and the second one, etc., etc. However, if you had a parallel ability for whatever reason and your

use was more asynchronous, maybe it started a co routine, for example, then it would run all the

routines all at once and said the sequence would probably wait for one car routine to finish before

going on to the next.

So you can see how you could come up with different ways of composing arrays of abilities.

And that is the composite pattern.

Obviously, the formulation is typically more generic than relating to abilities.

You'd have these components again, very much the same as the decorator pattern.

You would have a leaf, which is kind of referring to the fact that the thing we had before looked a

little bit like a tree upside-down.

So a leaf would be an operation that actually does something.

The composite would be the branches of the tree because it's the branching out points.

It so says, let's sequence these, let's do these in parallel, etc..

By the way, if you've come across behavior trees, this is the way you would implement behavior trees,

essentially by using the composite pattern.

So how do we go ahead and implement the composite pattern in our ability code base?

So let's jump over to it now and give ourselves a little bit more room because here I before and decorate,

I want to create a new public class, which is going to be the sequence composite.

And it's going to inherit from my ability, and it's going to implement the interface of my ability,

basically the use and well, we're going to have to have some sort of children in here.

But you've done this before with the decorator.

So I'm not going to hold your hand here.

I'm going to challenge you to implement the composite pattern in the same vein as the decorator remembering

that instead of single liability, we might want to use an array or a list.

So pause the video and have a go.

OK.

Welcome back, so I'm going to make it a private variable.

I'm going to make it for simplicity's sake.

I'm going to use an array that you'd probably want to use a list or something.

So it's an array of liability and we're going to call this the children.

And we're going to create a constructor which takes in that children array.

So when you create a new sequence, you're going to pass in an array of children and that is going to

be set here.

And the use method would do something very, very simple.

For example, it would do a for each loop over the child in children, and it would call the child's

child dot use method passing in the current game object like so.

So that's a very simple way of creating a sequence composite.

Obviously, you can have all sorts of composites, as I've just explained ones.

You could have a random composite one that basically selects a random option from this list instead

of create calling them all in sequence.

You can have one that calls them in reverse sequence.

The abilities are endless, and you can really split these down into tiny, little reusable chunks so

that you can easily program all sorts of abilities into the system.

So how do we go ahead and construct it again?

That could be a challenge for you.

I'm going to go ahead and do it.

So new sequence composite like.

So now in here, we need to pass in a new eye ability array, which we're going to construct within

here and in here.

You could put something like a first.

We'll start off with a new heel ability as the first child and then after that we might run the new

rage ability and then in there just to show how flexible the system is, we could run a delayed decorator,

which itself couldn't contains another range ability, something along these sorts of lines.

It's entirely possible using our composite pattern.

Obviously, you can have composites of composites and the trees go on endlessly because of this self

referring pattern, because of the fact that the sequence composite is an eye ability and has liabilities

within it because the delay decorator is a liability and has liability within it.

That's really the genius of these decorator and composite patterns is that it allows you to wrap them

indefinitely into these tree structures that are very, very powerful.

So that's it for this little trio of patterns, the strategy, the decorator and composite the next

video.

We're going to be moving on to a completely new paradigm of pattern, the model view controller.

I'll see you there.