示例#1
0
        public Ponto[,] Read()
        {
            List<Ponto> pontos = new List<Ponto>();
            Ponto[,] matrizLabirinto = null;

            FileInfo file = new FileInfo(this.NomeArquivo);

            if (file.Exists)
            {
                int linha = 0;
                int coluna = 0;

                using (StreamReader sr = new StreamReader(file.FullName))
                {
                    while (!sr.EndOfStream)
                    {
                        char[] line = sr.ReadLine().ToCharArray();

                        foreach (char item in line)
                        {
                            TipoPonto tipoPonto;

                            switch (item.ToString().ToUpper())
                            {
                                case "#":
                                    tipoPonto = TipoPonto.Parede;
                                    break;
                                case ".":
                                    tipoPonto = TipoPonto.Campo;
                                    break;
                                case "I":
                                    tipoPonto = TipoPonto.Inicio;
                                    break;
                                case "F":
                                    tipoPonto = TipoPonto.Fim;
                                    break;
                                default:
                                    tipoPonto = TipoPonto.Parede;
                                    break;
                            }

                            pontos.Add(new Ponto(linha, coluna, tipoPonto));
                            coluna++;
                        }
                        linha++;
                        coluna = 0;
                    }
                }

                int linhas = pontos[pontos.Count - 1].Linha + 1;
                int colunas = pontos[pontos.Count - 1].Coluna + 1;

                matrizLabirinto = new Ponto[linhas, colunas];
                pontos.ForEach(a => matrizLabirinto[a.Linha, a.Coluna] = a);
            }

            return matrizLabirinto;
        }
        public void ValidaLeituraPontoInicio()
        {
            Ponto[,] matrizLabirinto = FileInstance.Read();
            Ponto expected = new Ponto(0, 33, TipoPonto.Inicio);

            Assert.AreEqual(expected.StatusAtualPonto, matrizLabirinto[0, 33].StatusAtualPonto);
            Assert.AreEqual(expected.Linha, matrizLabirinto[0, 33].Linha);
            Assert.AreEqual(expected.Tipo, matrizLabirinto[0, 33].Tipo);
            Assert.AreEqual(expected.Coluna, matrizLabirinto[0, 33].Coluna);
        }
        public void ValidaLeituraPontoFim()
        {
            Ponto[,] matrizLabirinto = FileInstance.Read();
            Ponto expected = new Ponto(6, 1, TipoPonto.Fim);

            Assert.AreEqual(expected.StatusAtualPonto, matrizLabirinto[6, 1].StatusAtualPonto);
            Assert.AreEqual(expected.Linha, matrizLabirinto[6, 1].Linha);
            Assert.AreEqual(expected.Tipo, matrizLabirinto[6, 1].Tipo);
            Assert.AreEqual(expected.Coluna, matrizLabirinto[6, 1].Coluna);
        }
示例#4
0
        public bool PodeMover(Movimento movimento, Ponto ponto)
        {
            if (movimento.Equals(Movimento.Subir))
            {
                if (ponto.Linha - 1 >= 0)
                {
                    Ponto proximoPonto = this.Pontos[ponto.Linha - 1, ponto.Coluna];

                    if (proximoPonto.Tipo.Equals(TipoPonto.Campo) || proximoPonto.Tipo.Equals(TipoPonto.Fim) || proximoPonto.Tipo.Equals(TipoPonto.Inicio))
                        return true;
                }
                return false;
            }
            if (movimento.Equals(Movimento.Descer))
            {
                if (ponto.Linha + 1 <= this.NumLinhas - 1)
                {
                    Ponto proximoPonto = this.Pontos[ponto.Linha + 1, ponto.Coluna];

                    if (proximoPonto.Tipo.Equals(TipoPonto.Campo) || proximoPonto.Tipo.Equals(TipoPonto.Fim) || proximoPonto.Tipo.Equals(TipoPonto.Inicio))
                        return true;
                }
                return false;
            }
            if (movimento.Equals(Movimento.Direita))
            {
                if (ponto.Coluna + 1 <= this.NumColunas - 1)
                {
                    Ponto proximoPonto = this.Pontos[ponto.Linha, ponto.Coluna + 1];

                    if (proximoPonto.Tipo.Equals(TipoPonto.Campo) || proximoPonto.Tipo.Equals(TipoPonto.Fim) || proximoPonto.Tipo.Equals(TipoPonto.Inicio))
                        return true;
                }
                return false;
            }
            else if (movimento.Equals(Movimento.Esquerda))
            {
                if (ponto.Coluna - 1 >= 0)
                {
                    Ponto proximoPonto = this.Pontos[ponto.Linha, ponto.Coluna - 1];

                    if (proximoPonto.Tipo.Equals(TipoPonto.Campo) || proximoPonto.Tipo.Equals(TipoPonto.Fim) || proximoPonto.Tipo.Equals(TipoPonto.Inicio))
                        return true;

                }
                return false;
            }
            return false;
        }
示例#5
0
        public List<Ponto> RetornaPontosAdjacentes(Ponto p)
        {
            List<Ponto> listaPontosAdjacentes = new List<Ponto>();

            if (this.PodeMover(Movimento.Descer, p))
                listaPontosAdjacentes.Add(this.Pontos[p.Linha + 1, p.Coluna]);
            if (this.PodeMover(Movimento.Direita, p))
                listaPontosAdjacentes.Add(this.Pontos[p.Linha, p.Coluna + 1]);
            if (this.PodeMover(Movimento.Esquerda, p))
                listaPontosAdjacentes.Add(this.Pontos[p.Linha, p.Coluna - 1]);
            if (this.PodeMover(Movimento.Subir, p))
                listaPontosAdjacentes.Add(this.Pontos[p.Linha - 1, p.Coluna]);

            return listaPontosAdjacentes;
        }
示例#6
0
        public void Save(Ponto[,] pontosLabirinto)
        {
            FileInfo file = new FileInfo(this.NomeArquivo);

            if (file.Exists)
                file.Delete();

            using (StreamWriter sw = new StreamWriter(file.FullName))
            {
                int linha = 0;
                foreach (Ponto p in pontosLabirinto)
                {
                    if (linha != p.Linha)
                        sw.WriteLine();
                    linha = p.Linha;

                    switch (p.Tipo)
                    {
                        case TipoPonto.Parede:
                            sw.Write("#");
                            break;
                        case TipoPonto.Campo:
                            sw.Write(".");
                            break;
                        case TipoPonto.Inicio:
                            sw.Write("I");
                            break;
                        case TipoPonto.Fim:
                            sw.Write("F");
                            break;
                        default:
                            sw.Write("#");
                            break;
                    }
                }
            }
        }