def __init__(self,world,manager,scrollLoc,screenPos,size,clientID):
        self.world = world
        self.manager = manager
        self.scrollLoc = scrollLoc
        self.cartScrollLoc = specialMath.isoToCart(scrollLoc)
        self.loc = screenPos
        self.size = size
        self.rect = pygame.Rect(screenPos,size)
        self.hud=None
        self.clientID = clientID
        
        if world is not None:
            self.minimap = MiniMap(self.world,clientID=clientID)
            self.worldSize=self.world.grid.getCartGridDimensions()
        else:
            self.minimap = None
        
        #FIXME - SHOULD COME FROM A CONFIG FILE
        self.scrollSensitivity=.001
        
        self.initDeadZoneBasedOnSize()
        self.surface = pygame.Surface(size)
        self.surface.set_clip(((0,0),size))
        self.scrollSpeed = [0,0]

        self.selectedEntities = []
                
        self.viewportEntities = []
        self.myViewportEntities = []
        
        self.quickSelect = {}
        for i in xrange(pygame.K_0,pygame.K_9+1):
            self.quickSelect[i] = pygame.sprite.Group()
        
        self.dragRect = None
        
        self.currentMenu = None
        
        from ContextualMenu import getCGDcontextualMenu
        self.contextualMenu = getCGDcontextualMenu()
        
        self._selectedEntitiesChanged = False
        
        self.gameOver = False
 def changeWorld(self,world):
     self.world = world
     self.minimap = MiniMap(self.world)
     self.worldSize=self.world.grid.getCartGridDimensions()
class Viewport(object):  #SHOULD PROBABLY INHERIT FROM DRAWABLE OBJECT
    """
    Acts as a "window" into the world it contains. Includes deadzone dimensions
    so that it can be scrolled with the mouse.
    
    @param world: the world the viewport can see
    @param scrollLoc: (x,y) #World coordinates of the corner of the viewport
    @param loc: (x,y) #Corner of the viewport in screen coordinates
    @param size: (width,height) #Dimensions in screen coordinates
    @param mouse: the mouse controlling it
    @param deadZoneRect:
    @param selectedEntities:
    @param selector: a selection rectangle that is activated and drawn when necessary #FIXME: NOT YET IMPLEMENTED
    
    @param clientID: identifying string or number given by the server
    when a client is created
    """
    
    def __init__(self,world,manager,scrollLoc,screenPos,size,clientID):
        self.world = world
        self.manager = manager
        self.scrollLoc = scrollLoc
        self.cartScrollLoc = specialMath.isoToCart(scrollLoc)
        self.loc = screenPos
        self.size = size
        self.rect = pygame.Rect(screenPos,size)
        self.hud=None
        self.clientID = clientID
        
        if world is not None:
            self.minimap = MiniMap(self.world,clientID=clientID)
            self.worldSize=self.world.grid.getCartGridDimensions()
        else:
            self.minimap = None
        
        #FIXME - SHOULD COME FROM A CONFIG FILE
        self.scrollSensitivity=.001
        
        self.initDeadZoneBasedOnSize()
        self.surface = pygame.Surface(size)
        self.surface.set_clip(((0,0),size))
        self.scrollSpeed = [0,0]

        self.selectedEntities = []
                
        self.viewportEntities = []
        self.myViewportEntities = []
        
        self.quickSelect = {}
        for i in xrange(pygame.K_0,pygame.K_9+1):
            self.quickSelect[i] = pygame.sprite.Group()
        
        self.dragRect = None
        
        self.currentMenu = None
        
        from ContextualMenu import getCGDcontextualMenu
        self.contextualMenu = getCGDcontextualMenu()
        
        self._selectedEntitiesChanged = False
        
        self.gameOver = False
    
    def setClientID(self,clientID):
        self.clientID = clientID
        self.minimap.setClientID(clientID)
    
    def setGameOver(self):
        self.gameOver = True
        
    def initDeadZoneBasedOnSize(self):
        #CURRENT IMPLEMENTATION IS FAKE
        offset = int(0.3*float(self.size[0]))
        deadZoneSize = (self.size[0]-offset,self.size[1]-offset)
        self.deadZoneRect = pygame.Rect((0, 0), deadZoneSize)
        self.deadZoneRect.center = (self.size[0]/2.0,\
                                    self.size[1]/2.0)

    def setScrollSpeed(self,mousePos):
        deadZoneHeight,deadZoneWidth = self.deadZoneRect.size
        relMousePos = (mousePos[0]-self.loc[0],mousePos[1]-self.loc[1])
        if self.rect.collidepoint(mousePos) and \
            not self.deadZoneRect.collidepoint(relMousePos) and \
            not self.minimap.hasFocus(mousePos):
            dx = (mousePos[0]-self.deadZoneRect.center[0]-self.loc[0])
            dy = (mousePos[1]-self.deadZoneRect.center[1]-self.loc[1])

            self.scrollSpeed[0]=dx*self.scrollSensitivity
            self.scrollSpeed[1]=dy*self.scrollSensitivity
        else:
            self.scrollSpeed = [0,0]
    
    def initiateActionEvent(self,event):
        pos = event.pos

        if self.minimap.rect.collidepoint(pos):
            mapClickPoint = self.minimap.clickToGridPos(pos)
            if mapClickPoint is not None:
                return 
            else:            
                cartPos = specialMath.isoToCart(pos)
                destCart = self.cartScrollLoc[0] + cartPos[0], \
                            self.cartScrollLoc[1] + cartPos[1]
        else:
            cartPos = specialMath.isoToCart(pos)
            destCart = self.cartScrollLoc[0] + cartPos[0], \
                        self.cartScrollLoc[1] + cartPos[1]
        
        clicked = specialMath.closestEntity(self.viewportEntities,pos)
        
        if clicked:
            drawRect = clicked.rect.move(clicked.drawOffset)
            drawRect.center = specialMath.cartToIso(drawRect.center)
        
            if not drawRect.collidepoint(pos):
                clicked = None
        
        if clicked is not None:
            self.currentMenu = self.contextualMenu.getMenu(self.selectedEntities,clicked)
        else:
            self.currentMenu = self.contextualMenu.getMenu(self.selectedEntities,WayPoint(*destCart))
            
        if self.currentMenu is not None:
            self.currentMenu.open(event.pos)
        
    def completeActionEvent(self,event):
        attacking = False
        pos = event.pos
        
        # Performs action indicated by menu if menu is visible
        # and exists.  Otherwise, the menu reference is destroyed.
        if self.currentMenu is not None and self.currentMenu.visible:
            self.selectMenu(pos)
            return # Do not do anything else if the menu is selected
        else:
            self.currentMenu = None
        
        # Sets destination in cartesian coordinates
        # Handles minimap clicks
        if self.minimap.rect.collidepoint(pos):
            mapClickPoint = self.minimap.clickToGridPos(pos)
            if mapClickPoint is not None:
                destCart = mapClickPoint
            else:
                cartPos = specialMath.isoToCart(pos)
                destCart = (self.cartScrollLoc[0] + cartPos[0])%self.worldSize[0], \
                            (self.cartScrollLoc[1] + cartPos[1])%self.worldSize[1]
        else:
            cartPos = specialMath.isoToCart(pos)
            destCart = (self.cartScrollLoc[0] + cartPos[0])%self.worldSize[0], \
                        (self.cartScrollLoc[1] + cartPos[1])%self.worldSize[1]
        
        # Determines closest entity to a click
        clicked = specialMath.closestEntity(self.viewportEntities,pos)
        
        if clicked:
            drawRect = clicked.rect.move(clicked.drawOffset)
            drawRect.center = specialMath.cartToIso(drawRect.center)
        
            if not drawRect.collidepoint(pos):
                clicked = None
        
        # clicked is now either None or the closest Entity to the click
        if clicked:
            for selected in self.selectedEntities:
                attacking=True
                if isinstance(selected,Unit):
                    selected.initAction(clicked)
       
        if not attacking:
            eCenter = specialMath.centerOfEntityList(self.selectedEntities, self.worldSize)
            for entity in self.selectedEntities:
                if not entity.status==Locals.MOVING:
                    entity.dest=entity.realCenter
                if entity.movable: entity.status=Locals.MOVING
                dx = entity.rect.center[0] - eCenter[0]
                dy = entity.rect.center[1] - eCenter[1]
                newLoc = (dx+destCart[0],dy+destCart[1])
                entity.addToPath(newLoc)
  
    def startDrag(self,event):
            self.dragRect = DragBox(event.pos)
        
    def continueDrag(self,event):
        if self.dragRect is not None:
            self.dragRect.update(event.curr)
            if self.dragRect.visible:
                self.drawDragRect()
    
    def completeDrag(self,event):
        if self.dragRect is not None:
            self.dragRect.update(event.curr)
            if self.dragRect.visible:
                self.drawDragRect()
        self.dragSelect(event)
        self.dragRect = None
    
    def drawMiniMap(self):
        if self.minimap is not None:
            self.minimap.update(self.cartPointTupleOfScreen())
            self.minimap.draw(self.surface)
    
    def drawDragRect(self):   
        """
        Draws the drag rectangle from a mouse drag, if not None.
        """
        if not self.dragRect == None:
            self.dragRect.draw(self.surface)
    
    def dragSelect(self,event):
        """
        Fill this in.
        """
        if self.dragRect is not None:
            start = event.start
            end = event.curr
            
            if isinstance(event,Event.DragCompletedEvent):
                for e in self.selectedEntities:
                    e.deselect()
                    self._selectedEntitiesChanged = True
                self.selectedEntities = []
            #else: pass # if it is an Event.AddDragCompletedEvent, do
            # # not deselect
            
            #if self.dragRect.isOffScreen(self.size):
            #    searchList = self.world.allEntities.values()
            #else:
            #    searchList = self.viewportEntities
            searchList = self.myViewportEntities
            
            for entity in searchList:
            
                drawRect = entity.rect.move(entity.drawOffset)
                drawRect.center = specialMath.cartToIso(drawRect.center)
                
                selectRect=entity.getSelectionRect(drawRect)
            
                if selectRect.colliderect(MakeBoundingBox(start,end)):

                    if isinstance(event,Event.DragCompletedEvent):
                        entity.select()
                        self.selectedEntities.append(entity)
                        self._selectedEntitiesChanged = True
                    else: # Add drag completed event
                        if entity not in self.selectedEntities:
                            entity.select()
                            self.selectedEntities.append(entity)
                            self._selectedEntitiesChanged = True
    
    def ownsEntity(self,entity):
        """
        Returns boolean indicating whether or not this client owns the
        provided entity.
        """
        return self.clientID == entity.owner
    
    def clickEvent(self,event):
        """
        What works:
        single - clicking on units
        click on ground to deselect all (without a modifier)
        click a unit while holding a modifier to add to the selection
        click a selected unit while holding a modifier to remove from the selection
        """
        
        pos = event.pos
        
        if self.minimap.rect.collidepoint(pos):
            mapClickPoint = self.minimap.clickToGridPos(pos)
            if mapClickPoint is not None:
                self._setCartScrollLocation(mapClickPoint)
                return
        cartPos = specialMath.isoToCart(pos)
        destCart = (self.cartScrollLoc[0] + cartPos[0])/self.worldSize[0], \
                       (self.cartScrollLoc[1] + cartPos[1])/self.worldSize[1]
        
        # MAY BREAK THINGS - CHECK
        #clicked = specialMath.closestEntity(self.viewportEntities,pos)
        clicked = specialMath.closestEntity(self.myViewportEntities,pos)
        
        if clicked:
            drawRect = clicked.rect.move(clicked.drawOffset)
            drawRect.center = specialMath.cartToIso(drawRect.center)
            
            selectRect=clicked.getSelectionRect(drawRect)
            
            if not selectRect.collidepoint(pos):
                clicked = None
        
        if isinstance(event,Event.SelectionEvent):
            for e in self.selectedEntities:
                e.deselect()

            self.selectedEntities = []
            self._selectedEntitiesChanged = True

        if clicked and self.ownsEntity(clicked):
            # Determines if the closest entity is already selected.
            # If it is, it makes it no longer selected.
            if clicked.selected:
                clicked.deselect()
                self.selectedEntities.remove(clicked)
            else:
                clicked.select()
                self.selectedEntities.append(clicked)
                #print clicked.healthStr()
                #if isinstance(clicked, Unit): print '\n' + str(clicked.inventory)
            self._selectedEntitiesChanged = True
            
    def updateMenu(self,eventPos):
        if self.currentMenu is not None:
            self.currentMenu.update(eventPos)
    
    def selectMenu(self,eventPos):
        if self.currentMenu is not None:
            self.currentMenu.select(eventPos)
        self.currentMenu = None
    
    def drawMenu(self):
        if self.currentMenu is not None:
            self.currentMenu.draw(self.surface)
    
    def mouseMoved(self,event):
        self.setScrollSpeed(event.pos)
        self.updateMenu(event.pos)
    
    def _setCartScrollLocation(self,newCartLoc):
        self.cartScrollLoc = tuple(newCartLoc)
        self.scrollLoc = specialMath.cartToIso(self.cartScrollLoc)
    
    def scrollBasedOnElapsedTime(self,elapsedTime):
        
        if not self.world == None and self.currentMenu == None:# FIXME and self.dragRect == None:
            newScrollLoc = list(self.scrollLoc)
            scrollAddX = self.scrollSpeed[0]*elapsedTime
            scrollAddY = self.scrollSpeed[1]*elapsedTime
            if not self.dragRect == None:
                self.dragRect.scroll((scrollAddX,scrollAddY)) 
            newScrollLoc[0] = (newScrollLoc[0]+scrollAddX)
            newScrollLoc[1] = (newScrollLoc[1]+scrollAddY)
            
            # used to calculate corner of scroll location in cartesian grid
            self.cartScrollLoc = self.isoToWrappedCart(newScrollLoc)
            
            newScrollLoc = specialMath.cartToIso(self.cartScrollLoc)
            self.scrollLoc = tuple(newScrollLoc)
    
    def cartWrap(self,cartCoord):
        gridSizeX,gridSizeY = self.world.gridDim
        return cartCoord[0]%gridSizeX,cartCoord[1]%gridSizeY
    
    def isoToWrappedCart(self,isoCoord):
        """
        Returns a wrapped cartesian coordinate from an isometric
        coordinate.
        """
        return self.cartWrap(specialMath.isoToCart(isoCoord))
    
    def drawContainedEntities(self):
        """
        Draws all elements contained in the current viewport to
        self.surface.
        """
        for e in self.viewportEntities:
            e.draw(self.surface,self.scrollLoc)
  
    def setFocusedEntities(self):
        rawMouseLoc = pygame.mouse.get_pos()
        viewportMouseLoc = rawMouseLoc[0]-self.loc[0],rawMouseLoc[1]-self.loc[1]
        
        for e in self.viewportEntities:
            
            drawRect = e.rect.move(e.drawOffset)
            drawRect.center = specialMath.cartToIso(drawRect.center)
            
            selectRect = e.getSelectionRect(drawRect)
            
            if selectRect.collidepoint(viewportMouseLoc):
                e.focus()
  
    def draw(self,displaySurface):
        """
        Draws the map and all entities for the current world location.
        displaySurface is provided by the screen.
        """

        if not self.world == None:
            
            if not self.gameOver:
                self.setFocusedEntities()
                self.world.grid.draw(self.surface, self.scrollLoc, self.size)
                self.drawContainedEntities()
                self.drawDragRect()
                self.drawMiniMap()
                #self.drawDebugFrames() #Add this in to see the scroll boxes
                self.drawMenu()
                displaySurface.blit(self.surface, (self.loc,self.size))
            else:
                 font=pygame.font.Font(pygame.font.get_default_font(),120)
                 txt=font.render('YOU LOSE.',False,(0,0,0))
                 self.surface.blit(txt,(0,0))

    def processUpdateEvent(self,event):
        timeElapsed = event.elapsedTimeSinceLastFrame
        
        self.setViewportEntities()
        self.postNotification()
        
        # FIXME - NOT EFFICIENT
        for entity in self.world.getDeadEntities():
            if entity in self.selectedEntities:
                try:
                    self.selectedEntities.remove(entity)
                    self._selectedEntitiesChanged = True
                except ValueError: # thrown if entity not in selectedEntity list
                    pass
        
        if self._selectedEntitiesChanged:
            self.manager.post(Event.SelectedEntityEvent(self.selectedEntities))
            self._selectedEntitiesChanged = False
        
        if self.currentMenu is not None and not self.currentMenu.visible:
            self.currentMenu._delayedOpen(timeElapsed)
        
        self.scrollBasedOnElapsedTime(timeElapsed)
        self.world.elapsedTimeSinceLastFrame = timeElapsed
    
    def rectToCartWrappedRects(self,rect):
        isoLeftTop = rect.topleft
        cartLeftTop = self.isoToWrappedCart(isoLeftTop)
    
    def cartPointTupleOfScreen(self):
        """
        Returns a tuple of the Cartesian points of the current view
        into the world.  Order: topleft,topright,bottomright,bottomleft
        """
        l,t = self.cartScrollLoc
            
        w,h = self.size
        cartWidthVector=specialMath.isoToCart((w,0))
        cartHeightVector=specialMath.isoToCart((0,h))
        
        cartTopLeft=l,t
        cartTopRight=l+cartWidthVector[0],t+cartWidthVector[1]
        cartBottomRight=l+cartWidthVector[0]+cartHeightVector[0],t+cartWidthVector[1]+cartHeightVector[1]
        cartBottomLeft=l+cartHeightVector[0],t+cartHeightVector[1]
        
        return cartTopLeft,cartTopRight,cartBottomRight,cartBottomLeft
        
    def setViewportEntities(self):
        if not self.world == None:
            """FIXME to work with new coordinates."""
            
            cartTopLeft,cartTopRight,cartBottomRight,cartBottomLeft = \
                self.cartPointTupleOfScreen()
            
            worldWidth,worldHeight = self.world.grid.getCartGridDimensions()
            screen=[]
            
            #determine which screens to check
            xRange = [0]
            yRange = [0]
            
            if cartBottomLeft[0] >= 0:
                xRange.append(-1)
            if cartTopRight[0] <= worldWidth:
                xRange.append(1)
            
            if cartTopLeft[1] >= 0:
                yRange.append(-1)
            if cartBottomRight[1] <= worldHeight:
                yRange.append(1)
                
            for i in xRange:
                for j in yRange:
                    TL = cartTopLeft[0]+i*worldWidth,cartTopLeft[1]+j*worldHeight
                    TR = cartTopRight[0]+i*worldWidth,cartTopRight[1]+j*worldHeight
                    BR = cartBottomRight[0]+i*worldWidth,cartBottomRight[1]+j*worldHeight
                    BL = cartBottomLeft[0]+i*worldWidth,cartBottomLeft[1]+j*worldHeight
                    
                    screen.append((TL,TR,BR,BL))
            
            self.viewportEntities = self.world.getScreenEntities(screen)
            
            self.myViewportEntities = []
            for entity in self.viewportEntities:
                if self.ownsEntity(entity):
                    self.myViewportEntities.append(entity)
    
    def drawDebugFrames(self):  
        """
        Draws frames on viewport which are useful for debugging.
        Defines the scrolling and non-scrolling regions.
        """
        rect = ((0,0),self.size)
        pygame.draw.rect(self.surface, (255,255,0), rect, 3)
        pygame.draw.rect(self.surface, (255,0,255), self.deadZoneRect, 2)
    
    def setQuickSelect(self,event):
        self.quickSelect[event.key].empty()
        for entity in self.selectedEntities:
            self.quickSelect[event.key].add(entity)
        
    def getQuickSelect(self,event):
        for entity in self.quickSelect[event.key].sprites():
            entity.select()
            if entity not in self.selectedEntities:
                self.selectedEntities.append(entity)
                self._selectedEntitiesChanged = True
    
    def postNotification(self):
        """
        If the world has notifications, post the first 
        notification.
        """

        for i in xrange(len(self.world.notifications)):
            self.manager.post(self.world.notifications.pop(0))    
    
    def changeWorld(self,world):
        self.world = world
        self.minimap = MiniMap(self.world)
        self.worldSize=self.world.grid.getCartGridDimensions()