コード例 #1
0
 public override void ExecuteFourmi(Fourmi destFourmi)
 {
     if (destFourmi.Comportement.ToString().Equals("AttitudeEnnemi"))
     {
         destFourmi.Vie = 0;
     }
 }
コード例 #2
0
        /// <summary>
        /// Actualise les informations de la fourmi
        /// </summary>
        /// <param name="perso"></param>
        public void Actualise(PersonnageAbstrait perso)
        {
            Fourmi = (Fourmi)perso;
            Vie    = Fourmi.Vie;
            Nom    = Fourmi.Nom;

            System.Diagnostics.Debug.WriteLine("Fourmi n° " + Nom + " a " + Vie + " points de vie");
        }
コード例 #3
0
        public override List <Evenement> executer(PersonnageAbstrait personnage, EnvironnementAbstrait env)
        {
            List <Evenement>          evenements  = comportement.executer(personnage, env);
            ZoneAbstraite             newPosition = personnage.position;
            List <PersonnageAbstrait> listeFourmi = newPosition.ListeFourmiAlentours(env);

            foreach (PersonnageAbstrait f in listeFourmi)
            {
                Fourmi fourmi = (Fourmi)f;
                f.pointDeVie++;
            }
            return(evenements);
        }
コード例 #4
0
        private void Start(object sender, RoutedEventArgs e)
        {
            simulateur = SimulateurFourmi.GetInstance();
            var zone   = simulateur.FabriqueZone.Creer();
            var midPos = GetMidPosition(zone);

            reine = simulateur.FabriqueFourmi.Creer(zone, midPos);
            reine.Comportement = new ComportementReine(reine);
            reine.AttacherObs(simulateur);
            RenderTerrain(Terrain, zone.LimitX, zone.LimitY);

            Dessine(zone.LimitX / 2, zone.LimitY / 2, "Content/fourmiRNRN.jpg");
        }
コード例 #5
0
 private void plus(object sender, RoutedEventArgs e)
 {
     if (reine != null)
     {
         fourmi = reine.Comportement.Cast <ComportementReine>().CreerFourmi();
         fourmi.AttacherObs(simulateur);
         fourmi.Position.X = 20 / 2;
         fourmi.Position.Y = 20 / 2 + 1;
         fourmiList.Add(fourmi);
         //if (fourmi.Etat == Oeuf)
         //{
         Dessine(fourmi.Position.X, fourmi.Position.Y, "Content/oeuf.jpg");
         //}
         //Dessine(fourmi.Position.X+1, fourmi.Position.Y+1, "Content/fourmiRN.jpg");
     }
 }
コード例 #6
0
ファイル: Program.cs プロジェクト: ellylldhan/eni-17-asp-net
        static void Main(string[] args)
        {
            Console.WriteLine("M02 D04 - Les Génériques");
            Fourmi fourmi = new Fourmi();
            Fruit  fruit  = new Fruit {
                DateCueillette = DateTime.Now.AddDays(-5)
            };

            Zoo.NourrirAnimal(fourmi, fruit);

            Chat chat = new Chat();
            Pate pate = new Pate {
                DatePeremption = DateTime.Now.AddYears(1)
            };

            Zoo.NourrirAnimal(chat, pate);

            //Console.ReadKey();
        }
コード例 #7
0
        public static void Main(string[] args)
        {
            Fourmi fourmi1 = new Fourmi();
            Fruit  fruit1  = new Fruit()
            {
                DateCueilette = DateTime.Now.AddDays(-5)
            };

            Console.WriteLine($"La fourmi mange un fruit {Zoo.NourrirAnimal(fourmi1, fruit1)}");

            Fruit fruit2 = new Fruit()
            {
                DateCueilette = DateTime.Now.AddDays(-12)
            };

            Console.WriteLine($"La fourmi mange un fruit {Zoo.NourrirAnimal(fourmi1, fruit2)}");

            Pate pate1 = new Pate()
            {
                DatePeremption = DateTime.Now.AddDays(1)
            };
            Pate pate2 = new Pate()
            {
                DatePeremption = DateTime.Now.AddDays(-1)
            };

            //Console.WriteLine($"La fourmi mange un fruit {Zoo.NourrirAnimal(fourmi1, pate1)}");

            Chat chat1 = new Chat();

            Console.WriteLine($"Le chat mange de la paté {Zoo.NourrirAnimal(chat1, pate1)}");
            Console.WriteLine($"Le chat mange de la paté {Zoo.NourrirAnimal(chat1, pate2)}");

            GenericTest <Chat> .ListElements();

            Console.ReadLine();
        }
