def handleCollide(self, object_, objectsHit):
     for obj in objectsHit:
         if not objectsHit[obj] in object_.handledCollisions: 
             obj = objectsHit[obj]
             if object_.getType()=="MovingObject" and obj.getType()=="StationaryObject":
                 c = self.getCollisionDirection(object_, obj)
                 if c[0] or c[1]:
                     object_.setAngle(maths.getAngleOfReflection(object_.getAngle(), 0))
                     pos = object_.getPosition()
                     vec = maths.polarToCartesian((180+object_.getAngle())%360, 3)
                     pos = pos[0]-vec[0], pos[1]-vec[1]
                     object_.setPosition(pos)
                 elif c[2] or c[3]:
                     object_.setAngle(maths.getAngleOfReflection(object_.getAngle(), 90))
                     pos = object_.getPosition()
                     vec = maths.polarToCartesian((180-object_.getAngle())%360, 3)
                     pos = pos[0]-vec[0], pos[1]-vec[1]
                     object_.setPosition(pos)
                 
                 
                 object_.setSpeed(maths.getReducedSpeedByPercent(object_.BOUNCYNESS, object_.getSpeed()))
                 object_.onCollide(obj)                         
             elif object_.getType()=="StationaryObject" and obj.getType()=="StationaryObject":
                 object_.onCollide(obj)
             elif object_.getType()=="MovingObject" and obj.getType()=="MovingObject":
                 object_.moveBack(object_.getSpeed()*2)        
                 print object_.getName(), obj.getName()                  
                 vec = maths.getFinalPolarVectorFromVector(object_.MASS, object_.getVector(), obj.MASS, obj.getVector())
                 #vec = maths.getFinalPolarVectorFromVector(obj.MASS, obj.getVector(), object_.MASS, object_.getVector())
                 
                 if object_.getName()!="Ball":
                     obj.setSpeed(vec[0][1])
                     obj.setAngle(vec[0][0])
                     obj.addHandledCollision(object_)
                     object_.setSpeed(vec[1][1])
                     object_.setAngle(vec[1][0])
                 else:
                     obj.setSpeed(vec[1][1])
                     obj.setAngle(vec[1][0])
                     obj.addHandledCollision(object_)
                     object_.setSpeed(vec[0][1])
                     object_.setAngle(vec[0][0])
 
             elif object_.getType()=="StationaryObject" and obj.getType()=="MovingObject":
                 object_.onCollide(obj)
             elif object_.getType()=="ContainerObject" and obj.getType()=="MovingObject":
                 object_.onCollide(obj)
             elif object_.getType()=="MovingObject" and obj.getType()=="ContainerObject":
                 object_.onCollide(obj)
             else:
                 self.logger.error("Invalid Object(s): "+str(object_.getType())+", "+str(obj.getType()))
 def updateMovement(self):
     for obj in self.objects:
         obj = self.objects[obj]
         if obj.TYPE=="MovingObject":
             obj.setSpeed(maths.getReducedSpeedByPercent(obj.FRICTION, obj.getSpeed()))
             vec = maths.polarToCartesian(obj.getAngle(), obj.getSpeed())
             obj.setVector(vec)
             #print vec, obj.getAngle(), obj.getSpeed(), obj.getPosition()
             obj.setPosition((obj.getPosition()[0]+vec[0], obj.getPosition()[1]+vec[1]))
 def updateRobots(self):
     for team in self.robots:
         for robot in self.robots[team]:
             rbt = self.robots[team][robot]
             rbt.update()
             
             closestDist = 200
             closestObject = 0, (200, 200), 0
             closestObjectPhy = None
             
             for obj in self.physics.objects:
                 obj = self.physics.objects[obj]
                 if obj.VISIBLE_BY_SONAR:
                     result = maths.isLookingAt(rbt.getPosition(), rbt.getAngle(), obj.getRect())
                     if result[0]:
                         dist = obj.getRect().center
                         dist = dist[0]-rbt.getPosition()[0], dist[1]-rbt.getPosition()[1]
                         dist = maths.math.sqrt((dist[0]*dist[0])+(dist[1]*dist[1]))
                         
                         if dist < closestDist:
                             if not obj.getName() == rbt.getName():
                                 closestDist = dist
                                 closestObject = result
                                 closestObjectPhy = obj
             try:
                 pos2 = maths.polarToCartesian(rbt.getAngle(), dist+100)
                 pos2 = rbt.getPosition()[0]+pos2[0], rbt.getPosition()[1]+pos2[1]
                 lookingAt = maths.getPointOfIntersection(rbt.getPosition(), 
                                                           pos2, 
                                                           maths.indexToCoordinate(closestObjectPhy.getRect(), closestObject[2]), 
                                                           maths.indexToCoordinate(closestObjectPhy.getRect(), closestObject[3]))
                 
                 dx, dy = lookingAt[0]-rbt.getPosition()[0], lookingAt[1]-rbt.getPosition()[1]
                 distFromPointBeingLookedAt = maths.math.sqrt((dx*dx)+(dy*dy))
                 rbt.addSensorReading("SONAR", distFromPointBeingLookedAt)
                 rbt.addSensorReading("TYPE", closestObjectPhy.getName())
             except Exception, ex:
                 pass #TODO
 def moveBack(self, steps):
     self.vector = maths.polarToCartesian(self.angle, -steps)
     x,y = self.vector
     self.position = self.position[0]+x, self.position[1]+y
 def draw(self):
     pygame.draw.circle(self.surf, self.color, self.rect.center, 8)
     pos1 = maths.polarToCartesian(self.getHeading(), 7)
     pygame.draw.line(self.surf, (0, 255, 0), (pos1[0]+self.rect.centerx, pos1[1]+self.rect.centery), self.rect.center, 1)