Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Tout ce qui n'a pas de catégorie !
Pourquoi je n'arrive pas à me remettre aux PIC
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 874
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#1 Message par F6FCO » dim. 11 août 2019 17:26

Programmer des jeux, çà vous dit ?
Depuis que j'ai trouvé ce site je suis devenu accroc. Dommage que l'assembleur ne figure pas dans tous les langages proposés, du coup je me suis remis au C.
https://www.codingame.com/home
Une porte nand prend 2 bits en entrée... cochonne va !!! :langue:

Pourquoi je n'arrive pas à me remettre aux PIC
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1321
Enregistré en : juillet 2016
Localisation : Terre

#2 Message par Temps-x » mar. 13 août 2019 00:41

Bonsoir F6FCO, et tout le forum,

Ah !! ses jeunes toujours entrain de jouer, :roll: j'espère que tu as eu l'Alien(sale bête). ASM c'est spécifique, donc, non incorporable dans le jeux. :wink:

==> A+
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

Pourquoi je n'arrive pas à me remettre aux PIC
Gérard
Avatar de l’utilisateur
Expert
Expert
Messages : 1182
Âge : 61
Enregistré en : septembre 2015
Localisation : Alsace - Haut-Rhin

#3 Message par Gérard » mer. 14 août 2019 22:13

Je constate qu'il n'y a pas d'âge pour jouer ...
F6, l'éternel ado. :-D
Le 18 / 04 / 2019 je suis devenu papy de jumeaux, une fille et un garçon. Quel bonheur.

Pourquoi je n'arrive pas à me remettre aux PIC
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 874
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#4 Message par F6FCO » ven. 16 août 2019 15:17

Ah !! ses jeunes toujours entrain de jouer, :roll:


Gérard a écrit :Je constate qu'il n'y a pas d'âge pour jouer ...
F6, l'éternel ado. :-D


Ben vous avez raison, un vrai gosse ! j'aime bien jouer :oops: :-), mais ce site c'est plus que du jeu, c'est de la programmation pure et dure, la communauté Codingame propose des challenges sous forme de jeux qu'il faut résoudre par des lignes de code. En fait c'est de la programmation pure et dure, ils ont simplement enrobés les énoncés des problèmes pour que ce soit ludique mais çà n'empêche pas qu'il faut remuer les neurones pour s'en sortir.
Pour le moment je m'en tiens à des trucs simples à résoudre mais on peut aussi (plus tard) participer à des batailles de bots en programmant sois-même son robot. Je n'en suis pas encore là.
Pour l'instant j'essaie de faire atterrir la sonde Mars Lander correctement, pas si simple :roll:

Pour ma part j'ai choisi le C parce que j'y avais déjà un peu touché avec le pseudo C simplifié d'arduino mais il y a une foultitude de langages possibles pour résoudre les enigmes, du Basic au Fortran en passant par le PHP, il y en a pour tout le monde.

Mais bon ceci dit je ne laisse pas tomber les PIC pour autant, j'ai un projet de bras robot dans les cartons mais il faut d'abord que je termine mon atelier pour m'y mettre.
Une porte nand prend 2 bits en entrée... cochonne va !!! :langue:

Pourquoi je n'arrive pas à me remettre aux PIC
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 874
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#5 Message par F6FCO » dim. 1 sept. 2019 11:28

Hello tous,
Des nouvelles du front.
Je suis passé aux challenges multijoueurs. Il s'agit de programmer des bots et de les faire affronter ceux d'autres joueurs, moi je fais çà en C mais il y a plein d'autres langages reconnus. On programme son bot en local, on le teste contre un bot du site et quand on le pense prêt on le soumet pour se confronter au reste du monde. En face des Russes, USA, Chine, Allemands, Coréens, etc. etc. Je me suis même battu contre un Syrien.
Ce matin j'ai foutu une raclée à un prof d'informatique de Paris. Pour l'instant c'est juste des calculs de trajectoires et collisions mais dans les niveaux supérieurs il va falloir peaufiner les algorithmes, et au dernier niveau les gars utilisent les algorithmes génétiques, les réseaux de neurones, le minimax, l'alpha-beta et d'autres, mais çà m'étonnerait que j'arrive jusque-là car le niveau est vraiment élevé.

