In a previous post I constructed a simple agent-based simulation model, containing groups of agents that can be located on a battlefield grid. The model was coded in Python, using matplotlib for visualization.

The agents were modelled as a class, as shown below:

# class, defining agents as abstract data types class agent: # init-method, the constructor method for agents def __init__(self,x,y,group): self.life = 100 # agent's life score self.x = x self.y = y self.group = group

A 2-dimensional array for modelling the battlefield grid was created with a list comprehension in Python:

# creating empty 100 x 100 list using list comprehension in python battlefield = [[None for i in range(0,100)] for i in range(0,100)]

A helper function for creating a group of agents with defined group size was implemented as displayed below:

# -- define a function for creating agents and assigning them to grid def agentCreator(size,group,groupList,field,n,m): # loop through entire group, i.e. in this case 1000 units for j in range(0,size): # select random available location while True: # random x coordinate x = random.choice(range(0,n)) # random y coordinate y = random.choice(range(0,m)) # check if spot is available; if not then re-iterate if field[x][y] == None: field[x][y] = agent(x=x,y=y,group=group) # append agent object reference to group list groupList.append(field[x][y]) # exit while loop; spot on field is taken break

Using these model components I created an initial battlefield population and plotted agent locations using matplotlib. This is done in the code below:

# list with available x and y locations locations = battlefield.copy() # using .copy prevents copying by reference # create empty list for containing agent references in future, type A & B agents_A = [] agents_B = [] # assigning random spots to agents of group A and B; import random agentCreator(size = 1000, group = "A", groupList = agents_A, field = battlefield, n = 100, m = 100) agentCreator(size = 1000, group = "B", groupList = agents_B, field = battlefield, n = 100, m = 100) #.imshow() needs a matrix with float elements; population = [[0.0 for i in range(0,100)] for i in range(0,100)] # if agent is of type A, put a 1.0, if of type B, pyt a 2.0 for i in range(1,100): for j in range(1,100): if battlefield[i][j] == None: # empty pass # leave 0.0 in population cell elif battlefield[i][j].group == "A": # group A agents population[i][j] = 1.0 # 1.0 means "A" else: # group B agents population[i][j] = 2.0 # 2.0 means "B" # import pyplot and colors from matplotlib from matplotlib import pyplot, colors # using colors from matplotlib, define a color map colormap = colors.ListedColormap(["lightgrey","green","blue"]) # define figure size using pyplot pyplot.figure(figsize = (12,12)) # using pyplot add a title pyplot.title("battlefield before simulation run (green = A, blue = B)", fontsize = 24) # using pyplot add x and y labels pyplot.xlabel("x coordinates", fontsize = 20) pyplot.ylabel("y coordinates", fontsize = 20) # adjust x and y axis ticks, using pyplot pyplot.xticks(fontsize = 16) pyplot.yticks(fontsize = 16) # use .imshow() method from pyplot to visualize agent locations pyplot.imshow(X = population, cmap = colormap)

<matplotlib.image.AxesImage at 0x22495922ac8>

We can now conduct a simple simulation run which in later posts will turn into an experiment. For this we implement two attack strategies:

##### Group A has the strategy of always hitting the same agent in each round

##### Group B has a random and independent strategy for attacking enemies. This means that each agent of type B will attack a randomly selected enemy within that agent’s reach.

The simulation is now conducted under the following conditions:

##### 1) Each round is one iteration

##### 2) In each round, each agent can attack one agent within his reach

##### 3) The reach of an agent is defined at the start of the simulation and defaults to 10

##### 4) If an agent dies he will no longer be located on the battle field

##### 5) An agent dies when his life score equals or goes below zero

##### 6) Each agent has a randomly distributed attack damage, ranging from 10 to 60

##### 7) In each round all agents get to launch an attack

With these rules in place I will now iterate through 50 rounds of fighting. At the end I will print a plot of the remaining agents on the battlefield. The implementation follows below:

