def __init__(self, frame):
self._frame = frame
self._key_pressed = None
self._keycode_pressed = 0
self._keystate_pressed = 0
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed', self._key_pressed_cb)
self._key_grabber.connect('key-released', self._key_released_cb)
self._tabbing_handler = TabbingHandler(self._frame, _TABBING_MODIFIER)
for f in os.listdir(os.path.join(config.ext_path, 'globalkey')):
if f.endswith('.py') and not f.startswith('__'):
module_name = f[:-3]
try:
logging.debug('Loading module %r', module_name)
module = __import__('globalkey.' + module_name, globals(),
locals(), [module_name])
for key in module.BOUND_KEYS:
if key in _actions_table:
raise ValueError('Key %r is already bound' % key)
_actions_table[key] = module
except Exception:
logging.exception('Exception while loading extension:')
self._key_grabber.grab_keys(_actions_table.keys())
def __init__(self, frame):
self._frame = frame
self._key_pressed = None
self._keycode_pressed = 0
self._keystate_pressed = 0
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed',
self._key_pressed_cb)
self._key_grabber.connect('key-released',
self._key_released_cb)
self._tabbing_handler = TabbingHandler(self._frame, _TABBING_MODIFIER)
for f in os.listdir(os.path.join(config.ext_path, 'globalkey')):
if f.endswith('.py') and not f.startswith('__'):
module_name = f[:-3]
try:
logging.debug('Loading module %r', module_name)
module = __import__('globalkey.' + module_name, globals(),
locals(), [module_name])
for key in module.BOUND_KEYS:
if key in _actions_table:
raise ValueError('Key %r is already bound' % key)
_actions_table[key] = module
except Exception:
logging.exception('Exception while loading extension:')
self._key_grabber.grab_keys(_actions_table.keys())
class KeyHandler(object):
def __init__(self, frame):
self._frame = frame
self._key_pressed = None
self._keycode_pressed = 0
self._keystate_pressed = 0
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed', self._key_pressed_cb)
self._key_grabber.connect('key-released', self._key_released_cb)
self._tabbing_handler = TabbingHandler(self._frame, _TABBING_MODIFIER)
for f in os.listdir(os.path.join(config.ext_path, 'globalkey')):
if f.endswith('.py') and not f.startswith('__'):
module_name = f[:-3]
try:
logging.debug('Loading module %r', module_name)
module = __import__('globalkey.' + module_name, globals(),
locals(), [module_name])
for key in module.BOUND_KEYS:
if key in _actions_table:
raise ValueError('Key %r is already bound' % key)
_actions_table[key] = module
except Exception:
logging.exception('Exception while loading extension:')
self._key_grabber.grab_keys(_actions_table.keys())
def _change_volume(self, step=None, value=None):
if step is not None:
volume = sound.get_volume() + step
elif value is not None:
volume = value
volume = min(max(0, volume), _VOLUME_MAX)
sound.set_volume(volume)
sound.set_muted(volume == 0)
def handle_previous_window(self, event_time):
self._tabbing_handler.previous_activity(event_time)
def handle_next_window(self, event_time):
self._tabbing_handler.next_activity(event_time)
def handle_close_window(self, event_time):
active_activity = shell.get_model().get_active_activity()
if active_activity.is_journal():
return
active_activity.get_window().close()
def handle_zoom_mesh(self, event_time):
shell.get_model().set_zoom_level(ShellModel.ZOOM_MESH, event_time)
def handle_zoom_group(self, event_time):
shell.get_model().set_zoom_level(ShellModel.ZOOM_GROUP, event_time)
def handle_zoom_home(self, event_time):
shell.get_model().set_zoom_level(ShellModel.ZOOM_HOME, event_time)
def handle_zoom_activity(self, event_time):
shell.get_model().set_zoom_level(ShellModel.ZOOM_ACTIVITY, event_time)
def handle_volume_max(self, event_time):
self._change_volume(value=_VOLUME_MAX)
def handle_volume_min(self, event_time):
self._change_volume(value=0)
def handle_volume_mute(self, event_time):
if sound.get_muted() is True:
sound.set_muted(False)
else:
sound.set_muted(True)
def handle_volume_up(self, event_time):
self._change_volume(step=_VOLUME_STEP)
def handle_volume_down(self, event_time):
self._change_volume(step=-_VOLUME_STEP)
def handle_frame(self, event_time):
self._frame.notify_key_press()
def handle_quit_emulator(self, event_time):
session.get_session_manager().shutdown()
def handle_open_search(self, event_time):
journalactivity.get_journal().focus_search()
def _key_pressed_cb(self, grabber, keycode, state, event_time):
key = grabber.get_key(keycode, state)
logging.debug('_key_pressed_cb: %i %i %s', keycode, state, key)
if key is not None:
self._key_pressed = key
self._keycode_pressed = keycode
self._keystate_pressed = state
action = _actions_table[key]
if self._tabbing_handler.is_tabbing():
# Only accept window tabbing events, everything else
# cancels the tabbing operation.
if not action in ['next_window', 'previous_window']:
self._tabbing_handler.stop(event_time)
return True
if hasattr(action, 'handle_key_press'):
action.handle_key_press(key)
elif isinstance(action, basestring):
method = getattr(self, 'handle_' + action)
method(event_time)
else:
raise TypeError('Invalid action %r' % action)
return True
else:
# If this is not a registered key, then cancel tabbing.
if self._tabbing_handler.is_tabbing():
if not grabber.is_modifier(keycode):
self._tabbing_handler.stop(event_time)
return True
return False
def _key_released_cb(self, grabber, keycode, state, event_time):
logging.debug('_key_released_cb: %i %i', keycode, state)
if self._tabbing_handler.is_tabbing():
# We stop tabbing and switch to the new window as soon as the
# modifier key is raised again.
if grabber.is_modifier(keycode, mask=_TABBING_MODIFIER):
self._tabbing_handler.stop(event_time)
return True
return False
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating PlayGo')
self.size = DEFAULT_SIZE
self.komi = DEFAULT_KOMI
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.gameToolbar = GameToolbar(self)
toolbox.add_toolbar(_('Game'), self.gameToolbar)
self.gameToolbar.connect('game-restart', self.restart_game)
self.gameToolbar.connect('game-board-size', self.board_size_change)
self.gameToolbar.connect('ai-activated', self.ai_activated_cb)
self.gameToolbar.connect('ai-deactivated', self.ai_deactivated_cb)
self.gameToolbar.show()
# Initialize the game
self.game = GoGame(self.size)
self.CurrentColor = 'B'
self.PlayerColor = 'B'
self.pass_count = 0
self.ai_activated = False
self.set_up_ui()
if not handle.object_id:
self.infopanel.show(_('Welcome to PlayGo!'))
else:
self.show_score()
self.lastX = -1
self.lastY = -1
# Set keypad actions
self._key_actions = {
'KP_Up' : 'move_up',
'KP_Right' : 'move_right',
'KP_Down' : 'move_down',
'KP_Left' : 'move_left',
'KP_Home' : 'place_stone',
'KP_Next' : 'undo',
'KP_End' : 'pass' }
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed',
self._key_pressed_cb)
# New KeyGrabber API change (ticket #7999)
try:
self._key_grabber.grab_keys(self._key_actions.keys())
except:
for key in self._key_actions.keys():
self._key_grabber.grab(key)
#Set up collaboration
self.collaboration = CollaborationWrapper(self,
self.buddy_joined,
self.buddy_left,
self.Play,
self.game.undostack,
self.bootstrap)
self.connect('shared', self.collaboration._shared_cb)
if self._shared_activity:
# We are joining the activity
self.connect('joined', self.collaboration._joined_cb)
if self.get_shared():
# We've already joined
self.collaboration._joined_cb()
class PlayGo(Activity):
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating PlayGo')
self.size = DEFAULT_SIZE
self.komi = DEFAULT_KOMI
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.gameToolbar = GameToolbar(self)
toolbox.add_toolbar(_('Game'), self.gameToolbar)
self.gameToolbar.connect('game-restart', self.restart_game)
self.gameToolbar.connect('game-board-size', self.board_size_change)
self.gameToolbar.connect('ai-activated', self.ai_activated_cb)
self.gameToolbar.connect('ai-deactivated', self.ai_deactivated_cb)
self.gameToolbar.show()
# Initialize the game
self.game = GoGame(self.size)
self.CurrentColor = 'B'
self.PlayerColor = 'B'
self.pass_count = 0
self.ai_activated = False
self.set_up_ui()
if not handle.object_id:
self.infopanel.show(_('Welcome to PlayGo!'))
else:
self.show_score()
self.lastX = -1
self.lastY = -1
# Set keypad actions
self._key_actions = {
'KP_Up' : 'move_up',
'KP_Right' : 'move_right',
'KP_Down' : 'move_down',
'KP_Left' : 'move_left',
'KP_Home' : 'place_stone',
'KP_Next' : 'undo',
'KP_End' : 'pass' }
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed',
self._key_pressed_cb)
# New KeyGrabber API change (ticket #7999)
try:
self._key_grabber.grab_keys(self._key_actions.keys())
except:
for key in self._key_actions.keys():
self._key_grabber.grab(key)
#Set up collaboration
self.collaboration = CollaborationWrapper(self,
self.buddy_joined,
self.buddy_left,
self.Play,
self.game.undostack,
self.bootstrap)
self.connect('shared', self.collaboration._shared_cb)
if self._shared_activity:
# We are joining the activity
self.connect('joined', self.collaboration._joined_cb)
if self.get_shared():
# We've already joined
self.collaboration._joined_cb()
def set_up_ui(self):
self.board = boardwidget.GoBoardWidget(self.game.get_status(), self.size)
self.board.connect('motion-notify-event', self.board_motion_cb)
self.board.connect('insert-requested', self.insert_cb)
self.main_view = gtk.VBox()
self.board_aspect = gtk.AspectFrame(None, .5, .5, 1, False)
self.board_aspect.add(self.board)
self.main_view.pack_start(self.board_aspect)
self.buttons_box = gtk.HBox()
self.buttons_alignment = gtk.Alignment(0.5, 1, 0.5, 1)
#Pass button
self.pass_button = gtk.Button(_('Pass'))
self.pass_button.connect("clicked", self.pass_cb)
self.buttons_box.pack_start(self.pass_button, True, True, 10)
#Undo button
self.undo_button = gtk.Button(_('Undo'))
self.undo_button.connect("clicked", self.undo_cb)
self.buttons_box.pack_start(self.undo_button, True, True, 10)
self.buttons_alignment.add(self.buttons_box)
self.main_view.pack_start(self.buttons_alignment, False, padding=10)
self.infopanel = infopanel.InfoPanel()
self.main_view.pack_start(self.infopanel, False)
self.set_canvas(self.main_view)
self.show_all()
def insert_cb(self, widget, x, y, announce=True, ai_play=False):
''' The insert function. It makes the play and manages turn changing
stone drawing, etc.
Parameters x and y are the coordinates of the play ((0,0) is top left),
widget points to the widget that emitted the signal connected to this
function, announce is True when we need to announce this play to
other people collaborating, and ai_play is True when this is called
by the AI, so we know not to ask for an AI play again '''
# Check if it's our turn only if it's a local play (announce is True)
# Calls by other players will always be out of turn for us.
if announce and self.get_currentcolor() != self.get_playercolor():
logger.debug('Play at %s x %s was out-of-turn!', x, y)
self.infopanel.show(_('It\'s not your turn!'))
return False
# Make the play only if it wasn't a pass move.
if x != -1:
self.pass_count = 0
error = self.game.illegal(x, y, self.get_currentcolor())
if error:
self.infopanel.show(error)
return False
# Make the play
captures = self.game.play((x, y), self.get_currentcolor())
if self.ai_activated and not ai_play:
self.notify_ai(x, y, self.get_currentcolor())
self.gameToolbar.grey_out_size_change()
if captures: self.redraw_captures(captures)
self.show_score()
self.board.draw_stone(x, y, self.get_currentcolor(), widget)
# Player passed
else:
self.pass_count += 1
# Announce the local play
if self.get_shared() and announce:
self.collaboration.Play(x, y)
self.change_turn()
if x == -1:
self.infopanel.show(_('Opponent passed'))
# If this is the second consecutive pass, the game ends
if self.pass_count == 2:
self.game_end()
return
# If we are playing a local game with AI turned off, change the color
if not self.get_shared() and not self.ai_activated:
self.change_player_color()
# Else, if the AI is on, and this wasn't played by it, request a play by it.
elif self.ai_activated:
self.change_player_color()
if not ai_play:
self.play_ai()
def undo_cb(self, widget=None, data=None):
if self.game.undo():
self.board.queue_draw()
# If playing against AI undo twice
if self.ai_activated:
self.ai.undo()
self.game.undo()
self.ai.undo()
else:
self.change_turn()
if not self.get_shared() and not self.ai_activated:
self.change_player_color()
self.show_score()
def pass_cb(self, widget=None, data=None):
if self.get_shared():
if self.get_currentcolor() == self.get_playercolor():
self.pass_count += 1
self.collaboration.Play(-1, -1)
else:
self.infopanel.show(_('It\'s not your turn!'))
return
else:
self.pass_count += 1
self.change_player_color()
self.change_turn()
if self.pass_count == 2:
self.game_end()
if self.ai_activated:
self.ai.pass_move(self.get_currentcolor())
self.play_ai()
def write_file(self, file_path):
logger.debug('Writing file: %s', file_path)
# Strip the undostack
undostack = self.game.undostack[:]
strippedstack = []
for pos, color, captures in undostack:
strippedstack.append(pos)
f = open(file_path, 'w')
try:
cPickle.dump(strippedstack, f, cPickle.HIGHEST_PROTOCOL)
finally:
f.close()
self.metadata['our-color'] = self.get_playercolor()
self.metadata['shared'] = str(self.get_shared())
self.metadata['size'] = str(self.size)
self.metadata['ai'] = str(self.ai_activated)
def read_file(self, file_path):
logger.debug('Reading file: %s', file_path)
f = open(file_path, 'r')
try:
newstack = cPickle.load(f)
finally:
f.close()
if self.get_shared():
logger.debug('The game we are loading is shared!')
self.PlayerColor = self.metadata.get('our-color', 'B')
if self.size != self.metadata.get('size', DEFAULT_SIZE):
self.board_size_change(None, int(self.metadata.get('size', DEFAULT_SIZE)))
self.bootstrap(newstack)
if self.metadata.get('ai', None) == 'True':
self.gameToolbar._size_combo.set_sensitive(False)
self.gameToolbar._ai_button.set_active(True) # This triggers the 'toggled' signal too
def board_motion_cb(self, widget, event):
x, y = self.board.get_mouse_event_xy(event)
if x == self.lastX and y == self.lastY:
return
if not self.game.is_occupied(x, y) and self.game.legal((x, y), self.get_playercolor()):
self.board.draw_ghost_stone(x, y, self.get_playercolor())
self.lastX = x
self.lastY = y
def invert_color(self, color):
if color == 'B': return 'W'
return 'B'
def get_currentcolor(self):
return self.CurrentColor
def change_turn(self):
# It's the other guy's turn now
if self.CurrentColor == 'B':
self.infopanel.show(_('White\'s turn'))
else:
self.infopanel.show(_('Black\'s turn'))
self.CurrentColor = self.invert_color(self.get_currentcolor())
def get_playercolor(self):
return self.PlayerColor
def change_player_color(self):
self.PlayerColor = self.invert_color(self.get_playercolor())
def set_player_color(self, color):
self.PlayerColor = color
def redraw_captures(self, captures):
for x in captures:
self.board.redraw_area(x[0], x[1])
def bootstrap(self, plays):
''' Take our game to the state it would have if @plays were manually played'''
logger.debug('Bootstraping...')
self.board.do_expose_event() # HACK: Looks like read_file is called before the board is exposed
for pos in plays:
logger.debug('Playing at %s with color %s', pos, self.get_currentcolor())
captures = self.game.play((pos[0], pos[1]), self.get_currentcolor())
if captures: self.redraw_captures(captures)
self.change_turn()
self.change_player_color()
logger.debug('Color after bootstraping is %s', self.get_currentcolor())
self.show_score()
self.board.do_expose_event()
def restart_game(self, widget=None):
logger.debug('Received restart signal!')
self.CurrentColor = 'B'
self.PlayerColor = 'B'
self.pass_count = 0
self.game.clear()
self.board.territories = None
self.board.status = self.game.status
self.board.do_expose_event()
self.show_score()
self.board.set_sensitive(True)
self.buttons_box.set_sensitive(True)
self.lastX = -1
self.lastY = -1
if self.ai_activated:
self.ai.clear()
def game_end(self):
self.board.set_sensitive(False)
self.buttons_box.set_sensitive(False)
territories = self.game.get_territories()
self.board.territories = territories
final_score = {'B':(len(territories['B']) - self.game.get_score()['W']),
'W':(len(territories['W']) - self.game.get_score()['B'] + self.komi)}
if final_score['B'] > final_score['W']:
winner_string = _('Black wins!')
elif final_score['W'] > final_score['B']:
winner_string = _('White wins!')
else:
winner_string = _('There was a tie!')
self.infopanel.show(_('Game ended! %s' % winner_string))
self.infopanel.show_score(_('Final score: White %(W)g - Black %(B)g' % final_score))
def board_size_change(self, widget, size):
self.lastY = -1
self.lastX = -1
if size == self.size:
return
self.size = size
del self.game
self.game = GoGame(size)
self.board_aspect.remove(self.board)
del self.board
self.board = boardwidget.GoBoardWidget(self.game.get_status(), int(size))
self.board_aspect.add(self.board)
self.board.connect('motion-notify-event', self.board_motion_cb)
self.board.connect('insert-requested', self.insert_cb)
self.board.show()
if self.ai_activated:
del self.ai
self.ai = gnugo(boardsize=self.size)
def ai_activated_cb(self, widget=None):
try:
self.ai = gnugo(boardsize=self.size)
except Exception, e:
self._alert(_('AI'), _('GnuGo loading failed!: %s' % e))
self.gameToolbar.set_ai_button_state(False)
else:
class KeyHandler(object):
def __init__(self, frame):
self._frame = frame
self._key_pressed = None
self._keycode_pressed = 0
self._keystate_pressed = 0
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed',
self._key_pressed_cb)
self._key_grabber.connect('key-released',
self._key_released_cb)
self._tabbing_handler = TabbingHandler(self._frame, _TABBING_MODIFIER)
for f in os.listdir(os.path.join(config.ext_path, 'globalkey')):
if f.endswith('.py') and not f.startswith('__'):
module_name = f[:-3]
try:
logging.debug('Loading module %r', module_name)
module = __import__('globalkey.' + module_name, globals(),
locals(), [module_name])
for key in module.BOUND_KEYS:
if key in _actions_table:
raise ValueError('Key %r is already bound' % key)
_actions_table[key] = module
except Exception:
logging.exception('Exception while loading extension:')
self._key_grabber.grab_keys(_actions_table.keys())
def _change_volume(self, step=None, value=None):
if step is not None:
volume = sound.get_volume() + step
elif value is not None:
volume = value
volume = min(max(0, volume), _VOLUME_MAX)
sound.set_volume(volume)
sound.set_muted(volume == 0)
def handle_previous_window(self, event_time):
self._tabbing_handler.previous_activity(event_time)
def handle_next_window(self, event_time):
self._tabbing_handler.next_activity(event_time)
def handle_close_window(self, event_time):
active_activity = shell.get_model().get_active_activity()
if active_activity.is_journal():
return
active_activity.get_window().close()
def handle_zoom_mesh(self, event_time):
shell.get_model().set_zoom_level(ShellModel.ZOOM_MESH, event_time)
def handle_zoom_group(self, event_time):
shell.get_model().set_zoom_level(ShellModel.ZOOM_GROUP, event_time)
def handle_zoom_home(self, event_time):
shell.get_model().set_zoom_level(ShellModel.ZOOM_HOME, event_time)
def handle_zoom_activity(self, event_time):
shell.get_model().set_zoom_level(ShellModel.ZOOM_ACTIVITY, event_time)
def handle_volume_max(self, event_time):
self._change_volume(value=_VOLUME_MAX)
def handle_volume_min(self, event_time):
self._change_volume(value=0)
def handle_volume_mute(self, event_time):
if sound.get_muted() is True:
sound.set_muted(False)
else:
sound.set_muted(True)
def handle_volume_up(self, event_time):
self._change_volume(step=_VOLUME_STEP)
def handle_volume_down(self, event_time):
self._change_volume(step=-_VOLUME_STEP)
def handle_frame(self, event_time):
self._frame.notify_key_press()
def handle_quit_emulator(self, event_time):
session.get_session_manager().shutdown()
def handle_open_search(self, event_time):
journalactivity.get_journal().focus_search()
def _key_pressed_cb(self, grabber, keycode, state, event_time):
key = grabber.get_key(keycode, state)
logging.debug('_key_pressed_cb: %i %i %s', keycode, state, key)
if key is not None:
self._key_pressed = key
self._keycode_pressed = keycode
self._keystate_pressed = state
action = _actions_table[key]
if self._tabbing_handler.is_tabbing():
# Only accept window tabbing events, everything else
# cancels the tabbing operation.
if not action in ['next_window', 'previous_window']:
self._tabbing_handler.stop(event_time)
return True
if hasattr(action, 'handle_key_press'):
action.handle_key_press(key)
elif isinstance(action, basestring):
method = getattr(self, 'handle_' + action)
method(event_time)
else:
raise TypeError('Invalid action %r' % action)
return True
else:
# If this is not a registered key, then cancel tabbing.
if self._tabbing_handler.is_tabbing():
if not grabber.is_modifier(keycode):
self._tabbing_handler.stop(event_time)
return True
return False
def _key_released_cb(self, grabber, keycode, state, event_time):
logging.debug('_key_released_cb: %i %i', keycode, state)
if self._tabbing_handler.is_tabbing():
# We stop tabbing and switch to the new window as soon as the
# modifier key is raised again.
if grabber.is_modifier(keycode, mask=_TABBING_MODIFIER):
self._tabbing_handler.stop(event_time)
return True
return False
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating PlayGo')
self.size = DEFAULT_SIZE
self.komi = DEFAULT_KOMI
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.gameToolbar = GameToolbar(self)
toolbox.add_toolbar(_('Game'), self.gameToolbar)
self.gameToolbar.connect('game-restart', self.restart_game)
self.gameToolbar.connect('game-board-size', self.board_size_change)
self.gameToolbar.connect('ai-activated', self.ai_activated_cb)
self.gameToolbar.connect('ai-deactivated', self.ai_deactivated_cb)
self.gameToolbar.show()
# Initialize the game
self.game = GoGame(self.size)
self.CurrentColor = 'B'
self.PlayerColor = 'B'
self.pass_count = 0
self.ai_activated = False
self.set_up_ui()
if not handle.object_id:
self.infopanel.show(_('Welcome to PlayGo!'))
else:
self.show_score()
self.lastX = -1
self.lastY = -1
# Set keypad actions
self._key_actions = {
'KP_Up': 'move_up',
'KP_Right': 'move_right',
'KP_Down': 'move_down',
'KP_Left': 'move_left',
'KP_Home': 'place_stone',
'KP_Next': 'undo',
'KP_End': 'pass'
}
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed', self._key_pressed_cb)
# New KeyGrabber API change (ticket #7999)
try:
self._key_grabber.grab_keys(self._key_actions.keys())
except:
for key in self._key_actions.keys():
self._key_grabber.grab(key)
#Set up collaboration
self.collaboration = CollaborationWrapper(self, self.buddy_joined,
self.buddy_left, self.Play,
self.game.undostack,
self.bootstrap)
self.connect('shared', self.collaboration._shared_cb)
if self._shared_activity:
# We are joining the activity
self.connect('joined', self.collaboration._joined_cb)
if self.get_shared():
# We've already joined
self.collaboration._joined_cb()
class PlayGo(Activity):
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating PlayGo')
self.size = DEFAULT_SIZE
self.komi = DEFAULT_KOMI
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.gameToolbar = GameToolbar(self)
toolbox.add_toolbar(_('Game'), self.gameToolbar)
self.gameToolbar.connect('game-restart', self.restart_game)
self.gameToolbar.connect('game-board-size', self.board_size_change)
self.gameToolbar.connect('ai-activated', self.ai_activated_cb)
self.gameToolbar.connect('ai-deactivated', self.ai_deactivated_cb)
self.gameToolbar.show()
# Initialize the game
self.game = GoGame(self.size)
self.CurrentColor = 'B'
self.PlayerColor = 'B'
self.pass_count = 0
self.ai_activated = False
self.set_up_ui()
if not handle.object_id:
self.infopanel.show(_('Welcome to PlayGo!'))
else:
self.show_score()
self.lastX = -1
self.lastY = -1
# Set keypad actions
self._key_actions = {
'KP_Up': 'move_up',
'KP_Right': 'move_right',
'KP_Down': 'move_down',
'KP_Left': 'move_left',
'KP_Home': 'place_stone',
'KP_Next': 'undo',
'KP_End': 'pass'
}
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed', self._key_pressed_cb)
# New KeyGrabber API change (ticket #7999)
try:
self._key_grabber.grab_keys(self._key_actions.keys())
except:
for key in self._key_actions.keys():
self._key_grabber.grab(key)
#Set up collaboration
self.collaboration = CollaborationWrapper(self, self.buddy_joined,
self.buddy_left, self.Play,
self.game.undostack,
self.bootstrap)
self.connect('shared', self.collaboration._shared_cb)
if self._shared_activity:
# We are joining the activity
self.connect('joined', self.collaboration._joined_cb)
if self.get_shared():
# We've already joined
self.collaboration._joined_cb()
def set_up_ui(self):
self.board = boardwidget.GoBoardWidget(self.game.get_status(),
self.size)
self.board.connect('motion-notify-event', self.board_motion_cb)
self.board.connect('insert-requested', self.insert_cb)
self.main_view = gtk.VBox()
self.board_aspect = gtk.AspectFrame(None, .5, .5, 1, False)
self.board_aspect.add(self.board)
self.main_view.pack_start(self.board_aspect)
self.buttons_box = gtk.HBox()
self.buttons_alignment = gtk.Alignment(0.5, 1, 0.5, 1)
#Pass button
self.pass_button = gtk.Button(_('Pass'))
self.pass_button.connect("clicked", self.pass_cb)
self.buttons_box.pack_start(self.pass_button, True, True, 10)
#Undo button
self.undo_button = gtk.Button(_('Undo'))
self.undo_button.connect("clicked", self.undo_cb)
self.buttons_box.pack_start(self.undo_button, True, True, 10)
self.buttons_alignment.add(self.buttons_box)
self.main_view.pack_start(self.buttons_alignment, False, padding=10)
self.infopanel = infopanel.InfoPanel()
self.main_view.pack_start(self.infopanel, False)
self.set_canvas(self.main_view)
self.show_all()
def insert_cb(self, widget, x, y, announce=True, ai_play=False):
''' The insert function. It makes the play and manages turn changing
stone drawing, etc.
Parameters x and y are the coordinates of the play ((0,0) is top left),
widget points to the widget that emitted the signal connected to this
function, announce is True when we need to announce this play to
other people collaborating, and ai_play is True when this is called
by the AI, so we know not to ask for an AI play again '''
# Check if it's our turn only if it's a local play (announce is True)
# Calls by other players will always be out of turn for us.
if announce and self.get_currentcolor() != self.get_playercolor():
logger.debug('Play at %s x %s was out-of-turn!', x, y)
self.infopanel.show(_('It\'s not your turn!'))
return False
# Make the play only if it wasn't a pass move.
if x != -1:
self.pass_count = 0
error = self.game.illegal(x, y, self.get_currentcolor())
if error:
self.infopanel.show(error)
return False
# Make the play
captures = self.game.play((x, y), self.get_currentcolor())
if self.ai_activated and not ai_play:
self.notify_ai(x, y, self.get_currentcolor())
self.gameToolbar.grey_out_size_change()
if captures: self.redraw_captures(captures)
self.show_score()
self.board.draw_stone(x, y, self.get_currentcolor(), widget)
# Player passed
else:
self.pass_count += 1
# Announce the local play
if self.get_shared() and announce:
self.collaboration.Play(x, y)
self.change_turn()
if x == -1:
self.infopanel.show(_('Opponent passed'))
# If this is the second consecutive pass, the game ends
if self.pass_count == 2:
self.game_end()
return
# If we are playing a local game with AI turned off, change the color
if not self.get_shared() and not self.ai_activated:
self.change_player_color()
# Else, if the AI is on, and this wasn't played by it, request a play by it.
elif self.ai_activated:
self.change_player_color()
if not ai_play:
self.play_ai()
def undo_cb(self, widget=None, data=None):
if self.game.undo():
self.board.queue_draw()
# If playing against AI undo twice
if self.ai_activated:
self.ai.undo()
self.game.undo()
self.ai.undo()
else:
self.change_turn()
if not self.get_shared() and not self.ai_activated:
self.change_player_color()
self.show_score()
def pass_cb(self, widget=None, data=None):
if self.get_shared():
if self.get_currentcolor() == self.get_playercolor():
self.pass_count += 1
self.collaboration.Play(-1, -1)
else:
self.infopanel.show(_('It\'s not your turn!'))
return
else:
self.pass_count += 1
self.change_player_color()
self.change_turn()
if self.pass_count == 2:
self.game_end()
if self.ai_activated:
self.ai.pass_move(self.get_currentcolor())
self.play_ai()
def write_file(self, file_path):
logger.debug('Writing file: %s', file_path)
# Strip the undostack
undostack = self.game.undostack[:]
strippedstack = []
for pos, color, captures in undostack:
strippedstack.append(pos)
f = open(file_path, 'w')
try:
cPickle.dump(strippedstack, f, cPickle.HIGHEST_PROTOCOL)
finally:
f.close()
self.metadata['our-color'] = self.get_playercolor()
self.metadata['shared'] = str(self.get_shared())
self.metadata['size'] = str(self.size)
self.metadata['ai'] = str(self.ai_activated)
def read_file(self, file_path):
logger.debug('Reading file: %s', file_path)
f = open(file_path, 'r')
try:
newstack = cPickle.load(f)
finally:
f.close()
if self.get_shared():
logger.debug('The game we are loading is shared!')
self.PlayerColor = self.metadata.get('our-color', 'B')
if self.size != self.metadata.get('size', DEFAULT_SIZE):
self.board_size_change(
None, int(self.metadata.get('size', DEFAULT_SIZE)))
self.bootstrap(newstack)
if self.metadata.get('ai', None) == 'True':
self.gameToolbar._size_combo.set_sensitive(False)
self.gameToolbar._ai_button.set_active(
True) # This triggers the 'toggled' signal too
def board_motion_cb(self, widget, event):
x, y = self.board.get_mouse_event_xy(event)
if x == self.lastX and y == self.lastY:
return
if not self.game.is_occupied(x, y) and self.game.legal(
(x, y), self.get_playercolor()):
self.board.draw_ghost_stone(x, y, self.get_playercolor())
self.lastX = x
self.lastY = y
def invert_color(self, color):
if color == 'B': return 'W'
return 'B'
def get_currentcolor(self):
return self.CurrentColor
def change_turn(self):
# It's the other guy's turn now
if self.CurrentColor == 'B':
self.infopanel.show(_('White\'s turn'))
else:
self.infopanel.show(_('Black\'s turn'))
self.CurrentColor = self.invert_color(self.get_currentcolor())
def get_playercolor(self):
return self.PlayerColor
def change_player_color(self):
self.PlayerColor = self.invert_color(self.get_playercolor())
def set_player_color(self, color):
self.PlayerColor = color
def redraw_captures(self, captures):
for x in captures:
self.board.redraw_area(x[0], x[1])
def bootstrap(self, plays):
''' Take our game to the state it would have if @plays were manually played'''
logger.debug('Bootstraping...')
self.board.do_expose_event(
) # HACK: Looks like read_file is called before the board is exposed
for pos in plays:
logger.debug('Playing at %s with color %s', pos,
self.get_currentcolor())
captures = self.game.play((pos[0], pos[1]),
self.get_currentcolor())
if captures: self.redraw_captures(captures)
self.change_turn()
self.change_player_color()
logger.debug('Color after bootstraping is %s', self.get_currentcolor())
self.show_score()
self.board.do_expose_event()
def restart_game(self, widget=None):
logger.debug('Received restart signal!')
self.CurrentColor = 'B'
self.PlayerColor = 'B'
self.pass_count = 0
self.game.clear()
self.board.territories = None
self.board.status = self.game.status
self.board.do_expose_event()
self.show_score()
self.board.set_sensitive(True)
self.buttons_box.set_sensitive(True)
self.lastX = -1
self.lastY = -1
if self.ai_activated:
self.ai.clear()
def game_end(self):
self.board.set_sensitive(False)
self.buttons_box.set_sensitive(False)
territories = self.game.get_territories()
self.board.territories = territories
final_score = {
'B': (len(territories['B']) - self.game.get_score()['W']),
'W':
(len(territories['W']) - self.game.get_score()['B'] + self.komi)
}
if final_score['B'] > final_score['W']:
winner_string = _('Black wins!')
elif final_score['W'] > final_score['B']:
winner_string = _('White wins!')
else:
winner_string = _('There was a tie!')
self.infopanel.show(_('Game ended! %s' % winner_string))
self.infopanel.show_score(
_('Final score: White %(W)g - Black %(B)g' % final_score))
def board_size_change(self, widget, size):
self.lastY = -1
self.lastX = -1
if size == self.size:
return
self.size = size
del self.game
self.game = GoGame(size)
self.board_aspect.remove(self.board)
del self.board
self.board = boardwidget.GoBoardWidget(self.game.get_status(),
int(size))
self.board_aspect.add(self.board)
self.board.connect('motion-notify-event', self.board_motion_cb)
self.board.connect('insert-requested', self.insert_cb)
self.board.show()
if self.ai_activated:
del self.ai
self.ai = gnugo(boardsize=self.size)
def ai_activated_cb(self, widget=None):
try:
self.ai = gnugo(boardsize=self.size)
except Exception, e:
self._alert(_('AI'), _('GnuGo loading failed!: %s' % e))
self.gameToolbar.set_ai_button_state(False)
else:
