# Pyxel Studio

import pyxel, random,math

pyxel.init(160,160, title= 'The space survivor 2')
pyxel.load("3.pyxres")
#3000 parametre + options

v={ 
    'phrase de mort':1,
    'couleur_noir_casier':10,
    'couleur_noir':False,
    'etatJeu' : 0,  
    'score' : 0,
    'vies': 3,
    'victoire':0,
    'victoire2':0,
    'victoire3':0,
    'u':48,
    'v':16,
    'ennemis_2':[],
    'tir_detection':[],
    'tir_fait':False,
    'mouvement':False,
    'vie_ennemis':10,
    'mouvement_e':False,
    'x':16,
    'y':32,
    'invulnérable':False,
    'time_i':0,
    'endurance':100,
    'vie_perdu_totale':0,
    'capsule_soin':[],
    'vitesse':3,
    'victoire_p_deblocage':0,
    'gain_score':1,
    'duree_effets':600,
    'visibilite_boss':70,
    'super':0,
    'capsule_soin_option':True,
    'pause':0,
    'distance_ennemis_fort':0,
    'distance_ennemis_fort_y':0,
    'distance_ennemis_fort_x':0,
    't':0,
    'vitesse_tir_solo':13,
    'vitesse_tir_ennemi':20,
    'couleur_arriereplan':1,
    #armes
    'laser_solo':True,
    'laser_double':False,
    'laser_lock':False,
    'lasers_foudroie':False,
    'laser_split':False,
    'unlock_split':False,
    'timer_split':30,
    'total_score':0,
    'nb_score':0,
    'objectif':[],
    'victoire':0,
    'collision':False,
    'frequence_endurance':90,
    'infinie_endurance':False,
    'tir_super':[],
    'frame_invincibilite':6,
    'spawn_ennemis_fort':True,
    
    'fréquence_apparition_ennemis':30,
    'capsule_endurance':[],
    'tirs_j_split':[],
    'vitesse_e':1,
    'vitesse_tir_e':2,
    'timer_option':900,
    'timer':900,
    'timer_p':900,
    'score_liste':[],
    'limite_essaie':5,
    'pièces':[],
    'x_ia':60,
    'y_ia':40,
    'score_ia':0,
    'tir_ia':[],
    'nb_partie_joué':0,
    'nb_gagné':0,
    'tir_a_droite':True,
    'tir_a_gauche':True,
    'tir_touche':0,
    'tir_totaux':0,
    'bouclier':[],
    'limite_endurance':100,
    'vitesse_option':3,
    'vie_option':4,
    'degats_au_joueur':1,
    'tir_super2':[],
    
    'limite_cone_vision':1,
    'ia_x':60,
    'ia_y':40,
    'cherche_joueur':False,
    'limite_spawn_capsule':1,
    'limite_objectif':1,
    'touchable':False,
    #skin
    'laser_verts':False,
    'laser_rouge':True,
    'laser_multicolore':False,
    'laser_sapin':False,
    'vaisseau_rouge':True,
    'vaisseau_blanc':False,
    'vaisseau_noel':False,
    'mode':0,
    #timer
    'timer_a':200,
    'timer_cache_cache':300,
    'timer_fin_cache':60,
    'timer_effet':[],
    'timer_effet_endurance':[],
    'timer_temps_jeu':0,
    'timer_inv_ennemi2':[],
    'invulnerable_e:':False,
    #pas
    'pas_restant':0,
    'pas_en_moins':1/3,
    #skin,monnaie
    'monnaie':0,
    'payer_vaisseau_noel':False,
    'p_laser_vert':False,
    'p_laser_multicolore':False,
    'p_laser_sapin':False,
    'p_vaisseau_blanc':False,
    'l_monnaie':1,
    #aléatoire
     'n':0,
     'x':0,
     'l':0,
     'limite_aleatoire':1,
     'limite_l':1,
     'mouv':1,
     #lieu
     'dans_les_buissons':False,
     #musique
     'm':1
    
}    










#===============================================
#               UPDATE___ DRAW __ GENERAL ====================================================================

def update():
    
    gestion_temps_jeu()
    if v['etatJeu']==0:
        update_menu()
        
        
    if v["etatJeu"]==1:
        update_game()
       
       
        
    
    if v["etatJeu"]==2:
        update_gameover()
    if v["etatJeu"]==3:
        update_game5()
    if v['etatJeu']==5:
        update_game3()
    if v['etatJeu']==6:
        update_objectif()

    if v['etatJeu']==7:
        update_skin()
    if v["etatJeu"]==4:
        update_settings()
    if v['etatJeu']==8:
        update_casier()
    if v['etatJeu']==9:
        update_score()
    if v['etatJeu']==10:
        update_astuce()
    if v['etatJeu']==11:
        update_show_score()
    if v['etatJeu']==12:
        update_fin_piece()
    if v['etatJeu']==13:
        update_option()
    if v['etatJeu']==14:
        update_option2()
    if v['etatJeu']==15:
        update_game2()
    if v['etatJeu']==16:
        update_pause()
    
pyxel.playm(v['m'],loop=True)        
    
    
    
    
    
    
    
    
    
def draw():
    if v["etatJeu"]==0:
        draw_menu()
        
    if v["etatJeu"]==1:
        draw_game()
        
    if v["etatJeu"]==2:
        draw_gameover()
    if v['etatJeu']==3:
        draw_game5()
    if v['etatJeu']==5:
        draw_game3()
    if v['etatJeu']==6:
        draw_objectif()
    if v['etatJeu']==7:
        draw_skin()
    if v["etatJeu"]==4:
        draw_settings()
    if v['etatJeu']==8:
        draw_casier()
    if v['etatJeu']==9:
        draw_score()
    if v['etatJeu']==10:
        draw_astuce()
    if v['etatJeu']==11:
        draw_show_score()
    if v['etatJeu']==12:
        draw_fin_piece()
    if v['etatJeu']==13:
        draw_option()
    if v['etatJeu']==14:
        draw_option2()
    if v['etatJeu']==15:
        draw_game2()
    if v['etatJeu']==16:
        draw_pause()
    
    
 ###################################################################################casier   
def update_casier():
   
    
    if pyxel.btnp(pyxel.KEY_M):   
        v['etatJeu'] =0
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_SPACE):
        v['laser_solo']=True
        v['laser_lock']=False
        v['laser_double']=False
        v['lasers_foudroie']=False
        v['laser_split']=False
        pyxel.play(0,11)
        
    if b['unlock_double'] >0:

        if pyxel.btn(pyxel.KEY_D):
            v['laser_double']=True
            v['laser_lock']=False
            v['laser_solo']=False
            v['lasers_foudroie']=False
            v['laser_split']=False
            pyxel.play(0,11)
            
  
        
    if b['unlock_lock']>0:
        if pyxel.btn(pyxel.KEY_R):
            v['laser_lock']=True
            v['laser_double']=False
            v['laser_solo']=False
            v['lasers_foudroie']=False
            v['laser_split']=False
            pyxel.play(0,11)
    
    if b['unlock_destroy']>0:
        if pyxel.btn(pyxel.KEY_F):
            v['laser_lock']=False
            v['laser_double']=False
            v['laser_solo']=False
            v['lasers_foudroie']=True
            v['laser_split']=False
            pyxel.play(0,11)
    if v['unlock_split']>0:
        if pyxel.btn(pyxel.KEY_C):
            v['laser_lock']=False
            v['laser_double']=False
            v['laser_solo']=False
            v['lasers_foudroie']=False
            v['laser_split']=True
            pyxel.play(0,11)
    
            
   

    
    




def draw_casier():
    pyxel.cls(v['couleur_arriereplan'])
    if pyxel.frame_count%20<10:
        pyxel.text(60,10, "Menu des armes", 13)
    else:
        pyxel.text(60,10, "Menu des armes", 10)
    if pyxel.frame_count%40>20:    
        pyxel.blt(30,20,0,0,128,32,16,1)
    else:
        pyxel.blt(28,20,0,0,192,48,32,1)
    if pyxel.frame_count%60>20:
        pyxel.blt(80,20,0,26,144,30,16,1)
    elif pyxel.frame_count%60<20<40:
        pyxel.blt(80,20,0,75,144,39,16,1)
    else:
        pyxel.blt(80,20,0,80,184,70,16,1)
    
    if v['unlock_split']>=1:
        if v['laser_split']:
            pyxel.text(40,115, "laser croix:C",8)
        else:
            pyxel.text(40,115, "laser croix:C", v['couleur_noir_casier'])
    else:
        pyxel.text(40,115, "Requis:victoire cache-cache",v['couleur_noir_casier'])
        pyxel.blt(150,113,0,212,44,10,11,1)




    if v['laser_solo']:
        pyxel.text(40,55, "laser solo:espace",8)
    else:
        pyxel.text(40,55, "laser solo:espace", v['couleur_noir_casier'])

    if b['unlock_double']>=1:
        if v['laser_double']:
            pyxel.text(40,70, "laser double:D", 8)
        else:
            pyxel.text(40,70, "laser double:D", v['couleur_noir_casier'])
    else:
        pyxel.text(40,70, "score:20 requis",v['couleur_noir_casier'])
        pyxel.blt(105,68,0,212,44,10,11,1)
    if b['unlock_lock']>=1:
        if v['laser_lock']:
            pyxel.text(40,85, "laser lock:R", 8)
        
        else:
            pyxel.text(40,85, "laser lock:R",v['couleur_noir_casier'])
    else:
        pyxel.text(40,85, "score:25 requis",v['couleur_noir_casier'])
        pyxel.blt(105,83,0,212,44,10,11,1)

    if b['unlock_destroy']>=1:
        if v['lasers_foudroie']:

            pyxel.text(40,100, "laser_foudroie:f",8)
        else:
            pyxel.text(40,100, "laser_foudroie:f", v['couleur_noir_casier'])
    else:
        pyxel.text(40,100, "score:27 requis",v['couleur_noir_casier'])
        pyxel.blt(105,98,0,212,44,10,11,1)
    pyxel.text(10,150,"M:Menu",v['couleur_noir_casier'])

    
    




#
#=============================================================================      MENU         ===============================================================


def update_menu():
    if pyxel.btnp(pyxel.KEY_4):
        v['etatJeu']=10
        v['mode']=10
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_SPACE) and(v['laser_solo']==True or v['laser_double']==True or v['laser_lock']==True or v['lasers_foudroie']==True or v['laser_split']==True)and (v['limite_essaie']>0):
          
        v['etatJeu']=10
        v['mode']=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_3):
        v['etatJeu']=10
        v['mode']=3
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_C):
        v['etatJeu']=8
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_N):
        v['etatJeu']=4
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_S):
        v['etatJeu']=9
        
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_SPACE) and v['limite_essaie']<=0:
        v['score_liste']=[]
        v['limite_essaie']=5
        v['nb_score']=0
        v['total_score']=0
        pyxel.play(0,11)
        
    if pyxel.btnp(pyxel.KEY_P)and(v['laser_solo']==True or v['laser_double']==True or v['laser_lock']==True or v['lasers_foudroie']==True or v['laser_split']==True):
        v['etatJeu']=10
        v['mode']=2
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_X):
        v['etatJeu']=7
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_Q):
        pyxel.quit()
    limite_pas()
    

    
    
    
    
    
    
   
    init()
    
   

def draw_menu():
    pyxel.cls(0)
    pyxel.bltm(0,0,3,0,0,160,160,0)
    if pyxel.frame_count%40>20:
        pyxel.blt(125,105,0,26,144,30,16,1)
    else:
        pyxel.blt(125,105,0,75,144,39,16,1)
        pyxel.play(1,15)


    monnaie_Affichage()

    pyxel.text(80,45, "Menu", 8)
    if pyxel.frame_count%30>10:
        pyxel.text(60,20,"SPACE SURVIVOR 2",3)
    else :
        pyxel.text(60,20,"SPACE SURVIVOR 2",10)
    
    if v['limite_essaie']>0:
        if pyxel.frame_count%10>5:
    
            pyxel.text(40, 58, "4:mode super ennemi!", 10)
        else:
            pyxel.text(40, 58, "4:mode super ennemi!", 13)


    if v['laser_solo']==True or v['laser_double']==True or v['laser_lock']==True or v['lasers_foudroie']==True or v['laser_split'] :
        if v['limite_essaie']>0:
            if pyxel.frame_count%10>5:
                pyxel.text(40, 88, "ESPACE: mode ennemi", 10)
            else:
                pyxel.text(40, 88, "ESPACE: mode ennemi", 9)
            

        else:
            pyxel.text(40, 88, "ESPACE:RESET", 10)
    if v["limite_essaie"]>0 and (v['laser_solo']==True or v['laser_double']==True or v['laser_lock']==True or v['lasers_foudroie']==True or v['laser_split']):
        pyxel.text(40,78, "P: mode piece", 9)
        if pyxel.frame_count%40>20:
            pyxel.blt(115,82,0,40,104,16,16,1)
        else:
            pyxel.blt(115,82,0,216,240,16,16,1)

    if pyxel.frame_count%20>10:
        pyxel.text(40,68, "3: mode cache-cache", 3)
    else:
        pyxel.text(40,68, "3: mode cache-cache", 8)
    pyxel.text(40,142, "x: skins", 10)
    pyxel.text(40,152, "Q:quitter le jeu", 7)
    
    

    
        

    pyxel.text(40, 100, "N:Parametres", 9)
    if v['laser_double']==False and v['laser_lock']==False and v['lasers_foudroie']==False and v['laser_solo']==False:
        if pyxel.frame_count%25>12.5:
            pyxel.text(40,112, "c:choisis ton arme", 9)
        else:
            pyxel.text(40,112, "c:choisis ton arme", 3)
    else:
        pyxel.text(40,112, "c:choisis ton arme", 9)


    pyxel.text(40,122,"s:acceder au score", 5)
    pyxel.text(40,132,"essai(s)restant(s)"+str(v['limite_essaie']), 8)
    

    
#
#==================================================================================     GAME ============================================================================
b={
    'x':0,
    'y':130,
    'ennemis':[],
    'tirs_j':[],
    'tirs_e': [],
    'explosions':[],
    'tirs_restants':6,
    'bombes_restantes':2,
    'bombes':[],
    'explosions_bombes':[],
    'explosions_ennemis':[],
    'degat_explosion':[],
    'invulnérable_b':False,
    'unlock_double':0,
    'unlock_destroy':0,
    'unlock_lock':0,
    'limite_barricade':3,
    'map_desert':False,
    'map_colline':True
    
}



#monnaie du jeu
def monnaie_Affichage():
    pyxel.text(0,10,""+str(v['monnaie']),10)
    pyxel.text(12,10,"$",10)
#mouvement du vaisseau joueur
def vaisseau_joueur_move():
    if b['x']>=152:
        b['x']=152
    if b['y']>=152:
        b['y']=152
    if b['x']<=8:
        b['x']=8
    if b['y']<=8:
        b['y']=8    
    if v['etatJeu']!=5:
        if pyxel.btn(pyxel.KEY_LEFT)  and v['endurance']>=1 :
            b['x']-=v['vitesse']
            v['endurance']-=0.1
        if pyxel.btn(pyxel.KEY_RIGHT) and v['endurance']>=1:
            b['x']+=v['vitesse']
            v['endurance']-=0.1
    
        if pyxel.btn(pyxel.KEY_UP) and v['endurance']>=1:
            b['y']-=v['vitesse']
            v['endurance']-=0.1
        if pyxel.btn(pyxel.KEY_DOWN) and v['endurance']>=1:
            b['y']+=v['vitesse']
            v['endurance']-=0.1
    else:
        if pyxel.btn(pyxel.KEY_LEFT)  and v['pas_restant']>0 :
            b['x']-=v['vitesse']
            v['pas_restant']-=v['pas_en_moins']
        if pyxel.btn(pyxel.KEY_RIGHT) and v['pas_restant']>0:
            b['x']+=v['vitesse']
            v['pas_restant']-=v['pas_en_moins']
            
    
        if pyxel.btn(pyxel.KEY_UP) and v['pas_restant']>0:
            b['y']-=v['vitesse']
            v['pas_restant']-=v['pas_en_moins']
            
        if pyxel.btn(pyxel.KEY_DOWN) and v['pas_restant']>0:
            b['y']+=v['vitesse']
            v['pas_restant']-=v['pas_en_moins']
           

        #creation d ennemis
def ennemis_creation():
    if pyxel.frame_count%v['fréquence_apparition_ennemis']==0:
        b['ennemis'].append([random.randint(10,130),random.randint(0,15)])
        #mouvements d ennemis
def ennemis_move():
    for ennemi in b['ennemis']:
        ennemi[1]+=v['vitesse_e']
       
            
        if v['score']>=10:
            v['vitesse_e']=2.5
        if v['score']>=20:
            v['vitesse_e']=3

        if ennemi[1]>=155:
            b['explosions_ennemis'].append([ennemi[0],ennemi[1]-6,30])
            b['ennemis'].remove(ennemi)
def gestion_timer_astuce():
    if v['timer_a']>0:
        v['timer_a']-=1
    
#musique
def gestion_musique()  :
    if v['etatJeu']==0:
        v['m']=1
    if v['etatJeu']==1:
        v['m']=6
    else:
        v['m']=1        
def gestion_explosion_ennemis():
    for explosion_e in b['explosions_ennemis']:
        explosion_e[2]-=1
        if explosion_e[2]<=0:
            b['explosions_ennemis'].remove(explosion_e)
           
#COLLISION
def collision(ax1,ay1,ax2,ay2,bx1,by1,bx2,by2):
    if ax1 > bx2 or ay1 >by2 or bx1>ax2 or by1>ay2:
        return False
    else:
        return True
def endurance():
    if v['endurance']>=v['limite_endurance']:
        v['endurance']=v['limite_endurance']
    if v['endurance']<=0:
        v['endurance']=0
    if v['endurance']<v['limite_endurance'] and pyxel.frame_count%v['frequence_endurance']==0:
        v['endurance']+=30
    
   #capsules 
def capsule_generate():
    if v['vies']==1 and pyxel.frame_count%40==0 and v['capsule_soin_option']:
        if v['vie_option']>1:
            v['capsule_soin'].append([random.randint(0,135),3])
def capsule_move():
    for capsule in v['capsule_soin']:
        capsule[1]+=1
        if capsule[1]>=135:
            v['capsule_soin'].remove(capsule)
def capsule_endurance_creation():
    if v['limite_spawn_capsule']>0:
        v['capsule_endurance'].append([random.randint(1,130),random.randint(1,130)])
        v['limite_spawn_capsule']-=1
def capsule_move_endurance():
    for c in v['capsule_endurance']:
        c[1]-=0.1
        if c[1]<5:
            c[1]=5
def capsule_end_draw():
    for c in v['capsule_endurance']:
        if pyxel.frame_count%40>20:
            pyxel.blt(c[0],c[1],0,232,0,16,16,1)
        else:
            pyxel.blt(c[0],c[1],0,216,136,16,16,1)
    if v['infinie_endurance']:
        pyxel.text(0,130,"munitions infinies!",8)
    if v['vitesse']>=v['vitesse_option']+1:
        pyxel.text(0,120,"boost de vitesse",8)


def touche_joueur_endurance_capsule():
    for c in v['capsule_endurance']:
        if collision(b['x'],b['y'],b['x']+16,b['y']+16,c[0],c[1],c[0]+16,c[1]+16):
            v['capsule_endurance'].remove(c)
            v['timer_effet_endurance'].append([v['duree_effets']])
            
def gestion_effet_endurance() :   
    if len(v['timer_effet_endurance'])>0:
        for i in v['timer_effet_endurance'] :
            i[0] -=1
            if i[0]  <=0:
                v['infinie_endurance']=False
                
            else:
                v['infinie_endurance']=True
                


            
def touche_joueur_capsule():
    for capsule in v['capsule_soin']:
        if collision(b['x'],b['y'],b['x']+16,b['y']+16,capsule[0],capsule[1],capsule[0]+16,capsule[1]+16):
            v['capsule_soin'].remove(capsule)
            v['vies']+=1
            v['timer_effet'].append([v['duree_effets']])
          

            
            
            if v['vies']>=v['vie_option']:
                v['vies']=v['vie_option']
            
def gestion_effet():
    if len(v['timer_effet'])>0:
        for t in v['timer_effet']  :
            t[0]-=1
            if t[0]<=0:
                v['vitesse'] =v['vitesse_option']
                v['timer_effet'].remove(t)
            else:
                v['vitesse']=v['vitesse_option']+1

def gestion_temps_jeu() : 
    v['timer_temps_jeu']+=1
def temps_jeu_draw():
    pyxel.text(15,70,"temps de jeu:"+str(round(v['timer_temps_jeu']/30)),13)   
    pyxel.text(86,70,"seconde(s)",13)
    



def touche_tir_e_capsule():

    for capsule in v['capsule_soin']:
        for tir_e in b['tirs_e']:
            if collision(tir_e[0],tir_e[1],tir_e[0]+8,tir_e[1]+10,capsule[0],capsule[1],capsule[0]+16,capsule[1]+16) and len(v['capsule_soin'])>0:
                if capsule in v['capsule_soin']:
                    v['capsule_soin'].remove(capsule)
                    b['tirs_e'].remove(tir_e)
                
def temps_niveau():
    if v['timer'] >0:
        v['timer'] -=1
    else:
        v['etatJeu']=11
        v['score_liste'].append(v['score'])
        v['nb_score']+=1
        v['total_score']+=v['score']
        v['limite_essaie']-=1
def temps_niveau_pièce():
    if v['timer_p'] >0:
        v['timer_p'] -=1
    else:
        v['etatJeu']=12
        v['nb_partie_joué']+=1
        if v['score']>v['score_ia']:
            v['nb_gagné']+=1
             
def touche_ennemi_capsule():
    
    for capsule in v['capsule_soin']:
            
        for ennemi in b['ennemis']:
            if collision(ennemi[0],ennemi[1],ennemi[0]+8,ennemi[1]+13,capsule[0],capsule[1],capsule[0]+16,capsule[1]+16):
                if capsule in v['capsule_soin']:
                    v['capsule_soin'].remove(capsule)
                    b['ennemis'].remove(ennemi)
    
#tirs_joueur
def tirs_joueur_creation():
    if pyxel.btnp(pyxel.KEY_SPACE) and v['endurance']>=40 and v['lasers_foudroie']==True and v['super']<100:            
         
        b['tirs_j'].append([b['x']+30,b['y'],b['x'],b['y'],b['x']+65,b['y'],b['x']-65,b['y'],b['x']-30,b['y']])
        if v['infinie_endurance']==False:
            v['endurance']-=40
        else:
            v['endurance']-=0


        v['tir_totaux']+=5
        pyxel.play(0,13)
    if pyxel.btnp(pyxel.KEY_SPACE) and v['endurance']>=25 and v['laser_split']==True and v['super']<100:            
        
       
        v['tirs_j_split'].append([b['x'],b['y'],15])
        if v['infinie_endurance']==False:
            
            v['endurance']-=25
        else:
            v['endurance']-=0

        v['tir_totaux']+=1
        pyxel.play(3,6)        
    if pyxel.btnp(pyxel.KEY_SPACE) and v['endurance']>=20 and v['laser_lock']==True and v['super']<100:            
        
        
        b['tirs_j'].append([b['x'],b['y']])
        if v['infinie_endurance']==False:
            v['endurance']-=20
        else:
            v['endurance']-=0


      
        v['tir_totaux']+=1
        pyxel.play(3,6)
            
    
            
    if pyxel.btnp(pyxel.KEY_SPACE) and v['endurance']>=40 and v['laser_double']==True and v['super']<100:            
         
        b['tirs_j'].append([b['x']+16,b['y'],b['x'],b['y']])
        if v['infinie_endurance']==False:
            v['endurance']-=40
        else:
            v['endurance']-=0
        v['tir_totaux']+=2
        pyxel.play(3,6)
                
           
    if pyxel.btnp(pyxel.KEY_SPACE) and v['endurance']>=15 and  v['laser_solo']==True and v['super']<100:       
        v['tir_a_droite']= False
        v['tir_a_gauche']=False
        b['tirs_j'].append([b['x'],b['y']])
        if v['infinie_endurance']==False:
            v['endurance']-=15
        else:
            v['endurance']-=0
        v['tir_totaux']+=1
        pyxel.play(3,6)
    if pyxel.btnp(pyxel.KEY_2) and v['endurance']>=15 and  v['laser_solo']==True:       
        v['tir_a_droite']=  True
        v['tir_a_gauche']=False
        b['tirs_j'].append([b['x'],b['y']])
        v['endurance']-=15
        v['tir_totaux']+=1
        pyxel.play(3,6)
    if pyxel.btnp(pyxel.KEY_1) and v['endurance']>=15 and  v['laser_solo']==True:       
        v['tir_a_gauche']=  True
        v['tir_a_droite']=False
        b['tirs_j'].append([b['x'],b['y']])
        v['endurance']-=15
        v['tir_totaux']+=1
        pyxel.play(3,6)
def tirs_super():
        if v['laser_solo']:
            if pyxel.btnp(pyxel.KEY_SPACE) and v['super']>=100 :   
                v['super']-=v['super']
                v['tirs_j_split'].append([b['x'],b['y'],15])
                v['tir_totaux']+=1
        if v['lasers_foudroie']:
            if pyxel.btnp(pyxel.KEY_SPACE) and v['super']>=100 :
                v['super']-=v['super']
                v['tirs_j_split'].append([b['x']+30,b['y'],b['x'],b['y'],b['x']+65,b['y'],b['x']-65,b['y'],b['x']-30,b['y'],35])
                v['tir_totaux']+=5
                pyxel.play(0,13)
        if v['laser_lock']:
            if pyxel.btnp(pyxel.KEY_SPACE) and v['super']>=100 :
                v['super']-=v['super']
                v['tirs_j_split'].append([b['x'],b['y'],b['x']+40,b['y'],b['x']-40,b['y'],60])
                v['tir_totaux']+=3
                pyxel.play(3,6)
        if v['laser_double']:
             if pyxel.btnp(pyxel.KEY_SPACE) and v['super']>=100 :
                v['super']-=v['super']
                v['tirs_j_split'].append([b['x']+16,b['y'],b['x'],b['y'],b['x']-16,b['y'],10])
                v['tir_totaux']+=2
                pyxel.play(3,6)
        if v['laser_split']:
            if pyxel.btnp(pyxel.KEY_SPACE) and v['super']>=100 :
                v['super']-=v['super']
                v['tir_super2'].append([b['x'],b['y'],15])
                v['tir_totaux']+=1
                pyxel.play(3,6)
                
def tir_super_deplacement(): 
    if v['laser_solo']:
        for tir in v['tirs_j_split']  :
            tir[1]-=v['vitesse_tir_solo']
            tir[2]-=1
            if tir[2]<=0:
                v['tir_super'].append([0,0,140,0,0,140,140,140,70,0])
                v['tirs_j_split'].remove(tir)
        for tir_j in v['tir_super']:
            tir_j[1]+=10
            tir_j[0]+=10
            tir_j[2]-=10
            tir_j[3]+=10
            tir_j[4]+=10
            tir_j[5]-=10
            tir_j[6]-=10
            tir_j[7]-=10
            
            tir_j[9]+=10

    if v['lasers_foudroie']:
        for tir in v['tirs_j_split']:
            tir[1]-=4
            tir[3]-=4
            tir[5]-=4
            tir[7]-=4
            tir[9]-=4
            tir[10]-=1
            if tir[10]<=0:
                pyxel.play(0,13)
                v['tir_super'].append([tir[0],tir[1],tir[2],tir[3],tir[4],tir[5],tir[6],tir[7],tir[8],tir[9]])
                v['tirs_j_split'].remove(tir)
        for tir in v['tir_super']:
            tir[1]+=6
            tir[3]+=6
            tir[5]+=6
            tir[7]+=6
            tir[9]+=6
    if v['laser_lock']:
        for tir in v['tirs_j_split']:
            tir[1]-=3
            tir[6]-=1
            tir[3]-=3
            tir[5]-=3
            if tir[6]<=0:
                if tir in v['tirs_j_split']:
                    v['tirs_j_split'].remove(tir)
            for ennemi in b['ennemis']:
                if tir[0]>ennemi[0]:
                    tir[0]-=10
                if tir[0]<ennemi[0]:
                    tir[0]+=10
                if tir[1]<ennemi[1]:
                    tir[1]+=10
                if tir[1]>ennemi[1]:
                    tir[1]-=10
                if tir[1]<0 or tir[3]<0 or tir[5]<0:
                    v['tirs_j_split'].remove(tir)
            

                
                
                if tir[2]>ennemi[0]:
                    tir[2]-=10
                if tir[2]<ennemi[0]:
                    tir[2]+=10
                if tir[3]<ennemi[1]:
                    tir[3]+=10
                if tir[3]>ennemi[1]:
                    tir[3]-=10

                if tir[4]>ennemi[0]:
                    tir[4]-=10
                if tir[4]<ennemi[0]:
                    tir[4]+=10
                if tir[5]<ennemi[1]:
                    tir[5]+=10
                if tir[5]>ennemi[1]:
                    tir[5]-=10
            for ennemi in v['ennemis_2']:
                if tir[0]>ennemi[0]:
                    tir[0]-=10
                if tir[0]<ennemi[0]:
                    tir[0]+=10
                if tir[1]<ennemi[1]:
                    tir[1]+=10
                if tir[1]>ennemi[1]:
                    tir[1]-=10
                
            

                
                
                if tir[2]>ennemi[0]:
                    tir[2]-=10
                if tir[2]<ennemi[0]:
                    tir[2]+=10
                if tir[3]<ennemi[1]:
                    tir[3]+=10
                if tir[3]>ennemi[1]:
                    tir[3]-=10

                if tir[4]>ennemi[0]:
                    tir[4]-=10
                if tir[4]<ennemi[0]:
                    tir[4]+=10
                if tir[5]<ennemi[1]:
                    tir[5]+=10
                if tir[5]>ennemi[1]:
                    tir[5]-=10
    if v['laser_double']:
        for tir in v['tirs_j_split']:
            tir[1]-=11
            tir[3]-=11
            tir[5]-=11
            tir[6]-=1
            if tir[6]<=0:
                v['tir_super'].append([140,0,140,0])
                v['tirs_j_split'].remove(tir)
        for tir in v['tir_super']:
            tir[0]-=12
            tir[2]-=12
    if v['laser_split']:
        for tir in v['tir_super2']:
            tir[1]-=3
            tir[2]-=1
            if tir[2]<=0:
                v['tir_super'].append([tir[0],tir[1],tir[0],tir[1],tir[0],tir[1],tir[0],tir[1],tir[0],tir[1],tir[0],tir[1],tir[0],tir[1],tir[0],tir[1]])
                v['tir_super2'].remove(tir)
        for tir in v['tir_super']:
            tir[1]-=7
            tir[2]-=7
            tir[4]+=7
            tir[7]+=7
            tir[8]+=7
            tir[9]+=7
            tir[10]-=7
            tir[11]-=7
            tir[12]+=7
            tir[13]-=7
            tir[14]-=7
            tir[15]+=7



def super_draw():
    if v['super'] <=0:
        pyxel.blt(0,20,0,208,178,16,4,1)
    if v['super'] >0 and v['super']<10:
        pyxel.blt(0,20,0,208,195,16,4,1)
    if v['super']>=10 and v['super']<=25:
        pyxel.blt(0,20,0,208,228,16,4,1)
    if v['super']>25 and v['super']<35:
        pyxel.blt(0,20,0,208,204,16,4,1)
    
    if v['super']>=35 and v['super']<=45:
        pyxel.blt(0,20,0,208,219,16,4,1)
    if v['super']>45 and v['super']<=55:
        pyxel.blt(0,20,0,208,185,16,4,1)
    if v['super']>55 and v['super']<70:
        pyxel.blt(0,20,0,208,163,16,4,1)
    if v['super']>=70 and v['super']<80:
        pyxel.blt(0,20,0,208,169,16,4,1)
    if v['super']>=80 and v['super']<90:
        pyxel.blt(0,20,0,209,191,16,4,1)
    if v['super']>=90 and v['super']<100:
        pyxel.blt(0,20,0,208,155,16,4,1)
    if v['super']>=100:
        pyxel.blt(0,20,0,208,211,16,4,1)




                
    
        
    
  
         
def tir_joueur_deplacement():
    if v['laser_split']:
        for tir in v['tirs_j_split']:
            tir[1]-=3
            tir[2]-=1
            if tir[2]<=0:
                b['tirs_j'].append([tir[0],tir[1],tir[0],tir[1],tir[0],tir[1],tir[0],tir[1],15])
                pyxel.play(0,12)
                v['tirs_j_split'].remove(tir)
        for tir_j in b['tirs_j']:
            tir_j[8]-=1
            tir_j[1]-=7
            tir_j[2]-=7
            tir_j[4]+=7
            tir_j[7]+=7
            if tir_j[8]<=0:
                b['tirs_j'].remove(tir_j)

               

    if v['laser_lock'] and v['etatJeu']!= 10:
        for tir in b['tirs_j']:
            tir[1]-=3
            if tir[1]<=0:
                b['tirs_j'].remove(tir)
            if tir[1]>160:
                b['tirs_j'].remove(tir) 
            for ennemi in b['ennemis']:
                if tir[0]>ennemi[0]:
                    tir[0]-=10
                if tir[0]<ennemi[0]:
                    tir[0]+=10
                if tir[1]<ennemi[1]:
                    tir[1]+=10
                if tir[1]>ennemi[1]:
                    tir[1]-=10
            for ennemi in v['ennemis_2']:
                if tir[0]>ennemi[0]:
                    tir[0]-=10
                if tir[0]<ennemi[0]:
                    tir[0]+=10
                if tir[1]<ennemi[1]:
                    tir[1]+=10
                if tir[1]>ennemi[1]:
                    tir[1]-=10
            
    if v['laser_lock'] and v['etatJeu']==3:
        for tir in b['tirs_j']:
            tir[1]-=3
            if tir[1]<=0:
                b['tirs_j'].remove(tir)
            if tir[1]>160:
                b['tirs_j'].remove(tir) 
            for pièce in v['pièces']:
                if tir[0]>pièce[0]:
                    tir[0]-=3
                if tir[0]<pièce[0]:
                    tir[0]+=3
                if tir[1]<pièce[1]:
                    tir[1]+=3
                if tir[1]>pièce[1]:
                    tir[1]-=3
    

    elif v['laser_double']:
        for tir in b['tirs_j']:
            tir[1]-=13
            tir[3]-=13
            if tir[1]<=0:
                b['tirs_j'].remove(tir)
    elif v['lasers_foudroie']:
        for tir in b['tirs_j']:
            tir[1]-=4
            tir[3]-=4
            tir[5]-=4
            tir[7]-=4
            tir[9]-=4
            if tir[1]>140 and tir[3]>140 and tir[5]>140 and tir[7]>140 and tir[9] <=0:
                b['tirs_j'].remove(tir)

                
                
    elif  v['laser_solo'] and v['tir_a_droite'] ==False and v['tir_a_gauche']==False :
        for tir in b['tirs_j']:
                    
            tir[1]-=v['vitesse_tir_solo']
            if tir[1]<=0:
                b['tirs_j'].remove(tir)
    elif v['laser_solo']and v['tir_a_droite'] and v['tir_a_gauche']==False:
        for tir in b['tirs_j']:
            tir[0]+=13
            if tir[0]>=140:
                b['tirs_j'].remove(tir)
    elif v['laser_solo']and v['tir_a_gauche'] and v['tir_a_droite'] ==False:
        for tir in b['tirs_j']:
            tir[0]-=13
            if tir[0]<=0:
                b['tirs_j'].remove(tir)
    

    
