public void InserirEntidade(float x, float y, int posicaoEntidadeX = -1, int posicaoEntidadeY = -1)
        {
            /* Cria uma nova entidade dado sua posição e sua localização dentro do sprite principal */

            // Retorna as coordenadas ajustadas de uma entidade. Transforma as coordenadas recebidas do mouse para as coordenadas ajustadas no mundo
            Vector2f vec = GetPosicaoAjustada(x, y);

            TipoEntidade tipo;

            if (posicaoEntidadeX == -1)
            {
                posicaoEntidadeX = PosicaoEntidade.X;
            }
            if (posicaoEntidadeY == -1)
            {
                posicaoEntidadeY = PosicaoEntidade.Y;
            }

            // Define se a entidade é tangível ou intágivel
            if ((posicaoEntidadeX == 1 && posicaoEntidadeY == 9) ||
                (posicaoEntidadeX == 3 && posicaoEntidadeY == 9) ||
                (posicaoEntidadeX == 0 && posicaoEntidadeY == 32) ||
                (posicaoEntidadeX == 2 && posicaoEntidadeY == 0) ||
                (posicaoEntidadeX == 3 && posicaoEntidadeY == 0))
            {
                tipo = TipoEntidade.Intangivel;
            }
            else
            {
                tipo = TipoEntidade.Tangivel;
            }

            if (!HaEntidadeAqui(vec.X, vec.Y, tipo))
            {
                // Dimensões de um bloco na textura principal
                int comprimento = (int)(spritePrincipal.Texture.Size.X / Informacoes.qtdEntidades.X);
                int altura      = (int)(spritePrincipal.Texture.Size.Y / Informacoes.qtdEntidades.Y);

                // Encontra e recorta na textura principal a nova textura da entidade baseada na coluna e na linha recebidas
                IntRect rect = new IntRect(posicaoEntidadeX * comprimento, posicaoEntidadeY * altura, comprimento, altura);
                spritePrincipal.TextureRect = rect;
                Sprite s = new Sprite(spritePrincipal);
                s.Origin   = new Vector2f(comprimento / 2, altura / 2);
                s.Position = new Vector2f(vec.X, vec.Y);

                // Uma nova entidade será criada dependendo de qual objeto o jogador selecionou no menu
                if ((posicaoEntidadeX >= 1 && posicaoEntidadeX <= 4) && posicaoEntidadeY == 4)
                {
                    Armadilha a = new Armadilha(s, tipo, TipoArmadilha.Atirador, posicaoEntidadeX, posicaoEntidadeY);
                    EntidadesTangiveis.Add(a);
                    Armadilhas.Add(a);
                }
                else if (posicaoEntidadeX == 4 && posicaoEntidadeY == 3)
                {
                    Armadilha a = new Armadilha(s, tipo, TipoArmadilha.Espinhos, posicaoEntidadeX, posicaoEntidadeY);
                    EntidadesTangiveis.Add(a);
                    Armadilhas.Add(a);
                }
                else if (posicaoEntidadeX == 0 && (posicaoEntidadeY == 4 || posicaoEntidadeY == 5))
                {
                    Mecanismo m = new Mecanismo(s, tipo, posicaoEntidadeX, posicaoEntidadeY);
                    EntidadesTangiveis.Add(m);
                    Mecanismos.Add(m);
                }
                else if (posicaoEntidadeX == 0 && posicaoEntidadeY == 1)
                {
                    Entidade e = new Entidade(s, tipo, posicaoEntidadeX, posicaoEntidadeY);
                    EntidadesTangiveis.Add(e);
                    npcs.Add(e);
                }
                else if (posicaoEntidadeY == 6 && (posicaoEntidadeX == 2 ||
                                                   posicaoEntidadeX == 3 ||
                                                   posicaoEntidadeX == 4))
                {
                    Escada e = new Escada(s, tipo, posicaoEntidadeX, posicaoEntidadeY);
                    EntidadesTangiveis.Add(e);
                    Escadas.Add(e);
                }
                else
                {
                    Entidade aux = new Entidade(s, tipo, posicaoEntidadeX, posicaoEntidadeY);

                    if (tipo == TipoEntidade.Intangivel)
                    {
                        EntidadesIntangiveis.Add(aux);
                    }
                    else
                    {
                        EntidadesTangiveis.Add(aux);
                    }
                }
            }
        }
Esempio n. 2
0
        private void Window_MouseButtonPressed(object sender, MouseButtonEventArgs e)
        {
            /* Eventos quando os botões do mouse são pressionados */

            // Caso o botão esquerdo do mouse seja pressionado
            if (e.Button == Mouse.Button.Left && !bloqueandoAcoes)
            {
                // Caso seja pressionado no menu
                if (Mouse.GetPosition(window).X >= window.Size.X * Informacoes.propViewMundo)
                {
                    Acao botaoPressionado = menu.BotaoPressionado(Mouse.GetPosition(window));
                    acao = botaoPressionado;

                    if (botaoPressionado == Acao.IndicarEntidade)
                    {
                        mundo.GerenciadorEnt.PosicaoEntidade = menu.PosicaoEntidade;
                        acao = Acao.AdicionarObjeto;
                    }

                    if (acao != Acao.GerenciarPropriedades)
                    {
                        menu.ArmadilhaAux = null;
                        menu.AtualizarValores(Acao.Nenhum);
                        mundo.GerenciadorEnt.ApagarQuadradoArmadilhas();
                    }

                    if (acao != Acao.GerenciarConexao)
                    {
                        mundo.ArmadilhaAux = null;
                        mundo.MecanismoAux = null;

                        if (acao != Acao.GerenciarPropriedades)
                        {
                            mundo.GerenciadorEnt.ApagarQuadradoArmadilhas();
                            mundo.GerenciadorEnt.ApagarQuadradoMecanismos();
                        }

                        else
                        {
                            mundo.GerenciadorEnt.ApagarQuadradoMecanismos();
                        }
                    }

                    if (acao == Acao.GerenciarEventos)
                    {
                        gerenciadorArquivos.CarregarEventos();
                    }

                    else if (acao == Acao.Salvar)
                    {
                        gerenciadorArquivos.SalvarMundo(mundo.GerenciadorEnt.EntidadesTangiveis,
                                                        mundo.GerenciadorEnt.EntidadesIntangiveis,
                                                        mundo.GerenciadorEnt.Armadilhas,
                                                        mundo.GerenciadorEnt.Mecanismos,
                                                        mundo.GerenciadorEnt.Escadas);
                    }
                    else if (acao == Acao.Carregar)
                    {
                        zoom = 5;
                        AplicarZoomMundo();
                        viewMundo.Center = new Vector2f(0, 0);
                        gerenciadorArquivos.CarregarMundo(mundo.GerenciadorEnt);
                    }
                }

                // Caso o botão seja pressionado no mundo
                else
                {
                    switch (acao)
                    {
                    // Gerencia as propriedades de uma armadilha
                    case Acao.GerenciarPropriedades:
                        menu.ArmadilhaAux = mundo.GerenciadorEnt.SelecionarArmadilha(posMouseMundo.X, posMouseMundo.Y);
                        mundo.GerenciadorEnt.ApagarQuadradoArmadilhas();

                        if (menu.ArmadilhaAux != null)
                        {
                            menu.ArmadilhaAux.Selecionado = true;
                        }

                        menu.AtualizarValores(Acao.Nenhum);
                        break;

                    // Cria uma conexão entre duas entidades
                    case Acao.GerenciarConexao:
                        Armadilha aAux = mundo.GerenciadorEnt.SelecionarArmadilha(posMouseMundo.X, posMouseMundo.Y);
                        Mecanismo mAux = mundo.GerenciadorEnt.SelecionarMecanismo(posMouseMundo.X, posMouseMundo.Y);
                        Escada    eAux = mundo.GerenciadorEnt.SelecionarEscada(posMouseMundo.X, posMouseMundo.Y);

                        if (eAux == null)
                        {
                            mundo.EscadaAux1 = null;
                            mundo.EscadaAux2 = null;
                            mundo.GerenciadorEnt.ApagarQuadradoEscadas();

                            if (aAux != null && mAux == null)
                            {
                                mundo.ArmadilhaAux = aAux;
                            }

                            else if (aAux == null && mAux != null)
                            {
                                mundo.GerenciadorEnt.ApagarQuadradoMecanismos();
                                mundo.GerenciadorEnt.ApagarQuadradoArmadilhas();
                                mundo.MecanismoAux             = mAux;
                                mundo.MecanismoAux.Selecionado = true;
                                mundo.MecanismoAux.ApagarQuadradoArmadilhas();
                                mundo.MecanismoAux.DesenharQuadradoArmadilhas();
                            }

                            else
                            {
                                mundo.ArmadilhaAux = null;
                                mundo.MecanismoAux = null;
                                mundo.GerenciadorEnt.ApagarQuadradoArmadilhas();
                                mundo.GerenciadorEnt.ApagarQuadradoMecanismos();
                            }

                            if (mundo.ArmadilhaAux != null && mundo.MecanismoAux != null)
                            {
                                mundo.MecanismoAux.IncluirArmadilha(mundo.ArmadilhaAux);
                                mundo.MecanismoAux.DesenharQuadradoArmadilhas();
                            }
                        }
                        else
                        {
                            if (mundo.EscadaAux1 == null)
                            {
                                mundo.EscadaAux1 = eAux;

                                mundo.EscadaAux1.Selecionado = true;

                                if (mundo.EscadaAux1.EscadaCon != null)
                                {
                                    mundo.EscadaAux2             = mundo.EscadaAux1.EscadaCon;
                                    mundo.EscadaAux2.Selecionado = true;
                                }
                            }
                            else if (mundo.EscadaAux1 != null && mundo.EscadaAux2 == null)
                            {
                                mundo.EscadaAux2             = eAux;
                                mundo.EscadaAux1.EscadaCon   = mundo.EscadaAux2;
                                mundo.EscadaAux2.EscadaCon   = mundo.EscadaAux1;
                                mundo.EscadaAux2.Selecionado = true;
                            }
                        }

                        break;

                    // Carrega um novo diálogo e o relaciona com um NPC
                    case Acao.GerenciarDialogos:
                        if (mundo.GerenciadorEnt.HaNPCAqui(posMouseMundo.X, posMouseMundo.Y))
                        {
                            gerenciadorArquivos.CarregarDialogo(posMouseMundo);
                        }
                        break;

                    case Acao.GerenciarMusicas:

                        // Cria a área ocupada por uma música ou carrega o título da músic aa partir de um arquivo
                        if (mundo.MusicaAux == null)
                        {
                            Musica auxM = mundo.HaMusicaAqui(new Vector2f(posMouseMundo.X, posMouseMundo.Y));
                            if (auxM == null)
                            {
                                mundo.MusicaAux = new Musica()
                                {
                                    C1           = new Vector2f(posMouseMundo.X, posMouseMundo.Y),
                                    C1Preenchido = true
                                };
                            }
                            else
                            {
                                gerenciadorArquivos.CarregarMusica(auxM);
                            }
                        }
                        else
                        {
                            if (!mundo.MusicaAux.C2Preenchido)
                            {
                                mundo.MusicaAux.C2           = new Vector2f(posMouseMundo.X, posMouseMundo.Y);
                                mundo.MusicaAux.C2Preenchido = true;
                                mundo.MusicaAux.CriarRetangulo();
                                mundo.InserirMusica();
                                mundo.MusicaAux = null;
                            }
                        }
                        break;
                    }
                }
            }

            // Caso o botão direito do mouse seja pressioanado
            else if (e.Button == Mouse.Button.Right && !bloqueandoAcoes)
            {
                // Caso seja pressionado no mundo
                if (Mouse.GetPosition(window).X <= window.Size.X * Informacoes.propViewMundo)
                {
                    switch (acao)
                    {
                    // Exclui a coneão entre duas entidades
                    case Acao.GerenciarConexao:
                        if (mundo.MecanismoAux != null)
                        {
                            Armadilha armadilha = mundo.GerenciadorEnt.SelecionarArmadilha(posMouseMundo.X, posMouseMundo.Y);

                            if (armadilha != null)
                            {
                                armadilha.Selecionado = false;
                                mundo.MecanismoAux.ExcluirArmadilha(armadilha);
                            }
                        }
                        Escada escada = mundo.GerenciadorEnt.SelecionarEscada(posMouseMundo.X, posMouseMundo.Y);
                        if (escada != null)
                        {
                            escada.Selecionado = false;
                            escada.EscadaCon   = null;
                            mundo.GerenciadorEnt.ExcluirConecaoEscada(escada);
                        }
                        break;

                    // Exclui uma música
                    case Acao.GerenciarMusicas:
                        Musica auxM = mundo.HaMusicaAqui(new Vector2f(posMouseMundo.X, posMouseMundo.Y));
                        if (auxM != null)
                        {
                            mundo.ExcluirMusica(auxM);
                        }

                        break;
                    }
                }
            }
        }