Exemple #1
0
    override public void GuardarEntradaDatos()
    {
        string tipoEntradaDatos = isPartido ? "Partido" : "Practica";

        Debug.Log("Guardando como: " + tipoEntradaDatos);

        mensajeErrorGuardado.gameObject.SetActive(true);

        string nombrePatido = nombrePartidoText.text.ToUpper();

        if (nombrePatido == "")
        {
            mensajeErrorGuardado.SetText("Nombre inválido!".ToUpper(), AppController.Idiomas.Español);
            mensajeErrorGuardado.SetText("Invalid name!".ToUpper(), AppController.Idiomas.Ingles);
            mensajeErrorGuardado.Activar();
            Debug.Log("Nombre inválido");
            return;
        }
        else if (equipo.ContienePartido(tipoEntradaDatos, nombrePatido))
        {
            mensajeErrorGuardado.SetText("Nombre existente!".ToUpper(), AppController.Idiomas.Español);
            mensajeErrorGuardado.SetText("Existing name!".ToUpper(), AppController.Idiomas.Ingles);
            mensajeErrorGuardado.Activar();
            Debug.Log("Nombre existente");
            return;
        }

        Deportes.DeporteEnum deporteActual = equipo.GetDeporte();
        Estadisticas         estEquipo     = new Estadisticas(deporteActual);
        DateTime             fecha         = DateTime.Now;

        Debug.Log("Fehca guardada: " + fecha.ToString());

        for (int i = 0; i < jugadores.Count; i++)
        {
            Estadisticas estadistica = new Estadisticas(deporteActual);

            for (int j = 0; j < listaEstadisticas.Count; j++)
            {
                Button[] botones = columnas[j + 1].GetComponentsInChildren <Button>();
                estadistica.AgregarEstadisticas(listaEstadisticas[j].ToUpper(), botones[i].GetComponent <BotonEntradaDato>().GetCantidad());
            }

            estadistica.SetFecha(fecha);
            estEquipo.SetFecha(fecha);
            Debug.Log("Estadsitica - cant : " + estadistica.GetCantidadCategorias());
            estEquipo.AgregarEstadisticas(estadistica);
            //jugadores[i].SetEstadisticas(estadistica, tipoEntradaDatos);
            //jugadores[i].AgregarPartido(new Partido(nombrePartidoText.text, estadistica), tipoEntradaDatos);
            //jugadores[i].GuardarEntradaDato(tipoEntradaDatos, estadistica, new Partido(nombrePatido, estadistica, fecha));
        }

        //equipo.SetEstadisticas(estEquipo, tipoEntradaDatos);
        //equipo.AgregarPartido(new Partido(nombrePartidoText.text, estEquipo), tipoEntradaDatos);
        //equipo.GuardarEntradaDato(tipoEntradaDatos, estEquipo, new Partido(nombrePatido, estEquipo, fecha, isPartido));

        Debug.Log("Entrada guardado como: " + tipoEntradaDatos);

        //CanvasController.instance.escenas.Add(1);
        CanvasController.instance.retrocesoPausado = false;
        CanvasController.instance.MostrarPanelAnterior();
        CanvasController.instance.overlayPanel.gameObject.SetActive(true);
        CanvasController.instance.botonDespliegueMenu.SetActive(true);
        Screen.orientation = ScreenOrientation.Portrait;
        Destroy(gameObject);
    }