C'est pire que la drogue ce truc, et en quelques jours j'ai sacrément progressé en C :wink:
Une porte nand prend 2 bits en entrée... cochonne va !!! :langue:

Pourquoi je n'arrive pas à me remettre aux PIC
venom
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 652
Âge : 33
Enregistré en : avril 2016
Localisation : Klyntar
Contact :

#6 Message par venom » dim. 1 sept. 2019 13:06

Wouah sympa ça des combats de bots. J'étais tomber sur des vidéos il y a longtemps. J'imagine que ça doit "prendre aux tripes" :lol:

Bonne continuation. Que la force soit avec toi







@++
En fait tout est une question de BIT ? :-D

Pourquoi je n'arrive pas à me remettre aux PIC
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 874
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#7 Message par F6FCO » mar. 3 sept. 2019 08:23

venom a écrit :J'imagine que ça doit "prendre aux tripes" :lol:

Plus encore que tu ne le crois, je me couche le soir en faisant des algorithmes pour pondre la routine qui fera la différence :roll:

Pour exemple voici le programme qui m'a permis de passer en ligue de bronze:

Code : Tout sélectionner

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
// --------------- Prototypes
void gestion_boost();
void gestion_collisions();
void calcul_distances ();
void gestion_freinage();
void gestion_angle();
void enregistrement_cibles();
void gestion_distances_courtes();
void calcul_chemin_parcouru();

// ----------------------------------------------------------------
// enregistrement des cibles
// tableau répertoriant toutes les cibles, on les enregistre au premier tour. 
// (0)X, (1)Y, (2)rang, (3)plus grand, (4)nb boucles while entre chaque cible, (5) distance séparant la cible de la prochaine
#define t_x 0               // coord x de la cible
#define t_y 1               // coord y de la cible
#define t_rang 2            // ordre de placement des cibles
#define t_nb_boucles 3      // nb boucle entre deux cibles
#define t_meill_dist 4      // cibles les plus éloignées l'une de l'autre, à 1 pour la plus eloignée, 0 pour les autres
#define t_dist 5
#define t_maxi 8

#define zone_freinage 800
#define val_freinage 0
#define zone_pre_freinage 1800
#define val_pre_freinage 60                    // 40 ok
#define angle_acceleration 100
#define distance_inter_cibles_mini 2500
#define val_puissance_reduite 90
#define zone_freinage_distance_courte 620
#define distance_collision 1200
#define angle_virage 90
#define angle_boost 10

int tab_cibles[t_maxi][6];      
int ptr_boucles
=0;          // éxécution d'une boucle while (1)
int ptr_cibles=0;          // nb cibles -1
int ptr_tour=0;
int ptr_change=0;               // changement de coordonnées
int rang_distance_max=0;

// variables calcul distance
int dmc=0;                  // distance moi/cible
int dma=0;                  // distance moi/adversaire
int dac=0;                  // distance adv/cible
// ----------------------------------------------------------------
int sortie_x=0;
int sortie_y=0;
int distance_maxX=0;
int chemin=0;               // chemin parcouru depuis la cible précédente
int ptr_freinage=0;

int old_cible_x=0;          // coord cibnle précédente
int old_cible_y=0;          // coord cible précédente
int old_checkpoint_x=0;         // ancien checkpoint X
int old_checkpoint_y=0;         // ancien checkpoint Y
int distance_inter_cibles=0;
int valid_boost=0;
int valid_shield=0;

// variables codingame
int x;
int y;
int P;
int next_checkpoint_x;      // 
int next_checkpoint_y;      //
int next_checkpoint_dist;   //
int next_checkpoint_angle;  //
int opponent_y;


