Répondre à la discussion
Affichage des résultats 1 à 15 sur 15

Programmation autours d'un jeu



  1. #1
    lepatagon

    Programmation autours d'un jeu


    ------

    Bonjour,
    Je recherche un programmeur qui pourrait m’aider a faire tourner un ptit programme au sujet d’un jeu.
    Ce jeu se nomme KHALOU et est disponible gratuitement sur Itunes pour Iphone et Ipad.
    https://itunes.apple.com/fr/app/khalou/id589404904?mt=8
    Je vous laisse en lire les règles. Voici mes requêtes :
    Il existe pour ce jeu 2^16 = 65536 positions différentes.
    Les jetons de ce jeu peuvent se retourner de différentes façons. Je cherche un petit script a faire tourner qui pourrait me donner :
    *Pour chacune des positions : le nombre de retournement minimum pour rendre le damier du jeu tout blanc (le but du jeu). Cela est toujours faisable en 5 retournements minimum (démontré via théorie des groupes).
    *Trouver ainsi le nombre totale de positions résolvables en : 1, 2, 3, 4 et 5 retournements minimum.

    Qui pourrait m’aider pour cette programmation ?

    Merci

    Dan

    -----

  2. Publicité
  3. #2
    Chanur

    Re : Programmation autours d'un jeu

    Bonjour,

    Tu aurais pu donner les règles du jeu, parce qu'avec ton lien je ne les ai pas trouvées.
    Et tant qu'à faire du copier-coller ...
    Enfin bon. Elle sont là : developpez.net, et là : hardware.fr
    Maintenant, je ne vois pas très bien ce que tu attends. Comme il apparaît que pour une position donnée, il y a moins de 188628750 mouvements à étudier, il suffit de tout balayer. C'est assez simple à programmer.

    A+
    Ce qui se conçoit bien s'énonce clairement ; et les mots pour le dire arrivent aisément.

  4. #3
    lepatagon

    Re : Programmation autours d'un jeu

    oui mais je ne sais pas programmer

  5. #4
    whoami

    Re : Programmation autours d'un jeu

    Bonjour,

    Eh bien, c'est l'occasion d'apprendre.

  6. A voir en vidéo sur Futura
  7. #5
    Chanur

    Re : Programmation autours d'un jeu

    C'est même plus rapide que ce que je pensais. Il faut environ 4 millisecondes (sur un AMD à 3.6Gherz) en moyenne pour trouver la solution (testé sur 100000 positions aléatoires).
    Je pourrais faire deux fois plus rapide en utilisant les deux coeurs de mon processeur, mais il faudrait deux threads et j'ai la flemme.
    C'est un peu brutal comme programmation.
    Code:
    // une position est représentée sur un entier sur 16 bits// les 46 mouvements sont représentés par 46 entiers sur 16 bits
    // appliquer un mouvement à une position consiste à faire un Xor entre la position et le mouvement
    
    
    #include <stdio.h>
    // Les 46 mouvements possibles (le 0 final me sert de terminateur)
    unsigned short mouvement [47] = {   0xf000  // ligne 1
                                    ,   0x0f00  // ligne 2
                                    ,   0x00f0  // ligne 3
                                    ,   0x000f  // ligne 4
                                    ,   0x8888  // colonne 1
                                    ,   0x4444  // colonne 2
                                    ,   0x2222  // colonne 3
                                    ,   0x1111  // colonne 4
                                    ,   0x8421  // diagonale 1
                                    ,   0x1248  // diagonale 2
                                    ,   0xc800  // coins de la ligne 1
                                    ,   0xc400
                                    ,   0x6400
                                    ,   0x6200
                                    ,   0x3200
                                    ,   0x3100
                                    ,   0x0c80  // coins de la ligne 2
                                    ,   0x8c00
                                    ,   0x0c40
                                    ,   0x4c00
                                    ,   0x0640
                                    ,   0x4600
                                    ,   0x0620
                                    ,   0x2600
                                    ,   0x0320
                                    ,   0x2300
                                    ,   0x0310
                                    ,   0x1300
                                    ,   0x00c8  // coins de la ligne 3
                                    ,   0x08c0
                                    ,   0x00c4
                                    ,   0x04c0
                                    ,   0x0064
                                    ,   0x0460
                                    ,   0x0062
                                    ,   0x0260
                                    ,   0x0032
                                    ,   0x0230
                                    ,   0x0031
                                    ,   0x0130
                                    ,   0x008c  // coins de la ligne 4
                                    ,   0x004c
                                    ,   0x0046
                                    ,   0x0026
                                    ,   0x0023
                                    ,   0x0013
                                    ,   0x0000
                                    };
    
    
    void afficher (unsigned short position)
        {
        int i, j, k;
        for (i=0, k=0x8000; i<4; i++)
            {
            for (j=0; j<4; j++, k>>=1)
                {
                if (position & k)
                    putchar ('o');
                else
                    putchar ('.');
                }
            putchar ('\n');
            }
        putchar ('\n');
        }
    int main ()
        {
        int i, j, k;
        register unsigned short * m1;
        register unsigned short * m2;
        register unsigned short * m3;
        register unsigned short * m4;
        register unsigned short * m5;
        
        // Affichage de controle des positions
        // for (m1=mouvement; *m1; m1++)
        //    afficher (*m1);
    
    
        // Saisie de la position de départ
        char buffer [10];
        unsigned short position = 0;
        for (i=0, k=0x8000; i<4; i++)
            {
            fgets (buffer, sizeof (buffer), stdin);
            for (j=0; j<4; j++, k>>=1)
                {
                if (buffer [j] != ' ')
                    position |= k;
                }
            }
        putchar ('\n');
        afficher (position);
    
    
        // essayer en 1 coup
        for (m1=mouvement; *m1; m1++)
            {
            if ((position ^ *m1) == 0)
                {
                printf ("solution en 1 coup :\n");
                afficher (*m1);
                return 0;
                }
            }
    
    
        // bon. Ca n'a pas marché. Essayons en 2 coups.
        for (m1 = mouvement; *m1; m1++)
            {
            unsigned short p = position ^ *m1;
            for (m2 = mouvement; *m2; m2++)
                {
                if ((p^*m2) == 0)
                    {
                    printf ("solution en 2 coups :\n");
                    afficher (*m1);
                    afficher (*m2);
                    return 0;
                    }
                }
            }
    
    
        // Ca n'a toujours pas marché. En 3 coups, peut-être ?
        for (m1 = mouvement; *m1; m1++)
            {
            unsigned short p1 = position ^ *m1;
            for (m2 = mouvement; *m2; m2++)
                {
                unsigned short p2 = p1 ^ *m2;
                for (m3 = mouvement; *m3; m3++)
                    {
                    if ((p2^*m3) == 0)
                        {
                        printf ("solution en 3 coups :\n");
                        afficher (*m1);
                        afficher (*m2);
                        afficher (*m3);
                        return 0;
                        }
                    }
                }
            }
    
    
        // Décidemment, ya rien à faire. Voyons si 4 coups suffisent ...
        for (m1 = mouvement; *m1; m1++)
            {
            unsigned short p1 = position ^ *m1;
            for (m2 = mouvement; *m2; m2++)
                {
                unsigned short p2 = p1 ^ *m2;
                for (m3 = mouvement; *m3; m3++)
                    {
                    unsigned short p3 = p2 ^ *m3;
                    for (m4 = mouvement; *m4; m4++)
                        {
                        if ((p3^*m4) == 0)
                            {
                            printf ("solution en 4 coups :\n");
                            afficher (*m1);
                            afficher (*m2);
                            afficher (*m3);
                            afficher (*m4);
                            return 0;
                            }
                        }
                    }
                }
            }
    
    
        // On peut essayer en 5, paraît que c'est le maximum.
        for (m1 = mouvement; *m1; m1++)
            {
            unsigned short p1 = position ^ *m1;
            for (m2 = mouvement; *m2; m2++)
                {
                unsigned short p2 = p1 ^ *m2;
                for (m3 = mouvement; *m3; m3++)
                    {
                    unsigned short p3 = p2 ^ *m3;
                    for (m4 = mouvement; *m4; m4++)
                        {
                        unsigned short p4 = p3 ^ *m4;
                        for (m5 = mouvement; *m5; m5++)
                            {
                            if ((p4^*m5) == 0)
                                {
                                printf ("solution en 5 coups :\n");
                                afficher (*m1);
                                afficher (*m2);
                                afficher (*m3);
                                afficher (*m4);
                                afficher (*m5);
                                return 0;
                                }
                            }
                        }
                    }
                }
            }
    
    
        // Bon. J'arrête là. En principe ça suffit.
        // De toute façon, à ce niveau c'est plus de la programmation, c'est de la dactylographie.
    
    
        return 0;
        }
    Ce qui se conçoit bien s'énonce clairement ; et les mots pour le dire arrivent aisément.

  8. #6
    lepatagon

    Re : Programmation autours d'un jeu

    merci, bpc
    je suis nul en prog et ne sais pas executer ce sript. Comment puis je le faire via Html ou autre ??

  9. Publicité
  10. #7
    defender19

    Re : Programmation autours d'un jeu

    Google existe aussi...

    Tu copies ça dans un fichier, enregistre avec un nom comme script.c
    dans un terminal/console : gcc script.c - o exe
    puis ./exe

    généralement

  11. #8
    lepatagon

    Re : Programmation autours d'un jeu

    et ben ca reste du chinois pour moi

  12. #9
    danyvio

    Re : Programmation autours d'un jeu

    Citation Envoyé par lepatagon Voir le message
    et ben ca reste du chinois pour moi
    中国的语言是很容易的!
    On trouve des chercheurs qui cherchent ; on cherche des chercheurs qui trouvent !

  13. #10
    lepatagon

    Re : Programmation autours d'un jeu

    et ouiiiiiiiiiiiiii

  14. #11
    Paraboloide_Hyperbolique

    Re : Programmation autours d'un jeu

    Bonsoir,

    Ce que defender19 veut dire dans son langage geek, est:

    1) copier le code dans un fichier texte avec l'extension "standard" c, car ce script est écrit en langage 'c'.
    2) compiler le code. Il propose d'utiliser gcc (qui est la référence des compilateurs gratuit pour le langage 'c' et les fans des systèmes unix).
    Cependant, gcc tel quel ne possède pas d'interface graphique et il faut passer par le "terminal/console" (sous Linux) ou "l'invite de commandes" (sous Windows)
    pour l'utiliser. Defender19 indique comment appeler gcc via cette fenêtre et les arguments à passer (fichier à compiler et nom du fichier objet '-o' de sortie).

    Pour quelqu'un qui débute, c'est plutôt rébarbatif. Si vous préférez les interfaces graphiques, vous pouvez compiler ce code sous Windows (ou sous Linux) avec
    Code-blocks, téléchargeable ici: http://www.codeblocks.org/

    Comme tout programme, il faut le prendre en main, surtout si vous n'êtes pas familier avec les notions de programmation.
    Code-blocks est un IDE (Interface de Devéloppement Intégré) qui possède notamment un compilateur avec un éditeur de texte, le tout intégré dans une interface graphique unique.

    Pour pouvoir compiler le code ci-dessus et le faire tourner, vous devez créer un nouveau projet de type "console" et copier-coller le code fournit dans un fichier texte.

  15. #12
    Chanur

    Re : Programmation autours d'un jeu

    Bonsoir,
    Citation Envoyé par lepatagon Voir le message
    je suis nul en prog et ne sais pas executer ce sript. Comment puis je le faire via Html ou autre ??
    Euh, oui, pardon, jaurais du être plus explicite.

    Merci à defender19 et Paraboloide_Hyperbolique (et peut-être danyvio ???) d'avoir complété.

    En plus j'ai écrit quelques âneries : c’était idiot de tester 100000 positions : il n'y en a que 65536 en tout.
    Et le choix des variables que j'ai mis en register est absurde. Déjà que c'est d'une utilité discutable ...

    Par contre, ne rêve pas, lepatagon, je ne crois pas qu'on puisse faire aussi simple avec un langage comme html.

    A+
    Dernière modification par Chanur ; 19/02/2013 à 22h33.
    Ce qui se conçoit bien s'énonce clairement ; et les mots pour le dire arrivent aisément.

  16. Publicité
  17. #13
    invite54165721

    Re : Programmation autours d'un jeu

    Citation Envoyé par Chanur Voir le message
    Merci à defender19 et Paraboloide_Hyperbolique (et peut-être danyvio ???)
    J'ai utilisé le traducteur de google pour l'intervention de danyvio. Cà signifie "la langue chinoise est très facile"
    Dernière modification par alovesupreme ; 20/02/2013 à 14h05.

  18. #14
    deyni

    Re : Programmation autours d'un jeu

    Bonjour,

    Je dirai comme defender19. Si tu es sous linux, ou mac, tu ouvres le terminal et tu tapes:
    gcc -o script -Wall -Wextra
    Puis:
    ./script

    Si ça marche pas dit nous les warinings que tu vois.
    Deynid'oiseaux partout !! :rire:

  19. #15
    Chanur

    Re : Programmation autours d'un jeu

    Bonjour, deyni

    Attention , dans la ligne de compilation, il faut donner le nom de ce qu'on compile ...
    gcc -o script -Wall -Wextra script.c

    Mais de toutes façons, je crois que
    lepatagon a trouvé son bonheur ailleurs. Je ne suis pas sûr qu'on le reverra.
    Ce qui se conçoit bien s'énonce clairement ; et les mots pour le dire arrivent aisément.

Discussions similaires

  1. R - Ajuster les labels autours des points (langage R)
    Par Azote dans le forum Programmation et langages, Algorithmique
    Réponses: 0
    Dernier message: 26/03/2012, 14h40
  2. logistique autours de la voiture électrique
    Par Julien PARIS dans le forum Environnement, développement durable et écologie
    Réponses: 57
    Dernier message: 28/02/2011, 08h07
  3. Répartition des électrons autours de l'atome
    Par lingdoo dans le forum Chimie
    Réponses: 5
    Dernier message: 18/12/2009, 17h14
  4. Programmation jeu de vie de conway en C
    Par cos dans le forum Logiciel - Software - Open Source
    Réponses: 2
    Dernier message: 09/01/2007, 09h40
  5. problème d'instalation d'un jeu
    Par gogol3 dans le forum Logiciel - Software - Open Source
    Réponses: 5
    Dernier message: 06/03/2004, 19h31