Buenas, os traigo ya por fin después de unas semanas desarrollando la primera versión de gameLibZeroCPP que es el mismo engine para hacer juegos 2D que he programando anteriormente para java/processing y recientemente termine tambinén para javaScript.
Esta en su primera versión, me faltan infinidad de cosas, pero ya se pueden hacer juegos completos.
- Incluye todo lo necesario para empezar a crear video juegos, todo el entorno está preconfigurado, el editor es el conocido Notepad++.
Como viene siendo costumbre en mi, presento un nuevo proyecto con una serie de videos para los pocos curiosos que quieran trastear con el, aquí va el primero.En breve muchos mas..
DESCARGA: https://www.dropbox.com/s/54a7xq9gq0avcmi/gameLibZeroCPP.zip?dl=0 (https://www.dropbox.com/s/54a7xq9gq0avcmi/gameLibZeroCPP.zip?dl=0)
DESCARGA; INSTALACION Y PRIMEROS PASOS
https://www.youtube.com/watch?v=47ma6hsz8KY&feature=youtu.be (https://www.youtube.com/watch?v=47ma6hsz8KY&feature=youtu.be)
TUTORIAL 02: ESCENAS.
https://youtu.be/Fvgnmc4OJbI (https://youtu.be/Fvgnmc4OJbI)
TUTORIAL 03: ANIMACIONES Y SEÑALES.
https://youtu.be/ffD_M2Ik97A (https://youtu.be/ffD_M2Ik97A)
TUTORIAL 05: JUEGO DE NAVES DESDE CERO!
https://www.youtube.com/watch?v=QKfBZpwC0ZU (https://www.youtube.com/watch?v=QKfBZpwC0ZU)
https://www.youtube.com/watch?v=N2cMJzU0wK8 (https://www.youtube.com/watch?v=N2cMJzU0wK8)
https://www.youtube.com/watch?v=JM8UQnCvTHc (https://www.youtube.com/watch?v=JM8UQnCvTHc)
https://www.youtube.com/watch?v=Cjs1cUBoXeY (https://www.youtube.com/watch?v=Cjs1cUBoXeY)
TUTORIAL 07: COLISIONES!
https://www.youtube.com/watch?v=KSXrPWLMsxs
Descarga del ejemplo en los comentarios del video.. descarga del entorno actualizada ;)
Ya tengo el sistema de scroll listo :)
En breve el video tutorial mostrando como usarlo.
Tutorial sobre scrolls con la libreria para c++, hasta mas sencillo que en div.
https://youtu.be/Fvgnmc4OJbI?list=PLdAjzekZKCCYHPg8A8lVbV4oqZs-eDpdS
¡Gran trabajo! Estoy siguiendo atentamente tus avances con la librería :D :D
Gracias tio, en breve un juego de muestra para ver el desarrollo desde cero de un juego completo.
Pinta interesante ahora que instale devc++
Saludos
Entorno actualizado y tercer video tutorial sobre animaciones y señales.
A disfrutarlo ;)
Entorno actualizado al inicio del post! Libreria actualizada con los scrolls!
Nuevo ejemplo sobre como controlar el scroll.. mas bien es algo mas que un scroll.. es realmente la capacidad que tiene la libreria de renderizar los sprites tileados y ciclicos, así que en mis pruebas he creado un scroll parallax con 7 mil capas y funciona perfecto..
Son posibles los efectos de agua, lluvia, lava, nuebla etc etc..
Actualizado al inicio del post, ejemplo de juego de naves desde cero en cpp ;)
Actualizada la descarga del entorno con la libreria actualizada, ahora contiene un pequeño controlador de teclado que permite capturar pulsaciones y las almacena en un buffer con todo el texto escrito.
Un ejemplo de codigo seria este;
#include "gameLibZero.cpp"
keyboard keyb;
void setup(){
setMode(640, 400);
setFps(60);
keyb.setFont(GetFontDefault());
}
void draw(){
keyb.core();
keyb.render();
}
donde keyb.core() realiza el trabajo de construir el texto en base a las pulsaciones, y keyb.render() pinta una linea simple en pantalla con el contenido del texto..
La clase que hace de controlador de buffer de escritura es esta por si alguien tiene curiosidad:
class keyboard{
public:
int size = 22; // text font size..
static const int buffer_size = 255; // keyboard buffer size..
char buffer[buffer_size]; // buffer..
int key; // allows key detection code..
int ptr = 0; // iterator..
bool visible = true;
int align = RIGHT;
float x, y;
float alpha = 255;
Font font;
bool font_defined = false;
int delay; // delay to show cursor..
//---------------------------------
//---------------------------------
void core(){
key = GetKeyPressed();
if(IsKeyPressed(KEY_BACKSPACE)){
key = -1000;
}
switch(key){
case -1:
// no key detected..
break;
case -1000:
{
if(ptr>0){
ptr --;
buffer[ptr] = 0;
}
delay = 0;
}
break;
default:
{
buffer[ptr] = key;
ptr++;
if(ptr>buffer_size){
cout<<"Warning: Keyboard buffer overflow."<<endl;
ptr--;
}
delay = 0;
}
break;
}
}
//---------------------------------
void setFont(Font fnt){
this->font = fnt;
font_defined = true;
}
//---------------------------------
void clear(){
memset(buffer, 0, sizeof(buffer));
ptr = 0;
}
//---------------------------------
void render(){
if(!font_defined){
cout<<"Warning: Keyboard font not defined.."<<endl;
}else{
screenDrawText(font, size, buffer, align, x, y, WHITE, alpha);
delay = (delay+1)%(fps/2);
if(delay<(fps/4)){
Vector2 offset = MeasureTextEx(font, buffer, size, text_spacing);
screenDrawText(font, size, "_", align, x+offset.x+2, y, WHITE, alpha);
}
}
}
//---------------------------------
};
Resaltado de sintaxys para la gameLibZero..
Acabo de grabar un nuevo video tutorial, esta subiendo a youtube, en breve os lo comparto, junto con la nueva libreria actualizada y con coloreado de sintaxis de regalo ;)
El video trata sobre las colisiones, explica profundamente las funciones collision() collisionMouse() y collisionType(), también muestra mediante una imagen de un juego de naves lo que es realmente el juego en si detrás de todos sus adornos, dejando a la vista la esencia del juego y el calculo de colisión entre poligonos.
En un rato estara disponible junto con el nuevo material para probar.. de entre las novedades, que también prepararé videos explicativos sobre como usarla.. se encuentra mi "usadisima por mi" EGUI por fin portada a C++ tambien.. donde podremos crear botones, cajas de entrada de texto y checkButton´s de una forma tan sencilla que da la risa 8-)
Y ya para después de los videos sobre Animacion y EGUI prepararé una libreria de red al mas puro estilo Div Games Studio, hace años preparé un API para hacer un modulo de red para Gemix, llevo años perfeccionandolo en java/processing ya que lo uso a diario en el trabajo y creo que la siguiente tarea será portarlo también a C++ para tener libreria de red atraves de internet de una forma también simple.
Buenas Erkosone :)
Yo estoy muy liado para probar cosas, pero háblame por privado en Discord si necesitas hosting web en un subdominio de divhub.org :)
Buenas gente, os comunico que acabo de liarme la manta a la cabeza y he decidido integrar un 3d en los procesos estilo div..
Esta idea me lleva rompiendo la cabeza desde hace muchos años.. pensando como integrar un sistema 3d en un sistema de procesos 2d y creo que tengo una buena solución.. Lo estoy planteando así:
- Los procesos de inicio son 2D, para que puedan representar un grafico o modelo 3D simplemente se usa esta función desde el proceso: set3D(); y ya esta.. el grafico ahora pertenece al plano 3d y no al 2d.. sus X Y Z serán las usadas para representarlo en el plano 3d del juego.
Para volver al modo de renderizado 2d tan solo hay que hacer: set2D(); y volveremos a tener un proceso normal y corriente.
ahora mismo estoy pensando el mejor nombre para asignar un modelo cargado al proceso y que sea este el que se represente.. como tengo las variable locales predefinidas graph y visible.. creo que bastará con que si visible == true el graph se represente en 3d o en 2d.. osea.. si se ha llamado desde un proceso concreto a set3D(); y hago visible = false; no se pintará su graph.. pero si hago setModel(xxx); entonces se pintará el modelo 3d..
La idea es que co-existan los dos sistemas conjuntamente, tanto el 3d como el 2d..
Así que lo que añado a los procesos es:
metodos:
set3D();
set2D();
setModel();
freeModel();
variables:
bool model_visible;
float anglex;
float angley;
float angle lo antengo ya que será igual que anglez..
Creo que tiene consistencia.. haber las pruebas que tal.. voy a intentar hacer algun mierda churro juego para ver si se hace natural escribir codigo con estos nombres.. que os parece este sistema?
Un ejemplo de codigo es este:
#include "gameLibZero.cpp"
int ST = 0;
Font fnt;
images img;
//------------------------------------------------------------
void setup(){
setMode(1024, 600);
setFps(60);
fnt = LoadFont("data/fonts/00.png.fnt");
loadImages("data/images", &img);
}
//------------------------------------------------------------
class objeto_2d:public process{
public:
int st = 0;
int anima = 0;
vector<int>animation = { 0,0,0,1,1,1,2,2,2,3,3,3,4,4,4 };
void frame(){
switch(st){
case 0:
{
graph = img[0];
visible = true;
x = 512;
y = 200;
size = 200;
st = 10;
}
break;
case 10:
{
anima = (anima+1)%animation.size();
graph = img[animation[anima]];
}
break;
}
}
};
//------------------------------------------------------------
class objeto_3d:public process{
public:
int st = 0;
int anima = 0;
vector<int>animation = { 0,0,0,1,1,1,2,2,2,3,3,3,4,4,4 };
void frame(){
switch(st){
case 0:
{
graph = img[0];
visible = true;
x = 0;
y = 0;
z = 0;
size = 200;
set3d();
st = 10;
}
break;
case 10:
{
anima = (anima+1)%animation.size();
drawGraphic3D(graph, x, y, z, size, alpha);
if(key(KEY_LEFT)){
x -= 0.1;
}
if(key(KEY_RIGHT)){
x += 0.1;
}
if(key(KEY_UP)){
z -= 0.1;
}
if(key(KEY_DOWN)){
z += 0.1;
}
if(key(KEY_Q)){
y += 0.1;
}
if(key(KEY_A)){
y -= 0.1;
}
}
break;
}
}
};
//------------------------------------------------------------
void draw(){
screenDrawText(GetFontDefault(), 22, "gameLibZero 1.5", CENTER, 512, 50, WHITE, 255);
screenDrawText(fnt, 64, "3D world + 2d sprites tech demo", CENTER, 512, 150, WHITE, 255);
switch(ST){
case 0:
{
new objeto_2d();
new objeto_3d();
ST = 10;
}
break;
case 10:
{
}
break;
}
}
//------------------------------------------------------------
La función drawGraphic3d(); es improvisada.. es un screenDrawGraphic() pero para 3d.. en la versión publica de la libreria no sera necesaria.. ya existirá el metodo interno render3D() de los procesos que renderizará automaticamente lo que tenga que renderizarse..
Avances 3D:
- Cambio de proceso 2d normal a proceso 3d con los metodos set2d() y set3d().
- Estando en modo 3d() un proceos renderizará su graph como un sprite 3D.
- Si se setea un modelo 3d al proceso con setModel() el proceso 3D dejará de renderizar su graph como sprite3D y pasará a renderizar su modelo3D.
- Para volver a renderizar su graph como sprite3D se libera el modelo con freeModel();
Un ejemplo de codigo de todo esto, es realmente simple:
#include "gameLibZero.cpp"
int ST = 0;
Font fnt;
images img;
Model m;
//------------------------------------------------------------
void setup(){
setMode(1024, 600);
setFps(60);
fnt = LoadFont("data/fonts/00.png.fnt");
loadImages("data/images", &img);
m = LoadModel("data/models/bridge.obj");
//fullscreen();
}
//------------------------------------------------------------
class objeto_2d:public process{
public:
int st = 0;
int anima = 0;
vector<int>animation = { 0,0,0,1,1,1,2,2,2,3,3,3,4,4,4 };
void frame(){
switch(st){
case 0:
{
graph = img[0];
visible = true;
x = 512;
y = 200;
size = 200;
st = 10;
}
break;
case 10:
{
anima = (anima+1)%animation.size();
graph = img[animation[anima]];
}
break;
}
}
};
//------------------------------------------------------------
class objeto_3d:public process{
public:
int st = 0;
int anima = 0;
vector<int>animation = { 0,0,0,1,1,1,2,2,2,3,3,3,4,4,4 };
void frame(){
switch(st){
case 0:
{
graph = img[0];
visible = true;
x = 0;
y = 0;
z = 5;
size = 50;
set3d();
setModel(m);
setTexture("data/models/bridge_diffuse.png");
anglez = 45;
st = 10;
}
break;
case 10:
{
anima = (anima+1)%animation.size();
graph = img[animation[anima]];
}
break;
}
}
};
//------------------------------------------------------------
class objeto_3d_b:public process{
public:
int st = 0;
int anima = 0;
vector<int>animation = { 0,0,0,1,1,1,2,2,2,3,3,3,4,4,4 };
void frame(){
switch(st){
case 0:
{
graph = img[0];
visible = true;
x = 0;
y = 0;
z = 0;
size = 200;
set3d();
st = 10;
}
break;
case 10:
{
anima = (anima+1)%animation.size();
graph = img[animation[anima]];
if(key(KEY_LEFT)){
x -= 0.1;
xmirror = true;
}
if(key(KEY_RIGHT)){
x += 0.1;
xmirror = false;
}
if(key(KEY_UP)){
z -= 0.1;
}
if(key(KEY_DOWN)){
z += 0.1;
}
if(key(KEY_Q)){
y += 0.1;
}
if(key(KEY_A)){
y -= 0.1;
}
}
break;
}
}
};
//------------------------------------------------------------
void draw(){
screenDrawText(GetFontDefault(), 22, "gameLibZero 1.5", CENTER, 512, 50, WHITE, 255);
screenDrawText(fnt, 64, "3D world + 2d sprites tech demo", CENTER, 512, 150, WHITE, 255);
switch(ST){
case 0:
{
new objeto_2d();
new objeto_3d();
new objeto_3d_b();
ST = 10;
}
break;
case 10:
{
}
break;
}
}
//------------------------------------------------------------
Y el ejemplo compilado para probar:
UPDATE IMPORTANTE!
Habia un bug grave en la creación de procesos con cuerpos estaticos, ahora se crean correctamente, lo he descubierto durante el desarrollo de un tutorial de juego de plataformas para publicar..
Habia un error durante la creación del shape interno.. este no era capaz de rotar antes de añadirse al mundo para posteriormente volverse estatico..
Ahora esta corregido, y aquí esta el ejemplo de juego de plataformas.. es un mini ejemplo para ver la potencia de la libreria usando sensores.. es una simplificación de las versiones anteriores que usaban isContact() que es una función demasiado compleja para lo que sirve en si misma.. ahora con los procesos a modo de sensor la cosa esta muchisimo mas cercana al estilo DIV original. :)
La verdad es que me siento muy comodo con esta forma de hacer las cosas.. si alguien descarga el ejemplo y lo prueba ya verá como funciona perfecto.. y mas simple no puede ser ;)
El archivo rar contiene la ultima versión de la libreria.. no actualizo el entorno todavía al completo por que en esta nueva entrega incluirá generador de fuentes estupendo, egui, y mucho contenido 3d además de un juego al estilo mario de la wii de estos que sale mario en sprites dentro de un mundo 3d.
(http://forum.bennugd.org/index.php?action=dlattach;topic=4749.0;attach=4150)
#include "gameLibZero.cpp"
int ST = 0;
images img;
int type_plataforma;
void setup(){
setMode(640, 400);
setFps(60);
fullscreen();
loadImages("data/images", &img);
setGravity(0, 0);
}
//------------------------------------------------------------------
class sensor:public process{
public:
int st = 0;
bool toco_suelo = false;
void frame(){
switch(st){
case 0:
{
graph = img[2];
visible = true;
x = father->x;
y = father->y;
createBody(TYPE_CIRCLE, METAL);
setSensor(true);
st = 10;
}
break;
case 10:
{
x = father->x;
y = father->y;
translate(x,y+32);
toco_suelo = collisionType(type_plataforma);
}
break;
}
}
};
//------------------------------------------------------------------
class personaje:public process{
public:
int st = 0;
sensor* s;
bool salto = false;
void frame(){
addVy(10);
switch(st){
case 0:
{
graph = img[1];
visible = true;
x = 320;
y = 320;
createBody(TYPE_BOX, METAL);
s = new sensor();
st = 10;
}
break;
case 10:
{
/* ¿¿ TOCO SUELO ?? */
if(s->toco_suelo){
screenDrawText(GetFontDefault(), 18, "TOCO_SUELO", CENTER, x, y-50, WHITE, 255);
if(key(KEY_UP) && salto==false){
salto = true;
addVy(-400);
}
}else{
}
if(!key(KEY_UP)){
salto = false;
}
if(key(KEY_LEFT)){
addVx(-10);
}
if(key(KEY_RIGHT)){
addVx(10);
}
if(key(KEY_DOWN)){
addVy(5);
}
}
break;
}
}
};
//------------------------------------------------------------------
class plataforma:public process{
public:
int st = 0;
int w,h;
plataforma(float x, float y, float width, float height, float angle){
this->x = x;
this->y = y;
this->w = width;
this->h = height;
this->angle = angle;
}
void frame(){
switch(st){
case 0:
{
graph = newGraph(w, h, BLUE);
visible = true;
createBody(TYPE_BOX, HUMAN);
type_plataforma = type;
setStatic(true);
st = 10;
}
break;
case 10:
break;
}
}
};
//------------------------------------------------------------------
void draw(){
switch(ST){
case 0:
{
// plataforma( x, y, ancho, alto, angulo );
new plataforma(320, 390, 640, 10, 0);
new plataforma(100, 350, 200, 5, 10);
new plataforma(540, 350, 200, 5, -10);
new plataforma(200, 250, 100, 5, 0);
new plataforma(440, 250, 100, 5, 0);
new plataforma(320, 150, 200, 5, 0);
new personaje();
ST = 10;
}
break;
case 10:
{
}
break;
}
}
muy bueno erkosone, me gusta lo del 3d...
podes incluir videos de los demos?
Hola Splinter, si claro, dejame que entremos en el fin de semana y me pongo a ello ;)
UPDATE:
- Añadidos nuevos metodos para calculo de distancias en 2d y 3d.
- Añadidos nuevos materiales tales como 'SENSOR' para crear cuerpos kinematicos hasta ahora no disponibles.
Bien, pues llegados a este punto en el que el engine es funcional y es rapido y estable, comienzo el port a WEB, osea, voy a incrustrar emscriptem en el paquete para que "pulsando F6" se compile el proyecto para WEB.
Así me ahorro todo el sistema de multiplataforma ya que en web assembly funcionan todas las librerias que estan escritas en C99 y en mi caso esto se cumple.
Mas noticias dentro de poco..
UPDATE:
- Implementado el sistema de resolución virtual automatico.
La cosa esta en que tu haces un setMode(320, 176); por ejemplo, y luego puedes redimensionar la ventana e incluso maximizarla, la verdad es que ha quedado genial! os dejo un pequeño test para ver el concepto, queda muy bien!