Beyond the Shadows: olc_act.c File Reference

{                            \
        int blah = flag_value( _table, _arg );        \
        _blargh = (blah == NO_FLAG) ? 0 : blah;        \
    }

{                            \
        int blah = flag_value( _table, _arg );        \
        _blargh ^= (blah == NO_FLAG) ? 0 : blah;    \
    }

01322 {
01323     AREA_DATA *pArea;
01324     char upper[MAX_STRING_LENGTH];
01325     int ilower;
01326     int iupper;
01327 
01328     EDIT_AREA (ch, pArea);
01329 
01330     one_argument (argument, upper);
01331 
01332     if (!is_number (upper) || upper[0] == '\0')
01333     {
01334         send_to_char ("Syntax:  max_vnum [#xupper]\n\r", ch);
01335         return FALSE;
01336     }
01337 
01338     if ((ilower = pArea->min_vnum) > (iupper = atoi (upper)))
01339     {
01340         send_to_char ("AEdit:  Upper must be larger then lower.\n\r", ch);
01341         return FALSE;
01342     }
01343 
01344     if (!check_range (ilower, iupper))
01345     {
01346         send_to_char ("AEdit:  Range must include only this area.\n\r", ch);
01347         return FALSE;
01348     }
01349 
01350     if (get_vnum_area (iupper) && get_vnum_area (iupper) != pArea)
01351     {
01352         send_to_char ("AEdit:  Upper vnum already assigned.\n\r", ch);
01353         return FALSE;
01354     }
01355 
01356     pArea->max_vnum = iupper;
01357     send_to_char ("Upper vnum set.\n\r", ch);
01358 
01359     return TRUE;
01360 }

01279 {
01280     AREA_DATA *pArea;
01281     char lower[MAX_STRING_LENGTH];
01282     int ilower;
01283     int iupper;
01284 
01285     EDIT_AREA (ch, pArea);
01286 
01287     one_argument (argument, lower);
01288 
01289     if (!is_number (lower) || lower[0] == '\0')
01290     {
01291         send_to_char ("Syntax:  min_vnum [#xlower]\n\r", ch);
01292         return FALSE;
01293     }
01294 
01295     if ((ilower = atoi (lower)) > (iupper = pArea->max_vnum))
01296     {
01297         send_to_char ("AEdit:  Value must be less than the max_vnum.\n\r",
01298                       ch);
01299         return FALSE;
01300     }
01301 
01302     if (!check_range (ilower, iupper))
01303     {
01304         send_to_char ("AEdit:  Range must include only this area.\n\r", ch);
01305         return FALSE;
01306     }
01307 
01308     if (get_vnum_area (ilower) && get_vnum_area (ilower) != pArea)
01309     {
01310         send_to_char ("AEdit:  Lower vnum already assigned.\n\r", ch);
01311         return FALSE;
01312     }
01313 
01314     pArea->min_vnum = ilower;
01315     send_to_char ("Lower vnum set.\n\r", ch);
01316     return TRUE;
01317 }

01224 {
01225     AREA_DATA *pArea;
01226     char lower[MAX_STRING_LENGTH];
01227     char upper[MAX_STRING_LENGTH];
01228     int ilower;
01229     int iupper;
01230 
01231     EDIT_AREA (ch, pArea);
01232 
01233     argument = one_argument (argument, lower);
01234     one_argument (argument, upper);
01235 
01236     if (!is_number (lower) || lower[0] == '\0'
01237         || !is_number (upper) || upper[0] == '\0')
01238     {
01239         send_to_char ("Syntax:  vnum [#xlower] [#xupper]\n\r", ch);
01240         return FALSE;
01241     }
01242 
01243     if ((ilower = atoi (lower)) > (iupper = atoi (upper)))
01244     {
01245         send_to_char ("AEdit:  Upper must be larger then lower.\n\r", ch);
01246         return FALSE;
01247     }
01248 
01249     if (!check_range (atoi (lower), atoi (upper)))
01250     {
01251         send_to_char ("AEdit:  Range must include only this area.\n\r", ch);
01252         return FALSE;
01253     }
01254 
01255     if (get_vnum_area (ilower) && get_vnum_area (ilower) != pArea)
01256     {
01257         send_to_char ("AEdit:  Lower vnum already assigned.\n\r", ch);
01258         return FALSE;
01259     }
01260 
01261     pArea->min_vnum = ilower;
01262     send_to_char ("Lower vnum set.\n\r", ch);
01263 
01264     if (get_vnum_area (iupper) && get_vnum_area (iupper) != pArea)
01265     {
01266         send_to_char ("AEdit:  Upper vnum already assigned.\n\r", ch);
01267         return TRUE;            /* The lower value has been set. */
01268     }
01269 
01270     pArea->max_vnum = iupper;
01271     send_to_char ("Upper vnum set.\n\r", ch);
01272 
01273     return TRUE;
01274 }

