def test_simple(self): dim = 64 a = Area(Rectangle(Field(0, 0), Field(dim - 1, dim - 1)), 1) load_from_file("../maps/4", a, 'x') pass
def test_dimensions(self): first = Field(0, 0) second = Field(9, 9) rect = Rectangle(first, second) self.assertEqual(rect.height(), 10) self.assertEqual(rect.width(), 10)
def load_from_file(filename, area, symbol): f = open(filename, 'r') dimension = area.height() # Primary loading, will load simple 1xn rectangles j = 0 i = 0 # Ugly imperative programming while j <= i: start = None newline = False i = 0 r = f.read(1) while i < dimension and len(r) > 0 and not newline: if r == symbol: if start is None: start = i elif start is not None: if i - start > 0: area += Rectangle(Field(start, j), Field(i - 1, j)) start = None if r == '\n': newline = True else: r = f.read(1) i += 1 j += 1 optimize_area(area)
def __init__(self, x, y, type=FieldType.empty, rectangle=None, corner_type=None): Field.__init__(self, x, y, type, rectangle) self.corner_type = corner_type
def test_remove(self): a = Area(Rectangle(Field(0, 0), Field(7, 7)), 1) r = Rectangle(Field(0, 0), Field(4, 4)) self.assertFalse(r in a.rectangles) a += r self.assertTrue(r in a.rectangles) a -= r self.assertFalse(r in a.rectangles)
def test_place(self): start = Field(3, 3) a = Area(Rectangle(Field(0, 0), Field(15, 15)), 2) w = Agent(a, start, RandomBehaviour()) self.assertTrue(w.position, start) bad_start = Field(323233223, 3322332) with self.assertRaises(Exception): w.position(bad_start)
def test_shell(self): start = Field(1, 1) end = Field(4, 4) ray = Ray(start, end) expected = Rectangle(start, end) # Checking result = ray.rectangle_shell() self.assertEqual(result, expected)
def test_shell2(self): start = Field(0.5, 0.5) end = Field(4.5, 4.5) ray = Ray(start, end) expected = Rectangle(Field(0, 0), Field(5, 5)) # Checking result = ray.rectangle_shell() self.assertEqual(result, expected)
def test_remove3(self): a = Area(Rectangle(Field(0, 0), Field(15, 15)), 3) r = Rectangle(Field(8, 10), Field(10, 11)) self.assertFalse(r in a.top_right.bottom_left.rectangles) a += r self.assertTrue(r in a.top_right.bottom_left.rectangles) a -= r self.assertFalse(r in a.top_right.bottom_left.rectangles)
def test_remove2(self): a = Area(Rectangle(Field(0, 0), Field(15, 15)), 2) r = Rectangle(Field(0, 0), Field(6, 6)) self.assertFalse(r in a.bottom_left.rectangles) a += r self.assertTrue(r in a.bottom_left.rectangles) a -= r self.assertFalse(r in a.bottom_left.rectangles)
def test_hash_true(self): first = Field(0, 0) second = Field(9, 9) rect1 = Rectangle(first, second) rect2 = Rectangle(first, second) self.assertEqual(rect1.__hash__(), rect2.__hash__())
def test_init_subindexes(self): a = Area(Rectangle(Field(0, 0), Field(7, 7)), 2) self.assertTrue( a.bottom_left.main == Rectangle(Field(0, 0), Field(3, 3))) self.assertTrue( a.bottom_right.main == Rectangle(Field(4, 0), Field(7, 3))) self.assertTrue(a.top_left.main == Rectangle(Field(0, 4), Field(3, 7))) self.assertTrue( a.top_right.main == Rectangle(Field(4, 4), Field(7, 7)))
def test_all_rectangles(self): a = Area(Rectangle(Field(0, 0), Field(127, 127)), 4) original = set() for i in range(0, 100): rect = Rectangle(Field(i, i), Field(i, i)) original.add(rect) a += rect result = a.all_rectangles() self.assertEqual(original, result)
def area(): a = Area.of_size(64) rectangles = [ Rectangle(Field(50, 0), Field(40, 50), type=FieldType.inaccessible), ] a += rectangles return a
def test_init_area(self): a = Area(Rectangle(Field(0, 0), Field(31, 31)), 2) rect = Rectangle(Field(5, 5), Field(10, 10)) a += rect for c in rect.corners(): self.assertEqual(c.rectangle.area, a)
def test_sorting(self): f1 = Field(20, 100) f2 = Field(3, 5) f3 = Field(5, 2) f4 = Field(100, 100) data = [f1, f2, f3, f4] data.sort(key=lambda f: (f.x, f.y), reverse=True) self.assertEqual(data, [f4, f1, f3, f2])
def __init__(self, area): self.area = area self.dimension = area.main.width() self.fields = np.zeros(shape=(self.dimension, self.dimension), dtype=int) self.fill_rectangle(Rectangle( Field(0, 0), Field(self.dimension - 1, self.dimension - 1)), value=self.EMPTY_SEEN) self.gen_walls()
def confine(self): if self.area: start = Field(max(self.area.main.start.x, self.start.x - 1), max(self.area.main.start.y, self.start.y - 1)) end = Field(min(self.area.main.end.x, self.end.x + 1), min(self.area.main.end.y, self.end.y + 1)) else: start = Field(max(0, self.start.x - 1), max(0, self.start.y - 1)) end = Field(self.end.x + 1, self.end.y + 1) return Rectangle(start, end, type=self.type, area=None)
def test_init_subsubindexes(self): a = Area(Rectangle(Field(0, 0), Field(7, 7)), 3) self.assertTrue(a.bottom_left.bottom_left.main == Rectangle( Field(0, 0), Field(1, 1))) self.assertTrue(a.bottom_left.bottom_right.main == Rectangle( Field(2, 0), Field(3, 1))) self.assertTrue( a.bottom_left.top_left.main == Rectangle(Field(0, 2), Field(1, 3))) self.assertTrue(a.bottom_left.top_right.main == Rectangle( Field(2, 2), Field(3, 3)))
def test_corner_shell(self): test_cases = { Rectangle(Field(0, 0), Field(5, 5)): Rectangle(Point(-0.5, -0.5), Point(5.5, 5.5)), Rectangle(Field(2, 2), Field(4, 4)): Rectangle(Point(1.5, 1.5), Point(4.5, 4.5)) } for case, expected in test_cases.items(): self.assertEqual(case.corner_shell(), expected)
def test_and_none(self): big1 = Field(5, 5) big2 = Field(10, 10) small1 = Field(1, 1) small2 = Field(4, 4) big = Rectangle(big1, big2) small = Rectangle(small1, small2) self.assertEqual(None, big & small)
def test_str(self): first = Field(0, 0) second = Field(17, 10) expected = "(0,10) ... (17,10)\n" \ "... ... ...\n" \ "(0,0) ... (17,0)" rect = Rectangle(first, second) self.assertEqual(rect.__str__(), expected)
def middle(self): mid_x = (self.start.x + self.end.x) // 2 mid_y = (self.start.y + self.end.y) // 2 # Parity of dimensions, sorry for unclarity, the best way x_adjust = (self.width() + 1) % 2 y_adjust = (self.width() + 1) % 2 if x_adjust + y_adjust == 0: return Field(mid_x, mid_y, type=self.type) else: return Rectangle(Field(mid_x, mid_y), Field(mid_x + 1, mid_y + 1), type=self.type)
def test_add_multiple_list(self): a = Area(Rectangle(Field(0, 0), Field(15, 15)), 1) rectangles = [ Rectangle(Field(2, 2), Field(3, 3)), Rectangle(Field(2, 5), Field(3, 5)), Rectangle(Field(5, 2), Field(6, 3)), Rectangle(Field(5, 5), Field(6, 6)) ] a += rectangles # Check self.assertEqual(set(rectangles), a.all_rectangles())
def test_all_rectangles_complex(self): a = Area(Rectangle(Field(0, 0), Field(511, 511)), 4) original = set() for i in range(1, 20): for j in range(1, 20): rect = (Rectangle(Field(i * 6, j * 6), Field(i * 6 + 2, j * 6 + 2))) original.add(rect) a += rect result = a.all_rectangles() self.assertEqual(original, result)
def test_and_contains(self): big1 = Field(0, 0) big2 = Field(10, 10) small1 = Field(4, 4) small2 = Field(8, 8) big = Rectangle(big1, big2) small = Rectangle(small1, small2) self.assertEqual(small, big & small) self.assertEqual(small & big, big & small)
def test_conversion2(self): r = Rectangle(Field(1, 1), Field(5, 5)) results = { "(1,1)": (0.5, 0.5), "(1,5)": (0.5, 5.5), "(5,1)": (5.5, 0.5), "(5,5)": (5.5, 5.5) } for c in r.corners(): r = results[c.__str__()] self.assertEqual(Point(r[0], r[1]), Point.corner_to_point(c))
def test_root(self): a = Area(Rectangle(Field(0, 0), Field(1023, 1023)), 8) other = Area(Rectangle(Field(0, 0), Field(1023, 1023)), 8) for child in a.children: while child.is_subindexed(): child = child.bottom_left self.assertEquals(child.get_root(), a) # Abusive self.assertNotEqual(child.get_root(), child) self.assertNotEqual(child.get_root(), child.parent) self.assertNotEqual(child.get_root(), other)
def gen_area(self): # DO NOT CHANGE!!! a = Area(Rectangle(Field(0, 0), Field(15, 15)), 1) rectangles = [ Rectangle(Field(2, 2), Field(3, 3), type=FieldType.inaccessible), Rectangle(Field(2, 5), Field(3, 6), type=FieldType.inaccessible), Rectangle(Field(5, 2), Field(6, 3), type=FieldType.inaccessible), Rectangle(Field(6, 5), Field(6, 5), type=FieldType.inaccessible) ] a += rectangles return a
def test_add_multiple(self): a = Area(Rectangle(Field(0, 0), Field(15, 15)), 2) r = Rectangle(Field(6, 6), Field(10, 10)) self.assertFalse(r in a.bottom_left.rectangles) self.assertFalse(r in a.bottom_right.rectangles) self.assertFalse(r in a.top_left.rectangles) self.assertFalse(r in a.top_right.rectangles) a += r self.assertTrue(r in a.bottom_left.rectangles) self.assertTrue(r in a.bottom_right.rectangles) self.assertTrue(r in a.top_left.rectangles) self.assertTrue(r in a.top_right.rectangles)
def __init__(self, memory: Memory=None, fieldsize_x: int=None, fieldsize_y: int=None, sleeptime=0.5): if fieldsize_x is None and fieldsize_y is None and memory is not None: self.__field = memory.current().get_field() self.__memory = memory else: self.__memory = Memory() if fieldsize_x is None: fieldsize_x = 10 if fieldsize_y is None: fieldsize_y = 10 self.__field = Field(fieldsize_x, fieldsize_y) self.__is_running = Event() self.__is_running.clear() self.__sleeptime = sleeptime
def do(self) -> Field: self.__post = Field(self.__pre.get_size()[0], self.__pre.get_size()[1]) for x, y in self.__pre.field_iter(): alive_neighbours = self.__pre.get_number_of_neighbours_with_state(x, y, TileState.alive) # case reborn ( 3 living neighbours) if alive_neighbours == 3 and self.__pre.get_tile_state(x, y) is TileState.dead: self.__post.set_tile_state(x, y, TileState.alive) if self.__pre.get_tile_state(x, y) == TileState.dead: self.__became_alive_number += 1 # case staying alive ( 2 or 3 living neighbours) elif 1 < alive_neighbours < 4 and self.__pre.get_tile_state(x, y) is TileState.alive : self.__post.set_tile_state(x, y, TileState.alive) # case dying else: self.__post.set_tile_state(x, y, TileState.dead) if self.__pre.get_tile_state(x, y) == TileState.alive: self.__became_dead_number += 1 return self.__post
class Turn: def __init__(self, field: Field): self.__pre = field self.__post = None self.__became_alive_number = 0 self.__became_dead_number = 0 def do(self) -> Field: self.__post = Field(self.__pre.get_size()[0], self.__pre.get_size()[1]) for x, y in self.__pre.field_iter(): alive_neighbours = self.__pre.get_number_of_neighbours_with_state(x, y, TileState.alive) # case reborn ( 3 living neighbours) if alive_neighbours == 3 and self.__pre.get_tile_state(x, y) is TileState.dead: self.__post.set_tile_state(x, y, TileState.alive) if self.__pre.get_tile_state(x, y) == TileState.dead: self.__became_alive_number += 1 # case staying alive ( 2 or 3 living neighbours) elif 1 < alive_neighbours < 4 and self.__pre.get_tile_state(x, y) is TileState.alive : self.__post.set_tile_state(x, y, TileState.alive) # case dying else: self.__post.set_tile_state(x, y, TileState.dead) if self.__pre.get_tile_state(x, y) == TileState.alive: self.__became_dead_number += 1 return self.__post def undo(self) -> Field: return self.__pre def get_field(self) -> Field: return self.__post if self.__post is not None else self.__pre def get_birth_number(self): return self.__became_alive_number def get_death_number(self): return self.__became_dead_number
class Game: __observers = [] __thread = None def __init__(self, memory: Memory=None, fieldsize_x: int=None, fieldsize_y: int=None, sleeptime=0.5): if fieldsize_x is None and fieldsize_y is None and memory is not None: self.__field = memory.current().get_field() self.__memory = memory else: self.__memory = Memory() if fieldsize_x is None: fieldsize_x = 10 if fieldsize_y is None: fieldsize_y = 10 self.__field = Field(fieldsize_x, fieldsize_y) self.__is_running = Event() self.__is_running.clear() self.__sleeptime = sleeptime def start(self): if not self.__is_running.is_set(): self.__is_running.set() self.__thread = Thread(target=self.run) self.__thread.setDaemon(True) self.__thread.start() def run(self): while self.__is_running.is_set(): turn = Turn(self.__field) self.__field = turn.do() self.__memory.save(turn) for observer in self.__observers: observer.notify(self.__field) sleep(self.__sleeptime) def set_sleeptime(self, time: int): self.__sleeptime = time def stop(self) -> Memory: if self.__is_running.is_set(): self.__is_running.clear() self.save() def toggle(self): if self.__is_running.is_set(): self.stop() else: self.start() def add_observer(self, observer): if observer is not None: self.__observers.append(observer) def remove_observer(self, observer): if observer in self.__observers: self.__observers.remove(observer) def remove_all_observers(self): self.__observers = [] def load(self, name): self.__memory.load(name) self.__field = self.__memory.current().get_field() def save(self, name=None): if name is None: self.__memory.persist() else: self.__memory.persist(name) def toggle_tile(self, x, y): # if not self.__is_running.is_set(): self.__field.toggle_tile_state(x, y) for observer in self.__observers: observer.notify(self.__field)