/* take an object from a char */
void obj_from_char(struct obj_data *object)
{
struct obj_data *tmp;
if (!object) {
log("No object to be take from char.");
assert(0);
}
if (!object->carried_by) {
log("this object is not carried by anyone");
assert(0);
}
if (!object->carried_by->carrying) {
log("No one is carrying this object");
assert(0);
}
if (object->in_obj) {
log("Obj in more than one place.");
assert(0);
}
if (object->equipped_by) {
log("Obj in more than one place.");
assert(0);
}
if (object->carried_by->carrying == object) /* head of list */
object->carried_by->carrying = object->next_content;
else
{
for (tmp = object->carried_by->carrying;
tmp && (tmp->next_content != object);
tmp = tmp->next_content); /* locate previous */
if (!tmp) {
log("Couldn't find object on character");
assert(0);
}
tmp->next_content = object->next_content;
}
IS_CARRYING_W(object->carried_by) -= GET_OBJ_WEIGHT(object);
IS_CARRYING_N(object->carried_by)--;
object->carried_by = 0;
object->equipped_by = 0; /* should be unnecessary, but, why risk it */
object->next_content = 0;
object->in_obj = 0;
}
void
shopping_list(char *arg, struct char_data *ch,
struct char_data * keeper, int shop_nr)
{
char buf[MAX_STRING_LENGTH], name[MAX_INPUT_LENGTH];
struct obj_data *obj, *last_obj = 0;
int cnt = 0, index = 0;
bool found = FALSE;
if (!(is_ok(keeper, ch, shop_nr)))
return;
if (SHOP_SORT(shop_nr) < IS_CARRYING_N(keeper))
sort_keeper_objs(keeper, shop_nr);
one_argument(arg, name);
strcpy(buf, " ## Available Item Cost\n\r");
strcat(buf, "-------------------------------------------------------------------------\n\r");
if (keeper->carrying)
for (obj = keeper->carrying; obj; obj = obj->next_content)
if (CAN_SEE_OBJ(ch, obj) && (obj->obj_flags.cost > 0))
{
if (!last_obj)
{
last_obj = obj;
cnt = 1;
}
else if (same_obj(last_obj, obj))
cnt++;
else {
index++;
if (!(*name) || isname(name, last_obj->name))
{
strcat(buf, list_object(ch, last_obj, cnt, index, shop_nr));
found = TRUE;
}
cnt = 1;
last_obj = obj;
}
}
index++;
if (!last_obj)
stc("Currently, there is nothing for sale.\r\n", ch);
else if (*name && !found)
stc("Presently, none of those are for sale.\r\n", ch);
else {
if (!(*name) || isname(name, last_obj->name))
strcat(buf, list_object(ch, last_obj, cnt, index, shop_nr));
page_string(ch->desc, buf, 1);
}
}
struct obj_data *
slide_obj(struct obj_data * obj, struct char_data * keeper, int shop_nr)
/*
This function is a slight hack! To make sure that duplicate items are
only listed once on the "list", this function groups "identical"
objects together on the shopkeeper's inventory list. The hack involves
knowing how the list is put together, and manipulating the order of
the objects on the list. (But since most of DIKU is not encapsulated,
and information hiding is almost never used, it isn't that big a deal) -JF
*/
{
struct obj_data *loop;
int temp;
if (SHOP_SORT(shop_nr) < IS_CARRYING_N(keeper))
sort_keeper_objs(keeper, shop_nr);
/* Extract the object if it is identical to one produced */
if (shop_producing(obj, shop_nr))
{
temp = GET_OBJ_RNUM(obj);
extract_obj(obj);
return (&obj_proto[temp]);
}
/* randomly remove a piece of eq from shopkeeper inventory */
if (number(0, 5)==0) {
temp = GET_OBJ_RNUM(obj);
extract_obj(obj);
return (&obj_proto[temp]);
}
SHOP_SORT(shop_nr)++;
loop = keeper->carrying;
obj_to_char(obj, keeper);
keeper->carrying = loop;
while (loop)
{
if (same_obj(obj, loop))
{
obj->next_content = loop->next_content;
loop->next_content = obj;
return (obj);
}
loop = loop->next_content;
}
keeper->carrying = obj;
return (obj);
}
/* give an object to a char */
void obj_to_char(struct obj_data * object, struct char_data * ch)
{
if (object && ch) {
object->next_content = ch->carrying;
ch->carrying = object;
object->carried_by = ch;
object->in_room = NOWHERE;
IS_CARRYING_W(ch) += GET_OBJ_WEIGHT(object);
IS_CARRYING_N(ch)++;
/* set flag for crash-save system */
SET_BIT(PLR_FLAGS(ch), PLR_CRASH);
} else
log("SYSERR: NULL obj or char passed to obj_to_char");
}
/* take an object from a char */
void obj_from_char(struct obj_data * object)
{
struct obj_data *temp;
if (object == NULL) {
log("SYSERR: NULL object passed to obj_from_char");
return;
}
REMOVE_FROM_LIST(object, object->carried_by->carrying, next_content);
/* set flag for crash-save system */
SET_BIT(PLR_FLAGS(object->carried_by), PLR_CRASH);
IS_CARRYING_W(object->carried_by) -= GET_OBJ_WEIGHT(object);
IS_CARRYING_N(object->carried_by)--;
object->carried_by = NULL;
object->next_content = NULL;
}
/* Give an object to a char. */
void obj_to_char(struct obj_data *object, struct char_data *ch)
{
if (object && ch) {
object->next_content = ch->carrying;
ch->carrying = object;
object->carried_by = ch;
IN_ROOM(object) = NOWHERE;
IS_CARRYING_W(ch) += GET_OBJ_WEIGHT(object);
IS_CARRYING_N(ch)++;
autoquest_trigger_check(ch, NULL, object, AQ_OBJ_FIND);
/* set flag for crash-save system, but not on mobs! */
if (!IS_NPC(ch))
SET_BIT_AR(PLR_FLAGS(ch), PLR_CRASH);
} else
log("SYSERR: NULL obj (%p) or char (%p) passed to obj_to_char.", object, ch);
}
/* give an object to a char */
void obj_to_char(struct obj_data *object, struct char_data *ch)
{
assert(!object->in_obj && !object->carried_by && !object->equipped_by &&
object->in_room == NOWHERE);
if (ch->carrying)
object->next_content = ch->carrying;
else
object->next_content = 0;
ch->carrying = object;
object->carried_by = ch;
object->in_room = NOWHERE;
object->equipped_by = 0;
object->in_obj = 0;
IS_CARRYING_W(ch) += GET_OBJ_WEIGHT(object);
IS_CARRYING_N(ch)++;
}
/* take an object from a char */
void obj_from_char(struct obj_data *object)
{
struct obj_data *tmp;
if (object->carried_by->carrying == object) /* head of list */
object->carried_by->carrying = object->next_content;
else
{
for (tmp = object->carried_by->carrying;
tmp && (tmp->next_content != object);
tmp = tmp->next_content); /* locate previous */
tmp->next_content = object->next_content;
}
IS_CARRYING_W(object->carried_by) -= GET_OBJ_WEIGHT(object);
IS_CARRYING_N(object->carried_by)--;
object->carried_by = 0;
object->next_content = 0;
}
void
shopping_buy(char *arg, struct char_data *ch,
struct char_data *keeper, int shop_nr)
{
char tempstr[200], buf[MAX_STRING_LENGTH];
struct obj_data *obj, *last_obj = NULL;
int goldamt = 0, buynum, bought = 0;
if (!(is_ok(keeper, ch, shop_nr)))
return;
if (SHOP_SORT(shop_nr) < IS_CARRYING_N(keeper))
sort_keeper_objs(keeper, shop_nr);
if ((buynum = transaction_amt(arg)) < 0)
{
sprintf(buf, "%s A negative amount? Try selling me something.",
GET_NAME(ch));
do_tell(keeper, buf, cmd_tell, 0);
return;
}
if (!(*arg) || !(buynum))
{
sprintf(buf, "%s What do you want to buy??", GET_NAME(ch));
do_tell(keeper, buf, cmd_tell, 0);
return;
}
if (!(obj = get_purchase_obj(ch, arg, keeper, shop_nr, TRUE)))
return;
if ((buy_price(ch, obj, shop_nr) > GET_GOLD(ch)) && !IS_GOD(ch))
{
sprintf(buf, shop_index[shop_nr].missing_cash2, GET_NAME(ch));
do_tell(keeper, buf, cmd_tell, 0);
switch (SHOP_BROKE_TEMPER(shop_nr))
{
case 0:
do_action(keeper, GET_NAME(ch), cmd_puke, 0);
return;
case 1:
do_echo(keeper, "smokes on his joint.", cmd_emote, SCMD_EMOTE);
return;
default:
return;
}
}
if ((IS_CARRYING_N(ch) + 1 > CAN_CARRY_N(ch)))
{
sprintf(buf, "%s: You can't carry any more items.\n\r",
fname(obj->name));
send_to_char(buf, ch);
return;
}
if ((IS_CARRYING_W(ch) + GET_OBJ_WEIGHT(obj)) > CAN_CARRY_W(ch))
{
sprintf(buf, "%s: You can't carry that much weight.\n\r",
fname(obj->name));
send_to_char(buf, ch);
return;
}
while ((obj) && ((GET_GOLD(ch) >= buy_price(ch, obj, shop_nr)) || IS_GOD(ch))
&& (IS_CARRYING_N(ch) < CAN_CARRY_N(ch)) && (bought < buynum)
&& (IS_CARRYING_W(ch) + GET_OBJ_WEIGHT(obj) <= CAN_CARRY_W(ch)))
{
bought++;
/* Test if producing shop ! */
if (shop_producing(obj, shop_nr))
obj = read_object(GET_OBJ_RNUM(obj), REAL);
else
{
obj_from_char(obj);
SHOP_SORT(shop_nr)--;
}
obj_to_char(obj, ch);
goldamt += buy_price(ch, obj, shop_nr);
if (!IS_GOD(ch))
GET_GOLD(ch) -= buy_price(ch, obj, shop_nr);
last_obj = obj;
obj = get_purchase_obj(ch, arg, keeper, shop_nr, FALSE);
if (!same_obj(obj, last_obj))
break;
}
if (bought < buynum)
{
if (!obj || !same_obj(last_obj, obj))
sprintf(buf, "%s I only have %d to sell you.", GET_NAME(ch), bought);
else if (GET_GOLD(ch) < buy_price(ch, obj, shop_nr))
sprintf(buf, "%s You can only afford %d.", GET_NAME(ch), bought);
else if (IS_CARRYING_N(ch) >= CAN_CARRY_N(ch))
sprintf(buf, "%s You can only hold %d.", GET_NAME(ch), bought);
else if (IS_CARRYING_W(ch) + GET_OBJ_WEIGHT(obj) > CAN_CARRY_W(ch))
sprintf(buf, "%s You can only carry %d.", GET_NAME(ch), bought);
else
sprintf(buf, "%s Something screwy only gave you %d.", GET_NAME(ch),
bought);
do_tell(keeper, buf, cmd_tell, 0);
}
if (!IS_GOD(ch))
GET_GOLD(keeper) += goldamt;
sprintf(tempstr, "%s", times_message(ch->carrying, 0, bought));
sprintf(buf, "$n buys %s.", tempstr);
act(buf, FALSE, ch, obj, 0, TO_ROOM);
sprintf(buf, shop_index[shop_nr].message_buy, GET_NAME(ch), goldamt);
do_tell(keeper, buf, cmd_tell, 0);
sprintf(buf, "You now have %s.\n\r", tempstr);
send_to_char(buf, ch);
if (SHOP_USES_BANK(shop_nr))
if (GET_GOLD(keeper) > MAX_OUTSIDE_BANK)
{
SHOP_BANK(shop_nr) += (GET_GOLD(keeper) - MAX_OUTSIDE_BANK);
GET_GOLD(keeper) = MAX_OUTSIDE_BANK;
}
}
void shopping_buy( const char *arg, struct char_data *ch,
struct char_data *keeper, int shop_nr)
{
char argm[100], buf[MAX_STRING_LENGTH], newarg[100];
int num = 1;
struct obj_data *temp1;
int i;
float mult = 0;
if(!(is_ok(keeper,ch,shop_nr)))
return;
if(keeper->generic != 0)
for(i = 0; i <= MAX_TRADE; i++) {
if(keeper->generic == FAMINE)
if(shop_index[shop_nr].type[i] == ITEM_FOOD) {
mult = shop_multiplier; /* we're in a famine, we sell food, so we */
break; /* our prices to hell ;-) -DM */
}
if(keeper->generic == DWARVES_STRIKE)
if((shop_index[shop_nr].type[i] == ITEM_ARMOR) || (shop_index[shop_nr].type[i] == ITEM_WEAPON)) {
mult = shop_multiplier;
break;
}
}
only_argument(arg, argm);
if(!(*argm)) {
sprintf(buf,
"%s what do you want to buy??"
,GET_NAME(ch));
do_tell(keeper,buf,19);
return;
};
if( ( num = getabunch( argm, newarg ) ) != 0 )
{
strcpy(argm,newarg);
}
if (num == 0) num = 1;
if(!( temp1 =
get_obj_in_list_vis(ch,argm,keeper->carrying))) {
sprintf(buf,
shop_index[shop_nr].no_such_item1
,GET_NAME(ch));
do_tell(keeper,buf,19);
return;
}
if(temp1->obj_flags.cost <= 0) {
sprintf(buf,
shop_index[shop_nr].no_such_item1
,GET_NAME(ch));
do_tell(keeper,buf,19);
extract_obj(temp1);
return;
}
if( GET_GOLD(ch) < (int) (num*(temp1->obj_flags.cost*
shop_index[shop_nr].profit_buy -
((chr_apply[ (int)GET_CHR(ch) ].reaction*temp1->obj_flags.cost)/100) +
(mult * temp1->obj_flags.cost))) && GetMaxLevel(ch)<DEMIGOD) {
sprintf(buf, shop_index[shop_nr].missing_cash2, GET_NAME(ch));
do_tell(keeper,buf,19);
switch(shop_index[shop_nr].temper1) {
case 0:
do_action(keeper,GET_NAME(ch),30);
return;
case 1:
do_emote(keeper,"grins happily",36);
return;
default:
return;
}
}
if ((IS_CARRYING_N(ch) + num) > (CAN_CARRY_N(ch)))
{
sprintf(buf,"%s : You can't carry that many items.\n\r",
fname(temp1->name));
send_to_char(buf, ch);
return;
}
if ((IS_CARRYING_W(ch) + (num * temp1->obj_flags.weight)) > CAN_CARRY_W(ch))
{
sprintf(buf,"%s : You can't carry that much weight.\n\r",
fname(temp1->name));
send_to_char(buf, ch);
return;
}
act("$n buys $p.", FALSE, ch, temp1, 0, TO_ROOM);
sprintf(buf, shop_index[shop_nr].message_buy,
GET_NAME(ch), (int) (num * (temp1->obj_flags.cost*
shop_index[shop_nr].profit_buy -
((chr_apply[ (int)GET_CHR(ch)].reaction*temp1->obj_flags.cost)/100) +
(mult * temp1->obj_flags.cost))));
do_tell(keeper,buf,19);
sprintf(buf,"You now have %s (*%d).\n\r",
temp1->short_description,num);
send_to_char(buf,ch);
while (num-- > 0) {
if (GetMaxLevel(ch)<DEMIGOD)
GET_GOLD(ch) -= (int)(temp1->obj_flags.cost*
shop_index[shop_nr].profit_buy -
((chr_apply[ (int)GET_CHR(ch) ].reaction*temp1->obj_flags.cost)/100)+
(mult * temp1->obj_flags.cost));
GET_GOLD(keeper) += (int)(temp1->obj_flags.cost*
shop_index[shop_nr].profit_buy -
((chr_apply[(int)GET_CHR(ch)].reaction*temp1->obj_flags.cost)/100)+
(mult * temp1->obj_flags.cost));
/* Test if producing shop ! */
if (shop_producing(temp1,shop_nr))
temp1 = read_object(temp1->item_number, REAL);
else {
obj_from_char(temp1);
if (temp1 == NULL) {
send_to_char("Sorry, I just ran out of those.\n\r",ch);
GET_GOLD(ch) += (int)(temp1->obj_flags.cost*
shop_index[shop_nr].profit_buy -
((chr_apply[ (int)GET_CHR(ch) ].reaction *
temp1->obj_flags.cost)/100)+
(mult * temp1->obj_flags.cost));
return;
}
}
obj_to_char(temp1,ch);
}
return;
}
void mag_summons(int level, struct char_data *ch, struct obj_data *obj,
int spellnum, int savetype)
{
struct char_data *mob = NULL;
struct obj_data *tobj, *next_obj;
int pfail = 0, msg = 0, fmsg = 0, num = 1, handle_corpse = FALSE, i;
mob_vnum mob_num;
if (ch == NULL)
return;
switch (spellnum) {
case SPELL_CLONE:
msg = 10;
fmsg = rand_number(2, 6); /* Random fail message. */
mob_num = MOB_CLONE;
pfail = 50; /* 50% failure, should be based on something later. */
break;
case SPELL_ANIMATE_DEAD:
if (obj == NULL || !IS_CORPSE(obj)) {
act(mag_summon_fail_msgs[7], FALSE, ch, 0, 0, TO_CHAR);
return;
}
handle_corpse = TRUE;
msg = 11;
fmsg = rand_number(2, 6); /* Random fail message. */
mob_num = MOB_ZOMBIE;
pfail = 10; /* 10% failure, should vary in the future. */
break;
default:
return;
}
if (AFF_FLAGGED(ch, AFF_CHARM)) {
send_to_char(ch, "You are too giddy to have any followers!\r\n");
return;
}
if (rand_number(0, 101) < pfail) {
send_to_char(ch, "%s", mag_summon_fail_msgs[fmsg]);
return;
}
for (i = 0; i < num; i++) {
if (!(mob = read_mobile(mob_num, VIRTUAL))) {
send_to_char(ch, "You don't quite remember how to make that creature.\r\n");
return;
}
char_to_room(mob, IN_ROOM(ch));
IS_CARRYING_W(mob) = 0;
IS_CARRYING_N(mob) = 0;
SET_BIT(AFF_FLAGS(mob), AFF_CHARM);
if (spellnum == SPELL_CLONE) {
/* Don't mess up the prototype; use new string copies. */
mob->player.name = strdup(GET_NAME(ch));
mob->player.short_descr = strdup(GET_NAME(ch));
}
act(mag_summon_msgs[msg], FALSE, ch, 0, mob, TO_ROOM);
add_follower(mob, ch);
}
if (handle_corpse) {
for (tobj = obj->contains; tobj; tobj = next_obj) {
next_obj = tobj->next_content;
obj_from_obj(tobj);
obj_to_char(tobj, mob);
}
extract_obj(obj);
}
}
void make_corpse(struct char_data *ch)
{
char buf2[MAX_NAME_LENGTH + 64];
struct obj_data *corpse, *o;
struct obj_data *money;
int i;
corpse = create_obj();
corpse->item_number = NOTHING;
IN_ROOM(corpse) = NOWHERE;
corpse->name = strdup("corpse");
snprintf(buf2, sizeof(buf2), "The corpse of %s is lying here.", GET_NAME(ch));
corpse->description = strdup(buf2);
snprintf(buf2, sizeof(buf2), "the corpse of %s", GET_NAME(ch));
corpse->short_description = strdup(buf2);
GET_OBJ_TYPE(corpse) = ITEM_CONTAINER;
GET_OBJ_WEAR(corpse) = ITEM_WEAR_TAKE;
GET_OBJ_EXTRA(corpse) = ITEM_NODONATE;
GET_OBJ_VAL(corpse, 0) = 0; /* You can't store stuff in a corpse */
GET_OBJ_VAL(corpse, 3) = 1; /* corpse identifier */
GET_OBJ_WEIGHT(corpse) = GET_WEIGHT(ch) + IS_CARRYING_W(ch);
GET_OBJ_RENT(corpse) = 100000;
if (IS_NPC(ch))
GET_OBJ_TIMER(corpse) = max_npc_corpse_time;
else
GET_OBJ_TIMER(corpse) = max_pc_corpse_time;
/* transfer character's inventory to the corpse */
corpse->contains = ch->carrying;
for (o = corpse->contains; o != NULL; o = o->next_content)
o->in_obj = corpse;
object_list_new_owner(corpse, NULL);
/* transfer character's equipment to the corpse */
for (i = 0; i < NUM_WEARS; i++)
if (GET_EQ(ch, i))
obj_to_obj(unequip_char(ch, i), corpse);
/* transfer gold */
if (GET_GOLD(ch) > 0) {
/*
* following 'if' clause added to fix gold duplication loophole
* The above line apparently refers to the old "partially log in,
* kill the game character, then finish login sequence" duping
* bug. The duplication has been fixed (knock on wood) but the
* test below shall live on, for a while. -gg 3/3/2002
*/
if (IS_NPC(ch) || ch->desc) {
money = create_money(GET_GOLD(ch));
obj_to_obj(money, corpse);
}
GET_GOLD(ch) = 0;
}
ch->carrying = NULL;
IS_CARRYING_N(ch) = 0;
IS_CARRYING_W(ch) = 0;
obj_to_room(corpse, IN_ROOM(ch));
}
/* =========================================================================
NAME : use_tattoo()
DESCRIPTION:
RETURNS : TRUE if a tattoo was used
WARNINGS :
HISTORY : Created by dlkarnes 970417
OTHER :
========================================================================= */
int
use_tattoo( struct char_data *ch )
{
void add_follower_quiet(struct char_data *ch, struct char_data *leader);
if (ch && !IS_NPC(ch))
{
if (TAT_TIMER(ch))
{
char mybuf[256];
sprintf(mybuf, "You can't use your tattoo's magick for "
"%d more hour%s.\r\n", TAT_TIMER(ch),TAT_TIMER(ch)>1?"s":"");
send_to_char(mybuf, ch);
return(FALSE);
}
switch (GET_TATTOO(ch))
{
case TATTOO_NONE:
send_to_char ("You don't have a tattoo.\r\n", ch);
break;
case TATTOO_SKULL:
{
struct char_data *skull = read_mobile(9, VIRTUAL);
struct affected_type af;
char_to_room(skull, ch->in_room);
add_follower_quiet(skull, ch);
IS_CARRYING_W(skull) = 0;
IS_CARRYING_N(skull) = 0;
af.type = SPELL_CHARM;
af.duration = 20;
af.modifier = 0;
af.location = 0;
af.bitvector = AFF_CHARM;
affect_to_char(skull, &af);
act("$n's tattoo glows brightly for a second, and $N appears!",
TRUE, ch, 0, skull, TO_ROOM);
act("Your tattoo glows brightly for a second, and $N appears!",
TRUE, ch, 0, skull, TO_CHAR);
}
break;
case TATTOO_EYE:
call_magic(ch, ch, NULL, SPELL_GREATPERCEPT,
DEFAULT_WAND_LVL, CAST_WAND);
break;
case TATTOO_SHIP:
call_magic(ch, ch, NULL, SPELL_CHANGE_DENSITY,
DEFAULT_WAND_LVL, CAST_WAND);
break;
case TATTOO_ANGEL:
call_magic(ch, ch, NULL, SPELL_BLESS, DEFAULT_WAND_LVL, CAST_WAND);
break;
default:
send_to_char("Your tattoo can't be 'use'd.\r\n", ch);
return (FALSE);
}
TAT_TIMER(ch)=24;
}
return(FALSE);
}
void shopping_buy( char *arg, struct char_data *ch,
struct char_data *keeper, int shop_nr)
{
char argm[100], buf[MAX_STRING_LENGTH];
struct obj_data *temp1;
struct char_data *temp_char;
if(!(is_ok(keeper,ch,shop_nr)))
return;
one_argument(arg, argm);
if(!(*argm))
{
sprintf(buf,
"%s what do you want to buy??"
,GET_NAME(ch));
do_tell(keeper,buf,19);
return;
};
if(!( temp1 =
get_obj_in_list_vis(ch,argm,keeper->carrying)))
{
sprintf(buf,
shop_index[shop_nr].no_such_item1
,GET_NAME(ch));
do_tell(keeper,buf,19);
return;
}
if(temp1->obj_flags.cost <= 0)
{
sprintf(buf,
shop_index[shop_nr].no_such_item1
,GET_NAME(ch));
do_tell(keeper,buf,19);
extract_obj(temp1);
return;
}
if(GET_GOLD(ch) < (int) (temp1->obj_flags.cost*
shop_index[shop_nr].profit_buy) && GET_LEVEL(ch)<22)
{
sprintf(buf,
shop_index[shop_nr].missing_cash2,
GET_NAME(ch));
do_tell(keeper,buf,19);
switch(shop_index[shop_nr].temper1)
{
case 0:
do_action(keeper,GET_NAME(ch),30);
return;
case 1:
do_emote(keeper,"smokes on his joint",36);
return;
default:
return;
}
}
if ((IS_CARRYING_N(ch) + 1 > CAN_CARRY_N(ch)))
{
sprintf(buf,"%s : You can't carry that many items.\n\r",
fname(temp1->name));
send_to_char(buf, ch);
return;
}
if ((IS_CARRYING_W(ch) + temp1->obj_flags.weight) > CAN_CARRY_W(ch))
{
sprintf(buf,"%s : You can't carry that much weight.\n\r",
fname(temp1->name));
send_to_char(buf, ch);
return;
}
act("$n buys $p.", FALSE, ch, temp1, 0, TO_ROOM);
sprintf(buf,
shop_index[shop_nr].message_buy,
GET_NAME(ch),
(int) (temp1->obj_flags.cost*
shop_index[shop_nr].profit_buy));
do_tell(keeper,buf,19);
sprintf(buf,"You now have %s.\n\r",
temp1->short_description);
send_to_char(buf,ch);
if(GET_LEVEL(ch)<22)
GET_GOLD(ch) -= (int)(temp1->obj_flags.cost*
shop_index[shop_nr].profit_buy);
GET_GOLD(keeper) += (int)(temp1->obj_flags.cost*
shop_index[shop_nr].profit_buy);
/* Test if producing shop ! */
if(shop_producing(temp1,shop_nr))
temp1 = read_object(temp1->item_number, REAL);
else
obj_from_char(temp1);
obj_to_char(temp1,ch);
return;
}
void make_corpse(struct char_data *ch)
{
struct obj_data *corpse, *o;
struct obj_data *money;
char buf[MAX_STRING_LENGTH];
int i;
char *strdup(char *source);
struct obj_data *create_money( int amount );
CREATE(corpse, struct obj_data, 1);
clear_object(corpse);
corpse->item_number = NOWHERE;
corpse->in_room = NOWHERE;
corpse->name = strdup("corpse");
sprintf(buf, "Corpse of %s is lying here.",
(IS_NPC(ch) ? ch->player.short_descr : GET_NAME(ch)));
corpse->description = strdup(buf);
sprintf(buf, "Corpse of %s",
(IS_NPC(ch) ? ch->player.short_descr : GET_NAME(ch)));
corpse->short_description = strdup(buf);
corpse->contains = ch->carrying;
if ( (GET_GOLD(ch)>0) &&
( IS_NPC(ch) || (ch->desc) ) )
{
money = create_money(GET_GOLD(ch));
GET_GOLD(ch)=0;
obj_to_obj(money,corpse);
}
corpse->obj_flags.type_flag = ITEM_CONTAINER;
corpse->obj_flags.wear_flags = ITEM_TAKE;
corpse->obj_flags.value[0] = 0; /* You can't store stuff in a corpse */
corpse->obj_flags.value[3] = 1; /* corpse identifyer */
corpse->obj_flags.weight = GET_WEIGHT(ch)+IS_CARRYING_W(ch);
corpse->obj_flags.cost_per_day = 100000;
if (IS_NPC(ch))
corpse->obj_flags.timer = MAX_NPC_CORPSE_TIME;
else
corpse->obj_flags.timer = MAX_PC_CORPSE_TIME;
for (i=0; i<MAX_WEAR; i++)
if (ch->equipment[i])
obj_to_obj(unequip_char(ch, i), corpse);
ch->carrying = 0;
IS_CARRYING_N(ch) = 0;
IS_CARRYING_W(ch) = 0;
corpse->next = object_list;
object_list = corpse;
for(o = corpse->contains; o; o->in_obj = corpse, o = o->next_content);
object_list_new_owner(corpse, 0);
obj_to_room(corpse, ch->in_room);
}
int pet_shops(struct char_data *ch, int cmd, char *arg)
{
char buf[MAX_STRING_LENGTH], pet_name[256];
int pet_room;
struct char_data *pet;
pet_room = ch->in_room+1;
if (cmd==59) { /* List */
send_to_char("Available pets are:\n\r", ch);
for(pet = world[pet_room].people; pet; pet = pet->next_in_room) {
sprintf(buf, "%8d - %s\n\r", 3*GET_EXP(pet), pet->player.short_descr);
send_to_char(buf, ch);
}
return(TRUE);
} else if (cmd==56) { /* Buy */
arg = one_argument(arg, buf);
arg = one_argument(arg, pet_name);
/* Pet_Name is for later use when I feel like it */
if (!(pet = get_char_room(buf, pet_room))) {
send_to_char("There is no such pet!\n\r", ch);
return(TRUE);
}
if (GET_GOLD(ch) < (GET_EXP(pet)*3)) {
send_to_char("You don't have enough gold!\n\r", ch);
return(TRUE);
}
GET_GOLD(ch) -= GET_EXP(pet)*3;
pet = read_mobile(pet->nr, REAL);
GET_EXP(pet) = 0;
SET_BIT(pet->specials.affected_by, AFF_CHARM);
if (*pet_name) {
sprintf(buf,"%s %s", pet->player.name, pet_name);
free(pet->player.name);
pet->player.name = strdup(buf);
sprintf(buf,"%sA small sign on a chain around the neck says 'My Name is %s'\n\r",
pet->player.description, pet_name);
free(pet->player.description);
pet->player.description = strdup(buf);
}
char_to_room(pet, ch->in_room);
add_follower(pet, ch);
/* Be certain that pet's can't get/carry/use/weild/wear items */
IS_CARRYING_W(pet) = 1000;
IS_CARRYING_N(pet) = 100;
send_to_char("May you enjoy your pet.\n\r", ch);
act("$n bought $N as a pet.",FALSE,ch,0,pet,TO_ROOM);
return(TRUE);
}
/* All commands except list and buy */
return(FALSE);
}