for counter in range(0,50): # in this case I am conducting 50 iterations # iterating through all cells on the battlefield for i in range(0,len(battlefield)): for j in range(0,len(battlefield)): #print("top tier iteration, i: "+str(i)+", j: "+str(j)) # check if there is an agent in the respective cell if battlefield[i][j] != None: # depending on the type: execute respective attack strategy if battlefield[i][j].group == "A": found_i = None found_j = None # look in neigbouring cells in same order for each iteration for k in range(i-10,i+11): for l in range(j-10,j+11): # check for negative index values; if so - break! if k < 0 or l < 0: break # check for index values above 99, if so break! if k > 99 or l > 99: break if battlefield[k][l]: if battlefield[k][l].group == "B": # then this is an enemy if found_i == None: found_i = k found_j = l # deal damage to identified enemy if found_i: battlefield[found_i][found_j].life = battlefield[found_i][found_j].life - random.randint(10,60) else: # first check if there even is an enemy in one of the surrounding cells enemy_found = False for k in range(i-10,i+11): for l in range(j-10,j+11): # check for negative index, if so break to next iteration if k < 0 or l < 0: break # check for index values above 99, if so break if k > 99 or l > 99: break if battlefield[k][l] != None: if battlefield[k][l].group == "A": enemy_found = True # select a random row and a random column found_i = None found_j = None while enemy_found and found_i == None: k = random.randint(i-10,i+10) l = random.randint(j-10,j+10) # check for negative index, if so continue to next iteration if k < 0 or l < 0: continue # check for index value > 99, if so continue if k > 99 or l > 99: continue if k != i: if battlefield[k][l]: if battlefield[k][l].group == "A": found_i = k found_j = l else: if l != j: if battlefield[k][l]: if battlefield[k][l].group == "A": found_i = k found_j = l # deal damage to identified enemy if found_i: battlefield[found_i][found_j].life = battlefield[found_i][found_j].life - random.randint(10,60) # identifying agents with life score of score or below - and removing them from the grid for i in range(0,len(battlefield)): for j in range(0,len(battlefield)): if battlefield[i][j]: if battlefield[i][j].life <= 0: battlefield[i][j] = None # producing a plot of all battlefield locations, 10 iterations after population = [[0.0 for i in range(0,100)] for i in range(0,100)] # if agent is of type A, put a 1.0, if of type B, pyt a 2.0 for i in range(1,100): for j in range(1,100): if battlefield[i][j] == None: # empty pass # leave 0.0 in population cell elif battlefield[i][j].group == "A": # group A agents population[i][j] = 1.0 # 1.0 means "A" else: # group B agents population[i][j] = 2.0 # 2.0 means "B" # import pyplot and colors from matplotlib from matplotlib import pyplot, colors # using colors from matplotlib, define a color map colormap = colors.ListedColormap(["lightgrey","green","blue"]) # define figure size using pyplot pyplot.figure(figsize = (12,12)) # using pyplot add a title pyplot.title("battlefield after 50 iterations (green = A, blue = B)", fontsize = 24) # using pyplot add x and y labels pyplot.xlabel("x coordinates", fontsize = 20) pyplot.ylabel("y coordinates", fontsize = 20) # adjust x and y axis ticks, using pyplot pyplot.xticks(fontsize = 16) pyplot.yticks(fontsize = 16) # use .imshow() method from pyplot to visualize agent locations pyplot.imshow(X = population, cmap = colormap)

<matplotlib.image.AxesImage at 0x22495be1848>

In some following posts I will clean the code and pack its functionality into re-usable functions. I will then conduct a more comprehensive simulation study in which various parameters are varied to investigate their impact on battle outcome.

In this example I used Python lists as my agent containers of choice. However, similar models can be constructed using e.g. NumPy arrays.

Data scientist focusing on simulation, optimization and modeling in R, SQL, VBA and Python

## Leave a Reply