[Topique d'entraide] Le défi de Xuanwu
Posté le 24/09/2020 18:57
Bonjours à toutes et à tous, et bienvenue sur le topique d'entraide pour
le premier défi python du concours de rentrée 2020
Vous pouvez partager ici vos astuces, idées ou découverte, ou voir ce que les autres font. Rappelons tout de même que de poster directement des solutions est considéré comme de la triche et est donc
interdit (du moins c'était le cas il y a deux ans et aucunes idée pur cette année
)
Tout d'abord, le défi cette année semble être de guider à travers un labyrinthe une machine à coup de tourner à gauche/droite d'un angle θ et avancer. Pour avoir une participation valide, il faut compléter le labyrinthe, et pour gagner, faire ceci avec le minimum d'énergie/score (un peu de patience, j'y viens).
On a donc 3 fichiers à notre disposition:
- labytest.py qui sert à soumettre votre proposition
- polycalc.py qui permet d'uniformiser le dessin sur tous les modèles et floutant la limite entre la folie et le génie
- laby.py celui qui nous intéresse, contenant les fonctions de mouvement/calculs de score.
Maintenant que les banalités sont sous le tapis passons à la partie plus intéressante, celle ou je vous décortique le programme
Donc, il y a beaucoup de chose dans ce court fichier:
- De nombreuse fonction pour le hasard, elles servent à créer le labyrinthe afin qu'il soit généré procéduralement (mais comme tout le monde a la même seed minecraft, on a tous le même) pas grands chose à creuser de ce côté
- quelques fonctions de tracés, aucun commentaire.
Concentrons-nous à présent sur comment agir sur l'environnement:
- La foreuse est représentée par une liste de 7 nombres:
- X, Y, θ, une copie de X, une copie de Y, et score1, score2 et score3 (plus connues sous le nom
state[i] dans le code)
- Les fonctions tourner vont changer θ du nombre de radian indiqué dans le sens horaire (droite) ou anti-horaire (gauche).
- La fonction avancer va effectuer des pas en avant de 0.25 (selon l'angle θ actuel).
Enfin le score:
- Le score final est calculé en faisant score1 moins la division euclidienne de score2 par deux plus le sinus de score3(
score = scrore1 - score2//2 + sin(score3))
- Touner de θ augmente score1 par
5 +cout(θ) et de score3 de θ
- Avancer augmente score1 de
8+cout(l) et score3 de
l
- Avancer augmente score2 de 1 par pas de 0.25, soit de
4*l au total (et donc diminue le score final de
2*l ramené à l'entier inférieur)
- Si vous rencontrez un mur, score1 augmente de 15 et la fonction s'arrête (ne vous donnant pas vos points dans score2)
La fonction
cout est en fait la suivante:
def cout(a):
return len(str(round(abs(x)/1.,5)
Donc dans l'ordre:
-
abs met votre nombre a la valeur absolue
-
/1. convertie ce dernier en nombre a virgule
-
round ne garde que 5 chiffres après la virgule
-
str transforme le tout en chaine de caractères
-
len renvois la longueur de cette chaine de caractères
Ce que cela signifie, c'est que
score1 augmentera du nombre de caractères dans
a, mais:
- le potentiel signe moins est ignoré
- 1 est convertie en 1.0, donc niveau score c'est la même que 1.2
- les chiffres ne sont comptés que jusqu'à 5 place après la virgule
Enfin derniers détails:
-
score2 ne peut pas être plus grand que 200.
-
fix_angle(a) renvoi
a
Et voilà, c'est tout pour moi, la stratégie semble donc de faire les plus grandes lignes droites possibles avec le minimum de virages.
Sur ce bonne chance et que la meilleure gagne ♥
Citer : Posté le 24/09/2020 19:00 | #
C'était rapide hehehe.
Je remet du coup.
Coucou.
Les angles utilisés par a_gauche et a_droite sont exprimés en radians.
Ajouter cette ligne après import permet de taper les fonctions plus vite sur calto (j'ai vu que c'était possible direct dans l'import mais je préfère comme ça).
C'est très basique mais faut bien commencer quelque part.
Citer : Posté le 24/09/2020 19:03 | #
Merci beaucoup Hackell ! Tu n'as fait que confirmer ce que je pensais déjà concernant la stratégie, mais merci beaucoup pour l'explication du code
Bonne chance à tous !
Citer : Posté le 25/09/2020 08:36 | #
mis à jour pour prendre en compte les changement de la v3 du script 💜
Citer : Posté le 25/09/2020 10:21 | #
Code compatible v3 J'en fait de trop ?
from math import sin, cos, asin, pi
from polycalc import *
import pygame
from pygame.locals import *
def ri(a,b):
global s
s = (s * 214013 + 2531011) % 4294967296
r = (s // 65536) & 0x7fff
return r % (b-a) + a
def mon_secret(v, b, n):
return v & ~(b * 2**n)
def mon_xor(a, b):
return a + b - (a & b)
def fix_angle(a):
return a * 2 * asin(1) / pi
def ufl(r):
global rl
i, s = r // 3, 10 * (r % 3)
rep = rl[i]//2**s & 1023
if rep != r:
rep = ufl(rep)
rl[i] = mon_secret(rl[i], 1023, s)
s = rep * 2**s
rl[i] = mon_xor(rl[i], s)
return rep
def ufm(r1, r2):
global rl
i, r1 = r1 // 3, 10 * (r1 % 3)
r2 *= 2**r1
rl[i] = mon_secret(rl[i], 1023, r1)
rl[i] = mon_xor(rl[i], r2)
def cout(x):
return len(str(round(abs(x)/1.,5)))
def a_gauche(a):
global state
state[7] += a
state[5] += 5 + cout(a)
state[2] -= a
def a_droite(a):
state[7] += 2 * a
a_gauche(-a)
def avancer(l):
global state
t = fix_angle(state[2])
dx, dy = cos(t), sin(t)
state[7] += l
state[5] += 8 + cout(l)
while(l > 0):
state[3:5] = state[0:2]
x, y = state[0] + dx/4, state[1] + dy/4
ix, iy = int(x) - (x < 0), int(y) - (y < 0)
drx, dry = ix - int(state[3]), iy - int(state[4])
vw = lambda y, x: wl[y] & 2**x
hw = lambda y, x: wl[y + laby_h] & 2**x
wx = laby_w - 2 - min(ix, ix - drx)
tx = drx and (ix < 0 or ix >= laby_w or vw(iy - dry, laby_w - 2 - min(ix, ix - drx)))
ty = dry and (iy < 0 or iy >= laby_h or hw(min(iy, iy - dry), laby_w - 1 - (ix - drx)))
t = dx <= 0 or int(x) < laby_w - 1 or int(y) < laby_h - 1
if t and tx or ty or (drx and dry and (t and tx or ty)) or (drx and dry and (t and vw(iy, laby_w - 2 - min(ix, ix - drx)) or hw(min(iy, iy - dry), laby_w - 1 - ix))):
state[5] += 15
return
l -= .25
state[6] += (state[6] < 200)
state[0:2] = (x, y)
draw_line(state[3] * zx, state[4] * zy, state[0] * zx, state[1] * zy, colors[4])
laby_w, laby_h = 20, 12
s = 0xdeadbeef
rl = [(3*i + 2)*1048576 + (3*i + 1)*1024 + 3*i for i in range(laby_w*laby_h + 2//3)]
wl = [(2**(laby_w + 1) - 1) // (1 + (k < laby_h)) for k in range(2*laby_h - 1)]
cl = laby_w * laby_h
while cl > 1 - (laby_w * laby_h)//100*10:
y = ri(0, 2*laby_h - 1)
x = ri(0, laby_w - (y < laby_h))
if wl[y] & 2**x:
if y < laby_h:
r1 = y*laby_w + x
r2 = r1 + 1
else:
r1 = (y - laby_h)*laby_w + x
r2 = r1 + laby_w
rl1, rl2 = ufl(r1), ufl(r2)
if rl1 != rl2 or cl <= 1:
ufm(rl1, rl2)
cl -= 1
wl[y] = mon_secret(wl[y], 1, x)
for r in range(laby_w * laby_h):
ufl(r)
#screen_w, screen_h, poly_set_pixel, poly_draw_line, poly_fill_rect, poly_clean_screen, poly_show_screen = get_infos()
ratio = 3
screen_w = 384*ratio
screen_h = 192*ratio
ds = 4
zint = 1 + (screen_w > 2*laby_w*ds)
ds += zint - 1
zx, zy = (screen_w - zint) / laby_w, (screen_h - zint) / laby_h
#get_infos, poly_set_pixel, rl, ufl, ufm = None, None, None, None, None
colors = ([0, 95, 0], [0, 0, 63], [0, 200, 0], [0, 0, 255], [255, 0, 0])
pygame.init()
pygame.mixer.quit()
pygame.display.set_caption('Concours')
fenetre = pygame.display.set_mode((screen_w,screen_h))
def draw_line(x1, y1, x2, y2, c):
pygame.draw.line(fenetre, (c),(x1, y1), (x2, y2))
pygame.display.update()
def clean_screen():
fenetre.fill([255,255,255])
def fill_rect_v(x, y, w, h, c):
pygame.draw.rect(fenetre, c, Rect(x, y, 3, 15*ratio))
def fill_rect_h(x, y, w, h, c):
pygame.draw.rect(fenetre, c, Rect(x, y, 15*ratio+10, 3))
def aller_selon(f, affiche):
global state
state = [0, .5, 0, 0, .5, 0, 0, 0]
clean_screen()
for i in range(2):
fill_rect_v(0, i * laby_h * zy, laby_w * zx, zint, colors[1])
fill_rect_h(i * laby_w * zx, (not i) * zy, zint, (laby_h - 1) * zy, colors[0])
for y in range(2*laby_h - 1):
for z in range(laby_w - (y < laby_h)):
if wl[y] & 2**z:
x = laby_w - 1 - z
if y < laby_h:
fill_rect_v(x * zx, y * zy, zint, zy, colors[2])
else:
fill_rect_h(x * zx, (y - laby_h + 1) * zy, zx, zint, colors[3])
f()
boucle=False
while not boucle and affiche:
for event in pygame.event.get():
if event.type==QUIT:
boucle=True
pygame.display.update()
state[5] += sin(fix_angle(state[7])) - state[6] // 2
print('Consommation : ' + str(state[5]))
if state[0] >= laby_w:
print('------------ GG ! -----------')
print('info@tiplanet.org.')
return state[5]
Ajouté le 25/09/2020 à 10:23 :
J'aime beaucoup regarder l'avancement des scores en fonction de chaque action, et je peux vous dire que c'est fort intéressant
Citer : Posté le 25/09/2020 11:30 | # |
Fichier joint
Histoire de vous aider un peu plus
Citer : Posté le 25/09/2020 12:22 | #
T'as oublié quelques passages en haut à droite !
Citer : Posté le 25/09/2020 14:52 | #
Taper sur calculette c'est lourd, j'ai adapté la fonction getinfo() du script numworks pour utiliser le module tkinter et pouvoir travailler directement sur PC :
racine = tk.Tk()
canv = tk.Canvas(racine, bg="white", height=440, width=640)
canv.pack()
def conversion(nombre):
dictionnaire=["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"]
return dictionnaire[nombre//16]+dictionnaire[nombre%16]
def col3_2_rgb(c, bits, bgr):
return c[2*bgr]//2**(8 - bits[0]) + c[1]//2**(8 - bits[1])*2**bits[0] + c[2*(not bgr)]//2**(8-bits[2])*2**(bits[0] + bits[1])
def kc16_draw_line(x1, y1, x2, y2, c):
draw_line(int(x1), int(y1), int(x2), int(y2), col3_2_rgb(c, [5, 6, 5], 1))
def get_infos():
global kc16_draw_line
fnop = lambda : None
screen_w, screen_h, color_bits, poly_set_pixel, poly_draw_line, poly_fill_rect, poly_clean_screen, need_clean, need_line, need_rect = 0, 222, [5, 6, 5], fnop, fnop, fnop, fnop, 0, 1, 1
try:
if chr(256)==chr(0): # KhiCAS Python compat.
need_line = 0
need_clean = 1
screen_w = 320
def poly_set_pixel(x, y, c):
set_pixel(x, y, col3_2_rgb(c, [5,6,5], 0))
poly_draw_line = kc16_draw_line
except:
pass
if not screen_w:
kc16_draw_line = None
try: # KhiCAS Micropython
import graphic
def poly_draw_line(x1, y1, x2, y2, c):
graphic.draw_line(int(x1), int(y1), int(x2), int(y2), col3_2_rgb(c, color_bits, 1))
def poly_fill_rect(x1, y1, x2, y2, c):
graphic.draw_filled_rectangle(int(x1), int(y1), int(x2), int(y2), c)
screen_w, poly_set_pixel, need_clean, need_line, need_rect = 320, graphic.set_pixel, 1, 0, 0
except:
pass
if not screen_w:
try: # NumWorks
print("numworks détectée")
screen_w, need_rect = 320, 0
def poly_set_pixel(x,y,c):
canv.create_rectangle(2*int(x), 2*int(y), 2*(int(x)+1), 2*(int(y)+1), fill="#"+conversion(c[0])+conversion(c[1])+conversion(c[2]))
def poly_fill_rect(x, y, w, h, c):
canv.create_rectangle(2*int(x), 2*int(y), 2*(int(x)+int(w)), 2*(int(y)+int(h)), fill="#"+conversion(c[0])+conversion(c[1])+conversion(c[2]))
except:
pass
if need_line:
def poly_draw_line(x1, y1, x2, y2, c):
m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2)
if (x2 - x1) ** 2 < (y2 - y1) ** 2:
m, a1, a2, b1, b2 = 1, b1, b2, a1, a2
if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1
for k in range(a2 - a1 + 1):
a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1))
poly_set_pixel((a, b)[m], (b, a)[m], c)
if need_rect:
def poly_fill_rect(x, y, w, h, c):
for k in range(h):
poly_draw_line(x, y + k, x + w - 1, y + k, c)
if need_clean:
def poly_clean_screen():
poly_fill_rect(0, 0, screen_w, screen_h, [255, 255, 255])
return screen_w, screen_h, poly_set_pixel, poly_draw_line, poly_fill_rect, poly_clean_screen, fnop
Citer : Posté le 25/09/2020 16:20 | #
Il y a beaucoup d'histoire du genre "j'ai pas le même score sur caltos que sur PC" en, ce moment.
La raison est simple, votre ordi et la calculatrice ne vont pas arrondir les flottant de la même maniére, là ou un 0.97 reste un 0.97 sur pc, votre calculatrice ni verra qu'un 0.9699999999999999999 ce qui une fois passer dans cout (qui compte le nombre de caractére et l'ajoute à votre score) augmente votre score de... beaucoup! Faites ça plusieurs fois et la différence devient enorme!!
Donc méfier vous et si vous avez une solution, dites-le
Citer : Posté le 25/09/2020 17:16 | #
Il y a beaucoup d'histoire du genre "j'ai pas le même score sur caltos que sur PC" en, ce moment.
La raison est simple, votre ordi et la calculatrice ne vont pas arrondir les flottant de la même maniére, là ou un 0.97 reste un 0.97 sur pc, votre calculatrice ni verra qu'un 0.9699999999999999999 ce qui une fois passer dans cout (qui compte le nombre de caractére et l'ajoute à votre score) augmente votre score de... beaucoup! Faites ça plusieurs fois et la différence devient enorme!!
Donc méfier vous et si vous avez une solution, dites-le
Pour l'instant j'ai 440 sur PC et 440.94 sur calculatrice. Je dirais donc que l'écart est acceptable. Mais je ne comprends pas comment font les hiscores !
Citer : Posté le 25/09/2020 17:31 | #
Personnellement, j'ai obtenu 148 sur calculatrice et 134 sur PC, donc il y avait quand même une différence de 14, ce qui est énorme
PM Générateur
graph100+ bleue
Neuronix9302
2nde GT
Citer : Posté le 25/09/2020 17:34 | #
Euh là je suis perplexe parce que les flottants qu'on manipule sont tous en précision complète, et toutes les fonctions sont uniformément continues ; y'a absolument zéro piège de précision.
Citer : Posté le 25/09/2020 17:38 | #
Les flottants Python des Casio/NumWorks/TI sont au standard double précision, c'est-à-dire que la précision est codée sur 53 bits.
Les résultats sont absolument identiques d'un modèle à l'autre.
Nous lions des émulateurs utilisables gratuitement.
Vous avez parfaitement le droit d'utiliser autre chose, mais c'est alors à vous de tenir compte de la différence de précision dans un sens ou dans l'autre.
Citer : Posté le 25/09/2020 17:39 | #
non, c'est normal, cout(0.97) renvoi 4 sur pc et 18 sur calculatrice, soit 14 de difference. il a juste dû tomber sur un nombre similaire
Citer : Posté le 25/09/2020 17:40 | #
Cependant il est évident que le str() MicroPython n'a pas le comportement élégant de non-ambiguité que le Python distribué sur PC utilise. Pour l'éviter il serait malin (mais je pense que c'est un peu tard) de préférer round(x*1e5) à round(x,5) puisque les entiers sont toujours représentables exactement.
Citer : Posté le 25/09/2020 17:40 | #
Je sais bien, je ne suis pas en train de critiquer et je suis totalement d'accord avec ça.
Mais le plus bizarre étant que c'est lors d'une unique étape que mon score PC et calculatrice devient différent, et directement avec un écart de 14.
Je ne vois vraiment pas d'où ça peut venir, puisque la précision n'impacte pas, étant la même
Edit : je n'ai rien dit, je n'avais pas vu le message de Hackcell
PM Générateur
graph100+ bleue
Neuronix9302
2nde GT
Citer : Posté le 25/09/2020 17:44 | #
Cependant il est évident que le str() MicroPython n'a pas le comportement élégant de non-ambiguité que le Python distribué sur PC utilise. Pour l'éviter il serait malin (mais je pense que c'est un peu tard) de préférer round(x*1e5) à round(x,5) puisque les entiers sont toujours représentables exactement.
Si ça te convient et qu'en prime ça arrange les candidats, je peux parfaitement l'introduire dans la v4.
Citer : Posté le 25/09/2020 17:46 | #
Disons que ça va modifier quelques scores, mais normalement que les améliorer. Si tu penses que c'est acceptable pour le concours, vas-y. J'avoue que j'ai toujours peur de modifier le code après le lancement... j'espère que ça ne contrariera personne sur le classement encore primitif.
Edit : Oublie pas d'enlever les 0 à la fin dans ce cas.
Citer : Posté le 25/09/2020 19:05 | #
Coucou, encore moi : Pour plus de rapidité, voici :
LA V2 DE LA V3 DU PROGRAMMEJ'ai plus de voix
Il affiche maintenant le score et le "GG"
J'ai ajouté to_rad(deg) pour... transformer des degrés en radians
from math import sin, cos, asin, pi
from polycalc import *
import pygame
from pygame.locals import *
def ri(a,b):
global s
s = (s * 214013 + 2531011) % 4294967296
r = (s // 65536) & 0x7fff
return r % (b-a) + a
def mon_secret(v, b, n):
return v & ~(b * 2**n)
def mon_xor(a, b):
return a + b - (a & b)
def fix_angle(a):
return a * 2 * asin(1) / pi
def ufl(r):
global rl
i, s = r // 3, 10 * (r % 3)
rep = rl[i]//2**s & 1023
if rep != r:
rep = ufl(rep)
rl[i] = mon_secret(rl[i], 1023, s)
s = rep * 2**s
rl[i] = mon_xor(rl[i], s)
return rep
def ufm(r1, r2):
global rl
i, r1 = r1 // 3, 10 * (r1 % 3)
r2 *= 2**r1
rl[i] = mon_secret(rl[i], 1023, r1)
rl[i] = mon_xor(rl[i], r2)
def cout(x):
return len(str(round(abs(x)/1.,5)))
def a_gauche(a):
global state
state[7] += a
state[5] += 5 + cout(a)
state[2] -= a
def a_droite(a):
state[7] += 2 * a
a_gauche(-a)
def avancer(l):
global state
t = fix_angle(state[2])
dx, dy = cos(t), sin(t)
state[7] += l
state[5] += 8 + cout(l)
while(l > 0):
state[3:5] = state[0:2]
x, y = state[0] + dx/4, state[1] + dy/4
ix, iy = int(x) - (x < 0), int(y) - (y < 0)
drx, dry = ix - int(state[3]), iy - int(state[4])
vw = lambda y, x: wl[y] & 2**x
hw = lambda y, x: wl[y + laby_h] & 2**x
wx = laby_w - 2 - min(ix, ix - drx)
tx = drx and (ix < 0 or ix >= laby_w or vw(iy - dry, laby_w - 2 - min(ix, ix - drx)))
ty = dry and (iy < 0 or iy >= laby_h or hw(min(iy, iy - dry), laby_w - 1 - (ix - drx)))
t = dx <= 0 or int(x) < laby_w - 1 or int(y) < laby_h - 1
if t and tx or ty or (drx and dry and (t and tx or ty)) or (drx and dry and (t and vw(iy, laby_w - 2 - min(ix, ix - drx)) or hw(min(iy, iy - dry), laby_w - 1 - ix))):
state[5] += 15
return
l -= .25
state[6] += (state[6] < 200)
state[0:2] = (x, y)
draw_line(state[3] * zx, state[4] * zy, state[0] * zx, state[1] * zy, colors[4])
laby_w, laby_h = 20, 12
s = 0xdeadbeef
rl = [(3*i + 2)*1048576 + (3*i + 1)*1024 + 3*i for i in range(laby_w*laby_h + 2//3)]
wl = [(2**(laby_w + 1) - 1) // (1 + (k < laby_h)) for k in range(2*laby_h - 1)]
cl = laby_w * laby_h
while cl > 1 - (laby_w * laby_h)//100*10:
y = ri(0, 2*laby_h - 1)
x = ri(0, laby_w - (y < laby_h))
if wl[y] & 2**x:
if y < laby_h:
r1 = y*laby_w + x
r2 = r1 + 1
else:
r1 = (y - laby_h)*laby_w + x
r2 = r1 + laby_w
rl1, rl2 = ufl(r1), ufl(r2)
if rl1 != rl2 or cl <= 1:
ufm(rl1, rl2)
cl -= 1
wl[y] = mon_secret(wl[y], 1, x)
for r in range(laby_w * laby_h):
ufl(r)
#screen_w, screen_h, poly_set_pixel, poly_draw_line, poly_fill_rect, poly_clean_screen, poly_show_screen = get_infos()
ratio = 2
screen_w = 384*ratio
screen_h = 192*ratio
ds = 4
zint = 1 + (screen_w > 2*laby_w*ds)
ds += zint - 1
zx, zy = (screen_w - zint) / laby_w, (screen_h - zint) / laby_h
#get_infos, poly_set_pixel, rl, ufl, ufm = None, None, None, None, None
colors = ([0, 95, 0], [0, 0, 63], [0, 200, 0], [0, 0, 255], [255, 0, 0])
pygame.init()
pygame.mixer.quit()
pygame.display.set_caption('Concours')
fenetre = pygame.display.set_mode((screen_w,screen_h+12*ratio))
font = pygame.font.Font('freesansbold.ttf', 22)
def draw_line(x1, y1, x2, y2, c):
pygame.draw.line(fenetre, (c),(x1, y1), (x2, y2))
pygame.display.update()
def clean_screen():
fenetre.fill([255,255,255])
def fill_rect_v(x, y, w, h, c):
pygame.draw.rect(fenetre, c, Rect(x, y, 3, 15*ratio))
def fill_rect_h(x, y, w, h, c):
pygame.draw.rect(fenetre, c, Rect(x, y, 15*ratio+10, 3))
def aller_selon(f, affiche):
global state
state = [0, .5, 0, 0, .5, 0, 0, 0]
clean_screen()
for i in range(2):
fill_rect_v(0, i * laby_h * zy, laby_w * zx, zint, colors[1])
fill_rect_h(i * laby_w * zx, (not i) * zy, zint, (laby_h - 1) * zy, colors[0])
for y in range(2*laby_h - 1):
for z in range(laby_w - (y < laby_h)):
if wl[y] & 2**z:
x = laby_w - 1 - z
if y < laby_h:
fill_rect_v(x * zx, y * zy, zint, zy, colors[2])
else:
fill_rect_h(x * zx, (y - laby_h + 1) * zy, zx, zint, colors[3])
f()
state[5] += sin(fix_angle(state[7])) - state[6] // 2
print('Consommation : ' + str(state[5]))
if state[0] >= laby_w:
print('------------ GG ! -----------')
print('info@tiplanet.org.')
gg = font.render('GG', True, (128,0,0), (255,255,255))
ggrect = gg.get_rect()
fenetre.blit(gg, (384*ratio-50, 192*ratio + 1))
text = font.render('C:' + str(state[5]), True, (0,0,0), (255,255,255))
textRect = text.get_rect()
fenetre.blit(text, (0, 192*ratio + 1))
boucle=False
while not boucle and affiche:
for event in pygame.event.get():
if event.type==QUIT:
boucle=True
pygame.display.update()
return state[5]
def to_rad(deg):
return deg*pi/180
Citer : Posté le 25/09/2020 19:42 | #
Personnellement, j'ai obtenu 148 sur calculatrice et 134 sur PC, donc il y avait quand même une différence de 14, ce qui est énorme
Je suis descendu à 211, toujours pas d'écart
Citer : Posté le 25/09/2020 23:48 | #
Je veux pas balancer, mais Pavel a fait un script qui aide grandement à la résolution du problème