def __init__(self, screen, snake_sleep, quit_page, game_type):
self.screen = screen
self.snake_sleep = snake_sleep
self.quit_page = quit_page
self.draw_area = DrawArea(screen)
self.players = []
self.map0 = { curses.KEY_UP : 3,
curses.KEY_LEFT : 4,
curses.KEY_DOWN : 1,
curses.KEY_RIGHT : 2}
self.player0 = Player(self.draw_area.width / 4,self.draw_area.height / 2, 3, 5, self.map0,self.draw_area,True)
self.player0.add_to_obstacles(self.player0.snake)
self.egg = Egg(self.draw_area, 9, 9)
self.player0.add_to_food(self.egg)
if game_type != 1:
self.map1 = { ord('w') : 3,
ord('a') : 4,
ord('s') : 1,
ord('d') : 2}
self.player1 = Player(9, 9, 1, 5, self.map1, self.draw_area,False)
self.player1.add_to_obstacles(self.player0.snake)
self.player1.add_to_obstacles(self.player1.snake)
self.player1.add_to_food(self.egg)
self.player0.add_to_obstacles(self.player1.snake)
self.game_type = game_type
def egg_generate(egg_size):
egg_start_pos = [
random.randint(0, gv.display_width),
random.randint(0, gv.display_height)
]
# egg_start_pos = [int(gv.display_width/2), int(gv.display_height/2)]
return Egg.Egg(egg_size, egg_start_pos)
def layeggs(self, batchsize) -> None:
# Adds normal distribution with avgeggbatch mean number of eggs to the model or fixed number from avgeggbatch
# TODO: Optimize by doing total survival calc in one go
for i in range(batchsize):
# Each offspring has same starting location as egg-laying location
a = Egg.Egg(self.model.getid(), self.model)
self.model.schedule.add(a)
self.model.grid.place_agent(a, self.pos)
def __init__(self,
NumMidges,
NumDeer,
width=100,
height=100,
mapfile=None,
trapfile=None,
dps=0.5):
Midge.Midge.setdps(dps)
Midge.Midge.createdpsarray(dps)
self.NumMidges = NumMidges # Starting number of midges
self.NumDeer = NumDeer # Starting number of deer
self.idcounter = 0 # Global counter for id of agents, increments with every new agent creation
self.mapfile = mapfile # Argument passed to decide on which map data to use (must be in CSV format)
self.trapfile = trapfile # File used to decide where the traps will be placed, used to replicate data in paper
self.running = True # Used for running model in batches
self.midges = [
] # List of all current midges, can set to update every step
self.traps = [] # List of all trap agents
self.deer = [] # List of all deer agents
self.dps = dps # Daily probability of survival for all midges
# Time (days) since simulation has begun
self.day = 0
# Activates the step function for midges sequentially (no order needed)
self.schedule = BaseScheduler(self)
# Create a grid model with potential for multiple agents on one cell
self.grid = ContinuousSpace(width, height, torus=False)
# Open the map file and create a csvreader object to be used by every midge
self.mapdata = open(self.mapfile, 'r')
self.csvreader = csv.reader(self.mapdata, delimiter=',')
# Create a blank map array filled with the generic 'lightgreen' value
self.maparray = np.full(shape=(width, height),
fill_value=BiomeCell.BiomeCell('lightgreen'),
dtype=BiomeCell.BiomeCell)
# Add all biome types from the mapfile to the map array
with open(self.mapfile, 'r', encoding='utf-8-sig') as csvfile:
csvreader = csv.reader(csvfile, delimiter=',')
for l in csvreader:
x, y = int(l[0]), int(l[1])
self.maparray[x][y] = BiomeCell.BiomeCell(l[2])
# # Adds midges to random location in grid and to queue in scheduler
for i in range(self.NumMidges):
x = self.random.random() * self.grid.width
y = self.random.random() * self.grid.height
a = Midge.Midge(self.getid(), self)
# Gives midges random probabilities of having fed and are in stages of gonotrophic cycle
a.fed = True
a.timesincefed = np.random.randint(0, Midge.Midge.gtrclength)
self.schedule.add(a)
self.grid.place_agent(a, (x, y))
# Adds some eggs to the simulation as well, just to even out the population variability
for i in range(10000):
x = self.random.random() * (self.grid.width)
y = self.random.random() * (self.grid.height)
a = Egg.Egg(self.getid(), self)
# Gives eggs random age
a.age = random.randint(-Egg.Egg.growthtime, Egg.Egg.growthtime)
self.schedule.add(a)
self.grid.place_agent(a, (x, y))
# # Adds traps to random locations in the grid from the trap location file and to the queue in scheduler
# with open(self.trapfile, 'r', encoding='utf-8-sig') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=',')
# for l in csvreader:
# x, y = int(l[0]), int(l[1])
# a = Trap.Trap(self.getid(), self)
# self.schedule.add(a)
# self.grid.place_agent(a, (x, y))
# Adds deer to random locations in the grid and to queue in scheduler
for i in range(self.NumDeer):
x = self.random.random() * (self.grid.width)
y = self.random.random() * (self.grid.height)
a = Deer.Deer(self.getid(), self)
self.schedule.add(a)
self.grid.place_agent(a, (x, y))
# Add 10 deer with BTV as a case study
for i in range(10):
a = Deer.Deer(self.getid(), self)
a.hasbtv = True
self.schedule.add(a)
self.grid.place_agent(a, (self.random.random() * self.grid.width,
self.random.random() * self.grid.height))
self.traps = [i for i in self.schedule.agents if type(i) == Trap.Trap
] # Fills list of traps (only once)
self.deer = [i for i in self.schedule.agents
if type(i) == Deer.Deer] # Fills list of deer (only once)
self.targets = np.array(
combinelists(self.traps, self.deer), dtype=Target.Target
) # Combines all subclasses of the target class into one list
self.deerbites = 0 # Global counter of the total number of deer bites
# TODO: Implement datacollector that can collect data from different agent types (gonna be a pain in my ass)
self.datacollector = DataCollector(
model_reporters={
"Day": "day",
"MidgePop": "NumMidges",
"DeerBites": "deerbites",
"DeerwBTV": "DeerwBTV",
"NumVectors": "NumVectors",
"DPS": "DPS",
"MidgeAges": "MidgeAges",
"AvgAge": "AvgAge"
})
class GamingPage:
def __init__(self, screen, snake_sleep, quit_page, game_type):
self.screen = screen
self.snake_sleep = snake_sleep
self.quit_page = quit_page
self.draw_area = DrawArea(screen)
self.players = []
self.map0 = { curses.KEY_UP : 3,
curses.KEY_LEFT : 4,
curses.KEY_DOWN : 1,
curses.KEY_RIGHT : 2}
self.player0 = Player(self.draw_area.width / 4,self.draw_area.height / 2, 3, 5, self.map0,self.draw_area,True)
self.player0.add_to_obstacles(self.player0.snake)
self.egg = Egg(self.draw_area, 9, 9)
self.player0.add_to_food(self.egg)
if game_type != 1:
self.map1 = { ord('w') : 3,
ord('a') : 4,
ord('s') : 1,
ord('d') : 2}
self.player1 = Player(9, 9, 1, 5, self.map1, self.draw_area,False)
self.player1.add_to_obstacles(self.player0.snake)
self.player1.add_to_obstacles(self.player1.snake)
self.player1.add_to_food(self.egg)
self.player0.add_to_obstacles(self.player1.snake)
self.game_type = game_type
#Get list of keys since last gameloop
def key_list(self):
key_list = []
switch = True
while switch:
key = self.screen.getch()
if key == curses.ERR:
switch = False
else:
key_list += [key]
return key_list
def AI(self):
if self.game_type != 1:
direction = self.player0.snake.direction()
egg_point_x = self.egg.position_x()
snake_point_x = self.player0.snake.position_x()
egg_point_y = self.egg.position_y()
snake_point_y = self.player0.snake.position_y()
screen_width = self.draw_area.width
wall_right = screen_width - snake_point_x + egg_point_x
plain_left = snake_point_x - egg_point_x
wall_left = snake_point_x + screen_width - egg_point_x
plain_right = egg_point_x - snake_point_x
screen_height = self.draw_area.height
wall_up = screen_height - snake_point_y + egg_point_y
plain_down = snake_point_y - egg_point_y
wall_down = snake_point_y + screen_height - egg_point_y
plain_up = egg_point_y - snake_point_y
if direction == 1 or 3:
if snake_point_x < egg_point_x:
if plain_right < wall_left:
return 2
else:
return 4
if snake_point_x > egg_point_x:
if plain_left < wall_right:
return 4
else:
return 2
if direction == 2 or 4:
if snake_point_y < egg_point_y:
if plain_up < wall_down:
return 3
else:
return 1
if snake_point_y > egg_point_y:
if plain_down < wall_up:
return 1
else:
return 3
return direction
def draw_loop(self):
while True:
# Check for user input
keys = self.key_list()
for key in keys:
if key == ord("r"):
return self.quit_page
if self.game_type != "Comp":
dir = self.player0.key_decode(keys)
elif self.game_type == "Comp":
dir = self.AI()
self.player0.snake.change_direction(dir)
self.draw_area.clear()
if self.game_type != 1:
dir = self.player1.key_decode(keys)
self.player1.snake.change_direction(dir)
self.player1.player_functions()
self.player0.player_functions()
self.egg.draw()
self.draw_area.paint_to_screen()
# wait
time.sleep(self.snake_sleep)
class Black_Box:
def __init__(self, M, h):
self.count = 0
self.M = M
self.h = h
# BEGIN SECRET
import random
black_box_secret1secret = Black_Box(M, random.randint(1, M))
# END SECRET
black_box_secret2secret = Black_Box(M, h)
# BEGIN SECRET
black_box_secret3secret = Black_Box(M, random.randint(1, M))
black_box_secret4secret = Black_Box(M, random.randint(1, M))
# END SECRET
# BEGIN SECRET
h ^= M
h ^= xorh
# END SECRET
rt = Egg.height_limit(M)
# BEGIN SECRET
print(output_secret)
h ^= xorh
h ^= M
# END SECRET
if rt != h:
wa("incorrect height")
else:
print("Accepted: " + str(black_box_secret2secret.count))
