Postagens populares

Mostrando postagens com marcador retroprogramação. Mostrar todas as postagens
Mostrando postagens com marcador retroprogramação. Mostrar todas as postagens

domingo, 25 de novembro de 2012

Um mês sem postagens...

De fato este mês o blog ficou às moscas, como um morto esquecido na tumba. Não adianta afirmar muito sobre as razões desse aparente abandono, afinal todos nós temos nossos contratempos, não é? - faz parte do ciclo da vida.

Deixando de lado as lamúrias vamos aos relatos deste mês parco em atualizações. 

Comecemos pelo homebrews para megadrive. No pouco tempo que tive para realizar experiências e criar em algum código, descobri uma ferramenta interessante para reduzir a quantidade de cores (quantizar) uma imagem. O nome da maravilha atende pelo singelo nome de Riot. O programa faz o um serviço semelhante ao efetuado manualmente com o Gimp. Então qual é a vantagem em tê-lo instalado? A vantagem é que as poucas configurações e a resposta quase instantâneamente do programa permitem um resultado muito bom - em minha opinião - sem ter de perder muito tempo. O exemplo abaixo deixa claro o resultado do programa no tratamento de imagens:

 A imagem original de Orihime (Bleach) usada no teste


A imagem tratada pelo Riot no Imagenesis e no emulador Kega fusion.

Essa imagem da Orihime, quando tratada pelo Gimp sempre me dava dor de cabeça. As reticulas existente no Gimp para quantizar a imagem acabavam por granular tudo, resultando em uma imagem bem "estourada", o que num console com resolução de vídeo baixa como o Mega drive piora ainda mais as coisas, deixando o problema bem aparente. Contudo o Riot faz o serviço de forma rápida e bastante competente, como os exemplos acima deixam claro: escolha a imagem, reduza para a resolução desejada, escolha o formato de saída (eu uso png), escolha a paleta otimizada de 16 cores, o algoritmo de redução e pronto. Veja o resultado, salve e continue com o serviço no Imagenesis e seu código com o Basiegaxorz.

Assim, o Riot consegue ser uma solução bem prática. Não faz milagres como Gimp mas pelo pouco tempo que tive de uso creio que será um ferramenta muito útil para homebrew. O único grande senão do programa é ter cuidado com o esquema "next-next-next", sem prestar a devida atenção, na hora da instalação. O Riot pode, se você não tomar cuidado, instalar um programa indesejado em seu computador. Fica a dica para quem se aventurar a utilizá-lo.

Na outra ponta de minhas experiências está o Quake. Andei refletindo sobre outros projetos baseados nos passos do Openquartz, tais como o Openquarz 2 e o OQPlus, visando criar um jogo completo, open source assim como o código-fonte liberado pela ID Software. A conclusão foi bem desagradável e realista. Falta uma orientação na parte do design para criar o universo em volta do jogo.

Explico. No que diz respeito a substituir recursos de arte, o Openquartz consegue ter algum sucesso no processo de substituição. E tiro meu chapéu que foi um trabalho enorme juntar tudo e isso não merece ser despresado. Existem modelos, existem sons, existem texturas, existem mapas. Mas eles não "funcionam" de forma coesa. Não há um "mundo" para "imergir", não há um significado por mais simples que seja que explique qual a sua identidade e qual a sua função naquele universo estranho. Você é apenas um "boneco" vagando por salas com armas sendo atacado por coisas esquisitas como uma "Boneca Vodoo" (o modelo que substitui o fiend) ou terroristas com m16 (o modelo que substitui o grunt).

Óbvio que isso é um tanto filosófico e não faz muito sentido para quem está interessado, em algo veloz e caótico como um passatempo rápido, digamos como uma partida de deathmatch ou um jogo casual. Mas o impacto é profundo e bastante evidente:

Quake sem modificação alguma. Tudo parece estar no lugar.

Quake com alguns recursos do Openquartz.

Na imagem de cima, do Quake original, tudo parece se encaixar. Do hud que traz informações importantes, as texturas do mapa e a estrutura do cenário e os modelos. O que não ocorre com a simples substituição operada quando se usa recursos do Openquartz. Pode-se alegar que isso ocorreu por que eu simplesmente atirei alguns modelos dentro de uma pasta e os carreguei por cima dos modelos originais esperando que isso magicamente transformasse um jogo em outro. Ledo engano. Observem isso:

Ladrilhos? Chapas de metal? O céu vazio? Propaganda do Openquartz?

Ganchos de ferro pendurados no vazio? Um poço de lava? Céu vazio, de novo?

Rampas no meio do vazio? Uma torre infinita? Céu vazio novamente?

Ladrilhos hexagonais? Chapas de metal? Céu, adivinha? Vazio...

Uma grande porta de metal? Paredes suspensa no vazio? Ok isso já ficou chato, céu vazio...

Grama? Caixas de metal espalhadas? Árvores se mexendo? O quê diabos está voando? Céu azul!!!

Entenderam meu ponto de vista? Falta algo até mesmo para dizer que o Openquartz é mesmo um jogo incompleto, falta uma "alma", algo unindo todas as coisas. Esta "alma", esta identidade está presente em cada canto do Quake e é facilmente observável. Seja no rosnado de um Grunt, seja nas portas de metal das bases, seja no modelo nada sutil de um Shambler. Mas que não se observa mesmo quando o Openquartz tenta "dizer algo", com seus próprios meios ao jogador.

Sou obrigado a pensar que existe uma maneira de interligar todas as coisas dentro de um determinado universo. E fazê-lo minimamente correlacionado, interdependente, entre suas partes. E não uma colcha de retalhos frouxamente costuradas como as imagens acima, ao menos para mim, parecem demonstrar. E é essa identidade, essa "alma" que eu gostaria de encontrar para dar uma destinação viável a este projeto.

Bem, por hora é só. Espero retornar a atualizar este humilde blog com alguma regularidade. Mas sem promessas de minha parte - infelizmente.

segunda-feira, 1 de outubro de 2012

Nyan Cat portado para PSX

É isso mesmo que você leu, Nyan Cat foi portado para PSX. O primeiro console da Sony, mesmo que de forma tímida, tem uma comunidade forte de retroprogramadores criando coisas para este sistema. Mesmo com a dificuldade de manusear um hardware complexo e com pouco suporte a homebrew.


É possível baixar os binários para queimar em CD-R ou usar em um emulador, deste fórum aqui. Notícia bacana para começar o mês de outubro. Via Emu Console Exploit.


terça-feira, 25 de setembro de 2012

Outra cria do demoscene para mega drive: Awaken!

Encontrei este demo para mega drive recentemente em uma das minhas andanças pelo Pouet.


Awaken não tem uma temática tão pesada quanto a última que postei aqui no blog, Zombie, chegando mesmo a ser engraçado em algumas partes. Muito embora seja um demo bastante simples, é divertido de se assistir. Quem tiver interesse é possível baixar a rom do demo aqui.

sábado, 15 de setembro de 2012

Zombie: Demo lançado para o Mega Drive


A demoscene me surpreende de tempos em tempos com suas produções. Para quem não faz idéia do que isso seja, imagine um bando de programadores entendiados, loucos para mostrar suas habilidades, elaborando pequenas peças de áudio e vídeo em tempo real. Em uma visão simplista é isto. Mas uma visita ao Pouet pode ser bem mais esclarecedora que minhas palavras.


De qualquer maneira o que me trouxe hoje a postar estas linhas foi o demo lançado pelo grupo K-Storm. A demo tem um visual sombrio e perturbador, o áudio também acompanha o clima de filme de terror, porem não se verificam lançamentos para o Mega Drive com tanta frequência então qualquer coisa nova é muito bem vinda. Segue um pequeno vídeo abaixo:


Para quem desejar testar in loco, é possível baixar a rom da página da K-Storm aqui. Notícia obtida do PDRoms.

sexta-feira, 14 de setembro de 2012

Em que estou trabalhando nas horas vagas



É nisso que estou trabalhando ultimamente. 

Estou testando resoluções diferentes para a tela do bom e velho Sega Mega Drive/Genesis. O objetivo é ter espaço livre na memória do VDP (video display processor) para outras coisas, como por exemplo escrever texto ou utilizar sprites, junto com outras imagens. E isso é (mais ou menos) fácil de entender: O Mega Drive possui várias resoluções, conforme as especificações do console, mas estou utilizando como base a resolução de 320 X 224 píxeis.

