ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/object.C
(Generate patch)

Comparing deliantra/server/common/object.C (file contents):
Revision 1.234 by root, Tue May 6 18:47:52 2008 UTC vs.
Revision 1.250 by root, Wed Jul 16 14:29:40 2008 UTC

… …
206 SET_FLAG (ob1, FLAG_BEEN_APPLIED); 206 SET_FLAG (ob1, FLAG_BEEN_APPLIED);
207 207
208 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) 208 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
209 SET_FLAG (ob2, FLAG_BEEN_APPLIED); 209 SET_FLAG (ob2, FLAG_BEEN_APPLIED);
210 210
211 if (ob1->arch->name != ob2->arch->name 211 if (ob1->arch->archname != ob2->arch->archname
212 || ob1->name != ob2->name 212 || ob1->name != ob2->name
213 || ob1->title != ob2->title 213 || ob1->title != ob2->title
214 || ob1->msg != ob2->msg 214 || ob1->msg != ob2->msg
215 || ob1->weight != ob2->weight 215 || ob1->weight != ob2->weight
216 || ob1->attacktype != ob2->attacktype 216 || ob1->attacktype != ob2->attacktype
217 || ob1->magic != ob2->magic 217 || ob1->magic != ob2->magic
218 || ob1->slaying != ob2->slaying 218 || ob1->slaying != ob2->slaying
219 || ob1->skill != ob2->skill 219 || ob1->skill != ob2->skill
220 || ob1->value != ob2->value 220 || ob1->value != ob2->value
221 || ob1->animation_id != ob2->animation_id 221 || ob1->animation_id != ob2->animation_id
222 || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependent on each other
222 || ob1->client_type != ob2->client_type 223 || ob1->client_type != ob2->client_type
223 || ob1->materialname != ob2->materialname 224 || ob1->materialname != ob2->materialname
224 || ob1->lore != ob2->lore 225 || ob1->lore != ob2->lore
225 || ob1->subtype != ob2->subtype 226 || ob1->subtype != ob2->subtype
226 || ob1->move_type != ob2->move_type 227 || ob1->move_type != ob2->move_type
… …
344 else 345 else
345 { 346 {
346 // maybe there is a player standing on the same mapspace 347 // maybe there is a player standing on the same mapspace
347 // this will catch the case where "this" is a player 348 // this will catch the case where "this" is a player
348 if (object *pl = ms ().player ()) 349 if (object *pl = ms ().player ())
350 if ((!pl->container && pl->contr->ns && !pl->contr->ns->update_look)
349 if (!pl->container || this == pl->container) 351 || this == pl->container)
350 return pl; 352 return pl;
351 } 353 }
352 } 354 }
353 355
354 return 0; 356 return 0;
… …
478 */ 480 */
479object * 481object *
480find_object_name (const char *str) 482find_object_name (const char *str)
481{ 483{
482 shstr_cmp str_ (str); 484 shstr_cmp str_ (str);
483 object *op;
484 485
486 if (str_)
485 for_all_objects (op) 487 for_all_objects (op)
486 if (op->name == str_) 488 if (op->name == str_)
487 break; 489 return op;
488 490
489 return op; 491 return 0;
490} 492}
491 493
492/* 494/*
493 * Sets the owner and sets the skill and exp pointers to owner's current 495 * Sets the owner and sets the skill and exp pointers to owner's current
494 * skill and experience objects. 496 * skill and experience objects.
… …
904 * drop on that space. 906 * drop on that space.
905 */ 907 */
906 if (!drop_to_ground 908 if (!drop_to_ground
907 || !map 909 || !map
908 || map->in_memory != MAP_ACTIVE 910 || map->in_memory != MAP_ACTIVE
909 || map->nodrop 911 || map->no_drop
910 || ms ().move_block == MOVE_ALL) 912 || ms ().move_block == MOVE_ALL)
911 { 913 {
912 while (inv) 914 while (inv)
913 {
914 inv->destroy_inv (false);
915 inv->destroy (); 915 inv->destroy (true);
916 }
917 } 916 }
918 else 917 else
919 { /* Put objects in inventory onto this space */ 918 { /* Put objects in inventory onto this space */
920 while (inv) 919 while (inv)
921 { 920 {
… …
943 942
944static struct freed_map : maptile 943static struct freed_map : maptile
945{ 944{
946 freed_map () 945 freed_map ()
947 { 946 {
948 path = "<freed objects map>"; 947 path = "<freed objects map>";
949 name = "/internal/freed_objects_map"; 948 name = "/internal/freed_objects_map";
950 width = 3; 949 width = 3;
951 height = 3; 950 height = 3;
952 nodrop = 1; 951 no_drop = 1;
952 no_reset = 1;
953 953
954 alloc (); 954 alloc ();
955 in_memory = MAP_ACTIVE; 955 in_memory = MAP_ACTIVE;
956 } 956 }
957 957
… …
1056 if (object *pl = visible_to ()) 1056 if (object *pl = visible_to ())
1057 esrv_del_item (pl->contr, count); 1057 esrv_del_item (pl->contr, count);
1058 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
1059 1059
1060 adjust_weight (env, -total_weight ()); 1060 adjust_weight (env, -total_weight ());
1061
1062 *(above ? &above->below : &env->inv) = below;
1063
1064 if (below)
1065 below->above = above;
1066 1061
1067 /* we set up values so that it could be inserted into 1062 /* we set up values so that it could be inserted into
1068 * 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
1069 * to the caller to decide what we want to do. 1064 * to the caller to decide what we want to do.
1070 */ 1065 */
1071 map = env->map; 1066 map = env->map;
1072 x = env->x; 1067 x = env->x;
1073 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
1074 above = 0; 1074 above = 0;
1075 below = 0; 1075 below = 0;
1076 env = 0; 1076 env = 0;
1077 1077
1078 /* 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
… …
1108 1108
1109 esrv_del_item (pl->contr, count); 1109 esrv_del_item (pl->contr, count);
1110 } 1110 }
1111 1111
1112 /* link the object above us */ 1112 /* link the object above us */
1113 if (above) 1113 // re-link, make sure compiler can easily use cmove
1114 above->below = below; 1114 *(above ? &above->below : &ms.top) = below;
1115 else 1115 *(below ? &below->above : &ms.bot) = above;
1116 ms.top = below; /* we were top, set new top */
1117
1118 /* Relink the object below us, if there is one */
1119 if (below)
1120 below->above = above;
1121 else
1122 {
1123 /* Nothing below, which means we need to relink map object for this space
1124 * use translated coordinates in case some oddness with map tiling is
1125 * evident
1126 */
1127 if (GET_MAP_OB (map, x, y) != this)
1128 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 ());
1129
1130 ms.bot = above; /* goes on above it. */
1131 }
1132 1116
1133 above = 0; 1117 above = 0;
1134 below = 0; 1118 below = 0;
1135 1119
1136 if (map->in_memory == MAP_SAVING) 1120 if (map->in_memory == MAP_SAVING)
… …
1251 * job preparing multi-part monsters. 1235 * job preparing multi-part monsters.
1252 */ 1236 */
1253object * 1237object *
1254insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y) 1238insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1255{ 1239{
1240 op->remove ();
1241
1256 for (object *tmp = op->head_ (); tmp; tmp = tmp->more) 1242 for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
1257 { 1243 {
1258 tmp->x = x + tmp->arch->x; 1244 tmp->x = x + tmp->arch->x;
1259 tmp->y = y + tmp->arch->y; 1245 tmp->y = y + tmp->arch->y;
1260 } 1246 }
… …
1283 * just 'op' otherwise 1269 * just 'op' otherwise
1284 */ 1270 */
1285object * 1271object *
1286insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1272insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1287{ 1273{
1288 assert (!op->flag [FLAG_FREED]); 1274 if (op->is_on_map ())
1275 {
1276 LOG (llevError, "insert_ob_in_map called for object already on map");
1277 abort ();
1278 }
1289 1279
1280 if (op->env)
1281 {
1282 LOG (llevError, "insert_ob_in_map called for object in an inventory (proceeding)");
1290 op->remove (); 1283 op->remove ();
1284 }
1285
1286 if (op->face && !face_info (op->face))//D TODO: remove soon
1287 {//D
1288 LOG (llevError | logBacktrace, "op->face out of bounds: %s", op->debug_desc ());//D
1289 op->face = 1;//D
1290 }//D
1291 1291
1292 /* Ideally, the caller figures this out. However, it complicates a lot 1292 /* Ideally, the caller figures this out. However, it complicates a lot
1293 * of areas of callers (eg, anything that uses find_free_spot would now 1293 * of areas of callers (eg, anything that uses find_free_spot would now
1294 * need extra work 1294 * need extra work
1295 */ 1295 */
… …
1312 */ 1312 */
1313 if (op->nrof && !(flag & INS_NO_MERGE)) 1313 if (op->nrof && !(flag & INS_NO_MERGE))
1314 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1314 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1315 if (object::can_merge (op, tmp)) 1315 if (object::can_merge (op, tmp))
1316 { 1316 {
1317 // TODO: we atcually want to update tmp, not op, 1317 // TODO: we actually want to update tmp, not op,
1318 // but some caller surely breaks when we return tmp 1318 // but some caller surely breaks when we return tmp
1319 // from here :/ 1319 // from here :/
1320 op->nrof += tmp->nrof; 1320 op->nrof += tmp->nrof;
1321 tmp->destroy (1); 1321 tmp->destroy (1);
1322 } 1322 }
… …
1333 { 1333 {
1334 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n"); 1334 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1335 abort (); 1335 abort ();
1336 } 1336 }
1337 1337
1338 if (!originator->is_on_map ())
1339 LOG (llevDebug | logBacktrace, "insert_ob_in_map(%s) called with INS_BELOW_ORIGINATOR when originator '%s' not on map",
1340 op->debug_desc (), originator->debug_desc ());
1341
1338 op->above = originator; 1342 op->above = originator;
1339 op->below = originator->below; 1343 op->below = originator->below;
1340
1341 if (op->below)
1342 op->below->above = op;
1343 else
1344 ms.bot = op;
1345
1346 /* since *below* originator, no need to update top */
1347 originator->below = op; 1344 originator->below = op;
1345
1346 *(op->below ? &op->below->above : &ms.bot) = op;
1348 } 1347 }
1349 else 1348 else
1350 { 1349 {
1351 object *top, *floor = NULL; 1350 object *floor = 0;
1352 1351 object *top = ms.top;
1353 top = ms.bot;
1354 1352
1355 /* If there are other objects, then */ 1353 /* If there are other objects, then */
1356 if (top) 1354 if (top)
1357 { 1355 {
1358 object *last = 0;
1359
1360 /* 1356 /*
1361 * If there are multiple objects on this space, we do some trickier handling. 1357 * If there are multiple objects on this space, we do some trickier handling.
1362 * We've already dealt with merging if appropriate. 1358 * We've already dealt with merging if appropriate.
1363 * Generally, we want to put the new object on top. But if 1359 * Generally, we want to put the new object on top. But if
1364 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last 1360 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
… …
1367 * once we get to them. This reduces the need to traverse over all of 1363 * once we get to them. This reduces the need to traverse over all of
1368 * them when adding another one - this saves quite a bit of cpu time 1364 * them when adding another one - this saves quite a bit of cpu time
1369 * when lots of spells are cast in one area. Currently, it is presumed 1365 * when lots of spells are cast in one area. Currently, it is presumed
1370 * that flying non pickable objects are spell objects. 1366 * that flying non pickable objects are spell objects.
1371 */ 1367 */
1372 for (top = ms.bot; top; top = top->above) 1368 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1373 { 1369 {
1374 if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR)) 1370 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || QUERY_FLAG (tmp, FLAG_OVERLAY_FLOOR))
1375 floor = top; 1371 floor = tmp;
1376 1372
1377 if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR)) 1373 if (QUERY_FLAG (tmp, FLAG_NO_PICK) && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1378 { 1374 {
1379 /* We insert above top, so we want this object below this */ 1375 /* We insert above top, so we want this object below this */
1380 top = top->below; 1376 top = tmp->below;
1381 break; 1377 break;
1382 } 1378 }
1383 1379
1384 last = top; 1380 top = tmp;
1385 } 1381 }
1386
1387 /* Don't want top to be NULL, so set it to the last valid object */
1388 top = last;
1389 1382
1390 /* We let update_position deal with figuring out what the space 1383 /* We let update_position deal with figuring out what the space
1391 * looks like instead of lots of conditions here. 1384 * looks like instead of lots of conditions here.
1392 * makes things faster, and effectively the same result. 1385 * makes things faster, and effectively the same result.
1393 */ 1386 */
… …
1400 */ 1393 */
1401 if (!(flag & INS_ON_TOP) 1394 if (!(flag & INS_ON_TOP)
1402 && ms.flags () & P_BLOCKSVIEW 1395 && ms.flags () & P_BLOCKSVIEW
1403 && (op->face && !faces [op->face].visibility)) 1396 && (op->face && !faces [op->face].visibility))
1404 { 1397 {
1398 object *last;
1399
1405 for (last = top; last != floor; last = last->below) 1400 for (last = top; last != floor; last = last->below)
1406 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT)) 1401 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
1407 break; 1402 break;
1408 1403
1409 /* Check to see if we found the object that blocks view, 1404 /* Check to see if we found the object that blocks view,
… …
1417 } /* If objects on this space */ 1412 } /* If objects on this space */
1418 1413
1419 if (flag & INS_ABOVE_FLOOR_ONLY) 1414 if (flag & INS_ABOVE_FLOOR_ONLY)
1420 top = floor; 1415 top = floor;
1421 1416
1422 /* Top is the object that our object (op) is going to get inserted above. 1417 // insert object above top, or bottom-most if top = 0
1423 */
1424
1425 /* First object on this space */
1426 if (!top) 1418 if (!top)
1427 { 1419 {
1420 op->below = 0;
1428 op->above = ms.bot; 1421 op->above = ms.bot;
1429
1430 if (op->above)
1431 op->above->below = op;
1432
1433 op->below = 0;
1434 ms.bot = op; 1422 ms.bot = op;
1423
1424 *(op->above ? &op->above->below : &ms.top) = op;
1435 } 1425 }
1436 else 1426 else
1437 { /* get inserted into the stack above top */ 1427 {
1438 op->above = top->above; 1428 op->above = top->above;
1439
1440 if (op->above)
1441 op->above->below = op; 1429 top->above = op;
1442 1430
1443 op->below = top; 1431 op->below = top;
1444 top->above = op; 1432 *(op->above ? &op->above->below : &ms.top) = op;
1445 } 1433 }
1446 1434 }
1447 if (!op->above)
1448 ms.top = op;
1449 } /* else not INS_BELOW_ORIGINATOR */
1450 1435
1451 if (op->type == PLAYER) 1436 if (op->type == PLAYER)
1452 { 1437 {
1453 op->contr->do_los = 1; 1438 op->contr->do_los = 1;
1454 ++op->map->players; 1439 ++op->map->players;
… …
1554 1539
1555 nrof -= nr; 1540 nrof -= nr;
1556 1541
1557 if (nrof) 1542 if (nrof)
1558 { 1543 {
1559 adjust_weight (env, -weight * nr); // carrying == 0 1544 adjust_weight (env, -weight * max (1, nr)); // carrying == 0
1560 1545
1561 if (object *pl = visible_to ()) 1546 if (object *pl = visible_to ())
1562 esrv_update_item (UPD_NROF, pl, this); 1547 esrv_update_item (UPD_NROF, pl, this);
1563 1548
1564 return true; 1549 return true;
1565 } 1550 }
1566 else 1551 else
1567 { 1552 {
1568 destroy (1); 1553 destroy ();
1569 return false; 1554 return false;
1570 } 1555 }
1571} 1556}
1572 1557
1573/* 1558/*
… …
2449{ 2434{
2450 char flagdesc[512]; 2435 char flagdesc[512];
2451 char info2[256 * 4]; 2436 char info2[256 * 4];
2452 char *p = info; 2437 char *p = info;
2453 2438
2454 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}", 2439 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s%s,flags:[%s],type:%d}",
2455 count, 2440 count,
2456 uuid.c_str (), 2441 uuid.c_str (),
2457 &name, 2442 &name,
2458 title ? "\",title:\"" : "", 2443 title ? ",title:\"" : "",
2459 title ? (const char *)title : "", 2444 title ? (const char *)title : "",
2445 title ? "\"" : "",
2460 flag_desc (flagdesc, 512), type); 2446 flag_desc (flagdesc, 512), type);
2461 2447
2462 if (!flag[FLAG_REMOVED] && env) 2448 if (!flag[FLAG_REMOVED] && env)
2463 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2449 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2464 2450

Diff Legend

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