champion 2008 , coucou747

Publié mercredi 14 mai 2008 18:29 par coucou747

champion 2008

prologin s'acheve sur une dure bataille de pommes :)

je vous passe mon "champion"

 * _   _                     _            _
 *| | | | __ _ _ __ ___  ___| |_ ___ _ __( )___  __      ____ _ _ __
 *| |_| |/ _` | '_ ` _ \/ __| __/ _ \ '__|// __| \ \ /\ / / _` | '__|
 *|  _  | (_| | | | | | \__ \ ||  __/ |    \__ \  \ V  V / (_| | |
 *|_| |_|\__,_|_| |_| |_|___/\__\___|_|    |___/   \_/\_/ \__,_|_|

ouais, bon, jme suis fait plaisir sur l'ascii art :)

/*
 * Champion (ou pas) prologin 2008 (rendu le 10 mai 2008)
 *
 * Style de programmation
 *   les fonctions devront faire une seule chose, une chose precise, et la faire bien.
 *   J'ai choisi quelques variables globales pour stoquer mes donnees
 *
 *
 * Strategie envisagees (en resume...) :
 *     - aller chercher et ramener des pommes dans ma zone
 *     - tirer sur quelques ennemis (quand ca a l'air interessant
 *     - sauver quelques hamsters lorsqu'ils tombent dans une fosse
 *     - tenter de traverser quelques ravins

On gere le moteur general par une liste d'etats,
et des pointeurs sur fonctions pour gerer les operations de facon assez abstraite.

Tirer
  seulement lorsque c'est notre tour de jouer en premier, histoire de ne pas
  gaspiller nos precieux trognons.
  Je n'envoie aussi des trognons dans la gueule de nos ennemis,
  que quand ils sont en face, histoire de ne pas perdre trop de temps.
  Si notre enemie ne tombe pas dans une fosse,
  alors il est inutile d'envoyer un trognon.

Se deplacer
  On se deplace vers la pomme la plus proche qui n'est pas occupee par nos mecs.
  Ensuite, on ramene les pommes dans notre zone pour recommencer.

  Quand un hamster tombe dans la fosse, c'est chiant,
  faut qu'un autre aille tenter de le sauver, mais je sais pas trop si ca fonctionne bien...

  Quand on n'a rien a faire (pommes innaccessibles par exemple) on devrait chercher a aller
  de l'autre cote des fosses (fonction bouge_ton_cul) mais en pratique,
  c'est tres difficile de gerer correctement le grapin, et donc...

Les sauver (tentative morbide a base de "je te pousse")

Les points forts de mon IA : sa recuperation de points, son cote safe, et son attaque.

*/

#include "prologin.h"
#include <stdlib.h>
#include <stdio.h>


//! Notre structure de donnees copeaux de bois.
typedef struct {
  //int pomme;
  int sol; //! peut-etre normal, un obstacle ou un trou
  int x, y; //! ses coordonnees
} copBois;

struct hamstruct;
//! notre type de pointeurs sur fonctions
// ces fonctions sont des fonctions d'actions
typedef void (*HamAction)(struct hamstruct *h, int toD);

struct hamstruct {
  int id; // son id
  int x, y; // la position de notre hamestere
  int toD[3]; // les parametres des actions de notre hamstere (to Direction)
  HamAction actions[3]; // les trois actions de notre jambon (ou hamster, je sais plus)

  int used_ordres; // le nombre d'ordres qu'il utilise

  int traverse; // si il a droit de traverser un fosse ou pas

  int Ntrognons; // le nombre de trognons qu'il lui reste a prendre
  int Hpomme;   // ca aurait pu etre utile, mais en fait non...
  int mission;

  int utile;   // dit si sa mission est vraiemnt importante ou pas;

  int mtx, mty;  // mission target x. y

  int s; // quand on a besoin de suivre qqn

  int m; // l'etat du grapin
  int timefreeze, opx, opy;
};

typedef struct hamstruct ham;

#define GR if (r!=SUCCESS) printf("747---bad argument hamster %d ligne %d erreur %d\n\n", h->id, __LINE__, r);
#define HAMSTER_NOMBRE 3
#define NTROGNONS      2

#define CHERCHER_POMMES 0
#define TOMBER_POMMES   1
#define RAMASSER_POMMES 2
#define POMMES_SAVEHOME 3
#define PROTEGER_POMMES 4
#define SUIVRE          5
#define GRAPPINER       6

//! ma valeur absolue
int mabs(int a){
  if (a<0) return -a; return a;
}

void decider(ham *h); //! prototype de la fonction de decision.

//! les fonctions de type HamAction.

//! fonction de deplacement
void aller(ham *h, int toD){
  //printf("747---deplacement du hamster %d, vers %d\n",
  //   h->id, toD  );
  int r = deplacer(h->id, toD); GR
}
//! fonction qui lache une pomme 
void lacher(ham *h, int toD){
  printf("747---le hamster %d, lache une pomme en %d, %d\n",
   h->id, h->x, h->y  );
  int r = lacher_pomme(h->id, toD); GR
}
//! fonction de ramassage de pomme
void ramasser(ham *h, int toD){
  printf("747---le hamster %d, ramasse une pomme en %d, %d\n",
     h->id, h->x, h->y  );
  int r = ramasser_pomme(h->id); GR
}
//! fonction qui sert a poser le grapin sur un ham
void grappiner(ham *h, int toD){
  printf("747---le hamster %d, grappine en %d\n",
     h->id, toD );
  int r = grappin(h->id, toD); GR
}
//! fonction qui envoie un trognon sur un ham
void trogner(ham *h, int toD){
  printf("747---le hamster %d, trogne en %d\n",
     h->id, toD );
  int r = trognon(h->id, toD); GR
}
//! fonction de repos d'un hamstere
void patienter(ham *h, int toD){
  //printf("747--- Le hamster %d ne fout rien\n", h->id);
  int r=attendre(h->id); GR
}
/*
Ces fonction auraient pu etres utilisees, je les ai codees quand j'etais 
+
*/

/*
int getX(int pos){
  return pos & 0xFFFF;
}
int getY(int pos){
  return (pos & 0xFFFF0000 ) >> 16;
}
int pos(int x, int y){
  return x + ( y << 16) ;
}
*/


//! dit si c'est ta zone
int macase(int x, int y){
  return y==0 || y==1;
}


// VAR globales

copBois *cases, **map; // la map
int sx, sy, tmap, /* size x, y, taille map*/
  end; /* nombre de tours */

ham hamster[HAMSTER_NOMBRE]; // les hamsters

int haswhite; // dit si on a les blancs ce tour la ou pas.

//int strategie; // soit on met 1, soit 3

// dit si la position est valide ou non
int isValidPos(int x, int y){
  return x>=0 && x < sx && y < sy && y >=0;
}

//! met a jours l'etat de la case *o au niveau des pommes
//void updatePomme(copBois *o){
//  o->pomme = pomme(o->x, o->y);
//}
//! dit ou un gars est
void tayou(ham *h){
  int x, y;
  x=pos_x(h->id);
  y=pos_y(h->id);
  h->Hpomme= porte_pomme(h->id);

  if (x==h->opx && y==h->opy){
    h->timefreeze++;
  }else{
    h->timefreeze=0;
  }
  h->opx=x; h->opy=y;

  h->x=x;
  h->y=y;
}
//! fait bouger un gars
void agir(ham *h){
  int i;

  printf("747---HAMSTER %d -- %d-- mission : %d, (%d, %d) %d\n",
   h->id, h->traverse, h->mission, h->mtx, h->mty, h->utile);

  for (i=0;i<h->used_ordres;i++){
    h->actions[i](h, h->toD[i]);
  }
}
//! dit si un hamster veut deja aller en cette position
int people_has(int x, int y){
  int i;
  for(i=0;i<HAMSTER_NOMBRE; i++ ){
    if (hamster[i].mtx ==x && hamster[i].mty == y) return 1;
  }
  return 0;
}


//! fonction qui trouve une pomme interessante a ramenner
int findPomme(ham *h){
  int x, y, bx=-1, by=-1, minT=9999, d;
  for (x=0;x<sx; x++){
    for (y=0;y<sy;y++){
      if ((!macase(x, y)) && NORMAL == map[x][y].sol && pomme(x, y)){
        if (people_has(x, y)) continue; // si qqn s'occupe deja de cette pomme
  d=distance(x, y, h->x, h->y, h->traverse);
        if (d < minT){
    bx=x; by=y; minT=d;
  }
      }
    }
  }
  //printf("747---pomme interessante en %d, %d (%d, %d, t=%d)\n",
  //  bx, by, h->x, h->y, minT);
  h->mtx = bx;
  h->mty = by;
  if (h->mtx == -1 && h->mty == -1){
    h->mtx=0; h->mty=0;
    // on a deja toutes les pommes
    return 0;
  }else{
    return 1;
  }
}
//! applique une direction a une position
void applyDir(int x, int y, int d, int *dx, int *dy){
  switch(d){
  case HAUT:
    *dy=y-1; *dx=x;
    break;
  case GAUCHE:
    *dy=y; *dx=x-1;
    break;
  case BAS:
    *dy=y+1; *dx=x;
    break;
  case DROITE:
    *dy=y; *dx=x+1;
    break;
  default:
    printf("747---ERREUR DE PARAMETRE %d\n\n", __LINE__);
    break;
  }
}
//! dit si un hamster est en x, y (donc si on le pousserait en y allant)
int jepousse(int x, int y){
  int i;
  for (i=0;i<3;i++){
    if (hamster[i].x==x && hamster[i].y==y){
      return 1;
    }
  }
  return 0;
}
//! cherche la direction pour aller a h
int allera(ham *h){
  int i, p=ICI, x, y, dmin=-1, d;

  if (h->x==h->mtx && h->y==h->mty)
    return ICI;
  for (i=0;i<4;i++){
    applyDir(h->x, h->y, i, &x, &y);
    if (jepousse(x, y)) continue;  // on interdit de pousser son partenaire
    if (isValidPos(x, y)){
      // fake pour eviter les cases tranchees
      d= distance(x, y, h->mtx, h->mty, h->traverse)*2 + (map[x][y].sol!=NORMAL);
      if (dmin==-1 || d < dmin){
  //printf("747---d = %d  %d\n", d, i);
  dmin=d;
  p=i;
      }
    }
  }
  return p;
}

// organise le retour a la maison d'une pomme
void retour_maison(ham *h){
  int d;

  if (!porte_pomme(h->id)){
    //h->mission = CHERCHER_POMMES;
    //decider(h);
    //return;
  }

//printf("747--- Retour maison\n");
  // on definit la nouvelle destination
  h->mtx=0; h->mty=0;
  while (pomme(h->mtx, h->mty) || NORMAL != map[h->mtx][h->mty].sol ){
    h->mtx++;
    if (h->mtx==sx){
      h->mty++; h->mtx=0;
    }
    //printf("747--- CASE NOT EMPTY !!! %d %d\n", h->mtx, h->mty);
  }
  d=allera(h);
  if (d==ICI){ // si tu deposes la pomme
//printf("747--- Bienvenu a la maison !\n");
    h->actions[h->used_ordres]=lacher;
    h->toD[h->used_ordres]=d;
    h->used_ordres++;
    h->mission=CHERCHER_POMMES;
  }else{ // deplacement vers la maison
    //printf("747--- On va en %d %d\n", h->mtx, h->mty);
    h->actions[h->used_ordres]=aller;
    h->toD[h->used_ordres]=d;
    h->used_ordres++;
    applyDir(h->x, h->y, d, &h->x, &h->y);
  }
}

//! protege les pommes
void blinde_home(ham *h){
//printf("747---On blinde nos pommes\n");
  int d;
  
  while (NORMAL != map[h->mtx][h->mty].sol ){
    h->mtx++;
    if (h->mtx==sx){
      h->mty++; h->mtx=0;
    }
  }
// printf("747---On sait ou on va\n");
  d=allera(h);
  if (d==ICI){ // si tu dois changer de mission
    h->actions[h->used_ordres]=patienter;
    h->toD[h->used_ordres]=d;
    h->used_ordres++;
    h->mission=CHERCHER_POMMES;
  }else{ // deplacement vers la maison
    h->actions[h->used_ordres]=aller;
    h->toD[h->used_ordres]=d;
    h->used_ordres++;
    applyDir(h->x, h->y, d, &h->x, &h->y);
  }
}

//! dit si les cases sont a cote ou non
int isnear(ham *h1, ham *h2){
  int ax=mabs(h1->x - h2->x);
  int ay=mabs(h1->y - h2->y);
  return (ax==0 && ay==1 ) || (ax==1 && ay==0);
}
//! donne la direction pour aller d'un point a un autre
int directionde(int x1, int y1, int x2, int y2){
  if (y1<y2) return BAS;
  if (x1<x2) return DROITE;
  if (y1>y2) return HAUT;
  return GAUCHE;
}
//! pose un grapin
void ograppiner(ham *h1, ham *h2){
  printf("747--- grappin %d ----) %d\n", h1->id, h2->id);
  h1->actions[h1->used_ordres]=grappiner;
  h1->toD[h1->used_ordres]=directionde(h2->x, h2->y, h1->x, h1->y);
  printf("747--- On grapine en %d\n", h1->toD[h2->used_ordres]);
  h1->used_ordres++;
}
//! renvoie la direction opposee
int oltherd(int d){
  switch (d){
  case HAUT: return BAS;
  case BAS: return HAUT;
  case DROITE: return GAUCHE;
  case GAUCHE: return DROITE;
  default: return ICI;
  }
}
//! fonction principale de suivit d'une unitee
void suivre_p(ham *h1, ham *h2){
  printf("747---Suivre\n");
  int d;
  h1->traverse=1;
  h1->mtx = h2->x;
  h1->mty = h2->y;
  if (isnear(h1, h2)){
    if (map[h2->x][h2->y].sol!=NORMAL){
      d=directionde(h1->x, h1->y, h2->x, h2->y);
  h1->mission=GRAPPINER;
  h1->s=h2->id;
  h1->m=0;
      return;
    }else{
      d=ICI;
    }
  }else{
    d=allera(h1);
  }

  if (d==ICI){
    printf("747--- t'es sur le mec que tu suis...\n");
    h1->actions[h1->used_ordres]=patienter;
    h1->toD[h1->used_ordres]=ICI;
    h1->used_ordres++;
  }else{
    h1->actions[h1->used_ordres]=aller;
    h1->toD[h1->used_ordres]=d;
    h1->used_ordres++;
    applyDir(h1->x, h1->y, d, &h1->x, &h1->y);
    if (h1->x == h2->x && h1->y == h2->y){
      applyDir(h2->x, h2->y, d, &h1->x, &h1->y);
    }
  }
  h1->traverse=0;
}

//! verifie si un mur horizontale est present
int murdeaH(int x, int xe, int y){
  for (; x<=xe;x++){
    if (map[x][y].sol == OBSTACLE){
      return 1;
    }
  }
  return 0;
}
//! verifie si un mur vertical est present
int murdeaV(int x, int y, int ye){
  for (; y<=ye;y++){
    if (map[x][y].sol == OBSTACLE){
      return 1;
    }
  }
  return 0;
}
// dit si on a un interret a balancer le truc
int Hinteret(int x, int y, int d){
  while (isValidPos(x, y)){
    if (map[x][y].sol == TRANCHEE) return 1;
    applyDir(x, y, d, &x, &y);
  }
  return 0;
}

// shot l'ennemy (a base de trognons de pommes)
int hamstershot(ham *h, int can){
  //return 0;
  int i, ex, ey, d=ICI, p;
  if (!can) return 0;
  if (h->Ntrognons==0) return 0;
  for (i=3;i<6;i++){
    ex = pos_x(i);
    ey = pos_y(i);
    p=porte_pomme(i);
    //printf("747---- |||||||||||||| EX=%d\tEY=%d  IAMIN %d %d\n", ex, ey, h->x, h->y);
    if (ey == h->y){
      if ( ex < h->x ){
  if (murdeaH(ex, h->x, ey)) continue;
  if (ex==0) continue;
  if (Hinteret(ex, ey, GAUCHE) || p) d=GAUCHE;
      }else{
  if (murdeaH(h->x, ex, ey)) continue;
  if (ex==sx-1) continue;
  if (Hinteret(ex, ey, DROITE) || p) d=DROITE;
  //printf("747--- SHOT !!!!\n");
      }
    }else if (ex == h->x){
      if ( ey < h->y ){
  if (murdeaV(ex, ey, h->y)) continue;
  if (ey==0) continue;
  if (Hinteret(ex, ey, HAUT) || p) d=HAUT;
      }else{
  if (murdeaV(ex, h->y, ey)) continue;
  if (ey==sy-1) continue;
  if (Hinteret(ex, ey, BAS) || p) d=BAS;
      }
    }
  }
  if (d!=ICI){
    h->actions[h->used_ordres]=trogner;
    h->toD[h->used_ordres]=d;
    h->used_ordres++;
    h->Ntrognons--;
    printf("747---SHOT %d\n", d);
    return 1;
  }else{
    return 0;
  }
}

// lance le suivi d'un ami, pour lui permettre de traverser, ou le sauver
void suivre(ham *h, int suivreId, int pt){
  h->mission = SUIVRE;
  h->s = suivreId;
  h->m=pt;
}

// la fonction qui envoie un hamstere dans les tranchees
void bouge_ton_cul(ham *h){
  if (h->traverse) return;
  printf("747---Le hamstere %d bouge enfin le cul et va par delas des ravins\n", h->id);
  h->mission = CHERCHER_POMMES;
  h->traverse = 1;
}

//! fonction qui decide ce qu'un hamster fait
void decider(ham *h){
  int d;
  if (hamstershot(h, haswhite)) return;

  if (h->mission == CHERCHER_POMMES){
    if (findPomme(h)){
      h->mission=RAMASSER_POMMES;
      h->utile = 1; // mec utile
    }else{
      h->mission=PROTEGER_POMMES;
      h->utile=0; // mec inutile
    }
  }
  if (h->mission == PROTEGER_POMMES){
    blinde_home(h);
    h->utile = 0; // mec inutile
  }else  if (h->mission == RAMASSER_POMMES){
    h->utile = 1; // mec utile
    d=allera(h);
    if (d==ICI){
      printf("747--- pomme spotted\n");
      h->mission = POMMES_SAVEHOME; // on decide de rameter la pomme a la maison
      h->actions[h->used_ordres]=ramasser; // on ramasse la pomme
      h->used_ordres++;
    }else{
      h->actions[h->used_ordres]=aller;
      h->toD[h->used_ordres]=d;
      h->used_ordres++;
      //printf("747--- d=%d    (%d %d)\n", d, h->x, h->y);
      applyDir(h->x, h->y, d, &h->x, &h->y);
    }
  }else if ( h->mission == POMMES_SAVEHOME ){
    retour_maison(h); // on ramene la pomme a la maison

  }else if (h->mission == GRAPPINER){
    if (h->m==0){
      h->m=1;
      ograppiner(h, &hamster[h->s]);
    }else{
      h->traverse=0;
      h->mission=CHERCHER_POMMES;
      decider(h);
    }
  }else if (h->mission == SUIVRE){
    suivre_p(h, &hamster[h->s]);
  }
}
void resetHamster(ham *h){
  h->mission=CHERCHER_POMMES;
  h->timefreeze=0;
  h->traverse=0;
}
//! mise a jours des pommes
/*id pommes_update(){
  int i;
  for (i=0;i<HAMSTER_NOMBRE;i++){
  }
  }*/
//! fonction d'initialisation
void init_game(void)
{
  int i, j;
  copBois *o;

  // initialisation de la taille de la map
  sx=taille_carte_x();
  sy=taille_carte_y();
  tmap = sx * sy;
  // initialisation du temps
  end = nombre_tours();
  // initialisation des cases memoires
  cases = (copBois *) malloc(sx * sy * sizeof(copBois));
  map = (copBois **) malloc(sx * sizeof(copBois *));
  // initialisation des pointeurs vers la map
  for (i=0;i<sx;i++){
    map[i]=cases + sy * i;
  }
  // initialisation de la map
  for (i=0;i<sx;i++){
    for (j=0;j<sy;j++){
      o=&map[i][j];
      o->x = i;
      o->y = j;
      o->sol = type_case(i, j);
      //datePomme(o);
    }
  }
  // initialisation des hamsters
  for (i=0; i< HAMSTER_NOMBRE;i++){
    hamster[i].id=i;
    resetHamster(&hamster[i]);
    hamster[i].Ntrognons=NTROGNONS;
    hamster[i].utile = 0;
    hamster[i].x=-1; hamster[i].y=-1; 
    for (j=0;j<3;j++)
      hamster[i].actions[j]=patienter;
    //    tayou(&hamster[i]);
  }
  //strategie = 1;
}


//! fonction principale, appellee a chaque tour
void play_turn(void)
{
  int i;
  int now = numero_tour();
  haswhite = commence();
  int turn;
  int ne=-1;

  printf("747--- TOUR %d\n", now);

  // on recherche nos hamsters
  for (i=0; i< HAMSTER_NOMBRE;i++){
    tayou(&hamster[i]);   // ou est le hamster
    hamster[i].used_ordres=0;
    if (hamster[i].timefreeze >= 4){
      printf("747--- TIMEFREEZE %d %d\n", i, hamster[i].timefreeze);
      resetHamster(&hamster[i]);
    }
  }


  // pommes_update(); // on update quelques infos de la map

  // on decide de bouger
  for (turn=0;turn<3;turn++){
    int fait=0;
    for (i=0;i<HAMSTER_NOMBRE;i++){
      if (hamster[i].used_ordres <=turn){
  printf("747---Decision du tour : %d du hamster %d (%d)\n",
         turn, i, NORMAL==map[hamster[i].x][hamster[i].y].sol,
         hamster[i].timefreeze);
  if (ne!=-1){
    suivre(&hamster[i], ne, 0);
  }else{
    if (map[hamster[i].x][hamster[i].y].sol != NORMAL && hamster[i].traverse==0){
      ne=i;
    }
    // on ne bouge que sur un sol normal
    decider(&hamster[i]);
    if (hamster[i].utile)
      fait=1;
  }
      }
    }
    if (!fait){
      // bouge_ton_cul(&hamster[1]);
      //suivre(&hamster[2], 1, 1);
    }
  }
  // on bouge (donne les ordres)
  for (i=0;i<HAMSTER_NOMBRE;i++){
    agir(&hamster[i]); //break;
  }
  printf("747--- FIN TOUR\n");
}

Prologin 2008 : la bataille des pommes

j'aurais bientot mon classement, il reste encore quelques bugs (pour passer les tranchees) mais il faisait pas mal de points :)

Ce post vous a plu ? Ajoutez le dans vos favoris pour ne pas perdre de temps à le retrouver le jour où vous en aurez besoin :

Classé sous programmation, geek, Fun, champion, prologin
Attachment(s): audouinm.zip

# re: champion 2008 @ mercredi 14 mai 2008 20:05

Pourquoi avoir laissé les 70 retour chariot de fin ?

Pour le reste je ne fais plus de C depuis bien longtemps et ca ne me manque pas perso ;)

Fabrice

ROMELARD Fabrice

# re: champion 2008 @ mercredi 14 mai 2008 20:44

tsais, faire du C# a prologin, c'est pas possible, faire du java, c'est suicidaire, faire du pascal aussi...

faire de l'ocaml c'est une bonne idee, mais a mon avis, ca ne t'aurait pas beaucoup plu non plus...

coucou747

# re: champion 2008 @ mercredi 14 mai 2008 22:45

Pourquoi faire du java c'est sucidaire ? à l'époque j'avais fais en java et je ne m'en étais pas trop mal sorti :)

Alexandre Marlot

# re: champion 2008 @ mercredi 14 mai 2008 23:07

parfois, le serveur ne marche pas correctement, et pour certains langages, c'est clairement pas a leur avantage...

le serveur est fait en Cpp, donc pour ceux qui font du C ou Cpp, ils sont SUR d'avoir au moins a minuit, un code qui fonctionne... pour java, peut-etre, peut-etre pas :)

coucou747

# re: champion 2008 @ jeudi 15 mai 2008 10:35

Oué mais dans mon cas ça avait marché. Nous avions juste eu quelques petits problèmes d'allocation mémoire puisque java prenait trop de mémoire mais il avait enlever la limite et ca avait tout de suite marcher mieux :)

Les résultats ne sont pas communiqué dès le lendemain matin ?

Alexandre Marlot

# re: champion 2008 @ jeudi 15 mai 2008 10:42

je ne suis pas parmi les 10 premiers cette annee... donc non, faudra attendre quelques jours

coucou747

Les 10 derniers blogs postés

- ssdl view et TPT par Matthieu MEZIL le il y a 23 heures et 17 minutes

- L'injection SQL n'est PAS un problème QUE pour les développeurs web ! par CoqBlog le 07-05-2008, 01:08

- Un outil pour réaliser des animations WPF basées sur des équations de Bézier par Perspective le 07-04-2008, 21:45