Exemple #2
0
    public void SetSpriteBotonEquipo(Equipo equipo)
    {
        equipoFocus = equipo;

        int cantJugadores = equipo.GetJugadores().Count;

        if (cantJugadores == 0)
        {
            cantidadJugadoresText.SetText("Equipo vacio".ToUpper(), AppController.Idiomas.Español);
            cantidadJugadoresText.SetText("empy team".ToUpper(), AppController.Idiomas.Ingles);
        }
        else if (cantJugadores == 1)
        {
            cantidadJugadoresText.SetText(equipo.GetJugadores().Count + " jugador".ToUpper(), AppController.Idiomas.Español);
            cantidadJugadoresText.SetText(equipo.GetJugadores().Count + " player".ToUpper(), AppController.Idiomas.Ingles);
        }
        else
        {
            cantidadJugadoresText.SetText(equipo.GetJugadores().Count + " jugadores".ToUpper(), AppController.Idiomas.Español);
            cantidadJugadoresText.SetText(equipo.GetJugadores().Count + " players".ToUpper(), AppController.Idiomas.Ingles);
        }

        //Debug.Log("DEPORTE: " + equipo.GetDeporteNombre() + ", " + (int)equipo.GetDeporte());
        switch (equipo.GetDeporte())
        {
        case Deportes.DeporteEnum.Futbol:
            spriteDeporte.texture = spriteFutbol.texture;
            break;

        case Deportes.DeporteEnum.HockeyCesped:
            spriteDeporte.texture = spriteHockeyCesped.texture;
            break;

        case Deportes.DeporteEnum.Tenis:
            spriteDeporte.texture = spriteTenis.texture;
            break;

        case Deportes.DeporteEnum.Softball:
            spriteDeporte.texture = spriteSoftball.texture;
            break;

        case Deportes.DeporteEnum.Voley:
            spriteDeporte.texture = spriteVoley.texture;
            break;

        case Deportes.DeporteEnum.HockeyPatines:
            spriteDeporte.texture = spriteHockeyPatines.texture;
            break;

        case Deportes.DeporteEnum.Rugby:
            spriteDeporte.texture = spriteRugby.texture;
            break;

        case Deportes.DeporteEnum.Basket:
            spriteDeporte.texture = spriteBasket.texture;
            break;

        case Deportes.DeporteEnum.Handball:
            spriteDeporte.texture = spriteHandball.texture;
            break;

        case Deportes.DeporteEnum.Padel:
            spriteDeporte.texture = spritePadel.texture;
            break;
        }

        //spriteDeporte.texture = listaSprites[(int)equipo.GetDeporte()].texture;

        spriteDeporte.transform.localScale.Set(2f, 2f, 1f);
    }
 public SaveDataEquipo(Equipo equipo)
 {
     nombreEquipo = equipo.GetNombre();
     deporte      = equipo.GetDeporte();
 }
