Independent Game Festival

Estava dando uma olhada pelos sites e vi em vários blogs falando sobre esse evento, comentando sobre ter vários competidores e tudo mais. Acho muito bom essas coisas, e sou louco atrás de campeonatos assim para tentar competir.
Porém nesse infelizmente não posso, por um leve detalhe, eu ainda não tenho nenhum jogo, com excessão do que eu fiz para TCC, mas esse não considero tanto assim.
Independente disso resolvi dar uma olhada em alguns projetos.
Na página Independet Game Festival existe a lista de todos competidores e acho que a maioria dos projetos tem um video de demonstração. Ainda estou dando uma passada na lista e assistindo os vídeos.
Meu objetivo nisso é ver a qualidade dos jogos do pessoal que está desenvolvendo jogos, lembrando que é mundial esse campeonato, e por enquanto vi apenas um projeto que sei que é brasileiro, o City Rain, que ganhou a Imagine Cup um tempo atrás. Fico torcendo para eles ou algum brasileiro faturar essa também.
Mas fica aqui a página de um jogo que achei muito interessante a ideia e a jogabilidade, esse eu realmente paguei um pau, o jogo chama Cogs .



Pretendo deixar mais alguns videos assim que achar mais jogos interessantes, e comentar um pouco também.

Modificações

Vou tentar dar uma ressussitada nesse blog, depois de um belo tempo. Terminou meu tcc faz alguns dias e estou começando a mexer no Unity3D, pegando uns tutoriais ainda. O visual do blog vai ficar meio estranho por uns dias, pois estou começando a modifica-lo...

Meu TCC quase final

Faltando praticamente duas semanas pra apresentação do TCC e ele ainda cheio de erros... vou aproveitar o tempo aqui pra descrever o projeto como está por enquanto, pois disso não acho que vá mudar muito.
A imagem é simples pois tudo foi feito em SDL, porém é possivel jogar via rede com até 15 jogadores. As unicas API usadas são SDL, SDL_net, SDL_ttf, SDL_image. E alguns scripts foram feito em Lua.

Essa primeira tela é a de login, onde existe o campo de usuário e senha. Emcima disso contém a história do jogo, um introdução do que será a primeira missão do jogo, que por enquanto é a única.

Essa tela é a de conversa com o NPC, todos npcs tem um script em lua contendo as frases da conversa.

Apertando F1 existe uma tela de Ajuda que mostra os comando básicos para jogar.

A tela de luta, não existe movimento do personagem na luta, apenas é mostrado o dano no campo de texto, a barra de vida diminui e a de XP aumenta...

Simplificando sem falar em todos os passos e tecnologias é isso meu tcc. Assim que tiver terminado, se eu passar eu vou deixar o documento aqui.

Lua no Windows com Visual Studio

Depois de um belo tempo apanhando tentando juntar Lua e C++ no windows eu consegui, mais ou menos, mas dá pra fazer alguma coisa util.

Aqui vai um tutorial de como usar Lua com visual Studio.

1 - Baixe e instale o Lua for Windows. Fazendo a instalação completa ele deixa todos arquivos necessários para o desenvolvimento.

2 - No visual Studio, crie um novo Projeto. Vá em propriedades e Adicione a paste Include no seu devido lugar, bem como a pasta Lib. (essa parte é bem simples, google deve ensinar também).

3 - Voltando ao Projeto em 'Resources Files', crie o arquivo "teste.lua" e cole esse código no arquivo

function falar(palavra)
if palavra == "oi" then
return "Ola, em que posso ajuda-lo?"

elseif palavra == "ola" then
return "Ola, em que posso ajuda-lo?"

elseif palavra == "tchau" then
return "Ate Logo"

elseif palavra == "comprar" then
return "Aqui estao os itens que eu vendo"

elseif palavra == "vender" then
return "Otimo, que itens gostaria de vender"

else
return "nao sei do que esta falando"
end
end

Esse é um jeito simples de conversação, como não sei muito de Lua, foi o jeito mais rápido que pensei para testar a função.

4 - No arquivo principal do C++, adicione esse código

#include
// Carrega as bibliotecas do Lua e Auxiliares
extern "C"
{
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
}

