# Copyright (C) 2006, 2007, 2008 One Laptop Per Child
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
import logging
import gobject
from os.path import join
from gettext import gettext as _
from gobject import SIGNAL_RUN_FIRST, TYPE_PYOBJECT, GObject, timeout_add
from gobject import source_remove
from model import Model
from audio import Audio
import theme
_logger = logging.getLogger('memorize-activity')
SERVICE = 'org.laptop.Memorize'
IFACE = SERVICE
PATH = '/org/laptop/Memorize'
class MemorizeGame(GObject):
__gsignals__ = {
'reset_scoreboard': (SIGNAL_RUN_FIRST, None, []),
'reset_table': (SIGNAL_RUN_FIRST, None, []),
'load_mode': (SIGNAL_RUN_FIRST, None, [TYPE_PYOBJECT]),
'load_game': (SIGNAL_RUN_FIRST, None, 2 * [TYPE_PYOBJECT]),
'change_game': (SIGNAL_RUN_FIRST, None, 2 * [TYPE_PYOBJECT]),
'change_game_signal': (SIGNAL_RUN_FIRST, None, 5 * [TYPE_PYOBJECT]),
'set-border': (SIGNAL_RUN_FIRST, None, 3 * [TYPE_PYOBJECT]),
'flip-card': (SIGNAL_RUN_FIRST, None, [int, bool]),
'flip-card-signal': (SIGNAL_RUN_FIRST, None, [int]),
'cement-card': (SIGNAL_RUN_FIRST, None, [int]),
'flop-card': (SIGNAL_RUN_FIRST, None, [int]),
'highlight-card': (SIGNAL_RUN_FIRST, None, 2 * [TYPE_PYOBJECT]),
'add_buddy': (SIGNAL_RUN_FIRST, None, 2 * [TYPE_PYOBJECT]),
'rem_buddy': (SIGNAL_RUN_FIRST, None, [TYPE_PYOBJECT]),
'increase-score': (SIGNAL_RUN_FIRST, None, [TYPE_PYOBJECT]),
'wait_mode_buddy': (SIGNAL_RUN_FIRST, None, 2 * [TYPE_PYOBJECT]),
'msg_buddy': (SIGNAL_RUN_FIRST, None, 2 * [TYPE_PYOBJECT]),
'change-turn': (SIGNAL_RUN_FIRST, None, [TYPE_PYOBJECT]),
}
def __init__(self):
gobject.GObject.__init__(self)
self.myself = None
self.players_score = {}
self.players = []
self.waiting_players = []
self.current_player = None
self.last_flipped = -1
self.last_highlight = 1
self._flop_card_timeout = -1
self.messenger = None
self.sentitive = True
self.model = Model()
self.flip_block = False
self._flop_cards = None
self.audio = Audio()
def load_game(self, game_name, size, mode):
self.set_load_mode('Loading game')
if self.model.read(game_name) == 0:
self.model.def_grid(size)
self.model.data['running'] = 'False'
self.model.data['mode'] = mode
logging.debug(' Read setup file %r: %r ',
game_name, self.model.grid)
self.emit('load_game', self.model.data, self.model.grid)
else:
logging.error(' Reading setup file %s', game_name)
def load_remote(self, grid, data, mode, signal = False):
self.set_load_mode(_('Loading game...'))
self.model.grid = grid
self.model.data = data
self.model.data['mode'] = mode
self.emit('reset_scoreboard')
if not signal:
self.emit('change_game_signal',
mode,
self.get_grid(),
self.model.data,
self.waiting_players,
self.model.data['game_file'])
self.emit('change_game', self.model.data, self.get_grid())
for buddy in self.players:
self.players_score[buddy] = 0
self.current_player = None
self.last_flipped = -1
self.last_highlight = 1
self.change_turn()
self.model.data['running'] = 'False'
for card in self.model.grid:
if card['state'] == '1':
self.emit('flip-card', self.model.grid.index(card), False)
self.last_flipped = self.model.grid.index(card)
elif card['state'] != '0':
stroke_color, fill_color = card['state'].split(',')
self.emit('flip-card', self.model.grid.index(card), False)
self.emit('set-border', self.model.grid.index(card),
stroke_color, fill_color)
def add_buddy(self, buddy, score = 0):
_logger.debug('Buddy %r was added to game', buddy.props.nick)
self.players.append(buddy)
self.players_score[buddy] = score
self.emit('add_buddy', buddy, score)
logging.debug(str(buddy))
if self.current_player == None:
self.current_player = buddy
self.change_turn()
def rem_buddy(self, buddy):
_logger.debug('Buddy %r was removed from game', buddy.props.nick)
if self.current_player == buddy and len(self.players) >= 2:
if self.last_flipped != -1:
self.emit('flop-card', self.last_flipped)
self.model.grid[self.last_flipped]['state'] = '0'
self.last_flipped = -1
self.change_turn()
index = self.players.index(buddy)
del self.players[index]
del (self.players_score[buddy])
self.emit('rem_buddy', buddy)
def buddy_message(self, buddy, text):
self.emit('msg_buddy', buddy, text)
def update_turn(self):
self.set_sensitive(self.current_player == self.myself)
self.emit('change-turn', self.current_player)
def change_turn(self):
if len(self.players) <= 1:
self.current_player = self.players[0]
if self.current_player == None:
self.current_player = self.players[0]
elif self.current_player == self.players[-1]:
self.current_player = self.players[0]
else:
next_player = self.players.index(self.current_player) + 1
self.current_player = self.players[next_player]
self.update_turn()
def card_overflipped(self, widget, identifier):
if self._flop_cards and identifier in self._flop_cards:
self.card_flipped(widget, identifier)
def card_flipped(self, widget, identifier, signal = False):
if self._flop_cards:
source_remove(self._flop_card_timeout)
self.flop_card(self._flop_cards[0], self._flop_cards[1])
# Check if is my turn
if (not self.sentitive and not signal) or \
self.last_flipped == identifier:
return
# Handle groups if needed
if self.model.data.get('divided') == '1':
if self.last_flipped == -1 and identifier \
>= (len(self.model.grid)/2):
return
if self.last_flipped != -1 and identifier \
< (len(self.model.grid)/2):
return
# do not process flips when flipping back
if self.flip_block:
return
else:
self.flip_block = True
self.model.data['running'] = 'True'
def flip_card(full_animation):
self.emit('flip-card', identifier, full_animation)
if not signal:
self.emit('flip-card-signal', identifier)
snd = self.model.grid[identifier].get('snd', None)
if snd != None:
sound_file = join(self.model.data.get('pathsnd'), snd)
self.audio.play(sound_file)
# First card case
if self.last_flipped == -1:
flip_card(full_animation=True)
self.last_flipped = identifier
self.model.grid[identifier]['state'] = '1'
self.flip_block = False
# Second card case
else:
# Pair matched
pair_key_1 = self.model.grid[self.last_flipped]['pairkey']
pair_key_2 = self.model.grid[identifier]['pairkey']
if pair_key_1 == pair_key_2:
flip_card(full_animation=False)
stroke_color, fill_color = \
self.current_player.props.color.split(',')
self.emit('set-border', identifier, stroke_color, fill_color)
self.emit('set-border', self.last_flipped,
stroke_color, fill_color)
self.increase_point(self.current_player)
self.model.grid[identifier]['state'] = \
self.current_player.props.color
self.model.grid[self.last_flipped]['state'] = \
self.current_player.props.color
self.flip_block = False
self.emit('cement-card', identifier)
self.emit('cement-card', self.last_flipped)
# Pair didn't match
else:
flip_card(full_animation=True)
self.model.grid[identifier]['state'] = '1'
self.set_sensitive(False)
self._flop_cards = (identifier, self.last_flipped)
self._flop_card_timeout = timeout_add(theme.FLOP_BACK_TIMEOUT,
self.flop_card, identifier, self.last_flipped)
self.last_flipped = -1
def flop_card(self, identifier, identifier2):
self._flop_card_timeout = -1
self._flop_cards = None
self.emit('flop-card', identifier)
self.model.grid[identifier]['state'] = '0'
self.emit('flop-card', identifier2)
self.model.grid[identifier2]['state'] = '0'
#if self.model.data['divided'] == '1':
# self.card_highlighted(widget, -1, False)
self.set_sensitive(True)
self.flip_block = False
self.change_turn()
def card_highlighted(self, widget, identifier, mouse):
self.emit('highlight-card', self.last_highlight, False)
self.last_highlight = identifier
if identifier == -1 or not self.sentitive:
return
if self.model.data['divided'] == '1':
if self.last_flipped == -1 and identifier \
>= (len(self.model.grid)/2):
return
if self.last_flipped != -1 and identifier \
< (len(self.model.grid)/2):
return
if mouse and self.model.grid[identifier]['state'] == '0' or not mouse:
self.emit('highlight-card', identifier, True)
def increase_point(self, buddy, inc=1):
self.players_score[buddy] += inc
for i_ in range(inc):
self.emit('increase-score', buddy)
def get_grid(self):
return self.model.grid
def collect_data(self):
for player, score in self.players_score.items():
index = self.players.index(player)
score = self.players_score[player]
self.model.data[str(index)] = str(score)
return self.model.data
def change_game(self, widget, game_name, size, mode,
title = None, color= None):
if mode in ['file', 'demo']:
if self.model.read(game_name) != 0:
logging.error(' Reading setup file %s', game_name)
return
if size == None:
size = int(self.model.data['size'])
self.model.def_grid(size)
if title != None:
self.model.data['title'] = title
if color != None:
self.model.data['color'] = color
self.load_remote(self.model.grid, self.model.data, mode, False)
def reset_game(self, size = None):
if size == None:
size = int(self.model.data['size'])
self.model.def_grid(size)
self.load_remote(self.model.grid, self.model.data, False)
def set_load_mode(self, msg):
self.emit('load_mode', msg)
def set_messenger(self, messenger):
self.messenger = messenger
def set_sensitive(self, status):
self.sentitive = status
if not status:
self.emit('highlight-card', self.last_highlight, False)
def get_sensitive(self):
return self.sentitive
def get_current_player(self):
return self.current_player
def get_players_data(self):
data = []
for player, score in self.players_score.items():
data.append([player.props.key, player.props.nick,
player.props.color, score])
return data
def set_wait_list(self, wait_list):
self.waiting_players = wait_list
for w in wait_list:
for p in self.players:
if w[0] == p.props.key:
list.remove(w)
for i_ in range(w[3]):
self.increase_point(p)
def set_myself(self, buddy):
self.myself = buddy
def add_to_waiting_list(self, buddy):
self.players.remove(buddy)
self.waiting_players.append(buddy)
self.emit('wait_mode_buddy', buddy, True)
def rem_to_waiting_list(self, buddy):
self.waiting_players.remove(buddy)
self.players.append(buddy)
self.emit('wait_mode_buddy', buddy, False)
def load_waiting_list(self, wait_list):
for buddy in wait_list:
self.add_to_waiting_list(buddy)
def empty_waiting_list(self):
for buddy in self.waiting_players:
self.rem_to_waiting_list(buddy)