Entiendo,
La idea al principio era de cargarlas todas. Ya que imágenes de 250x250 tampoco ocupan mucho.
Pero ya pensando con la idea de en un futuro tener que evolucionar el juego, las 1,000 imágenes pasarían en algún momento a ser 10,000 o así. Y entonces tendría que buscar otra alternativa.

Haré como lo dices, que al final es como lo había implementado al principio

Hola a todos!
Se me plantea una duda y no se como encarar esto.

Pongamos que:
- Tenemos un juego para móvil (Al final el destino es lo de menos, ya que quiero que sea optimo).
- El juego contiene por decir un número 1,000 imágenes.
- Estas imágenes se dividen en grupos de 100. ( O sea, suelen mostrarse 100 imágenes como mucho a la vez, y segun el bloque en el que estemos son unas u otras).
- Hay un punto del juego, que puede ser que se muestren todas las imágenes a la vez(Aunque puedo poner cierto "bloque" para no tener que cargarlas todas).

Opciones:
A) Cargar desde el principio todas las imágenes en memoria y así solo tener que dirigirme a su ruta cuando las necesite.

B) Solo ir cargando en memoria las fotos que necesite, liberando la memoria de las imágenes que ya no necesite.

C) Ir cargando las imágenes que voy utilizando en memoria, y cuando tenga que cargar nuevas imágenes, las anteriores no las libero y las sigo manteniendo en memoria.

Gracias

Hola, primero desearos Felices fiestas.
Segundo, si, hace mil que no me pasaba por el canal.
Tercero, intenté seguir un poco el pronostico que comenté hace tiempo. Hacer porfolio, buscar trabajo, y finalmente tratar de montarme mi propia "empresa".

Bueno estoy en el 3r punto sin mucho éxito, supongo que en breves me tocará buscarme curro y tal jaja. Pero no he venido aquí a quejarme.

Abro el hilo para haceros saber el último proyecto que he desarrollado en solitario. (Los assets me los hizo un artista que contraté).

Es un juego para Android al más estilo "Cut The Rope" o "Tiger Ball". Aunque como ya vereis tiene una clara y diferente variante haciendo muy único.

Se trata de hacer lineas con el dedo simulando "telarañas" para ayudar a Willow que es una pequeña y amigable araña a llegar a su hogar, haciendola rebotar en las paredes. (Es una pelota  hablando claro).

Tiene muy buenas criticas y en general ha gustado, el problema que no logro tener una retención de publico.
Os dejo el link del trailer:
https://youtu.be/AKrCFUlImZ8



LINK:

https://play.google.com/store/apps/details?id=com.gurosoft.FeedTheWillow

Saludos!
Estoy trabajando en mi proyecto personal y quería crear un buen mediation de adds para reciclar en mi siguientes proyectos, el caso es que voy PERDIDISIMO!.

Me voy a explicar:

Me he registrado en diferentes redes de publicidad para utilizar en Android desde Unity.
Lo de registrarme en diferentes redes es para luego poder gestionar que ads me dan más cantidad de dinero para poder mostrar :P

Estoy en Addmob, Appodeal, Startapp, Revmob, UnityAds.

EL caso es que no tengo ni idea de como controlar la petición de publicidad y saber decidir cual es la mejor.

Por lo que he leído esto lo suelen gestionar las propias empresas... como por ejemplo Elegir Appodeal con Addmob, y Appodeal ya gestiona el mediation para decidir cual es el mejor ads para enseñar.

Tengo unas dudas, en este caso

1r) Entonces en Unity solo debo tener el SDK de Appodeal. (En su Manifest ya tiene las referencias a un montón de redes publicitarias).

2n) Solo muestro adds desde los codigos de Appodeal?

3r) Desde la web de Appodeal activo y linkeo mis otras cuentas con Appodeal (o las que pueda) Addmob seguro.

