Rectangle Hit Test

def hitTest2(loc1,size1,loc2,size2,output=0):
	if loc1.x+size1.x>=loc2.x and loc1.x<=loc2.x+size2.x:
				if loc1.y+size1.y>=loc2.y and loc1.y<=loc2.y+size2.y:
					output=1
	if output:
		#Calculate origins/centers
		ox1=loc1.x+size1.x/2
		oy1=loc1.y+size1.y/2
		ox2=loc2.x+size2.x/2
		oy2=loc2.y+size2.y/2
		#Difference between origins to locate the direction
		difx=ox1-ox2
		dify=oy1-oy2
		if difx<=0: output1=1#hit from r
		else: output1=2#hit from l
		if dify<=0: output2=1#hit from t
		else: output2=2#hit from b
		#check which is most important
		if dify<0:dify*=-1
		if difx<0:difx*=-1
		if difx>dify: output=output1
		else: output=output2+2
	return output

'''
    Please draw the rectangles to convince
    yourself that the assertions are true.
'''

import numbers

class Vector(list):
    def __str__(self):
        return 'Vector(%s)'%(list.__str__(self))
    def __add__(A,B):
        return Vector(a+b for (a,b,) in zip(A,B,))
    def __sub__(A,B):
        return Vector(a-b for (a,b,) in zip(A,B,))
    def __mul__(A,B):
        if isinstance(B,numbers.Number):
            return Vector(a*B for a in A)
        try:
            return Vector(a*b for (a,b,) in zip(A,B,))
        except:
            raise TypeError('Cannot multiply Vector by %s'%(B.__class__.__name__))

class Rectangle:
    def __init__(self,center,size,**kwargs):
        self.center = center
        self.size = size
        self.__dict__.update(kwargs)
    def min(self):
        return Vector(self.center-self.size*0.5)
    def max(self):
        return Vector(self.center+self.size*0.5)
    def __repr__(self):
        return 'Rectangle(center=%s,size=%s)'%(self.center,self.size)
    def __str__(self):
        if hasattr(self,'name'):
            return str(self.name)
        return __repr__(self)

def V(*args):
    return Vector(args)

def overlap(A,B):             # written for generalized hyperrectangle
    return all(coordinates_of_overlap(A,B))

def coordinates_of_overlap(A,B): # written for generalized hyperrectangle
    An = A.min()
    Ax = A.max()
    Bn = B.min()
    Bx = B.max()
    return list(max(An[i],Bn[i]) <= min(Ax[i],Bx[i]) for i in range(len(An)))

R = Rectangle
A = R(V(0,0.0),V(1.1,2))
B = R(V(1,0.9),V(1.1,2))
C = R(V(7,1.0),V(1.1,2))
D = R(V(0,0.0),V(1.1,2)*0.1,name='enclosed by A')

assert overlap(A,A)
assert overlap(A,B)
assert not overlap(A,C)
assert overlap(A,D)
assert [False, True] == coordinates_of_overlap(A,C)

def hitCorner(loc1,loc2,size2):
	if loc1.x>loc2.x and loc1.x<loc2.x+size2.x:
		if loc1.y>loc2.y and loc1.y<loc2.y+size2.y:
			return True
	
def hitTest2(loc1,size1,loc2,size2,output=0):
	if loc1.x+size1.x>=loc2.x and loc1.x<=loc2.x+size2.x:
				if loc1.y+size1.y>=loc2.y and loc1.y<=loc2.y+size2.y:
					output=1
	if output:
		#Rectangle alert
		if size2.x!=size2.y:
			c1=hitCorner(loc1,loc2,size2)
			c2=hitCorner(Point(loc1.x,loc1.y+size1.y),loc2,size2)
			c3=hitCorner(Point(loc1.x+size1.x,loc1.y+size1.y),loc2,size2)
			c4=hitCorner(Point(loc1.x+size1.x,loc1.y),loc2,size2)
			if c1 and c2: return 2#l
			elif c2 and c3: return 3#t
			elif c3 and c4: return 1#r
			elif c4 and c1: return 4#b
			
		#Calculate origins
		ox1=loc1.x+size1.x/2
		oy1=loc1.y+size1.y/2
		ox2=loc2.x+size2.x/2
		oy2=loc2.y+size2.y/2
		#Difference between origins to locate the direction
		difx=ox1-ox2
		dify=oy1-oy2
		if difx<=0: output1=1#hit from r
		else: output1=2#hit from l
		if dify<=0: output2=1#hit from t
		else: output2=2#hit from b
		#check which is most important
		if dify<0:dify*=-1
		if difx<0:difx*=-1
		if difx>dify: output=output1
		else: output=output2+2
		#output=output2+2
	return output