SPACE INVADERS

# -*- coding: cp1252 -*-

###################################
#                                 #
#  Programme : Space invaders     #
#  Auteur : Shakan972             #
#  Date de creation : 13/04/07    #
#                                 #
###################################


##########################################
#                                        #
# Importations des fonctions nécessaires #
#                                        #
##########################################

from Tkinter import *
from random import *
import time
import pickle

############################
#                          #
# Définition des fonctions #
#                          #
############################

# Cette fonction affiche l'écran de présentation du jeu

def EcranDePresentation():
    global DebutJeu
    if DebutJeu!=1:
        AffichageScore.configure(text="",font=('Fixedsys',16))
        AffichageVie.configure(text="",font=('Fixedsys',16))
        can.delete(ALL)
        fen.after(1500,Titre)

# On afficher le nom du jeu à l'écran

def Titre():
    global DebutJeu
    if DebutJeu!=1:
        can.create_text(320,240,font=('Fixedsys',24),text="SPACE INVADERS",fill='blue')
        fen.after(2000,Titre2)

# On affiche le nom de l'auteur ( It's me !! :p )

def Titre2():
    global DebutJeu
    if DebutJeu!=1:
        can.create_text(320,270,font=('Freshbot',18),text="By Shakan972",fill='red')
        fen.after(3000,LoadMeilleurScore)

# Cette fonction va permettre d'enregistrer
# le meilleur score

def SaveMeilleurScore(resultat):
    FichierScore=open('HighScore','r')
    lecture=pickle.load(FichierScore)

    # Si le score réalisé à la fin de la partie
    # est supérieur à celui déjà enregistré dans le fichier
    # alors on remplace ce dernier par le nouveau score record
    
    if resultat>lecture:
        FichierScore=open('HighScore','w')
        pickle.dump(resultat,FichierScore)
        FichierScore.close()
        fen.after(2000,MessageRecord)
    else:
        fen.after(15000,EcranDePresentation)
    FichierScore.close()

# Cette fonction affiche un message
# lui indiquant qu'il a établit un
# nouveau record :D

def MessageRecord():
    can.delete(ALL)
    can.create_text(320,240,font=('Georgia',18),text="Vous avez établi un nouveau record !!",fill='red')
    fen.after(3000,LoadMeilleurScore)
        
# Quant à cette fonction elle va permettre
# de lire le meilleur score afin de l'afficher

def LoadMeilleurScore():
    global DebutJeu
    if DebutJeu!=1:
        FichierScore=open('HighScore','r')
        lecture=pickle.load(FichierScore)
        can.delete(ALL)
        can.create_text(320,240,font=('Fixedsys',24),text="HIGH SCORE",fill='blue')
        can.create_text(320,270,font=('Fixedsys',24),text=str(lecture),fill='blue')
        FichierScore.close()
        fen.after(3000,EcranDePresentation)

# Cette fonction permet de vérifier
# l'existence d'un fichier

def existe(fname):
    try:
        f=open(fname,'r')
        f.close()
        return 1
    except:
        return 0

# Cette fonction permet de réinitialiser le jeu
# selon la volonté du joueur de recommencer une partie

def new_game():
    global xe,ye,xe2,ye2,xe3,ye3,LimiteAvancement,dx,ListeCoordEnnemis,ListeEnnemis,ObusEnnemi,flag,photo,NbreEnnemis,Score,ViesJoueur
    global ListeAbri,CoordonneesBriques,projectile,feu,feuEnnemi,PasAvancement
    global dyobus,dyobusEnnemi,DebutJeu,BonusActif,dxeb,EnnemiBonus,Mort,photo,PasMax,NbreEnRangees
    
    DebutJeu=1

    # On remet l'image d'origine

    photo=PhotoImage(file='earth.gif')
    can.create_image(320,240,image=photo)

    Mort=0

    # On efface tout à l'écran
    
    can.delete(ALL)
    can.create_image(320,240,image=photo)

    # Coordonnées de départ des ennemis
    # pour chaque catégorie
    
    xe,ye=20,20
    xe2,ye2=20,80
    xe3,ye3=20,160
    
    LimiteAvancement=1
    if len(ObusEnnemi)==1:
        can.delete(ObusEnnemi[0])
    dx=1

    # Pas d'avancement d'un obus
    # tiré par le joueur
    
    dyobus=20

    # Pas d'avancement d'un obus
    # tiré par un ennemi
    
    dyobusEnnemi=10
    feu=0
    ViesJoueur=3
    Score=0
    feuEnnemi=0
    
    Ennemis1=[]
    Ennemis2=[]
    Ennemis3=[]
    ListeEnnemis=[Ennemis1,Ennemis2,Ennemis3]
    
    Ennemis=[]
    projectile=[]
    
    CoordEnnemis1=[]
    CoordEnnemis2=[]
    CoordEnnemis3=[]
    ListeCoordEnnemis=[CoordEnnemis1,CoordEnnemis2,CoordEnnemis3]
    
    NbreEnnemis1=6
    NbreEnnemis2=6
    NbreEnnemis3=6
    PasAvancement=0
    NbreEnnemis=[NbreEnnemis1,NbreEnnemis2,NbreEnnemis3]
    
    v=0

    BonusActif=0
    dxeb=5
    EnnemiBonus=[]

    Creation_Abris()
    Creation_CanonMobile()

    # On détermine de manière aléatoire
    # le nombre de temps avant qu'apparaisse
    # le premier ennemi bonus du jeu :)
    
    fen.after(randrange(60000,100000,100),CreationEnnemiBonus)


    AffichageScore.configure(text="Score : "+str(Score),font=('Fixedsys',16))
    AffichageVie.configure(text="Lives : "+str(ViesJoueur),font=('Fixedsys',16))
    

    # Appel des fonctions de création des ennemis
    # pour recréer un bataillon de vaisseaux hostiles
    # prêts à en découdre à nouveau avec le joueur !!
    
    while v<6:
        Ennemi_Categorie1()
        Ennemi_Categorie2()
        Ennemi_Categorie3()
        v+=1

    flag=1
   
        
# Cette fonction permet de créer les abris
# assurant la défense en papier du canon mobile XD

def Creation_Abris():
    global ListeAbris,CoordonneesBriques

    ListeAbris=[]
    CoordonneesBriques=[]

    i=0

    x=40
    y=340

    while i<3:
        limX=x+120
        limY=y+60
        departx=x
        while y<limY:
            while x<limX:
                ListeAbris.append(can.create_rectangle(x,y,x+20,y+20,fill='grey'))
                CoordonneesBriques.append([x,y])
                x+=20
            x=departx
            y+=20
        i+=1
        x+=220
        y-=60

# Cette fonction permet de créer le nerf de la guerre
# ==> Le canon mobile \o/

def Creation_CanonMobile():
    global canon,xc1,xc2,yc1,yc2
    canon=[]

    xc1=20
    yc1=440

    # Création du canon

    canon.append(can.create_rectangle(xc1,yc1,xc1+20,yc1+20,fill='green'))

    xc2=xc1-20
    yc2=yc1+20

    # Création de la plate-forme du canon

    canon.append(can.create_rectangle(xc2,yc2,xc2+60,yc2+20,fill='green'))
    
    

# Les 3 fonctions ci-dessous vont permettre de créer les ennemis du jeu

# Création de la 1er catégorie d'ennemis du jeu

def Ennemi_Categorie1():
    global ListeEnnemis,ListeCoordEnnemis,xe,ye
    ListeCoordEnnemis[0].append([xe,ye])
    Ennemis=[]
    Ennemis.append(can.create_rectangle(xe,ye,xe+60,ye+20,fill='blue'))
    Ennemis.append(can.create_rectangle(xe,ye,xe+20,ye+40,fill='blue'))
    Ennemis.append(can.create_rectangle(xe+40,ye,xe+60,ye+40,fill='blue'))
    ListeEnnemis[0].append(Ennemis)
    xe=xe+80

# Création de la 2e catégorie d'ennemis du jeu

def Ennemi_Categorie2():
    global ListeEnnemis,ListeCoordEnnemis,xe2,ye2
    ListeCoordEnnemis[1].append([xe2,ye2])
    Ennemis=[]
    Ennemis.append(can.create_rectangle(xe2,ye2,xe2+20,ye2+40,fill='violet'))
    Ennemis.append(can.create_rectangle(xe2+40,ye2,xe2+60,ye2+40,fill='violet'))
    Ennemis.append(can.create_rectangle(xe2+20,ye2+20,xe2+40,ye2+60,fill='violet'))
    ListeEnnemis[1].append(Ennemis)
    xe2=xe2+80

