무한대전 방 데이터 Convert

자료출처 : GAME BBS (Telnet gamebbs.co.kr)

제 목 : [참고] 방 데이타 변환 소스 찬성 : 0 반대 : 0
올린이 : uhruh (최경호 ) 읽음 : 74 날짜 : 1999/11/30 06:39
------------------------------------------------------------------------------
Modor 방 데이터 변환 예제

아래 소스는 Mordor 의 방 데이터 변환 예제입니다.
무한대전과 Mordor 의 각 데이타 스트럭처내 변수배열과 크기는 같으나
제가 방, 몹, 아이템 데이타를 모두 삭제하고 새로 스트럭쳐를 조정해주면서
몇가지 변수를 추가했기 때문에 아래 room 스트럭쳐는 무한대전이나 Mordor
의 스트럭쳐와 약간 다릅니다.
처음 출구에 방향치를 넣기위해 플래그(direction[2])로 그것을 만들어줬으나
나중에 변수 하나로 대치하기 위해 아래 변환 소스를 짜게 되었습니다.
(출구의방향이 하나이므로 플래그까지 쓸 필요가 없는데 그렇게 설계해버렸군
요 -.-)
이 예제는 출구의 direction[2] 라는 플래그로 쓰이는 변수를 direction 으로
대치하기 위한 것이며 그 외 방 데이타들은 기존의 것을 유지합니다.
ROOMPATH 아래 모든 방 데이타들을 일괄적으로 하나씩 불러들여 새로 고쳐진
스트럭쳐 형식으로 변환시켜 이를 다른 디렉토리에 저장하게 하는 함수입니다.

자신의 머드에서 기존의 방이나 몹등 데이타를 그대로 유지하면서 데이타의 확장
이나 재 배치를 원하시면 이 소스를 참고하세요.
이 소스는 *방변환 식의 명령으로 convert_rom() 함수를 부를는 식으로 머드안에서
작동할 수 있게 만들어졌으며 이 소스를 예로 든다면 새로 변환되어 새로 생기는
데이타는 save_new_rom_to_file() 함수에서 보시는 것처럼 ROOMPATH/new/
아래에서 만들어지게 설정했고 이 기능이 작동기기전 이 디렉토리들은 미리 만들
어져 있어야 합니다.
convert_rom() 외에 다른 모든 함수들은 Mordor 에 있는 것을 수정한 것이며
데이타를 변환 시킨 후 이를 적용하려면 게임 소스상에서 바뀐 스트럭쳐를 적용
시켜주고 새로 생긴 데이터를 이전 데이타 대신 대치해 준 후 새로 컴파일 하여서
게임을 재시작 해줘야 합니다.
물론 새로 바뀐 데이타가 여기 처럼 데이타 형식 자체가 바뀌었다면 이와 관련된
데이타 조작 부분들도 손봐줘야 합니다.
데이타 변환이 이뤄진 후 데이타를 변환시키는 기능은 필요가 없으므로 이도 컴파일
되지 않도록 빼주세요.

머드에 내장시키지 않고 유틸리티 식으로 짜려했으나 그것보다는 머드에 내장시키는
방법이 컴파일할 때 편하기 때문에 그렇게 했습니다. (따로 유틸리티 식으로 만드려
면 Makefile 과 여러 헤더화일을 만들어줘야하기 때문에 아주 귀찮아져요 ㅠ.ㅠ )
                                                                          
다시 말씀드리지만 이 소스는 제가 만들고 있는 머드이외에는 데이타 형식이 틀리
므로 곧바로 수정없이 다른 머드에 적용될 수 없으며 자신의 머드에서 기존 데이타
를 유지하면서 스트럭쳐 변수의 확장이나 배치를 조정할 목적으로 그 기능의 함수를
만들 상황일 때 참고하세요.


#include "mstruct.h"
#include "mextern.h"

/*
typedef struct exit_ {
       char name[20];
       short room;
       char flags[8];
       char direction[2];
       int kdm_index;
       char extra[2];
       struct lasttime ltime;
       unsigned char key;
} exit_;
*/

typedef struct new_exit_ {
       char name[20];
       short room;
       char flags[8];
       char direction;
       int kdm_index;
       char extra[4];
       struct lasttime ltime; /* Timed open/close */
       unsigned char key; /* Key required */
} new_exit_;

typedef struct new_ext_tag { /* Exit list tags */
       struct new_ext_tag *next_tag;
       struct new_exit_ *ext;
} new_xtag;

typedef struct new_room {
       short rom_num;
       char name[80];
       char *short_desc; /* Descriptions */
       char *long_desc;
       char *obj_desc;
       char lolevel; /* Lowest level allowed in */
       char hilevel; /* Highest level allowed in */
       short special;
       char trap;
       short trapexit;
       char track[80]; /* Track exit */
       char flags[8];
       short random[10]; /* Random monsters */
       char traffic; /* R. monster traffic */

       int kdm_index;
       char extra[36];

       struct lasttime perm_mon[10]; /* Permanent/reappearing monsters */
       struct lasttime perm_obj[10]; /* Permanent/reappearing items */
       long beenhere; /* # times room visited */
       long established; /* Time room was established */
       new_xtag *first_ext; /* Exits */
       otag *first_obj; /* Items */
       ctag *first_mon; /* Monsters */
       ctag *first_ply; /* Players */
} new_room;

int save_new_rom_to_file(int num, new_room *rom_ptr);
int write_new_rom(int fd, new_room *rom_ptr, char perm_only );
void free_new_rom( new_room *rom_ptr );
int count_new_ext( new_room *rom_ptr );
int count_new_ite( new_room *rom_ptr, char perm_only );
int count_new_mon( new_room *rom_ptr, char perm_only );

