/**
* This is the inherit for wrapping papers which can be wrapped
* around things.
*
* To use the inherit you must call make_wrapping() on the object,
* to set up the basic parameters of the wrapping paper.
*
* @see make_wrapping()
* @author Sandoz, 2002.
*/
inherit BAGGAGE_OBJ;
#define TINY 10
#define SMALL 20
#define MEDIUM 50
#define LARGE 100
#define HUGE 200
#define MAX 400
nosave int wrapped, moving;
nosave string desc, size;
/** @ignore yes */
string get_long() {
if( !wrapped ) {
int number;
string str;
number = query_max_weight() / 5;
switch( number ) {
case 0 :
str = "less than half a pound";
break;
case 1 :
str = "about half a pound";
break;
case 2 :
str = "about a pound";
break;
case 3 :
str = "about a pound and a half";
break;
case 4 .. 14 :
str = "about "+query_num( ( number + 1 ) / 2 ) +" pounds";
break;
case 15 .. 24 :
str = "about ten pounds";
break;
case 25 .. 34 :
str = "about fifteen pounds";
break;
case 35 .. 149 :
str = "about "+query_num( ( number + 10 ) / 20 * 10 )+" pounds";
break;
case 150 .. 249 :
str = "about a hundred pounds";
break;
default :
str = "over a hundred pounds";
}
return "This is "+add_a(size)+" piece of "+desc+" paper, perfect for "
"wrapping around goods before posting a parcel, or just making a "
"present.\nIt looks big and durable enough to fit "+str+" of "
"goods.\n";
}
return "This "+size+" piece of "+desc+" paper appears to have been "
"wrapped around some goods. A loose flap invites you to unwrap the "
"packet and unravel whatever lies within.\n";
} /* get_long() */
/** @ignore */
void create() {
::create();
set_stuck( 1 );
} /* create() */
/**
* This method queries whether this object is a parcel
* acceptable by the post office or not.
* It returns true if it has been wrapped.
* @return 1 if wrapped, 0 if not
*/
int query_is_postage_parcel() { return wrapped; }
/** @ignore yes */
void set_wrapped() {
if( wrapped ) {
set_name("packet");
remove_adjective( ({"piece", "of", "wrapping"}) );
remove_plural("papers");
add_adjective("paper");
add_plural("packets");
set_short( size+" "+desc+" paper packet");
set_main_plural( size+" "+desc+" paper packets");
}
} /* get_short() */
/**
* This method queries whether or not we have been wrapped or not.
* @return 1 for wrapped, 0 for unused
*/
int query_wrapped() { return wrapped; }
/**
* This method returns the size string of the paper.
* @return the size of the paper as a string
*/
string query_size() { return size; }
/**
* This method returns the extra description of the paper.
* @return the extra description of the paper
*/
string query_desc() { return desc; }
/** @ignore yes */
int do_not_sell() { return wrapped; }
/**
* This method sets up the basic parameters of the wrapping paper.
* The description argument should be a short, adjective-like
* description for the object, which should not hint at the size
* of the paper, because that will be added automatically.
* Capacity should be the maximum weight of the things that could
* be wrapped with the paper.
* <br>
* The size description of the paper will be calculated from the
* capacity according to the following table:<br>
* 0..10 - "tiny"<br>
* 11..20 - "small"<br>
* 21..50 - "medium-sized"<br>
* 51..100 - "large"<br>
* 101..200 - "huge"<br>
* 201..400 - "enormous"<br>
* <br>
* Anything above 200 will give an error message and a 'broken' paper
* will be created.
* @param description the short adjective-like description
* @param capacity the capacity of the wrapping paper
* @example
* // Make a "huge brown wrapping paper"
* make_wrapping("brown", 120 );
* @example
* // Make a "small beige wrapping paper"
* make_wrapping("beige", 8 );
*/
void make_wrapping( string description, int capacity ) {
if( capacity < 2 )
capacity = 2;
desc = description;
switch( capacity ) {
case 0..TINY:
size = "tiny";
break;
case TINY+1..SMALL:
size = "small";
break;
case SMALL+1..MEDIUM:
size = "medium-sized";
break;
case MEDIUM+1..LARGE:
size = "large";
break;
case LARGE+1..HUGE:
size = "huge";
break;
case HUGE+1..MAX:
size = "enormous";
break;
default:
size = "broken";
capacity = MAX;
printf("The maximum capacity for a wrapping paper is "+MAX+".\n");
}
set_name("paper");
set_short( size+" piece of "+desc+" wrapping paper");
set_main_plural( size+" pieces of "+desc+" wrapping paper");
add_adjective( size+" piece of "+desc+" wrapping");
set_long( (: get_long() :) );
set_weight( 1 + capacity / ( LARGE * 25 ) );
set_value( 100 + to_int( 20 * sqrt( to_float(capacity) ) ) );
set_max_weight( capacity );
set_material("paper");
add_property("writeable", 1 );
} /* make_wrapping() */
/** @ignore yes */
int test_add( object ob, int flag ) {
if( !moving )
return 0;
return ::test_add( ob, flag );
} /* test_add() */
/** @ignore */
int do_wrap( object *obs ) {
object ob, *failed;
int i;
if( wrapped ) {
add_failed_mess("$D $V$0=has,have$V$ already been wrapped around "
"something.\n");
return 0;
}
if( !sizeof(obs) ) {
add_failed_mess("You need to $V $D around something.\n");
return 0;
}
if( ( i = member_array( TO, obs ) ) != -1 ) {
add_failed_mess("You cannot wrap $I around itself.\n", obs[i..i] );
return 0;
}
if( sizeof( failed = filter( obs, (: living($1) :) ) ) ) {
add_failed_mess("You cannot $V $D around $I because they are living "
"things.\n", failed );
return 0;
}
if( sizeof( failed = filter( obs, (: ENV($1) != TP :) ) ) ) {
add_failed_mess("You don't appear to have $I anymore.\n", failed );
return 0;
}
if( sizeof( failed = filter( obs, (: ENV($1) != TP :) ) ) ) {
add_failed_mess("You don't appear to have $I anymore.\n", failed );
return 0;
}
if( sizeof( failed = filter( obs, (: $1->query_worn_by() :) ) ) ) {
add_failed_mess("You cannot $V $D around $I because you are "
"wearing "+({"it", "them"})[query_group(failed)]+".\n", failed );
return 0;
}
if( sizeof( failed = filter( obs, (: $1->query_wielded() :) ) ) ) {
add_failed_mess("You cannot $V $D around $I because you are "
"holding "+({"it", "them"})[query_group(failed)]+".\n", failed );
return 0;
}
if( sizeof( failed = filter( obs, (: $1->query_keep() :) ) ) ) {
add_failed_mess("You cannot $V $D around $I because you are "
"keeping "+({"it", "them"})[query_group(failed)]+".\n", failed );
return 0;
}
i = 0;
foreach( ob in obs )
i += ob->query_complete_weight();
if( i > query_max_weight() ) {
add_failed_mess("$I $V$0=is,are$V$ too large to fit in $D.\n", obs );
return 0;
}
set_stuck( 0 );
moving = 1;
obs->move(TO);
moving = 0;
do_close();
set_stuck( 1 );
wrapped = 1;
call_out( (: set_wrapped :), 2 );
add_succeeded_mess("$N carefully $V $D around $I.\n", obs );
return 1;
} /* do_wrap() */
/** @ignore */
int do_unwrap() {
object *obs, ob;
if( !wrapped ) {
add_failed_mess("$D $V$0=has,have$V$ not been wrapped around "
"anything.\n");
return 0;
}
set_stuck(0);
do_open();
if( !sizeof( obs = INV(TO) ) ) {
add_succeeded_mess("$N tear$s $D to pieces and, much to $p "
"surprise, find$s nothing within.\n");
} else {
add_succeeded_mess("");
tell_object( TP, "You tear "+the_short()+" to pieces and find "+
query_multiple_short( obs, "a")+" enclosed within.\n");
tell_room( ENV(TP), TP->the_short()+" $V$0=tears,tear$V$ "+
the_short()+" to pieces and $V$0=finds,find$V$ "+
query_multiple_short( obs, "a")+" enclosed within.\n", TP );
if( sizeof( obs = filter( obs, (: $1->move(TP) :) ) ) ) {
obs->move(ENV(TP));
tell_object( TP, "Unfortunately you are too burdened and fumble "+
query_multiple_short(obs)+".\n");
}
}
ob = clone_object(PAPER_OBJ);
ob->set_short( size+" torn piece of "+desc+" paper");
ob->set_adjectives( ({ }) );
ob->add_adjective( size+" torn piece of "+desc );
ob->set_long("This is "+add_a(size)+", somewhat torn piece of "+
desc+" paper that seems to have come off a packet or something "
"similar.\n");
ob->set_weight( 80 * query_weight() / 100 + 1 );
ob->set_value( 1 + to_int( 20 * sqrt( to_float(query_max_weight()) ) ) );
ob->set_read_mess( query_read_mess() );
if( ob->move(TP) )
ob->move(ENV(TP));
move("/room/rubbish");
return 1;
} /* do_unwrap() */
/** @ignore */
void init() {
::init();
add_command("wrap",
"<direct:object:me> around <indirect:object:me'things'>",
(: do_wrap($1) :) );
add_command("wrap", "<indirect:object:me'things'> in <direct:object:me>",
(: do_wrap($1) :) );
add_command("unwrap");
} /* init() */
/** @ignore */
mixed stats() {
return ::stats() + ({
({ "wrapped", wrapped }),
({ "desc", desc }),
({ "size", size }),
});
} /* stats() */
/** @ignore yes */
void init_dynamic_arg( mapping map, mixed dummy ) {
if( map["::"] ) {
moving = 1;
::init_dynamic_arg( map["::"], dummy );
moving = 0;
}
if( map["wrapped"] )
wrapped = map["wrapped"];
set_wrapped();
set_long( (: get_long() :) );
} /* init_dynamic_arg() */
/** @ignore yes */
mapping query_dynamic_auto_load() {
mapping map;
map = ([ "::" : ::query_dynamic_auto_load() ]);
if( wrapped )
map["wrapped"] = wrapped;
return map;
} /* query_dynamic_auto_load() */
/** @ignore */
mapping int_query_static_auto_load() {
mapping map;
map = ([ "::" : ::int_query_static_auto_load() ]);
if( desc )
map["desc"] = desc;
if( size )
map["size"] = size;
return map;
} /* int_query_static_auto_load() */
/** @ignore */
void init_static_arg( mapping map ) {
if( map["::"] )
::init_static_arg( map["::"] );
if( map["desc"] )
desc = map["desc"];
if( map["size"] )
size = map["size"];
} /* init_static_arg() */
/** @ignore */
mixed query_static_auto_load() {
if( base_name(TO) == __FILE__[0..<3] )
return int_query_static_auto_load();
return ([ ]);
} /* query_static_auto_load() */