def bombe_creation():
    if pyxel.btnp(pyxel.KEY_C):
        b['bombes'].append([b['x']-25,b['y']-30,b['x']+25,b['y'],60])
        b['bombes_restantes']-=1
def bombe_deplacement():
    for bombe in b['bombes']:
        bombe[1]-=0
        bombe[3]-=0
        bombe[4]-=1
        if bombe[4]<=0:
            b['explosions_bombes'].append([bombe[0],bombe[1],bombe[2],bombe[3],15])
            
            b['bombes'].remove(bombe)

            
#touche_ennemi        
def touche_joueur_explosion():
    b['invulnerable_b']=False
    for explosion_e in b['explosions_ennemis']:
        if collision(b['x'],b['y'],b['x']+10,b['y']+8,explosion_e[0],explosion_e[1],explosion_e[0]+11,explosion_e[1]+8) and b['invulnerable_b']==False:
            v['vies']-=1
            b['degat_explosion'].append([15])
            b['explosions_ennemis'].remove(explosion_e)
        elif collision(b['x'],b['y'],b['x']+10,b['y']+8,explosion_e[0],explosion_e[1],explosion_e[0]+11,explosion_e[1]+8) and v['invulnerable_b']==True:
            v['vies']-=0
def gestion_invulnerable_explosion():
    for degat in b['degat_explosion']:
        b['invulnerable_b']=True
        if degat[0]>0:
            degat[0]-=1
            
        else:
            b['invulnerable_b']=False
def invuln_ennemi2():
    if len(v['timer_inv_ennemi2'])>0:
        for t in v['timer_inv_ennemi2']:
            if t[0]>0:
                t[0]-=1
                v['invulnerable_e:']=True
            else:
                v['invulnerable_e:']=False
