ACT_COMM.c
void do_pray(CHAR_DATA * ch, char *argument) /* Order by Muerte */
{
DESCRIPTOR_DATA *d;
act_new("You get down on your knees and pray to the gods '$t'", ch, argument, NULL, TO_CHAR, POS_DEAD);
act("$n drops to $s knees and prays.", ch, NULL, argument, TO_ROOM);
for (d = descriptor_list; d != NULL; d = d->next)
{
if (d->connected == CON_PLAYING && IS_IMMORTAL(d->character))
{
if (ch->order)
printf_to_char(d->character, "{WPray [{M%s{W] [%s of %s]:{w %s{x.\n\r", ch->name, ch->order_ptr->rank[ch->orderrank].rankname, ch->order_ptr->patron, argument);
else
printf_to_char(d->character, "{WPray [{M%s{W] {w%s{x.\n\r", ch->name, argument);
}
}
return;
}
ACT_INFO.C
do_score:
/* Add and format anywhere you like */
if (ch->order) /* Order by Muerte */
printf_to_char(ch, "{wReligion: {W%s {xof{W %s{x.\n\r",
!str_cmp(ch->name, ch->order_ptr->patron) ? "Patron" : player_orderrank(ch),
!str_cmp(ch->name, ch->order_ptr->patron) ? ch->order_ptr->name : ch->order_ptr->patron);
DB.C
do_boot:
before->
/*
* Read in all the area files.
*/
add->
load_orderlist(); /* Order by Muerte */
INTERP.C
/* I use grant, If you don't, you want to make the IM/OLC commands leveled however you want */
cmd_table add->
/* Order Stuff by Muerte */
{"patron", do_patron, POS_RESTING, 0, LOG_NORMAL, 1, 0},
{"unpatron", do_unpatron, POS_RESTING, 0, LOG_NORMAL, 1, 0},
{"orderrank", do_orderrank, POS_RESTING, 0, LOG_NORMAL, 1, 0},
{"followers", do_followers, POS_RESTING, 0, LOG_NORMAL, 1, 0},
{"pray", do_pray, POS_DEAD, 0, LOG_NORMAL, 0, 0},
/* Order OLC by Muerte */
{"orlist", do_orlist, POS_DEAD, IM, LOG_NORMAL, 0, 0},
{"oredit", do_oredit, POS_DEAD, IM, LOG_NORMAL, 0, 0},
{"orsave", do_orsave, POS_DEAD, IM, LOG_NORMAL, 0, 0},
INTERP.H
add->
DECLARE_DO_FUN( do_patron ); /* Order by Muerte */
DECLARE_DO_FUN( do_unpatron ); /* Order by Muerte */
DECLARE_DO_FUN( do_orderrank ); /* Order by Muerte */
DECLARE_DO_FUN( do_followers ); /* Order by Muerte */
DECLARE_DO_FUN( do_orlist ); /* Order by Muerte */
DECLARE_DO_FUN( do_oredit ); /* Order by Muerte */
DECLARE_DO_FUN( do_orsave ); /* Order by Muerte */
MERC.H
add with like types ->
typedef struct order_data ORDER_DATA; /* Order by Muerte */
typedef struct ordermem_data ORDERMEM_DATA;
typedef struct order_rank order_rankdata;
#define MAX_GODS 2
#define MAX_ORDER 10
#define MAX_ORDERRANK 10
#define ORDER_LIST "../order/order.lst" /* Order by Muerte */
#define ORDER_DIR "../order/"
extern ORDER_DATA * order_first; /* Order by Muerte */
extern ORDER_DATA * order_last;
extern ORDERMEM_DATA * ordermem_first;
extern ORDERMEM_DATA * ordermem_last;
extern int top_order;
extern const struct god_type god_table [MAX_GODS];
add-> char_data
ORDER_DATA * order_ptr; /* Order by Muerte */
char * order; /* Order by Muerte */
sh_int orderrank; /* Order by Muerte */
add-> room_index_data
ORDER_DATA * order; /* Order by Muerte */
add-> /* olc.c */
void save_order args( (ORDER_DATA * pGuild) ); /* Order by Muerte */
ORDER_DATA *get_order_data args( ( int order ) ); /* Order by Muerte */
int add_ordermem args((ORDERMEM_DATA * mMemb)); /* Order by Muerte */
int del_ordermem args((char * name_of_player)); /* Order by Muerte */
add-> /* olc_save.c */
void do_saveorder args( ( CHAR_DATA *ch, char *argument ) ); /* Order by Muerte */
add-> at end of file
/* Order flags by Muerte */
#define ORDER_DELETED A
#define ORDER_CHANGED B
#define ORDER_INDEPENDENT C /* a "loner" order */
#define ORDER_ADDED D
/* order.c by Muerte */
struct order_data order_table[MAX_ORDER];
char * order_bit_name args( ( int order_flags ) );
bool is_order args( (CHAR_DATA *ch) );
bool is_same_order args( (CHAR_DATA *ch, CHAR_DATA *victim) );
ORDER_DATA *order_lookup args( (const char *name) );
ORDER_DATA *order_name args((CHAR_DATA *ch));
void do_order args( (CHAR_DATA *ch, char *argument ) );
char *player_orderrank args( (CHAR_DATA *ch) );
char *player_order args( (CHAR_DATA *ch) );
void load_orderlist args(());
bool can_order args( (CHAR_DATA *ch) );
bool can_deorder args( (CHAR_DATA *ch) );
bool can_orderpromote args( (CHAR_DATA *ch) );
bool can_orderdemote args( (CHAR_DATA *ch) );
struct order_rank /* Order by Muerte */
{
char *rankname; /* name of rank */
};
struct ordermem_data /* Order by Muerte */
{
ORDERMEM_DATA * next;
ORDER_DATA * order;
char *name; /* Follower Name */
int rank; /* Rank of Follower */
};
struct order_data /* Order by Muerte */
{
ORDER_DATA * next;
int vnum;
char *file_name;
char *patron; /* name of patron */
char *name; /* name of order */
order_rankdata rank[MAX_ORDERRANK]; /* orders rank system */
int ml[4]; /* mortal leader rights */
long flags; /* flags for order */
int members;
ORDERMEM_DATA *ordermem;
};
struct god_type /* Order by Muerte */
{
char * name; /* God's Name */
char * desc; /* Brief Description */
char * holy_symbol;
char * prof;
sh_int align_compat[9]; /* Alignment compatability */
sh_int class_compat[11+2]; /* Class compatibility */
sh_int align; /* God's alignment */
sh_int race_compat[8]; /* Racial compatibility */
};
OLC.H
add-> conn state
#define ED_ORDER (Next number in line) /* Order by Muerte */
add-> Utils
ORDER_DATA *get_order_data args ((int vnum)); /* Order by Muerte */
add-> room editor prototypes
DECLARE_OLC_FUN( redit_order ); /* Order by Muerte */
add-> below other prototypes
/* Order Editor Prototypes by Muerte */
DECLARE_OLC_FUN( oredit_flags );
DECLARE_OLC_FUN( oredit_rank );
DECLARE_OLC_FUN( oredit_name );
DECLARE_OLC_FUN( oredit_show );
DECLARE_OLC_FUN( oredit_create );
DECLARE_OLC_FUN( oredit_list );
DECLARE_OLC_FUN( oredit_rooms );
DECLARE_OLC_FUN( oredit_ml );
DECLARE_OLC_FUN( oredit_patron );
DECLARE_OLC_FUN( oredit_file );
add-> Return Pointers
#define EDIT_ORDER(Ch, Order) ( Order = Ch->desc->pEdit ) /* Order by Muerte */
add -> mem.c prototype
ORDER_DATA *new_order args ( ( void ) ); /* Order by Muerte */
void free_order args ( ( ORDER_DATA *pOrder ) ); /* Order by Muerte */
add -> interp prototype
void oredit args( ( CHAR_DATA *ch, char *argument ) ); /* Order by Muerte */
add -> interp table prototype
extern const struct olc_cmd_type oredit_table[]; /* Order by Muerte */
add -> editor commands
DECLARE_DO_FUN( do_oredit ); /* Order by Muerte */
MEM.c
add -> ROOM_INDEX_DATA *new_room_index(void)
pRoom->order = 0; /* Order by Muerte */
add -> end of file
extern int top_order; /* Order by Muerte */
ORDER_DATA *order_free; /* Order by Muerte */
ORDER_DATA *new_order(void) /* Order by Muerte */
{
ORDER_DATA *pOrder;
char buf[MAX_INPUT_LENGTH];
int i;
if (!order_free)
{
pOrder = alloc_perm(sizeof(*pOrder));
top_order++;
}
else
{
pOrder = order_free;
order_free = order_free->next;
}
pOrder->next = NULL;
pOrder->name = str_dup("New Order");
pOrder->patron = str_dup("Ao");
pOrder->rank[0].rankname = str_dup("Believer");
pOrder->rank[1].rankname = str_dup("Follower");
pOrder->rank[2].rankname = str_dup("Worshipper");
pOrder->rank[3].rankname = str_dup("Faithful");
pOrder->rank[4].rankname = str_dup("Devoted");
pOrder->rank[5].rankname = str_dup("Junior Priest");
pOrder->rank[6].rankname = str_dup("Priest");
pOrder->rank[7].rankname = str_dup("High Priest");
pOrder->rank[8].rankname = str_dup("Chosen One");
pOrder->rank[9].rankname = str_dup("Patron");
for(i=0; i < 4; i++)
{
pOrder->ml[i] = 0;
}
pOrder->flags = ORDER_ADDED;
sprintf(buf, "order%d.ord", pOrder->vnum);
pOrder->file_name = str_dup(buf);
pOrder->vnum = top_order - 1;
return pOrder;
}
void free_order(ORDER_DATA * pOrder) /* Order by Muerte */
{
free_string(pOrder->name);
free_string(pOrder->file_name);
pOrder->next = order_free->next;
order_free = pOrder;
return;
}
OLC.C
add -> bool run_olc_editor(DESCRIPTOR_DATA * d)
case ED_ORDER: /* Order by Muerte */
oredit(d->character, d->incomm);
break;
add -> char *olc_ed_name(CHAR_DATA * ch)
case ED_ORDER: /* Order by Muerte */
sprintf(buf, "OrEdit");
break;
add -> bool show_commands(CHAR_DATA * ch, char *argument)
case ED_ORDER: /* Order by Muerte */
show_olc_cmds( ch, oredit_table );
break;
add -> with other command tables
/* Order edit command table by Muerte */
const struct olc_cmd_type oredit_table[] =
{
{ "commands", show_commands },
{ "create", oredit_create },
{ "flag", oredit_flags },
{ "list", oredit_list },
{ "ml", oredit_ml },
{ "name", oredit_name },
{ "patron", oredit_patron },
{ "rank", oredit_rank },
{ "show", oredit_show },
{ "filename", oredit_file },
{ "?", show_help },
{ NULL, 0 }
};
add -> const struct editor_cmd_type editor_table[] = {
{ "order", do_oredit }, /* Order by Muerte */
add -> at end of file
void do_oredit( CHAR_DATA *ch, char *argument ) /* Order by Muerte */
{
ORDER_DATA *pOrder;
int value;
char arg[MAX_STRING_LENGTH];
argument = one_argument(argument,arg);
if ( IS_NPC(ch) )
return;
if (is_number(arg))
{
value = atoi(arg) -1;
if (!(pOrder = get_order_data(value)))
{
send_to_char("That order vnum does not exist.\n\r", ch);
return;
}
}
if (( arg[0] == '\0') || (!str_cmp(arg,"list")))
{
send_to_char("Syntax: oredit <order name>\n\r", ch);
do_function(ch, &do_orlist, "");
return;
}
else if ( !str_cmp( arg, "create" ) )
{
oredit_create( ch, "" );
ch->desc->editor = ED_ORDER;
return;
}
if (!is_number(arg))
pOrder = order_lookup(arg);
ch->desc->pEdit = (void *) pOrder;
ch->desc->editor = ED_ORDER;
return;
}
void oredit( CHAR_DATA *ch, char *argument ) /* Order by Muerte */
{
ORDER_DATA *pOrder;
char command[MIL];
char arg[MIL];
int cmd;
EDIT_ORDER(ch, pOrder);
smash_tilde( argument );
strcpy( arg, argument );
argument = one_argument( argument, command );
if ( !str_cmp(command, "done") )
{
edit_done( ch );
return;
}
if ( command[0] == '\0' )
{
oredit_show( ch, argument );
return;
}
// Search Table and Dispatch Command.
for ( cmd = 0; oredit_table[cmd].name != NULL; cmd++ )
{
if ( !str_prefix( command, oredit_table[cmd].name ) )
{
if ( (*oredit_table[cmd].olc_fun) ( ch, argument ) )
{
SET_BIT( pOrder->flags, ORDER_CHANGED );
return;
}
else
return;
}
}
// Default to Standard Interpreter.
interpret( ch, arg );
return;
}
void do_orlist(CHAR_DATA * ch, char *argument) /* Order by Muerte */
{
ORDER_DATA *pOrder;
char buf[MAX_STRING_LENGTH];
char result[MAX_STRING_LENGTH * 2]; /* May need tweaking. */
int i = 0;
if (IS_NPC(ch))
return;
sprintf(result, "[%3s] [%-27s]\n\r", "Num", "Order Name");
for (pOrder = order_first; pOrder; pOrder = pOrder->next)
{
i++;
sprintf(buf, "[%3d] %-29.29s %s\n\r", i, pOrder->name, IS_SET(pOrder->flags, ORDER_CHANGED) ? "[CHANGED]" : "");
strcat(result, buf);
}
send_to_char(result, ch);
return;
}
OLC_ACT.c
add -> REDIT( redit_copy )
pRoom->order = pRoom2->order; /* Order by Muerte */
add -> REDIT(redit_show)
if (pRoom->order > 0) /* Order by Muerte */
{
sprintf(buf, "Order : %s\n\r", pRoom->order->name);
strcat(buf1, buf);
}
add -> in REDIT stuff
REDIT(redit_order) /* Order by Muerte */
{
ROOM_INDEX_DATA *pRoom;
EDIT_ROOM(ch, pRoom);
pRoom->order = order_lookup(argument);
send_to_char("Order set.\n\r", ch);
return TRUE;
}
add-> at end of file
/* Order Editor by Muerte */
OREDIT( oredit_flags ) /* Order by Muerte */
{
ORDER_DATA *pOrder;
long value = 0;
if ( argument[0] != '\0' )
{
EDIT_ORDER( ch, pOrder );
if ( ( value = flag_value( order_flags, argument ) ) != NO_FLAG )
{
pOrder->flags ^= value;
send_to_char( "Order flag(s) toggled.\n\r", ch);
return TRUE;
}
}
send_to_char( "Syntax: flag [flag ID]\n\r"
"Type '? order' for a list of valid flags.\n\r", ch );
return FALSE;
}
OREDIT( oredit_rank ) /* Order by Muerte */
{
ORDER_DATA *pOrder;
char arg1[4];
EDIT_ORDER(ch, pOrder);
argument = one_argument(argument, arg1);
if (is_number(arg1) && atoi(arg1) <= MAX_ORDERRANK)
{
int value;
value = atoi(arg1) -1;
if (argument[0] != '\0')
{
free_string(pOrder->rank[value].rankname);
pOrder->rank[value].rankname = str_dup( argument );
send_to_char("Rank name changed.\n\r", ch);
return TRUE;
}
}
send_to_char("Syntax: rank rank# newname\n\r", ch);
return FALSE;
}
OREDIT(oredit_create) /* Order by Muerte */
{
ORDER_DATA *pOrder;
pOrder = new_order();
order_last->next = pOrder;
order_last = pOrder;
ch->desc->pEdit = (void *) pOrder;
send_to_char("Order Created.\n\r", ch);
return FALSE;
}
OREDIT(oredit_name) /* Order by Muerte */
{
ORDER_DATA *pOrder;
EDIT_ORDER(ch, pOrder);
if (argument[0] == '\0')
{
send_to_char("Syntax: name [$name]\n\r", ch);
return FALSE;
}
free_string(pOrder->name);
pOrder->name = str_dup(argument);
send_to_char("Name set.\n\r", ch);
return TRUE;
}
OREDIT( oredit_list ) /* Order by Muerte */
{
char buf[MIL];
BUFFER *buffer;
int i;
buffer = new_buf();
sprintf(buf, "Num Order Name Flags\n\r-----------------------------------------------\n\r");
add_buf(buffer, buf);
for (i=1; i <= MAX_ORDER; i++)
{
if (order_table[i].name != NULL && order_table[i].name[0] != '\0')
{
sprintf(buf,"[%2d] %s\t Flags:\t[%s]\n\r",
i, order_table[i].name, flag_string( order_flags, order_table[i].flags ) );
add_buf(buffer, buf);
}
}
page_to_char( buf_string(buffer), ch );
free_buf(buffer);
return FALSE;
}
OREDIT( oredit_show ) /* Order by Muerte */
{
ORDER_DATA *pOrder;
char buf[MSL];
int i;
EDIT_ORDER(ch, pOrder);
sprintf(buf, "File: %s\n\r", pOrder->file_name);
send_to_char(buf, ch);
sprintf(buf, "Name: %s\n\r", pOrder->name);
send_to_char(buf, ch);
sprintf(buf, "Order Patron: %s\n\r", pOrder->patron);
send_to_char(buf, ch);
sprintf(buf, "Flags: [%s]\n\r\n\r", flag_string( order_flags, pOrder->flags ) );
send_to_char(buf, ch);
sprintf(buf, "# Rank\n\r--------------------------------------------------------------\n\r");
for (i=0; i < MAX_ORDERRANK; i++)
{
sprintf(buf,"[%2d] %-25s\n\r", i+1, (pOrder->rank[i].rankname != '\0') ? pOrder->rank[i].rankname : "None");
send_to_char(buf, ch);
}
printf_to_char(ch, "\n\r\n\rMortal Leader Rights\n\r--------------------\n\r");
sprintf(buf, "Can Order : %s\n\rCan Deorder : %s\n\rCan Promote : %s\n\rCan Demote : %s\n\r",
(pOrder->ml[0]==1) ? "True" : "False", (pOrder->ml[1]==1) ? "True" : "False",
(pOrder->ml[2]==1) ? "True" : "False", (pOrder->ml[3]==1) ? "True" : "False");
send_to_char(buf, ch);
return FALSE;
}
OREDIT( oredit_ml ) /* Order by Muerte */
{
ORDER_DATA *pOrder;
char arg1[6], arg2[6], arg3[6], arg4[6];
bool set = FALSE;
EDIT_ORDER(ch, pOrder);
if ( argument[0] == '\0' )
{
send_to_char( "Syntax: ml TRUE|FALSE TRUE|FALSE TRUE|FALSE TRUE|FALSE\n\r", ch );
return FALSE;
}
argument = one_argument(argument, arg1);
argument = one_argument(argument, arg2);
argument = one_argument(argument, arg3);
argument = one_argument(argument, arg4);
if (!str_prefix(arg1,"true") )
{ pOrder->ml[0] = TRUE; set = TRUE; }
else
if (!str_prefix(arg1, "false") )
{ pOrder->ml[0] = FALSE; set = TRUE; }
if (!str_prefix(arg2,"true") )
{ pOrder->ml[1] = TRUE; set = TRUE; }
else
if (!str_prefix(arg2, "false") )
{ pOrder->ml[1] = FALSE; set = TRUE; }
if (!str_prefix(arg3,"true") )
{ pOrder->ml[2] = TRUE; set = TRUE; }
else
if (!str_prefix(arg3, "false") )
{ pOrder->ml[2] = FALSE; set = TRUE; }
if (!str_prefix(arg4,"true") )
{ pOrder->ml[3] = TRUE; set = TRUE; }
else
if (!str_prefix(arg4, "false") )
{ pOrder->ml[3] = FALSE; set = TRUE; }
if (set)
{
send_to_char("Mortal Leader traits set.\n\r", ch);
return TRUE;
}
return FALSE;
}
OREDIT(oredit_file) /* Order by Muerte */
{
ORDER_DATA *pOrder;
char file[MAX_STRING_LENGTH];
int i, length;
EDIT_ORDER(ch, pOrder);
one_argument(argument, file); /* Forces Lowercase */
if (argument[0] == '\0')
{
send_to_char("Syntax: filename [$file]\n\r", ch);
return FALSE;
}
/*
* Simple Syntax Check.
*/
length = strlen(argument);
if (length > 8)
{
send_to_char("No more than eight characters allowed.\n\r", ch);
return FALSE;
}
/*
* Allow only letters and numbers.
*/
for (i = 0; i < length; i++)
{
if (!isalnum(file[i]))
{
send_to_char("Only letters and numbers are valid.\n\r", ch);
return FALSE;
}
}
free_string(pOrder->file_name);
strcat(file, ".ord");
pOrder->file_name = str_dup(file);
send_to_char("Filename set.\n\r", ch);
return TRUE;
}
OREDIT( oredit_patron ) /* Order by Muerte */
{
ORDER_DATA *pOrder;
char arg1[MSL];
char deity[MSL];
int i;
EDIT_ORDER(ch, pOrder);
argument = one_argument(argument, arg1);
memset(deity, 0, MSL);
if ( arg1[0] == '\0' )
{
send_to_char( "Syntax: patron <name>\n\r", ch );
return FALSE;
}
for(i=0;i < MAX_GODS;i++)
{
sprintf(deity, god_table[i].name);
if (!str_cmp(arg1, deity))
{
pOrder->patron = str_dup( deity );
send_to_char( "Patron set.\n\r", ch );
return TRUE;
}
}
send_to_char("That god does not have power in this realm.", ch);
return FALSE;
}
OLC_SAVE.C
add -> save_rooms below guild stuff.
if (pRoomIndex->order > 0)
fprintf(fp, "G %s~\n", pRoomIndex->order->name);
add -> at end of file
void save_order_list() /* Order by Muerte */
{
FILE *fp;
ORDER_DATA *pOrder;
if (!(fp = fopen(ORDER_LIST, "w")))
{
bug("Save_order_list: fopen", 0);
perror("order.lst");
}
else
{
for (pOrder = order_first; pOrder; pOrder = pOrder->next)
{
fprintf(fp, "%s\n", pOrder->file_name);
}
fprintf(fp, "$\n");
fclose(fp);
}
return;
}
void save_order(ORDER_DATA * pOrder) /* Order by Muerte */
{
FILE *fp;
char buf[MAX_STRING_LENGTH];
char file[200];
int value;
ORDERMEM_DATA *ordermem;
fclose(fpReserve);
sprintf(file, ORDER_DIR);
strcat(file, pOrder->file_name);
if (!(fp = fopen(file, "w")))
{
bug("Open_Order: fopen", 0);
perror(pOrder->file_name);
}
fprintf(fp, "%s~\n", pOrder->file_name);
fprintf(fp, "Order %s~\n", pOrder->name);
fprintf(fp, "Patron %s~\n", pOrder->patron);
for (value=0; value < MAX_ORDERRANK; value++)
{
if (pOrder->rank[value].rankname == NULL || pOrder->rank[value].rankname[0] == '\0')
pOrder->rank[value].rankname = str_dup("Unassigned");
fprintf(fp, "Rank\t%d\t%s~\n", value+1, pOrder->rank[value].rankname);
}
fprintf(fp, "ML\t");
for(value=0;value < 4;value++)
fprintf(fp, "%d ", pOrder->ml[value]);
fprintf(fp, "\n");
// Remove "changed" bit before writing flags to file
if (IS_SET(pOrder->flags, ORDER_CHANGED))
REMOVE_BIT(pOrder->flags, ORDER_CHANGED);
fprintf( fp, "Flag %s\n", fwrite_flag(pOrder->flags, buf));
fprintf(fp, "\n\n");
for (ordermem = ordermem_first; ordermem; ordermem = ordermem->next)
{
if (pOrder == ordermem->order)
{
sprintf(buf, "Member\t%s~ %d\n", ordermem->name, ordermem->rank);
fprintf(fp, buf);
}
}
fprintf(fp, "\n");
fprintf(fp, "End\n");
fclose(fp);
fpReserve = fopen(NULL_FILE, "r");
return;
}
void do_orsave(CHAR_DATA * ch, char *argument) /* Order by Muerte */
{
char arg1[MAX_INPUT_LENGTH];
ORDER_DATA *pOrder;
FILE *fp;
int sec, value;
fp = NULL;
if (!ch)
sec = 9;
else if (!IS_NPC(ch))
sec = ch->pcdata->security;
else
sec = 0;
smash_tilde(argument);
strcpy(arg1, argument);
if (arg1[0] == '\0')
{
if (ch)
{
send_to_char("Syntax:\n\r", ch);
send_to_char(" osave <vnum>/order - saves a particular order\n\r",ch);
send_to_char(" osave list - saves the order.lst file\n\r",ch);
send_to_char(" osave changed - saves modified orders.\n\r",ch);
send_to_char(" osave orders - saves all orders.\n\r",ch);
send_to_char("\n\r", ch);
do_function(ch, &do_oredit, "");
}
return;
}
value = atoi(arg1);
if (!(pOrder = get_order_data(value-1)) && is_number(arg1))
{
if (ch)
send_to_char("That order does not exist.\n\r", ch);
return;
}
if (is_number(arg1))
{
if (!IS_IMMORTAL(ch))
{
send_to_char("You are not a editor for this order.\n\r", ch);
return;
}
save_order_list();
save_order(pOrder);
printf_to_char(ch, "Order %s saved.\n\r", pOrder->name);
return;
}
/* Save the order.lst file. */
/* ----------------------- */
if (!str_cmp(arg1, "list"))
{
save_order_list();
send_to_char("Order list saved.\n\r", ch);
return;
}
if (!str_cmp("changed", arg1))
{
char buf[MAX_INPUT_LENGTH];
save_order_list();
if (ch)
send_to_char("Saved orders:\n\r", ch);
else
log_string("Saved orders:");
sprintf(buf, "None.\n\r");
for (pOrder = order_first; pOrder; pOrder = pOrder->next)
{
/* Save changed orders. */
if (IS_SET(pOrder->flags, ORDER_CHANGED))
{
save_order(pOrder);
sprintf(buf, "%24s - '%s'", pOrder->name, pOrder->file_name);
if (ch)
{
send_to_char(buf, ch);
send_to_char("\n\r", ch);
}
else
log_string(buf);
REMOVE_BIT(pOrder->flags, ORDER_CHANGED);
}
}
if (!str_cmp(buf, "None.\n\r"))
{
if (ch)
send_to_char(buf, ch);
else
log_string("None.");
}
return;
}
if (!str_cmp("orders", arg1))
{
save_order_list();
for (pOrder = order_first; pOrder; pOrder = pOrder->next)
{
save_order(pOrder);
REMOVE_BIT(pOrder->flags, ORDER_CHANGED);
}
if (IS_IMMORTAL(ch))
send_to_char("You saved order organizations.\n\r", ch);
return;
}
if (order_lookup(arg1))
{
save_order_list();
for (pOrder = order_first; pOrder; pOrder = pOrder->next)
{
if (pOrder->name == arg1)
{
save_order(pOrder);
REMOVE_BIT(pOrder->flags, ORDER_CHANGED);
}
}
if (IS_IMMORTAL(ch))
printf_to_char(ch, "You saved %s order changes.\n\r", arg1);
return;
}
}
SAVE.C
add -> fwrite_char
if (ch->order) /* Order by Muerte */
{
fprintf( fp, "Order %s~\n", ch->order);
fprintf( fp, "OrderRank %d\n", ch->orderrank);
}
add -> load_char_obj
ch->order = (char *)NULL; /* Order by Muerte */
ch->order_ptr = (ORDER_DATA *)NULL;
add -> fread_Char (in proper spots)
if (!str_cmp(word, "Order")) { /* Order by Muerte */
ch->order = str_dup(fread_string(fp));
ch->order_ptr = order_name(ch);
if(ch->order_ptr==NULL) {
ch->order = (char *)NULL;
}
fMatch = TRUE;
}
KEY( "OrderRank", ch->orderrank, fread_number( fp ) );
TABLES.C
/* God must be in the table in order to patron an order *
* The table isn't fully functional, it's made for nanny *
* If you would like to do restrictions. Ties into Merc.h*
* Max_GODS */
add -> at end
/* God/Order Table by Muerte */
const struct god_type god_table[MAX_GODS] = {
/* { name, description, holy symbol, profile,
{ LG, NG, CG, LN, CN, TN, LE, NE, CE }
{ Brb, Brd, Cle, Drd, Ftr, Mnk, Pal, Rgr, Rog, Src, Wiz, Ill, Nec },
align,
{ Human, Dwarf, High Elf, Gnome, Half-Elf, Half-Orc, Halfling }
}
*/
{"No Deity", "no particular religious persuasion", NULL, "NOTHING",
{1, 1, 1, 1, 1, 1, 1, 1, 1},
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
ALIGN_NEUTRAL,
{0, 0, 0, 0, 0, 0, 0}
},
};
HELP.ARE (or where ever your helps go)
0 PATRON~
The patron/worship system allows players to follow player gods or non-player gods.
You may patron or unpatron, Your God may patron you or unpatron you.
Syntax:
Mortal -> patron <god>
Mortal -> unpatron <god>
Immortal -> patron <mortal>
Immortal -> unpatron <mortal>
Patron code by: Muerte (muerte@acestar.org)
Thanks to: Gary McNickle (dharvest), Morpheous, mapleman
~
60 OREDIT ORLIST ORSAVE~
OREDIT is the OLC Editor to create orders.
OREDIT create -> make a new order
OREDIT name -> edit order
OREDIT vnum -> edit order
Once in edition, the commands are:
file <argument> -> filename
name <argument> -> order name
patron <argument> -> order patron
rank # <argument> -> rename rank
ML TRUE|FALSE TRUE|FALSE TRUE|FALSE TRUE|FALSE -> set mortal commands (not fully implimented)
ORLIST is the command to list current orders.
Lists current orders and thier vnums
ORSAVE is the command to save orders.
orsave <vnum>/name - saves a particular order
orsave list - saves the order.lst file
orsave changed - saves modified orders.
orsave orders - saves all orders.
Patron code by: Muerte (muerte@acestar.org)
Thanks to: Gary McNickle (dharvest), Morpheous, mapleman
~