def ComptePompe():
#Je pense que ca va boucler sans discontinue avec les pompes
#Sauf quand va rentrer dans boucle while car descendu assez bas
#alors devra sortir boucle pour intéragir avec bouton
#Donc il faut qu'au moment d'arrêter l'exercice il s'éloigne du capteur
#
global Fin
global mesures #On cherche mesure car peut changer en cours de série
PompesValideBas = 2
pompes = 0
compteur = -1
Affichage("On passe aux pompes")
time.sleep(3)
Affichage("Mettez-vous en position")
time.sleep(4)
Affichage("C'est partit !!")
time.sleep(2)
while DemandeUtil(True) == True and Fin == False:
#tant que pompe rentre pas dans boucle va sonder valeur bouton
#Aucun try tout se fait en direct
#est ce que dès que va en bas ca detecte et rentre dans boucle ?
if pompes > compteur:
Affichage("Nombre de pompe =" + str(pompes))
compteur = pompes
#Pour afficher que quand une pompe supplémentaire
if Pompe(PompesValideBas, mesures[0]):
#si la pompe est validée
pompes = pompes + 1
return pompes
def ControleGainage(DistanceValide):
#Emet un bruit de 1 seconde lorsque l'utillisateur a une mauvaise position ce qui equivaut a etre en dehors de l'intervalle de 10cm autour de la valeur DitanceValide
#Retourne le temps de gainage
#qui correspond soit à 2 si il y a eu faute soit 1 sinon
temps = 0
dist = ultrasonicRead(ultrasonic_ranger)
if (dist > (DistanceValide + 2) or (dist < DistanceValide - 2)):
#regarder cb vaut 1 d'acard en cm
digitalWrite(buzzer, 0)
Affichage("Mauvaise Position")
time.sleep(2)
temps = temps + 2
else:
digitalWrite(buzzer, 0)
Affichage("Bonne Position")
time.sleep(0.5)
temps = temps + 0.5
# except KeyboardInterrupt:
# digitalWrite(buzzer, 0)
# break
# except DemandeUtil() != True:
# digitalWrite(buzzer, 0)
return temps
def affichage(self):
print ("------------------ Analyse du Master Boot Record (MBR) ------------------")
print ("Affichag Ascii du Boot code dans le MBR:")
print(Affichage.dumpAscii(self.BootCode))
print()
print ("La signature du disque : "+Affichage.dumpHex(self.signature))
for i in range(4):
self.partEntrys[i].affichage()
print()
print ("Vérification de la signature MBR(55AA) : "+Affichage.dumpHex(self.MagiqueNumber))
def __init__(self): """ Initialise le jeu en créant un nouvel affichage et en définissant tous les attributs de l'objet à None ou False. """ self.affichage = Affichage() self.niveau = None self.serveur = None self.client = None self.en_boucle = False self.en_partie = False
def __init__(self, mbrReader):
self.mbr = mbrReader
self.partitsLIst = {}
for i in range(4):
if self.mbr.partEntrys[
i].PartitionType == b'\x0b': # si c'est un fat32
self.partitsLIst[i] = Fat32(self.mbr.partEntrys[i],
self.mbr.offsetFirstSector,
self.mbr.file)
curentP = self.partitsLIst[i]
print(Affichage.dumpHex(curentP.boot_sec1))
print()
print(Affichage.dumpAscii(curentP.boot_sec1))
print(curentP.bytes_per_sector)
print(curentP.sectors_by_cluster)
print(curentP.reserved_sector)
print(curentP.number_of_fat_copis)
print(curentP.type_media)
print(curentP.number_of_root_directory_entry)
print(curentP.total_sectors_by_filesystem)
print(Affichage.dumpAscii(curentP.system_fichier))
print(curentP.fileSystem_version)
print(Affichage.dumpHex(curentP.extended_signature))
print(curentP.serial_numberOfPartit)
print(Affichage.dumpAscii(curentP.volume_label))
print(Affichage.dumpAscii(curentP.fileSystem_type))
print()
print(Affichage.dumpAscii(curentP.fileSystemInfo))
print(Affichage.dumpAscii(curentP.marqueRra))
print(curentP.nbrOctetsLibre)
print(curentP.premier_cluster_disponible)
def ComptePompeSecours(Bas):
#Compte les pompes mais s'arrête pas avec le bouton
#renvoie la distance
nbPompe = 0
a = temp(sensor, '1.1')
Affichage(str(a))
while True:
try:
dist = ultrasonicRead(ultrasonic_ranger)
if (dist < Bas):
digitalWrite(buzzer, 1)
time.sleep(2)
nbPompe = nbPompe + 1
Affichage(str(nbPompe))
digitalWrite(buzzer, 0)
digitalWrite(buzzer, 0)
time.sleep(2)
except:
return 0
def ChronoGainage():
#renvoie le temps de gainage effectué jusqu'à ce que l'utilisateur
#appuie sur le bouton pour passer
global Fin
global mesures #On cherche mesure car peut changer en cours de série
BonnePosition = mesures[1]
temps = 0
Affichage("On passe au gainage")
time.sleep(4)
Affichage("Mettez-vous en position")
time.sleep(4)
Affichage("C'est partit !!")
time.sleep(2)
while DemandeUtil(True) == True and Fin == False:
#Sonde toutes les secondes si y a une faute
#si pas de faute avance de 1 sec
#si faute attend 2 secondes et bip
temps = temps + ControleGainage(BonnePosition)
Affichage("Temps de gainage = " + str(temps))
return temps
def Bouton(continu):
#
#Fonction chronometrant le nombre de secondes pendant
#lesquelles le bouton a ete appuye
#Prennd un paramètre un bool qui dit continue ou pas
#True la fonction sortira directement du while
while True:
temps = 0
if digitalRead(button) == 1:
while digitalRead(button) == 1:
time.sleep(1)
temps = temps + 1
if temps < 3:
Affichage("Passer, appui : " + str(temps) + "sec")
if temps >= 3 and temps < 7:
Affichage("Reprendre mesures, appui : " + str(temps) +
"sec")
if temps >= 7:
Affichage("Fin entrainement appui : " + str(temps) + "sec")
return temps #va tourner en continue
if continu:
return temps
def pause():
#Arrête l'entrainement et chronomètre la pause
temps = 0
i = 0
global Fin
while DemandeUtil(True) == True and Fin == False:
#Sondage en continu
#il faut appuyer plus de 1 seconde car sinon peut que demandeUtil ne soit pas scruté
#car timesleep fait des pauses de 1 secondes
#autre solution le threading (progra parallèle mais trop compliqué)
time.sleep(0.1)
i = i + 1
if i == 10:
#Pour ne pas afficher trop de temps ca clignote
temps = temps + 1
Affichage("Temps de pause = " + str(temps))
i = 0
return temps
def PrisesDesMesures():
global Fin
#Prend les mesures
AffichageMesurePompe()
ValidationMesures = True #veut dire qu'il passe
#On met aussi la possibilité qu'il appuie plus de 5 sec auquel cas ca n'arrête pas tout.
while ValidationMesures == True and Fin == False:
mesuresPompe = PriseDeMesure()
AffichageMesureFin()
ValidationMesures = DemandeUtil(False)
ValidationMesures = True
while ValidationMesures == True and Fin == False:
AffichageMesureGainage()
mesuresGainage = PriseDeMesure()
Affichage("Garder les mesures ? ")
ValidationMesures = DemandeUtil(False)
if Fin == True:
return 0
return [mesuresPompe, mesuresGainage]
import direct.directbase.DirectStart
from direct.task import Task
base.disableMouse()
if base.camLens != None:
base.camLens.setNear(0.001)
if base.camera != None:
base.camera.setPos(0.0, 5.0, 0.0)
base.camera.lookAt(0.0, 0.0, 0.0)
if base.win != None:
base.win.setClearColor(Vec4(0.8,0.8,0.8,1))
base.graphicsEngine.renderFrame()
db = DB()
gps = GPS()
aff = Affichage()
if base.win!=None:
gui = Interface(aff)
else:
gui = None
aff.gui = gui
parseur = Parser(gui)
parseur.cg = aff
parseur.prepareParse()
if len(sys.argv)>1:
if sys.argv[1]=="parse+bam":
parseur.parse(BAM=True)
sys.exit()
if sys.argv[1]=="parse":
parseur.parse()
from flag import Flag
from minus import Minus
import json
screen = pygame.display.set_mode((720, 700))
pygame.display.set_caption("Labyrinthe")
bg = pygame.image.load("bg.png")
bg = pygame.transform.scale(bg, (1800, 1800))
box = pygame.image.load("black-check-box.png")
box = pygame.transform.scale(box, (50, 50))
blank = pygame.image.load("blank.png")
blank = pygame.transform.scale(blank, (50, 50))
flag = Flag()
affichage = Affichage(screen, box, blank)
player = Player()
minus = Minus()
with open('level.json', 'w') as outfile:
json.dump(1, outfile)
i = 0
run = True
while run:
screen.blit(bg, (-250, -350))
minus.start(screen, player)
screen.blit(player.image, player.rect)
flag.start(screen)
class Jeu:
""" Cette classe sert principalement d'interface entre un Affichage et un
Niveau. Elle initialise et actualise les objets à chaque changement de
menu. """
def __init__(self):
""" Initialise le jeu en créant un nouvel affichage et en définissant
tous les attributs de l'objet à None ou False. """
self.affichage = Affichage()
self.niveau = None
self.serveur = None
self.client = None
self.en_boucle = False
self.en_partie = False
def charger(self):
""" Charge les images du jeu dans la mémoire vive. """
self.affichage.charger_images()
def arreter(self):
""" Arrête le programme après avoir arrêté le serveur et / ou le
client si une partie en réseau a été lancée. """
if self.serveur:
self.serveur.arreter_ecoute()
self.serveur.arreter_echange()
if self.client:
self.client.arreter_echange()
self.client.deconnecter()
utile.arreter()
def initialiser_menu_principal(self):
""" Crée un niveau de fond et les widgets du menu principal. """
utile.debogguer("Initialisation du menu principal")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_menu(self)
self.creer_niveau()
joueur = self.niveau.creer_joueur()
joueur.droite()
joueur.vie = float("inf")
self.niveau.ajouter_entite(joueur)
self.niveau.joueur_id = joueur.identifiant
self.en_partie = False
def initialiser_menu_multijoueur(self):
""" Crée les widgets du menu multijoueur principal. Réutilise le
niveau de fond déjà crée. """
utile.debogguer("Initialisation du menu multijoueur")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_multijoueur(self)
def initialiser_menu_heberger(self):
""" Crée les widgets du menu de réglage du serveur (héberger).
Réutilise le niveau de fond déjà crée. """
utile.debogguer("Initialisation du menu heberger")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_heberger(self)
def initialiser_menu_rejoindre(self):
""" Crée les widgets du menu de réglage du client (rejoindre).
Réutilise le niveau de fond déjà crée. """
utile.debogguer("Initialisation du menu rejoindre")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_rejoindre(self)
def initialiser_partie(self):
""" Crée un niveau et les widgets de partie. """
utile.debogguer("Initialisation d'une partie")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_partie()
self.creer_niveau()
joueur = self.niveau.creer_joueur()
self.niveau.ajouter_entite(joueur)
self.niveau.joueur_id = joueur.identifiant
self.en_partie = True
def initialiser_partie_serveur(self, port):
""" Crée puis lance un serveur écoutant sur un port donné. Si le
serveur arrive à se lier au port donné, crée un niveau ainsi
que les widgets de partie (comme en mode solo).
<port> (int): Le port d'écoute du serveur. """
self.serveur = Serveur(self, port)
if not self.serveur.accrocher():
self.affichage.afficher_message("Impossible de créer un serveur")
self.arreter_boucle()
else:
utile.debogguer("Initialisation d'une partie (serveur)")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_partie()
self.creer_niveau("serveur")
joueur = self.niveau.creer_joueur()
self.niveau.ajouter_entite(joueur)
self.niveau.joueur_id = joueur.identifiant
self.serveur.lancer_ecoute()
self.serveur.lancer_echange()
self.en_partie = True
def initialiser_partie_client(self, adresse, port):
""" Crée un client et lance une tentative de connexion à l'adresse et
le port donnés. Si la tentative réussi, crée un niveauClient et
lance la boucle d'échange du client.
<adresse> (str): L'adresse du serveur à joindre.
<port> (int): Le port d'écoute du serveur. """
self.client = Client(self)
if not self.client.connecter(adresse, port):
self.affichage.afficher_message("Impossible de se connecter")
self.arreter_boucle()
else:
utile.debogguer("Initialisation d'une partie (client)")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_partie()
self.affichage.afficher_message("Connecté au serveur !")
self.creer_niveau("client")
self.client.lancer_echange()
self.en_partie = True
def creer_niveau(self, mode="solo"):
""" Crée et initialise un nouveau niveau ainsi qu'un joueur.
[mode] (str): Le mode de gestion du niveau (solo, client ou
serveur). (solo par défaut). """
utile.debogguer("Création d'un nouveau niveau")
if mode == "solo":
self.niveau = Niveau(self)
elif mode == "client":
self.niveau = NiveauClient(self, self.client)
elif mode == "serveur":
self.niveau = NiveauServeur(self, self.serveur)
self.niveau.initialiser_image()
def lancer_boucle(self):
""" Lance une nouvelle boucle de jeu en mettant en pause la boucle
de jeu actuellement active. Une nouvelle boucle est généralement
lancée à la création d'un nouveau menu. """
utile.debogguer("Lancement d'une nouvelle boucle de jeu")
temps_precedent = time.time()
self.en_boucle = True
while self.en_boucle:
temps_ecoule = time.time() - temps_precedent
temps_precedent = time.time()
self.affichage.actualiser_evenements(self)
self.niveau.actualiser(temps_ecoule)
self.affichage.actualiser(self.niveau, self)
self.en_boucle = True
utile.debogguer("Fin d'une boucle de jeu")
def arreter_boucle(self):
""" Arrête la boucle de jeu en cours. """
self.en_boucle = False
def arreter_partie(self):
""" Déconnecte le client ou arrête le serveur si une partie réseau est
en cours. """
if self.client:
self.client.arreter_echange()
self.client.deconnecter()
if self.serveur:
self.serveur.arreter_ecoute()
self.serveur.arreter_echange()
def finir_partie(self):
""" Affiche le menu de fin de partie. """
utile.debogguer("Fin de la partie")
self.niveau.en_pause = True
self.en_partie = False
self.affichage.creer_widgets_fin(self)
def finir_partie_serveur(self):
""" Affiche le menu de fin de partie en tant que serveur. """
utile.debogguer("Fin de partie en tant que serveur")
self.niveau.enlever_entite(self.niveau.obtenir_joueur_local())
def finir_partie_client(self):
""" Affiche le menu de fin de partie en tant que client. """
utile.debogguer("Fin de partie en tant que client")
self.niveau.enlever_entite(self.niveau.obtenir_joueur_local())
def geler_partie(self, pause=True):
""" Met la partie en pause en créant le menu de pause ou continue la
partie en supprimant les widgets de pause.
[pause] (bool): Si True, met le jeu en pause, sinon continue la
partie. (True par défaut). """
self.niveau.en_pause = pause
if pause:
utile.debogguer("Gêle de la partie")
self.affichage.creer_widgets_pause(self)
else:
utile.debogguer("Dégèle de la partie")
self.affichage.supprimer_widgets_pause()
def ajouter_client(self, adresse):
""" Ajoute un joueur à la partie et envoie le niveau en cours à ce
dernier. Cette méthode est généralement appelée par un serveur
lorsqu'un client se connecte.
<adresse> (str): L'adresse du client qui vient de se connecter. """
self.affichage.afficher_message("Un joueur vient de se connecter")
joueur = self.niveau.creer_joueur()
self.niveau.ajouter_entite(joueur)
self.niveau.envoyer()
self.niveau.definir_joueur(adresse, joueur)
def enlever_client(self, adresse):
""" Enlève un joueur de la partie et préviens touts les autres. Cette
méthode est généralement appelée par un serveur lorsqu'un client
se déconnecte.
<adresse> (str): L'adresse du client qui vient de se déconnecter. """
self.affichage.afficher_message("Un joueur vient de se déconnecter")
#!/usr/bin/env python3.6
import math
from affichage import Affichage
if __name__ == "__main__":
print ("screan01")
screan = Affichage()
def entrainement3():
#Procédure de l'entrainement 1
#AffichageDebut()
global mesures
mesures = PrisesDesMesures()
Affichage("On va commencer l'entrainement")
time.sleep(4)
global Fin
ResultatsEntrainement = []
while True:
if Fin:
break
pompes1 = ComptePompe()
if Fin:
break
ResultatsEntrainement = ResultatsEntrainement + [(1, pompes1, 0)]
tempsPause = pause()
#Vérif si l'util veut arrêter ou pas
#Global Fin marche t'elle ?
if Fin:
break
pompes2 = ComptePompe()
if Fin:
break
ResultatsEntrainement = ResultatsEntrainement + [(1, pompes2, 0)]
tempsPause = pause()
#Vérif si l'util veut arrêter ou pas
#Global Fin marche t'elle ?
if Fin:
break
# Fin Vérif
gainage1 = ChronoGainage()
ResultatsEntrainement = ResultatsEntrainement + [
(2, gainage1, tempsPause)
]
#pause()
#Vérif si l'util veut arrêter ou pas
if Fin:
break
tempsPause = pause()
if Fin:
break
gainage1 = ChronoGainage()
ResultatsEntrainement = ResultatsEntrainement + [
(2, gainage1, tempsPause)
]
#pause()
#Vérif si l'util veut arrêter ou pas
if Fin:
break
#pompes2 = ComptePompe( mesures[0])
#ResultatsEntrainement = ResultatsEntrainement +[(1,pompes2,tempsPause)]
#tempsPause = pause()
#Vérif si l'util veut arrêter ou pas
#Global Fin marche t'elle ?
# Fin Vérif
return ResultatsEntrainement
Affichage("Fin d'entrainement au revoir")
time.sleep(5)
Affichage("Regardez vos stats à l'ecran")
return ResultatsEntrainement
class App():
def __init__(self, dim):
# display a view of the cube in canvas
self.dim = dim
self.affichage = Affichage(self.dim)
self.restApp()
def restApp(self):
# create a cube with dimension, view and colors
self.createCube()
# create agent
self.createAgent()
def createCube(self):
# create a cube with dimension, view and colors
self.myCube = Cube(self.dim) # create the cube
self.myView = self.myCube.view
self.myMaster = self.myCube.master # get the master view
self.myMasterAsInt = self.myCube.masterAsInt # get the master view
def createAgent(self):
# create agent
self.agent = Actions(self.myCube)
self.actions = []
self.reversedOppositeActions = []
def oneActionState(self, action):
self.myMaster, self.myMasterAsInt = self.agent.makeOneAction(action)
def manyActionsState(self, nb_time):
last_1 = "A"
temp = []
for _ in range(nb_time):
last_1, action, action_i, self.myMaster, self.myMasterAsInt = self.agent.makeRandomActions(
last_1)
self.actions.append(action)
temp.append(action_i)
temp.reverse()
self.reversedOppositeActions = temp
del temp
def updateWindow(self):
self.affichage.showCube(self.myMaster, self.myView)
self.affichage.window.update_idletasks()
self.affichage.window.update()
time.sleep(0.05)
def quit(self, temps=0.0):
self.affichage.quit(temps)
def num_solved_sides(self): # compte le nombre de face résolue
solved = 0
for side in self.myMaster:
color = side[0][0]
# if number of pieces on this side equal to first square is number of total pieces, side is solved
if sum(collections.Counter(row)[color]
for row in side) == self.dim**2:
solved += 1
return solved
def AffichageDebut():
#Affiche le tutoriel à l'écran lcd
time.sleep(3)
Affichage("Bienvenue sur votre Sport Trainer")
time.sleep(3)
Affichage("Pour passer le tutoriel appuyez ")
time.sleep(3)
Affichage("sur le bouton plus de 3 secondes")
if BoutonInteract(False) != 1 and Fin == False:
time.sleep(3)
Affichage("Vous allez dialoguer avec ")
time.sleep(3)
Affichage("votre entraineur")
time.sleep(3)
Affichage("au moyens d'un bouton")
time.sleep(3)
Affichage(" entre 0 et 3 sec vous passez")
time.sleep(3)
Affichage("a l'etape suivante")
time.sleep(2)
Affichage("entre 3 et 7 sec vous ")
time.sleep(3)
Affichage("reprenez vos mesures")
time.sleep(3)
Affichage("plus de 7 sec vous ")
time.sleep(3)
Affichage("arretez l'entraînement")
time.sleep(3)
Affichage("Essayez ! appuyez entre 0 et ")
time.sleep(3)
Affichage("3 secondes sur le bouton")
time.sleep(3)
while BoutonInteract(False) != 0:
Affichage("Non reessayez ! ")
Affichage("Bravo ! ")
time.sleep(3)
Affichage("Commencons l'entrainement")
return 0
def Test_Capteur_Distance():
while True:
Affichage(str(PriseDeMesure()))
time.sleep(0.2)
return 0
if __name__ == "__main__":
logger.set_level(logger.INFO)
env = gym.make('VizdoomBasic-v0',
depth=True,
labels=True,
position=True,
health=True)
outdir = 'log/viz_doom-agent-results'
#env = wrappers.Monitor(env, directory=outdir, force=True)
agent = VizDoomAgent(env)
episode_count = 500
reward = 0
done = False
reword_recorder = Affichage()
BATCH_SIZE = 128
GAMMA = 0.9
render = False
buffer = replay(50000)
for i in range(episode_count):
ob = env.reset()
reword_recorder.start_episode()
step = 0
while True:
action = agent.act(agent.preprocess(ob), reward, done)
transition = Transition(agent.preprocess(ob), action, None, None,
None)
if step % 100 == 0:
print(step)
ob, reward, done, _ = env.step(action)
def __init__(self, dim):
# display a view of the cube in canvas
self.dim = dim
self.affichage = Affichage(self.dim)
self.restApp()
from tsp_graph_init import Graph
import numpy as np
import random
from affichage import Affichage
random.seed(1)
np.random.seed(1)
LARGEUR = 800
HAUTEUR = 600
mat_lieux = Graph.charger_graph("graph_5.csv")
app = Affichage(LARGEUR, HAUTEUR, array_lieux=mat_lieux, nb_lieux=5)
"""
Args:
l (int): largeur de l'espace
h (int): hauteur de l'espace
array_lieux (array or bool): Matrice des points à calculer. Si la valeur de 'array_lieu' est initialisée à 'False'\
le programme générera automatiquement une liste de lieux à partir du nombre de lieux spécifié pour 'nb_lieux'
nb_lieux (int, optional): Nombre de lieux à utiliser pour la génération de lieux aléatoires si `array_lieux` = `False`.\
Defaults to 25.
"""
app.mainloop()