Fazia tempo que não postavamos nenhuma novidade, agora também temos algumas boas, estamos chegando mais perto de um demo do jogo de tactics rpg agora que fizemos as técnicas funcionarem no jogo (http://bit.ly/jGuA7T) e agora temos algumas funções básicas do Mapa funcionando.

Get the Flash Player to see this player.

Terminando as novidades, nesse final de semana depois de termos a primeira versão do enredo em mãos definimos qual será o nome do jogo: Black Amber (@BlackAmberGame).

Para quem tem acompanhado no twitter viu que essa semana conseguimos implementar um algoritmo para descobrir a área que o personagem poderia se mover. Nesse calculo utilizamos o Taxicab-Geometry (ou Manhattan Distance), esse algoritmo serve para calcular a menor distância a ser percorrida entre dois pontos, quem quiser saber mais sobre esse algoritmo pode visitar a página do Wikipedia http://bit.ly/hsxECh ou ainda pode olhar o artigo do Chip Reinhardt da Stevensville High School, Taxicab Geometry: History and Applications, http://bit.ly/gOTVOX.

Agora voltando ao nosso problema, no começo da semana comecei a pensar em maneiras de calcular a área em que os personagens poderiam se mover, até o momento eu somente sabia quantos passos cada um poderia fazer e tinha todos os blocos do campo. Um pouco para minha sorte o Jonathan mandou eu dar uma olhada no Taxicab Geometry que era bem capaz que ele resolvesse o problema, após algum tempo de estudo passei a entender como poderia ser feito e passei a desenhar a solução que utilizaria para calcular a área.

Minha solução consiste em 3 passos, o primeiro eu pego o ponto onde se encontra o personagem e calculo os limites maximo e minimos onde ele possa chegar:
(obs.: no jogo o plano é diferente do normal, o Y representa altura, então o ‘plano 2D’ fica Z e X)


            /*
             * Calcula os pontos maximos e minimos onde talvez seja posivel chegar.
             * Todos os maximos sao calculados pelo ponto central mais o resultado da multiplicacao 
             * entre o tamanho do tile e a distancia onde se pode chegar, enquanto os minimos sao achados
             * pela subtracao desses valores
             */
            float pontoMaxX = pontoCentral.X + (TamanhoTile * distanciaMaxima);
            float pontoMinX = pontoCentral.X - (TamanhoTile * distanciaMaxima);
            float pontoMaxZ = pontoCentral.Z + (TamanhoTile * distanciaMaxima);
            float pontoMinZ = pontoCentral.Z - (TamanhoTile * distanciaMaxima);

Então ele pega o ponto onde está o personagem (ponto central) em cada eixo e faz uma soma com o resultado da multiplicação entre o Tamanho do Tile (no caso o tamanho é sempre 6) e o numero máximo de passos para descobrir os limites máximos e depois faz a subtração para descobrir o limite mínimo assim criando um quadro imaginário onde talvez o personagem possa se mover:

            /*
             * Monta uma lista de Tiles onde possa se mover
             */
            List<Tile> tilesPossiveisList = tiles.FindAll(
                                                delegate(Tile tile) 
                                                {
                                                    bool retorno = false;
                                                    /*
                                                     * Verifica se o tile esta dentro dos limites onde o personagem pode se mover
                                                     */
                                                    if (!tile.Blocked && tile.Position.X >= pontoMinX && tile.Position.X <= pontoMaxX &&
                                                        tile.Position.Z >= pontoMinZ && tile.Position.Z <= pontoMaxZ)
                                                    {
                                                        /*
                                                         * Verifica quais os tiles estao na distancia correta usando a distancia de Manhattan
                                                         */
                                                        int distanciaEntrePontos = CalculaDistanciaManhattan(new Vector2(pontoCentral.Z, pontoCentral.X), new Vector2(tile.Position.Z, tile.Position.X));
                                                        retorno = (distanciaEntrePontos >= distanciaMinima && distanciaEntrePontos <= distanciaMaxima);
                                                    }
                                                    return retorno;
                                                }
                                            );

Agora já limitamos os tiles que precisamos verificar, eis que chega a hora de ver em quais tiles o personagem pode realmente se mover, então passamos pela lista de tiles verficando quais estão dentro do limite e não estão bloqueado, os que estiverem dentro dos limites serão submetidos ao cálculo do Taxicab Geometry se o resultado estiver dentro da distancia mínima (usada para calcular área de ataques) e máxima permitida significa que ele é um tile que o personagem pode se mover.

        /// <summary>
        /// Passe dois vetores x,y e descubra quantos passos sao necessarios para sair do 
        /// ponto inicial ate o final.
        /// Nota: para esse metodo lembrar que no nosso plano o Vector2.X e igual ao Vector3.Z
        /// e o Vector2.Y = Vector3.X
        /// </summary>
        /// <param name="pontoInicio">Ponto em que o personagem, ou objeto esta</param>
        /// <param name="pontoFinal">Ponto que se deseja chegar</param>
        /// <returns>O numero de passos necessarios para chegar no ponto final</returns>
        public static int CalculaDistanciaManhattan(Vector2 pontoInicio, Vector2 pontoFinal)
        {
            int distancia = 0;
            distancia = (int) (Math.Abs(pontoFinal.X - pontoInicio.X) + Math.Abs(pontoFinal.Y - pontoInicio.Y));
            return distancia / TamanhoTile;
        }

        /// <summary>
        /// Recebe uma lista com os Tiles do campo de batalha, o ponto onde o personagem se encontra e
        /// a distancia de movimento, ataque ou magia e retorna os Tiles em que e possivel executar a acao.
        /// </summary>
        /// <param name="tiles">Lista com os tiles do campo</param>
        /// <param name="pontoCentral">O ponto 0 da area que se deseja calcular</param>
        /// <param name="distanciaMinima">Distancia minima da area</param>
        /// <param name="distanciaMaxima">Distancia maxima da area</param>
        /// <returns>Uma lista com os tiles em que e possivel executar a acao</returns>
        public static List<Tile> CalculaAreaManhattan(List<Tile> tiles, Vector3 pontoCentral, int distanciaMinima, int distanciaMaxima)
        {
            /*
             * Calcula os pontos maximos e minimos onde talvez seja posivel chegar.
             * Todos os maximos sao calculados pelo ponto central mais o resultado da multiplicacao 
             * entre o tamanho do tile e a distancia onde se pode chegar, enquanto os minimos sao achados
             * pela subtracao desses valores.
             */
            float pontoMaxX = pontoCentral.X + (TamanhoTile * distanciaMaxima);
            float pontoMinX = pontoCentral.X - (TamanhoTile * distanciaMaxima);
            float pontoMaxZ = pontoCentral.Z + (TamanhoTile * distanciaMaxima);
            float pontoMinZ = pontoCentral.Z - (TamanhoTile * distanciaMaxima);

            /*
             * Monta uma lista de Tiles onde possa se mover
             */
            List<Tile> tilesPossiveisList = tiles.FindAll(
                                                delegate(Tile tile) 
                                                {
                                                    bool retorno = false;
                                                    /*
                                                     * Verifica se o tile esta dentro dos limites onde o personagem pode se mover
                                                     */
                                                    if (!tile.Blocked && tile.Position.X >= pontoMinX && tile.Position.X <= pontoMaxX &&
                                                        tile.Position.Z >= pontoMinZ && tile.Position.Z <= pontoMaxZ)
                                                    {
                                                        /*
                                                         * Verifica quais os tiles estao na distancia correta usando a distancia de Manhattan
                                                         */
                                                        int distanciaEntrePontos = CalculaDistanciaManhattan(new Vector2(pontoCentral.Z, pontoCentral.X), new Vector2(tile.Position.Z, tile.Position.X));
                                                        retorno = (distanciaEntrePontos >= distanciaMinima && distanciaEntrePontos <= distanciaMaxima);
                                                    }
                                                    return retorno;
                                                }
                                            );
            return tilesPossiveisList;
        }

Ai está o código completo, óbvio que ainda não é a melhor solução possivel pretendo melhorar na medida do possivel, mas por enquanto atende ao que necessitamos muito bem.

Para terminar o post um vídeo com todo esse código funcionando.

Get the Flash Player to see this player.

Continuamos a todo vapor no desenvolvimento do Tactic RPG, nessa semana ele teve uma boa evolução depois de tanto trabalho conseguimos fazer um esquema de camera bom e já começamos a fazer os cenários. Aqui estão algumas fotos demonstrando a evolução.

Graças a um exemplo do App Hub fizemos uma grama (http://bit.ly/fNWOy2) e usando o starter kit de RPG (http://bit.ly/guStIx) também do App Hub fizemos uma maneira de criar os cenários. Assim que surgirem novidades faremos mais um post.