def __init__(self):
pygame.init()
self.game_settings = GameSettings()
self.board_settings = BoardSettings()
self.logo = pygame.image.load('assets/logo.png')
pygame.display.set_icon(self.logo)
pygame.display.set_caption("{} Version: {}".format(
self.game_settings.name, self.game_settings.version))
self.board = Board()
self.screen = self.board.drawBoard()
self.clock = pygame.time.Clock()
self.green_set = JanggiSet(self, 'Green', 'assets/green_pieces.png',
'assets/green_pieces.json')
self.red_set = JanggiSet(self, 'Red', 'assets/red_pieces.png',
'assets/red_pieces.json')
# mouse tracker
self.mouseDown = False
self.mouseReleased = False
self.grabbed_piece = None
self.moveList = []
# player turn
self.turn = "Red"
def __init__(self):
super().__init__()
self.title('Chess V2')
if sys.platform == "linux":
self.window_arg = "-zoomed"
else:
self.window_arg = "-fullscreen"
self.fullscreen_state = False
self.attributes(self.window_arg, self.fullscreen_state)
self.bind("<F11>", self.toggle_fullscreen)
self.bind("<Escape>", self.exit_fullscreen)
self.board = Board(self)
self.mainloop()
def main(board_size, number_of_dice):
player_list, snake_list, ladder_list = parse_input_file()
board_object = Board(board_size, player_list, snake_list, ladder_list, number_of_dice)
# stop when one player wins
# can be extended to playing game till one player exists by changing to
# while board_object.get_number_of_winner() != len(player_list)-1:
while board_object.get_number_of_winner() == 0:
_dice_val, _source, _player = board_object.make_move()
print(str(_player.get_name()) + " rolled a " + str(_dice_val) + " and moved from " + str(_source) + " to " + str(_player.get_current_pos()))
_rank_list = board_object.get_rank_list()
for key, val in _rank_list.items():
print(key.get_name() + " wins the game")
def play_a_game(settings, snakes_and_ladders=False, report_frequency='end'):
"""
Takes input settings and plays a game. Outputs the final configuration of the game.
:param settings: A dict containing all the information loaded from a json file
:param snakes_and_ladders: Optional arg. If blank, will just use the snakes and ladders from the settings,
if not, will use the configuration supplied.
:param report_frequency: Choice for frequency of reports. Options are: 'end' for end of game, and 'turn' for
a report every turn.
:return: A generated report on the matter
"""
if snakes_and_ladders:
settings['board']['snakes_and_ladders'] = snakes_and_ladders
b = Board(**settings['board'])
for i in range(settings['players']['number_of_players']):
p = BasePlayer("ai{}".format(i))
b.add_player(p)
if report_frequency == 'end':
while not b.check_for_winners():
b.take_turn()
final_report = b.generate_report()
elif report_frequency == 'turn':
final_report = dict()
while not b.check_for_winners():
t = b.get_number_of_turns()
r = b.generate_report()
final_report[t] = r
b.take_turn()
t = b.get_number_of_turns()
r = b.generate_report()
final_report[t] = r
else:
raise ValueError('{} is not a valid input'.format(report_frequency))
return final_report
def main():
pygame.init()
clock_object = pygame.time.Clock()
game_settings = Settings()
lines = Borders(game_settings)
# initialize screen size
screen = pygame.display.set_mode((game_settings.screen_width, game_settings.screen_height))
pygame.display.set_caption("2048")
# Create game instance and add three cells to it.
game_board = Board(game_settings, screen)
game_board.add_tile(game_settings, quantity=3)
while True:
# Limits screen refreshment speed.
clock_object.tick(30)
game_board.draw_board(game_settings)
lines.draw_lines(screen, game_settings)
for event in pygame.event.get():
if event.type == pygame.QUIT:
# If game window is closed.
sys.exit()
elif event.type == pygame.KEYDOWN:
# If keyboard keys are pressed.
if event.key in game_board.movement_keys:
# New tile is added only if key press initiated a change in game board.
# If move() or calculate() returns True, then cell value was modified, and new tile is added.
change_in_move_1 = game_board.move(event.key, game_settings)
change_in_calculate = game_board.calculate(event.key, game_settings)
change_in_move_2 = game_board.move(event.key, game_settings)
if change_in_move_1 or change_in_move_2 or change_in_calculate:
game_board.add_tile(game_settings, quantity=1)
elif game_board.check_game_over(game_settings):
game_board.game_over(game_settings)
elif event.key == pygame.K_q:
sys.exit()
pygame.display.flip()
def launchGame():
pieceSize = 100 # taille de chaque pièce du jeu d'échecs
pygame.init()
#* ================== Window =====================
WIDTH, HEIGHT = 1000, 1000 # Largeur et hauteur de la fenêtre
WIN = pygame.display.set_mode((WIDTH, HEIGHT)) # Définir la fenêtre
pygame.display.set_caption("Chess") # Titre de la fenêtre
main_font = pygame.font.SysFont("comicsans", 50)
end_game_font = pygame.font.SysFont("comicsans", 75)
board = Board()
playerWhite = Player(board, WHITE)
playerBlack = Player(board, BLACK)
#* Register
register = Register(settings["whereToSave"], settings["whoPlaysWhite"], settings["whoPlaysBlack"])
def endGame(whoWins):
"""
Affiche la fin de la game si victoire de l'un
"""
textsurface = end_game_font.render(f'{whoWins} WINS', True, Color.BLUE.value)
WIN.blit(textsurface, (400,400))
pygame.display.update()
duration = 0
while duration < 10000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
pygame.time.delay(50)
duration += 50
exit()
def endGameNulle() :
"""
Affiche la fin d'une partie en cas de pat (match nul)
"""
textsurface = end_game_font.render(f'NULLE', True, Color.BLUE.value)
WIN.blit(textsurface, (400,400))
pygame.display.update()
duration = 0
while duration < 10000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
pygame.time.delay(50)
duration += 50
exit()
nbCoups = 0
while True:
board.updateGraphicalInterface(WIN, [playerBlack, playerWhite])
# print(board)
nbCoups+=1 # On incrémente le nombre de coups
etat = playerWhite.turn(board, playerBlack, WIN, nbCoups, register) # Tour des blancs
if etat == 0:
# Les blancs ont perdu
endGame('BLACK')
elif etat == 1:
endGameNulle()
# print()
# print("\n".join([str(x) for x in playerBlack.king.casesInaccessiblesPourLeRoi(board, playerWhite)]))
# print()
nbCoups+=1 # on incrémente de coups
etat = playerBlack.turn(board, playerWhite, WIN, nbCoups, register) # Tour des noirs
if etat == 0:
# Les noirs ont perdu
endGame('WHITE')
elif etat == 1:
endGameNulle()
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
def main():
# get PCBmodE version
version = utils.get_git_revision()
# setup and parse commandline arguments
argp = cmdArgSetup(version)
cmdline_args = argp.parse_args()
# Might support running multiple boards in the future,
# for now get the first onw
board_name = cmdline_args.boards[0]
makeConfig(board_name, version, cmdline_args)
# check if build directory exists; if not, create
build_dir = os.path.join(config.cfg['base-dir'], config.cfg['locations']['build'])
utils.create_dir(build_dir)
# renumber refdefs and dump board config file
if cmdline_args.renumber is not False:
msg.info("Renumbering refdefs")
if cmdline_args.renumber is None:
order = 'top-to-bottom'
else:
order = cmdline_args.renumber.lower()
utils.renumberRefdefs(order)
# Extract routing from input SVG file
elif cmdline_args.extract is True:
extract.extract()
# Create a BoM
elif cmdline_args.make_bom is not False:
bom.make_bom(cmdline_args.make_bom)
else:
# make the board
if cmdline_args.make is True:
msg.info("Creating board")
board = Board()
# Create production files (Gerbers, Excellon, etc.)
if cmdline_args.fab is not False:
if cmdline_args.fab is None:
manufacturer = 'default'
else:
manufacturer = cmdline_args.fab.lower()
msg.info("Creating Gerbers")
gerber.gerberise(manufacturer)
msg.info("Creating excellon drill file")
excellon.makeExcellon(manufacturer)
if cmdline_args.pngs is True:
msg.info("Creating PNGs")
utils.makePngs()
filename = os.path.join(config.cfg['locations']['boards'],
config.cfg['name'],
config.cfg['locations']['build'],
'paths_db.json')
try:
f = open(filename, 'wb')
except IOError as e:
print "I/O error({0}): {1}".format(e.errno, e.strerror)
f.write(json.dumps(config.pth, sort_keys=True, indent=2))
f.close()
msg.info("Done!")
from utils.pieces import Piece
from utils.board import Board
from utils.teams import Team
from termcolor import colored
from utils.helper import (y_flip, get_x_between, get_y_between,
letter_to_number, number_to_letter, print_error,
get_piece_to_move, get_target_position,
update_team_threat, checkmate, get_between_exclusive,
check_move)
board = Board()
def player_move(team, oppo_team):
print(colored(team.colour + '\'s turn', team.colour))
curr_pos = get_piece_to_move()
tar_pos = get_target_position()
result = check_move(team, oppo_team, curr_pos, tar_pos, board)
return result, curr_pos, tar_pos
def act_on_result(result, curr_pos, tar_pos, team):
"""
Takes result of player_move and check_move functions
to determine next action
Return: 0 if move is invalid (same player's turn)
1 if move is valid (next player's turn)
from utils.engine import Engine
if __name__ == '__main__':
size = input("Entrez la taille du plateau (inf à 26 et pair): ")
while not size.isdigit() \
or int(size) < 4 or int(size) > 26 \
or int(size) % 2 == 1:
size = input("Err, entrez la taille du plateau (inf à 26 et pair): ")
width = height = int(size)
players = input("Joueur contre une IA ? [O/n] ")
while players.lower() not in [
'yes', 'y', 'oui', 'o', 'no', 'n', 'non', ''
]:
players = input("Err, joueur contre une IA ? [O/n] ")
players = 2 if players in ['no', 'n', 'non'] else 1
board = Board(width, height)
board.make_board()
engine = Engine(board, players)
engine.start()
try:
while engine.is_playing:
engine.get_action()
except (KeyboardInterrupt, EOFError):
engine.stop()