def tsetter_action(agent, **kwargs):
execution_key = get_exec_key(kwargs=kwargs)
return common_action(agent,
get_group(RED_FOLLOWERS, execution_key=execution_key),
get_group(BLUE_FOLLOWERS,
execution_key=execution_key),
gt,
lt, **kwargs)
def setUp(self, props=None):
set_up()
self.wolf = create_wolf(TEST_WNAME, TEST_WNUM)
self.sheep = create_sheep(TEST_SNAME, TEST_SNUM)
self.wolves = get_group(WOLF_GROUP)
self.wolves += self.wolf
# make a new plural for sheep!
self.sheeps = get_group(SHEEP_GROUP)
self.sheeps += self.sheep
get_env().place_member(self.sheep, None)
get_env().place_member(self.wolf, None)
def tsetter_action(agent, **kwargs):
"""
Action for trend setters
"""
return common_action(
agent,
get_group(RED_FOLLOWERS, agent.exec_key),
get_group(BLUE_FOLLOWERS, agent.exec_key),
gt,
lt,
**kwargs)
def follower_action(agent, **kwargs):
"""
Action for followers
"""
return common_action(
agent,
get_group(RED_TSETTERS, agent.exec_key),
get_group(BLUE_TSETTERS, agent.exec_key),
lt,
gt,
**kwargs
)
def transaction(store, consumer):
"""
Add money to the store's capital from consumer.
"""
capital = store.get_attr(CAPITAL) + consumer.get_attr(SPENDING_POWER)
store.set_attr(CAPITAL, capital)
if NOT_DEBUG:
print(store.name, store.get_attr(CAPITAL))
bb_grp = get_group(BIG_BOX, store.exec_key)
mp_grp = get_group(MP_STORE, store.exec_key)
debug_retailer(bb_grp)
debug_retailer(mp_grp)
def wolfram_action(wolf_env, **kwargs):
"""
The action that will be taken every period.
"""
execution_key = kwargs[EXEC_KEY]
row_above_idx = get_env_attr("prev_row_idx", execution_key=execution_key)
active_row_idx = wolf_env.height - wolf_env.get_periods()
wolf_env.user.tell("Checking agents in row {} against the rule {}".format(
active_row_idx, get_env_attr("rule_num", execution_key=execution_key)))
if active_row_idx < 1:
gone_far_enough()
return DONT_MOVE
else:
next_row_idx = active_row_idx - 1
next_row = wolf_env.get_row_hood(next_row_idx)
left_color = \
agent_color(x=0, y=active_row_idx, execution_key=execution_key)
x = 0
row_above = wolf_env.get_row_hood(row_above_idx)
for agent_nm in row_above:
if DEBUG:
print("Checking agent at", row_above[agent_nm])
if (x > 0) and (x < wolf_env.width - 1):
middle_color = agent_color(agent_nm=agent_nm,
execution_key=execution_key)
right_color = agent_color(x=x + 1,
y=active_row_idx,
execution_key=execution_key)
if DEBUG:
print(" Left: %d, middle: %d, right: %d" %
(left_color, middle_color, right_color))
if next_color(
get_env_attr("rule_dict", execution_key=execution_key),
left_color, middle_color, right_color):
wolf_env.add_switch(
next_row[agent_nm_from_xy(x, next_row_idx)],
get_group(WHITE, execution_key),
get_group(BLACK, execution_key))
left_color = middle_color
x += 1
set_env_attr("prev_row_idx", next_row_idx, execution_key=execution_key)
return DONT_MOVE
def wolf_action(agent, **kwargs):
if agent.duration <= 0:
return rem_agent(agent, **kwargs)
else:
prey = get_prey(agent, get_group(SHEEP_GROUP, kwargs=kwargs), **kwargs)
if prey is not None:
eat(agent, prey, **kwargs)
else:
agent.duration /= 2
agent[TIME_TO_REPR] -= 1
if agent[TIME_TO_REPR] == 0:
reproduce(agent, create_wolf, get_group(WOLF_GROUP, kwargs=kwargs),
**kwargs)
return False
def gameoflife_action(biosphere):
"""
The action that will be taken every period for the enviornment.
Loops through the list of agents that has to come alive and die
and carries out the corresponding action.
"""
global to_come_alive
global to_die
global reset_lists
b = get_group(BLACK)
for agent_pos in to_come_alive:
if DEBUG:
print("Agent at", agent_pos, "will come alive")
if biosphere.get_agent_at(agent_pos[0], agent_pos[1]) is None:
agent = create_game_cell(agent_pos[0], agent_pos[1])
b += agent
biosphere.place_member(agent, xy=(agent_pos[0], agent_pos[1]))
for agent in to_die:
if not isinstance(agent, tuple):
if DEBUG:
print("Agent at", agent, "will die")
agent.die()
b.del_member(agent)
biosphere.remove_location(agent.get_x(), agent.get_y())
reset_lists = True
return True
def populate_board(patterns, pattern_num, execution_key=CLI_EXEC_KEY):
agent_locs = patterns[pattern_num]
b = get_group(BLACK, execution_key)
for loc in agent_locs:
agent = create_game_cell(loc[X], loc[Y])
b += agent
get_env().place_member(agent, xy=loc)
def central_bank_action(agent, **kwargs):
"""
If exchanges are down "enough", distribute coupons!
Enough is a parameter.
"""
execution_key = get_exec_key(kwargs=kwargs)
CB_interven_pts = get_env_attr("CB_interven_pts",
execution_key=execution_key)
set_env_attr("num_rounds",
get_env_attr("num_rounds", execution_key=execution_key) + 1,
execution_key=execution_key)
co_op_mbrs = get_group(CO_OP_MEMBERS, execution_key=execution_key)
unemp_rate = get_env_attr("last_per_unemp",
execution_key=execution_key,
default_value=0) / len(co_op_mbrs) * 100
unemp_threshold = agent["percent_change"]
if unemp_rate >= unemp_threshold:
user_tell("Unemployment has risen to " + str(unemp_rate) +
" more than default value " + str(unemp_threshold) +
" CB Intervened")
CB_interven_pts.append([
get_env_attr("num_rounds", execution_key=execution_key),
get_env_attr("last_per_exchg", execution_key=execution_key)
])
distribute_coupons(agent, execution_key=execution_key)
return True
def populate_board_tumbler(width, height):
center = [width // 2, height // 2]
# this code is clearly awful: we must re-code this
# per the mathematical pattern underlying this crap
b = get_group(BLACK)
agent_loc = [(center[0] - 1, center[1]), (center[0] - 2, center[1]),
(center[0] + 1, center[1]),
(center[0] + 2, center[1]), (center[0] - 1, center[1] - 1),
(center[0] - 2, center[1] - 1),
(center[0] + 1, center[1] - 1),
(center[0] + 2, center[1] - 1),
(center[0] - 1, center[1] - 2),
(center[0] - 1, center[1] - 3),
(center[0] - 1, center[1] - 4),
(center[0] + 1, center[1] - 2),
(center[0] + 1, center[1] - 3),
(center[0] + 1, center[1] - 4),
(center[0] - 3, center[1] - 3),
(center[0] - 3, center[1] - 4),
(center[0] - 3, center[1] - 5),
(center[0] - 2, center[1] - 5),
(center[0] + 3, center[1] - 3),
(center[0] + 3, center[1] - 4),
(center[0] + 3, center[1] - 5),
(center[0] + 2, center[1] - 5)]
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
b += agent
get_env().place_member(agent, xy=loc)
def bacterium_action(agent, **kwargs):
"""
Algorithm:
1) sense env
(toxin_level = calc_toxin(toxins, agent))
2) see if it is worse or better than previous env
3) if worse, change direction
(agent["angle"] = new_angle)
4) move (done automatically by returning False)
"""
if DEBUG:
user_tell("I'm " + agent.name + " and I'm hungry.")
execution_key = CLI_EXEC_KEY
if EXEC_KEY in kwargs:
execution_key = kwargs[EXEC_KEY]
toxin_level = calc_toxin(get_group(TOXINS, execution_key=execution_key),
agent)
nutrient_level = calc_nutrient(
get_group(NUTRIENTS, execution_key=execution_key), agent)
if agent["prev_toxicity"] is not None:
toxin_change = toxin_level - agent["prev_toxicity"]
else:
toxin_change = sys.maxsize * (-1)
if agent["prev_nutricity"] is not None:
nutrient_change = nutrient_level - agent["prev_nutricity"]
else:
nutrient_change = sys.maxsize * (-1)
threshold = DEF_THRESHOLD
agent["prev_toxicity"] = toxin_level
agent["prev_nutricity"] = nutrient_level
if (toxin_change > nutrient_change) or (threshold >= toxin_level):
if agent["angle"] is None:
new_angle = randint(0, 360)
else:
angle_shift = randint(45, 315)
new_angle = agent["angle"] + angle_shift
if (new_angle > 360):
new_angle = new_angle % 360
agent["angle"] = new_angle
# return False means to move
return False
def populate_board_small_exploder(width, height, execution_key=CLI_EXEC_KEY):
center = [width // 2, height // 2]
agent_loc = get_agent_rules("small_exploder", center)
b = get_group(BLACK, execution_key)
for loc in agent_loc:
agent = create_game_cell(loc[X], loc[Y])
b += agent
get_env().place_member(agent, xy=loc)
def test_get_group(self):
"""
Don't worry about using a "real" group: just make sure we
get what was added!
"""
add_group("Group name", "Test")
grp = get_group("Group name")
self.assertEqual(grp, "Test")
def get_util(store):
"""
Get utility depending on the store type.
"""
if store.primary_group() == get_group(BIG_BOX):
return calc_util(store)
else:
return calc_util(store) + get_env_attr("mp_pref")
def height_rpt(env, **kwargs):
natural = get_group(NATURAL)
geneng = get_group(GENENG)
num_natural = len(natural)
num_geneng = len(geneng)
total_nat_height = 0
# total_gen_height = 0
for agent_nm in natural:
agent = get_registration(agent_nm)
total_nat_height += agent["height"]
user_tell("\n**************")
user_tell("Height Report:")
user_tell("**************")
user_tell(f"For the {num_natural} people in the natural group,")
user_tell("we have an average height of: " +
f"{total_nat_height / num_natural}")
user_tell(f"For the {num_geneng} people in the gen eng group,")
user_tell("we have an average height of:")
def distribute_coupons(agent, execution_key=CLI_EXEC_KEY):
"""
Distribute coupons from central bank randomly to each babysitter.
Coupons are gaussian distributed based on extra_coupons and extra_dev.
"""
co_op_members = get_group(CO_OP_MEMBERS, execution_key=execution_key)
for bbsit in co_op_members:
co_op_members[bbsit]['coupons'] += int(
gaussian(agent["extra_coupons"], agent["extra_dev"]))
def populate_board_glider(width, height):
b = get_group(BLACK)
center = [width // 2, height // 2]
agent_loc = [(center[0], center[1]), (center[0] - 1, center[1] + 1),
(center[0] + 1, center[1] + 1),
(center[0] + 1, center[1]), (center[0], center[1] - 1)]
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
b += agent
get_env().place_member(agent, xy=loc)
def populate_board_lightweight_spaceship(width,
height,
execution_key=CLI_EXEC_KEY):
center = [width // 2, height // 2]
agent_loc = get_agent_rules("spaceship", center)
b = get_group(BLACK, execution_key)
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
b += agent
get_env().place_member(agent, xy=loc)
def get_color(group, execution_key=None):
"""
Returns W or B, W for white and B for black
when passed in a group.
W and B are integer values:- 0 and 1, respectively.
"""
if group == get_group(WHITE, execution_key):
return W
else:
return B
def populate_board_exploder(width, height):
center = [width // 2, height // 2]
agent_loc = [(center[0], center[1]), (center[0], center[1] - 4)]
b = get_group(BLACK)
for i in range(0, 5):
agent_loc.append((center[0] - 2, center[1] - i))
agent_loc.append((center[0] + 2, center[1] - i))
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
b += agent
get_env().place_member(agent, xy=loc)
def switch(agent_nm, grp1_nm, grp2_nm, execution_key=None):
"""
Move agent from grp1 to grp2.
We first must recover agent objects from the registry.
"""
agent = get_registration(agent_nm, execution_key=execution_key)
if agent is None:
user_log_notif("In switch; could not find agent: " + str(agent))
grp1 = get_group(grp1_nm, execution_key=execution_key)
if grp1 is None:
user_log_notif("In switch; could not find from group: " + str(grp1))
grp2 = get_group(grp2_nm, execution_key=execution_key)
if grp2 is None:
user_log_notif("In switch; could not find to group: " + str(grp2))
split_em = split(grp1, agent)
joined_em = join(grp2, agent)
if DEBUG and split_em and joined_em:
user_log_notif("Switched agent " + str(agent) + " from grp " +
grp1_nm + "(id: " + str(id(grp1)) + ")" + " to grp " +
grp2_nm + "(id: " + str(id(grp2)) + ")")
def wolf_action(agent, **kwargs):
if agent.duration <= 0 or agent.duration == agent[TIME_TO_EMIGRATE]:
return rem_agent(agent, **kwargs)
else:
execution_key = get_exec_key(kwargs=kwargs)
prey = get_prey(agent,
get_group(SHEEP_GROUP, execution_key=execution_key),
**kwargs)
if prey is not None:
eat(agent, prey, **kwargs)
agent[TIME_TO_REPR] -= 1
# wolves can have a litter between 4 & 6 pups
num_of_babies = randint(4, 6)
while num_of_babies > 0:
reproduce(agent, create_wolf,
get_group(WOLF_GROUP, execution_key=execution_key),
**kwargs)
num_of_babies -= 1
agent.duration -= 1
return False
def populate_board_exploder(width, height, execution_key=CLI_EXEC_KEY):
center = [width // 2, height // 2]
agent_loc = get_agent_rules("exploder", center)
b = get_group(BLACK, execution_key)
for i in range(0, 5):
agent_loc.append((center[X] - 2, center[Y] - i))
agent_loc.append((center[X] + 2, center[Y] - i))
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
b += agent
get_env().place_member(agent, xy=loc)
def coop_action(coop_env, **kwargs):
execution_key = get_exec_key(kwargs=kwargs)
sitters = get_sitters(get_group(CO_OP_MEMBERS,
execution_key=execution_key))
going_out = get_going_out(
get_group(CO_OP_MEMBERS, execution_key=execution_key))
exchanges = min(len(sitters), len(going_out))
sitter_agents = [agent for agent in sitters]
going_out_agents = [agent for agent in going_out]
for i in range(exchanges):
sitter, outer = sitter_agents[i], going_out_agents[i]
sitters[sitter]['coupons'] += 1
going_out[outer]['coupons'] -= 1
set_env_attr("last_per_exchg", exchanges, execution_key=execution_key)
set_env_attr("last_per_unemp",
max(len(sitters), len(going_out)) - exchanges,
execution_key=execution_key)
return True
def populate_board_tumbler(width, height, execution_key=CLI_EXEC_KEY):
"""
Tumbler is a classic GOL pattern.
But this must be recoded to eliminate all the hard-coding of positions.
"""
center = [width // 2, height // 2]
b = get_group(BLACK, execution_key)
agent_loc = get_agent_rules("tumbler", center)
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
b += agent
get_env().place_member(agent, xy=loc)
def populate_board_n_vertical_row(width, height, n=10):
center = [width // 2, height // 2]
agent_loc = []
top = (n // 2) + (n % 2)
bottom = n // 2
b = get_group(BLACK)
for t in range(top):
agent_loc.append((center[0], center[1] + t))
for b in range(1, bottom):
agent_loc.append((center[0], center[1] - b))
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
b += agent
get_env().place_member(agent, xy=loc)
def populate_board_n_horizontal_row(width, height, n=10):
center = [width // 2, height // 2]
agent_loc = []
right = (n // 2) + (n % 2)
left = n // 2
b = get_group(BLACK)
for r in range(right):
agent_loc.append((center[0] + r, center[1]))
for le in range(1, left):
agent_loc.append((center[0] - le, center[1]))
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
b += agent
get_env().place_member(agent, xy=loc)
def populate_board_lightweight_spaceship(width, height):
center = [width // 2, height // 2]
agent_loc = [(center[0], center[1]), (center[0] - 1, center[1]),
(center[0] - 2, center[1]),
(center[0] - 3, center[1]), (center[0], center[1] - 1),
(center[0], center[1] - 2),
(center[0] - 4, center[1] - 1),
(center[0] - 1, center[1] - 3),
(center[0] - 4, center[1] - 3)]
b = get_group(BLACK)
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
b += agent
get_env().place_member(agent, xy=loc)
def get_prey(agent, sheep, **kwargs):
"""
Wolves eat active sheep from the neighbourhood
"""
exec_key = get_exec_key(kwargs=kwargs)
if len(get_group(SHEEP_GROUP, exec_key)) <= 0:
raise NoSheep("All out of sheep!")
return get_env(execution_key=exec_key) \
.get_neighbor_of_groupX(agent,
SHEEP_GROUP,
hood_size=get_env_attr(
"prey_dist",
execution_key=exec_key))
