typedef struct
{
  int position_en_x;
  int position_en_y;
  union {
    unsigned short *pU16;
    unsigned char *pU8;
  };
}

struct s_graphics
{
  // Les données qui représentent ton espace graphique (par exemple tes écrans virtuels)
  void *light_screen,*dark_screen;
};

struct s_drawable
{
  void (*draw)(void *this,short x,short y,struct s_graphics *g);
};

struct s_sprite8
{
  struct s_drawable drawable;
  short h;
  unsigned char *data;
};

struct s_sprite16
{
  struct s_drawable drawable;
  short h;
  unsigned short *data;
};

enum e_mario_size {Mario_PETIT,Mario_GRAND};

struct s_mario
{
  struct s_drawable *sprite;
  short x,y;
  enum e_mario_size size;
};

enum e_sprite_id {Sprite_MARIO_PETIT,Sprite_MARIO_GRAND};

extern short sprites_h[];
extern void *sprites_data[];


void Graphics_init(struct s_graphcis *this,void *light_screen,void *dark_screen)
{
  this->light_screen = light_screen;
  this->dark_screen = dark_screen;
}

Sprite8_draw(struct s_sprite8 *this,short x,short y,struct s_graphics *g)
{
  // Appel d'une fonction d'extgraph
  GraySprite8_OR(this->data,x,y,this->h,g->light_screen,g->dark_screen);
}

Sprite8_init(struct s_sprite16 *this,short h,unsigned char *data)
{
  this->h = h;
  this->data = data;

  this->drawable.draw = Sprite8_draw;
}

Sprite16_draw(struct s_sprite16 *this,short x,short y,struct s_graphics *g)
{
  // Appel d'une fonction d'extgraph
  GraySprite16_OR(this->data,x,y,this->h,g->light_screen,g->dark_screen);
}

Sprite16_init(struct s_sprite16 *this,short h,unsigned short *data)
{
  this->h = h;
  this->data = data;

  this->drawable.draw = Sprite16_draw;
}

void Mario_init(struct s_mario *this,short x,short y)
{
  this->x = x;
  this->y = y;
  this->size = Mario_PETIT;

  this->sprite = loadSprite(Sprite_MARIO_PETIT);
}

void Mario_quit(struct s_mario *this)
{
  free(this->sprite);
}

void Mario_draw(struct s_mario *this,struct s_graphics *graphics)
{
  this->sprite->draw(this->sprite,this->x,this->y,graphics);
}

void Mario_move(struct s_mario *this,short x,short y)
{
  this->x = x;
  this->y = y;
}

void Mario_grandit(struct s_mario *this)
{
  this->size = Mario_GRAND;
  free(this->sprite);
  this->sprite = loadSprite(Sprite_MARIO_GRAND);
}

struct s_drawable *loadSprite(enum e_sprite_id id)
{
  switch(id)
  {
  case Sprite_MARIO_PETIT:
    {
      struct s_sprite8 *sprite = malloc(sizeof(struct s_sprite);
      Sprite8_init(sprite,sprites_h[id],sprites_data[id]);
      return &(sprite->drawable);
    }
    break;

  case Sprite_MARIO_GRAND:
    {
      struct s_sprite16 *sprite = malloc(sizeof(struct s_sprite16));
      Sprite16_init(sprite,sprites_h[id],sprites_data[id]);
      return &(sprite->drawable);
    }
    break;
  }
}

void _main(void)
{
  if(!GrayOn())
    return;

  struct s_graphics graphics;
  Graphics_init(&graphics,GrayGetPlane(LIGHT_PLANE),GrayGetPlane(LIGHT_PLANE));

  struct s_mario mario;
  Mario_init(&mario,0,0);

  Mario_draw(&mario,&graphics);
  Mario_move(&mario,50,50);
  Mario_grandit(&mario);
  Mario_draw(&mario,&graphics);

  Mario_quit();
  GrayOff();
}

typedef void (*spritefunc_t)(short x, short y, short height, const void *sprite, void *vm_addr, short mode);

typedef struct sprite {
 void *data_d;
 void *data_l;
 void *data_m;
 unsigned short h;
 spritefunc_t drawfunc;
} sprite;

unsigned char smallmario_d[8]={1,2,3,4,5,6,7,8};
unsigned char smallmario_l[8]={1,2,3,4,5,6,7,8};
unsigned char smallmario_m[8]={1,2,3,4,5,6,7,8};
unsigned short bigmario_d[16]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
unsigned short bigmario_l[16]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
unsigned short bigmario_m[16]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
sprite sprites[]={{smallmario_d,smallmario_l,smallmario_m,8,(spritefunc_t)Sprite8},
                  {bigmario_d,bigmario_l,bigmario_m,16,(spritefunc_t)Sprite16}};

void DrawSprite(sprite *s, short x, short y)
{
  s->drawfunc(x,y,s->h,s->data_m,GrayGetPlane(DARK_PLANE),SPRT_AND);
  s->drawfunc(x,y,s->h,s->data_m,GrayGetPlane(LIGHT_PLANE),SPRT_AND);
  s->drawfunc(x,y,s->h,s->data_d,GrayGetPlane(DARK_PLANE),SPRT_OR);
  s->drawfunc(x,y,s->h,s->data_l,GrayGetPlane(LIGHT_PLANE),SPRT_OR);
}