Server upload

RD Core / Commit #2

Commit Server upload

Alex committed 18/10/2026 23:38 main Patch

1,106 files +223,404 -0

All commits Browse code

A src/item.cpp +1,794-0 View file

Large diff collapsed. 1,795 diff lines hidden.

		@@ -0,0 +1,1794 @@
1	+	/**
2	+	* The Forgotten Server - a free and open-source MMORPG server emulator
3	+	* Copyright (C) 2019 Mark Samman <mark.samman@gmail.com>
4	+	*
5	+	* This program is free software; you can redistribute it and/or modify
6	+	* it under the terms of the GNU General Public License as published by
7	+	* the Free Software Foundation; either version 2 of the License, or
8	+	* (at your option) any later version.
9	+	*
10	+	* This program is distributed in the hope that it will be useful,
11	+	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	+	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	+	* GNU General Public License for more details.
14	+	*
15	+	* You should have received a copy of the GNU General Public License along
16	+	* with this program; if not, write to the Free Software Foundation, Inc.,
17	+	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18	+	*/
19	+
20	+	#include "otpch.h"
21	+
22	+	#include "item.h"
23	+	#include "container.h"
24	+	#include "teleport.h"
25	+	#include "trashholder.h"
26	+	#include "mailbox.h"
27	+	#include "house.h"
28	+	#include "game.h"
29	+	#include "bed.h"
30	+
31	+	#include "actions.h"
32	+	#include "spells.h"
33	+
34	+	extern Game g_game;
35	+	extern Spells* g_spells;
36	+	extern Vocations g_vocations;
37	+
38	+	Items Item::items;
39	+
40	+	Item* Item::CreateItem(const uint16_t type, uint16_t count /= 0/)
41	+	{
42	+	Item* newItem = nullptr;
43	+
44	+	const ItemType& it = Item::items[type];
45	+	if (it.group == ITEM_GROUP_DEPRECATED) {
46	+	return nullptr;
47	+	}
48	+
49	+	if (it.stackable && count == 0) {
50	+	count = 1;
51	+	}
52	+
53	+	if (it.id != 0) {
54	+	if (it.isDepot()) {
55	+	newItem = new DepotLocker(type);
56	+	} else if (it.isContainer()) {
57	+	newItem = new Container(type);
58	+	} else if (it.isTeleport()) {
59	+	newItem = new Teleport(type);
60	+	} else if (it.isMagicField()) {
61	+	newItem = new MagicField(type);
62	+	} else if (it.isDoor()) {
63	+	newItem = new Door(type);
64	+	} else if (it.isTrashHolder()) {
65	+	newItem = new TrashHolder(type);
66	+	} else if (it.isMailbox()) {
67	+	newItem = new Mailbox(type);
68	+	} else if (it.isBed()) {
69	+	newItem = new BedItem(type);
70	+	} else if (it.id >= 2210 && it.id <= 2212) {
71	+	newItem = new Item(type - 3, count);
72	+	} else if (it.id == 2215 \|\| it.id == 2216) {
73	+	newItem = new Item(type - 2, count);
74	+	} else if (it.id >= 2202 && it.id <= 2206) {
75	+	newItem = new Item(type - 37, count);
76	+	} else if (it.id == 2640) {
77	+	newItem = new Item(6132, count);
78	+	} else if (it.id == 6301) {
79	+	newItem = new Item(6300, count);
80	+	} else if (it.id == 18528) {
81	+	newItem = new Item(18408, count);
82	+	} else {
83	+	newItem = new Item(type, count);
84	+	}
85	+
86	+	newItem->incrementReferenceCounter();
87	+	}
88	+
89	+	return newItem;
90	+	}
91	+
92	+	Container* Item::CreateItemAsContainer(const uint16_t type, uint16_t size)
93	+	{
94	+	const ItemType& it = Item::items[type];
95	+	if (it.id == 0 \|\| it.group == ITEM_GROUP_DEPRECATED \|\| it.stackable \|\| it.useable \|\| it.moveable \|\| it.pickupable \|\| it.isDepot() \|\| it.isSplash() \|\| it.isDoor()) {
96	+	return nullptr;
97	+	}
98	+
99	+	Container* newItem = new Container(type, size);
100	+	newItem->incrementReferenceCounter();
101	+	return newItem;
102	+	}
103	+
104	+	Item* Item::CreateItem(PropStream& propStream)
105	+	{
106	+	uint16_t id;
107	+	if (!propStream.read<uint16_t>(id)) {
108	+	return nullptr;
109	+	}
110	+
111	+	switch (id) {
112	+	case ITEM_FIREFIELD_PVP_FULL:
113	+	id = ITEM_FIREFIELD_PERSISTENT_FULL;
114	+	break;
115	+
116	+	case ITEM_FIREFIELD_PVP_MEDIUM:
117	+	id = ITEM_FIREFIELD_PERSISTENT_MEDIUM;
118	+	break;
119	+
120	+	case ITEM_FIREFIELD_PVP_SMALL:
121	+	id = ITEM_FIREFIELD_PERSISTENT_SMALL;
122	+	break;
123	+
124	+	case ITEM_ENERGYFIELD_PVP:
125	+	id = ITEM_ENERGYFIELD_PERSISTENT;
126	+	break;
127	+
128	+	case ITEM_POISONFIELD_PVP:
129	+	id = ITEM_POISONFIELD_PERSISTENT;
130	+	break;
131	+
132	+	case ITEM_MAGICWALL:
133	+	id = ITEM_MAGICWALL_PERSISTENT;
134	+	break;
135	+
136	+	case ITEM_WILDGROWTH:
137	+	id = ITEM_WILDGROWTH_PERSISTENT;
138	+	break;
139	+
140	+	default:
141	+	break;
142	+	}
143	+
144	+	return Item::CreateItem(id, 0);
145	+	}
146	+
147	+	Item::Item(const uint16_t type, uint16_t count /= 0/) :
148	+	id(type)
149	+	{
150	+	const ItemType& it = items[id];
151	+
152	+	if (it.isFluidContainer() \|\| it.isSplash()) {
153	+	setFluidType(count);
154	+	} else if (it.stackable) {
155	+	if (count != 0) {
156	+	setItemCount(count);
157	+	} else if (it.charges != 0) {
158	+	setItemCount(it.charges);
159	+	}
160	+	} else if (it.charges != 0) {
161	+	if (count != 0) {
162	+	setCharges(count);
163	+	} else {
164	+	setCharges(it.charges);
165	+	}
166	+	}
167	+
168	+	setDefaultDuration();
169	+	}
170	+
171	+	Item::Item(const Item& i) :
172	+	Thing(), id(i.id), count(i.count), loadedFromMap(i.loadedFromMap)
173	+	{
174	+	if (i.attributes) {
175	+	attributes.reset(new ItemAttributes(*i.attributes));
176	+	}
177	+	}
178	+
179	+	Item* Item::clone() const
180	+	{
181	+	Item* item = Item::CreateItem(id, count);
182	+	if (attributes) {
183	+	item->attributes.reset(new ItemAttributes(*attributes));
184	+	if (item->getDuration() > 0) {
185	+	item->incrementReferenceCounter();
186	+	item->setDecaying(DECAYING_TRUE);
187	+	g_game.toDecayItems.push_front(item);
188	+	}
189	+	}
190	+	return item;
191	+	}
192	+
193	+	bool Item::equals(const Item* otherItem) const
194	+	{
195	+	if (!otherItem \|\| id != otherItem->id) {
196	+	return false;
197	+	}
198	+
199	+	const auto& otherAttributes = otherItem->attributes;
200	+	if (!attributes) {
201	+	return !otherAttributes \|\| (otherAttributes->attributeBits == 0);
202	+	} else if (!otherAttributes) {
203	+	return (attributes->attributeBits == 0);
204	+	}
205	+
206	+	if (attributes->attributeBits != otherAttributes->attributeBits) {
207	+	return false;
208	+	}
209	+
210	+	const auto& attributeList = attributes->attributes;
211	+	const auto& otherAttributeList = otherAttributes->attributes;
212	+	for (const auto& attribute : attributeList) {
213	+	if (ItemAttributes::isStrAttrType(attribute.type)) {
214	+	for (const auto& otherAttribute : otherAttributeList) {
215	+	if (attribute.type == otherAttribute.type && attribute.value.string != otherAttribute.value.string) {
216	+	return false;
217	+	}
218	+	}
219	+	} else {
220	+	for (const auto& otherAttribute : otherAttributeList) {
221	+	if (attribute.type == otherAttribute.type && attribute.value.integer != otherAttribute.value.integer) {
222	+	return false;
223	+	}
224	+	}
225	+	}
226	+	}
227	+	return true;
228	+	}
229	+
230	+	void Item::setDefaultSubtype()
231	+	{
232	+	const ItemType& it = items[id];
233	+
234	+	setItemCount(1);
235	+
236	+	if (it.charges != 0) {
237	+	if (it.stackable) {
238	+	setItemCount(it.charges);
239	+	} else {
240	+	setCharges(it.charges);
241	+	}
242	+	}
243	+	}
244	+
245	+	void Item::onRemoved()
246	+	{
247	+	ScriptEnvironment::removeTempItem(this);
248	+
249	+	if (hasAttribute(ITEM_ATTRIBUTE_UNIQUEID)) {
250	+	g_game.removeUniqueItem(getUniqueId());
251	+	}
252	+	}
253	+
254	+	void Item::setID(uint16_t newid)
255	+	{
256	+	const ItemType& prevIt = Item::items[id];
257	+	id = newid;
258	+
259	+	const ItemType& it = Item::items[newid];
260	+	uint32_t newDuration = it.decayTime * 1000;
261	+
262	+	if (newDuration == 0 && !it.stopTime && it.decayTo < 0) {
263	+	removeAttribute(ITEM_ATTRIBUTE_DECAYSTATE);
264	+	removeAttribute(ITEM_ATTRIBUTE_DURATION);
265	+	}
266	+
267	+	removeAttribute(ITEM_ATTRIBUTE_CORPSEOWNER);
268	+
269	+	if (newDuration > 0 && (!prevIt.stopTime \|\| !hasAttribute(ITEM_ATTRIBUTE_DURATION))) {
270	+	setDecaying(DECAYING_FALSE);
271	+	setDuration(newDuration);
272	+	}
273	+	}
274	+
275	+	Cylinder* Item::getTopParent()
276	+	{
277	+	Cylinder* aux = getParent();
278	+	Cylinder* prevaux = dynamic_cast<Cylinder*>(this);
279	+	if (!aux) {
280	+	return prevaux;
281	+	}
282	+
283	+	while (aux->getParent() != nullptr) {
284	+	prevaux = aux;
285	+	aux = aux->getParent();
286	+	}
287	+
288	+	if (prevaux) {
289	+	return prevaux;
290	+	}
291	+	return aux;
292	+	}
293	+
294	+	const Cylinder* Item::getTopParent() const
295	+	{
296	+	const Cylinder* aux = getParent();
297	+	const Cylinder* prevaux = dynamic_cast<const Cylinder*>(this);
298	+	if (!aux) {
299	+	return prevaux;
300	+	}
301	+
302	+	while (aux->getParent() != nullptr) {
303	+	prevaux = aux;
304	+	aux = aux->getParent();
305	+	}
306	+
307	+	if (prevaux) {
308	+	return prevaux;
309	+	}
310	+	return aux;
311	+	}
312	+
313	+	Tile* Item::getTile()
314	+	{
315	+	Cylinder* cylinder = getTopParent();
316	+	//get root cylinder
317	+	if (cylinder && cylinder->getParent()) {
318	+	cylinder = cylinder->getParent();
319	+	}
320	+	return dynamic_cast<Tile*>(cylinder);
321	+	}
322	+
323	+	const Tile* Item::getTile() const
324	+	{
325	+	const Cylinder* cylinder = getTopParent();
326	+	//get root cylinder
327	+	if (cylinder && cylinder->getParent()) {
328	+	cylinder = cylinder->getParent();
329	+	}
330	+	return dynamic_cast<const Tile*>(cylinder);
331	+	}
332	+
333	+	uint16_t Item::getSubType() const
334	+	{
335	+	const ItemType& it = items[id];
336	+	if (it.isFluidContainer() \|\| it.isSplash()) {
337	+	return getFluidType();
338	+	} else if (it.stackable) {
339	+	return count;
340	+	} else if (it.charges != 0) {
341	+	return getCharges();
342	+	}
343	+	return count;
344	+	}
345	+
346	+	Player* Item::getHoldingPlayer() const
347	+	{
348	+	Cylinder* p = getParent();
349	+	while (p) {
350	+	if (p->getCreature()) {
351	+	return p->getCreature()->getPlayer();
352	+	}
353	+
354	+	p = p->getParent();
355	+	}
356	+	return nullptr;
357	+	}
358	+
359	+	void Item::setSubType(uint16_t n)
360	+	{
361	+	const ItemType& it = items[id];
362	+	if (it.isFluidContainer() \|\| it.isSplash()) {
363	+	setFluidType(n);
364	+	} else if (it.stackable) {
365	+	setItemCount(n);
366	+	} else if (it.charges != 0) {
367	+	setCharges(n);
368	+	} else {
369	+	setItemCount(n);
370	+	}
371	+	}
372	+
373	+	Attr_ReadValue Item::readAttr(AttrTypes_t attr, PropStream& propStream)
374	+	{
375	+	switch (attr) {
376	+	case ATTR_COUNT:
377	+	case ATTR_RUNE_CHARGES: {
378	+	uint8_t count;
379	+	if (!propStream.read<uint8_t>(count)) {
380	+	return ATTR_READ_ERROR;
381	+	}
382	+
383	+	setSubType(count);
384	+	break;
385	+	}
386	+
387	+	case ATTR_ACTION_ID: {
388	+	uint16_t actionId;
389	+	if (!propStream.read<uint16_t>(actionId)) {
390	+	return ATTR_READ_ERROR;
391	+	}
392	+
393	+	setActionId(actionId);
394	+	break;
395	+	}
396	+
397	+	case ATTR_UNIQUE_ID: {
398	+	uint16_t uniqueId;
399	+	if (!propStream.read<uint16_t>(uniqueId)) {
400	+	return ATTR_READ_ERROR;
401	+	}
402	+
403	+	setUniqueId(uniqueId);
404	+	break;
405	+	}
406	+
407	+	case ATTR_TEXT: {
408	+	std::string text;
409	+	if (!propStream.readString(text)) {
410	+	return ATTR_READ_ERROR;
411	+	}
412	+
413	+	setText(text);
414	+	break;
415	+	}
416	+
417	+	case ATTR_WRITTENDATE: {
418	+	uint32_t writtenDate;
419	+	if (!propStream.read<uint32_t>(writtenDate)) {
420	+	return ATTR_READ_ERROR;
421	+	}
422	+
423	+	setDate(writtenDate);
424	+	break;
425	+	}
426	+
427	+	case ATTR_WRITTENBY: {
428	+	std::string writer;
429	+	if (!propStream.readString(writer)) {
430	+	return ATTR_READ_ERROR;
431	+	}
432	+
433	+	setWriter(writer);
434	+	break;
435	+	}
436	+
437	+	case ATTR_DESC: {
438	+	std::string text;
439	+	if (!propStream.readString(text)) {
440	+	return ATTR_READ_ERROR;
441	+	}
442	+
443	+	setSpecialDescription(text);
444	+	break;
445	+	}
446	+
447	+	case ATTR_CHARGES: {
448	+	uint16_t charges;
449	+	if (!propStream.read<uint16_t>(charges)) {
450	+	return ATTR_READ_ERROR;
451	+	}
452	+
453	+	setSubType(charges);
454	+	break;
455	+	}
456	+
457	+	case ATTR_DURATION: {
458	+	int32_t duration;
459	+	if (!propStream.read<int32_t>(duration)) {
460	+	return ATTR_READ_ERROR;
461	+	}
462	+
463	+	setDuration(std::max<int32_t>(0, duration));
464	+	break;
465	+	}
466	+
467	+	case ATTR_DECAYING_STATE: {
468	+	uint8_t state;
469	+	if (!propStream.read<uint8_t>(state)) {
470	+	return ATTR_READ_ERROR;
471	+	}
472	+
473	+	if (state != DECAYING_FALSE) {
474	+	setDecaying(DECAYING_PENDING);
475	+	}
476	+	break;
477	+	}
478	+
479	+	case ATTR_NAME: {
480	+	std::string name;
481	+	if (!propStream.readString(name)) {
482	+	return ATTR_READ_ERROR;
483	+	}
484	+
485	+	setStrAttr(ITEM_ATTRIBUTE_NAME, name);
486	+	break;
487	+	}
488	+
489	+	case ATTR_ARTICLE: {
490	+	std::string article;
491	+	if (!propStream.readString(article)) {
492	+	return ATTR_READ_ERROR;
493	+	}
494	+
495	+	setStrAttr(ITEM_ATTRIBUTE_ARTICLE, article);
496	+	break;
497	+	}
498	+
499	+	case ATTR_PLURALNAME: {
500	+	std::string pluralName;
501	+	if (!propStream.readString(pluralName)) {
502	+	return ATTR_READ_ERROR;
503	+	}
504	+
505	+	setStrAttr(ITEM_ATTRIBUTE_PLURALNAME, pluralName);
506	+	break;
507	+	}
508	+
509	+	case ATTR_WEIGHT: {
510	+	uint32_t weight;
511	+	if (!propStream.read<uint32_t>(weight)) {
512	+	return ATTR_READ_ERROR;
513	+	}
514	+
515	+	setIntAttr(ITEM_ATTRIBUTE_WEIGHT, weight);
516	+	break;
517	+	}
518	+
519	+	case ATTR_ATTACK: {
520	+	int32_t attack;
521	+	if (!propStream.read<int32_t>(attack)) {
522	+	return ATTR_READ_ERROR;
523	+	}
524	+
525	+	setIntAttr(ITEM_ATTRIBUTE_ATTACK, attack);
526	+	break;
527	+	}
528	+
529	+	case ATTR_DEFENSE: {
530	+	int32_t defense;
531	+	if (!propStream.read<int32_t>(defense)) {
532	+	return ATTR_READ_ERROR;
533	+	}
534	+
535	+	setIntAttr(ITEM_ATTRIBUTE_DEFENSE, defense);
536	+	break;
537	+	}
538	+
539	+	case ATTR_EXTRADEFENSE: {
540	+	int32_t extraDefense;
541	+	if (!propStream.read<int32_t>(extraDefense)) {
542	+	return ATTR_READ_ERROR;
543	+	}
544	+
545	+	setIntAttr(ITEM_ATTRIBUTE_EXTRADEFENSE, extraDefense);
546	+	break;
547	+	}
548	+
549	+	case ATTR_ARMOR: {
550	+	int32_t armor;
551	+	if (!propStream.read<int32_t>(armor)) {
552	+	return ATTR_READ_ERROR;
553	+	}
554	+
555	+	setIntAttr(ITEM_ATTRIBUTE_ARMOR, armor);
556	+	break;
557	+	}
558	+
559	+	case ATTR_HITCHANCE: {
560	+	int8_t hitChance;
561	+	if (!propStream.read<int8_t>(hitChance)) {
562	+	return ATTR_READ_ERROR;
563	+	}
564	+
565	+	setIntAttr(ITEM_ATTRIBUTE_HITCHANCE, hitChance);
566	+	break;
567	+	}
568	+
569	+	case ATTR_SHOOTRANGE: {
570	+	uint8_t shootRange;
571	+	if (!propStream.read<uint8_t>(shootRange)) {
572	+	return ATTR_READ_ERROR;
573	+	}
574	+
575	+	setIntAttr(ITEM_ATTRIBUTE_SHOOTRANGE, shootRange);
576	+	break;
577	+	}
578	+
579	+	case ATTR_DECAYTO: {
580	+	int32_t decayTo;
581	+	if (!propStream.read<int32_t>(decayTo)) {
582	+	return ATTR_READ_ERROR;
583	+	}
584	+
585	+	setIntAttr(ITEM_ATTRIBUTE_DECAYTO, decayTo);
586	+	break;
587	+	}
588	+
589	+	case ATTR_WRAPID: {
590	+	uint16_t wrapId;
591	+	if (!propStream.read<uint16_t>(wrapId)) {
592	+	return ATTR_READ_ERROR;
593	+	}
594	+
595	+	setIntAttr(ITEM_ATTRIBUTE_WRAPID, wrapId);
596	+	break;
597	+	}
598	+
599	+	//these should be handled through derived classes
600	+	//If these are called then something has changed in the items.xml since the map was saved
601	+	//just read the values
602	+
603	+	//Depot class
604	+	case ATTR_DEPOT_ID: {
605	+	if (!propStream.skip(2)) {
606	+	return ATTR_READ_ERROR;
607	+	}
608	+	break;
609	+	}
610	+
611	+	//Door class
612	+	case ATTR_HOUSEDOORID: {
613	+	if (!propStream.skip(1)) {
614	+	return ATTR_READ_ERROR;
615	+	}
616	+	break;
617	+	}
618	+
619	+	//Bed class
620	+	case ATTR_SLEEPERGUID: {
621	+	if (!propStream.skip(4)) {
622	+	return ATTR_READ_ERROR;
623	+	}
624	+	break;
625	+	}
626	+
627	+	case ATTR_SLEEPSTART: {
628	+	if (!propStream.skip(4)) {
629	+	return ATTR_READ_ERROR;
630	+	}
631	+	break;
632	+	}
633	+
634	+	//Teleport class
635	+	case ATTR_TELE_DEST: {
636	+	if (!propStream.skip(5)) {
637	+	return ATTR_READ_ERROR;
638	+	}
639	+	break;
640	+	}
641	+
642	+	//Container class
643	+	case ATTR_CONTAINER_ITEMS: {
644	+	return ATTR_READ_ERROR;
645	+	}
646	+
647	+	case ATTR_CUSTOM_ATTRIBUTES: {
648	+	uint64_t size;
649	+	if (!propStream.read<uint64_t>(size)) {
650	+	return ATTR_READ_ERROR;
651	+	}
652	+
653	+	for (uint64_t i = 0; i < size; i++) {
654	+	// Unserialize key type and value
655	+	std::string key;
656	+	if (!propStream.readString(key)) {
657	+	return ATTR_READ_ERROR;
658	+	};
659	+
660	+	// Unserialize value type and value
661	+	ItemAttributes::CustomAttribute val;
662	+	if (!val.unserialize(propStream)) {
663	+	return ATTR_READ_ERROR;
664	+	}
665	+
666	+	setCustomAttribute(key, val);
667	+	}
668	+	break;
669	+	}
670	+
671	+	default:
672	+	return ATTR_READ_ERROR;
673	+	}
674	+
675	+	return ATTR_READ_CONTINUE;
676	+	}
677	+
678	+	bool Item::unserializeAttr(PropStream& propStream)
679	+	{
680	+	uint8_t attr_type;
681	+	while (propStream.read<uint8_t>(attr_type) && attr_type != 0) {
682	+	Attr_ReadValue ret = readAttr(static_cast<AttrTypes_t>(attr_type), propStream);
683	+	if (ret == ATTR_READ_ERROR) {
684	+	return false;
685	+	} else if (ret == ATTR_READ_END) {
686	+	return true;
687	+	}
688	+	}
689	+	return true;
690	+	}
691	+
692	+	bool Item::unserializeItemNode(OTB::Loader&, const OTB::Node&, PropStream& propStream)
693	+	{
694	+	return unserializeAttr(propStream);
695	+	}
696	+
697	+	void Item::serializeAttr(PropWriteStream& propWriteStream) const
698	+	{
699	+	const ItemType& it = items[id];
700	+	if (it.stackable \|\| it.isFluidContainer() \|\| it.isSplash()) {
701	+	propWriteStream.write<uint8_t>(ATTR_COUNT);
702	+	propWriteStream.write<uint8_t>(getSubType());
703	+	}
704	+
705	+	uint16_t charges = getCharges();
706	+	if (charges != 0) {
707	+	propWriteStream.write<uint8_t>(ATTR_CHARGES);
708	+	propWriteStream.write<uint16_t>(charges);
709	+	}
710	+
711	+	if (it.moveable) {
712	+	uint16_t actionId = getActionId();
713	+	if (actionId != 0) {
714	+	propWriteStream.write<uint8_t>(ATTR_ACTION_ID);
715	+	propWriteStream.write<uint16_t>(actionId);
716	+	}
717	+	}
718	+
719	+	const std::string& text = getText();
720	+	if (!text.empty()) {
721	+	propWriteStream.write<uint8_t>(ATTR_TEXT);
722	+	propWriteStream.writeString(text);
723	+	}
724	+
725	+	const time_t writtenDate = getDate();
726	+	if (writtenDate != 0) {
727	+	propWriteStream.write<uint8_t>(ATTR_WRITTENDATE);
728	+	propWriteStream.write<uint32_t>(writtenDate);
729	+	}
730	+
731	+	const std::string& writer = getWriter();
732	+	if (!writer.empty()) {
733	+	propWriteStream.write<uint8_t>(ATTR_WRITTENBY);
734	+	propWriteStream.writeString(writer);
735	+	}
736	+
737	+	const std::string& specialDesc = getSpecialDescription();
738	+	if (!specialDesc.empty()) {
739	+	propWriteStream.write<uint8_t>(ATTR_DESC);
740	+	propWriteStream.writeString(specialDesc);
741	+	}
742	+
743	+	if (hasAttribute(ITEM_ATTRIBUTE_DURATION)) {
744	+	propWriteStream.write<uint8_t>(ATTR_DURATION);
745	+	propWriteStream.write<uint32_t>(getIntAttr(ITEM_ATTRIBUTE_DURATION));
746	+	}
747	+
748	+	ItemDecayState_t decayState = getDecaying();
749	+	if (decayState == DECAYING_TRUE \|\| decayState == DECAYING_PENDING) {
750	+	propWriteStream.write<uint8_t>(ATTR_DECAYING_STATE);
751	+	propWriteStream.write<uint8_t>(decayState);
752	+	}
753	+
754	+	if (hasAttribute(ITEM_ATTRIBUTE_NAME)) {
755	+	propWriteStream.write<uint8_t>(ATTR_NAME);
756	+	propWriteStream.writeString(getStrAttr(ITEM_ATTRIBUTE_NAME));
757	+	}
758	+
759	+	if (hasAttribute(ITEM_ATTRIBUTE_ARTICLE)) {
760	+	propWriteStream.write<uint8_t>(ATTR_ARTICLE);
761	+	propWriteStream.writeString(getStrAttr(ITEM_ATTRIBUTE_ARTICLE));
762	+	}
763	+
764	+	if (hasAttribute(ITEM_ATTRIBUTE_PLURALNAME)) {
765	+	propWriteStream.write<uint8_t>(ATTR_PLURALNAME);
766	+	propWriteStream.writeString(getStrAttr(ITEM_ATTRIBUTE_PLURALNAME));
767	+	}
768	+
769	+	if (hasAttribute(ITEM_ATTRIBUTE_WEIGHT)) {
770	+	propWriteStream.write<uint8_t>(ATTR_WEIGHT);
771	+	propWriteStream.write<uint32_t>(getIntAttr(ITEM_ATTRIBUTE_WEIGHT));
772	+	}
773	+
774	+	if (hasAttribute(ITEM_ATTRIBUTE_ATTACK)) {
775	+	propWriteStream.write<uint8_t>(ATTR_ATTACK);
776	+	propWriteStream.write<int32_t>(getIntAttr(ITEM_ATTRIBUTE_ATTACK));
777	+	}
778	+
779	+	if (hasAttribute(ITEM_ATTRIBUTE_DEFENSE)) {
780	+	propWriteStream.write<uint8_t>(ATTR_DEFENSE);
781	+	propWriteStream.write<int32_t>(getIntAttr(ITEM_ATTRIBUTE_DEFENSE));
782	+	}
783	+
784	+	if (hasAttribute(ITEM_ATTRIBUTE_EXTRADEFENSE)) {
785	+	propWriteStream.write<uint8_t>(ATTR_EXTRADEFENSE);
786	+	propWriteStream.write<int32_t>(getIntAttr(ITEM_ATTRIBUTE_EXTRADEFENSE));
787	+	}
788	+
789	+	if (hasAttribute(ITEM_ATTRIBUTE_ARMOR)) {
790	+	propWriteStream.write<uint8_t>(ATTR_ARMOR);
791	+	propWriteStream.write<int32_t>(getIntAttr(ITEM_ATTRIBUTE_ARMOR));
792	+	}
793	+
794	+	if (hasAttribute(ITEM_ATTRIBUTE_HITCHANCE)) {
795	+	propWriteStream.write<uint8_t>(ATTR_HITCHANCE);
796	+	propWriteStream.write<int8_t>(getIntAttr(ITEM_ATTRIBUTE_HITCHANCE));
797	+	}
798	+
799	+	if (hasAttribute(ITEM_ATTRIBUTE_SHOOTRANGE)) {
800	+	propWriteStream.write<uint8_t>(ATTR_SHOOTRANGE);
801	+	propWriteStream.write<uint8_t>(getIntAttr(ITEM_ATTRIBUTE_SHOOTRANGE));
802	+	}
803	+
804	+	if (hasAttribute(ITEM_ATTRIBUTE_DECAYTO)) {
805	+	propWriteStream.write<uint8_t>(ATTR_DECAYTO);
806	+	propWriteStream.write<int32_t>(getIntAttr(ITEM_ATTRIBUTE_DECAYTO));
807	+	}
808	+
809	+	if (hasAttribute(ITEM_ATTRIBUTE_WRAPID)) {
810	+	propWriteStream.write<uint8_t>(ATTR_WRAPID);
811	+	propWriteStream.write<uint16_t>(getIntAttr(ITEM_ATTRIBUTE_WRAPID));
812	+	}
813	+
814	+	if (hasAttribute(ITEM_ATTRIBUTE_CUSTOM)) {
815	+	const ItemAttributes::CustomAttributeMap* customAttrMap = attributes->getCustomAttributeMap();
816	+	propWriteStream.write<uint8_t>(ATTR_CUSTOM_ATTRIBUTES);
817	+	propWriteStream.write<uint64_t>(static_cast<uint64_t>(customAttrMap->size()));
818	+	for (const auto &entry : *customAttrMap) {
819	+	// Serializing key type and value
820	+	propWriteStream.writeString(entry.first);
821	+
822	+	// Serializing value type and value
823	+	entry.second.serialize(propWriteStream);
824	+	}
825	+	}
826	+	}
827	+
828	+	bool Item::hasProperty(ITEMPROPERTY prop) const
829	+	{
830	+	const ItemType& it = items[id];
831	+	switch (prop) {
832	+	case CONST_PROP_BLOCKSOLID: return it.blockSolid;
833	+	case CONST_PROP_MOVEABLE: return it.moveable && !hasAttribute(ITEM_ATTRIBUTE_UNIQUEID);
834	+	case CONST_PROP_HASHEIGHT: return it.hasHeight;
835	+	case CONST_PROP_BLOCKPROJECTILE: return it.blockProjectile;
836	+	case CONST_PROP_BLOCKPATH: return it.blockPathFind;
837	+	case CONST_PROP_ISVERTICAL: return it.isVertical;
838	+	case CONST_PROP_ISHORIZONTAL: return it.isHorizontal;
839	+	case CONST_PROP_IMMOVABLEBLOCKSOLID: return it.blockSolid && (!it.moveable \|\| hasAttribute(ITEM_ATTRIBUTE_UNIQUEID));
840	+	case CONST_PROP_IMMOVABLEBLOCKPATH: return it.blockPathFind && (!it.moveable \|\| hasAttribute(ITEM_ATTRIBUTE_UNIQUEID));
841	+	case CONST_PROP_IMMOVABLENOFIELDBLOCKPATH: return !it.isMagicField() && it.blockPathFind && (!it.moveable \|\| hasAttribute(ITEM_ATTRIBUTE_UNIQUEID));
842	+	case CONST_PROP_NOFIELDBLOCKPATH: return !it.isMagicField() && it.blockPathFind;
843	+	case CONST_PROP_SUPPORTHANGABLE: return it.isHorizontal \|\| it.isVertical;
844	+	default: return false;
845	+	}
846	+	}
847	+
848	+	uint32_t Item::getWeight() const
849	+	{
850	+	uint32_t weight = getBaseWeight();
851	+	if (isStackable()) {
852	+	return weight * std::max<uint32_t>(1, getItemCount());
853	+	}
854	+	return weight;
855	+	}
856	+
857	+	std::string Item::getDescription(const ItemType& it, int32_t lookDistance,
858	+	const Item* item /= nullptr/, int32_t subType /= -1/, bool addArticle /= true/)
859	+	{
860	+	const std::string* text = nullptr;
861	+
862	+	std::ostringstream s;
863	+	s << getNameDescription(it, item, subType, addArticle);
864	+
865	+	if (item) {
866	+	subType = item->getSubType();
867	+	}
868	+
869	+	if (it.isRune()) {
870	+	if (it.runeLevel > 0 \|\| it.runeMagLevel > 0) {
871	+	if (RuneSpell* rune = g_spells->getRuneSpell(it.id)) {
872	+	int32_t tmpSubType = subType;
873	+	if (item) {
874	+	tmpSubType = item->getSubType();
875	+	}
876	+	s << ". " << (it.stackable && tmpSubType > 1 ? "They" : "It") << " can only be used by ";
877	+
878	+	const VocSpellMap& vocMap = rune->getVocMap();
879	+	std::vector<Vocation*> showVocMap;
880	+
881	+	// vocations are usually listed with the unpromoted and promoted version, the latter being
882	+	// hidden from description, so `total / 2` is most likely the amount of vocations to be shown.
883	+	showVocMap.reserve(vocMap.size() / 2);
884	+	for (const auto& voc : vocMap) {
885	+	if (voc.second) {
886	+	showVocMap.push_back(g_vocations.getVocation(voc.first));
887	+	}
888	+	}
889	+
890	+	if (!showVocMap.empty()) {
891	+	auto vocIt = showVocMap.begin(), vocLast = (showVocMap.end() - 1);
892	+	while (vocIt != vocLast) {
893	+	s << asLowerCaseString((*vocIt)->getVocName()) << "s";
894	+	if (++vocIt == vocLast) {
895	+	s << " and ";
896	+	} else {
897	+	s << ", ";
898	+	}
899	+	}
900	+	s << asLowerCaseString((*vocLast)->getVocName()) << "s";
901	+	} else {
902	+	s << "players";
903	+	}
904	+
905	+	s << " with";
906	+
907	+	if (it.runeLevel > 0) {
908	+	s << " level " << it.runeLevel;
909	+	}
910	+
911	+	if (it.runeMagLevel > 0) {
912	+	if (it.runeLevel > 0) {
913	+	s << " and";
914	+	}
915	+
916	+	s << " magic level " << it.runeMagLevel;
917	+	}
918	+
919	+	s << " or higher";
920	+	}
921	+	}
922	+	} else if (it.weaponType != WEAPON_NONE) {
923	+	bool begin = true;
924	+	if (it.weaponType == WEAPON_DISTANCE && it.ammoType != AMMO_NONE) {
925	+	s << " (Range:" << static_cast<uint16_t>(item ? item->getShootRange() : it.shootRange);
926	+
927	+	int32_t attack;
928	+	int8_t hitChance;
929	+	if (item) {
930	+	attack = item->getAttack();
931	+	hitChance = item->getHitChance();
932	+	} else {
933	+	attack = it.attack;
934	+	hitChance = it.hitChance;
935	+	}
936	+
937	+	if (attack != 0) {
938	+	s << ", Atk" << std::showpos << attack << std::noshowpos;
939	+	}
940	+
941	+	if (hitChance != 0) {
942	+	s << ", Hit%" << std::showpos << static_cast<int16_t>(hitChance) << std::noshowpos;
943	+	}
944	+
945	+	begin = false;
946	+	} else if (it.weaponType != WEAPON_AMMO) {
947	+
948	+	int32_t attack, defense, extraDefense;
949	+	if (item) {
950	+	attack = item->getAttack();
951	+	defense = item->getDefense();
952	+	extraDefense = item->getExtraDefense();
953	+	} else {
954	+	attack = it.attack;
955	+	defense = it.defense;
956	+	extraDefense = it.extraDefense;
957	+	}
958	+
959	+	if (attack != 0) {
960	+	begin = false;
961	+	s << " (Atk:" << attack;
962	+
963	+	if (it.abilities && it.abilities->elementType != COMBAT_NONE && it.abilities->elementDamage != 0) {
964	+	s << " physical + " << it.abilities->elementDamage << ' ' << getCombatName(it.abilities->elementType);
965	+	}
966	+	}
967	+
968	+	if (defense != 0 \|\| extraDefense != 0) {
969	+	if (begin) {
970	+	begin = false;
971	+	s << " (";
972	+	} else {
973	+	s << ", ";
974	+	}
975	+
976	+	s << "Def:" << defense;
977	+	if (extraDefense != 0) {
978	+	s << ' ' << std::showpos << extraDefense << std::noshowpos;
979	+	}
980	+	}
981	+	}
982	+
983	+	if (it.abilities) {
984	+	for (uint8_t i = SKILL_FIRST; i <= SKILL_LAST; i++) {
985	+	if (!it.abilities->skills[i]) {
986	+	continue;
987	+	}
988	+
989	+	if (begin) {
990	+	begin = false;
991	+	s << " (";
992	+	} else {
993	+	s << ", ";
994	+	}
995	+
996	+	s << getSkillName(i) << ' ' << std::showpos << it.abilities->skills[i] << std::noshowpos;
997	+	}
998	+
999	+	for (uint8_t i = SPECIALSKILL_FIRST; i <= SPECIALSKILL_LAST; i++) {
1000	+	if (!it.abilities->specialSkills[i]) {
1001	+	continue;
1002	+	}
1003	+
1004	+	if (begin) {
1005	+	begin = false;
1006	+	s << " (";
1007	+	} else {
1008	+	s << ", ";
1009	+	}
1010	+
1011	+	s << getSpecialSkillName(i) << ' ' << std::showpos << it.abilities->specialSkills[i] << '%' << std::noshowpos;
1012	+	}
1013	+
1014	+	if (it.abilities->stats[STAT_MAGICPOINTS]) {
1015	+	if (begin) {
1016	+	begin = false;
1017	+	s << " (";
1018	+	} else {
1019	+	s << ", ";
1020	+	}
1021	+
1022	+	s << "magic level " << std::showpos << it.abilities->stats[STAT_MAGICPOINTS] << std::noshowpos;
1023	+	}
1024	+
1025	+	int16_t show = it.abilities->absorbPercent[0];
1026	+	if (show != 0) {
1027	+	for (size_t i = 1; i < COMBAT_COUNT; ++i) {
1028	+	if (it.abilities->absorbPercent[i] != show) {
1029	+	show = 0;
1030	+	break;
1031	+	}
1032	+	}
1033	+	}
1034	+
1035	+	if (show == 0) {
1036	+	bool tmp = true;
1037	+
1038	+	for (size_t i = 0; i < COMBAT_COUNT; ++i) {
1039	+	if (it.abilities->absorbPercent[i] == 0) {
1040	+	continue;
1041	+	}
1042	+
1043	+	if (tmp) {
1044	+	tmp = false;
1045	+
1046	+	if (begin) {
1047	+	begin = false;
1048	+	s << " (";
1049	+	} else {
1050	+	s << ", ";
1051	+	}
1052	+
1053	+	s << "protection ";
1054	+	} else {
1055	+	s << ", ";
1056	+	}
1057	+
1058	+	s << getCombatName(indexToCombatType(i)) << ' ' << std::showpos << it.abilities->absorbPercent[i] << std::noshowpos << '%';
1059	+	}
1060	+	} else {
1061	+	if (begin) {
1062	+	begin = false;
1063	+	s << " (";
1064	+	} else {
1065	+	s << ", ";
1066	+	}
1067	+
1068	+	s << "protection all " << std::showpos << show << std::noshowpos << '%';
1069	+	}
1070	+
1071	+	show = it.abilities->fieldAbsorbPercent[0];
1072	+	if (show != 0) {
1073	+	for (size_t i = 1; i < COMBAT_COUNT; ++i) {
1074	+	if (it.abilities->absorbPercent[i] != show) {
1075	+	show = 0;
1076	+	break;
1077	+	}
1078	+	}
1079	+	}
1080	+
1081	+	if (show == 0) {
1082	+	bool tmp = true;
1083	+
1084	+	for (size_t i = 0; i < COMBAT_COUNT; ++i) {
1085	+	if (it.abilities->fieldAbsorbPercent[i] == 0) {
1086	+	continue;
1087	+	}
1088	+
1089	+	if (tmp) {
1090	+	tmp = false;
1091	+
1092	+	if (begin) {
1093	+	begin = false;
1094	+	s << " (";
1095	+	} else {
1096	+	s << ", ";
1097	+	}
1098	+
1099	+	s << "protection ";
1100	+	} else {
1101	+	s << ", ";
1102	+	}
1103	+
1104	+	s << getCombatName(indexToCombatType(i)) << " field " << std::showpos << it.abilities->fieldAbsorbPercent[i] << std::noshowpos << '%';
1105	+	}
1106	+	} else {
1107	+	if (begin) {
1108	+	begin = false;
1109	+	s << " (";
1110	+	} else {
1111	+	s << ", ";
1112	+	}
1113	+
1114	+	s << "protection all fields " << std::showpos << show << std::noshowpos << '%';
1115	+	}
1116	+
1117	+	if (it.abilities->speed) {
1118	+	if (begin) {
1119	+	begin = false;
1120	+	s << " (";
1121	+	} else {
1122	+	s << ", ";
1123	+	}
1124	+
1125	+	s << "speed " << std::showpos << (it.abilities->speed >> 1) << std::noshowpos;
1126	+	}
1127	+	}
1128	+
1129	+	if (!begin) {
1130	+	s << ')';
1131	+	}
1132	+	} else if (it.armor != 0 \|\| (item && item->getArmor() != 0) \|\| it.showAttributes) {
1133	+	bool begin = true;
1134	+
1135	+	int32_t armor = (item ? item->getArmor() : it.armor);
1136	+	if (armor != 0) {
1137	+	s << " (Arm:" << armor;
1138	+	begin = false;
1139	+	}
1140	+
1141	+	if (it.abilities) {
1142	+	for (uint8_t i = SKILL_FIRST; i <= SKILL_LAST; i++) {
1143	+	if (!it.abilities->skills[i]) {
1144	+	continue;
1145	+	}
1146	+
1147	+	if (begin) {
1148	+	begin = false;
1149	+	s << " (";
1150	+	} else {
1151	+	s << ", ";
1152	+	}
1153	+
1154	+	s << getSkillName(i) << ' ' << std::showpos << it.abilities->skills[i] << std::noshowpos;
1155	+	}
1156	+
1157	+	if (it.abilities->stats[STAT_MAGICPOINTS]) {
1158	+	if (begin) {
1159	+	begin = false;
1160	+	s << " (";
1161	+	} else {
1162	+	s << ", ";
1163	+	}
1164	+
1165	+	s << "magic level " << std::showpos << it.abilities->stats[STAT_MAGICPOINTS] << std::noshowpos;
1166	+	}
1167	+
1168	+	int16_t show = it.abilities->absorbPercent[0];
1169	+	if (show != 0) {
1170	+	for (size_t i = 1; i < COMBAT_COUNT; ++i) {
1171	+	if (it.abilities->absorbPercent[i] != show) {
1172	+	show = 0;
1173	+	break;
1174	+	}
1175	+	}
1176	+	}
1177	+
1178	+	if (!show) {
1179	+	bool protectionBegin = true;
1180	+	for (size_t i = 0; i < COMBAT_COUNT; ++i) {
1181	+	if (it.abilities->absorbPercent[i] == 0) {
1182	+	continue;
1183	+	}
1184	+
1185	+	if (protectionBegin) {
1186	+	protectionBegin = false;
1187	+
1188	+	if (begin) {
1189	+	begin = false;
1190	+	s << " (";
1191	+	} else {
1192	+	s << ", ";
1193	+	}
1194	+
1195	+	s << "protection ";
1196	+	} else {
1197	+	s << ", ";
1198	+	}
1199	+
1200	+	s << getCombatName(indexToCombatType(i)) << ' ' << std::showpos << it.abilities->absorbPercent[i] << std::noshowpos << '%';
1201	+	}
1202	+	} else {
1203	+	if (begin) {
1204	+	begin = false;
1205	+	s << " (";
1206	+	} else {
1207	+	s << ", ";
1208	+	}
1209	+
1210	+	s << "protection all " << std::showpos << show << std::noshowpos << '%';
1211	+	}
1212	+
1213	+	show = it.abilities->fieldAbsorbPercent[0];
1214	+	if (show != 0) {
1215	+	for (size_t i = 1; i < COMBAT_COUNT; ++i) {
1216	+	if (it.abilities->absorbPercent[i] != show) {
1217	+	show = 0;
1218	+	break;
1219	+	}
1220	+	}
1221	+	}
1222	+
1223	+	if (!show) {
1224	+	bool tmp = true;
1225	+
1226	+	for (size_t i = 0; i < COMBAT_COUNT; ++i) {
1227	+	if (it.abilities->fieldAbsorbPercent[i] == 0) {
1228	+	continue;
1229	+	}
1230	+
1231	+	if (tmp) {
1232	+	tmp = false;
1233	+
1234	+	if (begin) {
1235	+	begin = false;
1236	+	s << " (";
1237	+	} else {
1238	+	s << ", ";
1239	+	}
1240	+
1241	+	s << "protection ";
1242	+	} else {
1243	+	s << ", ";
1244	+	}
1245	+
1246	+	s << getCombatName(indexToCombatType(i)) << " field " << std::showpos << it.abilities->fieldAbsorbPercent[i] << std::noshowpos << '%';
1247	+	}
1248	+	} else {
1249	+	if (begin) {
1250	+	begin = false;
1251	+	s << " (";
1252	+	} else {
1253	+	s << ", ";
1254	+	}
1255	+
1256	+	s << "protection all fields " << std::showpos << show << std::noshowpos << '%';
1257	+	}
1258	+
1259	+	if (it.abilities->speed) {
1260	+	if (begin) {
1261	+	begin = false;
1262	+	s << " (";
1263	+	} else {
1264	+	s << ", ";
1265	+	}
1266	+
1267	+	s << "speed " << std::showpos << (it.abilities->speed >> 1) << std::noshowpos;
1268	+	}
1269	+	}
1270	+
1271	+	if (!begin) {
1272	+	s << ')';
1273	+	}
1274	+	} else if (it.isContainer() \|\| (item && item->getContainer())) {
1275	+	uint32_t volume = 0;
1276	+	if (!item \|\| !item->hasAttribute(ITEM_ATTRIBUTE_UNIQUEID)) {
1277	+	if (it.isContainer()) {
1278	+	volume = it.maxItems;
1279	+	} else {
1280	+	volume = item->getContainer()->capacity();
1281	+	}
1282	+	}
1283	+
1284	+	if (volume != 0) {
1285	+	s << " (Vol:" << volume << ')';
1286	+	}
1287	+	} else {
1288	+	bool found = true;
1289	+
1290	+	if (it.abilities) {
1291	+	if (it.abilities->speed > 0) {
1292	+	s << " (speed " << std::showpos << (it.abilities->speed / 2) << std::noshowpos << ')';
1293	+	} else if (hasBitSet(CONDITION_DRUNK, it.abilities->conditionSuppressions)) {
1294	+	s << " (hard drinking)";
1295	+	} else if (it.abilities->invisible) {
1296	+	s << " (invisibility)";
1297	+	} else if (it.abilities->regeneration) {
1298	+	s << " (faster regeneration)";
1299	+	} else if (it.abilities->manaShield) {
1300	+	s << " (mana shield)";
1301	+	} else {
1302	+	found = false;
1303	+	}
1304	+	} else {
1305	+	found = false;
1306	+	}
1307	+
1308	+	if (!found) {
1309	+	if (it.isKey()) {
1310	+	s << " (Key:" << std::setfill('0') << std::setw(4) << (item ? item->getActionId() : 0) << ')';
1311	+	} else if (it.isFluidContainer()) {
1312	+	if (subType > 0) {
1313	+	const std::string& itemName = items[subType].name;
1314	+	s << " of " << (!itemName.empty() ? itemName : "unknown");
1315	+	} else {
1316	+	s << ". It is empty";
1317	+	}
1318	+	} else if (it.isSplash()) {
1319	+	s << " of ";
1320	+
1321	+	if (subType > 0 && !items[subType].name.empty()) {
1322	+	s << items[subType].name;
1323	+	} else {
1324	+	s << "unknown";
1325	+	}
1326	+	} else if (it.allowDistRead && (it.id < 7369 \|\| it.id > 7371)) {
1327	+	s << ".\n";
1328	+
1329	+	if (lookDistance <= 4) {
1330	+	if (item) {
1331	+	text = &item->getText();
1332	+	if (!text->empty()) {
1333	+	const std::string& writer = item->getWriter();
1334	+	if (!writer.empty()) {
1335	+	s << writer << " wrote";
1336	+	time_t date = item->getDate();
1337	+	if (date != 0) {
1338	+	s << " on " << formatDateShort(date);
1339	+	}
1340	+	s << ": ";
1341	+	} else {
1342	+	s << "You read: ";
1343	+	}
1344	+	s << *text;
1345	+	} else {
1346	+	s << "Nothing is written on it";
1347	+	}
1348	+	} else {
1349	+	s << "Nothing is written on it";
1350	+	}
1351	+	} else {
1352	+	s << "You are too far away to read it";
1353	+	}
1354	+	} else if (it.levelDoor != 0 && item) {
1355	+	uint16_t actionId = item->getActionId();
1356	+	if (actionId >= it.levelDoor) {
1357	+	s << " for level " << (actionId - it.levelDoor);
1358	+	}
1359	+	}
1360	+	}
1361	+	}
1362	+
1363	+	if (it.showCharges) {
1364	+	s << " that has " << subType << " charge" << (subType != 1 ? "s" : "") << " left";
1365	+	}
1366	+
1367	+	if (it.showDuration) {
1368	+	if (item && item->hasAttribute(ITEM_ATTRIBUTE_DURATION)) {
1369	+	uint32_t duration = item->getDuration() / 1000;
1370	+	s << " that will expire in ";
1371	+
1372	+	if (duration >= 86400) {
1373	+	uint16_t days = duration / 86400;
1374	+	uint16_t hours = (duration % 86400) / 3600;
1375	+	s << days << " day" << (days != 1 ? "s" : "");
1376	+
1377	+	if (hours > 0) {
1378	+	s << " and " << hours << " hour" << (hours != 1 ? "s" : "");
1379	+	}
1380	+	} else if (duration >= 3600) {
1381	+	uint16_t hours = duration / 3600;
1382	+	uint16_t minutes = (duration % 3600) / 60;
1383	+	s << hours << " hour" << (hours != 1 ? "s" : "");
1384	+
1385	+	if (minutes > 0) {
1386	+	s << " and " << minutes << " minute" << (minutes != 1 ? "s" : "");
1387	+	}
1388	+	} else if (duration >= 60) {
1389	+	uint16_t minutes = duration / 60;
1390	+	s << minutes << " minute" << (minutes != 1 ? "s" : "");
1391	+	uint16_t seconds = duration % 60;
1392	+
1393	+	if (seconds > 0) {
1394	+	s << " and " << seconds << " second" << (seconds != 1 ? "s" : "");
1395	+	}
1396	+	} else {
1397	+	s << duration << " second" << (duration != 1 ? "s" : "");
1398	+	}
1399	+	} else {
1400	+	s << " that is brand-new";
1401	+	}
1402	+	}
1403	+
1404	+	if (!it.allowDistRead \|\| (it.id >= 7369 && it.id <= 7371)) {
1405	+	s << '.';
1406	+	} else {
1407	+	if (!text && item) {
1408	+	text = &item->getText();
1409	+	}
1410	+
1411	+	if (!text \|\| text->empty()) {
1412	+	s << '.';
1413	+	}
1414	+	}
1415	+
1416	+	if (it.wieldInfo != 0) {
1417	+	s << "\nIt can only be wielded properly by ";
1418	+
1419	+	if (it.wieldInfo & WIELDINFO_PREMIUM) {
1420	+	s << "premium ";
1421	+	}
1422	+
1423	+	if (!it.vocationString.empty()) {
1424	+	s << it.vocationString;
1425	+	} else {
1426	+	s << "players";
1427	+	}
1428	+
1429	+	if (it.wieldInfo & WIELDINFO_LEVEL) {
1430	+	s << " of level " << it.minReqLevel << " or higher";
1431	+	}
1432	+
1433	+	if (it.wieldInfo & WIELDINFO_MAGLV) {
1434	+	if (it.wieldInfo & WIELDINFO_LEVEL) {
1435	+	s << " and";
1436	+	} else {
1437	+	s << " of";
1438	+	}
1439	+
1440	+	s << " magic level " << it.minReqMagicLevel << " or higher";
1441	+	}
1442	+
1443	+	s << '.';
1444	+	}
1445	+
1446	+	if (lookDistance <= 1) {
1447	+	if (item) {
1448	+	const uint32_t weight = item->getWeight();
1449	+	if (weight != 0 && it.pickupable) {
1450	+	s << '\n' << getWeightDescription(it, weight, item->getItemCount());
1451	+	}
1452	+	} else if (it.weight != 0 && it.pickupable) {
1453	+	s << '\n' << getWeightDescription(it, it.weight);
1454	+	}
1455	+	}
1456	+
1457	+	if (item) {
1458	+	const std::string& specialDescription = item->getSpecialDescription();
1459	+	if (!specialDescription.empty()) {
1460	+	s << '\n' << specialDescription;
1461	+	} else if (lookDistance <= 1 && !it.description.empty()) {
1462	+	s << '\n' << it.description;
1463	+	}
1464	+	} else if (lookDistance <= 1 && !it.description.empty()) {
1465	+	s << '\n' << it.description;
1466	+	}
1467	+
1468	+	if (it.allowDistRead && it.id >= 7369 && it.id <= 7371) {
1469	+	if (!text && item) {
1470	+	text = &item->getText();
1471	+	}
1472	+
1473	+	if (text && !text->empty()) {
1474	+	s << '\n' << *text;
1475	+	}
1476	+	}
1477	+	return s.str();
1478	+	}
1479	+
1480	+	std::string Item::getDescription(int32_t lookDistance) const
1481	+	{
1482	+	const ItemType& it = items[id];
1483	+	return getDescription(it, lookDistance, this);
1484	+	}
1485	+
1486	+	std::string Item::getNameDescription(const ItemType& it, const Item* item /= nullptr/, int32_t subType /= -1/, bool addArticle /= true/)
1487	+	{
1488	+	if (item) {
1489	+	subType = item->getSubType();
1490	+	}
1491	+
1492	+	std::ostringstream s;
1493	+
1494	+	const std::string& name = (item ? item->getName() : it.name);
1495	+	if (!name.empty()) {
1496	+	if (it.stackable && subType > 1) {
1497	+	if (it.showCount) {
1498	+	s << subType << ' ';
1499	+	}
1500	+
1501	+	s << (item ? item->getPluralName() : it.getPluralName());
1502	+	} else {
1503	+	if (addArticle) {
1504	+	const std::string& article = (item ? item->getArticle() : it.article);
1505	+	if (!article.empty()) {
1506	+	s << article << ' ';
1507	+	}
1508	+	}
1509	+
1510	+	s << name;
1511	+	}
1512	+	} else {
1513	+	if (addArticle) {
1514	+	s << "an ";
1515	+	}
1516	+	s << "item of type " << it.id;
1517	+	}
1518	+	return s.str();
1519	+	}
1520	+
1521	+	std::string Item::getNameDescription() const
1522	+	{
1523	+	const ItemType& it = items[id];
1524	+	return getNameDescription(it, this);
1525	+	}
1526	+
1527	+	std::string Item::getWeightDescription(const ItemType& it, uint32_t weight, uint32_t count /= 1/)
1528	+	{
1529	+	std::ostringstream ss;
1530	+	if (it.stackable && count > 1 && it.showCount != 0) {
1531	+	ss << "They weigh ";
1532	+	} else {
1533	+	ss << "It weighs ";
1534	+	}
1535	+
1536	+	if (weight < 10) {
1537	+	ss << "0.0" << weight;
1538	+	} else if (weight < 100) {
1539	+	ss << "0." << weight;
1540	+	} else {
1541	+	std::string weightString = std::to_string(weight);
1542	+	weightString.insert(weightString.end() - 2, '.');
1543	+	ss << weightString;
1544	+	}
1545	+
1546	+	ss << " oz.";
1547	+	return ss.str();
1548	+	}
1549	+
1550	+	std::string Item::getWeightDescription(uint32_t weight) const
1551	+	{
1552	+	const ItemType& it = Item::items[id];
1553	+	return getWeightDescription(it, weight, getItemCount());
1554	+	}
1555	+
1556	+	std::string Item::getWeightDescription() const
1557	+	{
1558	+	uint32_t weight = getWeight();
1559	+	if (weight == 0) {
1560	+	return std::string();
1561	+	}
1562	+	return getWeightDescription(weight);
1563	+	}
1564	+
1565	+	void Item::setUniqueId(uint16_t n)
1566	+	{
1567	+	if (hasAttribute(ITEM_ATTRIBUTE_UNIQUEID)) {
1568	+	return;
1569	+	}
1570	+
1571	+	if (g_game.addUniqueItem(n, this)) {
1572	+	getAttributes()->setUniqueId(n);
1573	+	}
1574	+	}
1575	+
1576	+	bool Item::canDecay() const
1577	+	{
1578	+	if (isRemoved()) {
1579	+	return false;
1580	+	}
1581	+
1582	+	const ItemType& it = Item::items[id];
1583	+	if (getDecayTo() < 0 \|\| it.decayTime == 0) {
1584	+	return false;
1585	+	}
1586	+
1587	+	if (hasAttribute(ITEM_ATTRIBUTE_UNIQUEID)) {
1588	+	return false;
1589	+	}
1590	+
1591	+	return true;
1592	+	}
1593	+
1594	+	uint32_t Item::getWorth() const
1595	+	{
1596	+	switch (id) {
1597	+	case ITEM_GOLD_COIN:
1598	+	return count;
1599	+
1600	+	case ITEM_PLATINUM_COIN:
1601	+	return count * 100;
1602	+
1603	+	case ITEM_CRYSTAL_COIN:
1604	+	return count * 10000;
1605	+
1606	+	default:
1607	+	return 0;
1608	+	}
1609	+	}
1610	+
1611	+	LightInfo Item::getLightInfo() const
1612	+	{
1613	+	const ItemType& it = items[id];
1614	+	return {it.lightLevel, it.lightColor};
1615	+	}
1616	+
1617	+	std::string ItemAttributes::emptyString;
1618	+	int64_t ItemAttributes::emptyInt;
1619	+	double ItemAttributes::emptyDouble;
1620	+	bool ItemAttributes::emptyBool;
1621	+
1622	+	const std::string& ItemAttributes::getStrAttr(itemAttrTypes type) const
1623	+	{
1624	+	if (!isStrAttrType(type)) {
1625	+	return emptyString;
1626	+	}
1627	+
1628	+	const Attribute* attr = getExistingAttr(type);
1629	+	if (!attr) {
1630	+	return emptyString;
1631	+	}
1632	+	return *attr->value.string;
1633	+	}
1634	+
1635	+	void ItemAttributes::setStrAttr(itemAttrTypes type, const std::string& value)
1636	+	{
1637	+	if (!isStrAttrType(type)) {
1638	+	return;
1639	+	}
1640	+
1641	+	if (value.empty()) {
1642	+	return;
1643	+	}
1644	+
1645	+	Attribute& attr = getAttr(type);
1646	+	delete attr.value.string;
1647	+	attr.value.string = new std::string(value);
1648	+	}
1649	+
1650	+	void ItemAttributes::removeAttribute(itemAttrTypes type)
1651	+	{
1652	+	if (!hasAttribute(type)) {
1653	+	return;
1654	+	}
1655	+
1656	+	auto prev_it = attributes.rbegin();
1657	+	if ((*prev_it).type == type) {
1658	+	attributes.pop_back();
1659	+	} else {
1660	+	auto it = prev_it, end = attributes.rend();
1661	+	while (++it != end) {
1662	+	if ((*it).type == type) {
1663	+	(*it) = attributes.back();
1664	+	attributes.pop_back();
1665	+	break;
1666	+	}
1667	+	prev_it = it;
1668	+	}
1669	+	}
1670	+	attributeBits &= ~type;
1671	+	}
1672	+
1673	+	int64_t ItemAttributes::getIntAttr(itemAttrTypes type) const
1674	+	{
1675	+	if (!isIntAttrType(type)) {
1676	+	return 0;
1677	+	}
1678	+
1679	+	const Attribute* attr = getExistingAttr(type);
1680	+	if (!attr) {
1681	+	return 0;
1682	+	}
1683	+	return attr->value.integer;
1684	+	}
1685	+
1686	+	void ItemAttributes::setIntAttr(itemAttrTypes type, int64_t value)
1687	+	{
1688	+	if (!isIntAttrType(type)) {
1689	+	return;
1690	+	}
1691	+
1692	+	getAttr(type).value.integer = value;
1693	+	}
1694	+
1695	+	void ItemAttributes::increaseIntAttr(itemAttrTypes type, int64_t value)
1696	+	{
1697	+	if (!isIntAttrType(type)) {
1698	+	return;
1699	+	}
1700	+
1701	+	getAttr(type).value.integer += value;
1702	+	}
1703	+
1704	+	const ItemAttributes::Attribute* ItemAttributes::getExistingAttr(itemAttrTypes type) const
1705	+	{
1706	+	if (hasAttribute(type)) {
1707	+	for (const Attribute& attribute : attributes) {
1708	+	if (attribute.type == type) {
1709	+	return &attribute;
1710	+	}
1711	+	}
1712	+	}
1713	+	return nullptr;
1714	+	}
1715	+
1716	+	ItemAttributes::Attribute& ItemAttributes::getAttr(itemAttrTypes type)
1717	+	{
1718	+	if (hasAttribute(type)) {
1719	+	for (Attribute& attribute : attributes) {
1720	+	if (attribute.type == type) {
1721	+	return attribute;
1722	+	}
1723	+	}
1724	+	}
1725	+
1726	+	attributeBits \|= type;
1727	+	attributes.emplace_back(type);
1728	+	return attributes.back();
1729	+	}
1730	+
1731	+	void Item::startDecaying()
1732	+	{
1733	+	g_game.startDecay(this);
1734	+	}
1735	+
1736	+	bool Item::hasMarketAttributes() const
1737	+	{
1738	+	if (attributes == nullptr) {
1739	+	return true;
1740	+	}
1741	+
1742	+	for (const auto& attr : attributes->getList()) {
1743	+	if (attr.type == ITEM_ATTRIBUTE_CHARGES) {
1744	+	uint16_t charges = static_cast<uint16_t>(attr.value.integer);
1745	+	if (charges != items[id].charges) {
1746	+	return false;
1747	+	}
1748	+	} else if (attr.type == ITEM_ATTRIBUTE_DURATION) {
1749	+	uint32_t duration = static_cast<uint32_t>(attr.value.integer);
1750	+	if (duration != getDefaultDuration()) {
1751	+	return false;
1752	+	}
1753	+	} else {
1754	+	return false;
1755	+	}
1756	+	}
1757	+	return true;
1758	+	}
1759	+
1760	+	template<>
1761	+	const std::string& ItemAttributes::CustomAttribute::get<std::string>() {
1762	+	if (value.type() == typeid(std::string)) {
1763	+	return boost::get<std::string>(value);
1764	+	}
1765	+
1766	+	return emptyString;
1767	+	}
1768	+
1769	+	template<>
1770	+	const int64_t& ItemAttributes::CustomAttribute::get<int64_t>() {
1771	+	if (value.type() == typeid(int64_t)) {
1772	+	return boost::get<int64_t>(value);
1773	+	}
1774	+
1775	+	return emptyInt;
1776	+	}
1777	+
1778	+	template<>
1779	+	const double& ItemAttributes::CustomAttribute::get<double>() {
1780	+	if (value.type() == typeid(double)) {
1781	+	return boost::get<double>(value);
1782	+	}
1783	+
1784	+	return emptyDouble;
1785	+	}
1786	+
1787	+	template<>
1788	+	const bool& ItemAttributes::CustomAttribute::get<bool>() {
1789	+	if (value.type() == typeid(bool)) {
1790	+	return boost::get<bool>(value);
1791	+	}
1792	+
1793	+	return emptyBool;
1794	+	}

A src/item.h +918-0 View file

Large diff collapsed. 919 diff lines hidden.

		@@ -0,0 +1,918 @@
1	+	/**
2	+	* The Forgotten Server - a free and open-source MMORPG server emulator
3	+	* Copyright (C) 2019 Mark Samman <mark.samman@gmail.com>
4	+	*
5	+	* This program is free software; you can redistribute it and/or modify
6	+	* it under the terms of the GNU General Public License as published by
7	+	* the Free Software Foundation; either version 2 of the License, or
8	+	* (at your option) any later version.
9	+	*
10	+	* This program is distributed in the hope that it will be useful,
11	+	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	+	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	+	* GNU General Public License for more details.
14	+	*
15	+	* You should have received a copy of the GNU General Public License along
16	+	* with this program; if not, write to the Free Software Foundation, Inc.,
17	+	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18	+	*/
19	+
20	+	#ifndef FS_ITEM_H_009A319FB13D477D9EEFFBBD9BB83562
21	+	#define FS_ITEM_H_009A319FB13D477D9EEFFBBD9BB83562
22	+
23	+	#include "cylinder.h"
24	+	#include "items.h"
25	+	#include "luascript.h"
26	+	#include "thing.h"
27	+	#include "tools.h"
28	+	#include <typeinfo>
29	+
30	+	#include <boost/lexical_cast.hpp>
31	+	#include <boost/variant.hpp>
32	+	#include <deque>
33	+
34	+	class Creature;
35	+	class Player;
36	+	class Container;
37	+	class Depot;
38	+	class Teleport;
39	+	class TrashHolder;
40	+	class Mailbox;
41	+	class Door;
42	+	class MagicField;
43	+	class BedItem;
44	+
45	+	enum ITEMPROPERTY {
46	+	CONST_PROP_BLOCKSOLID = 0,
47	+	CONST_PROP_HASHEIGHT,
48	+	CONST_PROP_BLOCKPROJECTILE,
49	+	CONST_PROP_BLOCKPATH,
50	+	CONST_PROP_ISVERTICAL,
51	+	CONST_PROP_ISHORIZONTAL,
52	+	CONST_PROP_MOVEABLE,
53	+	CONST_PROP_IMMOVABLEBLOCKSOLID,
54	+	CONST_PROP_IMMOVABLEBLOCKPATH,
55	+	CONST_PROP_IMMOVABLENOFIELDBLOCKPATH,
56	+	CONST_PROP_NOFIELDBLOCKPATH,
57	+	CONST_PROP_SUPPORTHANGABLE,
58	+	};
59	+
60	+	enum TradeEvents_t {
61	+	ON_TRADE_TRANSFER,
62	+	ON_TRADE_CANCEL,
63	+	};
64	+
65	+	enum ItemDecayState_t : uint8_t {
66	+	DECAYING_FALSE = 0,
67	+	DECAYING_TRUE,
68	+	DECAYING_PENDING,
69	+	};
70	+
71	+	enum AttrTypes_t {
72	+	// ATTR_DESCRIPTION = 1,
73	+	// ATTR_EXT_FILE = 2,
74	+	ATTR_TILE_FLAGS = 3,
75	+	ATTR_ACTION_ID = 4,
76	+	ATTR_UNIQUE_ID = 5,
77	+	ATTR_TEXT = 6,
78	+	ATTR_DESC = 7,
79	+	ATTR_TELE_DEST = 8,
80	+	ATTR_ITEM = 9,
81	+	ATTR_DEPOT_ID = 10,
82	+	// ATTR_EXT_SPAWN_FILE = 11,
83	+	ATTR_RUNE_CHARGES = 12,
84	+	// ATTR_EXT_HOUSE_FILE = 13,
85	+	ATTR_HOUSEDOORID = 14,
86	+	ATTR_COUNT = 15,
87	+	ATTR_DURATION = 16,
88	+	ATTR_DECAYING_STATE = 17,
89	+	ATTR_WRITTENDATE = 18,
90	+	ATTR_WRITTENBY = 19,
91	+	ATTR_SLEEPERGUID = 20,
92	+	ATTR_SLEEPSTART = 21,
93	+	ATTR_CHARGES = 22,
94	+	ATTR_CONTAINER_ITEMS = 23,
95	+	ATTR_NAME = 24,
96	+	ATTR_ARTICLE = 25,
97	+	ATTR_PLURALNAME = 26,
98	+	ATTR_WEIGHT = 27,
99	+	ATTR_ATTACK = 28,
100	+	ATTR_DEFENSE = 29,
101	+	ATTR_EXTRADEFENSE = 30,
102	+	ATTR_ARMOR = 31,
103	+	ATTR_HITCHANCE = 32,
104	+	ATTR_SHOOTRANGE = 33,
105	+	ATTR_CUSTOM_ATTRIBUTES = 34,
106	+	ATTR_DECAYTO = 35,
107	+	ATTR_WRAPID = 36
108	+	};
109	+
110	+	enum Attr_ReadValue {
111	+	ATTR_READ_CONTINUE,
112	+	ATTR_READ_ERROR,
113	+	ATTR_READ_END,
114	+	};
115	+
116	+	class ItemAttributes {
117	+	public:
118	+	ItemAttributes() = default;
119	+
120	+	void setSpecialDescription(const std::string &desc) {
121	+	setStrAttr(ITEM_ATTRIBUTE_DESCRIPTION, desc);
122	+	}
123	+	const std::string &getSpecialDescription() const {
124	+	return getStrAttr(ITEM_ATTRIBUTE_DESCRIPTION);
125	+	}
126	+
127	+	void setText(const std::string &text) {
128	+	setStrAttr(ITEM_ATTRIBUTE_TEXT, text);
129	+	}
130	+	void resetText() { removeAttribute(ITEM_ATTRIBUTE_TEXT); }
131	+	const std::string &getText() const { return getStrAttr(ITEM_ATTRIBUTE_TEXT); }
132	+
133	+	void setDate(int32_t n) { setIntAttr(ITEM_ATTRIBUTE_DATE, n); }
134	+	void resetDate() { removeAttribute(ITEM_ATTRIBUTE_DATE); }
135	+	time_t getDate() const {
136	+	return static_cast<time_t>(getIntAttr(ITEM_ATTRIBUTE_DATE));
137	+	}
138	+
139	+	void setWriter(const std::string &writer) {
140	+	setStrAttr(ITEM_ATTRIBUTE_WRITER, writer);
141	+	}
142	+	void resetWriter() { removeAttribute(ITEM_ATTRIBUTE_WRITER); }
143	+	const std::string &getWriter() const {
144	+	return getStrAttr(ITEM_ATTRIBUTE_WRITER);
145	+	}
146	+
147	+	void setActionId(uint16_t n) { setIntAttr(ITEM_ATTRIBUTE_ACTIONID, n); }
148	+	uint16_t getActionId() const {
149	+	return static_cast<uint16_t>(getIntAttr(ITEM_ATTRIBUTE_ACTIONID));
150	+	}
151	+
152	+	void setUniqueId(uint16_t n) { setIntAttr(ITEM_ATTRIBUTE_UNIQUEID, n); }
153	+	uint16_t getUniqueId() const {
154	+	return static_cast<uint16_t>(getIntAttr(ITEM_ATTRIBUTE_UNIQUEID));
155	+	}
156	+
157	+	void setCharges(uint16_t n) { setIntAttr(ITEM_ATTRIBUTE_CHARGES, n); }
158	+	uint16_t getCharges() const {
159	+	return static_cast<uint16_t>(getIntAttr(ITEM_ATTRIBUTE_CHARGES));
160	+	}
161	+
162	+	void setFluidType(uint16_t n) { setIntAttr(ITEM_ATTRIBUTE_FLUIDTYPE, n); }
163	+	uint16_t getFluidType() const {
164	+	return static_cast<uint16_t>(getIntAttr(ITEM_ATTRIBUTE_FLUIDTYPE));
165	+	}
166	+
167	+	void setOwner(uint32_t owner) { setIntAttr(ITEM_ATTRIBUTE_OWNER, owner); }
168	+	uint32_t getOwner() const { return getIntAttr(ITEM_ATTRIBUTE_OWNER); }
169	+
170	+	void setCorpseOwner(uint32_t corpseOwner) {
171	+	setIntAttr(ITEM_ATTRIBUTE_CORPSEOWNER, corpseOwner);
172	+	}
173	+	uint32_t getCorpseOwner() const {
174	+	return getIntAttr(ITEM_ATTRIBUTE_CORPSEOWNER);
175	+	}
176	+
177	+	void setDuration(int32_t time) { setIntAttr(ITEM_ATTRIBUTE_DURATION, time); }
178	+	void decreaseDuration(int32_t time) {
179	+	increaseIntAttr(ITEM_ATTRIBUTE_DURATION, -time);
180	+	}
181	+	uint32_t getDuration() const { return getIntAttr(ITEM_ATTRIBUTE_DURATION); }
182	+
183	+	void setDecaying(ItemDecayState_t decayState) {
184	+	setIntAttr(ITEM_ATTRIBUTE_DECAYSTATE, decayState);
185	+	}
186	+	ItemDecayState_t getDecaying() const {
187	+	return static_cast<ItemDecayState_t>(getIntAttr(ITEM_ATTRIBUTE_DECAYSTATE));
188	+	}
189	+
190	+	struct CustomAttribute {
191	+	typedef boost::variant<boost::blank, std::string, int64_t, double, bool>
192	+	VariantAttribute;
193	+	VariantAttribute value;
194	+
195	+	CustomAttribute() : value(boost::blank()) {}
196	+
197	+	template <typename T> explicit CustomAttribute(const T &v) : value(v) {}
198	+
199	+	template <typename T> void set(const T &v) { value = v; }
200	+
201	+	template <typename T> const T &get();
202	+
203	+	struct PushLuaVisitor : public boost::static_visitor<> {
204	+	lua_State *L;
205	+
206	+	explicit PushLuaVisitor(lua_State *L) : boost::static_visitor<>(), L(L) {}
207	+
208	+	void operator()(const boost::blank &) const { lua_pushnil(L); }
209	+
210	+	void operator()(const std::string &v) const {
211	+	LuaScriptInterface::pushString(L, v);
212	+	}
213	+
214	+	void operator()(bool v) const { LuaScriptInterface::pushBoolean(L, v); }
215	+
216	+	void operator()(const int64_t &v) const { lua_pushnumber(L, v); }
217	+
218	+	void operator()(const double &v) const { lua_pushnumber(L, v); }
219	+	};
220	+
221	+	void pushToLua(lua_State *L) const {
222	+	boost::apply_visitor(PushLuaVisitor(L), value);
223	+	}
224	+
225	+	struct SerializeVisitor : public boost::static_visitor<> {
226	+	PropWriteStream &propWriteStream;
227	+
228	+	explicit SerializeVisitor(PropWriteStream &propWriteStream)
229	+	: boost::static_visitor<>(), propWriteStream(propWriteStream) {}
230	+
231	+	void operator()(const boost::blank &) const {}
232	+
233	+	void operator()(const std::string &v) const {
234	+	propWriteStream.writeString(v);
235	+	}
236	+
237	+	template <typename T> void operator()(const T &v) const {
238	+	propWriteStream.write<T>(v);
239	+	}
240	+	};
241	+
242	+	void serialize(PropWriteStream &propWriteStream) const {
243	+	propWriteStream.write<uint8_t>(static_cast<uint8_t>(value.which()));
244	+	boost::apply_visitor(SerializeVisitor(propWriteStream), value);
245	+	}
246	+
247	+	bool unserialize(PropStream &propStream) {
248	+	// This is hard coded so it's not general, depends on the position of the
249	+	// variants.
250	+	uint8_t pos;
251	+	if (!propStream.read<uint8_t>(pos)) {
252	+	return false;
253	+	}
254	+
255	+	switch (pos) {
256	+	case 1: { // std::string
257	+	std::string tmp;
258	+	if (!propStream.readString(tmp)) {
259	+	return false;
260	+	}
261	+	value = tmp;
262	+	break;
263	+	}
264	+
265	+	case 2: { // int64_t
266	+	int64_t tmp;
267	+	if (!propStream.read<int64_t>(tmp)) {
268	+	return false;
269	+	}
270	+	value = tmp;
271	+	break;
272	+	}
273	+
274	+	case 3: { // double
275	+	double tmp;
276	+	if (!propStream.read<double>(tmp)) {
277	+	return false;
278	+	}
279	+	value = tmp;
280	+	break;
281	+	}
282	+
283	+	case 4: { // bool
284	+	bool tmp;
285	+	if (!propStream.read<bool>(tmp)) {
286	+	return false;
287	+	}
288	+	value = tmp;
289	+	break;
290	+	}
291	+
292	+	default: {
293	+	value = boost::blank();
294	+	return false;
295	+	}
296	+	}
297	+	return true;
298	+	}
299	+	};
300	+
301	+	private:
302	+	bool hasAttribute(itemAttrTypes type) const {
303	+	return (type & attributeBits) != 0;
304	+	}
305	+	void removeAttribute(itemAttrTypes type);
306	+
307	+	static std::string emptyString;
308	+	static int64_t emptyInt;
309	+	static double emptyDouble;
310	+	static bool emptyBool;
311	+
312	+	typedef std::unordered_map<std::string, CustomAttribute> CustomAttributeMap;
313	+
314	+	struct Attribute {
315	+	union {
316	+	int64_t integer;
317	+	std::string *string;
318	+	CustomAttributeMap *custom;
319	+	} value;
320	+	itemAttrTypes type;
321	+
322	+	explicit Attribute(itemAttrTypes type) : type(type) {
323	+	memset(&value, 0, sizeof(value));
324	+	}
325	+	Attribute(const Attribute &i) {
326	+	type = i.type;
327	+	if (ItemAttributes::isIntAttrType(type)) {
328	+	value.integer = i.value.integer;
329	+	} else if (ItemAttributes::isStrAttrType(type)) {
330	+	value.string = new std::string(*i.value.string);
331	+	} else if (ItemAttributes::isCustomAttrType(type)) {
332	+	value.custom = new CustomAttributeMap(*i.value.custom);
333	+	} else {
334	+	memset(&value, 0, sizeof(value));
335	+	}
336	+	}
337	+	Attribute(Attribute &&attribute)
338	+	: value(attribute.value), type(attribute.type) {
339	+	memset(&attribute.value, 0, sizeof(value));
340	+	attribute.type = ITEM_ATTRIBUTE_NONE;
341	+	}
342	+	~Attribute() {
343	+	if (ItemAttributes::isStrAttrType(type)) {
344	+	delete value.string;
345	+	} else if (ItemAttributes::isCustomAttrType(type)) {
346	+	delete value.custom;
347	+	}
348	+	}
349	+	Attribute &operator=(Attribute other) {
350	+	Attribute::swap(*this, other);
351	+	return *this;
352	+	}
353	+	Attribute &operator=(Attribute &&other) {
354	+	if (this != &other) {
355	+	if (ItemAttributes::isStrAttrType(type)) {
356	+	delete value.string;
357	+	} else if (ItemAttributes::isCustomAttrType(type)) {
358	+	delete value.custom;
359	+	}
360	+
361	+	value = other.value;
362	+	type = other.type;
363	+
364	+	memset(&other.value, 0, sizeof(value));
365	+	other.type = ITEM_ATTRIBUTE_NONE;
366	+	}
367	+	return *this;
368	+	}
369	+
370	+	static void swap(Attribute &first, Attribute &second) {
371	+	std::swap(first.value, second.value);
372	+	std::swap(first.type, second.type);
373	+	}
374	+	};
375	+
376	+	std::vector<Attribute> attributes;
377	+	uint32_t attributeBits = 0;
378	+
379	+	const std::string &getStrAttr(itemAttrTypes type) const;
380	+	void setStrAttr(itemAttrTypes type, const std::string &value);
381	+
382	+	int64_t getIntAttr(itemAttrTypes type) const;
383	+	void setIntAttr(itemAttrTypes type, int64_t value);
384	+	void increaseIntAttr(itemAttrTypes type, int64_t value);
385	+
386	+	const Attribute *getExistingAttr(itemAttrTypes type) const;
387	+	Attribute &getAttr(itemAttrTypes type);
388	+
389	+	CustomAttributeMap *getCustomAttributeMap() {
390	+	if (!hasAttribute(ITEM_ATTRIBUTE_CUSTOM)) {
391	+	return nullptr;
392	+	}
393	+
394	+	return getAttr(ITEM_ATTRIBUTE_CUSTOM).value.custom;
395	+	}
396	+
397	+	template <typename R> void setCustomAttribute(int64_t key, R value) {
398	+	std::string tmp = boost::lexical_cast<std::string>(key);
399	+	setCustomAttribute(tmp, value);
400	+	}
401	+
402	+	void setCustomAttribute(int64_t key, CustomAttribute &value) {
403	+	std::string tmp = boost::lexical_cast<std::string>(key);
404	+	setCustomAttribute(tmp, value);
405	+	}
406	+
407	+	template <typename R> void setCustomAttribute(std::string &key, R value) {
408	+	toLowerCaseString(key);
409	+	if (hasAttribute(ITEM_ATTRIBUTE_CUSTOM)) {
410	+	removeCustomAttribute(key);
411	+	} else {
412	+	getAttr(ITEM_ATTRIBUTE_CUSTOM).value.custom = new CustomAttributeMap();
413	+	}
414	+	getAttr(ITEM_ATTRIBUTE_CUSTOM).value.custom->emplace(key, value);
415	+	}
416	+
417	+	void setCustomAttribute(std::string &key, CustomAttribute &value) {
418	+	toLowerCaseString(key);
419	+	if (hasAttribute(ITEM_ATTRIBUTE_CUSTOM)) {
420	+	removeCustomAttribute(key);
421	+	} else {
422	+	getAttr(ITEM_ATTRIBUTE_CUSTOM).value.custom = new CustomAttributeMap();
423	+	}
424	+	getAttr(ITEM_ATTRIBUTE_CUSTOM)
425	+	.value.custom->insert(std::make_pair(std::move(key), std::move(value)));
426	+	}
427	+
428	+	const CustomAttribute *getCustomAttribute(int64_t key) {
429	+	std::string tmp = boost::lexical_cast<std::string>(key);
430	+	return getCustomAttribute(tmp);
431	+	}
432	+
433	+	const CustomAttribute *getCustomAttribute(const std::string &key) {
434	+	if (const CustomAttributeMap *customAttrMap = getCustomAttributeMap()) {
435	+	auto it = customAttrMap->find(asLowerCaseString(key));
436	+	if (it != customAttrMap->end()) {
437	+	return &(it->second);
438	+	}
439	+	}
440	+	return nullptr;
441	+	}
442	+
443	+	bool removeCustomAttribute(int64_t key) {
444	+	std::string tmp = boost::lexical_cast<std::string>(key);
445	+	return removeCustomAttribute(tmp);
446	+	}
447	+
448	+	bool removeCustomAttribute(const std::string &key) {
449	+	if (CustomAttributeMap *customAttrMap = getCustomAttributeMap()) {
450	+	auto it = customAttrMap->find(asLowerCaseString(key));
451	+	if (it != customAttrMap->end()) {
452	+	customAttrMap->erase(it);
453	+	return true;
454	+	}
455	+	}
456	+	return false;
457	+	}
458	+
459	+	const static uint32_t intAttributeTypes =
460	+	ITEM_ATTRIBUTE_ACTIONID \| ITEM_ATTRIBUTE_UNIQUEID \| ITEM_ATTRIBUTE_DATE \|
461	+	ITEM_ATTRIBUTE_WEIGHT \| ITEM_ATTRIBUTE_ATTACK \| ITEM_ATTRIBUTE_DEFENSE \|
462	+	ITEM_ATTRIBUTE_EXTRADEFENSE \| ITEM_ATTRIBUTE_ARMOR \|
463	+	ITEM_ATTRIBUTE_HITCHANCE \| ITEM_ATTRIBUTE_SHOOTRANGE \|
464	+	ITEM_ATTRIBUTE_OWNER \| ITEM_ATTRIBUTE_DURATION \|
465	+	ITEM_ATTRIBUTE_DECAYSTATE \| ITEM_ATTRIBUTE_CORPSEOWNER \|
466	+	ITEM_ATTRIBUTE_CHARGES \| ITEM_ATTRIBUTE_FLUIDTYPE \|
467	+	ITEM_ATTRIBUTE_DOORID \| ITEM_ATTRIBUTE_DECAYTO \| ITEM_ATTRIBUTE_WRAPID;
468	+	const static uint32_t stringAttributeTypes =
469	+	ITEM_ATTRIBUTE_DESCRIPTION \| ITEM_ATTRIBUTE_TEXT \| ITEM_ATTRIBUTE_WRITER \|
470	+	ITEM_ATTRIBUTE_NAME \| ITEM_ATTRIBUTE_ARTICLE \| ITEM_ATTRIBUTE_PLURALNAME;
471	+
472	+	public:
473	+	static bool isIntAttrType(itemAttrTypes type) {
474	+	return (type & intAttributeTypes) == type;
475	+	}
476	+	static bool isStrAttrType(itemAttrTypes type) {
477	+	return (type & stringAttributeTypes) == type;
478	+	}
479	+	inline static bool isCustomAttrType(itemAttrTypes type) {
480	+	return (type & ITEM_ATTRIBUTE_CUSTOM) == type;
481	+	}
482	+
483	+	const std::vector<Attribute> &getList() const { return attributes; }
484	+
485	+	friend class Item;
486	+	};
487	+
488	+	class Item : virtual public Thing {
489	+	public:
490	+	// Factory member to create item of right type based on type
491	+	static Item *CreateItem(const uint16_t type, uint16_t count = 0);
492	+	static Container *CreateItemAsContainer(const uint16_t type, uint16_t size);
493	+	static Item *CreateItem(PropStream &propStream);
494	+	static Items items;
495	+
496	+	// Constructor for items
497	+	Item(const uint16_t type, uint16_t count = 0);
498	+	Item(const Item &i);
499	+	virtual Item *clone() const;
500	+
501	+	virtual ~Item() = default;
502	+
503	+	// non-assignable
504	+	Item &operator=(const Item &) = delete;
505	+
506	+	bool equals(const Item *otherItem) const;
507	+
508	+	Item *getItem() override final { return this; }
509	+	const Item *getItem() const override final { return this; }
510	+	virtual Teleport *getTeleport() { return nullptr; }
511	+	virtual const Teleport *getTeleport() const { return nullptr; }
512	+	virtual TrashHolder *getTrashHolder() { return nullptr; }
513	+	virtual const TrashHolder *getTrashHolder() const { return nullptr; }
514	+	virtual Mailbox *getMailbox() { return nullptr; }
515	+	virtual const Mailbox *getMailbox() const { return nullptr; }
516	+	virtual Door *getDoor() { return nullptr; }
517	+	virtual const Door *getDoor() const { return nullptr; }
518	+	virtual MagicField *getMagicField() { return nullptr; }
519	+	virtual const MagicField *getMagicField() const { return nullptr; }
520	+	virtual BedItem *getBed() { return nullptr; }
521	+	virtual const BedItem *getBed() const { return nullptr; }
522	+
523	+	const std::string &getStrAttr(itemAttrTypes type) const {
524	+	if (!attributes) {
525	+	return ItemAttributes::emptyString;
526	+	}
527	+	return attributes->getStrAttr(type);
528	+	}
529	+	void setStrAttr(itemAttrTypes type, const std::string &value) {
530	+	getAttributes()->setStrAttr(type, value);
531	+	}
532	+
533	+	int64_t getIntAttr(itemAttrTypes type) const {
534	+	if (!attributes) {
535	+	return 0;
536	+	}
537	+	return attributes->getIntAttr(type);
538	+	}
539	+	void setIntAttr(itemAttrTypes type, int64_t value) {
540	+	getAttributes()->setIntAttr(type, value);
541	+	}
542	+	void increaseIntAttr(itemAttrTypes type, int64_t value) {
543	+	getAttributes()->increaseIntAttr(type, value);
544	+	}
545	+
546	+	void removeAttribute(itemAttrTypes type) {
547	+	if (attributes) {
548	+	attributes->removeAttribute(type);
549	+	}
550	+	}
551	+	bool hasAttribute(itemAttrTypes type) const {
552	+	if (!attributes) {
553	+	return false;
554	+	}
555	+	return attributes->hasAttribute(type);
556	+	}
557	+
558	+	template <typename R> void setCustomAttribute(std::string &key, R value) {
559	+	getAttributes()->setCustomAttribute(key, value);
560	+	}
561	+
562	+	void setCustomAttribute(std::string &key,
563	+	ItemAttributes::CustomAttribute &value) {
564	+	getAttributes()->setCustomAttribute(key, value);
565	+	}
566	+
567	+	const ItemAttributes::CustomAttribute *getCustomAttribute(int64_t key) {
568	+	if (!attributes) {
569	+	return nullptr;
570	+	}
571	+	return getAttributes()->getCustomAttribute(key);
572	+	}
573	+
574	+	const ItemAttributes::CustomAttribute *
575	+	getCustomAttribute(const std::string &key) {
576	+	if (!attributes) {
577	+	return nullptr;
578	+	}
579	+	return getAttributes()->getCustomAttribute(key);
580	+	}
581	+
582	+	bool removeCustomAttribute(int64_t key) {
583	+	if (!attributes) {
584	+	return false;
585	+	}
586	+	return getAttributes()->removeCustomAttribute(key);
587	+	}
588	+
589	+	bool removeCustomAttribute(const std::string &key) {
590	+	if (!attributes) {
591	+	return false;
592	+	}
593	+	return getAttributes()->removeCustomAttribute(key);
594	+	}
595	+
596	+	void setSpecialDescription(const std::string &desc) {
597	+	setStrAttr(ITEM_ATTRIBUTE_DESCRIPTION, desc);
598	+	}
599	+	const std::string &getSpecialDescription() const {
600	+	return getStrAttr(ITEM_ATTRIBUTE_DESCRIPTION);
601	+	}
602	+
603	+	void setText(const std::string &text) {
604	+	setStrAttr(ITEM_ATTRIBUTE_TEXT, text);
605	+	}
606	+	void resetText() { removeAttribute(ITEM_ATTRIBUTE_TEXT); }
607	+	const std::string &getText() const { return getStrAttr(ITEM_ATTRIBUTE_TEXT); }
608	+
609	+	void setDate(int32_t n) { setIntAttr(ITEM_ATTRIBUTE_DATE, n); }
610	+	void resetDate() { removeAttribute(ITEM_ATTRIBUTE_DATE); }
611	+	time_t getDate() const {
612	+	return static_cast<time_t>(getIntAttr(ITEM_ATTRIBUTE_DATE));
613	+	}
614	+
615	+	void setWriter(const std::string &writer) {
616	+	setStrAttr(ITEM_ATTRIBUTE_WRITER, writer);
617	+	}
618	+	void resetWriter() { removeAttribute(ITEM_ATTRIBUTE_WRITER); }
619	+	const std::string &getWriter() const {
620	+	return getStrAttr(ITEM_ATTRIBUTE_WRITER);
621	+	}
622	+
623	+	void setActionId(uint16_t n) {
624	+	if (n < 100) {
625	+	n = 100;
626	+	}
627	+
628	+	setIntAttr(ITEM_ATTRIBUTE_ACTIONID, n);
629	+	}
630	+	uint16_t getActionId() const {
631	+	if (!attributes) {
632	+	return 0;
633	+	}
634	+	return static_cast<uint16_t>(getIntAttr(ITEM_ATTRIBUTE_ACTIONID));
635	+	}
636	+
637	+	uint16_t getUniqueId() const {
638	+	if (!attributes) {
639	+	return 0;
640	+	}
641	+	return static_cast<uint16_t>(getIntAttr(ITEM_ATTRIBUTE_UNIQUEID));
642	+	}
643	+
644	+	void setCharges(uint16_t n) { setIntAttr(ITEM_ATTRIBUTE_CHARGES, n); }
645	+	uint16_t getCharges() const {
646	+	if (!attributes) {
647	+	return 0;
648	+	}
649	+	return static_cast<uint16_t>(getIntAttr(ITEM_ATTRIBUTE_CHARGES));
650	+	}
651	+
652	+	void setFluidType(uint16_t n) { setIntAttr(ITEM_ATTRIBUTE_FLUIDTYPE, n); }
653	+	uint16_t getFluidType() const {
654	+	if (!attributes) {
655	+	return 0;
656	+	}
657	+	return static_cast<uint16_t>(getIntAttr(ITEM_ATTRIBUTE_FLUIDTYPE));
658	+	}
659	+
660	+	void setOwner(uint32_t owner) { setIntAttr(ITEM_ATTRIBUTE_OWNER, owner); }
661	+	uint32_t getOwner() const {
662	+	if (!attributes) {
663	+	return 0;
664	+	}
665	+	return getIntAttr(ITEM_ATTRIBUTE_OWNER);
666	+	}
667	+
668	+	void setCorpseOwner(uint32_t corpseOwner) {
669	+	setIntAttr(ITEM_ATTRIBUTE_CORPSEOWNER, corpseOwner);
670	+	}
671	+	uint32_t getCorpseOwner() const {
672	+	if (!attributes) {
673	+	return 0;
674	+	}
675	+	return getIntAttr(ITEM_ATTRIBUTE_CORPSEOWNER);
676	+	}
677	+
678	+	void setDuration(int32_t time) { setIntAttr(ITEM_ATTRIBUTE_DURATION, time); }
679	+	void decreaseDuration(int32_t time) {
680	+	increaseIntAttr(ITEM_ATTRIBUTE_DURATION, -time);
681	+	}
682	+	uint32_t getDuration() const {
683	+	if (!attributes) {
684	+	return 0;
685	+	}
686	+	return getIntAttr(ITEM_ATTRIBUTE_DURATION);
687	+	}
688	+
689	+	void setDecaying(ItemDecayState_t decayState) {
690	+	setIntAttr(ITEM_ATTRIBUTE_DECAYSTATE, decayState);
691	+	}
692	+	ItemDecayState_t getDecaying() const {
693	+	if (!attributes) {
694	+	return DECAYING_FALSE;
695	+	}
696	+	return static_cast<ItemDecayState_t>(getIntAttr(ITEM_ATTRIBUTE_DECAYSTATE));
697	+	}
698	+
699	+	void setDecayTo(int32_t decayTo) {
700	+	setIntAttr(ITEM_ATTRIBUTE_DECAYTO, decayTo);
701	+	}
702	+	int32_t getDecayTo() const {
703	+	if (hasAttribute(ITEM_ATTRIBUTE_DECAYTO)) {
704	+	return getIntAttr(ITEM_ATTRIBUTE_DECAYTO);
705	+	}
706	+	return items[id].decayTo;
707	+	}
708	+
709	+	static std::string getDescription(const ItemType &it, int32_t lookDistance,
710	+	const Item *item = nullptr,
711	+	int32_t subType = -1,
712	+	bool addArticle = true);
713	+	static std::string getNameDescription(const ItemType &it,
714	+	const Item *item = nullptr,
715	+	int32_t subType = -1,
716	+	bool addArticle = true);
717	+	static std::string getWeightDescription(const ItemType &it, uint32_t weight,
718	+	uint32_t count = 1);
719	+
720	+	std::string getDescription(int32_t lookDistance) const override final;
721	+	std::string getNameDescription() const;
722	+	std::string getWeightDescription() const;
723	+
724	+	// serialization
725	+	virtual Attr_ReadValue readAttr(AttrTypes_t attr, PropStream &propStream);
726	+	bool unserializeAttr(PropStream &propStream);
727	+	virtual bool unserializeItemNode(OTB::Loader &, const OTB::Node &,
728	+	PropStream &propStream);
729	+
730	+	virtual void serializeAttr(PropWriteStream &propWriteStream) const;
731	+
732	+	bool isPushable() const override final { return isMoveable(); }
733	+	int32_t getThrowRange() const override final {
734	+	return (isPickupable() ? 15 : 2);
735	+	}
736	+
737	+	uint16_t getID() const { return id; }
738	+	uint16_t getClientID() const { return items[id].clientId; }
739	+	void setID(uint16_t newid);
740	+
741	+	// Returns the player that is holding this item in his inventory
742	+	Player *getHoldingPlayer() const;
743	+
744	+	WeaponType_t getWeaponType() const { return items[id].weaponType; }
745	+	Ammo_t getAmmoType() const { return items[id].ammoType; }
746	+	uint8_t getShootRange() const {
747	+	if (hasAttribute(ITEM_ATTRIBUTE_SHOOTRANGE)) {
748	+	return getIntAttr(ITEM_ATTRIBUTE_SHOOTRANGE);
749	+	}
750	+	return items[id].shootRange;
751	+	}
752	+
753	+	virtual uint32_t getWeight() const;
754	+	uint32_t getBaseWeight() const {
755	+	if (hasAttribute(ITEM_ATTRIBUTE_WEIGHT)) {
756	+	return getIntAttr(ITEM_ATTRIBUTE_WEIGHT);
757	+	}
758	+	return items[id].weight;
759	+	}
760	+	int32_t getAttack() const {
761	+	if (hasAttribute(ITEM_ATTRIBUTE_ATTACK)) {
762	+	return getIntAttr(ITEM_ATTRIBUTE_ATTACK);
763	+	}
764	+	return items[id].attack;
765	+	}
766	+	int32_t getArmor() const {
767	+	if (hasAttribute(ITEM_ATTRIBUTE_ARMOR)) {
768	+	return getIntAttr(ITEM_ATTRIBUTE_ARMOR);
769	+	}
770	+	return items[id].armor;
771	+	}
772	+	int32_t getDefense() const {
773	+	if (hasAttribute(ITEM_ATTRIBUTE_DEFENSE)) {
774	+	return getIntAttr(ITEM_ATTRIBUTE_DEFENSE);
775	+	}
776	+	return items[id].defense;
777	+	}
778	+	int32_t getExtraDefense() const {
779	+	if (hasAttribute(ITEM_ATTRIBUTE_EXTRADEFENSE)) {
780	+	return getIntAttr(ITEM_ATTRIBUTE_EXTRADEFENSE);
781	+	}
782	+	return items[id].extraDefense;
783	+	}
784	+	int32_t getSlotPosition() const { return items[id].slotPosition; }
785	+	int8_t getHitChance() const {
786	+	if (hasAttribute(ITEM_ATTRIBUTE_HITCHANCE)) {
787	+	return getIntAttr(ITEM_ATTRIBUTE_HITCHANCE);
788	+	}
789	+	return items[id].hitChance;
790	+	}
791	+
792	+	uint32_t getWorth() const;
793	+	LightInfo getLightInfo() const;
794	+
795	+	bool hasProperty(ITEMPROPERTY prop) const;
796	+	bool isBlocking() const { return items[id].blockSolid; }
797	+	bool isStackable() const { return items[id].stackable; }
798	+	bool isAlwaysOnTop() const { return items[id].alwaysOnTop; }
799	+	bool isGroundTile() const { return items[id].isGroundTile(); }
800	+	bool isMagicField() const { return items[id].isMagicField(); }
801	+	bool isMoveable() const { return items[id].moveable; }
802	+	bool isPickupable() const { return items[id].pickupable; }
803	+	bool isUseable() const { return items[id].useable; }
804	+	bool isHangable() const { return items[id].isHangable; }
805	+	bool isRotatable() const {
806	+	const ItemType &it = items[id];
807	+	return it.rotatable && it.rotateTo;
808	+	}
809	+	bool hasWalkStack() const { return items[id].walkStack; }
810	+
811	+	const std::string &getName() const {
812	+	if (hasAttribute(ITEM_ATTRIBUTE_NAME)) {
813	+	return getStrAttr(ITEM_ATTRIBUTE_NAME);
814	+	}
815	+	return items[id].name;
816	+	}
817	+	const std::string getPluralName() const {
818	+	if (hasAttribute(ITEM_ATTRIBUTE_PLURALNAME)) {
819	+	return getStrAttr(ITEM_ATTRIBUTE_PLURALNAME);
820	+	}
821	+	return items[id].getPluralName();
822	+	}
823	+	const std::string &getArticle() const {
824	+	if (hasAttribute(ITEM_ATTRIBUTE_ARTICLE)) {
825	+	return getStrAttr(ITEM_ATTRIBUTE_ARTICLE);
826	+	}
827	+	return items[id].article;
828	+	}
829	+
830	+	// get the number of items
831	+	uint16_t getItemCount() const { return count; }
832	+	void setItemCount(uint8_t n) { count = n; }
833	+
834	+	static uint32_t countByType(const Item *i, int32_t subType) {
835	+	if (subType == -1 \|\| subType == i->getSubType()) {
836	+	return i->getItemCount();
837	+	}
838	+
839	+	return 0;
840	+	}
841	+
842	+	void setDefaultSubtype();
843	+	uint16_t getSubType() const;
844	+	void setSubType(uint16_t n);
845	+
846	+	void setUniqueId(uint16_t n);
847	+
848	+	void setDefaultDuration() {
849	+	uint32_t duration = getDefaultDuration();
850	+	if (duration != 0) {
851	+	setDuration(duration);
852	+	}
853	+	}
854	+	uint32_t getDefaultDuration() const { return items[id].decayTime * 1000; }
855	+	bool canDecay() const;
856	+
857	+	virtual bool canRemove() const { return true; }
858	+	virtual bool canTransform() const { return true; }
859	+	virtual void onRemoved();
860	+	virtual void onTradeEvent(TradeEvents_t, Player *) {}
861	+
862	+	virtual void startDecaying();
863	+
864	+	bool isLoadedFromMap() const { return loadedFromMap; }
865	+	void setLoadedFromMap(bool value) { loadedFromMap = value; }
866	+	bool isCleanable() const {
867	+	return !loadedFromMap && canRemove() && isPickupable() &&
868	+	!hasAttribute(ITEM_ATTRIBUTE_UNIQUEID) &&
869	+	!hasAttribute(ITEM_ATTRIBUTE_ACTIONID);
870	+	}
871	+
872	+	bool hasMarketAttributes() const;
873	+
874	+	std::unique_ptr<ItemAttributes> &getAttributes() {
875	+	if (!attributes) {
876	+	attributes.reset(new ItemAttributes());
877	+	}
878	+	return attributes;
879	+	}
880	+
881	+	void incrementReferenceCounter() { ++referenceCounter; }
882	+	void decrementReferenceCounter() {
883	+	if (--referenceCounter == 0) {
884	+	delete this;
885	+	}
886	+	}
887	+
888	+	Cylinder *getParent() const override { return parent; }
889	+	void setParent(Cylinder *cylinder) override { parent = cylinder; }
890	+	Cylinder *getTopParent();
891	+	const Cylinder *getTopParent() const;
892	+	Tile *getTile() override;
893	+	const Tile *getTile() const override;
894	+	bool isRemoved() const override { return !parent \|\| parent->isRemoved(); }
895	+
896	+	protected:
897	+	Cylinder *parent = nullptr;
898	+
899	+	uint16_t id; // the same id as in ItemType
900	+
901	+	private:
902	+	std::string getWeightDescription(uint32_t weight) const;
903	+
904	+	std::unique_ptr<ItemAttributes> attributes;
905	+
906	+	uint32_t referenceCounter = 0;
907	+
908	+	uint8_t count = 1; // number of stacked items
909	+
910	+	bool loadedFromMap = false;
911	+
912	+	// Don't add variables here, use the ItemAttribute class.
913	+	};
914	+
915	+	using ItemList = std::list<Item *>;
916	+	using ItemDeque = std::deque<Item *>;
917	+
918	+	#endif

A src/itemloader.h +198-0 View file

		@@ -0,0 +1,198 @@
1	+	/**
2	+	* The Forgotten Server - a free and open-source MMORPG server emulator
3	+	* Copyright (C) 2019 Mark Samman <mark.samman@gmail.com>
4	+	*
5	+	* This program is free software; you can redistribute it and/or modify
6	+	* it under the terms of the GNU General Public License as published by
7	+	* the Free Software Foundation; either version 2 of the License, or
8	+	* (at your option) any later version.
9	+	*
10	+	* This program is distributed in the hope that it will be useful,
11	+	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	+	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	+	* GNU General Public License for more details.
14	+	*
15	+	* You should have received a copy of the GNU General Public License along
16	+	* with this program; if not, write to the Free Software Foundation, Inc.,
17	+	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18	+	*/
19	+
20	+	#ifndef FS_ITEMLOADER_H_107F1D3EECC94CD0A0F528843010D5D4
21	+	#define FS_ITEMLOADER_H_107F1D3EECC94CD0A0F528843010D5D4
22	+
23	+	#include "fileloader.h"
24	+
25	+	enum itemgroup_t {
26	+	ITEM_GROUP_NONE,
27	+
28	+	ITEM_GROUP_GROUND,
29	+	ITEM_GROUP_CONTAINER,
30	+	ITEM_GROUP_WEAPON, //deprecated
31	+	ITEM_GROUP_AMMUNITION, //deprecated
32	+	ITEM_GROUP_ARMOR, //deprecated
33	+	ITEM_GROUP_CHARGES,
34	+	ITEM_GROUP_TELEPORT, //deprecated
35	+	ITEM_GROUP_MAGICFIELD, //deprecated
36	+	ITEM_GROUP_WRITEABLE, //deprecated
37	+	ITEM_GROUP_KEY, //deprecated
38	+	ITEM_GROUP_SPLASH,
39	+	ITEM_GROUP_FLUID,
40	+	ITEM_GROUP_DOOR, //deprecated
41	+	ITEM_GROUP_DEPRECATED,
42	+
43	+	ITEM_GROUP_LAST
44	+	};
45	+
46	+	/////////OTB specific//////////////
47	+	enum clientVersion_t {
48	+	CLIENT_VERSION_750 = 1,
49	+	CLIENT_VERSION_755 = 2,
50	+	CLIENT_VERSION_760 = 3,
51	+	CLIENT_VERSION_770 = 3,
52	+	CLIENT_VERSION_780 = 4,
53	+	CLIENT_VERSION_790 = 5,
54	+	CLIENT_VERSION_792 = 6,
55	+	CLIENT_VERSION_800 = 7,
56	+	CLIENT_VERSION_810 = 8,
57	+	CLIENT_VERSION_811 = 9,
58	+	CLIENT_VERSION_820 = 10,
59	+	CLIENT_VERSION_830 = 11,
60	+	CLIENT_VERSION_840 = 12,
61	+	CLIENT_VERSION_841 = 13,
62	+	CLIENT_VERSION_842 = 14,
63	+	CLIENT_VERSION_850 = 15,
64	+	CLIENT_VERSION_854_BAD = 16,
65	+	CLIENT_VERSION_854 = 17,
66	+	CLIENT_VERSION_855 = 18,
67	+	CLIENT_VERSION_860_OLD = 19,
68	+	CLIENT_VERSION_860 = 20,
69	+	CLIENT_VERSION_861 = 21,
70	+	CLIENT_VERSION_862 = 22,
71	+	CLIENT_VERSION_870 = 23,
72	+	CLIENT_VERSION_871 = 24,
73	+	CLIENT_VERSION_872 = 25,
74	+	CLIENT_VERSION_873 = 26,
75	+	CLIENT_VERSION_900 = 27,
76	+	CLIENT_VERSION_910 = 28,
77	+	CLIENT_VERSION_920 = 29,
78	+	CLIENT_VERSION_940 = 30,
79	+	CLIENT_VERSION_944_V1 = 31,
80	+	CLIENT_VERSION_944_V2 = 32,
81	+	CLIENT_VERSION_944_V3 = 33,
82	+	CLIENT_VERSION_944_V4 = 34,
83	+	CLIENT_VERSION_946 = 35,
84	+	CLIENT_VERSION_950 = 36,
85	+	CLIENT_VERSION_952 = 37,
86	+	CLIENT_VERSION_953 = 38,
87	+	CLIENT_VERSION_954 = 39,
88	+	CLIENT_VERSION_960 = 40,
89	+	CLIENT_VERSION_961 = 41,
90	+	CLIENT_VERSION_963 = 42,
91	+	CLIENT_VERSION_970 = 43,
92	+	CLIENT_VERSION_980 = 44,
93	+	CLIENT_VERSION_981 = 45,
94	+	CLIENT_VERSION_982 = 46,
95	+	CLIENT_VERSION_983 = 47,
96	+	CLIENT_VERSION_985 = 48,
97	+	CLIENT_VERSION_986 = 49,
98	+	CLIENT_VERSION_1010 = 50,
99	+	CLIENT_VERSION_1020 = 51,
100	+	CLIENT_VERSION_1021 = 52,
101	+	CLIENT_VERSION_1030 = 53,
102	+	CLIENT_VERSION_1031 = 54,
103	+	CLIENT_VERSION_1035 = 55,
104	+	CLIENT_VERSION_1076 = 56,
105	+	CLIENT_VERSION_1098 = 57,
106	+	};
107	+
108	+	enum rootattrib_ {
109	+	ROOT_ATTR_VERSION = 0x01,
110	+	};
111	+
112	+	enum itemattrib_t {
113	+	ITEM_ATTR_FIRST = 0x10,
114	+	ITEM_ATTR_SERVERID = ITEM_ATTR_FIRST,
115	+	ITEM_ATTR_CLIENTID,
116	+	ITEM_ATTR_NAME,
117	+	ITEM_ATTR_DESCR,
118	+	ITEM_ATTR_SPEED,
119	+	ITEM_ATTR_SLOT,
120	+	ITEM_ATTR_MAXITEMS,
121	+	ITEM_ATTR_WEIGHT,
122	+	ITEM_ATTR_WEAPON,
123	+	ITEM_ATTR_AMU,
124	+	ITEM_ATTR_ARMOR,
125	+	ITEM_ATTR_MAGLEVEL,
126	+	ITEM_ATTR_MAGFIELDTYPE,
127	+	ITEM_ATTR_WRITEABLE,
128	+	ITEM_ATTR_ROTATETO,
129	+	ITEM_ATTR_DECAY,
130	+	ITEM_ATTR_SPRITEHASH,
131	+	ITEM_ATTR_MINIMAPCOLOR,
132	+	ITEM_ATTR_07,
133	+	ITEM_ATTR_08,
134	+	ITEM_ATTR_LIGHT,
135	+
136	+	//1-byte aligned
137	+	ITEM_ATTR_DECAY2, //deprecated
138	+	ITEM_ATTR_WEAPON2, //deprecated
139	+	ITEM_ATTR_AMU2, //deprecated
140	+	ITEM_ATTR_ARMOR2, //deprecated
141	+	ITEM_ATTR_WRITEABLE2, //deprecated
142	+	ITEM_ATTR_LIGHT2,
143	+	ITEM_ATTR_TOPORDER,
144	+	ITEM_ATTR_WRITEABLE3, //deprecated
145	+
146	+	ITEM_ATTR_WAREID,
147	+
148	+	ITEM_ATTR_LAST
149	+	};
150	+
151	+	enum itemflags_t {
152	+	FLAG_BLOCK_SOLID = 1 << 0,
153	+	FLAG_BLOCK_PROJECTILE = 1 << 1,
154	+	FLAG_BLOCK_PATHFIND = 1 << 2,
155	+	FLAG_HAS_HEIGHT = 1 << 3,
156	+	FLAG_USEABLE = 1 << 4,
157	+	FLAG_PICKUPABLE = 1 << 5,
158	+	FLAG_MOVEABLE = 1 << 6,
159	+	FLAG_STACKABLE = 1 << 7,
160	+	FLAG_FLOORCHANGEDOWN = 1 << 8, // unused
161	+	FLAG_FLOORCHANGENORTH = 1 << 9, // unused
162	+	FLAG_FLOORCHANGEEAST = 1 << 10, // unused
163	+	FLAG_FLOORCHANGESOUTH = 1 << 11, // unused
164	+	FLAG_FLOORCHANGEWEST = 1 << 12, // unused
165	+	FLAG_ALWAYSONTOP = 1 << 13,
166	+	FLAG_READABLE = 1 << 14,
167	+	FLAG_ROTATABLE = 1 << 15,
168	+	FLAG_HANGABLE = 1 << 16,
169	+	FLAG_VERTICAL = 1 << 17,
170	+	FLAG_HORIZONTAL = 1 << 18,
171	+	FLAG_CANNOTDECAY = 1 << 19, // unused
172	+	FLAG_ALLOWDISTREAD = 1 << 20,
173	+	FLAG_UNUSED = 1 << 21, // unused
174	+	FLAG_CLIENTCHARGES = 1 << 22, /* deprecated */
175	+	FLAG_LOOKTHROUGH = 1 << 23,
176	+	FLAG_ANIMATION = 1 << 24,
177	+	FLAG_FULLTILE = 1 << 25, // unused
178	+	FLAG_FORCEUSE = 1 << 26,
179	+	};
180	+
181	+	//1-byte aligned structs
182	+	#pragma pack(1)
183	+
184	+	struct VERSIONINFO {
185	+	uint32_t dwMajorVersion;
186	+	uint32_t dwMinorVersion;
187	+	uint32_t dwBuildNumber;
188	+	uint8_t CSDVersion[128];
189	+	};
190	+
191	+	struct lightBlock2 {
192	+	uint16_t lightLevel;
193	+	uint16_t lightColor;
194	+	};
195	+
196	+	#pragma pack()
197	+	/////////OTB specific//////////////
198	+	#endif