Romero Games

Download dos Anexos deste blog

2025-04-19T10:43:00.000-03:00

Quando eu comecei a criar este blog, eu usei como repositório de arquivos o Google Sites. O Google Sites foi encerrado e os arquivos foram copiados para uma pasta do meu Google Drive.

Eu corrigir os links das postagens principais, mas como são muitas postagens resolvi disponibilizar aqui o link direto para a pasta do Google Drive que tem todos os arquivos usados por este blog.

Link:

Google Drive: Romero Games Anexos

Traduções do meu livro de Blueprints/UE5

2024-10-12T13:44:00.002-03:00

O objetivo desta postagem é compartilhar com vocês a alegria que eu sinto ao ver o meu livro em inglês Blueprints Visual Scripting for Unreal Engine 5 ser traduzido e publicado em outras línguas.

Isto é resultado de um trabalho de muitos anos com a Unreal Engine que iniciou com os meus tutoriais sobre programação em UnrealScript:

https://romerogames.blogspot.com/p/sumario-unrealscript.html

Foi algo que comecei sem pretensão mas que gerou oportunidades que decidi me dedicar.

O meu livro foi publicado em 2022:

A versão Coreana foi publicada em 2023:

A versão Chinesa foi publicada em 2024:

A versão Russa foi publicada em 2025:

Atualmente, o foco dos meus estudos está na nova linguagem de programação Verse. Ela faz parte do UEFN (Editor do Unreal para Fortnite) mas posteriormente estará disponível também no editor padrão da Unreal Engine.

Este é o link dos meus tutoriais da linguagem Verse:

https://romeroblueprints.blogspot.com/p/sumario-verse.html

Sumário Retrogaming

Meu novo livro de Blueprints para Unreal Engine 5

2022-05-16T13:30:00.005-03:00

Foi publicado o meu livro em inglês Blueprints Visual Scripting for Unreal Engine 5. O livro tem 568 páginas e está disponível em versão física e digital.

Link Amazon.com.br: https://www.amazon.com.br/Blueprints-Visual-Scripting-Unreal-Engine-ebook/dp/B09NPCF8P9/

A Unreal Engine 5 está sendo usada em diversas áreas além da indústria de games como em filmes, arquitetura, automotiva, transmissões ao vivo, e simulações. A busca por profissionais com experiência em Unreal Engine será muito grande daqui para frente.

Invista em sua carreira de desenvolvedor Unreal conhecendo a fundo a programação com Blueprints, que é um aspecto central da Unreal Engine.

Luis Cataldi, Lead Evangelist at Quixel/Epic Games, escreveu um excelente prefácio para o livro:

O capítulo 19 do livro está disponível de graça. O capítulo é sobre Procedural Generation e pode ser acessado neste link: Capítulo 19.

Sumário Retrogaming

A Jornada de Marcos Romero

2021-07-02T09:21:00.001-03:00

Fiz uma breve apresentação sobre a minha história de desenvolvimento de games, desde o início da empresa RH Games até os meus trabalhos com a Unreal Engine nos dias de hoje. O vídeo pode ser acessado neste link:

https://www.youtube.com/watch?v=Dgas1Ox23Ao

Sumário Retrogaming

Quem foi Seumas McNally?

2021-03-21T08:00:00.003-03:00

À memória de Seumas McNally (10/02/1979 - 21/03/2000)

21 de março de 2021

A principal premiação dada no Independent Games Festival se chama Seumas McNally Grand Prize. Mas você sabe quem foi Seumas McNally?

O objetivo deste artigo é compartilhar esta inspiradora história de vida com o público atual. Seumas McNally faleceu há 21 anos em 21/03/2000, com 21 anos de idade.

Em junho de 1997, aos 18 anos de idade, Seumas McNally foi diagnosticado com Linfoma de Hodgkin (um tipo de câncer) em estágio avançado. Seumas decidiu manter o foco em seu trabalho como programador de jogos independente. O seu irmão estava ao seu lado como artista.

Existe uma organização chamada Starlight Foundation que tenta realizar sonhos de crianças e jovens com doenças graves. A família de Seumas fez uma requisição para a Starlight, mas ao invés de pedir uma viagem para a Disney ou outros desejos mais tradicionais, o desejo de Seumas era visitar a id Software e conversar com John Carmack sobre programação de gráficos em 3D.

Em junho de 1998, Seumas e sua família viajaram para a cidade de Dallas no Texas para encontrar com John Carmack. Eles foram muito bem recebidos na id Software e foi um momento muito especial para Seumas, pois John Carmack compartilhou suas idéias e experiência e se divertiram ao longo de todo o dia.

No final de 1998, apesar do seu estado de saúde precário, Seumas fundou a sua própria empresa de desenvolvimento de games chamada Longbow Digital Arts. O seu pai, a sua mãe e o seu irmão estavam trabalhando juntos com Seumas nos projetos DX-BALL 2 e Tread Marks.

Tread Marks é um jogo 3D de corrida e combate de tanques. O sistema de renderização do terreno e as ferramentas de edição 3D foram programados por Seumas McNally. A imagem abaixo é uma screenshot do jogo.

O jogo Tread Marks foi concluído e submetido ao Independent Games Festival no ano 2000. Tread Marks ganhou três prêmios: "Best Programming", "Best Game Design" e o "Grand Prize".

A imagem abaixo é de Seumas e sua família no evento.

O estado de saúde de Seumas piorou rapidamente depois da viagem de retorno para casa após o evento. Seumas McNally faleceu em 21 de março de 2000, uma semana após receber as suas premiações.

O Independent Games Festival renomeou o Grand Prize para Seumas McNally Grand Prize para honrar a memória dele.

A morte de Seumas McNally me marcou muito. No ano 2000, eu estava no auge da minha dedicação à programação dos jogos da RH Games e acompanhei as notícias do Independent Games Festival. Além disso, a idade de Seumas é muito próxima da minha. Foi um momento de bastante reflexão e valorização da vida.

Referências:

Remembering Seumas McNally

John Carmack and Seumas McNally

Seumas McNally Grand Prize

Sumário Retrogaming

RH Games Post Mortem

2021-01-20T14:22:00.001-03:00

Foi publicado no portal Nerd Pai Dégua o Post Mortem que eu escrevi sobre a empresa RH Games. Este texto contém mais detalhes e curiosidades da história da primeira empresa de desenvolvimento de games do Pará.

O Post Mortem pode ser acessado neste link:

https://nerdpd.wordpress.com/2021/01/19/post-mortem-rh-games/

Sumário Retrogaming

Como comecei a programar jogos

2020-11-23T21:34:00.000-03:00

No início de 1993, eu estava com 14 anos quando comecei a trabalhar meio período no escritório de advocacia do meu pai. Assumi o lugar do meu irmão, pois ele estava se preparando para fazer as provas para o IME e ITA no fim do ano.

Eu era o responsável pelo computador do escritório. As minhas tarefas consistiam em digitar os textos das petições, montar planilhas de cálculos para alguns processos e gerenciar a relação de processos do escritório. Às vezes fazia algum serviço externo, tipo enviar cartas nos correios ou pagar contas no banco.

O computador do escritório era um PC AT 286 com monitor monocromático, sistema operacional DOS e HD de 20 MegaBytes. Ele era parecido ao computador desta foto:

No computador estava instalado o jogo SimCity que pertencia ao meu irmão. Esta é a caixa do jogo SimCity:

Depois que concluía todas as minhas tarefas do escritório, eu aproveitava o tempo livre para jogar SimCity. SimCity era um jogo bem interessante que prendia atenção devido as inúmeras possibilidades de ações existentes ao gerenciar uma cidade. De vez em quando eu imprimia o mapa da minha cidade para planejar a forma como eu iria expandi-la.

