Hello j'ai un code pygame qui permet de "mettre" la nuit en fonction du nombre de minutes actuel.

J'ai donc fait un truc comme ca :

#requete pour le temps traduit uniquement en heures pour savoir
#si on est la nuit ou non et faire apparaitre les monstres ou pas
heure_in_sec = time.localtime(time.time())
heure        = time.strftime('%H %M')
h_liste      = heure.split(' ')
if   h_liste[1] in (8, 17, 22, 31, 40, 48, 59): transparence = 80
elif h_liste[1] in (6, 15, 20, 29, 38, 46, 57): transparence = 90
elif h_liste[1] in (4, 13, 18, 27, 36, 44, 55): transparence = 100

Donc ici je fais une récupération de l'heure dans mon while pour avoir une mise à jour (j'ai pas mis le while il fait 800 lignes), et l'indice 1 est celui des minutes récupérées et splittés avec les heures dans une liste.

Mon code est bcp trop répétitif dans j'ai pas tout mis non plus et j'aimerai savoir si il y aurait une méthode plus légère, moins lourde que des if in (tuple) set transparence.

Merci de votre aide.

PS: au lieu de changer le niveau de transparence toutes les 2 minutes, j'ai pensé à faire tous les tours de boucles avec 255 / nombres de secondes dans mes cycles (je vais donc devoir uniformiser mon tuple) pour avoir quelque chose de plus réel.

Quel est le lien entre les nombres à l'intérieur des tuples ?

Edit: Peut être que ça peut t'aider:

>>> times = {(8, 17, 22, 31, 40, 48, 59): 80,
             (6, 15, 20, 29, 38, 46, 57): 90,
             (4, 13, 18, 27, 36, 44, 55): 100}
>>> try:
        transparence = (times[x] for x in times if int(time.strftime("%H %M")[-2:]) in x)[0]
except: pass

-
Edité par Anonyme 10 septembre 2014 à 19:43:49

C'est le nombre à laquelle il faut appliquer tel ou tel niveau de transparence.

Merci

-
Edité par Anonyme 10 septembre 2014 à 19:47:43

Permet-moi tout d'abord de te rappeler de mettre tes sujets en "résolu" lorsque tu as trouvé la réponse à ta question.

Je ne comprends pas vraiment ce que tu veux faire, et ça m'a l'air de toute façon un peu compliqué. À ta place, je ferais plutôt un truc du genre:

- créer une liste constante contenant les différents niveaux de luminosité (ou de transparence) au fil de la journée (cette liste peut être remplie soit à la main, soit avec une fonction mathématique adaptée)

- la luminosité à l'instant t est donnée par l'élément de cette liste à l'index t. Le pas (différence entre deux valeurs consécutives) de t dans la liste est choisi au plus adapté (par exemple, la durée de la journée divisée par 256 ou 512) 

from math import cos, pi

# Liste des valeurs de la transparence au fil de la journée
TRANSPARENCES = [int((cos(2*pi*x/DUREE_JOURNEE) + 1)*127.5) for x in range(DUREE_JOURNEE)]

temps %= DUREE_JOURNEE # On repart à 0 à la fin de la journee

# On récupère à chaque bouclela valeur de la luminosité
luminosite = TRANSPARENCES[int(temps)]

 Sinon, réexplique-moi ta solution, je ne la comprends pas très bien, peut-être parce que je suis bouché (qui a dit ça  ???)

Salut,

Je te vois sur tout les fronts: pygame, tkinter, sockets, etc...

Tu devrais ralentir, et commencer par apprendre les bases de python (en toute objectivité). Tes solutions m'ont l'air à chaque fois "extrémistes": une boucle while de ..... 800 LIGNES . Tu n'automatise pas bien tes codes (énormément de code répétitif: un exemple).

PS: Regarde-tu les réponses qu'on poste sur tes nombreux autres sujets? Et puis tu as déjà ouvert un sujet sur l'obscurcissement de ton image

Sinon pour ton problème, ça va dépendre énormément de comment tu gère le temps dans ton jeu? Est-ce du tour par tour? Dans ce cas, attendre un certain nombre de tours est une bonne solution. Par contre utiliser le module time le serait pour une gestion réel du temps. A chaque tour de boucle, tu pourrai faire une différence entre 2 intervalles de temps et si celui-ci est assez grand, tu peux faire la transition.

Ah d'acc. Ben je t'ai pas donné un bon truc alors . Je pige pas ton code. Tu me dis que ce qu'il y a à l'intérieur des tuples c'est le niveau de transparence à appliquer alors que dans ton code tu dit:

Je récupère les heures et les minutes sous la variable h_liste

Si le nombre de minute en string est un nombre parmi l'ensemble
{8, 17, 22, 31, 40, 48, 59}, alors le niveau de transparence devient 80.

Sinon si le nombre de minute en string est un nombre parmi l'ensemble
{6, 15, 20, 29, 38, 46, 57}, alors le niveau de transparence devient 90.

Sinon si le nombre de minute en string est un nombre parmi l'ensemble
{4, 13, 18, 27, 36, 44, 55}, alors le niveau de transparence devient 100.

Déjà c'est étrange car tu cherche si un string est un int, ensuite c'est pas du tout ce que tu veux faire si j'ai bien compris.

Edit: j'ai mis trois heures à écrire mon message 

-
Edité par Anonyme 10 septembre 2014 à 20:00:13

tatrats a écrit:

Permet-moi tout d'abord de te rappeler de mettre tes sujets en "résolu" lorsque tu as trouvé la réponse à ta question.

Je ne comprends pas vraiment ce que tu veux faire, et ça m'a l'air de toute façon un peu compliqué.

Je souhaite faire une journée qui je pense durera 10 minutes et qu'au fur et à mesure, la transparence de mon sprite bleu baisse pour faire comme un voile et donner une impression de nuit.

Olygrim a écrit:

Salut,

Je te vois sur tout les fronts: pygame, tkinter, sockets, etc...

Tu devrais ralentir, et commencer par apprendre les bases de python (en toute objectivité). Tes solutions m'ont l'air à chaque fois "extrémistes": une boucle while de ..... 800 LIGNES . Tu n'automatise pas bien tes codes (énormément de code répétitif: un exemple).

Les bases, merci, je les connais bien (je pense) . Une while de 800 ligne car j'ai encore un problème avec d'autres listes qui me prennent quasiment 400 lignes et pis je gère beaucoup d'évenements différents (trop ?) Je suis sur beaucoup de bibliothèques différentes car il y a des choses que je ne comprend pas, donc je demande, mais j'ai souvent des problèmes épineux (si je postais tous mes problèmes, je pense que le forum serait pollué à 100% )

Olygrim a écrit:

Sinon pour ton problème, ça va dépendre énormément de comment tu gère le temps dans ton jeu? Est-ce du tour par tour? Dans ce cas, attendre un certain nombre de tours est une bonne solution. Par contre utiliser le module time le serait pour une gestion réel du temps. A chaque tour de boucle, tu pourrai faire une différence entre 2 intervalles de temps et si celui-ci est assez grand, tu peux faire la transition.

Ce n'est pas du tour par tour mais du temps réel. En appliquant ce que tu me proposes j'ai peur que le jeu bloque en attendant que le temps soit correcte (peut être que je me trompe mais vu que cela m'a bloqué un programme en C, j'ai un peu peur ).

AlphaZeta a écrit:

Déjà c'est étrange car tu cherche si un string est un int, ensuite c'est pas du tout ce que tu veux faire si j'ai bien compris.

Ah oui j'ai du me planter , je vais corriger ca, merci  .

Je pense que la meilleure solution soit d'utiliser la magie des fonctions:

import time, math

while True:
	time.sleep(1)
	x = int(time.strftime("%H %M")[-2:])
	print(int(math.cos((x - 5) / 3.18) * 50 + 50))

-
Edité par Anonyme 13 septembre 2014 à 10:09:24

Merci

Sans vouloir te harceler:

- il n'est pas normal que ton while fasse 800 lignes : tu ne dois y mettre que la gestion des événements et l'appel des fonctions d'affichage et de gestion du jeu (déplacement, IA...), sachant que pour chaque événement, tu ne devrais pas dépasser disons, trois à quatre lignes de code, au-delà desquelles tu mets le tout dans une fonction que tu appelles dans la boucle

- tu ne me sembles pas très au point en python. Je pense que le minimum vital pour faire un jeu de l'ampleur du tien (si je comprends bien, 3d isométrique, monstres, cycles jour-nuit, et bien d'autres encore) c'est de connaître sur le bout des doigts conditions, boucles, fonctions, classes (y compris méthodes spéciales et héritage), connaître parfaitement tous les types standard pour trouver la meilleure solution à chaque problème, savoir se servir de la bibliothèque standard, et, pourquoi pas, connaître les métaclasses et les décorateurs (mais tu peux tout à fait t'en passer)

