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.97 by root, Fri Nov 6 12:49:19 2009 UTC vs.
Revision 1.128 by root, Wed Dec 5 19:03:27 2018 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 (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 5 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 6 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 7 * Copyright (©) 1992 Frank Tore Johansen
7 * 8 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 9 * 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 10 * 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 11 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version. 12 * option) any later version.
12 * 13 *
13 * This program is distributed in the hope that it will be useful, 14 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 17 * GNU General Public License for more details.
17 * 18 *
18 * You should have received a copy of the Affero GNU General Public License 19 * You should have received a copy of the Affero GNU General Public License
19 * and the GNU General Public License along with this program. If not, see 20 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>. 21 * <http://www.gnu.org/licenses/>.
21 * 22 *
22 * The authors can be reached via e-mail to <support@deliantra.net> 23 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 24 */
24 25
25/* 26/*
26 * Routines that is executed from objects based on their speed have been 27 * Routines that is executed from objects based on their speed have been
… …
28 */ 29 */
29#include <global.h> 30#include <global.h>
30#include <spells.h> 31#include <spells.h>
31#include <sproto.h> 32#include <sproto.h>
32 33
33/* The following removes doors. The functions check to see if similar 34/* The following removes doors. The functions check to see if similar
34 * doors are next to the one that is being removed, and if so, set it 35 * doors are next to the one that is being removed, and if so, set it
35 * so those will be removed shortly (in a cascade like fashion.) 36 * so those will be removed shortly (in a cascade like fashion.)
36 */ 37 */
37void 38void
38remove_door (object *op) 39remove_door (object *op)
… …
50 } 51 }
51 } 52 }
52 53
53 if (op->other_arch) 54 if (op->other_arch)
54 { 55 {
55 object *tmp = arch_to_object (op->other_arch); 56 object *tmp = op->other_arch->instance ();
56 tmp->x = op->x; 57 tmp->x = op->x;
57 tmp->y = op->y; 58 tmp->y = op->y;
58 tmp->map = op->map; 59 tmp->map = op->map;
59 tmp->level = op->level; 60 tmp->level = op->level;
60 insert_ob_in_map (tmp, op->map, op, 0); 61 insert_ob_in_map (tmp, op->map, op, 0);
… …
69 int i; 70 int i;
70 object *tmp; 71 object *tmp;
71 72
72 for (i = 1; i < 9; i += 2) 73 for (i = 1; i < 9; i += 2)
73 { 74 {
74 tmp = present (LOCKED_DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i]); 75 tmp = present (LOCKED_DOOR, op->map, op->x + DIRX (i), op->y + DIRY (i));
75 if (tmp && tmp->slaying == op->slaying) 76 if (tmp && tmp->slaying == op->slaying)
76 { /* same key both doors */ 77 { /* same key both doors */
77 tmp->set_speed (0.1f); 78 tmp->set_speed (0.1f);
78 tmp->speed_left = -0.2f; 79 tmp->speed_left = -0.2f;
79 } 80 }
80 } 81 }
81 82
82 if (op->other_arch) 83 if (op->other_arch)
83 { 84 {
84 tmp = arch_to_object (op->other_arch); 85 tmp = op->other_arch->instance ();
85 tmp->x = op->x; 86 tmp->x = op->x;
86 tmp->y = op->y; 87 tmp->y = op->y;
87 tmp->map = op->map; 88 tmp->map = op->map;
88 tmp->level = op->level; 89 tmp->level = op->level;
89 insert_ob_in_map (tmp, op->map, op, 0); 90 insert_ob_in_map (tmp, op->map, op, 0);
90 } 91 }
91 92
92 op->drop_and_destroy (); 93 op->drop_and_destroy ();
93} 94}
94 95
95void 96static void
96generate_monster (object *gen) 97generate_monster (object *gen)
97{ 98{
98 if (!gen->map) 99 if (!gen->map)
99 return; 100 return;
100 101
… …
107 return; 108 return;
108 109
109 object *op; 110 object *op;
110 int dir; 111 int dir;
111 112
112 if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN)) 113 if (gen->flag [FLAG_CONTENT_ON_GEN])
113 { 114 {
114 // either copy one item from the inventory... 115 // either copy one item from the inventory...
115 if (!gen->inv) 116 if (!gen->inv)
116 return; 117 return;
117 118
… …
125 if (dir < 0) 126 if (dir < 0)
126 return; 127 return;
127 128
128 op = op->deep_clone (); 129 op = op->deep_clone ();
129 130
130 CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE); 131 op->clr_flag (FLAG_IS_A_TEMPLATE);
131 unflag_inv (op, FLAG_IS_A_TEMPLATE); 132 unflag_inv (op, FLAG_IS_A_TEMPLATE);
132 } 133 }
133 else if (gen->other_arch) 134 else if (gen->other_arch)
134 { 135 {
135 // ...or use other_arch 136 // ...or use other_arch
136 dir = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1); 137 dir = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
137 if (dir < 0) 138 if (dir < 0)
138 return; 139 return;
139 140
140 op = arch_to_object (gen->other_arch); 141 op = gen->other_arch->instance ();
141 } 142 }
142 else 143 else
143 return; 144 return;
144 145
145 op->expand_tail (); 146 op->expand_tail ();
… …
158 } 159 }
159 160
160 op->destroy (); 161 op->destroy ();
161} 162}
162 163
163void 164static void
164remove_force (object *op) 165remove_force (object *op)
165{ 166{
166 if (--op->duration > 0) 167 if (--op->duration > 0)
167 return; 168 return;
168 169
169 if (op->env) 170 if (op->env)
170 switch (op->subtype) 171 switch (op->subtype)
171 { 172 {
172 case FORCE_CONFUSION: 173 case FORCE_CONFUSION:
173 CLEAR_FLAG (op->env, FLAG_CONFUSED); 174 op->env->clr_flag (FLAG_CONFUSED);
174 new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n"); 175 new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n");
175 176
176 default: 177 default:
177 CLEAR_FLAG (op, FLAG_APPLIED); 178 op->clr_flag (FLAG_APPLIED);
178 change_abil (op->env, op); 179 change_abil (op->env, op);
179 op->env->update_stats (); 180 op->env->update_stats ();
180 } 181 }
181 182
182 op->destroy (); 183 op->destroy ();
183} 184}
184 185
185void 186static void
186remove_blindness (object *op) 187remove_blindness (object *op)
187{ 188{
188 if (--op->stats.food > 0) 189 if (--op->stats.food > 0)
189 return; 190 return;
190 191
191 CLEAR_FLAG (op, FLAG_APPLIED); 192 op->clr_flag (FLAG_APPLIED);
192 193
193 if (op->env) 194 if (op->env)
194 { 195 {
195 change_abil (op->env, op); 196 change_abil (op->env, op);
196 op->env->update_stats (); 197 op->env->update_stats ();
197 } 198 }
198 199
199 op->destroy (); 200 op->destroy ();
200} 201}
201 202
202void 203static void
203poison_more (object *op) 204poison_more (object *op)
204{ 205{
205 if (op->env == NULL || !QUERY_FLAG (op->env, FLAG_ALIVE) || op->env->stats.hp < 0) 206 if (op->env == NULL || !op->env->flag [FLAG_ALIVE] || op->env->stats.hp < 0)
206 { 207 {
207 op->destroy (); 208 op->destroy ();
208 return; 209 return;
209 } 210 }
210 211
… …
213 /* need to unapply the object before update_stats is called, else fix_player 214 /* need to unapply the object before update_stats is called, else fix_player
214 * will not do anything. 215 * will not do anything.
215 */ 216 */
216 if (op->env->type == PLAYER) 217 if (op->env->type == PLAYER)
217 { 218 {
218 CLEAR_FLAG (op, FLAG_APPLIED); 219 op->clr_flag (FLAG_APPLIED);
219 op->env->update_stats (); 220 op->env->update_stats ();
220 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now."); 221 new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now.");
221 } 222 }
222 223
223 op->destroy (); 224 op->destroy ();
… …
232 233
233 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1); 234 hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
234} 235}
235 236
236 237
237void 238static void
238move_gate (object *op) 239move_gate (object *op)
239{ /* 1 = going down, 0 = going up */ 240{ /* 1 = going down, 0 = going up */
240 object *tmp; 241 object *tmp;
241 242
242 if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op)) 243 if (uint32_t (op->stats.wc) >= op->anim_frames ())
243 { 244 {
244 LOG (llevError, "Gate error: animation was %d, max=%d\n", op->stats.wc, NUM_ANIMATIONS (op)); 245 LOG (llevError, "%s: gate error: animation was %d, max=%d\n", op->debug_desc (), op->stats.wc, op->anim_frames ());
245 op->stats.wc = 0; 246 op->stats.wc = 0;
246 } 247 }
247 248
248 /* We're going down */
249 if (op->value) 249 if (op->value)
250 { 250 {
251 /* We're going down */
251 if (--op->stats.wc <= 0) 252 if (--op->stats.wc <= 0)
252 { /* Reached bottom, let's stop */ 253 { /* Reached bottom, let's stop */
253 op->stats.wc = 0; 254 op->stats.wc = 0;
254 if (op->arch->speed) 255 if (op->arch->has_active_speed ())
255 op->value = 0; 256 op->value = 0;
256 else 257 else
257 op->set_speed (0); 258 op->set_speed (0);
258 } 259 }
259 260
260 if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1)) 261 if (op->stats.wc < op->anim_frames () / 2 + 1)
261 { 262 {
262 op->move_block = 0; 263 op->move_block = 0;
263 CLEAR_FLAG (op, FLAG_BLOCKSVIEW); 264 op->clr_flag (FLAG_BLOCKSVIEW);
264 update_all_los (op->map, op->x, op->y); 265 update_all_los (op->map, op->x, op->y);
265 } 266 }
266
267 SET_ANIMATION (op, op->stats.wc);
268 update_object (op, UP_OBJ_CHANGE);
269 return;
270 }
271
272 /* We're going up */
273
274 /* First, lets see if we are already at the top */
275 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
276 {
277
278 /* Check to make sure that only non pickable and non rollable
279 * objects are above the gate. If so, we finish closing the gate,
280 * otherwise, we fall through to the code below which should lower
281 * the gate slightly.
282 */
283
284 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))
286 break;
287
288 if (!tmp)
289 {
290 if (op->arch->speed)
291 op->value = 1;
292 else
293 op->set_speed (0);
294
295 return;
296 }
297 }
298
299 if (op->stats.food)
300 { /* The gate is going temporarily down */
301 if (--op->stats.wc <= 0)
302 { /* Gone all the way down? */
303 op->stats.food = 0; /* Then let's try again */
304 op->stats.wc = 0;
305 }
306 } 267 }
307 else 268 else
269 {
270 /* We're going up */
271
272 /* First, lets see if we are already at the top */
273 if (op->stats.wc == op->anim_frames () - 1)
274 {
275 /* Check to make sure that only non pickable and non rollable
276 * objects are above the gate. If so, we finish closing the gate,
277 * otherwise, we fall through to the code below which should lower
278 * the gate slightly.
279 */
280
281 for (tmp = op->above; tmp; tmp = tmp->above)
282 if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
283 break;
284
285 if (!tmp)
286 {
287 if (op->arch->has_active_speed ())
288 op->value = 1;
289 else
290 op->set_speed (0);
291
292 return;
293 }
294 }
295
296 if (op->stats.food)
297 { /* The gate is going temporarily down */
298 if (--op->stats.wc <= 0)
299 { /* Gone all the way down? */
300 op->stats.food = 0; /* Then let's try again */
301 op->stats.wc = 0;
302 }
303 }
304 else
308 { /* The gate is still going up */ 305 { /* The gate is still going up */
309 op->stats.wc++; 306 op->stats.wc++;
307 min_it (op->stats.wc, op->anim_frames () - 1);
310 308
311 if (op->stats.wc >= NUM_ANIMATIONS (op))
312 op->stats.wc = NUM_ANIMATIONS (op) - 1;
313
314 /* If there is something on top of the gate, we try to roll it off. 309 /* If there is something on top of the gate, we try to roll it off.
315 * If a player/monster, we don't roll, we just hit them with damage 310 * If a player/monster, we don't roll, we just hit them with damage
316 */ 311 */
317 if (op->stats.wc >= NUM_ANIMATIONS (op) / 2) 312 if (op->stats.wc >= op->anim_frames () / 2)
318 { 313 {
319 /* Halfway or further, check blocks */ 314 /* Halfway or further, check blocks */
320 /* First, get the top object on the square. */ 315 /* First, get the top object on the square. */
321 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above) 316 for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
322 ; 317 ;
323 318
324 if (tmp) 319 if (tmp)
325 {
326 if (QUERY_FLAG (tmp, FLAG_ALIVE))
327 { 320 {
328 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1); 321 if (tmp->flag [FLAG_ALIVE])
329 op->play_sound (sound_find ("blocked_gate"));
330
331 if (tmp->type == PLAYER)
332 new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);
333 }
334 /* If the object is not alive, and the object either can
335 * be picked up or the object rolls, move the object
336 * off the gate.
337 */
338 else if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL)))
339 {
340 /* 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);
342
343 /* If there is a free spot, move the object someplace */
344 if (i > 0)
345 { 322 {
323 hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1);
324 op->play_sound (sound_find ("blocked_gate"));
325
326 if (tmp->type == PLAYER)
327 new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);
328 }
329 /* If the object is not alive, and the object either can
330 * be picked up or the object rolls, move the object
331 * off the gate.
332 */
333 else if (!tmp->flag [FLAG_ALIVE] && (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL]))
334 {
335 /* If it has speed, it should move itself, otherwise: */
336 int i = find_free_spot (tmp, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1);
337
338 /* If there is a free spot, move the object someplace */
339 if (i > 0)
340 {
346 mapxy pos (tmp); 341 mapxy pos (tmp);
347 pos.move (i); 342 pos.move (i);
348 if (pos.normalise ()) 343 if (pos.normalise ())
349 tmp->move_to (pos); 344 tmp->move_to (pos);
345 }
350 } 346 }
351 } 347 }
352 }
353 348
354 /* See if there is still anything blocking the gate */ 349 /* See if there is still anything blocking the gate */
355 for (tmp = op->above; tmp; tmp = tmp->above) 350 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)) 351 if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
357 break; 352 break;
358 353
359 /* IF there is, start putting the gate down */ 354 /* IF there is, start putting the gate down */
360 if (tmp) 355 if (tmp)
361 op->stats.food = 1; 356 op->stats.food = 1;
362 else 357 else
363 { 358 {
364 op->move_block = MOVE_ALL; 359 op->move_block = MOVE_ALL;
365 360
366 if (!op->arch->stats.ac) 361 if (!op->arch->stats.ac)
367 SET_FLAG (op, FLAG_BLOCKSVIEW); 362 op->set_flag (FLAG_BLOCKSVIEW);
363
368 update_all_los (op->map, op->x, op->y); 364 update_all_los (op->map, op->x, op->y);
369 } 365 }
370 } /* gate is halfway up */ 366 } /* gate is halfway up */
371
372 SET_ANIMATION (op, op->stats.wc);
373 update_object (op, UP_OBJ_CHANGE);
374 } /* gate is going up */ 367 } /* gate is going up */
368 }
369
370 op->update_anim_frame (op->stats.wc);
375} 371}
376 372
377/* hp : how long door is open/closed 373/* hp : how long door is open/closed
378 * maxhp : initial value for hp 374 * maxhp : initial value for hp
379 * sp : 1 = open, 0 = close 375 * sp : 1 = open, 0 = close
380 */ 376 */
381void 377static void
382move_timed_gate (object *op) 378move_timed_gate (object *op)
383{ 379{
384 int v = op->value; 380 int v = op->value;
385 381
386 if (op->stats.sp) 382 if (op->stats.sp)
… …
405 * speed: frequency of 'glances' 401 * speed: frequency of 'glances'
406 * connected: connected value of detector 402 * connected: connected value of detector
407 * sp: 1 if detection sets buttons 403 * sp: 1 if detection sets buttons
408 * -1 if detection unsets buttons 404 * -1 if detection unsets buttons
409 */ 405 */
410 406static void
411void
412move_detector (object *op) 407move_detector (object *op)
413{ 408{
414 object *tmp; 409 object *tmp;
415 int last = op->value; 410 int last = op->value;
416 int detected; 411 int detected;
… …
471} 466}
472 467
473void 468void
474animate_trigger (object *op) 469animate_trigger (object *op)
475{ 470{
476 if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op)) 471 if (uint32_t (++op->stats.wc) >= op->anim_frames ())
477 { 472 {
478 op->stats.wc = 0; 473 op->stats.wc = 0;
479 check_trigger (op, NULL); 474 check_trigger (op, NULL);
480 } 475 }
481 else 476 else
482 { 477 op->update_anim_frame (op->stats.wc);
483 SET_ANIMATION (op, op->stats.wc);
484 update_object (op, UP_OBJ_FACE);
485 }
486} 478}
487 479
488void 480static void
489move_hole (object *op) 481move_hole (object *op)
490{ /* 1 = opening, 0 = closing */ 482{ /* 1 = opening, 0 = closing */
491 if (op->value) 483 if (op->value)
492 { /* We're opening */ 484 {
485 /* We're opening */
486 op->stats.wc--;
493 if (--op->stats.wc <= 0) 487 if (op->stats.wc <= 0)
494 { /* Opened, let's stop */ 488 { /* Opened, let's stop */
495 op->stats.wc = 0; 489 op->stats.wc = 0;
496 op->set_speed (0); 490 op->set_speed (0);
497 491
498 /* Hard coding this makes sense for holes I suppose */ 492 /* Hard coding this makes sense for holes I suppose */
… …
501 { 495 {
502 next = tmp->above; 496 next = tmp->above;
503 move_apply (op, tmp, tmp); 497 move_apply (op, tmp, tmp);
504 } 498 }
505 } 499 }
506 500 }
507 SET_ANIMATION (op, op->stats.wc); 501 else
508 update_object (op, UP_OBJ_FACE);
509 return;
510 } 502 {
511
512 /* We're closing */ 503 /* We're closing */
513 op->move_on = 0; 504 op->move_on = 0;
514 505
515 op->stats.wc++; 506 op->stats.wc++;
516 if ((int) op->stats.wc >= NUM_ANIMATIONS (op)) 507 if (op->stats.wc >= op->anim_frames ())
517 op->stats.wc = NUM_ANIMATIONS (op) - 1; 508 {
518 509 op->stats.wc = op->anim_frames () - 1;
519 SET_ANIMATION (op, op->stats.wc);
520 update_object (op, UP_OBJ_FACE);
521 if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
522 op->set_speed (0); /* closed, let's stop */ 510 op->set_speed (0); /* closed, let's stop */
511 }
512 }
513
514 op->update_anim_frame (op->stats.wc);
523} 515}
524 516
525 517
526/* stop_item() returns a pointer to the stopped object. The stopped object 518/* stop_item() returns a pointer to the stopped object. The stopped object
527 * may or may not have been removed from maps or inventories. It will not 519 * may or may not have been removed from maps or inventories. It will not
… …
574fix_stopped_item (object *op, maptile *map, object *originator) 566fix_stopped_item (object *op, maptile *map, object *originator)
575{ 567{
576 if (map == NULL) 568 if (map == NULL)
577 return; 569 return;
578 570
579 if (QUERY_FLAG (op, FLAG_REMOVED)) 571 if (op->flag [FLAG_REMOVED])
580 insert_ob_in_map (op, map, originator, 0); 572 insert_ob_in_map (op, map, originator, 0);
581 else if (op->type == ARROW) 573 else if (op->type == ARROW)
582 merge_ob (op, NULL); /* only some arrows actually need this */ 574 merge_ob (op, NULL); /* only some arrows actually need this */
583} 575}
584 576
… …
610 op->stats.hp = 0; 602 op->stats.hp = 0;
611 op->stats.grace = 0; 603 op->stats.grace = 0;
612 op->level = 0; 604 op->level = 0;
613 op->face = op->arch->face; 605 op->face = op->arch->face;
614 op->owner = 0; 606 op->owner = 0;
607
608 op->clr_flag (FLAG_NO_PICK); /* fire_bow makes arrows NO_PICK so monsters (or anything else) don't pick them mid-flight */
615 609
616 update_object (op, UP_OBJ_CHANGE); 610 update_object (op, UP_OBJ_CHANGE);
617 611
618 return op; 612 return op;
619} 613}
… …
647 if (op) 641 if (op)
648 merge_ob (op, 0); 642 merge_ob (op, 0);
649 } 643 }
650} 644}
651 645
652/* Move an arrow along its course. op is the arrow or thrown object. 646/* Move an arrow or throwen_obj along its course. op is the arrow or thrown object.
653 */ 647 */
654void 648void
655move_arrow (object *op) 649move_arrow (object *op)
656{ 650{
657 int was_reflected; 651 int was_reflected;
658 652
659 if (!op->map) 653 if (!op->map)
660 { 654 {
661 LOG (llevError, "BUG: Arrow had no map.\n"); 655 LOG (llevError | logBacktrace, "BUG: Arrow %s had no map.\n", op->debug_desc ());
662 op->destroy (); 656 op->destroy ();
663 return; 657 return;
664 } 658 }
665 659
666 /* we need to stop thrown objects at some point. Like here. */ 660 /* we need to stop thrown objects at some point. Like here. */
… …
685 stop_arrow (op); 679 stop_arrow (op);
686 return; 680 return;
687 } 681 }
688 } 682 }
689 683
684 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
685 * about 17 squares. Tune as needed.
686 */
687 op->set_speed (op->speed - 0.05);
688
690 /* if the arrow is moving too slow.. stop it. 0.5 was chosen as lower 689 /* if the arrow is moving too slow.. stop it. 0.5 was chosen as lower
691 values look rediculous. */ 690 values look ridiculous. */
692 if (op->speed < 0.5 && op->type == ARROW) 691 if (op->speed < (op->type == ARROW ? 0.5 : MIN_ACTIVE_SPEED))
693 { 692 {
694 stop_arrow (op); 693 stop_arrow (op);
695 return; 694 return;
696 } 695 }
697 696
… …
710 if (pos->flags () & P_IS_ALIVE) 709 if (pos->flags () & P_IS_ALIVE)
711 { 710 {
712 object *tmp; 711 object *tmp;
713 712
714 for (tmp = pos->bot; tmp; tmp = tmp->above) 713 for (tmp = pos->bot; tmp; tmp = tmp->above)
715 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 714 if (tmp->flag [FLAG_ALIVE] && tmp != op->owner)
716 break; 715 {
717
718 /* Not really fair, but don't let monsters hit themselves with 716 /* Not really fair, but don't let monsters hit themselves with
719 * their own arrow - this can be because they fire it then 717 * their own arrow - this can be because they fire it then
720 * move into it. 718 * move into it.
721 */ 719 */
722 if (tmp && tmp != op->owner) 720
723 {
724 /* Found living object, but it is reflecting the missile. Update 721 /* Found living object, but it is reflecting the missile. Update
725 * as below. (Note that for living creatures there is a small 722 * as below. (Note that for living creatures there is a small
726 * chance that reflect_missile fails.) 723 * chance that reflect_missile fails.)
727 */ 724 */
728 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE) && (rndm (0, 99)) < (90 - op->level / 10)) 725 if (tmp->flag [FLAG_REFL_MISSILE] && (rndm (0, 99)) < (90 - op->level / 10))
729 { 726 {
730 int number = op->face;
731
732 op->direction = absdir (op->direction + 4); 727 op->direction = absdir (op->direction + 4);
733 update_turn_face (op); 728 update_turn_face (op);
734 was_reflected = 1; /* skip normal movement calculations */ 729 was_reflected = 1; /* skip normal movement calculations */
735 } 730 }
736 else 731 else
737 { 732 {
738 /* Attack the object. */ 733 /* Attack the object. */
739 op = hit_with_arrow (op, tmp); 734 op = hit_with_arrow (op, tmp);
740 735
741 if (!op) 736 if (!op)
742 return; 737 return;
743 } 738 }
744 } /* if this is not hitting its owner */ 739
745 } /* if there is something alive on this space */ 740 break;
741 }
742 }
746 743
747 if (OB_TYPE_MOVE_BLOCK (op, pos->move_block)) 744 if (OB_TYPE_MOVE_BLOCK (op, pos->move_block))
748 { 745 {
749 int retry = 0; 746 int retry = 0;
750 747
… …
752 * note that this code will now catch cases where a monster is 749 * note that this code will now catch cases where a monster is
753 * on a wall but has reflecting - the arrow won't reflect. 750 * on a wall but has reflecting - the arrow won't reflect.
754 * Mapmakers shouldn't put monsters on top of wall in the first 751 * Mapmakers shouldn't put monsters on top of wall in the first
755 * place, so I don't consider that a problem. 752 * place, so I don't consider that a problem.
756 */ 753 */
757 if (!QUERY_FLAG (op, FLAG_REFLECTING) || !(rndm (0, 19))) 754 if (!op->flag [FLAG_REFLECTING] || !rndm (0, 19))
758 { 755 {
759 stop_arrow (op); 756 stop_arrow (op);
760 return; 757 return;
761 } 758 }
762 else 759 else
… …
816 if (op->has_anim ()) 813 if (op->has_anim ())
817 op->set_anim_frame (op->direction); 814 op->set_anim_frame (op->direction);
818 } /* object is reflected */ 815 } /* object is reflected */
819 } /* object ran into a wall */ 816 } /* object ran into a wall */
820 817
821 /* decrease the speed as it flies. 0.05 means a standard bow will shoot
822 * about 17 squares. Tune as needed.
823 */
824 op->speed -= 0.05;
825
826 /* Move the arrow. */ 818 /* Move the arrow. */
827 op->move_to (pos); 819 op->move_to (pos);
828} 820}
829 821
830static void 822static void
831change_object (object *op) 823change_object (object *op)
832{ /* Doesn`t handle linked objs yet */ 824{ /* Doesn`t handle linked objs yet */
833 int i, j;
834
835 if (!op->other_arch) 825 if (!op->other_arch)
836 { 826 {
837 LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ()); 827 LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ());
838 return; 828 return;
839 } 829 }
840 830
841 /* In non-living items only change when food value is 0 */ 831 /* In non-living items only change when food value is 0 */
842 if (!QUERY_FLAG (op, FLAG_ALIVE)) 832 if (!op->flag [FLAG_ALIVE])
843 { 833 {
844 if (op->stats.food-- > 0) 834 if (op->stats.food-- > 0)
845 return; 835 return;
846 836
847 op->stats.food = 1; /* so 1 other_arch is made */ 837 op->stats.food = 1; /* so 1 other_arch is made */
848 } 838 }
849 839
850 object *env = op->env; 840 object *env = op->env;
851 841
852 op->remove (); 842 op->remove ();
853 for (i = 0; i < op->stats.food; i++) 843 for (int i = 0; i < op->stats.food; i++)
854 { 844 {
855 object *tmp = arch_to_object (op->other_arch); 845 object *tmp = op->other_arch->instance ();
856 846
857 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */ 847 tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
858 848
859 if (env) 849 if (env)
860 env->insert (tmp); 850 env->insert (tmp);
861 else 851 else
862 { 852 {
863 j = find_first_free_spot (tmp, op->map, op->x, op->y); 853 int j = find_first_free_spot (tmp, op->map, op->x, op->y);
854
864 if (j < 0) /* No free spot */ 855 if (j < 0) /* No free spot */
865 tmp->destroy (); 856 tmp->destroy ();
866 else 857 else
867 { 858 {
868 mapxy pos (op); pos.move (j); 859 mapxy pos (op); pos.move (j);
… …
893 884
894 if (op->head) 885 if (op->head)
895 head = op->head; 886 head = op->head;
896 887
897 for (tmp = op->above; tmp; tmp = tmp->above) 888 for (tmp = op->above; tmp; tmp = tmp->above)
898 if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 889 if (!tmp->flag [FLAG_IS_FLOOR])
899 break; 890 break;
900 891
901 /* If nothing above us to move, nothing to do */ 892 /* If nothing above us to move, nothing to do */
902 if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS)) 893 if (!tmp || tmp->flag [FLAG_WIZPASS])
903 return; 894 return;
904 895
905 if (EXIT_PATH (head)) 896 if (EXIT_PATH (head))
906 { 897 {
907 if (tmp->type == PLAYER) 898 if (tmp->type == PLAYER)
… …
942/* This object will teleport someone to a different map 933/* This object will teleport someone to a different map
943 and will also apply changes to the player from its inventory. 934 and will also apply changes to the player from its inventory.
944 This was invented for giving classes, but there's no reason it 935 This was invented for giving classes, but there's no reason it
945 can't be generalized. 936 can't be generalized.
946*/ 937*/
947void 938static void
948move_player_changer (object *op) 939move_player_changer (object *op)
949{ 940{
950 object *player;
951 object *walk;
952
953 if (!op->above || !EXIT_PATH (op)) 941 if (!op->above || !EXIT_PATH (op))
954 return; 942 return;
955 943
956 /* This isn't all that great - means that the player_mover 944 /* This isn't all that great - means that the player_mover
957 * needs to be on top. 945 * needs to be on top.
958 */ 946 */
959 if (op->above->type == PLAYER) 947 if (op->above->type == PLAYER)
960 { 948 {
949 object *player = op->above;
950
961 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player))) 951 if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
962 return; 952 return;
963 953
964 player = op->above;
965
966 for (walk = op->inv; walk; walk = walk->below) 954 for (object *walk = op->inv; walk; walk = walk->below)
967 apply_changes_to_player (player, walk); 955 apply_changes_to_player (player, walk);
968 956
969 player->update_stats (); 957 player->update_stats ();
970 958
971 esrv_send_inventory (op->above, op->above); 959 esrv_send_inventory (op->above, op->above);
… …
1009 } 997 }
1010 998
1011 cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL); 999 cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL);
1012} 1000}
1013 1001
1014/* move_player_mover: this function takes a "player mover" as an 1002/* move_player_mover: this function takes a "player mover" as an
1015 * argument, and performs the function of a player mover, which is: 1003 * argument, and performs the function of a player mover, which is:
1016 * 1004 *
1017 * a player mover finds any players that are sitting on it. It 1005 * a player mover finds any players that are sitting on it. It
1018 * moves them in the op->stats.sp direction. speed is how often it'll move. 1006 * moves them in the op->stats.sp direction. speed is how often it'll move.
1019 * If attacktype is nonzero it will paralyze the player. If lifesave is set, 1007 * If attacktype is nonzero it will paralyze the player. If lifesave is set,
1020 * it'll dissapear after hp+1 moves. If hp is set and attacktype is set, 1008 * it'll dissapear after hp+1 moves. If hp is set and attacktype is set,
1021 * it'll paralyze the victim for hp*his speed/op->speed 1009 * it'll paralyze the victim for hp*his speed/op->speed
1022 */ 1010 */
1023void 1011static void
1024move_player_mover (object *op) 1012move_player_mover (object *op)
1025{ 1013{
1026 int dir = op->stats.sp; 1014 int dir = 0;
1027 sint16 nx, ny;
1028 maptile *m;
1029
1030 /* Determine direction now for random movers so we do the right thing */
1031 if (!dir)
1032 dir = rndm (1, 8);
1033 1015
1034 for (object *victim = op->ms ().bot; victim; victim = victim->above) 1016 for (object *victim = op->ms ().bot; victim; victim = victim->above)
1035 { 1017 {
1036 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) && 1018 if (victim->flag [FLAG_ALIVE]
1019 && !victim->flag [FLAG_WIZPASS]
1037 (victim->move_type & op->move_type || !victim->move_type)) 1020 && (victim->move_type & op->move_type || !victim->move_type))
1021 {
1022 if (op->flag [FLAG_LIFESAVE] && op->stats.hp-- < 0)
1038 { 1023 {
1024 op->destroy ();
1025 return;
1026 }
1027
1028 /* Determine direction only once so we do the right thing */
1029 // why is it the right thing, though?
1030 if (!dir)
1031 dir = op->stats.sp ? op->stats.sp : rndm (1, 8);
1032
1033 sint16 nx = op->x + DIRX (dir);
1034 sint16 ny = op->y + DIRY (dir);
1035 maptile *m = op->map;
1036 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1037 {
1038 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
1039 return;
1040 }
1039 1041
1040 if (victim->head) 1042 if (victim->head)
1041 victim = victim->head; 1043 victim = victim->head;
1042 1044
1043 if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0)
1044 {
1045 op->remove ();
1046 return;
1047 }
1048
1049 nx = op->x + freearr_x[dir];
1050 ny = op->y + freearr_y[dir];
1051 m = op->map;
1052 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1053 {
1054 LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
1055 return;
1056 }
1057
1058 if (should_director_abort (op, victim)) 1045 if (should_director_abort (op, victim))
1059 return; 1046 return;
1060 1047
1061 for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above) 1048 for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above)
1062 { 1049 {
1063 if (nextmover->type == PLAYERMOVER) 1050 if (nextmover->type == PLAYERMOVER)
1064 nextmover->speed_left = -.99f; 1051 nextmover->speed_left = -.99f;
1065 1052
1066 if (QUERY_FLAG (nextmover, FLAG_ALIVE)) 1053 if (nextmover->flag [FLAG_ALIVE])
1067 op->speed_left = -1.1f; /* wait until the next thing gets out of the way */ 1054 op->speed_left = -1.1f; /* wait until the next thing gets out of the way */
1068 } 1055 }
1069 1056
1070 if (victim->type == PLAYER) 1057 if (victim->type == PLAYER)
1071 { 1058 {
… …
1083 } 1070 }
1084 else 1071 else
1085 return; 1072 return;
1086 } 1073 }
1087 else 1074 else
1088 move_object (victim, dir); 1075 victim->move (dir);
1089 1076
1090 if (!op->stats.maxsp && op->attacktype) 1077 if (!op->stats.maxsp && op->attacktype)
1091 op->stats.maxsp = 2; 1078 op->stats.maxsp = 2;
1092 1079
1093 if (op->attacktype) 1080 if (op->attacktype)
1094 { /* flag to paralyze the player */ 1081 { /* flag to paralyze the player */
1095 victim->speed_left = max (-5.f, -FABS (op->stats.maxsp * victim->speed / op->speed)); 1082 victim->speed_left = max (-5.f, -op->stats.maxsp * victim->speed / op->speed);
1096 } 1083 }
1097 } 1084 }
1098 } 1085 }
1099} 1086}
1100 1087
… …
1138 break; 1125 break;
1139 } 1126 }
1140 } 1127 }
1141} 1128}
1142 1129
1143/* move_creator (by peterm) 1130/* move_creator (by peterm)
1144 * it has the creator object create it's other_arch right on top of it. 1131 * it has the creator object create it's other_arch right on top of it.
1145 * connected: what will trigger it 1132 * connected: what will trigger it
1146 * hp: how many times it may create before stopping 1133 * hp: how many times it may create before stopping
1147 * lifesave: if set, it'll never disappear but will go on creating 1134 * lifesave: if set, it'll never disappear but will go on creating
1148 * everytime it's triggered 1135 * everytime it's triggered
… …
1156void 1143void
1157move_creator (object *creator) 1144move_creator (object *creator)
1158{ 1145{
1159 object *new_ob; 1146 object *new_ob;
1160 1147
1161 if (!QUERY_FLAG (creator, FLAG_LIFESAVE) && --creator->stats.hp < 0) 1148 if (!creator->flag [FLAG_LIFESAVE] && --creator->stats.hp < 0)
1162 { 1149 {
1163 creator->stats.hp = -1; 1150 creator->stats.hp = -1;
1164 return; 1151 return;
1165 } 1152 }
1166 1153
… …
1170 int i; 1157 int i;
1171 object *ob_to_copy; 1158 object *ob_to_copy;
1172 1159
1173 /* select random object from inventory to copy */ 1160 /* select random object from inventory to copy */
1174 ob_to_copy = creator->inv; 1161 ob_to_copy = creator->inv;
1175 for (ob = creator->inv->below, i = 1; ob != NULL; ob = ob->below, i++) 1162 for (ob = creator->inv->below, i = 1; ob; ob = ob->below, i++)
1176 { 1163 {
1177 if (rndm (0, i) == 0) 1164 if (rndm (0, i) == 0)
1178 { 1165 {
1179 ob_to_copy = ob; 1166 ob_to_copy = ob;
1180 } 1167 }
1181 } 1168 }
1169
1182 new_ob = ob_to_copy->deep_clone (); 1170 new_ob = ob_to_copy->deep_clone ();
1183 CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE); 1171 new_ob->clr_flag (FLAG_IS_A_TEMPLATE);
1184 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE); 1172 unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1185 } 1173 }
1186 else 1174 else
1187 { 1175 {
1188 if (!creator->other_arch) 1176 if (!creator->other_arch)
… …
1203 return; 1191 return;
1204 } 1192 }
1205 1193
1206 // for now lets try to identify everything generated here, it mostly 1194 // for now lets try to identify everything generated here, it mostly
1207 // happens automated, so this will at least fix many identify-experience holes 1195 // happens automated, so this will at least fix many identify-experience holes
1208 SET_FLAG (new_ob, FLAG_IDENTIFIED); 1196 if (new_ob->need_identify ())
1197 new_ob->set_flag (FLAG_IDENTIFIED);
1209 1198
1210 insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y); 1199 insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);
1211 if (QUERY_FLAG (new_ob, FLAG_FREED)) 1200 if (new_ob->flag [FLAG_FREED])
1212 return; 1201 return;
1213 1202
1214 if (creator->slaying) 1203 if (creator->slaying)
1215 new_ob->name = new_ob->title = creator->slaying; 1204 new_ob->name = new_ob->title = creator->slaying;
1216} 1205}
… …
1254 } 1243 }
1255} 1244}
1256 1245
1257// mapscript objects activate themselves (only) then their timer fires 1246// mapscript objects activate themselves (only) then their timer fires
1258// TODO: maybe they should simply trigger the link like any other object? 1247// TODO: maybe they should simply trigger the link like any other object?
1259void 1248static void
1260move_mapscript (object *op) 1249move_mapscript (object *op)
1261{ 1250{
1262 op->set_speed (0); 1251 op->set_speed (0);
1263 cfperl_mapscript_activate (op, true, op, 0); 1252 cfperl_mapscript_activate (op, true, op, 0);
1264} 1253}
1265 1254
1255static void
1266void move_lamp (object *op) 1256move_lamp (object *op)
1267{ 1257{
1268 // if the lamp/torch is off, we should disable it. 1258 // if the lamp/torch is off, we should disable it.
1269 if (!op->glow_radius) 1259 if (!op->glow_radius)
1270 { 1260 {
1271 op->set_speed (0); 1261 op->set_speed (0);
… …
1300} 1290}
1301 1291
1302void 1292void
1303process_object (object *op) 1293process_object (object *op)
1304{ 1294{
1305 if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))) 1295 if (ecb_expect_false (op->flag [FLAG_IS_A_TEMPLATE]))
1306 return; 1296 return;
1307 1297
1308 if (expect_false (INVOKE_OBJECT (TICK, op))) 1298 if (ecb_expect_false (INVOKE_OBJECT (TICK, op)))
1309 return; 1299 return;
1310 1300
1311 if (QUERY_FLAG (op, FLAG_MONSTER)) 1301 if (op->flag [FLAG_MONSTER])
1312 if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED)) 1302 if (move_monster (op) || op->flag [FLAG_FREED])
1313 return; 1303 return;
1314 1304
1315 if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0) 1305 if (op->flag [FLAG_ANIMATE] && op->anim_speed == 0)
1316 { 1306 {
1317 animate_object (op, op->contr ? op->facing : op->direction); 1307 animate_object (op, op->contr ? op->facing : op->direction);
1318 1308
1319 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1309 if (op->flag [FLAG_SEE_ANYWHERE])
1320 make_sure_seen (op); 1310 make_sure_seen (op);
1321 } 1311 }
1322 1312
1323 if (expect_false ( 1313 if (ecb_expect_false (
1324 op->flag [FLAG_GENERATOR] 1314 op->flag [FLAG_GENERATOR]
1325 || op->flag [FLAG_CHANGING] 1315 || op->flag [FLAG_CHANGING]
1326 || op->flag [FLAG_IS_USED_UP] 1316 || op->flag [FLAG_IS_USED_UP]
1327 )) 1317 ))
1328 { 1318 {
1329 if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state) 1319 if (op->flag [FLAG_CHANGING] && !op->state)
1330 { 1320 {
1331 change_object (op); 1321 change_object (op);
1332 return; 1322 return;
1333 } 1323 }
1334 1324
1335 if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY)) 1325 if (op->flag [FLAG_GENERATOR] && !op->flag [FLAG_FRIENDLY])
1336 generate_monster (op); 1326 generate_monster (op);
1337 1327
1338 if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0) 1328 if (op->flag [FLAG_IS_USED_UP] && --op->stats.food <= 0)
1339 { 1329 {
1340 if (QUERY_FLAG (op, FLAG_APPLIED)) 1330 if (op->flag [FLAG_APPLIED])
1341 remove_force (op); 1331 remove_force (op);
1342 else 1332 else
1343 { 1333 {
1344 op->remove (); // TODO: really necessary? 1334 op->remove (); // TODO: really necessary?
1345 1335
1346 if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE)) 1336 if (op->flag [FLAG_SEE_ANYWHERE])
1347 make_sure_not_seen (op); 1337 make_sure_not_seen (op);
1348 1338
1349 op->drop_and_destroy (); 1339 op->drop_and_destroy ();
1350 } 1340 }
1351 1341
… …
1487 1477
1488 case LAMP: 1478 case LAMP:
1489 case TORCH: 1479 case TORCH:
1490 move_lamp (op); 1480 move_lamp (op);
1491 break; 1481 break;
1492 }
1493}
1494 1482
1483 case PHYSICS: // hmm, bad naming
1484 move_physics (op);
1485 break;
1486 }
1487}
1488

Diff Legend

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