def create_events(self, dungeon: Dungeon):
self.all_reset_events()
floor_map = dungeon.floor_map
room_size = dungeon.room_size
player = self.__player
height, width = floor_map.shape
self.__enemy_map = Matrix(height, width, dtype='object')
self.__treasure_map = Matrix(height, width, dtype='object')
self.__create_stair(floor_map, width, height, room_size)
for _ in range(60):
x = random.randint(3, width - 4)
y = random.randint(3, height - 4)
if not self.__can_create_events(dungeon, (y, x)):
continue
choice = random.choice([1, 2, 2, 2, 2])
if choice == 1:
treasure = TreasureBox((y, x), self.__game_system,
self.__game_info)
self.__treasure_map[treasure.map_coordinate] = treasure
else:
enemy = Enemy((y, x), self.__game_system, self.__game_info,
dungeon, player, self.__enemy_map)
self.__enemy_map[enemy.map_coordinate] = enemy
def __init__(self, game_system: GameSystem, game_info: GameInfo,
player: Player):
self.__game_system = game_system
self.__game_info = game_info
self.__player = player
self.__enemy_map = Matrix()
self.__treasure_map = Matrix()
self.__stair: Stairs = None
def get_delta(self, cur_x):
n = cur_x.size[1]
a = MathFunction.get_jacobian_matrix(self.functions, cur_x[0])
b = Matrix((n, 1))
elems_b = []
for f in self.functions:
elems_b.append(-f(*cur_x[0]))
b.fill(*elems_b)
return GaussMethod(a, b).solve().transpose()
def __solve(self, prec, left_boundary, right_boundary, log):
points = reduce((lambda ss, cs: (s + [c] for s in ss for c in cs)),
zip(left_boundary, right_boundary),
[[]])
lam = -1
min_jac = None
first_point = None
for p in points:
tmp = MathFunction.get_jacobian_matrix(self.functions, p).norm_inf()
if tmp > lam:
lam = tmp
# first_point = p
if min_jac is None:
min_jac = tmp
first_point = p
elif tmp < min_jac:
min_jac = tmp
first_point = p
lam = 1 / lam
dpr('lambda =', lam)
dpr('min jacobian =', min_jac)
dpr('=> first point =', first_point)
prev_x = Matrix((1, len(first_point)))
prev_x.fill(*first_point)
# jac = MathFunction.get_jacobian_matrix(self.functions, monotonicity_interval[0])
# lam = 1 / jac.norm_inf()
phi_list = [lambda *x, f=self.functions[i], l=lam, i=i: x[i] - l*f(*x)
for i in range(len(self.functions))]
q = 0.9
# relax_coef = 0.1
cur_x = self.__next_x(prev_x, phi_list)
# prev_x *= 1 - relax_coef
# cur_x *= relax_coef
# cur_x += prev_x
dpr('iter 1')
dpr('prev_x =', prev_x[0])
dpr('cur_x =', cur_x[0])
iter_count = 1
while q / (1 - q) * (cur_x - prev_x).transpose().norm_inf() > prec:
dpr('prec = ', (cur_x - prev_x).transpose().norm_inf())
prev_x = cur_x
cur_x = self.__next_x(prev_x, phi_list)
iter_count += 1
dpr('next x = ', cur_x[0])
if log:
pass
# print("Number of iterations (with first point x0 = {}) = {}".format(first_point, iter_count))
return cur_x[0]
def __get_base_map(self) -> Matrix:
height, width = self.__base_size
base_map = Matrix(height, width)
XP = [0, 1, 0, -1]
YP = [-1, 0, 1, 0]
FLOOR = FloorType.FLOOR
WALL = FloorType.WALL
for x in range(width):
base_map[0, x] = WALL
base_map[height - 1, x] = WALL
for y in range(1, height - 1):
base_map[y, 0] = WALL
base_map[y, width - 1] = WALL
for y in range(1, height - 1):
for x in range(1, width - 1):
base_map[y, x] = FLOOR
for y in range(2, height - 2, 2):
for x in range(2, width - 2, 2):
base_map[y, x] = WALL
for y in range(2, height - 2, 2):
for x in range(2, width - 2, 2):
d = random.randint(0, 3)
if x > 2:
d = random.randint(0, 2)
base_map[y + YP[d], x + XP[d]] = WALL
return base_map
def __solve(self, prec, monotonicity_interval, log):
"""
monotonicity_interval: two points in Rn
"""
first_point = list(map(lambda x, y: (x + y) / 2, *monotonicity_interval))
prev_x = Matrix((1, len(first_point)))
prev_x.fill(*first_point)
cur_x = self.get_delta(prev_x) + prev_x
iter_count = 1
while (cur_x - prev_x).norm_inf() > prec:
prev_x = cur_x
cur_x = self.get_delta(prev_x) + prev_x
iter_count += 1
if log:
print("Number of iterations (with first point x0 = {}) = {}".format(first_point, iter_count))
return cur_x[0]
def draw(self,
game_system: GameSystem,
center: (int, int),
floor_map: Matrix
):
center_y, center_x = center
min_y = -4
max_y = 6
min_x = -5
max_x = 6
self.__stair.draw()
for around_y in range(min_y, max_y):
for around_x in range(min_x, max_x):
map_y = center_y + around_y
map_x = center_x + around_x
if not floor_map.is_in((map_y, map_x)):
continue
treasure = self.__treasure_map[map_y, map_x]
if treasure is not None:
treasure.draw()
enemy = self.__enemy_map[map_y, map_x]
if enemy is not None:
enemy.draw()
def __update_L_mtrx(self, prev_a_mtrx, k):
mk = Matrix.identity(self.__mtrx.size)
for i in range(k+1, mk.size[0]):
mu = self.__get_mu(prev_a_mtrx, i, k)
mk[i][k] = -mu
self.__L[i][k] = mu
return mk
def get_inverse_matrix(mtrx, log=False):
gm = GaussMethod(mtrx)
gm.log(log)
inv_mtrx = Matrix([mtrx.size[0], 0])
b = Matrix([mtrx.size[0], 1])
for i in range(mtrx.size[0]):
b[i-1][0] = 0
b[i][0] = 1
gm.set_vector(b)
inv_mtrx.append_col(gm.solve())
if log:
print("Check the correctness of the answer: ")
print("A * A^(-1) = ")
print(mtrx * inv_mtrx)
print()
return inv_mtrx
def __init__(self,
game_info: GameInfo,
base_size: (int, int),
room_size: int):
self.__game_info = game_info
self.__base_size = base_size
self.__room_size = room_size
self.__floor_map = Matrix()
def create_floor_map(self):
base_size = self.__base_size
room_size = self.__room_size
base_map = self.__get_base_map()
base_height, base_width = base_size
height = base_height * room_size
width = base_width * room_size
floor_map = Matrix(height, width)
FLOOR = FloorType.FLOOR
WALL = FloorType.WALL
for y in range(height):
for x in range(width):
floor_map[y, x] = WALL
for y in range(1, base_height - 1):
for x in range(1, base_width - 1):
dx = x * room_size + 1
dy = y * room_size + 1
if base_map[y, x] == FLOOR:
if random.randint(0, 99) < 20:
for ry in range(-1, room_size - 1):
for rx in range(-1, room_size - 1):
floor_map[dy + ry, dx + rx] = FLOOR
else:
floor_map[dy, dx] = FLOOR
road_size = math.floor(room_size / 2) + 1
if base_map[y - 1, x] == FLOOR:
for ry in range(1, road_size):
floor_map[dy - ry, dx] = FLOOR
if base_map[y + 1, x] == FLOOR:
for ry in range(1, road_size):
floor_map[dy + ry, dx] = FLOOR
if base_map[y, x - 1] == FLOOR:
for rx in range(1, road_size):
floor_map[dy, dx - rx] = FLOOR
if base_map[y, x + 1] == FLOOR:
for rx in range(1, road_size):
floor_map[dy, dx + rx] = FLOOR
self.__floor_map = floor_map
def all_reset_events(self):
self.__enemy_map = Matrix()
self.__treasure_map = Matrix()
class EventManager:
@property
def enemys(self) -> []:
return self.__enemy_map.get_not_empty_values()
@property
def enemy_map(self) -> Matrix:
return self.__enemy_map
@property
def treasure_map(self) -> Matrix:
return self.__treasure_map
def __init__(self, game_system: GameSystem, game_info: GameInfo,
player: Player):
self.__game_system = game_system
self.__game_info = game_info
self.__player = player
self.__enemy_map = Matrix()
self.__treasure_map = Matrix()
self.__stair: Stairs = None
def remove_enemy(self, event: Event):
self.__enemy_map[event.map_coordinate] = None
def remove_treasure(self, treasure_box: TreasureBox):
self.__treasure_map[treasure_box.map_coordinate] = None
def all_reset_events(self):
self.__enemy_map = Matrix()
self.__treasure_map = Matrix()
def ready_move_enemys(self):
for enemy in self.__enemy_map.get_not_empty_values():
if not enemy.ready_move():
continue
self.__enemy_map[enemy.next_position] = enemy
self.__enemy_map[enemy.map_coordinate] = None
def move_enemys(self):
for enemy in self.__enemy_map.get_not_empty_values():
enemy.move()
def get_enemy(self, position: (int, int)) -> Optional[Enemy]:
return self.__enemy_map[position]
def get_treasure_box(self, position: (int, int)) -> Optional[TreasureBox]:
return self.__treasure_map[position]
def is_floor_clear(self) -> bool:
return self.__player.map_coordinate == self.__stair.map_coordinate
def __create_stair(self, floor_map: Matrix, width: int, height: int,
room_size: int):
while True:
x = random.randint(3, width - 4)
y = random.randint(3, height - 4)
if floor_map[y, x] == FloorType.WALL:
continue
area_size = math.floor(room_size / 2) + 1
for ry in range(-area_size, area_size):
for rx in range(-area_size, area_size):
floor_map[y + ry, x + rx] = FloorType.FLOOR
self.__stair = Stairs((y, x), self.__game_system, self.__game_info)
break
def __can_create_events(self, dungeon: Dungeon,
position: (int, int)) -> bool:
y, x = position
if dungeon.floor_map[y, x] == FloorType.WALL:
return False
if self.__enemy_map[y, x] is not None:
return False
if self.__treasure_map[y, x] is not None:
return False
if self.__stair.y == y and self.__stair.x == x:
return False
return True
def create_events(self, dungeon: Dungeon):
self.all_reset_events()
floor_map = dungeon.floor_map
room_size = dungeon.room_size
player = self.__player
height, width = floor_map.shape
self.__enemy_map = Matrix(height, width, dtype='object')
self.__treasure_map = Matrix(height, width, dtype='object')
self.__create_stair(floor_map, width, height, room_size)
for _ in range(60):
x = random.randint(3, width - 4)
y = random.randint(3, height - 4)
if not self.__can_create_events(dungeon, (y, x)):
continue
choice = random.choice([1, 2, 2, 2, 2])
if choice == 1:
treasure = TreasureBox((y, x), self.__game_system,
self.__game_info)
self.__treasure_map[treasure.map_coordinate] = treasure
else:
enemy = Enemy((y, x), self.__game_system, self.__game_info,
dungeon, player, self.__enemy_map)
self.__enemy_map[enemy.map_coordinate] = enemy
def draw(self, game_system: GameSystem, center: (int, int),
floor_map: Matrix):
center_y, center_x = center
min_y = -4
max_y = 6
min_x = -5
max_x = 6
self.__stair.draw()
for around_y in range(min_y, max_y):
for around_x in range(min_x, max_x):
map_y = center_y + around_y
map_x = center_x + around_x
if not floor_map.is_in((map_y, map_x)):
continue
treasure = self.__treasure_map[map_y, map_x]
if treasure is not None:
treasure.draw()
enemy = self.__enemy_map[map_y, map_x]
if enemy is not None:
enemy.draw()
def __LU_decomposition(self):
self.__L = Matrix.identity(self.__mtrx.size)
ak_mtrx = self.__mtrx.copy()
if self.need_logging:
print("A0 = ")
print(ak_mtrx)
k = GaussMethod.__max_row_in_col(ak_mtrx, 0, 0)
if k != 0:
self.__permutations.append((0, k))
ak_mtrx.exchange_rows(0, k)
if self.need_logging:
print("In A{} exchange {} and {} rows\n".format(0, 0, k))
if self.need_logging:
print("PA{} = ".format(0))
print(ak_mtrx)
print("L{} = ".format(0))
print(self.__L)
ak_mtrx = self.__update_L_mtrx(ak_mtrx, 0) * ak_mtrx
if self.need_logging:
print("A{} = ".format(1))
print(ak_mtrx)
print("L{} = ".format(1))
print(self.__L)
for i in range(1, self.__mtrx.size[0]-1):
k = GaussMethod.__max_row_in_col(ak_mtrx, i, i)
if i != k:
self.__permutations.append((i, k))
ak_mtrx.exchange_rows(i, k)
self.__L.exchange_rows(i, k)
self.__L.exchange_cols(i, k)
if self.need_logging:
print("In A{} exchange {} and {} rows".format(i, i, k))
print("In L{} exchange {} and {} rows".format(i, i, k))
print("In L{} exchange {} and {} columns\n".format(i, i, k))
if self.need_logging:
print("PA{} = ".format(i))
print(ak_mtrx)
print("L{} = ".format(i))
print(self.__L)
ak_mtrx = self.__update_L_mtrx(ak_mtrx, i) * ak_mtrx
if self.need_logging:
print("A{} = ".format(i+1))
print(ak_mtrx)
print("L{} = ".format(i+1))
print(self.__L)
if self.need_logging:
print("U = A{}\n".format(self.__mtrx.size[0]-1))
self.__U = ak_mtrx
if self.need_logging:
print("L * U = ")
print(self.__L * self.__U)
pa = self.__mtrx.copy()
for i in self.__permutations:
pa.exchange_rows(i[0], i[1])
print("PA = ")
print(pa)