O jogo era colorido, mas como o meu monitor era monocromático então a versão do jogo executada era em preto e branco conforme imagem abaixo.

No computador também estava instalado o compilador Turbo C. Um compilador é um programa que cria outro programa a partir da conversão de um código-fonte escrito em uma linguagem de programação. Existem diversas linguagens de programação com propósitos diferentes.

A Linguagem de programação C é uma linguagem de propósito geral, mas que foi criada com o foco em desenvolvimento de programas de sistema, que são programas que interagem direto com o hardware. Ela fornece diversos recursos para manipulação direta da memória do computador, por isso ela se tornou muito popular na indústria de software, principalmente para a programação de jogos.

O meu irmão tinha um livro de Turbo C que apresentava os fundamentos da programação utilizando a linguagem C. Eu comecei a estudar este livro e a única coisa que pensava era em como transformar todos aqueles conceitos em um jogo.

Entretanto, o livro não continha nenhum material direcionado para a programação de jogos e nesta época não tinha internet para poder consultar. Foi necessário muita criatividade e experimentação para conseguir chegar no meu objetivo. Mas eu consegui, e assim surgiu o meu primeiro jogo chamado Raven:

O jogador controla uma espaçonave chamada Raven e precisa destruir os blocos que caem na tela. A espaçonave é representada na tela pela letra "W". Eu escolhi esta letra porque ela me lembrava uma nave do Star Wars.

A conclusão deste jogo foi muito importante para mim. Agora eu já possuía as estruturas essenciais para o código de um jogo que poderia expandir em outros projetos. Um admirável mundo novo surgiu diante de mim. Me empolguei e já estava com inúmeras ideias para outros jogos. Parei de jogar SimCity e qualquer tempo livre que eu tinha no escritório eu me dedicava aos meus projetos de jogos.

Um dos meus próximos projetos consistia em programar um jogo que pudesse ser jogado por duas pessoas simultaneamente. Este projeto se transformou no jogo "Mina". Cada jogador controla um personagem e deve pegar o item da sua cor que aparece em posições aleatórias na tela. Existem 5 minas que estão escondidas na área do jogo e que mudam de posição periodicamente.

Ao pegar um item ganha 10 pontos e se colidir com uma mina explode e perde 5 pontos. Quem fizer 100 pontos primeiro ganha a partida. O jogador 1 usa as teclas WASD para se mover e o jogador 2 usa as setas do teclado. Neste jogo eu programei até o recurso de pause que é acionado pressionando a tecla "P".

Vou comentar duas curiosidades sobre o jogo Mina. A primeira é que eu consegui programar uma música para ele. O computador PC possuía um alto-falante simples. Existia uma função no Turbo C chamada "sound" que ativa o alto-falante em uma determinada frequência. Eu encontrei uma tabela com as frequências correspondentes às notas musicais (DÓ, RÉ, MI…). Converti todas as notas musicais de uma música para as frequências equivalentes e fiz o controle do tempo usado por cada nota usando um contador interno do jogo que uso para sincronizar os eventos.

A outra curiosidade é em relação às cores. No código em linguagem C do jogo eu defini as cores que os objetos do jogo iam usar. Cada jogador era representado por uma cor. Esta cor era usada para desenhar o personagem, o item, o nome e a pontuação de cada jogador. O jogador 1 era representado pela cor verde e o jogador 2 pela cor amarela. Os demais elementos do jogo usavam a cor vermelha. Só tinha um problema, o meu monitor era monocromático, ele exibia as cores como diferentes tonalidades da cor verde. Mesmo assim dava para distinguir os tons usados no jogo e eu sabia que um dia o jogo Mina seria executado em um monitor colorido.

Outro projeto que eu me dediquei foi a programação de um jogo de RPG. O meu jogo de RPG é baseado em uma história chamada "O Poço dos Desejos". Na tela do jogo é exibida uma descrição da sala atual onde o jogador se encontra e logo abaixo são exibidas as várias opções de ações disponíveis para aquela sala. O jogador pode escolher uma opção pressionando a tecla equivalente (1 a 5). Foi implementado também um sistema de combate por turno que é usado quando um inimigo é encontrado.

Estes e outros programas que eu implementei estão disponíveis com código-fonte no meu projeto Genesis:

http://romerogames.blogspot.com/p/sumario-genesis.html

Em 1995, o computador do escritório deu problema e foi substituído por um PC 486 com monitor colorido. Com isso, eu passei a programar em uma máquina com bem mais poder de processamento. A área que eu tinha mais interesse era a programação de jogos em 3D.

Encontrei na livraria este livro sobre programação de realidade virtual:

O livro usava a REND386, que é uma biblioteca de funções em linguagem C para renderização 3D. A REND386 construía e manipulava um mundo virtual a partir de 3 tipos de arquivos: PLG, FIG e WLD.

Formato PLG: Um arquivo de polígonos (PLG) contém as definições de um objeto 3D. Ele é composto por três partes: título do objeto, vértices e descritores de polígonos.
Formato FIG: Um arquivo de figura (FIG) é usado para agrupar vários objetos PLG permitindo a representação de uma entidade 3D com hierarquia entre os objetos 3D, como uma pessoa por exemplo.
Formato WLD: Um arquivo de mundo (WLD) permite a definição de um ambiente virtual 3D. Ele possui vários comandos para a definição de formas simples no mundo, especificação de cores dos planos e permite a inclusão de arquivos do tipo PLG e FIG dentro do ambiente virtual.

Este é um exemplo de ambiente programado com a REND386:

Em 1997, eu queria praticar a linguagem de programação Pascal. Devido a complexidade da linguagem C, a linguagem Pascal era a mais utilizada para ensinar conceitos de programação nas faculdades nesta época por ser mais fácil.

Resolvi programar a continuação do jogo Mina em Pascal. A tela de abertura do jogo ficou assim:

Adicionei vários recursos neste jogo. Nesta tela inicial os símbolos da borda se movimentam gerando um efeito visual similar ao de um painel eletrônico. O Mina 2 tem modo de jogo para 1 ou 2 jogadores, possui várias fases, tem tela de instruções e tela dos recordes que são registrados em um arquivo externo para serem recuperados na próxima execução do jogo.

Além das minas escondidas que mudam de posição periodicamente, existem várias bolas que ficam quicando no cenário e que fazem o jogador perder pontos se colidir com elas. A imagem abaixo é de uma das fase do jogo:

Tem um fato muito curioso sobre a programação do jogo Mina 2. Eu escrevi praticamente todo o código Pascal da programação do jogo no papel. Somente depois de concluí-lo foi que eu passei para o computador. O código ficou espalhado em 6 folhas. O link abaixo é de um PDF com as 6 folhas:

Mina2CodFonte.pdf

Esta é a imagem de uma das folhas:

Outro programa que eu fiz em linguagem Pascal foi uma RPG Engine para ensinar alguns amigos a programar jogos de RPG em modo texto. O jogo de exemplo apresenta 4 salas, sendo que em cada sala é demonstrado um recurso diferente.

A RPG Engine mostra o uso de inventários, itens, diálogos baseados em palavras-chave, combate em turno e interligação entre as salas onde se passa o jogo.

Desde o fim de 1994 eu não estava jogando nenhum jogo. Eu fiquei totalmente por fora dos lançamentos do PlayStation 1 e do Nintendo 64. Eu nunca joguei no PlayStation 1 e a primeira vez que eu joguei em um Nintendo 64 foi em 2006 quando eu comprei um usado.

Eu estava bastante focado nas minhas pesquisas de programação de jogos. Com a experiência adquirida, eu já estava decidido a criar minha própria empresa de desenvolvimento de jogos.

