def handleEvent(self, event):
     if event[0] == soya.sdlconst.QUIT:
         raise Exception
     elif event[0] == soya.sdlconst.MOUSEMOTION:
         if self.rightClicking:
             dx,dz = event[3],event[4] # mouse cursor movement
             self.alpha -= dx*0.02
             self.beta  -= dz*0.02
         elif not self.viewOnly:
             cube2dPositions = []
             for cubeCenter in self.cubeCenters:
                 cube3dPos = soya.Point(self.parent,cubeCenter[0],cubeCenter[1],cubeCenter[2])
                 cube2dPositions.append(self.camera.coord3d_to_2d(cube3dPos))
             cube2dPositions = vstack(cube2dPositions)
             i = argmin(map(norm, \
                         cube2dPositions - array([event[1],event[2]])))
             self.selectedCube = self.cubeToBlk.keys()[i]
             if self.selectedCube != self.previouslySelectedCube:
                 self.updateCursor()
                 self.previouslySelectedCube = self.selectedCube
     elif event[0] == soya.sdlconst.MOUSEBUTTONDOWN:
         if event[1] == soya.sdlconst.BUTTON_WHEELDOWN:
             self.selectedVariant += 1
             self.updateCursor()
         elif event[1] == soya.sdlconst.BUTTON_WHEELUP:
             self.selectedVariant -= 1
             self.updateCursor()
         elif event[1] == soya.sdlconst.BUTTON_RIGHT:
             self.rightClicking = True
         elif event[1] == soya.sdlconst.BUTTON_LEFT and not self.viewOnly:
             raise SelectionPerformed(self.selectedMove)
     elif event[0] == soya.sdlconst.MOUSEBUTTONUP:
         if event[1] == soya.sdlconst.BUTTON_RIGHT:
             self.rightClicking = False
     elif event[0] == soya.sdlconst.KEYDOWN:
         if event[1] == soya.sdlconst.K_LEFT:
             self.alpha += 0.1
         elif event[1] == soya.sdlconst.K_RIGHT:
             self.alpha -= 0.1
         elif event[1] == soya.sdlconst.K_DOWN:
             self.beta -= 0.1
         elif event[1] == soya.sdlconst.K_UP:
             self.beta += 0.1
         elif event[1] == soya.sdlconst.K_PAGEUP:
             self.radius = max(self.radius - 0.5, 0.01)
         elif event[1] == soya.sdlconst.K_PAGEDOWN:
             self.radius = min(self.radius + 0.5, 20.0)
         elif event[1] == soya.sdlconst.K_ESCAPE:
             raise Exception

 def computeAllBlockPlacements(cls, legalMoves):
     cubeToBlk = {} # cube coords -> (blkId, blkVar)
     for coords, blkId, blkVarId in legalMoves:
         for cube in imap(tuple, coords+blockVarWithOrigin(blkId,blkVarId)):
             if not cubeToBlk.has_key(cube):
                 cubeToBlk[cube] = []
             cubeToBlk[cube].append( (coords,blkId,blkVarId) )
     # If their is a cube higher than another, move its entries to the lower cube
     S = reversed(sortCubes2(array(cubeToBlk.keys())))
     lastOne = tuple(next(S))
     try:
         while True:
             nextToLastOne = tuple(next(S))
             # Same xy coordinates ?
             if lastOne[0]==nextToLastOne[0] and lastOne[1]==nextToLastOne[1] :
                 # nextToLastOne has smaller z
                 L = cubeToBlk.pop(lastOne)
                 cubeToBlk[nextToLastOne].extend( L )
             lastOne = nextToLastOne
     except StopIteration:
         pass
     # Compute the center of each cube key in the soya world frame
     cubeCenters = vstack([array([c[0],c[2],c[1]]) for c in cubeToBlk.keys()])
     return cubeToBlk, cubeCenters

def bruteForceTree(gs, root=(None,[]), saveGs=False, depth=2):
    if depth <= 0:
        return root
    knownMoves = []
    if root[0]!=None:
        # Get the next player moves already registered
        # through children nodes
        if len(root[1]) > 0 and root[1][0]['move'] != None:
            knownMoves = vstack(node[0]['move'] for node in root[1])
    # Get the legal moves of the next player
    lm = gs.legalMoves()
    if lm == []:
        lm = [None]
    else:
        # Filter moves that are already known
        lm = [move for move in lm if move not in knownMoves]
    # Add nodes for those which are new
    for move in lm:
        dic = {'player':gs.nextPlayer,'move':move}
        root[1].append( (dic,[]) )
    # Evaluate each move and perform recursion
    for i,node in enumerate(root[1]):
        # Play the move
        move = node[0]['move']
        nextGs = gs.clone().playMove(move)
        if saveGs:
            node[0]['gs'] = nextGs
        # Evaluate the scores
        node[0]['baseScores'] = nextGs.baseScores()
        node[0]['penalty'] = nextGs.penalty()
        # Recursion
        nextGs.bruteForceTree(root=node,saveGs=saveGs,depth=depth-1)
        # DEBUG
        if depth==2:
            print "done node %d/%d" % (i,len(root[1]))
    return root

 def test_2D_array2(self):
     a = array([1,2]); b = array([1,2]);
     res=vstack([a,b])
     desired = array([[1,2],[1,2]])
     assert_array_equal(res,desired)

 def test_1D_array(self):
     a = array([1]); b = array([2]);
     res=vstack([a,b])
     desired = array([[1],[2]])
     assert_array_equal(res,desired)

 def test_2D_array(self):
     a = array([[1], [2]])
     b = array([[1], [2]])
     res = vstack([a, b])
     desired = array([[1], [2], [1], [2]])
     assert_array_equal(res, desired)

 def test_generator(self):
     with assert_warns(FutureWarning):
         vstack((np.arange(3) for _ in range(2)))