[Variedades] O Maior Brasileiro de Todos os Tempos

Olá pessoal, há algum tempo o SBT (Sistema Brasileiro de Televisão, canal 4 - São Paulo) vinha coletando votos para eleger o maior brasileiro de todos os tempo, em parceria com a rede de televisão BBC. Pois bem, alguns meses depois, atualmente conseguiram coletar mais de 1 milhão de votos propostos e assim dar continuidade a seleção. Ontem, quarta-feira, estreou o programa apresentador por Carlos Nascimento, às 23:30hrs.
No programa foi e serão apresentados os 100 mais votados pelo público brasileiro que participou, para então, a partir desses mais votados, escolher o único brasileiro que merece o título. Para acessar informações sobre o programa, e o já anunciados à disputa pelo titulo acesse o site abaixo, e veja todos os classificados:

http://www.sbt.com.br/omaiorbrasileiro/ (O Maior Brasileiro de Todos os Tempos)

A proposta do programa é muito importante não só para nós brasileiros, mas como o Brasil, e sua visibilidade. Entretanto venho ressaltar que uma das maiores decepções que tive com o programa, foi a exigência de que nenhum integrante do SBT entrasse para a disputa do título. Afinal, o SBT conta com uma série de grandes nomes e possíveis ganhadores ao prêmios. Lamento por isso, mas creio que nós brasileiros saberemos escolher muito bem nosso representante a ser O Maior Brasileiro de Todos os Tempo.

[Filmes] O Espetacular Homem-Aranha

Olá pessoal, após nossa prévia antes do filme estrear, assisti O Espetacular Homem-Aranha, e aqui um pouco do que tenho a dizer do que foi visto no filme, no que faltou e no que precisava ter melhorado. O inicio do filme começa com o Peter Parker ainda criança e com seus pais, uma boa entrada para que os espectadores entendessem o porque Peter morava com seus tios e como foi esse processo. Como já esperado o filme abordou o colegial, onde mostra os comportamentos dos alunos e como o Peter se encontrava nesse ambiente. Até o momento antes da picada da aranha, o filme é bem parado, contendo somente história e drama, criando um ambiente de toda a situação para mais tarde essa ser cobrada na história.

Pode-se dizer que a parte "herói" da história começa quando Peter conhece o Dr. Connors e é picado pelas aranhas, que partiam de um processo de pesquisa gerado pelo pai de Peter. A trama é bem alimentada, não há difusão entre as cenas, contendo uma história retilínea sem grandes acontecimentos fora o central. Nesse filme, temos um Peter mais autêntico e ao mesmo tempo que "se acha o cara do pedaço", entretanto conforme o decorrer do filme percebe-se que ele vai adquirindo toda a humildade que existe dentro dos heróis. O filme em si teve assuntos mal resolvidos, incluindo o Clarim Diário na trama, e o primeiro ataque do Lagarto a cidade que falou um final que deixou a pergunta: Porque o Lagarto fugiu? O que aconteceu com o cara que ele tava atrás?

Em si o filme é espetacular, como o próprio nome diz, apesar de alguns aspectos deixarem a desejar, ele cumpre sua promessa, e deixa um bom filme de super-heróis com direito a continuação. Vale a pena ver e rever no cinema, ou quando sair em locadoras. A minha avaliação nesse filme é de 8 pontos de 10.

[Filmes] [Prévia] O Espetacular Homem-Aranha

Olá, como todos sabemos, amanhã (6/07/12) estreará nos cinemas O Espetacular Homem-Aranha, existem diversos comentários sobre esse filme, e diversas críticas em relação ao reboot da saga. Abaixo podemos conferir o trailer, e especular que o filme promete bastante emoção.

O Homem-Aranha já teve suas aparições no cinema com a trilogia de filmes estreando Tobey Maguire como o protagonista Peter Parker. Porém, a forma como a história foi adaptada para o cinema era um tanto contraditória a das histórias em quadrinhos.


Assim, esse novo filme, traz a história completamente remodelada, e semelhante aos quadrinhos, mostrando o Peter Parker nerd, com personagens novos, e uma das mudanças mais significativas em relação aos demais filmes, é a utilização de um aparelho desenvolvido pelo próprio Peter para lançar teias, exatamente como é nos quadrinhos.

(Sistema lança teias, do novo filme)

