ADD IN MEM.C

/* Help Editor - kermit 1/98 */
HELP_DATA *new_help(void)
{
     HELP_DATA *NewHelp;

     NewHelp = alloc_perm(sizeof(*NewHelp) );

     NewHelp->level    = 0;
     NewHelp->keyword = str_dup("");
     NewHelp->text    = str_dup("");
     NewHelp->next    = NULL;

     return NewHelp;
}

ADD IN OLC.C

--- run_olc_editor ---

    case ED_MPCODE:
        mpedit( d->character, d->incomm );
        break;
+    case ED_HELP:
+        hedit( d->character, d->incomm );
+        break;
    default:
	return FALSE;

--- olc_ed_name ---

    case ED_MPCODE:
        sprintf( buf, "MPEdit" );
        break;
+    case ED_HELP:
+        sprintf( buf, "HEdit" );
+        break;
    default:
	sprintf( buf, " " );
	break;

--- show_commands ---

	case ED_MPCODE:
	    show_olc_cmds( ch, mpedit_table );
            break;
+    case ED_HELP:
+        show_olc_cmds( ch, hedit_table );
+        break;

    }

---

/* Help Editor - kermit 1/98 */
const struct olc_cmd_type hedit_table[] =
{
/*  {   command		function	}, */

    { "commands", show_commands  },
    { "desc",     hedit_desc     },
    { "keywords", hedit_keywords },
    { "level",    hedit_level    },
    { "make",     hedit_make     },
    { "show",     hedit_show     },
    { "delete",   hedit_delete   },
    {   "?",      show_help      },

    {	NULL, 0, }
};

--- const struct editor_cmd_type ---

    {	"mpcode",	do_mpedit	},
+    {   "help",         do_hedit        },

    {	NULL,		0,		}

---

/* Help Editor - kermit 1/98 */
void hedit( CHAR_DATA *ch, char *argument)
{
    char command[MIL];
    char arg[MIL];
    int cmd;
    
    smash_tilde(argument);
    strcpy(arg, argument);
    argument = one_argument( argument, command);

    if (ch->pcdata->security < 9)
    {
        send_to_char("HEdit: Insufficient security to modify code\n\r",ch);
       edit_done(ch);
    }

    if ( !str_cmp(command, "done") )
    {
	edit_done( ch );
	return;
    }

    if ( command[0] == '\0' )
    {
        hedit_show( ch, argument );
	return;
    }

    for ( cmd = 0; hedit_table[cmd].name != NULL; cmd++ )
    {
	if ( !str_prefix( command, hedit_table[cmd].name ) )
	{
            (*hedit_table[cmd].olc_fun) ( ch, argument );
            return;
	}
    }

    interpret( ch, arg );
    return;    
}
        
/* Help Editor - kermit 1/98 */
void do_hedit( CHAR_DATA *ch, char *argument )
{
    HELP_DATA *pHelp;
    char arg1[MIL];
    char argall[MAX_INPUT_LENGTH],argone[MAX_INPUT_LENGTH];
    bool found = FALSE;

    strcpy(arg1,argument);
    
    if(argument[0] != '\0')
    {
        /* Taken from do_help */
        argall[0] = '\0';
        while (argument[0] != '\0' )
        {
            argument = one_argument(argument,argone);
            if (argall[0] != '\0')
                strcat(argall," ");
            strcat(argall,argone);
        }

        for ( pHelp = help_first; pHelp != NULL; pHelp = pHelp->next )
        {
            if ( is_name( argall, pHelp->keyword ) )
            {
                ch->desc->pEdit=(void *)pHelp;
                ch->desc->editor= ED_HELP;
                found = TRUE;
                return;
            }
        }
    }

    if(!found)
    {
        argument = one_argument(arg1, arg1);
        
        if(!str_cmp(arg1,"make"))
        {
            if (argument[0] == '\0')
            {
                send_to_char("Syntax: edit help new [topic]\n\r",ch);
                return;
            }
            if (hedit_make(ch, argument) )
                ch->desc->editor = ED_HELP;
            return;
        }
    }

    send_to_char( "HEdit:  There is no default help to edit.\n\r", ch );
    return;
}

ADD IN OLC.H

#define ED_HELP 6

void    hedit          args( ( CHAR_DATA *ch, char *argument ) );

extern const struct olc_cmd_type	hedit_table[];

DECLARE_DO_FUN( do_hedit       );

/* Help Editor - kermit 1/98 */
DECLARE_OLC_FUN( hedit_show    );
DECLARE_OLC_FUN( hedit_make );
DECLARE_OLC_FUN( hedit_desc   );
DECLARE_OLC_FUN( hedit_level   );
DECLARE_OLC_FUN( hedit_keywords   );
DECLARE_OLC_FUN( hedit_delete );

#define EDIT_HELP(Ch, Help)     ( Help = (HELP_DATA *)Ch->desc->pEdit )

HELP_DATA *new_help args ( (void) );
void free_help  args( ( HELP_DATA * pHelp));
void save_helps args( (void) );

---



ADD IN OLC_ACT.C

#define HEDIT( fun )            bool fun( CHAR_DATA *ch, char *argument )

---

 /* Help Editor - kermit 1/98 */
 HEDIT (hedit_make)
 {
     HELP_DATA *pHelp;
     
     if (argument[0] == '\0')
     {
         send_to_char("Syntax: mpedit make [keyword(s)]\n\r",ch);
         return FALSE;
     }
 
     pHelp                        = new_help();
     pHelp->keyword = str_dup(argument);
     pHelp->next                  = help_first;
     help_first                    = pHelp;
     ch->desc->pEdit               = (void *)pHelp;
 
     send_to_char("New Help Entry Created.\n\r",ch);
     return TRUE;
 }

HEDIT( hedit_show)
{
    HELP_DATA *pHelp;
    char buf[MSL];

    EDIT_HELP(ch,pHelp);

    if(pHelp->delete)  {
        send_to_char("\n\nTHIS HELP IS MARKED FOR DELETION!\n\r",ch);
        return FALSE;
    }
    
    sprintf(buf, "Level:       [%d]\n\r"
                "Keywords: %s\n\r"
                "\n\r%s\n\r",
            pHelp->level, pHelp->keyword, pHelp->text);
    send_to_char(buf,ch);
    
    return FALSE;
}

HEDIT( hedit_desc)
{
    HELP_DATA *pHelp;
    EDIT_HELP(ch, pHelp);

    if (argument[0] =='\0')
    {
       string_append(ch, &pHelp->text);
       return TRUE;
    }

    send_to_char(" Syntax: desc\n\r",ch);
    return FALSE;
}

HEDIT( hedit_keywords)
{
    HELP_DATA *pHelp;
    EDIT_HELP(ch, pHelp);

    if(argument[0] == '\0')
    {
        send_to_char(" Syntax: keywords [keywords]\n\r",ch);
        return FALSE;
    }

    pHelp->keyword = str_dup(argument);
    send_to_char( "Keyword(s) Set.\n\r", ch);
    return TRUE;
}

HEDIT(hedit_level)
{
    HELP_DATA *pHelp;

    EDIT_HELP(ch, pHelp);

    if ( argument[0] == '\0' || !is_number( argument ) )
    {
	send_to_char( "Syntax:  level [number]\n\r", ch );
	return FALSE;
    }

    pHelp->level = atoi( argument );

    send_to_char( "Level set.\n\r", ch);
    return TRUE;
}

HEDIT( hedit_delete)
{
    HELP_DATA *pHelp;

    EDIT_HELP(ch,pHelp);

    if(!pHelp->delete) {
        pHelp->delete = TRUE;
        send_to_char("YOU HAVE MARKED THIS HELP DELETION!\n\r",ch);
        return TRUE;
    }

    pHelp->delete = FALSE;
    send_to_char("YOU HAVE UNMARKED THIS HELP FOR DELETION!\n\r",ch);
    return TRUE;
}

ADD IN OLC_SAVE.C

--- do_asave ---

    send_to_char( "  asave world    - saves the world! (db dump)\n\r",	ch );
+    send_to_char( "  asave helps    - saves the help files\n\r",	ch );
    send_to_char( "\n\r", ch );

---
    	send_to_char( "Area saved.\n\r", ch );
	return;
    }

+     /* Save Help File */
+    if(!str_cmp(arg1, "helps"))
+    {
+        save_helps();
+        send_to_char( "Helps Saved.\n\r", ch);
+        return;
+    }

    /* Show correct syntax. */

---

void save_helps()
{
    HELP_DATA * pHelp;
    FILE * fp;

    if (! (fp = fopen( "help.are", "w") ) )
    {
        bug( "Open_help: fopen", 0);
        perror( "help.are");
     }

        fprintf(fp, "#HELPS\n");

        for ( pHelp = help_first; pHelp != NULL; pHelp = pHelp->next )
        {
            if(pHelp->delete)
                continue;
            
            fprintf(fp, "%d %s~\n\n%s~\n",
                    pHelp->level, pHelp->keyword, fix_string(pHelp->text));
        }

        fprintf(fp,"0 $~\n\n#$\n");
        fclose(fp);
        return;
}

---------------

ADD IN MERC.H

#define MSL MAX_STRING_LENGTH
#define MIL MAX_INPUT_LENGTH

struct	help_data
{
    HELP_DATA *	next;
    sh_int	level;
    char *	keyword;
    char *	text;
+   bool delete;    
};

ADD IN INTERP.C

    { "hedit",		do_hedit,	POS_DEAD,    0,  LOG_NORMAL, 1 },

ADD IN INTERP.H

DECLARE_DO_FUN( do_hedit	);