from tkinter import *
import os
import random
import sys


def achat_nouriture (nb_conserve) :
    global nouriture
    global argent
    if nb_conserve*10 <= argent :
        for c in range(nb_conserve) :
            nouriture += 20
            argent -= 10

def achat_aquarium (nb_aquariums, aquariums) :
    global argent
    if nb_aquariums*30 <= argent :
        for a in range(nb_aquariums) :
            argent -= 30
            aquarium.pop_max += 20

def efface_ecran () :
    if sys.platform.startswith("win") :
        os.system("cls")
    else :
        os.system("clear")


class Poisson :


    def __init__ (self):
        self.age = 0
        self.sexe = random.randint(1,2)
        self.capacite_reproduction = 0
        self.besoin_nourriture = 1
        self.vie = 1

    def temps (self):
        self.age += 1
        if self.age > 6 or self.besoin_nourriture == 1:
            global nb_poisson_m
            nb_poisson_m += 0
            self.vie = 0
        self.capacite_reproduction = 1
        self.besoin_nourriture = 1

    def reproduction (self):
        self.capacite_reproduction = 0

    def repas (self) :
        self.besoin_nourriture = 0



class Aquarium :


    def __init__ (self ):
        self.pop = []
        self.pop_max = 20
        poisson = Poisson()
        poisson.sexe = 1
        self.nouveau_poisson(poisson)
        poisson = Poisson()
        poisson.sexe = 2
        self.nouveau_poisson(poisson)

    def reproduction (self ):
        print("1")
        nb_p_m_adulte = 0
        nb_p_f_adulte = 0
        for poisson in self.pop :
            if poisson.age > 0 and poisson.sexe == 1:
                nb_p_m_adulte += 1
            if poisson.age > 0 and poisson.sexe == 2:
                nb_p_f_adulte += 1
        if nb_p_m_adulte > nb_p_f_adulte :
            nb_couple = nb_p_f_adulte
        else :
            nb_couple = nb_p_m_adulte
        for i in range(nb_couple) :
            nb_enfant = random.randint(5,10)
            for i in range(nb_enfant) :
                poisson = Poisson()
                self.nouveau_poisson(poisson)

    def vente (self, nb_poissons ) :
        poisson_mature = 0
        for poisson in self.pop :
            if poisson.age > 0 :
                poisson_mature += 1
        if poisson_mature < nb_poissons :
            nb_poissons = poisson_mature
        global argent
        for p in range(nb_poissons) :
            argent += 1.5
            del self.pop[1]

    def repas (self) :
        global nouriture
        for poisson in self.pop :
            if nouriture > 0 :
                nouriture -= 1
                poisson.repas()
            else :
                global nb_poisson_m
                nb_poisson_m += 1

    def nouveau_poisson (self , poisson):
        if len(self.pop) < self.pop_max :
            self.pop.append(poisson)
        else :
            global nb_poisson_m
            nb_poisson_m += 1

    def temps (self ) :
        for poisson in self.pop :
            poisson.temps()
            if poisson.vie == 0 :
                self.pop = [poisson for poisson in self.pop if poisson.vie]



argent = 200
nouriture = 20
nb_conseil = 0
aquarium = Aquarium()
nb_poisson_m = 0

