Programmer un figure en Python, même hors ligne

"""
Animation inspirée de l'article de Vincent Pantaloni dans cet article de l'APMEP : https://afdm.apmep.fr/rubriques/ouvertures/mathematiques-du-jonglage/
"""

ph = addCalc('ph', '0') # Ajoute à la figure MathGraph32 d'un calcul dont la valeur sera changée dans draw et permettra l'animation
n_balls = addCalc('nballs', '5') # Ajoute à la figure un calcul de nom nballs. Modifiable mais doit rester impair et >= 3
nballs = getValue(n_balls) #Renvoie la valeur actuelle du calcul MathGraph32 nballs
valph = 0
def draw(): # Fonction utilisée pour l'animation et qui change la formule du calcul MathGraph32 ph et recalcule et redessine les objets qui en dépendent
	global valph
	valph += 0.0075
	giveFormulaTo('ph', str(valph))
	updateDependantDisplay(ph) # On ne calcule et redessine que les objets dépendant du calcul ph
	
dimf = getFigDim() # Renvoie une liste contenant les dimensions de la fenêtre de travail
width = dimf[0]
height = dimf[1]
zoomFig(width/2, height/2, 2) # On zoome d'un facteur 2 sur la figure
addTimerButton(draw, 1/60) # Ajoute un boutons Start - Stop qui appellera la fonction draw tous les soixantièmes de seconde
O = getPointByName('O') # On mémorise le point O origine du repère comme objet point (plus rapide que de faire référence à son nom plus tard)
setAngleUnity('radian') # On impose le radian à notre figure
# Début de la création des objets graphiques fixes de la figure (qui ne dépendent pas de ph)
head_0 = addPointXY(0, 2)
setHidden(head_0)
head_radius = 0.7
head = addCircleOr(head_0, head_radius, 'black', '-', 2)
head_0_position = getPointPosition(head_0)
head_base = addPointXY(head_0_position.x, head_0_position.y - head_radius)
setHidden(head_base)

spine_base = addPointXY(0, head_0_position.y - 4)
setHidden(spine_base)
torso = addSegment(head_base, spine_base, 'black', '-', 2)

shoulder_y = head_0_position.y - 1.5
l_shoulder = addPointXY(1.25, shoulder_y, '', 'black', 'O')
r_shoulder = addPointXY(-1.25, shoulder_y, '', "black", 'O')

shoulders = addSegment(l_shoulder, r_shoulder, 'black', '-', 2)
up_arm_0 = addPointXY(0.0, -1.0)
setHidden(up_arm_0)
    
l_arm_ph = addCalc('larmph', 'mod(nballs * ph,1)')
l_arm_th = addCalc('larmth', '2.0 * pi * larmph')

l_up_th = addCalc('lupth', '-0.25 * larmph * sin(larmth)')
v_l_up_arm = addImPointRotation(up_arm_0, O, l_up_th)
setHidden(v_l_up_arm)
l_elbow = addImPointTranslation(v_l_up_arm, O, l_shoulder)

l_forearm_x = addCalc('lforearmx', '-0.75 * cos(larmth)')
l_forearm_y = addCalc('lforearmy', '0.5 * (sin(larmth) - 0.8)')

v_l_forearm = addPointXY(l_forearm_x, l_forearm_y)
setHidden(v_l_forearm)
l_hand = addImPointTranslation(v_l_forearm, O, l_elbow)
mesabsleft = addXMeasure(l_hand, 'masabsleft')
mesordleft = addYMeasure(l_hand, 'masordleft')
l_hand_comp = addCalcComp('lhand', 'masabsleft + i*masordleft')

l_up_arm = addSegment(l_shoulder, l_elbow, 'green', '-', 2)
l_forearm = addSegment(l_elbow, l_hand, 'green', '-', 2)

r_arm_ph = addCalc('rarmph', 'mod(larmph + 0.5, 1)')
r_arm_th = addCalc('rarmth', '2.0 * pi * rarmph')

r_up_th = addCalc('rupth', '0.25 * rarmph * sin(rarmth)')

v_r_up_arm = addImPointRotation(up_arm_0, O, r_up_th)
setHidden(v_r_up_arm)
r_elbow = addImPointTranslation(v_r_up_arm, O, r_shoulder)

r_forearm_x = addCalc('rforearmx', '0.75 * cos(rarmth)')
r_forearm_y = addCalc('rforearmy', '0.5 * (sin(rarmth) - 0.8)')
v_r_forearm = addPointXY(r_forearm_x, r_forearm_y)
setHidden(v_r_forearm)
r_hand = addImPointTranslation(v_r_forearm, O, r_elbow)
mesabsright = addXMeasure(r_hand, 'mesabsright')
mesordright = addYMeasure(r_hand, 'mesordright')
r_hand_comp = addCalcComp('rhand', 'mesabsright+i*mesordright')
r_up_arm = addSegment(r_shoulder, r_elbow, 'red', '-', 2)
r_forearm = addSegment(r_elbow, r_hand, 'red', '-', 2)
# Fin de la création des objest fixes de la figure (qui ne dépendent pas de h)

ball_colors = ["blue", "green", "red", "#ffbf00", "cyan"]

# Dans cette fonction, il faut donner aux objets de type calcul MathGraph32 des noms dépendant de i car sinon on aura des erreurs de calcul créés ayant le même nom
def make_ball(i):
	stri = str(i)
	j = 'j' + stri # Nom du calcul qui représente la valeur actuelle de i dans les calculs MathGraph32 suivants
	addCalc(j, stri)
	ballph = 'ballph' + stri # Nom de calcul dans mtg32
	ball_ph = addCalc(ballph, f"mod(2.0 * (ph * nballs + {j}),nballs * 2)") 
	airph = 'airph' + stri # Nom de calcul dans mtg32
	# f suivi de " sert à insérer dans la chaîne entre "" le contenu de variables chaînes en entourant leur nom entre accolades. Ainsi {j} insère le contenu de la variable j définie plus haut
	air_ph = addCalc(airph, f"mod({ballph}, nballs) / (nballs - 1)")
	airltorx = 'airltorx' + stri  # Nom de calcul dans mtg32
	air_l_to_r_x = addCalc(airltorx, f"0.5 - {airph} * 2.5")
	airrtolx = 'airrtolx' + stri # Nom de calcul dans mtg32
	air_r_to_l_x = addCalc(airrtolx, f"-0.5 + {airph} * 2.5")
	airy = 'airy' + stri # Nom de calcul dans mtg32
	air_y = addCalc(airy, f"2 + 1.0 - 15.0 * ({airph} - 0.5)^2")
	airltor = 'airltor' + stri # Nom de calcul complexe dans mtg32
	air_l_to_r = addCalcComp(airltor, f"{airltorx}+i*{airy}")
	airrtol = 'airrtol' + stri # Nom de calcul complexe dans mtg32
	air_r_to_l = addCalcComp(airrtol, f"{airrtolx}+i*{airy}")
	# Ci-dessous on définit une formule de calcul complexe valide pour MathGraph32 (si on veut que la figure soit dynamique il ne faut pas utiliser conditon Python if)
	forcalc = f"si({ballph} <= nballs - 1, {airltor}, si({ballph} <= nballs ,rhand, si({ballph} <= 2*nballs - 1,{airrtol}, lhand)))"

	color = ball_colors[i % 5]
	point = addPointZ(f"{forcalc}", '') # Le point est défini par son affixe complexe donné par la formule forcalc
	setHidden(point)
	circle = addCircleOr(point, 0.15, 'black', '-', 2)
	return addSurface(circle, color, 'fill')

for i in range(nballs):
    make_ball(i)