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.48 by root, Thu Sep 14 23:13:48 2006 UTC vs.
Revision 1.54 by root, Fri Nov 17 19:40:53 2006 UTC

374 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump. 374 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
375 * Some error messages. 375 * Some error messages.
376 * The result of the dump is stored in the static global errmsg array. 376 * The result of the dump is stored in the static global errmsg array.
377 */ 377 */
378 378
379void 379char *
380dump_object2 (object *op)
381{
382 errmsg[0] = 0;
383 return;
384 //TODO//D#d#
385#if 0
386 char *cp;
387
388/* object *tmp;*/
389
390 if (op->arch != NULL)
391 {
392 strcat (errmsg, "arch ");
393 strcat (errmsg, op->arch->name ? op->arch->name : "(null)");
394 strcat (errmsg, "\n");
395 if ((cp = get_ob_diff (op, &empty_archetype->clone)) != NULL)
396 strcat (errmsg, cp);
397# if 0
398 /* Don't dump player diffs - they are too long, mostly meaningless, and
399 * will overflow the buffer.
400 * Changed so that we don't dump inventory either. This may
401 * also overflow the buffer.
402 */
403 if (op->type != PLAYER && (cp = get_ob_diff (op, &empty_archetype->clone)) != NULL)
404 strcat (errmsg, cp);
405 for (tmp = op->inv; tmp; tmp = tmp->below)
406 dump_object2 (tmp);
407# endif
408 strcat (errmsg, "end\n");
409 }
410 else
411 {
412 strcat (errmsg, "Object ");
413 if (op->name == NULL)
414 strcat (errmsg, "(null)");
415 else
416 strcat (errmsg, op->name);
417 strcat (errmsg, "\n");
418# if 0
419 if ((cp = get_ob_diff (op, &empty_archetype->clone)) != NULL)
420 strcat (errmsg, cp);
421 for (tmp = op->inv; tmp; tmp = tmp->below)
422 dump_object2 (tmp);
423# endif
424 strcat (errmsg, "end\n");
425 }
426#endif
427}
428
429/*
430 * Dumps an object. Returns output in the static global errmsg array.
431 */
432
433void
434dump_object (object *op) 380dump_object (object *op)
435{ 381{
436 if (op == NULL) 382 if (!op)
437 { 383 return strdup ("[NULLOBJ]");
438 strcpy (errmsg, "[NULL pointer]");
439 return;
440 }
441 errmsg[0] = '\0';
442 dump_object2 (op);
443}
444 384
445void 385 object_freezer freezer;
446dump_all_objects (void) 386 save_object (freezer, op, 3);
447{ 387 return freezer.as_string ();
448 object *op;
449
450 for (op = object::first; op != NULL; op = op->next)
451 {
452 dump_object (op);
453 fprintf (logfile, "Object %s\n", errmsg);
454 }
455} 388}
456 389
457/* 390/*
458 * get_nearest_part(multi-object, object 2) returns the part of the 391 * get_nearest_part(multi-object, object 2) returns the part of the
459 * multi-object 1 which is closest to the second object. 392 * multi-object 1 which is closest to the second object.
479 */ 412 */
480 413
481object * 414object *
482find_object (tag_t i) 415find_object (tag_t i)
483{ 416{
484 object *op;
485
486 for (op = object::first; op != NULL; op = op->next) 417 for (object *op = object::first; op; op = op->next)
487 if (op->count == i) 418 if (op->count == i)
488 break; 419 return op;
489 420
490 return op; 421 return 0;
491} 422}
492 423
493/* 424/*
494 * Returns the first object which has a name equal to the argument. 425 * Returns the first object which has a name equal to the argument.
495 * Used only by the patch command, but not all that useful. 426 * Used only by the patch command, but not all that useful.
911 mortals.erase (i); 842 mortals.erase (i);
912 } 843 }
913 844
914 static int lastmortals = 0;//D 845 static int lastmortals = 0;//D
915 846
916 if (mortals.size() != lastmortals)//D 847 if (mortals.size() != lastmortals && lastmortals > 100)//D
917 { 848 {
918 lastmortals = mortals.size ();//D 849 lastmortals = mortals.size ();//D
919 LOG (llevDebug, "%d objects in mortal queue\n", lastmortals);//D 850 LOG (llevDebug, "%d objects in mortal queue\n", lastmortals);//D
920 } 851 }
921} 852}
972 * it from the list of used objects, and puts it on the list of 903 * it from the list of used objects, and puts it on the list of
973 * free objects. The IS_FREED() flag is set in the object. 904 * free objects. The IS_FREED() flag is set in the object.
974 * The object must have been removed by remove_ob() first for 905 * The object must have been removed by remove_ob() first for
975 * this function to succeed. 906 * this function to succeed.
976 * 907 *
977 * If free_inventory is set, free inventory as well. Else drop items in 908 * If destroy_inventory is set, free inventory as well. Else drop items in
978 * inventory to the ground. 909 * inventory to the ground.
979 */ 910 */
980void object::free (bool free_inventory) 911void object::destroy (bool destroy_inventory)
981{ 912{
982 if (QUERY_FLAG (this, FLAG_FREED)) 913 if (QUERY_FLAG (this, FLAG_FREED))
983 return; 914 return;
984 915
985 if (QUERY_FLAG (this, FLAG_FRIENDLY)) 916 if (QUERY_FLAG (this, FLAG_FRIENDLY))
990 921
991 SET_FLAG (this, FLAG_FREED); 922 SET_FLAG (this, FLAG_FREED);
992 923
993 if (more) 924 if (more)
994 { 925 {
995 more->free (free_inventory); 926 more->destroy (destroy_inventory);
996 more = 0; 927 more = 0;
997 } 928 }
998 929
999 if (inv) 930 if (inv)
1000 { 931 {
1001 /* Only if the space blocks everything do we not process - 932 /* Only if the space blocks everything do we not process -
1002 * if some form of movement is allowed, let objects 933 * if some form of movement is allowed, let objects
1003 * drop on that space. 934 * drop on that space.
1004 */ 935 */
1005 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL) 936 if (destroy_inventory || !map || map->in_memory != MAP_IN_MEMORY || GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)
1006 { 937 {
1007 object *op = inv; 938 object *op = inv;
1008 939
1009 while (op) 940 while (op)
1010 { 941 {
1011 object *tmp = op->below; 942 object *tmp = op->below;
1012 op->free (free_inventory); 943 op->destroy (destroy_inventory);
1013 op = tmp; 944 op = tmp;
1014 } 945 }
1015 } 946 }
1016 else 947 else
1017 { /* Put objects in inventory onto this space */ 948 { /* Put objects in inventory onto this space */
1041 // clear those pointers that likely might have circular references to us 972 // clear those pointers that likely might have circular references to us
1042 owner = 0; 973 owner = 0;
1043 enemy = 0; 974 enemy = 0;
1044 attacked_by = 0; 975 attacked_by = 0;
1045 976
977 // only relevant for players(?), but make sure of it anyways
978 contr = 0;
979
1046 /* Remove object from the active list */ 980 /* Remove object from the active list */
1047 speed = 0; 981 speed = 0;
1048 update_ob_speed (this); 982 update_ob_speed (this);
1049 983
1050 unlink (); 984 unlink ();
1084{ 1018{
1085 object *tmp, *last = 0; 1019 object *tmp, *last = 0;
1086 object *otmp; 1020 object *otmp;
1087 1021
1088 int check_walk_off; 1022 int check_walk_off;
1089 mapstruct *m; 1023 maptile *m;
1090 1024
1091 sint16 x, y; 1025 sint16 x, y;
1092 1026
1093 if (QUERY_FLAG (op, FLAG_REMOVED)) 1027 if (QUERY_FLAG (op, FLAG_REMOVED))
1094 return; 1028 return;
1173 * use translated coordinates in case some oddness with map tiling is 1107 * use translated coordinates in case some oddness with map tiling is
1174 * evident 1108 * evident
1175 */ 1109 */
1176 if (GET_MAP_OB (m, x, y) != op) 1110 if (GET_MAP_OB (m, x, y) != op)
1177 { 1111 {
1178 dump_object (op); 1112 char *dump = dump_object (op);
1179 LOG (llevError, 1113 LOG (llevError,
1180 "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", errmsg); 1114 "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", dump);
1115 free (dump);
1181 dump_object (GET_MAP_OB (m, x, y)); 1116 dump = dump_object (GET_MAP_OB (m, x, y));
1182 LOG (llevError, "%s\n", errmsg); 1117 LOG (llevError, "%s\n", dump);
1118 free (dump);
1183 } 1119 }
1184 1120
1185 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */ 1121 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1186 } 1122 }
1187 1123
1213 1149
1214 tmp->contr->socket.update_look = 1; 1150 tmp->contr->socket.update_look = 1;
1215 } 1151 }
1216 1152
1217 /* See if player moving off should effect something */ 1153 /* See if player moving off should effect something */
1218 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0)) 1154 if (check_walk_off
1155 && ((op->move_type & tmp->move_off)
1156 && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1219 { 1157 {
1220 move_apply (tmp, op, NULL); 1158 move_apply (tmp, op, NULL);
1221 1159
1222 if (op->destroyed ()); 1160 if (op->destroyed ())
1223 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name); 1161 LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ());
1224 } 1162 }
1225 1163
1226 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */ 1164 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1227 1165
1228 if (tmp->above == tmp) 1166 if (tmp->above == tmp)
1289/* 1227/*
1290 * same as insert_ob_in_map except it handle separate coordinates and do a clean 1228 * same as insert_ob_in_map except it handle separate coordinates and do a clean
1291 * job preparing multi-part monsters 1229 * job preparing multi-part monsters
1292 */ 1230 */
1293object * 1231object *
1294insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y) 1232insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1295{ 1233{
1296 object *tmp; 1234 object *tmp;
1297 1235
1298 if (op->head) 1236 if (op->head)
1299 op = op->head; 1237 op = op->head;
1327 * NULL if 'op' was destroyed 1265 * NULL if 'op' was destroyed
1328 * just 'op' otherwise 1266 * just 'op' otherwise
1329 */ 1267 */
1330 1268
1331object * 1269object *
1332insert_ob_in_map (object *op, mapstruct *m, object *originator, int flag) 1270insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1333{ 1271{
1334 object *tmp, *top, *floor = NULL; 1272 object *tmp, *top, *floor = NULL;
1335 sint16 x, y; 1273 sint16 x, y;
1336 1274
1337 if (QUERY_FLAG (op, FLAG_FREED)) 1275 if (QUERY_FLAG (op, FLAG_FREED))
1340 return NULL; 1278 return NULL;
1341 } 1279 }
1342 1280
1343 if (m == NULL) 1281 if (m == NULL)
1344 { 1282 {
1345 dump_object (op); 1283 char *dump = dump_object (op);
1346 LOG (llevError, "Trying to insert in null-map!\n%s\n", errmsg); 1284 LOG (llevError, "Trying to insert in null-map!\n%s\n", dump);
1285 free (dump);
1347 return op; 1286 return op;
1348 } 1287 }
1349 1288
1350 if (out_of_map (m, op->x, op->y)) 1289 if (out_of_map (m, op->x, op->y))
1351 { 1290 {
1352 dump_object (op); 1291 char *dump = dump_object (op);
1353 LOG (llevError, "Trying to insert object outside the map.\n%s\n", errmsg); 1292 LOG (llevError, "Trying to insert object outside the map.\n%s\n", dump);
1354#ifdef MANY_CORES 1293#ifdef MANY_CORES
1355 /* Better to catch this here, as otherwise the next use of this object 1294 /* Better to catch this here, as otherwise the next use of this object
1356 * is likely to cause a crash. Better to find out where it is getting 1295 * is likely to cause a crash. Better to find out where it is getting
1357 * improperly inserted. 1296 * improperly inserted.
1358 */ 1297 */
1359 abort (); 1298 abort ();
1360#endif 1299#endif
1300 free (dump);
1361 return op; 1301 return op;
1362 } 1302 }
1363 1303
1364 if (!QUERY_FLAG (op, FLAG_REMOVED)) 1304 if (!QUERY_FLAG (op, FLAG_REMOVED))
1365 { 1305 {
1366 dump_object (op); 1306 char *dump = dump_object (op);
1367 LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", errmsg); 1307 LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", dump);
1308 free (dump);
1368 return op; 1309 return op;
1369 } 1310 }
1370 1311
1371 if (op->more != NULL) 1312 if (op->more != NULL)
1372 { 1313 {
1809 tmp, * 1750 tmp, *
1810 otmp; 1751 otmp;
1811 1752
1812 if (!QUERY_FLAG (op, FLAG_REMOVED)) 1753 if (!QUERY_FLAG (op, FLAG_REMOVED))
1813 { 1754 {
1814 dump_object (op); 1755 char *dump = dump_object (op);
1815 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg); 1756 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", dump);
1757 free (dump);
1816 return op; 1758 return op;
1817 } 1759 }
1818 1760
1819 if (where == NULL) 1761 if (where == NULL)
1820 { 1762 {
1821 dump_object (op); 1763 char *dump = dump_object (op);
1822 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg); 1764 LOG (llevError, "Trying to put object in NULL.\n%s\n", dump);
1765 free (dump);
1823 return op; 1766 return op;
1824 } 1767 }
1825 1768
1826 if (where->head) 1769 if (where->head)
1827 { 1770 {
1928 1871
1929int 1872int
1930check_move_on (object *op, object *originator) 1873check_move_on (object *op, object *originator)
1931{ 1874{
1932 object *tmp; 1875 object *tmp;
1933 mapstruct *m = op->map; 1876 maptile *m = op->map;
1934 int x = op->x, y = op->y; 1877 int x = op->x, y = op->y;
1935 1878
1936 MoveType move_on, move_slow, move_block; 1879 MoveType move_on, move_slow, move_block;
1937 1880
1938 if (QUERY_FLAG (op, FLAG_NO_APPLY)) 1881 if (QUERY_FLAG (op, FLAG_NO_APPLY))
2027 * a matching archetype at the given map and coordinates. 1970 * a matching archetype at the given map and coordinates.
2028 * The first matching object is returned, or NULL if none. 1971 * The first matching object is returned, or NULL if none.
2029 */ 1972 */
2030 1973
2031object * 1974object *
2032present_arch (const archetype *at, mapstruct *m, int x, int y) 1975present_arch (const archetype *at, maptile *m, int x, int y)
2033{ 1976{
2034 object * 1977 object *
2035 tmp; 1978 tmp;
2036 1979
2037 if (m == NULL || out_of_map (m, x, y)) 1980 if (m == NULL || out_of_map (m, x, y))
2050 * a matching type variable at the given map and coordinates. 1993 * a matching type variable at the given map and coordinates.
2051 * The first matching object is returned, or NULL if none. 1994 * The first matching object is returned, or NULL if none.
2052 */ 1995 */
2053 1996
2054object * 1997object *
2055present (unsigned char type, mapstruct *m, int x, int y) 1998present (unsigned char type, maptile *m, int x, int y)
2056{ 1999{
2057 object * 2000 object *
2058 tmp; 2001 tmp;
2059 2002
2060 if (out_of_map (m, x, y)) 2003 if (out_of_map (m, x, y))
2200 * the archetype because that isn't correct if the monster has been 2143 * the archetype because that isn't correct if the monster has been
2201 * customized, changed states, etc. 2144 * customized, changed states, etc.
2202 */ 2145 */
2203 2146
2204int 2147int
2205find_free_spot (const object *ob, mapstruct *m, int x, int y, int start, int stop) 2148find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop)
2206{ 2149{
2207 int 2150 int
2208 i, 2151 i,
2209 index = 0, flag; 2152 index = 0, flag;
2210 static int 2153 static int
2231 return -1; 2174 return -1;
2232 return altern[RANDOM () % index]; 2175 return altern[RANDOM () % index];
2233} 2176}
2234 2177
2235/* 2178/*
2236 * find_first_free_spot(archetype, mapstruct, x, y) works like 2179 * find_first_free_spot(archetype, maptile, x, y) works like
2237 * find_free_spot(), but it will search max number of squares. 2180 * find_free_spot(), but it will search max number of squares.
2238 * But it will return the first available spot, not a random choice. 2181 * But it will return the first available spot, not a random choice.
2239 * Changed 0.93.2: Have it return -1 if there is no free spot available. 2182 * Changed 0.93.2: Have it return -1 if there is no free spot available.
2240 */ 2183 */
2241 2184
2242int 2185int
2243find_first_free_spot (const object *ob, mapstruct *m, int x, int y) 2186find_first_free_spot (const object *ob, maptile *m, int x, int y)
2244{ 2187{
2245 int 2188 int
2246 i; 2189 i;
2247 2190
2248 for (i = 0; i < SIZEOFFREE; i++) 2191 for (i = 0; i < SIZEOFFREE; i++)
2312 * because we have to know what movement the thing looking to move 2255 * because we have to know what movement the thing looking to move
2313 * there is capable of. 2256 * there is capable of.
2314 */ 2257 */
2315 2258
2316int 2259int
2317find_dir (mapstruct *m, int x, int y, object *exclude) 2260find_dir (maptile *m, int x, int y, object *exclude)
2318{ 2261{
2319 int 2262 int
2320 i, 2263 i,
2321 max = SIZEOFFREE, mflags; 2264 max = SIZEOFFREE, mflags;
2322 2265
2323 sint16 nx, ny; 2266 sint16 nx, ny;
2324 object * 2267 object *
2325 tmp; 2268 tmp;
2326 mapstruct * 2269 maptile *
2327 mp; 2270 mp;
2328 2271
2329 MoveType blocked, move_type; 2272 MoveType blocked, move_type;
2330 2273
2331 if (exclude && exclude->head) 2274 if (exclude && exclude->head)
2539 * Modified to be map tile aware -.MSW 2482 * Modified to be map tile aware -.MSW
2540 */ 2483 */
2541 2484
2542 2485
2543int 2486int
2544can_see_monsterP (mapstruct *m, int x, int y, int dir) 2487can_see_monsterP (maptile *m, int x, int y, int dir)
2545{ 2488{
2546 sint16 dx, dy; 2489 sint16 dx, dy;
2547 int 2490 int
2548 mflags; 2491 mflags;
2549 2492

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines