public BettingManager(BusinessManager businessManager, int nbJoueur)
        {
            this.businessManager = businessManager;
            rand = new Random();
            joueurs = new List<Joueur>();

            for (int i = 0; i < nbJoueur; i++)
            {
                joueurs.Add(new Joueur("player" + i, 0));
            }

            List<Jedi> allJedis = businessManager.getJedis();
            List<Jedi> jedis_to_pool = new List<Jedi>();

            //Creation de la liste a mettre dans la pool
            for (int i = 0; i < 16; i++)
            {
                int index = rand.Next() % allJedis.Count;
                jedis_to_pool.Add(allJedis[index]);
                allJedis.Remove(allJedis[index]);
            }

            jedis = jedis_to_pool;
            pool = new Tournoi(jedis_to_pool, businessManager.getStades());
        }
        public GamePage(Tournoi t, bool b) {
            InitializeComponent();

            m_tournament = t;
            m_manual = b;
            m_current_match = 0;
            m_currentPhase = EPhaseTournoi.HuitiemeFinale;
        }
 public TournoiViewer(Tournoi t,bool auto, int idJ1, int idJ2)
 {
     this.tournoi = t;
     Auto = auto;
     IdJ1 = idJ1;
     IdJ2 = idJ2;
     InitializeComponent();
 }
 public Auto_PhaseTournois(Jedi j1, Jedi j2, Tournoi t)
 {
     InitializeComponent();
     this.jedi1 = j1;
     this.jedi2 = j2;
     this.tournoi = t;
     this.playAuto = new PlayAuto(tournoi);
 }
        /// <summary>
        /// Adapte un Tournoi en Tournoi Contract.
        /// </summary>
        /// <param name="tournoi">Tournoi à adapter.</param>
        /// <returns>Tournoi contract.</returns>
        public static TournoiContract fromTournoi(Tournoi tournoi)
        {
            if (tournoi == null)
                return null;

            TournoiContract tc = new TournoiContract(tournoi.ID, tournoi.Nom, MatchAdapter.fromMatchList(tournoi.Matchs));
            return tc;
        }
 public TournoiWCF(Tournoi tournoi)
     : base(tournoi)
 {
     this.nom = tournoi.Nom;
     matchesWCF = new List<MatchWCF>();
     foreach (Match m in tournoi.Matches)
     {
         matchesWCF.Add(new MatchWCF(m));
     }
 }
Beispiel #7
0
 private void Detail_Tournoi_Click(object sender, EventArgs e)
 {
     try
     {
         EntitiesLayer.Tournoi item = (Tournoi)ListViewTournois.SelectedItems[0];
         TournoiWindow         win  = new TournoiWindow(item);
         win.Show();
         this.Close();
     }
     catch { }
 }
        /// <summary>
        /// Adapte un Tournoi Contract en Tournoi.
        /// </summary>
        /// <param name="tournoiC">Tournoi à adapter.</param>
        /// <returns>Tournoi.</returns>
        public static Tournoi fromTournoiContract(TournoiContract tournoiC)
        {
            if (tournoiC == null)
                return null;

            Tournoi t = new Tournoi();
            t.ID = tournoiC.ID;
            t.Nom = tournoiC.Nom;
            t.Matchs = MatchAdapter.fromMatchContractList(tournoiC.Matchs);

            return t;
        }
       public Automatique()
        {
            InitializeComponent();
            List<JediViewModel> jvm = new List<JediViewModel>();

            foreach (Tournoi t in JediTournamentManager.GetTournoi())
            {
                if (t.Nom.Equals("Tournoi Final"))
                    tournoi = t;
            }

            foreach (Jedi j in JediTournamentManager.GetParticipants(tournoi))
            {
                jvm.Add(new JediViewModel(j));
            }
            listJedi1.DataContext = jvm;
            listJedi2.DataContext = jvm;
        }
        public TournoiChoixSelection(bool auto, Tournoi t)
        {
            InitializeComponent();
            this.t = t;

            Auto = auto;

            List<Jedi> jedis = new List<Jedi>();
            JediTournamentManager manager = new JediTournamentManager();

            foreach(Match match in t.Matchs)
            {
                jedis.Add(match.Jedi1);
                jedis.Add(match.Jedi2);
            }

            cbJ1.ItemsSource = jedis;
            cbJ2.ItemsSource = jedis;
        }
