pygameview.py

#! /usr/bin/env python

import sys
import time
import string

import pygame
import pygame.sprite
from pygame.locals import * #the KeyboardController needs these

import events
import catan
import mapmodel
import textrect
from mapmodel import walk_corners_along_tile
from pygame_utils import *
from pygame_trade import TradeDisplay, TradeButton
from pygame_discard import DiscardDisplay
from pygame_choosevictim import ChooseVictimDisplay
from pygame_yearofplenty import ChooseTwoCardsDisplay
from pygame_monopoly import MonopolyDisplay

tileGroup = pygame.sprite.RenderUpdates()
tileModelToSprite = {}
cornerGroup = pygame.sprite.RenderUpdates()
cornerModelToSprite = {}
edgeGroup = pygame.sprite.RenderUpdates()
edgeModelToSprite = {}
portGroup = pygame.sprite.RenderUpdates()
hudGroup = pygame.sprite.RenderUpdates()

#------------------------------------------------------------------------------
class HudObject(object):
    def __init__(self, *args):
        hudGroup.add(self)
        events.registerListener(self)

#------------------------------------------------------------------------------
class TextButton(SimpleTextButton, HudObject):
    def __init__(self, *args):
        SimpleTextButton.__init__(self, *args)
        HudObject.__init__(self)

#------------------------------------------------------------------------------
class HudTradeButton(TradeButton, HudObject):
    def __init__(self, *args):
        TradeButton.__init__(self, *args)
        HudObject.__init__(self)
    
#------------------------------------------------------------------------------
class CPUSpinnerController:
    def __init__(self):
        events.registerListener( self )
        self.keepGoing = 1

    def run(self):
        while self.keepGoing:
            events.post(events.Tick())

    def onQuit(self):
        #this will stop the while loop from running
        self.keepGoing = False

#------------------------------------------------------------------------------
class KeyboardController:
    """KeyboardController takes Pygame events generated by the
    keyboard and uses them to control the model, by sending Requests
    or to control the Pygame display directly, as with the QuitEvent
    """
    def __init__(self, playerName=None):
        '''playerName is an optional argument; when given, this
        keyboardController will control only the specified player
        '''
        events.registerListener( self )

        self.activePlayer = None
        self.playerName = playerName
        self.players = []

    def onTick(self):
        #Handle Input Events
        for event in pygame.event.get():
            ev = None
            if event.type == QUIT:
                ev = events.Quit()
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    # Hit Shift-ESC or Ctrl-ESC to go to the debugger
                    # otherwise ESC will quit the game
                    if event.mod and (
                       event.mod & KMOD_SHIFT or event.mod & KMOD_CTRL):
                        print 'event mod', event.mod
                        import pdb
                        pdb.set_trace()
                    else:
                        ev = events.Quit()
                else:
                    ev = ('KeyDown', event.key, event.unicode, event.mod)
            elif event.type == MOUSEBUTTONDOWN:
                if event.button == 1:
                    events.post('MouseLeftDown', pos=event.pos)
            elif event.type == MOUSEBUTTONUP:
                if event.button == 1:
                    events.post('MouseLeftUp', pos=event.pos)
            elif event.type == MOUSEMOTION:
                events.post('MouseMotion', pos=event.pos, buttons=event.buttons)
            if ev:
                if isinstance(ev, tuple):
                    events.post( *ev )
                else:
                    events.post( ev )


#------------------------------------------------------------------------------
class EndTurnButton(TextButton):
    def __init__(self):
        TextButton.__init__(self, (150,50), 'END TURN')

    #----------------------------------------------------------------------
    def onMouseLeftDown(self, pos):
        if self.rect.collidepoint(pos):
            events.post('TurnFinishRequest', humanPlayer)


#------------------------------------------------------------------------------
class SaveGameButton(TextButton):
    def __init__(self):
        TextButton.__init__(self, (150,50), 'SAVE GAME')

    #----------------------------------------------------------------------
    def onMouseLeftDown(self, pos):
        if self.rect.collidepoint(pos):
            print '        SAVED   **************'
            import saved_game
            saved_game.save()