4rt) Conectándolas, el dinero ingresado siempre se va a ver desde Appodeal? o la parte ganado por Addmob, la veré desde su web Addmob?

Como veis, estoy hecho un lio! He buscado mucho por internet sobre como gestionar la mediation de Adds y no hay manera de encontrar nada que me de una visión de como tengo que hacerlo.

PD: Tenia intención de poner Banners, Interstitial, videos. y Splash Banner.(Pero esto no es relevante).


Mil Gracias!

Hola chicos y chicas!
Acabo de publicar mi 2n juego para Android que tengo la esperanza que fluya un poco mejor que el 1r.

Os dejo el enlace del juego, y miraos si queréis el trailer que son 30 segundos y es bastante divertido (pero simple) jaja
Cuidaos.
Ah si lo descargais y echais unas partidas no me va a molestar eh :P

https://play.google.com/store/apps/details?id=com.gurosoft.haters

Buenos he estado indagando por mi cuenta y me gustaría que me recomendarais vosotros que soys más expertos.
Ahora como he dicho estoy utilizando Addmod y UnnityAdds.

He dado con  Chartboost , LeadBolt y Revmod.
La verdad es que de estos 3 he encontrado información muy vieja y no sabría deducir si son buenas empresas de publicidad o si quedarme con Addmod.
Qué me deciis vosotros?

Hola buenas de nuevo, recientemente he publicado 2 pequeños juegos para Android a la Google play y viendo los acontecimientos me han entrado muchas dudas.

Los juegos los he hecho en Unity.

Veréis para generar ingresos utilizo tanto UnityAdds para Videos como Addmod para la publicidad estandar.

En unityAdd: Con 10 impresiones totales  me ha generado 0 beneficios.

En addmod: Solo genera beneficios por click al anuncio..no por visualizar.

Mi pregunta es...como lo hacen las empresas para generar beneficios si son publicidad por click? como lo hizo Flappy Birds? Porque dudo que la gente pulsara en su publicidad.

O No lo hago bien y a parte de UnityAdd y Addmod existe otra herramienta que da beneficiones por impresiones y no por click? porque me gustaría saberlo

Gracias!

Hola a todos después de muuuuucho tiempo!

Acabo de finalizar uno de mis proyectos para Android que se trata de un juego de Billar muy completo. Tiene diferentes modos de juego (bola8, clásico español, 3 bandas, snooker).

Ademas tiene una buena inteligencia artificial y modo campeonato.

Os animo a que lo probéis! aunque sea para que me deis unas cuantas descargas!

Mil gracias!

https://play.google.com/store/apps/details?id=com.gurosoft.billar

Por si alguien quiere verlo o simplemente aprovechar el codigo, os dejoel codigo del algoritmo hecho con algunas pruebas, en c++
Es largo porque las creaciones de los mapas estan hechas manualmente xD

PD. un grafo de tamaño 40*36 tarda 0,2 segundos en resolverlo.....muy muy lento

Código [Seleccionar] Expand


#include <iostream>
#include <vector>
#include <cstdlib>
#include <iostream>
#include <algorithm>    // std::sort
#include <stdlib.h>
using namespace std;
///0 camino, 1 inacesible, heroe se pone a 5.
/*#define tamX 6//3//6
#define tamY 5//3//5
#define tileX 1////3
#define tileY 2//2//3
*/
/*///mapa1, inici:2-2, fin 2-5
///3*4= 8-6, 8-15
#define tamX 7//3//6
#define tamY 5//3//5
#define tileX 3////3
#define tileY 4//2//3
*/