- que tu veuilles ou non suivre mes deux conseils précédents (aussi importants soient-ils), suis celui-là. Je peux te dire ça car j'ai moi-même fait l'erreur de faire le contraire. Ne te lance pas dans un gros projet (c'en est un) tête baissée. Prends avant le temps de réfléchir à la structure de ton programme, à tes priorités de codage, et ne fais pas de code "figé", mais des sous-parties indépendantes les unes des autres pour ne pas avoir besoin de tout recoder dès que tu changes une petite chose. Dernier conseil, pour en avoir moi-même fait les frais, commente toujours ton code, même si "personne ne le verra", ou "bôf, je comprendrai". En plus, commenter le code permet d'éviter le : "j'ai tapé au pif, je ne sais pas comment ça fonctionne, mais puisque ça fonctionne je le garde"

tatrats a écrit:

Sans vouloir te harceler:

- il n'est pas normal que ton while fasse 800 lignes : tu ne dois y mettre que la gestion des événements et l'appel des fonctions d'affichage et de gestion du jeu (déplacement, IA...), sachant que pour chaque événement, tu ne devrais pas dépasser disons, trois à quatre lignes de code, au-delà desquelles tu mets le tout dans une fonction que tu appelles dans la boucle

- tu ne me sembles pas très au point en python. Je pense que le minimum vital pour faire un jeu de l'ampleur du tien (si je comprends bien, 3d isométrique, monstres, cycles jour-nuit, et bien d'autres encore) c'est de connaître sur le bout des doigts conditions, boucles, fonctions, classes (y compris méthodes spéciales et héritage), connaître parfaitement tous les types standard pour trouver la meilleure solution à chaque problème, savoir se servir de la bibliothèque standard, et, pourquoi pas, connaître les métaclasses et les décorateurs (mais tu peux tout à fait t'en passer)