A nova roupa do Homem-Aranha, como observada a abaixo, se tornou mas sombria e com mais estilo que a antiga, agora sim podemos confiar no novo Homem-Aranha, pois, antigamente, o filme passava uma imagem muito "infântil".

(Tobey Maguire, à esquerda - Andrew Garfield, à direita)

Outra mudança significativa, o Peter Parker agora, está mais "adolescente", possivelmente para o filme isso vai representar talvez um ambiente mais colegial, abordando sobre problemas mais comuns na adolescência. E uma prévia exclusiva de 4 minutos do filme saiu, woOooOoOw, vamos assistir.

É pessoal, podemos notar que o filme além de mais adulto, terá bastante conflitos emocionais entre os personagens, novas perspectivas de visão, muita ação e destruição, que é essencial para todo filme de super-heróis. É isso aí, agora aguardando ansioso pela estréia, que provavelmente, vai esgotar.

[Tutorial] [XNA] Jogo de Plataforma - Parte 3

Olá pessoal, em nossos últimos tutoriais desenvolvemos as classes Camera2D e Animacao para o nosso jogo. Caso não tenha acompanhado os tutoriais anteriores dessa série, sugiro que acesse os seguintes links antes de prosseguir:

Primeiros Conceitos (Conhecendo o XNA) - Parte 1 (Classe Camera2D) - Parte 2 (Classe Animacao)

Nesse tutorial, desenvolveremos uma classe de objeto que estará presente no jogo. O nome para tal classe será Tile. Os tiles são pequenos pedaços de imagens que servem para criar uma nova imagem composta conhecida como layer, utilizadas para criar o cenário de um jogo. Observe a imagem abaixo:

(Super Mario Bros 3)

Na imagem acima temos um jogo com seu personagem, cenários, inimigos, etc. Para montar esse cenário 2D de maneira mais prática e, economizando o máximo possível de uso da memória do computador. Construímos esse objeto utilizando vários tiles que são armazenados, um por um, na classe Tile. Sendo assim possuímos somente os tiles principais, mas montados o mapa conforme nossa necessidade. Abaixo um exemplo com os tiles utilizados para montar o cenário da fase acima:

(Tiles do Jogo Super Mario Bros)

Muito bem! A classe que iremos desenvolver agora não será ainda capaz de montar nosso cenário, somente de armazenar os tiles acima, para posteriormente, serem usados na construção de um cenário. Vamos agora analisar nossos atributos. Todo tile tem o seu tipo de colisão, sua textura e seu tamanho. Crie uma nova classe dentro do projeto do jogo chamada Tile. Começamos a montar nossa classe fazendo referências aos frameworks.

using Microsoft.XNA.Framework;

using Microsoft.XNA.Framework.Graphics;

Antes de começar a escrever nosso código dentro do bloco da classe, vamos criar um tipo de atributo enumerador, responsável por identificar o tipo de colisão. Esse processo facilita e padroniza os dados.

// Enumeração dos tipos de colisão existentes

public enum TipoColisao

{

     // Refere-se ao Tile passável

     passa,

     // Refere-se ao Tile impassável

     naoPassa,

     // Refere-se ao Tile plataforma

     plataforma,

}

Pronto :) Criamos nosso enumerador, agora podemos começar a escrever nossa classe, definindo os atributos e métodos dos tiles.

public class Tile

{

     // Definição da textura do Tile

     protected Texture2D tile;

     // Definicão do tipo de colisão do Tile, observe

     // a variável é do tipo enumerador que criamos

     public TileColisao colisao;

     // Definição do tamanho do Tile

     public Vector2 tamanho;

     // Método que constrói o nosso Tile, recebendo

     // a textura e o tipo da colisão

     public Tile(Textura2D textura, TileColisao _colisao)

     {

          this.tile = textura;

          this.colisao = _colisao;

          this.tamanho = new Vector2(textura.Width, textura.Height);

     }

}

Agora temos nossa classe Tile completa, pronta para começar a receber nossos tiles, nos próximos tutoriais aprenderemos a implementar essa classe em nosso projeto e criar o cenário conforme nossa preferência. Aguardo vocês e até breve. ( com mais um gif HUAHUAHUAUH sou viciado D: )

[Tutorial] [XNA] Jogo de Plataforma - Parte 2

Olá caros friends, em nosso último tutorial da série Jogo de Plataforma, abordamos alguns princípios básicos sobre plataforma adotando como exemplo o jogo do famoso Super Mario. Além disso, desenvolvemos a classe Camera2D que se movimenta junto com o personagem do jogo.

Neste parte do tutorial desenvolveremos a classe Animacao. Como podemos observar em qualquer jogo de plataforma, durante a movimentação do jogador e objetos pela tela, sempre é uma espécie de conjunto de animações, como por exemplo, animação para o personagem andar, correr, pular, etc. Sendo assim, a classe que desenvolveremos será responsável por criar nossos frames de animação e animá-los caso haja necessidade.

Inicialmente, crie uma nova classe no projeto, com o botão direito do mouse clique no nome do seu projeto localizado no Solution Explorer, depois no submenu Add, e por fim Class. Dê o nome Animacao para classe e clique em okay.

Antes de começar o desenvolvimento da classe, vamos analisar seus termos técnicos para que possamos identificar seus atributos e métodos dentro do jogo. Toda animação possui uma certa quantidade de quadros de desenho, um tempo de transição de um desenho para o outro e a instrução de repetição, caso exista. Por tanto identificamos três atributos da nossa classe:

1. Quadros da Animação - Todos os desenhos que compõem ela.
2. Quantidade Total de Quadros.
3. Tempo de Intervalo - Tempo de transição de um quadro para o outro.
4. Repetição - Se a animação fica ou não repetindo.

Nessa classe trabalharemos com Rectangles, que em termos computacionais, é preciso de um dispositivo gráfico para renderiza-los. Para isso faramos referência ao framework do XNA. Indicado abaixo:

using Microsoft.XNA.Framework;
using Microsoft.XNA.Framework.Graphics;

Pois bem, agora podemos começar o desenvolvimento da classe Animacao. Dentro do bloco:

public class Animacao
{
     // Digitar todo o código da classe aqui.
}


Começaremos a declaração dos atributos identificados anteriormente para a nossa classe. Todos atributos serão privados somente para a Animacao, entretanto, podemos modificar seus valores, para isso serão criados os métodos get/set para cada um dos atributos.


// Lista que contém os quadros da Animacao
private List<Rectangle> quadrosAnimacao = new List<Rectangle>();
// Método para obter essa lista quando necessário
public List<Rectangle> QuadrosAnimacao { get { return this.quadrosAnimacao; } }


// Tempo de intervalo de transição dos quadros da Animacao
private float intervalo = 0.10f
// Métodos para obter e setar o intervalo quando necessário
public float getIntervalo() { return this.intervalo; }
public void setIntervalo(float _intervalo) { this.intervalo = _intervalo; }


// Define se existe repetição na Animacao
private bool existeLoop = false;
// Métodos para obter e setar a existência de repetição
public bool getExisteLoop() { return this.existeLoop; }
public void setExisteLoop(bool _loop) { this.existeLoop = _loop; }


// Define a quantidade total de frames da Animacao
private int quadrosTotal = 0;

Prontinho muchachos, criamos os atributos e os métodos para controlar esses atributos dentro da classe. Bom, como agora já temos os atributos, faltam os métodos da classe. Para um animação só existe o método construtor, que vai construir a animação e deixa-la armazenada na memória, e ela será acionada conforme instruções que receber do objeto a ser animado.

// Método que constrói nossa Animacao
// é enviado para esse método uma lista de quadros
// com inicio, e total de quadros dela
public Animacao(List<Rectangle> quadros, int inicio, int total)
{
     // Define a quantidade de quadros da Animacao
     this.quadrosTotal = total;


     // Adiciona cada quadro que foi recebido a lista de quadros da Animacao
     for (int i = inicio; i < (inicio + total); i++)
     {
          this.quadrosAnimacao.Add(quadros[i]);
     }
}

E ai está nossa classe Animacao, prontinha direto do forno ( HUHAUHA ) para ser utilizada. Entretanto guardaremos ela, pois para se ter uma animação é preciso um objeto, que em nosso caso, não temos ainda. Conforme os tutoriais forem evoluindo, todas as classe serão diretamente conectadas umas as outras. Aguardo todos em nosso próximo tutorial. ( Como de costume nosso gif básico HUAUHAUHAHU )

[Internet] Que isso Repórter, Que isso?