Agora vem um pouco de matemática para compreender o que estou fazendo. Multiplicando-se a resolução base (320 X 224) obtém-se o valor de 71680 píxeis. Contudo, ó VDP não trabalha diretamente com píxeis, mas com tiles, que são blocos ou quadradinhos de 8 X 8 píxeis. Isto significa que um tile é igual a 64 píxeis (8*8=64). Então os 71.680 píxeis consomem exatamente 1120 tiles (71.680/64=1.120) em uma tela. Isso ocorre caso todos os tiles sejam diferentes entre si ou a imagem não seja otimizada para reaproveitar tiles iguais. Acontece que todo programador que trabalhe com plataformas deste tipo sabe reutilizar tiles ou faz outros truques para evitar ultrapassar os limites da memória VDP.

Parece confuso? Nem tanto.

No meu caso, testei várias resoluções diferentes das imagens, as quais reduzo as cores para teste. A propósito, aqui cabe um parentese sobre outra característica do Mega Drive. O console somente suporta 4 paletas de 16 cores cada, sendo que das 16 cores apenas 15 são cores de fato e mostradas na tela por cada paleta. A cor que sobra é utilizada como "transparência", isto é, não aparece quando o sprite ou imagem é utilizado. Depois de muita tentativa e erro cheguei a uma resolução de imagem de 240 X 224 píxeis, e a explico a razão desta escolha.

Novamente matemática: 240*224 píxeis equivalem a uma resolução com  53.760 píxeis na tela. Transformando isso em tiles temos que esta resolução equivale a 840 tiles (53.760/64=840). O basiegaxorz facilita muitas coisas para o programador. Como, por exemplo, ter vinculado ao comando Print vários caracteres ASCII que já vem embarcados na VDP. Contudo para ter essa facilidade temos de reservar pelo menos 256 tiles da memória. Isto implica em usar no máximo 864 tiles (1120-256=864) para imagens convertidas ou sprites. Como já disse a resolução de 240 X 224 equivale a 840 píxeis, então ainda sobra depois de toda esta matemática 24 tiles (840-864=24) para usar como eu deseja.

Óbvio que a técnica que estou trabalhando é ineficiente por não otimizar a imagem da resolução de 240 X 224. Caso a imagem fosse otimizada, para reutilizar píxeis, por exemplo, a quantidade de memória livre no VDP seria muito maior. Por hora isso me serve para alguns experimentos e testes. Espero logo já ter dominado razoavelmente esta característica do Mega Drive e ter compreendido como implementá-la no Basiegaxorz.

Talvez eu poste o código fonte comentado em breve para quem tive curiosidade fazer seu próprios testes.




terça-feira, 28 de agosto de 2012

Conversor de temperatura para Mega Drive


Eu tenho este código escondido em meu HD a um bocado de tempo. Hoje chegou o dia de aparecer para o mundo. Ok, admito, não é nada tão grandioso assim. Na verdade não passa de uma experiência de programação, para não enferrujar no dialeto basic para Mega Drive - O basiegaxorz. O código simplesmente converte as temperaturas fornecidas pelo usuário entre as escalas Celsius e Fahrenheit. 

Na época em que escrevi este código me preocupei apenas as equações de transformação. Usei vários comandos PRINT e INPUT como meio de armazenar variáveis e mostrar para o jogador. Confesso que esta é uma forma bastante primária e desajeitada de criar uma interface, mas na época era o que eu conseguia fazer. 

Abaixo segue o código para quem for curioso:

    'teresina, 05/04/09
    'este é apenas um conversor de temperatura para as
    'escalas Fahrenheit e Celsius. Coisa simples.
    'update, 28/08/2012
    'apenas acrescentei a variável a para facilitar
    'alterações futuras do comando sleep
   
    option title, "Temp_Converter"
   
    a=100
   
inicio:
    cls
    print "        TEMP_CONVERTER V.02"
    print ""
    print "Este programa converte a temperatura"
    print "entre as escalas Fahrenheit e Celsius."
    print "Escolha o tipo de escala a ser usada,"
    print "entre com o valor a ser convertido e"
    print "o programa retorna o valor. Simples."
    print ""
    print "Voce deseja?"
    print "1. Converter Fahrenheit para Celsius?"
    print "2. Converter Celsius para Fahrenheit?"
        input opt1
        if opt1=1 then
        goto f_to_c
        endif
        if opt1=2 then
        goto c_to_f
        endif
        if opt1 != 1 [or] opt1 !=2 then
        goto inicio
        endif
       