/*///mapa2, inici 3-1, fin 1-3
///3*4 12-3,   4-9
#define tamX 6//3//6
#define tamY 5//3//5
#define tileX 3////3
#define tileY 4//2//3
*/
///mapa3, el completo
///i 0-0,   9-11, 3*4= 0,0,, 36-33
#define tamX 12//3//6
#define tamY 10//3//5
#define tileX 3////3
#define tileY 4//2//3
struct vertice{
    int posx;///la posicion que ocupa en la matriz
    int posy;
    int valor;
    int pos=-1;///la posicion que ocupa en la array <0,0>=0; <0,1>1, 0,2=2 etc...
    vector<int>adjy;///
    vector<int>adjx;///
    vector<int>adj;///con posiciones direcamtne
    int g=10;
    int f=-1;
    int padrex=-1;///para saber la ruta
    int padrey=-1;
    int padre=-1;
    ///hijo, lo mismo ke el padre pero al reves
    int hijox=-1;
    int hijoy=-1;
    int hijo=-1;

    bool visitado=false;
    ///es la 1r posicion de cada celda del grafo " si cada tile ocupa...3 celdas del grafo pues apuntara
    ///a la 1r celda ke es arriba izkierda
    int maty;
    int matx;
};
struct comparador {///operador para realizar las modificaciones de ordenadcion de mi vector
  bool operator() (vertice i,vertice j) { return (i.f>j.f);}
} mayorF;


int mapa[tamY][tamX];///dimensiones del mapa 6x, 5y
   vertice grafo[tamY*tileY][tamX*tileX];///cada tile del mapa son *10 pixeles
