Beispiel #1
0
 def chooseVictim(self):
     opponents = self.findPossibleVictims()
     if opponents:
         victim = opponents[0]
         events.post('RobRequest', self, victim)
     else:
         events.post('SkipRobRequest', self)
Beispiel #2
0
 def placeOnTile(self, tile):
     if self._tile:
         self._tile.robber = None
     self._tile = tile
     self._tile.robber = self
     print 'Robber placed:', tile
     events.post('RobberPlaced', self)
Beispiel #3
0
 def run(self):
     self.lastTick = time.time()
     while self.keepGoing:
         now = time.time()
         delta = now - self.lastTick
         self.lastTick = now
         events.post("Tick", delta)
Beispiel #4
0
    def __init__(self):
        pips = [Pip(i) for i in [5,2,6,3,8,10,9,12,11,4,8,10,9,4,5,6,3,11]]

        random.shuffle(terrainClasses)
        self.tiles = []
        self.robber = Robber()
        mapmodel.build()
        for i, cls in enumerate(terrainClasses):
            tile = mapmodel.allTiles[Board.spiralWalk[i]-1]
            tile.graphicalPosition = Board.graphicalPositions[i]
            tile.terrain = cls()
            if cls == Desert:
                self.robber.placeOnTile(tile)
            else:
                tile.pip = pips.pop(0)
            self.tiles.append(tile)

        self.ports = [Port((None,3)), Port((None,3)),
                      Port((None,3)), Port((None,3)),
                      Port((Grain,2)), Port((Brick,2)),
                      Port((Stone,2)), Port((Sheep,2)),
                      Port((Wood,2))]
        random.shuffle(self.ports)

        self.layOutPorts()

        events.post('BoardCreated', self)
Beispiel #5
0
def _instakill(player, other):
    if 'instakill' in other:
        player.add_attributes(attributes.Dead)
        events.post(consts.ENTITY_DEATH, dead=player)
        events.post(consts.HEALTH_CHANGED, target=player, previous=player.health, new=0)
        
        player.health = 0
Beispiel #6
0
    def onPlayVictoryCardRequest(self, player, victoryCardClass):
        if player != self or self != game.state.activePlayer:
            return

        foundCard = None
        for vcard in self.victoryCards:
            if isinstance(vcard, victoryCardClass):
                foundCard = vcard
                break
        if not foundCard:
            events.post('Error', 'Player does not have requested card.')
            return
        if not hasattr(foundCard, 'action'):
            events.post('Error', 'Card has no associated action.')
            return
        if self.victoryCardPlayedThisTurn:
            events.post('Error', 'Only one victory card per turn.')
            return
        if foundCard in self.victoryCardsBoughtThisTurn:
            events.post('Error', 'Victory card was bought this turn')
            return
        if (game.state.stage == Stages.preRoll
            and not victoryCardClass == Soldier):
            events.post('Error', 'Only soldier cards during pre-roll.')
            return

        self.victoryCardPlayedThisTurn = True
            
        self.victoryCards.remove(foundCard)
        self.playedVictoryCards.append(foundCard)

        foundCard.action(self)
Beispiel #7
0
 def onMonopoly(self, player, cardClass):
     if player == self:
         return
     stolen = [card for card in self.cards if isinstance(card, cardClass)]
     for card in stolen:
         self.cards.remove(card)
     events.post('MonopolyGive', self, player, stolen)
Beispiel #8
0
    def __call__(self, event):
        if 'user_controllable' not in self.entity:
            return
        if 'dead' in self.entity:
            return

        self.entity.amoeba_physics.damage(1, self.entity)

        if event.type == pygame.MOUSEBUTTONDOWN:
            self.start = event.pos
            self.circles = self.entity.circles
        if event.type == pygame.MOUSEBUTTONUP:
            if self.start is None:
                return
            
            v = Vector(*event.pos) - Vector(*self.start)
            cap = 150
            v.magnitude = v.magnitude if v < cap else cap
            v.magnitude *= 0.01
            for circle in self.circles:
                circle.acceleration -= v
            
            self.start = None
            
            events.post(consts.OBJECT_FLUNG, target=self.entity)
Beispiel #9
0
def handle_collision(event):
    player = None
    other = None
    
    if event.entity1.affiliation == 'player1':
        player, other = event.entity1, event.entity2
    elif event.entity2.affiliation == 'player1':
        other, player = event.entity1, event.entity2
    else:
        return

    # remove enemy from screen
    if other.affiliation == 'enemy':
        if len(player.circles) > len(other.circles):
            player.amoeba_physics.eat(player, other)
            other.add_attributes(attributes.RemoveMe)
        else:
            other.amoeba_physics.eat(other, player)
            player.add_attributes(attributes.RemoveMe)
            player.add_attributes(attributes.Dead)
            # events.post(consts.ENTITY_DEATH, dead=player)
        
    if 'instakill' in other:
        _instakill(player, other)
    elif 'size_increase_powerup' in other:
        _size_increase_powerup(player, other)
    elif 'increase_health' in other:
        _increase_health(player, other)
    elif 'inflicts_damage' in other:
        pass
        # _inflicts_damage(player, other)
    elif 'trigger' in other:
        events.post(consts.TRIGGER, origin=other, tag=other.trigger)
Beispiel #10
0
    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)
Beispiel #11
0
 def onChooseTwoCardsRequest(self, player, cardClasses):
     if player == self.activePlayer:
         cards = []
         for cls in cardClasses:
             card = cls()
             cards.append(card)
             player.cards.append(card)
         events.post('ChooseTwoCards', player, cards)
Beispiel #12
0
 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)
Beispiel #13
0
def run_saved_game():
    import saved_game
    saved_game.load()
    spinner = pygameview.CPUSpinnerController()
    kbController = pygameview.KeyboardController()
    pygameView = pygameview.PygameView()
    pygameview.humanPlayer = catan.game.players[-1]
    events.post('RefreshState')
    spinner.run()
Beispiel #14
0
 def __call__(self, event):
     if event.type == pygame.MOUSEMOTION:
         if self.is_within(event.pos):
             self.highlight_delta = 1
         else:
             self.highlight_delta = -1
     if event.type == pygame.MOUSEBUTTONDOWN:
         if self.is_within(event.pos):
             events.post(consts.CHANGE_FRAME, frame=self.next_frame, level=self.level)
Beispiel #15
0
 def add(self, item):
     if isinstance(item, VictoryCard):
         self.victoryCards.append(item)
         self.victoryCardsBoughtThisTurn.append(item)
         events.post('PlayerDrewVictoryCard', self, item)
     else:
         item.owner = self
         self.items.append(item)
         self.activeItem = item
         events.post('PlayerPlacing', self, item)
Beispiel #16
0
 def onMouseLeftDown(self, pos):
     if not self.rect.collidepoint(pos):
         return
     self.dirty = True
     innerPos = vect_diff(pos, self.topleft)
     for button in self.addButtons.values():
         if button.rect.collidepoint(innerPos):
             button.click()
     if self.dButton.rect.collidepoint(innerPos):
         if self.dButton.hintlighted:
             events.post('MonopolyRequest', self.player, self._chosen)
Beispiel #17
0
 def onRobRequest(self, thief, victim):
     if thief == self.activePlayer:
         if victim.cards:
             card = random.choice(victim.cards)
             victim.cards.remove(card)
             thief.cards.append(card)
             events.post('Rob', thief, victim, card)
         if self.stage == Stages.postRollChooseVictim:
             self.stage = Stages.playerTurn
         elif self.stage == Stages.preRollChooseVictim:
             self.stage = Stages.preRoll
Beispiel #18
0
def _inflicts_damage(player, other):
    if player.health <= 0:
        player.add_attributes(attributes.Dead)
        events.post(consts.ENTITY_DEATH, dead=player)
    else:
        events.post(
            consts.HEALTH_CHANGED, 
            target=player, 
            previous=player.health, 
            new=player.health - other.inflicts_damage)
            
        player.health -= other.inflicts_damage
Beispiel #19
0
 def onProposeTrade(self, player, toGive, toTake):
     if player == self:
         self.offer = []
         for cls, howMany in toGive.items():
             for card in self.cards:
                 if card.__class__ == cls and card not in self.offer:
                     self.offer.append(card)
                     howMany -= 1
                     if howMany == 0:
                         break
             if howMany != 0:
                 events.post('Error', 'Player does not have enough cards')
         self.wants = toTake
Beispiel #20
0
 def onMouseLeftDown(self, pos):
     if not self.rect.collidepoint(pos):
         return
     self.dirty = True
     innerPos = vect_diff(pos, self.topleft)
     for button in self.addButtons.values() + self.removeButtons.values():
         #print 'button', button, button.rect
         if button.rect.collidepoint(innerPos):
             print 'button %s sees mouse inner' % button
             button.click()
     if self.dButton.rect.collidepoint(innerPos):
         if self.dButton.hintlighted:
             events.post('DiscardRequest', self.player, self._discards)
Beispiel #21
0
 def onDiscardRequest(self, player, discards):
     if self != player:
         return
     print 'player %s discards %d from %d' %\
            (self, len(discards), len(self.cards))
     if not all([card in self.cards for card in discards]):
         print 'Player tried to discard cards that he did not own'
         return
     if not len(discards) == len(self.cards)/2:
         print 'Player tried to discard the wrong amout of cards'
         return
     for card in discards:
         self.cards.remove(card)
     events.post('Discard', self)
Beispiel #22
0
def _size_increase_powerup(player, other):
    events.post_delayed_event(
        consts.REMOVE_POWERUP, 10, 
        player=player, 
        original_health=player.health,
        increase = other.size_increase_powerup)
    events.post(
        consts.HEALTH_CHANGED,
        target=player,
        previous=player.health,
        new=player.health + other.size_increase_powerup)
        
    player.health += other.size_increase_powerup
    other.add_attributes(attributes.RemoveMe)
    other.size_increase_powerup = 0
Beispiel #23
0
 def onDiceRollRequest(self, player):
     import random
     if debugRolls:
         a,b = debugRolls.pop(0)
     else:
         a = random.randrange(1,7)
         b = random.randrange(1,7)
     self.lastRoll = (a,b)
     if (player != game.state.activePlayer
         or game.state.stage not in [Stages.preRoll]
         ):
         print 'illegal dice roll request', player
     else:
         print 'Dice roll:', a, b
         events.post('DiceRoll', a, b)
Beispiel #24
0
 def doPlacement(self):
     if isinstance(self.activeItem, Settlement):
         corners = self.findFreeCornersForSettlement()
         c = corners[0]
         c.add(self.activeItem)
     elif isinstance(self.activeItem, Road):
         edges = self.findFreeEdgesOfSettlement(self.latestItem)
         e = edges[0]
         e.add(self.activeItem)
     elif isinstance(self.activeItem, Robber):
         tiles = self.findFreeTilesForRobber()
         t = tiles[0]
         events.post('RobberPlaceRequest', self, t)
     self.latestItem = self.activeItem
     self.activeItem = None
Beispiel #25
0
 def wrappedfn(*args):
     if not game:
         raise ValueError('Game must be initialized before a function'
                          ' decorated with allowedDuring can be called')
     #print 'called ', fn
     #print 'supposed to be in', allowedStages
     if game.state.stage not in allowedStages:
         print 'EVENT NOT ALLOWED', fn.__name__, game.state.stage
         events.post('EventNotAllowedAtThisStage', fn.__name__,
                                          game.state.stage,
                                          allowedStages)
         return
         #raise EventNotAllowedAtThisStage(fn.__name__,
         #                                 game.state.stage,
         #                                 allowedStages)
     retval = fn(*args)
     return retval
Beispiel #26
0
    def onStageChange(self, newStage):
        print self, 'sees new stage', newStage
        self.offer = []
        self.wants = []
        if catan.game.state.stage == Stages.sevenRolledDiscard:
            self.discard()

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

        if catan.game.state.stage == Stages.preRoll:
            self.rollDice()
        if catan.game.state.stage == Stages.playerTurn:
            events.post('TurnFinishRequest', self)
        if catan.game.state.stage in [Stages.preRollChooseVictim,
                                Stages.postRollChooseVictim]:
            self.chooseVictim()
Beispiel #27
0
def handle_removed_powerups(event):
    current_health = event.player.health
    
    if current_health < event.original_health:
        return
        
    prev = event.player.health
    event.player.health -= event.increase
    if event.player.health < event.original_health:
        event.player.health = event.original_health
        
    
    events.post(
        consts.HEALTH_CHANGED,
        target=event.player,
        previous=prev,
        new=event.player.health)
        
    print 'done', event.player.health
Beispiel #28
0
def parse(items, threshold):
    for item in items:

        if item['sentiment'][0] > 0:
            item['type'] = 'buy'
            item['confidence'] = item['sentiment'][0] * 100

        if item['sentiment'][0] < 0:
            item['type'] = 'sell'
            item['confidence'] = item['sentiment'][0] * -100

        if item['sentiment'][0] == 0:
            item['confidence'] = 0

        print(item['timestamp'],item['source'],item['type'],item['confidence'],item['description'])
        if item['confidence'] > threshold:
            print('POSTED')
            #print(item['timestamp'],item['source'],item['type'],item['confidence'],item['description'])
            if LIVE:
                events.post(**item)
Beispiel #29
0
def parse(items, threshold):
    for item in items:

        if item['sentiment'][0] > 0:
            item['type'] = 'buy'
            item['confidence'] = item['sentiment'][0] * 100

        if item['sentiment'][0] < 0:
            item['type'] = 'sell'
            item['confidence'] = item['sentiment'][0] * -100

        if item['sentiment'][0] == 0:
            item['confidence'] = 0

        print(item['timestamp'],item['source'],item['type'],item['confidence'],item['description'])
        if item['confidence'] > threshold:
            print('POSTED')
            #print(item['timestamp'],item['source'],item['type'],item['confidence'],item['description'])
            if LIVE:
                events.post(**item)
Beispiel #30
0
 def onStageChange(self, newStage):
     if game.state.stage == Stages.setup:
         self.board = Board()
     if game.state.stage == Stages.cardHarvest:
         for tile in self.board.tiles:
             if tile.pip == None:
                 continue
             if tile.pip.value == sum(self.dice.lastRoll):
                 cardClass = tile.terrain.getCardClass()
                 for corner in tile.corners:
                     if not corner.settlement:
                         continue
                     owner = corner.settlement.owner
                     if isinstance(corner.settlement, City):
                         # Cities get 2 cards
                         cards = [cardClass(), cardClass()]
                     else:
                         # Regular settlements get 1 card
                         cards = [cardClass()]
                     events.post('Harvest', cards, tile, owner)
         events.post('CardHarvestOver')
Beispiel #31
0
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()