# Création de la 3e catégorie d'ennemis du jeu

def Ennemi_Categorie3():
    global ListeEnnemis,ListeCoordEnnemis,xe3,ye3
    ListeCoordEnnemis[2].append([xe3,ye3])
    Ennemis=[]
    Ennemis.append(can.create_rectangle(xe3+20,ye3,xe3+40,ye3+60,fill='brown'))
    Ennemis.append(can.create_rectangle(xe3,ye3+20,xe3+60,ye3+40,fill='brown'))
    ListeEnnemis[2].append(Ennemis)
    xe3=xe3+80

# Cette fonction va permettre de créer
# l'ennemi bonus du jeu

def CreationEnnemiBonus():
    global EnnemiBonus,xeb,yeb,BonusActif,DebutJeu,CoordEnnemiBonus,dxeb,flag

    if flag!=0:
        if BonusActif!=1:
            BonusActif=1
            dxeb=5
            hasard=randrange(0,10,1)
            if hasard>=5:
                xeb=0
                dxeb=dxeb
            else:
                xeb=630
                dxeb=-dxeb
            yeb=randrange(80,400,10)
            EnnemiBonus.append(can.create_oval(xeb,yeb,xeb+35,yeb+15,fill='red'))
            EnnemiBonus.append(can.create_oval(xeb+5,yeb+5,xeb+10,yeb+10,fill='yellow'))
            EnnemiBonus.append(can.create_oval(xeb+15,yeb+5,xeb+20,yeb+10,fill='yellow'))
            EnnemiBonus.append(can.create_oval(xeb+25,yeb+5,xeb+30,yeb+10,fill='yellow'))
    
        

# Cette fonction va permettre d'animer
# le mouvement de l'ennemi bonus

def AnimationEnnemiBonus():
    global EnnemiBonus,xeb,yeb,dxeb,xtir,ytir,DebutJeu,BonusActif,projectile,flag,feu,Score

    if flag!=0 and DebutJeu!=0 and BonusActif!=0 :


        # Si l'ennemi bonus atteint l'autre bout de l'écran
        # il s'auto-détruit !! XD

        if dxeb>0:
            if xeb>=640:
                BonusActif=0
                can.delete(EnnemiBonus[0])
                can.delete(EnnemiBonus[1])
                can.delete(EnnemiBonus[2])
                can.delete(EnnemiBonus[3])
                xeb=0
                yeb=0
                EnnemiBonus=[]

                # Détermination aléatoire du temps d'appel
                # de la fonction qui va permettre de procéder
                # à la création d'un nouvel ennemi bonus
                
                fen.after(randrange(60000,100000,100),CreationEnnemiBonus)
        else:
            if xeb<=20:
                BonusActif=0
                can.delete(EnnemiBonus[0])
                can.delete(EnnemiBonus[1])
                can.delete(EnnemiBonus[2])
                can.delete(EnnemiBonus[3])
                xeb=0
                yeb=0
                EnnemiBonus=[]
                fen.after(randrange(60000,100000,100),CreationEnnemiBonus)
                

        # On fait l'ennemi bonus avancer
                
        xeb=xeb+dxeb

        if len(EnnemiBonus)!=0:
            can.coords(EnnemiBonus[0],xeb,yeb,xeb+35,yeb+15)
            can.coords(EnnemiBonus[1],xeb+5,yeb+5,xeb+10,yeb+10)
            can.coords(EnnemiBonus[2],xeb+15,yeb+5,xeb+20,yeb+10)
            can.coords(EnnemiBonus[3],xeb+25,yeb+5,xeb+30,yeb+10)

        # On vérifie si l'obus tiré par le joueur
        # touche l'ennemi bonus si tel est le cas
        # l'ennemi bonus est détruit et on l'efface
        # de l'ecran pour faire le joueur empocher 300 pts !!

        if feu!=0:
            if ytir<=yeb and ytir>=yeb-25:
                if xtir>=xeb-10 and xtir<=xeb+40:
                    BonusActif=0

                    # On efface l'ennemi bonus
                    # ainsi que l'obus qui l'a touché

                    if len(projectile)!=0:
                        can.delete(projectile[0])
                    can.delete(EnnemiBonus[0])
                    can.delete(EnnemiBonus[1])
                    can.delete(EnnemiBonus[2])
                    can.delete(EnnemiBonus[3])

                    # On utlise la fonction score afin
                    # d'afficher le nombre de points gagnés
                    # à la suite de la destruction de
                    # l'ennemi bonus
                    
                    score(300,xeb,yeb,17.5,7.5)

                    # Gain de points ==> Modification du score du joueur
                    
                    Score+=300
                    AffichageScore.configure(text="Score : "+str(Score),font=('Fixedsys',16))

                    # On remet les coordonnées de l'ennemi
                    # bonus à zéro pour n'engendrer aucune
                    # erreur
                    
                    xeb,yeb=0,0
                    xtir,ytir=0,0

                    # On désactive l'animation de l'obus
                    # tiré par le joueur

                    feu=0

                    EnnemiBonus=[]

                    fen.after(randrange(15000,25000,100),CreationEnnemiBonus)
                
        # On reboucle le tout
        
        fen.after(50,AnimationEnnemiBonus)
    else:
        fen.after(50,AnimationEnnemiBonus)

# Cette fonction permet d'afficher
# le nombre de points gagnés à la suite
# de la destruction d'un ennemi

def score(donnee,x,y,x2,y2):
    global afficherScore
    afficherScore.append(can.create_text(x+x2,y+y2,font=('Fixedsys',8),text=str(donnee)+' pts',fill='red'))
    fen.after(1500,EffacerScore)

# Cette fonction permet d'effacer
# le nombre de point gagnés et affichés
# suite à la destruction d'un ennemi

def EffacerScore():
    global afficherScore
    i=0
    while i<len(afficherScore):
        can.delete(afficherScore[i])
        i+=1

# La fonction ci-dessous permet
# d'animer le canon mobile selon
# la direction choisie par le joueur

def move(dx):
    global xc1,xc2,yc1,yc2,ViesJoueur,flag

    if ViesJoueur!=0 or flag!=0:
   
        xc1=xc1+dx
        xc2=xc2+dx

        # Si on arrive au bord de l'écran
        # le canon mobile se retrouve bloqué
        # afin de ne pas aller plus loin :p
        
        if xc2<=0:
            xc1=20
            xc2=0
            can.coords(canon[0],xc1,yc1,xc1+20,yc1+20)
            can.coords(canon[1],xc2,yc2,xc2+60,yc2+20)
        elif xc2>=600:
            xc1=600
            xc2=580
            can.coords(canon[0],xc1,yc1,xc1+20,yc1+20)
            can.coords(canon[1],xc2,yc2,xc2+60,yc2+20)
        else:
            can.coords(canon[0],xc1,yc1,xc1+20,yc1+20)
            can.coords(canon[1],xc2,yc2,xc2+60,yc2+20)

# Cette fonction va s'occuper de faire les ennemis se déplacer
# automatiquement dans le canevas histoire qu'ils puissent esquiver
# les tirs du joueur ( un genre d'IA à deux balles quoi !! XD )

