class StartScene(Scene):
"""Start scene that welcomes the user.
Attributes
----------
font: pygame.font.Font
Font that is to be used in this scene
button: Button
Button object for the user to go to the next scene
background: Background
Background object to display another background
Methods
-------
render(screen)
Renders background, the button and the title
update()
Just to pass the superclass notimplemented error
handle_events(events)
When a key is pressed or the button is pressed will move to the next scene
"""
def __init__(self):
Scene.__init__(self)
self.font = pygame.font.Font("Images/Montserrat-ExtraBold.ttf", 38)
self.button = Button(font_size=21, w=349, center=True)
self.background = Background("Images/background.jpg", (0, 0))
def render(self, screen):
"""Renders background, the button and the title"""
self.background.render(screen)
self.button.render(screen, "Press any key or click to start")
title = self.font.render("Cooperative Agents in Multi-agent Systems",
True, (124, 124, 124))
shadow = pygame.Surface(title.get_size(), pygame.SRCALPHA)
shadow.fill((124, 124, 124, 100))
title.blit(shadow, (0, 0), special_flags=pygame.BLEND_RGBA_MULT)
screen.blit(title, (34, 125))
title = self.font.render("Cooperative Agents in Multi-agent Systems",
True, (226, 215, 215))
screen.blit(title, (31, 122))
def update(self):
"""Just to pass the superclass notimplemented error"""
pass
def handle_events(self, events):
"""When a key is pressed or the button is pressed will move to the next scene"""
Scene.handle_events(self, events)
for event in events:
self.button.handle_events(event)
if event.type == pygame.KEYDOWN:
self.manager.go_to(SelectAgentsScene())
if self.button.handle_events(event):
self.manager.go_to(SelectAgentsScene())
class PlayTournamentScene(Scene):
"""Scene where the user can see the simulation and interact with its objects.
Attributes
----------
font: pygame.font.Font
Font that is to be used in this scene
running: bool
Store if the simulation is running or not
was_running: bool
Store if the simulation was running or not
new_generation: bool
Store if the components is over or not
run: Tournament.start()
Method that initializes the components
UPDATE: pygame.USEREVENT
Event that will call the next step in the simulation
speed: int
speed of the simulation
blobs: dict
Dictionary of blobs to represent agents
agents: list
List of agents
playing_agents: list
List of playing agents
reset_button: Button
Button object to reset the game (return to the previous page)
speed_slider: Slider
Slider object to handle the simulation speed
message_box: MessageBox
MessageBox object to ask the user if they want to continue to the next components
Methods
-------
render(screen)
Renders the blobs, buttons, radio buttons, sliders, labels, and lines
update()
Updates the blobs status, messagebox, and slider
handle_events()
If the start button is pressed, starts the simulation; if the next button is pressed, gets the next round;
if the slider is changed, changes the speed; if the reset button is pressed, goes back to the select agents
scene; when the graph buttons are pressed, calls the plot_graph function
plot_graph(name, xs, ys, x_label, y_label, title)
Creates a Graph object, adds it to the list of graphs
"""
def __init__(self):
Scene.__init__(self)
size = pygame.display.get_window_size()
pygame.display.set_mode((size[0], size[1]), pygame.RESIZABLE)
self.font = pygame.font.Font("Images/Montserrat-Regular.ttf", 21)
self.font2 = pygame.font.Font("Images/Montserrat-Regular.ttf", 15)
self.font3 = pygame.font.Font("Images/Montserrat-ExtraBold.ttf", 15)
self.tournament = Tournament()
self.run = self.tournament.start()
self.agents = self.tournament.get_agents()
self.conductors = self.tournament.get_conductors()
self.blobs = dict()
self.playing_agents = None
self.running = False
self.was_running = False
self.new_generation = False
self.generation = self.tournament.generation
self.total_generations = self.tournament.total_generations
self.total_rounds = self.tournament.total_rounds
self.total_giving_encounters = self.tournament.total_giving_encounters
self.total_gossip_encounters = self.tournament.total_gossip_encounters
self.UPDATE = pygame.USEREVENT + 1
self.speed = 99
pygame.time.set_timer(self.UPDATE, self.speed, True)
self.tab = 0
self.home_tab = DropdownItem(pygame.Rect(18, 8, 47, 19),
0,
"Home",
underline=0,
font=15,
center=False)
self.info_tab = DropdownItem(pygame.Rect(89, 8, 29, 19),
1,
"Info",
underline=0,
font=15,
center=False)
self.reset_button = Button(w=90, pos=(16, 39), center=True)
self.start_stop_button = Button(w=80, pos=(130, 39), center=True)
self.next_button = Button(w=80, pos=(234, 39), center=True)
self.speed_label = self.font.render("Speed", True, (255, 255, 255))
self.speed_outside_im = pygame.image.load(
"Images/speedometer_outside.png")
self.speed_outside_im = pygame.transform.smoothscale(
self.speed_outside_im, (30, 30))
self.speed_inside_im = pygame.image.load(
"Images/speedometer_inside.png")
self.speed_inside_im = pygame.transform.smoothscale(
self.speed_inside_im, (15, 15))
self.speed_slider = Slider((465, 57), 240, fro=5, to=100)
self.message_box = MessageBox(400, 133)
self.shift = False
self.check_shift = True
self.max_shift = None
self.min_shift_x = None
self.min_shift_y = None
self.shift_x = 0
self.shift_y = 0
self.border = 0
self.zoom = 100
self.show_zoom = False
self.BACK_TO_NORMAL = pygame.USEREVENT + 2
self.min_zoom = 25
self.max_zoom = 400
self.simulation_size_w_padding = None
self.simulation_size_wo_padding = None
def render(self, screen):
"""Renders the blobs, buttons, radio buttons, labels and lines"""
Scene.render(self, screen)
pos1 = pos2 = None
if self.tournament.receiver_agent and self.tournament.giver_agent:
pos1 = self.blobs[self.tournament.receiver_agent].get_pos()
pos2 = self.blobs[self.tournament.giver_agent].get_pos()
if self.tournament.gossiping_agents:
pos1 = self.blobs[self.tournament.gossiping_agents[0]].get_pos()
pos2 = self.blobs[self.tournament.gossiping_agents[1]].get_pos()
render_after = []
for agent in self.blobs:
w, h = pygame.display.get_window_size()
if 0 - self.blobs[agent].radius / 2 < self.blobs[agent].get_pos(
)[0] < w + self.blobs[agent].radius / 2:
if 87 - self.blobs[agent].radius / 2 < self.blobs[
agent].get_pos()[1] < h + self.blobs[agent].radius / 2:
if self.blobs[agent].show_name:
render_after.append(agent)
if agent in [
self.tournament.giver_agent,
self.tournament.receiver_agent
]:
render_after.append(agent)
if agent in self.tournament.gossiping_agents:
render_after.append(agent)
self.blobs[agent].render(screen)
if pos1 and pos2:
color = (255, 255, 255)
if self.tournament.encounter_type == "Gossip":
if self.tournament.gossip:
color = (0, 0, 255)
else:
if self.tournament.cooperate is not None:
if self.tournament.cooperate:
color = (0, 255, 0)
else:
color = (255, 0, 0)
pygame.draw.aaline(screen,
color, (pos1[0] - 2, pos1[1]),
(pos2[0] - 2, pos2[1]),
blend=100)
pygame.draw.aaline(screen,
color, (pos1[0] - 1, pos1[1]),
(pos2[0] - 1, pos2[1]),
blend=100)
pygame.draw.aaline(screen, color, pos1, pos2, blend=100)
pygame.draw.aaline(screen,
color, (pos1[0], pos1[1] - 1),
(pos2[0], pos2[1] - 1),
blend=100)
pygame.draw.aaline(screen,
color, (pos1[0], pos1[1] - 2),
(pos2[0], pos2[1] - 2),
blend=100)
for ra in render_after:
self.blobs[ra].render(screen)
pygame.draw.rect(screen, (30, 30, 30), (0, 0, 100000, 85))
self.home_tab.render(screen)
self.info_tab.render(screen)
if self.tab == 0:
self.reset_button.render(screen, "Reset")
# self.prev_button.render(screen, "Prev")
if not self.running:
self.start_stop_button.render(screen, "Start")
else:
self.start_stop_button.render(screen, "Stop")
self.next_button.render(screen, "Next")
screen.blit(self.speed_label, (338, 42))
screen.blit(self.speed_outside_im, (412, 42))
speed_inside_im = rot_center(self.speed_inside_im,
-(abs(self.speed) * 2.7 - 135))
screen.blit(speed_inside_im, (419, 51))
self.speed_slider.render(screen)
speed_label = self.font.render(str(self.speed), True,
(255, 255, 255))
screen.blit(speed_label, (729, 44))
elif self.tab == 1:
generation_label = self.font2.render(
f"{self.tournament.generation} Generation / {self.total_generations} Generations",
True, (255, 255, 255))
screen.blit(generation_label, (16, 35))
round_label = self.font2.render(
f"{self.tournament.round} Round / {self.total_rounds} Rounds",
True, (255, 255, 255))
screen.blit(round_label, (407, 35))
giving_encounter_label = self.font2.render(
f"{self.tournament.giving_encounters} Giving Encounter / {self.total_giving_encounters} Rounds",
True, (255, 255, 255))
screen.blit(giving_encounter_label, (664, 35))
gossip_encounter_label = self.font2.render(
f"{self.tournament.gossip_encounters} Gossip Encounter / {self.total_gossip_encounters} Rounds",
True, (255, 255, 255))
screen.blit(gossip_encounter_label, (200, 58))
encounter_type_label = self.font2.render(
f"Encounter type: {self.tournament.encounter_type}", True,
(255, 255, 255))
screen.blit(encounter_type_label, (544, 58))
pygame.draw.line(screen, (247, 95, 23), (0, 85), (100000, 85), 2)
if self.show_zoom:
zoom_label = self.font3.render(f"Zoom: {self.zoom}%", True,
(255, 255, 255))
screen.blit(zoom_label, (840, 97))
if self.new_generation:
self.message_box.render(
screen, "Do you want to continue to a new tournament?")
def update(self):
"""Updates the blobs status, messagebox, and slider"""
self.agents = self.tournament.get_agents()
self.conductors = self.tournament.get_conductors()
if self.new_generation:
if self.message_box.ask_again:
self.message_box.show = True
else:
self.running = self.was_running
self.new_generation = False
self.message_box.show = False
self.message_box.answer = ""
self.blobs = dict()
if self.message_box.answer == "yes":
self.running = self.was_running
self.new_generation = False
self.message_box.show = False
self.message_box.answer = ""
self.blobs = dict()
elif self.message_box.answer == "":
pass
else:
pygame.quit()
exit(0)
else:
length = len(self.agents) + len(self.conductors)
size = (38, 18)
shift = 0
while length > size[0] * size[1]:
size = size[0] + 2, size[1] + 2
shift += 1
w = int(25 * self.zoom / 100)
self.border = shift * w
self.max_shift = (shift + 2) * w
self.simulation_size_w_padding = (size[0] + 2) * w, (size[1] +
2) * w
self.simulation_size_wo_padding = size[0] * w, size[1] * w
self.min_shift_x = -self.simulation_size_w_padding[
0] + 950 + shift * w
self.min_shift_y = -self.simulation_size_w_padding[
1] + 465 + shift * w
if self.blobs:
self.blobs[self.conductors[0]].update(shift=(self.shift_x,
self.shift_y),
zoom=self.zoom,
width=w)
for agent in self.agents:
if agent == self.tournament.giver_agent:
self.blobs[agent].update(giver=True,
shift=(self.shift_x,
self.shift_y),
zoom=self.zoom,
width=w)
continue
if agent == self.tournament.receiver_agent:
self.blobs[agent].update(receiver=True,
shift=(self.shift_x,
self.shift_y),
zoom=self.zoom,
width=w)
continue
if agent in self.tournament.gossiping_agents:
self.blobs[agent].update(gossiping=True,
shift=(self.shift_x,
self.shift_y),
zoom=self.zoom,
width=w)
continue
self.blobs[agent].update(shift=(self.shift_x,
self.shift_y),
zoom=self.zoom,
width=w)
else:
zoom = self.zoom
self.zoom = 100
w = int(25 * self.zoom / 100)
self.border = shift * w
self.max_shift = (shift + 2) * w
self.simulation_size_w_padding = (size[0] + 2) * w, (size[1] +
2) * w
self.simulation_size_wo_padding = size[0] * w, size[1] * w
self.min_shift_x = -self.simulation_size_w_padding[
0] + 950 + shift * w
self.min_shift_y = -self.simulation_size_w_padding[
1] + 465 + shift * w
self.min_zoom = int(465 / self.simulation_size_w_padding[1] *
100)
self.zoom = zoom
x = y = -shift
for agent in self.agents:
if x == int(size[0] / 2) - shift and y == int(
size[1] / 2) - shift:
self.blobs[self.conductors[0]] = Blob(
(x, y), w, 20, self.conductors[0], conductor=True)
x += 1
self.blobs[agent] = Blob((x, y), w, 20, agent, player=True)
x += 1
if x == size[0] - shift:
x = -shift
y += 1
self.speed_slider.update()
if int(self.speed_slider.number) != self.speed:
self.speed = int(self.speed_slider.number)
self.home_tab.update(self.tab == self.home_tab.index)
self.info_tab.update(self.tab == self.info_tab.index)
def handle_events(self, events):
"""If the start button is pressed, starts the simulation; if the next button is pressed, gets the next round;
if the slider is changed, changes the speed; if the reset button is pressed, goes back to the select agents
scene; when the graph buttons are pressed, calls the plot_graph function"""
Scene.handle_events(self, events)
for event in events:
if event.type == self.UPDATE:
pygame.time.set_timer(self.UPDATE, self.speed, True)
if self.running:
if next(self.run):
self.new_generation = True
self.was_running = self.running
self.running = False
if not self.message_box.handle_events(event):
for agent in self.blobs:
self.blobs[agent].handle_events(event)
if self.tab == 0:
self.speed_slider.handle_events(event)
if self.reset_button.handle_events(event):
self.manager.go_to(self.manager.previous)
if self.start_stop_button.handle_events(event):
self.running = not self.running
if self.next_button.handle_events(event):
if next(self.run):
self.new_generation = True
self.was_running = self.running
self.running = False
if self.check_shift:
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 2:
self.shift = True
if event.type == pygame.MOUSEBUTTONUP:
self.shift = False
if event.type == pygame.MOUSEMOTION:
if self.shift:
self.shift_x += event.rel[0]
self.shift_y += event.rel[1]
if self.shift_x < self.min_shift_x:
self.shift_x = self.min_shift_x
if self.shift_x > self.max_shift:
self.shift_x = self.max_shift
if self.shift_y < self.min_shift_y:
self.shift_y = self.min_shift_y
if self.shift_y > self.max_shift:
self.shift_y = self.max_shift
if event.type == pygame.MOUSEWHEEL:
self.check_shift = True
zoom = self.zoom
if event.y != 0:
if self.zoom <= 200:
self.zoom += 25 * event.y
else:
self.zoom += 100 * event.y
if self.zoom > self.max_zoom:
self.zoom = self.max_zoom
elif self.zoom <= self.min_zoom:
self.zoom = self.min_zoom
zoom = self.zoom
shift_x = int(
(950 - self.simulation_size_w_padding[0]) /
2) + self.max_shift
shift_y = int(
(465 - self.simulation_size_w_padding[1]) /
2) + self.max_shift
self.min_shift_x = shift_x - 1
self.max_shift = shift_x + 1
self.shift_x = shift_x
self.shift_y = shift_y
self.check_shift = False
if zoom != self.zoom:
mouse_pos = pygame.mouse.get_pos(
)[0], pygame.mouse.get_pos()[1] - 87
new_pos = mouse_pos[0] * self.zoom / 100, mouse_pos[
1] * self.zoom / 100
self.shift_x = int(mouse_pos[0] - new_pos[0])
self.shift_y = int(mouse_pos[1] - new_pos[1])
self.show_zoom = True
pygame.time.set_timer(self.BACK_TO_NORMAL, 600, True)
if event.type == self.BACK_TO_NORMAL:
self.show_zoom = False
if event.type == pygame.KEYDOWN:
if pygame.key.get_mods() and pygame.KMOD_ALT:
if event.key == pygame.K_h:
self.tab = self.home_tab.index
if event.key == pygame.K_i:
self.tab = self.info_tab.index
if event.key == pygame.K_SPACE:
self.running = not self.running
if event.key == pygame.K_RIGHT:
if next(self.run):
self.new_generation = True
self.was_running = self.running
self.running = False
if self.home_tab.handle_events(event):
self.tab = self.home_tab.index
if self.info_tab.handle_events(event):
self.tab = self.info_tab.index
class SelectAgentsScene(Scene):
"""Select agents scene where the user can select the amount of agents and number of rounds.
Attributes
----------
font: pygame.font.Font
Font that is to be used in this scene
tournament_manager: TournamentManager
TournamentManager that takes control of switching between tournaments.
dr_rb: RadioButton
Direct reciprocity radio button
ir_rb: RadioButton
Indirect reciprocity radio button
true_rb: RadioButton
Radio button for asking that agents having an option to chose if they want to play is true
false_rb: RadioButton
Radio button for asking that agents having an option to chose if they want to play is false
input_boxes: list [InputBox]
list of input boxes where the user enters the amount of agents they want
input_label: list [pygame.Surface]
list of labels for the input boxes
round_input_box: InputBox
input box to ask the user the number of rounds they want
start_button: Button
The button that will take the user to the playing screen
user_input: list
list that will store the values the user has chosen
selection: int
Stores the selection process the user chose
selection1_rb: RadioButton
First selection process radio button
selection2_rb: RadioButton
Second selection process radio button
Methods
-------
render(screen)
Renders the radio buttons for components selection, labels for description, input boxes to get the values, and
the button
update()
Update input box text, and radio buttons
get_user_input()
Gets user input from input boxes
handle_events(events)
Handles all the objects events, and when the button is pressed will move to the next scene
"""
def __init__(self):
Scene.__init__(self)
self.font = pygame.font.Font("Images/Montserrat-Regular.ttf", 21)
self.font2 = pygame.font.Font("Images/Montserrat-Regular.ttf", 15)
self.item = DropdownItem((100, 100), 1, "12345678")
self.player_label = self.font.render("Player Agent", True, (255, 255, 255))
self.gossip_type_list = ["Fair", "Selection 2", "Selection 3", "Selection 4", "Selection 5", "Selection 6"]
self.gossip_type_dropdown = Dropdown("Gossip Type", w=131, pos=(177, 16), selections=self.gossip_type_list)
self.discrimination_type_list = ["Cooperator", "Stern", "Defector", "Selection 4", "Selection 5", "Selection 6"]
self.discrimination_type_dropdown = Dropdown("Discrimination Type", w=193, pos=(334, 16), selections=self.discrimination_type_list)
self.discrimination_threshold_label = self.font2.render("Discrimination Threshold (-5 to 5.5):", True, (255, 255, 255))
self.discrimination_threshold_input = InputBox((833, 16), w=101, h=27, text="0.543", fro=-5, to=5.5, decimal=True, negative=True)
self.gossip_weight_label = self.font2.render("Gossip Weight (0 to 1):", True, (255, 255, 255))
self.gossip_weight_input = InputBox((196, 55), w=101, h=27, text="0.543", fro=0, to=1, decimal=True)
self.trust_criteria_label = self.font2.render("Trust Criteria (0 to 1):", True, (255, 255, 255))
self.trust_criteria_input = InputBox((521, 55), w=101, h=27, text="0.543", fro=0, to=1, decimal=True)
self.number_of_players_label = self.font2.render("Number of Players:", True, (255, 255, 255))
self.number_of_players_input = InputBox((833, 55), w=101, h=27, text="1000")
self.self_advertisement = True
self.self_advertisement_radio_label = self.font2.render("Self Advertisement:", True, (255, 255, 255))
self.self_advertisement_radio_yes_label = self.font2.render("Yes", True, (255, 255, 255))
self.self_advertisement_radio_yes = RadioButton((170 + 12, 100 + 12), on=True)
self.self_advertisement_radio_no_label = self.font2.render("No", True, (255, 255, 255))
self.self_advertisement_radio_no = RadioButton((231 + 12, 100 + 12), on=False)
self.self_advertisement_radio_no.bind(self.self_advertisement_radio_yes, self.change_self_advertisement)
self.add_button = Button(w=75, pos=(859, 92), center=True)
self.added = []
self.agents = []
self.agents2 = []
self.chips = []
self.scroll = HorizontalScroll(items=self.chips, pos=(16, 139))
self.conductor_label = self.font.render("Conductor Agent", True, (255, 255, 255))
self.number_of_conductors_label = self.font2.render("Number of Conductors:", True, (255, 255, 255))
self.number_of_conductors_input = InputBox((460, 221), w=101, h=27, text="1000")
self.number_of_rounds_label = self.font2.render("Total Number of Rounds:", True, (255, 255, 255))
self.number_of_rounds_input = InputBox((833, 221), w=101, h=27, text="1000")
self.giving_encounters_label = self.font2.render("Total Giving Encounters:", True, (255, 255, 255))
self.giving_encounters_input = InputBox((513, 260), w=101, h=27, text="1000")
self.gossip_encounters_label = self.font2.render("Total Giving Encounters:", True, (255, 255, 255))
self.gossip_encounters_input = InputBox((833, 260), w=101, h=27, text="1000")
self.starting_order = True
self.starting_order_radio_label = self.font2.render("Starting Order:", True, (255, 255, 255))
self.starting_order_radio_giving_label = self.font2.render("Giving", True, (255, 255, 255))
self.starting_order_radio_giving = RadioButton((131 + 12, 261 + 12), on=True)
self.starting_order_radio_gossip_label = self.font2.render("Gossip", True, (255, 255, 255))
self.starting_order_radio_gossip = RadioButton((215 + 12, 261 + 12), on=False)
self.starting_order_radio_gossip.bind(self.starting_order_radio_giving, self.change_starting_order)
self.events_file_name_label = self.font2.render("Events File Name:", True, (255, 255, 255))
self.events_file_name_input = InputBox((162, 326), w=236, h=27, text="example.event", file=True)
self.results_file_name_label = self.font2.render("Results File Name:", True, (255, 255, 255))
self.results_file_name_input = InputBox((162, 365), w=236, h=27, text="example.res", file=True)
self.benefit_cooperation_label = self.font2.render("Benefit of Cooperation:", True, (255, 255, 255))
self.benefit_cooperation_input = InputBox((607, 326), w=101, h=27, text="10")
self.cost_cooperation_label = self.font2.render("Cost of Cooperation:", True, (255, 255, 255))
self.cost_cooperation_input = InputBox((585, 365), w=101, h=27, text="10")
self.start_time_label = self.font2.render("Start Time:", True, (255, 255, 255))
self.start_time_input = InputBox((833, 365), w=101, h=27, text="10")
self.evolution_type_list = ["Cultural", "Genetic", "Selection 3", "Selection 4", "Selection 5", "Selection 6"]
self.evolution_type_dropdown = Dropdown("Evolution Type", w=157, pos=(777, 326), selections=self.evolution_type_list)
self.generation_range_label = self.font.render("Generation Range", True, (255, 255, 255))
self.min_generation_range_label = self.font2.render("Minimum Generation Range:", True, (255, 255, 255))
self.min_generation_range_input = InputBox((246, 468), w=101, h=27, text="-5", negative=True)
self.max_generation_range_label = self.font2.render("Maximum Generation Range:", True, (255, 255, 255))
self.max_generation_range_input = InputBox((246, 507), w=101, h=27, text="5")
self.image_score_range_label = self.font.render("Image Score Range", True, (255, 255, 255))
self.min_image_score_range_label = self.font2.render("Minimum Image Score:", True, (255, 255, 255))
self.min_image_score_range_input = InputBox((680, 468), w=101, h=27, text="-5", negative=True)
self.max_image_score_range_label = self.font2.render("Maximum Image Score:", True, (255, 255, 255))
self.max_image_score_range_input = InputBox((680, 507), w=101, h=27, text="5")
self.start_button = Button(w=80, pos=(854, 499), center=True)
def change_starting_order(self):
self.starting_order = not self.starting_order
def change_self_advertisement(self):
self.self_advertisement = not self.self_advertisement
def render(self, screen):
"""Renders the radio buttons for components selection, labels for description, input boxes to get the values,
and the button"""
Scene.render(self, screen)
screen.blit(self.player_label, (16, 16))
screen.blit(self.discrimination_threshold_label, (553, 20))
self.discrimination_threshold_input.render(screen)
screen.blit(self.gossip_weight_label, (19, 59))
self.gossip_weight_input.render(screen)
screen.blit(self.trust_criteria_label, (357, 59))
self.trust_criteria_input.render(screen)
screen.blit(self.number_of_players_label, (682, 59))
self.number_of_players_input.render(screen)
screen.blit(self.self_advertisement_radio_label, (19, 102))
screen.blit(self.self_advertisement_radio_yes_label, (198, 102))
self.self_advertisement_radio_yes.render(screen)
screen.blit(self.self_advertisement_radio_no_label, (259, 102))
self.self_advertisement_radio_no.render(screen)
self.add_button.render(screen, "Add")
self.scroll.render(screen)
pygame.draw.line(screen, (247, 95, 23), (16, 201), (934, 201), 5)
gfxdraw.filled_circle(screen, 16, 201, 2, (247, 95, 23))
gfxdraw.aacircle(screen, 16, 201, 2, (247, 95, 23))
gfxdraw.filled_circle(screen, 934, 201, 2, (247, 95, 23))
gfxdraw.aacircle(screen, 934, 201, 2, (247, 95, 23))
screen.blit(self.conductor_label, (16, 222))
screen.blit(self.number_of_conductors_label, (275, 225))
self.number_of_conductors_input.render(screen)
screen.blit(self.number_of_rounds_label, (638, 225))
self.number_of_rounds_input.render(screen)
screen.blit(self.giving_encounters_label, (322, 264))
self.giving_encounters_input.render(screen)
screen.blit(self.gossip_encounters_label, (642, 264))
self.gossip_encounters_input.render(screen)
screen.blit(self.starting_order_radio_label, (16, 263))
self.starting_order_radio_giving.render(screen)
screen.blit(self.starting_order_radio_giving_label, (159, 263))
self.starting_order_radio_gossip.render(screen)
screen.blit(self.starting_order_radio_gossip_label, (243, 263))
pygame.draw.line(screen, (247, 95, 23), (16, 306), (934, 306), 5)
gfxdraw.filled_circle(screen, 16, 306, 2, (247, 95, 23))
gfxdraw.aacircle(screen, 16, 306, 2, (247, 95, 23))
gfxdraw.filled_circle(screen, 934, 306, 2, (247, 95, 23))
gfxdraw.aacircle(screen, 934, 306, 2, (247, 95, 23))
screen.blit(self.events_file_name_label, (16, 330))
self.events_file_name_input.render(screen)
screen.blit(self.results_file_name_label, (16, 369))
self.results_file_name_input.render(screen)
screen.blit(self.benefit_cooperation_label, (425, 330))
self.benefit_cooperation_input.render(screen)
screen.blit(self.cost_cooperation_label, (425, 369))
self.cost_cooperation_input.render(screen)
screen.blit(self.start_time_label, (744, 369))
self.start_time_input.render(screen)
pygame.draw.line(screen, (247, 95, 23), (16, 411), (934, 411), 5)
gfxdraw.filled_circle(screen, 16, 411, 2, (247, 95, 23))
gfxdraw.aacircle(screen, 16, 411, 2, (247, 95, 23))
gfxdraw.filled_circle(screen, 934, 411, 2, (247, 95, 23))
gfxdraw.aacircle(screen, 934, 411, 2, (247, 95, 23))
screen.blit(self.generation_range_label, (16, 431))
screen.blit(self.min_generation_range_label, (16, 472))
self.min_generation_range_input.render(screen)
screen.blit(self.max_generation_range_label, (16, 511))
self.max_generation_range_input.render(screen)
pygame.draw.line(screen, (247, 95, 23), (421, 412), (421, 534), 5)
gfxdraw.filled_circle(screen, 421, 534, 2, (247, 95, 23))
gfxdraw.aacircle(screen, 421, 534, 2, (247, 95, 23))
screen.blit(self.image_score_range_label, (493, 431))
screen.blit(self.min_image_score_range_label, (493, 472))
self.min_image_score_range_input.render(screen)
screen.blit(self.max_image_score_range_label, (493, 511))
self.max_image_score_range_input.render(screen)
self.start_button.render(screen, "Save")
self.discrimination_type_dropdown.render(screen)
self.evolution_type_dropdown.render(screen)
self.gossip_type_dropdown.render(screen)
def update(self):
"""Update input box text, and radio buttons"""
if self.agents != self.agents2:
self.agents2 = self.agents.copy()
self.chips = []
start = 0
for i, item in enumerate(self.agents):
chip = Chip(item, pos=(start, 0))
self.chips.append(chip)
start += chip.rect.w + 16
self.scroll.update(self.chips)
self.gossip_type_dropdown.update()
self.discrimination_type_dropdown.update()
self.evolution_type_dropdown.update()
def handle_events(self, events):
"""Handles all the objects events, and when the button is pressed will move to the next scene"""
Scene.handle_events(self, events)
for event in events:
active = False
active = active or self.discrimination_type_dropdown.handle_events(event)
active = active or self.evolution_type_dropdown.handle_events(event)
active = active or self.gossip_type_dropdown.handle_events(event)
if not active:
self.discrimination_threshold_input.handle_events(event)
self.gossip_weight_input.handle_events(event)
self.trust_criteria_input.handle_events(event)
self.number_of_players_input.handle_events(event)
self.number_of_conductors_input.handle_events(event)
self.number_of_rounds_input.handle_events(event)
self.giving_encounters_input.handle_events(event)
self.gossip_encounters_input.handle_events(event)
self.events_file_name_input.handle_events(event)
self.results_file_name_input.handle_events(event)
self.benefit_cooperation_input.handle_events(event)
self.cost_cooperation_input.handle_events(event)
self.start_time_input.handle_events(event)
self.min_image_score_range_input.handle_events(event)
self.min_generation_range_input.handle_events(event)
self.max_image_score_range_input.handle_events(event)
self.max_generation_range_input.handle_events(event)
if self.add_button.handle_events(event):
discrimination_type = self.discrimination_type_list[self.discrimination_type_dropdown.selected]
discrimination_threshold = self.discrimination_threshold_input.get_text()
gossip_type = self.gossip_type_list[self.gossip_type_dropdown.selected]
gossip_weight = self.gossip_weight_input.get_text()
trust_criteria = self.trust_criteria_input.get_text()
self_advertisement = "yes" if self.self_advertisement else "no"
number_of_players = self.number_of_players_input.get_text()
self.agents.append(discrimination_type + " " + str(number_of_players))
self.added.append(
{"d_ty": discrimination_type, "d_th": discrimination_threshold, "g_t": gossip_type,
"g_w": gossip_weight, "t_c": trust_criteria, "s_a": self_advertisement,
"n": number_of_players})
if self.start_button.handle_events(event):
for item in self.added:
items = list(item.values())
items = ','.join(items)
print("make(" + item["n"] + ",player(" + items + ")),")
giving = "on" if self.starting_order else "off"
gossip = "off" if self.starting_order else "on"
items = ','.join(
[self.number_of_conductors_input.get_text(), "1", self.number_of_rounds_input.get_text(), "1",
self.giving_encounters_input.get_text(), self.gossip_encounters_input.get_text(), giving,
gossip, "active"])
print("make(1,conductor(0," + items + ")),")
print("set(imagescorerange(" + self.min_image_score_range_input.get_text() + "," + self.max_image_score_range_input.get_text() + ")),")
print("set(cooperationcost(" + self.cost_cooperation_input.get_text() + ")),")
print("set(cooperationbenefit(" + self.benefit_cooperation_input.get_text() + ")),")
print("set(generationinfo(" + self.min_generation_range_input.get_text() + "," + self.max_generation_range_input.get_text() + ")),")
print("set(starttime(" + self.start_time_input.get_text() + ")),")
print("set(evolutiontype(" + self.evolution_type_list[self.evolution_type_dropdown.selected] + ")),")
print("output(resultsin('" + self.results_file_name_input.get_text() + "')),")
print("output(eventsin('" + self.events_file_name_input.get_text() + "'))")
self.manager.go_to(PlayTournamentScene())
self.self_advertisement_radio_no.handle_events(event)
self.self_advertisement_radio_yes.handle_events(event)
self.starting_order_radio_gossip.handle_events(event)
self.starting_order_radio_giving.handle_events(event)
if i := self.scroll.handle_events(event):
self.agents.pop(i - 1)
self.added.pop(i - 1)
