… | |
… | |
110 | /* We basically go through the stack of objects, and if there is |
110 | /* We basically go through the stack of objects, and if there is |
111 | * some other object that has NO_PASS or FLAG_ALIVE set, return |
111 | * some other object that has NO_PASS or FLAG_ALIVE set, return |
112 | * true. If we get through the entire stack, that must mean |
112 | * true. If we get through the entire stack, that must mean |
113 | * ob is blocking it, so return 0. |
113 | * ob is blocking it, so return 0. |
114 | */ |
114 | */ |
115 | for (object *tmp = ms.bot; tmp; tmp = tmp->above) |
115 | for (object *tmp = ms.top; tmp; tmp = tmp->below) |
116 | { |
116 | { |
117 | if (OB_MOVE_BLOCK (ob, tmp)) |
117 | if (OB_MOVE_BLOCK (ob, tmp)) |
118 | { |
118 | { |
119 | if (INVOKE_OBJECT (BLOCKED_MOVE, tmp, ob)) |
119 | if (INVOKE_OBJECT (BLOCKED_MOVE, tmp, ob)) |
120 | if (RESULT_INT (0)) |
120 | if (RESULT_INT (0)) |
… | |
… | |
144 | return 1; // unconditional block |
144 | return 1; // unconditional block |
145 | |
145 | |
146 | } else { |
146 | } else { |
147 | // space does not block the ob, directly, but |
147 | // space does not block the ob, directly, but |
148 | // anything alive that is not a door still |
148 | // anything alive that is not a door still |
149 | // blocks anything but wizards. |
149 | // blocks anything |
150 | |
150 | |
151 | if (tmp->flag [FLAG_ALIVE] |
151 | if (tmp->flag [FLAG_ALIVE] |
152 | && tmp->head_ () != ob |
|
|
153 | && tmp != ob |
|
|
154 | && tmp->type != DOOR) |
152 | && tmp->type != DOOR |
|
|
153 | && tmp->head_ () != ob) //TODO: maybe move these check up? |
155 | return 1; |
154 | return 1; |
156 | } |
155 | } |
157 | } |
156 | } |
158 | |
157 | |
159 | return 0; |
158 | return 0; |
160 | } |
159 | } |
161 | |
160 | |
162 | /* |
161 | /* |
163 | * Returns qthe blocking object if the given object can't fit in the given |
162 | * Returns the blocking object if the given object can't fit in the given |
164 | * spot. This is meant for multi space objects - for single space objecs, |
163 | * spot. This is meant for multi space objects - for single space objecs, |
165 | * just calling get_map_blocked and checking that against movement type |
164 | * just calling get_map_blocked and checking that against movement type |
166 | * of object. This function goes through all the parts of the multipart |
165 | * of object. This function goes through all the parts of the multipart |
167 | * object and makes sure they can be inserted. |
166 | * object and makes sure they can be inserted. |
168 | * |
167 | * |
… | |
… | |
422 | return false; |
421 | return false; |
423 | |
422 | |
424 | return freezer.save (path); |
423 | return freezer.save (path); |
425 | } |
424 | } |
426 | |
425 | |
427 | maptile::maptile () |
426 | void |
|
|
427 | maptile::init () |
428 | { |
428 | { |
429 | in_memory = MAP_SWAPPED; |
429 | in_memory = MAP_SWAPPED; |
430 | |
430 | |
431 | /* The maps used to pick up default x and y values from the |
431 | /* The maps used to pick up default x and y values from the |
432 | * map archetype. Mimic that behaviour. |
432 | * map archetype. Mimic that behaviour. |
433 | */ |
433 | */ |
434 | width = 16; |
434 | width = 16; |
435 | height = 16; |
435 | height = 16; |
436 | timeout = 300; |
436 | timeout = 300; |
437 | max_items = MAX_ITEM_PER_ACTION; |
437 | max_items = MAX_ITEM_PER_ACTION; |
438 | max_volume = 2000000; // 2m³ |
438 | max_volume = 2000000; // 2m³ |
439 | } |
|
|
440 | |
|
|
441 | maptile::maptile (int w, int h) |
|
|
442 | { |
|
|
443 | in_memory = MAP_SWAPPED; |
|
|
444 | |
|
|
445 | width = w; |
|
|
446 | height = h; |
|
|
447 | reset_timeout = 0; |
439 | reset_timeout = 0; |
448 | timeout = 300; |
|
|
449 | enter_x = 0; |
440 | enter_x = 0; |
450 | enter_y = 0; |
441 | enter_y = 0; |
|
|
442 | } |
|
|
443 | |
|
|
444 | maptile::maptile () |
|
|
445 | { |
|
|
446 | init (); |
|
|
447 | } |
|
|
448 | |
|
|
449 | maptile::maptile (int w, int h) |
|
|
450 | { |
|
|
451 | init (); |
|
|
452 | |
|
|
453 | width = w; |
|
|
454 | height = h; |
451 | |
455 | |
452 | alloc (); |
456 | alloc (); |
453 | } |
457 | } |
454 | |
458 | |
455 | /* |
459 | /* |
… | |
… | |
662 | case KW_end: |
666 | case KW_end: |
663 | thawer.next (); |
667 | thawer.next (); |
664 | return true; |
668 | return true; |
665 | |
669 | |
666 | default: |
670 | default: |
667 | if (!thawer.parse_error ("map", 0)) |
671 | if (!thawer.parse_error ("map")) |
668 | return false; |
672 | return false; |
669 | break; |
673 | break; |
670 | } |
674 | } |
671 | |
675 | |
672 | thawer.next (); |
676 | thawer.next (); |
… | |
… | |
1420 | * |
1424 | * |
1421 | * currently, the only flag supported (0x1) is don't translate for |
1425 | * currently, the only flag supported (0x1) is don't translate for |
1422 | * closest body part of 'op1' |
1426 | * closest body part of 'op1' |
1423 | */ |
1427 | */ |
1424 | void |
1428 | void |
1425 | get_rangevector (object *op1, object *op2, rv_vector * retval, int flags) |
1429 | get_rangevector (object *op1, object *op2, rv_vector *retval, int flags) |
1426 | { |
1430 | { |
1427 | if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y)) |
1431 | if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y)) |
1428 | { |
1432 | { |
1429 | /* be conservative and fill in _some_ data */ |
1433 | /* be conservative and fill in _some_ data */ |
1430 | retval->distance = 10000; |
1434 | retval->distance = 10000; |
1431 | retval->distance_x = 10000; |
1435 | retval->distance_x = 10000; |
1432 | retval->distance_y = 10000; |
1436 | retval->distance_y = 10000; |
1433 | retval->direction = 0; |
1437 | retval->direction = 0; |
1434 | retval->part = 0; |
1438 | retval->part = 0; |
1435 | } |
1439 | } |
1436 | else |
1440 | else |
1437 | { |
1441 | { |
1438 | object *best; |
|
|
1439 | |
|
|
1440 | retval->distance_x += op2->x - op1->x; |
1442 | retval->distance_x += op2->x - op1->x; |
1441 | retval->distance_y += op2->y - op1->y; |
1443 | retval->distance_y += op2->y - op1->y; |
1442 | |
1444 | |
1443 | best = op1; |
1445 | object *best = op1; |
|
|
1446 | |
1444 | /* If this is multipart, find the closest part now */ |
1447 | /* If this is multipart, find the closest part now */ |
1445 | if (!(flags & 0x1) && op1->more) |
1448 | if (!(flags & 1) && op1->more) |
1446 | { |
1449 | { |
1447 | int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi; |
1450 | int best_distance = idistance (retval->distance_x, retval->distance_y); |
1448 | |
1451 | |
1449 | /* we just take the offset of the piece to head to figure |
1452 | /* we just take the offset of the piece to head to figure |
1450 | * distance instead of doing all that work above again |
1453 | * distance instead of doing all that work above again |
1451 | * since the distance fields we set above are positive in the |
1454 | * since the distance fields we set above are positive in the |
1452 | * same axis as is used for multipart objects, the simply arithmetic |
1455 | * same axis as is used for multipart objects, the simply arithmetic |
1453 | * below works. |
1456 | * below works. |
1454 | */ |
1457 | */ |
1455 | for (object *tmp = op1->more; tmp; tmp = tmp->more) |
1458 | for (object *tmp = op1->more; tmp; tmp = tmp->more) |
1456 | { |
1459 | { |
1457 | tmpi = (op1->x - tmp->x + retval->distance_x) * (op1->x - tmp->x + retval->distance_x) + |
1460 | int tmpi = idistance (op1->x - tmp->x + retval->distance_x, op1->y - tmp->y + retval->distance_y); |
1458 | (op1->y - tmp->y + retval->distance_y) * (op1->y - tmp->y + retval->distance_y); |
1461 | |
1459 | if (tmpi < best_distance) |
1462 | if (tmpi < best_distance) |
1460 | { |
1463 | { |
1461 | best_distance = tmpi; |
1464 | best_distance = tmpi; |
1462 | best = tmp; |
1465 | best = tmp; |
1463 | } |
1466 | } |
1464 | } |
1467 | } |
1465 | |
1468 | |
1466 | if (best != op1) |
1469 | if (best != op1) |
1467 | { |
1470 | { |
1468 | retval->distance_x += op1->x - best->x; |
1471 | retval->distance_x += op1->x - best->x; |
1469 | retval->distance_y += op1->y - best->y; |
1472 | retval->distance_y += op1->y - best->y; |
1470 | } |
1473 | } |
1471 | } |
1474 | } |
1472 | |
1475 | |
1473 | retval->part = best; |
1476 | retval->part = best; |
1474 | retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y)); |
1477 | retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y)); |
1475 | retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y); |
1478 | retval->direction = find_dir_2 (retval->distance_x, retval->distance_y); |
1476 | } |
1479 | } |
1477 | } |
1480 | } |
1478 | |
1481 | |
1479 | /* this is basically the same as get_rangevector above, but instead of |
1482 | /* this is basically the same as get_rangevector above, but instead of |
1480 | * the first parameter being an object, it instead is the map |
1483 | * the first parameter being an object, it instead is the map |
… | |
… | |
1490 | get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector *retval, int flags) |
1493 | get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector *retval, int flags) |
1491 | { |
1494 | { |
1492 | if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y)) |
1495 | if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y)) |
1493 | { |
1496 | { |
1494 | /* be conservative and fill in _some_ data */ |
1497 | /* be conservative and fill in _some_ data */ |
1495 | retval->distance = 100000; |
1498 | retval->distance = 100000; |
1496 | retval->distance_x = 32767; |
1499 | retval->distance_x = 32767; |
1497 | retval->distance_y = 32767; |
1500 | retval->distance_y = 32767; |
1498 | retval->direction = 0; |
1501 | retval->direction = 0; |
1499 | retval->part = 0; |
1502 | retval->part = 0; |
1500 | } |
1503 | } |
1501 | else |
1504 | else |
1502 | { |
1505 | { |
1503 | retval->distance_x += op2->x - x; |
1506 | retval->distance_x += op2->x - x; |
1504 | retval->distance_y += op2->y - y; |
1507 | retval->distance_y += op2->y - y; |
1505 | |
1508 | |
1506 | retval->part = 0; |
1509 | retval->part = 0; |
1507 | retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y)); |
1510 | retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y)); |
1508 | retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y); |
1511 | retval->direction = find_dir_2 (retval->distance_x, retval->distance_y); |
1509 | } |
1512 | } |
1510 | } |
1513 | } |
1511 | |
1514 | |
1512 | /* Returns true of op1 and op2 are effectively on the same map |
1515 | /* Returns true of op1 and op2 are effectively on the same map |
1513 | * (as related to map tiling). Note that this looks for a path from |
1516 | * (as related to map tiling). Note that this looks for a path from |
… | |
… | |
1563 | */ |
1566 | */ |
1564 | for (int i = 1000; --i;) |
1567 | for (int i = 1000; --i;) |
1565 | { |
1568 | { |
1566 | object *pick = at (gen (width), gen (height)).bot; |
1569 | object *pick = at (gen (width), gen (height)).bot; |
1567 | |
1570 | |
1568 | // do not prefer big monsters just because they are big. |
1571 | // must be head: do not prefer big monsters just because they are big. |
1569 | if (pick && pick->is_head ()) |
1572 | if (pick && pick->is_head ()) |
1570 | return pick->head_ (); |
1573 | return pick; |
1571 | } |
1574 | } |
1572 | |
1575 | |
1573 | // instead of crashing in the unlikely(?) case, try to return *something* |
1576 | // instead of crashing in the unlikely(?) case, try to return *something* |
1574 | return archetype::find (shstr_bug); |
1577 | return archetype::find (shstr_bug); |
1575 | } |
1578 | } |