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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.226 by root, Sat May 3 08:50:30 2008 UTC vs.
Revision 1.237 by root, Tue May 6 21:04:37 2008 UTC

…		…
139		139
140	/* Returns TRUE if every key_values in wants has a partner with the same value in has. */	140	/* Returns TRUE if every key_values in wants has a partner with the same value in has. */
141	static bool	141	static bool
142	compare_ob_value_lists_one (const object wants, const object has)	142	compare_ob_value_lists_one (const object wants, const object has)
143	{	143	{
144	key_value *wants_field;
145
146	/* n-squared behaviour (see get_ob_key_link()), but I'm hoping both	144	/* n-squared behaviour (see kv_get), but I'm hoping both
147	* objects with lists are rare, and lists stay short. If not, use a	145	* objects with lists are rare, and lists stay short. If not, use a
148	* different structure or at least keep the lists sorted...	146	* different structure or at least keep the lists sorted...
149	*/	147	*/
150		148
151	/* For each field in wants, */	149	/* For each field in wants, */
152	for (wants_field = wants->key_values; wants_field; wants_field = wants_field->next)	150	for (key_value *kv = wants->key_values; kv; kv = kv->next)
153	{	151	if (has->kv_get (kv->key) != kv->value)
154	key_value *has_field;	152	return false;
155
156	/* Look for a field in has with the same key. */
157	has_field = get_ob_key_link (has, wants_field->key);
158
159	if (!has_field)
160	return 0; /* No field with that name. */
161
162	/* Found the matching field. */
163	if (has_field->value != wants_field->value)
164	return 0; /* Values don't match, so this half of the comparison is false. */
165
166	/* If we get here, we found a match. Now for the next field in wants. */
167	}
168		153
169	/* If we get here, every field in wants has a matching field in has. */	154	/* If we get here, every field in wants has a matching field in has. */
170	return 1;	155	return true;
171	}	156	}
172		157
173	/* Returns TRUE if ob1 has the same key_values as ob2. */	158	/* Returns TRUE if ob1 has the same key_values as ob2. */
174	static bool	159	static bool
175	compare_ob_value_lists (const object ob1, const object ob2)	160	compare_ob_value_lists (const object ob1, const object ob2)
176	{	161	{
177	/* However, there may be fields in has which aren't partnered in wants,	162	/* However, there may be fields in has which aren't partnered in wants,
178	* so we need to run the comparison twice. :(	163	* so we need to run the comparison twice. :(
179	*/	164	*/
180	return compare_ob_value_lists_one (ob1, ob2) && compare_ob_value_lists_one (ob2, ob1);	165	return compare_ob_value_lists_one (ob1, ob2)
		166	&& compare_ob_value_lists_one (ob2, ob1);
181	}	167	}
182		168
183	/* Function examines the 2 objects given to it, and returns true if	169	/* Function examines the 2 objects given to it, and returns true if
184	* they can be merged together.	170	* they can be merged together.
185	*	171	*
…		…
368	return 0;	354	return 0;
369	}	355	}
370		356
371	// adjust weight per container type ("of holding")	357	// adjust weight per container type ("of holding")
372	static sint32	358	static sint32
373	weight_adjust (object *op, sint32 weight)	359	weight_adjust_for (object *op, sint32 weight)
374	{	360	{
375	return op->type == CONTAINER	361	return op->type == CONTAINER
376	? lerp (weight, 0, 100, 0, 100 - op->stats.Str)	362	? lerp (weight, 0, 100, 0, 100 - op->stats.Str)
377	: weight;	363	: weight;
378	}	364	}
…		…
384	static void	370	static void
385	adjust_weight (object *op, sint32 weight)	371	adjust_weight (object *op, sint32 weight)
386	{	372	{
387	while (op)	373	while (op)
388	{	374	{
		375	// adjust by actual difference to account for rounding errors
		376	// i.e. (w2 - w1) / f != w2 / f - w1 / f and the latter is correct
389	weight = weight_adjust (op, weight);	377	weight = weight_adjust_for (op, op->carrying)
		378	- weight_adjust_for (op, op->carrying - weight);
390		379
391	if (!weight)	380	if (!weight)
392	return;	381	return;
393		382
394	op->carrying += weight;	383	op->carrying += weight;
…		…
417	op->update_weight ();	406	op->update_weight ();
418		407
419	sum += op->total_weight ();	408	sum += op->total_weight ();
420	}	409	}
421		410
422	sum = weight_adjust (this, sum);	411	sum = weight_adjust_for (this, sum);
423		412
424	if (sum != carrying)	413	if (sum != carrying)
425	{	414	{
426	carrying = sum;	415	carrying = sum;
427		416
…		…
603	}	592	}
604		593
605	op->key_values = 0;	594	op->key_values = 0;
606	}	595	}
607		596
608	object &	597	/*
609	object::operator =(const object &src)	598	* copy_to first frees everything allocated by the dst object,
		599	* and then copies the contents of itself into the second
		600	* object, allocating what needs to be allocated. Basically, any
		601	* data that is malloc'd needs to be re-malloc/copied. Otherwise,
		602	* if the first object is freed, the pointers in the new object
		603	* will point at garbage.
		604	*/
		605	void
		606	object::copy_to (object *dst)
610	{	607	{
611	remove ();	608	dst->remove ();
612
613	(object_copy )this = src;	609	(object_copy )dst = *this;
614
615	flag [FLAG_REMOVED] = true;	610	dst->flag [FLAG_REMOVED] = true;
616		611
617	/* Copy over key_values, if any. */	612	/* Copy over key_values, if any. */
618	if (src.key_values)	613	if (key_values)
619	{	614	{
620	key_value *tail = 0;	615	key_value *tail = 0;
621	key_values = 0;	616	dst->key_values = 0;
622		617
623	for (key_value *i = src.key_values; i; i = i->next)	618	for (key_value *i = key_values; i; i = i->next)
624	{	619	{
625	key_value *new_link = new key_value;	620	key_value *new_link = new key_value;
626		621
627	new_link->next = 0;	622	new_link->next = 0;
628	new_link->key = i->key;	623	new_link->key = i->key;
629	new_link->value = i->value;	624	new_link->value = i->value;
630		625
631	/* Try and be clever here, too. */	626	/* Try and be clever here, too. */
632	if (!key_values)	627	if (!dst->key_values)
633	{	628	{
634	key_values = new_link;	629	dst->key_values = new_link;
635	tail = new_link;	630	tail = new_link;
636	}	631	}
637	else	632	else
638	{	633	{
639	tail->next = new_link;	634	tail->next = new_link;
640	tail = new_link;	635	tail = new_link;
641	}	636	}
642	}	637	}
643	}	638	}
644	}
645
646	/*
647	* copy_to first frees everything allocated by the dst object,
648	* and then copies the contents of itself into the second
649	* object, allocating what needs to be allocated. Basically, any
650	* data that is malloc'd needs to be re-malloc/copied. Otherwise,
651	* if the first object is freed, the pointers in the new object
652	* will point at garbage.
653	*/
654	void
655	object::copy_to (object *dst)
656	{
657	dst = this;
658		639
659	if (speed < 0)	640	if (speed < 0)
660	dst->speed_left -= rndm ();	641	dst->speed_left -= rndm ();
661		642
662	dst->set_speed (dst->speed);	643	dst->set_speed (dst->speed);
…		…
971	nodrop = 1;	952	nodrop = 1;
972		953
973	alloc ();	954	alloc ();
974	in_memory = MAP_ACTIVE;	955	in_memory = MAP_ACTIVE;
975	}	956	}
		957
		958	~freed_map ()
		959	{
		960	destroy ();
		961	}
976	} freed_map; // freed objects are moved here to avoid crashes	962	} freed_map; // freed objects are moved here to avoid crashes
977		963
978	void	964	void
979	object::do_destroy ()	965	object::do_destroy ()
980	{	966	{
…		…
1070	if (object *pl = visible_to ())	1056	if (object *pl = visible_to ())
1071	esrv_del_item (pl->contr, count);	1057	esrv_del_item (pl->contr, count);
1072	flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed	1058	flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed
1073		1059
1074	adjust_weight (env, -total_weight ());	1060	adjust_weight (env, -total_weight ());
1075
1076	*(above ? &above->below : &env->inv) = below;
1077
1078	if (below)
1079	below->above = above;
1080		1061
1081	/* we set up values so that it could be inserted into	1062	/* we set up values so that it could be inserted into
1082	* the map, but we don't actually do that - it is up	1063	* the map, but we don't actually do that - it is up
1083	* to the caller to decide what we want to do.	1064	* to the caller to decide what we want to do.
1084	*/	1065	*/
1085	map = env->map;	1066	map = env->map;
1086	x = env->x;	1067	x = env->x;
1087	y = env->y;	1068	y = env->y;
		1069
		1070	// make sure cmov optimisation is applicable
		1071	*(above ? &above->below : &env->inv) = below;
		1072	*(below ? &below->above : &above ) = above; // &above is just a dummy
		1073
1088	above = 0;	1074	above = 0;
1089	below = 0;	1075	below = 0;
1090	env = 0;	1076	env = 0;
1091		1077
1092	/* NO_FIX_PLAYER is set when a great many changes are being	1078	/* NO_FIX_PLAYER is set when a great many changes are being
…		…
1122		1108
1123	esrv_del_item (pl->contr, count);	1109	esrv_del_item (pl->contr, count);
1124	}	1110	}
1125		1111
1126	/* link the object above us */	1112	/* link the object above us */
1127	if (above)	1113	// re-link, make sure compiler can easily use cmove
1128	above->below = below;	1114	*(above ? &above->below : &ms.top) = below;
1129	else	1115	*(below ? &below->above : &ms.bot) = above;
1130	ms.top = below; /* we were top, set new top */
1131
1132	/* Relink the object below us, if there is one */
1133	if (below)
1134	below->above = above;
1135	else
1136	{
1137	/* Nothing below, which means we need to relink map object for this space
1138	* use translated coordinates in case some oddness with map tiling is
1139	* evident
1140	*/
1141	if (GET_MAP_OB (map, x, y) != this)
1142	LOG (llevError, "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom? %s\n", debug_desc ());
1143
1144	ms.bot = above; /* goes on above it. */
1145	}
1146		1116
1147	above = 0;	1117	above = 0;
1148	below = 0;	1118	below = 0;
1149		1119
1150	if (map->in_memory == MAP_SAVING)	1120	if (map->in_memory == MAP_SAVING)
…		…
1297	* just 'op' otherwise	1267	* just 'op' otherwise
1298	*/	1268	*/
1299	object *	1269	object *
1300	insert_ob_in_map (object op, maptile m, object *originator, int flag)	1270	insert_ob_in_map (object op, maptile m, object *originator, int flag)
1301	{	1271	{
1302	assert (!op->flag [FLAG_FREED]);
1303
1304	op->remove ();	1272	op->remove ();
1305		1273
1306	/* Ideally, the caller figures this out. However, it complicates a lot	1274	/* Ideally, the caller figures this out. However, it complicates a lot
1307	* of areas of callers (eg, anything that uses find_free_spot would now	1275	* of areas of callers (eg, anything that uses find_free_spot would now
1308	* need extra work	1276	* need extra work
1309	*/	1277	*/
1310	if (!xy_normalise (m, op->x, op->y))	1278	if (!xy_normalise (m, op->x, op->y))
1311	{	1279	{
1312	op->destroy (1);	1280	op->head_ ()->destroy (1);// remove head_ once all tail object destroyers found
1313	return 0;	1281	return 0;
1314	}	1282	}
1315		1283
1316	if (object *more = op->more)	1284	if (object *more = op->more)
1317	if (!insert_ob_in_map (more, m, originator, flag))	1285	if (!insert_ob_in_map (more, m, originator, flag))
…		…
1326	*/	1294	*/
1327	if (op->nrof && !(flag & INS_NO_MERGE))	1295	if (op->nrof && !(flag & INS_NO_MERGE))
1328	for (object *tmp = ms.bot; tmp; tmp = tmp->above)	1296	for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1329	if (object::can_merge (op, tmp))	1297	if (object::can_merge (op, tmp))
1330	{	1298	{
1331	// TODO: we atcually want to update tmp, not op,	1299	// TODO: we actually want to update tmp, not op,
1332	// but some caller surely breaks when we return tmp	1300	// but some caller surely breaks when we return tmp
1333	// from here :/	1301	// from here :/
1334	op->nrof += tmp->nrof;	1302	op->nrof += tmp->nrof;
1335	tmp->destroy (1);	1303	tmp->destroy (1);
1336	}	1304	}
…		…
1341	if (!QUERY_FLAG (op, FLAG_ALIVE))	1309	if (!QUERY_FLAG (op, FLAG_ALIVE))
1342	CLEAR_FLAG (op, FLAG_NO_STEAL);	1310	CLEAR_FLAG (op, FLAG_NO_STEAL);
1343		1311
1344	if (flag & INS_BELOW_ORIGINATOR)	1312	if (flag & INS_BELOW_ORIGINATOR)
1345	{	1313	{
1346	if (originator->map != op->map \|\| originator->x != op->x \|\| originator->y != op->y)	1314	if (originator->map != op->map \|\| originator->x != op->x \|\| originator->y != op->y \|\| !originator->is_on_map ())
1347	{	1315	{
1348	LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");	1316	LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1349	abort ();	1317	abort ();
1350	}	1318	}
1351		1319
1352	op->above = originator;	1320	op->above = originator;
1353	op->below = originator->below;	1321	op->below = originator->below;
1354
1355	if (op->below)
1356	op->below->above = op;
1357	else
1358	ms.bot = op;
1359
1360	/* since below originator, no need to update top */
1361	originator->below = op;	1322	originator->below = op;
		1323
		1324	*(op->below ? &op->below->above : &ms.bot) = op;
1362	}	1325	}
1363	else	1326	else
1364	{	1327	{
1365	object top, floor = NULL;	1328	object *floor = 0;
1366		1329	object *top = ms.top;
1367	top = ms.bot;
1368		1330
1369	/* If there are other objects, then */	1331	/* If there are other objects, then */
1370	if (top)	1332	if (top)
1371	{	1333	{
1372	object *last = 0;
1373
1374	/*	1334	/*
1375	* If there are multiple objects on this space, we do some trickier handling.	1335	* If there are multiple objects on this space, we do some trickier handling.
1376	* We've already dealt with merging if appropriate.	1336	* We've already dealt with merging if appropriate.
1377	* Generally, we want to put the new object on top. But if	1337	* Generally, we want to put the new object on top. But if
1378	* flag contains INS_ABOVE_FLOOR_ONLY, once we find the last	1338	* flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
…		…
1381	* once we get to them. This reduces the need to traverse over all of	1341	* once we get to them. This reduces the need to traverse over all of
1382	* them when adding another one - this saves quite a bit of cpu time	1342	* them when adding another one - this saves quite a bit of cpu time
1383	* when lots of spells are cast in one area. Currently, it is presumed	1343	* when lots of spells are cast in one area. Currently, it is presumed
1384	* that flying non pickable objects are spell objects.	1344	* that flying non pickable objects are spell objects.
1385	*/	1345	*/
1386	for (top = ms.bot; top; top = top->above)	1346	for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1387	{	1347	{
1388	if (QUERY_FLAG (top, FLAG_IS_FLOOR) \|\| QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))	1348	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) \|\| QUERY_FLAG (tmp, FLAG_OVERLAY_FLOOR))
1389	floor = top;	1349	floor = tmp;
1390		1350
1391	if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW \| MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR))	1351	if (QUERY_FLAG (tmp, FLAG_NO_PICK) && (tmp->move_type & (MOVE_FLY_LOW \| MOVE_FLY_HIGH)) && !QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1392	{	1352	{
1393	/* We insert above top, so we want this object below this */	1353	/* We insert above top, so we want this object below this */
1394	top = top->below;	1354	top = tmp->below;
1395	break;	1355	break;
1396	}	1356	}
1397		1357
1398	last = top;	1358	top = tmp;
1399	}	1359	}
1400
1401	/* Don't want top to be NULL, so set it to the last valid object */
1402	top = last;
1403		1360
1404	/* We let update_position deal with figuring out what the space	1361	/* We let update_position deal with figuring out what the space
1405	* looks like instead of lots of conditions here.	1362	* looks like instead of lots of conditions here.
1406	* makes things faster, and effectively the same result.	1363	* makes things faster, and effectively the same result.
1407	*/	1364	*/
…		…
1414	*/	1371	*/
1415	if (!(flag & INS_ON_TOP)	1372	if (!(flag & INS_ON_TOP)
1416	&& ms.flags () & P_BLOCKSVIEW	1373	&& ms.flags () & P_BLOCKSVIEW
1417	&& (op->face && !faces [op->face].visibility))	1374	&& (op->face && !faces [op->face].visibility))
1418	{	1375	{
		1376	object *last;
		1377
1419	for (last = top; last != floor; last = last->below)	1378	for (last = top; last != floor; last = last->below)
1420	if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))	1379	if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
1421	break;	1380	break;
1422		1381
1423	/* Check to see if we found the object that blocks view,	1382	/* Check to see if we found the object that blocks view,
…		…
1434	top = floor;	1393	top = floor;
1435		1394
1436	/* Top is the object that our object (op) is going to get inserted above.	1395	/* Top is the object that our object (op) is going to get inserted above.
1437	*/	1396	*/
1438		1397
1439	/* First object on this space */	1398	/* no top found, insert on top */
1440	if (!top)	1399	if (!top)
1441	{	1400	{
1442	op->above = ms.bot;
1443
1444	if (op->above)
1445	op->above->below = op;
1446
1447	op->below = 0;	1401	op->above = 0;
		1402	op->below = ms.top;
1448	ms.bot = op;	1403	ms.top = op;
		1404
		1405	*(op->below ? &op->below->above : &ms.bot) = op;
1449	}	1406	}
1450	else	1407	else
1451	{ /* get inserted into the stack above top */	1408	{ /* get inserted into the stack above top */
1452	op->above = top->above;	1409	op->above = top->above;
1453
1454	if (op->above)
1455	op->above->below = op;	1410	top->above = op;
1456		1411
1457	op->below = top;	1412	op->below = top;
1458	top->above = op;	1413	*(op->above ? &op->above->below : &ms.top) = op;
1459	}	1414	}
1460
1461	if (!op->above)
1462	ms.top = op;
1463	} /* else not INS_BELOW_ORIGINATOR */	1415	} /* else not INS_BELOW_ORIGINATOR */
1464		1416
1465	if (op->type == PLAYER)	1417	if (op->type == PLAYER)
1466	{	1418	{
1467	op->contr->do_los = 1;	1419	op->contr->do_los = 1;
…		…
1604	}	1556	}
1605	else	1557	else
1606	{	1558	{
1607	decrease (nr);	1559	decrease (nr);
1608		1560
1609	object *op = object_create_clone (this);	1561	object *op = deep_clone ();
1610	op->nrof = nr;	1562	op->nrof = nr;
1611	return op;	1563	return op;
1612	}	1564	}
1613	}	1565	}
1614		1566
…		…
1835	LOG (llevError, "Present_arch called outside map.\n");	1787	LOG (llevError, "Present_arch called outside map.\n");
1836	return NULL;	1788	return NULL;
1837	}	1789	}
1838		1790
1839	for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)	1791	for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
1840	if (tmp->arch == at)	1792	if (tmp->arch->archname == at->archname)
1841	return tmp;	1793	return tmp;
1842		1794
1843	return NULL;	1795	return NULL;
1844	}	1796	}
1845		1797
…		…
1909	* The first matching object is returned, or NULL if none.	1861	* The first matching object is returned, or NULL if none.
1910	*/	1862	*/
1911	object *	1863	object *
1912	present_arch_in_ob (const archetype at, const object op)	1864	present_arch_in_ob (const archetype at, const object op)
1913	{	1865	{
1914	for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below)	1866	for (object *tmp = op->inv; tmp; tmp = tmp->below)
1915	if (tmp->arch == at)	1867	if (tmp->arch->archname == at->archname)
1916	return tmp;	1868	return tmp;
1917		1869
1918	return NULL;	1870	return NULL;
1919	}	1871	}
1920		1872
…		…
2329		2281
2330	/*	2282	/*
2331	* create clone from object to another	2283	* create clone from object to another
2332	*/	2284	*/
2333	object *	2285	object *
2334	object_create_clone (object *asrc)	2286	object::deep_clone ()
2335	{	2287	{
		2288	assert (("deep_clone called on non-head object", is_head ()));
		2289
2336	object *dst = 0;	2290	object *dst = clone ();
2337		2291
2338	if (!asrc)
2339	return 0;
2340
2341	object *src = asrc->head_ ();
2342
2343	object *prev = 0;	2292	object *prev = dst;
2344	for (object *part = src; part; part = part->more)	2293	for (object *part = this->more; part; part = part->more)
2345	{	2294	{
2346	object *tmp = part->clone ();	2295	object *tmp = part->clone ();
2347
2348	tmp->x -= src->x;
2349	tmp->y -= src->y;
2350
2351	if (!part->head)
2352	{
2353	dst = tmp;
2354	tmp->head = 0;
2355	}
2356	else
2357	tmp->head = dst;	2296	tmp->head = dst;
2358
2359	tmp->more = 0;
2360
2361	if (prev)
2362	prev->more = tmp;	2297	prev->more = tmp;
2363
2364	prev = tmp;	2298	prev = tmp;
2365	}	2299	}
2366		2300
2367	for (object *item = src->inv; item; item = item->below)	2301	for (object *item = inv; item; item = item->below)
2368	insert_ob_in_ob (object_create_clone (item), dst);	2302	insert_ob_in_ob (item->deep_clone (), dst);
2369		2303
2370	return dst;	2304	return dst;
2371	}	2305	}
2372		2306
2373	/* This returns the first object in who's inventory that	2307	/* This returns the first object in who's inventory that
…		…
2382	return tmp;	2316	return tmp;
2383		2317
2384	return 0;	2318	return 0;
2385	}	2319	}
2386		2320
2387	/* If ob has a field named key, return the link from the list,	2321	const shstr &
2388	* otherwise return NULL.	2322	object::kv_get (const shstr &key) const
2389	*
2390	* key must be a passed in shared string - otherwise, this won't
2391	* do the desired thing.
2392	*/
2393	key_value *
2394	get_ob_key_link (const object ob, const char key)
2395	{	2323	{
2396	for (key_value *link = ob->key_values; link; link = link->next)	2324	for (key_value *kv = key_values; kv; kv = kv->next)
2397	if (link->key == key)	2325	if (kv->key == key)
2398	return link;
2399
2400	return 0;
2401	}
2402
2403	/*
2404	* Returns the value of op has an extra_field for key, or NULL.
2405	*
2406	* The argument doesn't need to be a shared string.
2407	*
2408	* The returned string is shared.
2409	*/
2410	const char *
2411	get_ob_key_value (const object op, const char const key)
2412	{
2413	key_value *link;
2414	shstr_cmp canonical_key (key);
2415
2416	if (!canonical_key)
2417	{
2418	/* 1. There being a field named key on any object
2419	* implies there'd be a shared string to find.
2420	* 2. Since there isn't, no object has this field.
2421	* 3. Therefore, this object doesn't have this field.
2422	*/
2423	return 0;
2424	}
2425
2426	/* This is copied from get_ob_key_link() above -
2427	* only 4 lines, and saves the function call overhead.
2428	*/
2429	for (link = op->key_values; link; link = link->next)
2430	if (link->key == canonical_key)
2431	return link->value;	2326	return kv->value;
2432		2327
2433	return 0;	2328	return shstr_null;
2434	}	2329	}
2435		2330
2436	/*	2331	void
2437	* Updates the canonical_key in op to value.	2332	object::kv_set (const shstr &key, const shstr &value)
2438	*
2439	* canonical_key is a shared string (value doesn't have to be).
2440	*
2441	* Unless add_key is TRUE, it won't add fields, only change the value of existing
2442	* keys.
2443	*
2444	* Returns TRUE on success.
2445	*/
2446	int
2447	set_ob_key_value_s (object op, const shstr & canonical_key, const char value, int add_key)
2448	{	2333	{
2449	key_value field = NULL, last = NULL;	2334	for (key_value *kv = key_values; kv; kv = kv->next)
2450		2335	if (kv->key == key)
2451	for (field = op->key_values; field != NULL; field = field->next)
2452	{
2453	if (field->key != canonical_key)
2454	{	2336	{
2455	last = field;	2337	kv->value = value;
2456	continue;	2338	return;
2457	}	2339	}
2458		2340
2459	if (value)	2341	key_value *kv = new key_value;
2460	field->value = value;	2342
2461	else	2343	kv->next = key_values;
		2344	kv->key = key;
		2345	kv->value = value;
		2346
		2347	key_values = kv;
		2348	}
		2349
		2350	void
		2351	object::kv_del (const shstr &key)
		2352	{
		2353	for (key_value *kvp = &key_values; kvp; kvp = &(*kvp)->next)
		2354	if ((*kvp)->key == key)
2462	{	2355	{
2463	/* Basically, if the archetype has this key set,	2356	key_value kv = kvp;
2464	* we need to store the null value so when we save	2357	kvp = (kvp)->next;
2465	* it, we save the empty value so that when we load,	2358	delete kv;
2466	* we get this value back again.	2359	return;
2467	*/
2468	if (get_ob_key_link (op->arch, canonical_key))
2469	field->value = 0;
2470	else
2471	{
2472	if (last)
2473	last->next = field->next;
2474	else
2475	op->key_values = field->next;
2476
2477	delete field;
2478	}
2479	}	2360	}
2480	return TRUE;
2481	}
2482	/* IF we get here, key doesn't exist */
2483
2484	/* No field, we'll have to add it. */
2485
2486	if (!add_key)
2487	return FALSE;
2488
2489	/* There isn't any good reason to store a null
2490	* value in the key/value list. If the archetype has
2491	* this key, then we should also have it, so shouldn't
2492	* be here. If user wants to store empty strings,
2493	* should pass in ""
2494	*/
2495	if (value == NULL)
2496	return TRUE;
2497
2498	field = new key_value;
2499
2500	field->key = canonical_key;
2501	field->value = value;
2502	/* Usual prepend-addition. */
2503	field->next = op->key_values;
2504	op->key_values = field;
2505
2506	return TRUE;
2507	}
2508
2509	/*
2510	* Updates the key in op to value.
2511	*
2512	* If add_key is FALSE, this will only update existing keys,
2513	* and not add new ones.
2514	* In general, should be little reason FALSE is ever passed in for add_key
2515	*
2516	* Returns TRUE on success.
2517	*/
2518	int
2519	set_ob_key_value (object op, const char key, const char *value, int add_key)
2520	{
2521	shstr key_ (key);
2522
2523	return set_ob_key_value_s (op, key_, value, add_key);
2524	}	2361	}
2525		2362
2526	object::depth_iterator::depth_iterator (object *container)	2363	object::depth_iterator::depth_iterator (object *container)
2527	: iterator_base (container)	2364	: iterator_base (container)
2528	{	2365	{

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.226 by root, Sat May 3 08:50:30 2008 UTC vs. Revision 1.237 by root, Tue May 6 21:04:37 2008 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.226 by root, Sat May 3 08:50:30 2008 UTC vs.
Revision 1.237 by root, Tue May 6 21:04:37 2008 UTC