Sumário Retrogaming

Meu Super Nintendo

2020-11-15T09:39:00.000-03:00

Em 1992 eu estava com 13 anos. Meu irmão e eu estávamos querendo um Super Nintendo. Começamos a negociar com o nosso pai e ficou acertado que o Super Nintendo seria o presente de aniversário para nós dois. Nesta época o Super Nintendo ainda não tinha sido lançado no Brasil, ainda era um produto importado. Como meu pai gosta de viajar, nós três fomos para Manaus nas férias de julho passear e comprar o Super Nintendo na zona franca.

Depois que compramos o Super Nintendo, eu não via a hora de retornarmos para Belém para que eu pudesse jogar. A pousada que ficamos em Manaus era simples e não tinha televisão.

Voltamos para Belém e chegamos de noite em casa. A primeira coisa que eu fiz com o meu irmão foi abrir a caixa do Super Nintendo para conectá-lo na televisão. Entretanto, ocorreu um imprevisto.

O Super Nintendo vem com um cabo de áudio e vídeo (aquele que tem os conectores amarelo, branco e vermelho) e com um cabo de antena VHF de enroscar. A televisão do meu pai não tinha entrada para o cabo de áudio e vídeo e a entrada de antena da televisão ainda era no formato que são dois parafusos que recebem o conector.

Nós precisávamos de um conversor para poder ligar o Super Nintendo na nossa TV. A imagem abaixo é do manual do Super Nintendo e ilustra como deve ser feita a conexão neste caso. A peça que estava faltando para nós é a que está com o nome "75 / 300Ω CONVERTER" no manual.

Imaginem a frustração que estávamos sentindo. Então lembramos que no quarto do meu pai tinha uma TV portátil colorida de 5 polegadas, e ela tinha os conectores coloridos para receber o cabo de áudio e vídeo. A TV portátil do meu pai era semelhante ao desta foto:

Corremos para o quarto do meu pai e conseguimos ligar o Super Nintendo na TV portátil. Pelo menos matamos a vontade de jogar naquele dia. O único problema era que por causa do tamanho da TV nós não conseguíamos diferenciar se o Mario estava na forma grande ou pequena. No dia seguinte compramos o conversor necessário para ligar na TV da sala.

Este é o Super Nintendo que possuo atualmente:

Em julho de 1992, no mesmo mês que compramos o Super Nintendo, encontrei a edição número 1 da revista GamePower na banca de revistas do aeroporto. Na capa da revista estava o jogo Street Fighter II com a legenda "Revelamos Tudo". O Street Fighter II tinha sido recém-lançado no Super Nintendo. Além disso, a revista era especializada em Nintendo. Era exatamente a revista que eu precisava na época. Como não existia internet, a única forma de acompanhar as novidades dos jogos era através destas revistas.

Neste período, praticamente todo fim semana eu alugava um jogo. Os tipos de jogos que eu alugava podem ser vistos nas capas das revistas GamePower de 1 a 20 que eu possuo.

A última revista GamePower que comprei foi a de número 20 que saiu em fevereiro de 1994. Nesta época eu já estava bastante dedicado à programação de jogos. No tempo que sobrava, eu jogava jogos de luta.

Devido ao enorme sucesso do jogo Street Fighter II no Super Nintendo, em quase toda esquina de Belém passou a ter alguma casa com vários Super Nintendos disponíveis onde você podia pagar para jogar Street Fighter II por uma hora.

Perto da casa do meu pai tinha uma dessas casas de games. Ela era mantida por dois irmãos. Fiz amizade com eles e frequentemente passava por lá para disputar Street Fighter II ou apenas para conversar com os meus amigos.

Durante o ano de 1994, o meu foco no Super Nintendo foi treinar para disputar em jogos de luta. Eu treinei pra valer nos jogos Street Fighter II Turbo, Mortal Kombat e Mortal Kombat 2:

As minhas habilidades de lutador virtual eram conhecidas nesta casa de games. Às vezes marcavam desafios comigo para o fim de semana. As disputas eram momentos muito emocionantes, com direito a torcida. Foram bons tempos vividos nesta casa de games.

Além desses jogos de luta, teve apenas mais um jogo que eu joguei em 1994, que foi o RPG Shadowrun:

Eu aluguei este jogo no início de 1994 e gostei muito da ambientação do jogo que possui uma temática mais madura. Por ser um jogo longo e complexo não dava para concluí-lo em um fim de semana. Mesmo que eu alugasse novamente, dificilmente ainda estaria lá o arquivo de save com o meu progresso.

Na locadora que eu aluguei o Shadowrun, tinha uma relação de jogos usados que eram vendidos a um preço acessível. Eram jogos que não eram mais alugados, por isso o dono colocava para vender.

Eu imaginava que o Shadowrun não era muito alugado nesta locadora, pois o estilo RPG não era muito popular, principalmente devido a dificuldade de entender os textos em inglês. Eu ficava enchendo a paciência do atendente da locadora perguntando quando eles iam colocar o Shadowrun na lista de venda dos usados, dizendo que ninguém alugava este jogo. Um dia quando voltei na locadora, o atendente me chamou e disse que conversou com o dono. O dono tinha autorizado a venda do Shadowrun para mim pelo preço dos jogos usados. Eu fiquei muito feliz.

Em relação à história do Shadowrun, logo nos primeiros minutos do jogo, o seu personagem é assassinado por uma gangue:

Em seguida, aparece uma raposa correndo em sua direção. Ao chegar do seu lado, a raposa se transforma em uma mulher e lança um feitiço em você:

Após isso, aparecem os agentes funerários e te levam para o necrotério. Você acorda dentro da gaveta do necrotério, confuso e sem lembrar de nada. Quando você abre a porta da sala que está, os agentes funerários se assustam e correm desesperados para outra sala. A porta deles está trancada e se você tentar conversar, eles respondem:

- Não tem ninguém aqui, só nós… ratos!

Shadowrun possui muitos ambientes interessantes. Em uma parte do jogo, temos de entrar no show da cantora de rock Maria Mercurial:

Através da tela de diálogos conhecemos vários personagens bem elaborados:

Shadowrun foi a minha última grande aventura no Super Nintendo. No final de 1994 eu parei totalmente de jogar videogames. Mas não foi por perda de interesse, foi uma decisão. Estava decidido a me dedicar integralmente à programação de jogos.

Sumário Retrogaming

Meu Game Boy

2020-11-08T19:38:00.003-03:00

O meu primeiro contato com o Game Boy ocorreu no ano de 1991 quando eu tinha 12 anos. Nesta época era muito comum os minigames, que eram videogames portáteis simples com apenas um jogo, como este da imagem abaixo:

Um dia, durante o intervalo de aula, um colega japonês estava no fundo da sala com um Game Boy. Quando vi aquilo eu comentei com outro colega que estava do meu lado:

- Olha aquele minigame gigante.

Como ele já conhecia o Game Boy, respondeu empolgado:

- É… mas pode trocar o cartucho dele.

Aos poucos meu interesse pelo Game Boy foi aumentando. Até que decidi pedir de presente de aniversário. A minha mãe disse que ia pedir para uma amiga comprar na Zona Franca de Manaus, pois lá estes aparelhos importados eram mais baratos devido a incentivos do governo.

Eu possuía em casa a revista "A Semana em Ação Especial Games". Era um edição especial da revista "A Semana em Ação". Como esta edição fez muito sucesso, logo em seguida se transformou na revista Ação Games. A revista que eu possuía pode ser acessada no datassette.org neste link:

https://datassette.org/revistas/acao-games/semana-em-acao-especial-games-no-2