Beispiel #11
0
        public AddMatch(EntitiesLayer.Tournoi tournoi)
        {
            InitializeComponent();
            BManager   = new BusinessLayer.BusinessManager();
            TheTournoi = tournoi;
            List <Pokemon> listPoke = new List <Pokemon>();
            List <Pokemon> listtmp  = BManager.getPokemon();

            for (int i = 0; i < listtmp.Count; i++)
            {
                listPoke.Add(listtmp.ElementAt(i));
            }
            for (int i = 0; i < TheTournoi.nbrMatch; i++)
            {
                listPoke.Remove(TheTournoi.Matchs[i].Pokemon1);
                listPoke.Remove(TheTournoi.Matchs[i].Pokemon2);
            }
            pokemon1.DataContext = listPoke;
            pokemon2.DataContext = listPoke;
        }
        public void AjoutTournoiExemple()
        {
            List<Jedi> jedis = getJedis();
            List<Jedi> jedis_to_pool = new List<Jedi>();
            List<Stade> stades = getStades();
            Random rand = new Random();

            for (int i = 0; i <= 15; i++)
            {
                int index = rand.Next() % jedis.Count;
                jedis_to_pool.Add(jedis[index]);
                jedis.Remove(jedis[index]);
            }
            Tournoi tournoi = new Tournoi(jedis_to_pool, stades);
            tournoi.Nom = "Tournoi de Test";

            List<Tournoi> tournois = getTournoi();
            tournois.Add(tournoi);
            updateTournoi(tournois);
        }