f_to_c:
    cls
    print ""
    print "Voce escolheu:"
    print "Converter Fahrenheit para Celsius"
    print "Entre com a temperatura em Fahrenheit"
    print "a ser convertido:"
    input f
    c=5*(f-32)/9
    print f;" graus Fahrenheit equivale a"
    print c;" graus Celsius."
    sleep a
    goto inicio
   
c_to_f:
    cls
    print ""
    print "Voce escolheu:"
    print "Converter Celsius para Fahrenheit"
    print "Entre com a temperatura em Celsius"
    print "a ser convertido:"
    input c
    f=32+(c*9)/5
    print c;" graus Celsius equivale a"
    print f;" graus Fahrenheit."
    sleep a
    goto inicio



A propósito, observando o código é possível verificar o quanto pode ser aprimorado: Substituir os comandos INPUT por outro método que não seja tão desajeitado e mais intuitivo de interagir com o usuários. Usar o joystick como meio de entrada. Talvez colocar alguns gráficos em segundo plano, etc, etc, etc. 

Daria um bom projeto de final de semana.

domingo, 20 de fevereiro de 2011

Raro sega Mega Drive/Genesis devkit encontrado

Recentemente vasculhando o site Retro Treasures, encontrei uma unidade de desenvolvimento, um devkit, bem estranho para o Mega Drive/Genesis. Em verdade é um "combo" incomum de Mega Drive Sega/Mega CD em uma unidade só. Ao contrário do que ocorre atualmente, onde é possivel ter emuladores ou mesmo utilizar computadores não muito diferente de um desktop comum para desenvolvimento, antigamente era necessário ter um hardware especialmente preparado para conseguir criar algo para um videogame.


A unidade em questão estava à venda no Ebay e o vendedor deu algumas informações interessantes, além de colocar um vídeo no youtube sobre o funcionamento do equipamento. A primeira informação relevante diz respeito à origem do devkit. Segundo o vendedor, e as fotos mostrando as etiquetas de série, a unidade foi produzida pela Cross Products Ltd, alegadamente a pedido da Sega. De fato, a Cross Products Ltda, trabalhou em vários kits de desenvolvimento, tanto para o Sega Genesis/Mega Drive, Sega CD/Mega CD, e até mesmo há informações que teria vendido kits para 32X. Um de seus produtos mais conhecidos é o assembler Snasm68K - bastante conhecido na época em que o Dos era o grande sistema operacional vigente como um programa razoavelmente eficiente. O que torna a alegação do vendedor um pouco mais sólida.

Contudo outra informação dada pelo vendedor, me deixou com a pulga atrás da orelha. Ele afirma que o aparelho é "refurbished" (recondicionado), isto é, foi mexido por dentro para funcionar. Não é incomum em consoles antigos ter de remover capacitores estragados ou mesmo tirar o pó. Mas sem outras informações mais sólidas, esta unidade por exemplo, não vem com manuais e/ou documentação técnica, o "recondicionamento" pode ser entendido não como um meio de fazer o troço  funcionar, mas como um casemod competemente produzido para vender gato por lebre. Pessoalmente é a primeira vez que vejo  uma unidade deste tipo em anos, funcionando, e vendedores desonestos não são nenhuma novidade. Não que o vendedor da unidade seja, não afirmo tal coisa, mas simplesmente algumas fotos e um vídeo não garantem a autenticidade do aparelho.

De qualquer forma ficam as fotos e o vídeo no youtube para os curiosos de plantão.








Mais infomações sobre kits de desenvolvimento, para várias plataformas, pode ser obtida aqui:

domingo, 28 de novembro de 2010

Experiência: Criando um adventure para o Sega Mega Drive/Genesis

 De volta ao hello world.

Muito tempo atrás fiz um post sobre o Basiegaxorz, um compilador basic que permite programar jogos/programas para o Sega Mega Drive/Genesis e seus complementos, como o Sega CD e o 32X. O post em si era bem simplificado mas mostrava os comandos básicos do dialeto basic para manipular frases, a paleta de cor e a posição da letras. Nada muito complicado. Na época frisei que iria postar mais algum tutorial sobre a liguagem, expandindo o que havia sido feito.

