def __init__(self):
self.turtleWrapper = turtleWrap.TurtleWrapper()
self.warehouse = warehouse.Warehouse()
self.population = Generation.Generation()
self.screen = turtle.Screen()
self.current_position = Point.Point(round(self.warehouse.WIDTH/2), round(self.warehouse.HEIGHT/2))
self.init_screen()
def main():
# Read yaml configuration file
routing_config = Utilities.read_yml("routing_config.yml")
routes = routing_config['routes']
generations = routing_config['generations']
generation_size = routing_config['generation_size']
mutation_chance = routing_config['mutation_chance']
origin = routing_config['origin']
# Read in csv to a dictionary
#nodes_dict = Utilities.read_input_nodes("Kiosk Coords.csv")
nodes_dict = Utilities.read_json_states("state_capitals.json")
# Creates a Network object for the purpose of organizing the Nodes for use in the genetic algorithm
node_network = Network.Network('StateCapitols', origin, nodes_dict)
# Create the initial generation of solutions
solution_generation = Generation.Generation(size=generation_size,
routes=routes,
origin=origin,
network=node_network)
# Begin iterating through generations
best_solution = None
for i in range(1, generations + 1):
solution_generation.generation_step(mutation_chance)
solution_generation.remove_weakest_half()
# Log best solutions
if best_solution is not None:
current_best_solution = solution_generation.get_best_solution()
if (best_solution.score > current_best_solution.score):
best_solution = current_best_solution
else:
best_solution = solution_generation.get_best_solution()
if i % 100 == 0:
print("Generation: ", i)
print("Average distance: ",
solution_generation.generation_average_score())
print("Min Distance: ", best_solution.score)
print("")
#print(best_solution.route_list)
#print(best_solution.score)
# If the best solution was found to be valid print output and generate a quick plot for validation
if best_solution.valid_solution():
node_network.process_solution(best_solution)
node_network.display_routes()
node_network.plot_routes()
else:
print("Error: Best solution is invalid")
def search(self):
# self.res["text"]=(str(self.choix.get()))+" - "+str(self.entryNb.get())
g = Generation(self.Imdp.get(),self.Ilogin.get())
a=self.choix.get()
rep=0
if a==0:
print("Choisissez une option")
elif a==1:
rep=g.choix1()
elif a==2:
rep=g.choix2()
elif a==3:
rep=g.choix3()
elif a==4:
rep=g.choix4()
elif a==5:
rep=g.choix5()
elif a==6:
rep=g.choix6()
elif a==7:
rep=g.choix7()
elif a==9:
if g.choix1()!=0:
rep=g.choix1()
elif g.choix2()!=0:
rep=g.choix2()
elif g.choix3()!=0:
rep=g.choix3()
elif g.choix4()!=0:
rep=g.choix4()
elif g.choix5()!=0:
rep=g.choix5()
elif g.choix6()!=0:
rep=g.choix6()
elif g.choix7()!=0:
rep=g.choix7()
if rep==0:
self.res["text"] = "Décryptage impossible"
else:
self.res["text"]=rep
def __init__(self, ce_id):
# check if there is "Simulations" folder is already created or not
self.simulationsPath = os.path.dirname(
os.path.realpath(__file__)) + "/Simulations/"
if os.path.isdir(self.simulationsPath):
pass
else:
os.makedirs(self.simulationsPath)
# Collection of all CultEvo runs
# something of the form : ..cwd..\Simulations_2016-03-04_[13_23_06]\
self.simulationPath = self.simulationsPath + "Sim_{}/".format(ce_id)
if os.path.isdir(self.simulationPath):
pass
else:
# create folders with specific simulation detail as their name
os.makedirs(self.simulationPath)
# individual simulation run paths(holding all its generation folders):
self.simRunPath = self.simulationPath + "SimRun_000/"
if os.listdir(self.simulationPath).__len__() == 0:
os.makedirs(self.simRunPath)
else:
# get the highest index of the already existing folders.
self.simRunPath = self.simulationPath + "SimRun_{:03}/".format(
int(sorted(os.listdir(self.simulationPath))[-1].split("_")[1])
+ 1)
os.makedirs(self.simRunPath)
# for Generation folders check in Generation.py
# Variable determining how many generations we wan t toallow
generations = P.generations
generation_run = Generation.Generation(P.numberAgents, generations,
self.simRunPath)
self.numOfGenerations = generation_run.countGenUp
from pprint import pprint
from Pokedex import *
from Generation import *
json_data = open('pokemon-list.json')
data = json.load(json_data)
listdata = data["list"]
json_data.close()
Pokedex('Kanto', listdata).print_details_to_file()
Pokedex('Johto', listdata).print_details_to_file()
Pokedex('Hoenn', listdata).print_details_to_file()
Pokedex('Sinnoh', listdata).print_details_to_file()
Pokedex('Unova', listdata).print_details_to_file()
Pokedex('New Unova', listdata).print_details_to_file()
Pokedex('Central Kalos', listdata).print_details_to_file()
Pokedex('Coastal Kalos', listdata).print_details_to_file()
Pokedex('Mountain Kalos', listdata).print_details_to_file()
Pokedex('Alola', listdata).print_details_to_file()
Pokedex('Melemele Alola', listdata).print_details_to_file()
Pokedex('Akala Alola', listdata).print_details_to_file()
Pokedex('Ulaula Alola', listdata).print_details_to_file()
Pokedex('Poni Alola', listdata).print_details_to_file()
for i in range(1, 8):
Generation(i, listdata).print_details_to_file()
def initializeFirstGeneration(self):
self.generation = Generation(0)
#1 - 3 - 6 - 7 sont ok
# NOK : 2 - 4 - 5
from Generation import *
fichier = open("passtext.txt", "r", encoding="UTF-8")
nbligne = 0
while fichier.readline(): #on compte nmobre de ligne du fichier d mot de passe
nbligne += 1
fichier.close()
fichier = open("passtext.txt", "r", encoding="UTF-8")
for i in range(0, nbligne): #on teste tout les mots de passe sur le choix 3
mdp = fichier.readline().rstrip().split(':')
motdepasse = Generation(mdp[1], mdp[0]) #création de l'objet
print(mdp[0] + " : ") # 1 2 3 6 7 OK
print("1. " + str(motdepasse.choix1()))
print("2. " + str(motdepasse.choix2()))
print("3. " + str(motdepasse.choix3()))
print("4. " + str(motdepasse.choix4()))
print("5. " + str(motdepasse.choix5()))
print("6. " + str(motdepasse.choix6()))
print("7. " + str(motdepasse.choix7()))
print()
fichier.close()
def generate_sea_test(self):
# implementing Generation.py
gen = Generation.Generation()
gen.make()
while not gen.isComplete():
del gen
print("Generation failed, remaking...")
gen = Generation.Generation()
gen.make()
gen.printRooms()
# island is at (3, 3)
test = Island(pygame.math.Vector2(3, 3), "Test")
self.islands[str(test.pos)] = test
#
# Test island generation
#
x, y = 0, 0
shop_exists = False
# Loop for each room on Generated island
for row in gen.rows:
for room in row:
if room.iter_num is 6 and not shop_exists:
room_shop = GameBase.Room(test, pygame.math.Vector2(y, x))
room_shop.neighbors = room.neighbors
room_shop.gen_Object = room
shop_exists = True
# print ("shop at " + str(y) + ", " + str(x))
elif room.iter_num is 1:
room_pickups = GameBase.Room(test,
pygame.math.Vector2(y, x))
room_pickups.neighbors = room.neighbors
room_pickups.gen_Object = room
# print ("start at " + str(y) + ", " + str(x))
elif room.iter_num is 2:
room_creation = GameBase.Room(test,
pygame.math.Vector2(y, x))
room_creation.neighbors = room.neighbors
room_creation.gen_Object = room
elif room.iter_num is 3:
room_enemies = GameBase.Room(test,
pygame.math.Vector2(y, x))
room_enemies.neighbors = room.neighbors
room_enemies.gen_Object = room
elif room.iter_num is 4:
room_boss = GameBase.Room(test, pygame.math.Vector2(y, x))
room_boss.neighbors = room.neighbors
room_boss.gen_Object = room
else:
empty_room = GameBase.Room(test, pygame.math.Vector2(y, x))
empty_room.neighbors = room.neighbors
empty_room.gen_Object = room
# print ("empty at " + str(y) + ", " + str(x))
test.rooms.append(empty_room)
y += 1
x += 1
y = 0
# pickups room
# places stuff in room_pickups
ship = Entities.ExitShip(room_pickups)
ship.pos = pygame.math.Vector2(
Constants.TILE_SIZE * Constants.ROOM_SIZE / 2,
Constants.TILE_SIZE * Constants.ROOM_SIZE / 2)
room_pickups.entities.append(ship)
room_pickups.type = GameBase.RoomType.EXIT
for i in range(1, 5):
heart = Entities.HealthPickup(room_pickups, i)
heart.pos = pygame.math.Vector2(64 + 48 * i,
96) # location of hearts on screen
room_pickups.entities.append(heart)
for i in range(1, 7):
enemie = Characters.SnakeEnemy(room_enemies)
enemie.pos = pygame.math.Vector2(
64 + 48 * i, 112) # places the location of the enemie
room_enemies.entities.append(enemie)
for i in range(1, 4):
enemie = Characters.HornetEnemy(room_enemies)
enemie.pos = pygame.math.Vector2(
80 + 120 * i, 112) # places the location of the enemie
room_enemies.entities.append(enemie)
for i in range(0, 10):
g = pow(2, i)
gold = Entities.GoldPickup(room_pickups, g)
gold.pos = pygame.math.Vector2(
Constants.ROOM_SIZE * Constants.TILE_SIZE - 96,
64 + 48 * i) # location of gold on screen
room_pickups.entities.append(gold)
item = Entities.ItemPickup(room_pickups,
Items.BasicMeleeItem("sword", 2))
item.pos = pygame.math.Vector2(100, 200)
room_pickups.entities.append(item)
item3 = Entities.ItemPickup(room_pickups,
Items.BasicMeleeItem("cutlass", 3))
item3.pos = pygame.math.Vector2(300, 200)
room_pickups.entities.append(item3)
item2 = Entities.ItemPickup(room_pickups, Items.BowItem())
item2.pos = pygame.math.Vector2(200, 200)
room_pickups.entities.append(item2)
test.rooms.append(room_enemies)
test.rooms.append(room_pickups)
test.start_room = room_pickups
# boss room
b = Characters.WizardEnemy(room_boss)
b.teleport()
room_boss.entities.append(b)
test.rooms.append(room_boss)
room_boss.type = GameBase.RoomType.BOSS
# shop room
# places stuff in room_shop
room_shop.type = GameBase.RoomType.SHOP
shopkeeper = Characters.Shopkeeper(room_shop)
shopkeeper.pos = pygame.math.Vector2(100, 300)
room_shop.entities.append(shopkeeper)
pedestal = Entities.ShopPedestal(
room_shop, Entities.ItemPickup(room_shop, Items.DummyItem()), 30)
pedestal.pos = pygame.math.Vector2(108, 375)
room_shop.entities.append(pedestal)
test.rooms.append(room_shop)
test.rooms.append(room_creation)
for room in test.rooms:
keys = list(room.neighbors.keys())
factor = 64
# if North exit
if 1 in keys:
thingy = Entities.HealthPickup(room, 1)
# thingy.pos = pygame.math.Vector2(factor * 4, factor * 2)
# room.entities.append(thingy)
else:
if (room.pos.y != 0):
for i in range(9):
wall = Entities.Terrain(room)
wall.pos = pygame.math.Vector2(factor * i, 0)
room.entities.append(wall)
# if East exit
if 2 in keys:
thingy = Entities.HealthPickup(room, 2)
# thingy.pos = pygame.math.Vector2(factor * 7, factor * 4)
# room.entities.append(thingy)
else:
if (room.pos.x != 2):
for i in range(9):
wall = Entities.Terrain(room)
wall.pos = pygame.math.Vector2(factor * 8, factor * i)
room.entities.append(wall)
# if South exit
if 3 in keys:
thingy = Entities.HealthPickup(room, 3)
# thingy.pos = pygame.math.Vector2(factor * 4, factor * 7)
# room.entities.append(thingy)
else:
if (room.pos.y != 2):
for i in range(9):
wall = Entities.Terrain(room)
wall.pos = pygame.math.Vector2(factor * i, factor * 8)
room.entities.append(wall)
# if West exit
if 4 in keys:
thingy = Entities.HealthPickup(room, 4)
# thingy.pos = pygame.math.Vector2(factor * i, factor * 4)
# room.entities.append(thingy)
else:
if (room.pos.x != 0):
for i in range(9):
wall = Entities.Terrain(room)
wall.pos = pygame.math.Vector2(0, factor * i)
room.entities.append(wall)
def generation(island):
width = random.randint(3, 7)
length = random.randint(3, 7)
# implementing Generation.py
gen = Generation.Generation(width, length)
gen.make()
while not gen.isComplete():
del gen
print("Generation failed, remaking...")
gen = Generation.Generation(width, length)
gen.make()
gen.printRooms()
island.width = width
island.length = length
# Start creation
x, y = 0, 0
shop_exists = False
# Loop for each room on Generated island
for row in gen.rows:
for room in row:
if room.iter_num is 6 and not shop_exists:
room_shop = GameBase.Room(island, pygame.math.Vector2(y, x))
room_shop.neighbors = room.neighbors
room_shop.gen_Object = room
shop_exists = True
# print ("shop at " + str(y) + ", " + str(x))
elif room.iter_num is 1:
room_pickups = GameBase.Room(island, pygame.math.Vector2(y, x))
room_pickups.neighbors = room.neighbors
room_pickups.gen_Object = room
# print ("start at " + str(y) + ", " + str(x))
else:
empty_room = GameBase.Room(island, pygame.math.Vector2(y, x))
empty_room.neighbors = room.neighbors
empty_room.gen_Object = room
# print ("empty at " + str(y) + ", " + str(x))
island.rooms.append(empty_room)
y += 1
x += 1
y = 0
# boss room
b = Characters.WizardEnemy(island.rooms[(len(island.rooms) - 1)])
b.teleport()
island.rooms[(len(island.rooms) - 1)].entities.append(b)
island.rooms[(len(island.rooms) - 1)].type = GameBase.RoomType.BOSS
# starting room
island.start_room = island.rooms[0]
ship = Entities.ExitShip(island.start_room)
ship.pos = pygame.math.Vector2(64 * 5, 64 * 5)
island.start_room.entities.append(ship)
island.start_room.type = GameBase.RoomType.EXIT
# pickups room
# places stuff in room_pickups
# for i in range(1, 5):
# heart = Entities.HealthPickup(room_pickups, i)
# heart.pos = pygame.math.Vector2(64 + 48 * i, 96) # location of hearts on screen
# room_pickups.entities.append(heart)
# for i in range(0, 10):
# g = pow(2, i)
# gold = Entities.GoldPickup(room_pickups, g)
# gold.pos = pygame.math.Vector2(Constants.ROOM_SIZE * Constants.TILE_SIZE - 96, 64 + 48 * i) # location of gold on screen
# room_pickups.entities.append(gold)
item = Entities.ItemPickup(room_pickups, Items.DummyItem())
item.pos = pygame.math.Vector2(100, 200)
room_pickups.entities.append(item)
island.rooms.append(room_pickups)
# shop room
# places stuff in room_shop
room_shop.type = GameBase.RoomType.SHOP
shopkeeper = Characters.Shopkeeper(room_shop)
shopkeeper.pos = pygame.math.Vector2(
Constants.ROOM_SIZE * Constants.TILE_SIZE / 2 - 16,
Constants.ROOM_SIZE * Constants.TILE_SIZE / 2 - 96)
room_shop.entities.append(shopkeeper)
pedestal_count = random.randint(1, 4)
for i in range(pedestal_count):
x = Constants.ROOM_SIZE * Constants.TILE_SIZE / (pedestal_count +
1) * (i + 1)
y = shopkeeper.pos.y + 160
make_store_pedestal(room_shop, pygame.math.Vector2(x, y))
island.rooms.append(room_shop)
# island.rooms.append(room_creation)
# Wall placement
for room in island.rooms:
keys = list(room.neighbors.keys())
factor = 64 # rooms are (9 * 64) x (9 * 64) pixels
# if no North exit
if 1 not in keys:
# if not Northernmost row
if (room.pos.y != 0):
# if Westernmost column
if (room.pos.x == 0):
for i in range(1, 9):
addWall(room, factor * i, 0)
# if Easternmost column
elif (room.pos.x == (width - 1)):
for i in range(8):
addWall(room, factor * i, 0)
# make as usual
else:
for i in range(9):
addWall(room, factor * i, 0)
else:
for i in range(9):
addBound(room, factor * i, 0)
else:
# if not Northernmost row
if (room.pos.y != 0):
# if not Westernmost column
if (room.pos.x != 0):
addWall(room, 0, 0)
# if not Easternmost column
if (room.pos.x != (length - 1)):
addWall(room, factor * 8, 0)
# if no East exit
if 2 not in keys:
# if not Easternmost column
if (room.pos.x != (length - 1)):
# if Northernmost row
if (room.pos.y == 0):
for i in range(1, 9):
addWall(room, factor * 8, factor * i)
# if Southernmost row
elif (room.pos.y == (width - 1)):
for i in range(8):
addWall(room, factor * 8, factor * i)
# make as usual
else:
for i in range(9):
addWall(room, factor * 8, factor * i)
else:
for i in range(9):
addBound(room, factor * 8, factor * i)
else:
# if not Easternmost column
if (room.pos.x != (length - 1)):
# if not Northernmost row
if (room.pos.y != 0):
addWall(room, factor * 8, 0)
# if not Southernmost row
if (room.pos.y != (width - 1)):
addWall(room, factor * 8, factor * 8)
# if no South exit
if 3 not in keys:
# if not Southernmost row
if (room.pos.y != (width - 1)):
# if Easternmost column
if (room.pos.x == 0):
for i in range(1, 9):
addWall(room, factor * i, factor * 8)
# if Westernmost column
elif (room.pos.x == (length - 1)):
for i in range(8):
addWall(room, factor * i, factor * 8)
# draw wall as usual
else:
for i in range(9):
addWall(room, factor * i, factor * 8)
else:
for i in range(9):
addBound(room, factor * i, factor * 8)
else:
# if not Southernmost row
if (room.pos.y != (width - 1)):
# if not Easternmost column
if (room.pos.x != 0):
addWall(room, 0, factor * 8)
# if not Westernmost column
if (room.pos.x != (length - 1)):
addWall(room, factor * 8, factor * 8)
# if West exit
if 4 not in keys:
# if not Westernmost room
if (room.pos.x != 0):
# if Northernmost room
if (room.pos.y == 0):
for i in range(1, 9):
addWall(room, 0, factor * i)
# if Southernmost room
elif (room.pos.y == (width - 1)):
for i in range(8):
addWall(room, 0, factor * i)
# draw wall as usual
else:
for i in range(9):
addWall(room, 0, factor * i)
else:
for i in range(9):
addBound(room, 0, factor * i)
else:
# if not Westernmost column
if (room.pos.x != 0):
# if not Northernmost row
if (room.pos.y != 0):
addWall(room, 0, 0)
# if not Southernmost row
if (room.pos.y != (width - 1)):
addWall(room, 0, factor * 8)
#model = NeuralNetwork(dimensions = [5, 3, 1], activation_hidden = 'relu')
#print('weights : ', model.getModel().get_weights())
### Set parameters ###
num_episodes = 1
num_individuals = 20
dimensions = [2, 1]
activation_hidden = 'relu'
activation_output = 'sigmoid'
num_timesteps = 400
num_generations = 5
######################
gen = Generation(num_individuals=num_individuals,
dimensions=dimensions,
activation_hidden=activation_hidden,
activation_output=activation_output)
#print(gen)
avg_fitness_history = []
for gen_num in range(num_generations):
print('Generation ', gen_num)
# Loop over the individuals in the population in one generation
for individual in gen.get_population():
observation = env.reset()
fitness = 0
# Loop over the number of time steps
def recherche(self):
value = self.CheckVar.get()
mdp_clear = ""
if value == 1:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix1()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 2:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix2()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 3:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix3()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 4:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix4()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 5:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix5()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 6:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix6()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 7:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix7()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
if value == 8:
test_choix = Generation(self.login.get(), self.mdp.get())
mdp_clear = test_choix.choix8()
if mdp_clear == 0:
self.resultext.set(
"Erreur, impossible de décrypter le mot de passe, Mauvaise méthode"
)
else:
self.resultext.set("Résultat: " + mdp_clear)
def __init__(self, island, pos):
self.entities = []
self.island = island
self.pos = pos
self.discovered = False
self.visited = False
self.type = RoomType.NORMAL
# Get background textures
self.map = Parser.main(pos, self.island.width, self.island.length)
self.tileLib = Parser.tileDict()
self.tiles = []
self.drawX = 0
self.drawY = 0
# Get room contents
self.layout = Parser.getLayout(self.type)
self.layoutLib = Parser.getLayoutLib()
# Data from generation
self.neighbors = dict()
self.gen_Object = Generation.Generation().Room()
# Apply background textures
self.bg = pygame.Surface(
pygame.math.Vector2(Constants.ROOM_SIZE * Constants.TILE_SIZE,
Constants.ROOM_SIZE * Constants.TILE_SIZE))
for element in self.map:
self.tilesRow = []
for unit in element:
tilename = self.tileLib[unit].replace('"', '')
tilename = random.choice(tilename.split('&'))
self.image = Drawing.Sprite(
pygame.image.load(tilename).convert_alpha())
self.image.scale = pygame.math.Vector2(
64 / self.image.tex.get_width(),
64 / self.image.tex.get_height())
self.tilesRow.append(self.image)
self.tiles.append(self.tilesRow)
for element in self.tiles:
for unit in element:
unit.pos = pygame.math.Vector2(self.drawX, self.drawY)
unit.draw(self.bg)
self.drawX += 64
self.drawY += 64
self.drawX = 0
# Apply room contents
self.drawX = 0
self.drawY = 0
for row in self.layout:
for element in row:
if element in self.layoutLib:
obj = 0
if element is "h":
obj = Characters.HornetEnemy(self)
elif element is "s":
obj = Characters.SnakeEnemy(self)
obj.pos = pygame.math.Vector2(self.drawX, self.drawY)
self.entities.append(obj)
self.drawX += 64
self.drawY += 64
self.drawX = 0
import Generation as G gen = G.Generation()
