def r2_procreate(self, abm, ca):
neighborhood = ca.get_agent_neighborhood(self.x, self.y, 1)
if self.is_fertile():
free_cells = [v[0] for v in list(neighborhood.values())
if v[1] is False and (v[0].x != self.x and v[0].y != self.y)]
mates = [v[1] for v in list(neighborhood.values()) if not v[1] is False]
if mates:
m = get_RNG().choice(mates)
both_wealthy1 = (self.sugar >= self.init_sugar and m.sugar >= m.init_sugar)
both_wealthy2 = (self.spice >= self.init_spice and m.spice >= m.init_spice)
# All criteria is fulfilled to procreate!
if free_cells and m.is_fertile() and m.gender != self.gender and both_wealthy1 and both_wealthy2:
# Take one free cell to place Junior there.
c = get_RNG().choice(free_cells)
n_x = c.x
n_y = c.y
# Give him / her initial resources
n_su = int(self.init_sugar / 2) + int(m.init_sugar / 2)
n_sp = int(self.init_spice / 2) + int(m.init_spice / 2)
self.sugar -= int(self.init_sugar / 2)
self.spice -= int(self.init_spice / 2)
m.sugar -= int(m.init_sugar / 2)
m.spice -= int(m.init_spice / 2)
# Fuse mommy's and daddy's chromosomes to create Juniors attributes.
# This is the actual creation of the baby. Behold the wonders of nature!
n_chromosome = self.chromosome.merge_with(m.chromosome)
child = SSAgent(n_x, n_y, self.gc, n_su, n_sp, 0, n_chromosome)
# Give the parents a reference to their newborn so they can,
# inherit their wealth to it before their inevitable demise.
self.children.append(child)
m.children.append(child)
# Update the abm that it has to schedule a new agent.
abm.add_agent(child)
def get_cell_with_pheromone(self, target_ph, neighborhood):
"""
Gets the cell with highest pheromone value (or random if no pheromones present)
from the immediate neighborhood.
:param: neighborhood is a dict of (x, y) -> cell mappings,
where cell is a tuple of (ca_cell, [agent(s) on cell]).
If no agent is on the cell then the list in the tuple is simply 'False'
"""
result = None
result_list = []
backup_list = []
best_cell = None
max_ph = 0
# Choose the possible directions the ants can currently look at.
if self.current_dir == 5:
possible_dirs = [4, 5, 0]
elif self.current_dir == 0:
possible_dirs = [5, 0, 1]
else:
possible_dirs = [self.current_dir - 1, self.current_dir, self.current_dir + 1]
for i in possible_dirs:
d = self.directions[i]
_x = self.x + d[0]
_y = self.y + d[1]
if (_x, _y) in neighborhood:
cell = neighborhood[_x, _y]
if cell[0].pheromones[target_ph] > 0.00: # and (not cell[1] or len(cell[1]) < 10):
ph = cell[0].pheromones[target_ph]
if ph > max_ph:
best_cell = cell
max_ph = ph
self.current_dir = i
result_list.append((cell, ph, i))
# elif not cell[1] or len(cell[1]) < 10:
else:
backup_list.append((cell, i))
if result_list:
if get_RNG().random() < 0.10:
choice = AntAgent.weighted_choice(result_list)
# choice = get_RNG().choice(result_list)
result = choice[0]
self.current_dir = choice[1]
else:
result = best_cell
elif backup_list:
choice = get_RNG().choice(backup_list)
result = choice[0]
self.current_dir = choice[1]
else:
# print('Ant Error: no cells found to move to!')
self.current_dir = AntAgent.get_opposite_direction(self.current_dir)
return self.get_cell_with_pheromone(target_ph, neighborhood)
# Add a small random factor to the movement.
return result
def __init__(self, x, y, gc, team, min_density, power):
super().__init__(x, y, gc)
self.min_density = min_density
self.strategy_walk = cab_rng.get_RNG().randint(0, 1) # team.strategy_walk # 0 - random, 1 - min-based
self.strategy_seed = cab_rng.get_RNG().randint(0, 1) # team.strategy_seed # 0 - random, 1 - min-based
self.score = 0
self.power = power
self.color = team.color
self.team = team
def get_island_landscape(self):
l1 = {}
l2 = {}
last_rand = 0
for j in range(self.height):
for i in range(self.width):
q = i - math.floor(j / 2)
if get_RNG().randint(0, 100) < self.factor:
c = get_RNG().choice([True, False])
if c:
# last_rand = int(get_RNG().triangular(self.deepest, self.highest, self.water_level))
# l1[q, j] = last_rand
l1[q, j] = self.highest
for d in self.gc.HEX_DIRECTIONS:
l1[q + d[0], j + d[1]] = int(get_RNG().triangular(
self.water_level, self.highest,
self.highest * 0.75))
# try:
# l1[q + d[0], j + d[1]] = self.highest * 2
# except KeyError:
# pass
else:
l1[q, j] = self.deepest
for d in self.gc.HEX_DIRECTIONS:
l1[q + d[0], j + d[1]] = int(get_RNG().triangular(
self.deepest, self.water_level,
self.deepest * 0.75))
else:
l1[q, j] = self.water_level
for _ in range(self.smoothness):
for j in range(self.height):
for i in range(self.width):
n = 0
f = 0
q = i - math.floor(j / 2)
for d in self.gc.HEX_DIRECTIONS:
if not (d[0] == 0 and d[1] == 0):
try:
n += 1
f += l1[q + d[0], j + d[1]]
except KeyError:
pass
avg = f / n
if avg > l1[q, j]:
diff = avg - l1[q, j]
l2[q, j] = l1[q, j] + (diff * self.slope)
elif avg < l1[q, j]:
diff = l1[q, j] - avg
l2[q, j] = l1[q, j] - (diff * self.slope)
else:
l2[q, j] = l1[q, j]
l1, l2 = l2, l1
return l1
def __init__(self, x, y, gc, team, min_density, power):
super().__init__(x, y, gc)
self.min_density = min_density
self.strategy_walk = cab_rng.get_RNG().randint(
0, 1) # team.strategy_walk # 0 - random, 1 - min-based
self.strategy_seed = cab_rng.get_RNG().randint(
0, 1) # team.strategy_seed # 0 - random, 1 - min-based
self.score = 0
self.power = power
self.color = team.color
self.team = team
def get_island_landscape(self):
l1 = {}
l2 = {}
last_rand = 0
for j in range(self.height):
for i in range(self.width):
q = i - math.floor(j / 2)
if get_RNG().randint(0, 100) < self.factor:
c = get_RNG().choice([True, False])
if c:
# last_rand = int(get_RNG().triangular(self.deepest, self.highest, self.water_level))
# l1[q, j] = last_rand
l1[q, j] = self.highest
for d in self.gc.HEX_DIRECTIONS:
l1[q + d[0], j + d[1]] = int(get_RNG().triangular(self.water_level, self.highest, self.highest * 0.75))
# try:
# l1[q + d[0], j + d[1]] = self.highest * 2
# except KeyError:
# pass
else:
l1[q, j] = self.deepest
for d in self.gc.HEX_DIRECTIONS:
l1[q + d[0], j + d[1]] = int(get_RNG().triangular(self.deepest, self.water_level, self.deepest * 0.75))
else:
l1[q, j] = self.water_level
for _ in range(self.smoothness):
for j in range(self.height):
for i in range(self.width):
n = 0
f = 0
q = i - math.floor(j / 2)
for d in self.gc.HEX_DIRECTIONS:
if not (d[0] == 0 and d[1] == 0):
try:
n += 1
f += l1[q + d[0], j + d[1]]
except KeyError:
pass
avg = f / n
if avg > l1[q, j]:
diff = avg - l1[q, j]
l2[q, j] = l1[q, j] + (diff * self.slope)
elif avg < l1[q, j]:
diff = l1[q, j] - avg
l2[q, j] = l1[q, j] - (diff * self.slope)
else:
l2[q, j] = l1[q, j]
l1, l2 = l2, l1
return l1
def perceive_and_act(self, abm, ca):
self.has_spawned_creepling_this_turn = False
neighborhood = ca.get_empty_agent_neighborhood(self.x, self.y, 1)
possible_cells = list(neighborhood.values())
for c in possible_cells:
if not c.team or c.team.number != self.team.number:
self.dead = True
break
if self.current_creeplings < self.max_creeplings and not self.has_spawned_creepling_this_turn:
density = cab_rng.get_RNG().randint(1, 15)
power = cab_rng.get_RNG().randint(1, 10)
abm.add_agent(CreeplingAgent(
c.x, c.y, self.gc, self.team, density, power))
self.current_creeplings += 1
self.has_spawned_creepling_this_turn = True
def r4_diseases(self):
"""
All diseases, the agent is currently infected with, are trying to spread to its neighbors.
"""
#for n in neighbors:
# if n[1] and not n[1].dead and not self.dead:
# for _, d in self.diseases.items():
# d.spread(n[1])
for _, d in self.diseases.items():
targets = [
agent for (cell, agent) in self.neighbors
if agent is not None and not agent.dead and not self.dead
]
if targets:
victim = get_RNG().choice(targets)
d.spread(victim)
# Let the immune system build another instance
# and then attempt to fight the diseases.
self.im_create_antibodies()
self.immune_reaction()
# Reset the metabolism values of the agent to clear all past diseases.
# That way, the diseases just fought off by the immune system are not longer
# afflicting the body and possible new diseases can act on the agent.
self.meta_sugar = self.chromosome.meta_sugar
self.meta_spice = self.chromosome.meta_spice
# Have the diseases affect the agent
for _, d in self.diseases.items():
d.affect(self)
def im_create_antibodies(self):
if self.fertility[0] < self.age < self.fertility[1] and len(self.immune_system) <= 10:
is_copy = copy.deepcopy(self.chromosome.immune_system)
length = len(is_copy)
index = get_RNG().choice(range(length))
is_copy[index] = 1 - is_copy[index]
self.immune_system.append("".join(map(str, is_copy)))
def get_coastal_landscape(self):
l1 = [[0 for _ in range(self.y_dim)] for _ in range(self.x_dim)]
l2 = [[0 for _ in range(self.y_dim)] for _ in range(self.x_dim)]
for j in range(self.y_dim):
for i in range(self.x_dim):
# l1[i][j] = int(get_RNG().triangular(self.deepest, self.highest, 5))s
mode = (((i + j) / 200) * 20) - 15
l1[i][j] = int(cab_rng.get_RNG().triangular(
self.deepest + 2 * mode, self.highest + 2 * mode, mode))
for _ in range(self.smoothness):
for j in range(self.y_dim):
for i in range(self.x_dim):
n = 0
f = 0
for cy in range(-1, 2):
for cx in range(-1, 2):
if not (cy == 0 and cx == 0):
try:
n += 1
f += l1[i + cx][j + cy]
except IndexError:
pass
avg = f / n
if avg > l1[i][j]:
diff = avg - l1[i][j]
l2[i][j] = l1[i][j] + (diff * self.slope)
elif avg < l1[i][j]:
diff = l1[i][j] - avg
l2[i][j] = l1[i][j] - (diff * self.slope)
else:
l2[i][j] = l1[i][j]
l1, l2 = l2, l1
return l1
def get_coastal_landscape(self):
l1 = [[0 for _ in range(self.y_dim)] for _ in range(self.x_dim)]
l2 = [[0 for _ in range(self.y_dim)] for _ in range(self.x_dim)]
for j in range(self.y_dim):
for i in range(self.x_dim):
# l1[i][j] = int(get_RNG().triangular(self.deepest, self.highest, 5))s
mode = (((i + j) / 200) * 20) - 15
l1[i][j] = int(cab_rng.get_RNG().triangular(self.deepest + 2 * mode, self.highest + 2 * mode, mode))
for _ in range(self.smoothness):
for j in range(self.y_dim):
for i in range(self.x_dim):
n = 0
f = 0
for cy in range(-1, 2):
for cx in range(-1, 2):
if not (cy == 0 and cx == 0):
try:
n += 1
f += l1[i + cx][j + cy]
except IndexError:
pass
avg = f / n
if avg > l1[i][j]:
diff = avg - l1[i][j]
l2[i][j] = l1[i][j] + (diff * self.slope)
elif avg < l1[i][j]:
diff = l1[i][j] - avg
l2[i][j] = l1[i][j] - (diff * self.slope)
else:
l2[i][j] = l1[i][j]
l1, l2 = l2, l1
return l1
def perceive_and_act(self, abm, ca):
self.has_spawned_creepling_this_turn = False
neighborhood = ca.get_empty_agent_neighborhood(self.x, self.y, 1)
possible_cells = list(neighborhood.values())
for c in possible_cells:
if not c.team or c.team.number != self.team.number:
self.dead = True
break
if self.current_creeplings < self.max_creeplings and not self.has_spawned_creepling_this_turn:
density = cab_rng.get_RNG().randint(1, 15)
power = cab_rng.get_RNG().randint(1, 10)
abm.add_agent(
CreeplingAgent(c.x, c.y, self.gc, self.team, density,
power))
self.current_creeplings += 1
self.has_spawned_creepling_this_turn = True
def r4_diseases(self):
"""
All diseases, the agent is currently infected with, are trying to spread to its neighbors.
"""
#for n in neighbors:
# if n[1] and not n[1].dead and not self.dead:
# for _, d in self.diseases.items():
# d.spread(n[1])
for _, d in self.diseases.items():
targets = [agent for (cell, agent) in self.neighbors if agent is not None and not agent.dead and not self.dead]
if targets:
victim = get_RNG().choice(targets)
d.spread(victim)
# Let the immune system build another instance
# and then attempt to fight the diseases.
self.im_create_antibodies()
self.immune_reaction()
# Reset the metabolism values of the agent to clear all past diseases.
# That way, the diseases just fought off by the immune system are not longer
# afflicting the body and possible new diseases can act on the agent.
self.meta_sugar = self.chromosome.meta_sugar
self.meta_spice = self.chromosome.meta_spice
# Have the diseases affect the agent
for _, d in self.diseases.items():
d.affect(self)
def get_coastal_landscape(self):
l1 = {}
l2 = {}
for j in range(self.height):
for i in range(self.width):
# l1[i][j] = int(get_RNG().triangular(self.deepest, self.highest, 5))s
q = i - math.floor(j / 2)
mode = (((i + j) / 200) * 5) + self.water_level
l1[q, j] = int(get_RNG().triangular(self.deepest + 2 * mode, self.highest + 2 * mode, mode))
# l1[i][j] = int(get_RNG().triangular(self.deepest + 2 * mode, self.highest + 2 * mode, mode))
for _ in range(self.smoothness):
for j in range(self.height):
for i in range(self.width):
q = i - math.floor(j / 2)
n = 0
f = 0
for d in self.gc.HEX_DIRECTIONS:
if not (d[0] == 0 and d[1] == 0):
try:
n += 1
f += l1[q + d[0], j + d[1]]
except KeyError:
pass
avg = f / n
if avg > l1[q, j]:
diff = avg - l1[q, j]
l2[q, j] = l1[q, j] + (diff * self.slope)
elif avg < l1[q, j]:
diff = l1[q, j] - avg
l2[q, j] = l1[q, j] - (diff * self.slope)
else:
l2[q, j] = l1[q, j]
l1, l2 = l2, l1
return l1
def map_genome_to_attributes(self):
"""
Decodes the genome and creates the attribute of the individual.
"""
# The meta and init attributes cannot become smaller than 1,
# even though that is possible by the encoding. We have to avoid that.
meta_sugar = Chromosome.choose_dominant_gene(self.get_genome_substring('meta_sugar'))
meta_spice = Chromosome.choose_dominant_gene(self.get_genome_substring('meta_spice'))
init_sugar = Chromosome.choose_dominant_gene(self.get_genome_substring('init_sugar'))
init_spice = Chromosome.choose_dominant_gene(self.get_genome_substring('init_spice'))
vision = Chromosome.choose_dominant_gene(self.get_genome_substring('vision'))
gender = get_RNG().choice(self.get_genome_substring('gender'))
f1 = Chromosome.choose_dominant_gene(self.get_genome_substring('fertility_1'))
f2 = Chromosome.choose_dominant_gene(self.get_genome_substring('fertility_2'))
dying_age = Chromosome.choose_dominant_gene(self.get_genome_substring('dying_age'))
self.meta_sugar = max(int(meta_sugar, 2), 1)
self.meta_spice = max(int(meta_spice, 2), 1)
self.init_sugar = max(int(init_sugar, 2), 1)
self.init_spice = max(int(init_spice, 2), 1)
self.vision = int(vision, 2)
self.gender = int(gender, 2)
self.dying_age = int(dying_age, 2)
self.fertility = (int(f1, 2), int(f2, 2))
dna = "".join((meta_sugar, meta_spice, init_sugar, init_spice, vision, gender, f1, f2, dying_age))
self.dna_color = Chromosome.convert_to_color(dna)
def im_create_antibodies(self):
if self.fertility[0] < self.age < self.fertility[1] and len(
self.immune_system) <= 10:
is_copy = copy.deepcopy(self.chromosome.immune_system)
length = len(is_copy)
index = get_RNG().choice(range(length))
is_copy[index] = 1 - is_copy[index]
self.immune_system.append("".join(map(str, is_copy)))
def weighted_choice(choices):
total = sum(w for c, w, i in choices)
r = get_RNG().uniform(0, total)
up_to = 0
for c, w, i in choices:
if up_to + w > r:
return c, i
up_to += w
assert False, "Shouldn't get here"
def weighted_choice(choices):
total = sum(w for c, w, i in choices)
r = get_RNG().uniform(0, total)
up_to = 0
for c, w, i in choices:
if up_to + w > r:
return c, i
up_to += w
assert False, "Shouldn't get here"
def r2_procreate(self, abm, ca):
neighborhood = ca.get_agent_neighborhood(self.x, self.y, 1)
if self.is_fertile():
free_cells = [
v[0] for v in list(neighborhood.values())
if v[1] is False and (v[0].x != self.x and v[0].y != self.y)
]
mates = [
v[1] for v in list(neighborhood.values()) if not v[1] is False
]
if mates:
m = get_RNG().choice(mates)
both_wealthy1 = (self.sugar >= self.init_sugar
and m.sugar >= m.init_sugar)
both_wealthy2 = (self.spice >= self.init_spice
and m.spice >= m.init_spice)
# All criteria is fulfilled to procreate!
if free_cells and m.is_fertile(
) and m.gender != self.gender and both_wealthy1 and both_wealthy2:
# Take one free cell to place Junior there.
c = get_RNG().choice(free_cells)
n_x = c.x
n_y = c.y
# Give him / her initial resources
n_su = int(self.init_sugar / 2) + int(m.init_sugar / 2)
n_sp = int(self.init_spice / 2) + int(m.init_spice / 2)
self.sugar -= int(self.init_sugar / 2)
self.spice -= int(self.init_spice / 2)
m.sugar -= int(m.init_sugar / 2)
m.spice -= int(m.init_spice / 2)
# Fuse mommy's and daddy's chromosomes to create Juniors attributes.
# This is the actual creation of the baby. Behold the wonders of nature!
n_chromosome = self.chromosome.merge_with(m.chromosome)
child = SSAgent(n_x, n_y, self.gc, n_su, n_sp, 0,
n_chromosome)
# Give the parents a reference to their newborn so they can,
# inherit their wealth to it before their inevitable demise.
self.children.append(child)
m.children.append(child)
# Update the abm that it has to schedule a new agent.
abm.add_agent(child)
def create_gamete(genomes):
"""
Creates and returns a gamete that consists of parts of
both genomes in this chromosome.
:return: Gamete in form of a single bitstring.
"""
# 1) Generate a random number (gaussian distributed) of
# random indices which are then used to split the genes at the respective points.
genome_size = len(genomes[0])
num_partitions = int(get_RNG().triangular(0, genome_size / 2, genome_size))
partitions = get_RNG().sample(range(genome_size), num_partitions)
partitions.sort() # Now we have all our indices, and sorted.
partitions.append(genome_size) # Append the end of the string
start = 0
gamete = []
for p in partitions:
i = get_RNG().choice([0, 1])
gamete.extend(genomes[i][start:p])
start = p
# 'gamete' is now a list of integers. Convert the ints to strings and join 'em all together.
return gamete
def mutate(self):
"""
Has a chance of 0.5% to perform a random mutation in the dna,
and a chance of 1% to flip a few bits in the cultural dna.
:return:
"""
# Flip bit in genome
if get_RNG().random() < 0.005:
length = len(self.genomes)
index = get_RNG().randrange(length)
l = list(self.genomes[0])
l[index] = Chromosome.invert_bit(l[index])
g1 = "".join(l)
index = get_RNG().randrange(length)
l = list(self.genomes[1])
l[index] = Chromosome.invert_bit(l[index])
g2 = "".join(l)
self.genomes = (g1, g2)
# Flip a bit in culture
if get_RNG().random() < 0.01:
length = len(self.culture)
num_bits_changed = int(get_RNG().triangular(0, 1, length))
index = get_RNG().sample(range(length), num_bits_changed)
for i in index:
self.culture[i] = 1 - self.culture[i]
def spread_creep(self, neighborhood):
cells = [c for c in list(neighborhood.values())]
possible_cells = [
c for c in cells if c.team and self.team.number == c.team.number
]
if possible_cells:
if self.strategy_seed == 0:
cab_rng.get_RNG().shuffle(cells)
cell = cab_rng.get_RNG().choice(cells)
else:
min_val = min(possible_cells, key=attrgetter('temperature'))
c_list = [
c for c in possible_cells
if c.temperature == min_val.temperature
]
c_list.extend([
c for c in cells
if not c.team or self.team.number != c.team.number
])
cab_rng.get_RNG().shuffle(c_list)
cell = cab_rng.get_RNG().choice(c_list)
self.score += cell.inc_temperature(self.team, self.power)
else:
print("agent died: t{0} d{1} w{2} s{3} p{4}".format(
self.team.number, self.min_density, self.strategy_seed,
self.strategy_seed, self.power))
self.dead = True
def walk(self, neighborhood):
possible_cells = [
c for c in list(neighborhood.values())
if c.team and self.team.number == c.team.number
and c.temperature >= self.min_density
]
self.prev_x = self.x
self.prev_y = self.y
if possible_cells:
if self.strategy_walk == 0:
cab_rng.get_RNG().shuffle(possible_cells)
cell = cab_rng.get_RNG().choice(possible_cells)
else: # self.strategy_walk == 1:
min_val = min(possible_cells, key=attrgetter('temperature'))
c_list = [
c for c in possible_cells
if c.temperature == min_val.temperature
]
cab_rng.get_RNG().shuffle(c_list)
cell = cab_rng.get_RNG().choice(c_list)
# Move to new cell
self.x = cell.x
self.y = cell.y
else:
print("agent died: t{0} d{1} w{2} s{3} p{4}".format(
self.team.number, self.min_density, self.strategy_seed,
self.strategy_seed, self.power))
self.dead = True
def mutate(self):
"""
Has a chance of 0.5% to perform a random mutation in the dna,
and a chance of 1% to flip a few bits in the cultural dna.
:return:
"""
# Flip bit in genome
if get_RNG().random() < 0.005:
length = len(self.genomes)
index = get_RNG().randrange(length)
l = list(self.genomes[0])
l[index] = Chromosome.invert_bit(l[index])
g1 = "".join(l)
index = get_RNG().randrange(length)
l = list(self.genomes[1])
l[index] = Chromosome.invert_bit(l[index])
g2 = "".join(l)
self.genomes = (g1, g2)
# Flip a bit in culture
if get_RNG().random() < 0.01:
length = len(self.culture)
num_bits_changed = int(get_RNG().triangular(0, 1, length))
index = get_RNG().sample(range(length), num_bits_changed)
for i in index:
self.culture[i] = 1 - self.culture[i]
def create_gamete(genomes):
"""
Creates and returns a gamete that consists of parts of
both genomes in this chromosome.
:return: Gamete in form of a single bitstring.
"""
# 1) Generate a random number (gaussian distributed) of
# random indices which are then used to split the genes at the respective points.
genome_size = len(genomes[0])
num_partitions = int(get_RNG().triangular(0, genome_size / 2,
genome_size))
partitions = get_RNG().sample(range(genome_size), num_partitions)
partitions.sort() # Now we have all our indices, and sorted.
partitions.append(genome_size) # Append the end of the string
start = 0
gamete = []
for p in partitions:
i = get_RNG().choice([0, 1])
gamete.extend(genomes[i][start:p])
start = p
# 'gamete' is now a list of integers. Convert the ints to strings and join 'em all together.
return gamete
def __init__(self, x, y, gc):
"""
Initializes an agent
"""
super().__init__(x, y, gc)
self.id = "ant"
self.prev_x = x
self.prev_y = y
self.max_ph = gc.MAX_PHEROMONE
self.food = 1
self.has_food = False
self.dead = False
self.color = (0, 175, 200)
self.directions = [(1, 0), (1, -1), ( 0, -1), (-1, 0), (-1, 1), ( 0, 1)]
self.current_dir = get_RNG().randint(0, 5)
def __init__(self, x, y, gc):
"""
Initializes an agent
"""
super().__init__(x, y, gc)
self.id = "ant"
self.prev_x = x
self.prev_y = y
self.max_ph = gc.MAX_PHEROMONE
self.food = 1
self.has_food = False
self.dead = False
self.color = (0, 175, 200)
self.directions = [(1, 0), (1, -1), (0, -1), (-1, 0), (-1, 1), (0, 1)]
self.current_dir = get_RNG().randint(0, 5)
def choose_dominant_gene(strings):
"""
Takes two gene strings and returns the dominant one,
or random if both are dominant/ recessive
:param strings: Two sub-genes of the chromosome
:return: The more dominant/ luckier string of both.
"""
# How do we determine dominance?
# For now just by looking whether there is an even number of 'ones' in it.
dominant0 = strings[0].count('1') % 2 == 0
dominant1 = strings[1].count('1') % 2 == 0
if (dominant0 and dominant1) or (not (dominant0 or dominant1)):
return get_RNG().choice([strings[0], strings[1]])
elif dominant1:
return strings[0]
else:
return strings[1]
def choose_dominant_gene(strings):
"""
Takes two gene strings and returns the dominant one,
or random if both are dominant/ recessive
:param strings: Two sub-genes of the chromosome
:return: The more dominant/ luckier string of both.
"""
# How do we determine dominance?
# For now just by looking whether there is an even number of 'ones' in it.
dominant0 = strings[0].count('1') % 2 == 0
dominant1 = strings[1].count('1') % 2 == 0
if (dominant0 and dominant1) or (not (dominant0 or dominant1)):
return get_RNG().choice([strings[0], strings[1]])
elif dominant1:
return strings[0]
else:
return strings[1]
def update(self):
"""
This method regulates the cell's state according to the state of its neighbors.
"""
if self.zone.type == 'EMPTY':
self.zone.update(self)
else:
if len(self.neighbor_zones) > 0:
new_zone = get_RNG().choice(list(self.neighbor_zones))
if new_zone.type == 'RESIDENTIAL':
self.zone = ResidentialZone()
elif new_zone.type == 'COMMERCIAL':
self.zone = CommercialZone()
elif new_zone.type == 'INDUSTRIAL':
self.zone = IndustrialZone()
self.color = self.zone.color
self.neighbor_zones.clear()
print("self.color: ", self.color)
self.update_color()
def update(self):
"""
This method regulates the cell's state according to the state of its neighbors.
"""
if self.zone.type == 'EMPTY':
self.zone.update(self)
else:
if len(self.neighbor_zones) > 0:
new_zone = get_RNG().choice(list(self.neighbor_zones))
if new_zone.type == 'RESIDENTIAL':
self.zone = ResidentialZone()
elif new_zone.type == 'COMMERCIAL':
self.zone = CommercialZone()
elif new_zone.type == 'INDUSTRIAL':
self.zone = IndustrialZone()
self.color = self.zone.color
self.neighbor_zones.clear()
print("self.color: ", self.color)
self.update_color()
def r1_select_best_cell(self, ca):
"""
Agent selects the best cell to move to, according to: its resources, occupier and tribal alignment.
"""
neighborhood = ca.get_empty_agent_neighborhood(self.x, self.y,
self.vision)
best_cells = list()
max_dist = 0
max_w = 0
# Find cells with the highest possible reward.
# TODO: check if distance calculation is correct for hex grids
# print('neighborhood: {0}'.format(list(neighborhood.keys())))
for cell in list(neighborhood.values()):
if not best_cells:
best_cells = [cell]
max_w = self.welfare(cell.sugar, cell.spice)
max_dist = (abs(cell.x - self.x) + abs(cell.y - self.y))
else:
dist = ca.hex_distance(self.x, self.y, cell.q, cell.r)
welfare = self.welfare(cell.sugar, cell.spice)
if welfare > max_w:
best_cells = [cell]
max_w = welfare
max_dist = dist
elif welfare == max_w and dist < max_dist:
best_cells = [cell]
max_dist = dist
elif welfare == max_w and dist == max_dist:
best_cells.append(cell)
result_cell = get_RNG().choice(best_cells)
# TODO: In case the target cell is not directly adjacent, find an adjacent cell that leads into its direction.
# TODO: Make sure to pick one adjacent cell that is NOT currently occupied. Maybe calculate a path.
# if self.vision > 1 and CAHex.cube_distance(ca.ca_grid[self.x, self.y], result_cell) > 1:
# next_in_direction = CAHex.get_cell_in_direction(ca.ca_grid[self.x, self.y], result_cell)
# result_cell = ca.ca_grid[next_in_direction]
self.move_to(result_cell)
self.eat_from(result_cell)
def r1_select_best_cell(self, ca):
"""
Agent selects the best cell to move to, according to: its resources, occupier and tribal alignment.
"""
neighborhood = ca.get_empty_agent_neighborhood(self.x, self.y, self.vision)
best_cells = list()
max_dist = 0
max_w = 0
# Find cells with the highest possible reward.
# TODO: check if distance calculation is correct for hex grids
# print('neighborhood: {0}'.format(list(neighborhood.keys())))
for cell in list(neighborhood.values()):
if not best_cells:
best_cells = [cell]
max_w = self.welfare(cell.sugar, cell.spice)
max_dist = (abs(cell.x - self.x) + abs(cell.y - self.y))
else:
dist = ca.hex_distance(self.x, self.y, cell.q, cell.r)
welfare = self.welfare(cell.sugar, cell.spice)
if welfare > max_w:
best_cells = [cell]
max_w = welfare
max_dist = dist
elif welfare == max_w and dist < max_dist:
best_cells = [cell]
max_dist = dist
elif welfare == max_w and dist == max_dist:
best_cells.append(cell)
result_cell = get_RNG().choice(best_cells)
# TODO: In case the target cell is not directly adjacent, find an adjacent cell that leads into its direction.
# TODO: Make sure to pick one adjacent cell that is NOT currently occupied. Maybe calculate a path.
# if self.vision > 1 and CAHex.cube_distance(ca.ca_grid[self.x, self.y], result_cell) > 1:
# next_in_direction = CAHex.get_cell_in_direction(ca.ca_grid[self.x, self.y], result_cell)
# result_cell = ca.ca_grid[next_in_direction]
self.move_to(result_cell)
self.eat_from(result_cell)
def get_island_landscape(self):
l1 = [[0 for _ in range(self.y_dim)] for _ in range(self.x_dim)]
l2 = [[0 for _ in range(self.y_dim)] for _ in range(self.x_dim)]
lower_limit = int((self.y_dim + self.x_dim) * 0.33)
upper_limit = int((self.y_dim + self.x_dim) * 0.9)
print(lower_limit, upper_limit)
last_rand = 0
for j in range(self.y_dim):
for i in range(self.x_dim):
if (i + j) % self.factor == 0:
last_rand = int(cab_rng.get_RNG().triangular(
self.deepest, self.highest, self.water_level))
l1[i][j] = last_rand
for _ in range(self.smoothness):
for j in range(self.y_dim):
for i in range(self.x_dim):
n = 0
f = 0
for cy in range(-1, 2):
for cx in range(-1, 2):
if not (cy == 0 and cx == 0):
try:
n += 1
f += l1[i + cx][j + cy]
except IndexError:
pass
avg = f / n
if avg > l1[i][j]:
diff = avg - l1[i][j]
l2[i][j] = l1[i][j] + (diff * self.slope)
elif avg < l1[i][j]:
diff = l1[i][j] - avg
l2[i][j] = l1[i][j] - (diff * self.slope)
else:
l2[i][j] = l1[i][j]
l1, l2 = l2, l1
return l1
def get_coastal_landscape(self):
l1 = {}
l2 = {}
for j in range(self.height):
for i in range(self.width):
# l1[i][j] = int(get_RNG().triangular(self.deepest, self.highest, 5))s
q = i - math.floor(j / 2)
mode = (((i + j) / 200) * 5) + self.water_level
l1[q, j] = int(get_RNG().triangular(self.deepest + 2 * mode,
self.highest + 2 * mode,
mode))
# l1[i][j] = int(get_RNG().triangular(self.deepest + 2 * mode, self.highest + 2 * mode, mode))
for _ in range(self.smoothness):
for j in range(self.height):
for i in range(self.width):
q = i - math.floor(j / 2)
n = 0
f = 0
for d in self.gc.HEX_DIRECTIONS:
if not (d[0] == 0 and d[1] == 0):
try:
n += 1
f += l1[q + d[0], j + d[1]]
except KeyError:
pass
avg = f / n
if avg > l1[q, j]:
diff = avg - l1[q, j]
l2[q, j] = l1[q, j] + (diff * self.slope)
elif avg < l1[q, j]:
diff = l1[q, j] - avg
l2[q, j] = l1[q, j] - (diff * self.slope)
else:
l2[q, j] = l1[q, j]
l1, l2 = l2, l1
return l1
def get_island_landscape(self):
l1 = [[0 for _ in range(self.y_dim)] for _ in range(self.x_dim)]
l2 = [[0 for _ in range(self.y_dim)] for _ in range(self.x_dim)]
lower_limit = int((self.y_dim + self.x_dim) * 0.33)
upper_limit = int((self.y_dim + self.x_dim) * 0.9)
print(lower_limit, upper_limit)
last_rand = 0
for j in range(self.y_dim):
for i in range(self.x_dim):
if (i + j) % self.factor == 0:
last_rand = int(cab_rng.get_RNG().triangular(self.deepest, self.highest, self.water_level))
l1[i][j] = last_rand
for _ in range(self.smoothness):
for j in range(self.y_dim):
for i in range(self.x_dim):
n = 0
f = 0
for cy in range(-1, 2):
for cx in range(-1, 2):
if not (cy == 0 and cx == 0):
try:
n += 1
f += l1[i + cx][j + cy]
except IndexError:
pass
avg = f / n
if avg > l1[i][j]:
diff = avg - l1[i][j]
l2[i][j] = l1[i][j] + (diff * self.slope)
elif avg < l1[i][j]:
diff = l1[i][j] - avg
l2[i][j] = l1[i][j] - (diff * self.slope)
else:
l2[i][j] = l1[i][j]
l1, l2 = l2, l1
return l1
def map_genome_to_attributes(self):
"""
Decodes the genome and creates the attribute of the individual.
"""
# The meta and init attributes cannot become smaller than 1,
# even though that is possible by the encoding. We have to avoid that.
meta_sugar = Chromosome.choose_dominant_gene(
self.get_genome_substring('meta_sugar'))
meta_spice = Chromosome.choose_dominant_gene(
self.get_genome_substring('meta_spice'))
init_sugar = Chromosome.choose_dominant_gene(
self.get_genome_substring('init_sugar'))
init_spice = Chromosome.choose_dominant_gene(
self.get_genome_substring('init_spice'))
vision = Chromosome.choose_dominant_gene(
self.get_genome_substring('vision'))
gender = get_RNG().choice(self.get_genome_substring('gender'))
f1 = Chromosome.choose_dominant_gene(
self.get_genome_substring('fertility_1'))
f2 = Chromosome.choose_dominant_gene(
self.get_genome_substring('fertility_2'))
dying_age = Chromosome.choose_dominant_gene(
self.get_genome_substring('dying_age'))
self.meta_sugar = max(int(meta_sugar, 2), 1)
self.meta_spice = max(int(meta_spice, 2), 1)
self.init_sugar = max(int(init_sugar, 2), 1)
self.init_spice = max(int(init_spice, 2), 1)
self.vision = int(vision, 2)
self.gender = int(gender, 2)
self.dying_age = int(dying_age, 2)
self.fertility = (int(f1, 2), int(f2, 2))
dna = "".join((meta_sugar, meta_spice, init_sugar, init_spice, vision,
gender, f1, f2, dying_age))
self.dna_color = Chromosome.convert_to_color(dna)
def spread_creep(self, neighborhood):
cells = [c for c in list(neighborhood.values())]
possible_cells = [
c for c in cells if c.team and self.team.number == c.team.number]
if possible_cells:
if self.strategy_seed == 0:
cab_rng.get_RNG().shuffle(cells)
cell = cab_rng.get_RNG().choice(cells)
else:
min_val = min(possible_cells, key=attrgetter('temperature'))
c_list = [c for c in possible_cells if c.temperature ==
min_val.temperature]
c_list.extend(
[c for c in cells if not c.team or self.team.number != c.team.number])
cab_rng.get_RNG().shuffle(c_list)
cell = cab_rng.get_RNG().choice(c_list)
self.score += cell.inc_temperature(self.team, self.power)
else:
print("agent died: t{0} d{1} w{2} s{3} p{4}".format(
self.team.number, self.min_density, self.strategy_seed, self.strategy_seed, self.power))
self.dead = True
def walk(self, neighborhood):
possible_cells = [c for c in list(neighborhood.values(
)) if c.team and self.team.number == c.team.number and c.temperature >= self.min_density]
self.prev_x = self.x
self.prev_y = self.y
if possible_cells:
if self.strategy_walk == 0:
cab_rng.get_RNG().shuffle(possible_cells)
cell = cab_rng.get_RNG().choice(possible_cells)
else: # self.strategy_walk == 1:
min_val = min(possible_cells, key=attrgetter('temperature'))
c_list = [c for c in possible_cells if c.temperature ==
min_val.temperature]
cab_rng.get_RNG().shuffle(c_list)
cell = cab_rng.get_RNG().choice(c_list)
# Move to new cell
self.x = cell.x
self.y = cell.y
else:
print("agent died: t{0} d{1} w{2} s{3} p{4}".format(
self.team.number, self.min_density, self.strategy_seed, self.strategy_seed, self.power))
self.dead = True
def get_cell_with_pheromone(self, target_ph, neighborhood):
"""
Gets the cell with highest pheromone value (or random if no pheromones present)
from the immediate neighborhood.
:param: neighborhood is a dict of (x, y) -> cell mappings,
where cell is a tuple of (ca_cell, [agent(s) on cell]).
If no agent is on the cell then the list in the tuple is simply 'False'
"""
result = None
result_list = []
backup_list = []
best_cell = None
max_ph = 0
# Choose the possible directions the ants can currently look at.
if self.current_dir == 5:
possible_dirs = [4, 5, 0]
elif self.current_dir == 0:
possible_dirs = [5, 0, 1]
else:
possible_dirs = [
self.current_dir - 1, self.current_dir, self.current_dir + 1
]
for i in possible_dirs:
d = self.directions[i]
_x = self.x + d[0]
_y = self.y + d[1]
if (_x, _y) in neighborhood:
cell = neighborhood[_x, _y]
if cell[0].pheromones[
target_ph] > 0.00: # and (not cell[1] or len(cell[1]) < 10):
ph = cell[0].pheromones[target_ph]
if ph > max_ph:
best_cell = cell
max_ph = ph
self.current_dir = i
result_list.append((cell, ph, i))
# elif not cell[1] or len(cell[1]) < 10:
else:
backup_list.append((cell, i))
if result_list:
if get_RNG().random() < 0.10:
choice = AntAgent.weighted_choice(result_list)
# choice = get_RNG().choice(result_list)
result = choice[0]
self.current_dir = choice[1]
else:
result = best_cell
elif backup_list:
choice = get_RNG().choice(backup_list)
result = choice[0]
self.current_dir = choice[1]
else:
# print('Ant Error: no cells found to move to!')
self.current_dir = AntAgent.get_opposite_direction(
self.current_dir)
return self.get_cell_with_pheromone(target_ph, neighborhood)
# Add a small random factor to the movement.
return result
def get_random_valid_position(self) -> Tuple[int, int]:
"""
Returns coordinates of a random cell position that is within the boundaries of the grid.
:returns Coordinates in hex form.
"""
return cab_rng.get_RNG().choice(list(self.ca_grid.keys()))
def generate_agent(self, abm, ca):
# x, y = ca.get_random_valid_position()
# while (x, y) in abm.agent_locations:
# x, y = ca.get_random_valid_position()
x, y = get_RNG().choice(self.possible_starting_locations)
self.possible_starting_locations.remove((x, y))
meta_sugar = get_RNG().randint(self.gc.MIN_METABOLISM, self.gc.MAX_METABOLISM)
meta_spice = get_RNG().randint(self.gc.MIN_METABOLISM, self.gc.MAX_METABOLISM)
vision = get_RNG().randint(1, self.gc.VISION + 1)
g = get_RNG().choice([0, 1])
if g == 1:
f1 = get_RNG().randint(self.gc.F_FERTILITY_START[0], self.gc.F_FERTILITY_START[1])
f2 = get_RNG().randint(self.gc.F_FERTILITY_END[0], self.gc.F_FERTILITY_END[1])
f = (f1, f2)
else:
f1 = get_RNG().randint(self.gc.M_FERTILITY_START[0], self.gc.M_FERTILITY_START[1])
f2 = get_RNG().randint(self.gc.M_FERTILITY_END[0], self.gc.M_FERTILITY_END[1])
f = (f1, f2)
su = get_RNG().randint(self.gc.STARTING_SUGAR[0], self.gc.STARTING_SUGAR[1])
sp = get_RNG().randint(self.gc.STARTING_SUGAR[0], self.gc.STARTING_SUGAR[1])
d = get_RNG().randint(f[1], self.gc.MAX_AGENT_LIFE)
c = [get_RNG().randint(0, int((meta_sugar + meta_spice) / 2)) for _ in range(11)]
# imm_sys = [get_RNG().getrandbits(self.gc.NUM_TRIBES - 1) for _ in range(self.gc.IMMUNE_SYSTEM_GENOME_LENGTH)]
imm_sys = [get_RNG().getrandbits(int((meta_sugar + meta_spice) / 2)) for _ in range(self.gc.IMMUNE_SYSTEM_GENOME_LENGTH)]
a = 0 # get_RNG().randint(0, int(self.gc.MAX_AGENT_LIFE / 2))
gene_string = "{0:03b}".format(meta_sugar) + "{0:03b}".format(meta_spice)\
+ "{0:06b}".format(su) + "{0:06b}".format(sp) \
+ "{0:03b}".format(vision) + "{0:01b}".format(g)\
+ "{0:06b}".format(f[0]) + "{0:06b}".format(f[1]) + "{0:07b}".format(d)
# We use generation to keep track of how far an agent has walked down the evolutionary road.
generation = (0, 0)
genome = (gene_string, gene_string, c, imm_sys, generation)
# Retrieve a spawn position from the position list belonging to its tribe.
# tribe_id = max(set(c), key=c.count)
# get_RNG().shuffle(position_list[tribe_id])
# p = position_list[tribe_id].pop()
# Create the new agent and add to both, dictionary and list.
new_agent = SSAgent(x, y, self.gc, su, sp, a, genome)
# self.agent_dict[x, y] = new_agent
# self.agent_list.append(new_agent)
# abm.add_agent(new_agent)
return new_agent