def calculate_above(block: Block, blocks: List[Block]) -> Set[Block]:
"""
Calculated which of a given blocks are strictly above this given sample block.
:param block: a single block with a bottom level L
:param block_state: A full dictionary of blocks organized by thier top levels
X - Segment of initial block
A - Above (Suportee) blocks
N - Non above blocks
Front View | Side View | Top View
----------------------------------------------------------------------
AAAAAA | A | NNNNNN
N X N | NNNNNN XXXXXX |
| | A
| | XXAXXX
| | A
| | NNANNN
:return: A list of 1 or more blocks that are strictly above the given block,
or an empty list if no such blocks exist
"""
supported = set()
cells = block.get_cover_cells()
for potential_supported_block in blocks:
for cell in cells:
# Check if this cell is above under a cell from another block
if cell in potential_supported_block.get_cover_cells():
supported.add(potential_supported_block)
break
return supported
def calculate_below(block: Block, blocks: List[Block]) -> Set[Block]:
"""
Calculated which of a given list of blocks are strictly under this given sample block.
:param block: a single block with a bottom level L
:param blocks: A list of blocks, all top level L-1
X - Segment of initial block
S - Support blocks
N - Non support blocks
Front View | Side View | Top View
----------------------------------------------------------------------
XXXXXX | X | NNNNNN
N S S | NNNNNN SSSSSS |
| | X
| | SSXSSS
| | X
| | SSXSSS
:return: A list of 1 or more blocks that are strictly under the given block,
or an empty list if no such blocks exist
"""
supports = set()
cells = block.get_cover_cells()
for potential_support in blocks:
for cell in cells:
# Check if this cell is above under a cell from another block
if cell in potential_support.get_cover_cells():
supports.add(potential_support)
break
return supports
def test_spread(self):
tower_state = Tower_State()
#same orientation
orientation = 'tall_wide'
block1 = Block(block_mesh, orientation, (0, 0, 0))
block2 = Block(block_mesh, orientation, (2, 1, 0))
spread = tower_state.get_spread(block1, block2)
if DISPLAY:
display([block1.render(), block2.render()])
display_multiple_cells([block1.get_cells(), block2.get_cells()], scale=20)
display_multiple_grids([block1.get_cover_cells(), block2.get_cover_cells(), spread], scale=20)
orientation = 'short_wide'
block1 = Block(block_mesh, orientation, (0, 0, 0))
block2 = Block(block_mesh, orientation, (5, 5, 0))
spread = tower_state.get_spread(block1, block2)
if DISPLAY:
display([block1.render(), block2.render()])
display_multiple_cells([block1.get_cells(), block2.get_cells()], scale=20)
display_multiple_grids([block1.get_cover_cells(), block2.get_cover_cells(), spread], scale=20)
orientation = 'flat_thin'
block1 = Block(block_mesh, orientation, ( 0, 0, 0))
block2 = Block(block_mesh, orientation, (10, 10, 0))
spread = tower_state.get_spread(block1, block2)
if DISPLAY:
display([block1.render(), block2.render()])
display_multiple_cells([block1.get_cells(), block2.get_cells()], scale=20)
display_multiple_grids([block1.get_cover_cells(), block2.get_cover_cells(), spread], scale=20)
# differing orientations - must have same top level
block1 = Block(block_mesh, 'flat_wide', ( 0, 0, 0))
block2 = Block(block_mesh, 'tall_thin', ( 5, 3, -7))
spread = tower_state.get_spread(block1, block2)
if DISPLAY:
display([block1.render(), block2.render()])
display_multiple_cells([block1.get_cells(), block2.get_cells()], scale=20)
display_multiple_grids([block1.get_cover_cells(), block2.get_cover_cells(), spread], scale=20)
block1 = Block(block_mesh, 'flat_wide', ( 0, 0, 1))
block2 = Block(block_mesh, 'short_thin', ( -10, 3, 0))
spread = tower_state.get_spread(block1, block2)
if DISPLAY:
display([block1.render(), block2.render()])
display_multiple_cells([block1.get_cells(), block2.get_cells()], scale=20)
display_multiple_grids([block1.get_cover_cells(), block2.get_cover_cells(), spread], scale=20)
# test commutative quality of spread: ie. my spread with you is the same as yours spread with me.
block1 = Block(block_mesh, 'flat_wide', ( 0, 0, 1))
block2 = Block(block_mesh, 'short_thin', ( -15, 5, 0))
spread1 = tower_state.get_spread(block1, block2)
spread2 = tower_state.get_spread(block2, block1)
self.assertEqual(spread1, spread2)
if DISPLAY:
display([block1.render(), block2.render()])
display_multiple_cells([block1.get_cells(), block2.get_cells()], scale=20)
display_multiple_grids([block1.get_cover_cells(), block2.get_cover_cells(), spread1, spread2], scale=20)
block1 = Block(block_mesh, (0, 0, 0), (0, 5, 1))
block2 = Block(block_mesh, (0, 0, 0), (-2, -11, 1))
block3 = Block(block_mesh, 'flat_wide', (-1, -6, 3))
tower_state.set_blocks_above(block1, {block3})
tower_state.set_blocks_above(block2, {block3})
spread = tower_state.get_spread(block2, block1)
if DISPLAY:
display([block1.render(), block2.render()])
display_multiple_cells([block1.get_cells(), block2.get_cells()], scale=20)
display_multiple_grids([block1.get_cover_cells(), block2.get_cover_cells(), spread], scale=20)
block1 = Block(block_mesh, (0, 0, 0), (0, 9, 1))
block2 = Block(block_mesh, (0, 0, 0), (-2, -13, 1))
block3 = Block(block_mesh, 'flat_wide', (-1, -6, 3))
tower_state.set_blocks_above(block1, {block3})
tower_state.set_blocks_above(block2, {block3})
spread = tower_state.get_spread(block2, block1)
if DISPLAY:
display([block1.render(), block2.render()])
display_multiple_cells([block1.get_cells(), block2.get_cells()], scale=20)
display_multiple_grids([block1.get_cover_cells(), block2.get_cover_cells(), spread], scale=20)
block1 = Block(block_mesh, 'short_thin', (-8, -1, 1))
block2 = Block(block_mesh, 'short_thin', (7, 1, 1))
block3 = Block(block_mesh, 'flat_wide', (0, 0, 3))
tower_state.set_blocks_above(block1, {block3})
tower_state.set_blocks_above(block2, {block3})
spread = tower_state.get_spread(block2, block1)
if DISPLAY:
display([block1.render(), block2.render()])
display_multiple_cells([block1.get_cells(), block2.get_cells()], scale=20)
display_multiple_grids([block1.get_cover_cells(), block2.get_cover_cells(), spread], scale=20)
def get_spread(self, block1: Block, block2: Block):
"""
Retrieves the space between two blocks that can support blocks above, should their center of gravity
sit within them.
Spread should only be calculated between blocks that have already been recognized as close enough to hold
another block above them, otherwise behavior is not defined, or in the best case an assertion will fail.
This is garanteed by only calling get_spread on blocks both directly under the same piece.
Spread is commutative
:param block1:
:param block2:
:return:
"""
assert block1.get_top_level() == block2.get_top_level(
), str(block1) + str(block1.get_top_level()) + str(block2) + str(
block2.get_top_level())
# a spread with yourself it the cells you cover
if block1 == block2:
return block1.get_cover_cells()
ordered_pair = (block1, block2) if block1 < block2 else (block2,
block1)
if ordered_pair in self._spreads_memory: # shared with father
return self._spreads_memory[ordered_pair]
b1_cover_x = {cell[X] for cell in block1.get_cover_cells()}
b2_cover_x = {cell[X] for cell in block2.get_cover_cells()}
b1_cover_y = {cell[Y] for cell in block1.get_cover_cells()}
b2_cover_y = {cell[Y] for cell in block2.get_cover_cells()}
inter_x = b1_cover_x & b2_cover_x
inter_y = b1_cover_y & b2_cover_y
spread = set()
spread |= block1.get_cover_cells()
spread |= block2.get_cover_cells()
if (inter_x):
union_y = b1_cover_y | b2_cover_y
min_y = int(min(union_y))
max_y = int(max(union_y))
for y in range(min_y, max_y + 1):
for x in inter_x:
spread.add((x, y))
elif (inter_y):
union_x = b1_cover_x | b2_cover_x
min_x = int(min(union_x))
max_x = int(max(union_x))
for x in range(min_x, max_x + 1):
for y in inter_y:
spread.add((x, y))
else: # no common pieces - skew lines
"""
X XXXXXXX
XXXXXXX X X
or X or X
XXXXXXXX X X
Relevant for flat pieces only.
"""
pass
# See if the candidate blocks above can help increase spread
candidate_blocks = self.get_blocks_above(
block1) & self.get_blocks_above(block2)
if candidate_blocks:
flat_block = candidate_blocks.pop()
center_x, center_y, _ = tuple(flat_block.get_cog())
skew_center = set()
for cell in spread:
new_cell = ((cell[X] + center_x) // 2,
(cell[Y] + center_y) // 2)
skew_center.add(new_cell)
spread |= skew_center
self._spreads_memory[ordered_pair] = spread
return spread
