Buenos dias, estoy apilando ideas para empezar a hacer juegos simples que se vayan a disfrutar a partir de un rango de edad mas bien pequeño, solo que no tengo realmente algo bien pensado y reforzado porque ademas me gustaria que "aprendieran" alguna cosa jugando.

Habia pensado en hacer algo mas bien del estilo de busqueda de pareja o bien de relacion de objetos, pero estoy abierto a cualquier sugerencia.

Por otro lado donde me recomendariais desarrollar esta idea, se que para el manejo del PC tampoco puedo meterme en un target de edad demasiado bajo, pero pensando como son algunos padres hoy en dia que por ejemplo le dejan cualquier tablet a manos, bajo supervision adulta espero xD, pues me abre un poco el abanico de posibilidades. Aunque el PC suele estar en primer lugar.

Kinect podria ser una alternativa no? Que opinais?

No soy de los que responden mucho por el foro aunque si os leo muy a menudo, pero me gustaria que el autor del hilo vea mas puntos de vista, opiniones o casos dados.

Yo vengo de 2 FP (si en esa epoca me gustaba XD) y queria empezar con la parte "oculta" de la programacion de los videojuegos, pero a la vez saber mas de los demas campos que puede tener, diseño etc... y por eso me apunte en un posgrado al que accedi viajurado y CV. sorpresa la mia que tenian codigos desactualizados con bastantes errores y que el profesorado sinceramente dejaba mucho que desear, a parte viniendo de hacer Pascal y con pocas nociones de C ++ pues tenia que ponerme a revisar y aprender este lenguaje si o si. Despues de todo el posgrado, he llegado a la conclusion que aunque se hacer algunas pautas "basicas" de la programacion de videojuegos 2D y 3D me falta muchisimo por aprender de programacion, y veo que la parte matematica y fisica influye muchisimo, por eso me decidi a meterme en una carrera, para reciclarme en matematicas y aprender mas de fisicas, ya de paso hacer algo mas de programacion aunque no sea C++ y adquirir mejores metodos de trabajo. Se que no saldre haciendo un juegazo o con el conocimiento para ello pero con un poco de dedicacion al dia y ser bastante cabezon puedo sacar algo claro.

Aun y asi, a dia de hoy me gustaria tocar mas ramas a parte de la programacion, aunque supongo que esto lo tendre que hacer una vez pueda hacer alguna "practica" real en alguna empresa, en francia las hay a montones.

Yo le animo a ir a la uni.

Algo de esto que POR UNA VEZ se celebra en Andorra ^^ creo que es visita obligada ^^

TheCreature, si quereis puedo probar tambien vuestro juego y deciros si hay alguna cosilla que patine.

Es mas podria hablar de vuestro juego por radio ^^

El sistema que usé yo es ligeramente diferente. También calculé el punto de impacto respecto al centro de la raqueta para calcular el ángulo de salida, pero en lugar de dar un ángulo de salida fijo según el punto lo que hice fue sumar o restar a dicho ángulo un valor proporcional al punto de colisión y al ángulo de llegada.

Para hacerte una idea: en un juego tipo Arkanoid si la bola entraba con un ángulo de 80 el ángulo en la salida (en el centro de la raqueta) sería de 100. Cuanto más a la derecha más cerca de 80. Sin embargo, cuanto más a la izquierda más cerca de... 120. Es decir,  lo que yo hacía era tomar la diferencia entre el ángulo de entrada y su espejo (rebote perfecto en el centro) y tomar como límites en la salida el ángulo espejo más la diferencia y el ángulo espejo menos la diferencia (con un mínimo a cada lado, que la bola no puede salir plana o hacia abajo), calculando la salida en función del punto de la raqueta en que golpea.

Creo que estoy viendo por donde van los tiros pero podrias hacer un esquema simple de lo que explicas?

Te lo agradeceria.

nolver si lo pasais a PS3 (ojala) teneis comprador asegurado, lo puedo saborear en Xbox...

Acabo de enviarte 2 reportes mas uno de ellos explicando los modos usados y cuales resultados he obtenido.

Espero que si tienes alguna consulta que hacerme me contactes.

Acabo de ver este hilo y me lo estoy descargando para poder ser de ayuda con la fase beta.

Cualquier cosa me contactais. Si tengo feddbacks os los envio por aqui.

De hecho te mando ya mi primer feedback

Trac, dios, lo estoy usando en mi proyecto y es horriblemente lioso...

Como no lo llegues a consigurar bien, te haras un lio.

hay algo que no cuadra, haceis un juego en 3D del copon y luego te salen dudas sobre como pintar unos corazoncitos? emmm...

Hemos hecho 2D tambien lo que pasa es que ya no lo recuerdo xD

pues yo lo haría mucho más sencillo.

Si como máximo puedes tener 5 corazoncitos tendría un entero de 0 a 500, cada 100 unidades es un corazón lleno.

Y la forma de pintar los corazones con máscaras.

Si quieres tener un array de elementos para algo tan trivial tiene que tener un mótivo bastante fuerte detrás, sino intenta siempre hacerlo lo más simple posible.

Tomare en cuenta este consejo la verdad es que tiene pinta de estar interesante, si veo que no me salgo del problema pues cambiare en vez de corazones pondre un cambio de estado en el retrato, o un contador de % de vida.

Perdona, llevas razon xD,

Estoy escribiendo en C++, os dejo una imagen de lo que estoy preparando, aunque esta muy verde, y aun estamos detallando cosas.

Bueno estoy montando la info de un HUD para un juego plataformas 2.5D con la ayuda de otras personas, y he llegado a un punto que para la vida, es decir los corazones, creo que estaria mejor con un Array ya para el momento en el que se tenga que ir quitando, contando, sumando corazones.

El problema es que ahora mismo no se por donde cogerlo y hacer que por ejemplo ID1 sea corazon lleno, y ID2 corazon vacio.

Si quereis os puedo poner el codigo que uso para todo esto.

Buenas,

Tengo una pequeña consulta con esto porque el tilemapping no me sale, y me gustaria saber como poder implementarlo. Os adjunto los archivos de mi codigo a ver si me podeis hechar una mano con ello.

Se que necesito las sentencias RenderImage(), tengo una estructura TileMap, y el RenderTileMap.

Os dejo tambien el codigo tal como lo he encontrado pero no se por donde tirar.

Código [Seleccionar] Expand

struct TileMap
{
int tile_width, //Ancho y alto de las tiles
tile_height; //(píxeles)
int map_height, //Ancho y alto de todo el mapa
map_width; //(tiles)
int scene_width, //Ancho y alto de la parte visible
scene_height; //por pantalla del mapa (tiles)
int coord_x, //Coordenadas de la parte visible
coord_y; //(píxeles)
Image *images; //Vector de imágenes para cada tile
int **data; //El mapa, la matriz de tiles
};


Creo que  RenderTileMap tiene que ser algo asi:

Código [Seleccionar] Expand

void RenderTileMap( TileMap *map )
{
int tile;
int Xo = map->coord_x / map->tile_width;
int Yo = map->coord_y / map->tile_height;
int Xf = Xo + map->scene_width - 1;
int Yf = Yo + map->scene_height - 1;
int pos_x = 0;
int pos_y = 0;
for(int i=Yo; i<=Yf; i++)
{
for(int j=Xo; j<=Xf; j++)
{
tile = map->data[i][j];
RenderImage(map->images[tile], pos_x, pos_y);
pos_x += map->tile_width;
}
pos_x = 0;
pos_y += map->tile_height;
}
}


Pero el RenderImage como no sea el dibujado que tengo en el Scene.cpp Draw(); sin animacion no se por donde tirar...

os adjunto por aqui el contenido de cada archivo que tengo.

CScene.cpp

Código [Seleccionar] Expand

#include "cScene.h"
//#include <GL/glut.h>

cScene::cScene(void)
{
}

cScene::~cScene(void)
{
}


bool cScene::LoadLevel(int level)
{
bool res;

// load tile based map
//....

// Imagenes
res = img.Load("caba.png", GL_RGBA);
frame_seq = 0;
frame_delay = 0;

return res;
}

//Dibujado
void cScene::Draw()
{
float frame;

frame = (float)frame_seq * 0.25f;
glBindTexture(GL_TEXTURE_2D,img.GetID());
glBegin(GL_QUADS);
glTexCoord2f(frame      ,0.5f); glVertex2i(100          ,100          );
glTexCoord2f(frame+0.25f,0.5f); glVertex2i(100+TILE_SIZE,100          );
glTexCoord2f(frame+0.25f,0.25f); glVertex2i(100+TILE_SIZE,100+TILE_SIZE);
glTexCoord2f(frame      ,0.25f); glVertex2i(100          ,100+TILE_SIZE);
glEnd();

glBegin(GL_QUADS);
glTexCoord2f(frame      ,0.5f); glVertex2i(200          ,200          );
glTexCoord2f(frame+0.25f,0.5f); glVertex2i(200+TILE_SIZE,200          );
glTexCoord2f(frame+0.25f,0.25f); glVertex2i(200+TILE_SIZE,200+TILE_SIZE);
glTexCoord2f(frame      ,0.25f); glVertex2i(200          ,200+TILE_SIZE);
glEnd();

glBegin(GL_QUADS);
glTexCoord2f(frame      ,0.5f); glVertex2i(300          ,300          );
glTexCoord2f(frame+0.25f,0.5f); glVertex2i(300+TILE_SIZE,300          );
glTexCoord2f(frame+0.25f,0.25f); glVertex2i(300+TILE_SIZE,300+TILE_SIZE);
glTexCoord2f(frame      ,0.25f); glVertex2i(300          ,300+TILE_SIZE);
glEnd();


glBegin(GL_QUADS);
glTexCoord2f(frame      ,0.5f); glVertex2i(400          ,400          );
glTexCoord2f(frame+0.25f,0.5f); glVertex2i(400+TILE_SIZE,400          );
glTexCoord2f(frame+0.25f,0.25f); glVertex2i(400+TILE_SIZE,400+TILE_SIZE);
glTexCoord2f(frame      ,0.25f); glVertex2i(400          ,400+TILE_SIZE);
glEnd();
frame_delay++;
if(frame_delay == ANIMATION_DELAY)
{
frame_delay = 0;
frame_seq++;
if(frame_seq == 4) frame_seq = 0;

}

}
int* cScene::GetMap()
{
return map;
}

