def test_distance_between():
environment = [0, 0, 0, 0]
agent1 = [0, 0, 0, 0]
agent2 = [5, 3, 3, 5]
agent = agentframework.Agent(environment, agent1)
agent1_2 = agentframework.Agent(environment, agent2)
assert distance_between(agent, agent) == 0
assert distance_between(agent1_2, agent) != 0
def run():
# To allow the model to be run multiple times with differing variables, without closing down the window, the agents and environment need to be cleared.
# Otherwise, the agents will be appened with the new value, meaning there will be more agents than actually appear, so they wouldn't move correctly.
agents.clear()
#environment.clear()
global environment
environment = import_csv()
# Gets the three user defined values from the GUI spinboxes.
global num_of_iterations
num_of_iterations = int(noit.get())
print("Iterations = " + noit.get())
global num_of_agents
num_of_agents = int(noag.get())
print("Agents = " + noag.get())
global neighbourhood
neighbourhood = int(neigh.get())
print("Neighbourhood = " + neigh.get())
# Make the agents with x/y values from the web scraped data
for i in range(num_of_agents):
y = int(td_ys[i].text)
x = int(td_xs[i].text)
# Generating a 6 digit hexidecimal number to assign a colour to each agent.
# Without this, the colour of each agent changes because of random.shuffle in the update function.
hex_number = '#{:02x}{:02x}{:02x}'.format(
*map(lambda x: random.randint(0, 255), range(3)))
agents.append(
agentframework.Agent(environment, agents, x, y, hex_number))
# global animation
animation = matplotlib.animation.FuncAnimation(fig,
update,
frames=gen_function,
repeat=False)
print("2", len(agents))
canvas.draw()
def _create_agents(self):
"""
Generate new set of agents using the current model parameters
Returns
-------
None.
"""
# Reset the current agents list
self.agents = []
# Get the initial start positions
start_xs, start_ys = self.start_positions
# Create all agents
for i in range(self.num_of_agents):
# Get the initial start position
y = int(start_ys[i].text if len(start_ys) > i else random.
randint(0, self.environment.y_length - 1))
x = int(start_xs[i].text if len(start_xs) > i else random.
randint(0, self.environment.x_length - 1))
# Add new Agent to the model
self.agents.append(
agentframework.Agent(self.environment, self.agents, y, x,
self.agent_store_size,
self.agent_bite_size))
def setup_agents():
'''
Function to set up Class Agent (sheep) and Class Dogs (sheepdogs) using values from GUI sliders
Initalise sheep and sheepdogs into the agentframework
Returns:
if uncommented, prints number of sheep and number of wolves, as selected on GUI slider
'''
global num_of_agents # global variable defining number of sheep updated by value on GUI slider
global num_of_dogs # global variable defining number of sheepdogs updated by value on GUI slider
num_of_agents = slide1.get()
num_of_dogs = slide2.get()
print('Total number of Agents (sheep):', num_of_agents)
print('Total number of sheepdogs:', num_of_dogs)
# Make the sheep
for i in range(num_of_agents):
agents.append(agentframework.Agent(environment, agents, dogs))
# print('agents:', agents[i])
# # check sheep can return info about a different sheep
# print('Agent 6 from agent 1 point of view', agents[1].agents[6].x)
# Make the sheep dogs
for i in range(num_of_dogs):
y = int(td_ys[i].text) # integer obtained from html file
x = int(td_xs[i].text) # integer obtained from html file
dogs.append(agentframework.Dog(environment, agents, dogs, y, x))
def update(frame_number): # Module for creating animation
fig.clear()
# Make the agents.
for i in range(num_of_agents): # Repeat for number of agents
y = int(
td_ys[i].text) # Extracts the y value from the rest of the text
x = int(
td_xs[i].text) # Extracts the x value from the rest of the text
agents.append(agentframework.Agent(
agents, environment, y,
x)) # Pass arguments to module and return result into a
# Move the agents.
for j in range(num_of_iterations): # For each entry do...
for i in range(num_of_agents): # For each entry do...
agents[i].move() # Move the agent
agents[i].eat() # Eat the agent
agents[i].share_with_neighbours(neighbourhood)
# Plot points
matplotlib.pyplot.xlim(0, int(max(
environment[1]))) # Set the extent of the Y axis
matplotlib.pyplot.ylim(0, int(max(
environment[0]))) # Set the extent of the X axis
matplotlib.pyplot.imshow(environment)
for i in range(num_of_agents):
matplotlib.pyplot.scatter(agents[i].x, agents[i].y)
def test_distance_between():
"""
Testing the "distance_between()" function by adding two agents to the
"agents_list" and then ensuring that there is a distance between the first
and second agent, whereas there is no distance between the second agent and
itself.
"""
environment = [[2, 2], [2, 2]]
agents_list = []
agents_list.append(agentframework.Agent(environment, agents_list, 0, 0))
agents_list.append(agentframework.Agent(environment, agents_list, 0, 1))
assert agents_list[0].distance_between(
agents_list[1]) == 1, "There is a distance!"
assert agents_list[1].distance_between(
agents_list[1]) == 0, "There is no distance!"
def create_agents(num_agents):
agents = []
for i in range(num_agents):
if i < len(td_ys):
y = int(td_ys[i].text)
x = int(td_xs[i].text)
agents.append(
ag.Agent(environment_initial, agents, y_value=y, x_value=x))
else: #add random agents if data too small.
agents.append(ag.Agent(environment_initial, agents))
#check if there is enough data for all the agents, if not warn user of random coordinates:
if num_agents > len(td_xs):
print(
'Warning : The number of agents exeeds the ' + str(len(td_xs)) +
' available coordinates in sourced data. Random coordinates were allocated to '
+ str(num_agents - len(td_xs)) + ' agents.')
return (agents)
def sel():
global num_of_agents
num_of_agents = agentslider.get() #This allows the number of agents to be defined by the slider on the GUI interface
#Creating agent loop#
for i in range(num_of_agents):
y = int(td_ys[i].text)
x = int(td_xs[i].text)
agents.append(agentframework.Agent(environment, agents, y, x))
def run():
"""Reads in parameters from silders and checkboxes and initiates the animation to be plotted."""
# initialise
global num_agents
global max_age
global optimised_movement
global breed
global min_age_for_preg
global preg_duration
global agents
# makes the button reusable
global carry_on
carry_on = True
# re-import the clean environment for every run of the simulation
global environment
environment = import_environment()
# read in simulation parameters from the GUI widgets
optimised_movement = opt_var.get()
breed = babies_var.get()
max_age = max_age_slider.get()
min_age_for_preg = min_preg_age_slider.get()
preg_duration = preg_duration_slider.get()
num_agents = n_slider.get()
# create initial list of agents
agents = []
for _ in range(num_agents):
agents.append(af.Agent(environment,agents))
# print parameters to console
print(
'\n#### Run started with parameters:\n\
{} agents\n\
{} max age\n\
{} movement\n\
{} breeding\n\
{} minimum age for pregnancy\n\
{} duration of pregnancy\n'\
.format(
num_agents,
max_age,
('Optimised' if optimised_movement else 'Random'),
('Enabled' if breed else 'Disabled'),
min_age_for_preg,
preg_duration
)
)
# run animation
animation = anim.FuncAnimation(fig, update, frames=gen_function, repeat=False)
# and place it into the GUI
anim_placeholder.draw()
def run():
for i in range(num_of_agents):
agents.append(agentframework.Agent(random.randint(0,yrange)\
, random.randint(0,xrange), environment, agents, neighbourhood))
animation = matplotlib.animation.FuncAnimation(fig,
update,
frames=gen_function,
interval=1,
repeat=False)
canvas.draw()
def update(frame_number):
fig.clear()
global carry_on
# Omnivorous move, eat and share.
for j in range(num_of_iterations):
for i in range(num_of_agents):
agents[i].move()
agents[i].eat()
agents[i].share_with_neighbours(neighbourhood)
# Vegetarians move and convinced omnivorous to be vegetarians.
for j in range(num_of_iterations):
for l in range(num_of_agents2):
agents2[l].move()
a_chased = agents2[l].chase(ep_area, agents)
for k in a_chased:
chased.append(agentframework.Agent(environment, agents))
agents.remove(k)
#Setting the Stopping condition
#when there is iqual o more number of omnivorous transformed in vegetarians
if (len(agents2) == len(chased)) | (len(agents2) < len(chased)):
carry_on = False
print("stopping condition")
#Animation
#Displaying environment data
pyp.xlim(0, 100)
pyp.ylim(0, 100)
pyp.imshow(environment)
for a in agents:
pyp.scatter(a.x, a.y, c="red", marker="+")
#print(a.x,a.y)
for b in agents2:
pyp.scatter(b.x, b.y, c="green", marker="D")
#print(b.x,b.y)
#Print converted vegetarians
for c in chased:
pyp.scatter(c.x, c.y, c="blue", marker="d")
def update(frame_number):
fig.clear()
for i in range(num_of_agents):
agents.append(agentframework.Agent(environment,agents))
# Move and eat agents with every move or iteration.
for j in range(num_of_iterations):
for i in range(num_of_agents):
agents[i].move()
agents[i].eat()
agents[i].share_with_neighbours(neighbourhood)
# Loop through the agents in self.agents .
# Calculate the distance between self and the current other agent:
# distance = self.distance_between(agent)
# If distance is less than or equal to the neighbourhood
# Sum self.store and agent.store .
# Divide sum by two to calculate average.
# self.store = average
# agent.store = average
# End if
# End loop
# plot
matplotlib.pyplot.xlim(0, 299)
matplotlib.pyplot.ylim(0, 299)
for i in range(num_of_agents):
matplotlib.pyplot.scatter(agents[i].x,agents[i].y)
matplotlib.pyplot.imshow(environment)
def makeAgents(num_of_agents):
agentslist = []
# Initialisation - Make the agents.
for i in range(num_of_agents):
y = int(td_xs[i].text)
x = int(td_ys[i].text)
agents.append(agentframework.Agent(y, x, environment, agentslist))
# List of agents
for i in range(num_of_agents):
agentslist = (agents[i].y, agents[i].x)
#Test that agents are returning other agents positions
print(agents[2], agentslist)
# Total number of agents check
num_of_agents = len(agents)
print("num_of_agents", num_of_agents)
# Print out agents
for i in range(num_of_agents):
print(agents[i])
def sel():
global num_of_agents
global td_ys
global td_xs
global agents
global wolf_agents
num_of_agents = w.get()
# Pass in agents from web scrape, environment variable (and self as always).
for i in range(num_of_agents):
y = int(td_ys[i].text)
x = int(td_xs[i].text)
#print(x, y)
agents.append(agentframework.Agent(environment, agents, y, x))
for i in range(num_of_agents):
y = random.randint(0,100)
x = random.randint(0,100)
#print(x, y)
wolf_agents.append(agentframework.wolf_agent(environment, wolf_agents, agents, y, x))
def update(frame_number): # Module for creating animation
fig.clear()
# global carry_on
# Make the agents.
for i in range(num_of_agents): # Repeat for number of agents
a = agentframework.Agent(
agents,
environment) # Pass arguments to module and return result into a
agents.append(a) # Apend a to end of List
# Move the agents.
for j in range(num_of_iterations):
for i in range(num_of_agents):
agents[i].move()
agents[i].eat()
agents[i].share_with_neighbours(neighbourhood)
#def gen_function(b = [0]):
# a = 0
# global carry_on #Not actually needed as we're not assigning, but clearer
# while (a < 10) & (carry_on) :
# yield a # Returns control and waits next call.
# a = a + 1
#Plot points
# maxy = int(max(environment[1])) # Get maximum value of Y
# maxx = int(max(environment[0])) # Get maximum value of x
matplotlib.pyplot.xlim(0, int(max(
environment[1]))) # Set the extent of the Y axis
matplotlib.pyplot.ylim(0, int(max(
environment[0]))) # Set the extent of the X axis
matplotlib.pyplot.imshow(environment)
for i in range(num_of_agents):
matplotlib.pyplot.scatter(agents[i].x, agents[i].y)
def update(frame_number):
fig.clear()
global carry_on
#Reads in the data file with environment data.
f = open("in.txt", newline='') # Opens file in.txt.
reader = csv.reader(f, quoting=csv.QUOTE_NONNUMERIC) #Reader
for row in reader: #list of rows
rowlist = []
environment.append(rowlist)
for value in row: #list of values.
rowlist.append(value)
#f.close() #Closes in.txt file after processing.
# Sets up agents with environment data,y and x.
for i in range(num_of_agents):
y = int(td_ys[i].text)
x = int(td_xs[i].text)
agents.append(agentframework.Agent(environment, agents, y, x))
#Print (y)
#Print (x)
#Agent random walk,eat,share using loop.
for j in range(num_of_iterations):
for i in range(num_of_agents):
random.shuffle(agents)
agents[i].move()
agents[i].eat()
agents[i].share_with_neighbours(neighbourhood)
#Random stop model for model.
if random.random() < 0.1:
carry_on = False
print("stopping condition")
matplotlib.pyplot.xlim(0, 99)
matplotlib.pyplot.ylim(0, 99)
matplotlib.pyplot.imshow(environment)
for i in range(num_of_agents):
matplotlib.pyplot.scatter(agents[i].x, agents[i].y)
def initialise_agents(num_of_agents, environment):
"""
Create our agents.
Parameters
----------
environment : 2D list
Represents the environment of our agents. Number of rows must equal
the number of columns (square matrix).
size : int
Size/dimension of 2D list.
Returns
-------
agents : list of Agent()
List of Agent() class.
"""
agents = []
# Make the agents.
for i in range(num_of_agents):
agents.append(agentframework.Agent(environment, agents))
return agents
def setup():
#this is done to allow for connection with scale bar
global num_of_agents
#global allows to be seen outside of def function, agents=sheep
num_of_agents = scale_sheep.get()
#number of agents, connecting with scale bar
global num_of_wolves
#number of wolves
num_of_wolves = scale_wolves.get()
#set number of wolves
global wolves
#make wolves global
wolves = []
#makes wolves list
global agents
#makes agents global
agents = []
# Make the agents list
for i in range(num_of_agents):
#setting x y for sheep
y = int(td_ys[i].text)
#grabing text from html
x = int(td_xs[i].text)
#grabing text from html
agents.append(agentframework.Agent(environment, agents, wolves, x, y))
#connects agents to the environment, and grabs from framework
#print(agents[i])
for i in range(num_of_wolves):
#seeting up num of wolves
x = random.randint(150, 199)
#seting wolves random starting x coordinate
y = random.randint(0, 50)
#setting agents random y starting points
wolves.append(agentframework.Wolf(environment, wolves, agents, x, y))
def update(frame_number):
fig.clear()
global carry_on
#Fill the agents list.
for i in range(num_of_agents):
agents.append(agentframework.Agent(environment, agents))
#Shuffle the order in which we look through our agents. Move the agents, make them eat the environment and share food collected with their neighbours.
for j in range(num_of_iterations):
for i in range(num_of_agents):
shuffle(agents)
agents[i].move()
agents[i].eat()
agents[i].share_with_neighbours(neighbourhood)
#Ensure that if the agent eats more than 90 food then the model stops.
if object1.agent_eats > 90:
carry_on = False
print("stopping condition")
#Plot the model linking the agents and placing them on the environment to interact with it.
matplotlib.pyplot.xlim(0, 99)
matplotlib.pyplot.ylim(0, 99)
matplotlib.pyplot.imshow(environment)
for i in range(num_of_agents):
matplotlib.pyplot.scatter(agents[i].x, agents[i].y)
import matplotlib.pyplot
import agentframework
def distance_between(agents_row_a, agents_row_b):
return (((agents_row_a.x - agents_row_b.x)**2) +
((agents_row_a.y - agents_row_b.y)**2))**0.5
num_of_agents = 10
num_of_iterations = 100
agents = []
# Make the agents.
for i in range(num_of_agents):
agents.append(agentframework.Agent())
# Move the agents.
for j in range(num_of_iterations):
for i in range(num_of_agents):
agents[i].move() # uses the move method from class Agents.
matplotlib.pyplot.xlim(0, 99)
matplotlib.pyplot.ylim(0, 99)
for i in range(num_of_agents):
matplotlib.pyplot.scatter(
agents[i].x,
agents[i].y) # as in line 7 and 8 pulls from Agents class.
matplotlib.pyplot.show()
for agents_row_a in agents:
# Create the environments list by reading data from a text file.
# Used the csv import to parse the text file as it is comma seperated.
with open("assets/in.txt") as f:
reader = csv.reader(f, quoting=csv.QUOTE_NONNUMERIC)
for row in reader:
rowlist = []
for value in row:
rowlist.append(value)
environment.append(rowlist)
# Create the agents list with the environment
for i in range(num_of_agents):
agents.append(agentframework.Agent(environment))
# Move the agents.
for j in range(num_of_iterations):
for i in range(num_of_agents):
agents[i].move()
agents[i].eat()
# Plot the agents
matplotlib.pyplot.xlim(0, 99)
matplotlib.pyplot.ylim(0, 99)
matplotlib.pyplot.imshow(environment)
for i in range(num_of_agents):
matplotlib.pyplot.scatter(agents[i]._x, agents[i]._y)
f.close() # Don't close until you are done with the reader;
# the data is read on request.
# Parameters
agents = []
num_of_agents = 25
num_of_iterations = 15
neighbourhood = 20
# Plotting settings?
fig = matplotlib.pyplot.figure(figsize=(7, 7))
ax = fig.add_axes([0, 0, 1, 1])
# creating agents in a container
for i in range(num_of_agents):
agents.append(agentframework.Agent(environment, agents, neighbourhood))
#Movement, eating and sharing
# Defining a function to be called in the animation commando further below
def update(frame_number):
fig.clear()
for j in range(num_of_agents):
random.shuffle(agents) # Shuffles the list in every new iteration
for i in range(num_of_iterations):
agents[j].move()
agents[j].eat()
agents[j].share_with_neighbours(neighbourhood)
num_of_iterations = 10
#Agents object
agents = []
#Create a neighbourhood for each agent, this is 20 units distance
neighbourhood = 20
"""Create the agents"""
#For-Loop to append the agents to move randomly within the environment
#ranging from 0 to 99
print("Create Agents")
#Print the co-ordinates for the agents with co-ordinates from data.html
for i in range(num_of_agents):
y = int(td_ys[i].text) #make td_ys into integer data
x = int(td_xs[i].text) #make td_xs into integer data
agents.append(agentframework.Agent(i, environment, agents, x, y))
print(i) #prints number of agents from data.html minus 1
i = i + 1
#Below prints co-ordinates for an agent with known co-ordinates
agents.append(agentframework.Agent(i, environment, agents, 50, 50))
i = i + 1
#Below prints co-ordinates for another agent with known co-ordinates
agents.append(agentframework.Agent(i, environment, agents, 51, 51))
print("num_of_agents", num_of_agents) #prints agents with co-ordinates from
#data.html
num_of_agents = len(agents)
print("num_of_agents", num_of_agents) #prints total number of agents
for i in range(num_of_agents):
print("Agent Starting co-ordinates, and store value")
def update(frame_number):
"""Determines the code that should be run for each frame of the matplotlib animation.
Return:
None
"""
fig.clear()
global carry_on
# Loops for running the behaviour and interactions of the agents.
# Print statements used for testing.
for j in range(num_of_iterations):
# Shuffle function used to randomise the order sheep are processed with each iteration.
random.shuffle(sheep)
print("Number of sheep is " + str(len(sheep)))
# Interactions if more than 1 sheep.
if len(sheep) > 1:
for i in range(len(sheep) - 1):
sheep[i].move()
sheep[i].eat()
sheep[i].share_with_neighbours(neighbourhood)
sheep[i].lambing(lamb_distance)
if sheep[i].lambing(lamb_distance) == "Lamb":
sheep.append(agentframework.Agent(environment, sheep))
print("Sheep added")
print(len(sheep))
print("Sheep moved")
# Wolf movements and interactions.
for k in range(num_of_wolves):
wolves[k].move()
wolves[k].hunting(hunting_distance, sheep)
if wolves[k].hunting(hunting_distance, sheep) == "Hunted":
del (sheep[0])
print("Sheep eaten")
print(len(sheep))
# Stopping condition for animation if all sheep are eaten.
if len(sheep) == 0:
carry_on = False
print("All sheep have been eaten")
break
# Stopping condition for animation if number of sheep is greater than or equal to 100.
if len(sheep) >= 100:
carry_on = False
print("100 or more sheep in the field!")
break
else:
for i in range(1):
sheep[i].move()
sheep[i].eat()
# Wolf movements and interactions.
for k in range(num_of_wolves):
wolves[k].move()
wolves[k].hunting(hunting_distance, sheep)
if wolves[k].hunting(hunting_distance, sheep) == "Hunted":
del (sheep[0])
print("Sheep eaten")
print(len(sheep))
# Stopping condition for animation if all sheep are eaten.
if len(sheep) == 0:
carry_on = False
print("All sheep have been eaten")
break
break
break
# Generate scatterplot of sheep and wolves after model iterations.
matplotlib.pyplot.xlim(0, 99)
matplotlib.pyplot.ylim(0, 99)
for i in range(len(sheep)):
matplotlib.pyplot.scatter(sheep[i].x, sheep[i].y, color='white')
matplotlib.pyplot.imshow(environment)
for j in range(num_of_wolves):
matplotlib.pyplot.scatter(wolves[j].x, wolves[j].y, color='black')
matplotlib.pyplot.imshow(environment)
lamb_distance = 8
hunting_distance = 10
sheep = []
wolves = []
# Variables to create the matplotlib window for the animation.
fig = matplotlib.pyplot.figure(figsize=(7, 7))
ax = fig.add_axes([0, 0, 1, 1])
ax.set_autoscale_on(False)
# Make the agents.
# Addition of environment as argument for Agent class to allow interaction between agents and environment.
# Addition of agents as argument for Agent class to allow agents to interact with each other.
for i in range(num_of_sheep):
sheep.append(agentframework.Agent(environment, sheep))
# Make the wolves.
# Use of environment and agents as arguments to allow interactions.
for i in range(num_of_wolves):
wolves.append(agentframework.Wolves(environment, sheep, wolves))
# Setting carry_on variable for gen_function below.
carry_on = True
# Creating model animation.
def update(frame_number):
"""Determines the code that should be run for each frame of the matplotlib animation.
Return:
random_seed = 50
neighbourhood = 20
#controlling how many agents there are:
num_of_agents = 10
#specify the number of times the agents are to be moved:
num_of_iterations = 100
#create list "agents":
agents = []
#make agents a random integer between inc 0 and 99 and add them to the list of agents
#takes agents created in "agentframework" module
#puts y and x coordinates in list "agents"
for i in range(num_of_agents):
random_seed += 1
agents.append(
agentframework.Agent(random_seed, environment, neighbourhood, agents))
#print("agents created in framework and stored in agents list; number of agents created is determined by value assigned to num_of_agents:")
#print(agents[i])
#move the agents num_of_iterations times. "% 100" in "agentframework" creates torus environment, creating boundary to prevent agents leaving the space
for j in range(num_of_iterations):
for i in range(num_of_agents):
agents[i].move()
agents[i].eat()
print("randomly moved the agents num_of_iterations times:")
#print(agents)
#call eat for each agent
for j in range(num_of_iterations):
random.shuffle(agents)
for i in range(num_of_agents):
# Read in the environment
reader = csv.reader(f, quoting=csv.QUOTE_NONNUMERIC)
# Shift environment into a 2.D list
for row in reader:
rowlist = []
# Add each value to rowlist
for value in row:
rowlist.append(value)
# Attach rowlist to environment
environment.append(rowlist)
# Close the file
f.close()
# Create a line of code to convince self that agentframeowrk file is connected
a = agentframework.Agent(environment, agents)
# print(a.x, a.y)
#Loop through and create the agents and append information about environment and other agents
# Make the agents.
for i in range(num_of_agents):
agents.append(agentframework.Agent(environment, agents))
# Animating the model
# Create the update function
def update(frame_number):
fig.clear() # Clear figure
global carry_on
# Constructs the GUI slider.
def setup_agents():
"""The number of Sheep and Foxes in the environment are chosen by operating the slider."""
global num_of_agents # Global variable defines number of Sheep as selected using the slider.
global num_of_foxes # Global variable defines number of Foxes as selected using the slider.
num_of_agents = sheepslider.get()
num_of_foxes = foxesslider.get()
print('Total Sheep chosen:',
num_of_agents) # Prints total number of Sheep as selected.
print('Total Foxes chosen:',
num_of_foxes) # Prints total number of Foxes as selected.
# Initialise Agent (Sheep) Loop.
for i in range(num_of_agents):
agents.append(agentframework.Agent(environment, agents, foxes))
#print('Agents:',agents[i]) # Prints to ensure Sheep xy coordinates are being generated.
# Initialise Foxes Loop against html-derived coordinates.
for i in range(num_of_foxes):
y = int(td_ys[i].text
) # Foxes move according to the xy coordinates from the html file.
x = int(td_xs[i].text)
foxes.append(agentframework.Foxes(environment, agents, foxes, x, y))
#print('Foxes:',foxes[i]) # Prints to ensure Foxes xy coordinates are being generated.
# Agents (Sheep) move if the above specifications work.
carry_on = True # A Boolean value; the animation carries on running unless told otherwise.
def distance_between(agents_row_a, agents_row_b):
rowlist = []
for value in row:
rowlist.append(value)
environment.append(rowlist) #add data to the environment iterable
### INITIALISE MODEL AND CHANGE FUNCTIONS ###
# initialise the agents
for i in range(num_of_agents):
#set the x and y coordinates from the web scraped daa
y = int(td_ys[i].text)
x = int(td_xs[i].text)
#give the agent environment, coordinates and add to list of agents
agents.append(agentframework.Agent(environment, agents, y, x))
def update(frame_number):
"""
Function to to move and interact agents with environment for each frame update
"""
fig.clear()
global carry_on
global storeMax
#This creates a loop to access each individual agent
for i in range(num_of_agents):
# Move the agents, consume the environment and share with other agents
Number
Euclidean distance in a 2D space between a and b.
"""
return (((a.x - b.x)**2) + ((a.y - b.y)**2))**0.5
# Initialise variables
num_of_agents = 10
num_of_iterations = 100
neighbourhood = 20
# Make the agents.
agents = []
for i in range(num_of_agents):
agents.append(
agentframework.Agent(i, random.randint(0, 99), random.randint(0, 99),
environment, agents))
#print(agents[i]) # Check the agents are created
print("Initial agents")
for i in range(num_of_agents):
print(agents[i])
## Test the distance function
#d = distance_between(agentframework.Agent(0, 0, environment, agents),
#agentframework.Agent(3, 4, environment, agents))
#print(d)
# Move the agents.
for j in range(num_of_iterations):
for i in range(num_of_agents):
agents[i].move() # uses the move method from class Agent.
agents[i].eat() # uses the eat method in Agent class.
