public static PartidaViewModel AgregarFicha(PartidaViewModel partida, string fila, string columna)
        {
            var color = partida.siguiente_tiro;

            if (color == "blanco")
            {
                partida.siguiente_tiro = "negro";
            }
            else
            {
                partida.siguiente_tiro = "blanco";
            }
            if (partida.color_jugador1 == color)
            {
                partida.punteo_jugador1++;
            }
            else
            {
                partida.punteo_jugador2++;
            }
            foreach (var fil in partida.Filas)
            {
                foreach (var col in fil.columnas)
                {
                    if (col.nombre == columna && fil.nombre == fila)
                    {
                        col.color = color;
                    }
                }
            }
            return(partida);
        }
        public ActionResult CargarPartida(HttpPostedFileBase archivo)
        {
            if (!User.Identity.IsAuthenticated)
            {
                return(RedirectToAction("Login", "User"));
            }

            var Filename = Path.GetFileName(archivo.FileName);
            var path     = Path.Combine(Server.MapPath("~/Public/XML"), Filename);

            archivo.SaveAs(path);
            XmlDocument documento = new XmlDocument();

            documento.Load(path);
            PartidaCargada = Funciones.CrearPartida(modelo);
            PartidaCargada.movimientos_1   = 0;
            PartidaCargada.movimientos_2   = 0;
            PartidaCargada.punteo_jugador1 = 0;
            PartidaCargada.punteo_jugador2 = 0;
            foreach (var fila in PartidaCargada.Filas)
            {
                foreach (var columna in fila.columnas)
                {
                    columna.color = "";
                }
            }
            foreach (XmlNode node in documento.SelectNodes("/tablero/ficha"))
            {
                var f     = node["fila"].InnerText;
                var c     = node["columna"].InnerText;
                var color = node["color"].InnerText;

                foreach (var fila in PartidaCargada.Filas)
                {
                    foreach (var columna in fila.columnas)
                    {
                        if (c == columna.nombre && f == fila.nombre)
                        {
                            columna.color = color;
                            if (PartidaCargada.color_jugador1 == color)
                            {
                                PartidaCargada.punteo_jugador1++;
                                PartidaCargada.movimientos_1++;
                            }
                            else
                            {
                                PartidaCargada.punteo_jugador2++;
                                PartidaCargada.movimientos_2++;
                            }
                        }
                    }
                }
            }
            foreach (XmlNode node in documento.SelectNodes("/tablero/siguienteTiro"))
            {
                PartidaCargada.siguiente_tiro = node["color"].InnerText;
            }
            cargar = true;
            return(RedirectToAction("Partida", "Partida"));
        }
Beispiel #3
0
        public ViewListaPartida()
        {
            InitializeComponent();
            var viewModel = new PartidaViewModel();

            viewModel.Navigation = this.Navigation;
            BindingContext       = viewModel;
        }