void llenar();
void mapa1();
void mapa2();
void mapa3();
void llenargrafo();
void imprimir();
void ponerAdj();
void saberAdj();
void saberpos();
void BuscarCamino(int,int,int,int);///meto las posiciones "0,0" de las celdas del grafo de los tiles.
void imprimirpos();
int main()
{
   mapa3();
    llenargrafo();
    ponerAdj();
    imprimir();
    BuscarCamino(0,0,36,33);
  imprimir();
    return 0;
}
void BuscarCamino(int iy,int ix, int fy, int fx)
{
     vertice inici=grafo[iy][ix];
     vertice fin=grafo[fy][fx];
     vector<vertice> cola;
///lo ke hace es... si son 2 pixeles a mirar en x, y 3 en y "el tamaño tile es 2x3
            ///pues cuando alla 2 x conb misma posicion entonces metelo sino no...
            /// i se mete en la cola
            vector<vertice>vistox;
            vector<vertice>vistoy;
            int contx=0;
            int conty=0;

     cola.push_back(inici);

    //back es 1r valor, pop es kitarlo
   while (cola.size()>0)///mientras hay elementos
     {
        vertice v=cola.back();

        cola.pop_back();
        if(!v.visitado)
        {
           vistox.clear();
           vistoy.clear();
           contx=0;
           conty=0;

            grafo[v.maty][v.matx].visitado=true;///se mira el visitado de la 1r casilla
            if(v.pos!=fin.pos)///sino hemos llegado
            {
                for(int y1=v.maty; y1<v.maty+tileY; y1++)///recorremos las celdas ke tiene cada "tile grande" en el grafo
                {
                    for(int x1=v.matx; x1<v.matx+tileX; x1++)
                    {
                        for(int i=0; i<grafo[y1][x1].adj.size(); i++)///recorremos todos los adj de cada punto
                        {

                            int vy,vx;///guardo las posiciones asi para que no alla tanto lio,
                            ///quiero la 0,0 de cada tile.
                            vy=grafo[y1][x1].adjy[i];
                            vx=grafo[y1][x1].adjx[i];
                            int ay,ax;
                            ay=grafo[vy][vx].maty;
                            ax=grafo[vy][vx].matx;

                            vertice vadj=grafo[ay][ax];///adj de cada posicion
                            if(!vadj.visitado and vadj.pos!=v.pos)///si esta visitado pake verlo,ke su adj sea diferente a el mismo
                            {
                                int peso=v.g+(abs(vadj.posy-fin.posy)+abs(vadj.posx-fin.posy));
                                ///si tiene mismo padre...esque es una continuacion del tile, sumalo!
                                if(peso<vadj.f or vadj.f==-1 or vadj.padre==v.pos)///si el peso es menor o aun no se a iniciado "-1" metelo
                                {
                                    if(vadj.padre!=v.pos)///si no son mismo padre az como siemrpre.
                                    {
                                        vadj.padre=v.pos;///assignamos el padre de los adj como su padre su posicion
                                        vadj.padrey=v.posy;
                                        vadj.padrex=v.posx;
                                        vadj.f=peso;
                                        vadj.g=vadj.g+v.g;///se le suma
                                        cout<<"padre "<<vadj.padre<<" yo "<<vadj.pos<<endl;
                                    }
                                    else
                                    {
                                        vadj.f+=peso;///le sumamos mas el peso, la g se mantiene.
                                    }
                                    /// cout<< vadj.f<<" vady "<<vadj.posy<<" x "<<vadj.posx<< " finy "<< fin.posy <<" x "<<fin.posx <<endl;
                                    grafo[ay][ax]=vadj;///se iwala para ke coja todas las referencias, es pa trbaajr mas comodo
                                    if(v.posy!=vadj.posy)///kiere decir ke estmaos mirando adj arriba /abajo
                                    {
                                        vistoy.push_back(vadj);
                                        for(int i=0; i<vistoy.size(); i++)
                                        {
                                            if(vistoy[i].pos==vadj.pos)///si hay n=tile de los añadidmos, bien se puede ir
                                            {
                                                conty++;
                                            }
                                        }
                                        if(conty>=tileX)cola.push_back(vadj);
                                        conty=0;
                                    }
                                    else if(v.posx!=vadj.posx)///kiere decir ke estmaos mirando adj arriba /abajo
                                    {
                                        vistox.push_back(vadj);
                                        for(int i=0; i<vistox.size(); i++)
                                        {
                                            if(vistox[i].pos==vadj.pos)///si hay n=tile de los añadidmos, bien se puede ir
                                            {
                                                contx++;
                                            }
                                        }
                                        if(contx>=tileY)cola.push_back(vadj);
                                        contx=0;
                                    }

                                    std::sort (cola.begin(), cola.end(), mayorF);///ordenamos la array apra sacar el menor F
                               }
                            }
                        }


                    }
                }

            }
        }

     }
///padre

    vertice ruta=grafo[1][3];
     ruta=grafo[36][33];
cout<<"camino "<< ruta.pos<<endl;
    while (ruta.padrey!=-1)///x o y es lo mismo!
    {
        cout<<ruta.pos<<endl;
        //grafo[ruta.padrey][ruta.padrex].valor=3;
        grafo[ruta.padrey][ruta.padrex].hijo=ruta.pos;
         grafo[ruta.padrey][ruta.padrex].hijoy=ruta.posy;
          grafo[ruta.padrey][ruta.padrex].hijox=ruta.posx;
        ruta=grafo[ruta.padrey][ruta.padrex];


    }
    ruta=grafo[0][0];
cout<<"camino "<< ruta.hijo<<endl;
   while (ruta.hijo!=-1)///x o y es lo mismo!
    {
        cout<<ruta.pos<<endl;
        for(int y1=ruta.maty; y1<ruta.maty+tileY; y1++)///recorremos las celdas ke tiene cada "tile grande" en el grafo
                {
                    for(int x1=ruta.matx; x1<ruta.matx+tileX; x1++)
                    {
        //grafo[ruta.hijoy][ruta.hijox].valor=3;
        grafo[y1][x1].valor=3;

                    }
                    }
                    ruta=grafo[ruta.hijoy][ruta.hijox];
    }
}


