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)