- que tu veuilles ou non suivre mes deux conseils précédents (aussi importants soient-ils), suis celui-là. Je peux te dire ça car j'ai moi-même fait l'erreur de faire le contraire. Ne te lance pas dans un gros projet (c'en est un) tête baissée. Prends avant le temps de réfléchir à la structure de ton programme, à tes priorités de codage, et ne fais pas de code "figé", mais des sous-parties indépendantes les unes des autres pour ne pas avoir besoin de tout recoder dès que tu changes une petite chose. Dernier conseil, pour en avoir moi-même fait les frais, commente toujours ton code, même si "personne ne le verra", ou "bôf, je comprendrai". En plus, commenter le code permet d'éviter le : "j'ai tapé au pif, je ne sais pas comment ça fonctionne, mais puisque ça fonctionne je le garde"

Non t'inquiètes un conseil est toujours le bienvenu

Pour les fonctions je pense les faire bientot, au début le projet etait tout bete tout simple et je ne pensais avoir besoin d'en mettre. J'y réfléchis depuis plusieurs jours justement.

Ahah ! Ce n'est pas un gors projet 2680 lignes pour un jeu de base, si ? J'ai un cahier des charges je ne me lance pas tête baissée même si j'en donne l'impression, et commenter je vais le faire de se pas (ps: je t'ai mp)

Merci à toi

-
Edité par Anonyme 10 septembre 2014 à 21:07:22

Un petit exemple de la puissance python:

#Dico qui contient les mouvements
dico_mvt = {"K_UP":((10, 10), (-10, 10)), "K_LEFT": ((-10, 10), (-10, -10)),
"K_DOWN": ((-10, -10), (10, -10)), "K_RIGHT": ((10, -10), (10, 10))}

#Fonction de mise à jour des coordonnées
def fonction_mvt(dico):
    this_is_a_rect.topK_LEFT     = dico[0]
    this_is_a_rect.topK_RIGHT    = dico[1]
    this_is_a_rect.bottomK_LEFT  = dico[1]
    this_is_a_rect.bottomK_RIGHT = dico[0]
    print("{0} {1} {1} {0}".format(dico[0], dico[1]))

#Les conditionnelles de manière classique
if event.key == K_UP:
    fonction_mvt(dico_mvt["K_UP"])
elif event.key == K_LEFT:
    fonction_mvt(dico_mvt["K_LEFT"])
elif event.key == K_DOWN:
    fonction_mvt(dico_mvt["K_DOWN"])
elif event.key == K_RIGHT:
    fonction_mvt(dico_mvt["K_RIGHT"])

#Ou de manière plus stylé
if event.key in [K_UP, K_LEFT, K_DOWN, K_RIGHT]:
    fonction_mvt(dico_mvt["{}".format(event.key)])


#Et si les K_UP, K_LEFT, ... peuvent être entré directement comme clé de
#dictionnaire (sans les convertir en chaîne), alors le code devient:
dico_mvt = {K_UP:((10, 10), (-10, 10)), K_LEFT: ((-10, 10), (-10, -10)),
K_DOWN: ((-10, -10), (10, -10)), K_RIGHT: ((10, -10), (10, 10))}

if event.key in [K_UP, K_LEFT, K_DOWN, K_RIGHT]:
    fonction_mvt(dico_mvt[event.key])

Par rapport à ton propre code:

if event.key == K_UP :
    x_positive += 10
    x_negative += -10
    y_positive += 10
    top_left_     = (x_positive, y_positive)
    top_right_    = (x_negative, y_positive)
    bottom_left_  = (x_negative, y_positive)
    bottom_right_ = (x_positive, y_positive)
    this_is_a_rect.topleft     = top_left_
    this_is_a_rect.topright    = top_right_
    this_is_a_rect.bottomleft  = bottom_left_
    this_is_a_rect.bottomright = bottom_right_
    print("{} {} {} {}".format(top_left_, top_right_, bottom_left_, bottom_right_))
#on doit changer toutes les valeurs en fait
elif event.key == K_LEFT:
    x_negative += -10
    y_positive += 10
    y_negative += -10
    top_left_     = (x_negative, y_positive)
    top_right_    = (x_negative, y_negative)
    bottom_left_  = (x_negative, y_negative)
    bottom_right_ = (x_negative, y_positive)
    this_is_a_rect.topleft     = top_left_
    this_is_a_rect.topright    = top_right_
    this_is_a_rect.bottomleft  = bottom_left_
    this_is_a_rect.bottomright = bottom_right_
    print("{} {} {} {}".format(top_left_, top_right_, bottom_left_, bottom_right_))
elif event.key == K_DOWN:
    x_positive += 10
    x_negative += -10
    y_negative += -10
    top_left_     = (x_negative, y_negative)
    top_right_    = (x_positive, y_negative)
    bottom_left_  = (x_positive, y_negative)
    bottom_right_ = (x_negative, y_negative)
    this_is_a_rect.topleft     = top_left_
    this_is_a_rect.topright    = top_right_
    this_is_a_rect.bottomleft  = bottom_left_
    this_is_a_rect.bottomright = bottom_right_
    print("{} {} {} {}".format(top_left_, top_right_, bottom_left_, bottom_right_))
elif event.key == K_RIGHT:
    x_positive += 10
    y_positive += 10
    y_negative += -10
    top_left_     = (x_positive, y_negative)
    top_right_    = (x_positive, y_positive)
    bottom_left_  = (x_positive, y_positive)
    bottom_right_ = (x_positive, y_negative)
    this_is_a_rect.topleft     = top_left_
    this_is_a_rect.topright    = top_right_
    this_is_a_rect.bottomleft  = bottom_left_
    this_is_a_rect.bottomright = bottom_right_
    print("{} {} {} {}".format(top_left_, top_right_, bottom_left_, bottom_right_))

L'objectif n'est bien évidemment pas de se moquer. Juste te faire comprendre qu'il faut voir les fondamentaux (les boucles: for et while, les objets de base: liste, tuple, chaine, dictionnaire, et leurs méthodes: append, remove, ..., les fonctions et l'espace des noms) pour pleinement apprécier de programmer en python, et de se lancer en toute sereinité dans un projet comme le tien.

@Olygrim,

Dans ton code, je pense que tu peux éviter ligne 14 à 21 en modifiant tes clés de la variable dico_mvt.

Si tu changes par exemple "K_UP" par K_UP, et ainsi de suite, il te suffira de remplacer tes lignes 14 à 21 par une seule ligne

fonction_mvt(dico_mvt[event.key])

Et bien évidemment toutes les conséquences qui s'en suivent pour la suite du code...

@oldP

 C'est exactement ce que j'ai mis à la fin de mon code. Mais comme je ne sais pas si les K_UP sont acceptés comme clé (j'ai pas testé), je lui ai mis les 2 solutions 

Ah oui j'ai pas regardé la suite, je pensais comme tu n'as pas séparé (ce qui aurait été préférable), à un seul code, cela rend difficilement lisible après coup

K_UP est une variable, il n'y a pas de raison que se soit non fonctionnel en tant que clé de dictionnaire

-
Edité par Anonyme 10 septembre 2014 à 22:32:20