Se passou mais uma Brasil Game Show e com ela podemos notar como o mercado de games está crescendo no Brasil… sim, estamos nos tornando relevantes.

Não apenas no papel de consumidores, mas como criadores, com muita criatividade, estamos inovando nos jogos, seja no roteiro ou na jogabilidade, ano após ano as equipes provam isso, mostrando o amadurecimento dos nossos developers e a capacidade de criação.

Com uma grande área de jogos indies pudermos acompanhar os melhores títulos e saber o que esperar para o próximo ano.

Trajes Fatais, é um jogo estilo fighting, aonde os poderes estão na roupas dos personagens. Com um otimo game play e graficos que lembram aquele estilo arcade, ele mistura um pouco de nostalgia apreciada pelos older Gamers com a inovação do que temos hoje no mercado. Um jogo ideal para curtir o famoso 1×1 com os amigos.

Galaxy of Pen and Paper, o estilo clássico de RPG das antigas, o famoso game retrô com aquela inovação. Com um roteiro criativo e bem humorado garante ótimas risadas e muitos puzzles ao longo da sua jornada nessa galáxia. Garantes muitas horas de jogo de uma maneira empolgante.

Adalbert e o castelo totalmente seguro, com um titulo bem sarcástico, esse jogo ganha pela a jogabilidade. Em castelo cheio de puzzles, o jogador é obrigado a pensar em quais recursos pode utilizar para superar os obstáculos, podendo utilizar a própria morte inclusive.

Game of King, aquele card game clássico, que mata a saudades, lembrando um pouco o antigo spellfire. O jogo promete desafiar o jogador na estratégia em campo e na montagem do deck. Para todos que curtem um card game, esse indie promete otimas noites de jogatina com os amigos.

Pingoal, uma mistura de pinball com futebol, esse mobile game, mostra que é possível inovar nas pequenas coisas, com uma mecânica simples, você precisa defender o seu “gol” e ao mesmo tempo atacar o oponente. Esse jogo casual tem tudo para dar certo.

Esse foram apenas os jogos indies brasileiros, destaques na BGS, testados pela a nossa redação. Adoramos cada momento e partida do jogo, e esperamos ansiosos pela a publicações de todos no steam,play store e marketplace do XBOX.

Nos dias 1, 2, 3,4 e 5 de Agosto de 2016, tivemos um dos eventos mais aguardado do ano para grandes fãs de games. Um evento com foco em mostrar as grandes novidades em inovação e títulos que estão para chegar, sempre podemos contar com grandes marcas nesse evento como Sony e Microsoft, mostrando o que existe de melhor em tecnologia e quais a tendências para o futuro.

A cada ano o evento fica maior, acarretando também no crescimento da indústria de games no Brasil, claro que a comunidade de desenvolvedores brasileira está cada vez mais presente em eventos grandes, com um espaço especial para estúdio de games brasileiros e com um Game Jam ( um hackathon para games dev) , a comunidade de desenvolvedores está muito presente nesse mercado.

Com muita criatividade, olhamos de perto o sonho de muitos estúdios, alguns já estruturados e outros sendo apenas um grupo de amigos com um sonho de ter seu título no steam. Apesar de muitas variedades de plataformas e “mecânicas“, todos estão usando hoje Unreal enginer ou Unity, ok! isso não é ruim, mas infelizmente no Brasil, falta um pouco de variedade nas escolhas, todos estão seguindo a famosa “modinha” e isso acaba deixando alguns jogos parecidos, não por culta das enginers mas por que todas saem da mesma base e do mesmo “tutorial”, assim dificilmente teremos alguma inovação muito grande em termos de software.

Claro que tivemos alguns destaques,

‘Super Button Soccer’

O desfaio desse game, foi levar a mecânica do futebol de botão para o computador, com controles simples, onde é um prato cheio para os fãs dos anos 90 que passavam seu domingo a tarde praticando esse esporte.

‘Dog Duty’

Um jogo de gráfico a moda antiga, mas com mecânicas novas. Com um sistema de combate de mundo aberto, você seleciona seu time e vai destruindo tudo no melhor estilo “rush”.

‘G.U.T.S.’

Para quem curte Killer Instinct ou Mortal Kombat, com certeza vai adorar esse game. A ideia é simples, você solta vários ataques especiais até deixar seu adversário sem nenhum membro, levando em consideração que ele não tem barra de vida, diferente dos outros jogos do gênero, você simplesmente ganha quando seu adversário não tem mais nenhum membro no corpo.

‘Holy Avenger’

Um jogo que nasceu de um RPG a 18 anos atrás, promete não apenas encher o coração dos saudosos fãs, mas agradar ao publico jovem que nunca ouviu falar no titulo. Estamos todos esperando por esse game no steam.

Fora a área de indie games, tivemos o Game Jam realizado com a BGS em parceria com a Globo. O desafio foi simples, construir um game em 48 horas, isso feito dentro de uma espécie de prisão de vidro dentro do evento. Apesar de pouco tempo, tivemos muitas ideias boas e ótimos games desenvolvidos nessas horas. Com destaque para o game “Tormenta“, com um cenário cartoon e a ideia de fugir de uma prisão enquanto um olho te espionava, conquistou o coração dos players no evento, ganhando por votação como melhor game.

A BGS a cada vez torna um evento que não apenas reúne grandes players da indústria, mas nela podemos encontrar uma comunidade de desenvolvedores com muita vontade de criar e mostrar a maturidade dos game devs brasileiros.

Procurar soluções de projeto de algoritmos que possam ser processados do lado client, principalmente para compilar grandes quantidade de dados de forma eficiente utilizando poucos recursos, hoje em dia é um desafio para os desenvolvedores. Existem muitos conceitos que podem ser aplicados, sendo um deles o conceito de programação dinâmica.

Esse conceito de projeto segue a ideia de pegar um problema “grande” e dividir ele em partes menores, muitas vezes podemos resolver ele com uma função recursiva, mas como grandes partes dos algoritmos recursivos, temos o problema de empilhar varias funções e sobrecarregar a memorias da maquina, no nosso caso dependendo do numero de funções recursivas abertas, o browser travaria.

Agora vamos imaginar que ao invés de encher a memoria com varias funções, usaremos apenas um vetor como apoio para poder processar e cachear os resultados de cada conjunto gerado para resolver o problema, sendo que o tempo e recursos estimados para o processamento esta sempre vinculado ao tamanho do vetor que vamos percorrer, lembrando que com isso temos a vantagem de poder dividir ainda mais o problemas em vetores menores e processar ele conforme as ações do usuários.

Existem um problema computacional bem conhecido que pode ser resolvido através dessa estrategia, o problema de “soma de subconjuntos” ou “exact subset-sum”. Vamos imaginar que todas vez que carregar uma lista, eu determino um valor para que seja possível carregar, a pergunta é, qual combinações possível de valores posso carregar?

Esse tipo de inteligencia pode ser aplicado em vários casos comuns, como saber em tempo real quais combinações possível para um grupo de pessoas em quartos, saber qual a melhor combinação de itens para se colocar em um carrinho de compras ou ate mesmo quais conjuntos possíveis se colocar na mochila de uma viajem. O computador pode calcular tudo isso pra gente 😀 .

Vamos ao código:

function calcularSubConjuntosPossiveis(vetorLista,n,soma){

// Se o valor de subListaVetor[sum+1][n+1] for true então existe pelo menos um subconjunto possível

subListaVetor[soma+1][n+1];
var 1 = 0;
var j = 0;

// Se a soma de todos os itens for 0, resposta true

for(i = 0; i <= n; i++){
subListaVetor[0][i] =true;
}

// Se a soma dos itens não for 0, devemos verificar quais conjuntos possíveis existem

for(i = 1; i <= soma; i++){
subListaVetor[i][0] = false;
}

// Gera a matriz com combinações possíveis de conjuntos

for(i = 1; i <= soma; i++){

// colocar todos os valores no topo

for(j = 1; j <= n; j++){
subListaVetor[i][j] = subListaVetor[i][j-1];

//verifica se o item cabe dentro do conjunto e atualiza a posição dele dentro da matriz
if(i >= vetorLista[j-1]){
subListaVetor[i][j] = subListaVetor[i][j] || subListaVetor[i – vetorLista[j-1]][j-1];
}

}

}

// Vamos imprimir agora a nossa matriz, falado quais combinações de conjuntos possíveis

for (i = 0; i <= soma; i++){

for (j = 0; j <= n; j++){
document.write(subListaVetor[i][j]+” | “);
}

document.write(‘
‘);
}

// retorna true ou false, avisando se foi possível fazer a combinação de itens com os valores

return subListaVetor[soma][n];

}
Como resultado final, vamos ter uma matriz, falando true ou false, falando quais combinação possíveis por linha.

Hoje em dia, falamos muito em mineração de dados e como fazer isso de forma sofisticada. Como uma estrategia, podemos fazer algoritmos que compilem isso do lado client e não server-side, dessa maneira seria como compilar uma enorme quantidade de dados de forma distribuída, aliviando assim o stress no servidores.

Hoje vamos aprender a fazer isso com duas funções javascript, uma chamada MAP e outra REDUCE.

Na pratica, seria como se separássemos todos os dados em conjuntos ordenados e depois fazemos pequenas somas, dessa maneria podemos ter dois tipos resultados, um único valor se todos os elementos forem do mesmo tipo ou um vetor com valores separados se forem de tipos diferentes.

Primeiro vamos fazer um Array com os dados para minerar:

var dadosSoma = [1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3];

Utilizando o método MAP

O objeto Array tem alguns métodos bem interessante, incluindo o MAP, ok, mas como ele funciona?

Quando chamamos esse método, ele recebe dois parâmetros.

Callback: uma função de retorno que vai ser aplicada em todos os elementos do array, deve-se retornar sempre um elemento do mesmo tipo para ocupar o lugar dentro do conjunto.

ThisArg: opcional, geralmente para saber qual a posição do lindice ou algum objeto que precise ter interação com todos os elementos.

Depois de entender esses parâmetros o nosso código fica dessa maneira:

var dadosSoma = [1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3];

var mapSoma = dadosSoma.map(functionMapCallback);

Criando a functionMapCallback

Como primeiro parâmetro temos o elemento da posição atual, depois de manipular ela, fazemos o retorno substituindo a posição desse elemento por esse novo valor dentro do conjunto gerado pelo o map, a função implementada fica assim:

var functionMapCallback = function(elemento){ return elemento = elemento *2; /* multiplicando todos os elementos do array por 2 */ };

Usando o método reduce:

O método reduce recebe dois paramentos,a função de callback e qual o valor de inicio, sendo o segundo parâmetro opcional.

Com esse novo método o nosso código fica dessa maneira:

var dadosSoma = [1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3];

var functionMapCallback = function(elemento){ return elemento = elemento *2; /* multiplicando todos os elementos do array por 2 */ };

var mapSoma = dadosSoma.map(functionMapCallback);

var reduceSoma = mapSoma.reduce(functionReduceCallback);
Criando a functionReduceCallback:

Quando o método reduce, faz a chamada da função, ele passa dois parâmetros o valor anterior e o atual dentro de um mesmo conjunto. Como estamos trabalhando com uma soma de valores, a função final fica assim:

var functionReduceCallback = function(anterior,atual){ return anterior+atual /*somando os elementos do conjunto e retornando o valor que substitui esses dois elementos */}

E agora o nosso código fica dessa maneira:

var dadosSoma = [1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3];

var functionReduceCallback = function(anterior,atual){ return anterior+atual /*somando os elementos do conjunto e retornando o valor que substitui esses dois elementos */}

var functionMapCallback = function(elemento){ return elemento = elemento *2; /* multiplicando todos os elementos do array por 2 */ };

var mapSoma = dadosSoma.map(functionMapCallback);

var reduceSoma = mapSoma.reduce(functionReduceCallback);
E como resultado final o valor da variável dadosSoma se torna 132.

Refinamento de código:

var dadosSoma = [1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3,1, 2, 3];

