[Tutor] Improving My Simple Game Code for Speed, Memory and Learning

[WolfRage]

On 01/03/2015 04:42 PM, Dave Angel wrote:
> On 01/03/2015 04:22 PM, WolfRage wrote:
>> On 01/03/2015 06:58 AM, Dave Angel wrote:
>>> To transpose a grid, you want to use the zip() function.
>>>      self.transposed_grid = zip(*self.grid)
>> I see this gives me a list that is the column. Thus it solves the column
>> iteration problem, because now I can feed it to my checking and
>> elimination functions that take a slice.
>> Thanks!
>> Implementing now.
>
> I suspect you want instead:
>
>      self.transposed_grid = list( zip(*self.grid) )
>
> in Python 3.4.  zip gives an iterable for python 3.x, while it gave a
> list in python 2.x
>
> This is what I meant by "untested."
>
OK, I will try that implementation next. But I think this currently 
works well. Here is the latest iteration of my code.

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

     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 make_grid(self):
         # grid is 2d array as x, y ie [x][y].
         self.grid = []
         for row_num in range(self.rows):
             # Do you still think this needs to be broken into a smaller 
method?
             row = [GameTile(row_num, col_num, self.values)
                    for col_num in range(self.cols)]
             self.grid.append(row)
         self.transposed_grid = zip(*self.grid)

     def draw(self):
         for col in self.grid:
             print(end='| ')
             for node in col:
                 print(node, end=' | ')
             print()

     def find_eliminations(self):
         #First Down the columns.
         i = 0
         for col_list in self.transposed_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.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.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_nodes(self):
         pass
         # Now we can used the transposed_grid!




grid = GameGrid(4, 8)
grid.draw()
grid.find_eliminations()
print('After Eliminations')
grid.draw()