def ennemis():
    global dx,feuEnnemi,NbreEnnemis,Xobus,Yobus,ListeCoordEnnemis,DebutJeu,NbreEnRangees
    global ListeEnnemis,PasAvancement,NbreEnnemis,flag,LimiteAvancement,BonusActif,PasMax

    if flag!=0 and len(NbreEnnemis)>=1 and DebutJeu!=0:

        # Si tous les ennemis ont été détruits
        # ce n'est pas la peine d'exécuter l'animation
        # de quelque chose qui n'existe plus :p

        if NbreEnnemis!=0:
            i=0
            t=0
            PasAvancement+=1

            # On active le système de tir des méchants :p
            # ==> Armement des canons ==> Prêt à détruire l'ennemi ( le joueur )
            # Yes sir !! XD

            tir_ennemi()

            # Si jamais les ennemis atteignent le bas
            # de l'écran la partie s'arrête et le joueur
            # a perdu !! :p
           
            while i<len(ListeCoordEnnemis):
                while t<len(ListeCoordEnnemis[i]):
                    if ListeCoordEnnemis[i][t][1]>=420:
                        can.delete(ALL)
                        image()
                        flag=0
                        can.create_text(320,240,font=('Fixedsys',18),text="Game Over !!",fill='red')
                        feu=0
                        ArretAnimation=0
                        can.delete(canon[0])
                        can.delete(canon[1])
                        DebutJeu=0
                        SaveMeilleurScore(Score)
                        xc1,yc1=0,0
                        xc2,yc2=0,0
                    t+=1
                t=0
                i+=1

            i=0

            # Si les ennemis arrive au bout de l'écran
            # leur direction s'inverse et ils vont
            # dans le sens opposé

            dy=0
            

            if dx>0:

                # On va utiliser cette 2e variable afin
                # de s'assurer de l'inversion de la direction
                # des ennemis
                
                dx2=dx
                if len(ListeCoordEnnemis[0])!=0:
                    if ListeCoordEnnemis[0][len(ListeCoordEnnemis[0])-1][0]>=560:
                        dx=-dx2
                        dy=10
                if len(ListeCoordEnnemis[1])!=0:
                    if ListeCoordEnnemis[1][len(ListeCoordEnnemis[1])-1][0]>=560:
                        dx=-dx2
                        dy=10
                if len(ListeCoordEnnemis[2])!=0:
                    if ListeCoordEnnemis[2][len(ListeCoordEnnemis[2])-1][0]>=560:
                        dx=-dx2
                        dy=10
            elif dx<0:
                dx2=dx
                if len(ListeCoordEnnemis[0])!=0:
                    if ListeCoordEnnemis[0][0][0]<=20:
                        dx=-dx2
                        dy=10
                if len(ListeCoordEnnemis[1])!=0:
                    if ListeCoordEnnemis[1][0][0]<=20:
                        dx=-dx2
                        dy=10
                if len(ListeCoordEnnemis[2])!=0:
                    if ListeCoordEnnemis[2][0][0]<=20:
                        dx=-dx2
                        dy=10

            i=0
            t=0

            # On fait avancer tous les ennemis
            # du canevas
            
            while i<len(ListeCoordEnnemis):
                while t<len(ListeCoordEnnemis[i]):
                    ListeCoordEnnemis[i][t][0]=ListeCoordEnnemis[i][t][0]+dx
                    ListeCoordEnnemis[i][t][1]=ListeCoordEnnemis[i][t][1]+dy
                    t+=1
                i+=1
                t=0
            i=0
            while i<NbreEnnemis[0]:
                can.coords(ListeEnnemis[0][i][0],ListeCoordEnnemis[0][i][0],ListeCoordEnnemis[0][i][1],ListeCoordEnnemis[0][i][0]+60,ListeCoordEnnemis[0][i][1]+20)
                can.coords(ListeEnnemis[0][i][1],ListeCoordEnnemis[0][i][0],ListeCoordEnnemis[0][i][1],ListeCoordEnnemis[0][i][0]+20,ListeCoordEnnemis[0][i][1]+40)
                can.coords(ListeEnnemis[0][i][2],ListeCoordEnnemis[0][i][0]+40,ListeCoordEnnemis[0][i][1],ListeCoordEnnemis[0][i][0]+60,ListeCoordEnnemis[0][i][1]+40)
                i+=1
            i=0
            while i<NbreEnnemis[1]: 
                can.coords(ListeEnnemis[1][i][0],ListeCoordEnnemis[1][i][0],ListeCoordEnnemis[1][i][1],ListeCoordEnnemis[1][i][0]+20,ListeCoordEnnemis[1][i][1]+40)
                can.coords(ListeEnnemis[1][i][1],ListeCoordEnnemis[1][i][0]+40,ListeCoordEnnemis[1][i][1],ListeCoordEnnemis[1][i][0]+60,ListeCoordEnnemis[1][i][1]+40)
                can.coords(ListeEnnemis[1][i][2],ListeCoordEnnemis[1][i][0]+20,ListeCoordEnnemis[1][i][1]+20,ListeCoordEnnemis[1][i][0]+40,ListeCoordEnnemis[1][i][1]+60)
                i+=1
            i=0
            while i<NbreEnnemis[2]:
                can.coords(ListeEnnemis[2][i][0],ListeCoordEnnemis[2][i][0]+20,ListeCoordEnnemis[2][i][1],ListeCoordEnnemis[2][i][0]+40,ListeCoordEnnemis[2][i][1]+60)
                can.coords(ListeEnnemis[2][i][1],ListeCoordEnnemis[2][i][0],ListeCoordEnnemis[2][i][1]+20,ListeCoordEnnemis[2][i][0]+60,ListeCoordEnnemis[2][i][1]+40)
                i+=1
            fen.after(50,ennemis)
    else:
        fen.after(50,ennemis)