Nesta revista tinha duas páginas com informações sobre jogos do Game Boy:

Eu marquei vários jogos do Game Boy nestas páginas e dei para a minha mãe entregar para a amiga dela comprar lá em Manaus. O Game Boy foi comprado, mas ela não deve ter encontrado na loja nenhum dos jogos que marquei. Ela comprou outros dois jogos: Operation C e Godzilla.

A caixa do Game Boy é muito interessante, ela tinha um visual bem futurista:

Este é o Game Boy que tenho em casa atualmente:

O jogo Operation C faz parte da série de jogos de ação "Contra" da Konami. Esta versão da série para o Game Boy possui jogabilidade e gráficos bem similares aos outros jogos da série lançado para NES. Fiquei muito feliz por ter vindo este jogo. Eu gosto muito dos jogos da série "Contra".

Esta é a capa do jogo:

Estas são imagens de algumas fases do jogo:

O jogo do Godzilla que eu ganhei possui uma capa com vários monstros:

Olhando a capa dá para imaginar que você vai controlar o Godzilla e destruir vários prédios… Mas quando inicia o jogo você descobre que ele é assim:

Mas a jogabilidade dele é bem interessante envolvendo ação e quebra-cabeça. Além disso, é um jogo grande com 64 fases. Este jogo também foi uma excelente opção para o meu Game Boy.

A história do jogo é que vários monstros que o Godzilla já derrotou, se juntaram e sequestraram o filho do Godzilla, escondendo-o em algum lugar dentro do labirinto de Matrix (é esse mesmo o nome do labirinto :).

Ao concluir uma fase, são dadas duas opções de saída. A imagem abaixo mostra o mapa do jogo, onde o jogador concluiu a primeira fase e escolheu ir para a fase de baixo. O filho do Godzilla está escondido em uma das fase pelo meio do mapa. O seu progresso do jogo é mantido através do uso de Passwords.

De vez em quando a minha mãe me levava no fim de semana na locadora para alugar um jogo do Game Boy. Na época, a única locadora em Belém do Pará que eu sabia que tinha jogos do Game Boy era a Soft Game localizada próxima do centro da cidade.

Nesta locadora tinha um Senhor que trabalhava como recepcionista. Ele sempre estava fantasiado de Mario e era mais conhecido como Batata. Foi nesta locadora que eu joguei com meu irmão pela primeira vez em um Super Nintendo.

Vou comentar sobre cinco jogos de Game Boy que eu me lembro de ter alugado nesta época.

- Castlevania II: Belmont's Revenge

Excelente versão do Castlevania para o Game Boy. Possui fases bem interessantes, ótima jogabilidade e a trilha sonora é memorável. Um dos melhores jogos de ação do Game Boy original.

- Nintendo World Cup

Este jogo de futebol é muito divertido e engraçado. Era possível dar empurrões e carrinhos nos jogadores. Às vezes no final da partida tinha vários jogadores caídos no chão porque não conseguiam mais se levantar. Tinha uma ótima trilha sonora que mantinha o ritmo do jogo.

- Double Dragon

Adaptação do clássico jogo de luta dos fliperamas. Simples de jogar e divertido.

- Super Mario Land

Versão do Super Mario feita especificamente para o Game Boy. Possui jogabilidade similar ao Super Mario Bros 1.

- Teenage Mutant Ninja Turtles: Fall of the Foot Clan

Jogo das Tartarugas Ninjas que combina os estilos de jogo de luta e plataforma. Possui fases diversificadas e um bom visual.

Sumário Retrogaming

Beljogos no YouTube

2020-11-01T19:57:00.002-03:00

Eu fundei o grupo Beljogos no dia 10 de setembro de 2003 com o objetivo de incentivar o desenvolvimento de games em Belém do Pará e na região Norte.

No momento desta postagem, o Beljogos está com 17 anos e em plena atividade. As redes sociais do Beljogos podem ser acessadas neste link:

https://linktr.ee/beljogos

O Beljogos em parceria com o canal História Revista, em comemoração ao aniversário de 16 anos das atividades do grupo, fez uma série de vídeos de Análise / Review de Jogos Paraenses.

Este é o link da Playlist: Série Jogos Paraenses

No canal do Beljogos no YouTube também tem uma Playlist do Romero Games que pode ser acessada neste link:

Playlist Romero Games

Epic Games me convidou para uma Livestream

2020-08-22T17:16:00.002-03:00

Os meus trabalhos com a Unreal Engine foram reconhecidos internacionalmente em uma Livestream promovida pela Epic Games.

O título da Live é "Teaching & Learning Blueprints with Marcos Romero". A Live está disponível neste link:

https://www.twitch.tv/videos/703277395

O meu momento favorito é em 1h:12m:30s até 1h:13m:20s.

O grupo Beljogos organizou um vídeo com os melhores momentos desta Live. Este vídeo está com legendas em português e pode ser acessado neste link:

https://www.youtube.com/watch?v=WhNHt1u6Ijs

Vídeo sobre a RH Games

2019-10-18T13:48:00.001-03:00

Foi publicado um vídeo no YouTube sobre a história e os jogos da RH Games, que foi a primeira empresa de desenvolvimento de jogos no estado do Pará. A empresa iniciou suas atividades em 1999.

O vídeo pode ser acessado neste link:
https://www.youtube.com/watch?v=MwzNbXtarQE

Minhas aventuras com a Unreal Engine

2019-10-05T15:43:00.000-03:00

Em 2011, quando estava escrevendo minha série de artigos sobre programação de games usando UnrealScript para este blog, percebi que mesmo em inglês era bastante limitado o material disponível sobre UnrealScript. Por causa disso tive a idéia de criar um blog em inglês somente para ensinar UnrealScript.

Escrevi 40 artigos de UnrealScript, a versão em português foi publicada neste blog Romero Games e a versão em inglês foi publicada no blog Romero UnrealScript:

Eu recebi um ótimo feedback em relação ao conteúdo do blog Romero UnrealScript, que se tornou uma das principais referências para o aprendizado de UnrealScript.

Em junho de 2013, eu tive uma grata surpresa. A Epic Games me convidou para fazer parte do Unreal Engine 4 closed beta program para que eu pudesse ter acesso antecipado à Unreal Engine 4 e poder experimentar e colaborar com a evolução das ferramentas.

Depois eu recebi um poster manualmente assinado por Tim Sweeney, o criador da primeira Unreal Engine e dono da Epic Games. Ele é o meu ídolo na programação de games.

A Unreal Engine 4 foi lançada em março de 2014. Eu iniciei outro blog chamado Romero Blueprints com artigos em inglês e português para ensinar a programação de games usando Blueprints, que é uma linguagem visual criada pela Epic Games.

Em agosto de 2015, eu tive outra surpresa incrível. A Epic Games me premiou com um "Unreal Engine Educational Dev Grant" pelo trabalho que eu fiz no blog Romero Blueprints para ajudar as pessoas a aprenderem Unreal Engine 4. O anúncio oficial pode ser visto no link: Unreal Dev Grants Fund Education.

Eu escrevi para a Epic Games um guia em inglês de Blueprints chamado Blueprints Compendium. Em Março de 2016, a Epic Games distribuiu para o público o Blueprints Compendium na Game Developer Conference, o maior evento de desenvolvimento de games do mundo.

Em junho de 2017, eu terminei de escrever o volume 3 do Blueprints Compendium. Como agradecimento, a Epic Games me mandou um mouse sem fio da Logitech com logotipo da Unreal e uma manta da Unreal Engine muito macia:

Em 2018 a Epic Games me contratou para eu escrever o guia oficial do instrutor de Blueprints. O guia está disponível na página da Unreal Engine, clique na imagem abaixo para mais informações.