int main()
{
    P=100;
    // game loop
    while (1) {
        scanf("%d%d%d%d%d%d", &x, &y, &next_checkpoint_x, &next_checkpoint_y, &next_checkpoint_dist, &next_checkpoint_angle);
        scanf("%d%d", &opponent_x, &opponent_y);
        if (next_checkpoint_x!=old_checkpoint_x) {
            // calcul de la distance entre ancienne et nouvelle cible
            int xa=x, ya=y, xb=next_checkpoint_x,yb=next_checkpoint_y;
            distance_inter_cibles=sqrt( pow(xa-xb,2) + pow(ya-yb,2) );
        }
        fprintf(stderr,"next_checkpoint_x=%i next_checkpoint_y=%i\n",next_checkpoint_x, next_checkpoint_y);
        fprintf(stderr,"next_checkpoint_dist=%i next_checkpoint_angle=%i\n",next_checkpoint_dist, next_checkpoint_angle);

        enregistrement_cibles();        // au premier tour on enregistre les cibles dans un tableau

        // ---------------------------------------------------- pilotage -------------------------------------------------------
        gestion_boost();
        calcul_distances();             // calcul des distances adv/cible/moi
        gestion_collisions();
        freinage();

        // sortie ----------------------
        
        sortie_x
=next_checkpoint_x;
        sortie_y=next_checkpoint_y;
        if (valid_boost==1) printf("%d %d BOOST\n", sortie_x, sortie_y,P);
        else printf("%d %d %i\n", sortie_x, sortie_y,P);
      
        old_checkpoint_x
=next_checkpoint_x;
        old_checkpoint_y=next_checkpoint_y;
    }
    return 0;
}
  

// _____________________________________________________________________________________________________
void gestion_boost(){
    for (int i=0; i<ptr_cibles; i++){
        fprintf(stderr,"préparation boost --> tab_cibles[i][t_x]=%i tab_cibles[i][t_meill_dist]=%i\n",tab_cibles[i][t_x],tab_cibles[i][t_meill_dist]);
        if (ptr_tour>=&& tab_cibles[i][t_x]==next_checkpoint_x && tab_cibles[i][t_meill_dist]==1){
            fprintf(stderr,"next_checkpoint_x%i meilleure=%i\n",next_checkpoint_x, tab_cibles[i][t_meill_dist]);
            fprintf(stderr,"PRESQUE BOOST\n");
            if (next_checkpoint_angle >(-angle_boost) && next_checkpoint_angle < angle_boost){
                valid_boost=1;
                fprintf(stderr,"BOOST !!!!!!\n");
            }
        }
    }
}

// _____________________________________________________________________________________________________
void gestion_collisions(){
    if(dma<distance_collision ) {
        sortie_x=opponent_x; 
        sortie_y
=opponent_y; 
        fprintf
(stderr,"COLLISION !!!\n");
    }
}

// _____________________________________________________________________________________________________
void freinage(){
    // freinage en arrivant à la cible et accélération dés que l'angle avec la prochaine cible est bon
    calcul_chemin_parcouru();
    // -------- gestion distance inter-cible longues
    if (distance_inter_cibles>distance_inter_cibles_mini){
        ptr_freinage=0;
        
        
// FREINAGE
        if(chemin<=zone_pre_freinage && distance_inter_cibles>distance_inter_cibles_mini ){
            if (chemin<=zone_freinage){
                P=val_freinage;
                ptr_freinage=1;
                fprintf(stderr,"FREINAGE !!!\n",P);  
            
}
            
            
// PRE FREINAGE
            else{
                P=val_pre_freinage;
                ptr_freinage=1;
                fprintf(stderr,"PRE-FREINAGE !!!\n",P);  
             
}
        }
        
        
// RE-ACCELERATION
        if (ptr_freinage==0){
            if (next_checkpoint_angle>(-angle_acceleration) && next_checkpoint_angle<angle_acceleration ){
                P=100;
                ptr_freinage=0;
                fprintf(stderr,"RE-ACCELERATION !!!\n",P);  
                old_cible_x
=next_checkpoint_x;
                old_cible_y=next_checkpoint_y;
            }
        } 
    
}
    else {
        gestion_distances_courtes();
    }
    if (next_checkpoint_angle>angle_virage || next_checkpoint_angle< (-angle_virage)) {
        P=0;
        fprintf(stderr,"ANGLE VIRAGE P=0\n")   ;    
    
}

    fprintf(stderr,"zone_pre_freinage=%i zone_freinage=%i\n",zone_pre_freinage,zone_freinage);
    fprintf(stderr,"chemin=%i\n",chemin);
    //fprintf(stderr,"ptr_freinage=%i\n",ptr_freinage);
    //fprintf(stderr,"next_checkpoint_dist=%i next_checkpoint_angle=%i\n",next_checkpoint_dist,next_checkpoint_angle);
    fprintf(stderr,"P=%i\n",P);  
}
// _____________________________________________________________________________________________________

