/**************************************************************************/
// mixedit.cpp - Olc mix editor, Kerenos
/***************************************************************************
* The Dawn of Time v1.69r (c)1997-2004 Michael Garratt *
* >> A number of people have contributed to the Dawn codebase, with the *
* majority of code written by Michael Garratt - www.dawnoftime.org *
* >> To use this source code, you must fully comply with the dawn license *
* in licenses.txt... In particular, you may not remove this copyright *
* notice. *
**************************************************************************/
#include "include.h"
#include "olc.h"
#include "db.h"
#include "olc_ex.h"
mix_data *find_mix( char_data *ch, char *arg );
bool mix_create( char_data *ch, char * );
bool mixedit_values( char_data *ch, char *argument, int value );
bool set_mixvalue( char_data *ch, mix_data *mix, char *argument, int value );
bool set_mix_values( char_data *ch, mix_data *mix, int value_num, char *argument);
void show_obj_values( char_data *ch, OBJ_INDEX_DATA *pObj );
void list_mixes( char_data *ch, char *argument);
int compare_vn_int( vn_int *, vn_int * );
void mix_bsort( vn_int array[], sh_int num[], int size );
void empty_container( OBJ_DATA *container );
/**************************************************************************/
// semilocalized globals
mix_data *mix_list;
void save_object_values( FILE *fp, OBJ_INDEX_DATA *pObjIndex );
void load_object_values( FILE *fp, int version, OBJ_INDEX_DATA *pObjIndex);
/**************************************************************************/
bool mixedit_show( char_data *ch, char * )
{
OBJ_INDEX_DATA *oid = NULL;
mix_data *mix;
int i;
char buf[MIL];
EDIT_MIX( ch, mix );
ch->titlebar("Mixture Data");
ch->printlnf( "`=rName: `x%s", mix->name );
ch->printlnf( "`=rCreated by: `x%s", mix->creator );
ch->printlnf( "`=rLocked: `x%s", mix->locked ? "YES" : "NO" );
ch->printlnf( "`=rType: `x%s", flag_string( mixtype_types, mix->type ));
ch->printlnf( "`=rVessel: `x[%s]", flag_string( item_types, mix->vessel ));
ch->printlnf( "`=rDifficulty: `x%s (%d)",
modifier_table[mix->difficulty].name,
modifier_table[mix->difficulty].modifier );
ch->printlnf( "`=rTemplate VNUM: `x%d", mix->vnum_template );
ch->println("`=rIngredient Amount Needed`x");
for ( i=0; i < 5; i++ )
{
if (( oid = get_obj_index( mix->ingredients[i] )) == NULL ){
if(mix->ingredients[i]==0){
sprintf(buf, "ignored");
}else{
sprintf(buf, "(object not found)");
}
}else{
sprintf(buf, oid->short_descr );
}
ch->printlnf( "%d. %-5d %-2d (%s)",
i+1,
mix->ingredients[i],
mix->ingredients_num[i],
buf);
};
ch->titlebar("Result Data");
ch->printlnf( "`=rName: `x%s", mix->rname );
ch->printlnf( "`=rShort: `x%s", mix->rshort );
ch->printlnf( "`=rLong: `x%s", mix->rlong );
ch->printlnf( "`=rItem Type: `x[%s]", flag_string( item_types, mix->ritem_type ));
ch->printlnf( "`=rWear Flags: `x[%s]", flag_string( wear_flags, mix->rwear ));
if (( oid = get_obj_index( OBJ_VNUM_MUSHROOM )) == NULL )
{
return false;
}
OBJ_INDEX_DATA show_objindex;
show_objindex=*oid;
show_objindex.item_type = mix->ritem_type;
show_objindex.value[0] = mix->rvalue[0];
show_objindex.value[1] = mix->rvalue[1];
show_objindex.value[2] = mix->rvalue[2];
show_objindex.value[3] = mix->rvalue[3];
show_objindex.value[4] = mix->rvalue[4];
show_obj_values( ch, &show_objindex);
ch->wrapln("note: the level on resulting potions ignores the spell level set here, and is based on mixer level.");
return false;
}
/**************************************************************************/
// read in the result item type and values into mixdata node - Kal
void mixdata_read_rvalues(gio_type *, int, void *data, FILE *fp)
{
mix_data * mix= (mix_data*)data;
obj_index_data pObjIndex;
// do the reading
char *iname=fread_word( fp );
pObjIndex.item_type= item_lookup(iname);
if(pObjIndex.item_type==-1){
bugf("mixdata_read_rvalues(): Unfound item type '%s', mix entry name='%s'",
iname, mix->name);
do_abort();
};
load_object_values( fp, 5, &pObjIndex);
// transfer the results
memcpy(mix->rvalue, pObjIndex.value, sizeof(int)*5);
mix->ritem_type=pObjIndex.item_type;
}
/**************************************************************************/
// write the result item type and values from mixdata node - Kal
void mixdata_write_rvalues(gio_type *gio_table,int ti,void *data, FILE *fp)
{
mix_data * mix= (mix_data*)data;
obj_index_data pObjIndex;
// transfer the info to be saved
pObjIndex.item_type=mix->ritem_type;
memcpy(pObjIndex.value, mix->rvalue, sizeof(int)*5);
// do the writing
char *iname=item_name(pObjIndex.item_type);
if(has_space(iname) || IS_NULLSTR(iname)){
fprintf(fp, "%s '%s' ",
gio_table[ti].heading,
item_name(pObjIndex.item_type));
}else{
fprintf(fp, "%s %s ",
gio_table[ti].heading,
item_name(pObjIndex.item_type));
}
save_object_values( fp, &pObjIndex);
}
/**************************************************************************/
// create organization GIO lookup table
GIO_START(mix_data)
GIO_STRH(name, "Name ")
GIO_STRH(creator, "Creator ")
GIO_BOOLH(locked, "Locked ")
GIO_WFLAGH(type, "Type ", mixtype_types)
GIO_INTH(vnum_template, "Template ")
GIO_SHINTH(difficulty, "Difficulty ")
GIO_INTH(vessel, "Vessel ")
GIO_INT_ARRAY(ingredients, 5 )
GIO_SHINT_ARRAY(ingredients_num, 5 )
GIO_STRH(rname, "Result_Name ")
GIO_STRH(rshort, "Result_Short ")
GIO_STRH(rlong, "Result_Long ")
GIO_CUSTOM_WRITEH(rvalue, "Rtype_values ", mixdata_write_rvalues)
GIO_CUSTOM_READH(rvalue, "Rtype_values ", mixdata_read_rvalues)
GIO_WFLAGH(rwear, "Result_Wear ", wear_flags)
GIO_FINISH
/**************************************************************************/
// loads in the mix database
void load_mix_db(void)
{
logf("===Loading mix database from %s...", MIX_FILE);
GIOLOAD_LIST(mix_list, mix_data, MIX_FILE);
log_string ("load_mix_db(): finished");
}
/**************************************************************************/
// saves the mix database
void save_mix_db( void)
{
logf("===save_mix_db(): saving mix database to %s", MIX_FILE);
GIOSAVE_LIST(mix_list, mix_data, MIX_FILE, true);
}
/**************************************************************************/
void do_savemixdb( char_data *ch, char * )
{
save_mix_db( );
logf("do_savemixdb(): manual save of mix list completed to %s,\r\n"
"check logs for any errors.\r\n", MIX_FILE);
ch->println( "Mix data saved manually." );
}
/**************************************************************************/
// Entry Point for mixing
void do_mixedit( char_data *ch, char *argument )
{
mix_data *mix;
if ( IS_NPC( ch )){
ch->println("Players only.");
return;
}
if ( !IS_SET(TRUE_CH(ch)->pcdata->council, COUNCIL_REALM)
&& !IS_ADMIN(ch))
{
ch->println( "Only realm council may use this command." );
return;
}
if (IS_NULLSTR(argument)){
ch->println( " Syntax: mixedit <mix> (edits an existing mixture)");
ch->println( " Syntax: mixedit list <type> (shows all available mixes of a given type)" );
ch->println( " Syntax: mixedit create <name> (creates a new, null mixture)" );
return;
}
char arg[MIL];
argument=one_argument(argument,arg);
if(!str_cmp(arg,"create")){
mix_create( ch, "" );
return;
}
if ( !str_cmp( arg, "list" )){
list_mixes( ch, argument );
return;
}
// find an existing mixture
if(IS_NULLSTR(arg)){
ch->println("You must specify the type of mixtures you want to list.");
do_mixedit(ch,"");
return;
}
mix = find_mix(ch, arg);
if( !mix ){
ch->printlnf("There is no mixture named '%s'", arg );
return;
};
if ( mix->locked )
{
if (!( is_exact_name(TRUE_CH(ch)->name, mix->creator )
|| IS_ADMIN(ch)))
{
ch->printlnf( "Only %s or an admin may modify this mixture.", mix->creator );
return;
}
}
ch->desc->pEdit = (void*)mix;
ch->desc->editor = ED_MIX;
ch->printlnf("Editing '%s' mixture.", mix->name);
return;
}
/**************************************************************************/
// find an existing mixture
mix_data *find_mix( char_data *, char *mix )
{
mix_data *m;
// first do an exact match
for ( m = mix_list; m; m = m->next ){
if( !str_cmp( mix, m->name ))
{
return m;
}
}
// do a prefix mix
for ( m = mix_list; m; m = m->next ){
if( !str_prefix( mix, m->name ))
{
return m;
}
}
return NULL;
};
/**************************************************************************/
void list_mixes( char_data *ch, char *argument )
{
mix_data *m;
int col = 0;
int type = mixtype_lookup( argument );
if ( type == -1 )
{
ch->printlnf( "'%s' is an invalid mix type. Use 'mixedit list <type>', where type is one of: ", argument );
show_help( ch, "mixtype" );
ch->println("e.g.: mixedit list herbalism");
return;
}
ch->titlebar("Mixes");
for( m=mix_list; m; m = m->next )
{
if ( type == m->type )
{
ch->printf( " %-20s", m->name );
if ( ++col % 4 == 0 )
ch->print( "\r\n" );
}
}
ch->print("`x\r\n" );
return;
}
/**************************************************************************/
bool mix_create( char_data *ch, char * )
{
mix_data *node;
static mix_data zero_node;
node = new mix_data;
*node = zero_node;
node->next = mix_list;
mix_list = node;
mix_list->name = str_dup( "New" );
mix_list->creator = str_dup( ch->name );
mix_list->ritem_type = ITEM_TRASH;
ch->desc->pEdit = (void *)mix_list;
ch->desc->editor = ED_MIX;
ch->println( "Mixture Created." );
return false;
}
/**************************************************************************/
bool mixedit_name( char_data *ch, char *argument )
{
mix_data *mix;
EDIT_MIX( ch, mix );
if ( argument[0] == '\0' )
{
ch->println( "Syntax: name [name]" );
return false;
}
replace_string( mix->name, argument );
ch->printlnf( "Mixture is now known as '%s'.", mix->name );
return true;
}
/**************************************************************************/
bool mixedit_lock( char_data *ch, char * )
{
mix_data *mix;
EDIT_MIX( ch, mix );
if ( mix->locked == false )
{
mix->locked = true;
ch->println( "Mixture locked, only you or an admin may edit it while locked." );
}
else
{
mix->locked = false;
ch->println( "Mixture unlocked, anyone may edit this mixture." );
}
return true;
}
/**************************************************************************/
bool mixedit_type( char_data *ch, char *argument )
{
mix_data *mix;
EDIT_MIX( ch, mix );
int value;
if ( IS_NULLSTR( argument )){
ch->println( "Syntax: type [mixtype]\r\n ( ? mixtype to list)" );
return false;
}
if (( value = flag_value( mixtype_types, argument )) != NO_FLAG )
{
mix->type = value;
ch->println( "Type set." );
return true;
}
show_olc_options(ch, mixtype_types, "type", "mixtype", mix->type);
return false;
}
/**************************************************************************/
bool mixedit_difficulty( char_data *ch, char *argument )
{
mix_data *mix;
int mod;
EDIT_MIX( ch, mix );
if ( argument[0] == '\0' )
{
int i;
ch->print( "Syntax: difficulty [type]\r\nValid ones are: [`c" );
for ( i = 0; i < DIFF_MAX; i++ )
ch->printf( " %s (%d) ", modifier_table[i].name, modifier_table[i].modifier );
ch->print( "`x ]\r\n" );
return false;
}
mod = difficulty_lookup( argument );
if ( mod < 0 )
{
ch->println( "Invalid difficulty type." );
mixedit_difficulty( ch, "" );
return false;
}
mix->difficulty = mod;
ch->println( "Ok." );
return true;
}
/**************************************************************************/
bool mixedit_vnum( char_data *ch, char *argument )
{
mix_data *mix;
vn_int vnum;
EDIT_MIX( ch, mix );
if ( argument[0] == '\0' )
{
ch->println( "Syntax: vnum [number]" );
ch->println( " (Indicates which VNUM this data refers to." );
return false;
}
vnum = atoi( argument );
if ( vnum < 1 || vnum > game_settings->olc_max_vnum)
{
ch->printlnf( "VNUM must be greater than 0 and less than %d", game_settings->olc_max_vnum );
return false;
}
mix->vnum_template = vnum;
ch->printlnf( "VNUM set to '%d'.", mix->vnum_template );
return true;
}
/**************************************************************************/
bool mixedit_rname( char_data *ch, char *argument )
{
mix_data *mix;
EDIT_MIX( ch, mix );
if ( argument[0] == '\0' )
{
ch->println( "Syntax: rname [name] - This is the name of the result" );
return false;
}
replace_string( mix->rname, argument );
ch->printlnf( "Resulting name is now '%s'.", mix->rname );
return true;
}
/**************************************************************************/
bool mixedit_rtype( char_data *ch, char *argument )
{
mix_data *mix;
EDIT_MIX( ch, mix );
int value;
if( !IS_NULLSTR(argument)){
if (( value = flag_value( item_types, argument )) != NO_FLAG )
{
mix->ritem_type = value;
ch->println( "Type set." );
// Clear the values.
switch ( mix->ritem_type )
{
case ITEM_SCROLL:
case ITEM_POTION:
case ITEM_PILL:
mix->rvalue[0] = -1;
mix->rvalue[1] = -1;
mix->rvalue[2] = -1;
mix->rvalue[3] = -1;
mix->rvalue[4] = -1;
break;
case ITEM_POULTICE:
case ITEM_WAND:
case ITEM_STAFF:
mix->rvalue[0] = 0;
mix->rvalue[1] = 0;
mix->rvalue[2] = 0;
mix->rvalue[3] = -1;
mix->rvalue[4] = 0;
break;
default:
mix->rvalue[0] = 0;
mix->rvalue[1] = 0;
mix->rvalue[2] = 0;
mix->rvalue[3] = 0;
mix->rvalue[4] = 0;
break;
}
return true;
}
}
show_olc_options(ch, item_types, "rtype", "resulting object type", mix->ritem_type);
return false;
}
/**************************************************************************/
bool mixedit_vessel( char_data *ch, char *argument )
{
mix_data *mix;
EDIT_MIX( ch, mix );
int value;
if ( !IS_NULLSTR(argument) ){
if (( value = flag_value( item_types, argument )) != NO_FLAG ){
mix->vessel = value;
ch->println( "Type set." );
return true;
}
}
ch->println( "Syntax: vessel [item type]" );
ch->println( " Note: there is no sanity checking done here, so it's up to you" );
ch->println( " to make sure it's right. Currently, herbalism requires" );
ch->println( " a `Ycauldron`x or `Ymortar`x item type to work. More item" );
ch->println( " types will be added when new mixing skills are added ( ie, baking" );
ch->println( " skill may require an oven or bowl vessel to work [future project])" );
return false;
}
/**************************************************************************/
bool mixedit_rshort( char_data *ch, char *argument )
{
mix_data *mix;
EDIT_MIX( ch, mix );
// trim the spaces to the right of the short
while ( !IS_NULLSTR(argument) && is_space(argument[str_len(argument)-1]))
{
argument[str_len(argument)-1]='\0';
}
if ( argument[0] == '\0' )
{
ch->println( "Syntax: rshort [string]" );
return false;
}
// make sure first char is lowercase
argument[0] = LOWER(argument[0]);
char *ptemp = mix->rshort;
mix->rshort = str_dup( argument );
mix->rshort[0] = LOWER( mix->rshort[0] );
ch->printlnf( "Resulting vnum's short description from '%s' to '%s'.",
ptemp, mix->rshort );
free_string( ptemp );
return true;
}
/**************************************************************************/
bool mixedit_rlong( char_data *ch, char *argument )
{
mix_data *mix;
EDIT_MIX( ch, mix );
// trim the spaces to the right of the short
while ( !IS_NULLSTR(argument) && is_space(argument[str_len(argument)-1]))
{
argument[str_len(argument)-1]='\0';
}
if ( argument[0] == '\0' )
{
ch->println( "Syntax: rlong [string]" );
return false;
}
char *ptemp = mix->rlong;
mix->rlong = str_dup( argument );
mix->rlong[0] = UPPER( mix->rlong[0] );
ch->printlnf( "Long description from '%s' to '%s'.", ptemp, mix->rlong );
free_string( ptemp );
return true;
}
/**************************************************************************/
bool mixedit_rwear( char_data *ch, char *argument )
{
mix_data *mix;
EDIT_MIX( ch, mix );
int value;
if ( !IS_NULLSTR( argument )){
if (( value = flag_value( wear_flags, argument ) ) != NO_FLAG )
{
TOGGLE_BIT( mix->rwear, value);
ch->println( "Wear flag toggled." );
return true;
}
}
show_olc_options(ch, wear_flags, "rwear", "resulting object wear", mix->rwear);
return false;
}
/**************************************************************************/
bool set_mixvalue( char_data *ch, mix_data *mix, char *argument, int value )
{
if ( IS_NULLSTR( argument ))
{
set_mix_values( ch, mix, -1, "" );
return false;
}
if ( set_mix_values( ch, mix, value, argument ) )
return true;
return false;
}
/**************************************************************************/
bool set_mix_values( char_data *ch, mix_data *mix, int value_num, char *argument)
{
OBJ_INDEX_DATA *oid;
int value;
char combuf[MIL];
switch( mix->ritem_type )
{
default:
break;
case ITEM_LIGHT:
switch ( value_num )
{
default:
ch->println( "Only valid option is V2, which is the hours of light a light provides." );
do_help( ch, "OLC-ITEM-LIGHT" );
return false;
case 2:
ch->println( "HOURS OF LIGHT SET." );
mix->rvalue[2] = atoi( argument );
break;
}
break;
case ITEM_WAND:
case ITEM_STAFF:
switch ( value_num )
{
default:
do_help( ch, "OLC-ITEM-STAFF-WAND" );
return false;
case 0:
value=atoi( argument );
if(value==mix->rvalue[0]){
ch->println( "Spell level unchanged.\r\n" );
}else{
ch->printlnf( "Spell level changed from %d to %d.\r\n",
mix->rvalue[0], value);
mix->rvalue[0] = value;
}
break;
case 1:
ch->println( "TOTAL NUMBER OF CHARGES SET." );
mix->rvalue[1] = atoi( argument );
break;
case 2:
ch->println( "CURRENT NUMBER OF CHARGES SET." );
mix->rvalue[2] = atoi( argument );
break;
case 3:
sprintf(combuf, "v%d", value_num);
olc_generic_skill_assignment_to_int(ch, &mix->rvalue[value_num],
argument,true, true, combuf, "resulting object (type %s) spell",
item_name(mix->ritem_type));
break;
}
break;
case ITEM_POULTICE:
switch ( value_num )
{
default:
do_help( ch, "OLC-ITEM-POULTICE" );
return false;
case 0:
value=atoi( argument );
if(value==mix->rvalue[0]){
ch->println( "Spell level unchanged.\r\n" );
}else{
ch->printlnf( "Spell level changed from %d to %d.\r\n",
mix->rvalue[0], value);
mix->rvalue[0] = value;
}
break;
case 1:
ch->println( "TOTAL NUMBER OF APPLICATIONS SET." );
mix->rvalue[1] = atoi( argument );
break;
case 2:
ch->println( "CURRENT NUMBER OF APPLICATIONS SET." );
mix->rvalue[2] = atoi( argument );
break;
case 3:
sprintf(combuf, "v%d", value_num);
olc_generic_skill_assignment_to_int(ch, &mix->rvalue[value_num],
argument,true, true, combuf, "resulting object (type %s) spell",
item_name(mix->ritem_type));
break;
}
break;
case ITEM_SCROLL:
case ITEM_POTION:
case ITEM_PILL:
switch ( value_num )
{
default:
do_help( ch, "OLC-ITEM-SCROLL-POTION-PILL" );
return false;
case 0:
value=atoi( argument );
if(value==mix->rvalue[0]){
ch->println( "Spell level unchanged." );
}else{
ch->printlnf( "Spell level changed from %d to %d.\r\n",
mix->rvalue[0], value);
mix->rvalue[0] = value;
}
break;
case 1:
case 2:
case 3:
case 4:
sprintf(combuf, "v%d", value_num);
olc_generic_skill_assignment_to_int(ch, &mix->rvalue[value_num],
argument,true, true, combuf, "resulting object (type %s) spell%d",
item_name(mix->ritem_type), value_num);
break;
}
break;
case ITEM_INSTRUMENT:
switch ( value_num )
{
default:
do_help( ch, "OLC-ITEM-INSTRUMENT" );
return false;
case 0:
ch->println( "BARDIC SONG MOD SET." );
mix->rvalue[0] = atoi( argument );
break;
case 1:
ch->println( "# OF SONGS BEFORE RETUNING SET. (-1 is infinite)" );
mix->rvalue[1] = atoi(argument);
break;
}
break;
case ITEM_PARCHMENT:
switch ( value_num )
{
default:
return false;
case 0:
return false;
case 1:
ch->println( "Written on field set. Blank = 0 all else means it can't be written on." );
mix->rvalue[1] = atoi( argument );
break;
case 2:
ch->println( "Sealed field set. Unsealed = 0 all else means it's sealed." );
mix->rvalue[2] = atoi( argument );
break;
case 3:
mix->rvalue[3] = language_safe_lookup(argument)->unique_id;
ch->printlnf( "Language set to '%s'.", language_safe_lookup(argument)->name);
break;
}
break;
case ITEM_ARMOR:
switch ( value_num )
{
default:
do_help( ch, "OLC-ITEM-ARMOR" );
return false;
case 0:
ch->println( "AC PIERCE SET." );
mix->rvalue[0] = atoi( argument );
break;
case 1:
ch->println( "AC BASH SET." );
mix->rvalue[1] = atoi( argument );
break;
case 2:
ch->println( "AC SLASH SET." );
mix->rvalue[2] = atoi( argument );
break;
case 3:
ch->println( "AC EXOTIC SET." );
mix->rvalue[3] = atoi( argument );
break;
}
break;
case ITEM_WEAPON:
switch ( value_num )
{
default:
do_help( ch, "OLC-ITEM-WEAPON" );
return false;
case 0:
ch->println( "WEAPON CLASS SET." );
mix->rvalue[0] = flag_value( weapon_class_types, argument );
break;
case 1:
ch->println( "NUMBER OF DICE SET." );
mix->rvalue[1] = atoi( argument );
ch->printlnf( "Average damage is now %d",
(int) (mix->rvalue[1]+(mix->rvalue[1] * mix->rvalue[2]))/2);
break;
case 2:
ch->println( "TYPE OF DICE SET." );
mix->rvalue[2] = atoi( argument );
ch->printlnf( "Average damage is now %d",
(int) (mix->rvalue[1]+(mix->rvalue[1] * mix->rvalue[2]))/2);
break;
case 3:
ch->println( "WEAPON TYPE SET." );
mix->rvalue[3] = attack_lookup( argument );
break;
case 4:
ch->println( "SPECIAL WEAPON TYPE TOGGLED." );
mix->rvalue[4] ^= (flag_value( weapon_flags, argument ) != NO_FLAG
? flag_value( weapon_flags, argument ) : 0 );
break;
}
break;
case ITEM_PORTAL:
switch ( value_num )
{
default:
do_help(ch, "OLC-ITEM-PORTAL" );
return false;
case 0:
ch->println( "CHARGES SET." );
mix->rvalue[0] = atoi ( argument );
break;
case 1:
if (( value = flag_value( exit_flags, argument )) != NO_FLAG )
TOGGLE_BIT( mix->rvalue[1], value);
else
{
ch->printlnf( "Valid v1 portal exit flags are: %s",
flag_string( exit_flags, -1));
do_help ( ch, "OLC-ITEM-PORTAL" );
return false;
}
ch->println( "PORTAL EXIT FLAG SET." );
break;
case 2:
if ( ( value = flag_value( portal_flags, argument ) ) != NO_FLAG )
TOGGLE_BIT( mix->rvalue[2], value);
else
{
ch->printlnf( "Valid v2 portal flags are: %s",
flag_string( portal_flags, -1));
do_help ( ch, "OLC-ITEM-PORTAL" );
return false;
}
ch->println( "PORTAL EXIT FLAG SET." );
break;
case 3:
ch->println( "EXIT VNUM SET." );
mix->rvalue[3] = atoi ( argument );
break;
}
break;
case ITEM_TOKEN:
switch ( value_num )
{
default:
do_help(ch, "OLC-ITEM-TOKEN" );
return false;
case 0:
ch->println( "Token Flag Toggled." );
mix->rvalue[0] = ( flag_value( token_flags, argument ) != NO_FLAG
? flag_value( token_flags, argument ) : 0 );
break;
}
break;
case ITEM_COMPONENT:
switch ( value_num )
{
default:
do_help(ch, "OLC-ITEM-COMPONENT" );
return false;
case 0:
ch->println( "Charges set." );
mix->rvalue[0] = atoi( argument );
break;
case 1:
olc_generic_skill_assignment_to_int(ch, &mix->rvalue[value_num],
argument,true, true, "v1", "resulting object (%s) spell %d",
item_name(mix->ritem_type), value_num);
break;
}
break;
case ITEM_FURNITURE:
switch ( value_num )
{
default:
do_help( ch, "OLC-ITEM-FURNITURE" );
return false;
case 0:
ch->println( "NUMBER OF PEOPLE SET." );
mix->rvalue[0] = atoi ( argument );
break;
case 1:
ch->println( "MAX WEIGHT SET." );
mix->rvalue[1] = atoi ( argument );
break;
case 2:
ch->printlnf( "Valid v2 Furniture flags are: %s",
flag_string( furniture_flags, -1));
ch->println( "FURNITURE FLAGS TOGGLED." );
mix->rvalue[2] ^= (flag_value( furniture_flags, argument ) != NO_FLAG
? flag_value( furniture_flags, argument ) : 0);
break;
case 3:
ch->println( "HEAL BONUS SET." );
mix->rvalue[3] = atoi ( argument );
break;
case 4:
ch->println( "MANA BONUS SET." );
mix->rvalue[4] = atoi ( argument );
break;
}
break;
case ITEM_CAULDRON:
case ITEM_CONTAINER:
case ITEM_FLASK:
case ITEM_MORTAR:
switch ( value_num )
{
int value;
default:
do_help( ch, "OLC-ITEM-CONTAINER" );
return false;
case 0:
ch->wraplnf( "Maximum combined weight the resulting container can "
"hold changed from %d lbs to %d lbs.",
mix->rvalue[0], atoi( argument ));
mix->rvalue[0] = atoi( argument );
break;
case 1:
if ( ( value = flag_value( container_flags, argument ) ) != NO_FLAG )
TOGGLE_BIT( mix->rvalue[1], value);
else
{
ch->printlnf( "Valid v1 container flags are: %s",
flag_string( container_flags, -1));
do_help ( ch, "OLC-ITEM-CONTAINER" );
return false;
}
ch->println( "CONTAINER FLAG SET." );
break;
case 2:
if ( atoi(argument) != 0 )
{
if ( !get_obj_index( atoi( argument )))
{
ch->println( "THERE IS NO SUCH ITEM." );
return false;
}
if ( get_obj_index( atoi( argument ))->item_type != ITEM_KEY )
{
ch->println( "THAT ITEM IS NOT A KEY." );
return false;
}
}
ch->println( "CONTAINER KEY SET." );
mix->rvalue[2] = atoi( argument );
break;
case 3:
ch->wraplnf( "Maximum weight any single object able to be put into the "
"resulting container changed from %d lbs to %d lbs.",
mix->rvalue[3], atoi( argument ));
mix->rvalue[3] = atoi( argument );
break;
case 4:
ch->println( "WEIGHT MULTIPLIER SET." );
mix->rvalue[4] = atoi ( argument );
break;
}
break;
case ITEM_DRINK_CON:
switch ( value_num )
{
default:
do_help( ch, "OLC-ITEM-DRINK" );
return false;
case 0:
ch->println( "MAXIMUM AMOUT OF LIQUID HOURS SET." );
mix->rvalue[0] = atoi( argument );
break;
case 1:
ch->println( "CURRENT AMOUNT OF LIQUID HOURS SET." );
mix->rvalue[1] = atoi( argument );
break;
case 2:
ch->println( "LIQUID TYPE SET." );
mix->rvalue[2] = ( liq_lookup(argument) != -1 ? liq_lookup(argument) : 0 );
break;
case 3:
ch->println( "POISON VALUE TOGGLED." );
mix->rvalue[3] = ( mix->rvalue[3] == 0 ) ? 1 : 0;
break;
}
break;
case ITEM_FOUNTAIN:
switch (value_num)
{
default:
do_help( ch, "OLC-ITEM-FOUNTAIN" );
return false;
case 0:
ch->println( "MAXIMUM AMOUT OF LIQUID HOURS SET." );
mix->rvalue[0] = atoi( argument );
break;
case 1:
ch->println( "CURRENT AMOUNT OF LIQUID HOURS SET." );
mix->rvalue[1] = atoi( argument );
break;
case 2:
ch->println( "LIQUID TYPE SET." );
mix->rvalue[2] = ( liq_lookup( argument ) != -1 ? liq_lookup( argument ) : 0 );
break;
}
break;
case ITEM_FOOD:
switch ( value_num )
{
default:
do_help( ch, "OLC-ITEM-FOOD" );
return false;
case 0:
ch->println( "HOURS OF FOOD SET." );
mix->rvalue[0] = atoi( argument );
break;
case 1:
ch->println( "HOURS OF FULL SET." );
mix->rvalue[1] = atoi( argument );
break;
case 3:
ch->println( "POISON VALUE TOGGLED." );
mix->rvalue[3] = ( mix->rvalue[3] == 0 ) ? 1 : 0;
break;
}
break;
case ITEM_MONEY:
switch ( value_num )
{
default:
do_help( ch, "OLC-ITEM-MONEY" );
return false;
case 0:
ch->println( "GOLD AMOUNT SET." );
mix->rvalue[0] = atoi( argument );
break;
case 1:
ch->println( "SILVER AMOUNT SET." );
mix->rvalue[1] = atoi( argument );
break;
}
break;
}
if (( oid = get_obj_index( OBJ_VNUM_DUMMY )) == NULL )
{
return true;
}
oid->item_type = mix->ritem_type;
oid->value[0] = mix->rvalue[0];
oid->value[1] = mix->rvalue[1];
oid->value[2] = mix->rvalue[2];
oid->value[3] = mix->rvalue[3];
oid->value[4] = mix->rvalue[4];
show_obj_values( ch, oid );
// OBJ_VNUM_DUMMY shouldn't be left anything other than VNUM_DUMMY
oid->item_type = ITEM_TRASH;
return true;
}
/**************************************************************************/
bool mixedit_values( char_data *ch, char *argument, int value )
{
mix_data *mix;
EDIT_MIX( ch, mix );
if ( set_mixvalue( ch, mix, argument, value ))
return true;
return false;
}
/**************************************************************************/
bool mixedit_value0( char_data *ch, char *argument )
{
if ( mixedit_values( ch, argument, 0 ))
return true;
return false;
}
/**************************************************************************/
bool mixedit_value1( char_data *ch, char *argument )
{
if ( mixedit_values( ch, argument, 1 ))
return true;
return false;
}
/**************************************************************************/
bool mixedit_value2( char_data *ch, char *argument )
{
if ( mixedit_values( ch, argument, 2 ))
return true;
return false;
}
/**************************************************************************/
bool mixedit_value3( char_data *ch, char *argument )
{
if ( mixedit_values( ch, argument, 3 ))
return true;
return false;
}
/**************************************************************************/
bool mixedit_value4( char_data *ch, char *argument )
{
if ( mixedit_values( ch, argument, 4 ))
return true;
return false;
}
/**************************************************************************/
bool mixedit_ingredients( char_data *ch, char *argument )
{
mix_data *mix;
char parg[MIL];
int pos;
char varg[MIL];
vn_int vnum;
char qarg[MIL];
vn_int qty;
int i;
EDIT_MIX( ch, mix );
if ( IS_NULLSTR( argument ))
{
ch->println( "Syntax: ingredient <#> <vnum> <qty>" );
ch->println( " (# = a number between 1 and 5)");
ch->println( " (<vnum> = object vnum)");
ch->println( " (<qty> = required quantity of object)");
ch->println( "Syntax: ingredient <#> - (to clear an ingredient line)");
return false;
}
// check the position
argument = one_argument( argument, parg );
pos = atoi( parg );
if ( pos < 1 || pos > 5 )
{
ch->println( "# must be between 1 and 5." );
return false;
}
// check the vnum
argument = one_argument( argument, varg );
if(varg[0]=='-' && varg[1]=='\0'){
// clearing entry
ch->printlnf( "Position %d cleared (was %d, qty %d).",
pos,
mix->ingredients[pos-1],
mix->ingredients_num[pos-1]);
mix->ingredients[pos-1] = 0;
mix->ingredients_num[pos-1] = 0;
mix_bsort( mix->ingredients, mix->ingredients_num, 5 );
ch->println( "Required ingredient combination resorted." );
mixedit_show(ch,"");
return true;
}
if(!is_number(varg)){
ch->printlnf( "Vnum must be numeric or -, '%s' is neither of these.", varg );
mixedit_ingredients(ch,"");
return false;
}
vnum = atoi( varg);
if ( vnum < 1 ){
ch->printlnf( "Ingredient vnum for position %d must be greater than zero", pos);
mixedit_ingredients(ch,"");
return false;
}
// check the quantity
argument = one_argument( argument, qarg );
qty= atoi( qarg );
if ( qty < 1 || qty > 25 ) {
ch->printlnf( "The quantity of ingredient %d for position %d must be between 1 and 25.",
vnum, pos);
return false;
}
// check the ingredient value isn't already use in another position
for(i=0; i<5; i++){
if(i==pos-1){
continue;
}
if(mix->ingredients[i]==vnum){
ch->printlnf("There is already an ingredient with of a vnum of %d in position %d.",
vnum, i+1);
return false;
}
}
// announce the change
ch->printlnf( "Ingredient in position %d changed (was vnum %d, qty %d).",
pos, mix->ingredients[pos-1], mix->ingredients_num[pos-1]);
mix->ingredients[pos-1] = vnum;
mix->ingredients_num[pos-1] = qty;
// resort
mix_bsort( mix->ingredients, mix->ingredients_num, 5 );
ch->println( "Required ingredient combination resorted." );
// display updated sorting
mixedit_show(ch,"");
return true;
}
/**************************************************************************/
// quick and dirty bubble sort routine for mix vnums<>num_ingredients
// had to kind of cheat since I was trying to sort the vnums of the
// container and assign the number of each ingredient needed to the
// correct vnum, couldn't use the qsort since the two arrays aren't
// really dependent on each other once sorted
void mix_bsort( vn_int array[], sh_int num[], int size )
{
int temp, i, j;
for ( i = 0; i < size; i++ ){
for ( j = 0; j < size; j++ ){
if ( array[i] < array[j] ){
temp = array[i];
array[i] = array[j];
array[j] = temp;
// here comes the hack, all dressed in white
temp = num[i];
num[i] = num[j];
num[j] = temp;
}
}
}
}
/**************************************************************************/
// uses mixedit_show to display info
void do_mixshow( char_data *ch, char *argument )
{
mix_data *m;
void * pTemp = NULL;
if (!HAS_SECURITY(ch,1))
{
ch->println( "The mixshow command is an olc command, you dont have olc permissions." );
return;
}
if ( IS_NULLSTR( argument ))
{
ch->println( "Syntax: mixshow <mixname>" );
return;
}
m = find_mix( ch, argument );
if( !m )
{
ch->printlnf("There is no mixture named '%s'", argument );
return;
};
pTemp = ch->desc->pEdit;
ch->desc->pEdit = (void *)m;
mixedit_show( ch, "" );
ch->desc->pEdit = pTemp;
return;
}
/**************************************************************************/
/**************************************************************************/