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.180 by root, Thu Jan 14 23:46:14 2010 UTC vs.
Revision 1.190 by root, Sun Apr 18 05:55:04 2010 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001-2003,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001-2003 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * the terms of the Affero GNU General Public License as published by the 9 * the terms of the Affero GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version. 11 * option) any later version.
… …
23 */ 23 */
24 24
25#include <unistd.h> 25#include <unistd.h>
26 26
27#include "global.h" 27#include "global.h"
28#include "loader.h"
29#include "path.h" 28#include "path.h"
30 29
31//+GPL 30//+GPL
32 31
33sint8 maptile::outdoor_darkness; 32sint8 maptile::outdoor_darkness;
… …
111 /* 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
112 * 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
113 * true. If we get through the entire stack, that must mean 112 * true. If we get through the entire stack, that must mean
114 * ob is blocking it, so return 0. 113 * ob is blocking it, so return 0.
115 */ 114 */
116 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 115 for (object *tmp = ms.top; tmp; tmp = tmp->below)
117 { 116 {
118 if (OB_MOVE_BLOCK (ob, tmp)) 117 if (OB_MOVE_BLOCK (ob, tmp))
119 { 118 {
120 if (INVOKE_OBJECT (BLOCKED_MOVE, tmp, ob)) 119 if (INVOKE_OBJECT (BLOCKED_MOVE, tmp, ob))
121 if (RESULT_INT (0)) 120 if (RESULT_INT (0))
… …
145 return 1; // unconditional block 144 return 1; // unconditional block
146 145
147 } else { 146 } else {
148 // space does not block the ob, directly, but 147 // space does not block the ob, directly, but
149 // anything alive that is not a door still 148 // anything alive that is not a door still
150 // blocks anything but wizards. 149 // blocks anything
151 150
152 if (tmp->flag [FLAG_ALIVE] 151 if (tmp->flag [FLAG_ALIVE]
153 && tmp->head_ () != ob
154 && tmp != ob
155 && tmp->type != DOOR) 152 && tmp->type != DOOR
153 && tmp->head_ () != ob) //TODO: maybe move these check up?
156 return 1; 154 return 1;
157 } 155 }
158 } 156 }
159 157
160 return 0; 158 return 0;
161} 159}
162 160
163/* 161/*
164 * 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
165 * 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,
166 * just calling get_map_blocked and checking that against movement type 164 * just calling get_map_blocked and checking that against movement type
167 * 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
168 * object and makes sure they can be inserted. 166 * object and makes sure they can be inserted.
169 * 167 *
… …
423 return false; 421 return false;
424 422
425 return freezer.save (path); 423 return freezer.save (path);
426} 424}
427 425
428maptile::maptile () 426void
427maptile::init ()
429{ 428{
430 in_memory = MAP_SWAPPED; 429 in_memory = MAP_SWAPPED;
431 430
432 /* 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
433 * map archetype. Mimic that behaviour. 432 * map archetype. Mimic that behaviour.
434 */ 433 */
435 width = 16; 434 width = 16;
436 height = 16; 435 height = 16;
437 timeout = 300; 436 timeout = 300;
438 max_items = MAX_ITEM_PER_ACTION; 437 max_items = MAX_ITEM_PER_ACTION;
439 max_volume = 2000000; // 2m³ 438 max_volume = 2000000; // 2m³
440}
441
442maptile::maptile (int w, int h)
443{
444 in_memory = MAP_SWAPPED;
445
446 width = w;
447 height = h;
448 reset_timeout = 0; 439 reset_timeout = 0;
449 timeout = 300;
450 enter_x = 0; 440 enter_x = 0;
451 enter_y = 0; 441 enter_y = 0;
442}
443
444maptile::maptile ()
445{
446 init ();
447}
448
449maptile::maptile (int w, int h)
450{
451 init ();
452
453 width = w;
454 height = h;
452 455
453 alloc (); 456 alloc ();
454} 457}
455 458
456/* 459/*
… …
663 case KW_end: 666 case KW_end:
664 thawer.next (); 667 thawer.next ();
665 return true; 668 return true;
666 669
667 default: 670 default:
668 if (!thawer.parse_error ("map", 0)) 671 if (!thawer.parse_error ("map"))
669 return false; 672 return false;
670 break; 673 break;
671 } 674 }
672 675
673 thawer.next (); 676 thawer.next ();
… …
691 int unique = 0; 694 int unique = 0;
692 for (object *op = spaces [i].bot; op; ) 695 for (object *op = spaces [i].bot; op; )
693 { 696 {
694 object *above = op->above; 697 object *above = op->above;
695 698
696 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 699 if (op->flag [FLAG_IS_FLOOR] && op->flag [FLAG_UNIQUE])
697 unique = 1; 700 unique = 1;
698 701
699 if (op->head_ () == op && (QUERY_FLAG (op, FLAG_UNIQUE) || unique)) 702 if (op->head_ () == op && (op->flag [FLAG_UNIQUE] || unique))
700 op->destroy (); 703 op->destroy ();
701 704
702 op = above; 705 op = above;
703 } 706 }
704 } 707 }
… …
855 for (object *above, *op = ms->bot; op; op = above) 858 for (object *above, *op = ms->bot; op; op = above)
856 { 859 {
857 above = op->above; 860 above = op->above;
858 861
859 // do not decay anything above unique floor tiles (yet :) 862 // do not decay anything above unique floor tiles (yet :)
860 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 863 if (op->flag [FLAG_IS_FLOOR] && op->flag [FLAG_UNIQUE])
861 break; 864 break;
862 865
863 bool destroy = 0; 866 bool destroy = 0;
864 867
865 if (QUERY_FLAG (op, FLAG_IS_FLOOR) 868 if (op->flag [FLAG_IS_FLOOR]
866 || QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) 869 || op->flag [FLAG_OBJ_ORIGINAL]
867 || QUERY_FLAG (op, FLAG_UNIQUE) 870 || op->flag [FLAG_UNIQUE]
868 || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR) 871 || op->flag [FLAG_OVERLAY_FLOOR]
869 || QUERY_FLAG (op, FLAG_UNPAID) 872 || op->flag [FLAG_UNPAID]
870 || op->is_alive ()) 873 || op->is_alive ())
871 ; // do not decay 874 ; // do not decay
872 else if (op->is_weapon ()) 875 else if (op->is_weapon ())
873 { 876 {
874 op->stats.dam--; 877 op->stats.dam--;
… …
930 sint64 total_exp = 0; 933 sint64 total_exp = 0;
931 934
932 for (mapspace *ms = spaces + size (); ms-- > spaces; ) 935 for (mapspace *ms = spaces + size (); ms-- > spaces; )
933 for (object *op = ms->bot; op; op = op->above) 936 for (object *op = ms->bot; op; op = op->above)
934 { 937 {
935 if (QUERY_FLAG (op, FLAG_MONSTER)) 938 if (op->flag [FLAG_MONSTER])
936 { 939 {
937 total_exp += op->stats.exp; 940 total_exp += op->stats.exp;
938 monster_cnt++; 941 monster_cnt++;
939 } 942 }
940 943
941 if (QUERY_FLAG (op, FLAG_GENERATOR)) 944 if (op->flag [FLAG_GENERATOR])
942 { 945 {
943 total_exp += op->stats.exp; 946 total_exp += op->stats.exp;
944 947
945 if (archetype *at = op->other_arch) 948 if (archetype *at = op->other_arch)
946 { 949 {
… …
1128 */ 1131 */
1129 1132
1130 for (object *tmp = last; tmp; tmp = tmp->below) 1133 for (object *tmp = last; tmp; tmp = tmp->below)
1131 { 1134 {
1132 /* Once we get to a floor, stop, since we already have a floor object */ 1135 /* Once we get to a floor, stop, since we already have a floor object */
1133 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1136 if (tmp->flag [FLAG_IS_FLOOR])
1134 break; 1137 break;
1135 1138
1136 /* If two top faces are already set, quit processing */ 1139 /* If two top faces are already set, quit processing */
1137 if (top && middle) 1140 if (top && middle)
1138 break; 1141 break;
… …
1421 * 1424 *
1422 * currently, the only flag supported (0x1) is don't translate for 1425 * currently, the only flag supported (0x1) is don't translate for
1423 * closest body part of 'op1' 1426 * closest body part of 'op1'
1424 */ 1427 */
1425void 1428void
1426get_rangevector (object *op1, object *op2, rv_vector * retval, int flags) 1429get_rangevector (object *op1, object *op2, rv_vector *retval, int flags)
1427{ 1430{
1428 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))
1429 { 1432 {
1430 /* be conservative and fill in _some_ data */ 1433 /* be conservative and fill in _some_ data */
1431 retval->distance = 10000; 1434 retval->distance = 10000;
1432 retval->distance_x = 10000; 1435 retval->distance_x = 10000;
1433 retval->distance_y = 10000; 1436 retval->distance_y = 10000;
1434 retval->direction = 0; 1437 retval->direction = 0;
1435 retval->part = 0; 1438 retval->part = 0;
1436 } 1439 }
1437 else 1440 else
1438 { 1441 {
1439 object *best;
1440
1441 retval->distance_x += op2->x - op1->x; 1442 retval->distance_x += op2->x - op1->x;
1442 retval->distance_y += op2->y - op1->y; 1443 retval->distance_y += op2->y - op1->y;
1443 1444
1444 best = op1; 1445 object *best = op1;
1446
1445 /* If this is multipart, find the closest part now */ 1447 /* If this is multipart, find the closest part now */
1446 if (!(flags & 0x1) && op1->more) 1448 if (!(flags & 1) && op1->more)
1447 { 1449 {
1448 int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi; 1450 int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi;
1449 1451
1450 /* 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
1451 * distance instead of doing all that work above again 1453 * distance instead of doing all that work above again
… …
1564 */ 1566 */
1565 for (int i = 1000; --i;) 1567 for (int i = 1000; --i;)
1566 { 1568 {
1567 object *pick = at (gen (width), gen (height)).bot; 1569 object *pick = at (gen (width), gen (height)).bot;
1568 1570
1569 // do not prefer big monsters just because they are big. 1571 // must be head: do not prefer big monsters just because they are big.
1570 if (pick && pick->is_head ()) 1572 if (pick && pick->is_head ())
1571 return pick->head_ (); 1573 return pick;
1572 } 1574 }
1573 1575
1574 // instead of crashing in the unlikely(?) case, try to return *something* 1576 // instead of crashing in the unlikely(?) case, try to return *something*
1575 return archetype::find (shstr_bug); 1577 return archetype::find (shstr_bug);
1576} 1578}
… …
1609 1611
1610 if (distance <= MAX_SOUND_DISTANCE) 1612 if (distance <= MAX_SOUND_DISTANCE)
1611 ns->send_msg (NDI_GREY | NDI_DEF, SAY_CHANNEL, msg); 1613 ns->send_msg (NDI_GREY | NDI_DEF, SAY_CHANNEL, msg);
1612 } 1614 }
1613} 1615}
1616
1617dynbuf mapwalk_buf (sizeof (maprect) * 25, sizeof (maprect) * 25);
1614 1618
1615static void 1619static void
1616split_to_tiles (dynbuf &buf, maptile *m, int x0, int y0, int x1, int y1, int dx, int dy) 1620split_to_tiles (dynbuf &buf, maptile *m, int x0, int y0, int x1, int y1, int dx, int dy)
1617{ 1621{
1618 // clip to map to the left 1622 // clip to map to the left
… …
1674 r->dx = dx; 1678 r->dx = dx;
1675 r->dy = dy; 1679 r->dy = dy;
1676} 1680}
1677 1681
1678maprect * 1682maprect *
1679maptile::split_to_tiles (int x0, int y0, int x1, int y1) 1683maptile::split_to_tiles (dynbuf &buf, int x0, int y0, int x1, int y1)
1680{ 1684{
1681 static dynbuf buf (sizeof (maprect) * 8, sizeof (maprect) * 8);
1682 buf.clear (); 1685 buf.clear ();
1683 1686
1684 ::split_to_tiles (buf, this, x0, y0, x1, y1, 0, 0); 1687 ::split_to_tiles (buf, this, x0, y0, x1, y1, 0, 0);
1685 1688
1686 // add end marker 1689 // add end marker

Diff Legend

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