# Cette fonction gère le tir des ennemis
# et vérifie si un a atteint le canon
# mobile du joueur

def tir_ennemi():
    global feuEnnemi,Xobus,Yobus,ObusEnnemi,ListeCoordEnnemis,EnnemiChoisi,ChoixTireur,NbreEnnemis,flag,DebutJeu
    if flag!=0:
        if DebutJeu!=0:
            if feuEnnemi!=1 :
                feuEnnemi=1
                ObusEnnemi=[]
                i=0
                while i<len(EnnemiChoisi):
                    if EnnemiChoisi[i]==0:
                        del EnnemiChoisi[i]
                    i+=1
                    
                if len(EnnemiChoisi)==1:
                    Choix=0
                else:
                    Choix=randrange(0,len(EnnemiChoisi),1)

                # En fonction de la catégorie d'ennemis choisie
                # les coordonnées d'un obus tiré ne seront pas
                # les mêmes pour tout le monde

                if len(ObusEnnemi)!=1:
                    if Choix==0:
                        if NbreEnnemis[0]!=0:

                            # La portion de code ci-dessous va permettre aux
                            # ennemis de choisir le canon avec lequel ils vont
                            # canarder le joueur et ses défenses

                            CanonChoisi=randrange(0,3,1)
                            
                            ChoixTireur=[]
                            ChoixTireur.append([ListeCoordEnnemis[0][randrange(0,NbreEnnemis[0],1)][0],ListeCoordEnnemis[0][randrange(0,NbreEnnemis[0],1)][1]])
                            Xobus=ChoixTireur[0][0]+9
                            Yobus=ChoixTireur[0][1]+40
                            
                            if CanonChoisi==1:
                                ObusEnnemi.append(can.create_rectangle(Xobus,Yobus,Xobus+2,Yobus+40,fill='orange'))
                            else:
                                Xobus=Xobus+40
                                ObusEnnemi.append(can.create_rectangle(Xobus,Yobus,Xobus+2,Yobus+40,fill='orange'))

                    elif Choix==1:
                        if NbreEnnemis[1]!=0:
                    
                            ChoixTireur=[]
                            ChoixTireur.append([ListeCoordEnnemis[1][randrange(0,NbreEnnemis[1],1)][0],ListeCoordEnnemis[1][randrange(0,NbreEnnemis[1],1)][1]])
                            Xobus=ChoixTireur[0][0]+29
                            Yobus=ChoixTireur[0][1]+60
                        
                            ObusEnnemi.append(can.create_rectangle(Xobus,Yobus,Xobus+2,Yobus+40,fill='orange'))

                    elif Choix==2:
                        if NbreEnnemis[2]!=0:
                        
                            ChoixTireur=[]
                            ChoixTireur.append([ListeCoordEnnemis[2][randrange(0,NbreEnnemis[2],1)][0],ListeCoordEnnemis[2][randrange(0,NbreEnnemis[2],1)][1]])
                            Xobus=ChoixTireur[0][0]+29
                            Yobus=ChoixTireur[0][1]+60
                            
                            
                            ObusEnnemi.append(can.create_rectangle(Xobus,Yobus,Xobus+2,Yobus+40,fill='orange'))

                    # On démarre l'animation de l'obus
                    # tiré par un des ennemis
                       
                    AnimationObusEnnemi()
        

# Cette fonction permet d'animer l'obus tiré
# par un ennemi

def AnimationObusEnnemi():
    global xe,ye,dyobusEnnemi,Yobus,Xobus,ObusEnnemi,feuEnnemi,xc1,xc2,yc1,yc2,feu,ViesJoueur
    global PartieFinie,flag,projectile,DebutJeu,Score,Mort,ArretAnimation,canon
    if flag!=0:
        if feuEnnemi==1:
            Yobus=Yobus+dyobusEnnemi
            abri()
                                
            if Yobus>=480:
                if len(ObusEnnemi)==1:
                        can.delete(ObusEnnemi[0])
                feuEnnemi=0