Em 2019 a editora Packt Publishing entrou em contato comigo para que eu escrevesse o livro em inglês Blueprints Visual Scripting for Unreal Engine - Second Edition. O livro já foi publicado e pode ser adquirido na Amazon BR.

Em 2020, o meu projeto para ensinar programação em C++ na Unreal Engine foi selecionado no programa Epic MegaGrants.

Museu de Jogos no 3º MAG / 3º WDJA

2012-09-18T07:00:00.000-03:00

Realizei mais uma exposição do Museu de Jogos durante o 3º WDJA (Workshop de Desenvolvimento de Jogos da Amazônia), que ocorreu no dia 15 de setembro de 2012 no IESAM (Instituto de Estudos Superiores da Amazônia). Os eventos MAG (Mostra Analítica de Games) e WDJA são organizados pelo Beljogos e o IESAM em Belém do Pará.

Segue abaixo as fotos dos itens do Museu que levei para a exposição.

O Filipe Mendes do Beljogos aproveitou para levar alguns dos seus livros de arte de jogos. Ele levou também um xadrez do Super Mario que fez sucesso no evento. Vejam as fotos.

Filipe Mendes e Lucas Romero jogando o xadrez do Super Mario.

Lucas Romero no "Liberalzinho"

2012-09-17T10:09:00.000-03:00

O Lucas Romero apareceu no Liberalzinho, no dia 16 de setembro de 2012. O Liberalzinho é um caderno infantil do jornal "O Liberal" (Belém do Pará) que vem aos domingos.

A foto do Lucas está relacionada aos Jogos Escolares Católicos (JEC) onde ele participou representando o Colégio Gentil Bittencourt no esporte Karatê.

A lógica do jogo de labirinto (Game Maker)

2012-09-11T20:14:00.002-03:00

Esta postagem irá comentar sobre a implementação do jogo de labirinto no Game Maker que disponibilizei no blog nesta postagem:
Jogo de Labirinto no Game Maker

O foco do artigo será na lógica dos Eventos e Ações dos Objetos do jogo.

O principal Objeto é o "jogador". A imagem abaixo mostra os Sprites que o "jogador" utiliza, sendo um Sprite para cada direção.

Cada um desses Sprites possui quatro quadros de animação (subimagens), como pode ser visto no "Sprite Editor":

Os eventos do "jogador" são os seguintes:

O movimento do "jogador" é baseado nos blocos de 32x32 do labirinto. Sendo assim, as setas do teclado só irão responder quando o jogador estiver alinhado ao labirinto. A imagem abaixo mostra as ações que são executadas quando a Seta para Direita é pressionada.

A ação "Change Sprite" possui os seguintes parâmetros:

O valor "-1" no campo subimage, significa que o valor atual da subimagem não deve ser alterado para que não atrapalhe a animação do personagem.

O valor "1/3" no campo speed representa a velocidade da animação. Se o valor fosse 1 então a cada passo (step) a subimagem do sprite seria modificada. Como temos poucos quadros na animação do sprite, queremos que a subimagem seja alterada a cada 3 passos, ou seja, a velocidade de animação será 1/3. É bem mais simples representar a velocidação de animação usando frações ao invés de usar o ponto como em: "0.3333".

O evento "Alarm 0" do jogador foi criado por dois motivos. Um dos motivos é reunir em um único lugar as Ações que devem ser executadas no final do jogo, ao invés de repeti-las em diversos outros Eventos. O outro motivo é fazer com que a tela do jogo seja desenhada pelo menos uma vez após a derrota do jogador, para que imagem do jogador seja trocada antes do jogo parar.

No jogo, os Eventos que acionam o "Alarm 0" são as colisões com os objetos "monstro" ou "explosão". Ambos iniciam o "Alarm 0" com o valor de 1, para que já seja executado no próximo passo.

As ações que são executadas no "Alarm 0" são as seguintes:

Quando o jogador pressiona a barra de espaço, é colocada na tela uma instância do objeto "dinamite". No evento Create, a dinamite cria um Alarme com o valor de 100 passos. Como o jogo está rodando a 30 passsos por segundos, o tempo que irá demorar para a dinamite explodir será de 3,33 segundos. Quando o Alarme dispara, são criados 5 instâncias do objeto "explosão", sendo uma no centro e mais 4 nas posições adjacentes. A imagem abaixo mostra as ações.

Com um propósito didático criei um objeto chamado "pai_destrutivel". É um objeto bem simples que possui apenas um evento de colisão com o objeto explosão. Neste evento a instância atual é destruída. A idéia é que todos os objetos do jogo que possam ser eliminados por uma explosão (exceto o jogador) sejam filhos do objeto "pai_destrutivel", herdando todos os eventos criados no objeto "pai_destrutivel". Este conceito é chamado de "Herança" e é muito utilizado na Programação Orientada a Objetos.

Como exemplo temos o objeto "Monstro". Na propriedade "Parent" está atribuído o objeto "pai_destrutivel". A imagem abaixo mostra as propriedades do objeto "Monstro".

Quando um "Monstro" colide com um bloco, parede ou dinamite, ele precisa escolher uma nova direção para se mover. É atribuída uma nova direção para o "Monstro" e logo em seguida é verificada se a posição para onde o "Monstro" iria se mover no próximo passo está livre. Se estiver livre então o evento é encerrado com o uso da ação "Exit this Event". Caso não esteja livre, são testadas outras direções. A imagem abaixo mostra estas ações.

Estas mesmas ações são repetidas em 3 eventos: Colisão com objeto bloco; Colisão com objeto parede e Colisão com objeto dinamite. Esta é uma boa opção para converter essas ações em um script que seria apenas chamado nos 3 eventos.

O cenário do jogo é feito de uma forma bem simples. É desenhada uma cor de fundo azul e são usados os objetos parede (nas bordas) e bloco para montar o labirinto. A edição do cenário é feita com o uso da grade que foi configurada para a dimensão 32x32. Todos os objetos estão alinhados a esta grade.

Filme Detona Ralph (Wreck-It Ralph)

2012-09-08T11:03:00.000-03:00

A Disney está produzindo um filme que irá homenagear os games antigos. O filme conta a estória de Ralph, que é o vilão de um jogo de arcade (fliperama) chamado "Fix-it Felix Jr." (Conserta Felix Jr.). Ralph já estava cansado de sempre ser o vilão por 30 anos e queria provar que poderia ser um herói nos games.

Durante o filme, diversos personagens clássicos de games aparecem, como na imagem abaixo onde estão reunidos diversos vilões de games para desabafarem sobre a dura vida que eles levam.

A estréia do filme será no dia 04 de janeiro de 2013 no Brasil. Já está disponível um trailer em português que pode ser acessado na página: Trailer Detona Ralph.

O mais interessante foi que eles criaram realmente o jogo "antigo" que aparece no filme e disponibilizaram para o público jogá-lo na Internet. O jogo pode ser acessado no link: Jogo Conserta Felix Jr.

Shadowrun Returns

2012-08-23T19:47:00.000-03:00

Shadowrun é um livro de RPG que apresenta um mundo fictício em um futuro próximo. No mundo de Shadowrun estão presentes a força das armas, os mistérios da magia e as maravilhas da tecnologia.

Já foram desenvolvidos 3 jogos de videogames baseados em Shadowrun. O primeiro foi em 1993 para Super Nintendo, o segundo em 1994 para Mega Drive e o último em 2007 para XBox 360/Windows.

Jordan Weisman, que foi o criador original do livro de RPG do Shadowrun, conseguiu readquirir os direitos sobre o universo Shadowrun que estavam com a Microsoft.