コード例 #8
0
        private void OuvrirFichier()
        {
            App.MainVM.stop();
            while (App.MainVM.Runnin)
            {
            }

            OpenFileDialog OFDialog = new OpenFileDialog();

            OFDialog.InitialDirectory = Convert.ToString(Environment.SpecialFolder.MyDocuments);
            OFDialog.DefaultExt       = "xml";
            OFDialog.Filter           = "XML Files|*.xml|All Files|*.*";
            OFDialog.FilterIndex      = 1;
            if (OFDialog.ShowDialog() == true && OFDialog.FileName.Length > 0)
            {
                // CHARGER LE FICHIER ET VERIFIER SA VALIDITE
                XmlDocument Chargement = new XmlDocument();
                Chargement.Load(OFDialog.FileName);
                XmlNode MainVMXML;
                if ((MainVMXML = Chargement.SelectSingleNode("MainVM")) == null)
                {
                    System.Media.SystemSounds.Beep.Play();
                    MessageBox.Show("Fichier incompatible !", "Chargement", MessageBoxButton.OK);
                    return;
                }

                // RECUPERER DATA DE MAINVM
                int    Dim = int.Parse(MainVMXML.SelectSingleNode("Dim").InnerText);
                String TitreApplication = MainVMXML.SelectSingleNode("TitreApplication").InnerText;
                int    VitesseExec      = int.Parse(MainVMXML.SelectSingleNode("VitesseExec").InnerText);
                bool   Runnin           = bool.Parse(MainVMXML.SelectSingleNode("Runnin").InnerText);

                Terrain Terrain = new Terrain(Dim);

                // RECUPERER DATA DE TERRAIN
                XmlNode TerrainXML     = MainVMXML.SelectSingleNode("Terrain");
                int     NbToursTerrain = int.Parse(TerrainXML.SelectSingleNode("NbTours").InnerText);
                XmlNode CasesXML       = TerrainXML.SelectSingleNode("Cases");
                foreach (XmlNode CaseXML in CasesXML.SelectNodes("Case"))
                {
                    CaseAbstrait Case;
                    String       CaseClass           = CaseXML.SelectSingleNode("Class").InnerText;
                    int          CordX               = int.Parse(CaseXML.SelectSingleNode("CordX").InnerText);
                    int          CordY               = int.Parse(CaseXML.SelectSingleNode("CordY").InnerText);
                    int          PheromoneMaison     = int.Parse(CaseXML.SelectSingleNode("PheromoneMaison").InnerText);
                    int          PheromoneNourriture = int.Parse(CaseXML.SelectSingleNode("PheromoneNourriture").InnerText);
                    int          NbToursCase         = int.Parse(CaseXML.SelectSingleNode("NbTours").InnerText);

                    if (CaseClass == "CaseNourriture")
                    {
                        Case = new CaseNourriture(Terrain, CordX, CordY);
                        int        NourriturePoids = int.Parse(CaseXML.SelectSingleNode("Nourriture/Poids").InnerText);
                        Nourriture Nourriture      = new Nourriture(Case, NourriturePoids);
                        ((CaseNourriture)Case).Nourriture = Nourriture;
                    }
                    else if (CaseClass == "CaseFourmiliere")
                    {
                        Case = new CaseFourmiliere(Terrain, CordX, CordY);
                        int         NombreNourritures      = int.Parse(CaseXML.SelectSingleNode("Fourmiliere/NombreNourritures").InnerText);
                        int         NombreToursFourmiliere = int.Parse(CaseXML.SelectSingleNode("Fourmiliere/NombreTours").InnerText);
                        Fourmiliere Fourmiliere            = new Fourmiliere(Case, 0);
                        Fourmiliere.NombreNourritures       = NombreNourritures;
                        Fourmiliere.NombreTours             = NombreToursFourmiliere;
                        ((CaseFourmiliere)Case).Fourmiliere = Fourmiliere;
                    }
                    else if (CaseClass == "CaseNormal")
                    {
                        Case = new CaseNormal(Terrain, CordX, CordY);
                    }
                    else
                    {
                        System.Media.SystemSounds.Beep.Play();
                        MessageBox.Show("Erreur au chargement", "Chargement", MessageBoxButton.OK);
                        return;
                    }
                    Case.PheromoneMaison     = PheromoneMaison;
                    Case.PheromoneNourriture = PheromoneNourriture;
                    Case.NbTours             = NbToursCase;

                    XmlNode FourmisXML = CaseXML.SelectSingleNode("Fourmis");
                    foreach (XmlNode FourmiXML in FourmisXML.SelectNodes("Fourmi"))
                    {
                        int    Vie             = int.Parse(FourmiXML.SelectSingleNode("Vie").InnerText);
                        String StrategieFourmi = FourmiXML.SelectSingleNode("StrategieFourmi").InnerText;
                        Fourmi Fourmi          = new Fourmi(Case);
                        Fourmi.Vie = Vie;
                        if (StrategieFourmi == "StrategieRetourMaison")
                        {
                            Fourmi.StrategieFourmi = new StrategieRetourMaison();
                        }
                        Case.Fourmis.Add(Fourmi);
                    }
                    Terrain.Cases[Case.CordX, Case.CordY] = Case;
                }
                Terrain.NbTours = NbToursTerrain;

                XmlNode StatistiqueXML         = MainVMXML.SelectSingleNode("Statistique");
                int     NombreFourmis          = int.Parse(StatistiqueXML.SelectSingleNode("NombreFourmis").InnerText);
                int     NombreToursStatistique = int.Parse(StatistiqueXML.SelectSingleNode("NombreTours").InnerText);

                Statistique Statistique = new Statistique(Terrain);
                Statistique.NombreFourmis = NombreFourmis;
                Statistique.NombreTours   = NombreToursStatistique;

                App.MainVM.Dim              = Dim;
                App.MainVM.Terrain          = Terrain;
                App.MainVM.TitreApplication = TitreApplication;
                App.MainVM.VitesseExec      = VitesseExec;
                App.MainVM.Statistique      = Statistique;
                DessinePlateau();
                System.Media.SystemSounds.Beep.Play();
                MessageBox.Show("Fichier Chargé !", "Chargement", MessageBoxButton.OK);
            }
        }
