S. MarioBros - Editor de fase 0.1

Publicado por Samuel Leonardo 24/04/2009

[ Hits: 7.221 ]

Homepage: https://nerdki.blogspot.com/

Download MLevel_editor.tar.gz




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!!!

  



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);
}


Scripts recomendados

Função "Temporizador" em C

Um Classico exercicio de Lógica de Programação

Árvore AVL ordenação

Sistema básico de cadastro usando Listas Encadeadas

Biblioteca dos.h


  

Comentários
[1] Comentário enviado por SamL em 25/04/2009 - 19:05h

Uma pequena correção:
No arquivo level_editor.c, substitua a linha 18(#include <stdio.h>) por #include <stdlib.h>
Se alguem não percebeu, repare que está duplicado "#include <stdio.h>", :P, foi falta de atenção minha, era pra ser "#include <stdlib.h>"
vlw!

[2] Comentário enviado por SamL em 12/06/2009 - 22:17h

.

[3] Comentário enviado por aguamole em 25/04/2021 - 00:01h

Isso foi em 2009 faz o SuperMario para agente.

CPU i5-8400 GTX 750 SofRaid 4xSSD 16GB DDR4 mesmo assim uso Lubuntu.

[4] Comentário enviado por SamL em 25/04/2021 - 14:39h


[3] Comentário enviado por aguamole em 25/04/2021 - 00:01h

Isso foi em 2009 faz o SuperMario para agente.

CPU i5-8400 GTX 750 SofRaid 4xSSD 16GB DDR4 mesmo assim uso Lubuntu.

Rapaz, nem é porque eu não queira, se eu te contar que eu estou escrevendo justamente um mega tutorial de como criar um super mario? Faz meses que to escrevendo o código porque tenho tido pouca paciência pra escrever, dai vai muito lento mesmo rsrsrs. Espero acabar ele até julho pelo menos.


Contribuir com comentário




Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner
Linux banner
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts