def listing_components(components,component_actuel):
    yStart=450
    yPos=yStart
    i=0
    c=gs.Color.Grey
    for comp in components:
        if i==component_actuel:
            c=gs.Color.Yellow
        else:
            c=gs.Color.White
        render.text2d(50,yPos,comp.GetAspect(),16, c)
        yPos-=16
        i+=1
def listing_sprites(liste,sprite_actuel,c_inactive=gs.Color.White,c_active=gs.Color.Yellow):
    yStart=850
    yPos=yStart
    i=0
    render.text2d(25+300,yPos,"Sprites:",18, gs.Color.Green)
    yPos-=20
    for sprite in liste:
        if i==sprite_actuel:
            c=c_active
        else:
            c=c_inactive
        render.text2d(50+300,yPos,sprite.nom,16, c)
        yPos-=16
        i+=1
def listing_noeuds(noeuds,noeud_actuel,c_inactive=gs.Color.White,c_active=gs.Color.Yellow):
    yStart=850
    yPos=yStart
    i=0
    render.text2d(25,yPos,"Noeuds:",18, gs.Color.Green)
    yPos-=20
    for noeud in noeuds:
        if i==noeud_actuel:
            c=c_active
        else:
            c=c_inactive
        render.text2d(50,yPos,noeud.GetName(),16, c)
        yPos-=16
        i+=1
def affiche_donnees_noeud(noeud,c=gs.Color.Yellow):
    xPos=1200
    yPos=850
    e=16

    if not noeud.GetLight()==None:
        affiche_donnees_lumiere(noeud,xPos,c)
    elif not noeud.GetCamera()==None:
        affiche_donnees_camera(noeud,xPos,c)
    elif not noeud.GetObject()==None:
        affiche_donnees_object(noeud,xPos,c)
    else:
        render.text2d(xPos,yPos,"Noeud: "+noeud.GetName(),16, c)
        affiche_matrice(noeud.GetTransform(),xPos,yPos-2*e,c)
def draw():
	global screen_clock

	def fade_sin(fade):
		return (math.cos(fade * 3.0) + 1.0) * 0.5

	size = render.get_renderer().GetCurrentOutputWindow().GetSize()
	x = size.x * 0.5 - 100.0
	y = size.y * 0.5 - 210.0
	font_size = 80
	screen_clock += dt_sec

	render.text2d(x - size.x * 0.001, y - size.y * 0.001, "Press Enter", font_size, gs.Color(0,0,0, fade_sin(screen_clock) * 0.5),  globals.font_garamond)
	render.text2d(x, y, "Press Enter", font_size, gs.Color(1,1,1, fade_sin(screen_clock)), globals.font_garamond)

	y -= 40
	render.text2d(300, y - 20.0, "The MedieCross Project 2010-2015, made for TigSource.com.", 30, gs.Color.Black, globals.font_garamond)
	render.text2d(350, y - 50.0, "Code : Emmanuel Julien - Art : Francois Gutherz", 30, gs.Color.Black, globals.font_garamond)
	render.text2d(360, y - 80.0, "Animation : Ryan Hagen - Engine : Harfang3D", 30, gs.Color.Black, globals.font_garamond)
def play_simulation():
	while not input.key_press(gs.InputDevice.KeyEscape):
		clock.update()
		fps.update(clock.get_dt())
		render.set_camera3d(fps.pos.x, fps.pos.y, fps.pos.z, fps.rot.x, fps.rot.y, fps.rot.z)

		render.clear()

		for perso in array_perso:
			perso.draw()
			perso.update(physic_world)

		array_perso[0].kohonen_behaviour.draw(render.get_renderer().GetCurrentOutputWindow().GetSize().x, render.get_renderer().GetCurrentOutputWindow().GetSize().y)

		physic_world.draw()

		# render text
		if input.key_down(gs.InputDevice.KeyL):
			render.text2d(10, 120, 'Frag in Mem: %d' % KohonenBehaviour.memory.GetNbFragment())
			for action in range(perso_actions.nb_actions):
				render.text2d(10, 140 + 20*action, 'Frag for %s: %d, %d%%' % (perso_actions.get_current_action_name(action), KohonenBehaviour.memory.m_NbFragmentPerActionArray[action], KohonenBehaviour.memory.m_TabPercentFragmentPerAction[action]), 12, array_perso[0].kohonen_behaviour.color_array[action])

		render.text2d(10, 50, str(perso.selected_action)+" "+perso_actions.get_current_action_name(perso.selected_action))

		#draw it to the screen
		render.flip()
def affiche_donnees_object(lobject,xPos,c=gs.Color.White):
    yPos=850
    e=16
    obj=lobject.GetObject()
    render.text2d(xPos,yPos,"Objet: "+lobject.GetName(),16, c)

    geo=obj.GetGeometry()
    i=geo.GetMaterialCount()
    render.text2d(xPos,yPos-2*e,"Num matériaux: "+str(i),16, c)
    n=0
    while n<i:
        materiau=geo.GetMaterial(n)
        render.text2d(xPos,yPos-(n+4)*e,"Materiau "+str(n)+" : "+materiau.GetName(),16, c)
        #tex=materiau.GetTexture()
        #if is not None materiau.GetTexture()
        n+=1

    affiche_matrice(lobject.GetTransform(),xPos,yPos-(n+6)*e,c  )
Esempio n. 8
0
def afficheTexte(x, y, texte, transparence=1.0, size=1.0):
	render.text2d(x, y, texte, 30 * size, gs.Color(35 / 255, 40 / 255, 114 / 255, transparence),
				  '@data/Century_Gothic.ttf')
		for current_node in node_list:
			_pos = current_node.GetTransform().GetPosition()
			if md_screen_w * -0.5 < _pos.x < md_screen_w * 0.5:
				if md_screen_h * -0.5 < _pos.y < md_screen_h * 0.5:
					new_motion = {'type': node_get_type(current_node), 'size': node_get_size(current_node),
									'position': _pos, 'rotation': current_node.GetTransform().GetRotation()}
					new_frame.append(new_motion)

		prev_node_count = len(new_frame)
		if len(new_frame) < max_bullet:
			for i in range(max_bullet - len(new_frame)):
				new_frame.append(null_bullet)

		stream_list.append(new_frame)

	render.text2d(5, 25, "@%.2f FPS" % (1 / dt_sec))
	render.text2d(5, 40, "@%.2f sec" % (dt_sum))
	render.flip()

# Dump record

if len(stream_list) > 0:
	f = codecs.open(filename_out + '_' + str(current_scenario) + '.h', 'w')

	f.write('#include "genesis.h"\n\n')
	f.write('#define SIMULATION_' + str(current_scenario) + '_FRAME_LEN ' + str(len(stream_list)) + '\n')
	f.write('#define SIMULATION_' + str(current_scenario) + '_NODE_LEN ' + str(max_bullet) + '\n\n')

	f.write('const s16 ' + 'physics_sim_' + str(current_scenario) + '[] =' + '\n')
	f.write('{\n')
    def edition_terrain(cls):

        if input.key_down(gs.InputDevice.KeyA):
            cls.facteur_echelle_terrain_l1.x += 100
        elif input.key_down(gs.InputDevice.KeyQ):
            cls.facteur_echelle_terrain_l1.x -= 100
            if cls.facteur_echelle_terrain_l1.x < 100:
                cls.facteur_echelle_terrain_l1.x = 100

        if input.key_down(gs.InputDevice.KeyZ):
            cls.facteur_echelle_terrain_l1.y += 100
        elif input.key_down(gs.InputDevice.KeyS):
            cls.facteur_echelle_terrain_l1.y -= 100
            if cls.facteur_echelle_terrain_l1.y < 100:
                cls.facteur_echelle_terrain_l1.y = 100

        if input.key_down(gs.InputDevice.KeyE):
            cls.facteur_echelle_terrain_l2.x += 100
        elif input.key_down(gs.InputDevice.KeyD):
            cls.facteur_echelle_terrain_l2.x -= 100
            if cls.facteur_echelle_terrain_l2.x < 100:
                cls.facteur_echelle_terrain_l2.x = 100

        if input.key_down(gs.InputDevice.KeyR):
            cls.facteur_echelle_terrain_l2.y += 100
        elif input.key_down(gs.InputDevice.KeyF):
            cls.facteur_echelle_terrain_l2.y -= 100
            if cls.facteur_echelle_terrain_l2.y < 100:
                cls.facteur_echelle_terrain_l2.y = 100

        if input.key_down(gs.InputDevice.KeyT):
            cls.facteur_echelle_terrain_l3.x += 100
        elif input.key_down(gs.InputDevice.KeyG):
            cls.facteur_echelle_terrain_l3.x -= 100
            if cls.facteur_echelle_terrain_l3.x < 100:
                cls.facteur_echelle_terrain_l3.x = 100

        if input.key_down(gs.InputDevice.KeyY):
            cls.facteur_echelle_terrain_l3.y += 100
        elif input.key_down(gs.InputDevice.KeyH):
            cls.facteur_echelle_terrain_l3.y -= 100
            if cls.facteur_echelle_terrain_l3.y < 100:
                cls.facteur_echelle_terrain_l3.y = 100

        elif input.key_down(gs.InputDevice.KeyU):
            cls.amplitude_l1 += 100
        elif input.key_down(gs.InputDevice.KeyJ):
            cls.amplitude_l1 -= 100
            if cls.amplitude_l1 < 100:
                cls.amplitude_l1 = 100

        elif input.key_down(gs.InputDevice.KeyI):
            cls.amplitude_l2 += 1
        elif input.key_down(gs.InputDevice.KeyK):
            cls.amplitude_l2 -= 1
            if cls.amplitude_l2 < 1:
                cls.amplitude_l2 = 1

        elif input.key_down(gs.InputDevice.KeyO):
            cls.amplitude_l3 += 0.05
        elif input.key_down(gs.InputDevice.KeyL):
            cls.amplitude_l3 -= 0.05
            if cls.amplitude_l3 < 0.05:
                cls.amplitude_l3 = 0.05

        elif input.key_down(gs.InputDevice.KeyP):
            cls.facteur_precision_distance += 0.001
        elif input.key_down(gs.InputDevice.KeyM):
            cls.facteur_precision_distance -= 0.001
            if cls.facteur_precision_distance < 1.001:
                cls.facteur_precision_distance = 1.001

        elif input.key_down(gs.InputDevice.KeyNumpad2):
            cls.altitude_eau += 1
        elif input.key_down(gs.InputDevice.KeyNumpad1):
            cls.altitude_eau -= 1

        window_size = Demo.rendu.GetDefaultOutputWindow().GetSize()
        xPos = 10
        yPos = window_size.y - 30

        c = gs.Color(1., 0, 0, 1.)
        render.text2d(
            xPos, yPos, "A/Q facteur_echelle_terrain_l1.x: " +
            str(cls.facteur_echelle_terrain_l1.x), 16, c)
        render.text2d(
            xPos, yPos - 15, "Z/S facteur_echelle_terrain_l1.y: " +
            str(cls.facteur_echelle_terrain_l1.y), 16, c)
        render.text2d(
            xPos, yPos - 15 * 2, "E/D facteur_echelle_terrain_l2.x: " +
            str(cls.facteur_echelle_terrain_l2.x), 16, c)
        render.text2d(
            xPos, yPos - 15 * 3, "R/F facteur_echelle_terrain_l2.y: " +
            str(cls.facteur_echelle_terrain_l2.y), 16, c)
        render.text2d(
            xPos, yPos - 15 * 4, "T/G facteur_echelle_terrain_l3.x: " +
            str(cls.facteur_echelle_terrain_l3.x), 16, c)
        render.text2d(
            xPos, yPos - 15 * 5, "Y/H facteur_echelle_terrain_l3.y: " +
            str(cls.facteur_echelle_terrain_l3.y), 16, c)
        render.text2d(xPos, yPos - 15 * 6,
                      "U/J amplitude_l1: " + str(cls.amplitude_l1), 16, c)
        render.text2d(xPos, yPos - 15 * 7,
                      "I/K amplitude_l2: " + str(cls.amplitude_l2), 16, c)
        render.text2d(xPos, yPos - 15 * 8,
                      "O/L amplitude_l3: " + str(cls.amplitude_l3), 16, c)
        render.text2d(
            xPos, yPos - 15 * 9, "P/M facteur_precision_distance: " +
            str(cls.facteur_precision_distance), 16, c)
        render.text2d(xPos, yPos - 15 * 10,
                      "1/2 altitude_eau: " + str(cls.altitude_eau), 16, c)
            record_motion = False
            record_done = True

    if record_motion:
        new_frame = []
        for current_node in node_list:
            new_motion = {
                'position':
                current_node.GetTransform().GetPosition() * scale_factor,
                'rotation': current_node.GetTransform().GetRotation()
            }
            new_frame.append(new_motion)

        stream_list.append(new_frame)

    render.text2d(5, 25, "@%.2fFPS" % (1 / dt_sec))
    render.text2d(5, 5,
                  "Move around with QSZD, left mouse button to look around")
    render.flip()

# Dump record

f = codecs.open(filename_out + '.h', 'w')

f.write('#include "genesis.h"\n\n')
f.write('#define SIMULATION_FRAME_LEN ' + str(len(stream_list)) + '\n')
f.write('#define SIMULATION_NODE_LEN ' + str(len(node_list)) + '\n\n')

f.write('const fix16 ' + 'physics_sim' + '[] =' + '\n')
f.write('{\n')
Esempio n. 12
0
def affiche_donnees_lumiere(la_lumiere,xPos,c=gs.Color.White):
    yPos=850
    e=16
    l=la_lumiere.GetLight()
    modeles=['','','']
    modeles[gs.Light.Model_Point]="Point"
    modeles[gs.Light.Model_Linear]="Linear"
    modeles[gs.Light.Model_Spot]="Spot"

    shadows=['','','']
    shadows[gs.Light.Shadow_None]="None"
    shadows[gs.Light.Shadow_Map]="Map"
    shadows[gs.Light.Shadow_ProjectionMap]="ProjectionMap"

    render.text2d(xPos,yPos,"Lumière: "+la_lumiere.GetName(),16, c)
    render.text2d(xPos,yPos-e*2,"Model: "+modeles[l.GetModel()],16, c)
    #render.text2d(xPos,yPos-e*2,"Diff intensité: "+str(l.Get()],16, gs.Color.Yellow)

    render.text2d(xPos,yPos-e*3,"Shadow: "+shadows[l.GetShadow()],16, c)
    render.text2d(xPos,yPos-e*4,"Shadow range: "+str(l.GetShadowRange()),16, c)
    render.text2d(xPos,yPos-e*5,"Shadow bias: "+str(round(l.GetShadowBias(),6)),16,c)
    #render.text2d(xPos,yPos-e*6,"Shadow distribution: "+str(round(l.GetShadowDistribution(),6)),16, c)

    render.text2d(xPos,yPos-e*8,"Intensité Diff.: "+str(round(l.GetDiffuseIntensity(),3)),16, c)
    render.text2d(xPos,yPos-e*9,"Portée: "+str(round(l.GetRange(),3)),16, c)

    affiche_matrice(la_lumiere.GetTransform(),xPos,yPos-10*e,c  )
Esempio n. 13
0
def affiche_donnees_camera(la_camera,xPos,c=gs.Color.White):
    yPos=850
    e=16
    cam=la_camera.GetCamera()
    render.text2d(xPos,yPos,"Caméra: "+la_camera.GetName(),16, c)
    render.text2d(xPos,yPos-2*e,"Zoom: "+str(round(cam.GetZoomFactor(),3)),16, c)
    Fov=gs.ZoomFactorToFov(cam.GetZoomFactor())
    render.text2d(xPos,yPos-3*e,"Fov: "+str(round(Fov/pi*180,3)),16, c)

    distanceFocale=Demo.calcul_distance_focale(la_camera)
    render.text2d(xPos,yPos-4*e,"Distance focale: "+str(round(distanceFocale,3)),16, c)
    render.text2d(xPos,yPos-5*e,"Z near: "+str(round(cam.GetZNear(),3)),16,c)
    render.text2d(xPos,yPos-6*e,"Z far: "+str(round(cam.GetZFar(),3)),16, c)
    affiche_matrice(la_camera.GetTransform(),xPos,yPos-8*e,c)