Harebrained Schemes, que é a empresa liderada pelo Jordan Weisman, colocou um projeto no Kickstarter para obter fundos da comunidade com o objetivo de construir um novo jogo de RPG baseado no universo Shadowrun. Este jogo será para Windows/Mac e Tablets e se chamará Shadowrun Returns.

A resposta da comunidade foi imediata e rapidamente eles conseguiram os fundos necessários para a criação do jogo. A previsão de lançamento do jogo é para o 1º semestre de 2013.

O lançamento do Shadowrun Returns me interessa muito por dois motivos. O primeiro é que em 1993, quando comecei a programar jogos em linguagem C, eu estava jogando o Shadowrun do Super Nintendo. Fiquei muito empolgado com o ambiente e a estória do jogo, de forma que naquela época o meu sonho era um dia conseguir programar um jogo de RPG como o Shadowrun do Super Nintendo. O segundo motivo é que o Shadowrun Returns virá com um editor que permitirá aos usuários criarem suas próprias aventuras e disponibilizá-las para a comunidade.

A imagem abaixo é uma arte conceitual do Shadowrun Returns. Os desenvolvedores alegaram que a qualidade gráfica do jogo ficará semelhante a esta arte conceitual. Para acompanhar as novidades do projeto, acesse a página: http://harebrained-schemes.com/shadowrun/

A lógica do jogo de introdução ao Game Maker

2012-08-14T15:16:00.000-03:00

O objetivo desta postagem é comentar sobre a implementação do jogo de introdução ao Game Maker que disponibilizei no blog nesta postagem:
Iniciando no Game Maker

Vou manter o foco deste artigo apenas na lógica dos Eventos e Ações que estão dentro dos Objetos do jogo que são apenas quatro conforme a imagem abaixo:

É importante que esteja bem claro a diferença entre os termos "Objeto" e "Instância" dentro do Game Maker.

No Game Maker, quando você define um Objeto, ele representa um modelo que será usado para gerar várias Instâncias dentro do jogo. Por exemplo, neste jogo de introdução temos um único objeto que define o "Dinheiro". Mas durante o jogo podemos observar que o Dinheiro aparece em vários locais diferentes ao mesmo tempo na tela. Cada uma dessas aparições representa uma Instância do Objeto Dinheiro.

A lógica de um jogo feito no Game Maker é organizada na forma de Eventos e Ações. Os objetos são informados sobre os mais diversos Eventos que ocorrem durante o jogo podendo responder a certos Eventos através do uso das Ações.

Vamos começar analisando o objeto "jogador":

A imagem acima mostra as Ações que serão executados no momento da criação (Evento Create) de uma Instância do Objeto "jogador". São 3 ações, a primeira apenas inicia a música do jogo e as outras duas ações iniciam o Alame 1 com o valor 30 e o Alarme 2 com o valor 300.

Os Alarmes são Eventos que podemos utilizar para que sejam executados depois de um determinado período de tempo. Este jogo está usando o valor padrão do Game Maker de 30 passos (steps) por segundo. Este valor pode ser modificado nas propriedades da Room, aba Settings, campo Speed. Sendo assim, o Alarme 1 que contém o valor de 30 passos equivale a 1 segundo e é usado para criar uma nova Instância de Dinheiro. O Alarme 2 com o valor 300 equivale a 10 segundos e é usado para criar uma nova Instância de Pedra.

O Evento de Colisão com o Bloco pára o movimento do jogador, evitando que ele saia da área do jogo.

Os outros Eventos são relacionados ao teclado e movimentam o jogador para esquerda e para direita de acordo com a tecla pressionada. O Evento de teclado "no key" é acionado quando o jogador não pressiona nenhuma tecla.

O objeto "dinheiro" possui os seguintes Eventos:

No Evento Create, a instância do dinheiro é colocada em uma posição aleatória no topo da tela e dentro da área do jogo. Após isso é definido seu movimento que consiste apenas em ir para baixo com velocidade 6.

No Evento de colisão com o jogador, um som é tocado para indicar que o jogador coletou o dinheiro, depois a pontuação do jogador aumenta em 10 pontos e então esta instância atual do dinheiro é eliminada.

O último Evento do dinheiro é o "Outside Room" que é acionado quando a instância sai da tela. A única ação que é executada é a que elimina a instância do dinheiro.

O objeto "pedra" possui os seguintes Eventos:

Estes Eventos possuem Ações bem simples. Vou comentar apenas sobre o Evento de colisão com o jogador. Neste Evento a música do jogo é parada e um som indicando a Derrota é tocado, após isso é exibida uma mensagem de "Fim de Jogo" e também a Tabela de Pontos. Quando o jogador fechar a Tabela de Pontos o jogo será reiniciado.

O objeto "bloco" não possui Eventos.

Trilha Sonora do jogo Darksiders

2012-08-07T14:49:00.000-03:00

Darksiders é um jogo de ação/aventura que foi lançado em 2010 para Xbox 360, Playstation 3 e PC. A revista Fullgames publicou este jogo em sua edição nº 108. Além do jogo, a revista contém alguns extras do Darksiders como um Poster, uma revista em quadrinho digital e a trilha sonora.

A trilha sonora do jogo é excelente. Ela contém 23 faixas que ajudam a envolver o jogador no incrível mundo de Darksiders.

Programação de Jogos em Pascal

2012-08-06T09:17:00.000-03:00

Curiosamente a postagem do meu blog que possui mais acesso é uma do Projeto Genesis com o título "Jogos em Pascal". Suponho a partir dessa busca por Jogos em Pascal que muitas escolas de ensino médio e algumas faculdades ainda devem estar utilizando a linguagem Pascal para ensinar Algoritmos e Lógica de Programação.

Há muito tempo atrás eu programei 3 jogos em Pascal. Já disponibilizei todos eles no meu blog através do Projeto Genesis. Os jogos podem ser acessados nos links abaixo:

MINA 2
RPG ENGINE
LAB

Se houver interesse do público, eu posso escrever algumas postagens explicando o funcionamento do código fonte desses jogos.

Caso você seja um dos interessados, faça um comentário nesta postagem. Se possível, me informe se você está vendo Pascal na escola/faculdade.

Atualização:
Criei um blog separado para explicar o funcionamento do código fonte do jogo Mina 2. O blog pode ser acessado na url:
http://mina2pascal.blogspot.com.br

Conclusão de "UnrealScript para Iniciantes"

2012-06-28T06:40:00.000-03:00

Em 1999, tive o meu primeiro contato com a Unreal Engine através do jogo Unreal Tournament. Fiquei muito impressionado com os gráficos, música, inteligência artificial, armas e dinâmica do jogo. Quando me lembro deste jogo, automaticamente a música de Introdução e a voz da narradora no início do jogo começam a ecoar em minha mente.

Hoje em dia, admiro a Unreal Engine por uma perspectiva de programador. É fascinante a tecnologia e complexidade existentes no núcleo da Unreal Engine que foi elaborada pela mente brilhante de Tim Sweeney.

Gostaria de agradecer a Epic Games por ter criado essa incrível engine e ter disponibilizado ela através do UDK que permitiu que os sonhos de muitas pessoas se tornassem possíveis.

"The time has come to prove you are the best.
To crush your enemies;
to win the Tournament."

(Unreal Tournament 1 Intro)

Platformer Kit: SPG_AIPawn class (UnrealScript)

2012-06-27T09:22:00.001-03:00

A classe SPG_AIPawn representa os robôs que atacam o jogador no Platform Kit. As variáveis definidas para esta classe são as seguintes:

class SPG_AIPawn extends Pawn
      placeable;