コード例 #9
0
ファイル: Fourmiliere.cs プロジェクト: rogerwilko/sma
        // tue une fourmi
        public void KillFourmi(Fourmi f)
        {
            int type = f.Type;

            switch (type)
            {
                case TYPE_CHASSEUSE:
                    _nbrChasseuses--;
                    break;

                case TYPE_NOURRICE:
                    _nbrNourrices--;
                    break;

                case TYPE_OUVRIERE:
                    _nbrOuvrieres--;
                    break;
            }

            _listFourmis.Remove(f);
        }
コード例 #10
0
        public override List <Evenement> executer(PersonnageAbstrait personnage, EnvironnementAbstrait env)
        {
            List <Evenement> evenements = new List <Evenement>();

            if (((Fourmi)personnage).nourriturePortee == true)
            {
                personnage.comportement = new RentrerFourmiliere();
                return(evenements);
            }
            if (env.ZoneAbstraiteList[personnage.position.coordonnes.x].zoneAbstraiteList[personnage.position.coordonnes.y].containsObjet(typeof(Nourriture), env))
            {
                Console.WriteLine("out");
                if (personnage.GetType().BaseType == typeof(Fourmi))
                {
                    Fourmi f = (Fourmi)personnage;

                    f.nourriturePortee = true;
                    env.ZoneAbstraiteList[personnage.position.coordonnes.x].zoneAbstraiteList[personnage.position.coordonnes.y].getNourriture(env).valeurNutritive--;
                }
                if (env.ZoneAbstraiteList[personnage.position.coordonnes.x].zoneAbstraiteList[personnage.position.coordonnes.y].containsObjet(typeof(Nourriture), env))
                {
                    personnage.comportement = new RentrerFourmiliere();
                }
                else
                {
                    DecorateurSupprimerPheromone deco = new DecorateurSupprimerPheromone();
                    deco.ajouterComportement(new RentrerFourmiliere());
                    personnage.comportement = deco;
                }
                evenements.Add(new Evenement(personnage, (int)FourmiliereConstante.typeEvenement.passeLeTour));
            }

            else
            {
                ZoneAbstraite zone = env.ZoneAbstraiteList[personnage.position.coordonnes.x].zoneAbstraiteList[personnage.position.coordonnes.y];

                if (zone.getPheromone() != null && !zone.AccesAbstraitList[zone.getPheromone().direction]
                    .accesAbstrait.getFin(env).ZoneBloquee())
                {
                    personnage.Bouger(
                        zone.AccesAbstraitList[zone.getPheromone().direction]
                        .accesAbstrait.getFin(env));
                }
                else
                {
                    personnage.comportement = new DeplacementAleatoire();
                    personnage.comportement.executer(personnage, env);
                }
                if (zone.getPheromone() != null)
                {
                    switch (zone.getPheromone().direction)
                    {
                    case ((int)FourmiliereConstante.direction.bas):
                    {
                        evenements.Add(new Evenement(personnage, (int)FourmiliereConstante.typeEvenement.mouvementBas));
                        break;
                    }

                    case ((int)FourmiliereConstante.direction.haut):
                    {
                        evenements.Add(new Evenement(personnage, (int)FourmiliereConstante.typeEvenement.mouvementHaut));
                        break;
                    }

                    case ((int)FourmiliereConstante.direction.gauche):
                    {
                        evenements.Add(new Evenement(personnage, (int)FourmiliereConstante.typeEvenement.mouvementGauche));
                        break;
                    }

                    case ((int)FourmiliereConstante.direction.droite):
                    {
                        evenements.Add(new Evenement(personnage, (int)FourmiliereConstante.typeEvenement.mouvementDroit));
                        break;
                    }
                    }
                }
            }


            return(evenements);
        }