#------------------------------------------------------------------------------
class Console(EasySprite):
    def __init__(self):
        EasySprite.__init__(self)
        events.registerListener(self)
        self.image = EasySurface( (300,80) )
        self.rect = self.image.get_rect()

        self.outText = dict(text='...console output...', color=green )
        self.inText = dict(text='|', color=green )

        self.drawBg()
        self.drawText()

        hudGroup.add(self)
        self.dirty = True

    #----------------------------------------------------------------------
    def drawBg(self):
        bg = self.image.copy()
        r = self.rect.move(0,0)
        r.topleft = 0,0
        pygame.draw.rect(bg, green, r, 2)

        r.y = r.height/2
        r.height = r.height/2
        pygame.draw.rect(bg, green, r, 1)

        self.image.blit(bg, (0,0))

    #----------------------------------------------------------------------
    def drawText(self):
        r = self.rect.move(0,0)
        r.topleft = 0,0
        halfY = r.height/2
        #r.topleft = 2,2
        r.height = halfY
        r.inflate_ip(-4,-4)
        #print 'rendering', self.outText, 'on', r
        txtImg = textrect.render_textrect(rect=r,**self.outText)
        self.image.blit(txtImg, r)

        r.y = halfY + 2
        txtImg = font_render(**self.inText)
        self.image.blit(txtImg, r)

    #----------------------------------------------------------------------
    def update(self):
        self.image.fill(black)
        self.drawBg()
        self.drawText()

    #----------------------------------------------------------------------
    def onKeyDown(self, keycode, keyletter, mods):
        if keycode == K_BACKSPACE:
            self.inText['text'] = self.inText['text'][:-2] +'|'
        elif keycode == K_RETURN:
            statement = self.inText['text'][:-1]
            self.inText['text'] = '|'
            try:
                exec statement
            except Exception, ex:
                out = str(ex)
                self.outText['text'] = out
        elif keyletter in string.printable:
            self.inText['text'] = self.inText['text'][:-1] + keyletter +'|'
        
    #----------------------------------------------------------------------
    def notify(self, event):
        if isinstance(event, events.Tick):
            return
        text = self.outText['text']
        lines = text.split('\n')
        self.outText['text'] = '\n'.join([lines[-1], str(event)]) #last 2 items

#------------------------------------------------------------------------------
class DiceButton(EasySprite, Highlightable):
    def __init__(self):
        EasySprite.__init__(self)
        Highlightable.__init__(self)
        events.registerListener(self)
        self.image = EasySurface( (150,100) )
        self.rect = self.image.get_rect()

        self.diceText1 = dict(text='*', size=30, color=(255,0,0) )
        self.diceText2 = dict(text='*', size=30, color=(255,0,0) )

        self.drawBg()
        self.drawText()

        hudGroup.add(self)

    #----------------------------------------------------------------------
    def drawBg(self):
        bg = EasySurface( (150,100) )
        r = self.rect.move(0,0)
        r.topleft = 0,0
        pygame.draw.rect(bg, blue, r, 2)
        r.size = 60,60
        r.topleft = 8,8
        pygame.draw.rect(bg, blue, r, 1)
        r.topright = 142,8
        pygame.draw.rect(bg, blue, r, 1)
        self.image.blit(bg, (0,0))

    #----------------------------------------------------------------------
    def drawText(self):
        r = self.rect.move(0,0)

        if self.hoverlighted:
            color = white
        elif self.hintlighted:
            color = (255,100,100)
        else:
            color = red
        r.topleft = 0,35
        txtImg = font_render('ROLL', color=color)
        blit_at_center(self.image, txtImg, rect1=r)

        r.size = 50,50
        r.topleft = 12,12
        txtImg = font_render(**self.diceText1)
        self.image.blit(txtImg, r)

        r.topleft = 92,12
        txtImg = font_render(**self.diceText2)
        self.image.blit(txtImg, r)

    #----------------------------------------------------------------------
    def update(self):
        if catan.game.state.stage == catan.Stages.preRoll:
            self.hintlighted = True
        else:
            self.hintlighted = False
        self.image.fill(black)
        self.drawBg()
        self.drawText()
        self.dirty = False

    #----------------------------------------------------------------------
    def onDiceRoll(self, d1, d2):
        self.diceText1['text'] = str(d1)
        self.diceText2['text'] = str(d2)

    #----------------------------------------------------------------------
    def onMouseMotion(self, pos, buttons):
        self.checkHover(pos)

    #----------------------------------------------------------------------
    def onMouseLeftDown(self, pos):
        if self.rect.collidepoint(pos):
            events.post('DiceRollRequest', humanPlayer)

#------------------------------------------------------------------------------
class UseCardButton(EasySprite, Highlightable):
    def __init__(self, victoryCardClass):
        EasySprite.__init__(self)
        Highlightable.__init__(self)
        events.registerListener(self)
        self.image = EasySurface( (50,50) )
        self.rect = self.image.get_rect()
        hudGroup.add(self)

        self.victoryCardClass = victoryCardClass

        self.draw()

    #----------------------------------------------------------------------
    def update(self):
        if not self.dirty:
            return
        self.calculateHintlight()
        self.draw()

    #----------------------------------------------------------------------
    def draw(self):
        self.image.fill(black)
        r = self.rect.move(-self.x, -self.y)
        pygame.draw.rect(self.image, blue, r, 2)

        if self.hoverlighted:
            color = white
        elif self.hintlighted:
            color = (255,100,100)
        else:
            color = red
        txt = self.victoryCardClass.__name__[0]
        txtImg = font_render(txt, color=color, size=30)
        blit_at_center(self.image, txtImg)

        if humanPlayer:
            card = humanPlayer.getVictoryCardOfClass(self.victoryCardClass)
            if card:
                cardImg = victoryCard_img(card)
                self.image.blit(cardImg, (5,10))

        self.dirty = False

    #----------------------------------------------------------------------
    def onMouseMotion(self, pos, buttons):
        self.checkHover(pos)

    #----------------------------------------------------------------------
    def onMouseLeftDown(self, pos):
        if self.rect.collidepoint(pos):
            events.post('PlayVictoryCardRequest', humanPlayer,
                        self.victoryCardClass)

    #----------------------------------------------------------------------
    def onStageChange(self, *args):
        self.dirty = True

    #----------------------------------------------------------------------
    def calculateHintlight(self):
        if (catan.game.state.stage in (catan.Stages.preRoll,
                                      catan.Stages.playerTurn)
            and humanPlayer.getVictoryCardOfClass(self.victoryCardClass)):
            self.hintlighted = True
        else:
            self.hintlighted = False

