ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/map.C
Revision: 1.63
Committed: Mon Jan 1 00:41:02 2007 UTC (17 years, 5 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.62: +1 -0 lines
Log Message:
use freezer api for saving players, too

File Contents

# Content
1 /*
2 CrossFire, A Multiplayer game for X-windows
3
4 Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
21 The authors can be reached via e-mail at <crossfire@schmorp.de>
22 */
23
24 #include <global.h>
25 #include <funcpoint.h>
26
27 #include <loader.h>
28 #include <unistd.h>
29
30 #include "path.h"
31
32 /*
33 * This makes a path absolute outside the world of Crossfire.
34 * In other words, it prepends LIBDIR/MAPDIR/ to the given path
35 * and returns the pointer to a static array containing the result.
36 * it really should be called create_mapname
37 */
38 const char *
39 create_pathname (const char *name)
40 {
41 static char buf[8192];
42 snprintf (buf, sizeof (buf), "%s/%s/%s", settings.datadir, settings.mapdir, name);
43 return buf;
44 }
45
46 /*
47 * This function checks if a file with the given path exists.
48 * -1 is returned if it fails, otherwise the mode of the file
49 * is returned.
50 * It tries out all the compression suffixes listed in the uncomp[] array.
51 *
52 * If prepend_dir is set, then we call create_pathname (which prepends
53 * libdir & mapdir). Otherwise, we assume the name given is fully
54 * complete.
55 * Only the editor actually cares about the writablity of this -
56 * the rest of the code only cares that the file is readable.
57 * when the editor goes away, the call to stat should probably be
58 * replaced by an access instead (similar to the windows one, but
59 * that seems to be missing the prepend_dir processing
60 */
61 int
62 check_path (const char *name, int prepend_dir)
63 {
64 char buf[MAX_BUF];
65
66 char *endbuf;
67 struct stat statbuf;
68 int mode = 0;
69
70 if (prepend_dir)
71 strcpy (buf, create_pathname (name));
72 else
73 strcpy (buf, name);
74
75 /* old method (strchr(buf, '\0')) seemd very odd to me -
76 * this method should be equivalant and is clearer.
77 * Can not use strcat because we need to cycle through
78 * all the names.
79 */
80 endbuf = buf + strlen (buf);
81
82 if (stat (buf, &statbuf))
83 return -1;
84 if (!S_ISREG (statbuf.st_mode))
85 return (-1);
86
87 if (((statbuf.st_mode & S_IRGRP) && getegid () == statbuf.st_gid) ||
88 ((statbuf.st_mode & S_IRUSR) && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IROTH))
89 mode |= 4;
90
91 if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) ||
92 (statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IWOTH))
93 mode |= 2;
94
95 return (mode);
96 }
97
98 /* This rolls up wall, blocks_magic, blocks_view, etc, all into
99 * one function that just returns a P_.. value (see map.h)
100 * it will also do map translation for tiled maps, returning
101 * new values into newmap, nx, and ny. Any and all of those
102 * values can be null, in which case if a new map is needed (returned
103 * by a P_NEW_MAP value, another call to get_map_from_coord
104 * is needed. The case of not passing values is if we're just
105 * checking for the existence of something on those spaces, but
106 * don't expect to insert/remove anything from those spaces.
107 */
108 int
109 get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 *nx, sint16 *ny)
110 {
111 sint16 newx = x;
112 sint16 newy = y;
113
114 maptile *mp = get_map_from_coord (oldmap, &newx, &newy);
115
116 if (!mp)
117 return P_OUT_OF_MAP;
118
119 if (newmap) *newmap = mp;
120 if (nx) *nx = newx;
121 if (ny) *ny = newy;
122
123 return mp->at (newx, newy).flags () | (mp != oldmap ? P_NEW_MAP : 0);
124 }
125
126 /*
127 * Returns true if the given coordinate is blocked except by the
128 * object passed is not blocking. This is used with
129 * multipart monsters - if we want to see if a 2x2 monster
130 * can move 1 space to the left, we don't want its own area
131 * to block it from moving there.
132 * Returns TRUE if the space is blocked by something other than the
133 * monster.
134 * m, x, y are the target map/coordinates - needed for map tiling.
135 * the coordinates & map passed in should have been updated for tiling
136 * by the caller.
137 */
138 int
139 blocked_link (object *ob, maptile *m, int sx, int sy)
140 {
141 object *tmp;
142 int mflags, blocked;
143
144 /* Make sure the coordinates are valid - they should be, as caller should
145 * have already checked this.
146 */
147 if (OUT_OF_REAL_MAP (m, sx, sy))
148 {
149 LOG (llevError, "blocked_link: Passed map, x, y coordinates outside of map\n");
150 return 1;
151 }
152
153 /* Save some cycles - instead of calling get_map_flags(), just get the value
154 * directly.
155 */
156 mflags = m->at (sx, sy).flags ();
157
158 blocked = GET_MAP_MOVE_BLOCK (m, sx, sy);
159
160 /* If space is currently not blocked by anything, no need to
161 * go further. Not true for players - all sorts of special
162 * things we need to do for players.
163 */
164 if (ob->type != PLAYER && !(mflags & P_IS_ALIVE) && (blocked == 0))
165 return 0;
166
167 /* if there isn't anytyhing alive on this space, and this space isn't
168 * otherwise blocked, we can return now. Only if there is a living
169 * creature do we need to investigate if it is part of this creature
170 * or another. Likewise, only if something is blocking us do we
171 * need to investigate if there is a special circumstance that would
172 * let the player through (inventory checkers for example)
173 */
174 if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (ob, blocked))
175 return 0;
176
177 if (ob->head != NULL)
178 ob = ob->head;
179
180 /* We basically go through the stack of objects, and if there is
181 * some other object that has NO_PASS or FLAG_ALIVE set, return
182 * true. If we get through the entire stack, that must mean
183 * ob is blocking it, so return 0.
184 */
185 for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
186 {
187
188 /* This must be before the checks below. Code for inventory checkers. */
189 if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp))
190 {
191 /* If last_sp is set, the player/monster needs an object,
192 * so we check for it. If they don't have it, they can't
193 * pass through this space.
194 */
195 if (tmp->last_sp)
196 {
197 if (check_inv_recursive (ob, tmp) == NULL)
198 return 1;
199 else
200 continue;
201 }
202 else
203 {
204 /* In this case, the player must not have the object -
205 * if they do, they can't pass through.
206 */
207 if (check_inv_recursive (ob, tmp) != NULL) /* player has object */
208 return 1;
209 else
210 continue;
211 }
212 } /* if check_inv */
213 else
214 {
215 /* Broke apart a big nasty if into several here to make
216 * this more readable. first check - if the space blocks
217 * movement, can't move here.
218 * second - if a monster, can't move there, unles it is a
219 * hidden dm
220 */
221 if (OB_MOVE_BLOCK (ob, tmp))
222 return 1;
223 if (QUERY_FLAG (tmp, FLAG_ALIVE) && tmp->head != ob && tmp != ob &&
224 tmp->type != DOOR && !(QUERY_FLAG (tmp, FLAG_WIZ) && tmp->contr->hidden))
225 return 1;
226 }
227
228 }
229 return 0;
230 }
231
232
233 /*
234 * Returns true if the given object can't fit in the given spot.
235 * This is meant for multi space objects - for single space objecs,
236 * just calling get_map_blocked and checking that against movement type
237 * of object. This function goes through all the parts of the
238 * multipart object and makes sure they can be inserted.
239 *
240 * While this doesn't call out of map, the get_map_flags does.
241 *
242 * This function has been used to deprecate arch_out_of_map -
243 * this function also does that check, and since in most cases,
244 * a call to one would follow the other, doesn't make a lot of sense to
245 * have two seperate functions for this.
246 *
247 * This returns nonzero if this arch can not go on the space provided,
248 * 0 otherwise. the return value will contain the P_.. value
249 * so the caller can know why this object can't go on the map.
250 * Note that callers should not expect P_NEW_MAP to be set
251 * in return codes - since the object is multispace - if
252 * we did return values, what do you return if half the object
253 * is one map, half on another.
254 *
255 * Note this used to be arch_blocked, but with new movement
256 * code, we need to have actual object to check its move_type
257 * against the move_block values.
258 */
259 int
260 ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y)
261 {
262 archetype *tmp;
263 int flag;
264 maptile *m1;
265 sint16 sx, sy;
266
267 if (!ob)
268 {
269 flag = get_map_flags (m, &m1, x, y, &sx, &sy);
270 if (flag & P_OUT_OF_MAP)
271 return P_OUT_OF_MAP;
272
273 /* don't have object, so don't know what types would block */
274 return m1->at (sx, sy).move_block;
275 }
276
277 for (tmp = ob->arch; tmp; tmp = tmp->more)
278 {
279 flag = get_map_flags (m, &m1, x + tmp->clone.x, y + tmp->clone.y, &sx, &sy);
280
281 if (flag & P_OUT_OF_MAP)
282 return P_OUT_OF_MAP;
283 if (flag & P_IS_ALIVE)
284 return P_IS_ALIVE;
285
286 mapspace &ms = m1->at (sx, sy);
287
288 /* find_first_free_spot() calls this function. However, often
289 * ob doesn't have any move type (when used to place exits)
290 * so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.
291 */
292
293 if (ob->move_type == 0 && ms.move_block != MOVE_ALL)
294 continue;
295
296 /* Note it is intentional that we check ob - the movement type of the
297 * head of the object should correspond for the entire object.
298 */
299 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
300 return P_NO_PASS;
301 }
302
303 return 0;
304 }
305
306 /* When the map is loaded, load_object does not actually insert objects
307 * into inventory, but just links them. What this does is go through
308 * and insert them properly.
309 * The object 'container' is the object that contains the inventory.
310 * This is needed so that we can update the containers weight.
311 */
312 void
313 fix_container (object *container)
314 {
315 object *tmp = container->inv, *next;
316
317 container->inv = 0;
318 while (tmp)
319 {
320 next = tmp->below;
321 if (tmp->inv)
322 fix_container (tmp);
323
324 insert_ob_in_ob (tmp, container);
325 tmp = next;
326 }
327
328 /* sum_weight will go through and calculate what all the containers are
329 * carrying.
330 */
331 sum_weight (container);
332 }
333
334 /* link_multipart_objects go through all the objects on the map looking
335 * for objects whose arch says they are multipart yet according to the
336 * info we have, they only have the head (as would be expected when
337 * they are saved). We do have to look for the old maps that did save
338 * the more sections and not re-add sections for them.
339 */
340 void
341 maptile::link_multipart_objects ()
342 {
343 if (!spaces)
344 return;
345
346 for (mapspace *ms = spaces + size (); ms-- > spaces; )
347 for (object *tmp = ms->bot; tmp; )
348 {
349 object *above = tmp->above;
350
351 /* already multipart - don't do anything more */
352 if (!tmp->head && !tmp->more)
353 {
354 /* If there is nothing more to this object, this for loop
355 * won't do anything.
356 */
357 archetype *at;
358 object *last, *op;
359 for (at = tmp->arch->more, last = tmp;
360 at;
361 at = at->more, last = op)
362 {
363 op = arch_to_object (at);
364
365 /* update x,y coordinates */
366 op->x += tmp->x;
367 op->y += tmp->y;
368 op->head = tmp;
369 op->map = this;
370 last->more = op;
371 op->name = tmp->name;
372 op->title = tmp->title;
373
374 /* we could link all the parts onto tmp, and then just
375 * call insert_ob_in_map once, but the effect is the same,
376 * as insert_ob_in_map will call itself with each part, and
377 * the coding is simpler to just to it here with each part.
378 */
379 insert_ob_in_map (op, op->map, tmp, INS_NO_MERGE | INS_ABOVE_FLOOR_ONLY | INS_NO_WALK_ON);
380 }
381 }
382
383 tmp = above;
384 }
385 }
386
387 /*
388 * Loads (ands parses) the objects into a given map from the specified
389 * file pointer.
390 * mapflags is the same as we get with load_original_map
391 */
392 bool
393 maptile::load_objects (object_thawer &thawer)
394 {
395 int unique;
396 object *op, *prev = NULL, *last_more = NULL, *otmp;
397
398 op = object::create ();
399 op->map = this; /* To handle buttons correctly */
400
401 while (int i = load_object (thawer, op, 0))
402 {
403 /* if the archetype for the object is null, means that we
404 * got an invalid object. Don't do anything with it - the game
405 * or editor will not be able to do anything with it either.
406 */
407 if (op->arch == NULL)
408 {
409 LOG (llevDebug, "Discarding object without arch: %s\n", op->name ? (const char *) op->name : "(null)");
410 continue;
411 }
412
413 switch (i)
414 {
415 case LL_NORMAL:
416 insert_ob_in_map (op, this, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);
417
418 if (op->inv)
419 sum_weight (op);
420
421 prev = op, last_more = op;
422 break;
423
424 case LL_MORE:
425 insert_ob_in_map (op, this, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY);
426 op->head = prev, last_more->more = op, last_more = op;
427 break;
428 }
429
430 op = object::create ();
431 op->map = this;
432 }
433
434 op->destroy ();
435
436 #if 0
437 for (i = 0; i < width; i++)
438 for (j = 0; j < height; j++)
439 {
440 unique = 0;
441 /* check for unique items, or unique squares */
442 for (otmp = GET_MAP_OB (m, i, j); otmp; otmp = otmp->above)
443 {
444 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))
445 unique = 1;
446
447 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
448 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
449 }
450 }
451 #endif
452
453 return true;
454 }
455
456 void
457 maptile::activate ()
458 {
459 if (!spaces)
460 return;
461
462 for (mapspace *ms = spaces + size (); ms-- > spaces; )
463 for (object *op = ms->bot; op; op = op->above)
464 op->activate_recursive ();
465 }
466
467 void
468 maptile::deactivate ()
469 {
470 if (!spaces)
471 return;
472
473 for (mapspace *ms = spaces + size (); ms-- > spaces; )
474 for (object *op = ms->bot; op; op = op->above)
475 op->deactivate_recursive ();
476 }
477
478 bool
479 maptile::save_objects (object_freezer &freezer, int flags)
480 {
481 if (flags & IO_HEADER)
482 save_header (freezer);
483
484 if (!spaces)
485 return false;
486
487 for (int i = 0; i < size (); ++i)
488 {
489 int unique = 0;
490 for (object *op = spaces [i].bot; op; op = op->above)
491 {
492 if (op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR])
493 unique = 1;
494
495 if (!op->can_map_save ())
496 continue;
497
498 if (unique || op->flag [FLAG_UNIQUE])
499 {
500 if (flags & IO_UNIQUES)
501 save_object (freezer, op, 1);
502 }
503 else if (flags & IO_OBJECTS)
504 save_object (freezer, op, 1);
505 }
506 }
507
508 return true;
509 }
510
511 bool
512 maptile::load_objects (const char *path, bool skip_header)
513 {
514 object_thawer thawer (path);
515
516 if (!thawer)
517 return false;
518
519 if (skip_header)
520 for (;;)
521 {
522 keyword kw = thawer.get_kv ();
523
524 if (kw == KW_end)
525 break;
526
527 thawer.skip_kv (kw);
528 }
529
530 return load_objects (thawer);
531 }
532
533 bool
534 maptile::save_objects (const char *path, int flags)
535 {
536 object_freezer freezer;
537
538 if (!save_objects (freezer, flags))
539 return false;
540
541 return freezer.save (path);
542 }
543
544 maptile::maptile ()
545 {
546 in_memory = MAP_SWAPPED;
547
548 /* The maps used to pick up default x and y values from the
549 * map archetype. Mimic that behaviour.
550 */
551 width = 16;
552 height = 16;
553 reset_timeout = 0;
554 timeout = 300;
555 enter_x = 0;
556 enter_y = 0;
557 }
558
559 maptile::maptile (int w, int h)
560 {
561 in_memory = MAP_SWAPPED;
562
563 width = w;
564 height = h;
565 reset_timeout = 0;
566 timeout = 300;
567 enter_x = 0;
568 enter_y = 0;
569
570 alloc ();
571 }
572
573 /*
574 * Allocates the arrays contained in a maptile.
575 * This basically allocates the dynamic array of spaces for the
576 * map.
577 */
578 void
579 maptile::alloc ()
580 {
581 if (spaces)
582 return;
583
584 spaces = salloc0<mapspace> (size ());
585 }
586
587 /* Takes a string from a map definition and outputs a pointer to the array of shopitems
588 * corresponding to that string. Memory is allocated for this, it must be freed
589 * at a later date.
590 * Called by parse_map_headers below.
591 */
592 static shopitems *
593 parse_shop_string (const char *input_string)
594 {
595 char *shop_string, *p, *q, *next_semicolon, *next_colon;
596 shopitems *items = NULL;
597 int i = 0, number_of_entries = 0;
598 const typedata *current_type;
599
600 shop_string = strdup (input_string);
601 p = shop_string;
602 /* first we'll count the entries, we'll need that for allocating the array shortly */
603 while (p)
604 {
605 p = strchr (p, ';');
606 number_of_entries++;
607 if (p)
608 p++;
609 }
610
611 p = shop_string;
612 strip_endline (p);
613 items = new shopitems[number_of_entries + 1];
614 for (i = 0; i < number_of_entries; i++)
615 {
616 if (!p)
617 {
618 LOG (llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n");
619 break;
620 }
621
622 next_semicolon = strchr (p, ';');
623 next_colon = strchr (p, ':');
624 /* if there is a stregth specified, figure out what it is, we'll need it soon. */
625 if (next_colon && (!next_semicolon || next_colon < next_semicolon))
626 items[i].strength = atoi (strchr (p, ':') + 1);
627
628 if (isdigit (*p) || *p == '*')
629 {
630 items[i].typenum = atoi (p); /* atoi returns 0 when we have an asterisk */
631 current_type = get_typedata (items[i].typenum);
632 if (current_type)
633 {
634 items[i].name = current_type->name;
635 items[i].name_pl = current_type->name_pl;
636 }
637 }
638 else
639 { /*we have a named type, let's figure out what it is */
640 q = strpbrk (p, ";:");
641 if (q)
642 *q = '\0';
643
644 current_type = get_typedata_by_name (p);
645 if (current_type)
646 {
647 items[i].name = current_type->name;
648 items[i].typenum = current_type->number;
649 items[i].name_pl = current_type->name_pl;
650 }
651 else
652 { /* oh uh, something's wrong, let's free up this one, and try
653 * the next entry while we're at it, better print a warning
654 */
655 LOG (llevError, "invalid type %s defined in shopitems in string %s\n", p, input_string);
656 }
657 }
658
659 items[i].index = number_of_entries;
660 if (next_semicolon)
661 p = ++next_semicolon;
662 else
663 p = NULL;
664 }
665
666 free (shop_string);
667 return items;
668 }
669
670 /* opposite of parse string, this puts the string that was originally fed in to
671 * the map (or something equivilent) into output_string. */
672 static void
673 print_shop_string (maptile *m, char *output_string)
674 {
675 int i;
676 char tmp[MAX_BUF];
677
678 strcpy (output_string, "");
679 for (i = 0; i < m->shopitems[0].index; i++)
680 {
681 if (m->shopitems[i].typenum)
682 {
683 if (m->shopitems[i].strength)
684 sprintf (tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);
685 else
686 sprintf (tmp, "%s;", m->shopitems[i].name);
687 }
688 else
689 {
690 if (m->shopitems[i].strength)
691 sprintf (tmp, "*:%d;", m->shopitems[i].strength);
692 else
693 sprintf (tmp, "*");
694 }
695
696 strcat (output_string, tmp);
697 }
698 }
699
700 /* This loads the header information of the map. The header
701 * contains things like difficulty, size, timeout, etc.
702 * this used to be stored in the map object, but with the
703 * addition of tiling, fields beyond that easily named in an
704 * object structure were needed, so it just made sense to
705 * put all the stuff in the map object so that names actually make
706 * sense.
707 * This could be done in lex (like the object loader), but I think
708 * currently, there are few enough fields this is not a big deal.
709 * MSW 2001-07-01
710 */
711 bool
712 maptile::load_header (object_thawer &thawer)
713 {
714 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;
715 int msgpos = 0;
716 int maplorepos = 0;
717
718 for (;;)
719 {
720 keyword kw = thawer.get_kv ();
721
722 switch (kw)
723 {
724 case KW_EOF:
725 LOG (llevError, "%s: end of file while reading map header, aborting header load.\n", &path);
726 return false;
727
728 case KW_end:
729 return true;
730
731 case KW_msg:
732 thawer.get_ml (KW_endmsg, msg);
733 break;
734
735 case KW_lore: // CF+ extension
736 thawer.get_ml (KW_endlore, maplore);
737 break;
738
739 case KW_maplore:
740 thawer.get_ml (KW_endmaplore, maplore);
741 break;
742
743 case KW_arch:
744 if (strcmp (thawer.get_str (), "map"))
745 LOG (llevError, "%s: loading map and got a non 'arch map' line (arch %s), skipping.\n", &path, thawer.get_str ());
746 break;
747
748 case KW_oid:
749 thawer.get (this, thawer.get_sint32 ());
750 break;
751
752 case KW_file_format_version: break; // nop
753
754 case KW_name: thawer.get (name); break;
755 case KW_attach: thawer.get (attach); break;
756 case KW_reset_time: thawer.get (reset_time); break;
757 case KW_shopgreed: thawer.get (shopgreed); break;
758 case KW_shopmin: thawer.get (shopmin); break;
759 case KW_shopmax: thawer.get (shopmax); break;
760 case KW_shoprace: thawer.get (shoprace); break;
761 case KW_outdoor: thawer.get (outdoor); break;
762 case KW_temp: thawer.get (temp); break;
763 case KW_pressure: thawer.get (pressure); break;
764 case KW_humid: thawer.get (humid); break;
765 case KW_windspeed: thawer.get (windspeed); break;
766 case KW_winddir: thawer.get (winddir); break;
767 case KW_sky: thawer.get (sky); break;
768
769 case KW_per_player: thawer.get (per_player); break;
770 case KW_per_party: thawer.get (per_party); break;
771
772 case KW_region: get_region_by_name (thawer.get_str ()); break;
773 case KW_shopitems: shopitems = parse_shop_string (thawer.get_str ()); break;
774
775 // old names new names
776 case KW_hp: case KW_enter_x: thawer.get (enter_x); break;
777 case KW_sp: case KW_enter_y: thawer.get (enter_y); break;
778 case KW_x: case KW_width: thawer.get (width); break;
779 case KW_y: case KW_height: thawer.get (height); break;
780 case KW_weight: case KW_reset_timeout: thawer.get (reset_timeout); break;
781 case KW_value: case KW_swap_time: thawer.get (timeout); break;
782 case KW_level: case KW_difficulty: thawer.get (difficulty); difficulty = clamp (difficulty, 1, settings.max_level); break;
783 case KW_invisible: case KW_darkness: thawer.get (darkness); break;
784 case KW_stand_still: case KW_fixed_resettime: thawer.get (fixed_resettime); break;
785
786 case KW_tile_path_1: thawer.get (tile_path [0]); break;
787 case KW_tile_path_2: thawer.get (tile_path [1]); break;
788 case KW_tile_path_3: thawer.get (tile_path [2]); break;
789 case KW_tile_path_4: thawer.get (tile_path [3]); break;
790
791 default:
792 LOG (llevError, "%s: skipping unknown key in map header: %s\n", &path, keyword_str [kw]);
793 break;
794 }
795 }
796
797 abort ();
798 }
799
800 bool
801 maptile::load_header (const char *path)
802 {
803 object_thawer thawer (path);
804
805 if (!thawer)
806 return false;
807
808 return load_header (thawer);
809 }
810
811 /******************************************************************************
812 * This is the start of unique map handling code
813 *****************************************************************************/
814
815 /* This goes through the maptile and removed any unique items on the map. */
816 void
817 maptile::clear_unique_items ()
818 {
819 for (int i = 0; i < size (); ++i)
820 {
821 int unique = 0;
822 for (object *op = spaces [i].bot; op; )
823 {
824 object *above = op->above;
825
826 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
827 unique = 1;
828
829 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
830 {
831 op->destroy_inv (false);
832 op->destroy ();
833 }
834
835 op = above;
836 }
837 }
838 }
839
840 bool
841 maptile::save_header (object_freezer &freezer)
842 {
843 #define MAP_OUT(k) freezer.put (KW_ ## k, k)
844 #define MAP_OUT2(k,v) freezer.put (KW_ ## k, v)
845
846 MAP_OUT2 (arch, "map");
847
848 if (name) MAP_OUT (name);
849 MAP_OUT (swap_time);
850 MAP_OUT (reset_time);
851 MAP_OUT (reset_timeout);
852 MAP_OUT (fixed_resettime);
853 MAP_OUT (difficulty);
854
855 if (region) MAP_OUT2 (region, region->name);
856
857 if (shopitems)
858 {
859 char shop[MAX_BUF];
860 print_shop_string (this, shop);
861 MAP_OUT2 (shopitems, shop);
862 }
863
864 MAP_OUT (shopgreed);
865 MAP_OUT (shopmin);
866 MAP_OUT (shopmax);
867 if (shoprace) MAP_OUT (shoprace);
868 MAP_OUT (darkness);
869 MAP_OUT (width);
870 MAP_OUT (height);
871 MAP_OUT (enter_x);
872 MAP_OUT (enter_y);
873
874 if (msg) freezer.put (KW_msg , KW_endmsg , msg);
875 if (maplore) freezer.put (KW_maplore, KW_endmaplore, maplore);
876
877 MAP_OUT (outdoor);
878 MAP_OUT (temp);
879 MAP_OUT (pressure);
880 MAP_OUT (humid);
881 MAP_OUT (windspeed);
882 MAP_OUT (winddir);
883 MAP_OUT (sky);
884
885 MAP_OUT (per_player);
886 MAP_OUT (per_party);
887
888 if (tile_path [0]) MAP_OUT2 (tile_path_1, tile_path [0]);
889 if (tile_path [1]) MAP_OUT2 (tile_path_2, tile_path [1]);
890 if (tile_path [2]) MAP_OUT2 (tile_path_3, tile_path [2]);
891 if (tile_path [3]) MAP_OUT2 (tile_path_4, tile_path [3]);
892
893 freezer.put (this);
894 freezer.put (KW_end);
895
896 return true;
897 }
898
899 bool
900 maptile::save_header (const char *path)
901 {
902 object_freezer freezer;
903
904 if (!save_header (freezer))
905 return false;
906
907 return freezer.save (path);
908 }
909
910 /*
911 * Remove and free all objects in the given map.
912 */
913 void
914 maptile::clear ()
915 {
916 if (!spaces)
917 return;
918
919 for (mapspace *ms = spaces + size (); ms-- > spaces; )
920 while (object *op = ms->bot)
921 {
922 if (op->head)
923 op = op->head;
924
925 op->destroy_inv (false);
926 op->destroy ();
927 }
928
929 sfree (spaces, size ()), spaces = 0;
930
931 if (buttons)
932 free_objectlinkpt (buttons), buttons = 0;
933 }
934
935 void
936 maptile::clear_header ()
937 {
938 name = 0;
939 msg = 0;
940 maplore = 0;
941 shoprace = 0;
942 delete [] shopitems, shopitems = 0;
943
944 for (int i = 0; i < 4; i++)
945 tile_path [i] = 0;
946 }
947
948 maptile::~maptile ()
949 {
950 assert (destroyed ());
951 }
952
953 void
954 maptile::clear_links_to (maptile *m)
955 {
956 /* We need to look through all the maps and see if any maps
957 * are pointing at this one for tiling information. Since
958 * tiling can be asymetric, we just can not look to see which
959 * maps this map tiles with and clears those.
960 */
961 for (int i = 0; i < 4; i++)
962 if (tile_map[i] == m)
963 tile_map[i] = 0;
964 }
965
966 void
967 maptile::do_destroy ()
968 {
969 attachable::do_destroy ();
970
971 clear ();
972 }
973
974 /*
975 * Updates every button on the map (by calling update_button() for them).
976 */
977 void
978 maptile::update_buttons ()
979 {
980 for (oblinkpt *obp = buttons; obp; obp = obp->next)
981 for (objectlink *ol = obp->link; ol; ol = ol->next)
982 {
983 if (!ol->ob)
984 {
985 LOG (llevError, "Internal error in update_button (%s (%dx%d), connected %ld).\n",
986 ol->ob ? (const char *) ol->ob->name : "null", ol->ob ? ol->ob->x : -1, ol->ob ? ol->ob->y : -1, obp->value);
987 continue;
988 }
989
990 if (ol->ob->type == BUTTON || ol->ob->type == PEDESTAL)
991 {
992 update_button (ol->ob);
993 break;
994 }
995 }
996 }
997
998 /*
999 * This routine is supposed to find out the difficulty of the map.
1000 * difficulty does not have a lot to do with character level,
1001 * but does have a lot to do with treasure on the map.
1002 *
1003 * Difficulty can now be set by the map creature. If the value stored
1004 * in the map is zero, then use this routine. Maps should really
1005 * have a difficulty set than using this function - human calculation
1006 * is much better than this functions guesswork.
1007 */
1008 int
1009 maptile::estimate_difficulty () const
1010 {
1011 long monster_cnt = 0;
1012 double avgexp = 0;
1013 sint64 total_exp = 0;
1014
1015 for (mapspace *ms = spaces + size (); ms-- > spaces; )
1016 for (object *op = ms->bot; op; op = op->above)
1017 {
1018 if (QUERY_FLAG (op, FLAG_MONSTER))
1019 {
1020 total_exp += op->stats.exp;
1021 monster_cnt++;
1022 }
1023
1024 if (QUERY_FLAG (op, FLAG_GENERATOR))
1025 {
1026 total_exp += op->stats.exp;
1027
1028 if (archetype *at = type_to_archetype (GENERATE_TYPE (op)))
1029 total_exp += at->clone.stats.exp * 8;
1030
1031 monster_cnt++;
1032 }
1033 }
1034
1035 avgexp = (double) total_exp / monster_cnt;
1036
1037 for (int i = 1; i <= settings.max_level; i++)
1038 if ((level_exp (i, 1) - level_exp (i - 1, 1)) > (100 * avgexp))
1039 return i;
1040
1041 return 1;
1042 }
1043
1044 /* change_map_light() - used to change map light level (darkness)
1045 * up or down. Returns true if successful. It should now be
1046 * possible to change a value by more than 1.
1047 * Move this from los.c to map.c since this is more related
1048 * to maps than los.
1049 * postive values make it darker, negative make it brighter
1050 */
1051 int
1052 maptile::change_map_light (int change)
1053 {
1054 int new_level = darkness + change;
1055
1056 /* Nothing to do */
1057 if (!change || (new_level <= 0 && darkness == 0) || (new_level >= MAX_DARKNESS && darkness >= MAX_DARKNESS))
1058 return 0;
1059
1060 /* inform all players on the map */
1061 if (change > 0)
1062 new_info_map (NDI_BLACK | NDI_UNIQUE, this, "It becomes darker.");
1063 else
1064 new_info_map (NDI_BLACK | NDI_UNIQUE, this, "It becomes brighter.");
1065
1066 /* Do extra checking. since darkness is a unsigned value,
1067 * we need to be extra careful about negative values.
1068 * In general, the checks below are only needed if change
1069 * is not +/-1
1070 */
1071 if (new_level < 0)
1072 darkness = 0;
1073 else if (new_level >= MAX_DARKNESS)
1074 darkness = MAX_DARKNESS;
1075 else
1076 darkness = new_level;
1077
1078 /* All clients need to get re-updated for the change */
1079 update_all_map_los (this);
1080 return 1;
1081 }
1082
1083 /*
1084 * This function updates various attributes about a specific space
1085 * on the map (what it looks like, whether it blocks magic,
1086 * has a living creatures, prevents people from passing
1087 * through, etc)
1088 */
1089 void
1090 mapspace::update_ ()
1091 {
1092 object *tmp, *last = 0;
1093 uint8 flags = 0, light = 0, anywhere = 0;
1094 New_Face *top, *floor, *middle;
1095 object *top_obj, *floor_obj, *middle_obj;
1096 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1097
1098 middle = blank_face;
1099 top = blank_face;
1100 floor = blank_face;
1101
1102 middle_obj = 0;
1103 top_obj = 0;
1104 floor_obj = 0;
1105
1106 for (tmp = bot; tmp; last = tmp, tmp = tmp->above)
1107 {
1108 /* This could be made additive I guess (two lights better than
1109 * one). But if so, it shouldn't be a simple additive - 2
1110 * light bulbs do not illuminate twice as far as once since
1111 * it is a dissapation factor that is cubed.
1112 */
1113 if (tmp->glow_radius > light)
1114 light = tmp->glow_radius;
1115
1116 /* This call is needed in order to update objects the player
1117 * is standing in that have animations (ie, grass, fire, etc).
1118 * However, it also causes the look window to be re-drawn
1119 * 3 times each time the player moves, because many of the
1120 * functions the move_player calls eventualy call this.
1121 *
1122 * Always put the player down for drawing.
1123 */
1124 if (!tmp->invisible)
1125 {
1126 if ((tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
1127 {
1128 top = tmp->face;
1129 top_obj = tmp;
1130 }
1131 else if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1132 {
1133 /* If we got a floor, that means middle and top were below it,
1134 * so should not be visible, so we clear them.
1135 */
1136 middle = blank_face;
1137 top = blank_face;
1138 floor = tmp->face;
1139 floor_obj = tmp;
1140 }
1141 /* Flag anywhere have high priority */
1142 else if (QUERY_FLAG (tmp, FLAG_SEE_ANYWHERE))
1143 {
1144 middle = tmp->face;
1145
1146 middle_obj = tmp;
1147 anywhere = 1;
1148 }
1149 /* Find the highest visible face around. If equal
1150 * visibilities, we still want the one nearer to the
1151 * top
1152 */
1153 else if (middle == blank_face || (tmp->face->visibility > middle->visibility && !anywhere))
1154 {
1155 middle = tmp->face;
1156 middle_obj = tmp;
1157 }
1158 }
1159
1160 if (tmp == tmp->above)
1161 {
1162 LOG (llevError, "Error in structure of map\n");
1163 exit (-1);
1164 }
1165
1166 move_slow |= tmp->move_slow;
1167 move_block |= tmp->move_block;
1168 move_on |= tmp->move_on;
1169 move_off |= tmp->move_off;
1170 move_allow |= tmp->move_allow;
1171
1172 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) flags |= P_BLOCKSVIEW;
1173 if (QUERY_FLAG (tmp, FLAG_NO_MAGIC)) flags |= P_NO_MAGIC;
1174 if (tmp->type == PLAYER) flags |= P_PLAYER;
1175 if (tmp->type == SAFE_GROUND) flags |= P_SAFE;
1176 if (QUERY_FLAG (tmp, FLAG_ALIVE)) flags |= P_IS_ALIVE;
1177 if (QUERY_FLAG (tmp, FLAG_DAMNED)) flags |= P_NO_CLERIC;
1178 }
1179
1180 this->light = light;
1181 this->flags_ = flags;
1182 this->move_block = move_block & ~move_allow;
1183 this->move_on = move_on;
1184 this->move_off = move_off;
1185 this->move_slow = move_slow;
1186
1187 /* At this point, we have a floor face (if there is a floor),
1188 * and the floor is set - we are not going to touch it at
1189 * this point.
1190 * middle contains the highest visibility face.
1191 * top contains a player/monster face, if there is one.
1192 *
1193 * We now need to fill in top.face and/or middle.face.
1194 */
1195
1196 /* If the top face also happens to be high visibility, re-do our
1197 * middle face. This should not happen, as we already have the
1198 * else statement above so middle should not get set. OTOH, it
1199 * may be possible for the faces to match but be different objects.
1200 */
1201 if (top == middle)
1202 middle = blank_face;
1203
1204 /* There are three posibilities at this point:
1205 * 1) top face is set, need middle to be set.
1206 * 2) middle is set, need to set top.
1207 * 3) neither middle or top is set - need to set both.
1208 */
1209
1210 for (tmp = last; tmp; tmp = tmp->below)
1211 {
1212 /* Once we get to a floor, stop, since we already have a floor object */
1213 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1214 break;
1215
1216 /* If two top faces are already set, quit processing */
1217 if ((top != blank_face) && (middle != blank_face))
1218 break;
1219
1220 /* Only show visible faces, unless its the editor - show all */
1221 if (!tmp->invisible || editor)
1222 {
1223 /* Fill in top if needed */
1224 if (top == blank_face)
1225 {
1226 top = tmp->face;
1227 top_obj = tmp;
1228 if (top == middle)
1229 middle = blank_face;
1230 }
1231 else
1232 {
1233 /* top is already set - we should only get here if
1234 * middle is not set
1235 *
1236 * Set the middle face and break out, since there is nothing
1237 * more to fill in. We don't check visiblity here, since
1238 *
1239 */
1240 if (tmp->face != top)
1241 {
1242 middle = tmp->face;
1243 middle_obj = tmp;
1244 break;
1245 }
1246 }
1247 }
1248 }
1249
1250 if (middle == floor)
1251 middle = blank_face;
1252
1253 if (top == middle)
1254 middle = blank_face;
1255
1256 faces [0] = top; faces_obj [0] = top != blank_face ? top_obj : 0;
1257 faces [1] = middle; faces_obj [1] = middle != blank_face ? middle_obj : 0;
1258 faces [2] = floor; faces_obj [2] = floor != blank_face ? floor_obj : 0;
1259 }
1260
1261 /* this updates the orig_map->tile_map[tile_num] value after loading
1262 * the map. It also takes care of linking back the freshly loaded
1263 * maps tile_map values if it tiles back to this one. It returns
1264 * the value of orig_map->tile_map[tile_num]. It really only does this
1265 * so that it is easier for calling functions to verify success.
1266 */
1267 static maptile *
1268 load_and_link_tiled_map (maptile *orig_map, int tile_num)
1269 {
1270 maptile *mp = orig_map->load_map_sync (orig_map->tile_path [tile_num], orig_map);
1271
1272 if (!mp || mp->in_memory != MAP_IN_MEMORY)
1273 {
1274 // emergency mode, manufacture a dummy map, this creates a memleak, but thats fine
1275 LOG (llevError, "FATAL: cannot load tiled map %s from %s, leaking memory and worse!\n",
1276 &orig_map->tile_path[tile_num], &orig_map->path);
1277 mp = new maptile (1, 1);
1278 mp->alloc ();
1279 mp->in_memory = MAP_IN_MEMORY;
1280 }
1281
1282 int dest_tile = (tile_num + 2) % 4;
1283
1284 orig_map->tile_map[tile_num] = mp;
1285
1286 // optimisation: back-link map to origin map if euclidean
1287 //TODO: non-euclidean maps MUST GO
1288 if (orig_map->tile_map[tile_num]->tile_path[dest_tile] == orig_map->path)
1289 orig_map->tile_map[tile_num]->tile_map[dest_tile] = orig_map;
1290
1291 return mp;
1292 }
1293
1294 /* this returns TRUE if the coordinates (x,y) are out of
1295 * map m. This function also takes into account any
1296 * tiling considerations, loading adjacant maps as needed.
1297 * This is the function should always be used when it
1298 * necessary to check for valid coordinates.
1299 * This function will recursively call itself for the
1300 * tiled maps.
1301 */
1302 int
1303 out_of_map (maptile *m, int x, int y)
1304 {
1305 /* If we get passed a null map, this is obviously the
1306 * case. This generally shouldn't happen, but if the
1307 * map loads fail below, it could happen.
1308 */
1309 if (!m)
1310 return 0;
1311
1312 if (x < 0)
1313 {
1314 if (!m->tile_path[3])
1315 return 1;
1316
1317 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
1318 load_and_link_tiled_map (m, 3);
1319
1320 return out_of_map (m->tile_map[3], x + m->tile_map[3]->width, y);
1321 }
1322
1323 if (x >= m->width)
1324 {
1325 if (!m->tile_path[1])
1326 return 1;
1327
1328 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
1329 load_and_link_tiled_map (m, 1);
1330
1331 return out_of_map (m->tile_map[1], x - m->width, y);
1332 }
1333
1334 if (y < 0)
1335 {
1336 if (!m->tile_path[0])
1337 return 1;
1338
1339 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
1340 load_and_link_tiled_map (m, 0);
1341
1342 return out_of_map (m->tile_map[0], x, y + m->tile_map[0]->height);
1343 }
1344
1345 if (y >= m->height)
1346 {
1347 if (!m->tile_path[2])
1348 return 1;
1349
1350 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
1351 load_and_link_tiled_map (m, 2);
1352
1353 return out_of_map (m->tile_map[2], x, y - m->height);
1354 }
1355
1356 /* Simple case - coordinates are within this local
1357 * map.
1358 */
1359 return 0;
1360 }
1361
1362 /* This is basically the same as out_of_map above, but
1363 * instead we return NULL if no map is valid (coordinates
1364 * out of bounds and no tiled map), otherwise it returns
1365 * the map as that the coordinates are really on, and
1366 * updates x and y to be the localized coordinates.
1367 * Using this is more efficient of calling out_of_map
1368 * and then figuring out what the real map is
1369 */
1370 maptile *
1371 get_map_from_coord (maptile *m, sint16 *x, sint16 *y)
1372 {
1373 if (*x < 0)
1374 {
1375 if (!m->tile_path[3])
1376 return 0;
1377
1378 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
1379 load_and_link_tiled_map (m, 3);
1380
1381 *x += m->tile_map[3]->width;
1382 return (get_map_from_coord (m->tile_map[3], x, y));
1383 }
1384
1385 if (*x >= m->width)
1386 {
1387 if (!m->tile_path[1])
1388 return 0;
1389
1390 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
1391 load_and_link_tiled_map (m, 1);
1392
1393 *x -= m->width;
1394 return (get_map_from_coord (m->tile_map[1], x, y));
1395 }
1396
1397 if (*y < 0)
1398 {
1399 if (!m->tile_path[0])
1400 return 0;
1401
1402 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
1403 load_and_link_tiled_map (m, 0);
1404
1405 *y += m->tile_map[0]->height;
1406 return (get_map_from_coord (m->tile_map[0], x, y));
1407 }
1408
1409 if (*y >= m->height)
1410 {
1411 if (!m->tile_path[2])
1412 return 0;
1413
1414 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
1415 load_and_link_tiled_map (m, 2);
1416
1417 *y -= m->height;
1418 return (get_map_from_coord (m->tile_map[2], x, y));
1419 }
1420
1421 /* Simple case - coordinates are within this local
1422 * map.
1423 */
1424 return m;
1425 }
1426
1427 /**
1428 * Return whether map2 is adjacent to map1. If so, store the distance from
1429 * map1 to map2 in dx/dy.
1430 */
1431 static int
1432 adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
1433 {
1434 if (!map1 || !map2)
1435 return 0;
1436
1437 if (map1 == map2)
1438 {
1439 *dx = 0;
1440 *dy = 0;
1441 }
1442 else if (map1->tile_map[0] == map2)
1443 { /* up */
1444 *dx = 0;
1445 *dy = -map2->height;
1446 }
1447 else if (map1->tile_map[1] == map2)
1448 { /* right */
1449 *dx = map1->width;
1450 *dy = 0;
1451 }
1452 else if (map1->tile_map[2] == map2)
1453 { /* down */
1454 *dx = 0;
1455 *dy = map1->height;
1456 }
1457 else if (map1->tile_map[3] == map2)
1458 { /* left */
1459 *dx = -map2->width;
1460 *dy = 0;
1461 }
1462 else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2)
1463 { /* up right */
1464 *dx = map1->tile_map[0]->width;
1465 *dy = -map1->tile_map[0]->height;
1466 }
1467 else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2)
1468 { /* up left */
1469 *dx = -map2->width;
1470 *dy = -map1->tile_map[0]->height;
1471 }
1472 else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2)
1473 { /* right up */
1474 *dx = map1->width;
1475 *dy = -map2->height;
1476 }
1477 else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2)
1478 { /* right down */
1479 *dx = map1->width;
1480 *dy = map1->tile_map[1]->height;
1481 }
1482 else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2)
1483 { /* down right */
1484 *dx = map1->tile_map[2]->width;
1485 *dy = map1->height;
1486 }
1487 else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2)
1488 { /* down left */
1489 *dx = -map2->width;
1490 *dy = map1->height;
1491 }
1492 else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2)
1493 { /* left up */
1494 *dx = -map1->tile_map[3]->width;
1495 *dy = -map2->height;
1496 }
1497 else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2)
1498 { /* left down */
1499 *dx = -map1->tile_map[3]->width;
1500 *dy = map1->tile_map[3]->height;
1501 }
1502 else
1503 return 0;
1504
1505 return 1;
1506 }
1507
1508 /* From map.c
1509 * This is used by get_player to determine where the other
1510 * creature is. get_rangevector takes into account map tiling,
1511 * so you just can not look the the map coordinates and get the
1512 * righte value. distance_x/y are distance away, which
1513 * can be negativbe. direction is the crossfire direction scheme
1514 * that the creature should head. part is the part of the
1515 * monster that is closest.
1516 *
1517 * get_rangevector looks at op1 and op2, and fills in the
1518 * structure for op1 to get to op2.
1519 * We already trust that the caller has verified that the
1520 * two objects are at least on adjacent maps. If not,
1521 * results are not likely to be what is desired.
1522 * if the objects are not on maps, results are also likely to
1523 * be unexpected
1524 *
1525 * currently, the only flag supported (0x1) is don't translate for
1526 * closest body part of 'op1'
1527 */
1528 void
1529 get_rangevector (object *op1, object *op2, rv_vector * retval, int flags)
1530 {
1531 if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))
1532 {
1533 /* be conservative and fill in _some_ data */
1534 retval->distance = 100000;
1535 retval->distance_x = 32767;
1536 retval->distance_y = 32767;
1537 retval->direction = 0;
1538 retval->part = 0;
1539 }
1540 else
1541 {
1542 object *best;
1543
1544 retval->distance_x += op2->x - op1->x;
1545 retval->distance_y += op2->y - op1->y;
1546
1547 best = op1;
1548 /* If this is multipart, find the closest part now */
1549 if (!(flags & 0x1) && op1->more)
1550 {
1551 object *tmp;
1552 int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi;
1553
1554 /* we just take the offset of the piece to head to figure
1555 * distance instead of doing all that work above again
1556 * since the distance fields we set above are positive in the
1557 * same axis as is used for multipart objects, the simply arithmetic
1558 * below works.
1559 */
1560 for (tmp = op1->more; tmp != NULL; tmp = tmp->more)
1561 {
1562 tmpi = (op1->x - tmp->x + retval->distance_x) * (op1->x - tmp->x + retval->distance_x) +
1563 (op1->y - tmp->y + retval->distance_y) * (op1->y - tmp->y + retval->distance_y);
1564 if (tmpi < best_distance)
1565 {
1566 best_distance = tmpi;
1567 best = tmp;
1568 }
1569 }
1570 if (best != op1)
1571 {
1572 retval->distance_x += op1->x - best->x;
1573 retval->distance_y += op1->y - best->y;
1574 }
1575 }
1576 retval->part = best;
1577 retval->distance = isqrt (retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y);
1578 retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y);
1579 }
1580 }
1581
1582 /* this is basically the same as get_rangevector above, but instead of
1583 * the first parameter being an object, it instead is the map
1584 * and x,y coordinates - this is used for path to player -
1585 * since the object is not infact moving but we are trying to traverse
1586 * the path, we need this.
1587 * flags has no meaning for this function at this time - I kept it in to
1588 * be more consistant with the above function and also in case they are needed
1589 * for something in the future. Also, since no object is pasted, the best
1590 * field of the rv_vector is set to NULL.
1591 */
1592
1593 void
1594 get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
1595 {
1596 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
1597 {
1598 /* be conservative and fill in _some_ data */
1599 retval->distance = 100000;
1600 retval->distance_x = 32767;
1601 retval->distance_y = 32767;
1602 retval->direction = 0;
1603 retval->part = 0;
1604 }
1605 else
1606 {
1607 retval->distance_x += op2->x - x;
1608 retval->distance_y += op2->y - y;
1609
1610 retval->part = NULL;
1611 retval->distance = isqrt (retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y);
1612 retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y);
1613 }
1614 }
1615
1616 /* Returns true of op1 and op2 are effectively on the same map
1617 * (as related to map tiling). Note that this looks for a path from
1618 * op1 to op2, so if the tiled maps are asymetric and op2 has a path
1619 * to op1, this will still return false.
1620 * Note we only look one map out to keep the processing simple
1621 * and efficient. This could probably be a macro.
1622 * MSW 2001-08-05
1623 */
1624 int
1625 on_same_map (const object *op1, const object *op2)
1626 {
1627 int dx, dy;
1628
1629 return adjacent_map (op1->map, op2->map, &dx, &dy);
1630 }
1631
1632 object *
1633 maptile::insert (object *op, int x, int y, object *originator, int flags)
1634 {
1635 if (!op->flag [FLAG_REMOVED])
1636 op->remove ();
1637
1638 return insert_ob_in_map_at (op, this, originator, flags, x, y);
1639 }
1640