Beispiel #13
0
 public void addTournoi(Tournoi tournoi)
 {
     m_bridge.addTournoi(tournoi);
 }
       public static List<Jedi> GetParticipants(Tournoi t)
        {
            List<Jedi> participants = new List<Jedi>();
            foreach (Match c in t.Matchs)
            {
                participants.Add(c.Jedi1);
                participants.Add(c.Jedi2);
             }

            return participants;
        }
 public static List<Match> GetMatchs(Tournoi t)
 {
     List<Match> listMatchs=t.Matchs; 
     return listMatchs;
 }
 /// <summary>
 /// Met à jour le tournoi en paramètre.
 /// </summary>
 /// <param name="tournoi">Tournoi à modifier.</param>
 public void UpdateTournoi(Tournoi tournoi)
 {
     m_data.UpdateTournoi(tournoi);
 }
 /// <summary>
 /// Supprime le tournoi passé en paramètre.
 /// </summary>
 /// <param name="tournoi">Tournoi à supprimer.</param>
 public void DeleteTournoi(Tournoi tournoi)
 {
     m_data.DeleteTournoi(tournoi);
 }
 /// <summary>
 /// Crée un nouveau tournoi.
 /// </summary>
 /// <param name="tournoi">Tournoi à créer.</param>
 public void CreateTournoi(Tournoi tournoi)
 {
     m_data.CreateTournoi(tournoi);
 }
 public int EditTournoi(Tournoi _tournoi)
 {
     int val = 0;
     using (SqlConnection sqlConnection = new SqlConnection(m_connectionString))
     { //reste les Matchs à supprimer 
         try
         {
             string query = "UPDATE Tournoi SET Nom=@nom WHERE idTournoi=@idTournoi";
             SqlCommand sqlCommand = new SqlCommand(query, sqlConnection);
             sqlCommand.Parameters.AddWithValue("@nom", _tournoi.Nom);
             sqlConnection.Open();
             sqlCommand.ExecuteNonQuery();
             val = 1;
         }
         catch (SqlException e)
         {
             string s = e.Message;
         }
         finally
         {
             sqlConnection.Close();
         }
     }
     return val;
 }
 public int RemoveTournoi(Tournoi _tournoi)
 {
     int val = 0;
     using (SqlConnection sqlConnection = new SqlConnection(m_connectionString))
     { //reste les Matchs à supprimer 
         try {
             string requete = "DELETE FROM Tournoi WHERE idTournoi=@idtournoi";
             SqlCommand sqlCommand = new SqlCommand(requete, sqlConnection);
             sqlCommand.Parameters.AddWithValue("@idtournoi", _tournoi.ID);
             sqlConnection.Open();
             sqlCommand.ExecuteNonQuery();
             sqlConnection.Close();
             val = 1;
         }catch (SqlException e)
         {
             string s = e.Message;
         }
         finally
         {
             sqlConnection.Close();
         }
     }
     return val;
 }
 public int InsertTournoi(Tournoi _tournoi)
 {
     int val=0;
     using (SqlConnection sqlConnection = new SqlConnection(m_connectionString))
     {
         try
         { 
             string requete = "INSERT INTO Tournoi (Nom) VALUES (@Nom)";
             SqlCommand sqlCommand = new SqlCommand(requete, sqlConnection);
             sqlCommand.Parameters.AddWithValue("@Nom",_tournoi.Nom);
             sqlConnection.Open();
             sqlCommand.ExecuteNonQuery();
         }catch (SqlException e)
         {
             string s = e.Message;
         }
         finally
         {
         sqlConnection.Close();
         }
 } 
     return val;
   }
        public void modTournoi(Tournoi tournoi)
        {
            changeTournoi(tournoi.Matchs, tournoi.ID);

            using (SqlConnection sqlConnection = new SqlConnection(m_connexionString))
            {
                SqlCommand sqlModTournoi = new SqlCommand("UPDATE dbo.tournoi SET nom='" + tournoi.Nom + "' WHERE id=" + tournoi.ID, sqlConnection);
                sqlModTournoi.Connection = sqlConnection;
                sqlConnection.Open();
                sqlModTournoi.ExecuteNonQuery();
                sqlConnection.Close();
            }
        }
        public void addTournoi(Tournoi tournoi)
        {
            int id = 0;

            using (SqlConnection sqlConnection = new SqlConnection(m_connexionString))
            {
                SqlCommand sqlAddTournoi = new SqlCommand("INSERT INTO dbo.tournoi (nom) VALUES ('" + tournoi.Nom + "')", sqlConnection);
                sqlAddTournoi.Connection = sqlConnection;
                sqlConnection.Open();
                sqlAddTournoi.ExecuteNonQuery();
                sqlConnection.Close();
            }

            using (SqlConnection sqlConnection = new SqlConnection(m_connexionString))
            {
                SqlCommand sqlCommandTournoi = new SqlCommand("SELECT IDENT_CURRENT('tournoi')", sqlConnection);
                sqlConnection.Open();

                SqlDataReader sqlDataReaderTournoi = sqlCommandTournoi.ExecuteReader();

                while (sqlDataReaderTournoi.Read())
                {
                    id = (int)sqlDataReaderTournoi.GetDecimal(0);
                }

            }

            if (id != 0)
            {
                changeTournoi(tournoi.Matchs, id);
            }
        }
Beispiel #24
0
 public void modTournoi(Tournoi tournoi)
 {
     m_bridge.modTournoi(tournoi);
 }