- Sandcastle et CodePlex : le verdict par CoqBlog le 07-04-2008, 20:53

- ssdl view et TPH par Matthieu MEZIL le 07-04-2008, 19:12

- Webcasts sur le Parallel Framework disponibles par Matthieu MEZIL le 07-04-2008, 17:26

- [Silverlight] - Comprendre et Débuter avec Silverlight par Danuz le 07-04-2008, 12:41

- SharePoint : Nouvel article sur l'exportation et Importation de sites SharePoint par Blog Technique de Romelard Fabrice le 07-04-2008, 01:00

- ImagineCup 2008 Final in Paris: Day 1 par Richard Clark le 07-03-2008, 22:48

- PowerShell : Comment utiliser un ENUM .NET dans un script PowerShell par Blog Technique de Romelard Fabrice le 07-03-2008, 18:09

Posts récents

Ce blog

Catégorie des messages

Archives

champion 2008

# re: champion 2008 @ mercredi 14 mai 2008 20:05

# re: champion 2008 @ mercredi 14 mai 2008 20:44

# re: champion 2008 @ mercredi 14 mai 2008 22:45

# re: champion 2008 @ mercredi 14 mai 2008 23:07

# re: champion 2008 @ jeudi 15 mai 2008 10:35

# re: champion 2008 @ jeudi 15 mai 2008 10:42