Beispiel #4
0
        public ViewCadastroPartida()
        {
            InitializeComponent();
            Partida partida = new Partida();

            partida.DtPartida = DateTime.Now;
            var viewModel = new PartidaViewModel(partida);

            viewModel.Navigation = this.Navigation;
            BindingContext       = viewModel;
        }
        public ActionResult GuardarPartida(int nombre)
        {
            if (!User.Identity.IsAuthenticated)
            {
                return(RedirectToAction("Login", "User"));
            }

            PartidaViewModel partida = new PartidaViewModel();

            foreach (var part in modelo.partidas)
            {
                if (part.nombre == nombre)
                {
                    partida = part;
                    break;
                }
            }
            string Filename = "Partida_#" + partida.nombre + ".xml";
            var    path     = Path.Combine(Server.MapPath("~/Public/XML_SAVE"), Filename);

            if (System.IO.File.Exists(path))
            {
                System.IO.File.Delete(path);
            }
            XDocument documento = new XDocument(new XDeclaration("1.0", "utf-8", null));
            XElement  Raiz      = new XElement("tablero");

            documento.Add(Raiz);
            foreach (var fila in partida.Filas)
            {
                foreach (var columna in fila.columnas)
                {
                    if (!string.IsNullOrEmpty(columna.color))
                    {
                        XElement ficha  = new XElement("ficha");
                        XElement colors = new XElement("color", columna.color);
                        XElement col    = new XElement("columna", columna.nombre);
                        XElement fil    = new XElement("fila", fila.nombre);
                        ficha.Add(colors);
                        ficha.Add(col);
                        ficha.Add(fil);
                        Raiz.Add(ficha);
                    }
                }
            }
            XElement siguiente = new XElement("siguienteTiro");
            XElement color     = new XElement("color", partida.siguiente_tiro);

            siguiente.Add(color);
            Raiz.Add(siguiente);

            documento.Save(path);
            return(RedirectToAction("Index", "Partida", new { mensaje = "Partida Guardada" }));
        }
        public static PartidaViewModel CrearPartida(DatosModel dato)
        {
            PartidaViewModel partida = new PartidaViewModel();

            string[] columnas = { "A", "B", "C", "D", "E", "F", "G", "H" };
            partida.nombre          = dato.nombre + 1;
            partida.jugador1        = "jugador1";
            partida.jugador2        = "jugador2";
            partida.color_jugador1  = "negro";
            partida.color_jugador2  = "blanco";
            partida.movimientos_1   = 0;
            partida.movimientos_2   = 0;
            partida.punteo_jugador1 = 2;
            partida.punteo_jugador2 = 2;
            partida.siguiente_tiro  = "blanco";
            for (int i = 1; i <= 8; i++)
            {
                FilaViewModel fila = new FilaViewModel();
                fila.nombre = i.ToString();
                for (int j = 0; j < columnas.Length; j++)
                {
                    ColumnaViewModel col = new ColumnaViewModel();
                    col.color  = "";
                    col.nombre = columnas[j];

                    if (j == 3 && i == 4)
                    {
                        col.color = "blanco";
                    }
                    if (j == 3 && i == 5)
                    {
                        col.color = "negro";
                    }
                    if (j == 4 && i == 4)
                    {
                        col.color = "negro";
                    }
                    if (j == 4 && i == 5)
                    {
                        col.color = "blanco";
                    }
                    fila.columnas.Add(col);
                }
                partida.Filas.Add(fila);
            }
            dato.partidas.Add(partida);
            dato.nombre++;
            return(partida);
        }
        // GET: Partida
        public ActionResult Index(int Id, string Nome)
        {
            @ViewBag.IdCampeonato = Id;
            var partidaViewModel = new List <PartidaViewModel>();
            var partida          = _partidaRepositorio.Get(a => a.CampeonatoId == Id);

            foreach (var i in partida)
            {
                var PartidaViewModel = new PartidaViewModel()
                {
                    NomeJogador1        = i.Jogador1.Nome,
                    NomeJogadorVencedor = i.JogadorIdVencedor == null ? "" : i.JogadorVencedor.Nome,
                    NomeJogador2        = i.Jogador2.Nome,
                    JogadorId1          = i.JogadorId1,
                    JogadorId2          = i.JogadorId2,
                    Turno             = i.Turno,
                    JogadorIdVencedor = i.JogadorIdVencedor,
                    PartidaId         = i.Id
                };
                ViewBag.NomeVencedor = Nome;
                ViewBag.Turno        = PartidaViewModel.Turno;
                partidaViewModel.Add(PartidaViewModel);
                //if (PartidaViewModel.Turno == 3 || PartidaViewModel.Turno == 4 || PartidaViewModel.Turno == 5)
                //{
                //    var turno = PartidaViewModel.Turno;
                //    var jogadorVencedor = _partidaRepositorio.First(a => a.Turno == turno && a.CampeonatoId == Id).JogadorVencedor.Nome;
                //        //First(a => a.Turno == 3 || a.Turno == 4 || a.Turno == 5 && a.CampeonatoId == Id ).JogadorVencedor.Nome;
                //    @ViewBag.JogadorVencedor = jogadorVencedor;
                //}
            }


            var vencedor = TempData["Vencedor"];

            ViewBag.Vencedor = vencedor;
            var erro = TempData["mensagemErro"];

            if (erro != null)
            {
                ModelState.AddModelError("Erro", erro.ToString());
            }

            return(View(partidaViewModel));
        }
        public async Task <ActionResult> Partidas(int codigoTime)
        {
            var login    = Session["user"].ToString();
            var partidas = await _administrativoBLL.RetornarPartidas(codigoTime, login);

            var usuario = await _autenticaBLL.RetornarUsuario(login);

            var model = new PartidaViewModel()
            {
                Partidas          = partidas.Select(c => new PartidaModel(c)).ToList(),
                MeusTimes         = (await _administrativoBLL.RetornarTimes(usuario)).Select(c => new TimeModel(c)).ToList(),
                TimesAdversarios  = (await _administrativoBLL.RetornarTimesAdversarios(usuario, codigoTime)).Select(c => new TimeModel(c)).ToList(),
                Jogadores         = (await _administrativoBLL.RetornarJogadores(usuario, codigoTime)).Select(c => new JogadorModel(c)).ToList(),
                TipoAcontecimento = (await _administrativoBLL.RetornarTipoAcontecimento()).Select(c => new TipoAcontecimentoModel(c)).ToList(),
                codigoTime        = codigoTime
            };

            return(View("Partidas/Index", model));
        }
        public ActionResult Partida(int nom, string fila, string columna)
        {
            if (!User.Identity.IsAuthenticated)
            {
                return(RedirectToAction("Login", "User"));
            }

            ViewBag.mensaje = "funciono";
            var partida = new PartidaViewModel();

            foreach (var part in modelo.partidas)
            {
                if (part.nombre == nom)
                {
                    partida = part;
                    break;
                }
            }
            var model = Funciones.AgregarFicha(partida, fila, columna);

            ViewBag.partida = model;
            return(View(model));
        }
        public ActionResult Partida()
        {
            if (!User.Identity.IsAuthenticated)
            {
                return(RedirectToAction("Login", "User"));
            }

            var partida = new PartidaViewModel();

            if (!cargar)
            {
                partida = Funciones.CrearPartida(modelo);
            }
            else
            {
                partida        = PartidaCargada;
                cargar         = false;
                PartidaCargada = new PartidaViewModel();
            }
            ViewBag.mensaje = "partida";
            ViewBag.partida = partida;
            return(View(partida));
        }