def validation () :
    global texte_aquarium
    global texte_conserve
    global texte_poisson
    global texte_conseil
    global texte
    global argent
    global nb_conseil
    global nb_poisson_m
    poissons = len(aquarium.pop)
    try :
        nb_aquariums = int(texte_aquarium.get())
    except ValueError :
        nb_aquariums = 0
    try :
        nb_conserves = int(texte_conserve.get())
    except ValueError :
        nb_conserves = 0
    try :
        nb_poissons = int(texte_poisson.get())
    except ValueError :
        nb_poissons = 0
    try :
        nb_conseils = int(texte_poisson.get())
    except ValueError :
        nb_conseils = 0
    if nb_conseils*20 < argent :
        nb_conseil += nb_conseils
        argent -= 20*nb_conseils
    if nb_aquariums > 0 :
        achat_aquarium (nb_aquariums, aquarium)
    if nb_conserves > 0 :
        achat_nouriture (nb_conserves)
    if nb_poissons > 0 :
        aquarium.vente(nb_poissons)
    if argent < 0  or aquarium.pop == 0 :
        print ("Perdu")
        os.system("pause")
    efface_ecran()
    nb_poisson_m = 0
    aquarium.repas()
    aquarium.temps()
    aquarium.reproduction()
    texte_aquarium.set("Combiens d'aquariums voulez-vous acheter")
    texte_conserve.set("Combiens de conserve voulez-vous acheter")
    texte_poisson.set("Combiens de poissons voulez-vous vendre")
    texte_conseil.set("Combiens de conseils voulez-vous acheter")
    texte.set("{} poissons sont morts le mois dernier.\n \nVous possédez :\n  -{} $\n  -{} poissons\n  -{} aquariums\n  -{} rations de nouritures\n  -{} conseils".format(nb_poisson_m, argent, poissons, int(aquarium.pop_max / 20), nouriture, nb_conseil))
    
    

fenetre = Tk()
fenetre.title("Elevage de gupies")
fenetre.geometry("300x350+500+250")
fenetre["bg"] = "blue"

texte = StringVar()
poissons = len(aquarium.pop)
texte.set("{} poissons sont morts le mois dernier.\n \nVous possédez :\n  -{} $\n  -{} poissons\n  -{} aquariums\n  -{} rations de nouritures\n  -{} conseils".format(nb_poisson_m, argent, poissons, int(aquarium.pop_max / 20), nouriture, nb_conseil))
message_donnees = Label(fenetre, textvariable=texte, justify="left")
message_donnees.place(x=0, y=0)
message_donnees.pack()


texte_aquarium = StringVar()
texte_aquarium.set("Combiens d'aquariums voulez-vous acheter")
question_aquarium = Entry(fenetre, textvariable=texte_aquarium, width=40)
question_aquarium.focus_set()
question_aquarium.pack(padx = 5, pady = 5)

texte_conserve = StringVar()
texte_conserve.set("Combiens de conserve voulez-vous acheter")
question_conserve = Entry(fenetre, textvariable=texte_conserve, width=40)
question_conserve.focus_set()
question_conserve.pack(padx = 5, pady = 5)
    
texte_poisson = StringVar()
texte_poisson.set("Combiens de poissons voulez-vous vendre")
question_poisson = Entry(fenetre, textvariable=texte_poisson, width=40)
question_poisson.focus_set()
question_poisson.pack(padx = 5, pady = 5)

texte_conseil = StringVar()
texte_conseil.set("Combiens de conseils voulez-vous acheter")
question_conseil = Entry(fenetre, textvariable=texte_conseil, width=40)
question_conseil.focus_set()
question_conseil.pack(padx = 5, pady = 5)

boutton_valider = Button(fenetre, text="Valider", fg="blue", command = validation)
boutton_valider.pack(side="left")
    
boutton_quitter = Button(fenetre, text="Quitter", fg="red", command=fenetre.quit)
boutton_quitter.pack(side="right")
    
fenetre.mainloop()

verification_deplacement(robot.position[0], robot.position[1]-1)
verification_deplacement(robot.position[0], robot.position[1]+1)
verification_deplacement(robot.position[0]-1, robot.position[1])
verification_deplacement(robot.position[0]+1, robot.position[1])

elif lab[pos_ligne][pos_col] == "1" or lab[pos_ligne][pos_col] == "2" or lab[pos_ligne][pos_col] == "3" :

def enregistrement (self) :
        global robot
        choix_enregistrement = input("Voulez-vous enregistrer la partie?")
        if choix_enregistrement.upper() == "O" :
            data = str("{} {} {} {} {}".format(robot.position[0], robot.position[1], self.niveau[5], robot.vie, robot.argent))
            with open("enregistrement.txt", "w") as fichier :
                mon_depickler = pickle.Pickler(fichier)
                mon_depickler.dump(data)

TypeError: write() argument must be str, not bytes