Hi, welcome to this new lesson. We're finally at Week 5, which is going to
be our final week, and I'm excited to cover with
you object interactions. We have covered already how to create data structures such
as lists and dictionaries. We've also covered
how to use vectors as data structures that contain information about
direction and magnitude. We also been learning how
to operate with grids, and finally, with objects. Objects are what we
define as classes, classes that in a way, allow us to construct
objects and use those to modularly construct a series of functionality that
is self contained. In this final week, what we really want to do is start putting these
things together. We are going to be using the framework of object
interactions to really describe how objects within an object
oriented paradigm behave and relate to one
another and how do we actually make them
speak to one another? Especially, they
will speak through the data structures that
we have been learning. We will see how they
operate and can render themselves visible to
one another through lists, through grids, through
distance checks, and other different
forms of evaluation. Let's look at some of those. What we're really talking
about is how does one object interact or send
a message to another object? That object, maybe you
want to just change or ask for a coordinate
or change your color, any interaction that we might want to have
between objects. This is a task that we
haven't really covered yet. We know how to construct objects that are autonomous
and self contained, but we haven't really
started seeing how they interact with one another. This is the foundation
of systems, in a way. If you really start
thinking about how systems are constructed, it has to do with a series
of autonomous entities that send messages and
information between one another. As we can see here, we can actually understand the messaging behavior
between two entities, but also as this grows, as we have a system that
has multiple entities, we can really start seeing
that a more complex system emerges and something
that perhaps its behavior might be more
difficult to predict. Therefore, we will
be simulating. It would only be possible
for us to understand the behavior of a system
through the simulation, executing our code and observing and maybe perhaps storing some data of how
the system is behaving. Let's look at an
example of how objects might interact with each
other in relation to a grid. Here, we actually
have three entities. Let's call them some
random walkers as we've been seeing
throughout this course. They're an autonomous entity, but they're at the same
time relying on a grid, which could be, as we
will see throughout this week, also an object. We have the object of the grid, we could have the
object of a cell. A grid in an object
oriented paradigm, could be thought as a
collection of cells. But at the same time we
have this random walker, which has a position
in this grid. These entities could
actually talk to each other not only through maybe
direct proximity, but also by their relationality. If you think of
the game of chess, the relationship is established by the rules of each
one of the pieces, but at the same time it's relational position
to one another. Many times, we do not have
a grid in the background. We do not have a system like a grid that would allow us to keep track of where things are, and that's totally fine. We could actually have
entities floating in space. We can use different criteria
such as distance and orientation to select what are the perhaps certain units that might be capable
to be interacted with. If we want to let's say push away from a unit
that is too close, that's a unit that we need
to calculate a distance to. This is a series of calculations that might be
computationally expensive if we actually start relying
a lot in loops to iterate over the entire
list of objects. But they can yield exactly the objects
that we're looking for. Is this object in the
right orientation? Is this object close to me? Or there could be a series
of criterias that are met in order to achieve what would be an interaction
between objects. We're going to be
covering many of these different
forms of interaction throughout this week one by one, and so I'll take you through them in the next
lesson. See you then.