Instalando Quake
Agora, voltarei a jogar. =)
Recentemente saiu a notícia no BR-Linux: estava disponível para jogar Quake Live com a pequena instalação de um plugin no Firefox. Entro no site do quakelive e tento instalar no meu Firefox ou no Safari do Mac OS X. O resultado foi o mesmo, a tela abaixo.
Incompatibilidade de plugin
Instalando o plugin
Plugin instalado
Prossigo com o processo de instalação, ele demora um pouquinho baixando atualizações (ok, minha banda de conexão não é muito larga), mas finalmente consigo começar o jogo. Como estou jogando na VM, com recursos escassos para vídeo e conexão lenta, o jogo ficou bastante lento, porém mesmo assim dá pra sentir que o jogo está bom e é empolgante ter essa portabilidade para GNU/Linux através do Firefox. Resta agora conseguir isso para o Mac OS. =)
Carregando jogo
Tela de boas vindas
Começando a jogar
Jogando em tela inteira
Chegando aquela época do ano novamente: muitas coisas por vir, muitas expectativas. E já estamos quase em abril, então…
Outra expectativa: joguinho interessante da produtora de games “The Behemoth”. Nunca joguei nada deles, mas se o trailer abaixo for fiel ao gameplay, parece bom.
Isso sem contar a expectativa final: provas e projetos. O bom e velho stress entre provas, projetos, trabalhos, monitoria, e IC. Sem isso, não tinha graça. =)
Quem viver, verá!
Enquanto estava estudando a linguagem de programação Lua, em um capítulo sobre elementos funcionais da linguagem, me deparei com uma explicação interessante para tail recursion. Nela, o autor do livro (Programming in Lua, 1ª Edição) falava como a linguagem implementa completamente tail recursion(que acho que fica bem traduzido como recursão de cauda). Até aí tudo legal, mas melhora.
Bem, pra demonstrar que implementa e também explicar o conceito, o autor se utiliza de um jogo-exemplo: um labirinto. O jogo constrói o labirinto através de funções que chamam umas às outras, porém utilizando-se de recursão de cauda para manter sempre o uso de memória como se só houvesse uma função. Explicação e o exemplo utilizado podem ser encontrados aqui.
Explicando melhor recursão de cauda: o princípio é que não precisamos que uma função fique esperando o retorno de um resultado de outra para terminar sua execução, como acontece normalmente. Se você faz uma função em C, ou um método em Java, que termina com um comando return outraFuncao;, a função original ficaria esperando o termino da chamada para poder terminar sua execução. Só que outraFuncao pode fazer chamadas a outras funções, e essas a mais outras, e assim por diante. Tal carga será deixada para a memória, que acabará por estourar(um stack overflow, ou estouro de pilha). Mas perceba que, no caso de uma instrução final de uma função, não há motivo para a espera de retorno da chamada. Pode-se simplesmente indicar que o retorno será o da função agora chamada, e limpar a memória utilizada pela execução da original. É isto que linguagens funcionais como Haskell e Scheme e linguagens com fortes influências, como Lua, implementam.
A novidade que gostaria de compartilhar aqui é uma implementação do mesmo código feito em Lua, para Haskell. O código pode dar origem a um jogo bastante complexo e infinitamente escalável, já que ao chamar uma nova função (entrar em um novo quarto) nenhuma informação é mantida da que chama, e sua execução é encerrada por completo. Código em Haskell abaixo:
import IO
main = do
room1
room1 = do
putStrLn "You're in room #1"
text <- getLine
if text=="south" then
room3 -- movendo-se pro quarto 3
else
if text=="east" then
room2 --movendo-se pro quarto 2
else
putStrLn "Invalid move" >>
room1 --permanece no mesmo quarto
room2 = do
putStrLn "You're in room #2"
text <- getLine
if text=="south" then
room4
else
if text=="west" then
room1
else
putStrLn "Invalid move" >>
room2
room3 = do
putStrLn "You're in room #3"
text <- getLine
if text=="north" then
room1
else
if text=="east" then
room4
else
putStrLn "Invalid move" >>
room3
room4 = do
putStrLn "You're in room #4! You won!"
O código é simples, elegante, e correto. É este mesmo comportamento que torna a recursão um ponto tão forte em Haskell: iteração não é necessária à linguagem pois recursividade não apresenta peso adicional algum ao código. Isto nos permite escrever funções recursivas muito mais poderosas do que podemos encontrar em uma linguagem como C ou Java, onde a pilha de execução não suporta tantas chamadas quanto uma tarefa mais complexa possa precisar(ex.: inserção em uma árvore AVL com 100 mil nós). Isso nos permite executar códigos como o clássico exemplo do fatorial:
fact x = if x < 0 then error"Fatoriais sao de numeros positivos!"
else fact2 x 1 where
fact2 0 acumulador = acumulador
fact2 x acumulador = fact2 (x-1) (acumulador*x)
Pode-se rodar este exemplo e calcular o fatorial de 100 mil, o que não é possível com recursão em C. Apesar do peso do alto nível de abstração, vemos aí parte do poder do paradigma funcional e da linguagem Haskell!
PS: Erro corrigido no quanto à recursividade do fatorial. Ah, e o exemplo do fatorial pode não dar Stack Overflow, mas dependendo da entrada você pode atingir picos de uso de CPU. =)
Como prometido aqui, colocando algo que eu estava vendo há algumas semanas atrás, bem interessante e, por enquanto, fácil de mexer: Manipulação de sons com Pygame.
Pygame
Uma explicação antes: Pygame é uma biblioteca para produção de jogos em Python. Oferece suporte a sons, gráficos 2D e 3D, entre várias coisas necessárias à produção de jogos. Aqui eu estou mostrando só como utilizá-la para tocar e manipular sons.
Para começar, é necessário importar o módulo pygame e inicializá-lo.
import pygame pygame.init()
Manipulação mais simples: usa-se a classe Sound.
from pygame.mixer import Sound audio = pygame.mixer.Sound(caminhoArquivo)
onde caminhoArquivo é uma String contendo o caminho relativo até o arquivo de som, ou o caminho absoluto no sistema. Pygame por padrão suporta extensões .wav e .ogg, ao menos na versão testada(Linux). Chega a ser estupidamente fácil a maneira como você manda tocá-lo:
audio.play()
onde o método play também pode receber um argumento da quantidade de vezes que toca novamente, e outro do tempo destinado a tocar. No caso maior, a interface dele fica algo como play(numeroDeRepetições,duração). Pode-se fazer um som tocar uma quantidade infinita de vezes passando o argumento como -1.
Vários canais de som também estão disponíveis, e você pode tocar vários sons simultaneamente. Por exemplo:
musica = Sound(musica1)
som = Sound(som1)
v = True
musica.play(-1)
while(True):
if v:
som.play()
v = not v
O exemplo é meio absurdo, já que eternamente ocorreria o laço e não haveria pausa alguma. Porém a idéia principal é que toda vez que v for verdadeiro, será tocado o som. Enquanto tudo acontece, a musica continuará tocando normalmente.
Manipulação aprimorada: usaremos agora o tipo sndarray.
import pygame.mixer.sndarray from pygame.mixer.sndarray import * arraySom = array(musica)
Agora você tem um array contendo todas as amostras de byte do som. Isso é um array BEM grande. Por exemplo, se o som tiver uma taxa de amostragem de 11000Hz, temos 11000 amostras por segundo. Logo, o tamanho do array é de 11000 * tamanho do som em segundos. Você pode testar isso manipulando este array, como no exemplo abaixo:
novoArray = arraySom[0:33000]
Considerando que temos um som com amostragem de 11000Hz, temos agora um novoArray com o equivalente a 3 segundos de amostragem(≈1/11000 segundo). Para tocar, podemos converter de volta para Sound.
novoSom = sndarray.make_sound(novoArray) novoSom.play()
Pronto, agora você tocará aproximadamente 3 segundos do objeto musica original, do tipo Sound, uma representação do arquivo de som original passado como argumento.
Canais de reprodução
Há também maneiras para controlar os canais que são utilizados. O método play da classe Sound retorna um objeto de tipo Channel. Com ele, você pode controlar algumas coisas como volume de audio, inclusive para cada saída de som. Como funciona: a classe Channel possui um método setVolume, o qual recebe uma tupla numérica, onde os argumentos vão de 0 a 1(argumentos maiores que 1 funcionam como 1, até onde testei).
volume = 0.3, 0.7 canal = musica.play() canal.setVolume(volume)
Você pode ouvir agora a saída da esquerda com som menor que a da direita, e nenhuma das duas com o volume máximo.
Canais de reprodução são alocados automaticamente pelo sistema, e possuem um numero limitado. Você pode aumentar a quantidade de canais, usando-se do método set…, e alocar explicitamente o canal que você deseja para o toque do som, utilizando-se do seguinte formato:
valor_desejado = 10 pygame.mixer.set_num_channels(valor_desejado) #você tem agora 10 canais disponíveis. pygame.mixer.set_reserved(1) #você reservou um canal. Agora pygame não alocará automaticamente nada no canal 0. canal = pygame.mixer.Channel(0) #atribuiu seu canal reservado à variável canal canal.play(musica) #tocará o som musica no canal reservado.
Com tudo isso você pode editar seus sons, fazê-los tocar da maneira que deseja, simular sons vindos de diferentes posições(Stereo Panning, brincando com os volumes das caixas), ou seja, tem um arsenal pra manipulações sonoras bastante potente. Tudo graças a uma biblioteca de jogos. =)
Boa parte desse código foi testado em uma instalação do pygame, usando de Python versão 2.6. Talvez não haja disponível versão para a nova versão 3.0. Talvez haja algum erro, mas prometo revisar isso depois. =)
Este post é dedicado aos lendários jogos de Adventure de outrora, jogos que fizeram minha infância e adolescência muito mais interessantes. =)
Os jogos deste gênero produzidos no começo dos anos 90 pela Lucas Arts tinham tudo: humor, sarcasmo, inteligência, ação e até romance – a p**ra toda. Foi uma boa era. Jogos muito bem feitos, nos quais você não tinha como perder: parte da filosofia da empresa era que “jogos são feitos para divertir, não para frustrar o jogador” – havia realmente declarações da filosofia nos manuais dos jogos! É, muita coisa mudou desde então. Por isso, volta e meia recorro a eles.
Full Throttle
“An ambush? Really?”
, por Miranda, amiga de Maureen, pouco antes de ela lhe sacanear não lhe dando uma carona.
Hit the Road
Day of the Tentacle
The Day of The Tentacle é um jogo ousado. É bem provável que ele seja um dos motivos de eu gostar de história, já que sua paródia da história americana junto com a idéia de causalidade de fatos e apelo científico tornam o jogo bastante complexo. Paradoxos de viagem no tempo são deixados de lado quando você precisa salvar o mundo!
Um pouco do enredo: Não menciono o Maniac Mansion original aqui por alguns motivos: sua dinâmica era um tanto mais confusa que o 2º, nunca cheguei a jogá-lo por completo, e ele não possuía a filosofia de que o jogador não pode perder – não necessariamente nesta ordem. Mesmo assim, sua história tem continuidade no segundo jogo da série, onde 3 estudantes voltam a Mansão para salvar o mundo, quando um tentáculo – criação do Dr. Fred, gênio lunático do primeiro jogo – pede socorro com ajuda de um hamster. Ao salvarem o tentáculo bom, eles também libertam um tentáculo terrivelmente maligno, que parte então para dominar o mundo. A única solução então é viajar no tempo de forma a impedir que o tentáculo maligno ganhe poderes, e venha a precisar ser impedido. Quando os três personagens tentam fazê-lo, acabam se separando entre o passado, presente e o futuro, e AÍ começa a diversão de verdade. =)
Um último jogo sobre o qual eu comentaria seria a série da Ilha dos Macacos (Maldição, fuga, etc). Formam uma série muito bem sucedida e tal, MAS eu nunca os joguei. Houve milhares de comentários entre amigos, porém nunca tive a oportunidade. Uma pena. Quando jogar, colocarei algo aqui.