void saberpos()
{
    for(int y1=0; y1<tamY*tileY; y1++){
        for(int x1=0; x1<tamX*tileX; x1++){
                cout<<grafo[y1][x1].pos<<" "<<endl;
        }
        cout<<endl;
    }

}
void ponerAdj()
{
     for(int y=0; y<tamY; y++){
        for(int x=0; x<tamX; x++){

        if(mapa[y][x]!=1)///no es pared solida
            {  // cout<<" estat "<<y<<" "<<x<<endl;
                for(int y1=y*tileY; y1<y*tileY+tileY; y1++){
                    for(int x1=x*tileX; x1<x*tileX+tileX; x1++){
                           // cout<<"grafo y-x "<<y1<<" "<<x1<<endl;
                       ///miramos las 4 posiciones para meterlas
                       if(grafo[y1][x1-1].valor!=1 and x1-1>=0)///su izkierda
                       {  //  cout<<"entra iz "<<x1-1<< "adj a pos "<<grafo[y1][x1-1].pos<<endl;
                            grafo[y1][x1].adj.push_back(grafo[y1][x1-1].pos);
                           grafo[y1][x1].adjy.push_back(y1);
                           grafo[y1][x1].adjx.push_back(x1-1);
                       }
                       if(grafo[y1][x1+1].valor!=1 and x1+1<tamX*tileX)///derecha
                       {//cout<<"entra de "<<x1+1<< "adj a pos "<<grafo[y1][x1+1].pos<<endl;
                           grafo[y1][x1].adj.push_back(grafo[y1][x1+1].pos);
                           grafo[y1][x1].adjy.push_back(y1);
                           grafo[y1][x1].adjx.push_back(x1+1);
                       }
                       if(grafo[y1-1][x1].valor!=1 and y1-1>=0)///arriba
                       {//cout<<"entra arr "<<y1-1<< "adj a pos "<<grafo[y1-1][x1].pos<<endl;
                           grafo[y1][x1].adj.push_back(grafo[y1-1][x1].pos);
                           grafo[y1][x1].adjy.push_back(y1-1);
                           grafo[y1][x1].adjx.push_back(x1);
                       }
                       if(grafo[y1+1][x1].valor!=1 and y1+1<tamY*tileY)///abajo
                       {//cout<<"entra ab "<<y1+1<< "adj a pos "<<grafo[y1+1][x1].pos<<endl;
                           grafo[y1][x1].adj.push_back(grafo[y1+1][x1].pos);
                           grafo[y1][x1].adjy.push_back(y1+1);
                           grafo[y1][x1].adjx.push_back(x1);
                       }
                    }
                }

            }



        }

    }

}
void saberAdj()
{
   for(int y1=0; y1<tamY*tileY; y1++){
        for(int x1=0; x1<tamX*tileX; x1++){
                for(int i=0; i<grafo[y1][x1].adj.size();i++)cout<<" pos y "<<y1<<" "<<x1 <<" = "<<grafo[y1][x1].adj[i]<<endl;
                 //for(int i=0; i<grafo[y1][x1].adjy.size();i++)cout<<" pos y "<<y1<<" "<<x1 <<" = "<<grafo[y1][x1].adjy[i]<<endl;
                 //for(int i=0; i<grafo[y1][x1].adjx.size();i++)cout<<" pos x "<<y1<<" "<<x1 <<" = "<<grafo[y1][x1].adjx[i]<<endl;
                }
    }

}

void imprimir()
{
    for(int y=0; y<tamY; y++){
        for(int x=0; x<tamX; x++) cout<<mapa[y][x]<<" ";
    cout<<endl;
    }

    cout<<endl;
    for(int y1=0; y1<tamY*tileY; y1++){
                for(int x1=0; x1<tamX*tileX; x1++){
                    cout<<grafo[y1][x1].valor<<" ";
                }
                cout<<endl;
            }
}
void imprimirpos()
{

    cout<<endl;
    for(int y1=0; y1<tamY*tileY; y1++){
                for(int x1=0; x1<tamX*tileX; x1++){
                    cout<<grafo[y1][x1].pos<<" ";
                }
                cout<<endl;
            }
}
void llenargrafo()
{   int n=0;
    for(int y=0; y<tamY; y++){
        for(int x=0; x<tamX; x++){
            for(int y1=y*tileY; y1<y*tileY+tileY; y1++){
                for(int x1=x*tileX; x1<x*tileX+tileX; x1++){
                    grafo[y1][x1].pos=n;
                    grafo[y1][x1].valor=mapa[y][x];
                    grafo[y1][x1].posx=x1;
                    grafo[y1][x1].posy=y1;
                    grafo[y1][x1].maty=y*tileY;
                    grafo[y1][x1].matx=x*tileX;

                }
            }
            n++;
        }

    }

}
void llenar()
{
    /* mapa[0][0]=5;
    mapa[0][1]=0;
    mapa[0][2]=0;

    mapa[1][0]=0;
    mapa[1][1]=1;
    mapa[1][2]=0;

    mapa[2][0]=0;
    mapa[2][1]=1;
    mapa[2][2]=6;
    */
    /*mapa[0][0]=0;
    mapa[0][1]=1;
    mapa[1][0]=0;
    mapa[1][1]=1;
    */
    mapa[0][0]=5;//5
    mapa[0][1]=0;
    mapa[0][2]=1;
    mapa[0][3]=1;
    mapa[0][4]=0;
    mapa[0][5]=1;

    mapa[1][0]=1;
    mapa[1][1]=0;
    mapa[1][2]=0;
    mapa[1][3]=0;
    mapa[1][4]=0;
    mapa[1][5]=1;

    mapa[2][0]=0;
    mapa[2][1]=0;
    mapa[2][2]=1;
    mapa[2][3]=1;
    mapa[2][4]=0;
    mapa[2][5]=0;

     mapa[3][0]=0;
    mapa[3][1]=1;///SSSSSS
    mapa[3][2]=1;
    mapa[3][3]=1;
    mapa[3][4]=1;
    mapa[3][5]=0;

     mapa[4][0]=0;
    mapa[4][1]=0;
    mapa[4][2]=0;
    mapa[4][3]=0;
    mapa[4][4]=6;
    mapa[4][5]=0;


}
void mapa1()
{

    mapa[0][0]=0;//5
    mapa[0][1]=0;
    mapa[0][2]=0;
    mapa[0][3]=0;
    mapa[0][4]=0;
    mapa[0][5]=0;
    mapa[0][6]=0;

    mapa[1][0]=0;
    mapa[1][1]=0;
    mapa[1][2]=0;
    mapa[1][3]=1;
    mapa[1][4]=0;
    mapa[1][5]=0;
    mapa[1][6]=0;

    mapa[2][0]=0;
    mapa[2][1]=0;
    mapa[2][2]=5;
    mapa[2][3]=1;
    mapa[2][4]=0;
    mapa[2][5]=6;
    mapa[2][6]=0;

    mapa[3][0]=0;
    mapa[3][1]=0;///SSSSSS
    mapa[3][2]=0;
    mapa[3][3]=1;
    mapa[3][4]=0;
    mapa[3][5]=0;
    mapa[3][6]=0;

     mapa[4][0]=0;
    mapa[4][1]=0;
    mapa[4][2]=0;
    mapa[4][3]=0;
    mapa[4][4]=0;
    mapa[4][5]=0;
    mapa[4][6]=0;

    mapa[5][0]=0;
    mapa[5][1]=0;
    mapa[5][2]=0;
    mapa[5][3]=0;
    mapa[5][4]=0;
    mapa[5][5]=0;
    mapa[5][6]=0;

}
void mapa2()
{

    mapa[0][0]=0;//5
    mapa[0][1]=0;
    mapa[0][2]=0;
    mapa[0][3]=0;
    mapa[0][4]=0;
    mapa[0][5]=0;


    mapa[1][0]=0;
    mapa[1][1]=0;
    mapa[1][2]=0;
    mapa[1][3]=6;
    mapa[1][4]=0;
    mapa[1][5]=0;


    mapa[2][0]=0;
    mapa[2][1]=1;
    mapa[2][2]=1;
    mapa[2][3]=1;
    mapa[2][4]=0;
    mapa[2][5]=0;


    mapa[3][0]=0;
    mapa[3][1]=5;///SSSSSS
    mapa[3][2]=0;
    mapa[3][3]=1;
    mapa[3][4]=0;
    mapa[3][5]=0;


     mapa[4][0]=0;
    mapa[4][1]=0;
    mapa[4][2]=0;
    mapa[4][3]=0;
    mapa[4][4]=0;
    mapa[4][5]=0;


}
void mapa3()
{

    mapa[0][0]=5;//5
    mapa[0][1]=0;
    mapa[0][2]=0;
    mapa[0][3]=0;
    mapa[0][4]=0;
    mapa[0][5]=1;
    mapa[0][6]=1;
    mapa[0][7]=1;
    mapa[0][8]=0;
    mapa[0][9]=0;
    mapa[0][10]=0;
    mapa[0][11]=0;

    mapa[1][0]=1;//5
    mapa[1][1]=0;
    mapa[1][2]=1;
    mapa[1][3]=1;
    mapa[1][4]=0;
    mapa[1][5]=1;
    mapa[1][6]=0;
    mapa[1][7]=0;
    mapa[1][8]=0;
    mapa[1][9]=1;
    mapa[1][10]=1;
    mapa[1][11]=0;

     mapa[2][0]=1;//5
    mapa[2][1]=0;
    mapa[2][2]=1;
    mapa[2][3]=0;
    mapa[2][4]=1;
    mapa[2][5]=0;
    mapa[2][6]=0;
    mapa[2][7]=0;
    mapa[2][8]=1;
    mapa[2][9]=1;
    mapa[2][10]=0;
    mapa[2][11]=0;

     mapa[3][0]=1;//5
    mapa[3][1]=0;
    mapa[3][2]=1;
    mapa[3][3]=0;
    mapa[3][4]=0;
    mapa[3][5]=0;
    mapa[3][6]=1;
    mapa[3][7]=0;
    mapa[3][8]=0;
    mapa[3][9]=1;
    mapa[3][10]=0;
    mapa[3][11]=1;

     mapa[4][0]=0;//5
    mapa[4][1]=0;
    mapa[4][2]=1;
    mapa[4][3]=1;
    mapa[4][4]=0;
    mapa[4][5]=0;
    mapa[4][6]=1;
    mapa[4][7]=0;
    mapa[4][8]=0;
    mapa[4][9]=1;
    mapa[4][10]=0;
    mapa[4][11]=0;

     mapa[5][0]=0;//5
    mapa[5][1]=1;
    mapa[5][2]=1;
    mapa[5][3]=0;
    mapa[5][4]=0;
    mapa[5][5]=1;
    mapa[5][6]=1;
    mapa[5][7]=1;
    mapa[5][8]=1;
    mapa[5][9]=0;
    mapa[5][10]=1;
    mapa[5][11]=0;

     mapa[6][0]=0;//5
    mapa[6][1]=0;
    mapa[6][2]=0;
    mapa[6][3]=0;
    mapa[6][4]=1;
    mapa[6][5]=0;
    mapa[6][6]=0;
    mapa[6][7]=0;
    mapa[6][8]=0;
    mapa[6][9]=0;
    mapa[6][10]=0;
    mapa[6][11]=0;

     mapa[7][0]=0;//5
    mapa[7][1]=0;
    mapa[7][2]=1;
    mapa[7][3]=0;
    mapa[7][4]=1;
    mapa[7][5]=0;
    mapa[7][6]=1;
    mapa[7][7]=0;
    mapa[7][8]=1;
    mapa[7][9]=1;
    mapa[7][10]=1;
    mapa[7][11]=1;

     mapa[8][0]=1;//5
    mapa[8][1]=0;
    mapa[8][2]=0;
    mapa[8][3]=0;
    mapa[8][4]=1;
    mapa[8][5]=0;
    mapa[8][6]=0;
    mapa[8][7]=1;
    mapa[8][8]=0;
    mapa[8][9]=0;
    mapa[8][10]=0;
    mapa[8][11]=0;

     mapa[9][0]=1;//5
    mapa[9][1]=0;
    mapa[9][2]=1;
    mapa[9][3]=0;
    mapa[9][4]=1;
    mapa[9][5]=0;
    mapa[9][6]=0;
    mapa[9][7]=0;
    mapa[9][8]=0;
    mapa[9][9]=0;
    mapa[9][10]=1;
    mapa[9][11]=6;




}






