Concours Python 2022 - Pykaster3D «attrape-les toutes» !

[critor]

Twitch sur Pykaster3D actuellement, avec Radalium, disciple de cent20 :
https://www.twitch.tv/radalium

[critor]

Nouvelle chance si tu as raté les formidables astuces de Radalium et cent20 au twitch de ce matin, nouveau twitch cet après-midi par M4x1m3.
Rendez-vous à 15h pour réussir !
https://www.twitch.tv/m4xi1m3

[RapidZapper]

Etat des équipes en fin de concours, QATW & v601

[critor]

Classement pas tout-à-fait final encore, 4 participants en embuscade ont envoyé des participations juste avant minuit.

Sinon, rediffusion du live twitch où notre grand stratège cent20 a déployé une énergie absolument formidable :
https://www.twitch.tv/videos/1651509707

[critor]

Voilà, normalement tout a été traité.
L'anonymat a été levé, et les scripts soumis sont téléchargeables pour ceux qui le souhaitent :
https://tiplanet.org/concours_pykaster3d_2022.php

Merci à vous tous pour la formidable énergie déployée dans ce concours (j'ai vu passer des twitch très enthousiastes, des outils conçus sur-mesures que vous nous expliquerez bientôt j'espère, ainsi que de grands stratèges en chefs de groupes).

À bientôt...

[critor]

Félicitations donc Afyu pour avoir réussi à sortir nettement du lot avec un score que personne n'a été capable d'approcher par la suite.

Nous attendons de toi :

• le choix de ton lot personnel
• le choix du lot pour le groupe V601 en accord avec tes camarades (vous nous direz ensuite quels éléments envoyer à qui)
• ta narration de recherche

[Afyu]

Pour le choix du lot, je voudrais :

1 lot NumWorks : 1 coque collector NumWorks avec la façade de la NumWorks imprimée + 1 autocollant NumWorks en forme de NumWorks + 1 pack de goodies NumWorks + 1 goodie Calcuso au choix + 1 pack de goodies Xcas + 1 pack de goodies TI-Planète Casio

Pour les goodies :

NumWorks

• 1 goodie NumWorks au choix :
  
  • cahier NumWorks

Calcuso

• 1 goodie Calcuso au choix :
  
  • stylo Calcuso
  

Xcas

• 1 autocollant Xcas
• 1 goodie Xcas au choix :
  
  • aimantin Xcas

TI-Planète-Casio

• 1 aimantin TI-Planet citrouille sur fond noir
• 1 aimantin de meilleur membre du groupe victorieux du concours de la rentrée 2022
• 1 autocollant TI-Planet sans VIP
• 1 autocollant Planète Casio
• 1 compte premium TI-Planet que je donne à qui voudra

[Afyu]

Voici ma méthode pour obtenir mon meilleur score sur le concours de la rentrée 2022 organisé par TI-Planet et Planète-Casio :

Je commence par télécharger l'archive qui contient les fichiers pour participer, installer les quelques modules Python nécessaires au bon fonctionnement des différents scripts et... c'est parti !

Pour ma 1ère partie, je conserve les premières actions qui sont données dans le fichier pyka3d.py et qui permettent de capturer une 1ère souris et je poursuis la partie pour un score final de 1292 points en attrapant toutes les souris que je croise, dans l'ordre où je les croise. Je n'ai croisé aucune souris rouge (donc de niveau supérieur au mien) lors de cette partie.

Je quitte la partie pour récupérer la liste de mes actions et je l'envoie en tant que 1ère participation pour un premier score de... 787 points !

Je relis l'annonce du concours et me rends compte qu'il faut ajouter la liste des actions retournée dans la console au moment de quitter la partie à la liste déjà présente dans le fichier pyka3d.py.

Bon, je rectifie et renvoie la bonne liste pour un score de 1292 points.

Je retente et fais 1354 points avec 12 souris restantes et quelques parties plus tard 1406 points avec 1 souris restante.

Lors de mes nombreux essais, j'ai réussi à me repérer un peu mieux perdre un peu moins dans le labyrinthe créé par critor (mais quand même un peu ! Arg... ) et j'ai toujours suivi le même parcours, globalement :
accéder à l'escalier qui permet de monter au 1er étage, puis prendre la passerelle qui permet d'aller dans la partie avec les 4 tours (renfermant chacune une plaque de pression qui permet de faire gagner 1 niveau à toutes les souris encore présentes) et les haies qui encadrent la dernière tour permettant d'accéder à la 5ème et dernière plaque de pression. L'avantage d'attraper un grand nombre de souris dès le départ est que les sauts sont plus grands et sont donc plus faciles à effectuer pour franchir certains trous et que les escaliers peuvent être montés sans devoir sauter à chaque marche (ce qui coûte très cher en points !).

