Muitas vezes as pessoas acham que precisamos de algum framework ou algo do tipo para desenvolver um game, particularmente acho que sempre devemos analisar o problema antes de tomar esse tipo de decisão, nesse caso tive a oportunidade de provar isso fazendo um game para uma promoção da Colgate, onde eles estavam atrás de “ideias” para promover sua nova pasta de dente.
A nova pasta tem como argumento “Ir para a Balada com um Sorriso Branco e Bonito”, com isso na cabeça, apresentei como proposta o “Sorriso Defender”, um game mobile, para você defender a sua balada das caries e coisas que podem atrapalhar o seu sorriso.
O game segue uma mecânica bem simples e conhecida, a mesma do space invaders, so que com a temática dessa nova linha da Colgate.
Seguindo essa ideia, criamos primeiro o cenário do jogo, ja no cenário podemos ter alguns truques, muitos usados em games simples, notem o contorno da cidade junto com outros efeitos ja são da própria imagem, ganhando dessa maneira desempenho na hora do render, outro ponto são as setas de controle que também pertencem ao fundo, assim so precisamo mapear a área de touch para movimentar o nosso herói.
Para ser nosso herói ninguém mais importante que a própria:
Agora vamos definir o cenário da nossa balada:
E por ultimo as caries:
Pronto, como nem todos conhecem a mecânica do space invaders, vamos fazer um tela para o tutorial do game:
Pronto, com tudo feito, agora vamos programar o game. O jogo foi feito em 5 classe: – TelaPrincipal, responsável por abri o game, e gerenciar as telas que aparecem no game, assim como a navegação. – Pasta, responsável por movimentar e contar a vida do nosso serio, junto com os disparos de Colgate nos inimigos. – SorrisoDefender, responsável pelo o controle do loop principal do jogo, junto com os pontos do jogo. – Monstro, cria monstros no cenário e mata os que forem acertados pelo o nosso jogador. – Rodar, thread criada para controle de aspectos do game. – Para saber quando um jogador perde vida, validamos por area, quando um mostro passar da área mapeada tiramos vida do jogados e quando um disparo da nossa pasta acerta se encontra na mesma área que um mostro, tiramos o mostro do game e aumentamos os pontos do jogador. Para quem quiser estudar mais a fundo ou tirar alguma ou melhorar o game, estou deixando o fonte para download:
Há um tempo, a porto seguro estava com a campanha do “Transito Gentil”. Hoje, depois de muito tempo, posso falar um pouco sobre o game e postar as fontes para outros desenvolvedores.
O game segue uma ideia bem simples baseado nos conceitos do livro A Theory Of Fun For Game Design, escrito por Raph Koster. Partindo dos mesmos princípios, decidi criar um casual game, aonde o jogador se colocar na tarefa de “administrar” o transito de uma avenida e punir os carros que não estão sendo “gentis”, com os outros.
Depois da ideia do jogo, precisamos definir agora a mecânica do mesmo. Nesse caso optamos por “clicks” do mouse em cima dos carros, caso o jogador acabe punindo por engano algum motorista que esteja sendo “gentil”, ele perde uma vida, caso ele cumpra seu dever e acerte qual carro está errado, ele ganha pontos. Ao conseguir acumular pontos suficientes ele passa de nível.
No jogo, foi definido três tipos de penalidades diferentes:
– Dirigir alcoolizado/bebendo
– Dirigir falando no celular
– Dirigir em alta velocidade
Depois de definir as regras, ganhos e penalidades, vamos fazer a nossa HUD (termo usado para definir o painel do jogador),então para isso precisamos definir quais as informações relevantes para o nosso jogador sempre ter em mãos, elas foram:
– Vidas – Pontos – Nível – Valor de cada penalidade – Um personagem para o jogador se identificar
Pronto, já temos as regras, a HUD, enfim… já definimos tudo que um jogo precisa ter, agora vamos para a parte mais divertida… PROGRAMAR!
Por ser um game simples, dividi ele em três partes.
– Scene, lugar aonde vou controlar cenários, juntar os elementos e ter o loop do game. -Carros.class, responsável por criar os carros no jogo e definir se são carros simples ou carros penalidades. -Regras, classe dentro do próprio fla, responsável por punir ou presentear nosso jogador de acordo com as ações dele.
Pronto depois das regras definidas, interface feita e código pronto, agora vamos jogar: http://richard.brochini.com/citygentil.swf Para quem quiser baixar o código fonte do game, segue: http://richard.brochini.com/fonteGentilCity.rar
Hoje veremos como integrar aplicações web com a rede de serviços mobile. Como ja foi visto antes em http://richard.brochini.com/?p=248, podemos usar a API do Bluevia para integrar várias linguagens, então por que não integrá-la usando uma linguagem web como o PHP para fazer coisas mais legais nos meus programas?
Antes de começar, precisamos escolher quais tecnologias usar, e neste caso vamos usar php5+zend, usando as classes que a própria bluevia disponibiliza. Para a parte de SO estou utilizando uma dist Ubuntu e para web server, utilizaremos o apache serve.
Vamos dividir nosso sistema em duas partes: uma de envio e outra de leitura. Assim teremos dois processos separados e isso nos permite receber e enviar SMS’s ao mesmo tempo. Para a leitura criaremos um arquivos chamado receber.php, onde irá receber todos os SMS’s e gravar em um arquivo chamado temp dentro do nosso servidor. Nesse caso estou gravando dentro desse arquivo, mas nada impede de alterar o fonte para gravar dentro de um BD ou algo do tipo.
Arquivo receber.php
Primeiro importamos as classes e incluímos o zend framework:
Agora precisamos deixar rodando dentro do Ubuntu como um processo, e neste caso usei esse comando:
var/usr/php receber.php &
Agora que já estamos recebendo, vamos enviar. Para isso criamos o arquivo enviar.php. O início se parece muito com o outro que foi feito, inclui as classes e estancia elas:
E para enviar basta passar as infos para a classe BlueviaClient, e tratar os erros:
$bv = new BlueviaClient($mode,$application_context); if ($bv){ $smsMT = $bv->getService(‘SmsMT’); if ($smsMT){ $smsMT->addRecipient(“551199732787″); // numero com 55 DD CEL $smsMT->setMessage(“teste de envio olha eu aki!!”); try{ $result = $smsMT->send(); print “Sms MT API\n”; print “Send SMS\n”; if($result) { print “Sms ID “.$result.”\n”; } } catch (Exception $e) { print “Sms MT\n”; print “Send SMS\n”; print “Exception sending SMS: “.$e->getMessage().”\n”; } print “Request “.$bv->getLastRequest().”\n”; print “Response “.$bv->getLastResponse().”\n”; try { $delivery_status = $smsMT->getDeliveryStatus($result); print “Delivery status\n”; print “Phone number “.$delivery_status->smsDeliveryStatus->smsDeliveryStatus[0]->address->phoneNumber.”\n”; print “Delivery status “.$delivery_status->smsDeliveryStatus->smsDeliveryStatus[0]->deliveryStatus.”\n”; } catch (Exception $e) { print “Delivery status\n”; print “Exception retreiving the SMS delivery status: “.$e->getMessage().”\n”; } unset($smsMT); } }
Notem que a forma com que tratamos os erros nesse caso, foi seguindo os conceitos de OO dentro do PHP5. Podemos facilmente adaptar esse fonte, para ler uma lista de celulares e os textos de dentro de um arquivo ou algo do tipo.
Hoje vamos ver algo simples que pode ser feito no php5 que pouca gente conhece: a função “__autoload ”.
Com ela podemos incluir classes seguindo padrão, fazendo com que todos os includes do php sejam feitos de forma dinâmica. Isso ajuda em:
– Ao alterar algo ou incluir uma classe nova, não precisamos checar se foi dado include em todos os outros arquivos.
– Garante que seja incluído arquivos que realmente sejam usados, evitando carregar classes que não estão sendo usadas, fazendo com que não haja uso desnecessário de memória.
– Ajuda a criar e seguir um padrão para as classes e onde elas se encontram.
Isso pode ser feito de uma maneira bem simples. Primeiro precisamos definir um padrão. Vamos colocar todas as classes dentro de um pasta chamada “classes” e definir que quando criarmos o arquivo de uma classe, seguirá esse formato: “NomeDaClasse.class.php”. Agora que padronizamos podemos criar nossa função:
function __autoload($class_name) { require_once (‘classe/’.$class_name.’.class.php’); }
O __autoload, pertence ao conjunto de funções internas dentro do php. Toda vez que chamamos uma classe, ele terá essa função. Nesse caso ele está pegando o nome da classe e dando o include usando o nome dela, por exemplo:
$a = new Usuario();
O __autoload vai entender que você está chamado a classe de nome “Usuario”, e vai chamar essa função trocando o $class_name pelo nome da classe chamada. A string ficará assim: “classe/Usuario.class.php” Que será o arquivo que ele vai chamar.
Agora podemos criar um arquivo chamado config.php e nele escrever essa função, e incluir no nosso index principal. Assim toda vez que chamarmos uma classe, ele procura e adiciona automaticamente essa classe no include_once, que por sua vez o carrega na memória somente quando for chamada. Pode não parecer, mas o ganho de desempenho é bem grande, ainda mais quando se trabalha com sistema de grande porte.
Espero que essa dica seja útil! Esta prática resolve muitos problemas de performance.
Resolvi estudar as novas versões de API que a Bluevia disponibilizou no site deles. Umas dessas me chamou um pouco mais a atenção, que foi a Voice API. Está em versão Alpha ainda, mas gostei do que possibilita criar.
Hoje com a Bluevia temos:
API de SMS que permite enviar e receber mensagens de textos entre celulares usando a rede da operadora ; API MMS que permite troca de arquivo multimídias (fotos e vídeos), entre celulares utilizando a rede da operadora ; API de payment onde se pode fazer cobranças usando crédito do celular da pessoa ; E API Voice, onde é possível integrar conversas de áudio dentro de sua aplicação.
Nem todas estão disponíveis no Brasil ainda, mas eles prometem que todas estarão até o fim do ano.
Para começar a usar o Bluevia, é preciso se cadastrar: https://labs.bluevia.com/ Depois do cadastro, você entra no seu dashboard, onde terá acesso a todas as APIs. Mesmo as que ainda não funcionam no Brasil. O mais legal do Bluevia é que você gera receita quando seu aplicativo envia e recebe dados usando a rede da operadora, e eles estão dispostos a te dar parte dessa receita. Só que para isso, é preciso desenvolver aplicativos legais e que as pessoas utilizem. Eu já desenvolvi alguns aplicativos e gostei muito do resultado.
Para desenvolver qualquer coisa, é necessário antes baixar o pacote com a API que você vai usar. Podemos baixar nesse site: https://labs.bluevia.com/en/page/tech.APIs Depois precisamos registrar a aplicação dentro do Bluevia. Você sobe um ícone, fala sobre o que ela faz e quais funcionalidades irá usar. Após isso, deve pegar um token para sua tela e pronto, já podemos usá-la. Existem vários exemplos de como usá-la no próprio site, mas aqui irei falar um pouco do que usei em meus aplicativos.
Com a API de SMS, acho que a aplicação mais criativa que fiz foi um aplicativo de enquete. Nele eu enviava a enquete para meus amigos e registrava todos os votos deles, para no final dar o resultado do vencedor.
Com a API de MMS, a pessoa enviava uma imagem, meu servidor recebia e a processava com algum efeito aleatório e retornava para o celular da pessoa. O mais legal eram os efeitos engraçados que deixei para gerar essas imagens, então muita gente mandava só para ver o que iria acontecer.
Com a API de Pagamento fiz uma forma de compra de moeda virtual para um jogo on-line, mas infelizmente não foi ao ar esta aplicação.
Com a API de VOICE, já fiz alguns testes, apesar de não poder usá-la ainda no Brasil. Andei brincando com algumas coisas, e o legal é poder construir um aplicativo web, que é possível ligar para ele e com isso escutar tudo o que você fala. Com isso consegui montar uma interface em que o áudio aparecia escrito no site.
Através da API VOICE é possível também, ligar para alguma pessoa e executar um WAV onde a própria pessoa escuta, como se fosse uma ligação normal. Já pensou nesta possibilidade? Imagine seu servidor ligando de madrugada, falando que algum serviço está fora, ou seu e-commerce ligando para o cliente e informando qual a situação de entrega do pedido?
Espero ter ajudado com essas dica e que vocês tenham muitas ideias!
Hoje vamos montar um webservice em PHP para localizar ônibus.
Atualmente ouve-se falar muito sobre cidades inteligentes e como construir aplicativos que tornem a vida das pessoas mais agradável, e para isso o governo está investindo bastante em TI.
Algumas linhas tiveram um GPS instalado em cada ônibus, e os dados desse GPS vão para o servidor da SPTrans de ip “200.189.189.54“. Para consultar os dados dele, vamos precisar enviar alguns comandos e para isso precisamos saber como o sistema de ônibus está organizado.
Os ônibus funcionam através de corredores, então a primeira coisa a ser feita será identificar esse corredores:
Campo Limpo código 8 Expresso Tiradentes código 9 Inajar de Souza código 3 Parelheiros código 7 Paes de Barros código 1 Pirituba código 2 Santo Amaro código 10
Agora que sabemos o código vamos dar o primeiro comando:
Vamos analisar agora o retorno que recebemos em json:
{“CodigoParada”:700016474,”Endereco”:”R CRUZEIRO\/ R ANHANGUERA”,”Latitude”:-23.523134,”Longitude”:-46.65309,”Nome”:”ANHANGUERA B\/C”
Onde os campos são:
CodigoParada = código do próximo ponto que ele vai parar Endereco = endereço do próximo cruzamento Latitude = ponto de lat dele Longitude = ponto de long dele Nome = qual o nome desse ônibus
E recebemos os dados de todos os ônibus daquela linha no momento. Um dado importante que podemos tirar com isso, é saber exatamente quantos ônibus temos circulando naquele corredor no momento.
Agora basta selecionar um ônibus na lista e pronto! Podemos fazer uma nova consulta e verificar quais os dados da próxima parada e medir quanto tempo falta para chegar lá. No caso o comando seria esse:
http://200.189.189.54/InternetServices/Previsao?cb=jQuery172032039905060082674_1359795074526&codigoParada={código da próxima parada }
Com esse comando, podemos descobrir muitas coisas e se analisarmos bem, existem alguns dados valiosos. Como quais são os pontos que este ônibus passa, qual a hora de chegada prevista para cada ponto, quais os pontos de lat e log e qual a hora prevista para o ônibus terminar o trajeto.
Com todas essas informações, podemos construir muitos aplicativos que podem nos ajudar a ter uma cidade melhor.
Esse aplicativo tem uma mecânica bem simples: cadastrar seus amigos separando-os por times e depois enviar SMS em massa para todos. Só que ao invés de escolher um amigo, você escolhe um time para enviar.
Vamos para a prática!
A primeira coisa foi definir a mecânica das interfaces para o aplicativo. Nesse caso, para deixar tudo bem separado. Criei todas as telas em xmls usando a própria lib do android.
Depois de montar os botões e todo o resto, criamos um arquivo xml chamado inicio.xml. Esse arquivo vai ser a tela inicial.
Nesse caso inserimos um elemento dentro do layout, no qual informamos as propriedades, tamanho e tipo de obj.
Para simplificar este aplicativo resolvi criar um xml para cada interface, para não mudar sempre o mesmo xml. Isso deixa o aplicativo mais simples, porém ele fica um pouco pesado para o usuário final.
Feito o layout de todas as pages, vamos para o fonte.
Todo aplicativo Android tem uma classe principal que herda uma classe chamada “Activity”. Essa classe gera um processo no celular que fica rodando no aparelho do usuário. Ela tem um método chamado “onCreate”, que sempre vai ser executado quando o usuário inicia o aplicativo. Nele colocaremos tudo o que precisamos para rodá-lo. Então, como estamos trabalhando com uma lista de amigos, vamos verificar se a lista existe e carregar.
No método “Carregar amigos”, vamos ler a lista de amigos que gravamos em um arquivo texto no celular do usuário. Caso esse arquivo não exista, será necessário criá-lo. Caso contrário, apenas verificamos se tem algo nele e carregamos para a variável amigos.
Agora precisamos cadastrar nossos amigos de acordo com a tela que criamos.
Nessa tela vamos cadastrar o nome do time do amigo, o telefone e seu nome. Claro que este aplicativo poderia pegar os contatos do próprio aparelho do usuário, mas a intenção é trabalhar com escrita e busca no aparelho. Em um post futuro mostro como fazer essa adaptação.
Para cadastrar, criamos o método salvarTimeAmigo. Ele vai ser responsável por capturar os dados da interface e gravar no arquivo que criamos.
Notem que logo depois de salvar os dados, chamamos “setContentView(R.layout.inicio);”. Com essa chamada carregamos a interface inicio.xml, e dessa maneira voltamos para a tela principal da aplicação.
Depois dos amigos cadastrados, agora vamos enviar o sms para os amigos.
Para enviar o SMS, precisamos de uma operadora. Para isso, conheço apenas duas opções: fazer algum acordo para usar um sistema delas ou usar o BlueVia. Nesse caso vamos usar a segunda opção.
Nesse post não irei me aprofundar muito a respeito de como o BlueVia funciona. Mas irei explicar o que precisamos para usá-lo.
Para usar o BlueVia, precisamos nos cadastrar no site: http://www.bluevia.com/. Através dele geramos um ticket e um hash para usar a rede de celular, e agora é só baixar a API para Android e implementar nesta aplicação.
Ao pressionar o botão enviar, a nossa classe principal captura os dados dessa interface e envia para a classe SMS. A mesma se conecta com o BlueVia e manda os dados para envio.
Ao iniciar a classe SMS, iniciamos a conexão no construtor dela:
