Gemix Studio

Posted: **Wed Jan 30, 2019 3:23 am**

Buenas gente.. os dejo un pequeño mini juego programado por mi.
Es completamente open source y el unico motivo por el cual lo he hecho ha sido por entretener a mi niña de 4 años y a la vez testear la gameLibZero que ando haciendo desde hace meses..

No esta excesivamente pulido.. pero abro la veda.. sed completamente crueles conmigo XD..
Bueno, veréis que es un juego hecho en dos tardes.. no es nada del otro mundo, incluye codigo fuente para losmas curiosos.. es el tipico juego de cartas para hacer parejas..

Para los mas curiosos que no quieran descargar el juego os pego el SOURCE:

Source Code (C++) [ Download ] [ Hide ]

/*
    tipos de cartas: formas, animales, colores, transportes, frutas.
*/
#include "gameLibZero.cpp"
int ST = 0;
images img;
fonts fnt;
images frutas;
images formas;
images animales;
images colores;
images transportes;
images particles;
images pikachu;
images rainbow;
process* idMouse;               // id del proceso del mouse..
process* idBackButton;          // boton de volver atras..
bool fin_difuminado = false;    // fin transición pantalla seleccion personaje..
char nombre[20];                // nombre del jugador..
int nombre_pos = 0;             // posición de inserción de caracter del nombre..
 
bool nombre_ok = false;         // nombre aceptado mediante boton ENTER..
bool go_back = false;           // indica si volver atras..
bool tipo_elegido = false;      // indica cuando se ha escogido un tipo de cartas para jugar..
 
// tipos de objetos..
int type_gametype;
int type_carta;
 
struct controls{
    bool up   = false;
    bool down = false;
    bool left = false;
    bool right= false;
    bool    a = false;
    bool    b = false;
    bool active=true;
}controls;
 
images mazo_seleccionado;
class carta;
// pareja
carta* id_a;            // id carta A
carta* id_b;            // id carta B
int pareja_st = 0;      // estado de la pareja..
int pares = 0;          // parejas conseguidas..
//---------------------------------------------------------------------------
void setup(){
    setMode(1370, 768);
    setFps(60);
    loadImages("data/image/main", &img);
    loadImages("data/image/frutas", &frutas);
    loadImages("data/image/formas", &formas);
    loadImages("data/image/animales", &animales);
    loadImages("data/image/colores", &colores);
    loadImages("data/image/transportes", &transportes);
    loadImages("data/image/particles", &particles);
    loadImages("data/image/pikachu", &pikachu);
    loadImages("data/image/rainbow_dash", &rainbow);
    loadFonts("data/font", &fnt);
    HideCursor();
    fadeOff(0);
    //fullscreen();
    setBackgroundColor(WHITE);
}
//---------------------------------------------------------------------------
class finPartida:public process{
    public:
    int st = 0;
    int anima = 0;
    int delay = 0;
    void frame(){
        screenDrawText(fnt[1], 100, "BUEN TRABAJO!", CENTER, 685, 50, WHITE, 255);
        switch(st){
            case 0:
                {
                    x = 1500;
                    y = 768/2 + 50;
                    size = 80;
                    graph = rainbow[0];
                    visible = true;
                    st = 10;
                }
                break;
            case 10:
                {
                    delay = (delay+1)%2;
                    if(delay==0){
                        anima = (anima+1)%rainbow.size();
                    }
                    graph = rainbow[anima];
                    if(x>100){
                        x-=5;
                    }else{
                        fadeOff(2000);
                        st = 20;
                        
                    }
                }
                break;
            case 20:
                {
                    delay = (delay+1)%2;
                    if(delay==0){
                        anima = (anima+1)%rainbow.size();
                    }
                    graph = rainbow[anima];
                    x-=5;
                    if(!fading){
                        st = 30;
                        ST = 1000;
                    }
                }
                break;
        }
    }
};
//---------------------------------------------------------------------------
class cartel:public process{
    public:
    int st = 0;
    int tipo = 0;
    int gr;
    cartel(int tipo){
        this->tipo = tipo;
    }
    void frame(){
        switch(st){
            case 0:
                {
                    switch(tipo){
                        case 1:
                            {
                                /* CARTEL BUENO */
                                gr = rand(22, 28);
                            }
                            break;
                        case 2:
                            {
                                /* CARTEL MALO */
                                gr = rand(29, 33);
                            }
                            break;
                        case 100:
                            {
                                /* CARTEL PREPARADOS.. */
                                gr = 20;
                            }
                            break;
                        case 200:
                            {
                                /* CARTEL A JUGAR! */
                                gr = 21;
                            }
                            break;
                    }
                    priority = 32;
                    x = -1640;
                    y = 660;
                    graph = img[gr];
                    visible = true;
                    size = 90;
                    st = 10;
                }
                break;
            case 10:
                {
                    if(x<600){
                        x+=25;
                    }else{
                        st = 20;
                    }
                }
                break;
            case 20:
                {
                    if(x<800){
                        x+=4;
                    }else{
                        st = 30;
                    }
                }
                break;
            case 30:
                {
                    if(x<2000){
                        x+=25;
                    }else{
                        signal(this, s_kill);
                        st = 40;
                    }
                }
                break;
        }
    }
};
//---------------------------------------------------------------------------
class carta:public process{
    public:
    int st = 0;
    int num = 0;
    int minx = 90;
    int separacion = 170;
    int gr;
    vector<int>cartas_sin_barajar = {0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7};
    int delay=0;
    bool flag = false;      // cuando se gira se pone a true.. se vuelve a poner a false desde el gestor de cartas..
    carta(int num, int gr){
        this->num = num;
        this->gr = gr;
    }
    void frame(){
        switch(st){
            case 0:
                {
                    type_carta = type;
                    priority = 128;
                    sizex = sizey = 160;
                    graph = mazo_seleccionado[cartas_sin_barajar[num]];
                    visible = true;
                    if(num<8){
                        y = 270;
                        x = minx + num*separacion;
                    }else{
                        y = 500;
                        x = minx + (num-8)*separacion;
                    }
                    createBody(TYPE_BOX, SENSOR);
                    st = 10;
                }
                break;
            case 10:
                {
                    delay = (delay+1)%(60+num*10);
                    if(delay==0){
                        st = 20;
                    }
                }
                break;
            case 20:
                {
                    if(sizex>0){
                        sizex-=10;
                    }else{
                        graph = img[3];
                        st = 30;
                    }
                }
                break;
            case 30:
                {
                    if(sizex<160){
                        sizex+=10;
                    }else{
                        /* CUANDO LA ULTIMA CARTA ESTA GIRADA SE ACTIVA EL JOYSTIC */
                        if(num==15){
                            new cartel(200);        // cartel: a jugar!
                            controls.active = true;
                        }
                        st = 40;
                    }
                }
                break;
            case 40:
                {
                    if(angle<360){
                        angle+=10;
                        setAngle(angle);
                    }
                    
                    if(collision(idMouse)){
                        if(controls.a && controls.active){
                            controls.active = false;
                            switch(pareja_st){
                                case 0:
                                    id_a = this;
                                    pareja_st++;
                                    break;
                                case 1:
                                    id_b = this;
                                    pareja_st++;
                                    break;
                            }
                            st = 45;
                        }
                    }
                }
                break;
            case 45:
                {
                    if(!controls.a){
                        controls.active = true;
                        flag = true;
                        st = 50;
                    }
                }
                break;
            case 50:
                {
                    if(sizex>0){
                        sizex-=10;
                    }else{
                        graph = mazo_seleccionado[gr];
                        st = 60;
                    }
                }
                break;
            case 60:
                {
                    if(sizex<160){
                        sizex+=10;
                    }else{
                        delay = 0;
                        st = 70;
                    }
                    
                }
                break;
            case 70:
                {
                    delay = (delay+1)%60;
                    if(delay==0){
                        st = 80;
                    }
                }
                break;
            case 80:
                {
                    // aqui la carta ha terminado de girar para mostrarse..
                }
                break;
            case 100:
                {
                    if(sizex>0){
                        sizex-=10;
                    }else{
                        graph = img[3];
                        st = 110;
                    }
                }
                break;
            case 110:
                {
                    if(sizex<160){
                        sizex+=10;
                    }else{
                        st = 40;
                    }
                }
                break;
        }
    }
};
//---------------------------------------------------------------------------
class generaCartas:public process{
    public:
    int st = 0;
    int delay = 0;
    vector<int>cartas = {0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7};
    void frame(){
        //cout<<controls.active<<endl;
        switch(st){
            case 0:
                {
                    controls.active = false;
                    // barajar cartas..
                    std::random_shuffle(cartas.begin(), cartas.end());
                    
                    new cartel(100);    // cartel preparados..
                    
                    // sacar cartas..
                    for(int i=0; i<16; i++){
                        new carta(i, cartas[i]);
                    }
                    size = 40;
                    st = 10;
                }
                break;
            case 10:
                {
                    if(pareja_st==2){
                        controls.active = false;
                        if(id_a->gr == id_b->gr){
                            /* PAREJA CORRECTA */
                            pares ++;           // sumar 1 a las parejas descubiertas..
                            new cartel(1);      // cartel bueno..
                            delay = 0;
                            st = 20;
                            
                        }else{
                            /* PAREJA INCORRECTA */
                            if(id_a->flag && id_b->flag){
                                id_a->flag = false;
                                id_b->flag = false;
                                new cartel(2);      // cartel malo..
                            }
                            if(id_a->st==80 && id_b->st==80){
                                id_a->st = 100;
                                id_b->st = 100;
                                delay = 0;
                                st = 20;
                            }
                            
                        }
                    }
                }
                break;
            case 20:
                {
                    delay = (delay+1)%60;
                    if(delay==0){
                        controls.active = true;
                        pareja_st = 0;
                        if(pares == 8){
                            st = 30;
                        }else{
                            st = 10;
                        }
                    }
                }
                break;
            case 30:
                {
                    // terminado el juego..
                    fadeOff(1500);
                    st = 40;
                }
                break;
            case 40:
                {
                    if(!fading){
                        tipo_elegido = false;
                        ST = 3000;
                    }
                }
                break;
        }
    }
};
//---------------------------------------------------------------------------
class botonVolverElijePersonaje:public process{
    public:
    int st = 0;
    void frame(){
        switch(st){
            case 0:
                {
                    priority = 128;
                    graph = img[18];
                    visible = true;
                    x = 150;
                    y = 680;
                    size = 300;
                    createBody(TYPE_BOX, SENSOR);
                    st = 10;
                }
                break;
            case 10:
                {
                    if(collision(idMouse)){
                        setTintColor(color(200,200,200,127));
                        if(controls.a){
                            go_back = true;
                            st = 20;
                        }
                    }else{
                        setTintColor(WHITE);
                    }
                }
                break;
        }
    }
};
//---------------------------------------------------------------------------
class raton:public process{
    public:
    int st = 0;
    int vel = 10;
    void frame(){
        switch(st){
            case 0:
                {
                    priority = 64;
                    x = 1370/2;
                    y = 384;
                    graph = newGraph(1,1,WHITE);
                    visible = true;
                    createBody(TYPE_CIRCLE, SENSOR);
                    setCenter(8,5);
                    graph = img[10];
                    signal(this, s_protected);
                    st = 10;
                }
                break;
            case 10:
                {
                    if(controls.left){
                        x-=vel;
                    }
                    if(controls.right){
                        x+=vel;
                    }
                    if(controls.up){
                        y-=vel;
                    }
                    if(controls.down){
                        y+=vel;
                    }
                    
                    if(x<30){
                        x = 30;
                    }
                    if(x>1300){
                        x = 1300;
                    }
                    if(y<30){
                        y = 30;
                    }
                    if(y>700){
                        y = 700;
                    }
                    
                    translate(x, y);
                    graph = img[10];
                    if(collisionType(type_gametype)){
                        graph = img[11];
                        if(controls.a){
                            graph = img[8];
                            //st = 20;
                        }
                    }
                    
                    if(collision(idBackButton)){
                        graph = img[11];
                        if(controls.a){
                            graph = img[8];
                            //st = 20;
                        }
                    }
                    
                    if(collisionType(type_carta)){
                        graph = img[11];
                        if(controls.a){
                            graph = img[8];
                            //st = 20;
                        }
                    }
                    
                    
                }
                break;
            case 20:
                {
                    
                }
                break;
        }
    }
};
//---------------------------------------------------------------------------
class gametype:public process{
    public:
    int st = 0;
    int counter = 0;
    int it = 0;
    int inc;
    images cartas;
    gametype(images gr, float x, float y){
        this->cartas = gr;
        this->x = x;
        this->y = y;
    }
    void frame(){
        switch(st){
            case 0:
                {
                    priority = 128;
                    type_gametype = type;
                    graph = cartas[0];
                    visible = true;
                    size = 200;
                    createBody(TYPE_BOX, SENSOR);
                    st = 10;
                }
                break;
            case 10:
                {
                    // si se ha escogido otro mazo de cartas..
                    if(tipo_elegido){
                        //tipo_elegido = false;
                        st = 100;
                    }
                    
                    // animacion del mazo..
                    counter = (counter+1)%60;
                    if(counter==0){
                        it = (it+1)%cartas.size();
                        graph = cartas[it];
                    }
                    
                    // si paso el puntero por el mazo..
                    if(collision(idMouse)){
                        screenDrawGraphic(img[2], x, y, angle, size, alpha);
                        if(controls.a){
                            tipo_elegido = true;
                            mazo_seleccionado = cartas;
                            controls.active = false;
                            st = 20;
                        }
                    }
                }
                break;
            case 20:
                {
                    if(getDistance(1370/2, y) > 10){
                        if(x>1370/2){
                            x-=5;
                        }else{
                            x+=5;
                        }
                    }else{
                        fadeOff(2000);
                        st = 30;
                    }
                    translate(x,y);
                }
                break;
            case 30:
                {
                    size+=5;
                    if(!fading){
                        ST = 2000;
                        st = 40;
                    }
                }
                break;
            case 40:
                {
                    
                }
                break;
            case 100:
                {
                    inc = (inc+10)%360;
                    x += 10*sin(radians(inc));
                    y+=5;
                    translate(x,y);
                }
                break;
        }
    }
};
//---------------------------------------------------------------------------
class background:public process{
    public:
    int st = 0;
    void frame(){
        switch(st){
            case 0:
                {
                    priority = 512;
                    graph = img[18];
                    visible = true;
                    x = 685;
                    y = 384;
                    //size = 130;
                    //signal(this, s_protected);
                    st = 10;
                }
                break;
            case 10:
                {
                    //offset.x++;
                    //offset.y--;
                }
                break;
        }
    }
};
//---------------------------------------------------------------------------
class animatedBackground:public process{
    public:
    int st = 0;
    void frame(){
        switch(st){
            case 0:
                {
                    priority = 512;
                    graph = img[19];
                    visible = true;
                    x = 685;
                    y = 384;
                    size = 130;
                    tiling = { 1.5f, 1.5f };
                    st = 10;
                }
                break;
            case 10:
                {
                    offset.x++;
                    offset.y--;
                }
                break;
        }
    }
};
//---------------------------------------------------------------------------
class difuminado:public process{
    public:
    int st = 0;
    int pika = 0;
    void frame(){
        switch(st){
            case 0: 
                {
                    priority = 32;
                    x = 2000+(1370/2);
                    y = 768/2;
                    size = 150;
                    graph = img[16];
                    visible = true;
                    st = 10;
                }
                break;
            case 10:
                {
                    if(x>1370/2){
                        x-=10;
                    }else{
                        fin_difuminado = true;
                    }
                    
                    pika = (pika+1)%pikachu.size();
                    screenDrawGraphic(pikachu[pika], x-1010, y, 0, 100, 255);
                    
                }
                break;
           
        }
    }
};
//---------------------------------------------------------------------------
class tecla:public process{
    public:
    int st = 0;
    char letra[10];
    int xMinima = 150;
    int yMinima = 380;
    int separacion = 120;
    int fila, columna;
    char linea_0[10] = {'q','w','e','r','t','y','u','i','o','p'};
    char linea_1[10] = {'a','s','d','f','g','h','j','k','l','&'};
    char linea_2[10] = {'z','x','c','v','b','n','m','?','!','@'};
    tecla(int fila, int columna){
        this->fila = fila;
        this->columna = columna;
    }
    void frame(){
        switch(st){
            case 0: 
                {
                    priority = 128;
                    size = 240;
                    x = xMinima+(columna*separacion);
                    y = yMinima+(separacion*fila);
                    
                    switch(fila){
                        case 0:
                            letra[0] = linea_0[columna];
                            letra[1] = '\0';
                            break;
                        case 1:
                            letra[0] = linea_1[columna];
                            letra[1] = '\0';
                            break;
                        case 2:
                            letra[0] = linea_2[columna];
                            letra[1] = '\0';
                            break;
                    }
                    
                    graph = img[17];
                    visible = true;
                    createBody(TYPE_BOX, SENSOR);
                    st = 10;
                }
                break;
            case 10:
                {
                    switch(letra[0]){
                        case '@':
                            screenDrawText(fnt[5], 34, "ENTER", CENTER, x, y, WHITE, 255);
                            break;
                        case '&':
                            screenDrawText(fnt[5], 32, "BORRAR", CENTER, x, y, WHITE, 255);
                            break;
                        default:
                            screenDrawText(fnt[5], 100, letra, CENTER, x, y, WHITE, 255);
                            break;
                    }
                    if(collision(idMouse)){
                        if(controls.a){
                            switch(letra[0]){
                                case '@':
                                    nombre_ok = true;
                                    break;
                                case '&':
                                    if(nombre_pos>0){
                                        nombre_pos--;
                                        nombre[nombre_pos] = 0;
                                        st = 20;
                                    }
                                    break;
                                default:
                                    if(nombre_pos < 10){
                                        nombre[nombre_pos] = letra[0];
                                        nombre_pos ++;
                                        st = 20;
                                    }
                                    break;
                            }
                        }
                    }
                }
                break;
            case 20:
                {
                    screenDrawText(fnt[5], 100, letra, CENTER, x, y, WHITE, 255);
                    if(!controls.a){
                        st = 10;
                    }
                }
                break;
        }
    }
};
//---------------------------------------------------------------------------
class seleccionarNinioNinia:public process{
    public:
    int st;
    int flash=0;
    process* idDifuminado;
    void frame(){
        switch(st){
            case 0:
                {
                    priority = 128;
                    screenDrawText(fnt[3], 64,"SELECT OPTION", CENTER, 685, 50, WHITE, 255);
                    screenDrawGraphic(img[12], 685-250, 350, 0, 100, 255);
                    screenDrawGraphic(img[13], 685+250, 350, 0, 100, 255);
                    if(idMouse->x<655){
                        screenDrawGraphic(img[14], 685-250, 350, 0, 100, 255);
                        if(controls.a){
                            st = 100;
                        }
                    }
                    if(idMouse->x>705){
                        screenDrawGraphic(img[15], 685+250, 350, 0, 100, 255);
                        if(controls.a){
                            st = 200;
                        }
                    }
                }
                break;
            case 100:
                {
                    screenDrawText(fnt[3], 64,"SELECT OPTION", CENTER, 685, 50, WHITE, 255);
                    screenDrawGraphic(img[12], 685-250, 350, 0, 100, 255);
                    screenDrawGraphic(img[13], 685+250, 350, 0, 100, alpha);
                    if(alpha>0){
                        alpha -= 5;
                    }else{
                        idDifuminado = new difuminado();
                        st = 110;
                    }
                }
                break;
            case 110:
                {
                    screenDrawText(fnt[3], 64,"SELECT OPTION", CENTER, 685, 50, WHITE, 255);
                    screenDrawGraphic(img[12], 685-250, 350, 0, 100, 255);
                    if(fin_difuminado==true){
                        alpha = 255;
                        idDifuminado->priority = 256;
                        fadeOff(0);
                        signal(idDifuminado, s_kill);
                        //new background();
                        new animatedBackground();
                        crearTeclado();
                        st = 300;
                    }
                }
                break;
            case 200:
                {
                    screenDrawText(fnt[3], 64,"SELECT OPTION", CENTER, 685, 50, WHITE, 255);
                    screenDrawGraphic(img[12], 685-250, 350, 0, 100, alpha);
                    screenDrawGraphic(img[13], 685+250, 350, 0, 100, 255);
                    if(alpha>0){
                        alpha -= 5;
                    }else{
                        idDifuminado = new difuminado();
                        st = 210;
                    }
                }
                break;
            case 210:
                {
                    screenDrawText(fnt[3], 64,"SELECT OPTION", CENTER, 685, 50, WHITE, 255);
                    screenDrawGraphic(img[13], 685+250, 350, 0, 100, 255);
                    if(fin_difuminado==true){
                        alpha = 255;
                        idDifuminado->priority = 256;
                        fadeOff(0);
                        signal(idDifuminado, s_kill);
                        //new background();
                        new animatedBackground();
                        crearTeclado();
                        st = 300;
                    }
                }
                break;
            case 300:
                {
                    fin_difuminado = false;
                    fadeOn(1500);
                    st = 400;
                }
                break;
            
            case 400:
                {
                    /* AQUI SE ENTRA CUANDO EL DIFUMINADO TERMINA DE MOVERSE */
                    screenDrawText(fnt[0], 86,"YOUR NAME?", CENTER, 685, 80, WHITE, 255);
                    screenDrawText(fnt[2], 100, nombre, CENTER, 685, 200, WHITE, 255);
                    flash = (flash+1)%30;
                    if(flash<15){
                        screenDrawText(fnt[2], 100, "_", CENTER, 685+MeasureTextEx(fnt[2], nombre, 100, text_spacing).x, 200, WHITE, 255);
                    }
                    if(nombre_ok==true){
                        nombre_ok = false;
                        fadeOff(1500);
                        st = 500;
                    }
                }
                break;
            case 500:
                {
                    screenDrawText(fnt[0], 86,"YOUR NAME?", CENTER, 685, 80, WHITE, 255);
                    screenDrawText(fnt[2], 100, nombre, CENTER, 685, 200, WHITE, 255);
                    if(!fading){
                        ST = 1000;
                        st = 510;
                    }
                }
                break;
            case 510:
                {
                    
                }
                break;
        }
    }
    void crearTeclado(){
        for(int alto=0; alto<3; alto++){
            for(int ancho=0; ancho<10; ancho++){
                new tecla(alto, ancho);
            }
        }
    }
};
//---------------------------------------------------------------------------
void draw(){
    
    if(key(KEY_SPACE)){
        controls.a = true;
    }else{
        controls.a = false;
    }
    
    if(key(KEY_UP)){
        controls.up = true;
    }else{
        controls.up = false;
    }
    
    if(key(KEY_DOWN)){
        controls.down = true;
    }else{
        controls.down = false;
    }
    
    if(key(KEY_LEFT)){
        controls.left = true;
    }else{
        controls.left = false;
    }
    
    if(key(KEY_RIGHT)){
        controls.right = true;
    }else{
        controls.right = false;
    }
    
    switch(ST){
        case 0:
            {
                new animatedBackground();
                idMouse = new raton();
                new seleccionarNinioNinia();
                setBackgroundColor(WHITE);
                fadeOn(1500);
                ST = 10;
            }
            break;
        case 10:
            {
                
            }
            break;
        //------------------------------------------------------
        case 1000:
            {
                letMeAlone();
                fadeOn(1500);
                //new background();
                new animatedBackground();
                new gametype(formas, 140, 400);
                new gametype(animales, 420, 400);
                new gametype(colores, 1370/2, 400);
                new gametype(transportes, 1370-420, 400);
                new gametype(frutas, 1370-140, 400);
                idBackButton = new botonVolverElijePersonaje();
                ST = 1010;
            }
            break;
        case 1010:
            {
                screenDrawText(fnt[0], 140, "MY MEMORY GAME", CENTER, 685, 80, WHITE, 255);
                screenDrawText(fnt[1], 60, "Selecciona un tipo de cartas para empezar a jugar", CENTER, 685, 180, WHITE, 255);
                if(go_back){
                    go_back = false;
                    controls.active = false;
                    fadeOff(1500);
                    ST = 1020;
                }
            }
            break;
        case 1020:
            {
                screenDrawText(fnt[0], 140, "MY MEMORY GAME", CENTER, 685, 80, WHITE, 255);
                screenDrawText(fnt[1], 60, "Selecciona un tipo de cartas para empezar a jugar", CENTER, 685, 180, WHITE, 255);
                if(!fading){
                    signal(idMouse, s_unprotected);
                    letMeAlone();
                    fadeOn(1500);
                    controls.active = true;
                    ST = 0;
                }
            }
            break;
        //------------------------------------------------------
        case 2000:
            {
                // aqui empieza la partida..
                letMeAlone();
                fadeOn(1500);
                new animatedBackground();
                controls.active = true;
                new generaCartas();
                ST = 2010;
            }
            break;
        //------------------------------------------------------
        case 3000:
            {
                letMeAlone();
                fadeOn(1500);
                new finPartida();
                ST = 3010;
            }
            break;
        //------------------------------------------------------
    }
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
 

Posted: **Wed Jan 30, 2019 12:26 pm**

No he podido jugarlo,la resolucion es muy grande y no veo parte del escenario,no puedo pasar de las letras porque no se ve el boton enter para pasar al juego.

Yo solo puedo poner como maximo una resolucion de 1024x768.Porque utilizas los cursores del teclado en vez del raton?

Posted: **Wed Jan 30, 2019 3:52 pm**

Hola Hokuto, esta a esa resolución por que es para jugarlo en la tele de casa con la nena de 4 años a pantalla completa.
Y tiene esos controles por que uso el mando de Wii para jugar.

El juego en si es un juego infantil, tranqui no te pierdes gran cosa jeje..

Gemix Studio

[GAME] Memory! Programado por mi.

[GAME] Memory! Programado por mi.

Re: [GAME] Memory! Programado por mi.

Re: [GAME] Memory! Programado por mi.