def total_gain(agent, target):
"""
calculer les réserves de l’agent additionnée à l’ensemble du sucre qu’il récupérera durant son voyage soustrait
au métabolisme consommé à chaque étape
"""
pop = get_population(agent)
env = get_env(agent)
pos = get_pos(agent)
sugar_level = get_sugar_level(agent)
#x_diff,y_diff
xd, yd = u.vector_diff(pos, target)
if xd == 0: #the same line
steps = abs(yd)
step = (1 if yd < 0 else -1)
for i in range(steps):
cell_refs = correct_position((pos[0], pos[1] + step * i), env)
cell = e.get_cell(env, cell_refs)
sugar_level += c.get_sugar_level(cell)
else: #the same row
steps = abs(xd)
step = (1 if xd < 0 else -1)
for i in range(steps):
cell_refs = correct_position((pos[0] + step * i, pos[1]), env)
cell = e.get_cell(env, cell_refs)
sugar_level += c.get_sugar_level(cell)
return sugar_level - get_metabolism(agent) * steps
def total_gain(agent,target): """ calculer les réserves de l’agent additionnée à l’ensemble du sucre qu’il récupérera durant son voyage soustrait au métabolisme consommé à chaque étape """ pop = get_population(agent) env = get_env(agent) pos = get_pos(agent) sugar_level = get_sugar_level(agent) #x_diff,y_diff xd,yd = u.vector_diff(pos,target) if xd == 0: #the same line steps = abs(yd) step = (1 if yd < 0 else -1) for i in range(steps): cell_refs = correct_position((pos[0],pos[1]+step*i),env) cell = e.get_cell(env,cell_refs) sugar_level += c.get_sugar_level(cell) else: #the same row steps = abs(xd) step = (1 if xd < 0 else -1) for i in range(steps): cell_refs = correct_position((pos[0]+step*i,pos[1]),env) cell = e.get_cell(env,cell_refs) sugar_level += c.get_sugar_level(cell) return sugar_level - get_metabolism(agent)*steps
def min_sugar_level_need( env, agent, cells_refs ):
"""
Renvoie la cell_ref minimum que l'agent a besoin parmi la liste des cells_refs
"""
# On crée une liste des cellules graces à la liste des positions.
cells = []
for cell_ref in cells_refs:
cells.append( e.get_cell( env, cell_ref ) )
# On a deux listes: les cellules et les positions.
# On ordonne la liste des cellules en fonction du taux de sucre (Et les positions s'ordonneront en fonction aussi)
u.sort_on_second_list(cells_refs, cells, order_decrease_cell_by_sugar_level)
# On recherche le minimum
minimal_cell_ref = cells_refs[0]
minimal_cell = cells[0]
#On parcout tous les éléments
for temp in range( len(cells) ):
temp_ref = cells_refs[temp] #Position
temp_cell = cells[temp] #Cellule
#Si le taux suffit à la survie et que celui-ci est plus petit que le supposé "minimal".
if c.get_sugar_level( temp_cell ) >= get_metabolism( agent ) and c.get_sugar_level( minimal_cell ) > c.get_sugar_level( temp_cell ):
minimal_cell_ref = temp_ref # Nouvelle position minimale
minimal_cell = temp_cell # Nouvelle cellule minimale
return minimal_cell_ref # Renvoie la position de la cellule
def max_sugar_level_cell_ref(env, cell_ref_list):
"""
Return the reference of the cell (from the given list)
with the highest sugar level.
"""
max_cell_ref = cell_ref_list[0]
max_cell = get_cell(env, max_cell_ref)
for cell_ref in cell_ref_list:
cell = get_cell(env, cell_ref)
if c.get_sugar_level(cell) > c.get_sugar_level(max_cell):
max_cell = cell
max_cell_ref = cell_ref
return max_cell_ref
def max_sugar_level_cell_ref(env, cell_ref_list):
"""
Return the reference of the cell (from the given list)
with the highest sugar level.
"""
max_cell_ref = cell_ref_list[0]
max_cell = get_cell(env, max_cell_ref)
for cell_ref in cell_ref_list:
cell = get_cell(env, cell_ref)
if c.get_sugar_level(cell) > c.get_sugar_level(max_cell):
max_cell = cell
max_cell_ref = cell_ref
return max_cell_ref
def max_ressource_cell_position(l, l_pos):
"""
Returns the position of the cell of the environment which has
the biggest sugar level.
"""
l_res = []
for elem in l:
l_res.append(c.get_sugar_level(elem))
max_res = max(l_res)
for i in range(len(l)):
if c.get_sugar_level(l[i]) == max_res:
pos_cell = l_pos[i]
return pos_cell
def move_to_the_highest_sugar_level_cell(agent):
"""
RA1 : déplace l'agent dans la cellule à quantité de sucre la plus élevée
"""
cells_refs = accecible_positions(agent)
if len(cells_refs) > 0:
highest = cells_refs[0]
env = get_env(agent)
for i in range(len(cells_refs)):
cell = e.get_cell(env, cells_refs[i])
highest_cell = e.get_cell(env, highest)
if c.get_sugar_level(cell) > c.get_sugar_level(highest_cell):
highest = cells_refs[i]
move(agent, highest)
def move_to_the_lowest_sugar_level_cell(agent): """ RA3 : déplace l'agent dans la cellule à quantité de sucre la moins élevée et assez pour son métabolisme """ cells_refs = accecible_positions(agent) if len(cells_refs) > 0: lowest = cells_refs[0] env = get_env(agent) for i in range(len(cells_refs)): cell = e.get_cell(env,cells_refs[i]) lowest_cell = e.get_cell(env,lowest) if c.get_sugar_level(cell) < c.get_sugar_level(lowest_cell): lowest = cells_refs[i] move (agent,lowest)
def move_to_the_highest_sugar_level_cell(agent): """ RA1 : déplace l'agent dans la cellule à quantité de sucre la plus élevée """ cells_refs = accecible_positions(agent) if len(cells_refs) > 0: highest = cells_refs[0] env = get_env(agent) for i in range(len(cells_refs)): cell = e.get_cell(env,cells_refs[i]) highest_cell = e.get_cell(env,highest) if c.get_sugar_level(cell) > c.get_sugar_level(highest_cell): highest = cells_refs[i] move (agent,highest)
def move_to_the_lowest_sugar_level_cell(agent):
"""
RA3 : déplace l'agent dans la cellule à quantité de sucre la moins élevée
et assez pour son métabolisme
"""
cells_refs = accecible_positions(agent)
if len(cells_refs) > 0:
lowest = cells_refs[0]
env = get_env(agent)
for i in range(len(cells_refs)):
cell = e.get_cell(env, cells_refs[i])
lowest_cell = e.get_cell(env, lowest)
if c.get_sugar_level(cell) < c.get_sugar_level(lowest_cell):
lowest = cells_refs[i]
move(agent, lowest)
def eat_quarter(agent): """ consomme le quart du sucre de la cellule """ cell = get_cell(agent) amount = c.get_sugar_level(cell)/4 consumption_sugar(agent,amount)
def eat_half(agent): """ consomme la moitié du sucre de la cellule """ cell = get_cell(agent) amount = c.get_sugar_level(cell)/2 consumption_sugar(agent,amount)
def eat_all(agent): """ consomme tout le sucre de la cellule """ cell = get_cell(agent) amount = c.get_sugar_level(cell) consumption_sugar(agent,amount)
def env_plot(env, showGrid=True):
"""
Add a plot of the environment (possibly including a
grid) to the current pylab plot.
To actually show the plot, the pylab.show() method
still has to be invoked.
"""
ax = plt.gca()
ax.set_aspect('equal', 'box')
ax.xaxis.set_major_locator(plt.NullLocator())
ax.yaxis.set_major_locator(plt.NullLocator())
sz = e.size(env)
mat = []
row = []
col = []
sugar = []
size_factor = 3000.0/sz/e.get_max_capacity(env)
# Plot sugar level of each cell
for cell_ref in e.get_cell_refs(env):
cell = e.get_cell(env, cell_ref)
(y, x) = cell_ref
row.append(y+0.5)
col.append(x+0.5)
sugar.append(size_factor*c.get_sugar_level(cell))
plt.scatter(row, col, sugar, color='yellow', alpha=1)#, marker='s')
# Plot the grid (or only an outer border)
for k in range(sz+1):
if showGrid or k == 0 or k == sz:
plt.plot([k, k], [0, sz], color='black', alpha=0.1, ls='-')
plt.plot([0, sz], [k, k], color='black', alpha=0.1, ls='-')
def eat_sugar(agent, mas):
matrix = e.get_cell_matrix(m.get_env(mas))
pop = m.get_pop(mas)
(col, lig) = get_pos(agent)
vision = get_vision(agent)
sugar_agent = get_sugar_level(agent)
max_sugar_agent = get_max_sugar_capacity(agent)
sugar_cell = c.get_sugar_level(matrix[lig][col])
new_sugar_agent = 0.0
new_sugar_cell = 0.0
if sugar_agent == max_sugar_agent:
new_sugar_agent = max_sugar_agent
new_sugar_cell = sugar_cell
if sugar_agent < max_sugar_agent:
if sugar_agent + sugar_cell < max_sugar_agent:
new_sugar_agent = sugar_agent + sugar_cell
new_sugar_cell = 0.0
if sugar_agent + sugar_cell > max_sugar_agent:
new_sugar_agent = max_sugar_agent
new_sugar_cell = sugar_cell + (sugar_agent - max_sugar_agent)
c.set_sugar_level(matrix[lig][col], new_sugar_cell)
return new_sugar_agent, new_sugar_cell
def eat_half(agent):
"""
consomme la moitié du sucre de la cellule
"""
cell = get_cell(agent)
amount = c.get_sugar_level(cell) / 2
consumption_sugar(agent, amount)
def eat_all(agent):
"""
consomme tout le sucre de la cellule
"""
cell = get_cell(agent)
amount = c.get_sugar_level(cell)
consumption_sugar(agent, amount)
def eat_quarter(agent):
"""
consomme le quart du sucre de la cellule
"""
cell = get_cell(agent)
amount = c.get_sugar_level(cell) / 4
consumption_sugar(agent, amount)
def eat_all(agent, env):
cell_ref = get_pos(agent)
cell = e.get_cell(env, cell_ref )
sugar = c.get_sugar_level( cell ) # On enregistre le taux de sucre de la cellule
sugar += get_sugar_level ( agent ) # On ajoute la réserve de l'agent
c.set_sugar_level( cell , 0 ) # On vide la cellule
set_sugar_level ( agent , sugar ) # On donne tout à l'agent
def better_ressource_cell_position(l, l_pos, agent):
"""
Returns the position of the cell in the environment which has
enough sugar for the metabolism of the agent. But this sugar
level must be near the metabolism of the agent (as near as possible).
But if the metabolism of the agent is bigger than every sugar level of
every cell, then this function returns the position of the nearest
sugar level. Used for RA3.
"""
l_res = []
for elem in l:
l_res.append(c.get_sugar_level(elem))
l_res.append(get_metabolism(agent))
l_res.sort()
best_res = best_ressource(agent, l_res, get_metabolism(agent))
for i in range(len(l)):
if c.get_sugar_level(l[i]) == best_res:
pos_cell = l_pos[i]
return pos_cell
def is_possible_to_move(agent,position): """ vérifie si un agent peut se déplcer, on vérifie si: la quantité de sucre de la cellule additionnée à la réserve de sucre de l'agent est suffisante au métabolisme, si il n'y a pas d'agent dans sa cellule """ env = get_env(agent) cell = e.get_cell(env,position) possible_to_move = not c.agent_is_present(cell) \ and (c.get_sugar_level(cell)+get_sugar_level(agent)) >= get_metabolism(agent) return possible_to_move
def __compute_cell_color(cell):
# Compute the color of the cell, depending on its sugar level
sugar_level = c.get_sugar_level(cell)
env = c.get_env(cell)
max_capacity = e.get_max_capacity(env)
ratio = sugar_level / max_capacity
color_level = int(255 * (1 - ratio))
# convert the color level to hexadecimal representation
hex_color_level = hex(color_level)[2:].zfill(2)
color_code = '#' + 'ff' + 'ff' + hex_color_level
return color_code
def __compute_cell_color(cell):
# Compute the color of the cell, depending on its sugar level
sugar_level = c.get_sugar_level(cell)
env = c.get_env(cell)
max_capacity = e.get_max_capacity(env)
ratio = sugar_level / max_capacity
color_level = int(255 * (1 - ratio))
# convert the color level to hexadecimal representation
hex_color_level = hex(color_level)[2:].zfill(2)
color_code = '#' + 'ff' + 'ff' + hex_color_level
return color_code
def is_possible_to_move(agent, position):
"""
vérifie si un agent peut se déplcer, on vérifie si: la quantité de sucre de la cellule additionnée
à la réserve de sucre de l'agent est suffisante au métabolisme,
si il n'y a pas d'agent dans sa cellule
"""
env = get_env(agent)
cell = e.get_cell(env, position)
possible_to_move = not c.agent_is_present(cell) \
and (c.get_sugar_level(cell)+get_sugar_level(agent)) >= get_metabolism(agent)
return possible_to_move
def eat_and_consumpt_sugar(agent, cell):
"""
Adds the sugar level of the cell to the sugar level of
the agent and makes the cell empty.
It also reduce the agent's sugar level because of his
metabolism.
"""
new = get_sugar_level(agent) + c.get_sugar_level(cell)
set_sugar_level(agent, new)
c.set_sugar_level(cell, 0)
new2 = get_sugar_level(agent) - get_metabolism(agent)
set_sugar_level(agent, new2)
def sort_sugar_level_desc(env, cell_ref_list):
"""
Sort the list of cells reference in descending order of
their corresponding sugar level.
"""
# Build a separate list that assigns the sugar level to each
# corresponding cell referenced in the list given as parameter.
sugar_level_list = []
for cell_ref in cell_ref_list:
cell = get_cell(cell_ref)
level = c.get_sugar_level(cell)
sugar_level_list.append(level)
# Call sorting function.
sort_on_second_list(cell_ref_list, sugar_level_list, order_numeric_asc)
def sort_sugar_level_desc(env, cell_ref_list):
"""
Sort the list of cells reference in descending order of
their corresponding sugar level.
"""
# Build a separate list that assigns the sugar level to each
# corresponding cell referenced in the list given as parameter.
sugar_level_list = []
for cell_ref in cell_ref_list:
cell = get_cell(env, cell_ref)
level = c.get_sugar_level(cell)
sugar_level_list.append(level)
# Call sorting function.
u.sort_on_second_list(cell_ref_list, sugar_level_list, order_numeric_asc)
def get_is_living(agent): """ vérifie si un agent est vivant : s'il a assez à manger, s'il peut se déplacer et si son age ne dépasse pas la limite """ cell = get_cell(agent) cell_sugar_level = c.get_sugar_level(cell) metabolism = get_metabolism(agent) agent_sugar_level = get_sugar_level(agent) age = get_age(agent) pop = get_population(agent) max_age = p.get_pop_property(pop,"MAX_AGENT_AGE") is_alive = (cell_sugar_level+agent_sugar_level >= metabolism) and age <= max_age if not is_alive: kill(agent) return is_alive
def get_is_living(agent):
"""
vérifie si un agent est vivant : s'il a assez à manger, s'il peut se déplacer et si son age ne dépasse pas la limite
"""
cell = get_cell(agent)
cell_sugar_level = c.get_sugar_level(cell)
metabolism = get_metabolism(agent)
agent_sugar_level = get_sugar_level(agent)
age = get_age(agent)
pop = get_population(agent)
max_age = p.get_pop_property(pop, "MAX_AGENT_AGE")
is_alive = (cell_sugar_level + agent_sugar_level >=
metabolism) and age <= max_age
if not is_alive:
kill(agent)
return is_alive
def better_ressources_for_average(l, l_pos, agent):
"""
Returns the list of the positions of the cells which have enough
sugar compared with the metabolism of the agent. But if the metabolism
of the agent is bigger than every sugar level of every cell, it
returns a list containing the cell which has the biggest sugar level.
"""
l_res = []
l_good_pos = []
for elem in l:
l_res.append(c.get_sugar_level(elem))
u.sort_on_second_list(l_pos, l_res, u_mod.order_scalar_asc)
if len(l_res) > 0:
if get_metabolism(agent) > max(l_res):
l_good_pos = [l_pos[len(l_pos) - 1]]
else:
for i in range(len(l_res)):
if l_res[i] > get_metabolism(agent):
l_good_pos.append(l_pos[i])
return l_good_pos
def consumption_sugar(agent, amount):
"""
consomation de sucre par l'agent
amount : quantité de sucre qui va être consomé (s'il le peut)
"""
cell = get_cell(agent)
pop = get_population(agent)
c_sugar_level = c.get_sugar_level(cell)
a_sugar_level = get_sugar_level(agent)
metabolism = get_metabolism(agent)
max_sugar_level = p.get_pop_property(pop, "MAX_SUGAR_LEVEL")
if (amount >= metabolism):
if not has_max_sugar_level(agent):
a_sugar_level += amount - metabolism
if a_sugar_level > max_sugar_level:
a_sugar_level = max_sugar_level
c_sugar_level -= amount
else:
a_sugar_level -= metabolism
elif (amount + a_sugar_level) >= metabolism:
a_sugar_level -= metabolism - amount
c_sugar_level -= amount
set_sugar_level(agent, a_sugar_level)
c.set_sugar_level(cell, c_sugar_level)
def consumption_sugar(agent,amount): """ consomation de sucre par l'agent amount : quantité de sucre qui va être consomé (s'il le peut) """ cell = get_cell(agent) pop = get_population(agent) c_sugar_level = c.get_sugar_level(cell) a_sugar_level = get_sugar_level(agent) metabolism = get_metabolism(agent) max_sugar_level = p.get_pop_property(pop,"MAX_SUGAR_LEVEL") if (amount >= metabolism): if not has_max_sugar_level(agent): a_sugar_level += amount - metabolism if a_sugar_level > max_sugar_level: a_sugar_level = max_sugar_level c_sugar_level -= amount else: a_sugar_level -= metabolism elif (amount + a_sugar_level) >= metabolism: a_sugar_level -= metabolism - amount c_sugar_level -= amount set_sugar_level(agent,a_sugar_level) c.set_sugar_level(cell,c_sugar_level)
def RA2_is_possible( env, agent, target ):
agent_ref = get_pos( agent )
result = u.vector_diff( target, agent_ref )
target_unit = vector_one_max( result )
cell_ref = u.vector_sum( agent_ref, target_unit )
cell = e.get_cell( env, cell_ref )
return ( not c.agent_is_present(cell) ) and get_metabolism(agent) <= get_sugar_level(agent) + c.get_sugar_level(cell)
def order_decrease_cell_by_sugar_level( cell1, cell2 ):
"""
Renvoie vrai si le taux de sucre de la cell1 est plus petit que celui de la cell2.
"""
return c.get_sugar_level( cell1 ) < c.get_sugar_level( cell2 )