int convert_rom(creature *ply_ptr, cmd *cmnd)
{
       int fd, ff, i;
       int num;
       char file[80];
       room *rom_ptr;
       new_room *new_rom;
       xtag *xp;
       new_xtag *new_xp, *prev = 0;
       new_exit_ *ext;

       fd = ply_ptr->fd;

       for (num = 1; num < RMAX; num++){
               if(HASHROOMS)
                       sprintf(file, "%s/r%02d/r%05d", ROOMPATH, num/1000, num)

               else
                       sprintf(file, "%s/r%05d", ROOMPATH, num);
               ff = open(file, O_RDONLY, 0);
           if(ff >= 0) {
                       close(ff);
                       load_rom_from_file(num, &rom_ptr);

               new_rom = (new_room *)malloc(sizeof(new_room));
               if(!new_rom)
                       merror("convert_rom", FATAL);

               zero(new_rom, sizeof(new_room));
               new_rom->rom_num = rom_ptr->rom_num;
               strcpy(new_rom->name,rom_ptr->name);
               new_rom->short_desc = rom_ptr->short_desc;
               new_rom->long_desc = rom_ptr->long_desc;
               new_rom->obj_desc = rom_ptr->obj_desc;
               new_rom->lolevel = rom_ptr->lolevel;
               new_rom->hilevel = rom_ptr->hilevel;
               new_rom->special = rom_ptr->special;
               new_rom->trap = rom_ptr->trap;
               new_rom->trapexit = rom_ptr->trapexit;
               strcpy(new_rom->track,rom_ptr->track);
               for(i = 0; i < 36; i++)
                       new_rom->flags[i] = rom_ptr->flags[i];
               for(i = 0; i < 10; i++)
                       new_rom->random[i] = rom_ptr->random[i];
               new_rom->traffic = rom_ptr->traffic;
               new_rom->kdm_index = rom_ptr->kdm_index;

               for(i = 0; i < 36; i++)
                       new_rom->extra[i] = 0;

               for(i = 0; i < 10; i++) {
                       new_rom->perm_mon[i].interval = rom_ptr->perm_mon[i].int

                       new_rom->perm_mon[i].ltime = rom_ptr->perm_mon[i].ltime;

                       new_rom->perm_mon[i].misc = rom_ptr->perm_mon[i].misc;
               }
               for(i = 0; i < 10; i++) {
                       new_rom->perm_obj[i].interval = rom_ptr->perm_obj[i].int

                       new_rom->perm_obj[i].ltime = rom_ptr->perm_obj[i].ltime;

                       new_rom->perm_obj[i].misc = rom_ptr->perm_obj[i].misc;
               }

               new_rom->beenhere = rom_ptr->beenhere;
               new_rom->established = rom_ptr->established;

               xp = rom_ptr->first_ext;
               new_xp = new_rom->first_ext;
               prev = 0;
               while(xp) {

                       new_xp = (new_xtag *)malloc(sizeof(new_xtag));
                       if(!new_xp)
                               merror("convert_rom", FATAL);

                       ext = (new_exit_ *)malloc(sizeof(new_exit_));
                       if(!ext)
                               merror("convert_rom", FATAL);

                       zero(new_xp, sizeof(new_xtag));
                       zero(ext, sizeof(new_exit_));
                       strcpy(ext->name, xp->ext->name);

                       ext->room = xp->ext->room;
                       for(i = 0; i < 8; i++)
                               ext->flags[i] = xp->ext->flags[i];

                       if(XD_ISSET(xp->ext,MP_SOUTH))
                               ext->direction = MP_SOUTH;
                       else if(XD_ISSET(xp->ext,MP_NORTH))
                               ext->direction = MP_NORTH;
                       else if(XD_ISSET(xp->ext,MP_WEST))
                               ext->direction = MP_WEST;
                       else if(XD_ISSET(xp->ext,MP_EAST))
                               ext->direction = MP_EAST;
                       else if(XD_ISSET(xp->ext,MP_UP))
                               ext->direction = MP_UP;
                       else if(XD_ISSET(xp->ext,MP_DOWN))
                               ext->direction = MP_DOWN;
                       else if(XD_ISSET(xp->ext,MP_SOUTHEAST))
                               ext->direction = MP_SOUTHEAST;
                       else if(XD_ISSET(xp->ext,MP_NORTHWEST))
                               ext->direction = MP_NORTHWEST;
                       else if(XD_ISSET(xp->ext,MP_SOUTHWEST))
                               ext->direction = MP_SOUTHWEST;
                       else if(XD_ISSET(xp->ext,MP_NORTHEAST))
                               ext->direction = MP_NORTHEAST;
                       else {
                               ext->direction = 0;
                       }
                       ext->kdm_index = xp->ext->kdm_index;
                       for(i = 0; i < 4; i++)
                               ext->extra[i] = xp->ext->extra[i];
                       ext->ltime.interval = xp->ext->ltime.interval;
                       ext->ltime.ltime = xp->ext->ltime.ltime;
                       ext->ltime.misc = xp->ext->ltime.misc;

                       ext->key = xp->ext->key;

                       new_xp->next_tag = 0;
                       new_xp->ext = ext;

                       if (prev) {
                               prev->next_tag = new_xp;
                               prev = new_xp;
                       }
                       else {
                               new_rom->first_ext = new_xp;
                               prev = new_rom->first_ext;
                       }
                       xp = xp->next_tag;
               }

               new_rom->first_obj = rom_ptr->first_obj;
               new_rom->first_mon = rom_ptr->first_mon;
               new_rom->first_ply = rom_ptr->first_ply;

               save_new_rom_to_file(num, new_rom);
               print(fd, "방 데이터 변환: %d\n", num);

               free_new_rom(new_rom);
               free_rom(rom_ptr);

           }
           else
               close(ff);

       }
       return(0);
}

int save_new_rom_to_file(int num, new_room *rom_ptr)
{
       int fd;
       long n;
       char file[80];

       if(HASHROOMS) {
               sprintf(file, "%s/new/r%02d/r%05ld", ROOMPATH, num/1000, num);
       }
       else
               sprintf(file, "%s/new/r%05ld", ROOMPATH, num);

       unlink(file);
       fd = open(file, O_RDWR | O_CREAT, ACC);
       if(fd < 0)
               return(-1);

       n = write_new_rom(fd, rom_ptr, PERMONLY);
       if(n < 0) {
               close(fd);
               return(-1);
       }
       close(fd);

       return(0);
}