void gestion_distances_courtes(){
            if (chemin<=zone_freinage_distance_courte){
                P=val_freinage;
                ptr_freinage=1;
                fprintf(stderr,"FREINAGE DISTANCE COURTE !!!\n",P);  
            
}
            else {
                P=val_puissance_reduite;
            }
}

// _____________________________________________________________________________________________________
void calcul_chemin_parcouru(){
    int xa=x, ya=y, xb=next_checkpoint_x, yb=next_checkpoint_y;
    chemin=sqrt( pow(xa-xb,2) + pow(ya-yb,2) );
}


// _____________________________________________________________________________________________________
void calcul_distances (){
        dmc=sqrt( pow(abs(x-next_checkpoint_x),2) + pow(abs(y-next_checkpoint_y),2)); // distance moi/cible
        dma=sqrt( pow(abs(x-opponent_x),2) + pow(abs(y-opponent_y),2)); // distance moi/adversaire
        dac=sqrt( pow(abs(opponent_x-next_checkpoint_x),2) + pow(abs(opponent_x-next_checkpoint_y),2)); // distance adversaire/cible
}
      
 
// _____________________________________________________________________________________________________
void enregistrement_cibles(){
    // --------------------------- enregistrement des cibles dans le tableau tab_cibles ----------------------------------
    ptr_boucles++;          // nb boucles while(1) parcourues
    
    
// à la fin du premier tour de cirque on incrémente ptr_tour
    if (ptr_tour==&& next_checkpoint_x==tab_cibles[0][t_x] && ptr_cibles>1) {
        ptr_tour++;
        // et on en profite pour calculer signifier la plus grande distance
        int distmax=0, ptr=-1;
        for (int i=0; i<ptr_cibles; i++){
            if (tab_cibles[i][t_dist]>distmax){
                distmax=tab_cibles[i][t_dist];
                ptr=i;
            }
        }
        tab_cibles[ptr][t_meill_dist]=1;
    }
   
   
// pendant le 1er tour on enregistre les cibles dans le tableau tab_cibles[]
    if(ptr_tour==&& (old_cible_x != next_checkpoint_x )){
        tab_cibles[ptr_cibles][t_x]=next_checkpoint_x;      // pos x de la cible
        tab_cibles[ptr_cibles][t_y]=next_checkpoint_y;      // coord y de la cible
        tab_cibles[ptr_cibles][t_rang]=ptr_cibles;          // numero de la cible
        tab_cibles[ptr_cibles][t_nb_boucles]=ptr_boucles-tab_cibles[ptr_cibles-1][t_nb_boucles]; // nb boucles entre la cible et la précédente
        tab_cibles[ptr_cibles][t_dist]=distance_inter_cibles;// distance entre chaques cibles
        old_cible_x=next_checkpoint_x;
        old_cible_y=next_checkpoint_y;
        ptr_cibles++;
    }   
/*
    fprintf(stderr,"ptr_cibles=%i ptr_tour=%i\n",ptr_cibles, ptr_tour);
    for (int i=0;i<t_maxi;i++){
        if(i<=ptr_cibles && tab_cibles[i][t_x]!=0) {
            fprintf(stderr,"cible%i x=%i y=%i rang=%i dist=%i meill_dist=%i boucle=%i\n",i, tab_cibles[i][t_x], tab_cibles[i][t_y], tab_cibles[i][t_rang], tab_cibles[i][t_dist], tab_cibles[i][t_meill_dist], tab_cibles[i][t_nb_boucles]);
        }
    }
*/
    
}
 
Une porte nand prend 2 bits en entrée... cochonne va !!! :langue:

Pourquoi je n'arrive pas à me remettre aux PIC
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1420
Âge : 68
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#8 Message par paulfjujo » mar. 3 sept. 2019 14:52

bonjour,

F6FCO a écrit :
Pour exemple voici le programme qui m'a permis de passer en ligue de bronze:


:+1: On voit que tu maitrises déja bien le langage C

j'ai vu sur coding.com qu'ils ne proposent que le C# ou C++
mais apparament ton code est en C Classique ( genre TurboC 2.00 que j'ai bien pratiqué sur PC)
est-ce que tu t'es inscrit dans une equipe, un projet ouvert,
ou parts tu "from scracht" ( de zero) ?

j'ai parcouru le site vite fait et mes suis inscrit
car je voudrais m'interresser à Java et Python ( interface Application et page WEB)
mais Il me semble que c'est tres orienté JEU ..
et ça demande d'accepter des cookies à chaque coin de page .. c'est un peu dérangeant .
oops du coup, je me demande si j'ai bien fait d'aller là..?
Aides toi, le ciel ou Fantastpic t'aideras

Pourquoi je n'arrive pas à me remettre aux PIC
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 874
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#9 Message par F6FCO » mar. 3 sept. 2019 23:52

Bonsoir Paul,
J'avais un peu programmé le C il y a longtemps maisà l'époque n'ayant rien de concret à faire avec j'étais vite passé à autre chose, ensuite je m'y suis remis avec le pseudo C simplifié d'arduino. Quand j'ai découvert Codingame je me suis dit que c'était une bonne manière de m'y remettre plus sérieusement et de progresser.
Tes premières impressions sont un peu faussées, à priori on pourrait croire que c'est du jeu mais en réalité c'est bien des vrais problèmes de programmation et d'algorithmique déguisés en jeu pour les rendre plus attrayants. Le principe c'est la plateforme qui gère les graphismes, à toi de pondre le code qui va résoudre le problème.

A toi de choisir le ou les langages que tu vas utiliser, il y en a en gros une bonne quarantaine d'implémentés. Il y a beaucoup de codeurs qui utilisent Python et Java sur la plateforme. Pour ma part je me suis mis au C car çà me permettra d'être plus à l'aise en C PIC.

Par exemple les bots que je programme en ce moment sur le thème des courses de Racers dans le désert de Star Wars correspond tout à fait aux problèmes que je vais rencontrer quand je reprendrai le projet de mon bras robot piloté par PIC, coordonnées polaires et cartésiennes, sinus, cosinus, etc.
Chacun s'inscrit seul sur la plateforme et résoud seul ses énigmes mais on peut aussi se faire une liste d'"amis" avec lesquels on peut se confronter sur les mêmes problèmes, s'affronter et discuter sur la manière d'avancer.

Tu as plusieurs façons de participer:
- tu peux résoudre seul ce qu'ils appellent des puzzles qui ne sont rien d'autre que des petits problèmes de programmation et il y en a une foultitude, - tu peux programmer des bots, dans ce cas tu peaufine ton programme en local et quand tu te sens prêt tu le soumet et la plateforme se charge de le confronter au reste des codeurs de la planète entière ( il y a dans les 1500 000 codeurs inscrits tous pays confondus) et tu obtiens un classement, ensuite tu peux peaufiner ton programme pour le rendre plus performant encore et encore. Tu peux suivre les derniers combats de tes confrontations, c'est très instructif pour comprendre ou pêche ton programme et ce qu'il y a à améliorer, dans ce cas tu fais tes modifs en local, tu le re-soumet et tu vois ce que çà donne.
- tu peux aussi t'inscrire à des petits challenges de codage qui durent entre 5 et 15mn, genre on te donne des données d'entrées et celles de sortie, à toi de trouver le code qui va bien pour faire çà, ou bien un pbm à résoudre le plus vite possible, ou bien à faire le code le plus concis possible, etc.
- Il y a aussi des compétitions de code qui durent 1 semaine mais çà ne n'ai pas essayé.

Bizarre pour les cookies, çà ne me le fait pas ici. Tu es bien sur Codingame.com ?
Une porte nand prend 2 bits en entrée... cochonne va !!! :langue:

Pourquoi je n'arrive pas à me remettre aux PIC
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 874
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#10 Message par F6FCO » ven. 6 sept. 2019 09:10

Bonjour Paul et les autres,

Comme ce n'est pas du C Pic je n'ai pas osé poster sur le forum C mais j'ai un petit dilemme, je bloque dessus depuis hier am:.

Code : Tout sélectionner

double essai=4/2


Donne la valeur 2, normal.

Code : Tout sélectionner

double essai=2/4


Donne 0.000000 au lieu de 0.5 :sad:

J'ai essayé avec d'autres types mais pareil:

Code : Tout sélectionner

Float essai=2/4


Code : Tout sélectionner

long double=2/4


même chose, une idée ?
Une porte nand prend 2 bits en entrée... cochonne va !!! :langue:


Retourner vers « Coin Fourre-tout »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 0 invité