dadosSoma =dadosSoma.map(function(anterior,atual){return elemento = elemento *2; }).reduce(function(elemento){return anterior+atual; );

alert(dadosSoma); //exibindo o valor do resultado
Esse tipo de pensando, em dividir grandes quantidades de dados em conjuntos, economiza muito processamento e torna o código mais refinado para outros programadores. Fazer esse tipo de implementação no lado do client, entra no conceito de sistema distribuídos, aonde você divide a compilação dos dados pelo o numero de acessos e cada client fica responsável por compilar os seus dados, ao invés do servidor compilar milhões de usuários juntos.

Hoje, organizar dados de forma bonita e que não assuste as pessoas é um desafio para muitos desenvolvedores. Existem muitas APIs para nos ajudar nessa tarefa, hoje vamos conhecer uma que está sendo muito usada devido sua agilidade e, claro, por levar o logo do Google.

Essa API além de ser uma mão na roda, tem algumas vantagens como, por exemplo, você poder gerar os gráfico em SVG e poder pre-compilar os dados (no caso para gráfico gigantes), no próprio servidor da Google, além de deixar o seu dashboard com algumas funções e com aquela cara amigável que o Google Analytics tem.

Bem, para começar a utilizá-la só precisamos importa-la direto do servidor para o nosso site:



Agora dentro de uma nova tag script, vamos carregar o tipo de gráfico precisamos:



Notem que não precisamos declarar o objeto “google”, dentro do pacote que importamos, ele já esta como obj static ,funcionando como uma especie de singleton, assim ele só carrega e compila os pacotes que enviamos, isso economiza, e muito, a memoria do navegador, já que ele nunca vai carregar tudo.

No caso do método load, primeiro passamos o parâmetro “visualization”, que se encarrega de carregar os pacotes gráficos do google, logo em seguida passamos a versão que vamos usar, no caso a “1.0″, a versão atual dessa lib e por ultimo quais packages vamos importar, vamos pegar o ‘corechart’ que seria o pacote de gráficos mais simples.

Só depois que a função terminar de carregar os pacotes que chamamos, é que poderemos montar o gráfico, como não sabemos quanto tempo isso demora, podendo ter variações por conta da conexão do usuário e para a página não ficar travado enquanto esperamos, essa API tem um função de call-back.



Com essa chamada de callback, vamos enviar qual ação será tomada depois que tudo foi carregado, podemos criar uma chamada dentro dela ou informar um nome de função, vamos informa o nome da função, que vai se chamar “desenharMeuGrafico”.

Agora precisamos criar a função de nome “desenharMeuGrafico”:



Como essa função só vai ser chamada depois que se tem certeza que todas as libs foram carregadas, podemos colocar toda a parte para gerar e compilar dados nela.

Primeiro vamos iniciar a variável “grafico”, com isso setamos quais colunas e dados vamos mostrar no gráfico, depois criamos a variável “opcao”, aonde passamos o tamanho e o titulo do nosso gráfico.

Agora vamos criar a variável “desenho”, nela escolhemos o tipo de gráfico para ser renderizado, no caso escolhemos o “PieChart”, o famoso gráfico pizza, e logo em seguida passamos como parâmetro o objeto da DIV aonde queremos que o gráfico fique.



Nesse trecho de código fizemos apenas um gráfico usando apenas os recursos mais básicos que essa API oferece, se olharmos a documentação dela mais afundo, podemos notar que temos infinitas possibilidades com ela, como animações e prever eventos em cima dos gráfico que criamos, com isso podemos fazer Dashboards cada vez mais interativos.

Vamos imaginar um mundo que pode transformar-se a nossa volta, um cenário em que tudo esta conectado ao ponto em que toda a informação é relevante, tudo pode ser usado e compartilhado, não estamos pensando no futuro e sim no momento de evolução em que nos encontramos.

Vamos imaginar que hoje ao acordar você abre a geladeira e percebe que ela esta com algum problema, mas você não se preocupa com isso, afinal, a sua geladeira já “avisou” a empresa que ela se encontra na garantia e você já recebeu um e-mail perguntando qual seria o melhor horário para um técnico ir pessoalmente resolver seu problema. O técnico em questão também já sabe qual o defeito, afinal a sua geladeira já mandou um diagnostico completo para ele. Podemos ir mais longe ainda, ao sair de casa, seu relógio apita e avisa que você está em uma região que tem alguns problemas de transito nesse momento e sugere que pegue um metro, nessa situação, é possível também, ao passar pelo metro você usar seu celular para pagar pela passagem.

O cenário que descrevemos agora, faz parte de algo que esta acontecendo há algum tempo e hoje já se tornou uma realidade, ela se chama IoT ( Internet of Things ou Internet das Coisas), graças a isso temos o que podemos chamar de M2M (Machine to Machine ou Maquina com Maquina), que permite que os objetos conversem entrem si para nos informar sobre as mudanças de estado do mundo a nossa volta e além disso, eles podem tomar decisões e prevenir futuros defeitos.
Agora analisando o cenário geral, por que estamos falando a respeito disso hoje? Qual a relação que isso tem com os desenvolvedores de web? Bem, o maior avanço nisso tudo foi o refinamento e a praticidade elaborada para o desenvolvimento dessa plataforma, baseado em eletrônica básica e junto com conhecimentos de programação, qualquer um que saiba programar pode fazer seu próprio produto de IoT. Os kits de desenvolvimento são fáceis de mexer e baratos, fazendo nós, os desenvolvedores, focarmos na lógica e inovação do mesmo.

Grande parte dos esforços hoje em dia é focada em sistemas para casas inteligentes, mas já podemos encontrar desde cadeados de bicicletas inteligentes, até mesmo tapetes que avisam quem está em um determinado lugar da casa ou do escritório. Tudo isso está sempre conectado à internet e registrando na rede todos os dados coletados.

Hoje temos vários kits de IoT, os quais podemos desenvolver em cima. Um dos mais famosos é o Arduino Intel Galileo, que a Telefônica adaptou para que se possa desenvolver usando nodes.js, isso mostra que pela primeira vez podemos construir “coisas vivas”, saindo do mundo abstrato. Empolgante não?

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:

http://richard.brochini.com/SorrisoDefender.rar

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:

set_include_path(‘projeto/bluevia/ZendFramework-1.11.11/library’);
include_once “src/BlueviaClient.php”;

Depois criamos o arquivo para escrita:

$file = fopen (“temp”, “a”);

Agora iniciamos as classes e passamos a chaves de acesso do Bluevia:

$mode= BlueviaClient_Api_Constants::LIVE_MODE;
$application_context = array(
‘app’ => array(
‘consumer_key’ => ‘xxxxxx’,
‘consumer_secret’ => ‘xxxxxx’
));
$bv = new BlueviaClient($mode,$application_context);
$sms = $bv->getService(‘SmsMo’);

Definimos nosso shortcode, responsável por identificar nossa aplicação dentro da rede:

$shortcode = “xxxx”;

Agora fazemos o loop para ficar “aguardando” os sms’s chegarem e logo em seguida guardar o conteúdo deles no arquivo temp:

while(true){
try{
$msg = $sms->getMessages($shortcode);
if($msg!=”){
$temVars = $msg->receivedSMS->receivedSMS->message.”-”.$msg->receivedSMS->receivedSMS->originAddress->phoneNumber.”\r\n”;
while(true){
if(is_writable(temp)){
echo $temVars;
fwrite($file,$temVars);
break;
}
}
}
}catch(Exception $e) {
echo “erro “.$e->getMessage();
}
sleep(1);
}
fclose($file);

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:

$oldpath = set_include_path(‘.:/home/tecnomancher/projeto/bluevia/ZendFramework-1.11.11/library’);
include_once “src/BlueviaClient.php”;
$mode= BlueviaClient_Api_Constants::LIVE_MODE;
$application_context = array(
‘app’ => array(
‘consumer_key’ => ‘xxxxxx’,
‘consumer_secret’ => ‘xxxxx’
),
‘user’ => array(
‘token_access’ => ”,
‘token_secret’ => ”
)
);
$bv = new BlueviaClient($mode,$application_context);
$application_context = array(
‘app’ => array(
‘consumer_key’ => ‘xxxxx’,
‘consumer_secret’ => ‘xxxxxx’
),
‘user’ => array(
‘token_access’ => ‘xxxxxxxxxxxxx’,
‘token_secret’ => ‘xxxxxxxxxxxxx’
)
);

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.