[ViewVC] Diff of: cvs/deliantra/server/common/item.C

Comparing deliantra/server/common/item.C (file contents):
Revision 1.44 by root, Sun Apr 13 21:22:47 2008 UTC vs.
Revision 1.63 by root, Fri Nov 6 13:03:34 2009 UTC

…		…
1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	#include <global.h>	25	#include <global.h>
25	#include <funcpoint.h>
26	#include <living.h>	26	#include <living.h>
27	#include <spells.h>	27	#include <spells.h>
28		28
29	const char *const coins[NUM_COINS + 1] = { "royalty", "platinacoin", "goldcoin", "silvercoin", 0 };	29	const char *const coins[NUM_COINS + 1] = { "royalty", "platinacoin", "goldcoin", "silvercoin", 0 };
30		30
170	{SPELLBOOK, "spellbook", "spellbooks", SK_LITERACY, 0},	170	{SPELLBOOK, "spellbook", "spellbooks", SK_LITERACY, 0},
171	{CLOAK, "cloak", "cloaks", SK_SMITHERY, 0},	171	{CLOAK, "cloak", "cloaks", SK_SMITHERY, 0},
172	{SPINNER, "spinner", "spinners", 0, 0},	172	{SPINNER, "spinner", "spinners", 0, 0},
173	{GATE, "gate", "gates", 0, 0},	173	{GATE, "gate", "gates", 0, 0},
174	{BUTTON, "button", "buttons", 0, 0},	174	{BUTTON, "button", "buttons", 0, 0},
175	{CF_HANDLE, "cf handle", "cf handles", 0, 0},	175	{T_HANDLE, "cf handle", "cf handles", 0, 0},
176	{HOLE, "hole", "holes", 0, 0},	176	{HOLE, "hole", "holes", 0, 0},
177	{TRAPDOOR, "trapdoor", "trapdoors", 0, 0},	177	{TRAPDOOR, "trapdoor", "trapdoors", 0, 0},
178	{SIGN, "sign", "signs", 0, 0},	178	{SIGN, "sign", "signs", 0, 0},
179	{BOOTS, "boots", "boots", SK_SMITHERY, 0},	179	{BOOTS, "boots", "boots", SK_SMITHERY, 0},
180	{GLOVES, "gloves", "gloves", SK_SMITHERY, 0},	180	{GLOVES, "gloves", "gloves", SK_SMITHERY, 0},
…		…
207	{BUILDER, "item builder", "item builders", 0, 0},	207	{BUILDER, "item builder", "item builders", 0, 0},
208	{MATERIAL, "building material", "building materials", 0, 0},	208	{MATERIAL, "building material", "building materials", 0, 0},
209	{ITEM_TRANSFORMER, "item_transformer", "item_transformers", 0, 0},	209	{ITEM_TRANSFORMER, "item_transformer", "item_transformers", 0, 0},
210	};	210	};
211		211
212	const int item_types_size = sizeof (item_types) / sizeof (*item_types);	212	static const int item_types_size = sizeof (item_types) / sizeof (*item_types);
213		213
214	materialtype_t *materialt;	214	materialtype_t *materialt;
215		215
216	/*	216	/*
217	materialtype material[NROFMATERIALS] = {	217	materialtype material[NROFMATERIALS] = {
…		…
253	};	253	};
254		254
255	int	255	int
256	get_power_from_ench (int ench)	256	get_power_from_ench (int ench)
257	{	257	{
258	if (ench < 0) ench = 0;
259	if (ench > 20) ench = 20;
260
261	return enc_to_item_power[ench];	258	return enc_to_item_power [clamp (ench, 0, 20)];
262	}	259	}
263		260
264	/* This takes an object 'op' and figures out what its item_power	261	/* This takes an object 'op' and figures out what its item_power
265	* rating should be. This should only really be used by the treasure	262	* rating should be. This should only really be used by the treasure
266	* generation code, and when loading legacy objects. It returns	263	* generation code, and when loading legacy objects. It returns
…		…
300	if (op->type == WEAPON)	297	if (op->type == WEAPON)
301	{	298	{
302	for (i = 1; i < NROFATTACKS; i++)	299	for (i = 1; i < NROFATTACKS; i++)
303	if (op->attacktype & (1 << i))	300	if (op->attacktype & (1 << i))
304	enc++;	301	enc++;
		302
305	if (op->slaying)	303	if (op->slaying)
306	enc += 2; /* What it slays is probably more relevent */	304	enc += 2; /* What it slays is probably more relevent */
307	}	305	}
		306
308	/* Items the player can equip */	307	/* Items the player can equip */
309	if ((op->type == WEAPON) \|\| (op->type == ARMOUR) \|\| (op->type == HELMET) \|\|	308	if ((op->type == WEAPON) \|\| (op->type == ARMOUR) \|\| (op->type == HELMET) \|\|
310	(op->type == SHIELD) \|\| (op->type == RING) \|\|	309	(op->type == SHIELD) \|\| (op->type == RING) \|\|
311	(op->type == BOOTS) \|\| (op->type == GLOVES) \|\|	310	(op->type == BOOTS) \|\| (op->type == GLOVES) \|\|
312	(op->type == AMULET) \|\| (op->type == GIRDLE) \|\| (op->type == BRACERS) \|\| (op->type == CLOAK))	311	(op->type == AMULET) \|\| (op->type == GIRDLE) \|\| (op->type == BRACERS) \|\| (op->type == CLOAK))
…		…
315	enc += op->stats.hp; /* hp regen */	314	enc += op->stats.hp; /* hp regen */
316	enc += op->stats.sp; /* mana regen */	315	enc += op->stats.sp; /* mana regen */
317	enc += op->stats.grace; /* grace regen */	316	enc += op->stats.grace; /* grace regen */
318	enc += op->stats.exp; /* speed bonus */	317	enc += op->stats.exp; /* speed bonus */
319	}	318	}
		319
320	enc += op->stats.luck;	320	enc += op->stats.luck;
321		321
322	/* Do spell paths now */	322	/* Do spell paths now */
323	for (i = 1; i < NRSPELLPATHS; i++)	323	for (i = 1; i < NRSPELLPATHS; i++)
324	{	324	{
…		…
328	enc -= 2;	328	enc -= 2;
329	else if (op->path_repelled & (1 << i))	329	else if (op->path_repelled & (1 << i))
330	enc--;	330	enc--;
331	}	331	}
332		332
333	if (QUERY_FLAG (op, FLAG_LIFESAVE))	333	if (op->flag [FLAG_LIFESAVE ]) enc += 5;
334	enc += 5;	334	if (op->flag [FLAG_REFL_SPELL ]) enc += 3;
335	if (QUERY_FLAG (op, FLAG_REFL_SPELL))	335	if (op->flag [FLAG_REFL_MISSILE]) enc += 2;
336	enc += 3;	336	if (op->flag [FLAG_XRAYS ]) enc += 2;
337	if (QUERY_FLAG (op, FLAG_REFL_MISSILE))	337	if (op->flag [FLAG_STEALTH ]) enc += 1;
338	enc += 2;	338	if (op->flag [FLAG_SEE_IN_DARK ]) enc += 1;
339	if (QUERY_FLAG (op, FLAG_STEALTH))	339	if (op->flag [FLAG_MAKE_INVIS ]) enc += 1;
340	enc += 1;
341	if (QUERY_FLAG (op, FLAG_XRAYS))
342	enc += 2;
343	if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
344	enc += 1;
345	if (QUERY_FLAG (op, FLAG_MAKE_INVIS))
346	enc += 1;
347		340
348	return get_power_from_ench (enc);	341	return get_power_from_ench (enc);
349	}	342	}
350		343
351	/* returns the typedata that has a number equal to itemtype, if there	344	/* returns the typedata that has a number equal to itemtype, if there
352	* isn't one, returns NULL */	345	* isn't one, returns NULL */
353	const typedata *	346	const typedata *
354	get_typedata (int itemtype)	347	get_typedata (int itemtype)
355	{	348	{
356	int i;
357
358	for (i = 0; i < item_types_size; i++)	349	for (int i = 0; i < item_types_size; i++)
359	if (item_types[i].number == itemtype)	350	if (item_types[i].number == itemtype)
360	return &item_types[i];	351	return &item_types[i];
		352
361	return NULL;	353	return NULL;
362	}	354	}
363		355
364	/* returns the typedata that has a name equal to itemtype, if there	356	/* returns the typedata that has a name equal to itemtype, if there
365	* isn't one, return the plural name that matches, if there still isn't	357	* isn't one, return the plural name that matches, if there still isn't
366	* one return NULL */	358	* one return NULL */
367	const typedata *	359	const typedata *
368	get_typedata_by_name (const char *name)	360	get_typedata_by_name (const char *name)
369	{	361	{
370	int i;
371
372	for (i = 0; i < item_types_size; i++)	362	for (int i = 0; i < item_types_size; i++)
373	if (!strcmp (item_types[i].name, name))	363	if (!strcmp (item_types[i].name, name))
374	return &item_types[i];	364	return &item_types[i];
		365
375	for (i = 0; i < item_types_size; i++)	366	for (int i = 0; i < item_types_size; i++)
376	if (!strcmp (item_types[i].name_pl, name))	367	if (!strcmp (item_types[i].name_pl, name))
377	{	368	{
378	LOG (llevInfo,	369	LOG (llevInfo,
379	"get_typedata_by_name: I have been sent the plural %s, the singular form %s is preffered\n", name, item_types[i].name);	370	"get_typedata_by_name: I have been sent the plural %s, the singular form %s is prefered\n", name, item_types[i].name);
380	return &item_types[i];	371	return &item_types[i];
381	}	372	}
		373
382	return NULL;	374	return 0;
383	}	375	}
384		376
385	/* describe_resistance generates the visible naming for resistances.	377	/* describe_resistance generates the visible naming for resistances.
386	* returns a static array of the description. This can return	378	* returns a static array of the description. This can return
387	* a big buffer.	379	* a big buffer.
…		…
389	* but do put a newline at the end. Useful when dumping to files	381	* but do put a newline at the end. Useful when dumping to files
390	*/	382	*/
391	const char *	383	const char *
392	describe_resistance (const object *op, int newline)	384	describe_resistance (const object *op, int newline)
393	{	385	{
394	static char buf[VERY_BIG_BUF];	386	static dynbuf_text buf; buf.clear ();
395	char buf1[VERY_BIG_BUF];
396	int tmpvar;
397		387
398	buf[0] = 0;	388	for (int i = 0; i < NROFATTACKS; i++)
399	for (tmpvar = 0; tmpvar < NROFATTACKS; tmpvar++)
400	{
401	if (op->resist[tmpvar] && (op->type != FLESH \|\| atnr_is_dragon_enabled (tmpvar) == 1))	389	if (op->resist[i] && (op->type != FLESH \|\| atnr_is_dragon_enabled (i) == 1))
402	{	390	buf.printf (newline ? "%s %d\n" : "(%s %+d)", resist_plus[i], op->resist[i]);
403	if (!newline)
404	sprintf (buf1, "(%s %+d)", resist_plus[tmpvar], op->resist[tmpvar]);
405	else
406	sprintf (buf1, "%s %d\n", resist_plus[tmpvar], op->resist[tmpvar]);
407		391
408	strcat (buf, buf1);
409	}
410	}
411	return buf;	392	return buf;
412	}	393	}
413
414		394
415	/*	395	/*
416	* query_weight(object) returns a character pointer to a static buffer	396	* query_weight(object) returns a character pointer to a static buffer
417	* containing the text-representation of the weight of the given object.	397	* containing the text-representation of the weight of the given object.
418	* The buffer will be overwritten by the next call to query_weight().	398	* The buffer will be overwritten by the next call to query_weight().
		399	*
		400	* Seems to be used only by unimportant stuff. Remove?
419	*/	401	*/
420	const char *	402	const char *
421	query_weight (const object *op)	403	query_weight (const object *op)
422	{	404	{
423	static char buf[10];	405	static char buf[10];
424	sint32 i = (op->nrof ? op->nrof : 1) * op->weight + op->carrying;	406	sint32 i = op->total_weight ();
425		407
426	if (op->weight < 0)	408	if (op->weight < 0)
427	return " ";	409	return " ";
428		410
429	if (i % 1000)	411	if (i % 1000)
…		…
449	return buf;	431	return buf;
450	}	432	}
451		433
452	if (i < 21)	434	if (i < 21)
453	return levelnumbers[i];	435	return levelnumbers[i];
		436
454	if (!(i % 10))	437	if (!(i % 10))
455	return levelnumbers_10[i / 10];	438	return levelnumbers_10[i / 10];
456		439
457	strcpy (buf, numbers_10[i / 10]);	440	strcpy (buf, numbers_10[i / 10]);
458	strcat (buf, levelnumbers[i % 10]);	441	strcat (buf, levelnumbers[i % 10]);
…		…
463	* get_number(integer) returns the text-representation of the given number	446	* get_number(integer) returns the text-representation of the given number
464	* in a static buffer. The buffer might be overwritten at the next	447	* in a static buffer. The buffer might be overwritten at the next
465	* call to get_number().	448	* call to get_number().
466	* It is currently only used by the query_name() function.	449	* It is currently only used by the query_name() function.
467	*/	450	*/
468	const char *	451	static const char *
469	get_number (int i)	452	get_number (int i)
470	{	453	{
471	if (i <= 20)	454	if (i <= 20)
472	return numbers[i];	455	return numbers[i];
473	else	456	else
…		…
490	*/	473	*/
491		474
492	/* Aug 95 modified this slightly so that Skill tools don't have magic bonus	475	/* Aug 95 modified this slightly so that Skill tools don't have magic bonus
493	* from stats.sp - b.t.	476	* from stats.sp - b.t.
494	*/	477	*/
495	const char *	478	static const char *
496	ring_desc (const object *op)	479	ring_desc (const object *op)
497	{	480	{
498	static dynbuf_text buf; buf.clear ();	481	static dynbuf_text buf; buf.clear ();
499	int attr, val, len;	482	int attr, val, len;
500		483
…		…
534	}	517	}
535		518
536	/*	519	/*
537	* query_short_name(object) is similar to query_name, but doesn't	520	* query_short_name(object) is similar to query_name, but doesn't
538	* contain any information about object status (worn/cursed/etc.)	521	* contain any information about object status (worn/cursed/etc.)
		522	*
		523	* It is sometimes used when printing messages, so should fit well into a sentence.
539	*/	524	*/
540	const char *	525	const char *
541	query_short_name (const object *op)	526	query_short_name (const object *op)
542	{	527	{
543	if (op->name == 0)	528	if (!op->name)
544	return "(null)";	529	return "(null)";
545		530
546	if (!op->nrof	531	if (!op->nrof
547	&& !op->weight	532	&& !op->weight
548	&& !op->title	533	&& !op->title
…		…
571	if (op->type != SPELLBOOK)	556	if (op->type != SPELLBOOK)
572	buf.printf (" (lvl %d)", op->level);	557	buf.printf (" (lvl %d)", op->level);
573	}	558	}
574	break;	559	break;
575		560
576	case ALTAR:	561	case ALTAR:
577	case TRIGGER_ALTAR:	562	case TRIGGER_ALTAR:
578	case IDENTIFY_ALTAR:	563	case IDENTIFY_ALTAR:
579	case CONVERTER:	564	case CONVERTER:
580	if (op->slaying == shstr_money)	565	if (op->slaying == shstr_money)
581	{	566	{
582	bool wrap = !!buf.size ();	567	bool wrap = !!buf.size ();
583		568
584	if (wrap) buf << " [";	569	if (wrap) buf << " [";
585		570
586	archetype *coin = 0;	571	archetype *coin = 0;
587		572
588	for (char const const c = coins; *coins; ++c)	573	for (char const const c = coins; *coins; ++c)
589	if ((coin = archetype::find (*c)))	574	if ((coin = archetype::find (*c)))
590	if (op->stats.food % coin->value == 0)	575	if (op->stats.food % coin->value == 0)
591	break;	576	break;
592		577
593	sint32 coins = op->stats.food / coin->value;	578	sint32 coins = op->stats.food / coin->value;
594		579
595	buf.printf ("drop %d %s (or equivalent)", coins, coins == 1 ? &coin->name : &coin->name_pl);	580	buf.printf ("drop %d %s (or equivalent)", coins, coins == 1 ? &coin->name : &coin->name_pl);
596		581
597	if (wrap) buf << ']';	582	if (wrap) buf << ']';
598	}	583	}
599	break;	584	break;
600		585
601	case SKILL:	586	case SKILL:
602	case AMULET:	587	case AMULET:
603	case RING:	588	case RING:
604	if (!op->title)	589	if (!op->title)
…		…
627	* you can make several calls to query_name before the bufs start getting	612	* you can make several calls to query_name before the bufs start getting
628	* overwritten. This may be a bad thing (it may be easier to assume the value	613	* overwritten. This may be a bad thing (it may be easier to assume the value
629	* returned is good forever.) However, it makes printing statements that	614	* returned is good forever.) However, it makes printing statements that
630	* use several names much easier (don't need to store them to temp variables.)	615	* use several names much easier (don't need to store them to temp variables.)
631	*	616	*
		617	* It is used extensively within messages, so should return only a prose
		618	* and short description of the item.
632	*/	619	*/
633	const char *	620	const char *
634	query_name (const object *op)	621	query_name (const object *op)
635	{	622	{
636	int len = 0;	623	int len = 0;
…		…
649		636
650	buf << query_short_name (op);	637	buf << query_short_name (op);
651		638
652	if (QUERY_FLAG (op, FLAG_INV_LOCKED))	639	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
653	buf << " *";	640	buf << " *";
654	if (op->type == CONTAINER && ((op->env && op->env->container == op) \|\| (!op->env && QUERY_FLAG (op, FLAG_APPLIED))))	641	if (op->is_open_container ())
655	buf << " (open)";	642	buf << " (open)";
656		643
657	if (QUERY_FLAG (op, FLAG_KNOWN_CURSED))	644	if (QUERY_FLAG (op, FLAG_KNOWN_CURSED))
658	{	645	{
659	if (QUERY_FLAG (op, FLAG_DAMNED))	646	if (QUERY_FLAG (op, FLAG_DAMNED))
…		…
673	*/	660	*/
674	if (QUERY_FLAG (op, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (op, FLAG_IDENTIFIED))	661	if (QUERY_FLAG (op, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (op, FLAG_IDENTIFIED))
675	buf << " (magic)";	662	buf << " (magic)";
676		663
677	#if 0	664	#if 0
678	/* item_power will be returned in desribe_item - it shouldn't really	665	/* item_power will be returned in describe_item - it shouldn't really
679	* be returned in the name.	666	* be returned in the name.
680	*/	667	*/
681	if (op->item_power)	668	if (op->item_power)
682	sprintf (buf[use_buf] + strlen (buf[use_buf]), "(item_power %+d)", op->item_power);	669	sprintf (buf[use_buf] + strlen (buf[use_buf]), "(item_power %+d)", op->item_power);
683		670
…		…
715	default:	702	default:
716	buf << " (applied)";	703	buf << " (applied)";
717	}	704	}
718	}	705	}
719		706
		707	switch (op->type)
		708	{
		709	case LAMP:
		710	if (op->glow_radius)
		711	buf << " (on)";
		712	else if (op->stats.food <= 0)
		713	buf << " (empty)";
		714	else
		715	buf << " (off)";
		716	break;
		717
		718	case TORCH:
		719	if (op->glow_radius)
		720	buf << " (burning)";
		721	else if (op->stats.food <= 0)
		722	buf << " (burned out)";
		723	break;
		724	}
		725
720	if (QUERY_FLAG (op, FLAG_UNPAID))	726	if (QUERY_FLAG (op, FLAG_UNPAID))
721	buf << " (unpaid)";	727	buf << " (unpaid)";
722		728
723	return buf;	729	return buf;
724	}	730	}
…		…
729	* of the given object. The buffer will be overwritten at the next	735	* of the given object. The buffer will be overwritten at the next
730	* call to query_base_name(). This is a lot like query_name, but we	736	* call to query_base_name(). This is a lot like query_name, but we
731	* don't include the item count or item status. Used for inventory sorting	737	* don't include the item count or item status. Used for inventory sorting
732	* and sending to client.	738	* and sending to client.
733	* If plural is set, we generate the plural name of this.	739	* If plural is set, we generate the plural name of this.
		740	*
		741	* It is sometimes used to display messages, and usually only used to match stuff,
		742	* so maybe this function should be removed.
734	*/	743	*/
735	const char *	744	const char *
736	query_base_name (const object *op, int plural)	745	query_base_name (const object *op, int plural)
737	{	746	{
738	if ((!plural && !op->name) \|\| (plural && !op->name_pl))	747	if ((!plural && !op->name) \|\| (plural && !op->name_pl))
…		…
808	*/	817	*/
809	if (op->has_active_speed ())	818	if (op->has_active_speed ())
810	switch ((int) ((FABS (op->speed)) * 15))	819	switch ((int) ((FABS (op->speed)) * 15))
811	{	820	{
812	case 0:	821	case 0:
813	buf << "(very slow movement";	822	buf << "(very slow movement)";
814	break;	823	break;
815	case 1:	824	case 1:
816	buf << "(slow movement)";	825	buf << "(slow movement)";
817	break;	826	break;
818	case 2:	827	case 2:
…		…
933	* wouldn't need to use the SEE_INVISIBLE flag to know it is	942	* wouldn't need to use the SEE_INVISIBLE flag to know it is
934	* a dragon player examining food. Could have things like	943	* a dragon player examining food. Could have things like
935	* a dwarven axe, in which the full abilities are only known to	944	* a dwarven axe, in which the full abilities are only known to
936	* dwarves, etc.	945	* dwarves, etc.
937	*	946	*
938	* This function is really much more complicated than it should
939	* be, because different objects have different meanings
940	* for the same field (eg, wands use 'food' for charges). This
941	* means these special cases need to be worked out.
942	*
943	* Add 'owner' who is the person examining this object.	947	* Add 'owner' who is the person examining this object.
944	* owner can be null if no one is being associated with this	948	* owner can be null if no one is being associated with this
945	* item (eg, debug dump or the like)	949	* item (eg, debug dump or the like)
946	*/	950	*/
947	const char *	951	const char *
…		…
1005	buf << "well charged.";	1009	buf << "well charged.";
1006	else if (op->stats.sp == op->stats.maxsp)	1010	else if (op->stats.sp == op->stats.maxsp)
1007	buf << "fully charged.";	1011	buf << "fully charged.";
1008	else	1012	else
1009	buf << "almost full.";	1013	buf << "almost full.";
		1014	break;
		1015
		1016	case LAMP:
		1017	{
		1018	int percent = ((double) 100 / op->arch->stats.food) * op->stats.food;
		1019	buf << "(fuel: ";
		1020	if (percent == 0)
		1021	buf << "empty";
		1022	else if (percent < 10)
		1023	buf << "very low";
		1024	else if (percent < 25)
		1025	buf << "low";
		1026	else if (percent < 50)
		1027	buf << "half empty";
		1028	else if (percent < 75)
		1029	buf << "half full";
		1030	else if (percent < 95)
		1031	buf << "well filled";
		1032	else if (percent <= 100)
		1033	buf << "full";
		1034	buf << ")";
		1035	}
1010	break;	1036	break;
1011		1037
1012	case FOOD:	1038	case FOOD:
1013	case FLESH:	1039	case FLESH:
1014	case DRINK:	1040	case DRINK:
…		…
1170	if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealth)";	1196	if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealth)";
1171		1197
1172	if (op->slaying && op->type != FOOD)	1198	if (op->slaying && op->type != FOOD)
1173	buf.printf ("(slay %s)", &op->slaying);	1199	buf.printf ("(slay %s)", &op->slaying);
1174		1200
		1201	if (op->type == SKILL_TOOL && op->skill)
		1202	buf.printf ("(%s)", &op->skill);
		1203
1175	buf.add_abilities ("Attacks", op->attacktype);	1204	buf.add_abilities ("Attacks", op->attacktype);
1176	/* resistance on flesh is only visible for quetzals. If	1205	/* resistance on flesh is only visible for quetzals. If
1177	* non flesh, everyone can see its resistances	1206	* non flesh, everyone can see its resistances
1178	*/	1207	*/
1179	if (op->type != FLESH \|\| (owner && is_dragon_pl (owner)))	1208	if (op->type != FLESH \|\| (owner && is_dragon_pl (owner)))
…		…
1194	}	1223	}
1195		1224
1196	void	1225	void
1197	examine (object op, object tmp)	1226	examine (object op, object tmp)
1198	{	1227	{
1199	std::string s = tmp->describe (op);	1228	std::string info = tmp->describe (op);
1200		1229
1201	new_draw_info (NDI_UNIQUE, 0, op, s.c_str ());	1230	op->contr->infobox (MSG_CHANNEL ("examine"), info.c_str ());
1202	}	1231	}
1203		1232
1204	/*	1233	/*
1205	* inventory prints object's inventory. If inv==NULL then print player's	1234	* inventory prints object's inventory. If inv==NULL then print player's
1206	* inventory.	1235	* inventory.
…		…
1211	{	1240	{
1212	static dynbuf_text buf; buf.clear ();	1241	static dynbuf_text buf; buf.clear ();
1213		1242
1214	for (object *tmp = inv; tmp; tmp = tmp->below)	1243	for (object *tmp = inv; tmp; tmp = tmp->below)
1215	if (who && QUERY_FLAG (who, FLAG_WIZ))	1244	if (who && QUERY_FLAG (who, FLAG_WIZ))
1216	buf.printf ("%s- %-28.28s (%5d) %-8s\n", indent, query_name (tmp), tmp->count, query_weight (tmp));	1245	buf.printf ("%s- %-28.28s (%5d) %-8s\n", indent, tmp->query_name (), tmp->count, tmp->query_weight ());
1217	else if (!tmp->invisible && (type == CONTAINER \|\| QUERY_FLAG (tmp, FLAG_APPLIED)))	1246	else if (!tmp->invisible && (type == CONTAINER \|\| QUERY_FLAG (tmp, FLAG_APPLIED)))
1218	buf.printf ("%s- %-36.36s %-8s\n", indent, query_name (tmp), query_weight (tmp));	1247	buf.printf ("%s- %-36.36s %-8s\n", indent, tmp->query_name (), tmp->query_weight ());
1219		1248
1220	if (buf.size ())	1249	if (buf.size ())
1221	buf.printf ("%s(total weight: %s)\n", indent, query_weight (this));	1250	buf.printf ("%s(total weight: %s)\n", indent, query_weight ());
1222	else	1251	else
1223	buf.printf ("%s(empty)\n", indent);	1252	buf.printf ("%s(empty)\n", indent);
1224		1253
1225	return buf;	1254	return buf;
1226	}	1255	}
…		…
1358	* Supposed to fix face-values as well here, but later.	1387	* Supposed to fix face-values as well here, but later.
1359	*/	1388	*/
1360	void	1389	void
1361	identify (object *op)	1390	identify (object *op)
1362	{	1391	{
1363	object *pl;
1364
1365	SET_FLAG (op, FLAG_IDENTIFIED);	1392	SET_FLAG (op, FLAG_IDENTIFIED);
1366	CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);	1393	CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);
1367	CLEAR_FLAG (op, FLAG_NO_SKILL_IDENT);	1394	CLEAR_FLAG (op, FLAG_NO_SKILL_IDENT);
1368		1395
1369	/*	1396	/*
…		…
1376	{	1403	{
1377	if (op->inv && op->randomitems)	1404	if (op->inv && op->randomitems)
1378	op->title = op->inv->name;	1405	op->title = op->inv->name;
1379	else if (op->arch)	1406	else if (op->arch)
1380	{	1407	{
1381	op->name = op->arch->object::name;	1408	op->name = op->arch->object::name;
1382	op->name_pl = op->arch->object::name_pl;	1409	op->name_pl = op->arch->object::name_pl;
1383	}	1410	}
1384	}	1411	}
1385		1412
1386	/* If the object is on a map, make sure we update its face */	1413	/* If the object is on a map, make sure we update its face */
1387	if (op->map)	1414	if (op->map)
1388	update_object (op, UP_OBJ_CHANGE);	1415	update_object (op, UP_OBJ_CHANGE);
1389	else	1416
1390	{	1417	if (object *pl = op->visible_to ())
1391	pl = op->in_player ();
1392	if (pl)
1393	/* A lot of the values can change from an update - might as well send	1418	/* A lot of the values can change from an update - might as well send
1394	* it all.	1419	* it all.
1395	*/	1420	*/
1396	esrv_send_item (pl, op);	1421	esrv_send_item (pl, op);
1397	}
1398	}	1422	}
1399		1423

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/common/item.C (file contents): Revision 1.44 by root, Sun Apr 13 21:22:47 2008 UTC vs. Revision 1.63 by root, Fri Nov 6 13:03:34 2009 UTC

Diff Legend

Comparing deliantra/server/common/item.C (file contents):
Revision 1.44 by root, Sun Apr 13 21:22:47 2008 UTC vs.
Revision 1.63 by root, Fri Nov 6 13:03:34 2009 UTC