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
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])
groups[0] += agent
get_env().place_member(agent, xy=loc)
def restore_globals(env):
global groups
global mp_pref
global hood_size
global store_census
mp_pref = get_env().props["mp_pref"]
hood_size = get_env().props["hood_size"]
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
init_props(MODEL_NAME, props)
groups = []
groups.append(
Composite("value_investors", {"color": BLUE},
member_creator=create_value_investor,
num_members=get_prop("value_investors",
DEF_NUM_VALUE_INVESTOR)))
groups.append(
Composite("trend_followers", {"color": RED},
member_creator=create_trend_follower,
num_members=get_prop("trend_followers",
DEF_NUM_TREND_FOLLOWER)))
groups.append(create_market_maker("market_maker"))
Env("fmarket",
members=groups,
width=UNLIMITED,
height=UNLIMITED,
census=market_report,
line_data_func=plot_asset_price)
get_env().exclude_menu_item("scatter_plot")
def populate_board_exploder(width, height):
center = [width // 2, height // 2]
agent_loc = [(center[0], center[1]), (center[0], center[1] - 4)]
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])
groups[0] += agent
get_env().place_member(agent, xy=loc)
def main():
global wine_group
global cheese_group
global max_util
(cheese_group, wine_group, max_util) = set_up()
# `get_env()` returns an env, which itself is a callable object
get_env()()
return 0
def reproduce(agent, create_func, num_created, group):
"""
Agents reproduce when "time_to_repr" reaches 0
"""
if agent["time_to_repr"] == 0:
get_env().add_child(group)
agent["time_to_repr"] = agent["orig_repr_time"]
return True
else:
return False
def populate_board_glider(width, height):
global groups
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])
groups[0] += agent
get_env().place_member(agent, xy=loc)
def main():
global resource_holders
global entrepreneurs
(blue_group, red_group) = set_up()
if DEBUG2:
get_env().user.tell(get_env().__repr__())
get_env()()
return 0
def dealer_action(dealer): # testcase??
"""
Display debug statements
"""
get_env().user.tell("I'm " + dealer.name + " and I'm a dealer.")
dealer_characteristic = get_dealer_characteristic()
dealer["dealer_characteristic"] = dealer_characteristic
dealer["emoji_used"] = get_dealer_emoji(dealer_characteristic)
dealer["curr_car_life"] = get_dealer_car(dealer_characteristic)
# return False means to move
return False
def main():
global trader_group
global max_utility
(trader_group, max_utility) = set_up()
if DEBUG2:
get_env().user.tell(get_env().__repr__())
get_env()()
return 0
def main():
if len(sys.argv) < 2:
print("datafile name missing")
print("USAGE: used_cars.py [datafile]")
exit(1)
pathname = sys.argv[1]
filename = pathname.split("/")[1]
info = filename.split("_")[0]
num_dealers = int(info)
set_up(num_dealers)
get_env()()
return 0
def rholder_action(agent):
if agent["resources"]:
get_env().user.tell("I'm " + agent.name +
" and I've got resources. I have " +
str(agent["cash"]) + " dollors now." + " I have " +
str(agent["resources"]) + ".")
else:
get_env().user.tell("I'm " + agent.name +
" and I've got resources. I have " +
str(agent["cash"]) + " dollors now." +
" I ran out of resources!")
# resource holder dont move
return True
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)]
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
groups[0] += 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
for r in range(right):
agent_loc.append((center[0] + r, center[1]))
for l in range(1, left):
agent_loc.append((center[0] - l, center[1]))
for loc in agent_loc:
agent = create_game_cell(loc[0], loc[1])
groups[0] += 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
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])
groups[0] += agent
get_env().place_member(agent, xy=loc)
def seek_a_trade(agent):
nearby_agent = get_env().get_closest_agent(agent)
if nearby_agent is not None:
negotiate(agent, nearby_agent)
print("I'm", agent.name, "I have", goods_to_str(agent[GOODS]))
# return False means to move
return False
def seg_agent_action(agent):
"""
If the agent is surrounded by more "others" than it
is comfortable with, the agent will move.
"""
stay_put = True
if agent["hood_changed"]:
agent_group = agent.primary_group()
ratio_same = 0
neighbors = get_env().get_moore_hood(agent,
hood_size=agent['hood_size'])
num_same = 0
for neighbor in neighbors:
if neighbors[neighbor].primary_group() == agent_group:
num_same += 1
if agent["just_moved"] is True:
neighbors[neighbor]["hood_changed"] = True
agent["just_moved"] = False
if len(neighbors) != 0:
ratio_same = num_same / len(neighbors)
stay_put = env_favorable(ratio_same, agent[TOLERANCE])
if stay_put:
agent["hood_changed"] = False
else:
agent["just_moved"] = True
for neighbor in neighbors:
neighbors[neighbor]["hood_changed"] = True
return stay_put
def env(self):
"""
This is the env property.
We use `registry.get_env()` to return whatever
the registry has.
"""
return get_env()
def check_for_new_agents(agent):
global to_come_alive
curr_x = agent.get_x()
curr_y = agent.get_y()
for y in ([-1, 0, 1]):
for x in ([-1, 0, 1]):
if (x != 0) or (y != 0):
new_x = curr_x + x
new_y = curr_y + y
if get_env().get_agent_at(new_x, new_y) is None:
x1, x2, y1, y2 = get_env().get_moore_hood_idx(new_x,
new_y)
if apply_dead_rules(new_x, new_y, x1, x2, y1, y2):
to_come_alive.append((new_x, new_y))
return to_come_alive
def buyer_action(agent): # how to write this testcase
"""
This functions lets buyer
to decides whether wants to buy a car or not
"""
print("_" * 20)
print("Agent: " + agent.name)
agent["age"] += 1
if not agent["has_car"]:
my_dealer = get_env().get_neighbor_of_groupX(agent,
get_group(DEALER_GRP),
hood_size=4)
if my_dealer is None:
print("No dealers nearby.")
elif is_credible(my_dealer, agent):
buy_from_dealer(agent, my_dealer)
else:
print("I found a rotten dealer: ", str(my_dealer))
else:
# return False means to move
print("I have a car!")
agent["car_life"] -= 1
if agent["car_life"] <= 0:
agent["has_car"] = False
# call strategy function to update the data
agent["strategy"]["func"]()
print("Agent strategy =", agent["strategy"])
return False
def setUp(self):
self.models = {}
with open("models.json") as json_file:
data = json.load(json_file)
for mdl_json in data["models_database"]:
model = locate("models." + mdl_json["run"])
model.set_up()
self.models[mdl_json["name"]] = get_env()
def test_get_env(self):
"""
We don't need to use "real" Env: just make sure get returns
what set put in!
"""
set_env("Test")
env = get_env()
self.assertEqual(env, "Test")
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
global max_utility
pa = init_props(MODEL_NAME, props, model_dir="capital")
trader_group = Composite("trader", {"color": BLUE},
member_creator=create_trader,
props=pa,
num_members=get_prop('num_traders',
DEF_NUM_TRADER))
Env("env",
height=get_prop('grid_height', DEF_HEIGHT),
width=get_prop('grid_width', DEF_WIDTH),
members=[trader_group])
for trader in trader_group:
allocate_resources(trader_group[trader], GOODS)
get_env().user.tell(trader_group[trader]["goods"])
return (trader_group, max_utility)
def drinker_action(agent):
global attendance
global attendance_record
global agents_decided
drinkers = get_group(DRINKERS)
non_drinkers = get_group(NON_DRINKERS)
changed = True
decision = get_decision(agent)
agents_decided += 1
if agents_decided == population:
attendance_record.append(attendance)
if attendance > optimal_occupancy:
extras = attendance - optimal_occupancy
discourage(extras)
agents_decided = 0
attendance = 0
print("Avg attendance so far: ",
get_average_attendance(attendance_record))
if decision:
attendance += 1
if agent.primary_group() == non_drinkers:
changed = False
get_env().add_switch(agent, non_drinkers,
drinkers)
else:
if agent.primary_group() == drinkers:
changed = False
get_env().add_switch(agent, drinkers,
non_drinkers)
# return False means to move
return changed
def run(user, test_run=False):
# steps = 0
# acts = 0
if not test_run:
steps = user.ask("How many periods?")
if steps is None or steps == "" or steps.isspace():
steps = DEF_STEPS
else:
steps = int(steps)
user.tell("Steps = " + str(steps))
else:
steps = DEF_STEPS
acts = get_env().runN(periods=steps)
return acts
def apply_dead_rules(curr_x, curr_y, x1, x2, y1, y2):
"""
Apply the rules for dead agents.
The agent passed in should be alive, meaning its color should be white.
"""
global groups
num_live_neighbors = 0
for x in range(x1, x2 + 1):
for y in range(y1, y2 + 1):
neighbor = get_env().get_agent_at(x, y)
if (neighbor is not None and neighbor.primary_group() == groups[0]
and (curr_x != x or curr_y != y)):
num_live_neighbors += 1
if num_live_neighbors == 3:
return True
else:
return False
def consumer_action(consumer):
"""
Check shops near consumer and
consumer decide where to shop at.
"""
global hood_size
nearby_neighbors = get_env().get_moore_hood(consumer, hood_size=hood_size)
store_to_go = None
max_util = 0.0
for neighbors in nearby_neighbors:
neighbor = nearby_neighbors[neighbors]
if (neighbor.is_active()
and (neighbor.primary_group() != groups[CONSUMER_INDX])):
if sells_good(neighbor, consumer, groups):
curr_store_util = get_util(neighbor)
if curr_store_util > max_util:
max_util = curr_store_util
store_to_go = neighbor
if store_to_go is not None:
transaction(store_to_go, consumer)
if DEBUG:
print(" someone shopped at ", store_to_go)
consumer["item needed"] = get_rand_good_type()
return False
def put_props(model_id, payload, indra_dir):
model = get_model(model_id, indra_dir=indra_dir)
setup_dict[model["run"]](props=payload)
env = get_env()
print(env)
return json_converter(get_env())
def main():
set_up()
get_env()()
return 0
def line_graph(user, update=False):
if update:
user.tell("Updating the line graph.")
else:
user.tell("Drawing a line graph.")
return get_env().line_graph()