int write_new_rom(int fd, new_room *rom_ptr, char perm_only )
{
       int n, cnt, error=0;
       new_xtag *xp;
       ctag *cp;
       otag *op;
       char pcontain;

       n = write(fd, rom_ptr, sizeof(room));
       if(n < sizeof(room))
               merror("write_new_rom", FATAL);

       cnt = count_new_ext(rom_ptr);
       n = write(fd, &cnt, sizeof(int));
       if(n < sizeof(int))
               merror("write_new_rom", FATAL);

       xp = rom_ptr->first_ext;
       while(xp) {
               n = write(fd, xp->ext, sizeof(new_exit_));
               if(n < sizeof(new_exit_))
                       merror("write_new_rom", FATAL);
               xp = xp->next_tag;
       }

       cnt = count_new_mon(rom_ptr, perm_only);
       n = write(fd, &cnt, sizeof(int));
       if(n < sizeof(int))
               merror("write_new_rom", FATAL);

       cp = rom_ptr->first_mon;
       while(cp) {
               if(!perm_only || (perm_only && F_ISSET(cp->crt, MPERMT)))
                       if(write_crt(fd, cp->crt, 0) < 0)
                               error = 1;
               cp = cp->next_tag;
       }

       cnt = count_new_ite(rom_ptr, perm_only);
       n = write(fd, &cnt, sizeof(int));
       if(n < sizeof(int))
               merror("write_new_rom", FATAL);

op = rom_ptr->first_obj;
       while(op) {
               if(!perm_only || (perm_only && (F_ISSET(op->obj, OPERMT)))){
                       if (F_ISSET(op->obj,OCONTN)
                               && (F_ISSET(op->obj, OPERMT)))
                               pcontain = ALLITEMS;
                       else
                               pcontain = perm_only;
                               if(write_obj(fd, op->obj, pcontain) < 0)
                                       error = 1;
               }
               op = op->next_tag;
       }

       if(!rom_ptr->short_desc)
               cnt = 0;
       else
               cnt = strlen(rom_ptr->short_desc) + 1;
       n = write(fd, &cnt, sizeof(int));
       if(n < sizeof(int))
               merror("write_new_rom", FATAL);

       if(cnt) {
               n = write(fd, rom_ptr->short_desc, cnt);
               if(n < cnt)
                       merror("write_new_rom", FATAL);
       }

       if(!rom_ptr->long_desc)
               cnt = 0;
       else
               cnt = strlen(rom_ptr->long_desc) + 1;
       n = write(fd, &cnt, sizeof(int));
       if(n < sizeof(int))
               merror("write_new_rom", FATAL);

       if(cnt) {
               n = write(fd, rom_ptr->long_desc, cnt);
               if(n < cnt)
                       merror("write_new_rom", FATAL);
       }

       if(!rom_ptr->obj_desc)
               cnt = 0;
       else
               cnt = strlen(rom_ptr->obj_desc) + 1;
       n = write(fd, &cnt, sizeof(int));
       if(n < sizeof(int))
               merror("write_new_rom", FATAL);

       if(cnt) {
               n = write(fd, rom_ptr->obj_desc, cnt);
               if(n < cnt)
                       merror("write_new_rom", FATAL);
       }

       if(error)
               return(-1);
       else
               return(0);
}

void free_new_rom( new_room *rom_ptr )
{
       new_xtag *xp, *xtemp;
       otag *op, *otemp;
       ctag *cp, *ctemp;

#ifdef DMALLOC
       dmalloc_verify (rom_ptr);
#endif /* DMALLOC */

       xp = rom_ptr->first_ext;
       while(xp) {
               xtemp = xp->next_tag;
               free(xp->ext);
               free(xp);
               xp = xtemp;
       }
       rom_ptr->first_ext = 0;

       free(rom_ptr);
}

int count_new_ext( new_room *rom_ptr )
{
       new_xtag *xp;
       int total = 0;

       xp = rom_ptr->first_ext;
       while(xp) {
               total++;
               xp = xp->next_tag;
       }
       return(total);
}
int count_new_mon( new_room *rom_ptr, char perm_only )
{
       ctag *cp;
       int total=0;

       cp = rom_ptr->first_mon;
       while(cp) {
               if(!perm_only || (perm_only && F_ISSET(cp->crt, MPERMT)))
                       total++;
               cp = cp->next_tag;
       }
       return(total);
}


int count_new_ite(new_room *rom_ptr, char perm_only )
{
       otag *op;
       int total=0;

       op = rom_ptr->first_obj;
       while(op) {
               if(!perm_only || (perm_only && (F_ISSET(op->obj, OPERMT))))
                       total++;
               op = op->next_tag;
       }
       return(total);
}

홈지기 "그륨"