Пример #1
0
def demander(quelquechose, t=0):
    """ Une surcouche de iconsole.demander 
		qui met l'état actuel en « acteur »
		
		@quelquechose : str = un truc à afficher 
		@t : int = nombre de tabulations [opts]
		
		@return : str
	"""
    return iconsole.demander(get_etat(), quelquechose, t)
Пример #2
0
import persistance
import affichage
import moteur
import iconsole
import couleurs
import misc

if __name__ == '__main__':
	persistance.init ()
	couleurs.init ()
	# affichage.init ()

	continuer = True
	while continuer == True:
		jcode = iconsole.demander ("main","Tu veux decider du code ?")
		jcode = misc.question_fermee (jcode)

		if jcode == True:
		    iconsole.choisir_code ()
		else:
		    iconsole.choisir_code ()

		iconsole.jouer ()

		rep = iconsole.demander ("main","Tu veux rejouer ?")
		continuer = misc.question_fermee (jcode)
		affichage.reset ()

	persistance.save ()
Пример #3
0
    iconsole.afficher("Chargement", "Interface console principale ...")
    sleep(random())

    iconsole.afficher("Chargement", "Lancement ...")
    sleep(1)

    e = "Menu"  # L'état de base est le "Menu"
    joueur.init()  # Initialise le joueur

    iconsole.afficher(e, "Tapez « help » pour obtenir de l'aide ...")

    continuer = True
    while continuer == True:
        # Les commandes sont
        # help, humain-code, humain-joue, quit, ia-joue, ia-code
        rep = iconsole.demander(e, "Commande")

        if rep == "quit":
            continuer = False
            iconsole.afficher("Programme", "Quitte ...")
        else:
            try:
                e = joueur.send(rep)
            except joueur.ErreurFatale:
                iconsole.afficher("Programme", "Une erreur fatale est survenue ...")
                continuer = False
            except joueur.LeProgrammeurEstCon:
                iconsole.afficher("Programme", "Une des fonctions dans `joueur.py` est mal utilisée ... quitte")
                continuer = False
            except joueur.EcranInvalide:
                iconsole.afficher(
Пример #4
0
def gen_fsm ():
	""" Crée la FSM ... c'est toute la fonction la plus importante """
	
	# Variables de la FSM
	fichier = ""
	st = "menu-fichier"

	
	while True:

		# Là est toute la magnificience 
		# on rend la main avec l'état actuel (comme ça les gens peuvent
		# savoir où on est) 
		# mais la prochaine exécution ... demande une action à faire
		# (et comme la boucle est infinie ... on revient toujours attendre 
		# à ce point exact de la boucle :-P.
		req = (yield st) # on sauve dans une variable 
		
		if st == "menu-fichier": # Si on est dans le menu-fichier les commandes sont 
			if req == "list":
				# On affiche la liste des fichiers 
				# disponnibles 
				iconsole.afficher (st, persistance.liste_fichiers ())
			elif req == "entrer":
				# Yop, on transite vers l'état menu-variable
				# SI ET SEULEMENT SI l'utilisateur 
				# a sélectionné un fichier !!!
				if fichier != "":
					st = "menu-variable"
				else:
					iconsole.afficher (st,"Vous n'avez pas sélectionné un fichier ...")
			elif req == "help":
				# L'aide affiche la liste des commandes possibles 
				iconsole.afficher (st, "Les commandes sont : « quit », « list », « entrer », « help » et @Fichier")
			else: # C'est un nom de fichier 
				# On suppose que si ce n'est pas une commande, 
				# c'est un nom de fichier, et on change donc 
				# le fichier sélectionné
				fichier = req
				iconsole.afficher (st,"Vous avez sélectionné " + req)
				
		else: # il n'existe que deux états, celui là est donc menu-variable
			# On a forcément définit un fichier,
			# vu que l'on ne peut être arrivé à cet état 
			# QUE par une transition !
			if req == "list":
				# On affiche simplement la liste des variables disponnibles 
				iconsole.afficher (st, persistance.liste_variables (fichier))
			elif req == "up":
				# On retourne au menu fichier ... tout con 
				st = "menu-fichier"
			elif req == "ou":
				# On dit à l'utilisateur où il se trouve, c'est à dire le fichier courant 
				iconsole.afficher (st, "Le fichier courant est : "+ fichier)
			elif req == "help":
				# On affiche la liste des commandes disponnibles 
				iconsole.afficher (st, "Les commandes sont : « quit », « ou », « list », « help », « up » et @Variable")
			else: # C'est une variable 
				# On suppose que si ce n'est pas une commande c'est une variable 
				# à modifier ... Donc on demande la nouvelle valeur 
				# et on modifie ... 
				try:
					iconsole.afficher (st, "Valeur actuelle : " + str (persistance.get_propriete (fichier,req)))
				except:
					iconsole.afficher (st, "Nouvelle variable !")
				val = iconsole.demander (st,"Nouvelle valeur")
				persistance.set_propriete (fichier,req,val)
				iconsole.afficher (st,"Bien modifié !")
Пример #5
0
	persistance.init ()

	# On crée une machine comme définit en début de fichier 
	machine = gen_fsm ()
	
	#st = machine.next () # premier yield, pour savoir le nom de l'état et initialiser le générateur
	
	st = next (machine)

	# La boucle infinie ... moche !
	while True:
		# On actualise l'état courant à chaque
		# tour de boucle ... 
		
		# Un prompt personnalisé, demande une commande 
		req = iconsole.demander (st, "Commande")
		
		# Ici on fait un switch entre les états 
		# C'est là que se déroule toutes les 
		# redirections ... Je ne sais pas trop comment 
		# faire cela autrement :-)
		
		# Quelque soit l'état ... on peut quitter ! :-)
		if req == "quit":
			break # On sort de la boucle, sauve, et quitte le programme 
		
		st = machine.send (req) # on l'envoie à la machine
	# Une fois la boucle terminée, on doit 
	# sauver les modifications (sinon c'est con nan ?)
	persistance.save ()