01201 {
01202     AREA_DATA *pArea;
01203 
01204     EDIT_AREA(ch, pArea);
01205 
01206     if (ch->level < 60)
01207     {
01208         send_to_char("You do not have access in deleteing areas.\n\r",ch);
01209         return FALSE;
01210     }
01211 
01212     if (pArea->adelete)
01213     {
01214         send_to_char("Area's delete status removed.\n\r",ch);
01215         pArea->adelete = FALSE;
01216         return TRUE;
01217     }
01218     send_to_char("Area's delete status set.\n\r",ch);
01219     pArea->adelete = TRUE;
01220     return TRUE;
01221 }

01141 {
01142     AREA_DATA *pArea;
01143     char name[MAX_STRING_LENGTH];
01144     char buf[MAX_STRING_LENGTH];
01145 
01146     EDIT_AREA (ch, pArea);
01147 
01148     one_argument (argument, name);
01149 
01150     if (name[0] == '\0')
01151     {
01152         send_to_char ("Syntax:  builder [$name]  -toggles builder\n\r", ch);
01153         send_to_char ("Syntax:  builder All      -allows everyone\n\r", ch);
01154         return FALSE;
01155     }
01156 
01157     name[0] = UPPER (name[0]);
01158 
01159     if (strstr (pArea->builders, name) != '\0')
01160     {
01161         pArea->builders = string_replace (pArea->builders, name, "\0");
01162         pArea->builders = string_unpad (pArea->builders);
01163 
01164         if (pArea->builders[0] == '\0')
01165         {
01166             free_string (pArea->builders);
01167             pArea->builders = str_dup ("None");
01168         }
01169         send_to_char ("Builder removed.\n\r", ch);
01170         return TRUE;
01171     }
01172     else
01173     {
01174         buf[0] = '\0';
01175         if (strstr (pArea->builders, "None") != '\0')
01176         {
01177             pArea->builders = string_replace (pArea->builders, "None", "\0");
01178             pArea->builders = string_unpad (pArea->builders);
01179         }
01180 
01181         if (pArea->builders[0] != '\0')
01182         {
01183             strcat (buf, pArea->builders);
01184             strcat (buf, " ");
01185         }
01186         strcat (buf, name);
01187         free_string (pArea->builders);
01188         pArea->builders = string_proper (str_dup (buf));
01189 
01190         send_to_char ("Builder added.\n\r", ch);
01191         send_to_char (pArea->builders, ch);
01192         return TRUE;
01193     }
01194 
01195     return FALSE;
01196 }

01102 {
01103     AREA_DATA *pArea;
01104     char sec[MAX_STRING_LENGTH];
01105     char buf[MAX_STRING_LENGTH];
01106     int value;
01107 
01108     EDIT_AREA (ch, pArea);
01109 
01110     one_argument (argument, sec);
01111 
01112     if (!is_number (sec) || sec[0] == '\0')
01113     {
01114         send_to_char ("Syntax:  security [#xlevel]\n\r", ch);
01115         return FALSE;
01116     }
01117 
01118     value = atoi (sec);
01119 
01120     if (value > ch->pcdata->security || value < 0)
01121     {
01122         if (ch->pcdata->security != 0)
01123         {
01124             sprintf (buf, "Security is 0-%d.\n\r", ch->pcdata->security);
01125             send_to_char (buf, ch);
01126         }
01127         else
01128             send_to_char ("Security is 0 only.\n\r", ch);
01129         return FALSE;
01130     }
01131 
01132     pArea->security = value;
01133 
01134     send_to_char ("Security set.\n\r", ch);
01135     return TRUE;
01136 }

01047 {
01048     AREA_DATA *pArea;
01049     char age[MAX_STRING_LENGTH];
01050 
01051     EDIT_AREA (ch, pArea);
01052 
01053     one_argument (argument, age);
01054 
01055     if (!is_number (age) || age[0] == '\0')
01056     {
01057         send_to_char ("Syntax:  age [#xage]\n\r", ch);
01058         return FALSE;
01059     }
01060 
01061     pArea->age = atoi (age);
01062 
01063     send_to_char ("Age set.\n\r", ch);
01064     return TRUE;
01065 }

00999 {
01000     AREA_DATA *pArea;
01001     char file[MAX_STRING_LENGTH];
01002     int i, length;
01003 
01004     EDIT_AREA (ch, pArea);
01005 
01006     one_argument (argument, file);    /* Forces Lowercase */
01007 
01008     if (argument[0] == '\0')
01009     {
01010         send_to_char ("Syntax:  filename [$file]\n\r", ch);
01011         return FALSE;
01012     }
01013 
01014     /*
01015      * Simple Syntax Check.
01016      */
01017     length = strlen (argument);
01018     if (length > 8)
01019     {
01020         send_to_char ("No more than eight characters allowed.\n\r", ch);
01021         return FALSE;
01022     }
01023 
01024     /*
01025      * Allow only letters and numbers.
01026      */
01027     for (i = 0; i < length; i++)
01028     {
01029         if (!isalnum (file[i]))
01030         {
01031             send_to_char ("Only letters and numbers are valid.\n\r", ch);
01032             return FALSE;
01033         }
01034     }
01035 
01036     free_string (pArea->file_name);
01037     strcat (file, ".are");
01038     pArea->file_name = str_dup (file);
01039 
01040     send_to_char ("Filename set.\n\r", ch);
01041     return TRUE;
01042 }

00979 {
00980     AREA_DATA *pArea;
00981 
00982     EDIT_AREA (ch, pArea);
00983 
00984     if (argument[0] == '\0')
00985     {
00986         send_to_char ("Syntax:   credits [$credits]\n\r", ch);
00987         return FALSE;
00988     }
00989 
00990     free_string (pArea->credits);
00991     pArea->credits = str_dup (argument);
00992 
00993     send_to_char ("Credits set.\n\r", ch);
00994     return TRUE;
00995 }

00953 {
00954     AREA_DATA *pArea;
00955     EDIT_AREA(ch,pArea);
00956 
00957     if (argument[0] == '\0')
00958     {
00959         send_to_char("Syntax: cont <contname> -- do 'cshow' for a list of continents.\n\r",ch);
00960         return FALSE;
00961     }
00962 
00963     free_string (pArea->cont);
00964     if (cont_lookup(argument) != 0)
00965     {
00966         pArea->cont = str_dup(conts_table[cont_lookup(argument)].name);
00967         send_to_char("Continent set.\n\r",ch);
00968         return TRUE;
00969     }
00970     else
00971     {
00972         send_to_char ("Invalid Continent. Use 'cshow' to view current continents.\n\r",ch);
00973         return FALSE;
00974     }
00975     return TRUE;
00976 }

00935 {
00936     AREA_DATA *pArea;
00937 
00938     EDIT_AREA (ch, pArea);
00939 
00940     if (argument[0] == '\0')
00941     {
00942         send_to_char ("Syntax:   name [$name]\n\r", ch);
00943         return FALSE;
00944     }
00945 
00946     free_string (pArea->name);
00947     pArea->name = str_dup (argument);
00948 
00949     send_to_char ("Name set.\n\r", ch);
00950     return TRUE;
00951 }

00919 {
00920     AREA_DATA *pArea;
00921 
00922     pArea = new_area ();
00923     area_last->next = pArea;
00924     area_last = pArea;            /* Thanks, Walker. */
00925     ch->desc->pEdit = (void *) pArea;
00926 
00927     SET_BIT (pArea->area_flags, AREA_ADDED);
00928     send_to_char ("Area Created.\n\r", ch);
00929     return FALSE;
00930 }

00907 {
00908     AREA_DATA *pArea;
00909 
00910     EDIT_AREA (ch, pArea);
00911 
00912     reset_area (pArea);
00913     send_to_char ("Area reset.\n\r", ch);
00914 
00915     return FALSE;
00916 }

00859 {
00860     AREA_DATA *pArea;
00861     char buf[MAX_STRING_LENGTH];
00862 
00863     EDIT_AREA (ch, pArea);
00864 
00865     sprintf (buf, "Name:     [{c%5d{x] {c%s{x\n\r", pArea->vnum, pArea->name);
00866     send_to_char (buf, ch);
00867 
00868 #if 0                            /* ROM OLC */
00869     sprintf (buf, "Recall:   [%5d] %s\n\r", pArea->recall,
00870              get_room_index (pArea->recall)
00871              ? get_room_index (pArea->recall)->name : "none");
00872     send_to_char (buf, ch);
00873 #endif /* ROM */
00874 
00875     sprintf (buf, "File:     {c%s{x\n\r", pArea->file_name);
00876     send_to_char (buf, ch);
00877 
00878     sprintf (buf, "Vnums:    [{c%d{w-{c%d{x]\n\r", pArea->min_vnum, pArea->max_vnum);
00879     send_to_char (buf, ch);
00880 
00881     sprintf (buf, "Age:      [{c%d{x]\n\r", pArea->age);
00882     send_to_char (buf, ch);
00883 
00884     sprintf (buf, "Players:  [{c%d{x]\n\r", pArea->nplayer);
00885     send_to_char (buf, ch);
00886 
00887     sprintf (buf, "Security: [{c%d{x]\n\r", pArea->security);
00888     send_to_char (buf, ch);
00889 
00890     sprintf (buf, "Builders: [{c%s{x]\n\r", pArea->builders);
00891     send_to_char (buf, ch);
00892 
00893     sprintf (buf, "Credits : [{c%s{x]\n\r", pArea->credits);
00894     send_to_char (buf, ch);
00895 
00896     sprintf (buf, "Flags:    [{c%s{x]\n\r",
00897              flag_string (area_flags, pArea->area_flags));
00898     send_to_char (buf, ch);
00899 
00900     sprintf(buf, "Cont:     [{c%s{x]\n\r", pArea->cont);
00901     send_to_char(buf,ch);
00902 
00903     return FALSE;
00904 }

01617 {
01618     ROOM_INDEX_DATA *pRoom;
01619     char command[MAX_INPUT_LENGTH];
01620     char arg[MAX_INPUT_LENGTH];
01621     int value;
01622 
01623     EDIT_ROOM (ch, pRoom);
01624 
01625     /*
01626      * Set the exit flags, needs full argument.
01627      * ----------------------------------------
01628      */
01629     if ((value = flag_value (exit_flags, argument)) != NO_FLAG)
01630     {
01631         ROOM_INDEX_DATA *pToRoom;
01632         sh_int rev;                /* ROM OLC */
01633 
01634         if (!pRoom->exit[door])
01635         {
01636             send_to_char ("Exit doesn't exist.\n\r", ch);
01637             return FALSE;
01638         }
01639 
01640         /*
01641          * This room.
01642          */
01643         TOGGLE_BIT (pRoom->exit[door]->rs_flags, value);
01644         /* Don't toggle exit_info because it can be changed by players. */
01645         pRoom->exit[door]->exit_info = pRoom->exit[door]->rs_flags;
01646 
01647         /*
01648          * Connected room.
01649          */
01650         pToRoom = pRoom->exit[door]->u1.to_room;    /* ROM OLC */
01651         rev = rev_dir[door];
01652 
01653         if (pToRoom->exit[rev] != NULL)
01654         {
01655             pToRoom->exit[rev]->rs_flags = pRoom->exit[door]->rs_flags;
01656             pToRoom->exit[rev]->exit_info = pRoom->exit[door]->exit_info;
01657         }
01658 
01659         send_to_char ("Exit flag toggled.\n\r", ch);
01660         return TRUE;
01661     }
01662 
01663     /*
01664      * Now parse the arguments.
01665      */
01666     argument = one_argument (argument, command);
01667     one_argument (argument, arg);
01668 
01669     if (command[0] == '\0' && argument[0] == '\0')
01670     {                            /* Move command. */
01671         move_char (ch, door, TRUE);    /* ROM OLC */
01672         return FALSE;
01673     }
01674 
01675     if (command[0] == '?')
01676     {
01677         do_help (ch, "EXIT");
01678         return FALSE;
01679     }
01680 
01681     if (!str_cmp (command, "delete"))
01682     {
01683         ROOM_INDEX_DATA *pToRoom;
01684         sh_int rev;                /* ROM OLC */
01685 
01686         if (!pRoom->exit[door])
01687         {
01688             send_to_char ("REdit:  Cannot delete a null exit.\n\r", ch);
01689             return FALSE;
01690         }
01691 
01692         /*
01693          * Remove ToRoom Exit.
01694          */
01695         rev = rev_dir[door];
01696         pToRoom = pRoom->exit[door]->u1.to_room;    /* ROM OLC */
01697 
01698         if (pToRoom->exit[rev])
01699         {
01700             free_exit (pToRoom->exit[rev]);
01701             pToRoom->exit[rev] = NULL;
01702         }
01703 
01704         /*
01705          * Remove this exit.
01706          */
01707         free_exit (pRoom->exit[door]);
01708         pRoom->exit[door] = NULL;
01709 
01710         send_to_char ("Exit unlinked.\n\r", ch);
01711         return TRUE;
01712     }
01713 
01714     if (!str_cmp (command, "link"))
01715     {
01716         EXIT_DATA *pExit;
01717         ROOM_INDEX_DATA *toRoom;
01718 
01719         if (arg[0] == '\0' || !is_number (arg))
01720         {
01721             send_to_char ("Syntax:  [direction] link [vnum]\n\r", ch);
01722             return FALSE;
01723         }
01724 
01725         value = atoi (arg);
01726 
01727         if (!(toRoom = get_room_index (value)))
01728         {
01729             send_to_char ("REdit:  Cannot link to non-existant room.\n\r",
01730                           ch);
01731             return FALSE;
01732         }
01733 
01734         if (!IS_BUILDER (ch, toRoom->area))
01735         {
01736             send_to_char ("REdit:  Cannot link to that area.\n\r", ch);
01737             return FALSE;
01738         }
01739 
01740         if (toRoom->exit[rev_dir[door]])
01741         {
01742             send_to_char ("REdit:  Remote side's exit already exists.\n\r",
01743                           ch);
01744             return FALSE;
01745         }
01746 
01747         if (!pRoom->exit[door])
01748             pRoom->exit[door] = new_exit ();
01749 
01750         pRoom->exit[door]->u1.to_room = toRoom;
01751         pRoom->exit[door]->orig_door = door;
01752 
01753         door = rev_dir[door];
01754         pExit = new_exit ();
01755         pExit->u1.to_room = pRoom;
01756         pExit->orig_door = door;
01757         toRoom->exit[door] = pExit;
01758 
01759         send_to_char ("Two-way link established.\n\r", ch);
01760         return TRUE;
01761     }
01762 
01763     if (!str_cmp (command, "dig"))
01764     {
01765         char buf[MAX_STRING_LENGTH];
01766 
01767         if (arg[0] == '\0' || !is_number (arg))
01768         {
01769             send_to_char ("Syntax: [direction] dig <vnum>\n\r", ch);
01770             return FALSE;
01771         }
01772 
01773         redit_create (ch, arg);
01774         sprintf (buf, "link %s", arg);
01775         change_exit (ch, buf, door);
01776         return TRUE;
01777     }
01778 
01779     if (!str_cmp (command, "room"))
01780     {
01781         ROOM_INDEX_DATA *toRoom;
01782 
01783         if (arg[0] == '\0' || !is_number (arg))
01784         {
01785             send_to_char ("Syntax:  [direction] room [vnum]\n\r", ch);
01786             return FALSE;
01787         }
01788 
01789         value = atoi (arg);
01790 
01791         if (!(toRoom = get_room_index (value)))
01792         {
01793             send_to_char ("REdit:  Cannot link to non-existant room.\n\r",
01794                           ch);
01795             return FALSE;
01796         }
01797 
01798         if (!pRoom->exit[door])
01799             pRoom->exit[door] = new_exit ();
01800 
01801         pRoom->exit[door]->u1.to_room = toRoom;    /* ROM OLC */
01802         pRoom->exit[door]->orig_door = door;
01803 
01804         send_to_char ("One-way link established.\n\r", ch);
01805         return TRUE;
01806     }
01807 
01808     if (!str_cmp (command, "key"))
01809     {
01810         OBJ_INDEX_DATA *key;
01811 
01812         if (arg[0] == '\0' || !is_number (arg))
01813         {
01814             send_to_char ("Syntax:  [direction] key [vnum]\n\r", ch);
01815             return FALSE;
01816         }
01817 
01818         if (!pRoom->exit[door])
01819         {
01820             send_to_char ("Exit doesn't exist.\n\r", ch);
01821             return FALSE;
01822         }
01823 
01824         value = atoi (arg);
01825 
01826         if (!(key = get_obj_index (value)))
01827         {
01828             send_to_char ("REdit:  Key doesn't exist.\n\r", ch);
01829             return FALSE;
01830         }
01831 
01832         if (key->item_type != ITEM_KEY)
01833         {
01834             send_to_char ("REdit:  Object is not a key.\n\r", ch);
01835             return FALSE;
01836         }
01837 
01838         pRoom->exit[door]->key = value;
01839 
01840         send_to_char ("Exit key set.\n\r", ch);
01841         return TRUE;
01842     }
01843 
01844     if (!str_cmp (command, "name"))
01845     {
01846         if (arg[0] == '\0')
01847         {
01848             send_to_char ("Syntax:  [direction] name [string]\n\r", ch);
01849             send_to_char ("         [direction] name none\n\r", ch);
01850             return FALSE;
01851         }
01852 
01853         if (!pRoom->exit[door])
01854         {
01855             send_to_char ("Exit doesn't exist.\n\r", ch);
01856             return FALSE;
01857         }
01858 
01859         free_string (pRoom->exit[door]->keyword);
01860 
01861         if (str_cmp (arg, "none"))
01862             pRoom->exit[door]->keyword = str_dup (arg);
01863         else
01864             pRoom->exit[door]->keyword = str_dup ("");
01865 
01866         send_to_char ("Exit name set.\n\r", ch);
01867         return TRUE;
01868     }
01869 
01870     if (!str_prefix (command, "description"))
01871     {
01872         if (arg[0] == '\0')
01873         {
01874             if (!pRoom->exit[door])
01875             {
01876                 send_to_char ("Exit doesn't exi


Defines
#define	AEDIT(fun) bool fun( CHAR_DATA ch, char argument )
#define	ALT_FLAGVALUE_SET(_blargh, _table, _arg)
#define	ALT_FLAGVALUE_TOGGLE(_blargh, _table, _arg)
#define	HEDIT(fun) bool fun( CHAR_DATA ch, char argument )
#define	MEDIT(fun) bool fun( CHAR_DATA ch, char argument )
#define	OEDIT(fun) bool fun( CHAR_DATA ch, char argument )
#define	REDIT(fun) bool fun( CHAR_DATA ch, char argument )
#define	SEDIT(fun) bool fun( CHAR_DATA ch, char argument )
Functions
	AEDIT (aedit_uvnum)
	AEDIT (aedit_lvnum)
	AEDIT (aedit_vnum)
	AEDIT (aedit_delete)
	AEDIT (aedit_builder)
	AEDIT (aedit_security)
	AEDIT (aedit_age)
	AEDIT (aedit_file)
	AEDIT (aedit_credits)
	AEDIT (aedit_cont)
	AEDIT (aedit_name)
	AEDIT (aedit_create)
	AEDIT (aedit_reset)
	AEDIT (aedit_show)
bool	change_exit (CHAR_DATA ch, char argument, int door)
bool	check_range (int lower, int upper)
AREA_DATA *	get_vnum_area (int vnum)
	HEDIT (hedit_delete)
	HEDIT (hedit_level)
	HEDIT (hedit_keywords)
	HEDIT (hedit_desc)
	HEDIT (hedit_show)
	HEDIT (hedit_make)
	MEDIT (medit_delmprog)
	MEDIT (medit_addmprog)
	MEDIT (medit_group)
	MEDIT (medit_hitroll)
	MEDIT (medit_gold)
	MEDIT (medit_position)
	MEDIT (medit_race)
	MEDIT (medit_damdice)
	MEDIT (medit_manadice)
	MEDIT (medit_hitdice)
	MEDIT (medit_size)
	MEDIT (medit_off)
	MEDIT (medit_material)
	MEDIT (medit_vuln)
	MEDIT (medit_res)
	MEDIT (medit_imm)
	MEDIT (medit_part)
	MEDIT (medit_form)
	MEDIT (medit_affect)
	MEDIT (medit_act)
	MEDIT (medit_sex)
	MEDIT (medit_shop)
	MEDIT (medit_name)
	MEDIT (medit_short)
	MEDIT (medit_long)
	MEDIT (medit_desc)
	MEDIT (medit_level)
	MEDIT (medit_align)
	MEDIT (medit_damtype)
	MEDIT (medit_spec)
	MEDIT (medit_create)
	MEDIT (medit_show)
char *	mprog_type_to_name (int type)
	OEDIT (oedit_condition)
	OEDIT (oedit_level)
	OEDIT (oedit_material)
	OEDIT (oedit_type)
	OEDIT (oedit_wear)
	OEDIT (oedit_extra)
	OEDIT (oedit_ed)
	OEDIT (oedit_create)
	OEDIT (oedit_cost)
	OEDIT (oedit_weight)
	OEDIT (oedit_value4)
	OEDIT (oedit_value3)
	OEDIT (oedit_value2)
	OEDIT (oedit_value1)
	OEDIT (oedit_value0)
	OEDIT (oedit_long)
	OEDIT (oedit_short)
	OEDIT (oedit_name)
	OEDIT (oedit_delaffect)
	OEDIT (oedit_addapply)
	OEDIT (oedit_addaffect)
	OEDIT (oedit_show)
bool	oedit_values (CHAR_DATA ch, char argument, int value)
	REDIT (redit_sector)
	REDIT (redit_extra)
	REDIT (redit_delete)
	REDIT (redit_copy)
	REDIT (redit_room)
	REDIT (redit_owner)
	REDIT (redit_oreset)
	REDIT (redit_mreset)
	REDIT (redit_format)
	REDIT (redit_clan)
	REDIT (redit_mana)
	REDIT (redit_heal)
	REDIT (redit_night_desc)
	REDIT (redit_dfix)
	REDIT (redit_desc)
	REDIT (redit_name)
	REDIT (redit_create)
	REDIT (redit_ed)
	REDIT (redit_down)
	REDIT (redit_up)
	REDIT (redit_west)
	REDIT (redit_east)
	REDIT (redit_south)
	REDIT (redit_north)
	REDIT (redit_show)
	REDIT (redit_ttype)
	REDIT (redit_tstate)
	REDIT (redit_troute)
	REDIT (redit_oshow)
	REDIT (redit_mshow)
	REDIT (redit_olist)
	REDIT (redit_mlist)
	REDIT (redit_rlist)
	SEDIT (sedit_delete)
	SEDIT (sedit_char_not_found)
	SEDIT (sedit_others_auto)
	SEDIT (sedit_char_auto)
	SEDIT (sedit_others_found)
	SEDIT (sedit_vict_found)
	SEDIT (sedit_char_found)
	SEDIT (sedit_others_no_arg)
	SEDIT (sedit_char_no_arg)
	SEDIT (sedit_show)
	SEDIT (sedit_create)
bool	set_obj_values (CHAR_DATA ch, OBJ_INDEX_DATA pObj, int value_num, char *argument)
bool	set_value (CHAR_DATA ch, OBJ_INDEX_DATA pObj, char *argument, int value)
void	show_damlist (CHAR_DATA *ch)
void	show_flag_cmds (CHAR_DATA ch, const struct flag_type flag_table)
bool	show_help (CHAR_DATA ch, char argument)
void	show_liqlist (CHAR_DATA *ch)
void	show_obj_values (CHAR_DATA ch, OBJ_INDEX_DATA obj)
void	show_skill_cmds (CHAR_DATA *ch, int tar)
void	show_spec_cmds (CHAR_DATA *ch)
bool	show_version (CHAR_DATA ch, char argument)
int	wear_bit (int loc)
int	wear_loc (int bits, int count)
Variables
const struct olc_help_type	help_table []
const struct wear_type	wear_table []

olc_act.c File Reference

Defines

Functions

Variables

Define Documentation

Function Documentation