def test_isEmptyY_p_notempty(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 0, 2)
grid.add(sensor1)
grid.add(sensor2)
self.assertFalse(sensor1.isEmptyY(grid, 2, -1))
def test_isEmptyY_p_empty(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 0, 3)
grid.add(sensor1)
grid.add(sensor2)
self.assertTrue(sensor1.isEmptyY(grid, 2, -1))
def test2(): width = 39 height = 39 steps = 700 rc = 4 rs = 1 maxMoves = 100 lowerK = 5 upperK = 1 capacity = 1 grid = Grid(width, height, capacity) sensors = initSensors3(rc, rs, maxMoves, lowerK, upperK, width, height) for sensor in sensors: grid.add(sensor) totalCoveragesList=[] totalMovesList=[] stepList = [] for i in range(steps): changed = grid.iterate(i) print "STEP:", i if i % 1 == 0: stepList.append(i / 2) totalCoveragesList.append(totalCoverage(grid)) totalMovesList.append(totalMoves(grid)) if not changed: break graphCoverage(stepList, totalCoveragesList) graphMoves(stepList, totalMovesList) print grid.toString()
def test_isEmptyX_n_empty(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 3, 0)
grid.add(sensor1)
grid.add(sensor2)
self.assertTrue(sensor2.isEmptyX(grid, 2, 1))
def test_count_sameLocation(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 0, 0)
grid.add(sensor1)
grid.add(sensor2)
self.assertEqual(sensor1.countSensors(grid, -3, -3, 6, 6), 2)
def test_move_moveCount(self):
grid = Grid()
sensor1 = Sensor(3, 1, 0, 0, 0)
sensor2 = Sensor(3, 1, 0, 0, 1)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual((sensor1.x, sensor1.y), (0, 0))
def test_move_xp(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 1, 0)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual((sensor2.x, sensor2.y), (2, 0))
def test_neighbours_one(self):
grid = Grid()
sensor1 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, 0, 0)
sensor2 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, 1, 0)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual(len(sensor1.neighbours), 1)
def test_block_yp(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 0, 3)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual((sensor2.x, sensor2.y), (0, 3))
def test_moveBack_yp(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 0, 2)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual((sensor1.x, sensor1.y), (0, -1))
self.assertEqual((sensor2.x, sensor2.y), (0, 3))
grid.iterate()
self.assertEqual((sensor1.x, sensor1.y), (0, 0))
def test_neighbours_eight_border(self):
grid = Grid()
sensor1 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, 0, 0)
for i in range(8):
angle = i / 4.0 * math.pi
x = 2.999 * math.cos(angle)
y = 2.999 * math.sin(angle)
print(x, y)
sensor = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, x, y)
grid.add(sensor)
grid.add(sensor1)
grid.iterate()
self.assertEqual(len(sensor1.neighbours), 8)
def test_f_direction_many(self):
for i in range(8):
grid = Grid()
sensor1 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, 0, 0)
angle = i / 4.0 * math.pi
x = 1 * math.cos(angle)
y = 1 * math.sin(angle)
grid.add(sensor1)
sensor2 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, x, y)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual(len(sensor1.neighbours), 1)
self.assertEqual((sensor1.v[0], sensor1.v[1]), (-x, -y))
def test_f_cover_many(self):
kdegree = 1
for i in range(8):
grid = Grid()
sensor1 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, 0, 0)
angle = i / 4.0 * math.pi
x = 1 * math.cos(angle)
y = 1 * math.sin(angle)
grid.add(sensor1)
sensor2 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, x, y)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual(sensor1.critical, True)
self.assertEqual(len(sensor1.neighbours), 1)
self.assertEqual(sensor1.fdegree, sensor1.kdegree)
kdegree = 0
for i in range(8):
grid = Grid()
sensor1 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, 0, 0)
angle = i / 4.0 * math.pi
x = 1 * math.cos(angle)
y = 1 * math.sin(angle)
grid.add(sensor1)
sensor2 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, x, y)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual(sensor1.critical, False)
self.assertEqual(len(sensor1.neighbours), 1)
self.assertEqual(sensor1.fdegree, 0)
def test_moveBack_xn(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 2, 0)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual((sensor1.x, sensor1.y), (-1, 0))
self.assertEqual((sensor2.x, sensor2.y), (3, 0))
sensor1.moveBack(grid)
self.assertEqual(sensor1.xlast, -1)
self.assertTrue(sensor1.isEmptyX(grid, 3, -1))
self.assertTrue(sensor1.xmoveback)
grid.iterate()
self.assertEqual((sensor2.x, sensor2.y), (2, 0))
def test1(): width = 14 height = 14 steps = 300 rc = 4 lowerK = 5 upperK = 1 grid = Grid(width, height, 1) sensors = initSensors2(rc, lowerK, upperK) for sensor in sensors: grid.add(sensor) for i in range(steps): changed = grid.iterate(i) print "STEP:",i if not changed: break print grid.toString()
def test0(): steps = 2 rc = 4 lowerK = 5 upperK = 1 capacity = 0 grid = Grid(capacity=capacity) sensors = initSensors0(rc, lowerK, upperK) guy = sensors[0] for sensor in sensors: grid.add(sensor) for i in range(steps): changed = grid.iterate(i) print "STEP:",i print guy.Q1, guy.Q2, guy.Q3, guy.Q4 print guy.minQ, guy.maxQ print guy.moveLocation print "L: ",guy.x, guy.y print grid.toString() if not changed: break
def test2():
steps = 250
rc = 4
rs = 2
maxMoves = 200
grid = Grid()
sensors = initSensors3(rc, rs, maxMoves)
for sensor in sensors:
grid.add(sensor)
totalCoveragesList = []
totalMovesList = []
stepList = []
for i in range(steps):
changed = grid.iterate()
print "STEP:", i
stepList.append(i)
totalCoveragesList.append(totalCoverage(grid))
totalMovesList.append(totalMoves(grid))
if not changed:
break
graphCoverage(stepList, totalCoveragesList)
graphMoves(stepList, totalMovesList)
print grid.toString()
def test_count_boundaries(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 3, 3)
sensor3 = Sensor(3, 1, 50, -3, -3)
sensor4 = Sensor(3, 1, 50, -3, 3)
sensor5 = Sensor(3, 1, 50, 3, -3)
grid.add(sensor1)
grid.add(sensor2)
grid.add(sensor3)
grid.add(sensor4)
grid.add(sensor5)
self.assertEqual(sensor1.countSensors(grid, -3, -3, 6, 6), 5)
def evaluate(agent, N, logger, reward_func_str):
env = Grid(4)
env.set_reward(reward_func_str)
max_tile_distribution = {}
overall_sum_moves = 0
overall_sum_q = 0
state_first = [[0, 0, 0, 0], [0, 0, 0, 0], [2, 0, 2, 0], [0, 0, 0, 0]]
state_1 = [[2, 0, 4, 2], [0, 0, 0, 16], [0, 0, 8, 32], [0, 4, 32, 16]]
state_2 = [[2, 2, 4, 2], [8, 16, 0, 0], [64, 32, 0, 4], [64, 0, 0, 0]]
state_3 = [[2, 32, 128, 2], [8, 128, 64, 16], [8, 32, 16, 8], [2, 8, 4, 2]]
state_4 = [[2, 32, 128, 2], [8, 128, 64, 16], [8, 32, 16, 8], [2, 8, 4, 2]]
state_5 = [[4, 2, 16, 256], [4, 8, 64, 32], [0, 0, 128, 4], [0, 0, 256, 8]]
state_6 = [[4, 4, 16, 256], [2, 2, 512, 32], [0, 8, 128, 4], [0, 0, 16, 8]]
state_last = [[32, 0, 0, 0], [8, 2, 0, 0], [64, 16, 0, 16],
[1024, 1024, 4, 4]]
state_after = [[8, 32, 512, 32], [8, 16, 1024, 16], [64, 0, 8, 512],
[0, 0, 0, 2048]]
state_right = [[0, 0, 2, 32], [0, 0, 32, 16], [2, 0, 8, 64], [0, 0, 0, 0]]
state_up = [[32, 16, 64, 0], [2, 32, 16, 0], [0, 0, 0, 0], [0, 0, 2, 0]]
state_left = [[0, 0, 0, 0], [64, 16, 0, 2], [16, 32, 0, 0], [32, 2, 0, 0]]
state_down = [[0, 2, 0, 0], [0, 0, 0, 0], [0, 16, 32, 2], [0, 64, 16, 32]]
states = [
state_first, state_1, state_2, state_3, state_4, state_5, state_6,
state_last, state_after, state_right, state_up, state_left, state_down
]
states_names = [
"state_first", "state_1", "state_2", "state_3", "state_4", "state_5",
"state_6", "state_last", "state_after", "state_right", "state_up",
"state_left", "state_down"
]
states = list(
map(lambda x: np.ma.log2(np.array(x).flatten()).filled(0) / 10,
states))
results = {}
for i in range(len(states)):
state = states[i]
state_name = states_names[i]
q = agent.gamma * agent.model.predict(
np.reshape(state, [1, env.state_size]))[0]
results[state_name] = list(q)
logger.info(str(results))
for i in range(N):
env.reset()
moves = 0
sum_q = 0
while not env.is_game_over():
state = np.reshape(env.get_curr_state(), [1, env.state_size])
action = agent.act_policy(state, env.get_available_moves())
reward = env.reward_func(action)
env.play(action)
env.add()
moves += 1
if env.is_game_over():
reward = env.reward_func(action)
q = reward + agent.gamma * np.amax(
agent.model.predict(
np.reshape(env.get_curr_state(), [1, env.state_size]))[0])
sum_q += q
if env.get_max_tile() not in max_tile_distribution:
max_tile_distribution[env.get_max_tile()] = 1
else:
max_tile_distribution[env.get_max_tile()] += 1
overall_sum_moves += moves
overall_sum_q += sum_q
logger.info(
"{{'Playing at episode': {}, 'game num': {}, 'moves': {}, 'maxtile': {}, 'mean q value': {}}}"
.format(e, i + 1, moves, env.get_max_tile(), sum_q / moves))
logger.info(
"{{'Performance at episode': {}, 'max tile distribution': '{}', 'avg no of moves': {}, 'mean q value': {}}}"
.format(e, sorted(max_tile_distribution.items(), key=lambda x: x[0]),
overall_sum_moves / N, overall_sum_q / overall_sum_moves))
def test_count_basic(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
grid.add(sensor1)
self.assertEqual(sensor1.countSensors(grid, -3, -3, 6, 6), 1)
if __name__ == '__main__':
assert N_AGENTS < N_GRID**2
# Creating grid
grid = Grid(N_GRID, verbose=VERBOSE)
mailbox = MailBox()
# Creating agents
agents = []
agents.append(Agent(0, (0, 0), (2, 2), grid, mailbox))
agents.append(Agent(1, (1, 0), (1, 0), grid, mailbox))
agents.append(Agent(2, (0, 1), (0, 1), grid, mailbox))
for agent in agents:
assert grid.add(agent)
print(grid)
# Starting agents
for a in agents:
a.start()
# Looping until agents are done or MAX_ITER is reached
nb_completed_goal = 0
i = 0
while nb_completed_goal < N_AGENTS and i <= MAX_ITER:
sleep(REFRESH_TIME)
nb_completed_goal = 0
class GameGrid(Frame):
def __init__(self):
Frame.__init__(self)
self.grid()
self.master.title('2048')
self.master.bind("<Key>", self.key_down)
#self.gamelogic = gamelogic
self.commands = {
KEY_UP: 'UP',
KEY_DOWN: 'DOWN',
KEY_LEFT: 'LEFT',
KEY_RIGHT: 'RIGHT',
KEY_UP_ALT: 'UP',
KEY_DOWN_ALT: 'DOWN',
KEY_LEFT_ALT: 'LEFT',
KEY_RIGHT_ALT: 'RIGHT'
}
self.grid_cells = []
self.init_grid()
self.matrix = Grid(GRID_LEN)
self.init_matrix()
self.update_grid_cells()
self.mainloop()
def init_grid(self):
background = Frame(self,
bg=BACKGROUND_COLOR_GAME,
width=SIZE,
height=SIZE)
background.grid()
for i in range(GRID_LEN):
grid_row = []
for j in range(GRID_LEN):
cell = Frame(background,
bg=BACKGROUND_COLOR_CELL_EMPTY,
width=SIZE / GRID_LEN,
height=SIZE / GRID_LEN)
cell.grid(row=i,
column=j,
padx=GRID_PADDING,
pady=GRID_PADDING)
# font = Font(size=FONT_SIZE, family=FONT_FAMILY, weight=FONT_WEIGHT)
t = Label(master=cell,
text="",
bg=BACKGROUND_COLOR_CELL_EMPTY,
justify=CENTER,
font=FONT,
width=4,
height=2)
t.grid()
grid_row.append(t)
self.grid_cells.append(grid_row)
def init_matrix(self):
self.matrix.add()
self.matrix.add()
def update_grid_cells(self):
for i in range(GRID_LEN):
for j in range(GRID_LEN):
new_number = self.matrix.get_ele(i, j)
if new_number == 0:
self.grid_cells[i][j].configure(
text="", bg=BACKGROUND_COLOR_CELL_EMPTY)
else:
self.grid_cells[i][j].configure(
text=str(int(new_number)),
bg=BACKGROUND_COLOR_DICT[new_number],
fg=CELL_COLOR_DICT[new_number])
self.update_idletasks()
def key_down(self, event):
key = repr(event.char)
if key in self.commands:
played_move = self.commands[repr(event.char)]
if played_move in self.matrix.get_available_moves():
self.matrix.play(played_move)
self.matrix.add()
self.update_grid_cells()
if self.matrix.is_win():
self.grid_cells[1][1].configure(
text="You", bg=BACKGROUND_COLOR_CELL_EMPTY)
self.grid_cells[1][2].configure(
text="Win!", bg=BACKGROUND_COLOR_CELL_EMPTY)
elif self.matrix.is_game_over():
self.grid_cells[1][1].configure(
text="You", bg=BACKGROUND_COLOR_CELL_EMPTY)
self.grid_cells[1][2].configure(
text="Lose!", bg=BACKGROUND_COLOR_CELL_EMPTY)
grid = Grid(N_GRID, verbose=VERBOSE)
mailbox = MailBox()
# Creating agents
agents = []
goals = []
domain = (0, N_GRID - 1)
for i in range(N_AGENTS):
pos = rand_pos(domain)
goal = rand_pos(domain)
while pos == goal or not grid.is_empty(pos) or goal in goals:
pos = rand_pos(domain)
goal = rand_pos(domain)
agent = Agent(i, pos, goal, grid, mailbox)
if grid.add(agent):
agents.append(agent)
goals.append(goal)
if VERBOSE:
print('Agent', i, 'crée à la position', pos, 'avec objectif',
goal)
print(grid)
# Starting agents
for a in agents:
a.start()
# Looping until agents are done or MAX_ITER is reached
nb_completed_goal = 0
i = 0
def test_fcover_none(self):
grid = Grid()
sensor1 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, 0, 0)
grid.add(sensor1)
grid.iterate()
self.assertEqual((sensor1.x, sensor1.y), (0, 0))
if steps > best_steps or maxtiles > best_maxtile:
best_action, best_steps, best_maxtile = action, steps, maxtiles
print('choose {}'.format(best_action))
return best_action
if __name__ == '__main__':
env = Grid(4)
env.winning_number = 4
tempenv = Grid(4)
tempenv.winning_number = 4
NO_OF_TRIALS = 1000
NO_OF_ROLLOUT = 20
DEPTH = 100
best_move_dict = {}
for trial in range(NO_OF_TRIALS):
env.reset()
while not env.is_game_over():
t1 = time.time()
move = get_best_move(tempenv, env.mat, NO_OF_ROLLOUT, DEPTH)
print(time.time() - t1)
env.show()
env.play(move)
env.add()
print(env.get_max_tile())
class PhysicsSystem(object):
def __init__(self):
self.objects = []
self.grid = Grid()
# profiling
self.time_coll = 0
self.time_dyn = 0
self.cnt = 0
def add_object(self, obj):
self.objects.append(obj)
def update(self, dt):
t0 = time.time()
# reset ephemeral state
for obj in self.objects:
obj.acc = Vector2d(0, 0)
# collisions
self.process_collisions()
t1 = time.time()
# integrate dynamics
self.grid.clear()
for obj in self.objects:
obj.vel = obj.vel + obj.acc * dt
if (obj.vel.length() > 5):
obj.vel = obj.vel * 0.9
obj.pos = obj.pos + obj.vel * dt
if (obj.pos.x > 100): obj.pos.x = -100
if (obj.pos.y > 100): obj.pos.y = -100
if (obj.pos.x < -100): obj.pos.x = 100
if (obj.pos.y < -100): obj.pos.y = 100
self.grid.add(obj.pos, obj)
t2 = time.time()
self.time_coll += t1 - t0
self.time_dyn += t2 - t1
self.cnt += 1
if (self.cnt % 100 == 0):
print("collisions:{} ms dynamics: {} ms".format(
self.time_coll / 100 * 1000,
self.time_dyn / 100 * 1000)) # time in ms
self.time_coll = 0.0
self.time_dyn = 0.0
def process_collisions(self):
for obj1 in self.objects:
# check collisions with every other object
# candidates = self.objects
# check collisions with objects within the given radius
candidates = self.grid.objects_in_radius(obj1.pos, 5)
for obj2 in candidates:
# skip if two objs are the same
if obj1 is obj2:
continue
d = (obj1.pos - obj2.pos).length()
if (d < 1E-6): d = 1E-6
comp = obj1.radius + obj2.radius - d
if comp > 0:
# objects are colliding
direction = (obj1.pos - obj2.pos) / d
stiffness = 500
obj1.acc = direction * comp * stiffness / obj1.mass
obj2.acc = direction * comp * stiffness / obj2.mass * -1
if __name__ == "__main__":
pygame.init()
screen = pygame.display.set_mode((800, 600))
grid = Grid('grass', 10, 6)
ui = UI(grid)
guys = []
enemies = []
for x in xrange(2):
for y in xrange(4):
guy = Guy('dude')
grid.add(guy, (x*2 + 1 + y % 2, y))
guys.append(guy)
enemy = Guy('dude')
enemy.image = pygame.transform.flip(enemy.image, True, False)
grid.add(enemy, (x*2 + 6 + y % 2, y))
enemies.append(enemy)
curguy = 0
while 1:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
elif event.type == KEYDOWN:
prevguy = curguy
curguy = handle_key(grid, ui, screen, event.key, guys, curguy)
def test_move_none(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
grid.add(sensor1)
grid.iterate()
self.assertEqual((sensor1.x, sensor1.y), (0, 0))