Estava agora mesmo navegando "trankilo" pela internet, quando, wOOoooOow vejo uma Repórter paranormal, essa fala a notícia e ainda acontece!! :o

Que isso hein, que isso HUUHUHAUHAUHUHUHA acho que agora ela tem que ganhar um aumento hein!? Afinal notícia mais exclusiva que essa é pra poucos... Prêmio #FuckYeah de Reportagem

[Tutorial] [XNA] Jogo de Plataforma - Parte 1

Quando falamos em Jogos de Plataforma e ambientes 2D, é bem impossível não lembrar dos jogos do famoso encanador chamado Mario. ( Afinal se você não se lembrou do Mario, provavelmente você é um poser de jogos HUAUHAUHAH ) Abaixo um breve vídeo, do nosso amiguinho youtube, com um exemplo de jogada no Super Mario:

Observando a jogabilidade podemos ver que o Mário se movimenta pela fase, a todo momento a câmera está focalizada nele. O Mário pode andar, correr, pular, pular sobre inimigos, crescer com cogumelo, ganhar poderes com uma flor, ganhar vida com cogumelo, bater em tijolos, entrar por canos, por fim ganhar pontuação e terminar a fase.


Para este tutorial iremos desenvolver a classe Camera2D. Nesta classe criaremos uma câmera capaz de acompanhar o nosso jogador durante a sua movimentação pela fase. Como esse é um dos nossos primeiros tutoriais de desenvolvimento, ensinarei criar um novo projeto e a classe Camera2D. Abra o Visual C# 2008, e crie um novo projeto baseado em XNA, dê o nome ao projeto de MeuPrimeiroJogo, e clique okay. Como na imagem abaixo:

Agora no Solution Explorer, clique com o botão direito sobre o nome do seu projeto, vá até o submenu Add, e por fim em Class. Na janela que abrir digite Camera2D e clique em okay.

Antes de desenvolver a classe Camera2D, vamos identificar alguns atributos e métodos que toda câmera possui. Vamos analisar o funcionamento de uma câmera... Ela possui uma posição, um tamanho de resolução e um limite de tela. A partir dessas informações identificamos os seguintes atributos da nossa classe:

1. Posição da Câmera 2D - Refere-se a posição nos eixos X e Y da tela.
2. Limites da Tela - Refere-se ao limites do personagem, para que este seja seguido pela câmera.
3. Tamanho da Tela - Refere-se as dimensões em pixels de altura e largura da tela.

Identificado os atributos, vamos verificar as possibilidades de ação de uma câmera. Como ela é um objeto do jogo que precisa ser inicializador por tanto é necessário seu construtor. Além disso a câmera precisa seguir o objeto-alvo ( no caso o jogador ) na tela, e se movimentar pelo espaço do jogo, junto com o jogador. Agora que desenvolvemos uma teoria sobre a Camera2D começaremos a desenvolver nosso código da classe. Inicialmente, como iremos trabalhar com os gráficos da tela, devido nosso objeto ser uma câmera, precisamos fazer referências ao framework que iremos utilizar, por isso adicionamos as seguintes linhas os inicio do nosso código

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

Agora já podemos começar a produção da nossa classe dentro do bloco a seguir:

public class Camera2D 
{ 
    // Digitar dentro desse bloco o código da nossa classe 
} 

Vamos começar declarando nossos atributos da classe:

// Definição da posição da Camera2D no ambiente do jogo. 
// Vector2 é um tipo de dado que armazena em Vector os valores de X e Y. 
// Definimos a posição inicial como Zero. 
public Vector2 posicaoCamera = Vector2.Zero; 
// Definição dos limites da Camera2D no ambiente do jogo. 
private Vector2 limites; 
// Definição das dimensões da tela do jogo. 
private float widthTela, heightTela; 


Excelente ;) Criamos os atributos da nossa classe, a posicaoCamera é um atributo público pois pode ser acessado por quaisquer classes do jogo. Já o limites, widthTela e heightTela, são atributos somente para a Camera2D, portanto são privados. Agora vamos desenvolver os métodos disponíveis. 