Exemple #4
0
    public static void LoadData()
    {
        BinaryFormatter formatter = new BinaryFormatter();

        if (Directory.Exists(pathEquipos))
        {
            #region Equipo
            //CARGAR EQUIPOS
            string[] equiposDirectories = Directory.GetDirectories(pathEquipos);

            for (int i = 0; i < equiposDirectories.Length; i++)
            {
                //PATH DE UN EQUIPO
                string pathEquipo = equiposDirectories[i];

                FileStream     equipoStream = new FileStream(pathEquipo + "/equipo.txt", FileMode.Open);
                SaveDataEquipo dataEquipo   = (SaveDataEquipo)formatter.Deserialize(equipoStream);

                //CREAR EL EQUIPO
                Equipo equipo = new Equipo(dataEquipo);

                equipoStream.Close();

                #region Jugadores
                //CARGAR JUGADORES
                string pathJugadores = pathEquipo + "/jugadores";

                if (Directory.Exists(pathJugadores))
                {
                    string[] jugadoresDirectories = Directory.GetDirectories(pathJugadores);

                    foreach (var jugadorDir in jugadoresDirectories)
                    {
                        FileStream      streamJugador = new FileStream(jugadorDir + "/jugador.txt", FileMode.Open);
                        SaveDataJugador dataJugador   = (SaveDataJugador)formatter.Deserialize(streamJugador);

                        Jugador jugador = new Jugador(dataJugador);

                        streamJugador.Close();

                        #region Estadisticas globales jugadores
                        //CARGAR ESTADISTICAS GLOBALES
                        if (File.Exists(jugadorDir + "/estGlobalPartido.txt"))
                        {
                            FileStream           estPartidoStream = new FileStream(jugadorDir + "/estGlobalPartido.txt", FileMode.Open);
                            SaveDataEstadisticas dataEstPartido   = (SaveDataEstadisticas)formatter.Deserialize(estPartidoStream);
                            jugador.CargarEstadisticasGlobalesPartido(new Estadisticas(dataEstPartido));
                            estPartidoStream.Close();
                        }
                        if (File.Exists(jugadorDir + "/estGlobalPractica.txt"))
                        {
                            FileStream           estPracticaStream = new FileStream(jugadorDir + "/estGlobalPractica.txt", FileMode.Open);
                            SaveDataEstadisticas dataEstPractica   = (SaveDataEstadisticas)formatter.Deserialize(estPracticaStream);
                            jugador.CargarEstadisticasGlobalesPractica(new Estadisticas(dataEstPractica));
                            estPracticaStream.Close();
                        }
                        #endregion

                        #region Partidos jugadores
                        //CARGAR PARTIDOS
                        if (Directory.Exists(jugadorDir + "/partidos"))
                        {
                            string pathPartidos = jugadorDir + "/partidos";

                            string[] partidosDirectories = Directory.GetDirectories(pathPartidos);

                            foreach (var partidoDir in partidosDirectories)
                            {
                                //string pathPartido = pathPartidos + partidoDir;

                                FileStream      streamPartido = new FileStream(partidoDir + "/partido.txt", FileMode.Open);
                                SaveDataPartido dataPartido   = (SaveDataPartido)formatter.Deserialize(streamPartido);

                                FileStream streamPosicion = new FileStream(partidoDir + "/posicion.txt", FileMode.Open);
                                string     dataPosicion   = (string)formatter.Deserialize(streamPosicion);

                                FileStream           streamEstadisticas = new FileStream(partidoDir + "/estadisticas.txt", FileMode.Open);
                                SaveDataEstadisticas dataEstadisticas   = (SaveDataEstadisticas)formatter.Deserialize(streamEstadisticas);

                                FileStream streamResultado = new FileStream(partidoDir + "/resultado.txt", FileMode.Open);

                                Partido _partido = new Partido(dataPartido, dataEstadisticas, jugador, dataPosicion);

                                if (equipo.GetDeporte() == Deportes.DeporteEnum.Tenis || equipo.GetDeporte() == Deportes.DeporteEnum.Padel || equipo.GetDeporte() == Deportes.DeporteEnum.Voley)
                                {
                                    SaveDataResultadoSets resPartidoSets = (SaveDataResultadoSets)formatter.Deserialize(streamResultado);
                                    ResultadoSets         _res           = new ResultadoSets(resPartidoSets);
                                    _partido.AgregarResultadoEntradaDatos(_res, Partido.TipoResultadoPartido.Sets);
                                }
                                else
                                {
                                    SaveDataResultadoNormal resPartidoNormal = (SaveDataResultadoNormal)formatter.Deserialize(streamResultado);
                                    ResultadoNormal         _res             = new ResultadoNormal(resPartidoNormal);
                                    _partido.AgregarResultadoEntradaDatos(_res, Partido.TipoResultadoPartido.Normal);
                                }

                                jugador.CargarPartido(_partido);

                                streamPartido.Close();
                                streamEstadisticas.Close();
                            }
                        }
                        #endregion

                        #region Practicas jugadores
                        //CARGAR PRACTICAS
                        if (Directory.Exists(jugadorDir + "/practicas"))
                        {
                            string pathPracticas = jugadorDir + "/practicas";

                            string[] practicasDirectories = Directory.GetDirectories(pathPracticas);

                            foreach (var practicaDir in practicasDirectories)
                            {
                                //string pathPractica = pathPracticas + practicaDir;

                                FileStream      streamPractica = new FileStream(practicaDir + "/partido.txt", FileMode.Open);
                                SaveDataPartido dataPractica   = (SaveDataPartido)formatter.Deserialize(streamPractica);

                                FileStream streamPosicion = new FileStream(practicaDir + "/posicion.txt", FileMode.Open);
                                string     dataPosicion   = (string)formatter.Deserialize(streamPosicion);
                                Debug.Log("POS LOAD: " + jugador.GetPosicionActual());

                                FileStream           streamEstadisticas = new FileStream(practicaDir + "/estadisticas.txt", FileMode.Open);
                                SaveDataEstadisticas dataEstadisticas   = (SaveDataEstadisticas)formatter.Deserialize(streamEstadisticas);

                                FileStream streamResultado = new FileStream(practicaDir + "/resultado.txt", FileMode.Open);

                                Partido _partido = new Partido(dataPractica, dataEstadisticas, jugador, dataPosicion);

                                if (equipo.GetDeporte() == Deportes.DeporteEnum.Tenis || equipo.GetDeporte() == Deportes.DeporteEnum.Padel || equipo.GetDeporte() == Deportes.DeporteEnum.Voley)
                                {
                                    SaveDataResultadoSets resPartidoSets = (SaveDataResultadoSets)formatter.Deserialize(streamResultado);
                                    ResultadoSets         _res           = new ResultadoSets(resPartidoSets);
                                    _partido.AgregarResultadoEntradaDatos(_res, Partido.TipoResultadoPartido.Sets);
                                }
                                else
                                {
                                    SaveDataResultadoNormal resPartidoNormal = (SaveDataResultadoNormal)formatter.Deserialize(streamResultado);
                                    ResultadoNormal         _res             = new ResultadoNormal(resPartidoNormal);
                                    _partido.AgregarResultadoEntradaDatos(_res, Partido.TipoResultadoPartido.Normal);
                                }

                                jugador.CargarPractica(_partido);

                                streamPractica.Close();
                                streamEstadisticas.Close();
                            }
                        }
                        #endregion
                        equipo.CargarJugador(jugador);
                    }
                }
                #endregion

                #region Jugador Favorito
                string favPlayerPath = pathEquipo + "/favouritePlayer.txt";
                if (File.Exists(favPlayerPath))
                {
                    FileStream streamFavPlayer = new FileStream(favPlayerPath, FileMode.Open);
                    string     jugadorFavorito = (string)formatter.Deserialize(streamFavPlayer);

                    equipo.SetJugadorFavorito(jugadorFavorito);
                }
                #endregion

                #region Estadisticas globales equipo
                //CARGAR ESTADISTICAS GLOBALES
                if (File.Exists(pathEquipo + "/estGlobalPartido.txt"))
                {
                    FileStream           estPartidoStream = new FileStream(pathEquipo + "/estGlobalPartido.txt", FileMode.Open);
                    SaveDataEstadisticas dataEstPartido   = (SaveDataEstadisticas)formatter.Deserialize(estPartidoStream);
                    Estadisticas         est = new Estadisticas(dataEstPartido);
                    equipo.CargarEstadisticasGlobalesPartido(est);
                    estPartidoStream.Close();
                }
                if (File.Exists(pathEquipo + "/estGlobalPractica.txt"))
                {
                    FileStream           estPracticaStream = new FileStream(pathEquipo + "/estGlobalPractica.txt", FileMode.Open);
                    SaveDataEstadisticas dataEstPractica   = (SaveDataEstadisticas)formatter.Deserialize(estPracticaStream);
                    equipo.CargarEstadisticasGlobalesPractica(new Estadisticas(dataEstPractica));
                    estPracticaStream.Close();
                }
                #endregion

                #region Partidos equipo
                //CARGAR PARTIDOS
                if (Directory.Exists(pathEquipo + "/partidos"))
                {
                    string pathPartidos = pathEquipo + "/partidos";

                    string[] partidosDirectories = Directory.GetDirectories(pathPartidos);

                    foreach (var partidoDir in partidosDirectories)
                    {
                        //string pathPartido = pathPartidos + partidoDir;

                        FileStream      streamPartido = new FileStream(partidoDir + "/partido.txt", FileMode.Open);
                        SaveDataPartido dataPartido   = (SaveDataPartido)formatter.Deserialize(streamPartido);

                        FileStream           streamEstadisticas = new FileStream(partidoDir + "/estadisticas.txt", FileMode.Open);
                        SaveDataEstadisticas dataEstadisticas   = (SaveDataEstadisticas)formatter.Deserialize(streamEstadisticas);

                        FileStream streamResultado = new FileStream(partidoDir + "/resultado.txt", FileMode.Open);

                        Partido _partido = new Partido(dataPartido, dataEstadisticas, equipo);

                        if (equipo.GetDeporte() == Deportes.DeporteEnum.Tenis || equipo.GetDeporte() == Deportes.DeporteEnum.Padel || equipo.GetDeporte() == Deportes.DeporteEnum.Voley)
                        {
                            SaveDataResultadoSets resPartidoSets = (SaveDataResultadoSets)formatter.Deserialize(streamResultado);
                            ResultadoSets         _res           = new ResultadoSets(resPartidoSets);
                            _partido.AgregarResultadoEntradaDatos(_res, Partido.TipoResultadoPartido.Sets);
                        }
                        else
                        {
                            SaveDataResultadoNormal resPartidoNormal = (SaveDataResultadoNormal)formatter.Deserialize(streamResultado);
                            ResultadoNormal         _res             = new ResultadoNormal(resPartidoNormal);
                            _partido.AgregarResultadoEntradaDatos(_res, Partido.TipoResultadoPartido.Normal);
                        }


                        equipo.CargarPartido(_partido);

                        streamPartido.Close();
                        streamEstadisticas.Close();
                    }
                }
                #endregion

                #region Practica equipo
                //CARGAR PRACTICAS
                if (Directory.Exists(pathEquipo + "/practicas"))
                {
                    string pathPracticas = pathEquipo + "/practicas";

                    string[] practicasDirectories = Directory.GetDirectories(pathPracticas);

                    foreach (var practicaDir in practicasDirectories)
                    {
                        //string pathPractica = pathPracticas + practicaDir;

                        FileStream      streamPractica = new FileStream(practicaDir + "/partido.txt", FileMode.Open);
                        SaveDataPartido dataPractica   = (SaveDataPartido)formatter.Deserialize(streamPractica);

                        FileStream           streamEstadisticas = new FileStream(practicaDir + "/estadisticas.txt", FileMode.Open);
                        SaveDataEstadisticas dataEstadisticas   = (SaveDataEstadisticas)formatter.Deserialize(streamEstadisticas);

                        FileStream streamResultado = new FileStream(practicaDir + "/resultado.txt", FileMode.Open);

                        Partido _partido = new Partido(dataPractica, dataEstadisticas, equipo);

                        if (equipo.GetDeporte() == Deportes.DeporteEnum.Tenis || equipo.GetDeporte() == Deportes.DeporteEnum.Padel || equipo.GetDeporte() == Deportes.DeporteEnum.Voley)
                        {
                            SaveDataResultadoSets resPartidoSets = (SaveDataResultadoSets)formatter.Deserialize(streamResultado);
                            ResultadoSets         _res           = new ResultadoSets(resPartidoSets);
                            _partido.AgregarResultadoEntradaDatos(_res, Partido.TipoResultadoPartido.Sets);
                        }
                        else
                        {
                            SaveDataResultadoNormal resPartidoNormal = (SaveDataResultadoNormal)formatter.Deserialize(streamResultado);
                            ResultadoNormal         _res             = new ResultadoNormal(resPartidoNormal);
                            _partido.AgregarResultadoEntradaDatos(_res, Partido.TipoResultadoPartido.Normal);
                        }

                        equipo.CargarPractica(_partido);

                        streamPractica.Close();
                        streamEstadisticas.Close();
                    }
                }
                #endregion
                #endregion



                #region Planillas
                //CARGAR PLANILLAS
                string pathPlanillas = pathEquipos + equipo.GetNombre() + "/planillas";

                if (Directory.Exists(pathPlanillas))
                {
                    string[] planillasDirectories = Directory.GetDirectories(pathPlanillas);            //Vector de Carpetas de Planillas

                    for (int j = 0; j < planillasDirectories.Length; j++)                               //Para cada carpeta de planillas
                    {
                        string pathPlanillaAsistencia = Directory.GetFiles(planillasDirectories[j])[0]; //Obtengo la dirección de la carpeta actual

                        FileStream streamPlanillaAsistencia = new FileStream(pathPlanillaAsistencia, FileMode.Open);
                        SaveDataPlanillaAsistencia dataPlanillaAsistencia = (SaveDataPlanillaAsistencia)formatter.Deserialize(streamPlanillaAsistencia);

                        equipo.AgregarPlanillaAsistencia(dataPlanillaAsistencia);

                        string[] detallesFiles = Directory.GetFiles(planillasDirectories[j] + "/Detalles"); //Vector de todos los detalles en la carpeta actual

                        for (int k = 0; k < detallesFiles.Length; k++)                                      //Para cada detalle
                        {
                            FileStream streamDetalles = new FileStream(detallesFiles[k], FileMode.Open);

                            SaveDataPlanilla dataDetalle = (SaveDataPlanilla)formatter.Deserialize(streamDetalles);

                            //Agregar la Planilla al Equipo
                            equipo.AgregarDetalle(new DetalleAsistencia(dataDetalle), dataDetalle.GetNombrePlanilla());

                            streamDetalles.Close();
                        }
                    }
                }
                #endregion

                //Agregar Equipo a la lista de Equipos
                AppController.instance.AgregarEquipo(equipo);
            }
        }

        #region Jugadas
        //Cargar imagenes
        if (Directory.Exists(pathImagenJugadas))
        {
            //Por cada imagen guardada creo un objeto imagen
            string[] pathsCarpeta = Directory.GetDirectories(pathImagenJugadas);

            for (int i = 0; i < pathsCarpeta.Length; i++)
            {
                string _nombreCarpeta = Path.GetFileName(pathsCarpeta[i]);
                if (_nombreCarpeta == "-")
                {
                    _nombreCarpeta = SaveSystem.carpetaEspecialEspañol;
                }

                CarpetaJugada _carpeta = new CarpetaJugada(_nombreCarpeta);

                string[] pathCarpetasJugadas = Directory.GetDirectories(pathsCarpeta[i]);

                for (int k = 0; k < pathCarpetasJugadas.Length; k++)
                {
                    string[] pathArchivos = Directory.GetFiles(pathCarpetasJugadas[k]);

                    byte[] bytes     = null;
                    string nombre    = string.Empty;
                    string categoria = string.Empty;

                    for (int j = 0; j < pathArchivos.Length; j++)
                    {
                        if (Path.GetExtension(pathArchivos[j]) == ".png")
                        {
                            nombre = Path.GetFileNameWithoutExtension(pathArchivos[j]);

                            bytes = File.ReadAllBytes(pathArchivos[j]);
                        }
                        else
                        {
                            FileStream streamCategoria = new FileStream(pathArchivos[j], FileMode.Open);
                            categoria = (string)formatter.Deserialize(streamCategoria);
                        }
                    }

                    ImagenBiblioteca _imagenBiblioteca = new ImagenBiblioteca(bytes, nombre, categoria, _carpeta);
                    //AppController.instance.AgregarImagen(_imagenBiblioteca);
                    _carpeta.AgregarJugada(_imagenBiblioteca);
                }
                AppController.instance.AgregarCarpetaJugada(_carpeta);
            }

            if (!Directory.Exists(pathImagenJugadas + "-"))
            {
                Directory.CreateDirectory(pathImagenJugadas + "-");
                AppController.instance.AgregarCarpetaJugada(new CarpetaJugada(SaveSystem.carpetaEspecialEspañol));
            }
        }
        else
        {
            Directory.CreateDirectory(pathImagenJugadas + "-");
            AppController.instance.AgregarCarpetaJugada(new CarpetaJugada(SaveSystem.carpetaEspecialEspañol));
        }
        #endregion

        #region Settings
        string settingsPath = Application.persistentDataPath + "/" + SaveSystem.carpetaPrincipal + "/settings.txt";
        if (File.Exists(settingsPath))
        {
            FileStream       streamSettings = new FileStream(settingsPath, FileMode.Open);
            SaveDataSettings dataSettings   = (SaveDataSettings)formatter.Deserialize(streamSettings);

            AppController.instance.SetSettings(dataSettings);
        }

        string equipoFavPath = Application.persistentDataPath + "/" + SaveSystem.carpetaPrincipal + "/favouriteTeam.txt";
        if (File.Exists(equipoFavPath))
        {
            FileStream streamFavTeam  = new FileStream(equipoFavPath, FileMode.Open);
            string     equipoFavorito = (string)formatter.Deserialize(streamFavTeam);

            AppController.instance.SetTeamAsFavourite(equipoFavorito);
        }
        #endregion
    }
    override public void GuardarEntradaDatos()
    {
        string tipoEntradaDatos = isPartido ? "Partido" : "Practica";

        Debug.Log("Guardando como: " + tipoEntradaDatos);

        mensajeErrorGuardado.gameObject.SetActive(true);

        string nombrePartido = nombrePartidoText.text.ToUpper();
        Equipo equipo        = AppController.instance.equipoActual;

        if (nombrePartido == "" || !AppController.instance.VerificarNombre(nombrePartido))
        {
            mensajeErrorGuardado.SetText("Nombre inválido".ToUpper(), AppController.Idiomas.Español);
            mensajeErrorGuardado.SetText("Invalid name".ToUpper(), AppController.Idiomas.Ingles);
            mensajeErrorGuardado.Activar();
            Debug.Log("Nombre inválido");
            return;
        }
        else if (equipo.ContienePartido(tipoEntradaDatos, nombrePartido))
        {
            mensajeErrorGuardado.SetText("Nombre existente".ToUpper(), AppController.Idiomas.Español);
            mensajeErrorGuardado.SetText("Existing name".ToUpper(), AppController.Idiomas.Ingles);
            mensajeErrorGuardado.Activar();
            Debug.Log("Nombre existente");
            return;
        }

        Deportes.DeporteEnum deporteActual = equipo.GetDeporte();
        Estadisticas         estEquipo     = new Estadisticas(deporteActual);
        DateTime             fecha         = DateTime.Now;
        int cantPeriodos = relojEntradaDatos.GetCurrentPeriod();

        Partido       _partido = new Partido(nombrePartido, estEquipo, fecha, isPartido, cantPeriodos);
        List <Evento> _eventos = seccionEstadisticas.GetListaEventos();

        _partido.SetListaEventos(_eventos);

        if (deporteActual == Deportes.DeporteEnum.Softball || deporteActual == Deportes.DeporteEnum.Futbol || deporteActual == Deportes.DeporteEnum.Basket || deporteActual == Deportes.DeporteEnum.HockeyCesped || deporteActual == Deportes.DeporteEnum.HockeyPatines || deporteActual == Deportes.DeporteEnum.Rugby || deporteActual == Deportes.DeporteEnum.Handball)
        {
            if (insertarResultado && !resultadoNormal.VerificarInputs())
            {
                mensajeErrorGuardado.SetText("Completar campos de resultado".ToUpper(), AppController.Idiomas.Español);
                mensajeErrorGuardado.SetText("Complete results fields".ToUpper(), AppController.Idiomas.Ingles);
                mensajeErrorGuardado.Activar();
                return;
            }
            resultadoNormal.SetResultado();
            Debug.Log("RES: " + resultadoNormal.GetResultado());
            Debug.Log("PROP: " + resultadoNormal.GetResultadoPropio());
            Debug.Log("CONT: " + resultadoNormal.GetResultadoContrario());
            Debug.Log("PEN PROP: " + resultadoNormal.GetResultadoPenalesPropio());
            Debug.Log("PEN CONT: " + resultadoNormal.GetResultadoPenalesContrario());
            _partido.AgregarResultadoEntradaDatos(resultadoNormal, Partido.TipoResultadoPartido.Normal);
            seccionBanca.GuardarEntradaDato(listaNombres, nombrePartido, tipoEntradaDatos, fecha, resultadoNormal, _eventos, Partido.TipoResultadoPartido.Normal, cantPeriodos);
        }
        else
        {
            if (insertarResultado && !resultadoSets.VerificarInputs())
            {
                mensajeErrorGuardado.SetText("Completar campos de resultado".ToUpper(), AppController.Idiomas.Español);
                mensajeErrorGuardado.SetText("Complete results fields".ToUpper(), AppController.Idiomas.Ingles);
                mensajeErrorGuardado.Activar();
                return;
            }
            resultadoSets.SetResultado();
            _partido.AgregarResultadoEntradaDatos(resultadoSets, Partido.TipoResultadoPartido.Sets);
            seccionBanca.GuardarEntradaDato(listaNombres, nombrePartido, tipoEntradaDatos, fecha, resultadoSets, _eventos, Partido.TipoResultadoPartido.Sets, cantPeriodos);
        }


        //PARA LOS JUGADORES
        seccionBanca.SetFechaEntradaDato(fecha); //para cada jugadorEntradaDato, estadistica.setfecha(fecha)

        //PARA EL EQUIPO
        estEquipo.SetFecha(fecha);
        seccionBanca.AgregarEstadisticasEquipo(estEquipo);
        equipo.GuardarEntradaDato(tipoEntradaDatos, estEquipo, _partido);



        //CanvasController.instance.escenas.Add(1);
        CanvasController.instance.retrocesoPausado = false;
        CanvasController.instance.MostrarPanelAnterior();
        CanvasController.instance.overlayPanel.gameObject.SetActive(true);
        CanvasController.instance.botonDespliegueMenu.SetActive(true);
        Screen.orientation = ScreenOrientation.Portrait;
        Destroy(gameObject);
    }