olc_class.c

Go to the documentation of this file.

/* C(lass)Edit 1.0 By tribul of BTS (Beyond the shadows) 
 * Permission is given to use, as long as it
 * retains this tag. Enjoy. */

/* one.xwin.net 4000 - BTS
 * bioteq@unidef.net - email 
 *
 * I admit, this code ranks up with the ugliest of them all...
 * bare with it. */


#if defined(macintosh)
#include <types.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#endif
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "merc.h"
#include "tables.h"
#include "olc.h"
#include "lookup.h"
#include "recycle.h"
extern OCLASS_DATA *class_last;
#define CEDIT( fun )           bool fun(CHAR_DATA *ch, char*argument)

const struct olc_cmd_type cedit_table[] = {
    {"show", cedit_show},
    {"name", cedit_name},
        {"wname", cedit_wname},
        {"thac0", cedit_thac_0},
        {"thac32", cedit_thac_32},
        {"primary", cedit_primary},
 //       {"weapon", cedit_weapon},
 //       {"guild1", cedit_guild_1},
 //       {"guild2", cedit_guild_2},
        {"skill", cedit_skill},
        {"minhp", cedit_min_hp},
        {"maxhp", cedit_max_hp},
        {"base" , cedit_base},
        {"default", cedit_default},
        {"commands", show_commands},
    {"csave", cedit_save},
        {"?", show_help},
        {NULL,0}
};

void do_cedit(CHAR_DATA *ch, char *argument)
{
       char arg[MAX_STRING_LENGTH];
       OCLASS_DATA *pClass;
       OCLASS_DATA *cClass;
       pClass = cClass;
       //cClass = cClass->next;
       
       if (IS_NPC(ch))
               return;
        argument = one_argument(argument, arg);
        if (is_number(arg))
        {
               send_to_char("Syntax - cedit [create] class\n\r",ch);
               return;
        }
    else if (!str_cmp(arg, "create"))
        {
                if (ch->pcdata->security < 5)
                {
                        send_to_char("CEdit: Not enough security.\n\r",ch);
                        return;
                }
    
        cedit_create (ch, "");
        ch->desc->editor = ED_CLASS;
        return;
    }
    else
    {
        send_to_char("no.\n\r",ch);
        return;
    }
    ch->desc->pEdit=(void *) pClass;
    ch->desc->editor = ED_CLASS;
    return;
}



CEDIT (cedit_create)
{
    OCLASS_DATA *pClass;
    extern OCLASS_DATA *class_first;
    pClass = new_class();
    pClass->name = str_dup("New Class");
    pClass->who_name = str_dup("NWC");
    pClass->thac_0 = 0;
    pClass->thac_32 = 0;
    pClass->primary = 0;
    pClass->weapon = 0;
    pClass->guild1 = 0;
    pClass->guild2 = 0;
    pClass->skill = 0;
    pClass->minhp = 0;
    pClass->maxhp = 0;
    pClass->base = str_dup("New Class Basics");
    pClass->c_default = str_dup("New Class Default");
    //if (class_last)
//      class_last->next = pClass;
    if (class_first)
        class_first = pClass;
    class_last= pClass;
    pClass->next = NULL;
    ch->desc->pEdit = (OCLASS_DATA*) pClass;
    ch->desc->editor = ED_CLASS;
    send_to_char("Class created\n\r",ch);
    send_to_char("Warning. This will not save when you do done. And you cannot do asave changed.\n\r You must type 'csave' to save it for review.\n\r",ch);
    return FALSE;



}
CEDIT (cedit_wname)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch, pClass);

    if (is_number(argument))
    {
        send_to_char("Value cannot be a number.\n\r",ch);
        return TRUE;
    }
    if (argument[0] == '\0')
    {
        send_to_char("wname <name> (Three leters)",ch);
        return TRUE;
    }
    if (strlen(argument) > 3)
    {
        send_to_char("Only THREE characters\n\r",ch);
        return TRUE;
    }
    
    pClass->who_name = str_dup(argument);
    free_string(argument); /* ...had some strange things happening. Just to be safe ^_^*/
    //do_function(ch, cedit_show, "");

    
    return TRUE;
}
CEDIT (cedit_thac_0)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch,pClass);

    if (argument[0] == '\0')
    {
        send_to_char("thac_0 <number>",ch);
        return TRUE;
    }
    if (!is_number(argument))
    {
        send_to_char("Value must be numberic\n\r",ch);
        return TRUE;
    }
    if (atoi (argument) > 50 || atoi (argument) < 5)
    {
        send_to_char("Be real...\n\r",ch);
        return TRUE;
    }
    pClass->thac_0 =atoi (argument);
    free_string(argument);
//  do_function(ch, cedit_show, "");

    return TRUE;
}
CEDIT (cedit_thac_32)
{
     OCLASS_DATA *pClass;
     EDIT_CLASS(ch,pClass);
         if (argument[0] == '\0')
         {
                 send_to_char("thac_32 <number>",ch);
                 return TRUE;
         }
         if (!is_number(argument))
         {
                 send_to_char("Value must be numberic\n\r",ch);
                 return TRUE;
         }
         if (atoi (argument) > 0 || atoi (argument) < -50)
         {
                 send_to_char("Be real...\n\r",ch);
                 return TRUE;
         }
         pClass->thac_32 =atoi (argument);
         free_string(argument);
  //       do_function(ch, cedit_show, "");

                                 
    
    return TRUE;
}
CEDIT (cedit_primary)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS (ch, pClass);
    if (argument[0] == '\0')
    {
        send_to_char("primary <number> (0 through 4)",ch);
        return TRUE;
    }
    if (!str_cmp(argument, "?"))
    {
        send_to_char("\n\r0 = strength\n\r1 = intelligence\n\r2 = Wisdom\n\r3 = Dexterity\n\r4 = Con\n\r",ch);
        return TRUE;
    }

    if (!is_number(argument))
    {
        send_to_char("Value must be numeric.\n\r",ch);
        return TRUE;
    }
    if (atoi (argument) < 0 || atoi (argument) > 4)
    {
        send_to_char("Only 0 - 4\n\r",ch);
        return TRUE;
    }
    pClass->primary = atoi (argument);
    free_string(argument);
//  do_function(ch,cedit_show,"");
    return TRUE;
}
/*CEDIT (cedit_guild_1)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch,pClass);
    if (argument[0] == '\0')
    {
        send_to_char("guild1 <vnum>\n\r",ch);
        return TRUE;
    }
    if (!is_number(argument))
    {
        send_to_char("Value must be numeric\n\r",ch);
        return TRUE;
    }
    if (atoi (argument) < 1)
    {
        send_to_char("Funny...\n\r",ch);
        return TRUE;
    }
    pClass->guild1 = atoi (argument);
    free_string(argument);
    do_function(ch,cedit_show,"");
    return TRUE;

    
}
CEDIT (cedit_guild_2)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch,pClass);
    if (argument[0] == '\0')
    {
        send_to_char("guild2 <vnum>\n\r",ch);
        return TRUE;
    }
    if (!is_number(argument))
    {
        send_to_char("Value must be numeric\n\r",ch);
        return TRUE;
    }
    if (atoi (argument) < 1)
    {
        send_to_char("Funny...\n\r",ch);
        return TRUE;
    }
    pClass->guild2 = atoi (argument);
    free_string(argument);
    do_function(ch,cedit_show,"");
    return TRUE;
}*/
CEDIT (cedit_skill)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch, pClass);
    if (argument[0] == '\0')
    {
        send_to_char("skill <number>\n\r",ch);
        return TRUE;
    }
    if (!is_number(argument))
    {
        send_to_char("Value must be numeric\n\r",ch);
        return TRUE;
    }
    if (atoi (argument) < 10 || atoi (argument) > 80)
    {
        send_to_char("Must be between 10 and 80\n\r",ch);
        return TRUE;
    }
    pClass->skill = atoi (argument);
    free_string(argument);
//  do_function(ch,cedit_show,"");
    return TRUE;
}
CEDIT (cedit_min_hp)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch, pClass);
    if (argument[0] == '\0')
    {
        send_to_char("minhp <number>\n\r",ch);
        return TRUE;
    }
    if (!is_number(argument))
    {
        send_to_char("Value must be numeric\n\r",ch);
        return TRUE;
    }
    if (atoi (argument) < 5 || atoi (argument) > 15)
    {
        send_to_char("Between 5 and 15 only!\n\r",ch);
        return TRUE;
    }
    pClass->minhp = atoi (argument);
    free_string(argument);
//  do_function(ch, cedit_show,"");
    return TRUE;
}
CEDIT (cedit_max_hp)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch,pClass);
    if (argument[0] == '\0')
    {
        send_to_char("maxhp <number>\n\r",ch);
        return TRUE;
    }
    if (!is_number(argument))
    {
        send_to_char("Value must be numeric\n\r",ch);
        return TRUE;
    }
    if (atoi (argument) < 16 || atoi (argument) > 40)
    {
        send_to_char("Between 16 and 40 only!\n\r",ch);
        return TRUE;
    }
    pClass->maxhp = atoi (argument);
    free_string(argument);
//  do_function(ch,cedit_show,"");
    return TRUE;
}
CEDIT (cedit_base)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch, pClass);
    if (argument[0] == '\0')
    {
        send_to_char("base <base skill>\n\r",ch);
        return TRUE;
    }
    if (is_number(argument))
    {
        send_to_char("Non-numeric value, please.\n\r",ch);
        return TRUE;
    }
    pClass->base = str_dup(argument);
    free_string(argument);
//  do_function(ch,cedit_show,"");
    return TRUE;
}
CEDIT (cedit_default)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch,pClass);
    if (argument[0] == '\0')
    {
        send_to_char("default <default group>\n\r",ch);
        return TRUE;
    }
    if (is_number(argument))
    {
        send_to_char("Non-numeric value, please.\n\r",ch);
        return TRUE;
    }
    pClass->c_default = str_dup(argument);
    free_string(argument);
//  do_function(ch,cedit_show,"");
    return TRUE;
}

CEDIT (cedit_name)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch, pClass);
    if (argument[0] == '\0')
    {
        send_to_char("name <name>\n\r",ch);
        return TRUE;
    }
    pClass->name = str_dup(argument);
//  do_function(ch, cedit_show, "");
    return TRUE;
}
/*CEDIT (cedit_weapon)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS (ch, pClass);
    if (argument[0] == '\0')
    {
        send_to_char("weapon <vnum> \n\r",ch);
        return TRUE;
    }
    if (!is_number(argument))
    {
        send_to_char("Numeric value only.\n\r",ch);
        return TRUE;
    }
    if (atoi (argument) < 1)
    {
        send_to_char("funny...\n\r",ch);
        return TRUE;
    }
    pClass->weapon = atoi (argument);
    free_string(argument);
    do_function(ch,cedit_show,"");
    return TRUE;
}*/
CEDIT (cedit_show)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch, pClass);
    char buf[MAX_STRING_LENGTH];

    sprintf(buf, "Name - [%s]\n\r", str_dup(pClass->name));
    send_to_char(buf,ch);
    sprintf(buf, "Wname - [%s]\n\r", str_dup(pClass->who_name));
    send_to_char(buf,ch);
    sprintf(buf, "Thac0 - [%d]\n\r", pClass->thac_0);
    send_to_char(buf,ch);
    sprintf(buf, "Thac32 - [%d]\n\r",pClass->thac_32);
    send_to_char(buf,ch);
    sprintf(buf, "Primary - [%d]\n\r",pClass->primary);
    send_to_char(buf,ch);
    sprintf(buf, "Weapon - [%d]\n\r",pClass->weapon);
    send_to_char(buf,ch);
    sprintf(buf, "Guild1 - [%d]\n\r", pClass->guild1);
    send_to_char(buf,ch);
    sprintf(buf, "Guild2 - [%d]\n\r", pClass->guild2);
    send_to_char(buf,ch);
    sprintf(buf, "Skill - [%d]\n\r", pClass->skill);
    send_to_char(buf,ch);
    sprintf(buf, "Maxhp - [%d]\n\r", pClass->maxhp);
    send_to_char(buf,ch);
    sprintf(buf, "Minhp - [%d]\n\r",pClass->minhp);
    send_to_char(buf,ch);
    sprintf(buf, "Base skills - [%s]\n\r", pClass->base);
    send_to_char(buf,ch);
    sprintf(buf, "Default skills - [%s]\n\r", pClass->c_default);
    send_to_char(buf,ch);
    return TRUE;
}
CEDIT (cedit_save)
{
    OCLASS_DATA *pClass;
    EDIT_CLASS(ch,pClass);
    char buf[MAX_STRING_LENGTH];
    FILE *fp;
    if (pClass->name[0] == '\0' || pClass->name == NULL || !str_cmp(pClass->name, "New Class"))
    {
        send_to_char("Please supply a name.\n\r",ch);
        return TRUE;
    }
    if (pClass->who_name[0] == '\0' || pClass->who_name == NULL || !str_cmp(pClass->who_name, "NWC"))
    {
        send_to_char("Please supply a who name (wname)\n\r",ch);
        return TRUE;
    }
    
/*  if (pClass->weapon == 0)
    {
        send_to_char("Weapon vnum needs to be set.\n\r",ch);
        return TRUE;
    }
    if (pClass->guild1 == 0)
    {
        send_to_char("Guild1 vnum needs to be set.\n\r",ch);
        return TRUE;
    }
    if (pClass->guild2 == 0)
    {
        send_to_char("Guild2 vnum needs to be set.\n\r",ch);
        return TRUE;
    }*/
    if (pClass->maxhp == 0)
    {
        send_to_char("Maxhp needs to be set.\n\r",ch);
        return TRUE;
    }
    if (pClass->minhp == 0)
    {
        send_to_char("Minhp needs to be set.\n\r",ch);
        return TRUE;
    }
    if (pClass->base[0] == '\0' || pClass->base == NULL || !str_cmp(pClass->base, "New Class Basics"))
    {
        send_to_char("Base needs to be set.\n\r",ch);
        return TRUE;
    }
    if (pClass->c_default[0] == '\0' || pClass->c_default == NULL || !str_cmp(pClass->c_default, "New Class Default"))
    {
        send_to_char("Default needs to be set.\n\r",ch);
        return TRUE;
    }
    if (pClass->skill == 0)
    {
        send_to_char("Skill level needs to be set. (This is how far they can practice a skill to.)\n\r",ch);
        return TRUE;
    }
    send_to_char("Saving ... ",ch);
    sprintf(buf, "class/%s.class",  pClass->name);
    fp = fopen (buf, "w");
    if (!fp)
    {
        send_to_char("Failed! -- Contact the head coder for details.\n\r",ch);
        return FALSE;
    }
    fprintf(fp, "#CLASS\n");
    fprintf(fp, "Name %s~\n", pClass->name);
    fprintf(fp, "WhoN %s~\n", pClass->who_name);
    fprintf(fp, "Prime %d\n", pClass->primary);
    fprintf(fp, "Weapon %d\n", pClass->weapon);
    fprintf(fp, "Guild1 %d\n",pClass->guild1);
    fprintf(fp, "Guild2 %d\n", pClass->guild2);
    fprintf(fp, "Skill %d\n", pClass->skill);
    fprintf(fp, "Thac00 %d\n", pClass->thac_0);
    fprintf(fp, "Thac32 %d\n", pClass->thac_32);
    fprintf(fp, "HPMIN %d\n", pClass->minhp);
    fprintf(fp, "HPMAX %d\n", pClass->maxhp);
    fprintf(fp, "FMana 0\n");
    fprintf(fp, "Pick 0\n");
    fprintf(fp, "Base %s~\n", pClass->base);
    fprintf(fp, "Default %s~\n", pClass->c_default);
    fprintf(fp, "End\n");
    send_to_char(" Done!\n\r",ch);
    send_to_char("This does not mean it will be loaded now. Submit note to Tribul, and tell him the name of the class.\n\r",ch);
    send_to_char("He will review it, and see if it is worthy, or not.\n\r",ch);
    send_to_char("Type done, and you may be on your way.\n\r",ch);
    fclose(fp);
    return TRUE;
    
}
    

void cedit (CHAR_DATA *ch, char *argument)
{
        char arg[MAX_INPUT_LENGTH];
        char command[MAX_INPUT_LENGTH];
    smash_tilde (argument);
        strcpy(arg, argument);
        argument = one_argument(argument, command);
    if (ch->level < 55)
        {
                send_to_char ("CEdit: You're not high enough level to do this.\n\r",ch);
                edit_done(ch);
                return;
        }
       if (!str_cmp(command, "done"))
        {
                edit_done (ch);
                return;
        }


        if (command[0] == '\0')
        {
                return;
        }
        int cmd;
        for (cmd = 0; cedit_table[cmd].name != NULL; cmd++)
        {
                if (!str_prefix(command, cedit_table[cmd].name))
                {
                        if ((*cedit_table[cmd].olc_fun) (ch, argument))
                        {
                                return;
                        }
                        else
                                    return;
                }
        }
        interpret (ch, arg);
        return;
}   
    

---