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

Comparing deliantra/server/server/time.C (file contents):
Revision 1.100 by root, Sun Nov 29 09:41:28 2009 UTC vs.
Revision 1.118 by root, Fri Jan 27 22:00:40 2012 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 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002 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.
… …
50 } 50 }
51 } 51 }
52 52
53 if (op->other_arch) 53 if (op->other_arch)
54 { 54 {
55 object *tmp = arch_to_object (op->other_arch); 55 object *tmp = op->other_arch->instance ();
56 tmp->x = op->x; 56 tmp->x = op->x;
57 tmp->y = op->y; 57 tmp->y = op->y;
58 tmp->map = op->map; 58 tmp->map = op->map;
59 tmp->level = op->level; 59 tmp->level = op->level;
60 insert_ob_in_map (tmp, op->map, op, 0); 60 insert_ob_in_map (tmp, op->map, op, 0);
… …
79 } 79 }
80 } 80 }
81 81
82 if (op->other_arch) 82 if (op->other_arch)
83 { 83 {
84 tmp = arch_to_object (op->other_arch); 84 tmp = op->other_arch->instance ();
85 tmp->x = op->x; 85 tmp->x = op->x;
86 tmp->y = op->y; 86 tmp->y = op->y;
87 tmp->map = op->map; 87 tmp->map = op->map;
88 tmp->level = op->level; 88 tmp->level = op->level;
89 insert_ob_in_map (tmp, op->map, op, 0); 89 insert_ob_in_map (tmp, op->map, op, 0);
… …
107 return; 107 return;
108 108
109 object *op; 109 object *op;
110 int dir; 110 int dir;
111 111
112 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN)) 112 if (gen->flag [FLAG_CONTENT_ON_GEN])
113 { 113 {
114 // either copy one item from the inventory... 114 // either copy one item from the inventory...
115 if (!gen->inv) 115 if (!gen->inv)
116 return; 116 return;
117 117
… …
125 if (dir < 0) 125 if (dir < 0)
126 return; 126 return;
127 127
128 op = op->deep_clone (); 128 op = op->deep_clone ();
129 129
130 CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE); 130 op->clr_flag (FLAG_IS_A_TEMPLATE);
131 unflag_inv (op, FLAG_IS_A_TEMPLATE); 131 unflag_inv (op, FLAG_IS_A_TEMPLATE);
132 } 132 }
133 else if (gen->other_arch) 133 else if (gen->other_arch)
134 { 134 {
135 // ...or use other_arch 135 // ...or use other_arch
136 dir = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1); 136 dir = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
137 if (dir < 0) 137 if (dir < 0)
138 return; 138 return;
139 139
140 op = arch_to_object (gen->other_arch); 140 op = gen->other_arch->instance ();
141 } 141 }
142 else 142 else
143 return; 143 return;
144 144
145 op->expand_tail (); 145 op->expand_tail ();
… …
168 168
169 if (op->env) 169 if (op->env)
170 switch (op->subtype) 170 switch (op->subtype)
171 { 171 {
172 case FORCE_CONFUSION: 172 case FORCE_CONFUSION:
173 CLEAR_FLAG (op->env, FLAG_CONFUSED); 173 op->env->clr_flag (FLAG_CONFUSED);
174 new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n"); 174 new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n");
175 175
176 default: 176 default:
177 CLEAR_FLAG (op, FLAG_APPLIED); 177 op->clr_flag (FLAG_APPLIED);
178 change_abil (op->env, op); 178 change_abil (op->env, op);
179 op->env->update_stats (); 179 op->env->update_stats ();
180 } 180 }
181 181
182 op->destroy (); 182 op->destroy ();
… …
186remove_blindness (object *op) 186remove_blindness (object *op)
187{ 187{
188 if (--op->stats.food > 0) 188 if (--op->stats.food > 0)
189 return; 189 return;
190 190
191 CLEAR_FLAG (op, FLAG_APPLIED); 191 op->clr_flag (FLAG_APPLIED);
192 192
193 if (op->env) 193 if (op->env)
194 { 194 {
195 change_abil (op->env, op); 195 change_abil (op->env, op);
196 op->env->update_stats (); 196 op->env->update_stats ();
… …
200} 200}
201 201
202static void 202static void
203poison_more (object *op) 203poison_more (object *op)
204{ 204{
205 if (op->env == NULL || !QUERY_FLAG (op->env, FLAG_ALIVE) || op->env->stats.hp < 0) 205 if (op->env == NULL || !op->env->flag [FLAG_ALIVE] || op->env->stats.hp < 0)
206 { 206 {
207 op->destroy (); 207 op->destroy ();
208 return; 208 return;
209 } 209 }
210 210
… …
213 /* need to unapply the object before update_stats is called, else fix_player 213 /* need to unapply the object before update_stats is called, else fix_player
214 * will not do anything. 214 * will not do anything.
215 */ 215 */
216 if (op->env->type == PLAYER) 216 if (op->env->type == PLAYER)
217 { 217 {
218 CLEAR_FLAG (op, FLAG_APPLIED); 218 op->clr_flag (FLAG_APPLIED);
219 op->env->update_stats (); 219 op->env->update_stats ();
220 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now."); 220 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now.");
221 } 221 }
222 222
223 op->destroy (); 223 op->destroy ();
… …
239{ /* 1 = going down, 0 = going up */ 239{ /* 1 = going down, 0 = going up */
240 object *tmp; 240 object *tmp;
241 241
242 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op)) 242 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op))
243 { 243 {
244 LOG (llevError, "Gate error: animation was %d, max=%d\n", op->stats.wc, NUM_ANIMATIONS (op)); 244 LOG (llevError, "%s: gate error: animation was %d, max=%d\n", op->debug_desc (), op->stats.wc, NUM_ANIMATIONS (op));
245 op->stats.wc = 0; 245 op->stats.wc = 0;
246 } 246 }
247 247
248 /* We're going down */ 248 /* We're going down */
249 if (op->value) 249 if (op->value)
… …
258 } 258 }
259 259
260 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1)) 260 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1))
261 { 261 {
262 op->move_block = 0; 262 op->move_block = 0;
263 CLEAR_FLAG (op, FLAG_BLOCKSVIEW); 263 op->clr_flag (FLAG_BLOCKSVIEW);
264 update_all_los (op->map, op->x, op->y); 264 update_all_los (op->map, op->x, op->y);
265 } 265 }
266 266
267 SET_ANIMATION (op, op->stats.wc); 267 SET_ANIMATION (op, op->stats.wc);
268 update_object (op, UP_OBJ_CHANGE); 268 update_object (op, UP_OBJ_CHANGE);
… …
272 /* We're going up */ 272 /* We're going up */
273 273
274 /* First, lets see if we are already at the top */ 274 /* First, lets see if we are already at the top */
275 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1)) 275 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
276 { 276 {
277
278 /* Check to make sure that only non pickable and non rollable 277 /* Check to make sure that only non pickable and non rollable
279 * objects are above the gate. If so, we finish closing the gate, 278 * objects are above the gate. If so, we finish closing the gate,
280 * otherwise, we fall through to the code below which should lower 279 * otherwise, we fall through to the code below which should lower
281 * the gate slightly. 280 * the gate slightly.
282 */ 281 */
283 282
284 for (tmp = op->above; tmp; tmp = tmp->above) 283 for (tmp = op->above; tmp; tmp = tmp->above)
285 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE)) 284 if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
286 break; 285 break;
287 286
288 if (!tmp) 287 if (!tmp)
289 { 288 {
290 if (op->arch->has_active_speed ()) 289 if (op->arch->has_active_speed ())
… …
321 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above) 320 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
322 ; 321 ;
323 322
324 if (tmp) 323 if (tmp)
325 { 324 {
326 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 325 if (tmp->flag [FLAG_ALIVE])
327 { 326 {
328 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1); 327 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1);
329 op->play_sound (sound_find ("blocked_gate")); 328 op->play_sound (sound_find ("blocked_gate"));
330 329
331 if (tmp->type == PLAYER) 330 if (tmp->type == PLAYER)
… …
333 } 332 }
334 /* If the object is not alive, and the object either can 333 /* If the object is not alive, and the object either can
335 * be picked up or the object rolls, move the object 334 * be picked up or the object rolls, move the object
336 * off the gate. 335 * off the gate.
337 */ 336 */
338 else if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL))) 337 else if (!tmp->flag [FLAG_ALIVE] && (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL]))
339 { 338 {
340 /* If it has speed, it should move itself, otherwise: */ 339 /* If it has speed, it should move itself, otherwise: */
341 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1); 340 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1);
342 341
343 /* If there is a free spot, move the object someplace */ 342 /* If there is a free spot, move the object someplace */
… …
351 } 350 }
352 } 351 }
353 352
354 /* See if there is still anything blocking the gate */ 353 /* See if there is still anything blocking the gate */
355 for (tmp = op->above; tmp; tmp = tmp->above) 354 for (tmp = op->above; tmp; tmp = tmp->above)
356 if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE)) 355 if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
357 break; 356 break;
358 357
359 /* IF there is, start putting the gate down */ 358 /* IF there is, start putting the gate down */
360 if (tmp) 359 if (tmp)
361 op->stats.food = 1; 360 op->stats.food = 1;
362 else 361 else
363 { 362 {
364 op->move_block = MOVE_ALL; 363 op->move_block = MOVE_ALL;
365 364
366 if (!op->arch->stats.ac) 365 if (!op->arch->stats.ac)
367 SET_FLAG (op, FLAG_BLOCKSVIEW); 366 op->set_flag (FLAG_BLOCKSVIEW);
368 update_all_los (op->map, op->x, op->y); 367 update_all_los (op->map, op->x, op->y);
369 } 368 }
370 } /* gate is halfway up */ 369 } /* gate is halfway up */
371 370
372 SET_ANIMATION (op, op->stats.wc); 371 SET_ANIMATION (op, op->stats.wc);
… …
502 move_apply (op, tmp, tmp); 501 move_apply (op, tmp, tmp);
503 } 502 }
504 } 503 }
505 504
506 SET_ANIMATION (op, op->stats.wc); 505 SET_ANIMATION (op, op->stats.wc);
507 update_object (op, UP_OBJ_FACE); 506 update_object (op, UP_OBJ_CHANGE);
508 return; 507 return;
509 } 508 }
510 509
511 /* We're closing */ 510 /* We're closing */
512 op->move_on = 0; 511 op->move_on = 0;
513 512
514 op->stats.wc++; 513 op->stats.wc++;
515 if ((int) op->stats.wc >= NUM_ANIMATIONS (op)) 514 if (op->stats.wc >= NUM_ANIMATIONS (op))
516 op->stats.wc = NUM_ANIMATIONS (op) - 1; 515 op->stats.wc = NUM_ANIMATIONS (op) - 1;
517 516
518 SET_ANIMATION (op, op->stats.wc); 517 SET_ANIMATION (op, op->stats.wc);
519 update_object (op, UP_OBJ_FACE); 518 update_object (op, UP_OBJ_CHANGE);
520 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1)) 519 if (op->stats.wc == (NUM_ANIMATIONS (op) - 1))
521 op->set_speed (0); /* closed, let's stop */ 520 op->set_speed (0); /* closed, let's stop */
522} 521}
523 522
524 523
525/* stop_item() returns a pointer to the stopped object. The stopped object 524/* stop_item() returns a pointer to the stopped object. The stopped object
… …
573fix_stopped_item (object *op, maptile *map, object *originator) 572fix_stopped_item (object *op, maptile *map, object *originator)
574{ 573{
575 if (map == NULL) 574 if (map == NULL)
576 return; 575 return;
577 576
578 if (QUERY_FLAG (op, FLAG_REMOVED)) 577 if (op->flag [FLAG_REMOVED])
579 insert_ob_in_map (op, map, originator, 0); 578 insert_ob_in_map (op, map, originator, 0);
580 else if (op->type == ARROW) 579 else if (op->type == ARROW)
581 merge_ob (op, NULL); /* only some arrows actually need this */ 580 merge_ob (op, NULL); /* only some arrows actually need this */
582} 581}
583 582
… …
646 if (op) 645 if (op)
647 merge_ob (op, 0); 646 merge_ob (op, 0);
648 } 647 }
649} 648}
650 649
651/* Move an arrow along its course. op is the arrow or thrown object. 650/* Move an arrow or throwen_obj along its course. op is the arrow or thrown object.
652 */ 651 */
653void 652void
654move_arrow (object *op) 653move_arrow (object *op)
655{ 654{
656 int was_reflected; 655 int was_reflected;
657 656
658 if (!op->map) 657 if (!op->map)
659 { 658 {
660 LOG (llevError, "BUG: Arrow had no map.\n"); 659 LOG (llevError | logBacktrace, "BUG: Arrow %s had no map.\n", op->debug_desc ());
661 op->destroy (); 660 op->destroy ();
662 return; 661 return;
663 } 662 }
664 663
665 /* we need to stop thrown objects at some point. Like here. */ 664 /* we need to stop thrown objects at some point. Like here. */
… …
684 stop_arrow (op); 683 stop_arrow (op);
685 return; 684 return;
686 } 685 }
687 } 686 }
688 687
688 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
689 * about 17 squares. Tune as needed.
690 */
691 op->set_speed (op->speed - 0.05);
692
689 /* if the arrow is moving too slow.. stop it. 0.5 was chosen as lower 693 /* if the arrow is moving too slow.. stop it. 0.5 was chosen as lower
690 values look rediculous. */ 694 values look rediculous. */
691 if (op->speed < 0.5 && op->type == ARROW) 695 if (op->speed < (op->type == ARROW ? 0.5 : MIN_ACTIVE_SPEED))
692 { 696 {
693 stop_arrow (op); 697 stop_arrow (op);
694 return; 698 return;
695 } 699 }
696 700
… …
709 if (pos->flags () & P_IS_ALIVE) 713 if (pos->flags () & P_IS_ALIVE)
710 { 714 {
711 object *tmp; 715 object *tmp;
712 716
713 for (tmp = pos->bot; tmp; tmp = tmp->above) 717 for (tmp = pos->bot; tmp; tmp = tmp->above)
714 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 718 if (tmp->flag [FLAG_ALIVE])
715 break; 719 break;
716 720
717 /* Not really fair, but don't let monsters hit themselves with 721 /* Not really fair, but don't let monsters hit themselves with
718 * their own arrow - this can be because they fire it then 722 * their own arrow - this can be because they fire it then
719 * move into it. 723 * move into it.
… …
722 { 726 {
723 /* Found living object, but it is reflecting the missile. Update 727 /* Found living object, but it is reflecting the missile. Update
724 * as below. (Note that for living creatures there is a small 728 * as below. (Note that for living creatures there is a small
725 * chance that reflect_missile fails.) 729 * chance that reflect_missile fails.)
726 */ 730 */
727 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE) && (rndm (0, 99)) < (90 - op->level / 10)) 731 if (tmp->flag [FLAG_REFL_MISSILE] && (rndm (0, 99)) < (90 - op->level / 10))
728 { 732 {
729 int number = op->face;
730
731 op->direction = absdir (op->direction + 4); 733 op->direction = absdir (op->direction + 4);
732 update_turn_face (op); 734 update_turn_face (op);
733 was_reflected = 1; /* skip normal movement calculations */ 735 was_reflected = 1; /* skip normal movement calculations */
734 } 736 }
735 else 737 else
… …
751 * note that this code will now catch cases where a monster is 753 * note that this code will now catch cases where a monster is
752 * on a wall but has reflecting - the arrow won't reflect. 754 * on a wall but has reflecting - the arrow won't reflect.
753 * Mapmakers shouldn't put monsters on top of wall in the first 755 * Mapmakers shouldn't put monsters on top of wall in the first
754 * place, so I don't consider that a problem. 756 * place, so I don't consider that a problem.
755 */ 757 */
756 if (!QUERY_FLAG (op, FLAG_REFLECTING) || !(rndm (0, 19))) 758 if (!op->flag [FLAG_REFLECTING] || !rndm (0, 19))
757 { 759 {
758 stop_arrow (op); 760 stop_arrow (op);
759 return; 761 return;
760 } 762 }
761 else 763 else
… …
815 if (op->has_anim ()) 817 if (op->has_anim ())
816 op->set_anim_frame (op->direction); 818 op->set_anim_frame (op->direction);
817 } /* object is reflected */ 819 } /* object is reflected */
818 } /* object ran into a wall */ 820 } /* object ran into a wall */
819 821
820 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
821 * about 17 squares. Tune as needed.
822 */
823 op->speed -= 0.05;
824
825 /* Move the arrow. */ 822 /* Move the arrow. */
826 op->move_to (pos); 823 op->move_to (pos);
827} 824}
828 825
829static void 826static void
830change_object (object *op) 827change_object (object *op)
831{ /* Doesn`t handle linked objs yet */ 828{ /* Doesn`t handle linked objs yet */
832 int i, j;
833
834 if (!op->other_arch) 829 if (!op->other_arch)
835 { 830 {
836 LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ()); 831 LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ());
837 return; 832 return;
838 } 833 }
839 834
840 /* In non-living items only change when food value is 0 */ 835 /* In non-living items only change when food value is 0 */
841 if (!QUERY_FLAG (op, FLAG_ALIVE)) 836 if (!op->flag [FLAG_ALIVE])
842 { 837 {
843 if (op->stats.food-- > 0) 838 if (op->stats.food-- > 0)
844 return; 839 return;
845 840
846 op->stats.food = 1; /* so 1 other_arch is made */ 841 op->stats.food = 1; /* so 1 other_arch is made */
847 } 842 }
848 843
849 object *env = op->env; 844 object *env = op->env;
850 845
851 op->remove (); 846 op->remove ();
852 for (i = 0; i < op->stats.food; i++) 847 for (int i = 0; i < op->stats.food; i++)
853 { 848 {
854 object *tmp = arch_to_object (op->other_arch); 849 object *tmp = op->other_arch->instance ();
855 850
856 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */ 851 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
857 852
858 if (env) 853 if (env)
859 env->insert (tmp); 854 env->insert (tmp);
860 else 855 else
861 { 856 {
862 j = find_first_free_spot (tmp, op->map, op->x, op->y); 857 int j = find_first_free_spot (tmp, op->map, op->x, op->y);
858
863 if (j < 0) /* No free spot */ 859 if (j < 0) /* No free spot */
864 tmp->destroy (); 860 tmp->destroy ();
865 else 861 else
866 { 862 {
867 mapxy pos (op); pos.move (j); 863 mapxy pos (op); pos.move (j);
… …
892 888
893 if (op->head) 889 if (op->head)
894 head = op->head; 890 head = op->head;
895 891
896 for (tmp = op->above; tmp; tmp = tmp->above) 892 for (tmp = op->above; tmp; tmp = tmp->above)
897 if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 893 if (!tmp->flag [FLAG_IS_FLOOR])
898 break; 894 break;
899 895
900 /* If nothing above us to move, nothing to do */ 896 /* If nothing above us to move, nothing to do */
901 if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS)) 897 if (!tmp || tmp->flag [FLAG_WIZPASS])
902 return; 898 return;
903 899
904 if (EXIT_PATH (head)) 900 if (EXIT_PATH (head))
905 { 901 {
906 if (tmp->type == PLAYER) 902 if (tmp->type == PLAYER)
… …
1005 } 1001 }
1006 1002
1007 cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL); 1003 cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL);
1008} 1004}
1009 1005
1010/* move_player_mover: this function takes a "player mover" as an 1006/* move_player_mover: this function takes a "player mover" as an
1011 * argument, and performs the function of a player mover, which is: 1007 * argument, and performs the function of a player mover, which is:
1012 * 1008 *
1013 * a player mover finds any players that are sitting on it. It 1009 * a player mover finds any players that are sitting on it. It
1014 * moves them in the op->stats.sp direction. speed is how often it'll move. 1010 * moves them in the op->stats.sp direction. speed is how often it'll move.
1015 * If attacktype is nonzero it will paralyze the player. If lifesave is set, 1011 * If attacktype is nonzero it will paralyze the player. If lifesave is set,
… …
1017 * it'll paralyze the victim for hp*his speed/op->speed 1013 * it'll paralyze the victim for hp*his speed/op->speed
1018 */ 1014 */
1019static void 1015static void
1020move_player_mover (object *op) 1016move_player_mover (object *op)
1021{ 1017{
1022 int dir = op->stats.sp; 1018 int dir = 0;
1023 sint16 nx, ny;
1024 maptile *m;
1025
1026 /* Determine direction now for random movers so we do the right thing */
1027 if (!dir)
1028 dir = rndm (1, 8);
1029 1019
1030 for (object *victim = op->ms ().bot; victim; victim = victim->above) 1020 for (object *victim = op->ms ().bot; victim; victim = victim->above)
1031 { 1021 {
1032 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1022 if (victim->flag [FLAG_ALIVE]
1023 && !victim->flag [FLAG_WIZPASS]
1033 (victim->move_type & op->move_type || !victim->move_type)) 1024 && (victim->move_type & op->move_type || !victim->move_type))
1025 {
1026 if (op->flag [FLAG_LIFESAVE] && op->stats.hp-- < 0)
1034 { 1027 {
1028 op->destroy ();
1029 return;
1030 }
1031
1032 /* Determine direction only once so we do the right thing */
1033 // why is it the right thing, though?
1034 if (!dir)
1035 dir = op->stats.sp ? op->stats.sp : rndm (1, 8);
1036
1037 sint16 nx = op->x + freearr_x[dir];
1038 sint16 ny = op->y + freearr_y[dir];
1039 maptile *m = op->map;
1040 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1041 {
1042 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
1043 return;
1044 }
1035 1045
1036 if (victim->head) 1046 if (victim->head)
1037 victim = victim->head; 1047 victim = victim->head;
1038 1048
1039 if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0)
1040 {
1041 op->remove ();
1042 return;
1043 }
1044
1045 nx = op->x + freearr_x[dir];
1046 ny = op->y + freearr_y[dir];
1047 m = op->map;
1048 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1049 {
1050 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
1051 return;
1052 }
1053
1054 if (should_director_abort (op, victim)) 1049 if (should_director_abort (op, victim))
1055 return; 1050 return;
1056 1051
1057 for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above) 1052 for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above)
1058 { 1053 {
1059 if (nextmover->type == PLAYERMOVER) 1054 if (nextmover->type == PLAYERMOVER)
1060 nextmover->speed_left = -.99f; 1055 nextmover->speed_left = -.99f;
1061 1056
1062 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1057 if (nextmover->flag [FLAG_ALIVE])
1063 op->speed_left = -1.1f; /* wait until the next thing gets out of the way */ 1058 op->speed_left = -1.1f; /* wait until the next thing gets out of the way */
1064 } 1059 }
1065 1060
1066 if (victim->type == PLAYER) 1061 if (victim->type == PLAYER)
1067 { 1062 {
… …
1079 } 1074 }
1080 else 1075 else
1081 return; 1076 return;
1082 } 1077 }
1083 else 1078 else
1084 move_object (victim, dir); 1079 victim->move (dir);
1085 1080
1086 if (!op->stats.maxsp && op->attacktype) 1081 if (!op->stats.maxsp && op->attacktype)
1087 op->stats.maxsp = 2; 1082 op->stats.maxsp = 2;
1088 1083
1089 if (op->attacktype) 1084 if (op->attacktype)
… …
1152void 1147void
1153move_creator (object *creator) 1148move_creator (object *creator)
1154{ 1149{
1155 object *new_ob; 1150 object *new_ob;
1156 1151
1157 if (!QUERY_FLAG (creator, FLAG_LIFESAVE) && --creator->stats.hp < 0) 1152 if (!creator->flag [FLAG_LIFESAVE] && --creator->stats.hp < 0)
1158 { 1153 {
1159 creator->stats.hp = -1; 1154 creator->stats.hp = -1;
1160 return; 1155 return;
1161 } 1156 }
1162 1157
… …
1166 int i; 1161 int i;
1167 object *ob_to_copy; 1162 object *ob_to_copy;
1168 1163
1169 /* select random object from inventory to copy */ 1164 /* select random object from inventory to copy */
1170 ob_to_copy = creator->inv; 1165 ob_to_copy = creator->inv;
1171 for (ob = creator->inv->below, i = 1; ob != NULL; ob = ob->below, i++) 1166 for (ob = creator->inv->below, i = 1; ob; ob = ob->below, i++)
1172 { 1167 {
1173 if (rndm (0, i) == 0) 1168 if (rndm (0, i) == 0)
1174 { 1169 {
1175 ob_to_copy = ob; 1170 ob_to_copy = ob;
1176 } 1171 }
1177 } 1172 }
1173
1178 new_ob = ob_to_copy->deep_clone (); 1174 new_ob = ob_to_copy->deep_clone ();
1179 CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE); 1175 new_ob->clr_flag (FLAG_IS_A_TEMPLATE);
1180 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE); 1176 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1181 } 1177 }
1182 else 1178 else
1183 { 1179 {
1184 if (!creator->other_arch) 1180 if (!creator->other_arch)
… …
1199 return; 1195 return;
1200 } 1196 }
1201 1197
1202 // for now lets try to identify everything generated here, it mostly 1198 // for now lets try to identify everything generated here, it mostly
1203 // happens automated, so this will at least fix many identify-experience holes 1199 // happens automated, so this will at least fix many identify-experience holes
1204 SET_FLAG (new_ob, FLAG_IDENTIFIED); 1200 if (new_ob->need_identify ())
1201 new_ob->set_flag (FLAG_IDENTIFIED);
1205 1202
1206 insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y); 1203 insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);
1207 if (QUERY_FLAG (new_ob, FLAG_FREED)) 1204 if (new_ob->flag [FLAG_FREED])
1208 return; 1205 return;
1209 1206
1210 if (creator->slaying) 1207 if (creator->slaying)
1211 new_ob->name = new_ob->title = creator->slaying; 1208 new_ob->name = new_ob->title = creator->slaying;
1212} 1209}
… …
1297} 1294}
1298 1295
1299void 1296void
1300process_object (object *op) 1297process_object (object *op)
1301{ 1298{
1302 if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))) 1299 if (expect_false (op->flag [FLAG_IS_A_TEMPLATE]))
1303 return; 1300 return;
1304 1301
1305 if (expect_false (INVOKE_OBJECT (TICK, op))) 1302 if (expect_false (INVOKE_OBJECT (TICK, op)))
1306 return; 1303 return;
1307 1304
1308 if (QUERY_FLAG (op, FLAG_MONSTER)) 1305 if (op->flag [FLAG_MONSTER])
1309 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED)) 1306 if (move_monster (op) || op->flag [FLAG_FREED])
1310 return; 1307 return;
1311 1308
1312 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0) 1309 if (op->flag [FLAG_ANIMATE] && op->anim_speed == 0)
1313 { 1310 {
1314 animate_object (op, op->contr ? op->facing : op->direction); 1311 animate_object (op, op->contr ? op->facing : op->direction);
1315 1312
1316 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1313 if (op->flag [FLAG_SEE_ANYWHERE])
1317 make_sure_seen (op); 1314 make_sure_seen (op);
1318 } 1315 }
1319 1316
1320 if (expect_false ( 1317 if (expect_false (
1321 op->flag [FLAG_GENERATOR] 1318 op->flag [FLAG_GENERATOR]
1322 || op->flag [FLAG_CHANGING] 1319 || op->flag [FLAG_CHANGING]
1323 || op->flag [FLAG_IS_USED_UP] 1320 || op->flag [FLAG_IS_USED_UP]
1324 )) 1321 ))
1325 { 1322 {
1326 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state) 1323 if (op->flag [FLAG_CHANGING] && !op->state)
1327 { 1324 {
1328 change_object (op); 1325 change_object (op);
1329 return; 1326 return;
1330 } 1327 }
1331 1328
1332 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY)) 1329 if (op->flag [FLAG_GENERATOR] && !op->flag [FLAG_FRIENDLY])
1333 generate_monster (op); 1330 generate_monster (op);
1334 1331
1335 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0) 1332 if (op->flag [FLAG_IS_USED_UP] && --op->stats.food <= 0)
1336 { 1333 {
1337 if (QUERY_FLAG (op, FLAG_APPLIED)) 1334 if (op->flag [FLAG_APPLIED])
1338 remove_force (op); 1335 remove_force (op);
1339 else 1336 else
1340 { 1337 {
1341 op->remove (); // TODO: really necessary? 1338 op->remove (); // TODO: really necessary?
1342 1339
1343 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1340 if (op->flag [FLAG_SEE_ANYWHERE])
1344 make_sure_not_seen (op); 1341 make_sure_not_seen (op);
1345 1342
1346 op->drop_and_destroy (); 1343 op->drop_and_destroy ();
1347 } 1344 }
1348 1345
… …
1484 1481
1485 case LAMP: 1482 case LAMP:
1486 case TORCH: 1483 case TORCH:
1487 move_lamp (op); 1484 move_lamp (op);
1488 break; 1485 break;
1489 }
1490}
1491 1486
1487 case PHYSICS: // hmm, bad naming
1488 move_physics (op);
1489 break;
1490 }
1491}
1492

Diff Legend

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