// Método que constrói a Camera2D ao ser inicializada 
// Recebe como parâmetro o dispositivo gráfico e a 
// posição inicial dela no ambiente 
public Camera2D (GraphicsDeviceManager graphics, Vector2 posicaoInicial) 
{ 
    // Define o tamanho da tela conforme a viewport do usuário 
    this.widthTela = graphics.GraphicsDevice.Viewport.Width; 
    this.heightTela = graphics.GraphicsDevice.Viewport.Height; 
    // Define a posição inicial da Camera2D na tela 
    this.posicao = posicaoInicial;
    // Define os limites para X e Y como a metade da tela 
    this.limites = (widthTela * 0.5f, heightTela * 0.5f); 
} 


// Método para seguir o objeto-alvo atualizando a 
// posição da Camera2D conforme a posição do objeto 
public void Atualizar(Vector2 posicaoAlvo) 
{ 
    // Se a posição X do alvo for maior que o limite X da Camera2D 
    if (posicaoAlvo.X > limites.X) 
    { 
        // Atualiza a posição da Camera2D em X 
        this.posicaoCamera.X = posicaoAlvo.X - limites.X; 
        // Se a posição Y do alvo for maior que o limite Y da Camera2D 
        if (posicaoAlvo.Y > limites.Y) 
        { 
            // Atualiza a posição da Camera2D em Y 
            this.posicaoCamera.Y = posicaoAlvo.Y - limites.Y; 
        } 
    } 
} 


// Método que transforma a posição de cada objeto na tela 
// na direção oposta para qual a Camera2D se locomove e 
// retorna a nova posição do objeto na tela 
public Vector2 Transformar(Vector2 posicaoAntiga) 
{ 
    return new Vector2 ( posicaoAntiga.X - posicaoCamera.X, 
                                    posicaoAntiga.Y - posicaoCamera.Y); 
} 


Muito bem o/ agora criamos nossos métodos e nossa Camera2D está pronta para ser utilizada em nosso projeto. Como ainda não temos um objeto em nosso jogo, a câmera não será implementada agora. Mas nos próximos tutoriais conforme vamos progredindo em nossa criação aprenderemos como implementar a câmera com um objeto-alvo. Aguardo você e até a próxima. ( Um gif básico para distrair HUAUHAUHAHHUAHUHAUHUA )

[Tutorial] [XNA] Primeiros Conceitos

Ultimamente tenho tido um grande interesse em saber como os jogos funcionam, sobre as técnicas que são utilizadas e todo processo de desenvolvimento. Claro que, assim como tudo na vida, o jogo também é um processo bem complexo que necessita de grande apoio para ser desenvolvido.

( Se algum dia você desenvolver um jogo, sozinho, super legal que tenha muita popularidade. Meus parabéns, você é um nerd dos bons HUAHUHAUH )


Enfim, com algumas pesquisas pela internet, encontrei um framework ( um auxílio de desenvolvimento de software ) muito interessante para desenvolvimento de jogos para as plataformas Windows e X-BOX 360. Seu nome é Microsoft XNA, e ele pode ser baixado gratuitamente através do link abaixo:

http://www.microsoft.com/en-us/download/details.aspx?id=15163
( Microsoft XNA 3.1 - Fonte Microsoft )

( Já existe a versão 4.0 para esse framework. Mas se é a primeira vez que você ouve falar desse software sugiro a versão 3.1, pois é bem menos complexa do que a 4.0 )


Para o funcionamento do XNA 3.1, é necessário ter o editor de programação Visual C#, que pode ser baixado gratuitamente no link abaixo.


http://www.baixaki.com.br/download/visual-c-2008-express-edition-csharp-.htm
( Visual C# Express Edition 2008 - Fonte Baixaki )


Ao instalar esses dois softwares já estamos preparados para começar a desenvolver um game desde o nível mais básico ao mais avançado. A partir do próximo tutorial começaremos a trabalhar em um jogo 2D estilo plataforma. Aguardo você lá ;)

Expectativas

Aqui vou abordar sobre diversos assuntos, quero falar sobre filmes, séries, músicas, internet, ensinar também, parte do meu conhecimento a vocês. Espero que gostem, ohyeah!!

O Primeiro Rascunho

Olá, como primeira postagem, creio eu que muitas pessoas não sabem o que postar, em si, geralmente somos rodeados por lero-leros, que nos fazem não entender completamente nada do que estamos lendo. Algo parecido como agora, estou aqui, escrevendo sem um rumo, sem objetivo, nesse blog, pretendo falar de tudo que vier a mente, afinal cérebros pensam, e tudo que pensam praticamente são bem aleatórios...