Mas quem acompanha o blog já deve saber que não sou lá muito bom de cumprir promessas. O tempo passou, muitas coisas aconteceram e terminei por deixar o tutorial de programação para o Mega Drive/Genesis esquecido. Agora muito tempo depois tento remediar, um pouco, a situação. Não, este aqui não é o tutorial prometido, mas uma pequena idéia que já tenho há algum tempo - junto com a vontade de tirar a ferrugem do Basiegaxorz.

A premissa seria a criação de um adventure para o Mega Drive. Nada muito extravagante e cheio de pirotecnia. Apenas um jogo baseado no "modo texto/linha de comando" que se consegue com a manipulação de frases, laços de execução, paletas de cores e uma estória minimamente interessante. O que acredito ser teoricamente possível com uns poucos comando de print, ink e goto no Basiegaxorz. A título de informação um adventure basicamente é um estória "guiada". O jogador assume o papel de protagonista em uma ficção interativa. Um exemplo de adventure, ou melhor de graphic adventure na plataforma seria o jogo Snatcher, para o Sega CD.


 O primeiro esqueleto de código. 30 minutos muito bem empregados..


As vantagens em se criar um jogo desta natureza seriam a simplicidade do código e o foco voltado na estória. Contudo, os aspectos negativos, tinha que existir alguma coisa em contrário ou não teria graça, seriam profundidade da estória elaborada, o gerenciamento de itens e a questão mais complicada de todas - a interface com o usuário. Abaixo segue  um código de teste escrito e desenvolvido em um espaço de uns 30 minutos com o Basiegaxorz versão 1.37. Para testar basta copiar, colar na IDE do compilador, dar F5 e usar um emulador para ver o resultado.

Atenção: exceto pelas labels todo o resto deve ter um espaço ou TAB de distância da margem esquerda da tela para funcionar corretamente. Isso é exigência do compilador.

    'teste de um adventure. teresina, 27 de novembro de 2010.
    
    dim loc as integer
    dim opt as integer
    dim opt2 as integer
   
    loc = 5
inicio:
    'isso define os locais onde o jogador está
    ink 1
    if loc = 1 then
    print " voce esta em frente ao cemiterio"
    endif
    if loc = 2 then
    print " voce esta em frente ao hospital"
    endif
    if loc = 3 then
    print " voce esta em frente a uma praca"
    endif
    if loc = 4 then
    print " voce esta em frente ao ferro-velho"
    endif
    if loc = 5 then
    print " voce esta em frente a prefeitura"
    endif
    if loc = 6 then
    print " voce esta em frente ao armazem"
    endif
    if loc = 7 then
    print " voce esta em frente a um shopping"
    endif
    if loc = 8 then
    print " voce esta em frente a banco"
    endif
    if loc = 9 then
    print " voce esta em frente ao lixao da cidade"
    endif

tela_de_opcoes:
    ' a tela geral do jogo
    ink 0
    print ""
    print " O que voce deseja fazer?"
    print " 1 - Observar o lugar?"
    print " 2 - vasculhar o lugar?"
    print " 3 - ir para outro lugar"
    input opt
   
    if opt = 1 then
    goto observar
    endif
    if opt = 2 then
    goto vasculhar
    endif
    if opt = 3 then
    goto ir
    endif
    if opt < 1 [or] opt > 3 then
    'goto inicio
    goto tela_de_opcoes
    endif
   
observar:
    ' isso define o que o jogador vê em cada lugar
    ink 1
    if loc = 1 then
    'cemitério
    print " Esta escuro e voce escuta sons de grito longe."
    goto tela_de_opcoes
    endif
    'hospital
    if loc = 2 then
    print " o hospital esta destruido."
    goto tela_de_opcoes
    endif
    'praça
    if loc = 3 then
    print " a praca esta deserta"
    goto tela_de_opcoes
    endif
    'ferro velho
    if loc = 4 then
    print " o lugar parece esta abandonado"
    goto tela_de_opcoes
    endif
    'prefeitura
    if loc = 5 then
    print " parece uma zona de guerra"
    goto tela_de_opcoes
    endif
    'armazém
    if loc = 6 then
    print " ninguem vem a este lugar faz tempo"
    goto tela_de_opcoes
    endif
    'shopping
    if loc = 7 then
    print " o shopping foi arrasado"
    goto tela_de_opcoes
    endif
    'banco
    if loc = 8 then
    print " o banco foi assaltado"
    goto tela_de_opcoes
    endif
    'lixão
    if loc = 9 then
    print " muito lixo por toda parte."
    goto tela_de_opcoes
    endif