Esempio n. 14
0
def affiche_matrice(mat,x,y,c=gs.Color.White):
    e=16
    position=mat.GetPosition()
    orientation=mat.GetRotation()

    render.text2d(x,y,"X: "+str(round(position.x,3)),16, c)
    render.text2d(x,y-e,"Y: "+str(round(position.y,3)),16, c)
    render.text2d(x,y-2*e,"Z: "+str(round(position.z,3)),16, c)
    render.text2d(x,y-4*e,"T: "+str(round(orientation.x/pi*180.,3))+"°    "+str(round(orientation.x,3))+" rad",16, c)
    render.text2d(x,y-5*e,"L: "+str(round(orientation.y/pi*180.,3))+"°    "+str(round(orientation.y,3))+" rad",16, c)
    render.text2d(x,y-6*e,"R: "+str(round(orientation.z/pi*180.,3))+"°    "+str(round(orientation.z,3))+" rad",16, c)
    def edition_terrain(cls):

        if input.key_down(gs.InputDevice.KeyA):
            cls.facteur_echelle_terrain_l1.x+=100
        elif input.key_down(gs.InputDevice.KeyQ):
            cls.facteur_echelle_terrain_l1.x-=100
            if cls.facteur_echelle_terrain_l1.x<100:
                cls.facteur_echelle_terrain_l1.x=100

        if input.key_down(gs.InputDevice.KeyZ):
            cls.facteur_echelle_terrain_l1.y+=100
        elif input.key_down(gs.InputDevice.KeyS):
            cls.facteur_echelle_terrain_l1.y-=100
            if cls.facteur_echelle_terrain_l1.y<100:
                cls.facteur_echelle_terrain_l1.y=100

        if input.key_down(gs.InputDevice.KeyE):
            cls.facteur_echelle_terrain_l2.x+=100
        elif input.key_down(gs.InputDevice.KeyD):
            cls.facteur_echelle_terrain_l2.x-=100
            if cls.facteur_echelle_terrain_l2.x<100:
                cls.facteur_echelle_terrain_l2.x=100

        if input.key_down(gs.InputDevice.KeyR):
            cls.facteur_echelle_terrain_l2.y+=100
        elif input.key_down(gs.InputDevice.KeyF):
            cls.facteur_echelle_terrain_l2.y-=100
            if cls.facteur_echelle_terrain_l2.y<100:
                cls.facteur_echelle_terrain_l2.y=100

        if input.key_down(gs.InputDevice.KeyT):
            cls.facteur_echelle_terrain_l3.x+=100
        elif input.key_down(gs.InputDevice.KeyG):
            cls.facteur_echelle_terrain_l3.x-=100
            if cls.facteur_echelle_terrain_l3.x<100:
                cls.facteur_echelle_terrain_l3.x=100

        if input.key_down(gs.InputDevice.KeyY):
            cls.facteur_echelle_terrain_l3.y+=100
        elif input.key_down(gs.InputDevice.KeyH):
            cls.facteur_echelle_terrain_l3.y-=100
            if cls.facteur_echelle_terrain_l3.y<100:
                cls.facteur_echelle_terrain_l3.y=100



        elif input.key_down(gs.InputDevice.KeyU):
                cls.amplitude_l1+=100
        elif input.key_down(gs.InputDevice.KeyJ):
            cls.amplitude_l1-=100
            if cls.amplitude_l1<100:
                cls.amplitude_l1=100

        elif input.key_down(gs.InputDevice.KeyI):
                cls.amplitude_l2+=1
        elif input.key_down(gs.InputDevice.KeyK):
            cls.amplitude_l2-=1
            if cls.amplitude_l2<1:
                cls.amplitude_l2=1

        elif input.key_down(gs.InputDevice.KeyO):
                cls.amplitude_l3+=0.05
        elif input.key_down(gs.InputDevice.KeyL):
            cls.amplitude_l3-=0.05
            if cls.amplitude_l3<0.05:
                cls.amplitude_l3=0.05

        elif input.key_down(gs.InputDevice.KeyP):
                cls.facteur_precision_distance+=0.001
        elif input.key_down(gs.InputDevice.KeyM):
            cls.facteur_precision_distance-=0.001
            if cls.facteur_precision_distance<1.001:
                cls.facteur_precision_distance=1.001

        elif input.key_down(gs.InputDevice.KeyNumpad2):
                cls.altitude_eau+=1
        elif input.key_down(gs.InputDevice.KeyNumpad1):
            cls.altitude_eau-=1


        window_size = Demo.rendu.GetDefaultOutputWindow().GetSize()
        xPos=10
        yPos=window_size.y-30

        c=gs.Color(1.,0,0,1.)
        render.text2d(xPos,yPos,"A/Q facteur_echelle_terrain_l1.x: "+str(cls.facteur_echelle_terrain_l1.x),16, c)
        render.text2d(xPos,yPos-15,"Z/S facteur_echelle_terrain_l1.y: "+str(cls.facteur_echelle_terrain_l1.y),16, c)
        render.text2d(xPos,yPos-15*2,"E/D facteur_echelle_terrain_l2.x: "+str(cls.facteur_echelle_terrain_l2.x),16, c)
        render.text2d(xPos,yPos-15*3,"R/F facteur_echelle_terrain_l2.y: "+str(cls.facteur_echelle_terrain_l2.y),16, c)
        render.text2d(xPos,yPos-15*4,"T/G facteur_echelle_terrain_l3.x: "+str(cls.facteur_echelle_terrain_l3.x),16, c)
        render.text2d(xPos,yPos-15*5,"Y/H facteur_echelle_terrain_l3.y: "+str(cls.facteur_echelle_terrain_l3.y),16, c)
        render.text2d(xPos,yPos-15*6,"U/J amplitude_l1: "+str(cls.amplitude_l1),16, c)
        render.text2d(xPos,yPos-15*7,"I/K amplitude_l2: "+str(cls.amplitude_l2),16, c)
        render.text2d(xPos,yPos-15*8,"O/L amplitude_l3: "+str(cls.amplitude_l3),16, c)
        render.text2d(xPos,yPos-15*9,"P/M facteur_precision_distance: "+str(cls.facteur_precision_distance),16, c)
        render.text2d(xPos,yPos-15*10,"1/2 altitude_eau: "+str(cls.altitude_eau),16, c)