// Dynamic light environment component to help speed up lighting calculations for the pawn
var(Pawn) const DynamicLightEnvironmentComponent LightEnvironment;

// Ground speed of the pawn, display as Ground Speed in the editor
var(Pawn) const float UserGroundSpeed<DisplayName=Ground Speed>;

// Explosion particle system to play when blowing up
var(Pawn) const ParticleSystem ExplosionParticleTemplate;

// Explosion sound to play
var(Pawn) const SoundCue ExplosionSoundCue;

// Explosion damage amount 
var(Pawn) const int ExplosionDamage;

// Archetyped pick up to drop
var(Pawn) const archetype DroppedPickup ArchetypedPickup;

// Percentage chance to drop pickups
var(Pawn) const float ChanceToDropPickup;

// Current enemy
var Actor Enemy;

Existe um Archetype para a classe SPG_AIPawn. A imagem abaixo mostra as variáveis específicas da classe SPG_AIPawn.

A função Tick() é executada a cada frame. Nesta função é armazenada uma referência ao jogador na variável Enemy (inimigo), caso isto ainda não tenha sido feito.

Depois disso, caso o robô já esteja no solo andando (Physics == PHYS_Walking), ele obtém a localização do jogador e ajusta sua velocidade e rotação para mover em direção ao jogador.

simulated function Tick(float DeltaTime)
{
    local PlayerController PlayerController;
    local Vector Direction;
    local Rotator NewRotation;

    Super.Tick(DeltaTime);

    // If we don't have an enemy yet...
    if (Enemy == None)
    {
        // Find the player controller in the world
        PlayerController = GetALocalPlayerController();

        if (PlayerController != None && PlayerController.Pawn != None)
        {
            // Set the enemy to the player controller's pawn
            Enemy = PlayerController.Pawn;
        }
    }
    else if (Physics == PHYS_Walking)
    {
        // Find the direction in order for me to look at my enemy
        Direction = Enemy.Location - Location;

        // Only need to use the yaw from the direction
        NewRotation = Rotator(Direction);
        NewRotation.Pitch = 0;
        NewRotation.Roll = 0;

        // Set the rotation so that I look at the enemy
        SetRotation(NewRotation);

        // Set my velocity, so I move towards the enemy
        Velocity = Normal(Enemy.Location - Location) * UserGroundSpeed;

        // Set my acceleration, so I move towards the enemy
        Acceleration = Velocity;
    }
}

Quando um robô colide com o jogador a função Bump() é executada. Para mais informações sobre colisão leia o artigo: "Colisão em UnrealScript".

O jogador, que é representado pela variável Other nesta função, recebe o dano cujo valor está definido na variável ExplosionDamage. Na imagem do Archetype podemos ver que o valor padrão desta variável é 5.

O efeito com partículas que representa a explosão é acionado e é reproduzido o som da explosão armazenado na variável ExplosionSoundCue. Para mais informações sobre SoundCue, leia o artigo: "Tocando Sons em UnrealScript".

event Bump(Actor Other, PrimitiveComponent OtherComp, Vector HitNormal)
{
    Super.Bump(Other, OtherComp, HitNormal);

    if (SPG_PlayerPawn(Other) != None)
    {
        // Apply damage to the bumped pawn
        Other.TakeDamage(ExplosionDamage, None, Location, Vect(0, 0, 0), class'DamageType');

        // Play the particle effect
        if (ExplosionParticleTemplate != None)
        {
            WorldInfo.MyEmitterPool.SpawnEmitter(ExplosionParticleTemplate, Location);
        }

        // Play the explosion sound
        if (ExplosionSoundCue != None)
        {
            PlaySound(ExplosionSoundCue);
        }

        // Destroy the pawn
        Destroy();
    }
}

Quando um robô é eliminado pelo jogador, a função PlayDying() é executada. Nesta função a física do robô é definida como PHYS_RigidBody para que ele caia no chão.

É verificada a possibilidade de o robô deixar cair um item de energia, que é representada pela classe SPG_HealthPickup. Este teste é feito com a expressão: "FRand() <= ChanceToDropPickup". FRand() é uma função do UnrealScript que retorna um valor aleatório entre 0.0 e 1.0. A variável ChanceToDropPickup está definida no Archetype com o valor "0.3". Isto significa que existe 30% de chance de que um item de energia caia do robô.

simulated function PlayDying(class<DamageType> DamageType, vector HitLoc)
{
    local DroppedPickup DroppedPickup;

    Mesh.MinDistFactorForKinematicUpdate = 0.0;
    Mesh.ForceSkelUpdate();
    Mesh.SetTickGroup(TG_PostAsyncWork);
    CollisionComponent = Mesh;
    CylinderComponent.SetActorCollision(false, false);
    Mesh.SetActorCollision(true, false);
    Mesh.SetTraceBlocking(true, true);
    SetPawnRBChannels(true);

    SetPhysics(PHYS_RigidBody);

    Mesh.PhysicsWeight = 1.f;

    if (Mesh.bNotUpdatingKinematicDueToDistance)
    {
        Mesh.UpdateRBBonesFromSpaceBases(true, true);
    }

    Mesh.PhysicsAssetInstance.SetAllBodiesFixed(false);
    Mesh.bUpdateKinematicBonesFromAnimation = false;
    Mesh.WakeRigidBody();

    // Set the actor to automatically destroy in ten seconds.
    LifeSpan = 10.f;

    // Chance to drop a pick up
    if (ArchetypedPickup != None && FRand() <= ChanceToDropPickup)
    {
        // Spawn a dropped pickup
        DroppedPickup = Spawn(ArchetypedPickup.Class,,, Location,, ArchetypedPickup);

        if (DroppedPickup != None)
        {
            // Set the dropped pick up to falling
            DroppedPickup.SetPhysics(PHYS_Falling);

            // Set the velocity of the dropped pickup to the toss velocity
            DroppedPickup.Velocity.X = 0;
            DroppedPickup.Velocity.Y = 0;
            DroppedPickup.Velocity.Z = RandRange(200.f, 250.f);
        }
    }
}

Platformer Kit: SPG_Weapon class (UnrealScript)

2012-06-26T14:06:00.000-03:00

A classe SPG_Weapon representa a arma utilizada no Platformer Kit. Ela é baseada na Link Gun do Unreal Tournament, mas possui apenas a opção de tiro com projétil.

Se você não conhece a classe Weapon, dê uma lida no artigo: "Classe Weapon (UnrealScript)".

As variáveis da classe SPG_Weapon estão disponíveis para modificação no editor.

class SPG_Weapon extends Weapon;

// Name of the socket which represents the muzzle socket
var(Weapon) const Name MuzzleSocketName;

// Particle system representing the muzzle flash
var(Weapon) const ParticleSystemComponent MuzzleFlash;

// Projectile classes that this weapon fires. DisplayName lets the editor show this as WeaponProjectiles
var(Weapon) const array< class<Projectile> > Projectiles<DisplayName=Weapon Projectiles>;

// Sounds to play back when the weapon is fired
var(Weapon) const array<SoundCue> WeaponFireSounds;

Também foi criado um Archetype para a classe SPG_Weapon. A imagem abaixo mostra os valores de algumas variáveis.

A classe SPG_Weapon utiliza dois Sockets. Um para marcar a posição no modelo 3D da arma de onde o tiro será disparado. O outro Socket pertence a classe SPG_PlayerPawn e marca a posição onde a arma deve ficar em relação ao jogador. Para entender mais sobre Sockets, dê uma lida no artigo da UDN: "Skeletal Mesh Sockets".

Na função PostBeginPlay() o Componente de Sistema de Partículas representado pela variável "MuzzleFlash" é anexado ao Socket da arma. A arma é anexada ao jogador na função ClientGivenTo().