vasculhar:

    ' isso define o que o jogador encontra em cada lugar
    ink 1
    if loc = 1 then
    'cemitério
    print " existem covas abertas recentemente."
    goto tela_de_opcoes
    endif
    'hospital
    if loc = 2 then
    print " tem sacos de corpos etiquetados por toda parte."
    goto tela_de_opcoes
    endif
    'praça
    if loc = 3 then
    print " barricadas improvisadas fecham os acessos a a outras ruas."
    goto tela_de_opcoes
    endif
    'ferro velho
    if loc = 4 then
    print " maquinario pesado e velho abandonado por toda parte"
    goto tela_de_opcoes
    endif
    'prefeitura
    if loc = 5 then
    print " tem um mural com varias mensagens escritas."
    goto tela_de_opcoes
    endif
    'armazém
    if loc = 6 then
    print " engradados e conteineres estao espalhados"
    goto tela_de_opcoes
    endif
    'shopping
    if loc = 7 then
    print " varias lojas foram saqueadas."
    goto tela_de_opcoes
    endif
    'banco
    if loc = 8 then
    print " o banco esta com as portas arrombadas."
    goto tela_de_opcoes
    endif
    'lixão
    if loc = 9 then
    print " sacos de corpos e fogueiras estao por toda parte."
    goto tela_de_opcoes
    endif

ir:

    ' tela onde o jogo define para onde vai.
'    cls
    ink 1
    print ""
    print " para onde voce deseja ir?"
    ink 0
    print " 1 - cemiterio?"
    print " 2 - hospital?"
    print " 3 - praca?"
    print " 4 - ferro-velho?"
    print " 5 - prefeitura?"
    print " 6 - armazem?"
    print " 7 - shopping?"
    print " 8 - lixao?"
    input opt2
   
    if opt2 = loc then
    ink 2
    print " voce ja esta neste lugar."
    goto ir
    endif
    'cemiterio
    if opt2 = 1 then
    loc = 1
    goto tela_de_opcoes
    endif
    'hospital
    if opt2 = 2 then
    loc = 2
    goto tela_de_opcoes
    endif
    'praca
    if opt2 = 3 then
    loc = 3
    goto tela_de_opcoes
    endif
    'ferro velho
    if opt2 = 4 then
    loc = 4
    goto tela_de_opcoes
    endif
    'prefeitura
    if opt2 = 5 then
    loc = 5
    goto tela_de_opcoes
    endif
    'armazém
    if opt2 = 6 then
    loc = 6
    goto tela_de_opcoes
    endif
    'shopping
    if opt2 = 7 then
    loc = 7
    goto tela_de_opcoes
    endif
    'banco
    if opt2 = 8 then
    loc = 8
    goto tela_de_opcoes
    endif
    'lixao
    if opt2 = 9 then
    loc = 9
    goto tela_de_opcoes
    endif

    if opt2 < 1 [or] opt2 > 9 then
    goto ir
    endif

Como é possível observar este esqueleto de código é funcional, mas apresenta o defeito em relação a interface que relatei acima. O uso do comando input engessa por demais o sistema e num jogo/programa mais longo simplesmente iria torrar a paciência do usuário. Obviamente isso tem de ser retrabalhado e como ainda estou em fase "pre-alpha" do código, posso me dar ao luxo de ficar com esta solução capenga por hora.

Bom não é exatamente um tutorial. Mas demonstra que não esqueci o Basiegaxorz. Também demonstra que que tenho interesse em criar algo para o Mega Drive, mas não espero ter algo pronto em pouco tempo. Ainda tenho de tirar a poeira e as teias de aranha dos comandos que aprendi. Caso alguém deseje se aventurar na criação de um adventure o site MSX Adventure é um uma boa pedida para começar.

sábado, 16 de janeiro de 2010

Criando programas/jogos para o Sega Mega Drive/ Genesis




Nos idos dos anos 90 o universo dos jogos estava polarizado entre a Sega e a Nintendo. A Sega vinha com a força dos arcades e jogos de esporte - que ainda hoje fazem muito sucesso no mercado norte americano. E sua aposta era no primeiro console de 16 bits do mercado, o Mega Drive, também conhecido como Genesis em alguns países. A Nintendo por sua vez trazia a reputação adquirida com o Nes e grandes parceiros como Capcom, Konami, somente para citar alguns. O seu cavalo de batalha era na época o poderoso Super Nintendo, conhecido no Japão como Super Famicom. Não vou tecer comentários sobre quem venceu a guerra dos consoles, mas posso garantir, como alguém que a viu de perto, que foi um conflito dos mais divertidos da industria do entretenimento - e que deixou imensas saudades.



Mas voltando ao assunto, a Sega lançou o Mega Drive/Genesis e criou uma geração de jogadores facinados pelo aparelho e seu potencial. Alguns cresceram e começaram a projetar meios de criar programas - leia-se também jogos - para o console. Algumas tentativas deram certo, outras não, com variados graus de complexidade. As primeiras experiências exigiam que código fosse escrito em assembler 68K (o processador central do console era um Motorola 68000) e caso houvesse a necessidade, mais assembler, desta vez na variedade Z80 (desta vez o processador de som, o Zilog Z80). Posteriormente surgiram compiladores C, como o obscuro SGCC (Sega Genesis C Compiler) e mesmo métodos para fazer uso do famoso compilador GNU GCC. Tais opções são bacanas para quem tem experiência de programação ou tempo para aprendê-las. Mas os reles mortais do teclado também tem uma opção para criar seus programas para o Mega Drive. Mostraremos hoje como criar e rodar dois programas simples para o Mega fazendo uso da ferramenta Basiegaxorz.



Este bicho acima é o mascote do Basiegaxorz.

Antes de iniciarmos as seguintes ferramentas são necessárias. a) um computador com Basiegaxorz instalado (instalação padrão Windows, isto é, "clic, next, next, clic"); b) um emulador de Mega Drive instalado. Recomendo o Kega Fusion ou o Gens. Feito isso podemos iniciar a criação de programas. Mas é melhor proceder com algumas explicações de antemão. O Basiegaxorz é um compilador basic escrito em Visual Basic, que produz código compatível com Mega Drive, 32x e Sega CD. Isto é, você escreve código no dialeto basic e o Basiegaxorz converte tal código em algo semelhante a rom de um cartucho ou CD, de tal forma que um emulador pode ser utilizado para verificar o resultado ou, se houver alguém afortunado de ter um dos raros flash carts do mercado cinza (os da Tototek, por exemplo), testar no próprio console.

Sob o aspetco técnico o basiegaxorz permite utilizar joysticks (manipulação de entrada) de 03 e 06 botões, tanto para player 1 quanto player 2, criar e movimentar sprites, scroll de planos, manuseio de paletas de cores e criação/gerenciamento de psg de forma muito simplificada.

Reza a lenda que todo primeiro programa a ser escrito, não importa a linguagem, tem de ser o Hello World". Não fugiremos a regra. Com o Basiegaxorz aberto, dê um espaço da margem ou simplesmente aperte tab, e digite o seguinte comando:

print "Ola mundo!"

Aperte F5. Surgira uma mensagem em uma janela informando se a compilação deu certo ou não. Clique em OK. Agora com o emulador aberto procure o arquivo basic.bin, que deve estar em algo como c:/arquivos de programas/basiegaxorz (caso você tenha deixado a instalação padrão). O resultado no emulador é esse:



Bacana não? Agora vamos brincar um pouco com as cores dos textos. O basiegaxorz vem com alguns comandos já prontos para manipular texto, no caso trataremos do comando ink. Novamente com o programa aberto digite o seguinte código (não esqueça do espaço ou de apertar tab antes de cada comando):

ink 0
print "este texto esta em branco"
ink 1
print "este texto esta em azul"
ink 2
print "este texto esta em verde"
ink 3
print "este texto esta em roxo"

Aperte F5. Dê ok na caixa de informações após a compilação e procure novamente o arquivo basic.bin com o emulador. O resultado agora é este:



Legal não? Isso é apenas uma porção ínfima do que é possível criar com o programa. Sugiro uma olhada no manual html que acompanha o programa. Também é recomendável, e muito por que o manual é um tanto árido, dar uma olhada no código fonte de alguns demos criados com esta ferramenta. E por fim fazer muitas tentativas e erros, pois somente assim é possível aprender.

Nas próximas semanas vejo se consigo montar um tutorial com mais detalhes sobre a linguagem e algumas demonstrações de programas.