Exemple #1
0
        public ActionResult Adiciona(Comodo comodo)
        {
            ComodoDAO dao = new ComodoDAO();

            dao.Adiciona(comodo);
            return(RedirectToAction("Index"));
        }
Exemple #2
0
        public ActionResult Cadastrar(Comodo model)
        {
            try {
                if (model == null)
                {
                    throw new Exception("Preencha o nome do cômodo");
                }

                if (model.Nome == null)
                {
                    throw new Exception("Preencha o nome do cômodo");
                }

                using (var service = new Service <Comodo>())
                {
                    var userId = Convert.ToInt32(Session["UserId"]);
                    model.UsuarioId = userId;

                    service.Save(model);
                }

                TempData["Sucesso"]  = true;
                TempData["Mensagem"] = "Comodo " + model.Nome + " cadastrado com sucesso";
            }
            catch (Exception exception) {
                TempData["Erro"]     = true;
                TempData["Mensagem"] = exception.Message;
            }

            var view = RedirectToAction("Index");

            view.ExecuteResult(ControllerContext);

            return(null);
        }
Exemple #3
0
        public void atualizarComodo()
        {
            if (atualizando)
            {
                return;
            }

            atualizando = true;

            var comodo     = new Comodo();
            var controller = new ComodoController();

            var index       = gridComodos.CurrentCell.RowIndex;
            var id          = gridComodos.Rows[index].Cells["ID"].Value.ToString();
            var nome        = gridComodos.Rows[index].Cells["Nome"].Value.ToString();
            var largura     = gridComodos.Rows[index].Cells["Largura"].Value.ToString();
            var comprimento = gridComodos.Rows[index].Cells["Comprimento"].Value.ToString();

            int aux;

            if (!int.TryParse(id, out aux))
            {
                return;
            }
            comodo.Id = int.Parse(id);
            if (comodo.ValidarCampos(nome, largura, comprimento))
            {
                controller.AtualizarComodo(comodo);
            }
            else
            {
                CarregarGrids();
            }
            atualizando = false;
        }
        public void Excluir(int id)
        {
            AndromedaContext ctx = new AndromedaContext();
            Comodo           com = ctx.Comodo.Find(id);

            ctx.Entry(com).State = System.Data.Entity.EntityState.Deleted;
            ctx.SaveChanges();
        }
        //[HttpPost]
        //[ValidateAntiForgeryToken]
        public ActionResult Recuperar(int id)
        {
            Comodo comodo = db.Comodos.Find(id);

            comodo.Ativo = true;
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
        public ActionResult DeleteConfirmed(int id)
        {
            Comodo comodo = db.Comodos.Find(id);

            comodo.Ativo = false;
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
        public ActionResult Index([Bind("Largura,Altura,Profundidade")] Comodo comodo)
        {
            Double quantidadeEmlitros = 0;

            quantidadeEmlitros = calculadora.calcularLitragem(comodo);

            return(RedirectToRoute(new { Controller = "CalculadoraPintura", Action = "QuantidadeLitros", litros = quantidadeEmlitros }));
        }
Exemple #8
0
 public void Adiciona(Comodo comodos)
 {
     using (var context = new BaseContext())
     {
         context.Comodos.Add(comodos);
         context.SaveChanges();
     }
 }
Exemple #9
0
        private void CadastrarItem_Click(object sender, EventArgs e)
        {
            var comodo = new Comodo();

            var comodoController = new ComodoController();

            comodo.ValidarCampos(txtNome.Text, numLargura.Text, numComprimento.Text);

            comodoController.CadastrarComodo(comodo);

            this.Close();
        }
Exemple #10
0
    void AlterarLuzApagada(bool luzApagada, MeshRenderer luzComodoAtual = null)
    {
        if (!luzComodoAtual)
        {
            luzComodoAtual = personagem.luzComodoAtual;
        }

        Comodo comodo = luzComodoAtual.transform.parent.GetComponent <Comodo>();

        comodo.luzApagada = luzApagada;

        comodo.AlterarLuz(luzApagada);
    }
        public ActionResult Edit(Comodo comodo)
        {
            if (ModelState.IsValid)
            {
                db.Entry(comodo).State = System.Data.Entity.EntityState.Modified;
                db.SaveChanges();


                return(RedirectToAction("Index"));
            }

            return(View(comodo));
        }
Exemple #12
0
    bool CalcularSairComodo(GameObject comodo)
    {
        Comodo comodoScript         = comodo.GetComponent <Comodo>();
        float  quantidadeNpcsComodo = comodoScript.npcsComodo.Count;

        if (comodoScript.limiteNpcs && quantidadeNpcsComodo > 0)
        {
            float chanceComodo             = Random.Range(1, 100);
            float chanceNpcAdicionalComodo = Mathf.Max(1, jogo.chanceNpcAdicionalComodo - (quantidadeNpcsComodo * 2));

            if (chanceComodo > chanceNpcAdicionalComodo)
            {
                return(false);
            }
        }

        return(true);
    }
        public ActionResult Edit(int?id)
        {
            if (id.HasValue != true)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            Comodo comodo = db.Comodos.Find(id);



            if (comodo == null)
            {
                return(HttpNotFound());
            }


            return(View(comodo));
        }
        public ActionResult Create(Comodo comodo)
        {
            if (ModelState.IsValid)
            {
                if (Validacao(comodo) == null)
                {
                    comodo.Ativo = true;
                    db.Comodos.Add(comodo);
                    db.SaveChanges();
                    RedirectToAction("Index");
                    return(View(comodo));
                }
                else
                {
                    ViewBag.Erro = "Já existem um comodo com esse nome";
                }
            }

            return(View());
        }
Exemple #15
0
        public void CadastrarComodo(Comodo Comodo)
        {
            var dbContext = new DbContext();

            try
            {
                var query = new StringBuilder();

                query.AppendLine($"INSERT INTO COMODOS ");
                query.AppendLine($"(NOME ,LARGURA ,COMPRIMENTO, DATACRIACAO)");
                query.AppendLine($"VALUES");
                query.AppendLine($"('{Comodo.Nome}', '{Comodo.Largura}', '{Comodo.Comprimento}', '{DateTime.Now:s}')");

                dbContext.ExecuteQuery(query.ToString());
            }
            catch
            {
                throw;
            }
        }
Exemple #16
0
        public void AtualizarComodo(Comodo Comodo)
        {
            var dbContext = new DbContext();

            try
            {
                var query = new StringBuilder();

                query.AppendLine($"UPDATE COMODOS SET ");
                query.AppendLine($"NOME = '{Comodo.Nome}',");
                query.AppendLine($"LARGURA = '{Comodo.Largura}',");
                query.AppendLine($"COMPRIMENTO = '{Comodo.Comprimento}'");
                query.AppendLine($"WHERE ID = {Comodo.Id}");

                dbContext.ExecuteQuery(query.ToString());
            }
            catch
            {
                throw;
            }
        }
Exemple #17
0
    void MoverParaWaypoint(bool variarPosicao = true, bool ignorarAlteracoes = false, GameObject objetoDirecao = null)
    {
        AdicionarDebugInfo("MoverParaWaypoint: " + waypointAtual.name);

        Waypoint   waypointScript = waypointAtual.GetComponent <Waypoint>();
        GameObject comodoWaypoint = waypointScript.comodo;
        Comodo     comodo         = comodoWaypoint.GetComponent <Comodo>();

        npc.DefinirComodoAtual(comodoWaypoint);

        /*if (modificadorTensaoLiberado && waypointAnterior != waypointAtual && personagem.comodoAtual)
         * {
         *      if (comodo.luzApagada)
         *              AumentarTensao("Luz - " + personagem.comodoAtual.name);
         *      else
         *              ReduzirTensao("Luz - " + personagem.comodoAtual.name);
         * }*/

        Vector3 posicao = waypointAtual.transform.position;

        if (variarPosicao)
        {
            posicao = VariarPosicao();
        }

        AtualizarDirecao(posicao);
        AtualizarAnimacao("movimento", true);

        duracaoMovimento = Vector3.Distance(transform.parent.position, posicao) / (chamarExorcista ? 1.5f : 1f);

        iTween.MoveTo(transform.parent.gameObject, iTween.Hash("position", posicao, "easeType", iTween.EaseType.linear, "time", duracaoMovimento));

        StartCoroutine(AlterarEmMovimento());

        if (objetoDirecao)
        {
            StartCoroutine(AtualizarDirecaoObjeto(objetoDirecao));
        }
    }
Exemple #18
0
        public Comodo ObterComodo(int id)
        {
            Comodo retorno = null;

            var dbContext = new DbContext();

            try
            {
                var query = $"SELECT * FROM COMODOS WHERE ID = {id}";

                var dt = dbContext.ExecuteSelect(query);

                var lista = TransformarDataTable(dt);

                retorno = lista.FirstOrDefault();
            }
            catch
            {
                throw;
            }

            return(retorno);
        }
Exemple #19
0
        public ActionResult ComodosSave(Comodo comodo)
        {
            try
            {
                using (var service = new Service <Comodo>())
                {
                    service.Save(comodo);

                    TempData["Sucesso"]  = true;
                    TempData["Mensagem"] = "Cadastrado com sucesso.";
                }
            }
            catch (Exception ex)
            {
                TempData["Erro"]     = true;
                TempData["Mensagem"] = "Não foi possível cadastrar. Erro: " + ex.Message;
            }

            var view = RedirectToAction("Aparelhos");

            view.ExecuteResult(ControllerContext);

            return(null);
        }
Exemple #20
0
    void Movimentar()
    {
        if ((tipoReacao == "objeto" && emMovimento) ||
            (tipoReacao == "movimento" && !emMovimento) ||
            (tipoReacao == "tensao") && tensaoAtual == 0)
        {
            DesativarBalaoReacao();
        }

        if (caminho.Count() > 0 && !emMovimento)
        {
            if (movimentoLiberado)
            {
                waypointAnterior = waypointAtual;
                waypointAtual    = caminho[0];
                AdicionarDebugInfo("Processando caminho: " + waypointAnterior.name + " para " + waypointAtual.name);
                caminho.RemoveAt(0);

                MoverParaWaypoint(caminho.Count() == 0 ? true : false, true, caminho.Count() == 0 ? waypointAtual.transform.parent.gameObject : null);

                if (saindo && caminho.Count == 0)
                {
                    AdicionarDebugInfo("NpcSaiu chamado em (saindo && caminho.Count == 0)");
                    StartCoroutine(NpcSaiu());
                    return;
                }
                else if (chamarExorcista && caminho.Count == 0)
                {
                    bool         checarChamarExorcista = true;
                    GameObject[] npcs = GameObject.FindGameObjectsWithTag("NPC");
                    foreach (GameObject npc in npcs)
                    {
                        if (npc != gameObject)
                        {
                            NPC npcScript = npc.GetComponent <NPC>();
                            if (npcScript.chamarExorcista)
                            {
                                checarChamarExorcista = false;
                                break;
                            }
                        }
                    }

                    if (checarChamarExorcista)
                    {
                        StartCoroutine(PrepararExorcista());
                    }
                    else
                    {
                        chamarExorcista = false;
                    }

                    AdicionarDebugInfo("NpcSaiu chamado em (saindo && caminho.Count == 0)");
                    StartCoroutine(NpcSaiu());
                }
            }
            else
            {
                movimentoLiberado = true;
            }

            return;
        }

        if (movimentar)
        {
            if (movimentoLiberado)
            {
                float chance = Random.Range(1, 100);

                if (chamadoComodo)
                {
                    chance = chanceSairComodo;
                }

                if (chance <= chanceSairJogo && waypointAtual != jogo.waypointInicial)
                {
                    caminho = Waypoint.DefinirCaminho(waypointAtual, jogo.waypointInicial, true);
                    saindo  = true;
                }
                else if (chance <= chanceSairComodo)
                {
                    GameObject comodoSelecionado = null;
                    if (chamadoComodo)
                    {
                        comodoSelecionado = chamadoComodo;
                        chamadoComodo     = null;
                    }
                    else
                    {
                        List <GameObject> comodos = Comodo.PegarComodos();

                        Dictionary <GameObject, float> comodosDistancia = new Dictionary <GameObject, float>();

                        foreach (GameObject comodo in comodos)
                        {
                            if (comodo != npc.comodoAtual && !comodo.GetComponent <Comodo>().luzApagada)
                            {
                                comodosDistancia.Add(comodo, Vector3.Distance(transform.position, comodo.transform.position));
                            }
                        }

                        if (comodosDistancia.Count > 0)
                        {
                            var comodosDistanciaOrdenados = from pair in comodosDistancia
                                                            orderby pair.Value ascending
                                                            select pair;

                            var comodosProximos = comodosDistanciaOrdenados.ToList();

                            int maxComodos = Mathf.Min(2, comodosProximos.Count());

                            List <GameObject> comodosVisitar = new List <GameObject>();

                            for (int i = 0; i < maxComodos; i++)
                            {
                                comodosVisitar.Add(comodosProximos.First().Key);
                                comodosProximos.RemoveAt(0);
                            }

                            comodoSelecionado = comodosVisitar.PickRandom();
                        }
                    }

                    if (comodoSelecionado)
                    {
                        if (!CalcularSairComodo(comodoSelecionado))
                        {
                            return;
                        }

                        List <GameObject> waypoints = Waypoint.PegarWaypoints(comodoSelecionado, true);

                        Dictionary <GameObject, float> waypointsDistancia = new Dictionary <GameObject, float>();

                        foreach (GameObject waypoint in waypoints)
                        {
                            waypointsDistancia.Add(waypoint, Vector3.Distance(transform.position, waypoint.transform.position));
                        }

                        var waypointsDistanciaOrdenados = from pair in waypointsDistancia
                                                          orderby pair.Value ascending
                                                          select pair;

                        var waypointsProximos = waypointsDistanciaOrdenados.ToList();

                        int maxWaypoints = Mathf.Min(3, waypointsProximos.Count());

                        List <GameObject> waypointsSelecionados = new List <GameObject>();

                        for (int i = 0; i < maxWaypoints; i++)
                        {
                            waypointsSelecionados.Add(waypointsProximos.First().Key);
                            waypointsProximos.RemoveAt(0);
                        }

                        if (waypointsSelecionados.Count() > 0)
                        {
                            GameObject waypointSelecionado = waypointsSelecionados.PickRandom();

                            caminho = Waypoint.DefinirCaminho(waypointAtual, waypointSelecionado, true);
                        }
                    }
                }
                else if (chance <= chanceObjetoAtrair)
                {
                    Comodo            comodo        = waypointAtual.GetComponent <Waypoint>().comodo.GetComponent <Comodo>();
                    List <GameObject> objetosComodo = comodo.objetosComodo;

                    Dictionary <GameObject, float> objetosDistancia = new Dictionary <GameObject, float>();

                    foreach (GameObject objeto in objetosComodo)
                    {
                        if (!objetosVisitados.Contains(objeto))
                        {
                            objetosDistancia.Add(objeto, Vector3.Distance(objeto.transform.position, waypointAtual.transform.position));
                        }
                    }

                    if (objetosDistancia.Count() > 0)
                    {
                        var objetosDistanciaOrdenados = from pair in objetosDistancia
                                                        orderby pair.Value ascending
                                                        select pair;

                        var objetosProximos = objetosDistanciaOrdenados.ToList();

                        int maxObjetos = Mathf.Min(3, objetosProximos.Count());

                        List <GameObject> objetosVisitar = new List <GameObject>();

                        for (int i = 0; i < maxObjetos; i++)
                        {
                            objetosVisitar.Add(objetosProximos.First().Key);
                            objetosProximos.RemoveAt(0);
                        }

                        GameObject visitarObjeto = objetosVisitar.PickRandom(1).First();

                        objetosVisitados.Add(visitarObjeto);

                        GameObject waypointChildren = null;
                        foreach (Transform child in visitarObjeto.transform)
                        {
                            if (child.CompareTag("Waypoint"))
                            {
                                waypointChildren = child.gameObject;
                                break;
                            }
                        }

                        if (waypointChildren)
                        {
                            caminho = Waypoint.DefinirCaminho(waypointAtual, waypointChildren, true);

                            tipoReacao        = "objeto";
                            interagindoObjeto = true;
                            reacaoLiberada    = true;
                        }
                    }
                    else
                    {
                        //objetosVisitados = new List<GameObject>();

                        // Colocar uma chance de zerar os objetos visitados no cômodo
                        // Criar uma lista de objetos visitados dependendo do cômodo em questão
                    }
                }
                else if (chance <= chanceWaypointAleatorioComodo)
                {
                    bool waypointDisponivel = false;
                    List <GameObject> waypointsDisponiveis = Waypoint.PegarWaypoints(npc.comodoAtual, true);

                    while (!waypointDisponivel && waypointsDisponiveis.Count > 0)
                    {
                        GameObject waypoint = waypointsDisponiveis.PickRandom();

                        if (!waypoint.GetComponent <Waypoint>().travarMovimento)
                        {
                            waypointDisponivel = true;
                            caminho            = Waypoint.DefinirCaminho(waypointAtual, waypoint, true);
                        }
                        else
                        {
                            waypointsDisponiveis.Remove(waypoint);
                        }
                    }
                }
                else
                {
                    AdicionarDebugInfo("Ir para waypoint adjacente.");
                    waypointAnterior = waypointAtual;

                    List <GameObject> waypointsDisponiveis = waypointAtual.GetComponent <Waypoint>().waypointsDisponiveis.ToList();

                    if (waypointsDisponiveis.Count == 0)
                    {
                        waypointsDisponiveis = Waypoint.PegarWaypoints(personagem.comodoAtual);
                    }

                    bool comodoDisponivel = false;

                    while (!comodoDisponivel && waypointsDisponiveis.Count > 0)
                    {
                        GameObject waypointSelecionado = waypointsDisponiveis[Random.Range(0, waypointsDisponiveis.Count)];
                        Waypoint   waypointScript      = waypointSelecionado.GetComponent <Waypoint>();
                        GameObject comodoWaypoint      = waypointScript.comodo;

                        bool luzApagada = false;
                        if (comodoWaypoint)
                        {
                            luzApagada = comodoWaypoint.GetComponent <Comodo>().luzApagada;
                        }

                        bool checarNpcComodo = true;
                        if (comodoWaypoint != npc.comodoAtual)
                        {
                            AdicionarDebugInfo("Calcular para Sair do Cômodo");
                            checarNpcComodo = CalcularSairComodo(comodoWaypoint);
                        }

                        if (checarNpcComodo && !waypointScript.travarMovimento && (waypointScript.objeto || !luzApagada))
                        {
                            comodoDisponivel = true;
                            AdicionarDebugInfo("comodoDisponivel");
                            waypointAtual = waypointSelecionado;
                            break;
                        }
                        else
                        {
                            waypointsDisponiveis.Remove(waypointSelecionado);
                        }

                        AdicionarDebugInfo("waypointsDisponiveis.Count: " + waypointsDisponiveis.Count);
                    }

                    AdicionarDebugInfo("waypointAtual.name: " + waypointAtual.name + " - waypointAnterior.name: " + waypointAnterior.name);

                    MoverParaWaypoint();
                }
            }
            else if (!emMovimento)
            {
                if (waypointAtual.GetComponent <Waypoint>().movimentoAutomatico)
                {
                    List <GameObject> waypointsDisponiveis = waypointAtual.GetComponent <Waypoint>().waypointsDisponiveis;
                    foreach (GameObject waypoint in waypointsDisponiveis)
                    {
                        if (waypoint.name != waypointAnterior.name)
                        {
                            bool       liberado       = false;
                            GameObject checarWaypoint = waypoint;
                            while (!liberado)
                            {
                                Waypoint waypointScript = checarWaypoint.GetComponent <Waypoint>();
                                if (waypointScript.movimentoAutomatico)
                                {
                                    foreach (GameObject wp in waypointScript.waypointsDisponiveis)
                                    {
                                        if (wp.name != checarWaypoint.name)
                                        {
                                            checarWaypoint = wp;
                                        }
                                    }
                                }
                                else
                                {
                                    if (CalcularSairComodo(waypointScript.comodo))
                                    {
                                        liberado = true;
                                    }

                                    break;
                                }
                            }

                            if (liberado)
                            {
                                waypointAnterior = waypointAtual;
                                waypointAtual    = waypoint;
                                MoverParaWaypoint();
                                break;
                            }
                        }
                    }
                }
                else if (!liberacaoIniciada)
                {
                    StartCoroutine(LiberacaoMovimento());
                }
                else if (interagindoObjeto)
                {
                    StartCoroutine(AtualizarAnimacao("foto", true, 2f));
                    interagindoObjeto = false;
                }
            }
        }
        else if (objetoInteracao && atualizarDirecaoAposMovimento && !emMovimento)
        {
            AtualizarDirecao(objetoInteracao.transform.position);
            atualizarDirecaoAposMovimento = false;
        }
    }
 public Comodo Validacao(Comodo comodo)
 {
     return(db.Comodos.FirstOrDefault(x => x.NomeComodo.Equals(comodo.NomeComodo)));
 }