#------------------------------------------------------------------------------
class SoldierButton(UseCardButton):
    def __init__(self):
        UseCardButton.__init__(self, catan.Soldier)

#------------------------------------------------------------------------------
class YearOfPlentyButton(UseCardButton):
    def __init__(self):
        UseCardButton.__init__(self, catan.YearOfPlenty)

    #----------------------------------------------------------------------
    def onChooseTwoCards(self, *args):
        self.dirty = True

#------------------------------------------------------------------------------
class MonopolyButton(UseCardButton):
    def __init__(self):
        UseCardButton.__init__(self, catan.Monopoly)

    #----------------------------------------------------------------------
    def onMonopoly(self, *args):
        self.dirty = True


#------------------------------------------------------------------------------
class BuyButton(EasySprite, Highlightable):
    def __init__(self, itemClass, text):
        EasySprite.__init__(self)
        Highlightable.__init__(self)
        events.registerListener(self)
        self.image = EasySurface( (50,50) )
        self.rect = self.image.get_rect()
        hudGroup.add(self)

        self.text = text

        self.itemClass = itemClass

        self.draw()

    #----------------------------------------------------------------------
    def update(self):
        if not self.dirty:
            return
        self.calculateHintlight()
        self.draw()

    #----------------------------------------------------------------------
    def draw(self):
        self.image.fill(black)
        r = self.rect.move(-self.x, -self.y)
        pygame.draw.rect(self.image, blue, r, 2)

        if self.hoverlighted:
            color = white
        elif self.hintlighted:
            color = (255,100,100)
        else:
            color = red
        txtImg = font_render(self.text, color=color, size=30)
        blit_at_center(self.image, txtImg)

        self.dirty = False

    #----------------------------------------------------------------------
    def onMouseMotion(self, pos, buttons):
        self.checkHover(pos)

    #----------------------------------------------------------------------
    def onMouseLeftDown(self, pos):
        if self.rect.collidepoint(pos):
            events.post('BuyRequest', humanPlayer, self.itemClass)

    #----------------------------------------------------------------------
    def calculateHintlight(self):
        item = self.itemClass()
        if not humanPlayer.neededCardClasses(item):
            self.hintlighted = True
        else:
            self.hintlighted = False

    #----------------------------------------------------------------------
    def onRob(self, thief, victim, card):
        if humanPlayer in [thief, victim]:
            self.dirty = True

    #----------------------------------------------------------------------
    def onDiscard(self, player):
        if player == humanPlayer:
            self.dirty = True
        
    #----------------------------------------------------------------------
    def onHarvest(self, cards, sourceTile, recipient):
        if recipient == humanPlayer:
            self.dirty = True

    #----------------------------------------------------------------------
    def onPlayerPlacing(self, *args):
        self.dirty = True

    #----------------------------------------------------------------------
    def onPlayerDrewVictoryCard(self, *args):
        self.dirty = True


#------------------------------------------------------------------------------
class BuySettlementButton(BuyButton):
    def __init__(self):
        BuyButton.__init__(self, catan.Settlement, 'S')

#------------------------------------------------------------------------------
class BuyRoadButton(BuyButton):
    def __init__(self):
        BuyButton.__init__(self, catan.Road, 'R')

#------------------------------------------------------------------------------
class BuyCityButton(BuyButton):
    def __init__(self):
        BuyButton.__init__(self, catan.City, 'C')

#------------------------------------------------------------------------------
class BuyVictoryCardButton(BuyButton):
    def __init__(self):
        BuyButton.__init__(self, catan.VictoryCard, 'V')

#------------------------------------------------------------------------------
class ItemSprite(EasySprite):
    def __init__(self, itemLetter, thing):
        self.thing = thing
        self.image = font_render(itemLetter, color=thing.owner.color)

#------------------------------------------------------------------------------
class SettlementSprite(ItemSprite):
    def __init__(self, settlement):
        ItemSprite.__init__(self, 'S', settlement)

#------------------------------------------------------------------------------
class CitySprite(ItemSprite):
    def __init__(self, city):
        ItemSprite.__init__(self, 'C', city)

#------------------------------------------------------------------------------
class RoadSprite(ItemSprite):
    def __init__(self, road):
        ItemSprite.__init__(self, 'R', road)


#------------------------------------------------------------------------------
class Tile(EasySprite, Highlightable):
    def __init__(self, tile):
        EasySprite.__init__(self)
        Highlightable.__init__(self)
        events.registerListener(self)

        self.image = EasySurface( (100,100) )
        self.rect = self.image.get_rect()
        r = self.rect

        text = tile.name
        textImg = font_render(text)
        self.image.blit( textImg, r.center )

        self.tile = tile
        self.calcCornerPositions()

        tileGroup.add(self)
        tileModelToSprite[tile] = self

    def collides(self, point):
        if not self.rect.collidepoint(point):
            return False
        # TODO: make this return true when the point is inside the hexagon
        return True

    def calcCornerPositions(self):
        r = self.rect
        We = r.midleft
        NW = (r.width/3, r.top)
        NE = (2*r.width/3, r.top)
        Ea = r.midright
        SE = (2*r.width/3, r.bottom)
        SW = (r.width/3, r.bottom)
        if self.tile.name == 't01':
            self.cornerPositions = [ NW, We, NE, SW, Ea, SE ]
        elif self.tile.name in ['t02','t10']:
            self.cornerPositions = [ Ea, SE, NE, SW, NW, We ]
        elif self.tile.name in ['t03', 't12']:
            self.cornerPositions = [ SW, SE, We, Ea, NW, NE ]
        elif self.tile.name in ['t04', 't14']:
            self.cornerPositions = [ NE, Ea, NW, SE, We, SW ]
        elif self.tile.name in ['t05', 't16']:
            self.cornerPositions = [ We, SW, NW, SE, NE, Ea ]
        elif self.tile.name in ['t06', 't18']:
            self.cornerPositions = [ NW, NE, We, Ea, SW, SE ]
        elif self.tile.name in ['t07', 't17', 't19']:
            self.cornerPositions = [ NW, We, NE, SW, Ea, SE ]
        elif self.tile.name in ['t08']:
            self.cornerPositions = [ SE, SW, Ea, We, NE, NW ]
        elif self.tile.name in ['t09']:
            self.cornerPositions = [ Ea, NE, SE, NW, SW, We ]
        elif self.tile.name in ['t11']:
            self.cornerPositions = [ SW, We, SE, NW, Ea, NE ]
        elif self.tile.name in ['t13']:
            self.cornerPositions = [ NE, NW, Ea, We, SE, SW ]
        elif self.tile.name in ['t15']:
            self.cornerPositions = [ We, NW, SW, NE, SE, Ea ]
        else:
            raise Exception('unknown tile')

    def update(self):
        if not self.dirty:
            return

        r = self.rect.move((0,0))
        r.topleft = 0,0

        # draw the terrain color
        terrain = self.tile.terrain
        if terrain:
            color = terrain_colors[terrain.__class__]
            pygame.draw.circle(self.image, color, r.center, r.width/2)
            if self.hintlighted:
                color2 = [float(x)/280*255 for x in color]
                radius2 = r.width/2 - 10
                pygame.draw.circle(self.image, color2, r.center, radius2)

        # draw the tile name
        #text = self.tile.name
        #textImg = font_render(text, color=(0,0,0, 18))
        #self.image.blit(textImg, vect_add(r.midtop,(0,20)))

        # draw the pip
        if self.tile.pip:
            size = 30 - 2*abs(7 - self.tile.pip.value)
            textImg = font_render(str(self.tile.pip.value), size=size)
            blit_at_center(self.image, textImg)

        # draw the robber
        if self.tile.robber:
            textImg = font_render('X', color=black, size=36)
            blit_at_center(self.image, textImg)

        #self.debug_draw()

        self.dirty = False

    def debug_draw(self):
        for i, c in enumerate(self.tile.corners):
            corner = cornerModelToSprite[c]
            r = corner.rect.move((0,0))
            r.center = self.cornerPositions[i]
            r.clamp_ip(self.image.get_rect())
            self.image.blit(corner.image, r.topleft)
        for i, e in enumerate(self.tile.edges):
            text = e.name
            textImg = font_render(text, size=15, color=blue)
            if len(e.corners) == 2:
                c1, c2 = e.corners
                corner = cornerModelToSprite[c1]
                pos1 = corner.rect.center
                corner = cornerModelToSprite[c2]
                pos2 = corner.rect.center
                pygame.draw.aaline(self.image, blue, pos1, pos2)
                r = pygame.Rect(pos1[0], pos1[1],
                                (pos2[0] - pos1[0]), (pos2[1] - pos1[1]))
                self.image.blit(textImg, r.center)
            else:
                self.image.blit(textImg, (40,14*i))

    def onHintLightTiles(self, tiles):
        if self.tile in tiles:
            self.hintlighted = True

    def onRobberPlaced(self, *args):
        self.hintlighted = False

    def onMouseLeftDown(self, pos):
        if self.hintlighted and self.collides(pos):
            # TODO: there is a bug here.
            # If the user interface sends two TileClicked events immediately
            # after another (such as if the user clicks on an overlap), the
            # event manager will get two of these and place the robber twice
            # consider making a special queue for UI events like clicks
            events.post('TileClicked', self.tile)
                

