Hank Mclaughlin

##
#Hank Mclaughlin's Rect class
#
#This is a rectangle that has collision detection and some
#basic collision response as well as properties for edges,
#corners, midpoints of edges, the center point, and the size
#that can be used as normal members.
#It can also find the union or intersection between itself
#and another given Rect.
#In addition to that, it has a fairly flexible constructor
#that can take a variety of types of sets of arguments.
#
#This is public domain, please use it however you want!
#
#For reference, there are some Doxygen-style docs above
#each method.
#(Aside from the private getters and setters for
# properties, that is)
#Methods are camelCased, as well, and the getters and
#setters begin with underscores (IE: _ ) which mean
#that they are mostly internal.


##
#@brief Generic rectangle container
#
#Contains methods for collision detection and reponse,
#as well as properties for all 4 edges, size, corners,
#and midpoints of edges.
class Rect(object):
  def __init__(self,x,y=None,w=None,h=None):
    if y != None:
      if w != None:
        if h != None:
          self.left   = x
          self.bottom = y
          self.width  = w
          self.height = h
        else:
          self.left   = x
          self.bottom = y
          self.width  = w
          self.height = w
      else:
        self.bottomleft = x
        self.size       = y
    else:
      if isinstance(x,Rect):
        self.left   = x.left
        self.bottom = x.bottom
        self.width  = x.width
        self.height = x.height
      else:
        self.left   = x[0]
        self.bottom = x[1]
        self.width  = x[2]
        self.height = x[3]


  def _getLeft(self):
    return self._left
  def _setLeft(self,new_left):
    self._left = new_left
  left = property(_getLeft,_setLeft)

  def _getRight(self):
    return self._left + self._width
  def _setRight(self,new_right):
    self._left = new_right - self._width
  right = property(_getRight,_setRight)

  def _getCenterx(self):
    return self._left + (self._width / 2.0)
  def _setCenterx(self,new_centerx):
    self._left = new_centerx - (self._width / 2.0)
  centerx = property(_getCenterx,_setCenterx)

  def _getBottom(self):
    return self._bottom
  def _setBottom(self,new_bottom):
    self._bottom = new_bottom
  bottom = property(_getBottom,_setBottom)

  def _getTop(self):
    return self._bottom + self._width
  def _setTop(self,new_top):
    self._bottom = new_top - self._width
  top = property(_getTop,_setTop)

  def _getCentery(self):
    return self._bottom + (self._width / 2.0)
  def _setCentery(self,new_centery):
    self._bottom = new_centery - (self._width / 2.0)
  centery = property(_getCentery,_setCentery)

  def _getWidth(self):
    return self._width
  def _setWidth(self,new_width):
    self._width = new_width
  width = property(_getWidth,_setWidth)

  def _getHeight(self):
    return self._height
  def _setHeight(self,new_height):
    self._height = new_height
  height = property(_getHeight,_setHeight)

  def _getTopLeft(self):
    return self.left, self.top
  def _setTopLeft(self,new_topleft):
    self.left, self.top = new_topleft
  topleft = property(_getTopLeft, _setTopLeft)

  def _getTopRight(self):
    return self.right, self.top
  def _setTopRight(self,new_topright):
    self.right, self.top = new_topright
  topright = property(_getTopRight, _setTopRight)

  def _getBottomLeft(self):
    return self.left, self.bottom
  def _setBottomLeft(self,new_bottomleft):
    self.left, self.bottom = new_bottomleft
  bottomleft = property(_getBottomLeft, _setBottomLeft)

  def _getBottomRight(self):
    return self.right, self.bottom
  def _setBottomRight(self,new_bottomright):
    self.right, self.bottom = new_bottomright
  bottomright = property(_getBottomRight, _setBottomRight)

  def _getMidLeft(self):
    return self.left, self.centery
  def _setMidLeft(self,new_midleft):
    self.left, self.centery = new_midleft
  midleft = property(_getMidLeft, _setMidLeft)

  def _getMidRight(self):
    return self.right, self.centery
  def _setMidRight(self,new_midright):
    self.right, self.centery = new_midright
  midright = property(_getMidRight, _setMidRight)

  def _getMidTop(self):
    return self.centerx, self.top
  def _setMidTop(self,new_midtop):
    self.centerx, self.top = new_midtop
  midtop = property(_getMidTop, _setMidTop)

  def _getMidBottom(self):
    return self.centerx, self.bottom
  def _setMidBottom(self,new_midbottom):
    self.centerx, self.bottom = new_midbottom
  midbottom = property(_getMidBottom, _setMidBottom)

  def _getCenter(self):
    return self.centerx,self.centery
  def _setCenter(self,new_center):
    self.centerx,self.centery = new_center
  center = property(_getCenter,_setCenter)

  def _getSize(self):
    return self.width,self.height
  def _setSize(self,new_size):
    self.width,self.height = new_size
  size = property(_getSize,_setSize)


  ##
  #@brief Does the caller contain the given point?
  #
  #@param pt (2-tuple of numbers)\n
  #          The point to test
  #
  #@return Whether the caller contains the given point
  def collidePoint(self,pt):
    collide_x = pt[0] > self.left   and pt[0] < self.right
    collide_y = pt[1] > self.bottom and pt[1] <   self.top

    return collide_x and collide_y


  ##
  #@brief Does the caller overlap with the given Rect?
  #
  #@param other (Rect)\n
  #             The Rect to check
  #
  #@return Whether the caller and the given Rect overlap
  def collideRect(self,other):
    collide_x = self.left < other.right
    collide_x = collide_x and other.left < self.right

    collide_y = self.bottom < other.top
    collide_y = collide_y and other.bottom < self.top

    return collide_x and collide_y



  ##
  #@brief Move the caller inside of the given Rect
  #
  #@param other (Rect)\n
  #             The Rect to move the caller inside of
  #
  #@post If the caller is wider than the given
  #      Rect, then it has been centered on the
  #      given Rect horizontally. Otherwise, the
  #      caller lies completely within the given
  #      Rect along the X axis\n
  #      If the caller is taller than the given
  #      Rect, the it has been centered on the
  #      given Rect vertically. Otherwise, the
  #      caller lies completely within the given
  #      Rect along the Y axis
  def clampIn(self,other):
    if not self.collideRect(other):
      return None

    if   self.width > other.width:
      self.centerx = other.centerx
    elif self.left < other.left:
      self.left = other.left
    elif self.right > other.right:
      self.right = other.right

    if   self.height > other.height:
      self.centery = other.centery
    elif self.bottom < other.bottom:
      self.bottom = other.bottom
    elif self.top > other.top:
      self.top = other.top


  ##
  #@brief Move the caller completely out of the given Rect
  #
  #@param other (Rect)\n
  #             The Rect to move the caller out of
  #@param dx (number)\n
  #          The direction/speed along the X
  #          axis that the caller should be moving
  #@param dy (number)\n
  #          The direction/speed along the Y
  #          axis that the caller should be moving
  #
  #@post If dx > 0 and the caller's right edge
  #      overlapped the given Rect's left edge,
  #      the caller's right edge is now at the
  #      given Rect's left edge\n
  #      If dx < 0 and the caller's left edge
  #      overlapped the given Rect's right edge,
  #      the caller's left edge is now at the
  #      given Rect's right edge\n
  #      If dy > 0 and the caller's top edge
  #      overlapped the given Rect's bottom
  #      edge, the caller's top edge is now
  #      at the given Rect's bottom edge\n
  #      If dy < 0 and the caller's bottom
  #      edge overlapped the given Rect's
  #      top edge, the caller's bottom edge
  #      is now at the given Rect's top edge
  #
  #\note If abs(dx) > abs(dy), then dy is treated
  #      as if it were given as 0. Otherwise, dx
  #      is treated as if it were given as 0
  #
  def clampOff(self,other,dx,dy):
    if not self.collideRect(other):
      return None

    if abs(dx) > abs(dy):
      dy = 0
    else:
      dx = 0

    if dx > 0 and self.right > other.left:
      self.right = other.left

    if dx < 0 and self.left < other.right:
      self.left = other.right

    if dy > 0 and self.top > other.bottom:
      self.top = other.bottom

    if dy < 0 and self.bottom < other.top:
      self.bottom = other.top




  ##
  #@brief Get the union of the caller and a given Rect
  #
  #@param other (Rect)\n
  #             The Rect to get the union of
  #
  #@return A new Rect that covers the combined area of
  #        other and the caller. This is still a Rect,
  #        so additional area is covered
  def union(self,other):
    far_left   = self.left
    far_right  = self.right
    far_top    = self.top
    far_bottom = self.bottom

    if self.left > other.left:
      far_left = other.left

    if self.right < other.right:
      far_right = other.right

    if self.bottom > other.bottom:
      far_bottom = other.bottom

    if self.top < other.top:
      far_top = other.top

    rect_area = [0,0,0,0]

    rect_area[0] = far_left
    rect_area[1] = far_bottom
    rect_area[2] = far_right - far_left
    rect_area[3] = far_top   - far_bottom

    return Rect(rect_area)



  ##
  #@brief Get the area shared by the caller and a given Rect
  #
  #@param other (Rect)\n
  #             The Rect to intersect the caller with
  #
  #@return If other and the caller intersect, this method
  #        returns a Rect covering the shared area\n
  #        If they do not, then this method returns None
  def intersection(self,other):
    if not self.collideRect(other):
      return None


    near_left   = self.left
    near_top    = self.top
    near_right  = self.right
    near_bottom = self.bottom

    if self.left < other.left:
      near_left = other.left

    if self.right > other.right:
      near_right = other.right

    if self.bottom < other.bottom:
      near_bottom = other.bottom

    if self.top > other.top:
      near_top = other.top

    rect_area = [0,0,0,0]

    rect_area[0] = near_left
    rect_area[1] = near_bottom
    rect_area[2] = near_right - near_left
    rect_area[3] = near_top   - near_bottom

    return Rect(rect_area)