simulated event PostBeginPlay()
{
    local SkeletalMeshComponent SkeletalMeshComponent;

    Super.PostBeginPlay();

    if (MuzzleFlash != None)
    {
        SkeletalMeshComponent = SkeletalMeshComponent(Mesh);
        if (SkeletalMeshComponent != None && SkeletalMeshComponent.GetSocketByName(MuzzleSocketName) != None)
        {
            SkeletalMeshComponent.AttachComponentToSocket(MuzzleFlash, MuzzleSocketName);
        }
    }
}

Uma das funções que é executada quando a arma é disparada é a PlayFireEffects(). Ela é responsável por ativar o Sistema de Partículas e reproduzir o som de disparo da arma.

Para mais informações sobre Sistemas de Partículas, acesse o artigo da UDN: "Particles Systems".

Segue abaixo a imagem de quando a arma é disparada e o código da função PlayFireEffects().

simulated function PlayFireEffects(byte FireModeNum, optional vector HitLocation)
{
    if (MuzzleFlash != None)
    {
        // Activate the muzzle flash
        MuzzleFlash.ActivateSystem();
    }

    // Play back weapon fire sound if FireModeNum is within the array bounds and if the 
    // weapon fire sound in that array index is not none
    if (FireModeNum < WeaponFireSounds.Length && WeaponFireSounds[FireModeNum] != None && Instigator != None)
    {
        Instigator.PlaySound(WeaponFireSounds[FireModeNum]);
    }
}

A outra função que é executada quando a arma é disparada é a ProjectileFire(). Ela é responsável por criar um novo projétil e iniciá-lo na posição e direção corretas.

A posição do projétil é obtida a partir da função GetWeaponStartTraceLocation() da classe SPG_PlayerPawn, que é representada no código pela variável Instigator.

simulated function Projectile ProjectileFire()
{
    local Vector SpawnLocation;
    local Rotator SpawnRotation;
    local class<Projectile> ProjectileClass;
    local Projectile SpawnedProjectile;

    // tell remote clients that we fired, to trigger effects
    IncrementFlashCount();

    // Only allow servers to spawn projectiles
    if (Role == ROLE_Authority)
    {
        // This is where we would spawn the projectile
        SpawnLocation = Instigator.GetWeaponStartTraceLocation();

        // This is the rotation we should spawn the projectile
        SpawnRotation = GetAdjustedAim(SpawnLocation);

        // Get the projectile class
        ProjectileClass = GetProjectileClass();
        if (ProjectileClass != None)
        {
            // Spawn the projectile setting the projectile's owner to myself
            SpawnedProjectile = Spawn(ProjectileClass, Self,, SpawnLocation, SpawnRotation);

            // Check if we've spawned the projectile, and that it isn't going to be deleted
            if (SpawnedProjectile != None && !SpawnedProjectile.bDeleteMe)
            {
                // Initialize the projectile
                SpawnedProjectile.Init(Vector(SpawnRotation));
            }
        }
      
        // Return it up the line
        return SpawnedProjectile;
    }

    return None;
}

Platformer Kit: SPG_PlayerPawn class (UnrealScript)

2012-06-25T11:47:00.000-03:00

A classe SPG_PlayerPawn representa o personagem do jogador. Se você não conhece a classe Pawn dê uma lida no artigo: "Classe Pawn (UnrealScript)".

As variáveis abaixo da classe SPG_PlayerPawn estão disponíveis para modificação no editor.

class SPG_PlayerPawn extends Pawn;

// Dynamic light environment component to help speed up lighting calculations for the pawn
var(Pawn) const DynamicLightEnvironmentComponent LightEnvironment;

// How fast a pawn turns
var(Pawn) const float TurnRate;

// How high the pawn jumps
var(Pawn) const float JumpHeight;

// Socket to use for attaching weapons
var(Pawn) const Name WeaponSocketName;

// Height to set the collision cylinder when crouching
var(Pawn) const float CrouchHeightOverride<DisplayName=Crouch Height>;

// Radius to set the collision cylinder when crouching
var(Pawn) const float CrouchRadiusOverride<DisplayName=Crouch Radius>;

Também foi criado um Archetype para a classe SPG_PlayerPawn. A imagem abaixo mostra os valores de algumas variáveis.

A função FaceRotation() da classe SPG_PlayerPawn é chamada a partir da função UpdateRotation() da classe SPG_PlayerController.

Nesta função serão ajustadas dois tipos de Rotação: a rotação da mira e a rotação do personagem.

A rotação da mira é ajustada a partir da variável "AimNode.Aim.Y" baseada no valor da variável Pitch da Rotação que é passada como parâmetro. A variável AimNode é do tipo AnimNodeAimOffset.

A rotação do personagem é feita baseada no valor da variável Yaw da Rotação que é passada como parâmetro, utilizando a função SetRotation() da classe Pawn.

simulated function FaceRotation(Rotator NewRotation, float DeltaTime)
{
    local Rotator FacingRotation;

    // Set the desired yaw the new rotation yaw
    if (NewRotation.Yaw != 0)
    {
        DesiredYaw = NewRotation.Yaw;
    }

    // If the current yaw doesn't match the desired yaw, then interpolate towards it
    if (CurrentYaw != DesiredYaw)
    {
        CurrentYaw = Lerp(CurrentYaw, DesiredYaw, TurnRate * DeltaTime);
    }

    // If we have a valid aim offset node
    if (AimNode != None)
    {
        // Clamp the current pitch to the view pitch min and view pitch max
        CurrentPitch = Clamp(CurrentPitch + NewRotation.Pitch, ViewPitchMin, ViewPitchMax);

        if (CurrentPitch > 0.f)
        {
            // Handle when we're aiming up
            AimNode.Aim.Y = float(CurrentPitch) / ViewPitchMax;
        }
        else if (CurrentPitch < 0.f)
        {
            // Handle when we're aiming down
            AimNode.Aim.Y = float(CurrentPitch) / ViewPitchMin;
           
            if (AimNode.Aim.Y > 0.f)
            {
                AimNode.Aim.Y *= -1.f;
            }
        }
        else
        {
            // Handle when we're aiming straight forward
            AimNode.Aim.Y = 0.f;
        }
    }

    // Update the facing rotation
    FacingRotation.Pitch = 0;
    FacingRotation.Yaw = CurrentYaw;
    FacingRotation.Roll = 0;

    SetRotation(FacingRotation);
}

A função DoJump() é chamada para realizar o pulo do personagem. Ela leva em conta os diferentes modos de Física que o personagem pode se encontrar.

Em essência, a velocidade no eixo Z (para cima) recebe o valor que se encontra na variável JumpHeight que foi definido nesta classe e que pode ser ajustada no Archetype. Depois é verificado se o jogador se encontra em uma plataforma móvel. Caso seja verdade então a velocidade da plataforma (Base.Velocity.Z) influencia a velocidade do pulo do jogador.

function bool DoJump(bool bUpdating)
{
    if (bJumpCapable && !bIsCrouched && !bWantsToCrouch && (Physics == PHYS_Walking || Physics == PHYS_Ladder || Physics == PHYS_Spider))
     {
        if (Physics == PHYS_Spider)
        {
            Velocity = JumpHeight * Floor;
        }
        else if (Physics == PHYS_Ladder)
        {
            Velocity.Z = 0.f;
        }
        else
        {
            Velocity.Z = JumpHeight;
        }

        if (Base != None && !Base.bWorldGeometry && Base.Velocity.Z > 0.f)
        {
            Velocity.Z += Base.Velocity.Z;
        }

        SetPhysics(PHYS_Falling);
        return true;
    }

    return false;
}