Editor de fase para um futuro clone do Super Mario Bros que estou implementando.
Por enquanto está bem simples, mas brevemente irei aperfeiçoá-lo. Com ele você pode editar/criar um novo mapa. Aperte espaço para mudar o title e clique com o botão do mouse na janela que se abre para mudar as imagens. Como sempre, acompanha uma versão pré-compilada.

Para compilar:
    $ gcc -o level_editor level_editor.c -lSDL

Para executar:
    $ ./level_editor

Vlw!!!

• Download MLevel_editor.tar.gz
• Enviar nova versão

Esconder código-fonte

/*
  Feito em 23/04/2009 às 13:00, by Sam L.

  Editor de fase para o super mario bros que estou implementando.
  Por enquanto está bem simples esse editor, mas brevemente irei aperfeiçoá-lo.
  Com ele você pode editar/criar um novo mapa. Aperte espaço para mudaro tile e 
  clique com o botão do mouse na janela que se abre para mudar as imagens.
  Como sempre, acompanha uma versão pré-compilada.
  Para compilar:
    $ gcc -o level_editor level_editor.c -lSDL
  Para executar:
    $ ./level_editor

  vlw!!!
*/

#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <SDL/SDL.h>

#define  FPS          30
#define  BPP          32
#define  FLAGS        ((SDL_SWSURFACE | SDL_HWSURFACE) | SDL_ANYFORMAT | SDL_HWACCEL | SDL_RLEACCEL | SDL_DOUBLEBUF )

/*Numero máximo de tile na vertical e horizontal*/
#define  MAP_W_MAX    30
#define  MAP_H_MAX    16

#define  TILESIZE     32 /*Largura do tile*/
#define  TILE_MAX     13 /*Numero máximo de tiles*/

/*Aqui é para armazenar o mapa*/
FILE *file_map;
char mapa[MAP_H_MAX][MAP_W_MAX];


/*========Protótipos das funções==============*/
void Cont_fps(Uint32 time_now);
void LoadLevel(const char *filename);
void SaveLevel(const char *filename);
void DrawMap(SDL_Surface *tiles, SDL_Surface *screen);
void DrawFoco(SDL_Surface *surf, int x, int y, SDL_Surface *screen);

int main(int argc, char *argv[])
{
  int  coor_x, coor_y;
  int  index = 0;
  int  done = 0;
  Uint32  time_now;
  char *mapname;
  char option[] = {'.','a','b','c','d','e','f','g','h','i','j','k','l'};

  SDL_Surface *screen, *tiles, *mfoco;
  SDL_Event event;

  tiles = SDL_LoadBMP("imagens/smb.bmp");
  mfoco = SDL_LoadBMP("imagens/foco.bmp");

  if(SDL_Init(SDL_INIT_VIDEO) < 0)
     {
       printf("ERROR: %s\n", SDL_GetError());
       exit(1);
     }

  if((tiles == NULL) || (mfoco == NULL))
     {
       printf("ERROR: %s\n", SDL_GetError());
       exit(1);
     }


  if(argc > 2)
     {
       printf("Usage: %s <mapa_jah_criado>\n", argv[1]);
       printf("Você pode carregar o \"demo_level.map\" que está no pacote tar.gz\n");
       exit(1);
     }
  else if( argc == 2)
          {
            /*Carregando um level anterior*/
            strcpy(mapname, (const char *)argv[1]);
            LoadLevel(mapname);
          }
  else
     {
      //NOTE: Sempre será excluido esse default_level
      /*Inicializando com o nome padrão para o mapa*/
       strcpy(mapname, "default_level.map");
      /*inicializando o mapa*/
       memset(mapa, '.', sizeof(mapa));
     }
 /*Setando uma cor chave na imagem mfoco, no caso é a cor branca*/
  SDL_SetColorKey(mfoco, SDL_RLEACCEL | SDL_SRCCOLORKEY, SDL_MapRGB(mfoco->format, 255, 255, 255));

  screen = SDL_SetVideoMode(MAP_W_MAX*TILESIZE,  MAP_H_MAX*TILESIZE, BPP, FLAGS);
  if(screen == NULL)
     {
       printf("ERROR: %s\n", SDL_GetError());
       exit(1);
     }
  SDL_WM_SetCaption("Level_Editor 0.1 -> by Sam L.", NULL);
  while(!done)
        {
          time_now = SDL_GetTicks();
          while(SDL_PollEvent(&event))
                {
                 /* Pegando as coordenadas do cursor no screen */
                  SDL_GetMouseState(&coor_x, &coor_y);

                 /* Transformando as coordenadas do screen em coordenadas do mapa */
                  coor_x = coor_x/TILESIZE;
                  coor_y = coor_y/TILESIZE;
      //achei melhor separar os eventos
                  if(event.type == SDL_QUIT)
                     {
                       done = 1;
                     }

                  if(event.type == SDL_MOUSEBUTTONDOWN)
                     {
                       mapa[coor_y][coor_x] = option[index];
                     }

                  if(event.type == SDL_KEYDOWN)
                     {
                       if(event.key.keysym.sym == SDLK_SPACE)
                          {
                            if(index < (TILE_MAX - 1))
                               {
                                 index = index + 1;
                               }
                            else
                                {
                                  index = 0;
                                }
                            printf("IMAGEM_NUMERO:::%d\n",index);
                          }
                     }
                }

          DrawMap(tiles, screen);
          DrawFoco(mfoco, coor_x*TILESIZE, coor_y*TILESIZE, screen);
          SDL_UpdateRect(screen,0,0,0,0);
          Cont_fps(time_now);
        }
  /* Salva ou sobrescrve um mapa anteriormente criado */
  SaveLevel(mapname);

  SDL_Quit();
  return 0;
}

void Cont_fps(Uint32 time_now)
{
  time_now = SDL_GetTicks() - time_now;
  if(time_now < 1000/FPS)
     {
       SDL_Delay(1000/FPS - time_now);
     }
}

void LoadLevel(const char *filename)
{
  file_map = fopen(filename, "r+");

  if(file_map == NULL)
     {
       printf("Não foi possível abrir/criar o arquivo\n");
       exit(1);
     }

  if(fread(mapa, sizeof(mapa), 1, file_map) != 1)
     {
       printf("Não foi possivel ler o arquivo %s\n", filename);
       exit(1);
     }
  else
      {
        printf("Lendo mapa do arquivo %s\n", filename);
      }

  fclose(file_map);
}

void SaveLevel(const char *filename)
{
  file_map = fopen(filename, "w+");

  if(file_map == NULL)
     {
       printf("Não foi possível abrir/criar o arquivo\n");
       exit(1);
     }

  if(fwrite(mapa, sizeof(mapa), 1, file_map) != 1)
     {
       printf("Não foi possível gravar o mapa\n");
       exit(1);
     }
  else
      {
        printf("Mapa salvo com sucesso!\n");
      }

  fclose(file_map);
}

void DrawMap(SDL_Surface *tiles, SDL_Surface *screen)
{
  int lin, col;
  SDL_Rect font, dest;

  font.y = 0;
  font.w = TILESIZE;
  font.h = TILESIZE;

  for(lin = 0; lin < MAP_H_MAX; lin++)
      {
        dest.y = lin*TILESIZE;
        for(col = 0; col < MAP_W_MAX; col++)
            {
              dest.x = col*TILESIZE;

              /*NOTE: Isso aqui não está nada bom...*/
              switch(mapa[lin][col])
                     {
                       case '.':
                            font.x = 0;
                       break;

                       case 'a':
                            font.x = 1*TILESIZE;
                       break;

                       case 'b':
                            font.x = 2*TILESIZE;
                       break;

                       case 'c':
                            font.x = 3*TILESIZE;
                       break;

                       case 'd':
                            font.x = 4*TILESIZE;
                       break;

                       case 'e':
                            font.x = 5*TILESIZE;
                       break;

                       case 'f':
                            font.x = 6*TILESIZE;
                       break;

                       case 'g':
                            font.x = 7*TILESIZE;
                       break;

                       case 'h':
                            font.x = 8*TILESIZE;
                       break;

                       case 'i':
                            font.x = 9*TILESIZE;
                       break;

                       case 'j':
                            font.x = 10*TILESIZE;
                       break;

                       case 'k':
                            font.x = 11*TILESIZE;
                       break;

                       case 'l':
                            font.x = 12*TILESIZE;
                       break;
                     }
              SDL_BlitSurface(tiles, &font, screen, &dest);
            }
      }
}

void DrawFoco(SDL_Surface *surf, int x, int y, SDL_Surface *screen)
{
  SDL_Rect offset;

  offset.x = x;
  offset.y = y;

  SDL_BlitSurface(surf, NULL, screen, &offset);
}

Rotina para controle de portas paralelas em C. (biblioteca LP.h)

Lista Simplesmente Encadeada

Ordenação quicksort

Usando shared memory 2

Manipulação de um vetor de registros