#------------------------------------------------------------------------------
class Port(EasySprite, Highlightable):
    def __init__(self, port):
        EasySprite.__init__(self)
        Highlightable.__init__(self)
        events.registerListener(self)

        self.image = EasySurface( (20,20) )
        self.rect = self.image.get_rect()
        self.port = port

        self.drawBg()

        portGroup.add(self)

    def drawBg(self):
        if self.hoverlighted:
            bgcolor = (255,255,0, 250)
        elif self.hintlighted:
            bgcolor = (255,128,0, 200)
        else:
            bgcolor = (255,128,0, 128)
        self.image.fill( bgcolor )
        text = str(self.port[1])
        if self.port[0]:
            text += self.port[0].__name__[:2]
        textImg = font_render(text, size=18, color=(5,0,0))
        self.image.blit( textImg, (0,0) )

    def update(self):
        if not self.dirty:
            return

        self.drawBg()

        print mapmodel.portsToCorners
        c1, c2 = mapmodel.portsToCorners[self.port]
        cSprite1 = cornerModelToSprite[c1]
        cSprite2 = cornerModelToSprite[c2]

        lenVect = vect_diff(cSprite1.center, cSprite2.center)
        lenVect = vect_scal_mult(lenVect, .5)
        midpoint = vect_diff(cSprite1.center, lenVect)
        self.rect.center = midpoint

        self.dirty = False


#------------------------------------------------------------------------------
class Corner(EasySprite, Highlightable):
    def __init__(self, corner):
        #print 'making corner', corner.name
        EasySprite.__init__(self)
        Highlightable.__init__(self)
        events.registerListener(self)

        self.image = EasySurface( (22,22) )
        self.rect = self.image.get_rect()
        self.corner = corner

        self.drawBg()

        cornerGroup.add(self)
        cornerModelToSprite[corner] = self

    def drawBg(self):
        if self.hoverlighted:
            bgcolor = (0,255,28, 250)
        elif self.hintlighted:
            bgcolor = (0,255,28, 200)
        else:
            bgcolor = (0,255,28, 128)
        self.image.fill( bgcolor )
        text = self.corner.name
        textImg = font_render(text, size=15, color=(5,0,0))
        self.image.blit( textImg, (0,0) )
        if self.hintlighted:
            pygame.draw.rect(self.image, white, self.image.get_rect(), 1)

    def update(self):
        if not self.dirty:
            return

        for e in self.corner.edges:
            eSprite = edgeModelToSprite.get(e)
            if eSprite:
                eSprite.dirty = True

        self.drawBg()

        if self.corner.stuff:
            thing = self.corner.stuff[0]
            if isinstance(thing, catan.Settlement):
                txtImg = SettlementSprite(thing).image
            if isinstance(thing, catan.City):
                txtImg = CitySprite(thing).image
            self.image.blit( txtImg, (8,8) )

        self.move_to_absolute_position()
        self.dirty = False

    def move_to_absolute_position(self):
        corner = self.corner
        tile = corner.tiles[0]
        idx = tile.corners.index(self.corner)
        tSprite = tileModelToSprite[tile]
        rel_pos = tSprite.cornerPositions[idx]
        abs_pos = vect_add(tSprite.topleft, rel_pos)
        self.topleft = (abs_pos)

    def onItemPlaced(self, item):
        if self.hoverlighted:
            self.hoverlighted = False
        if self.hintlighted:
            self.hintlighted = False
        if item.location == self.corner:
            self.dirty = True

    def onRobberPlaced(self, *args):
        self.dirty = True

    def onHintLightCorners(self, corners):
        if self.corner in corners:
            self.hintlighted = True

    def onMouseMotion(self, pos, buttons):
        if self.hintlighted:
            if self.rect.collidepoint(pos):
                self.hoverlighted = True
            else:
                self.hoverlighted = False
        
    def onMouseLeftDown(self, pos):
        if self.hoverlighted:
            if self.rect.collidepoint(pos):
                events.post('ClickCorner', self.corner)

                
#------------------------------------------------------------------------------
class Edge(EasySprite, Highlightable):
    def __init__(self, edge):
        #print 'making edge', edge.name
        EasySprite.__init__(self)
        Highlightable.__init__(self)
        events.registerListener(self)

        self.edge = edge

        edgeGroup.add(self)
        edgeModelToSprite[edge] = self

        if len(self.edge.corners) != 2:
            print '??'
            return

        c1, c2 = self.edge.corners
        cSprite = cornerModelToSprite[c1]
        r1 = cSprite.rect
        r1_point = pygame.Rect(r1.center,(1,1))
        cSprite = cornerModelToSprite[c2]
        r2 = cSprite.rect
        r2_point = pygame.Rect(r2.center,(1,1))

        self.rect = r1.union(r2)

        norm_rect = self.rect.move(0,0)
        norm_rect.normalize()
        self.image = EasySurface(self.rect)
        self.image.fill(blue)

    def update(self):
        if not self.dirty:
            return

        c1, c2 = self.edge.corners

        c1Sprite = cornerModelToSprite[c1]
        r1 = c1Sprite.rect
        r1_point = pygame.Rect(r1.center,(1,1))

        c2Sprite = cornerModelToSprite[c2]
        r2 = c2Sprite.rect
        r2_point = pygame.Rect(r2.center,(1,1))

        self.rect = r1.union(r2)

        norm_rect = self.rect.move(0,0)
        norm_rect.normalize()
        self.image = EasySurface(self.rect)

        if self.hoverlighted:
            color = (100,100,255, 255)
        elif self.hintlighted:
            color = (0,0,255, 255)
        else:
            color = (0,0,200, 255)

        #print 'drawing edge from, to', c1Sprite.center, c2Sprite.center
        point1 = vect_diff(c1Sprite.center, self.rect.topleft)
        point2 = vect_diff(c2Sprite.center, self.rect.topleft)
        pygame.draw.aaline(self.image, color, point1, point2)
        if self.hintlighted or self.hoverlighted:
            pygame.draw.circle(self.image, white, point1, 3)
            pygame.draw.circle(self.image, white, point2, 3)

        if self.edge.stuff:
            item = self.edge.stuff[0]
            txtImg = RoadSprite(item).image
            self.image.blit( txtImg, vect_diff(self.rect.center, self.rect.topleft))

        self.dirty = False

    def onItemPlaced(self, item):
        if self.hintlighted or self.hoverlighted:
            self.hintlighted = False
            self.hoverlighted = False
        if item.location == self.edge:
            self.dirty = True

    def onHintLightEdges(self, edges):
        if self.edge in edges:
            self.hintlighted = True

    def onRobberPlaced(self, *args):
        self.dirty = True

    def onMouseMotion(self, pos, buttons):
        if self.hintlighted:
            if self.rect.collidepoint(pos):
                self.hoverlighted = True
            else:
                self.hoverlighted = False
        
    def onMouseLeftDown(self, pos):
        if self.hoverlighted:
            if self.rect.collidepoint(pos):
                events.post('ClickEdge', self.edge)