int main()
{
// Inicia o Lua
lua_State* L = lua_open();
// inicia todas bibliotecas adicionais
luaL_openlibs(L);
// Roda o script criado
luaL_dofile(L, "teste.lua");
// Apaga qualquer dado que estiver na pilha
lua_settop(L, 0);

char b[30];
do {
printf(">");
scanf("%s", b);
// Pega o arquivo global com esse nome, que no caso é uma função, mas poderia ser uma variável
lua_getglobal(L, "falar");
// Envia a String digitada para a pilha para ser processada pela funcao
lua_pushstring(L, b);
// Chama a funcao com um argumento e que ira retornar um valor
lua_call(L, 1, 1);
// Transforma o resultado que está na primeira posição da pilha em string e imprime
printf("%s\n",lua_tostring(L, -1));
// Apaga o valor da pilha
lua_pop(L, 1);
} while(b[0] != 'q');
// Termina lua
lua_close(L);

return 0;
}



Se eu tiver feito tudo certo e você também o código irá rodar e você terá um sistema bem simples de chat para usar em jogos, como é no meu caso.

Cliente em SDL_net

Aqui tem um código simples de um cliente multi-thread usando SDL_net.
O código é bem simples, e eu usei de base. Ele completo está junto com os exemplos de SDL_net, mas eu tirei muita coisa do código para ficar mais fácil de entender.
Vou deixar todas as linhas comentadas, no proximo post eu tento deixar o servidor aqui.


//Arquivo 'CConnection.h'
class CConnection
{
public:
// Inicia a conecção com a rede
CConnection();
// Thread responsável por receber as mensagens da rede
void netThread();
// Thread responsável por enviar mensagens para a rede
void localThread();


private:
// Tamanho maximo das mensagens
static const int LENGTH = 1024;
IPaddress ip;
// Socket para conecção
TCPsocket sock;
// Porta para conecção com a rede
Uint16 port;
char *name;
char * host;
char msgSend[LENGTH];
char *msg;
char msgRecv[LENGTH];
SDLNet_SocketSet socketSet;
int numReady;
char *str;
};

Arquivo com descrição dos métodos: "CConnection.cpp"

#include "CConnection.h"

CConnection::CConnection()
{
// IP do host, ou localhost para conecção local
host = "localhost";
// Nome do usuario para identificar no servidor
name = "usuario";
// Inicia o SDL_net
SDLNet_Init();
// Porta de conecção 8080
port = 8080;

SDLNet_ResolveHost(&ip,host,port);
// Abre o socket de conecção
sock = SDLNet_TCP_Open(&ip);
// Aloca o socketset para verificar apenas um socket
socketSet = SDLNet_AllocSocketSet(1);
// Adiciona o socket de conecção ao socketset
SDLNet_TCP_AddSocket(socketSet, sock);
// envia mensagem para o servidor com o nome
SDLNet_TCP_Send(sock, name, strlen(name));

numReady = 0;
}
void CConnection::localThread()
{
// Thread sempre fica rodando par enviar mensagem
while(1)
{
// Pega mensagem a ser enviada
scanf("%s", &msgSend);

msgSend[strlen(msgSend)-1]='\0';

if(strlen(msgSend))
{
// Envia mensagem para o servidor
SDLNet_TCP_Send(sock, msgSend, strlen(msgSend));
}
}
}
void CConnection::netThread()
{
// Sempre está recebendo mensagem
while(1)
{
// Verifica se o socket esta pronto para receber dados
numReady = SDLNet_CheckSockets(socketSet, 1000);

if(numReady == 1)
{
if(SDLNet_SocketReady(sock))
{

char tmp[LENGTH];
// result é o tamanho da mensagem recebida
int result = SDLNet_TCP_Recv(sock, msgRecv, LENGTH);
// copia para uma variavel temporaria apenas a quantidade exata da frase
strncpy (tmp,msgRecv,result);
// Finaliza o string
tmp[result] = '\0';
strcpy(msgRecv, tmp);
printf("%s\n",msgRecv);
}
}
}
}

Arquivo principal do código com o método main. "main.cpp"

#include "CConnection.h"
// inicia a conecção
CConnection *conn = new CConnection();
// cria thread para recebimento de msg
int net(void *unused)
{
conn->netThread();
return 0;
}
// cria thread para envio de msg
int local(void *unused)
{
conn->localThread();
return 0;
}

int main(int argc, char *argv[])
{
// inicia SDL
SDL_Init(SDL_INIT_EVERYTHING);
// Cria as threads
SDL_Thread *netThread, *localThread;
// inicializa as threads
localThread = SDL_CreateThread(local, NULL);
netThread = SDL_CreateThread(net, NULL);
// deixa o programa rodando
while(1)
{

}

SDLNet_Quit();
SDL_Quit();
return(0);
}