Lo hago pixel x pixel porque:

El mapa cada celda ocupa por ejemplo 20x20 pixeles, todos los objetos del mapa, la parte que tocan el suelo ocupan 20x20 tambien.

Que sucede, pues el movimiento es de 2 en 2, osea en una misma celda pueden estar mas de 1 objeto, y esto a la hora de moverse usando un grafo es un problema, entonces he reducido los tamaños de las celdas a 1x1 para resolver ese problema. no?:s

Si era mi idea...lo estoy programando haciendo que salgan diferentes hilos por cada calculo.. buffaunque es un algoritmo lentito
porque mi mapa cada celda ocupa el tamaño de un tile 96x48, pero el mapa del grafo es pixel por pixel, y al tener un mapa de scroll el tamaño es enorme

Aunque hare las rutas localmente por la parte que se imprimen en pantalla...aun asi es costoso

mexi!

Hola buenas, me ha tocado hacer la IA en un proyecto y la verdad es que investigando voy a implementar para su movimiento un pathfinding, aunque tengo varias dudas:

El juego es un estilo de los enemigos van hacia a ti a atacarte, teniendo de esquivar obstáculos que hay en el mapa y a los propios otros enemigos, asta aquí bien el problema viene:

Tengo casi implementado el algoritmo para desde la posición de 1 enemigo, y sabiendo la posición del héroe, haga el algoritmo del pathfinding y una vez lo tiene recorrerlo.

