Python: Classes that "talk" to each other

Question

I'm a college student. I'm in my second comp sci class and we haven't got much past simply making classes and functions within them so I haven't really been able to make much use of the complicated jargon I've found on the internet.

I'm making a roach infestation sim, and I need to be able to have a "roach" class be able to detect where a "food" class is in a window. My teacher told me that my best shot might be to make another mastermind-like class that is a middle man between the two, but I don't really know how that would work. Can anyone help me out? I'm using Python through Calico. Here's what I have of the roach class (EDIT: guess I should show the main() etc too):

class Roach:
    def __init__(self, win, placex, placey):
        self.timer = 320 + (10 *(int(10 *random.random())))
        self.speed = 0.2
        self.heading = 360
        self.win = win
        self.x = placex
        self.y = placey
        self.body = self.makeBody()
        self.body.draw(self.win)
    def __str__(self):
        t = "Roach at ("+str(self.x)+","+str(self.y)+")"
        return t
    def makeBody(self):
        body = Rectangle((-5,-5),(5,5))
        body.setFill(Color('Brown'))
        body.moveTo(self.x,self.y)
        return body
    def move(self, win):
        self.x = self.x + self.speed *sin(self.heading)
        self.y = self.y + self.speed *cos(self.heading)
        self.body.moveTo(self.x,self.y)
        self.avoid(win)
    def avoid(self, win):
        Border = False
        if self.x >= win.getWidth():
            self.setHeading(random.randrange(91, 269))
            self.x = win.getWidth() - 1
            Border = True
        elif self.x <= 0:
            self.setHeading(random.randrange(271, 449))
            self.x = 1
            Border = True
        elif self.y >= win.getHeight():
            self.setHeading(random.randrange(1, 179))
            self.y = win.getHeight() - 1
            Border = True
        elif self.y <= 0:
            self.setHeading(random.randrange(181, 359))
            self.y = 1
            Border = True
        return Border
        #Getters
    def getSpeed(self):
        return self.speed
    def getHeading(self):
        return self.heading
    def getX(self):
        return self.x
    def getY(self):
        return self.y
    #Setters
    def setSpeed(self, speed):
        self.speed = speed
    def setHeading(self, heading):
        self.heading = heading
        self.body.rotateTo(self.heading)
    def setX(self, x):
        self.x = x
    def setY(self, y):
        self.y = y


def main():
    win = Window(400, 400)
    win.setBackground(Color("White"))
    Rpop = []
    Wpop = []
    i = 320
    menu(win, Rpop, Wpop)
    while getKeyPressed() != 'Escape':
        for roach in Rpop:
            if roach.avoid(win) == True:
                roach.avoid(win)
            elif i % roach.timer == 0:
                roach.setHeading(360*random.random())
            roach.move(win)
        if getKeyPressed() == 'm':
            menu(win, Rpop, Wpop)
        i = i + 1


def menu(win, Rpop, Wpop):
    while getKeyPressed() != 's':
        if getKeyPressed() == 'r':
            Rpop.append(Roach(win,getMouseNow()[0],getMouseNow()[1]))
        if getKeyPressed() == 'w':
            point1 = getMouse()
            dot1 = Circle((point1[0],point1[1]), 3)
            dot1.draw(win)
            point2 = getMouse()
            dot2 = Circle((point2[0],point2[1]), 3)
            dot2.draw(win)
            Wpop.append(Wall(win, point1[0], point1[1], point2[0], point2[1]))
    return

main()

Sorry for the lack of comments and likely juvenile programming. Thank you so much.

Answer 1

Here's a sort of rough outline of how you might use an additional "Master" class to allow two other classes to communicate as is alluded to in the OP:

class Master():
    ...
    def is_food_there(self, coords):
        for food_instance in self.food_instances:
            if coords == food_instance.coords:
                return True

class Food():
    def __init__(self, master_instance):
        self.coords = ###some coordinates or whatever
        master_instance.food_instances.append(self) ### register this food with master

class Roach():
    def __init__(self, master_instance):
        self.master_instance = master_instance
    ...
    def move(self, newlocation):
        if( self.master_instance.is_food_there(newlocation) ): ### check with master for food coords
            ###do something

The idea is that the we have a Master class which is essentially a container for a list of Food instances, and Roach class knows which Master instance it belongs to, so it can access that master's "is_food_there" function which in turn looks through the Food instances that belong to it. The Master class is "the man in the middle" in this example.