Rede com SDL_net

Depois de uma semana de muito palavrão e por ter passado vontade de quebrar o computador várias vezes eu consegui entender o sistema de rede do SDL_net.
Depois que se entende as coisas, sempre parece que elas sao tão obvias. Mas como eu não achei nenhum código simples e comentado para download tive que ir modificando o que tinha disponivel e apagando metade do código para deixar um pouco mais simples.
Mas enfim consegui fazer funcionar a rede.
Como tudo ja vem semi pronto, o jeito mais simples disponibiliza apenas 15 jogadores conectados ao servidor. É possível adicionar a quantidade que desejar, porém acho que para o TCC é mais que o suficiente.
Por enquanto é possivel o cliente conectar, desconectar e reconectar ao servidor.
Enviar e receber mensagens.
As mensagens podem ser transmitidas para todos os clientes depois de chegarem ao servidor.

Agora o próximo passo é sincronizar isso ao cliente e codificar as mensagem.

Editor de Mapas

Quase 11 hrs da noite, e acabei de terminar o editor de mapas d jogo.
Essa é o que eu posso chamar de versão 1.0, bem simples, porém faz tudo que é necessário.

O mapa é feito por 2 camadas, uma que contém apenas os terrenos e a outra onde ficará o ambiente, objetos, árvores, entre outras coisas.
Os mapas são salvos em um arquivo simples que contém apenas o código dos Tiles.
O editor pode colocar os objetos dessas duas camadas, sendo que cada camada tem objetos distintos, são arquivos diferentes, e em cada arquivo é possível ter 1000 tiles diferentes, apesar de eu usar no máximo 200 nesse jogo.
O tamanho do mapa, ainda é apenas editado manualmente.
O editor já salva o arquivo e o recarrega em caso de algum erro.
Os desenhos são feitos utilizando o mouse.
O mapa se movimenta pelo teclado.
No canto superior esquerdo tem os tiles modelos, que podem ser mudados utilizando as teclas: A,S,D,W.
Fica aqui a foto do editor.



Assim que estiver pronto o mapa eu posto uma imagem dele.

Primeira Tela

Depois de alguns milhoes de anos tentando fazer alguma coisa, atrasando meu tcc por qualquer motivo besta. Até que enfim consegui fazer a primeira tela do jogo.
Ela não está funcionando 100%, a parte de Chat tenho que fazer alguns ajustes ainda, e por enquanto apenas funciona offline, com alguns defeitinhos.
Mas ja é alguma coisa.

GUI usando SDL

Depois de muito tempo tentando fazer funcionar o código dos outros, resolvi fazer um inteiro meu, o que não é tão complicado quanto parece, ou pelo menos eu estou achando isso ainda.
Meu maior problema mesmo ainda é o C++, ainda apanho um pouco com isso.
Mas enfim, eu precisava mais de botões, e principalmente de campos de texto para poder digitar as coisas no jogo. E por enquanto está indo a todo vapor.
O botão é feito por meio de imagem, e é possível colocar 2 imagens, uma com o botão normal e outra quando é clicado. É possível colocar funções para clicar com botão esquerdo e direito, apenas ainda não coloquei os escritos no botão, mas isto também é simples.
O campo de texto tem um sistema de ativar e desativar, que quando ativado, tudo que for digitado aparece no campo, e quanto desativado, o texto permace onde está. Falta apenas podelar a parte visual, mas é possivel escolher qualquer estilo de fonte, tamanho e cor.
Aqui vai um visual bem simples de como está indo tudo. Pretendo deixar o código aqui assim que terminado.


Acima na esquerda é o botão e embaixo o campo de texto.

Campeonato de SDL

Depois de tanto tempo estudando, até que enfim resolveram criar um campeonato que use SDL.
Li um artigo agora a pouco falando sobre isso e ja fui ver na página.
O prêmio é de 200 dólares pago pelo PayPal.
A data para envio do projeto é até 1 de setembro (até que tem bastante tempo).
e O gênero é Side Scrolling Shooters, que andei dando uma olhada e é tipo aqueles jogos antigos de naves de tiro, pra quem jogou Super Nintendo acho que é tipo STG.

Aqui vai o site para quem se interessa. Eu vou participar.

SDL Tutorials