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.237 by root, Tue May 6 21:04:37 2008 UTC vs.
Revision 1.253 by root, Sun Aug 17 22:46:26 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.
… …
768 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC)) 770 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC))
769 || (m.move_on | op->move_on ) != m.move_on 771 || (m.move_on | op->move_on ) != m.move_on
770 || (m.move_off | op->move_off ) != m.move_off 772 || (m.move_off | op->move_off ) != m.move_off
771 || (m.move_slow | op->move_slow) != m.move_slow 773 || (m.move_slow | op->move_slow) != m.move_slow
772 /* This isn't perfect, but I don't expect a lot of objects to 774 /* This isn't perfect, but I don't expect a lot of objects to
773 * to have move_allow right now. 775 * have move_allow right now.
774 */ 776 */
775 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block 777 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block
776 || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp) 778 || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)
777 m.flags_ = 0; 779 m.flags_ = 0;
778 } 780 }
… …
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
… …
1115 *(below ? &below->above : &ms.bot) = above; 1115 *(below ? &below->above : &ms.bot) = above;
1116 1116
1117 above = 0; 1117 above = 0;
1118 below = 0; 1118 below = 0;
1119 1119
1120 ms.flags_ = 0;
1121
1120 if (map->in_memory == MAP_SAVING) 1122 if (map->in_memory == MAP_SAVING)
1121 return; 1123 return;
1122 1124
1123 int check_walk_off = !flag [FLAG_NO_APPLY]; 1125 int check_walk_off = !flag [FLAG_NO_APPLY];
1124 1126
… …
1156 } 1158 }
1157 1159
1158 last = tmp; 1160 last = tmp;
1159 } 1161 }
1160 1162
1161 /* last == NULL if there are no objects on this space */
1162 //TODO: this makes little sense, why only update the topmost object?
1163 if (!last)
1164 map->at (x, y).flags_ = 0;
1165 else
1166 update_object (last, UP_OBJ_REMOVE);
1167
1168 if (flag [FLAG_BLOCKSVIEW] || glow_radius) 1163 if (flag [FLAG_BLOCKSVIEW] || glow_radius)
1169 update_all_los (map, x, y); 1164 update_all_los (map, x, y);
1170 } 1165 }
1171} 1166}
1172 1167
… …
1235 * job preparing multi-part monsters. 1230 * job preparing multi-part monsters.
1236 */ 1231 */
1237object * 1232object *
1238insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y) 1233insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1239{ 1234{
1235 op->remove ();
1236
1240 for (object *tmp = op->head_ (); tmp; tmp = tmp->more) 1237 for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
1241 { 1238 {
1242 tmp->x = x + tmp->arch->x; 1239 tmp->x = x + tmp->arch->x;
1243 tmp->y = y + tmp->arch->y; 1240 tmp->y = y + tmp->arch->y;
1244 } 1241 }
… …
1267 * just 'op' otherwise 1264 * just 'op' otherwise
1268 */ 1265 */
1269object * 1266object *
1270insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1267insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1271{ 1268{
1269 if (op->is_on_map ())
1270 {
1271 LOG (llevError, "insert_ob_in_map called for object already on map");
1272 abort ();
1273 }
1274
1275 if (op->env)
1276 {
1277 LOG (llevError, "insert_ob_in_map called for object in an inventory (proceeding)");
1272 op->remove (); 1278 op->remove ();
1279 }
1280
1281 if (op->face && !face_info (op->face))//D TODO: remove soon
1282 {//D
1283 LOG (llevError | logBacktrace, "op->face out of bounds: %s", op->debug_desc ());//D
1284 op->face = 1;//D
1285 }//D
1273 1286
1274 /* Ideally, the caller figures this out. However, it complicates a lot 1287 /* Ideally, the caller figures this out. However, it complicates a lot
1275 * of areas of callers (eg, anything that uses find_free_spot would now 1288 * of areas of callers (eg, anything that uses find_free_spot would now
1276 * need extra work 1289 * need extra work
1277 */ 1290 */
… …
1309 if (!QUERY_FLAG (op, FLAG_ALIVE)) 1322 if (!QUERY_FLAG (op, FLAG_ALIVE))
1310 CLEAR_FLAG (op, FLAG_NO_STEAL); 1323 CLEAR_FLAG (op, FLAG_NO_STEAL);
1311 1324
1312 if (flag & INS_BELOW_ORIGINATOR) 1325 if (flag & INS_BELOW_ORIGINATOR)
1313 { 1326 {
1314 if (originator->map != op->map || originator->x != op->x || originator->y != op->y || !originator->is_on_map ()) 1327 if (originator->map != op->map || originator->x != op->x || originator->y != op->y)
1315 { 1328 {
1316 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n"); 1329 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1317 abort (); 1330 abort ();
1318 } 1331 }
1332
1333 if (!originator->is_on_map ())
1334 LOG (llevDebug | logBacktrace, "insert_ob_in_map(%s) called with INS_BELOW_ORIGINATOR when originator '%s' not on map",
1335 op->debug_desc (), originator->debug_desc ());
1319 1336
1320 op->above = originator; 1337 op->above = originator;
1321 op->below = originator->below; 1338 op->below = originator->below;
1322 originator->below = op; 1339 originator->below = op;
1323 1340
… …
1390 } /* If objects on this space */ 1407 } /* If objects on this space */
1391 1408
1392 if (flag & INS_ABOVE_FLOOR_ONLY) 1409 if (flag & INS_ABOVE_FLOOR_ONLY)
1393 top = floor; 1410 top = floor;
1394 1411
1395 /* Top is the object that our object (op) is going to get inserted above. 1412 // insert object above top, or bottom-most if top = 0
1396 */
1397
1398 /* no top found, insert on top */
1399 if (!top) 1413 if (!top)
1400 { 1414 {
1401 op->above = 0; 1415 op->below = 0;
1402 op->below = ms.top; 1416 op->above = ms.bot;
1403 ms.top = op; 1417 ms.bot = op;
1404 1418
1405 *(op->below ? &op->below->above : &ms.bot) = op; 1419 *(op->above ? &op->above->below : &ms.top) = op;
1406 } 1420 }
1407 else 1421 else
1408 { /* get inserted into the stack above top */ 1422 {
1409 op->above = top->above; 1423 op->above = top->above;
1410 top->above = op; 1424 top->above = op;
1411 1425
1412 op->below = top; 1426 op->below = top;
1413 *(op->above ? &op->above->below : &ms.top) = op; 1427 *(op->above ? &op->above->below : &ms.top) = op;
1414 } 1428 }
1415 } /* else not INS_BELOW_ORIGINATOR */ 1429 }
1416 1430
1417 if (op->type == PLAYER) 1431 if (op->type == PLAYER)
1418 { 1432 {
1419 op->contr->do_los = 1; 1433 op->contr->do_los = 1;
1420 ++op->map->players; 1434 ++op->map->players;
… …
1516 if (!nr) 1530 if (!nr)
1517 return true; 1531 return true;
1518 1532
1519 nr = min (nr, nrof); 1533 nr = min (nr, nrof);
1520 1534
1535 if (nrof > nr)
1536 {
1521 nrof -= nr; 1537 nrof -= nr;
1522
1523 if (nrof)
1524 {
1525 adjust_weight (env, -weight * nr); // carrying == 0 1538 adjust_weight (env, -weight * max (1, nr)); // carrying == 0
1526 1539
1527 if (object *pl = visible_to ()) 1540 if (object *pl = visible_to ())
1528 esrv_update_item (UPD_NROF, pl, this); 1541 esrv_update_item (UPD_NROF, pl, this);
1529 1542
1530 return true; 1543 return true;
1531 } 1544 }
1532 else 1545 else
1533 { 1546 {
1534 destroy (1); 1547 destroy ();
1535 return false; 1548 return false;
1536 } 1549 }
1537} 1550}
1538 1551
1539/* 1552/*
… …
2415{ 2428{
2416 char flagdesc[512]; 2429 char flagdesc[512];
2417 char info2[256 * 4]; 2430 char info2[256 * 4];
2418 char *p = info; 2431 char *p = info;
2419 2432
2420 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}", 2433 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s%s,flags:[%s],type:%d}",
2421 count, 2434 count,
2422 uuid.c_str (), 2435 uuid.c_str (),
2423 &name, 2436 &name,
2424 title ? "\",title:\"" : "", 2437 title ? ",title:\"" : "",
2425 title ? (const char *)title : "", 2438 title ? (const char *)title : "",
2439 title ? "\"" : "",
2426 flag_desc (flagdesc, 512), type); 2440 flag_desc (flagdesc, 512), type);
2427 2441
2428 if (!flag[FLAG_REMOVED] && env) 2442 if (!flag[FLAG_REMOVED] && env)
2429 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2443 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2430 2444

Diff Legend

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