コード例 #11
0
ファイル: MainController.cs プロジェクト: rogerwilko/sma
        // Méthode principale
        public void Execute()
        {
            if (_view == null)
            {
                _view = new ViewSFML();
                _view.InitView(); // initialisation de la vue
            }

            _tourCourant = 0;
            _paused = false;
            _colored = false;

            // création et ajout de l'unique reine à la fourmilière
            Fourmiliere.Instance.Reine = (Queen)Fourmiliere.Instance.MakeFourmi(Fourmiliere.TYPE_QUEEN);

            Fourmiliere.Instance.MakeFourmi(Fourmiliere.TYPE_NOURRICE);

            Fourmiliere.Instance.StockNourriture = 5000; // nourriture de départ
            Fourmiliere.Instance.TotalNourriture = 0;

            Terrain.Instance.MakeTerrain(); // création du terrain

            _view.setFPS(_fps);

            ConfigController.Instance.ShowWin(); // fenêtre de configuration

            // tant que la vue est ouverte et qu'il y a des petites fourmis
            while (_view.IsRunning() /*&& Fourmiliere.Instance.NbrFourmis > 1*/)
            {
                if (!_paused)
                {
                    Console.WriteLine("\n*** JOUR " + _tourCourant + " ***\n");
                    Console.WriteLine("Nombre de fourmis : " + Fourmiliere.Instance.NbrFourmis);
                    Console.WriteLine("Nombre de fourmis chasseuses : " + Fourmiliere.Instance.NbrChasseuses);
                    Console.WriteLine("Nombre de fourmis ouvrières : " + Fourmiliere.Instance.NbrOuvrieres);
                    Console.WriteLine("Nombre de fourmis nourrices : " + Fourmiliere.Instance.NbrNourrices);
                    Console.WriteLine("Stocks de nourriture : " + Fourmiliere.Instance.StockNourriture);
                    Console.WriteLine("Nourriture totale consommée : " + Fourmiliere.Instance.TotalNourriture);

                    // on utilise une copie de la liste car elle peut être modifiée !
                    Fourmi[] list = new Fourmi[Fourmiliere.Instance.NbrFourmis];
                    Fourmiliere.Instance.ListFourmis.CopyTo(list);

                    // pour toutes les fourmis
                    foreach (Fourmi f in list)
                    {
                        f.VieMaVieDeFourmi(_tourCourant);
                    }

                    // reine

                    Fourmiliere.Instance.Reine.Pondre();
                    Fourmiliere.Instance.Reine.Pondre();

                    _tourCourant++;
                }

                _view.UpdateView(); // on met à jour la vue

                GC.Collect();
            }

            Console.WriteLine("\n\nGAME OVER...\n");

            //Console.ReadKey();
        }
コード例 #12
0
ファイル: Nourrice.cs プロジェクト: rogerwilko/sma
        // stratégie de marche sans larve : on marche normalement jusqu'à trouver une larve
        public void DeplacerNourriceSansLarve()
        {
            if (Etat == 0)
                return;

            DeplacerNormal();

            foreach(Fourmi f in Fourmiliere.Instance.ListFourmis)
            {
                if(f.Etat == 0 && f.PosX == PosX && f.PosY == PosY) // on est sur la case d'une larve !
                {
                    _myLarve = f;
                    _strategieDeplacement = DeplacerNourriceAvecLarve; // un peu gluant, mais appétissant !
                }
            }
        }
コード例 #13
0
 public virtual void ExecuteFourmi(Fourmi destFourmi)
 {
 }
コード例 #14
0
ファイル: Deplacement.cs プロジェクト: xTeddyR/Fourmiliere
 public virtual void Avance(Fourmi fourmi, Location Destination)
 {
 }
コード例 #15
0
ファイル: Deplacement.cs プロジェクト: xTeddyR/Fourmiliere
 public virtual void Avance(Fourmi fourmi)
 {
 }