Beispiel #25
0
 public void delTournoi(Tournoi tournoi)
 {
     m_bridge.delTournoi(tournoi);
 }
        /// <summary>
        /// Constructeur du ViewModel
        /// </summary>
        public TournoiCreatorViewModel() {
            int indexJedi;
            int indexSith;
            int indexStade;
            Random random = new Random();
            BusinessLayer.JediTournamentManager bm = new BusinessLayer.JediTournamentManager();

            m_tournoi = new Tournoi();

            List<Jedi> JediList = bm.getJedis();
            List<Jedi> SithList = bm.getSiths();
            List<Stade> StadeList = bm.getAllStades();

            // Création des matchs de la quart de finale
            for(int i = 0; i < 4; i++) {
                indexJedi = random.Next(JediList.Count);
                indexSith = random.Next(SithList.Count);
                indexStade = random.Next(StadeList.Count);
                m_tournoi.Matchs.Add(new Match(i, JediList[indexJedi], SithList[indexSith], EPhaseTournoi.QuartFinale, StadeList[indexStade]));
                JediList.Remove(JediList[indexJedi]);
                SithList.Remove(SithList[indexSith]);
            }

            // Réinitialisation des listes
            JediList = bm.getJedis();
            SithList = bm.getSiths();

            // Création des matchs de la demie finale
            for (int i = 4; i < 6; i++) {
                indexJedi = random.Next(JediList.Count);
                indexSith = random.Next(SithList.Count);
                indexStade = random.Next(StadeList.Count);
                m_tournoi.Matchs.Add(new Match(i, JediList[indexJedi], SithList[indexSith], EPhaseTournoi.DemiFinale, StadeList[indexStade]));
            }

            // Création des matchs de la finale
            indexJedi = random.Next(JediList.Count);
            indexSith = random.Next(SithList.Count);
            indexStade = random.Next(StadeList.Count);
            m_tournoi.Matchs.Add(new Match(6, JediList[indexJedi], SithList[indexSith], EPhaseTournoi.Finale, StadeList[indexStade]));

            // Création de la liste MatchViewModel
            m_matchs = new ObservableCollection<MatchViewModel>();
            for(int i = 0; i < 4; i++) { 
                m_matchs.Add(new MatchViewModel(m_tournoi.Matchs[i]));
            }
        }
        public void lancerPhaseTournoi(List<int> paris, List<Jedi> jedis_paris)
        {
            foreach (Match match in pool.Matches)
            {
                PlayingMatch pMatch = new PlayingMatch(match);
                while (!pMatch.MatchOver)
                {
                    pMatch.playTurn(pMatch.automaticChoose(), pMatch.automaticChoose());
                }
                for (int i= 0;i < joueurs.Count;i++)
                {
                    if (match.JediVainqueur.Id == jedis_paris[i].Id)
                    {
                        joueurs[i].Score += paris[i];
                    }
                }
            }

            //Maj bdd
            List<Match> oldMatches = businessManager.getMatches();
            oldMatches.Concat(pool.Matches);
            businessManager.updateMatch(oldMatches);
            pool = pool.nextPool();
            jedis = new List<Jedi>();
            foreach (Match match in pool.Matches)
            {
                jedis.Add(match.Jedi1);
                jedis.Add(match.Jedi2);
            }
            end = pool.PoolVide;
        }
        public void testTournoi()
        {
            Jedi jedi1 = new Jedi();
            Jedi jedi2 = new Jedi();
            Jedi jedi3 = new Jedi();
            Jedi jedi4 = new Jedi();

            Stade stade = new Stade(12, "Test", 2000, "Ouine", null, null);
            Stade stade2 = new Stade(13, "Test2", 4000, "Tata", null, null);

            List<Match> listMatchs = new List<Match>();
                listMatchs.Add(new Match(42, jedi1, jedi2, EPhaseTournoi.QuartFinale, stade));
                listMatchs.Add(new Match(56, jedi3, jedi4, EPhaseTournoi.DemiFinale, stade2));

            List<Match> listMatchs2 = new List<Match>();
                listMatchs2.Add(new Match(2, jedi3, jedi1, EPhaseTournoi.Finale, stade));

            Tournoi tournoi = new Tournoi(27, "Le Premier Tournoi", listMatchs);

            Assert.AreEqual(tournoi.ID, 27);
            Assert.AreEqual(tournoi.Nom, "Le Premier Tournoi");
            Assert.AreEqual(tournoi.Matchs, listMatchs);

            tournoi.Nom = "Un Nouveau Tournoi";
            tournoi.Matchs = listMatchs2;

            Assert.AreEqual(tournoi.Nom, "Un Nouveau Tournoi");
            Assert.AreEqual(tournoi.Matchs, listMatchs2);
        }
 public void delTournoi(Tournoi tournoi)
 {
     using (SqlConnection sqlConnection = new SqlConnection(m_connexionString))
     {
         SqlCommand sqlDelTournoi = new SqlCommand("UPDATE dbo.match SET id_tournoi=null WHERE id_tournoi=" + tournoi.ID + ";DELETE FROM dbo.tournoi WHERE id=" + tournoi.ID, sqlConnection);
         sqlDelTournoi.Connection = sqlConnection;
         sqlConnection.Open();
         sqlDelTournoi.ExecuteNonQuery();
         sqlConnection.Close();
     }
 }
 public PlayAuto(Tournoi t)
 {
     this.tournoi = t;
 }
Beispiel #31
0
        public void TestModTournoi()
        {
            DalManager m_data = DalManager.Instance;

            Jedi jedi1 = new Jedi();
            Jedi jedi2 = new Jedi();
            Stade stade1 = new Stade(12, "Test", 2000, "Tata Win", null, null);
            Stade stade2 = new Stade(13, "Test2", 4000, "Tonton Lose", null, null);
            m_data.addJedi(jedi1);
            m_data.addJedi(jedi2);
            m_data.addStade(stade1);
            m_data.addStade(stade2);

            List<Stade> list1 = m_data.getAllStades().Where(s => (s.Nom == stade1.Nom && s.NbPlaces == stade1.NbPlaces && s.Planete == stade1.Planete) || (s.Nom == stade2.Nom && s.NbPlaces == stade2.NbPlaces && s.Planete == stade2.Planete)).ToList();
            List<Jedi> list2 = m_data.getAllJedis().Where(j => (j.Nom == jedi1.Nom || j.Nom == jedi2.Nom)).ToList();
            Match match1 = new Match(42, list2.ElementAt(0), list2.ElementAt(1), EPhaseTournoi.Finale, list1.ElementAt(0));
            Match match2 = new Match(42, list2.ElementAt(0), list2.ElementAt(1), EPhaseTournoi.Finale, list1.ElementAt(1));
            m_data.addMatch(match1);
            m_data.addMatch(match2);

            List<Match> listMatchs = m_data.getAllMatchs().Where(m => m.Jedi1.ID == list2.ElementAt(0).ID && m.Jedi2.ID == list2.ElementAt(1).ID && (m.Stade.ID == list1.ElementAt(0).ID || m.Stade.ID == list1.ElementAt(1).ID)).ToList();

            Tournoi toto = new Tournoi(27, "Le Premier Tournoi", listMatchs);
            m_data.addTournoi(toto);
            List<Tournoi> list = m_data.getAllTournois().Where(t => t.Nom == toto.Nom).ToList();
            List<Match> listMatchs2 = m_data.getAllMatchs().Where(m => m.Jedi1.ID == list2.ElementAt(0).ID && m.Jedi2.ID == list2.ElementAt(1).ID && m.Stade.ID == list1.ElementAt(0).ID).ToList();
            list.ElementAt(0).Matchs = listMatchs2;
            list.ElementAt(0).Nom = "SecondTournoi";
            m_data.modTournoi(list.ElementAt(0));
            List<Tournoi> list5 = m_data.getAllTournois().Where(t => t.Nom == list.ElementAt(0).Nom).ToList();

            Assert.AreEqual(list.ElementAt(0).Nom, list5.ElementAt(0).Nom);
            m_data.delTournoi(list5.ElementAt(0));
            m_data.delMatch(listMatchs.ElementAt(0));
            m_data.delMatch(listMatchs.ElementAt(1));
            m_data.delStade(list1.ElementAt(0));
            m_data.delStade(list1.ElementAt(1));
            m_data.delJedi(list2.ElementAt(0));
            m_data.delJedi(list2.ElementAt(1));
        }
        public void AddTournoi(string nom, MatchContract match1, MatchContract match2, MatchContract match3, MatchContract match4)
        {
            List<MatchContract> listMatchc = new List<MatchContract>();
            listMatchc.Add(match1);
            listMatchc.Add(match2);
            listMatchc.Add(match3);
            listMatchc.Add(match4);

            List<Match> listMatch = new List<Match>();

            List<Jedi> listJedi = jtm.getAllJedis();

            List<Stade> listStade = jtm.getAllStades();

            Jedi jedi1 = new Jedi();
            Jedi jedi2 = new Jedi();
            Stade stade = new Stade();

            foreach (MatchContract m in listMatchc)
            {

                jedi1 = listJedi.Find(j => j.Nom == m.Jedi1.Nom);
                jedi2 = listJedi.Find(j => j.Nom == m.Jedi2.Nom);
                stade = listStade.Find(s => s.Planete == m.Stade.Planete);

                listMatch.Add(new Match(m.Id, jedi1, jedi2, EPhaseTournoi.QuartFinale, stade));
            }

            Tournoi tournoi = new Tournoi(0, nom, listMatch);

            jtm.addTournoi(tournoi);
        }