1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
import random
import logging
from sugar3 import profile
from dominopiece import DominoPiece
import dominoview
from dominoview import Tile
from dominoview import DominoTableView
from dominoplayer import DominoPlayer
from dominoplayer import SimpleAutoPlayer
class DominoGame:
"""
Esta es la clase principal del juego
"""
# estados del juego
GAME_STATE_SELECT_PIECE = 1
GAME_STATE_LOCATE_PIECE = 2
GAME_STATE_ANOTHER_USER = 3
GAME_STATE_FINISH_GAME = 4
def __init__(self, processor, drawingarea):
self.ui_player = None
self.table = DominoTableView()
self.pieces = []
self.placed_pieces = []
self.game_state = DominoGame.GAME_STATE_SELECT_PIECE
self.players = []
self.values = []
self.cantX = self.table.cantX
self.cantY = self.table.cantY
for n in range(0, self.cantX):
self.values.append([])
for p in range(0, self.cantY):
tile = Tile(n, p)
self.values[n].append(tile)
# primera y ultima posicion de las piezas
self.start = None
self.end = None
self.processor = processor
self.drawingarea = drawingarea
def next_player(self, num_player):
logging.debug('START n %s p %s direction %s value %s', self.start.n,
self.start.p, self.start.direction, self.start.value)
logging.debug('END n %s p %s direction %s value %s', self.end.n,
self.end.p, self.end.direction, self.end.value)
if num_player >= len(self.players) - 1:
return self.players[0]
else:
return self.players[num_player + 1]
# Posiciona una pieza en el tablero
def put_piece(self, player, piece, n, p):
player.remove_piece(piece)
valueA = piece.a
valueB = piece.b
if piece.reversed:
valueA = piece.b
valueB = piece.a
self.values[n][p].value = valueA
if piece.vertical:
self.values[n][p + 1].value = valueB
else:
self.values[n + 1][p].value = valueB
piece.state = DominoPiece.PIECE_PLACED
piece.visible = True
piece.x, piece.y = self.table.get_tile_position(n, p)
self.placed_pieces.append(piece)
player.order_piece_selected = 0
player.has_passed = False
self.drawingarea.queue_draw()
def test_free_position(self, n, p):
logging.debug('test_free_position %s %s', n, p)
if (n < 0) or (p < 0) or (n > self.cantX) or (p > self.cantY):
# Out of limits
logging.debug('Out of limits cantX %s catY %s',
self.cantX, self.cantY)
return False
try:
if self.values[n][p].value != -1:
# N,P position have a piece
logging.debug('Tile busy n %s p %s', n, p)
return False
except IndexError:
return False
return True
def _create_domino(self):
for n in range(0, 7):
for p in range(n, 7):
# creo pieza
piece = DominoPiece(n, p)
self.pieces.append(piece)
self.processor.alter_labels(self.pieces)
# Toma al azar una cantidad de piezas del juego y
# las devuelve en una coleccion
def take_pieces(self, cant):
result = []
for n in range(0, cant):
cantPieces = len(self.pieces)
if cantPieces > 0:
r = int(random.random() * cantPieces)
piece = self.pieces[r]
# la quito de las piezas del juego
self.pieces[r] = cantPieces
self.pieces.remove(cantPieces)
# la agrego a result
result.append(piece)
return result
# para debug
def print_value_pieces(self, pieceList):
for piece in pieceList:
logging.error('%s %s', piece.n, piece.p)
def start_game(self, numPlayers):
self._create_domino()
self.placed_pieces = []
self.players = []
auto_player = SimpleAutoPlayer(self, 0)
auto_player.set_pieces(self.take_pieces(7))
self.players.append(auto_player)
for n in range(1, numPlayers):
player = DominoPlayer(self, n)
player.set_pieces(self.take_pieces(7))
self.players.append(player)
# comienza a jugar el primer jugador
self.players[0].play()
self.ui_player = self.players[1]
self.ui_player.color = profile.get_color()
self.ui_player.name = profile.get_nick_name()
def show_pieces_player(self, player):
pieces = player.get_pieces()
if len(pieces) > 0:
separacion_x = int((dominoview.SCREEN_WIDTH - dominoview.SIZE *
len(pieces)) / len(pieces))
x = separacion_x / 2
y = player.pieces_y_position
for piece in pieces:
piece.x = x
piece.y = y
piece.vertical = True
x = x + dominoview.SIZE + separacion_x
piece.visible = True
class DominoGamePoints:
def __init__(self):
self.name = None
self.played = 0
self.win = 0
self.lost = 0
|