#------------------------------------------------------------------------------
class PygameView:
    def __init__(self):
        events.registerListener( self )

        pygame.init()
        self.window = pygame.display.set_mode( (800,740) )
        pygame.display.set_caption( 'TITLE HERE' )

        self.background = pygame.Surface( self.window.get_size() )
        self.background.fill(black)

        self.window.blit( self.background, (0,0) )
        pygame.display.flip()

        self.opponentDisplayPositions = [ (0,5), (100,0), (200,5) ]

        self.showRobberCursor = False

        self.showHud()


    #----------------------------------------------------------------------
    def refresh(self):
        self.opponentDisplayPositions = [ (0,5), (100,0), (200,5) ]

    #----------------------------------------------------------------------
    def showHud(self):
        sbutton = SoldierButton()
        sbutton.topleft = 600, 100

        sbutton = YearOfPlentyButton()
        sbutton.topleft = 660, 100

        mbutton = MonopolyButton()
        mbutton.topleft = 720, 100

        vbutton = BuyVictoryCardButton()
        vbutton.topleft = 600, 160

        sbutton = BuySettlementButton()
        sbutton.topleft = 600, 220
        rbutton = BuyRoadButton()
        rbutton.topleft = 660, 220
        cbutton = BuyCityButton()
        cbutton.topleft = 720, 220

        dbutton = DiceButton()
        dbutton.topleft = 600, 300
        ebutton = EndTurnButton()
        ebutton.topleft = 600, 440

        tbutton = HudTradeButton()
        tbutton.topleft = 600, 520
        
        sbutton = SaveGameButton()
        sbutton.topleft = 600, 600

        console = Console()
        console.topleft = 10, 640

    #----------------------------------------------------------------------
    def showMap(self, board):
        # clear the screen first
        self.background.fill(black)
        self.window.blit( self.background, (0,0) )
        pygame.display.flip()

        center = self.window.get_rect().center

        row = 0
        column = 0
        tiles = board.tiles[:] # copy
        while tiles:
            t = tiles.pop(0)
            tSprite = Tile(t)
            x = 300 + tSprite.tile.graphicalPosition[0]*75
            # minus because pygame uses less = up in the y dimension
            y = 300 - tSprite.tile.graphicalPosition[1]*55
            tSprite.rect.move_ip(x,y)
        for c in mapmodel.allCorners:
            corner = Corner(c)
        for e in mapmodel.allEdges:
            eSprite = Edge(e)
        for p in mapmodel.portsToCorners.keys():
            pSprite = Port(p)
            
    #----------------------------------------------------------------------
    def drawCursor(self):
        if not self.showRobberCursor:
            return []
        pos = pygame.mouse.get_pos()
        textImg = font_render('X', color=white, size=36)
        self.window.blit( textImg, vect_diff(pos, (-2,-2)) )
        textImg = font_render('X', color=black, size=36)
        self.window.blit( textImg, pos )
        return [textImg.get_rect().move(pos)]

    #----------------------------------------------------------------------
    def draw(self):
        self.window.blit( self.background, (0,0) )

        for tSprite in tileGroup:
            tSprite.update()
        dirtyRects = tileGroup.draw( self.window )

        for cSprite in cornerGroup:
            cSprite.update()
        dirtyRects = cornerGroup.draw( self.window )

        for pSprite in portGroup:
            pSprite.update()
        dirtyRects = portGroup.draw( self.window )

        for eSprite in edgeGroup:
            eSprite.update()
        dirtyRects = edgeGroup.draw( self.window )

        for hudSprite in hudGroup:
            #print 'calling update on ', hudSprite
            hudSprite.update()
        dirtyRects = hudGroup.draw( self.window )

        dirtyRects += self.drawCursor()

        pygame.display.flip()
        time.sleep(1)

    #----------------------------------------------------------------------
    def onShowRobberCursor(self, player):
        if player != humanPlayer:
            # show some alert that the active player is placing the robber
            return
        self.showRobberCursor = True
        for tSprite in tileGroup:
            tSprite.hintlighted = True

    #----------------------------------------------------------------------
    def onTileClicked(self, tile):
        if self.showRobberCursor:
            events.post('RobberPlaceRequest', humanPlayer, tile)

    #----------------------------------------------------------------------
    def onRobberPlaced(self, *args):
        self.showRobberCursor = False

    #----------------------------------------------------------------------
    def onShowChooseVictim(self, player, opponents):
        if player != humanPlayer:
            # show some alert that the active player is choosing a victim
            return
        cdisplay = ChooseVictimDisplay(player, opponents)
        # cdisplay will kill itself on the RobRequest event
        cdisplay.add(hudGroup)
        cdisplay.center = self.window.get_rect().center

    #----------------------------------------------------------------------
    def onShowDiscard(self, player):
        if player != humanPlayer:
            # show some alert that the active player is discarding
            return
        ddisplay = DiscardDisplay(player)
        ddisplay.add(hudGroup)
        ddisplay.center = self.window.get_rect().center

    #----------------------------------------------------------------------
    def onShowTrade(self):
        tdisplay = TradeDisplay(humanPlayer)
        # tdisplay will kill itself on the HideTrade event
        tdisplay.add(hudGroup)
        tdisplay.center = self.window.get_rect().center

    #----------------------------------------------------------------------
    def onShowPlayerChooseTwoCards(self, player):
        if player != humanPlayer:
            # show some alert that the active player is choosing 2 cards
            return
        cdisplay = ChooseTwoCardsDisplay(player)
        cdisplay.add(hudGroup)
        cdisplay.center = self.window.get_rect().center

    #----------------------------------------------------------------------
    def onShowMonopoly(self, player):
        if player != humanPlayer:
            # show some alert that the active player is playing Monopoly
            return
        mdisplay = MonopolyDisplay(player)
        mdisplay.add(hudGroup)
        mdisplay.center = self.window.get_rect().center


    #----------------------------------------------------------------------
    def onBoardCreated(self, board):
        self.showMap(board)

    #----------------------------------------------------------------------
    def onRefreshState(self):
        self.refresh()
        self.showMap(catan.game.board)
        for player in catan.game.players:
            playerDisplay = PlayerDisplay(player)
            if isinstance(player, catan.HumanPlayer):
                playerDisplay.topleft = 350, 660
            else:
                # CPU Player
                pos = self.opponentDisplayPositions.pop(0)
                playerDisplay.topleft = pos

    #----------------------------------------------------------------------
    def onPlayerJoin(self, player):
        playerDisplay = PlayerDisplay(player)
        if isinstance(player, catan.HumanPlayer):
            playerDisplay.topleft = 350, 660
        else:
            # CPU Player
            pos = self.opponentDisplayPositions.pop(0)
            playerDisplay.topleft = pos

    #----------------------------------------------------------------------
    def onTick(self):
        self.draw()

#------------------------------------------------------------------------------
class BoardDisplay(object):
    def __init__(self, board):
        self.board = board
        self.tiles = []
        for t in self.board.tiles:
            tSprite = Tile(t)
            self.tiles.append(tSprite)

    def align_to_center(self, centerPos):
        visitedCorners = []
        visitedEdges = []
        cornSprites = []
        remainingTiles = mapmodel.allTiles

        tSprite1 = self.tiles[0]
        tile = tSprite1.tile
        tSprite1.center = center
        tSprite.calcCornerPositions()
        remainingTiles.remove(tile)

        cornPosIdx = 0

        def visitFn(corner, edge):
            cornPosIdx += 1
            if edge and set.issubset(edge.corners, visitedCorners):
                return

            cSprite = Corner(corner)
            cSprite.center = tSprite1.cornerPositions[cornPosIdx]
            cornSprites.append(cSprite)
            visitedCorners.append(corner)

            if edge:
                otherTiles = (edge.tiles - [tile])
                if otherTiles:
                    otherTile = otherTiles[0]
                    if otherTile in remainingTiles:
                        otherTileS.setCenterFromEdge(edge, tSprite)

        walk_corners_along_tile(tile, visitFn)


#------------------------------------------------------------------------------
class PlayerDisplay(EasySprite):
    def __init__(self, player):
        EasySprite.__init__(self)
        events.registerListener(self)
        self.image = EasySurface( (80,80) )
        self.rect = self.image.get_rect()

        self.player = player
        self.active = False

        self.drawBg()

        hudGroup.add(self)
        self.dirty = True

    #----------------------------------------------------------------------
    def drawBg(self):
        self.image.fill( (0,0,20) )
        r = self.rect.move(0,0)
        r.topleft = 0,0
        pygame.draw.rect(self.image, blue, r, 8)
        
        if self.player.points >= 10:
            r2 = r.inflate(10,10)
            r2.center = r.center
            pygame.draw.rect(self.image, white, r2)

        if catan.game.state.activePlayer == self.player:
            self.active = True
        else:
            self.active = False

        if self.active:
            pygame.draw.rect(self.image, (200,200,255), r, 1)

        txtImg = font_render(str(self.player.identifier),
                             color=self.player.color)
        pos = vect_add(r.midtop, (10,4))
        self.image.blit(txtImg, pos)

        txtImg = font_render(str(self.player.points),
                             color=self.player.color)
        pos = vect_add(r.midtop, (20,4))
        self.image.blit(txtImg, pos)

    #----------------------------------------------------------------------
    def drawCards(self):
        cards = self.player.cards
        draw_cards(cards, self.image, 2, 6, 3, 3)

    #----------------------------------------------------------------------
    def drawVictoryCards(self):
        for i, card in enumerate(self.player.victoryCards):
            cardImg = victoryCard_img(card)
            cardPos = vect_add((32,6), (3*i,3*i))
            self.image.blit(cardImg, cardPos)

        for i, card in enumerate(self.player.playedVictoryCards):
            cardImg = victoryCard_img(card)
            cardPos = vect_add((5,50), (3*i,0))
            self.image.blit(cardImg, cardPos)


    #----------------------------------------------------------------------
    def update(self):
        if not self.dirty:
            return
        self.drawBg()
        self.drawCards()
        self.drawVictoryCards()
        self.dirty = False

    #----------------------------------------------------------------------
    def onStageChange(self, newStage):
        if newStage in [catan.Stages.preRoll,
                        catan.Stages.playerTurn]:
            self.dirty = True

        if self.player != humanPlayer:
            return

        if newStage == catan.Stages.sevenRolledDiscard:
            if len(self.player.cards) > 7:
                events.post('ShowDiscard', self.player)

        if self.player != catan.game.state.activePlayer:
            return

        elif newStage in [catan.Stages.preRollChooseVictim,
                          catan.Stages.postRollChooseVictim]:
            possibleVictims = self.player.findPossibleVictims()
            if possibleVictims:
                if len(possibleVictims) == 1:
                    events.post('RobRequest', self.player,
                                possibleVictims[0])
                else:
                    events.post('ShowChooseVictim', self.player,
                                possibleVictims)
            else:
                events.post('SkipRobRequest', self.player)


    #----------------------------------------------------------------------
    def onPlayerDrewVictoryCard(self, player, card):
        if player == self.player:
            self.dirty = True

    #----------------------------------------------------------------------
    def onDiscard(self, player):
        if player == self.player:
            self.dirty = True

    #----------------------------------------------------------------------
    def onPlayerPlacing(self, player, item):
        self.dirty = True
        if self.player == player and isinstance(item, catan.Robber):
            events.post('ShowRobberCursor', self.player)

    #----------------------------------------------------------------------
    def onRefreshState(self):
        self.dirty = True

    #----------------------------------------------------------------------
    def onConfirmProposal(self, *args):
        self.dirty = True

    #----------------------------------------------------------------------
    def onMaritimeTrade(self, *args):
        self.dirty = True

    #----------------------------------------------------------------------
    def onItemPlaced(self, *args):
        self.dirty = True

    #----------------------------------------------------------------------
    def onChooseTwoCards(self, player, cards):
        self.dirty = True

    #----------------------------------------------------------------------
    def onMonopoly(self, player, cards):
        self.dirty = True


humanPlayer = None

#------------------------------------------------------------------------------
def main():
    global humanPlayer
    spinner = CPUSpinnerController()
    kbController = KeyboardController()
    pygameView = PygameView()
    catan.init()
    from cpu_player_minimal import CPUPlayer
    events.post('PlayerJoin', CPUPlayer(1))
    events.post('PlayerJoin', CPUPlayer(2))
    events.post('PlayerJoin', CPUPlayer(3))
    humanPlayer = catan.HumanPlayer(4)
    events.post('PlayerJoin', humanPlayer)
    spinner.run()

#------------------------------------------------------------------------------
_oldExceptHook = sys.excepthook
def customExceptHook(etype, evalue, etb):
    print '='*60
    print 'EXCEPTION HOOK'
    _oldExceptHook(etype, evalue, etb)
    import pdb
    retval = pdb.pm()
    print 'retval :', retval
    

if __name__ == "__main__":
    sys.excepthook = customExceptHook
    main()