So I was write as I suspected; the grid is not actually being built like I thought it was. Sure the ID's print fine but when the grid positions are procedurally accessed the program fails with IndexError.

python3 test1.py
| 19 |  5 |  5 |  5 |
| 11 |  6 | 19 | 11 |
|  6 |  6 | 11 | 19 |
| 11 | 20 |  6 |  5 |
| 11 |  5 | 20 |  5 |
| 20 | 20 | 11 | 11 |
| 19 | 19 |  5 |  5 |
| 11 | 19 | 19 |  5 |
After Eliminations
|  0 |  0 |  0 |  5 |
| 11 |  0 | 19 | 11 |
|  0 |  0 | 11 |  0 |
|  0 | 20 |  6 |  0 |
|  0 |  5 | 20 |  0 |
|  0 |  0 |  0 |  0 |
| 19 |  0 |  0 |  0 |
|  0 |  0 |  0 |  0 |
broke 0 5
0 6
broke 1 6
1 7
broke 2 6
2 7
broke 3 6
3 7
After Drops
|  0 |  0 |  0 |  5 |
|  0 |  0 | 19 |  0 |
|  0 |  0 | 11 |  0 |
|  0 | 20 |  6 |  0 |
|  0 |  0 |  0 |  0 |
|  0 |  0 |  0 |  0 |
| 11 |  0 |  0 |  0 |
| 19 |  5 | 20 | 11 |
Normal
| 0,0 | 1,0 | 2,0 | 3,0 |
| 0,1 | 1,1 | 2,1 | 3,1 |
| 0,2 | 1,2 | 2,2 | 3,2 |
| 0,3 | 1,3 | 2,3 | 3,3 |
| 0,4 | 1,4 | 2,4 | 3,4 |
| 0,5 | 1,5 | 2,5 | 3,5 |
| 0,6 | 1,6 | 2,6 | 3,6 |
| 0,7 | 1,7 | 2,7 | 3,7 |
Procedurally
# The first printed pair is the id, the second pair in parentheses is
# the procedurally accessed id, which should be all ordered as (column,
# row)
| 0,0 (0,0) | 1,0 (0,1) | 2,0 (0,2) | 3,0 (0,3) | Traceback (most recent call last):
  File "test1.py", line 186, in <module>
    grid.draw_by_id_proc()
  File "test1.py", line 75, in draw_by_id_proc
print(self.grid[col_num][row_num].id, '(' + str(col_num) + ',' + str(row_num) + ')', end=' | ')
IndexError: list index out of range


I am attempting to fix it now. Any help is appreciated.

#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 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(col_num, row_num, self.values)
                   for col_num in range(self.cols)]
            self.grid.append(row)
        self.transposed_grid = list(zip(*self.grid))

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

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

    def draw_by_id_trans(self):
        for col in self.transposed_grid:
            print(end='| ')
            for node in col:
                print(node.id, end=' | ')
            print()

    def draw_by_id_proc(self):
        # Draw Procedurally
        for col_num in range(self.cols):
            print(end='| ')
            for row_num in range(self.rows):
print(self.grid[col_num][row_num].id, '(' + str(col_num) + ',' + str(row_num) + ')', 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_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.transposed_grid:
            while True:
                # Low is on Top, High is on Bottom
                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

    def drop_floating_nodes1(self):
        i = 0
        for col_list in self.transposed_grid:
            while True:
                try:
                    low, high = col_list[i: i + 2]  # Goes Down the Rows
                    if high.value == 0 and low.value != 0:
                        high.value = low.value
                        low.value = 0
                    i += 1
                except ValueError:
                    i = 0
                    break




grid = GameGrid(4, 8)
grid.draw()
grid.find_eliminations()
print('After Eliminations')
grid.draw()
#print()
grid.drop_floating_nodes0()
print('After Drops')
grid.draw()
print('Normal')
grid.draw_by_id()
#print('Tansposed')
#grid.draw_by_id_trans()
print('Procedurally')
grid.draw_by_id_proc()
_______________________________________________
Tutor maillist  -  Tutor@python.org
To unsubscribe or change subscription options:
https://mail.python.org/mailman/listinfo/tutor

Reply via email to