Cierto, fallo mio por leer, grabar cds, mover carpetas y escuchar musica al mismo tiempo.

y aunque fueran 3 estudiantes, si son 3 finlandeses que han estudiado informatica, ya tienen las cualidades necesarias para hacer un juego.
aquí se pone en entredicho la gente que en su vida ha picado una linea de codigo y quiere hacer un juego, porque esos no conocen la complejidad del contexto.

A eso me refería. Gracias por la aclaración, que igual yo me expliqué mal ^^

Suerte pues. Todo lo que sirva para aprender algo nuevo siempre es divertido :P

Y de todas formas yo me estaba refiriendo a juegos AAA. Nuestras ideas son tan bonitos en nuestra cabeza... xD

Ya he probado la demo... y mola muchísimo.

Muy buen trabajo chicos, seguro que os va bien ^^

Bienvenido al foro.

Espero que te sirva de ayuda y encuentres todo lo que necesitas ;)

Ya he visto el video y... joder, si todo eso es in-game tiene una pinta increíble. En cuanto pueda va para la colección, que me encantan estos juegos que te sumergen en la ambientación más que ir pegando tiros. Me gusta pasar miedito :P

Yo me refería a "esconder" un poco la geometría de los niveles. Es decir, si el escenario hace tal que _|---|_ pues que sea por ejemplo una roca (con forma rectangular para que no tengáis problemas con las físicas) en lugar del suelo de la cueva que hace esa forma. O poner rocas delante y detrás del plano donde se mueve la criatura. No afectan a como se mueve la criatura por los niveles, pero si le da cierta vida al escenario, no se si me explico.

Tampoco es que me dedique a estas cosas, pero suelo darle vueltas a muchas cosas y me fijo en todas esas tonterías mientras juego (aparte de ponerme a pensar como habrán implementado en código tal o cual cosa...).

Tiene muy buena pinta. Un vídeo ayudaría en la elaboración de halagos xD

Yo tengo bastante con la carrera que no tengo tiempo ni para mis proyectos personales. Siento mucho no poder echaros una mano.

Una pequeña apreciación sobre los niveles... Veo las cuevas demasiado "geométricas". El suelo es muy plano, las paredes muy rectas... Se supone que es una cueva, y dado que las cuevas se forman con las corrientes de agua deberían ser mas sinuosas y no tan rectas. Aparte, se supone que dentro de las cuevas viven todo tipo de bichos, y allá donde hay criatura viviente queda rastro de su paso, ya sean plantas y demás.

No quiero decir que los niveles deban ser un caos, sino que añadáis mas elementos decorativos, desniveles, rampas, rocas por aquí, por allí, si hay un precipicio sea por algo (quizás una corriente de agua ha sido la que ha escavado la tierra hasta formar ese precipicio y al fondo puede verse), ese tipo de cosas. Es un plataformas porque tienes que ir saltando, esquivando, recorriendo el terreno... no que la cueva sea así porque es un juego de plataformas. No se si me explico :(

Y no lo tomes a mal, pretendo que sea una critica constructiva.

No es que por aquí sean negativos, sino realistas.

Mucha gente cree que hacer videojuegos lo puede hacer cualquiera y que con ganas todo se hace... y no es del todo así. Que me digan a mi cuantas matrices, transformaciones y mil cosas más tuve que aprender, calcular e implementar en mi librería 3D para poder mostrar un puñetero cubo en OpenGL...

Un ejemplillo así tonto sacado de una practica de la carrera al azar.

Fichero .h

Código [Seleccionar] Expand

#ifndef ARCHIVOS_H_
#define ARCHIVOS_H_

int almacena_piezas(tpieza *p,int tam,char *ruta);
int recupera_piezas1(char *ruta,tpieza *p,int tam);
int numero_piezas_archivo(char *ruta);
tpieza* recupera_piezas2(char *ruta,int *plongitud);
int concatena_piezas_archivo(tpieza *p,int tam,char *ruta);



#endif /* ARCHIVOS_H_ */

Fichero .c

Código [Seleccionar] Expand

#include "pieza.h"
#include <stdio.h>
#include <stdlib.h>
/*
* @brief Guarda en un fichero binario el vector pasado
* @param p Vector a guardar
* @param tam Tamaño del vector
* @param ruta Ruta donde guardar el archivo
* @return Devuelve el numero de elementos guardados o 0 si error
*/
int almacena_piezas(tpieza *p,int tam,char *ruta)
{
int numPiezas;

FILE *file;

file=fopen(ruta,"wb");

if(file==NULL)
{
numPiezas=0;
}else
{
numPiezas=fwrite(p,sizeof(tpieza),tam,file);

if(numPiezas!=tam)
{
numPiezas=0;
}
}

fclose(file);

return numPiezas;
}

/*
* @brief Carga piezas desde un archivo
* @param ruta Ruta donde se encuentra el archivo con los datos
* @param p Vector donde almacenar los elementos cargados
* @param tam Tamaño del vector y numero de elementos que cargaremos desde el archivo
* @return Devuelve el numero de elementos leidos o 0 si hubo error
*/
int recupera_piezas1(char *ruta,tpieza *p,int tam)
{
int numPiezas;
FILE *file;

file=fopen(ruta,"rb");

if(file==NULL)
{
numPiezas=0;
}else
{
numPiezas=fread(p,sizeof(tpieza),tam,file);

if(numPiezas!=tam)
{
numPiezas=0;
}
}

fclose(file);

return numPiezas;
}

/*
* @brief Calcula el numero de elementos pieza que tiene un archivo
* @param ruta Ruta donde se encuentra el archivo
* @return Devuelve el numero de piezas contenidas en el archivo
*/
int numero_piezas_archivo(char *ruta)
{
int num;

FILE *file;

if((file=fopen(ruta,"rb"))==NULL)
{
fprintf(stderr,"\nnumPiezasArchivo:error al abrir el archivo");
}else
{
fseek(file,0,SEEK_END);

num=(int)ftell(file)/sizeof(tpieza);
}

fclose(file);

return num;
}

/*
* @brief Carga todos los clientes de un archivo
* @param ruta Ruta donde se encuentra el archivo con la informacion
* @param plongitud Numero de elementos que tendra el vector (y por tanto que hay en el archivo)
* @return Devuelve un vector con los elementos del archivo
* @post Modifica plongitud con el numero de elementos que hay en el vector
*/
tpieza* recupera_piezas2(char *ruta,int *plongitud)
{
tpieza *nuevo;
int error;
FILE *file;

(*plongitud)=numero_piezas_archivo(ruta);

if((nuevo=(tpieza*)malloc(sizeof(tpieza)*(*plongitud)))==NULL)
{
fprintf(stderr,"\nrecuperaPiezas2:no hay memoria.\n");
}

if((file=fopen(ruta,"rb"))==NULL)
{
fprintf(stderr,"recuperaPiezas2:error al abrir el archivo.\n");
}else
{
if(fread(nuevo,sizeof(tpieza),(*plongitud),file)!=(*plongitud))
{
error=ferror(file);
if(error)
{
//fprintf(stderr,"\n%s\n",strerror(error));
nuevo=NULL;
}
}
}

fclose(file);


return nuevo;
}

/*
* @brief Inserta al final del archivo todos los elementos de un vector
* @param p Vector con las piezas a guardar en el archivo
* @param tam Tamaño del vector
* @param ruta Ruta donde se encuentra el archivo donde se guardara la informacion
* @return Devuelve el numero de elementos guardados
*/
int concatena_piezas_archivo(tpieza *p,int tam,char *ruta)
{
int numPiezas;
FILE *file;

if((file=fopen(ruta,"wb"))==NULL)
{
fprintf(stderr,"\nconcatenaPiezasArchivo:no se pudo abrir el archivo.\n");
}else
{
fseek(file,0,SEEK_END);
numPiezas=fwrite(p,sizeof(tpieza),tam,file);

if(numPiezas!=tam)
{
fprintf(stderr,"\nconcatenaPiezasArchivo:error al escribir en el archivo.\n");
numPiezas=0;
}
}

return numPiezas;
}


Luego ya puedes tener otro fichero main.c (por poner un nombre) con tu función main. Con incluir el archivo de cabecera .h tendras disponibles las funciones que has declarado.

Piensa en ello como si fueran en parejas. fichero.c y fichero.h. El fichero.c declaras tus funciones, como funcionan y lo que hacen, es los engranajes por así decirlo. En el .h pones solo la cabecera de cada función que quieras que este accesible desde fuera cuando hagas un #include . Lo suyo es que también declares aquí los tipos y estructuras para tenerlos también disponibles donde hagas un #include.

Espero haberme explicado.

Currazo que se habrán dado portando el UE3 al iPhone.

Pinta genial y al menos ya le he encontrado una utilidad a un iPad xD

Dios no... estoy estudiando una asignatura sobre esto (Organización y gestión empresarial) de la carrera y vengo aquí para desconectar para encontrarme esto xDDDDD

Al hilo del tema, ten cuidado con la forma jurídica porque como dicen más arriba, en el caso de deudas iran a por tu patrimonio personal. En el caso de la S.L. se limita al capital de la empresa (osease, los 3005,06€ mínimos para la creación de la sociedad más el capital que haya ganado esta).

Quizás lo mejor seria tener preparado un proyecto como "carta de presentación" y después montar la empresa propiamente dicha. Recuerda que no hace falta más de una persona para hacer un Braid ^^

Voy a rebuscar entre mis practicas de MTP II por si te puede ser de ayuda.

La filosfia es bastante sencilla. Buscas hacia un lado mientras no encuentres un muro mediante llamadas recursivas. Si no es por ahi, buscas hacia otro lado, y asi en las cuatro direcciones (arriba, izquierda, abajo, derecha).

Sobre algoritmos mas avanzadas no puedo ayudarte porque no entiendo del tema aunque implementar uno mismo las cosas siempre ayuda a entenderlas mejor como dicen por ahi.

EDIT:
Lo encontre, aunque ya te digo que es de hace mucho tiempo y no se como andará...

Código [Seleccionar] Expand

int buscarSalidaLaberinto(int** laberinto,int nColumnas,int nFilas,int x,int y)
{
  if(x<0 || y<0 || x==nFilas || y==nFilas)    //Si x o y están fuera del vector
    {
      return 0;     //La salida no está por aquí
    }else
      {
      switch(laberinto[x][y])
      {
        case SALIDA:

          fprintf(stdout,"\nSalida del laberinto en (%d,%d)",x,y);
          fflush(stdout);

          break;

        case ENTRADA:
        case PASILLO:
          laberinto[x][y] = 2;  //Lo marcamos como visitado
          //Buscamos hacia arriba
          if(buscarSalidaLaberinto(laberinto,nColumnas,nFilas,x,y-1)==0)//Si no lo encuentra hacia arriba
            {
              //Buscamos hacia la derecha
              if(buscarSalidaLaberinto(laberinto,nColumnas,nFilas,x+1,y)==0)//Si no lo encuentra hacia la derecha
                {
                  //Buscamos hacia abajo
                  if(buscarSalidaLaberinto(laberinto,nColumnas,nFilas,x,y+1)==0)//Si no lo encuentra hacia abajo
                    {
                      //Buscamos hacia la izquierda
                      if(buscarSalidaLaberinto(laberinto,nColumnas,nFilas,x-1,y)==0)//Si no lo encontramos hacia la izquierda
                        {
                          return 0; //Por aqui no está la salida
                        }
                    }
                }
            }
          laberinto[x][y]=0;
          break;

        case PARED:
return 0;
        case VISITADO:
          return 0;

      }
      }
}