def touche_ennemis():
    if v['laser_split']:
        for ennemi in b['ennemis']:
            for tir in v['tirs_j_split']:
                if collision(tir[0],tir[1],tir[0]+16,tir[1]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=15
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
            for tir in v['tir_super2']:
                if collision(tir[0],tir[1],tir[0]+16,tir[1]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=15
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
            
            for tir in v['tir_super']:
                if collision(tir[0],tir[1],tir[0]+16,tir[1]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[2],tir[3],tir[2]+16,tir[3]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[4],tir[5],tir[4]+16,tir[5]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[6],tir[7],tir[6]+16,tir[7]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                    

                if collision(tir[8],tir[9],tir[8]+16,tir[9]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[10],tir[11],tir[10]+16,tir[11]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[12],tir[13],tir[12]+16,tir[13]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[14],tir[15],tir[14]+16,tir[15]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
        



        for ennemi in b['ennemis']:
            for tir_j in b['tirs_j']:
                if collision(tir_j[0],tir_j[1],tir_j[0]+16,tir_j[1]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                        v['tir_touche']+=1
                        v['super']+=5
                        v['score']+=v['gain_score']
                        v['endurance']+=0
                        pyxel.play(2,5) 
                if collision(tir_j[2],tir_j[3],tir_j[2]+16,tir_j[3]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                        v['tir_touche']+=1
                        v['super']+=15
                        v['score']+=v['gain_score']
                        v['endurance']+=0
                        pyxel.play(2,5) 
                if collision(tir_j[4],tir_j[5],tir_j[4]+18,tir_j[5]+18,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                        v['tir_touche']+=1
                        v['super']+=15
                        v['score']+=v['gain_score']
                        v['endurance']+=0
                        pyxel.play(2,5) 
                if collision(tir_j[6],tir_j[7],tir_j[6]+16,tir_j[7]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                        v['tir_touche']+=1
                        v['super']+=15
                        v['score']+=v['gain_score']
                        v['endurance']+=0
                        pyxel.play(2,5) 

#tir contre ennemi2
        
        for ennemi in v['ennemis_2']:
            for tir in v['tirs_j_split']:
                if collision(tir[0],tir[1],tir[0]+16,tir[1]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['super']+=15
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
            for tir in v['tir_super2']:
                if collision(tir[0],tir[1],tir[0]+16,tir[1]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['super']+=15
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
            
            for tir in v['tir_super']:
                if collision(tir[0],tir[1],tir[0]+16,tir[1]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[2],tir[3],tir[2]+16,tir[3]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[4],tir[5],tir[4]+16,tir[5]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[6],tir[7],tir[6]+16,tir[7]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[8],tir[9],tir[8]+16,tir[9]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[10],tir[11],tir[10]+16,tir[11]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[12],tir[13],tir[12]+16,tir[13]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[14],tir[15],tir[14]+16,tir[15]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                
            for tir_j in b['tirs_j']:
                if collision(tir_j[0],tir_j[1],tir_j[0]+16,tir_j[1]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['tir_touche']+=1
                    v['super']+=5
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir_j[2],tir_j[3],tir_j[2]+16,tir_j[3]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['tir_touche']+=1
                    v['super']+=15
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir_j[4],tir_j[5],tir_j[4]+18,tir_j[5]+18,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['tir_touche']+=1
                    v['super']+=15
                    v['score']+=v['gain_score']
                    v['endurance']+=0 
                    pyxel.play(2,5) 
                if collision(tir_j[6],tir_j[7],tir_j[6]+16,tir_j[7]+16,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=3
                    v['tir_touche']+=1
                    v['super']+=15
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
        


    
    if v['laser_double']:
        for ennemi in b['ennemis']:
            for tir in b['tirs_j']:
            
                if collision(tir[0]-6,tir[1]-3,tir[0]+13,tir[1]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                        v['super']+=40
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    
                if collision(tir[2]-6,tir[3]-3,tir[2]+13,tir[3]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=40
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
            for tir in v['tirs_j_split']:
        
                if collision(tir[0]-13,tir[1]-10,tir[0]+20,tir[1]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5)
                if collision(tir[2]-13,tir[3]-10,tir[2]+20,tir[3]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5)
                if collision(tir[4]-13,tir[5]-10,tir[4]+20,tir[5]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=40
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    
                    
                    pyxel.play(2,5)
                    
                    return True
            for tir in v['tir_super']:
            
                if collision(tir[0]-6,tir[1]-7,tir[0]+13,tir[1]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5)
                if collision(tir[2]-6,tir[3]-7,tir[2]+13,tir[3]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    
                    
                    pyxel.play(2,5)
                    
                    return True
            for tir in v['tirs_j_split']:
                
                if collision(tir[0]-6,tir[1]-3,tir[0]+13,tir[1]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5)
                if collision(tir[2]-6,tir[3]-3,tir[2]+13,tir[3]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                    
                    
                    pyxel.play(2,5)
                    
#ennem2 collision     
        
        for ennemi in v['ennemis_2']:
            for tir in b['tirs_j']:
                if collision(tir[0]-6,tir[1]-3,tir[0]+13,tir[1]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    v['super']+=20
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                    
                if collision(tir[2]-6,tir[3]-3,tir[2]+13,tir[3]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    v['super']+=20
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
            for tir in v['tirs_j_split']:
            
                if collision(tir[0]-13,tir[1]-10,tir[0]+20,tir[1]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5)
                if collision(tir[2]-13,tir[3]-10,tir[2]+20,tir[3]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5) 
                if collision(tir[4]-13,tir[5]-10,tir[4]+20,tir[5]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    v['super']+=40
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                
                    
                    pyxel.play(2,5)
            for tir in v['tirs_j_split']:
                if collision(tir[0]-6,tir[1]-3,tir[0]+13,tir[1]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5)
                if collision(tir[2]-6,tir[3]-3,tir[2]+13,tir[3]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                        b['explosions'].append([ennemi[0],ennemi[1],15])
                        v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                        ennemi[2]-=2
                        v['super']+=10
                        v['tir_touche']+=1
                        v['score']+=v['gain_score']
                        v['endurance']+=0
                    
                    
                        pyxel.play(2,5)
            for tir in v['tir_super']:
            
                if collision(tir[0]-6,tir[1]-7,tir[0]+13,tir[1]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=5
                    pyxel.play(2,5)
                if collision(tir[2]-6,tir[3]-7,tir[2]+13,tir[3]+13,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False :
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    v['super']+=10
                    v['tir_touche']+=1
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    pyxel.play(2,5)                          
                    
                    
                  
    elif v['lasers_foudroie']:
        for tir in b['tirs_j']:
            for ennemi in b['ennemis']:
                if collision(tir[0]-10,tir[1]-5,tir[0]+20,tir[1]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[2]-10,tir[3]-10,tir[2]+20,tir[3]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[4]-10,tir[5]-10,tir[4]+15,tir[5]+15,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[6]-10,tir[7]-10,tir[6]+15,tir[7]+15,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[8]-12,tir[9]-12,tir[8]+10,tir[9]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['tir_touche']+=1
                    v['super']+=15
                    b['ennemis'].remove(ennemi)
                    v['score']+=v['gain_score']
                    v['endurance']+=0
        for tir in v['tirs_j_split']:
            for ennemi in b['ennemis']:
                if collision(tir[0]-10,tir[1]-5,tir[0]+20,tir[1]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[2]-10,tir[3]-10,tir[2]+20,tir[3]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[4]-10,tir[5]-10,tir[4]+15,tir[5]+15,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[6]-10,tir[7]-10,tir[6]+15,tir[7]+15,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[8]-12,tir[9]-12,tir[8]+10,tir[9]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['tir_touche']+=1
                    

                    v['super']+=5
                    b['ennemis'].remove(ennemi)
                    v['score']+=v['gain_score']
                    v['endurance']+=0
        for tir in v['tir_super']:
            for ennemi in b['ennemis']:
                if collision(tir[0]-10,tir[1]-5,tir[0]+20,tir[1]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[2]-10,tir[3]-10,tir[2]+20,tir[3]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[4]-10,tir[5]-10,tir[4]+15,tir[5]+15,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[6]-10,tir[7]-10,tir[6]+15,tir[7]+15,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[8]-12,tir[9]-12,tir[8]+10,tir[9]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['tir_touche']+=1
                    
                   
                    v['super']+=5
                    b['ennemis'].remove(ennemi)
                    v['score']+=v['gain_score']
                    v['endurance']+=0
                    
                    pyxel.play(2,5)
    #collision ennemi 2                
                    return True
        for tir in b['tirs_j']:
            for ennemi in v['ennemis_2']:
                if collision(tir[0]-10,tir[1]-5,tir[0]+10,tir[1]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[2]-10,tir[3]-10,tir[2]+10,tir[3]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[4]-3,tir[5]-3,tir[4]+10,tir[5]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[6]-3,tir[7]-3,tir[6]+10,tir[7]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[8]-4,tir[9]-4,tir[8]+10,tir[9]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    if v['invulnerable_e:']==False:
                        b['explosions'].append([ennemi[0],ennemi[1],15])
                        v['tir_touche']+=1
                        v['super']+=15
                        v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                        ennemi[2]-=2
                        v['score']+=v['gain_score']
                        v['endurance']+=0
        for tir in v['tirs_j_split']:
            for ennemi in v['ennemis_2']:
                if collision(tir[0]-3,tir[1]-3,tir[0]+10,tir[1]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[2]-10,tir[3]-10,tir[2]+20,tir[3]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[4],tir[5],tir[4]+15,tir[5]+15,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[6],tir[7],tir[6]+10,tir[7]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[8],tir[9],tir[8]+10,tir[9]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)  :
                    if v['invulnerable_e:']==False:
                        v['tir_touche']+=1
                        b['explosions'].append([ennemi[0],ennemi[1],15])
                        v['super']+=5
                        v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                        ennemi[2]-=2
                        v['score']+=v['gain_score']
                        v['endurance']+=0
        for tir in v['tir_super']:
            for ennemi in v['ennemis_2']:
                
                if collision(tir[0]-10,tir[1]-5,tir[0]+20,tir[1]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[2]-10,tir[3]-10,tir[2]+20,tir[3]+20,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[4]-10,tir[5]-10,tir[4]+15,tir[5]+15,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)or collision(tir[6]-10,tir[7]-10,tir[6]+15,tir[7]+15,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) or collision(tir[8]-12,tir[9]-12,tir[8]+10,tir[9]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) :
                    if v['invulnerable_e:']==False:
                        b['explosions'].append([ennemi[0],ennemi[1],15])
                        v['tir_touche']+=1
                        v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                        ennemi[2]-=2
                        v['super']+=5
                    
                        v['score']+=v['gain_score']
                        v['endurance']+=0
                    
                        pyxel.play(2,5)
    elif v['laser_solo']:
        for tir in b['tirs_j']:
            for ennemi in b['ennemis']:
                if collision(tir[0],tir[1],tir[0]+5,tir[1]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=20
                    v['endurance']+=0
                    v['tir_touche']+=1
                    if tir in b['tirs_j']:
                        b['tirs_j'].remove(tir)
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
        for tir in v['tirs_j_split']:
            for ennemi in b['ennemis']:
                if collision(tir[0],tir[1],tir[0]+5,tir[1]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    v['tir_touche']+=1
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    pyxel.play(2,5)
        for tir in v['tir_super']:
            for ennemi in b['ennemis']:
                if collision(tir[0],tir[1]-4,tir[0]+10,tir[1]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    v['tir_touche']+=1
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    
                    pyxel.play(2,5)
                if collision(tir[2],tir[3]-4,tir[2]+10,tir[3]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    v['tir_touche']+=1
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                if collision(tir[4],tir[5],tir[4]+5,tir[5]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    v['tir_touche']+=1
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                if collision(tir[6],tir[7],tir[6]+5,tir[7]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    v['tir_touche']+=1
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                if collision(tir[8],tir[9],tir[8]+5,tir[9]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    v['tir_touche']+=1
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    
                    return True
#colision ennemi 2
        for tir in b['tirs_j']:
            for ennemi in v['ennemis_2']:
                if collision(tir[0],tir[1],tir[0]+5,tir[1]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=20
                    v['endurance']+=0
                    v['tir_touche']+=1
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
        for tir in v['tirs_j_split']:
            for ennemi in v['ennemis_2']:
                if collision(tir[0],tir[1],tir[0]+5,tir[1]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    v['tir_touche']+=1
                    
                    
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    pyxel.play(2,5)
        for tir in v['tir_super']:
            for ennemi in v['ennemis_2']:
                if collision(tir[0],tir[1]-4,tir[0]+10,tir[1]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    v['tir_touche']+=1
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    pyxel.play(2,5)
                if collision(tir[2],tir[3]-4,tir[2]+10,tir[3]+10,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False:
                    v['tir_touche']+=1
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                if collision(tir[4],tir[5],tir[4]+5,tir[5]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False:
                    v['tir_touche']+=1
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                if collision(tir[6],tir[7],tir[6]+5,tir[7]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False:
                    v['tir_touche']+=1
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                if collision(tir[8],tir[9],tir[8]+5,tir[9]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False:
                    v['tir_touche']+=1
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    v['score']+=v['gain_score']
                    v['super']+=10
                    v['endurance']+=0
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    ennemi[2]-=2
                    
                    return True
                  
                
                    
    elif v['laser_lock']:
        for tir in b['tirs_j']:
            for ennemi in b['ennemis']:
                if collision(tir[0],tir[1],tir[0]+5,tir[1]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['score']+=v['gain_score']
                    v['super']+=15
                    v['endurance']+=0
                    if tir in b['tirs_j']:
                        b['tirs_j'].remove(tir)
                    v['tir_touche']+=1
                    pyxel.play(2,5)
                    return True
        for ennemi in b['ennemis']:    
            for tir in v['tirs_j_split']:
                if collision(tir[0],tir[1],tir[0]+5,tir[1]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['score']+=v['gain_score']
                    v['super']+=15
                    v['endurance']+=0
                    
                    v['tir_touche']+=1
                    pyxel.play(2,5)
                if collision(tir[2],tir[3],tir[2]+5,tir[3]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['score']+=v['gain_score']
                    v['super']+=15
                    v['endurance']+=0
                    
                    v['tir_touche']+=1
                    pyxel.play(2,5)
                if collision(tir[4],tir[5],tir[4]+5,tir[5]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16):
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    if ennemi in b['ennemis']:
                        b['ennemis'].remove(ennemi)
                    v['score']+=v['gain_score']
                    v['super']+=15
                    v['endurance']+=0
                    
                    v['tir_touche']+=1
                    pyxel.play(2,5)
             #collision ennemi 2      
        for tir in b['tirs_j']:
            for ennemi in v['ennemis_2']:
                if collision(tir[0],tir[1],tir[0]+5,tir[1]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16)and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    ennemi[2]-=2
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])

                    v['score']+=v['gain_score']
                    v['super']+=15
                    v['endurance']+=0
                    if tir in b['tirs_j']:
                        b['tirs_j'].remove(tir)
                    v['tir_touche']+=1
                    pyxel.play(2,5)
                    return True
        for ennemi in v['ennemis_2']:    
            for tir in v['tirs_j_split']:
                if collision(tir[0],tir[1],tir[0]+5,tir[1]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    ennemi[2]-=2
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    v['score']+=v['gain_score']
                    v['super']+=15
                    v['endurance']+=0
                    if tir in v['tirs_j_split']:
                        v['tirs_j_split'].remove(tir)
                    v['tir_touche']+=1
                    pyxel.play(2,5)
                if collision(tir[2],tir[3],tir[2]+5,tir[3]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    ennemi[2]-=2
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    if tir in v['tirs_j_split']:
                        v['tirs_j_split'].remove(tir)
                    v['score']+=v['gain_score']
                    v['super']+=15
                    v['endurance']+=0
                    
                    
                    v['tir_touche']+=1
                    pyxel.play(2,5)
                if collision(tir[4],tir[5],tir[4]+5,tir[5]+5,ennemi[0],ennemi[1],ennemi[0]+16,ennemi[1]+16) and v['invulnerable_e:']==False:
                    b['explosions'].append([ennemi[0],ennemi[1],15])
                    ennemi[2]-=2
                    v['timer_inv_ennemi2'].append([v['frame_invincibilite']])
                    
                    v['score']+=v['gain_score']
                    v['super']+=15
                    v['endurance']+=0
                    if tir in v['tirs_j_split']:
                        v['tirs_j_split'].remove(tir)
                    v['tir_touche']+=1
                    pyxel.play(2,5)        
                
                    
def touche_joueur():
    for ennemi in b['ennemis']:
        if collision(ennemi[0],ennemi[1],ennemi[0]+8,ennemi[1]+10,b['x'],b['y'],b['x']+10,b['y']+12) and v['invulnerable']==False:
            b['ennemis'].remove(ennemi)
            b['explosions'].append([ennemi[0],ennemi[1],15])
            v['vies']-=v['degats_au_joueur']
            
        elif collision(ennemi[0],ennemi[1],ennemi[0]+8,ennemi[1]+10,b['x'],b['y'],b['x']+10,b['y']+12) and v['invulnerable']==True: 
            v['vies']-=0
    for tir in b['tirs_e']:
        if collision(tir[0],tir[1],tir[0]+10,tir[1]+13,b['x'],b['y'],b['x']+10,b['y']+12) and v['invulnerable']==False:
            v['vies']-=v['degats_au_joueur']
            b['tirs_e'].remove(tir)
           

            
def touche_ennemis_bombe():
    for ennemi in b['ennemis']:
        for bombe_explosion in b['explosions_bombes']:
            if collision(ennemi[0],ennemi[1],ennemi[0]+8,ennemi[1]+10,bombe_explosion[0]-100,bombe_explosion[1]-100,bombe_explosion[0]+100,bombe_explosion[1]+100):
                if ennemi in b['ennemis']:
                    b['ennemis'].remove(ennemi)
                    v['score']+=1
            if collision(ennemi[0],ennemi[1],ennemi[0]+8,ennemi[1]+10,bombe_explosion[2]-100,bombe_explosion[3]-100,bombe_explosion[2]+100,bombe_explosion[3]+100):
                if ennemi in b['ennemis']:
                    b['ennemis'].remove(ennemi)
                    v['score']+=1


def touche_tir_e_bombe():
    for tir_e in b['tirs_e']:
        for bombe_explosion in b['explosions_bombes']:
            if collision(tir_e[0],tir_e[1],tir_e[0]+8,tir_e[1]+7,bombe_explosion[0]-70,bombe_explosion[1]-70,bombe_explosion[0]+70,bombe_explosion[1]+70):
                b['tirs_e'].remove(tir_e)
def bouclier_creation():
    if pyxel.btnp(pyxel.KEY_V) and v['endurance']>=30 and b['limite_barricade']>0:
        v['bouclier'].append([b['x']+5,b['y']-3,4])
        v['endurance']-=30
        b['limite_barricade']-=1
def draw_bouclier():
    for bou in v['bouclier']:
        pyxel.blt(bou[0],bou[1],0,154,30,8,4,1)
def bouclier_collision():
    for bou in v['bouclier']:
        for ennemi in b['ennemis']:
            if collision(ennemi[0],ennemi[1],ennemi[0]+8,ennemi[1]+10,bou[0],bou[1],bou[0]+8,bou[1]+4) :
                b['ennemis'].remove(ennemi)
                b['explosions'].append([ennemi[0],ennemi[1],15])
                bou[2]-=1
                pyxel.play(2,5)
                v['score']+=1
                if bou[2]<=0:
                    v['bouclier'].remove(bou)

def mort():
    if v['vies']<=0:
        v['etatJeu']=2

def update_game():
    
    
    animation_joueur()
    invulnerabilite()
    animation_ennemi_tir()
    gestion_liste_explosion()
    gestion_deblocage_armes()
    touche_joueur_explosion()
    gestion_invulnerable_explosion()
    temps_niveau()
    mort()
    
    bouclier_creation()
    bouclier_collision()
    pause_gestion()
        
    #capsules
    
    touche_ennemi_capsule()
    capsule_generate()
    capsule_move()
    touche_joueur_capsule()
    gestion_effet()
    capsule_endurance_creation()
    capsule_move_endurance()
    gestion_effet_endurance()
    touche_joueur_endurance_capsule()
    #endurance
    endurance()
    #ennemi
    ennemis_move()
    ennemis_creation()
    gestion_explosion_ennemis() 
    #personnage
    vaisseau_joueur_move()
    #tir_joueur
    tirs_joueur_creation()
    tir_joueur_deplacement()
    tirs_super()
    tir_super_deplacement()
    tir_ia_deplacement()
    touche_ennemis()
    touche_joueur()
    bombe_creation()
    bombe_deplacement()
    gestion_explosion_bombe()
    touche_ennemis_bombe()
    touche_tir_e_bombe()
    
    
   
def affichage_game()  :
       
    if v['etatJeu']==15:
        pyxel.text(120,20,"vitesse:"+str(v['vitesse']),7)
        pyxel.text(120,10,"score:"+str(v['score']),7)
    else:
        pyxel.text(120,20,"vitesse:"+str(v['vitesse']),7)
        pyxel.text(120,10,"score:"+str(v['score']),7)
        pyxel.text(120,30,"temps:"+str(v['timer']/30),7)
        



def explosion_e_draw():
    for explosion_e in b['explosions_ennemis']:
        if pyxel.frame_count%30>15:
            pyxel.blt(explosion_e[0],explosion_e[1],0,48,80,16,16,1) 
        else:
            pyxel.blt(explosion_e[0],explosion_e[1],0,64,80,16,16,1) 
           

        
    
def draw_game():
    pyxel.cls(1)
    if b['map_colline']:
        pyxel.bltm(0,0,1,0,0,160,160,1)
    else:
        pyxel.bltm(0,0,6,0,0,160,160,1)
    super_draw()
    endurance_draw()


    
    capsule_end_draw()
    draw_bouclier()
    explosion_e_draw()
    tirs_draw()
    vie_draw()
    explosion_et_tir_e_draw() 
    bombe_et_bombe_explosion_draw()
    pyxel_endurance_capsule_et_ennemi_draw()

        
        
    affichage_game()
    

           
def gestion_deblocage_armes():
    if v['score']>=20 :
        b['unlock_double']+=1
    elif v['score']<20 :
        b['unlock_double']+=0
    if v['score']>=25 :
       b['unlock_lock']+=1
    elif v['score']<25 :
        b['unlock_lock']+=0

    if v['score']>=27:
        b['unlock_destroy']+=1
    elif v['score']<27 :
        b['unlock_destroy']+=0
    



               




def endurance_draw():
    if v['endurance']<=0:
        pyxel.blt(0,30,0,64,229,24,5,1)
    if v['endurance']>0 and v['endurance']<=5:
        pyxel.blt(0,30,0,112,213,24,5,1)
    if v['endurance']>5 and v['endurance']<=10:
        pyxel.blt(0,30,0,64,205,24,5,1)
    if v['endurance']>10 and v['endurance']<=20:
        pyxel.blt(0,30,0,64,221,24,5,1)
    if v['endurance']>20 and v['endurance']<=30:
        pyxel.blt(0,30,0,64,237,24,5,1)
    if v['endurance']>30 and v['endurance']<=40:
        pyxel.blt(0,30,0,64,213,24,5,1)
    if v['endurance']>40 and v['endurance']<=50:
        pyxel.blt(0,30,0,64,245,24,5,1)
    if v['endurance']>50 and v['endurance']<=60:
        pyxel.blt(0,30,0,88,205,24,5,1)
    if v['endurance']>60 and v['endurance']<=70:
        pyxel.blt(0,30,0,88,213,24,5,1)
    if v['endurance']>70 and v['endurance']<=80:
        pyxel.blt(0,30,0,88,221,24,5,1)
    if v['endurance']>80 and v['endurance']<=90:
        pyxel.blt(0,30,0,88,229,24,5,1)
    if v['endurance']>90 and v['endurance']<=100:
        pyxel.blt(0,30,0,88,245,24,5,1)

def vie_draw():
    if v['vies']==4:
        pyxel.blt(0,0,0,0,168,64,16,1)

    if v['vies']==3:
        pyxel.blt(0,0,0,128,80,48,16,1)
    elif v['vies']==2:
        pyxel.blt(0,0,0,112,112,32,16,1)
    elif v['vies']==1:
        if pyxel.frame_count%30<15:
            pyxel.blt(0,0,0,0,112,16,16,1) 
def explosion_et_tir_e_draw():
    for explosion in b['explosions']:
        if v['laser_verts']:
            if pyxel.frame_count%2==0:
                pyxel.blt(explosion[0],explosion[1],0,232,80,8,8,1)
            else:
                pyxel.blt(explosion[0],explosion[1],0,240,80,8,8,1)
        if v['laser_rouge']:
            if pyxel.frame_count%2==0:
                pyxel.blt(explosion[0],explosion[1],0,16,64,8,8,1)
            else:
                pyxel.blt(explosion[0],explosion[1],0,24,64,8,8,1)
        if v['laser_multicolore']:
            if pyxel.frame_count%2==0:
                pyxel.blt(explosion[0],explosion[1],0,152,64,8,8,1)
            else:
                pyxel.blt(explosion[0],explosion[1],0,160,64,8,8,1)
        if v['laser_sapin']:
            if pyxel.frame_count%2==0:
                pyxel.blt(explosion[0],explosion[1],0,152,56,8,8,1)
            else:
                pyxel.blt(explosion[0],explosion[1],0,160,56,8,8,1)

    
def bombe_et_bombe_explosion_draw():
    for bombe in b['bombes']:
        pyxel.blt(bombe[0],bombe[1],0,24,112,16,16,1)
        pyxel.blt(bombe[2],bombe[3],0,24,112,16,16,1)
    for bombe_explosion in b['explosions_bombes']:
        if pyxel.frame_count%30<15:
            pyxel.circ(bombe_explosion[0],bombe_explosion[1],140,10)
        else:    
            pyxel.circ(bombe_explosion[0],bombe_explosion[1],50,8)
        if pyxel.frame_count%30<15:
            pyxel.circ(bombe_explosion[2],bombe_explosion[3],140,10)
        else:    
            pyxel.circ(bombe_explosion[2],bombe_explosion[3],50,8)
def pyxel_endurance_capsule_et_ennemi_draw():
    if v['etatJeu']==5:
        pyxel.text(60,120,"pas restant(s):"+str(round(v['pas_restant'])),7)
    
        

    for capsule in v['capsule_soin']:
        if pyxel.frame_count%60>20:
            pyxel.blt(capsule[0],capsule[1],0,120,56,16,16,1)
        elif pyxel.frame_count%60<20<40:
            pyxel.blt(capsule[0],capsule[1],0,136,96,16,16,1)
        else:
            pyxel.blt(capsule[0],capsule[1],0,144,8,16,16,1)


    
    if v['vaisseau_noel'] and v['touchable']:
        if v['mouvement']==True:
            
            pyxel.blt(b['x'],b['y'],0,v['x'],v['y'],16,20,1)
            

        else:
            pyxel.blt(b['x'],b['y'],0,v['x'],v['y'],16,18,1)
        
    
    elif v['vaisseau_noel'] and v['touchable']==False:
        
        pyxel.blt(b['x'],b['y'],0,v['x'],v['y'],16,16,1)
    else:
        pyxel.blt(b['x'],b['y'],0,v['x'],v['y'],16,16,1)

    
    



    for ennemi in b['ennemis']:
        pyxel.blt(ennemi[0],ennemi[1],0,v['u'],v['v'],16,16,1)
def tirs_draw() :
    if v['laser_rouge']:
        if v['laser_split']:
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
            for tir_j in b['tirs_j']:
                pyxel.blt(tir_j[0],tir_j[1],0,64,64,8,16,1)
                pyxel.blt(tir_j[2],tir_j[3],0,64,64,8,16,1)
                pyxel.blt(tir_j[4],tir_j[5],0,64,64,8,16,1)
                pyxel.blt(tir_j[6],tir_j[7],0,64,64,8,16,1)
            for tir_j in v['tir_super']:
                pyxel.blt(tir_j[0],tir_j[1],0,64,64,8,16,1)
                pyxel.blt(tir_j[2],tir_j[3],0,64,64,8,16,1)
                pyxel.blt(tir_j[4],tir_j[5],0,64,64,8,16,1)
                pyxel.blt(tir_j[6],tir_j[7],0,64,64,8,16,1)
                pyxel.blt(tir_j[8],tir_j[9],0,64,64,8,16,1)
                pyxel.blt(tir_j[10],tir_j[11],0,64,64,8,16,1)
                pyxel.blt(tir_j[12],tir_j[13],0,64,64,8,16,1)
                pyxel.blt(tir_j[14],tir_j[15],0,64,64,8,16,1)
            for tir in v['tir_super2']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)



        if v['laser_double']:
        

            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,64,64,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,64,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,64,64,8,16,1)
            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,64,64,8,16,1)
            
        elif v['laser_solo']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
                


            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,64,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,64,64,8,16,1)
                pyxel.blt(tir[6],tir[7],0,64,64,8,16,1)
                pyxel.blt(tir[8],tir[9],0,64,64,8,16,1)
                
                
           

            
        
        elif v['laser_lock']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,64,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,64,64,8,16,1)

        elif v['lasers_foudroie']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,64,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,64,64,8,16,1)
                pyxel.blt(tir[6],tir[7],0,64,64,8,16,1)
                pyxel.blt(tir[8],tir[9],0,64,64,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,64,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,64,64,8,16,1)
                pyxel.blt(tir[6],tir[7],0,64,64,8,16,1)
                pyxel.blt(tir[8],tir[9],0,64,64,8,16,1)
            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,64,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,64,64,8,16,1)
                pyxel.blt(tir[6],tir[7],0,64,64,8,16,1)
                pyxel.blt(tir[8],tir[9],0,64,64,8,16,1)
    elif v['laser_verts']:
        if v['laser_split']:
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
            for tir_j in b['tirs_j']:
                pyxel.blt(tir_j[0],tir_j[1],0,72,64,8,16,1)
                pyxel.blt(tir_j[2],tir_j[3],0,72,64,8,16,1)
                pyxel.blt(tir_j[4],tir_j[5],0,72,64,8,16,1)
                pyxel.blt(tir_j[6],tir_j[7],0,72,64,8,16,1)
            for tir_j in v['tir_super']:
                pyxel.blt(tir_j[0],tir_j[1],0,72,64,8,16,1)
                pyxel.blt(tir_j[2],tir_j[3],0,72,64,8,16,1)
                pyxel.blt(tir_j[4],tir_j[5],0,72,64,8,16,1)
                pyxel.blt(tir_j[6],tir_j[7],0,72,64,8,16,1)
                pyxel.blt(tir_j[8],tir_j[9],0,72,64,8,16,1)
                pyxel.blt(tir_j[10],tir_j[11],0,72,64,8,16,1)
                pyxel.blt(tir_j[12],tir_j[13],0,72,64,8,16,1)
                pyxel.blt(tir_j[14],tir_j[15],0,72,64,8,16,1)
            for tir in v['tir_super2']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)



        if v['laser_double']:
        

            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,72,64,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,72,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,72,64,8,16,1)
            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,72,64,8,16,1)
            
            
        elif v['laser_solo']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
                


            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,72,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,72,64,8,16,1)
                pyxel.blt(tir[6],tir[7],0,72,64,8,16,1)
                pyxel.blt(tir[8],tir[9],0,72,64,8,16,1)
        
        elif v['laser_lock']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,72,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,72,64,8,16,1)
        elif v['lasers_foudroie']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,72,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,72,64,8,16,1)
                pyxel.blt(tir[6],tir[7],0,72,64,8,16,1)
                pyxel.blt(tir[8],tir[9],0,72,64,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,72,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,72,64,8,16,1)
                pyxel.blt(tir[6],tir[7],0,72,64,8,16,1)
                pyxel.blt(tir[8],tir[9],0,72,64,8,16,1)
            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,72,64,8,16,1)
                pyxel.blt(tir[2],tir[3],0,72,64,8,16,1)
                pyxel.blt(tir[4],tir[5],0,72,64,8,16,1)
                pyxel.blt(tir[6],tir[7],0,72,64,8,16,1)
                pyxel.blt(tir[8],tir[9],0,72,64,8,16,1)
    elif v['laser_multicolore']:
        if v['laser_split']:
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
            for tir_j in b['tirs_j']:
                pyxel.blt(tir_j[0],tir_j[1],0,160,0,8,16,1)
                pyxel.blt(tir_j[2],tir_j[3],0,160,0,8,16,1)
                pyxel.blt(tir_j[4],tir_j[5],0,160,0,8,16,1)
                pyxel.blt(tir_j[6],tir_j[7],0,160,0,8,16,1)
            for tir_j in v['tir_super']:
                pyxel.blt(tir_j[0],tir_j[1],0,160,0,8,16,1)
                pyxel.blt(tir_j[2],tir_j[3],0,160,0,8,16,1)
                pyxel.blt(tir_j[4],tir_j[5],0,160,0,8,16,1)
                pyxel.blt(tir_j[6],tir_j[7],0,160,0,8,16,1)
                pyxel.blt(tir_j[8],tir_j[9],0,160,0,8,16,1)
                pyxel.blt(tir_j[10],tir_j[11],0,160,0,8,16,1)
                pyxel.blt(tir_j[12],tir_j[13],0,160,0,8,16,1)
                pyxel.blt(tir_j[14],tir_j[15],0,160,0,8,16,1)
            for tir in v['tir_super2']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
        if v['laser_double']:
        

            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
                pyxel.blt(tir[2],tir[3],0,160,0,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
                pyxel.blt(tir[2],tir[3],0,160,0,8,16,1)
                pyxel.blt(tir[4],tir[5],0,160,0,8,16,1)
            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
                pyxel.blt(tir[2],tir[3],0,160,0,8,16,1)
        elif v['laser_solo']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
                


            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
                pyxel.blt(tir[2],tir[3],0,160,0,8,16,1)
                pyxel.blt(tir[4],tir[5],0,160,0,8,16,1)
                pyxel.blt(tir[6],tir[7],0,160,0,8,16,1)
                pyxel.blt(tir[8],tir[9],0,160,0,8,16,1)
        
        elif v['laser_lock']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
                pyxel.blt(tir[2],tir[3],0,160,0,8,16,1)
                pyxel.blt(tir[4],tir[5],0,160,0,8,16,1)
        elif v['lasers_foudroie']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
                pyxel.blt(tir[2],tir[3],0,160,0,8,16,1)
                pyxel.blt(tir[4],tir[5],0,160,0,8,16,1)
                pyxel.blt(tir[6],tir[7],0,160,0,8,16,1)
                pyxel.blt(tir[8],tir[9],0,160,0,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
                pyxel.blt(tir[2],tir[3],0,160,0,8,16,1)
                pyxel.blt(tir[4],tir[5],0,160,0,8,16,1)
                pyxel.blt(tir[6],tir[7],0,160,0,8,16,1)
                pyxel.blt(tir[8],tir[9],0,160,0,8,16,1)
            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,160,0,8,16,1)
                pyxel.blt(tir[2],tir[3],0,160,0,8,16,1)
                pyxel.blt(tir[4],tir[5],0,160,0,8,16,1)
                pyxel.blt(tir[6],tir[7],0,160,0,8,16,1)
                pyxel.blt(tir[8],tir[9],0,160,0,8,16,1)
    elif v['laser_sapin']:
        if v['laser_split']:
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
            for tir_j in b['tirs_j']:
                pyxel.blt(tir_j[0],tir_j[1],0,152,40,8,16,1)
                pyxel.blt(tir_j[2],tir_j[3],0,152,40,8,16,1)
                pyxel.blt(tir_j[4],tir_j[5],0,152,40,8,16,1)
                pyxel.blt(tir_j[6],tir_j[7],0,152,40,8,16,1)
            for tir_j in v['tir_super']:
                pyxel.blt(tir_j[0],tir_j[1],0,152,40,8,16,1)
                pyxel.blt(tir_j[2],tir_j[3],0,152,40,8,16,1)
                pyxel.blt(tir_j[4],tir_j[5],0,152,40,8,16,1)
                pyxel.blt(tir_j[6],tir_j[7],0,152,40,8,16,1)
                pyxel.blt(tir_j[8],tir_j[9],0,152,40,8,16,1)
                pyxel.blt(tir_j[10],tir_j[11],0,152,40,8,16,1)
                pyxel.blt(tir_j[12],tir_j[13],0,152,40,8,16,1)
                pyxel.blt(tir_j[14],tir_j[15],0,152,40,8,16,1)
            for tir in v['tir_super2']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
        
        if v['laser_double']:
        

            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
                pyxel.blt(tir[2],tir[3],0,152,40,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
                pyxel.blt(tir[2],tir[3],0,152,40,8,16,1)
                pyxel.blt(tir[4],tir[5],0,152,40,8,16,1)
            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
                pyxel.blt(tir[2],tir[3],0,152,40,8,16,1)
        elif v['laser_solo']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
                


            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
                pyxel.blt(tir[2],tir[3],0,152,40,8,16,1)
                pyxel.blt(tir[4],tir[5],0,152,40,8,16,1)
                pyxel.blt(tir[6],tir[7],0,152,40,8,16,1)
                pyxel.blt(tir[8],tir[9],0,152,40,8,16,1)
        
        elif v['laser_lock']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
           
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],152,40,0,8,16,1)
                pyxel.blt(tir[2],tir[3],0,152,40,8,16,1)
                pyxel.blt(tir[4],tir[5],0,152,40,8,16,1)
        elif v['lasers_foudroie']:
            for tir in b['tirs_j']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
                pyxel.blt(tir[2],tir[3],0,152,40,8,16,1)
                pyxel.blt(tir[4],tir[5],0,152,40,8,16,1)
                pyxel.blt(tir[6],tir[7],0,152,40,8,16,1)
                pyxel.blt(tir[8],tir[9],0,152,40,8,16,1)
            for tir in v['tirs_j_split']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
                pyxel.blt(tir[2],tir[3],0,152,40,8,16,1)
                pyxel.blt(tir[4],tir[5],0,152,40,8,16,1)
                pyxel.blt(tir[6],tir[7],0,152,40,8,16,1)
                pyxel.blt(tir[8],tir[9],0,152,40,8,16,1)
            for tir in v['tir_super']:
                pyxel.blt(tir[0],tir[1],0,152,40,8,16,1)
                pyxel.blt(tir[2],tir[3],0,152,40,8,16,1)
                pyxel.blt(tir[4],tir[5],0,152,40,8,16,1)
                pyxel.blt(tir[6],tir[7],0,152,40,8,16,1)
                pyxel.blt(tir[8],tir[9],0,152,40,8,16,1)




###############################################################################################################""
def update_score():
    if pyxel.btn(pyxel.KEY_M):
        v['etatJeu']=0
        pyxel.play(0,11)
    

def draw_score():
    pyxel.cls(v['couleur_arriereplan'])
    pyxel.bltm(0,0,2,0,0,150,40,1)
    if pyxel.frame_count%30<15:
        pyxel.text(40,33,"Modes ennemis/super",10)
    else:
        pyxel.text(40,33,"Modes ennemis/super",13)

    if len(v['score_liste'])>0:
        if v['couleur_arriereplan']!=12:
            pyxel.text(40,47,"meilleur score:"+str(max(v['score_liste'])),12)
        else:
            pyxel.text(40,47,"meilleur score:"+str(max(v['score_liste'])),0)

    if v['nb_score']>0:
        if v['couleur_arriereplan']!=7:
            pyxel.text(40,60,"moyenne scores:"+str(round((v['total_score']/v['nb_score']))),7)
        else:
            pyxel.text(40,60,"moyenne scores:"+str(round((v['total_score']/v['nb_score']))),0)

    if len(v['score_liste'])==0:
        pyxel.text(40,73,"pas de palmares!",v['couleur_noir_casier'])
    if len(v['score_liste'])>0:
        if v['couleur_arriereplan']!=8:
            pyxel.text(40,73,"pire score:"+str(min(v['score_liste'])),8)
        else:
            pyxel.text(40,73,"pire score:"+str(min(v['score_liste'])),0)

    if len(v['score_liste'])>0:
        pyxel.text(40,83,"scores:"+str(v['score_liste']),v['couleur_noir_casier'])



    
                    


    if v['tir_totaux']>0:
        pyxel.text(40,93,"taux tirs reussis:"+str(round((v['tir_touche']/v['tir_totaux'])*100)),v['couleur_noir_casier'])
        pyxel.text(130,93,"%",v['couleur_noir_casier'])
    if pyxel.frame_count%30<15:
        pyxel.text(10,122,"Mode Cache-cache ",3)
    else:
        pyxel.text(10,122,"Mode Cache-cache ",8)

    
    pyxel.text(10,130,"Nombre de victoire:"+str(v['victoire']),v['couleur_noir_casier'])
    
    

    if pyxel.frame_count%30<15:
        pyxel.text(10,100,"Mode piece",10)
    else:
        pyxel.text(10,100,"Mode piece",13)
    if v['nb_partie_joué']>0:
        if v['couleur_arriereplan']!= 7:
            pyxel.text(10,110,"taux de victoires:"+str(round((v['nb_gagné']/v['nb_partie_joué'])*100)),7)
            pyxel.text(100,110,"%",7)
        else:
            
            pyxel.text(10,110,"taux de victoires:"+str(round((v['nb_gagné']/v['nb_partie_joué'])*100)),0)
            pyxel.text(100,110,"%",0)
    else:
        pyxel.text(10,110,"pas de combat a votre actif!",v['couleur_noir_casier'])

    
    #################################################################################################################objectif
    
def update_objectif():
    if v['timer_fin_cache']>0:
        v['timer_fin_cache']-=1
    else:
        v['etatJeu']=0
    if v['vies']==4:
        if v['collision']:
            if v['l_monnaie']>0:
                v['monnaie']+=10
                v['l_monnaie']-=1
        else:
            v['monnaie']+=0







    
    
def draw_objectif(): 
   
    if v['vies']==v['vie_option'] and v['collision']:
        pyxel.cls(1)
        pyxel.text(50,60,"objectif Atteint!",10)
        v['unlock_split']+=1
        
    elif v['vies']<=0:
        if v['collision']==False:
            pyxel.cls(0)
            if pyxel.frame_count%20>10:
                pyxel.text(40,60,"Vous Avez echoue!!",8)
        else:
            pyxel.cls(1)
            pyxel.text(50,60,"objectif Atteint!",10)
            v['unlock_split']+=1
    if v['timer_cache_cache']<=0:
        pyxel.cls(1)
        if pyxel.frame_count%20>10:
            pyxel.text(40,60,"Vous Avez echoue!!",8)
            pyxel.text(40,70,"Temps ecoule!",8)  





                 
                

    
    
    
    
    
            
            
            
            
    
    
    
    
  
    
    
    
    
#
#====================================================================================  GAME OVER ============================================================================



def update_gameover():
    if pyxel.btnp(pyxel.KEY_M):
        v['etatJeu']=0
        
    
    
    
def draw_gameover():
    pyxel.cls(0)
    if pyxel.frame_count%10>5:
        if v['phrase de mort']==0:
            pyxel.text(48,70, "Vous avez peri!", 8)
        if v['phrase de mort']==1:
            pyxel.text(65,70, "GAME OVER", 8)
    pyxel.text(10,120, "Menu:m", 12)
    
    
    
    
    
    
    
    
    
#
#=====================================================================================  niveau2 =============================================================================================
def update_game5():
    temps_niveau_pièce()
    vaisseau_joueur_move()
    animation_joueur()
    invulnerabilite()
    animation_ennemi_tir()
    gestion_liste_explosion()
    gestion_deblocage_armes()
    touche_joueur_explosion()
    gestion_invulnerable_explosion()
    creation_pièce()
    gestion_collision_pièce()
    règles_pièces()
    tirs_joueur_creation()
    tir_joueur_deplacement()
    endurance()
    ia_gestion()
    ia_collision()
    tir_ia()
    tir_ia_deplacement()
    pause_gestion()
   

def draw_game5():
    pyxel.cls(1)
    explosion_e_draw()
    tirs_draw()
    vie_draw()
    explosion_et_tir_e_draw() 
    bombe_et_bombe_explosion_draw()
    pyxel_endurance_capsule_et_ennemi_draw()
    pièce_draw()
    endurance_draw()

    for tir_ia in v['tir_ia']:
        pyxel.rect(tir_ia[0],tir_ia[1],4,2,8)
    
    pyxel.text(100,20,"vitesse:"+str(v['vitesse']),7)
    pyxel.text(100,10,"score:"+str(v['score']),7)
    pyxel.text(100,30,"temps:"+str(v['timer_p']/30),7)
    pyxel.text(0,30,"score ennemi:"+str(v['score_ia']),7)
    pyxel.blt(v['x_ia'],v['y_ia'],0,v['u'],v['v'],16,16,1)


def creation_pièce():
    if pyxel.frame_count%60==0:
        v['pièces'].append([random.randint(20,110),random.randint(0,132),60])
def pièce_draw():
    for pièce in v['pièces']:
        if pyxel.frame_count%30<15:
            pyxel.blt(pièce[0],pièce[1],0,40,104,16,16,1)
        else:
            pyxel.blt(pièce[0],pièce[1],0,216,240,16,16,1)

def gestion_collision_pièce():
    for pièce in v['pièces']:
        if collision(pièce[0],pièce[1],pièce[0]+8,pièce[1]+10,b['x'],b['y'],b['x']+10,b['y']+12) :
            v['pièces'].remove(pièce)
            v['score']+=3
    if v['laser_double']:
        for tir in b['tirs_j']:
            for pièce in v['pièces']:
                if collision(tir[0]-6,tir[1]-3,tir[0]+13,tir[1]+13,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16) or collision(tir[2]-6,tir[3]-3,tir[2]+13,tir[3]+13,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16):
                    v['tir_touche']+=1
                    v['pièces'].remove(pièce)
                    v['score']+=1
                    v['endurance']+=5
                    return True
                    
                  
    elif v['lasers_foudroie']:
        for tir in b['tirs_j']:
            for pièce in v['pièces']:
                if collision(tir[0]-5,tir[1],tir[0]+20,tir[1]+20,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16) or collision(tir[2],tir[3],tir[2]+20,tir[3]+20,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16)or collision(tir[4]-10,tir[5]-10,tir[4]+15,tir[5]+15,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16)or collision(tir[6]-10,tir[7]-10,tir[6]+15,tir[7]+15,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16) or collision(tir[8]-8,tir[9]-8,tir[8]+10,tir[9]+10,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16):
                    v['pièces'].remove(pièce)
                    v['score']+=1
                    v['endurance']+=5
                    v['tir_touche']+=1
                    return True
    elif v['laser_solo']:
       for tir in b['tirs_j']:
            for pièce in v['pièces']:
                if collision(tir[0]-6,tir[1]-3,tir[0]+13,tir[1]+13,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16):
                    
                    v['pièces'].remove(pièce)
                    v['score']+=1
                    v['endurance']+=5
                    v['tir_touche']+=1
                    return True
    elif v['laser_lock']:
       for tir in b['tirs_j']:
            for pièce in v['pièces']:
                if collision(tir[0]-6,tir[1]-3,tir[0]+13,tir[1]+13,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16):
                    
                    v['pièces'].remove(pièce)
                    v['score']+=1
                    v['endurance']+=5
                    v['tir_touche']+=1
                    return True
    elif v['laser_split']:
        for tir in b['tirs_j']:
            for pièce in v['pièces']:
                if collision(tir[0]-6,tir[1]-3,tir[0]+13,tir[1]+13,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16):
                    
                    v['pièces'].remove(pièce)
                    v['score']+=1
                    v['endurance']+=5
                    v['tir_touche']+=1
                if collision(tir[2]-6,tir[3]-3,tir[2]+13,tir[3]+13,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16):
                    
                    v['pièces'].remove(pièce)
                    v['score']+=1
                    v['endurance']+=5
                    v['tir_touche']+=1
                if collision(tir[4]-6,tir[5]-3,tir[4]+13,tir[5]+13,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16):
                    
                    v['pièces'].remove(pièce)
                    v['score']+=1
                    v['endurance']+=5
                    v['tir_touche']+=1
                if collision(tir[6]-6,tir[7]-3,tir[6]+13,tir[7]+13,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16):
                    
                    v['pièces'].remove(pièce)
                    v['score']+=1
                    v['endurance']+=5
                    v['tir_touche']+=1
        for tir_j in v['tirs_j_split']:
            for pièce in v['pièces']:
                if collision(tir_j[0]-6,tir_j[1]-3,tir_j[0]+13,tir_j[1]+13,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16):
                    
                    v['pièces'].remove(pièce)
                    v['score']+=1
                    v['endurance']+=5
                    v['tir_touche']+=1
                  
                  
                  
    
def règles_pièces():
    for pièce in v['pièces']:
        if pièce[2]>0:
            pièce[2]-=1
        else:
            v['pièces'].remove(pièce)
def ia_gestion():
    for pièce in v['pièces']:
        if v['x_ia'] >= pièce[0] :
            v['x_ia']-=1.5
        elif v['x_ia'] < pièce[0]:
            v['x_ia']+=1.5
        if v['y_ia'] >= pièce[1]:
            v['y_ia']-=1.5
        elif v['y_ia']<=pièce[1]:
            v['y_ia']+=1.5
def ia_collision():
    
        for pièce in v['pièces']:
            if collision(v['x_ia']-3,v['y_ia']-3,v['x_ia']+15,v['y_ia']+15,pièce[0]+12,pièce[1]+12,pièce[0]+12,pièce[1]+12):
                if pièce in v['pièces']: 
                    v['pièces'].remove(pièce)
                v['score_ia']+=2
        for tir_ia in v['tir_ia']:
            for pièce in v['pièces']:
                if collision(tir_ia[0],tir_ia[1],tir_ia[0]+6,tir_ia[1]+4,pièce[0],pièce[1],pièce[0]+16,pièce[1]+16):
                    if tir_ia in v['tir_ia']:
                        v['tir_ia'].remove(tir_ia)
                    if pièce in v['pièces']:
                        v['pièces'].remove(pièce)
                    v['score_ia']+=1
    

    

def tir_ia():
    if pyxel.frame_count%1000==0:
        v['tir_ia'].append([v['x_ia'],v['y_ia']])
        pyxel.play(2,7)
def tir_ia_deplacement():
    
    for tir_ia in v['tir_ia']:
        tir_ia[1]-=5
        for pièce in v['pièces']:
            
            if tir_ia[0]> pièce[0] :
                tir_ia[0]-=1
            
            else:
                tir_ia[0]+=1
            if tir_ia[1]> pièce[1]  :
                tir_ia[1]-=5
            
            else:
                tir_ia[1]+=1
            if tir_ia[1]>140 or tir_ia[1]<0:
                v['tir_ia'].remove(tir_ia)

            

   
   

#====================================================================================  SETTINGS ================================================================================
def update_settings():
    if pyxel.btn(pyxel.KEY_M):
        v['etatJeu']=0
        pyxel.play(0,11)
    if pyxel.btn(pyxel.KEY_C):
        b['map_colline']=True
        b['map_desert']=False
        pyxel.play(0,11)
    if pyxel.btn(pyxel.KEY_D):
        b['map_colline']=False
        b['map_desert']=True
        pyxel.play(0,11)
    if pyxel.btn(pyxel.KEY_O):
        v['etatJeu']=13
        pyxel.play(0,11)
    

def draw_settings():
    pyxel.cls(v['couleur_arriereplan'])
    pyxel.bltm(0,0,5,0,0,160,47,1)
    if pyxel.frame_count%20>10:
        pyxel.text(65,15, "Parametres", 8)
    else:
        pyxel.text(65,15, "Parametres", 9)
    
    
    pyxel.text(15,40 , "-Fleches directionnelles:avancer ", v['couleur_noir_casier'])
    pyxel.text(15, 50, "-ESPACE : tirer vers le haut",v['couleur_noir_casier'])
    pyxel.text(15, 60, "-P: mettre en pause",v['couleur_noir_casier'])
    pyxel.text(15, 70, "-n'oubliez pas de suivre les astuces!",v['couleur_noir_casier'])
    pyxel.text(15, 80, "-entrer en collision avec une potion",v['couleur_noir_casier'])
    pyxel.text(15,90, "-potion verte:munitions infinies",v['couleur_noir_casier'])
    pyxel.text(15,100, "-potion Rouge:1 coeur,+ de vitesse",v['couleur_noir_casier'])

    pyxel.text(125,155, "option:O",v['couleur_noir_casier'])

    if pyxel.frame_count%30>15:
        pyxel.text(0, 155, "M: Revenir au menu", 10)
    else:
        pyxel.text(0, 155, "M: Revenir au menu",7)
    

    
    pyxel.text(15,115,"temps de jeu:"+str(math.floor(v['timer_temps_jeu']/1800)),v['couleur_noir_casier'])
    pyxel.text(15,125,"en secondes:"+str(round(v['timer_temps_jeu']/30)),v['couleur_noir_casier'])
    pyxel.text(15,135,"en heures:"+str(round(v['timer_temps_jeu']/30/3600)),v['couleur_noir_casier'])
    pyxel.text(80,115,"min",v['couleur_noir_casier'])

def update_option():
    if pyxel.btn(pyxel.KEY_P):
        v['etatJeu']=4
        pyxel.play(0,11)
    if pyxel.btn(pyxel.KEY_C):
        b['map_colline']=True
        b['map_desert']=False
        pyxel.play(0,11)
        
    if pyxel.btn(pyxel.KEY_D):
        b['map_colline']=False
        b['map_desert']=True
        pyxel.play(0,11)
    if pyxel.btn(pyxel.KEY_J):
        v['fréquence_apparition_ennemis']+=1
        pyxel.play(0,11)
    if pyxel.btn(pyxel.KEY_A):
        v['fréquence_apparition_ennemis']-=1
        pyxel.play(0,11)
    if v['fréquence_apparition_ennemis']<=0:
        v['fréquence_apparition_ennemis']=1
    if pyxel.btnp(pyxel.KEY_Z):
        v['gain_score']+=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_E):
        v['gain_score']-=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_R):
        v['duree_effets']+=30
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_T):
        v['duree_effets']-=30
        pyxel.play(0,11)

        
    if pyxel.btnp(pyxel.KEY_Y):
        v['limite_endurance']+=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_U):
        v['limite_endurance']-=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_I):
        v['vitesse_option']+=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_L):
        v['vitesse_option']-=1
        pyxel.play(0,11)
        
    if pyxel.btnp(pyxel.KEY_Q):
        v['visibilite_boss']+=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_S):
        v['visibilite_boss']-=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_G):
        v['vie_option']+=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_F):
        v['vie_option']-=1
        pyxel.play(0,11)
    if v['vie_option']>4:
        v['vie_option']=4
    
    if pyxel.btnp(pyxel.KEY_N):
        v['etatJeu']=14
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_V):
        v['vitesse_tir_solo']+=10
        v['gain_score']+=10
        v['limite_endurance']+=100
        v['duree_effets']+=10
        v['fréquence_apparition_ennemis']+=10
        v['degats_au_joueur']+=10
        v['vie_ennemis']+=10
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_SPACE):
        v['vitesse_tir_solo']=13
        v['gain_score']=1
        v['limite_endurance']=100
        v['duree_effets']=600
        v['fréquence_apparition_ennemis']=30
        v['degats_au_joueur']=1
        v['vie_ennemis']=10
        v['visibilite_boss']=70
        v['vitesse_option']=3
        v['vie_option']=4
        v['capsule_soin_option']=True
        v['timer_option']=900
        pyxel.play(0,11)
       
    
    
    
    
                   






def draw_option():
    pyxel.cls(v['couleur_arriereplan'])
    pyxel.text(0,0, "Espace:reset", 8)
    if pyxel.frame_count%20>10:
        pyxel.text(45,15, "Option", 8)
    else:
        pyxel.text(45,15, "Option", 9)
    if v['couleur_noir']==False:
        pyxel.text(45,25, "Frequence", 10)
    
        pyxel.text(0,35, "apparitions des ennemis:"+str(v['fréquence_apparition_ennemis']), 10)
        pyxel.text(115,35, "j", 10)
        pyxel.text(125,35, "A", 10)
        pyxel.blt(110,35,0,97,140,5,5,1)
        pyxel.blt(120,35,0,105,140,5,5,1)
   

        pyxel.text(0,45, "gain du score:"+str(v['gain_score']), 10)
        pyxel.blt(110,45,0,97,140,5,5,1)
        pyxel.blt(120,45,0,105,140,5,5,1)
        pyxel.text(115,45, "Z", 10)
        pyxel.text(125,45, "E", 10)
        pyxel.text(0,55, "duree des potions:"+str(round(v['duree_effets']/30)), 10)
        pyxel.text(85,55, "S", 10)
        pyxel.blt(110,55,0,97,140,5,5,1)
        pyxel.blt(120,55,0,105,140,5,5,1)
        pyxel.text(115,55, "R", 10)
        pyxel.text(125,55, "T", 10)
        pyxel.text(0,65, "barre d'endurance:"+str(round(v['limite_endurance'])), 10)
        pyxel.blt(110,65,0,97,140,5,5,1)
        pyxel.blt(120,65,0,105,140,5,5,1)
        pyxel.text(115,65, "Y", 10)
        pyxel.text(125,65, "U", 10)
        pyxel.text(0,75, "vitesse du joueur:"+str(round(v['vitesse_option'])), 10)
        pyxel.blt(110,75,0,97,140,5,5,1)
        pyxel.blt(120,75,0,105,140,5,5,1)
        pyxel.text(115,75, "I", 10)
        pyxel.text(125,75, "L", 10)
        pyxel.text(0,85, "portee boss cache-cache:"+str(round(v['visibilite_boss'])), 10)
        pyxel.blt(115,85,0,97,140,5,5,1)
        pyxel.blt(125,85,0,105,140,5,5,1)
        pyxel.text(120,85, "q", 10)
        pyxel.text(130,85, "S", 10)
        pyxel.text(0,95, "vie du joueur:"+str(round(v['vie_option'])), 10)
        pyxel.blt(115,95,0,97,140,5,5,1)
        pyxel.blt(125,95,0,105,140,5,5,1)
        pyxel.text(120,95, "G", 10)
        pyxel.text(130,95, "F", 10)
        pyxel.text(100, 130, "N:suite", 10)
        pyxel.text(0, 130, "P: Revenir aux parametre", 10)
    else:
        pyxel.text(45,25, "Frequence", 0)
    
        pyxel.text(0,35, "apparitions des ennemis:"+str(v['fréquence_apparition_ennemis']), 0)
        pyxel.text(115,35, "j", 0)
        pyxel.text(125,35, "A", 0)
        pyxel.blt(110,35,0,97,140,5,5,1)
        pyxel.blt(120,35,0,105,140,5,5,1)
   

        pyxel.text(0,45, "gain du score:"+str(v['gain_score']), 0)
        pyxel.blt(110,45,0,97,140,5,5,1)
        pyxel.blt(120,45,0,105,140,5,5,1)
        pyxel.text(115,45, "Z", 0)
        pyxel.text(125,45, "E", 0)
        pyxel.text(0,55, "duree des potions:"+str(round(v['duree_effets']/30)), 0)
        pyxel.text(85,55, "S", 0)
        pyxel.blt(110,55,0,97,140,5,5,1)
        pyxel.blt(120,55,0,105,140,5,5,1)
        pyxel.text(115,55, "R", 0)
        pyxel.text(125,55, "T", 0)
        pyxel.text(0,65, "barre d'endurance:"+str(round(v['limite_endurance'])), 0)
        pyxel.blt(110,65,0,97,140,5,5,1)
        pyxel.blt(120,65,0,105,140,5,5,1)
        pyxel.text(115,65, "Y", 0)
        pyxel.text(125,65, "U", 0)
        pyxel.text(0,75, "vitesse du joueur:"+str(round(v['vitesse_option'])), 0)
        pyxel.blt(110,75,0,97,140,5,5,1)
        pyxel.blt(120,75,0,105,140,5,5,1)
        pyxel.text(115,75, "I", 0)
        pyxel.text(125,75, "L", 0)
        pyxel.text(0,85, "portee boss cache-cache:"+str(round(v['visibilite_boss'])), 0)
        pyxel.blt(115,85,0,97,140,5,5,1)
        pyxel.blt(125,85,0,105,140,5,5,1)
        pyxel.text(120,85, "q", 0)
        pyxel.text(130,85, "S", 0)
        pyxel.text(0,95, "vie du joueur:"+str(round(v['vie_option'])), 0)
        pyxel.blt(115,95,0,97,140,5,5,1)
        pyxel.blt(125,95,0,105,140,5,5,1)
        pyxel.text(120,95, "G", 0)
        pyxel.text(130,95, "F", 0)
        pyxel.text(100, 130, "N:suite", 0)
    
        pyxel.text(0, 130, "P: Revenir aux parametre", 0)
    if b['map_desert']:
        if v['couleur_arriereplan']!=3:
            pyxel.text(15,110, "d: selectionne la map desert",3)
        else:
            pyxel.text(15,110, "d: selectionne la map desert",9)

    else:
        if v['couleur_arriereplan']!=7:
            pyxel.text(15,110, "d: selectionne la map desert",7)
        else:
            pyxel.text(15,110, "d: selectionne la map desert",8)

    if b['map_colline']:
        if v['couleur_arriereplan']!=3:
            pyxel.text(15,120, "c: selectionne la map colline",3)
        else:
            pyxel.text(15,120, "c: selectionne la map colline",9)

    else:
        if v['couleur_arriereplan']!=7:
            pyxel.text(15,120, "c: selectionne la map colline",7)
        else:
            pyxel.text(15,120, "c: selectionne la map colline",8)

def update_option2():
    if pyxel.btn(pyxel.KEY_P):
        v['etatJeu']=4
        pyxel.play(0,11)
    if pyxel.btn(pyxel.KEY_O):
        v['etatJeu']=13
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_A):
        v['degats_au_joueur']+=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_Z):
        v['degats_au_joueur']-=1
        pyxel.play(0,11)
    if v['degats_au_joueur']<0:
        v['degats_au_joueur']=0
    if pyxel.btnp(pyxel.KEY_E):
        v['timer_option']+=30
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_R):
        v['timer_option']-=30
        pyxel.play(0,11)  
    if pyxel.btnp(pyxel.KEY_T):
        v['vie_ennemis']+=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_Y):
        v['vie_ennemis']-=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_U):
        if v['capsule_soin_option']:
            v['capsule_soin_option']=False
        elif v['capsule_soin_option']==False:
            v['capsule_soin_option']=True
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_I):
        v['vitesse_tir_solo']+=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_Q):
        v['vitesse_tir_solo']-=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_S):
        v['vitesse_tir_solo']+=10
        v['gain_score']+=10
        v['limite_endurance']+=100
        v['duree_effets']+=10
        v['fréquence_apparition_ennemis']+=10
        v['degats_au_joueur']+=10
        v['vie_ennemis']+=10
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_F):
        v['vitesse_tir_ennemi']+=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_D):
        v['vitesse_tir_ennemi']-=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_G):
        v['couleur_arriereplan']+=1
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_H):
        v['couleur_arriereplan']-=1
        pyxel.play(0,11)
    if v['couleur_arriereplan']<=0:
        v['couleur_arriereplan']=0
    if v['couleur_arriereplan']>=15:
        v['couleur_arriereplan']=15
    if pyxel.btnp(pyxel.KEY_J):
        if v['couleur_noir']==False:
            v['couleur_noir']=True
            v['couleur_noir_casier']=0
        else:
            v['couleur_noir']=False
            v['couleur_noir_casier']=10
        pyxel.play(0,11)
    if pyxel.btnp(pyxel.KEY_K):
        v['phrase de mort']+=1
    if pyxel.btnp(pyxel.KEY_L):
        v['phrase de mort']-=1
    if v['phrase de mort']>=1:
        v['phrase de mort']=1
    if v['phrase de mort']<=0:
        v['phrase de mort']=0
    
    
    
    
    
    
          
    
def draw_option2():
    pyxel.cls(v['couleur_arriereplan'])
    if v['couleur_noir']==True:
        pyxel.text(0, 130, "P: Revenir aux parametre", 0)
        pyxel.text(100, 130, "O: precedent", 0)
        pyxel.text(0,10, "degat ennemis:"+str(round(v['degats_au_joueur'])), 0)
        pyxel.blt(115,10,0,97,140,5,5,1)
        pyxel.blt(125,10,0,105,140,5,5,1)
        pyxel.text(120,10, "A", 0)
        pyxel.text(130,10, "Z", 0)

        pyxel.text(0,20, "temps d'une partie:"+str(round(v['timer_option']/30)), 0)
        pyxel.blt(115,20,0,97,140,5,5,1)
        pyxel.blt(125,20,0,105,140,5,5,1)
        pyxel.text(120,20, "E", 0)
        pyxel.text(130,20, "R", 0)

        pyxel.text(0,30, "vie supers ennemis:"+str(round(v['vie_ennemis'])), 0)
        pyxel.blt(115,30,0,97,140,5,5,1)
        pyxel.blt(125,30,0,105,140,5,5,1)
        pyxel.text(120,30, "T", 0)
        pyxel.text(130,30, "Y", 0)
        if v['capsule_soin_option']:
            pyxel.text(0,40, "capsule soin: active", 0)    
        else:
            pyxel.text(0,40, "capsule soin: desactive", 0)   

    
        pyxel.text(120,40, "U", 0)

        pyxel.text(0,50, "vitesse tir solo:"+str(round(v['vitesse_tir_solo'])), 0)
        pyxel.blt(115,50,0,97,140,5,5,1)
        pyxel.blt(125,50,0,105,140,5,5,1)
        pyxel.text(120,50, "i", 0)
        pyxel.text(130,50, "q", 0)

        pyxel.text(0,60, "delai entre 2 tirs ennemi:"+str(round(v['vitesse_tir_ennemi'])), 0)
        pyxel.blt(115,60,0,97,140,5,5,1)
        pyxel.blt(125,60,0,105,140,5,5,1)
        pyxel.text(120,60, "F", 0)
        pyxel.text(130,60, "D", 0)
        if v['couleur_arriereplan']==0:
            pyxel.text(0,70, "couleur arriere-plan : noir", 0)
        if v['couleur_arriereplan']==1:
            pyxel.text(0,70, "couleur arriere-plan : bleu fonce", 0)
        if v['couleur_arriereplan']==2:
            pyxel.text(0,70, "couleur arriere-plan : rose", 0)
        if v['couleur_arriereplan']==3:
            pyxel.text(0,70, "couleur arriere-plan : vert fonce",0)
        if v['couleur_arriereplan']==4:
            pyxel.text(0,70, "couleur arriere-plan : marron",0)
        if v['couleur_arriereplan']==5:
            pyxel.text(0,70, "couleur arriere-plan :bleu ciel", 0)
        if v['couleur_arriereplan']==6:
            pyxel.text(0,70, "couleur arriere-plan : bleu Glace", 0)
        if v['couleur_arriereplan']==7:
            pyxel.text(0,70, "couleur arriere-plan : blanc", 0)
        if v['couleur_arriereplan']==8:
            pyxel.text(0,70, "couleur arriere-plan : rouge", 0)
        if v['couleur_arriereplan']==9:
            pyxel.text(0,70, "couleur arriere-plan : orange", 10)
        if v['couleur_arriereplan']==10:
            pyxel.text(0,70, "couleur arriere-plan : jaune", 0)
        if v['couleur_arriereplan']==11:
            pyxel.text(0,70, "couleur arriere-plan : vert clair", 0)
        if v['couleur_arriereplan']==12:
            pyxel.text(0,70, "couleur arriere-plan : bleu clair", 0)
        if v['couleur_arriereplan']==13:
            pyxel.text(0,70, "couleur arriere-plan : gris ", 0)
        if v['couleur_arriereplan']==14:
            pyxel.text(0,70, "couleur arriere-plan : beige", 0)
        if v['couleur_arriereplan']==15:
           pyxel.text(0,70, "couleur arriere-plan : blanc pale", 0)
    
    
        pyxel.blt(140,70,0,97,140,5,5,1)
        pyxel.blt(150,70,0,105,140,5,5,1)
        pyxel.text(145,70, "G", 0)
        pyxel.text(155,70, "H", 0) 
        pyxel.text(0,80, "mode couleur noir:active", 0)
        pyxel.text(145,80, "j",0)
        if v['phrase de mort']==1:
            pyxel.text(0,90,"phrase quand vous mourrez: GAME OVER",0)
        elif v['phrase de mort']==0:
            pyxel.text(0,90,"phrase quand vous mourrez: Vous avez peri!",0)

        pyxel.blt(140,90,0,97,140,5,5,1)
        pyxel.blt(150,90,0,105,140,5,5,1)
        pyxel.text(145,95, "k", 0)
        pyxel.text(155,95, "L", 0) 
    
    else:
        pyxel.text(0, 130, "P: Revenir aux parametre", 10)
        pyxel.text(100, 130, "O: precedent", 10)
        pyxel.text(0,10, "degat ennemis:"+str(round(v['degats_au_joueur'])), 10)
        pyxel.blt(115,10,0,97,140,5,5,1)
        pyxel.blt(125,10,0,105,140,5,5,1)
        pyxel.text(120,10, "A", 10)
        pyxel.text(130,10, "Z", 10)

        pyxel.text(0,20, "temps d'une partie:"+str(round(v['timer_option']/30)), 10)
        pyxel.blt(115,20,0,97,140,5,5,1)
        pyxel.blt(125,20,0,105,140,5,5,1)
        pyxel.text(120,20, "E", 10)
        pyxel.text(130,20, "R", 10)

        pyxel.text(0,30, "vie supers ennemis:"+str(round(v['vie_ennemis'])), 10)
        pyxel.blt(115,30,0,97,140,5,5,1)
        pyxel.blt(125,30,0,105,140,5,5,1)
        pyxel.text(120,30, "T", 10)
        pyxel.text(130,30, "Y", 10)
        if v['capsule_soin_option']:
            pyxel.text(0,40, "capsule soin: active", 10)    
        else:
            pyxel.text(0,40, "capsule soin: desactive", 10)   

    
        pyxel.text(120,40, "U", 10)

        pyxel.text(0,50, "vitesse tir solo:"+str(round(v['vitesse_tir_solo'])), 10)
        pyxel.blt(115,50,0,97,140,5,5,1)
        pyxel.blt(125,50,0,105,140,5,5,1)
        pyxel.text(120,50, "i", 10)
        pyxel.text(130,50, "q", 10)

        pyxel.text(0,60,  "delai entre 2 tirs ennemi:"+str(round(v['vitesse_tir_ennemi'])), 10)
        pyxel.blt(115,60,0,97,140,5,5,1)
        pyxel.blt(125,60,0,105,140,5,5,1)
        pyxel.text(120,60, "F", 10)
        pyxel.text(130,60, "D", 10)
        if v['couleur_arriereplan']==0:
            pyxel.text(0,70, "couleur arriere-plan : noir", 10)
        if v['couleur_arriereplan']==1:
            pyxel.text(0,70, "couleur arriere-plan : bleu fonce", 10)
        if v['couleur_arriereplan']==2:
            pyxel.text(0,70, "couleur arriere-plan : rose", 10)
        if v['couleur_arriereplan']==3:
            pyxel.text(0,70, "couleur arriere-plan : vert fonce", 10)
        if v['couleur_arriereplan']==4:
            pyxel.text(0,70, "couleur arriere-plan : marron", 10)
        if v['couleur_arriereplan']==5:
            pyxel.text(0,70, "couleur arriere-plan :bleu ciel", 10)
        if v['couleur_arriereplan']==6:
            pyxel.text(0,70, "couleur arriere-plan : bleu Glace", 10)
        if v['couleur_arriereplan']==7:
            pyxel.text(0,70, "couleur arriere-plan : blanc", 10)
        if v['couleur_arriereplan']==8:
            pyxel.text(0,70, "couleur arriere-plan : rouge", 10)
        if v['couleur_arriereplan']==9:
            pyxel.text(0,70, "couleur arriere-plan : orange", 10)
        if v['couleur_arriereplan']==10:
            pyxel.text(0,70, "couleur arriere-plan : jaune", 10)
        if v['couleur_arriereplan']==11:
            pyxel.text(0,70, "couleur arriere-plan : vert clair", 10)
        if v['couleur_arriereplan']==12:
            pyxel.text(0,70, "couleur arriere-plan : bleu clair", 10)
        if v['couleur_arriereplan']==13:
            pyxel.text(0,70, "couleur arriere-plan : gris ", 10)
        if v['couleur_arriereplan']==14:
            pyxel.text(0,70, "couleur arriere-plan : beige", 10)
        if v['couleur_arriereplan']==15:
           pyxel.text(0,70, "couleur arriere-plan : blanc pale", 10)
    
       
            
       
        pyxel.text(0,80, "mode couleur noir:desactive", 10)
        pyxel.text(145,80, "j",10)

        pyxel.blt(140,70,0,97,140,5,5,1)
        pyxel.blt(150,70,0,105,140,5,5,1)
        pyxel.text(145,70, "G", 10)
        pyxel.text(155,70, "H", 10) 

        if v['phrase de mort']==1:
            pyxel.text(0,90,"phrase quand vous mourrez: GAME OVER",10)
        elif v['phrase de mort']==0:
            pyxel.text(0,90,"phrase quand vous mourrez: Vous avez peri!",10)
        pyxel.blt(140,90,0,97,140,5,5,1)
        pyxel.blt(150,90,0,105,140,5,5,1)
        pyxel.text(145,95, "k", 10)
        pyxel.text(155,95, "L", 10) 

        
       
       
    
   





    
#====================================================================================================================================================Menu2
def init():
    b['x']=20
    b['y']=110
    b['ennemis']=[]
    b['tirs_j']=[]
    v['vies']=v['vie_option']
    v['score']=0
    b['explosions']=[]
    b['bombes_restantes']=5
    b['explosions_bombes']=[]
    v['endurance']=v['limite_endurance']
    v['capsule_soin']=[]
    v['vitesse']=v['vitesse_option']
    b['bombes']=[]
    
    
    v['limite_spawn']=1
    
    b['degat_explosion']=[]
    b['explosions_ennemis']=[]
    v['vitesse_e']=1
    v['vitesse_tir_e']=2
    b['tirs_e']=[]
    v['sang']=[]
    v['timer']=v['timer_option']
    v['pièces']=[]
    v['x_ia']=60                  
    v['y_ia']=40
    v['score_ia'] =0
    v['tir_ia']=[]
    v['timer_p']=900
    v['bouclier']=[]
    b['limite_barricade']=3
    v['cherche_joueur']=False
    v['ia_x']=60
    v['ia_y']=40
    v['limite_objectif']=1
    v['objectif']=[]
    v['touchable']=True
    v['u']=48
    v['v']=16
    v['limite_aleatoire']=1
    v['timer_a']=90
    v['timer_cache_cache']=930
    v['limite_l']=1
    v['pas_en_moins']=1/3
    v['pas_restant']=v['l']
    v['l_monnaie']=1
    v['timer_fin_cache']=75
    v['tirs_j_split']=[]
    v['timer_effet']=[]
    v['collision']=False
    v['limite_spawn_capsule']=1
    v['capsule_endurance']=[]
    v['timer_effet_endurance']=[]
    v['frequence_endurance']=50
    v['infinie_endurance']=False
    v['super']=0
    v['tir_super']=[]
    v['tirs_j_split']=[]
    v['tir_super2']=[]
    v['ennemis_2']=[]
    v['timer_inv_ennemi2']=[]
    v['invulnerable_e:']=False
    
    
def animation_joueur():
    if v['vaisseau_rouge']:
        if pyxel.btn(pyxel.KEY_UP) or pyxel.btn(pyxel.KEY_LEFT) or pyxel.btn(pyxel.KEY_DOWN) or pyxel.btn(pyxel.KEY_RIGHT):
            v['mouvement']=True
        else:
            v['mouvement']=False   
        if v['mouvement']:
            v['x']=24
            v['y']=96
        else:
            v['x']=32
            v['y']=16 
    elif v['vaisseau_blanc']  : 
        if pyxel.btn(pyxel.KEY_UP) or pyxel.btn(pyxel.KEY_LEFT) or pyxel.btn(pyxel.KEY_DOWN) or pyxel.btn(pyxel.KEY_RIGHT):
            v['mouvement']=True
        else:
            v['mouvement']=False   
        if v['mouvement']:
            v['x']=16
            v['y']=32
        else:
            v['x']=32
            v['y']=32 
    elif v['vaisseau_noel']:
        if pyxel.btn(pyxel.KEY_UP) or pyxel.btn(pyxel.KEY_LEFT) or pyxel.btn(pyxel.KEY_DOWN) or pyxel.btn(pyxel.KEY_RIGHT):
            v['mouvement']=True
        else:
            v['mouvement']=False   
        if v['mouvement']:
            v['x']=240
            v['y']=52
        else:
            v['x']=233
            v['y']=21

    
def animation_ennemi_tir():
    for tire in v['tir_detection']:
        tire[0]-=1
        if tire[0]>0:
            v['tir_fait']=True
        if tire[0]<=0:
            v['tir_fait']=False 
    
    if v['tir_fait']==True :
        v['u']=96
        v['v']=16
    else:
        v['u']=48
        v['v']=16
def invulnerabilite():
    
    if pyxel.btnp(pyxel.KEY_A) and pyxel.btn(pyxel.KEY_RIGHT) and v['endurance']>=20:
        b['x']+=10
        v['endurance']-=20
        v['time_i']=60
        v['invulnerable']=True
    if pyxel.btnp(pyxel.KEY_A) and pyxel.btn(pyxel.KEY_LEFT) and v['endurance']>=20:
        b['x']-=10
        v['endurance']-=20
        v['time_i']=60
        v['invulnerable']=True
    
    
    if v['time_i']>0:
        v['time_i']-=1
    else:
        v['invulnerable']=False

    
def gestion_liste_explosion():
    if len(b['explosions'])>0:
        for explosion in b['explosions']:
            explosion[2]-=1
            if explosion[2]<=0:
                b['explosions'].remove(explosion)
def gestion_explosion_bombe():
    if len(b['explosions_bombes'])>0:
        for bombe_explosion in b['explosions_bombes']:
            bombe_explosion[4]-=1
            if bombe_explosion[4]<=0:
                b['explosions_bombes'].remove(bombe_explosion)
        return

    
                     

    

    
        

#=======================================================================================================================================================================================niveau3
def objectif():
    if v['limite_objectif']>0 and pyxel.frame_count%15==0:
        v['limite_objectif']-=1
        v['objectif'].append([random.randint(60,128),random.randint(20,115)])
def objectif_collision():
    for o in v['objectif']:
        if collision(b['x'],b['y'],b['x']+10,b['y']+12,o[0],o[1],o[0]+10,o[1]+5):
            v['etatJeu']=6
            v['victoire']+=1
            
            v['collision']=True
        else: 
            v['collision']=False
     
def gestion_timer_cc():
    if v['timer_cache_cache']>0:
        v['timer_cache_cache']-=1
    else:
        v['etatJeu']=6
def update_game3():
    
    vaisseau_joueur_move()
    invulnerabilite()
    animation_ennemi_tir()
    gestion_liste_explosion()
    gestion_deblocage_armes()
    touche_joueur_explosion()
    gestion_invulnerable_explosion()
    creation_pièce()
    gestion_collision_pièce()
    règles_pièces()
    objectif()
    collision_cone_joueur()
    deplacement_ia2()
    collision_ia()
    objectif_collision()
    gestion_timer_cc()
    
    pause_gestion()
    if v['vies']<=0:
        v['etatJeu']=6
    v['vitesse']=1.25
    
    



def draw_game3():
    pyxel.cls(1)
    pyxel.bltm(0,0,4,0,0,160,160,1)
    explosion_e_draw()
    vie_draw()
    explosion_et_tir_e_draw() 
    bombe_et_bombe_explosion_draw()
    endurance_draw()
    pyxel_endurance_capsule_et_ennemi_draw()
    ###################################################################################################################################3
   
    if v['cherche_joueur']==False:
        pyxel.blt(v['ia_x'],v['ia_y'],0,v['u'],v['v'],16,32,1)
    else:
        pyxel.blt(v['ia_x'],v['ia_y'],0,v['u'],v['v'],16,16,1)


    
    pyxel.text(90,20,"vu:"+str(v['cherche_joueur']),7)
    pyxel.text(90,30,"timer:"+str(round(v['timer_cache_cache']/30)),7)
    
    
    pyxel.text(70,10,"touchable:"+str(v['touchable']),7)
   
    for o in v['objectif']:
        pyxel.rect(o[0],o[1],10,5,8)
        pyxel.text(o[0]-5,o[1]-3,"objectif",9)
    



def collision_cone_joueur():
    if b['x'] > v['ia_x']+v['visibilite_boss'] or b['x']<v['ia_x']-v['visibilite_boss'] or b['y']>v['ia_y']+v['visibilite_boss'] or b['y']<v['ia_y']-v['visibilite_boss'] and v['dans_les_buissons']==False :
        
    
        
        v['cherche_joueur']=False
    else:
        
        v['cherche_joueur']=True
    if (b['x']>0 and b['x']<30 and b['y']<120 and b['y']>30) or (b['x']>87 and b['x']<110 and b['y']>=5 and b['y']<15):
        v['dans_les_buissons']=True
    else:
        v['dans_les_buissons']=False
    if v['dans_les_buissons']:
        if b['x']>=v['ia_x']+22 or b['x'] <=v['ia_x']-22 or  b['y']>=v['ia_y']+22 or  b['y']<=v['ia_y']-22:
        
            v['cherche_joueur']=False
            v['touchable']=False
            v['pas_en_moins']=1/10
            v['x']=16
            v['y']=16
        else:
            v['cherche_joueur']=True
            v['touchable']=True
            v['pas_en_moins']=1/10
            v['x']=16
            v['y']=16
        
    else:
        v['touchable']=True
        v['pas_en_moins']=1/3

        if v['vaisseau_blanc']:
           
            v['x']=32
            v['y']=32
        
        elif v['vaisseau_rouge']:
    
           
            v['x']=32
            v['y']=16
        elif v['vaisseau_noel']:
            v['x']=233
            v['y']=21
            
        v['touchable']=True

def limite_pas():
    if v['limite_l']>0:
        v['l']= random.randint(60,90)
        v['limite_l']-=1
    v['pas_restant']=v['l']
    
def deplacement_ia2():
    if v['cherche_joueur']==False:
        v['u']=208
        v['v']=72
    
        if pyxel.frame_count%30==0:
            v['n']=random.randint(1,4)
        if v['n']==4 :
            v['ia_x'] +=2
        if v['n']==3 :
            v['ia_x'] -=2
        if  v['n']==2 :
            v['ia_y'] -=2
        if v['n']==1 :
            v['ia_y'] +=2
        if v['ia_x']>136:
            v['ia_x']=136
        if v['ia_y']>136:
            v['ia_y']=136
        if v['ia_y']<=6:
            v['ia_y']=6
        if v['ia_x']<=6:
            v['ia_x']=6
    else:
        v['u']=48
        v['v']=16
        if v['ia_x']>b['x']:
            v['ia_x']-= 1.5
        elif v['ia_x']<b['x']:
            v['ia_x']+=1.5
        if v['ia_y']>b['y']:
            v['ia_y']-=1.5
        elif v['ia_y']<b['y']:
            v['ia_y']+=1.5
def collision_ia():
    if collision(v['ia_x'],v['ia_y'],v['ia_x']+10,v['ia_y']+10,b['x'],b['y'],b['x']+10,b['y']+12) :
        if v['touchable']==True:
            v['vies']-=4
        else:
            v['vies']-=0


def update_skin():
    if pyxel.btnp(pyxel.KEY_V) :
        if v['monnaie']>=40:
            v['monnaie']-=40
            pyxel.play(1,14)
            v['p_laser_vert']=True
    if pyxel.btnp(pyxel.KEY_V) and v['p_laser_vert']:
        v['laser_verts']=True
        v['laser_rouge']=False
        v['laser_multicolore']=False
        v['laser_sapin']=False
       
    if pyxel.btnp(pyxel.KEY_R):
        v['laser_verts']=False
        v['laser_rouge']=True
        v['laser_sapin']=False
        v['laser_multicolore']=False
        
    if pyxel.btnp(pyxel.KEY_5) :
        if v['monnaie']>=20:
            v['monnaie']-=20
            v['p_vaisseau_blanc']=True
            pyxel.play(1,14)
    if pyxel.btnp(pyxel.KEY_5) and v['p_vaisseau_blanc']:
        v['vaisseau_rouge']=False
        v['vaisseau_blanc']=True
        v['vaisseau_noel']=False
        
        
        
    
    if pyxel.btnp(pyxel.KEY_4):
        v['vaisseau_rouge']=True
        v['vaisseau_blanc']=False
        v['vaisseau_noel']=False
        
    if pyxel.btnp(pyxel.KEY_C) :
        if v['monnaie']>=50:
            v['monnaie']-=50
            v['p_laser_multicolore']=True
            pyxel.play(1,14)
    if pyxel.btnp(pyxel.KEY_C) and v['p_laser_multicolore']:
        v['laser_verts']=False
        v['laser_rouge']=False
        v['laser_multicolore']=True
        v['laser_sapin']=False
        
    if pyxel.btnp(pyxel.KEY_S) :
        if v['monnaie']>=60:
            v['monnaie']-=60
            v['p_laser_sapin']=True
            pyxel.play(1,14)
    if pyxel.btnp(pyxel.KEY_S) and v['p_laser_sapin']:
        v['laser_verts']=False
        v['laser_rouge']=False
        v['laser_multicolore']=False
        v['laser_sapin']=True
        
    if pyxel.btnp(pyxel.KEY_N) :
        if v['monnaie']>=100:
            v['monnaie']-=100
            v['payer_vaisseau_noel']=True
            pyxel.play(1,14)
        if pyxel.btnp(pyxel.KEY_N) and v['payer_vaisseau_noel']:

            v['vaisseau_rouge']=False
            v['vaisseau_blanc']=False
            v['vaisseau_noel']=True
    if pyxel.btnp(pyxel.KEY_M):
        v['etatJeu']=0
            
        
    
    






def draw_skin():
    pyxel.cls(v['couleur_arriereplan'])
    pyxel.text(120,10,""+str(v['monnaie']),v['couleur_noir_casier'])
    pyxel.text(133,10,"$",v['couleur_noir_casier'])
    pyxel.text(25,10,"n",v['couleur_noir_casier'])
    pyxel.blt(30,0,0,234,20,16,20,1)
    if v['payer_vaisseau_noel']==False:
        pyxel.text(40,10,"100 $",v['couleur_noir_casier'])
    else:
        
        if v['vaisseau_noel'] :
            pyxel.text(40,10,"equipe",v['couleur_noir_casier'])
        else:
            pyxel.text(40,10,"posseder",v['couleur_noir_casier'])




    pyxel.text(25,30,"s",v['couleur_noir_casier'])
    pyxel.blt(30,20,0,152,40,8,16,1)
    if v['p_laser_sapin']==False:
        pyxel.text(40,30,"60 $",v['couleur_noir_casier'])
    else:
        
        if v['laser_sapin'] :
            pyxel.text(40,30,"equipe",v['couleur_noir_casier'])
        else:
            pyxel.text(40,30,"possede",v['couleur_noir_casier'])

    pyxel.text(25,70,"R",v['couleur_noir_casier'])
    pyxel.blt(30,60,0,64,64,8,16,1)
    if v['laser_rouge']:
        pyxel.text(40,70,"equipe",v['couleur_noir_casier'])
    else:
        pyxel.text(40,70,"posseder",v['couleur_noir_casier'])

    

    pyxel.text(25,90,"v",v['couleur_noir_casier'])
    pyxel.blt(30,80,0,72,64,8,16,1)
    if v['p_laser_vert']==False:
        pyxel.text(40,90,"40 $",v['couleur_noir_casier'])
    else:
        if v['laser_verts'] :
            pyxel.text(40,90,"equipe",v['couleur_noir_casier'])
        else:
            pyxel.text(40,90,"posseder",v['couleur_noir_casier'])
    pyxel.text(25,120,"4",v['couleur_noir_casier'])
    pyxel.blt(30,110,0,32,16,16,16,1)
    if v['vaisseau_rouge']:
        pyxel.text(40,120,"equipe",v['couleur_noir_casier'])
    else:
        pyxel.text(40,120,"possede",v['couleur_noir_casier'])
    pyxel.text(25,100,"5",v['couleur_noir_casier'])
    pyxel.blt(30,90,0,32,32,16,16,1)
    if v['p_vaisseau_blanc']==False:
        pyxel.text(40,100,"20 $",v['couleur_noir_casier'])
    else:
        
        if v['vaisseau_blanc']:
            pyxel.text(40,100,"equipe",v['couleur_noir_casier'])
        else:
            pyxel.text(40,100,"posseder",v['couleur_noir_casier'])
    pyxel.text(25,50,"C",v['couleur_noir_casier'])
    pyxel.blt(30,40,0,160,0,16,16,1)
    if v['p_laser_multicolore']==False:
        pyxel.text(40,50,"50 $",v['couleur_noir_casier'])
    else:
        
        if v['laser_multicolore'] :
            pyxel.text(40,50,"equipe",v['couleur_noir_casier'])
        else:
            pyxel.text(40,50,"posseder",v['couleur_noir_casier'])
    pyxel.text(5,135,"M:menu",v['couleur_noir_casier'])
###########################################################################################################
def update_astuce():
    gestion_timer_astuce()
    


    if v['limite_aleatoire']>0:
        v['x']=random.randint(1,6)
        v['limite_aleatoire']=0
    if v['timer_a']<=0:
        if v['mode']==1:
            v['etatJeu']=1
        elif v['mode']==2:
            v['etatJeu']=3
        elif v['mode']==3:
            v['etatJeu']=5
        elif v['mode']==10:
            v['etatJeu']=15


def draw_astuce():
    pyxel.cls(1)
    if v['mode']==1:
        if b['map_colline']:
            pyxel.bltm(0,48,1,0,0,160,160,1)
        else:
            pyxel.bltm(0,0,6,0,0,160,160,1)

    if v['mode']==3:
        pyxel.bltm(0,0,4,0,0,160,160,1)
    if v['x']==1:
        if pyxel.frame_count%20>10:
            pyxel.text(45,10,"Astuces",8)
        else:
            pyxel.text(45,10,"Astuces",10)
        pyxel.text(20,50,"Vous ne pouvez pas  ",8)
        pyxel.text(20,60,"tuer les ennemis ",8)
        pyxel.text(20,70,"dans le mode cache-cache",8)
        pyxel.text(20,80,"et dans le mode piece",8)
        pyxel.text(90,120,"chargement...",8)
        
    elif v['x']==2:
        if pyxel.frame_count%20>10:
            pyxel.text(45,10,"Astuces",8)
        else:
            pyxel.text(45,10,"Astuces",10)

        pyxel.text(20,50,"Au mode piece recoltez plus  ",8)
        pyxel.text(20,60,"de piece que l'adversaire! ",8)
        pyxel.text(90,120,"chargement...",8)
    elif v['x']==3:
        if pyxel.frame_count%20>10:
            pyxel.text(45,10,"Astuces",8)
        else:
            pyxel.text(45,10,"Astuces",10)
        pyxel.text(20,50,"Au mode Ennemis gagnez un max  ",8)
        pyxel.text(20,60,"de score en 30 secondes!",8)
        pyxel.text(90,120,"chargement...",8)
    elif v['x']==4:
        if pyxel.frame_count%20>10:
            pyxel.text(45,10,"Astuces",8)
        else:
            pyxel.text(45,10,"Astuces",10)
        pyxel.text(20,50,"Au mode cache-cache,recuperez",8)
        pyxel.text(20,60,"l'objectif sans etre vu!",8)
        pyxel.text(90,120,"chargement...",8)
    elif v['x']==5:
        if pyxel.frame_count%20>10:
            pyxel.text(45,10,"Astuces",8)
        else:
            pyxel.text(45,10,"Astuces",10)
        pyxel.text(20,50,"attention chaque tir coute du",8)
        pyxel.text(20,60,"carburant,ne spammez pas!",8)
        pyxel.text(90,120,"chargement...",8)
    else:
        if pyxel.frame_count%20>10:
            pyxel.text(45,10,"Astuces",8)
        else:
            pyxel.text(45,10,"Astuces",8)
        pyxel.text(20,50,"attention! le deplacement",8)
        pyxel.text(20,60,"coute du carburant",8)
        pyxel.text(90,120,"chargement...",8)


#=======================================================================================================

def update_show_score():
    if pyxel.btn(pyxel.KEY_M):
        v['etatJeu']=0
        pyxel.play(0,11)
    if pyxel.btn(pyxel.KEY_S):
        v['etatJeu']=9
        pyxel.play(0,11)
    
    
def draw_show_score():
    pyxel.cls(v['couleur_arriereplan'])
    pyxel.text(40,65,"ton score:"+str(v['score']),v['couleur_noir_casier'])
    if v['score']<=10 :
        pyxel.text(40,80,"vous etes Mauvais!!!",8)
        if v['l_monnaie']>0:
            v['monnaie']+=0
            v['l_monnaie']-=1
    elif v['score']>10 and v['score']<=15 :
        pyxel.text(40,80,"Pas Terrible",9)
        if v['l_monnaie']>0:
            v['l_monnaie']-=1
            v['monnaie']+=5
    elif v['score']>15 and v['score']<=20 :
        pyxel.text(40,80,"Pas Mal!!!",9)
        if v['l_monnaie']>0:
            v['monnaie']+=10
            v['l_monnaie']-=1
    elif v['score']>20 and v['score']<=25:
        pyxel.text(40,80,"Excellent!!!",3)
        if v['l_monnaie']>0:
            v['monnaie']+=20
            v['l_monnaie']-=1
    elif v['score']>25 :
        if pyxel.frame_count%20>10:
            pyxel.text(40,80,"t'es un dieu!!!!",8)
        else:
            pyxel.text(40,80,"t'es un dieu!!!!",10)
        if v['l_monnaie']>0:
            v['monnaie']+=50
            v['l_monnaie']-=1
        


    


    
    pyxel.text(0,150,"M:menu",v['couleur_noir_casier'])
    pyxel.text(110,150,"S:score menu",v['couleur_noir_casier'])
##########################################################################################################
def update_fin_piece():
    if pyxel.btn(pyxel.KEY_M):
        v['etatJeu']=0
    if v['score']>v['score_ia']:
        v['unlock_split']+=1
        if v['l_monnaie']>0:
            v['monnaie']+=40
            v['l_monnaie']-=1
            
    else:
        v['monnaie']+=0
    






def draw_fin_piece():
    pyxel.cls(1)
    pyxel.bltm(0,0,7,0,0,160,160,1)
    pyxel.text(10,130,"M:menu",3)
    if v['score']>v['score_ia']:
       
        if pyxel.frame_count%20<10:
            pyxel.text(37,54,"VICTOIRE!!!",8)
        else:
            pyxel.text(37,54,"VICTOIRE!!!",10)
    elif v['score']==v['score_ia']:
        pyxel.text(37,54,"Egalite!",3)
    else:
        pyxel.text(37,54,"defaite!",8)


##############################################################################################################################################    
def ennemi2_creation():
    if pyxel.frame_count%100==0:
        if v['spawn_ennemis_fort']:
            v['ennemis_2'].append([random.randint(30,110),random.randint(20,40),v['vie_ennemis']])
def gestion_spawn():
    if len(v['ennemis_2'])==0:
        v['spawn_ennemis_fort']=True
    else:
        v['spawn_ennemis_fort']=False
def ennemi2_move():
    if pyxel.frame_count%5==0:
        v['mouv']=random.randint(2,4)
    for ennemi in v['ennemis_2']:
        
        if v['mouv']==2:
            ennemi[1]+=1.5
        if v['mouv']==3:
            ennemi[1]-=1.5
        else:
            ennemi[1]+=0
        
        if ennemi[0]>144:
            ennemi[0]=144
        if ennemi[0]<16:
            ennemi[0]=16
        if ennemi[1]>144:
            ennemi[1]=144
        if ennemi[1]<16:
            ennemi[1]=16
        if ennemi[0]>b['x']:
            ennemi[0]-=1
        else:
            ennemi[0]+=1

def animation_ennemis():
    if v['mouv']==2 or v['mouv']==3:
        v['mouvement_e']=True
    elif v['mouv']==0:
        v['mouvement_e']=False

def tir_ennemis():
    
    for ennemi in v['ennemis_2']:
        if pyxel.frame_count%v['vitesse_tir_ennemi']==0:
            b['tirs_e'].append([ennemi[0]+8,ennemi[1]+15])
def tir_ennemis_deplacement():
    
    for tir in b['tirs_e']:
        tir[1]+=3.5
                

        if tir[1]<0:
            b['tirs_e'].remove(tir)
            
def tir_e_draw_et_ennemi2():
    for tir in b['tirs_e']:
        pyxel.blt(tir[0],tir[1],0,64,64,8,16,1)
    for ennemi in v['ennemis_2']:
        if v['mouvement_e']==False:
            pyxel.blt(ennemi[0],ennemi[1],0,16,48,16,16,1)
        elif v['mouvement_e']:
            pyxel.blt(ennemi[0],ennemi[1],0,32,240,16,16,1)



def gestion_vie_ennemie():
    for ennemi in v['ennemis_2']:
        if ennemi[2]<=0:
            v['ennemis_2'].remove(ennemi)


    
def mort_game2():
    if v['vies']<=0:
        v['etatJeu']=11
        v['score_liste'].append(v['score'])
        v['limite_essaie']-=1


def pause_gestion():
    if pyxel.btnp(pyxel.KEY_P):
        if v['etatJeu']==1:
            v['pause']=1
        if v['etatJeu']==3:
            v['pause']=2
        if v['etatJeu']==5:
            v['pause']=3
        if v['etatJeu']==15:
            v['pause']=4
        
        
        
        v['etatJeu']=16
def update_game2():
    tirs_joueur_creation()
    tir_joueur_deplacement()
    tirs_super()
    tir_super_deplacement()   
    animation_joueur()
    invulnerabilite()
    animation_ennemi_tir()
    gestion_liste_explosion()
    gestion_deblocage_armes()
    touche_joueur_explosion()
    gestion_invulnerable_explosion()
    tir_ennemis_deplacement()
    gestion_spawn()
    mort_game2()
    tir_ennemis()
    bouclier_creation()
    bouclier_collision()
    ennemi2_creation() 
    ennemi2_move()   
    gestion_vie_ennemie()
    invuln_ennemi2() 
    animation_ennemis()  
    #capsules
    pause_gestion()
    touche_ennemi_capsule()
    
    touche_joueur_capsule()
    
   
    pause_gestion()
    gestion_effet_endurance()
    touche_joueur_endurance_capsule()
    #endurance
    endurance()
    #ennemi
    ennemis_move()
    ennemis_creation()
    gestion_explosion_ennemis() 
    #personnage
    vaisseau_joueur_move()
    #tir_joueur
    
    tir_ia_deplacement()
    touche_ennemis()
    touche_joueur()
    
    gestion_explosion_bombe()
    touche_ennemis_bombe()
    touche_tir_e_bombe()
    




def draw_game2():
    pyxel.cls(1)
    if b['map_colline']:
        pyxel.bltm(0,0,1,0,0,160,160,1)
    else:
        pyxel.bltm(0,0,6,0,0,160,160,1)
    
    affichage_game()
    draw_bouclier()
    tir_e_draw_et_ennemi2()
    explosion_e_draw()
    tirs_draw()
    vie_draw()
    explosion_et_tir_e_draw() 
    bombe_et_bombe_explosion_draw()
    pyxel_endurance_capsule_et_ennemi_draw()
    super_draw()
    endurance_draw()

#===================================================================================================================
def update_pause():
    if pyxel.btnp(pyxel.KEY_SPACE):
        if v['pause']==1:
            v['etatJeu']=1
        if v['pause']==2:
            v['etatJeu']=3
        if v['pause']==3:
            v['etatJeu']=5
        if v['pause']==4:
            v['etatJeu']=15
    if pyxel.btnp(pyxel.KEY_N):
        v['etatJeu']=0









def draw_pause():
    
    pyxel.cls(v['couleur_arriereplan'])
    if pyxel.frame_count%40<20:
        pyxel.text(40,70,"vous etes en pause!",13)
    else:
        pyxel.text(40,70,"vous etes en pause!",8)

    pyxel.text(40,80,"espace :reprendre",v['couleur_noir_casier'])
    pyxel.text(0,110,"vie:"+str(v['vies']),v['couleur_noir_casier'])
    pyxel.text(0,120,"carburant:"+str(round(v['endurance'])),v['couleur_noir_casier'])
    pyxel.text(0,130,"charge super:"+str(v['super']),v['couleur_noir_casier']) 
    pyxel.text(0,100,"score:"+str(v['score']),v['couleur_noir_casier'])
    if v['pause']==4:
        if len(v['ennemis_2'])>0:
            for ennemi in v['ennemis_2']:
                if b['y']>=ennemi[1]:
                    v['distance_ennemis_fort_y']= b['y']-ennemi[1]
                else:
                    v['distance_ennemis_fort_y']= ennemi[1]-b['y']
                if b['x']>=ennemi[0]:
                    v['distance_ennemis_fort_x']= b['x']-ennemi[0]
                else:
                    v['distance_ennemis_fort_x']= ennemi[0]-b['x']
                v['distance_ennemis_fort']=math.sqrt(v['distance_ennemis_fort_x']**2+v['distance_ennemis_fort_y']**2)
                
            pyxel.text(0,90,"distance de ennemi fort:"+str(round(v['distance_ennemis_fort'])),v['couleur_noir_casier'])
            pyxel.text(120,90,"pixels",v['couleur_noir_casier'])
            


    pyxel.text(100,155,"N :quitter",v['couleur_noir_casier'])


pyxel.run(update,draw)