On 01/12/2015 05:00 PM, Alan Gauld wrote:
<SNIP>
__str__methodf of the grid.
Then the draw method becomes print(self)
And you can also just use print(aGrid) etc.
<SNIP>
Implemented with some other improvements using the same idea but applied
to several of the other functions, that provide output.
Now I am going to try and add the ability to have the table generated
but with a set number of rows empty or pre-set to zero.
#CODE BELOW
import random
class GameTile():
def __init__(self, col, row, values=None, value=None, **kwargs):
# values is not required because the value can be directly set.
# This is to support a future feature that will allow me to build a
# board off of a list.
# id is grid(X,Y) which is equal to grid(col,row)
self.id = str(col) + ',' + str(row)
self.col = col
self.row = row
if value is None:
value = random.choice(values)
self.value = value
self.eliminated = False
# hide_anim = hidden for animation purposes
self.hide_anim = False
# drop_value = value to be dropped during animation
self.drop_value = None
# drop_to could have inversely been a drop_from
# drop_to = the id of where the value should be dropped too.
self.drop_to = None
def __str__(self):
return "%2d" % self.value
class GameGrid():
def __init__(self, cols=8, rows=7, **kwargs):
if cols < 3 or rows < 3:
raise ValueError("Minimum board size is 3x3! %sx%s is too
small."
% (cols, rows))
self.cols = cols
self.rows = rows
self.values = [5, 6, 11, 19, 20]
self.make_grid()
def __str__(self):
output = []
for row in self.transposed_grid:
s = '| '
for node in row:
s += str(node) + ' | '
output.append(s)
return '\n'.join(output)
def make_grid(self):
# grid is 2d array as x, y ie [x][y].
# transposed_grid is 2d array as y, x ie [y][x]
self.transposed_grid = []
for row_num in range(self.rows):
row = [GameTile(col_num, row_num, self.values)
for col_num in range(self.cols)]
self.transposed_grid.append(row)
self.grid = list(zip(*self.transposed_grid))
def draw(self):
print(self)
def draw_by_id(self):
# Why does this one use self.transposed_grid instead of self.grid ?
output = []
for row in self.transposed_grid:
s = '| '
for node in row:
s += str(node.id) + ' | '
output.append(s)
return '\n'.join(output)
def draw_by_id_proc(self):
# Draw Procedurally
output = []
for row_num in range(self.rows):
s = '| '
for col_num in range(self.cols):
s += (str(self.grid[col_num][row_num].id) + '(' +
str(col_num) +
',' + str(row_num) + ')' + ' | ')
output.append(s)
return '\n'.join(output)
def draw_by_id_trans(self):
# Why does this one use self.grid instead of self.transposed_grid ?
output = []
for col in self.grid:
s = '| '
for node in col:
s += str(node.id) + ' | '
output.append(s)
return '\n'.join(output)
def draw_by_id_trans_proc (self):
# Draw Transposed & Procedurally
output = []
for col_num in range(self.cols):
s = '| '
for row_num in range(self.rows):
s += (str(self.transposed_grid[row_num][col_num].id) +
'(' +
str(col_num) + ',' + str(row_num) + ')' + ' | ')
output.append(s)
return '\n'.join(output)
def find_eliminations(self):
#First Down the columns.
i = 0
for col_list in self.grid:
while True:
try:
if self.check_total(col_list[i: i + 3]):
self.eliminate(col_list[i: i + 3])
i += 1
except ValueError:
i = 0
break
# Now across the rows.
for row_list in self.transposed_grid:
while True:
try:
if self.check_total(row_list[i: i + 3]):
self.eliminate(row_list[i: i + 3])
i += 1
except ValueError:
i = 0
break
# Set all eliminated nodes to a value of 0.
for col in self.transposed_grid:
for node in col:
if node.eliminated is True:
node.eliminated = False
node.value = 0
def check_total(self, slices):
first, second, third = slices
if first.value == second.value or second.value == third.value:
total = first.value + second.value + third.value
return total in (17, 21, 28, 29, 31, 42, 45, 46, 49, 58)
def eliminate(self, slices):
first, second, third = slices
first.eliminated = True
second.eliminated = True
third.eliminated = True
def drop_floating_nodes0(self):
i = self.rows
# first_zero_row serves as memory for how far to drop non-zero
values
first_zero_row = None
for col_list in self.grid:
while True:
# Low is on Top it is low because it is the lower
numbered row
# High is on Bottom it is high because it is the higher
numbered
low, high = col_list[i - 2: i] # Goes Up the Rows
if high.value == 0:
if low.value != 0:
if first_zero_row is None:
high.value = low.value
low.value = 0
first_zero_row = low
else:
first_zero_row.value = low.value
low.value = 0
try:
row = first_zero_row.row - 1
col = first_zero_row.col
first_zero_row = self.grid[col][row]
except:
i = self.rows
print('broke', col, row)
print(first_zero_row.col,
first_zero_row.row)
first_zero_row = None
break
else:
if first_zero_row is None:
first_zero_row = high
i -= 1
if i == 1:
i = self.rows
first_zero_row = None
break
grid = GameGrid(4, 8)
print(grid)
grid.find_eliminations()
print('After Eliminations')
print(grid)
grid.drop_floating_nodes0()
print('After Drops')
print(grid)
print('By ID')
print(grid.draw_by_id())
print('By ID & Procedurally')
print(grid.draw_by_id_proc())
print('Transposed')
print(grid.draw_by_id_trans())
print('Transposed & Procedurally')
print(grid.draw_by_id_trans_proc())
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
https://mail.python.org/mailman/listinfo/tutor