Avec un niveau élevé, on peut même sauter sur la passerelle depuis le sol en-dessous (depuis l'arène des héros) !!

Le 23/09, Hackcell4TI crée un topic d'entraide sur Planète-Casio https://www.planet-casio.com/Fr/forums/topic17167-1-topique-dentraide-v601s-hq.html qui donne de précieuses informations sur le calcul du score et qui est rapidement complété par un plan du rez-de-chaussée puis du 1er étage du château et qui me permet (enfin !) de moins me perdre et d'avancer plus vite jusqu'aux 5 plaques de pression.

Explications Code

J'en profite pour modifier le script pyka3dlb.py pour remplacer la ligne 181 par les lignes suivantes :

Code: Select all

color = (sprite[S_HEIGHT],sprite[S_DATA][i],player[P_LEVEL] <= main_player[P_LEVEL] and sprite[S_PALETTE] or HAS_COLOR and (MAGENTA,BLACK,(255,20,20),(253,52,52),(200,5,5) ,(163,28,28) ,(255,189,0),(255,239,255)) or (MAGENTA,WHITE,BLACK),sprite[S_TRANSP],0,ph/Z_XY_RATIO, sprite[S_BITS])
if player[P_LEVEL] == main_player[P_LEVEL]:
  color = (sprite[S_HEIGHT],sprite[S_DATA][i],player[P_LEVEL] <= main_player[P_LEVEL] and sprite[S_PALETTE+1] or HAS_COLOR and (MAGENTA,BLACK,(255,220,220),(253,252,252),(200,225,225) ,(243,228,228) ,(255,229,200),(255,239,255)) or (MAGENTA,WHITE,BLACK),sprite[S_TRANSP],0,ph/Z_XY_RATIO, sprite[S_BITS])
elif player[P_LEVEL] == main_player[P_LEVEL] - 1:
  color = (sprite[S_HEIGHT],sprite[S_DATA][i],player[P_LEVEL] <= main_player[P_LEVEL] and sprite[S_PALETTE+1] or HAS_COLOR and (MAGENTA,BLACK,(25,20,220),(23,52,252),(20,25,225) ,(163,28,228) ,(255,89,200),(255,39,255)) or (MAGENTA,WHITE,BLACK),sprite[S_TRANSP],0,ph/Z_XY_RATIO, sprite[S_BITS])

qui permettent de modifier la couleur de certaines souris. Celles qui sont du même niveau que le joueur et qui rapportent donc 100 points, sont affichées en blanc et celles qui ont 1 niveau de moins que le joueur (et qui rapportent donc 50 points) sont affichées en bleu foncé. Ces dernières ne demandent qu'à absorber une autre souris pour gagner un niveau et devenir des souris à 100 points

J'ajoute également les lignes juste après la ligne 180 if is_visible(y1, y2): de pyka3dlb.py et juste avant les lignes qui changent la couleur d'affichage des souris en fonction de leur niveau :

Code: Select all

for elt in players:print(elt[P_LEVEL],end=" ")
print("niv joueur : ",main_player[P_LEVEL])
print("niv :",player[P_LEVEL],end=" ")
print(" / ",end=" ")


pour afficher le niveau des souris que je croise puis le niveau de toutes les souris restantes. La fonction complète avec l'indentation est dans l'onglet Code. Ça me permet par exemple de savoir s'il y a une souris à mon niveau pour ensuite aller l'attraper ou s'il faut que j'attende une fusion favorable pour avoir une souris à mon niveau. Cet affichage n'est effectué que lorsque je croise une souris, mais j'ai ensuite changé pour que cet affichage soit effectué plus régulièrement (à chaque déplacement). À ce stade du concours, je n'ai aucun outil qui me donne une mini-carte du château vu de dessus ou qui affiche des carrés colorés pour représenter la position des souris en temps réel.

Code: Select all

def inject_players_tiles(bt, tt, players_ids, last_block_infos, x0, y0, r, d, last_d):
  if bt or tt:
    global cast_ray_list, cast_ray_shown_players_ids
    for player_id in players_ids:
      if not player_id in cast_ray_shown_players_ids:
        player = players[player_id]
        if player[P_Z] >= last_block_infos[B_TOP] and tt or player[P_Z] < last_block_infos[B_BOTTOM] and bt:
          r0 = atan2(player[P_Y]-y0, player[P_X]-x0)
          if abs(((r0-r)+pi)%(2*pi)-pi) < pi/2:
            dp=sqrt(dist2(x0, y0, player[P_X], player[P_Y]))
            dw = dp * tan(r - r0)
            pr = player_radius(player)
            if abs(dw) <= pr and (dp/cos(r - r0) >= last_d or dp/cos(r - r0) <= d):
              sprite = textures[-1]
              i = floor(sprite[S_WIDTH]*(dw + pr)/(2*pr))
              if i < sprite[S_WIDTH]:
                ph = player_height(player)
                pt=SCREEN_HEIGHT/2-(player[P_Z]+ph-player_eye_altitude(main_player))*SCREEN_HEIGHT/dp/Z_XY_RATIO
                pb=SCREEN_HEIGHT/2+(player_eye_altitude(main_player)-player[P_Z])*SCREEN_HEIGHT/dp/Z_XY_RATIO
                y1, y2 = min_max(pt, pb)
                if is_visible(y1, y2):
                  for elt in players:print(elt[P_LEVEL],end=" ")
                  print("niv joueur : ",main_player[P_LEVEL])
                  print("niv :",player[P_LEVEL],end=" ")
                  print(" / ",end=" ")
                  color = (sprite[S_HEIGHT],sprite[S_DATA][i],player[P_LEVEL] <= main_player[P_LEVEL] and sprite[S_PALETTE] or HAS_COLOR and (MAGENTA,BLACK,(255,20,20),(253,52,52),(200,5,5) ,(163,28,28) ,(255,189,0),(255,239,255)) or (MAGENTA,WHITE,BLACK),sprite[S_TRANSP],0,ph/Z_XY_RATIO, sprite[S_BITS])
                  if player[P_LEVEL] == main_player[P_LEVEL]:
                    color = (sprite[S_HEIGHT],sprite[S_DATA][i],player[P_LEVEL] <= main_player[P_LEVEL] and sprite[S_PALETTE+1] or HAS_COLOR and (MAGENTA,BLACK,(255,220,220),(253,252,252),(200,225,225) ,(243,228,228) ,(255,229,200),(255,239,255)) or (MAGENTA,WHITE,BLACK),sprite[S_TRANSP],0,ph/Z_XY_RATIO, sprite[S_BITS])
                  elif player[P_LEVEL] == main_player[P_LEVEL] - 1:
                    color = (sprite[S_HEIGHT],sprite[S_DATA][i],player[P_LEVEL] <= main_player[P_LEVEL] and sprite[S_PALETTE+1] or HAS_COLOR and (MAGENTA,BLACK,(25,20,220),(23,52,252),(20,25,225) ,(163,28,228) ,(255,89,200),(255,39,255)) or (MAGENTA,WHITE,BLACK),sprite[S_TRANSP],0,ph/Z_XY_RATIO, sprite[S_BITS])
                  if not inclus_inter(cast_ray_inter, y1, y2):
                    cast_ray_list.extend((floor(y1), ceil(y2), color, 1/(1+d)))
                    cast_ray_shown_players_ids.append(player_id)


Le 27/09 j'améliore mon score jusqu'à 1785 points avec 13 souris restantes et en ayant appuyé sur les 5 plaques de pression.

Le 30/09 j'arrive à 2056 points et 2 souris restantes.

L'une est coincée sous le premier escalier (probablement à cause d'une absorption de souris ou d'une des plaques de pression qui lui a fait prendre un niveau alors que le plafond était trop bas pour ça) et l'autre est à l'extérieur du château et je suis d'ailleurs passé juste à côté sans la voir, en ayant pourtant fait plusieurs fois le tour du château et de nombreux détours inutiles. Lorsque je sais qu'il y a une souris à mon niveau présente dans le château, je la cherche jusqu'à la trouver, puis je quitte la partie et la redémarre pour aller directement sur la souris en question. C'est long mais c'est l'inconvénient de ne pas avoir de vision globale du château avec par exemple une vue de dessus et l'emplacement en temps réels des souris.

C'est dans cette partie que j'ai commencé à utiliser l'action Attendre pour optimiser les fusions ou pour avoir une souris à mon niveau à aller chercher. D'où le [4,1200] dans la liste.

C'est juste après cette partie à 2056 points que le 02/10, SlyVTT, dans sa grande générosité, nous partage son Mod fantastique https://tiplanet.org/forum/viewtopic.php?f=49&t=25786&start=60#p269188, qui affiche une mini-carte du château vu de dessus avec des carrés colorés qui représentent les souris restantes. Leur position est affichée en temps réel sur la carte avec une couleur qui indique leur niveau par rapport au niveau du joueur. C'est le bonheur d'avoir un tel Mod et une telle représentation de la partie ! Merci SlyVTT !!! Je passe directement de 2056 points à 2195 points avec un parcours bien plus direct et pertinent et avec moins de détours inutiles. C'est dans cette partie que j'ai commencé à exploiter l'action Attendre, en particulier après avoir appuyé sur les 4 premières plaques de pression.
Je teste différentes valeurs pour Attendre et je me rends compte, en affichant le niveau des souris restantes dans la console, qu'avec Attendre 15000 et même avec Attendre 13500, les souris restantes ont fusionné en 6 souris de niveaux [9, 11, 12, 13, 14, 15] alors que je suis niveau 11. D'où le [4, 13500] dans mon parcours.
En m'aidant de la vue de dessus et de la position en temps réel des souris restantes, je les attrape dans l'ordre pour arriver niveau 16 et j'attrape la dernière, niveau 9, pour 2195 points.

Il est assez long de faire ces différents essais avec différentes valeurs de Attendre, alors j'ai modifié les différents scripts du concours pour en faire une version sans interface graphique (sans GUI : Graphic User Interface). J'ai modifié les fichiers pyka3dlb.py, polycal5.py et polycalc_sdl2.py. Je vous mets les 3 fichiers en pièces jointes. En utilisant pypy3.7, une partie complète est alors exécutée en environ 1 sec entre le départ et l'affichage du score final (et en environ 10 sec avec Python3) au lieu de environ 40 sec avec le script pyka3d.py, avec le paramètre d'affichage à False.
Une telle version sans interface graphique permet par exemple d'affiner la manière dont on avance près d'un trou à franchir. On peut créer une boucle For qui permet de choisir de combien on avance, puis de sauter et d'attendre pendant 5 instants et en affichant l'altitude du joueur après ces actions, on peut savoir de combien on peut avancer avant de tomber dans le trou et ainsi s'assurer d'être le mieux placé pour réussir son saut

Voyant que les dernières souris peuvent fusionner dans le bon ordre pour faire une souris de haut niveau qui rapporte beaucoup plus de points que chaque petite souris attrapée séparément, je me dis qu'il faut que je travaille sur l'optimisation de la fin de la partie après avoir appuyé sur 4 ou 5 plaques de pression qui font monter toutes les souris de 1 niveau.

Je recommence une partie en m'arrangeant pour qu'il reste un plus grand nombre de souris au moment où j'appuie sur les plaques de pression. Les fusions ne se déroulant pas toujours aussi bien que dans cette partie à 2195 points plutôt chanceuse, je modifie le script pyka3dlb.py pour afficher le niveau des souris restantes après chaque action en ajoutant les lignes suivantes à la fin du fichier, juste avant le return :

Code: Select all

  Niveaux=[]
  for elt in players[1:]: # on exclut le niveau du joueur
    Niveaux.append(elt[P_LEVEL])
  Niveaux.sort() # on tri la liste par niveaux croissants
  print(Niveaux,len(Niveaux),"Niv Joueur : ",main_player[P_LEVEL])


et je modifie le script pyka3d.py pour tester des parties avec différentes valeurs d'un Attendre placé à la fin du parcours en remplaçant la ligne score, liste_actions_clavier = jouer_selon(liste_actions, False) par les lignes :

Code: Select all

sav_liste=liste_actions[:]
for avance in range(1,15,10):
    for temps in range(100,1000,100):
        print(avance,temps)
        liste_actions=sav_liste[:]
        liste_actions+=[0, avance/100, 4, temps]
    #liste_actions+=[0, avance/100, 5, 0.39269908169872414, 0, avance/100, 5, 0.39269908169872414, 0, avance/100, 5, 0.39269908169872414, 0, avance/100, 5, 0.39269908169872414, 0, avance/100, 5, 0.39269908169872414, 4, temps]
        score, liste_actions_clavier = jouer_selon(liste_actions, False)


J'ajoute un déplacement et un Attendre à la fin de ma liste et je regarde quel score elle permet d'obtenir. Je modifie la distance du déplacement et le temps du Attendre pour "influencer" le hasard des déplacements des souris et ainsi avoir des fusions dans le bon sens. Si ça ne fonctionne pas, alors je modifie le nombre de déplacement ou de rotation avant le Attendre, comme dans la ligne commentée. Je mets des petits déplacements parce que je suis sur la 5ème plaque de pression lorsque j'optimise les fusions et je veux à tout prix éviter de descendre de cette plaque de pression pour éviter de me faire attraper par une souris de haut niveau qui roderait dans le labyrinthe de haies.

Dans une de mes parties, je suis allé dans le labyrinthe de haies pour en faire sortir une souris à fusionner en lui faisant prendre l'escalier. Je l'ai ensuite coincée contre les créneaux du château pour la faire sauter en bas mais à l'extérieur et pas dans le labyrinthe de haies. Pour vérifier qu'elle saute, j'ajoute la ligne suivante vers la fin du fichier pyka3dlb.py :
print([ player[P_Z] for player in players[1:]])
et je relance mon script pyka3d.py avec la boucle For et je regarde dans les affichages dans la console quand est-ce que l'altitude de la souris qui m'intéresse est enfin à 0.

En parallèle, je modifie une autre version du script pyka3d.py pour essayer d'optimiser une partie déjà terminée. Une telle optimisation est délicate dans la mesure où la modification d'une partie du parcours modifie les déplacements suivants des souris et casse donc la suite de la partie.

Concrètement : si on modifie la valeur d'un déplacement, alors les souris risquent de ne pas prendre le même chemin dans les actions suivantes et on se retrouve à aller attraper une souris... qui n'est plus à l'emplacement où elle était attendue !

La seule action qui peut librement être modifiée pour optimiser le score est le saut. J'optimise donc la hauteur des sauts en la réduisant, en particulier dans les escaliers lorsque je saute à chaque marche, pour sauter d'une hauteur inférieure à 1, ce qui consomme alors moins de 1 point par saut. Mon score à 2195 points passe alors à 2202 points.

La première version est en pièce jointe pyka3d_optimisation_score_final.py et son principe est le suivant : on prend une partie et on choisit une action aléatoirement, si cette action est un saut, alors on réduit un peu sa hauteur et on teste si la nouvelle liste donne un meilleur score ou pas. Et on répète l'opération plein de fois, en reprenant la meilleure partie obtenue avant chaque modification. J'ai ajouté une gestion de lecture de la liste à partir d'un fichier et d'écriture dans un fichier de chaque nouvelle meilleure partie obtenue, ce qui me permet de lancer plusieurs fois mon script en parallèle et d'optimiser le score plus rapidement en utilisant toujours le même fichier pour stocker la meilleure liste.
J'ai modifié ce script d'optimisation pour parcourir directement tous les sauts de ma liste, ce qui est bien plus efficace mais ne permet plus de lancer plusieurs fois le script en parallèle. Cette nouvelle version est
en pièce jointe pyka3d_optimisation_score_final_v2.py

Sur les parties suivantes, je parviens à obtenir 2256 points (optimisé à 2264 points) avec l'ajout de liste_actions+=[0, 0.08, 5, 0.39269908169872414, 0, 0.08, 5, 0.39269908169872414, 0, 0.08, 5, 0.39269908169872414, 0, 0.08, 5, 0.39269908169872414, 0, 0.08, 5, 0.39269908169872414, 4, 9958] juste après avoir appuyé sur les 5 plaques de pression. Le Attendre 9958 permet quelques dernières fusions et laisse alors 6 souris à 100 points à attraper.

J'obtiens ensuite une partie à 2336 points (optimisé à 2340 points). Et c'est là qu'après une discussion sur le chat quant au score maximal théorique d'une partie, je me dis que je peux tenter de faire une partie avec uniquement des fusions favorables. Pour ça, je sors le tableur et je compte. Je place les souris avec leur niveau initial dans le tableau et je regarde ce qu'il se passe en imaginant que j'attrape des souris dans le bon ordre (une souris de niveau 3, puis une souris de niveau 4, puis une souris de niveau 5 et ainsi de suite) et je suppose que les souris de petit niveau fusionnent dans le bon ordre pour donner des souris de grand niveau et je parviens au résultat suivant : je peux attraper des souris de niveau 3 à 19 et il reste 7 souris de petit niveau, à la fin (qui constituent une sorte de marge : je peux me permettre 7 fusions défavorables tout en laissant possible la création des souris de tous les niveaux de 3 à 19). C'est avec ce calcul et cette simulation que j'ai été convaincu qu'il est plus rentable de prendre les 5 plaques de pression plutôt que seulement 4 en économisant la vingtaine de marches de la dernière tour. Il est en effet plus rentable de perdre une vingtaine de points en gravissant cette dernière tour et de faire monter toutes les souris restantes de 1 niveau que de se contenter de 4 plaques de pression.

Je m'exécute et tente une telle partie, mais c'est très long et les fusions indésirables sont légion (fusion de deux souris de petit niveau ou de deux souris de grand niveau, ou obtention d'un trop grand nombre de souris de haut niveau ce qui laisse trop peu de souris de petit niveau pour faire vraiment monter en niveaux les souris de haut niveau) et je dois très régulièrement interrompre ma partie, récupérer la liste obtenue dans la console, en supprimer la fin et coller le reste dans mon fichier pyka3d.py, relancer la partie et tenter des déplacements différents pour obtenir une fusion favorable. Et il faut répéter ces opérations jusqu'à n'obtenir que des fusions favorables.
Pour m'aider dans cette tâche ardue, dans le fichier pyka3dlb.py j'ajoute la ligne print("Fusion de Niv",player[P_LEVEL],"et Niv",p2near[P_LEVEL]) juste après la ligne if player[P_LEVEL] >= p2near[P_LEVEL] and p2near != main_player: # fusion pour clairement afficher chaque fusion dans la console avec le niveau des deux souris qui viennent de fusionner.

Une fois les 5 plaques de pression trouvées et déclenchées, je m'arrange pour faire fusionner les souris restantes dans un ordre favorable et ne parvenant pas à obtenir toutes les fusions directement avec un long temps d'attente, je décide de le faire fusion par fusion et je m'aide des lignes suivantes, ajoutées à la fin du fichier pyka3dlb.py :

Code: Select all

if len(Niveaux) == 17 :
  print("Initial : ",[6, 7, 8, 8, 8, 9, 9, 9, 10, 11, 12, 13, 14, 14, 16, 17, 17, 19])
  print("Niveaux :    ",Niveaux)
  if Niveaux.count(10) == 2 : print("                      Pas bon ! ")


La dernière ligne me permet d'afficher clairement les situations où il y a eu fusion de deux souris de niveau 9, ce que je ne souhaite pas !

ou encore :

Code: Select all

if (11 in Niveaux) + (12 in Niveaux) + (13 in Niveaux) + (14 in Niveaux) + (15 in Niveaux) + (16 in Niveaux) +  (17 in Niveaux) + (18 in Niveaux) + (19 in Niveaux) >= 6:
  print("     YOUPI !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
if (11 in Niveaux) + (12 in Niveaux) + (13 in Niveaux) + (14 in Niveaux) + (15 in Niveaux) + (16 in Niveaux) +  (17 in Niveaux) + (18 in Niveaux) + (19 in Niveaux) + (20 in Niveaux) >= 7:
  print("     !!!!!!!!!!!!!!!!!!!!!!!! EXCEPTIONNEL !!!!!!!!!!!!!!!!!!!!!!!!!!!")


Ici, je suis niveau 11 et je regarde s'il y a 6 ou 7 souris de niveaux différents compris entre 11 et 19 inclus, ce qui permettrait d'avoir 600 ou 700 points en les attrapant. J'avais encore des petites souris à attraper pour gagner un ou plusieurs niveaux dans le cas d'un ou plusieurs niveaux sautés.

ou même :

Code: Select all

if  ((16 in Niveaux) +  (17 in Niveaux) + (18 in Niveaux) + (19 in Niveaux) + (20 in Niveaux) >= 4):
  print("!!!")
  print(Niveaux)
  print("     PAS MAL !!!!!!!!!!!!!!!")


Ici, c'est le même esprit, mais je suis niveau 16 et je veux 4 souris à attraper.

ou même :

Code: Select all

if 16 in Niveaux:
  print("     YOUPI")
if 17 in Niveaux or 18 in Niveaux:
  print("       OK avec saut de niveaux")


Ici, c'est de nouveau la même idée, mais en cherchant à avoir une souris de niveau 16 ou une souris de niveau 17 ou 18.

Je parviens finalement à avoir des souris de tous les niveaux entre 3 et 19 et il me reste 1 souris de marge. Ce qui me donne un score de 2534 points (optimisé à 2542 points).

J'ai modifié le Mod de SlyVTT pour nuancer la couleur des souris de niveau supérieur au niveau du joueur pour pouvoir aller les chercher dans le bon ordre, en ajoutant dans le fichier pyka3dlb.py modifié par SlyVTT, juste après la ligne if (player[P_Z]==main_player[P_Z]):, les lignes suivantes :

Code: Select all

if (player[P_LEVEL] - main_player[P_LEVEL]) == 1:
  fill_rect( OFFSET_X+SCALE_FACTOR*floor(player[P_X]), OFFSET_Y+SCALE_FACTOR*floor(player[P_Y]), SCALE_FACTOR, SCALE_FACTOR, (255,0,255) )
elif (player[P_LEVEL] - main_player[P_LEVEL]) == 2:
  fill_rect( OFFSET_X+SCALE_FACTOR*floor(player[P_X]), OFFSET_Y+SCALE_FACTOR*floor(player[P_Y]), SCALE_FACTOR, SCALE_FACTOR, (200,0,200) )
elif (player[P_LEVEL] - main_player[P_LEVEL]) == 3:
  fill_rect( OFFSET_X+SCALE_FACTOR*floor(player[P_X]), OFFSET_Y+SCALE_FACTOR*floor(player[P_Y]), SCALE_FACTOR, SCALE_FACTOR, (150,0,150) )
elif (player[P_LEVEL] > main_player[P_LEVEL]):
  fill_rect( OFFSET_X+SCALE_FACTOR*floor(player[P_X]), OFFSET_Y+SCALE_FACTOR*floor(player[P_Y]), SCALE_FACTOR, SCALE_FACTOR, (100,0,100) )


Cette partie à 2542 points m'a pris 2 journées et un nombre considérable de répétitions de la procédure suivante : avancer dans la partie, avoir une fusion défavorable, rager, quitter la partie, copier-coller la liste des actions affichées dans la console pour l'ajouter à la liste du fichier pyka3d.py, relancer la partie, tenter un mouvement différent (un pas de côté, ou reculer, ou tourner, ou attendre ou un mélange de tout ça) et espérer avoir une fusion favorable.
Parmi les contraintes et difficultés rencontrées, il y a eu, entre autres : des souris coincées sous un escalier, une souris de niveau 8 coincée dans le labyrinthe et qui ne peut pas en sortir parce qu'elle ne saute pas assez haut pour monter sur les créneaux, une souris de niveau 4 qui coince une souris de niveau 1 dans un coin et qui finit par la manger automatiquement en passant au niveau 5 lors de l'appui sur une plaque de pression, alors que je ne pouvais pas me permettre de fusionner une souris de niveau 4 avec une de niveau 1 (j'avais besoin que ces deux souris soient mangées par des souris de niveau 5 ou plus), la présence d'un trop grand nombre de souris de haut niveau dans le labyrinthe de haies (et qui se menacent entre elles et peinent à sortir du labyrinthe lorsque j'en ai besoin)... chacune de ces situations m'ayant obligé à reprendre la partie du début ou à supprimer une grande partie de l'avancée de ma partie.

Et là, c'est la révélation qui change tout : pour monter le premier escalier (celui qui mène au 1er étage), il faut être au minimum au niveau 10 pour franchir le trou. Il en est de même pour accéder à la passerelle qui mène au labyrinthe des haies, mais ce saut est difficile à réussir au niveau 10 et par confort j'ai fini par ne le faire qu'un niveau 11 et prendre l'habitude de monter l'escalier au niveau 11. Une discussion sur le chat m'a rappelé qu'il est possible d'accéder à la passerelle au niveau 10, comme je le faisais dans mes toutes premières parties. Je reprends donc mon tableur et recalcule tout. Il est en effet bien moins coûteux d'obtenir une souris de niveau 10 en appuyant sur les 5 plaques de pression que sans les plaques. C'est moins coûteux en nombre de petites souris à fusionner (une souris de niveau 4 fusionnée avec une autre souris puis qui prend 5 niveaux avec les plaques de pression plutôt qu'une souris de niveau 4 qui fusionne avec 6 souris (!!) pour atteindre le niveau 10). Il est donc bien plus intéressant de prendre la passerelle au niveau 10 qu'au niveau 11. Cette économie de 5 souris permet d'avoir finalement 12 souris de marge plutôt que 7. Et si on s'arrange pour avoir une souris de niveau 9 parmi ces 12 souris, alors elle peut fusionner avec les 11 autres pour donner une souris de niveau 20 !!
Je me rends alors compte qu'il est possible d'obtenir une souris de niveau 20 mais avec 0 souris restante ! Aucune marge, donc ça veut dire qu'il faut uniquement des fusions dans le bon ordre et aucun droit à l'erreur.
Dans cette partie ultime, je dois attraper une souris de niveau 3, puis une de niveau 4 puis parmi les 97 souris restantes, obtenir une souris de niveau 5, une de niveau 6 et ainsi de suite jusqu'à une souris de niveau 20. Donc 16 souris de niveau 5 à 20 inclus, à partir de 97 souris, ce qui représente 81 fusions favorables. C'est pas gagné...

J'entreprends donc une partie qui va me prendre 3 jours, à coup de [avancer dans la partie, avoir une fusion défavorable, rager, quitter la partie, copier-coller la liste des actions affichées dans la console pour l'ajouter à la liste du fichier pyka3d.py, relancer la partie, tenter un mouvement différent (un pas de côté, ou reculer, ou tourner, ou attendre ou un mélange de tout ça) et espérer avoir une fusion favorable.]...

Mais ça c'était jusqu'à ce que SlyVTT intègre sa formidable interface à l'outil formidable de M4x1m3 et que cet outil me soit rendu accessible. L'outil de M4x1m3 permettait déjà d'avoir une vue en 3D orientable à souhait avec gestion du zoom et surtout le précieux bouton Undo qui permet de supprimer la ou les dernières actions saisies (jusqu'à revenir à la toute première action !). Par ailleurs, il était possible de saisir une action avec un paramètre différent de 1, comme avancer de 0.3, sauter d'une hauteur 0.5 ou attendre 1000 et d'annuler cette action d'un simple clic sur Undo Tout au long de cette aventure, SlyVTT a effectué de nombreuses modifications de son outil puis de la fusion de son outil avec celui de M4x1m3. Parmi les améliorations apportées, on peut citer : ajout de vecteurs qui donnent l'orientation des souris et donc la direction de leur prochain déplacement (et qui montre clairement la prise en chasse d'une souris par une autre), ajout de l'affichage des fusions dans un cadre reproduisant la console, ajout de l'affichage de la liste des niveaux des souris restantes et mise en évidence des fusions de souris au moyen de l'affichage temporaire d'un cercle sur la mini-carte... Ces différentes améliorations m'ont permis d'entreprendre cette partie ultime avec 81 fusions dans le bon ordre et des souris de niveaux 3 à 20.

J'obtiens un score à 2575 puis 2634 et j'obtiens finalement un ultime score de 2651 points, une semaine avant la fin du concours ! (optimisé à 2655.2 points avec une réduction de la hauteur des sauts).

J'en profite pour remercier toutes les personnes qui sont à l'initiative de l'organisation et de la réalisation de ce concours qui est impressionnant par sa technicité et la compatibilité des scripts avec de nombreuses calculatrices ! Je remercie également mes coéquipiers et nos concurrents (cent20 et ses 20 élèves) qui ont oeuvré à faire de ce concours un espace et un moment convivial et stimulant et qui nous a tous poussés à nous dépasser !
Je remercie également Pavel et CrimsonDeus qui par leur absence m'ont permis d'être mieux classé que les années précédentes

[critor]

Merci Afyu, une excellente narration de recherche, j'espère que tes disciples t'en offrent des comme ça également.

Un choix de lot tout aussi généreux que ta personne ; tu n'as même pas pris de calculatrice, la laissant pour ceux qui viennent après toi.
Il ne me manque que l'autocollant du groupe qui devrait arriver fin novembre.

Sont épuisés après ton choix :

• la coque NumWorks choisie
• l'autocollant NumWorks tête de loup
• le cahier NumWorks
• le stylo Calcuso

[Afyu]

Le groupe V601 choisit le lot suivant :

• 1 lot 83PCE : 1 calculatrice TI-83 Premium CE Edition Python + 1 licence logiciel d'émulation TI-SmartView CE dédié + 1 film de protection écran Wyngs dédié + 1 livret de prise en main Calcuso + 1 goodie Calcuso au choix + 1 pack de goodies TI + 1 pack de goodies TI-Planète Casio

Pour les packs de goodies communs accompagnant les lots :

TI

• 1 adaptateur pour périphériques USB (clavier, clé USB, souris, etc.)
• 1 clavier USB dédié pour TI-84 Plus CE
• 1 porte-clésTI <3 Maths
• 1 autocollant TI Love Maths
• 1 coffret de 3 casse-têtes TI
• 1 stylo TI T³
• 1 paire de chaussettes TI-84 Plus CE
• 1 cahier TI (200 pages)
• 1 sac en toile TI
• 1 clé USB TI (4 Go) : TI-Innovator Rover
• 1 goodie TI boîte cubique TI-83 Premium CE
• 1 cahier d'activités TI au choix :
  
  • Activités BBC micro:bit avec la TI-83 Premium CE Edition Python, par Jean-Louis Balas et Abdel Yazi

Calcuso

• 1 goodie Calcuso au choix :
  
  • kit de géométrie Calcuso
  

TI-Planète-Casio

• 1 aimantin TI-Planet Noël sur fond noir
• 1 autocollant TI-Planet sans VIP
• 1 autocollant Planète Casio