Esempio n. 16
0
 def affiche_message_erreur(cls):
     y=450
     for message in cls.message_erreur:
         render.text2d(400,y,message,16, gs.Color.Red)
         y+=20
        if record_motion and dt_sum > 8.0:
            record_motion = False
            record_done = True

    if record_motion:
        new_frame = []
        for current_node in node_list:
            new_motion = {
                "position": current_node.GetTransform().GetPosition() * scale_factor,
                "rotation": current_node.GetTransform().GetRotation(),
            }
            new_frame.append(new_motion)

        stream_list.append(new_frame)

    render.text2d(5, 25, "@%.2fFPS" % (1 / dt_sec))
    render.text2d(5, 5, "Move around with QSZD, left mouse button to look around")
    render.flip()

# Dump record

f = codecs.open(filename_out + ".h", "w")

f.write('#include "genesis.h"\n\n')
f.write("#define SIMULATION_FRAME_LEN " + str(len(stream_list)) + "\n")
f.write("#define SIMULATION_NODE_LEN " + str(len(node_list)) + "\n\n")

f.write("const fix16 " + "physics_sim" + "[] =" + "\n")
f.write("{\n")

out_str = ""
Esempio n. 18
0
def affiche_donnees_environnement(ze_environnement,xPos,yPos,c=gs.Color.White):
    e=16
    bgc=ze_environnement.GetBackgroundColor()
    render.text2d(xPos,yPos,"Environnement: "+ze_environnement.GetAspect(),16, c)
    render.text2d(xPos,yPos-2*e,"Couleur fond: R="+str(round(bgc.r,3))+" V="+str(round(bgc.g,3))+" B="+str(round(bgc.b,3)),16, c)
