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

Comparing deliantra/server/common/map.C (file contents):
Revision 1.80 by root, Thu Jan 25 03:54:44 2007 UTC vs.
Revision 1.87 by root, Thu Feb 15 21:07:48 2007 UTC

… …
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 21 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
23 */ 23 */
24 24
25#include <global.h>
26#include <funcpoint.h>
27
28#include <loader.h>
29#include <unistd.h> 25#include <unistd.h>
26
27#include "global.h"
28#include "funcpoint.h"
29
30#include "loader.h"
30 31
31#include "path.h" 32#include "path.h"
32 33
33/* 34/*
34 * This makes a path absolute outside the world of Crossfire. 35 * This makes a path absolute outside the world of Crossfire.
… …
67 char *endbuf; 68 char *endbuf;
68 struct stat statbuf; 69 struct stat statbuf;
69 int mode = 0; 70 int mode = 0;
70 71
71 if (prepend_dir) 72 if (prepend_dir)
72 strcpy (buf, create_pathname (name)); 73 assign (buf, create_pathname (name));
73 else 74 else
74 strcpy (buf, name); 75 assign (buf, name);
75 76
76 /* old method (strchr(buf, '\0')) seemd very odd to me - 77 /* old method (strchr(buf, '\0')) seemd very odd to me -
77 * this method should be equivalant and is clearer. 78 * this method should be equivalant and is clearer.
78 * Can not use strcat because we need to cycle through 79 * Can not use strcat because we need to cycle through
79 * all the names. 80 * all the names.
… …
541 return false; 542 return false;
542 543
543 if (skip_header) 544 if (skip_header)
544 for (;;) 545 for (;;)
545 { 546 {
546 keyword kw = thawer.get_kv ();
547
548 if (kw == KW_end) 547 if (thawer.kw == KW_end)
549 break; 548 break;
550 549
551 thawer.skip_kv (kw); 550 thawer.skip_kv ();
552 } 551 }
553 552
554 return _load_objects (thawer); 553 return _load_objects (thawer);
555} 554}
556 555
… …
568maptile::maptile () 567maptile::maptile ()
569{ 568{
570 in_memory = MAP_SWAPPED; 569 in_memory = MAP_SWAPPED;
571 570
572 /* The maps used to pick up default x and y values from the 571 /* The maps used to pick up default x and y values from the
573 * map archetype. Mimic that behaviour. 572 * map archetype. Mimic that behaviour.
574 */ 573 */
575 width = 16; 574 width = 16;
576 height = 16; 575 height = 16;
577 reset_timeout = 0;
578 timeout = 300; 576 timeout = 300;
579 enter_x = 0; 577 max_nrof = 1000; // 1000 items of anything
580 enter_y = 0; 578 max_volume = 2000000; // 2m³
581} 579}
582 580
583maptile::maptile (int w, int h) 581maptile::maptile (int w, int h)
584{ 582{
585 in_memory = MAP_SWAPPED; 583 in_memory = MAP_SWAPPED;
… …
739 { 737 {
740 keyword kw = thawer.get_kv (); 738 keyword kw = thawer.get_kv ();
741 739
742 switch (kw) 740 switch (kw)
743 { 741 {
744 case KW_EOF:
745 LOG (llevError, "%s: end of file while reading map header, aborting header load.\n", &path);
746 return false;
747
748 case KW_end:
749 return true;
750
751 default:
752 case KW_ERROR:
753 LOG (llevError, "%s: skipping errornous line (%s) while reading map header.\n", &path, thawer.last_keyword);
754 break;
755
756 case KW_msg: 742 case KW_msg:
757 thawer.get_ml (KW_endmsg, msg); 743 thawer.get_ml (KW_endmsg, msg);
758 break; 744 break;
759 745
760 case KW_lore: // CF+ extension 746 case KW_lore: // CF+ extension
… …
792 case KW_sky: thawer.get (sky); break; 778 case KW_sky: thawer.get (sky); break;
793 779
794 case KW_per_player: thawer.get (per_player); break; 780 case KW_per_player: thawer.get (per_player); break;
795 case KW_per_party: thawer.get (per_party); break; 781 case KW_per_party: thawer.get (per_party); break;
796 782
797 case KW_region: default_region = get_region_by_name (thawer.get_str ()); break; 783 case KW_region: default_region = region::find (thawer.get_str ()); break;
798 case KW_shopitems: shopitems = parse_shop_string (thawer.get_str ()); break; 784 case KW_shopitems: shopitems = parse_shop_string (thawer.get_str ()); break;
799 785
800 // old names new names 786 // old names new names
801 case KW_hp: case KW_enter_x: thawer.get (enter_x); break; 787 case KW_hp: case KW_enter_x: thawer.get (enter_x); break;
802 case KW_sp: case KW_enter_y: thawer.get (enter_y); break; 788 case KW_sp: case KW_enter_y: thawer.get (enter_y); break;
… …
810 796
811 case KW_tile_path_1: thawer.get (tile_path [0]); break; 797 case KW_tile_path_1: thawer.get (tile_path [0]); break;
812 case KW_tile_path_2: thawer.get (tile_path [1]); break; 798 case KW_tile_path_2: thawer.get (tile_path [1]); break;
813 case KW_tile_path_3: thawer.get (tile_path [2]); break; 799 case KW_tile_path_3: thawer.get (tile_path [2]); break;
814 case KW_tile_path_4: thawer.get (tile_path [3]); break; 800 case KW_tile_path_4: thawer.get (tile_path [3]); break;
801
802 case KW_end:
803 return true;
804
805 default:
806 if (!thawer.parse_error ("map", 0))
807 return false;
808 break;
815 } 809 }
816 } 810 }
817 811
818 abort (); 812 abort ();
819} 813}
… …
932 * Remove and free all objects in the given map. 926 * Remove and free all objects in the given map.
933 */ 927 */
934void 928void
935maptile::clear () 929maptile::clear ()
936{ 930{
931 sfree (regions, size ()), regions = 0;
932 free (regionmap), regionmap = 0;
933
937 if (!spaces) 934 if (spaces)
938 return; 935 {
939
940 for (mapspace *ms = spaces + size (); ms-- > spaces; ) 936 for (mapspace *ms = spaces + size (); ms-- > spaces; )
941 while (object *op = ms->bot) 937 while (object *op = ms->bot)
942 { 938 {
943 if (op->head) 939 if (op->head)
944 op = op->head; 940 op = op->head;
945 941
946 op->destroy_inv (false); 942 op->destroy_inv (false);
947 op->destroy (); 943 op->destroy ();
948 } 944 }
949 945
950 sfree (spaces, size ()), spaces = 0; 946 sfree (spaces, size ()), spaces = 0;
947 }
951 948
952 if (buttons) 949 if (buttons)
953 free_objectlinkpt (buttons), buttons = 0; 950 free_objectlinkpt (buttons), buttons = 0;
954} 951}
955 952
… …
1277 faces [0] = top; faces_obj [0] = top != blank_face ? top_obj : 0; 1274 faces [0] = top; faces_obj [0] = top != blank_face ? top_obj : 0;
1278 faces [1] = middle; faces_obj [1] = middle != blank_face ? middle_obj : 0; 1275 faces [1] = middle; faces_obj [1] = middle != blank_face ? middle_obj : 0;
1279 faces [2] = floor; faces_obj [2] = floor != blank_face ? floor_obj : 0; 1276 faces [2] = floor; faces_obj [2] = floor != blank_face ? floor_obj : 0;
1280} 1277}
1281 1278
1279uint64
1280mapspace::volume () const
1281{
1282 uint64 vol = 0;
1283
1284 for (object *op = top; op && !op->flag [FLAG_NO_PICK]; op = op->below)
1285 vol += op->volume ();
1286
1287 return vol;
1288}
1289
1282/* this updates the orig_map->tile_map[tile_num] value after finding 1290/* this updates the orig_map->tile_map[tile_num] value after finding
1283 * the map. It also takes care of linking back the freshly found 1291 * the map. It also takes care of linking back the freshly found
1284 * maps tile_map values if it tiles back to this one. It returns 1292 * maps tile_map values if it tiles back to this one. It returns
1285 * the value of orig_map->tile_map[tile_num]. 1293 * the value of orig_map->tile_map[tile_num].
1286 */ 1294 */
… …
1449 1457
1450/** 1458/**
1451 * Return whether map2 is adjacent to map1. If so, store the distance from 1459 * Return whether map2 is adjacent to map1. If so, store the distance from
1452 * map1 to map2 in dx/dy. 1460 * map1 to map2 in dx/dy.
1453 */ 1461 */
1454static int 1462int
1455adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy) 1463adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
1456{ 1464{
1457 if (!map1 || !map2) 1465 if (!map1 || !map2)
1458 return 0; 1466 return 0;
1459 1467
… …
1571get_rangevector (object *op1, object *op2, rv_vector * retval, int flags) 1579get_rangevector (object *op1, object *op2, rv_vector * retval, int flags)
1572{ 1580{
1573 if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y)) 1581 if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))
1574 { 1582 {
1575 /* be conservative and fill in _some_ data */ 1583 /* be conservative and fill in _some_ data */
1576 retval->distance = 100000; 1584 retval->distance = 10000;
1577 retval->distance_x = 32767; 1585 retval->distance_x = 10000;
1578 retval->distance_y = 32767; 1586 retval->distance_y = 10000;
1579 retval->direction = 0; 1587 retval->direction = 0;
1580 retval->part = 0; 1588 retval->part = 0;
1581 } 1589 }
1582 else 1590 else
1583 { 1591 {
… …
1588 1596
1589 best = op1; 1597 best = op1;
1590 /* If this is multipart, find the closest part now */ 1598 /* If this is multipart, find the closest part now */
1591 if (!(flags & 0x1) && op1->more) 1599 if (!(flags & 0x1) && op1->more)
1592 { 1600 {
1593 object *tmp;
1594 int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi; 1601 int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi;
1595 1602
1596 /* we just take the offset of the piece to head to figure 1603 /* we just take the offset of the piece to head to figure
1597 * distance instead of doing all that work above again 1604 * distance instead of doing all that work above again
1598 * since the distance fields we set above are positive in the 1605 * since the distance fields we set above are positive in the
1599 * same axis as is used for multipart objects, the simply arithmetic 1606 * same axis as is used for multipart objects, the simply arithmetic
1600 * below works. 1607 * below works.
1601 */ 1608 */
1602 for (tmp = op1->more; tmp != NULL; tmp = tmp->more) 1609 for (object *tmp = op1->more; tmp; tmp = tmp->more)
1603 { 1610 {
1604 tmpi = (op1->x - tmp->x + retval->distance_x) * (op1->x - tmp->x + retval->distance_x) + 1611 tmpi = (op1->x - tmp->x + retval->distance_x) * (op1->x - tmp->x + retval->distance_x) +
1605 (op1->y - tmp->y + retval->distance_y) * (op1->y - tmp->y + retval->distance_y); 1612 (op1->y - tmp->y + retval->distance_y) * (op1->y - tmp->y + retval->distance_y);
1606 if (tmpi < best_distance) 1613 if (tmpi < best_distance)
1607 { 1614 {
… …
1616 retval->distance_y += op1->y - best->y; 1623 retval->distance_y += op1->y - best->y;
1617 } 1624 }
1618 } 1625 }
1619 1626
1620 retval->part = best; 1627 retval->part = best;
1621 retval->distance = idistance (retval->distance_x, retval->distance_y); 1628 retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y));
1622 retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y); 1629 retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y);
1623 } 1630 }
1624} 1631}
1625 1632
1626/* this is basically the same as get_rangevector above, but instead of 1633/* this is basically the same as get_rangevector above, but instead of
… …
1631 * flags has no meaning for this function at this time - I kept it in to 1638 * flags has no meaning for this function at this time - I kept it in to
1632 * be more consistant with the above function and also in case they are needed 1639 * be more consistant with the above function and also in case they are needed
1633 * for something in the future. Also, since no object is pasted, the best 1640 * for something in the future. Also, since no object is pasted, the best
1634 * field of the rv_vector is set to NULL. 1641 * field of the rv_vector is set to NULL.
1635 */ 1642 */
1636
1637void 1643void
1638get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags) 1644get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector *retval, int flags)
1639{ 1645{
1640 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y)) 1646 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
1641 { 1647 {
1642 /* be conservative and fill in _some_ data */ 1648 /* be conservative and fill in _some_ data */
1643 retval->distance = 100000; 1649 retval->distance = 100000;
… …
1680 op->remove (); 1686 op->remove ();
1681 1687
1682 return insert_ob_in_map_at (op, this, originator, flags, x, y); 1688 return insert_ob_in_map_at (op, this, originator, flags, x, y);
1683} 1689}
1684 1690
1691region *
1692maptile::region (int x, int y) const
1693{
1694 if (regions
1695 && regionmap
1696 && !OUT_OF_REAL_MAP (this, x, y))
1697 if (struct region *reg = regionmap [regions [y * width + x]])
1698 return reg;
1699
1700 if (default_region)
1701 return default_region;
1702
1703 return ::region::default_region ();
1704}
1705
1706

Diff Legend

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