cScene.h

Código [Seleccionar] Expand

#pragma once
#include "cTexture.h"
#define SCENE_ALTO 64
#define SCENE_ANCHO 64
#define TILE_SIZE 32
#define ANIMATION_DELAY 8

class cScene
{
public:
cScene(void);
virtual ~cScene(void);
// Carga del nivel de la textura en este caso solo 1
bool LoadLevel(int level);
// Accion de dibujado en pantalla
void Draw();

int *GetMap();

private:
int map[SCENE_ALTO*SCENE_ANCHO];

cTexture img;
int frame_seq;
int frame_delay;

};


main.cpp

Código [Seleccionar] Expand

#include <GL/glut.h>
#include "cGame.h"

#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")


cGame Game;


void AppRender()
{
Game.Render();
}
void AppKeyboard(unsigned char key, int x, int y)
{
Game.ReadKeyboard(key,x,y,true);
}
void AppKeyboardUp(unsigned char key, int x, int y)
{
Game.ReadKeyboard(key,x,y,false);
}
void AppSpecialKeys(int key, int x, int y)
{
Game.ReadKeyboard(key,x,y,true);
}
void AppSpecialKeysUp(int key, int x, int y)
{
Game.ReadKeyboard(key,x,y,false);
}
void AppMouse(int button, int state, int x, int y)
{
Game.ReadMouse(button,state,x,y);
}
void AppIdle()
{
if(!Game.Loop()) exit(0);
}

void main(int argc, char** argv)
{
int res_x,res_y,pos_x,pos_y;

//GLUT initialization
glutInit(&argc, argv);

//RGBA with double buffer
glutInitDisplayMode(GLUT_RGBA | GLUT_ALPHA | GLUT_DOUBLE);

//Create centered window
res_x = glutGet(GLUT_SCREEN_WIDTH);
res_y = glutGet(GLUT_SCREEN_HEIGHT);
pos_x = (res_x>>1)-(GAME_WIDTH>>1);
pos_y = (res_y>>1)-(GAME_HEIGHT>>1);

glutInitWindowPosition(pos_x,pos_y);
glutInitWindowSize(GAME_WIDTH,GAME_HEIGHT);
glutCreateWindow("My first game!");

/*glutGameModeString("800x600:32");
glutEnterGameMode();*/

//Make the default cursor disappear
//glutSetCursor(GLUT_CURSOR_NONE);

//Register callback functions
glutDisplayFunc(AppRender);
glutKeyboardFunc(AppKeyboard);
glutKeyboardUpFunc(AppKeyboardUp);
glutSpecialFunc(AppSpecialKeys);
glutSpecialUpFunc(AppSpecialKeysUp);
glutMouseFunc(AppMouse);
glutIdleFunc(AppIdle);

//Game initializations
Game.Init();

//Application loop
glutMainLoop();
}


Gracias y perdonad el tocho.

Buenas,

Estoy decidido a comprarme un libro de C/C++ y en vista que he encontrado un par, me asaltan las dudas sobre la "calidad" de los mismos.

Esperando obtener un poco de consejo sobre cual de ellos es mejor, o mas completo, os dejo las referencias de los libros.

Uno seria este:



" C/C++ CURSO DE PROGRAMACION (3ª ED)
de CEBALLOS, FRANCISCO JAVIER
RA-MA 2007 
     708 pags
Lengua: CASTELLANO
Encuadernación: Tapa blanda
ISBN: 9788478977628
Colección:
Nº Edición:3ª
Año de edición:2007
Plaza edición: MADRID"

Otro seria este:



" ENCICLOPEDIA DEL LENGUAJE C++ (INCLUYE CD)
de CEBALLOS, FRANCISCO JAVIER
RA-MA 2003
19.0x25.0 cm      1120 pags
Lengua: CASTELLANO
Encuadernación: Tapa blanda
ISBN: 9788478975846
Colección:
Nº Edición:1ª
Año de edición:2003
Plaza edición: MADRID"

Son estos dos que mas o menos he estado mirando. Si hubiera alguno mas que tuviera que tener en cuenta decidmelo.

Muchas gracias por adelantado.

Gracias por el anote, creo que empezare a aplicarlo asi sin mas en los mios.

Para el pause hay que llamar a ninguna cabecera en particular no?