Esempio n. 19
0
		global radius_circle_eye, counter_seed, lose, win, array_point, array_size_point, array_full_point, array_id_line, next_symbol, reducing, start, reset
		if not input.mouse_button_was_down() and input.mouse_button_down():
			counter_seed = 0
			lose = False
			win = False
			array_point = []
			array_size_point = []
			array_full_point = []
			array_id_line = []
			next_symbol = True
			reducing = 0.0
			start = True
			reset = True

	if lose:
		render.text2d(31.25*size_pixel.x, size.y/4, "You LOSE yourself \nto the devil !", 6.5*size_pixel.x, gameboy_palette[2], font_path="Early GameBoy.ttf")
		render.text2d(size.x/6, size.y/4*3, "Click to Restart", 7.8125*size_pixel.x, gameboy_palette[2], font_path="Early GameBoy.ttf")
		check_clicked()
		draw_pentacle(gs.Vector3(big_resolution.x*0.5, big_resolution.y*0.5, 0), 50, 40)

	if win:
		render.text2d(size.x/20, size.y/4*3.5, "The demon's door is \nnow closed\nCongratulation !", 7.8125*size_pixel.x, gameboy_palette[2], font_path="Early GameBoy.ttf")
		render.text2d(size.x/6, size.y/4, "Click to Restart", 7.8125*size_pixel.x, gameboy_palette[2], font_path="Early GameBoy.ttf")
		check_clicked()

	random.seed(counter_seed)

	render.clear(gs.Color(16/255, 19/255, 12/255))
	# render.clear(gs.Color.Black)

	# draw_circle_explosion(big_resolution.x * .5, big_resolution.y * .5, radius_circle_eye, 10, get_random_color())
Esempio n. 20
0
def affiche_parametres_filtres():
    window_size = Demo.rendu.GetDefaultOutputWindow().GetSize()
    xPos=10
    yPos=window_size.y-30

    c=gs.Color.White
    render.text2d(xPos,yPos,"A/Q pr_taille_aura: "+str(Demo.pr_taille_aura),16, c)
    render.text2d(xPos,yPos-15,"Z/S pr_intensite_aura: "+str(Demo.pr_intensite_aura),16, c)
    render.text2d(xPos,yPos-15*2,"E/D pr_aura_contraste: "+str(Demo.pr_aura_contraste),16, c)
    render.text2d(xPos,yPos-15*3,"R/F pr_aura_seuil_contraste: "+str(Demo.pr_aura_seuil_contraste),16, c)
    render.text2d(xPos,yPos-15*4,"T/G pr_aura_hue: "+str(Demo.pr_aura_hue),16, c)
    render.text2d(xPos,yPos-15*5,"Y/H pr_aura_saturation: "+str(Demo.pr_aura_saturation),16, c)
    render.text2d(xPos,yPos-15*6,"U/J pr_aura_value: "+str(Demo.pr_aura_value),16, c)
    render.text2d(xPos,yPos-15*7,"I/K pr_alpha_aura: "+str(Demo.pr_alpha_aura),16, c)
    render.text2d(xPos,yPos-15*8,"O/L pr_alpha_rendu: "+str(Demo.pr_alpha_rendu),16, c)
    render.text2d(xPos,yPos-15*9,"1/2 pr_Contraste: "+str(Demo.pr_Contraste),16, c)
    render.text2d(xPos,yPos-15*10,"3/4 pr_Seuil_contraste: "+str(Demo.pr_Seuil_contraste),16, c)
    render.text2d(xPos,yPos-15*11,"5/6 pr_Hue: "+str(Demo.pr_Hue),16, c)
    render.text2d(xPos,yPos-15*12,"7/8 pr_Saturation: "+str(Demo.pr_Saturation),16, c)
    render.text2d(xPos,yPos-15*13,"9/0 pr_Value: "+str(Demo.pr_Value),16, c)