schroedingerchess package

Submodules

schroedingerchess.chess module

First test for chess implementation.

class schroedingerchess.chess.ChessBoard

Bases: object

Chess board manipulation.

add_move_to_history(x1, y1, x2, y2, piece, target_piece)

Add move to history (temporarily or not).

all_legal_moves()

all_legal_moves_gen()

Search all legal move at a given turn.

all_legal_natures(piece, update=True)

Search all legal natures a piece could have.

auto_move(intelligent=False)

Perform one of the legal moves at random.

compute_attack()

Encode attack as a binary table.

compute_position()

Encode position as a binary table.

create_standard_board()

Define standard board for test purposes.

delete_move_from_history(x1, y1, x2, y2, piece, target_piece)

Reverse the last move.

display_guess()

Display a possible guess.

display_natures()

Display the number of legal natures.

end_game()

free_trajectory(x1, y1, x2, y2)

Decide if a move is prevented by other pieces in the way.

get_coord(s)

Get coordinates from square number.

get_square(x, y)

Get square number from coordinates.

is_legal_nature(piece, n)

Check if, given the current history, piece could have nature n.

legal_moves_from(x1, y1)

legal_moves_from_gen(x1, y1)

Search all legal moves starting from a given square.

move(x1, y1, x2, y2, disp=True)

Test and perform a move.

Will raise IllegalMove if the move is not valid.

move_exists(x1, y1, x2, y2)

Verify that a move exists in chess.

nature_elimination(piece, x1, y1, x2, y2)

Find which natures got impossible for the piece that just moved.

on_board(x1, y1)

Check if a square is part of the board.

one_player_game()

parse_variable(var)

Parse pulp variable name.

pawn_could_reach(x1, y1, x2, y2, c)

Check whether a pawn on (x1, y1) can go to (x2, y2).

pawn_could_take(x1, y1, x2, y2, c)

Check whether a pawn on (x1, y1) threatens (x2, y2).

perform_move(x1, y1, x2, y2, problem)

Perform a move, assuming it is valid.

possible_move(x1, y1, x2, y2, n, c)

Decide if a move belongs to the abilities of a piece nature.

Special case for pawns where it depends upon the color, target and the previous moves.

quantum_explanation(check=None)

Perform consistency check with MIP.

Returns the solved linear problem.

test_move(x1, y1, x2, y2, full_result=False)

Test whether a move is possible.

Raise IllegalMove exceptions detailing the various move invalidities.

translate_move(move)

trivial_test_move(x1, y1, x2, y2)

Check obvious failures.

update_guess(problem)

Update guess with MIP solution.

class schroedingerchess.chess.ChessPiece(c, i, n, p, b=None)

Bases: object

Chess piece manipulation.

exception schroedingerchess.chess.IllegalMove

Bases: Exception

Illegal move.

class schroedingerchess.chess.LightBoard

Bases: object

getDeadPieces(color)

getPiece(x, y)

getPieceIndex(x, y)

move(x1, y1, x2, y2)

static possibleNaturesFromMove(x1, y1, x2, y2, color, natures)

setPiece(i, color, position, natures)

i is the index of the piece in self.pieces (same as ChessBoard.pieces)

unwrap(wrap)

wrapUp()

schroedingerchess.chess.main()

Main.

schroedingerchess.client module

class schroedingerchess.client.ChessClientProtocol(client)

Bases: twisted.internet.protocol.Protocol

Class which handles the communication protocol between the game client and the game server.

connectionLost(reason)

Handles the connection lost with the server. :param reason: Reason of the disconnection

connectionMade()

Called when a connection is made.

This may be considered the initializer of the protocol, because it is called when the connection is completed. For clients, this is called once the connection to the server has been established; for servers, this is called after an accept() call stops blocking and a socket has been received. If you need to send any greeting or initial message, do it here.

dataReceived(data)

Handles the reception of data from the server. :param data: A byte representing a JSON-encoded object (default encoding UTF-8)

sendMessage(msg)

Sends a message to the server using the protocol. :param msg: A dictionary representing a message.

split_messages(data)

schroedingerchess.display module

Display chess board.

class schroedingerchess.display.ChessDisplay(gameEngine)

Bases: object

Display of the chess board.

addMessage(message)

Split the incoming text message according to the screen size and add it to the message history :param message: A string message

check_address_format(s)

drawBoard(lightBoard)

Draws the board. :param lightBoard: The light board to draw. :see LightBoard

drawCheckMates(checkmate_positions)

Draws the checkmates created by the last move. :param checkmates_positions: List of the checkmate positions.

drawChecks(check_positions)

Draws the checks created by the last move. :param check_positions: List of the check positions.

drawMenu()

Draws the start menu.

drawPane()

draw_piece(color, natures, x, y, size, extended=False)

x, y are in pixels

flipDisplay(newState)

Set the display orientation :param newState: Is True if and only if the display has to be upside down (Black in the lower part)

flipY(y)

Flip the y coordinate depending on the flip parameter :param y: The y coordinate

handleIllegalMove(reason)

Handles illegal moves. :param reason: Reason of the illegal move

load_images()

Retrieve images from memory.

setLastMove(x1, y1, x2, y2)

setMenuMode()

setOnePlayerOnNetworkMode(name, address, color)

Sets the game engine on the one-player on network mode.

setTwoPlayersOnOneBoardMode()

Sets the game engine on the two-players-on-one-board mode.

update()

Updates the frame.

updateBoard(events)

Handles piece selection and move attempts.

updateMenu(events)

Updates the start menu.

updatePane(events=[])

Update the right hand side pane

class schroedingerchess.display.InputBox(x, y, w, h, text='')

Bases: object

draw(screen)

handle_event(event)

update()

schroedingerchess.game_engines module

class schroedingerchess.game_engines.GameEngine

Bases: object

checkEnd()

Schedules an end check

checkEndTask()

Task to perform to check whether the game has ended.

handleIllegalMove(reason)

Handles an illegal move.

makeDisplayDrawBoard()

Makes the display redraw the board.

makeDisplayDrawChecks(check_positions)

makeDisplayDrawChecksMates(checkmate_positions)

move(x1, y1, x2, y2)

Schedules a move task.

moveTask(x1, y1, x2, y2)

Task to perform when the display detects a move.

resume()

Resumes the reaction loop of the window.

setOnePlayerOnNetworkMode(name, address, color)

Sets the engine on the one-player-on-network mode.

setTwoPlayersOnOneBoardMode()

Sets the engine on the two-players-on-one-board mode.

start()

Starts the game engine. Create the window and initiate the reaction loop.

startFromEngine(engine)

Starts the game engine. Create the window and initiate the reaction loop.

stop()

Stops the game engine.

suspend()

Suspends the reaction loop of the window.

class schroedingerchess.game_engines.OnePlayerOnNetwork(gameEngine, name, address=None, color=0)

Bases: schroedingerchess.game_engines.GameEngine

autoMove()

autoMoveTask()

checkEndTask()

Task to perform to check whether the game has ended.

connectionFailed(*kwargs)

handleCheckMates(description)

handleChecks(description)

handleDisconnection(description)

handleInit()

handleMove(description)

Executes a move received from the server

handleReady()

handleUpdateBoard(description)

moveTask(x1, y1, x2, y2)

Task to perform when the display detects a move.

class schroedingerchess.game_engines.TwoPlayersOnOneBoard(gameEngine)

Bases: schroedingerchess.game_engines.GameEngine

autoMove()

checkEndTask()

Task to perform to check whether the game has ended.

move(x1, y1, x2, y2)

Schedules a move task.

moveTask(mov)

Task to perform when the display detects a move.

updateLightBoard()

schroedingerchess.run module

schroedingerchess.server module

class schroedingerchess.server.ChessServer

Bases: twisted.internet.protocol.Factory

Game server : produces a new ChessServerProtocol each time a client arrives

addWaitingPlayer(client)

assignColor(player_id, color)

protocol

alias of ChessServerProtocol

removeGame(game_id)

removePlayerFromWaitingList(player_id)

tryToMatchPlayers()

class schroedingerchess.server.ChessServerProtocol

Bases: twisted.internet.protocol.Protocol

Class to handles the communication protocol with a game client.

connectionLost(reason)

Handles the connection lost with the client (executes automatically). :param reason: Reason of the disconnection

connectionMade()

Sends the game information when a new client is connected.

dataReceived(data)

Handles the reception of data by the server :param data: A byte representing a JSON-encoded object (default encoding UTF-8)

disconnect()

Disconnect current player / protocol

handleEndGame(color)

handleGreetings(msg)

handleMove(msg, auto=False)

refuseMessage(msg)

Handles the reception of messages when waiting for second player. All instructions are illegal. :param msg: A dictionary representing a message.

sendMessage(msg)

Sends a message to the client. :param msg: A dictionary representing a message.

sendMessageToAll(msg)

Sends a message to the client and the other player’s client. :param msg: A dictionary representing a message.

sendMessageToOther(msg)

Sends a message to the client and the other player’s client. :param msg: A dictionary representing a message.

split_messages(data)

class schroedingerchess.server.Game(whites, blacks, gameIndex)

Bases: object

Class to represent a game instance.

autoMove()

checkEnd(color)

disconnectPlayers()

move(x1, y1, x2, y2, color)

notifyReady()

sendMessageTo(msg, color)

sendMessageToAll(msg)

updateLightBoard()

Schedules an update board task.

updateLightBoardTask()

Module contents