예제 #1
0
 def move(self, move, board):
     capture = True
     if board.fields[move.toField] is None:
         capture = False
     
     explosionMoves = super(AtomicGame, self).move(move, board)
     
     if not capture:
         return explosionMoves
     
     # create explosion moves
     target = move.toField
     for x in [-1, 0, 1]:
         for y in [-1, 0, 1]:
             # piece itself
             #if x == 0 and y == 0:
             #    continue
             # fields around it
             explosionTarget = board.moveByDirection(target, x, y)
             if explosionTarget is None:
                 continue
             if board.fields[explosionTarget] is None:
                 continue 
             if board.fields[explosionTarget].shortName in self.PAWN_PIECE_TYPES:
                 continue 
             move = Move(explosionTarget, explosionTarget)
             move.toPiece = '' # indicates that field will be cleared
             move.silent = True
             # execute on board
             board.move(move) 
             explosionMoves.append(move)
              
     return explosionMoves
예제 #2
0
 def move(self, move, board):
     coin_pos = board.findPieces('c', None).pop() # there only is one ;-)
     coin_target = coin_pos + (move.toField - move.fromField)
     coin_move = Move(coin_pos, coin_target)
     coin_move.silent = True
     board.move(coin_move)
     # normal stuff
     return [coin_move] + super(CoinGame, self).move(move, board)
예제 #3
0
파일: JazzyServer.py 프로젝트: jazzer/Jazzy
    def handle_input(self, message, gameConnection):
        #print message
        if message is None:
            return
        
        params = message.split("/")
        #print params
        if len(params) > 1:
            mq = mqPool.get(params[1])
        print params
        
        if mq is None:
            print 'Access to non-existing message queue: %s' % params[1]; 
            return ''
            
        # make sure this socket is tied to the message queue?
        mq.socket = gameConnection
            
        if (params[0] == 'post' and params[2] == 'move'):
            # record time (when jazzy is calculating, nobody's clock should be active...)
            input_time = datetime.datetime.now()
                        
            # filter watchers attempting to post stuff
            if mq.watching or mq.game.finished == True:
                return
            # only allow current player to post his move
            if mq.game.getCurrentPlayer().mq != mq:
                mq.send(Message('alert', {'msg': 'Not your turn.'}).data)
                return
            
            game = mq.game
            
            # find board
            originalFrom = params[3]
            originalTo = params[4]
            shortFrom = originalFrom.replace('board_', '').replace('_field', '_');
            shortTo = originalTo.replace('board_', '').replace('_field', '_');
            boardId = shortFrom.split('_')[0]
            targetBoard = mq.game.getBoard(boardId)
            
            # create move
            if  shortFrom.split('_')[1] == 'SHORTCASTLING' or  shortFrom.split('_')[1] == 'LONGCASTLING':
                # castling
                postedMove = Move(None, None)
                postedMove.annotation = shortFrom.split('_')[1]
            else:
                # standard move
                fromField = shortFrom.split('_')[1]
                toField = int(shortTo.split('_')[1])
                postedMove = Move(fromField, toField)
                # do we have a promotion option set?
                if len(params) > 5:
                    postedMove.toPiece = game.getPieceByString(params[5], game.board) 

            
            # check move for correctness
            isLegalMove = game.isLegalMove(postedMove, targetBoard)
            # parse move
            postedMove.simpleParse(targetBoard)
            postedMove.fullParse(targetBoard)
                            
            # put the message to all players
            if isLegalMove:
                # do we have to ask for promotion piece?
                if game.moveNeedsPromotion(postedMove, targetBoard):
                    msg = Message('promote', {'from': originalFrom, 'to': originalTo})
                    # add options
                    msg.data['options'] = game.getPromotionOptions(postedMove.fromPiece.color)
                    mq.send(msg.data)
                else:
                    moves = game.move(postedMove, targetBoard, realMove = True, input_time = input_time)
                    
                    # analyze if game is over
                    result = game.getGameOverMessage()
                    if not(result is None):
                        game.finish()                        
    
                    # post all the moves the particular game created
                    for move in moves:                    
                        if isinstance(move, NullMove):
                            data = {'from':-1, 'to':-1}
                            data['silent'] = True
                        else:
                            # normal move
                            #move.simpleParse(mq.game.board)
                            if move.board is None:
                                data = {'from': move.fromField, 'to': move.toField}
                            else:
                                data = {'from': str(move.board.id) + '_' + str(move.fromField), 'to': str(move.board.id) + '_' + str(move.toField)}
                                
                            if move.silent:
                                data['silent'] = True
                            if not(move.toPiece is None):
                                if move.toPiece == '':
                                    data['toPiece'] = ''
                                else:
                                    data['toPiece'] = move.toPiece.getShortName()
                        if not(game.getCurrentPlayer(game.board) is None) and not(game.finished):
                            data['currP'] = game.getCurrentPlayer(game.board).mq.shortenedId
                        mq.metagame.broadcastSocket(Message('move', data).data)
                        
                    mq.metagame.broadcastSocket(Message('movehist', {'user': mq.subject.name, 'str': postedMove.str}).data)
                    
                    # debug position
                    logger.debug(str(game.board))
                    
                    # resend parts of the board that have changed (not forced)
                    for player in mq.metagame.players:
                        sitMsg = mq.metagame.getSituationMessage(mq, player=player)
                        if not(sitMsg is None):
                            player.mq.send(sitMsg.data)
                    # clear board
                    mq.game.board.resend = False # TODO generalize
                    
                    # distribute the game over message if there was one
                    if not(result is None):
                        mq.metagame.broadcastSocket(result.data)
                    
            else: 
                # not legal move
                msg = Message('alert', {'msg': 'Illegal move.'})
                mq.send(msg.data)
                if game.DEBUG_LEGAL_MOVES_ON_ILLEGAL_MOVE:
                    msg = Message('srvmsg', {'msg': 'Possible moves are: ' + str(sorted(mq.game.possibleMoves, key=lambda move: [str(move.fromField), move.toField]))})
                    mq.send(msg.data)
        
        elif (params[0] == 'getsit'):
            return mq.metagame.getSituationMessage(mq, force=True, init=True).data
        
        # draw claims
        elif params[0] == 'claim':
            # filter watchers attempting to post stuff
            if mq.watching:
                return
                
            if params[2] == 'repetition':                    
                if mq.game.isRepetitionDraw():
                    mq.metagame.broadcastSocket(mq.game._generateGameOverMessage('Draw by repetition upon player\'s request', '0.5-0.5', None).data)
                    mq.game.finish()   
                else:
                    mq.send(Message('alert', {'msg': 'No draw by repetition. This position has been on board {0} times.'.format(mq.game.getRepetitionCount())}).data) 
                    
            if params[2] == 'xmoverule':
                if mq.game.isXMoveDraw():
                    mq.metagame.broadcastSocket(mq.game._generateGameOverMessage('Draw by {0} move rule upon player\'s request'.format(mq.game.DRAW_X_MOVES_VALUE), '0.5-0.5').data)
                    mq.game.finish()   
                else:
                    mq.send(Message('alert', {'msg': 'No draw by {0} move rule. Counter is at {1}.'.format(mq.game.DRAW_X_MOVES_VALUE, mq.game.board.drawXMoveCounter)}).data)
            
            # clock
            if params[2] == 'clock':
                clockExpirationPlayer = None
                for player in mq.game.players:
                    if player.mq.clock.isExpired():
                        if clockExpirationPlayer is None:
                            clockExpirationPlayer = player
                        else:
                            # more than 1 clock expired -> draw
                            mq.game.broadcastSocket(mq.game._valueResult(None, 'Both players\' time\'s up!').data)
                            mq.game.finish()   
                            return
                        
                # anounce winner        
                if not(clockExpirationPlayer is None):
                    mq.game.broadcastSocket(mq.game._valueResult(clockExpirationPlayer, 'Time\'s up!').data)
                    mq.game.finish()   
                else:
                    mq.send(Message('alert', {'msg': 'No time trouble detected.'}).data)
                    
                    
        # messages about game end (resigning, draws) 
        elif (params[0] == 'end'):
            # only players please!
            if not mq.watching:
                # player resigned
                if (params[2] == 'resign'):
                    result = '0-1' if mq.subject.color == 'white' else '1-0' 
                    winner = mq.game.getNextCurrentPlayer() if mq.game.getCurrentPlayer() == mq.subject else mq.game.getCurrentPlayer()
                    mq.metagame.broadcastSocket(mq.game._generateGameOverMessage('Player resigned.', result, winner).data)
                    mq.game.finish()   
                # player is offering draw
                elif (params[2] == 'draw-offer'):
                    agreeingPlayers = []
                    for player in mq.game.players:
                        if player.offeringDraw:
                            agreeingPlayers.append(player)
                    
                    # rule: you may not offer a draw when you are on the move!
                    if not(mq.subject.offeringDraw) and (len(agreeingPlayers) > 0 or mq.subject != mq.game.getCurrentPlayer()):
                        # keep the player's decision
                        mq.subject.offeringDraw = True
                        
                        # do all players agree?
                        agreeingPlayers = []
                        for player in mq.game.players:
                            if player.offeringDraw:
                                agreeingPlayers.append(player)
                                
                        if len(agreeingPlayers) == len(mq.game.players):
                            # finish the game
                            mq.metagame.broadcastSocket(mq.game._generateGameOverMessage('Players agreed.', '0.5-0.5', None).data)
                            mq.game.finish()   
                        else:
                            # ask the other players
                            mq.metagame.broadcastSocket(Message('draw-offer', {}).data, agreeingPlayers)
                    
            
        # transfer chat message     
        elif (params[0] == 'post' and params[2] == 'chat'):            
            # filter watchers attempting to post stuff
            if mq.watching:
                return
            
            # sanitize
            msg = params[3]
            msg = GenericHandler.sanitizeHTML(msg)
                        
            mq.metagame.broadcastSocket(Message('chat', {'user': mq.subject.name, 'msg': msg}).data, [mq.subject])
예제 #4
0
파일: ClassicGame.py 프로젝트: jazzer/Jazzy
    def parseCastling(self, moveSet, board, player):
        if True in board.castlingsPossible[player.color]:
            # has the king moved already?
            kingPiece = board.fields[self.castlingPositions[player.color][0]]
            if not(kingPiece is None) and kingPiece.moveCount > 0 and not self.CASTLING_IF_KING_HAS_MOVED:
                # destroys both castling possibilities!
                board.castlingsPossible[player.color] = [False, False]
                return moveSet       
                        
            # short / long
            for cType in [0, 1]:
                if board.castlingsPossible[player.color][cType]:
                    good = True
                    # has the rook moved already?
                    rookPiece = board.fields[self.castlingPositions[player.color][1 + cType]]
                    if not(rookPiece is None) and rookPiece.moveCount > 0 and not self.CASTLING_IF_ROOK_HAS_MOVED:
                        # destroys this castling possibility!
                        board.castlingsPossible[player.color][cType] = False
                        good = False
                    # any relevant field non-empty?
                    if good:
                        # relevant fields are any between rook's and king's start and target fields
                        leftPos = min(self.castlingPositions[player.color][0],
                                      self.castlingPositions[player.color][1 + cType],
                                      self.castlingTargetPositions[player.color][2 * cType],
                                      self.castlingTargetPositions[player.color][2 * cType + 1])
                        rightPos = max(self.castlingPositions[player.color][0],
                                      self.castlingPositions[player.color][1 + cType],
                                      self.castlingTargetPositions[player.color][2 * cType],
                                      self.castlingTargetPositions[player.color][2 * cType + 1])
                        # check them for emptiness (moving rook being there is okay [Chess960!])
                        for pos in range(leftPos, rightPos + 1):
                            if not (board.fields[pos] is None) and pos != self.castlingPositions[player.color][0] and pos != self.castlingPositions[player.color][1 + cType]: # empty, king, rook
                                good = False
                                break

                    # fields for king checked?          
                    if good and True:
                        # get all attacked fields
                        opponentMoves = self.getPossibleMoves(board, False, self.getNextPlayer(board, player), noCastlingMoves=True, noDropMoves=True)
                        opponentAttackedFields = set()
                        for oMove in opponentMoves:
                            opponentAttackedFields.add(oMove.toField)
                        
                        # get fields king will cross (including start and end)
                        kingPos = self.castlingPositions[player.color][0]
                        kingTargetPos = self.castlingTargetPositions[player.color][2 * cType]
                        leftPos = min(kingPos, kingTargetPos)
                        rightPos = max(kingPos, kingTargetPos)
                        
                        # compare
                        for pos in range(leftPos, rightPos + 1):
                            if pos in opponentAttackedFields:
                                # test which type of check has happened and obey settings
                                if pos == kingPos and not self.CASTLING_FROM_CHECK:
                                    good = False
                                    break
                                elif pos == kingTargetPos and not self.CASTLING_TO_CHECK:
                                    good = False
                                    break
                                elif not self.CASTLING_THROUGH_CHECK:
                                    good = False
                                    break
                    
                    # good!
                    if good:
                        move = Move(None, None)
                        move.annotation = 'SHORTCASTLING' if cType == 0 else 'LONGCASTLING'
                        moveSet.add(move)
        
        return moveSet