Eso me ha resultado fácil, la duda es que, la posición del HEROE puede irse modificando en cada bucle, ya que el juego de en tiempo real, la implementacion seria la misma?

Osea, calculo el recorrido, y muevo enemigo por ese recorrido creado, pero si Heroe cambia su posicion, enemigo que vuelva a crear una nueva ruta.
Así es como lo tenia pensando, pero no se si hay alguna forma mejor, ya que esto podría ser muy costosa porque por lo general HÉROE nunca va estar en la misma posición.

Gracias

Vaya
Nose yo estoy usando el tutorial de esta web
https://software.intel.com/en-us/articles/creating-multi-platform-games-with-cocos2d-x

Y alli ya lo pone: NOTA: Como se puede observar, se crea una copia de la librería completa en cada proyecto nuevo creado, esto tiene la ventaja de poder crear el proyecto en la ruta deseada, pero la desventaja de que cada proyecto ocupara unos 300MB, y una vez compilado será como mínimo 1GB.

Pero nose ha que viene :S

Buenas! He empezado hace varios días a utilizar este framework.
La verdad es que apenas estoy mirándome los códigos de los ejemplos.

La verdad es que me ha llamado la atención el tamaño que ocupan los proyectos, me explico, un nuevo provecto de HelloWorld ocupa 200 MB

Esto es normal? o algo esta mal? porque si pretendo hacer juegos para móviles, con esos tamaños solo en un nuevo projecto es ya casi impensable.

EDIT: compilado ocupa 1 GB
Gracias!

El juego online era uno sencillito de cartas y poder jugar contra otra gente...
Lo que este tema lleva mucho retrasandolo porque no se con que lenguaje usar, miraré cocos2d que al usar c++ me resultará facil, a ver que tal.
gracias