Luiz Pestana's Web Blog desenvolvimento de aplicativos e jogos

Rodando Apenas um Processo C# (.Net)

Para se certificar que só haverá uma execução de seu programa, fiz um pequeno código que encerra a execução antiga desse mesmo exe, mantendo somente a recém executada.

Coloque isso antes do Application.Run();

foreach (Process proc in Process.GetProcesses())
if ((proc.ProcessName == Path.GetFileNameWithoutExtension(Application.ExecutablePath)) && (proc.Id != Process.GetCurrentProcess().Id)) proc.Kill();

Caso queira que mantena apenas a antiga, interrompendo a recém executada, é só trocar o proc.Kill(); por Application.Exit();

ps: Não se esqueça, o código utiliza o nome do executável, então caso use algum executável com um nome bem comum, pode ser que não funcione.

Espero ter ajudado... =)

Compactar e Descompactar strings em C# (.Net)

Trafegar ou armazenar strings é uma tarefa muito comum nos aplicativos e jogos, se você é programador, é muito provável que já tenha feito algum arquivo de texto com configurações ou enviado informações em string através da rede. Mas você já pensou que pode economizar tempo e espaço se utilizar compactação?

Em C# (.Net) a compactação e descompactação de strings é um processo simples, desde que saiba o caminho, e por isso resolvi colocar um exemplo de como utilizar o GZip para a tarefa.

Primeiro é necessário utilizar essas bibliotecas específicas:

using System.IO;
using System.IO.Compression;

Para compactar, utilize o código:

string stringNormal = "seutexto";

byte[] byteArr = Encoding.Unicode.GetBytes(stringNormal);

// Você pode trocar o MemoryStream pelo FileStream para salvar em arquivo.
MemoryStream memStream = new MemoryStream();
GZipStream gzStream = new GZipStream(memStream, CompressionMode.Compress, true);
gzStream.Write(byteArr, 0, byteArr.Length);
gzStream.Close();

// Caso utilize o FileStream, troque o código a seguir pelo Save.
memStream.Position = 0;
byteArr = new byte[memStream.Length];
memStream.Read(byteArr, 0, byteArr.Length);
memStream.Close();

// Aqui o byteArr contém o conteúdo compactado que pode ser trafegado

Para descompactar é bem semelhante, porém é necessário a utilização de uma array de buffer:

string stringNormal;

// Você pode trocar o MemoryStream 1 pelo FileStream para salvar em arquivo.
MemoryStream memStream1 = new MemoryStream();

// Carregar o byteArr com o conteúdo compactado, ou trocar o MemoryStream 2 para FileStream.
MemoryStream memStream2 = new MemoryStream(byteArr);

GZipStream gzStream = new GZipStream(memStream2, CompressionMode.Decompress, true);
int readBytes;
byte[] buffer = new byte[1024];
while ((readBytes = gzStream.Read(buffer, 0, buffer.Length)) != 0)
    memStream1.Write(buffer, 0, readBytes);
memStream2.Close();
gzStream.Close();

// Caso utilize o FileStream, troque o código a seguir pelo Save.
memStream1.Position = 0;
byteArr = new byte[memStream1.Length];
memStream1.Read(byteArr, 0, byteArr.Length);
memStream1.Close();

stringNormal = Encoding.Unicode.GetString(byteArr);

Espero que tenha ajudado, e comente caso tenha alguma dúvida, crítica ou sugestão. ...ou apenas para agradecer! =)

Testes com Movimentação de Personagem

Hoje fiz um primeiro teste de movimentação com física e colisão para o meu mais novo projeto de jogo (logo mais passo detalhes sobre ele). Testei entre vários os tipos, aquele que a câmera segue de trás (Resident Evil 4 e 5, Uncharted, Tomb Raider...), com mouse para atacar e o teclado para andar (DeadNation, Alien Breed...), com o mouse para andar e atacar (Diablo, World of Warcraft...) e por fim teclado para andar e atacar (Resident Evil 1, 2 e 3).

A que eu mais me identifiquei foi a última, a qual você usa duas teclas para rotacionar o personagem e outras duas para andar para frente e para trás, assim como no clássico Resident Evil.

Após fazer alguns testes, segue o script da movimentação em LUA para Shiva 3D:

if ( nMX ~= 0 or nMY ~= 0 )
then
   object.rotate ( hModelObj, 0, nMX, 0, object.kGlobalSpace )

   local dX, dY, dZ = object.getDirection ( hModelObj, object.kGlobalSpace )
   dynamics.addForce ( hDynObj, nMY * 300 * dX, 0, nMY * 300 * dZ, object.kGlobalSpace )

   dynamics.setLinearDamping ( hDynObj, 5 )
end
object.matchTranslation ( hModelObj, hDynObj, object.kGlobalSpace )

Observações:
- nMX e nMX variam entre -1, 0 e 1 conforme as teclas WASD estão apertadas;
- hModelObj é o modelo do personagem e kDynObj é o objeto de colisão.

Confesso que tenho uma inclinação a escolher a movimentação dos jogos que eu mais gostei, porém sei que não são as melhores e por isso quero a opinião de vocês.

Shiva 3D com Kinect

Logo após a Microsoft lançar o SDK oficial para utilizar o Kinect no PC eu já comprei um. É muito interessante a ideia de desenvolver para um dispositivo que captura movimentos por tão pouco custo. Imagine as possibilidades? não só no desenvolvimento de jogos que usem o Kinect mas também como ferramenta para desenvolver outros jogos. Sim, pensei que ele pode ser usado como motion capture para animações de modelos 3D, mesmo que o Kinect não seja usado no próprio jogo. As possibilidades são muitas.

E para testar a SDK, que pode ser encontrada aqui: http://research.microsoft.com/en-us/um/redmond/projects/kinectsdk/ utilizei o Shiva 3D (engine a qual já tenho algum conhecimento). Tive que programar um plugin em C++, mas nada tão completo, a SDK é bem explicadinha e intuitiva.

Vejam uma demo:

Ainda estou finalizando algumas coisas no plugin, e gostaria de saber se vocês ficaram interessados nisso, se sim, posso abrir o fonte assim que terminar.

Não esqueçam de me seguir no twitter para novidades: http://twitter.com/luizpestana/

Até logo!

Tutorial de Shiva 3D, parte 1

Olá amigos desenvolvedores e curiosos, estou aqui escrevendo mais um tutorial para facilitar as vossas vidas e também aprender. Dessa vez estarei escrevendo sobre o Shiva 3D, uma engine de jogos que descobri na Campus Party e me interessou devido a sua portabilidade e facilidade de desenvolvimento.

Seria um produto similar ao Unity 3D e Unreal Engine, os quais eu já tinha um pouco de experiência, porém mais acessível, pois além de existir uma versão não comercial gratuita, sua licença custa desde R$400 em sua versão básica, até R$4000 com recursos mais avançados.

Se te interessou, leia o tutorial por completo na comunidade GameDev-BR clicando aqui.

E não esqueça de comentar. =)