def undo_single_move(self, b):
move = None
nmove = len(self.movelist)
try:
move = self.movelist.pop()
engine.command("undo")
self.redolist.append(move)
self.lastmove = move
self.stm = self.get_side_to_move()
gv.gui.set_side_to_move(self.stm)
except IndexError:
pass
try:
gv.usib.stop_engine()
gv.usiw.stop_engine()
except:
pass
self.gameover = False
#gv.board.update()
# set move list window to last move
self.move_list.set_move(len(self.movelist))
self.goto_move(len(self.movelist))
if move is not None:
squares_to_hilite = (move[0:2], move[2:4])
else:
squares_to_hilite = None
self.lastmove = ""
gv.board.update(squares_to_hilite=squares_to_hilite)
if move is not None:
gv.gui.set_status_bar_msg("back: (" + str(nmove) + ". " + move +
")")
def undo_move(self):
engine.command("undo")
move = None
try:
move = self.movelist.pop()
self.redolist.append(move)
except IndexError:
pass
def undo_move(self):
engine.command("undo")
move = None
try:
move = self.movelist.pop()
self.redolist.append(move)
except IndexError:
pass
def human_move(self, move):
self.movelist.append(move)
self.redolist = []
self.lastmove = move
gv.board.update()
# update move list in move list window
self.move_list.update()
if gv.verbose:
engine.command("bd")
self.src = ""
self.gameover, msg = self.check_for_gameover()
if (self.gameover):
self.stop()
gv.gui.set_status_bar_msg(msg)
self.automatic_comment(msg, len(self.movelist))
self.thinking = False
return
self.stm = self.get_side_to_move()
gv.gui.set_side_to_move(self.stm)
if gv.verbose:
print("#")
print("# " + self.get_side_to_move_string(self.stm) +
_(" to move"))
print("#")
gv.gui.set_status_bar_msg(" ")
self.src = ""
# update time for last move
gv.tc.update_clock()
gv.gui.apply_drag_and_drop_settings(self.player[self.stm], self.stm)
if self.player[self.stm] == "Human":
# set clock ready for move to come
gv.tc.start_clock(self.stm)
if not self.timer_active:
GObject.timeout_add(1000, gv.tc.show_time)
return
self.thinking = True
# disable some functionality while the computer is thinking
# gv.gui.disable_menu_items()
# it's the computers turn to move. Kick off a separate thread for
# computers move so that gui is still useable
self.ct = _thread.start_new_thread(self.computer_move, ())
return
def human_move(self, move):
self.movelist.append(move)
self.redolist = []
self.lastmove = move
gv.board.update()
# update move list in move list window
self.move_list.update()
if gv.verbose:
engine.command("bd")
self.src = ""
self.gameover, msg = self.check_for_gameover()
if (self.gameover):
self.stop()
gv.gui.set_status_bar_msg(msg)
self.automatic_comment( msg,len(self.movelist))
self.thinking = False
return
self.stm = self.get_side_to_move()
gv.gui.set_side_to_move(self.stm)
if gv.verbose:
print("#")
print("# " + self.get_side_to_move_string(self.stm) + _(" to move"))
print("#")
gv.gui.set_status_bar_msg(" ")
self.src = ""
# update time for last move
gv.tc.update_clock()
gv.gui.apply_drag_and_drop_settings(self.player[self.stm], self.stm)
if self.player[self.stm] == "Human":
# set clock ready for move to come
gv.tc.start_clock(self.stm)
if not self.timer_active:
GObject.timeout_add(1000, gv.tc.show_time)
return
self.thinking = True
# disable some functionality while the computer is thinking
# gv.gui.disable_menu_items()
# it's the computers turn to move. Kick off a separate thread for
# computers move so that gui is still useable
self.ct = _thread.start_new_thread(self.computer_move, ())
return
def undo_move(self):
if gv.show_moves == True:
gv.gui.set_csave()
engine.command("undo")
move = None
try:
move = self.movelist.pop()
self.redolist.append(move)
except IndexError:
pass
def undo_move(self):
if gv.show_moves == True:
gv.gui.set_csave()
engine.command("undo")
move = None
try:
move = self.movelist.pop()
self.redolist.append(move)
except IndexError:
pass
def undo_single_move(self, b):
engine.command("undo")
move = None
try:
move = self.movelist.pop()
self.redolist.append(move)
self.lastmove = move
self.stm = self.get_side_to_move()
gv.gui.set_side_to_move(self.stm)
except IndexError:
pass
try:
gv.usib.stop_engine()
gv.usiw.stop_engine()
except:
pass
self.gameover = False
gv.board.update()
# set move list window to last move
self.move_list.set_move(len(self.movelist))
if move is not None:
gv.gui.set_status_bar_msg("(" + move + ")")
def undo_single_move(self, b):
if gv.show_moves == True:
gv.gui.set_csave()
move = None
nmove = len(self.movelist)
try:
move = self.movelist.pop()
engine.command("undo")
self.redolist.append(move)
self.lastmove = move
self.stm = self.get_side_to_move()
gv.gui.set_side_to_move(self.stm)
except IndexError:
pass
try:
gv.usib.stop_engine()
gv.usiw.stop_engine()
except:
pass
self.gameover = False
#gv.board.update()
# set move list window to last move
self.move_list.set_move(len(self.movelist))
self.goto_move(len(self.movelist))
if move is not None:
squares_to_hilite=(move[0:2], move[2:4])
else:
squares_to_hilite=None
self.lastmove = ""
gv.board.update(squares_to_hilite=squares_to_hilite)
if move is not None:
amodel = self.move_list.treeview.get_model()
aniter = amodel.get_iter(nmove)
gv.gui.set_status_bar_msg("back: (" +str(nmove-1) +"." + amodel.get_value(aniter,1)+ ")")
def __init__(self):
gv.gshogi = self
self.xname = ""
Filefound = False
# set global variables for debug messages
gv.verbose, gv.verbose_usi, gv.show_moves, gv.show_header = utils.get_verbose(
)
# prefix to find package files/folders
self.prefix = utils.get_prefix()
# set up .gshogi directory in the home directory
self.gshogipath = utils.create_settings_dir()
self.glade_dir = os.path.join(self.prefix, "glade")
# get settings saved from previous game
self.settings = utils.get_settings_from_file(self.gshogipath)
# Filename from command line
Startfilename = False
for arg in range(1, len(sys.argv)):
if (sys.argv[arg] != '-v' and sys.argv[arg] != '-vusi'
and sys.argv[arg] != ""):
if (sys.argv[arg].find(":") != -1
or sys.argv[arg].startswith("/")):
Startfilename = True
if Startfilename == True:
self.xname = self.xname + " " + sys.argv[
arg] #single file from command-line
#print (sys.argv[arg] + " "+ str(arg) +" "+ self.xname)
if sys.argv[arg].find(".psn") != -1:
Filefound = True
break
if sys.argv[arg].find(".gshog") != -1:
Filefound = True
break
self.xname = self.xname.strip()
if gv.verbose == True:
print("Filename read: " + self.xname + " File:" +
str(Filefound) + " " + VERSION)
self.ask_before_promoting = False
self.gameover = False
self.time_limit = "00:10"
self.stopped = True
self.quitting = False
self.src = ""
self.src_x = ""
self.src_y = ""
self.startpos = "startpos"
self.start_stm = BLACK
self.search_depth = 39
self.thinking = False
self.cmove = "none"
self.movelist = []
self.lastmove = ""
self.redolist = []
self.player = ["Human", "gshogi"]
self.pondermove = [None, None]
opening_book_path = os.path.join(self.prefix, "data/opening.bbk")
engine.init(opening_book_path, gv.verbose)
gv.gui = gui.Gui()
gv.pieces = pieces.Pieces()
# custom pieceset path
if self.settings != "":
gv.pieces.set_custom_pieceset_path(
self.settings.custom_pieceset_path)
gv.pieces.load_pieces(self.prefix)
# usiw is the instance that plays white (gote)
# usib is the instance that plays black (sente)
gv.usib = usi.Usi("b")
gv.usiw = usi.Usi("w")
# instantiate board, gui, classes
gv.tc = time_control.Time_Control()
gv.engine_manager = engine_manager.Engine_Manager()
gv.board = board.Board()
gv.set_board_colours = set_board_colours.Set_Board_Colours(self.prefix)
# set colours to previous game (if any)
if self.settings != "":
gv.set_board_colours.restore_colour_settings(
self.settings.colour_settings)
gv.gui.build_gui()
gv.board.build_board()
self.engine_output = engine_output.get_ref()
# set level
command = "level 0 " + self.time_limit
engine.command(command)
# turn off beeps
if not BEEP:
engine.command("beep")
# restore users settings to values from previous game
self.restore_settings(self.settings)
gv.usib.set_engine(self.player[BLACK], None)
gv.usiw.set_engine(self.player[WHITE], None)
gv.gui.update_toolbar(self.player)
self.move_list = move_list.get_ref()
gv.tc.reset_clock()
gv.gui.enable_go_button()
gv.gui.disable_stop_button()
self.stm = self.get_side_to_move()
self.timer_active = False
gv.set_board_colours.apply_colour_settings()
if Filefound == True:
gv.lastdir = os.path.dirname(self.xname)
# single file from command-line
gv.gui.load_save.load_game_parm(self.xname)
def computer_move(self):
try:
self.thinking = True
while True:
self.thinking = True
self.stm = self.get_side_to_move()
# update time for last move
# gv.tc.update_clock()
GLib.idle_add(gv.gui.set_side_to_move, self.stm)
# set clock ready for move to come
# gv.tc.start_clock(self.stm)
if gv.verbose:
print("#")
print(("# " + self.get_side_to_move_string(self.stm) +
" to move"))
print("#")
if self.player[self.stm] == "Human":
GLib.idle_add(gv.gui.apply_drag_and_drop_settings,
self.player[self.stm], self.stm)
self.thinking = False
gv.tc.start_clock(self.stm)
return
t_start = time.time()
if self.player[self.stm] != "gshogi":
if self.stm == BLACK:
self.usi = gv.usib
# usi_opponent = self.usiw
# opponent_stm = WHITE
else:
self.usi = gv.usiw
# usi_opponent = self.usib
# opponent_stm = BLACK
ponder_enabled = gv.engine_manager.get_ponder()
if not ponder_enabled:
# get engines move
self.cmove, self.pondermove[self.stm] = self.usi.cmove(
self.movelist, self.stm)
else:
# pondering
ponderhit = False
if (self.pondermove[self.stm] is not None
and len(self.movelist) > 0):
if (self.movelist[-1] == self.pondermove[self.stm]
):
ponderhit = True
if ponderhit:
# ponderhit, wait for return of bestmove and
# pondermove
self.cmove, self.pondermove[self.stm] = \
self.usi.send_ponderhit(self.stm)
else:
if self.pondermove[self.stm] is not None:
# stop ponder, wait for return of bestmove and
# pondermove from ponder
bm, pm = self.usi.stop_ponder()
# get engines move
self.cmove, self.pondermove[self.stm] = \
self.usi.cmove(self.movelist, self.stm)
# start pondering
if self.pondermove[self.stm] is not None:
# send position and ponder command,
# return immediately
self.usi.start_ponder(self.pondermove[self.stm],
self.movelist, self.cmove)
if self.stopped or self.cmove is None:
self.thinking = False
return
if gv.verbose:
print("computer move is", self.cmove)
# check if player resigned
if self.cmove == "resign":
if gv.verbose:
print("computer resigned")
self.gameover = True
self.thinking = False
colour = self.get_side_to_move_string(self.stm)
msg = _(" game over - ") + colour + _(" resigned")
GLib.idle_add(self.stop)
GLib.idle_add(gv.gui.set_status_bar_msg, msg)
self.automatic_comment(self.cmove + ": " + _(msg),
len(self.movelist))
self.thinking = False
return
# engine.setplayer(WHITE)
engine.setplayer(self.stm)
validmove = engine.hmove(self.cmove)
if (not validmove):
GLib.idle_add(self.stop)
GLib.idle_add(
gv.gui.set_status_bar_msg,
self.cmove + _(" - computer made illegal Move!"))
self.gameover = True
self.thinking = False
self.automatic_comment(
self.cmove + _(" - computer made illegal Move!"),
len(self.movelist))
return
if gv.verbose:
engine.command("bd")
else:
if gv.verbose:
print("using gshogi builtin engine")
#
# We are using the builtin gshogi engine (not a USI engine)
#
if self.player[self.stm ^ 1] == "Human":
GLib.idle_add(gv.gui.set_status_bar_msg,
_("Thinking ..."))
# set the computer to black or white
engine.setplayer(self.stm ^ 1)
# start the clock
# print "starting clock from gshogi.py"
gv.tc.start_clock(self.stm)
# set time limit/level for move in gshogi engine
gv.tc.set_gshogi_time_limit(self.stm)
# call the gshogi engine to do the move
self.cmove = engine.cmove()
# update time for last move
# print "updating clock from gshogi.py"
GLib.idle_add(gv.tc.update_clock)
# if the engine moved very fast then wait a bit
# before displaying the move. The time to wait
# is in MIN_MOVETIME in constants.py
t_end = time.time()
move_t = t_end - t_start
if move_t < MIN_MOVETIME:
diff = MIN_MOVETIME - move_t
time.sleep(diff)
GLib.idle_add(gv.gui.set_side_to_move, self.stm)
if self.quitting:
return
if self.stopped:
self.thinking = False
GLib.idle_add(gv.gui.set_status_bar_msg, _("stopped"))
engine.command("undo")
return
if self.cmove != "":
self.movelist.append(self.cmove)
self.redolist = []
self.lastmove = self.cmove
else:
# empty move is returned by gshogi engine when it is in
# checkmate
if gv.verbose:
print("empty move returned by engine")
# if program is exitting then quit this thread asap
if self.quitting:
return
# gv.board.save_board(len(self.movelist))
# show computer move
GLib.idle_add(gv.board.update)
GLib.idle_add(self.move_list.update)
# if self.player[self.stm] != "gshogi"
# and gv.engine_manager.get_ponder():
# self.usi.send_ponder()
# # self.ctp= thread.start_new_thread(
# self.usi.send_ponder, () )
if gv.verbose:
engine.command("bd")
if gv.verbose:
print("move=", self.cmove)
msg = self.cmove
self.gameover, gmsg = self.check_for_gameover()
if (self.gameover):
msg = self.get_side_to_move_string(self.stm) + ": "
msg = msg + gmsg
self.thinking = False
self.stm = self.get_side_to_move()
GLib.idle_add(self.stop)
GLib.idle_add(gv.gui.set_side_to_move, self.stm)
GLib.idle_add(gv.gui.set_status_bar_msg, msg)
self.automatic_comment(msg, len(self.movelist))
return
msg = self.get_side_to_move_string(self.stm) + ": " + str(
len(self.movelist)) + ". " + msg
GLib.idle_add(gv.gui.set_status_bar_msg, msg)
# give gui time to update the board
time.sleep(0.1)
self.thinking = False
except:
traceback.print_exc()
return
def set_gshogi_time_limit(self, stm):
#
# set engine depth/nodes/time to maximum
#
engine.depth(39)
engine.nodes(0)
engine.command("level 0 59:59")
# byoyomi
if self.type == 0:
if stm == WHITE:
gs_movetime = self.wtime
else:
gs_movetime = self.btime
gs_byoyomi = self.byo_byoyomi * 1000
if gs_movetime > 0:
gs_movetime = int(gs_movetime / 80)
elif gs_byoyomi > 0:
gs_movetime = gs_byoyomi
else:
# no time left - set to 1 second
gs_movetime = 1000
# if less than 1 second set to 1 second
if gs_movetime < 1000:
gs_movetime = 1000
gs_secs = int(gs_movetime / 1000)
gs_mins = int(gs_secs / 60)
if gs_mins > 59:
gs_mins = 59
gs_secs = 59
elif gs_mins > 0:
gs_secs = gs_secs % (gs_mins * 60)
gs_mins = int(gs_mins)
gs_secs = int(gs_secs)
gs_mins_str = str(gs_mins)
gs_secs_str = str(gs_secs)
if gs_mins < 10:
gs_mins_str = "0" + gs_mins_str
if gs_secs < 10:
gs_secs_str = "0" + gs_secs_str
gs_level = gs_mins_str + ":" + gs_secs_str
if gv.verbose:
print(("using byoyomi TC - wtime:", self.wtime, ", btime:",
self.btime, ", byoyomi:", self.byo_byoyomi * 1000,
", stm:", stm, ", time for move (ms):", gs_movetime))
command = "level 0 " + gs_level
# print "gshogi time limit:",command
# e.g.
# time limit of 10 seconds per move
# level 0 00:10
#
# time limit of 10 moves in 2 minutes
# level 10 2
engine.command(command)
# classical
elif self.type == 1:
if stm == WHITE:
gs_movetime = self.wtime
else:
gs_movetime = self.btime
# if less than 1 second set to 1 second
if gs_movetime < 1000:
gs_movetime = 1000
gs_secs = int(gs_movetime / 1000)
gs_mins = int(gs_secs / 60)
if gs_mins > 0:
gs_secs = gs_secs % (gs_mins * 60)
gs_mins = int(gs_mins)
gs_secs = int(gs_secs)
gs_mins_str = str(gs_mins)
gs_secs_str = str(gs_secs)
if gs_mins < 10:
gs_mins_str = "0" + gs_mins_str
if gs_secs < 10:
gs_secs_str = "0" + gs_secs_str
gs_level = gs_mins_str + ":" + gs_secs_str
if gv.verbose:
print(("using classical TC - wtime:", self.wtime, ", btime:",
self.btime, ", movestogo:", str(self.wmoves_to_go),
", stm:", stm, ", time for move (ms):", gs_movetime))
print((" - ", str(self.wmoves_to_go),
" moves in ", gs_mins_str, "minutes", gs_secs_str,
" seconds"))
if self.wmoves_to_go == 1:
command = "level 0 " + gs_level
else:
command = "level " + str(self.wmoves_to_go) + " " + gs_level
engine.command(command)
# incremental
elif self.type == 2:
if stm == WHITE:
gs_movetime = self.wtime
else:
gs_movetime = self.btime
if gs_movetime > 0:
gs_movetime = int(gs_movetime / 80)
else:
# no time left - set to 1 second
gs_movetime = 1000
gs_secs = int(gs_movetime / 1000)
gs_mins = int(gs_secs / 60)
if gs_mins > 0:
gs_secs = gs_secs % (gs_mins * 60)
gs_mins = int(gs_mins)
gs_secs = int(gs_secs)
if gs_mins <= 0 and gs_secs < 1:
gs_secs = 1
gs_mins_str = str(gs_mins)
gs_secs_str = str(gs_secs)
if gs_mins < 10:
gs_mins_str = "0" + gs_mins_str
if gs_secs < 10:
gs_secs_str = "0" + gs_secs_str
gs_level = gs_mins_str + ":" + gs_secs_str
if gv.verbose:
print(("using incremental TC - wtime:", self.wtime, ", btime:",
self.btime, ", winc/binc:", str(self.inc_bonus * 1000),
", stm:", stm, ", time for move (ms):", gs_movetime))
command = "level 0 " + gs_level
engine.command(command)
# fixed time per move
elif self.type == 3:
gs_movetime = self.ftpm_seconds * 1000
gs_secs = int(gs_movetime / 1000)
gs_mins = int(gs_secs / 60)
if gs_mins > 0:
gs_secs = gs_secs % (gs_mins * 60)
gs_mins = int(gs_mins)
gs_secs = int(gs_secs)
if gs_mins <= 0 and gs_secs < 1:
gs_secs = 1
gs_mins_str = str(gs_mins)
gs_secs_str = str(gs_secs)
if gs_mins < 10:
gs_mins_str = "0" + gs_mins_str
if gs_secs < 10:
gs_secs_str = "0" + gs_secs_str
gs_level = gs_mins_str + ":" + gs_secs_str
if gv.verbose:
print(("using fixed time per move TC - wtime:", self.wtime,
", btime:", self.btime, " stm:", stm,
", time for move (ms):", gs_movetime))
command = "level 0 " + gs_level
engine.command(command)
# fixed search depth
elif self.type == 4:
idepth = self.dpth_depth
if idepth > 39:
if gv.verbose:
print(("search depth (", idepth,
") exceeds max for gshogi engine, setting to 39"))
idepth = 39
if gv.verbose:
print("setting depth for gshogi engine to", idepth)
engine.depth(idepth)
# fixed nodes search
elif self.type == 6:
inodes = self.nodes_nodes
if gv.verbose:
print("setting nodes for gshogi engine to", inodes)
print("time=", time.time())
engine.nodes(inodes)
command = "level 0 59:59"
engine.command(command)
def load_game_psn_from_str(self, gamestr):
cnt = 0
comment_active = False
movelist = []
redolist = []
startpos = "startpos"
engine.command("new")
stm = BLACK
moveread = 0
movecnt = 0
self.gamestr = gamestr
self.game_len = len(self.gamestr)
self.comments.clear_comments()
# First header should be near the start of the file
# Note the first chars in the file may be a BOM entry and
# we need to skip these
ptr = 0
# Find "[" of first header
while 1:
if ptr >= self.game_len or ptr > 2000:
gv.gui.info_box("Error (1) loading file. No headers found")
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1
if gamestr[ptr] == "[":
break
ptr += 1
# First Header found (ptr pointing at "[")
hdr, newptr = self.get_header(ptr)
if hdr is None:
gv.gui.info_box("Error (2) loading file. No headers found")
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1
# Read remaining headers
while hdr is not None:
ptr = newptr
try:
prop, value = hdr.split(None, 1)
except ValueError:
# Error - cannot split header into a property/value pair
gv.gui.info_box("Error loading file. Invalid header:" + hdr)
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1
if prop == "SFEN":
# set board position, side to move
startpos, stm, moveread = self.process_sfen(value) #moveread from position
elif prop == "Handicap":
handicap = value.strip('"')
handicap = handicap.lower()
sfen = ""
if handicap == "lance":
sfen = "lnsgkgsn1/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "bishop":
sfen = "lnsgkgsnl/1r7/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "rook":
sfen = "lnsgkgsnl/7b1/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "rook+lance":
sfen = "lnsgkgsn1/7b1/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "rook+bishop":
sfen = "lnsgkgsnl/9/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "four piece":
sfen = "1nsgkgsn1/9/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "six piece":
sfen = "2sgkgs2/9/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "eight piece":
sfen = "3gkg3/9/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "ten piece":
sfen = "4k4/9/ppppppppp/9/9/9/PPPPPPPPP/" \
"B5R1/LNSGKGSNL w - 1"
elif handicap == "three pawn":
sfen = "4k4/9/9/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 3p 1"
if sfen != "":
startpos, stm, moveread= self.process_sfen(sfen)
hdr, newptr = self.get_header(ptr)
# Moves
lastmove = ""
while 1:
if gv.verbose:
print()
print("Processing move number (ply):" + str(movecnt + 1))
newptr = self.skip_whitespace(ptr)
if newptr is None:
break
ptr = newptr
# if we get a header here then it must be a multi-game file
# We cannot process multi-game so treat it as eof and exit
if gamestr[ptr] == "[":
break
# Check for stuff to ignore
# ignore it and continue processing
ignore_string, newptr = self.get_ignore_string(ptr)
if ignore_string is not None:
# Can get "1...." to indicate white to move first
# if ignore_string == "1...." and movecnt == 0:
# # Use sfen for initial position but set stm to white
# startpos, stm = self.process_sfen(
# "lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/" \
# "1B5R1/LNSGKGSNL w - 1")
ptr = newptr
continue
# comment
if self.gamestr[ptr] == "{":
comment = ""
ptr += 1
while 1:
if ptr >= self.game_len:
gv.gui.info_box("Error unterminated comment")
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1 # end of file before end of comment
if self.gamestr[ptr] == "}":
ptr += 1
break
comment += self.gamestr[ptr]
ptr += 1
# add comment
self.comments.set_comment(movecnt, comment)
continue
# move number
# we do not use it
moveno, newptr = self.get_moveno(ptr)
if moveno is not None:
ptr = newptr
continue
# move
move, newptr = self.get_move(ptr, movelist, stm)
if move is not None:
ptr = newptr
engine.setplayer(stm)
stm = stm ^ 1
if gv.verbose:
print("move=", move)
validmove = engine.hmove(move)
if (not validmove):
# Should never get this message since get_move has already
# validated the move aginst the legal move list
# Can get it for sennichite (repetition)
gv.gui.info_box(
"Error loading file, illegal move (possible "
"sennichite (repetition)):" + move + " move number:" +
str(movecnt + 1))
#gv.gshogi.new_game("NewGame")
#gv.gui.set_status_bar_msg("Error loading game")
#return 1
movecnt += 1
movelist.append(move)
lastmove = move
if gv.verbose:
engine.command("bd")
continue
# Invalid - Display Error
# If we get here we have an invalid word
# Errors here will stop the processing and prevent the file loading
# If the invalid word should be skipped instead then add it to the
# ignore processing above
word, newptr = self.get_word(ptr)
if word is not None:
gv.gui.info_box(
"Error loading file, unable to process move number " +
str(movecnt + 1) + ". (illegal move or invalid format):" +
word)
# Load failed part way through so reset the game
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1
ptr += 1
gv.usib.set_newgame()
gv.usiw.set_newgame()
gv.gui.set_status_bar_msg("game loaded")
self.gameover = False
gv.gshogi.set_movelist(movelist)
gv.gshogi.set_redolist(redolist)
gv.gshogi.set_startpos(startpos)
gv.gshogi.set_lastmove(lastmove)
gv.board.update()
# update move list in move list window
self.move_list.update()
stm = gv.gshogi.get_side_to_move()
gv.gshogi.set_side_to_move(stm)
gv.gui.set_side_to_move(stm)
gv.tc.reset_clock()
return 0
def set_gshogi_time_limit(self, stm):
#
# set engine depth/nodes/time to maximum
#
engine.depth(39)
engine.nodes(0)
engine.command("level 0 59:59")
# byoyomi
if self.type == 0:
if stm == WHITE:
gs_movetime = self.wtime
else:
gs_movetime = self.btime
gs_byoyomi = self.byo_byoyomi * 1000
if gs_movetime > 0:
gs_movetime = int(gs_movetime / 80)
elif gs_byoyomi > 0:
gs_movetime = gs_byoyomi
else:
# no time left - set to 1 second
gs_movetime = 1000
# if less than 1 second set to 1 second
if gs_movetime < 1000:
gs_movetime = 1000
gs_secs = int(gs_movetime / 1000)
gs_mins = int(gs_secs / 60)
if gs_mins > 59:
gs_mins = 59
gs_secs = 59
elif gs_mins > 0:
gs_secs = gs_secs % (gs_mins * 60)
gs_mins = int(gs_mins)
gs_secs = int(gs_secs)
gs_mins_str = str(gs_mins)
gs_secs_str = str(gs_secs)
if gs_mins < 10:
gs_mins_str = "0" + gs_mins_str
if gs_secs < 10:
gs_secs_str = "0" + gs_secs_str
gs_level = gs_mins_str + ":" + gs_secs_str
if gv.verbose:
print(("using byoyomi TC - wtime:", self.wtime, ", btime:",
self.btime, ", byoyomi:", self.byo_byoyomi * 1000,
", stm:", stm, ", time for move (ms):", gs_movetime))
command = "level 0 " + gs_level
# print "gshogi time limit:",command
# e.g.
# time limit of 10 seconds per move
# level 0 00:10
#
# time limit of 10 moves in 2 minutes
# level 10 2
engine.command(command)
# classical
elif self.type == 1:
if stm == WHITE:
gs_movetime = self.wtime
else:
gs_movetime = self.btime
# if less than 1 second set to 1 second
if gs_movetime < 1000:
gs_movetime = 1000
gs_secs = int(gs_movetime / 1000)
gs_mins = int(gs_secs / 60)
if gs_mins > 0:
gs_secs = gs_secs % (gs_mins * 60)
gs_mins = int(gs_mins)
gs_secs = int(gs_secs)
gs_mins_str = str(gs_mins)
gs_secs_str = str(gs_secs)
if gs_mins < 10:
gs_mins_str = "0" + gs_mins_str
if gs_secs < 10:
gs_secs_str = "0" + gs_secs_str
gs_level = gs_mins_str + ":" + gs_secs_str
if gv.verbose:
print(("using classical TC - wtime:", self.wtime, ", btime:",
self.btime, ", movestogo:", str(self.wmoves_to_go),
", stm:", stm, ", time for move (ms):", gs_movetime))
print((" - ", str(self.wmoves_to_go),
" moves in ", gs_mins_str, "minutes", gs_secs_str,
" seconds"))
if self.wmoves_to_go == 1:
command = "level 0 " + gs_level
else:
command = "level " + str(self.wmoves_to_go) + " " + gs_level
engine.command(command)
# incremental
elif self.type == 2:
if stm == WHITE:
gs_movetime = self.wtime
else:
gs_movetime = self.btime
if gs_movetime > 0:
gs_movetime = int(gs_movetime / 80)
else:
# no time left - set to 1 second
gs_movetime = 1000
gs_secs = int(gs_movetime / 1000)
gs_mins = int(gs_secs / 60)
if gs_mins > 0:
gs_secs = gs_secs % (gs_mins * 60)
gs_mins = int(gs_mins)
gs_secs = int(gs_secs)
if gs_mins <= 0 and gs_secs < 1:
gs_secs = 1
gs_mins_str = str(gs_mins)
gs_secs_str = str(gs_secs)
if gs_mins < 10:
gs_mins_str = "0" + gs_mins_str
if gs_secs < 10:
gs_secs_str = "0" + gs_secs_str
gs_level = gs_mins_str + ":" + gs_secs_str
if gv.verbose:
print(("using incremental TC - wtime:", self.wtime, ", btime:",
self.btime, ", winc/binc:", str(self.inc_bonus * 1000),
", stm:", stm, ", time for move (ms):", gs_movetime))
command = "level 0 " + gs_level
engine.command(command)
# fixed time per move
elif self.type == 3:
gs_movetime = self.ftpm_seconds * 1000
gs_secs = int(gs_movetime / 1000)
gs_mins = int(gs_secs / 60)
if gs_mins > 0:
gs_secs = gs_secs % (gs_mins * 60)
gs_mins = int(gs_mins)
gs_secs = int(gs_secs)
if gs_mins <= 0 and gs_secs < 1:
gs_secs = 1
gs_mins_str = str(gs_mins)
gs_secs_str = str(gs_secs)
if gs_mins < 10:
gs_mins_str = "0" + gs_mins_str
if gs_secs < 10:
gs_secs_str = "0" + gs_secs_str
gs_level = gs_mins_str + ":" + gs_secs_str
if gv.verbose:
print(("using fixed time per move TC - wtime:", self.wtime,
", btime:", self.btime, " stm:", stm,
", time for move (ms):", gs_movetime))
command = "level 0 " + gs_level
engine.command(command)
# fixed search depth
elif self.type == 4:
idepth = self.dpth_depth
if idepth > 39:
if gv.verbose:
print(("search depth (", idepth,
") exceeds max for gshogi engine, setting to 39"))
idepth = 39
if gv.verbose:
print("setting depth for gshogi engine to", idepth)
engine.depth(idepth)
# fixed nodes search
elif self.type == 6:
inodes = self.nodes_nodes
if gv.verbose:
print("setting nodes for gshogi engine to", inodes)
print("time=", time.time())
engine.nodes(inodes)
command = "level 0 59:59"
engine.command(command)
def new_game(self, menu_name):
self.gameover = False
engine.command("new")
if menu_name == "NewGame":
# Normal Game (No handicap)
self.startpos = "startpos"
self.start_stm = BLACK
else:
# Handicap Game
self.start_stm = WHITE
if menu_name == "LanceHandicap":
sfen = "lnsgkgsn1/1r5b1/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "BishopHandicap":
sfen = "lnsgkgsnl/1r7/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "RookHandicap":
sfen = "lnsgkgsnl/7b1/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "RookandLanceHandicap":
sfen = "lnsgkgsn1/7b1/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "TwoPieceHandicap":
sfen = "lnsgkgsnl/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "FourPieceHandicap":
sfen = "1nsgkgsn1/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "SixPieceHandicap":
sfen = "2sgkgs2/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "EightPieceHandicap":
sfen = "3gkg3/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "TenPieceHandicap":
sfen = "4k4/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "ThreePawnHandicap":
sfen = "4k4/9/9/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w 3p - 1"
else:
gv.gui.info_box("Error. Invalid menu name:" + menu_name)
return
engine.setfen(sfen)
self.startpos = sfen
self.movelist = [] #mandatory
gv.board.update()
# update move list in move list window
self.move_list.update()
# clean comments (bugfix)
self.move_list.comments.clear_comments()
if not BEEP:
engine.command("beep")
gv.usib.set_newgame()
gv.usiw.set_newgame()
self.movelist = []
self.redolist = []
#gv.gui.movestore.clear() #kills move-box!!!!!!!!!!!!!!!!!!!!!!!!!!111
self.lastmove = ""
#clear comment-and move windows
#self.move_list.comments.automatic_comment("") # just a Test
#print("test")
if gv.show_moves == True:
start, end =gv.gui.comment_view.get_buffer().get_bounds()
gv.gui.comment_view.get_buffer().delete(start,end)
gv.gui.comment_view.get_buffer().insert(start,"-")
gv.gui.move_view.get_model().clear()
gv.gui.set_status_bar_msg("")
self.stm = self.get_side_to_move()
gv.gui.set_side_to_move(self.stm)
gv.tc.reset_clock()
gv.event = "##"
gv.gamedate = str(date.today().day) +"."+str(date.today().month)+"."+str(date.today().year)
gv.gote = self.player[BLACK]
gv.sente = self.player[WHITE]
if gv.show_header == True:
GLib.idle_add(gv.gui.header_lblsente.set_text, "")
GLib.idle_add(gv.gui.header_lblgote.set_text,"")
GLib.idle_add(gv.gui.header_lblevent.set_text, "")
GLib.idle_add(gv.gui.header_lbldate.set_text, "")
def __init__(self):
gv.gshogi = self
self.xname = ""
Filefound = False
# set global variables for debug messages
gv.verbose, gv.verbose_usi, gv.show_moves, gv.show_header = utils.get_verbose()
# prefix to find package files/folders
self.prefix = utils.get_prefix()
# set up .gshogi directory in the home directory
self.gshogipath = utils.create_settings_dir()
self.glade_dir = os.path.join(self.prefix, "glade")
# get settings saved from previous game
self.settings = utils.get_settings_from_file(self.gshogipath)
# Filename from command line
Startfilename = False
for arg in range(1, len(sys.argv)):
if (sys.argv[arg] != '-v' and sys.argv[arg] != '-vusi' and sys.argv[arg] !=""):
if (sys.argv[arg].find(":")!= -1 or sys.argv[arg].startswith("/")) :
Startfilename = True
if Startfilename == True:
self.xname = self.xname + " " + sys.argv[arg] #single file from command-line
#print (sys.argv[arg] + " "+ str(arg) +" "+ self.xname)
if sys.argv[arg].find(".psn") != -1:
Filefound = True
break
if sys.argv[arg].find(".gshog") != -1:
Filefound = True
break
self.xname = self.xname.strip()
if gv.verbose == True :
print("Filename read: " + self.xname + " File:"+ str(Filefound) +" "+VERSION)
self.ask_before_promoting = False
self.gameover = False
self.time_limit = "00:10"
self.stopped = True
self.quitting = False
self.src = ""
self.src_x = ""
self.src_y = ""
self.startpos = "startpos"
self.start_stm = BLACK
self.search_depth = 39
self.thinking = False
self.cmove = "none"
self.movelist = []
self.lastmove = ""
self.redolist = []
self.player = ["Human", "gshogi"]
self.pondermove = [None, None]
opening_book_path = os.path.join(self.prefix, "data/opening.bbk")
engine.init(opening_book_path, gv.verbose)
gv.gui = gui.Gui()
gv.pieces = pieces.Pieces()
# custom pieceset path
if self.settings != "":
gv.pieces.set_custom_pieceset_path(
self.settings.custom_pieceset_path)
gv.pieces.load_pieces(self.prefix)
# usiw is the instance that plays white (gote)
# usib is the instance that plays black (sente)
gv.usib = usi.Usi("b")
gv.usiw = usi.Usi("w")
# instantiate board, gui, classes
gv.tc = time_control.Time_Control()
gv.engine_manager = engine_manager.Engine_Manager()
gv.board = board.Board()
gv.set_board_colours = set_board_colours.Set_Board_Colours(self.prefix)
# set colours to previous game (if any)
if self.settings != "":
gv.set_board_colours.restore_colour_settings(
self.settings.colour_settings)
gv.gui.build_gui()
gv.board.build_board()
self.engine_output = engine_output.get_ref()
# set level
command = "level 0 " + self.time_limit
engine.command(command)
# turn off beeps
if not BEEP:
engine.command("beep")
# restore users settings to values from previous game
self.restore_settings(self.settings)
gv.usib.set_engine(self.player[BLACK], None)
gv.usiw.set_engine(self.player[WHITE], None)
gv.gui.update_toolbar(self.player)
self.move_list = move_list.get_ref()
gv.tc.reset_clock()
gv.gui.enable_go_button()
gv.gui.disable_stop_button()
self.stm = self.get_side_to_move()
self.timer_active = False
gv.set_board_colours.apply_colour_settings()
if Filefound==True:
gv.lastdir = os.path.dirname(self.xname)
# single file from command-line
gv.gui.load_save.load_game_parm(self.xname)
def __init__(self):
gv.gshogi = self
# set global variables for debug messages
gv.verbose, gv.verbose_usi = utils.get_verbose()
# prefix to find package files/folders
self.prefix = utils.get_prefix()
# set up .gshogi directory in the home directory
self.gshogipath = utils.create_settings_dir()
self.glade_dir = os.path.join(self.prefix, "glade")
# get settings saved from previous game
self.settings = utils.get_settings_from_file(self.gshogipath)
self.ask_before_promoting = False
self.gameover = False
self.time_limit = "00:10"
self.stopped = True
self.quitting = False
self.src = ""
self.src_x = ""
self.src_y = ""
self.startpos = "startpos"
self.start_stm = BLACK
self.search_depth = 39
self.thinking = False
self.cmove = "none"
self.movelist = []
self.lastmove = ""
self.redolist = []
self.player = ["Human", "gshogi"]
self.pondermove = [None, None]
opening_book_path = os.path.join(self.prefix, "data/opening.bbk")
engine.init(opening_book_path, gv.verbose)
gv.gui = gui.Gui()
gv.pieces = pieces.Pieces()
# custom pieceset path
if self.settings != "":
gv.pieces.set_custom_pieceset_path(
self.settings.custom_pieceset_path)
gv.pieces.load_pieces(self.prefix)
# usiw is the instance that plays white (gote)
# usib is the instance that plays black (sente)
gv.usib = usi.Usi("b")
gv.usiw = usi.Usi("w")
# instantiate board, gui, classes
gv.tc = time_control.Time_Control()
gv.engine_manager = engine_manager.Engine_Manager()
gv.board = board.Board()
gv.set_board_colours = set_board_colours.Set_Board_Colours(self.prefix)
# set colours to previous game (if any)
if self.settings != "":
gv.set_board_colours.restore_colour_settings(
self.settings.colour_settings)
gv.gui.build_gui()
gv.board.build_board()
self.engine_output = engine_output.get_ref()
# set level
command = "level 0 " + self.time_limit
engine.command(command)
# turn off beeps
if not BEEP:
engine.command("beep")
# restore users settings to values from previous game
self.restore_settings(self.settings)
gv.usib.set_engine(self.player[BLACK], None)
gv.usiw.set_engine(self.player[WHITE], None)
gv.gui.update_toolbar(self.player)
self.move_list = move_list.get_ref()
gv.tc.reset_clock()
gv.gui.enable_go_button()
gv.gui.disable_stop_button()
self.stm = self.get_side_to_move()
self.timer_active = False
gv.set_board_colours.apply_colour_settings()
def new_game(self, menu_name):
self.gameover = False
engine.command("new")
if menu_name == "NewGame":
# Normal Game (No handicap)
self.startpos = "startpos"
self.start_stm = BLACK
else:
# Handicap Game
self.start_stm = WHITE
if menu_name == "LanceHandicap":
sfen = "lnsgkgsn1/1r5b1/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "BishopHandicap":
sfen = "lnsgkgsnl/1r7/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "RookHandicap":
sfen = "lnsgkgsnl/7b1/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "RookandLanceHandicap":
sfen = "lnsgkgsn1/7b1/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "TwoPieceHandicap":
sfen = "lnsgkgsnl/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "FourPieceHandicap":
sfen = "1nsgkgsn1/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "SixPieceHandicap":
sfen = "2sgkgs2/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "EightPieceHandicap":
sfen = "3gkg3/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "TenPieceHandicap":
sfen = "4k4/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "ThreePawnHandicap":
sfen = "4k4/9/9/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w 3p - 1"
else:
gv.gui.info_box("Error. Invalid menu name:" + menu_name)
return
engine.setfen(sfen)
self.startpos = sfen
self.movelist = [] #mandatory
gv.board.update()
# update move list in move list window
self.move_list.update()
# clean comments (bugfix)
self.move_list.comments.clear_comments()
if not BEEP:
engine.command("beep")
gv.usib.set_newgame()
gv.usiw.set_newgame()
self.movelist = []
self.redolist = []
#gv.gui.movestore.clear() #kills move-box!!!!!!!!!!!!!!!!!!!!!!!!!!111
self.lastmove = ""
#clear comment-and move windows
#self.move_list.comments.automatic_comment("") # just a Test
#print("test")
if gv.show_moves == True:
start, end = gv.gui.comment_view.get_buffer().get_bounds()
gv.gui.comment_view.get_buffer().delete(start, end)
gv.gui.comment_view.get_buffer().insert(start, "-")
gv.gui.move_view.get_model().clear()
gv.gui.set_status_bar_msg("")
self.stm = self.get_side_to_move()
gv.gui.set_side_to_move(self.stm)
gv.tc.reset_clock()
gv.event = "##"
gv.gamedate = str(date.today().day) + "." + str(
date.today().month) + "." + str(date.today().year)
gv.gote = self.player[BLACK]
gv.sente = self.player[WHITE]
if gv.show_header == True:
GLib.idle_add(gv.gui.header_lblsente.set_text, "")
GLib.idle_add(gv.gui.header_lblgote.set_text, "")
GLib.idle_add(gv.gui.header_lblevent.set_text, "")
GLib.idle_add(gv.gui.header_lbldate.set_text, "")
def new_game(self, menu_name):
self.gameover = False
engine.command("new")
if menu_name == "NewGame":
# Normal Game (No handicap)
self.startpos = "startpos"
self.start_stm = BLACK
else:
# Handicap Game
self.start_stm = WHITE
if menu_name == "LanceHandicap":
sfen = "lnsgkgsn1/1r5b1/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "BishopHandicap":
sfen = "lnsgkgsnl/1r7/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "RookHandicap":
sfen = "lnsgkgsnl/7b1/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "RookandLanceHandicap":
sfen = "lnsgkgsn1/7b1/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "TwoPieceHandicap":
sfen = "lnsgkgsnl/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "FourPieceHandicap":
sfen = "1nsgkgsn1/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "SixPieceHandicap":
sfen = "2sgkgs2/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "EightPieceHandicap":
sfen = "3gkg3/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
elif menu_name == "TenPieceHandicap":
sfen = "4k4/9/ppppppppp/9/9/9/" \
"PPPPPPPPP/1B5R1/LNSGKGSNL w - 1"
else:
gv.gui.info_box("Error. Invalid menu name:" + menu_name)
return
engine.setfen(sfen)
self.startpos = sfen
gv.board.update()
# update move list in move list window
self.move_list.update()
if not BEEP:
engine.command("beep")
gv.usib.set_newgame()
gv.usiw.set_newgame()
self.movelist = []
self.redolist = []
self.lastmove = ""
gv.gui.set_status_bar_msg("")
self.stm = self.get_side_to_move()
gv.gui.set_side_to_move(self.stm)
gv.tc.reset_clock()
def load_game_psn_from_str(self, gamestr):
cnt = 0
comment_active = False
movelist = []
redolist = []
startpos = "startpos"
engine.command("new")
stm = BLACK
movecnt = 0
self.gamestr = gamestr
self.game_len = len(self.gamestr)
self.comments.clear_comments()
# First header should be near the start of the file
# Note the first chars in the file may be a BOM entry and
# we need to skip these
ptr = 0
# Find "[" of first header
while 1:
if ptr >= self.game_len or ptr > 2000:
gv.gui.info_box("Error (1) loading file. No headers found")
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1
if gamestr[ptr] == "[":
break
ptr += 1
# First Header found (ptr pointing at "[")
hdr, newptr = self.get_header(ptr)
if hdr is None:
gv.gui.info_box("Error (2) loading file. No headers found")
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1
# Read remaining headers
while hdr is not None:
ptr = newptr
try:
prop, value = hdr.split(None, 1)
except ValueError:
# Error - cannot split header into a property/value pair
gv.gui.info_box("Error loading file. Invalid header:" + hdr)
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1
if prop == "SFEN":
# set board position, side to move
startpos, stm = self.process_sfen(value)
elif prop == "Handicap":
handicap = value.strip('"')
handicap = handicap.lower()
sfen = ""
if handicap == "lance":
sfen = "lnsgkgsn1/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "bishop":
sfen = "lnsgkgsnl/1r7/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "rook":
sfen = "lnsgkgsnl/7b1/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "rook+lance":
sfen = "lnsgkgsn1/7b1/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "rook+bishop":
sfen = "lnsgkgsnl/9/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "four piece":
sfen = "1nsgkgsn1/9/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "six piece":
sfen = "2sgkgs2/9/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "eight piece":
sfen = "3gkg3/9/ppppppppp/9/9/9/PPPPPPPPP/" \
"1B5R1/LNSGKGSNL w - 1"
elif handicap == "ten piece":
sfen = "4k4/9/ppppppppp/9/9/9/PPPPPPPPP/" \
"B5R1/LNSGKGSNL w - 1"
if sfen != "":
startpos, stm = self.process_sfen(sfen)
hdr, newptr = self.get_header(ptr)
# Moves
lastmove = ""
while 1:
if gv.verbose:
print()
print("Processing move number (ply):" + str(movecnt + 1))
newptr = self.skip_whitespace(ptr)
if newptr is None:
break
ptr = newptr
# if we get a header here then it must be a multi-game file
# We cannot process multi-game so treat it as eof and exit
if gamestr[ptr] == "[":
break
# Check for stuff to ignore
# ignore it and continue processing
ignore_string, newptr = self.get_ignore_string(ptr)
if ignore_string is not None:
# Can get "1...." to indicate white to move first
# if ignore_string == "1...." and movecnt == 0:
# # Use sfen for initial position but set stm to white
# startpos, stm = self.process_sfen(
# "lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/" \
# "1B5R1/LNSGKGSNL w - 1")
ptr = newptr
continue
# comment
if self.gamestr[ptr] == "{":
comment = ""
ptr += 1
while 1:
if ptr >= self.game_len:
gv.gui.info_box("Error unterminated comment")
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1 # end of file before end of comment
if self.gamestr[ptr] == "}":
ptr += 1
break
comment += self.gamestr[ptr]
ptr += 1
# add comment
self.comments.set_comment(movecnt, comment)
continue
# move number
# we do not use it
moveno, newptr = self.get_moveno(ptr)
if moveno is not None:
ptr = newptr
continue
# move
move, newptr = self.get_move(ptr, movelist, stm)
if move is not None:
ptr = newptr
engine.setplayer(stm)
stm = stm ^ 1
if gv.verbose:
print("move=", move)
validmove = engine.hmove(move)
if (not validmove):
# Should never get this message since get_move has already
# validated the move aginst the legal move list
# Can get it for sennichite (repetition)
gv.gui.info_box(
"Error loading file, illegal move (possible "
"sennichite (repetition)):" + move + " move number:" +
str(movecnt + 1))
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1
movecnt += 1
movelist.append(move)
lastmove = move
if gv.verbose:
engine.command("bd")
continue
# Invalid - Display Error
# If we get here we have an invalid word
# Errors here will stop the processing and prevent the file loading
# If the invalid word should be skipped instead then add it to the
# ignore processing above
word, newptr = self.get_word(ptr)
if word is not None:
gv.gui.info_box(
"Error loading file, unable to process move number " +
str(movecnt + 1) + ". (illegal move or invalid format):" +
word)
# Load failed part way through so reset the game
gv.gshogi.new_game("NewGame")
gv.gui.set_status_bar_msg("Error loading game")
return 1
ptr += 1
gv.usib.set_newgame()
gv.usiw.set_newgame()
gv.gui.set_status_bar_msg("game loaded")
self.gameover = False
gv.gshogi.set_movelist(movelist)
gv.gshogi.set_redolist(redolist)
gv.gshogi.set_startpos(startpos)
gv.gshogi.set_lastmove(lastmove)
gv.board.update()
# update move list in move list window
self.move_list.update()
stm = gv.gshogi.get_side_to_move()
gv.gshogi.set_side_to_move(stm)
gv.gui.set_side_to_move(stm)
gv.tc.reset_clock()
return 0
def computer_move(self):
try:
self.thinking = True
while True:
self.thinking = True
self.stm = self.get_side_to_move()
# update time for last move
# gv.tc.update_clock()
GLib.idle_add(gv.gui.set_side_to_move, self.stm)
# set clock ready for move to come
# gv.tc.start_clock(self.stm)
if gv.verbose:
print("#")
print(("# " + self.get_side_to_move_string(self.stm) +
" to move"))
print("#")
if self.player[self.stm] == "Human":
GLib.idle_add(gv.gui.apply_drag_and_drop_settings,
self.player[self.stm], self.stm)
self.thinking = False
gv.tc.start_clock(self.stm)
return
t_start = time.time()
if self.player[self.stm] != "gshogi":
if self.stm == BLACK:
self.usi = gv.usib
# usi_opponent = self.usiw
# opponent_stm = WHITE
else:
self.usi = gv.usiw
# usi_opponent = self.usib
# opponent_stm = BLACK
ponder_enabled = gv.engine_manager.get_ponder()
if not ponder_enabled:
# get engines move
self.cmove, self.pondermove[self.stm] = self.usi.cmove(
self.movelist, self.stm)
else:
# pondering
ponderhit = False
if (self.pondermove[self.stm] is not None and
len(self.movelist) > 0):
if (self.movelist[-1] ==
self.pondermove[self.stm]):
ponderhit = True
if ponderhit:
# ponderhit, wait for return of bestmove and
# pondermove
self.cmove, self.pondermove[self.stm] = \
self.usi.send_ponderhit(self.stm)
else:
if self.pondermove[self.stm] is not None:
# stop ponder, wait for return of bestmove and
# pondermove from ponder
bm, pm = self.usi.stop_ponder()
# get engines move
self.cmove, self.pondermove[self.stm] = \
self.usi.cmove(self.movelist, self.stm)
# start pondering
if self.pondermove[self.stm] is not None:
# send position and ponder command,
# return immediately
self.usi.start_ponder(
self.pondermove[self.stm],
self.movelist, self.cmove)
if self.stopped or self.cmove is None:
self.thinking = False
return
if gv.verbose:
print("computer move is", self.cmove)
# check if player resigned
if self.cmove == "resign":
if gv.verbose:
print("computer resigned")
self.gameover = True
self.thinking = False
colour = self.get_side_to_move_string(self.stm)
msg = _(" game over - ") + colour + _(" resigned")
GLib.idle_add(self.stop)
GLib.idle_add(gv.gui.set_status_bar_msg, msg)
self.automatic_comment(self.cmove + ": "+ _(msg),len(self.movelist))
self.thinking = False
return
# engine.setplayer(WHITE)
engine.setplayer(self.stm)
validmove = engine.hmove(self.cmove)
if (not validmove):
GLib.idle_add(self.stop)
GLib.idle_add(gv.gui.set_status_bar_msg,
self.cmove + _(" - computer made illegal Move!"))
self.gameover = True
self.thinking = False
self.automatic_comment(self.cmove + _(" - computer made illegal Move!"),len(self.movelist))
return
if gv.verbose:
engine.command("bd")
else:
if gv.verbose:
print("using gshogi builtin engine")
#
# We are using the builtin gshogi engine (not a USI engine)
#
if self.player[self.stm ^ 1] == "Human":
GLib.idle_add(gv.gui.set_status_bar_msg,
_("Thinking ..."))
# set the computer to black or white
engine.setplayer(self.stm ^ 1)
# start the clock
# print "starting clock from gshogi.py"
gv.tc.start_clock(self.stm)
# set time limit/level for move in gshogi engine
gv.tc.set_gshogi_time_limit(self.stm)
# call the gshogi engine to do the move
self.cmove = engine.cmove()
# update time for last move
# print "updating clock from gshogi.py"
GLib.idle_add(gv.tc.update_clock)
# if the engine moved very fast then wait a bit
# before displaying the move. The time to wait
# is in MIN_MOVETIME in constants.py
t_end = time.time()
move_t = t_end - t_start
if move_t < MIN_MOVETIME:
diff = MIN_MOVETIME - move_t
time.sleep(diff)
GLib.idle_add(gv.gui.set_side_to_move, self.stm)
if self.quitting:
return
if self.stopped:
self.thinking = False
GLib.idle_add(gv.gui.set_status_bar_msg, _("stopped"))
engine.command("undo")
return
if self.cmove != "":
self.movelist.append(self.cmove)
self.redolist = []
self.lastmove = self.cmove
else:
# empty move is returned by gshogi engine when it is in
# checkmate
if gv.verbose:
print("empty move returned by engine")
# if program is exitting then quit this thread asap
if self.quitting:
return
# gv.board.save_board(len(self.movelist))
# show computer move
GLib.idle_add(gv.board.update)
GLib.idle_add(self.move_list.update)
# if self.player[self.stm] != "gshogi"
# and gv.engine_manager.get_ponder():
# self.usi.send_ponder()
# # self.ctp= thread.start_new_thread(
# self.usi.send_ponder, () )
if gv.verbose:
engine.command("bd")
if gv.verbose:
print("move=", self.cmove)
msg = self.cmove
self.gameover, gmsg = self.check_for_gameover()
if (self.gameover):
msg = self.get_side_to_move_string(self.stm) + ": "
msg = msg + gmsg
self.thinking = False
self.stm = self.get_side_to_move()
GLib.idle_add(self.stop)
GLib.idle_add(gv.gui.set_side_to_move, self.stm)
GLib.idle_add(gv.gui.set_status_bar_msg, msg)
self.automatic_comment(msg,len(self.movelist))
return
msg = self.get_side_to_move_string(self.stm) + ": " + str(len(self.movelist)) + ". " + msg
GLib.idle_add(gv.gui.set_status_bar_msg, msg)
# give gui time to update the board
time.sleep(0.1)
self.thinking = False
except:
traceback.print_exc()
return
